The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/usr/gen_init_cpio.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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         unsigned 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),
  396                                 PATH_MAX - strlen(expanded));
  397                         strncat(expanded, end + 1,
  398                                 PATH_MAX - strlen(expanded));
  399                         strncpy(new_location, expanded, PATH_MAX);
  400                         new_location[PATH_MAX] = 0;
  401                 } else
  402                         break;
  403         }
  404 
  405         return new_location;
  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 [-t <timestamp>] <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                 "\n"
  496                 "<timestamp> is time in seconds since Epoch that will be used\n"
  497                 "as mtime for symlinks, special files and directories. The default\n"
  498                 "is to use the current time for these entries.\n",
  499                 prog);
  500 }
  501 
  502 struct file_handler file_handler_table[] = {
  503         {
  504                 .type    = "file",
  505                 .handler = cpio_mkfile_line,
  506         }, {
  507                 .type    = "nod",
  508                 .handler = cpio_mknod_line,
  509         }, {
  510                 .type    = "dir",
  511                 .handler = cpio_mkdir_line,
  512         }, {
  513                 .type    = "slink",
  514                 .handler = cpio_mkslink_line,
  515         }, {
  516                 .type    = "pipe",
  517                 .handler = cpio_mkpipe_line,
  518         }, {
  519                 .type    = "sock",
  520                 .handler = cpio_mksock_line,
  521         }, {
  522                 .type    = NULL,
  523                 .handler = NULL,
  524         }
  525 };
  526 
  527 #define LINE_SIZE (2 * PATH_MAX + 50)
  528 
  529 int main (int argc, char *argv[])
  530 {
  531         FILE *cpio_list;
  532         char line[LINE_SIZE];
  533         char *args, *type;
  534         int ec = 0;
  535         int line_nr = 0;
  536         const char *filename;
  537 
  538         default_mtime = time(NULL);
  539         while (1) {
  540                 int opt = getopt(argc, argv, "t:h");
  541                 char *invalid;
  542 
  543                 if (opt == -1)
  544                         break;
  545                 switch (opt) {
  546                 case 't':
  547                         default_mtime = strtol(optarg, &invalid, 10);
  548                         if (!*optarg || *invalid) {
  549                                 fprintf(stderr, "Invalid timestamp: %s\n",
  550                                                 optarg);
  551                                 usage(argv[0]);
  552                                 exit(1);
  553                         }
  554                         break;
  555                 case 'h':
  556                 case '?':
  557                         usage(argv[0]);
  558                         exit(opt == 'h' ? 0 : 1);
  559                 }
  560         }
  561 
  562         if (argc - optind != 1) {
  563                 usage(argv[0]);
  564                 exit(1);
  565         }
  566         filename = argv[optind];
  567         if (!strcmp(filename, "-"))
  568                 cpio_list = stdin;
  569         else if (!(cpio_list = fopen(filename, "r"))) {
  570                 fprintf(stderr, "ERROR: unable to open '%s': %s\n\n",
  571                         filename, strerror(errno));
  572                 usage(argv[0]);
  573                 exit(1);
  574         }
  575 
  576         while (fgets(line, LINE_SIZE, cpio_list)) {
  577                 int type_idx;
  578                 size_t slen = strlen(line);
  579 
  580                 line_nr++;
  581 
  582                 if ('#' == *line) {
  583                         /* comment - skip to next line */
  584                         continue;
  585                 }
  586 
  587                 if (! (type = strtok(line, " \t"))) {
  588                         fprintf(stderr,
  589                                 "ERROR: incorrect format, could not locate file type line %d: '%s'\n",
  590                                 line_nr, line);
  591                         ec = -1;
  592                         break;
  593                 }
  594 
  595                 if ('\n' == *type) {
  596                         /* a blank line */
  597                         continue;
  598                 }
  599 
  600                 if (slen == strlen(type)) {
  601                         /* must be an empty line */
  602                         continue;
  603                 }
  604 
  605                 if (! (args = strtok(NULL, "\n"))) {
  606                         fprintf(stderr,
  607                                 "ERROR: incorrect format, newline required line %d: '%s'\n",
  608                                 line_nr, line);
  609                         ec = -1;
  610                 }
  611 
  612                 for (type_idx = 0; file_handler_table[type_idx].type; type_idx++) {
  613                         int rc;
  614                         if (! strcmp(line, file_handler_table[type_idx].type)) {
  615                                 if ((rc = file_handler_table[type_idx].handler(args))) {
  616                                         ec = rc;
  617                                         fprintf(stderr, " line %d\n", line_nr);
  618                                 }
  619                                 break;
  620                         }
  621                 }
  622 
  623                 if (NULL == file_handler_table[type_idx].type) {
  624                         fprintf(stderr, "unknown file type line %d: '%s'\n",
  625                                 line_nr, line);
  626                 }
  627         }
  628         if (ec == 0)
  629                 cpio_trailer();
  630 
  631         exit(ec);
  632 }

Cache object: 784aa873f8f8730ab007b3cef6b84c6a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.