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%016jx ", (uintmax_t)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