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

   1 /*
   2  * Copyright (c) 2008 Tim Post
   3  * Copyright (c) 2011, Martin Sucha
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * - Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * - The name of the author may not be used to endorse or promote products
  16  *   derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <getopt.h>
  33 #include <str.h>
  34 #include <io/console.h>
  35 #include <io/color.h>
  36 #include <io/style.h>
  37 #include <io/keycode.h>
  38 #include <errno.h>
  39 #include <vfs/vfs.h>
  40 #include <assert.h>
  41
  42 #include "config.h"
  43 #include "util.h"
  44 #include "errors.h"
  45 #include "entry.h"
  46 #include "cat.h"
  47 #include "cmds.h"
  48
  49 static const char *cmdname = "cat";
  50 #define CAT_VERSION "0.0.1"
  51 #define CAT_DEFAULT_BUFLEN 1024
  52 #define CAT_FULL_FILE 0
  53
  54 static const char *hexchars = "0123456789abcdef";
  55
  56 static bool paging_enabled = false;
  57 static size_t chars_remaining = 0;
  58 static size_t lines_remaining = 0;
  59 static sysarg_t console_cols = 0;
  60 static sysarg_t console_rows = 0;
  61 static bool should_quit = false;
  62 static bool dash_represents_stdin = false;
  63 static unsigned int lineno = 0;
  64 static bool number = false;
  65 static bool last_char_was_newline = false;
  66
  67 static console_ctrl_t *console = NULL;
  68
  69 static struct option const long_options[] = {
  70         { "help", no_argument, 0, 'h' },
  71         { "version", no_argument, 0, 'v' },
  72         { "head", required_argument, 0, 'H' },
  73         { "tail", required_argument, 0, 't' },
  74         { "buffer", required_argument, 0, 'b' },
  75         { "more", no_argument, 0, 'm' },
  76         { "hex", no_argument, 0, 'x' },
  77         { "stdin", no_argument, 0, 's' },
  78         { "number", no_argument, 0, 'n' },
  79         { 0, 0, 0, 0 }
  80 };
  81
  82 /* Dispays help for cat in various levels */
  83 void help_cmd_cat(unsigned int level)
  84 {
  85         if (level == HELP_SHORT) {
  86                 printf("`%s' shows the contents of files\n", cmdname);
  87         } else {
  88                 help_cmd_cat(HELP_SHORT);
  89                 printf(
  90                     "Usage:  %s [options] <file1> [file2] [...]\n"
  91                     "Options:\n"
  92                     "  -h, --help       A short option summary\n"
  93                     "  -v, --version    Print version information and exit\n"
  94                     "  -H, --head ##    Print only the first ## bytes\n"
  95                     "  -t, --tail ##    Print only the last ## bytes\n"
  96                     "  -b, --buffer ##  Set the read buffer size to ##\n"
  97                     "  -m, --more       Pause after each screen full\n"
  98                     "  -x, --hex        Print bytes as hex values\n"
  99                     "  -s, --stdin      Treat `-' in file list as standard input\n"
 100                     "  -n, --number     Number all output lines\n"
 101                     "Currently, %s is under development, some options don't work.\n",
 102                     cmdname, cmdname);
 103         }
 104
 105         return;
 106 }
 107
 108 static void waitprompt(void)
 109 {
 110         console_set_pos(console, 0, console_rows - 1);
 111         console_set_color(console, COLOR_WHITE, COLOR_BLUE, 0);
 112
 113         printf("ENTER/SPACE/PAGE DOWN - next page, "
 114             "ESC/Q - quit, C - continue unpaged");
 115         fflush(stdout);
 116
 117         console_set_style(console, STYLE_NORMAL);
 118 }
 119
 120 static void waitkey(void)
 121 {
 122         cons_event_t ev;
 123         kbd_event_t *kev;
 124
 125         while (true) {
 126                 if (!console_get_event(console, &ev)) {
 127                         return;
 128                 }
 129                 if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
 130                         kev = &ev.ev.key;
 131
 132                         if (kev->key == KC_ESCAPE || kev->key == KC_Q) {
 133                                 should_quit = true;
 134                                 return;
 135                         }
 136                         if (kev->key == KC_C) {
 137                                 paging_enabled = false;
 138                                 return;
 139                         }
 140                         if (kev->key == KC_ENTER || kev->key == KC_SPACE ||
 141                             kev->key == KC_PAGE_DOWN) {
 142                                 return;
 143                         }
 144                 }
 145         }
 146         assert(false);
 147 }
 148
 149 static void newpage(void)
 150 {
 151         console_clear(console);
 152         chars_remaining = console_cols;
 153         lines_remaining = console_rows - 1;
 154 }
 155
 156 static void paged_char(wchar_t c)
 157 {
 158         if (last_char_was_newline && number) {
 159                 lineno++;
 160                 printf("%6u  ", lineno);
 161         }
 162         putchar(c);
 163         last_char_was_newline = c == '\n';
 164         if (paging_enabled) {
 165                 chars_remaining--;
 166                 if (c == '\n' || chars_remaining == 0) {
 167                         chars_remaining = console_cols;
 168                         lines_remaining--;
 169                 }
 170                 if (lines_remaining == 0) {
 171                         fflush(stdout);
 172                         waitprompt();
 173                         waitkey();
 174                         newpage();
 175                 }
 176         }
 177 }
 178
 179 static unsigned int cat_file(const char *fname, size_t blen, bool hex,
 180     off64_t head, off64_t tail, bool tail_first)
 181 {
 182         int fd, count = 0, reads = 0;
 183         size_t bytes;
 184         char *buff = NULL;
 185         size_t i;
 186         size_t offset = 0, copied_bytes = 0;
 187         off64_t file_size = 0, length = 0;
 188         aoff64_t pos = 0;
 189         errno_t rc;
 190
 191         bool reading_stdin = dash_represents_stdin && (str_cmp(fname, "-") == 0);
 192
 193         if (reading_stdin) {
 194                 fd = fileno(stdin);
 195                 /* Allow storing the whole UTF-8 character. */
 196                 blen = STR_BOUNDS(1);
 197         } else {
 198                 errno_t rc = vfs_lookup_open(fname, WALK_REGULAR, MODE_READ, &fd);
 199                 if (rc != EOK) {
 200                         fd = -1;
 201                 }
 202         }
 203
 204         if (fd < 0) {
 205                 printf("Unable to open %s\n", fname);
 206                 return 1;
 207         }
 208
 209         if (NULL == (buff = (char *) malloc(blen + 1))) {
 210                 vfs_put(fd);
 211                 printf("Unable to allocate enough memory to read %s\n",
 212                     fname);
 213                 return 1;
 214         }
 215
 216         if (tail != CAT_FULL_FILE) {
 217                 vfs_stat_t st;
 218
 219                 if (vfs_stat(fd, &st) != EOK) {
 220                         vfs_put(fd);
 221                         free(buff);
 222                         printf("Unable to vfs_stat %d\n", fd);
 223                         return 1;
 224                 }
 225                 file_size = st.size;
 226                 if (head == CAT_FULL_FILE) {
 227                         head = file_size;
 228                         length = tail;
 229                 } else if (tail_first) {
 230                         length = head;
 231                 } else {
 232                         if (tail > head)
 233                                 tail = head;
 234                         length = tail;
 235                 }
 236
 237                 if (tail_first) {
 238                         pos = (tail >= file_size) ? 0 : (file_size - tail);
 239                 } else {
 240                         pos = ((head - tail) >= file_size) ? 0 : (head - tail);
 241                 }
 242         } else
 243                 length = head;
 244
 245         do {
 246                 size_t bytes_to_read;
 247                 if (reading_stdin) {
 248                         bytes_to_read = 1;
 249                 } else {
 250                         if ((length != CAT_FULL_FILE) &&
 251                             (length - (off64_t)count <= (off64_t)(blen - copied_bytes))) {
 252                                 bytes_to_read = (size_t) (length - count);
 253                         } else {
 254                                 bytes_to_read = blen - copied_bytes;
 255                         }
 256                 }
 257
 258                 rc = vfs_read(fd, &pos, buff + copied_bytes, bytes_to_read,
 259                     &bytes);
 260                 copied_bytes = 0;
 261
 262                 if (rc == EOK && bytes > 0) {
 263                         buff[bytes] = '\0';
 264                         offset = 0;
 265                         for (i = 0; i < bytes && !should_quit; i++) {
 266                                 if (hex) {
 267                                         paged_char(hexchars[((uint8_t)buff[i]) / 16]);
 268                                         paged_char(hexchars[((uint8_t)buff[i]) % 16]);
 269                                         paged_char(((count + i + 1) & 0xf) == 0 ? '\n' : ' ');
 270                                 } else {
 271                                         wchar_t c = str_decode(buff, &offset, bytes);
 272                                         if (c == 0) {
 273                                                 /* Reached end of string */
 274                                                 break;
 275                                         } else if (c == U_SPECIAL && offset + 2 >= (size_t)bytes) {
 276                                                 /* If an extended character is cut off due to the size of the buffer,
 277                                                    we will copy it over to the next buffer so it can be read correctly. */
 278                                                 copied_bytes = bytes - offset + 1;
 279                                                 memcpy(buff, buff + offset - 1, copied_bytes);
 280                                                 break;
 281                                         }
 282                                         paged_char(c);
 283                                 }
 284
 285                         }
 286                         count += bytes;
 287                         reads++;
 288                 }
 289
 290                 if (reading_stdin)
 291                         fflush(stdout);
 292         } while (rc == EOK && bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
 293
 294         vfs_put(fd);
 295         if (rc != EOK) {
 296                 printf("Error reading %s\n", fname);
 297                 free(buff);
 298                 return 1;
 299         }
 300
 301         free(buff);
 302
 303         return 0;
 304 }
 305
 306 /* Main entry point for cat, accepts an array of arguments */
 307 int cmd_cat(char **argv)
 308 {
 309         unsigned int argc, i, ret = 0;
 310         size_t buffer = 0;
 311         int c, opt_ind;
 312         aoff64_t head = CAT_FULL_FILE, tail = CAT_FULL_FILE;
 313         bool hex = false;
 314         bool more = false;
 315         bool tailFirst = false;
 316         sysarg_t rows, cols;
 317         errno_t rc;
 318
 319         /*
 320          * reset global state
 321          * TODO: move to structure?
 322          */
 323         paging_enabled = false;
 324         chars_remaining = 0;
 325         lines_remaining = 0;
 326         console_cols = 0;
 327         console_rows = 0;
 328         should_quit = false;
 329         dash_represents_stdin = false;
 330         console = console_init(stdin, stdout);
 331         number = false;
 332         lineno = 0;
 333         /* This enables printing of the first number. */
 334         last_char_was_newline = true;
 335
 336
 337         argc = cli_count_args(argv);
 338
 339         c = 0;
 340         optreset = 1;
 341         optind = 0;
 342         opt_ind = 0;
 343
 344         while (c != -1) {
 345                 c = getopt_long(argc, argv, "xhvmH:t:b:sn", long_options, &opt_ind);
 346                 switch (c) {
 347                 case 'h':
 348                         help_cmd_cat(HELP_LONG);
 349                         return CMD_SUCCESS;
 350                 case 'v':
 351                         printf("%s\n", CAT_VERSION);
 352                         return CMD_SUCCESS;
 353                 case 'H':
 354                         if (!optarg || str_uint64_t(optarg, NULL, 10, false, &head) != EOK) {
 355                                 puts("Invalid head size");
 356                                 return CMD_FAILURE;
 357                         }
 358                         break;
 359                 case 't':
 360                         if (!optarg || str_uint64_t(optarg, NULL, 10, false, &tail) != EOK) {
 361                                 puts("Invalid tail size");
 362                                 return CMD_FAILURE;
 363                         }
 364                         if (head == CAT_FULL_FILE)
 365                                 tailFirst = true;
 366                         break;
 367                 case 'b':
 368                         if (!optarg || str_size_t(optarg, NULL, 10, false, &buffer) != EOK) {
 369                                 puts("Invalid buffer size");
 370                                 return CMD_FAILURE;
 371                         }
 372                         break;
 373                 case 'm':
 374                         more = true;
 375                         break;
 376                 case 'x':
 377                         hex = true;
 378                         break;
 379                 case 's':
 380                         dash_represents_stdin = true;
 381                         break;
 382                 case 'n':
 383                         number = true;
 384                         break;
 385                 }
 386         }
 387
 388         argc -= optind;
 389
 390         if (argc < 1) {
 391                 printf("%s - incorrect number of arguments. Try `%s --help'\n",
 392                     cmdname, cmdname);
 393                 return CMD_FAILURE;
 394         }
 395
 396         if (buffer < 4)
 397                 buffer = CAT_DEFAULT_BUFLEN;
 398
 399         if (more) {
 400                 rc = console_get_size(console, &cols, &rows);
 401                 if (rc != EOK) {
 402                         printf("%s - cannot get console size\n", cmdname);
 403                         return CMD_FAILURE;
 404                 }
 405                 console_cols = cols;
 406                 console_rows = rows;
 407                 paging_enabled = true;
 408                 newpage();
 409         }
 410
 411         for (i = optind; argv[i] != NULL && !should_quit; i++)
 412                 ret += cat_file(argv[i], buffer, hex, head, tail, tailFirst);
 413
 414         if (ret)
 415                 return CMD_FAILURE;
 416         else
 417                 return CMD_SUCCESS;
 418 }
 419