5 #include <errno.h>

     9 #include "command.h"

    10 #include "request.h"

    15 static void _memcache_conn_bev_write (struct bufferevent *bev, void *arg);

    16 static void _memcache_conn_bev_read (struct bufferevent *bev, void *arg);

    17 static void _memcache_conn_bev_error (struct bufferevent *bev, short what, void *arg);

    18 static void _memcache_conn_ev_write (evutil_socket_t fd, short event, void *arg);

    97 }

    98 

    99 /*

   100  * Start writing out the request data

   101  */

   102 void memcache_conn_send_req_data (struct memcache_conn *conn) {

   103     // just fake a call to the event handler

   104     _memcache_conn_ev_write(conn->fd, EV_WRITE, conn);

   105 }

   106 

   107 /*

   108  * Start reading a reply from the connection

   109  */

   110 void memcache_conn_handle_reply (struct memcache_conn *conn) {

   111     // ensure that we either didn't have a command, or it has been sent

   112     assert(conn->req->buf.data == NULL || conn->req->buf.offset == conn->req->buf.len);

   113 

   114     // start reading on the bufferevent

   115     if (bufferevent_enable(conn->bev, EV_READ))

   116         PERROR("bufferevent_enable");

   117 

   118     // ok, wait for the reply

   119     return;

   120 

   121 error:

   122     // XXX: error handling

   123     assert(0);

   139     // set up the bufferevent

   140     if ((conn->bev = bufferevent_new(fd, 

   141         &_memcache_conn_bev_read,

   142         &_memcache_conn_bev_write,

   143         &_memcache_conn_bev_error,

   144         conn

   145     )) == NULL)

   146         ERROR("bufferevent_new");

   147 

   160 }

   161 

   162 /*

   163  * The write buffer is empty, which means that we have written out a command header

   164  */

   165 static void _memcache_conn_bev_write (struct bufferevent *bev, void *arg) {

   166     struct memcache_conn *conn = arg;

   167 

   168     // the command header has been sent

   169     assert(evbuffer_get_length(bufferevent_get_output(bev)) == 0);

   170     

   171     // does this request have some data to be included in the request?

   172     if (conn->req->buf.data > 0) {

   173         // we need to send the request data next

   174         memcache_conn_send_req_data(conn);

   175 

   176     } else {

   177         // wait for a reply

   178         memcache_conn_handle_reply(conn);

   179     }

   180 }

   181 

   182 /*

   183  * We have received some reply data, which should include the complete reply line at some point

   184  */

   185 static void _memcache_conn_bev_read (struct bufferevent *bev, void *arg) {

   186     struct memcache_conn *conn = arg;

   187     struct evbuffer *in_buf = bufferevent_get_input(bev);

   188     char *header_data;

   189     enum memcache_reply reply_type;

   190     int has_data;

   191     

   192     // ensure that we do indeed have some data

   193     assert(evbuffer_get_length(in_buf) > 0);

   194 

   195     // attempt to parse the response header

   196     if (memcache_cmd_parse_header(in_buf, &header_data, &reply_type, &conn->req->key, &conn->req->obj, &has_data))

   197         ERROR("memcache_cmd_parse_header");

   198 

   199     // XXX: read reply data

   200 

   201 error:

   202     // XXX: error handling

   203     return;

   204 }

   205 

   206 

   207 static void _memcache_conn_bev_error (struct bufferevent *bev, short what, void *arg) {

   208     // XXX: error handling

   209     assert(0);

   210 }

   211 

   212 static void _memcache_conn_ev_write (evutil_socket_t fd, short event, void *arg) {

   213     struct memcache_conn *conn = arg;

   214     struct memcache_buf *buf = &conn->req->buf;

   215     int ret;

   216 

   217     // correct event

   218     assert(event == EV_WRITE);

   219 

   220     // we do indeed have data to send

   221     assert(buf->len > 0 && buf->data != NULL && buf->offset < buf->len);

   222     

   223     // do the actual write()

   224     if ((ret = write(fd, buf->data + buf->offset, buf->len - buf->offset)) == -1 && errno != EAGAIN)

   225         PERROR("write");

   226 

   227     // should never be the case... ?

   228     if (ret == 0)

   229         ERROR("write returned 0 !?!");

   230     

   231     // did we manage to write some data?

   232     if (ret > 0) {

   233         // update offset

   234         buf->offset += ret;

   235     }

   236 

   237     // data left to write?

   238     if (buf->offset < buf->len) {

   239         // reschedule

   240         if (event_add(&conn->ev, NULL))

   241             PERROR("event_add");

   242 

   243     } else {

   244         // done! We can handle the reply now

   245         memcache_conn_handle_reply(conn);

   246     }

   247 

   248     // success

   249     return;

   250 

   251 error:

   252     // XXX: error handling

   253     assert(0);