src/libpakfire/build.c

   1 /*#############################################################################
   2 #                                                                             #
   3 # Pakfire - The IPFire package management system                              #
   4 # Copyright (C) 2021 Pakfire development team                                 #
   5 #                                                                             #
   6 # This program is free software: you can redistribute it and/or modify        #
   7 # it under the terms of the GNU General Public License as published by        #
   8 # the Free Software Foundation, either version 3 of the License, or           #
   9 # (at your option) any later version.                                         #
  10 #                                                                             #
  11 # This program is distributed in the hope that it will be useful,             #
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  14 # GNU General Public License for more details.                                #
  15 #                                                                             #
  16 # You should have received a copy of the GNU General Public License           #
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  18 #                                                                             #
  19 #############################################################################*/
  20
  21 #include <errno.h>
  22 #include <stdlib.h>
  23 #include <sys/mount.h>
  24 #include <time.h>
  25 #include <unistd.h>
  26 #include <uuid/uuid.h>
  27
  28 #define PCRE2_CODE_UNIT_WIDTH 8
  29 #include <pcre2.h>
  30
  31 #include <pakfire/build.h>
  32 #include <pakfire/cgroup.h>
  33 #include <pakfire/dependencies.h>
  34 #include <pakfire/dist.h>
  35 #include <pakfire/file.h>
  36 #include <pakfire/i18n.h>
  37 #include <pakfire/jail.h>
  38 #include <pakfire/logging.h>
  39 #include <pakfire/mount.h>
  40 #include <pakfire/package.h>
  41 #include <pakfire/packager.h>
  42 #include <pakfire/parser.h>
  43 #include <pakfire/private.h>
  44 #include <pakfire/problem.h>
  45 #include <pakfire/repo.h>
  46 #include <pakfire/request.h>
  47 #include <pakfire/scriptlet.h>
  48 #include <pakfire/snapshot.h>
  49 #include <pakfire/solution.h>
  50 #include <pakfire/string.h>
  51 #include <pakfire/util.h>
  52
  53 #define CCACHE_DIR "/var/cache/ccache"
  54
  55 // We guarantee 2 GiB of memory to every build container
  56 #define PAKFIRE_BUILD_MEMORY_GUARANTEED         (size_t)2 * 1024 * 1024 * 1024
  57
  58 // We allow only up to 2048 processes/threads for every build container
  59 #define PAKFIRE_BUILD_PID_LIMIT                         (size_t)2048
  60
  61 struct pakfire_build {
  62         struct pakfire* pakfire;
  63         int nrefs;
  64
  65         // Flags
  66         int flags;
  67
  68         // Build ID
  69         uuid_t id;
  70         char _id[UUID_STR_LEN];
  71
  72         char target[PATH_MAX];
  73
  74         // Times
  75         time_t time_start;
  76
  77         // cgroup
  78         struct pakfire_cgroup* cgroup;
  79
  80         // Jail
  81         struct pakfire_jail* jail;
  82
  83         // The build repository
  84         struct pakfire_repo* repo;
  85
  86         // A list of all built packages
  87         struct pakfire_packagelist* packages;
  88
  89         // Buildroot
  90         char buildroot[PATH_MAX];
  91
  92         // States
  93         int init:1;
  94 };
  95
  96 #define TEMPLATE \
  97         "#!/bin/bash --login\n" \
  98         "\n" \
  99         "set -e\n" \
 100         "set -x\n" \
 101         "\n" \
 102         "%%{_%s}\n" \
 103         "\n" \
 104         "exit 0\n"
 105
 106 static int pakfire_build_has_flag(struct pakfire_build* build, int flag) {
 107         return build->flags & flag;
 108 }
 109
 110 static time_t pakfire_build_duration(struct pakfire_build* build) {
 111         // What time is it now?
 112         time_t now = time(NULL);
 113
 114         // Return any errors
 115         if (now < 0)
 116                 return now;
 117
 118         return now - build->time_start;
 119 }
 120
 121 static int __pakfire_build_setup_repo(struct pakfire* pakfire,
 122                 struct pakfire_repo* repo, void* p) {
 123         char path[PATH_MAX];
 124         FILE* f = NULL;
 125         int r;
 126
 127         struct pakfire_build* build = (struct pakfire_build*)p;
 128
 129         // Skip processing the installed repository
 130         if (pakfire_repo_is_installed_repo(repo))
 131                 return 0;
 132
 133         // Skip processing any other internal repositories
 134         if (pakfire_repo_is_internal(repo))
 135                 return 0;
 136
 137         const char* name = pakfire_repo_get_name(repo);
 138
 139         DEBUG(pakfire, "Exporting repository configuration for '%s'\n", name);
 140
 141         // Make path for configuration file
 142         r = pakfire_path(build->pakfire, path, PAKFIRE_CONFIG_DIR "/repos/%s.repo", name);
 143         if (r) {
 144                 ERROR(pakfire, "Could not make repository configuration path for %s: %m\n", name);
 145                 goto ERROR;
 146         }
 147
 148         // Create the parent directory
 149         r = pakfire_mkparentdir(path, 0755);
 150         if (r)
 151                 goto ERROR;
 152
 153         // Open the repository configuration
 154         f = fopen(path, "w");
 155         if (!f) {
 156                 ERROR(pakfire, "Could not open %s for writing: %m\n", path);
 157                 goto ERROR;
 158         }
 159
 160         // Write repository configuration
 161         r = pakfire_repo_write_config(repo, f);
 162         if (r) {
 163                 ERROR(pakfire, "Could not write repository configuration for %s: %m\n", name);
 164                 goto ERROR;
 165         }
 166
 167         // Bind-mount any local repositories
 168         if (pakfire_repo_is_local(repo)) {
 169                 const char* _path = pakfire_repo_get_path(repo);
 170
 171                 // Bind-mount the repository data read-only
 172                 r = pakfire_jail_bind(build->jail, _path, _path, MS_RDONLY);
 173                 if (r) {
 174                         ERROR(pakfire, "Could not bind-mount the repository at %s: %m\n", _path);
 175                         goto ERROR;
 176                 }
 177         }
 178
 179 ERROR:
 180         if (f)
 181                 fclose(f);
 182
 183         return r;
 184 }
 185
 186 /*
 187         This function enables the local repository so that it can be accessed by
 188         a pakfire instance running inside the chroot.
 189 */
 190 static int pakfire_build_enable_repos(struct pakfire_build* build) {
 191         return pakfire_repo_walk(build->pakfire, __pakfire_build_setup_repo, build);
 192 }
 193
 194 /*
 195         Drops the user into a shell
 196 */
 197 static int pakfire_build_shell(struct pakfire_build* build) {
 198         int r;
 199
 200         // Export local repository if running in interactive mode
 201         r = pakfire_build_enable_repos(build);
 202         if (r)
 203                 return r;
 204
 205         // Run shell
 206         return pakfire_jail_shell(build->jail);
 207 }
 208
 209 static int pakfire_build_read_script(struct pakfire_build* build,
 210                 const char* filename, char** buffer, size_t* length) {
 211         char path[PATH_MAX];
 212         FILE* f = NULL;
 213         int r;
 214
 215         // Compose the source path
 216         r = pakfire_path_join(path, PAKFIRE_SCRIPTS_DIR, filename);
 217         if (r) {
 218                 ERROR(build->pakfire, "Could not compose path for script '%s': %m\n", filename);
 219                 goto ERROR;
 220         }
 221
 222         DEBUG(build->pakfire, "Reading script from %s...\n", path);
 223
 224         // Open the file
 225         f = fopen(path, "r");
 226         if (!f) {
 227                 ERROR(build->pakfire, "Could not open script %s: %m\n", path);
 228                 goto ERROR;
 229         }
 230
 231         // Read the file into a the buffer
 232         r = pakfire_read_file_into_buffer(f, buffer, length);
 233         if (r) {
 234                 ERROR(build->pakfire, "Could not read script: %m\n");
 235                 goto ERROR;
 236         }
 237
 238 ERROR:
 239         if (f)
 240                 fclose(f);
 241
 242         return r;
 243 }
 244
 245 static int pakfire_build_run_script(
 246                 struct pakfire_build* build,
 247                 const char* filename,
 248                 const char* args[],
 249                 pakfire_jail_communicate_in communicate_in,
 250                 pakfire_jail_communicate_out communicate_out,
 251                 void* data) {
 252         int r;
 253
 254         char* script = NULL;
 255         size_t length = 0;
 256
 257         DEBUG(build->pakfire, "Running build script '%s'...\n", filename);
 258
 259         // Read the script
 260         r = pakfire_build_read_script(build, filename, &script, &length);
 261         if (r) {
 262                 ERROR(build->pakfire, "Could not read script %s: %m\n", filename);
 263                 return r;
 264         }
 265
 266         // Execute the script
 267         r = pakfire_jail_exec_script(build->jail, script, length, args,
 268                         communicate_in, communicate_out, data);
 269         if (r) {
 270                 ERROR(build->pakfire, "Script '%s' failed with status %d\n", filename, r);
 271         }
 272
 273         if (script)
 274                 free(script);
 275
 276         return r;
 277 }
 278
 279 struct pakfire_find_deps_ctx {
 280         struct pakfire_package* pkg;
 281         int dep;
 282         struct pakfire_scriptlet* scriptlet;
 283         int class;
 284         const pcre2_code* filter;
 285
 286         struct pakfire_filelist* filelist;
 287         unsigned int i;
 288 };
 289
 290 static int pakfire_build_make_filter(struct pakfire_build* build, pcre2_code** regex,
 291                 struct pakfire_parser* makefile, const char* namespace, const char* filter) {
 292         char* pattern = NULL;
 293         int r = 0;
 294
 295         // Fetch the pattern
 296         pattern = pakfire_parser_get(makefile, namespace, filter);
 297
 298         // Nothing if to if there is no or an empty pattern
 299         if (!pattern || !*pattern)
 300                 goto ERROR;
 301
 302         DEBUG(build->pakfire, "Found filter for %s: %s\n", filter, pattern);
 303
 304         // Compile the regular expression
 305         r = pakfire_compile_regex(build->pakfire, regex, pattern);
 306         if (r)
 307                 goto ERROR;
 308
 309 ERROR:
 310         if (pattern)
 311                 free(pattern);
 312
 313         return r;
 314 }
 315
 316 static int pakfire_build_send_filelist(struct pakfire* pakfire, void* data, int fd) {
 317         struct pakfire_find_deps_ctx* ctx = (struct pakfire_find_deps_ctx*)data;
 318         struct pakfire_file* file = NULL;
 319         int r = 0;
 320
 321         const size_t length = pakfire_filelist_length(ctx->filelist);
 322
 323         // Check if we have reached the end of the filelist
 324         if (ctx->i >= length)
 325                 return EOF;
 326
 327         // Fetch the next file
 328         file = pakfire_filelist_get(ctx->filelist, ctx->i);
 329         if (!file) {
 330                 DEBUG(pakfire, "Could not fetch file %d: %m\n", ctx->i);
 331                 r = 1;
 332                 goto ERROR;
 333         }
 334
 335         // Fetch the path of the file
 336         const char* path = pakfire_file_get_path(file);
 337         if (!path) {
 338                 ERROR(pakfire, "Received a file with an empty path\n");
 339                 r = 1;
 340                 goto ERROR;
 341         }
 342
 343         // Skip files that don't match what we are looking for
 344         if (ctx->class && !pakfire_file_matches_class(file, ctx->class))
 345                 goto SKIP;
 346
 347         // Write path to stdin
 348         r = dprintf(fd, "%s\n", path);
 349         if (r < 0)
 350                 return r;
 351
 352 SKIP:
 353         // Move on to the next file
 354         ctx->i++;
 355
 356         // Success
 357         r = 0;
 358
 359 ERROR:
 360         if (file)
 361                 pakfire_file_unref(file);
 362
 363         return r;
 364 }
 365
 366 static int pakfire_build_process_deps(struct pakfire* pakfire,
 367                 void* data, int priority, const char* buffer, const size_t length) {
 368         const struct pakfire_find_deps_ctx* ctx = (struct pakfire_find_deps_ctx*)data;
 369         char dep[PATH_MAX];
 370         pcre2_match_data* match = NULL;
 371         int r = 0;
 372
 373         // Nothing to do for an empty buffer
 374         if (!buffer || !*buffer)
 375                 return 0;
 376
 377         switch (priority) {
 378                 // Add every dependency that we have received
 379                 case LOG_INFO:
 380                         // Copy the dependency to the stack (and remove the trailing newline)
 381                         r = pakfire_string_format(dep, "%.*s", (int)length - 1, buffer);
 382                         if (r)
 383                                 return r;
 384
 385                         DEBUG(pakfire, "Processing dependency: %s\n", dep);
 386
 387                         // Filter out any dependencies that are provided by this package
 388                         if (ctx->dep == PAKFIRE_PKG_REQUIRES) {
 389                                 // If this is a file, we check if it is on the filelist
 390                                 if (pakfire_filelist_contains(ctx->filelist, dep))
 391                                         goto SKIP;
 392
 393                                 // Otherwise check if this dependency is provided by this package
 394                                 else if (pakfire_package_matches_dep(ctx->pkg, PAKFIRE_PKG_PROVIDES, dep))
 395                                         goto SKIP;
 396                         }
 397
 398                         // Check if this dependency should be filtered
 399                         if (ctx->filter) {
 400                                 match = pcre2_match_data_create_from_pattern(ctx->filter, NULL);
 401                                 if (!match) {
 402                                         ERROR(pakfire, "Could not allocate PCRE match data: %m\n");
 403                                         goto ERROR;
 404                                 }
 405
 406                                 // Perform matching
 407                                 r = pcre2_jit_match(ctx->filter, (PCRE2_SPTR)dep, length - 1,
 408                                         0, 0, match, NULL);
 409
 410                                 // No match
 411                                 if (r == PCRE2_ERROR_NOMATCH) {
 412                                         // Fall through...
 413
 414                                 // Handle any errors
 415                                 } else if (r < 0) {
 416                                         char error[120];
 417
 418                                         // Fetch the error message
 419                                         r = pcre2_get_error_message(r, (PCRE2_UCHAR*)error, sizeof(error));
 420                                         if (r < 0) {
 421                                                 ERROR(pakfire, "Could not fetch PCRE error message: %m\n");
 422                                                 r = 1;
 423                                                 goto ERROR;
 424                                         }
 425
 426                                         ERROR(pakfire, "Could not match the filter: %s\n", error);
 427                                         r = 1;
 428                                         goto ERROR;
 429
 430                                 // Match!
 431                                 } else {
 432                                         DEBUG(pakfire, "Skipping dependency that has been filtered: %s\n", dep);
 433                                         r = 0;
 434                                         goto ERROR;
 435                                 }
 436                         }
 437
 438                         // Add dependency
 439                         r = pakfire_package_add_dep(ctx->pkg, ctx->dep, buffer);
 440                         if (r) {
 441                                 ERROR(pakfire, "Could not process dependency '%s': %m\n", buffer);
 442                                 return r;
 443                         }
 444                         break;
 445
 446                 // Send everything else to the default logger
 447                 default:
 448                         ERROR(pakfire, "%s\n", buffer);
 449                         break;
 450         }
 451
 452         goto ERROR;
 453
 454 SKIP:
 455         DEBUG(pakfire, "Skipping dependency that is provided by the package itself: %s\n", dep);
 456
 457 ERROR:
 458         if (match)
 459                 pcre2_match_data_free(match);
 460
 461         return r;
 462 }
 463
 464 /*
 465         This function is a special way to run a script.
 466
 467         It will pipe the filelist into the standard input of the called script
 468         and will read any dependencies from the standard output.
 469 */
 470 static int pakfire_build_find_deps(struct pakfire_build* build,
 471                 struct pakfire_package* pkg, int dep, const char* script,
 472                 struct pakfire_filelist* filelist, int class, const pcre2_code* filter) {
 473         // Construct the context
 474         struct pakfire_find_deps_ctx ctx = {
 475                 .pkg      = pkg,
 476                 .dep      = dep,
 477                 .class    = class,
 478                 .filter   = filter,
 479
 480                 // Filelist
 481                 .filelist = filelist,
 482                 .i        = 0,
 483         };
 484         int r;
 485
 486         // Skip calling the script if class doesn't match
 487         if (class && !pakfire_filelist_matches_class(filelist, class)) {
 488                 DEBUG(build->pakfire, "Skipping calling %s as class does not match\n", script);
 489                 return 0;
 490         }
 491
 492         // Pass the buildroot as first argument
 493         const char* args[] = {
 494                 pakfire_relpath(build->pakfire, build->buildroot),
 495                 NULL,
 496         };
 497
 498         // Run the script
 499         r = pakfire_build_run_script(build, script, args,
 500                 pakfire_build_send_filelist, pakfire_build_process_deps, &ctx);
 501         if (r)
 502                 ERROR(build->pakfire, "%s returned with error %d\n", script, r);
 503
 504         return r;
 505 }
 506
 507 static int pakfire_build_find_dependencies(struct pakfire_build* build,
 508                 struct pakfire_parser* makefile, const char* namespace,
 509                 struct pakfire_package* pkg, struct pakfire_filelist* filelist) {
 510         pcre2_code* filter_provides = NULL;
 511         pcre2_code* filter_requires = NULL;
 512         int r;
 513
 514         // Fetch the provides filter
 515         r = pakfire_build_make_filter(build, &filter_provides,
 516                 makefile, namespace, "filter_provides");
 517         if (r) {
 518                 ERROR(build->pakfire, "Provides filter is broken: %m\n");
 519                 goto ERROR;
 520         }
 521
 522         // Fetch the requires filter
 523         r = pakfire_build_make_filter(build, &filter_requires,
 524                 makefile, namespace, "filter_requires");
 525         if (r) {
 526                 ERROR(build->pakfire, "Requires filter is broken: %m\n");
 527                 goto ERROR;
 528         }
 529
 530         // Find all provides
 531         r = pakfire_build_find_deps(build, pkg,
 532                 PAKFIRE_PKG_PROVIDES, "find-provides", filelist, 0, filter_provides);
 533         if (r)
 534                 goto ERROR;
 535
 536         // Find all Perl provides
 537         r = pakfire_build_find_deps(build, pkg,
 538                 PAKFIRE_PKG_PROVIDES, "perl.prov", filelist, PAKFIRE_FILE_PERL, filter_provides);
 539         if (r)
 540                 goto ERROR;
 541
 542         // Find all requires
 543         r = pakfire_build_find_deps(build, pkg,
 544                 PAKFIRE_PKG_REQUIRES, "find-requires", filelist, 0, filter_requires);
 545         if (r)
 546                 goto ERROR;
 547
 548         // Find all Perl requires
 549         r = pakfire_build_find_deps(build, pkg,
 550                 PAKFIRE_PKG_REQUIRES, "perl.req", filelist, PAKFIRE_FILE_PERL, filter_requires);
 551         if (r)
 552                 goto ERROR;
 553
 554 ERROR:
 555         if (filter_provides)
 556                 pcre2_code_free(filter_provides);
 557         if (filter_requires)
 558                 pcre2_code_free(filter_requires);
 559
 560         return r;
 561 }
 562
 563 static int __pakfire_build_package_mark_config_files(
 564                 struct pakfire* pakfire, struct pakfire_file* file, void* data) {
 565         char** configfiles = (char**)data;
 566         int r;
 567
 568         // Skip anything that isn't a regular file
 569         if (pakfire_file_get_type(file) == S_IFREG)
 570                 return 0;
 571
 572         // Fetch path
 573         const char* path = pakfire_file_get_path(file);
 574
 575         // Check if any configfile entry matches against this
 576         for (char** configfile = configfiles; *configfile; configfile++) {
 577                 if (pakfire_string_startswith(path, *configfile)) {
 578                         r = pakfire_file_set_flags(file, PAKFIRE_FILE_CONFIG);
 579                         if (r)
 580                                 return r;
 581
 582                         // Done
 583                         break;
 584                 }
 585         }
 586
 587         return 0;
 588 }
 589
 590 static int pakfire_build_package_mark_config_files(struct pakfire_build* build,
 591                 struct pakfire_filelist* filelist, struct pakfire_parser* makefile, const char* namespace) {
 592         char** configfiles = NULL;
 593         int r;
 594
 595         // Fetch configfiles from makefile
 596         r = pakfire_parser_get_filelist(makefile, namespace, "configfiles", &configfiles, NULL);
 597
 598         // If configfiles is not set, there is nothing to do
 599         if (!configfiles)
 600                 return 0;
 601
 602         r = pakfire_filelist_walk(filelist, __pakfire_build_package_mark_config_files, configfiles);
 603
 604         // Cleanup
 605         if (configfiles) {
 606                 for (char** configfile = configfiles; *configfile; configfile++)
 607                         free(*configfile);
 608                 free(configfiles);
 609         }
 610
 611         return r;
 612 }
 613
 614 static int pakfire_build_package_add_files(struct pakfire_build* build,
 615                 struct pakfire_parser* makefile, const char* buildroot, const char* namespace,
 616                 struct pakfire_package* pkg, struct pakfire_packager* packager) {
 617         struct pakfire_filelist* filelist = NULL;
 618         char** includes = NULL;
 619         char** excludes = NULL;
 620         int r;
 621
 622         // Fetch filelist from makefile
 623         r = pakfire_parser_get_filelist(makefile, namespace, "files", &includes, &excludes);
 624
 625         // No files to package?
 626         if (!includes && !excludes)
 627                 return 0;
 628
 629         // Allocate a new filelist
 630         r = pakfire_filelist_create(&filelist, build->pakfire);
 631         if (r)
 632                 goto ERROR;
 633
 634         // Scan for files
 635         r = pakfire_filelist_scan(filelist, build->buildroot,
 636                 (const char**)includes, (const char**)excludes);
 637         if (r)
 638                 goto ERROR;
 639
 640         DEBUG(build->pakfire, "%zu file(s) found\n", pakfire_filelist_length(filelist));
 641
 642         // Nothing to do if the filelist is empty
 643         if (pakfire_filelist_is_empty(filelist))
 644                 goto ERROR;
 645
 646         // Dump the filelist
 647         pakfire_filelist_dump(filelist, PAKFIRE_FILE_DUMP_FULL);
 648
 649         // Find dependencies
 650         r = pakfire_build_find_dependencies(build, makefile, namespace, pkg, filelist);
 651         if (r) {
 652                 ERROR(build->pakfire, "Finding dependencies failed: %m\n");
 653                 goto ERROR;
 654         }
 655
 656         // Mark configuration files
 657         r = pakfire_build_package_mark_config_files(build, filelist, makefile, namespace);
 658         if (r)
 659                 goto ERROR;
 660
 661         // Add all files to the package
 662         r = pakfire_packager_add_files(packager, filelist);
 663         if (r)
 664                 goto ERROR;
 665
 666 ERROR:
 667         if (filelist)
 668                 pakfire_filelist_unref(filelist);
 669         if (includes) {
 670                 for (char** include = includes; *include; include++)
 671                         free(*include);
 672                 free(includes);
 673         }
 674         if (excludes) {
 675                 for (char** exclude = excludes; *exclude; exclude++)
 676                         free(*exclude);
 677                 free(excludes);
 678         }
 679
 680         return r;
 681 }
 682
 683 static int pakfire_build_send_scriptlet(struct pakfire* pakfire, void* data, int fd) {
 684         const struct pakfire_find_deps_ctx* ctx = (struct pakfire_find_deps_ctx*)data;
 685         size_t length = 0;
 686
 687         // Fetch the scriptlet
 688         const char* p = pakfire_scriptlet_get_data(ctx->scriptlet, &length);
 689         if (!p) {
 690                 ERROR(pakfire, "Could not fetch scriptlet: %m\n");
 691                 return 1;
 692         }
 693
 694         // Write it into the pipe
 695         ssize_t bytes_written = write(fd, p, length);
 696         if (bytes_written < 0) {
 697                 ERROR(pakfire, "Could not send scriptlet: %m\n");
 698                 return 1;
 699         }
 700
 701         return EOF;
 702 }
 703
 704 static int pakfire_build_add_scriptlet_requires(struct pakfire_build* build,
 705                 struct pakfire_package* pkg, struct pakfire_scriptlet* scriptlet) {
 706         int r;
 707
 708         struct pakfire_find_deps_ctx ctx = {
 709                 .pkg       = pkg,
 710                 .dep       = PAKFIRE_PKG_PREREQUIRES,
 711                 .scriptlet = scriptlet,
 712         };
 713
 714         // Find all pre-requires
 715         r = pakfire_build_run_script(build, "find-prerequires", NULL,
 716                 pakfire_build_send_scriptlet, pakfire_build_process_deps, &ctx);
 717         if (r)
 718                 goto ERROR;
 719
 720 ERROR:
 721         return r;
 722 }
 723
 724 static int pakfire_build_package_add_scriptlet(struct pakfire_build* build,
 725                 struct pakfire_package* pkg, struct pakfire_packager* packager,
 726                 const char* type, const char* data) {
 727         struct pakfire_scriptlet* scriptlet = NULL;
 728         char* shell = NULL;
 729         int r;
 730
 731         // Wrap scriptlet into a shell script
 732         r = asprintf(&shell, "#!/bin/sh\n\nset -e\n\n%s\n\nexit 0\n", data);
 733         if (r < 0)
 734                 goto ERROR;
 735
 736         // Create a scriptlet
 737         r = pakfire_scriptlet_create(&scriptlet, build->pakfire, type, shell, 0);
 738         if (r)
 739                 goto ERROR;
 740
 741         // Add it to the package
 742         r = pakfire_packager_add_scriptlet(packager, scriptlet);
 743         if (r) {
 744                 ERROR(build->pakfire, "Could not add scriptlet %s\n", type);
 745                 goto ERROR;
 746         }
 747
 748         // Add scriptlet requirements
 749         r = pakfire_build_add_scriptlet_requires(build, pkg, scriptlet);
 750         if (r) {
 751                 ERROR(build->pakfire, "Could not add scriptlet requirements: %m\n");
 752                 goto ERROR;
 753         }
 754
 755         // Success
 756         r = 0;
 757
 758 ERROR:
 759         if (scriptlet)
 760                 pakfire_scriptlet_unref(scriptlet);
 761         if (shell)
 762                 free(shell);
 763
 764         return r;
 765 }
 766
 767 static int pakfire_build_package_add_scriptlets(struct pakfire_build* build,
 768                 struct pakfire_parser* makefile, const char* namespace,
 769                 struct pakfire_package* pkg, struct pakfire_packager* packager) {
 770         char name[NAME_MAX];
 771         int r;
 772
 773         for (const char** type = pakfire_scriptlet_types; *type; type++) {
 774                 r = pakfire_string_format(name, "scriptlet:%s", *type);
 775                 if (r)
 776                         return r;
 777
 778                 // Fetch the scriptlet
 779                 char* data = pakfire_parser_get(makefile, namespace, name);
 780                 if (!data)
 781                         continue;
 782
 783                 // Add it to the package
 784                 r = pakfire_build_package_add_scriptlet(build, pkg, packager, *type, data);
 785                 if (r) {
 786                         free(data);
 787                         return r;
 788                 }
 789
 790                 free(data);
 791         }
 792
 793         return 0;
 794 }
 795
 796 static int pakfire_build_package(struct pakfire_build* build, struct pakfire_parser* makefile,
 797                 const char* buildroot, const char* namespace) {
 798         struct pakfire_package* pkg = NULL;
 799         struct pakfire_packager* packager = NULL;
 800
 801         int r = 1;
 802
 803         // Expand the handle into the package name
 804         char* name = pakfire_parser_expand(makefile, "packages", namespace);
 805         if (!name) {
 806                 ERROR(build->pakfire, "Could not get package name: %m\n");
 807                 goto ERROR;
 808         }
 809
 810         INFO(build->pakfire, "Building package '%s'...\n", name);
 811         DEBUG(build->pakfire, "  buildroot = %s\n", buildroot);
 812
 813         // Fetch build architecture
 814         const char* arch = pakfire_get_arch(build->pakfire);
 815         if (!arch)
 816                 goto ERROR;
 817
 818         // Fetch package from makefile
 819         r = pakfire_parser_create_package(makefile, &pkg, NULL, namespace, arch);
 820         if (r) {
 821                 ERROR(build->pakfire, "Could not create package from makefile: %m\n");
 822                 goto ERROR;
 823         }
 824
 825         // Set distribution
 826         const char* distribution = pakfire_parser_get(makefile, NULL, "DISTRO_NAME");
 827         if (distribution) {
 828                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_DISTRO, distribution);
 829                 if (r)
 830                         goto ERROR;
 831         }
 832
 833         // Set build ID
 834         pakfire_package_set_uuid(pkg, PAKFIRE_PKG_BUILD_ID, build->id);
 835
 836         // Set source package
 837         const char* source_name = pakfire_parser_get(makefile, NULL, "name");
 838         if (source_name) {
 839                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_SOURCE_NAME, source_name);
 840                 if (r)
 841                         goto ERROR;
 842         }
 843
 844         // Set source EVR
 845         const char* source_evr = pakfire_parser_get(makefile, NULL, "evr");
 846         if (source_evr) {
 847                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_SOURCE_EVR, source_evr);
 848                 if (r)
 849                         goto ERROR;
 850         }
 851
 852         // Set source arch
 853         r = pakfire_package_set_string(pkg, PAKFIRE_PKG_SOURCE_ARCH, "src");
 854         if (r)
 855                 goto ERROR;
 856
 857         // Create a packager
 858         r = pakfire_packager_create(&packager, build->pakfire, pkg);
 859         if (r)
 860                 goto ERROR;
 861
 862         // Add files
 863         r = pakfire_build_package_add_files(build, makefile, buildroot, namespace,
 864                 pkg, packager);
 865         if (r)
 866                 goto ERROR;
 867
 868         // Add scriptlets
 869         r = pakfire_build_package_add_scriptlets(build, makefile, namespace,
 870                 pkg, packager);
 871         if (r)
 872                 goto ERROR;
 873
 874         const char* path = pakfire_repo_get_path(build->repo);
 875
 876         // Write the finished package
 877         r = pakfire_packager_finish_to_directory(packager, path, NULL);
 878         if (r) {
 879                 ERROR(build->pakfire, "pakfire_packager_finish() failed: %m\n");
 880                 goto ERROR;
 881         }
 882
 883         // Cleanup all packaged files
 884         r = pakfire_packager_cleanup(packager);
 885         if (r)
 886                 goto ERROR;
 887
 888         // Success
 889         r = 0;
 890
 891 ERROR:
 892         if (packager)
 893                 pakfire_packager_unref(packager);
 894         if (pkg)
 895                 pakfire_package_unref(pkg);
 896         if (name)
 897                 free(name);
 898
 899         return r;
 900 }
 901
 902 static int pakfire_build_package_dump(struct pakfire* pakfire,
 903                 struct pakfire_package* pkg, void* p) {
 904         char* dump = pakfire_package_dump(pkg, PAKFIRE_PKG_DUMP_LONG);
 905         if (!dump)
 906                 return 1;
 907
 908         INFO(pakfire, "%s\n", dump);
 909         free(dump);
 910
 911         return 0;
 912 }
 913
 914 static int pakfire_build_packages(struct pakfire_build* build,
 915                 struct pakfire_parser* makefile) {
 916         DEBUG(build->pakfire, "Creating packages...");
 917         int r = 1;
 918
 919         const char* buildroot = pakfire_relpath(build->pakfire, build->buildroot);
 920
 921         // Fetch a list all all packages
 922         char** packages = pakfire_parser_list_namespaces(makefile, "packages.package:*");
 923         if (!packages) {
 924                 ERROR(build->pakfire, "Could not find any packages: %m\n");
 925                 goto ERROR;
 926         }
 927
 928         unsigned int num_packages = 0;
 929
 930         // Count how many packages we have
 931         for (char** package = packages; *package; package++)
 932                 num_packages++;
 933
 934         DEBUG(build->pakfire, "Found %d package(s)\n", num_packages);
 935
 936         // Build packages in reverse order
 937         for (int i = num_packages - 1; i >= 0; i--) {
 938                 r = pakfire_build_package(build, makefile, buildroot, packages[i]);
 939                 if (r)
 940                         goto ERROR;
 941         }
 942
 943         // Rescan the build repository to import all packages again
 944         r = pakfire_repo_scan(build->repo, 0);
 945         if (r)
 946                 goto ERROR;
 947
 948         // Create a new packagelist
 949         r = pakfire_packagelist_create(&build->packages, build->pakfire);
 950         if (r)
 951                 goto ERROR;
 952
 953         // Fetch all packages
 954         r = pakfire_repo_to_packagelist(build->repo, build->packages);
 955         if (r)
 956                 goto ERROR;
 957
 958         // Dump them all
 959         r = pakfire_packagelist_walk(build->packages, pakfire_build_package_dump, NULL);
 960         if (r)
 961                 goto ERROR;
 962
 963         // Success
 964         r = 0;
 965
 966 ERROR:
 967         if (packages)
 968                 free(packages);
 969
 970         return r;
 971 }
 972
 973 static int pakfire_build_stage(struct pakfire_build* build,
 974                 struct pakfire_parser* makefile, const char* stage) {
 975         char template[1024];
 976
 977         // Prepare template for this stage
 978         int r = pakfire_string_format(template, TEMPLATE, stage);
 979         if (r)
 980                 return r;
 981
 982         // Fetch the environment
 983         char** envp = pakfire_parser_make_environ(makefile);
 984
 985         // Create the build script
 986         char* script = pakfire_parser_expand(makefile, "build", template);
 987         if (!script) {
 988                 ERROR(build->pakfire, "Could not generate the build script for stage '%s': %m\n",
 989                         stage);
 990                 goto ERROR;
 991         }
 992
 993         INFO(build->pakfire, "Running build stage '%s'\n", stage);
 994
 995         // Import environment
 996         // XXX is this a good idea?
 997         r = pakfire_jail_import_env(build->jail, (const char**)envp);
 998         if (r) {
 999                 ERROR(build->pakfire, "Could not import environment: %m\n");
1000                 goto ERROR;
1001         }
1002
1003         // Run the script
1004         r = pakfire_jail_exec_script(build->jail, script, strlen(script), NULL, NULL, NULL, NULL);
1005         if (r) {
1006                 ERROR(build->pakfire, "Build stage '%s' failed with status %d\n", stage, r);
1007         }
1008
1009 ERROR:
1010         if (envp) {
1011                 for (char** e = envp; *e; e++)
1012                         free(*e);
1013                 free(envp);
1014         }
1015         if (script)
1016                 free(script);
1017
1018         return r;
1019 }
1020
1021 enum {
1022         PAKFIRE_BUILD_CLEANUP_FILES         = (1 << 0),
1023         PAKFIRE_BUILD_ERROR_IF_NOT_EMPTY    = (1 << 1),
1024 };
1025
1026 /*
1027         This helper function takes a callback which is expected to add any files
1028         to the given filelist which will optionally be all removed after.
1029 */
1030 static int pakfire_build_post_process_files(struct pakfire_build* build,
1031                 struct pakfire_filelist* filelist, const char* description,
1032                 int (*callback)(struct pakfire* pakfire, struct pakfire_file* file, void* data),
1033                 int flags) {
1034         struct pakfire_filelist* removees = NULL;
1035         int r;
1036
1037         // Create a filelist with objects that need to be removed
1038         r = pakfire_filelist_create(&removees, build->pakfire);
1039         if (r)
1040                 goto ERROR;
1041
1042         // Find all files that need to be removed
1043         r = pakfire_filelist_walk(filelist, callback, removees);
1044         if (r)
1045                 goto ERROR;
1046
1047         if (!pakfire_filelist_is_empty(removees)) {
1048                 if (description)
1049                         INFO(build->pakfire, "%s\n", description);
1050
1051                 // Show all files which will be removed
1052                 pakfire_filelist_dump(removees, PAKFIRE_FILE_DUMP_FULL|PAKFIRE_FILE_DUMP_ISSUES);
1053
1054                 // Remove all files on the removee list
1055                 if (flags & PAKFIRE_BUILD_CLEANUP_FILES) {
1056                         r = pakfire_filelist_cleanup(removees);
1057                         if (r)
1058                                 goto ERROR;
1059
1060                         // Remove all files from the filelist
1061                         r = pakfire_filelist_remove_all(filelist, removees);
1062                         if (r)
1063                                 goto ERROR;
1064                 }
1065
1066                 // Report an error if any files have been found
1067                 if (flags & PAKFIRE_BUILD_ERROR_IF_NOT_EMPTY)
1068                         r = 1;
1069         }
1070
1071 ERROR:
1072         if (removees)
1073                 pakfire_filelist_unref(removees);
1074
1075         return r;
1076 }
1077
1078 static int __pakfire_build_remove_static_libraries(
1079                 struct pakfire* pakfire, struct pakfire_file* file, void* data) {
1080         struct pakfire_filelist* removees = (struct pakfire_filelist*)data;
1081         char path[PATH_MAX];
1082         int r;
1083
1084         // Find all static libraries
1085         if (pakfire_file_matches_class(file, PAKFIRE_FILE_STATIC_LIBRARY)) {
1086                 // Copy the filename
1087                 r = pakfire_string_set(path, pakfire_file_get_abspath(file));
1088                 if (r)
1089                         return -1;
1090
1091                 // Remove the extension
1092                 r = pakfire_path_replace_extension(path, "so");
1093                 if (r)
1094                         return -1;
1095
1096                 // Only delete if there is a shared object with the same name
1097                 if (pakfire_path_exists(path))
1098                         return pakfire_filelist_add(removees, file);
1099         }
1100
1101         return 0;
1102 }
1103
1104 static int pakfire_build_post_remove_static_libraries(
1105                 struct pakfire_build* build, struct pakfire_filelist* filelist) {
1106         return pakfire_build_post_process_files(build, filelist,
1107                 "Removing static libaries...",
1108                 __pakfire_build_remove_static_libraries,
1109                 PAKFIRE_BUILD_CLEANUP_FILES);
1110 }
1111
1112 static int __pakfire_build_remove_libtool_archives(
1113                 struct pakfire* pakfire, struct pakfire_file* file, void* data) {
1114         struct pakfire_filelist* removees = (struct pakfire_filelist*)data;
1115
1116         // Find all libtool archive files
1117         if (pakfire_file_matches_class(file, PAKFIRE_FILE_LIBTOOL_ARCHIVE))
1118                 return pakfire_filelist_add(removees, file);
1119
1120         return 0;
1121 }
1122
1123 static int pakfire_build_post_remove_libtool_archives(
1124                 struct pakfire_build* build, struct pakfire_filelist* filelist) {
1125         return pakfire_build_post_process_files(build, filelist,
1126                 "Removing libtool archives...",
1127                 __pakfire_build_remove_libtool_archives,
1128                 PAKFIRE_BUILD_CLEANUP_FILES);
1129 }
1130
1131 static int __pakfire_build_check_broken_symlinks(
1132                 struct pakfire* pakfire, struct pakfire_file* file, void* data) {
1133         struct pakfire_filelist* broken = (struct pakfire_filelist*)data;
1134         int r;
1135
1136         // Ignore anything that isn't a symlink
1137         switch (pakfire_file_get_type(file)) {
1138                 case S_IFLNK:
1139                         if (!pakfire_file_symlink_target_exists(file)) {
1140                                 r = pakfire_filelist_add(broken, file);
1141                                 if (r)
1142                                         return r;
1143                         }
1144
1145                         break;
1146
1147                 // Ignore anything that isn't a symlink
1148                 default:
1149                         break;
1150         }
1151
1152         return 0;
1153 }
1154
1155 static int pakfire_build_post_check_broken_symlinks(
1156                 struct pakfire_build* build, struct pakfire_filelist* filelist) {
1157         return pakfire_build_post_process_files(build, filelist,
1158                 "Broken symlinks have been found:",
1159                 __pakfire_build_check_broken_symlinks,
1160                 PAKFIRE_BUILD_ERROR_IF_NOT_EMPTY);
1161 }
1162
1163 /*
1164         BUILDROOT Check
1165 */
1166 static int pakfire_build_post_check_buildroot(
1167                 struct pakfire_build* build, struct pakfire_filelist* filelist) {
1168         const char* buildroot = pakfire_relpath(build->pakfire, build->buildroot);
1169
1170         // Nested function to keep a reference to buildroot
1171         int __pakfire_build_post_check_buildroot(
1172                         struct pakfire* pakfire, struct pakfire_file* file, void* data) {
1173                 struct pakfire_filelist* matches = (struct pakfire_filelist*)data;
1174                 int r;
1175
1176                 if (pakfire_file_payload_matches(file, buildroot, strlen(buildroot))) {
1177                         r = pakfire_filelist_add(matches, file);
1178                         if (r)
1179                                 return r;
1180                 }
1181
1182                 return 0;
1183         }
1184
1185         return pakfire_build_post_process_files(
1186                 build, filelist, "Files containing BUILDROOT:",
1187                 __pakfire_build_post_check_buildroot, PAKFIRE_BUILD_ERROR_IF_NOT_EMPTY);
1188 }
1189
1190 /*
1191         File Issues
1192 */
1193
1194 static int __pakfire_build_post_check_files(
1195                 struct pakfire* pakfire, struct pakfire_file* file, void* data) {
1196         struct pakfire_filelist* broken = (struct pakfire_filelist*)data;
1197         int issues = 0;
1198         int r;
1199
1200         // Check file for issues
1201         r = pakfire_file_check(file, &issues);
1202         if (r) {
1203                 ERROR(pakfire, "%s: File Check failed: %m\n", pakfire_file_get_path(file));
1204                 return r;
1205         }
1206
1207         // If any issues have been found, consider this file to be on the list
1208         if (issues) {
1209                 r = pakfire_filelist_add(broken, file);
1210                 if (r)
1211                         return r;
1212         }
1213
1214         return 0;
1215 }
1216
1217 static int pakfire_build_post_check_files(
1218                 struct pakfire_build* build, struct pakfire_filelist* filelist) {
1219         return pakfire_build_post_process_files(
1220                 build,
1221                 filelist,
1222                 "File Issues:",
1223                 __pakfire_build_post_check_files,
1224                 PAKFIRE_BUILD_ERROR_IF_NOT_EMPTY);
1225 }
1226
1227 static int pakfire_build_run_post_build_checks(struct pakfire_build* build) {
1228         struct pakfire_filelist* filelist = NULL;
1229         int r;
1230
1231         // Create a filelist of all files in the build
1232         r = pakfire_filelist_create(&filelist, build->pakfire);
1233         if (r) {
1234                 ERROR(build->pakfire, "Could not create filelist: %m\n");
1235                 goto ERROR;
1236         }
1237
1238         // Scan for all files in BUILDROOT
1239         r = pakfire_filelist_scan(filelist, build->buildroot, NULL, NULL);
1240         if (r)
1241                 goto ERROR;
1242
1243         // If the filelist is empty, we can are done
1244         if (pakfire_filelist_is_empty(filelist)) {
1245                 DEBUG(build->pakfire, "Empty BUILDROOT. Skipping post build checks...\n");
1246                 r = 0;
1247                 goto ERROR;
1248         }
1249
1250         // Remove any static libraries
1251         r = pakfire_build_post_remove_static_libraries(build, filelist);
1252         if (r)
1253                 goto ERROR;
1254
1255         // Remove any libtool archives
1256         r = pakfire_build_post_remove_libtool_archives(build, filelist);
1257         if (r)
1258                 goto ERROR;
1259
1260         // Check for any broken symlinks
1261         r = pakfire_build_post_check_broken_symlinks(build, filelist);
1262         if (r)
1263                 goto ERROR;
1264
1265         // Check for BUILDROOT
1266         r = pakfire_build_post_check_buildroot(build, filelist);
1267         if (r)
1268                 goto ERROR;
1269
1270         // Check files
1271         r = pakfire_build_post_check_files(build, filelist);
1272         if (r)
1273                 goto ERROR;
1274
1275 ERROR:
1276         if (filelist)
1277                 pakfire_filelist_unref(filelist);
1278
1279         return r;
1280 }
1281
1282 static const char* post_build_scripts[] = {
1283         "check-rpaths",
1284         "check-hardening",
1285         "check-interpreters",
1286         "compress-man-pages",
1287         "strip",
1288         NULL,
1289 };
1290
1291 static int pakfire_build_run_post_build_scripts(struct pakfire_build* build) {
1292         // Fetch buildroot
1293         const char* buildroot = pakfire_relpath(build->pakfire, build->buildroot);
1294
1295         // Set default arguments for build scripts
1296         const char* args[] = {
1297                 buildroot, NULL
1298         };
1299
1300         // Run them one by one
1301         for (const char** script = post_build_scripts; *script; script++) {
1302                 int r = pakfire_build_run_script(build, *script, args, NULL, NULL, NULL);
1303                 if (r)
1304                         return r;
1305         }
1306
1307         return 0;
1308 }
1309
1310 static void pakfire_build_free(struct pakfire_build* build) {
1311         if (build->packages)
1312                 pakfire_packagelist_unref(build->packages);
1313
1314         if (build->repo) {
1315                 pakfire_repo_clean(build->repo, PAKFIRE_REPO_CLEAN_FLAGS_DESTROY);
1316                 pakfire_repo_unref(build->repo);
1317         }
1318
1319         if (build->jail)
1320                 pakfire_jail_unref(build->jail);
1321
1322         if (build->cgroup) {
1323                 // Destroy the cgroup
1324                 pakfire_cgroup_destroy(build->cgroup);
1325
1326                 // Free it
1327                 pakfire_cgroup_unref(build->cgroup);
1328         }
1329
1330         pakfire_unref(build->pakfire);
1331         free(build);
1332 }
1333
1334 static int pakfire_build_parse_id(struct pakfire_build* build, const char* id) {
1335         int r;
1336
1337         // Try parsing the Build ID
1338         if (id) {
1339                 r = uuid_parse(id, build->id);
1340                 if (r) {
1341                         ERROR(build->pakfire, "Could not parse build ID '%s'\n", id);
1342                         errno = EINVAL;
1343                         return r;
1344                 }
1345
1346         // Otherwise initialize the Build ID with something random
1347         } else {
1348                 uuid_generate_random(build->id);
1349         }
1350
1351         // Store the ID as string, too
1352         uuid_unparse_lower(build->id, build->_id);
1353
1354         return 0;
1355 }
1356
1357 /*
1358         Sets up a new cgroup for this build
1359 */
1360 static int pakfire_build_setup_cgroup(struct pakfire_build* build) {
1361         struct pakfire_config* config = NULL;
1362         char path[PATH_MAX];
1363         int r;
1364
1365         // Compose path
1366         r = pakfire_string_format(path, "pakfire/build-%s", build->_id);
1367         if (r) {
1368                 ERROR(build->pakfire, "Could not compose path for cgroup: %m\n");
1369                 goto ERROR;
1370         }
1371
1372         // Create a new cgroup
1373         r = pakfire_cgroup_open(&build->cgroup, build->pakfire, path,
1374                 PAKFIRE_CGROUP_ENABLE_ACCOUNTING);
1375         if (r) {
1376                 ERROR(build->pakfire, "Could not create cgroup for build %s: %m\n", build->_id);
1377                 goto ERROR;
1378         }
1379
1380         // Fetch config
1381         config = pakfire_get_config(build->pakfire);
1382         if (!config)
1383                 goto ERROR;
1384
1385         // Guarantee some minimum memory
1386         size_t memory_guaranteed = pakfire_config_get_bytes(config, "build",
1387                 "memory_guaranteed", PAKFIRE_BUILD_MEMORY_GUARANTEED);
1388         if (memory_guaranteed) {
1389                 r = pakfire_cgroup_set_guaranteed_memory(build->cgroup, memory_guaranteed);
1390                 if (r)
1391                         goto ERROR;
1392         }
1393
1394         // Limit memory
1395         size_t memory_limit = pakfire_config_get_bytes(config, "build", "memory_limit", 0);
1396         if (memory_limit) {
1397                 r = pakfire_cgroup_set_memory_limit(build->cgroup, memory_limit);
1398                 if (r)
1399                         goto ERROR;
1400         }
1401
1402         // Set PID limit
1403         size_t pid_limit = pakfire_config_get_int(config, "build",
1404                 "pid_limit", PAKFIRE_BUILD_PID_LIMIT);
1405         if (pid_limit) {
1406                 r = pakfire_cgroup_set_pid_limit(build->cgroup, pid_limit);
1407                 if (r)
1408                         goto ERROR;
1409         }
1410
1411 ERROR:
1412         if (config)
1413                 pakfire_config_unref(config);
1414
1415         return r;
1416 }
1417
1418 /*
1419         Sets up a new jail for this build
1420 */
1421 static int pakfire_build_setup_jail(struct pakfire_build* build) {
1422         int r;
1423
1424         // Create a new jail
1425         r = pakfire_jail_create(&build->jail, build->pakfire, 0);
1426         if (r) {
1427                 ERROR(build->pakfire, "Could not create jail for build %s: %m\n", build->_id);
1428                 return r;
1429         }
1430
1431         // Connect the jail to our cgroup
1432         r = pakfire_jail_set_cgroup(build->jail, build->cgroup);
1433         if (r) {
1434                 ERROR(build->pakfire, "Could not set cgroup for jail: %m\n");
1435                 return r;
1436         }
1437
1438         // Done
1439         return 0;
1440 }
1441
1442 /*
1443         Sets up the ccache for this build
1444 */
1445 static int pakfire_build_setup_ccache(struct pakfire_build* build) {
1446         char path[PATH_MAX];
1447         int r;
1448
1449         // Check if we want a ccache
1450         if (pakfire_build_has_flag(build, PAKFIRE_BUILD_DISABLE_CCACHE)) {
1451                 DEBUG(build->pakfire, "ccache usage has been disabled for this build\n");
1452
1453                 // Set CCACHE_DISABLE=1 so that if ccache is installed, it will disable itself
1454                 r = pakfire_jail_set_env(build->jail, "CCACHE_DISABLE", "1");
1455                 if (r) {
1456                         ERROR(build->pakfire, "Could not disable ccache: %m\n");
1457                         return r;
1458                 }
1459
1460                 return 0;
1461         }
1462
1463         // Compose path
1464         r = pakfire_cache_path(build->pakfire, path, "%s", "ccache");
1465         if (r) {
1466                 ERROR(build->pakfire, "Could not compose ccache path: %m\n");
1467                 return 1;
1468         }
1469
1470         DEBUG(build->pakfire, "Mounting ccache from %s\n", path);
1471
1472         // Ensure path exists
1473         r = pakfire_mkdir(path, 0755);
1474         if (r && errno != EEXIST) {
1475                 ERROR(build->pakfire, "Could not create ccache directory %s: %m\n", path);
1476                 return r;
1477         }
1478
1479         // Bind-mount the directory
1480         r = pakfire_jail_bind(build->jail, path, CCACHE_DIR, MS_NOSUID|MS_NOEXEC|MS_NODEV);
1481         if (r) {
1482                 ERROR(build->pakfire, "Could not mount ccache: %m\n");
1483                 return r;
1484         }
1485
1486         return 0;
1487 }
1488
1489 static int pakfire_build_setup_repo(struct pakfire_build* build) {
1490         char path[PATH_MAX] = PAKFIRE_TMP_DIR "/pakfire-build-repo.XXXXXX";
1491         char url[PATH_MAX];
1492         int r;
1493
1494         // Create a new repository
1495         r = pakfire_repo_create(&build->repo, build->pakfire, PAKFIRE_REPO_RESULT);
1496         if (r) {
1497                 ERROR(build->pakfire, "Could not create repository %s: %m", PAKFIRE_REPO_RESULT);
1498                 return r;
1499         }
1500
1501         // Set description
1502         pakfire_repo_set_description(build->repo, _("Build Repository"));
1503
1504         // Create a temporary directory
1505         const char* p = pakfire_mkdtemp(path);
1506         if (!p) {
1507                 ERROR(build->pakfire, "Could not create a the build repository: %m\n");
1508                 return 1;
1509         }
1510
1511         // Format the URL
1512         r = pakfire_string_format(url, "file://%s", path);
1513         if (r)
1514                 return r;
1515
1516         // Set the URL
1517         pakfire_repo_set_baseurl(build->repo, url);
1518
1519         return r;
1520 }
1521
1522 static int pakfire_build_set_time_start(struct pakfire_build* build) {
1523         const time_t now = time(NULL);
1524
1525         if (now < 0) {
1526                 ERROR(build->pakfire, "Could not fetch start time: %m\n");
1527                 return 1;
1528         }
1529
1530         build->time_start = now;
1531
1532         return 0;
1533 }
1534
1535 PAKFIRE_EXPORT int pakfire_build_create(struct pakfire_build** build,
1536                 struct pakfire* pakfire, const char* id, int flags) {
1537         int r;
1538
1539         // Allocate build object
1540         struct pakfire_build* b = calloc(1, sizeof(*b));
1541         if (!b)
1542                 return 1;
1543
1544         // Reference pakfire
1545         b->pakfire = pakfire_ref(pakfire);
1546
1547         // Initialize reference counter
1548         b->nrefs = 1;
1549
1550         // Copy flags
1551         b->flags = flags;
1552
1553         // Store start time
1554         r = pakfire_build_set_time_start(b);
1555         if (r)
1556                 goto ERROR;
1557
1558         // Parse ID
1559         r = pakfire_build_parse_id(b, id);
1560         if (r)
1561                 goto ERROR;
1562
1563         // Setup repo
1564         r = pakfire_build_setup_repo(b);
1565         if (r)
1566                 goto ERROR;
1567
1568         // Create cgroup
1569         r = pakfire_build_setup_cgroup(b);
1570         if (r)
1571                 goto ERROR;
1572
1573         // Create jail
1574         r = pakfire_build_setup_jail(b);
1575         if (r)
1576                 goto ERROR;
1577
1578         // Setup ccache
1579         r = pakfire_build_setup_ccache(b);
1580         if (r)
1581                 goto ERROR;
1582
1583         *build = b;
1584         return 0;
1585
1586 ERROR:
1587         pakfire_build_free(b);
1588         return r;
1589 }
1590
1591 PAKFIRE_EXPORT struct pakfire_build* pakfire_build_ref(struct pakfire_build* build) {
1592         ++build->nrefs;
1593
1594         return build;
1595 }
1596
1597 PAKFIRE_EXPORT struct pakfire_build* pakfire_build_unref(struct pakfire_build* build) {
1598         if (--build->nrefs > 0)
1599                 return build;
1600
1601         pakfire_build_free(build);
1602         return NULL;
1603 }
1604
1605 PAKFIRE_EXPORT int pakfire_build_set_target(
1606                 struct pakfire_build* build, const char* target) {
1607         return pakfire_string_set(build->target, target);
1608 }
1609
1610 static int pakfire_build_install_packages(struct pakfire_build* build,
1611                 int* snapshot_needs_update) {
1612         int r;
1613
1614         const char* packages[] = {
1615                 "build-essential",
1616                 NULL,
1617         };
1618
1619         int changed = 0;
1620
1621         // Install everything
1622         r = pakfire_install(build->pakfire, 0, 0, packages, NULL, 0,
1623                 &changed, NULL, NULL);
1624         if (r) {
1625                 ERROR(build->pakfire, "Could not install build dependencies: %m\n");
1626                 return r;
1627         }
1628
1629         // Mark snapshot as changed if new packages were installed
1630         if (changed)
1631                 *snapshot_needs_update = 1;
1632
1633         // Update everything
1634         r = pakfire_sync(build->pakfire, 0, 0, &changed, NULL, NULL);
1635         if (r) {
1636                 ERROR(build->pakfire, "Could not update packages: %m\n");
1637                 return r;
1638         }
1639
1640         // Has anything changed?
1641         if (changed)
1642                 *snapshot_needs_update = 1;
1643
1644         return 0;
1645 }
1646
1647 /*
1648         Initializes the build environment
1649 */
1650 static int pakfire_build_init(struct pakfire_build* build) {
1651         int r;
1652
1653         // Don't do it again
1654         if (build->init) {
1655                 DEBUG(build->pakfire, "Build environment has already been initialized\n");
1656                 return 0;
1657         }
1658
1659         // Tells us whether we need to (re-)create the snapshot
1660         int snapshot_needs_update = 0;
1661
1662         // Extract snapshot
1663         if (!pakfire_build_has_flag(build, PAKFIRE_BUILD_DISABLE_SNAPSHOT)) {
1664                 r = pakfire_snapshot_restore(build->pakfire);
1665                 if (r)
1666                         return r;
1667         }
1668
1669         // Install or update any build dependencies
1670         r = pakfire_build_install_packages(build, &snapshot_needs_update);
1671         if (r)
1672                 return r;
1673
1674         // Update the snapshot if there were changes
1675         if (!pakfire_build_has_flag(build, PAKFIRE_BUILD_DISABLE_SNAPSHOT) && snapshot_needs_update) {
1676                 // Store the snapshot
1677                 r = pakfire_snapshot_store(build->pakfire);
1678                 if (r)
1679                         return r;
1680         }
1681
1682         // Mark as initialized
1683         build->init = 1;
1684
1685         return 0;
1686 }
1687
1688 static int pakfire_build_read_makefile(struct pakfire_build* build,
1689                 struct pakfire_parser** parser, struct pakfire_package* package) {
1690         char path[PATH_MAX];
1691         int r;
1692
1693         struct pakfire_parser_error* error = NULL;
1694
1695         const char* nevra = pakfire_package_get_string(package, PAKFIRE_PKG_NEVRA);
1696         const char* name  = pakfire_package_get_string(package, PAKFIRE_PKG_NAME);
1697
1698         // Compose path to makefile
1699         r = pakfire_path(build->pakfire, path, "/usr/src/packages/%s/%s.nm", nevra, name);
1700         if (r < 0)
1701                 return 1;
1702
1703         // Read makefile
1704         r = pakfire_read_makefile(parser, build->pakfire, path, &error);
1705         if (r) {
1706                 if (error) {
1707                         ERROR(build->pakfire, "Could not parse makefile %s: %s\n", path,
1708                                 pakfire_parser_error_get_message(error));
1709                 } else {
1710                         ERROR(build->pakfire, "Could not parse makefile %s: %m\n", path);
1711                 }
1712
1713                 goto ERROR;
1714         }
1715
1716         // Set BUILDROOT
1717         const char* buildroot = pakfire_relpath(build->pakfire, build->buildroot);
1718         if (buildroot)
1719                 pakfire_parser_set(*parser, NULL, "BUILDROOT", buildroot, 0);
1720
1721 ERROR:
1722         if (error)
1723                 pakfire_parser_error_unref(error);
1724
1725         return r;
1726 }
1727
1728 static int pakfire_build_perform(struct pakfire_build* build,
1729                 struct pakfire_parser* makefile) {
1730         int r;
1731
1732         // Prepare the build
1733         r = pakfire_build_stage(build, makefile, "prepare");
1734         if (r)
1735                 goto ERROR;
1736
1737         // Perform the build
1738         r = pakfire_build_stage(build, makefile, "build");
1739         if (r)
1740                 goto ERROR;
1741
1742         // Test the build
1743         if (!pakfire_build_has_flag(build, PAKFIRE_BUILD_DISABLE_TESTS)) {
1744                 r = pakfire_build_stage(build, makefile, "test");
1745                 if (r)
1746                         goto ERROR;
1747         }
1748
1749         // Install everything
1750         r = pakfire_build_stage(build, makefile, "install");
1751         if (r)
1752                 goto ERROR;
1753
1754         // Run post build checks
1755         r = pakfire_build_run_post_build_checks(build);
1756         if (r) {
1757                 ERROR(build->pakfire, "Post build checks failed\n");
1758                 goto ERROR;
1759         }
1760
1761         // Run post build scripts
1762         r = pakfire_build_run_post_build_scripts(build);
1763         if (r)
1764                 goto ERROR;
1765
1766         // Done!
1767         return 0;
1768
1769 ERROR:
1770         // Drop to a shell for debugging
1771         if (pakfire_build_has_flag(build, PAKFIRE_BUILD_INTERACTIVE))
1772                 pakfire_build_shell(build);
1773
1774         return r;
1775 }
1776
1777 static int __pakfire_build_unpackaged_file(struct pakfire* pakfire,
1778                 struct pakfire_file* file, void* p) {
1779         char* s = pakfire_file_dump(file, PAKFIRE_FILE_DUMP_FULL);
1780         if (s) {
1781                 ERROR(pakfire, "%s\n", s);
1782                 free(s);
1783         }
1784
1785         return 0;
1786 }
1787
1788 static int pakfire_build_check_unpackaged_files(struct pakfire_build* build) {
1789         struct pakfire_filelist* filelist = NULL;
1790         int r;
1791
1792         // Create a new filelist
1793         r = pakfire_filelist_create(&filelist, build->pakfire);
1794         if (r)
1795                 goto ERROR;
1796
1797         // Scan for all files in BUILDROOT
1798         r = pakfire_filelist_scan(filelist, build->buildroot, NULL, NULL);
1799         if (r)
1800                 goto ERROR;
1801
1802         if (!pakfire_filelist_is_empty(filelist)) {
1803                 ERROR(build->pakfire, "Unpackaged files found:\n");
1804
1805                 r = pakfire_filelist_walk(filelist, __pakfire_build_unpackaged_file, NULL);
1806                 if (r)
1807                         goto ERROR;
1808
1809                 // Report an error
1810                 r = 1;
1811         }
1812
1813 ERROR:
1814         if (filelist)
1815                 pakfire_filelist_unref(filelist);
1816
1817         return r;
1818 }
1819
1820 static int pakfire_build_install_package(struct pakfire* pakfire,
1821                 struct pakfire_package* pkg, void* p) {
1822         struct pakfire_request* request = (struct pakfire_request*)p;
1823
1824         return pakfire_request_add_package(request, PAKFIRE_REQ_INSTALL, pkg,
1825                 PAKFIRE_REQUEST_ESSENTIAL);
1826 }
1827
1828 static int pakfire_build_install_test(struct pakfire_build* build) {
1829         struct pakfire_request* request = NULL;
1830         struct pakfire_problem* problem = NULL;
1831         struct pakfire_solution* solution = NULL;
1832         const char* s = NULL;
1833         int r;
1834
1835         // Create a new request
1836         r = pakfire_request_create(&request, build->pakfire, 0);
1837         if (r)
1838                 goto ERROR;
1839
1840         // Add all packages
1841         r = pakfire_packagelist_walk(build->packages, pakfire_build_install_package, request);
1842
1843         // Solve the request
1844         r = pakfire_request_solve(request);
1845         switch (r) {
1846                 // All okay
1847                 case 0:
1848                         break;
1849
1850                 // Dependency Error
1851                 case 2:
1852                         ERROR(build->pakfire, "Install test failed:\n");
1853
1854                         // Walk through all problems
1855                         for (;;) {
1856                                 r = pakfire_request_next_problem(request, &problem);
1857                                 if (r)
1858                                         goto ERROR;
1859
1860                                 // There are no more problems
1861                                 if (!problem)
1862                                         break;
1863
1864                                 // Format the problem into something human-readable
1865                                 s = pakfire_problem_to_string(problem);
1866                                 if (!s)
1867                                         continue;
1868
1869                                 ERROR(build->pakfire, "  * %s\n", s);
1870
1871                                 // Walk through all solutions
1872                                 for (;;) {
1873                                         r = pakfire_problem_next_solution(problem, &solution);
1874                                         if (r)
1875                                                 goto ERROR;
1876
1877                                         // There are no more solutions
1878                                         if (!solution)
1879                                                 break;
1880
1881                                         // Format the solution into something human-readable
1882                                         s = pakfire_solution_to_string(solution);
1883                                         if (!s)
1884                                                 continue;
1885
1886                                         ERROR(build->pakfire, "    * %s\n", s);
1887                                 }
1888                         }
1889
1890                         break;
1891
1892                 // Any other errors
1893                 default:
1894                         goto ERROR;
1895         }
1896
1897 ERROR:
1898         if (r)
1899                 ERROR(build->pakfire, "Install test failed: %m\n");
1900         if (request)
1901                 pakfire_request_unref(request);
1902         if (problem)
1903                 pakfire_problem_unref(problem);
1904         if (solution)
1905                 pakfire_solution_unref(solution);
1906
1907         return r;
1908 }
1909
1910 static int pakfire_build_post_check(struct pakfire_build* build) {
1911         int r;
1912
1913         // Check for unpackaged files
1914         r = pakfire_build_check_unpackaged_files(build);
1915         if (r)
1916                 return r;
1917
1918         // Perform install test
1919         r = pakfire_build_install_test(build);
1920         if (r)
1921                 return r;
1922
1923         return 0;
1924 }
1925
1926 static int pakfire_build_copy_package(struct pakfire* pakfire,
1927                 struct pakfire_package* pkg, void* p) {
1928         struct pakfire_archive* archive = NULL;
1929         char path[PATH_MAX];
1930         int r;
1931
1932         const char* target = (const char*)p;
1933
1934         if (!target) {
1935                 errno = EINVAL;
1936                 return 1;
1937         }
1938
1939         // Fetch the package filename
1940         const char* filename = pakfire_package_get_string(pkg, PAKFIRE_PKG_FILENAME);
1941         if (!filename) {
1942                 r = 1;
1943                 goto ERROR;
1944         }
1945
1946         // Format the destination path
1947         r = pakfire_string_format(path, "%s/%s", target, filename);
1948         if (r)
1949                 goto ERROR;
1950
1951         // Open the archive
1952         archive = pakfire_package_get_archive(pkg);
1953         if (!archive) {
1954                 r = 1;
1955                 goto ERROR;
1956         }
1957
1958         // Copy it to its destination
1959         r = pakfire_archive_copy(archive, path);
1960         if (r)
1961                 goto ERROR;
1962
1963 ERROR:
1964         if (archive)
1965                 pakfire_archive_unref(archive);
1966
1967         return r;
1968 }
1969
1970 static int pakfire_build_copy_packages(struct pakfire_build* build) {
1971         struct pakfire_repo* local = NULL;
1972         int r = 0;
1973
1974         DEBUG(build->pakfire, "Copying built packages\n");
1975
1976         // Fetch local repository
1977         local = pakfire_get_repo(build->pakfire, PAKFIRE_REPO_LOCAL);
1978
1979         // Copy all packages to the target path
1980         if (*build->target) {
1981                 r = pakfire_packagelist_walk(build->packages,
1982                         pakfire_build_copy_package, build->target);
1983                 if (r)
1984                         goto ERROR;
1985         }
1986
1987         // If we have a local repository, we copy all packages to it
1988         if (local) {
1989                 const char* path = pakfire_repo_get_path(local);
1990                 if (path) {
1991                         r = pakfire_packagelist_walk(build->packages,
1992                                 pakfire_build_copy_package, (void*)path);
1993                         if (r)
1994                                 goto ERROR;
1995                 }
1996         }
1997
1998 ERROR:
1999         if (local)
2000                 pakfire_repo_unref(local);
2001
2002         return r;
2003 }
2004
2005 static int pakfire_build_install_source_package(
2006                 struct pakfire_build* build, struct pakfire_package* package) {
2007         struct pakfire_request* request = NULL;
2008         struct pakfire_transaction* transaction = NULL;
2009         int r;
2010
2011         // Create a new request
2012         r = pakfire_request_create(&request, build->pakfire, 0);
2013         if (r)
2014                 goto ERROR;
2015
2016         // Add the package
2017         r = pakfire_request_add_package(request, PAKFIRE_REQ_INSTALL, package,
2018                 PAKFIRE_REQUEST_ESSENTIAL);
2019         if (r)
2020                 goto ERROR;
2021
2022         // Solve the request
2023         r = pakfire_request_solve(request);
2024         if (r)
2025                 goto ERROR;
2026
2027         // Fetch the transaction
2028         r = pakfire_request_get_transaction(request, &transaction);
2029         if (r)
2030                 goto ERROR;
2031
2032         // Set how many packages have been changed
2033         const size_t changes = pakfire_transaction_count(transaction);
2034
2035         // Sanity check to see if we actually try to install anything
2036         if (!changes) {
2037                 ERROR(build->pakfire, "The source package did not get installed\n");
2038                 r = 1;
2039                 goto ERROR;
2040         }
2041
2042         // Run the transaction
2043         r = pakfire_transaction_run(transaction, 0);
2044         if (r)
2045                 goto ERROR;
2046
2047 ERROR:
2048         if (transaction)
2049                 pakfire_transaction_unref(transaction);
2050         if (request)
2051                 pakfire_request_unref(request);
2052
2053         return r;
2054 }
2055
2056 PAKFIRE_EXPORT int pakfire_build_exec(struct pakfire_build* build, const char* path) {
2057         struct pakfire_package* package = NULL;
2058         struct pakfire_parser* makefile = NULL;
2059         char* buildroot = NULL;
2060         char duration[TIME_STRING_MAX];
2061         int r;
2062
2063         // Set buildroot
2064         r = pakfire_path(build->pakfire, build->buildroot, "%s",
2065                 PAKFIRE_TMP_DIR "/pakfire-buildroot.XXXXXX");
2066         if (r)
2067                 goto ERROR;
2068
2069         // Open the source package
2070         r = pakfire_commandline_add(build->pakfire, path, &package);
2071         if (r)
2072                 goto ERROR;
2073
2074         const char* nevra = pakfire_package_get_string(package, PAKFIRE_PKG_NEVRA);
2075
2076         INFO(build->pakfire, "Building %s...\n", nevra);
2077
2078         // Initialize the build environment
2079         r = pakfire_build_init(build);
2080         if (r)
2081                 goto ERROR;
2082
2083         // Install the source package
2084         r = pakfire_build_install_source_package(build, package);
2085         if (r) {
2086                 ERROR(build->pakfire, "Could not install the source package: %m\n");
2087                 goto ERROR;
2088         }
2089
2090         // Create BUILDROOT
2091         buildroot = pakfire_mkdtemp(build->buildroot);
2092         if (!buildroot) {
2093                 ERROR(build->pakfire, "Could not create BUILDROOT: %m\n");
2094                 goto ERROR;
2095         }
2096
2097         // Open the makefile
2098         r = pakfire_build_read_makefile(build, &makefile, package);
2099         if (r)
2100                 goto ERROR;
2101
2102         // Perform the actual build
2103         r = pakfire_build_perform(build, makefile);
2104         if (r)
2105                 goto ERROR;
2106
2107         // Create the packages
2108         r = pakfire_build_packages(build, makefile);
2109         if (r) {
2110                 ERROR(build->pakfire, "Could not create packages: %m\n");
2111                 goto ERROR;
2112         }
2113
2114         // Perform post build checks
2115         r = pakfire_build_post_check(build);
2116         if (r)
2117                 goto ERROR;
2118
2119         // Copy packages to their destination
2120         r = pakfire_build_copy_packages(build);
2121         if (r)
2122                 goto ERROR;
2123
2124         // Log duration
2125         r = pakfire_format_time(duration, pakfire_build_duration(build));
2126         if (r)
2127                 goto ERROR;
2128
2129         INFO(build->pakfire, "Build successfully completed in %s\n", duration);
2130
2131 ERROR:
2132         if (makefile)
2133                 pakfire_parser_unref(makefile);
2134         if (package)
2135                 pakfire_package_unref(package);
2136
2137         // Cleanup buildroot
2138         if (buildroot)
2139                 pakfire_rmtree(buildroot, 0);
2140
2141         return r;
2142 }
2143
2144 /*
2145         Compatibility function to keep the legacy API.
2146 */
2147 PAKFIRE_EXPORT int pakfire_build(struct pakfire* pakfire, const char* path,
2148                 const char* target, const char* id, int flags) {
2149         struct pakfire_build* build = NULL;
2150         int r;
2151
2152         // Check if path is set
2153         if (!path) {
2154                 errno = EINVAL;
2155                 return 1;
2156         }
2157
2158         // Create a new build environment
2159         r = pakfire_build_create(&build, pakfire, id, flags);
2160         if (r)
2161                 goto ERROR;
2162
2163         // Set target
2164         if (target) {
2165                 r = pakfire_build_set_target(build, target);
2166                 if (r)
2167                         goto ERROR;
2168         }
2169
2170         // Run build
2171         r = pakfire_build_exec(build, path);
2172
2173 ERROR:
2174         if (build)
2175                 pakfire_build_unref(build);
2176
2177         return r;
2178 }
2179
2180 int pakfire_build_clean(struct pakfire* pakfire, int flags) {
2181         struct pakfire_repo* local = NULL;
2182         int r = 0;
2183
2184         // Fetch local repository
2185         local = pakfire_get_repo(pakfire, PAKFIRE_REPO_LOCAL);
2186         if (!local) {
2187                 ERROR(pakfire, "Could not find repository %s: %m\n", PAKFIRE_REPO_LOCAL);
2188                 goto ERROR;
2189         }
2190
2191         // Destroy everything in it
2192         r = pakfire_repo_clean(local, PAKFIRE_REPO_CLEAN_FLAGS_DESTROY);
2193         if (r)
2194                 goto ERROR;
2195
2196 ERROR:
2197         if (local)
2198                 pakfire_repo_unref(local);
2199
2200         return r;
2201 }
2202
2203 /*
2204         This is a convenience function that sets up a build environment and
2205         then drops the user into an interactive shell.
2206 */
2207 PAKFIRE_EXPORT int pakfire_shell(struct pakfire* pakfire, const char** packages, int flags) {
2208         struct pakfire_build* build = NULL;
2209         int r;
2210
2211         // Shells are always interactive
2212         flags |= PAKFIRE_BUILD_INTERACTIVE;
2213
2214         // Create a new build environment
2215         r = pakfire_build_create(&build, pakfire, NULL, flags);
2216         if (r) {
2217                 ERROR(pakfire, "Could not create build: %m\n");
2218                 goto ERROR;
2219         }
2220
2221         // Initialize the build environment
2222         r = pakfire_build_init(build);
2223         if (r)
2224                 goto ERROR;
2225
2226         // Install any additional packages
2227         if (packages) {
2228                 r = pakfire_install(build->pakfire, 0, 0, packages, NULL, 0, NULL, NULL, NULL);
2229                 if (r)
2230                         return r;
2231         }
2232
2233         // Run shell
2234         r = pakfire_build_shell(build);
2235
2236 ERROR:
2237         if (build)
2238                 pakfire_build_unref(build);
2239
2240         return r;
2241 }