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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/types.h> 27 #include <stdio.h> 28 #include <errno.h> 29 #include <unistd.h> 30 #include <string.h> 31 #include <wait.h> 32 #include <limits.h> 33 #include <gelf.h> 34 #include "machdep.h" 35 #include "sgs.h" 36 #include "conv.h" 37 #include "_crle.h" 38 #include "msg.h" 39 40 /* 41 * Establish an association between a filter and filtee. Both the filter and 42 * filtee already exist in the internal hash table, since auditing registers 43 * objects (la_objopen()) before it registers filters (la_objfilter()). 44 */ 45 static int 46 filter(Crle_desc *crle, const char *filter, const char *str, const char *filtee) 47 { 48 Hash_ent *fltrent, *flteent; 49 Flt_desc *flt; 50 Aliste idx; 51 52 /* 53 * Locate the filter. Mark the underlying object as the filter to 54 * reflect that no matter how it is referenced, it's a filter. 55 */ 56 if ((fltrent = get_hash(crle->c_strtbl, (Addr)filter, 0, 57 HASH_FND_ENT)) == NULL) 58 return (1); 59 if ((fltrent = get_hash(crle->c_strtbl, (Addr)fltrent->e_obj->o_path, 0, 60 HASH_FND_ENT)) == NULL) 61 return (1); 62 fltrent->e_obj->o_flags |= RTC_OBJ_FILTER; 63 64 /* 65 * Locate the filtee. Mark the referencing object as the filtee, as 66 * this is the object referenced by the filter. 67 */ 68 if ((flteent = get_hash(crle->c_strtbl, (Addr)filtee, 0, 69 HASH_FND_ENT)) == NULL) 70 return (1); 71 flteent->e_flags |= RTC_OBJ_FILTEE; 72 73 /* 74 * Traverse the filter list using the filters real name. If ld.so.1 75 * inspects the resulting configuration file for filters, it's the 76 * objects real name that will be used (PATHNAME()). 77 */ 78 for (APLIST_TRAVERSE(crle->c_flt, idx, flt)) { 79 /* 80 * Determine whether this filter and filtee string pair already 81 * exist. 82 */ 83 if ((strcmp(flt->f_fent->e_obj->o_path, 84 fltrent->e_obj->o_path) != 0) && 85 (strcmp(flt->f_str, str) != 0)) 86 continue; 87 88 /* 89 * Add this filtee additional association. 90 */ 91 if (aplist_append(&(flt->f_filtee), flteent, 92 AL_CNT_CRLE) == NULL) 93 return (1); 94 95 crle->c_fltenum++; 96 return (0); 97 } 98 99 /* 100 * This is a new filter descriptor. Add this new filtee association. 101 */ 102 if (((flt = malloc(sizeof (Flt_desc))) == NULL) || 103 ((flt->f_strsz = strlen(str) + 1) == 0) || 104 ((flt->f_str = malloc(flt->f_strsz)) == NULL)) { 105 int err = errno; 106 (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), 107 crle->c_name, strerror(err)); 108 return (1); 109 } 110 if ((aplist_append(&(crle->c_flt), flt, AL_CNT_CRLE) == NULL) || 111 (aplist_append(&(flt->f_filtee), flteent, AL_CNT_CRLE) == NULL)) 112 return (1); 113 114 flt->f_fent = fltrent; 115 (void) memcpy((void *)flt->f_str, (void *)str, flt->f_strsz); 116 crle->c_strsize += flt->f_strsz; 117 crle->c_fltrnum += 1; 118 crle->c_fltenum += 2; /* Account for null filtee desc. */ 119 120 return (0); 121 } 122 123 /* 124 * Establish the dependencies of an ELF object and add them to the internal 125 * configuration information. This information is gathered by using libcrle.so.1 126 * as an audit library - this is akin to using ldd(1) only simpler. 127 */ 128 int 129 depend(Crle_desc *crle, const char *name, Half flags, GElf_Ehdr *ehdr) 130 { 131 const char *exename; 132 const char *preload; 133 int fildes[2], pid; 134 135 /* 136 * If we're dealing with a dynamic executable we'll execute it, 137 * otherwise we'll preload the shared object with one of the lddstub's. 138 */ 139 if (ehdr->e_type == ET_EXEC) { 140 exename = name; 141 preload = NULL; 142 } else { 143 exename = conv_lddstub(M_CLASS); 144 preload = name; 145 } 146 147 /* 148 * Set up a pipe through which the audit library will write the 149 * dependencies. 150 */ 151 if (pipe(fildes) == -1) { 152 int err = errno; 153 (void) fprintf(stderr, MSG_INTL(MSG_SYS_PIPE), 154 crle->c_name, strerror(err)); 155 return (1); 156 } 157 158 /* 159 * Fork ourselves to run our executable and collect its dependencies. 160 */ 161 if ((pid = fork()) == -1) { 162 int err = errno; 163 (void) fprintf(stderr, MSG_INTL(MSG_SYS_FORK), 164 crle->c_name, strerror(err)); 165 return (1); 166 } 167 168 if (pid) { 169 /* 170 * Parent. Read each dependency from the audit library. The read 171 * side of the pipe is attached to stdio to make obtaining the 172 * individual dependencies easier. 173 */ 174 int error = 0, status; 175 FILE *fd; 176 char buffer[PATH_MAX]; 177 178 (void) close(fildes[1]); 179 if ((fd = fdopen(fildes[0], MSG_ORIG(MSG_STR_READ))) != NULL) { 180 char *str; 181 182 while (fgets(buffer, PATH_MAX, fd) != NULL) { 183 /* 184 * Make sure we recognize the message, remove 185 * the newline (which allowed fgets() use) and 186 * register the name; 187 */ 188 if (strncmp(MSG_ORIG(MSG_AUD_PRF), buffer, 189 MSG_AUD_PRF_SIZE)) 190 continue; 191 192 str = strrchr(buffer, '\n'); 193 *str = '\0'; 194 str = buffer + MSG_AUD_PRF_SIZE; 195 196 if (strncmp(MSG_ORIG(MSG_AUD_DEPEND), 197 str, MSG_AUD_DEPEND_SIZE) == 0) { 198 /* 199 * Process any dependencies. 200 */ 201 str += MSG_AUD_DEPEND_SIZE; 202 203 if ((error = inspect(crle, str, 204 (flags & ~RTC_OBJ_GROUP))) != 0) 205 break; 206 207 } else if (strncmp(MSG_ORIG(MSG_AUD_FILTER), 208 str, MSG_AUD_FILTER_SIZE) == 0) { 209 char *_flt, *_str; 210 211 /* 212 * Process any filters. 213 */ 214 _flt = str += MSG_AUD_FILTER_SIZE; 215 _str = strchr(str, ':'); 216 *_str++ = '\0'; str = _str++; 217 str = strrchr(str, ')'); 218 *str++ = '\0'; str++; 219 if ((error = filter(crle, _flt, _str, 220 str)) != 0) 221 break; 222 } 223 } 224 } else 225 error = errno; 226 227 while (wait(&status) != pid) 228 ; 229 if (status) { 230 if (WIFSIGNALED(status)) { 231 (void) fprintf(stderr, 232 MSG_INTL(MSG_SYS_EXEC), crle->c_name, 233 exename, (WSIGMASK & status), 234 ((status & WCOREFLG) ? 235 MSG_INTL(MSG_SYS_CORE) : 236 MSG_ORIG(MSG_STR_EMPTY))); 237 } 238 error = status; 239 } 240 (void) fclose(fd); 241 242 return (error); 243 } else { 244 char efds[MSG_ENV_AUD_FD_SIZE + 10]; 245 char epld[PATH_MAX]; 246 char eldf[PATH_MAX]; 247 248 (void) close(fildes[0]); 249 250 /* 251 * Child. Set up environment variables to enable and identify 252 * auditing. Initialize CRLE_FD and LD_FLAGS strings. 253 */ 254 (void) snprintf(efds, (MSG_ENV_AUD_FD_SIZE + 10), 255 MSG_ORIG(MSG_ENV_AUD_FD), fildes[1]); 256 (void) snprintf(eldf, PATH_MAX, MSG_ORIG(MSG_ENV_LD_FLAGS)); 257 258 /* 259 * If asked to dump a group of dependencies make sure any 260 * lazily-loaded objects get processed - (append loadavail to 261 * LD_FLAGS=confgen). 262 */ 263 if (flags & RTC_OBJ_GROUP) 264 (void) strcat(eldf, MSG_ORIG(MSG_LDFLG_LOADAVAIL)); 265 266 /* 267 * Put LD_PRELOAD= in the environment if necessary. 268 */ 269 if (preload) { 270 (void) snprintf(epld, PATH_MAX, 271 MSG_ORIG(MSG_ENV_LD_PRELOAD), preload); 272 } 273 274 /* 275 * Put strings in the environment for exec(). 276 * NOTE, use of automatic variables for construction of the 277 * environment variables is legitimate here, as they are local 278 * to the child process and are established solely for exec(). 279 */ 280 if ((putenv(efds) != 0) || (putenv(crle->c_audit) != 0) || 281 (putenv(eldf) != 0) || (preload && (putenv(epld) != 0))) { 282 int err = errno; 283 (void) fprintf(stderr, MSG_INTL(MSG_SYS_PUTENV), 284 crle->c_name, strerror(err)); 285 return (1); 286 } 287 288 if (execlp(exename, exename, 0) == -1) { 289 _exit(errno); 290 /* NOTREACHED */ 291 } 292 } 293 return (0); 294 } 295