uspace/app/bdsh/cmds/modules/mkfile/mkfile.c

   1 /*
   2  * Copyright (c) 2009 Jiri Svoboda
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <errno.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <stdint.h>
  33 #include <str_error.h>
  34 #include <dirent.h>
  35 #include <macros.h>
  36 #include <getopt.h>
  37 #include <stdarg.h>
  38 #include <str.h>
  39 #include <ctype.h>
  40 #include <vfs/vfs.h>
  41
  42 #include "config.h"
  43 #include "errors.h"
  44 #include "util.h"
  45 #include "entry.h"
  46 #include "mkfile.h"
  47 #include "cmds.h"
  48
  49 /** Number of bytes to write at a time */
  50 #define BUFFER_SIZE 16384
  51
  52 static const char *cmdname = "mkfile";
  53
  54 static struct option const long_options[] = {
  55         {"size", required_argument, 0, 's'},
  56         {"sparse", no_argument, 0, 'p'},
  57         {"help", no_argument, 0, 'h'},
  58         {0, 0, 0, 0}
  59 };
  60
  61 void help_cmd_mkfile(unsigned int level)
  62 {
  63         if (level == HELP_SHORT) {
  64                 printf("`%s' creates a new zero-filled file\n", cmdname);
  65         } else {
  66                 help_cmd_mkfile(HELP_SHORT);
  67                 printf(
  68                 "Usage:  %s [options] <path>\n"
  69                 "Options:\n"
  70                 "  -h, --help       A short option summary\n"
  71                 "  -s, --size sz    Size of the file\n"
  72                 "  -p, --sparse     Create a sparse file\n"
  73                 "\n"
  74                 "Size is a number followed by 'k', 'm' or 'g' for kB, MB, GB.\n"
  75                 "E.g. 100k, 2m, 1g.\n",
  76                 cmdname);
  77         }
  78
  79         return;
  80 }
  81
  82 /** Parse size specification.
  83  *
  84  * Size specification is in the form <decimal_number><unit> where
  85  * <unit> is 'k', 'm' or 'g' for kB, MB, GB.
  86  *
  87  * @param str   String containing the size specification.
  88  * @param rsize Place to store size in bytes
  89  * @return      EOK on success or an error code
  90  */
  91 static errno_t read_size(const char *str, size_t *rsize)
  92 {
  93         size_t number, unit;
  94         char *ep;
  95
  96         number = strtol(str, &ep, 10);
  97         if (ep[0] == '\0') {
  98                 *rsize = number;
  99                 return EOK;
 100         }
 101
 102         if (ep[1] != '\0')
 103                     return EINVAL;
 104
 105         switch (tolower(ep[0])) {
 106         case 'k': unit = 1024; break;
 107         case 'm': unit = 1024*1024; break;
 108         case 'g': unit = 1024*1024*1024; break;
 109         default: return EINVAL;
 110         }
 111
 112         *rsize = number * unit;
 113         return EOK;
 114 }
 115
 116 int cmd_mkfile(char **argv)
 117 {
 118         unsigned int argc;
 119         int c, opt_ind;
 120         int fd;
 121         size_t file_size;
 122         size_t total_written;
 123         size_t to_write;
 124         size_t nwritten;
 125         errno_t rc;
 126         char *file_name;
 127         void *buffer;
 128         bool create_sparse = false;
 129         aoff64_t pos = 0;
 130
 131         file_size = 0;
 132
 133         argc = cli_count_args(argv);
 134
 135         for (c = 0, optreset = 1, optind = 0, opt_ind = 0; c != -1;) {
 136                 c = getopt_long(argc, argv, "ps:h", long_options, &opt_ind);
 137                 switch (c) {
 138                 case 'h':
 139                         help_cmd_mkfile(HELP_LONG);
 140                         return CMD_SUCCESS;
 141                 case 'p':
 142                         create_sparse = true;
 143                         break;
 144                 case 's':
 145                         rc = read_size(optarg, &file_size);
 146                         if (rc != EOK) {
 147                                 printf("%s: Invalid file size specification.\n",
 148                                     cmdname);
 149                                 return CMD_FAILURE;
 150                         }
 151                         break;
 152                 }
 153         }
 154
 155         argc -= optind;
 156
 157         if (argc != 1) {
 158                 printf("%s: incorrect number of arguments. Try `%s --help'\n",
 159                         cmdname, cmdname);
 160                 return CMD_FAILURE;
 161         }
 162
 163         file_name = argv[optind];
 164
 165         rc = vfs_lookup_open(file_name, WALK_REGULAR | WALK_MUST_CREATE, MODE_WRITE, &fd);
 166         if (rc != EOK) {
 167                 printf("%s: failed to create file %s.\n", cmdname, file_name);
 168                 return CMD_FAILURE;
 169         }
 170
 171         if (create_sparse && file_size > 0) {
 172                 const char byte = 0x00;
 173
 174                 pos = file_size - 1;
 175                 rc = vfs_write(fd, &pos, &byte, sizeof(char), &nwritten);
 176                 if (rc != EOK) {
 177                         vfs_put(fd);
 178                         goto error;
 179                 }
 180                 return CMD_SUCCESS;
 181         }
 182
 183         buffer = calloc(BUFFER_SIZE, 1);
 184         if (buffer == NULL) {
 185                 printf("%s: Error, out of memory.\n", cmdname);
 186                 return CMD_FAILURE;
 187         }
 188
 189         total_written = 0;
 190         while (total_written < file_size) {
 191                 to_write = min(file_size - total_written, BUFFER_SIZE);
 192                 rc = vfs_write(fd, &pos, buffer, to_write, &nwritten);
 193                 if (rc != EOK) {
 194                         printf("%s: Error writing file (%s).\n", cmdname, str_error(rc));
 195                         vfs_put(fd);
 196                         free(buffer);
 197                         return CMD_FAILURE;
 198                 }
 199                 total_written += nwritten;
 200         }
 201
 202         free(buffer);
 203
 204         rc = vfs_put(fd);
 205         if (rc != EOK)
 206                 goto error;
 207
 208         return CMD_SUCCESS;
 209 error:
 210         printf("%s: Error writing file (%s).\n", cmdname, str_error(rc));
 211         return CMD_FAILURE;
 212 }