File:  [Qemu by Fabrice Bellard] / qemu / qemu-img.c
Revision 1.1.1.2 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 16:42:46 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0082, HEAD
qemu 0.8.2

    1: /*
    2:  * create a COW disk image
    3:  * 
    4:  * Copyright (c) 2003 Fabrice Bellard
    5:  * 
    6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
    7:  * of this software and associated documentation files (the "Software"), to deal
    8:  * in the Software without restriction, including without limitation the rights
    9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   10:  * copies of the Software, and to permit persons to whom the Software is
   11:  * furnished to do so, subject to the following conditions:
   12:  *
   13:  * The above copyright notice and this permission notice shall be included in
   14:  * all copies or substantial portions of the Software.
   15:  *
   16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   22:  * THE SOFTWARE.
   23:  */
   24: #include "vl.h"
   25: 
   26: #ifdef _WIN32
   27: #include <windows.h>
   28: #endif
   29: 
   30: void *get_mmap_addr(unsigned long size)
   31: {
   32:     return NULL;
   33: }
   34: 
   35: void qemu_free(void *ptr)
   36: {
   37:     free(ptr);
   38: }
   39: 
   40: void *qemu_malloc(size_t size)
   41: {
   42:     return malloc(size);
   43: }
   44: 
   45: void *qemu_mallocz(size_t size)
   46: {
   47:     void *ptr;
   48:     ptr = qemu_malloc(size);
   49:     if (!ptr)
   50:         return NULL;
   51:     memset(ptr, 0, size);
   52:     return ptr;
   53: }
   54: 
   55: char *qemu_strdup(const char *str)
   56: {
   57:     char *ptr;
   58:     ptr = qemu_malloc(strlen(str) + 1);
   59:     if (!ptr)
   60:         return NULL;
   61:     strcpy(ptr, str);
   62:     return ptr;
   63: }
   64: 
   65: void pstrcpy(char *buf, int buf_size, const char *str)
   66: {
   67:     int c;
   68:     char *q = buf;
   69: 
   70:     if (buf_size <= 0)
   71:         return;
   72: 
   73:     for(;;) {
   74:         c = *str++;
   75:         if (c == 0 || q >= buf + buf_size - 1)
   76:             break;
   77:         *q++ = c;
   78:     }
   79:     *q = '\0';
   80: }
   81: 
   82: /* strcat and truncate. */
   83: char *pstrcat(char *buf, int buf_size, const char *s)
   84: {
   85:     int len;
   86:     len = strlen(buf);
   87:     if (len < buf_size) 
   88:         pstrcpy(buf + len, buf_size - len, s);
   89:     return buf;
   90: }
   91: 
   92: int strstart(const char *str, const char *val, const char **ptr)
   93: {
   94:     const char *p, *q;
   95:     p = str;
   96:     q = val;
   97:     while (*q != '\0') {
   98:         if (*p != *q)
   99:             return 0;
  100:         p++;
  101:         q++;
  102:     }
  103:     if (ptr)
  104:         *ptr = p;
  105:     return 1;
  106: }
  107: 
  108: void term_printf(const char *fmt, ...)
  109: {
  110:     va_list ap;
  111:     va_start(ap, fmt);
  112:     vprintf(fmt, ap);
  113:     va_end(ap);
  114: }
  115: 
  116: void __attribute__((noreturn)) error(const char *fmt, ...) 
  117: {
  118:     va_list ap;
  119:     va_start(ap, fmt);
  120:     fprintf(stderr, "qemu-img: ");
  121:     vfprintf(stderr, fmt, ap);
  122:     fprintf(stderr, "\n");
  123:     exit(1);
  124:     va_end(ap);
  125: }
  126: 
  127: static void format_print(void *opaque, const char *name)
  128: {
  129:     printf(" %s", name);
  130: }
  131: 
  132: void help(void)
  133: {
  134:     printf("qemu-img version " QEMU_VERSION ", Copyright (c) 2004-2005 Fabrice Bellard\n"
  135:            "usage: qemu-img command [command options]\n"
  136:            "QEMU disk image utility\n"
  137:            "\n"
  138:            "Command syntax:\n"
  139:            "  create [-e] [-b base_image] [-f fmt] filename [size]\n"
  140:            "  commit [-f fmt] filename\n"
  141:            "  convert [-c] [-e] [-f fmt] filename [-O output_fmt] output_filename\n"
  142:            "  info [-f fmt] filename\n"
  143:            "\n"
  144:            "Command parameters:\n"
  145:            "  'filename' is a disk image filename\n"
  146:            "  'base_image' is the read-only disk image which is used as base for a copy on\n"
  147:            "    write image; the copy on write image only stores the modified data\n"
  148:            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
  149:            "  'size' is the disk image size in kilobytes. Optional suffixes 'M' (megabyte)\n"
  150:            "    and 'G' (gigabyte) are supported\n"
  151:            "  'output_filename' is the destination disk image filename\n"
  152:            "  'output_fmt' is the destination format\n"
  153:            "  '-c' indicates that target image must be compressed (qcow format only)\n"
  154:            "  '-e' indicates that the target image must be encrypted (qcow format only)\n"
  155:            );
  156:     printf("\nSupported format:");
  157:     bdrv_iterate_format(format_print, NULL);
  158:     printf("\n");
  159:     exit(1);
  160: }
  161: 
  162: 
  163: #define NB_SUFFIXES 4
  164: 
  165: static void get_human_readable_size(char *buf, int buf_size, int64_t size)
  166: {
  167:     static const char suffixes[NB_SUFFIXES] = "KMGT";
  168:     int64_t base;
  169:     int i;
  170: 
  171:     if (size <= 999) {
  172:         snprintf(buf, buf_size, "%" PRId64, size);
  173:     } else {
  174:         base = 1024;
  175:         for(i = 0; i < NB_SUFFIXES; i++) {
  176:             if (size < (10 * base)) {
  177:                 snprintf(buf, buf_size, "%0.1f%c", 
  178:                          (double)size / base,
  179:                          suffixes[i]);
  180:                 break;
  181:             } else if (size < (1000 * base) || i == (NB_SUFFIXES - 1)) {
  182:                 snprintf(buf, buf_size, "%" PRId64 "%c", 
  183:                          ((size + (base >> 1)) / base),
  184:                          suffixes[i]);
  185:                 break;
  186:             }
  187:             base = base * 1024;
  188:         }
  189:     }
  190: }
  191: 
  192: #if defined(WIN32)
  193: /* XXX: put correct support for win32 */
  194: static int read_password(char *buf, int buf_size)
  195: {
  196:     int c, i;
  197:     printf("Password: ");
  198:     fflush(stdout);
  199:     i = 0;
  200:     for(;;) {
  201:         c = getchar();
  202:         if (c == '\n')
  203:             break;
  204:         if (i < (buf_size - 1))
  205:             buf[i++] = c;
  206:     }
  207:     buf[i] = '\0';
  208:     return 0;
  209: }
  210: 
  211: #else
  212: 
  213: #include <termios.h>
  214: 
  215: static struct termios oldtty;
  216: 
  217: static void term_exit(void)
  218: {
  219:     tcsetattr (0, TCSANOW, &oldtty);
  220: }
  221: 
  222: static void term_init(void)
  223: {
  224:     struct termios tty;
  225: 
  226:     tcgetattr (0, &tty);
  227:     oldtty = tty;
  228: 
  229:     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
  230:                           |INLCR|IGNCR|ICRNL|IXON);
  231:     tty.c_oflag |= OPOST;
  232:     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
  233:     tty.c_cflag &= ~(CSIZE|PARENB);
  234:     tty.c_cflag |= CS8;
  235:     tty.c_cc[VMIN] = 1;
  236:     tty.c_cc[VTIME] = 0;
  237:     
  238:     tcsetattr (0, TCSANOW, &tty);
  239: 
  240:     atexit(term_exit);
  241: }
  242: 
  243: int read_password(char *buf, int buf_size)
  244: {
  245:     uint8_t ch;
  246:     int i, ret;
  247: 
  248:     printf("password: ");
  249:     fflush(stdout);
  250:     term_init();
  251:     i = 0;
  252:     for(;;) {
  253:         ret = read(0, &ch, 1);
  254:         if (ret == -1) {
  255:             if (errno == EAGAIN || errno == EINTR) {
  256:                 continue;
  257:             } else {
  258:                 ret = -1;
  259:                 break;
  260:             }
  261:         } else if (ret == 0) {
  262:             ret = -1;
  263:             break;
  264:         } else {
  265:             if (ch == '\r') {
  266:                 ret = 0;
  267:                 break;
  268:             }
  269:             if (i < (buf_size - 1))
  270:                 buf[i++] = ch;
  271:         }
  272:     }
  273:     term_exit();
  274:     buf[i] = '\0';
  275:     printf("\n");
  276:     return ret;
  277: }
  278: #endif
  279: 
  280: static BlockDriverState *bdrv_new_open(const char *filename,
  281:                                        const char *fmt)
  282: {
  283:     BlockDriverState *bs;
  284:     BlockDriver *drv;
  285:     char password[256];
  286: 
  287:     bs = bdrv_new("");
  288:     if (!bs)
  289:         error("Not enough memory");
  290:     if (fmt) {
  291:         drv = bdrv_find_format(fmt);
  292:         if (!drv)
  293:             error("Unknown file format '%s'", fmt);
  294:     } else {
  295:         drv = NULL;
  296:     }
  297:     if (bdrv_open2(bs, filename, 0, drv) < 0) {
  298:         error("Could not open '%s'", filename);
  299:     }
  300:     if (bdrv_is_encrypted(bs)) {
  301:         printf("Disk image '%s' is encrypted.\n", filename);
  302:         if (read_password(password, sizeof(password)) < 0)
  303:             error("No password given");
  304:         if (bdrv_set_key(bs, password) < 0)
  305:             error("invalid password");
  306:     }
  307:     return bs;
  308: }
  309: 
  310: static int img_create(int argc, char **argv)
  311: {
  312:     int c, ret, encrypted;
  313:     const char *fmt = "raw";
  314:     const char *filename;
  315:     const char *base_filename = NULL;
  316:     int64_t size;
  317:     const char *p;
  318:     BlockDriver *drv;
  319:     
  320:     encrypted = 0;
  321:     for(;;) {
  322:         c = getopt(argc, argv, "b:f:he");
  323:         if (c == -1)
  324:             break;
  325:         switch(c) {
  326:         case 'h':
  327:             help();
  328:             break;
  329:         case 'b':
  330:             base_filename = optarg;
  331:             break;
  332:         case 'f':
  333:             fmt = optarg;
  334:             break;
  335:         case 'e':
  336:             encrypted = 1;
  337:             break;
  338:         }
  339:     }
  340:     if (optind >= argc) 
  341:         help();
  342:     filename = argv[optind++];
  343:     size = 0;
  344:     if (base_filename) {
  345:         BlockDriverState *bs;
  346:         bs = bdrv_new_open(base_filename, NULL);
  347:         bdrv_get_geometry(bs, &size);
  348:         size *= 512;
  349:         bdrv_delete(bs);
  350:     } else {
  351:         if (optind >= argc)
  352:             help();
  353:         p = argv[optind];
  354:         size = strtoul(p, (char **)&p, 0);
  355:         if (*p == 'M') {
  356:             size *= 1024 * 1024;
  357:         } else if (*p == 'G') {
  358:             size *= 1024 * 1024 * 1024;
  359:         } else if (*p == 'k' || *p == 'K' || *p == '\0') {
  360:             size *= 1024;
  361:         } else {
  362:             help();
  363:         }
  364:     }
  365:     drv = bdrv_find_format(fmt);
  366:     if (!drv)
  367:         error("Unknown file format '%s'", fmt);
  368:     printf("Formating '%s', fmt=%s",
  369:            filename, fmt);
  370:     if (encrypted)
  371:         printf(", encrypted");
  372:     if (base_filename) {
  373:         printf(", backing_file=%s",
  374:                base_filename);
  375:     }
  376:     printf(", size=%" PRId64 " kB\n", (int64_t) (size / 1024));
  377:     ret = bdrv_create(drv, filename, size / 512, base_filename, encrypted);
  378:     if (ret < 0) {
  379:         if (ret == -ENOTSUP) {
  380:             error("Formatting or formatting option not supported for file format '%s'", fmt);
  381:         } else {
  382:             error("Error while formatting");
  383:         }
  384:     }
  385:     return 0;
  386: }
  387: 
  388: static int img_commit(int argc, char **argv)
  389: {
  390:     int c, ret;
  391:     const char *filename, *fmt;
  392:     BlockDriver *drv;
  393:     BlockDriverState *bs;
  394: 
  395:     fmt = NULL;
  396:     for(;;) {
  397:         c = getopt(argc, argv, "f:h");
  398:         if (c == -1)
  399:             break;
  400:         switch(c) {
  401:         case 'h':
  402:             help();
  403:             break;
  404:         case 'f':
  405:             fmt = optarg;
  406:             break;
  407:         }
  408:     }
  409:     if (optind >= argc) 
  410:         help();
  411:     filename = argv[optind++];
  412: 
  413:     bs = bdrv_new("");
  414:     if (!bs)
  415:         error("Not enough memory");
  416:     if (fmt) {
  417:         drv = bdrv_find_format(fmt);
  418:         if (!drv)
  419:             error("Unknown file format '%s'", fmt);
  420:     } else {
  421:         drv = NULL;
  422:     }
  423:     if (bdrv_open2(bs, filename, 0, drv) < 0) {
  424:         error("Could not open '%s'", filename);
  425:     }
  426:     ret = bdrv_commit(bs);
  427:     switch(ret) {
  428:     case 0:
  429:         printf("Image committed.\n");
  430:         break;
  431:     case -ENOENT:
  432:         error("No disk inserted");
  433:         break;
  434:     case -EACCES:
  435:         error("Image is read-only");
  436:         break;
  437:     case -ENOTSUP:
  438:         error("Image is already committed");
  439:         break;
  440:     default:
  441:         error("Error while committing image");
  442:         break;
  443:     }
  444: 
  445:     bdrv_delete(bs);
  446:     return 0;
  447: }
  448: 
  449: static int is_not_zero(const uint8_t *sector, int len)
  450: {
  451:     int i;
  452:     len >>= 2;
  453:     for(i = 0;i < len; i++) {
  454:         if (((uint32_t *)sector)[i] != 0)
  455:             return 1;
  456:     }
  457:     return 0;
  458: }
  459: 
  460: static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
  461: {
  462:     int v, i;
  463: 
  464:     if (n <= 0) {
  465:         *pnum = 0;
  466:         return 0;
  467:     }
  468:     v = is_not_zero(buf, 512);
  469:     for(i = 1; i < n; i++) {
  470:         buf += 512;
  471:         if (v != is_not_zero(buf, 512))
  472:             break;
  473:     }
  474:     *pnum = i;
  475:     return v;
  476: }
  477: 
  478: #define IO_BUF_SIZE 65536
  479: 
  480: static int img_convert(int argc, char **argv)
  481: {
  482:     int c, ret, n, n1, compress, cluster_size, cluster_sectors, encrypt;
  483:     const char *filename, *fmt, *out_fmt, *out_filename;
  484:     BlockDriver *drv;
  485:     BlockDriverState *bs, *out_bs;
  486:     int64_t total_sectors, nb_sectors, sector_num;
  487:     uint8_t buf[IO_BUF_SIZE];
  488:     const uint8_t *buf1;
  489: 
  490:     fmt = NULL;
  491:     out_fmt = "raw";
  492:     compress = 0;
  493:     encrypt = 0;
  494:     for(;;) {
  495:         c = getopt(argc, argv, "f:O:hce");
  496:         if (c == -1)
  497:             break;
  498:         switch(c) {
  499:         case 'h':
  500:             help();
  501:             break;
  502:         case 'f':
  503:             fmt = optarg;
  504:             break;
  505:         case 'O':
  506:             out_fmt = optarg;
  507:             break;
  508:         case 'c':
  509:             compress = 1;
  510:             break;
  511:         case 'e':
  512:             encrypt = 1;
  513:             break;
  514:         }
  515:     }
  516:     if (optind >= argc) 
  517:         help();
  518:     filename = argv[optind++];
  519:     if (optind >= argc) 
  520:         help();
  521:     out_filename = argv[optind++];
  522:     
  523:     bs = bdrv_new_open(filename, fmt);
  524: 
  525:     drv = bdrv_find_format(out_fmt);
  526:     if (!drv)
  527:         error("Unknown file format '%s'", fmt);
  528:     if (compress && drv != &bdrv_qcow)
  529:         error("Compression not supported for this file format");
  530:     if (encrypt && drv != &bdrv_qcow)
  531:         error("Encryption not supported for this file format");
  532:     if (compress && encrypt)
  533:         error("Compression and encryption not supported at the same time");
  534:     bdrv_get_geometry(bs, &total_sectors);
  535:     ret = bdrv_create(drv, out_filename, total_sectors, NULL, encrypt);
  536:     if (ret < 0) {
  537:         if (ret == -ENOTSUP) {
  538:             error("Formatting not supported for file format '%s'", fmt);
  539:         } else {
  540:             error("Error while formatting '%s'", out_filename);
  541:         }
  542:     }
  543:     
  544:     out_bs = bdrv_new_open(out_filename, out_fmt);
  545: 
  546:     if (compress) {
  547:         cluster_size = qcow_get_cluster_size(out_bs);
  548:         if (cluster_size <= 0 || cluster_size > IO_BUF_SIZE)
  549:             error("invalid cluster size");
  550:         cluster_sectors = cluster_size >> 9;
  551:         sector_num = 0;
  552:         for(;;) {
  553:             nb_sectors = total_sectors - sector_num;
  554:             if (nb_sectors <= 0)
  555:                 break;
  556:             if (nb_sectors >= cluster_sectors)
  557:                 n = cluster_sectors;
  558:             else
  559:                 n = nb_sectors;
  560:             if (bdrv_read(bs, sector_num, buf, n) < 0) 
  561:                 error("error while reading");
  562:             if (n < cluster_sectors)
  563:                 memset(buf + n * 512, 0, cluster_size - n * 512);
  564:             if (is_not_zero(buf, cluster_size)) {
  565:                 if (qcow_compress_cluster(out_bs, sector_num, buf) != 0)
  566:                     error("error while compressing sector %" PRId64,
  567:                           sector_num);
  568:             }
  569:             sector_num += n;
  570:         }
  571:     } else {
  572:         sector_num = 0;
  573:         for(;;) {
  574:             nb_sectors = total_sectors - sector_num;
  575:             if (nb_sectors <= 0)
  576:                 break;
  577:             if (nb_sectors >= (IO_BUF_SIZE / 512))
  578:                 n = (IO_BUF_SIZE / 512);
  579:             else
  580:                 n = nb_sectors;
  581:             if (bdrv_read(bs, sector_num, buf, n) < 0) 
  582:                 error("error while reading");
  583:             /* NOTE: at the same time we convert, we do not write zero
  584:                sectors to have a chance to compress the image. Ideally, we
  585:                should add a specific call to have the info to go faster */
  586:             buf1 = buf;
  587:             while (n > 0) {
  588:                 if (is_allocated_sectors(buf1, n, &n1)) {
  589:                     if (bdrv_write(out_bs, sector_num, buf1, n1) < 0) 
  590:                         error("error while writing");
  591:                 }
  592:                 sector_num += n1;
  593:                 n -= n1;
  594:                 buf1 += n1 * 512;
  595:             }
  596:         }
  597:     }
  598:     bdrv_delete(out_bs);
  599:     bdrv_delete(bs);
  600:     return 0;
  601: }
  602: 
  603: #ifdef _WIN32
  604: static int64_t get_allocated_file_size(const char *filename)
  605: {
  606:     typedef DWORD (WINAPI * get_compressed_t)(const char *filename, DWORD *high);
  607:     get_compressed_t get_compressed;
  608:     struct _stati64 st;
  609: 
  610:     /* WinNT support GetCompressedFileSize to determine allocate size */
  611:     get_compressed = (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"), "GetCompressedFileSizeA");
  612:     if (get_compressed) {
  613:     	DWORD high, low;
  614:     	low = get_compressed(filename, &high);
  615:     	if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR)
  616: 	    return (((int64_t) high) << 32) + low;
  617:     }
  618: 
  619:     if (_stati64(filename, &st) < 0) 
  620:         return -1;
  621:     return st.st_size;
  622: }
  623: #else
  624: static int64_t get_allocated_file_size(const char *filename)
  625: {
  626:     struct stat st;
  627:     if (stat(filename, &st) < 0) 
  628:         return -1;
  629:     return (int64_t)st.st_blocks * 512;
  630: }
  631: #endif
  632: 
  633: static int img_info(int argc, char **argv)
  634: {
  635:     int c;
  636:     const char *filename, *fmt;
  637:     BlockDriver *drv;
  638:     BlockDriverState *bs;
  639:     char fmt_name[128], size_buf[128], dsize_buf[128];
  640:     int64_t total_sectors, allocated_size;
  641: 
  642:     fmt = NULL;
  643:     for(;;) {
  644:         c = getopt(argc, argv, "f:h");
  645:         if (c == -1)
  646:             break;
  647:         switch(c) {
  648:         case 'h':
  649:             help();
  650:             break;
  651:         case 'f':
  652:             fmt = optarg;
  653:             break;
  654:         }
  655:     }
  656:     if (optind >= argc) 
  657:         help();
  658:     filename = argv[optind++];
  659: 
  660:     bs = bdrv_new("");
  661:     if (!bs)
  662:         error("Not enough memory");
  663:     if (fmt) {
  664:         drv = bdrv_find_format(fmt);
  665:         if (!drv)
  666:             error("Unknown file format '%s'", fmt);
  667:     } else {
  668:         drv = NULL;
  669:     }
  670:     if (bdrv_open2(bs, filename, 0, drv) < 0) {
  671:         error("Could not open '%s'", filename);
  672:     }
  673:     bdrv_get_format(bs, fmt_name, sizeof(fmt_name));
  674:     bdrv_get_geometry(bs, &total_sectors);
  675:     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
  676:     allocated_size = get_allocated_file_size(filename);
  677:     if (allocated_size < 0)
  678: 	sprintf(dsize_buf, "unavailable");
  679:     else
  680:         get_human_readable_size(dsize_buf, sizeof(dsize_buf), 
  681:                                 allocated_size);
  682:     printf("image: %s\n"
  683:            "file format: %s\n"
  684:            "virtual size: %s (%" PRId64 " bytes)\n"
  685:            "disk size: %s\n",
  686:            filename, fmt_name, size_buf, 
  687:            (total_sectors * 512),
  688:            dsize_buf);
  689:     if (bdrv_is_encrypted(bs))
  690:         printf("encrypted: yes\n");
  691:     bdrv_delete(bs);
  692:     return 0;
  693: }
  694: 
  695: int main(int argc, char **argv)
  696: {
  697:     const char *cmd;
  698: 
  699:     bdrv_init();
  700:     if (argc < 2)
  701:         help();
  702:     cmd = argv[1];
  703:     optind++;
  704:     if (!strcmp(cmd, "create")) {
  705:         img_create(argc, argv);
  706:     } else if (!strcmp(cmd, "commit")) {
  707:         img_commit(argc, argv);
  708:     } else if (!strcmp(cmd, "convert")) {
  709:         img_convert(argc, argv);
  710:     } else if (!strcmp(cmd, "info")) {
  711:         img_info(argc, argv);
  712:     } else {
  713:         help();
  714:     }
  715:     return 0;
  716: }

unix.superglobalmegacorp.com