• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/opkg-lede/libopkg/opkg_install.c

  1 /* opkg_install.c - the opkg package management system
  2 
  3    Carl D. Worth
  4 
  5    Copyright (C) 2001 University of Southern California
  6 
  7    This program is free software; you can redistribute it and/or
  8    modify it under the terms of the GNU General Public License as
  9    published by the Free Software Foundation; either version 2, or (at
 10    your option) any later version.
 11 
 12    This program is distributed in the hope that it will be useful, but
 13    WITHOUT ANY WARRANTY; without even the implied warranty of
 14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 15    General Public License for more details.
 16 */
 17 
 18 #include <stdio.h>
 19 #include <time.h>
 20 #include <signal.h>
 21 #include <unistd.h>
 22 #include <sys/stat.h>
 23 
 24 #include "pkg.h"
 25 #include "pkg_hash.h"
 26 #include "pkg_extract.h"
 27 
 28 #include "opkg_install.h"
 29 #include "opkg_configure.h"
 30 #include "opkg_download.h"
 31 #include "opkg_remove.h"
 32 
 33 #include "opkg_utils.h"
 34 #include "opkg_message.h"
 35 #include "opkg_cmd.h"
 36 #include "opkg_defines.h"
 37 
 38 #include "sprintf_alloc.h"
 39 #include "file_util.h"
 40 #include "xsystem.h"
 41 #include "libbb/libbb.h"
 42 
 43 static int satisfy_dependencies_for(pkg_t * pkg)
 44 {
 45         int i, err;
 46         pkg_vec_t *depends = pkg_vec_alloc();
 47         pkg_t *dep;
 48         char **tmp, **unresolved = NULL, *prev = NULL;
 49         int ndepends;
 50 
 51         ndepends = pkg_hash_fetch_unsatisfied_dependencies(pkg, depends,
 52                                                            &unresolved);
 53 
 54         if (unresolved) {
 55                 opkg_msg(ERROR,
 56                          "Cannot satisfy the following dependencies for %s:\n",
 57                          pkg->name);
 58                 tmp = unresolved;
 59                 while (*unresolved) {
 60                         if (!prev || strcmp(*unresolved, prev))
 61                                 opkg_message(ERROR, "\t%s\n", *unresolved);
 62                         prev = *unresolved;
 63                         unresolved++;
 64                 }
 65                 unresolved = tmp;
 66                 while (*unresolved) {
 67                         free(*unresolved);
 68                         unresolved++;
 69                 }
 70                 free(tmp);
 71                 if (!conf->force_depends) {
 72                         opkg_msg(INFO,
 73                                  "This could mean that your package list is out of date or that the packages\n"
 74                                  "mentioned above do not yet exist (try 'opkg update'). To proceed in spite\n"
 75                                  "of this problem try again with the '-force-depends' option.\n");
 76                         pkg_vec_free(depends);
 77                         return -1;
 78                 }
 79         }
 80 
 81         if (ndepends <= 0) {
 82                 pkg_vec_free(depends);
 83                 return 0;
 84         }
 85 
 86         /* Mark packages as to-be-installed */
 87         for (i = 0; i < depends->len; i++) {
 88                 /* Dependencies should be installed the same place as pkg */
 89                 if (depends->pkgs[i]->dest == NULL) {
 90                         depends->pkgs[i]->dest = pkg->dest;
 91                 }
 92                 depends->pkgs[i]->state_want = SW_INSTALL;
 93         }
 94 
 95         for (i = 0; i < depends->len; i++) {
 96                 dep = depends->pkgs[i];
 97                 /* The package was uninstalled when we started, but another
 98                    dep earlier in this loop may have depended on it and pulled
 99                    it in, so check first. */
100                 if ((dep->state_status != SS_INSTALLED)
101                     && (dep->state_status != SS_UNPACKED)) {
102                         opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
103                         err = opkg_install_pkg(dep, 0);
104                         /* mark this package as having been automatically installed to
105                          * satisfy a dependancy */
106                         dep->auto_installed = 1;
107                         if (err) {
108                                 pkg_vec_free(depends);
109                                 return err;
110                         }
111                 }
112         }
113 
114         pkg_vec_free(depends);
115 
116         return 0;
117 }
118 
119 static int check_conflicts_for(pkg_t * pkg)
120 {
121         int i;
122         pkg_vec_t *conflicts = NULL;
123         message_level_t level;
124 
125         if (conf->force_depends) {
126                 level = NOTICE;
127         } else {
128                 level = ERROR;
129         }
130 
131         if (!conf->force_depends)
132                 conflicts = pkg_hash_fetch_conflicts(pkg);
133 
134         if (conflicts) {
135                 opkg_msg(level, "The following packages conflict with %s:\n",
136                          pkg->name);
137                 i = 0;
138                 while (i < conflicts->len)
139                         opkg_msg(level, "\t%s", conflicts->pkgs[i++]->name);
140                 opkg_message(level, "\n");
141                 pkg_vec_free(conflicts);
142                 return -1;
143         }
144         return 0;
145 }
146 
147 static int update_file_ownership(pkg_t * new_pkg, pkg_t * old_pkg)
148 {
149         str_list_t *new_list, *old_list;
150         str_list_elt_t *iter, *niter;
151 
152         new_list = pkg_get_installed_files(new_pkg);
153         if (new_list == NULL)
154                 return -1;
155 
156         for (iter = str_list_first(new_list), niter =
157              str_list_next(new_list, iter); iter;
158              iter = niter, niter = str_list_next(new_list, niter)) {
159                 char *new_file = (char *)iter->data;
160                 pkg_t *owner = file_hash_get_file_owner(new_file);
161                 pkg_t *obs = hash_table_get(&conf->obs_file_hash, new_file);
162 
163                 opkg_msg(DEBUG2,
164                          "%s: new_pkg=%s wants file %s, from owner=%s\n",
165                          __func__, new_pkg->name, new_file,
166                          owner ? owner->name : "<NULL>");
167 
168                 if (!owner || (owner == old_pkg) || obs)
169                         file_hash_set_file_owner(new_file, new_pkg);
170         }
171 
172         if (old_pkg) {
173                 old_list = pkg_get_installed_files(old_pkg);
174                 if (old_list == NULL) {
175                         pkg_free_installed_files(new_pkg);
176                         return -1;
177                 }
178 
179                 for (iter = str_list_first(old_list), niter =
180                      str_list_next(old_list, iter); iter;
181                      iter = niter, niter = str_list_next(old_list, niter)) {
182                         char *old_file = (char *)iter->data;
183                         pkg_t *owner = file_hash_get_file_owner(old_file);
184                         if (!owner || (owner == old_pkg)) {
185                                 /* obsolete */
186                                 hash_table_insert(&conf->obs_file_hash,
187                                                   old_file, old_pkg);
188                         }
189                 }
190                 pkg_free_installed_files(old_pkg);
191         }
192         pkg_free_installed_files(new_pkg);
193         return 0;
194 }
195 
196 static int verify_pkg_installable(pkg_t * pkg)
197 {
198         unsigned long kbs_available, pkg_size_kbs;
199         unsigned long installed_size;
200         char *root_dir = NULL;
201         struct stat s;
202 
203         installed_size = (unsigned long) pkg_get_int(pkg, PKG_INSTALLED_SIZE);
204 
205         if (conf->force_space || installed_size == 0)
206                 return 0;
207 
208         if (pkg->dest) {
209                 if (!strcmp(pkg->dest->name, "root") && conf->overlay_root
210                     && !stat(conf->overlay_root, &s) && (s.st_mode & S_IFDIR))
211                         root_dir = conf->overlay_root;
212                 else
213                         root_dir = pkg->dest->root_dir;
214         }
215 
216         if (!root_dir)
217                 root_dir = conf->default_dest->root_dir;
218 
219         kbs_available = get_available_kbytes(root_dir);
220 
221         pkg_size_kbs = (installed_size + 1023) / 1024;
222 
223         if (pkg_size_kbs >= kbs_available) {
224                 opkg_msg(ERROR, "Only have %ldkb available on filesystem %s, "
225                          "pkg %s needs %ld\n",
226                          kbs_available, root_dir, pkg->name, pkg_size_kbs);
227                 return -1;
228         }
229 
230         return 0;
231 }
232 
233 static int unpack_pkg_control_files(pkg_t * pkg)
234 {
235         int err;
236         char *conffiles_file_name;
237         char *root_dir;
238         char *tmp_unpack_dir;
239         FILE *conffiles_file;
240         conffile_list_t *cl;
241 
242         sprintf_alloc(&tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir,
243                       pkg->name);
244 
245         tmp_unpack_dir = mkdtemp(tmp_unpack_dir);
246         if (tmp_unpack_dir == NULL) {
247                 opkg_perror(ERROR, "Failed to create temporary directory");
248                 return -1;
249         }
250 
251         pkg_set_string(pkg, PKG_TMP_UNPACK_DIR, tmp_unpack_dir);
252 
253         err = pkg_extract_control_files_to_dir(pkg, tmp_unpack_dir);
254         if (err) {
255                 return err;
256         }
257 
258         /* XXX: CLEANUP: There might be a cleaner place to read in the
259            conffiles. Seems like I should be able to get everything to go
260            through pkg_init_from_file. If so, maybe it would make sense to
261            move all of unpack_pkg_control_files to that function. */
262 
263         /* Don't need to re-read conffiles if we already have it */
264         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
265         if (cl && !nv_pair_list_empty(cl)) {
266                 return 0;
267         }
268 
269         sprintf_alloc(&conffiles_file_name, "%s/conffiles",
270                       tmp_unpack_dir);
271         if (!file_exists(conffiles_file_name)) {
272                 free(conffiles_file_name);
273                 return 0;
274         }
275 
276         conffiles_file = fopen(conffiles_file_name, "r");
277         if (conffiles_file == NULL) {
278                 opkg_perror(ERROR, "Failed to open %s", conffiles_file_name);
279                 free(conffiles_file_name);
280                 return -1;
281         }
282         free(conffiles_file_name);
283 
284         cl = xcalloc(1, sizeof(*cl));
285         conffile_list_init(cl);
286 
287         while (1) {
288                 char *cf_name;
289                 char *cf_name_in_dest;
290                 int i;
291 
292                 cf_name = file_read_line_alloc(conffiles_file);
293                 if (cf_name == NULL) {
294                         break;
295                 }
296                 if (cf_name[0] == '\0') {
297                         continue;
298                 }
299                 for (i = strlen(cf_name) - 1;
300                      (i >= 0) && (cf_name[i] == ' ' || cf_name[i] == '\t');
301                      i--) {
302                         cf_name[i] = '\0';
303                 }
304 
305                 /* Prepend dest->root_dir to conffile name.
306                    Take pains to avoid multiple slashes. */
307                 root_dir = pkg->dest->root_dir;
308                 if (conf->offline_root)
309                         /* skip the offline_root prefix */
310                         root_dir =
311                             pkg->dest->root_dir + strlen(conf->offline_root);
312                 sprintf_alloc(&cf_name_in_dest, "%s%s", root_dir,
313                               cf_name[0] == '/' ? (cf_name + 1) : cf_name);
314 
315                 /* Can't get an md5sum now, (file isn't extracted yet).
316                    We'll wait until resolve_conffiles */
317                 conffile_list_append(cl, cf_name_in_dest, NULL);
318 
319                 free(cf_name);
320                 free(cf_name_in_dest);
321         }
322 
323         pkg_set_ptr(pkg, PKG_CONFFILES, cl);
324 
325         fclose(conffiles_file);
326 
327         return 0;
328 }
329 
330 /*
331  * Remove packages which were auto_installed due to a dependency by old_pkg,
332  * which are no longer a dependency in the new (upgraded) pkg.
333  */
334 static int pkg_remove_orphan_dependent(pkg_t * pkg, pkg_t * old_pkg)
335 {
336         int j, l, found, r, err = 0;
337         int n_deps;
338         pkg_t *p;
339         struct compound_depend *cd0, *cd1;
340         abstract_pkg_t **dependents;
341 
342         for (cd0 = pkg_get_ptr(old_pkg, PKG_DEPENDS); cd0 && cd0->type; cd0++) {
343                 if (cd0->type != DEPEND)
344                         continue;
345                 for (j = 0; j < cd0->possibility_count; j++) {
346 
347                         found = 0;
348 
349                         for (cd1 = pkg_get_ptr(pkg, PKG_DEPENDS); cd1 && cd1->type; cd1++) {
350                                 if (cd1->type != DEPEND)
351                                         continue;
352                                 for (l = 0; l < cd1->possibility_count; l++) {
353                                         if (cd0->possibilities[j]
354                                             == cd1->possibilities[l]) {
355                                                 found = 1;
356                                                 break;
357                                         }
358                                 }
359                                 if (found)
360                                         break;
361                         }
362 
363                         if (found)
364                                 continue;
365 
366                         /*
367                          * old_pkg has a dependency that pkg does not.
368                          */
369                         p = pkg_hash_fetch_installed_by_name(cd0->
370                                                              possibilities[j]->
371                                                              pkg->name);
372 
373                         if (!p)
374                                 continue;
375 
376                         if (!p->auto_installed)
377                                 continue;
378 
379                         n_deps = pkg_has_installed_dependents(p, &dependents);
380                         n_deps--;       /* don't count old_pkg */
381 
382                         if (n_deps == 0) {
383                                 opkg_msg(NOTICE, "%s was autoinstalled and is "
384                                          "now orphaned, removing.\n", p->name);
385 
386                                 /* p has one installed dependency (old_pkg),
387                                  * which we need to ignore during removal. */
388                                 p->state_flag |= SF_REPLACE;
389 
390                                 r = opkg_remove_pkg(p, 0);
391                                 if (!err)
392                                         err = r;
393                         } else
394                                 opkg_msg(INFO, "%s was autoinstalled and is "
395                                          "still required by %d "
396                                          "installed packages.\n",
397                                          p->name, n_deps);
398 
399                 }
400         }
401 
402         return err;
403 }
404 
405 /* returns number of installed replacees */
406 static int
407 pkg_get_installed_replacees(pkg_t * pkg, pkg_vec_t * installed_replacees)
408 {
409         abstract_pkg_t **replaces = pkg_get_ptr(pkg, PKG_REPLACES);
410         int j;
411 
412         while (replaces && *replaces) {
413                 abstract_pkg_t *ab_pkg = *replaces++;
414                 pkg_vec_t *pkg_vec = ab_pkg->pkgs;
415                 if (pkg_vec) {
416                         for (j = 0; j < pkg_vec->len; j++) {
417                                 pkg_t *replacee = pkg_vec->pkgs[j];
418                                 if (!pkg_conflicts(pkg, replacee))
419                                         continue;
420                                 if (replacee->state_status == SS_INSTALLED) {
421                                         pkg_vec_insert(installed_replacees,
422                                                        replacee);
423                                 }
424                         }
425                 }
426         }
427 
428         return installed_replacees->len;
429 }
430 
431 static int pkg_remove_installed_replacees(pkg_vec_t * replacees)
432 {
433         int i;
434         int replaces_count = replacees->len;
435         for (i = 0; i < replaces_count; i++) {
436                 pkg_t *replacee = replacees->pkgs[i];
437                 int err;
438                 replacee->state_flag |= SF_REPLACE;     /* flag it so remove won't complain */
439                 err = opkg_remove_pkg(replacee, 0);
440                 if (err)
441                         return err;
442         }
443         return 0;
444 }
445 
446 /* to unwind the removal: make sure they are installed */
447 static int pkg_remove_installed_replacees_unwind(pkg_vec_t * replacees)
448 {
449         int i, err;
450         int replaces_count = replacees->len;
451         for (i = 0; i < replaces_count; i++) {
452                 pkg_t *replacee = replacees->pkgs[i];
453                 if (replacee->state_status != SS_INSTALLED) {
454                         opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
455                         err = opkg_install_pkg(replacee, 0);
456                         if (err)
457                                 return err;
458                 }
459         }
460         return 0;
461 }
462 
463 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
464 static int
465 opkg_install_check_downgrade(pkg_t * pkg, pkg_t * old_pkg, int message)
466 {
467         if (old_pkg) {
468                 char message_out[15];
469                 char *old_version = pkg_version_str_alloc(old_pkg);
470                 char *new_version = pkg_version_str_alloc(pkg);
471                 int cmp = pkg_compare_versions(old_pkg, pkg);
472                 int rc = 0;
473 
474                 memset(message_out, '\x', 15);
475                 strncpy(message_out, "Upgrading ", strlen("Upgrading "));
476                 if ((conf->force_downgrade == 1) && (cmp > 0)) {        /* We've been asked to allow downgrade  and version is precedent */
477                         cmp = -1;       /* then we force opkg to downgrade */
478                         strncpy(message_out, "Downgrading ", strlen("Downgrading "));   /* We need to use a value < 0 because in the 0 case we are asking to */
479                         /* reinstall, and some check could fail asking the "force-reinstall" option */
480                 }
481 
482                 if (cmp > 0) {
483                         if (!conf->download_only)
484                                 opkg_msg(NOTICE,
485                                          "Not downgrading package %s on %s from %s to %s.\n",
486                                          old_pkg->name, old_pkg->dest->name,
487                                          old_version, new_version);
488                         rc = 1;
489                 } else if (cmp < 0) {
490                         if (!conf->download_only)
491                                 opkg_msg(NOTICE,
492                                          "%s%s on %s from %s to %s...\n",
493                                          message_out, pkg->name,
494                                          old_pkg->dest->name, old_version,
495                                          new_version);
496                         pkg->dest = old_pkg->dest;
497                         rc = 0;
498                 } else {        /* cmp == 0 */
499 
500                         if (!conf->download_only)
501                                 opkg_msg(NOTICE,
502                                          "%s (%s) already install on %s.\n",
503                                          pkg->name, new_version,
504                                          old_pkg->dest->name);
505                         rc = 1;
506                 }
507                 free(old_version);
508                 free(new_version);
509                 return rc;
510         } else {
511                 char message_out[15];
512                 memset(message_out, '\x', 15);
513                 if (message)
514                         strncpy(message_out, "Upgrading ",
515                                 strlen("Upgrading "));
516                 else
517                         strncpy(message_out, "Installing ",
518                                 strlen("Installing "));
519                 char *version = pkg_version_str_alloc(pkg);
520 
521                 if (!conf->download_only)
522                         opkg_msg(NOTICE, "%s%s (%s) to %s...\n", message_out,
523                                  pkg->name, version, pkg->dest->name);
524                 free(version);
525         }
526         return 0;
527 }
528 
529 static int prerm_upgrade_old_pkg(pkg_t * pkg, pkg_t * old_pkg)
530 {
531         /* DPKG_INCOMPATIBILITY:
532            dpkg does some things here that we don't do yet. Do we care?
533 
534            1. If a version of the package is already installed, call
535            old-prerm upgrade new-version
536            2. If the script runs but exits with a non-zero exit status
537            new-prerm failed-upgrade old-version
538            Error unwind, for both the above cases:
539            old-postinst abort-upgrade new-version
540          */
541         int err;
542         char *script_args;
543         char *new_version;
544 
545         if (!old_pkg || !pkg)
546                 return 0;
547 
548         new_version = pkg_version_str_alloc(pkg);
549 
550         sprintf_alloc(&script_args, "upgrade %s", new_version);
551         free(new_version);
552         err = pkg_run_script(old_pkg, "prerm", script_args);
553         free(script_args);
554         if (err != 0) {
555                 opkg_msg(ERROR, "prerm script for package \"%s\" failed\n",
556                          old_pkg->name);
557                 return -1;
558         }
559         return 0;
560 }
561 
562 static int prerm_upgrade_old_pkg_unwind(pkg_t * pkg, pkg_t * old_pkg)
563 {
564         /* DPKG_INCOMPATIBILITY:
565            dpkg does some things here that we don't do yet. Do we care?
566            (See prerm_upgrade_old_package for details)
567          */
568         return 0;
569 }
570 
571 static int prerm_deconfigure_conflictors(pkg_t * pkg, pkg_vec_t * conflictors)
572 {
573         /* DPKG_INCOMPATIBILITY:
574            dpkg does some things here that we don't do yet. Do we care?
575            2. If a 'conflicting' package is being removed at the same time:
576            1. If any packages depended on that conflicting package and
577            --auto-deconfigure is specified, call, for each such package:
578            deconfigured's-prerm deconfigure \
579            in-favour package-being-installed version \
580            removing conflicting-package version
581            Error unwind:
582            deconfigured's-postinst abort-deconfigure \
583            in-favour package-being-installed-but-failed version \
584            removing conflicting-package version
585 
586            The deconfigured packages are marked as requiring
587            configuration, so that if --install is used they will be
588            configured again if possible.
589            2. To prepare for removal of the conflicting package, call:
590            conflictor's-prerm remove in-favour package new-version
591            Error unwind:
592            conflictor's-postinst abort-remove in-favour package new-version
593          */
594         return 0;
595 }
596 
597 static int
598 prerm_deconfigure_conflictors_unwind(pkg_t * pkg, pkg_vec_t * conflictors)
599 {
600         /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
601            do yet. Do we care?  (See prerm_deconfigure_conflictors for
602            details) */
603         return 0;
604 }
605 
606 static int preinst_configure(pkg_t * pkg, pkg_t * old_pkg)
607 {
608         int err;
609         char *preinst_args;
610 
611         if (old_pkg) {
612                 char *old_version = pkg_version_str_alloc(old_pkg);
613                 sprintf_alloc(&preinst_args, "upgrade %s", old_version);
614                 free(old_version);
615         } else if (pkg->state_status == SS_CONFIG_FILES) {
616                 char *pkg_version = pkg_version_str_alloc(pkg);
617                 sprintf_alloc(&preinst_args, "install %s", pkg_version);
618                 free(pkg_version);
619         } else {
620                 preinst_args = xstrdup("install");
621         }
622 
623         err = pkg_run_script(pkg, "preinst", preinst_args);
624         if (err) {
625                 opkg_msg(ERROR, "Aborting installation of %s.\n", pkg->name);
626                 return -1;
627         }
628 
629         free(preinst_args);
630 
631         return 0;
632 }
633 
634 static int preinst_configure_unwind(pkg_t * pkg, pkg_t * old_pkg)
635 {
636         /* DPKG_INCOMPATIBILITY:
637            dpkg does the following error unwind, should we?
638            pkg->postrm abort-upgrade old-version
639            OR pkg->postrm abort-install old-version
640            OR pkg->postrm abort-install
641          */
642         return 0;
643 }
644 
645 static char *backup_filename_alloc(const char *file_name)
646 {
647         char *backup;
648 
649         sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
650 
651         return backup;
652 }
653 
654 static int backup_make_backup(const char *file_name)
655 {
656         int err;
657         char *backup;
658 
659         backup = backup_filename_alloc(file_name);
660         err = file_copy(file_name, backup);
661         if (err) {
662                 opkg_msg(ERROR, "Failed to copy %s to %s\n", file_name, backup);
663         }
664 
665         free(backup);
666 
667         return err;
668 }
669 
670 static int backup_exists_for(const char *file_name)
671 {
672         int ret;
673         char *backup;
674 
675         backup = backup_filename_alloc(file_name);
676 
677         ret = file_exists(backup);
678 
679         free(backup);
680 
681         return ret;
682 }
683 
684 static int backup_remove(const char *file_name)
685 {
686         char *backup;
687 
688         backup = backup_filename_alloc(file_name);
689         unlink(backup);
690         free(backup);
691 
692         return 0;
693 }
694 
695 static int backup_modified_conffiles(pkg_t * pkg, pkg_t * old_pkg)
696 {
697         int err;
698         conffile_list_elt_t *iter;
699         conffile_t *cf;
700         conffile_list_t *cl;
701 
702         if (conf->noaction)
703                 return 0;
704 
705         /* Backup all modified conffiles */
706         if (old_pkg) {
707                 cl = pkg_get_ptr(old_pkg, PKG_CONFFILES);
708 
709                 for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
710                      iter = nv_pair_list_next(cl, iter)) {
711                         char *cf_name;
712 
713                         cf = iter->data;
714                         cf_name = root_filename_alloc(cf->name);
715 
716                         /* Don't worry if the conffile is just plain gone */
717                         if (file_exists(cf_name)
718                             && conffile_has_been_modified(cf)) {
719                                 err = backup_make_backup(cf_name);
720                                 if (err) {
721                                         return err;
722                                 }
723                         }
724                         free(cf_name);
725                 }
726         }
727 
728         /* Backup all conffiles that were not conffiles in old_pkg */
729         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
730 
731         for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
732              iter = nv_pair_list_next(cl, iter)) {
733                 char *cf_name;
734                 cf = (conffile_t *) iter->data;
735                 cf_name = root_filename_alloc(cf->name);
736                 /* Ignore if this was a conffile in old_pkg as well */
737                 if (pkg_get_conffile(old_pkg, cf->name)) {
738                         continue;
739                 }
740 
741                 if (file_exists(cf_name) && (!backup_exists_for(cf_name))) {
742                         err = backup_make_backup(cf_name);
743                         if (err) {
744                                 return err;
745                         }
746                 }
747                 free(cf_name);
748         }
749 
750         return 0;
751 }
752 
753 static int backup_modified_conffiles_unwind(pkg_t * pkg, pkg_t * old_pkg)
754 {
755         conffile_list_t *cl;
756         conffile_list_elt_t *iter;
757 
758         if (old_pkg) {
759                 cl = pkg_get_ptr(old_pkg, PKG_CONFFILES);
760 
761                 for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
762                      iter = nv_pair_list_next(cl, iter)) {
763                         backup_remove(((nv_pair_t *) iter->data)->name);
764                 }
765         }
766 
767         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
768 
769         for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
770              iter = nv_pair_list_next(cl, iter)) {
771                 backup_remove(((nv_pair_t *) iter->data)->name);
772         }
773 
774         return 0;
775 }
776 
777 static int check_data_file_clashes(pkg_t * pkg, pkg_t * old_pkg)
778 {
779         /* DPKG_INCOMPATIBILITY:
780            opkg takes a slightly different approach than dpkg at this
781            point.  dpkg installs each file in the new package while
782            creating a backup for any file that is replaced, (so that it
783            can unwind if necessary).  To avoid complexity and redundant
784            storage, opkg doesn't do any installation until later, (at the
785            point at which dpkg removes the backups.
786 
787            But, we do have to check for data file clashes, since after
788            installing a package with a file clash, removing either of the
789            packages involved in the clash has the potential to break the
790            other package.
791          */
792         str_list_t *files_list;
793         str_list_elt_t *iter, *niter;
794         char *filename;
795         int clashes = 0;
796 
797         files_list = pkg_get_installed_files(pkg);
798         if (files_list == NULL)
799                 return -1;
800 
801         for (iter = str_list_first(files_list), niter =
802              str_list_next(files_list, iter); iter;
803              iter = niter, niter = str_list_next(files_list, iter)) {
804                 filename = (char *)iter->data;
805                 if (file_exists(filename) && (!file_is_dir(filename))) {
806                         pkg_t *owner;
807                         pkg_t *obs;
808 
809                         if (backup_exists_for(filename)) {
810                                 continue;
811                         }
812 
813                         /* Pre-existing files are OK if force-overwrite was asserted. */
814                         if (conf->force_overwrite) {
815                                 /* but we need to change who owns this file */
816                                 file_hash_set_file_owner(filename, pkg);
817                                 continue;
818                         }
819 
820                         owner = file_hash_get_file_owner(filename);
821 
822                         /* Pre-existing files are OK if owned by the pkg being upgraded. */
823                         if (owner && old_pkg) {
824                                 if (strcmp(owner->name, old_pkg->name) == 0) {
825                                         continue;
826                                 }
827                         }
828 
829                         /* Pre-existing files are OK if owned by a package replaced by new pkg. */
830                         if (owner) {
831                                 opkg_msg(DEBUG2,
832                                          "Checking replaces for %s in package %s\n",
833                                          filename, owner->name);
834                                 if (pkg_replaces(pkg, owner)) {
835                                         continue;
836                                 }
837 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
838    then it's ok to overwrite. */
839                                 if (strcmp(owner->name, pkg->name) == 0) {
840                                         opkg_msg(INFO,
841                                                  "Replacing pre-existing file %s"
842                                                  " owned by package %s\n",
843                                                  filename, owner->name);
844                                         continue;
845                                 }
846                         }
847 
848                         /* Pre-existing files are OK if they are obsolete */
849                         obs = hash_table_get(&conf->obs_file_hash, filename);
850                         if (obs) {
851                                 opkg_msg(INFO,
852                                          "Pre-exiting file %s is obsolete."
853                                          " obs_pkg=%s\n", filename, obs->name);
854                                 continue;
855                         }
856 
857                         /* We have found a clash. */
858                         opkg_msg(ERROR, "Package %s wants to install file %s\n"
859                                  "\tBut that file is already provided by package ",
860                                  pkg->name, filename);
861                         if (owner) {
862                                 opkg_message(ERROR, "%s\n", owner->name);
863                         } else {
864                                 opkg_message(ERROR, "<no package>\n"
865                                              "Please move this file out of the way and try again.\n");
866                         }
867                         clashes++;
868                 }
869         }
870         pkg_free_installed_files(pkg);
871 
872         return clashes;
873 }
874 
875 /*
876  * XXX: This function sucks, as does the below comment.
877  */
878 static int check_data_file_clashes_change(pkg_t * pkg, pkg_t * old_pkg)
879 {
880         /* Basically that's the worst hack I could do to be able to change ownership of
881            file list, but, being that we have no way to unwind the mods, due to structure
882            of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
883            What we do here is change the ownership of file in hash if a replace ( or similar events
884            happens )
885            Only the action that are needed to change name should be considered.
886            @@@ To change after 1.0 release.
887          */
888         str_list_t *files_list;
889         str_list_elt_t *iter, *niter;
890 
891         files_list = pkg_get_installed_files(pkg);
892         if (files_list == NULL)
893                 return -1;
894 
895         for (iter = str_list_first(files_list), niter =
896              str_list_next(files_list, iter); iter;
897              iter = niter, niter = str_list_next(files_list, niter)) {
898                 char *filename = (char *)iter->data;
899                 if (file_exists(filename) && (!file_is_dir(filename))) {
900                         pkg_t *owner;
901 
902                         owner = file_hash_get_file_owner(filename);
903 
904                         if (conf->force_overwrite) {
905                                 /* but we need to change who owns this file */
906                                 file_hash_set_file_owner(filename, pkg);
907                                 continue;
908                         }
909 
910                         /* Pre-existing files are OK if owned by a package replaced by new pkg. */
911                         if (owner) {
912                                 if (pkg_replaces(pkg, owner)) {
913 /* It's now time to change the owner of that file.
914    It has been "replaced" from the new "Replaces", then I need to inform lists file about that.  */
915                                         opkg_msg(INFO,
916                                                  "Replacing pre-existing file %s "
917                                                  "owned by package %s\n",
918                                                  filename, owner->name);
919                                         file_hash_set_file_owner(filename, pkg);
920                                         continue;
921                                 }
922                         }
923 
924                 }
925         }
926         pkg_free_installed_files(pkg);
927 
928         return 0;
929 }
930 
931 static int check_data_file_clashes_unwind(pkg_t * pkg, pkg_t * old_pkg)
932 {
933         /* Nothing to do since check_data_file_clashes doesn't change state */
934         return 0;
935 }
936 
937 static int postrm_upgrade_old_pkg(pkg_t * pkg, pkg_t * old_pkg)
938 {
939         /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
940            1. If the package is being upgraded, call
941            old-postrm upgrade new-version
942            2. If this fails, attempt:
943            new-postrm failed-upgrade old-version
944            Error unwind, for both cases:
945            old-preinst abort-upgrade new-version    */
946         int err;
947         char *script_args;
948         char *new_version;
949 
950         if (!old_pkg || !pkg)
951                 return 0;
952 
953         new_version = pkg_version_str_alloc(pkg);
954 
955         sprintf_alloc(&script_args, "upgrade %s", new_version);
956         free(new_version);
957         err = pkg_run_script(old_pkg, "postrm", script_args);
958         free(script_args);
959         if (err != 0) {
960                 opkg_msg(ERROR, "postrm script for package \"%s\" failed\n",
961                          old_pkg->name);
962                 return -1;
963         }
964         return 0;
965 }
966 
967 static int postrm_upgrade_old_pkg_unwind(pkg_t * pkg, pkg_t * old_pkg)
968 {
969         /* DPKG_INCOMPATIBILITY:
970            dpkg does some things here that we don't do yet. Do we care?
971            (See postrm_upgrade_old_pkg for details)
972          */
973         return 0;
974 }
975 
976 static int remove_obsolesced_files(pkg_t * pkg, pkg_t * old_pkg)
977 {
978         int err = 0;
979         str_list_t *old_files;
980         str_list_elt_t *of;
981         str_list_t *new_files;
982         str_list_elt_t *nf;
983         hash_table_t new_files_table;
984 
985         old_files = pkg_get_installed_files(old_pkg);
986         if (old_files == NULL)
987                 return -1;
988 
989         new_files = pkg_get_installed_files(pkg);
990         if (new_files == NULL) {
991                 pkg_free_installed_files(old_pkg);
992                 return -1;
993         }
994 
995         new_files_table.entries = NULL;
996         hash_table_init("new_files", &new_files_table, 20);
997         for (nf = str_list_first(new_files); nf;
998              nf = str_list_next(new_files, nf)) {
999                 if (nf && nf->data)
1000                         hash_table_insert(&new_files_table, nf->data, nf->data);
1001         }
1002 
1003         for (of = str_list_first(old_files); of;
1004              of = str_list_next(old_files, of)) {
1005                 pkg_t *owner;
1006                 char *old, *new;
1007                 old = (char *)of->data;
1008                 new = (char *)hash_table_get(&new_files_table, old);
1009                 if (new)
1010                         continue;
1011 
1012                 if (file_is_dir(old)) {
1013                         continue;
1014                 }
1015                 owner = file_hash_get_file_owner(old);
1016                 if (owner != old_pkg) {
1017                         /* in case obsolete file no longer belongs to old_pkg */
1018                         continue;
1019                 }
1020 
1021                 /* old file is obsolete */
1022                 opkg_msg(NOTICE, "Removing obsolete file %s.\n", old);
1023                 if (!conf->noaction) {
1024                         err = unlink(old);
1025                         if (err) {
1026                                 opkg_perror(ERROR, "unlinking %s failed", old);
1027                         }
1028                 }
1029         }
1030 
1031         hash_table_deinit(&new_files_table);
1032         pkg_free_installed_files(old_pkg);
1033         pkg_free_installed_files(pkg);
1034 
1035         return err;
1036 }
1037 
1038 static int install_maintainer_scripts(pkg_t * pkg, pkg_t * old_pkg)
1039 {
1040         int ret;
1041         char *prefix;
1042 
1043         sprintf_alloc(&prefix, "%s.", pkg->name);
1044         ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
1045                                                            pkg->dest->info_dir,
1046                                                            prefix);
1047         free(prefix);
1048         return ret;
1049 }
1050 
1051 static int remove_disappeared(pkg_t * pkg)
1052 {
1053         /* DPKG_INCOMPATIBILITY:
1054            This is a fairly sophisticated dpkg operation. Shall we
1055            skip it? */
1056 
1057         /* Any packages all of whose files have been overwritten during the
1058            installation, and which aren't required for dependencies, are
1059            considered to have been removed. For each such package
1060            1. disappearer's-postrm disappear overwriter overwriter-version
1061            2. The package's maintainer scripts are removed
1062            3. It is noted in the status database as being in a sane state,
1063            namely not installed (any conffiles it may have are ignored,
1064            rather than being removed by dpkg). Note that disappearing
1065            packages do not have their prerm called, because dpkg doesn't
1066            know in advance that the package is going to vanish.
1067          */
1068         return 0;
1069 }
1070 
1071 static int install_data_files(pkg_t * pkg)
1072 {
1073         int err;
1074 
1075         /* opkg takes a slightly different approach to data file backups
1076            than dpkg. Rather than removing backups at this point, we
1077            actually do the data file installation now. See comments in
1078            check_data_file_clashes() for more details. */
1079 
1080         opkg_msg(INFO, "Extracting data files to %s.\n", pkg->dest->root_dir);
1081         err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
1082         if (err) {
1083                 return err;
1084         }
1085 
1086         opkg_msg(DEBUG, "Calling pkg_write_filelist.\n");
1087         err = pkg_write_filelist(pkg);
1088         if (err)
1089                 return err;
1090 
1091         /* XXX: FEATURE: opkg should identify any files which existed
1092            before installation and which were overwritten, (see
1093            check_data_file_clashes()). What it must do is remove any such
1094            files from the filelist of the old package which provided the
1095            file. Otherwise, if the old package were removed at some point
1096            it would break the new package. Removing the new package will
1097            also break the old one, but this cannot be helped since the old
1098            package's file has already been deleted. This is the importance
1099            of check_data_file_clashes(), and only allowing opkg to install
1100            a clashing package with a user force. */
1101 
1102         return 0;
1103 }
1104 
1105 static int resolve_conffiles(pkg_t * pkg)
1106 {
1107         conffile_list_elt_t *iter;
1108         conffile_list_t *cl;
1109         conffile_t *cf;
1110         char *cf_backup;
1111         char *chksum;
1112 
1113         if (conf->noaction)
1114                 return 0;
1115 
1116         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
1117 
1118         for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
1119              iter = nv_pair_list_next(cl, iter)) {
1120                 char *root_filename;
1121                 cf = (conffile_t *) iter->data;
1122                 root_filename = root_filename_alloc(cf->name);
1123 
1124                 /* Might need to initialize the md5sum for each conffile */
1125                 if (cf->value == NULL) {
1126                         cf->value = file_sha256sum_alloc(root_filename);
1127                 }
1128 
1129                 if (!file_exists(root_filename)) {
1130                         free(root_filename);
1131                         continue;
1132                 }
1133 
1134                 cf_backup = backup_filename_alloc(root_filename);
1135 
1136                 if (file_exists(cf_backup)) {
1137                         /* Let's compute md5 to test if files are changed */
1138                         if (cf->value && strlen(cf->value) > 33) {
1139                                 chksum = file_sha256sum_alloc(cf_backup);
1140                         } else {
1141                                 chksum = file_md5sum_alloc(cf_backup);
1142                         }
1143 
1144                         if (chksum && cf->value
1145                             && strcmp(cf->value, chksum) != 0) {
1146                                 if (conf->force_maintainer) {
1147                                         opkg_msg(NOTICE,
1148                                                  "Conffile %s using maintainer's setting.\n",
1149                                                  cf_backup);
1150                                 } else {
1151                                         char *new_conffile;
1152                                         sprintf_alloc(&new_conffile, "%s-opkg",
1153                                                       root_filename);
1154                                         opkg_msg(ERROR,
1155                                                  "Existing conffile %s "
1156                                                  "is different from the conffile in the new package."
1157                                                  " The new conffile will be placed at %s.\n",
1158                                                  root_filename, new_conffile);
1159                                         rename(root_filename, new_conffile);
1160                                         rename(cf_backup, root_filename);
1161                                         free(new_conffile);
1162                                 }
1163                         }
1164                         unlink(cf_backup);
1165                         if (chksum)
1166                                 free(chksum);
1167                 }
1168 
1169                 free(cf_backup);
1170                 free(root_filename);
1171         }
1172 
1173         return 0;
1174 }
1175 
1176 int opkg_install_by_name(const char *pkg_name)
1177 {
1178         int cmp;
1179         pkg_t *old, *new;
1180         char *old_version, *new_version;
1181 
1182         old = pkg_hash_fetch_installed_by_name(pkg_name);
1183         if (old)
1184                 opkg_msg(DEBUG2, "Old versions from pkg_hash_fetch %s.\n",
1185                          pkg_get_string(old, PKG_VERSION));
1186 
1187         new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name);
1188         if (new == NULL) {
1189                 opkg_msg(NOTICE, "Unknown package '%s'.\n", pkg_name);
1190                 return -1;
1191         }
1192 
1193         opkg_msg(DEBUG2, "Versions from pkg_hash_fetch:");
1194         if (old)
1195                 opkg_message(DEBUG2, " old %s ", pkg_get_string(old, PKG_VERSION));
1196         opkg_message(DEBUG2, " new %s\n", pkg_get_string(new, PKG_VERSION));
1197 
1198         new->state_flag |= SF_USER;
1199         if (old) {
1200                 old_version = pkg_version_str_alloc(old);
1201                 new_version = pkg_version_str_alloc(new);
1202 
1203                 cmp = pkg_compare_versions(old, new);
1204                 if ((conf->force_downgrade == 1) && (cmp > 0)) {        /* We've been asked to allow downgrade  and version is precedent */
1205                         opkg_msg(DEBUG, "Forcing downgrade\n");
1206                         cmp = -1;       /* then we force opkg to downgrade */
1207                         /* We need to use a value < 0 because in the 0 case we are asking to */
1208                         /* reinstall, and some check could fail asking the "force-reinstall" option */
1209                 }
1210                 opkg_msg(DEBUG, "Comparing visible versions of pkg %s:"
1211                          "\n\t%s is installed "
1212                          "\n\t%s is available "
1213                          "\n\t%d was comparison result\n",
1214                          pkg_name, old_version, new_version, cmp);
1215                 if (cmp == 0) {
1216                         opkg_msg(NOTICE,
1217                                  "Package %s (%s) installed in %s is up to date.\n",
1218                                  old->name, old_version, old->dest->name);
1219                         free(old_version);
1220                         free(new_version);
1221                         return 0;
1222                 } else if (cmp > 0) {
1223                         opkg_msg(NOTICE,
1224                                  "Not downgrading package %s on %s from %s to %s.\n",
1225                                  old->name, old->dest->name, old_version,
1226                                  new_version);
1227                         free(old_version);
1228                         free(new_version);
1229                         return 0;
1230                 } else if (cmp < 0) {
1231                         new->dest = old->dest;
1232                         old->state_want = SW_DEINSTALL;
1233                 }
1234                 free(old_version);
1235                 free(new_version);
1236         }
1237 
1238         opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
1239         return opkg_install_pkg(new, 0);
1240 }
1241 
1242 /**
1243  *  @brief Really install a pkg_t
1244  */
1245 int opkg_install_pkg(pkg_t * pkg, int from_upgrade)
1246 {
1247         int err = 0;
1248         int message = 0;
1249         pkg_t *old_pkg = NULL;
1250         pkg_vec_t *replacees;
1251         abstract_pkg_t *ab_pkg = NULL;
1252         int old_state_flag;
1253         char *file_md5, *pkg_md5;
1254         char *file_sha256, *pkg_sha256;
1255         sigset_t newset, oldset;
1256         const char *local_filename;
1257         long long int pkg_expected_size;
1258         struct stat pkg_stat;
1259         time_t now;
1260 
1261         if (from_upgrade)
1262                 message = 1;    /* Coming from an upgrade, and should change the output message */
1263 
1264         opkg_msg(DEBUG2, "Calling pkg_arch_supported.\n");
1265 
1266         if (!pkg_arch_supported(pkg)) {
1267                 opkg_msg(ERROR,
1268                          "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1269                          pkg_get_architecture(pkg), pkg->name);
1270                 return -1;
1271         }
1272         if (pkg->state_status == SS_INSTALLED && conf->nodeps == 0) {
1273                 err = satisfy_dependencies_for(pkg);
1274                 if (err)
1275                         return -1;
1276 
1277                 opkg_msg(NOTICE, "Package %s is already installed on %s.\n",
1278                          pkg->name, pkg->dest->name);
1279                 return 0;
1280         }
1281 
1282         if (pkg->dest == NULL) {
1283                 pkg->dest = conf->default_dest;
1284         }
1285 
1286         old_pkg = pkg_hash_fetch_installed_by_name(pkg->name);
1287 
1288         err = opkg_install_check_downgrade(pkg, old_pkg, message);
1289         if (err)
1290                 return -1;
1291 
1292         pkg->state_want = SW_INSTALL;
1293         if (old_pkg) {
1294                 old_pkg->state_want = SW_DEINSTALL;     /* needed for check_data_file_clashes of dependencies */
1295         }
1296 
1297         err = check_conflicts_for(pkg);
1298         if (err)
1299                 return -1;
1300 
1301         /* this setup is to remove the upgrade scenario in the end when
1302            installing pkg A, A deps B & B deps on A. So both B and A are
1303            installed. Then A's installation is started resulting in an
1304            uncecessary upgrade */
1305         if (pkg->state_status == SS_INSTALLED)
1306                 return 0;
1307 
1308         err = verify_pkg_installable(pkg);
1309         if (err)
1310                 return -1;
1311 
1312         local_filename = pkg_get_string(pkg, PKG_LOCAL_FILENAME);
1313 
1314         if (local_filename == NULL) {
1315                 if (!conf->cache && conf->download_only) {
1316                         char cwd[4096];
1317                         if (getcwd(cwd, sizeof(cwd)) != NULL)
1318                                 err = opkg_download_pkg(pkg, cwd);
1319                         else
1320                                 return -1;
1321                 } else {
1322                         err = opkg_download_pkg(pkg, conf->tmp_dir);
1323                 }
1324                 if (err) {
1325                         opkg_msg(ERROR, "Failed to download %s. "
1326                                  "Perhaps you need to run 'opkg update'?\n",
1327                                  pkg->name);
1328                         return -1;
1329                 }
1330 
1331                 local_filename = pkg_get_string(pkg, PKG_LOCAL_FILENAME);
1332         }
1333 
1334         /* check that the repository is valid */
1335 #if defined(HAVE_USIGN)
1336         char *list_file_name, *sig_file_name, *lists_dir;
1337 
1338         /* check to ensure the package has come from a repository */
1339         if (conf->check_signature && pkg->src) {
1340                 sprintf_alloc(&lists_dir, "%s", (conf->restrict_to_default_dest)
1341                               ? conf->default_dest->lists_dir
1342                               : conf->lists_dir);
1343                 sprintf_alloc(&list_file_name, "%s/%s", lists_dir,
1344                               pkg->src->name);
1345                 sprintf_alloc(&sig_file_name, "%s/%s.sig", lists_dir,
1346                               pkg->src->name);
1347 
1348                 if (file_exists(sig_file_name)) {
1349                         if (opkg_verify_file(list_file_name, sig_file_name)) {
1350                                 opkg_msg(ERROR,
1351                                          "Failed to verify the signature of %s.\n",
1352                                          list_file_name);
1353                                 if (!conf->force_signature)
1354                                         return -1;
1355                         }
1356                 } else {
1357                         opkg_msg(ERROR, "Signature file is missing for %s. "
1358                                  "Perhaps you need to run 'opkg update'?\n",
1359                                  pkg->name);
1360                         if (!conf->force_signature)
1361                                 return -1;
1362                 }
1363 
1364                 free(lists_dir);
1365                 free(list_file_name);
1366                 free(sig_file_name);
1367         }
1368 #endif
1369 
1370         /* Check file size */
1371         err = lstat(local_filename, &pkg_stat);
1372 
1373         if (err) {
1374                 opkg_msg(ERROR, "Failed to stat %s: %s\n",
1375                          local_filename, strerror(errno));
1376                 return -1;
1377         }
1378 
1379         pkg_expected_size = pkg_get_int(pkg, PKG_SIZE);
1380 
1381         if (pkg_expected_size > 0 && pkg_stat.st_size != pkg_expected_size) {
1382                 if (!conf->force_checksum) {
1383                         opkg_msg(ERROR,
1384                                  "Package size mismatch: %s is %lld bytes, expecting %lld bytes\n",
1385                                  pkg->name, (long long int)pkg_stat.st_size, pkg_expected_size);
1386                         return -1;
1387                 } else {
1388                         opkg_msg(NOTICE,
1389                                  "Ignored %s size mismatch.\n",
1390                                  pkg->name);
1391                 }
1392         }
1393 
1394         /* Check for md5 values */
1395         pkg_md5 = pkg_get_md5(pkg);
1396         if (pkg_md5) {
1397                 file_md5 = file_md5sum_alloc(local_filename);
1398                 if (file_md5 && strcmp(file_md5, pkg_md5)) {
1399                         if (!conf->force_checksum) {
1400                                 opkg_msg(ERROR, "Package %s md5sum mismatch. "
1401                                          "Either the opkg or the package index are corrupt. "
1402                                          "Try 'opkg update'.\n", pkg->name);
1403                                 free(file_md5);
1404                                 return -1;
1405                         } else {
1406                                 opkg_msg(NOTICE,
1407                                          "Ignored %s md5sum mismatch.\n",
1408                                          pkg->name);
1409                         }
1410                 }
1411                 if (file_md5)
1412                         free(file_md5);
1413         }
1414 
1415         /* Check for sha256 value */
1416         pkg_sha256 = pkg_get_sha256(pkg);
1417         if (pkg_sha256) {
1418                 file_sha256 = file_sha256sum_alloc(local_filename);
1419                 if (file_sha256 && strcmp(file_sha256, pkg_sha256)) {
1420                         if (!conf->force_checksum) {
1421                                 opkg_msg(ERROR,
1422                                          "Package %s sha256sum mismatch. "
1423                                          "Either the opkg or the package index are corrupt. "
1424                                          "Try 'opkg update'.\n", pkg->name);
1425                                 free(file_sha256);
1426                                 return -1;
1427                         } else {
1428                                 opkg_msg(NOTICE,
1429                                          "Ignored %s sha256sum mismatch.\n",
1430                                          pkg->name);
1431                         }
1432                 }
1433                 if (file_sha256)
1434                         free(file_sha256);
1435         }
1436 
1437         if (conf->download_only) {
1438                 if (conf->nodeps == 0) {
1439                         err = satisfy_dependencies_for(pkg);
1440                         if (err)
1441                                 return -1;
1442                 }
1443                 return 0;
1444         }
1445 
1446         if (!pkg_get_string(pkg, PKG_TMP_UNPACK_DIR)) {
1447                 if (unpack_pkg_control_files(pkg) == -1) {
1448                         opkg_msg(ERROR,
1449                                  "Failed to unpack control files from %s.\n",
1450                                  local_filename);
1451                         return -1;
1452                 }
1453         }
1454 
1455         err = update_file_ownership(pkg, old_pkg);
1456         if (err)
1457                 return -1;
1458 
1459         if (conf->nodeps == 0) {
1460                 err = satisfy_dependencies_for(pkg);
1461                 if (err)
1462                         return -1;
1463                 if (pkg->state_status == SS_UNPACKED)
1464                         /* Circular dependency has installed it for us. */
1465                         return 0;
1466         }
1467 
1468         replacees = pkg_vec_alloc();
1469         pkg_get_installed_replacees(pkg, replacees);
1470 
1471         /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1472 
1473         sigemptyset(&newset);
1474         sigaddset(&newset, SIGINT);
1475         sigprocmask(SIG_BLOCK, &newset, &oldset);
1476 
1477         opkg_state_changed++;
1478         pkg->state_flag |= SF_FILELIST_CHANGED;
1479 
1480         if (old_pkg) {
1481                 pkg_remove_orphan_dependent(pkg, old_pkg);
1482                 old_pkg->is_upgrade = 1;
1483                 pkg->is_upgrade = 1;
1484         }
1485         /* XXX: BUG: we really should treat replacement more like an upgrade
1486          *      Instead, we're going to remove the replacees
1487          */
1488         err = pkg_remove_installed_replacees(replacees);
1489         if (err)
1490                 goto UNWIND_REMOVE_INSTALLED_REPLACEES;
1491 
1492         err = prerm_upgrade_old_pkg(pkg, old_pkg);
1493         if (err)
1494                 goto UNWIND_PRERM_UPGRADE_OLD_PKG;
1495 
1496         err = prerm_deconfigure_conflictors(pkg, replacees);
1497         if (err)
1498                 goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
1499 
1500         err = preinst_configure(pkg, old_pkg);
1501         if (err)
1502                 goto UNWIND_PREINST_CONFIGURE;
1503 
1504         err = backup_modified_conffiles(pkg, old_pkg);
1505         if (err)
1506                 goto UNWIND_BACKUP_MODIFIED_CONFFILES;
1507 
1508         err = check_data_file_clashes(pkg, old_pkg);
1509         if (err)
1510                 goto UNWIND_CHECK_DATA_FILE_CLASHES;
1511 
1512         err = postrm_upgrade_old_pkg(pkg, old_pkg);
1513         if (err)
1514                 goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
1515 
1516         if (conf->noaction)
1517                 return 0;
1518 
1519         /* point of no return: no unwinding after this */
1520         if (old_pkg) {
1521                 old_pkg->state_want = SW_DEINSTALL;
1522 
1523                 if (old_pkg->state_flag & SF_NOPRUNE) {
1524                         opkg_msg(INFO, "Not removing obsolesced files because "
1525                                  "package %s marked noprune.\n", old_pkg->name);
1526                 } else {
1527                         opkg_msg(INFO, "Removing obsolesced files for %s\n",
1528                                  old_pkg->name);
1529                         if (remove_obsolesced_files(pkg, old_pkg)) {
1530                                 opkg_msg(ERROR, "Failed to determine "
1531                                          "obsolete files from previously "
1532                                          "installed %s\n", old_pkg->name);
1533                         }
1534                 }
1535 
1536                 /* removing files from old package, to avoid ghost files */
1537                 remove_data_files_and_list(old_pkg);
1538                 remove_maintainer_scripts(old_pkg);
1539         }
1540 
1541         opkg_msg(INFO, "%s maintainer scripts.\n",
1542                  (pkg->is_upgrade) ? ("Upgrading") : ("Installing"));
1543         if (install_maintainer_scripts(pkg, old_pkg)) {
1544                 opkg_msg(ERROR, "Failed to extract maintainer scripts for %s."
1545                          " Package debris may remain!\n", pkg->name);
1546                 goto pkg_is_hosed;
1547         }
1548 
1549         /* the following just returns 0 */
1550         remove_disappeared(pkg);
1551 
1552         opkg_msg(INFO, "Installing data files for %s.\n", pkg->name);
1553 
1554         if (install_data_files(pkg)) {
1555                 opkg_msg(ERROR, "Failed to extract data files for %s. "
1556                          "Package debris may remain!\n", pkg->name);
1557                 goto pkg_is_hosed;
1558         }
1559 
1560         err = check_data_file_clashes_change(pkg, old_pkg);
1561         if (err) {
1562                 opkg_msg(ERROR, "check_data_file_clashes_change() failed for "
1563                          "for files belonging to %s.\n", pkg->name);
1564         }
1565 
1566         opkg_msg(INFO, "Resolving conf files for %s\n", pkg->name);
1567         resolve_conffiles(pkg);
1568 
1569         pkg->state_status = SS_UNPACKED;
1570         old_state_flag = pkg->state_flag;
1571         pkg->state_flag &= ~SF_PREFER;
1572         opkg_msg(DEBUG, "pkg=%s old_state_flag=%x state_flag=%x\n",
1573                  pkg->name, old_state_flag, pkg->state_flag);
1574 
1575         if (old_pkg)
1576                 old_pkg->state_status = SS_NOT_INSTALLED;
1577 
1578         now = time(NULL);
1579         pkg_set_int(pkg, PKG_INSTALLED_TIME, now);
1580 
1581         ab_pkg = pkg->parent;
1582         if (ab_pkg)
1583                 ab_pkg->state_status = pkg->state_status;
1584 
1585         sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1586         pkg_vec_free(replacees);
1587         return 0;
1588 
1589 UNWIND_POSTRM_UPGRADE_OLD_PKG:
1590         postrm_upgrade_old_pkg_unwind(pkg, old_pkg);
1591 UNWIND_CHECK_DATA_FILE_CLASHES:
1592         check_data_file_clashes_unwind(pkg, old_pkg);
1593 UNWIND_BACKUP_MODIFIED_CONFFILES:
1594         backup_modified_conffiles_unwind(pkg, old_pkg);
1595 UNWIND_PREINST_CONFIGURE:
1596         preinst_configure_unwind(pkg, old_pkg);
1597 UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1598         prerm_deconfigure_conflictors_unwind(pkg, replacees);
1599 UNWIND_PRERM_UPGRADE_OLD_PKG:
1600         prerm_upgrade_old_pkg_unwind(pkg, old_pkg);
1601 UNWIND_REMOVE_INSTALLED_REPLACEES:
1602         pkg_remove_installed_replacees_unwind(replacees);
1603 
1604 pkg_is_hosed:
1605         sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1606 
1607         pkg_vec_free(replacees);
1608         return -1;
1609 }
1610 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt