16 

    17 struct recvline_state {

    18     size_t tail_offset;

    19     size_t tail_len;

    20 };

    21 

    22 /*

    23  * This looks for a full '\r\n' terminated line at the beginning of the given buffer. If found, the \r\n will be

    24  * replaced with a '\0', and the offset to the beginning of the next line returned. If not found, zero is returned

    25  * (which is never a valid next-line offset).

    26  *

    27  * The given \a hint is an hint as to the offset at which to start scanning, used for incremental invocations of this

    28  * on the same buffer.

    29  *

    30  */

    31 int _parse_line (char *buf, size_t len, size_t *hint) {

    32     int i;

    33 

    34     // empty buffer -> nothing

    35     if (len == 0)

    36         return 0;

    37 

    38     // look for terminating '\r\n' sequence

    39     for (i = *hint; i < len - 1; i++) {

    40         // match this + next char

    41         if (buf[i] == '\r' && buf[i + 1] == '\n')

    42             break;

    43     }

    44 

    45     // incomplete?

    46     if (i >= len - 1) {

    47         *hint = len - 1;

    48         return 0;

    49     }

    50 

    51     // mangle the newline off

    52     buf[i] = '\0';

    53 

    54     // return offset to next line

    55     return i + 2;

    56 }

    57 

    58 /*

    59  * Receive one line of data into the buffer of the given length

    60  */

    61 int recvline (struct sock_stream *sock, char *buf, size_t len, struct recvline_state *ctx) {

    62     size_t recv_offset = 0, peek_offset = 0, next_offset = 0;

    63     int ret;

    64 

    65     // adjust offset from previous data

    66     recv_offset = ctx->tail_len;

    67 

    68     // move trailing data from previous line to front of buffer

    69     if (ctx->tail_offset) {

    70         // move to front

    71         memmove(buf, buf + ctx->tail_offset, ctx->tail_len);

    72 

    73         // reset

    74         ctx->tail_offset = 0;

    75         ctx->tail_len = 0;

    76     }

    77 

    78     // readline loop

    79     do {

    80         // parse any line at the beginning of the buffer

    81         if ((next_offset = _parse_line(buf, recv_offset, &peek_offset)) > 0)

    82             break;

    83 

    84         // ensure there's enough space for it

    85         assert(recv_offset < len);

    86         

    87         // otherwise, read more data

    88         if ((ret = sock_stream_read(sock, buf + recv_offset, len - recv_offset)) < 0)

    89             err(1, "read");

    90 

    91         // EOF?

    92         if (ret == 0)

    93             errx(1, "read: EOF");

    94         

    95         // update recv_offset

    96         recv_offset += ret;

    97     } while (1);

    98 

    99     // update state for next call

   100     ctx->tail_offset = next_offset;

   101     ctx->tail_len = recv_offset - next_offset;

   102 

   103     // ok

   104     return 0;

   105 }

   110     struct recvline_state recvline_ctx;

   117     memset(&recvline_ctx, 0, sizeof(recvline_ctx));

   118