ssize_t tls_prng_dev_read(TLS_PRNG_SRC *dev, size_t len) { const char *myname = "tls_prng_dev_read"; unsigned char buffer[UCHAR_MAX]; ssize_t count; size_t rand_bytes; if (len <= 0) msg_panic("%s: bad read length: %ld", myname, (long) len); if (len > sizeof(buffer)) rand_bytes = sizeof(buffer); else rand_bytes = len; errno = 0; #ifdef __APPLE_OS_X_SERVER__ const char *p_no_poll = "apple-no-poll"; count = timed_read(dev->fd, buffer, rand_bytes, dev->timeout, (void *)p_no_poll); #else /* __APPLE_OS_X_SERVER__ */ count = timed_read(dev->fd, buffer, rand_bytes, dev->timeout, (void *) 0); #endif /* __APPLE_OS_X_SERVER__ */ if (count > 0) { if (msg_verbose) msg_info("%s: read %ld bytes from entropy device %s", myname, (long) count, dev->name); RAND_seed(buffer, count); } else { if (msg_verbose) msg_info("%s: cannot read %ld bytes from entropy device %s: %m", myname, (long) rand_bytes, dev->name); } return (count); }
TEST(TIMEDREAD, CASE1) { char result[4096]; ASSERT_EQ(1, timed_read("aaa", result, 4096)); EXPECT_EQ(-1, timed_read("aaabbbb", result, 4096)); EXPECT_EQ(-1, timed_read("ls", result, 4096)); EXPECT_STREQ("a",result); }
static int extract_request(struct http_connection *c, struct http_request *r) { int ret = 0; while(1) { /* Parse a request header from the connection buf. */ parse_request_header(r, c->buf, c->buf_length); /* If we found one, extract the rest of the request based on the length, * and return to process it. */ int len = r->length; if(len > 0) { /* Prepare r->buf to receive the extracted request. */ if (len > sizeof(r->static_buf)) r->buf = malloc(len); /* If the length is <= the size of the connection buffer, we can just * copy it out into the request buffer, and we are done. */ if (len <= c->buf_length) { memcpy(r->buf, c->buf, len); c->buf_length = c->buf_length - len; memmove(c->buf, &c->buf[len], c->buf_length); /* Otherwise, we need to read in the rest of the request from the wire. */ } else { memcpy(r->buf, c->buf, c->buf_length); len -= c->buf_length; c->buf_length = 0; while (len) { ret = timed_read(c, &r->buf[r->length - len], len); len -= ret; if(ret <= 0) return ret; } return r->length; } /* Honor some non-persistent clients */ if (strstr(r->buf, "Connection: close")) c->should_close = 1; return len; } /* Otherwise, try and read in the next request from the socket */ ret = timed_read(c, &c->buf[c->buf_length], sizeof(c->buf) - c->buf_length); /* If the return code is invalid or marks the end of a connection, just * return it. */ if(ret <= 0) return ret; /* Otherwise, update the buf_length and loop back around to try and * extract the request again. */ c->buf_length += ret; } }
ssize_t tls_prng_file_read(TLS_PRNG_SRC *fh, size_t len) { const char *myname = "tls_prng_file_read"; char buffer[8192]; ssize_t to_read; ssize_t count; if (msg_verbose) msg_info("%s: seed internal pool from file %s", myname, fh->name); if (lseek(fh->fd, 0, SEEK_SET) < 0) { if (msg_verbose) msg_info("cannot seek entropy file %s: %m", fh->name); return (-1); } errno = 0; for (to_read = len; to_read > 0; to_read -= count) { if ((count = timed_read(fh->fd, buffer, to_read > sizeof(buffer) ? sizeof(buffer) : to_read, fh->timeout, (void *) 0)) < 0) { if (msg_verbose) msg_info("cannot read entropy file %s: %m", fh->name); return (-1); } if (count == 0) break; RAND_seed(buffer, count); } if (msg_verbose) msg_info("read %ld bytes from entropy file %s: %m", (long) (len - to_read), fh->name); return (len - to_read); }
int main(int argc, char **argv) { char result[4096]; ::testing::InitGoogleTest(&argc, argv); RUN_ALL_TESTS(); printf("*****\n"); timed_read("/usr/bin/ls", result, 4096); printf("%s\n", result); }
/* * Write one byte to an empty fifo, then try to read one byte and make sure * we don't get back EAGAIN. */ static void test_nonblocking_one_byte(void) { int reader_fd, ret, timedout, writer_fd; ssize_t len; u_char ch; makefifo("testfifo", __func__); if (openfifo("testfifo", __func__, &reader_fd, &writer_fd) < 0) { warn("test_nonblocking: openfifo: testfifo"); cleanfifo2("testfifo", -1, -1); exit(-1); } if (set_nonblocking(reader_fd, __func__) < 0) { cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } ch = 0xfe; ret = timed_write(writer_fd, &ch, sizeof(ch), &len, 5, &timedout, __func__); if (ret < 0) { warn("test_nonblocking_one_byte: timed_write"); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } if (len != sizeof(ch)) { warnx("test_nonblocking_one_byte: timed_write: tried to write " "%zu, wrote %zd", sizeof(ch), len); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } ch = 0xab; ret = timed_read(reader_fd, &ch, sizeof(ch), &len, 5, &timedout, __func__); if (ret < 0) { warn("test_nonblocking_one_byte: timed_read"); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } if (len != sizeof(ch)) { warnx("test_nonblocking_one_byte: timed_read: wanted %zu, read " "%zd", sizeof(ch), len); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } if (ch != 0xfe) { warnx("test_nonblocking_one_byte: timed_read: expected to read " "0x%02x, read 0x%02x", 0xfe, ch); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } cleanfifo2("testfifo", reader_fd, writer_fd); }
ssize_t tls_prng_egd_read(TLS_PRNG_SRC *egd, size_t len) { const char *myname = "tls_prng_egd_read"; unsigned char buffer[UCHAR_MAX]; ssize_t count; if (len <= 0) msg_panic("%s: bad length %ld", myname, (long) len); buffer[0] = 1; buffer[1] = (len > UCHAR_MAX ? UCHAR_MAX : len); if (timed_write(egd->fd, buffer, 2, egd->timeout, (void *) 0) != 2) { msg_info("cannot write to EGD server %s: %m", egd->name); return (-1); } if (timed_read(egd->fd, buffer, 1, egd->timeout, (void *) 0) != 1) { msg_info("cannot read from EGD server %s: %m", egd->name); return (-1); } count = buffer[0]; if (count > sizeof(buffer)) count = sizeof(buffer); if (count == 0) { msg_info("EGD server %s reports zero bytes available", egd->name); return (-1); } if (timed_read(egd->fd, buffer, count, egd->timeout, (void *) 0) != count) { msg_info("cannot read %ld bytes from EGD server %s: %m", (long) count, egd->name); return (-1); } if (msg_verbose) msg_info("%s: got %ld bytes from EGD server %s", myname, (long) count, egd->name); RAND_seed(buffer, count); return (count); }
int Socket::receive( unsigned char *inBuffer, int inNumBytes, long inTimeout ) { if( mIsConnectionBroken ) return -1; int *socketIDptr = (int *)( mNativeObjectPointer ); int socketID = socketIDptr[0]; if( inTimeout == -1 ) { // use MSG_WAITALL flag here to block until inNumBytes has arrived return recv( socketID, inBuffer, inNumBytes, MSG_WAITALL ); } else { return timed_read( socketID, inBuffer, inNumBytes, inTimeout ); } }
int master_monitor(int time_limit) { pid_t pid; int pipes[2]; char buf[1]; /* * Sanity check. */ if (time_limit <= 0) msg_panic("master_monitor: bad time limit: %d", time_limit); /* * Set up the plumbing for child-to-parent communication. */ if (pipe(pipes) < 0) msg_fatal("pipe: %m"); close_on_exec(pipes[0], CLOSE_ON_EXEC); close_on_exec(pipes[1], CLOSE_ON_EXEC); /* * Fork the child, and wait for it to report successful initialization. */ switch (pid = fork()) { case -1: /* Error. */ msg_fatal("fork: %m"); case 0: /* Child. Initialize as daemon in the background. */ close(pipes[0]); return (pipes[1]); default: /* Parent. Monitor the child in the foreground. */ close(pipes[1]); switch (timed_read(pipes[0], buf, 1, time_limit, (char *) 0)) { default: /* The child process still runs, but something is wrong. */ (void) kill(pid, SIGKILL); /* FALLTHROUGH */ case 0: /* The child process exited prematurely. */ msg_fatal("daemon initialization failure"); case 1: /* The child process initialized successfully. */ exit(0); } } }
static bool try_query(Message *msg, Message *answer, timeout_t *timeout) { int s = get_connection(timeout); if (s < 0) return false; if (timeout_happened(timeout)) { debug("try_query: get_connection() timed out\n"); return false; } if (!timed_write(s, msg, sizeof(Message), timeout)) { debug("try_query: failed to send the query to the leader\n"); return false; } if (!timed_read(s, answer, sizeof(Message), timeout)) { debug("try_query: failed to recv the answer from the leader\n"); return false; } return true; }
//******************************************************************************** // Function: redirect_count // // Description: Recieve Control Plane redirect count. //******************************************************************************** static int32_t redirect_count(void) { void *context = zmq_ctx_new (); void *requester = zmq_socket(context, ZMQ_REQ); int32_t timeo{}; zmq_setsockopt(requester, ZMQ_LINGER, (void*) &timeo, sizeof(timeo)); char buffer[64]; sprintf(buffer, "tcp://localhost:%d", TCPLANE_SERVICE); zmq_connect(requester, buffer); sprintf(buffer, "%d", redirectCount); zmq_send(requester, buffer, strlen(buffer), 0); size_t size = timed_read(requester, buffer, sizeof(buffer), READ_TIMEOUT); if(size) size = atoi(buffer); zmq_close(requester); zmq_ctx_destroy(context); return size; }
/* * This test operates on blocking and non-blocking fifo file descriptors, in * order to determine whether they block at good moments or not. By good we * mean: don't block for non-blocking sockets, and do block for blocking * ones, assuming there isn't I/O buffer to satisfy the request. * * We use a timeout of 5 seconds, concluding that in 5 seconds either all I/O * that can take place will, and that if we reach the end of the timeout, * then blocking has occurred. * * We assume that the buffer size on a fifo is <512K, and as such, that * writing that much data without an active reader will result in blocking. */ static void test_blocking_read_empty(void) { int reader_fd, ret, timedout, writer_fd; ssize_t len; u_char ch; makefifo("testfifo", __func__); if (openfifo("testfifo", &reader_fd, &writer_fd) < 0) { warn("test_blocking_read_empty: openfifo: testfifo"); cleanfifo2("testfifo", -1, -1); exit(-1); } /* * Read one byte from an empty blocking fifo, block as there is no * data. */ if (set_blocking(reader_fd, __func__) < 0) { cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } ret = timed_read(reader_fd, &ch, sizeof(ch), &len, 5, &timedout, __func__); if (ret != -1) { warnx("test_blocking_read_empty: timed_read: returned " "success"); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } if (errno != EINTR) { warn("test_blocking_read_empty: timed_read"); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } /* * Read one byte from an empty non-blocking fifo, return EAGAIN as * there is no data. */ if (set_nonblocking(reader_fd, __func__) < 0) { cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } ret = timed_read(reader_fd, &ch, sizeof(ch), &len, 5, &timedout, __func__); if (ret != -1) { warnx("test_blocking_read_empty: timed_read: returned " "success"); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } if (errno != EAGAIN) { warn("test_blocking_read_empty: timed_read"); cleanfifo2("testfifo", reader_fd, writer_fd); exit(-1); } cleanfifo2("testfifo", reader_fd, writer_fd); }
static int NBScat_exec(struct ast_channel *chan, const char *data) { int res=0; int fds[2]; int ms = -1; int pid = -1; struct ast_format owriteformat; struct timeval next; struct ast_frame *f; struct myframe { struct ast_frame f; char offset[AST_FRIENDLY_OFFSET]; short frdata[160]; } myf; ast_format_clear(&owriteformat); if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds)) { ast_log(LOG_WARNING, "Unable to create socketpair\n"); return -1; } ast_stopstream(chan); ast_format_copy(&owriteformat, &chan->writeformat); res = ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR); if (res < 0) { ast_log(LOG_WARNING, "Unable to set write format to signed linear\n"); return -1; } res = NBScatplay(fds[1]); /* Wait 1000 ms first */ next = ast_tvnow(); next.tv_sec += 1; if (res >= 0) { pid = res; /* Order is important -- there's almost always going to be mp3... we want to prioritize the user */ for (;;) { ms = ast_tvdiff_ms(next, ast_tvnow()); if (ms <= 0) { res = timed_read(fds[0], myf.frdata, sizeof(myf.frdata)); if (res > 0) { myf.f.frametype = AST_FRAME_VOICE; ast_format_set(&myf.f.subclass.format, AST_FORMAT_SLINEAR, 0); myf.f.datalen = res; myf.f.samples = res / 2; myf.f.mallocd = 0; myf.f.offset = AST_FRIENDLY_OFFSET; myf.f.src = __PRETTY_FUNCTION__; myf.f.delivery.tv_sec = 0; myf.f.delivery.tv_usec = 0; myf.f.data.ptr = myf.frdata; if (ast_write(chan, &myf.f) < 0) { res = -1; break; } } else { ast_debug(1, "No more mp3\n"); res = 0; break; } next = ast_tvadd(next, ast_samp2tv(myf.f.samples, 8000)); } else { ms = ast_waitfor(chan, ms); if (ms < 0) { ast_debug(1, "Hangup detected\n"); res = -1; break; } if (ms) { f = ast_read(chan); if (!f) { ast_debug(1, "Null frame == hangup() detected\n"); res = -1; break; } if (f->frametype == AST_FRAME_DTMF) { ast_debug(1, "User pressed a key\n"); ast_frfree(f); res = 0; break; } ast_frfree(f); } } } } close(fds[0]); close(fds[1]); if (pid > -1) kill(pid, SIGKILL); if (!res && owriteformat.id) ast_set_write_format(chan, &owriteformat); return res; }
static int pipe_exec(struct cw_channel *chan, int argc, char **argv) { int res=0; struct localuser *u; int fds[2]; int ms = -1; int pid = -1; int owriteformat; int oreadformat; int timeout = 2000; struct timeval last; struct cw_frame *f; struct myframe { struct cw_frame f; char offset[CW_FRIENDLY_OFFSET]; short frdata[160]; } myf; last.tv_usec = 0; last.tv_sec = 0; if (argc < 2 || argc > 3) { cw_log(LOG_ERROR, "Syntax: %s\n", pipe_syntax); return -1; } LOCAL_USER_ADD(u); if (pipe(fds)) { cw_log(LOG_WARNING, "Unable to create pipe\n"); LOCAL_USER_REMOVE(u); return -1; } // MOC: Setting non blocking doesn't seem to change anything // flags = fcntl(fds[1], F_GETFL); // fcntl(fds[1], F_SETFL, flags | O_NONBLOCK); // flags = fcntl(fds[0], F_GETFL); // fcntl(fds[0], F_SETFL, flags | O_NONBLOCK); cw_stopstream(chan); if (chan->_state != CW_STATE_UP) res = cw_answer(chan); if (res) { close(fds[0]); close(fds[1]); cw_log(LOG_WARNING, "Answer failed!\n"); LOCAL_USER_REMOVE(u); return -1; } oreadformat = chan->readformat; res = cw_set_read_format(chan, CW_FORMAT_SLINEAR); owriteformat = chan->writeformat; res += cw_set_write_format(chan, CW_FORMAT_SLINEAR); if (res < 0) { close(fds[0]); close(fds[1]); cw_log(LOG_WARNING, "Unable to set write format to signed linear\n"); LOCAL_USER_REMOVE(u); return -1; } res = pipeencode(argv[1], argv[2], fds[0], fds[1]); if (res >= 0) { last = cw_tvnow(); last.tv_sec += 1; pid = res; for (;;) { /* Wait for audio, and stream */ if (argv[0][0] == '0') { /* START WRITE TO FD */ ms = cw_waitfor(chan, 10); if (ms < 0) { cw_log(LOG_DEBUG, "Hangup detected\n"); res = -1; break; } else if (ms > 0) { f = cw_read(chan); if (!f) { cw_log(LOG_DEBUG, "Null frame == hangup() detected\n"); res = -1; break; } if (f->frametype == CW_FRAME_DTMF) { cw_log(LOG_DEBUG, "User pressed a key\n"); cw_fr_free(f); res = 0; break; } if (f->frametype == CW_FRAME_VOICE) { res = write(fds[1], f->data, f->datalen); if (res < 0) { if (errno != EAGAIN) { cw_log(LOG_WARNING, "Write failed to pipe: %s\n", strerror(errno)); cw_fr_free(f); res = -1; break; } } } cw_fr_free(f); } /* END WRITE TO FD */ } else { /* START WRITE CHANNEL */ ms = cw_tvdiff_ms(last, cw_tvnow()); if (ms <= 0) { res = timed_read(fds[0], myf.frdata, sizeof(myf.frdata), timeout); if (res > 0) { cw_fr_init_ex(&myf.f, CW_FRAME_VOICE, CW_FORMAT_SLINEAR, __PRETTY_FUNCTION__); myf.f.datalen = res; myf.f.samples = res/sizeof(int16_t); myf.f.offset = CW_FRIENDLY_OFFSET; myf.f.data = myf.frdata; if (cw_write(chan, &myf.f) < 0) { res = -1; break; } } else { cw_log(LOG_DEBUG, "No more stream\n"); res = 0; break; } last = cw_tvadd(last, cw_samp2tv(myf.f.samples, 8000)); } else { ms = cw_waitfor(chan, ms); if (ms < 0) { cw_log(LOG_DEBUG, "Hangup detected\n"); res = -1; break; } if (ms) { f = cw_read(chan); if (!f) { cw_log(LOG_DEBUG, "Null frame == hangup() detected\n"); res = -1; break; } if (f->frametype == CW_FRAME_DTMF) { cw_log(LOG_DEBUG, "User pressed a key\n"); cw_fr_free(f); res = 0; break; } cw_fr_free(f); } } /* END WRITE CHANNEL */ } } } close(fds[0]); close(fds[1]); LOCAL_USER_REMOVE(u); if (pid > -1) kill(pid, SIGKILL); if (!res && oreadformat) cw_set_read_format(chan, oreadformat); if (!res && owriteformat) cw_set_write_format(chan, owriteformat); return res; }
static int mp3_exec(struct ast_channel *chan, const char *data) { int res=0; int fds[2]; int ms = -1; int pid = -1; RAII_VAR(struct ast_format *, owriteformat, NULL, ao2_cleanup); int timeout = 2000; struct timeval next; struct ast_frame *f; struct myframe { struct ast_frame f; char offset[AST_FRIENDLY_OFFSET]; short frdata[160]; } myf = { .f = { 0, }, }; struct ast_format * native_format; unsigned int sampling_rate; struct ast_format * write_format; if (ast_strlen_zero(data)) { ast_log(LOG_WARNING, "MP3 Playback requires an argument (filename)\n"); return -1; } if (pipe(fds)) { ast_log(LOG_WARNING, "Unable to create pipe\n"); return -1; } ast_stopstream(chan); native_format = ast_format_cap_get_format(ast_channel_nativeformats(chan), 0); sampling_rate = ast_format_get_sample_rate(native_format); write_format = ast_format_cache_get_slin_by_rate(sampling_rate); owriteformat = ao2_bump(ast_channel_writeformat(chan)); res = ast_set_write_format(chan, write_format); if (res < 0) { ast_log(LOG_WARNING, "Unable to set write format to signed linear\n"); return -1; } myf.f.frametype = AST_FRAME_VOICE; myf.f.subclass.format = write_format; myf.f.mallocd = 0; myf.f.offset = AST_FRIENDLY_OFFSET; myf.f.src = __PRETTY_FUNCTION__; myf.f.delivery.tv_sec = 0; myf.f.delivery.tv_usec = 0; myf.f.data.ptr = myf.frdata; res = mp3play(data, sampling_rate, fds[1]); if (!strncasecmp(data, "http://", 7)) { timeout = 10000; } /* Wait 1000 ms first */ next = ast_tvnow(); next.tv_sec += 1; if (res >= 0) { pid = res; /* Order is important -- there's almost always going to be mp3... we want to prioritize the user */ for (;;) { ms = ast_tvdiff_ms(next, ast_tvnow()); if (ms <= 0) { res = timed_read(fds[0], myf.frdata, sizeof(myf.frdata), timeout); if (res > 0) { myf.f.datalen = res; myf.f.samples = res / 2; if (ast_write(chan, &myf.f) < 0) { res = -1; break; } } else { ast_debug(1, "No more mp3\n"); res = 0; break; } next = ast_tvadd(next, ast_samp2tv(myf.f.samples, sampling_rate)); } else { ms = ast_waitfor(chan, ms); if (ms < 0) { ast_debug(1, "Hangup detected\n"); res = -1; break; } if (ms) { f = ast_read(chan); if (!f) { ast_debug(1, "Null frame == hangup() detected\n"); res = -1; break; } if (f->frametype == AST_FRAME_DTMF) { ast_debug(1, "User pressed a key\n"); ast_frfree(f); res = 0; break; } ast_frfree(f); } } } } close(fds[0]); close(fds[1]); if (pid > -1) kill(pid, SIGKILL); if (!res && owriteformat) ast_set_write_format(chan, owriteformat); ast_frfree(&myf.f); return res; }
static int mp3_exec(struct ast_channel *chan, void *data) { int res=0; struct localuser *u; int fds[2]; int ms = -1; int pid = -1; int owriteformat; int timeout = 2000; struct timeval next; struct ast_frame *f; struct myframe { struct ast_frame f; char offset[AST_FRIENDLY_OFFSET]; short frdata[160]; } myf; if (ast_strlen_zero(data)) { ast_log(LOG_WARNING, "MP3 Playback requires an argument (filename)\n"); return -1; } LOCAL_USER_ADD(u); if (pipe(fds)) { ast_log(LOG_WARNING, "Unable to create pipe\n"); LOCAL_USER_REMOVE(u); return -1; } ast_stopstream(chan); owriteformat = chan->writeformat; res = ast_set_write_format(chan, AST_FORMAT_SLINEAR); if (res < 0) { ast_log(LOG_WARNING, "Unable to set write format to signed linear\n"); LOCAL_USER_REMOVE(u); return -1; } res = mp3play((char *)data, fds[1]); if (!strncasecmp((char *)data, "http://", 7)) { timeout = 10000; } /* Wait 1000 ms first */ next = ast_tvnow(); next.tv_sec += 1; if (res >= 0) { pid = res; /* Order is important -- there's almost always going to be mp3... we want to prioritize the user */ for (;;) { ms = ast_tvdiff_ms(next, ast_tvnow()); if (ms <= 0) { res = timed_read(fds[0], myf.frdata, sizeof(myf.frdata), timeout); if (res > 0) { myf.f.frametype = AST_FRAME_VOICE; myf.f.subclass = AST_FORMAT_SLINEAR; myf.f.datalen = res; myf.f.samples = res / 2; myf.f.mallocd = 0; myf.f.offset = AST_FRIENDLY_OFFSET; myf.f.src = __PRETTY_FUNCTION__; myf.f.delivery.tv_sec = 0; myf.f.delivery.tv_usec = 0; myf.f.data = myf.frdata; if (ast_write(chan, &myf.f) < 0) { res = -1; break; } } else { ast_log(LOG_DEBUG, "No more mp3\n"); res = 0; break; } next = ast_tvadd(next, ast_samp2tv(myf.f.samples, 8000)); } else { ms = ast_waitfor(chan, ms); if (ms < 0) { ast_log(LOG_DEBUG, "Hangup detected\n"); res = -1; break; } if (ms) { f = ast_read(chan); if (!f) { ast_log(LOG_DEBUG, "Null frame == hangup() detected\n"); res = -1; break; } if (f->frametype == AST_FRAME_DTMF) { ast_log(LOG_DEBUG, "User pressed a key\n"); ast_frfree(f); res = 0; break; } ast_frfree(f); } } } } close(fds[0]); close(fds[1]); if (pid > -1) kill(pid, SIGKILL); if (!res && owriteformat) ast_set_write_format(chan, owriteformat); LOCAL_USER_REMOVE(u); return res; }
int Socket::receive( unsigned char *inBuffer, int inNumBytes, long inTimeout ) { unsigned int *socketIDptr = (unsigned int *)( mNativeObjectPointer ); unsigned int socketID = socketIDptr[0]; int numReceived = 0; char error = false; char errorReturnValue = -1; char stopLooping = false; // for win32, we can't specify MSG_WAITALL // so we have too loop until the entire message is received, // as long as there is no error. // note that if a timeout is set, we use the stopLooping flag // to return only the available data (we do not emulate MSG_WAITALL) while( numReceived < inNumBytes && !error && !stopLooping ) { // the number of bytes left to receive int numRemaining = inNumBytes - numReceived; // pointer to the spot in the buffer where the // remaining bytes should be stored unsigned char *remainingBuffer = &( inBuffer[ numReceived ] ); int numReceivedIn; if( inTimeout == -1 ) { numReceivedIn = recv( socketID, (char*)remainingBuffer, numRemaining, 0 ); } else { numReceivedIn = timed_read( socketID, remainingBuffer, numRemaining, inTimeout ); // stop looping after one timed read stopLooping = true; } if( numReceivedIn > 0 ) { numReceived += numReceivedIn; } else { if( numReceivedIn == 0 ) { // the socket was gracefully closed // return whatever we have received stopLooping = true; } else if( numReceivedIn == SOCKET_ERROR ) { error = true; // socket error errorReturnValue = -1; } else if( numReceivedIn == -2 ) { error = true; // timeout errorReturnValue = -2; } else { printf( "Unexpected return value from socket receive: %d.\n", numReceivedIn ); error = true; errorReturnValue = -1; } } } if( error ) { return errorReturnValue; } else { return numReceived; } }
static int recv_req(int fd, lscgid_t *cgi_req, int timeout) { time_t begin; time_t cur; int ret; begin = time(NULL); cgi_req->m_fdReceived = -1; ret = timed_read(fd, (char *)&cgi_req->m_data, sizeof(lscgid_req), timeout - 1); if (ret == -1) return 500; ret = process_req_header(cgi_req); if (ret) return ret; //fprintf( stderr, "1 Proc: %ld, data: %ld\n", cgi_req->m_data.m_nproc.rlim_cur, // cgi_req->m_data.m_data.rlim_cur ); if (cgi_req->m_data.m_type == LSCGID_TYPE_SUEXEC) { uint32_t pid = (uint32_t)getpid(); write(STDOUT_FILENO, &pid, 4); } cur = time(NULL); timeout -= cur - begin; ret = timed_read(fd, cgi_req->m_pBuf, cgi_req->m_data.m_szData, timeout); if (ret == -1) return 500; ret = process_req_data(cgi_req); if (ret) { s_pError = "lscgid: data error!"; return ret; } if (cgi_req->m_data.m_type == LSCGID_TYPE_SUEXEC) { //cgi_req->m_fdReceived = recv_fd( fd ); char nothing; if ((FDPass::readFd(fd, ¬hing, 1, &cgi_req->m_fdReceived) == -1) || (cgi_req->m_fdReceived == -1)) { fprintf(stderr, "lscgid: read_fd() failed: %s\n", strerror(errno)); return 500; } if (cgi_req->m_fdReceived != STDIN_FILENO) { dup2(cgi_req->m_fdReceived, STDIN_FILENO); close(cgi_req->m_fdReceived); cgi_req->m_fdReceived = -1; } } //fprintf( stderr, "2 Proc: %ld, data: %ld\n", cgi_req->m_data.m_nproc.rlim_cur, // cgi_req->m_data.m_data.rlim_cur ); return 0; }
static enum mad_flow input(void * data, struct mad_stream * stream) { static unsigned char buf[BUFSIZE + 1] = { 0 }; struct stream * ptr = (struct stream *) data; static int nbyte = 0; int remnbyte = 0; if(feof(ptr->streamfd)) return MAD_FLOW_STOP; if(stream->next_frame) { remnbyte = (unsigned) (& buf[nbyte] - stream->next_frame); memmove(buf, stream->next_frame, remnbyte); } if(ptr->preload) { nbyte = timed_read(fileno(ptr->streamfd), buf + remnbyte, BUFSIZE - remnbyte, ptr->timeout); if(nbyte == -1) { fputs("Stream timed out.\n", stderr); } else if(ptr->dump) fwrite(buf + remnbyte, sizeof(buf[0]), nbyte, ptr->dump); } else { while(nbyte < BUFSIZE) { int retval = timed_read(fileno(ptr->streamfd), buf + nbyte, BUFSIZE - nbyte, ptr->timeout); if(retval <= 0) break; if(ptr->dump) fwrite(buf + nbyte, sizeof(buf[0]), retval, ptr->dump); nbyte += retval; } if(!nbyte) { fputs("Stream timed out while trying to preload data.\n", stderr); } ptr->preload = !0; } if(nbyte <= 0) return MAD_FLOW_STOP; nbyte += remnbyte; mad_stream_buffer(stream, (unsigned char *) buf, nbyte); if(kill(ptr->parent, 0) == -1 && errno == ESRCH) { fclose(ptr->streamfd); killed = !0; return MAD_FLOW_STOP; } if(killed) return MAD_FLOW_STOP; return MAD_FLOW_CONTINUE; }
/* Parse, a-la IPv6 */ int parse6(int fd, struct sockaddr_in6 *laddr, struct sockaddr_in6 *faddr) { char token[21], buf[BUFSIZ], *p; struct sockaddr_in6 laddr2, faddr2; struct passwd *pw; uid_t uid; int n; if (debug_flag && syslog_flag) syslog(LOG_DEBUG, "In function parse6(), from %s to %s", gethost6(faddr), gethost6(laddr)); faddr2 = *faddr; laddr2 = *laddr; lport = fport = 0; /* Read query from client */ if ((n = timed_read(fd, buf, sizeof(buf) - 1, IO_TIMEOUT)) <= 0) { if (syslog_flag) syslog(LOG_NOTICE, n ? "read from %s: %m" : "read from %s: EOF", gethost6(faddr)); if ((n = snprintf(buf, sizeof(buf), "%d , %d : ERROR : UNKNOWN-ERROR\r\n", lport, fport)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } buf[n] = '\0'; /* Pull out local and remote ports */ p = buf; while (isspace(*p)) p++; if ((p = strtok(p, " \t,"))) { lport = atoi(p); if ((p = strtok(NULL, " \t,"))) fport = atoi(p); } if (lport < 1 || lport > 65535 || fport < 1 || fport > 65535) { if (syslog_flag) syslog(LOG_NOTICE, "scanf: invalid-port(s): %d , %d from %s", lport, fport, gethost6(faddr)); if ((n = snprintf(buf, sizeof(buf), "%d , %d : ERROR : %s\r\n", lport, fport, unknown_flag ? "UNKNOWN-ERROR" : "INVALID-PORT")) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if (syslog_flag && verbose_flag) syslog(LOG_NOTICE, "request for (%d,%d) from %s", lport, fport, gethost6(faddr)); if (debug_flag && syslog_flag) syslog(LOG_DEBUG, " After fscanf(), before k_getuid6()"); /* * Next - get the specific TCP connection and return the * uid - user number. */ if (k_getuid6(&faddr2, htons(fport), laddr, htons(lport), &uid) == -1) { if (no_user_token_flag) { gentoken(token, sizeof token); syslog(LOG_NOTICE, "token %s == NO USER", token); if ((n = snprintf(buf, sizeof(buf), "%d , %d : USERID : %s%s%s :%s\r\n", lport, fport, opsys_name, charset_sep, charset_name, token)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if (syslog_flag) syslog(LOG_DEBUG, "Returning: %d , %d : NO-USER", lport, fport); if ((n = snprintf(buf, sizeof(buf), "%d , %d : ERROR : %s\r\n", lport, fport, unknown_flag ? "UNKNOWN-ERROR" : "NO-USER")) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if (debug_flag && syslog_flag) syslog(LOG_DEBUG, " After k_getuid6(), before getpwuid()"); pw = getpwuid(uid); if (!pw) { if (syslog_flag) syslog(LOG_WARNING, "getpwuid() could not map uid (%u) to name", uid); if ((n = snprintf(buf, sizeof(buf), "%d , %d : USERID : %s%s%s :%u\r\n", lport, fport, opsys_name, charset_sep, charset_name, uid)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if (syslog_flag) syslog(LOG_DEBUG, "Successful lookup: %d , %d : %s", lport, fport, pw->pw_name); if (noident_flag && check_noident(pw->pw_dir)) { if (syslog_flag && verbose_flag) syslog(LOG_NOTICE, "user %s requested HIDDEN-USER for host %s: %d, %d", pw->pw_name, gethost6(faddr), lport, fport); if ((n = snprintf(buf, sizeof(buf), "%d , %d : ERROR : HIDDEN-USER\r\n", lport, fport)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if (userident_flag && getuserident(pw->pw_dir, token, sizeof token)) { syslog(LOG_NOTICE, "token \"%s\" == uid %u (%s)", token, uid, pw->pw_name); if ((n = snprintf(buf, sizeof(buf), "%d , %d : USERID : %s%s%s :%s\r\n", lport, fport, opsys_name, charset_sep, charset_name, token)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if (token_flag) { gentoken(token, sizeof token); syslog(LOG_NOTICE, "token %s == uid %u (%s)", token, uid, pw->pw_name); if ((n = snprintf(buf, sizeof(buf), "%d , %d : USERID : %s%s%s :%s\r\n", lport, fport, opsys_name, charset_sep, charset_name, token)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if (number_flag) { if ((n = snprintf(buf, sizeof(buf), "%d , %d : USERID : %s%s%s :%u\r\n", lport, fport, opsys_name, charset_sep, charset_name, uid)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; } if ((n = snprintf(buf, sizeof(buf), "%d , %d : USERID : %s%s%s :%s\r\n", lport, fport, opsys_name, charset_sep, charset_name, pw->pw_name)) >= sizeof(buf) || n < 0) n = strlen(buf); if (timed_write(fd, buf, n, IO_TIMEOUT) != n && syslog_flag) { syslog(LOG_NOTICE, "write to %s: %m", gethost6(faddr)); return 1; } return 0; }
int http_get(const char* url, char* result_buffer, size_t maxlen) { char *urlparse, *hostname, *port, *path; struct addrinfo hints, *result, *rp; char request[10240], *bp; int sockfd, rlen, bytes, total_bytes; /* http://hostname:port/foo */ urlparse = strdup(url); hostname = urlparse+7; while (*hostname && *hostname == '/') hostname++; port = hostname; while (*port && *port != '/' && *port != ':') port++; if (*port == '/') { path = port; *path++ = '\0'; port = (url[5] == 's') ? "443" : "80"; } else { *port++ = '\0'; path = port; while (*path && *path != '/') path++; *path++ = '\0'; } rlen = snprintf(request, 10240, "GET /%s HTTP/1.1\r\nHost: %s\r\n\r\n", path, hostname); if (10240 == rlen) { free(urlparse); return -1; } total_bytes = 0; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; if (0 == getaddrinfo(hostname, port, &hints, &result)) { for (rp = result; rp != NULL; rp = rp->ai_next) { if ((0 > (sockfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol))) || (0 > connect(sockfd, rp->ai_addr, rp->ai_addrlen)) || (0 > write(sockfd, request, rlen))) { if (sockfd >= 0) close(sockfd); } else { total_bytes = 0; bp = result_buffer; do { bytes = timed_read(sockfd, bp, maxlen-(1+total_bytes), 1000); if (bytes > 0) { bp += bytes; total_bytes += bytes; } } while (bytes > 0); *bp = '\0'; close(sockfd); break; } } freeaddrinfo(result); } free(urlparse); return total_bytes; }
void* pkb_tunnel_ping(void* void_fe) { struct pk_tunnel* fe = (struct pk_tunnel*) void_fe; struct timeval tv1, tv2, to; char buffer[1024], printip[1024]; int sockfd, bytes, want; PK_TRACE_FUNCTION; fe->priority = 0; in_addr_to_str(fe->ai.ai_addr, printip, 1024); if (pk_state.fake_ping) { fe->priority = rand() % 500; } else { gettimeofday(&tv1, NULL); to.tv_sec = pk_state.socket_timeout_s; to.tv_usec = 0; if ((0 > (sockfd = PKS_socket(fe->ai.ai_family, fe->ai.ai_socktype, fe->ai.ai_protocol))) || PKS_fail(PKS_setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *) &to, sizeof(to))) || PKS_fail(PKS_setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, (char *) &to, sizeof(to))) || PKS_fail(PKS_connect(sockfd, fe->ai.ai_addr, fe->ai.ai_addrlen)) || PKS_fail(PKS_write(sockfd, PK_FRONTEND_PING, strlen(PK_FRONTEND_PING)))) { if (sockfd >= 0){ PKS_close(sockfd); } if (fe->error_count < 999) fe->error_count += 1; pk_log(PK_LOG_MANAGER_DEBUG, "Ping %s failed! (connect)", printip); sleep(2); /* We don't want to return first! */ return NULL; } /* Magic number: 116 bytes is the shortest response we expect. It is * still long enough to contain the X-PageKite-Overloaded marker, if * present at all. */ bytes = timed_read(sockfd, buffer, 116, 1000); buffer[116] = '\0'; want = strlen(PK_FRONTEND_PONG); if ((bytes < want) || (0 != strncmp(buffer, PK_FRONTEND_PONG, want))) { if (fe->error_count < 999) fe->error_count += 1; pk_log(PK_LOG_MANAGER_DEBUG, "Ping %s failed! (read=%d)", printip, bytes); sleep(2); /* We don't want to return first! */ return NULL; } PKS_close(sockfd); gettimeofday(&tv2, NULL); fe->priority = (tv2.tv_sec - tv1.tv_sec) * 1000 + (tv2.tv_usec - tv1.tv_usec) / 1000; if (strcasestr(buffer, PK_FRONTEND_OVERLOADED) != NULL) { fe->priority += 1; sleep(2); /* We don't want to return first! */ } } if (fe->conn.status & (FE_STATUS_WANTED|FE_STATUS_IS_FAST)) { /* Bias ping time to make old decisions a bit more sticky. We ignore * DNS though, to allow a bit of churn to spread the load around and * make sure new tunnels don't stay ignored forever. */ fe->priority /= 10; fe->priority *= 9; pk_log(PK_LOG_MANAGER_DEBUG, "Ping %s: %dms (biased)", printip, fe->priority); } else { /* Add artificial +/-5% jitter to ping results */ fe->priority *= ((rand() % 11) + 95); fe->priority /= 100; pk_log(PK_LOG_MANAGER_DEBUG, "Ping %s: %dms", printip, fe->priority); } PK_CHECK_MEMORY_CANARIES; return NULL; }
/* permitted -- return whether a given host is allowed to connect to the server. */ static int permitted (unsigned long host_addr, int fd) { int key; struct entry *entry; char auth_protocol[128]; char buf[1024]; int auth_data_len; if (fd > 0) { /* we are checking permission on a real connection */ /* Read auth protocol name */ if (timed_read(fd, auth_protocol, AUTH_NAMESZ, AUTH_TIMEOUT, 1) <= 0) return FALSE; if (strcmp (auth_protocol, DEFAUTH_NAME) && strcmp (auth_protocol, MCOOKIE_NAME)) { printf ("authentication protocol (%s) from client is invalid...\n", auth_protocol); printf ("... Was the client an old version of gnuclient/gnudoit?\004\n"); return FALSE; } if (!strcmp(auth_protocol, MCOOKIE_NAME)) { /* * doing magic cookie auth */ if (timed_read (fd, buf, 10, AUTH_TIMEOUT, 1) <= 0) return FALSE; auth_data_len = atoi (buf); if (auth_data_len <= 0 || auth_data_len > (int) sizeof (buf)) { return FALSE; } if (timed_read (fd, buf, auth_data_len, AUTH_TIMEOUT, 0) != auth_data_len) return FALSE; #ifdef AUTH_MAGIC_COOKIE if (server_xauth && server_xauth->data) { /* Do a compare without comprising info about the size of the cookie */ int auth_data_pos; int auth_mismatches = ( auth_data_len ^ server_xauth->data_length ); for(auth_data_pos = 0; auth_data_pos < auth_data_len; ++auth_data_pos) auth_mismatches |= ( buf[auth_data_pos] ^ server_xauth->data[auth_data_pos % server_xauth->data_length]); if (auth_mismatches == 0) return TRUE; for(;rand() % 1000;); } #else printf ("client tried Xauth, but server is not compiled with Xauth\n"); #endif /* * auth failed, but allow this to fall through to the GNU_SECURE * protocol.... */ printf ("Xauth authentication failed, trying GNU_SECURE auth...\004\n"); } /* Other auth protocols go here, and should execute only if the * auth_protocol name matches. */ } /* Now, try the old GNU_SECURE stuff... */ /* First find the hash key */ key = HASH(host_addr) % TABLE_SIZE; /* Now check the chain for that hash key */ for(entry=permitted_hosts[key]; entry != NULL; entry=entry->next) if (host_addr == entry->host_addr) return(TRUE); return(FALSE); } /* permitted */