sbin/kldconfig/kldconfig.c

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