| /* |
| * ***************************************************************************** |
| * |
| * SPDX-License-Identifier: BSD-2-Clause |
| * |
| * Copyright (c) 2018-2020 Gavin D. Howard and contributors. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| * |
| * ***************************************************************************** |
| * |
| * Code to handle special I/O for bc. |
| * |
| */ |
| |
| #include <assert.h> |
| #include <ctype.h> |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <signal.h> |
| |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| |
| #include "read.h" |
| #include "history.h" |
| #include "program.h" |
| #include "vm.h" |
| |
| static bool bc_read_binary(const char *buf, size_t size) { |
| |
| size_t i; |
| |
| for (i = 0; i < size; ++i) { |
| if (BC_ERR(BC_READ_BIN_CHAR(buf[i]))) return true; |
| } |
| |
| return false; |
| } |
| |
| bool bc_read_buf(BcVec *vec, char *buf, size_t *buf_len) { |
| |
| char *nl; |
| |
| if (!*buf_len) return false; |
| |
| nl = strchr(buf, '\n'); |
| |
| if (nl != NULL) { |
| |
| size_t nllen = (size_t) ((nl + 1) - buf); |
| |
| nllen = *buf_len >= nllen ? nllen : *buf_len; |
| |
| bc_vec_npush(vec, nllen, buf); |
| *buf_len -= nllen; |
| memmove(buf, nl + 1, *buf_len + 1); |
| |
| return true; |
| } |
| |
| bc_vec_npush(vec, *buf_len, buf); |
| *buf_len = 0; |
| |
| return false; |
| } |
| |
| BcStatus bc_read_chars(BcVec *vec, const char *prompt) { |
| |
| bool done = false; |
| |
| assert(vec != NULL && vec->size == sizeof(char)); |
| |
| BC_SIG_ASSERT_NOT_LOCKED; |
| |
| bc_vec_npop(vec, vec->len); |
| |
| #if BC_ENABLE_PROMPT |
| if (BC_USE_PROMPT) { |
| bc_file_puts(&vm.fout, prompt); |
| bc_file_flush(&vm.fout); |
| } |
| #endif // BC_ENABLE_PROMPT |
| |
| if (bc_read_buf(vec, vm.buf, &vm.buf_len)) { |
| bc_vec_pushByte(vec, '\0'); |
| return BC_STATUS_SUCCESS; |
| } |
| |
| while (!done) { |
| |
| ssize_t r; |
| |
| BC_SIG_LOCK; |
| |
| r = read(STDIN_FILENO, vm.buf + vm.buf_len, |
| BC_VM_STDIN_BUF_SIZE - vm.buf_len); |
| |
| if (BC_UNLIKELY(r < 0)) { |
| |
| if (errno == EINTR) { |
| |
| if (vm.status == (sig_atomic_t) BC_STATUS_QUIT) { |
| BC_SIG_UNLOCK; |
| return BC_STATUS_QUIT; |
| } |
| |
| assert(vm.sig); |
| |
| vm.status = (sig_atomic_t) BC_STATUS_SUCCESS; |
| #if BC_ENABLE_PROMPT |
| if (BC_USE_PROMPT) bc_file_puts(&vm.fout, prompt); |
| #endif // BC_ENABLE_PROMPT |
| bc_file_flush(&vm.fout); |
| |
| BC_SIG_UNLOCK; |
| |
| continue; |
| } |
| |
| BC_SIG_UNLOCK; |
| |
| bc_vm_err(BC_ERROR_FATAL_IO_ERR); |
| } |
| |
| BC_SIG_UNLOCK; |
| |
| if (r == 0) { |
| bc_vec_pushByte(vec, '\0'); |
| return BC_STATUS_EOF; |
| } |
| |
| vm.buf_len += (size_t) r; |
| vm.buf[vm.buf_len] = '\0'; |
| |
| done = bc_read_buf(vec, vm.buf, &vm.buf_len); |
| } |
| |
| bc_vec_pushByte(vec, '\0'); |
| |
| return BC_STATUS_SUCCESS; |
| } |
| |
| BcStatus bc_read_line(BcVec *vec, const char *prompt) { |
| |
| BcStatus s; |
| |
| #if BC_ENABLE_HISTORY |
| if (BC_TTY && !vm.history.badTerm) |
| s = bc_history_line(&vm.history, vec, prompt); |
| else s = bc_read_chars(vec, prompt); |
| #else // BC_ENABLE_HISTORY |
| s = bc_read_chars(vec, prompt); |
| #endif // BC_ENABLE_HISTORY |
| |
| if (BC_ERR(bc_read_binary(vec->v, vec->len - 1))) |
| bc_vm_verr(BC_ERROR_FATAL_BIN_FILE, bc_program_stdin_name); |
| |
| return s; |
| } |
| |
| void bc_read_file(const char *path, char **buf) { |
| |
| BcError e = BC_ERROR_FATAL_IO_ERR; |
| size_t size, r; |
| struct stat pstat; |
| int fd; |
| |
| BC_SIG_ASSERT_LOCKED; |
| |
| assert(path != NULL); |
| |
| fd = open(path, O_RDONLY); |
| if (BC_ERR(fd < 0)) bc_vm_verr(BC_ERROR_FATAL_FILE_ERR, path); |
| if (BC_ERR(fstat(fd, &pstat) == -1)) goto malloc_err; |
| |
| if (BC_ERR(S_ISDIR(pstat.st_mode))) { |
| e = BC_ERROR_FATAL_PATH_DIR; |
| goto malloc_err; |
| } |
| |
| size = (size_t) pstat.st_size; |
| *buf = bc_vm_malloc(size + 1); |
| |
| r = (size_t) read(fd, *buf, size); |
| if (BC_ERR(r != size)) goto read_err; |
| |
| (*buf)[size] = '\0'; |
| |
| if (BC_ERR(bc_read_binary(*buf, size))) { |
| e = BC_ERROR_FATAL_BIN_FILE; |
| goto read_err; |
| } |
| |
| close(fd); |
| |
| return; |
| |
| read_err: |
| free(*buf); |
| malloc_err: |
| close(fd); |
| bc_vm_verr(e, path); |
| } |