Add a PAM config for kde.
[dragonfly.git] / sbin / jscan / subs.c
1 /*
2  * Copyright (c) 2004,2005 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
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  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sbin/jscan/subs.c,v 1.8 2005/09/07 19:10:09 dillon Exp $
35  */
36
37 #include "jscan.h"
38
39 void
40 jf_warn(struct jfile *jf, const char *ctl, ...)
41 {
42     va_list va;
43
44     fprintf(stderr, "@0x%016llx ", jf->jf_pos);
45     va_start(va, ctl);
46     vfprintf(stderr, ctl, va);
47     va_end(va);
48     fprintf(stderr, "\n");
49 }
50
51 const char *
52 type_to_name(int16_t rectype)
53 {
54     const char *str;
55
56     switch((u_int16_t)rectype & ~JMASK_LAST) {
57     case JLEAF_PAD:
58         str = "PAD";
59         break;
60     case JLEAF_ABORT:
61         str = "ABORT";
62         break;
63     case JTYPE_ASSOCIATE:
64         str = "ASSOCIATE";
65         break;
66     case JTYPE_DISASSOCIATE:
67         str = "DISASSOCIATE";
68         break;
69     case JTYPE_UNDO:
70         str = "UNDO";
71         break;
72     case JTYPE_REDO:
73         str = "REDO";
74         break;
75     case JTYPE_AUDIT:
76         str = "AUDIT";
77         break;
78     case JTYPE_SETATTR:
79         str = "SETATTR";
80         break;
81     case JTYPE_WRITE:
82         str = "WRITE";
83         break;
84     case JTYPE_PUTPAGES:
85         str = "PUTPAGES";
86         break;
87     case JTYPE_SETACL:
88         str = "SETACL";
89         break;
90     case JTYPE_SETEXTATTR:
91         str = "SETEXTATTR";
92         break;
93     case JTYPE_CREATE:
94         str = "CREATE";
95         break;
96     case JTYPE_MKNOD:
97         str = "MKNOD";
98         break;
99     case JTYPE_LINK:
100         str = "LINK";
101         break;
102     case JTYPE_SYMLINK:
103         str = "SYMLINK";
104         break;
105     case JTYPE_WHITEOUT:
106         str = "WHITEOUT";
107         break;
108     case JTYPE_REMOVE:
109         str = "REMOVE";
110         break;
111     case JTYPE_MKDIR:
112         str = "MKDIR";
113         break;
114     case JTYPE_RMDIR:
115         str = "RMDIR";
116         break;
117     case JTYPE_RENAME:
118         str = "RENAME";
119         break;
120     case JTYPE_VATTR:
121         str = "vattr";
122         break;
123     case JTYPE_CRED:
124         str = "cred";
125         break;
126     case JLEAF_FILEDATA:
127         str = "filedata";
128         break;
129     case JLEAF_PATH1:
130         str = "path1";
131         break;
132     case JLEAF_PATH2:
133         str = "path2";
134         break;
135     case JLEAF_PATH3:
136         str = "path3";
137         break;
138     case JLEAF_PATH4:
139         str = "path4";
140         break;
141     case JLEAF_UID:
142         str = "uid";
143         break;
144     case JLEAF_GID:
145         str = "gid";
146         break;
147     case JLEAF_VTYPE:
148         str = "vtype";
149         break;
150     case JLEAF_MODES:
151         str = "modes";
152         break;
153     case JLEAF_FFLAGS:
154         str = "fflags";
155         break;
156     case JLEAF_PID:
157         str = "pid";
158         break;
159     case JLEAF_PPID:
160         str = "ppid";
161         break;
162     case JLEAF_COMM:
163         str = "comm";
164         break;
165     case JLEAF_ATTRNAME:
166         str = "attrname";
167         break;
168     case JLEAF_PATH_REF:
169         str = "path_ref";
170         break;
171     case JLEAF_RESERVED_0F:
172         str = "?";
173         break;
174     case JLEAF_SYMLINKDATA:
175         str = "symlinkdata";
176         break;
177     case JLEAF_SEEKPOS:
178         str = "seekpos";
179         break;
180     case JLEAF_INUM:
181         str = "inum";
182         break;
183     case JLEAF_NLINK:
184         str = "nlink";
185         break;
186     case JLEAF_FSID:
187         str = "fsid";
188         break;
189     case JLEAF_SIZE:
190         str = "size";
191         break;
192     case JLEAF_ATIME:
193         str = "atime";
194         break;
195     case JLEAF_MTIME:
196         str = "mtime";
197         break;
198     case JLEAF_CTIME:
199         str = "ctime";
200         break;
201     case JLEAF_GEN:
202         str = "gen";
203         break;
204     case JLEAF_FLAGS:
205         str = "flags";
206         break;
207     case JLEAF_UDEV:
208         str = "udev";
209         break;
210     case JLEAF_FILEREV:
211         str = "filerev";
212         break;
213     default:
214         str = "?";
215         break;
216     }
217     return (str);
218 }
219
220 void
221 stringout(FILE *fp, char c, int exact)
222 {
223     if ((c >= 'a' && c <= 'z') ||
224         (c >= 'A' && c <= 'Z') ||
225         (c >= '0' && c <= '9')
226     ) {
227         putc(c, fp);
228     } else if (isprint((unsigned char)c) && c != '\\' && c != '\"') {
229         putc(c, fp);
230     } else if (exact == 0) {
231         putc('.', fp);
232     } else if (c == 0) {
233         fprintf(fp, "\\0");
234     } else if (c == '\n') {
235         fprintf(fp, "\\n");
236     } else {
237         fprintf(fp, "\\x%02x", (int)(unsigned char)c);
238     }
239 }
240
241 void
242 jattr_reset(struct jattr *jattr)
243 {
244     struct jattr *undo;
245     struct jattr_data *data;
246
247     if (jattr->path1)
248         free(jattr->path1);
249     if (jattr->path2)
250         free(jattr->path2);
251     if (jattr->path3)
252         free(jattr->path3);
253     if (jattr->path4)
254         free(jattr->path4);
255     if (jattr->comm)
256         free(jattr->comm);
257     if (jattr->attrname)
258         free(jattr->attrname);
259     if (jattr->pathref)
260         free(jattr->pathref);
261     if (jattr->symlinkdata)
262         free(jattr->symlinkdata);
263     while ((data = jattr->data.next) != NULL) {
264         jattr->data.next = data->next;
265         free(data);
266     }
267     if ((undo = jattr->undo) != NULL)
268         jattr_reset(jattr->undo);
269     bzero(jattr, sizeof(*jattr));
270     jattr->undo = undo;
271     jattr->uid = (uid_t)-1;
272     jattr->gid = (gid_t)-1;
273     jattr->size = (off_t)-1;
274     jattr->modes = -1;
275     jattr->flags = -1;
276     jattr->seekpos = -1;
277 }
278
279 int64_t
280 buf_to_int64(const void *buf, int bytes)
281 {
282     int64_t v;
283
284     switch(bytes) {
285     case 1:
286         v = (int64_t)*(const u_int8_t *)buf;
287         break;
288     case 2:
289         v = (int64_t)*(const u_int16_t *)buf;
290         break;
291     case 4:
292         v = (int64_t)*(const u_int32_t *)buf;
293         break;
294     case 8:
295         v = *(const int64_t *)buf;
296         break;
297     default:
298         v = 0;
299     }
300     return(v);
301 }
302
303 void *
304 dupdata(const void *buf, int bytes)
305 {
306     void *res;
307
308     res = malloc(bytes);
309     bcopy(buf, res, bytes);
310
311     return(res);
312 }
313
314 char *
315 dupdatastr(const void *buf, int bytes)
316 {
317     char *res;
318
319     res = malloc(bytes + 1);
320     bcopy(buf, res, bytes);
321     res[bytes] = 0;
322
323     return(res);
324 }
325
326 /*
327  * Similar to dupdatastr() but contains sanity checks.
328  */
329 char *
330 dupdatapath(const void *buf, int bytes)
331 {
332     char *res;
333     char *scan;
334
335     res = malloc(bytes + 1);
336     bcopy(buf, res, bytes);
337     res[bytes] = 0;
338
339     if (res[0] == '/') {
340         fprintf(stderr, "Bad path: %s\n", res);
341         free(res);
342         return(NULL);
343     }
344     scan = res;
345     for (;;) {
346         if (scan[0] == '.' && scan[1] == '.' &&
347             (scan[2] == 0 || scan[2] == '/')
348         ) {
349             fprintf(stderr, "Bad path: %s\n", res);
350             free(res);
351             return(NULL);
352         }
353         if ((scan = strchr(scan, '/')) == NULL)
354             break;
355         ++scan;
356     }
357     return(res);
358 }
359
360 void
361 get_transid_from_file(const char *path, int64_t *transid, int flags)
362 {
363     int n;
364     int fd;
365     char buf[32];
366
367     *transid = 0;
368     if ((fd = open(path, O_RDONLY)) >= 0) {
369         n = read(fd, buf, sizeof(buf) - 1);
370         if (n >= 0)
371             buf[n] = 0;
372         *transid = strtoull(buf, NULL, 16);
373         jmodes |= flags;
374         close(fd);
375     }
376 }
377