utils/guest_creator/main.c

   1 #include "ezxml.h"
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <getopt.h>
   5 #include <unistd.h>
   6 #include <string.h>
   7 #include <fcntl.h>
   8 #include <sys/stat.h>
   9 #include <sys/types.h>
  10 #include <sys/ioctl.h>
  11 #include <sys/mman.h>
  12 #include <unistd.h>
  13 #include <errno.h>
  14
  15 #include <v3_ctrl.h>
  16
  17 #define MAX_FILES 256
  18
  19 /*
  20 struct file_info {
  21     int size;
  22     char filename[2048];
  23     char id[256];
  24 };
  25 */
  26
  27 /*
  28
  29    The Palacios cookie encodes "v3vee" followed by a
  30    3 byte version code.   There are currently two versions:
  31
  32     \0\0\0 => original (no checksum)
  33     \0\0\1 => checksum
  34 */
  35
  36 #define COOKIE "v3vee\0\0\0"
  37 #define COOKIE_LEN            8
  38 #define COOKIE_VERSION_OFFSET 5
  39 #define COOKIE_VERSION_LEN    3
  40
  41 int version = 1; // default version is now 1
  42
  43
  44 int num_files = 0;
  45 struct file_info files[MAX_FILES];
  46
  47 #define STDIO_FD 1
  48
  49
  50 int parse_config_input(ezxml_t cfg_input);
  51 int write_output(char * filename, ezxml_t cfg_output);
  52 int copy_file(int file_index, FILE * data_file);
  53
  54 void usage() {
  55     printf("Usage: build_vm <infile> [-v version] [-o outfile]\n");
  56 }
  57
  58 int main(int argc, char ** argv) {
  59     int c;
  60     char * outfile = NULL;
  61     char * infile = NULL;
  62
  63     memset((char *)files, 0, sizeof(files));
  64
  65     opterr = 0;
  66
  67     while ((c = getopt(argc, argv, "ho:v:")) != -1) {
  68         switch (c) {
  69             case 'o':
  70                 outfile = optarg;
  71                 break;
  72             case 'v':
  73                 version = atoi(optarg);
  74                 break;
  75             case 'h':
  76                 usage();
  77                 return 1;
  78             default:
  79                 abort();
  80         }
  81     }
  82
  83     if (optind >= argc) {
  84         usage();
  85         return 1;
  86     }
  87
  88     if (version != 0 && version != 1) {
  89         printf("Only versions 0 and 1 are supported\n");
  90         return 1;
  91     }
  92
  93     infile = argv[optind];
  94
  95
  96     if (outfile == NULL) {
  97         char * endptr = rindex(infile, '.');
  98
  99         outfile = malloc(strlen(infile) + strlen(".dat") + 1);
 100
 101         strncpy(outfile, infile, endptr - infile);
 102
 103         sprintf(outfile, "%s.dat", outfile);
 104     }
 105
 106
 107
 108     printf("Input: [%s] ==>>  Output: [%s]\n", infile, outfile);
 109
 110     ezxml_t cfg_input = ezxml_parse_file(infile);
 111     if (strcmp("", ezxml_error(cfg_input)) != 0) {
 112         printf("%s\n", ezxml_error(cfg_input));
 113         return -1;
 114     }
 115
 116     if (cfg_input == NULL) {
 117         printf("Could not open configuration input file: %s\n", infile);
 118         return 1;
 119     }
 120
 121
 122
 123
 124     // parse input
 125     if (parse_config_input(cfg_input) == -1) {
 126         printf("Error parsing configuration input\n");
 127         return 1;
 128     }
 129
 130     //  printf("xml : %s\n", ezxml_toxml(cfg_input));
 131
 132
 133
 134     // write output
 135
 136
 137
 138     write_output(outfile, cfg_input);
 139
 140
 141     return 0;
 142 }
 143
 144 char * get_val(ezxml_t cfg, char * tag) {
 145     char * attrib = (char *)ezxml_attr(cfg, tag);
 146     ezxml_t txt = ezxml_child(cfg, tag);
 147
 148     if ((txt != NULL) && (attrib != NULL)) {
 149         printf("Invalid Cfg file: Duplicate value for %s (attr=%s, txt=%s)\n",
 150                tag, attrib, ezxml_txt(txt));
 151         exit(-1);
 152     }
 153
 154     return (attrib == NULL) ? ezxml_txt(txt) : attrib;
 155 }
 156
 157
 158
 159 int parse_config_input(ezxml_t cfg_input) {
 160     ezxml_t file_tags = NULL;
 161     ezxml_t tmp_file_tag = NULL;
 162
 163     // files are transformed into blobs that are slapped to the end of the file
 164
 165     file_tags = ezxml_child(cfg_input, "files");
 166
 167     tmp_file_tag = ezxml_child(file_tags, "file");
 168
 169     while (tmp_file_tag) {
 170         char * filename = get_val(tmp_file_tag, "filename");
 171         struct stat file_stats;
 172         char * id = get_val(tmp_file_tag, "id");
 173         char index_buf[256];
 174
 175
 176         if (stat(filename, &file_stats) != 0) {
 177             perror(filename);
 178             exit(-1);
 179         }
 180
 181         files[num_files].size = (unsigned int)file_stats.st_size;
 182         strncpy(files[num_files].id, id, 256);
 183         strncpy(files[num_files].filename, filename, 2048);
 184
 185         snprintf(index_buf, 256, "%d", num_files);
 186         ezxml_set_attr_d(tmp_file_tag, "index", index_buf);
 187
 188         num_files++;
 189         tmp_file_tag = ezxml_next(tmp_file_tag);
 190     }
 191
 192
 193     return 0;
 194 }
 195
 196
 197 static int generate_file_hashes (char * filename,
 198                                  unsigned long long hdr_offset,
 199                                  int num_files) {
 200     unsigned char * file_data;
 201     unsigned char * out_data;
 202     struct mem_file_hdr * hdrs = NULL;
 203     int i, fd, out_fd;
 204     struct stat st;
 205
 206     out_fd = open(filename, O_RDWR);
 207     if (!out_fd) {
 208         fprintf(stderr, "Couldn't open output file %s\n", filename);
 209         return -1;
 210     }
 211     fstat(out_fd, &st);
 212
 213     /* mmap the out file, easy access to file headers */
 214     if ((out_data = mmap(0,
 215                          st.st_size,
 216                          PROT_READ|PROT_WRITE,
 217                          MAP_SHARED,
 218                          out_fd,
 219                          0)) == MAP_FAILED) {
 220         fprintf(stderr, "Error mapping output file (%d)\n", errno);
 221         return -1;
 222     }
 223
 224     hdrs = (struct mem_file_hdr *)(out_data + hdr_offset);
 225
 226     /* mmap each file, then update it's hash */
 227     for (i = 0; i < num_files; i++) {
 228
 229         fd = open(files[i].filename, O_RDONLY);
 230         if (!fd) {
 231             fprintf(stderr, "Error opening file %s\n",
 232                     files[i].filename);
 233             return -1;
 234         }
 235
 236         if ((file_data = mmap(0,
 237                               hdrs[i].file_size,
 238                               PROT_READ,
 239                               MAP_PRIVATE,
 240                               fd,
 241                               0)) == MAP_FAILED) {
 242             fprintf(stderr, "Could not mmap file for hashing\n");
 243             return -1;
 244          }
 245
 246          /* generate the hash and save it */
 247         hdrs[i].file_hash = v3_hash_buffer(file_data, hdrs[i].file_size);
 248         printf("Generating hash for file %s (hash=0x%lx)\n",
 249                 files[i].filename, hdrs[i].file_hash);
 250
 251         munmap(file_data, hdrs[i].file_size);
 252         close(fd);
 253     }
 254
 255     munmap(out_data, st.st_size);
 256     return 0;
 257 }
 258
 259 void gen_cookie(char *dest)
 260 {
 261     memcpy(dest,COOKIE,COOKIE_LEN);
 262     dest[COOKIE_VERSION_OFFSET]   = (((unsigned)version) >> 16) & 0xff;
 263     dest[COOKIE_VERSION_OFFSET+1] = (((unsigned)version) >>  8) & 0xff;
 264     dest[COOKIE_VERSION_OFFSET+2] = (((unsigned)version) >>  0) & 0xff;
 265 }
 266
 267
 268 int write_output(char * filename, ezxml_t cfg_output) {
 269     FILE * data_file = fopen(filename, "w+");
 270     char * new_cfg_str = ezxml_toxml(cfg_output);
 271     unsigned int cfg_len = strlen(new_cfg_str);
 272     unsigned long long zero = 0;
 273     int i = 0;
 274     unsigned long long offset = 0;
 275     unsigned long long file_cnt = num_files;
 276     unsigned long long hdr_offset = 0;
 277     char cookie[COOKIE_LEN];
 278
 279     gen_cookie(cookie);
 280
 281     fwrite(cookie, COOKIE_LEN, 1, data_file);
 282     offset += COOKIE_LEN;
 283
 284     //  printf("New config: \n%s\n", new_cfg_str);
 285
 286     fwrite(&cfg_len, sizeof(unsigned int), 1, data_file);
 287     offset += sizeof(unsigned int);
 288
 289     fwrite(new_cfg_str, cfg_len, 1, data_file);
 290     offset += cfg_len;
 291
 292     fwrite(&zero, 1, 8, data_file);
 293     offset += 8;
 294
 295     printf("Total number of files: %llu\n", file_cnt);
 296
 297     fwrite(&file_cnt, 8, 1, data_file);
 298     offset += 8;
 299
 300
 301     if (version==0) {
 302         // for version 0, we simply have the file num, offset, size list
 303         // each index entry is 16 bytes long plus end padding
 304         offset += (16 * num_files) + 8;
 305     } else if (version==1) {
 306         // For a version 1, we have the file num, offset, size, and hash list
 307         // We need to remember where this begins in the file, though...
 308         hdr_offset = offset;
 309
 310         // each index entry is (16+sizeof(unsigned long)) bytes long plus end padding
 311         offset += ((16 + sizeof(unsigned long)) * num_files) + 8;
 312     }
 313
 314     for (i = 0; i < num_files; i++) {
 315         fwrite(&i, 4, 1, data_file);
 316         fwrite(&(files[i].size), 4, 1, data_file);
 317         fwrite(&offset, 8, 1, data_file);
 318
 319         if (version==1) {
 320             /* we can't generate the hash yet, zero for now */
 321             fwrite(&zero, sizeof(unsigned long), 1, data_file);
 322         }
 323
 324         offset += files[i].size;
 325     }
 326
 327     fwrite(&zero, 1, 8, data_file);
 328
 329     for (i = 0; i < num_files; i++) {
 330
 331         copy_file(i, data_file);
 332
 333     }
 334
 335     fclose(data_file);
 336
 337     if (version==1) {
 338         // We now will go back and place the hashes
 339         if (generate_file_hashes(filename,
 340                                  hdr_offset,
 341                                  num_files) < 0) {
 342             fprintf(stderr, "Error generating file hashes\n");
 343             return -1;
 344         }
 345     }
 346
 347
 348     return 0;
 349 }
 350
 351
 352 #define XFER_BLK_SIZE 4096
 353
 354 int copy_file(int file_index, FILE * data_file) {
 355     char xfer_buf[XFER_BLK_SIZE];
 356     int bytes_to_read = files[file_index].size;
 357     int bytes_read = 0;
 358     int xfer_len = XFER_BLK_SIZE;
 359     FILE * in_file = NULL;
 360     char * filename = files[file_index].filename;
 361     struct winsize wsz;
 362     char cons_line[256];
 363     int prog_len = 0;
 364     double ratio = 100;
 365     int num_dots = 256;
 366
 367     printf("Copying [%d] -- %s \n",
 368            file_index,
 369            filename);
 370
 371
 372     if (ioctl(STDIO_FD, TIOCGWINSZ, &wsz) == -1) {
 373         printf("ioctl error on STDIO\n");
 374         return -1;
 375     }
 376
 377
 378     memset(cons_line, 0, 256);
 379     snprintf(cons_line, 256, "\r(%s) [", files[file_index].id);
 380     prog_len = wsz.ws_col - (strlen(cons_line) + 11);
 381
 382
 383
 384     in_file = fopen(filename, "r");
 385
 386     while (bytes_to_read > 0) {
 387         struct winsize tmp_wsz;
 388         int tmp_dots = 0;
 389
 390         if (ioctl(STDIO_FD, TIOCGWINSZ, &tmp_wsz) == -1) {
 391             printf("ioctl error on STDIO\n");
 392             return -1;
 393         }
 394
 395         ratio = (double)bytes_read / (double)(files[file_index].size);
 396         tmp_dots = (int)(ratio * (double)prog_len);
 397
 398         if ((tmp_dots != num_dots) || (tmp_wsz.ws_col != wsz.ws_col)) {
 399             int i = 0;
 400             int num_blanks = 0;
 401
 402             wsz = tmp_wsz;
 403             num_dots = tmp_dots;
 404
 405             num_blanks = prog_len - num_dots;
 406
 407             memset(cons_line, 0, 256);
 408             snprintf(cons_line, 256, "\r(%s) [", files[file_index].id);
 409
 410             for (i = 0; i <= num_dots; i++) {
 411                 strcat(cons_line, "=");
 412             }
 413
 414             for (i = 0; i < num_blanks - 1; i++) {
 415                 strcat(cons_line, " ");
 416             }
 417
 418             strcat(cons_line, "] ");
 419
 420             //  printf("console width = %d\n", wsz.ws_col);
 421             write(STDIO_FD, cons_line, wsz.ws_col);
 422         }
 423
 424
 425
 426         if (xfer_len > bytes_to_read) {
 427             xfer_len = bytes_to_read;
 428         }
 429
 430         if (fread(xfer_buf, xfer_len, 1, in_file) == 0) {
 431             printf("Error reading data file %s\n", filename);
 432             exit(-1);
 433         }
 434
 435         if (fwrite(xfer_buf, xfer_len, 1, data_file) == 0) {
 436             printf("Error writing data file contents");
 437             exit(-1);
 438         }
 439
 440
 441         bytes_read += xfer_len;
 442         bytes_to_read -= xfer_len;
 443     }
 444
 445     strcat(cons_line, "Done\n");
 446     write(STDIO_FD, cons_line, wsz.ws_col);
 447
 448
 449     fclose(in_file);
 450
 451     return 0;
 452 }