1 /* 2 * Copyright (c) 2001 Peter Pentchev 3 * All rights reserved. 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 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/types.h> 32 #include <sys/queue.h> 33 #include <sys/sysctl.h> 34 35 #include <err.h> 36 #include <errno.h> 37 #include <limits.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <unistd.h> 42 43 /* the default sysctl name */ 44 #define PATHCTL "kern.module_path" 45 46 /* queue structure for the module path broken down into components */ 47 TAILQ_HEAD(pathhead, pathentry); 48 struct pathentry { 49 char *path; 50 TAILQ_ENTRY(pathentry) next; 51 }; 52 53 /* the Management Information Base entries for the search path sysctl */ 54 static int mib[5]; 55 static size_t miblen; 56 /* the sysctl name, defaults to PATHCTL */ 57 static char *pathctl; 58 /* the sysctl value - the current module search path */ 59 static char *modpath; 60 /* flag whether user actions require changing the sysctl value */ 61 static int changed; 62 63 /* Top-level path management functions */ 64 static void addpath(struct pathhead *, char *, int, int); 65 static void rempath(struct pathhead *, char *, int, int); 66 static void showpath(struct pathhead *); 67 68 /* Low-level path management functions */ 69 static char *qstring(struct pathhead *); 70 71 /* sysctl-related functions */ 72 static void getmib(void); 73 static void getpath(void); 74 static void parsepath(struct pathhead *, char *, int); 75 static void setpath(struct pathhead *); 76 77 static void usage(void); 78 79 /* Get the MIB entry for our sysctl */ 80 static void 81 getmib(void) 82 { 83 84 /* have we already fetched it? */ 85 if (miblen != 0) 86 return; 87 88 miblen = sizeof(mib) / sizeof(mib[0]); 89 if (sysctlnametomib(pathctl, mib, &miblen) != 0) 90 err(1, "sysctlnametomib(%s)", pathctl); 91 } 92 93 /* Get the current module search path */ 94 static void 95 getpath(void) 96 { 97 char *path; 98 size_t sz; 99 100 if (modpath != NULL) { 101 free(modpath); 102 modpath = NULL; 103 } 104 105 if (miblen == 0) 106 getmib(); 107 if (sysctl(mib, miblen, NULL, &sz, NULL, 0) == -1) 108 err(1, "getting path: sysctl(%s) - size only", pathctl); 109 if ((path = malloc(sz + 1)) == NULL) { 110 errno = ENOMEM; 111 err(1, "allocating %lu bytes for the path", 112 (unsigned long)sz+1); 113 } 114 if (sysctl(mib, miblen, path, &sz, NULL, 0) == -1) 115 err(1, "getting path: sysctl(%s)", pathctl); 116 modpath = path; 117 } 118 119 /* Set the module search path after changing it */ 120 static void 121 setpath(struct pathhead *pathq) 122 { 123 char *newpath; 124 125 if (miblen == 0) 126 getmib(); 127 if ((newpath = qstring(pathq)) == NULL) { 128 errno = ENOMEM; 129 err(1, "building path string"); 130 } 131 if (sysctl(mib, miblen, NULL, NULL, newpath, strlen(newpath)+1) == -1) 132 err(1, "setting path: sysctl(%s)", pathctl); 133 134 if (modpath != NULL) 135 free(modpath); 136 modpath = newpath; 137 } 138 139 /* Add/insert a new component to the module search path */ 140 static void 141 addpath(struct pathhead *pathq, char *path, int force, int insert) 142 { 143 struct pathentry *pe, *pskip; 144 char pathbuf[MAXPATHLEN+1]; 145 size_t len; 146 static unsigned added = 0; 147 unsigned i; 148 149 /* 150 * If the path exists, use it; otherwise, take the user-specified 151 * path at face value - may be a removed directory. 152 */ 153 if (realpath(path, pathbuf) == NULL) 154 strlcpy(pathbuf, path, sizeof(pathbuf)); 155 156 len = strlen(pathbuf); 157 /* remove a terminating slash if present */ 158 if ((len > 0) && (pathbuf[len-1] == '/')) 159 pathbuf[--len] = '\0'; 160 161 /* is it already in there? */ 162 TAILQ_FOREACH(pe, pathq, next) 163 if (!strcmp(pe->path, pathbuf)) 164 break; 165 if (pe != NULL) { 166 if (force) 167 return; 168 errx(1, "already in the module search path: %s", pathbuf); 169 } 170 171 /* OK, allocate and add it. */ 172 if (((pe = malloc(sizeof(*pe))) == NULL) || 173 ((pe->path = strdup(pathbuf)) == NULL)) { 174 errno = ENOMEM; 175 err(1, "allocating path component"); 176 } 177 if (!insert) { 178 TAILQ_INSERT_TAIL(pathq, pe, next); 179 } else { 180 for (i = 0, pskip = TAILQ_FIRST(pathq); i < added; i++) 181 pskip = TAILQ_NEXT(pskip, next); 182 if (pskip != NULL) 183 TAILQ_INSERT_BEFORE(pskip, pe, next); 184 else 185 TAILQ_INSERT_TAIL(pathq, pe, next); 186 added++; 187 } 188 changed = 1; 189 } 190 191 /* Remove a path component from the module search path */ 192 static void 193 rempath(struct pathhead *pathq, char *path, int force, int insert __unused) 194 { 195 char pathbuf[MAXPATHLEN+1]; 196 struct pathentry *pe; 197 size_t len; 198 199 /* same logic as in addpath() */ 200 if (realpath(path, pathbuf) == NULL) 201 strlcpy(pathbuf, path, sizeof(pathbuf)); 202 203 len = strlen(pathbuf); 204 /* remove a terminating slash if present */ 205 if ((len > 0) && (pathbuf[len-1] == '/')) 206 pathbuf[--len] = '\0'; 207 208 /* Is it in there? */ 209 TAILQ_FOREACH(pe, pathq, next) 210 if (!strcmp(pe->path, pathbuf)) 211 break; 212 if (pe == NULL) { 213 if (force) 214 return; 215 errx(1, "not in module search path: %s", pathbuf); 216 } 217 218 /* OK, remove it now.. */ 219 TAILQ_REMOVE(pathq, pe, next); 220 changed = 1; 221 } 222 223 /* Display the retrieved module search path */ 224 static void 225 showpath(struct pathhead *pathq) 226 { 227 char *s; 228 229 if ((s = qstring(pathq)) == NULL) { 230 errno = ENOMEM; 231 err(1, "building path string"); 232 } 233 printf("%s\n", s); 234 free(s); 235 } 236 237 /* Break a string down into path components, store them into a queue */ 238 static void 239 parsepath(struct pathhead *pathq, char *path, int uniq) 240 { 241 char *p; 242 struct pathentry *pe; 243 244 while ((p = strsep(&path, ";")) != NULL) 245 if (!uniq) { 246 if (((pe = malloc(sizeof(*pe))) == NULL) || 247 ((pe->path = strdup(p)) == NULL)) { 248 errno = ENOMEM; 249 err(1, "allocating path element"); 250 } 251 TAILQ_INSERT_TAIL(pathq, pe, next); 252 } else { 253 addpath(pathq, p, 1, 0); 254 } 255 } 256 257 /* Recreate a path string from a components queue */ 258 static char * 259 qstring(struct pathhead *pathq) 260 { 261 char *s, *p; 262 struct pathentry *pe; 263 264 s = strdup(""); 265 TAILQ_FOREACH(pe, pathq, next) { 266 asprintf(&p, "%s%s%s", 267 s, pe->path, (TAILQ_NEXT(pe, next) != NULL? ";": "")); 268 free(s); 269 if (p == NULL) 270 return (NULL); 271 s = p; 272 } 273 274 return (s); 275 } 276 277 /* Usage message */ 278 static void 279 usage(void) 280 { 281 282 fprintf(stderr, "%s\n%s\n", 283 "usage:\tkldconfig [-dfimnUv] [-S sysctlname] [path ...]", 284 "\tkldconfig -r"); 285 exit(1); 286 } 287 288 /* Main function */ 289 int 290 main(int argc, char *argv[]) 291 { 292 /* getopt() iterator */ 293 int c; 294 /* iterator over argv[] path components */ 295 int i; 296 /* Command-line flags: */ 297 /* "-f" - no diagnostic messages */ 298 int fflag; 299 /* "-i" - insert before the first element */ 300 int iflag; 301 /* "-m" - merge into the existing path, do not replace it */ 302 int mflag; 303 /* "-n" - do not actually set the new module path */ 304 int nflag; 305 /* "-r" - print out the current search path */ 306 int rflag; 307 /* "-U" - remove duplicate values from the path */ 308 int uniqflag; 309 /* "-v" - verbose operation (currently a no-op) */ 310 int vflag; 311 /* The higher-level function to call - add/remove */ 312 void (*act)(struct pathhead *, char *, int, int); 313 /* The original path */ 314 char *origpath; 315 /* The module search path broken down into components */ 316 struct pathhead pathq; 317 318 fflag = iflag = mflag = nflag = rflag = uniqflag = vflag = 0; 319 act = addpath; 320 origpath = NULL; 321 if ((pathctl = strdup(PATHCTL)) == NULL) { 322 /* this is just too paranoid ;) */ 323 errno = ENOMEM; 324 err(1, "initializing sysctl name %s", PATHCTL); 325 } 326 327 /* If no arguments and no options are specified, force '-m' */ 328 if (argc == 1) 329 mflag = 1; 330 331 while ((c = getopt(argc, argv, "dfimnrS:Uv")) != -1) 332 switch (c) { 333 case 'd': 334 if (iflag || mflag) 335 usage(); 336 act = rempath; 337 break; 338 case 'f': 339 fflag = 1; 340 break; 341 case 'i': 342 if (act != addpath) 343 usage(); 344 iflag = 1; 345 break; 346 case 'm': 347 if (act != addpath) 348 usage(); 349 mflag = 1; 350 break; 351 case 'n': 352 nflag = 1; 353 break; 354 case 'r': 355 rflag = 1; 356 break; 357 case 'S': 358 free(pathctl); 359 if ((pathctl = strdup(optarg)) == NULL) { 360 errno = ENOMEM; 361 err(1, "sysctl name %s", optarg); 362 } 363 break; 364 case 'U': 365 uniqflag = 1; 366 break; 367 case 'v': 368 vflag++; 369 break; 370 default: 371 usage(); 372 } 373 374 argc -= optind; 375 argv += optind; 376 377 /* The '-r' flag cannot be used when paths are also specified */ 378 if (rflag && (argc > 0)) 379 usage(); 380 381 TAILQ_INIT(&pathq); 382 383 /* Retrieve and store the path from the sysctl value */ 384 getpath(); 385 if ((origpath = strdup(modpath)) == NULL) { 386 errno = ENOMEM; 387 err(1, "saving the original search path"); 388 } 389 390 /* 391 * Break down the path into the components queue if: 392 * - we are NOT adding paths, OR 393 * - the 'merge' flag is specified, OR 394 * - the 'print only' flag is specified, OR 395 * - the 'unique' flag is specified. 396 */ 397 if ((act != addpath) || mflag || rflag || uniqflag) 398 parsepath(&pathq, modpath, uniqflag); 399 else if (modpath[0] != '\0') 400 changed = 1; 401 402 /* Process the path arguments */ 403 for (i = 0; i < argc; i++) 404 act(&pathq, argv[i], fflag, iflag); 405 406 if (changed && !nflag) 407 setpath(&pathq); 408 409 if (rflag || (changed && vflag)) { 410 if (changed && (vflag > 1)) 411 printf("%s -> ", origpath); 412 showpath(&pathq); 413 } 414 415 return (0); 416 } 417