1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <sys/types.h> 4 #include <sys/stat.h> 5 #include <string.h> 6 #include <unistd.h> 7 #include <time.h> 8 #include <fcntl.h> 9 #include <errno.h> 10 #include <ctype.h> 11 #include <limits.h> 12 13 /* 14 * Original work by Jeff Garzik 15 * 16 * External file lists, symlink, pipe and fifo support by Thayne Harbaugh 17 * Hard link support by Luciano Rocha 18 */ 19 20 #define xstr(s) #s 21 #define str(s) xstr(s) 22 23 static unsigned int offset; 24 static unsigned int ino = 721; 25 static time_t default_mtime; 26 27 struct file_handler { 28 const char *type; 29 int (*handler)(const char *line); 30 }; 31 32 static void push_string(const char *name) 33 { 34 unsigned int name_len = strlen(name) + 1; 35 36 fputs(name, stdout); 37 putchar(0); 38 offset += name_len; 39 } 40 41 static void push_pad (void) 42 { 43 while (offset & 3) { 44 putchar(0); 45 offset++; 46 } 47 } 48 49 static void push_rest(const char *name) 50 { 51 unsigned int name_len = strlen(name) + 1; 52 unsigned int tmp_ofs; 53 54 fputs(name, stdout); 55 putchar(0); 56 offset += name_len; 57 58 tmp_ofs = name_len + 110; 59 while (tmp_ofs & 3) { 60 putchar(0); 61 offset++; 62 tmp_ofs++; 63 } 64 } 65 66 static void push_hdr(const char *s) 67 { 68 fputs(s, stdout); 69 offset += 110; 70 } 71 72 static void cpio_trailer(void) 73 { 74 char s[256]; 75 const char name[] = "TRAILER!!!"; 76 77 sprintf(s, "%s%08X%08X%08lX%08lX%08X%08lX" 78 "%08X%08X%08X%08X%08X%08X%08X", 79 "070701", /* magic */ 80 0, /* ino */ 81 0, /* mode */ 82 (long) 0, /* uid */ 83 (long) 0, /* gid */ 84 1, /* nlink */ 85 (long) 0, /* mtime */ 86 0, /* filesize */ 87 0, /* major */ 88 0, /* minor */ 89 0, /* rmajor */ 90 0, /* rminor */ 91 (unsigned)strlen(name)+1, /* namesize */ 92 0); /* chksum */ 93 push_hdr(s); 94 push_rest(name); 95 96 while (offset % 512) { 97 putchar(0); 98 offset++; 99 } 100 } 101 102 static int cpio_mkslink(const char *name, const char *target, 103 unsigned int mode, uid_t uid, gid_t gid) 104 { 105 char s[256]; 106 107 if (name[0] == '/') 108 name++; 109 sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX" 110 "%08X%08X%08X%08X%08X%08X%08X", 111 "070701", /* magic */ 112 ino++, /* ino */ 113 S_IFLNK | mode, /* mode */ 114 (long) uid, /* uid */ 115 (long) gid, /* gid */ 116 1, /* nlink */ 117 (long) default_mtime, /* mtime */ 118 (unsigned)strlen(target)+1, /* filesize */ 119 3, /* major */ 120 1, /* minor */ 121 0, /* rmajor */ 122 0, /* rminor */ 123 (unsigned)strlen(name) + 1,/* namesize */ 124 0); /* chksum */ 125 push_hdr(s); 126 push_string(name); 127 push_pad(); 128 push_string(target); 129 push_pad(); 130 return 0; 131 } 132 133 static int cpio_mkslink_line(const char *line) 134 { 135 char name[PATH_MAX + 1]; 136 char target[PATH_MAX + 1]; 137 unsigned int mode; 138 int uid; 139 int gid; 140 int rc = -1; 141 142 if (5 != sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX) "s %o %d %d", name, target, &mode, &uid, &gid)) { 143 fprintf(stderr, "Unrecognized dir format '%s'", line); 144 goto fail; 145 } 146 rc = cpio_mkslink(name, target, mode, uid, gid); 147 fail: 148 return rc; 149 } 150 151 static int cpio_mkgeneric(const char *name, unsigned int mode, 152 uid_t uid, gid_t gid) 153 { 154 char s[256]; 155 156 if (name[0] == '/') 157 name++; 158 sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX" 159 "%08X%08X%08X%08X%08X%08X%08X", 160 "070701", /* magic */ 161 ino++, /* ino */ 162 mode, /* mode */ 163 (long) uid, /* uid */ 164 (long) gid, /* gid */ 165 2, /* nlink */ 166 (long) default_mtime, /* mtime */ 167 0, /* filesize */ 168 3, /* major */ 169 1, /* minor */ 170 0, /* rmajor */ 171 0, /* rminor */ 172 (unsigned)strlen(name) + 1,/* namesize */ 173 0); /* chksum */ 174 push_hdr(s); 175 push_rest(name); 176 return 0; 177 } 178 179 enum generic_types { 180 GT_DIR, 181 GT_PIPE, 182 GT_SOCK 183 }; 184 185 struct generic_type { 186 const char *type; 187 mode_t mode; 188 }; 189 190 static struct generic_type generic_type_table[] = { 191 [GT_DIR] = { 192 .type = "dir", 193 .mode = S_IFDIR 194 }, 195 [GT_PIPE] = { 196 .type = "pipe", 197 .mode = S_IFIFO 198 }, 199 [GT_SOCK] = { 200 .type = "sock", 201 .mode = S_IFSOCK 202 } 203 }; 204 205 static int cpio_mkgeneric_line(const char *line, enum generic_types gt) 206 { 207 char name[PATH_MAX + 1]; 208 unsigned int mode; 209 int uid; 210 int gid; 211 int rc = -1; 212 213 if (4 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d", name, &mode, &uid, &gid)) { 214 fprintf(stderr, "Unrecognized %s format '%s'", 215 line, generic_type_table[gt].type); 216 goto fail; 217 } 218 mode |= generic_type_table[gt].mode; 219 rc = cpio_mkgeneric(name, mode, uid, gid); 220 fail: 221 return rc; 222 } 223 224 static int cpio_mkdir_line(const char *line) 225 { 226 return cpio_mkgeneric_line(line, GT_DIR); 227 } 228 229 static int cpio_mkpipe_line(const char *line) 230 { 231 return cpio_mkgeneric_line(line, GT_PIPE); 232 } 233 234 static int cpio_mksock_line(const char *line) 235 { 236 return cpio_mkgeneric_line(line, GT_SOCK); 237 } 238 239 static int cpio_mknod(const char *name, unsigned int mode, 240 uid_t uid, gid_t gid, char dev_type, 241 unsigned int maj, unsigned int min) 242 { 243 char s[256]; 244 245 if (dev_type == 'b') 246 mode |= S_IFBLK; 247 else 248 mode |= S_IFCHR; 249 250 if (name[0] == '/') 251 name++; 252 sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX" 253 "%08X%08X%08X%08X%08X%08X%08X", 254 "070701", /* magic */ 255 ino++, /* ino */ 256 mode, /* mode */ 257 (long) uid, /* uid */ 258 (long) gid, /* gid */ 259 1, /* nlink */ 260 (long) default_mtime, /* mtime */ 261 0, /* filesize */ 262 3, /* major */ 263 1, /* minor */ 264 maj, /* rmajor */ 265 min, /* rminor */ 266 (unsigned)strlen(name) + 1,/* namesize */ 267 0); /* chksum */ 268 push_hdr(s); 269 push_rest(name); 270 return 0; 271 } 272 273 static int cpio_mknod_line(const char *line) 274 { 275 char name[PATH_MAX + 1]; 276 unsigned int mode; 277 int uid; 278 int gid; 279 char dev_type; 280 unsigned int maj; 281 unsigned int min; 282 int rc = -1; 283 284 if (7 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d %c %u %u", 285 name, &mode, &uid, &gid, &dev_type, &maj, &min)) { 286 fprintf(stderr, "Unrecognized nod format '%s'", line); 287 goto fail; 288 } 289 rc = cpio_mknod(name, mode, uid, gid, dev_type, maj, min); 290 fail: 291 return rc; 292 } 293 294 static int cpio_mkfile(const char *name, const char *location, 295 unsigned int mode, uid_t uid, gid_t gid, 296 unsigned int nlinks) 297 { 298 char s[256]; 299 char *filebuf = NULL; 300 struct stat buf; 301 long size; 302 int file = -1; 303 int retval; 304 int rc = -1; 305 int namesize; 306 int i; 307 308 mode |= S_IFREG; 309 310 file = open (location, O_RDONLY); 311 if (file < 0) { 312 fprintf (stderr, "File %s could not be opened for reading\n", location); 313 goto error; 314 } 315 316 retval = fstat(file, &buf); 317 if (retval) { 318 fprintf(stderr, "File %s could not be stat()'ed\n", location); 319 goto error; 320 } 321 322 filebuf = malloc(buf.st_size); 323 if (!filebuf) { 324 fprintf (stderr, "out of memory\n"); 325 goto error; 326 } 327 328 retval = read (file, filebuf, buf.st_size); 329 if (retval < 0) { 330 fprintf (stderr, "Can not read %s file\n", location); 331 goto error; 332 } 333 334 size = 0; 335 for (i = 1; i <= nlinks; i++) { 336 /* data goes on last link */ 337 if (i == nlinks) size = buf.st_size; 338 339 if (name[0] == '/') 340 name++; 341 namesize = strlen(name) + 1; 342 sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX" 343 "%08lX%08X%08X%08X%08X%08X%08X", 344 "070701", /* magic */ 345 ino, /* ino */ 346 mode, /* mode */ 347 (long) uid, /* uid */ 348 (long) gid, /* gid */ 349 nlinks, /* nlink */ 350 (long) buf.st_mtime, /* mtime */ 351 size, /* filesize */ 352 3, /* major */ 353 1, /* minor */ 354 0, /* rmajor */ 355 0, /* rminor */ 356 namesize, /* namesize */ 357 0); /* chksum */ 358 push_hdr(s); 359 push_string(name); 360 push_pad(); 361 362 if (size) { 363 if (fwrite(filebuf, size, 1, stdout) != 1) { 364 fprintf(stderr, "writing filebuf failed\n"); 365 goto error; 366 } 367 offset += size; 368 push_pad(); 369 } 370 371 name += namesize; 372 } 373 ino++; 374 rc = 0; 375 376 error: 377 if (filebuf) free(filebuf); 378 if (file >= 0) close(file); 379 return rc; 380 } 381 382 static char *cpio_replace_env(char *new_location) 383 { 384 char expanded[PATH_MAX + 1]; 385 char env_var[PATH_MAX + 1]; 386 char *start; 387 char *end; 388 389 for (start = NULL; (start = strstr(new_location, "${")); ) { 390 end = strchr(start, '}'); 391 if (start < end) { 392 *env_var = *expanded = '\0'; 393 strncat(env_var, start + 2, end - start - 2); 394 strncat(expanded, new_location, start - new_location); 395 strncat(expanded, getenv(env_var), PATH_MAX); 396 strncat(expanded, end + 1, PATH_MAX); 397 strncpy(new_location, expanded, PATH_MAX); 398 } else 399 break; 400 } 401 402 return new_location; 403 } 404 405 406 static int cpio_mkfile_line(const char *line) 407 { 408 char name[PATH_MAX + 1]; 409 char *dname = NULL; /* malloc'ed buffer for hard links */ 410 char location[PATH_MAX + 1]; 411 unsigned int mode; 412 int uid; 413 int gid; 414 int nlinks = 1; 415 int end = 0, dname_len = 0; 416 int rc = -1; 417 418 if (5 > sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX) 419 "s %o %d %d %n", 420 name, location, &mode, &uid, &gid, &end)) { 421 fprintf(stderr, "Unrecognized file format '%s'", line); 422 goto fail; 423 } 424 if (end && isgraph(line[end])) { 425 int len; 426 int nend; 427 428 dname = malloc(strlen(line)); 429 if (!dname) { 430 fprintf (stderr, "out of memory (%d)\n", dname_len); 431 goto fail; 432 } 433 434 dname_len = strlen(name) + 1; 435 memcpy(dname, name, dname_len); 436 437 do { 438 nend = 0; 439 if (sscanf(line + end, "%" str(PATH_MAX) "s %n", 440 name, &nend) < 1) 441 break; 442 len = strlen(name) + 1; 443 memcpy(dname + dname_len, name, len); 444 dname_len += len; 445 nlinks++; 446 end += nend; 447 } while (isgraph(line[end])); 448 } else { 449 dname = name; 450 } 451 rc = cpio_mkfile(dname, cpio_replace_env(location), 452 mode, uid, gid, nlinks); 453 fail: 454 if (dname_len) free(dname); 455 return rc; 456 } 457 458 static void usage(const char *prog) 459 { 460 fprintf(stderr, "Usage:\n" 461 "\t%s [-t <timestamp>] <cpio_list>\n" 462 "\n" 463 "<cpio_list> is a file containing newline separated entries that\n" 464 "describe the files to be included in the initramfs archive:\n" 465 "\n" 466 "# a comment\n" 467 "file <name> <location> <mode> <uid> <gid> [<hard links>]\n" 468 "dir <name> <mode> <uid> <gid>\n" 469 "nod <name> <mode> <uid> <gid> <dev_type> <maj> <min>\n" 470 "slink <name> <target> <mode> <uid> <gid>\n" 471 "pipe <name> <mode> <uid> <gid>\n" 472 "sock <name> <mode> <uid> <gid>\n" 473 "\n" 474 "<name> name of the file/dir/nod/etc in the archive\n" 475 "<location> location of the file in the current filesystem\n" 476 " expands shell variables quoted with ${}\n" 477 "<target> link target\n" 478 "<mode> mode/permissions of the file\n" 479 "<uid> user id (0=root)\n" 480 "<gid> group id (0=root)\n" 481 "<dev_type> device type (b=block, c=character)\n" 482 "<maj> major number of nod\n" 483 "<min> minor number of nod\n" 484 "<hard links> space separated list of other links to file\n" 485 "\n" 486 "example:\n" 487 "# A simple initramfs\n" 488 "dir /dev 0755 0 0\n" 489 "nod /dev/console 0600 0 0 c 5 1\n" 490 "dir /root 0700 0 0\n" 491 "dir /sbin 0755 0 0\n" 492 "file /sbin/kinit /usr/src/klibc/kinit/kinit 0755 0 0\n" 493 "\n" 494 "<timestamp> is time in seconds since Epoch that will be used\n" 495 "as mtime for symlinks, special files and directories. The default\n" 496 "is to use the current time for these entries.\n", 497 prog); 498 } 499 500 struct file_handler file_handler_table[] = { 501 { 502 .type = "file", 503 .handler = cpio_mkfile_line, 504 }, { 505 .type = "nod", 506 .handler = cpio_mknod_line, 507 }, { 508 .type = "dir", 509 .handler = cpio_mkdir_line, 510 }, { 511 .type = "slink", 512 .handler = cpio_mkslink_line, 513 }, { 514 .type = "pipe", 515 .handler = cpio_mkpipe_line, 516 }, { 517 .type = "sock", 518 .handler = cpio_mksock_line, 519 }, { 520 .type = NULL, 521 .handler = NULL, 522 } 523 }; 524 525 #define LINE_SIZE (2 * PATH_MAX + 50) 526 527 int main (int argc, char *argv[]) 528 { 529 FILE *cpio_list; 530 char line[LINE_SIZE]; 531 char *args, *type; 532 int ec = 0; 533 int line_nr = 0; 534 const char *filename; 535 536 default_mtime = time(NULL); 537 while (1) { 538 int opt = getopt(argc, argv, "t:h"); 539 char *invalid; 540 541 if (opt == -1) 542 break; 543 switch (opt) { 544 case 't': 545 default_mtime = strtol(optarg, &invalid, 10); 546 if (!*optarg || *invalid) { 547 fprintf(stderr, "Invalid timestamp: %s\n", 548 optarg); 549 usage(argv[0]); 550 exit(1); 551 } 552 break; 553 case 'h': 554 case '?': 555 usage(argv[0]); 556 exit(opt == 'h' ? 0 : 1); 557 } 558 } 559 560 if (argc - optind != 1) { 561 usage(argv[0]); 562 exit(1); 563 } 564 filename = argv[optind]; 565 if (!strcmp(filename, "-")) 566 cpio_list = stdin; 567 else if (!(cpio_list = fopen(filename, "r"))) { 568 fprintf(stderr, "ERROR: unable to open '%s': %s\n\n", 569 filename, strerror(errno)); 570 usage(argv[0]); 571 exit(1); 572 } 573 574 while (fgets(line, LINE_SIZE, cpio_list)) { 575 int type_idx; 576 size_t slen = strlen(line); 577 578 line_nr++; 579 580 if ('#' == *line) { 581 /* comment - skip to next line */ 582 continue; 583 } 584 585 if (! (type = strtok(line, " \t"))) { 586 fprintf(stderr, 587 "ERROR: incorrect format, could not locate file type line %d: '%s'\n", 588 line_nr, line); 589 ec = -1; 590 break; 591 } 592 593 if ('\n' == *type) { 594 /* a blank line */ 595 continue; 596 } 597 598 if (slen == strlen(type)) { 599 /* must be an empty line */ 600 continue; 601 } 602 603 if (! (args = strtok(NULL, "\n"))) { 604 fprintf(stderr, 605 "ERROR: incorrect format, newline required line %d: '%s'\n", 606 line_nr, line); 607 ec = -1; 608 } 609 610 for (type_idx = 0; file_handler_table[type_idx].type; type_idx++) { 611 int rc; 612 if (! strcmp(line, file_handler_table[type_idx].type)) { 613 if ((rc = file_handler_table[type_idx].handler(args))) { 614 ec = rc; 615 fprintf(stderr, " line %d\n", line_nr); 616 } 617 break; 618 } 619 } 620 621 if (NULL == file_handler_table[type_idx].type) { 622 fprintf(stderr, "unknown file type line %d: '%s'\n", 623 line_nr, line); 624 } 625 } 626 if (ec == 0) 627 cpio_trailer(); 628 629 exit(ec); 630 } 631