static struct io_plan *read_done(struct io_conn *conn, struct data *d)
{
tal_resize(&d->pattern, tal_count(d->pattern) + 1 + strlen(d->buf));
strcat(d->pattern, "<");
strcat(d->pattern, d->buf);
return read_more(conn, d);
}
static char next_char(state * st) {
if (st->offset == st->fill) {
st->fill = 0;
st->offset = 0;
read_more(st);
}
return st->buf[st->offset++];
}
int
hstcpcli::response_recv(size_t& num_flds_r)
{
if (error_code < 0) {
return error_code;
}
clear_error();
if (num_req_bufd > 0 || num_req_sent == 0 || num_req_rcvd > 0 ||
response_end_offset != 0) {
close();
return set_error(-1, "response_recv: protocol out of sync");
}
cur_row_offset = 0;
num_flds_r = num_flds = 0;
if (fd.get() < 0) {
return set_error(-1, "read: closed");
}
size_t offset = 0;
while (true) {
const char *const lbegin = readbuf.begin() + offset;
const char *const lend = readbuf.end();
const char *const nl = memchr_char(lbegin, '\n', lend - lbegin);
if (nl != 0) {
offset = (nl + 1) - readbuf.begin();
break;
}
if (read_more() <= 0) {
close();
return set_error(-1, "read: eof");
}
}
response_end_offset = offset;
--num_req_sent;
++num_req_rcvd;
char *start = readbuf.begin();
char *const finish = start + response_end_offset - 1;
const size_t resp_code = read_ui32(start, finish);
skip_one(start, finish);
num_flds_r = num_flds = read_ui32(start, finish);
if (resp_code != 0) {
skip_one(start, finish);
char *const err_begin = start;
read_token(start, finish);
char *const err_end = start;
std::string e = std::string(err_begin, err_end - err_begin);
if (e.empty()) {
e = "unknown_error";
}
return set_error(resp_code, e);
}
cur_row_offset = start - readbuf.begin();
DBG(fprintf(stderr, "[%s] ro=%zu eol=%zu\n",
std::string(readbuf.begin(), readbuf.begin() + response_end_offset)
.c_str(),
cur_row_offset, response_end_offset));
DBG(fprintf(stderr, "RES 0\n"));
return 0;
}
static bool read_from_buffer(struct seekable_istream *sstream, ssize_t *ret_r)
{
struct istream_private *stream = &sstream->istream;
const unsigned char *data;
size_t size, avail_size;
if (stream->pos < sstream->buffer_peak) {
/* This could be the first read() or we could have already
seeked backwards. */
i_assert(stream->pos == 0 && stream->skip == 0);
stream->skip = stream->istream.v_offset;
stream->pos = sstream->buffer_peak;
size = stream->pos - stream->skip;
} else {
/* need to read more */
i_assert(stream->pos == sstream->buffer_peak);
size = sstream->cur_input == NULL ? 0 :
i_stream_get_data_size(sstream->cur_input);
if (size == 0) {
/* read more to buffer */
*ret_r = read_more(sstream);
if (*ret_r == 0 || *ret_r == -1)
return TRUE;
}
/* we should have more now. */
data = i_stream_get_data(sstream->cur_input, &size);
i_assert(size > 0);
/* change skip to 0 temporarily so i_stream_try_alloc() won't try to
compress the buffer. */
size_t old_skip = stream->skip;
stream->skip = 0;
bool have_space = i_stream_try_alloc(stream, size, &avail_size);
stream->skip = old_skip;
if (!have_space)
return FALSE;
if (size > avail_size)
size = avail_size;
memcpy(stream->w_buffer + stream->pos, data, size);
stream->pos += size;
sstream->buffer_peak += size;
i_stream_skip(sstream->cur_input, size);
}
*ret_r = size;
i_assert(*ret_r > 0);
return TRUE;
}
static isc_result_t
read_one_line(perf_datafile_t *dfile, isc_buffer_t *lines)
{
const char *cur;
unsigned int length, curlen, nrem;
isc_result_t result;
while (ISC_TRUE) {
/* Get the current line */
cur = isc_buffer_current(&dfile->data);
curlen = strcspn(cur, "\n");
/*
* If the current line contains the rest of the buffer,
* we need to read more (unless the full file is cached).
*/
nrem = isc_buffer_remaininglength(&dfile->data);
if (curlen == nrem) {
if (! dfile->cached) {
result = read_more(dfile);
if (result != ISC_R_SUCCESS)
return (result);
}
if (isc_buffer_remaininglength(&dfile->data) == 0) {
dfile->nruns++;
return (ISC_R_EOF);
}
if (isc_buffer_remaininglength(&dfile->data) > nrem)
continue;
}
/* We now have a line. Advance the buffer past it. */
isc_buffer_forward(&dfile->data, curlen);
if (isc_buffer_remaininglength(&dfile->data) > 0)
isc_buffer_forward(&dfile->data, 1);
/* If the line is empty or a comment, we need to try again. */
if (curlen > 0 && cur[0] != ';')
break;
}
length = isc_buffer_availablelength(lines);
if (curlen > length - 1)
curlen = length - 1;
isc_buffer_putmem(lines, cur, curlen);
isc_buffer_putuint8(lines, 0);
return (ISC_R_SUCCESS);
}
int main(int argc, char **argv) {
void *pattern = objpath_compile(argv[1]);
msgpack_unpacker pac;
msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE);
msgpack_unpacked result;
msgpack_unpacked_init(&result);
while(1) {
int rc = read_more(&pac);
if(!rc) break;
while(msgpack_unpacker_next(&pac, &result)) {
match(&result.data, pattern);
}
}
return 0;
}
/* Documented in io.h */
int
lsi_io_read(sckhld sh, struct readctx *rctx, tokarr *tok, uint64_t to_us)
{
uint64_t tend = to_us ? lsi_b_tstamp_us() + to_us : 0;
uint64_t tnow, trem = 0;
V("Wanna read with%s timeout (%"PRIu64"). %zu bytes in buffer: '%.*s'",
tend?"":" no", to_us, rctx->eptr - rctx->wptr,
(int)(rctx->eptr - rctx->wptr), rctx->wptr);
while (rctx->wptr < rctx->eptr && ISDELIM(*rctx->wptr))
rctx->wptr++; /* skip leading line delimiters */
if (rctx->wptr == rctx->eptr) { /* empty buffer, use the opportunity.. */
rctx->wptr = rctx->eptr = rctx->workbuf;
V("Opportunistical buffer reset");
}
size_t linelen;
char *delim;
char *linestart;
do {
while (!(delim = find_delim(rctx))) {
if (tend) {
tnow = lsi_b_tstamp_us();
trem = tnow >= tend ? 1 : tend - tnow;
}
int r = read_more(sh, rctx, trem);
if (r <= 0)
return r;
}
linestart = rctx->wptr;
linelen = delim - linestart;
rctx->wptr++;
V("Delim found, linelen %zu", linelen);
} while (linelen == 0);
rctx->wptr += linelen;
*delim = '\0';
I("Read: '%s'", linestart);
return lsi_ut_tokenize(linestart, tok) ? 1 : -1;
}
inline uint32_t getu32()
{
if (rlim - rpos < 12)
rpos = read_more(rpos);
uint32_t v;
do {
v = rnextf() - '0';
} while (v >= D);
uint32_t res = v;
for (;;) {
v = rnextf() - '0';
if (v >= D)
break;
res = res * D + v;
}
return res;
}
static bool read_from_buffer(struct seekable_istream *sstream, ssize_t *ret_r)
{
struct istream_private *stream = &sstream->istream;
const unsigned char *data;
size_t size, pos, offset;
i_assert(stream->skip == 0);
if (stream->istream.v_offset + stream->pos >= sstream->membuf->used) {
/* need to read more */
if (sstream->membuf->used >= stream->max_buffer_size)
return FALSE;
size = sstream->cur_input == NULL ? 0 :
i_stream_get_data_size(sstream->cur_input);
if (size == 0) {
/* read more to buffer */
*ret_r = read_more(sstream);
if (*ret_r == 0 || *ret_r == -1)
return TRUE;
}
/* we should have more now. */
data = i_stream_get_data(sstream->cur_input, &size);
i_assert(size > 0);
buffer_append(sstream->membuf, data, size);
i_stream_skip(sstream->cur_input, size);
}
offset = stream->istream.v_offset;
stream->buffer = CONST_PTR_OFFSET(sstream->membuf->data, offset);
pos = sstream->membuf->used - offset;
*ret_r = pos - stream->pos;
i_assert(*ret_r > 0);
stream->pos = pos;
return TRUE;
}
void SuifEnv::read( const String& inputFileName ) {
FileSetBlock *file_set_block = read_more(inputFileName);
delete (SuifObject *)_file_set_block;
_file_set_block = file_set_block;
}
/* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated
with this ino. Perform a preliminary ordering on data nodes, throwing away
those which are completely obsoleted by newer ones. The naïve approach we
use to take of just returning them _all_ in version order will cause us to
run out of memory in certain degenerate cases. */
static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
struct jffs2_readinode_info *rii)
{
struct jffs2_raw_node_ref *ref, *valid_ref;
unsigned char *buf = NULL;
union jffs2_node_union *node;
size_t retlen;
int len, err;
rii->mctime_ver = 0;
dbg_readinode("ino #%u\n", f->inocache->ino);
/* FIXME: in case of NOR and available ->point() this
* needs to be fixed. */
len = sizeof(union jffs2_node_union) + c->wbuf_pagesize;
buf = kmalloc(len, GFP_KERNEL);
if (!buf)
return -ENOMEM;
spin_lock(&c->erase_completion_lock);
valid_ref = jffs2_first_valid_node(f->inocache->nodes);
if (!valid_ref && f->inocache->ino != 1)
JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino);
while (valid_ref) {
/* We can hold a pointer to a non-obsolete node without the spinlock,
but _obsolete_ nodes may disappear at any time, if the block
they're in gets erased. So if we mark 'ref' obsolete while we're
not holding the lock, it can go away immediately. For that reason,
we find the next valid node first, before processing 'ref'.
*/
ref = valid_ref;
valid_ref = jffs2_first_valid_node(ref->next_in_ino);
spin_unlock(&c->erase_completion_lock);
cond_resched();
/*
* At this point we don't know the type of the node we're going
* to read, so we do not know the size of its header. In order
* to minimize the amount of flash IO we assume the header is
* of size = JFFS2_MIN_NODE_HEADER.
*/
len = JFFS2_MIN_NODE_HEADER;
if (jffs2_is_writebuffered(c)) {
int end, rem;
/*
* We are about to read JFFS2_MIN_NODE_HEADER bytes,
* but this flash has some minimal I/O unit. It is
* possible that we'll need to read more soon, so read
* up to the next min. I/O unit, in order not to
* re-read the same min. I/O unit twice.
*/
end = ref_offset(ref) + len;
rem = end % c->wbuf_pagesize;
if (rem)
end += c->wbuf_pagesize - rem;
len = end - ref_offset(ref);
}
dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref));
/* FIXME: point() */
err = jffs2_flash_read(c, ref_offset(ref), len, &retlen, buf);
if (err) {
JFFS2_ERROR("can not read %d bytes from 0x%08x, " "error code: %d.\n", len, ref_offset(ref), err);
goto free_out;
}
if (retlen < len) {
JFFS2_ERROR("short read at %#08x: %zu instead of %d.\n", ref_offset(ref), retlen, len);
err = -EIO;
goto free_out;
}
node = (union jffs2_node_union *)buf;
/* No need to mask in the valid bit; it shouldn't be invalid */
if (je32_to_cpu(node->u.hdr_crc) != crc32(0, node, sizeof(node->u)-4)) {
JFFS2_NOTICE("Node header CRC failed at %#08x. {%04x,%04x,%08x,%08x}\n",
ref_offset(ref), je16_to_cpu(node->u.magic),
je16_to_cpu(node->u.nodetype),
je32_to_cpu(node->u.totlen),
je32_to_cpu(node->u.hdr_crc));
jffs2_dbg_dump_node(c, ref_offset(ref));
jffs2_mark_node_obsolete(c, ref);
goto cont;
}
if (je16_to_cpu(node->u.magic) != JFFS2_MAGIC_BITMASK) {
/* Not a JFFS2 node, whinge and move on */
JFFS2_NOTICE("Wrong magic bitmask 0x%04x in node header at %#08x.\n",
je16_to_cpu(node->u.magic), ref_offset(ref));
jffs2_mark_node_obsolete(c, ref);
goto cont;
}
switch (je16_to_cpu(node->u.nodetype)) {
case JFFS2_NODETYPE_DIRENT:
if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent) &&
len < sizeof(struct jffs2_raw_dirent)) {
err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf);
if (unlikely(err))
goto free_out;
}
err = read_direntry(c, ref, &node->d, retlen, rii);
if (unlikely(err))
goto free_out;
break;
case JFFS2_NODETYPE_INODE:
if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode) &&
len < sizeof(struct jffs2_raw_inode)) {
err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf);
if (unlikely(err))
goto free_out;
}
err = read_dnode(c, ref, &node->i, len, rii);
if (unlikely(err))
goto free_out;
break;
default:
if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node) &&
len < sizeof(struct jffs2_unknown_node)) {
err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf);
if (unlikely(err))
goto free_out;
}
err = read_unknown(c, ref, &node->u);
if (unlikely(err))
goto free_out;
}
cont:
spin_lock(&c->erase_completion_lock);
}
spin_unlock(&c->erase_completion_lock);
kfree(buf);
f->highest_version = rii->highest_version;
dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n",
f->inocache->ino, rii->highest_version, rii->latest_mctime,
rii->mctime_ver);
return 0;
free_out:
jffs2_free_tmp_dnode_info_list(&rii->tn_root);
jffs2_free_full_dirent_list(rii->fds);
rii->fds = NULL;
kfree(buf);
return err;
}
int main(int argc, char* argv[]) {
jq_state *jq = NULL;
int ret = 0;
int compiled = 0;
char *t = NULL;
if (argc) progname = argv[0];
if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
return jq_testsuite(argc, argv);
}
jq = jq_init();
if (jq == NULL) {
perror("malloc");
ret = 2;
goto out;
}
const char* program = 0;
input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
ninput_files = 0;
int further_args_are_files = 0;
int jq_flags = 0;
size_t short_opts = 0;
jv program_arguments = jv_array();
jv lib_search_paths = jv_array();
for (int i=1; i<argc; i++, short_opts = 0) {
if (further_args_are_files) {
input_filenames[ninput_files++] = argv[i];
} else if (!strcmp(argv[i], "--")) {
if (!program) usage(2);
further_args_are_files = 1;
} else if (!isoptish(argv[i])) {
if (program) {
input_filenames[ninput_files++] = argv[i];
} else {
program = argv[i];
}
} else {
if (argv[i][1] == 'L') {
if (argv[i][2] != 0) { // -Lname (faster check than strlen)
lib_search_paths = jv_array_append(lib_search_paths, jv_string(argv[i]+2));
} else if (i >= argc - 1) {
fprintf(stderr, "-L takes a parameter: (e.g. -L /search/path or -L/search/path)\n");
die();
} else {
lib_search_paths = jv_array_append(lib_search_paths, jv_string(argv[i+1]));
i++;
}
continue;
}
if (isoption(argv[i], 's', "slurp", &short_opts)) {
options |= SLURP;
if (!short_opts) continue;
}
if (isoption(argv[i], 'r', "raw-output", &short_opts)) {
options |= RAW_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'c', "compact-output", &short_opts)) {
options |= COMPACT_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'C', "color-output", &short_opts)) {
options |= COLOUR_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'M', "monochrome-output", &short_opts)) {
options |= NO_COLOUR_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'a', "ascii-output", &short_opts)) {
options |= ASCII_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "unbuffered", &short_opts)) {
options |= UNBUFFERED_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'S', "sort-keys", &short_opts)) {
options |= SORTED_OUTPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'R', "raw-input", &short_opts)) {
options |= RAW_INPUT;
if (!short_opts) continue;
}
if (isoption(argv[i], 'n', "null-input", &short_opts)) {
options |= PROVIDE_NULL;
if (!short_opts) continue;
}
if (isoption(argv[i], 'f', "from-file", &short_opts)) {
options |= FROM_FILE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'j', "join-output", &short_opts)) {
options |= RAW_OUTPUT | RAW_NO_LF;
if (!short_opts) continue;
}
if (isoption(argv[i], 'i', "in-place", &short_opts)) {
options |= IN_PLACE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'e', "exit-status", &short_opts)) {
options |= EXIT_STATUS;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "arg", &short_opts)) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --arg takes two parameters (e.g. -a varname value)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "argfile", &short_opts)) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --argfile takes two parameters (e.g. -a varname filename)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
jv data = jv_load_file(argv[i+2], 0);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: Bad JSON in --argfile %s %s: %s\n", progname,
argv[i+1], argv[i+2], jv_string_value(data));
jv_free(data);
ret = 2;
goto out;
}
if (jv_get_kind(data) == JV_KIND_ARRAY && jv_array_length(jv_copy(data)) == 1)
data = jv_array_get(data, 0);
arg = jv_object_set(arg, jv_string("value"), data);
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "debug-dump-disasm", &short_opts)) {
options |= DUMP_DISASM;
if (!short_opts) continue;
}
if (isoption(argv[i], 0, "debug-trace", &short_opts)) {
jq_flags |= JQ_DEBUG_TRACE;
if (!short_opts) continue;
}
if (isoption(argv[i], 'h', "help", &short_opts)) {
usage(0);
if (!short_opts) continue;
}
if (isoption(argv[i], 'V', "version", &short_opts)) {
printf("jq-%s\n", JQ_VERSION);
ret = 0;
goto out;
}
// check for unknown options... if this argument was a short option
if (strlen(argv[i]) != short_opts + 1) {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
}
char *penv = getenv("JQ_LIBRARY_PATH");
if (penv) {
#ifdef WIN32
#define PATH_ENV_SEPARATOR ";"
#else
#define PATH_ENV_SEPARATOR ":"
#endif
lib_search_paths = jv_array_concat(lib_search_paths,jv_string_split(jv_string(penv),jv_string(PATH_ENV_SEPARATOR)));
#undef PATH_ENV_SEPARATOR
}
jq_set_lib_dirs(jq,lib_search_paths);
char *origin = strdup(argv[0]);
if (origin == NULL) {
fprintf(stderr, "Error: out of memory\n");
exit(1);
}
jq_set_lib_origin(jq,jv_string(dirname(origin)));
free(origin);
#if (!defined(WIN32) && defined(HAVE_ISATTY)) || defined(HAVE__ISATTY)
#if defined(HAVE__ISATTY) && defined(isatty)
#undef isatty
#define isatty _isatty
#endif
if (!program && isatty(STDOUT_FILENO) && !isatty(STDIN_FILENO))
program = ".";
#endif
if (!program) usage(2);
if ((options & IN_PLACE)) {
if (ninput_files == 0) usage(2);
if (strcmp(input_filenames[0], "-") == 0) usage(2);
size_t tlen = strlen(input_filenames[0]) + 7;
t = jv_mem_alloc(tlen);
int n = snprintf(t, tlen,"%sXXXXXX", input_filenames[0]);
assert(n > 0 && (size_t)n < tlen);
if (mkstemp(t) == -1) {
fprintf(stderr, "Error: %s creating temporary file", strerror(errno));
exit(3);
}
if (freopen(t, "w", stdout) == NULL) {
fprintf(stderr, "Error: %s redirecting stdout to temporary file", strerror(errno));
exit(3);
}
}
if (ninput_files == 0) current_input = stdin;
if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
die();
}
if (options & FROM_FILE) {
jv data = jv_load_file(program, 1);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
jv_free(data);
ret = 2;
goto out;
}
compiled = jq_compile_args(jq, jv_string_value(data), program_arguments);
jv_free(data);
} else {
compiled = jq_compile_args(jq, program, program_arguments);
}
if (!compiled){
ret = 3;
goto out;
}
if (options & DUMP_DISASM) {
jq_dump_disassembly(jq, 0);
printf("\n");
}
if (options & PROVIDE_NULL) {
ret = process(jq, jv_null(), jq_flags);
} else {
jv slurped;
if (options & SLURP) {
if (options & RAW_INPUT) {
slurped = jv_string("");
} else {
slurped = jv_array();
}
}
struct jv_parser* parser = jv_parser_new(0);
char buf[4096];
while (read_more(buf, sizeof(buf))) {
if (options & RAW_INPUT) {
int len = strlen(buf);
if (len > 0) {
if (options & SLURP) {
slurped = jv_string_concat(slurped, jv_string(buf));
} else {
if (buf[len-1] == '\n') buf[len-1] = 0;
ret = process(jq, jv_string(buf), jq_flags);
}
}
} else {
jv_parser_set_buf(parser, buf, strlen(buf), !feof(stdin));
jv value;
while (jv_is_valid((value = jv_parser_next(parser)))) {
if (options & SLURP) {
slurped = jv_array_append(slurped, value);
} else {
ret = process(jq, value, jq_flags);
}
}
if (jv_invalid_has_msg(jv_copy(value))) {
jv msg = jv_invalid_get_msg(value);
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
ret = 4;
break;
} else {
jv_free(value);
}
}
}
jv_parser_free(parser);
if (ret != 0)
goto out;
if (options & SLURP) {
ret = process(jq, slurped, jq_flags);
}
}
if ((options & IN_PLACE)) {
#ifdef WIN32
(void) freopen("NUL", "w+", stdout);
#else
(void) freopen("/dev/null", "w+", stdout);
#endif
if (rename(t, input_filenames[0]) == -1) {
fprintf(stderr, "Error: %s renaming temporary file", strerror(errno));
exit(3);
}
jv_mem_free(t);
}
out:
jv_mem_free(input_filenames);
jq_teardown(&jq);
if (ret >= 10 && (options & EXIT_STATUS))
return ret - 10;
if (ret >= 10)
return 0;
return ret;
}
static struct io_plan *read_priority_init(struct io_conn *conn, struct data *d)
{
/* This should suppress the write */
ok1(io_conn_exclusive(conn, true));
return read_more(conn, d);
}
int main(int argc, char* argv[]) {
jq_state *jq = NULL;
int ret = 0;
int compiled = 0;
if (argc) progname = argv[0];
if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
return jq_testsuite(argc, argv);
}
jq = jq_init();
if (jq == NULL) {
perror("malloc");
ret = 1;
goto out;
}
const char* program = 0;
input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
ninput_files = 0;
int further_args_are_files = 0;
int jq_flags = 0;
jv_parser_flags parser_flags = 0;
jv program_arguments = jv_array();
for (int i=1; i<argc; i++) {
if (further_args_are_files) {
input_filenames[ninput_files++] = argv[i];
} else if (!strcmp(argv[i], "--")) {
if (!program) usage();
further_args_are_files = 1;
} else if (!isoptish(argv[i])) {
if (program) {
input_filenames[ninput_files++] = argv[i];
} else {
program = argv[i];
}
} else if (isoption(argv[i], 's', "slurp")) {
options |= SLURP;
} else if (isoption(argv[i], 'r', "raw-output")) {
options |= RAW_OUTPUT;
} else if (isoption(argv[i], 'c', "compact-output")) {
options |= COMPACT_OUTPUT;
} else if (isoption(argv[i], 'C', "color-output")) {
options |= COLOUR_OUTPUT;
} else if (isoption(argv[i], 'M', "monochrome-output")) {
options |= NO_COLOUR_OUTPUT;
} else if (isoption(argv[i], 'a', "ascii-output")) {
options |= ASCII_OUTPUT;
} else if (isoption(argv[i], 0, "unbuffered")) {
options |= UNBUFFERED_OUTPUT;
} else if (isoption(argv[i], 'S', "sort-keys")) {
options |= SORTED_OUTPUT;
} else if (isoption(argv[i], 'R', "raw-input")) {
options |= RAW_INPUT;
} else if (isoption(argv[i], 'n', "null-input")) {
options |= PROVIDE_NULL;
} else if (isoption(argv[i], 'f', "from-file")) {
options |= FROM_FILE;
} else if (isoption(argv[i], 'e', "exit-status")) {
options |= EXIT_STATUS;
} else if (isoption(argv[i], 'I', "online-input")) {
parser_flags = JV_PARSE_EXPLODE_TOPLEVEL_ARRAY;
} else if (isoption(argv[i], 0, "arg")) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --arg takes two parameters (e.g. -a varname value)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
} else if (isoption(argv[i], 0, "argfile")) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --argfile takes two parameters (e.g. -a varname filename)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
jv data = jv_load_file(argv[i+2], 0);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: Bad JSON in --argfile %s %s: %s\n", progname,
argv[i+1], argv[i+2], jv_string_value(data));
jv_free(data);
ret = 1;
goto out;
}
if (jv_get_kind(data) == JV_KIND_ARRAY && jv_array_length(jv_copy(data)) == 1)
data = jv_array_get(data, 0);
arg = jv_object_set(arg, jv_string("value"), data);
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
} else if (isoption(argv[i], 0, "debug-dump-disasm")) {
options |= DUMP_DISASM;
} else if (isoption(argv[i], 0, "debug-trace")) {
jq_flags |= JQ_DEBUG_TRACE;
} else if (isoption(argv[i], 'h', "help")) {
usage();
} else if (isoption(argv[i], 'V', "version")) {
printf("jq-%s\n", JQ_VERSION);
ret = 0;
goto out;
} else {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
if (!program) usage();
if (ninput_files == 0) current_input = stdin;
if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
die();
}
if (options & FROM_FILE) {
jv data = jv_load_file(program, 1);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
jv_free(data);
ret = 1;
goto out;
}
compiled = jq_compile_args(jq, jv_string_value(data), program_arguments);
jv_free(data);
} else {
compiled = jq_compile_args(jq, program, program_arguments);
}
if (!compiled){
ret = 1;
goto out;
}
if (options & DUMP_DISASM) {
jq_dump_disassembly(jq, 0);
printf("\n");
}
if (options & PROVIDE_NULL) {
ret = process(jq, jv_null(), jq_flags);
} else {
jv slurped;
if (options & SLURP) {
if (options & RAW_INPUT) {
slurped = jv_string("");
} else {
slurped = jv_array();
}
}
struct jv_parser* parser = jv_parser_new(parser_flags);
char buf[4096];
while (read_more(buf, sizeof(buf))) {
if (options & RAW_INPUT) {
int len = strlen(buf);
if (len > 0) {
if (options & SLURP) {
slurped = jv_string_concat(slurped, jv_string(buf));
} else {
if (buf[len-1] == '\n') buf[len-1] = 0;
ret = process(jq, jv_string(buf), jq_flags);
}
}
} else {
jv_parser_set_buf(parser, buf, strlen(buf), !feof(stdin));
jv value;
while (jv_is_valid((value = jv_parser_next(parser)))) {
if (options & SLURP) {
slurped = jv_array_append(slurped, value);
} else {
ret = process(jq, value, jq_flags);
}
}
if (jv_invalid_has_msg(jv_copy(value))) {
jv msg = jv_invalid_get_msg(value);
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
ret = 1;
break;
} else {
jv_free(value);
}
}
}
jv_parser_free(parser);
if (ret != 0)
goto out;
if (options & SLURP) {
ret = process(jq, slurped, jq_flags);
}
}
out:
jv_mem_free(input_filenames);
jq_teardown(&jq);
if (ret >= 10 && ret <= 11 && !(options & EXIT_STATUS))
return 0;
return ret;
}
void connection::handle_read(const boost::system::error_code& error, std::size_t bytes_transferred)
{
status_ = READING;
// data read, no need for timeouts (RK, note: race condition)
cancel_read_timeout();
if (!error && bytes_transferred > 0)
{
// ensure written bytes in the buffer
_buf.commit(bytes_transferred);
boost::tribool result;
// http variables
/// The incoming request.
request request_;
/// our response
reply reply_;
const char *begin;
// websocket variables
size_t bytes_consumed;
switch (connection_type)
{
case connection_http:
begin = boost::asio::buffer_cast<const char*>(_buf.data());
try
{
request_parser_.reset();
boost::tie(result, boost::tuples::ignore) = request_parser_.parse(
request_, begin, begin + _buf.size());
}
catch (...)
{
_log.Log(LOG_ERROR, "Exception parsing http request.");
}
if (result) {
size_t sizeread = begin - boost::asio::buffer_cast<const char*>(_buf.data());
_buf.consume(sizeread);
reply_.reset();
const char *pConnection = request_.get_req_header(&request_, "Connection");
keepalive_ = pConnection != NULL && boost::iequals(pConnection, "Keep-Alive");
request_.keep_alive = keepalive_;
request_.host_address = host_endpoint_address_;
request_.host_port = host_endpoint_port_;
if (request_.host_address.substr(0, 7) == "::ffff:") {
request_.host_address = request_.host_address.substr(7);
}
request_handler_.handle_request(request_, reply_);
if (reply_.status == reply::switching_protocols) {
// this was an upgrade request
connection_type = connection_websocket;
// from now on we are a persistant connection
keepalive_ = true;
websocket_parser.Start();
websocket_parser.GetHandler()->store_session_id(request_, reply_);
// todo: check if multiple connection from the same client in CONNECTING state?
}
if (request_.keep_alive && ((reply_.status == reply::ok) || (reply_.status == reply::no_content) || (reply_.status == reply::not_modified))) {
// Allows request handler to override the header (but it should not)
reply::add_header_if_absent(&reply_, "Connection", "Keep-Alive");
std::stringstream ss;
ss << "max=" << default_max_requests_ << ", timeout=" << read_timeout_;
reply::add_header_if_absent(&reply_, "Keep-Alive", ss.str());
}
MyWrite(reply_.to_string(request_.method));
if (reply_.status == reply::switching_protocols) {
// this was an upgrade request, set this value after MyWrite to allow the 101 response to go out
connection_type = connection_websocket;
}
if (keepalive_) {
read_more();
}
status_ = WAITING_WRITE;
}
else if (!result)
{
keepalive_ = false;
reply_ = reply::stock_reply(reply::bad_request);
MyWrite(reply_.to_string(request_.method));
if (keepalive_) {
read_more();
}
}
else
{
read_more();
}
break;
case connection_websocket:
case connection_closing:
begin = boost::asio::buffer_cast<const char*>(_buf.data());
result = websocket_parser.parse((const unsigned char *)begin, _buf.size(), bytes_consumed, keepalive_);
_buf.consume(bytes_consumed);
if (result) {
// we received a complete packet (that was handled already)
if (keepalive_) {
read_more();
}
else {
// a connection close control packet was received
// todo: wait for writeQ to flush?
connection_type = connection_closing;
}
}
else // if (!result)
{
read_more();
}
break;
}
}
else if (error != boost::asio::error::operation_aborted)
{
connection_manager_.stop(shared_from_this());
}
}
int main(int argc, char* argv[]) {
int ret = 0;
if (argc) progname = argv[0];
if (argc > 1 && !strcmp(argv[1], "--run-tests")) {
return jq_testsuite(argc - 1, argv + 1);
}
const char* program = 0;
input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
ninput_files = 0;
int further_args_are_files = 0;
int jq_flags = 0;
jv program_arguments = jv_array();
for (int i=1; i<argc; i++) {
if (further_args_are_files) {
input_filenames[ninput_files++] = argv[i];
} else if (!strcmp(argv[i], "--")) {
if (!program) usage();
further_args_are_files = 1;
} else if (!isoptish(argv[i])) {
if (program) {
input_filenames[ninput_files++] = argv[i];
} else {
program = argv[i];
}
} else if (isoption(argv[i], 's', "slurp")) {
options |= SLURP;
} else if (isoption(argv[i], 'r', "raw-output")) {
options |= RAW_OUTPUT;
} else if (isoption(argv[i], 'c', "compact-output")) {
options |= COMPACT_OUTPUT;
} else if (isoption(argv[i], 'C', "color-output")) {
options |= COLOUR_OUTPUT;
} else if (isoption(argv[i], 'M', "monochrome-output")) {
options |= NO_COLOUR_OUTPUT;
} else if (isoption(argv[i], 'a', "ascii-output")) {
options |= ASCII_OUTPUT;
} else if (isoption(argv[i], 'R', "raw-input")) {
options |= RAW_INPUT;
} else if (isoption(argv[i], 'n', "null-input")) {
options |= PROVIDE_NULL;
} else if (isoption(argv[i], 'f', "from-file")) {
options |= FROM_FILE;
} else if (isoption(argv[i], 0, "arg")) {
if (i >= argc - 2) {
fprintf(stderr, "%s: --arg takes two parameters (e.g. -a varname value)\n", progname);
die();
}
jv arg = jv_object();
arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
program_arguments = jv_array_append(program_arguments, arg);
i += 2; // skip the next two arguments
} else if (isoption(argv[i], 0, "debug-dump-disasm")) {
options |= DUMP_DISASM;
} else if (isoption(argv[i], 0, "debug-trace")) {
jq_flags |= JQ_DEBUG_TRACE;
} else if (isoption(argv[i], 'h', "help")) {
usage();
} else if (isoption(argv[i], 'V', "version")) {
fprintf(stderr, "jq version %s\n", PACKAGE_VERSION);
return 0;
} else {
fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
die();
}
}
if (!program) usage();
if (ninput_files == 0) current_input = stdin;
if ((options & PROVIDE_NULL) && (options & (RAW_INPUT | SLURP))) {
fprintf(stderr, "%s: --null-input cannot be used with --raw-input or --slurp\n", progname);
die();
}
if (options & FROM_FILE) {
jv data = slurp_file(program);
if (!jv_is_valid(data)) {
data = jv_invalid_get_msg(data);
fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
jv_free(data);
return 1;
}
bc = jq_compile_args(jv_string_value(data), program_arguments);
jv_free(data);
} else {
bc = jq_compile_args(program, program_arguments);
}
if (!bc) return 1;
if (options & DUMP_DISASM) {
dump_disassembly(0, bc);
printf("\n");
}
if (options & PROVIDE_NULL) {
process(jv_null(), jq_flags);
} else {
jv slurped;
if (options & SLURP) {
if (options & RAW_INPUT) {
slurped = jv_string("");
} else {
slurped = jv_array();
}
}
struct jv_parser parser;
jv_parser_init(&parser);
char buf[4096];
while (read_more(buf, sizeof(buf))) {
if (options & RAW_INPUT) {
int len = strlen(buf);
if (len > 0) {
if (options & SLURP) {
slurped = jv_string_concat(slurped, jv_string(buf));
} else {
if (buf[len-1] == '\n') buf[len-1] = 0;
process(jv_string(buf), jq_flags);
}
}
} else {
jv_parser_set_buf(&parser, buf, strlen(buf), !feof(stdin));
jv value;
while (jv_is_valid((value = jv_parser_next(&parser)))) {
if (options & SLURP) {
slurped = jv_array_append(slurped, value);
} else {
process(value, jq_flags);
}
}
if (jv_invalid_has_msg(jv_copy(value))) {
jv msg = jv_invalid_get_msg(value);
fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
jv_free(msg);
ret = 1;
break;
} else {
jv_free(value);
}
}
}
jv_parser_free(&parser);
if (ret != 0)
goto out;
if (options & SLURP) {
process(slurped, jq_flags);
}
}
out:
jv_mem_free(input_filenames);
bytecode_free(bc);
return ret;
}
void far alt_functions()
{
int the_char,row,i,save_row_curser,save_col_curser;
/*save the curser position*/
save_row_curser = row_curser;
save_col_curser = col_curser;
read_curser_pos();
turn_off_curser();
the_char = ' ';
while(the_char != 13 /*cr*/)
{
read_more(1);
the_char = megatek_data[0];
if(the_char == 24) /*CAN*/
{
all_lights_off();
pfk_out(the_char);
}
else if(the_char == 25) /*EM*/
{
all_lights_on();
pfk_out(the_char);
}
else if((the_char >= '@') && (the_char <= 95)) /*turn off line*/
{
row = the_char - 64;
pfk_out(the_char);
light_lines[row].is_on = 'f';
if(display_alt_menu == 't')
{
if(light_lines[row].light_message[0] != '\0')
{
if(light_lines[row].col > 60)
attribute_string(column61_blank,
light_lines[row].row,
light_lines[row].col,
the_light_color);
else
attribute_string(column36_blank,
light_lines[row].row,
light_lines[row].col,
the_light_color);
}
}
}
else if((the_char >= ' ') && (the_char <= '?')) /*turn on line*/
{
row = the_char - 32;
pfk_out(the_char);
light_lines[row].is_on = 't';
if(display_alt_menu == 't')
{
if(light_lines[row].light_message[0] != '\0')
{
attribute_string(light_lines[row].
light_message,
light_lines[row].row,
light_lines[row].col,
the_light_color);
}
}
}
}
/*restore the cursor*/
goto_row_col(row_curser,col_curser);
row_curser = save_row_curser;
col_curser = save_col_curser;
turn_on_curser();
}
static ssize_t i_stream_seekable_read(struct istream_private *stream)
{
struct seekable_istream *sstream = (struct seekable_istream *)stream;
const unsigned char *data;
size_t size, pos;
ssize_t ret;
if (sstream->fd == -1) {
if (read_from_buffer(sstream, &ret))
return ret;
/* copy everything to temp file and use it as the stream */
if (copy_to_temp_file(sstream) < 0) {
stream->max_buffer_size = (size_t)-1;
if (!read_from_buffer(sstream, &ret))
i_unreached();
return ret;
}
i_assert(sstream->fd != -1);
}
stream->buffer = CONST_PTR_OFFSET(stream->buffer, stream->skip);
stream->pos -= stream->skip;
stream->skip = 0;
i_assert(stream->istream.v_offset + stream->pos <= sstream->write_peak);
if (stream->istream.v_offset + stream->pos == sstream->write_peak) {
/* need to read more */
if (sstream->cur_input == NULL ||
i_stream_get_data_size(sstream->cur_input) == 0) {
ret = read_more(sstream);
if (ret == -1 || ret == 0)
return ret;
}
/* save to our file */
data = i_stream_get_data(sstream->cur_input, &size);
ret = write(sstream->fd, data, size);
if (ret <= 0) {
if (ret < 0 && !ENOSPACE(errno)) {
i_error("istream-seekable: write_full(%s) failed: %m",
sstream->temp_path);
}
if (i_stream_seekable_write_failed(sstream) < 0)
return -1;
if (!read_from_buffer(sstream, &ret))
i_unreached();
return ret;
}
i_stream_sync(sstream->fd_input);
i_stream_skip(sstream->cur_input, ret);
sstream->write_peak += ret;
}
i_stream_seek(sstream->fd_input, stream->istream.v_offset);
ret = i_stream_read_memarea(sstream->fd_input);
if (ret <= 0) {
stream->istream.eof = sstream->fd_input->eof;
stream->istream.stream_errno =
sstream->fd_input->stream_errno;
} else {
ret = -2;
}
stream->buffer = i_stream_get_data(sstream->fd_input, &pos);
stream->pos -= stream->skip;
stream->skip = 0;
ret = pos > stream->pos ? (ssize_t)(pos - stream->pos) : ret;
stream->pos = pos;
return ret;
}
packet_ptr_t transport_t::handle_events(unsigned int timeout_millis) {
//Check if we have a header
if (cur_consumed_ < AA_PACKET_HEADER_SIZE) {
read_more(timeout_millis);
if (cur_consumed_ < AA_PACKET_HEADER_SIZE)
return packet_ptr_t();
}
// Read the header
u_char chan = stream_buffer_.at(0);
u_char flags = stream_buffer_.at(1);
uint16_t packet_size = (uint16_t) (stream_buffer_.at(2) * 256 + stream_buffer_.at(3));
//Check if we need more data for this packet
if (cur_consumed_ < packet_size+4) {
read_more(timeout_millis);
return packet_ptr_t();
}
packet_ptr_t cur_packet;
size_t header_size = 4;
// This is the first packet of multi-packet series
if ((flags & AA_LAST_FRAG) == 0 && (flags & AA_FIRST_FRAG))
{
if (this->mutli_packet_)
throw std::runtime_error("Interleaved multi-packet: first fragment");
packet_ptr_t multi_first(new packet_t());
multi_first->chan_ = chan;
multi_first->encrypted_ = flags & AA_ENCRYPTED;
multi_first->control_ = flags & AA_CONTROL_FLAG;
uint32_t full_size = safe_cast<uint32_t>(stream_buffer_.at(4)*(256*256*256) +
stream_buffer_.at(5)*(256*256) + stream_buffer_.at(6)*256 + stream_buffer_.at(7));
//Insert the initial content
multi_first->content_.reserve(full_size);
this->mutli_packet_ = multi_first;
cur_packet = multi_first;
header_size = 8;
} else if (this->mutli_packet_)
{
cur_packet = this->mutli_packet_;
if (chan != cur_packet->chan_)
throw std::runtime_error("Interleaved packet stream: middle fragment");
} else {
cur_packet = packet_ptr_t(new packet_t());
cur_packet->chan_ = chan;
cur_packet->encrypted_ = flags & AA_ENCRYPTED;
cur_packet->control_ = flags & AA_CONTROL_FLAG;
cur_packet->content_.reserve(packet_size);
}
cur_packet->content_.insert(cur_packet->content_.end(),
stream_buffer_.begin()+header_size,
stream_buffer_.begin()+header_size+packet_size);
std::copy(stream_buffer_.begin()+packet_size+header_size, stream_buffer_.end(),
stream_buffer_.begin());
cur_consumed_ -= packet_size+header_size;
if (flags & AA_LAST_FRAG) {
this->mutli_packet_ = packet_ptr_t();
return cur_packet;
}
return packet_ptr_t();
}
/* Get tmp_dnode_info and full_dirent for all non-obsolete nodes associated
with this ino, returning the former in order of version */
static int jffs2_get_inode_nodes(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
struct rb_root *tnp, struct jffs2_full_dirent **fdp,
uint32_t *highest_version, uint32_t *latest_mctime,
uint32_t *mctime_ver)
{
struct jffs2_raw_node_ref *ref, *valid_ref;
struct rb_root ret_tn = RB_ROOT;
struct jffs2_full_dirent *ret_fd = NULL;
unsigned char *buf = NULL;
union jffs2_node_union *node;
size_t retlen;
int len, err;
*mctime_ver = 0;
dbg_readinode("ino #%u\n", f->inocache->ino);
if (jffs2_is_writebuffered(c)) {
/*
* If we have the write buffer, we assume the minimal I/O unit
* is c->wbuf_pagesize. We implement some optimizations which in
* this case and we need a temporary buffer of size =
* 2*c->wbuf_pagesize bytes (see comments in read_dnode()).
* Basically, we want to read not only the node header, but the
* whole wbuf (NAND page in case of NAND) or 2, if the node
* header overlaps the border between the 2 wbufs.
*/
len = 2*c->wbuf_pagesize;
} else {
/*
* When there is no write buffer, the size of the temporary
* buffer is the size of the larges node header.
*/
len = sizeof(union jffs2_node_union);
}
/* FIXME: in case of NOR and available ->point() this
* needs to be fixed. */
buf = kmalloc(len, GFP_KERNEL);
if (!buf)
return -ENOMEM;
spin_lock(&c->erase_completion_lock);
valid_ref = jffs2_first_valid_node(f->inocache->nodes);
if (!valid_ref && f->inocache->ino != 1)
JFFS2_WARNING("Eep. No valid nodes for ino #%u.\n", f->inocache->ino);
while (valid_ref) {
unsigned char *bufstart;
/* We can hold a pointer to a non-obsolete node without the spinlock,
but _obsolete_ nodes may disappear at any time, if the block
they're in gets erased. So if we mark 'ref' obsolete while we're
not holding the lock, it can go away immediately. For that reason,
we find the next valid node first, before processing 'ref'.
*/
ref = valid_ref;
valid_ref = jffs2_first_valid_node(ref->next_in_ino);
spin_unlock(&c->erase_completion_lock);
cond_resched();
/*
* At this point we don't know the type of the node we're going
* to read, so we do not know the size of its header. In order
* to minimize the amount of flash IO we assume the node has
* size = JFFS2_MIN_NODE_HEADER.
*/
if (jffs2_is_writebuffered(c)) {
/*
* We treat 'buf' as 2 adjacent wbufs. We want to
* adjust bufstart such as it points to the
* beginning of the node within this wbuf.
*/
bufstart = buf + (ref_offset(ref) % c->wbuf_pagesize);
/* We will read either one wbuf or 2 wbufs. */
len = c->wbuf_pagesize - (bufstart - buf);
if (JFFS2_MIN_NODE_HEADER + (int)(bufstart - buf) > c->wbuf_pagesize) {
/* The header spans the border of the first wbuf */
len += c->wbuf_pagesize;
}
} else {
bufstart = buf;
len = JFFS2_MIN_NODE_HEADER;
}
dbg_readinode("read %d bytes at %#08x(%d).\n", len, ref_offset(ref), ref_flags(ref));
/* FIXME: point() */
err = jffs2_flash_read(c, ref_offset(ref), len,
&retlen, bufstart);
if (err) {
JFFS2_ERROR("can not read %d bytes from 0x%08x, " "error code: %d.\n", len, ref_offset(ref), err);
goto free_out;
}
if (retlen < len) {
JFFS2_ERROR("short read at %#08x: %d instead of %d.\n", ref_offset(ref), retlen, len);
err = -EIO;
goto free_out;
}
node = (union jffs2_node_union *)bufstart;
switch (je16_to_cpu(node->u.nodetype)) {
case JFFS2_NODETYPE_DIRENT:
if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_dirent)) {
err = read_more(c, ref, sizeof(struct jffs2_raw_dirent), &len, buf, bufstart);
if (unlikely(err))
goto free_out;
}
err = read_direntry(c, ref, &node->d, retlen, &ret_fd, latest_mctime, mctime_ver);
if (err == 1) {
jffs2_mark_node_obsolete(c, ref);
break;
} else if (unlikely(err))
goto free_out;
if (je32_to_cpu(node->d.version) > *highest_version)
*highest_version = je32_to_cpu(node->d.version);
break;
case JFFS2_NODETYPE_INODE:
if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_raw_inode)) {
err = read_more(c, ref, sizeof(struct jffs2_raw_inode), &len, buf, bufstart);
if (unlikely(err))
goto free_out;
}
err = read_dnode(c, ref, &node->i, &ret_tn, len, latest_mctime, mctime_ver);
if (err == 1) {
jffs2_mark_node_obsolete(c, ref);
break;
} else if (unlikely(err))
goto free_out;
if (je32_to_cpu(node->i.version) > *highest_version)
*highest_version = je32_to_cpu(node->i.version);
break;
default:
if (JFFS2_MIN_NODE_HEADER < sizeof(struct jffs2_unknown_node)) {
err = read_more(c, ref, sizeof(struct jffs2_unknown_node), &len, buf, bufstart);
if (unlikely(err))
goto free_out;
}
err = read_unknown(c, ref, &node->u);
if (err == 1) {
jffs2_mark_node_obsolete(c, ref);
break;
} else if (unlikely(err))
goto free_out;
}
spin_lock(&c->erase_completion_lock);
}
spin_unlock(&c->erase_completion_lock);
*tnp = ret_tn;
*fdp = ret_fd;
kfree(buf);
dbg_readinode("nodes of inode #%u were read, the highest version is %u, latest_mctime %u, mctime_ver %u.\n",
f->inocache->ino, *highest_version, *latest_mctime, *mctime_ver);
return 0;
free_out:
jffs2_free_tmp_dnode_info_list(&ret_tn);
jffs2_free_full_dirent_list(ret_fd);
kfree(buf);
return err;
}
inline int rnext()
{
if (rlim - rpos <= 0)
rpos = read_more(rpos);
return (rlim - rpos > 0) ? rnextf() : -1;
}
int main(int argc, char ** argv) {
if (argc < 2) {
fprintf(stderr, "%s used outside of a shebang\n", argv[0]);
return exit_usage;
}
state st;
st.filename = argv[1];
st.fd = open(st.filename, O_RDONLY | O_CLOEXEC);
if (st.fd == -1) {
fprintf(stderr, "opening %s for reading: %s\n", st.filename, strerror(errno));
return exit_open_script;
}
#ifdef NEED_FCNTL
fcntl(st.fd, F_SETFD, fcntl(st.fd, F_GETFD) | FD_CLOEXEC);
#endif
struct stat buf;
if (fstat(st.fd, &buf) == -1) {
fprintf(stderr, "getting file status of %s: %s\n", st.filename, strerror(errno));
return exit_stat;
}
st.capacity = buf.st_blksize;
st.fill = 0;
st.offset = 0;
st.buf = malloc(st.capacity);
if (!st.buf) {
perror("allocating argument buffer");
exit(exit_mem);
}
/* Skip first line */
while (next_char(&st) != '\n');
/* Ensure we start with a shebang */
if (next_char(&st) != '#' || next_char(&st) != '!') {
fprintf(stderr, "second line of %s doesn't begin with #!\n", st.filename);
return exit_no_shebang;
}
/* Skip leading spaces */
while (next_char(&st) == ' ');
st.fill = st.fill - (st.offset - 1);
memmove(st.buf, st.buf + st.offset - 1, st.fill);
st.offset = 0;
int separate_arg = 0;
size_t arg_count = 0;
/* Read long shebang line */
while (1) {
for (; st.offset < st.fill; ++st.offset) {
switch (st.buf[st.offset]) {
case '\0':
fprintf(stderr, "unexpected null character in long shebang line of %s\n", st.filename);
return exit_null;
case '\n':
st.buf[st.offset] = '\0';
arg_count++;
goto args_done;
case ' ':
st.buf[st.offset] = '\0';
arg_count++;
/* arg_count overflow would require st.capacity overflow, which we already check for */
break;
case '\\':
++st.offset;
if (st.offset == st.fill)
read_more(&st);
switch (st.buf[st.offset]) {
case 'n':
st.buf[st.offset] = '\n';
case '\\':
case ' ':
memmove(st.buf + st.offset - 1, st.buf + st.offset, st.fill - st.offset);
st.fill--;
st.offset--;
break;
case 'a':
if (st.offset == st.fill)
read_more(&st);
if (st.offset != 1 || st.buf[2] != ' ' || separate_arg) {
fprintf(stderr, "\\a escape doesn't appear as the first argument of long shebang line %s\n", st.filename);
return exit_bad_a_escape;
}
if (st.fill == 2)
read_more(&st);
memmove(st.buf, st.buf + 3, st.fill - 3);
st.offset = 0;
separate_arg = 1;
break;
default:
fprintf(stderr, "unknown escape %c in long shebang line of %s\n", st.buf[st.offset], st.filename);
return exit_unknown_escape;
}
break;
}
}
read_more(&st);
}
args_done:
arg_count -= separate_arg;
if (arg_count == 0) {
fprintf(stderr, "no arguments in long shebang line of %s\n", st.filename);
return exit_no_args;
}
char ** args = malloc(sizeof(char**) * (arg_count + argc));
if (!args) {
perror("allocating arg pointer buffer");
return exit_mem;
}
args[0] = st.buf;
if (separate_arg) {
while (*args[0] != '\0')
args[0]++;
args[0]++;
}
for (size_t i = 1; i < arg_count; ++i) {
args[i] = args[i-1] + 1;
while (*args[i] != '\0')
args[i]++;
args[i]++;
}
for (size_t i = arg_count; i < arg_count + argc; ++i) {
args[i] = argv[i + 1 - arg_count];
}
execvp(st.buf, args);
fprintf(stderr, "executing %s: %s\n", args[0], strerror(errno));
return exit_exec;
}
int
hstcpcli::response_recv(size_t& num_flds_r)
{
if (error_code < 0) {
return error_code;
}
clear_error();
if (num_req_bufd > 0 || num_req_sent == 0 || num_req_rcvd > 0 ||
response_end_offset != 0) {
close();
return set_error(-1, "response_recv: protocol out of sync");
}
cur_row_offset = 0;
num_flds_r = num_flds = 0;
if (fd.get() < 0) {
return set_error(-1, "read: closed");
}
size_t offset = 0;
while (true) {
const char *const lbegin = readbuf.begin() + offset;
const char *const lend = readbuf.end();
if (lbegin < lend)
{
const char *const nl = memchr_char(lbegin, '\n', lend - lbegin);
if (nl != 0) {
offset += (nl + 1) - lbegin;
break;
}
offset += lend - lbegin;
}
if (read_more() <= 0) {
close();
error_code = -1;
return error_code;
}
}
response_end_offset = offset;
--num_req_sent;
++num_req_rcvd;
char *start = readbuf.begin();
char *const finish = start + response_end_offset - 1;
const size_t resp_code = read_ui32(start, finish);
skip_one(start, finish);
num_flds_r = num_flds = read_ui32(start, finish);
if (resp_code != 0) {
skip_one(start, finish);
char *const err_begin = start;
read_token(start, finish);
char *const err_end = start;
String e = String(err_begin, err_end - err_begin, &my_charset_bin);
if (!e.length()) {
e = String("unknown_error", &my_charset_bin);
}
return set_error(resp_code, e);
}
cur_row_offset = start - readbuf.begin();
DBG(fprintf(stderr, "[%s] ro=%zu eol=%zu\n",
String(readbuf.begin(), readbuf.begin() + response_end_offset)
.c_str(),
cur_row_offset, response_end_offset));
DBG(fprintf(stderr, "RES 0\n"));
if (flds.max_element < num_flds)
{
if (allocate_dynamic(&flds, num_flds))
return set_error(-1, "out of memory");
}
flds.elements = num_flds;
return 0;
}
