Correct sizeof(pointer) bugs that should have been sizeof(*pointer)
[dragonfly.git] / sbin / kldconfig / kldconfig.c
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  * $FreeBSD: src/sbin/kldconfig/kldconfig.c,v 1.3.2.1 2001/08/01 05:52:36 obrien Exp $
27  * $DragonFly: src/sbin/kldconfig/kldconfig.c,v 1.3 2006/01/17 23:49:12 dillon Exp $
28  */
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 #if defined(__FreeBSD_version)
44 #if __FreeBSD_version < 500000
45 #define NEED_SLASHTERM
46 #endif /* < 500000 */
47 #else  /* defined(__FreeBSD_version) */
48 /* just in case.. */
49 #define NEED_SLASHTERM
50 #endif /* defined(__FreeBSD_version) */
51
52 /* the default sysctl name */
53 #define PATHCTL "kern.module_path"
54
55 /* queue structure for the module path broken down into components */
56 TAILQ_HEAD(pathhead, pathentry);
57 struct pathentry {
58         char                    *path;
59         TAILQ_ENTRY(pathentry)  next;
60 };
61
62 /* the Management Information Base entries for the search path sysctl */
63 static int       mib[5];
64 static size_t    miblen;
65 /* the sysctl name, defaults to PATHCTL */
66 static char     *pathctl;
67 /* the sysctl value - the current module search path */
68 static char     *modpath;
69 /* flag whether user actions require changing the sysctl value */
70 static int       changed;
71
72 /* Top-level path management functions */
73 static void      addpath(struct pathhead *, char *, int, int);
74 static void      rempath(struct pathhead *, char *, int, int);
75 static void      showpath(struct pathhead *);
76
77 /* Low-level path management functions */
78 static char     *qstring(struct pathhead *);
79
80 /* sysctl-related functions */
81 static void      getmib(void);
82 static void      getpath(void);
83 static void      parsepath(struct pathhead *, char *, int);
84 static void      setpath(struct pathhead *);
85
86 static void      usage(void);
87
88 /* Get the MIB entry for our sysctl */
89 static void
90 getmib(void)
91 {
92
93         /* have we already fetched it? */
94         if (miblen != 0)
95                 return;
96         
97         miblen = sizeof(mib) / sizeof(mib[0]);
98         if (sysctlnametomib(pathctl, mib, &miblen) != 0)
99                 err(1, "sysctlnametomib(%s)", pathctl);
100 }
101
102 /* Get the current module search path */
103 static void
104 getpath(void)
105 {
106         char *path;
107         size_t sz;
108
109         if (modpath != NULL) {
110                 free(modpath);
111                 modpath = NULL;
112         }
113
114         if (miblen == 0)
115                 getmib();
116         if (sysctl(mib, miblen, NULL, &sz, NULL, NULL) == -1)
117                 err(1, "getting path: sysctl(%s) - size only", pathctl);
118         if ((path = malloc(sz + 1)) == NULL) {
119                 errno = ENOMEM;
120                 err(1, "allocating %lu bytes for the path",
121                     (unsigned long)sz+1);
122         }
123         if (sysctl(mib, miblen, path, &sz, NULL, NULL) == -1)
124                 err(1, "getting path: sysctl(%s)", pathctl);
125         modpath = path;
126 }
127
128 /* Set the module search path after changing it */
129 static void
130 setpath(struct pathhead *pathq)
131 {
132         char *newpath;
133
134         if (miblen == 0)
135                 getmib();
136         if ((newpath = qstring(pathq)) == NULL) {
137                 errno = ENOMEM;
138                 err(1, "building path string");
139         }
140         if (sysctl(mib, miblen, NULL, NULL, newpath, strlen(newpath)+1) == -1)
141                 err(1, "setting path: sysctl(%s)", pathctl);
142
143         if (modpath)
144                 free(modpath);
145         modpath = newpath;
146 }
147
148 /* Add/insert a new component to the module search path */
149 static void
150 addpath(struct pathhead *pathq, char *path, int force, int insert)
151 {
152         struct pathentry *pe, *pskip;
153         char pathbuf[MAXPATHLEN+1];
154         size_t len;
155         static unsigned added = 0;
156         unsigned i;
157
158         /*
159          * If the path exists, use it; otherwise, take the user-specified
160          * path at face value - may be a removed directory.
161          */
162         if (realpath(path, pathbuf) == NULL)
163                 strlcpy(pathbuf, path, sizeof(pathbuf));
164
165         len = strlen(pathbuf);
166 #ifdef NEED_SLASHTERM
167         /* slash-terminate, because the kernel linker said so. */
168         if ((len == 0) || (pathbuf[len-1] != '/')) {
169                 if (len == sizeof(pathbuf) - 1)
170                         errx(1, "path too long: %s", pathbuf);
171                 pathbuf[len] = '/';
172         }
173 #else  /* NEED_SLASHTERM */
174         /* remove a terminating slash if present */
175         if ((len > 0) && (pathbuf[len-1] == '/'))
176                 pathbuf[--len] = '\0';
177 #endif /* NEED_SLASHTERM */
178
179         /* is it already in there? */
180         TAILQ_FOREACH(pe, pathq, next)
181                 if (!strcmp(pe->path, pathbuf))
182                         break;
183         if (pe != NULL) {
184                 if (force)
185                         return;
186                 errx(1, "already in the module search path: %s", pathbuf);
187         }
188         
189         /* OK, allocate and add it. */
190         if (((pe = malloc(sizeof(*pe))) == NULL) ||
191             ((pe->path = strdup(pathbuf)) == NULL)) {
192                 errno = ENOMEM;
193                 err(1, "allocating path component");
194         }
195         if (!insert) {
196                 TAILQ_INSERT_TAIL(pathq, pe, next);
197         } else {
198                 for (i = 0, pskip = TAILQ_FIRST(pathq); i < added; i++)
199                         pskip = TAILQ_NEXT(pskip, next);
200                 if (pskip != NULL)
201                         TAILQ_INSERT_BEFORE(pskip, pe, next);
202                 else
203                         TAILQ_INSERT_TAIL(pathq, pe, next);
204                 added++;
205         }
206         changed = 1;
207 }
208
209 /* Remove a path component from the module search path */
210 static void
211 rempath(struct pathhead *pathq, char *path, int force, int insert __unused)
212 {
213         char pathbuf[MAXPATHLEN+1];
214         struct pathentry *pe;
215         size_t len;
216
217         /* same logic as in addpath() */
218         if (realpath(path, pathbuf) == NULL)
219                 strlcpy(pathbuf, path, sizeof(pathbuf));
220
221         len = strlen(pathbuf);
222 #ifdef NEED_SLASHTERM
223         /* slash-terminate, because the kernel linker said so. */
224         if ((len == 0) || (pathbuf[len-1] != '/')) {
225                 if (len == sizeof(pathbuf) - 1)
226                         errx(1, "path too long: %s", pathbuf);
227                 pathbuf[len] = '/';
228         }
229 #else  /* NEED_SLASHTERM */
230         /* remove a terminating slash if present */
231         if ((len > 0) && (pathbuf[len-1] == '/'))
232                 pathbuf[--len] = '\0';
233 #endif /* NEED_SLASHTERM */
234
235         /* Is it in there? */
236         TAILQ_FOREACH(pe, pathq, next)
237                 if (!strcmp(pe->path, pathbuf))
238                         break;
239         if (pe == NULL) {
240                 if (force)
241                         return;
242                 errx(1, "not in module search path: %s", pathbuf);
243         }
244
245         /* OK, remove it now.. */
246         TAILQ_REMOVE(pathq, pe, next);
247         changed = 1;
248 }
249
250 /* Display the retrieved module search path */
251 static void
252 showpath(struct pathhead *pathq)
253 {
254         char *s;
255
256         if ((s = qstring(pathq)) == NULL) {
257                 errno = ENOMEM;
258                 err(1, "building path string");
259         }
260         printf("%s\n", s);
261         free(s);
262 }
263
264 /* Break a string down into path components, store them into a queue */
265 static void
266 parsepath(struct pathhead *pathq, char *path, int uniq)
267 {
268         char *p;
269         struct pathentry *pe;
270         
271         while ((p = strsep(&path, ";")) != NULL)
272                 if (!uniq) {
273                         if (((pe = malloc(sizeof(*pe))) == NULL) ||
274                             ((pe->path = strdup(p)) == NULL)) {
275                                 errno = ENOMEM;
276                                 err(1, "allocating path element");
277                         }
278                         TAILQ_INSERT_TAIL(pathq, pe, next);
279                 } else {
280                         addpath(pathq, p, 1, 0);
281                 }
282 }
283
284 /* Recreate a path string from a components queue */
285 static char *
286 qstring(struct pathhead *pathq)
287 {
288         char *s, *p;
289         struct pathentry *pe;
290         
291         s = strdup("");
292         TAILQ_FOREACH(pe, pathq, next) {
293                 asprintf(&p, "%s%s%s",
294                     s, pe->path, (TAILQ_NEXT(pe, next) != NULL? ";": ""));
295                 free(s);
296                 if (p == NULL)
297                         return (NULL);
298                 s = p;
299         }
300
301         return (s);
302 }
303
304 /* Usage message */
305 static void
306 usage(void)
307 {
308
309         fprintf(stderr, "%s\n%s\n",
310             "usage:\tkldconfig [-dfimnUv] [-S sysctlname] [path..]",
311             "\tkldconfig -r");
312         exit(1);
313 }
314
315 /* Main function */
316 int
317 main(int argc, char *argv[])
318 {
319         /* getopt() iterator */
320         int c;
321         /* iterator over argv[] path components */
322         int i;
323         /* Command-line flags: */
324         /* "-f" - no diagnostic messages */
325         int fflag;
326         /* "-i" - insert before the first element */
327         int iflag;
328         /* "-m" - merge into the existing path, do not replace it */
329         int mflag;
330         /* "-n" - do not actually set the new module path */
331         int nflag;
332         /* "-r" - print out the current search path */
333         int rflag;
334         /* "-U" - remove duplicate values from the path */
335         int uniqflag;
336         /* "-v" - verbose operation (currently a no-op) */
337         int vflag;
338         /* The higher-level function to call - add/remove */
339         void (*act)(struct pathhead *, char *, int, int);
340         /* The original path */
341         char *origpath;
342         /* The module search path broken down into components */
343         struct pathhead pathq;
344
345         fflag = iflag = mflag = nflag = rflag = uniqflag = vflag = 0;
346         act = addpath;
347         origpath = NULL;
348         if ((pathctl = strdup(PATHCTL)) == NULL) {
349                 /* this is just too paranoid ;) */
350                 errno = ENOMEM;
351                 err(1, "initializing sysctl name %s", PATHCTL);
352         }
353
354         /* If no arguments and no options are specified, force '-m' */
355         if (argc == 1)
356                 mflag = 1;
357
358         while ((c = getopt(argc, argv, "dfimnrS:Uv")) != -1)
359                 switch (c) {
360                         case 'd':
361                                 if (iflag || mflag)
362                                         usage();
363                                 act = rempath;
364                                 break;
365                         case 'f':
366                                 fflag = 1;
367                                 break;
368                         case 'i':
369                                 if (act != addpath)
370                                         usage();
371                                 iflag = 1;
372                                 break;
373                         case 'm':
374                                 if (act != addpath)
375                                         usage();
376                                 mflag = 1;
377                                 break;
378                         case 'n':
379                                 nflag = 1;
380                                 break;
381                         case 'r':
382                                 rflag = 1;
383                                 break;
384                         case 'S':
385                                 free(pathctl);
386                                 if ((pathctl = strdup(optarg)) == NULL) {
387                                         errno = ENOMEM;
388                                         err(1, "sysctl name %s", optarg);
389                                 }
390                                 break;
391                         case 'U':
392                                 uniqflag = 1;
393                                 break;
394                         case 'v':
395                                 vflag++;
396                                 break;
397                         default:
398                                 usage();
399                 }
400
401         argc -= optind;
402         argv += optind;
403
404         /* The '-r' flag cannot be used when paths are also specified */
405         if (rflag && (argc > 0))
406                 usage();
407
408         TAILQ_INIT(&pathq);
409
410         /* Retrieve and store the path from the sysctl value */
411         getpath();
412         if ((origpath = strdup(modpath)) == NULL) {
413                 errno = ENOMEM;
414                 err(1, "saving the original search path");
415         }
416
417         /*
418          * Break down the path into the components queue if:
419          * - we are NOT adding paths, OR
420          * - the 'merge' flag is specified, OR
421          * - the 'print only' flag is specified, OR
422          * - the 'unique' flag is specified.
423          */
424         if ((act != addpath) || mflag || rflag || uniqflag)
425                 parsepath(&pathq, modpath, uniqflag);
426         else if (modpath[0] != '\0')
427                 changed = 1;
428
429         /* Process the path arguments */
430         for (i = 0; i < argc; i++)
431                 act(&pathq, argv[i], fflag, iflag);
432
433         if (changed && !nflag)
434                 setpath(&pathq);
435
436         if (rflag || (changed && vflag)) {
437                 if (changed && (vflag > 1))
438                         printf("%s -> ", origpath);
439                 showpath(&pathq);
440         }
441
442         return (0);
443 }