usr.sbin/pkg_install/lib/plist.c

   1 /*
   2  * FreeBSD install - a package for the installation and maintainance
   3  * of non-core utilities.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * Jordan K. Hubbard
  15  * 18 July 1993
  16  *
  17  * General packing list routines.
  18  *
  19  */
  20
  21 #include <sys/cdefs.h>
  22 __FBSDID("$FreeBSD$");
  23
  24 #include "lib.h"
  25 #include <err.h>
  26 #include <md5.h>
  27
  28 /* Add an item to a packing list */
  29 void
  30 add_plist(Package *p, plist_t type, const char *arg)
  31 {
  32     PackingList tmp;
  33
  34     tmp = new_plist_entry();
  35     tmp->name = copy_string(arg);
  36     tmp->type = type;
  37
  38     if (!p->head)
  39         p->head = p->tail = tmp;
  40     else {
  41         tmp->prev = p->tail;
  42         p->tail->next = tmp;
  43         p->tail = tmp;
  44     }
  45     switch (type) {
  46     case PLIST_NAME:
  47         p->name = tmp->name;
  48         break;
  49
  50     case PLIST_ORIGIN:
  51         p->origin = tmp->name;
  52         break;
  53
  54     default:
  55         break;
  56     }
  57 }
  58
  59 void
  60 add_plist_top(Package *p, plist_t type, const char *arg)
  61 {
  62     PackingList tmp;
  63
  64     tmp = new_plist_entry();
  65     tmp->name = copy_string(arg);
  66     tmp->type = type;
  67
  68     if (!p->head)
  69         p->head = p->tail = tmp;
  70     else {
  71         tmp->next = p->head;
  72         p->head->prev = tmp;
  73         p->head = tmp;
  74     }
  75 }
  76
  77 /* Return the last (most recent) entry in a packing list */
  78 PackingList
  79 last_plist(Package *p)
  80 {
  81     return p->tail;
  82 }
  83
  84 /* Mark all items in a packing list to prevent iteration over them */
  85 void
  86 mark_plist(Package *pkg)
  87 {
  88     PackingList p = pkg->head;
  89
  90     while (p) {
  91         p->marked = TRUE;
  92         p = p->next;
  93     }
  94 }
  95
  96 /* Find a given item in a packing list and, if so, return it (else NULL) */
  97 PackingList
  98 find_plist(Package *pkg, plist_t type)
  99 {
 100     PackingList p = pkg->head;
 101
 102     while (p) {
 103         if (p->type == type)
 104             return p;
 105         p = p->next;
 106     }
 107     return NULL;
 108 }
 109
 110 /* Look for a specific boolean option argument in the list */
 111 char *
 112 find_plist_option(Package *pkg, const char *name)
 113 {
 114     PackingList p = pkg->head;
 115
 116     while (p) {
 117         if (p->type == PLIST_OPTION && !strcmp(p->name, name))
 118             return p->name;
 119         p = p->next;
 120     }
 121     return NULL;
 122 }
 123
 124 /*
 125  * Delete plist item 'type' in the list (if 'name' is non-null, match it
 126  * too.)  If 'all' is set, delete all items, not just the first occurance.
 127  */
 128 void
 129 delete_plist(Package *pkg, Boolean all, plist_t type, const char *name)
 130 {
 131     PackingList p = pkg->head;
 132
 133     while (p) {
 134         PackingList pnext = p->next;
 135
 136         if (p->type == type && (!name || !strcmp(name, p->name))) {
 137             free(p->name);
 138             if (p->prev)
 139                 p->prev->next = pnext;
 140             else
 141                 pkg->head = pnext;
 142             if (pnext)
 143                 pnext->prev = p->prev;
 144             else
 145                 pkg->tail = p->prev;
 146             free(p);
 147             if (!all)
 148                 return;
 149             p = pnext;
 150         }
 151         else
 152             p = p->next;
 153     }
 154 }
 155
 156 /* Allocate a new packing list entry */
 157 PackingList
 158 new_plist_entry(void)
 159 {
 160     PackingList ret;
 161
 162     ret = (PackingList)malloc(sizeof(struct _plist));
 163     bzero(ret, sizeof(struct _plist));
 164     return ret;
 165 }
 166
 167 /* Free an entire packing list */
 168 void
 169 free_plist(Package *pkg)
 170 {
 171     PackingList p = pkg->head;
 172
 173     while (p) {
 174         PackingList p1 = p->next;
 175
 176         free(p->name);
 177         free(p);
 178         p = p1;
 179     }
 180     pkg->head = pkg->tail = NULL;
 181 }
 182
 183 /*
 184  * For an ascii string denoting a plist command, return its code and
 185  * optionally its argument(s)
 186  */
 187 int
 188 plist_cmd(const char *s, char **arg)
 189 {
 190     char cmd[FILENAME_MAX + 20];        /* 20 == fudge for max cmd len */
 191     char *cp;
 192     const char *sp;
 193
 194     strcpy(cmd, s);
 195     str_lowercase(cmd);
 196     cp = cmd;
 197     sp = s;
 198     while (*cp) {
 199         if (isspace(*cp)) {
 200             *cp = '\0';
 201             while (isspace(*sp)) /* Never sure if macro, increment later */
 202                 ++sp;
 203             break;
 204         }
 205         ++cp, ++sp;
 206     }
 207     if (arg)
 208         *arg = (char *)sp;
 209     if (!strcmp(cmd, "cwd"))
 210         return PLIST_CWD;
 211     else if (!strcmp(cmd, "srcdir"))
 212         return PLIST_SRC;
 213     else if (!strcmp(cmd, "cd"))
 214         return PLIST_CWD;
 215     else if (!strcmp(cmd, "exec"))
 216         return PLIST_CMD;
 217     else if (!strcmp(cmd, "unexec"))
 218         return PLIST_UNEXEC;
 219     else if (!strcmp(cmd, "mode"))
 220         return PLIST_CHMOD;
 221     else if (!strcmp(cmd, "owner"))
 222         return PLIST_CHOWN;
 223     else if (!strcmp(cmd, "group"))
 224         return PLIST_CHGRP;
 225     else if (!strcmp(cmd, "noinst"))
 226         return PLIST_NOINST;
 227     else if (!strcmp(cmd, "comment")) {
 228         if (!strncmp(*arg, "ORIGIN:", 7)) {
 229             *arg += 7;
 230             return PLIST_ORIGIN;
 231         } else if (!strncmp(*arg, "DEPORIGIN:", 10)) {
 232             *arg += 10;
 233             return PLIST_DEPORIGIN;
 234         }
 235         return PLIST_COMMENT;
 236     } else if (!strcmp(cmd, "ignore"))
 237         return PLIST_IGNORE;
 238     else if (!strcmp(cmd, "ignore_inst"))
 239         return PLIST_IGNORE_INST;
 240     else if (!strcmp(cmd, "name"))
 241         return PLIST_NAME;
 242     else if (!strcmp(cmd, "display"))
 243         return PLIST_DISPLAY;
 244     else if (!strcmp(cmd, "pkgdep"))
 245         return PLIST_PKGDEP;
 246     else if (!strcmp(cmd, "conflicts"))
 247         return PLIST_CONFLICTS;
 248     else if (!strcmp(cmd, "mtree"))
 249         return PLIST_MTREE;
 250     else if (!strcmp(cmd, "dirrm"))
 251         return PLIST_DIR_RM;
 252     else if (!strcmp(cmd, "option"))
 253         return PLIST_OPTION;
 254     else
 255         return FAIL;
 256 }
 257
 258 /* Read a packing list from a file */
 259 void
 260 read_plist(Package *pkg, FILE *fp)
 261 {
 262     char *cp, pline[FILENAME_MAX];
 263     int cmd, major, minor;
 264
 265     pkg->fmtver_maj = 1;
 266     pkg->fmtver_mnr = 0;
 267     pkg->origin = NULL;
 268     while (fgets(pline, FILENAME_MAX, fp)) {
 269         int len = strlen(pline);
 270
 271         while (len && isspace(pline[len - 1]))
 272             pline[--len] = '\0';
 273         if (!len)
 274             continue;
 275         cp = pline;
 276         if (pline[0] != CMD_CHAR) {
 277             cmd = PLIST_FILE;
 278             goto bottom;
 279         }
 280         cmd = plist_cmd(pline + 1, &cp);
 281         if (cmd == FAIL) {
 282             warnx("%s: unknown command '%s' (package tools out of date?)",
 283                 __func__, pline);
 284             goto bottom;
 285         }
 286         if (*cp == '\0') {
 287             cp = NULL;
 288             if (cmd == PLIST_PKGDEP) {
 289                 warnx("corrupted record for package %s (pkgdep line without "
 290                         "argument), ignoring", pkg->name);
 291                 cmd = FAIL;
 292             }
 293             goto bottom;
 294         }
 295         if (cmd == PLIST_COMMENT && sscanf(cp, "PKG_FORMAT_REVISION:%d.%d\n",
 296                                            &major, &minor) == 2) {
 297             pkg->fmtver_maj = major;
 298             pkg->fmtver_mnr = minor;
 299             if (verscmp(pkg, PLIST_FMT_VER_MAJOR, PLIST_FMT_VER_MINOR) <= 0)
 300                 goto bottom;
 301
 302             warnx("plist format revision (%d.%d) is higher than supported"
 303                   "(%d.%d)", pkg->fmtver_maj, pkg->fmtver_mnr,
 304                   PLIST_FMT_VER_MAJOR, PLIST_FMT_VER_MINOR);
 305             if (pkg->fmtver_maj > PLIST_FMT_VER_MAJOR) {
 306                 cleanup(0);
 307                 exit(2);
 308             }
 309         }
 310 bottom:
 311         add_plist(pkg, cmd, cp);
 312     }
 313 }
 314
 315 /* Write a packing list to a file, converting commands to ascii equivs */
 316 void
 317 write_plist(Package *pkg, FILE *fp)
 318 {
 319     PackingList plist = pkg->head;
 320
 321     while (plist) {
 322         switch(plist->type) {
 323         case PLIST_FILE:
 324             fprintf(fp, "%s\n", plist->name);
 325             break;
 326
 327         case PLIST_CWD:
 328             fprintf(fp, "%ccwd %s\n", CMD_CHAR, (plist->name == NULL) ? "" : plist->name);
 329             break;
 330
 331         case PLIST_SRC:
 332             fprintf(fp, "%csrcdir %s\n", CMD_CHAR, plist->name);
 333             break;
 334
 335         case PLIST_CMD:
 336             fprintf(fp, "%cexec %s\n", CMD_CHAR, plist->name);
 337             break;
 338
 339         case PLIST_UNEXEC:
 340             fprintf(fp, "%cunexec %s\n", CMD_CHAR, plist->name);
 341             break;
 342
 343         case PLIST_CHMOD:
 344             fprintf(fp, "%cmode %s\n", CMD_CHAR, plist->name ? plist->name : "");
 345             break;
 346
 347         case PLIST_CHOWN:
 348             fprintf(fp, "%cowner %s\n", CMD_CHAR, plist->name ? plist->name : "");
 349             break;
 350
 351         case PLIST_CHGRP:
 352             fprintf(fp, "%cgroup %s\n", CMD_CHAR, plist->name ? plist->name : "");
 353             break;
 354
 355         case PLIST_COMMENT:
 356             fprintf(fp, "%ccomment %s\n", CMD_CHAR, plist->name);
 357             break;
 358
 359         case PLIST_NOINST:
 360             fprintf(fp, "%cnoinst %s\n", CMD_CHAR, plist->name);
 361             break;
 362
 363         case PLIST_IGNORE:
 364         case PLIST_IGNORE_INST:         /* a one-time non-ignored file */
 365             fprintf(fp, "%cignore\n", CMD_CHAR);
 366             break;
 367
 368         case PLIST_NAME:
 369             fprintf(fp, "%cname %s\n", CMD_CHAR, plist->name);
 370             break;
 371
 372         case PLIST_DISPLAY:
 373             fprintf(fp, "%cdisplay %s\n", CMD_CHAR, plist->name);
 374             break;
 375
 376         case PLIST_PKGDEP:
 377             fprintf(fp, "%cpkgdep %s\n", CMD_CHAR, plist->name);
 378             break;
 379
 380         case PLIST_CONFLICTS:
 381             fprintf(fp, "%cconflicts %s\n", CMD_CHAR, plist->name);
 382             break;
 383
 384         case PLIST_MTREE:
 385             fprintf(fp, "%cmtree %s\n", CMD_CHAR, plist->name);
 386             break;
 387
 388         case PLIST_DIR_RM:
 389             fprintf(fp, "%cdirrm %s\n", CMD_CHAR, plist->name);
 390             break;
 391
 392         case PLIST_OPTION:
 393             fprintf(fp, "%coption %s\n", CMD_CHAR, plist->name);
 394             break;
 395
 396         case PLIST_ORIGIN:
 397             fprintf(fp, "%ccomment ORIGIN:%s\n", CMD_CHAR, plist->name);
 398             break;
 399
 400         case PLIST_DEPORIGIN:
 401             fprintf(fp, "%ccomment DEPORIGIN:%s\n", CMD_CHAR, plist->name);
 402             break;
 403
 404         default:
 405             cleanup(0);
 406             errx(2, "%s: unknown command type %d (%s)", __func__,
 407                 plist->type, plist->name);
 408             break;
 409         }
 410         plist = plist->next;
 411     }
 412 }
 413
 414 /*
 415  * Delete the results of a package installation.
 416  *
 417  * This is here rather than in the pkg_delete code because pkg_add needs to
 418  * run it too in cases of failure.
 419  */
 420 int
 421 delete_package(Boolean ign_err, Boolean nukedirs, Package *pkg)
 422 {
 423     PackingList p;
 424     const char *Where = ".", *last_file = "";
 425     Boolean fail = SUCCESS;
 426     Boolean preserve;
 427     char tmp[FILENAME_MAX], *name = NULL;
 428     char *prefix = NULL;
 429
 430     preserve = find_plist_option(pkg, "preserve") ? TRUE : FALSE;
 431     for (p = pkg->head; p; p = p->next) {
 432         switch (p->type)  {
 433         case PLIST_NAME:
 434             name = p->name;
 435             break;
 436
 437         case PLIST_IGNORE:
 438             p = p->next;
 439             break;
 440
 441         case PLIST_CWD:
 442             if (!prefix)
 443                 prefix = p->name;
 444             Where = (p->name == NULL) ? prefix : p->name;
 445             if (Verbose)
 446                 printf("Change working directory to %s\n", Where);
 447             break;
 448
 449         case PLIST_UNEXEC:
 450             format_cmd(tmp, FILENAME_MAX, p->name, Where, last_file);
 451             if (Verbose)
 452                 printf("Execute '%s'\n", tmp);
 453             if (!Fake && system(tmp)) {
 454                 warnx("unexec command for '%s' failed", tmp);
 455                 fail = FAIL;
 456             }
 457             break;
 458
 459         case PLIST_FILE:
 460             last_file = p->name;
 461             sprintf(tmp, "%s/%s", Where, p->name);
 462             if (isdir(tmp) && fexists(tmp) && !issymlink(tmp)) {
 463                 warnx("cannot delete specified file '%s' - it is a directory!\n"
 464            "this packing list is incorrect - ignoring delete request", tmp);
 465             }
 466             else {
 467                 if (p->next && p->next->type == PLIST_COMMENT && !strncmp(p->next->name, "MD5:", 4)) {
 468                     char *cp = NULL, buf[33];
 469
 470                     /*
 471                      * For packing lists whose version is 1.1 or greater, the md5
 472                      * hash for a symlink is calculated on the string returned
 473                      * by readlink().
 474                      */
 475                     if (issymlink(tmp) && verscmp(pkg, 1, 0) > 0) {
 476                         int len;
 477                         char linkbuf[FILENAME_MAX];
 478
 479                         if ((len = readlink(tmp, linkbuf, FILENAME_MAX)) > 0)
 480                              cp = MD5Data((unsigned char *)linkbuf, len, buf);
 481                     } else if (isfile(tmp) || verscmp(pkg, 1, 1) < 0)
 482                         cp = MD5File(tmp, buf);
 483
 484                     if (cp != NULL) {
 485                         /* Mismatch? */
 486                         if (strcmp(cp, p->next->name + 4)) {
 487                             warnx("'%s' fails original MD5 checksum - %s",
 488                                   tmp, Force ? "deleted anyway." : "not deleted.");
 489                             if (!Force) {
 490                                 fail = FAIL;
 491                                 continue;
 492                             }
 493                         }
 494                     }
 495                 }
 496                 if (Verbose)
 497                     printf("Delete file %s\n", tmp);
 498                 if (!Fake) {
 499                     if (delete_hierarchy(tmp, ign_err, nukedirs))
 500                         fail = FAIL;
 501                     if (preserve && name) {
 502                         char tmp2[FILENAME_MAX];
 503
 504                         if (make_preserve_name(tmp2, FILENAME_MAX, name, tmp)) {
 505                             if (fexists(tmp2)) {
 506                                 if (rename(tmp2, tmp))
 507                                    warn("preserve: unable to restore %s as %s",
 508                                         tmp2, tmp);
 509                             }
 510                         }
 511                     }
 512                 }
 513             }
 514             break;
 515
 516         case PLIST_DIR_RM:
 517             sprintf(tmp, "%s/%s", Where, p->name);
 518             if (!isdir(tmp) && fexists(tmp)) {
 519                 warnx("cannot delete specified directory '%s' - it is a file!\n"
 520         "this packing list is incorrect - ignoring delete request", tmp);
 521             }
 522             else {
 523                 if (Verbose)
 524                     printf("Delete directory %s\n", tmp);
 525                 if (!Fake && delete_hierarchy(tmp, ign_err, FALSE)) {
 526                     warnx("unable to completely remove directory '%s'", tmp);
 527                     fail = FAIL;
 528                 }
 529             }
 530             last_file = p->name;
 531             break;
 532
 533         default:
 534             break;
 535         }
 536     }
 537     return fail;
 538 }
 539
 540 #ifdef DEBUG
 541 #define RMDIR(dir) vsystem("%s %s", RMDIR_CMD, dir)
 542 #define REMOVE(dir,ie) vsystem("%s %s%s", REMOVE_CMD, (ie ? "-f " : ""), dir)
 543 #else
 544 #define RMDIR rmdir
 545 #define REMOVE(file,ie) (remove(file) && !(ie))
 546 #endif
 547
 548 /* Selectively delete a hierarchy */
 549 int
 550 delete_hierarchy(const char *dir, Boolean ign_err, Boolean nukedirs)
 551 {
 552     char *cp1, *cp2;
 553
 554     cp1 = cp2 = strdup(dir);
 555     if (!fexists(dir) && !issymlink(dir)) {
 556         if (!ign_err)
 557             warnx("%s '%s' doesn't exist",
 558                 isdir(dir) ? "directory" : "file", dir);
 559         return !ign_err;
 560     }
 561     else if (nukedirs) {
 562         if (vsystem("%s -r%s %s", REMOVE_CMD, (ign_err ? "f" : ""), dir))
 563             return 1;
 564     }
 565     else if (isdir(dir) && !issymlink(dir)) {
 566         if (RMDIR(dir) && !ign_err)
 567             return 1;
 568     }
 569     else {
 570         if (REMOVE(dir, ign_err))
 571             return 1;
 572     }
 573
 574     if (!nukedirs)
 575         return 0;
 576     while (cp2) {
 577         if ((cp2 = strrchr(cp1, '/')) != NULL)
 578             *cp2 = '\0';
 579         if (!isemptydir(dir))
 580             return 0;
 581         if (RMDIR(dir) && !ign_err) {
 582             if (!fexists(dir))
 583                 warnx("directory '%s' doesn't exist", dir);
 584             else
 585                 return 1;
 586         }
 587         /* back up the pathname one component */
 588         if (cp2) {
 589             cp1 = strdup(dir);
 590         }
 591     }
 592     return 0;
 593 }