/* Reads the file from the current position to the end into a string. */ static MVMString * slurp(MVMThreadContext *tc, MVMOSHandle *h) { MVMIOFileData *data = (MVMIOFileData *)h->body.data; uv_fs_t req; ensure_decode_stream(tc, data); /* Typically we're slurping an entire file, so just request the bytes * until the end; repeat to ensure we get 'em all. */ if (uv_fs_fstat(tc->loop, &req, data->fd, NULL) < 0) { MVM_exception_throw_adhoc(tc, "slurp from filehandle failed: %s", uv_strerror(req.result)); } /* Sometimes - usually for special files like those in /proc - the file * size comes up 0, even though the S_ISREG test succeeds. So in that case * we try a small read and switch to a "read chunks until EOF" impl. * Otherwise we just read the exact size of the file. */ if (req.statbuf.st_size == 0) { if (read_to_buffer(tc, data, 32) > 0) { while (read_to_buffer(tc, data, 4096) > 0) ; } } else { while (read_to_buffer(tc, data, req.statbuf.st_size) > 0) ; } return MVM_string_decodestream_get_all(tc, data->ds); }
UniversalContainer uc_from_json_file(const char* fname) { Buffer* buf = read_to_buffer(fname); UniversalContainer uc = uc_decode_json(buf); delete buf; return uc; }
static void do_test_libeprom24x(void) { int value; do { print_menu(); printf("Enter choice : "); scanf("%d",&value); switch(value) { case 1: get_prod_info(); break; case 2: get_last_error(); break; case 3: initialize(); break; case 4: finalize(); break; case 5: read_u8(); break; case 6: read_u16(); break; case 7: read_u32(); break; case 8: read_to_buffer(); break; case 9: write_u8(); break; case 10: write_u16(); break; case 11: write_u32(); break; case 12: write_from_buffer(); break; case 13: erase_chip(); break; case 100: /* Exit */ break; default: printf("Illegal choice!\n"); } } while (value != 100); return; }
int read_file(ino iNode, char *buffer, int offset, int numbytes) { char iNodeDataBlock[BLOCK_SIZE]; int linesRead = -2; if (iNode < 16) { ReadBlock(4, iNodeDataBlock); iNodeEntry *iNodes = (iNodeEntry *)iNodeDataBlock; linesRead = read_to_buffer(iNodes[iNode], buffer, offset, numbytes); } else { ReadBlock(5, iNodeDataBlock); iNodeEntry *iNodes = (iNodeEntry *)iNodeDataBlock; linesRead = read_to_buffer(iNodes[iNode - 16], buffer, offset, numbytes); } return linesRead; }
UniversalContainer load_ini_file(const char* filename) { UniversalContainer uc; Buffer* buf = read_to_buffer(filename); if (!buf) return uc; uc = uc_decode_ini(buf); delete buf; return uc; }
/* Reads the stream from the current position to the end into a string, * fetching as much data is available. */ MVMString * MVM_io_syncstream_slurp(MVMThreadContext *tc, MVMOSHandle *h) { MVMIOSyncStreamData *data = (MVMIOSyncStreamData *)h->body.data; ensure_decode_stream(tc, data); /* Fetch as much data as we can (XXX this can be more efficient, by * passing on down that we want to get many buffers from libuv). */ while (read_to_buffer(tc, data, CHUNK_SIZE)) ; return MVM_string_decodestream_get_all(tc, data->ds); }
/* Reads the specified number of bytes into a the supplied buffer, returing * the number actually read. */ MVMint64 MVM_io_syncstream_read_bytes(MVMThreadContext *tc, MVMOSHandle *h, char **buf, MVMint64 bytes) { MVMIOSyncStreamData *data = (MVMIOSyncStreamData *)h->body.data; ensure_decode_stream(tc, data); /* See if we've already enough; if not, try and grab more. */ if (!MVM_string_decodestream_have_bytes(tc, data->ds, bytes)) read_to_buffer(tc, data, bytes > CHUNK_SIZE ? bytes : CHUNK_SIZE); /* Read as many as we can, up to the limit. */ return MVM_string_decodestream_bytes_to_buf(tc, data->ds, buf, bytes); }
/* Reads the specified number of bytes into a the supplied buffer, returing * the number actually read. */ static MVMint64 read_bytes(MVMThreadContext *tc, MVMOSHandle *h, char **buf, MVMint64 bytes) { MVMIOFileData *data = (MVMIOFileData *)h->body.data; ensure_decode_stream(tc, data); /* Keep requesting bytes until we have enough in the buffer or we hit * end of file. */ while (!MVM_string_decodestream_have_bytes(tc, data->ds, bytes)) { if (read_to_buffer(tc, data, bytes) <= 0) break; } /* Read as many as we can, up to the limit. */ return MVM_string_decodestream_bytes_to_buf(tc, data->ds, buf, bytes); }
/* Gets the specified number of characters from the file. */ static MVMString * read_chars(MVMThreadContext *tc, MVMOSHandle *h, MVMint64 chars) { MVMIOFileData *data = (MVMIOFileData *)h->body.data; ensure_decode_stream(tc, data); /* Pull data until we can read the chars we want. */ do { MVMString *result = MVM_string_decodestream_get_chars(tc, data->ds, chars); if (result != NULL) return result; } while (read_to_buffer(tc, data, CHUNK_SIZE) > 0); /* Reached end of file, so just take what we have. */ return MVM_string_decodestream_get_all(tc, data->ds); }
/* Reads the file from the current position to the end into a string. */ static MVMString * slurp(MVMThreadContext *tc, MVMOSHandle *h) { MVMIOFileData *data = (MVMIOFileData *)h->body.data; uv_fs_t req; ensure_decode_stream(tc, data); /* Typically we're slurping an entire file, so just request the bytes * until the end; repeat to ensure we get 'em all. */ if (uv_fs_fstat(tc->loop, &req, data->fd, NULL) < 0) { MVM_exception_throw_adhoc(tc, "slurp from filehandle failed: %s", uv_strerror(req.result)); } while (read_to_buffer(tc, data, req.statbuf.st_size) > 0) ; return MVM_string_decodestream_get_all(tc, data->ds); }
/* Reads a single line from the file handle. May serve it from a buffer, if we * already read enough data. */ static MVMString * read_line(MVMThreadContext *tc, MVMOSHandle *h) { MVMIOFileData *data = (MVMIOFileData *)h->body.data; ensure_decode_stream(tc, data); /* Pull data until we can read a line. */ do { MVMString *line = MVM_string_decodestream_get_until_sep(tc, data->ds, data->sep); if (line != NULL) return line; } while (read_to_buffer(tc, data, CHUNK_SIZE) > 0); /* Reached end of file, or last (non-termianted) line. */ return MVM_string_decodestream_get_all(tc, data->ds); }
/* Gets the specified number of characters from the stream. */ MVMString * MVM_io_syncstream_read_chars(MVMThreadContext *tc, MVMOSHandle *h, MVMint64 chars) { MVMIOSyncStreamData *data = (MVMIOSyncStreamData *)h->body.data; MVMString *result; ensure_decode_stream(tc, data); /* Do we already have the chars available? */ result = MVM_string_decodestream_get_chars(tc, data->ds, chars); if (result) { return result; } else { /* No; read and try again. */ read_to_buffer(tc, data, CHUNK_SIZE); result = MVM_string_decodestream_get_chars(tc, data->ds, chars); if (result != NULL) return result; } /* Fetched all we immediately can, so just take what we have. */ return MVM_string_decodestream_get_all(tc, data->ds); }
void assert_last_line (HANDLE h_stream, const char *starts_with) { char buffer[4096]; char *c = buffer, *last_line_position = c; read_to_buffer (h_stream, (char **)&buffer, 4096); while (1) { for (; *c != '\r' && *c != '\n' && *c != 0; c++); if (*c == 0 || *(c+1) == 0 || *(c+2) == 0) break; c ++; last_line_position = c; }; if (strncmp (last_line_position, starts_with, strlen (starts_with))) rpc_log_error ("tester: assert_last_line: '%s'", buffer); }
void dump (HANDLE h_stream) { char buffer[4096]; read_to_buffer (h_stream, (char **)&buffer, 4095); printf ("%s", buffer); }
void run_log_forwarder(struct fd_pair *internal, struct fd_pair *input, struct fd_pair *output, struct fd_pair *error, int interactive) { int i; fd_set read_set; fd_set write_set; struct timeval timeout; int stdin_open = 1; int stdout_open = 1; int stderr_open = 1; int internal_open = 1; int input_open = 1; int output_open = 1; int error_open = error ? 1 : 0; int max_fd = internal->write_side; if (input->write_side > max_fd) max_fd = input->write_side; if (output->read_side > max_fd) max_fd = output->read_side; if (error_open && error->read_side > max_fd) max_fd = error->read_side; max_fd++; reserve = NULL; struct list internal_buffer = {NULL, NULL}; struct list input_buffer = {NULL, NULL}; struct list stdout_buffer = {NULL, NULL}; struct list stderr_buffer = {NULL, NULL}; /* non-blocking read/write */ int flags = fcntl(STDIN_FILENO, F_GETFL, 0); fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK); flags = fcntl(STDOUT_FILENO, F_GETFL, 0); fcntl(STDOUT_FILENO, F_SETFL, flags | O_NONBLOCK); flags = fcntl(STDERR_FILENO, F_GETFL, 0); fcntl(STDERR_FILENO, F_SETFL, flags | O_NONBLOCK); flags = fcntl(internal->write_side, F_GETFL, 0); fcntl(internal->write_side, F_SETFL, flags | O_NONBLOCK); flags = fcntl(input->write_side, F_GETFL, 0); fcntl(input->write_side, F_SETFL, flags | O_NONBLOCK); flags = fcntl(output->read_side, F_GETFL, 0); fcntl(output->read_side, F_SETFL, flags | O_NONBLOCK); if (error_open) { flags = fcntl(error->read_side, F_GETFL, 0); fcntl(error->read_side, F_SETFL, flags | O_NONBLOCK); } /* as long as there is a parent process and something to read */ while (getppid() > 1 && (output_open || error_open)) { /* prepare read set */ FD_ZERO(&read_set); if (stdin_open) FD_SET(STDIN_FILENO, &read_set); if (output_open) FD_SET(output->read_side, &read_set); if (error_open) FD_SET(error->read_side, &read_set); /* prepare write set */ FD_ZERO(&write_set); if (internal_buffer.head && internal_open) FD_SET(internal->write_side, &write_set); if (input_buffer.head && input_open) FD_SET(input->write_side, &write_set); if (stdout_buffer.head && stdout_open) FD_SET(STDOUT_FILENO, &write_set); if (stderr_buffer.head && stderr_open) FD_SET(STDERR_FILENO, &write_set); /* timeout to avoid hanging processes if PPID changes to 1 between getppid and select */ timeout.tv_sec = 300; timeout.tv_usec = 0; /* what to do */ int result = select(max_fd, &read_set, &write_set, NULL, &timeout); /* error handling */ if (result < 0) { if (EINTR == errno) continue; perror("select"); break; } /* timeout */ else if (0 == result) { continue; } /* non-blocking write */ if (FD_ISSET(input->write_side, &write_set)) { input_open = write_from_buffer(input->write_side, &input_buffer, 0); } if (FD_ISSET(STDERR_FILENO, &write_set)) { stderr_open = write_from_buffer(STDERR_FILENO, &stderr_buffer, 0); } if (FD_ISSET(STDOUT_FILENO, &write_set)) { stdout_open = write_from_buffer(STDOUT_FILENO, &stdout_buffer, 0); } if (FD_ISSET(internal->write_side, &write_set)) { internal_open = write_from_buffer(internal->write_side, &internal_buffer, 1); } /* non-blocking read */ if (FD_ISSET(STDIN_FILENO, &read_set)) { stdin_open = read_to_buffer(STDIN_FILENO, &input_buffer, (internal_open && !interactive) ? &internal_buffer : NULL); } if (error_open && FD_ISSET(error->read_side, &read_set)) { error_open = read_to_buffer(error->read_side, &stderr_buffer, internal_open ? &internal_buffer : NULL); } if (FD_ISSET(output->read_side, &read_set)) { output_open = read_to_buffer(output->read_side, &stdout_buffer, internal_open ? &internal_buffer : NULL); } /* propagate closed input */ if (!stdin_open && !input_buffer.head && input_open) { close(input->write_side); input_open = 0; } } /* do we have something left out for writing? (reset to blocking mode before writing) */ flags = fcntl(STDERR_FILENO, F_GETFL, 0); fcntl(STDERR_FILENO, F_SETFL, flags & (~O_NONBLOCK)); flags = fcntl(STDOUT_FILENO, F_GETFL, 0); fcntl(STDOUT_FILENO, F_SETFL, flags & (~O_NONBLOCK)); flags = fcntl(internal->write_side, F_GETFL, 0); fcntl(internal->write_side, F_SETFL, flags & (~O_NONBLOCK)); while (stderr_buffer.head) { write_from_buffer(STDERR_FILENO, &stderr_buffer, 0); } while (stdout_buffer.head) { write_from_buffer(STDOUT_FILENO, &stdout_buffer, 0); } while (internal_open && internal_buffer.head) { internal_open = write_from_buffer(internal->write_side, &internal_buffer, 1); } /* still some input? Write it out immediately 1:1*/ if (internal_open) { while (error_open && read_to_buffer(error->read_side, &stderr_buffer, &internal_buffer)) { write_from_buffer(STDERR_FILENO, &stderr_buffer, 0); write_from_buffer(internal->write_side, &internal_buffer, 1); } while (read_to_buffer(output->read_side, &stdout_buffer, &internal_buffer)) { write_from_buffer(STDOUT_FILENO, &stdout_buffer, 0); write_from_buffer(internal->write_side, &internal_buffer, 1); } } else { while (error_open && read_to_buffer(error->read_side, &stderr_buffer, NULL)) { write_from_buffer(STDERR_FILENO, &stderr_buffer, 0); } while (read_to_buffer(output->read_side, &stdout_buffer, NULL)) { write_from_buffer(STDOUT_FILENO, &stdout_buffer, 0); } } /* final cleanup */ if (NULL != reserve) { free(reserve); } }