tools/lib/api/io.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Lightweight buffered reading library.
   4  *
   5  * Copyright 2019 Google LLC.
   6  */
   7 #ifndef __API_IO__
   8 #define __API_IO__
   9
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12
  13 struct io {
  14         /* File descriptor being read/ */
  15         int fd;
  16         /* Size of the read buffer. */
  17         unsigned int buf_len;
  18         /* Pointer to storage for buffering read. */
  19         char *buf;
  20         /* End of the storage. */
  21         char *end;
  22         /* Currently accessed data pointer. */
  23         char *data;
  24         /* Set true on when the end of file on read error. */
  25         bool eof;
  26 };
  27
  28 static inline void io__init(struct io *io, int fd,
  29                             char *buf, unsigned int buf_len)
  30 {
  31         io->fd = fd;
  32         io->buf_len = buf_len;
  33         io->buf = buf;
  34         io->end = buf;
  35         io->data = buf;
  36         io->eof = false;
  37 }
  38
  39 /* Reads one character from the "io" file with similar semantics to fgetc. */
  40 static inline int io__get_char(struct io *io)
  41 {
  42         char *ptr = io->data;
  43
  44         if (io->eof)
  45                 return -1;
  46
  47         if (ptr == io->end) {
  48                 ssize_t n = read(io->fd, io->buf, io->buf_len);
  49
  50                 if (n <= 0) {
  51                         io->eof = true;
  52                         return -1;
  53                 }
  54                 ptr = &io->buf[0];
  55                 io->end = &io->buf[n];
  56         }
  57         io->data = ptr + 1;
  58         return *ptr;
  59 }
  60
  61 /* Read a hexadecimal value with no 0x prefix into the out argument hex. If the
  62  * first character isn't hexadecimal returns -2, io->eof returns -1, otherwise
  63  * returns the character after the hexadecimal value which may be -1 for eof.
  64  * If the read value is larger than a u64 the high-order bits will be dropped.
  65  */
  66 static inline int io__get_hex(struct io *io, __u64 *hex)
  67 {
  68         bool first_read = true;
  69
  70         *hex = 0;
  71         while (true) {
  72                 int ch = io__get_char(io);
  73
  74                 if (ch < 0)
  75                         return ch;
  76                 if (ch >= '0' && ch <= '9')
  77                         *hex = (*hex << 4) | (ch - '0');
  78                 else if (ch >= 'a' && ch <= 'f')
  79                         *hex = (*hex << 4) | (ch - 'a' + 10);
  80                 else if (ch >= 'A' && ch <= 'F')
  81                         *hex = (*hex << 4) | (ch - 'A' + 10);
  82                 else if (first_read)
  83                         return -2;
  84                 else
  85                         return ch;
  86                 first_read = false;
  87         }
  88 }
  89
  90 /* Read a positive decimal value with out argument dec. If the first character
  91  * isn't a decimal returns -2, io->eof returns -1, otherwise returns the
  92  * character after the decimal value which may be -1 for eof. If the read value
  93  * is larger than a u64 the high-order bits will be dropped.
  94  */
  95 static inline int io__get_dec(struct io *io, __u64 *dec)
  96 {
  97         bool first_read = true;
  98
  99         *dec = 0;
 100         while (true) {
 101                 int ch = io__get_char(io);
 102
 103                 if (ch < 0)
 104                         return ch;
 105                 if (ch >= '0' && ch <= '9')
 106                         *dec = (*dec * 10) + ch - '0';
 107                 else if (first_read)
 108                         return -2;
 109                 else
 110                         return ch;
 111                 first_read = false;
 112         }
 113 }
 114
 115 #endif /* __API_IO__ */