One Level Up Top Level

src/client.c - weighttp

Functions defined

Source code

  1. /*
  2. * weighttp - a lightweight and simple webserver benchmarking tool
  3. *
  4. * Author:
  5. *     Copyright (c) 2009-2011 Thomas Porzelt
  6. *
  7. * License:
  8. *     MIT, see COPYING file
  9. */

  11. #include "weighttp.h"

  13. static uint8_t client_parse(Client *client, int size);
  14. static void client_io_cb(struct ev_loop *loop, ev_io *w, int revents);
  15. static void client_set_events(Client *client, int events);
  16. /*
  17. static void client_add_events(Client *client, int events);
  18. static void client_rem_events(Client *client, int events);

  20. static void client_add_events(Client *client, int events) {
  21.     struct ev_loop *loop = client->worker->loop;
  22.     ev_io *watcher = &client->sock_watcher;

  24.     if ((watcher->events & events) == events)
  25.         return;

  27.     ev_io_stop(loop, watcher);
  28.     ev_io_set(watcher, watcher->fd, watcher->events | events);
  29.     ev_io_start(loop, watcher);
  30. }

  32. static void client_rem_events(Client *client, int events) {
  33.     struct ev_loop *loop = client->worker->loop;
  34.     ev_io *watcher = &client->sock_watcher;

  36.     if (0 == (watcher->events & events))
  37.         return;

  39.     ev_io_stop(loop, watcher);
  40.     ev_io_set(watcher, watcher->fd, watcher->events & ~events);
  41.     ev_io_start(loop, watcher);
  42. }
  43. */

  45. ‌static void client_set_events(Client *client, int events) {
  46.     struct ev_loop *loop = client->worker->loop;
  47.     ev_io *watcher = &client->sock_watcher;

  49.     if (events == (watcher->events & (EV_READ | EV_WRITE)))
  50.         return;

  52.     ev_io_stop(loop, watcher);
  53.     ev_io_set(watcher, watcher->fd, (watcher->events & ~(EV_READ | EV_WRITE)) | events);
  54.     ev_io_start(loop, watcher);
  55. }

  57. ‌Client *client_new(Worker *worker) {
  58.     Client *client;

  60.     client = W_MALLOC(Client, 1);
  61.     client->state = CLIENT_START;
  62.     client->worker = worker;
  63.     client->sock_watcher.fd = -1;
  64.     client->sock_watcher.data = client;
  65.     client->content_length = -1;
  66.     client->buffer_offset = 0;
  67.     client->request_offset = 0;
  68.     client->keepalive = client->worker->config->keep_alive;
  69.     client->chunked = 0;
  70.     client->chunk_size = -1;
  71.     client->chunk_received = 0;

  73.     return client;
  74. }

  76. ‌void client_free(Client *client) {
  77.     if (client->sock_watcher.fd != -1) {
  78.         ev_io_stop(client->worker->loop, &client->sock_watcher);
  79.         shutdown(client->sock_watcher.fd, SHUT_WR);
  80.         close(client->sock_watcher.fd);
  81.     }

  83.     free(client);
  84. }

  86. ‌static void client_reset(Client *client) {
  87.     //printf("keep alive: %d\n", client->keepalive);
  88.     if (!client->keepalive) {
  89.         if (client->sock_watcher.fd != -1) {
  90.             ev_io_stop(client->worker->loop, &client->sock_watcher);
  91.             shutdown(client->sock_watcher.fd, SHUT_WR);
  92.             close(client->sock_watcher.fd);
  93.             client->sock_watcher.fd = -1;
  94.         }

  96.         client->state = CLIENT_START;
  97.     } else {
  98.         client_set_events(client, EV_WRITE);
  99.         client->state = CLIENT_WRITING;
  100.         client->worker->stats.req_started++;
  101.     }

  103.     client->parser_state = PARSER_START;
  104.     client->buffer_offset = 0;
  105.     client->parser_offset = 0;
  106.     client->request_offset = 0;
  107.     client->ts_start = 0;
  108.     client->ts_end = 0;
  109.     client->status_success = 0;
  110.     client->success = 0;
  111.     client->content_length = -1;
  112.     client->bytes_received = 0;
  113.     client->header_size = 0;
  114.     client->keepalive = client->worker->config->keep_alive;
  115.     client->chunked = 0;
  116.     client->chunk_size = -1;
  117.     client->chunk_received = 0;
  118. }

  120. ‌static uint8_t client_connect(Client *client) {
  121.     //printf("connecting...\n");
  122.     start:

  124.     if (-1 == connect(client->sock_watcher.fd, client->worker->config->saddr->ai_addr, client->worker->config->saddr->ai_addrlen)) {
  125.         switch (errno) {
  126.             case EINPROGRESS:
  127.             case EALREADY:
  128.                 /* async connect now in progress */
  129.                 client->state = CLIENT_CONNECTING;
  130.                 return 1;
  131.             case EISCONN:
  132.                 break;
  133.             case EINTR:
  134.                 goto start;
  135.             default:
  136.             {
  137.                 strerror_r(errno, client->buffer, sizeof(client->buffer));
  138.                 W_ERROR("connect() failed: %s (%d)", client->buffer, errno);
  139.                 return 0;
  140.             }
  141.         }
  142.     }

  144.     /* successfully connected */
  145.     client->state = CLIENT_WRITING;
  146.     return 1;
  147. }

  149. ‌static void client_io_cb(struct ev_loop *loop, ev_io *w, int revents) {
  150.     Client *client = w->data;

  152.     UNUSED(loop);
  153.     UNUSED(revents);

  155.     client_state_machine(client);
  156. }

  158. ‌void client_state_machine(Client *client) {
  159.     int r;
  160.     Config *config = client->worker->config;

  162.     start:
  163.     //printf("state: %d\n", client->state);
  164.     switch (client->state) {
  165.         case CLIENT_START:
  166.             client->worker->stats.req_started++;

  168.             do {
  169.                 r = socket(config->saddr->ai_family, config->saddr->ai_socktype, config->saddr->ai_protocol);
  170.             } while (-1 == r && errno == EINTR);

  172.             if (-1 == r) {
  173.                 client->state = CLIENT_ERROR;
  174.                 strerror_r(errno, client->buffer, sizeof(client->buffer));
  175.                 W_ERROR("socket() failed: %s (%d)", client->buffer, errno);
  176.                 goto start;
  177.             }

  179.             /* set non-blocking */
  180.             fcntl(r, F_SETFL, O_NONBLOCK | O_RDWR);

  182.             ev_init(&client->sock_watcher, client_io_cb);
  183.             ev_io_set(&client->sock_watcher, r, EV_WRITE);
  184.             ev_io_start(client->worker->loop, &client->sock_watcher);

  186.             if (!client_connect(client)) {
  187.                 client->state = CLIENT_ERROR;
  188.                 goto start;
  189.             } else {
  190.                 client_set_events(client, EV_WRITE);
  191.                 return;
  192.             }
  193.         case CLIENT_CONNECTING:
  194.             if (!client_connect(client)) {
  195.                 client->state = CLIENT_ERROR;
  196.                 goto start;
  197.             }
  198.         case CLIENT_WRITING:
  199.             while (1) {
  200.                 r = write(client->sock_watcher.fd, &config->request[client->request_offset], config->request_size - client->request_offset);
  201.                 //printf("write(%d - %d = %d): %d\n", config->request_size, client->request_offset, config->request_size - client->request_offset, r);
  202.                 if (r == -1) {
  203.                     /* error */
  204.                     if (errno == EINTR)
  205.                         continue;
  206.                     strerror_r(errno, client->buffer, sizeof(client->buffer));
  207.                     W_ERROR("write() failed: %s (%d)", client->buffer, errno);
  208.                     client->state = CLIENT_ERROR;
  209.                     goto start;
  210.                 } else if (r != 0) {
  211.                     /* success */
  212.                     client->request_offset += r;
  213.                     if (client->request_offset == config->request_size) {
  214.                         /* whole request was sent, start reading */
  215.                         client->state = CLIENT_READING;
  216.                         client_set_events(client, EV_READ);
  217.                     }

  219.                     return;
  220.                 } else {
  221.                     /* disconnect */
  222.                     client->state = CLIENT_END;
  223.                     goto start;
  224.                 }
  225.             }
  226.         case CLIENT_READING:
  227.             while (1) {
  228.                 r = read(client->sock_watcher.fd, &client->buffer[client->buffer_offset], sizeof(client->buffer) - client->buffer_offset - 1);
  229.                 //printf("read(): %d, offset was: %d\n", r, client->buffer_offset);
  230.                 if (r == -1) {
  231.                     /* error */
  232.                     if (errno == EINTR)
  233.                         continue;
  234.                     strerror_r(errno, client->buffer, sizeof(client->buffer));
  235.                     W_ERROR("read() failed: %s (%d)", client->buffer, errno);
  236.                     client->state = CLIENT_ERROR;
  237.                 } else if (r != 0) {
  238.                     /* success */
  239.                     client->bytes_received += r;
  240.                     client->buffer_offset += r;
  241.                     client->worker->stats.bytes_total += r;

  243.                     if (client->buffer_offset >= sizeof(client->buffer)) {
  244.                         /* too big response header */
  245.                         client->state = CLIENT_ERROR;
  246.                         break;
  247.                     }
  248.                     client->buffer[client->buffer_offset] = '\0';
  249.                     //printf("buffer:\n==========\n%s\n==========\n", client->buffer);
  250.                     if (!client_parse(client, r)) {
  251.                         client->state = CLIENT_ERROR;
  252.                         //printf("parser failed\n");
  253.                         break;
  254.                     } else {
  255.                         if (client->state == CLIENT_END)
  256.                             goto start;
  257.                         else
  258.                             return;
  259.                     }
  260.                 } else {
  261.                     /* disconnect */
  262.                     if (client->parser_state == PARSER_BODY && !client->keepalive && client->status_success
  263.                         && !client->chunked && client->content_length == -1) {
  264.                         client->success = 1;
  265.                         client->state = CLIENT_END;
  266.                     } else {
  267.                         client->state = CLIENT_ERROR;
  268.                     }

  270.                     goto start;
  271.                 }
  272.             }

  274.         case CLIENT_ERROR:
  275.             //printf("client error\n");
  276.             client->worker->stats.req_error++;
  277.             client->keepalive = 0;
  278.             client->success = 0;
  279.             client->state = CLIENT_END;
  280.         case CLIENT_END:
  281.             /* update worker stats */
  282.             client->worker->stats.req_done++;

  284.             if (client->success) {
  285.                 client->worker->stats.req_success++;
  286.                 client->worker->stats.bytes_body += client->bytes_received - client->header_size;
  287.             } else {
  288.                 client->worker->stats.req_failed++;
  289.             }

  291.             /* print progress every 10% done */
  292.             if (client->worker->id == 1 && client->worker->stats.req_done % client->worker->progress_interval == 0) {
  293.                 printf("progress: %3d%% done\n",
  294.                     (int) (client->worker->stats.req_done * 100 / client->worker->stats.req_todo)
  295.                 );
  296.             }

  298.             if (client->worker->stats.req_started == client->worker->stats.req_todo) {
  299.                 /* this worker has started all requests */
  300.                 client->keepalive = 0;
  301.                 client_reset(client);

  303.                 if (client->worker->stats.req_done == client->worker->stats.req_todo) {
  304.                     /* this worker has finished all requests */
  305.                     ev_unref(client->worker->loop);
  306.                 }
  307.             } else {
  308.                 client_reset(client);
  309.                 goto start;
  310.             }
  311.     }
  312. }


  315. ‌static uint8_t client_parse(Client *client, int size) {
  316.     char *end, *str;
  317.     uint16_t status_code;

  319.     switch (client->parser_state) {
  320.         case PARSER_START:
  321.             //printf("parse (START):\n%s\n", &client->buffer[client->parser_offset]);
  322.             /* look for HTTP/1.1 200 OK */
  323.             if (client->buffer_offset < sizeof("HTTP/1.1 200\r\n"))
  324.                 return 1;

  326.             if (strncmp(client->buffer, "HTTP/1.1 ", sizeof("HTTP/1.1 ")-1) != 0)
  327.                 return 0;

  329.             // now the status code
  330.             status_code = 0;
  331.             str = client->buffer + sizeof("HTTP/1.1 ")-1;
  332.             for (end = str + 3; str != end; str++) {
  333.                 if (*str < '0' || *str > '9')
  334.                     return 0;

  336.                 status_code *= 10;
  337.                 status_code += *str - '0';
  338.             }

  340.             if (status_code >= 200 && status_code < 300) {
  341.                 client->worker->stats.req_2xx++;
  342.                 client->status_success = 1;
  343.             } else if (status_code < 400) {
  344.                 client->worker->stats.req_3xx++;
  345.                 client->status_success = 1;
  346.             } else if (status_code < 500) {
  347.                 client->worker->stats.req_4xx++;
  348.             } else if (status_code < 600) {
  349.                 client->worker->stats.req_5xx++;
  350.             } else {
  351.                 // invalid status code
  352.                 return 0;
  353.             }

  355.             // look for next \r\n
  356.             end = strchr(end, '\r');
  357.             if (!end || *(end+1) != '\n')
  358.                 return 0;

  360.             client->parser_offset = end + 2 - client->buffer;
  361.             client->parser_state = PARSER_HEADER;
  362.         case PARSER_HEADER:
  363.             //printf("parse (HEADER)\n");
  364.             /* look for Content-Length and Connection header */
  365.             while (NULL != (end = strchr(&client->buffer[client->parser_offset], '\r'))) {
  366.                 if (*(end+1) != '\n')
  367.                     return 0;

  369.                 if (end == &client->buffer[client->parser_offset]) {
  370.                     /* body reached */
  371.                     client->parser_state = PARSER_BODY;
  372.                     client->header_size = end + 2 - client->buffer;
  373.                     //printf("body reached\n");

  375.                     return client_parse(client, size - client->header_size);
  376.                 }

  378.                 *end = '\0';
  379.                 str = &client->buffer[client->parser_offset];
  380.                 //printf("checking header: '%s'\n", str);

  382.                 if (strncmp(str, "Content-Length: ", sizeof("Content-Length: ")-1) == 0) {
  383.                     /* content length header */
  384.                     client->content_length = str_to_uint64(str + sizeof("Content-Length: ") - 1);
  385.                 } else if (strncmp(str, "Connection: ", sizeof("Connection: ")-1) == 0) {
  386.                     /* connection header */
  387.                     str += sizeof("Connection: ") - 1;

  389.                     if (strncmp(str, "close", sizeof("close")-1) == 0)
  390.                         client->keepalive = 0;
  391.                     else if (strncmp(str, "Keep-Alive", sizeof("Keep-Alive")-1) == 0)
  392.                         client->keepalive = client->worker->config->keep_alive;
  393.                     else if (strncmp(str, "keep-alive", sizeof("keep-alive")-1) == 0)
  394.                         client->keepalive = client->worker->config->keep_alive;
  395.                     else
  396.                         return 0;
  397.                 } else if (strncmp(str, "Transfer-Encoding: ", sizeof("Transfer-Encoding: ")-1) == 0) {
  398.                     /* transfer encoding header */
  399.                     str += sizeof("Transfer-Encoding: ") - 1;

  401.                     if (strncmp(str, "chunked", sizeof("chunked")-1) == 0)
  402.                         client->chunked = 1;
  403.                     else
  404.                         return 0;
  405.                 }


  408.                 if (*(end+2) == '\r' && *(end+3) == '\n') {
  409.                     /* body reached */
  410.                     client->parser_state = PARSER_BODY;
  411.                     client->header_size = end + 4 - client->buffer;
  412.                     client->parser_offset = client->header_size;
  413.                     //printf("body reached\n");

  415.                     return client_parse(client, size - client->header_size);
  416.                 }

  418.                 client->parser_offset = end - client->buffer + 2;
  419.             }

  421.             return 1;
  422.         case PARSER_BODY:
  423.             //printf("parse (BODY)\n");
  424.             /* do nothing, just consume the data */
  425.             /*printf("content-l: %"PRIu64", header: %d, recevied: %"PRIu64"\n",
  426.             client->content_length, client->header_size, client->bytes_received);*/

  428.             if (client->chunked) {
  429.                 int consume_max;

  431.                 str = &client->buffer[client->parser_offset];
  432.                 /*printf("parsing chunk: '%s'\n(%"PRIi64" received, %"PRIi64" size, %d parser offset)\n",
  433.                     str, client->chunk_received, client->chunk_size, client->parser_offset
  434.                 );*/

  436.                 if (client->chunk_size == -1) {
  437.                     /* read chunk size */
  438.                     client->chunk_size = 0;
  439.                     client->chunk_received = 0;
  440.                     end = str + size;

  442.                     for (; str < end; str++) {
  443.                         if (*str == ';' || *str == '\r')
  444.                             break;

  446.                         client->chunk_size *= 16;
  447.                         if (*str >= '0' && *str <= '9')
  448.                             client->chunk_size += *str - '0';
  449.                         else if (*str >= 'A' && *str <= 'Z')
  450.                             client->chunk_size += 10 + *str - 'A';
  451.                         else if (*str >= 'a' && *str <= 'z')
  452.                             client->chunk_size += 10 + *str - 'a';
  453.                         else
  454.                             return 0;
  455.                     }

  457.                     str = strstr(str, "\r\n");
  458.                     if (!str)
  459.                         return 0;
  460.                     str += 2;

  462.                     //printf("---------- chunk size: %"PRIi64", %d read, %d offset, data: '%s'\n", client->chunk_size, size, client->parser_offset, str);

  464.                     if (client->chunk_size == 0) {
  465.                         /* chunk of size 0 marks end of content body */
  466.                         client->state = CLIENT_END;
  467.                         client->success = client->status_success ? 1 : 0;
  468.                         return 1;
  469.                     }

  471.                     size -= str - &client->buffer[client->parser_offset];
  472.                     client->parser_offset = str - client->buffer;
  473.                 }

  475.                 /* consume chunk till chunk_size is reached */
  476.                 consume_max = client->chunk_size - client->chunk_received;

  478.                 if (size < consume_max)
  479.                     consume_max = size;

  481.                 client->chunk_received += consume_max;
  482.                 client->parser_offset += consume_max;

  484.                 //printf("---------- chunk consuming: %d, received: %"PRIi64" of %"PRIi64", offset: %d\n", consume_max, client->chunk_received, client->chunk_size, client->parser_offset);

  486.                 if (client->chunk_received == client->chunk_size) {
  487.                     if (client->buffer[client->parser_offset] != '\r' || client->buffer[client->parser_offset+1] != '\n')
  488.                         return 0;

  490.                     /* got whole chunk, next! */
  491.                     //printf("---------- got whole chunk!!\n");
  492.                     client->chunk_size = -1;
  493.                     client->chunk_received = 0;
  494.                     client->parser_offset += 2;
  495.                     consume_max += 2;

  497.                     /* there is stuff left to parse */
  498.                     if (size - consume_max > 0)
  499.                         return client_parse(client, size - consume_max);
  500.                 }

  502.                 client->parser_offset = 0;
  503.                 client->buffer_offset = 0;

  505.                 return 1;
  506.             } else {
  507.                 /* not chunked, just consume all data till content-length is reached */
  508.                 client->buffer_offset = 0;

  510.                 if (client->content_length == -1)
  511.                     return 0;

  513.                 if (client->bytes_received == (uint64_t) (client->header_size + client->content_length)) {
  514.                     /* full response received */
  515.                     client->state = CLIENT_END;
  516.                     client->success = client->status_success ? 1 : 0;
  517.                 }
  518.             }

  520.             return 1;
  521.     }

  523.     return 1;
  524. }

One Level Up Top Level