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 <errno.h>
 11#include <poll.h>
 12#include <stdlib.h>
 13#include <string.h>
 14#include <unistd.h>
 15#include <linux/types.h>
 16
 17struct io {
 18	/* File descriptor being read/ */
 19	int fd;
 20	/* Size of the read buffer. */
 21	unsigned int buf_len;
 22	/* Pointer to storage for buffering read. */
 23	char *buf;
 24	/* End of the storage. */
 25	char *end;
 26	/* Currently accessed data pointer. */
 27	char *data;
 28	/* Read timeout, 0 implies no timeout. */
 29	int timeout_ms;
 30	/* Set true on when the end of file on read error. */
 31	bool eof;
 32};
 33
 34static inline void io__init(struct io *io, int fd,
 35			    char *buf, unsigned int buf_len)
 36{
 37	io->fd = fd;
 38	io->buf_len = buf_len;
 39	io->buf = buf;
 40	io->end = buf;
 41	io->data = buf;
 42	io->timeout_ms = 0;
 43	io->eof = false;
 44}
 45
 46/* Reads one character from the "io" file with similar semantics to fgetc. */
 47static inline int io__get_char(struct io *io)
 48{
 49	char *ptr = io->data;
 50
 51	if (io->eof)
 52		return -1;
 53
 54	if (ptr == io->end) {
 55		ssize_t n;
 56
 57		if (io->timeout_ms != 0) {
 58			struct pollfd pfds[] = {
 59				{
 60					.fd = io->fd,
 61					.events = POLLIN,
 62				},
 63			};
 64
 65			n = poll(pfds, 1, io->timeout_ms);
 66			if (n == 0)
 67				errno = ETIMEDOUT;
 68			if (n > 0 && !(pfds[0].revents & POLLIN)) {
 69				errno = EIO;
 70				n = -1;
 71			}
 72			if (n <= 0) {
 73				io->eof = true;
 74				return -1;
 75			}
 76		}
 77		n = read(io->fd, io->buf, io->buf_len);
 78
 79		if (n <= 0) {
 80			io->eof = true;
 81			return -1;
 82		}
 83		ptr = &io->buf[0];
 84		io->end = &io->buf[n];
 85	}
 86	io->data = ptr + 1;
 87	return *ptr;
 88}
 89
 90/* Read a hexadecimal value with no 0x prefix into the out argument hex. If the
 91 * first character isn't hexadecimal returns -2, io->eof returns -1, otherwise
 92 * returns the character after the hexadecimal value which may be -1 for eof.
 93 * If the read value is larger than a u64 the high-order bits will be dropped.
 94 */
 95static inline int io__get_hex(struct io *io, __u64 *hex)
 96{
 97	bool first_read = true;
 98
 99	*hex = 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			*hex = (*hex << 4) | (ch - '0');
107		else if (ch >= 'a' && ch <= 'f')
108			*hex = (*hex << 4) | (ch - 'a' + 10);
109		else if (ch >= 'A' && ch <= 'F')
110			*hex = (*hex << 4) | (ch - 'A' + 10);
111		else if (first_read)
112			return -2;
113		else
114			return ch;
115		first_read = false;
116	}
117}
118
119/* Read a positive decimal value with out argument dec. If the first character
120 * isn't a decimal returns -2, io->eof returns -1, otherwise returns the
121 * character after the decimal value which may be -1 for eof. If the read value
122 * is larger than a u64 the high-order bits will be dropped.
123 */
124static inline int io__get_dec(struct io *io, __u64 *dec)
125{
126	bool first_read = true;
127
128	*dec = 0;
129	while (true) {
130		int ch = io__get_char(io);
131
132		if (ch < 0)
133			return ch;
134		if (ch >= '0' && ch <= '9')
135			*dec = (*dec * 10) + ch - '0';
136		else if (first_read)
137			return -2;
138		else
139			return ch;
140		first_read = false;
141	}
142}
143
144/* Read up to and including the first delim. */
145static inline ssize_t io__getdelim(struct io *io, char **line_out, size_t *line_len_out, int delim)
146{
147	char buf[128];
148	int buf_pos = 0;
149	char *line = NULL, *temp;
150	size_t line_len = 0;
151	int ch = 0;
152
153	/* TODO: reuse previously allocated memory. */
154	free(*line_out);
155	while (ch != delim) {
156		ch = io__get_char(io);
157
158		if (ch < 0)
159			break;
160
161		if (buf_pos == sizeof(buf)) {
162			temp = realloc(line, line_len + sizeof(buf));
163			if (!temp)
164				goto err_out;
165			line = temp;
166			memcpy(&line[line_len], buf, sizeof(buf));
167			line_len += sizeof(buf);
168			buf_pos = 0;
169		}
170		buf[buf_pos++] = (char)ch;
171	}
172	temp = realloc(line, line_len + buf_pos + 1);
173	if (!temp)
174		goto err_out;
175	line = temp;
176	memcpy(&line[line_len], buf, buf_pos);
177	line[line_len + buf_pos] = '\0';
178	line_len += buf_pos;
179	*line_out = line;
180	*line_len_out = line_len;
181	return line_len;
182err_out:
183	free(line);
184	*line_out = NULL;
185	return -ENOMEM;
186}
187
188static inline ssize_t io__getline(struct io *io, char **line_out, size_t *line_len_out)
189{
190	return io__getdelim(io, line_out, line_len_out, /*delim=*/'\n');
191}
192
193#endif /* __API_IO__ */

  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
 13struct 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
 28static 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. */
 40static 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 */
 66static 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 */
 95static 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__ */