usr/src/lib/libadm/common/pkgparam.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  22 /*        All Rights Reserved   */
  23
  24 /*
  25  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  26  * Use is subject to license terms.
  27  */
  28
  29 /*
  30  * Copyright 2010 Nexenta Systems, Inc.  All rights reserved.
  31  */
  32
  33 /*LINTLIBRARY*/
  34
  35 /*   5-20-92   newroot support added  */
  36
  37 #include <stdio.h>
  38 #include <limits.h>
  39 #include <ctype.h>
  40 #include <errno.h>
  41 #include <string.h>
  42 #include <sys/types.h>
  43 #include <pkgstrct.h>
  44 #include <pkginfo.h>
  45 #include <pkglocs.h>
  46 #include <stdlib.h>
  47 #include <unistd.h>
  48 #include "libadm.h"
  49
  50 #define VALSIZ  128
  51 #define NEWLINE '\n'
  52 #define ESCAPE  '\\'
  53
  54 static char sepset[] =  ":=\n";
  55 static char qset[] =    "'\"";
  56 static char *pkg_inst_root = NULL;
  57
  58 char *pkgdir = NULL;
  59 char *pkgfile = NULL;
  60
  61 static char Adm_pkgloc[PATH_MAX] = { 0 }; /* added for newroot */
  62 static char Adm_pkgadm[PATH_MAX] = { 0 }; /* added for newroot */
  63
  64 /*
  65  * This looks in a directory that might be the top level directory of a
  66  * package. It tests a temporary install directory first and then for a
  67  * standard directory. This looks a little confusing, so here's what's
  68  * happening. If this pkginfo is being openned in a script during a pkgadd
  69  * which is updating an existing package, the original pkginfo file is in a
  70  * directory that has been renamed from <pkginst> to .save.<pkginst>. If the
  71  * pkgadd fails it will be renamed back to <pkginst>. We are always interested
  72  * in the OLD pkginfo data because the new pkginfo data is already in our
  73  * environment. For that reason, we try to open the backup first - that has
  74  * the old data. This returns the first accessible path in "path" and a "1"
  75  * if an appropriate pkginfo file was found. It returns a 0 if no type of
  76  * pkginfo was located.
  77  */
  78 int
  79 pkginfofind(char *path, char *pkg_dir, char *pkginst)
  80 {
  81         int len = 0;
  82
  83         /* Construct the temporary pkginfo file name. */
  84         len =  snprintf(path, PATH_MAX, "%s/.save.%s/pkginfo", pkg_dir,
  85             pkginst);
  86         if (len > PATH_MAX)
  87                 return (0);
  88         if (access(path, 0)) {
  89                 /*
  90                  * This isn't a temporary directory, so we look for a
  91                  * regular one.
  92                  */
  93                 len =  snprintf(path, PATH_MAX, "%s/%s/pkginfo", pkg_dir,
  94                     pkginst);
  95                 if (len > PATH_MAX)
  96                         return (0);
  97                 if (access(path, 0))
  98                         return (0); /* doesn't appear to be a package */
  99         }
 100
 101         return (1);
 102 }
 103
 104 /*
 105  * This opens the appropriate pkginfo file for a particular package.
 106  */
 107 FILE *
 108 pkginfopen(char *pkg_dir, char *pkginst)
 109 {
 110         FILE *fp = NULL;
 111         char temp[PATH_MAX];
 112
 113         if (pkginfofind(temp, pkg_dir, pkginst))
 114                 fp = fopen(temp, "r");
 115
 116         return (fp);
 117 }
 118
 119
 120 char *
 121 fpkgparam(FILE *fp, char *param)
 122 {
 123         char    ch, buffer[VALSIZ];
 124         char    *mempt, *copy;
 125         int     c, n;
 126         boolean_t check_end_quote = B_FALSE;
 127         boolean_t begline, quoted, escape;
 128         int idx = 0;
 129
 130         if (param == NULL) {
 131                 errno = ENOENT;
 132                 return (NULL);
 133         }
 134
 135         mempt = NULL;
 136
 137         for (;;) {              /* For each entry in the file fp */
 138                 copy = buffer;
 139                 n = 0;
 140
 141                 /* Get the next token. */
 142                 while ((c = getc(fp)) != EOF) {
 143                         ch = (char)c;
 144                         if (strchr(sepset, ch))
 145                                 break;
 146                         if (++n < VALSIZ)
 147                                 *copy++ = ch;
 148                 }
 149
 150                 /* If it's the end of the file, exit the for() loop */
 151                 if (c == EOF) {
 152                         errno = EINVAL;
 153                         return (NULL); /* No more entries left */
 154
 155                 /* If it's end of line, look for the next parameter. */
 156                 } else if (c == NEWLINE)
 157                         continue;
 158
 159                 /* At this point copy points to the end of a valid parameter. */
 160                 *copy = '\0';           /* Terminate the string. */
 161                 if (buffer[0] == '#')   /* If it's a comment, drop thru. */
 162                         copy = NULL;    /* Comments don't get buffered. */
 163                 else {
 164                         /* If parameter is NULL, we return whatever we got. */
 165                         if (param[0] == '\0') {
 166                                 (void) strcpy(param, buffer);
 167                                 copy = buffer;
 168
 169                         /* If this doesn't match the parameter, drop thru. */
 170                         } else if (strcmp(param, buffer))
 171                                 copy = NULL;
 172
 173                         /* Otherwise, this is our boy. */
 174                         else
 175                                 copy = buffer;
 176                 }
 177
 178                 n = 0;
 179                 quoted = escape = B_FALSE;
 180                 begline = B_TRUE; /* Value's line begins */
 181
 182                 /* Now read the parameter value. */
 183                 while ((c = getc(fp)) != EOF) {
 184                         ch = (char)c;
 185
 186                         if (begline && ((ch == ' ') || (ch == '\t')))
 187                                 continue; /* Ignore leading white space */
 188
 189                         /*
 190                          * Take last end quote 'verbatim' if anything
 191                          * other than space, newline and escape.
 192                          * Example:
 193                          * PARAM1="zonename="test-zone""
 194                          *      Here in this example the letter 't' inside
 195                          *      the value is followed by '"', this makes
 196                          *      the previous end quote candidate '"',
 197                          *      a part of value and the end quote
 198                          *      disqualfies. Reset check_end_quote.
 199                          * PARAM2="value"<== newline here
 200                          * PARAM3="value"\
 201                          * "continued"<== newline here.
 202                          *      Check for end quote continues.
 203                          */
 204                         if (ch != NEWLINE && ch != ' ' && ch != ESCAPE &&
 205                             ch != '\t' && check_end_quote)
 206                                 check_end_quote = B_FALSE;
 207
 208                         if (ch == NEWLINE) {
 209                                 if (!escape) {
 210                                         /*
 211                                          * The end quote candidate qualifies.
 212                                          * Eat any trailing spaces.
 213                                          */
 214                                         if (check_end_quote) {
 215                                                 copy -= n - idx;
 216                                                 n = idx;
 217                                                 check_end_quote = B_FALSE;
 218                                                 quoted = B_FALSE;
 219                                         }
 220                                         break; /* End of entry */
 221                                 }
 222                                 /*
 223                                  * The end quote if exists, doesn't qualify.
 224                                  * Eat end quote and trailing spaces if any.
 225                                  * Value spans to next line.
 226                                  */
 227                                 if (check_end_quote) {
 228                                         copy -= n - idx;
 229                                         n = idx;
 230                                         check_end_quote = B_FALSE;
 231                                 } else if (copy) {
 232                                         copy--; /* Eat previous esc */
 233                                         n--;
 234                                 }
 235                                 escape = B_FALSE;
 236                                 begline = B_TRUE; /* New input line */
 237                                 continue;
 238                         } else {
 239                                 if (!escape && strchr(qset, ch)) {
 240                                         /* Handle quotes */
 241                                         if (begline) {
 242                                                 /* Starting quote */
 243                                                 quoted = B_TRUE;
 244                                                 begline = B_FALSE;
 245                                                 continue;
 246                                         } else if (quoted) {
 247                                                 /*
 248                                                  * This is the candidate
 249                                                  * for end quote. Check
 250                                                  * to see it qualifies.
 251                                                  */
 252                                                 check_end_quote = B_TRUE;
 253                                                 idx = n;
 254                                         }
 255                                 }
 256                                 if (ch == ESCAPE)
 257                                         escape = B_TRUE;
 258                                 else if (escape)
 259                                         escape = B_FALSE;
 260                                 if (copy) *copy++ = ch;
 261                                 begline = B_FALSE;
 262                         }
 263
 264                         if (copy && ((++n % VALSIZ) == 0)) {
 265                                 if (mempt) {
 266                                         mempt = realloc(mempt,
 267                                             (n+VALSIZ)*sizeof (char));
 268                                         if (!mempt)
 269                                                 return (NULL);
 270                                 } else {
 271                                         mempt = calloc((size_t)(2*VALSIZ),
 272                                             sizeof (char));
 273                                         if (!mempt)
 274                                                 return (NULL);
 275                                         (void) strncpy(mempt, buffer, n);
 276                                 }
 277                                 copy = &mempt[n];
 278                         }
 279                 }
 280
 281                 /*
 282                  * Don't allow trailing white space.
 283                  * NOTE : White space in the middle is OK, since this may
 284                  * be a list. At some point it would be a good idea to let
 285                  * this function know how to validate such a list. -- JST
 286                  *
 287                  * Now while there's a parametric value and it ends in a
 288                  * space and the actual remaining string length is still
 289                  * greater than 0, back over the space.
 290                  */
 291                 while (copy && isspace((unsigned char)*(copy - 1)) && n-- > 0)
 292                         copy--;
 293
 294                 if (quoted) {
 295                         if (mempt)
 296                                 (void) free(mempt);
 297                         errno = EFAULT; /* missing closing quote */
 298                         return (NULL);
 299                 }
 300                 if (copy) {
 301                         *copy = '\0';
 302                         break;
 303                 }
 304                 if (c == EOF) {
 305                         errno = EINVAL; /* parameter not found */
 306                         return (NULL);
 307                 }
 308         }
 309
 310         if (!mempt)
 311                 mempt = strdup(buffer);
 312         else
 313                 mempt = realloc(mempt, (strlen(mempt)+1)*sizeof (char));
 314         return (mempt);
 315 }
 316
 317 char *
 318 pkgparam(char *pkg, char *param)
 319 {
 320         static char lastfname[PATH_MAX];
 321         static FILE *fp = NULL;
 322         char *pt, *copy, *value, line[PATH_MAX];
 323
 324         if (!pkgdir)
 325                 pkgdir = get_PKGLOC();
 326
 327         if (!pkg) {
 328                 /* request to close file */
 329                 if (fp) {
 330                         (void) fclose(fp);
 331                         fp = NULL;
 332                 }
 333                 return (NULL);
 334         }
 335
 336         if (!param) {
 337                 errno = ENOENT;
 338                 return (NULL);
 339         }
 340
 341         if (pkgfile)
 342                 (void) strcpy(line, pkgfile); /* filename was passed */
 343         else
 344                 (void) pkginfofind(line, pkgdir, pkg);
 345
 346         if (fp && strcmp(line, lastfname)) {
 347                 /* different filename implies need for different fp */
 348                 (void) fclose(fp);
 349                 fp = NULL;
 350         }
 351         if (!fp) {
 352                 (void) strcpy(lastfname, line);
 353                 if ((fp = fopen(lastfname, "r")) == NULL)
 354                         return (NULL);
 355         }
 356
 357         /*
 358          * if parameter is a null string, then the user is requesting us
 359          * to find the value of the next available parameter for this
 360          * package and to copy the parameter name into the provided string;
 361          * if it is not, then it is a request for a specified parameter, in
 362          * which case we rewind the file to start search from beginning
 363          */
 364         if (param[0]) {
 365                 /* new parameter request, so reset file position */
 366                 if (fseek(fp, 0L, 0))
 367                         return (NULL);
 368         }
 369
 370         if (pt = fpkgparam(fp, param)) {
 371                 if (strcmp(param, "ARCH") == NULL ||
 372                     strcmp(param, "CATEGORY") == NULL) {
 373                         /* remove all whitespace from value */
 374                         value = copy = pt;
 375                         while (*value) {
 376                                 if (!isspace((unsigned char)*value))
 377                                         *copy++ = *value;
 378                                 value++;
 379                         }
 380                         *copy = '\0';
 381                 }
 382                 return (pt);
 383         }
 384         return (NULL);
 385 }
 386 /*
 387  * This routine sets adm_pkgloc and adm_pkgadm which are the
 388  * replacement location for PKGLOC and PKGADM.
 389  */
 390
 391 static void canonize_name(char *);
 392
 393 void
 394 set_PKGpaths(char *path)
 395 {
 396         if (path && *path) {
 397                 (void) snprintf(Adm_pkgloc, sizeof (Adm_pkgloc),
 398                     "%s%s", path, PKGLOC);
 399                 (void) snprintf(Adm_pkgadm, sizeof (Adm_pkgadm),
 400                     "%s%s", path, PKGADM);
 401                 set_install_root(path);
 402         } else {
 403                 (void) snprintf(Adm_pkgloc, sizeof (Adm_pkgloc), "%s", PKGLOC);
 404                 (void) snprintf(Adm_pkgadm, sizeof (Adm_pkgadm), "%s", PKGADM);
 405         }
 406         canonize_name(Adm_pkgloc);
 407         canonize_name(Adm_pkgadm);
 408         pkgdir = Adm_pkgloc;
 409 }
 410
 411 char *
 412 get_PKGLOC(void)
 413 {
 414         if (Adm_pkgloc[0] == NULL)
 415                 return (PKGLOC);
 416         else
 417                 return (Adm_pkgloc);
 418 }
 419
 420 char *
 421 get_PKGADM(void)
 422 {
 423         if (Adm_pkgadm[0] == NULL)
 424                 return (PKGADM);
 425         else
 426                 return (Adm_pkgadm);
 427 }
 428
 429 void
 430 set_PKGADM(char *newpath)
 431 {
 432         (void) strcpy(Adm_pkgadm, newpath);
 433 }
 434
 435 void
 436 set_PKGLOC(char *newpath)
 437 {
 438         (void) strcpy(Adm_pkgloc, newpath);
 439 }
 440
 441 #define isdot(x)        ((x[0] == '.')&&(!x[1]||(x[1] == '/')))
 442 #define isdotdot(x)     ((x[0] == '.')&&(x[1] == '.')&&(!x[2]||(x[2] == '/')))
 443
 444 static void
 445 canonize_name(char *file)
 446 {
 447         char *pt, *last;
 448         int level;
 449
 450         /* Remove references such as "./" and "../" and "//" */
 451
 452         for (pt = file; *pt; ) {
 453                 if (isdot(pt))
 454                         (void) strcpy(pt, pt[1] ? pt+2 : pt+1);
 455                 else if (isdotdot(pt)) {
 456                         level = 0;
 457                         last = pt;
 458                         do {
 459                                 level++;
 460                                 last += 2;
 461                                 if (*last)
 462                                         last++;
 463                         } while (isdotdot(last));
 464                         --pt; /* point to previous '/' */
 465                         while (level--) {
 466                                 if (pt <= file)
 467                                         return;
 468                                 while ((*--pt != '/') && (pt > file))
 469                                         ;
 470                         }
 471                         if (*pt == '/')
 472                                 pt++;
 473                         (void) strcpy(pt, last);
 474                 } else {
 475                         while (*pt && (*pt != '/'))
 476                                 pt++;
 477                         if (*pt == '/') {
 478                                 while (pt[1] == '/')
 479                                         (void) strcpy(pt, pt+1);
 480                                 pt++;
 481                         }
 482                 }
 483         }
 484         if ((--pt > file) && (*pt == '/'))
 485                 *pt = '\0';
 486 }
 487
 488 void
 489 set_install_root(char *path)
 490 {
 491         pkg_inst_root = strdup(path);
 492 }
 493
 494 char *
 495 get_install_root()
 496 {
 497         return (pkg_inst_root);
 498 }