static void read_remote(ph_sock_t *sock, ph_iomask_t why, void *data) { ph_buf_t *buf; ph_unused_parameter(data); if (why & (PH_IOMASK_TIME|PH_IOMASK_ERR)) { ph_log(PH_LOG_ERR, "disconnecting `P{sockaddr:%p}", (void*)&sock->peername); ph_sock_shutdown(sock, PH_SOCK_SHUT_RDWR); ph_sock_free(sock); remote_sock = NULL; ph_sched_stop(); return; } while (1) { buf = ph_sock_read_line(sock); if (!buf) { // Not available yet, we'll try again later return; } ph_ignore_result(write(STDOUT_FILENO, ph_buf_mem(buf), ph_buf_len(buf))); ph_buf_delref(buf); } }
// Called each time the session wakes up. // The `why` parameter indicates why we were woken up static void echo_processor(ph_sock_t *sock, ph_iomask_t why, void *arg) { struct echo_state *state = arg; ph_buf_t *buf; // If the socket encountered an error, or if the timeout was reached // (there's a default timeout, even if we didn't override it), then // we tear down the session if (why & (PH_IOMASK_ERR|PH_IOMASK_TIME)) { ph_log(PH_LOG_ERR, "disconnecting `P{sockaddr:%p}", (void*)&sock->peername); ph_sock_shutdown(sock, PH_SOCK_SHUT_RDWR); ph_mem_free(mt_state, state); ph_sock_free(sock); return; } // We loop because echo_processor is only triggered by newly arriving // data or events from the kernel. If we have data buffered and only // partially consume it, we won't get woken up until the next data // arrives, if ever. while (1) { // Try to read a line of text. // This returns a slice over the underlying buffer (if the line was // smaller than a buffer) or a freshly made contiguous buffer (if the // line was larger than our buffer segment size). Either way, we // own a reference to the returned buffer and should treat it as // a read-only slice. buf = ph_sock_read_line(sock); if (!buf) { // Not available yet, we'll try again later return; } // We got a line; update our state state->num_lines++; // Send our response. The data is buffered and automatically sent // to the client as it becomes writable, so we don't need to handle // partial writes or EAGAIN here. // If this was a "real" server, we would still check the return value // from the writes and proceed to tear down the session if things failed. // Note that buf includes the trailing CRLF, so our response // will implicitly end with CRLF too. ph_stm_printf(sock->stream, "You said [%d]: ", state->num_lines); ph_stm_write(sock->stream, ph_buf_mem(buf), ph_buf_len(buf), NULL); // We're done with buf, so we must release it ph_buf_delref(buf); } }
int uei_508_read_record(int m_port, char *m_buf, size_t m_buflen, const char *m_delim, uint32_t m_delimlen) { ph_buf_t *tmp_buf; if ((tmp_buf = ph_bufq_consume_record(SL508_read_buffer[m_port], m_delim, m_delimlen))) { size_t len = min((size_t)ph_buf_len(tmp_buf), m_buflen); if (len) memcpy(m_buf, ph_buf_mem(tmp_buf), len); ph_buf_delref(tmp_buf); return len; } else { return 0; } }
static void debug_con_processor(ph_sock_t *sock, ph_iomask_t why, void *arg) { if (why & (PH_IOMASK_ERR|PH_IOMASK_TIME)) { done: ph_sock_shutdown(sock, PH_SOCK_SHUT_RDWR); ph_sock_free(sock); return; } if (arg && (why & PH_IOMASK_WRITE) && ph_bufq_len(sock->wbuf) == 0) { goto done; } if (arg == NULL && (why & PH_IOMASK_READ)) { ph_buf_t *buf; char *cmd; int len; uint32_t i; buf = ph_sock_read_line(sock); if (!buf) { return; } sock->job.data = buf; ph_sock_shutdown(sock, PH_SOCK_SHUT_RD); cmd = (char*)ph_buf_mem(buf); len = ph_buf_len(buf); /* replace CRLF with NUL termination */ cmd[len - 2] = '\0'; for (i = 0; i < sizeof(funcs)/sizeof(funcs[0]); i++) { if (strcmp(funcs[i].name, cmd)) { continue; } funcs[i].func(sock); break; } } }
static void test_straddle_edges(void) { const char *delim = "\r\n"; int delim_len = strlen(delim); int default_buf_size = 8192; int i; char pad[8192]; memset(pad, 'x', sizeof(pad)); #define PAD_IT(__n) { \ uint64_t n = __n; \ while (n > 0) { \ ph_bufq_append(q, pad, MIN(n, sizeof(pad)), 0); \ n -= MIN(n, sizeof(pad)); \ } \ } // We want two buffers: [8192][8192] // And then to place our delimiter around the first boundary to verify // that the delimiter matching operates correctly // We define a cursor offset relative to the end of the first buffer // (0 means the last byte of the delimiter is in the last byte of the // first buffer, 1 means that the last delimiter byte is in the first // byte of the second buffer) for (i = - 2 * delim_len; i < 2 * delim_len; i++) { ph_bufq_t *q; q = ph_bufq_new(16*1024); // Fill up the start of the buffer uint64_t num_first = default_buf_size + i - delim_len; // first data PAD_IT(num_first); is(num_first, ph_bufq_len(q)); // first delim ph_bufq_append(q, delim, delim_len, 0); // second data PAD_IT(16); // second delim ph_bufq_append(q, delim, delim_len, 0); ph_buf_t *first = ph_bufq_consume_record(q, delim, delim_len); is_int(num_first + 2, ph_buf_len(first)); ph_buf_t *second = ph_bufq_consume_record(q, delim, delim_len); is_int(18, ph_buf_len(second)); diag("for i = %d, num_first = %d. first->len=%d second->len=%d", i, (int)num_first, (int)ph_buf_len(first), (int)ph_buf_len(second)); ph_buf_delref(first); ph_buf_delref(second); ph_bufq_free(q); } // Now, test the case where we have a partial match at a boundary, but not // the true match until later ph_bufq_t *q; q = ph_bufq_new(24*1024); PAD_IT(8191); ph_bufq_append(q, "\r", 1, 0); PAD_IT(8192); ph_bufq_append(q, delim, delim_len, 0); ph_buf_t *first = ph_bufq_consume_record(q, delim, delim_len); is_int(16386, ph_buf_len(first)); ph_buf_delref(first); ph_bufq_free(q); }