1 files changed, 180 insertions, 149 deletions

diff --git a/src/examples/mhd2spdy_spdy.c b/src/examples/mhd2spdy_spdy.c
index 8640df35..413de7f3 100644
--- a/src/examples/mhd2spdy_spdy.c
+++ b/src/examples/mhd2spdy_spdy.c
@@ -35,29 +35,27 @@
 #include "mhd2spdy_spdy.h"
 #include "mhd2spdy_http.h"
 
-enum
-{
-  IO_NONE,
-  WANT_READ,
-  WANT_WRITE
-};
-
 
 /*
  * Prints error containing the function name |func| and message |msg|
  * and exit.
  */
-static void spdy_dief(const char *func, const char *msg)
+static void
+spdy_dief(const char *func,
+          const char *msg)
 {
   fprintf(stderr, "FATAL: %s: %s\n", func, msg);
   exit(EXIT_FAILURE);
 }
 
+
 /*
  * Prints error containing the function name |func| and error code
  * |error_code| and exit.
  */
-void spdy_diec(const char *func, int error_code)
+void
+spdy_diec(const char *func,
+          int error_code)
 {
   fprintf(stderr, "FATAL: %s: error_code=%d, msg=%s\n", func, error_code,
           spdylay_strerror(error_code));
@@ -71,11 +69,12 @@ void spdy_diec(const char *func, int error_code)
  * bytes actually written. See the documentation of
  * spdylay_send_callback for the details.
  */
-static ssize_t spdy_cb_send(spdylay_session *session,
-                             const uint8_t *data,
-                             size_t length,
-                             int flags,
-                             void *user_data)
+static ssize_t
+spdy_cb_send(spdylay_session *session,
+             const uint8_t *data,
+             size_t length,
+             int flags,
+             void *user_data)
 {
   (void)session;
   (void)flags;
@@ -126,15 +125,19 @@ static ssize_t spdy_cb_send(spdylay_session *session,
   return rv;
 }
 
+
 /*
  * The implementation of spdylay_recv_callback type. Here we read data
  * from the network and write them in |buf|. The capacity of |buf| is
  * |length| bytes. Returns the number of bytes stored in |buf|. See
  * the documentation of spdylay_recv_callback for the details.
  */
-static ssize_t spdy_cb_recv(spdylay_session *session,
-                             uint8_t *buf, size_t length, int flags,
-                             void *user_data)
+static ssize_t
+spdy_cb_recv(spdylay_session *session,
+             uint8_t *buf,
+             size_t length, 
+             int flags,
+             void *user_data)
 {
   (void)session;
   (void)flags;
@@ -191,63 +194,47 @@ static ssize_t spdy_cb_recv(spdylay_session *session,
   return rv;
 }
 
-/*
- * The implementation of spdylay_before_ctrl_send_callback type.  We
- * use this function to get stream ID of the request. This is because
- * stream ID is not known when we submit the request
- * (spdylay_spdy_submit_request).
- */
-/*static void spdy_cb_before_ctrl_send(spdylay_session *session,
-                                      spdylay_frame_type type,
-                                      spdylay_frame *frame,
-                                      void *user_data)
-{
-}*/
-
 
-static void spdy_cb_on_ctrl_send(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
+static void
+spdy_cb_on_ctrl_send(spdylay_session *session,
+                    spdylay_frame_type type,
+                    spdylay_frame *frame,
+                    void *user_data)
 {
   (void)user_data;
   
-  //char **nv;
-  //const char *name = NULL;
   int32_t stream_id;
-  //size_t i;
   struct Proxy *proxy;
   
   switch(type) {
-  case SPDYLAY_SYN_STREAM:
-    //nv = frame->syn_stream.nv;
-    //name = "SYN_STREAM";
-    stream_id = frame->syn_stream.stream_id;
-    proxy = spdylay_session_get_stream_user_data(session, stream_id);
-    ++glob_opt.streams_opened;
-    ++proxy->spdy_connection->streams_opened;
-  PRINT_INFO2("opening stream: str open %i; %s", glob_opt.streams_opened, proxy->url);
-    break;
-  default:
-    break;
+    case SPDYLAY_SYN_STREAM:
+      stream_id = frame->syn_stream.stream_id;
+      proxy = spdylay_session_get_stream_user_data(session, stream_id);
+      ++glob_opt.streams_opened;
+      ++proxy->spdy_connection->streams_opened;
+      PRINT_INFO2("opening stream: str open %i; %s", glob_opt.streams_opened, proxy->url);
+      break;
+    default:
+      break;
   }
 }
 
-void spdy_cb_on_ctrl_recv(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
+
+void
+spdy_cb_on_ctrl_recv(spdylay_session *session,
+                    spdylay_frame_type type,
+                    spdylay_frame *frame,
+                    void *user_data)
 {
   (void)user_data;
   
-  //struct SPDY_Request *req;
   char **nv;
-  //const char *name = NULL;
   int32_t stream_id;
   struct Proxy * proxy;
 
   switch(type) {
     case SPDYLAY_SYN_REPLY:
       nv = frame->syn_reply.nv;
-      //name = "SYN_REPLY";
       stream_id = frame->syn_reply.stream_id;
     break;
     case SPDYLAY_RST_STREAM:
@@ -255,7 +242,6 @@ void spdy_cb_on_ctrl_recv(spdylay_session *session,
     break;
     case SPDYLAY_HEADERS:
       nv = frame->headers.nv;
-      //name = "HEADERS";
       stream_id = frame->headers.stream_id;
     break;
     default:
@@ -269,34 +255,37 @@ void spdy_cb_on_ctrl_recv(spdylay_session *session,
 
   switch(type) {
     case SPDYLAY_SYN_REPLY:
-  PRINT_INFO2("received headers for %s", proxy->url);
-  http_create_response(proxy, nv);
+      PRINT_INFO2("received headers for %s", proxy->url);
+      http_create_response(proxy, nv);
     break;
     case SPDYLAY_RST_STREAM:
-  PRINT_INFO2("received reset stream for %s", proxy->url);
-  proxy->error = true;
+      PRINT_INFO2("received reset stream for %s", proxy->url);
+      proxy->error = true;
     break;
     case SPDYLAY_HEADERS:
-  PRINT_INFO2("received headers for %s", proxy->url);
-  http_create_response(proxy, nv);
+      PRINT_INFO2("received headers for %s", proxy->url);
+      http_create_response(proxy, nv);
     break;
     default:
       return;
     break;
   }
+  
   glob_opt.spdy_data_received = true;
 }
 
+
 /*
  * The implementation of spdylay_on_stream_close_callback type. We use
  * this function to know the response is fully received. Since we just
  * fetch 1 resource in this program, after reception of the response,
  * we submit GOAWAY and close the session.
  */
-static void spdy_cb_on_stream_close(spdylay_session *session,
-                                     int32_t stream_id,
-                                     spdylay_status_code status_code,
-                                     void *user_data)
+static void
+spdy_cb_on_stream_close(spdylay_session *session,
+                       int32_t stream_id,
+                       spdylay_status_code status_code,
+                       void *user_data)
 {
   (void)status_code;
   (void)user_data;
@@ -315,24 +304,24 @@ static void spdy_cb_on_stream_close(spdylay_session *session,
     proxy->spdy_active = false;
   else
     free_proxy(proxy);
-  return;
 }
 
-#define SPDY_MAX_OUTLEN 4096
 
 /*
  * The implementation of spdylay_on_data_chunk_recv_callback type. We
  * use this function to print the received response body.
  */
-static void spdy_cb_on_data_chunk_recv(spdylay_session *session, uint8_t flags,
-                                        int32_t stream_id,
-                                        const uint8_t *data, size_t len,
-                                        void *user_data)
+static void
+spdy_cb_on_data_chunk_recv(spdylay_session *session,
+                          uint8_t flags,
+                          int32_t stream_id,
+                          const uint8_t *data,
+                          size_t len,
+                          void *user_data)
 {
   (void)flags;
   (void)user_data;
   
-  //struct SPDY_Request *req;
   struct Proxy *proxy;
   proxy = spdylay_session_get_stream_user_data(session, stream_id);
         
@@ -348,12 +337,17 @@ static void spdy_cb_on_data_chunk_recv(spdylay_session *session, uint8_t flags,
 
         memcpy(proxy->http_body + proxy->http_body_size, data, len);
         proxy->http_body_size += len;
-    PRINT_INFO2("received data for %s; %zu bytes", proxy->url, len);
+  PRINT_INFO2("received data for %s; %zu bytes", proxy->url, len);
   glob_opt.spdy_data_received = true;
 }
 
-static void spdy_cb_on_data_recv(spdylay_session *session,
-                uint8_t flags, int32_t stream_id, int32_t length, void *user_data)
+
+static void
+spdy_cb_on_data_recv(spdylay_session *session,
+                                 uint8_t flags,
+                     int32_t stream_id,
+                     int32_t length,
+                     void *user_data)
 {
   (void)length;
   (void)user_data;
@@ -367,18 +361,19 @@ static void spdy_cb_on_data_recv(spdylay_session *session,
         }
 }
 
+
 /*
  * Setup callback functions. Spdylay API offers many callback
  * functions, but most of them are optional. The send_callback is
  * always required. Since we use spdylay_session_recv(), the
  * recv_callback is also required.
  */
-static void spdy_setup_spdylay_callbacks(spdylay_session_callbacks *callbacks)
+static void
+spdy_setup_spdylay_callbacks(spdylay_session_callbacks *callbacks)
 {
   memset(callbacks, 0, sizeof(spdylay_session_callbacks));
   callbacks->send_callback = spdy_cb_send;
   callbacks->recv_callback = spdy_cb_recv;
-  //callbacks->before_ctrl_send_callback = spdy_cb_before_ctrl_send;
   callbacks->on_ctrl_send_callback = spdy_cb_on_ctrl_send;
   callbacks->on_ctrl_recv_callback = spdy_cb_on_ctrl_recv;
   callbacks->on_stream_close_callback = spdy_cb_on_stream_close;
@@ -386,21 +381,25 @@ static void spdy_setup_spdylay_callbacks(spdylay_session_callbacks *callbacks)
   callbacks->on_data_recv_callback = spdy_cb_on_data_recv;
 }
 
+
 /*
  * Callback function for SSL/TLS NPN. Since this program only supports
  * SPDY protocol, if server does not offer SPDY protocol the Spdylay
  * library supports, we terminate program.
  */
-static int spdy_cb_ssl_select_next_proto(SSL* ssl,
-                                unsigned char **out, unsigned char *outlen,
-                                const unsigned char *in, unsigned int inlen,
+static int
+spdy_cb_ssl_select_next_proto(SSL* ssl,
+                                unsigned char **out,
+                                unsigned char *outlen,
+                                const unsigned char *in,
+                                unsigned int inlen,
                                 void *arg)
 {
   (void)ssl;
   
-    //PRINT_INFO("spdy_cb_ssl_select_next_proto");
   int rv;
   uint16_t *spdy_proto_version;
+  
   /* spdylay_select_next_protocol() selects SPDY protocol version the
      Spdylay library supports. */
   rv = spdylay_select_next_protocol(out, outlen, in, inlen);
@@ -413,11 +412,14 @@ static int spdy_cb_ssl_select_next_proto(SSL* ssl,
   return SSL_TLSEXT_ERR_OK;
 }
 
+
 /*
  * Setup SSL context. We pass |spdy_proto_version| to get negotiated
  * SPDY protocol version in NPN callback.
  */
-void spdy_ssl_init_ssl_ctx(SSL_CTX *ssl_ctx, uint16_t *spdy_proto_version)
+void
+spdy_ssl_init_ssl_ctx(SSL_CTX *ssl_ctx,
+                      uint16_t *spdy_proto_version)
 {
   /* Disable SSLv2 and enable all workarounds for buggy servers */
   SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL|SSL_OP_NO_SSLv2 | SSL_OP_NO_COMPRESSION);
@@ -428,153 +430,184 @@ void spdy_ssl_init_ssl_ctx(SSL_CTX *ssl_ctx, uint16_t *spdy_proto_version)
                                    spdy_proto_version);
 }
 
-static int spdy_ssl_handshake(SSL *ssl, int fd)
+
+static int
+spdy_ssl_handshake(SSL *ssl,
+                   int fd)
 {
   int rv;
-  if(SSL_set_fd(ssl, fd) == 0) {
+  
+  if(SSL_set_fd(ssl, fd) == 0)
     spdy_dief("SSL_set_fd", ERR_error_string(ERR_get_error(), NULL));
-  }
+
   ERR_clear_error();
   rv = SSL_connect(ssl);
-  if(rv <= 0) {
+  if(rv <= 0)
     PRINT_INFO2("SSL_connect %s", ERR_error_string(ERR_get_error(), NULL));
-  }
   
   return rv;
 }
 
+
 /*
  * Connects to the host |host| and port |port|.  This function returns
  * the file descriptor of the client socket.
  */
-static int spdy_socket_connect_to(const char *host, uint16_t port)
+static int
+spdy_socket_connect_to(const char *host,
+                       uint16_t port)
 {
   struct addrinfo hints;
   int fd = -1;
   int rv;
   char service[NI_MAXSERV];
   struct addrinfo *res, *rp;
+  
+  //TODO checks
   snprintf(service, sizeof(service), "%u", port);
   memset(&hints, 0, sizeof(struct addrinfo));
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   rv = getaddrinfo(host, service, &hints, &res);
-  if(rv != 0) {
+  if(rv != 0)
+  {
           printf("%s\n",host);
     spdy_dief("getaddrinfo", gai_strerror(rv));
   }
-  for(rp = res; rp; rp = rp->ai_next) {
+  for(rp = res; rp; rp = rp->ai_next)
+  {
     fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-    if(fd == -1) {
+    if(fd == -1)
       continue;
-    }
     while((rv = connect(fd, rp->ai_addr, rp->ai_addrlen)) == -1 &&
           errno == EINTR);
-    if(rv == 0) {
+    if(rv == 0)
       break;
-    }
     close(fd);
     fd = -1;
   }
   freeaddrinfo(res);
+  
   return fd;
 }
 
-static void spdy_socket_make_non_block(int fd)
+
+static void
+spdy_socket_make_non_block(int fd)
 {
-  int flags, rv;
+  int flags;
+  int rv;
+  
   while((flags = fcntl(fd, F_GETFL, 0)) == -1 && errno == EINTR);
-  if(flags == -1) {
+  
+  if(flags == -1)
     spdy_dief("fcntl", strerror(errno));
-  }
+    
   while((rv = fcntl(fd, F_SETFL, flags | O_NONBLOCK)) == -1 && errno == EINTR);
-  if(rv == -1) {
+ 
+  if(rv == -1)
     spdy_dief("fcntl", strerror(errno));
-  }
 }
 
+
 /*
  * Setting TCP_NODELAY is not mandatory for the SPDY protocol.
  */
-static void spdy_socket_set_tcp_nodelay(int fd)
+static void
+spdy_socket_set_tcp_nodelay(int fd)
 {
   int val = 1;
   int rv;
+  
   rv = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val));
-  if(rv == -1) {
+  if(rv == -1)
     spdy_dief("setsockopt", strerror(errno));
-  }
 }
 
 /*
  * Update |pollfd| based on the state of |connection|.
  */
-void spdy_ctl_poll(struct pollfd *pollfd, struct SPDY_Connection *connection)
+void
+spdy_ctl_poll(struct pollfd *pollfd,
+              struct SPDY_Connection *connection)
 {
   pollfd->events = 0;
   if(spdylay_session_want_read(connection->session) ||
-     connection->want_io == WANT_READ) {
+     connection->want_io == WANT_READ)
+  {
     pollfd->events |= POLLIN;
   }
   if(spdylay_session_want_write(connection->session) ||
-     connection->want_io == WANT_WRITE) {
+     connection->want_io == WANT_WRITE)
+  {
     pollfd->events |= POLLOUT;
   }
 }
 
+
 /*
  * Update |selectfd| based on the state of |connection|.
  */
-bool spdy_ctl_select(fd_set * read_fd_set,
-                                fd_set * write_fd_set, 
-                                fd_set * except_fd_set,
-         struct SPDY_Connection *connection)
+bool
+spdy_ctl_select(fd_set * read_fd_set,
+                fd_set * write_fd_set, 
+                fd_set * except_fd_set,
+                struct SPDY_Connection *connection)
 {
   (void)except_fd_set;
   
   bool ret = false;
   
   if(spdylay_session_want_read(connection->session) ||
-     connection->want_io == WANT_READ) {
+     connection->want_io == WANT_READ)
+  {
     FD_SET(connection->fd, read_fd_set);
     ret = true;
   }
   if(spdylay_session_want_write(connection->session) ||
-     connection->want_io == WANT_WRITE) {
+     connection->want_io == WANT_WRITE)
+  {
     FD_SET(connection->fd, write_fd_set);
     ret = true;
   }
+  
   return ret;
 }
 
+
 /*
  * Performs the network I/O.
  */
-int  spdy_exec_io(struct SPDY_Connection *connection)
+int
+spdy_exec_io(struct SPDY_Connection *connection)
 {
   int rv;
+  
   rv = spdylay_session_recv(connection->session);
-  if(rv != 0) {
+  if(rv != 0)
+  {
     PRINT_INFO2("spdylay_session_recv %i", rv);
     return rv;
   }
   rv = spdylay_session_send(connection->session);
-  if(rv != 0) {
+  if(rv != 0)
     PRINT_INFO2("spdylay_session_send %i", rv);
-  }
+    
   return rv;
 }
 
+
 /*
  * Fetches the resource denoted by |uri|.
  */
-struct SPDY_Connection * spdy_connect(const struct URI *uri, uint16_t port, bool is_tls)
+struct SPDY_Connection *
+spdy_connect(const struct URI *uri,
+             uint16_t port,
+             bool is_tls)
 {
   spdylay_session_callbacks callbacks;
   int fd;
-  //SSL_CTX *ssl_ctx;
   SSL *ssl=NULL;
-  //struct SPDY_Request req;
   struct SPDY_Connection * connection;
   int rv;
 
@@ -583,19 +616,14 @@ struct SPDY_Connection * spdy_connect(const struct URI *uri, uint16_t port, bool
   /* Establish connection and setup SSL */
   PRINT_INFO2("connecting to %s:%i", uri->host, port);
   fd = spdy_socket_connect_to(uri->host, port);
-  if(fd == -1) {
+  if(fd == -1)
+  {
     PRINT_INFO("Could not open file descriptor");
-    return NULL;//glob_opt.spdy_connection;
+    return NULL;
   }
   
   if(is_tls)
   {
-    /*ssl_ctx = SSL_CTX_new(SSLv23_client_method());
-    if(ssl_ctx == NULL) {
-      spdy_dief("SSL_CTX_new", ERR_error_string(ERR_get_error(), NULL));
-    }
-    spdy_ssl_init_ssl_ctx(ssl_ctx, &spdy_proto_version);
-    */
     ssl = SSL_new(glob_opt.ssl_ctx);
     if(ssl == NULL) {
       spdy_dief("SSL_new", ERR_error_string(ERR_get_error(), NULL));
@@ -624,7 +652,6 @@ struct SPDY_Connection * spdy_connect(const struct URI *uri, uint16_t port, bool
 
   if(NULL == (connection = au_malloc(sizeof(struct SPDY_Connection))))
     return NULL;
-  //memset(connection, 0 , sizeof(struct SPDY_Connection));
   
   connection->is_tls = is_tls;
   connection->ssl = ssl;
@@ -647,6 +674,7 @@ struct SPDY_Connection * spdy_connect(const struct URI *uri, uint16_t port, bool
         return connection;
 }
 
+
 void
 spdy_free_connection(struct SPDY_Connection * connection)
 {
@@ -659,8 +687,10 @@ spdy_free_connection(struct SPDY_Connection * connection)
   }
 }
 
+
 int
-spdy_request(const char **nv, struct Proxy *proxy)
+spdy_request(const char **nv,
+             struct Proxy *proxy)
 {
   int ret;
   uint16_t port;
@@ -714,13 +744,18 @@ spdy_request(const char **nv, struct Proxy *proxy)
 
 
 void
-spdy_get_pollfdset(struct pollfd fds[], struct SPDY_Connection *connections[], unsigned int max_size, nfds_t *real_size)
+spdy_get_pollfdset(struct pollfd fds[],
+                   struct SPDY_Connection *connections[],
+                   unsigned int max_size,
+                   nfds_t *real_size)
 {
   struct SPDY_Connection *connection;
   struct Proxy *proxy;
   
   *real_size = 0;
-  if(max_size<1) return;
+  if(max_size<1)
+    return;
+    
   if(NULL != glob_opt.spdy_connection)
   {
     spdy_ctl_poll(&(fds[*real_size]), glob_opt.spdy_connection);
@@ -781,9 +816,11 @@ spdy_get_pollfdset(struct pollfd fds[], struct SPDY_Connection *connections[], u
 
 int
 spdy_get_selectfdset(fd_set * read_fd_set,
-                                fd_set * write_fd_set, 
-                                fd_set * except_fd_set,
-        struct SPDY_Connection *connections[], unsigned int max_size, nfds_t *real_size)
+                      fd_set * write_fd_set, 
+                      fd_set * except_fd_set,
+                      struct SPDY_Connection *connections[],
+                      unsigned int max_size,
+                      nfds_t *real_size)
 {
   struct SPDY_Connection *connection;
   struct Proxy *proxy;
@@ -791,7 +828,9 @@ spdy_get_selectfdset(fd_set * read_fd_set,
   int maxfd = 0;
   
   *real_size = 0;
-  if(max_size<1) return 0;
+  if(max_size<1)
+    return 0;
+    
   if(NULL != glob_opt.spdy_connection)
   {
     ret = spdy_ctl_select(read_fd_set,
@@ -857,12 +896,13 @@ spdy_get_selectfdset(fd_set * read_fd_set,
 
 
 void
-spdy_run(struct pollfd fds[], struct SPDY_Connection *connections[], int size)
+spdy_run(struct pollfd fds[],
+         struct SPDY_Connection *connections[],
+         int size)
 {
   int i;
   int ret;
   struct Proxy *proxy;
-  //PRINT_INFO2("size is %i", size);
   
   for(i=0; i<size; ++i)
   {
@@ -898,21 +938,20 @@ spdy_run(struct pollfd fds[], struct SPDY_Connection *connections[], int size)
       }
     }
     else
-    {
       PRINT_INFO("not called");
-    }
   }
 }
 
 void
 spdy_run_select(fd_set * read_fd_set,
-                                fd_set * write_fd_set, 
-                                fd_set * except_fd_set, struct SPDY_Connection *connections[], int size)
+                fd_set * write_fd_set, 
+                fd_set * except_fd_set,
+                struct SPDY_Connection *connections[],
+                int size)
 {
   int i;
   int ret;
   struct Proxy *proxy;
-  //PRINT_INFO2("size is %i", size);
   
   for(i=0; i<size; ++i)
   {
@@ -920,12 +959,6 @@ spdy_run_select(fd_set * read_fd_set,
     if(FD_ISSET(connections[i]->fd, read_fd_set) || FD_ISSET(connections[i]->fd, write_fd_set) || FD_ISSET(connections[i]->fd, except_fd_set))
     {
       ret = spdy_exec_io(connections[i]);
-      //PRINT_INFO2("%i",ret);
-      //if((spdy_pollfds[i].revents & POLLHUP) || (spdy_pollfds[0].revents & POLLERR))
-      //  PRINT_INFO("SPDY SPDY_Connection error");
-      
-      //TODO POLLRDHUP
-      // always close on ret != 0?
         
       if(0 != ret)
       {
@@ -948,8 +981,6 @@ spdy_run_select(fd_set * read_fd_set,
       }
     }
     else
-    {
       PRINT_INFO("not called");
-    }
   }
 }