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 (c) 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * The primary role of this file is to obtain a list of manifests that are 28 * located in a specified directory or one of its subdirectories. The 29 * find_manifests() function provides this service, and 30 * free_manifest_array() is used to free the memory associated with the 31 * returned list. 32 * 33 * The find_manifests() function can return an array consisting of all the 34 * .xml files in the directory and its subdirectories. Alternatively, 35 * find_manifests() can be asked to only return new manifests based on the 36 * return of mhash_test_file(). The list that is returned is an array of 37 * pointers to manifest_info structures. 38 * 39 * Implementation Notes: 40 * ==================== 41 * This module makes use of the nftw(3C) function to scan the directory. 42 * nftw() calls a processing function for every file that it finds. 43 * Unfortunately, nftw does not allow us to pass in any structure pointers 44 * to the processing function, and that makes it hard to accumulate a list. 45 * Thus, we will use the thread specific data area to hold data that must 46 * be retained between calls to the processing function. This will allow 47 * this module to be used in multi-threaded applications if the need 48 * arises. 49 */ 50 51 #include <assert.h> 52 #include <errno.h> 53 #include <ftw.h> 54 #include <libscf.h> 55 #include <libuutil.h> 56 #include <pthread.h> 57 #include <stdlib.h> 58 #include <string.h> 59 #include "manifest_find.h" 60 #include "manifest_hash.h" 61 62 #define MAX_DEPTH 24 63 64 /* Thread specific data */ 65 typedef struct mftsd { 66 manifest_info_t ** tsd_array; /* Array of manifest_info structs */ 67 int tsd_count; /* Number items in list */ 68 int tsd_max; /* Number of pointers allocated */ 69 /* at tsd_array. */ 70 int tsd_flags; /* Check flags for hash and extension */ 71 scf_handle_t *tsd_hndl; /* Handle for libscf. */ 72 } mftsd_t; 73 74 static pthread_key_t tsd_key = PTHREAD_ONCE_KEY_NP; 75 76 /* 77 * Add the manifest info consisting of filename (fn), hash property name 78 * (pname) and hash to the array at tsd_array. If necessary, realloc() 79 * will be called to increase the size of the buffer at tsd_array. 80 * 81 * Returns 0 on success and -1 on failure. If a failure occurs, errno will 82 * be set. 83 */ 84 static int 85 add_pointer(mftsd_t *tsdp, const char *fn, const char *pname, uchar_t *hash) 86 { 87 manifest_info_t *info; 88 manifest_info_t **newblock; 89 int new_max; 90 91 if (tsdp->tsd_count >= (tsdp->tsd_max - 1)) { 92 /* Need more memory. */ 93 new_max = (tsdp->tsd_max == 0) ? 16 : 2 * tsdp->tsd_max; 94 newblock = realloc(tsdp->tsd_array, 95 new_max * sizeof (*tsdp->tsd_array)); 96 if (newblock == NULL) 97 return (-1); 98 tsdp->tsd_array = newblock; 99 /* NULL terminate list in case allocations fail below. */ 100 *(tsdp->tsd_array + tsdp->tsd_count) = NULL; 101 tsdp->tsd_max = new_max; 102 } 103 info = uu_zalloc(sizeof (*info)); 104 if (info == NULL) { 105 errno = ENOMEM; 106 return (-1); 107 } 108 info->mi_path = uu_strdup(fn); 109 if (info->mi_path == NULL) { 110 uu_free(info); 111 errno = ENOMEM; 112 return (-1); 113 } 114 info->mi_prop = pname; 115 if (hash != NULL) 116 (void) memcpy(info->mi_hash, hash, MHASH_SIZE); 117 *(tsdp->tsd_array + tsdp->tsd_count) = info; 118 tsdp->tsd_count++; 119 120 /* NULL terminate the list. */ 121 *(tsdp->tsd_array + tsdp->tsd_count) = NULL; 122 123 return (0); 124 } 125 126 /* 127 * If necessary initialize the thread specific data key at tsd_key, and 128 * allocate a mftsd_t structure to hold our thread specific data. Upon 129 * success, the address the thread specific data is returned. On failure, 130 * NULL is returned and errno is set. 131 */ 132 static mftsd_t * 133 get_thread_specific_data() 134 { 135 mftsd_t *tsdp; 136 137 if (pthread_key_create_once_np(&tsd_key, NULL) != 0) 138 return (NULL); 139 tsdp = (mftsd_t *)pthread_getspecific(tsd_key); 140 if (tsdp == NULL) { 141 /* 142 * First time for this thread. We need to allocate memory 143 * for our thread specific data. 144 */ 145 tsdp = uu_zalloc(sizeof (*tsdp)); 146 if (tsdp == NULL) { 147 errno = ENOMEM; 148 return (NULL); 149 } 150 errno = pthread_setspecific(tsd_key, tsdp); 151 if (errno != 0) { 152 /* 153 * EINVAL means that our key is invalid, which 154 * would be a coding error. 155 */ 156 assert(errno != EINVAL); 157 return (NULL); 158 } 159 } 160 return (tsdp); 161 } 162 163 /* 164 * This function is called by nftw(3C) every time that it finds an object 165 * in a directory of interest. If the object is a file, process() checks 166 * to see if it is a service bundle file by insuring that it has a .xml 167 * extension. 168 * 169 * If the file is a service bundle file, and the CHECKHASH flag is set process() 170 * calls mhash_test_file() to see if it is a new bundle. Bundle file data 171 * for selected bundles is added to tsd_array in our thread specific data. 172 * 173 * Assume given file is a manifest unless BUNDLE_PROF flag is set to indicate 174 * it's a profile. For profile bundles, call mhash_test_file() with the 175 * appropriate argument. 176 * 177 * The CHECKEXT flag may be set if this was not a directory search request 178 * but a single service bundle file check that was determined by the caller to 179 * be found based not on the extension of the file. 180 */ 181 /*ARGSUSED*/ 182 static int 183 process(const char *fn, const struct stat *sp, int ftw_type, 184 struct FTW *ftws) 185 { 186 int is_profile; 187 char *suffix_match; 188 uchar_t hash[MHASH_SIZE]; 189 char *pname; 190 mftsd_t *tsdp; 191 192 if (ftw_type != FTW_F) 193 return (0); 194 195 tsdp = get_thread_specific_data(); 196 if (tsdp == NULL) 197 return (-1); 198 199 /* 200 * Only check the extension on the file when 201 * requested. 202 */ 203 if (tsdp->tsd_flags & CHECKEXT) { 204 suffix_match = strstr(fn, ".xml"); 205 if (suffix_match == NULL || strcmp(suffix_match, ".xml") != 0) 206 return (0); 207 } 208 209 if (tsdp->tsd_flags & CHECKHASH) { 210 is_profile = (tsdp->tsd_flags & BUNDLE_PROF) ? 1 : 0; 211 if (mhash_test_file(tsdp->tsd_hndl, fn, is_profile, &pname, 212 hash) == MHASH_NEWFILE) { 213 return (add_pointer(tsdp, fn, pname, hash)); 214 } 215 } else { 216 return (add_pointer(tsdp, fn, NULL, NULL)); 217 } 218 219 return (0); 220 } 221 222 /* 223 * This function returns a pointer to an array of manifest_info_t pointers. 224 * There is one manifest_info_t pointer for each service bundle file in the 225 * directory, dir, that satifies the selection criteria. The array is 226 * returned to arrayp. The array will be terminated with a NULL pointer. 227 * It is the responsibility of the caller to free the memory associated 228 * with the array by calling free_manifest_array(). 229 * 230 * flags : 231 * 0x1 - CHECKHASH - do the hash check and only return bundle 232 * files that do not have a hash entry in the smf/manifest table 233 * or the hash value has changed due to the bundle file having 234 * been modified. If not set then all service bundle files found 235 * are returned, regardless of the hash status. 236 * 237 * 0x2 - CHECKEXT - Check the extension of the file is .xml 238 * 239 * On success a count of the number of selected bundles is returned. 240 * Note, however, that *arrayp will be set to NULL if the selection is 241 * empty, and a count of 0 will be returned. In the case of failure, -1 242 * will be returned and errno will be set. 243 * 244 * This function takes a repository handle argument from the caller and saves 245 * that handle in a thread specific data structure. The thread specific 246 * repository handle is used in process() to communicate with the appropriate 247 * repository. Thus callers should take care of thread safety with respect to 248 * the repository handle. Currently, the two callers of find_manifests are both 249 * single threaded, i.e. svccfg and mfstscan, so thread safety not an issue. 250 */ 251 int 252 find_manifests(scf_handle_t *hndl, const char *dir, 253 manifest_info_t ***arrayp, int flags) 254 { 255 mftsd_t *tsdp; 256 int status = -1; 257 int count; 258 259 tsdp = get_thread_specific_data(); 260 if (tsdp == NULL) 261 return (-1); 262 263 tsdp->tsd_flags = flags; 264 265 if (tsdp->tsd_flags & CHECKHASH) { 266 tsdp->tsd_hndl = hndl; 267 } 268 269 if (nftw(dir, process, MAX_DEPTH, FTW_MOUNT) == 0) { 270 status = 0; 271 } 272 273 out: 274 if (status == 0) { 275 *arrayp = tsdp->tsd_array; 276 count = tsdp->tsd_count; 277 } else { 278 *arrayp = NULL; 279 free_manifest_array(tsdp->tsd_array); 280 count = -1; 281 } 282 283 /* Reset thread specific data. */ 284 (void) memset(tsdp, 0, sizeof (*tsdp)); 285 286 return (count); 287 } 288 289 /* 290 * Free the memory associated with the array of manifest_info structures. 291 */ 292 void 293 free_manifest_array(manifest_info_t **array) 294 { 295 manifest_info_t **entry; 296 manifest_info_t *info; 297 298 if (array == NULL) 299 return; 300 301 for (entry = array; *entry != NULL; entry++) { 302 info = *entry; 303 uu_free((void *) info->mi_path); 304 uu_free((void *) info->mi_prop); 305 uu_free(info); 306 } 307 308 /* 309 * Array is allocated with realloc(3C), so it must be freed with 310 * free(3c) rather than uu_free(). 311 */ 312 free(array); 313 } 314