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