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.6 2005/07/06 06:21:05 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_AUDIT: 73 str = "AUDIT"; 74 break; 75 case JTYPE_SETATTR: 76 str = "SETATTR"; 77 break; 78 case JTYPE_WRITE: 79 str = "WRITE"; 80 break; 81 case JTYPE_PUTPAGES: 82 str = "PUTPAGES"; 83 break; 84 case JTYPE_SETACL: 85 str = "SETACL"; 86 break; 87 case JTYPE_SETEXTATTR: 88 str = "SETEXTATTR"; 89 break; 90 case JTYPE_CREATE: 91 str = "CREATE"; 92 break; 93 case JTYPE_MKNOD: 94 str = "MKNOD"; 95 break; 96 case JTYPE_LINK: 97 str = "LINK"; 98 break; 99 case JTYPE_SYMLINK: 100 str = "SYMLINK"; 101 break; 102 case JTYPE_WHITEOUT: 103 str = "WHITEOUT"; 104 break; 105 case JTYPE_REMOVE: 106 str = "REMOVE"; 107 break; 108 case JTYPE_MKDIR: 109 str = "MKDIR"; 110 break; 111 case JTYPE_RMDIR: 112 str = "RMDIR"; 113 break; 114 case JTYPE_RENAME: 115 str = "RENAME"; 116 break; 117 case JTYPE_VATTR: 118 str = "vattr"; 119 break; 120 case JTYPE_CRED: 121 str = "cred"; 122 break; 123 case JLEAF_FILEDATA: 124 str = "filedata"; 125 break; 126 case JLEAF_PATH1: 127 str = "path1"; 128 break; 129 case JLEAF_PATH2: 130 str = "path2"; 131 break; 132 case JLEAF_PATH3: 133 str = "path3"; 134 break; 135 case JLEAF_PATH4: 136 str = "path4"; 137 break; 138 case JLEAF_UID: 139 str = "uid"; 140 break; 141 case JLEAF_GID: 142 str = "gid"; 143 break; 144 case JLEAF_VTYPE: 145 str = "vtype"; 146 break; 147 case JLEAF_MODES: 148 str = "modes"; 149 break; 150 case JLEAF_FFLAGS: 151 str = "fflags"; 152 break; 153 case JLEAF_PID: 154 str = "pid"; 155 break; 156 case JLEAF_PPID: 157 str = "ppid"; 158 break; 159 case JLEAF_COMM: 160 str = "comm"; 161 break; 162 case JLEAF_ATTRNAME: 163 str = "attrname"; 164 break; 165 case JLEAF_PATH_REF: 166 str = "path_ref"; 167 break; 168 case JLEAF_RESERVED_0F: 169 str = "?"; 170 break; 171 case JLEAF_SYMLINKDATA: 172 str = "symlinkdata"; 173 break; 174 case JLEAF_SEEKPOS: 175 str = "seekpos"; 176 break; 177 case JLEAF_INUM: 178 str = "inum"; 179 break; 180 case JLEAF_NLINK: 181 str = "nlink"; 182 break; 183 case JLEAF_FSID: 184 str = "fsid"; 185 break; 186 case JLEAF_SIZE: 187 str = "size"; 188 break; 189 case JLEAF_ATIME: 190 str = "atime"; 191 break; 192 case JLEAF_MTIME: 193 str = "mtime"; 194 break; 195 case JLEAF_CTIME: 196 str = "ctime"; 197 break; 198 case JLEAF_GEN: 199 str = "gen"; 200 break; 201 case JLEAF_FLAGS: 202 str = "flags"; 203 break; 204 case JLEAF_UDEV: 205 str = "udev"; 206 break; 207 case JLEAF_FILEREV: 208 str = "filerev"; 209 break; 210 default: 211 str = "?"; 212 break; 213 } 214 return (str); 215 } 216 217 void 218 stringout(FILE *fp, char c, int exact) 219 { 220 if ((c >= 'a' && c <= 'z') || 221 (c >= 'A' && c <= 'Z') || 222 (c >= '0' && c <= '9') 223 ) { 224 putc(c, fp); 225 } else if (isprint((unsigned char)c) && c != '\\' && c != '\"') { 226 putc(c, fp); 227 } else if (exact == 0) { 228 putc('.', fp); 229 } else if (c == 0) { 230 fprintf(fp, "\\0"); 231 } else if (c == '\n') { 232 fprintf(fp, "\\n"); 233 } else { 234 fprintf(fp, "\\x%02x", (int)(unsigned char)c); 235 } 236 } 237 238 void 239 jattr_reset(struct jattr *jattr) 240 { 241 struct jattr *undo; 242 struct jattr_data *data; 243 244 if (jattr->path1) 245 free(jattr->path1); 246 if (jattr->path2) 247 free(jattr->path2); 248 if (jattr->path3) 249 free(jattr->path3); 250 if (jattr->path4) 251 free(jattr->path4); 252 if (jattr->comm) 253 free(jattr->comm); 254 if (jattr->attrname) 255 free(jattr->attrname); 256 if (jattr->pathref) 257 free(jattr->pathref); 258 if (jattr->symlinkdata) 259 free(jattr->symlinkdata); 260 while ((data = jattr->data.next) != NULL) { 261 jattr->data.next = data->next; 262 free(data); 263 } 264 if ((undo = jattr->undo) != NULL) 265 jattr_reset(jattr->undo); 266 bzero(jattr, sizeof(*jattr)); 267 jattr->undo = undo; 268 jattr->uid = (uid_t)-1; 269 jattr->gid = (gid_t)-1; 270 jattr->size = (off_t)-1; 271 jattr->modes = -1; 272 jattr->flags = -1; 273 jattr->seekpos = -1; 274 } 275 276 int64_t 277 buf_to_int64(const void *buf, int bytes) 278 { 279 int64_t v; 280 281 switch(bytes) { 282 case 1: 283 v = (int64_t)*(const u_int8_t *)buf; 284 break; 285 case 2: 286 v = (int64_t)*(const u_int16_t *)buf; 287 break; 288 case 4: 289 v = (int64_t)*(const u_int32_t *)buf; 290 break; 291 case 8: 292 v = *(const int64_t *)buf; 293 break; 294 default: 295 v = 0; 296 } 297 return(v); 298 } 299 300 void * 301 dupdata(const void *buf, int bytes) 302 { 303 void *res; 304 305 res = malloc(bytes); 306 bcopy(buf, res, bytes); 307 308 return(res); 309 } 310 311 char * 312 dupdatastr(const void *buf, int bytes) 313 { 314 char *res; 315 316 res = malloc(bytes + 1); 317 bcopy(buf, res, bytes); 318 res[bytes] = 0; 319 320 return(res); 321 } 322 323 /* 324 * Similar to dupdatastr() but contains sanity checks. 325 */ 326 char * 327 dupdatapath(const void *buf, int bytes) 328 { 329 char *res; 330 char *scan; 331 332 res = malloc(bytes + 1); 333 bcopy(buf, res, bytes); 334 res[bytes] = 0; 335 336 if (res[0] == '/') { 337 fprintf(stderr, "Bad path: %s\n", res); 338 free(res); 339 return(NULL); 340 } 341 scan = res; 342 for (;;) { 343 if (scan[0] == '.' && scan[1] == '.' && 344 (scan[2] == 0 || scan[2] == '/') 345 ) { 346 fprintf(stderr, "Bad path: %s\n", res); 347 free(res); 348 return(NULL); 349 } 350 if ((scan = strchr(scan, '/')) == NULL) 351 break; 352 ++scan; 353 } 354 return(res); 355 } 356 357