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 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 28 29 #include <stdio.h> 30 #include <sys/types.h> 31 #include <sys/param.h> 32 #include <dirent.h> 33 #include <limits.h> 34 #include <errno.h> 35 #include <ctype.h> 36 #include <fcntl.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <unistd.h> 40 #include <pkglib.h> 41 #include <libintl.h> 42 #include <libinst.h> 43 #include <install.h> 44 45 #define ERR_NOPKGMAP "Cannot open pkgmap file." 46 47 #define ENTRY_MAX (PATH_MAX + 38) 48 #define IGNORE_START ":#!" 49 #define IGNORE_TYPE "i" 50 51 static int has_rel_path(char *entry); 52 static int is_relative(char *entry); 53 54 /* 55 * This routine attempts to determine with certainty whether or not 56 * the package is relocatable or not. It first attempts to determine if 57 * there is a reloc directory by scanning pkginstdir. If that fails to 58 * provide a definite result (pkg is coming from a stream device and 59 * the directories aren't in place) it inspects the pkgmap in pkginstdir 60 * in order to determine if the package has relocatable elements. If 61 * there is a single relative pathname or $BASEDIR/... construct, 62 * this returns 1. If no relative pathnames are found it returns 0 63 * meaning absolute package and all the things that implies. 64 * 65 * This does not determine the validity of the pkgmap file. If the pkgmap 66 * is corrupted, this returns 0. 67 */ 68 int 69 isreloc(char *pkginstdir) 70 { 71 FILE *pkg_fp; 72 struct dirent *drp; 73 DIR *dirfp; 74 int retcode = 0; 75 76 /* First look in the directory */ 77 if ((dirfp = opendir(pkginstdir)) != NULL) { 78 while ((drp = readdir(dirfp)) != NULL) { 79 if (drp->d_name[0] == '.') 80 continue; 81 if (strlen(drp->d_name) < (size_t)5) 82 continue; 83 if (strncmp(drp->d_name, "reloc", 5) == 0) { 84 retcode = 1; 85 break; 86 } 87 } 88 (void) closedir(dirfp); 89 } 90 91 /* 92 * If retcode == 0, meaning we didn't find a reloc directory then we 93 * probably don't have a complete directory structure available to 94 * us. We'll have to determine what type of package it is by scanning 95 * the pkgmap file. 96 */ 97 if (retcode == 0) { 98 char path_buffer[ENTRY_MAX]; 99 100 (void) snprintf(path_buffer, sizeof (path_buffer), 101 "%s/pkgmap", pkginstdir); 102 103 canonize(path_buffer); 104 105 if ((pkg_fp = fopen(path_buffer, "r")) != NULL) { 106 while (fgets(path_buffer, sizeof (path_buffer), pkg_fp)) 107 if (has_rel_path(path_buffer)) { 108 retcode = 1; 109 break; 110 } 111 (void) fclose(pkg_fp); 112 } else { 113 progerr(gettext(ERR_NOPKGMAP)); 114 quit(99); 115 } 116 } 117 118 return (retcode); 119 } 120 121 /* 122 * Test the string for the presence of a relative path. If found, return 123 * 1 otherwise return 0. If we get past the IGNORE_TYPE test, we're working 124 * with a line of the form : 125 * 126 * dpart type classname pathname ... 127 * 128 * It's pathname we're going to test here. 129 * 130 * Yes, yes, I know about sscanf(); but, I don't need to reserve 4K of 131 * space and parse the whole string, I just need to get to two tokens. 132 * We're in a hurry. 133 */ 134 static int 135 has_rel_path(char *entry) 136 { 137 register int entry_pos = 1; 138 139 /* If the line is a comment or special directive, return 0 */ 140 if (*entry == NULL || strchr(IGNORE_START, *entry)) 141 return (0); 142 143 /* Skip past this data entry if it is volume number. */ 144 if (isdigit(*entry)) { 145 while (*entry && !isspace(*entry)) { 146 entry++; 147 } 148 } 149 150 /* Skip past this white space */ 151 while (*entry && isspace(*entry)) { 152 entry++; 153 } 154 155 /* 156 * Now we're either pointing at the type or we're pointing at 157 * the termination of a degenerate entry. If the line is degenerate 158 * or the type indicates this line should be ignored, we return 159 * as though not relative. 160 */ 161 if (*entry == NULL || strchr(IGNORE_TYPE, *entry)) 162 return (0); 163 164 /* The pathname is in the third position */ 165 do { 166 /* Skip past this data entry */ 167 while (*entry && !isspace(*entry)) { 168 entry++; 169 } 170 171 /* Skip past this white space and call this the next entry */ 172 while (*entry && isspace(*entry)) { 173 entry++; 174 } 175 } while (++entry_pos < 3 && *entry != NULL); 176 177 /* 178 * Now we're pointing at the first character of the pathname. 179 * If the file is corrupted, we're pointing at NULL. is_relative() 180 * will return FALSE for NULL which will yield the correct return 181 * value. 182 */ 183 return (is_relative(entry)); 184 } 185 186 /* 187 * If the path doesn't begin with a variable, the first character in the 188 * path is tested for '/' to determine if it is absolute or not. If the 189 * path begins with a '$', that variable is resolved if possible. If it 190 * isn't defined yet, we exit with error code 1. 191 */ 192 static int 193 is_relative(char *entry) 194 { 195 register char *eopath = entry; /* end of full pathname pointer */ 196 register char **lasts = &entry; 197 198 /* If there is a path, test it */ 199 if (entry && *entry) { 200 if (*entry == '$') { /* it's an environment parameter */ 201 entry++; /* skip the '$' */ 202 203 while (*eopath && !isspace(*eopath)) 204 eopath++; 205 206 *eopath = '\0'; /* terminate the pathname */ 207 208 /* isolate the variable */ 209 entry = strtok_r(entry, "/", lasts); 210 211 /* 212 * Some packages call out $BASEDIR for relative 213 * paths in the pkgmap even though that is 214 * redundant. This special case is actually 215 * an indication that this is a relative 216 * path. 217 */ 218 if (strcmp(entry, "BASEDIR") == 0) 219 return (1); 220 /* 221 * Since entry is pointing to a now-expendable PATH_MAX 222 * size buffer, we can expand the path variable into it 223 * here. 224 */ 225 entry = getenv(entry); 226 } 227 228 /* 229 * Return type of path. If pathname was unresolvable 230 * variable, assume relative. This looks like a strange 231 * assumption since the resolved path may end up 232 * absolute and pkgadd may prompt the user for a basedir 233 * incorrectly because of this assumption. Unfortunately, 234 * the request script MUST have a final BASEDIR in the 235 * environment before it executes. 236 */ 237 if (entry && *entry) 238 return (RELATIVE(entry)); 239 else 240 return (1); 241 } else /* no path, so we skip it */ 242 return (0); 243 } 244