[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r28218 - libmicrohttpd/src/examples
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r28218 - libmicrohttpd/src/examples |
|
Date: |
Sat, 20 Jul 2013 21:21:10 +0200 |
Author: andreyu
Date: 2013-07-20 21:21:10 +0200 (Sat, 20 Jul 2013)
New Revision: 28218
Modified:
libmicrohttpd/src/examples/mhd2spdy.c
libmicrohttpd/src/examples/mhd2spdy_http.c
libmicrohttpd/src/examples/mhd2spdy_http.h
libmicrohttpd/src/examples/mhd2spdy_spdy.c
libmicrohttpd/src/examples/mhd2spdy_spdy.h
libmicrohttpd/src/examples/mhd2spdy_structures.c
libmicrohttpd/src/examples/mhd2spdy_structures.h
Log:
mhd2spdy: code formatting done and old code removed
Modified: libmicrohttpd/src/examples/mhd2spdy.c
===================================================================
--- libmicrohttpd/src/examples/mhd2spdy.c 2013-07-20 18:49:59 UTC (rev
28217)
+++ libmicrohttpd/src/examples/mhd2spdy.c 2013-07-20 19:21:10 UTC (rev
28218)
@@ -31,16 +31,20 @@
#include "mhd2spdy_spdy.h"
#include "mhd2spdy_http.h"
+
static int run = 1;
//static int spdy_close = 0;
-static void catch_signal(int signal)
+
+static void
+catch_signal(int signal)
{
(void)signal;
//spdy_close = 1;
run = 0;
}
+
int
run_everything ()
{
@@ -54,10 +58,7 @@
int maxfd_s = -1;
struct MHD_Daemon *daemon;
nfds_t spdy_npollfds = 1;
- //struct pollfd spdy_pollfds[MAX_SPDY_CONNECTIONS];
struct URI * spdy2http_uri = NULL;
- //int spdy_nfds;
- //int spdylay_timeout = 0;
struct SPDY_Connection *connection;
struct SPDY_Connection *connections[MAX_SPDY_CONNECTIONS];
struct SPDY_Connection *connection_for_delete;
@@ -68,18 +69,15 @@
if (signal(SIGINT, catch_signal) == SIG_ERR)
PRINT_INFO("signal failed");
- //spdy2http_url = argv[2];
glob_opt.streams_opened = 0;
glob_opt.responses_pending = 0;
glob_opt.global_memory = 0;
- //spdy_proto_version = 0;
srand(time(NULL));
if(init_parse_uri(&glob_opt.uri_preg))
DIE("Regexp compilation failed");
-
if(NULL != glob_opt.spdy2http_str)
{
ret = parse_uri(&glob_opt.uri_preg, glob_opt.spdy2http_str,
&spdy2http_uri);
@@ -105,12 +103,10 @@
if(NULL==daemon)
DIE("MHD_start_daemon failed");
-
do
{
-
- timeout.tv_sec = 0;
- timeout.tv_usec = 0;
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 0;
if(NULL == glob_opt.spdy_connection && NULL != glob_opt.spdy2http_str)
{
@@ -119,32 +115,19 @@
PRINT_INFO("cannot connect to the proxy");
}
- //PRINT_INFO("while1");
FD_ZERO(&rs);
FD_ZERO(&ws);
FD_ZERO(&es);
+
+ ret = MHD_get_timeout(daemon, &timeoutlong);
+ if(MHD_NO == ret || timeoutlong > 5000)
+ timeout.tv_sec = 5;
+ else
+ {
+ timeout.tv_sec = timeoutlong / 1000;
+ timeout.tv_usec = (timeoutlong % 1000) * 1000;
+ }
- /*if(glob_opt.spdy_data_received)
- {
- timeout.tv_sec = 0;
- timeout.tv_usec = 0;
- glob_opt.spdy_data_received = false;
-}
-else{*/
- /*if(glob_opt.responses_pending || glob_opt.streams_opened)// TODO only
streams_opened true?
- timeout.tv_usec = 0; //return immediately
- else
- {*/
- ret = MHD_get_timeout(daemon, &timeoutlong);
- if(MHD_NO == ret || timeoutlong > 5000)
- timeout.tv_sec = 5;
- else
- {
- timeout.tv_sec = timeoutlong / 1000;
- timeout.tv_usec = (timeoutlong % 1000) * 1000;
- }
- //}
-//}
if(MHD_NO == MHD_get_fdset (daemon,
&rs,
&ws,
@@ -160,12 +143,10 @@
&ws,
&es,
connections, MAX_SPDY_CONNECTIONS,
&spdy_npollfds);
- if(maxfd_s > maxfd) maxfd = maxfd_s;
+ if(maxfd_s > maxfd)
+ maxfd = maxfd_s;
PRINT_INFO2("MHD timeout %lld %lld", (unsigned long long)timeout.tv_sec,
(unsigned long long)timeout.tv_usec);
- //TODO
- //timeout.tv_sec = 0;
- //timeout.tv_usec = 0;
glob_opt.spdy_data_received = false;
@@ -181,42 +162,20 @@
break;
default:
PRINT_INFO("run");
- //MHD_run_from_select(daemon,&rs, &ws, &es); //not closing FDs
+ //MHD_run_from_select(daemon,&rs, &ws, &es); //not closing FDs at some
time in past
MHD_run(daemon);
spdy_run_select(&rs, &ws, &es, connections, spdy_npollfds);
if(glob_opt.spdy_data_received)
{
PRINT_INFO("MHD run again");
- //MHD_run_from_select(daemon,&rs, &ws, &es); //not closing FDs
+ //MHD_run_from_select(daemon,&rs, &ws, &es); //not closing FDs at
some time in past
MHD_run(daemon);
}
break;
}
-
- /*
- //if(glob_opt.streams_opened) spdylay_timeout = 500;
- //if(glob_opt.responses_pending || glob_opt.streams_opened)
spdylay_timeout = 0;
- //else spdylay_timeout = 0;
- //else spdylay_timeout = 0;
-
- spdy_get_pollfdset(spdy_pollfds, connections, MAX_SPDY_CONNECTIONS,
&spdy_npollfds);
-
- //TODO
- //spdylay_timeout = 0;
-
- PRINT_INFO2("spdylay timeout %i", spdylay_timeout);
- ret = poll(spdy_pollfds, spdy_npollfds, spdylay_timeout);
- if(ret == -1)
- DIE("poll");
- if(ret > 0){
- PRINT_INFO("spdy_run");
- spdy_run(spdy_pollfds, connections, spdy_npollfds);
- }*/
}
while(run);
- //TODO exit from loop and clean
-
MHD_stop_daemon (daemon);
//TODO SSL_free brakes
@@ -246,6 +205,7 @@
return 0;
}
+
void
display_usage()
{
Modified: libmicrohttpd/src/examples/mhd2spdy_http.c
===================================================================
--- libmicrohttpd/src/examples/mhd2spdy_http.c 2013-07-20 18:49:59 UTC (rev
28217)
+++ libmicrohttpd/src/examples/mhd2spdy_http.c 2013-07-20 19:21:10 UTC (rev
28218)
@@ -26,7 +26,9 @@
#include "mhd2spdy_spdy.h"
-void * http_log_cb(void * cls, const char * uri)
+void *
+http_log_cb(void * cls,
+const char * uri)
{
(void)cls;
@@ -34,29 +36,18 @@
PRINT_INFO2("log uri '%s'\n", uri);
- //TODO free
if(NULL == (http_uri = au_malloc(sizeof(struct HTTP_URI ))))
DIE("no memory");
- //memset(http_uri, 0 , sizeof(struct HTTP_URI));
http_uri->uri = strdup(uri);
return http_uri;
}
-/*
static int
-http_query_iterate_cb(void *cls,
- enum MHD_ValueKind kind,
- const char *name, const char *value)
-{
-
-}*/
-
-
-static int
http_iterate_cb(void *cls,
- enum MHD_ValueKind kind,
- const char *name, const char *value)
+ enum MHD_ValueKind kind,
+ const char *name,
+ const char *value)
{
(void)kind;
@@ -85,9 +76,9 @@
static ssize_t
http_response_callback (void *cls,
- uint64_t pos,
- char *buffer,
- size_t max)
+ uint64_t pos,
+ char *buffer,
+ size_t max)
{
(void)pos;
@@ -96,15 +87,6 @@
void *newbody;
const union MHD_ConnectionInfo *info;
int val = 1;
-
- //max=16;
-
- //PRINT_INFO2("response_callback, pos: %i, max is %i, len is
%i",pos,max,proxy->length);
-
- //assert(0 != proxy->length);
-
- //if(MHD_CONTENT_READER_END_OF_STREAM == proxy->length)
- // return MHD_CONTENT_READER_END_OF_STREAM;
PRINT_INFO2("http_response_callback for %s", proxy->url);
@@ -116,7 +98,6 @@
return MHD_CONTENT_READER_END_OF_STREAM;
}
- //*more = true;
if(!proxy->http_body_size)//nothing to write now
{
//flush data
@@ -154,13 +135,6 @@
if(proxy->length >= 0)
{
proxy->length -= ret;
- //printf("pr len %i", proxy->length);
- /*if(proxy->length <= 0)
- {
- // *more = false;
- //last frame
- proxy->length = MHD_CONTENT_READER_END_OF_STREAM;
- }*/
}
PRINT_INFO2("response_callback, size: %i",ret);
@@ -175,27 +149,7 @@
struct Proxy *proxy = (struct Proxy *)cls;
PRINT_INFO2("http_response_done_callback for %s", proxy->url);
- //int ret;
-
- //printf("response_done_callback\n");
-
- //printf("answer for %s was sent\n", (char *)cls);
-
- /*if(SPDY_RESPONSE_RESULT_SUCCESS != status)
- {
- printf("answer was NOT sent, %i\n",status);
- }*/
- /*if(CURLM_OK != (ret = curl_multi_remove_handle(multi_handle,
proxy->curl_handle)))
- {
- PRINT_INFO2("curl_multi_remove_handle failed (%i)", ret);
- }
- curl_slist_free_all(proxy->curl_headers);
- curl_easy_cleanup(proxy->curl_handle);
- */
- //SPDY_destroy_request(request);
- //SPDY_destroy_response(response);
- //if(!strcmp("/close",proxy->path)) run = 0;
- //free(proxy->path);
+
if(proxy->spdy_active)
proxy->http_active = false;
else
@@ -219,12 +173,8 @@
(void)upload_data;
(void)upload_data_size;
- //struct MHD_Response *response;
int ret;
struct Proxy *proxy;
- //struct URI *spdy_uri;
- //char **nv;
- //int num_headers;
struct SPDY_Headers spdy_headers;
//PRINT_INFO2("request cb %i; %s", *ptr,url);
@@ -240,7 +190,7 @@
free(http_uri->uri);
free(http_uri);
PRINT_INFO2("unexpected method %s", method);
- return MHD_NO; /* unexpected method */
+ return MHD_NO;
}
if(NULL == (proxy = au_malloc(sizeof(struct Proxy))))
@@ -250,17 +200,14 @@
}
++glob_opt.responses_pending;
- //memset(proxy, 0, sizeof(struct Proxy));
proxy->id = rand();
proxy->http_active = true;
- //PRINT_INFO2("proxy obj with id %i created (%i)", proxy->id, proxy);
proxy->http_connection = connection;
http_uri->proxy = proxy;
return MHD_YES;
}
proxy = http_uri->proxy;
- //*ptr = NULL; /* reset when done */
if(proxy->spdy_active)
{
@@ -270,45 +217,15 @@
}
PRINT_INFO2("received request for '%s %s %s'\n", method, http_uri->uri,
version);
- /*
- proxy->http_response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
- 8096,
- &http_response_callback,
- proxy,
- &http_response_done_callback);
-
- if (proxy->http_response == NULL)
- DIE("no response");
- */
proxy->url = http_uri->uri;
- //if(NULL == (proxy->url = strdup(http_uri->uri)))
- // DIE("no memory");
-
-//TODO HTTP headers
- /*MHD_get_connection_values (connection,
- MHD_HEADER_KIND,
- &http_iterate_cb,
- proxy);
- */
- //proxy->url = strdup(url);
- //if(NULL == (spdy_uri = au_malloc(sizeof(struct URI))))
- // DIE("no memory");
ret = parse_uri(&glob_opt.uri_preg, proxy->url, &proxy->uri);
if(ret != 0)
DIE("parse_uri failed");
- //proxy->uri = spdy_uri;
proxy->http_uri = http_uri;
proxy->spdy_active = true;
- //proxy->spdy_request = au_malloc(sizeof(struct SPDY_Request));
- //if(NULL == proxy->spdy_request)
- // DIE("no memory");
- //memset(proxy->spdy_request,0,sizeof(struct SPDY_Request));
- //spdy_request_init(proxy->spdy_request, &spdy_uri);
- //spdy_submit_request(spdy_connection, proxy);
-
spdy_headers.num = MHD_get_connection_values (connection,
MHD_HEADER_KIND,
NULL,
@@ -331,16 +248,10 @@
if(NULL == spdy_headers.nv[9])
spdy_headers.nv[9] = proxy->uri->host_and_port;
- /*int i;
- for(i=0; i<spdy_headers.cnt; i+=2)
- printf("%s: %s\n", spdy_headers.nv[i], spdy_headers.nv[i+1]);
- */
if(0 != spdy_request(spdy_headers.nv, proxy))
{
- //--glob_opt.responses_pending;
free(spdy_headers.nv);
- //MHD_destroy_response (proxy->http_response);
- free_proxy(proxy);//TODO call it here or in done_callback
+ free_proxy(proxy);
return MHD_NO;
}
@@ -364,60 +275,20 @@
if(MHD_NO == MHD_add_response_header (proxy->http_response,
"Keep-Alive", "timeout=5, max=100"))
PRINT_INFO("SPDY_name_value_add failed: ");
- /*
- const union MHD_ConnectionInfo *info;
- info = MHD_get_connection_info (connection,
- MHD_CONNECTION_INFO_CONNECTION_FD);
- int val = 1;
- int rv;
- rv = setsockopt(info->connect_fd, IPPROTO_TCP, TCP_NODELAY, &val,
(socklen_t)sizeof(val));
- if(rv == -1) {
- DIE("setsockopt");
- }*/
+
return MHD_YES;
}
+
void
-http_create_response(struct Proxy* proxy, char **nv)
+http_create_response(struct Proxy* proxy,
+ char **nv)
{
size_t i;
- //uint64_t response_size=MHD_SIZE_UNKNOWN;
-
- /*for(i = 0; nv[i]; i += 2) {
- if(0 == strcmp("content-length", nv[i]))
- {
- response_size = atoi(nv[i+1]);
- break;
- }
- }*/
- /*
- proxy->http_response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
- 4096,
- &http_response_callback,
- proxy,
- &http_response_done_callback);
-
- if (proxy->http_response == NULL)
- DIE("no response");
- if(MHD_NO == MHD_add_response_header (proxy->http_response,
- "Proxy-Connection", "keep-alive"))
- PRINT_INFO("SPDY_name_value_add failed: ");
- if(MHD_NO == MHD_add_response_header (proxy->http_response,
- "Connection", "Keep-Alive"))
- PRINT_INFO("SPDY_name_value_add failed: ");
- if(MHD_NO == MHD_add_response_header (proxy->http_response,
- "Keep-Alive", "timeout=5, max=100"))
- PRINT_INFO("SPDY_name_value_add failed: ");
- */
for(i = 0; nv[i]; i += 2) {
- //printf(" %s: %s\n", nv[i], nv[i+1]);
- //int j;
-
if(0 == strcmp(":status", nv[i]))
{
- //raise(SIGINT);
- //proxy->status_msg = nv[i+1];
char tmp[4];
memcpy(&tmp,nv[i+1],3);
tmp[3]=0;
@@ -431,35 +302,22 @@
}
else if(0 == strcmp("content-length", nv[i]))
{
- //proxy->length = atoi(nv[i+1]);
- //response_size = atoi(nv[i+1]);
continue;
}
- //for(j=0; j<strlen(nv[i]) && ':'==nv[i][j]; ++j);
-
char *header = *(nv+i);
- //header[0] = toupper(header[0]);
if(MHD_NO == MHD_add_response_header (proxy->http_response,
header, nv[i+1]))
{
PRINT_INFO2("SPDY_name_value_add failed: '%s' '%s'", header, nv[i+1]);
- //abort();
}
PRINT_INFO2("adding '%s: %s'",header, nv[i+1]);
}
- //PRINT_INFO2("%i", MHD_get_response_headers(proxy->http_response, NULL,
NULL));
- //PRINT_INFO2("state before %i", proxy->http_connection->state);
- //PRINT_INFO2("loop before %i", proxy->http_connection->event_loop_info);
if(MHD_NO == MHD_queue_response (proxy->http_connection, proxy->status,
proxy->http_response)){
PRINT_INFO("No queue");
abort();
}
- //PRINT_INFO2("state after %i", proxy->http_connection->state);
- //PRINT_INFO2("loop after %i", proxy->http_connection->event_loop_info);
- //MHD_destroy_response (proxy->http_response);
- //PRINT_INFO2("state after %i", proxy->http_connection->state);
- //PRINT_INFO2("loop after %i", proxy->http_connection->event_loop_info);
- MHD_destroy_response (proxy->http_response);
+
+ MHD_destroy_response (proxy->http_response);
}
Modified: libmicrohttpd/src/examples/mhd2spdy_http.h
===================================================================
--- libmicrohttpd/src/examples/mhd2spdy_http.h 2013-07-20 18:49:59 UTC (rev
28217)
+++ libmicrohttpd/src/examples/mhd2spdy_http.h 2013-07-20 19:21:10 UTC (rev
28218)
@@ -36,10 +36,13 @@
const char *upload_data,
size_t *upload_data_size,
void **ptr);
-
+
+
void * http_log_cb(void * cls, const char * uri);
-
+
+
void
http_create_response(struct Proxy* proxy, char **nv);
-
+
+
#endif
Modified: libmicrohttpd/src/examples/mhd2spdy_spdy.c
===================================================================
--- libmicrohttpd/src/examples/mhd2spdy_spdy.c 2013-07-20 18:49:59 UTC (rev
28217)
+++ libmicrohttpd/src/examples/mhd2spdy_spdy.c 2013-07-20 19:21:10 UTC (rev
28218)
@@ -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 @@
* 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 @@
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 @@
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 @@
break;
case SPDYLAY_HEADERS:
nv = frame->headers.nv;
- //name = "HEADERS";
stream_id = frame->headers.stream_id;
break;
default:
@@ -269,34 +255,37 @@
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 @@
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 @@
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 @@
}
}
+
/*
* 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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
return connection;
}
+
void
spdy_free_connection(struct SPDY_Connection * connection)
{
@@ -659,8 +687,10 @@
}
}
+
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 @@
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 @@
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 @@
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 @@
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 @@
}
}
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 @@
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 @@
}
}
else
- {
PRINT_INFO("not called");
- }
}
}
Modified: libmicrohttpd/src/examples/mhd2spdy_spdy.h
===================================================================
--- libmicrohttpd/src/examples/mhd2spdy_spdy.h 2013-07-20 18:49:59 UTC (rev
28217)
+++ libmicrohttpd/src/examples/mhd2spdy_spdy.h 2013-07-20 19:21:10 UTC (rev
28218)
@@ -26,43 +26,76 @@
#include "mhd2spdy_structures.h"
-struct SPDY_Connection * spdy_connect(const struct URI *uri, uint16_t port,
bool is_tls);
-void spdy_ctl_poll(struct pollfd *pollfd, struct SPDY_Connection *connection);
+struct SPDY_Connection *
+spdy_connect(const struct URI *uri,
+ uint16_t port,
+ bool is_tls);
-bool spdy_ctl_select(fd_set * read_fd_set,
- fd_set * write_fd_set,
- fd_set * except_fd_set,
- struct SPDY_Connection *connection);
-int spdy_exec_io(struct SPDY_Connection *connection);
+void
+spdy_ctl_poll(struct pollfd *pollfd,
+ struct SPDY_Connection *connection);
-void spdy_diec(const char *func, int error_code);
+bool
+spdy_ctl_select(fd_set * read_fd_set,
+ fd_set * write_fd_set,
+ fd_set * except_fd_set,
+ struct SPDY_Connection *connection);
+
+
+int
+spdy_exec_io(struct SPDY_Connection *connection);
+
+
+void
+spdy_diec(const char *func,
+ int error_code);
+
+
int
-spdy_request(const char **nv, struct Proxy *proxy);
+spdy_request(const char **nv,
+ struct Proxy *proxy);
-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);
+
+
+void
spdy_free_connection(struct SPDY_Connection * connection);
+
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);
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);
+
+
void
-spdy_run(struct pollfd fds[], struct SPDY_Connection *connections[], int size);
+spdy_run(struct pollfd fds[],
+ struct SPDY_Connection *connections[],
+ int size);
+
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);
+
+
#endif
Modified: libmicrohttpd/src/examples/mhd2spdy_structures.c
===================================================================
--- libmicrohttpd/src/examples/mhd2spdy_structures.c 2013-07-20 18:49:59 UTC
(rev 28217)
+++ libmicrohttpd/src/examples/mhd2spdy_structures.c 2013-07-20 19:21:10 UTC
(rev 28218)
@@ -32,7 +32,6 @@
free(uri->full_uri);
free(uri->scheme);
free(uri->host_and_port);
- //free(uri->host_and_port_for_connecting);
free(uri->host);
free(uri->path);
free(uri->path_and_more);
@@ -43,6 +42,7 @@
}
}
+
int
init_parse_uri(regex_t * preg)
{
@@ -66,7 +66,9 @@
}
int
-parse_uri(regex_t * preg, char * full_uri, struct URI ** uri)
+parse_uri(regex_t * preg,
+ char * full_uri,
+ struct URI ** uri)
{
int ret;
char *colon;
@@ -94,22 +96,8 @@
if(NULL == colon)
{
(*uri)->host = strdup((*uri)->host_and_port);
- /*if(0 == strcasecmp("http", uri->scheme))
- {
- uri->port = 80;
- asprintf(&(uri->host_and_port_for_connecting), "%s:80",
uri->host_and_port);
- }
- else if(0 == strcasecmp("https", uri->scheme))
- {
- uri->port = 443;
- asprintf(&(uri->host_and_port_for_connecting), "%s:443",
uri->host_and_port);
- }
- else
- {
- PRINT_INFO("no standard scheme!");
- */(*uri)->port = 0;
- /*uri->host_and_port_for_connecting = strdup(uri->host_and_port);
- }*/
+ (*uri)->port = 0;
+
return 0;
}
@@ -125,6 +113,7 @@
return 0;
}
+
void
free_proxy(struct Proxy *proxy)
{
@@ -136,6 +125,7 @@
free(proxy);
}
+//TODO remove this
void *au_malloc(size_t size)
{
void *new_memory;
Modified: libmicrohttpd/src/examples/mhd2spdy_structures.h
===================================================================
--- libmicrohttpd/src/examples/mhd2spdy_structures.h 2013-07-20 18:49:59 UTC
(rev 28217)
+++ libmicrohttpd/src/examples/mhd2spdy_structures.h 2013-07-20 19:21:10 UTC
(rev 28218)
@@ -49,23 +49,32 @@
#include <spdylay/spdylay.h>
#include <getopt.h>
+
+/* WANT_READ if SSL connection needs more input; or WANT_WRITE if it
+ needs more output; or IO_NONE. This is necessary because SSL/TLS
+ re-negotiation is possible at any time. Spdylay API offers
+ similar functions like spdylay_session_want_read() and
+ spdylay_session_want_write() but they do not take into account
+ SSL connection. */
+enum
+{
+ IO_NONE,
+ WANT_READ,
+ WANT_WRITE
+};
+
+
struct Proxy;
+
struct SPDY_Connection {
SSL *ssl;
- //SSL_CTX *ssl_ctx;
spdylay_session *session;
struct SPDY_Connection *prev;
struct SPDY_Connection *next;
struct Proxy *proxies_head;
struct Proxy *proxies_tail;
char *host;
- /* WANT_READ if SSL connection needs more input; or WANT_WRITE if it
- needs more output; or IO_NONE. This is necessary because SSL/TLS
- re-negotiation is possible at any time. Spdylay API offers
- similar functions like spdylay_session_want_read() and
- spdylay_session_want_write() but they do not take into account
- SSL connection. */
int fd;
int want_io;
uint counter;
@@ -79,7 +88,6 @@
char * full_uri;
char * scheme;
char * host_and_port;
- //char * host_and_port_for_connecting;
char * host;
char * path;
char * path_and_more;
@@ -88,26 +96,21 @@
uint16_t port;
};
+
struct HTTP_URI;
+
struct Proxy
{
struct MHD_Connection *http_connection;
struct MHD_Response *http_response;
struct URI *uri;
- struct HTTP_URI *http_uri; //TODO remove me
+ struct HTTP_URI *http_uri;
struct SPDY_Connection *spdy_connection;
struct Proxy *next;
struct Proxy *prev;
- //char *path;
char *url;
- //struct SPDY_Request *request;
- //struct SPDY_Response *response;
- //CURL *curl_handle;
- //struct curl_slist *curl_headers;
- //struct SPDY_NameValue *headers;
char *version;
- //char *status_msg;
void *http_body;
size_t http_body_size;
ssize_t length;
@@ -126,6 +129,7 @@
struct Proxy * proxy;
};
+
struct SPDY_Headers
{
const char **nv;
@@ -133,6 +137,7 @@
int cnt;
};
+
struct global_options
{
char *spdy2http_str;
@@ -150,25 +155,10 @@
bool verbose;
bool only_proxy;
bool spdy_data_received;
-} glob_opt;
+}
+glob_opt;
-/*
-#define SOCK_ADDR_IN_PTR(sa) ((struct sockaddr_in *)(sa))
-#define SOCK_ADDR_IN_FAMILY(sa) SOCK_ADDR_IN_PTR(sa)->sin_family
-#define SOCK_ADDR_IN_PORT(sa) SOCK_ADDR_IN_PTR(sa)->sin_port
-#define SOCK_ADDR_IN_ADDR(sa) SOCK_ADDR_IN_PTR(sa)->sin_addr
-
-#ifdef HAS_IPV6
-
-#define SOCK_ADDR_IN6_PTR(sa) ((struct sockaddr_in6 *)(sa))
-#define SOCK_ADDR_IN6_FAMILY(sa) SOCK_ADDR_IN6_PTR(sa)->sin6_family
-#define SOCK_ADDR_IN6_PORT(sa) SOCK_ADDR_IN6_PTR(sa)->sin6_port
-#define SOCK_ADDR_IN6_ADDR(sa) SOCK_ADDR_IN6_PTR(sa)->sin6_addr
-
-#endif
-*/
-
//forbidden headers
#define SPDY_HTTP_HEADER_TRANSFER_ENCODING "transfer-encoding"
#define SPDY_HTTP_HEADER_PROXY_CONNECTION "proxy-connection"
@@ -177,6 +167,7 @@
#define MAX_SPDY_CONNECTIONS 100
+#define SPDY_MAX_OUTLEN 4096
/**
* Insert an element at the head of a DLL. Assumes that head, tail and
@@ -251,18 +242,27 @@
void
free_uri(struct URI * uri);
+
int
init_parse_uri(regex_t * preg);
+
void
deinit_parse_uri(regex_t * preg);
-
+
+
int
-parse_uri(regex_t * preg, char * full_uri, struct URI ** uri);
+parse_uri(regex_t * preg,
+ char * full_uri,
+ struct URI ** uri);
+
void
free_proxy(struct Proxy *proxy);
-void *au_malloc(size_t size);
+void *
+au_malloc(size_t size);
+
+
#endif
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r28218 - libmicrohttpd/src/examples,
gnunet <=