1 

     2 #include "line_proto.h"

     3 

     4 #include <string.h>

     5 #include <stdlib.h>

     6 #include <assert.h>

     7 

     8 /*

     9  * Our state

    10  */

    11 struct line_proto {

    12     /* The sock_stream we read/write with */

    13     struct sock_stream *sock;

    14 

    15     /* Offset of trailing data in buf */

    16     size_t tail_offset;

    17 

    18     /* Length of trailing data in buf, if any */

    19     size_t tail_len;

    20 

    21     /* Last error */

    22     struct error_info err;

    23 };

    24 

    25 err_t line_proto_create (struct line_proto **lp_ptr, struct sock_stream *sock, struct error_info *err)

    26 {

    27     struct line_proto *lp;

    28 

    29     // allocate

    30     if ((lp = calloc(1, sizeof(*lp))) == NULL)

    31         return SET_ERROR(err, ERR_CALLOC);

    32 

    33     // store

    34     lp->sock = sock;

    35 

    36     // return

    37     *lp_ptr = lp;

    38 

    39     return SUCCESS;

    40 }

    41 

    42 /*

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

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

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

    46  *

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

    48  * on the same buffer.

    49  *

    50  */

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

    52     int i;

    53 

    54     // empty buffer -> nothing

    55     if (len == 0)

    56         return 0;

    57 

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

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

    60         // match this + next char

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

    62             break;

    63     }

    64 

    65     // incomplete?

    66     if (i >= len - 1) {

    67         *hint = len - 1;

    68         return 0;

    69     }

    70 

    71     // mangle the newline off

    72     buf[i] = '\0';

    73 

    74     // return offset to next line

    75     return i + 2;

    76 }

    77 

    78 err_t line_proto_read (struct line_proto *lp, char *buf, size_t len)

    79 {

    80     // offset to recv() new data into, offset to _parse_line hint, offset to next line from _parse_line

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

    82     int ret;

    83 

    84     // adjust offset from previous data

    85     recv_offset = lp->tail_len;

    86 

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

    88     if (lp->tail_offset) {

    89         // move to front

    90         memmove(buf, buf + lp->tail_offset, lp->tail_len);

    91 

    92         // reset

    93         lp->tail_offset = 0;

    94         lp->tail_len = 0;

    95     }

    96 

    97     // readline loop

    98     do {

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

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

   101             break;

   102 

   103         // ensure there's enough space for it

   104         assert(recv_offset < len);

   105         

   106         // otherwise, read more data

   107         if ((ret = sock_stream_read(lp->sock, buf + recv_offset, len - recv_offset)) < 0)

   108             RETURN_SET_ERROR_INFO(&lp->err, sock_stream_error(lp->sock));

   109 

   110         // EOF?

   111         if (ret == 0)

   112             return SET_ERROR(&lp->err, ERR_READ_EOF);

   113         

   114         // update recv_offset

   115         recv_offset += ret;

   116 

   117     } while (1);

   118 

   119     // update state for next call

   120     lp->tail_offset = next_offset;

   121     lp->tail_len = recv_offset - next_offset;

   122 

   123     // ok

   124     return SUCCESS;

   125 }

   126 

   127 const struct error_info* line_proto_error (struct line_proto *lp)

   128 {

   129     // return pointer

   130     return &lp->err;

   131 }