package/busybox/patches/500-ipkg.patch

   1 Index: busybox-1.7.2/archival/Config.in
   2 ===================================================================
   3 --- busybox-1.7.2.orig/archival/Config.in       2007-10-04 17:12:34.094845964 +0200
   4 +++ busybox-1.7.2/archival/Config.in    2007-10-04 17:14:22.056998379 +0200
   5 @@ -121,6 +121,15 @@
   6           gzip is used to compress files.
   7           It's probably the most widely used UNIX compression program.
   8
   9 +config IPKG
  10 +       bool "ipkg"
  11 +       default n
  12 +       select MD5SUM
  13 +       select WGET
  14 +       select DIFF
  15 +       help
  16 +         ipkg is the itsy package management system.
  17 +
  18  config RPM2CPIO
  19         bool "rpm2cpio"
  20         default n
  21 Index: busybox-1.7.2/archival/dpkg.c
  22 ===================================================================
  23 --- busybox-1.7.2.orig/archival/dpkg.c  2007-10-04 17:12:34.102846422 +0200
  24 +++ busybox-1.7.2/archival/dpkg.c       2007-10-04 17:14:22.060998604 +0200
  25 @@ -1455,6 +1455,10 @@
  26         return ar_handle->sub_archive->buffer;
  27  }
  28
  29 +/*
  30 +
  31 +// moved to data_extract_all.c
  32 +
  33  static void data_extract_all_prefix(archive_handle_t *archive_handle)
  34  {
  35         char *name_ptr = archive_handle->file_header->name;
  36 @@ -1466,6 +1470,8 @@
  37         }
  38  }
  39
  40 +*/
  41 +
  42  static void unpack_package(deb_file_t *deb_file)
  43  {
  44         const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
  45 Index: busybox-1.7.2/archival/ipkg.c
  46 ===================================================================
  47 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
  48 +++ busybox-1.7.2/archival/ipkg.c       2007-10-04 17:14:22.084999973 +0200
  49 @@ -0,0 +1,26 @@
  50 +/* ipkg.c - the itsy package management system
  51 +
  52 +   Florina Boor
  53 +
  54 +   Copyright (C) 2003 kernel concepts
  55 +
  56 +   This program is free software; you can redistribute it and/or
  57 +   modify it under the terms of the GNU General Public License as
  58 +   published by the Free Software Foundation; either version 2, or (at
  59 +   your option) any later version.
  60 +
  61 +   This program is distributed in the hope that it will be useful, but
  62 +   WITHOUT ANY WARRANTY; without even the implied warranty of
  63 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  64 +   General Public License for more details.
  65 +
  66 +   ipkg command line frontend using libipkg
  67 +
  68 +*/
  69 +
  70 +#include "libipkg/libipkg.h"
  71 +
  72 +int ipkg_main(int argc, char **argv)
  73 +{
  74 +       return ipkg_op(argc, argv);
  75 +}
  76 Index: busybox-1.7.2/archival/Kbuild
  77 ===================================================================
  78 --- busybox-1.7.2.orig/archival/Kbuild  2007-10-04 17:12:34.110846879 +0200
  79 +++ busybox-1.7.2/archival/Kbuild       2007-10-04 17:14:22.109001341 +0200
  80 @@ -15,6 +15,7 @@
  81  lib-$(CONFIG_DPKG_DEB)         += dpkg_deb.o
  82  lib-$(CONFIG_GUNZIP)           += bbunzip.o
  83  lib-$(CONFIG_GZIP)             += gzip.o bbunzip.o
  84 +lib-$(CONFIG_IPKG)             += ipkg.o
  85  lib-$(CONFIG_RPM2CPIO)         += rpm2cpio.o
  86  lib-$(CONFIG_RPM)              += rpm.o
  87  lib-$(CONFIG_TAR)              += tar.o
  88 Index: busybox-1.7.2/archival/libipkg/args.c
  89 ===================================================================
  90 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
  91 +++ busybox-1.7.2/archival/libipkg/args.c       2007-10-04 17:14:22.145003392 +0200
  92 @@ -0,0 +1,242 @@
  93 +/* args.c - parse command-line args
  94 +
  95 +  Carl D. Worth
  96 +
  97 +  Copyright 2001 University of Southern California
  98 +
  99 +  This program is free software; you can redistribute it and/or modify
 100 +  it under the terms of the GNU General Public License as published by
 101 +  the Free Software Foundation; either version 2, or (at your option)
 102 +  any later version.
 103 +
 104 +  This program is distributed in the hope that it will be useful,
 105 +  but WITHOUT ANY WARRANTY; without even the implied warranty of
 106 +  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 107 +  GNU General Public License for more details.
 108 + */
 109 +
 110 +#include <getopt.h>
 111 +#include <stdlib.h>
 112 +#include <string.h>
 113 +#include <unistd.h>
 114 +
 115 +#include "ipkg.h"
 116 +#include "ipkg_message.h"
 117 +
 118 +#include "args.h"
 119 +#include "sprintf_alloc.h"
 120 +
 121 +#include "libbb.h"
 122 +
 123 +
 124 +static void print_version(void);
 125 +
 126 +enum long_args_opt
 127 +{
 128 +     ARGS_OPT_FORCE_DEFAULTS = 129,
 129 +     ARGS_OPT_FORCE_DEPENDS,
 130 +     ARGS_OPT_FORCE_OVERWRITE,
 131 +     ARGS_OPT_FORCE_DOWNGRADE,
 132 +     ARGS_OPT_FORCE_REINSTALL,
 133 +     ARGS_OPT_FORCE_REMOVAL_OF_DEPENDENT_PACKAGES,
 134 +     ARGS_OPT_FORCE_REMOVAL_OF_ESSENTIAL_PACKAGES,
 135 +     ARGS_OPT_FORCE_SPACE,
 136 +     ARGS_OPT_NOACTION,
 137 +     ARGS_OPT_NODEPS,
 138 +     ARGS_OPT_VERBOSE_WGET,
 139 +     ARGS_OPT_VERBOSITY,
 140 +     ARGS_OPT_MULTIPLE_PROVIDERS
 141 +};
 142 +
 143 +int args_init(args_t *args)
 144 +{
 145 +     char *conf_file_dir;
 146 +
 147 +     memset(args, 0, sizeof(args_t));
 148 +
 149 +     args->dest = ARGS_DEFAULT_DEST;
 150 +
 151 +     conf_file_dir = getenv("IPKG_CONF_DIR");
 152 +     if (conf_file_dir == NULL || conf_file_dir[0] == '\0') {
 153 +         conf_file_dir = ARGS_DEFAULT_CONF_FILE_DIR;
 154 +     }
 155 +     sprintf_alloc(&args->conf_file, "%s/%s", conf_file_dir,
 156 +                  ARGS_DEFAULT_CONF_FILE_NAME);
 157 +
 158 +     args->force_defaults = ARGS_DEFAULT_FORCE_DEFAULTS;
 159 +     args->force_depends = ARGS_DEFAULT_FORCE_DEPENDS;
 160 +     args->force_overwrite = ARGS_DEFAULT_FORCE_OVERWRITE;
 161 +     args->force_downgrade = ARGS_DEFAULT_FORCE_DOWNGRADE;
 162 +     args->force_reinstall = ARGS_DEFAULT_FORCE_REINSTALL;
 163 +     args->force_removal_of_dependent_packages = ARGS_DEFAULT_FORCE_REMOVAL_OF_DEPENDENT_PACKAGES;
 164 +     args->force_removal_of_essential_packages = ARGS_DEFAULT_FORCE_REMOVAL_OF_ESSENTIAL_PACKAGES;
 165 +     args->noaction = ARGS_DEFAULT_NOACTION;
 166 +     args->nodeps = ARGS_DEFAULT_NODEPS;
 167 +     args->verbose_wget = ARGS_DEFAULT_VERBOSE_WGET;
 168 +     args->verbosity = ARGS_DEFAULT_VERBOSITY;
 169 +     args->offline_root = ARGS_DEFAULT_OFFLINE_ROOT;
 170 +     args->offline_root_pre_script_cmd = ARGS_DEFAULT_OFFLINE_ROOT_PRE_SCRIPT_CMD;
 171 +     args->offline_root_post_script_cmd = ARGS_DEFAULT_OFFLINE_ROOT_POST_SCRIPT_CMD;
 172 +     args->multiple_providers = 0;
 173 +     args->nocheckfordirorfile = 0;
 174 +     args->noreadfeedsfile = 0;
 175 +
 176 +     return 1;
 177 +}
 178 +
 179 +void args_deinit(args_t *args)
 180 +{
 181 +     free(args->conf_file);
 182 +     args->conf_file = NULL;
 183 +}
 184 +
 185 +int args_parse(args_t *args, int argc, char *argv[])
 186 +{
 187 +     int c;
 188 +     int option_index = 0;
 189 +     int parse_err = 0;
 190 +     static struct option long_options[] = {
 191 +         {"query-all", 0, 0, 'A'},
 192 +         {"conf-file", 1, 0, 'f'},
 193 +         {"conf", 1, 0, 'f'},
 194 +         {"dest", 1, 0, 'd'},
 195 +         {"force-defaults", 0, 0, ARGS_OPT_FORCE_DEFAULTS},
 196 +         {"force_defaults", 0, 0, ARGS_OPT_FORCE_DEFAULTS},
 197 +         {"force-depends", 0, 0, ARGS_OPT_FORCE_DEPENDS},
 198 +         {"force_depends", 0, 0, ARGS_OPT_FORCE_DEPENDS},
 199 +         {"force-overwrite", 0, 0, ARGS_OPT_FORCE_OVERWRITE},
 200 +         {"force_overwrite", 0, 0, ARGS_OPT_FORCE_OVERWRITE},
 201 +         {"force_downgrade", 0, 0, ARGS_OPT_FORCE_DOWNGRADE},
 202 +         {"force-downgrade", 0, 0, ARGS_OPT_FORCE_DOWNGRADE},
 203 +         {"force-reinstall", 0, 0, ARGS_OPT_FORCE_REINSTALL},
 204 +         {"force_reinstall", 0, 0, ARGS_OPT_FORCE_REINSTALL},
 205 +         {"force-space", 0, 0, ARGS_OPT_FORCE_SPACE},
 206 +         {"force_space", 0, 0, ARGS_OPT_FORCE_SPACE},
 207 +         {"recursive", 0, 0,
 208 +          ARGS_OPT_FORCE_REMOVAL_OF_DEPENDENT_PACKAGES},
 209 +         {"force-removal-of-dependent-packages", 0, 0,
 210 +          ARGS_OPT_FORCE_REMOVAL_OF_DEPENDENT_PACKAGES},
 211 +         {"force_removal_of_dependent_packages", 0, 0,
 212 +          ARGS_OPT_FORCE_REMOVAL_OF_DEPENDENT_PACKAGES},
 213 +         {"force-removal-of-essential-packages", 0, 0,
 214 +          ARGS_OPT_FORCE_REMOVAL_OF_ESSENTIAL_PACKAGES},
 215 +         {"force_removal_of_essential_packages", 0, 0,
 216 +          ARGS_OPT_FORCE_REMOVAL_OF_ESSENTIAL_PACKAGES},
 217 +         {"multiple-providers", 0, 0, ARGS_OPT_MULTIPLE_PROVIDERS},
 218 +         {"multiple_providers", 0, 0, ARGS_OPT_MULTIPLE_PROVIDERS},
 219 +         {"noaction", 0, 0, ARGS_OPT_NOACTION},
 220 +         {"nodeps", 0, 0, ARGS_OPT_NODEPS},
 221 +         {"offline", 1, 0, 'o'},
 222 +         {"offline-root", 1, 0, 'o'},
 223 +         {"test", 0, 0, ARGS_OPT_NOACTION},
 224 +         {"tmp-dir", 1, 0, 't'},
 225 +         {"verbose-wget", 0, 0, ARGS_OPT_VERBOSE_WGET},
 226 +         {"verbose_wget", 0, 0, ARGS_OPT_VERBOSE_WGET},
 227 +         {"verbosity", 2, 0, 'V'},
 228 +         {"version", 0, 0, 'v'},
 229 +         {0, 0, 0, 0}
 230 +     };
 231 +
 232 +     while (1) {
 233 +         c = getopt_long_only(argc, argv, "Ad:f:no:t:vV:", long_options, &option_index);
 234 +         if (c == -1)
 235 +              break;
 236 +
 237 +         switch (c) {
 238 +         case 'A':
 239 +              args->query_all = 1;
 240 +              break;
 241 +         case 'd':
 242 +              args->dest = optarg;
 243 +              break;
 244 +         case 'f':
 245 +              free(args->conf_file);
 246 +              args->conf_file = strdup(optarg);
 247 +              break;
 248 +         case 'o':
 249 +              args->offline_root = optarg;
 250 +              break;
 251 +         case 'n':
 252 +              args->noaction = 1;
 253 +              break;
 254 +         case 't':
 255 +              args->tmp_dir = strdup(optarg);
 256 +              break;
 257 +         case 'v':
 258 +              print_version();
 259 +              exit(0);
 260 +         case 'V':
 261 +         case ARGS_OPT_VERBOSITY:
 262 +              if (optarg)
 263 +                   args->verbosity = atoi(optarg);
 264 +              else
 265 +                   args->verbosity += 1;
 266 +              break;
 267 +         case ARGS_OPT_FORCE_DEFAULTS:
 268 +              args->force_defaults = 1;
 269 +              break;
 270 +         case ARGS_OPT_FORCE_DEPENDS:
 271 +              args->force_depends = 1;
 272 +              break;
 273 +         case ARGS_OPT_FORCE_OVERWRITE:
 274 +              args->force_overwrite = 1;
 275 +              break;
 276 +         case ARGS_OPT_FORCE_DOWNGRADE:
 277 +              args->force_downgrade = 1;
 278 +              break;
 279 +         case ARGS_OPT_FORCE_REINSTALL:
 280 +              args->force_reinstall = 1;
 281 +              break;
 282 +         case ARGS_OPT_FORCE_REMOVAL_OF_ESSENTIAL_PACKAGES:
 283 +              args->force_removal_of_essential_packages = 1;
 284 +              break;
 285 +         case ARGS_OPT_FORCE_REMOVAL_OF_DEPENDENT_PACKAGES:
 286 +              args->force_removal_of_dependent_packages = 1;
 287 +              break;
 288 +         case ARGS_OPT_FORCE_SPACE:
 289 +              args->force_space = 1;
 290 +              break;
 291 +         case ARGS_OPT_VERBOSE_WGET:
 292 +              args->verbose_wget = 1;
 293 +              break;
 294 +         case ARGS_OPT_MULTIPLE_PROVIDERS:
 295 +              args->multiple_providers = 1;
 296 +              break;
 297 +         case ARGS_OPT_NODEPS:
 298 +              args->nodeps = 1;
 299 +              break;
 300 +         case ARGS_OPT_NOACTION:
 301 +              args->noaction = 1;
 302 +              break;
 303 +         case ':':
 304 +              parse_err++;
 305 +              break;
 306 +         case '?':
 307 +              parse_err++;
 308 +              break;
 309 +         default:
 310 +              bb_error_msg("Confusion: getopt_long returned %d\n", c);
 311 +         }
 312 +     }
 313 +
 314 +     if (parse_err) {
 315 +         return -parse_err;
 316 +     } else {
 317 +         return optind;
 318 +     }
 319 +}
 320 +
 321 +void args_usage(char *complaint)
 322 +{
 323 +     if (complaint) {
 324 +          bb_error_msg("%s\n", complaint);
 325 +     }
 326 +     print_version();
 327 +     bb_show_usage();
 328 +     exit(1);
 329 +}
 330 +
 331 +static void print_version(void)
 332 +{
 333 +       bb_error_msg("version %s\n", IPKG_VERSION);
 334 +}
 335 Index: busybox-1.7.2/archival/libipkg/args.h
 336 ===================================================================
 337 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 338 +++ busybox-1.7.2/archival/libipkg/args.h       2007-10-04 17:14:22.173004992 +0200
 339 @@ -0,0 +1,72 @@
 340 +/* args.h - parse command-line args
 341 +
 342 +  Carl D. Worth
 343 +
 344 +  Copyright 2001 University of Southern California
 345 +
 346 +  This program is free software; you can redistribute it and/or modify
 347 +  it under the terms of the GNU General Public License as published by
 348 +  the Free Software Foundation; either version 2, or (at your option)
 349 +  any later version.
 350 +
 351 +  This program is distributed in the hope that it will be useful,
 352 +  but WITHOUT ANY WARRANTY; without even the implied warranty of
 353 +  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 354 +  GNU General Public License for more details.
 355 +*/
 356 +
 357 +#ifndef ARGS_H
 358 +#define ARGS_H
 359 +
 360 +struct args
 361 +{
 362 +    char *conf_file;
 363 +    char *dest;
 364 +    char *tmp_dir;
 365 +    int force_defaults;
 366 +    int force_depends;
 367 +    int force_overwrite;
 368 +    int force_downgrade;
 369 +    int force_reinstall;
 370 +    int force_removal_of_essential_packages;
 371 +    int force_removal_of_dependent_packages;
 372 +    int force_space;
 373 +    int noaction;
 374 +    int nodeps;
 375 +    int multiple_providers;
 376 +    int query_all;
 377 +    int verbose_wget;
 378 +    int verbosity;
 379 +    int nocheckfordirorfile;
 380 +    int noreadfeedsfile;
 381 +    char *offline_root;
 382 +    char *offline_root_pre_script_cmd;
 383 +    char *offline_root_post_script_cmd;
 384 +};
 385 +typedef struct args args_t;
 386 +
 387 +#define ARGS_DEFAULT_CONF_FILE_DIR "/etc"
 388 +#define ARGS_DEFAULT_CONF_FILE_NAME "ipkg.conf"
 389 +#define ARGS_DEFAULT_DEST NULL
 390 +#define ARGS_DEFAULT_FORCE_DEFAULTS 0
 391 +#define ARGS_DEFAULT_FORCE_DEPENDS 0
 392 +#define ARGS_DEFAULT_FORCE_OVERWRITE 0
 393 +#define ARGS_DEFAULT_FORCE_DOWNGRADE 0
 394 +#define ARGS_DEFAULT_FORCE_REINSTALL 0
 395 +#define ARGS_DEFAULT_FORCE_REMOVAL_OF_ESSENTIAL_PACKAGES 0
 396 +#define ARGS_DEFAULT_FORCE_REMOVAL_OF_DEPENDENT_PACKAGES 0
 397 +#define ARGS_DEFAULT_FORCE_SPACE 0
 398 +#define ARGS_DEFAULT_OFFLINE_ROOT NULL
 399 +#define ARGS_DEFAULT_OFFLINE_ROOT_PRE_SCRIPT_CMD NULL
 400 +#define ARGS_DEFAULT_OFFLINE_ROOT_POST_SCRIPT_CMD NULL
 401 +#define ARGS_DEFAULT_NOACTION 0
 402 +#define ARGS_DEFAULT_NODEPS 0
 403 +#define ARGS_DEFAULT_VERBOSE_WGET 0
 404 +#define ARGS_DEFAULT_VERBOSITY 1
 405 +
 406 +int args_init(args_t *args);
 407 +void args_deinit(args_t *args);
 408 +int args_parse(args_t *args, int argc, char *argv[]);
 409 +void args_usage(char *complaint);
 410 +
 411 +#endif
 412 Index: busybox-1.7.2/archival/libipkg/conffile.c
 413 ===================================================================
 414 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 415 +++ busybox-1.7.2/archival/libipkg/conffile.c   2007-10-04 17:14:22.249009320 +0200
 416 @@ -0,0 +1,64 @@
 417 +/* conffile.c - the itsy package management system
 418 +
 419 +   Carl D. Worth
 420 +
 421 +   Copyright (C) 2001 University of Southern California
 422 +
 423 +   This program is free software; you can redistribute it and/or
 424 +   modify it under the terms of the GNU General Public License as
 425 +   published by the Free Software Foundation; either version 2, or (at
 426 +   your option) any later version.
 427 +
 428 +   This program is distributed in the hope that it will be useful, but
 429 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 430 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 431 +   General Public License for more details.
 432 +*/
 433 +
 434 +#include <string.h>
 435 +#include <stdlib.h>
 436 +
 437 +#include "ipkg.h"
 438 +#include "ipkg_message.h"
 439 +
 440 +#include "conffile.h"
 441 +#include "file_util.h"
 442 +#include "sprintf_alloc.h"
 443 +
 444 +int conffile_init(conffile_t *conffile, const char *file_name, const char *md5sum)
 445 +{
 446 +    return nv_pair_init(conffile, file_name, md5sum);
 447 +}
 448 +
 449 +void conffile_deinit(conffile_t *conffile)
 450 +{
 451 +    nv_pair_deinit(conffile);
 452 +}
 453 +
 454 +int conffile_has_been_modified(ipkg_conf_t *conf, conffile_t *conffile)
 455 +{
 456 +    char *md5sum;
 457 +    char *filename = conffile->name;
 458 +    char *root_filename;
 459 +    int ret;
 460 +
 461 +    if (conffile->value == NULL) {
 462 +        ipkg_message(conf, IPKG_NOTICE, "%s: conffile %s has no md5sum\n", __FUNCTION__, conffile->name);
 463 +        return 1;
 464 +    }
 465 +
 466 +    root_filename = root_filename_alloc(conf, filename);
 467 +
 468 +    md5sum = file_md5sum_alloc(root_filename);
 469 +
 470 +    ret = strcmp(md5sum, conffile->value);
 471 +    if (ret) {
 472 +      ipkg_message(conf, IPKG_NOTICE, "%s: conffile %s: \t\nold md5=%s \t\nnew md5=%s\n", __FUNCTION__,
 473 +              conffile->name, md5sum, conffile->value);
 474 +    }
 475 +
 476 +    free(root_filename);
 477 +    free(md5sum);
 478 +
 479 +    return ret;
 480 +}
 481 Index: busybox-1.7.2/archival/libipkg/conffile.h
 482 ===================================================================
 483 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 484 +++ busybox-1.7.2/archival/libipkg/conffile.h   2007-10-04 17:14:22.277010917 +0200
 485 @@ -0,0 +1,30 @@
 486 +/* conffile.h - the itsy package management system
 487 +
 488 +   Carl D. Worth
 489 +
 490 +   Copyright (C) 2001 University of Southern California
 491 +
 492 +   This program is free software; you can redistribute it and/or
 493 +   modify it under the terms of the GNU General Public License as
 494 +   published by the Free Software Foundation; either version 2, or (at
 495 +   your option) any later version.
 496 +
 497 +   This program is distributed in the hope that it will be useful, but
 498 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 499 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 500 +   General Public License for more details.
 501 +*/
 502 +
 503 +#ifndef CONFFILE_H
 504 +#define CONFFILE_H
 505 +
 506 +#include "nv_pair.h"
 507 +
 508 +typedef struct nv_pair conffile_t;
 509 +
 510 +int conffile_init(conffile_t *conffile, const char *file_name, const char *md5sum);
 511 +void conffile_deinit(conffile_t *conffile);
 512 +int conffile_has_been_modified(struct ipkg_conf *conf, conffile_t *conffile);
 513 +
 514 +#endif
 515 +
 516 Index: busybox-1.7.2/archival/libipkg/conffile_list.c
 517 ===================================================================
 518 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 519 +++ busybox-1.7.2/archival/libipkg/conffile_list.c      2007-10-04 17:14:22.301012282 +0200
 520 @@ -0,0 +1,47 @@
 521 +/* conffile_list.c - the itsy package management system
 522 +
 523 +   Carl D. Worth
 524 +
 525 +   Copyright (C) 2001 University of Southern California
 526 +
 527 +   This program is free software; you can redistribute it and/or
 528 +   modify it under the terms of the GNU General Public License as
 529 +   published by the Free Software Foundation; either version 2, or (at
 530 +   your option) any later version.
 531 +
 532 +   This program is distributed in the hope that it will be useful, but
 533 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 534 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 535 +   General Public License for more details.
 536 +*/
 537 +
 538 +#include "ipkg.h"
 539 +
 540 +#include "conffile_list.h"
 541 +
 542 +int conffile_list_init(conffile_list_t *list)
 543 +{
 544 +    return nv_pair_list_init(list);
 545 +}
 546 +
 547 +void conffile_list_deinit(conffile_list_t *list)
 548 +{
 549 +    nv_pair_list_deinit(list);
 550 +}
 551 +
 552 +conffile_t *conffile_list_append(conffile_list_t *list, const char *file_name,
 553 +                        const char *md5sum)
 554 +{
 555 +    return nv_pair_list_append(list, file_name, md5sum);
 556 +}
 557 +
 558 +int conffile_list_push(conffile_list_t *list, conffile_t *data)
 559 +{
 560 +    return nv_pair_list_push(list, data);
 561 +}
 562 +
 563 +conffile_list_elt_t *conffile_list_pop(conffile_list_t *list)
 564 +{
 565 +    return nv_pair_list_pop(list);
 566 +}
 567 +
 568 Index: busybox-1.7.2/archival/libipkg/conffile_list.h
 569 ===================================================================
 570 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 571 +++ busybox-1.7.2/archival/libipkg/conffile_list.h      2007-10-04 17:14:22.325013650 +0200
 572 @@ -0,0 +1,36 @@
 573 +/* conffile_list.h - the itsy package management system
 574 +
 575 +   Carl D. Worth
 576 +
 577 +   Copyright (C) 2001 University of Southern California
 578 +
 579 +   This program is free software; you can redistribute it and/or
 580 +   modify it under the terms of the GNU General Public License as
 581 +   published by the Free Software Foundation; either version 2, or (at
 582 +   your option) any later version.
 583 +
 584 +   This program is distributed in the hope that it will be useful, but
 585 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 586 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 587 +   General Public License for more details.
 588 +*/
 589 +
 590 +#ifndef CONFFILE_LIST_H
 591 +#define CONFFILE_LIST_H
 592 +
 593 +#include "conffile.h"
 594 +#include "nv_pair_list.h"
 595 +
 596 +typedef struct nv_pair_list_elt conffile_list_elt_t;
 597 +typedef struct nv_pair_list conffile_list_t;
 598 +
 599 +int conffile_list_init(conffile_list_t *list);
 600 +void conffile_list_deinit(conffile_list_t *list);
 601 +
 602 +conffile_t *conffile_list_append(conffile_list_t *list, const char *name,
 603 +                              const char *root_dir);
 604 +int conffile_list_push(conffile_list_t *list, conffile_t *data);
 605 +conffile_list_elt_t *conffile_list_pop(conffile_list_t *list);
 606 +
 607 +#endif
 608 +
 609 Index: busybox-1.7.2/archival/libipkg/file_util.c
 610 ===================================================================
 611 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 612 +++ busybox-1.7.2/archival/libipkg/file_util.c  2007-10-04 17:14:22.353015250 +0200
 613 @@ -0,0 +1,132 @@
 614 +/* file_util.c - convenience routines for common stat operations
 615 +
 616 +   Carl D. Worth
 617 +
 618 +   Copyright (C) 2001 University of Southern California
 619 +
 620 +   This program is free software; you can redistribute it and/or
 621 +   modify it under the terms of the GNU General Public License as
 622 +   published by the Free Software Foundation; either version 2, or (at
 623 +   your option) any later version.
 624 +
 625 +   This program is distributed in the hope that it will be useful, but
 626 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 627 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 628 +   General Public License for more details.
 629 +*/
 630 +
 631 +#include "ipkg.h"
 632 +#include <sys/types.h>
 633 +#include <sys/stat.h>
 634 +
 635 +#include "sprintf_alloc.h"
 636 +#include "file_util.h"
 637 +#include "libbb.h"
 638 +#undef strlen
 639 +
 640 +int file_exists(const char *file_name)
 641 +{
 642 +    int err;
 643 +    struct stat stat_buf;
 644 +
 645 +    err = stat(file_name, &stat_buf);
 646 +    if (err == 0) {
 647 +       return 1;
 648 +    } else {
 649 +       return 0;
 650 +    }
 651 +}
 652 +
 653 +int file_is_dir(const char *file_name)
 654 +{
 655 +    int err;
 656 +    struct stat stat_buf;
 657 +
 658 +    err = stat(file_name, &stat_buf);
 659 +    if (err) {
 660 +       return 0;
 661 +    }
 662 +
 663 +    return S_ISDIR(stat_buf.st_mode);
 664 +}
 665 +
 666 +/* read a single line from a file, stopping at a newline or EOF.
 667 +   If a newline is read, it will appear in the resulting string.
 668 +   Return value is a malloc'ed char * which should be freed at
 669 +   some point by the caller.
 670 +
 671 +   Return value is NULL if the file is at EOF when called.
 672 +*/
 673 +#define FILE_READ_LINE_BUF_SIZE 1024
 674 +char *file_read_line_alloc(FILE *file)
 675 +{
 676 +    char buf[FILE_READ_LINE_BUF_SIZE];
 677 +    int buf_len;
 678 +    char *line = NULL;
 679 +    int line_size = 0;
 680 +
 681 +    memset(buf, 0, FILE_READ_LINE_BUF_SIZE);
 682 +    while (fgets(buf, FILE_READ_LINE_BUF_SIZE, file)) {
 683 +       buf_len = strlen(buf);
 684 +       if (line) {
 685 +           line_size += buf_len;
 686 +           line = realloc(line, line_size);
 687 +           if (line == NULL) {
 688 +               fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
 689 +               break;
 690 +           }
 691 +           strcat(line, buf);
 692 +       } else {
 693 +           line_size = buf_len + 1;
 694 +           line = strdup(buf);
 695 +       }
 696 +       if (buf[buf_len - 1] == '\n') {
 697 +           break;
 698 +       }
 699 +    }
 700 +
 701 +    return line;
 702 +}
 703 +
 704 +int file_move(const char *src, const char *dest)
 705 +{
 706 +    int err;
 707 +
 708 +    err = rename(src, dest);
 709 +
 710 +    if (err && errno == EXDEV) {
 711 +       err = file_copy(src, dest);
 712 +       unlink(src);
 713 +    } else if (err) {
 714 +       fprintf(stderr, "%s: ERROR: failed to rename %s to %s: %s\n",
 715 +               __FUNCTION__, src, dest, strerror(errno));
 716 +    }
 717 +
 718 +    return err;
 719 +}
 720 +
 721 +/* I put these here to keep libbb dependencies from creeping all over
 722 +   the ipkg code */
 723 +int file_copy(const char *src, const char *dest)
 724 +{
 725 +    int err;
 726 +
 727 +    err = copy_file(src, dest, FILEUTILS_FORCE | FILEUTILS_PRESERVE_STATUS);
 728 +    if (err) {
 729 +       fprintf(stderr, "%s: ERROR: failed to copy %s to %s\n",
 730 +               __FUNCTION__, src, dest);
 731 +    }
 732 +
 733 +    return err;
 734 +}
 735 +
 736 +int file_mkdir_hier(const char *path, long mode)
 737 +{
 738 +    return bb_make_directory((char *)path, mode, FILEUTILS_RECUR);
 739 +}
 740 +
 741 +char *file_md5sum_alloc(const char *file_name)
 742 +{
 743 +       return hash_file(file_name, HASH_MD5);
 744 +}
 745 +
 746 Index: busybox-1.7.2/archival/libipkg/file_util.h
 747 ===================================================================
 748 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 749 +++ busybox-1.7.2/archival/libipkg/file_util.h  2007-10-04 17:14:22.377016616 +0200
 750 @@ -0,0 +1,29 @@
 751 +/* file_util.h - convenience routines for common file operations
 752 +
 753 +   Carl D. Worth
 754 +
 755 +   Copyright (C) 2001 University of Southern California
 756 +
 757 +   This program is free software; you can redistribute it and/or
 758 +   modify it under the terms of the GNU General Public License as
 759 +   published by the Free Software Foundation; either version 2, or (at
 760 +   your option) any later version.
 761 +
 762 +   This program is distributed in the hope that it will be useful, but
 763 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 764 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 765 +   General Public License for more details.
 766 +*/
 767 +
 768 +#ifndef FILE_UTIL_H
 769 +#define FILE_UTIL_H
 770 +
 771 +int file_exists(const char *file_name);
 772 +int file_is_dir(const char *file_name);
 773 +char *file_read_line_alloc(FILE *file);
 774 +int file_move(const char *src, const char *dest);
 775 +int file_copy(const char *src, const char *dest);
 776 +int file_mkdir_hier(const char *path, long mode);
 777 +char *file_md5sum_alloc(const char *file_name);
 778 +
 779 +#endif
 780 Index: busybox-1.7.2/archival/libipkg/hash_table.c
 781 ===================================================================
 782 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 783 +++ busybox-1.7.2/archival/libipkg/hash_table.c 2007-10-04 17:14:22.397017756 +0200
 784 @@ -0,0 +1,155 @@
 785 +/* hash.c - hash tables for ipkg
 786 +
 787 +   Steven M. Ayer, Jamey Hicks
 788 +
 789 +   Copyright (C) 2002 Compaq Computer Corporation
 790 +
 791 +   This program is free software; you can redistribute it and/or
 792 +   modify it under the terms of the GNU General Public License as
 793 +   published by the Free Software Foundation; either version 2, or (at
 794 +   your option) any later version.
 795 +
 796 +   This program is distributed in the hope that it will be useful, but
 797 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 798 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 799 +   General Public License for more details.
 800 +*/
 801 +
 802 +#include <errno.h>
 803 +#include <stdio.h>
 804 +#include <stdlib.h>
 805 +#include <string.h>
 806 +#include "hash_table.h"
 807 +#include "ipkg_message.h"
 808 +
 809 +
 810 +static int hash_index(hash_table_t *hash, const char *pkg_name);
 811 +static int rotating(const char *key, int len, int prime);
 812 +
 813 +static int hash_index(hash_table_t *hash, const char *pkg_name)
 814 +{
 815 +    return rotating(pkg_name, strlen(pkg_name), hash->n_entries);
 816 +}
 817 +
 818 +static int rotating(const char *key, int len, int prime)
 819 +{
 820 +    unsigned int hash, i;
 821 +    for (hash=len, i=0; i<len; ++i)
 822 +       hash = (hash<<4)^(hash>>28)^key[i];
 823 +    return (hash % prime);
 824 +}
 825 +
 826 +
 827 +/*
 828 + * this is an open table keyed by strings
 829 + */
 830 +int hash_table_init(const char *name, hash_table_t *hash, int len)
 831 +{
 832 +    static int primes_table[] = {
 833 +       379, 761, 983, 1423, 2711, 3361, 3931, 4679, 5519, 6701, 9587,
 834 +       19471, 23143, 33961, 46499, 49727, 99529, 0
 835 +    };
 836 +    int *picker;
 837 +
 838 +    if (hash->entries != NULL) {
 839 +       /* we have been here already */
 840 +       return 0;
 841 +    }
 842 +
 843 +    hash->name = name;
 844 +    hash->entries = NULL;
 845 +    hash->n_entries = 0;
 846 +    hash->hash_entry_key = NULL;
 847 +
 848 +    picker = primes_table;
 849 +    while(*picker && (*picker++ < len));
 850 +    if(!*picker)
 851 +       fprintf(stderr, "%s: primes table might not be big enough (! << %d)\n", __FUNCTION__, len);
 852 +    --picker;
 853 +
 854 +    hash->n_entries = *picker;
 855 +    hash->entries = (hash_entry_t *)calloc(hash->n_entries, sizeof(hash_entry_t));
 856 +    if (hash->entries == NULL) {
 857 +       fprintf(stderr, "%s: Out of memory.\n", __FUNCTION__);
 858 +       return ENOMEM;
 859 +    }
 860 +    return 0;
 861 +}
 862 +
 863 +void hash_table_deinit(hash_table_t *hash)
 864 +{
 865 +    free(hash->entries);
 866 +    hash->entries = NULL;
 867 +    hash->n_entries = 0;
 868 +}
 869 +
 870 +void *hash_table_get(hash_table_t *hash, const char *key)
 871 +{
 872 +  int ndx= hash_index(hash, key);
 873 +  hash_entry_t *hash_entry = hash->entries + ndx;
 874 +  while (hash_entry)
 875 +  {
 876 +    if (hash_entry->key)
 877 +    {
 878 +      if (strcmp(key, hash_entry->key) == 0) {
 879 +         // ipkg_message(NULL, IPKG_DEBUG, "Function: %s. Key found for '%s' \n", __FUNCTION__, key);
 880 +        return hash_entry->data;
 881 +      }
 882 +    }
 883 +    hash_entry = hash_entry->next;
 884 +  }
 885 +  return NULL;
 886 +}
 887 +
 888 +int hash_table_insert(hash_table_t *hash, const char *key, void *value)
 889 +{
 890 +     int ndx= hash_index(hash, key);
 891 +     hash_entry_t *hash_entry = hash->entries + ndx;
 892 +     if (0) ipkg_message(NULL, IPKG_DEBUG2, "Function: %s. Inserting in hash for '%s' \n", __FUNCTION__, key);
 893 +     if (hash_entry->key) {
 894 +         if (strcmp(hash_entry->key, key) == 0) {
 895 +              /* alread in table, update the value */
 896 +               if (0) ipkg_message(NULL, IPKG_DEBUG2, "Function: %s. Value already in hash for '%s' \n", __FUNCTION__, key);
 897 +              hash_entry->data = value;
 898 +              return 0;
 899 +         } else {
 900 +              /*
 901 +               * if this is a collision, we have to go to the end of the ll,
 902 +               * then add a new entry
 903 +               * before we can hook up the value
 904 +               */
 905 +               if (0) ipkg_message(NULL, IPKG_DEBUG2, "Function: %s. Value already in hash by collision for '%s' \n", __FUNCTION__, key);
 906 +              while (hash_entry->next)
 907 +                   hash_entry = hash_entry->next;
 908 +              hash_entry->next = (hash_entry_t *)malloc(sizeof(hash_entry_t));
 909 +              if (!hash_entry->next) {
 910 +                   return -ENOMEM;
 911 +              }
 912 +              hash_entry = hash_entry->next;
 913 +              hash_entry->next = NULL;
 914 +         }
 915 +     }
 916 +     hash->n_elements++;
 917 +     hash_entry->key = strdup(key);
 918 +     hash_entry->data = value;
 919 +
 920 +     return 0;
 921 +}
 922 +
 923 +
 924 +void hash_table_foreach(hash_table_t *hash, void (*f)(const char *key, void *entry, void *data), void *data)
 925 +{
 926 +    int i;
 927 +    if (!hash || !f)
 928 +       return;
 929 +
 930 +    for (i = 0; i < hash->n_entries; i++) {
 931 +       hash_entry_t *hash_entry = (hash->entries + i);
 932 +       do {
 933 +           if(hash_entry->key) {
 934 +               f(hash_entry->key, hash_entry->data, data);
 935 +           }
 936 +       } while((hash_entry = hash_entry->next));
 937 +    }
 938 +}
 939 +
 940 Index: busybox-1.7.2/archival/libipkg/hash_table.h
 941 ===================================================================
 942 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 943 +++ busybox-1.7.2/archival/libipkg/hash_table.h 2007-10-04 17:14:22.425019349 +0200
 944 @@ -0,0 +1,44 @@
 945 +/* hash.h - hash tables for ipkg
 946 +
 947 +   Steven M. Ayer, Jamey Hicks
 948 +
 949 +   Copyright (C) 2002 Compaq Computer Corporation
 950 +
 951 +   This program is free software; you can redistribute it and/or
 952 +   modify it under the terms of the GNU General Public License as
 953 +   published by the Free Software Foundation; either version 2, or (at
 954 +   your option) any later version.
 955 +
 956 +   This program is distributed in the hope that it will be useful, but
 957 +   WITHOUT ANY WARRANTY; without even the implied warranty of
 958 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 959 +   General Public License for more details.
 960 +*/
 961 +
 962 +#ifndef _HASH_TABLE_H_
 963 +#define _HASH_TABLE_H_
 964 +
 965 +typedef struct hash_entry hash_entry_t;
 966 +typedef struct hash_table hash_table_t;
 967 +
 968 +struct hash_entry {
 969 +  const char * key;
 970 +  void * data;
 971 +  struct hash_entry * next;
 972 +};
 973 +
 974 +struct hash_table {
 975 +  const char *name;
 976 +  hash_entry_t * entries;
 977 +  int n_entries; /* number of buckets */
 978 +  int n_elements;
 979 +  const char * (*hash_entry_key)(void * data);
 980 +};
 981 +
 982 +int hash_table_init(const char *name, hash_table_t *hash, int len);
 983 +void hash_table_deinit(hash_table_t *hash);
 984 +void *hash_table_get(hash_table_t *hash, const char *key);
 985 +int hash_table_insert(hash_table_t *hash, const char *key, void *value);
 986 +void hash_table_foreach(hash_table_t *hash, void (*f)(const char *key, void *entry, void *data), void *data);
 987 +
 988 +#endif /* _HASH_TABLE_H_ */
 989 Index: busybox-1.7.2/archival/libipkg/ipkg_cmd.c
 990 ===================================================================
 991 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 992 +++ busybox-1.7.2/archival/libipkg/ipkg_cmd.c   2007-10-04 17:14:22.449020718 +0200
 993 @@ -0,0 +1,1431 @@
 994 +/* ipkg_cmd.c - the itsy package management system
 995 +
 996 +   Carl D. Worth
 997 +
 998 +   Copyright (C) 2001 University of Southern California
 999 +
1000 +   This program is free software; you can redistribute it and/or
1001 +   modify it under the terms of the GNU General Public License as
1002 +   published by the Free Software Foundation; either version 2, or (at
1003 +   your option) any later version.
1004 +
1005 +   This program is distributed in the hope that it will be useful, but
1006 +   WITHOUT ANY WARRANTY; without even the implied warranty of
1007 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1008 +   General Public License for more details.
1009 +*/
1010 +
1011 +#include <string.h>
1012 +
1013 +#include "ipkg.h"
1014 +#include <libgen.h>
1015 +#include <glob.h>
1016 +#include <errno.h>
1017 +#include <stdlib.h>
1018 +#include <unistd.h>
1019 +#include <signal.h>
1020 +#include <stdio.h>
1021 +#include <dirent.h>
1022 +
1023 +#include "ipkg_conf.h"
1024 +#include "ipkg_cmd.h"
1025 +#include "ipkg_message.h"
1026 +#include "pkg.h"
1027 +#include "pkg_dest.h"
1028 +#include "pkg_parse.h"
1029 +#include "sprintf_alloc.h"
1030 +#include "pkg.h"
1031 +#include "file_util.h"
1032 +#include "str_util.h"
1033 +#include "libbb.h"
1034 +#include "unarchive.h"
1035 +
1036 +#include <fnmatch.h>
1037 +
1038 +
1039 +#include "ipkg_download.h"
1040 +#include "ipkg_install.h"
1041 +#include "ipkg_upgrade.h"
1042 +#include "ipkg_remove.h"
1043 +#include "ipkg_configure.h"
1044 +#include "ipkg_message.h"
1045 +
1046 +#ifdef IPKG_LIB
1047 +#include "libipkg.h"
1048 +static void *p_userdata = NULL;
1049 +#endif
1050 +
1051 +static int ipkg_update_cmd(ipkg_conf_t *conf, int argc, char **argv);
1052 +static int ipkg_upgrade_cmd(ipkg_conf_t *conf, int argc, char **argv);
1053 +static int ipkg_list_cmd(ipkg_conf_t *conf, int argc, char **argv);
1054 +static int ipkg_info_cmd(ipkg_conf_t *conf, int argc, char **argv);
1055 +static int ipkg_status_cmd(ipkg_conf_t *conf, int argc, char **argv);
1056 +static int ipkg_install_pending_cmd(ipkg_conf_t *conf, int argc, char **argv);
1057 +static int ipkg_install_cmd(ipkg_conf_t *conf, int argc, char **argv);
1058 +static int ipkg_list_installed_cmd(ipkg_conf_t *conf, int argc, char **argv);
1059 +static int ipkg_remove_cmd(ipkg_conf_t *conf, int argc, char **argv);
1060 +static int ipkg_purge_cmd(ipkg_conf_t *conf, int argc, char **argv);
1061 +static int ipkg_flag_cmd(ipkg_conf_t *conf, int argc, char **argv);
1062 +static int ipkg_files_cmd(ipkg_conf_t *conf, int argc, char **argv);
1063 +static int ipkg_search_cmd(ipkg_conf_t *conf, int argc, char **argv);
1064 +static int ipkg_download_cmd(ipkg_conf_t *conf, int argc, char **argv);
1065 +static int ipkg_depends_cmd(ipkg_conf_t *conf, int argc, char **argv);
1066 +static int ipkg_whatdepends_cmd(ipkg_conf_t *conf, int argc, char **argv);
1067 +static int ipkg_whatdepends_recursively_cmd(ipkg_conf_t *conf, int argc, char **argv);
1068 +static int ipkg_whatsuggests_cmd(ipkg_conf_t *conf, int argc, char **argv);
1069 +static int ipkg_whatrecommends_cmd(ipkg_conf_t *conf, int argc, char **argv);
1070 +static int ipkg_whatprovides_cmd(ipkg_conf_t *conf, int argc, char **argv);
1071 +static int ipkg_whatconflicts_cmd(ipkg_conf_t *conf, int argc, char **argv);
1072 +static int ipkg_whatreplaces_cmd(ipkg_conf_t *conf, int argc, char **argv);
1073 +static int ipkg_compare_versions_cmd(ipkg_conf_t *conf, int argc, char **argv);
1074 +static int ipkg_print_architecture_cmd(ipkg_conf_t *conf, int argc, char **argv);
1075 +static int ipkg_configure_cmd(ipkg_conf_t *conf, int argc, char **argv);
1076 +
1077 +/* XXX: CLEANUP: The usage strings should be incorporated into this
1078 +   array for easier maintenance */
1079 +static ipkg_cmd_t cmds[] = {
1080 +     {"update", 0, (ipkg_cmd_fun_t)ipkg_update_cmd},
1081 +     {"upgrade", 0, (ipkg_cmd_fun_t)ipkg_upgrade_cmd},
1082 +     {"list", 0, (ipkg_cmd_fun_t)ipkg_list_cmd},
1083 +     {"list_installed", 0, (ipkg_cmd_fun_t)ipkg_list_installed_cmd},
1084 +     {"info", 0, (ipkg_cmd_fun_t)ipkg_info_cmd},
1085 +     {"flag", 1, (ipkg_cmd_fun_t)ipkg_flag_cmd},
1086 +     {"status", 0, (ipkg_cmd_fun_t)ipkg_status_cmd},
1087 +     {"install_pending", 0, (ipkg_cmd_fun_t)ipkg_install_pending_cmd},
1088 +     {"install", 1, (ipkg_cmd_fun_t)ipkg_install_cmd},
1089 +     {"remove", 1, (ipkg_cmd_fun_t)ipkg_remove_cmd},
1090 +     {"purge", 1, (ipkg_cmd_fun_t)ipkg_purge_cmd},
1091 +     {"configure", 0, (ipkg_cmd_fun_t)ipkg_configure_cmd},
1092 +     {"files", 1, (ipkg_cmd_fun_t)ipkg_files_cmd},
1093 +     {"search", 1, (ipkg_cmd_fun_t)ipkg_search_cmd},
1094 +     {"download", 1, (ipkg_cmd_fun_t)ipkg_download_cmd},
1095 +     {"compare_versions", 1, (ipkg_cmd_fun_t)ipkg_compare_versions_cmd},
1096 +     {"compare-versions", 1, (ipkg_cmd_fun_t)ipkg_compare_versions_cmd},
1097 +     {"print-architecture", 0, (ipkg_cmd_fun_t)ipkg_print_architecture_cmd},
1098 +     {"print_architecture", 0, (ipkg_cmd_fun_t)ipkg_print_architecture_cmd},
1099 +     {"print-installation-architecture", 0, (ipkg_cmd_fun_t)ipkg_print_architecture_cmd},
1100 +     {"print_installation_architecture", 0, (ipkg_cmd_fun_t)ipkg_print_architecture_cmd},
1101 +     {"depends", 1, (ipkg_cmd_fun_t)ipkg_depends_cmd},
1102 +     {"whatdepends", 1, (ipkg_cmd_fun_t)ipkg_whatdepends_cmd},
1103 +     {"whatdependsrec", 1, (ipkg_cmd_fun_t)ipkg_whatdepends_recursively_cmd},
1104 +     {"whatrecommends", 1, (ipkg_cmd_fun_t)ipkg_whatrecommends_cmd},
1105 +     {"whatsuggests", 1, (ipkg_cmd_fun_t)ipkg_whatsuggests_cmd},
1106 +     {"whatprovides", 1, (ipkg_cmd_fun_t)ipkg_whatprovides_cmd},
1107 +     {"whatreplaces", 1, (ipkg_cmd_fun_t)ipkg_whatreplaces_cmd},
1108 +     {"whatconflicts", 1, (ipkg_cmd_fun_t)ipkg_whatconflicts_cmd},
1109 +};
1110 +
1111 +int ipkg_state_changed;
1112 +static void write_status_files_if_changed(ipkg_conf_t *conf)
1113 +{
1114 +     if (ipkg_state_changed && !conf->noaction) {
1115 +         ipkg_message(conf, IPKG_INFO,
1116 +                      "  writing status file\n");
1117 +         ipkg_conf_write_status_files(conf);
1118 +         pkg_write_changed_filelists(conf);
1119 +     } else {
1120 +         ipkg_message(conf, IPKG_NOTICE, "Nothing to be done\n");
1121 +     }
1122 +}
1123 +
1124 +
1125 +static int num_cmds = sizeof(cmds) / sizeof(ipkg_cmd_t);
1126 +
1127 +ipkg_cmd_t *ipkg_cmd_find(const char *name)
1128 +{
1129 +     int i;
1130 +     ipkg_cmd_t *cmd;
1131 +
1132 +     for (i=0; i < num_cmds; i++) {
1133 +         cmd = &cmds[i];
1134 +         if (strcmp(name, cmd->name) == 0) {
1135 +              return cmd;
1136 +         }
1137 +     }
1138 +
1139 +     return NULL;
1140 +}
1141 +
1142 +#ifdef IPKG_LIB
1143 +int ipkg_cmd_exec(ipkg_cmd_t *cmd, ipkg_conf_t *conf, int argc, const char **argv, void *userdata)
1144 +{
1145 +       int result;
1146 +       p_userdata = userdata;
1147 +
1148 +
1149 +       result = (cmd->fun)(conf, argc, argv);
1150 +        if ( result == 0 ) {
1151 +           ipkg_message(conf, IPKG_NOTICE, "Done.\n");
1152 +        } else {
1153 +           ipkg_message(conf, IPKG_NOTICE, "An error ocurred, return value: %d.\n", result);
1154 +
1155 +        }
1156 +        if ( error_list ) {
1157 +           reverse_error_list(&error_list);
1158 +
1159 +           ipkg_message(conf, IPKG_NOTICE, "Collected errors:\n");
1160 +           /* Here we print the errors collected and free the list */
1161 +           while (error_list != NULL) {
1162 +                 ipkg_message(conf, IPKG_NOTICE, "%s",error_list->errmsg);
1163 +                 error_list = error_list->next;
1164 +
1165 +           }
1166 +           free_error_list(&error_list);
1167 +
1168 +        }
1169 +
1170 +       p_userdata = NULL;
1171 +       return result;
1172 +}
1173 +#else
1174 +int ipkg_cmd_exec(ipkg_cmd_t *cmd, ipkg_conf_t *conf, int argc, const char **argv)
1175 +{
1176 +     return (cmd->fun)(conf, argc, argv);
1177 +}
1178 +#endif
1179 +
1180 +static int ipkg_update_cmd(ipkg_conf_t *conf, int argc, char **argv)
1181 +{
1182 +     int err;
1183 +     int failures;
1184 +     char *lists_dir;
1185 +     pkg_src_list_elt_t *iter;
1186 +     pkg_src_t *src;
1187 +
1188 +
1189 +    sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir);
1190 +
1191 +    if (! file_is_dir(lists_dir)) {
1192 +         if (file_exists(lists_dir)) {
1193 +              ipkg_message(conf, IPKG_ERROR,
1194 +                           "%s: ERROR: %s exists, but is not a directory\n",
1195 +                           __FUNCTION__, lists_dir);
1196 +              free(lists_dir);
1197 +              return EINVAL;
1198 +         }
1199 +         err = file_mkdir_hier(lists_dir, 0755);
1200 +         if (err) {
1201 +              ipkg_message(conf, IPKG_ERROR,
1202 +                           "%s: ERROR: failed to make directory %s: %s\n",
1203 +                           __FUNCTION__, lists_dir, strerror(errno));
1204 +              free(lists_dir);
1205 +              return EINVAL;
1206 +         }
1207 +     }
1208 +
1209 +     failures = 0;
1210 +     for (iter = conf->pkg_src_list.head; iter; iter = iter->next) {
1211 +         char *url, *list_file_name;
1212 +
1213 +         src = iter->data;
1214 +
1215 +         if (src->extra_data)  /* debian style? */
1216 +             sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
1217 +                           src->gzip ? "Packages.gz" : "Packages");
1218 +         else
1219 +             sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages");
1220 +
1221 +         sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
1222 +         if (src->gzip) {
1223 +             char *tmp;
1224 +             char *tmp_file_name;
1225 +             FILE *in, *out;
1226 +
1227 +             tmp = strdup ("/tmp/ipkg.XXXXXX");
1228 +
1229 +             if (mkdtemp (tmp) == NULL) {
1230 +                 perror ("mkdtemp");
1231 +                 failures++;
1232 +                 continue;
1233 +             }
1234 +
1235 +             sprintf_alloc (&tmp_file_name, "%s/%s.gz", tmp, src->name);
1236 +             err = ipkg_download(conf, url, tmp_file_name);
1237 +             if (err == 0) {
1238 +                  ipkg_message (conf, IPKG_NOTICE, "Inflating %s\n", url);
1239 +                  in = fopen (tmp_file_name, "r");
1240 +                  out = fopen (list_file_name, "w");
1241 +                  if (in && out) {
1242 +                       inflate_unzip_result res;
1243 +                       inflate_unzip (&res, 0x8000, fileno(in), fileno(out));
1244 +                  } else
1245 +                       err = 1;
1246 +                  if (in)
1247 +                       fclose (in);
1248 +                  if (out)
1249 +                       fclose (out);
1250 +                  unlink (tmp_file_name);
1251 +                  rmdir (tmp);
1252 +                  free (tmp);
1253 +             }
1254 +         } else
1255 +             err = ipkg_download(conf, url, list_file_name);
1256 +         if (err) {
1257 +              failures++;
1258 +         } else {
1259 +              ipkg_message(conf, IPKG_NOTICE,
1260 +                           "Updated list of available packages in %s\n",
1261 +                           list_file_name);
1262 +         }
1263 +         free(url);
1264 +         free(list_file_name);
1265 +     }
1266 +     free(lists_dir);
1267 +
1268 +#ifdef CONFIG_CLEAR_SW_INSTALL_FLAG
1269 +#warning here
1270 +     /* clear SW_INSTALL on any package where state is SS_NOT_INSTALLED.
1271 +      * this is a hack to work around poor bookkeeping in old ipkg upgrade code
1272 +      * -Jamey 3/1/03
1273 +      */
1274 +     {
1275 +         int i;
1276 +         int changed = 0;
1277 +         pkg_vec_t *available = pkg_vec_alloc();
1278 +         pkg_hash_fetch_available(&conf->pkg_hash, available);
1279 +         ipkg_message(conf, IPKG_DEBUG, "Clearing SW_INSTALL for SS_NOT_INSTALLED packages.\n");
1280 +         for (i = 0; i < available->len; i++) {
1281 +              pkg_t *pkg = available->pkgs[i];
1282 +              if (pkg->state_want == SW_INSTALL && pkg->state_status == SS_NOT_INSTALLED) {
1283 +                   ipkg_message(conf, IPKG_DEBUG, "Clearing SW_INSTALL on package %s.\n", pkg->name);
1284 +                   pkg->state_want = SW_UNKNOWN;
1285 +                   changed = 1;
1286 +              }
1287 +         }
1288 +         pkg_vec_free(available);
1289 +         if (changed) {
1290 +              write_status_files_if_changed(conf);
1291 +         }
1292 +     }
1293 +#endif
1294 +
1295 +     return failures;
1296 +}
1297 +
1298 +
1299 +/* scan the args passed and cache the local filenames of the packages */
1300 +int ipkg_multiple_files_scan(ipkg_conf_t *conf, int argc, char **argv)
1301 +{
1302 +     int i;
1303 +     int err;
1304 +
1305 +     /*
1306 +      * First scan through package names/urls
1307 +      * For any urls, download the packages and install in database.
1308 +      * For any files, install package info in database.
1309 +      */
1310 +     for (i = 0; i < argc; i ++) {
1311 +         char *filename = argv [i];
1312 +         //char *tmp = basename (tmp);
1313 +         //int tmplen = strlen (tmp);
1314 +
1315 +         //if (strcmp (tmp + (tmplen - strlen (IPKG_PKG_EXTENSION)), IPKG_PKG_EXTENSION) != 0)
1316 +         //     continue;
1317 +         //if (strcmp (tmp + (tmplen - strlen (DPKG_PKG_EXTENSION)), DPKG_PKG_EXTENSION) != 0)
1318 +         //     continue;
1319 +
1320 +          ipkg_message(conf, IPKG_DEBUG2, "Debug mfs: %s  \n",filename );
1321 +
1322 +         err = ipkg_prepare_url_for_install(conf, filename, &argv[i]);
1323 +         if (err)
1324 +           return err;
1325 +     }
1326 +     return 0;
1327 +}
1328 +
1329 +struct ipkg_intercept
1330 +{
1331 +    char *oldpath;
1332 +    char *statedir;
1333 +};
1334 +
1335 +typedef struct ipkg_intercept *ipkg_intercept_t;
1336 +
1337 +ipkg_intercept_t ipkg_prep_intercepts(ipkg_conf_t *conf)
1338 +{
1339 +    ipkg_intercept_t ctx;
1340 +    char *newpath;
1341 +    int gen;
1342 +
1343 +    ctx = malloc (sizeof (*ctx));
1344 +    ctx->oldpath = strdup (getenv ("PATH"));
1345 +
1346 +    sprintf_alloc (&newpath, "%s/ipkg/intercept:%s", IPKGLIBDIR, ctx->oldpath);
1347 +    setenv ("PATH", newpath, 1);
1348 +    free (newpath);
1349 +
1350 +    gen = 0;
1351 + retry:
1352 +    sprintf_alloc (&ctx->statedir, "/tmp/ipkg-intercept-%d-%d", getpid (), gen);
1353 +    if (mkdir (ctx->statedir, 0770) < 0) {
1354 +       if (errno == EEXIST) {
1355 +           free (ctx->statedir);
1356 +           gen++;
1357 +           goto retry;
1358 +       }
1359 +       perror (ctx->statedir);
1360 +       return NULL;
1361 +    }
1362 +    setenv ("IPKG_INTERCEPT_DIR", ctx->statedir, 1);
1363 +    return ctx;
1364 +}
1365 +
1366 +int ipkg_finalize_intercepts(ipkg_intercept_t ctx)
1367 +{
1368 +    char *cmd;
1369 +    DIR *dir;
1370 +    int err = 0;
1371 +
1372 +    setenv ("PATH", ctx->oldpath, 1);
1373 +    free (ctx->oldpath);
1374 +
1375 +    dir = opendir (ctx->statedir);
1376 +    if (dir) {
1377 +       struct dirent *de;
1378 +       while (de = readdir (dir), de != NULL) {
1379 +           char *path;
1380 +
1381 +           if (de->d_name[0] == '.')
1382 +               continue;
1383 +
1384 +           sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
1385 +           if (access (path, X_OK) == 0) {
1386 +               if (system (path)) {
1387 +                   err = errno;
1388 +                   perror (de->d_name);
1389 +               }
1390 +           }
1391 +           free (path);
1392 +       }
1393 +    } else
1394 +       perror (ctx->statedir);
1395 +
1396 +    sprintf_alloc (&cmd, "rm -rf %s", ctx->statedir);
1397 +    system (cmd);
1398 +    free (cmd);
1399 +
1400 +    free (ctx->statedir);
1401 +    free (ctx);
1402 +
1403 +    return err;
1404 +}
1405 +
1406 +int ipkg_configure_packages(ipkg_conf_t *conf, char *pkg_name)
1407 +{
1408 +     pkg_vec_t *all;
1409 +     int i;
1410 +     pkg_t *pkg;
1411 +     ipkg_intercept_t ic;
1412 +     int r, err = 0;
1413 +
1414 +     ipkg_message(conf, IPKG_INFO,
1415 +                 "Configuring unpacked packages\n");
1416 +     fflush( stdout );
1417 +
1418 +     all = pkg_vec_alloc();
1419 +     pkg_hash_fetch_available(&conf->pkg_hash, all);
1420 +
1421 +     ic = ipkg_prep_intercepts (conf);
1422 +
1423 +     for(i = 0; i < all->len; i++) {
1424 +         pkg = all->pkgs[i];
1425 +
1426 +         if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
1427 +              continue;
1428 +
1429 +         if (pkg->state_status == SS_UNPACKED) {
1430 +              ipkg_message(conf, IPKG_NOTICE,
1431 +                           "Configuring %s\n", pkg->name);
1432 +              fflush( stdout );
1433 +              r = ipkg_configure(conf, pkg);
1434 +              if (r == 0) {
1435 +                   pkg->state_status = SS_INSTALLED;
1436 +                   pkg->parent->state_status = SS_INSTALLED;
1437 +                   pkg->state_flag &= ~SF_PREFER;
1438 +              } else {
1439 +                   if (!err)
1440 +                       err = r;
1441 +              }
1442 +         }
1443 +     }
1444 +
1445 +     r = ipkg_finalize_intercepts (ic);
1446 +     if (r && !err)
1447 +        err = r;
1448 +
1449 +     pkg_vec_free(all);
1450 +     return err;
1451 +}
1452 +
1453 +static void sigint_handler(int sig)
1454 +{
1455 +     signal(sig, SIG_DFL);
1456 +     ipkg_message(NULL, IPKG_NOTICE,
1457 +                 "ipkg: interrupted. writing out status database\n");
1458 +     write_status_files_if_changed(global_conf);
1459 +     exit(128 + sig);
1460 +}
1461 +
1462 +static int ipkg_install_cmd(ipkg_conf_t *conf, int argc, char **argv)
1463 +{
1464 +     int i;
1465 +     char *arg;
1466 +     int err=0;
1467 +
1468 +     global_conf = conf;
1469 +     signal(SIGINT, sigint_handler);
1470 +
1471 +     /*
1472 +      * Now scan through package names and install
1473 +      */
1474 +     for (i=0; i < argc; i++) {
1475 +         arg = argv[i];
1476 +
1477 +          ipkg_message(conf, IPKG_DEBUG2, "Debug install_cmd: %s  \n",arg );
1478 +          err = ipkg_prepare_url_for_install(conf, arg, &argv[i]);
1479 +          if (err != EINVAL && err != 0)
1480 +              return err;
1481 +     }
1482 +     pkg_info_preinstall_check(conf);
1483 +
1484 +     for (i=0; i < argc; i++) {
1485 +         arg = argv[i];
1486 +         if (conf->multiple_providers)
1487 +              err = ipkg_install_multi_by_name(conf, arg);
1488 +         else{
1489 +              err = ipkg_install_by_name(conf, arg);
1490 +          }
1491 +         if (err == IPKG_PKG_HAS_NO_CANDIDATE) {
1492 +              ipkg_message(conf, IPKG_ERROR,
1493 +                           "Cannot find package %s.\n"
1494 +                           "Check the spelling or perhaps run 'ipkg update'\n",
1495 +                           arg);
1496 +         }
1497 +     }
1498 +
1499 +     /* recheck to verify that all dependences are satisfied */
1500 +     if (0) ipkg_satisfy_all_dependences(conf);
1501 +
1502 +     ipkg_configure_packages(conf, NULL);
1503 +
1504 +     write_status_files_if_changed(conf);
1505 +
1506 +     return err;
1507 +}
1508 +
1509 +static int ipkg_upgrade_cmd(ipkg_conf_t *conf, int argc, char **argv)
1510 +{
1511 +     int i;
1512 +     pkg_t *pkg;
1513 +     int err;
1514 +
1515 +     global_conf = conf;
1516 +     signal(SIGINT, sigint_handler);
1517 +
1518 +     if (argc) {
1519 +         for (i=0; i < argc; i++) {
1520 +              char *arg = argv[i];
1521 +
1522 +               err = ipkg_prepare_url_for_install(conf, arg, &arg);
1523 +               if (err != EINVAL && err != 0)
1524 +                   return err;
1525 +         }
1526 +         pkg_info_preinstall_check(conf);
1527 +
1528 +         for (i=0; i < argc; i++) {
1529 +              char *arg = argv[i];
1530 +              if (conf->restrict_to_default_dest) {
1531 +                   pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1532 +                                                               argv[i],
1533 +                                                               conf->default_dest);
1534 +                   if (pkg == NULL) {
1535 +                        ipkg_message(conf, IPKG_NOTICE,
1536 +                                     "Package %s not installed in %s\n",
1537 +                                     argv[i], conf->default_dest->name);
1538 +                        continue;
1539 +                   }
1540 +              } else {
1541 +                   pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
1542 +                                                          argv[i]);
1543 +              }
1544 +              if (pkg)
1545 +                   ipkg_upgrade_pkg(conf, pkg);
1546 +              else {
1547 +                   ipkg_install_by_name(conf, arg);
1548 +               }
1549 +         }
1550 +     } else {
1551 +         pkg_vec_t *installed = pkg_vec_alloc();
1552 +
1553 +         pkg_info_preinstall_check(conf);
1554 +
1555 +         pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
1556 +         for (i = 0; i < installed->len; i++) {
1557 +              pkg = installed->pkgs[i];
1558 +              ipkg_upgrade_pkg(conf, pkg);
1559 +         }
1560 +         pkg_vec_free(installed);
1561 +     }
1562 +
1563 +     /* recheck to verify that all dependences are satisfied */
1564 +     if (0) ipkg_satisfy_all_dependences(conf);
1565 +
1566 +     ipkg_configure_packages(conf, NULL);
1567 +
1568 +     write_status_files_if_changed(conf);
1569 +
1570 +     return 0;
1571 +}
1572 +
1573 +static int ipkg_download_cmd(ipkg_conf_t *conf, int argc, char **argv)
1574 +{
1575 +     int i, err;
1576 +     char *arg;
1577 +     pkg_t *pkg;
1578 +
1579 +     pkg_info_preinstall_check(conf);
1580 +     for (i = 0; i < argc; i++) {
1581 +         arg = argv[i];
1582 +
1583 +         pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, arg);
1584 +         if (pkg == NULL) {
1585 +              ipkg_message(conf, IPKG_ERROR,
1586 +                           "Cannot find package %s.\n"
1587 +                           "Check the spelling or perhaps run 'ipkg update'\n",
1588 +                           arg);
1589 +              continue;
1590 +         }
1591 +
1592 +         err = ipkg_download_pkg(conf, pkg, ".");
1593 +
1594 +         if (err) {
1595 +              ipkg_message(conf, IPKG_ERROR,
1596 +                           "Failed to download %s\n", pkg->name);
1597 +         } else {
1598 +              ipkg_message(conf, IPKG_NOTICE,
1599 +                           "Downloaded %s as %s\n",
1600 +                           pkg->name, pkg->local_filename);
1601 +         }
1602 +     }
1603 +
1604 +     return 0;
1605 +}
1606 +
1607 +
1608 +static int ipkg_list_cmd(ipkg_conf_t *conf, int argc, char **argv)
1609 +{
1610 +     int i ;
1611 +     pkg_vec_t *available;
1612 +     pkg_t *pkg;
1613 +     char desc_short[IPKG_LIST_DESCRIPTION_LENGTH];
1614 +     char *newline;
1615 +     char *pkg_name = NULL;
1616 +     char *version_str;
1617 +
1618 +     if (argc > 0) {
1619 +         pkg_name = argv[0];
1620 +     }
1621 +     available = pkg_vec_alloc();
1622 +     pkg_hash_fetch_available(&conf->pkg_hash, available);
1623 +     for (i=0; i < available->len; i++) {
1624 +         pkg = available->pkgs[i];
1625 +         /* if we have package name or pattern and pkg does not match, then skip it */
1626 +         if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
1627 +              continue;
1628 +         if (pkg->description) {
1629 +              strncpy(desc_short, pkg->description, IPKG_LIST_DESCRIPTION_LENGTH);
1630 +         } else {
1631 +              desc_short[0] = '\0';
1632 +         }
1633 +         desc_short[IPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
1634 +         newline = strchr(desc_short, '\n');
1635 +         if (newline) {
1636 +              *newline = '\0';
1637 +         }
1638 +#ifndef IPKG_LIB
1639 +         printf("%s - %s\n", pkg->name, desc_short);
1640 +#else
1641 +         if (ipkg_cb_list) {
1642 +               version_str = pkg_version_str_alloc(pkg);
1643 +               ipkg_cb_list(pkg->name,desc_short,
1644 +                                            version_str,
1645 +                                        pkg->state_status,
1646 +                                        p_userdata);
1647 +               free(version_str);
1648 +         }
1649 +#endif
1650 +     }
1651 +     pkg_vec_free(available);
1652 +
1653 +     return 0;
1654 +}
1655 +
1656 +
1657 +static int ipkg_list_installed_cmd(ipkg_conf_t *conf, int argc, char **argv)
1658 +{
1659 +     int i ;
1660 +     pkg_vec_t *available;
1661 +     pkg_t *pkg;
1662 +     char desc_short[IPKG_LIST_DESCRIPTION_LENGTH];
1663 +     char *newline;
1664 +     char *pkg_name = NULL;
1665 +     char *version_str;
1666 +
1667 +     if (argc > 0) {
1668 +         pkg_name = argv[0];
1669 +     }
1670 +     available = pkg_vec_alloc();
1671 +     pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
1672 +     for (i=0; i < available->len; i++) {
1673 +         pkg = available->pkgs[i];
1674 +         /* if we have package name or pattern and pkg does not match, then skip it */
1675 +         if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
1676 +              continue;
1677 +         if (pkg->description) {
1678 +              strncpy(desc_short, pkg->description, IPKG_LIST_DESCRIPTION_LENGTH);
1679 +         } else {
1680 +              desc_short[0] = '\0';
1681 +         }
1682 +         desc_short[IPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
1683 +         newline = strchr(desc_short, '\n');
1684 +         if (newline) {
1685 +              *newline = '\0';
1686 +         }
1687 +#ifndef IPKG_LIB
1688 +         printf("%s - %s\n", pkg->name, desc_short);
1689 +#else
1690 +         if (ipkg_cb_list) {
1691 +               version_str = pkg_version_str_alloc(pkg);
1692 +               ipkg_cb_list(pkg->name,desc_short,
1693 +                                            version_str,
1694 +                                        pkg->state_status,
1695 +                                        p_userdata);
1696 +               free(version_str);
1697 +         }
1698 +#endif
1699 +     }
1700 +
1701 +     return 0;
1702 +}
1703 +
1704 +static int ipkg_info_status_cmd(ipkg_conf_t *conf, int argc, char **argv, int installed_only)
1705 +{
1706 +     int i;
1707 +     pkg_vec_t *available;
1708 +     pkg_t *pkg;
1709 +     char *pkg_name = NULL;
1710 +     char **pkg_fields = NULL;
1711 +     int n_fields = 0;
1712 +     char *buff ; // = (char *)malloc(1);
1713 +
1714 +     if (argc > 0) {
1715 +         pkg_name = argv[0];
1716 +     }
1717 +     if (argc > 1) {
1718 +         pkg_fields = &argv[1];
1719 +         n_fields = argc - 1;
1720 +     }
1721 +
1722 +     available = pkg_vec_alloc();
1723 +     if (installed_only)
1724 +         pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
1725 +     else
1726 +         pkg_hash_fetch_available(&conf->pkg_hash, available);
1727 +     for (i=0; i < available->len; i++) {
1728 +         pkg = available->pkgs[i];
1729 +         if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
1730 +              continue;
1731 +         }
1732 +#ifndef IPKG_LIB
1733 +         if (n_fields) {
1734 +              for (j = 0; j < n_fields; j++)
1735 +                   pkg_print_field(pkg, stdout, pkg_fields[j]);
1736 +         } else {
1737 +              pkg_print_info(pkg, stdout);
1738 +         }
1739 +#else
1740 +
1741 +         buff = pkg_formatted_info(pkg);
1742 +          if ( buff ) {
1743 +              if (ipkg_cb_status) ipkg_cb_status(pkg->name,
1744 +                                                 pkg->state_status,
1745 +                                                 buff,
1746 +                                                 p_userdata);
1747 +/*
1748 +   We should not forget that actually the pointer is allocated.
1749 +   We need to free it :)  ( Thanks florian for seeing the error )
1750 +*/
1751 +               free(buff);
1752 +          }
1753 +#endif
1754 +         if (conf->verbosity > 1) {
1755 +              conffile_list_elt_t *iter;
1756 +              for (iter = pkg->conffiles.head; iter; iter = iter->next) {
1757 +                   conffile_t *cf = iter->data;
1758 +                   int modified = conffile_has_been_modified(conf, cf);
1759 +                   ipkg_message(conf, IPKG_NOTICE, "conffile=%s md5sum=%s modified=%d\n",
1760 +                                cf->name, cf->value, modified);
1761 +              }
1762 +         }
1763 +     }
1764 +#ifndef IPKG_LIB
1765 +     if (buff)
1766 +         free(buff);
1767 +#endif
1768 +     pkg_vec_free(available);
1769 +
1770 +     return 0;
1771 +}
1772 +
1773 +static int ipkg_info_cmd(ipkg_conf_t *conf, int argc, char **argv)
1774 +{
1775 +     return ipkg_info_status_cmd(conf, argc, argv, 0);
1776 +}
1777 +
1778 +static int ipkg_status_cmd(ipkg_conf_t *conf, int argc, char **argv)
1779 +{
1780 +     return ipkg_info_status_cmd(conf, argc, argv, 1);
1781 +}
1782 +
1783 +static int ipkg_configure_cmd(ipkg_conf_t *conf, int argc, char **argv)
1784 +{
1785 +
1786 +     int err;
1787 +     if (argc > 0) {
1788 +         char *pkg_name = NULL;
1789 +
1790 +         pkg_name = argv[0];
1791 +
1792 +         err = ipkg_configure_packages (conf, pkg_name);
1793 +
1794 +     } else {
1795 +         err = ipkg_configure_packages (conf, NULL);
1796 +     }
1797 +
1798 +     write_status_files_if_changed(conf);
1799 +
1800 +     return err;
1801 +}
1802 +
1803 +static int ipkg_install_pending_cmd(ipkg_conf_t *conf, int argc, char **argv)
1804 +{
1805 +     int i, err;
1806 +     char *globpattern;
1807 +     glob_t globbuf;
1808 +
1809 +     sprintf_alloc(&globpattern, "%s/*" IPKG_PKG_EXTENSION, conf->pending_dir);
1810 +     err = glob(globpattern, 0, NULL, &globbuf);
1811 +     free(globpattern);
1812 +     if (err) {
1813 +         return 0;
1814 +     }
1815 +
1816 +     ipkg_message(conf, IPKG_NOTICE,
1817 +                 "The following packages in %s will now be installed.\n",
1818 +                 conf->pending_dir);
1819 +     for (i = 0; i < globbuf.gl_pathc; i++) {
1820 +         ipkg_message(conf, IPKG_NOTICE,
1821 +                      "%s%s", i == 0 ? "" : " ", globbuf.gl_pathv[i]);
1822 +     }
1823 +     ipkg_message(conf, IPKG_NOTICE, "\n");
1824 +     for (i = 0; i < globbuf.gl_pathc; i++) {
1825 +         err = ipkg_install_from_file(conf, globbuf.gl_pathv[i]);
1826 +         if (err == 0) {
1827 +              err = unlink(globbuf.gl_pathv[i]);
1828 +              if (err) {
1829 +                   ipkg_message(conf, IPKG_ERROR,
1830 +                                "%s: ERROR: failed to unlink %s: %s\n",
1831 +                                __FUNCTION__, globbuf.gl_pathv[i], strerror(err));
1832 +                   return err;
1833 +              }
1834 +         }
1835 +     }
1836 +     globfree(&globbuf);
1837 +
1838 +     return err;
1839 +}
1840 +
1841 +static int ipkg_remove_cmd(ipkg_conf_t *conf, int argc, char **argv)
1842 +{
1843 +     int i,a,done;
1844 +     pkg_t *pkg;
1845 +     pkg_t *pkg_to_remove;
1846 +     pkg_vec_t *available;
1847 +     char *pkg_name = NULL;
1848 +     global_conf = conf;
1849 +     signal(SIGINT, sigint_handler);
1850 +
1851 +// ENH: Add the "no pkg removed" just in case.
1852 +
1853 +    done = 0;
1854 +
1855 +     available = pkg_vec_alloc();
1856 +     pkg_info_preinstall_check(conf);
1857 +     if ( argc > 0 ) {
1858 +        pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
1859 +        for (i=0; i < argc; i++) {
1860 +           pkg_name = malloc(strlen(argv[i])+2);
1861 +           strcpy(pkg_name,argv[i]);
1862 +           for (a=0; a < available->len; a++) {
1863 +               pkg = available->pkgs[a];
1864 +              if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
1865 +                  continue;
1866 +               }
1867 +               if (conf->restrict_to_default_dest) {
1868 +                   pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1869 +                                                               pkg->name,
1870 +                                                               conf->default_dest);
1871 +               } else {
1872 +                   pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
1873 +               }
1874 +
1875 +               if (pkg == NULL) {
1876 +                   ipkg_message(conf, IPKG_ERROR, "Package %s is not installed.\n", pkg->name);
1877 +                   continue;
1878 +               }
1879 +               if (pkg->state_status == SS_NOT_INSTALLED) {    // Added the control, so every already removed package could be skipped
1880 +                   ipkg_message(conf, IPKG_ERROR, "Package seems to be %s not installed (STATUS = NOT_INSTALLED).\n", pkg->name);
1881 +                    continue;
1882 +               }
1883 +               ipkg_remove_pkg(conf, pkg_to_remove,0);
1884 +               done = 1;
1885 +           }
1886 +           free (pkg_name);
1887 +        }
1888 +        pkg_vec_free(available);
1889 +     } else {
1890 +         pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1891 +         int flagged_pkg_count = 0;
1892 +         int removed;
1893 +
1894 +         pkg_hash_fetch_all_installed(&conf->pkg_hash, installed_pkgs);
1895 +
1896 +         for (i = 0; i < installed_pkgs->len; i++) {
1897 +              pkg = installed_pkgs->pkgs[i];
1898 +              if (pkg->state_flag & SF_USER) {
1899 +                   flagged_pkg_count++;
1900 +              } else {
1901 +                   if (!pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL))
1902 +                        ipkg_message(conf, IPKG_NOTICE, "Non-user leaf package: %s\n", pkg->name);
1903 +              }
1904 +         }
1905 +         if (!flagged_pkg_count) {
1906 +              ipkg_message(conf, IPKG_NOTICE, "No packages flagged as installed by user, \n"
1907 +                           "so refusing to uninstall unflagged non-leaf packages\n");
1908 +              return 0;
1909 +         }
1910 +
1911 +         /* find packages not flagged SF_USER (i.e., installed to
1912 +          * satisfy a dependence) and not having any dependents, and
1913 +          * remove them */
1914 +         do {
1915 +              removed = 0;
1916 +              for (i = 0; i < installed_pkgs->len; i++) {
1917 +                   pkg = installed_pkgs->pkgs[i];
1918 +                   if (!(pkg->state_flag & SF_USER)
1919 +                       && !pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL)) {
1920 +                        removed++;
1921 +                        ipkg_message(conf, IPKG_NOTICE, "Removing non-user leaf package %s\n");
1922 +                        ipkg_remove_pkg(conf, pkg,0);
1923 +                         done = 1;
1924 +                   }
1925 +              }
1926 +         } while (removed);
1927 +         pkg_vec_free(installed_pkgs);
1928 +     }
1929 +
1930 +     if ( done == 0 )
1931 +        ipkg_message(conf, IPKG_NOTICE, "No packages removed.\n");
1932 +
1933 +     write_status_files_if_changed(conf);
1934 +     return 0;
1935 +}
1936 +
1937 +static int ipkg_purge_cmd(ipkg_conf_t *conf, int argc, char **argv)
1938 +{
1939 +     int i;
1940 +     pkg_t *pkg;
1941 +
1942 +     global_conf = conf;
1943 +     signal(SIGINT, sigint_handler);
1944 +
1945 +     pkg_info_preinstall_check(conf);
1946 +
1947 +     for (i=0; i < argc; i++) {
1948 +         if (conf->restrict_to_default_dest) {
1949 +              pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1950 +                                                          argv[i],
1951 +                                                          conf->default_dest);
1952 +         } else {
1953 +              pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
1954 +         }
1955 +
1956 +         if (pkg == NULL) {
1957 +              ipkg_message(conf, IPKG_ERROR,
1958 +                           "Package %s is not installed.\n", argv[i]);
1959 +              continue;
1960 +         }
1961 +         ipkg_purge_pkg(conf, pkg);
1962 +     }
1963 +
1964 +     write_status_files_if_changed(conf);
1965 +     return 0;
1966 +}
1967 +
1968 +static int ipkg_flag_cmd(ipkg_conf_t *conf, int argc, char **argv)
1969 +{
1970 +     int i;
1971 +     pkg_t *pkg;
1972 +     char *flags = argv[0];
1973 +
1974 +     global_conf = conf;
1975 +     signal(SIGINT, sigint_handler);
1976 +
1977 +     for (i=1; i < argc; i++) {
1978 +         if (conf->restrict_to_default_dest) {
1979 +              pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1980 +                                                          argv[i],
1981 +                                                          conf->default_dest);
1982 +         } else {
1983 +              pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
1984 +         }
1985 +
1986 +         if (pkg == NULL) {
1987 +              ipkg_message(conf, IPKG_ERROR,
1988 +                           "Package %s is not installed.\n", argv[i]);
1989 +              continue;
1990 +         }
1991 +          if (( strcmp(flags,"hold")==0)||( strcmp(flags,"noprune")==0)||
1992 +              ( strcmp(flags,"user")==0)||( strcmp(flags,"ok")==0)) {
1993 +             pkg->state_flag = pkg_state_flag_from_str(flags);
1994 +          }
1995 +/* pb_ asked this feature 03292004 */
1996 +/* Actually I will use only this two, but this is an open for various status */
1997 +          if (( strcmp(flags,"installed")==0)||( strcmp(flags,"unpacked")==0)){
1998 +             pkg->state_status = pkg_state_status_from_str(flags);
1999 +          }
2000 +         ipkg_state_changed++;
2001 +         ipkg_message(conf, IPKG_NOTICE,
2002 +                      "Setting flags for package %s to %s\n",
2003 +                      pkg->name, flags);
2004 +     }
2005 +
2006 +     write_status_files_if_changed(conf);
2007 +     return 0;
2008 +}
2009 +
2010 +static int ipkg_files_cmd(ipkg_conf_t *conf, int argc, char **argv)
2011 +{
2012 +     pkg_t *pkg;
2013 +     str_list_t *installed_files;
2014 +     str_list_elt_t *iter;
2015 +     char *pkg_version;
2016 +     size_t buff_len = 8192;
2017 +     size_t used_len;
2018 +     char *buff ;
2019 +
2020 +     buff = (char *)malloc(buff_len);
2021 +     if ( buff == NULL ) {
2022 +        fprintf( stderr,"%s: Unable to allocate memory \n",__FUNCTION__);
2023 +        return ENOMEM;
2024 +     }
2025 +
2026 +     if (argc < 1) {
2027 +         return EINVAL;
2028 +     }
2029 +
2030 +     pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
2031 +                                           argv[0]);
2032 +     if (pkg == NULL) {
2033 +         ipkg_message(conf, IPKG_ERROR,
2034 +                      "Package %s not installed.\n", argv[0]);
2035 +         return 0;
2036 +     }
2037 +
2038 +     installed_files = pkg_get_installed_files(pkg);
2039 +     pkg_version = pkg_version_str_alloc(pkg);
2040 +
2041 +#ifndef IPKG_LIB
2042 +     printf("Package %s (%s) is installed on %s and has the following files:\n",
2043 +           pkg->name, pkg_version, pkg->dest->name);
2044 +     for (iter = installed_files->head; iter; iter = iter->next) {
2045 +         puts(iter->data);
2046 +     }
2047 +#else
2048 +     if (buff) {
2049 +     try_again:
2050 +         used_len = snprintf(buff, buff_len, "Package %s (%s) is installed on %s and has the following files:\n",
2051 +                             pkg->name, pkg_version, pkg->dest->name) + 1;
2052 +         if (used_len > buff_len) {
2053 +              buff_len *= 2;
2054 +              buff = realloc (buff, buff_len);
2055 +              goto try_again;
2056 +         }
2057 +         for (iter = installed_files->head; iter; iter = iter->next) {
2058 +              used_len += strlen (iter->data) + 1;
2059 +              while (buff_len <= used_len) {
2060 +                   buff_len *= 2;
2061 +                   buff = realloc (buff, buff_len);
2062 +              }
2063 +              strncat(buff, iter->data, buff_len);
2064 +              strncat(buff, "\n", buff_len);
2065 +         }
2066 +         if (ipkg_cb_list) ipkg_cb_list(pkg->name,
2067 +                                        buff,
2068 +                                        pkg_version_str_alloc(pkg),
2069 +                                        pkg->state_status,
2070 +                                        p_userdata);
2071 +         free(buff);
2072 +     }
2073 +#endif
2074 +
2075 +     free(pkg_version);
2076 +     pkg_free_installed_files(pkg);
2077 +
2078 +     return 0;
2079 +}
2080 +
2081 +static int ipkg_depends_cmd(ipkg_conf_t *conf, int argc, char **argv)
2082 +{
2083 +
2084 +     if (argc > 0) {
2085 +         pkg_vec_t *available_pkgs = pkg_vec_alloc();
2086 +         const char *rel_str = "depends on";
2087 +         int i;
2088 +
2089 +         pkg_info_preinstall_check(conf);
2090 +
2091 +         if (conf->query_all)
2092 +              pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
2093 +         else
2094 +              pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
2095 +         for (i = 0; i < argc; i++) {
2096 +              const char *target = argv[i];
2097 +              int j;
2098 +
2099 +              ipkg_message(conf, IPKG_ERROR, "target=%s\n", target);
2100 +
2101 +              for (j = 0; j < available_pkgs->len; j++) {
2102 +                   pkg_t *pkg = available_pkgs->pkgs[j];
2103 +                   if (fnmatch(target, pkg->name, 0) == 0) {
2104 +                        int k;
2105 +                        int count = pkg->depends_count + pkg->pre_depends_count;
2106 +                        ipkg_message(conf, IPKG_ERROR, "What %s (arch=%s) %s\n",
2107 +                                     target, pkg->architecture, rel_str);
2108 +                        for (k = 0; k < count; k++) {
2109 +                             compound_depend_t *cdepend = &pkg->depends[k];
2110 +                             int l;
2111 +                             for (l = 0; l < cdepend->possibility_count; l++) {
2112 +                                  depend_t *possibility = cdepend->possibilities[l];
2113 +                                  ipkg_message(conf, IPKG_ERROR, "    %s", possibility->pkg->name);
2114 +                                  if (conf->verbosity > 0) {
2115 +                                       // char *ver = abstract_pkg_version_str_alloc(possibility->pkg);
2116 +                                       ipkg_message(conf, IPKG_NOTICE, " %s", possibility->version);
2117 +                                       if (possibility->version) {
2118 +                                            char *typestr = NULL;
2119 +                                            switch (possibility->constraint) {
2120 +                                            case NONE: typestr = "none"; break;
2121 +                                            case EARLIER: typestr = "<"; break;
2122 +                                            case EARLIER_EQUAL: typestr = "<="; break;
2123 +                                            case EQUAL: typestr = "="; break;
2124 +                                            case LATER_EQUAL: typestr = ">="; break;
2125 +                                            case LATER: typestr = ">"; break;
2126 +                                            }
2127 +                                            ipkg_message(conf, IPKG_NOTICE, " (%s %s)", typestr, possibility->version);
2128 +                                       }
2129 +                                       // free(ver);
2130 +                                  }
2131 +                                  ipkg_message(conf, IPKG_ERROR, "\n");
2132 +                             }
2133 +                        }
2134 +                   }
2135 +              }
2136 +         }
2137 +         pkg_vec_free(available_pkgs);
2138 +     }
2139 +     return 0;
2140 +}
2141 +
2142 +enum what_field_type {
2143 +  WHATDEPENDS,
2144 +  WHATCONFLICTS,
2145 +  WHATPROVIDES,
2146 +  WHATREPLACES,
2147 +  WHATRECOMMENDS,
2148 +  WHATSUGGESTS
2149 +};
2150 +
2151 +static int ipkg_what_depends_conflicts_cmd(ipkg_conf_t *conf, enum what_field_type what_field_type, int recursive, int argc, char **argv)
2152 +{
2153 +
2154 +     if (argc > 0) {
2155 +         pkg_vec_t *available_pkgs = pkg_vec_alloc();
2156 +         const char *rel_str = NULL;
2157 +         int i;
2158 +         int changed;
2159 +
2160 +         switch (what_field_type) {
2161 +         case WHATDEPENDS: rel_str = "depends on"; break;
2162 +         case WHATCONFLICTS: rel_str = "conflicts with"; break;
2163 +         case WHATSUGGESTS: rel_str = "suggests"; break;
2164 +         case WHATRECOMMENDS: rel_str = "recommends"; break;
2165 +         case WHATPROVIDES: rel_str = "provides"; break;
2166 +         case WHATREPLACES: rel_str = "replaces"; break;
2167 +         }
2168 +
2169 +         if (conf->query_all)
2170 +              pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
2171 +         else
2172 +              pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
2173 +
2174 +         /* mark the root set */
2175 +         pkg_vec_clear_marks(available_pkgs);
2176 +         ipkg_message(conf, IPKG_NOTICE, "Root set:\n");
2177 +         for (i = 0; i < argc; i++) {
2178 +              const char *dependee_pattern = argv[i];
2179 +              pkg_vec_mark_if_matches(available_pkgs, dependee_pattern);
2180 +         }
2181 +         for (i = 0; i < available_pkgs->len; i++) {
2182 +              pkg_t *pkg = available_pkgs->pkgs[i];
2183 +              if (pkg->state_flag & SF_MARKED) {
2184 +                   /* mark the parent (abstract) package */
2185 +                   pkg_mark_provides(pkg);
2186 +                   ipkg_message(conf, IPKG_NOTICE, "  %s\n", pkg->name);
2187 +              }
2188 +         }
2189 +
2190 +         ipkg_message(conf, IPKG_NOTICE, "What %s root set\n", rel_str);
2191 +         do {
2192 +              int j;
2193 +              changed = 0;
2194 +
2195 +              for (j = 0; j < available_pkgs->len; j++) {
2196 +                   pkg_t *pkg = available_pkgs->pkgs[j];
2197 +                   int k;
2198 +                   int count = ((what_field_type == WHATCONFLICTS)
2199 +                                ? pkg->conflicts_count
2200 +                                : pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count);
2201 +                   /* skip this package if it is already marked */
2202 +                   if (pkg->parent->state_flag & SF_MARKED) {
2203 +                        continue;
2204 +                   }
2205 +                   for (k = 0; k < count; k++) {
2206 +                        compound_depend_t *cdepend =
2207 +                             (what_field_type == WHATCONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
2208 +                        int l;
2209 +                        for (l = 0; l < cdepend->possibility_count; l++) {
2210 +                             depend_t *possibility = cdepend->possibilities[l];
2211 +                             if (possibility->pkg->state_flag & SF_MARKED) {
2212 +                                  /* mark the depending package so we won't visit it again */
2213 +                                  pkg->state_flag |= SF_MARKED;
2214 +                                  pkg_mark_provides(pkg);
2215 +                                  changed++;
2216 +
2217 +                                  ipkg_message(conf, IPKG_NOTICE, "    %s", pkg->name);
2218 +                                  if (conf->verbosity > 0) {
2219 +                                       char *ver = pkg_version_str_alloc(pkg);
2220 +                                       ipkg_message(conf, IPKG_NOTICE, " %s", ver);
2221 +                                       ipkg_message(conf, IPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
2222 +                                       if (possibility->version) {
2223 +                                            char *typestr = NULL;
2224 +                                            switch (possibility->constraint) {
2225 +                                            case NONE: typestr = "none"; break;
2226 +                                            case EARLIER: typestr = "<"; break;
2227 +                                            case EARLIER_EQUAL: typestr = "<="; break;
2228 +                                            case EQUAL: typestr = "="; break;
2229 +                                            case LATER_EQUAL: typestr = ">="; break;
2230 +                                            case LATER: typestr = ">"; break;
2231 +                                            }
2232 +                                            ipkg_message(conf, IPKG_NOTICE, " (%s %s)", typestr, possibility->version);
2233 +                                       }
2234 +                                       free(ver);
2235 +                                       if (!pkg_dependence_satisfiable(conf, possibility))
2236 +                                            ipkg_message(conf, IPKG_NOTICE, " unsatisfiable");
2237 +                                  }
2238 +                                  ipkg_message(conf, IPKG_NOTICE, "\n");
2239 +                                  goto next_package;
2240 +                             }
2241 +                        }
2242 +                   }
2243 +              next_package:
2244 +                   ;
2245 +              }
2246 +         } while (changed && recursive);
2247 +         pkg_vec_free(available_pkgs);
2248 +     }
2249 +
2250 +     return 0;
2251 +}
2252 +
2253 +int pkg_mark_provides(pkg_t *pkg)
2254 +{
2255 +     int provides_count = pkg->provides_count;
2256 +     abstract_pkg_t **provides = pkg->provides;
2257 +     int i;
2258 +     pkg->parent->state_flag |= SF_MARKED;
2259 +     for (i = 0; i < provides_count; i++) {
2260 +         provides[i]->state_flag |= SF_MARKED;
2261 +     }
2262 +     return 0;
2263 +}
2264 +
2265 +static int ipkg_whatdepends_recursively_cmd(ipkg_conf_t *conf, int argc, char **argv)
2266 +{
2267 +     return ipkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 1, argc, argv);
2268 +}
2269 +static int ipkg_whatdepends_cmd(ipkg_conf_t *conf, int argc, char **argv)
2270 +{
2271 +     return ipkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 0, argc, argv);
2272 +}
2273 +
2274 +static int ipkg_whatsuggests_cmd(ipkg_conf_t *conf, int argc, char **argv)
2275 +{
2276 +     return ipkg_what_depends_conflicts_cmd(conf, WHATSUGGESTS, 0, argc, argv);
2277 +}
2278 +
2279 +static int ipkg_whatrecommends_cmd(ipkg_conf_t *conf, int argc, char **argv)
2280 +{
2281 +     return ipkg_what_depends_conflicts_cmd(conf, WHATRECOMMENDS, 0, argc, argv);
2282 +}
2283 +
2284 +static int ipkg_whatconflicts_cmd(ipkg_conf_t *conf, int argc, char **argv)
2285 +{
2286 +     return ipkg_what_depends_conflicts_cmd(conf, WHATCONFLICTS, 0, argc, argv);
2287 +}
2288 +
2289 +static int ipkg_what_provides_replaces_cmd(ipkg_conf_t *conf, enum what_field_type what_field_type, int argc, char **argv)
2290 +{
2291 +
2292 +     if (argc > 0) {
2293 +         pkg_vec_t *available_pkgs = pkg_vec_alloc();
2294 +         const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
2295 +         int i;
2296 +
2297 +         pkg_info_preinstall_check(conf);
2298 +
2299 +         if (conf->query_all)
2300 +              pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
2301 +         else
2302 +              pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
2303 +         for (i = 0; i < argc; i++) {
2304 +              const char *target = argv[i];
2305 +              int j;
2306 +
2307 +              ipkg_message(conf, IPKG_ERROR, "What %s %s\n",
2308 +                           rel_str, target);
2309 +              for (j = 0; j < available_pkgs->len; j++) {
2310 +                   pkg_t *pkg = available_pkgs->pkgs[j];
2311 +                   int k;
2312 +                   int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
2313 +                   for (k = 0; k < count; k++) {
2314 +                        abstract_pkg_t *apkg =
2315 +                             ((what_field_type == WHATPROVIDES)
2316 +                              ? pkg->provides[k]
2317 +                              : pkg->replaces[k]);
2318 +                        if (fnmatch(target, apkg->name, 0) == 0) {
2319 +                             ipkg_message(conf, IPKG_ERROR, "    %s", pkg->name);
2320 +                             if (strcmp(target, apkg->name) != 0)
2321 +                                  ipkg_message(conf, IPKG_ERROR, "\t%s %s\n", rel_str, apkg->name);
2322 +                             ipkg_message(conf, IPKG_ERROR, "\n");
2323 +                        }
2324 +                   }
2325 +              }
2326 +         }
2327 +         pkg_vec_free(available_pkgs);
2328 +     }
2329 +     return 0;
2330 +}
2331 +
2332 +static int ipkg_whatprovides_cmd(ipkg_conf_t *conf, int argc, char **argv)
2333 +{
2334 +     return ipkg_what_provides_replaces_cmd(conf, WHATPROVIDES, argc, argv);
2335 +}
2336 +
2337 +static int ipkg_whatreplaces_cmd(ipkg_conf_t *conf, int argc, char **argv)
2338 +{
2339 +     return ipkg_what_provides_replaces_cmd(conf, WHATREPLACES, argc, argv);
2340 +}
2341 +
2342 +static int ipkg_search_cmd(ipkg_conf_t *conf, int argc, char **argv)
2343 +{
2344 +     int i;
2345 +
2346 +     pkg_vec_t *installed;
2347 +     pkg_t *pkg;
2348 +     str_list_t *installed_files;
2349 +     str_list_elt_t *iter;
2350 +     char *installed_file;
2351 +
2352 +     if (argc < 1) {
2353 +         return EINVAL;
2354 +     }
2355 +
2356 +     installed = pkg_vec_alloc();
2357 +     pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
2358 +
2359 +     for (i=0; i < installed->len; i++) {
2360 +         pkg = installed->pkgs[i];
2361 +
2362 +         installed_files = pkg_get_installed_files(pkg);
2363 +
2364 +         for (iter = installed_files->head; iter; iter = iter->next) {
2365 +              installed_file = iter->data;
2366 +              if (fnmatch(argv[0], installed_file, 0)==0)  {
2367 +#ifndef IPKG_LIB
2368 +                   printf("%s: %s\n", pkg->name, installed_file);
2369 +#else
2370 +                       if (ipkg_cb_list) ipkg_cb_list(pkg->name,
2371 +                                                      installed_file,
2372 +                                                      pkg_version_str_alloc(pkg),
2373 +                                                      pkg->state_status, p_userdata);
2374 +#endif
2375 +              }
2376 +         }
2377 +
2378 +         pkg_free_installed_files(pkg);
2379 +     }
2380 +
2381 +     /* XXX: CLEANUP: It's not obvious from the name of
2382 +       pkg_hash_fetch_all_installed that we need to call
2383 +       pkg_vec_free to avoid a memory leak. */
2384 +     pkg_vec_free(installed);
2385 +
2386 +     return 0;
2387 +}
2388 +
2389 +static int ipkg_compare_versions_cmd(ipkg_conf_t *conf, int argc, char **argv)
2390 +{
2391 +     if (argc == 3) {
2392 +         /* this is a bit gross */
2393 +         struct pkg p1, p2;
2394 +         parseVersion(&p1, argv[0]);
2395 +         parseVersion(&p2, argv[2]);
2396 +         return pkg_version_satisfied(&p1, &p2, argv[1]);
2397 +     } else {
2398 +         ipkg_message(conf, IPKG_ERROR,
2399 +                      "ipkg compare_versions <v1> <op> <v2>\n"
2400 +                      "<op> is one of <= >= << >> =\n");
2401 +         return -1;
2402 +     }
2403 +}
2404 +
2405 +#ifndef HOST_CPU_STR
2406 +#define HOST_CPU_STR__(X) #X
2407 +#define HOST_CPU_STR_(X) HOST_CPU_STR__(X)
2408 +#define HOST_CPU_STR HOST_CPU_STR_(HOST_CPU_FOO)
2409 +#endif
2410 +
2411 +static int ipkg_print_architecture_cmd(ipkg_conf_t *conf, int argc, char **argv)
2412 +{
2413 +     nv_pair_list_elt_t *l;
2414 +
2415 +     l = conf->arch_list.head;
2416 +     while (l) {
2417 +         nv_pair_t *nv = l->data;
2418 +         printf("arch %s %s\n", nv->name, nv->value);
2419 +         l = l->next;
2420 +     }
2421 +     return 0;
2422 +}
2423 +
2424 +
2425 Index: busybox-1.7.2/archival/libipkg/ipkg_cmd.h
2426 ===================================================================
2427 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
2428 +++ busybox-1.7.2/archival/libipkg/ipkg_cmd.h   2007-10-04 17:14:22.493023228 +0200
2429 @@ -0,0 +1,46 @@
2430 +/* ipkg_cmd.h - the itsy package management system
2431 +
2432 +   Carl D. Worth
2433 +
2434 +   Copyright (C) 2001 University of Southern California
2435 +
2436 +   This program is free software; you can redistribute it and/or
2437 +   modify it under the terms of the GNU General Public License as
2438 +   published by the Free Software Foundation; either version 2, or (at
2439 +   your option) any later version.
2440 +
2441 +   This program is distributed in the hope that it will be useful, but
2442 +   WITHOUT ANY WARRANTY; without even the implied warranty of
2443 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2444 +   General Public License for more details.
2445 +*/
2446 +
2447 +#ifndef IPKG_CMD_H
2448 +#define IPKG_CMD_H
2449 +
2450 +typedef int (*ipkg_cmd_fun_t)(ipkg_conf_t *conf, int argc, const char **argv);
2451 +
2452 +struct ipkg_cmd
2453 +{
2454 +    char *name;
2455 +    int requires_args;
2456 +    ipkg_cmd_fun_t fun;
2457 +};
2458 +typedef struct ipkg_cmd ipkg_cmd_t;
2459 +
2460 +ipkg_cmd_t *ipkg_cmd_find(const char *name);
2461 +#ifdef IPKG_LIB
2462 +int ipkg_cmd_exec(ipkg_cmd_t *cmd, ipkg_conf_t *conf, int argc,
2463 +                  const char **argv, void *userdata);
2464 +#else
2465 +int ipkg_cmd_exec(ipkg_cmd_t *cmd, ipkg_conf_t *conf, int argc, const char **argv);
2466 +#endif
2467 +int ipkg_multiple_files_scan (ipkg_conf_t *conf, int argc, char *argv[]);
2468 +/* install any packges with state_want == SW_INSTALL */
2469 +int ipkg_install_wanted_packages(ipkg_conf_t *conf);
2470 +/* ensure that all dependences are satisfied */
2471 +int ipkg_configure_packages(ipkg_conf_t *conf, char *pkg_name);
2472 +
2473 +int pkg_mark_provides(pkg_t *pkg);
2474 +
2475 +#endif
2476 Index: busybox-1.7.2/archival/libipkg/ipkg_conf.c
2477 ===================================================================
2478 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
2479 +++ busybox-1.7.2/archival/libipkg/ipkg_conf.c  2007-10-04 17:14:22.513024368 +0200
2480 @@ -0,0 +1,711 @@
2481 +/* ipkg_conf.c - the itsy package management system
2482 +
2483 +   Carl D. Worth
2484 +
2485 +   Copyright (C) 2001 University of Southern California
2486 +
2487 +   This program is free software; you can redistribute it and/or
2488 +   modify it under the terms of the GNU General Public License as
2489 +   published by the Free Software Foundation; either version 2, or (at
2490 +   your option) any later version.
2491 +
2492 +   This program is distributed in the hope that it will be useful, but
2493 +   WITHOUT ANY WARRANTY; without even the implied warranty of
2494 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2495 +   General Public License for more details.
2496 +*/
2497 +
2498 +#include <glob.h>
2499 +
2500 +#include "ipkg.h"
2501 +#include "ipkg_conf.h"
2502 +
2503 +#include "xregex.h"
2504 +#include "sprintf_alloc.h"
2505 +#include "ipkg_conf.h"
2506 +#include "ipkg_message.h"
2507 +#include "file_util.h"
2508 +#include "str_util.h"
2509 +#include "xsystem.h"
2510 +
2511 +
2512 +ipkg_conf_t *global_conf;
2513 +
2514 +static int ipkg_conf_parse_file(ipkg_conf_t *conf, const char *filename,
2515 +                               pkg_src_list_t *pkg_src_list,
2516 +                               nv_pair_list_t *tmp_dest_nv_pair_list,
2517 +                               char **tmp_lists_dir);
2518 +static int ipkg_init_options_array(const ipkg_conf_t *conf, ipkg_option_t **options);
2519 +static int ipkg_conf_set_option(const ipkg_option_t *options,
2520 +                               const char *name, const char *value);
2521 +static int ipkg_conf_set_default_dest(ipkg_conf_t *conf,
2522 +                                     const char *default_dest_name);
2523 +static int set_and_load_pkg_src_list(ipkg_conf_t *conf,
2524 +                                    pkg_src_list_t *nv_pair_list);
2525 +static int set_and_load_pkg_dest_list(ipkg_conf_t *conf,
2526 +                                     nv_pair_list_t *nv_pair_list, char * lists_dir);
2527 +
2528 +int ipkg_init_options_array(const ipkg_conf_t *conf, ipkg_option_t **options)
2529 +{
2530 +     ipkg_option_t tmp[] = {
2531 +         { "force_defaults", IPKG_OPT_TYPE_BOOL, &conf->force_defaults },
2532 +         { "force_depends", IPKG_OPT_TYPE_BOOL, &conf->force_depends },
2533 +         { "force_overwrite", IPKG_OPT_TYPE_BOOL, &conf->force_overwrite },
2534 +         { "force_downgrade", IPKG_OPT_TYPE_BOOL, &conf->force_downgrade },
2535 +         { "force_reinstall", IPKG_OPT_TYPE_BOOL, &conf->force_reinstall },
2536 +         { "force_space", IPKG_OPT_TYPE_BOOL, &conf->force_space },
2537 +         { "ftp_proxy", IPKG_OPT_TYPE_STRING, &conf->ftp_proxy },
2538 +         { "http_proxy", IPKG_OPT_TYPE_STRING, &conf->http_proxy },
2539 +         { "multiple_providers", IPKG_OPT_TYPE_BOOL, &conf->multiple_providers },
2540 +         { "no_proxy", IPKG_OPT_TYPE_STRING, &conf->no_proxy },
2541 +         { "test", IPKG_OPT_TYPE_INT, &conf->noaction },
2542 +         { "noaction", IPKG_OPT_TYPE_INT, &conf->noaction },
2543 +         { "nodeps", IPKG_OPT_TYPE_BOOL, &conf->nodeps },
2544 +         { "offline_root", IPKG_OPT_TYPE_STRING, &conf->offline_root },
2545 +         { "offline_root_post_script_cmd", IPKG_OPT_TYPE_STRING, &conf->offline_root_post_script_cmd },
2546 +         { "offline_root_pre_script_cmd", IPKG_OPT_TYPE_STRING, &conf->offline_root_pre_script_cmd },
2547 +         { "proxy_passwd", IPKG_OPT_TYPE_STRING, &conf->proxy_passwd },
2548 +         { "proxy_user", IPKG_OPT_TYPE_STRING, &conf->proxy_user },
2549 +         { "query-all", IPKG_OPT_TYPE_BOOL, &conf->query_all },
2550 +         { "verbose-wget", IPKG_OPT_TYPE_BOOL, &conf->verbose_wget },
2551 +         { "verbosity", IPKG_OPT_TYPE_BOOL, &conf->verbosity },
2552 +         { NULL }
2553 +     };
2554 +
2555 +     *options = (ipkg_option_t *)malloc(sizeof(tmp));
2556 +     if ( options == NULL ){
2557 +        fprintf(stderr,"%s: Unable to allocate memory\n",__FUNCTION__);
2558 +        return -1;
2559 +     }
2560 +
2561 +     memcpy(*options, tmp, sizeof(tmp));
2562 +     return 0;
2563 +};
2564 +
2565 +static void ipkg_conf_override_string(char **conf_str, char *arg_str)
2566 +{
2567 +     if (arg_str) {
2568 +         if (*conf_str) {
2569 +              free(*conf_str);
2570 +         }
2571 +         *conf_str = strdup(arg_str);
2572 +     }
2573 +}
2574 +
2575 +static void ipkg_conf_free_string(char **conf_str)
2576 +{
2577 +     if (*conf_str) {
2578 +         free(*conf_str);
2579 +         *conf_str = NULL;
2580 +     }
2581 +}
2582 +
2583 +int ipkg_conf_init(ipkg_conf_t *conf, const args_t *args)
2584 +{
2585 +     int err;
2586 +     char *tmp_dir_base;
2587 +     nv_pair_list_t tmp_dest_nv_pair_list;
2588 +     char * lists_dir =NULL;
2589 +     glob_t globbuf;
2590 +     char *etc_ipkg_conf_pattern = "/etc/ipkg/*.conf";
2591 +     char *pending_dir  =NULL;
2592 +
2593 +     memset(conf, 0, sizeof(ipkg_conf_t));
2594 +
2595 +     pkg_src_list_init(&conf->pkg_src_list);
2596 +
2597 +     nv_pair_list_init(&tmp_dest_nv_pair_list);
2598 +     pkg_dest_list_init(&conf->pkg_dest_list);
2599 +
2600 +     nv_pair_list_init(&conf->arch_list);
2601 +
2602 +     conf->restrict_to_default_dest = 0;
2603 +     conf->default_dest = NULL;
2604 +
2605 +
2606 +     if (args->tmp_dir)
2607 +         tmp_dir_base = args->tmp_dir;
2608 +     else
2609 +         tmp_dir_base = getenv("TMPDIR");
2610 +     sprintf_alloc(&conf->tmp_dir, "%s/%s",
2611 +                  tmp_dir_base ? tmp_dir_base : IPKG_CONF_DEFAULT_TMP_DIR_BASE,
2612 +                  IPKG_CONF_TMP_DIR_SUFFIX);
2613 +     conf->tmp_dir = mkdtemp(conf->tmp_dir);
2614 +     if (conf->tmp_dir == NULL) {
2615 +         fprintf(stderr, "%s: Failed to create temporary directory `%s': %s\n",
2616 +                 __FUNCTION__, conf->tmp_dir, strerror(errno));
2617 +         return errno;
2618 +     }
2619 +
2620 +     conf->force_depends = 0;
2621 +     conf->force_defaults = 0;
2622 +     conf->force_overwrite = 0;
2623 +     conf->force_downgrade = 0;
2624 +     conf->force_reinstall = 0;
2625 +     conf->force_space = 0;
2626 +     conf->force_removal_of_essential_packages = 0;
2627 +     conf->force_removal_of_dependent_packages = 0;
2628 +     conf->nodeps = 0;
2629 +     conf->verbose_wget = 0;
2630 +     conf->offline_root = NULL;
2631 +     conf->offline_root_pre_script_cmd = NULL;
2632 +     conf->offline_root_post_script_cmd = NULL;
2633 +     conf->multiple_providers = 0;
2634 +     conf->verbosity = 1;
2635 +     conf->noaction = 0;
2636 +
2637 +     conf->http_proxy = NULL;
2638 +     conf->ftp_proxy = NULL;
2639 +     conf->no_proxy = NULL;
2640 +     conf->proxy_user = NULL;
2641 +     conf->proxy_passwd = NULL;
2642 +
2643 +     pkg_hash_init("pkg-hash", &conf->pkg_hash, IPKG_CONF_DEFAULT_HASH_LEN);
2644 +     hash_table_init("file-hash", &conf->file_hash, IPKG_CONF_DEFAULT_HASH_LEN);
2645 +     hash_table_init("obs-file-hash", &conf->obs_file_hash, IPKG_CONF_DEFAULT_HASH_LEN);
2646 +     lists_dir=(char *)malloc(1);
2647 +     lists_dir[0]='\0';
2648 +     if (args->conf_file) {
2649 +         struct stat stat_buf;
2650 +         err = stat(args->conf_file, &stat_buf);
2651 +         if (err == 0)
2652 +              if (ipkg_conf_parse_file(conf, args->conf_file,
2653 +                                   &conf->pkg_src_list, &tmp_dest_nv_pair_list,&lists_dir)<0) {
2654 +                   /* Memory leakage from ipkg_conf_parse-file */
2655 +                   return -1;
2656 +               }
2657 +
2658 +     }
2659 +
2660 +     /* if (!lists_dir ){*/
2661 +     if (strlen(lists_dir)<=1 ){
2662 +        lists_dir = realloc(lists_dir,strlen(IPKG_CONF_LISTS_DIR)+2);
2663 +        sprintf (lists_dir,"%s",IPKG_CONF_LISTS_DIR);
2664 +     }
2665 +
2666 +     if (args->offline_root) {
2667 +            char *tmp = malloc(strlen(lists_dir) + strlen(args->offline_root) + 1);
2668 +            sprintf_alloc(&tmp, "%s/%s",args->offline_root,lists_dir);
2669 +            free(lists_dir);
2670 +            lists_dir = tmp;
2671 +     }
2672 +
2673 +     pending_dir = malloc(strlen(lists_dir)+strlen("/pending")+5);
2674 +     snprintf(pending_dir,strlen(lists_dir)+strlen("/pending") ,"%s%s",lists_dir,"/pending");
2675 +
2676 +     conf->lists_dir = strdup(lists_dir);
2677 +     conf->pending_dir = strdup(pending_dir);
2678 +
2679 +     if (args->offline_root)
2680 +         sprintf_alloc(&etc_ipkg_conf_pattern, "%s/etc/ipkg/*.conf", args->offline_root);
2681 +     memset(&globbuf, 0, sizeof(globbuf));
2682 +     err = glob(etc_ipkg_conf_pattern, 0, NULL, &globbuf);
2683 +     if (!err) {
2684 +         int i;
2685 +         for (i = 0; i < globbuf.gl_pathc; i++) {
2686 +              if (globbuf.gl_pathv[i])
2687 +                   if ( ipkg_conf_parse_file(conf, globbuf.gl_pathv[i],
2688 +                                        &conf->pkg_src_list, &tmp_dest_nv_pair_list,&lists_dir)<0) {
2689 +                        /* Memory leakage from ipkg_conf_parse-file */
2690 +                        return -1;
2691 +                   }
2692 +         }
2693 +     }
2694 +     globfree(&globbuf);
2695 +
2696 +     /* if no architectures were defined, then default all, noarch, and host architecture */
2697 +     if (nv_pair_list_empty(&conf->arch_list)) {
2698 +         nv_pair_list_append(&conf->arch_list, "all", "1");
2699 +         nv_pair_list_append(&conf->arch_list, "noarch", "1");
2700 +         nv_pair_list_append(&conf->arch_list, HOST_CPU_STR, "10");
2701 +     }
2702 +
2703 +     /* Even if there is no conf file, we'll need at least one dest. */
2704 +     if (tmp_dest_nv_pair_list.head == NULL) {
2705 +         nv_pair_list_append(&tmp_dest_nv_pair_list,
2706 +                             IPKG_CONF_DEFAULT_DEST_NAME,
2707 +                             IPKG_CONF_DEFAULT_DEST_ROOT_DIR);
2708 +     }
2709 +
2710 +     /* After parsing the file, set options from command-line, (so that
2711 +       command-line arguments take precedence) */
2712 +     /* XXX: CLEANUP: The interaction between args.c and ipkg_conf.c
2713 +       really needs to be cleaned up. There is so much duplication
2714 +       right now it is ridiculous. Maybe ipkg_conf_t should just save
2715 +       a pointer to args_t (which could then not be freed), rather
2716 +       than duplicating every field here? */
2717 +     if (args->force_depends) {
2718 +         conf->force_depends = 1;
2719 +     }
2720 +     if (args->force_defaults) {
2721 +         conf->force_defaults = 1;
2722 +     }
2723 +     if (args->force_overwrite) {
2724 +         conf->force_overwrite = 1;
2725 +     }
2726 +     if (args->force_downgrade) {
2727 +         conf->force_downgrade = 1;
2728 +     }
2729 +     if (args->force_reinstall) {
2730 +         conf->force_reinstall = 1;
2731 +     }
2732 +     if (args->force_removal_of_dependent_packages) {
2733 +         conf->force_removal_of_dependent_packages = 1;
2734 +     }
2735 +     if (args->force_removal_of_essential_packages) {
2736 +         conf->force_removal_of_essential_packages = 1;
2737 +     }
2738 +     if (args->nodeps) {
2739 +         conf->nodeps = 1;
2740 +     }
2741 +     if (args->noaction) {
2742 +         conf->noaction = 1;
2743 +     }
2744 +     if (args->query_all) {
2745 +         conf->query_all = 1;
2746 +     }
2747 +     if (args->verbose_wget) {
2748 +         conf->verbose_wget = 1;
2749 +     }
2750 +     if (args->multiple_providers) {
2751 +         conf->multiple_providers = 1;
2752 +     }
2753 +     if (args->verbosity != conf->verbosity) {
2754 +         conf->verbosity = args->verbosity;
2755 +     }
2756 +
2757 +     ipkg_conf_override_string(&conf->offline_root,
2758 +                              args->offline_root);
2759 +     ipkg_conf_override_string(&conf->offline_root_pre_script_cmd,
2760 +                              args->offline_root_pre_script_cmd);
2761 +     ipkg_conf_override_string(&conf->offline_root_post_script_cmd,
2762 +                              args->offline_root_post_script_cmd);
2763 +
2764 +/* Pigi: added a flag to disable the checking of structures if the command does not need to
2765 +         read anything from there.
2766 +*/
2767 +     if ( !(args->nocheckfordirorfile)){
2768 +        /* need to run load the source list before dest list -Jamey */
2769 +        if ( !(args->noreadfeedsfile))
2770 +           set_and_load_pkg_src_list(conf, &conf->pkg_src_list);
2771 +
2772 +        /* Now that we have resolved conf->offline_root, we can commit to
2773 +          the directory names for the dests and load in all the package
2774 +          lists. */
2775 +        set_and_load_pkg_dest_list(conf, &tmp_dest_nv_pair_list,lists_dir);
2776 +
2777 +        if (args->dest) {
2778 +            err = ipkg_conf_set_default_dest(conf, args->dest);
2779 +            if (err) {
2780 +                 return err;
2781 +            }
2782 +        }
2783 +     }
2784 +     nv_pair_list_deinit(&tmp_dest_nv_pair_list);
2785 +     free(lists_dir);
2786 +     free(pending_dir);
2787 +
2788 +     return 0;
2789 +}
2790 +
2791 +void ipkg_conf_deinit(ipkg_conf_t *conf)
2792 +{
2793 +#ifdef IPKG_DEBUG_NO_TMP_CLEANUP
2794 +#error
2795 +     fprintf(stderr, "%s: Not cleaning up %s since ipkg compiled "
2796 +            "with IPKG_DEBUG_NO_TMP_CLEANUP\n",
2797 +            __FUNCTION__, conf->tmp_dir);
2798 +#else
2799 +     int err;
2800 +
2801 +     err = rmdir(conf->tmp_dir);
2802 +     if (err) {
2803 +         if (errno == ENOTEMPTY) {
2804 +              char *cmd;
2805 +              sprintf_alloc(&cmd, "rm -fr %s\n", conf->tmp_dir);
2806 +              err = xsystem(cmd);
2807 +              free(cmd);
2808 +         }
2809 +         if (err)
2810 +              fprintf(stderr, "WARNING: Unable to remove temporary directory: %s: %s\n", conf->tmp_dir, strerror(errno));
2811 +     }
2812 +#endif /* IPKG_DEBUG_NO_TMP_CLEANUP */
2813 +
2814 +     free(conf->tmp_dir); /*XXX*/
2815 +
2816 +     pkg_src_list_deinit(&conf->pkg_src_list);
2817 +     pkg_dest_list_deinit(&conf->pkg_dest_list);
2818 +     nv_pair_list_deinit(&conf->arch_list);
2819 +     if (&conf->pkg_hash)
2820 +                   pkg_hash_deinit(&conf->pkg_hash);
2821 +     if (&conf->file_hash)
2822 +                   hash_table_deinit(&conf->file_hash);
2823 +     if (&conf->obs_file_hash)
2824 +                   hash_table_deinit(&conf->obs_file_hash);
2825 +
2826 +     ipkg_conf_free_string(&conf->offline_root);
2827 +     ipkg_conf_free_string(&conf->offline_root_pre_script_cmd);
2828 +     ipkg_conf_free_string(&conf->offline_root_post_script_cmd);
2829 +
2830 +     if (conf->verbosity > 1) {
2831 +         int i;
2832 +         hash_table_t *hashes[] = {
2833 +              &conf->pkg_hash,
2834 +              &conf->file_hash,
2835 +              &conf->obs_file_hash };
2836 +         for (i = 0; i < 3; i++) {
2837 +              hash_table_t *hash = hashes[i];
2838 +              int c = 0;
2839 +              int n_conflicts = 0;
2840 +              int j;
2841 +              for (j = 0; j < hash->n_entries; j++) {
2842 +                   int len = 0;
2843 +                   hash_entry_t *e = &hash->entries[j];
2844 +                   if (e->next)
2845 +                        n_conflicts++;
2846 +                   while (e && e->key) {
2847 +                        len++;
2848 +                        e = e->next;
2849 +                   }
2850 +                   if (len > c)
2851 +                        c = len;
2852 +              }
2853 +              ipkg_message(conf, IPKG_DEBUG, "hash_table[%s] n_buckets=%d n_elements=%d max_conflicts=%d n_conflicts=%d\n",
2854 +                           hash->name, hash->n_entries, hash->n_elements, c, n_conflicts);
2855 +              hash_table_deinit(hash);
2856 +         }
2857 +     }
2858 +}
2859 +
2860 +static int ipkg_conf_set_default_dest(ipkg_conf_t *conf,
2861 +                                     const char *default_dest_name)
2862 +{
2863 +     pkg_dest_list_elt_t *iter;
2864 +     pkg_dest_t *dest;
2865 +
2866 +     for (iter = conf->pkg_dest_list.head; iter; iter = iter->next) {
2867 +         dest = iter->data;
2868 +         if (strcmp(dest->name, default_dest_name) == 0) {
2869 +              conf->default_dest = dest;
2870 +              conf->restrict_to_default_dest = 1;
2871 +              return 0;
2872 +         }
2873 +     }
2874 +
2875 +     fprintf(stderr, "ERROR: Unknown dest name: `%s'\n", default_dest_name);
2876 +
2877 +     return 1;
2878 +}
2879 +
2880 +static int set_and_load_pkg_src_list(ipkg_conf_t *conf, pkg_src_list_t *pkg_src_list)
2881 +{
2882 +     pkg_src_list_elt_t *iter;
2883 +     pkg_src_t *src;
2884 +     char *list_file;
2885 +
2886 +     for (iter = pkg_src_list->head; iter; iter = iter->next) {
2887 +          src = iter->data;
2888 +         if (src == NULL) {
2889 +              continue;
2890 +         }
2891 +
2892 +         sprintf_alloc(&list_file, "%s/%s",
2893 +                         conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir,
2894 +                         src->name);
2895 +
2896 +         if (file_exists(list_file)) {
2897 +              pkg_hash_add_from_file(conf, list_file, src, NULL, 0);
2898 +         }
2899 +         free(list_file);
2900 +     }
2901 +
2902 +     return 0;
2903 +}
2904 +
2905 +static int set_and_load_pkg_dest_list(ipkg_conf_t *conf, nv_pair_list_t *nv_pair_list, char *lists_dir )
2906 +{
2907 +     nv_pair_list_elt_t *iter;
2908 +     nv_pair_t *nv_pair;
2909 +     pkg_dest_t *dest;
2910 +     char *root_dir;
2911 +
2912 +     for (iter = nv_pair_list->head; iter; iter = iter->next) {
2913 +         nv_pair = iter->data;
2914 +
2915 +         if (conf->offline_root) {
2916 +              sprintf_alloc(&root_dir, "%s%s", conf->offline_root, nv_pair->value);
2917 +         } else {
2918 +              root_dir = strdup(nv_pair->value);
2919 +         }
2920 +         dest = pkg_dest_list_append(&conf->pkg_dest_list, nv_pair->name, root_dir, lists_dir);
2921 +         free(root_dir);
2922 +         if (dest == NULL) {
2923 +              continue;
2924 +         }
2925 +         if (conf->default_dest == NULL) {
2926 +              conf->default_dest = dest;
2927 +         }
2928 +         if (file_exists(dest->status_file_name)) {
2929 +              pkg_hash_add_from_file(conf, dest->status_file_name,
2930 +                                     NULL, dest, 1);
2931 +         }
2932 +     }
2933 +
2934 +     return 0;
2935 +}
2936 +
2937 +static int ipkg_conf_parse_file(ipkg_conf_t *conf, const char *filename,
2938 +                               pkg_src_list_t *pkg_src_list,
2939 +                               nv_pair_list_t *tmp_dest_nv_pair_list,
2940 +                               char **lists_dir)
2941 +{
2942 +     ipkg_option_t * options;
2943 +     FILE *file = fopen(filename, "r");
2944 +     regex_t valid_line_re, comment_re;
2945 +#define regmatch_size 12
2946 +     regmatch_t regmatch[regmatch_size];
2947 +
2948 +     if (ipkg_init_options_array(conf, &options)<0)
2949 +        return ENOMEM;
2950 +
2951 +     if (file == NULL) {
2952 +         fprintf(stderr, "%s: failed to open %s: %s\n",
2953 +                 __FUNCTION__, filename, strerror(errno));
2954 +         free(options);
2955 +         return errno;
2956 +     }
2957 +     ipkg_message(conf, IPKG_NOTICE, "loading conf file %s\n", filename);
2958 +
2959 +     xregcomp(&comment_re,
2960 +                   "^[[:space:]]*(#.*|[[:space:]]*)$",
2961 +                   REG_EXTENDED);
2962 +     xregcomp(&valid_line_re, "^[[:space:]]*(\"([^\"]*)\"|([^[:space:]]*))[[:space:]]*(\"([^\"]*)\"|([^[:space:]]*))[[:space:]]*(\"([^\"]*)\"|([^[:space:]]*))([[:space:]]+([^[:space:]]+))?[[:space:]]*$", REG_EXTENDED);
2963 +
2964 +     while(1) {
2965 +         int line_num = 0;
2966 +         char *line;
2967 +         char *type, *name, *value, *extra;
2968 +
2969 +         line = file_read_line_alloc(file);
2970 +         line_num++;
2971 +         if (line == NULL) {
2972 +              break;
2973 +         }
2974 +
2975 +         str_chomp(line);
2976 +
2977 +         if (regexec(&comment_re, line, 0, 0, 0) == 0) {
2978 +              goto NEXT_LINE;
2979 +         }
2980 +
2981 +         if (regexec(&valid_line_re, line, regmatch_size, regmatch, 0) == REG_NOMATCH) {
2982 +              str_chomp(line);
2983 +              fprintf(stderr, "%s:%d: Ignoring invalid line: `%s'\n",
2984 +                      filename, line_num, line);
2985 +              goto NEXT_LINE;
2986 +         }
2987 +
2988 +         /* This has to be so ugly to deal with optional quotation marks */
2989 +         if (regmatch[2].rm_so > 0) {
2990 +              type = strndup(line + regmatch[2].rm_so,
2991 +                             regmatch[2].rm_eo - regmatch[2].rm_so);
2992 +         } else {
2993 +              type = strndup(line + regmatch[3].rm_so,
2994 +                             regmatch[3].rm_eo - regmatch[3].rm_so);
2995 +         }
2996 +         if (regmatch[5].rm_so > 0) {
2997 +              name = strndup(line + regmatch[5].rm_so,
2998 +                             regmatch[5].rm_eo - regmatch[5].rm_so);
2999 +         } else {
3000 +              name = strndup(line + regmatch[6].rm_so,
3001 +                             regmatch[6].rm_eo - regmatch[6].rm_so);
3002 +         }
3003 +         if (regmatch[8].rm_so > 0) {
3004 +              value = strndup(line + regmatch[8].rm_so,
3005 +                              regmatch[8].rm_eo - regmatch[8].rm_so);
3006 +         } else {
3007 +              value = strndup(line + regmatch[9].rm_so,
3008 +                              regmatch[9].rm_eo - regmatch[9].rm_so);
3009 +         }
3010 +         extra = NULL;
3011 +         if (regmatch[11].rm_so > 0) {
3012 +              extra = strndup (line + regmatch[11].rm_so,
3013 +                               regmatch[11].rm_eo - regmatch[11].rm_so);
3014 +         }
3015 +
3016 +         /* We use the tmp_dest_nv_pair_list below instead of
3017 +            conf->pkg_dest_list because we might encounter an
3018 +            offline_root option later and that would invalidate the
3019 +            directories we would have computed in
3020 +            pkg_dest_list_init. (We do a similar thing with
3021 +            tmp_src_nv_pair_list for sake of symmetry.) */
3022 +         if (strcmp(type, "option") == 0) {
3023 +              ipkg_conf_set_option(options, name, value);
3024 +         } else if (strcmp(type, "src") == 0) {
3025 +              if (!nv_pair_list_find((nv_pair_list_t *)pkg_src_list, name)) {
3026 +                   pkg_src_list_append (pkg_src_list, name, value, extra, 0);
3027 +              } else {
3028 +                   ipkg_message(conf, IPKG_ERROR, "ERROR: duplicate src declaration.  Skipping:\n\t src %s %s\n",
3029 +                                name, value);
3030 +              }
3031 +         } else if (strcmp(type, "src/gz") == 0) {
3032 +              if (!nv_pair_list_find((nv_pair_list_t *)pkg_src_list, name)) {
3033 +                   pkg_src_list_append (pkg_src_list, name, value, extra, 1);
3034 +              } else {
3035 +                   ipkg_message(conf, IPKG_ERROR, "ERROR: duplicate src declaration.  Skipping:\n\t src %s %s\n",
3036 +                                name, value);
3037 +              }
3038 +         } else if (strcmp(type, "dest") == 0) {
3039 +              nv_pair_list_append(tmp_dest_nv_pair_list, name, value);
3040 +         } else if (strcmp(type, "lists_dir") == 0) {
3041 +              *lists_dir = realloc(*lists_dir,strlen(value)+1);
3042 +               if (*lists_dir == NULL) {
3043 +                   ipkg_message(conf, IPKG_ERROR, "ERROR: Not enough memory\n");
3044 +                   free(options);
3045 +                   return EINVAL;
3046 +               }
3047 +               sprintf (*lists_dir,"%s",value);
3048 +         } else if (strcmp(type, "arch") == 0) {
3049 +              ipkg_message(conf, IPKG_INFO, "supported arch %s priority (%s)\n", name, value);
3050 +              if (!value) {
3051 +                   ipkg_message(conf, IPKG_NOTICE, "defaulting architecture %s priority to 10\n", name);
3052 +                   value = strdup("10");
3053 +              }
3054 +              nv_pair_list_append(&conf->arch_list, strdup(name), strdup(value));
3055 +         } else {
3056 +              fprintf(stderr, "WARNING: Ignoring unknown configuration "
3057 +                      "parameter: %s %s %s\n", type, name, value);
3058 +              free(options);
3059 +              return EINVAL;
3060 +         }
3061 +
3062 +         free(type);
3063 +         free(name);
3064 +         free(value);
3065 +         if (extra)
3066 +              free (extra);
3067 +
3068 +     NEXT_LINE:
3069 +         free(line);
3070 +     }
3071 +
3072 +     free(options);
3073 +     regfree(&comment_re);
3074 +     regfree(&valid_line_re);
3075 +     fclose(file);
3076 +
3077 +     return 0;
3078 +}
3079 +
3080 +static int ipkg_conf_set_option(const ipkg_option_t *options,
3081 +                               const char *name, const char *value)
3082 +{
3083 +     int i = 0;
3084 +     while (options[i].name) {
3085 +         if (strcmp(options[i].name, name) == 0) {
3086 +              switch (options[i].type) {
3087 +              case IPKG_OPT_TYPE_BOOL:
3088 +                   *((int *)options[i].value) = 1;
3089 +                   return 0;
3090 +              case IPKG_OPT_TYPE_INT:
3091 +                   if (value) {
3092 +                        *((int *)options[i].value) = atoi(value);
3093 +                        return 0;
3094 +                   } else {
3095 +                        printf("%s: Option %s need an argument\n",
3096 +                               __FUNCTION__, name);
3097 +                        return EINVAL;
3098 +                   }
3099 +              case IPKG_OPT_TYPE_STRING:
3100 +                   if (value) {
3101 +                        *((char **)options[i].value) = strdup(value);
3102 +                        return 0;
3103 +                   } else {
3104 +                        printf("%s: Option %s need an argument\n",
3105 +                               __FUNCTION__, name);
3106 +                        return EINVAL;
3107 +                   }
3108 +              }
3109 +         }
3110 +         i++;
3111 +     }
3112 +
3113 +     fprintf(stderr, "%s: Unrecognized option: %s=%s\n",
3114 +            __FUNCTION__, name, value);
3115 +     return EINVAL;
3116 +}
3117 +
3118 +int ipkg_conf_write_status_files(ipkg_conf_t *conf)
3119 +{
3120 +     pkg_dest_list_elt_t *iter;
3121 +     pkg_dest_t *dest;
3122 +     pkg_vec_t *all;
3123 +     pkg_t *pkg;
3124 +     register int i;
3125 +     int err;
3126 +
3127 +     if (conf->noaction)
3128 +         return 0;
3129 +     for (iter = conf->pkg_dest_list.head; iter; iter = iter->next) {
3130 +         dest = iter->data;
3131 +         dest->status_file = fopen(dest->status_file_tmp_name, "w");
3132 +         if (dest->status_file == NULL) {
3133 +              fprintf(stderr, "%s: Can't open status file: %s for writing: %s\n",
3134 +                      __FUNCTION__, dest->status_file_name, strerror(errno));
3135 +         }
3136 +     }
3137 +
3138 +     all = pkg_vec_alloc();
3139 +     pkg_hash_fetch_available(&conf->pkg_hash, all);
3140 +
3141 +     for(i = 0; i < all->len; i++) {
3142 +         pkg = all->pkgs[i];
3143 +         /* We don't need most uninstalled packages in the status file */
3144 +         if (pkg->state_status == SS_NOT_INSTALLED
3145 +             && (pkg->state_want == SW_UNKNOWN
3146 +                 || pkg->state_want == SW_DEINSTALL
3147 +                 || pkg->state_want == SW_PURGE)) {
3148 +              continue;
3149 +         }
3150 +         if (!pkg) {
3151 +           fprintf(stderr, "Null package\n");
3152 +         }
3153 +         if (pkg->dest == NULL) {
3154 +              fprintf(stderr, "%s: ERROR: Can't write status for "
3155 +                      "package %s since it has a NULL dest\n",
3156 +                      __FUNCTION__, pkg->name);
3157 +              continue;
3158 +         }
3159 +         if (pkg->dest->status_file) {
3160 +              pkg_print_status(pkg, pkg->dest->status_file);
3161 +         }
3162 +     }
3163 +
3164 +     pkg_vec_free(all);
3165 +
3166 +     for (iter = conf->pkg_dest_list.head; iter; iter = iter->next) {
3167 +         dest = iter->data;
3168 +         if (dest->status_file) {
3169 +              err = ferror(dest->status_file);
3170 +              fclose(dest->status_file);
3171 +              dest->status_file = NULL;
3172 +              if (!err) {
3173 +                   file_move(dest->status_file_tmp_name, dest->status_file_name);
3174 +              } else {
3175 +                   fprintf(stderr, "%s: ERROR: An error has occurred writing %s, "
3176 +                           "retaining old %s\n", __FUNCTION__,
3177 +                           dest->status_file_tmp_name, dest->status_file_name);
3178 +              }
3179 +         }
3180 +     }
3181 +
3182 +     return 0;
3183 +}
3184 +
3185 +
3186 +char *root_filename_alloc(ipkg_conf_t *conf, char *filename)
3187 +{
3188 +     char *root_filename;
3189 +     sprintf_alloc(&root_filename, "%s%s", (conf->offline_root ? conf->offline_root : ""), filename);
3190 +     return root_filename;
3191 +}
3192 Index: busybox-1.7.2/archival/libipkg/ipkg_conf.h
3193 ===================================================================
3194 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3195 +++ busybox-1.7.2/archival/libipkg/ipkg_conf.h  2007-10-04 17:14:22.545026188 +0200
3196 @@ -0,0 +1,107 @@
3197 +/* ipkg_conf.h - the itsy package management system
3198 +
3199 +   Carl D. Worth
3200 +
3201 +   Copyright (C) 2001 University of Southern California
3202 +
3203 +   This program is free software; you can redistribute it and/or
3204 +   modify it under the terms of the GNU General Public License as
3205 +   published by the Free Software Foundation; either version 2, or (at
3206 +   your option) any later version.
3207 +
3208 +   This program is distributed in the hope that it will be useful, but
3209 +   WITHOUT ANY WARRANTY; without even the implied warranty of
3210 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3211 +   General Public License for more details.
3212 +*/
3213 +
3214 +#ifndef IPKG_CONF_H
3215 +#define IPKG_CONF_H
3216 +
3217 +typedef struct ipkg_conf ipkg_conf_t;
3218 +
3219 +#include "hash_table.h"
3220 +#include "ipkg.h"
3221 +#include "args.h"
3222 +#include "pkg.h"
3223 +#include "pkg_hash.h"
3224 +#include "pkg_src_list.h"
3225 +#include "pkg_dest_list.h"
3226 +#include "nv_pair_list.h"
3227 +
3228 +#define IPKG_CONF_DEFAULT_TMP_DIR_BASE "/tmp"
3229 +#define IPKG_CONF_TMP_DIR_SUFFIX "ipkg-XXXXXX"
3230 +#define IPKG_CONF_LISTS_DIR  IPKG_STATE_DIR_PREFIX "/lists"
3231 +#define IPKG_CONF_PENDING_DIR IPKG_STATE_DIR_PREFIX "/pending"
3232 +
3233 +/* In case the config file defines no dest */
3234 +#define IPKG_CONF_DEFAULT_DEST_NAME "root"
3235 +#define IPKG_CONF_DEFAULT_DEST_ROOT_DIR "/"
3236 +
3237 +#define IPKG_CONF_DEFAULT_HASH_LEN 1024
3238 +
3239 +struct ipkg_conf
3240 +{
3241 +     pkg_src_list_t pkg_src_list;
3242 +     pkg_dest_list_t pkg_dest_list;
3243 +     nv_pair_list_t arch_list;
3244 +
3245 +     int restrict_to_default_dest;
3246 +     pkg_dest_t *default_dest;
3247 +
3248 +     char *tmp_dir;
3249 +     const char *lists_dir;
3250 +     const char *pending_dir;
3251 +
3252 +     /* options */
3253 +     int force_depends;
3254 +     int force_defaults;
3255 +     int force_overwrite;
3256 +     int force_downgrade;
3257 +     int force_reinstall;
3258 +     int force_space;
3259 +     int force_removal_of_dependent_packages;
3260 +     int force_removal_of_essential_packages;
3261 +     int nodeps; /* do not follow dependences */
3262 +     int verbose_wget;
3263 +     int multiple_providers;
3264 +     char *offline_root;
3265 +     char *offline_root_pre_script_cmd;
3266 +     char *offline_root_post_script_cmd;
3267 +     int query_all;
3268 +     int verbosity;
3269 +     int noaction;
3270 +
3271 +     /* proxy options */
3272 +     char *http_proxy;
3273 +     char *ftp_proxy;
3274 +     char *no_proxy;
3275 +     char *proxy_user;
3276 +     char *proxy_passwd;
3277 +
3278 +     hash_table_t pkg_hash;
3279 +     hash_table_t file_hash;
3280 +     hash_table_t obs_file_hash;
3281 +};
3282 +
3283 +enum ipkg_option_type {
3284 +     IPKG_OPT_TYPE_BOOL,
3285 +     IPKG_OPT_TYPE_INT,
3286 +     IPKG_OPT_TYPE_STRING
3287 +};
3288 +typedef enum ipkg_option_type ipkg_option_type_t;
3289 +
3290 +typedef struct ipkg_option ipkg_option_t;
3291 +struct ipkg_option {
3292 +     const char *name;
3293 +     const ipkg_option_type_t type;
3294 +     const void *value;
3295 +};
3296 +
3297 +int ipkg_conf_init(ipkg_conf_t *conf, const args_t *args);
3298 +void ipkg_conf_deinit(ipkg_conf_t *conf);
3299 +
3300 +int ipkg_conf_write_status_files(ipkg_conf_t *conf);
3301 +char *root_filename_alloc(ipkg_conf_t *conf, char *filename);
3302 +
3303 +#endif
3304 Index: busybox-1.7.2/archival/libipkg/ipkg_configure.c
3305 ===================================================================
3306 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3307 +++ busybox-1.7.2/archival/libipkg/ipkg_configure.c     2007-10-04 17:14:22.569027557 +0200
3308 @@ -0,0 +1,40 @@
3309 +/* ipkg_configure.c - the itsy package management system
3310 +
3311 +   Carl D. Worth
3312 +
3313 +   Copyright (C) 2001 University of Southern California
3314 +
3315 +   This program is free software; you can redistribute it and/or
3316 +   modify it under the terms of the GNU General Public License as
3317 +   published by the Free Software Foundation; either version 2, or (at
3318 +   your option) any later version.
3319 +
3320 +   This program is distributed in the hope that it will be useful, but
3321 +   WITHOUT ANY WARRANTY; without even the implied warranty of
3322 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3323 +   General Public License for more details.
3324 +*/
3325 +
3326 +#include "ipkg.h"
3327 +
3328 +#include "ipkg_configure.h"
3329 +
3330 +int ipkg_configure(ipkg_conf_t *conf, pkg_t *pkg)
3331 +{
3332 +    int err;
3333 +
3334 +    /* DPKG_INCOMPATIBILITY:
3335 +       dpkg actually does some conffile handling here, rather than at the
3336 +       end of ipkg_install(). Do we care? */
3337 +    /* DPKG_INCOMPATIBILITY:
3338 +       dpkg actually includes a version number to this script call */
3339 +    err = pkg_run_script(conf, pkg, "postinst", "configure");
3340 +    if (err) {
3341 +       printf("ERROR: %s.postinst returned %d\n", pkg->name, err);
3342 +       return err;
3343 +    }
3344 +
3345 +    ipkg_state_changed++;
3346 +    return 0;
3347 +}
3348 +
3349 Index: busybox-1.7.2/archival/libipkg/ipkg_configure.h
3350 ===================================================================
3351 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3352 +++ busybox-1.7.2/archival/libipkg/ipkg_configure.h     2007-10-04 17:14:22.593028927 +0200
3353 @@ -0,0 +1,25 @@
3354 +/* ipkg_configure.h - the itsy package management system
3355 +
3356 +   Carl D. Worth
3357 +
3358 +   Copyright (C) 2001 University of Southern California
3359 +
3360 +   This program is free software; you can redistribute it and/or
3361 +   modify it under the terms of the GNU General Public License as
3362 +   published by the Free Software Foundation; either version 2, or (at
3363 +   your option) any later version.
3364 +
3365 +   This program is distributed in the hope that it will be useful, but
3366 +   WITHOUT ANY WARRANTY; without even the implied warranty of
3367 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3368 +   General Public License for more details.
3369 +*/
3370 +
3371 +#ifndef IPKG_CONFIGURE_H
3372 +#define IPKG_CONFIGURE_H
3373 +
3374 +#include "ipkg_conf.h"
3375 +
3376 +int ipkg_configure(ipkg_conf_t *ipkg_conf, pkg_t *pkg);
3377 +
3378 +#endif
3379 Index: busybox-1.7.2/archival/libipkg/ipkg_download.c
3380 ===================================================================
3381 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3382 +++ busybox-1.7.2/archival/libipkg/ipkg_download.c      2007-10-04 17:14:22.617030294 +0200
3383 @@ -0,0 +1,195 @@
3384 +/* ipkg_download.c - the itsy package management system
3385 +
3386 +   Carl D. Worth
3387 +
3388 +   Copyright (C) 2001 University of Southern California
3389 +
3390 +   This program is free software; you can redistribute it and/or
3391 +   modify it under the terms of the GNU General Public License as
3392 +   published by the Free Software Foundation; either version 2, or (at
3393 +   your option) any later version.
3394 +
3395 +   This program is distributed in the hope that it will be useful, but
3396 +   WITHOUT ANY WARRANTY; without even the implied warranty of
3397 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3398 +   General Public License for more details.
3399 +*/
3400 +
3401 +#include "ipkg.h"
3402 +#include "ipkg_download.h"
3403 +#include "ipkg_message.h"
3404 +
3405 +#include "sprintf_alloc.h"
3406 +#include "xsystem.h"
3407 +#include "file_util.h"
3408 +#include "str_util.h"
3409 +
3410 +int ipkg_download(ipkg_conf_t *conf, const char *src, const char *dest_file_name)
3411 +{
3412 +    int err = 0;
3413 +
3414 +    char *src_basec = strdup(src);
3415 +    char *src_base = basename(src_basec);
3416 +    char *tmp_file_location;
3417 +    char *cmd;
3418 +
3419 +    ipkg_message(conf,IPKG_NOTICE,"Downloading %s\n", src);
3420 +
3421 +    fflush(stdout);
3422 +
3423 +    if (str_starts_with(src, "file:")) {
3424 +       int ret;
3425 +       const char *file_src = src + 5;
3426 +       ipkg_message(conf,IPKG_INFO,"Copying %s to %s...", file_src, dest_file_name);
3427 +       ret = file_copy(src + 5, dest_file_name);
3428 +       ipkg_message(conf,IPKG_INFO,"Done.\n");
3429 +       return ret;
3430 +    }
3431 +
3432 +    sprintf_alloc(&tmp_file_location, "%s/%s", conf->tmp_dir, src_base);
3433 +    err = unlink(tmp_file_location);
3434 +    if (err && errno != ENOENT) {
3435 +       ipkg_message(conf,IPKG_ERROR, "%s: ERROR: failed to unlink %s: %s\n",
3436 +               __FUNCTION__, tmp_file_location, strerror(errno));
3437 +       free(tmp_file_location);
3438 +       return errno;
3439 +    }
3440 +
3441 +    if (conf->http_proxy) {
3442 +       ipkg_message(conf,IPKG_DEBUG,"Setting environment variable: http_proxy = %s\n", conf->http_proxy);
3443 +       setenv("http_proxy", conf->http_proxy, 1);
3444 +    }
3445 +    if (conf->ftp_proxy) {
3446 +       ipkg_message(conf,IPKG_DEBUG,"Setting environment variable: ftp_proxy = %s\n", conf->ftp_proxy);
3447 +       setenv("ftp_proxy", conf->ftp_proxy, 1);
3448 +    }
3449 +    if (conf->no_proxy) {
3450 +       ipkg_message(conf,IPKG_DEBUG,"Setting environment variable: no_proxy = %s\n", conf->no_proxy);
3451 +       setenv("no_proxy", conf->no_proxy, 1);
3452 +    }
3453 +
3454 +    /* XXX: BUG rewrite to use execvp or else busybox's internal wget -Jamey 7/23/2002 */
3455 +    sprintf_alloc(&cmd, "wget --passive-ftp %s %s%s %s%s %s -P %s %s",
3456 +                 (conf->http_proxy || conf->ftp_proxy) ? "--proxy=on" : "",
3457 +                 conf->proxy_user ? "--proxy-user=" : "",
3458 +                 conf->proxy_user ? conf->proxy_user : "",
3459 +                 conf->proxy_passwd ? "--proxy-passwd=" : "",
3460 +                 conf->proxy_passwd ? conf->proxy_passwd : "",
3461 +                 conf->verbose_wget ? "" : "-q",
3462 +                 conf->tmp_dir,
3463 +                 src);
3464 +    err = xsystem(cmd);
3465 +    if (err) {
3466 +       if (err != -1) {
3467 +           ipkg_message(conf,IPKG_ERROR, "%s: ERROR: Command failed with return value %d: `%s'\n",
3468 +                   __FUNCTION__, err, cmd);
3469 +       }
3470 +       unlink(tmp_file_location);
3471 +       free(tmp_file_location);
3472 +       free(src_basec);
3473 +       free(cmd);
3474 +       return EINVAL;
3475 +    }
3476 +    free(cmd);
3477 +
3478 +    err = file_move(tmp_file_location, dest_file_name);
3479 +
3480 +    free(tmp_file_location);
3481 +    free(src_basec);
3482 +
3483 +    if (err) {
3484 +       return err;
3485 +    }
3486 +
3487 +    return 0;
3488 +}
3489 +
3490 +int ipkg_download_pkg(ipkg_conf_t *conf, pkg_t *pkg, const char *dir)
3491 +{
3492 +    int err;
3493 +    char *url;
3494 +
3495 +    if (pkg->src == NULL) {
3496 +       ipkg_message(conf,IPKG_ERROR, "ERROR: Package %s (parent %s) is not available from any configured src.\n",
3497 +               pkg->name, pkg->parent->name);
3498 +       return -1;
3499 +    }
3500 +
3501 +    sprintf_alloc(&url, "%s/%s", pkg->src->value, pkg->filename);
3502 +
3503 +    /* XXX: BUG: The pkg->filename might be something like
3504 +       "../../foo.ipk". While this is correct, and exactly what we
3505 +       want to use to construct url above, here we actually need to
3506 +       use just the filename part, without any directory. */
3507 +    sprintf_alloc(&pkg->local_filename, "%s/%s", dir, pkg->filename);
3508 +
3509 +    err = ipkg_download(conf, url, pkg->local_filename);
3510 +    free(url);
3511 +
3512 +    return err;
3513 +}
3514 +
3515 +/*
3516 + * Downloads file from url, installs in package database, return package name.
3517 + */
3518 +int ipkg_prepare_url_for_install(ipkg_conf_t *conf, const char *url, char **namep)
3519 +{
3520 +     int err = 0;
3521 +     pkg_t *pkg;
3522 +     pkg = pkg_new();
3523 +     if (pkg == NULL)
3524 +         return ENOMEM;
3525 +
3526 +     if (str_starts_with(url, "http://")
3527 +        || str_starts_with(url, "ftp://")) {
3528 +         char *tmp_file;
3529 +         char *file_basec = strdup(url);
3530 +         char *file_base = basename(file_basec);
3531 +
3532 +         sprintf_alloc(&tmp_file, "%s/%s", conf->tmp_dir, file_base);
3533 +         err = ipkg_download(conf, url, tmp_file);
3534 +         if (err)
3535 +              return err;
3536 +
3537 +         err = pkg_init_from_file(pkg, tmp_file);
3538 +         if (err)
3539 +              return err;
3540 +         pkg->local_filename = strdup(tmp_file);
3541 +
3542 +         free(tmp_file);
3543 +         free(file_basec);
3544 +
3545 +     } else if (strcmp(&url[strlen(url) - 4], IPKG_PKG_EXTENSION) == 0
3546 +               || strcmp(&url[strlen(url) - 4], DPKG_PKG_EXTENSION) == 0) {
3547 +
3548 +         err = pkg_init_from_file(pkg, url);
3549 +         if (err)
3550 +              return err;
3551 +         pkg->local_filename = strdup(url);
3552 +         ipkg_message(conf, IPKG_DEBUG2, "Package %s provided by hand (%s).\n", pkg->name,pkg->local_filename);
3553 +          pkg->provided_by_hand = 1;
3554 +
3555 +     } else {
3556 +       pkg_deinit(pkg);
3557 +       free(pkg);
3558 +       return 0;
3559 +     }
3560 +
3561 +     if (!pkg->architecture) {
3562 +         ipkg_message(conf, IPKG_ERROR, "Package %s has no Architecture defined.\n", pkg->name);
3563 +         return -EINVAL;
3564 +     }
3565 +
3566 +     pkg->dest = conf->default_dest;
3567 +     pkg->state_want = SW_INSTALL;
3568 +     pkg->state_flag |= SF_PREFER;
3569 +     pkg = hash_insert_pkg(&conf->pkg_hash, pkg, 1,conf);
3570 +     if ( pkg == NULL ){
3571 +        fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
3572 +        return 0;
3573 +     }
3574 +     if (namep) {
3575 +         *namep = strdup(pkg->name);
3576 +     }
3577 +     return 0;
3578 +}
3579 Index: busybox-1.7.2/archival/libipkg/ipkg_download.h
3580 ===================================================================
3581 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3582 +++ busybox-1.7.2/archival/libipkg/ipkg_download.h      2007-10-04 17:14:22.645031887 +0200
3583 @@ -0,0 +1,30 @@
3584 +/* ipkg_download.h - the itsy package management system
3585 +
3586 +   Carl D. Worth
3587 +
3588 +   Copyright (C) 2001 University of Southern California
3589 +
3590 +   This program is free software; you can redistribute it and/or
3591 +   modify it under the terms of the GNU General Public License as
3592 +   published by the Free Software Foundation; either version 2, or (at
3593 +   your option) any later version.
3594 +
3595 +   This program is distributed in the hope that it will be useful, but
3596 +   WITHOUT ANY WARRANTY; without even the implied warranty of
3597 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3598 +   General Public License for more details.
3599 +*/
3600 +
3601 +#ifndef IPKG_DOWNLOAD_H
3602 +#define IPKG_DOWNLOAD_H
3603 +
3604 +#include "ipkg_conf.h"
3605 +
3606 +int ipkg_download(ipkg_conf_t *conf, const char *src, const char *dest_file_name);
3607 +int ipkg_download_pkg(ipkg_conf_t *conf, pkg_t *pkg, const char *dir);
3608 +/*
3609 + * Downloads file from url, installs in package database, return package name.
3610 + */
3611 +int ipkg_prepare_url_for_install(ipkg_conf_t *conf, const char *url, char **namep);
3612 +
3613 +#endif
3614 Index: busybox-1.7.2/archival/libipkg/ipkg.h
3615 ===================================================================
3616 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3617 +++ busybox-1.7.2/archival/libipkg/ipkg.h       2007-10-04 17:14:22.669033256 +0200
3618 @@ -0,0 +1,74 @@
3619 +/* ipkg.h - the itsy package management system
3620 +
3621 +   Carl D. Worth
3622 +
3623 +   Copyright (C) 2001 University of Southern California
3624 +
3625 +   This program is free software; you can redistribute it and/or
3626 +   modify it under the terms of the GNU General Public License as
3627 +   published by the Free Software Foundation; either version 2, or (at
3628 +   your option) any later version.
3629 +
3630 +   This program is distributed in the hope that it will be useful, but
3631 +   WITHOUT ANY WARRANTY; without even the implied warranty of
3632 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3633 +   General Public License for more details.
3634 +*/
3635 +
3636 +#ifndef IPKG_H
3637 +#define IPKG_H
3638 +
3639 +/*
3640 +#ifdef HAVE_CONFIG_H
3641 +#include "config.h"
3642 +#endif
3643 +*/
3644 +
3645 +#if 0
3646 +#define IPKG_DEBUG_NO_TMP_CLEANUP
3647 +#endif
3648 +
3649 +#include "ipkg_includes.h"
3650 +#include "ipkg_conf.h"
3651 +#include "ipkg_message.h"
3652 +
3653 +#define IPKG_PKG_EXTENSION ".ipk"
3654 +#define DPKG_PKG_EXTENSION ".deb"
3655 +
3656 +#define IPKG_LEGAL_PKG_NAME_CHARS "abcdefghijklmnopqrstuvwxyz0123456789.+-"
3657 +#define IPKG_PKG_VERSION_SEP_CHAR '_'
3658 +
3659 +#define IPKG_STATE_DIR_PREFIX IPKGLIBDIR"/ipkg"
3660 +#define IPKG_LISTS_DIR_SUFFIX "lists"
3661 +#define IPKG_INFO_DIR_SUFFIX "info"
3662 +#define IPKG_STATUS_FILE_SUFFIX "status"
3663 +
3664 +#define IPKG_BACKUP_SUFFIX "-ipkg.backup"
3665 +
3666 +#define IPKG_LIST_DESCRIPTION_LENGTH 128
3667 +
3668 +#define IPKG_VERSION "0.99.162"
3669 +
3670 +
3671 +enum ipkg_error {
3672 +    IPKG_SUCCESS = 0,
3673 +    IPKG_PKG_DEPS_UNSATISFIED,
3674 +    IPKG_PKG_IS_ESSENTIAL,
3675 +    IPKG_PKG_HAS_DEPENDENTS,
3676 +    IPKG_PKG_HAS_NO_CANDIDATE
3677 +};
3678 +typedef enum ipkg_error ipkg_error_t;
3679 +
3680 +extern int ipkg_state_changed;
3681 +
3682 +
3683 +struct errlist {
3684 +    char * errmsg;
3685 +    struct errlist * next;
3686 +} ;
3687 +
3688 +extern struct errlist* error_list;
3689 +
3690 +extern ipkg_conf_t *global_conf;
3691 +
3692 +#endif
3693 Index: busybox-1.7.2/archival/libipkg/ipkg_includes.h
3694 ===================================================================
3695 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3696 +++ busybox-1.7.2/archival/libipkg/ipkg_includes.h      2007-10-04 17:14:22.685034167 +0200
3697 @@ -0,0 +1,79 @@
3698 +#ifndef IPKG_INCLUDES_H
3699 +#define IPKG_INCLUDES_H
3700 +
3701 +/* Define to 1 if you have the <memory.h> header file. */
3702 +#define HAVE_MEMORY_H 1
3703 +
3704 +/* Define to 1 if you have the <regex.h> header file. */
3705 +#define HAVE_REGEX_H 1
3706 +
3707 +/* Define to 1 if you have the <stdlib.h> header file. */
3708 +#define HAVE_STDLIB_H 1
3709 +
3710 +/* Define to 1 if you have the <strings.h> header file. */
3711 +#define HAVE_STRINGS_H 1
3712 +
3713 +/* Define to 1 if you have the <string.h> header file. */
3714 +#define HAVE_STRING_H 1
3715 +
3716 +/* Define to 1 if you have the <sys/stat.h> header file. */
3717 +#define HAVE_SYS_STAT_H 1
3718 +
3719 +/* Define to 1 if you have <sys/wait.h> that is POSIX.1 compatible. */
3720 +#define HAVE_SYS_WAIT_H 1
3721 +
3722 +/* Define to 1 if you have the <unistd.h> header file. */
3723 +#define HAVE_UNISTD_H 1
3724 +
3725 +/* Define to 1 if you have the ANSI C header files. */
3726 +#define STDC_HEADERS 1
3727 +
3728 +
3729 +#include <stdio.h>
3730 +
3731 +#if STDC_HEADERS
3732 +# include <stdlib.h>
3733 +# include <stdarg.h>
3734 +# include <stddef.h>
3735 +# include <ctype.h>
3736 +# include <errno.h>
3737 +#else
3738 +# if HAVE_STDLIB_H
3739 +#  include <stdlib.h>
3740 +# endif
3741 +#endif
3742 +
3743 +#if HAVE_REGEX_H
3744 +# include <regex.h>
3745 +#endif
3746 +
3747 +#if HAVE_STRING_H
3748 +# if !STDC_HEADERS && HAVE_MEMORY_H
3749 +#  include <memory.h>
3750 +# endif
3751 +/* XXX: What's the right way to pick up GNU's strndup declaration? */
3752 +# if __GNUC__
3753 +#   define __USE_GNU 1
3754 +# endif
3755 +# include <string.h>
3756 +# undef __USE_GNU
3757 +#endif
3758 +
3759 +#if HAVE_STRINGS_H
3760 +# include <strings.h>
3761 +#endif
3762 +
3763 +#if HAVE_SYS_STAT_H
3764 +# include <sys/stat.h>
3765 +#endif
3766 +
3767 +#if HAVE_SYS_WAIT_H
3768 +# include <sys/wait.h>
3769 +#endif
3770 +
3771 +#if HAVE_UNISTD_H
3772 +# include <sys/types.h>
3773 +# include <unistd.h>
3774 +#endif
3775 +
3776 +#endif /* IPKG_INCLUDES_H */
3777 Index: busybox-1.7.2/archival/libipkg/ipkg_install.c
3778 ===================================================================
3779 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
3780 +++ busybox-1.7.2/archival/libipkg/ipkg_install.c       2007-10-04 17:14:22.725036446 +0200
3781 @@ -0,0 +1,1942 @@
3782 +/* ipkg_install.c - the itsy package management system
3783 +
3784 +   Carl D. Worth
3785 +
3786 +   Copyright (C) 2001 University of Southern California
3787 +
3788 +   This program is free software; you can redistribute it and/or
3789 +   modify it under the terms of the GNU General Public License as
3790 +   published by the Free Software Foundation; either version 2, or (at
3791 +   your option) any later version.
3792 +
3793 +   This program is distributed in the hope that it will be useful, but
3794 +   WITHOUT ANY WARRANTY; without even the implied warranty of
3795 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3796 +   General Public License for more details.
3797 +*/
3798 +
3799 +#include "ipkg.h"
3800 +#include <errno.h>
3801 +#include <dirent.h>
3802 +#include <glob.h>
3803 +#include <time.h>
3804 +#include <signal.h>
3805 +typedef void (*sighandler_t)(int);
3806 +
3807 +#include "pkg.h"
3808 +#include "pkg_hash.h"
3809 +#include "pkg_extract.h"
3810 +
3811 +#include "ipkg_install.h"
3812 +#include "ipkg_configure.h"
3813 +#include "ipkg_download.h"
3814 +#include "ipkg_remove.h"
3815 +
3816 +#include "ipkg_utils.h"
3817 +#include "ipkg_message.h"
3818 +
3819 +#include "sprintf_alloc.h"
3820 +#include "file_util.h"
3821 +#include "str_util.h"
3822 +#include "xsystem.h"
3823 +#include "user.h"
3824 +
3825 +int satisfy_dependencies_for(ipkg_conf_t *conf, pkg_t *pkg);
3826 +static int verify_pkg_installable(ipkg_conf_t *conf, pkg_t *pkg);
3827 +static int unpack_pkg_control_files(ipkg_conf_t *conf, pkg_t *pkg);
3828 +
3829 +static int prerm_upgrade_old_pkg(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3830 +static int prerm_upgrade_old_pkg_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3831 +static int prerm_deconfigure_conflictors(ipkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors);
3832 +static int prerm_deconfigure_conflictors_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors);
3833 +static int preinst_configure(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3834 +static int preinst_configure_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3835 +static int check_data_file_clashes(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3836 +static int check_data_file_clashes_change(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3837 +static int check_data_file_clashes_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3838 +static int backup_modified_conffiles(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3839 +static int backup_modified_conffiles_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3840 +static int postrm_upgrade_old_pkg(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3841 +static int postrm_upgrade_old_pkg_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3842 +
3843 +static int remove_obsolesced_files(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3844 +static int install_maintainer_scripts(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
3845 +static int remove_disappeared(ipkg_conf_t *conf, pkg_t *pkg);
3846 +static int install_data_files(ipkg_conf_t *conf, pkg_t *pkg);
3847 +static int resolve_conffiles(ipkg_conf_t *conf, pkg_t *pkg);
3848 +
3849 +static int cleanup_temporary_files(ipkg_conf_t *conf, pkg_t *pkg);
3850 +
3851 +static int user_prefers_old_conffile(const char *file, const char *backup);
3852 +
3853 +static char *backup_filename_alloc(const char *file_name);
3854 +static int backup_make_backup(ipkg_conf_t *conf, const char *file_name);
3855 +static int backup_exists_for(const char *file_name);
3856 +static int backup_remove(const char *file_name);
3857 +
3858 +
3859 +int ipkg_install_from_file(ipkg_conf_t *conf, const char *filename)
3860 +{
3861 +     int err, cmp;
3862 +     pkg_t *pkg, *old;
3863 +     char *old_version, *new_version;
3864 +
3865 +     pkg = pkg_new();
3866 +     if (pkg == NULL) {
3867 +         return ENOMEM;
3868 +     }
3869 +
3870 +     err = pkg_init_from_file(pkg, filename);
3871 +     if (err) {
3872 +         return err;
3873 +     }
3874 +
3875 +     if (!pkg->architecture) {
3876 +         ipkg_message(conf, IPKG_ERROR, "Package %s has no Architecture defined.\n", pkg->name);
3877 +         return -EINVAL;
3878 +     }
3879 +
3880 +     /* XXX: CLEANUP: hash_insert_pkg has a nasty side effect of possibly
3881 +       freeing the pkg that we pass in. It might be nice to clean this up
3882 +       if possible.  */
3883 +     pkg = hash_insert_pkg(&conf->pkg_hash, pkg, 1,conf);
3884 +     old = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name);
3885 +
3886 +     pkg->local_filename = strdup(filename);
3887 +
3888 +     if (old) {
3889 +         old_version = pkg_version_str_alloc(old);
3890 +         new_version = pkg_version_str_alloc(pkg);
3891 +
3892 +         cmp = pkg_compare_versions(old, pkg);
3893 +          if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
3894 +             cmp = -1 ;                                       /* then we force ipkg to downgrade */
3895 +                                                              /* We need to use a value < 0 because in the 0 case we are asking to */
3896 +                                                              /* reinstall, and some check could fail asking the "force-reinstall" option */
3897 +          }
3898 +         if (cmp > 0) {
3899 +                ipkg_message(conf, IPKG_NOTICE,
3900 +                             "Not downgrading package %s on %s from %s to %s.\n",
3901 +                             old->name, old->dest->name, old_version, new_version);
3902 +                pkg->state_want = SW_DEINSTALL;
3903 +                pkg->state_flag |= SF_OBSOLETE;
3904 +                free(old_version);
3905 +                free(new_version);
3906 +                return 0;
3907 +         } else {
3908 +              free(old_version);
3909 +              free(new_version);
3910 +         }
3911 +     }
3912 +
3913 +     ipkg_message(conf, IPKG_DEBUG2,"Function: %s calling ipkg_install_pkg \n",__FUNCTION__);
3914 +     return ipkg_install_pkg(conf, pkg,0);
3915 +}
3916 +
3917 +ipkg_error_t ipkg_install_by_name(ipkg_conf_t *conf, const char *pkg_name)
3918 +{
3919 +     int cmp;
3920 +     pkg_t *old, *new;
3921 +     char *old_version, *new_version;
3922 +
3923 +     ipkg_message(conf, IPKG_DEBUG2, " Getting old  from pkg_hash_fetch \n" );
3924 +     old = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg_name);
3925 +     if ( old )
3926 +        ipkg_message(conf, IPKG_DEBUG2, " Old versions from pkg_hash_fetch %s \n",  old->version );
3927 +
3928 +     ipkg_message(conf, IPKG_DEBUG2, " Getting new  from pkg_hash_fetch \n" );
3929 +     new = pkg_hash_fetch_best_installation_candidate_by_name(conf, pkg_name);
3930 +     if ( new )
3931 +        ipkg_message(conf, IPKG_DEBUG2, " New versions from pkg_hash_fetch %s \n",  new->version );
3932 +
3933 +/* Pigi Basically here is broken the version stuff.
3934 +   What's happening is that nothing provide the version to differents
3935 +   functions, so the returned struct is always the latest.
3936 +   That's why the install by name don't work.
3937 +*/
3938 +     ipkg_message(conf, IPKG_DEBUG2, " Versions from pkg_hash_fetch in %s ", __FUNCTION__ );
3939 +
3940 +     if ( old )
3941 +        ipkg_message(conf, IPKG_DEBUG2, " old %s ", old->version );
3942 +     if ( new )
3943 +        ipkg_message(conf, IPKG_DEBUG2, " new %s ", new->version );
3944 +     ipkg_message(conf, IPKG_DEBUG2, " \n");
3945 +
3946 +     if (new == NULL) {
3947 +         return IPKG_PKG_HAS_NO_CANDIDATE;
3948 +     }
3949 +
3950 +     new->state_flag |= SF_USER;
3951 +     if (old) {
3952 +         old_version = pkg_version_str_alloc(old);
3953 +         new_version = pkg_version_str_alloc(new);
3954 +
3955 +         cmp = pkg_compare_versions(old, new);
3956 +          if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
3957 +            ipkg_message(conf, IPKG_DEBUG, " Forcing downgrade \n");
3958 +             cmp = -1 ;                                       /* then we force ipkg to downgrade */
3959 +                                                              /* We need to use a value < 0 because in the 0 case we are asking to */
3960 +                                                              /* reinstall, and some check could fail asking the "force-reinstall" option */
3961 +          }
3962 +         ipkg_message(conf, IPKG_DEBUG,
3963 +                      "Comparing visible versions of pkg %s:"
3964 +                      "\n\t%s is installed "
3965 +                      "\n\t%s is available "
3966 +                      "\n\t%d was comparison result\n",
3967 +                      pkg_name, old_version, new_version, cmp);
3968 +         if (cmp == 0 && !conf->force_reinstall) {
3969 +              ipkg_message(conf, IPKG_NOTICE,
3970 +                           "Package %s (%s) installed in %s is up to date.\n",
3971 +                           old->name, old_version, old->dest->name);
3972 +              free(old_version);
3973 +              free(new_version);
3974 +              return 0;
3975 +         } else if (cmp > 0) {
3976 +              ipkg_message(conf, IPKG_NOTICE,
3977 +                           "Not downgrading package %s on %s from %s to %s.\n",
3978 +                           old->name, old->dest->name, old_version, new_version);
3979 +              free(old_version);
3980 +              free(new_version);
3981 +              return 0;
3982 +         } else if (cmp < 0) {
3983 +              new->dest = old->dest;
3984 +              old->state_want = SW_DEINSTALL;    /* Here probably the problem for bug 1277 */
3985 +         }
3986 +     }
3987 +
3988 +     /* XXX: CLEANUP: The error code of ipkg_install_by_name is really
3989 +       supposed to be an ipkg_error_t, but ipkg_install_pkg could
3990 +       return any kind of integer, (might be errno from a syscall,
3991 +       etc.). This is a real mess and will need to be cleaned up if
3992 +       anyone ever wants to make a nice libipkg. */
3993 +
3994 +     ipkg_message(conf, IPKG_DEBUG2,"Function: %s calling ipkg_install_pkg \n",__FUNCTION__);
3995 +     return ipkg_install_pkg(conf, new,0);
3996 +}
3997 +
3998 +ipkg_error_t ipkg_install_multi_by_name(ipkg_conf_t *conf, const char *pkg_name)
3999 +{
4000 +     abstract_pkg_vec_t *providers = pkg_hash_fetch_all_installation_candidates (&conf->pkg_hash, pkg_name);
4001 +     int i;
4002 +     ipkg_error_t err;
4003 +     abstract_pkg_t *ppkg ;
4004 +
4005 +     if (providers == NULL)
4006 +         return IPKG_PKG_HAS_NO_CANDIDATE;
4007 +
4008 +     for (i = 0; i < providers->len; i++) {
4009 +         ppkg = abstract_pkg_vec_get(providers, i);
4010 +          ipkg_message(conf, IPKG_DEBUG2,"Function: %s calling ipkg_install_by_name %d \n",__FUNCTION__, i);
4011 +         err = ipkg_install_by_name(conf, ppkg->name);
4012 +         if (err)
4013 +              return err;
4014 +/* XXX Maybe ppkg should be freed ? */
4015 +     }
4016 +     return 0;
4017 +}
4018 +
4019 +/*
4020 + * Walk dependence graph starting with pkg, collect packages to be
4021 + * installed into pkgs_needed, in dependence order.
4022 + */
4023 +int pkg_mark_dependencies_for_installation(ipkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *pkgs_needed)
4024 +{
4025 +     int i, err;
4026 +     pkg_vec_t *depends = pkg_vec_alloc();
4027 +     char **unresolved = NULL;
4028 +     int ndepends;
4029 +
4030 +     ndepends = pkg_hash_fetch_unsatisfied_dependencies(conf,
4031 +                                                       pkg, depends,
4032 +                                                       &unresolved);
4033 +
4034 +     if (unresolved) {
4035 +         ipkg_message(conf, IPKG_ERROR,
4036 +                      "%s: Cannot satisfy the following dependencies for %s:\n\t",
4037 +                      conf->force_depends ? "Warning" : "ERROR", pkg->name);
4038 +         while (*unresolved) {
4039 +              ipkg_message(conf, IPKG_ERROR, " %s", *unresolved);
4040 +              unresolved++;
4041 +         }
4042 +         ipkg_message(conf, IPKG_ERROR, "\n");
4043 +         if (! conf->force_depends) {
4044 +              ipkg_message(conf, IPKG_INFO,
4045 +                           "This could mean that your package list is out of date or that the packages\n"
4046 +                           "mentioned above do not yet exist (try 'ipkg update'). To proceed in spite\n"
4047 +                           "of this problem try again with the '-force-depends' option.\n");
4048 +              pkg_vec_free(depends);
4049 +              return IPKG_PKG_DEPS_UNSATISFIED;
4050 +         }
4051 +     }
4052 +
4053 +     if (ndepends <= 0) {
4054 +         pkg_vec_free(depends);
4055 +         return 0;
4056 +     }
4057 +
4058 +     for (i = 0; i < depends->len; i++) {
4059 +         pkg_t *dep = depends->pkgs[i];
4060 +         /* The package was uninstalled when we started, but another
4061 +            dep earlier in this loop may have depended on it and pulled
4062 +            it in, so check first. */
4063 +         if ((dep->state_status != SS_INSTALLED)
4064 +             && (dep->state_status != SS_UNPACKED)
4065 +             && (dep->state_want != SW_INSTALL)) {
4066 +
4067 +              /* Mark packages as to-be-installed */
4068 +              dep->state_want = SW_INSTALL;
4069 +
4070 +              /* Dependencies should be installed the same place as pkg */
4071 +              if (dep->dest == NULL) {
4072 +                   dep->dest = pkg->dest;
4073 +              }
4074 +
4075 +              err = pkg_mark_dependencies_for_installation(conf, dep, pkgs_needed);
4076 +              if (err) {
4077 +                   pkg_vec_free(depends);
4078 +                   return err;
4079 +              }
4080 +         }
4081 +     }
4082 +     if (pkgs_needed)
4083 +         pkg_vec_insert(pkgs_needed, pkg);
4084 +
4085 +     pkg_vec_free(depends);
4086 +
4087 +     return 0;
4088 +}
4089 +
4090 +int name_mark_dependencies_for_installation(ipkg_conf_t *conf, const char *pkg_name, pkg_vec_t *pkgs_needed)
4091 +{
4092 +     int cmp;
4093 +     pkg_t *old, *new;
4094 +     char *old_version, *new_version;
4095 +
4096 +     old = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg_name);
4097 +
4098 +     new = pkg_hash_fetch_best_installation_candidate_by_name(conf, pkg_name);
4099 +     if (new == NULL) {
4100 +         return IPKG_PKG_HAS_NO_CANDIDATE;
4101 +     }
4102 +     if (old) {
4103 +         old_version = pkg_version_str_alloc(old);
4104 +         new_version = pkg_version_str_alloc(new);
4105 +
4106 +         cmp = pkg_compare_versions(old, new);
4107 +          if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
4108 +           ipkg_message(conf, IPKG_DEBUG, " Forcing downgrade ");
4109 +             cmp = -1 ;                                       /* then we force ipkg to downgrade */
4110 +                                                              /* We need to use a value < 0 because in the 0 case we are asking to */
4111 +                                                              /* reinstall, and some check could fail asking the "force-reinstall" option */
4112 +          }
4113 +         ipkg_message(conf, IPKG_DEBUG,
4114 +                      "comparing visible versions of pkg %s:"
4115 +                      "\n\t%s is installed "
4116 +                      "\n\t%s is available "
4117 +                      "\n\t%d was comparison result\n",
4118 +                      pkg_name, old_version, new_version, cmp);
4119 +         if (cmp == 0 && !conf->force_reinstall) {
4120 +              ipkg_message(conf, IPKG_NOTICE,
4121 +                           "Package %s (%s) installed in %s is up to date.\n",
4122 +                           old->name, old_version, old->dest->name);
4123 +              free(old_version);
4124 +              free(new_version);
4125 +              return 0;
4126 +         } else if (cmp > 0) {
4127 +              ipkg_message(conf, IPKG_NOTICE,
4128 +                           "Not downgrading package %s on %s from %s to %s.\n",
4129 +                           old->name, old->dest->name, old_version, new_version);
4130 +              free(old_version);
4131 +              free(new_version);
4132 +              return 0;
4133 +         } else if (cmp < 0) {
4134 +              new->dest = old->dest;
4135 +              old->state_want = SW_DEINSTALL;
4136 +              old->state_flag |= SF_OBSOLETE;
4137 +         }
4138 +     }
4139 +     return pkg_mark_dependencies_for_installation(conf, new, pkgs_needed);
4140 +}
4141 +
4142 +\f
4143 +
4144 +int satisfy_dependencies_for(ipkg_conf_t *conf, pkg_t *pkg)
4145 +{
4146 +     int i, err;
4147 +     pkg_vec_t *depends = pkg_vec_alloc();
4148 +     pkg_t *dep;
4149 +     char **unresolved = NULL;
4150 +     int ndepends;
4151 +
4152 +     ndepends = pkg_hash_fetch_unsatisfied_dependencies(conf,
4153 +                                                       pkg, depends,
4154 +                                                       &unresolved);
4155 +
4156 +     if (unresolved) {
4157 +         ipkg_message(conf, IPKG_ERROR,
4158 +                      "%s: Cannot satisfy the following dependencies for %s:\n\t",
4159 +                      conf->force_depends ? "Warning" : "ERROR", pkg->name);
4160 +         while (*unresolved) {
4161 +              ipkg_message(conf, IPKG_ERROR, " %s", *unresolved);
4162 +              unresolved++;
4163 +         }
4164 +         ipkg_message(conf, IPKG_ERROR, "\n");
4165 +         if (! conf->force_depends) {
4166 +              ipkg_message(conf, IPKG_INFO,
4167 +                           "This could mean that your package list is out of date or that the packages\n"
4168 +                           "mentioned above do not yet exist (try 'ipkg update'). To proceed in spite\n"
4169 +                           "of this problem try again with the '-force-depends' option.\n");
4170 +              pkg_vec_free(depends);
4171 +              return IPKG_PKG_DEPS_UNSATISFIED;
4172 +         }
4173 +     }
4174 +
4175 +     if (ndepends <= 0) {
4176 +         return 0;
4177 +     }
4178 +
4179 +     /* Mark packages as to-be-installed */
4180 +     for (i=0; i < depends->len; i++) {
4181 +         /* Dependencies should be installed the same place as pkg */
4182 +         if (depends->pkgs[i]->dest == NULL) {
4183 +              depends->pkgs[i]->dest = pkg->dest;
4184 +         }
4185 +         depends->pkgs[i]->state_want = SW_INSTALL;
4186 +     }
4187 +
4188 +     for (i = 0; i < depends->len; i++) {
4189 +         dep = depends->pkgs[i];
4190 +         /* The package was uninstalled when we started, but another
4191 +            dep earlier in this loop may have depended on it and pulled
4192 +            it in, so check first. */
4193 +         if ((dep->state_status != SS_INSTALLED)
4194 +             && (dep->state_status != SS_UNPACKED)) {
4195 +               ipkg_message(conf, IPKG_DEBUG2,"Function: %s calling ipkg_install_pkg \n",__FUNCTION__);
4196 +              err = ipkg_install_pkg(conf, dep,0);
4197 +              if (err) {
4198 +                   pkg_vec_free(depends);
4199 +                   return err;
4200 +              }
4201 +         }
4202 +     }
4203 +
4204 +     pkg_vec_free(depends);
4205 +
4206 +     return 0;
4207 +}
4208 +
4209 +
4210 +/* check all packages have their dependences satisfied, e.g., in case an upgraded package split */
4211 +int ipkg_satisfy_all_dependences(ipkg_conf_t *conf)
4212 +{
4213 +     if (conf->nodeps == 0) {
4214 +         int i;
4215 +         pkg_vec_t *installed = pkg_vec_alloc();
4216 +         pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
4217 +         for (i = 0; i < installed->len; i++) {
4218 +              pkg_t *pkg = installed->pkgs[i];
4219 +              satisfy_dependencies_for(conf, pkg);
4220 +         }
4221 +         pkg_vec_free(installed);
4222 +     }
4223 +     return 0;
4224 +}
4225 +
4226 +\f
4227 +
4228 +static int check_conflicts_for(ipkg_conf_t *conf, pkg_t *pkg)
4229 +{
4230 +     int i;
4231 +     pkg_vec_t *conflicts = NULL;
4232 +     int level;
4233 +     const char *prefix;
4234 +     if (conf->force_depends) {
4235 +         level = IPKG_NOTICE;
4236 +         prefix = "Warning";
4237 +     } else {
4238 +         level = IPKG_ERROR;
4239 +         prefix = "ERROR";
4240 +     }
4241 +
4242 +     if (!conf->force_depends)
4243 +         conflicts = (pkg_vec_t *)pkg_hash_fetch_conflicts(&conf->pkg_hash, pkg);
4244 +
4245 +     if (conflicts) {
4246 +         ipkg_message(conf, level,
4247 +                      "%s: The following packages conflict with %s:\n\t", prefix, pkg->name);
4248 +         i = 0;
4249 +         while (i < conflicts->len)
4250 +              ipkg_message(conf, level, " %s", conflicts->pkgs[i++]->name);
4251 +         ipkg_message(conf, level, "\n");
4252 +         pkg_vec_free(conflicts);
4253 +         return IPKG_PKG_DEPS_UNSATISFIED;
4254 +     }
4255 +     return 0;
4256 +}
4257 +
4258 +static int update_file_ownership(ipkg_conf_t *conf, pkg_t *new_pkg, pkg_t *old_pkg)
4259 +{
4260 +     str_list_t *new_list = pkg_get_installed_files(new_pkg);
4261 +     str_list_elt_t *iter;
4262 +
4263 +     for (iter = new_list->head; iter; iter = iter->next) {
4264 +         char *new_file = iter->data;
4265 +         pkg_t *owner = file_hash_get_file_owner(conf, new_file);
4266 +         if (!new_file)
4267 +              ipkg_message(conf, IPKG_ERROR, "Null new_file for new_pkg=%s\n", new_pkg->name);
4268 +         if (!owner || (owner == old_pkg))
4269 +              file_hash_set_file_owner(conf, new_file, new_pkg);
4270 +     }
4271 +     if (old_pkg) {
4272 +         str_list_t *old_list = pkg_get_installed_files(old_pkg);
4273 +         for (iter = old_list->head; iter; iter = iter->next) {
4274 +              char *old_file = iter->data;
4275 +              pkg_t *owner = file_hash_get_file_owner(conf, old_file);
4276 +              if (owner == old_pkg) {
4277 +                   /* obsolete */
4278 +                   hash_table_insert(&conf->obs_file_hash, old_file, old_pkg);
4279 +              }
4280 +         }
4281 +     }
4282 +     return 0;
4283 +}
4284 +
4285 +static int verify_pkg_installable(ipkg_conf_t *conf, pkg_t *pkg)
4286 +{
4287 +    /* XXX: FEATURE: Anything else needed here? Maybe a check on free space? */
4288 +
4289 +    /* sma 6.20.02:  yup; here's the first bit */
4290 +    /*
4291 +     * XXX: BUG easy for cworth
4292 +     * 1) please point the call below to the correct current root destination
4293 +     * 2) we need to resolve how to check the required space for a pending pkg,
4294 +     *    my diddling with the .ipk file size below isn't going to cut it.
4295 +     * 3) return a proper error code instead of 1
4296 +     */
4297 +     int comp_size, blocks_available;
4298 +
4299 +     if (!conf->force_space && pkg->installed_size != NULL) {
4300 +         blocks_available = get_available_blocks(conf->default_dest->root_dir);
4301 +
4302 +         comp_size = strtoul(pkg->installed_size, NULL, 0);
4303 +         /* round up a blocks count without doing fancy-but-slow casting jazz */
4304 +         comp_size = (int)((comp_size + 1023) / 1024);
4305 +
4306 +         if (comp_size >= blocks_available) {
4307 +              ipkg_message(conf, IPKG_ERROR,
4308 +                           "Only have %d available blocks on filesystem %s, pkg %s needs %d\n",
4309 +                           blocks_available, conf->default_dest->root_dir, pkg->name, comp_size);
4310 +              return ENOSPC;
4311 +         }
4312 +     }
4313 +     return 0;
4314 +}
4315 +
4316 +static int unpack_pkg_control_files(ipkg_conf_t *conf, pkg_t *pkg)
4317 +{
4318 +     int err;
4319 +     char *conffiles_file_name;
4320 +     char *root_dir;
4321 +     FILE *conffiles_file;
4322 +
4323 +     sprintf_alloc(&pkg->tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir, pkg->name);
4324 +
4325 +     pkg->tmp_unpack_dir = mkdtemp(pkg->tmp_unpack_dir);
4326 +     if (pkg->tmp_unpack_dir == NULL) {
4327 +         ipkg_message(conf, IPKG_ERROR,
4328 +                      "%s: Failed to create temporary directory '%s': %s\n",
4329 +                      __FUNCTION__, pkg->tmp_unpack_dir, strerror(errno));
4330 +         return errno;
4331 +     }
4332 +
4333 +     err = pkg_extract_control_files_to_dir(pkg, pkg->tmp_unpack_dir);
4334 +     if (err) {
4335 +         return err;
4336 +     }
4337 +
4338 +     /* XXX: CLEANUP: There might be a cleaner place to read in the
4339 +       conffiles. Seems like I should be able to get everything to go
4340 +       through pkg_init_from_file. If so, maybe it would make sense to
4341 +       move all of unpack_pkg_control_files to that function. */
4342 +
4343 +     /* Don't need to re-read conffiles if we already have it */
4344 +     if (pkg->conffiles.head) {
4345 +         return 0;
4346 +     }
4347 +
4348 +     sprintf_alloc(&conffiles_file_name, "%s/conffiles", pkg->tmp_unpack_dir);
4349 +     if (! file_exists(conffiles_file_name)) {
4350 +         free(conffiles_file_name);
4351 +         return 0;
4352 +     }
4353 +
4354 +     conffiles_file = fopen(conffiles_file_name, "r");
4355 +     if (conffiles_file == NULL) {
4356 +         fprintf(stderr, "%s: failed to open %s: %s\n",
4357 +                 __FUNCTION__, conffiles_file_name, strerror(errno));
4358 +         free(conffiles_file_name);
4359 +         return errno;
4360 +     }
4361 +     free(conffiles_file_name);
4362 +
4363 +     while (1) {
4364 +         char *cf_name;
4365 +         char *cf_name_in_dest;
4366 +
4367 +         cf_name = file_read_line_alloc(conffiles_file);
4368 +         if (cf_name == NULL) {
4369 +              break;
4370 +         }
4371 +         str_chomp(cf_name);
4372 +         if (cf_name[0] == '\0') {
4373 +              continue;
4374 +         }
4375 +
4376 +         /* Prepend dest->root_dir to conffile name.
4377 +            Take pains to avoid multiple slashes. */
4378 +         root_dir = pkg->dest->root_dir;
4379 +         if (conf->offline_root)
4380 +              /* skip the offline_root prefix */
4381 +              root_dir = pkg->dest->root_dir + strlen(conf->offline_root);
4382 +         sprintf_alloc(&cf_name_in_dest, "%s%s", root_dir,
4383 +                       cf_name[0] == '/' ? (cf_name + 1) : cf_name);
4384 +
4385 +         /* Can't get an md5sum now, (file isn't extracted yet).
4386 +            We'll wait until resolve_conffiles */
4387 +         conffile_list_append(&pkg->conffiles, cf_name_in_dest, NULL);
4388 +
4389 +         free(cf_name);
4390 +         free(cf_name_in_dest);
4391 +     }
4392 +
4393 +     fclose(conffiles_file);
4394 +
4395 +     return 0;
4396 +}
4397 +
4398 +/* returns number of installed replacees */
4399 +int pkg_get_installed_replacees(ipkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *installed_replacees)
4400 +{
4401 +     abstract_pkg_t **replaces = pkg->replaces;
4402 +     int replaces_count = pkg->replaces_count;
4403 +     int i, j;
4404 +     for (i = 0; i < replaces_count; i++) {
4405 +         abstract_pkg_t *ab_pkg = replaces[i];
4406 +         pkg_vec_t *pkg_vec = ab_pkg->pkgs;
4407 +         if (pkg_vec) {
4408 +              for (j = 0; j < pkg_vec->len; j++) {
4409 +                   pkg_t *replacee = pkg_vec->pkgs[j];
4410 +                   if (!pkg_conflicts(pkg, replacee))
4411 +                        continue;
4412 +                   if (replacee->state_status == SS_INSTALLED) {
4413 +                        pkg_vec_insert(installed_replacees, replacee);
4414 +                   }
4415 +              }
4416 +         }
4417 +     }
4418 +     return installed_replacees->len;
4419 +}
4420 +
4421 +int pkg_remove_installed_replacees(ipkg_conf_t *conf, pkg_vec_t *replacees)
4422 +{
4423 +     int i;
4424 +     int replaces_count = replacees->len;
4425 +     for (i = 0; i < replaces_count; i++) {
4426 +         pkg_t *replacee = replacees->pkgs[i];
4427 +         int err;
4428 +         replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
4429 +         err = ipkg_remove_pkg(conf, replacee,0);
4430 +         if (err)
4431 +              return err;
4432 +     }
4433 +     return 0;
4434 +}
4435 +
4436 +/* to unwind the removal: make sure they are installed */
4437 +int pkg_remove_installed_replacees_unwind(ipkg_conf_t *conf, pkg_vec_t *replacees)
4438 +{
4439 +     int i, err;
4440 +     int replaces_count = replacees->len;
4441 +     for (i = 0; i < replaces_count; i++) {
4442 +         pkg_t *replacee = replacees->pkgs[i];
4443 +         if (replacee->state_status != SS_INSTALLED) {
4444 +               ipkg_message(conf, IPKG_DEBUG2,"Function: %s calling ipkg_install_pkg \n",__FUNCTION__);
4445 +              err = ipkg_install_pkg(conf, replacee,0);
4446 +              if (err)
4447 +                   return err;
4448 +         }
4449 +     }
4450 +     return 0;
4451 +}
4452 +
4453 +int caught_sigint = 0;
4454 +static void ipkg_install_pkg_sigint_handler(int sig)
4455 +{
4456 +     caught_sigint = sig;
4457 +}
4458 +
4459 +/* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
4460 +static int ipkg_install_check_downgrade(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg, int message)
4461 +{
4462 +     if (old_pkg) {
4463 +          char message_out[15];
4464 +         char *old_version = pkg_version_str_alloc(old_pkg);
4465 +         char *new_version = pkg_version_str_alloc(pkg);
4466 +         int cmp = pkg_compare_versions(old_pkg, pkg);
4467 +         int rc = 0;
4468 +
4469 +          memset(message_out,'\x0',15);
4470 +          strncpy (message_out,"Upgrading ",strlen("Upgrading "));
4471 +          if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
4472 +             cmp = -1 ;                                       /* then we force ipkg to downgrade */
4473 +             strncpy (message_out,"Downgrading ",strlen("Downgrading "));         /* We need to use a value < 0 because in the 0 case we are asking to */
4474 +                                                              /* reinstall, and some check could fail asking the "force-reinstall" option */
4475 +          }
4476 +
4477 +         if (cmp > 0) {
4478 +              ipkg_message(conf, IPKG_NOTICE,
4479 +                           "Not downgrading package %s on %s from %s to %s.\n",
4480 +                           old_pkg->name, old_pkg->dest->name, old_version, new_version);
4481 +              rc = 1;
4482 +         } else if (cmp < 0) {
4483 +              ipkg_message(conf, IPKG_NOTICE,
4484 +                           "%s%s on %s from %s to %s...\n",
4485 +                           message_out, pkg->name, old_pkg->dest->name, old_version, new_version);
4486 +              pkg->dest = old_pkg->dest;
4487 +              rc = 0;
4488 +         } else /* cmp == 0 */ {
4489 +              if (conf->force_reinstall) {
4490 +                   ipkg_message(conf, IPKG_NOTICE,
4491 +                                "Reinstalling %s (%s) on %s...\n",
4492 +                                pkg->name, new_version, old_pkg->dest->name);
4493 +                   pkg->dest = old_pkg->dest;
4494 +                   rc = 0;
4495 +              } else {
4496 +                   ipkg_message(conf, IPKG_NOTICE,
4497 +                                "Not installing %s (%s) on %s -- already installed.\n",
4498 +                                pkg->name, new_version, old_pkg->dest->name);
4499 +                   rc = 1;
4500 +              }
4501 +         }
4502 +         free(old_version);
4503 +         free(new_version);
4504 +         return rc;
4505 +     } else {
4506 +      char message_out[15], *version ;
4507 +      memset(message_out,'\x0',15);
4508 +      if ( message )
4509 +          strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
4510 +      else
4511 +          strncpy( message_out,"Installing ",strlen("Installing ") );
4512 +         version = pkg_version_str_alloc(pkg);
4513 +
4514 +         ipkg_message(conf, IPKG_NOTICE,
4515 +                      "%s%s (%s) to %s...\n", message_out,
4516 +                      pkg->name, version, pkg->dest->name);
4517 +         free(version);
4518 +         return 0;
4519 +     }
4520 +}
4521 +
4522 +/* and now the meat... */
4523 +int ipkg_install_pkg(ipkg_conf_t *conf, pkg_t *pkg, int from_upgrade)
4524 +{
4525 +     int err = 0;
4526 +     int message = 0;
4527 +     pkg_t *old_pkg = NULL;
4528 +     pkg_vec_t *replacees;
4529 +     abstract_pkg_t *ab_pkg = NULL;
4530 +     int old_state_flag;
4531 +     char* file_md5;
4532 +
4533 +
4534 +     if ( from_upgrade )
4535 +        message = 1;            /* Coming from an upgrade, and should change the output message */
4536 +
4537 +     if (!pkg) {
4538 +         ipkg_message(conf, IPKG_ERROR,
4539 +                      "INTERNAL ERROR: null pkg passed to ipkg_install_pkg\n");
4540 +         return -EINVAL;
4541 +     }
4542 +
4543 +     ipkg_message(conf, IPKG_DEBUG2, "Function: %s calling pkg_arch_supported %s \n", __FUNCTION__, __FUNCTION__);
4544 +
4545 +     if (!pkg_arch_supported(conf, pkg)) {
4546 +         ipkg_message(conf, IPKG_ERROR, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
4547 +                      pkg->architecture, pkg->name);
4548 +         return -EINVAL;
4549 +     }
4550 +     if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
4551 +         err = satisfy_dependencies_for(conf, pkg);
4552 +         if (err) { return err; }
4553 +
4554 +         ipkg_message(conf, IPKG_NOTICE,
4555 +                      "Package %s is already installed in %s.\n",
4556 +                      pkg->name, pkg->dest->name);
4557 +         return 0;
4558 +     }
4559 +
4560 +     if (pkg->dest == NULL) {
4561 +         pkg->dest = conf->default_dest;
4562 +     }
4563 +
4564 +     old_pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name);
4565 +
4566 +     err = ipkg_install_check_downgrade(conf, pkg, old_pkg, message);
4567 +     if (err) { return err; }
4568 +
4569 +     pkg->state_want = SW_INSTALL;
4570 +     if (old_pkg){
4571 +         old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependences */
4572 +     }
4573 +
4574 +
4575 +     /* Abhaya: conflicts check */
4576 +     err = check_conflicts_for(conf, pkg);
4577 +     if (err) { return err; }
4578 +
4579 +     /* this setup is to remove the upgrade scenario in the end when
4580 +       installing pkg A, A deps B & B deps on A. So both B and A are
4581 +       installed. Then A's installation is started resulting in an
4582 +       uncecessary upgrade */
4583 +     if (pkg->state_status == SS_INSTALLED
4584 +        && conf->force_reinstall == 0) return 0;
4585 +
4586 +     err = verify_pkg_installable(conf, pkg);
4587 +     if (err) { return err; }
4588 +
4589 +     if (pkg->local_filename == NULL) {
4590 +         err = ipkg_download_pkg(conf, pkg, conf->tmp_dir);
4591 +         if (err) {
4592 +              ipkg_message(conf, IPKG_ERROR,
4593 +                           "Failed to download %s. Perhaps you need to run 'ipkg update'?\n",
4594 +                           pkg->name);
4595 +              return err;
4596 +         }
4597 +     }
4598 +
4599 +/* Check for md5 values */
4600 +     if (pkg->md5sum)
4601 +     {
4602 +         file_md5 = file_md5sum_alloc(pkg->local_filename);
4603 +         if (strcmp(file_md5, pkg->md5sum))
4604 +         {
4605 +              ipkg_message(conf, IPKG_ERROR,
4606 +                           "Package %s md5sum mismatch. Either the ipkg or the package index are corrupt. Try 'ipkg update'.\n",
4607 +                           pkg->name);
4608 +              free(file_md5);
4609 +              return err;
4610 +         }
4611 +         free(file_md5);
4612 +     }
4613 +
4614 +     if (pkg->tmp_unpack_dir == NULL) {
4615 +         unpack_pkg_control_files(conf, pkg);
4616 +     }
4617 +
4618 +     /* We should update the filelist here, so that upgrades of packages that split will not fail. -Jamey 27-MAR-03 */
4619 +/* Pigi: check if it will pass from here when replacing. It seems to fail */
4620 +/* That's rather strange that files don't change owner. Investigate !!!!!!*/
4621 +     err = update_file_ownership(conf, pkg, old_pkg);
4622 +     if (err) { return err; }
4623 +
4624 +     if (conf->nodeps == 0) {
4625 +         err = satisfy_dependencies_for(conf, pkg);
4626 +         if (err) { return err; }
4627 +     }
4628 +
4629 +     replacees = pkg_vec_alloc();
4630 +     pkg_get_installed_replacees(conf, pkg, replacees);
4631 +
4632 +     /* this next section we do with SIGINT blocked to prevent inconsistency between ipkg database and filesystem */
4633 +     {
4634 +         sigset_t newset, oldset;
4635 +         sighandler_t old_handler = NULL;
4636 +         int use_signal = 0;
4637 +         caught_sigint = 0;
4638 +         if (use_signal) {
4639 +              old_handler = signal(SIGINT, ipkg_install_pkg_sigint_handler);
4640 +         } else {
4641 +              sigemptyset(&newset);
4642 +              sigaddset(&newset, SIGINT);
4643 +              sigprocmask(SIG_BLOCK, &newset, &oldset);
4644 +         }
4645 +
4646 +         ipkg_state_changed++;
4647 +         pkg->state_flag |= SF_FILELIST_CHANGED;
4648 +
4649 +         /* XXX: BUG: we really should treat replacement more like an upgrade
4650 +          *      Instead, we're going to remove the replacees
4651 +          */
4652 +         err = pkg_remove_installed_replacees(conf, replacees);
4653 +         if (err) goto UNWIND_REMOVE_INSTALLED_REPLACEES;
4654 +
4655 +         err = prerm_upgrade_old_pkg(conf, pkg, old_pkg);
4656 +         if (err) goto UNWIND_PRERM_UPGRADE_OLD_PKG;
4657 +
4658 +         err = prerm_deconfigure_conflictors(conf, pkg, replacees);
4659 +         if (err) goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
4660 +
4661 +         err = preinst_configure(conf, pkg, old_pkg);
4662 +         if (err) goto UNWIND_PREINST_CONFIGURE;
4663 +
4664 +         err = backup_modified_conffiles(conf, pkg, old_pkg);
4665 +         if (err) goto UNWIND_BACKUP_MODIFIED_CONFFILES;
4666 +
4667 +         err = check_data_file_clashes(conf, pkg, old_pkg);
4668 +         if (err) goto UNWIND_CHECK_DATA_FILE_CLASHES;
4669 +
4670 +         err = postrm_upgrade_old_pkg(conf, pkg, old_pkg);
4671 +         if (err) goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
4672 +
4673 +         if (conf->noaction) return 0;
4674 +
4675 +         /* point of no return: no unwinding after this */
4676 +         if (old_pkg && !conf->force_reinstall) {
4677 +              old_pkg->state_want = SW_DEINSTALL;
4678 +
4679 +              if (old_pkg->state_flag & SF_NOPRUNE) {
4680 +                   ipkg_message(conf, IPKG_INFO,
4681 +                                "  not removing obsolesced files because package marked noprune\n");
4682 +              } else {
4683 +                   ipkg_message(conf, IPKG_INFO,
4684 +                                "  removing obsolesced files\n");
4685 +                   remove_obsolesced_files(conf, pkg, old_pkg);
4686 +              }
4687 +               /* removing files from old package, to avoid ghost files */
4688 +               remove_data_files_and_list(conf, old_pkg);
4689 +/* Pigi : It should be better to remove also maintainer and postrem scripts here, just in case*/
4690 +               remove_maintainer_scripts_except_postrm(conf, old_pkg);
4691 +               remove_postrm(conf, old_pkg);
4692 +/* Pigi */
4693 +
4694 +         }
4695 +
4696 +
4697 +         ipkg_message(conf, IPKG_INFO,
4698 +                      "  installing maintainer scripts\n");
4699 +         install_maintainer_scripts(conf, pkg, old_pkg);
4700 +
4701 +         /* the following just returns 0 */
4702 +         remove_disappeared(conf, pkg);
4703 +
4704 +         ipkg_message(conf, IPKG_INFO,
4705 +                      "  installing data files\n");
4706 +         install_data_files(conf, pkg);
4707 +
4708 +/* read comments from function for detail but I will execute this here as all other tests are ok.*/
4709 +         err = check_data_file_clashes_change(conf, pkg, old_pkg);
4710 +
4711 +         ipkg_message(conf, IPKG_INFO,
4712 +                      "  resolving conf files\n");
4713 +         resolve_conffiles(conf, pkg);
4714 +
4715 +         pkg->state_status = SS_UNPACKED;
4716 +         old_state_flag = pkg->state_flag;
4717 +         pkg->state_flag &= ~SF_PREFER;
4718 +         ipkg_message(conf, IPKG_DEBUG, "   pkg=%s old_state_flag=%x state_flag=%x\n", pkg->name, old_state_flag, pkg->state_flag);
4719 +
4720 +         if (old_pkg && !conf->force_reinstall) {
4721 +              old_pkg->state_status = SS_NOT_INSTALLED;
4722 +         }
4723 +
4724 +         time(&pkg->installed_time);
4725 +
4726 +         ipkg_message(conf, IPKG_INFO,
4727 +                      "  cleanup temp files\n");
4728 +         cleanup_temporary_files(conf, pkg);
4729 +
4730 +         ab_pkg = pkg->parent;
4731 +         if (ab_pkg)
4732 +              ab_pkg->state_status = pkg->state_status;
4733 +
4734 +         ipkg_message(conf, IPKG_INFO, "Done.\n");
4735 +
4736 +         if (use_signal)
4737 +              signal(SIGINT, old_handler);
4738 +         else
4739 +              sigprocmask(SIG_UNBLOCK, &newset, &oldset);
4740 +
4741 +         return 0;
4742 +
4743 +
4744 +     UNWIND_POSTRM_UPGRADE_OLD_PKG:
4745 +         postrm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
4746 +     UNWIND_CHECK_DATA_FILE_CLASHES:
4747 +         check_data_file_clashes_unwind(conf, pkg, old_pkg);
4748 +     UNWIND_BACKUP_MODIFIED_CONFFILES:
4749 +         backup_modified_conffiles_unwind(conf, pkg, old_pkg);
4750 +     UNWIND_PREINST_CONFIGURE:
4751 +         preinst_configure_unwind(conf, pkg, old_pkg);
4752 +     UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
4753 +         prerm_deconfigure_conflictors_unwind(conf, pkg, replacees);
4754 +     UNWIND_PRERM_UPGRADE_OLD_PKG:
4755 +         prerm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
4756 +     UNWIND_REMOVE_INSTALLED_REPLACEES:
4757 +         pkg_remove_installed_replacees_unwind(conf, replacees);
4758 +
4759 +         ipkg_message(conf, IPKG_INFO,
4760 +                      "  cleanup temp files\n");
4761 +         cleanup_temporary_files(conf, pkg);
4762 +
4763 +         ipkg_message(conf, IPKG_INFO,
4764 +                      "Failed.\n");
4765 +         if (use_signal)
4766 +              signal(SIGINT, old_handler);
4767 +         else
4768 +              sigprocmask(SIG_UNBLOCK, &newset, &oldset);
4769 +
4770 +         return err;
4771 +     }
4772 +}
4773 +
4774 +static int prerm_upgrade_old_pkg(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
4775 +{
4776 +     /* DPKG_INCOMPATIBILITY:
4777 +       dpkg does some things here that we don't do yet. Do we care?
4778 +
4779 +       1. If a version of the package is already installed, call
4780 +          old-prerm upgrade new-version
4781 +       2. If the script runs but exits with a non-zero exit status
4782 +          new-prerm failed-upgrade old-version
4783 +          Error unwind, for both the above cases:
4784 +          old-postinst abort-upgrade new-version
4785 +     */
4786 +     return 0;
4787 +}
4788 +
4789 +static int prerm_upgrade_old_pkg_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
4790 +{
4791 +     /* DPKG_INCOMPATIBILITY:
4792 +       dpkg does some things here that we don't do yet. Do we care?
4793 +       (See prerm_upgrade_old_package for details)
4794 +     */
4795 +     return 0;
4796 +}
4797 +
4798 +static int prerm_deconfigure_conflictors(ipkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors)
4799 +{
4800 +     /* DPKG_INCOMPATIBILITY:
4801 +       dpkg does some things here that we don't do yet. Do we care?
4802 +       2. If a 'conflicting' package is being removed at the same time:
4803 +               1. If any packages depended on that conflicting package and
4804 +                  --auto-deconfigure is specified, call, for each such package:
4805 +                  deconfigured's-prerm deconfigure \
4806 +                  in-favour package-being-installed version \
4807 +                  removing conflicting-package version
4808 +               Error unwind:
4809 +                  deconfigured's-postinst abort-deconfigure \
4810 +                  in-favour package-being-installed-but-failed version \
4811 +                  removing conflicting-package version
4812 +
4813 +                  The deconfigured packages are marked as requiring
4814 +                  configuration, so that if --install is used they will be
4815 +                  configured again if possible.
4816 +               2. To prepare for removal of the conflicting package, call:
4817 +                  conflictor's-prerm remove in-favour package new-version
4818 +               Error unwind:
4819 +                  conflictor's-postinst abort-remove in-favour package new-version
4820 +     */
4821 +     return 0;
4822 +}
4823 +
4824 +static int prerm_deconfigure_conflictors_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors)
4825 +{
4826 +     /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
4827 +       do yet. Do we care?  (See prerm_deconfigure_conflictors for
4828 +       details) */
4829 +     return 0;
4830 +}
4831 +
4832 +static int preinst_configure(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
4833 +{
4834 +     int err;
4835 +     char *preinst_args;
4836 +
4837 +     if (old_pkg) {
4838 +         char *old_version = pkg_version_str_alloc(old_pkg);
4839 +         sprintf_alloc(&preinst_args, "upgrade %s", old_version);
4840 +         free(old_version);
4841 +     } else if (pkg->state_status == SS_CONFIG_FILES) {
4842 +         char *pkg_version = pkg_version_str_alloc(pkg);
4843 +         sprintf_alloc(&preinst_args, "install %s", pkg_version);
4844 +         free(pkg_version);
4845 +     } else {
4846 +         preinst_args = strdup("install");
4847 +     }
4848 +
4849 +     err = pkg_run_script(conf, pkg, "preinst", preinst_args);
4850 +     if (err) {
4851 +         ipkg_message(conf, IPKG_ERROR,
4852 +                      "Aborting installation of %s\n", pkg->name);
4853 +         return 1;
4854 +     }
4855 +
4856 +     free(preinst_args);
4857 +
4858 +     return 0;
4859 +}
4860 +
4861 +static int preinst_configure_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
4862 +{
4863 +     /* DPKG_INCOMPATIBILITY:
4864 +       dpkg does the following error unwind, should we?
4865 +       pkg->postrm abort-upgrade old-version
4866 +       OR pkg->postrm abort-install old-version
4867 +       OR pkg->postrm abort-install
4868 +     */
4869 +     return 0;
4870 +}
4871 +
4872 +static int backup_modified_conffiles(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
4873 +{
4874 +     int err;
4875 +     conffile_list_elt_t *iter;
4876 +     conffile_t *cf;
4877 +
4878 +     if (conf->noaction) return 0;
4879 +
4880 +     /* Backup all modified conffiles */
4881 +     if (old_pkg) {
4882 +         for (iter = old_pkg->conffiles.head; iter; iter = iter->next) {
4883 +              char *cf_name;
4884 +
4885 +              cf = iter->data;
4886 +              cf_name = root_filename_alloc(conf, cf->name);
4887 +
4888 +              /* Don't worry if the conffile is just plain gone */
4889 +              if (file_exists(cf_name) && conffile_has_been_modified(conf, cf)) {
4890 +                   err = backup_make_backup(conf, cf_name);
4891 +                   if (err) {
4892 +                        return err;
4893 +                   }
4894 +              }
4895 +              free(cf_name);
4896 +         }
4897 +     }
4898 +
4899 +     /* Backup all conffiles that were not conffiles in old_pkg */
4900 +     for (iter = pkg->conffiles.head; iter; iter = iter->next) {
4901 +         char *cf_name;
4902 +         cf = iter->data;
4903 +         cf_name = root_filename_alloc(conf, cf->name);
4904 +         /* Ignore if this was a conffile in old_pkg as well */
4905 +         if (pkg_get_conffile(old_pkg, cf->name)) {
4906 +              continue;
4907 +         }
4908 +
4909 +         if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
4910 +              err = backup_make_backup(conf, cf_name);
4911 +              if (err) {
4912 +                   return err;
4913 +              }
4914 +         }
4915 +         free(cf_name);
4916 +     }
4917 +
4918 +     return 0;
4919 +}
4920 +
4921 +static int backup_modified_conffiles_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
4922 +{
4923 +     conffile_list_elt_t *iter;
4924 +
4925 +     if (old_pkg) {
4926 +         for (iter = old_pkg->conffiles.head; iter; iter = iter->next) {
4927 +              backup_remove(iter->data->name);
4928 +         }
4929 +     }
4930 +
4931 +     for (iter = pkg->conffiles.head; iter; iter = iter->next) {
4932 +         backup_remove(iter->data->name);
4933 +     }
4934 +
4935 +     return 0;
4936 +}
4937 +
4938 +
4939 +static int check_data_file_clashes(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
4940 +{
4941 +     /* DPKG_INCOMPATIBILITY:
4942 +       ipkg takes a slightly different approach than dpkg at this
4943 +       point.  dpkg installs each file in the new package while
4944 +       creating a backup for any file that is replaced, (so that it
4945 +       can unwind if necessary).  To avoid complexity and redundant
4946 +       storage, ipkg doesn't do any installation until later, (at the
4947 +       point at which dpkg removes the backups.
4948 +
4949 +       But, we do have to check for data file clashes, since after
4950 +       installing a package with a file clash, removing either of the
4951 +       packages involved in the clash has the potential to break the
4952 +       other package.
4953 +     */
4954 +     str_list_t *files_list;
4955 +     str_list_elt_t *iter;
4956 +
4957 +     int clashes = 0;
4958 +
4959 +     files_list = pkg_get_installed_files(pkg);
4960 +     for (iter = files_list->head; iter; iter = iter->next) {
4961 +         char *root_filename;
4962 +         char *filename = iter->data;
4963 +         root_filename = root_filename_alloc(conf, filename);
4964 +         if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
4965 +              pkg_t *owner;
4966 +              pkg_t *obs;
4967 +              /* Pre-existing conffiles are OK */
4968 +              /* @@@@ should have way to check that it is a conffile -Jamey */
4969 +              if (backup_exists_for(root_filename)) {
4970 +                   continue;
4971 +              }
4972 +
4973 +              /* Pre-existing files are OK if force-overwrite was asserted. */
4974 +              if (conf->force_overwrite) {
4975 +                   /* but we need to change who owns this file */
4976 +                   file_hash_set_file_owner(conf, filename, pkg);
4977 +                   continue;
4978 +              }
4979 +
4980 +              owner = file_hash_get_file_owner(conf, filename);
4981 +
4982 +              /* Pre-existing files are OK if owned by the pkg being upgraded. */
4983 +              if (owner && old_pkg) {
4984 +                   if (strcmp(owner->name, old_pkg->name) == 0) {
4985 +                        continue;
4986 +                   }
4987 +              }
4988 +
4989 +              /* Pre-existing files are OK if owned by a package replaced by new pkg. */
4990 +              if (owner) {
4991 +                    ipkg_message(conf, IPKG_DEBUG2, "Checking for replaces for %s in package %s\n", filename, owner->name);
4992 +                   if (pkg_replaces(pkg, owner)) {
4993 +                        continue;
4994 +                   }
4995 +/* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
4996 +   then it's ok to overwrite. */
4997 +                    if (strcmp(owner->name,pkg->name)==0){
4998 +                        ipkg_message(conf, IPKG_INFO, "Replacing pre-existing file %s owned by package %s\n", filename, owner->name);
4999 +                        continue;
5000 +                    }
5001 +              }
5002 +
5003 +              /* Pre-existing files are OK if they are obsolete */
5004 +              obs = hash_table_get(&conf->obs_file_hash, filename);
5005 +              if (obs) {
5006 +                   ipkg_message(conf, IPKG_INFO, "Pre-exiting file %s is obsolete.  obs_pkg=%s\n", filename, obs->name);
5007 +                   continue;
5008 +              }
5009 +
5010 +              /* We have found a clash. */
5011 +              ipkg_message(conf, IPKG_ERROR,
5012 +                           "Package %s wants to install file %s\n"
5013 +                           "\tBut that file is already provided by package ",
5014 +                           pkg->name, filename);
5015 +              if (owner) {
5016 +                   ipkg_message(conf, IPKG_ERROR,
5017 +                                "%s\n", owner->name);
5018 +              } else {
5019 +                   ipkg_message(conf, IPKG_ERROR,
5020 +                                "<no package>\nPlease move this file out of the way and try again.\n");
5021 +              }
5022 +              clashes++;
5023 +         }
5024 +         free(root_filename);
5025 +     }
5026 +     pkg_free_installed_files(pkg);
5027 +
5028 +     return clashes;
5029 +}
5030 +
5031 +static int check_data_file_clashes_change(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
5032 +{
5033 +    /* Basically that's the worst hack I could do to be able to change ownership of
5034 +       file list, but, being that we have no way to unwind the mods, due to structure
5035 +       of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
5036 +       What we do here is change the ownership of file in hash if a replace ( or similar events
5037 +       happens )
5038 +       Only the action that are needed to change name should be considered.
5039 +       @@@ To change after 1.0 release.
5040 +     */
5041 +     str_list_t *files_list;
5042 +     str_list_elt_t *iter;
5043 +
5044 +     int clashes = 0;
5045 +
5046 +     files_list = pkg_get_installed_files(pkg);
5047 +     for (iter = files_list->head; iter; iter = iter->next) {
5048 +         char *root_filename;
5049 +         char *filename = iter->data;
5050 +         root_filename = root_filename_alloc(conf, filename);
5051 +         if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
5052 +              pkg_t *owner;
5053 +
5054 +              if (conf->force_overwrite) {
5055 +                   /* but we need to change who owns this file */
5056 +                   file_hash_set_file_owner(conf, filename, pkg);
5057 +                   continue;
5058 +              }
5059 +
5060 +              owner = file_hash_get_file_owner(conf, filename);
5061 +
5062 +              /* Pre-existing files are OK if owned by a package replaced by new pkg. */
5063 +              if (owner) {
5064 +                   if (pkg_replaces(pkg, owner)) {
5065 +/* It's now time to change the owner of that file.
5066 +   It has been "replaced" from the new "Replaces", then I need to inform lists file about that.  */
5067 +                        ipkg_message(conf, IPKG_INFO, "Replacing pre-existing file %s owned by package %s\n", filename, owner->name);
5068 +                        file_hash_set_file_owner(conf, filename, pkg);
5069 +                        continue;
5070 +                   }
5071 +              }
5072 +
5073 +         }
5074 +         free(root_filename);
5075 +     }
5076 +     pkg_free_installed_files(pkg);
5077 +
5078 +     return clashes;
5079 +}
5080 +
5081 +static int check_data_file_clashes_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
5082 +{
5083 +     /* Nothing to do since check_data_file_clashes doesn't change state */
5084 +     return 0;
5085 +}
5086 +
5087 +static int postrm_upgrade_old_pkg(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
5088 +{
5089 +     /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
5090 +       1. If the package is being upgraded, call
5091 +          old-postrm upgrade new-version
5092 +       2. If this fails, attempt:
5093 +          new-postrm failed-upgrade old-version
5094 +       Error unwind, for both cases:
5095 +          old-preinst abort-upgrade new-version    */
5096 +     return 0;
5097 +}
5098 +
5099 +static int postrm_upgrade_old_pkg_unwind(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
5100 +{
5101 +     /* DPKG_INCOMPATIBILITY:
5102 +       dpkg does some things here that we don't do yet. Do we care?
5103 +       (See postrm_upgrade_old_pkg for details)
5104 +     */
5105 +    return 0;
5106 +}
5107 +
5108 +static int remove_obsolesced_files(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
5109 +{
5110 +     int err;
5111 +     str_list_t *old_files;
5112 +     str_list_elt_t *of;
5113 +     str_list_t *new_files;
5114 +     str_list_elt_t *nf;
5115 +
5116 +     if (old_pkg == NULL) {
5117 +         return 0;
5118 +     }
5119 +
5120 +     old_files = pkg_get_installed_files(old_pkg);
5121 +     new_files = pkg_get_installed_files(pkg);
5122 +
5123 +     for (of = old_files->head; of; of = of->next) {
5124 +         pkg_t *owner;
5125 +         char *old, *new;
5126 +         old = of->data;
5127 +         for (nf = new_files->head; nf; nf = nf->next) {
5128 +              new = nf->data;
5129 +              if (strcmp(old, new) == 0) {
5130 +                   goto NOT_OBSOLETE;
5131 +              }
5132 +         }
5133 +         if (file_is_dir(old)) {
5134 +              continue;
5135 +         }
5136 +         owner = file_hash_get_file_owner(conf, old);
5137 +         if (owner != old_pkg) {
5138 +              /* in case obsolete file no longer belongs to old_pkg */
5139 +              continue;
5140 +         }
5141 +
5142 +         /* old file is obsolete */
5143 +         ipkg_message(conf, IPKG_INFO,
5144 +                      "    removing obsolete file %s\n", old);
5145 +         if (!conf->noaction) {
5146 +              err = unlink(old);
5147 +              if (err) {
5148 +                   ipkg_message(conf, IPKG_ERROR, "    Warning: remove %s failed: %s\n", old,
5149 +                                strerror(errno));
5150 +              }
5151 +         }
5152 +
5153 +     NOT_OBSOLETE:
5154 +         ;
5155 +     }
5156 +
5157 +     pkg_free_installed_files(old_pkg);
5158 +     pkg_free_installed_files(pkg);
5159 +
5160 +     return 0;
5161 +}
5162 +
5163 +static int remove_obsolete_maintainer_scripts(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
5164 +{
5165 +     int i;
5166 +     int err = 0;
5167 +     char *globpattern;
5168 +     glob_t globbuf;
5169 +     if (0) {
5170 +         if (!pkg->dest) {
5171 +              ipkg_message(conf, IPKG_ERROR, "%s: no dest for package %s\n", __FUNCTION__, pkg->name);
5172 +              return -1;
5173 +         }
5174 +         sprintf_alloc(&globpattern, "%s/%s.*", pkg->dest->info_dir, pkg->name);
5175 +         err = glob(globpattern, 0, NULL, &globbuf);
5176 +         free(globpattern);
5177 +         if (err) {
5178 +              return err;
5179 +         }
5180 +         /* XXXX this should perhaps only remove the ones that are not overwritten in new package.  Jamey 11/11/2003 */
5181 +         for (i = 0; i < globbuf.gl_pathc; i++) {
5182 +              ipkg_message(conf, IPKG_DEBUG, "Removing control file %s from old_pkg %s\n",
5183 +                           globbuf.gl_pathv[i], old_pkg->name);
5184 +              if (!conf->noaction)
5185 +                   unlink(globbuf.gl_pathv[i]);
5186 +         }
5187 +         globfree(&globbuf);
5188 +     }
5189 +     return err;
5190 +}
5191 +
5192 +static int install_maintainer_scripts(ipkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
5193 +{
5194 +     int ret;
5195 +     char *prefix;
5196 +
5197 +     if (old_pkg)
5198 +         remove_obsolete_maintainer_scripts(conf, pkg, old_pkg);
5199 +     sprintf_alloc(&prefix, "%s.", pkg->name);
5200 +     ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
5201 +                                                       pkg->dest->info_dir,
5202 +                                                       prefix);
5203 +     free(prefix);
5204 +     return ret;
5205 +}
5206 +
5207 +static int remove_disappeared(ipkg_conf_t *conf, pkg_t *pkg)
5208 +{
5209 +     /* DPKG_INCOMPATIBILITY:
5210 +       This is a fairly sophisticated dpkg operation. Shall we
5211 +       skip it? */
5212 +
5213 +     /* Any packages all of whose files have been overwritten during the
5214 +       installation, and which aren't required for dependencies, are
5215 +       considered to have been removed. For each such package
5216 +       1. disappearer's-postrm disappear overwriter overwriter-version
5217 +       2. The package's maintainer scripts are removed
5218 +       3. It is noted in the status database as being in a sane state,
5219 +           namely not installed (any conffiles it may have are ignored,
5220 +          rather than being removed by dpkg). Note that disappearing
5221 +          packages do not have their prerm called, because dpkg doesn't
5222 +          know in advance that the package is going to vanish.
5223 +     */
5224 +     return 0;
5225 +}
5226 +
5227 +static int install_data_files(ipkg_conf_t *conf, pkg_t *pkg)
5228 +{
5229 +     int err;
5230 +
5231 +     /* ipkg takes a slightly different approach to data file backups
5232 +       than dpkg. Rather than removing backups at this point, we
5233 +       actually do the data file installation now. See comments in
5234 +       check_data_file_clashes() for more details. */
5235 +
5236 +     ipkg_message(conf, IPKG_INFO,
5237 +                 "    extracting data files to %s\n", pkg->dest->root_dir);
5238 +     err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
5239 +     if (err) {
5240 +         return err;
5241 +     }
5242 +
5243 +     /* XXX: BUG or FEATURE : We are actually loosing the Essential flag,
5244 +        so we can't save ourself from removing important packages
5245 +        At this point we (should) have extracted the .control file, so it
5246 +        would be a good idea to reload the data in it, and set the Essential
5247 +        state in *pkg. From now on the Essential is back in status file and
5248 +        we can protect again.
5249 +        We should operate this way:
5250 +        fopen the file ( pkg->dest->root_dir/pkg->name.control )
5251 +        check for "Essential" in it
5252 +        set the value in pkg->essential.
5253 +        This new routine could be useful also for every other flag
5254 +        Pigi: 16/03/2004 */
5255 +     set_flags_from_control(conf, pkg) ;
5256 +
5257 +     ipkg_message(conf, IPKG_DEBUG, "    Calling pkg_write_filelist from %s\n", __FUNCTION__);
5258 +     err = pkg_write_filelist(conf, pkg);
5259 +     if (err)
5260 +         return err;
5261 +
5262 +     /* XXX: FEATURE: ipkg should identify any files which existed
5263 +       before installation and which were overwritten, (see
5264 +       check_data_file_clashes()). What it must do is remove any such
5265 +       files from the filelist of the old package which provided the
5266 +       file. Otherwise, if the old package were removed at some point
5267 +       it would break the new package. Removing the new package will
5268 +       also break the old one, but this cannot be helped since the old
5269 +       package's file has already been deleted. This is the importance
5270 +       of check_data_file_clashes(), and only allowing ipkg to install
5271 +       a clashing package with a user force. */
5272 +
5273 +     return 0;
5274 +}
5275 +
5276 +static int resolve_conffiles(ipkg_conf_t *conf, pkg_t *pkg)
5277 +{
5278 +     conffile_list_elt_t *iter;
5279 +     conffile_t *cf;
5280 +     char *cf_backup;
5281 +
5282 +    char *md5sum;
5283 +
5284 +
5285 +     if (conf->noaction) return 0;
5286 +
5287 +     for (iter = pkg->conffiles.head; iter; iter = iter->next) {
5288 +         char *root_filename;
5289 +         cf = iter->data;
5290 +         root_filename = root_filename_alloc(conf, cf->name);
5291 +
5292 +         /* Might need to initialize the md5sum for each conffile */
5293 +         if (cf->value == NULL) {
5294 +              cf->value = file_md5sum_alloc(root_filename);
5295 +         }
5296 +
5297 +         if (!file_exists(root_filename)) {
5298 +              free(root_filename);
5299 +              continue;
5300 +         }
5301 +
5302 +         cf_backup = backup_filename_alloc(root_filename);
5303 +
5304 +
5305 +         if (file_exists(cf_backup)) {
5306 + /* Let's compute md5 to test if files are changed */
5307 +             md5sum = file_md5sum_alloc(cf_backup);
5308 +               if (strcmp( cf->value,md5sum) != 0 ) {
5309 +                 if (conf->force_defaults
5310 +                     || user_prefers_old_conffile(cf->name, cf_backup) ) {
5311 +                      rename(cf_backup, root_filename);
5312 +                 }
5313 +              }
5314 +              unlink(cf_backup);
5315 +              free(md5sum);
5316 +         }
5317 +
5318 +         free(cf_backup);
5319 +         free(root_filename);
5320 +     }
5321 +
5322 +     return 0;
5323 +}
5324 +
5325 +static int user_prefers_old_conffile(const char *file_name, const char *backup)
5326 +{
5327 +     char *response;
5328 +     const char *short_file_name;
5329 +
5330 +     short_file_name = strrchr(file_name, '/');
5331 +     if (short_file_name) {
5332 +         short_file_name++;
5333 +     } else {
5334 +         short_file_name = file_name;
5335 +     }
5336 +
5337 +     while (1) {
5338 +         response = get_user_response("    Configuration file '%s'\n"
5339 +                                      "    ==> File on system created by you or by a script.\n"
5340 +                                      "    ==> File also in package provided by package maintainer.\n"
5341 +                                      "       What would you like to do about it ?  Your options are:\n"
5342 +                                      "        Y or I  : install the package maintainer's version\n"
5343 +                                      "        N or O  : keep your currently-installed version\n"
5344 +                                      "          D     : show the differences between the versions (if diff is installed)\n"
5345 +                                      "     The default action is to keep your current version.\n"
5346 +                                      "    *** %s (Y/I/N/O/D) [default=N] ? ", file_name, short_file_name);
5347 +         if (strcmp(response, "y") == 0
5348 +             || strcmp(response, "i") == 0
5349 +             || strcmp(response, "yes") == 0) {
5350 +              free(response);
5351 +              return 0;
5352 +         }
5353 +
5354 +         if (strcmp(response, "d") == 0) {
5355 +              char *cmd;
5356 +
5357 +              free(response);
5358 +              /* XXX: BUG rewrite to use exec or busybox's internal diff */
5359 +              sprintf_alloc(&cmd, "diff -u %s %s", backup, file_name);
5360 +              xsystem(cmd);
5361 +              free(cmd);
5362 +              printf("    [Press ENTER to continue]\n");
5363 +              response = file_read_line_alloc(stdin);
5364 +              free(response);
5365 +              continue;
5366 +         }
5367 +
5368 +         free(response);
5369 +         return 1;
5370 +     }
5371 +}
5372 +
5373 +/* XXX: CLEANUP: I'd like to move all of the code for
5374 +   creating/cleaning pkg->tmp_unpack_dir directly into pkg.c. (Then,
5375 +   it would make sense to cleanup pkg->tmp_unpack_dir directly from
5376 +   pkg_deinit for example). */
5377 +static int cleanup_temporary_files(ipkg_conf_t *conf, pkg_t *pkg)
5378 +{
5379 +     DIR *tmp_dir;
5380 +     struct dirent *dirent;
5381 +     char *tmp_file;
5382 +
5383 +#ifdef IPKG_DEBUG_NO_TMP_CLEANUP
5384 +#error
5385 +     ipkg_message(conf, IPKG_DEBUG,
5386 +                 "%s: Not cleaning up %s since ipkg compiled with IPKG_DEBUG_NO_TMP_CLEANUP\n",
5387 +                 __FUNCTION__, pkg->tmp_unpack_dir);
5388 +     return 0;
5389 +#endif
5390 +
5391 +     if (pkg->tmp_unpack_dir && file_is_dir(pkg->tmp_unpack_dir)) {
5392 +         tmp_dir = opendir(pkg->tmp_unpack_dir);
5393 +         if (tmp_dir) {
5394 +              while (1) {
5395 +                   dirent = readdir(tmp_dir);
5396 +                   if (dirent == NULL) {
5397 +                        break;
5398 +                   }
5399 +                   sprintf_alloc(&tmp_file, "%s/%s",
5400 +                                 pkg->tmp_unpack_dir, dirent->d_name);
5401 +                   if (! file_is_dir(tmp_file)) {
5402 +                        unlink(tmp_file);
5403 +                   }
5404 +                   free(tmp_file);
5405 +              }
5406 +              closedir(tmp_dir);
5407 +              rmdir(pkg->tmp_unpack_dir);
5408 +              free(pkg->tmp_unpack_dir);
5409 +              pkg->tmp_unpack_dir = NULL;
5410 +         }
5411 +     }
5412 +
5413 +     ipkg_message(conf, IPKG_INFO, "cleanup_temporary_files: pkg=%s local_filename=%s tmp_dir=%s\n",
5414 +                 pkg->name, pkg->local_filename, conf->tmp_dir);
5415 +     if (pkg->local_filename && strncmp(pkg->local_filename, conf->tmp_dir, strlen(conf->tmp_dir)) == 0) {
5416 +         unlink(pkg->local_filename);
5417 +         free(pkg->local_filename);
5418 +         pkg->local_filename = NULL;
5419 +     }
5420 +
5421 +     return 0;
5422 +}
5423 +
5424 +static char *backup_filename_alloc(const char *file_name)
5425 +{
5426 +     char *backup;
5427 +
5428 +     sprintf_alloc(&backup, "%s%s", file_name, IPKG_BACKUP_SUFFIX);
5429 +
5430 +     return backup;
5431 +}
5432 +
5433 +int backup_make_backup(ipkg_conf_t *conf, const char *file_name)
5434 +{
5435 +     int err;
5436 +     char *backup;
5437 +
5438 +     backup = backup_filename_alloc(file_name);
5439 +     err = file_copy(file_name, backup);
5440 +     if (err) {
5441 +         ipkg_message(conf, IPKG_ERROR,
5442 +                      "%s: Failed to copy %s to %s\n",
5443 +                      __FUNCTION__, file_name, backup);
5444 +     }
5445 +
5446 +     free(backup);
5447 +
5448 +     return err;
5449 +}
5450 +
5451 +static int backup_exists_for(const char *file_name)
5452 +{
5453 +     int ret;
5454 +     char *backup;
5455 +
5456 +     backup = backup_filename_alloc(file_name);
5457 +
5458 +     ret = file_exists(backup);
5459 +
5460 +     free(backup);
5461 +
5462 +     return ret;
5463 +}
5464 +
5465 +static int backup_remove(const char *file_name)
5466 +{
5467 +     char *backup;
5468 +
5469 +     backup = backup_filename_alloc(file_name);
5470 +     unlink(backup);
5471 +     free(backup);
5472 +
5473 +     return 0;
5474 +}
5475 +
5476 +\f
5477 +
5478 +#ifdef CONFIG_IPKG_PROCESS_ACTIONS
5479 +
5480 +int ipkg_remove_packages(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_remove)
5481 +{
5482 +     /* first, remove the packages that need removing */
5483 +     for (i = 0 ; i < pkgs_to_remove->len; i++ ) {
5484 +         pkg_t *pkg = pkgs_to_remove->pkgs[i];
5485 +         err = ipkg_remove_pkg(conf, pkg,0);
5486 +         if (err) return err;
5487 +     }
5488 +     return 0;
5489 +}
5490 +
5491 +int ipkg_process_actions_sanity_check(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_remove, pkg_vec_t *pkgs_superseded, pkg_vec_t *pkgs_to_install)
5492 +{
5493 +     int i;
5494 +     /* now one more pass checking on the ones that need to be installed */
5495 +     for (i = 0 ; i < pkgs_to_install->len; i++ ) {
5496 +         pkg_t *pkg = pkgs_to_install->pkgs[i];
5497 +         if (pkg->dest == NULL)
5498 +              pkg->dest = conf->default_dest;
5499 +
5500 +         pkg->state_want = SW_INSTALL;
5501 +
5502 +         /* Abhaya: conflicts check */
5503 +         err = check_conflicts_for(conf, pkg);
5504 +         if (err) { return err; }
5505 +     }
5506 +     return 0;
5507 +}
5508 +
5509 +int ipkg_process_actions_unpack_packages(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_remove, pkg_vec_t *pkgs_to_install)
5510 +{
5511 +     int i;
5512 +     /* now one more pass checking on the ones that need to be installed */
5513 +     for (i = 0 ; i < pkgs_to_install->len; i++ ) {
5514 +         pkg_t *pkg = pkgs_to_install->pkgs[i];
5515 +
5516 +         /* XXX: FEATURE: Need to really support Provides/Replaces: here at some point */
5517 +         pkg_vec_t *replacees = pkg_vec_alloc();
5518 +         pkg_get_installed_replacees(conf, pkg, replacees);
5519 +
5520 +         /* XXX: BUG: we really should treat replacement more like an upgrade
5521 +          *      Instead, we're going to remove the replacees
5522 +          */
5523 +         err = pkg_remove_installed_replacees(conf, replacees);
5524 +         if (err) return err;
5525 +         pkg->state_flag |= SF_REMOVED_REPLACEES;
5526 +     }
5527 +     return 0;
5528 +}
5529 +
5530 +int ipkg_process_actions_unpack_packages(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_remove, pkg_vec_t *pkgs_to_install)
5531 +{
5532 +     int i;
5533 +     /* now one more pass checking on the ones that need to be installed */
5534 +     for (i = 0 ; i < pkgs_to_install->len; i++ ) {
5535 +         pkg_t *pkg = pkgs_to_install->pkgs[i];
5536 +         if (pkg->local_filename == NULL) {
5537 +              err = ipkg_download_pkg(conf, pkg, conf->tmp_dir);
5538 +              if (err) {
5539 +                   ipkg_message(conf, IPKG_ERROR,
5540 +                                "Failed to download %s. Perhaps you need to run 'ipkg update'?\n",
5541 +                                pkg->name);
5542 +                   return err;
5543 +              }
5544 +         }
5545 +         if (pkg->tmp_unpack_dir == NULL) {
5546 +              err = unpack_pkg_control_files(conf, pkg);
5547 +              if (err) return err;
5548 +         }
5549 +     }
5550 +     return 0;
5551 +}
5552 +
5553 +int ipkg_process_actions_prerm(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_install)
5554 +{
5555 +     int i;
5556 +     /* now one more pass checking on the ones that need to be installed */
5557 +     for (i = 0 ; i < pkgs_to_install->len; i++ ) {
5558 +         pkg_t *pkg = pkgs_to_install->pkgs[i];
5559 +         pkg_t *old_pkg = pkg->old_pkg;
5560 +
5561 +         err = prerm_upgrade_old_pkg(conf, pkg, old_pkg);
5562 +         if (err) return err;
5563 +
5564 +         err = prerm_deconfigure_conflictors(conf, pkg, replacees);
5565 +         if (err) return err;
5566 +
5567 +         err = preinst_configure(conf, pkg, old_pkg);
5568 +         if (err) return err;
5569 +
5570 +         err = backup_modified_conffiles(conf, pkg, old_pkg);
5571 +         if (err) return err;
5572 +
5573 +         err = postrm_upgrade_old_pkg(conf, pkg, old_pkg);
5574 +         if (err) return err;
5575 +     }
5576 +     return 0;
5577 +}
5578 +
5579 +int ipkg_process_actions_install(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_install)
5580 +{
5581 +     int i;
5582 +     /* now one more pass checking on the ones that need to be installed */
5583 +     for (i = 0 ; i < pkgs_to_install->len; i++ ) {
5584 +         pkg_t *pkg = pkgs_to_install->pkgs[i];
5585 +         pkg_t *old_pkg = pkg->old_pkg;
5586 +
5587 +         if (old_pkg) {
5588 +              old_pkg->state_want = SW_DEINSTALL;
5589 +
5590 +              if (old_pkg->state_flag & SF_NOPRUNE) {
5591 +                   ipkg_message(conf, IPKG_INFO,
5592 +                                "  not removing obsolesced files because package marked noprune\n");
5593 +              } else {
5594 +                   ipkg_message(conf, IPKG_INFO,
5595 +                                "  removing obsolesced files\n");
5596 +                   remove_obsolesced_files(conf, pkg, old_pkg);
5597 +              }
5598 +         }
5599 +
5600 +         ipkg_message(conf, IPKG_INFO,
5601 +                      "  installing maintainer scripts\n");
5602 +         install_maintainer_scripts(conf, pkg, old_pkg);
5603 +
5604 +         /* the following just returns 0 */
5605 +         remove_disappeared(conf, pkg);
5606 +
5607 +         ipkg_message(conf, IPKG_INFO,
5608 +                      "  installing data files\n");
5609 +         install_data_files(conf, pkg);
5610 +
5611 +         ipkg_message(conf, IPKG_INFO,
5612 +                      "  resolving conf files\n");
5613 +         resolve_conffiles(conf, pkg);
5614 +
5615 +         pkg->state_status = SS_UNPACKED;
5616 +
5617 +         if (old_pkg) {
5618 +              old_pkg->state_status = SS_NOT_INSTALLED;
5619 +         }
5620 +
5621 +         time(&pkg->installed_time);
5622 +
5623 +         ipkg_message(conf, IPKG_INFO,
5624 +                      "  cleanup temp files\n");
5625 +         cleanup_temporary_files(conf, pkg);
5626 +
5627 +         if (pkg->parent)
5628 +              pkg->parent->state_status = pkg->state_status;
5629 +     }
5630 +     return 0;
5631 +}
5632 +
5633 +int ipkg_process_actions_unwind_prerm(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_install)
5634 +{
5635 +     int i;
5636 +     /* now one more pass checking on the ones that need to be installed */
5637 +     for (i = 0 ; i < pkgs_to_install->len; i++ ) {
5638 +         pkg_t *pkg = pkgs_to_install->pkgs[i];
5639 +         pkg_t *old_pkg = pkg->old_pkg;
5640 +
5641 +         if (old_pkg) {
5642 +              if (old_pkg->state_flags & SF_POSTRM_UPGRADE)
5643 +                   postrm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
5644 +              if (old_pkg->state_flags & SF_CHECK_DATA_FILE_CLASHES)
5645 +                   check_data_file_clashes_unwind(conf, pkg, old_pkg);
5646 +              if (old_pkg->state_flags & SF_BACKUP_MODIFIED_CONFFILES)
5647 +                   backup_modified_conffiles_unwind(conf, pkg, old_pkg);
5648 +              if (old_pkg->state_flags & SF_PREINST_CONFIGURE)
5649 +                   preinst_configure_unwind(conf, pkg, old_pkg);
5650 +              if (old_pkg->state_flags & SF_DECONFIGURE_CONFLICTORS)
5651 +                   prerm_deconfigure_conflictors_unwind(conf, pkg, replacees);
5652 +              if (old_pkg->state_flags & SF_PRERM_UPGRADE)
5653 +                   prerm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
5654 +
5655 +              if (old_pkg->state_flags & SF_REMOVED_REPLACEES)
5656 +                   remove_installed_replacees_unwind(conf, pkg, old_pkg);
5657 +
5658 +         }
5659 +     }
5660 +     return 0;
5661 +}
5662 +
5663 +/*
5664 + * Perform all the actions.
5665 + *
5666 + * pkgs_to_remove are packages marked for removal.
5667 + * pkgs_superseded are the old packages being replaced by upgrades.
5668 + *
5669 + * Assumes pkgs_to_install includes all dependences, recursively, sorted in installable order.
5670 + */
5671 +int ipkg_process_actions(ipkg_conf_t *conf, pkg_vec_t *pkgs_to_remove, pkg_vec_t *pkgs_superseded, pkg_vec_t *pkgs_to_install)
5672 +{
5673 +     int err;
5674 +     int i;
5675 +
5676 +     err = ipkg_remove_packages(conf, pkgs_to_remove);
5677 +     if (err) return err;
5678 +
5679 +     err = ipkg_process_actions_sanity_check(conf, pkgs_superseded, pkgs_to_install);
5680 +     if (err) return err;
5681 +
5682 +     err = ipkg_process_actions_remove_replacees(conf, pkgs_to_install);
5683 +     if (err) goto UNWIND;
5684 +
5685 +     /* @@@@ look at ipkg_install_pkg for handling replacements */
5686 +     err = ipkg_process_actions_unpack_packages(conf, pkgs_to_install);
5687 +     if (err) goto UNWIND;
5688 +
5689 +     /*
5690 +      * Now that we have the packages unpacked, we can look for data
5691 +      * file clashes.  First, we mark the files from the superseded
5692 +      * packages as obsolete.  Then we scan the files in
5693 +      * pkgs_to_install, and only complain about clashes with
5694 +      * non-obsolete files.
5695 +      */
5696 +
5697 +     err = ipkg_process_actions_check_data_file_clashes(conf, pkgs_superseded, pkgs_to_install);
5698 +     if (err) goto UNWIND;
5699 +
5700 +     /* this was before checking data file clashes */
5701 +     err = ipkg_process_actions_prerm(conf, pkgs_superseded, pkgs_to_install);
5702 +     if (err) goto UNWIND;
5703 +
5704 +     /* point of no return: no unwinding after this */
5705 +     err = ipkg_process_actions_install(conf, pkgs_to_install);
5706 +     if (err) return err;
5707 +
5708 +     ipkg_message(conf, IPKG_INFO, "Done.\n");
5709 +     return 0;
5710 +
5711 + UNWIND:
5712 +     ipkg_process_actions_unwind(conf, pkgs_to_install);
5713 +
5714 +     ipkg_message(conf, IPKG_INFO,
5715 +                 "  cleanup temp files\n");
5716 +     cleanup_temporary_files(conf, pkg);
5717 +
5718 +     ipkg_message(conf, IPKG_INFO,
5719 +                 "Failed.\n");
5720 +     return err;
5721 +}
5722 +
5723 +#endif
5724 Index: busybox-1.7.2/archival/libipkg/ipkg_install.h
5725 ===================================================================
5726 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
5727 +++ busybox-1.7.2/archival/libipkg/ipkg_install.h       2007-10-04 17:14:22.753038046 +0200
5728 @@ -0,0 +1,35 @@
5729 +/* ipkg_install.h - the itsy package management system
5730 +
5731 +   Carl D. Worth
5732 +
5733 +   Copyright (C) 2001 University of Southern California
5734 +
5735 +   This program is free software; you can redistribute it and/or
5736 +   modify it under the terms of the GNU General Public License as
5737 +   published by the Free Software Foundation; either version 2, or (at
5738 +   your option) any later version.
5739 +
5740 +   This program is distributed in the hope that it will be useful, but
5741 +   WITHOUT ANY WARRANTY; without even the implied warranty of
5742 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
5743 +   General Public License for more details.
5744 +*/
5745 +
5746 +#ifndef IPKG_INSTALL_H
5747 +#define IPKG_INSTALL_H
5748 +
5749 +#include "pkg.h"
5750 +#include "ipkg_conf.h"
5751 +
5752 +ipkg_error_t ipkg_install_by_name(ipkg_conf_t *conf, const char *pkg_name);
5753 +ipkg_error_t ipkg_install_multi_by_name(ipkg_conf_t *conf, const char *pkg_name);
5754 +int ipkg_install_from_file(ipkg_conf_t *conf, const char *filename);
5755 +int ipkg_install_pkg(ipkg_conf_t *conf, pkg_t *pkg,int from_upgrading);
5756 +int satisfy_dependencies_for(ipkg_conf_t *conf, pkg_t *pkg);
5757 +
5758 +int ipkg_satisfy_all_dependences(ipkg_conf_t *conf);
5759 +
5760 +int pkg_mark_dependencies_for_installation(ipkg_conf_t *conf, pkg_t *pkg_name, pkg_vec_t *pkgs_needed);
5761 +int name_mark_dependencies_for_installation(ipkg_conf_t *conf, const char *pkg_name, pkg_vec_t *pkgs_needed);
5762 +
5763 +#endif
5764 Index: busybox-1.7.2/archival/libipkg/ipkg_message.c
5765 ===================================================================
5766 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
5767 +++ busybox-1.7.2/archival/libipkg/ipkg_message.c       2007-10-04 17:24:58.037240829 +0200
5768 @@ -0,0 +1,61 @@
5769 +/* ipkg_message.c - the itsy package management system
5770 +
5771 +   Copyright (C) 2003 Daniele Nicolodi <daniele@grinta.net>
5772 +
5773 +   This program is free software; you can redistribute it and/or
5774 +   modify it under the terms of the GNU General Public License as
5775 +   published by the Free Software Foundation; either version 2, or (at
5776 +   your option) any later version.
5777 +
5778 +   This program is distributed in the hope that it will be useful, but
5779 +   WITHOUT ANY WARRANTY; without even the implied warranty of
5780 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
5781 +   General Public License for more details.
5782 +*/
5783 +
5784 +
5785 +#include "ipkg.h"
5786 +#include "ipkg_conf.h"
5787 +#include "ipkg_message.h"
5788 +
5789 +#ifndef IPKG_LIB
5790 +
5791 +void
5792 +ipkg_message (ipkg_conf_t * conf, message_level_t level, const char *fmt, ...)
5793 +{
5794 +       va_list ap;
5795 +
5796 +       if (conf && (conf->verbosity < level))
5797 +       {
5798 +               return;
5799 +       }
5800 +       else
5801 +       {
5802 +
5803 +               va_start (ap, fmt);
5804 +               vprintf (fmt, ap);
5805 +               va_end (ap);
5806 +       }
5807 +}
5808 +
5809 +#else
5810 +
5811 +#include "libipkg.h"
5812 +
5813 +//#define ipkg_message(conf, level, fmt, arg...) ipkg_cb_message(conf, level, fmt, ## arg)
5814 +
5815 +void
5816 +ipkg_message (ipkg_conf_t * conf, message_level_t level, const char *fmt, ...)
5817 +{
5818 +       va_list ap;
5819 +       char ts[256];
5820 +
5821 +       if (ipkg_cb_message)
5822 +       {
5823 +               va_start (ap, fmt);
5824 +               vsnprintf (ts,256,fmt, ap);
5825 +               va_end (ap);
5826 +               ipkg_cb_message(conf,level,ts);
5827 +       }
5828 +}
5829 +#endif
5830 Index: busybox-1.7.2/archival/libipkg/ipkg_message.h
5831 ===================================================================
5832 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
5833 +++ busybox-1.7.2/archival/libipkg/ipkg_message.h       2007-10-04 17:23:42.072911866 +0200
5834 @@ -0,0 +1,32 @@
5835 +/* ipkg_message.h - the itsy package management system
5836 +
5837 +   Copyright (C) 2003 Daniele Nicolodi <daniele@grinta.net>
5838 +
5839 +   This program is free software; you can redistribute it and/or
5840 +   modify it under the terms of the GNU General Public License as
5841 +   published by the Free Software Foundation; either version 2, or (at
5842 +   your option) any later version.
5843 +
5844 +   This program is distributed in the hope that it will be useful, but
5845 +   WITHOUT ANY WARRANTY; without even the implied warranty of
5846 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
5847 +   General Public License for more details.
5848 +*/
5849 +
5850 +#ifndef _IPKG_MESSAGE_H_
5851 +#define _IPKG_MESSAGE_H_
5852 +
5853 +#include "ipkg.h"
5854 +#include "ipkg_conf.h"
5855 +
5856 +typedef enum {
5857 +     IPKG_ERROR,       /* error conditions */
5858 +     IPKG_NOTICE,      /* normal but significant condition */
5859 +     IPKG_INFO,                /* informational message */
5860 +     IPKG_DEBUG,       /* debug level message */
5861 +     IPKG_DEBUG2,      /* more debug level message */
5862 +} message_level_t;
5863 +
5864 +extern void ipkg_message(ipkg_conf_t *conf, message_level_t level, const char *fmt, ...);
5865 +
5866 +#endif /* _IPKG_MESSAGE_H_ */
5867 Index: busybox-1.7.2/archival/libipkg/ipkg_remove.c
5868 ===================================================================
5869 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
5870 +++ busybox-1.7.2/archival/libipkg/ipkg_remove.c        2007-10-04 17:14:22.801040776 +0200
5871 @@ -0,0 +1,383 @@
5872 +/* ipkg_remove.c - the itsy package management system
5873 +
5874 +   Carl D. Worth
5875 +
5876 +   Copyright (C) 2001 University of Southern California
5877 +
5878 +   This program is free software; you can redistribute it and/or
5879 +   modify it under the terms of the GNU General Public License as
5880 +   published by the Free Software Foundation; either version 2, or (at
5881 +   your option) any later version.
5882 +
5883 +   This program is distributed in the hope that it will be useful, but
5884 +   WITHOUT ANY WARRANTY; without even the implied warranty of
5885 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
5886 +   General Public License for more details.
5887 +*/
5888 +
5889 +#include "ipkg.h"
5890 +#include "ipkg_message.h"
5891 +
5892 +#include <glob.h>
5893 +
5894 +#include "ipkg_remove.h"
5895 +
5896 +#include "file_util.h"
5897 +#include "sprintf_alloc.h"
5898 +#include "str_util.h"
5899 +
5900 +#include "ipkg_cmd.h"
5901 +
5902 +/*
5903 + * Returns number of the number of packages depending on the packages provided by this package.
5904 + * Every package implicitly provides itself.
5905 + */
5906 +int pkg_has_installed_dependents(ipkg_conf_t *conf, abstract_pkg_t *parent_apkg, pkg_t *pkg, abstract_pkg_t *** pdependents)
5907 +{
5908 +     int nprovides = pkg->provides_count;
5909 +     abstract_pkg_t **provides = pkg->provides;
5910 +     int n_installed_dependents = 0;
5911 +     int i;
5912 +     for (i = 0; i <= nprovides; i++) {
5913 +         abstract_pkg_t *providee = provides[i];
5914 +         abstract_pkg_t **dependers = providee->depended_upon_by;
5915 +         abstract_pkg_t *dep_ab_pkg;
5916 +         if (dependers == NULL)
5917 +              continue;
5918 +         while ((dep_ab_pkg = *dependers++) != NULL) {
5919 +              if (dep_ab_pkg->state_status == SS_INSTALLED){
5920 +                   n_installed_dependents++;
5921 +               }
5922 +         }
5923 +
5924 +     }
5925 +     /* if caller requested the set of installed dependents */
5926 +     if (pdependents) {
5927 +         int p = 0;
5928 +         abstract_pkg_t **dependents = (abstract_pkg_t **)malloc((n_installed_dependents+1)*sizeof(abstract_pkg_t *));
5929 +
5930 +          if ( dependents == NULL ){
5931 +              fprintf(stderr,"%s Unable to allocate memory. REPORT THIS BUG IN BUGZILLA PLEASE\n", __FUNCTION__);
5932 +              return -1;
5933 +          }
5934 +
5935 +         *pdependents = dependents;
5936 +         for (i = 0; i <= nprovides; i++) {
5937 +              abstract_pkg_t *providee = provides[i];
5938 +              abstract_pkg_t **dependers = providee->depended_upon_by;
5939 +              abstract_pkg_t *dep_ab_pkg;
5940 +              if (dependers == NULL)
5941 +                   continue;
5942 +              while ((dep_ab_pkg = *dependers++) != NULL) {
5943 +                   if (dep_ab_pkg->state_status == SS_INSTALLED && !(dep_ab_pkg->state_flag & SF_MARKED)) {
5944 +                        dependents[p++] = dep_ab_pkg;
5945 +                        dep_ab_pkg->state_flag |= SF_MARKED;
5946 +                   }
5947 +              }
5948 +         }
5949 +         dependents[p] = NULL;
5950 +         /* now clear the marks */
5951 +         for (i = 0; i < p; i++) {
5952 +              abstract_pkg_t *dep_ab_pkg = dependents[i];
5953 +              dep_ab_pkg->state_flag &= ~SF_MARKED;
5954 +         }
5955 +     }
5956 +     return n_installed_dependents;
5957 +}
5958 +
5959 +int ipkg_remove_dependent_pkgs (ipkg_conf_t *conf, pkg_t *pkg, abstract_pkg_t **dependents)
5960 +{
5961 +    int i;
5962 +    int a;
5963 +    int count;
5964 +    pkg_vec_t *dependent_pkgs = pkg_vec_alloc();
5965 +    abstract_pkg_t * ab_pkg;
5966 +
5967 +    if((ab_pkg = pkg->parent) == NULL){
5968 +       fprintf(stderr, "%s: unable to get dependent pkgs. pkg %s isn't in hash table\n",
5969 +               __FUNCTION__, pkg->name);
5970 +       return 0;
5971 +    }
5972 +
5973 +    if (dependents == NULL)
5974 +           return 0;
5975 +
5976 +    // here i am using the dependencies_checked
5977 +    if (ab_pkg->dependencies_checked == 2) // variable to make out whether this package
5978 +       return 0;                          // has already been encountered in the process
5979 +                                          // of marking packages for removal - Karthik
5980 +    ab_pkg->dependencies_checked = 2;
5981 +
5982 +    i = 0;
5983 +    count = 1;
5984 +    while (dependents [i] != NULL) {
5985 +        abstract_pkg_t *dep_ab_pkg = dependents[i];
5986 +
5987 +       if (dep_ab_pkg->dependencies_checked == 2){
5988 +           i++;
5989 +           continue;
5990 +        }
5991 +        if (dep_ab_pkg->state_status == SS_INSTALLED) {
5992 +            for (a = 0; a < dep_ab_pkg->pkgs->len; a++) {
5993 +                pkg_t *dep_pkg = dep_ab_pkg->pkgs->pkgs[a];
5994 +                if (dep_pkg->state_status == SS_INSTALLED) {
5995 +                    pkg_vec_insert(dependent_pkgs, dep_pkg);
5996 +                    count++;
5997 +                }
5998 +            }
5999 +        }
6000 +       i++;
6001 +       /* 1 - to keep track of visited ab_pkgs when checking for possiblility of a broken removal of pkgs.
6002 +        * 2 - to keep track of pkgs whose deps have been checked alrdy  - Karthik */
6003 +    }
6004 +
6005 +    if (count == 1)
6006 +           return 0;
6007 +
6008 +
6009 +    for (i = 0; i < dependent_pkgs->len; i++) {
6010 +        int err = ipkg_remove_pkg(conf, dependent_pkgs->pkgs[i],0);
6011 +        if (err)
6012 +            return err;
6013 +    }
6014 +    return 0;
6015 +}
6016 +
6017 +static int user_prefers_removing_dependents(ipkg_conf_t *conf, abstract_pkg_t *abpkg, pkg_t *pkg, abstract_pkg_t **dependents)
6018 +{
6019 +    abstract_pkg_t *dep_ab_pkg;
6020 +    ipkg_message(conf, IPKG_ERROR, "Package %s is depended upon by packages:\n", pkg->name);
6021 +    while ((dep_ab_pkg = *dependents++) != NULL) {
6022 +        if (dep_ab_pkg->state_status == SS_INSTALLED)
6023 +             ipkg_message(conf, IPKG_ERROR, "\t%s\n", dep_ab_pkg->name);
6024 +    }
6025 +    ipkg_message(conf, IPKG_ERROR, "These might cease to work if package %s is removed.\n\n", pkg->name);
6026 +    ipkg_message(conf, IPKG_ERROR, "");
6027 +    ipkg_message(conf, IPKG_ERROR, "You can force removal of this package with -force-depends.\n");
6028 +    ipkg_message(conf, IPKG_ERROR, "You can force removal of this package and its dependents\n");
6029 +    ipkg_message(conf, IPKG_ERROR, "with -force-removal-of-dependent-packages or -recursive\n");
6030 +    ipkg_message(conf, IPKG_ERROR, "or by setting option force_removal_of_dependent_packages\n");
6031 +    ipkg_message(conf, IPKG_ERROR, "in ipkg.conf.\n");
6032 +    return 0;
6033 +}
6034 +
6035 +int ipkg_remove_pkg(ipkg_conf_t *conf, pkg_t *pkg,int message)
6036 +{
6037 +/* Actually, when "message == 1" I have been called from an upgrade, and not from a normal remove
6038 +   thus I wan't check for essential, as I'm upgrading.
6039 +   I hope it won't break anything :)
6040 +*/
6041 +     int err;
6042 +     abstract_pkg_t *parent_pkg = NULL;
6043 +
6044 +     if (pkg->essential && !message) {
6045 +         if (conf->force_removal_of_essential_packages) {
6046 +              fprintf(stderr, "WARNING: Removing essential package %s under your coercion.\n"
6047 +                      "\tIf your system breaks, you get to keep both pieces\n",
6048 +                      pkg->name);
6049 +         } else {
6050 +              fprintf(stderr, "ERROR: Refusing to remove essential package %s.\n"
6051 +                      "\tRemoving an essential package may lead to an unusable system, but if\n"
6052 +                      "\tyou enjoy that kind of pain, you can force ipkg to proceed against\n"
6053 +                      "\tits will with the option: -force-removal-of-essential-packages\n",
6054 +                      pkg->name);
6055 +              return IPKG_PKG_IS_ESSENTIAL;
6056 +         }
6057 +     }
6058 +
6059 +     if ((parent_pkg = pkg->parent) == NULL)
6060 +         return 0;
6061 +
6062 +     /* only attempt to remove dependent installed packages if
6063 +      * force_depends is not specified or the package is being
6064 +      * replaced.
6065 +      */
6066 +     if (!conf->force_depends
6067 +        && !(pkg->state_flag & SF_REPLACE)) {
6068 +         abstract_pkg_t **dependents;
6069 +         int has_installed_dependents =
6070 +              pkg_has_installed_dependents(conf, parent_pkg, pkg, &dependents);
6071 +
6072 +         if (has_installed_dependents) {
6073 +              /*
6074 +               * if this package is depended up by others, then either we should
6075 +               * not remove it or we should remove it and all of its dependents
6076 +               */
6077 +
6078 +              if (!conf->force_removal_of_dependent_packages
6079 +                  && !user_prefers_removing_dependents(conf, parent_pkg, pkg, dependents)) {
6080 +                   return IPKG_PKG_HAS_DEPENDENTS;
6081 +              }
6082 +
6083 +              /* remove packages depending on this package - Karthik */
6084 +              err = ipkg_remove_dependent_pkgs (conf, pkg, dependents);
6085 +              free(dependents);
6086 +              if (err) return err;
6087 +         }
6088 +     }
6089 +
6090 +     if ( message==0 ){
6091 +         printf("Removing package %s from %s...\n", pkg->name, pkg->dest->name);
6092 +         fflush(stdout);
6093 +     }
6094 +     pkg->state_flag |= SF_FILELIST_CHANGED;
6095 +
6096 +     pkg->state_want = SW_DEINSTALL;
6097 +     ipkg_state_changed++;
6098 +
6099 +     pkg_run_script(conf, pkg, "prerm", "remove");
6100 +
6101 +     /* DPKG_INCOMPATIBILITY: dpkg is slightly different here. It
6102 +       maintains an empty filelist rather than deleting it. That seems
6103 +       like a big pain, and I don't see that that should make a big
6104 +       difference, but for anyone who wants tighter compatibility,
6105 +       feel free to fix this. */
6106 +     remove_data_files_and_list(conf, pkg);
6107 +
6108 +     pkg_run_script(conf, pkg, "postrm", "remove");
6109 +
6110 +     remove_maintainer_scripts_except_postrm(conf, pkg);
6111 +
6112 +     /* Aman Gupta - Since ipkg is made for handheld devices with limited
6113 +      * space, it doesn't make sense to leave extra configurations, files,
6114 +      * and maintainer scripts left around. So, we make remove like purge,
6115 +      * and take out all the crap :) */
6116 +
6117 +     remove_postrm(conf, pkg);
6118 +     pkg->state_status = SS_NOT_INSTALLED;
6119 +
6120 +     if (parent_pkg)
6121 +         parent_pkg->state_status = SS_NOT_INSTALLED;
6122 +
6123 +     return 0;
6124 +}
6125 +
6126 +int ipkg_purge_pkg(ipkg_conf_t *conf, pkg_t *pkg)
6127 +{
6128 +    ipkg_remove_pkg(conf, pkg,0);
6129 +    return 0;
6130 +}
6131 +
6132 +int remove_data_files_and_list(ipkg_conf_t *conf, pkg_t *pkg)
6133 +{
6134 +     str_list_t installed_dirs;
6135 +     str_list_t *installed_files;
6136 +     str_list_elt_t *iter;
6137 +     char *file_name;
6138 +     conffile_t *conffile;
6139 +     int removed_a_dir;
6140 +     pkg_t *owner;
6141 +
6142 +     str_list_init(&installed_dirs);
6143 +     installed_files = pkg_get_installed_files(pkg);
6144 +
6145 +     for (iter = installed_files->head; iter; iter = iter->next) {
6146 +         file_name = iter->data;
6147 +
6148 +         if (file_is_dir(file_name)) {
6149 +              str_list_append(&installed_dirs, strdup(file_name));
6150 +              continue;
6151 +         }
6152 +
6153 +         conffile = pkg_get_conffile(pkg, file_name);
6154 +         if (conffile) {
6155 +              /* XXX: QUESTION: Is this right? I figure we only need to
6156 +                 save the conffile if it has been modified. Is that what
6157 +                 dpkg does? Or does dpkg preserve all conffiles? If so,
6158 +                 this seems like a better thing to do to conserve
6159 +                 space. */
6160 +              if (conffile_has_been_modified(conf, conffile)) {
6161 +                   printf("  not deleting modified conffile %s\n", file_name);
6162 +                   fflush(stdout);
6163 +                   continue;
6164 +              }
6165 +         }
6166 +
6167 +         ipkg_message(conf, IPKG_INFO, "  deleting %s (noaction=%d)\n", file_name, conf->noaction);
6168 +         if (!conf->noaction)
6169 +              unlink(file_name);
6170 +     }
6171 +
6172 +     if (!conf->noaction) {
6173 +         do {
6174 +              removed_a_dir = 0;
6175 +              for (iter = installed_dirs.head; iter; iter = iter->next) {
6176 +                   file_name = iter->data;
6177 +
6178 +                   if (rmdir(file_name) == 0) {
6179 +                        ipkg_message(conf, IPKG_INFO, "  deleting %s\n", file_name);
6180 +                        removed_a_dir = 1;
6181 +                        str_list_remove(&installed_dirs, &iter);
6182 +                   }
6183 +              }
6184 +         } while (removed_a_dir);
6185 +     }
6186 +
6187 +     pkg_free_installed_files(pkg);
6188 +     /* We have to remove the file list now, so that
6189 +       find_pkg_owning_file does not always just report this package */
6190 +     pkg_remove_installed_files_list(conf, pkg);
6191 +
6192 +     /* Don't print warning for dirs that are provided by other packages */
6193 +     for (iter = installed_dirs.head; iter; iter = iter->next) {
6194 +         file_name = iter->data;
6195 +
6196 +         owner = file_hash_get_file_owner(conf, file_name);
6197 +         if (owner) {
6198 +              free(iter->data);
6199 +              iter->data = NULL;
6200 +              str_list_remove(&installed_dirs, &iter);
6201 +         }
6202 +     }
6203 +
6204 +     /* cleanup */
6205 +     for (iter = installed_dirs.head; iter; iter = iter->next) {
6206 +         free(iter->data);
6207 +         iter->data = NULL;
6208 +     }
6209 +     str_list_deinit(&installed_dirs);
6210 +
6211 +     return 0;
6212 +}
6213 +
6214 +int remove_maintainer_scripts_except_postrm(ipkg_conf_t *conf, pkg_t *pkg)
6215 +{
6216 +    int i, err;
6217 +    char *globpattern;
6218 +    glob_t globbuf;
6219 +
6220 +    if (conf->noaction) return 0;
6221 +
6222 +    sprintf_alloc(&globpattern, "%s/%s.*",
6223 +                 pkg->dest->info_dir, pkg->name);
6224 +    err = glob(globpattern, 0, NULL, &globbuf);
6225 +    free(globpattern);
6226 +    if (err) {
6227 +       return 0;
6228 +    }
6229 +
6230 +    for (i = 0; i < globbuf.gl_pathc; i++) {
6231 +       if (str_ends_with(globbuf.gl_pathv[i], ".postrm")) {
6232 +           continue;
6233 +       }
6234 +        ipkg_message(conf, IPKG_INFO, "  deleting %s\n", globbuf.gl_pathv[i]);
6235 +       unlink(globbuf.gl_pathv[i]);
6236 +    }
6237 +    globfree(&globbuf);
6238 +
6239 +    return 0;
6240 +}
6241 +
6242 +int remove_postrm(ipkg_conf_t *conf, pkg_t *pkg)
6243 +{
6244 +    char *postrm_file_name;
6245 +
6246 +    if (conf->noaction) return 0;
6247 +
6248 +    sprintf_alloc(&postrm_file_name, "%s/%s.postrm",
6249 +                 pkg->dest->info_dir, pkg->name);
6250 +    unlink(postrm_file_name);
6251 +    free(postrm_file_name);
6252 +
6253 +    return 0;
6254 +}
6255 Index: busybox-1.7.2/archival/libipkg/ipkg_remove.h
6256 ===================================================================
6257 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
6258 +++ busybox-1.7.2/archival/libipkg/ipkg_remove.h        2007-10-04 17:14:22.821041916 +0200
6259 @@ -0,0 +1,33 @@
6260 +/* ipkg_remove.h - the itsy package management system
6261 +
6262 +   Carl D. Worth
6263 +
6264 +   Copyright (C) 2001 University of Southern California
6265 +
6266 +   This program is free software; you can redistribute it and/or
6267 +   modify it under the terms of the GNU General Public License as
6268 +   published by the Free Software Foundation; either version 2, or (at
6269 +   your option) any later version.
6270 +
6271 +   This program is distributed in the hope that it will be useful, but
6272 +   WITHOUT ANY WARRANTY; without even the implied warranty of
6273 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
6274 +   General Public License for more details.
6275 +*/
6276 +
6277 +#ifndef IPKG_REMOVE_H
6278 +#define IPKG_REMOVE_H
6279 +
6280 +#include "pkg.h"
6281 +#include "ipkg_conf.h"
6282 +
6283 +int ipkg_remove_pkg(ipkg_conf_t *conf, pkg_t *pkg,int message);
6284 +int ipkg_purge_pkg(ipkg_conf_t *conf, pkg_t *pkg);
6285 +int possible_broken_removal_of_packages (ipkg_conf_t *conf, pkg_t *pkg);
6286 +int pkg_has_installed_dependents(ipkg_conf_t *conf, abstract_pkg_t *parent_apkg, pkg_t *pkg, abstract_pkg_t *** pdependents);
6287 +int remove_data_files_and_list(ipkg_conf_t *conf, pkg_t *pkg);
6288 +int remove_maintainer_scripts_except_postrm (ipkg_conf_t *conf, pkg_t *pkg);
6289 +int remove_postrm (ipkg_conf_t *conf, pkg_t *pkg);
6290 +
6291 +
6292 +#endif
6293 Index: busybox-1.7.2/archival/libipkg/ipkg_upgrade.c
6294 ===================================================================
6295 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
6296 +++ busybox-1.7.2/archival/libipkg/ipkg_upgrade.c       2007-10-04 17:14:22.837042832 +0200
6297 @@ -0,0 +1,77 @@
6298 +/* ipkg_upgrade.c - the itsy package management system
6299 +
6300 +   Carl D. Worth
6301 +   Copyright (C) 2001 University of Southern California
6302 +
6303 +   Copyright (C) 2003 Daniele Nicolodi <daniele@grinta.net>
6304 +
6305 +   This program is free software; you can redistribute it and/or
6306 +   modify it under the terms of the GNU General Public License as
6307 +   published by the Free Software Foundation; either version 2, or (at
6308 +   your option) any later version.
6309 +
6310 +   This program is distributed in the hope that it will be useful, but
6311 +   WITHOUT ANY WARRANTY; without even the implied warranty of
6312 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
6313 +   General Public License for more details.
6314 +*/
6315 +
6316 +#include "ipkg.h"
6317 +#include "ipkg_install.h"
6318 +#include "ipkg_message.h"
6319 +
6320 +int ipkg_upgrade_pkg(ipkg_conf_t *conf, pkg_t *old)
6321 +{
6322 +     pkg_t *new;
6323 +     int cmp;
6324 +     char *old_version, *new_version;
6325 +
6326 +     if (old->state_flag & SF_HOLD) {
6327 +          ipkg_message(conf, IPKG_NOTICE,
6328 +                       "Not upgrading package %s which is marked "
6329 +                       "hold (flags=%#x)\n", old->name, old->state_flag);
6330 +          return 0;
6331 +     }
6332 +
6333 +     new = pkg_hash_fetch_best_installation_candidate_by_name(conf, old->name);
6334 +     if (new == NULL) {
6335 +          old_version = pkg_version_str_alloc(old);
6336 +          ipkg_message(conf, IPKG_NOTICE,
6337 +                       "Assuming locally installed package %s (%s) "
6338 +                       "is up to date.\n", old->name, old_version);
6339 +          free(old_version);
6340 +          return 0;
6341 +     }
6342 +
6343 +     old_version = pkg_version_str_alloc(old);
6344 +     new_version = pkg_version_str_alloc(new);
6345 +
6346 +     cmp = pkg_compare_versions(old, new);
6347 +     ipkg_message(conf, IPKG_DEBUG,
6348 +                  "comparing visible versions of pkg %s:"
6349 +                  "\n\t%s is installed "
6350 +                  "\n\t%s is available "
6351 +                  "\n\t%d was comparison result\n",
6352 +                  old->name, old_version, new_version, cmp);
6353 +     if (cmp == 0) {
6354 +          ipkg_message(conf, IPKG_INFO,
6355 +                       "Package %s (%s) installed in %s is up to date.\n",
6356 +                       old->name, old_version, old->dest->name);
6357 +          free(old_version);
6358 +          free(new_version);
6359 +          return 0;
6360 +     } else if (cmp > 0) {
6361 +          ipkg_message(conf, IPKG_NOTICE,
6362 +                       "Not downgrading package %s on %s from %s to %s.\n",
6363 +                       old->name, old->dest->name, old_version, new_version);
6364 +          free(old_version);
6365 +          free(new_version);
6366 +          return 0;
6367 +     } else if (cmp < 0) {
6368 +          new->dest = old->dest;
6369 +          old->state_want = SW_DEINSTALL;
6370 +     }
6371 +
6372 +     new->state_flag |= SF_USER;
6373 +     return ipkg_install_pkg(conf, new,1);
6374 +}
6375 Index: busybox-1.7.2/archival/libipkg/ipkg_upgrade.h
6376 ===================================================================
6377 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
6378 +++ busybox-1.7.2/archival/libipkg/ipkg_upgrade.h       2007-10-04 17:14:22.877045111 +0200
6379 @@ -0,0 +1,18 @@
6380 +/* ipkg_upgrade.c - the itsy package management system
6381 +
6382 +   Copyright (C) 2003 Daniele Nicolodi <daniele@grinta.net>
6383 +
6384 +   This program is free software; you can redistribute it and/or
6385 +   modify it under the terms of the GNU General Public License as
6386 +   published by the Free Software Foundation; either version 2, or (at
6387 +   your option) any later version.
6388 +
6389 +   This program is distributed in the hope that it will be useful, but
6390 +   WITHOUT ANY WARRANTY; without even the implied warranty of
6391 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
6392 +   General Public License for more details.
6393 +*/
6394 +
6395 +#include "ipkg.h"
6396 +
6397 +int ipkg_upgrade_pkg(ipkg_conf_t *conf, pkg_t *old);
6398 Index: busybox-1.7.2/archival/libipkg/ipkg_utils.c
6399 ===================================================================
6400 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
6401 +++ busybox-1.7.2/archival/libipkg/ipkg_utils.c 2007-10-04 17:14:22.897046251 +0200
6402 @@ -0,0 +1,181 @@
6403 +/* ipkg_utils.c - the itsy package management system
6404 +
6405 +   Steven M. Ayer
6406 +
6407 +   Copyright (C) 2002 Compaq Computer Corporation
6408 +
6409 +   This program is free software; you can redistribute it and/or
6410 +   modify it under the terms of the GNU General Public License as
6411 +   published by the Free Software Foundation; either version 2, or (at
6412 +   your option) any later version.
6413 +
6414 +   This program is distributed in the hope that it will be useful, but
6415 +   WITHOUT ANY WARRANTY; without even the implied warranty of
6416 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
6417 +   General Public License for more details.
6418 +*/
6419 +
6420 +#include "ipkg.h"
6421 +#include <errno.h>
6422 +#include <ctype.h>
6423 +#include <sys/vfs.h>
6424 +
6425 +#include "ipkg_utils.h"
6426 +#include "pkg.h"
6427 +#include "pkg_hash.h"
6428 +
6429 +struct errlist* error_list;
6430 +
6431 +int get_available_blocks(char * filesystem)
6432 +{
6433 +     struct statfs sfs;
6434 +
6435 +     if(statfs(filesystem, &sfs)){
6436 +         fprintf(stderr, "bad statfs\n");
6437 +         return 0;
6438 +     }
6439 +     /*    fprintf(stderr, "reported fs type %x\n", sfs.f_type); */
6440 +     return ((sfs.f_bavail * sfs.f_bsize) / 1024);
6441 +}
6442 +
6443 +char **read_raw_pkgs_from_file(const char *file_name)
6444 +{
6445 +     FILE *fp;
6446 +     char **ret;
6447 +
6448 +     if(!(fp = fopen(file_name, "r"))){
6449 +         fprintf(stderr, "can't get %s open for read\n", file_name);
6450 +         return NULL;
6451 +     }
6452 +
6453 +     ret = read_raw_pkgs_from_stream(fp);
6454 +
6455 +     fclose(fp);
6456 +
6457 +     return ret;
6458 +}
6459 +
6460 +char **read_raw_pkgs_from_stream(FILE *fp)
6461 +{
6462 +     char **raw = NULL, *buf, *scout;
6463 +     int count = 0;
6464 +     size_t size = 512;
6465 +
6466 +     buf = malloc (size);
6467 +
6468 +     while (fgets(buf, size, fp)) {
6469 +         while (strlen (buf) == (size - 1)
6470 +                && buf[size-2] != '\n') {
6471 +              size_t o = size - 1;
6472 +              size *= 2;
6473 +              buf = realloc (buf, size);
6474 +              if (fgets (buf + o, size - o, fp) == NULL)
6475 +                   break;
6476 +         }
6477 +
6478 +         if(!(count % 50))
6479 +              raw = realloc(raw, (count + 50) * sizeof(char *));
6480 +
6481 +         if((scout = strchr(buf, '\n')))
6482 +              *scout = '\0';
6483 +
6484 +         raw[count++] = strdup(buf);
6485 +     }
6486 +
6487 +     raw = realloc(raw, (count + 1) * sizeof(char *));
6488 +     raw[count] = NULL;
6489 +
6490 +     free (buf);
6491 +
6492 +     return raw;
6493 +}
6494 +
6495 +/* something to remove whitespace, a hash pooper */
6496 +char *trim_alloc(char *line)
6497 +{
6498 +     char *new;
6499 +     char *dest, *src, *end;
6500 +
6501 +     new = malloc(strlen(line) + 1);
6502 +     if ( new == NULL ){
6503 +        fprintf(stderr,"%s: Unable to allocate memory\n",__FUNCTION__);
6504 +        return NULL;
6505 +     }
6506 +     dest = new, src = line, end = line + (strlen(line) - 1);
6507 +
6508 +     /* remove it from the front */
6509 +     while(src &&
6510 +          isspace(*src) &&
6511 +          *src)
6512 +         src++;
6513 +     /* and now from the back */
6514 +     while((end > src) &&
6515 +          isspace(*end))
6516 +         end--;
6517 +     end++;
6518 +     *end = '\0';
6519 +     strcpy(new, src);
6520 +     /* this does from the first space
6521 +      *  blasting away any versions stuff in depends
6522 +      while(src &&
6523 +      !isspace(*src) &&
6524 +      *src)
6525 +      *dest++ = *src++;
6526 +      *dest = '\0';
6527 +      */
6528 +
6529 +     return new;
6530 +}
6531 +
6532 +int line_is_blank(const char *line)
6533 +{
6534 +     const char *s;
6535 +
6536 +     for (s = line; *s; s++) {
6537 +         if (!isspace(*s))
6538 +              return 0;
6539 +     }
6540 +     return 1;
6541 +}
6542 +
6543 +void push_error_list(struct errlist ** errors, char * msg){
6544 +  struct errlist *err_lst_tmp;
6545 +
6546 +
6547 +  err_lst_tmp = malloc ( sizeof (err_lst_tmp) );
6548 +  err_lst_tmp->errmsg=strdup(msg) ;
6549 +  err_lst_tmp->next = *errors;
6550 +  *errors = err_lst_tmp;
6551 +}
6552 +
6553 +
6554 +void reverse_error_list(struct errlist **errors){
6555 +   struct errlist *result=NULL;
6556 +   struct errlist *current= *errors;
6557 +   struct errlist *next;
6558 +
6559 +   while ( current != NULL ) {
6560 +      next = current->next;
6561 +      current->next=result;
6562 +      result=current;
6563 +      current=next;
6564 +   }
6565 +   *errors=result;
6566 +
6567 +}
6568 +
6569 +
6570 +void free_error_list(struct errlist **errors){
6571 +  struct errlist *current = *errors;
6572 +
6573 +    while (current != NULL) {
6574 +      free(current->errmsg);
6575 +      current = (*errors)->next;
6576 +      free(*errors);
6577 +      *errors = current;
6578 +    }
6579 +
6580 +
6581 +}
6582 +
6583 +
6584 Index: busybox-1.7.2/archival/libipkg/ipkg_utils.h
6585 ===================================================================
6586 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
6587 +++ busybox-1.7.2/archival/libipkg/ipkg_utils.h 2007-10-04 17:14:22.921047615 +0200
6588 @@ -0,0 +1,29 @@
6589 +/* ipkg_utils.h - the itsy package management system
6590 +
6591 +   Steven M. Ayer
6592 +
6593 +   Copyright (C) 2002 Compaq Computer Corporation
6594 +
6595 +   This program is free software; you can redistribute it and/or
6596 +   modify it under the terms of the GNU General Public License as
6597 +   published by the Free Software Foundation; either version 2, or (at
6598 +   your option) any later version.
6599 +
6600 +   This program is distributed in the hope that it will be useful, but
6601 +   WITHOUT ANY WARRANTY; without even the implied warranty of
6602 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
6603 +   General Public License for more details.
6604 +*/
6605 +
6606 +#ifndef IPKG_UTILS_H
6607 +#define IPKG_UTILS_H
6608 +
6609 +#include "pkg.h"
6610 +
6611 +int get_available_blocks(char * filesystem);
6612 +char **read_raw_pkgs_from_file(const char *file_name);
6613 +char **read_raw_pkgs_from_stream(FILE *fp);
6614 +char *trim_alloc(char * line);
6615 +int line_is_blank(const char *line);
6616 +
6617 +#endif
6618 Index: busybox-1.7.2/archival/libipkg/Kbuild
6619 ===================================================================
6620 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
6621 +++ busybox-1.7.2/archival/libipkg/Kbuild       2007-10-04 17:14:22.937048531 +0200
6622 @@ -0,0 +1,60 @@
6623 +# Makefile for busybox
6624 +#
6625 +# Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
6626 +# Copyright (C) 2006 OpenWrt.org
6627 +#
6628 +# Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
6629 +
6630 +LIBIPKG_CORE_OBJS:= \
6631 +       args.o \
6632 +       libipkg.o \
6633 +       user.o \
6634 +
6635 +LIBIPKG_CMD_OBJS:= \
6636 +       ipkg_cmd.o \
6637 +       ipkg_configure.o \
6638 +       ipkg_download.o \
6639 +       ipkg_install.o \
6640 +       ipkg_remove.o \
6641 +       ipkg_upgrade.o \
6642 +
6643 +LIBIPKG_DB_OBJS:= \
6644 +       hash_table.o \
6645 +       ipkg_conf.o \
6646 +       ipkg_utils.o \
6647 +       pkg.o \
6648 +       pkg_depends.o \
6649 +       pkg_extract.o \
6650 +       pkg_hash.o \
6651 +       pkg_parse.o \
6652 +       pkg_vec.o \
6653 +
6654 +LIBIPKG_LIST_OBJS:= \
6655 +       conffile.o \
6656 +       conffile_list.o \
6657 +       nv_pair.o \
6658 +       nv_pair_list.o \
6659 +       pkg_dest.o \
6660 +       pkg_dest_list.o \
6661 +       pkg_src.o \
6662 +       pkg_src_list.o \
6663 +       str_list.o \
6664 +       void_list.o \
6665 +
6666 +LIBIPKG_UTIL_OBJS:= \
6667 +       file_util.o \
6668 +       ipkg_message.o \
6669 +       str_util.o \
6670 +       xsystem.o \
6671 +
6672 +lib-y :=
6673 +lib-$(CONFIG_IPKG) += $(LIBIPKG_CORE_OBJS)
6674 +lib-$(CONFIG_IPKG) += $(LIBIPKG_CMD_OBJS)
6675 +lib-$(CONFIG_IPKG) += $(LIBIPKG_DB_OBJS)
6676 +lib-$(CONFIG_IPKG) += $(LIBIPKG_LIST_OBJS)
6677 +lib-$(CONFIG_IPKG) += $(LIBIPKG_UTIL_OBJS)
6678 +
6679 +ifeq ($(strip $(IPKG_ARCH)),)
6680 +IPKG_ARCH:=$(TARGET_ARCH)
6681 +endif
6682 +CFLAGS += -DIPKG_LIB -DIPKGLIBDIR="\"/usr/lib\"" -DHOST_CPU_STR="\"$(IPKG_ARCH)\""
6683 Index: busybox-1.7.2/archival/libipkg/libipkg.c
6684 ===================================================================
6685 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
6686 +++ busybox-1.7.2/archival/libipkg/libipkg.c    2007-10-04 17:14:22.949049213 +0200
6687 @@ -0,0 +1,527 @@
6688 +/* ipkglib.c - the itsy package management system
6689 +
6690 +   Florina Boor
6691 +
6692 +   Copyright (C) 2003 kernel concepts
6693 +
6694 +   This program is free software; you can redistribute it and/or
6695 +   modify it under the terms of the GNU General Public License as
6696 +   published by the Free Software Foundation; either version 2, or (at
6697 +   your option) any later version.
6698 +
6699 +   This program is distributed in the hope that it will be useful, but
6700 +   WITHOUT ANY WARRANTY; without even the implied warranty of
6701 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
6702 +   General Public License for more details.
6703 +*/
6704 +
6705 +#ifdef IPKG_LIB
6706 +
6707 +#include "ipkg.h"
6708 +#include "ipkg_includes.h"
6709 +#include "libipkg.h"
6710 +
6711 +#include "args.h"
6712 +#include "ipkg_conf.h"
6713 +#include "ipkg_cmd.h"
6714 +#include "file_util.h"
6715 +
6716 +
6717 +
6718 +ipkg_message_callback ipkg_cb_message = NULL;
6719 +ipkg_response_callback ipkg_cb_response = NULL;
6720 +ipkg_status_callback ipkg_cb_status = NULL;
6721 +ipkg_list_callback ipkg_cb_list = NULL;
6722 +
6723 +
6724 +int
6725 +ipkg_init (ipkg_message_callback mcall,
6726 +           ipkg_response_callback rcall,
6727 +           args_t * args)
6728 +{
6729 +       ipkg_cb_message = mcall;
6730 +       ipkg_cb_response = rcall;
6731 +
6732 +       args_init (args);
6733 +
6734 +       return 0;
6735 +}
6736 +
6737 +
6738 +int
6739 +ipkg_deinit (args_t * args)
6740 +{
6741 +       args_deinit (args);
6742 +       ipkg_cb_message = NULL;
6743 +       ipkg_cb_response = NULL;
6744 +
6745 +       /* place other cleanup stuff here */
6746 +
6747 +       return 0;
6748 +}
6749 +
6750 +
6751 +int
6752 +ipkg_packages_list(args_t *args,
6753 +                   const char *packages,
6754 +                   ipkg_list_callback cblist,
6755 +                   void *userdata)
6756 +{
6757 +       ipkg_cmd_t *cmd;
6758 +       ipkg_conf_t ipkg_conf;
6759 +       int err;
6760 +
6761 +       err = ipkg_conf_init (&ipkg_conf, args);
6762 +       if (err)
6763 +       {
6764 +               return err;
6765 +       }
6766 +
6767 +       ipkg_cb_list = cblist;
6768 +       /* we need to do this because of static declarations,
6769 +        * maybe a good idea to change */
6770 +       cmd = ipkg_cmd_find ("list");
6771 +       if (packages)
6772 +               err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &packages, userdata);
6773 +       else
6774 +               err = ipkg_cmd_exec (cmd, &ipkg_conf, 0, NULL, userdata);
6775 +       ipkg_cb_list = NULL;
6776 +       ipkg_conf_deinit (&ipkg_conf);
6777 +       return (err);
6778 +}
6779 +
6780 +
6781 +int
6782 +ipkg_packages_status(args_t *args,
6783 +                     const char *packages,
6784 +                     ipkg_status_callback cbstatus,
6785 +                     void *userdata)
6786 +{
6787 +       ipkg_cmd_t *cmd;
6788 +       ipkg_conf_t ipkg_conf;
6789 +       int err;
6790 +
6791 +       err = ipkg_conf_init (&ipkg_conf, args);
6792 +       if (err)
6793 +       {
6794 +               return err;
6795 +       }
6796 +
6797 +       ipkg_cb_status = cbstatus;
6798 +
6799 +       /* we need to do this because of static declarations,
6800 +        * maybe a good idea to change */
6801 +       cmd = ipkg_cmd_find ("status");
6802 +       if (packages)
6803 +               err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &packages, userdata);
6804 +       else
6805 +               err = ipkg_cmd_exec (cmd, &ipkg_conf, 0, NULL, userdata);
6806 +
6807 +       ipkg_cb_status = NULL;
6808 +       ipkg_conf_deinit (&ipkg_conf);
6809 +       return (err);
6810 +}
6811 +
6812 +
6813 +int
6814 +ipkg_packages_info(args_t *args,
6815 +                   const char *packages,
6816 +                   ipkg_status_callback cbstatus,
6817 +                   void *userdata)
6818 +{
6819 +       ipkg_cmd_t *cmd;
6820 +       ipkg_conf_t ipkg_conf;
6821 +       int err;
6822 +
6823 +       err = ipkg_conf_init (&ipkg_conf, args);
6824 +       if (err)
6825 +       {
6826 +               return err;
6827 +       }
6828 +
6829 +       ipkg_cb_status = cbstatus;
6830 +
6831 +       /* we need to do this because of static declarations,
6832 +        * maybe a good idea to change */
6833 +       cmd = ipkg_cmd_find ("info");
6834 +       if (packages)
6835 +               err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &packages, userdata);
6836 +       else
6837 +               err = ipkg_cmd_exec (cmd, &ipkg_conf, 0, NULL, userdata);
6838 +
6839 +       ipkg_cb_status = NULL;
6840 +       ipkg_conf_deinit (&ipkg_conf);
6841 +       return (err);
6842 +}
6843 +
6844 +
6845 +int
6846 +ipkg_packages_install (args_t * args, const char *name)
6847 +{
6848 +       ipkg_cmd_t *cmd;
6849 +       ipkg_conf_t ipkg_conf;
6850 +       int err;
6851 +
6852 +       /* this error should be handled in application */
6853 +       if (!name || !strlen (name))
6854 +               return (-1);
6855 +
6856 +       err = ipkg_conf_init (&ipkg_conf, args);
6857 +       if (err)
6858 +       {
6859 +               return err;
6860 +       }
6861 +
6862 +       /* we need to do this because of static declarations,
6863 +        * maybe a good idea to change */
6864 +       cmd = ipkg_cmd_find ("install");
6865 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &name, NULL);
6866 +
6867 +       ipkg_conf_deinit(&ipkg_conf);
6868 +       return (err);
6869 +}
6870 +
6871 +
6872 +int
6873 +ipkg_packages_remove(args_t *args, const char *name, int purge)
6874 +{
6875 +       ipkg_cmd_t *cmd;
6876 +       ipkg_conf_t ipkg_conf;
6877 +       int err;
6878 +
6879 +       /* this error should be handled in application */
6880 +       if (!name || !strlen (name))
6881 +               return (-1);
6882 +
6883 +       err = ipkg_conf_init (&ipkg_conf, args);
6884 +       if (err)
6885 +       {
6886 +               return err;
6887 +       }
6888 +
6889 +       /* we need to do this because of static declarations,
6890 +        * maybe a good idea to change */
6891 +       if (purge)
6892 +               cmd = ipkg_cmd_find ("purge");
6893 +       else
6894 +               cmd = ipkg_cmd_find ("remove");
6895 +
6896 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &name, NULL);
6897 +
6898 +       ipkg_conf_deinit(&ipkg_conf);
6899 +       return (err);
6900 +}
6901 +
6902 +
6903 +int
6904 +ipkg_lists_update(args_t *args)
6905 +{
6906 +       ipkg_cmd_t *cmd;
6907 +       ipkg_conf_t ipkg_conf;
6908 +       int err;
6909 +
6910 +       err = ipkg_conf_init (&ipkg_conf, args);
6911 +       if (err)
6912 +       {
6913 +               return err;
6914 +       }
6915 +
6916 +       /* we need to do this because of static declarations,
6917 +        * maybe a good idea to change */
6918 +       cmd = ipkg_cmd_find ("update");
6919 +
6920 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 0, NULL, NULL);
6921 +
6922 +       ipkg_conf_deinit(&ipkg_conf);
6923 +       return (err);
6924 +}
6925 +
6926 +
6927 +int
6928 +ipkg_packages_upgrade(args_t *args)
6929 +{
6930 +       ipkg_cmd_t *cmd;
6931 +       ipkg_conf_t ipkg_conf;
6932 +       int err;
6933 +
6934 +       err = ipkg_conf_init (&ipkg_conf, args);
6935 +       if (err)
6936 +       {
6937 +               return err;
6938 +       }
6939 +
6940 +       /* we need to do this because of static declarations,
6941 +        * maybe a good idea to change */
6942 +       cmd = ipkg_cmd_find ("upgrade");
6943 +
6944 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 0, NULL, NULL);
6945 +
6946 +       ipkg_conf_deinit(&ipkg_conf);
6947 +       return (err);
6948 +}
6949 +
6950 +
6951 +int
6952 +ipkg_packages_download (args_t * args, const char *name)
6953 +{
6954 +       ipkg_cmd_t *cmd;
6955 +       ipkg_conf_t ipkg_conf;
6956 +       int err;
6957 +
6958 +       /* this error should be handled in application */
6959 +       if (!name || !strlen (name))
6960 +               return (-1);
6961 +
6962 +       err = ipkg_conf_init (&ipkg_conf, args);
6963 +       if (err)
6964 +       {
6965 +               return err;
6966 +       }
6967 +
6968 +       /* we need to do this because of static declarations,
6969 +        * maybe a good idea to change */
6970 +       cmd = ipkg_cmd_find ("download");
6971 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &name, NULL);
6972 +
6973 +       ipkg_conf_deinit(&ipkg_conf);
6974 +       return (err);
6975 +}
6976 +
6977 +
6978 +int
6979 +ipkg_package_files(args_t *args,
6980 +                   const char *name,
6981 +                   ipkg_list_callback cblist,
6982 +                   void *userdata)
6983 +{
6984 +       ipkg_cmd_t *cmd;
6985 +       ipkg_conf_t ipkg_conf;
6986 +       int err;
6987 +
6988 +       /* this error should be handled in application */
6989 +       if (!name || !strlen (name))
6990 +               return (-1);
6991 +
6992 +       err = ipkg_conf_init (&ipkg_conf, args);
6993 +       if (err)
6994 +       {
6995 +               return err;
6996 +       }
6997 +
6998 +       ipkg_cb_list = cblist;
6999 +
7000 +       /* we need to do this because of static declarations,
7001 +        * maybe a good idea to change */
7002 +       cmd = ipkg_cmd_find ("files");
7003 +
7004 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &name, userdata);
7005 +
7006 +       ipkg_cb_list = NULL;
7007 +       ipkg_conf_deinit(&ipkg_conf);
7008 +       return (err);
7009 +}
7010 +
7011 +
7012 +int
7013 +ipkg_file_search(args_t *args,
7014 +                const char *file,
7015 +                               ipkg_list_callback cblist,
7016 +                void *userdata)
7017 +{
7018 +       ipkg_cmd_t *cmd;
7019 +       ipkg_conf_t ipkg_conf;
7020 +       int err;
7021 +
7022 +       /* this error should be handled in application */
7023 +       if (!file || !strlen (file))
7024 +               return (-1);
7025 +
7026 +       err = ipkg_conf_init (&ipkg_conf, args);
7027 +       if (err)
7028 +       {
7029 +               return err;
7030 +       }
7031 +
7032 +       ipkg_cb_list = cblist;
7033 +
7034 +       /* we need to do this because of static declarations,
7035 +        * maybe a good idea to change */
7036 +       cmd = ipkg_cmd_find ("search");
7037 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &file, userdata);
7038 +
7039 +       ipkg_cb_list = NULL;
7040 +       ipkg_conf_deinit(&ipkg_conf);
7041 +       return(err);
7042 +}
7043 +
7044 +
7045 +int
7046 +ipkg_file_what(args_t *args, const char *file, const char* command)
7047 +{
7048 +       ipkg_cmd_t *cmd;
7049 +       ipkg_conf_t ipkg_conf;
7050 +       int err;
7051 +
7052 +       /* this error should be handled in application */
7053 +       if (!file || !strlen (file))
7054 +               return (-1);
7055 +
7056 +       err = ipkg_conf_init (&ipkg_conf, args);
7057 +       if (err)
7058 +       {
7059 +               return err;
7060 +       }
7061 +
7062 +       /* we need to do this because of static declarations,
7063 +        * maybe a good idea to change */
7064 +       cmd = ipkg_cmd_find (command);
7065 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, 1, &file, NULL);
7066 +
7067 +       ipkg_conf_deinit(&ipkg_conf);
7068 +       return(err);
7069 +}
7070 +
7071 +#define ipkg_package_whatdepends(args,file) ipkg_file_what(args,file,"whatdepends")
7072 +#define ipkg_package_whatrecommends(args, file) ipkg_file_what(args,file,"whatrecommends")
7073 +#define ipkg_package_whatprovides(args, file) ipkg_file_what(args,file,"whatprovides")
7074 +#define ipkg_package_whatconflicts(args, file) ipkg_file_what(args,file,"whatconflicts")
7075 +#define ipkg_package_whatreplaces(args, file) ipkg_file_what(args,file,"whatreplaces")
7076 +
7077 +
7078 +int default_ipkg_message_callback(ipkg_conf_t *conf, message_level_t level,
7079 +                                 char *msg)
7080 +{
7081 +     if (conf && (conf->verbosity < level)) {
7082 +         return 0;
7083 +     } else {
7084 +#ifdef IPKG_LIB
7085 +          if ( level == IPKG_ERROR ){
7086 +             push_error_list(&error_list, msg);
7087 +//          printf(msg);
7088 +          } else
7089 +#endif
7090 +            printf(msg);
7091 +     }
7092 +     return 0;
7093 +}
7094 +
7095 +int default_ipkg_list_callback(char *name, char *desc, char *version,
7096 +                              pkg_state_status_t status, void *userdata)
7097 +{
7098 +     if (desc)
7099 +         printf("%s - %s - %s\n", name, version, desc);
7100 +     else
7101 +         printf("%s - %s\n", name, version);
7102 +     return 0;
7103 +}
7104 +
7105 +int default_ipkg_files_callback(char *name, char *desc, char *version,
7106 +                   pkg_state_status_t status, void *userdata)
7107 +{
7108 +     if (desc)
7109 +         printf("%s\n", desc);
7110 +     return 0;
7111 +}
7112 +
7113 +int default_ipkg_status_callback(char *name, int istatus, char *desc,
7114 +                                void *userdata)
7115 +{
7116 +     printf("%s\n", desc);
7117 +     return 0;
7118 +}
7119 +
7120 +char* default_ipkg_response_callback(char *question)
7121 +{
7122 +     char *response = NULL;
7123 +     printf(question);
7124 +     fflush(stdout);
7125 +     do {
7126 +         response = (char *)file_read_line_alloc(stdin);
7127 +     } while (response == NULL);
7128 +     return response;
7129 +}
7130 +
7131 +/* This is used for backward compatibility */
7132 +int
7133 +ipkg_op (int argc, char *argv[])
7134 +{
7135 +       int err, opt_index;
7136 +       args_t args;
7137 +       char *cmd_name;
7138 +       ipkg_cmd_t *cmd;
7139 +       ipkg_conf_t ipkg_conf;
7140 +
7141 +       args_init (&args);
7142 +
7143 +       opt_index = args_parse (&args, argc, argv);
7144 +       if (opt_index == argc || opt_index < 0)
7145 +       {
7146 +               args_usage ("ipkg must have one sub-command argument");
7147 +       }
7148 +
7149 +       cmd_name = argv[opt_index++];
7150 +/* Pigi: added a flag to disable the checking of structures if the command does not need to
7151 +         read anything from there.
7152 +*/
7153 +        if ( !strcmp(cmd_name,"print-architecture") ||
7154 +             !strcmp(cmd_name,"print_architecture") ||
7155 +             !strcmp(cmd_name,"print-installation-architecture") ||
7156 +             !strcmp(cmd_name,"print_installation_architecture") )
7157 +           args.nocheckfordirorfile = 1;
7158 +
7159 +/* Pigi: added a flag to disable the reading of feed files  if the command does not need to
7160 +         read anything from there.
7161 +*/
7162 +        if ( !strcmp(cmd_name,"flag") ||
7163 +             !strcmp(cmd_name,"configure") ||
7164 +             !strcmp(cmd_name,"remove") ||
7165 +             !strcmp(cmd_name,"files") ||
7166 +             !strcmp(cmd_name,"search") ||
7167 +             !strcmp(cmd_name,"compare_versions") ||
7168 +             !strcmp(cmd_name,"compare-versions") ||
7169 +             !strcmp(cmd_name,"list_installed") ||
7170 +             !strcmp(cmd_name,"list-installed") ||
7171 +             !strcmp(cmd_name,"status") )
7172 +           args.noreadfeedsfile = 1;
7173 +
7174 +
7175 +       err = ipkg_conf_init (&ipkg_conf, &args);
7176 +       if (err)
7177 +       {
7178 +               return err;
7179 +       }
7180 +
7181 +       args_deinit (&args);
7182 +
7183 +       ipkg_cb_message = default_ipkg_message_callback;
7184 +       ipkg_cb_response = default_ipkg_response_callback;
7185 +       ipkg_cb_status = default_ipkg_status_callback;
7186 +       if ( strcmp(cmd_name, "files")==0)
7187 +            ipkg_cb_list = default_ipkg_files_callback;
7188 +       else
7189 +            ipkg_cb_list = default_ipkg_list_callback;
7190 +
7191 +       cmd = ipkg_cmd_find (cmd_name);
7192 +       if (cmd == NULL)
7193 +       {
7194 +               fprintf (stderr, "%s: unknown sub-command %s\n", argv[0],
7195 +                        cmd_name);
7196 +               args_usage (NULL);
7197 +       }
7198 +
7199 +       if (cmd->requires_args && opt_index == argc)
7200 +       {
7201 +               fprintf (stderr,
7202 +                        "%s: the ``%s'' command requires at least one argument\n",
7203 +                        __FUNCTION__, cmd_name);
7204 +               args_usage (NULL);
7205 +       }
7206 +
7207 +       err = ipkg_cmd_exec (cmd, &ipkg_conf, argc - opt_index, (const char **) (argv + opt_index), NULL);
7208 +
7209 +       ipkg_conf_deinit (&ipkg_conf);
7210 +
7211 +       return err;
7212 +}
7213 +
7214 +#endif /* IPKG_LIB */
7215 Index: busybox-1.7.2/archival/libipkg/libipkg.h
7216 ===================================================================
7217 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
7218 +++ busybox-1.7.2/archival/libipkg/libipkg.h    2007-10-04 17:20:55.967446056 +0200
7219 @@ -0,0 +1,88 @@
7220 +/* ipkglib.h - the itsy package management system
7221 +
7222 +   Florian Boor <florian.boor@kernelconcepts.de>
7223 +
7224 +   This program is free software; you can redistribute it and/or
7225 +   modify it under the terms of the GNU General Public License as
7226 +   published by the Free Software Foundation; either version 2, or (at
7227 +   your option) any later version.
7228 +
7229 +   This program is distributed in the hope that it will be useful, but
7230 +   WITHOUT ANY WARRANTY; without even the implied warranty of
7231 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
7232 +   General Public License for more details.
7233 +*/
7234 +
7235 +#ifndef IPKGLIB_H
7236 +#define IPKGLIB_H
7237 +
7238 +#ifdef IPKG_LIB
7239 +
7240 +#include "ipkg_conf.h"
7241 +#include "ipkg_message.h"
7242 +
7243 +#include "libbb.h"
7244 +#include "args.h"
7245 +#include "pkg.h"
7246 +
7247 +typedef int (*ipkg_message_callback)(ipkg_conf_t *conf, message_level_t level,
7248 +       char *msg);
7249 +typedef int (*ipkg_list_callback)(char *name, char *desc, char *version,
7250 +       pkg_state_status_t status, void *userdata);
7251 +typedef int (*ipkg_status_callback)(char *name, int istatus, char *desc,
7252 +       void *userdata);
7253 +typedef char* (*ipkg_response_callback)(char *question);
7254 +
7255 +extern int ipkg_op(int argc, char *argv[]); /* ipkglib.c */
7256 +extern int ipkg_init (ipkg_message_callback mcall,
7257 +                      ipkg_response_callback rcall,
7258 +                                         args_t * args);
7259 +
7260 +extern int ipkg_deinit (args_t *args);
7261 +extern int ipkg_packages_list(args_t *args,
7262 +                              const char *packages,
7263 +                              ipkg_list_callback cblist,
7264 +                              void *userdata);
7265 +extern int ipkg_packages_status(args_t *args,
7266 +                                const char *packages,
7267 +                                ipkg_status_callback cbstatus,
7268 +                                                               void *userdata);
7269 +extern int ipkg_packages_info(args_t *args,
7270 +                              const char *packages,
7271 +                              ipkg_status_callback cbstatus,
7272 +                              void *userdata);
7273 +extern int ipkg_packages_install(args_t *args, const char *name);
7274 +extern int ipkg_packages_remove(args_t *args, const char *name, int purge);
7275 +extern int ipkg_lists_update(args_t *args);
7276 +extern int ipkg_packages_upgrade(args_t *args);
7277 +extern int ipkg_packages_download(args_t *args, const char *name);
7278 +extern int ipkg_package_files(args_t *args,
7279 +                              const char *name,
7280 +                                                         ipkg_list_callback cblist,
7281 +                                                         void *userdata);
7282 +extern int ipkg_file_search(args_t *args,
7283 +                            const char *file,
7284 +                                                       ipkg_list_callback cblist,
7285 +                                                       void *userdata);
7286 +extern int ipkg_package_whatdepends(args_t *args, const char *file);
7287 +extern int ipkg_package_whatrecommends(args_t *args, const char *file);
7288 +extern int ipkg_package_whatprovides(args_t *args, const char *file);
7289 +extern int ipkg_package_whatconflicts(args_t *args, const char *file);
7290 +extern int ipkg_package_whatreplaces(args_t *args, const char *file);
7291 +
7292 +extern ipkg_message_callback ipkg_cb_message; /* ipkglib.c */
7293 +extern ipkg_response_callback ipkg_cb_response;
7294 +extern ipkg_status_callback ipkg_cb_status;
7295 +extern ipkg_list_callback ipkg_cb_list;
7296 +extern void push_error_list(struct errlist **errors,char * msg);
7297 +extern void reverse_error_list(struct errlist **errors);
7298 +extern void free_error_list(struct errlist **errors);
7299 +
7300 +#else
7301 +
7302 +extern int ipkg_op(int argc, char *argv[]);
7303 +
7304 +#endif
7305 +
7306 +
7307 +#endif
7308 Index: busybox-1.7.2/archival/libipkg/nv_pair.c
7309 ===================================================================
7310 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
7311 +++ busybox-1.7.2/archival/libipkg/nv_pair.c    2007-10-04 17:14:22.989051492 +0200
7312 @@ -0,0 +1,40 @@
7313 +/* nv_pair.c - the itsy package management system
7314 +
7315 +   Carl D. Worth
7316 +
7317 +   Copyright (C) 2001 University of Southern California
7318 +
7319 +   This program is free software; you can redistribute it and/or
7320 +   modify it under the terms of the GNU General Public License as
7321 +   published by the Free Software Foundation; either version 2, or (at
7322 +   your option) any later version.
7323 +
7324 +   This program is distributed in the hope that it will be useful, but
7325 +   WITHOUT ANY WARRANTY; without even the implied warranty of
7326 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
7327 +   General Public License for more details.
7328 +*/
7329 +
7330 +#include "ipkg.h"
7331 +
7332 +#include "nv_pair.h"
7333 +#include "str_util.h"
7334 +
7335 +int nv_pair_init(nv_pair_t *nv_pair, const char *name, const char *value)
7336 +{
7337 +    nv_pair->name = str_dup_safe(name);
7338 +    nv_pair->value = str_dup_safe(value);
7339 +
7340 +    return 0;
7341 +}
7342 +
7343 +void nv_pair_deinit(nv_pair_t *nv_pair)
7344 +{
7345 +    free(nv_pair->name);
7346 +    nv_pair->name = NULL;
7347 +
7348 +    free(nv_pair->value);
7349 +    nv_pair->value = NULL;
7350 +}
7351 +
7352 +
7353 Index: busybox-1.7.2/archival/libipkg/nv_pair.h
7354 ===================================================================
7355 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
7356 +++ busybox-1.7.2/archival/libipkg/nv_pair.h    2007-10-04 17:14:23.037054223 +0200
7357 @@ -0,0 +1,32 @@
7358 +/* nv_pair.h - the itsy package management system
7359 +
7360 +   Carl D. Worth
7361 +
7362 +   Copyright (C) 2001 University of Southern California
7363 +
7364 +   This program is free software; you can redistribute it and/or
7365 +   modify it under the terms of the GNU General Public License as
7366 +   published by the Free Software Foundation; either version 2, or (at
7367 +   your option) any later version.
7368 +
7369 +   This program is distributed in the hope that it will be useful, but
7370 +   WITHOUT ANY WARRANTY; without even the implied warranty of
7371 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
7372 +   General Public License for more details.
7373 +*/
7374 +
7375 +#ifndef NV_PAIR_H
7376 +#define NV_PAIR_H
7377 +
7378 +typedef struct nv_pair nv_pair_t;
7379 +struct nv_pair
7380 +{
7381 +    char *name;
7382 +    char *value;
7383 +};
7384 +
7385 +int nv_pair_init(nv_pair_t *nv_pair, const char *name, const char *value);
7386 +void nv_pair_deinit(nv_pair_t *nv_pair);
7387 +
7388 +#endif
7389 +
7390 Index: busybox-1.7.2/archival/libipkg/nv_pair_list.c
7391 ===================================================================
7392 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
7393 +++ busybox-1.7.2/archival/libipkg/nv_pair_list.c       2007-10-04 17:14:23.053055147 +0200
7394 @@ -0,0 +1,98 @@
7395 +/* nv_pair_list.c - the itsy package management system
7396 +
7397 +   Carl D. Worth
7398 +
7399 +   Copyright (C) 2001 University of Southern California
7400 +
7401 +   This program is free software; you can redistribute it and/or
7402 +   modify it under the terms of the GNU General Public License as
7403 +   published by the Free Software Foundation; either version 2, or (at
7404 +   your option) any later version.
7405 +
7406 +   This program is distributed in the hope that it will be useful, but
7407 +   WITHOUT ANY WARRANTY; without even the implied warranty of
7408 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
7409 +   General Public License for more details.
7410 +*/
7411 +
7412 +#include "ipkg.h"
7413 +
7414 +#include "nv_pair.h"
7415 +#include "void_list.h"
7416 +#include "nv_pair_list.h"
7417 +
7418 +int nv_pair_list_elt_init(nv_pair_list_elt_t *elt, nv_pair_t *data)
7419 +{
7420 +    return void_list_elt_init((void_list_elt_t *) elt, data);
7421 +}
7422 +
7423 +void nv_pair_list_elt_deinit(nv_pair_list_elt_t *elt)
7424 +{
7425 +    void_list_elt_deinit((void_list_elt_t *) elt);
7426 +}
7427 +
7428 +int nv_pair_list_init(nv_pair_list_t *list)
7429 +{
7430 +    return void_list_init((void_list_t *) list);
7431 +}
7432 +
7433 +void nv_pair_list_deinit(nv_pair_list_t *list)
7434 +{
7435 +    nv_pair_list_elt_t *iter;
7436 +    nv_pair_t *nv_pair;
7437 +
7438 +    for (iter = list->head; iter; iter = iter->next) {
7439 +       nv_pair = iter->data;
7440 +       nv_pair_deinit(nv_pair);
7441 +
7442 +       /* malloced in nv_pair_list_append */
7443 +       free(nv_pair);
7444 +       iter->data = NULL;
7445 +    }
7446 +    void_list_deinit((void_list_t *) list);
7447 +}
7448 +
7449 +nv_pair_t *nv_pair_list_append(nv_pair_list_t *list, const char *name, const char *value)
7450 +{
7451 +    int err;
7452 +
7453 +    /* freed in nv_pair_list_deinit */
7454 +    nv_pair_t *nv_pair = malloc(sizeof(nv_pair_t));
7455 +
7456 +    if (nv_pair == NULL) {
7457 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
7458 +       return NULL;
7459 +    }
7460 +    nv_pair_init(nv_pair, name, value);
7461 +
7462 +    err = void_list_append((void_list_t *) list, nv_pair);
7463 +    if (err) {
7464 +       return NULL;
7465 +    }
7466 +
7467 +    return nv_pair;
7468 +}
7469 +
7470 +int nv_pair_list_push(nv_pair_list_t *list, nv_pair_t *data)
7471 +{
7472 +    return void_list_push((void_list_t *) list, data);
7473 +}
7474 +
7475 +nv_pair_list_elt_t *nv_pair_list_pop(nv_pair_list_t *list)
7476 +{
7477 +    return (nv_pair_list_elt_t *) void_list_pop((void_list_t *) list);
7478 +}
7479 +
7480 +char *nv_pair_list_find(nv_pair_list_t *list, char *name)
7481 +{
7482 +     nv_pair_list_elt_t *iter;
7483 +     nv_pair_t *nv_pair;
7484 +
7485 +     for (iter = list->head; iter; iter = iter->next) {
7486 +         nv_pair = iter->data;
7487 +         if (strcmp(nv_pair->name, name) == 0) {
7488 +              return nv_pair->value;
7489 +         }
7490 +     }
7491 +     return NULL;
7492 +}
7493 Index: busybox-1.7.2/archival/libipkg/nv_pair_list.h
7494 ===================================================================
7495 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
7496 +++ busybox-1.7.2/archival/libipkg/nv_pair_list.h       2007-10-04 17:14:23.073056281 +0200
7497 @@ -0,0 +1,60 @@
7498 +/* nv_pair_list.h - the itsy package management system
7499 +
7500 +   Carl D. Worth
7501 +
7502 +   Copyright (C) 2001 University of Southern California
7503 +
7504 +   This program is free software; you can redistribute it and/or
7505 +   modify it under the terms of the GNU General Public License as
7506 +   published by the Free Software Foundation; either version 2, or (at
7507 +   your option) any later version.
7508 +
7509 +   This program is distributed in the hope that it will be useful, but
7510 +   WITHOUT ANY WARRANTY; without even the implied warranty of
7511 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
7512 +   General Public License for more details.
7513 +*/
7514 +
7515 +#ifndef NV_PAIR_LIST_H
7516 +#define NV_PAIR_LIST_H
7517 +
7518 +#include "nv_pair.h"
7519 +#include "void_list.h"
7520 +
7521 +typedef struct nv_pair_list_elt nv_pair_list_elt_t;
7522 +struct nv_pair_list_elt
7523 +{
7524 +    nv_pair_list_elt_t *next;
7525 +    nv_pair_t *data;
7526 +};
7527 +
7528 +typedef struct nv_pair_list nv_pair_list_t;
7529 +struct nv_pair_list
7530 +{
7531 +    nv_pair_list_elt_t pre_head;
7532 +    nv_pair_list_elt_t *head;
7533 +    nv_pair_list_elt_t *tail;
7534 +};
7535 +
7536 +static inline int nv_pair_list_empty(nv_pair_list_t *list)
7537 +{
7538 +     if (list->head == NULL)
7539 +         return 1;
7540 +     else
7541 +         return 0;
7542 +}
7543 +
7544 +int nv_pair_list_elt_init(nv_pair_list_elt_t *elt, nv_pair_t *data);
7545 +void nv_pair_list_elt_deinit(nv_pair_list_elt_t *elt);
7546 +
7547 +int nv_pair_list_init(nv_pair_list_t *list);
7548 +void nv_pair_list_deinit(nv_pair_list_t *list);
7549 +
7550 +nv_pair_t *nv_pair_list_append(nv_pair_list_t *list,
7551 +                              const char *name, const char *value);
7552 +int nv_pair_list_push(nv_pair_list_t *list, nv_pair_t *data);
7553 +nv_pair_list_elt_t *nv_pair_list_pop(nv_pair_list_t *list);
7554 +char *nv_pair_list_find(nv_pair_list_t *list, char *name);
7555 +
7556 +#endif
7557 +
7558 Index: busybox-1.7.2/archival/libipkg/pkg.c
7559 ===================================================================
7560 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
7561 +++ busybox-1.7.2/archival/libipkg/pkg.c        2007-10-04 17:14:23.093057411 +0200
7562 @@ -0,0 +1,1747 @@
7563 +/* pkg.c - the itsy package management system
7564 +
7565 +   Carl D. Worth
7566 +
7567 +   Copyright (C) 2001 University of Southern California
7568 +
7569 +   This program is free software; you can redistribute it and/or
7570 +   modify it under the terms of the GNU General Public License as
7571 +   published by the Free Software Foundation; either version 2, or (at
7572 +   your option) any later version.
7573 +
7574 +   This program is distributed in the hope that it will be useful, but
7575 +   WITHOUT ANY WARRANTY; without even the implied warranty of
7576 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
7577 +   General Public License for more details.
7578 +*/
7579 +
7580 +#include "ipkg.h"
7581 +#include <ctype.h>
7582 +#include <string.h>
7583 +#include <errno.h>
7584 +
7585 +#include "pkg.h"
7586 +
7587 +#include "pkg_parse.h"
7588 +#include "pkg_extract.h"
7589 +#include "ipkg_message.h"
7590 +#include "ipkg_utils.h"
7591 +
7592 +#include "sprintf_alloc.h"
7593 +#include "file_util.h"
7594 +#include "str_util.h"
7595 +#include "xsystem.h"
7596 +#include "ipkg_conf.h"
7597 +
7598 +typedef struct enum_map enum_map_t;
7599 +struct enum_map
7600 +{
7601 +     int value;
7602 +     char *str;
7603 +};
7604 +
7605 +static const enum_map_t pkg_state_want_map[] = {
7606 +     { SW_UNKNOWN, "unknown"},
7607 +     { SW_INSTALL, "install"},
7608 +     { SW_DEINSTALL, "deinstall"},
7609 +     { SW_PURGE, "purge"}
7610 +};
7611 +
7612 +static const enum_map_t pkg_state_flag_map[] = {
7613 +     { SF_OK, "ok"},
7614 +     { SF_REINSTREQ, "reinstreq"},
7615 +     { SF_HOLD, "hold"},
7616 +     { SF_REPLACE, "replace"},
7617 +     { SF_NOPRUNE, "noprune"},
7618 +     { SF_PREFER, "prefer"},
7619 +     { SF_OBSOLETE, "obsolete"},
7620 +     { SF_USER, "user"},
7621 +};
7622 +
7623 +static const enum_map_t pkg_state_status_map[] = {
7624 +     { SS_NOT_INSTALLED, "not-installed" },
7625 +     { SS_UNPACKED, "unpacked" },
7626 +     { SS_HALF_CONFIGURED, "half-configured" },
7627 +     { SS_INSTALLED, "installed" },
7628 +     { SS_HALF_INSTALLED, "half-installed" },
7629 +     { SS_CONFIG_FILES, "config-files" },
7630 +     { SS_POST_INST_FAILED, "post-inst-failed" },
7631 +     { SS_REMOVAL_FAILED, "removal-failed" }
7632 +};
7633 +
7634 +static int verrevcmp(const char *val, const char *ref);
7635 +
7636 +
7637 +pkg_t *pkg_new(void)
7638 +{
7639 +     pkg_t *pkg;
7640 +
7641 +     pkg = malloc(sizeof(pkg_t));
7642 +     if (pkg == NULL) {
7643 +         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
7644 +         return NULL;
7645 +     }
7646 +
7647 +     pkg_init(pkg);
7648 +
7649 +     return pkg;
7650 +}
7651 +
7652 +int pkg_init(pkg_t *pkg)
7653 +{
7654 +     memset(pkg, 0, sizeof(pkg_t));
7655 +     pkg->name = NULL;
7656 +     pkg->epoch = 0;
7657 +     pkg->version = NULL;
7658 +     pkg->revision = NULL;
7659 +     pkg->familiar_revision = NULL;
7660 +     pkg->dest = NULL;
7661 +     pkg->src = NULL;
7662 +     pkg->architecture = NULL;
7663 +     pkg->maintainer = NULL;
7664 +     pkg->section = NULL;
7665 +     pkg->description = NULL;
7666 +     pkg->state_want = SW_UNKNOWN;
7667 +     pkg->state_flag = SF_OK;
7668 +     pkg->state_status = SS_NOT_INSTALLED;
7669 +     pkg->depends_str = NULL;
7670 +     pkg->provides_str = NULL;
7671 +     pkg->depends_count = 0;
7672 +     pkg->depends = NULL;
7673 +     pkg->suggests_str = NULL;
7674 +     pkg->recommends_str = NULL;
7675 +     pkg->suggests_count = 0;
7676 +     pkg->recommends_count = 0;
7677 +
7678 +     /* Abhaya: added init for conflicts fields */
7679 +     pkg->conflicts = NULL;
7680 +     pkg->conflicts_count = 0;
7681 +
7682 +     /* added for replaces.  Jamey 7/23/2002 */
7683 +     pkg->replaces = NULL;
7684 +     pkg->replaces_count = 0;
7685 +
7686 +     pkg->pre_depends_count = 0;
7687 +     pkg->pre_depends_str = NULL;
7688 +     pkg->provides_count = 0;
7689 +     pkg->provides = NULL;
7690 +     pkg->filename = NULL;
7691 +     pkg->local_filename = NULL;
7692 +     pkg->tmp_unpack_dir = NULL;
7693 +     pkg->md5sum = NULL;
7694 +     pkg->size = NULL;
7695 +     pkg->installed_size = NULL;
7696 +     pkg->priority = NULL;
7697 +     pkg->source = NULL;
7698 +     conffile_list_init(&pkg->conffiles);
7699 +     pkg->installed_files = NULL;
7700 +     pkg->installed_files_ref_cnt = 0;
7701 +     pkg->essential = 0;
7702 +     pkg->provided_by_hand = 0;
7703 +
7704 +     return 0;
7705 +}
7706 +
7707 +void pkg_deinit(pkg_t *pkg)
7708 +{
7709 +     free(pkg->name);
7710 +     pkg->name = NULL;
7711 +     pkg->epoch = 0;
7712 +     free(pkg->version);
7713 +     pkg->version = NULL;
7714 +     /* revision and familiar_revision share storage with version, so
7715 +       don't free */
7716 +     pkg->revision = NULL;
7717 +     pkg->familiar_revision = NULL;
7718 +     /* owned by ipkg_conf_t */
7719 +     pkg->dest = NULL;
7720 +     /* owned by ipkg_conf_t */
7721 +     pkg->src = NULL;
7722 +     free(pkg->architecture);
7723 +     pkg->architecture = NULL;
7724 +     free(pkg->maintainer);
7725 +     pkg->maintainer = NULL;
7726 +     free(pkg->section);
7727 +     pkg->section = NULL;
7728 +     free(pkg->description);
7729 +     pkg->description = NULL;
7730 +     pkg->state_want = SW_UNKNOWN;
7731 +     pkg->state_flag = SF_OK;
7732 +     pkg->state_status = SS_NOT_INSTALLED;
7733 +     free(pkg->depends_str);
7734 +     pkg->depends_str = NULL;
7735 +     free(pkg->provides_str);
7736 +     pkg->provides_str = NULL;
7737 +     pkg->depends_count = 0;
7738 +     /* XXX: CLEANUP: MEMORY_LEAK: how to free up pkg->depends ? */
7739 +     pkg->pre_depends_count = 0;
7740 +     free(pkg->pre_depends_str);
7741 +     pkg->pre_depends_str = NULL;
7742 +     pkg->provides_count = 0;
7743 +     /* XXX: CLEANUP: MEMORY_LEAK: how to free up pkg->provides ? */
7744 +     /* XXX: CLEANUP: MEMORY_LEAK: how to free up pkg->suggests ? */
7745 +     free(pkg->filename);
7746 +     pkg->filename = NULL;
7747 +     free(pkg->local_filename);
7748 +     pkg->local_filename = NULL;
7749 +     /* CLEANUP: It'd be nice to pullin the cleanup function from
7750 +       ipkg_install.c here. See comment in
7751 +       ipkg_install.c:cleanup_temporary_files */
7752 +     free(pkg->tmp_unpack_dir);
7753 +     pkg->tmp_unpack_dir = NULL;
7754 +     free(pkg->md5sum);
7755 +     pkg->md5sum = NULL;
7756 +     free(pkg->size);
7757 +     pkg->size = NULL;
7758 +     free(pkg->installed_size);
7759 +     pkg->installed_size = NULL;
7760 +     free(pkg->priority);
7761 +     pkg->priority = NULL;
7762 +     free(pkg->source);
7763 +     pkg->source = NULL;
7764 +     conffile_list_deinit(&pkg->conffiles);
7765 +     /* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
7766 +       since if they are calling deinit, they should know. Maybe do an
7767 +       assertion here instead? */
7768 +     pkg->installed_files_ref_cnt = 1;
7769 +     pkg_free_installed_files(pkg);
7770 +     pkg->essential = 0;
7771 +}
7772 +
7773 +int pkg_init_from_file(pkg_t *pkg, const char *filename)
7774 +{
7775 +     int err;
7776 +     char **raw;
7777 +     FILE *control_file;
7778 +
7779 +     err = pkg_init(pkg);
7780 +     if (err) { return err; }
7781 +
7782 +     pkg->local_filename = strdup(filename);
7783 +
7784 +     control_file = tmpfile();
7785 +     err = pkg_extract_control_file_to_stream(pkg, control_file);
7786 +     if (err) { return err; }
7787 +
7788 +     rewind(control_file);
7789 +     raw = read_raw_pkgs_from_stream(control_file);
7790 +     pkg_parse_raw(pkg, &raw, NULL, NULL);
7791 +
7792 +     fclose(control_file);
7793 +
7794 +     return 0;
7795 +}
7796 +
7797 +/* Merge any new information in newpkg into oldpkg */
7798 +/* XXX: CLEANUP: This function shouldn't actually modify anything in
7799 +   newpkg, but should leave it usable. This rework is so that
7800 +   pkg_hash_insert doesn't clobber the pkg that you pass into it. */
7801 +/*
7802 + * uh, i thought that i had originally written this so that it took
7803 + * two pkgs and returned a new one?  we can do that again... -sma
7804 + */
7805 +int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
7806 +{
7807 +     if (oldpkg == newpkg) {
7808 +         return 0;
7809 +     }
7810 +
7811 +     if (!oldpkg->src)
7812 +         oldpkg->src = newpkg->src;
7813 +     if (!oldpkg->dest)
7814 +         oldpkg->dest = newpkg->dest;
7815 +     if (!oldpkg->architecture)
7816 +         oldpkg->architecture = str_dup_safe(newpkg->architecture);
7817 +     if (!oldpkg->arch_priority)
7818 +         oldpkg->arch_priority = newpkg->arch_priority;
7819 +     if (!oldpkg->section)
7820 +         oldpkg->section = str_dup_safe(newpkg->section);
7821 +     if(!oldpkg->maintainer)
7822 +         oldpkg->maintainer = str_dup_safe(newpkg->maintainer);
7823 +     if(!oldpkg->description)
7824 +         oldpkg->description = str_dup_safe(newpkg->description);
7825 +     if (set_status) {
7826 +         /* merge the state_flags from the new package */
7827 +         oldpkg->state_want = newpkg->state_want;
7828 +         oldpkg->state_status = newpkg->state_status;
7829 +         oldpkg->state_flag = newpkg->state_flag;
7830 +     } else {
7831 +         if (oldpkg->state_want == SW_UNKNOWN)
7832 +              oldpkg->state_want = newpkg->state_want;
7833 +         if (oldpkg->state_status == SS_NOT_INSTALLED)
7834 +              oldpkg->state_status = newpkg->state_status;
7835 +         oldpkg->state_flag |= newpkg->state_flag;
7836 +     }
7837 +
7838 +     if (!oldpkg->depends_str && !oldpkg->pre_depends_str && !oldpkg->recommends_str && !oldpkg->suggests_str) {
7839 +         oldpkg->depends_str = newpkg->depends_str;
7840 +         newpkg->depends_str = NULL;
7841 +         oldpkg->depends_count = newpkg->depends_count;
7842 +         newpkg->depends_count = 0;
7843 +
7844 +         oldpkg->depends = newpkg->depends;
7845 +         newpkg->depends = NULL;
7846 +
7847 +         oldpkg->pre_depends_str = newpkg->pre_depends_str;
7848 +         newpkg->pre_depends_str = NULL;
7849 +         oldpkg->pre_depends_count = newpkg->pre_depends_count;
7850 +         newpkg->pre_depends_count = 0;
7851 +
7852 +         oldpkg->recommends_str = newpkg->recommends_str;
7853 +         newpkg->recommends_str = NULL;
7854 +         oldpkg->recommends_count = newpkg->recommends_count;
7855 +         newpkg->recommends_count = 0;
7856 +
7857 +         oldpkg->suggests_str = newpkg->suggests_str;
7858 +         newpkg->suggests_str = NULL;
7859 +         oldpkg->suggests_count = newpkg->suggests_count;
7860 +         newpkg->suggests_count = 0;
7861 +     }
7862 +
7863 +     if (!oldpkg->provides_str) {
7864 +         oldpkg->provides_str = newpkg->provides_str;
7865 +         newpkg->provides_str = NULL;
7866 +         oldpkg->provides_count = newpkg->provides_count;
7867 +         newpkg->provides_count = 0;
7868 +
7869 +         oldpkg->provides = newpkg->provides;
7870 +         newpkg->provides = NULL;
7871 +     }
7872 +
7873 +     if (!oldpkg->conflicts_str) {
7874 +         oldpkg->conflicts_str = newpkg->conflicts_str;
7875 +         newpkg->conflicts_str = NULL;
7876 +         oldpkg->conflicts_count = newpkg->conflicts_count;
7877 +         newpkg->conflicts_count = 0;
7878 +
7879 +         oldpkg->conflicts = newpkg->conflicts;
7880 +         newpkg->conflicts = NULL;
7881 +     }
7882 +
7883 +     if (!oldpkg->replaces_str) {
7884 +         oldpkg->replaces_str = newpkg->replaces_str;
7885 +         newpkg->replaces_str = NULL;
7886 +         oldpkg->replaces_count = newpkg->replaces_count;
7887 +         newpkg->replaces_count = 0;
7888 +
7889 +         oldpkg->replaces = newpkg->replaces;
7890 +         newpkg->replaces = NULL;
7891 +     }
7892 +
7893 +     if (!oldpkg->filename)
7894 +         oldpkg->filename = str_dup_safe(newpkg->filename);
7895 +     if (0)
7896 +     fprintf(stdout, "pkg=%s old local_filename=%s new local_filename=%s\n",
7897 +            oldpkg->name, oldpkg->local_filename, newpkg->local_filename);
7898 +     if (!oldpkg->local_filename)
7899 +         oldpkg->local_filename = str_dup_safe(newpkg->local_filename);
7900 +     if (!oldpkg->tmp_unpack_dir)
7901 +         oldpkg->tmp_unpack_dir = str_dup_safe(newpkg->tmp_unpack_dir);
7902 +     if (!oldpkg->md5sum)
7903 +         oldpkg->md5sum = str_dup_safe(newpkg->md5sum);
7904 +     if (!oldpkg->size)
7905 +         oldpkg->size = str_dup_safe(newpkg->size);
7906 +     if (!oldpkg->installed_size)
7907 +         oldpkg->installed_size = str_dup_safe(newpkg->installed_size);
7908 +     if (!oldpkg->priority)
7909 +         oldpkg->priority = str_dup_safe(newpkg->priority);
7910 +     if (!oldpkg->source)
7911 +         oldpkg->source = str_dup_safe(newpkg->source);
7912 +     if (oldpkg->conffiles.head == NULL){
7913 +         oldpkg->conffiles = newpkg->conffiles;
7914 +         conffile_list_init(&newpkg->conffiles);
7915 +     }
7916 +     if (!oldpkg->installed_files){
7917 +         oldpkg->installed_files = newpkg->installed_files;
7918 +         oldpkg->installed_files_ref_cnt = newpkg->installed_files_ref_cnt;
7919 +         newpkg->installed_files = NULL;
7920 +     }
7921 +     if (!oldpkg->essential)
7922 +         oldpkg->essential = newpkg->essential;
7923 +
7924 +     oldpkg->provided_by_hand |= newpkg->provided_by_hand;
7925 +
7926 +     return 0;
7927 +}
7928 +
7929 +abstract_pkg_t *abstract_pkg_new(void)
7930 +{
7931 +     abstract_pkg_t * ab_pkg;
7932 +
7933 +     ab_pkg = malloc(sizeof(abstract_pkg_t));
7934 +
7935 +     if (ab_pkg == NULL) {
7936 +         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
7937 +         return NULL;
7938 +     }
7939 +
7940 +     if ( abstract_pkg_init(ab_pkg) < 0 )
7941 +        return NULL;
7942 +
7943 +     return ab_pkg;
7944 +}
7945 +
7946 +int abstract_pkg_init(abstract_pkg_t *ab_pkg)
7947 +{
7948 +     memset(ab_pkg, 0, sizeof(abstract_pkg_t));
7949 +
7950 +     ab_pkg->provided_by = abstract_pkg_vec_alloc();
7951 +     if (ab_pkg->provided_by==NULL){
7952 +        return -1;
7953 +     }
7954 +     ab_pkg->dependencies_checked = 0;
7955 +     ab_pkg->state_status = SS_NOT_INSTALLED;
7956 +
7957 +     return 0;
7958 +}
7959 +
7960 +void set_flags_from_control(ipkg_conf_t *conf, pkg_t *pkg){
7961 +     char * temp_str;
7962 +     char **raw =NULL;
7963 +     char **raw_start=NULL;
7964 +
7965 +     temp_str = (char *) malloc (strlen(pkg->dest->info_dir)+strlen(pkg->name)+12);
7966 +     if (temp_str == NULL ){
7967 +        ipkg_message(conf, IPKG_INFO, "Out of memory in  %s\n", __FUNCTION__);
7968 +        return;
7969 +     }
7970 +     sprintf( temp_str,"%s/%s.control",pkg->dest->info_dir,pkg->name);
7971 +
7972 +     raw = raw_start = read_raw_pkgs_from_file(temp_str);
7973 +     if (raw == NULL ){
7974 +        ipkg_message(conf, IPKG_ERROR, "Unable to open the control file in  %s\n", __FUNCTION__);
7975 +        return;
7976 +     }
7977 +
7978 +     while(*raw){
7979 +        if (!pkg_valorize_other_field(pkg, &raw ) == 0) {
7980 +            ipkg_message(conf, IPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name);
7981 +        }
7982 +     }
7983 +     raw = raw_start;
7984 +     while (*raw) {
7985 +        if (raw!=NULL)
7986 +          free(*raw++);
7987 +     }
7988 +
7989 +     free(raw_start);
7990 +     free(temp_str);
7991 +
7992 +     return ;
7993 +
7994 +}
7995 +
7996 +char * pkg_formatted_info(pkg_t *pkg )
7997 +{
7998 +     char *line;
7999 +     char * buff;
8000 +
8001 +     buff = malloc(8192);
8002 +     if (buff == NULL) {
8003 +         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8004 +         return NULL;
8005 +     }
8006 +
8007 +     buff[0] = '\0';
8008 +
8009 +     line = pkg_formatted_field(pkg, "Package");
8010 +     strncat(buff ,line, strlen(line));
8011 +     free(line);
8012 +
8013 +     line = pkg_formatted_field(pkg, "Version");
8014 +     strncat(buff ,line, strlen(line));
8015 +     free(line);
8016 +
8017 +     line = pkg_formatted_field(pkg, "Depends");
8018 +     strncat(buff ,line, strlen(line));
8019 +     free(line);
8020 +
8021 +     line = pkg_formatted_field(pkg, "Recommends");
8022 +     strncat(buff ,line, strlen(line));
8023 +     free(line);
8024 +
8025 +     line = pkg_formatted_field(pkg, "Suggests");
8026 +     strncat(buff ,line, strlen(line));
8027 +     free(line);
8028 +
8029 +     line = pkg_formatted_field(pkg, "Provides");
8030 +     strncat(buff ,line, strlen(line));
8031 +     free(line);
8032 +
8033 +     line = pkg_formatted_field(pkg, "Replaces");
8034 +     strncat(buff ,line, strlen(line));
8035 +     free(line);
8036 +
8037 +     line = pkg_formatted_field(pkg, "Conflicts");
8038 +     strncat(buff ,line, strlen(line));
8039 +     free(line);
8040 +
8041 +     line = pkg_formatted_field(pkg, "Status");
8042 +     strncat(buff ,line, strlen(line));
8043 +     free(line);
8044 +
8045 +     line = pkg_formatted_field(pkg, "Section");
8046 +     strncat(buff ,line, strlen(line));
8047 +     free(line);
8048 +
8049 +     line = pkg_formatted_field(pkg, "Essential"); /* @@@@ should be removed in future release. *//* I do not agree with this Pigi*/
8050 +     strncat(buff ,line, strlen(line));
8051 +     free(line);
8052 +
8053 +     line = pkg_formatted_field(pkg, "Architecture");
8054 +     strncat(buff ,line, strlen(line));
8055 +     free(line);
8056 +
8057 +     line = pkg_formatted_field(pkg, "Maintainer");
8058 +     strncat(buff ,line, strlen(line));
8059 +     free(line);
8060 +
8061 +     line = pkg_formatted_field(pkg, "MD5sum");
8062 +     strncat(buff ,line, strlen(line));
8063 +     free(line);
8064 +
8065 +     line = pkg_formatted_field(pkg, "Size");
8066 +     strncat(buff ,line, strlen(line));
8067 +     free(line);
8068 +
8069 +     line = pkg_formatted_field(pkg, "Filename");
8070 +     strncat(buff ,line, strlen(line));
8071 +     free(line);
8072 +
8073 +     line = pkg_formatted_field(pkg, "Conffiles");
8074 +     strncat(buff ,line, strlen(line));
8075 +     free(line);
8076 +
8077 +     line = pkg_formatted_field(pkg, "Source");
8078 +     strncat(buff ,line, strlen(line));
8079 +     free(line);
8080 +
8081 +     line = pkg_formatted_field(pkg, "Description");
8082 +     strncat(buff ,line, strlen(line));
8083 +     free(line);
8084 +
8085 +     line = pkg_formatted_field(pkg, "Installed-Time");
8086 +     strncat(buff ,line, strlen(line));
8087 +     free(line);
8088 +
8089 +     return buff;
8090 +}
8091 +
8092 +char * pkg_formatted_field(pkg_t *pkg, const char *field )
8093 +{
8094 +     static size_t LINE_LEN = 128;
8095 +     char line_str[LINE_LEN];
8096 +     char * temp = (char *)malloc(1);
8097 +     int len = 0;
8098 +     int flag_provide_false = 0;
8099 +
8100 +/*
8101 +  Pigi: After some discussion with Florian we decided to modify the full procedure in
8102 +        dynamic memory allocation. This should avoid any other segv in this area ( except for bugs )
8103 +*/
8104 +
8105 +     if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
8106 +         goto UNKNOWN_FMT_FIELD;
8107 +     }
8108 +
8109 +     temp[0]='\0';
8110 +
8111 +     switch (field[0])
8112 +     {
8113 +     case 'a':
8114 +     case 'A':
8115 +         if (strcasecmp(field, "Architecture") == 0) {
8116 +              /* Architecture */
8117 +              if (pkg->architecture) {
8118 +                   temp = (char *)realloc(temp,strlen(pkg->architecture)+17);
8119 +                   if ( temp == NULL ){
8120 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8121 +                     return NULL;
8122 +                   }
8123 +                   temp[0]='\0';
8124 +                   snprintf(temp, (strlen(pkg->architecture)+17), "Architecture: %s\n", pkg->architecture);
8125 +              }
8126 +         } else {
8127 +              goto UNKNOWN_FMT_FIELD;
8128 +         }
8129 +         break;
8130 +     case 'c':
8131 +     case 'C':
8132 +         if (strcasecmp(field, "Conffiles") == 0) {
8133 +              /* Conffiles */
8134 +              conffile_list_elt_t *iter;
8135 +
8136 +              if (pkg->conffiles.head == NULL) {
8137 +                   return temp;
8138 +              }
8139 +
8140 +               len = 14 ;
8141 +              for (iter = pkg->conffiles.head; iter; iter = iter->next) {
8142 +                   if (iter->data->name && iter->data->value) {
8143 +                       len = len + (strlen(iter->data->name)+strlen(iter->data->value)+5);
8144 +                   }
8145 +              }
8146 +               temp = (char *)realloc(temp,len);
8147 +               if ( temp == NULL ){
8148 +                 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8149 +                 return NULL;
8150 +               }
8151 +               temp[0]='\0';
8152 +               strncpy(temp, "Conffiles:\n", 12);
8153 +              for (iter = pkg->conffiles.head; iter; iter = iter->next) {
8154 +                   if (iter->data->name && iter->data->value) {
8155 +                         snprintf(line_str, LINE_LEN, "%s %s\n", iter->data->name, iter->data->value);
8156 +                         strncat(temp, line_str, strlen(line_str));
8157 +                   }
8158 +              }
8159 +         } else if (strcasecmp(field, "Conflicts") == 0) {
8160 +              int i;
8161 +
8162 +              if (pkg->conflicts_count) {
8163 +                    len = 14 ;
8164 +                   for(i = 0; i < pkg->conflicts_count; i++) {
8165 +                        len = len + (strlen(pkg->conflicts_str[i])+5);
8166 +                    }
8167 +                    temp = (char *)realloc(temp,len);
8168 +                    if ( temp == NULL ){
8169 +                      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8170 +                      return NULL;
8171 +                    }
8172 +                    temp[0]='\0';
8173 +                    strncpy(temp, "Conflicts:", 11);
8174 +                   for(i = 0; i < pkg->conflicts_count; i++) {
8175 +                        snprintf(line_str, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->conflicts_str[i]);
8176 +                        strncat(temp, line_str, strlen(line_str));
8177 +                    }
8178 +                    strncat(temp, "\n", strlen("\n"));
8179 +              }
8180 +         } else {
8181 +              goto UNKNOWN_FMT_FIELD;
8182 +         }
8183 +         break;
8184 +     case 'd':
8185 +     case 'D':
8186 +         if (strcasecmp(field, "Depends") == 0) {
8187 +              /* Depends */
8188 +              int i;
8189 +
8190 +              if (pkg->depends_count) {
8191 +                    len = 14 ;
8192 +                   for(i = 0; i < pkg->depends_count; i++) {
8193 +                        len = len + (strlen(pkg->depends_str[i])+4);
8194 +                    }
8195 +                    temp = (char *)realloc(temp,len);
8196 +                    if ( temp == NULL ){
8197 +                      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8198 +                      return NULL;
8199 +                    }
8200 +                    temp[0]='\0';
8201 +                    strncpy(temp, "Depends:", 10);
8202 +                   for(i = 0; i < pkg->depends_count; i++) {
8203 +                        snprintf(line_str, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->depends_str[i]);
8204 +                        strncat(temp, line_str, strlen(line_str));
8205 +                    }
8206 +                    strncat(temp, "\n", strlen("\n"));
8207 +              }
8208 +         } else if (strcasecmp(field, "Description") == 0) {
8209 +              /* Description */
8210 +              if (pkg->description) {
8211 +                   temp = (char *)realloc(temp,strlen(pkg->description)+16);
8212 +                   if ( temp == NULL ){
8213 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8214 +                     return NULL;
8215 +                   }
8216 +                   temp[0]='\0';
8217 +                   snprintf(temp, (strlen(pkg->description)+16), "Description: %s\n", pkg->description);
8218 +              }
8219 +         } else {
8220 +              goto UNKNOWN_FMT_FIELD;
8221 +         }
8222 +      break;
8223 +     case 'e':
8224 +     case 'E': {
8225 +         /* Essential */
8226 +         if (pkg->essential) {
8227 +              temp = (char *)realloc(temp,16);
8228 +              if ( temp == NULL ){
8229 +                fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8230 +                return NULL;
8231 +              }
8232 +              temp[0]='\0';
8233 +              snprintf(temp, (16), "Essential: yes\n");
8234 +         }
8235 +     }
8236 +         break;
8237 +     case 'f':
8238 +     case 'F': {
8239 +         /* Filename */
8240 +         if (pkg->filename) {
8241 +              temp = (char *)realloc(temp,strlen(pkg->filename)+12);
8242 +              if ( temp == NULL ){
8243 +                 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8244 +                 return NULL;
8245 +              }
8246 +              temp[0]='\0';
8247 +              snprintf(temp, (strlen(pkg->filename)+12), "Filename: %s\n", pkg->filename);
8248 +         }
8249 +     }
8250 +         break;
8251 +     case 'i':
8252 +     case 'I': {
8253 +         if (strcasecmp(field, "Installed-Size") == 0) {
8254 +              /* Installed-Size */
8255 +               temp = (char *)realloc(temp,strlen(pkg->installed_size)+17);
8256 +               if ( temp == NULL ){
8257 +                  fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8258 +                  return NULL;
8259 +               }
8260 +               temp[0]='\0';
8261 +               snprintf(temp, (strlen(pkg->installed_size)+17), "Installed-Size: %s\n", pkg->installed_size);
8262 +         } else if (strcasecmp(field, "Installed-Time") == 0 && pkg->installed_time) {
8263 +               temp = (char *)realloc(temp,29);
8264 +               if ( temp == NULL ){
8265 +                 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8266 +                 return NULL;
8267 +               }
8268 +               temp[0]='\0';
8269 +               snprintf(temp, 29, "Installed-Time: %lu\n", pkg->installed_time);
8270 +         }
8271 +     }
8272 +         break;
8273 +     case 'm':
8274 +     case 'M': {
8275 +         /* Maintainer | MD5sum */
8276 +         if (strcasecmp(field, "Maintainer") == 0) {
8277 +              /* Maintainer */
8278 +              if (pkg->maintainer) {
8279 +                   temp = (char *)realloc(temp,strlen(pkg->maintainer)+14);
8280 +                   if ( temp == NULL ){
8281 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8282 +                     return NULL;
8283 +                   }
8284 +                   temp[0]='\0';
8285 +                   snprintf(temp, (strlen(pkg->maintainer)+14), "maintainer: %s\n", pkg->maintainer);
8286 +              }
8287 +         } else if (strcasecmp(field, "MD5sum") == 0) {
8288 +              /* MD5sum */
8289 +              if (pkg->md5sum) {
8290 +                   temp = (char *)realloc(temp,strlen(pkg->md5sum)+11);
8291 +                   if ( temp == NULL ){
8292 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8293 +                     return NULL;
8294 +                   }
8295 +                   temp[0]='\0';
8296 +                   snprintf(temp, (strlen(pkg->md5sum)+11), "MD5Sum: %s\n", pkg->md5sum);
8297 +              }
8298 +         } else {
8299 +              goto UNKNOWN_FMT_FIELD;
8300 +         }
8301 +     }
8302 +         break;
8303 +     case 'p':
8304 +     case 'P': {
8305 +         if (strcasecmp(field, "Package") == 0) {
8306 +              /* Package */
8307 +               temp = (char *)realloc(temp,strlen(pkg->name)+11);
8308 +               if ( temp == NULL ){
8309 +                 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8310 +                 return NULL;
8311 +               }
8312 +               temp[0]='\0';
8313 +               snprintf(temp, (strlen(pkg->name)+11), "Package: %s\n", pkg->name);
8314 +         } else if (strcasecmp(field, "Priority") == 0) {
8315 +              /* Priority */
8316 +               temp = (char *)realloc(temp,strlen(pkg->priority)+12);
8317 +               if ( temp == NULL ){
8318 +                 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8319 +                 return NULL;
8320 +               }
8321 +               temp[0]='\0';
8322 +               snprintf(temp, (strlen(pkg->priority)+12), "Priority: %s\n", pkg->priority);
8323 +         } else if (strcasecmp(field, "Provides") == 0) {
8324 +              /* Provides */
8325 +              int i;
8326 +
8327 +              if (pkg->provides_count) {
8328 +               /* Here we check if the ipkg_internal_use_only is used, and we discard it.*/
8329 +                  for ( i=0; i < pkg->provides_count; i++ ){
8330 +                     if (strstr(pkg->provides_str[i],"ipkg_internal_use_only")!=NULL) {
8331 +                         memset (pkg->provides_str[i],'\x0',strlen(pkg->provides_str[i])); /* Pigi clear my trick flag, just in case */
8332 +                         flag_provide_false = 1;
8333 +                      }
8334 +                  }
8335 +                  if ( !flag_provide_false ||                                             /* Pigi there is not my trick flag */
8336 +                     ((flag_provide_false) &&  (pkg->provides_count > 1))){             /* Pigi There is, but we also have others Provides */
8337 +                     char provstr[LINE_LEN];
8338 +                     len = 15;
8339 +                    for(i = 0; i < pkg->provides_count; i++) {
8340 +                         len = len + (strlen(pkg->provides_str[i])+5);
8341 +                     }
8342 +                     temp = (char *)realloc(temp,len);
8343 +                     if ( temp == NULL ){
8344 +                       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8345 +                       return NULL;
8346 +                     }
8347 +                     temp[0]='\0';
8348 +                     strncpy(temp, "Provides:", 12);
8349 +                    for(i = 0; i < pkg->provides_count; i++) {
8350 +                         if (strlen(pkg->provides_str[i])>0){;
8351 +                            snprintf(provstr, LINE_LEN, "%s %s", i == 1 ? "" : ",", pkg->provides_str[i]);
8352 +                            strncat(temp, provstr, strlen(provstr));
8353 +                         }
8354 +                     }
8355 +                     strncat(temp, "\n", strlen("\n"));
8356 +                  }
8357 +               }
8358 +         } else {
8359 +              goto UNKNOWN_FMT_FIELD;
8360 +         }
8361 +     }
8362 +         break;
8363 +     case 'r':
8364 +     case 'R': {
8365 +         int i;
8366 +         /* Replaces | Recommends*/
8367 +         if (strcasecmp (field, "Replaces") == 0) {
8368 +              if (pkg->replaces_count) {
8369 +                    len = 14;
8370 +                   for (i = 0; i < pkg->replaces_count; i++) {
8371 +                        len = len + (strlen(pkg->replaces_str[i])+5);
8372 +                    }
8373 +                    temp = (char *)realloc(temp,len);
8374 +                    if ( temp == NULL ){
8375 +                      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8376 +                      return NULL;
8377 +                    }
8378 +                    temp[0]='\0';
8379 +                    strncpy(temp, "Replaces:", 12);
8380 +                   for (i = 0; i < pkg->replaces_count; i++) {
8381 +                        snprintf(line_str, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->replaces_str[i]);
8382 +                        strncat(temp, line_str, strlen(line_str));
8383 +                    }
8384 +                    strncat(temp, "\n", strlen("\n"));
8385 +              }
8386 +         } else if (strcasecmp (field, "Recommends") == 0) {
8387 +              if (pkg->recommends_count) {
8388 +                    len = 15;
8389 +                   for(i = 0; i < pkg->recommends_count; i++) {
8390 +                         len = len + (strlen( pkg->recommends_str[i])+5);
8391 +                    }
8392 +                    temp = (char *)realloc(temp,len);
8393 +                   if ( temp == NULL ){
8394 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8395 +                     return NULL;
8396 +                   }
8397 +                    temp[0]='\0';
8398 +                    strncpy(temp, "Recommends:", 13);
8399 +                   for(i = 0; i < pkg->recommends_count; i++) {
8400 +                        snprintf(line_str, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->recommends_str[i]);
8401 +                        strncat(temp, line_str, strlen(line_str));
8402 +                    }
8403 +                    strncat(temp, "\n", strlen("\n"));
8404 +              }
8405 +         } else {
8406 +              goto UNKNOWN_FMT_FIELD;
8407 +         }
8408 +     }
8409 +         break;
8410 +     case 's':
8411 +     case 'S': {
8412 +         /* Section | Size | Source | Status | Suggests */
8413 +         if (strcasecmp(field, "Section") == 0) {
8414 +              /* Section */
8415 +              if (pkg->section) {
8416 +                   temp = (char *)realloc(temp,strlen(pkg->section)+11);
8417 +                   if ( temp == NULL ){
8418 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8419 +                     return NULL;
8420 +                   }
8421 +                   temp[0]='\0';
8422 +                   snprintf(temp, (strlen(pkg->section)+11), "Section: %s\n", pkg->section);
8423 +              }
8424 +         } else if (strcasecmp(field, "Size") == 0) {
8425 +              /* Size */
8426 +              if (pkg->size) {
8427 +                   temp = (char *)realloc(temp,strlen(pkg->size)+8);
8428 +                   if ( temp == NULL ){
8429 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8430 +                     return NULL;
8431 +                   }
8432 +                   temp[0]='\0';
8433 +                   snprintf(temp, (strlen(pkg->size)+8), "Size: %s\n", pkg->size);
8434 +              }
8435 +         } else if (strcasecmp(field, "Source") == 0) {
8436 +              /* Source */
8437 +              if (pkg->source) {
8438 +                   temp = (char *)realloc(temp,strlen(pkg->source)+10);
8439 +                   if ( temp == NULL ){
8440 +                     fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8441 +                     return NULL;
8442 +                   }
8443 +                   temp[0]='\0';
8444 +                   snprintf(temp, (strlen(pkg->source)+10), "Source: %s\n", pkg->source);
8445 +               }
8446 +         } else if (strcasecmp(field, "Status") == 0) {
8447 +              /* Status */
8448 +               /* Benjamin Pineau note: we should avoid direct usage of
8449 +                * strlen(arg) without keeping "arg" for later free()
8450 +                */
8451 +               char *pflag=pkg_state_flag_to_str(pkg->state_flag);
8452 +               char *pstat=pkg_state_status_to_str(pkg->state_status);
8453 +               char *pwant=pkg_state_want_to_str(pkg->state_want);
8454 +
8455 +               size_t sum_of_sizes = (size_t) ( strlen(pwant)+ strlen(pflag)+ strlen(pstat) + 12 );
8456 +               temp = (char *)realloc(temp,sum_of_sizes);
8457 +               if ( temp == NULL ){
8458 +                   fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8459 +                   return NULL;
8460 +                }
8461 +                temp[0]='\0';
8462 +                snprintf(temp, sum_of_sizes , "Status: %s %s %s\n", pwant, pflag, pstat);
8463 +                free(pflag);
8464 +                free(pwant);
8465 +               if(pstat) /* pfstat can be NULL if ENOMEM */
8466 +                   free(pstat);
8467 +         } else if (strcasecmp(field, "Suggests") == 0) {
8468 +              if (pkg->suggests_count) {
8469 +                   int i;
8470 +                    len = 13;
8471 +                   for(i = 0; i < pkg->suggests_count; i++) {
8472 +                        len = len + (strlen(pkg->suggests_str[i])+5);
8473 +                    }
8474 +                    temp = (char *)realloc(temp,len);
8475 +                    if ( temp == NULL ){
8476 +                      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8477 +                      return NULL;
8478 +                    }
8479 +                    temp[0]='\0';
8480 +                    strncpy(temp, "Suggests:", 10);
8481 +                   for(i = 0; i < pkg->suggests_count; i++) {
8482 +                        snprintf(line_str, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->suggests_str[i]);
8483 +                        strncat(temp, line_str, strlen(line_str));
8484 +                    }
8485 +                    strncat(temp, "\n", strlen("\n"));
8486 +              }
8487 +         } else {
8488 +              goto UNKNOWN_FMT_FIELD;
8489 +         }
8490 +     }
8491 +         break;
8492 +     case 'v':
8493 +     case 'V': {
8494 +         /* Version */
8495 +         char *version = pkg_version_str_alloc(pkg);
8496 +          temp = (char *)realloc(temp,strlen(version)+14);
8497 +          if ( temp == NULL ){
8498 +             fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8499 +             return NULL;
8500 +          }
8501 +          temp[0]='\0';
8502 +          snprintf(temp, (strlen(version)+12), "Version: %s\n", version);
8503 +         free(version);
8504 +     }
8505 +         break;
8506 +     default:
8507 +         goto UNKNOWN_FMT_FIELD;
8508 +     }
8509 +
8510 +     if ( strlen(temp)<2 ) {
8511 +          temp[0]='\0';
8512 +     }
8513 +     return temp;
8514 +
8515 + UNKNOWN_FMT_FIELD:
8516 +     fprintf(stderr, "%s: ERROR: Unknown field name: %s\n", __FUNCTION__, field);
8517 +     if ( strlen(temp)<2 ) {
8518 +          temp[0]='\0';
8519 +     }
8520 +
8521 +     return temp;
8522 +}
8523 +
8524 +void pkg_print_info(pkg_t *pkg, FILE *file)
8525 +{
8526 +     char * buff;
8527 +     if (pkg == NULL) {
8528 +       return;
8529 +     }
8530 +
8531 +     buff = pkg_formatted_info(pkg);
8532 +     if ( buff == NULL )
8533 +         return;
8534 +     if (strlen(buff)>2){
8535 +         fwrite(buff, 1, strlen(buff), file);
8536 +     }
8537 +     free(buff);
8538 +}
8539 +
8540 +void pkg_print_status(pkg_t * pkg, FILE * file)
8541 +{
8542 +     if (pkg == NULL) {
8543 +         return;
8544 +     }
8545 +
8546 +     /* XXX: QUESTION: Do we actually want more fields here? The
8547 +       original idea was to save space by installing only what was
8548 +       needed for actual computation, (package, version, status,
8549 +       essential, conffiles). The assumption is that all other fields
8550 +       can be found in th available file.
8551 +
8552 +       But, someone proposed the idea to make it possible to
8553 +       reconstruct a .ipk from an installed package, (ie. for beaming
8554 +       from one handheld to another). So, maybe we actually want a few
8555 +       more fields here, (depends, suggests, etc.), so that that would
8556 +       be guaranteed to work even in the absence of more information
8557 +       from the available file.
8558 +
8559 +       28-MAR-03: kergoth and I discussed this yesterday.  We think
8560 +       the essential info needs to be here for all installed packages
8561 +       because they may not appear in the Packages files on various
8562 +       feeds.  Furthermore, one should be able to install from URL or
8563 +       local storage without requiring a Packages file from any feed.
8564 +       -Jamey
8565 +     */
8566 +     pkg_print_field(pkg, file, "Package");
8567 +     pkg_print_field(pkg, file, "Version");
8568 +     pkg_print_field(pkg, file, "Depends");
8569 +     pkg_print_field(pkg, file, "Recommends");
8570 +     pkg_print_field(pkg, file, "Suggests");
8571 +     pkg_print_field(pkg, file, "Provides");
8572 +     pkg_print_field(pkg, file, "Replaces");
8573 +     pkg_print_field(pkg, file, "Conflicts");
8574 +     pkg_print_field(pkg, file, "Status");
8575 +     pkg_print_field(pkg, file, "Essential"); /* @@@@ should be removed in future release. */
8576 +     pkg_print_field(pkg, file, "Architecture");
8577 +     pkg_print_field(pkg, file, "Conffiles");
8578 +     pkg_print_field(pkg, file, "Installed-Time");
8579 +     fputs("\n", file);
8580 +}
8581 +
8582 +void pkg_print_field(pkg_t *pkg, FILE *file, const char *field)
8583 +{
8584 +     char *buff;
8585 +     if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
8586 +       fprintf(stderr, "%s: ERROR: Unknown field name: %s\n",
8587 +            __FUNCTION__, field);
8588 +     }
8589 +     buff = pkg_formatted_field(pkg, field);
8590 +     if (strlen(buff)>2) {
8591 +       fprintf(file, "%s", buff);
8592 +       fflush(file);
8593 +     }
8594 +     free(buff);
8595 +     return;
8596 +}
8597 +
8598 +/*
8599 + * libdpkg - Debian packaging suite library routines
8600 + * vercmp.c - comparison of version numbers
8601 + *
8602 + * Copyright (C) 1995 Ian Jackson <iwj10@cus.cam.ac.uk>
8603 + */
8604 +int pkg_compare_versions(const pkg_t *pkg, const pkg_t *ref_pkg)
8605 +{
8606 +     int r;
8607 +
8608 +     if (pkg->epoch > ref_pkg->epoch) {
8609 +         return 1;
8610 +     }
8611 +
8612 +     if (pkg->epoch < ref_pkg->epoch) {
8613 +         return -1;
8614 +     }
8615 +
8616 +     r = verrevcmp(pkg->version, ref_pkg->version);
8617 +     if (r) {
8618 +         return r;
8619 +     }
8620 +
8621 +#ifdef USE_DEBVERSION
8622 +     r = verrevcmp(pkg->revision, ref_pkg->revision);
8623 +     if (r) {
8624 +         return r;
8625 +     }
8626 +
8627 +     r = verrevcmp(pkg->familiar_revision, ref_pkg->familiar_revision);
8628 +#endif
8629 +
8630 +     return r;
8631 +}
8632 +
8633 +int verrevcmp(const char *val, const char *ref)
8634 +{
8635 +     int vc, rc;
8636 +     long vl, rl;
8637 +     const char *vp, *rp;
8638 +     const char *vsep, *rsep;
8639 +
8640 +     if (!val) val= "";
8641 +     if (!ref) ref= "";
8642 +     for (;;) {
8643 +         vp= val;  while (*vp && !isdigit(*vp)) vp++;
8644 +         rp= ref;  while (*rp && !isdigit(*rp)) rp++;
8645 +         for (;;) {
8646 +              vc= (val == vp) ? 0 : *val++;
8647 +              rc= (ref == rp) ? 0 : *ref++;
8648 +              if (!rc && !vc) break;
8649 +              if (vc && !isalpha(vc)) vc += 256; /* assumes ASCII character set */
8650 +              if (rc && !isalpha(rc)) rc += 256;
8651 +              if (vc != rc) return vc - rc;
8652 +         }
8653 +         val= vp;
8654 +         ref= rp;
8655 +         vl=0;  if (isdigit(*vp)) vl= strtol(val,(char**)&val,10);
8656 +         rl=0;  if (isdigit(*rp)) rl= strtol(ref,(char**)&ref,10);
8657 +         if (vl != rl) return vl - rl;
8658 +
8659 +         vc = *val;
8660 +         rc = *ref;
8661 +         vsep = strchr(".-", vc);
8662 +         rsep = strchr(".-", rc);
8663 +         if (vsep && !rsep) return -1;
8664 +         if (!vsep && rsep) return +1;
8665 +
8666 +         if (!*val && !*ref) return 0;
8667 +         if (!*val) return -1;
8668 +         if (!*ref) return +1;
8669 +     }
8670 +}
8671 +
8672 +int pkg_version_satisfied(pkg_t *it, pkg_t *ref, const char *op)
8673 +{
8674 +     int r;
8675 +
8676 +     r = pkg_compare_versions(it, ref);
8677 +
8678 +     if (strcmp(op, "<=") == 0 || strcmp(op, "<") == 0) {
8679 +         return r <= 0;
8680 +     }
8681 +
8682 +     if (strcmp(op, ">=") == 0 || strcmp(op, ">") == 0) {
8683 +         return r >= 0;
8684 +     }
8685 +
8686 +     if (strcmp(op, "<<") == 0) {
8687 +         return r < 0;
8688 +     }
8689 +
8690 +     if (strcmp(op, ">>") == 0) {
8691 +         return r > 0;
8692 +     }
8693 +
8694 +     if (strcmp(op, "=") == 0) {
8695 +         return r == 0;
8696 +     }
8697 +
8698 +     fprintf(stderr, "unknown operator: %s", op);
8699 +     return 0;
8700 +}
8701 +
8702 +int pkg_name_version_and_architecture_compare(pkg_t *a, pkg_t *b)
8703 +{
8704 +     int namecmp;
8705 +     int vercmp;
8706 +     if (!a->name || !b->name) {
8707 +       fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->name=%p b=%p b->name=%p\n",
8708 +              a, a->name, b, b->name);
8709 +       return 0;
8710 +     }
8711 +
8712 +     namecmp = strcmp(a->name, b->name);
8713 +     if (namecmp)
8714 +         return namecmp;
8715 +     vercmp = pkg_compare_versions(a, b);
8716 +     if (vercmp)
8717 +         return vercmp;
8718 +     if (!a->arch_priority || !b->arch_priority) {
8719 +       fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->arch_priority=%i b=%p b->arch_priority=%i\n",
8720 +              a, a->arch_priority, b, b->arch_priority);
8721 +       return 0;
8722 +     }
8723 +     if (a->arch_priority > b->arch_priority)
8724 +         return 1;
8725 +     if (a->arch_priority < b->arch_priority)
8726 +         return -1;
8727 +     return 0;
8728 +}
8729 +
8730 +int abstract_pkg_name_compare(abstract_pkg_t *a, abstract_pkg_t *b)
8731 +{
8732 +     if (!a->name || !b->name) {
8733 +       fprintf(stderr, "abstract_pkg_name_compare: a=%p a->name=%p b=%p b->name=%p\n",
8734 +              a, a->name, b, b->name);
8735 +       return 0;
8736 +     }
8737 +     return strcmp(a->name, b->name);
8738 +}
8739 +
8740 +
8741 +char *pkg_version_str_alloc(pkg_t *pkg)
8742 +{
8743 +     char *complete_version;
8744 +     char *epoch_str;
8745 +#ifdef USE_DEBVERSION
8746 +     char *revision_str;
8747 +     char *familiar_revision_str;
8748 +#endif
8749 +
8750 +     if (pkg->epoch) {
8751 +         sprintf_alloc(&epoch_str, "%d:", (int)(pkg->epoch));
8752 +     } else {
8753 +         epoch_str = strdup("");
8754 +     }
8755 +
8756 +#ifdef USE_DEBVERSION
8757 +     if (pkg->revision && strlen(pkg->revision)) {
8758 +         sprintf_alloc(&revision_str, "-%s", pkg->revision);
8759 +     } else {
8760 +         revision_str = strdup("");
8761 +     }
8762 +
8763 +     if (pkg->familiar_revision && strlen(pkg->familiar_revision)) {
8764 +         sprintf_alloc(&familiar_revision_str, "-fam%s", pkg->familiar_revision);
8765 +     } else {
8766 +         familiar_revision_str = strdup("");
8767 +     }
8768 +#endif
8769 +
8770 +#ifdef USE_DEBVERSION
8771 +     sprintf_alloc(&complete_version, "%s%s%s%s",
8772 +                  epoch_str, pkg->version, revision_str, familiar_revision_str);
8773 +#else
8774 +     sprintf_alloc(&complete_version, "%s%s",
8775 +                  epoch_str, pkg->version);
8776 +#endif
8777 +
8778 +     free(epoch_str);
8779 +#ifdef USE_DEBVERSION
8780 +     free(revision_str);
8781 +     free(familiar_revision_str);
8782 +#endif
8783 +
8784 +     return complete_version;
8785 +}
8786 +
8787 +str_list_t *pkg_get_installed_files(pkg_t *pkg)
8788 +{
8789 +     int err;
8790 +     char *list_file_name = NULL;
8791 +     FILE *list_file = NULL;
8792 +     char *line;
8793 +     char *installed_file_name;
8794 +     int rootdirlen;
8795 +
8796 +     pkg->installed_files_ref_cnt++;
8797 +
8798 +     if (pkg->installed_files) {
8799 +         return pkg->installed_files;
8800 +     }
8801 +
8802 +     pkg->installed_files = str_list_alloc();
8803 +     if (pkg->installed_files == NULL) {
8804 +         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
8805 +         return NULL;
8806 +     }
8807 +
8808 +     /* For uninstalled packages, get the file list firectly from the package.
8809 +       For installed packages, look at the package.list file in the database.
8810 +     */
8811 +     if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) {
8812 +         if (pkg->local_filename == NULL) {
8813 +              return pkg->installed_files;
8814 +         }
8815 +         /* XXX: CLEANUP: Maybe rewrite this to avoid using a temporary
8816 +            file. In other words, change deb_extract so that it can
8817 +            simply return the file list as a char *[] rather than
8818 +            insisting on writing in to a FILE * as it does now. */
8819 +         list_file = tmpfile();
8820 +         err = pkg_extract_data_file_names_to_stream(pkg, list_file);
8821 +         if (err) {
8822 +              fclose(list_file);
8823 +              fprintf(stderr, "%s: Error extracting file list from %s: %s\n",
8824 +                      __FUNCTION__, pkg->local_filename, strerror(err));
8825 +              return pkg->installed_files;
8826 +         }
8827 +         rewind(list_file);
8828 +     } else {
8829 +         sprintf_alloc(&list_file_name, "%s/%s.list",
8830 +                       pkg->dest->info_dir, pkg->name);
8831 +         if (! file_exists(list_file_name)) {
8832 +              free(list_file_name);
8833 +              return pkg->installed_files;
8834 +         }
8835 +
8836 +         list_file = fopen(list_file_name, "r");
8837 +         if (list_file == NULL) {
8838 +              fprintf(stderr, "WARNING: Cannot open %s: %s\n",
8839 +                      list_file_name, strerror(errno));
8840 +              free(list_file_name);
8841 +              return pkg->installed_files;
8842 +         }
8843 +         free(list_file_name);
8844 +     }
8845 +
8846 +     rootdirlen = strlen( pkg->dest->root_dir );
8847 +     while (1) {
8848 +         char *file_name;
8849 +
8850 +         line = file_read_line_alloc(list_file);
8851 +         if (line == NULL) {
8852 +              break;
8853 +         }
8854 +         str_chomp(line);
8855 +         file_name = line;
8856 +
8857 +         /* Take pains to avoid uglies like "/./" in the middle of file_name. */
8858 +         if( strncmp( pkg->dest->root_dir,
8859 +                      file_name,
8860 +                      rootdirlen ) ) {
8861 +              if (*file_name == '.') {
8862 +                   file_name++;
8863 +              }
8864 +              if (*file_name == '/') {
8865 +                   file_name++;
8866 +              }
8867 +
8868 +              /* Freed in pkg_free_installed_files */
8869 +              sprintf_alloc(&installed_file_name, "%s%s", pkg->dest->root_dir, file_name);
8870 +         } else {
8871 +              // already contains root_dir as header -> ABSOLUTE
8872 +              sprintf_alloc(&installed_file_name, "%s", file_name);
8873 +         }
8874 +         str_list_append(pkg->installed_files, installed_file_name);
8875 +         free(line);
8876 +     }
8877 +
8878 +     fclose(list_file);
8879 +
8880 +     return pkg->installed_files;
8881 +}
8882 +
8883 +/* XXX: CLEANUP: This function and it's counterpart,
8884 +   (pkg_get_installed_files), do not match our init/deinit naming
8885 +   convention. Nor the alloc/free convention. But, then again, neither
8886 +   of these conventions currrently fit the way these two functions
8887 +   work. */
8888 +int pkg_free_installed_files(pkg_t *pkg)
8889 +{
8890 +     str_list_elt_t *iter;
8891 +
8892 +     pkg->installed_files_ref_cnt--;
8893 +     if (pkg->installed_files_ref_cnt > 0) {
8894 +         return 0;
8895 +     }
8896 +
8897 +     if (pkg->installed_files) {
8898 +
8899 +         for (iter = pkg->installed_files->head; iter; iter = iter->next) {
8900 +              /* malloced in pkg_get_installed_files */
8901 +              free (iter->data);
8902 +              iter->data = NULL;
8903 +         }
8904 +
8905 +         str_list_deinit(pkg->installed_files);
8906 +     }
8907 +
8908 +     pkg->installed_files = NULL;
8909 +
8910 +     return 0;
8911 +}
8912 +
8913 +int pkg_remove_installed_files_list(ipkg_conf_t *conf, pkg_t *pkg)
8914 +{
8915 +     int err;
8916 +     char *list_file_name;
8917 +
8918 +     //I don't think pkg_free_installed_files should be called here. Jamey
8919 +     //pkg_free_installed_files(pkg);
8920 +
8921 +     sprintf_alloc(&list_file_name, "%s/%s.list",
8922 +                  pkg->dest->info_dir, pkg->name);
8923 +     if (!conf->noaction) {
8924 +         err = unlink(list_file_name);
8925 +         free(list_file_name);
8926 +
8927 +         if (err) {
8928 +              return errno;
8929 +         }
8930 +     }
8931 +     return 0;
8932 +}
8933 +
8934 +conffile_t *pkg_get_conffile(pkg_t *pkg, const char *file_name)
8935 +{
8936 +     conffile_list_elt_t *iter;
8937 +     conffile_t *conffile;
8938 +
8939 +     if (pkg == NULL) {
8940 +         return NULL;
8941 +     }
8942 +
8943 +     for (iter = pkg->conffiles.head; iter; iter = iter->next) {
8944 +         conffile = iter->data;
8945 +
8946 +         if (strcmp(conffile->name, file_name) == 0) {
8947 +              return conffile;
8948 +         }
8949 +     }
8950 +
8951 +     return NULL;
8952 +}
8953 +
8954 +int pkg_run_script(ipkg_conf_t *conf, pkg_t *pkg,
8955 +                  const char *script, const char *args)
8956 +{
8957 +     int err;
8958 +     char *path;
8959 +     char *cmd;
8960 +
8961 +     /* XXX: FEATURE: When conf->offline_root is set, we should run the
8962 +       maintainer script within a chroot environment. */
8963 +
8964 +     /* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages
8965 +       have scripts in pkg->tmp_unpack_dir. */
8966 +     if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) {
8967 +         if (pkg->dest == NULL) {
8968 +              fprintf(stderr, "%s: ERROR: installed package %s has a NULL dest\n",
8969 +                      __FUNCTION__, pkg->name);
8970 +              return EINVAL;
8971 +         }
8972 +         sprintf_alloc(&path, "%s/%s.%s", pkg->dest->info_dir, pkg->name, script);
8973 +     } else {
8974 +         if (pkg->tmp_unpack_dir == NULL) {
8975 +              fprintf(stderr, "%s: ERROR: uninstalled package %s has a NULL tmp_unpack_dir\n",
8976 +                      __FUNCTION__, pkg->name);
8977 +              return EINVAL;
8978 +         }
8979 +         sprintf_alloc(&path, "%s/%s", pkg->tmp_unpack_dir, script);
8980 +     }
8981 +
8982 +     ipkg_message(conf, IPKG_INFO, "Running script %s\n", path);
8983 +     if (conf->noaction) return 0;
8984 +
8985 +     /* XXX: CLEANUP: There must be a better way to handle maintainer
8986 +       scripts when running with offline_root mode and/or a dest other
8987 +       than '/'. I've been playing around with some clever chroot
8988 +       tricks and I might come up with something workable. */
8989 +     if (conf->offline_root) {
8990 +         setenv("IPKG_OFFLINE_ROOT", conf->offline_root, 1);
8991 +     }
8992 +
8993 +     setenv("PKG_ROOT",
8994 +           pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir, 1);
8995 +
8996 +     if (! file_exists(path)) {
8997 +         free(path);
8998 +         return 0;
8999 +     }
9000 +
9001 +     if (conf->offline_root) {
9002 +         fprintf(stderr, "(offline root mode: not running %s.%s)\n", pkg->name, script);
9003 +         free(path);
9004 +         return 0;
9005 +     }
9006 +
9007 +     sprintf_alloc(&cmd, "%s %s", path, args);
9008 +     free(path);
9009 +
9010 +     err = xsystem(cmd);
9011 +     free(cmd);
9012 +
9013 +     if (err) {
9014 +         fprintf(stderr, "%s script returned status %d\n", script, err);
9015 +         return err;
9016 +     }
9017 +
9018 +     return 0;
9019 +}
9020 +
9021 +char *pkg_state_want_to_str(pkg_state_want_t sw)
9022 +{
9023 +     int i;
9024 +
9025 +     for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
9026 +         if (pkg_state_want_map[i].value == sw) {
9027 +              return strdup(pkg_state_want_map[i].str);
9028 +         }
9029 +     }
9030 +
9031 +     fprintf(stderr, "%s: ERROR: Illegal value for state_want: %d\n",
9032 +            __FUNCTION__, sw);
9033 +     return strdup("<STATE_WANT_UNKNOWN>");
9034 +}
9035 +
9036 +pkg_state_want_t pkg_state_want_from_str(char *str)
9037 +{
9038 +     int i;
9039 +
9040 +     for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
9041 +         if (strcmp(str, pkg_state_want_map[i].str) == 0) {
9042 +              return pkg_state_want_map[i].value;
9043 +         }
9044 +     }
9045 +
9046 +     fprintf(stderr, "%s: ERROR: Illegal value for state_want string: %s\n",
9047 +            __FUNCTION__, str);
9048 +     return SW_UNKNOWN;
9049 +}
9050 +
9051 +char *pkg_state_flag_to_str(pkg_state_flag_t sf)
9052 +{
9053 +     int i;
9054 +     int len = 3; /* ok\000 is minimum */
9055 +     char *str = NULL;
9056 +
9057 +     /* clear the temporary flags before converting to string */
9058 +     sf &= SF_NONVOLATILE_FLAGS;
9059 +
9060 +     if (sf == 0) {
9061 +         return strdup("ok");
9062 +     } else {
9063 +
9064 +         for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
9065 +              if (sf & pkg_state_flag_map[i].value) {
9066 +                   len += strlen(pkg_state_flag_map[i].str) + 1;
9067 +              }
9068 +         }
9069 +         str = malloc(len);
9070 +          if ( str == NULL ) {
9071 +             fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
9072 +              return NULL;
9073 +          }
9074 +         str[0] = 0;
9075 +         for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
9076 +              if (sf & pkg_state_flag_map[i].value) {
9077 +                   strcat(str, pkg_state_flag_map[i].str);
9078 +                   strcat(str, ",");
9079 +              }
9080 +         }
9081 +         len = strlen(str);
9082 +         str[len-1] = 0; /* squash last comma */
9083 +         return str;
9084 +     }
9085 +}
9086 +
9087 +pkg_state_flag_t pkg_state_flag_from_str(char *str)
9088 +{
9089 +     int i;
9090 +     int sf = SF_OK;
9091 +
9092 +     if (strcmp(str, "ok") == 0) {
9093 +         return SF_OK;
9094 +     }
9095 +     for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
9096 +         const char *sfname = pkg_state_flag_map[i].str;
9097 +         int sfname_len = strlen(sfname);
9098 +         if (strncmp(str, sfname, sfname_len) == 0) {
9099 +              sf |= pkg_state_flag_map[i].value;
9100 +              str += sfname_len;
9101 +              if (str[0] == ',') {
9102 +                   str++;
9103 +              } else {
9104 +                   break;
9105 +              }
9106 +         }
9107 +     }
9108 +
9109 +     return sf;
9110 +}
9111 +
9112 +char *pkg_state_status_to_str(pkg_state_status_t ss)
9113 +{
9114 +     int i;
9115 +
9116 +     for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
9117 +         if (pkg_state_status_map[i].value == ss) {
9118 +              return strdup(pkg_state_status_map[i].str);
9119 +         }
9120 +     }
9121 +
9122 +     fprintf(stderr, "%s: ERROR: Illegal value for state_status: %d\n",
9123 +            __FUNCTION__, ss);
9124 +     return strdup("<STATE_STATUS_UNKNOWN>");
9125 +}
9126 +
9127 +pkg_state_status_t pkg_state_status_from_str(char *str)
9128 +{
9129 +     int i;
9130 +
9131 +     for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
9132 +         if (strcmp(str, pkg_state_status_map[i].str) == 0) {
9133 +              return pkg_state_status_map[i].value;
9134 +         }
9135 +     }
9136 +
9137 +     fprintf(stderr, "%s: ERROR: Illegal value for state_status string: %s\n",
9138 +            __FUNCTION__, str);
9139 +     return SS_NOT_INSTALLED;
9140 +}
9141 +
9142 +int pkg_arch_supported(ipkg_conf_t *conf, pkg_t *pkg)
9143 +{
9144 +     nv_pair_list_elt_t *l;
9145 +
9146 +     if (!pkg->architecture)
9147 +         return 1;
9148 +
9149 +     l = conf->arch_list.head;
9150 +
9151 +     while (l) {
9152 +         nv_pair_t *nv = l->data;
9153 +         if (strcmp(nv->name, pkg->architecture) == 0) {
9154 +              ipkg_message(conf, IPKG_DEBUG, "arch %s (priority %s) supported for pkg %s\n", nv->name, nv->value, pkg->name);
9155 +              return 1;
9156 +         }
9157 +         l = l->next;
9158 +     }
9159 +
9160 +     ipkg_message(conf, IPKG_DEBUG, "arch %s unsupported for pkg %s\n", pkg->architecture, pkg->name);
9161 +     return 0;
9162 +}
9163 +
9164 +int pkg_get_arch_priority(ipkg_conf_t *conf, const char *archname)
9165 +{
9166 +     nv_pair_list_elt_t *l;
9167 +
9168 +     l = conf->arch_list.head;
9169 +
9170 +     while (l) {
9171 +         nv_pair_t *nv = l->data;
9172 +         if (strcmp(nv->name, archname) == 0) {
9173 +              int priority = strtol(nv->value, NULL, 0);
9174 +              return priority;
9175 +         }
9176 +         l = l->next;
9177 +     }
9178 +     return 0;
9179 +}
9180 +
9181 +int pkg_info_preinstall_check(ipkg_conf_t *conf)
9182 +{
9183 +     int i;
9184 +     hash_table_t *pkg_hash = &conf->pkg_hash;
9185 +     pkg_vec_t *available_pkgs = pkg_vec_alloc();
9186 +     pkg_vec_t *installed_pkgs = pkg_vec_alloc();
9187 +
9188 +     ipkg_message(conf, IPKG_INFO, "pkg_info_preinstall_check: updating arch priority for each package\n");
9189 +     pkg_hash_fetch_available(pkg_hash, available_pkgs);
9190 +     /* update arch_priority for each package */
9191 +     for (i = 0; i < available_pkgs->len; i++) {
9192 +         pkg_t *pkg = available_pkgs->pkgs[i];
9193 +         int arch_priority = 1;
9194 +         if (!pkg)
9195 +              continue;
9196 +         // ipkg_message(conf, IPKG_DEBUG2, " package %s version=%s arch=%p:", pkg->name, pkg->version, pkg->architecture);
9197 +         if (pkg->architecture)
9198 +              arch_priority = pkg_get_arch_priority(conf, pkg->architecture);
9199 +         else
9200 +              ipkg_message(conf, IPKG_ERROR, "pkg_info_preinstall_check: no architecture for package %s\n", pkg->name);
9201 +         // ipkg_message(conf, IPKG_DEBUG2, "%s arch_priority=%d\n", pkg->architecture, arch_priority);
9202 +         pkg->arch_priority = arch_priority;
9203 +     }
9204 +
9205 +     for (i = 0; i < available_pkgs->len; i++) {
9206 +         pkg_t *pkg = available_pkgs->pkgs[i];
9207 +         if (!pkg->arch_priority && (pkg->state_flag || (pkg->state_want != SW_UNKNOWN))) {
9208 +              /* clear flags and want for any uninstallable package */
9209 +              ipkg_message(conf, IPKG_NOTICE, "Clearing state_want and state_flag for pkg=%s (arch_priority=%d flag=%d want=%d)\n",
9210 +                           pkg->name, pkg->arch_priority, pkg->state_flag, pkg->state_want);
9211 +              pkg->state_want = SW_UNKNOWN;
9212 +              pkg->state_flag = 0;
9213 +         }
9214 +     }
9215 +     pkg_vec_free(available_pkgs);
9216 +
9217 +     /* update the file owner data structure */
9218 +     ipkg_message(conf, IPKG_INFO, "pkg_info_preinstall_check: update file owner list\n");
9219 +     pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
9220 +     for (i = 0; i < installed_pkgs->len; i++) {
9221 +         pkg_t *pkg = installed_pkgs->pkgs[i];
9222 +         str_list_t *installed_files = pkg_get_installed_files(pkg); /* this causes installed_files to be cached */
9223 +         str_list_elt_t *iter;
9224 +         if (installed_files == NULL) {
9225 +              ipkg_message(conf, IPKG_ERROR, "No installed files for pkg %s\n", pkg->name);
9226 +              break;
9227 +         }
9228 +         for (iter = installed_files->head; iter; iter = iter->next) {
9229 +              char *installed_file = iter->data;
9230 +              // ipkg_message(conf, IPKG_DEBUG2, "pkg %s: file=%s\n", pkg->name, installed_file);
9231 +              file_hash_set_file_owner(conf, installed_file, pkg);
9232 +         }
9233 +     }
9234 +     pkg_vec_free(installed_pkgs);
9235 +
9236 +     return 0;
9237 +}
9238 +
9239 +struct pkg_write_filelist_data {
9240 +     ipkg_conf_t *conf;
9241 +     pkg_t *pkg;
9242 +     FILE *stream;
9243 +};
9244 +
9245 +void pkg_write_filelist_helper(const char *key, void *entry_, void *data_)
9246 +{
9247 +     struct pkg_write_filelist_data *data = data_;
9248 +     pkg_t *entry = entry_;
9249 +     if (entry == data->pkg) {
9250 +         fprintf(data->stream, "%s\n", key);
9251 +     }
9252 +}
9253 +
9254 +int pkg_write_filelist(ipkg_conf_t *conf, pkg_t *pkg)
9255 +{
9256 +     struct pkg_write_filelist_data data;
9257 +     char *list_file_name = NULL;
9258 +     int err = 0;
9259 +
9260 +     if (!pkg) {
9261 +         ipkg_message(conf, IPKG_ERROR, "Null pkg\n");
9262 +         return -EINVAL;
9263 +     }
9264 +     ipkg_message(conf, IPKG_INFO,
9265 +                 "    creating %s.list file\n", pkg->name);
9266 +     sprintf_alloc(&list_file_name, "%s/%s.list", pkg->dest->info_dir, pkg->name);
9267 +     if (!list_file_name) {
9268 +         ipkg_message(conf, IPKG_ERROR, "Failed to alloc list_file_name\n");
9269 +         return -ENOMEM;
9270 +     }
9271 +     ipkg_message(conf, IPKG_INFO,
9272 +                 "    creating %s file for pkg %s\n", list_file_name, pkg->name);
9273 +     data.stream = fopen(list_file_name, "w");
9274 +     if (!data.stream) {
9275 +         ipkg_message(conf, IPKG_ERROR, "Could not open %s for writing: %s\n",
9276 +                      list_file_name, strerror(errno));
9277 +                      return errno;
9278 +     }
9279 +     data.pkg = pkg;
9280 +     data.conf = conf;
9281 +     hash_table_foreach(&conf->file_hash, pkg_write_filelist_helper, &data);
9282 +     fclose(data.stream);
9283 +     free(list_file_name);
9284 +
9285 +     return err;
9286 +}
9287 +
9288 +int pkg_write_changed_filelists(ipkg_conf_t *conf)
9289 +{
9290 +     pkg_vec_t *installed_pkgs = pkg_vec_alloc();
9291 +     hash_table_t *pkg_hash = &conf->pkg_hash;
9292 +     int i;
9293 +     int err;
9294 +     if (conf->noaction)
9295 +         return 0;
9296 +
9297 +     ipkg_message(conf, IPKG_INFO, "%s: saving changed filelists\n", __FUNCTION__);
9298 +     pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
9299 +     for (i = 0; i < installed_pkgs->len; i++) {
9300 +         pkg_t *pkg = installed_pkgs->pkgs[i];
9301 +         if (pkg->state_flag & SF_FILELIST_CHANGED) {
9302 +               ipkg_message(conf, IPKG_DEBUG, "Calling pkg_write_filelist for pkg=%s from %s\n", pkg->name, __FUNCTION__);
9303 +              err = pkg_write_filelist(conf, pkg);
9304 +              if (err)
9305 +                   ipkg_message(conf, IPKG_NOTICE, "pkg_write_filelist pkg=%s returned %d\n", pkg->name, err);
9306 +         }
9307 +     }
9308 +     return 0;
9309 +}
9310 Index: busybox-1.7.2/archival/libipkg/pkg_depends.c
9311 ===================================================================
9312 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
9313 +++ busybox-1.7.2/archival/libipkg/pkg_depends.c        2007-10-04 17:14:23.109058340 +0200
9314 @@ -0,0 +1,1031 @@
9315 +/* pkg_depends.c - the itsy package management system
9316 +
9317 +   Steven M. Ayer
9318 +
9319 +   Copyright (C) 2002 Compaq Computer Corporation
9320 +
9321 +   This program is free software; you can redistribute it and/or
9322 +   modify it under the terms of the GNU General Public License as
9323 +   published by the Free Software Foundation; either version 2, or (at
9324 +   your option) any later version.
9325 +
9326 +   This program is distributed in the hope that it will be useful, but
9327 +   WITHOUT ANY WARRANTY; without even the implied warranty of
9328 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
9329 +   General Public License for more details.
9330 +*/
9331 +
9332 +#include "ipkg.h"
9333 +#include <errno.h>
9334 +#include <ctype.h>
9335 +
9336 +#include "pkg.h"
9337 +#include "ipkg_utils.h"
9338 +#include "pkg_hash.h"
9339 +#include "ipkg_message.h"
9340 +#include "pkg_parse.h"
9341 +#include "hash_table.h"
9342 +
9343 +static int parseDepends(compound_depend_t *compound_depend, hash_table_t * hash, char * depend_str);
9344 +static depend_t * depend_init(void);
9345 +static void depend_deinit(depend_t *d);
9346 +static char ** add_unresolved_dep(pkg_t * pkg, char ** the_lost, int ref_ndx);
9347 +static char ** merge_unresolved(char ** oldstuff, char ** newstuff);
9348 +static int is_pkg_in_pkg_vec(pkg_vec_t * vec, pkg_t * pkg);
9349 +
9350 +static int pkg_installed_and_constraint_satisfied(pkg_t *pkg, void *cdata)
9351 +{
9352 +     depend_t *depend = (depend_t *)cdata;
9353 +     if ((pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) && version_constraints_satisfied(depend, pkg))
9354 +         return 1;
9355 +     else
9356 +         return 0;
9357 +}
9358 +
9359 +static int pkg_constraint_satisfied(pkg_t *pkg, void *cdata)
9360 +{
9361 +     depend_t *depend = (depend_t *)cdata;
9362 +#if 0
9363 +     pkg_t * temp = pkg_new();
9364 +     int comparison;
9365 +     parseVersion(temp, depend->version);
9366 +     comparison = pkg_compare_versions(pkg, temp);
9367 +     free(temp);
9368 +
9369 +     fprintf(stderr, "%s: pkg=%s pkg->version=%s constraint=%p type=%d version=%s comparison=%d satisfied=%d\n",
9370 +            __FUNCTION__, pkg->name, pkg->version,
9371 +            depend, depend->constraint, depend->version,
9372 +            comparison, version_constraints_satisfied(depend, pkg));
9373 +#endif
9374 +     if (version_constraints_satisfied(depend, pkg))
9375 +         return 1;
9376 +     else
9377 +         return 0;
9378 +}
9379 +
9380 +/* returns ndependences or negative error value */
9381 +int pkg_hash_fetch_unsatisfied_dependencies(ipkg_conf_t *conf, pkg_t * pkg,
9382 +                                           pkg_vec_t *unsatisfied, char *** unresolved)
9383 +{
9384 +     pkg_t * satisfier_entry_pkg;
9385 +     register int i, j, k, l;
9386 +     int count, found;
9387 +     char ** the_lost;
9388 +     abstract_pkg_t * ab_pkg;
9389 +
9390 +     /*
9391 +      * this is a setup to check for redundant/cyclic dependency checks,
9392 +      * which are marked at the abstract_pkg level
9393 +      */
9394 +     if (!(ab_pkg = pkg->parent)) {
9395 +         fprintf(stderr, "%s:%d: something terribly wrong with pkg %s\n", __FUNCTION__, __LINE__, pkg->name);
9396 +         *unresolved = NULL;
9397 +         return 0;
9398 +     }
9399 +     if (ab_pkg->dependencies_checked) {    /* avoid duplicate or cyclic checks */
9400 +         *unresolved = NULL;
9401 +         return 0;
9402 +     } else {
9403 +         ab_pkg->dependencies_checked = 1;  /* mark it for subsequent visits */
9404 +     }
9405 +     /**/
9406 +
9407 +     count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
9408 +     if (!count){
9409 +         *unresolved = NULL;
9410 +         return 0;
9411 +     }
9412 +
9413 +     the_lost = NULL;
9414 +
9415 +     /* foreach dependency */
9416 +     for (i = 0; i < count; i++) {
9417 +         compound_depend_t * compound_depend = &pkg->depends[i];
9418 +         depend_t ** possible_satisfiers = compound_depend->possibilities;;
9419 +         found = 0;
9420 +         satisfier_entry_pkg = NULL;
9421 +
9422 +         if (compound_depend->type == GREEDY_DEPEND) {
9423 +              /* foreach possible satisfier */
9424 +              for (j = 0; j < compound_depend->possibility_count; j++) {
9425 +                   /* foreach provided_by, which includes the abstract_pkg itself */
9426 +                   abstract_pkg_t *abpkg = possible_satisfiers[j]->pkg;
9427 +                   abstract_pkg_vec_t *ab_provider_vec = abpkg->provided_by;
9428 +                   int nposs = ab_provider_vec->len;
9429 +                   abstract_pkg_t **ab_providers = ab_provider_vec->pkgs;
9430 +                   for (l = 0; l < nposs; l++) {
9431 +                        pkg_vec_t *test_vec = ab_providers[l]->pkgs;
9432 +                        /* if no depends on this one, try the first package that Provides this one */
9433 +                        if (!test_vec){   /* no pkg_vec hooked up to the abstract_pkg!  (need another feed?) */
9434 +                             continue;
9435 +                        }
9436 +
9437 +                        /* cruise this possiblity's pkg_vec looking for an installed version */
9438 +                        for (k = 0; k < test_vec->len; k++) {
9439 +                             pkg_t *pkg_scout = test_vec->pkgs[k];
9440 +                             /* not installed, and not already known about? */
9441 +                             if ((pkg_scout->state_want != SW_INSTALL)
9442 +                                 && !pkg_scout->parent->dependencies_checked
9443 +                                 && !is_pkg_in_pkg_vec(unsatisfied, pkg_scout)) {
9444 +                                  char ** newstuff = NULL;
9445 +                                  int rc;
9446 +                                  pkg_vec_t *tmp_vec = pkg_vec_alloc ();
9447 +                                  /* check for not-already-installed dependencies */
9448 +                                  rc = pkg_hash_fetch_unsatisfied_dependencies(conf,
9449 +                                                                               pkg_scout,
9450 +                                                                               tmp_vec,
9451 +                                                                               &newstuff);
9452 +                                  if (newstuff == NULL) {
9453 +                                       int ok = 1;
9454 +                                       for (l = 0; l < rc; l++) {
9455 +                                           pkg_t *p = tmp_vec->pkgs[l];
9456 +                                           if (p->state_want == SW_INSTALL)
9457 +                                               continue;
9458 +                                           ipkg_message(conf, IPKG_DEBUG, "not installing %s due to requirement for %s\n", pkg_scout->name, p->name);
9459 +                                           ok = 0;
9460 +                                           break;
9461 +                                       }
9462 +                                       pkg_vec_free (tmp_vec);
9463 +                                       if (ok) {
9464 +                                           /* mark this one for installation */
9465 +                                           ipkg_message(conf, IPKG_NOTICE, "Adding satisfier for greedy dependence: %s\n", pkg_scout->name);
9466 +                                           pkg_vec_insert(unsatisfied, pkg_scout);
9467 +                                       }
9468 +                                  } else  {
9469 +                                       ipkg_message(conf, IPKG_DEBUG, "not installing %s due to broken depends \n", pkg_scout->name);
9470 +                                       free (newstuff);
9471 +                                  }
9472 +                             }
9473 +                        }
9474 +                   }
9475 +              }
9476 +
9477 +              continue;
9478 +         }
9479 +
9480 +         /* foreach possible satisfier, look for installed package  */
9481 +         for (j = 0; j < compound_depend->possibility_count; j++) {
9482 +              /* foreach provided_by, which includes the abstract_pkg itself */
9483 +              depend_t *dependence_to_satisfy = possible_satisfiers[j];
9484 +              abstract_pkg_t *satisfying_apkg = possible_satisfiers[j]->pkg;
9485 +              pkg_t *satisfying_pkg =
9486 +                   pkg_hash_fetch_best_installation_candidate(conf, satisfying_apkg,
9487 +                                                              pkg_installed_and_constraint_satisfied,
9488 +                                                              dependence_to_satisfy, 1);
9489 +               /* Being that I can't test constraing in pkg_hash, I will test it here */
9490 +              if (satisfying_pkg != NULL) {
9491 +                  if (!pkg_installed_and_constraint_satisfied ( satisfying_pkg,dependence_to_satisfy)) {
9492 +                     satisfying_pkg = NULL;
9493 +                  }
9494 +               }
9495 +              ipkg_message(conf, IPKG_DEBUG, "%s:%d: satisfying_pkg=%p \n", __FILE__, __LINE__, satisfying_pkg);
9496 +              if (satisfying_pkg != NULL) {
9497 +                   found = 1;
9498 +                   break;
9499 +              }
9500 +
9501 +         }
9502 +         /* if nothing installed matches, then look for uninstalled satisfier */
9503 +         if (!found) {
9504 +              /* foreach possible satisfier, look for installed package  */
9505 +              for (j = 0; j < compound_depend->possibility_count; j++) {
9506 +                   /* foreach provided_by, which includes the abstract_pkg itself */
9507 +                   depend_t *dependence_to_satisfy = possible_satisfiers[j];
9508 +                   abstract_pkg_t *satisfying_apkg = possible_satisfiers[j]->pkg;
9509 +                   pkg_t *satisfying_pkg =
9510 +                        pkg_hash_fetch_best_installation_candidate(conf, satisfying_apkg,
9511 +                                                                   pkg_constraint_satisfied,
9512 +                                                                   dependence_to_satisfy, 1);
9513 +                    /* Being that I can't test constraing in pkg_hash, I will test it here too */
9514 +                   if (satisfying_pkg != NULL) {
9515 +                         if (!pkg_constraint_satisfied ( satisfying_pkg,dependence_to_satisfy)) {
9516 +                            satisfying_pkg = NULL;
9517 +                         }
9518 +                    }
9519 +
9520 +                   /* user request overrides package recommendation */
9521 +                   if (satisfying_pkg != NULL
9522 +                       && (compound_depend->type == RECOMMEND || compound_depend->type == SUGGEST)
9523 +                       && (satisfying_pkg->state_want == SW_DEINSTALL || satisfying_pkg->state_want == SW_PURGE)) {
9524 +                        ipkg_message (conf, IPKG_NOTICE, "%s: ignoring recommendation for %s at user request\n",
9525 +                                      pkg->name, satisfying_pkg->name);
9526 +                        continue;
9527 +                   }
9528 +
9529 +                   ipkg_message(conf, IPKG_DEBUG, "%s:%d: satisfying_pkg=%p\n", __FILE__, __LINE__, satisfying_pkg);
9530 +                   if (satisfying_pkg != NULL) {
9531 +                        satisfier_entry_pkg = satisfying_pkg;
9532 +                        break;
9533 +                   }
9534 +              }
9535 +         }
9536 +
9537 +         /* we didn't find one, add something to the unsatisfied vector */
9538 +         if (!found) {
9539 +              if (!satisfier_entry_pkg) {
9540 +                   /* failure to meet recommendations is not an error */
9541 +                   if (compound_depend->type != RECOMMEND && compound_depend->type != SUGGEST)
9542 +                        the_lost = add_unresolved_dep(pkg, the_lost, i);
9543 +                   else
9544 +                        ipkg_message (conf, IPKG_NOTICE, "%s: unsatisfied recommendation for %s\n",
9545 +                                      pkg->name, compound_depend->possibilities[0]->pkg->name);
9546 +              }
9547 +              else {
9548 +                   if (compound_depend->type == SUGGEST) {
9549 +                        /* just mention it politely */
9550 +                        ipkg_message (conf, IPKG_NOTICE, "package %s suggests installing %s\n",
9551 +                                      pkg->name, satisfier_entry_pkg->name);
9552 +                   } else {
9553 +                        char ** newstuff = NULL;
9554 +
9555 +                        if (satisfier_entry_pkg != pkg &&
9556 +                            !is_pkg_in_pkg_vec(unsatisfied, satisfier_entry_pkg)) {
9557 +                             pkg_vec_insert(unsatisfied, satisfier_entry_pkg);
9558 +                             pkg_hash_fetch_unsatisfied_dependencies(conf,
9559 +                                                                     satisfier_entry_pkg,
9560 +                                                                     unsatisfied,
9561 +                                                                     &newstuff);
9562 +                             the_lost = merge_unresolved(the_lost, newstuff);
9563 +                        }
9564 +                   }
9565 +              }
9566 +         }
9567 +     }
9568 +     *unresolved = the_lost;
9569 +
9570 +     return unsatisfied->len;
9571 +}
9572 +
9573 +/*checking for conflicts !in replaces
9574 +  If a packages conflicts with another but is also replacing it, I should not consider it a
9575 +  really conflicts
9576 +  returns 0 if conflicts <> replaces or 1 if conflicts == replaces
9577 +*/
9578 +int is_pkg_a_replaces(pkg_t *pkg_scout,pkg_t *pkg)
9579 +{
9580 +    int i ;
9581 +    int replaces_count = pkg->replaces_count;
9582 +    abstract_pkg_t **replaces;
9583 +
9584 +    if (pkg->replaces_count==0)    // No replaces, it's surely a conflict
9585 +        return 0;
9586 +
9587 +    replaces = pkg->replaces;
9588 +
9589 +    for (i = 0; i < replaces_count; i++) {
9590 +        if (strcmp(pkg_scout->name,pkg->replaces[i]->name)==0) {      // Found
9591 +            ipkg_message(NULL, IPKG_DEBUG2, "Seems I've found a replace %s %s \n",pkg_scout->name,pkg->replaces[i]->name);
9592 +            return 1;
9593 +        }
9594 +    }
9595 +    return 0;
9596 +
9597 +}
9598 +
9599 +
9600 +/* Abhaya: added support for conflicts */
9601 +pkg_vec_t * pkg_hash_fetch_conflicts(hash_table_t * hash, pkg_t * pkg)
9602 +{
9603 +    pkg_vec_t * installed_conflicts, * test_vec;
9604 +    compound_depend_t * conflicts;
9605 +    depend_t ** possible_satisfiers;
9606 +    depend_t * possible_satisfier;
9607 +    register int i, j, k;
9608 +    int count;
9609 +    abstract_pkg_t * ab_pkg;
9610 +    pkg_t **pkg_scouts;
9611 +    pkg_t *pkg_scout;
9612 +
9613 +    /*
9614 +     * this is a setup to check for redundant/cyclic dependency checks,
9615 +     * which are marked at the abstract_pkg level
9616 +     */
9617 +    if(!(ab_pkg = pkg->parent)){
9618 +       fprintf(stderr, "dependency check error.  pkg %s isn't in hash table\n", pkg->name);
9619 +       return (pkg_vec_t *)NULL;
9620 +    }
9621 +
9622 +    conflicts = pkg->conflicts;
9623 +    if(!conflicts){
9624 +       return (pkg_vec_t *)NULL;
9625 +    }
9626 +    installed_conflicts = pkg_vec_alloc();
9627 +
9628 +    count = pkg->conflicts_count;
9629 +
9630 +
9631 +
9632 +    /* foreach conflict */
9633 +    for(i = 0; i < pkg->conflicts_count; i++){
9634 +
9635 +       possible_satisfiers = conflicts->possibilities;
9636 +
9637 +       /* foreach possible satisfier */
9638 +       for(j = 0; j < conflicts->possibility_count; j++){
9639 +            possible_satisfier = possible_satisfiers[j];
9640 +            if (!possible_satisfier)
9641 +                fprintf(stderr, "%s:%d: possible_satisfier is null\n", __FUNCTION__, __LINE__);
9642 +            if (!possible_satisfier->pkg)
9643 +                fprintf(stderr, "%s:%d: possible_satisfier->pkg is null\n", __FUNCTION__, __LINE__);
9644 +           test_vec = possible_satisfier->pkg->pkgs;
9645 +           if (test_vec) {
9646 +                /* pkg_vec found, it is an actual package conflict
9647 +                * cruise this possiblity's pkg_vec looking for an installed version */
9648 +               pkg_scouts = test_vec->pkgs;
9649 +               for(k = 0; k < test_vec->len; k++){
9650 +                    pkg_scout = pkg_scouts[k];
9651 +                    if (!pkg_scout) {
9652 +                        fprintf(stderr,  "%s: null pkg scout\n", __FUNCTION__);
9653 +                        continue;
9654 +                    }
9655 +                   if ((pkg_scout->state_status == SS_INSTALLED || pkg_scout->state_want == SW_INSTALL) &&
9656 +                      version_constraints_satisfied(possible_satisfier, pkg_scout) && !is_pkg_a_replaces(pkg_scout,pkg)){
9657 +                       if (!is_pkg_in_pkg_vec(installed_conflicts, pkg_scout)){
9658 +                           pkg_vec_insert(installed_conflicts, pkg_scout);
9659 +                       }
9660 +                   }
9661 +               }
9662 +           }
9663 +       }
9664 +       conflicts++;
9665 +    }
9666 +
9667 +    if (installed_conflicts->len)
9668 +           return installed_conflicts;
9669 +    pkg_vec_free(installed_conflicts);
9670 +       return (pkg_vec_t *)NULL;
9671 +}
9672 +
9673 +int version_constraints_satisfied(depend_t * depends, pkg_t * pkg)
9674 +{
9675 +    pkg_t * temp;
9676 +    int comparison;
9677 +
9678 +    if(depends->constraint == NONE)
9679 +       return 1;
9680 +
9681 +    temp = pkg_new();
9682 +
9683 +    parseVersion(temp, depends->version);
9684 +
9685 +    comparison = pkg_compare_versions(pkg, temp);
9686 +
9687 +    free(temp);
9688 +
9689 +    if((depends->constraint == EARLIER) &&
9690 +       (comparison < 0))
9691 +       return 1;
9692 +    else if((depends->constraint == LATER) &&
9693 +           (comparison > 0))
9694 +       return 1;
9695 +    else if(comparison == 0)
9696 +       return 1;
9697 +    else if((depends->constraint == LATER_EQUAL) &&
9698 +           (comparison >= 0))
9699 +       return 1;
9700 +    else if((depends->constraint == EARLIER_EQUAL) &&
9701 +           (comparison <= 0))
9702 +       return 1;
9703 +
9704 +    return 0;
9705 +}
9706 +
9707 +int pkg_dependence_satisfiable(ipkg_conf_t *conf, depend_t *depend)
9708 +{
9709 +     abstract_pkg_t *apkg = depend->pkg;
9710 +     abstract_pkg_vec_t *provider_apkgs = apkg->provided_by;
9711 +     int n_providers = provider_apkgs->len;
9712 +     abstract_pkg_t **apkgs = provider_apkgs->pkgs;
9713 +     pkg_vec_t *pkg_vec;
9714 +     int n_pkgs ;
9715 +     int i;
9716 +     int j;
9717 +
9718 +     for (i = 0; i < n_providers; i++) {
9719 +         abstract_pkg_t *papkg = apkgs[i];
9720 +         pkg_vec = papkg->pkgs;
9721 +         if (pkg_vec) {
9722 +              n_pkgs = pkg_vec->len;
9723 +              for (j = 0; j < n_pkgs; j++) {
9724 +                   pkg_t *pkg = pkg_vec->pkgs[j];
9725 +                   if (version_constraints_satisfied(depend, pkg)) {
9726 +                        return 1;
9727 +                   }
9728 +              }
9729 +         }
9730 +     }
9731 +     return 0;
9732 +}
9733 +
9734 +int pkg_dependence_satisfied(ipkg_conf_t *conf, depend_t *depend)
9735 +{
9736 +     abstract_pkg_t *apkg = depend->pkg;
9737 +     abstract_pkg_vec_t *provider_apkgs = apkg->provided_by;
9738 +     int n_providers = provider_apkgs->len;
9739 +     abstract_pkg_t **apkgs = provider_apkgs->pkgs;
9740 +     int i;
9741 +     int n_pkgs;
9742 +     int j;
9743 +
9744 +     for (i = 0; i < n_providers; i++) {
9745 +         abstract_pkg_t *papkg = apkgs[i];
9746 +         pkg_vec_t *pkg_vec = papkg->pkgs;
9747 +         if (pkg_vec) {
9748 +              n_pkgs = pkg_vec->len;
9749 +              for (j = 0; j < n_pkgs; j++) {
9750 +                   pkg_t *pkg = pkg_vec->pkgs[j];
9751 +                   if (version_constraints_satisfied(depend, pkg)) {
9752 +                        if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED)
9753 +                             return 1;
9754 +                   }
9755 +              }
9756 +         }
9757 +     }
9758 +     return 0;
9759 +}
9760 +
9761 +static int is_pkg_in_pkg_vec(pkg_vec_t * vec, pkg_t * pkg)
9762 +{
9763 +    register int i;
9764 +    pkg_t ** pkgs = vec->pkgs;
9765 +
9766 +    for(i = 0; i < vec->len; i++)
9767 +       if((strcmp(pkg->name, (*(pkgs + i))->name) == 0)
9768 +          && (pkg_compare_versions(pkg, *(pkgs + i)) == 0)
9769 +          && (strcmp(pkg->architecture, (*(pkgs + i))->architecture) == 0))
9770 +           return 1;
9771 +    return 0;
9772 +}
9773 +
9774 +
9775 +#ifdef DeadCode
9776 +/**
9777 + * pkg_has_common_provides returns 1 if pkg and replacee both provide
9778 + * the same abstract package and 0 otherwise.
9779 + */
9780 +int pkg_has_common_provides(pkg_t *pkg, pkg_t *replacee)
9781 +{
9782 +     abstract_pkg_t **provides = pkg->provides;
9783 +     int provides_count = pkg->provides_count;
9784 +     abstract_pkg_t **replacee_provides = replacee->provides;
9785 +     int replacee_provides_count = replacee->provides_count;
9786 +     int i, j;
9787 +     for (i = 0; i < provides_count; i++) {
9788 +         abstract_pkg_t *apkg = provides[i];
9789 +         for (j = 0; j < replacee_provides_count; j++) {
9790 +              abstract_pkg_t *replacee_apkg = replacee_provides[i];
9791 +              if (apkg == replacee_apkg)
9792 +                   return 1;
9793 +         }
9794 +     }
9795 +     return 0;
9796 +}
9797 +#endif
9798 +
9799 +/**
9800 + * pkg_provides_abstract returns 1 if pkg->provides contains providee
9801 + * and 0 otherwise.
9802 + */
9803 +int pkg_provides_abstract(pkg_t *pkg, abstract_pkg_t *providee)
9804 +{
9805 +     abstract_pkg_t **provides = pkg->provides;
9806 +     int provides_count = pkg->provides_count;
9807 +     int i;
9808 +     for (i = 0; i < provides_count; i++) {
9809 +         if (provides[i] == providee)
9810 +              return 1;
9811 +     }
9812 +     return 0;
9813 +}
9814 +
9815 +/**
9816 + * pkg_replaces returns 1 if pkg->replaces contains one of replacee's provides and 0
9817 + * otherwise.
9818 + */
9819 +int pkg_replaces(pkg_t *pkg, pkg_t *replacee)
9820 +{
9821 +     abstract_pkg_t **replaces = pkg->replaces;
9822 +     int replaces_count = pkg->replaces_count;
9823 +     /* abstract_pkg_t **replacee_provides = pkg->provides;
9824 +     int replacee_provides_count = pkg->provides_count; */
9825 +     int i, j;
9826 +     for (i = 0; i < replaces_count; i++) {
9827 +         abstract_pkg_t *abstract_replacee = replaces[i];
9828 +         for (j = 0; j < replaces_count; j++) {
9829 +   /*            ipkg_message(NULL, IPKG_DEBUG2, "Searching pkg-name %s repprovname %s absrepname %s \n",
9830 +                 pkg->name,replacee->provides[j]->name, abstract_replacee->name); */
9831 +              if (replacee->provides[j] == abstract_replacee)
9832 +                   return 1;
9833 +         }
9834 +     }
9835 +     return 0;
9836 +}
9837 +
9838 +
9839 +/**
9840 + * pkg_conflicts_abstract returns 1 if pkg->conflicts contains conflictee and 0
9841 + * otherwise.
9842 + */
9843 +int pkg_conflicts_abstract(pkg_t *pkg, abstract_pkg_t *conflictee)
9844 +{
9845 +     compound_depend_t *conflicts = pkg->conflicts;
9846 +     int conflicts_count = pkg->conflicts_count;
9847 +     int i, j;
9848 +     for (i = 0; i < conflicts_count; i++) {
9849 +         int possibility_count = conflicts[i].possibility_count;
9850 +         struct depend **possibilities = conflicts[i].possibilities;
9851 +         for (j = 0; j < possibility_count; j++) {
9852 +              if (possibilities[j]->pkg == conflictee) {
9853 +                   return 1;
9854 +              }
9855 +         }
9856 +     }
9857 +     return 0;
9858 +}
9859 +
9860 +/**
9861 + * pkg_conflicts returns 1 if pkg->conflicts contains one of
9862 + * conflictee's provides and 0 otherwise.
9863 + */
9864 +int pkg_conflicts(pkg_t *pkg, pkg_t *conflictee)
9865 +{
9866 +     compound_depend_t *conflicts = pkg->conflicts;
9867 +     int conflicts_count = pkg->conflicts_count;
9868 +     abstract_pkg_t **conflictee_provides = conflictee->provides;
9869 +     int conflictee_provides_count = conflictee->provides_count;
9870 +     int i, j, k;
9871 +     int possibility_count;
9872 +     struct depend **possibilities;
9873 +     abstract_pkg_t *possibility ;
9874 +
9875 +     for (i = 0; i < conflicts_count; i++) {
9876 +         possibility_count = conflicts[i].possibility_count;
9877 +         possibilities = conflicts[i].possibilities;
9878 +         for (j = 0; j < possibility_count; j++) {
9879 +              possibility = possibilities[j]->pkg;
9880 +              for (k = 0; k < conflictee_provides_count; k++) {
9881 +                   if (possibility == conflictee_provides[k]) {
9882 +                        return 1;
9883 +                   }
9884 +              }
9885 +         }
9886 +     }
9887 +     return 0;
9888 +}
9889 +
9890 +static char ** merge_unresolved(char ** oldstuff, char ** newstuff)
9891 +{
9892 +    int oldlen = 0, newlen = 0;
9893 +    char ** result;
9894 +    register int i, j;
9895 +
9896 +    if(!newstuff)
9897 +       return oldstuff;
9898 +
9899 +    while(oldstuff && oldstuff[oldlen]) oldlen++;
9900 +    while(newstuff && newstuff[newlen]) newlen++;
9901 +
9902 +    result = (char **)realloc(oldstuff, sizeof(char *) * (oldlen + newlen + 1));
9903 +    if (result == NULL) {
9904 +        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
9905 +        return NULL;
9906 +    }
9907 +
9908 +    for(i = oldlen, j = 0; i < (oldlen + newlen); i++, j++)
9909 +       *(result + i) = *(newstuff + j);
9910 +
9911 +    *(result + i) = NULL;
9912 +
9913 +    return result;
9914 +}
9915 +
9916 +/*
9917 + * a kinda kludgy way to back out depends str from two different arrays (reg'l'r 'n pre)
9918 + * this is null terminated, no count is carried around
9919 + */
9920 +char ** add_unresolved_dep(pkg_t * pkg, char ** the_lost, int ref_ndx)
9921 +{
9922 +    int count;
9923 +    char ** resized;
9924 +    char *depend_str = pkg_depend_str(pkg, ref_ndx);
9925 +
9926 +    count = 0;
9927 +    while(the_lost && the_lost[count]) count++;
9928 +
9929 +    count++;  /* need one to hold the null */
9930 +    resized = (char **)realloc(the_lost, sizeof(char *) * (count + 1));
9931 +    if (resized == NULL) {
9932 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
9933 +       return NULL;
9934 +    }
9935 +    resized[count - 1] = strdup(depend_str);
9936 +    resized[count] = NULL;
9937 +
9938 +    return resized;
9939 +}
9940 +
9941 +void printDepends(pkg_t * pkg)
9942 +{
9943 +    register int i, j;
9944 +    compound_depend_t * depend;
9945 +    int count;
9946 +
9947 +    count = pkg->pre_depends_count + pkg->depends_count;
9948 +
9949 +    depend = pkg->depends;
9950 +    if(!depend){
9951 +       fprintf(stderr, "Depends pointer is NULL\n");
9952 +       return;
9953 +    }
9954 +    for(i = 0; i < count; i++){
9955 +       fprintf(stderr, "%s has %d possibilities:\n",
9956 +               (depend->type == GREEDY_DEPEND) ? "Greedy-Depend" : ((depend->type == DEPEND) ? "Depend" : "Pre-Depend"),
9957 +               depend->possibility_count);
9958 +       for(j = 0; j < depend->possibility_count; j++)
9959 +           fprintf(stderr, "\t%s version %s (%d)\n",
9960 +                   depend->possibilities[j]->pkg->name,
9961 +                   depend->possibilities[j]->version,
9962 +                   depend->possibilities[j]->constraint);
9963 +       depend++;
9964 +    }
9965 +}
9966 +
9967 +int buildProvides(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
9968 +{
9969 +    register int i, j;
9970 +
9971 +    /* every pkg provides itself */
9972 +    abstract_pkg_vec_insert(ab_pkg->provided_by, ab_pkg);
9973 +
9974 +    if (!pkg->provides_count)
9975 +      return 0;
9976 +
9977 +    pkg->provides = (abstract_pkg_t **)malloc(sizeof(abstract_pkg_t *) * (pkg->provides_count + 1));
9978 +    if (pkg->provides == NULL) {
9979 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
9980 +       return -1 ;
9981 +    }
9982 +    pkg->provides[0] = ab_pkg;
9983 +
9984 +    // if (strcmp(ab_pkg->name, pkg->name))
9985 +    //     fprintf(stderr, __FUNCTION__ ": ab_pkg=%s pkg=%s\n", ab_pkg->name, pkg->name);
9986 +
9987 +    for(i = 0; i < pkg->provides_count; i++){
9988 +        abstract_pkg_t *provided_abpkg = ensure_abstract_pkg_by_name(hash, pkg->provides_str[i]);
9989 +
9990 +       pkg->provides[i+1] = provided_abpkg;
9991 +
9992 +       j = 0;
9993 +       abstract_pkg_vec_insert(provided_abpkg->provided_by, ab_pkg);
9994 +    }
9995 +    return 0;
9996 +}
9997 +
9998 +/* Abhaya: added conflicts support */
9999 +int buildConflicts(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
10000 +{
10001 +    register int i;
10002 +    compound_depend_t * conflicts;
10003 +
10004 +    if (!pkg->conflicts_count)
10005 +       return 0;
10006 +
10007 +    conflicts = pkg->conflicts = malloc(sizeof(compound_depend_t) *
10008 +                                       pkg->conflicts_count);
10009 +    if (conflicts == NULL) {
10010 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
10011 +       return  -1;
10012 +    }
10013 +    for (i = 0; i < pkg->conflicts_count; i++) {
10014 +        conflicts->type = CONFLICTS;
10015 +        parseDepends(conflicts, hash,
10016 +                     pkg->conflicts_str[i]);
10017 +#if 0
10018 +        for (j = 0; j < conflicts->possibility_count; j++) {
10019 +             depend_t *possibility = conflicts->possibilities[j];
10020 +             abstract_pkg_t *conflicting_apkg = possibility->pkg;
10021 +             pkg_add_conflict_pair(ab_pkg, conflicting_apkg);
10022 +        }
10023 +#endif
10024 +        conflicts++;
10025 +    }
10026 +    return 0;
10027 +}
10028 +
10029 +int buildReplaces(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
10030 +{
10031 +     register int i, j;
10032 +
10033 +     if (!pkg->replaces_count)
10034 +         return 0;
10035 +
10036 +     pkg->replaces = (abstract_pkg_t **)malloc(sizeof(abstract_pkg_t *) * pkg->replaces_count);
10037 +     if (pkg->replaces == NULL) {
10038 +        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
10039 +        return  -1;
10040 +     }
10041 +
10042 +     // if (strcmp(ab_pkg->name, pkg->name))
10043 +     //     fprintf(stderr, __FUNCTION__ ": ab_pkg=%s pkg=%s\n", ab_pkg->name, pkg->name);
10044 +
10045 +     for(i = 0; i < pkg->replaces_count; i++){
10046 +         abstract_pkg_t *old_abpkg = ensure_abstract_pkg_by_name(hash, pkg->replaces_str[i]);
10047 +
10048 +         pkg->replaces[i] = old_abpkg;
10049 +
10050 +         j = 0;
10051 +         if (!old_abpkg->replaced_by)
10052 +              old_abpkg->replaced_by = abstract_pkg_vec_alloc();
10053 +               if ( old_abpkg->replaced_by == NULL ){
10054 +                  return -1;
10055 +               }
10056 +         /* if a package pkg both replaces and conflicts old_abpkg,
10057 +          * then add it to the replaced_by vector so that old_abpkg
10058 +          * will be upgraded to ab_pkg automatically */
10059 +         if (pkg_conflicts_abstract(pkg, old_abpkg))
10060 +              abstract_pkg_vec_insert(old_abpkg->replaced_by, ab_pkg);
10061 +     }
10062 +     return 0;
10063 +}
10064 +
10065 +int buildDepends(hash_table_t * hash, pkg_t * pkg)
10066 +{
10067 +     int count;
10068 +     register int i;
10069 +     compound_depend_t * depends;
10070 +
10071 +     if(!(count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count))
10072 +         return 0;
10073 +
10074 +     if (0 && pkg->pre_depends_count)
10075 +         fprintf(stderr, "pkg=%s pre_depends_count=%d depends_count=%d\n",
10076 +                 pkg->name, pkg->pre_depends_count, pkg->depends_count);
10077 +     depends = pkg->depends = malloc(sizeof(compound_depend_t) * count);
10078 +     if (depends == NULL) {
10079 +        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
10080 +        return  -1;
10081 +     }
10082 +
10083 +
10084 +     for(i = 0; i < pkg->pre_depends_count; i++){
10085 +         parseDepends(depends, hash, pkg->pre_depends_str[i]);
10086 +         if (0 && pkg->pre_depends_count)
10087 +              fprintf(stderr, " pre_depends_str=%s depends=%p possibility_count=%x\n",
10088 +                      pkg->pre_depends_str[i], depends, depends->possibility_count);
10089 +         depends->type = PREDEPEND;
10090 +         depends++;
10091 +     }
10092 +
10093 +     for(i = 0; i < pkg->recommends_count; i++){
10094 +         parseDepends(depends, hash, pkg->recommends_str[i]);
10095 +         if (0 && pkg->recommends_count)
10096 +              fprintf(stderr, " recommends_str=%s depends=%p possibility_count=%x\n",
10097 +                      pkg->recommends_str[i], depends, depends->possibility_count);
10098 +         depends->type = RECOMMEND;
10099 +         depends++;
10100 +     }
10101 +
10102 +     for(i = 0; i < pkg->suggests_count; i++){
10103 +         parseDepends(depends, hash, pkg->suggests_str[i]);
10104 +         if (0 && pkg->suggests_count)
10105 +              fprintf(stderr, " suggests_str=%s depends=%p possibility_count=%x\n",
10106 +                      pkg->suggests_str[i], depends, depends->possibility_count);
10107 +         depends->type = SUGGEST;
10108 +         depends++;
10109 +     }
10110 +
10111 +     for(i = 0; i < pkg->depends_count; i++){
10112 +         parseDepends(depends, hash, pkg->depends_str[i]);
10113 +         if (0 && pkg->depends_count)
10114 +              fprintf(stderr, " depends_str=%s depends=%p possibility_count=%x\n",
10115 +                      pkg->depends_str[i], depends, depends->possibility_count);
10116 +         depends++;
10117 +     }
10118 +     return 0;
10119 +}
10120 +
10121 +/*
10122 + * pkg_depend_string: returns the depends string specified by index.
10123 + *   All 4 kinds of dependences: dependence, pre-dependence, recommend, and suggest are number starting from 0.
10124 + *   [0,npredepends) -> returns pre_depends_str[index]
10125 + *   [npredepends,npredepends+nrecommends) -> returns recommends_str[index]
10126 + *   [npredepends+nrecommends,npredepends+nrecommends+nsuggests) -> returns recommends_str[index]
10127 + *   [npredepends+nrecommends+nsuggests,npredepends+nrecommends+nsuggests+ndepends) -> returns depends_str[index]
10128 + */
10129 +char *pkg_depend_str(pkg_t *pkg, int pkg_index)
10130 +{
10131 +     if (pkg_index < pkg->pre_depends_count) {
10132 +         return pkg->pre_depends_str[pkg_index];
10133 +     }
10134 +     pkg_index -= pkg->pre_depends_count;
10135 +
10136 +     if (pkg_index < pkg->recommends_count) {
10137 +         return pkg->recommends_str[pkg_index];
10138 +     }
10139 +     pkg_index -= pkg->recommends_count;
10140 +
10141 +     if (pkg_index < pkg->suggests_count) {
10142 +         return pkg->suggests_str[pkg_index];
10143 +     }
10144 +     pkg_index -= pkg->suggests_count;
10145 +
10146 +     if (pkg_index < pkg->depends_count) {
10147 +         return pkg->depends_str[pkg_index];
10148 +     }
10149 +     fprintf(stderr, "pkg_depend_str: index %d out of range for pkg=%s\n", pkg_index, pkg->name);
10150 +     return NULL;
10151 +}
10152 +
10153 +void freeDepends(pkg_t *pkg)
10154 +{
10155 +    int i;
10156 +
10157 +    if (pkg == NULL || pkg->depends == NULL) {
10158 +       return;
10159 +    }
10160 +
10161 +    fprintf(stderr, "Freeing depends=%p\n", pkg->depends);
10162 +    for (i=0; i < pkg->depends->possibility_count; i++) {
10163 +       depend_deinit(pkg->depends->possibilities[i]);
10164 +    }
10165 +    free(pkg->depends->possibilities);
10166 +    free(pkg->depends);
10167 +    pkg->depends = NULL;
10168 +}
10169 +
10170 +void buildDependedUponBy(pkg_t * pkg, abstract_pkg_t * ab_pkg)
10171 +{
10172 +     compound_depend_t * depends;
10173 +     int count, othercount;
10174 +     register int i, j;
10175 +     abstract_pkg_t * ab_depend;
10176 +     abstract_pkg_t ** temp;
10177 +
10178 +     count = pkg->pre_depends_count + pkg->depends_count;
10179 +     depends = pkg->depends;
10180 +
10181 +         if (0 && pkg->pre_depends_count)
10182 +              fprintf(stderr, "pkg=%s pre_depends_count=%d depends_count=%d\n",
10183 +                      pkg->name, pkg->pre_depends_count, pkg->depends_count);
10184 +     for (i = 0; i < count; i++) {
10185 +         if (0 && pkg->pre_depends_count)
10186 +              fprintf(stderr, "  i=%d possibility_count=%x depends=%p\n", i, depends->possibility_count, depends);
10187 +         for (j = 0; j < depends->possibility_count; j++){
10188 +              ab_depend = depends->possibilities[j]->pkg;
10189 +              if(!ab_depend->depended_upon_by)
10190 +                   ab_depend->depended_upon_by = (abstract_pkg_t **)calloc(1, sizeof(abstract_pkg_t *));
10191 +
10192 +              temp = ab_depend->depended_upon_by;
10193 +              othercount = 1;
10194 +              while(*temp){
10195 +                   temp++;
10196 +                   othercount++;
10197 +              }
10198 +              *temp = ab_pkg;
10199 +
10200 +              ab_depend->depended_upon_by = (abstract_pkg_t **)realloc(ab_depend->depended_upon_by,
10201 +                                                                       (othercount + 1) * sizeof(abstract_pkg_t *));
10202 +              /* the array may have moved */
10203 +              temp = ab_depend->depended_upon_by + othercount;
10204 +              *temp = NULL;
10205 +         }
10206 +         depends++;
10207 +     }
10208 +}
10209 +
10210 +static depend_t * depend_init(void)
10211 +{
10212 +    depend_t * d = (depend_t *)malloc(sizeof(depend_t));
10213 +    if ( d==NULL ){
10214 +        fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
10215 +        return NULL;
10216 +     }
10217 +    d->constraint = NONE;
10218 +    d->version = NULL;
10219 +    d->pkg = NULL;
10220 +
10221 +    return d;
10222 +}
10223 +
10224 +static void depend_deinit(depend_t *d)
10225 +{
10226 +    free(d);
10227 +}
10228 +
10229 +static int parseDepends(compound_depend_t *compound_depend,
10230 +                       hash_table_t * hash, char * depend_str)
10231 +{
10232 +     char * pkg_name, buffer[2048];
10233 +     int num_of_ors = 0;
10234 +     register int i;
10235 +     register char * src, * dest;
10236 +     depend_t ** possibilities;
10237 +
10238 +     /* first count the number of ored possibilities for satisfying dependency */
10239 +     src = depend_str;
10240 +     while(*src)
10241 +         if(*src++ == '|')
10242 +              num_of_ors++;
10243 +
10244 +     compound_depend->type = DEPEND;
10245 +
10246 +     compound_depend->possibility_count = num_of_ors + 1;
10247 +     possibilities = (depend_t **)malloc(sizeof(depend_t *) * (num_of_ors + 1));
10248 +     if (!possibilities)
10249 +         return -ENOMEM;
10250 +     compound_depend->possibilities = possibilities;
10251 +
10252 +     src = depend_str;
10253 +     for(i = 0; i < num_of_ors + 1; i++){
10254 +         possibilities[i] = depend_init();
10255 +          if (!possibilities[i])
10256 +              return -ENOMEM;
10257 +         /* gobble up just the name first */
10258 +         dest = buffer;
10259 +         while(*src &&
10260 +               !isspace(*src) &&
10261 +               (*src != '(') &&
10262 +               (*src != '*') &&
10263 +               (*src != '|'))
10264 +              *dest++ = *src++;
10265 +         *dest = '\0';
10266 +         pkg_name = trim_alloc(buffer);
10267 +          if (pkg_name == NULL )
10268 +              return -ENOMEM;
10269 +
10270 +         /* now look at possible version info */
10271 +
10272 +         /* skip to next chars */
10273 +         if(isspace(*src))
10274 +              while(*src && isspace(*src)) src++;
10275 +
10276 +         /* extract constraint and version */
10277 +         if(*src == '('){
10278 +              src++;
10279 +              if(!strncmp(src, "<<", 2)){
10280 +                   possibilities[i]->constraint = EARLIER;
10281 +                   src += 2;
10282 +              }
10283 +              else if(!strncmp(src, "<=", 2)){
10284 +                   possibilities[i]->constraint = EARLIER_EQUAL;
10285 +                   src += 2;
10286 +              }
10287 +              else if(!strncmp(src, ">=", 2)){
10288 +                   possibilities[i]->constraint = LATER_EQUAL;
10289 +                   src += 2;
10290 +              }
10291 +              else if(!strncmp(src, ">>", 2)){
10292 +                   possibilities[i]->constraint = LATER;
10293 +                   src += 2;
10294 +              }
10295 +              else if(!strncmp(src, "=", 1)){
10296 +                   possibilities[i]->constraint = EQUAL;
10297 +                   src++;
10298 +              }
10299 +              /* should these be here to support deprecated designations; dpkg does */
10300 +              else if(!strncmp(src, "<", 1)){
10301 +                   possibilities[i]->constraint = EARLIER_EQUAL;
10302 +                   src++;
10303 +              }
10304 +              else if(!strncmp(src, ">", 1)){
10305 +                   possibilities[i]->constraint = LATER_EQUAL;
10306 +                   src++;
10307 +              }
10308 +
10309 +              /* now we have any constraint, pass space to version string */
10310 +              while(isspace(*src)) src++;
10311 +
10312 +              /* this would be the version string */
10313 +              dest = buffer;
10314 +              while(*src && *src != ')')
10315 +                   *dest++ = *src++;
10316 +              *dest = '\0';
10317 +
10318 +              possibilities[i]->version = trim_alloc(buffer);
10319 +              /*                   fprintf(stderr, "let's print the depends version string:");
10320 +                                   fprintf(stderr, "version %s\n", possibilities[i]->version);*/
10321 +               if (possibilities[i]->version == NULL )
10322 +                   return -ENOMEM;
10323 +
10324 +
10325 +         }
10326 +         /* hook up the dependency to its abstract pkg */
10327 +         possibilities[i]->pkg = ensure_abstract_pkg_by_name(hash, pkg_name);
10328 +
10329 +         free(pkg_name);
10330 +
10331 +         /* now get past the ) and any possible | chars */
10332 +         while(*src &&
10333 +               (isspace(*src) ||
10334 +                (*src == ')') ||
10335 +                (*src == '|')))
10336 +              src++;
10337 +         if (*src == '*')
10338 +         {
10339 +              compound_depend->type = GREEDY_DEPEND;
10340 +              src++;
10341 +         }
10342 +     }
10343 +
10344 +     return 0;
10345 +}
10346 Index: busybox-1.7.2/archival/libipkg/pkg_depends.h
10347 ===================================================================
10348 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
10349 +++ busybox-1.7.2/archival/libipkg/pkg_depends.h        2007-10-04 17:14:23.129059469 +0200
10350 @@ -0,0 +1,105 @@
10351 +/* pkg_depends.h - the itsy package management system
10352 +
10353 +   Steven M. Ayer
10354 +
10355 +   Copyright (C) 2002 Compaq Computer Corporation
10356 +
10357 +   This program is free software; you can redistribute it and/or
10358 +   modify it under the terms of the GNU General Public License as
10359 +   published by the Free Software Foundation; either version 2, or (at
10360 +   your option) any later version.
10361 +
10362 +   This program is distributed in the hope that it will be useful, but
10363 +   WITHOUT ANY WARRANTY; without even the implied warranty of
10364 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10365 +   General Public License for more details.
10366 +*/
10367 +
10368 +#ifndef PKG_DEPENDS_H
10369 +#define PKG_DEPENDS_H
10370 +
10371 +#include "pkg.h"
10372 +#include "pkg_hash.h"
10373 +
10374 +enum depend_type {
10375 +    PREDEPEND,
10376 +    DEPEND,
10377 +    CONFLICTS,
10378 +    GREEDY_DEPEND,
10379 +    RECOMMEND,
10380 +    SUGGEST
10381 +};
10382 +typedef enum depend_type depend_type_t;
10383 +
10384 +enum version_constraint {
10385 +    NONE,
10386 +    EARLIER,
10387 +    EARLIER_EQUAL,
10388 +    EQUAL,
10389 +    LATER_EQUAL,
10390 +    LATER
10391 +};
10392 +typedef enum version_constraint version_constraint_t;
10393 +
10394 +struct depend{
10395 +    version_constraint_t constraint;
10396 +    char * version;
10397 +    abstract_pkg_t * pkg;
10398 +};
10399 +typedef struct depend depend_t;
10400 +
10401 +struct compound_depend{
10402 +    depend_type_t type;
10403 +    int possibility_count;
10404 +    struct depend ** possibilities;
10405 +};
10406 +typedef struct compound_depend compound_depend_t;
10407 +
10408 +#include "hash_table.h"
10409 +
10410 +int buildProvides(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg);
10411 +int buildConflicts(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg);
10412 +int buildReplaces(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg);
10413 +int buildDepends(hash_table_t * hash, pkg_t * pkg);
10414 +
10415 +/**
10416 + * pkg_has_common_provides returns 1 if pkg and replacee both provide
10417 + * the same abstract package and 0 otherwise.
10418 + */
10419 +int pkg_has_common_provides(pkg_t *pkg, pkg_t *replacee);
10420 +
10421 +/**
10422 + * pkg_provides returns 1 if pkg->provides contains providee and 0
10423 + * otherwise.
10424 + */
10425 +int pkg_provides_abstract(pkg_t *pkg, abstract_pkg_t *providee);
10426 +
10427 +/**
10428 + * pkg_replaces returns 1 if pkg->replaces contains one of replacee's provides and 0
10429 + * otherwise.
10430 + */
10431 +int pkg_replaces(pkg_t *pkg, pkg_t *replacee);
10432 +
10433 +/**
10434 + * pkg_conflicts_abstract returns 1 if pkg->conflicts contains conflictee provides and 0
10435 + * otherwise.
10436 + */
10437 +int pkg_conflicts_abstract(pkg_t *pkg, abstract_pkg_t *conflicts);
10438 +
10439 +/**
10440 + * pkg_conflicts returns 1 if pkg->conflicts contains one of conflictee's provides and 0
10441 + * otherwise.
10442 + */
10443 +int pkg_conflicts(pkg_t *pkg, pkg_t *conflicts);
10444 +
10445 +char *pkg_depend_str(pkg_t *pkg, int pkg_index);
10446 +void buildDependedUponBy(pkg_t * pkg, abstract_pkg_t * ab_pkg);
10447 +void freeDepends(pkg_t *pkg);
10448 +void printDepends(pkg_t * pkg);
10449 +int version_constraints_satisfied(depend_t * depends, pkg_t * pkg);
10450 +int pkg_hash_fetch_unsatisfied_dependencies(ipkg_conf_t *conf, pkg_t * pkg, pkg_vec_t *depends, char *** unresolved);
10451 +pkg_vec_t * pkg_hash_fetch_conflicts(hash_table_t * hash, pkg_t * pkg);
10452 +int pkg_dependence_satisfiable(ipkg_conf_t *conf, depend_t *depend);
10453 +int pkg_dependence_satisfied(ipkg_conf_t *conf, depend_t *depend);
10454 +
10455 +#endif
10456 Index: busybox-1.7.2/archival/libipkg/pkg_dest.c
10457 ===================================================================
10458 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
10459 +++ busybox-1.7.2/archival/libipkg/pkg_dest.c   2007-10-04 17:14:23.173061979 +0200
10460 @@ -0,0 +1,92 @@
10461 +/* pkg_dest.c - the itsy package management system
10462 +
10463 +   Carl D. Worth
10464 +
10465 +   Copyright (C) 2001 University of Southern California
10466 +
10467 +   This program is free software; you can redistribute it and/or
10468 +   modify it under the terms of the GNU General Public License as
10469 +   published by the Free Software Foundation; either version 2, or (at
10470 +   your option) any later version.
10471 +
10472 +   This program is distributed in the hope that it will be useful, but
10473 +   WITHOUT ANY WARRANTY; without even the implied warranty of
10474 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10475 +   General Public License for more details.
10476 +*/
10477 +
10478 +#include "ipkg.h"
10479 +
10480 +#include "pkg_dest.h"
10481 +#include "file_util.h"
10482 +#include "str_util.h"
10483 +#include "sprintf_alloc.h"
10484 +
10485 +int pkg_dest_init(pkg_dest_t *dest, const char *name, const char *root_dir,const char * lists_dir)
10486 +{
10487 +    dest->name = strdup(name);
10488 +
10489 +    /* Guarantee that dest->root_dir ends with a '/' */
10490 +    if (str_ends_with(root_dir, "/")) {
10491 +       dest->root_dir = strdup(root_dir);
10492 +    } else {
10493 +       sprintf_alloc(&dest->root_dir, "%s/", root_dir);
10494 +    }
10495 +    file_mkdir_hier(dest->root_dir, 0755);
10496 +
10497 +    sprintf_alloc(&dest->ipkg_dir, "%s%s",
10498 +                 dest->root_dir, IPKG_STATE_DIR_PREFIX);
10499 +    file_mkdir_hier(dest->ipkg_dir, 0755);
10500 +
10501 +    if (str_starts_with (lists_dir, "/"))
10502 +        sprintf_alloc(&dest->lists_dir, "%s", lists_dir);
10503 +    else
10504 +        sprintf_alloc(&dest->lists_dir, "/%s", lists_dir);
10505 +
10506 +    file_mkdir_hier(dest->lists_dir, 0755);
10507 +
10508 +    sprintf_alloc(&dest->info_dir, "%s/%s",
10509 +                 dest->ipkg_dir, IPKG_INFO_DIR_SUFFIX);
10510 +    file_mkdir_hier(dest->info_dir, 0755);
10511 +
10512 +    sprintf_alloc(&dest->status_file_name, "%s/%s",
10513 +                 dest->ipkg_dir, IPKG_STATUS_FILE_SUFFIX);
10514 +
10515 +    sprintf_alloc(&dest->status_file_tmp_name, "%s/%s.tmp",
10516 +                 dest->ipkg_dir, IPKG_STATUS_FILE_SUFFIX);
10517 +
10518 +    dest->status_file = NULL;
10519 +
10520 +    return 0;
10521 +}
10522 +
10523 +void pkg_dest_deinit(pkg_dest_t *dest)
10524 +{
10525 +    free(dest->name);
10526 +    dest->name = NULL;
10527 +
10528 +    free(dest->root_dir);
10529 +    dest->root_dir = NULL;
10530 +
10531 +    free(dest->ipkg_dir);
10532 +    dest->ipkg_dir = NULL;
10533 +
10534 +    free(dest->lists_dir);
10535 +    dest->lists_dir = NULL;
10536 +
10537 +    free(dest->info_dir);
10538 +    dest->info_dir = NULL;
10539 +
10540 +    free(dest->status_file_name);
10541 +    dest->status_file_name = NULL;
10542 +
10543 +    free(dest->status_file_tmp_name);
10544 +    dest->status_file_tmp_name = NULL;
10545 +
10546 +    if (dest->status_file) {
10547 +       fclose(dest->status_file);
10548 +    }
10549 +    dest->status_file = NULL;
10550 +
10551 +    dest->root_dir = NULL;
10552 +}
10553 Index: busybox-1.7.2/archival/libipkg/pkg_dest.h
10554 ===================================================================
10555 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
10556 +++ busybox-1.7.2/archival/libipkg/pkg_dest.h   2007-10-04 17:14:23.197063348 +0200
10557 @@ -0,0 +1,38 @@
10558 +/* pkg_dest.h - the itsy package management system
10559 +
10560 +   Carl D. Worth
10561 +
10562 +   Copyright (C) 2001 University of Southern California
10563 +
10564 +   This program is free software; you can redistribute it and/or
10565 +   modify it under the terms of the GNU General Public License as
10566 +   published by the Free Software Foundation; either version 2, or (at
10567 +   your option) any later version.
10568 +
10569 +   This program is distributed in the hope that it will be useful, but
10570 +   WITHOUT ANY WARRANTY; without even the implied warranty of
10571 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10572 +   General Public License for more details.
10573 +*/
10574 +
10575 +#ifndef PKG_DEST_H
10576 +#define PKG_DEST_H
10577 +
10578 +typedef struct pkg_dest pkg_dest_t;
10579 +struct pkg_dest
10580 +{
10581 +    char *name;
10582 +    char *root_dir;
10583 +    char *ipkg_dir;
10584 +    char *lists_dir;
10585 +    char *info_dir;
10586 +    char *status_file_name;
10587 +    char *status_file_tmp_name;
10588 +    FILE *status_file;
10589 +};
10590 +
10591 +int pkg_dest_init(pkg_dest_t *dest, const char *name, const char *root_dir,const char *lists_dir);
10592 +void pkg_dest_deinit(pkg_dest_t *dest);
10593 +
10594 +#endif
10595 +
10596 Index: busybox-1.7.2/archival/libipkg/pkg_dest_list.c
10597 ===================================================================
10598 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
10599 +++ busybox-1.7.2/archival/libipkg/pkg_dest_list.c      2007-10-04 17:14:23.213064259 +0200
10600 @@ -0,0 +1,85 @@
10601 +/* pkg_dest_list.c - the itsy package management system
10602 +
10603 +   Carl D. Worth
10604 +
10605 +   Copyright (C) 2001 University of Southern California
10606 +
10607 +   This program is free software; you can redistribute it and/or
10608 +   modify it under the terms of the GNU General Public License as
10609 +   published by the Free Software Foundation; either version 2, or (at
10610 +   your option) any later version.
10611 +
10612 +   This program is distributed in the hope that it will be useful, but
10613 +   WITHOUT ANY WARRANTY; without even the implied warranty of
10614 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10615 +   General Public License for more details.
10616 +*/
10617 +
10618 +#include "ipkg.h"
10619 +
10620 +#include "pkg_dest.h"
10621 +#include "void_list.h"
10622 +#include "pkg_dest_list.h"
10623 +
10624 +int pkg_dest_list_elt_init(pkg_dest_list_elt_t *elt, pkg_dest_t *data)
10625 +{
10626 +    return void_list_elt_init((void_list_elt_t *) elt, data);
10627 +}
10628 +
10629 +void pkg_dest_list_elt_deinit(pkg_dest_list_elt_t *elt)
10630 +{
10631 +    void_list_elt_deinit((void_list_elt_t *) elt);
10632 +}
10633 +
10634 +int pkg_dest_list_init(pkg_dest_list_t *list)
10635 +{
10636 +    return void_list_init((void_list_t *) list);
10637 +}
10638 +
10639 +void pkg_dest_list_deinit(pkg_dest_list_t *list)
10640 +{
10641 +    pkg_dest_list_elt_t *iter;
10642 +    pkg_dest_t *pkg_dest;
10643 +
10644 +    for (iter = list->head; iter; iter = iter->next) {
10645 +       pkg_dest = iter->data;
10646 +       pkg_dest_deinit(pkg_dest);
10647 +
10648 +       /* malloced in pkg_dest_list_append */
10649 +       free(pkg_dest);
10650 +       iter->data = NULL;
10651 +    }
10652 +    void_list_deinit((void_list_t *) list);
10653 +}
10654 +
10655 +pkg_dest_t *pkg_dest_list_append(pkg_dest_list_t *list, const char *name,
10656 +                                const char *root_dir,const char *lists_dir)
10657 +{
10658 +    int err;
10659 +    pkg_dest_t *pkg_dest;
10660 +
10661 +    /* freed in plg_dest_list_deinit */
10662 +    pkg_dest = malloc(sizeof(pkg_dest_t));
10663 +    if (pkg_dest == NULL) {
10664 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
10665 +       return NULL;
10666 +    }
10667 +
10668 +    pkg_dest_init(pkg_dest, name, root_dir,lists_dir);
10669 +    err = void_list_append((void_list_t *) list, pkg_dest);
10670 +    if (err) {
10671 +       return NULL;
10672 +    }
10673 +
10674 +    return pkg_dest;
10675 +}
10676 +
10677 +int pkg_dest_list_push(pkg_dest_list_t *list, pkg_dest_t *data)
10678 +{
10679 +    return void_list_push((void_list_t *) list, data);
10680 +}
10681 +
10682 +pkg_dest_list_elt_t *pkg_dest_list_pop(pkg_dest_list_t *list)
10683 +{
10684 +    return (pkg_dest_list_elt_t *) void_list_pop((void_list_t *) list);
10685 +}
10686 Index: busybox-1.7.2/archival/libipkg/pkg_dest_list.h
10687 ===================================================================
10688 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
10689 +++ busybox-1.7.2/archival/libipkg/pkg_dest_list.h      2007-10-04 17:14:23.229065168 +0200
10690 @@ -0,0 +1,50 @@
10691 +/* pkg_dest_list.h - the itsy package management system
10692 +
10693 +   Carl D. Worth
10694 +
10695 +   Copyright (C) 2001 University of Southern California
10696 +
10697 +   This program is free software; you can redistribute it and/or
10698 +   modify it under the terms of the GNU General Public License as
10699 +   published by the Free Software Foundation; either version 2, or (at
10700 +   your option) any later version.
10701 +
10702 +   This program is distributed in the hope that it will be useful, but
10703 +   WITHOUT ANY WARRANTY; without even the implied warranty of
10704 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10705 +   General Public License for more details.
10706 +*/
10707 +
10708 +#ifndef PKG_DEST_LIST_H
10709 +#define PKG_DEST_LIST_H
10710 +
10711 +#include "pkg_dest.h"
10712 +
10713 +typedef struct pkg_dest_list_elt pkg_dest_list_elt_t;
10714 +struct pkg_dest_list_elt
10715 +{
10716 +    pkg_dest_list_elt_t *next;
10717 +    pkg_dest_t *data;
10718 +};
10719 +
10720 +typedef struct pkg_dest_list pkg_dest_list_t;
10721 +struct pkg_dest_list
10722 +{
10723 +    pkg_dest_list_elt_t pre_head;
10724 +    pkg_dest_list_elt_t *head;
10725 +    pkg_dest_list_elt_t *tail;
10726 +};
10727 +
10728 +int pkg_dest_list_elt_init(pkg_dest_list_elt_t *elt, pkg_dest_t *data);
10729 +void pkg_dest_list_elt_deinit(pkg_dest_list_elt_t *elt);
10730 +
10731 +int pkg_dest_list_init(pkg_dest_list_t *list);
10732 +void pkg_dest_list_deinit(pkg_dest_list_t *list);
10733 +
10734 +pkg_dest_t *pkg_dest_list_append(pkg_dest_list_t *list, const char *name,
10735 +                                const char *root_dir,const char* lists_dir);
10736 +int pkg_dest_list_push(pkg_dest_list_t *list, pkg_dest_t *data);
10737 +pkg_dest_list_elt_t *pkg_dest_list_pop(pkg_dest_list_t *list);
10738 +
10739 +#endif
10740 +
10741 Index: busybox-1.7.2/archival/libipkg/pkg_extract.c
10742 ===================================================================
10743 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
10744 +++ busybox-1.7.2/archival/libipkg/pkg_extract.c        2007-10-04 17:14:23.245066087 +0200
10745 @@ -0,0 +1,224 @@
10746 +/* pkg_extract.c - the itsy package management system
10747 +
10748 +   Carl D. Worth
10749 +
10750 +   Copyright (C) 2001 University of Southern California
10751 +
10752 +   This program is free software; you can redistribute it and/or
10753 +   modify it under the terms of the GNU General Public License as
10754 +   published by the Free Software Foundation; either version 2, or (at
10755 +   your option) any later version.
10756 +
10757 +   This program is distributed in the hope that it will be useful, but
10758 +   WITHOUT ANY WARRANTY; without even the implied warranty of
10759 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10760 +   General Public License for more details.
10761 +*/
10762 +
10763 +#include "ipkg.h"
10764 +#include <errno.h>
10765 +#include <fcntl.h>
10766 +#include <stdio.h>
10767 +
10768 +#include "pkg_extract.h"
10769 +
10770 +#include "libbb.h"
10771 +#include "file_util.h"
10772 +#include "sprintf_alloc.h"
10773 +#include "unarchive.h"
10774 +
10775 +#define IPKG_CONTROL_ARCHIVE  "control.tar.gz"
10776 +#define IPKG_DATA_ARCHIVE  "data.tar.gz"
10777 +#define IPKG_CONTROL_FILE  "control"
10778 +
10779 +static void extract_ipkg_file_to_dir(pkg_t *pkg, const char *dir, const char *filename)
10780 +{
10781 +       archive_handle_t *archive;
10782 +       char *path;
10783 +
10784 +       sprintf_alloc(&path, "%s/", dir);
10785 +       archive = init_handle();
10786 +       archive->src_fd = xopen(pkg->local_filename, O_RDONLY);
10787 +       archive->filter = filter_accept_list;
10788 +       llist_add_to(&(archive->accept), (char *)filename);
10789 +       archive->buffer = path;
10790 +       archive->action_data = data_extract_all_prefix;
10791 +       archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
10792 +       while( get_header_tar_gz(archive) == EXIT_SUCCESS );
10793 +       close(archive->src_fd);
10794 +       free(archive->accept);
10795 +       free(archive);
10796 +       free(path);
10797 +}
10798 +
10799 +static void data_extract_file_name_to_buffer(archive_handle_t *archive)
10800 +{
10801 +       unsigned int size = strlen(archive->file_header->name) + 2;
10802 +
10803 +       if (archive->buffer == NULL) {
10804 +               archive->buffer = xmalloc(size);
10805 +               strcpy(archive->buffer, archive->file_header->name);
10806 +       } else {
10807 +               size += strlen(archive->buffer);
10808 +               archive->buffer = xrealloc(archive->buffer, size);
10809 +               strcat(archive->buffer, archive->file_header->name);
10810 +       }
10811 +       strcat(archive->buffer, "\n");
10812 +       data_skip(archive);
10813 +}
10814 +
10815 +int pkg_extract_control_file_to_stream(pkg_t *pkg, FILE *stream)
10816 +{
10817 +       archive_handle_t *archive;
10818 +       char *name;
10819 +
10820 +       extract_ipkg_file_to_dir(pkg, global_conf->tmp_dir, "./" IPKG_CONTROL_ARCHIVE);
10821 +       sprintf_alloc(&name, "%s/%s", global_conf->tmp_dir, IPKG_CONTROL_ARCHIVE);
10822 +       archive = init_handle();
10823 +       archive->src_fd = xopen(name, O_RDONLY);
10824 +       archive->filter = filter_accept_list;
10825 +       llist_add_to(&(archive->accept), "./" IPKG_CONTROL_FILE);
10826 +       archive->action_data = data_extract_to_buffer;
10827 +       while( get_header_tar_gz(archive) == EXIT_SUCCESS );
10828 +       close(archive->src_fd);
10829 +       fputs(archive->buffer, stream);
10830 +       free(archive->buffer);
10831 +       free(archive->accept);
10832 +       free(archive);
10833 +       free(name);
10834 +
10835 +       return 0;
10836 +}
10837 +
10838 +int pkg_extract_control_files_to_dir(pkg_t *pkg, const char *dir)
10839 +{
10840 +    return pkg_extract_control_files_to_dir_with_prefix(pkg, dir, "");
10841 +}
10842 +
10843 +int pkg_extract_control_files_to_dir_with_prefix(pkg_t *pkg, const char *dir, const char *prefix)
10844 +{
10845 +       archive_handle_t *archive;
10846 +       char *name;
10847 +       char *path;
10848 +
10849 +       extract_ipkg_file_to_dir(pkg, global_conf->tmp_dir, "./" IPKG_CONTROL_ARCHIVE);
10850 +       sprintf_alloc(&name, "%s/%s", global_conf->tmp_dir, IPKG_CONTROL_ARCHIVE);
10851 +       sprintf_alloc(&path, "%s/%s", dir, prefix);
10852 +       archive = init_handle();
10853 +       archive->src_fd = xopen(name, O_RDONLY);
10854 +       archive->filter = filter_accept_all;
10855 +       archive->buffer = path;
10856 +       archive->action_data = data_extract_all_prefix;
10857 +       archive->flags |= ARCHIVE_CREATE_LEADING_DIRS | ARCHIVE_PRESERVE_DATE | ARCHIVE_EXTRACT_UNCONDITIONAL;
10858 +       while( get_header_tar_gz(archive) == EXIT_SUCCESS );
10859 +       close(archive->src_fd);
10860 +       free(archive);
10861 +       free(path);
10862 +       free(name);
10863 +
10864 +       return 0;
10865 +}
10866 +
10867 +int pkg_extract_data_files_to_dir(pkg_t *pkg, const char *dir)
10868 +{
10869 +       archive_handle_t *archive;
10870 +       char *name;
10871 +       char *path;
10872 +
10873 +       extract_ipkg_file_to_dir(pkg, global_conf->tmp_dir, "./" IPKG_DATA_ARCHIVE);
10874 +       sprintf_alloc(&name, "%s/%s", global_conf->tmp_dir, IPKG_DATA_ARCHIVE);
10875 +       sprintf_alloc(&path, "%s/", dir);
10876 +       archive = init_handle();
10877 +       archive->src_fd = xopen(name, O_RDONLY);
10878 +       archive->filter = filter_accept_all;
10879 +       archive->buffer = path;
10880 +       archive->action_data = data_extract_all_prefix;
10881 +       archive->flags |= ARCHIVE_CREATE_LEADING_DIRS | ARCHIVE_PRESERVE_DATE | ARCHIVE_EXTRACT_UNCONDITIONAL;
10882 +       while( get_header_tar_gz(archive) == EXIT_SUCCESS );
10883 +       close(archive->src_fd);
10884 +       free(archive);
10885 +       free(path);
10886 +       free(name);
10887 +
10888 +       return 0;
10889 +}
10890 +
10891 +int pkg_extract_data_file_names_to_file(pkg_t *pkg, const char *file_name)
10892 +{
10893 +     int err=0;
10894 +     char *line, *data_file;
10895 +     FILE *file;
10896 +     FILE *tmp;
10897 +
10898 +     file = fopen(file_name, "w");
10899 +     if (file == NULL) {
10900 +         fprintf(stderr, "%s: ERROR: Failed to open %s for writing.\n",
10901 +                 __FUNCTION__, file_name);
10902 +         return EINVAL;
10903 +     }
10904 +
10905 +     tmp = tmpfile();
10906 +     if (pkg->installed_files) {
10907 +         str_list_elt_t *elt;
10908 +         for (elt = pkg->installed_files->head; elt; elt = elt->next) {
10909 +              fprintf(file, "%s\n", elt->data);
10910 +         }
10911 +     } else {
10912 +         err = pkg_extract_data_file_names_to_stream(pkg, tmp);
10913 +         if (err) {
10914 +              fclose(file);
10915 +              fclose(tmp);
10916 +              return err;
10917 +         }
10918 +
10919 +         /* Fixup data file names by removing the initial '.' */
10920 +         rewind(tmp);
10921 +         while (1) {
10922 +              line = file_read_line_alloc(tmp);
10923 +              if (line == NULL) {
10924 +                   break;
10925 +              }
10926 +
10927 +              data_file = line;
10928 +              if (*data_file == '.') {
10929 +                   data_file++;
10930 +              }
10931 +
10932 +              if (*data_file != '/') {
10933 +                   fputs("/", file);
10934 +              }
10935 +
10936 +              /* I have no idea why, but this is what dpkg does */
10937 +              if (strcmp(data_file, "/\n") == 0) {
10938 +                   fputs("/.\n", file);
10939 +              } else {
10940 +                   fputs(data_file, file);
10941 +              }
10942 +         }
10943 +     }
10944 +     fclose(tmp);
10945 +     fclose(file);
10946 +
10947 +     return err;
10948 +}
10949 +
10950 +int pkg_extract_data_file_names_to_stream(pkg_t *pkg, FILE *file)
10951 +{
10952 +       archive_handle_t *archive;
10953 +       char *name;
10954 +
10955 +       extract_ipkg_file_to_dir(pkg, global_conf->tmp_dir, "./" IPKG_DATA_ARCHIVE);
10956 +       sprintf_alloc(&name, "%s/%s", global_conf->tmp_dir, IPKG_DATA_ARCHIVE);
10957 +       archive = init_handle();
10958 +       archive->src_fd = xopen(name, O_RDONLY);
10959 +       archive->filter = filter_accept_all;
10960 +       archive->action_data = data_extract_file_name_to_buffer;
10961 +       while( get_header_tar_gz(archive) == EXIT_SUCCESS );
10962 +       close(archive->src_fd);
10963 +       fputs(archive->buffer, file);
10964 +       free(archive->buffer);
10965 +       free(archive);
10966 +       free(name);
10967 +
10968 +       return 0;
10969 +}
10970 Index: busybox-1.7.2/archival/libipkg/pkg_extract.h
10971 ===================================================================
10972 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
10973 +++ busybox-1.7.2/archival/libipkg/pkg_extract.h        2007-10-04 17:14:23.265067225 +0200
10974 @@ -0,0 +1,32 @@
10975 +/* pkg_extract.c - the itsy package management system
10976 +
10977 +   Carl D. Worth
10978 +
10979 +   Copyright (C) 2001 University of Southern California
10980 +
10981 +   This program is free software; you can redistribute it and/or
10982 +   modify it under the terms of the GNU General Public License as
10983 +   published by the Free Software Foundation; either version 2, or (at
10984 +   your option) any later version.
10985 +
10986 +   This program is distributed in the hope that it will be useful, but
10987 +   WITHOUT ANY WARRANTY; without even the implied warranty of
10988 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10989 +   General Public License for more details.
10990 +*/
10991 +
10992 +#ifndef PKG_EXTRACT_H
10993 +#define PKG_EXTRACT_H
10994 +
10995 +#include "pkg.h"
10996 +
10997 +int pkg_extract_control_file_to_stream(pkg_t *pkg, FILE *stream);
10998 +int pkg_extract_control_files_to_dir(pkg_t *pkg, const char *dir);
10999 +int pkg_extract_control_files_to_dir_with_prefix(pkg_t *pkg,
11000 +                                                const char *dir,
11001 +                                                const char *prefix);
11002 +int pkg_extract_data_files_to_dir(pkg_t *pkg, const char *dir);
11003 +int pkg_extract_data_file_names_to_file(pkg_t *pkg, const char *file_name);
11004 +int pkg_extract_data_file_names_to_stream(pkg_t *pkg, FILE *file);
11005 +
11006 +#endif
11007 Index: busybox-1.7.2/archival/libipkg/pkg.h
11008 ===================================================================
11009 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
11010 +++ busybox-1.7.2/archival/libipkg/pkg.h        2007-10-04 17:22:15.623985424 +0200
11011 @@ -0,0 +1,229 @@
11012 +/* pkg.h - the itsy package management system
11013 +
11014 +   Carl D. Worth
11015 +
11016 +   Copyright (C) 2001 University of Southern California
11017 +
11018 +   This program is free software; you can redistribute it and/or
11019 +   modify it under the terms of the GNU General Public License as
11020 +   published by the Free Software Foundation; either version 2, or (at
11021 +   your option) any later version.
11022 +
11023 +   This program is distributed in the hope that it will be useful, but
11024 +   WITHOUT ANY WARRANTY; without even the implied warranty of
11025 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11026 +   General Public License for more details.
11027 +*/
11028 +
11029 +#ifndef PKG_H
11030 +#define PKG_H
11031 +
11032 +#include <sys/types.h>
11033 +#include <sys/stat.h>
11034 +#include <unistd.h>
11035 +
11036 +#include "pkg_vec.h"
11037 +#include "str_list.h"
11038 +#include "pkg_src.h"
11039 +#include "pkg_dest.h"
11040 +#include "ipkg_conf.h"
11041 +#include "conffile_list.h"
11042 +
11043 +struct ipkg_conf;
11044 +
11045 +/* I think "Size" is currently the shortest field name */
11046 +#define PKG_MINIMUM_FIELD_NAME_LEN 4
11047 +
11048 +enum pkg_state_want
11049 +{
11050 +    SW_UNKNOWN = 1,
11051 +    SW_INSTALL,
11052 +    SW_DEINSTALL,
11053 +    SW_PURGE,
11054 +    SW_LAST_STATE_WANT
11055 +};
11056 +typedef enum pkg_state_want pkg_state_want_t;
11057 +
11058 +enum pkg_state_flag
11059 +{
11060 +    SF_OK        = 0,
11061 +    SF_REINSTREQ = 1,
11062 +    SF_HOLD      = 2,  /* do not upgrade version */
11063 +    SF_REPLACE   = 4,  /* replace this package */
11064 +    SF_NOPRUNE   = 8,  /* do not remove obsolete files */
11065 +    SF_PREFER    = 16, /* prefer this version */
11066 +    SF_OBSOLETE  = 32, /* old package in upgrade pair */
11067 +    SF_MARKED    = 64, /* temporary mark */
11068 +    SF_FILELIST_CHANGED = 128, /* needs filelist written */
11069 +    SF_USER      = 256,
11070 +    SF_LAST_STATE_FLAG
11071 +};
11072 +typedef enum pkg_state_flag pkg_state_flag_t;
11073 +#define SF_NONVOLATILE_FLAGS (SF_HOLD|SF_NOPRUNE|SF_PREFER|SF_OBSOLETE|SF_USER)
11074 +
11075 +enum pkg_state_status
11076 +{
11077 +    SS_NOT_INSTALLED = 1,
11078 +    SS_UNPACKED,
11079 +    SS_HALF_CONFIGURED,
11080 +    SS_INSTALLED,
11081 +    SS_HALF_INSTALLED,
11082 +    SS_CONFIG_FILES,
11083 +    SS_POST_INST_FAILED,
11084 +    SS_REMOVAL_FAILED,
11085 +    SS_LAST_STATE_STATUS
11086 +};
11087 +typedef enum pkg_state_status pkg_state_status_t;
11088 +
11089 +struct abstract_pkg{
11090 +    char * name;
11091 +    int dependencies_checked;
11092 +    pkg_vec_t * pkgs;
11093 +    pkg_state_status_t state_status;
11094 +    pkg_state_flag_t state_flag;
11095 +    struct abstract_pkg ** depended_upon_by; /* @@@@ this should be abstract_pkg_vec_t -Jamey */
11096 +    abstract_pkg_vec_t * provided_by;
11097 +    abstract_pkg_vec_t * replaced_by;
11098 +};
11099 +
11100 +#include "pkg_depends.h"
11101 +
11102 +/* XXX: CLEANUP: I'd like to clean up pkg_t in several ways:
11103 +
11104 +   The 3 version fields should go into a single version struct. (This
11105 +   is especially important since, currently, pkg->version can easily
11106 +   be mistaken for pkg_verson_str_alloc(pkg) although they are very
11107 +   distinct. This has been the source of multiple bugs.
11108 +
11109 +   The 3 state fields could possibly also go into their own struct.
11110 +
11111 +   All fields which deal with lists of packages, (Depends,
11112 +   Pre-Depends, Provides, Suggests, Recommends, Enhances), should each
11113 +   be handled by a single struct in pkg_t
11114 +
11115 +   All string fields for which there is a small set of possible
11116 +   values, (section, maintainer, architecture, maybe version?), that
11117 +   are reused among different packages -- for all such packages we
11118 +   should move from "char *"s to some atom datatype to share data
11119 +   storage and use less memory. We might even do reference counting,
11120 +   but probably not since most often we only create new pkg_t structs,
11121 +   we don't often free them.  */
11122 +struct pkg
11123 +{
11124 +     char *name;
11125 +     unsigned long epoch;
11126 +     char *version;
11127 +     char *revision;
11128 +     char *familiar_revision;
11129 +     pkg_src_t *src;
11130 +     pkg_dest_t *dest;
11131 +     char *architecture;
11132 +     char *section;
11133 +     char *maintainer;
11134 +     char *description;
11135 +     pkg_state_want_t state_want;
11136 +     pkg_state_flag_t state_flag;
11137 +     pkg_state_status_t state_status;
11138 +     char **depends_str;
11139 +     int depends_count;
11140 +     char **pre_depends_str;
11141 +     int pre_depends_count;
11142 +     char **recommends_str;
11143 +     int recommends_count;
11144 +     char **suggests_str;
11145 +     int suggests_count;
11146 +     compound_depend_t * depends;
11147 +
11148 +     /* Abhaya: new conflicts */
11149 +     char **conflicts_str;
11150 +     compound_depend_t * conflicts;
11151 +     int conflicts_count;
11152 +
11153 +     char **replaces_str;
11154 +     int replaces_count;
11155 +     abstract_pkg_t ** replaces;
11156 +
11157 +     char **provides_str;
11158 +     int provides_count;
11159 +     abstract_pkg_t ** provides;
11160 +
11161 +     abstract_pkg_t *parent;
11162 +
11163 +     pkg_t *old_pkg; /* during upgrade, points from installee to previously installed */
11164 +
11165 +     char *filename;
11166 +     char *local_filename;
11167 +     char *url;
11168 +     char *tmp_unpack_dir;
11169 +     char *md5sum;
11170 +     char *size;
11171 +     char *installed_size;
11172 +     char *priority;
11173 +     char *source;
11174 +     conffile_list_t conffiles;
11175 +     time_t installed_time;
11176 +     /* As pointer for lazy evaluation */
11177 +     str_list_t *installed_files;
11178 +     /* XXX: CLEANUP: I'd like to perhaps come up with a better
11179 +       mechanism to avoid the problem here, (which is that the
11180 +       installed_files list was being freed from an inner loop while
11181 +       still being used within an outer loop. */
11182 +     int installed_files_ref_cnt;
11183 +     int essential;
11184 +     int arch_priority;
11185 +/* Adding this flag, to "force" ipkg to choose a "provided_by_hand" package, if there are multiple choice */
11186 +     int provided_by_hand;
11187 +};
11188 +
11189 +pkg_t *pkg_new(void);
11190 +int pkg_init(pkg_t *pkg);
11191 +void pkg_deinit(pkg_t *pkg);
11192 +int pkg_init_from_file(pkg_t *pkg, const char *filename);
11193 +abstract_pkg_t *abstract_pkg_new(void);
11194 +int abstract_pkg_init(abstract_pkg_t *ab_pkg);
11195 +
11196 +/*
11197 + * merges fields from newpkg into oldpkg.
11198 + * Forcibly sets oldpkg state_status, state_want and state_flags if set_status is nonzero
11199 + */
11200 +int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status);
11201 +
11202 +char *pkg_version_str_alloc(pkg_t *pkg);
11203 +
11204 +int pkg_compare_versions(const pkg_t *pkg, const pkg_t *ref_pkg);
11205 +int pkg_name_version_and_architecture_compare(pkg_t *a, pkg_t *b);
11206 +int abstract_pkg_name_compare(abstract_pkg_t *a, abstract_pkg_t *b);
11207 +
11208 +char * pkg_formatted_info(pkg_t *pkg );
11209 +char * pkg_formatted_field(pkg_t *pkg, const char *field );
11210 +
11211 +void set_flags_from_control(ipkg_conf_t *conf, pkg_t *pkg);
11212 +
11213 +void pkg_print_info(pkg_t *pkg, FILE *file);
11214 +void pkg_print_status(pkg_t * pkg, FILE * file);
11215 +void pkg_print_field(pkg_t *pkg, FILE *file, const char *field);
11216 +str_list_t *pkg_get_installed_files(pkg_t *pkg);
11217 +int pkg_free_installed_files(pkg_t *pkg);
11218 +int pkg_remove_installed_files_list(ipkg_conf_t *conf, pkg_t *pkg);
11219 +conffile_t *pkg_get_conffile(pkg_t *pkg, const char *file_name);
11220 +int pkg_run_script(struct ipkg_conf *conf, pkg_t *pkg,
11221 +                  const char *script, const char *args);
11222 +
11223 +/* enum mappings */
11224 +char *pkg_state_want_to_str(pkg_state_want_t sw);
11225 +pkg_state_want_t pkg_state_want_from_str(char *str);
11226 +char *pkg_state_flag_to_str(pkg_state_flag_t sf);
11227 +pkg_state_flag_t pkg_state_flag_from_str(char *str);
11228 +char *pkg_state_status_to_str(pkg_state_status_t ss);
11229 +pkg_state_status_t pkg_state_status_from_str(char *str);
11230 +
11231 +int pkg_version_satisfied(pkg_t *it, pkg_t *ref, const char *op);
11232 +
11233 +int pkg_arch_supported(ipkg_conf_t *conf, pkg_t *pkg);
11234 +int pkg_info_preinstall_check(ipkg_conf_t *conf);
11235 +int pkg_free_installed_files(pkg_t *pkg);
11236 +
11237 +int pkg_write_filelist(ipkg_conf_t *conf, pkg_t *pkg);
11238 +int pkg_write_changed_filelists(ipkg_conf_t *conf);
11239 +
11240 +#endif
11241 Index: busybox-1.7.2/archival/libipkg/pkg_hash.c
11242 ===================================================================
11243 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
11244 +++ busybox-1.7.2/archival/libipkg/pkg_hash.c   2007-10-04 17:14:23.329070878 +0200
11245 @@ -0,0 +1,616 @@
11246 +/* ipkg_hash.c - the itsy package management system
11247 +
11248 +   Steven M. Ayer
11249 +
11250 +   Copyright (C) 2002 Compaq Computer Corporation
11251 +
11252 +   This program is free software; you can redistribute it and/or
11253 +   modify it under the terms of the GNU General Public License as
11254 +   published by the Free Software Foundation; either version 2, or (at
11255 +   your option) any later version.
11256 +
11257 +   This program is distributed in the hope that it will be useful, but
11258 +   WITHOUT ANY WARRANTY; without even the implied warranty of
11259 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11260 +   General Public License for more details.
11261 +*/
11262 +
11263 +#include "ipkg.h"
11264 +#include <errno.h>
11265 +#include <ctype.h>
11266 +#include <stdlib.h>
11267 +#include <string.h>
11268 +
11269 +#include "hash_table.h"
11270 +#include "pkg.h"
11271 +#include "ipkg_message.h"
11272 +#include "pkg_vec.h"
11273 +#include "pkg_hash.h"
11274 +#include "pkg_parse.h"
11275 +#include "ipkg_utils.h"
11276 +
11277 +static abstract_pkg_t * add_new_abstract_pkg_by_name(hash_table_t * hash, const char * pkg_name);
11278 +
11279 +/*
11280 + * this will talk to both feeds-lists files and installed status files
11281 + * example api:
11282 + *
11283 + * hash_table_t hash;
11284 + * pkg_hash_init(name, &hash, 1000);
11285 + * pkg_hash_add_from_file(<feed filename>);
11286 + *
11287 + * the query function is just there as a shell to prove to me that this
11288 + * sort of works, but isn't far from doing something useful
11289 + *
11290 + * -sma, 12/21/01
11291 + * modified: CDW 3 Jan. 2002
11292 + */
11293 +
11294 +
11295 +\f
11296 +int pkg_hash_init(const char *name, hash_table_t *hash, int len)
11297 +{
11298 +  return hash_table_init(name, hash, len);
11299 +}
11300 +
11301 +void pkg_hash_deinit(hash_table_t *hash)
11302 +{
11303 +  hash_table_deinit(hash);
11304 +}
11305 +
11306 +
11307 +/* Find the default arch for a given package status file if none is given. */
11308 +static char *pkg_get_default_arch(ipkg_conf_t *conf)
11309 +{
11310 +     nv_pair_list_elt_t *l;
11311 +     char *def_arch = HOST_CPU_STR;            /* Default arch */
11312 +     int def_prio = 0;                         /* Other archs override this */
11313 +
11314 +     l = conf->arch_list.head;
11315 +
11316 +     while (l) {
11317 +         nv_pair_t *nv = l->data;
11318 +         int priority = strtol(nv->value, NULL, 0);
11319 +
11320 +         /* Check if this arch has higher priority, and is valid */
11321 +         if ((priority > def_prio) &&
11322 +             (strcmp(nv->name, "all")) && (strcmp(nv->name, "noarch"))) {
11323 +              /* Our new default */
11324 +              def_prio = priority;
11325 +              def_arch = nv->name;
11326 +         }
11327 +         l = l->next;
11328 +     }
11329 +
11330 +     return strdup(def_arch);
11331 +}
11332 +
11333 +int pkg_hash_add_from_file(ipkg_conf_t *conf, const char *file_name,
11334 +                          pkg_src_t *src, pkg_dest_t *dest, int is_status_file)
11335 +{
11336 +     hash_table_t *hash = &conf->pkg_hash;
11337 +     char **raw;
11338 +     char **raw_start;
11339 +     pkg_t *pkg;
11340 +
11341 +     raw = raw_start = read_raw_pkgs_from_file(file_name);
11342 +     if (!raw)
11343 +        return -ENOMEM;
11344 +
11345 +     while(*raw){         /* don't worry, we'll increment raw in the parsing function */
11346 +         pkg = pkg_new();
11347 +         if (!pkg)
11348 +              return -ENOMEM;
11349 +
11350 +         if (pkg_parse_raw(pkg, &raw, src, dest) == 0) {
11351 +              if (!pkg->architecture) {
11352 +                   char *version_str = pkg_version_str_alloc(pkg);
11353 +                   pkg->architecture = pkg_get_default_arch(conf);
11354 +                   ipkg_message(conf, IPKG_ERROR, "Package %s version %s has no architecture specified, defaulting to %s.\n",
11355 +                                pkg->name, version_str, pkg->architecture);
11356 +                   free(version_str);
11357 +              }
11358 +              hash_insert_pkg(hash, pkg, is_status_file,conf);
11359 +         } else {
11360 +              free(pkg);
11361 +         }
11362 +     }
11363 +
11364 +     /* XXX: CLEANUP: I'd like a cleaner interface for cleaning up
11365 +       memory after read_raw_pkgs_from_file */
11366 +     raw = raw_start;
11367 +     while (*raw) {
11368 +         free(*raw++);
11369 +     }
11370 +     free(raw_start);
11371 +     return 0;
11372 +}
11373 +
11374 +abstract_pkg_t * abstract_pkg_fetch_by_name(hash_table_t * hash, const char * pkg_name)
11375 +{
11376 +  return (abstract_pkg_t *)hash_table_get(hash, pkg_name);
11377 +}
11378 +
11379 +abstract_pkg_vec_t *pkg_hash_fetch_all_installation_candidates(hash_table_t *hash, const char *name)
11380 +{
11381 +    abstract_pkg_t *apkg = abstract_pkg_fetch_by_name(hash, name);
11382 +    if (apkg)
11383 +       return NULL;
11384 +    return apkg->provided_by;
11385 +}
11386 +
11387 +
11388 +pkg_t *pkg_hash_fetch_best_installation_candidate(ipkg_conf_t *conf, abstract_pkg_t *apkg,
11389 +                                                 int (*constraint_fcn)(pkg_t *pkg, void *cdata), void *cdata, int quiet)
11390 +{
11391 +     int i, j;
11392 +     int nprovides = 0;
11393 +     int nmatching = 0;
11394 +     pkg_vec_t *matching_pkgs = pkg_vec_alloc();
11395 +     abstract_pkg_vec_t *matching_apkgs = abstract_pkg_vec_alloc();
11396 +     abstract_pkg_vec_t *provided_apkg_vec;
11397 +     abstract_pkg_t **provided_apkgs;
11398 +     abstract_pkg_vec_t *providers = abstract_pkg_vec_alloc();
11399 +     pkg_t *latest_installed_parent = NULL;
11400 +     pkg_t *latest_matching = NULL;
11401 +     pkg_t *held_pkg = NULL;
11402 +     pkg_t *good_pkg_by_name = NULL;
11403 +
11404 +     if (matching_apkgs == NULL || providers == NULL ||
11405 +         apkg == NULL || apkg->provided_by == NULL || (apkg->provided_by->len == 0))
11406 +         return NULL;
11407 +
11408 +     ipkg_message(conf, IPKG_DEBUG, "best installation candidate for %s\n", apkg->name);
11409 +
11410 +     provided_apkg_vec = apkg->provided_by;
11411 +     nprovides = provided_apkg_vec->len;
11412 +     provided_apkgs = provided_apkg_vec->pkgs;
11413 +     if (nprovides > 1)
11414 +         ipkg_message(conf, IPKG_DEBUG, " apkg=%s nprovides=%d\n", apkg->name, nprovides);
11415 +
11416 +     /* accumulate all the providers */
11417 +     for (i = 0; i < nprovides; i++) {
11418 +         abstract_pkg_t *provider_apkg = provided_apkgs[i];
11419 +         ipkg_message(conf, IPKG_DEBUG, " adding %s to providers\n", provider_apkg->name);
11420 +         abstract_pkg_vec_insert(providers, provider_apkg);
11421 +     }
11422 +     nprovides = providers->len;
11423 +
11424 +     for (i = 0; i < nprovides; i++) {
11425 +         abstract_pkg_t *provider_apkg = abstract_pkg_vec_get(providers, i);
11426 +         abstract_pkg_t *replacement_apkg = NULL;
11427 +         pkg_vec_t *vec;
11428 +
11429 +         if (provider_apkg->replaced_by && provider_apkg->replaced_by->len) {
11430 +              replacement_apkg = provider_apkg->replaced_by->pkgs[0];
11431 +              if (provider_apkg->replaced_by->len > 1) {
11432 +                   ipkg_message(conf, IPKG_NOTICE, "Multiple replacers for %s, using first one (%s)\n",
11433 +                                provider_apkg->name, replacement_apkg->name);
11434 +              }
11435 +         }
11436 +
11437 +         if (replacement_apkg)
11438 +              ipkg_message(conf, IPKG_DEBUG, "   replacement_apkg=%s for provider_apkg=%s\n",
11439 +                           replacement_apkg->name, provider_apkg->name);
11440 +
11441 +         if (replacement_apkg && (replacement_apkg != provider_apkg)) {
11442 +              if (abstract_pkg_vec_contains(providers, replacement_apkg))
11443 +                   continue;
11444 +              else
11445 +                   provider_apkg = replacement_apkg;
11446 +         }
11447 +
11448 +         if (!(vec = provider_apkg->pkgs)) {
11449 +              ipkg_message(conf, IPKG_DEBUG, "   no pkgs for provider_apkg %s\n", provider_apkg->name);
11450 +              continue;
11451 +         }
11452 +
11453 +
11454 +         /* now check for supported architecture */
11455 +         {
11456 +              int max_count = 0;
11457 +
11458 +              /* count packages matching max arch priority and keep track of last one */
11459 +              for (j = 0; j < vec->len; j++) {
11460 +                   pkg_t *maybe = vec->pkgs[j];
11461 +                   ipkg_message(conf, IPKG_DEBUG, "  %s arch=%s arch_priority=%d version=%s  \n",
11462 +                                maybe->name, maybe->architecture, maybe->arch_priority, maybe->version);
11463 +                   if (maybe->arch_priority > 0)  {
11464 +                        max_count++;
11465 +                        abstract_pkg_vec_insert(matching_apkgs, maybe->parent);
11466 +                        pkg_vec_insert(matching_pkgs, maybe);
11467 +                   }
11468 +              }
11469 +         }
11470 +     }
11471 +
11472 +     if (matching_pkgs->len > 1)
11473 +         pkg_vec_sort(matching_pkgs, pkg_name_version_and_architecture_compare);
11474 +     if (matching_apkgs->len > 1)
11475 +         abstract_pkg_vec_sort(matching_pkgs, abstract_pkg_name_compare);
11476 +
11477 +/* Here it is usefull, if ( matching_apkgs->len > 1 ), to test if one of this matching packages has the same name of the
11478 +   needed package. In this case, I would return it for install, otherwise I will continue with the procedure */
11479 +/* The problem is what to do when there are more than a mathing package, with the same name and several version ?
11480 +   Until now I always got the latest, but that breaks the downgrade option.
11481 +   If I stop at the first one, I would probably miss the new ones
11482 +   Maybe the way is to have some kind of flag somewhere, to see if the package been asked to install is from a file,
11483 +   or from a Packages feed.
11484 +   It it is from a file it always need to be checked whatever version I have in feeds or everywhere, according to force-down or whatever options*/
11485 +/*Pigi*/
11486 +
11487 +     for (i = 0; i < matching_pkgs->len; i++) {
11488 +         pkg_t *matching = matching_pkgs->pkgs[i];
11489 +          if (constraint_fcn(matching, cdata)) {  /* We found it */
11490 +             ipkg_message(conf, IPKG_DEBUG, " Found a valid candidate for the install: %s %s  \n", matching->name, matching->version) ;
11491 +             good_pkg_by_name = matching;
11492 +             if ( matching->provided_by_hand == 1 )    /* It has been provided by hand, so it is what user want */
11493 +                break;
11494 +          }
11495 +     }
11496 +
11497 +
11498 +     for (i = 0; i < matching_pkgs->len; i++) {
11499 +         pkg_t *matching = matching_pkgs->pkgs[i];
11500 +         latest_matching = matching;
11501 +         if (matching->parent->state_status == SS_INSTALLED || matching->parent->state_status == SS_UNPACKED)
11502 +              latest_installed_parent = matching;
11503 +         if (matching->state_flag & (SF_HOLD|SF_PREFER)) {
11504 +              if (held_pkg)
11505 +                   ipkg_message(conf, IPKG_ERROR, "Multiple packages (%s and %s) providing same name marked HOLD or PREFER.  Using latest.\n",
11506 +                                held_pkg->name, matching->name);
11507 +              held_pkg = matching;
11508 +         }
11509 +     }
11510 +
11511 +     if (!good_pkg_by_name && !held_pkg && !latest_installed_parent && matching_apkgs->len > 1 && !quiet) {
11512 +         ipkg_message(conf, IPKG_ERROR, "Package=%s, %d matching providers\n",
11513 +                      apkg->name, matching_apkgs->len);
11514 +         for (i = 0; i < matching_apkgs->len; i++) {
11515 +              abstract_pkg_t *matching = matching_apkgs->pkgs[i];
11516 +              ipkg_message(conf, IPKG_ERROR, "    %s\n", matching->name);
11517 +         }
11518 +         ipkg_message(conf, IPKG_ERROR, "Please select one with ipkg install or ipkg flag prefer\n");
11519 +     }
11520 +
11521 +     if (matching_apkgs->len > 1 && conf->verbosity > 1) {
11522 +         ipkg_message(conf, IPKG_NOTICE, "%s: for apkg=%s, %d matching pkgs\n",
11523 +                      __FUNCTION__, apkg->name, matching_pkgs->len);
11524 +         for (i = 0; i < matching_pkgs->len; i++) {
11525 +              pkg_t *matching = matching_pkgs->pkgs[i];
11526 +              ipkg_message(conf, IPKG_INFO, "    %s %s %s\n",
11527 +                           matching->name, matching->version, matching->architecture);
11528 +         }
11529 +     }
11530 +
11531 +     nmatching = matching_apkgs->len;
11532 +
11533 +     pkg_vec_free(matching_pkgs);
11534 +     abstract_pkg_vec_free(matching_apkgs);
11535 +     abstract_pkg_vec_free(providers);
11536 +
11537 +     if (good_pkg_by_name) {   /* We found a good candidate, we will install it */
11538 +         return good_pkg_by_name;
11539 +     }
11540 +     if (held_pkg) {
11541 +         ipkg_message(conf, IPKG_INFO, "  using held package %s\n", held_pkg->name);
11542 +         return held_pkg;
11543 +     }
11544 +     if (latest_installed_parent) {
11545 +         ipkg_message(conf, IPKG_INFO, "  using latest version of installed package %s\n", latest_installed_parent->name);
11546 +         return latest_installed_parent;
11547 +     }
11548 +     if (nmatching > 1) {
11549 +         ipkg_message(conf, IPKG_INFO, "  no matching pkg out of matching_apkgs=%d\n", nmatching);
11550 +         return NULL;
11551 +     }
11552 +     if (latest_matching) {
11553 +         ipkg_message(conf, IPKG_INFO, "  using latest matching %s %s %s\n",
11554 +                      latest_matching->name, latest_matching->version, latest_matching->architecture);
11555 +         return latest_matching;
11556 +     }
11557 +     return NULL;
11558 +}
11559 +
11560 +static int pkg_name_constraint_fcn(pkg_t *pkg, void *cdata)
11561 +{
11562 +     const char *name = (const char *)cdata;
11563 +     if (strcmp(pkg->name, name) == 0)
11564 +         return 1;
11565 +     else
11566 +         return 0;
11567 +}
11568 +
11569 +pkg_t *pkg_hash_fetch_best_installation_candidate_by_name(ipkg_conf_t *conf, const char *name)
11570 +{
11571 +     hash_table_t *hash = &conf->pkg_hash;
11572 +     abstract_pkg_t *apkg = NULL;
11573 +
11574 +     if (!(apkg = abstract_pkg_fetch_by_name(hash, name)))
11575 +         return NULL;
11576 +
11577 +     return pkg_hash_fetch_best_installation_candidate(conf, apkg, pkg_name_constraint_fcn, apkg->name, 0);
11578 +}
11579 +
11580 +
11581 +pkg_t * pkg_hash_fetch_by_name_version(hash_table_t *hash,
11582 +                                      const char *pkg_name,
11583 +                                      const char * version)
11584 +{
11585 +    pkg_vec_t * vec;
11586 +    register int i;
11587 +    char *version_str = NULL;
11588 +
11589 +    if(!(vec = pkg_vec_fetch_by_name(hash, pkg_name)))
11590 +       return NULL;
11591 +
11592 +    for(i = 0; i < vec->len; i++) {
11593 +       version_str = pkg_version_str_alloc(vec->pkgs[i]);
11594 +       if(!strcmp(version_str, version)) {
11595 +           free(version_str);
11596 +           break;
11597 +       }
11598 +       free(version_str);
11599 +    }
11600 +
11601 +    if(i == vec->len)
11602 +       return NULL;
11603 +
11604 +    return vec->pkgs[i];
11605 +}
11606 +
11607 +pkg_t *pkg_hash_fetch_installed_by_name_dest(hash_table_t *hash,
11608 +                                            const char *pkg_name,
11609 +                                            pkg_dest_t *dest)
11610 +{
11611 +    pkg_vec_t * vec;
11612 +    register int i;
11613 +
11614 +    if(!(vec = pkg_vec_fetch_by_name(hash, pkg_name))) {
11615 +       return NULL;
11616 +    }
11617 +
11618 +    for(i = 0; i < vec->len; i++)
11619 +       if((vec->pkgs[i]->state_status == SS_INSTALLED || vec->pkgs[i]->state_status == SS_UNPACKED) && vec->pkgs[i]->dest == dest) {
11620 +           return vec->pkgs[i];
11621 +        }
11622 +    return NULL;
11623 +}
11624 +
11625 +pkg_t *pkg_hash_fetch_installed_by_name(hash_table_t *hash,
11626 +                                       const char *pkg_name)
11627 +{
11628 +    pkg_vec_t * vec;
11629 +    register int i;
11630 +
11631 +    if(!(vec = pkg_vec_fetch_by_name(hash, pkg_name))){
11632 +       return NULL;
11633 +    }
11634 +
11635 +    for(i = 0; i < vec->len; i++)
11636 +       if (vec->pkgs[i]->state_status == SS_INSTALLED || vec->pkgs[i]->state_status == SS_UNPACKED){
11637 +           return vec->pkgs[i];
11638 +        }
11639 +
11640 +    return NULL;
11641 +}
11642 +
11643 +pkg_vec_t *pkg_vec_fetch_by_name(hash_table_t *hash, const char *pkg_name)
11644 +{
11645 +    abstract_pkg_t * ab_pkg;
11646 +
11647 +    if(!(ab_pkg = abstract_pkg_fetch_by_name(hash, pkg_name))){
11648 +       return NULL;
11649 +    }
11650 +
11651 +    if (ab_pkg->pkgs) {
11652 +      return ab_pkg->pkgs;
11653 +    } else if (ab_pkg->provided_by) {
11654 +      abstract_pkg_t *abpkg =  abstract_pkg_vec_get(ab_pkg->provided_by, 0);
11655 +      if (abpkg != NULL){
11656 +         return abpkg->pkgs;
11657 +      } else {
11658 +         return ab_pkg->pkgs;
11659 +      }
11660 +    } else {
11661 +      return NULL;
11662 +    }
11663 +}
11664 +
11665 +static int pkg_compare_names(const void *p1, const void *p2)
11666 +{
11667 +  const pkg_t *pkg1 = *(const pkg_t **)p1;
11668 +  const pkg_t *pkg2 = *(const pkg_t **)p2;
11669 +  if (pkg1->name == NULL)
11670 +    return 1;
11671 +  if (pkg2->name == NULL)
11672 +    return -1;
11673 +  return(strcmp(pkg1->name, pkg2->name));
11674 +}
11675 +
11676 +
11677 +static void pkg_hash_fetch_available_helper(const char *pkg_name, void *entry, void *data)
11678 +{
11679 +  int j;
11680 +  abstract_pkg_t *ab_pkg = (abstract_pkg_t *)entry;
11681 +  pkg_vec_t *all = (pkg_vec_t *)data;
11682 +  pkg_vec_t *pkg_vec = ab_pkg->pkgs;
11683 +  if (pkg_vec) {
11684 +    for (j = 0; j < pkg_vec->len; j++) {
11685 +      pkg_t *pkg = pkg_vec->pkgs[j];
11686 +      pkg_vec_insert(all, pkg);
11687 +    }
11688 +  }
11689 +}
11690 +
11691 +void pkg_hash_fetch_available(hash_table_t *hash, pkg_vec_t *all)
11692 +{
11693 +    hash_table_foreach(hash, pkg_hash_fetch_available_helper, all);
11694 +    qsort(all->pkgs, all->len, sizeof(pkg_t *), pkg_compare_names);
11695 +}
11696 +
11697 +static void pkg_hash_fetch_all_installed_helper(const char *pkg_name, void *entry, void *data)
11698 +{
11699 +  abstract_pkg_t *ab_pkg = (abstract_pkg_t *)entry;
11700 +  pkg_vec_t *all = (pkg_vec_t *)data;
11701 +  pkg_vec_t *pkg_vec = ab_pkg->pkgs;
11702 +  int j;
11703 +  if (pkg_vec) {
11704 +    for (j = 0; j < pkg_vec->len; j++) {
11705 +      pkg_t *pkg = pkg_vec->pkgs[j];
11706 +      if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) {
11707 +       pkg_vec_insert(all, pkg);
11708 +      }
11709 +    }
11710 +  }
11711 +}
11712 +void pkg_hash_fetch_all_installed(hash_table_t *hash, pkg_vec_t *all)
11713 +{
11714 +    hash_table_foreach(hash, pkg_hash_fetch_all_installed_helper, all);
11715 +    qsort(all->pkgs, all->len, sizeof(void*), pkg_compare_names);
11716 +}
11717 +
11718 +static void pkg_hash_dump_helper(const char *pkg_name, void *entry, void *data)
11719 +{
11720 +  int i;
11721 +  pkg_t *pkg;
11722 +  abstract_pkg_t *ab_pkg = (abstract_pkg_t *)entry;
11723 +  ipkg_conf_t *conf = (ipkg_conf_t *)data;
11724 +  abstract_pkg_t ** dependents = ab_pkg->depended_upon_by;
11725 +  fprintf(stdout, "%s\n", ab_pkg->name);
11726 +  i = 0;
11727 +  if (dependents != NULL)
11728 +    while (dependents [i] != NULL)
11729 +      printf ("\tdepended upon by - %s\n", dependents [i ++]->name);
11730 +  dependents = ab_pkg->provided_by->pkgs;
11731 +  i = 0;
11732 +  if (dependents != NULL)
11733 +    while (dependents [i] != NULL && i < ab_pkg->provided_by->len)
11734 +      printf ("\tprovided by - %s\n", dependents [i ++]->name);
11735 +  pkg = pkg_hash_fetch_best_installation_candidate_by_name (conf, ab_pkg->name);
11736 +  if (pkg) {
11737 +    i = 0;
11738 +    while (i < pkg->depends_count)
11739 +      printf ("\tdepends on - %s\n", pkg->depends_str [i ++]);
11740 +  }
11741 +}
11742 +void pkg_hash_dump(hash_table_t *hash, void *data)
11743 +{
11744 +
11745 +  printf ("\n\n+=+%s+=+\n\n", __FUNCTION__);
11746 +  hash_table_foreach(hash, pkg_hash_dump_helper, data);
11747 +  printf ("\n+=+%s+=+\n\n", __FUNCTION__);
11748 +}
11749 +
11750 +abstract_pkg_t * ensure_abstract_pkg_by_name(hash_table_t * hash, const char * pkg_name)
11751 +{
11752 +  abstract_pkg_t * ab_pkg;
11753 +
11754 +  if(!(ab_pkg = abstract_pkg_fetch_by_name(hash, pkg_name)))
11755 +    ab_pkg = add_new_abstract_pkg_by_name(hash, pkg_name);
11756 +
11757 +  return ab_pkg;
11758 +}
11759 +
11760 +pkg_t *hash_insert_pkg(hash_table_t *hash, pkg_t *pkg, int set_status,ipkg_conf_t *conf)
11761 +{
11762 +     abstract_pkg_t * ab_pkg;
11763 +     int arch_priority;
11764 +
11765 +     if(!pkg)
11766 +         return pkg;
11767 +
11768 +     arch_priority = pkg->arch_priority;
11769 +
11770 +     if (buildDepends(hash, pkg)<0){
11771 +        fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
11772 +        return NULL;
11773 +     }
11774 +     ab_pkg = ensure_abstract_pkg_by_name(hash, pkg->name);
11775 +
11776 +     if (set_status) {
11777 +         if (pkg->state_status == SS_INSTALLED) {
11778 +              ab_pkg->state_status = SS_INSTALLED;
11779 +         } else if (pkg->state_status == SS_UNPACKED) {
11780 +              ab_pkg->state_status = SS_UNPACKED;
11781 +         }
11782 +     }
11783 +
11784 +     if(!ab_pkg->pkgs)
11785 +         ab_pkg->pkgs = pkg_vec_alloc();
11786 +
11787 +     /* pkg_vec_insert_merge might munge package, but it returns an unmunged pkg */
11788 +     pkg = pkg_vec_insert_merge(ab_pkg->pkgs, pkg, set_status,conf );
11789 +     pkg->parent = ab_pkg;
11790 +
11791 +     if (buildProvides(hash, ab_pkg, pkg)<0){
11792 +        fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
11793 +        return NULL;
11794 +     }
11795 +     /* need to build the conflicts graph before replaces for correct calculation of replaced_by relation */
11796 +     if (buildConflicts(hash, ab_pkg, pkg)<0){
11797 +        fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
11798 +        return NULL;
11799 +     }
11800 +     if (buildReplaces(hash, ab_pkg, pkg)<0) {
11801 +        fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
11802 +        return NULL;
11803 +     }
11804 +
11805 +     buildDependedUponBy(pkg, ab_pkg);
11806 +     return pkg;
11807 +}
11808 +
11809 +/*
11810 + * this will assume that we've already determined that
11811 + * the abstract pkg doesn't exist, 'cause we should know these things...
11812 + */
11813 +static abstract_pkg_t * add_new_abstract_pkg_by_name(hash_table_t * hash, const char * pkg_name)
11814 +{
11815 +  abstract_pkg_t * ab_pkg;
11816 +
11817 +  ab_pkg = abstract_pkg_new();
11818 +  if (ab_pkg == NULL) { return NULL; }
11819 +
11820 +  ab_pkg->name = strdup(pkg_name);
11821 +  hash_table_insert(hash, pkg_name, ab_pkg);
11822 +
11823 +  return ab_pkg;
11824 +}
11825 +
11826 +
11827 +pkg_t *file_hash_get_file_owner(ipkg_conf_t *conf, const char *file_name)
11828 +{
11829 +     hash_table_t *file_hash = &conf->file_hash;
11830 +
11831 +     return hash_table_get(file_hash, file_name);
11832 +}
11833 +
11834 +int file_hash_set_file_owner(ipkg_conf_t *conf, const char *file_name, pkg_t *owning_pkg)
11835 +{
11836 +     hash_table_t *file_hash = &conf->file_hash;
11837 +     pkg_t *old_owning_pkg = hash_table_get(file_hash, file_name);
11838 +     int file_name_len = strlen(file_name);
11839 +
11840 +     if (file_name[file_name_len -1] == '/')
11841 +         return 0;
11842 +
11843 +     if (conf->offline_root) {
11844 +         int len = strlen(conf->offline_root);
11845 +         if (strncmp(file_name, conf->offline_root, len) == 0) {
11846 +              file_name += len;
11847 +         }
11848 +     }
11849 +
11850 +     // ipkg_message(conf, IPKG_DEBUG2, "owning_pkg=%s filename=%s\n", owning_pkg->name, file_name);
11851 +     hash_table_insert(file_hash, file_name, owning_pkg);
11852 +     if (old_owning_pkg) {
11853 +         str_list_remove_elt(old_owning_pkg->installed_files, file_name);
11854 +         /* mark this package to have its filelist written */
11855 +         old_owning_pkg->state_flag |= SF_FILELIST_CHANGED;
11856 +         owning_pkg->state_flag |= SF_FILELIST_CHANGED;
11857 +     }
11858 +     return 0;
11859 +}
11860 +
11861 +
11862 Index: busybox-1.7.2/archival/libipkg/pkg_hash.h
11863 ===================================================================
11864 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
11865 +++ busybox-1.7.2/archival/libipkg/pkg_hash.h   2007-10-04 17:14:23.349072007 +0200
11866 @@ -0,0 +1,61 @@
11867 +/* pkg_hash.h - the itsy package management system
11868 +
11869 +   Steven M. Ayer
11870 +
11871 +   Copyright (C) 2002 Compaq Computer Corporation
11872 +
11873 +   This program is free software; you can redistribute it and/or
11874 +   modify it under the terms of the GNU General Public License as
11875 +   published by the Free Software Foundation; either version 2, or (at
11876 +   your option) any later version.
11877 +
11878 +   This program is distributed in the hope that it will be useful, but
11879 +   WITHOUT ANY WARRANTY; without even the implied warranty of
11880 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11881 +   General Public License for more details.
11882 +*/
11883 +
11884 +#ifndef PKG_HASH_H
11885 +#define PKG_HASH_H
11886 +
11887 +#include "pkg.h"
11888 +#include "pkg_vec.h"
11889 +#include "hash_table.h"
11890 +
11891 +
11892 +int pkg_hash_init(const char *name, hash_table_t *hash, int len);
11893 +void pkg_hash_deinit(hash_table_t *hash);
11894 +void pkg_hash_map(hash_table_t *hash, void (*f)(void *data, void *entry), void *data);
11895 +
11896 +void pkg_hash_dump(hash_table_t *hash, void *data);
11897 +void pkg_hash_fetch_available(hash_table_t *hash, pkg_vec_t *available);
11898 +
11899 +int pkg_hash_add_from_file(ipkg_conf_t *conf, const char *file_name,
11900 +                          pkg_src_t *src, pkg_dest_t *dest, int is_status_file);
11901 +pkg_t *hash_insert_pkg(hash_table_t *hash, pkg_t *pkg, int set_status,ipkg_conf_t *conf);
11902 +
11903 +abstract_pkg_t * ensure_abstract_pkg_by_name(hash_table_t * hash, const char * pkg_name);
11904 +abstract_pkg_t * abstract_pkg_fetch_by_name(hash_table_t * hash, const char * pkg_name);
11905 +pkg_vec_t *pkg_hash_fetch_by_name(hash_table_t *hash, const char *pkg_name);
11906 +void pkg_hash_fetch_all_installed(hash_table_t *hash, pkg_vec_t *installed);
11907 +pkg_t * pkg_hash_fetch_by_name_version(hash_table_t *hash,
11908 +                                      const char *pkg_name,
11909 +                                      const char * version);
11910 +abstract_pkg_vec_t *pkg_hash_fetch_all_installation_candidates(hash_table_t *hash, const char *name);
11911 +pkg_t *pkg_hash_fetch_best_installation_candidate(ipkg_conf_t *conf, abstract_pkg_t *apkg,
11912 +                                                 int (*constraint_fcn)(pkg_t *pkg, void *data), void *cdata, int quiet);
11913 +pkg_t *pkg_hash_fetch_best_installation_candidate_by_name(ipkg_conf_t *conf, const char *name);
11914 +pkg_t *pkg_hash_fetch_installed_by_name(hash_table_t *hash,
11915 +                                       const char *pkg_name);
11916 +pkg_t *pkg_hash_fetch_installed_by_name_dest(hash_table_t *hash,
11917 +                                            const char *pkg_name,
11918 +                                            pkg_dest_t *dest);
11919 +
11920 +pkg_t *file_hash_get_file_owner(ipkg_conf_t *conf, const char *file_name);
11921 +int file_hash_set_file_owner(ipkg_conf_t *conf, const char *file_name, pkg_t *pkg);
11922 +
11923 +/* XXX: shouldn't this go in pkg_vec.[ch]? */
11924 +pkg_vec_t *pkg_vec_fetch_by_name(hash_table_t *hash, const char *pkg_name);
11925 +
11926 +#endif
11927 +
11928 Index: busybox-1.7.2/archival/libipkg/pkg_parse.c
11929 ===================================================================
11930 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
11931 +++ busybox-1.7.2/archival/libipkg/pkg_parse.c  2007-10-04 17:14:23.369073144 +0200
11932 @@ -0,0 +1,366 @@
11933 +/* pkg_parse.c - the itsy package management system
11934 +
11935 +   Steven M. Ayer
11936 +
11937 +   Copyright (C) 2002 Compaq Computer Corporation
11938 +
11939 +   This program is free software; you can redistribute it and/or
11940 +   modify it under the terms of the GNU General Public License as
11941 +   published by the Free Software Foundation; either version 2, or (at
11942 +   your option) any later version.
11943 +
11944 +   This program is distributed in the hope that it will be useful, but
11945 +   WITHOUT ANY WARRANTY; without even the implied warranty of
11946 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11947 +   General Public License for more details.
11948 +*/
11949 +
11950 +#include "ipkg.h"
11951 +#include <errno.h>
11952 +#include <ctype.h>
11953 +
11954 +#include "pkg.h"
11955 +#include "ipkg_utils.h"
11956 +#include "pkg_parse.h"
11957 +
11958 +int isGenericFieldType(char * type, char * line)
11959 +{
11960 +    if(!strncmp(line, type, strlen(type)))
11961 +       return 1;
11962 +    return 0;
11963 +}
11964 +
11965 +char * parseGenericFieldType(char * type, char * raw)
11966 +{
11967 +    char * field_value = raw + (strlen(type) + 1);
11968 +    return trim_alloc(field_value);
11969 +}
11970 +
11971 +void parseStatus(pkg_t *pkg, char * raw)
11972 +{
11973 +    char sw_str[64], sf_str[64], ss_str[64];
11974 +
11975 +    sscanf(raw, "Status: %s %s %s", sw_str, sf_str, ss_str);
11976 +    pkg->state_want = pkg_state_want_from_str(sw_str);
11977 +    pkg->state_flag = pkg_state_flag_from_str(sf_str);
11978 +    pkg->state_status = pkg_state_status_from_str(ss_str);
11979 +}
11980 +
11981 +char ** parseDependsString(char * raw, int * depends_count)
11982 +{
11983 +    char ** depends = NULL;
11984 +    int line_count = 0;
11985 +    char buff[2048], * dest;
11986 +
11987 +    while(raw && *raw && !isspace(*raw)) {
11988 +       raw++;
11989 +    }
11990 +
11991 +    if(line_is_blank(raw)){
11992 +       *depends_count = line_count;
11993 +       return NULL;
11994 +    }
11995 +    while(raw && *raw){
11996 +       depends = (char **)realloc(depends, sizeof(char *) * (line_count + 1));
11997 +
11998 +       while(isspace(*raw)) raw++;
11999 +
12000 +       dest = buff;
12001 +       while((*raw != ',') && *raw)
12002 +           *dest++ = *raw++;
12003 +
12004 +       *dest = '\0';
12005 +       depends[line_count] = trim_alloc(buff);
12006 +       if(depends[line_count] ==NULL)
12007 +          return NULL;
12008 +        line_count++;
12009 +       if(*raw == ',')
12010 +           raw++;
12011 +    }
12012 +    *depends_count = line_count;
12013 +    return depends;
12014 +}
12015 +
12016 +void parseConffiles(pkg_t * pkg, char * raw)
12017 +{
12018 +    char file_name[1048], md5sum[1048];  /* please tell me there aren't any longer that 1k */
12019 +
12020 +    if(!strncmp(raw, "Conffiles:", 10))
12021 +       raw += strlen("Conffiles:");
12022 +
12023 +    while(*raw && (sscanf(raw, "%s%s", file_name, md5sum) == 2)){
12024 +       conffile_list_append(&pkg->conffiles, file_name, md5sum);
12025 +       /*      fprintf(stderr, "%s %s ", file_name, md5sum);*/
12026 +       while (*raw && isspace(*raw)) {
12027 +           raw++;
12028 +       }
12029 +       raw += strlen(file_name);
12030 +       while (*raw && isspace(*raw)) {
12031 +           raw++;
12032 +       }
12033 +       raw += strlen(md5sum);
12034 +    }
12035 +}
12036 +
12037 +int parseVersion(pkg_t *pkg, char *raw)
12038 +{
12039 +  char *colon, *eepochcolon;
12040 +#ifdef USE_DEBVERSION
12041 +  char *hyphen;
12042 +#endif
12043 +  unsigned long epoch;
12044 +
12045 +  if (!*raw) {
12046 +      fprintf(stderr, "%s: ERROR: version string is empty", __FUNCTION__);
12047 +      return EINVAL;
12048 +  }
12049 +
12050 +  if (strncmp(raw, "Version:", 8) == 0) {
12051 +      raw += 8;
12052 +  }
12053 +  while (*raw && isspace(*raw)) {
12054 +      raw++;
12055 +  }
12056 +
12057 +  colon= strchr(raw,':');
12058 +  if (colon) {
12059 +    epoch= strtoul(raw,&eepochcolon,10);
12060 +    if (colon != eepochcolon) {
12061 +       fprintf(stderr, "%s: ERROR: epoch in version is not number", __FUNCTION__);
12062 +       return EINVAL;
12063 +    }
12064 +    if (!*++colon) {
12065 +       fprintf(stderr, "%s: ERROR: nothing after colon in version number", __FUNCTION__);
12066 +       return EINVAL;
12067 +    }
12068 +    raw= colon;
12069 +    pkg->epoch= epoch;
12070 +  } else {
12071 +    pkg->epoch= 0;
12072 +  }
12073 +
12074 +  pkg->revision = "";
12075 +  pkg->familiar_revision = "";
12076 +
12077 +  pkg->version= malloc(strlen(raw)+1);
12078 +  if ( pkg->version == NULL ) {
12079 +     fprintf(stderr, "%s: out of memory \n", __FUNCTION__);
12080 +     return ENOMEM;
12081 +  }
12082 +  strcpy(pkg->version, raw);
12083 +
12084 +#ifdef USE_DEBVERSION
12085 +  hyphen= strrchr(pkg->version,'-');
12086 +
12087 +  if (hyphen) {
12088 +    *hyphen++= 0;
12089 +    if (strncmp("fam", hyphen, 3) == 0) {
12090 +      pkg->familiar_revision=hyphen+3;
12091 +      hyphen= strrchr(pkg->version,'-');
12092 +      if (hyphen) {
12093 +       *hyphen++= 0;
12094 +       pkg->revision = hyphen;
12095 +      }
12096 +    } else {
12097 +      pkg->revision = hyphen;
12098 +    }
12099 +  }
12100 +#endif
12101 +
12102 +/*
12103 +  fprintf(stderr,"Parsed version: %lu, %s, %s, %s\n",
12104 +         pkg->epoch,
12105 +         pkg->version,
12106 +         pkg->revision,
12107 +         pkg->familiar_revision);
12108 +*/
12109 +
12110 +  return 0;
12111 +}
12112 +
12113 +
12114 +/* This code is needed to insert in first position the keyword for the aligning bug */
12115 +
12116 +int alterProvidesLine(char *raw, char *temp)
12117 +{
12118 +
12119 +
12120 +  if (!*raw) {
12121 +      fprintf(stderr, "%s: ERROR: Provides string is empty", __FUNCTION__);
12122 +      return -EINVAL;
12123 +  }
12124 +
12125 +  if ( temp == NULL ) {
12126 +     fprintf(stderr, "%s: out of memory \n", __FUNCTION__);
12127 +     return -ENOMEM;
12128 +  }
12129 +
12130 +  if (strncmp(raw, "Provides:", 9) == 0) {
12131 +      raw += 9;
12132 +  }
12133 +  while (*raw && isspace(*raw)) {
12134 +      raw++;
12135 +  }
12136 +
12137 +  snprintf ( temp, 35, "Provides: ipkg_internal_use_only, ");           /* First part of the line */
12138 +  while (*raw) {
12139 +     strncat( temp, raw++, 1);
12140 +  }
12141 +  return 0;
12142 +
12143 +}
12144 +
12145 +/* Some random thoughts from Carl:
12146 +
12147 +   This function could be considerably simplified if we just kept
12148 +   an array of all the generic string-valued field names, and looped
12149 +   through those looking for a match. Also, these fields could perhaps
12150 +   be stored in the package as an array as well, (or, probably better,
12151 +   as an nv_pair_list_t).
12152 +
12153 +   Fields which require special parsing or storage, (such as Depends:
12154 +   and Status:) could be handled as they are now.
12155 +*/
12156 +/* XXX: FEATURE: The Suggests: field needs to be changed from a string
12157 +   to a dependency list. And, since we already have
12158 +   Depends/Pre-Depends and need to add Conflicts, Recommends, and
12159 +   Enhances, perhaps we could generalize all of these and save some
12160 +   code duplication.
12161 +*/
12162 +int pkg_parse_raw(pkg_t *pkg, char ***raw, pkg_src_t *src, pkg_dest_t *dest)
12163 +{
12164 +    int reading_conffiles, reading_description;
12165 +    int pkg_false_provides=1;
12166 +    char ** lines;
12167 +    char * provide=NULL;
12168 +
12169 +    pkg->src = src;
12170 +    pkg->dest = dest;
12171 +
12172 +    reading_conffiles = reading_description = 0;
12173 +
12174 +    for (lines = *raw; *lines; lines++) {
12175 +       /*      fprintf(stderr, "PARSING %s\n", *lines);*/
12176 +       if(isGenericFieldType("Package:", *lines))
12177 +           pkg->name = parseGenericFieldType("Package", *lines);
12178 +       else if(isGenericFieldType("Architecture:", *lines))
12179 +           pkg->architecture = parseGenericFieldType("Architecture", *lines);
12180 +       else if(isGenericFieldType("Filename:", *lines))
12181 +           pkg->filename = parseGenericFieldType("Filename", *lines);
12182 +       else if(isGenericFieldType("Section:", *lines))
12183 +           pkg->section = parseGenericFieldType("Section", *lines);
12184 +       else if(isGenericFieldType("MD5sum:", *lines))
12185 +           pkg->md5sum = parseGenericFieldType("MD5sum", *lines);
12186 +       /* The old ipkg wrote out status files with the wrong case for MD5sum,
12187 +          let's parse it either way */
12188 +       else if(isGenericFieldType("MD5Sum:", *lines))
12189 +           pkg->md5sum = parseGenericFieldType("MD5Sum", *lines);
12190 +       else if(isGenericFieldType("Size:", *lines))
12191 +           pkg->size = parseGenericFieldType("Size", *lines);
12192 +       else if(isGenericFieldType("Source:", *lines))
12193 +           pkg->source = parseGenericFieldType("Source", *lines);
12194 +       else if(isGenericFieldType("Installed-Size:", *lines))
12195 +           pkg->installed_size = parseGenericFieldType("Installed-Size", *lines);
12196 +       else if(isGenericFieldType("Installed-Time:", *lines)) {
12197 +            char *time_str = parseGenericFieldType("Installed-Time", *lines);
12198 +            pkg->installed_time = strtoul(time_str, NULL, 0);
12199 +       } else if(isGenericFieldType("Priority:", *lines))
12200 +           pkg->priority = parseGenericFieldType("Priority", *lines);
12201 +       else if(isGenericFieldType("Essential:", *lines)) {
12202 +           char *essential_value;
12203 +           essential_value = parseGenericFieldType("Essential", *lines);
12204 +           if (strcmp(essential_value, "yes") == 0) {
12205 +               pkg->essential = 1;
12206 +           }
12207 +           free(essential_value);
12208 +       }
12209 +       else if(isGenericFieldType("Status", *lines))
12210 +           parseStatus(pkg, *lines);
12211 +       else if(isGenericFieldType("Version", *lines))
12212 +           parseVersion(pkg, *lines);
12213 +       else if(isGenericFieldType("Maintainer", *lines))
12214 +           pkg->maintainer = parseGenericFieldType("Maintainer", *lines);
12215 +       else if(isGenericFieldType("Conffiles", *lines)){
12216 +           parseConffiles(pkg, *lines);
12217 +           reading_conffiles = 1;
12218 +       }
12219 +       else if(isGenericFieldType("Description", *lines)) {
12220 +           pkg->description = parseGenericFieldType("Description", *lines);
12221 +           reading_conffiles = 0;
12222 +           reading_description = 1;
12223 +       }
12224 +
12225 +       else if(isGenericFieldType("Provides", *lines)){
12226 +/* Here we add the internal_use to align the off by one problem between provides_str and provides */
12227 +            provide = (char * ) malloc(strlen(*lines)+ 35 ); /* Preparing the space for the new ipkg_internal_use_only */
12228 +            if ( alterProvidesLine(*lines,provide) ){
12229 +               return EINVAL;
12230 +            }
12231 +           pkg->provides_str = parseDependsString( provide, &pkg->provides_count);
12232 +/* Let's try to hack a bit here.
12233 +   The idea is that if a package has no Provides, we would add one generic, to permit the check of dependencies
12234 +   in alot of other places. We will remove it before writing down the status database */
12235 +            pkg_false_provides=0;
12236 +            free(provide);
12237 +        }
12238 +
12239 +       else if(isGenericFieldType("Depends", *lines))
12240 +           pkg->depends_str = parseDependsString(*lines, &pkg->depends_count);
12241 +       else if(isGenericFieldType("Pre-Depends", *lines))
12242 +           pkg->pre_depends_str = parseDependsString(*lines, &pkg->pre_depends_count);
12243 +       else if(isGenericFieldType("Recommends", *lines))
12244 +           pkg->recommends_str = parseDependsString(*lines, &pkg->recommends_count);
12245 +       else if(isGenericFieldType("Suggests", *lines))
12246 +           pkg->suggests_str = parseDependsString(*lines, &pkg->suggests_count);
12247 +       /* Abhaya: support for conflicts */
12248 +       else if(isGenericFieldType("Conflicts", *lines))
12249 +           pkg->conflicts_str = parseDependsString(*lines, &pkg->conflicts_count);
12250 +       else if(isGenericFieldType("Replaces", *lines))
12251 +           pkg->replaces_str = parseDependsString(*lines, &pkg->replaces_count);
12252 +       else if(line_is_blank(*lines)) {
12253 +           lines++;
12254 +           break;
12255 +       }
12256 +       else if(**lines == ' '){
12257 +           if(reading_description) {
12258 +               /* we already know it's not blank, so the rest of description */
12259 +               pkg->description = realloc(pkg->description,
12260 +                                          strlen(pkg->description)
12261 +                                          + 1 + strlen(*lines) + 1);
12262 +               strcat(pkg->description, "\n");
12263 +               strcat(pkg->description, (*lines));
12264 +           }
12265 +           else if(reading_conffiles)
12266 +               parseConffiles(pkg, *lines);
12267 +       }
12268 +    }
12269 +    *raw = lines;
12270 +/* If the ipk has not a Provides line, we insert our false line */
12271 +    if ( pkg_false_provides==1)
12272 +       pkg->provides_str = parseDependsString ((char *)"Provides: ipkg_internal_use_only ", &pkg->provides_count);
12273 +
12274 +    if (pkg->name) {
12275 +       return 0;
12276 +    } else {
12277 +       return EINVAL;
12278 +    }
12279 +}
12280 +
12281 +int pkg_valorize_other_field(pkg_t *pkg, char ***raw)
12282 +{
12283 +    char ** lines;
12284 +
12285 +    for (lines = *raw; *lines; lines++) {
12286 +       if(isGenericFieldType("Essential:", *lines)) {
12287 +           char *essential_value;
12288 +           essential_value = parseGenericFieldType("Essential", *lines);
12289 +           if (strcmp(essential_value, "yes") == 0) {
12290 +               pkg->essential = 1;
12291 +           }
12292 +           free(essential_value);
12293 +       }
12294 +    }
12295 +    *raw = lines;
12296 +
12297 +    return 0;
12298 +}
12299 Index: busybox-1.7.2/archival/libipkg/pkg_parse.h
12300 ===================================================================
12301 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12302 +++ busybox-1.7.2/archival/libipkg/pkg_parse.h  2007-10-04 17:14:23.389074295 +0200
12303 @@ -0,0 +1,31 @@
12304 +/* pkg_parse.h - the itsy package management system
12305 +
12306 +   Steven M. Ayer
12307 +
12308 +   Copyright (C) 2002 Compaq Computer Corporation
12309 +
12310 +   This program is free software; you can redistribute it and/or
12311 +   modify it under the terms of the GNU General Public License as
12312 +   published by the Free Software Foundation; either version 2, or (at
12313 +   your option) any later version.
12314 +
12315 +   This program is distributed in the hope that it will be useful, but
12316 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12317 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12318 +   General Public License for more details.
12319 +*/
12320 +
12321 +#ifndef PKG_PARSE_H
12322 +#define PKG_PARSE_H
12323 +
12324 +int isGenericFieldType(char * type, char * line);
12325 +char * parseGenericFieldType(char * type, char * raw);
12326 +void parseStatus(pkg_t *pkg, char * raw);
12327 +int parseVersion(pkg_t *pkg, char *raw);
12328 +char ** parseDependsString(char * raw, int * depends_count);
12329 +int parseVersion(pkg_t *pkg, char *raw);
12330 +void parseConffiles(pkg_t * pkg, char * raw);
12331 +int pkg_parse_raw(pkg_t *pkg, char ***raw, pkg_src_t *src, pkg_dest_t *dest);
12332 +int pkg_valorize_other_field(pkg_t *pkg, char ***raw);
12333 +
12334 +#endif
12335 Index: busybox-1.7.2/archival/libipkg/pkg_src.c
12336 ===================================================================
12337 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12338 +++ busybox-1.7.2/archival/libipkg/pkg_src.c    2007-10-04 17:14:23.433076797 +0200
12339 @@ -0,0 +1,43 @@
12340 +/* pkg_src.c - the itsy package management system
12341 +
12342 +   Carl D. Worth
12343 +
12344 +   Copyright (C) 2001 University of Southern California
12345 +
12346 +   This program is free software; you can redistribute it and/or
12347 +   modify it under the terms of the GNU General Public License as
12348 +   published by the Free Software Foundation; either version 2, or (at
12349 +   your option) any later version.
12350 +
12351 +   This program is distributed in the hope that it will be useful, but
12352 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12353 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12354 +   General Public License for more details.
12355 +*/
12356 +
12357 +#include "ipkg.h"
12358 +
12359 +#include "pkg_src.h"
12360 +#include "str_util.h"
12361 +
12362 +int pkg_src_init(pkg_src_t *src, const char *name, const char *base_url, const char *extra_data, int gzip)
12363 +{
12364 +    src->gzip = gzip;
12365 +    src->name = str_dup_safe (name);
12366 +    src->value = str_dup_safe (base_url);
12367 +    if (extra_data)
12368 +       src->extra_data = str_dup_safe (extra_data);
12369 +    else
12370 +       src->extra_data = NULL;
12371 +    return 0;
12372 +}
12373 +
12374 +void pkg_src_deinit(pkg_src_t *src)
12375 +{
12376 +    free (src->name);
12377 +    free (src->value);
12378 +    if (src->extra_data)
12379 +       free (src->extra_data);
12380 +}
12381 +
12382 +
12383 Index: busybox-1.7.2/archival/libipkg/pkg_src.h
12384 ===================================================================
12385 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12386 +++ busybox-1.7.2/archival/libipkg/pkg_src.h    2007-10-04 17:14:23.457078165 +0200
12387 @@ -0,0 +1,34 @@
12388 +/* pkg_src.h - the itsy package management system
12389 +
12390 +   Carl D. Worth
12391 +
12392 +   Copyright (C) 2001 University of Southern California
12393 +
12394 +   This program is free software; you can redistribute it and/or
12395 +   modify it under the terms of the GNU General Public License as
12396 +   published by the Free Software Foundation; either version 2, or (at
12397 +   your option) any later version.
12398 +
12399 +   This program is distributed in the hope that it will be useful, but
12400 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12401 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12402 +   General Public License for more details.
12403 +*/
12404 +
12405 +#ifndef PKG_SRC_H
12406 +#define PKG_SRC_H
12407 +
12408 +#include "nv_pair.h"
12409 +
12410 +typedef struct
12411 +{
12412 +  char *name;
12413 +  char *value;
12414 +  char *extra_data;
12415 +  int gzip;
12416 +} pkg_src_t;
12417 +
12418 +int pkg_src_init(pkg_src_t *src, const char *name, const char *base_url, const char *extra_data, int gzip);
12419 +void pkg_src_deinit(pkg_src_t *src);
12420 +
12421 +#endif
12422 Index: busybox-1.7.2/archival/libipkg/pkg_src_list.c
12423 ===================================================================
12424 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12425 +++ busybox-1.7.2/archival/libipkg/pkg_src_list.c       2007-10-04 17:14:23.481079530 +0200
12426 @@ -0,0 +1,75 @@
12427 +/* pkg_src_list.c - the itsy package management system
12428 +
12429 +   Carl D. Worth
12430 +
12431 +   Copyright (C) 2001 University of Southern California
12432 +
12433 +   This program is free software; you can redistribute it and/or
12434 +   modify it under the terms of the GNU General Public License as
12435 +   published by the Free Software Foundation; either version 2, or (at
12436 +   your option) any later version.
12437 +
12438 +   This program is distributed in the hope that it will be useful, but
12439 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12440 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12441 +   General Public License for more details.
12442 +*/
12443 +
12444 +#include "ipkg.h"
12445 +
12446 +#include "pkg_src_list.h"
12447 +#include "void_list.h"
12448 +
12449 +int pkg_src_list_init(pkg_src_list_t *list)
12450 +{
12451 +    return void_list_init((void_list_t *) list);
12452 +}
12453 +
12454 +void pkg_src_list_deinit(pkg_src_list_t *list)
12455 +{
12456 +    pkg_src_list_elt_t *iter;
12457 +    pkg_src_t *pkg_src;
12458 +
12459 +    for (iter = list->head; iter; iter = iter->next) {
12460 +      pkg_src = iter->data;
12461 +      pkg_src_deinit(pkg_src);
12462 +
12463 +      /* malloced in pkg_src_list_append */
12464 +      free(pkg_src);
12465 +      iter->data = NULL;
12466 +    }
12467 +    void_list_deinit((void_list_t *) list);
12468 +}
12469 +
12470 +pkg_src_t *pkg_src_list_append(pkg_src_list_t *list,
12471 +                              const char *name, const char *base_url, const char *extra_data,
12472 +                              int gzip)
12473 +{
12474 +    int err;
12475 +
12476 +    /* freed in pkg_src_list_deinit */
12477 +    pkg_src_t *pkg_src = malloc(sizeof(pkg_src_t));
12478 +
12479 +    if (pkg_src == NULL) {
12480 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
12481 +       return NULL;
12482 +    }
12483 +    pkg_src_init(pkg_src, name, base_url, extra_data, gzip);
12484 +
12485 +    err = void_list_append((void_list_t *) list, pkg_src);
12486 +    if (err) {
12487 +       return NULL;
12488 +    }
12489 +
12490 +    return pkg_src;
12491 +}
12492 +
12493 +int pkg_src_list_push(pkg_src_list_t *list, pkg_src_t *data)
12494 +{
12495 +    return void_list_push((void_list_t *) list, data);
12496 +}
12497 +
12498 +pkg_src_list_elt_t *pkg_src_list_pop(pkg_src_list_t *list)
12499 +{
12500 +    return (pkg_src_list_elt_t *) void_list_pop((void_list_t *) list);
12501 +}
12502 Index: busybox-1.7.2/archival/libipkg/pkg_src_list.h
12503 ===================================================================
12504 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12505 +++ busybox-1.7.2/archival/libipkg/pkg_src_list.h       2007-10-04 17:14:23.497080447 +0200
12506 @@ -0,0 +1,57 @@
12507 +/* pkg_src_list.h - the itsy package management system
12508 +
12509 +   Carl D. Worth
12510 +
12511 +   Copyright (C) 2001 University of Southern California
12512 +
12513 +   This program is free software; you can redistribute it and/or
12514 +   modify it under the terms of the GNU General Public License as
12515 +   published by the Free Software Foundation; either version 2, or (at
12516 +   your option) any later version.
12517 +
12518 +   This program is distributed in the hope that it will be useful, but
12519 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12520 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12521 +   General Public License for more details.
12522 +*/
12523 +
12524 +#ifndef PKG_SRC_LIST_H
12525 +#define PKG_SRC_LIST_H
12526 +
12527 +#include "pkg_src.h"
12528 +
12529 +typedef struct pkg_src_list_elt pkg_src_list_elt_t;
12530 +struct pkg_src_list_elt
12531 +{
12532 +    pkg_src_list_elt_t *next;
12533 +    pkg_src_t *data;
12534 +};
12535 +
12536 +typedef struct pkg_src_list pkg_src_list_t;
12537 +struct pkg_src_list
12538 +{
12539 +    pkg_src_list_elt_t pre_head;
12540 +    pkg_src_list_elt_t *head;
12541 +    pkg_src_list_elt_t *tail;
12542 +};
12543 +
12544 +static inline int pkg_src_list_empty(pkg_src_list_t *list)
12545 +{
12546 +     if (list->head == NULL)
12547 +         return 1;
12548 +     else
12549 +         return 0;
12550 +}
12551 +
12552 +int pkg_src_list_elt_init(pkg_src_list_elt_t *elt, nv_pair_t *data);
12553 +void pkg_src_list_elt_deinit(pkg_src_list_elt_t *elt);
12554 +
12555 +int pkg_src_list_init(pkg_src_list_t *list);
12556 +void pkg_src_list_deinit(pkg_src_list_t *list);
12557 +
12558 +pkg_src_t *pkg_src_list_append(pkg_src_list_t *list, const char *name, const char *root_dir, const char *extra_data, int gzip);
12559 +int pkg_src_list_push(pkg_src_list_t *list, pkg_src_t *data);
12560 +pkg_src_list_elt_t *pkg_src_list_pop(pkg_src_list_t *list);
12561 +
12562 +#endif
12563 +
12564 Index: busybox-1.7.2/archival/libipkg/pkg_vec.c
12565 ===================================================================
12566 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12567 +++ busybox-1.7.2/archival/libipkg/pkg_vec.c    2007-10-04 17:14:23.513081356 +0200
12568 @@ -0,0 +1,230 @@
12569 +/* pkg_vec.c - the itsy package management system
12570 +
12571 +   Steven M. Ayer
12572 +
12573 +   Copyright (C) 2002 Compaq Computer Corporation
12574 +
12575 +   This program is free software; you can redistribute it and/or
12576 +   modify it under the terms of the GNU General Public License as
12577 +   published by the Free Software Foundation; either version 2, or (at
12578 +   your option) any later version.
12579 +
12580 +   This program is distributed in the hope that it will be useful, but
12581 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12582 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12583 +   General Public License for more details.
12584 +*/
12585 +
12586 +#include <stdlib.h>
12587 +#include <fnmatch.h>
12588 +#include "xregex.h"
12589 +#include "ipkg.h"
12590 +#include "pkg.h"
12591 +
12592 +pkg_vec_t * pkg_vec_alloc(void)
12593 +{
12594 +    pkg_vec_t * vec = (pkg_vec_t *)malloc(sizeof(pkg_vec_t));
12595 +    if (!vec) {
12596 +      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
12597 +      return NULL;
12598 +    }
12599 +    vec->pkgs = NULL;
12600 +    vec->len = 0;
12601 +
12602 +    return vec;
12603 +}
12604 +
12605 +void pkg_vec_free(pkg_vec_t *vec)
12606 +{
12607 +    free(vec->pkgs);
12608 +    free(vec);
12609 +}
12610 +
12611 +/*
12612 + * assumption: all names in a vector are identical
12613 + * assumption: all version strings are trimmed,
12614 + *             so identical versions have identical version strings,
12615 + *             implying identical packages; let's marry these
12616 + */
12617 +pkg_t *pkg_vec_insert_merge(pkg_vec_t *vec, pkg_t *pkg, int set_status,ipkg_conf_t *conf)
12618 +{
12619 +     int i;
12620 +     int found = 0;
12621 +
12622 +     /* look for a duplicate pkg by name, version, and architecture */
12623 +     for (i = 0; i < vec->len; i++){
12624 +         ipkg_message(conf, IPKG_DEBUG2, "Function: %s. Found pkg=%s version=%s arch=%s cmp=%s version=%s arch=%s \n",
12625 +                      __FUNCTION__, pkg->name, pkg->version, pkg->architecture,
12626 +                       vec->pkgs[i]->name, vec->pkgs[i]->version,vec->pkgs[i]->architecture );
12627 +         if ((strcmp(pkg->name, vec->pkgs[i]->name) == 0)
12628 +             && (pkg_compare_versions(pkg, vec->pkgs[i]) == 0)
12629 +             && (strcmp(pkg->architecture, vec->pkgs[i]->architecture) == 0)) {
12630 +              found  = 1;
12631 +               ipkg_message(conf, IPKG_DEBUG2, "Function: %s. Found duplicate for pkg=%s version=%s arch=%s\n",
12632 +                             __FUNCTION__, pkg->name, pkg->version, pkg->architecture);
12633 +              break;
12634 +         }
12635 +     }
12636 +
12637 +     /* we didn't find one, add it */
12638 +     if (!found){
12639 +         ipkg_message(conf, IPKG_DEBUG2, "Function: %s. Adding new pkg=%s version=%s arch=%s\n",
12640 +                      __FUNCTION__, pkg->name, pkg->version, pkg->architecture);
12641 +
12642 +         vec->pkgs = (pkg_t **)realloc(vec->pkgs, (vec->len + 1) * sizeof(pkg_t *));
12643 +         vec->pkgs[vec->len] = pkg;
12644 +         vec->len++;
12645 +         return pkg;
12646 +     }
12647 +     /* update the one that we have */
12648 +     else {
12649 +          ipkg_message(conf, IPKG_DEBUG2, "Function: %s. calling pkg_merge for pkg=%s version=%s arch=%s",
12650 +                        __FUNCTION__, pkg->name, pkg->version, pkg->architecture);
12651 +         if (set_status) {
12652 +              /* this is from the status file, so need to merge with existing database */
12653 +               ipkg_message(conf, IPKG_DEBUG2, " with set_status\n");
12654 +              pkg_merge(vec->pkgs[i], pkg, set_status);
12655 +              /* XXX: CLEANUP: It's not so polite to free something here
12656 +                 that was passed in from above. */
12657 +              pkg_deinit(pkg);
12658 +              free(pkg);
12659 +         } else {
12660 +               ipkg_message(conf, IPKG_DEBUG2, " WITHOUT set_status\n");
12661 +              /* just overwrite the old one */
12662 +              pkg_deinit(vec->pkgs[i]);
12663 +              free(vec->pkgs[i]);
12664 +              vec->pkgs[i] = pkg;
12665 +         }
12666 +         return vec->pkgs[i];
12667 +     }
12668 +}
12669 +
12670 +void pkg_vec_insert(pkg_vec_t *vec, const pkg_t *pkg)
12671 +{
12672 +     int i;
12673 +     int found = 0;
12674 +
12675 +     /* look for a duplicate pkg by name, version, and architecture */
12676 +     for (i = 0; i < vec->len; i++)
12677 +         if ((strcmp(pkg->name, vec->pkgs[i]->name) == 0)
12678 +             && (pkg_compare_versions(pkg, vec->pkgs[i]) == 0)
12679 +             && (strcmp(pkg->architecture, vec->pkgs[i]->name) == 0)) {
12680 +              found = 1;
12681 +              break;
12682 +         }
12683 +
12684 +     /* we didn't find one, add it */
12685 +     if(!found){
12686 +         vec->pkgs = (pkg_t **)realloc(vec->pkgs, (vec->len + 1) * sizeof(pkg_t *));
12687 +         *(const pkg_t **)&vec->pkgs[vec->len] = pkg;
12688 +         vec->len++;
12689 +     }
12690 +}
12691 +
12692 +int pkg_vec_contains(pkg_vec_t *vec, pkg_t *apkg)
12693 +{
12694 +     int i;
12695 +     for (i = 0; i < vec->len; i++)
12696 +         if (vec->pkgs[i] == apkg)
12697 +              return 1;
12698 +     return 0;
12699 +}
12700 +
12701 +typedef int (*compare_fcn_t)(const void *, const void *);
12702 +void pkg_vec_sort(pkg_vec_t *vec, int (*compar)(pkg_t *, pkg_t *))
12703 +{
12704 +     qsort(vec->pkgs, vec->len, sizeof(pkg_t *), (compare_fcn_t)compar);
12705 +}
12706 +
12707 +int pkg_vec_clear_marks(pkg_vec_t *vec)
12708 +{
12709 +     int npkgs = vec->len;
12710 +     int i;
12711 +     for (i = 0; i < npkgs; i++) {
12712 +         pkg_t *pkg = vec->pkgs[i];
12713 +         pkg->state_flag &= ~SF_MARKED;
12714 +     }
12715 +     return 0;
12716 +}
12717 +
12718 +int pkg_vec_mark_if_matches(pkg_vec_t *vec, const char *pattern)
12719 +{
12720 +     int matching_count = 0;
12721 +     pkg_t **pkgs = vec->pkgs;
12722 +     int npkgs = vec->len;
12723 +     int i;
12724 +     for (i = 0; i < npkgs; i++) {
12725 +         pkg_t *pkg = pkgs[i];
12726 +         if (fnmatch(pattern, pkg->name, 0)==0) {
12727 +              pkg->state_flag |= SF_MARKED;
12728 +              matching_count++;
12729 +         }
12730 +     }
12731 +     return matching_count;
12732 +}
12733 +
12734 +
12735 +abstract_pkg_vec_t * abstract_pkg_vec_alloc(void)
12736 +{
12737 +    abstract_pkg_vec_t * vec ;
12738 +    vec = (abstract_pkg_vec_t *)malloc(sizeof(abstract_pkg_vec_t));
12739 +    if (!vec) {
12740 +      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
12741 +      return NULL;
12742 +    }
12743 +    vec->pkgs = NULL;
12744 +    vec->len = 0;
12745 +
12746 +    return vec;
12747 +}
12748 +
12749 +void abstract_pkg_vec_free(abstract_pkg_vec_t *vec)
12750 +{
12751 +    free(vec->pkgs);
12752 +    free(vec);
12753 +}
12754 +
12755 +/*
12756 + * assumption: all names in a vector are unique
12757 + */
12758 +void abstract_pkg_vec_insert(abstract_pkg_vec_t *vec, abstract_pkg_t *pkg)
12759 +{
12760 +    int i;
12761 +
12762 +    /* look for a duplicate pkg by name */
12763 +    for(i = 0; i < vec->len; i++)
12764 +       if (strcmp(pkg->name, vec->pkgs[i]->name) == 0)
12765 +           break;
12766 +
12767 +    /* we didn't find one, add it */
12768 +    if(i == vec->len){
12769 +       vec->pkgs =
12770 +         (abstract_pkg_t **)
12771 +           realloc(vec->pkgs, (vec->len + 1) * sizeof(abstract_pkg_t *));
12772 +       vec->pkgs[vec->len] = pkg;
12773 +       vec->len++;
12774 +    }
12775 +}
12776 +
12777 +abstract_pkg_t * abstract_pkg_vec_get(abstract_pkg_vec_t *vec, int i)
12778 +{
12779 +    if (vec->len > i)
12780 +       return vec->pkgs[i];
12781 +    else
12782 +       return NULL;
12783 +}
12784 +
12785 +int abstract_pkg_vec_contains(abstract_pkg_vec_t *vec, abstract_pkg_t *apkg)
12786 +{
12787 +     int i;
12788 +     for (i = 0; i < vec->len; i++)
12789 +         if (vec->pkgs[i] == apkg)
12790 +              return 1;
12791 +     return 0;
12792 +}
12793 +
12794 +void abstract_pkg_vec_sort(pkg_vec_t *vec, int (*compar)(abstract_pkg_t *, abstract_pkg_t *))
12795 +{
12796 +     qsort(vec->pkgs, vec->len, sizeof(pkg_t *), (compare_fcn_t)compar);
12797 +}
12798 +
12799 Index: busybox-1.7.2/archival/libipkg/pkg_vec.h
12800 ===================================================================
12801 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12802 +++ busybox-1.7.2/archival/libipkg/pkg_vec.h    2007-10-04 17:14:23.565084313 +0200
12803 @@ -0,0 +1,64 @@
12804 +/* pkg_vec.h - the itsy package management system
12805 +
12806 +   Steven M. Ayer
12807 +
12808 +   Copyright (C) 2002 Compaq Computer Corporation
12809 +
12810 +   This program is free software; you can redistribute it and/or
12811 +   modify it under the terms of the GNU General Public License as
12812 +   published by the Free Software Foundation; either version 2, or (at
12813 +   your option) any later version.
12814 +
12815 +   This program is distributed in the hope that it will be useful, but
12816 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12817 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12818 +   General Public License for more details.
12819 +*/
12820 +
12821 +#ifndef PKG_VEC_H
12822 +#define PKG_VEC_H
12823 +
12824 +typedef struct pkg pkg_t;
12825 +typedef struct abstract_pkg abstract_pkg_t;
12826 +
12827 +struct pkg_vec
12828 +{
12829 +    pkg_t **pkgs;
12830 +    int len;
12831 +};
12832 +typedef struct pkg_vec pkg_vec_t;
12833 +
12834 +struct abstract_pkg_vec
12835 +{
12836 +    abstract_pkg_t **pkgs;
12837 +    int len;
12838 +};
12839 +typedef struct abstract_pkg_vec abstract_pkg_vec_t;
12840 +
12841 +typedef int (*pkg_compar_t)(pkg_t *, pkg_t *);
12842 +typedef int (*abstract_pkg_compar_t)(abstract_pkg_t *, abstract_pkg_t *);
12843 +
12844 +pkg_vec_t * pkg_vec_alloc(void);
12845 +void pkg_vec_free(pkg_vec_t *vec);
12846 +void marry_two_packages(pkg_t * newpkg, pkg_t * oldpkg);
12847 +
12848 +void pkg_vec_add(pkg_vec_t *vec, pkg_t *pkg);
12849 +/* pkg_vec_insert_merge: might munge pkg.
12850 +*  returns the pkg that is in the pkg graph */
12851 +pkg_t *pkg_vec_insert_merge(pkg_vec_t *vec, pkg_t *pkg, int set_status, ipkg_conf_t *conf);
12852 +/* this one never munges pkg */
12853 +void pkg_vec_insert(pkg_vec_t *vec, const pkg_t *pkg);
12854 +int pkg_vec_contains(pkg_vec_t *vec, pkg_t *apkg);
12855 +void pkg_vec_sort(pkg_vec_t *vec, int (*compar)(pkg_t *, pkg_t *));
12856 +
12857 +int pkg_vec_clear_marks(pkg_vec_t *vec);
12858 +int pkg_vec_mark_if_matches(pkg_vec_t *vec, const char *pattern);
12859 +
12860 +abstract_pkg_vec_t * abstract_pkg_vec_alloc(void);
12861 +void abstract_pkg_vec_free(abstract_pkg_vec_t *vec);
12862 +void abstract_pkg_vec_insert(abstract_pkg_vec_t *vec, abstract_pkg_t *pkg);
12863 +abstract_pkg_t * abstract_pkg_vec_get(abstract_pkg_vec_t *vec, int i);
12864 +int abstract_pkg_vec_contains(abstract_pkg_vec_t *vec, abstract_pkg_t *apkg);
12865 +void abstract_pkg_vec_sort(pkg_vec_t *vec, int (*compar)(abstract_pkg_t *, abstract_pkg_t *));
12866 +#endif
12867 +
12868 Index: busybox-1.7.2/archival/libipkg/sprintf_alloc.h
12869 ===================================================================
12870 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12871 +++ busybox-1.7.2/archival/libipkg/sprintf_alloc.h      2007-10-04 17:14:23.589085682 +0200
12872 @@ -0,0 +1,25 @@
12873 +/* sprintf_alloca.c -- like sprintf with memory allocation
12874 +
12875 +   Carl D. Worth
12876 +
12877 +   Copyright (C) 2001 University of Southern California
12878 +
12879 +   This program is free software; you can redistribute it and/or modify
12880 +   it under the terms of the GNU General Public License as published by
12881 +   the Free Software Foundation; either version 2, or (at your option)
12882 +   any later version.
12883 +
12884 +   This program is distributed in the hope that it will be useful,
12885 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
12886 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12887 +   GNU General Public License for more details.
12888 +*/
12889 +
12890 +#ifndef SPRINTF_ALLOC_H
12891 +#define SPRINTF_ALLOC_H
12892 +
12893 +#include "libbb.h"
12894 +
12895 +#define sprintf_alloc(str, fmt, args...)  *str = xasprintf(fmt, ## args)
12896 +
12897 +#endif
12898 Index: busybox-1.7.2/archival/libipkg/str_list.c
12899 ===================================================================
12900 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12901 +++ busybox-1.7.2/archival/libipkg/str_list.c   2007-10-04 17:14:23.609086833 +0200
12902 @@ -0,0 +1,76 @@
12903 +/* str_list.c - the itsy package management system
12904 +
12905 +   Carl D. Worth
12906 +
12907 +   Copyright (C) 2001 University of Southern California
12908 +
12909 +   This program is free software; you can redistribute it and/or
12910 +   modify it under the terms of the GNU General Public License as
12911 +   published by the Free Software Foundation; either version 2, or (at
12912 +   your option) any later version.
12913 +
12914 +   This program is distributed in the hope that it will be useful, but
12915 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12916 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12917 +   General Public License for more details.
12918 +*/
12919 +
12920 +#include "ipkg.h"
12921 +
12922 +#include "str_list.h"
12923 +
12924 +int str_list_elt_init(str_list_elt_t *elt, char *data)
12925 +{
12926 +    return void_list_elt_init((void_list_elt_t *) elt, data);
12927 +}
12928 +
12929 +void str_list_elt_deinit(str_list_elt_t *elt)
12930 +{
12931 +    void_list_elt_deinit((void_list_elt_t *) elt);
12932 +}
12933 +
12934 +str_list_t *str_list_alloc()
12935 +{
12936 +     str_list_t *list = (str_list_t *)malloc(sizeof(str_list_t));
12937 +     if (list)
12938 +         str_list_init(list);
12939 +     return list;
12940 +}
12941 +
12942 +int str_list_init(str_list_t *list)
12943 +{
12944 +    return void_list_init((void_list_t *) list);
12945 +}
12946 +
12947 +void str_list_deinit(str_list_t *list)
12948 +{
12949 +    void_list_deinit((void_list_t *) list);
12950 +}
12951 +
12952 +int str_list_append(str_list_t *list, char *data)
12953 +{
12954 +    return void_list_append((void_list_t *) list, data);
12955 +}
12956 +
12957 +int str_list_push(str_list_t *list, char *data)
12958 +{
12959 +    return void_list_push((void_list_t *) list, data);
12960 +}
12961 +
12962 +str_list_elt_t *str_list_pop(str_list_t *list)
12963 +{
12964 +    return (str_list_elt_t *) void_list_pop((void_list_t *) list);
12965 +}
12966 +
12967 +str_list_elt_t *str_list_remove(str_list_t *list, str_list_elt_t **iter)
12968 +{
12969 +    return (str_list_elt_t *) void_list_remove((void_list_t *) list,
12970 +                                              (void_list_elt_t **) iter);
12971 +}
12972 +
12973 +char *str_list_remove_elt(str_list_t *list, const char *target_str)
12974 +{
12975 +     return (char *)void_list_remove_elt((void_list_t *) list,
12976 +                                        (void *)target_str,
12977 +                                        (void_list_cmp_t)strcmp);
12978 +}
12979 Index: busybox-1.7.2/archival/libipkg/str_list.h
12980 ===================================================================
12981 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
12982 +++ busybox-1.7.2/archival/libipkg/str_list.h   2007-10-04 17:14:23.673090470 +0200
12983 @@ -0,0 +1,51 @@
12984 +/* str_list.h - the itsy package management system
12985 +
12986 +   Carl D. Worth
12987 +
12988 +   Copyright (C) 2001 University of Southern California
12989 +
12990 +   This program is free software; you can redistribute it and/or
12991 +   modify it under the terms of the GNU General Public License as
12992 +   published by the Free Software Foundation; either version 2, or (at
12993 +   your option) any later version.
12994 +
12995 +   This program is distributed in the hope that it will be useful, but
12996 +   WITHOUT ANY WARRANTY; without even the implied warranty of
12997 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12998 +   General Public License for more details.
12999 +*/
13000 +
13001 +#ifndef STR_LIST_H
13002 +#define STR_LIST_H
13003 +
13004 +#include "void_list.h"
13005 +
13006 +typedef struct str_list_elt str_list_elt_t;
13007 +struct str_list_elt
13008 +{
13009 +    str_list_elt_t *next;
13010 +    char *data;
13011 +};
13012 +
13013 +typedef struct xstr_list str_list_t;
13014 +struct xstr_list
13015 +{
13016 +    str_list_elt_t pre_head;
13017 +    str_list_elt_t *head;
13018 +    str_list_elt_t *tail;
13019 +};
13020 +
13021 +int str_list_elt_init(str_list_elt_t *elt, char *data);
13022 +void str_list_elt_deinit(str_list_elt_t *elt);
13023 +
13024 +str_list_t *str_list_alloc(void);
13025 +int str_list_init(str_list_t *list);
13026 +void str_list_deinit(str_list_t *list);
13027 +
13028 +int str_list_append(str_list_t *list, char *data);
13029 +int str_list_push(str_list_t *list, char *data);
13030 +str_list_elt_t *str_list_pop(str_list_t *list);
13031 +str_list_elt_t *str_list_remove(str_list_t *list, str_list_elt_t **iter);
13032 +char *str_list_remove_elt(str_list_t *list, const char *target_str);
13033 +
13034 +#endif
13035 Index: busybox-1.7.2/archival/libipkg/str_util.c
13036 ===================================================================
13037 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13038 +++ busybox-1.7.2/archival/libipkg/str_util.c   2007-10-04 17:20:30.425990533 +0200
13039 @@ -0,0 +1,63 @@
13040 +/* str_utils.c - the itsy package management system
13041 +
13042 +   Carl D. Worth
13043 +
13044 +   Copyright (C) 2001 University of Southern California
13045 +
13046 +   This program is free software; you can redistribute it and/or
13047 +   modify it under the terms of the GNU General Public License as
13048 +   published by the Free Software Foundation; either version 2, or (at
13049 +   your option) any later version.
13050 +
13051 +   This program is distributed in the hope that it will be useful, but
13052 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13053 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13054 +   General Public License for more details.
13055 +*/
13056 +
13057 +#include "ipkg.h"
13058 +
13059 +int str_starts_with(const char *str, const char *prefix)
13060 +{
13061 +    return (strncmp(str, prefix, strlen(prefix)) == 0);
13062 +}
13063 +
13064 +int str_ends_with(const char *str, const char *suffix)
13065 +{
13066 +    int suffix_len;
13067 +    int str_len;
13068 +
13069 +    str_len = strlen(str);
13070 +    suffix_len = strlen(suffix);
13071 +
13072 +    if (str_len < suffix_len) {
13073 +       return 0;
13074 +    }
13075 +
13076 +    return (strcmp(str + str_len - suffix_len, suffix) == 0);
13077 +}
13078 +
13079 +int str_chomp(char *str)
13080 +{
13081 +    if (str[strlen(str) - 1] == '\n') {
13082 +       str[strlen(str) - 1] = '\0';
13083 +       return 1;
13084 +    }
13085 +    return 0;
13086 +}
13087 +
13088 +int str_toupper(char *str)
13089 +{
13090 +    while (*str) {
13091 +       *str = toupper(*str);
13092 +       str++;
13093 +    }
13094 +
13095 +    return 0;
13096 +}
13097 +
13098 +char *str_dup_safe(const char *str)
13099 +{
13100 +    return str ? strdup(str) : NULL;
13101 +}
13102 +
13103 Index: busybox-1.7.2/archival/libipkg/str_util.h
13104 ===================================================================
13105 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13106 +++ busybox-1.7.2/archival/libipkg/str_util.h   2007-10-04 17:20:40.670574336 +0200
13107 @@ -0,0 +1,27 @@
13108 +/* str_utils.h - the itsy package management system
13109 +
13110 +   Carl D. Worth
13111 +
13112 +   Copyright (C) 2001 University of Southern California
13113 +
13114 +   This program is free software; you can redistribute it and/or
13115 +   modify it under the terms of the GNU General Public License as
13116 +   published by the Free Software Foundation; either version 2, or (at
13117 +   your option) any later version.
13118 +
13119 +   This program is distributed in the hope that it will be useful, but
13120 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13121 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13122 +   General Public License for more details.
13123 +*/
13124 +
13125 +#ifndef STR_UTILS_H
13126 +#define STR_UTILS_H
13127 +
13128 +int str_starts_with(const char *str, const char *prefix);
13129 +int str_ends_with(const char *str, const char *suffix);
13130 +int str_chomp(char *str);
13131 +int str_toupper(char *str);
13132 +char *str_dup_safe(const char *str);
13133 +
13134 +#endif
13135 Index: busybox-1.7.2/archival/libipkg/user.c
13136 ===================================================================
13137 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13138 +++ busybox-1.7.2/archival/libipkg/user.c       2007-10-04 17:14:23.757095256 +0200
13139 @@ -0,0 +1,58 @@
13140 +/* user.c - the itsy package management system
13141 +
13142 +   Jamey Hicks
13143 +
13144 +   Copyright (C) 2002 Hewlett Packard Company
13145 +   Copyright (C) 2001 University of Southern California
13146 +
13147 +   This program is free software; you can redistribute it and/or
13148 +   modify it under the terms of the GNU General Public License as
13149 +   published by the Free Software Foundation; either version 2, or (at
13150 +   your option) any later version.
13151 +
13152 +   This program is distributed in the hope that it will be useful, but
13153 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13154 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13155 +   General Public License for more details.
13156 +*/
13157 +
13158 +#include <stdio.h>
13159 +#include <stdarg.h>
13160 +#include "file_util.h"
13161 +#include "str_util.h"
13162 +#ifdef IPKG_LIB
13163 +#include "libipkg.h"
13164 +#endif
13165 +
13166 +
13167 +#ifdef IPKG_LIB
13168 +static char *question = NULL;
13169 +static int question_len = 255;
13170 +#endif
13171 +char *get_user_response(const char *format, ...)
13172 +{
13173 +     int len = question_len;
13174 +     va_list ap;
13175 +     char *response;
13176 +     va_start(ap, format);
13177 +
13178 +#ifndef IPKG_LIB
13179 +     vprintf(format, ap);
13180 +     do {
13181 +         response = file_read_line_alloc(stdin);
13182 +     } while (response == NULL);
13183 +#else
13184 +     do {
13185 +         if (question == NULL || len > question_len) {
13186 +              question = realloc(question, len + 1);
13187 +              question_len = len;
13188 +         }
13189 +         len = vsnprintf(question,question_len,format,ap);
13190 +     } while (len > question_len);
13191 +     response = strdup(ipkg_cb_response(question));
13192 +#endif
13193 +     str_chomp(response);
13194 +     str_tolower(response);
13195 +
13196 +     return response;
13197 +}
13198 Index: busybox-1.7.2/archival/libipkg/user.h
13199 ===================================================================
13200 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13201 +++ busybox-1.7.2/archival/libipkg/user.h       2007-10-04 17:14:23.785096849 +0200
13202 @@ -0,0 +1,23 @@
13203 +/* user.c - the itsy package management system
13204 +
13205 +   Jamey Hicks
13206 +
13207 +   Copyright (C) 2002 Hewlett Packard Company
13208 +   Copyright (C) 2001 University of Southern California
13209 +
13210 +   This program is free software; you can redistribute it and/or
13211 +   modify it under the terms of the GNU General Public License as
13212 +   published by the Free Software Foundation; either version 2, or (at
13213 +   your option) any later version.
13214 +
13215 +   This program is distributed in the hope that it will be useful, but
13216 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13217 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13218 +   General Public License for more details.
13219 +*/
13220 +
13221 +#include <stdio.h>
13222 +#include <stdarg.h>
13223 +
13224 +char *get_user_response(const char *format, ...);
13225 +
13226 Index: busybox-1.7.2/archival/libipkg/void_list.c
13227 ===================================================================
13228 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13229 +++ busybox-1.7.2/archival/libipkg/void_list.c  2007-10-04 17:14:23.805098002 +0200
13230 @@ -0,0 +1,194 @@
13231 +/* void_list.c - the itsy package management system
13232 +
13233 +   Carl D. Worth
13234 +
13235 +   Copyright (C) 2001 University of Southern California
13236 +
13237 +   This program is free software; you can redistribute it and/or
13238 +   modify it under the terms of the GNU General Public License as
13239 +   published by the Free Software Foundation; either version 2, or (at
13240 +   your option) any later version.
13241 +
13242 +   This program is distributed in the hope that it will be useful, but
13243 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13244 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13245 +   General Public License for more details.
13246 +*/
13247 +
13248 +#include "ipkg.h"
13249 +#include <errno.h>
13250 +
13251 +#include "void_list.h"
13252 +
13253 +int void_list_elt_init(void_list_elt_t *elt, void *data)
13254 +{
13255 +    elt->next = NULL;
13256 +    elt->data = data;
13257 +
13258 +    return 0;
13259 +}
13260 +
13261 +void void_list_elt_deinit(void_list_elt_t *elt)
13262 +{
13263 +    void_list_elt_init(elt, NULL);
13264 +}
13265 +
13266 +int void_list_init(void_list_t *list)
13267 +{
13268 +    void_list_elt_init(&list->pre_head, NULL);
13269 +    list->head = NULL;
13270 +    list->pre_head.next = list->head;
13271 +    list->tail = NULL;
13272 +
13273 +    return 0;
13274 +}
13275 +
13276 +void void_list_deinit(void_list_t *list)
13277 +{
13278 +    void_list_elt_t *elt;
13279 +
13280 +    while (list->head) {
13281 +       elt = void_list_pop(list);
13282 +       void_list_elt_deinit(elt);
13283 +       /* malloced in void_list_append */
13284 +       free(elt);
13285 +    }
13286 +}
13287 +
13288 +int void_list_append(void_list_t *list, void *data)
13289 +{
13290 +    void_list_elt_t *elt;
13291 +
13292 +    /* freed in void_list_deinit */
13293 +    elt = malloc(sizeof(void_list_elt_t));
13294 +    if (elt == NULL) {
13295 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
13296 +       return ENOMEM;
13297 +    }
13298 +
13299 +    void_list_elt_init(elt, data);
13300 +
13301 +    if (list->tail) {
13302 +       list->tail->next = elt;
13303 +       list->tail = elt;
13304 +    } else {
13305 +       list->head = elt;
13306 +       list->pre_head.next = list->head;
13307 +       list->tail = elt;
13308 +    }
13309 +
13310 +    return 0;
13311 +}
13312 +
13313 +int void_list_push(void_list_t *list, void *data)
13314 +{
13315 +    void_list_elt_t *elt;
13316 +
13317 +    elt = malloc(sizeof(void_list_elt_t));
13318 +    if (elt == NULL) {
13319 +       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
13320 +       return ENOMEM;
13321 +    }
13322 +
13323 +    void_list_elt_init(elt, data);
13324 +
13325 +    elt->next = list->head;
13326 +    list->head->next = elt;
13327 +    if (list->tail == NULL) {
13328 +       list->tail = list->head;
13329 +    }
13330 +
13331 +    return 0;
13332 +}
13333 +
13334 +void_list_elt_t *void_list_pop(void_list_t *list)
13335 +{
13336 +    void_list_elt_t *elt;
13337 +
13338 +    elt = list->head;
13339 +
13340 +    if (list->head) {
13341 +       list->head = list->head->next;
13342 +       list->pre_head.next = list->head;
13343 +       if (list->head == NULL) {
13344 +           list->tail = NULL;
13345 +       }
13346 +    }
13347 +
13348 +    return elt;
13349 +}
13350 +
13351 +void *void_list_remove(void_list_t *list, void_list_elt_t **iter)
13352 +{
13353 +    void_list_elt_t *prior;
13354 +    void_list_elt_t *old_elt;
13355 +    void *old_data;
13356 +
13357 +    old_elt = *iter;
13358 +    old_data = old_elt->data;
13359 +
13360 +    if (old_elt == list->head) {
13361 +       prior = &list->pre_head;
13362 +       void_list_pop(list);
13363 +    } else {
13364 +       for (prior = list->head; prior; prior = prior->next) {
13365 +           if (prior->next == old_elt) {
13366 +               break;
13367 +           }
13368 +       }
13369 +       if (prior == NULL || prior->next != old_elt) {
13370 +           fprintf(stderr, "%s: ERROR: element not found in list\n", __FUNCTION__);
13371 +           return NULL;
13372 +       }
13373 +       prior->next = old_elt->next;
13374 +
13375 +       if (old_elt == list->tail) {
13376 +           list->tail = prior;
13377 +       }
13378 +    }
13379 +
13380 +    void_list_elt_deinit(old_elt);
13381 +    *iter = prior;
13382 +
13383 +    return old_data;
13384 +}
13385 +
13386 +/* remove element containing elt data, using cmp(elt->data, target_data) == 0. */
13387 +void *void_list_remove_elt(void_list_t *list, const void *target_data, void_list_cmp_t cmp)
13388 +{
13389 +     void_list_elt_t *prior;
13390 +     void_list_elt_t *old_elt = NULL;
13391 +     void *old_data = NULL;
13392 +
13393 +     /* first element */
13394 +     if (list->head && list->head->data && (cmp(list->head->data, target_data) == 0)) {
13395 +         old_elt = list->head;
13396 +         old_data = list->head->data;
13397 +         void_list_pop(list);
13398 +     } else {
13399 +         int found = 0;
13400 +         for (prior = list->head; prior && prior->next; prior = prior->next) {
13401 +              if (prior->next->data && (cmp(prior->next->data, target_data) == 0)) {
13402 +                   old_elt = prior->next;
13403 +                   old_data = old_elt->data;
13404 +                   found = 1;
13405 +                   break;
13406 +              }
13407 +         }
13408 +         if (!found) {
13409 +              return NULL;
13410 +         }
13411 +         prior->next = old_elt->next;
13412 +
13413 +         if (old_elt == list->tail) {
13414 +              list->tail = prior;
13415 +         }
13416 +     }
13417 +     if (old_elt)
13418 +         void_list_elt_deinit(old_elt);
13419 +
13420 +     if (old_data)
13421 +         return old_data;
13422 +     else
13423 +         return NULL;
13424 +}
13425 Index: busybox-1.7.2/archival/libipkg/void_list.h
13426 ===================================================================
13427 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13428 +++ busybox-1.7.2/archival/libipkg/void_list.h  2007-10-04 17:14:23.841100046 +0200
13429 @@ -0,0 +1,59 @@
13430 +/* void_list.h - the itsy package management system
13431 +
13432 +   Carl D. Worth
13433 +
13434 +   Copyright (C) 2001 University of Southern California
13435 +
13436 +   This program is free software; you can redistribute it and/or
13437 +   modify it under the terms of the GNU General Public License as
13438 +   published by the Free Software Foundation; either version 2, or (at
13439 +   your option) any later version.
13440 +
13441 +   This program is distributed in the hope that it will be useful, but
13442 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13443 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13444 +   General Public License for more details.
13445 +*/
13446 +
13447 +#ifndef VOID_LIST_H
13448 +#define VOID_LIST_H
13449 +
13450 +typedef struct void_list_elt void_list_elt_t;
13451 +struct void_list_elt
13452 +{
13453 +    void_list_elt_t *next;
13454 +    void *data;
13455 +};
13456 +
13457 +typedef struct void_list void_list_t;
13458 +struct void_list
13459 +{
13460 +    void_list_elt_t pre_head;
13461 +    void_list_elt_t *head;
13462 +    void_list_elt_t *tail;
13463 +};
13464 +
13465 +static inline int void_list_empty(void_list_t *list)
13466 +{
13467 +     if (list->head == NULL)
13468 +         return 1;
13469 +     else
13470 +         return 0;
13471 +}
13472 +
13473 +int void_list_elt_init(void_list_elt_t *elt, void *data);
13474 +void void_list_elt_deinit(void_list_elt_t *elt);
13475 +
13476 +int void_list_init(void_list_t *list);
13477 +void void_list_deinit(void_list_t *list);
13478 +
13479 +int void_list_append(void_list_t *list, void *data);
13480 +int void_list_push(void_list_t *list, void *data);
13481 +void_list_elt_t *void_list_pop(void_list_t *list);
13482 +
13483 +void *void_list_remove(void_list_t *list, void_list_elt_t **iter);
13484 +/* remove element containing elt data, using cmp(elt->data, target_data) == 0. */
13485 +typedef int (*void_list_cmp_t)(const void *, const void *);
13486 +void *void_list_remove_elt(void_list_t *list, const void *target_data, void_list_cmp_t cmp);
13487 +
13488 +#endif
13489 Index: busybox-1.7.2/archival/libipkg/xsystem.c
13490 ===================================================================
13491 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13492 +++ busybox-1.7.2/archival/libipkg/xsystem.c    2007-10-04 17:14:23.865101421 +0200
13493 @@ -0,0 +1,64 @@
13494 +/* xsystem.c - system(3) with error messages
13495 +
13496 +   Carl D. Worth
13497 +
13498 +   Copyright (C) 2001 University of Southern California
13499 +
13500 +   This program is free software; you can redistribute it and/or
13501 +   modify it under the terms of the GNU General Public License as
13502 +   published by the Free Software Foundation; either version 2, or (at
13503 +   your option) any later version.
13504 +
13505 +   This program is distributed in the hope that it will be useful, but
13506 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13507 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13508 +   General Public License for more details.
13509 +*/
13510 +
13511 +#include "ipkg.h"
13512 +#include <sys/wait.h>
13513 +
13514 +#include "xsystem.h"
13515 +
13516 +/* XXX: FEATURE: I shouldn't actually use system(3) at all. I don't
13517 +   really need the /bin/sh invocation which takes resources and
13518 +   introduces security problems. I should switch all of this to a sort
13519 +   of execl() or execv() interface/implementation.
13520 +*/
13521 +
13522 +/* Like system(3), but with error messages printed if the fork fails
13523 +   or if the child process dies due to an uncaught signal. Also, the
13524 +   return value is a bit simpler:
13525 +
13526 +   -1 if there was any problem
13527 +   Otherwise, the 8-bit return value of the program ala WEXITSTATUS
13528 +   as defined in <sys/wait.h>.
13529 +*/
13530 +int xsystem(const char *cmd)
13531 +{
13532 +    int err;
13533 +
13534 +    err = system(cmd);
13535 +
13536 +    if (err == -1) {
13537 +       fprintf(stderr, "%s: ERROR: fork failed before execution: `%s'\n",
13538 +               __FUNCTION__, cmd);
13539 +       return -1;
13540 +    }
13541 +
13542 +    if (WIFSIGNALED(err)) {
13543 +       fprintf(stderr, "%s: ERROR: Child process died due to signal %d: `%s'\n",
13544 +               __FUNCTION__, WTERMSIG(err), cmd);
13545 +       return -1;
13546 +    }
13547 +
13548 +    if (WIFEXITED(err)) {
13549 +       /* Normal child exit */
13550 +       return WEXITSTATUS(err);
13551 +    }
13552 +
13553 +    fprintf(stderr, "%s: ERROR: Received unintelligible return value from system: %d",
13554 +           __FUNCTION__, err);
13555 +    return -1;
13556 +}
13557 +
13558 Index: busybox-1.7.2/archival/libipkg/xsystem.h
13559 ===================================================================
13560 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
13561 +++ busybox-1.7.2/archival/libipkg/xsystem.h    2007-10-04 17:14:23.885102559 +0200
13562 @@ -0,0 +1,34 @@
13563 +/* xsystem.h - system(3) with error messages
13564 +
13565 +   Carl D. Worth
13566 +
13567 +   Copyright (C) 2001 University of Southern California
13568 +
13569 +   This program is free software; you can redistribute it and/or
13570 +   modify it under the terms of the GNU General Public License as
13571 +   published by the Free Software Foundation; either version 2, or (at
13572 +   your option) any later version.
13573 +
13574 +   This program is distributed in the hope that it will be useful, but
13575 +   WITHOUT ANY WARRANTY; without even the implied warranty of
13576 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13577 +   General Public License for more details.
13578 +*/
13579 +
13580 +#ifndef XSYSTEM_H
13581 +#define XSYSTEM_H
13582 +
13583 +#include <stdlib.h>
13584 +
13585 +/* Like system(3), but with error messages printed if the fork fails
13586 +   or if the child process dies due to an uncaught signal. Also, the
13587 +   return value is a bit simpler:
13588 +
13589 +   -1 if there was any problem
13590 +   Otherwise, the 8-bit return value of the program ala WEXITSTATUS
13591 +   as defined in <sys/wait.h>.
13592 +*/
13593 +int xsystem(const char *cmd);
13594 +
13595 +#endif
13596 +
13597 Index: busybox-1.7.2/archival/libunarchive/data_extract_all.c
13598 ===================================================================
13599 --- busybox-1.7.2.orig/archival/libunarchive/data_extract_all.c 2007-10-04 17:12:34.462866938 +0200
13600 +++ busybox-1.7.2/archival/libunarchive/data_extract_all.c      2007-10-04 17:14:23.905103687 +0200
13601 @@ -129,3 +129,17 @@
13602                 }
13603         }
13604  }
13605 +
13606 +extern void data_extract_all_prefix(archive_handle_t *archive_handle)
13607 +{
13608 +       char *name_ptr = archive_handle->file_header->name;
13609 +
13610 +       name_ptr += strspn(name_ptr, "./");
13611 +       if (name_ptr[0] != '\0') {
13612 +               archive_handle->file_header->name = xmalloc(strlen(archive_handle->buffer) + 1 + strlen(name_ptr) + 1);
13613 +               strcpy(archive_handle->file_header->name, archive_handle->buffer);
13614 +               strcat(archive_handle->file_header->name, name_ptr);
13615 +               data_extract_all(archive_handle);
13616 +       }
13617 +}
13618 +
13619 Index: busybox-1.7.2/archival/libunarchive/Kbuild
13620 ===================================================================
13621 --- busybox-1.7.2.orig/archival/libunarchive/Kbuild     2007-10-04 17:12:34.474867620 +0200
13622 +++ busybox-1.7.2/archival/libunarchive/Kbuild  2007-10-04 17:14:23.925104840 +0200
13623 @@ -55,6 +55,7 @@
13624  lib-$(CONFIG_FEATURE_DEB_TAR_LZMA)      += decompress_unlzma.o get_header_tar_lzma.o
13625  lib-$(CONFIG_GUNZIP)                    += $(GUNZIP_FILES)
13626  lib-$(CONFIG_FEATURE_GUNZIP_UNCOMPRESS) += decompress_uncompress.o
13627 +lib-$(CONFIG_IPKG)                     += $(GUNZIP_FILES) get_header_tar.o get_header_tar_gz.o
13628  lib-$(CONFIG_RPM2CPIO)                  += $(GUNZIP_FILES) get_header_cpio.o
13629  lib-$(CONFIG_RPM)                       += $(GUNZIP_FILES) get_header_cpio.o
13630  lib-$(CONFIG_FEATURE_RPM_BZ2)           += decompress_bunzip2.o
13631 Index: busybox-1.7.2/include/applets.h
13632 ===================================================================
13633 --- busybox-1.7.2.orig/include/applets.h        2007-10-04 17:13:12.525035978 +0200
13634 +++ busybox-1.7.2/include/applets.h     2007-10-04 17:24:51.052842811 +0200
13635 @@ -190,6 +190,7 @@
13636  USE_IPCALC(APPLET(ipcalc, _BB_DIR_BIN, _BB_SUID_NEVER))
13637  USE_IPCRM(APPLET(ipcrm, _BB_DIR_USR_BIN, _BB_SUID_ALWAYS))
13638  USE_IPCS(APPLET(ipcs, _BB_DIR_USR_BIN, _BB_SUID_ALWAYS))
13639 +USE_IPKG(APPLET(ipkg, _BB_DIR_USR_BIN, _BB_SUID_NEVER))
13640  USE_IPLINK(APPLET(iplink, _BB_DIR_BIN, _BB_SUID_NEVER))
13641  USE_IPROUTE(APPLET(iproute, _BB_DIR_BIN, _BB_SUID_NEVER))
13642  USE_IPRULE(APPLET(iprule, _BB_DIR_BIN, _BB_SUID_NEVER))
13643 Index: busybox-1.7.2/include/unarchive.h
13644 ===================================================================
13645 --- busybox-1.7.2.orig/include/unarchive.h      2007-10-04 17:12:34.486868309 +0200
13646 +++ busybox-1.7.2/include/unarchive.h   2007-10-04 17:14:23.989108482 +0200
13647 @@ -74,6 +74,7 @@
13648
13649  extern void data_skip(archive_handle_t *archive_handle);
13650  extern void data_extract_all(archive_handle_t *archive_handle);
13651 +extern void data_extract_all_prefix(archive_handle_t *archive_handle);
13652  extern void data_extract_to_stdout(archive_handle_t *archive_handle);
13653  extern void data_extract_to_buffer(archive_handle_t *archive_handle);
13654
13655 Index: busybox-1.7.2/include/usage.h
13656 ===================================================================
13657 --- busybox-1.7.2.orig/include/usage.h  2007-10-04 17:13:12.629041904 +0200
13658 +++ busybox-1.7.2/include/usage.h       2007-10-04 17:14:23.993108707 +0200
13659 @@ -1226,6 +1226,82 @@
13660         "$ ls -la /tmp/busybox*\n" \
13661         "-rw-rw-r--    1 andersen andersen   554058 Apr 14 17:49 /tmp/busybox.tar.gz\n"
13662
13663 +#define ipkg_trivial_usage \
13664 +       "[options]... sub-command [arguments]..."
13665 +#define ipkg_full_usage \
13666 +       "ipkg is an utility to install, remove and manage .ipk packages.\n" \
13667 +       "\n" \
13668 +       "Sub-commands:\n" \
13669 +       "\nPackage Manipulation:\n" \
13670 +       "\tupdate               Update list of available packages\n" \
13671 +       "\tupgrade                      Upgrade all installed packages to latest version\n" \
13672 +       "\tinstall <pkg>                Download and install <pkg> (and dependencies)\n" \
13673 +       "\tinstall <file.ipk>   Install package <file.ipk>\n" \
13674 +       "\tconfigure [<pkg>]    Configure unpacked packages\n" \
13675 +       "\tremove <pkg|regexp>  Remove package <pkg|packages following regexp>\n" \
13676 +       "\tflag <flag> <pkg> ...        Flag package(s) <pkg>\n" \
13677 +       "\t <flag>=hold|noprune|user|ok|installed|unpacked (one per invocation) \n" \
13678 +       "\n" \
13679 +       "Informational Commands:\n" \
13680 +       "\tlist                 List available packages and descriptions\n" \
13681 +       "\tlist_installed               List all and only the installed packages and description \n" \
13682 +       "\tfiles <pkg>          List all files belonging to <pkg>\n" \
13683 +       "\tsearch <file|regexp>         Search for a package providing <file>\n" \
13684 +       "\tinfo [pkg|regexp [<field>]]  Display all/some info fields for <pkg> or all\n" \
13685 +       "\tstatus [pkg|regexp [<field>]]        Display all/some status fields for <pkg> or all\n" \
13686 +       "\tdownload <pkg>               Download <pkg> to current directory.\n" \
13687 +       "\tcompare_versions <v1> <op> <v2>\n" \
13688 +       "\t                          compare versions using <= < > >= = << >>\n" \
13689 +       "\tprint_architecture      prints the architecture.\n" \
13690 +       "\tprint_installation_architecture\n" \
13691 +       "\twhatdepends [-A] [pkgname|pat]+\n" \
13692 +       "\twhatdependsrec [-A] [pkgname|pat]+\n" \
13693 +       "\twhatprovides [-A] [pkgname|pat]+\n" \
13694 +       "\twhatconflicts [-A] [pkgname|pat]+\n" \
13695 +       "\twhatreplaces [-A] [pkgname|pat]+\n" \
13696 +       "\t                        prints the installation architecture.\n" \
13697 +       "\n" \
13698 +       "\nOptions:\n" \
13699 +       "\t-A                      Query all packages with whatdepends, whatprovides, whatreplaces, whatconflicts\n" \
13700 +       "\t-V <level>               Set verbosity level to <level>. If no value is\n" \
13701 +       "\t--verbosity <level>      provided increase verbosity by one. Verbosity levels:\n" \
13702 +       "\t                         0 errors only\n" \
13703 +       "\t                         1 normal messages (default)\n" \
13704 +       "\t                         2 informative messages\n" \
13705 +       "\t                         3 debug output\n" \
13706 +       "\t-f <conf_file>               Use <conf_file> as the ipkg configuration file\n" \
13707 +       "\t-conf <conf_file>    Default configuration file location\n" \
13708 +       "                               is /etc/ipkg.conf\n" \
13709 +       "\t-d <dest_name>               Use <dest_name> as the the root directory for\n" \
13710 +       "\t-dest <dest_name>    package installation, removal, upgrading.\n" \
13711 +       "                               <dest_name> should be a defined dest name from\n" \
13712 +       "                               the configuration file, (but can also be a\n" \
13713 +       "                               directory name in a pinch).\n" \
13714 +       "\t-o <offline_root>    Use <offline_root> as the root directory for\n" \
13715 +       "\t-offline <offline_root>      offline installation of packages.\n" \
13716 +       "\t-verbose_wget                more wget messages\n" \
13717 +       "\n" \
13718 +       "Force Options (use when ipkg is too smart for its own good):\n" \
13719 +       "\t-force-depends               Make dependency checks warnings instead of errors\n" \
13720 +       "\t                             Install/remove package in spite of failed dependences\n" \
13721 +       "\t-force-defaults              Use default options for questions asked by ipkg.\n" \
13722 +       "                               (no prompts). Note that this will not prevent\n" \
13723 +       "                               package installation scripts from prompting.\n" \
13724 +       "\t-force-reinstall     Allow ipkg to reinstall a package.\n" \
13725 +       "\t-force-overwrite     Allow ipkg to overwrite files from another package during an install.\n" \
13726 +       "\t-force-downgrade     Allow ipkg to downgrade packages.\n" \
13727 +       "\t-force_space            Install even if there does not seem to be enough space.\n" \
13728 +       "\t-noaction               No action -- test only\n" \
13729 +       "\t-nodeps                 Do not follow dependences\n" \
13730 +       "\t-force-removal-of-dependent-packages\n" \
13731 +       "\t-recursive           Allow ipkg to remove package and all that depend on it.\n" \
13732 +       "\t-test                   No action -- test only\n" \
13733 +       "\t-t                   Specify tmp-dir.\n" \
13734 +       "\t--tmp-dir            Specify tmp-dir.\n" \
13735 +       "\n" \
13736 +       "\tregexp could be something like 'pkgname*' '*file*' or similar\n" \
13737 +       "\teg: ipkg info 'libstd*' or ipkg search '*libop*' or ipkg remove 'libncur*'\n"
13738 +
13739  #define halt_trivial_usage \
13740         "[-d delay] [-n] [-f]"
13741  #define halt_full_usage \
13742 Index: busybox-1.7.2/Makefile
13743 ===================================================================
13744 --- busybox-1.7.2.orig/Makefile 2007-10-04 17:12:34.502869218 +0200
13745 +++ busybox-1.7.2/Makefile      2007-10-04 17:14:24.021110304 +0200
13746 @@ -428,6 +428,7 @@
13747
13748  libs-y         := \
13749                 archival/ \
13750 +               archival/libipkg/ \
13751                 archival/libunarchive/ \
13752                 console-tools/ \
13753                 coreutils/ \