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