/* pkg_alternatives.c - the opkg package management system
   
      Copyright (C) 2017 Yousong Zhou
   
      This program is free software; you can redistribute it and/or
      modify it under the terms of the GNU General Public License as
      published by the Free Software Foundation; either version 2, or (at
      your option) any later version.
   
     This program is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
  */
  
  #include <stdio.h>
  #include <sys/types.h>          /* stat */
  #include <sys/stat.h>
  #include <libgen.h>                     /* dirname */
  #include <unistd.h>
  
  #include "file_util.h"
  #include "libbb/libbb.h"
  #include "opkg_message.h"
  #include "pkg.h"
  #include "pkg_hash.h"
  #include "pkg_alternatives.h"
  #include "sprintf_alloc.h"
  
  struct alternative_provider {
          char *name;
          char *altpath;
  };
  
  static const struct alternative_provider providers[] = {
          {
                  .name = "busybox",
                  .altpath = "/bin/busybox",
          },
  };
  
  static const char *pkg_alternatives_check_providers(const char *path)
  {
          pkg_t *pkg;
          str_list_t *files;
          str_list_elt_t *iter;
          int i;
  
          for (i = 0; i < ARRAY_SIZE(providers); i++) {
                  pkg = pkg_hash_fetch_installed_by_name(providers[i].name);
                  if (!pkg) {
                          continue;
                  }
                  files = pkg_get_installed_files(pkg);
                  for (iter = str_list_first(files); iter; iter = str_list_next(files, iter)) {
                          if (!strcmp(path, (char *)(iter->data))) {
                                  pkg_free_installed_files(pkg);
                                  return providers[i].altpath;
                          }
                  }
                  pkg_free_installed_files(pkg);
          }
          return NULL;
  }
  
  static int pkg_alternatives_update_path(pkg_t *pkg, const pkg_vec_t *installed, const char *path)
  {
          struct pkg_alternatives *pkg_alts;
          struct pkg_alternative *the_alt = NULL;
          pkg_t *the_pkg = pkg;
          int i, j;
          int r;
          char *path_in_dest;
          const char *target_path = NULL;
  
          for (i = 0; i < installed->len; i++) {
                  pkg_t *pkg = installed->pkgs[i];
                  pkg_alts = pkg_get_ptr(pkg, PKG_ALTERNATIVES);
                  if (!pkg_alts)
                          continue;
  
                  for (j = 0; j < pkg_alts->nalts; j++) {
                          struct pkg_alternative *alt = pkg_alts->alts[j];
  
                          if (strcmp(path, alt->path))
                                  continue;
                          if (!the_alt || the_alt->prio < alt->prio) {
                                  the_pkg = pkg;
                                  the_alt = alt;
                          }
                  }
          }
  
          /* path is assumed to be an absolute one */
          sprintf_alloc(&path_in_dest, "%s%s", the_pkg->dest->root_dir, &path[1]);
          if (!path_in_dest)
                  return -1;
  
          if (the_alt) {
                 target_path = the_alt->altpath;
         } else {
                 target_path = pkg_alternatives_check_providers(path);
         }
 
         if (target_path) {
                 struct stat sb;
 
                 r = lstat(path_in_dest, &sb);
                 if (!r) {
                         char *realpath;
 
                         if (!S_ISLNK(sb.st_mode)) {
                                 opkg_msg(ERROR, "%s exists but is not a symlink\n", path_in_dest);
                                 r = -1;
                                 goto out;
                         }
                         realpath = xreadlink(path_in_dest);
                         if (realpath && strcmp(realpath, target_path))
                                 unlink(path_in_dest);
                         free(realpath);
                 } else if (errno != ENOENT) {
                         goto out;
                 }
                 {
                         char *path_copy = xstrdup(path_in_dest);
                         char *path_parent = dirname(path_copy);
 
                         r = file_mkdir_hier(path_parent, 0755);
                         free(path_copy);
                         if (r) {
                                 goto out;
                         }
                         r = symlink(target_path, path_in_dest);
                         if (r && errno == EEXIST) {
                                 /*
                                  * the strcmp & unlink check above will make sure that if EEXIST
                                  * happens, the symlink target also matches
                                  */
                                 r = 0;
                         }
                         if (r) {
                                 opkg_perror(ERROR, "failed symlinking %s -> %s", path_in_dest, target_path);
                         }
                 }
         } else {
                 unlink(path_in_dest);
                 r = 0;
         }
 
 out:
         free(path_in_dest);
         return r;
 }
 
 int pkg_alternatives_update(pkg_t * pkg)
 {
         int r = 0;
         int i;
         struct pkg_alternatives *pkg_alts;
         struct pkg_alternative *alt = NULL;
         pkg_vec_t *installed;
 
         pkg_alts = pkg_get_ptr(pkg, PKG_ALTERNATIVES);
         if (!pkg_alts)
                 return 0;
 
         installed = pkg_vec_alloc();
         pkg_hash_fetch_all_installed(installed);
         for (i = 0; i < pkg_alts->nalts; i++) {
                 alt = pkg_alts->alts[i];
                 r |= pkg_alternatives_update_path(pkg, installed, alt->path);
         }
         pkg_vec_free(installed);
 
         return r;
 }
 

• Git
• Wiki