summaryrefslogtreecommitdiffstats
path: root/nanohttp
diff options
context:
space:
mode:
Diffstat (limited to 'nanohttp')
-rw-r--r--nanohttp/nanohttp-client.c607
-rw-r--r--nanohttp/nanohttp-client.h70
-rw-r--r--nanohttp/nanohttp-common.c1115
-rw-r--r--nanohttp/nanohttp-common.h139
-rwxr-xr-xnanohttp/nanohttp-mime.c621
-rwxr-xr-xnanohttp/nanohttp-mime.h19
-rwxr-xr-xnanohttp/nanohttp-request.c389
-rwxr-xr-xnanohttp/nanohttp-request.h18
-rwxr-xr-xnanohttp/nanohttp-response.c267
-rwxr-xr-xnanohttp/nanohttp-response.h18
-rw-r--r--nanohttp/nanohttp-server.c344
-rw-r--r--nanohttp/nanohttp-server.h60
-rw-r--r--nanohttp/nanohttp-socket.c438
-rw-r--r--nanohttp/nanohttp-socket.h68
-rw-r--r--nanohttp/nanohttp-ssl.c509
-rw-r--r--nanohttp/nanohttp-ssl.h20
-rwxr-xr-xnanohttp/nanohttp-stream.c453
-rwxr-xr-xnanohttp/nanohttp-stream.h56
18 files changed, 2725 insertions, 2486 deletions
diff --git a/nanohttp/nanohttp-client.c b/nanohttp/nanohttp-client.c
index 02d6c3c..b5a3fd0 100644
--- a/nanohttp/nanohttp-client.c
+++ b/nanohttp/nanohttp-client.c
@@ -1,5 +1,5 @@
/******************************************************************
-* $Id: nanohttp-client.c,v 1.31 2006/01/06 15:16:03 mrcsys Exp $
+* $Id: nanohttp-client.c,v 1.32 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -39,8 +39,8 @@
#endif
#if 0
-static
-int httpc_send_data(httpc_conn_t *conn, const unsigned char* data, size_t size)
+static int
+httpc_send_data (httpc_conn_t * conn, const unsigned char *data, size_t size)
{
return -1;
}
@@ -50,11 +50,11 @@ FUNCTION: httpc_init
DESC: Initialize http client connection
NOTE: This will be called from soap_client_init_args()
----------------------------------------------------*/
-herror_t
-httpc_init(int argc, char *argv[])
+herror_t
+httpc_init (int argc, char *argv[])
{
- hoption_init_args(argc, argv);
- hsocket_module_init();
+ hoption_init_args (argc, argv);
+ hsocket_module_init ();
return H_OK;
}
@@ -63,9 +63,10 @@ httpc_init(int argc, char *argv[])
FUNCTION: httpc_destroy
DESC: Destroy the http client module
----------------------------------------------------*/
-void httpc_destroy()
+void
+httpc_destroy ()
{
- hsocket_module_destroy();
+ hsocket_module_destroy ();
}
@@ -75,23 +76,24 @@ DESC: Creates a new http client connection object
You need to create at least 1 http client connection
to communicate via http.
----------------------------------------------------*/
-httpc_conn_t *
-httpc_new()
+httpc_conn_t *
+httpc_new ()
{
static int counter = 10000;
- httpc_conn_t *res = (httpc_conn_t *) malloc(sizeof(httpc_conn_t));
+ httpc_conn_t *res = (httpc_conn_t *) malloc (sizeof (httpc_conn_t));
- if(hsocket_init(&res->sock)!= H_OK){
- return NULL;
- }
- res->header = NULL;
- res->version = HTTP_1_1;
- res->out = NULL;
- res->_dime_package_nr = 0;
- res->_dime_sent_bytes = 0;
- res->id = counter++;
- res->block = 0;
- return res;
+ if (hsocket_init (&res->sock) != H_OK)
+ {
+ return NULL;
+ }
+ res->header = NULL;
+ res->version = HTTP_1_1;
+ res->out = NULL;
+ res->_dime_package_nr = 0;
+ res->_dime_sent_bytes = 0;
+ res->id = counter++;
+ res->block = 0;
+ return res;
}
@@ -99,30 +101,30 @@ httpc_new()
FUNCTION: httpc_free
DESC: Free the given http client object.
----------------------------------------------------*/
-void
-httpc_free(httpc_conn_t * conn)
+void
+httpc_free (httpc_conn_t * conn)
{
- hpair_t *tmp;
+ hpair_t *tmp;
- if (conn == NULL)
- return;
+ if (conn == NULL)
+ return;
- while (conn->header != NULL)
+ while (conn->header != NULL)
{
tmp = conn->header;
conn->header = conn->header->next;
- hpairnode_free(tmp);
+ hpairnode_free (tmp);
}
- if (conn->out != NULL)
- {
- http_output_stream_free(conn->out);
- conn->out = NULL;
- }
+ if (conn->out != NULL)
+ {
+ http_output_stream_free (conn->out);
+ conn->out = NULL;
+ }
- hsocket_free(conn->sock);
- free(conn);
+ hsocket_free (conn->sock);
+ free (conn);
}
@@ -131,13 +133,13 @@ httpc_free(httpc_conn_t * conn)
DESC: Close and free the given http client object.
----------------------------------------------------*/
void
-httpc_close_free(httpc_conn_t * conn)
+httpc_close_free (httpc_conn_t * conn)
{
- if (conn == NULL)
- return;
+ if (conn == NULL)
+ return;
- hsocket_close(conn->sock);
- httpc_free(conn);
+ hsocket_close (conn->sock);
+ httpc_free (conn);
}
@@ -147,30 +149,34 @@ DESC: Adds a new (key, value) pair to the header
or modifies the old pair if this function will
finds another pair with the same 'key' value.
----------------------------------------------------*/
-int
-httpc_set_header(httpc_conn_t * conn, const char *key, const char *value)
+int
+httpc_set_header (httpc_conn_t * conn, const char *key, const char *value)
{
- hpair_t *p;
+ hpair_t *p;
- if (conn == NULL) {
- log_warn1("Connection object is NULL");
- return 0;
- }
- p = conn->header;
- while (p != NULL) {
- if (p->key != NULL) {
- if (!strcmp(p->key, key)) {
- free(p->value);
- p->value = (char *) malloc(strlen(value) + 1);
- strcpy(p->value, value);
- return 1;
- }
- }
- p = p->next;
- }
+ if (conn == NULL)
+ {
+ log_warn1 ("Connection object is NULL");
+ return 0;
+ }
+ p = conn->header;
+ while (p != NULL)
+ {
+ if (p->key != NULL)
+ {
+ if (!strcmp (p->key, key))
+ {
+ free (p->value);
+ p->value = (char *) malloc (strlen (value) + 1);
+ strcpy (p->value, value);
+ return 1;
+ }
+ }
+ p = p->next;
+ }
- conn->header = hpairnode_new(key, value, conn->header);
- return 0;
+ conn->header = hpairnode_new (key, value, conn->header);
+ return 0;
}
@@ -178,36 +184,34 @@ httpc_set_header(httpc_conn_t * conn, const char *key, const char *value)
FUNCTION: httpc_header_add_date
DESC: Adds the current date to the header.
----------------------------------------------------*/
-static
-void _httpc_set_error(httpc_conn_t *conn, int errcode,
- const char *format, ...)
+static void
+_httpc_set_error (httpc_conn_t * conn, int errcode, const char *format, ...)
{
- va_list ap;
+ va_list ap;
conn->errcode = errcode;
- va_start(ap, format);
- vsprintf(conn->errmsg, format, ap);
- va_end(ap);
+ va_start (ap, format);
+ vsprintf (conn->errmsg, format, ap);
+ va_end (ap);
}
/*--------------------------------------------------
FUNCTION: httpc_header_add_date
DESC: Adds the current date to the header.
----------------------------------------------------*/
-static
-void
-httpc_header_add_date(httpc_conn_t * conn)
+static void
+httpc_header_add_date (httpc_conn_t * conn)
{
- char buffer[255];
- time_t nw;
- struct tm stm;
+ char buffer[255];
+ time_t nw;
+ struct tm stm;
- /* Set date */
- nw = time(NULL);
- localtime_r(&nw, &stm);
- strftime(buffer, 255, "%a, %d %b %Y %T GMT", &stm);
- httpc_set_header(conn, HEADER_DATE, buffer);
+ /* Set date */
+ nw = time (NULL);
+ localtime_r (&nw, &stm);
+ strftime (buffer, 255, "%a, %d %b %Y %T GMT", &stm);
+ httpc_set_header (conn, HEADER_DATE, buffer);
}
@@ -217,26 +221,28 @@ FUNCTION: httpc_send_header
DESC: Sends the current header information stored
in conn through conn->sock.
----------------------------------------------------*/
-herror_t
-httpc_send_header(httpc_conn_t * conn)
+herror_t
+httpc_send_header (httpc_conn_t * conn)
{
- hpair_t *p;
- herror_t status;
- char buffer[1024];
-
- p = conn->header;
- while (p != NULL) {
- if (p->key && p->value) {
- sprintf(buffer, "%s: %s\r\n", p->key, p->value);
- status = hsocket_send(conn->sock, buffer);
- if (status != H_OK)
- return status;
- }
- p = p->next;
- }
+ hpair_t *p;
+ herror_t status;
+ char buffer[1024];
- status = hsocket_send(conn->sock, "\r\n");
- return status;
+ p = conn->header;
+ while (p != NULL)
+ {
+ if (p->key && p->value)
+ {
+ sprintf (buffer, "%s: %s\r\n", p->key, p->value);
+ status = hsocket_send (conn->sock, buffer);
+ if (status != H_OK)
+ return status;
+ }
+ p = p->next;
+ }
+
+ status = hsocket_send (conn->sock, "\r\n");
+ return status;
}
/*--------------------------------------------------
@@ -284,90 +290,98 @@ can also be NULL.
If success, this function will return 0.
>0 otherwise.
----------------------------------------------------*/
-static
-herror_t
-httpc_talk_to_server(hreq_method_t method, httpc_conn_t * conn,
- const char *urlstr)
+static herror_t
+httpc_talk_to_server (hreq_method_t method, httpc_conn_t * conn,
+ const char *urlstr)
{
- hurl_t url;
- char buffer[4096];
- herror_t status;
+ hurl_t url;
+ char buffer[4096];
+ herror_t status;
- if (conn == NULL) {
- return herror_new(
- "httpc_talk_to_server",
- GENERAL_INVALID_PARAM,
- "httpc_conn_t param is NULL");
- }
- /* Build request header */
- httpc_header_add_date(conn);
+ if (conn == NULL)
+ {
+ return herror_new ("httpc_talk_to_server",
+ GENERAL_INVALID_PARAM, "httpc_conn_t param is NULL");
+ }
+ /* Build request header */
+ httpc_header_add_date (conn);
- /* Create url */
- status = hurl_parse(&url, urlstr);
- if (status != H_OK) {
- log_error2("Can not parse URL '%s'", SAVE_STR(urlstr));
- return status;
- }
+ /* Create url */
+ status = hurl_parse (&url, urlstr);
+ if (status != H_OK)
+ {
+ log_error2 ("Can not parse URL '%s'", SAVE_STR (urlstr));
+ return status;
+ }
/* TODO (#1#): Check for HTTP protocol in URL */
- /* Set hostname */
- httpc_set_header(conn, HEADER_HOST, url.host);
+ /* Set hostname */
+ httpc_set_header (conn, HEADER_HOST, url.host);
- /* Open connection */
- status = hsocket_open(&conn->sock, url.host, url.port);
- if (status != H_OK) {
- return status;
- }
+ /* Open connection */
+ status = hsocket_open (&conn->sock, url.host, url.port);
+ if (status != H_OK)
+ {
+ return status;
+ }
#ifdef HAVE_SSL
- /* TODO XXX XXX this is probably not right -- matt */
- if(!&conn->sock.ssl){
- status = hsocket_block(conn->sock, conn->block);
- if (status != H_OK) {
- log_error1("Cannot make socket non-blocking");
- return status;
- }
+ /* TODO XXX XXX this is probably not right -- matt */
+ if (!&conn->sock.ssl)
+ {
+ status = hsocket_block (conn->sock, conn->block);
+ if (status != H_OK)
+ {
+ log_error1 ("Cannot make socket non-blocking");
+ return status;
}
+ }
#endif
- /* check method */
- if (method == HTTP_REQUEST_GET) {
-
- /* Set GET Header */
- sprintf(buffer, "GET %s HTTP/%s\r\n",
- (url.context[0] != '\0') ? url.context : ("/"),
- (conn->version == HTTP_1_0)?"1.0":"1.1");
-
- } else if (method == HTTP_REQUEST_POST) {
-
- /* Set POST Header */
- sprintf(buffer, "POST %s HTTP/%s\r\n",
- (url.context[0] != '\0') ? url.context : ("/"),
- (conn->version == HTTP_1_0)?"1.0":"1.1");
- } else {
-
- log_error1("Unknown method type!");
- return herror_new(
- "httpc_talk_to_server",
- GENERAL_INVALID_PARAM,
- "hreq_method_t must be HTTP_REQUEST_GET or HTTP_REQUEST_POST");
- }
+ /* check method */
+ if (method == HTTP_REQUEST_GET)
+ {
- log_verbose1("Sending header...");
- status = hsocket_send(conn->sock, buffer);
- if (status != H_OK) {
- log_error2("Can not send request (status:%d)", status);
- hsocket_close(conn->sock);
- return status;
- }
- /* Send Header */
- status = httpc_send_header(conn);
- if (status != H_OK) {
- log_error2("Can not send header (status:%d)", status);
- hsocket_close(conn->sock);
- return status;
- }
+ /* Set GET Header */
+ sprintf (buffer, "GET %s HTTP/%s\r\n",
+ (url.context[0] != '\0') ? url.context : ("/"),
+ (conn->version == HTTP_1_0) ? "1.0" : "1.1");
+
+ }
+ else if (method == HTTP_REQUEST_POST)
+ {
+
+ /* Set POST Header */
+ sprintf (buffer, "POST %s HTTP/%s\r\n",
+ (url.context[0] != '\0') ? url.context : ("/"),
+ (conn->version == HTTP_1_0) ? "1.0" : "1.1");
+ }
+ else
+ {
+
+ log_error1 ("Unknown method type!");
+ return herror_new ("httpc_talk_to_server",
+ GENERAL_INVALID_PARAM,
+ "hreq_method_t must be HTTP_REQUEST_GET or HTTP_REQUEST_POST");
+ }
+
+ log_verbose1 ("Sending header...");
+ status = hsocket_send (conn->sock, buffer);
+ if (status != H_OK)
+ {
+ log_error2 ("Can not send request (status:%d)", status);
+ hsocket_close (conn->sock);
+ return status;
+ }
+ /* Send Header */
+ status = httpc_send_header (conn);
+ if (status != H_OK)
+ {
+ log_error2 ("Can not send header (status:%d)", status);
+ hsocket_close (conn->sock);
+ return status;
+ }
- return H_OK;
+ return H_OK;
}
@@ -376,25 +390,25 @@ FUNCTION: httpc_get
DESC:
----------------------------------------------------*/
herror_t
-httpc_get(httpc_conn_t *conn, hresponse_t** out, const char *urlstr)
+httpc_get (httpc_conn_t * conn, hresponse_t ** out, const char *urlstr)
{
- herror_t status;
+ herror_t status;
- status = httpc_talk_to_server(HTTP_REQUEST_GET, conn, urlstr);
+ status = httpc_talk_to_server (HTTP_REQUEST_GET, conn, urlstr);
- if (status != H_OK)
- {
- return status;
- }
+ if (status != H_OK)
+ {
+ return status;
+ }
- status = hresponse_new_from_socket(conn->sock, out);
- if (status != H_OK)
- {
- return status;
- }
-
+ status = hresponse_new_from_socket (conn->sock, out);
+ if (status != H_OK)
+ {
+ return status;
+ }
- return H_OK;
+
+ return H_OK;
}
@@ -402,16 +416,17 @@ httpc_get(httpc_conn_t *conn, hresponse_t** out, const char *urlstr)
FUNCTION: httpc_post_begin
DESC: Returns H_OK if success
----------------------------------------------------*/
-herror_t httpc_post_begin(httpc_conn_t *conn, const char *url)
+herror_t
+httpc_post_begin (httpc_conn_t * conn, const char *url)
{
-
- herror_t status;
- status = httpc_talk_to_server(HTTP_REQUEST_POST, conn, url);
- if (status != H_OK)
- return status;
+ herror_t status;
- conn->out = http_output_stream_new(conn->sock, conn->header);
+ status = httpc_talk_to_server (HTTP_REQUEST_POST, conn, url);
+ if (status != H_OK)
+ return status;
+
+ conn->out = http_output_stream_new (conn->sock, conn->header);
return H_OK;
}
@@ -422,24 +437,25 @@ FUNCTION: httpc_post_begin
DESC: End a "POST" method and receive the response.
You MUST call httpc_post_end() before!
----------------------------------------------------*/
-herror_t httpc_post_end(httpc_conn_t *conn, hresponse_t** out)
+herror_t
+httpc_post_end (httpc_conn_t * conn, hresponse_t ** out)
{
herror_t status;
- status = http_output_stream_flush(conn->out);
+ status = http_output_stream_flush (conn->out);
if (status != H_OK)
{
return status;
}
- status = hresponse_new_from_socket(conn->sock, out);
- if (status != H_OK)
- {
- return status;
- }
+ status = hresponse_new_from_socket (conn->sock, out);
+ if (status != H_OK)
+ {
+ return status;
+ }
- return H_OK;
+ return H_OK;
}
@@ -595,128 +611,134 @@ hresponse_t* httpc_dime_end(httpc_conn_t *conn)
MIME support functions httpc_mime_* function set
-----------------------------------------------------*/
-static
-void _httpc_mime_get_boundary(httpc_conn_t *conn, char *dest)
+static void
+_httpc_mime_get_boundary (httpc_conn_t * conn, char *dest)
{
- sprintf(dest, "---=.Part_NH_%d", conn->id);
- log_verbose2("boundary= \"%s\"", dest);
+ sprintf (dest, "---=.Part_NH_%d", conn->id);
+ log_verbose2 ("boundary= \"%s\"", dest);
}
-herror_t httpc_mime_begin(httpc_conn_t *conn, const char *url,
- const char* related_start,
- const char* related_start_info,
- const char* related_type)
+herror_t
+httpc_mime_begin (httpc_conn_t * conn, const char *url,
+ const char *related_start,
+ const char *related_start_info, const char *related_type)
{
- herror_t status;
- char buffer[300];
- char temp[75];
- char boundary[75];
-
- /*
- Set Content-type
- Set multipart/related parameter
- type=..; start=.. ; start-info= ..; boundary=...
-
- */
- sprintf(buffer, "multipart/related;");
- /*
- using sprintf instead of snprintf because visual c does not support snprintf
- */
+ herror_t status;
+ char buffer[300];
+ char temp[75];
+ char boundary[75];
+
+ /*
+ Set Content-type Set multipart/related parameter type=..; start=.. ;
+ start-info= ..; boundary=...
+
+ */
+ sprintf (buffer, "multipart/related;");
+ /*
+ using sprintf instead of snprintf because visual c does not support
+ snprintf */
#ifdef WIN32
#define snprintf(buffer, num, s1, s2) sprintf(buffer, s1,s2)
#endif
- if (related_type) {
- snprintf(temp, 75, " type=\"%s\";", related_type);
- strcat(buffer, temp);
+ if (related_type)
+ {
+ snprintf (temp, 75, " type=\"%s\";", related_type);
+ strcat (buffer, temp);
}
-
- if (related_start) {
- snprintf(temp, 75, " start=\"%s\";", related_start);
- strcat(buffer, temp);
+
+ if (related_start)
+ {
+ snprintf (temp, 75, " start=\"%s\";", related_start);
+ strcat (buffer, temp);
}
- if (related_start_info) {
- snprintf(temp, 75, " start-info=\"%s\";", related_start_info);
- strcat(buffer, temp);
+ if (related_start_info)
+ {
+ snprintf (temp, 75, " start-info=\"%s\";", related_start_info);
+ strcat (buffer, temp);
}
- _httpc_mime_get_boundary(conn, boundary);
- snprintf(temp, 75, " boundary=\"%s\"", boundary);
- strcat(buffer, temp);
+ _httpc_mime_get_boundary (conn, boundary);
+ snprintf (temp, 75, " boundary=\"%s\"", boundary);
+ strcat (buffer, temp);
- httpc_set_header(conn, HEADER_CONTENT_TYPE, buffer);
+ httpc_set_header (conn, HEADER_CONTENT_TYPE, buffer);
- status = httpc_post_begin(conn, url);
- return status;
+ status = httpc_post_begin (conn, url);
+ return status;
}
-herror_t httpc_mime_next(httpc_conn_t *conn,
- const char* content_id,
- const char* content_type,
- const char* transfer_encoding)
+herror_t
+httpc_mime_next (httpc_conn_t * conn,
+ const char *content_id,
+ const char *content_type, const char *transfer_encoding)
{
- herror_t status;
- char buffer[512];
- char boundary[75];
+ herror_t status;
+ char buffer[512];
+ char boundary[75];
/* Get the boundary string */
- _httpc_mime_get_boundary(conn, boundary);
- sprintf(buffer, "\r\n--%s\r\n", boundary);
+ _httpc_mime_get_boundary (conn, boundary);
+ sprintf (buffer, "\r\n--%s\r\n", boundary);
/* Send boundary */
- status = http_output_stream_write(conn->out,
- (const byte_t*)buffer, strlen(buffer));
+ status = http_output_stream_write (conn->out,
+ (const byte_t *) buffer,
+ strlen (buffer));
- if (status != H_OK)
- return status;
+ if (status != H_OK)
+ return status;
- /* Send Content header */
- sprintf(buffer, "%s: %s\r\n%s: %s\r\n%s: %s\r\n\r\n",
- HEADER_CONTENT_TYPE, content_type,
- HEADER_CONTENT_TRANSFER_ENCODING, transfer_encoding,
- HEADER_CONTENT_ID, content_id);
+ /* Send Content header */
+ sprintf (buffer, "%s: %s\r\n%s: %s\r\n%s: %s\r\n\r\n",
+ HEADER_CONTENT_TYPE, content_type,
+ HEADER_CONTENT_TRANSFER_ENCODING, transfer_encoding,
+ HEADER_CONTENT_ID, content_id);
- status = http_output_stream_write(conn->out,
- (const byte_t*)buffer, strlen(buffer));
+ status = http_output_stream_write (conn->out,
+ (const byte_t *) buffer,
+ strlen (buffer));
- return status;
+ return status;
}
-herror_t httpc_mime_end(httpc_conn_t *conn, hresponse_t** out)
+herror_t
+httpc_mime_end (httpc_conn_t * conn, hresponse_t ** out)
{
- herror_t status;
- char buffer[512];
- char boundary[75];
+ herror_t status;
+ char buffer[512];
+ char boundary[75];
/* Get the boundary string */
- _httpc_mime_get_boundary(conn, boundary);
- sprintf(buffer, "\r\n--%s--\r\n\r\n", boundary);
+ _httpc_mime_get_boundary (conn, boundary);
+ sprintf (buffer, "\r\n--%s--\r\n\r\n", boundary);
/* Send boundary */
- status = http_output_stream_write(conn->out,
- (const byte_t*)buffer, strlen(buffer));
+ status = http_output_stream_write (conn->out,
+ (const byte_t *) buffer,
+ strlen (buffer));
if (status != H_OK)
return status;
/* Flush put stream */
- status = http_output_stream_flush(conn->out);
+ status = http_output_stream_flush (conn->out);
if (status != H_OK)
{
return status;
}
- status = hresponse_new_from_socket(conn->sock, out);
- if (status != H_OK)
- {
- return status;
- }
-
- return H_OK;
+ status = hresponse_new_from_socket (conn->sock, out);
+ if (status != H_OK)
+ {
+ return status;
+ }
+
+ return H_OK;
}
@@ -737,11 +759,11 @@ httpc_mime_send_file (httpc_conn_t * conn,
size_t size;
if (fd == NULL)
- return herror_new("httpc_mime_send_file", FILE_ERROR_OPEN,
- "Can not open file '%s'", filename);
+ return herror_new ("httpc_mime_send_file", FILE_ERROR_OPEN,
+ "Can not open file '%s'", filename);
status =
- httpc_mime_next(conn, content_id, content_type, transfer_encoding);
+ httpc_mime_next (conn, content_id, content_type, transfer_encoding);
if (status != H_OK)
{
fclose (fd);
@@ -754,24 +776,23 @@ httpc_mime_send_file (httpc_conn_t * conn,
if (size == -1)
{
fclose (fd);
- return herror_new("httpc_mime_send_file", FILE_ERROR_READ,
- "Can not read from file '%s'", filename);
+ return herror_new ("httpc_mime_send_file", FILE_ERROR_READ,
+ "Can not read from file '%s'", filename);
}
- if (size>0)
- {
- /*DEBUG: fwrite(buffer, 1, size, stdout);*/
- status = http_output_stream_write (conn->out, buffer, size);
- if (status != H_OK) {
- fclose (fd);
- return status;
- }
- }
+ if (size > 0)
+ {
+ /* DEBUG: fwrite(buffer, 1, size, stdout); */
+ status = http_output_stream_write (conn->out, buffer, size);
+ if (status != H_OK)
+ {
+ fclose (fd);
+ return status;
+ }
+ }
}
fclose (fd);
- log_verbose1("file sent!");
+ log_verbose1 ("file sent!");
return H_OK;
}
-
-
diff --git a/nanohttp/nanohttp-client.h b/nanohttp/nanohttp-client.h
index 395b29a..77c8e8e 100644
--- a/nanohttp/nanohttp-client.h
+++ b/nanohttp/nanohttp-client.h
@@ -1,5 +1,5 @@
/******************************************************************
- * $Id: nanohttp-client.h,v 1.16 2005/12/19 14:18:26 snowdrop Exp $
+ * $Id: nanohttp-client.h,v 1.17 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -21,8 +21,8 @@
*
* Email: ferhatayaz@yahoo.com
******************************************************************/
-#ifndef NANO_HTTP_CLIENT_H
-#define NANO_HTTP_CLIENT_H
+#ifndef NANO_HTTP_CLIENT_H
+#define NANO_HTTP_CLIENT_H
#include <nanohttp/nanohttp-common.h>
@@ -36,19 +36,16 @@ typedef struct httpc_conn
hpair_t *header;
hurl_t url;
http_version_t version;
- /*
- -1 : last dime package
- 0 : no dime connection
- >0 : dime package number
- */
+ /*
+ -1 : last dime package 0 : no dime connection >0 : dime package number */
int _dime_package_nr;
- long _dime_sent_bytes;
+ long _dime_sent_bytes;
int errcode;
char errmsg[150];
http_output_stream_t *out;
- int id; /* uniq id */
+ int id; /* uniq id */
int block;
-}httpc_conn_t;
+} httpc_conn_t;
/* --------------------------------------------------------------
@@ -58,56 +55,57 @@ typedef struct httpc_conn
/**
initialize the httpc_* module
*/
-herror_t httpc_init(int argc, char *argv[]);
-
+herror_t httpc_init (int argc, char *argv[]);
+
/**
Destroy the httpc_* module
*/
-void httpc_destroy();
+void httpc_destroy ();
/**
Creates a new connection
*/
-httpc_conn_t* httpc_new();
+httpc_conn_t *httpc_new ();
/**
Close and release a connection
*/
-void httpc_close_free(httpc_conn_t* conn);
+void httpc_close_free (httpc_conn_t * conn);
/**
Release a connection
(use httpc_close_free() instead)
*/
-void httpc_free(httpc_conn_t* conn);
+void httpc_free (httpc_conn_t * conn);
/**
* Close and release a connection
*/
-void httpc_close_free(httpc_conn_t* conn);
+void httpc_close_free (httpc_conn_t * conn);
/**
Set header element (key,value) pair.
*/
-int httpc_set_header(httpc_conn_t *conn, const char* key, const char* value);
+int httpc_set_header (httpc_conn_t * conn, const char *key,
+ const char *value);
/**
Invoke a "GET" method request and receive the response
*/
herror_t
-httpc_get(httpc_conn_t *conn, hresponse_t** out, const char *urlstr);
+httpc_get (httpc_conn_t * conn, hresponse_t ** out, const char *urlstr);
/**
Start a "POST" method request
Returns: HSOCKET_OK or error flag
*/
-herror_t httpc_post_begin(httpc_conn_t *conn, const char *url);
+herror_t httpc_post_begin (httpc_conn_t * conn, const char *url);
/**
End a "POST" method and receive the response.
You MUST call httpc_post_end() before!
*/
-herror_t httpc_post_end(httpc_conn_t *conn, hresponse_t **out);
+herror_t httpc_post_end (httpc_conn_t * conn, hresponse_t ** out);
/* --------------------------------------------------------------
@@ -136,24 +134,24 @@ hresponse_t* httpc_dime_end(httpc_conn_t *conn);
Begin MIME multipart/related POST request
Returns: HSOCKET_OK or error flag
*/
-herror_t httpc_mime_begin(httpc_conn_t *conn, const char *url,
- const char* related_start,
- const char* related_start_info,
- const char* related_type);
+herror_t httpc_mime_begin (httpc_conn_t * conn, const char *url,
+ const char *related_start,
+ const char *related_start_info,
+ const char *related_type);
/**
Send boundary and part header and continue
with next part
*/
-herror_t httpc_mime_next(httpc_conn_t *conn,
- const char* content_id,
- const char* content_type,
- const char* transfer_encoding);
+herror_t httpc_mime_next (httpc_conn_t * conn,
+ const char *content_id,
+ const char *content_type,
+ const char *transfer_encoding);
/**
Finish MIME request and get the response
*/
-herror_t httpc_mime_end(httpc_conn_t *conn, hresponse_t** out);
+herror_t httpc_mime_end (httpc_conn_t * conn, hresponse_t ** out);
/**
Send boundary and part header and continue
@@ -161,11 +159,9 @@ herror_t httpc_mime_end(httpc_conn_t *conn, hresponse_t** out);
*/
herror_t httpc_mime_send_file (httpc_conn_t * conn,
- const char *content_id,
- const char *content_type,
- const char *transfer_encoding,
- const char *filename);
+ const char *content_id,
+ const char *content_type,
+ const char *transfer_encoding,
+ const char *filename);
#endif
-
-
diff --git a/nanohttp/nanohttp-common.c b/nanohttp/nanohttp-common.c
index aa1ab45..7d7b141 100644
--- a/nanohttp/nanohttp-common.c
+++ b/nanohttp/nanohttp-common.c
@@ -1,5 +1,5 @@
/******************************************************************
-* $Id: nanohttp-common.c,v 1.20 2006/01/06 16:16:10 snowdrop Exp $
+* $Id: nanohttp-common.c,v 1.21 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -39,7 +39,7 @@
#define MAX_OPTION_SIZE 50
#define MAX_OPTION_VALUE_SIZE 150
-static char _hoption_table[MAX_OPTION_SIZE][MAX_OPTION_VALUE_SIZE];
+static char _hoption_table[MAX_OPTION_SIZE][MAX_OPTION_VALUE_SIZE];
#ifdef HAVE_SSL
extern char *SSLCert;
@@ -49,49 +49,56 @@ extern int SSLCertLess;
#endif
/* option stuff */
-void hoption_set(int opt, const char* value)
+void
+hoption_set (int opt, const char *value)
{
- if (opt >= MAX_OPTION_SIZE) {
- log_warn3("Option to high (%d >= %d)", opt, MAX_OPTION_SIZE);
- return;
- }
+ if (opt >= MAX_OPTION_SIZE)
+ {
+ log_warn3 ("Option to high (%d >= %d)", opt, MAX_OPTION_SIZE);
+ return;
+ }
- strncpy(_hoption_table[opt], value, MAX_OPTION_VALUE_SIZE);
+ strncpy (_hoption_table[opt], value, MAX_OPTION_VALUE_SIZE);
}
-char *hoption_get(int opt)
+char *
+hoption_get (int opt)
{
- if (opt >= MAX_OPTION_SIZE) {
- log_warn3("Option to high (%d >= %d)", opt, MAX_OPTION_SIZE);
- return "";
- }
+ if (opt >= MAX_OPTION_SIZE)
+ {
+ log_warn3 ("Option to high (%d >= %d)", opt, MAX_OPTION_SIZE);
+ return "";
+ }
- return _hoption_table[opt];
+ return _hoption_table[opt];
}
-void hoption_init_args(int argc, char* argv[])
+void
+hoption_init_args (int argc, char *argv[])
{
int i;
- hoption_set(HOPTION_TMP_DIR, "."); /* default value */
+ hoption_set (HOPTION_TMP_DIR, "."); /* default value */
/* initialize from arguments */
for (i = 0; i < argc; i++)
{
if (!strcmp (argv[i], NHTTP_ARG_TMPDIR) && i < argc - 1)
{
- hoption_set(HOPTION_TMP_DIR, argv[i+1]);
+ hoption_set (HOPTION_TMP_DIR, argv[i + 1]);
}
else if (!strcmp (argv[i], NHTTP_ARG_LOGFILE) && i < argc - 1)
{
- log_set_file(argv[i+1]);
+ log_set_file (argv[i + 1]);
}
else if (!strcmp (argv[i], NHTTP_ARG_CERT) && i < argc - 1)
{
#ifndef HAVE_SSL
- fprintf(stderr,"WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled", NHTTP_ARG_CERT);
+ fprintf (stderr,
+ "WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled",
+ NHTTP_ARG_CERT);
#else
SSLCert = argv[i + 1];
#endif
@@ -99,7 +106,9 @@ void hoption_init_args(int argc, char* argv[])
else if (!strcmp (argv[i], NHTTP_ARG_CERTPASS) && i < argc - 1)
{
#ifndef HAVE_SSL
- fprintf(stderr,"WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled", NHTTP_ARG_CERTPASS);
+ fprintf (stderr,
+ "WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled",
+ NHTTP_ARG_CERTPASS);
#else
SSLPass = argv[i + 1];
#endif
@@ -107,15 +116,19 @@ void hoption_init_args(int argc, char* argv[])
else if (!strcmp (argv[i], NHTTP_ARG_CA) && i < argc - 1)
{
#ifndef HAVE_SSL
- fprintf(stderr,"WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled", NHTTP_ARG_CA);
+ fprintf (stderr,
+ "WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled",
+ NHTTP_ARG_CA);
#else
SSLCA = argv[i + 1];
#endif
}
- else if (!strcmp (argv[i], NHTTP_ARG_HTTPS) )
+ else if (!strcmp (argv[i], NHTTP_ARG_HTTPS))
{
#ifndef HAVE_SSL
- fprintf(stderr,"WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled", NHTTP_ARG_HTTPS);
+ fprintf (stderr,
+ "WARNING: csoap compiled without '--with-ssl' flag. Parameter '%s' is disabled",
+ NHTTP_ARG_HTTPS);
#else
SSLCertLess = 1;
#endif
@@ -127,613 +140,667 @@ void hoption_init_args(int argc, char* argv[])
#ifdef WIN32
-#ifndef __MINGW32__
+#ifndef __MINGW32__
/* not thread safe!*/
-char *VisualC_funcname(const char* file, int line)
+char *
+VisualC_funcname (const char *file, int line)
{
- static char buffer[256];
- int i = strlen(file)-1;
- while (i>0 && file[i]!='\\')i--;
- sprintf(buffer, "%s:%d", (file[i]!='\\')?file:(file+i+1), line);
- return buffer;
-}
+ static char buffer[256];
+ int i = strlen (file) - 1;
+ while (i > 0 && file[i] != '\\')
+ i--;
+ sprintf (buffer, "%s:%d", (file[i] != '\\') ? file : (file + i + 1), line);
+ return buffer;
+}
#endif
#endif
typedef struct _herror_impl_t
{
- int errcode;
- char message[250];
- char func[100];
-}herror_impl_t;
+ int errcode;
+ char message[250];
+ char func[100];
+} herror_impl_t;
-herror_t herror_new(const char* func, int errcode, const char* format, ...)
+herror_t
+herror_new (const char *func, int errcode, const char *format, ...)
{
- va_list ap;
+ va_list ap;
- herror_impl_t *impl = (herror_impl_t*)malloc(sizeof(herror_impl_t));
- impl->errcode = errcode;
- strcpy(impl->func, func);
- va_start(ap, format);
- vsprintf(impl->message, format, ap);
- va_end(ap);
+ herror_impl_t *impl = (herror_impl_t *) malloc (sizeof (herror_impl_t));
+ impl->errcode = errcode;
+ strcpy (impl->func, func);
+ va_start (ap, format);
+ vsprintf (impl->message, format, ap);
+ va_end (ap);
- return (herror_t)impl;
+ return (herror_t) impl;
}
-int herror_code(herror_t err)
+int
+herror_code (herror_t err)
{
- herror_impl_t* impl = (herror_impl_t*)err;
- if (!err) return H_OK;
- return impl->errcode;
+ herror_impl_t *impl = (herror_impl_t *) err;
+ if (!err)
+ return H_OK;
+ return impl->errcode;
}
-char* herror_func(herror_t err)
+char *
+herror_func (herror_t err)
{
- herror_impl_t* impl = (herror_impl_t*)err;
- if (!err) return "";
- return impl->func;
+ herror_impl_t *impl = (herror_impl_t *) err;
+ if (!err)
+ return "";
+ return impl->func;
}
-char* herror_message(herror_t err)
+char *
+herror_message (herror_t err)
{
- herror_impl_t* impl = (herror_impl_t*)err;
- if (!err) return "";
- return impl->message;
+ herror_impl_t *impl = (herror_impl_t *) err;
+ if (!err)
+ return "";
+ return impl->message;
}
-void herror_release(herror_t err)
+void
+herror_release (herror_t err)
{
- herror_impl_t* impl = (herror_impl_t*)err;
- if (!err) return;
- free(impl);
+ herror_impl_t *impl = (herror_impl_t *) err;
+ if (!err)
+ return;
+ free (impl);
}
static log_level_t loglevel = HLOG_DEBUG;
-static char logfile[75] = {'\0'};
-static int log_background=0;
+static char logfile[75] = { '\0' };
+static int log_background = 0;
-log_level_t
-log_set_level(log_level_t level)
+log_level_t
+log_set_level (log_level_t level)
{
- log_level_t old = loglevel;
- loglevel = level;
- return old;
+ log_level_t old = loglevel;
+ loglevel = level;
+ return old;
}
-log_level_t
-log_get_level()
+log_level_t
+log_get_level ()
{
- return loglevel;
+ return loglevel;
}
-void log_set_file(const char *filename)
+void
+log_set_file (const char *filename)
{
- if (filename)
- strncpy(logfile, filename, 75);
- else
- logfile[0] = '\0';
+ if (filename)
+ strncpy (logfile, filename, 75);
+ else
+ logfile[0] = '\0';
}
-void log_set_background(int state)
+void
+log_set_background (int state)
{
- log_background=state;
+ log_background = state;
}
-char *log_get_file()
+char *
+log_get_file ()
{
- if (logfile[0] == '\0') return NULL;
- return logfile;
+ if (logfile[0] == '\0')
+ return NULL;
+ return logfile;
}
-static
-void
-log_write(log_level_t level, const char *prefix,
- const char *func, const char *format, va_list ap)
+static void
+log_write (log_level_t level, const char *prefix,
+ const char *func, const char *format, va_list ap)
{
- char buffer[1054];
- char buffer2[1054];
- FILE *f;
+ char buffer[1054];
+ char buffer2[1054];
+ FILE *f;
- if (level < loglevel)
- return;
+ if (level < loglevel)
+ return;
- if(!log_background || log_get_file()){
+ if (!log_background || log_get_file ())
+ {
#ifdef WIN32
- sprintf(buffer, "*%s*: [%s] %s\n",
- prefix, func, format);
+ sprintf (buffer, "*%s*: [%s] %s\n", prefix, func, format);
#else
- sprintf(buffer, "*%s*:(%d) [%s] %s\n",
- prefix, pthread_self(),func, format);
+ sprintf (buffer, "*%s*:(%d) [%s] %s\n",
+ prefix, pthread_self (), func, format);
#endif
- vsprintf(buffer2, buffer, ap);
- if(!log_background){
- printf(buffer2);
- fflush(stdout);
- }
+ vsprintf (buffer2, buffer, ap);
+ if (!log_background)
+ {
+ printf (buffer2);
+ fflush (stdout);
+ }
- if (log_get_file()) {
- f = fopen(log_get_file(), "a");
- if (!f) f = fopen(log_get_file(), "w");
- if (f) {
- fprintf(f, buffer2);
- fflush(f);
- fclose(f);
- }
- }
- }
+ if (log_get_file ())
+ {
+ f = fopen (log_get_file (), "a");
+ if (!f)
+ f = fopen (log_get_file (), "w");
+ if (f)
+ {
+ fprintf (f, buffer2);
+ fflush (f);
+ fclose (f);
+ }
+ }
+ }
}
-void
-log_verbose(const char *FUNC, const char *format,...)
+void
+log_verbose (const char *FUNC, const char *format, ...)
{
- va_list ap;
+ va_list ap;
- va_start(ap, format);
- log_write(HLOG_VERBOSE, "VERBOSE", FUNC, format, ap);
- va_end(ap);
+ va_start (ap, format);
+ log_write (HLOG_VERBOSE, "VERBOSE", FUNC, format, ap);
+ va_end (ap);
}
-void
-log_debug(const char *FUNC, const char *format,...)
+void
+log_debug (const char *FUNC, const char *format, ...)
{
- va_list ap;
+ va_list ap;
- va_start(ap, format);
- log_write(HLOG_DEBUG, "DEBUG", FUNC, format, ap);
- va_end(ap);
+ va_start (ap, format);
+ log_write (HLOG_DEBUG, "DEBUG", FUNC, format, ap);
+ va_end (ap);
}
-void
-log_info(const char *FUNC, const char *format,...)
+void
+log_info (const char *FUNC, const char *format, ...)
{
- va_list ap;
+ va_list ap;
- va_start(ap, format);
- log_write(HLOG_INFO, "INFO", FUNC, format, ap);
- va_end(ap);
+ va_start (ap, format);
+ log_write (HLOG_INFO, "INFO", FUNC, format, ap);
+ va_end (ap);
}
-void
-log_warn(const char *FUNC, const char *format,...)
+void
+log_warn (const char *FUNC, const char *format, ...)
{
- va_list ap;
+ va_list ap;
- va_start(ap, format);
- log_write(HLOG_WARN, "WARN", FUNC, format, ap);
- va_end(ap);
+ va_start (ap, format);
+ log_write (HLOG_WARN, "WARN", FUNC, format, ap);
+ va_end (ap);
}
-void
-log_error(const char *FUNC, const char *format,...)
+void
+log_error (const char *FUNC, const char *format, ...)
{
- va_list ap;
+ va_list ap;
- va_start(ap, format);
- log_write(HLOG_ERROR, "ERROR", FUNC, format, ap);
- va_end(ap);
+ va_start (ap, format);
+ log_write (HLOG_ERROR, "ERROR", FUNC, format, ap);
+ va_end (ap);
}
/* -----------------------------------------
FUNCTION: strcmpigcase
------------------------------------------*/
-int
-strcmpigcase(const char *s1, const char *s2)
+int
+strcmpigcase (const char *s1, const char *s2)
{
- int l1, l2, i;
+ int l1, l2, i;
- if (s1 == NULL && s2 == NULL)
- return 1;
- if (s1 == NULL || s2 == NULL)
- return 0;
+ if (s1 == NULL && s2 == NULL)
+ return 1;
+ if (s1 == NULL || s2 == NULL)
+ return 0;
- l1 = strlen(s1);
- l2 = strlen(s2);
+ l1 = strlen (s1);
+ l2 = strlen (s2);
- if (l1 != l2)
- return 0;
+ if (l1 != l2)
+ return 0;
- for (i = 0; i < l1; i++)
- if (toupper(s1[i]) != toupper(s2[i]))
- return 0;
+ for (i = 0; i < l1; i++)
+ if (toupper (s1[i]) != toupper (s2[i]))
+ return 0;
- return 1;
+ return 1;
}
-hpair_t *
-hpairnode_new(const char *key, const char *value, hpair_t * next)
+hpair_t *
+hpairnode_new (const char *key, const char *value, hpair_t * next)
{
- hpair_t *pair;
+ hpair_t *pair;
- log_verbose3("new pair ('%s','%s')", SAVE_STR(key), SAVE_STR(value));
- pair = (hpair_t *) malloc(sizeof(hpair_t));
+ log_verbose3 ("new pair ('%s','%s')", SAVE_STR (key), SAVE_STR (value));
+ pair = (hpair_t *) malloc (sizeof (hpair_t));
- if (key != NULL) {
- pair->key = (char *) malloc(strlen(key) + 1);
- strcpy(pair->key, key);
- } else {
- pair->key = NULL;
- }
+ if (key != NULL)
+ {
+ pair->key = (char *) malloc (strlen (key) + 1);
+ strcpy (pair->key, key);
+ }
+ else
+ {
+ pair->key = NULL;
+ }
- if (value != NULL) {
- pair->value = (char *) malloc(strlen(value) + 1);
- strcpy(pair->value, value);
- } else {
- pair->value = NULL;
- }
+ if (value != NULL)
+ {
+ pair->value = (char *) malloc (strlen (value) + 1);
+ strcpy (pair->value, value);
+ }
+ else
+ {
+ pair->value = NULL;
+ }
- pair->next = next;
+ pair->next = next;
- return pair;
+ return pair;
}
-hpair_t *
-hpairnode_parse(const char *str, const char *delim, hpair_t * next)
+hpair_t *
+hpairnode_parse (const char *str, const char *delim, hpair_t * next)
{
- hpair_t *pair;
- char *key, *value;
- int c;
+ hpair_t *pair;
+ char *key, *value;
+ int c;
- pair = (hpair_t *) malloc(sizeof(hpair_t));
- pair->key = "";
- pair->value = "";
- pair->next = next;
+ pair = (hpair_t *) malloc (sizeof (hpair_t));
+ pair->key = "";
+ pair->value = "";
+ pair->next = next;
- key = strtok_r((char *) str, delim, &value);
+ key = strtok_r ((char *) str, delim, &value);
- if (key != NULL) {
- pair->key = (char *) malloc(strlen(key) + 1);
- strcpy(pair->key, key);
- }
- if (value != NULL) {
- for (c = 0; value[c] == ' '; c++); /* skip white space */
- pair->value = (char *) malloc(strlen(&value[c]) + 1);
- strcpy(pair->value, &value[c]);
- }
- return pair;
+ if (key != NULL)
+ {
+ pair->key = (char *) malloc (strlen (key) + 1);
+ strcpy (pair->key, key);
+ }
+ if (value != NULL)
+ {
+ for (c = 0; value[c] == ' '; c++); /* skip white space */
+ pair->value = (char *) malloc (strlen (&value[c]) + 1);
+ strcpy (pair->value, &value[c]);
+ }
+ return pair;
}
-hpair_t *
-hpairnode_copy(const hpair_t * src)
+hpair_t *
+hpairnode_copy (const hpair_t * src)
{
- hpair_t *pair;
+ hpair_t *pair;
- if (src == NULL)
- return NULL;
+ if (src == NULL)
+ return NULL;
- pair = hpairnode_new(src->key, src->value, NULL);
- return pair;
+ pair = hpairnode_new (src->key, src->value, NULL);
+ return pair;
}
-hpair_t *
-hpairnode_copy_deep(const hpair_t * src)
+hpair_t *
+hpairnode_copy_deep (const hpair_t * src)
{
- hpair_t *pair, *result, *next;
+ hpair_t *pair, *result, *next;
- if (src == NULL)
- return NULL;
+ if (src == NULL)
+ return NULL;
- result = hpairnode_copy(src);
+ result = hpairnode_copy (src);
- next = src->next;
- pair = result;
+ next = src->next;
+ pair = result;
- while (next != NULL) {
- pair->next = hpairnode_copy(next);
- pair = pair->next;
- next = next->next;
- }
+ while (next != NULL)
+ {
+ pair->next = hpairnode_copy (next);
+ pair = pair->next;
+ next = next->next;
+ }
- return result;
+ return result;
}
-void
-hpairnode_dump(hpair_t * pair)
+void
+hpairnode_dump (hpair_t * pair)
{
- if (pair == NULL) {
- log_verbose1("(NULL)[]");
- return;
- }
- log_verbose5("(%p)['%s','%s','%p']", pair,
- SAVE_STR(pair->key), SAVE_STR(pair->value),
- pair->next);
+ if (pair == NULL)
+ {
+ log_verbose1 ("(NULL)[]");
+ return;
+ }
+ log_verbose5 ("(%p)['%s','%s','%p']", pair,
+ SAVE_STR (pair->key), SAVE_STR (pair->value), pair->next);
}
-void
-hpairnode_dump_deep(hpair_t * pair)
+void
+hpairnode_dump_deep (hpair_t * pair)
{
- hpair_t *p;
- p = pair;
+ hpair_t *p;
+ p = pair;
- log_verbose1("-- BEGIN dump hpairnode_t --");
+ log_verbose1 ("-- BEGIN dump hpairnode_t --");
- while (p != NULL) {
- hpairnode_dump(p);
- p = p->next;
- }
+ while (p != NULL)
+ {
+ hpairnode_dump (p);
+ p = p->next;
+ }
- log_verbose1("-- END dump hpairnode_t --\n");
+ log_verbose1 ("-- END dump hpairnode_t --\n");
}
-void
-hpairnode_free(hpair_t * pair)
+void
+hpairnode_free (hpair_t * pair)
{
- if (pair == NULL)
- return;
+ if (pair == NULL)
+ return;
- free(pair->key);
- free(pair->value);
+ free (pair->key);
+ free (pair->value);
- free(pair);
+ free (pair);
}
-void
-hpairnode_free_deep(hpair_t * pair)
+void
+hpairnode_free_deep (hpair_t * pair)
{
- hpair_t *tmp;
+ hpair_t *tmp;
+
+ while (pair != NULL)
+ {
+ tmp = pair->next;
+ hpairnode_free (pair);
+ pair = tmp;
+ }
+}
+
+char *
+hpairnode_get_ignore_case (hpair_t * pair, const char *key)
+{
+ if (key == NULL)
+ {
+ log_error1 ("key is NULL");
+ return NULL;
+ }
+ while (pair != NULL)
+ {
+ if (pair->key != NULL)
+ {
+ if (strcmpigcase (pair->key, key))
+ {
+ return pair->value;
+ }
+ }
+ pair = pair->next;
+ }
+
+ return NULL;
+}
+
+char *
+hpairnode_get (hpair_t * pair, const char *key)
+{
+ if (key == NULL)
+ {
+ log_error1 ("key is NULL");
+ return NULL;
+ }
+ while (pair != NULL)
+ {
+ if (pair->key != NULL)
+ {
+ if (!strcmp (pair->key, key))
+ {
+ return pair->value;
+ }
+ }
+ pair = pair->next;
+ }
- while (pair != NULL) {
- tmp = pair->next;
- hpairnode_free(pair);
- pair = tmp;
- }
+ return NULL;
}
-char *
-hpairnode_get_ignore_case(hpair_t * pair, const char *key)
+static void
+hurl_dump (const hurl_t * url)
{
- if (key == NULL) {
- log_error1("key is NULL");
- return NULL;
- }
- while (pair != NULL) {
- if (pair->key != NULL) {
- if (strcmpigcase(pair->key, key)) {
- return pair->value;
- }
- }
- pair = pair->next;
- }
- return NULL;
+ if (url == NULL)
+ {
+ log_error1 ("url is NULL!");
+ return;
+ }
+ log_verbose2 ("PROTOCOL : %d", url->protocol);
+ log_verbose2 (" HOST : %s", url->host);
+ log_verbose2 (" PORT : %d", url->port);
+ log_verbose2 (" CONTEXT : %s", url->context);
}
-char *
-hpairnode_get(hpair_t * pair, const char *key)
+
+herror_t
+hurl_parse (hurl_t * url, const char *urlstr)
{
- if (key == NULL) {
- log_error1("key is NULL");
- return NULL;
- }
- while (pair != NULL) {
- if (pair->key != NULL) {
- if (!strcmp(pair->key, key)) {
- return pair->value;
- }
- }
- pair = pair->next;
- }
-
- return NULL;
-}
-
-static
-void
-hurl_dump(const hurl_t * url)
-{
-
- if (url == NULL) {
- log_error1("url is NULL!");
- return;
- }
- log_verbose2("PROTOCOL : %d", url->protocol);
- log_verbose2(" HOST : %s", url->host);
- log_verbose2(" PORT : %d", url->port);
- log_verbose2(" CONTEXT : %s", url->context);
-}
-
-
-herror_t hurl_parse(hurl_t* url, const char *urlstr)
-{
- int iprotocol;
- int ihost;
- int iport;
- int len;
- int size;
- char tmp[8];
- char protocol[1024];
-
- iprotocol = 0;
- len = strlen(urlstr);
-
- /* find protocol */
- while (urlstr[iprotocol] != ':' && urlstr[iprotocol] != '\0') {
- iprotocol++;
- }
-
- if (iprotocol == 0) {
- log_error1("no protocol");
- return herror_new("hurl_parse", URL_ERROR_NO_PROTOCOL, "No protocol");
- }
- if (iprotocol + 3 >= len) {
- log_error1("no host");
- return herror_new("hurl_parse", URL_ERROR_NO_HOST, "No host");
- }
- if (urlstr[iprotocol] != ':'
- && urlstr[iprotocol + 1] != '/'
- && urlstr[iprotocol + 2] != '/') {
- log_error1("no protocol");
- return herror_new("hurl_parse", URL_ERROR_NO_PROTOCOL, "No protocol");
- }
- /* find host */
- ihost = iprotocol + 3;
- while (urlstr[ihost] != ':'
- && urlstr[ihost] != '/'
- && urlstr[ihost] != '\0') {
- ihost++;
- }
-
- if (ihost == iprotocol + 1) {
- log_error1("no host");
- return herror_new("hurl_parse", URL_ERROR_NO_HOST, "No host");
- }
- /* find port */
- iport = ihost;
- if (ihost + 1 < len) {
- if (urlstr[ihost] == ':') {
- while (urlstr[iport] != '/' && urlstr[iport] != '\0') {
- iport++;
- }
- }
- }
-
- /* find protocol */
- strncpy(protocol, urlstr, iprotocol);
- protocol[iprotocol] = '\0';
- if (strcmpigcase(protocol, "http"))
- url->protocol = PROTOCOL_HTTP;
- else if (strcmpigcase(protocol, "https"))
- url->protocol = PROTOCOL_HTTPS;
- else if (strcmpigcase(protocol, "ftp"))
- url->protocol = PROTOCOL_FTP;
- else return herror_new("hurl_parse",
- URL_ERROR_UNKNOWN_PROTOCOL, "Unknown protocol '%s'", protocol);
-
- /* TODO (#1#): add max of size and URL_MAX_HOST_SIZE */
- size = ihost - iprotocol - 3;
- strncpy(url->host, &urlstr[iprotocol + 3], size);
- url->host[size] = '\0';
-
- if (iport > ihost) {
- size = iport - ihost;
- strncpy(tmp, &urlstr[ihost + 1], size);
- url->port = atoi(tmp);
- } else {
- switch (url->protocol) {
- case PROTOCOL_HTTP:
- url->port = URL_DEFAULT_PORT_HTTP;
- break;
- case PROTOCOL_HTTPS:
- url->port = URL_DEFAULT_PORT_HTTPS;
- break;
- case PROTOCOL_FTP:
- url->port = URL_DEFAULT_PORT_FTP;
- break;
- }
- }
-
- len = strlen(urlstr);
- if (len > iport) {
- /* TODO (#1#): find max of size and URL_MAX_CONTEXT_SIZE */
- size = len - iport;
- strncpy(url->context, &urlstr[iport], size);
- url->context[size] = '\0';
- } else {
- url->context[0] = '\0';
- }
-
- hurl_dump(url);
-
- return H_OK;
+ int iprotocol;
+ int ihost;
+ int iport;
+ int len;
+ int size;
+ char tmp[8];
+ char protocol[1024];
+
+ iprotocol = 0;
+ len = strlen (urlstr);
+
+ /* find protocol */
+ while (urlstr[iprotocol] != ':' && urlstr[iprotocol] != '\0')
+ {
+ iprotocol++;
+ }
+
+ if (iprotocol == 0)
+ {
+ log_error1 ("no protocol");
+ return herror_new ("hurl_parse", URL_ERROR_NO_PROTOCOL, "No protocol");
+ }
+ if (iprotocol + 3 >= len)
+ {
+ log_error1 ("no host");
+ return herror_new ("hurl_parse", URL_ERROR_NO_HOST, "No host");
+ }
+ if (urlstr[iprotocol] != ':'
+ && urlstr[iprotocol + 1] != '/' && urlstr[iprotocol + 2] != '/')
+ {
+ log_error1 ("no protocol");
+ return herror_new ("hurl_parse", URL_ERROR_NO_PROTOCOL, "No protocol");
+ }
+ /* find host */
+ ihost = iprotocol + 3;
+ while (urlstr[ihost] != ':'
+ && urlstr[ihost] != '/' && urlstr[ihost] != '\0')
+ {
+ ihost++;
+ }
+
+ if (ihost == iprotocol + 1)
+ {
+ log_error1 ("no host");
+ return herror_new ("hurl_parse", URL_ERROR_NO_HOST, "No host");
+ }
+ /* find port */
+ iport = ihost;
+ if (ihost + 1 < len)
+ {
+ if (urlstr[ihost] == ':')
+ {
+ while (urlstr[iport] != '/' && urlstr[iport] != '\0')
+ {
+ iport++;
+ }
+ }
+ }
+
+ /* find protocol */
+ strncpy (protocol, urlstr, iprotocol);
+ protocol[iprotocol] = '\0';
+ if (strcmpigcase (protocol, "http"))
+ url->protocol = PROTOCOL_HTTP;
+ else if (strcmpigcase (protocol, "https"))
+ url->protocol = PROTOCOL_HTTPS;
+ else if (strcmpigcase (protocol, "ftp"))
+ url->protocol = PROTOCOL_FTP;
+ else
+ return herror_new ("hurl_parse",
+ URL_ERROR_UNKNOWN_PROTOCOL, "Unknown protocol '%s'",
+ protocol);
+
+ /* TODO (#1#): add max of size and URL_MAX_HOST_SIZE */
+ size = ihost - iprotocol - 3;
+ strncpy (url->host, &urlstr[iprotocol + 3], size);
+ url->host[size] = '\0';
+
+ if (iport > ihost)
+ {
+ size = iport - ihost;
+ strncpy (tmp, &urlstr[ihost + 1], size);
+ url->port = atoi (tmp);
+ }
+ else
+ {
+ switch (url->protocol)
+ {
+ case PROTOCOL_HTTP:
+ url->port = URL_DEFAULT_PORT_HTTP;
+ break;
+ case PROTOCOL_HTTPS:
+ url->port = URL_DEFAULT_PORT_HTTPS;
+ break;
+ case PROTOCOL_FTP:
+ url->port = URL_DEFAULT_PORT_FTP;
+ break;
+ }
+ }
+
+ len = strlen (urlstr);
+ if (len > iport)
+ {
+ /* TODO (#1#): find max of size and URL_MAX_CONTEXT_SIZE */
+ size = len - iport;
+ strncpy (url->context, &urlstr[iport], size);
+ url->context[size] = '\0';
+ }
+ else
+ {
+ url->context[0] = '\0';
+ }
+
+ hurl_dump (url);
+
+ return H_OK;
}
/* Content-type stuff */
-content_type_t *content_type_new(const char* content_type_str)
+content_type_t *
+content_type_new (const char *content_type_str)
{
hpair_t *pair = NULL, *last = NULL;
- content_type_t * ct;
+ content_type_t *ct;
char ch, key[256], value[256];
- int inQuote = 0, i=0, c=0, begin=0, len;
- int mode = 0;
- /* 0: searching ';'
- 1: process key
- 2: process value
- */
-
+ int inQuote = 0, i = 0, c = 0, begin = 0, len;
+ int mode = 0;
+ /* 0: searching ';' 1: process key 2: process value */
+
/* Create object */
- ct = (content_type_t*)malloc(sizeof(content_type_t));
+ ct = (content_type_t *) malloc (sizeof (content_type_t));
ct->params = NULL;
- len = strlen(content_type_str);
+ len = strlen (content_type_str);
while (i <= len)
{
if (i != len)
ch = content_type_str[i++];
- else
+ else
{
- ch = ' '; i++;
+ ch = ' ';
+ i++;
}
switch (mode)
{
- case 0:
-
- if (ch == ';')
- {
- ct->type[c] = '\0';
- c = 0;
- mode = 1;
- }
- else if (ch != ' ' && ch != '\t' && ch != '\r')
- ct->type[c++] = ch;
- break;
-
- case 1:
-
- if (ch == '=')
- {
- key[c] = '\0';
- c = 0;
- mode = 2;
- }
- else if (ch != ' ' && ch != '\t' && ch != '\r')
- key[c++] = ch;
- break;
-
- case 2:
-
- if (ch != ' ') begin = 1;
-
- if ((ch == ' ' || ch == ';') && !inQuote && begin)
- {
- value[c] = '\0';
-
- pair = hpairnode_new(key, value, NULL);
- if (ct->params == NULL)
- ct->params = pair;
- else
- last->next = pair;
- last = pair;
-
- c = 0;
- begin = 0;
- mode = 1;
- }
- else if (ch == '"')
- inQuote = !inQuote;
- else if (begin && ch != '\r')
- value[c++] = ch;
-
- break;
+ case 0:
+
+ if (ch == ';')
+ {
+ ct->type[c] = '\0';
+ c = 0;
+ mode = 1;
+ }
+ else if (ch != ' ' && ch != '\t' && ch != '\r')
+ ct->type[c++] = ch;
+ break;
+
+ case 1:
+
+ if (ch == '=')
+ {
+ key[c] = '\0';
+ c = 0;
+ mode = 2;
+ }
+ else if (ch != ' ' && ch != '\t' && ch != '\r')
+ key[c++] = ch;
+ break;
+
+ case 2:
+
+ if (ch != ' ')
+ begin = 1;
+
+ if ((ch == ' ' || ch == ';') && !inQuote && begin)
+ {
+ value[c] = '\0';
+
+ pair = hpairnode_new (key, value, NULL);
+ if (ct->params == NULL)
+ ct->params = pair;
+ else
+ last->next = pair;
+ last = pair;
+
+ c = 0;
+ begin = 0;
+ mode = 1;
+ }
+ else if (ch == '"')
+ inQuote = !inQuote;
+ else if (begin && ch != '\r')
+ value[c++] = ch;
+
+ break;
}
}
@@ -742,61 +809,74 @@ content_type_t *content_type_new(const char* content_type_str)
}
-void content_type_free(content_type_t *ct)
+void
+content_type_free (content_type_t * ct)
{
- if (!ct) return;
+ if (!ct)
+ return;
- hpairnode_free_deep(ct->params);
- free(ct);
+ hpairnode_free_deep (ct->params);
+ free (ct);
}
-part_t *part_new(const char *id, const char* filename,
- const char* content_type, const char* transfer_encoding, part_t *next)
+part_t *
+part_new (const char *id, const char *filename,
+ const char *content_type, const char *transfer_encoding,
+ part_t * next)
{
- part_t *part = (part_t*)malloc(sizeof(part_t));
+ part_t *part = (part_t *) malloc (sizeof (part_t));
part->header = NULL;
part->next = next;
part->deleteOnExit = 0;
- strcpy(part->id, id);
- strcpy(part->filename, filename);
+ strcpy (part->id, id);
+ strcpy (part->filename, filename);
if (content_type)
- strcpy(part->content_type, content_type);
+ strcpy (part->content_type, content_type);
else
part->content_type[0] = '\0';
- part->header = hpairnode_new(HEADER_CONTENT_ID, id, part->header);
+ part->header = hpairnode_new (HEADER_CONTENT_ID, id, part->header);
/* TODO (#1#): encoding is always binary. implement also others! */
/* part->header = hpairnode_new(HEADER_CONTENT_TRANSFER_ENCODING, "binary", part->header);*/
-
- strcpy(part->transfer_encoding, transfer_encoding?transfer_encoding:"binary");
- if (content_type) {
- part->header = hpairnode_new(HEADER_CONTENT_TYPE, content_type, part->header);
- } else {
+ strcpy (part->transfer_encoding,
+ transfer_encoding ? transfer_encoding : "binary");
+
+ if (content_type)
+ {
+ part->header =
+ hpairnode_new (HEADER_CONTENT_TYPE, content_type, part->header);
+ }
+ else
+ {
/* TODO (#1#): get content-type from mime type list */
}
return part;
}
-void part_free(part_t *part)
+void
+part_free (part_t * part)
{
if (part == NULL)
return;
- if (part->deleteOnExit) {
- remove(part->filename);
+ if (part->deleteOnExit)
+ {
+ remove (part->filename);
}
- hpairnode_free_deep(part->header);
+ hpairnode_free_deep (part->header);
- free(part);
+ free (part);
}
-attachments_t *attachments_new() /* should be used internally */
+attachments_t *
+attachments_new () /* should be used internally */
{
- attachments_t *attachments= (attachments_t*)malloc(sizeof(attachments_t));
+ attachments_t *attachments =
+ (attachments_t *) malloc (sizeof (attachments_t));
attachments->parts = NULL;
attachments->last = NULL;
attachments->root_part = NULL;
@@ -804,41 +884,44 @@ attachments_t *attachments_new() /* should be used internally */
return attachments;
}
-void attachments_add_part(attachments_t *attachments, part_t *part)
+void
+attachments_add_part (attachments_t * attachments, part_t * part)
{
/* paranoya check */
- if (!attachments)
+ if (!attachments)
return;
- if (attachments->last)
+ if (attachments->last)
attachments->last->next = part;
else
attachments->parts = part;
-
+
attachments->last = part;
}
/*
Free a mime message
*/
-void attachments_free(attachments_t *message)
+void
+attachments_free (attachments_t * message)
{
part_t *tmp, *part;
- if (message == NULL)
+ if (message == NULL)
return;
part = message->parts;
- while (part) {
+ while (part)
+ {
tmp = part->next;
- part_free(part);
- part= tmp;
+ part_free (part);
+ part = tmp;
}
if (message->root_part)
- part_free(message->root_part);
+ part_free (message->root_part);
/* TODO (#1#): HERE IS A BUG!!!! */
- free(message);
+ free (message);
}
@@ -846,30 +929,31 @@ void attachments_free(attachments_t *message)
/* strtok_r() */
char *
-strtok_r(char *s, const char *delim, char **save_ptr)
+strtok_r (char *s, const char *delim, char **save_ptr)
{
- char *token;
+ char *token;
- if (s == NULL)
- s = *save_ptr;
+ if (s == NULL)
+ s = *save_ptr;
- /* Scan leading delimiters. */
- s += strspn(s, delim);
- if (*s == '\0')
- return NULL;
+ /* Scan leading delimiters. */
+ s += strspn (s, delim);
+ if (*s == '\0')
+ return NULL;
- /* Find the end of the token. */
- token = s;
- s = strpbrk(token, delim);
- if (s == NULL)
- /* This token finishes the string. */
- *save_ptr = strchr(token, '\0');
- else {
- /* Terminate the token and make *SAVE_PTR point past it. */
- *s = '\0';
- *save_ptr = s + 1;
- }
- return token;
+ /* Find the end of the token. */
+ token = s;
+ s = strpbrk (token, delim);
+ if (s == NULL)
+ /* This token finishes the string. */
+ *save_ptr = strchr (token, '\0');
+ else
+ {
+ /* Terminate the token and make *SAVE_PTR point past it. */
+ *s = '\0';
+ *save_ptr = s + 1;
+ }
+ return token;
}
/* localtime_r() */
@@ -887,4 +971,3 @@ localtime_r (const time_t * const timep, struct tm *p_tm)
}
#endif
-
diff --git a/nanohttp/nanohttp-common.h b/nanohttp/nanohttp-common.h
index f23d165..36136b5 100644
--- a/nanohttp/nanohttp-common.h
+++ b/nanohttp/nanohttp-common.h
@@ -1,5 +1,5 @@
/******************************************************************
- * $Id: nanohttp-common.h,v 1.20 2005/12/19 14:06:16 snowdrop Exp $
+ * $Id: nanohttp-common.h,v 1.21 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -21,8 +21,8 @@
*
* Email: ferhatayaz@yahoo.com
******************************************************************/
-#ifndef NANO_HTTP_COMMON_H
-#define NANO_HTTP_COMMON_H
+#ifndef NANO_HTTP_COMMON_H
+#define NANO_HTTP_COMMON_H
#include <stdlib.h>
#include <time.h>
@@ -85,7 +85,7 @@
/* TODO (#1#): find proper ports */
#define URL_DEFAULT_PORT_HTTP 80
#define URL_DEFAULT_PORT_HTTPS 81
-#define URL_DEFAULT_PORT_FTP 120
+#define URL_DEFAULT_PORT_FTP 120
/* Success flag */
#define H_OK 0
@@ -123,7 +123,7 @@
#define MIME_ERROR_NO_BOUNDARY_PARAM 1301
#define MIME_ERROR_NO_START_PARAM 1302
#define MIME_ERROR_PARSE_ERROR 1303
-#define MIME_ERROR_NO_ROOT_PART 1304
+#define MIME_ERROR_NO_ROOT_PART 1304
#define MIME_ERROR_NOT_MIME_MESSAGE 1305
@@ -145,19 +145,19 @@
Set Sleep function platform depended
*/
#ifdef WIN32
- #define system_sleep(seconds) Sleep(seconds*1000);
+#define system_sleep(seconds) Sleep(seconds*1000);
#else
- #define system_sleep(seconds) sleep(seconds);
+#define system_sleep(seconds) sleep(seconds);
#endif
#ifdef WIN32
#include <string.h>
-char* strtok_r(char *s, const char *delim, char **save_ptr);
-struct tm *localtime_r(const time_t *const timep, struct tm *p_tm);
+char *strtok_r (char *s, const char *delim, char **save_ptr);
+struct tm *localtime_r (const time_t * const timep, struct tm *p_tm);
#endif
typedef unsigned char byte_t;
-typedef void* herror_t;
+typedef void *herror_t;
@@ -165,35 +165,35 @@ typedef void* herror_t;
Indicates the version of the
used HTTP protocol.
*/
-typedef enum _http_version {
- HTTP_1_0,
- HTTP_1_1 /* default */
-}http_version_t;
+typedef enum _http_version
+{
+ HTTP_1_0,
+ HTTP_1_1 /* default */
+} http_version_t;
/**
Indicates the used method
*/
-typedef enum _hreq_method
+typedef enum _hreq_method
{
HTTP_REQUEST_POST,
HTTP_REQUEST_GET
-}hreq_method_t ;
+} hreq_method_t;
-herror_t herror_new(const char* func,
- int errcode, const char* format, ...);
-int herror_code(herror_t err);
-char* herror_func(herror_t err);
-char* herror_message(herror_t err);
-void herror_release(herror_t err);
+herror_t herror_new (const char *func, int errcode, const char *format, ...);
+int herror_code (herror_t err);
+char *herror_func (herror_t err);
+char *herror_message (herror_t err);
+void herror_release (herror_t err);
/*
string function to compare strings ignoring case
Returns 1 if s1 equals s2 and 0 otherwise.
*/
-int strcmpigcase(const char *s1, const char *s2);
+int strcmpigcase (const char *s1, const char *s2);
@@ -221,7 +221,7 @@ struct hpair
@returns A newly crated hpair_t object. Use hpair_free()
or hpair_free_deep() to free the pair.
*/
-hpair_t *hpairnode_new(const char* key, const char* value, hpair_t* next);
+hpair_t *hpairnode_new (const char *key, const char *value, hpair_t * next);
/**
@@ -239,7 +239,7 @@ hpair_t *hpairnode_new(const char* key, const char* value, hpair_t* next);
@returns A newly crated hpair_t object. Use hpair_free()
or hpair_free_deep() to free the pair.
*/
-hpair_t *hpairnode_parse(const char *str, const char *delim, hpair_t * next);
+hpair_t *hpairnode_parse (const char *str, const char *delim, hpair_t * next);
/**
@@ -247,7 +247,7 @@ hpair_t *hpairnode_parse(const char *str, const char *delim, hpair_t * next);
@param pair the pair to free
*/
-void hpairnode_free(hpair_t *pair);
+void hpairnode_free (hpair_t * pair);
/**
@@ -257,7 +257,7 @@ void hpairnode_free(hpair_t *pair);
@param pair the pair to start to free the linked list
*/
-void hpairnode_free_deep(hpair_t * pair);
+void hpairnode_free_deep (hpair_t * pair);
/**
@@ -270,7 +270,7 @@ void hpairnode_free_deep(hpair_t * pair);
return the value (do not free this string) or NULL
if no pair was found with the key 'key'.
*/
-char *hpairnode_get(hpair_t *pair, const char* key);
+char *hpairnode_get (hpair_t * pair, const char *key);
/**
@@ -284,7 +284,7 @@ char *hpairnode_get(hpair_t *pair, const char* key);
return the value (do not free this string) or NULL
if no pair was found with the key 'key'.
*/
-char *hpairnode_get_ignore_case(hpair_t *pair, const char* key);
+char *hpairnode_get_ignore_case (hpair_t * pair, const char *key);
/**
@@ -300,7 +300,7 @@ char *hpairnode_get_ignore_case(hpair_t *pair, const char* key);
@see hpairnode_copy_deep
*/
-hpair_t* hpairnode_copy(const hpair_t *src);
+hpair_t *hpairnode_copy (const hpair_t * src);
/**
@@ -312,11 +312,11 @@ hpair_t* hpairnode_copy(const hpair_t *src);
@see hpairnode_copy
*/
-hpair_t* hpairnode_copy_deep(const hpair_t *src);
+hpair_t *hpairnode_copy_deep (const hpair_t * src);
/* Debug functions */
-void hpairnode_dump_deep(hpair_t *pair);
-void hpairnode_dump(hpair_t *pair);
+void hpairnode_dump_deep (hpair_t * pair);
+void hpairnode_dump (hpair_t * pair);
/**
The protocol types in enumeration
@@ -330,7 +330,7 @@ typedef enum _hprotocol
PROTOCOL_HTTP,
PROTOCOL_HTTPS,
PROTOCOL_FTP
-}hprotocol_t;
+} hprotocol_t;
@@ -355,7 +355,7 @@ typedef struct _hurl
URL_HTTP_DEFAULT_PORT
URL_HTTPS_DEFAULT_PORT
URL_FTP_DEFAULT_PORT
- */
+ */
int port;
/** The hostname */
@@ -363,7 +363,7 @@ typedef struct _hurl
/** The string after the hostname. */
char context[URL_MAX_CONTEXT_SIZE];
-}hurl_t;
+} hurl_t;
/**
@@ -378,7 +378,7 @@ typedef struct _hurl
URL_ERROR_NO_PROTOCOL
URL_ERROR_NO_HOST
*/
-herror_t hurl_parse(hurl_t *obj, const char* url);
+herror_t hurl_parse (hurl_t * obj, const char *url);
/*
Object representation of the content-type field
@@ -392,7 +392,7 @@ typedef struct _content_type
{
char type[128];
hpair_t *params;
-}content_type_t;
+} content_type_t;
/**
@@ -407,13 +407,13 @@ typedef struct _content_type
@see content_type_free
*/
-content_type_t *content_type_new(const char* content_type_str);
+content_type_t *content_type_new (const char *content_type_str);
/**
Frees the given content_type_t object
*/
-void content_type_free(content_type_t *ct);
+void content_type_free (content_type_t * ct);
@@ -429,13 +429,14 @@ typedef struct _part
char transfer_encoding[128];
char filename[250];
struct _part *next;
- int deleteOnExit; /* default is 0 */
-}part_t;
+ int deleteOnExit; /* default is 0 */
+} part_t;
-part_t *part_new(const char *id, const char* filename,
- const char* content_type, const char* transfer_encoding, part_t *next);
-void part_free(part_t *part);
+part_t *part_new (const char *id, const char *filename,
+ const char *content_type, const char *transfer_encoding,
+ part_t * next);
+void part_free (part_t * part);
@@ -448,9 +449,9 @@ typedef struct _attachments
part_t *parts;
part_t *last;
part_t *root_part;
-}attachments_t;
+} attachments_t;
-attachments_t *attachments_new(); /* should be used internally */
+attachments_t *attachments_new (); /* should be used internally */
/*
Free a attachment. Create attachments with MIME
@@ -458,15 +459,15 @@ attachments_t *attachments_new(); /* should be used internally */
@see mime_get_attachments
*/
-void attachments_free(attachments_t *message);
-void attachments_add_part(attachments_t *attachments, part_t *part);
+void attachments_free (attachments_t * message);
+void attachments_add_part (attachments_t * attachments, part_t * part);
/* tmp directory for multipart/related stuff */
#define HOPTION_TMP_DIR 2
-void hoption_init_args(int argc, char* argv[]);
-void hoption_set(int opt, const char* value);
-char *hoption_get(int opt);
+void hoption_init_args (int argc, char *argv[]);
+void hoption_set (int opt, const char *value);
+char *hoption_get (int opt);
/* logging stuff */
typedef enum log_level
@@ -477,21 +478,21 @@ typedef enum log_level
HLOG_WARN,
HLOG_ERROR,
HLOG_FATAL
-}log_level_t;
+} log_level_t;
-log_level_t log_set_level(log_level_t level);
-log_level_t log_get_level();
+log_level_t log_set_level (log_level_t level);
+log_level_t log_get_level ();
-void log_set_file(const char *filename);
-char *log_get_file();
+void log_set_file (const char *filename);
+char *log_get_file ();
#ifdef WIN32
- #if defined(_MSC_VER) && _MSC_VER <= 1200
- char *VisualC_funcname(const char* file, int line); /* not thread safe!*/
- #define __FUNCTION__ VisualC_funcname(__FILE__, __LINE__)
- #endif
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+char *VisualC_funcname (const char *file, int line); /* not thread safe! */
+#define __FUNCTION__ VisualC_funcname(__FILE__, __LINE__)
+#endif
#endif
#define log_verbose1(a1) log_verbose(__FUNCTION__, a1)
@@ -524,18 +525,12 @@ char *log_get_file();
#define log_error4(a1,a2,a3,a4) log_error(__FUNCTION__, a1,a2,a3,a4)
#define log_error5(a1,a2,a3,a4,a5) log_error(__FUNCTION__, a1,a2,a3,a4,a5)
-void log_verbose(const char* FUNC, const char *format, ...);
-void log_debug(const char* FUNC, const char *format, ...);
-void log_info(const char* FUNC, const char *format, ...);
-void log_warn(const char* FUNC, const char *format, ...);
-void log_error(const char* FUNC, const char *format, ...);
+void log_verbose (const char *FUNC, const char *format, ...);
+void log_debug (const char *FUNC, const char *format, ...);
+void log_info (const char *FUNC, const char *format, ...);
+void log_warn (const char *FUNC, const char *format, ...);
+void log_error (const char *FUNC, const char *format, ...);
#endif
-
-
-
-
-
-
diff --git a/nanohttp/nanohttp-mime.c b/nanohttp/nanohttp-mime.c
index f4ff487..3f17d38 100755
--- a/nanohttp/nanohttp-mime.c
+++ b/nanohttp/nanohttp-mime.c
@@ -3,7 +3,7 @@
* | \/ | | | | \/ | | _/
* |_''_| |_| |_''_| |_'/ PARSER
*
-* $Id: nanohttp-mime.c,v 1.7 2005/05/27 19:28:15 snowdrop Exp $
+* $Id: nanohttp-mime.c,v 1.8 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -45,32 +45,32 @@ Buffered Reader. A helper object to read bytes from a source
/* ------------------------------------------------------------------
MIME Parser
------------------------------------------------------------------*/
-typedef void (*MIME_part_begin) (void*);
-typedef void (*MIME_part_end) (void*);
-typedef void (*MIME_parse_begin) (void*);
-typedef void (*MIME_parse_end) (void*);
-typedef void (*MIME_ERROR_bytes) (void*,
- const unsigned char*, int);
-
-typedef enum _MIME_parser_status
+typedef void (*MIME_part_begin) (void *);
+typedef void (*MIME_part_end) (void *);
+typedef void (*MIME_parse_begin) (void *);
+typedef void (*MIME_parse_end) (void *);
+typedef void (*MIME_ERROR_bytes) (void *, const unsigned char *, int);
+
+typedef enum _MIME_parser_status
{
MIME_PARSER_INCOMPLETE_MESSAGE,
MIME_PARSER_READ_ERROR,
MIME_PARSER_OK
-}MIME_parser_status;
+} MIME_parser_status;
typedef enum _MIME_read_status
{
MIME_READ_OK,
MIME_READ_EOF,
MIME_READ_ERROR
-}MIME_read_status;
+} MIME_read_status;
#define MIME_READER_MAX_BUFFER_SIZE 1054
#define MIME_PARSER_BUFFER_SIZE 1054
-typedef MIME_read_status (*MIME_read_function) (void*, unsigned char*, int*);
+typedef MIME_read_status (*MIME_read_function) (void *, unsigned char *,
+ int *);
/**
@@ -85,36 +85,35 @@ typedef struct _MIME_reader
MIME_read_function read_function;
char buffer[MIME_READER_MAX_BUFFER_SIZE];
void *userdata;
-}MIME_reader;
+} MIME_reader;
-MIME_read_status MIME_filereader_function(void* userdata,
- unsigned char* dest, int* size);
+MIME_read_status MIME_filereader_function (void *userdata,
+ unsigned char *dest, int *size);
typedef struct _MIME_callbacks
{
- MIME_part_begin part_begin_cb;
- MIME_part_end part_end_cb;
- MIME_parse_begin parse_begin_cb;
- MIME_parse_end parse_end_cb;
+ MIME_part_begin part_begin_cb;
+ MIME_part_end part_end_cb;
+ MIME_parse_begin parse_begin_cb;
+ MIME_parse_end parse_end_cb;
MIME_ERROR_bytes received_bytes_cb;
-}MIME_callbacks;
+} MIME_callbacks;
-MIME_parser_status MIME_parse(
- MIME_read_function reader_function,
- void *reader_userdata,
- const char* user_boundary,
- const MIME_callbacks* callbacks,
- void *callbacks_userdata
-);
+MIME_parser_status MIME_parse (MIME_read_function reader_function,
+ void *reader_userdata,
+ const char *user_boundary,
+ const MIME_callbacks * callbacks,
+ void *callbacks_userdata);
/**
Initialize a reader
*/
-void MIME_reader_init(MIME_reader *reader,
- MIME_read_function reader_function,void *userdata)
+void
+MIME_reader_init (MIME_reader * reader,
+ MIME_read_function reader_function, void *userdata)
{
reader->size = 0;
reader->marker = -1;
@@ -127,8 +126,8 @@ void MIME_reader_init(MIME_reader *reader,
/**
Read data from a reader source.
*/
-MIME_read_status MIME_reader_read(MIME_reader *reader,
- unsigned char *buffer, int size)
+MIME_read_status
+MIME_reader_read (MIME_reader * reader, unsigned char *buffer, int size)
{
MIME_read_status status;
int readed_size;
@@ -145,64 +144,66 @@ MIME_read_status MIME_reader_read(MIME_reader *reader,
{
if (reader->marker != 0)
{
- memcpy(tempBuffer, reader->buffer + reader->marker,
- reader->size - reader->marker);
- memcpy(reader->buffer, tempBuffer,
+ memcpy (tempBuffer, reader->buffer + reader->marker,
reader->size - reader->marker);
+ memcpy (reader->buffer, tempBuffer, reader->size - reader->marker);
reader->current = reader->size - reader->marker;
}
- else if (reader->current == MIME_READER_MAX_BUFFER_SIZE-1)
+ else if (reader->current == MIME_READER_MAX_BUFFER_SIZE - 1)
{
- fprintf(stderr, "Marker error");
- return MIME_READ_ERROR;
+ fprintf (stderr, "Marker error");
+ return MIME_READ_ERROR;
}
reader->marker = 0;
}
else
reader->current = 0;
-
- readed_size = MIME_READER_MAX_BUFFER_SIZE - reader->current -1;
- status = reader->read_function(reader->userdata,
- reader->buffer + reader->current, &readed_size);
+
+ readed_size = MIME_READER_MAX_BUFFER_SIZE - reader->current - 1;
+ status = reader->read_function (reader->userdata,
+ reader->buffer + reader->current,
+ &readed_size);
if (status == MIME_READ_OK)
{
reader->size = readed_size + reader->current;
- }
+ }
else
return status;
}
if (size <= reader->size - reader->current)
{
- memcpy(buffer, reader->buffer + reader->current, size);
+ memcpy (buffer, reader->buffer + reader->current, size);
reader->current += size;
return MIME_READ_OK;
- }
+ }
else
{
/* Fill rest data */
rest_size = reader->size - reader->current;
- memcpy(buffer, reader->buffer + reader->current, rest_size);
+ memcpy (buffer, reader->buffer + reader->current, rest_size);
reader->current = reader->size;
- return MIME_reader_read(reader, buffer + rest_size,
- size - rest_size);
+ return MIME_reader_read (reader, buffer + rest_size, size - rest_size);
}
}
-void MIME_reader_set_marker(MIME_reader *reader)
+void
+MIME_reader_set_marker (MIME_reader * reader)
{
reader->marker = reader->current;
}
-void MIME_reader_unset_marker(MIME_reader *reader)
+void
+MIME_reader_unset_marker (MIME_reader * reader)
{
reader->marker = -1;
}
-void MIME_reader_jump_marker(MIME_reader *reader)
+void
+MIME_reader_jump_marker (MIME_reader * reader)
{
reader->current = reader->marker;
}
@@ -213,85 +214,89 @@ typedef struct _MIME_buffer
{
unsigned char data[MIME_PARSER_BUFFER_SIZE];
int size;
-}MIME_buffer;
+} MIME_buffer;
-void MIME_buffer_init(MIME_buffer *buffer)
+void
+MIME_buffer_init (MIME_buffer * buffer)
{
buffer->size = 0;
}
-void MIME_buffer_add(MIME_buffer *buffer, unsigned char ch)
+void
+MIME_buffer_add (MIME_buffer * buffer, unsigned char ch)
{
buffer->data[buffer->size++] = ch;
}
-void MIME_buffer_add_bytes(MIME_buffer *buffer, unsigned char *bytes, int size)
+void
+MIME_buffer_add_bytes (MIME_buffer * buffer, unsigned char *bytes, int size)
{
- memcpy(buffer->data, bytes, size);
+ memcpy (buffer->data, bytes, size);
buffer->size += size;
}
-int MIME_buffer_is_full(MIME_buffer *buffer)
+int
+MIME_buffer_is_full (MIME_buffer * buffer)
{
return buffer->size + 150 >= MIME_PARSER_BUFFER_SIZE;
}
-int MIME_buffer_is_empty(MIME_buffer *buffer)
+int
+MIME_buffer_is_empty (MIME_buffer * buffer)
{
return buffer->size == 0;
}
-void MIME_buffer_clear(MIME_buffer *buffer)
+void
+MIME_buffer_clear (MIME_buffer * buffer)
{
buffer->size = 0;
}
-MIME_parser_status MIME_parse(
- MIME_read_function reader_function,
- void *reader_userdata,
- const char* user_boundary,
- const MIME_callbacks* callbacks,
- void *callbacks_userdata
-)
+MIME_parser_status
+MIME_parse (MIME_read_function reader_function,
+ void *reader_userdata,
+ const char *user_boundary,
+ const MIME_callbacks * callbacks, void *callbacks_userdata)
{
- char boundary[150];
+ char boundary[150];
unsigned char ch[153];
- int boundary_length, n, ignore = 0;
+ int boundary_length, n, ignore = 0;
MIME_reader reader;
MIME_buffer buffer;
MIME_read_status status;
/* Init reader */
- MIME_reader_init(&reader, reader_function, reader_userdata);
+ MIME_reader_init (&reader, reader_function, reader_userdata);
/* Init buffer */
- MIME_buffer_init(&buffer);
+ MIME_buffer_init (&buffer);
/* Set boundary related stuff */
- sprintf(boundary, "\n--%s", user_boundary);
- boundary_length = strlen(boundary);
+ sprintf (boundary, "\n--%s", user_boundary);
+ boundary_length = strlen (boundary);
/* Call parse begin callback */
- callbacks->parse_begin_cb(callbacks_userdata);
+ callbacks->parse_begin_cb (callbacks_userdata);
while (1)
{
-set_marker:
+ set_marker:
/* Set marker */
- MIME_reader_set_marker(&reader);
+ MIME_reader_set_marker (&reader);
-read_byte:
+ read_byte:
/* Read 1 byte */
- status = MIME_reader_read(&reader, ch, 1);
- _log_str("buffer.log", ch,1);
+ status = MIME_reader_read (&reader, ch, 1);
+ _log_str ("buffer.log", ch, 1);
if (status == MIME_READ_EOF)
- return MIME_PARSER_INCOMPLETE_MESSAGE;
+ return MIME_PARSER_INCOMPLETE_MESSAGE;
else if (status == MIME_READ_ERROR)
- return MIME_PARSER_READ_ERROR;
+ return MIME_PARSER_READ_ERROR;
if (ch[0] == '\r' && !ignore)
{
@@ -299,181 +304,181 @@ read_byte:
while (n < boundary_length)
{
/* Read 1 byte */
- status = MIME_reader_read(&reader, ch, 1);
- _log_str("buffer.log", ch,1);
+ status = MIME_reader_read (&reader, ch, 1);
+ _log_str ("buffer.log", ch, 1);
if (status == MIME_READ_EOF)
- return MIME_PARSER_INCOMPLETE_MESSAGE;
+ return MIME_PARSER_INCOMPLETE_MESSAGE;
else if (status == MIME_READ_ERROR)
- return MIME_PARSER_READ_ERROR;
-
- /* Check if byte is in boundary */
- if (ch[0] == boundary[n])
+ return MIME_PARSER_READ_ERROR;
+
+ /* Check if byte is in boundary */
+ if (ch[0] == boundary[n])
{
n = n + 1;
- continue;
+ continue;
}
else
{
- MIME_reader_jump_marker(&reader);
+ MIME_reader_jump_marker (&reader);
ignore = 1;
goto read_byte;
}
-
- } /* while n < boundary_length*/
+
+ } /* while n < boundary_length */
/* Read 1 byte */
- status = MIME_reader_read(&reader, ch, 1);
- _log_str("buffer.log", ch,1);
+ status = MIME_reader_read (&reader, ch, 1);
+ _log_str ("buffer.log", ch, 1);
if (status == MIME_READ_EOF)
- return MIME_PARSER_INCOMPLETE_MESSAGE;
+ return MIME_PARSER_INCOMPLETE_MESSAGE;
else if (status == MIME_READ_ERROR)
- return MIME_PARSER_READ_ERROR;
-
+ return MIME_PARSER_READ_ERROR;
+
/* Show if byte is '\r' */
if (ch[0] == '\r')
{
/* Read 1 byte */
- status = MIME_reader_read(&reader, ch, 1);
- _log_str("buffer.log", ch,1);
+ status = MIME_reader_read (&reader, ch, 1);
+ _log_str ("buffer.log", ch, 1);
if (status == MIME_READ_EOF)
- return MIME_PARSER_INCOMPLETE_MESSAGE;
+ return MIME_PARSER_INCOMPLETE_MESSAGE;
else if (status == MIME_READ_ERROR)
- return MIME_PARSER_READ_ERROR;
+ return MIME_PARSER_READ_ERROR;
- /* Check if byte is '\n' */
+ /* Check if byte is '\n' */
if (ch[0] == '\n')
{
- if (!MIME_buffer_is_empty(&buffer))
+ if (!MIME_buffer_is_empty (&buffer))
{
/* Invoke callback */
- callbacks->received_bytes_cb(
- callbacks_userdata, buffer.data, buffer.size);
+ callbacks->received_bytes_cb (callbacks_userdata, buffer.data,
+ buffer.size);
/* Empty the buffer */
- MIME_buffer_clear(&buffer);
-
+ MIME_buffer_clear (&buffer);
+
/* Invoke End Part */
- callbacks->part_end_cb(callbacks_userdata);
+ callbacks->part_end_cb (callbacks_userdata);
}
-
+
/* Invoke start new Part */
- callbacks->part_begin_cb(callbacks_userdata);
+ callbacks->part_begin_cb (callbacks_userdata);
goto set_marker;
- } /* if (ch[0] == '\n') */
+ } /* if (ch[0] == '\n') */
else
{
/* Jump to marker and read bytes */
- MIME_reader_jump_marker(&reader);
- MIME_reader_read(&reader, ch, boundary_length+2);
- _log_str("buffer.log", ch,1);
+ MIME_reader_jump_marker (&reader);
+ MIME_reader_read (&reader, ch, boundary_length + 2);
+ _log_str ("buffer.log", ch, 1);
- MIME_buffer_add_bytes(&buffer, ch, boundary_length+2);
-
- if (MIME_buffer_is_full(&buffer))
+ MIME_buffer_add_bytes (&buffer, ch, boundary_length + 2);
+
+ if (MIME_buffer_is_full (&buffer))
{
/* Invoke callback */
- callbacks->received_bytes_cb(
- callbacks_userdata, buffer.data, buffer.size);
-
+ callbacks->received_bytes_cb (callbacks_userdata, buffer.data,
+ buffer.size);
+
/* Empty the buffer */
- MIME_buffer_clear(&buffer);
+ MIME_buffer_clear (&buffer);
}
- } /* else of if (ch[0] == '\n') */
+ } /* else of if (ch[0] == '\n') */
- } /* if (ch[0] == '\r') */
+ } /* if (ch[0] == '\r') */
else
{
if (ch[0] == '-')
{
/* Read 1 byte */
- status = MIME_reader_read(&reader, ch, 1);
- _log_str("buffer.log", ch,1);
+ status = MIME_reader_read (&reader, ch, 1);
+ _log_str ("buffer.log", ch, 1);
if (status == MIME_READ_EOF)
- return MIME_PARSER_INCOMPLETE_MESSAGE;
+ return MIME_PARSER_INCOMPLETE_MESSAGE;
else if (status == MIME_READ_ERROR)
- return MIME_PARSER_READ_ERROR;
+ return MIME_PARSER_READ_ERROR;
if (ch[0] == '-')
{
- if (!MIME_buffer_is_empty(&buffer))
+ if (!MIME_buffer_is_empty (&buffer))
{
/* Invoke callback */
- callbacks->received_bytes_cb(
- callbacks_userdata, buffer.data, buffer.size);
-
+ callbacks->received_bytes_cb (callbacks_userdata, buffer.data,
+ buffer.size);
+
/* Empty the buffer */
- MIME_buffer_clear(&buffer);
+ MIME_buffer_clear (&buffer);
/* Invoke End Part */
- callbacks->part_end_cb(callbacks_userdata);
+ callbacks->part_end_cb (callbacks_userdata);
}
-
+
/* Invoke start new Part */
- callbacks->parse_end_cb(callbacks_userdata);
+ callbacks->parse_end_cb (callbacks_userdata);
+
+ /* Finish parsing */
+ /* TODO (#1#): We assume that after -- comes \r\n This is not
+ always correct */
- /* Finish parsing*/
- /* TODO (#1#): We assume that after -- comes \r\n
- This is not always correct */
-
return MIME_PARSER_OK;
- } /* if (ch[0] == '-') */
+ } /* if (ch[0] == '-') */
else
{
- MIME_reader_jump_marker(&reader);
+ MIME_reader_jump_marker (&reader);
ignore = 1;
goto read_byte;
- } /* else of if (ch[0] == '-') */
-
- } /* if (ch[0] == '-') */
+ } /* else of if (ch[0] == '-') */
+
+ } /* if (ch[0] == '-') */
else
{
- MIME_reader_jump_marker(&reader);
+ MIME_reader_jump_marker (&reader);
ignore = 1;
goto read_byte;
- } /* else of if (ch[0] == '-') */
+ } /* else of if (ch[0] == '-') */
- } /* else of if (ch[0] == '\r') */
+ } /* else of if (ch[0] == '\r') */
- } /* if ch[0] == '\r' && !ignore */
+ } /* if ch[0] == '\r' && !ignore */
else
{
ignore = 0;
- MIME_buffer_add(&buffer, ch[0]);
+ MIME_buffer_add (&buffer, ch[0]);
- /* Chec if buffer is full*/
- if (MIME_buffer_is_full(&buffer))
+ /* Chec if buffer is full */
+ if (MIME_buffer_is_full (&buffer))
{
/* Invoke callback */
- callbacks->received_bytes_cb(
- callbacks_userdata, buffer.data, buffer.size);
-
+ callbacks->received_bytes_cb (callbacks_userdata, buffer.data,
+ buffer.size);
+
/* Empty the buffer */
- MIME_buffer_clear(&buffer);
+ MIME_buffer_clear (&buffer);
}
- } /* else of if ch[0] == '\r' && !ignore */
- } /* while (1) */
+ } /* else of if ch[0] == '\r' && !ignore */
+ } /* while (1) */
}
-MIME_read_status MIME_filereader_function(void* userdata,
- unsigned char* dest, int* size)
+MIME_read_status
+MIME_filereader_function (void *userdata, unsigned char *dest, int *size)
{
- FILE *f = (FILE*)userdata;
+ FILE *f = (FILE *) userdata;
- if (feof(f))
+ if (feof (f))
return MIME_READ_EOF;
- *size = fread(dest, 1, *size, f);
+ *size = fread (dest, 1, *size, f);
return MIME_READ_OK;
}
@@ -487,44 +492,45 @@ MIME_read_status MIME_filereader_function(void* userdata,
*/
typedef struct _mime_callback_data
{
- int part_id;
+ int part_id;
attachments_t *message;
- part_t *current_part;
- int buffer_capacity;
- char header[4064];
- char root_id[256];
- int header_index;
- int header_search;
- FILE *current_fd;
- char root_dir[512];
-}mime_callback_data_t;
+ part_t *current_part;
+ int buffer_capacity;
+ char header[4064];
+ char root_id[256];
+ int header_index;
+ int header_search;
+ FILE *current_fd;
+ char root_dir[512];
+} mime_callback_data_t;
-MIME_read_status mime_streamreader_function(void* userdata,
- unsigned char* dest, int* size)
+MIME_read_status
+mime_streamreader_function (void *userdata, unsigned char *dest, int *size)
{
- int readed=0;
- http_input_stream_t *in = (http_input_stream_t*)userdata;
+ int readed = 0;
+ http_input_stream_t *in = (http_input_stream_t *) userdata;
- if (!http_input_stream_is_ready(in))
+ if (!http_input_stream_is_ready (in))
return MIME_READ_EOF;
- readed = http_input_stream_read(in, dest, *size);
- /*
- log_info1("http_input_stream_read() returned 0");
- */
- if (readed == -1) {
- log_error4("[%d] %s():%s ", herror_code(in->err), herror_func(in->err), herror_message(in->err));
+ readed = http_input_stream_read (in, dest, *size);
+ /*
+ log_info1("http_input_stream_read() returned 0"); */
+ if (readed == -1)
+ {
+ log_error4 ("[%d] %s():%s ", herror_code (in->err), herror_func (in->err),
+ herror_message (in->err));
}
*size = readed;
- if (*size!=-1) {
- /*
- _log_str("reader.log", dest, *size);
- */
- return MIME_READ_OK;
- }
+ if (*size != -1)
+ {
+ /*
+ _log_str("reader.log", dest, *size); */
+ return MIME_READ_OK;
+ }
return MIME_READ_ERROR;
}
@@ -532,35 +538,35 @@ MIME_read_status mime_streamreader_function(void* userdata,
/*
Start Callback functions
*/
-static
-void _mime_parse_begin(void *data)
+static void
+_mime_parse_begin (void *data)
{
/* Nothing to do
mime_callback_data_t *cbdata = (mime_callback_data_t)data;
*/
- log_verbose2("Begin parse (%p)", data);
+ log_verbose2 ("Begin parse (%p)", data);
}
-static
-void _mime_parse_end(void *data)
+static void
+_mime_parse_end (void *data)
{
/* Nothing to do
mime_callback_data_t *cbdata = (mime_callback_data_t)data;
*/
- log_verbose2("End parse (%p)", data);
+ log_verbose2 ("End parse (%p)", data);
}
-static
-void _mime_part_begin(void *data)
+static void
+_mime_part_begin (void *data)
{
char buffer[1054];
- mime_callback_data_t *cbdata = (mime_callback_data_t*)data;
+ mime_callback_data_t *cbdata = (mime_callback_data_t *) data;
part_t *part;
- log_verbose2("Begin Part (%p)", data);
- part = (part_t *)malloc(sizeof(part_t));
+ log_verbose2 ("Begin Part (%p)", data);
+ part = (part_t *) malloc (sizeof (part_t));
part->next = NULL;
@@ -577,40 +583,40 @@ void _mime_part_begin(void *data)
cbdata->header_search = 0;
#ifdef WIN32
- sprintf(buffer, "%s\\mime_%p_%d.part", cbdata->root_dir,
- cbdata, cbdata->part_id++);
+ sprintf (buffer, "%s\\mime_%p_%d.part", cbdata->root_dir,
+ cbdata, cbdata->part_id++);
#else
- sprintf(buffer, "%s/mime_%p_%d.part", cbdata->root_dir,
- cbdata, cbdata->part_id++);
+ sprintf (buffer, "%s/mime_%p_%d.part", cbdata->root_dir,
+ cbdata, cbdata->part_id++);
#endif
/* log_info2("Creating FILE ('%s') deleteOnExit=1", buffer);*/
part->deleteOnExit = 1;
- cbdata->current_fd = fopen(buffer, "wb");
+ cbdata->current_fd = fopen (buffer, "wb");
if (cbdata->current_fd)
- strcpy(cbdata->current_part->filename, buffer);
+ strcpy (cbdata->current_part->filename, buffer);
else
- log_error2("Can not open file for write '%s'", buffer);
+ log_error2 ("Can not open file for write '%s'", buffer);
}
-static
-void _mime_part_end(void *data)
+static void
+_mime_part_end (void *data)
{
- mime_callback_data_t *cbdata = (mime_callback_data_t*)data;
- log_verbose2("End Part (%p)", data);
+ mime_callback_data_t *cbdata = (mime_callback_data_t *) data;
+ log_verbose2 ("End Part (%p)", data);
if (cbdata->current_fd)
{
- fclose(cbdata->current_fd);
+ fclose (cbdata->current_fd);
cbdata->current_fd = NULL;
}
}
-static
-hpair_t *_mime_process_header(char *buffer)
+static hpair_t *
+_mime_process_header (char *buffer)
{
- int i=0, c=0, proc_key, begin=0;
+ int i = 0, c = 0, proc_key, begin = 0;
hpair_t *first = NULL, *last = NULL;
char key[1054], value[1054];
@@ -620,22 +626,22 @@ hpair_t *_mime_process_header(char *buffer)
while (buffer[i] != '\0')
{
- if (buffer[i] == '\r' && buffer[i+1] == '\n')
+ if (buffer[i] == '\r' && buffer[i + 1] == '\n')
{
value[c] = '\0';
if (last)
{
- last->next = hpairnode_new(key, value, NULL);
- last = last->next;
+ last->next = hpairnode_new (key, value, NULL);
+ last = last->next;
}
else
{
- first = last = hpairnode_new(key, value, NULL);
+ first = last = hpairnode_new (key, value, NULL);
}
proc_key = 1;
c = 0;
i++;
- }
+ }
else if (buffer[i] == ':')
{
key[c] = '\0';
@@ -643,7 +649,7 @@ hpair_t *_mime_process_header(char *buffer)
begin = 0;
proc_key = 0;
}
- else
+ else
{
if (proc_key)
key[c++] = buffer[i];
@@ -661,19 +667,23 @@ hpair_t *_mime_process_header(char *buffer)
}
-static
-void _mime_received_bytes(void *data, const unsigned char* bytes, int size)
+static void
+_mime_received_bytes (void *data, const unsigned char *bytes, int size)
{
- int i=0;
+ int i = 0;
char *id, *type, *location;
- mime_callback_data_t *cbdata = (mime_callback_data_t*)data;
+ mime_callback_data_t *cbdata = (mime_callback_data_t *) data;
- if (!cbdata ) {
- log_error1("MIME transport error Called <received bytes> without initializing\n");
+ if (!cbdata)
+ {
+ log_error1
+ ("MIME transport error Called <received bytes> without initializing\n");
return;
}
- if (!cbdata->current_part) {
- log_error1("MIME transport error Called <received bytes> without initializing\n");
+ if (!cbdata->current_part)
+ {
+ log_error1
+ ("MIME transport error Called <received bytes> without initializing\n");
return;
}
/* log_verbose4("Received %d bytes (%p), header_search = %d",
@@ -682,7 +692,7 @@ void _mime_received_bytes(void *data, const unsigned char* bytes, int size)
if (cbdata->header_search < 4)
{
/* Find \r\n\r\n in bytes */
- for (i=0;i<size;i++)
+ for (i = 0; i < size; i++)
{
if (cbdata->header_search == 0)
{
@@ -728,25 +738,30 @@ void _mime_received_bytes(void *data, const unsigned char* bytes, int size)
cbdata->header[cbdata->header_index++] = '\n';
cbdata->header[cbdata->header_index++] = '\0';
cbdata->header_search = 4;
- cbdata->current_part->header = _mime_process_header(cbdata->header);
- hpairnode_dump_deep(cbdata->current_part->header);
+ cbdata->current_part->header =
+ _mime_process_header (cbdata->header);
+ hpairnode_dump_deep (cbdata->current_part->header);
/* set id */
- id = hpairnode_get(cbdata->current_part->header, HEADER_CONTENT_ID);
+ id =
+ hpairnode_get (cbdata->current_part->header, HEADER_CONTENT_ID);
if (id != NULL)
{
- strcpy(cbdata->current_part->id, id);
- if (!strcmp(id, cbdata->root_id))
+ strcpy (cbdata->current_part->id, id);
+ if (!strcmp (id, cbdata->root_id))
cbdata->message->root_part = cbdata->current_part;
}
- location = hpairnode_get(cbdata->current_part->header, HEADER_CONTENT_LOCATION);
+ location =
+ hpairnode_get (cbdata->current_part->header,
+ HEADER_CONTENT_LOCATION);
if (location != NULL)
{
- strcpy(cbdata->current_part->location, location);
+ strcpy (cbdata->current_part->location, location);
}
- type = hpairnode_get(cbdata->current_part->header, HEADER_CONTENT_TYPE);
+ type =
+ hpairnode_get (cbdata->current_part->header, HEADER_CONTENT_TYPE);
if (type != NULL)
{
- strcpy(cbdata->current_part->content_type, type);
+ strcpy (cbdata->current_part->content_type, type);
}
i++;
break;
@@ -761,17 +776,17 @@ void _mime_received_bytes(void *data, const unsigned char* bytes, int size)
}
}
/* TODO (#1#): Check for cbdata->header overflow */
-
- } /* for (i=0;i<size;i++) */
- } /* if (cbdata->header_search < 4) */
- if (i >= size-1)
+ } /* for (i=0;i<size;i++) */
+ } /* if (cbdata->header_search < 4) */
+
+ if (i >= size - 1)
return;
- /* Write remaining bytes into the file or buffer (if root)
- (buffer is disabled in this version) */
+ /* Write remaining bytes into the file or buffer (if root) (buffer is
+ disabled in this version) */
if (cbdata->current_fd)
- fwrite(&(bytes[i]), 1, size - i, cbdata->current_fd);
+ fwrite (&(bytes[i]), 1, size - i, cbdata->current_fd);
}
@@ -780,25 +795,25 @@ void _mime_received_bytes(void *data, const unsigned char* bytes, int size)
*/
attachments_t *
-mime_message_parse(http_input_stream_t *in, const char* root_id,
- const char* boundary, const char* dest_dir)
+mime_message_parse (http_input_stream_t * in, const char *root_id,
+ const char *boundary, const char *dest_dir)
{
MIME_parser_status status;
MIME_callbacks callbacks;
- attachments_t* message;
+ attachments_t *message;
- mime_callback_data_t *cbdata = (mime_callback_data_t*)
- malloc(sizeof(mime_callback_data_t));
+ mime_callback_data_t *cbdata = (mime_callback_data_t *)
+ malloc (sizeof (mime_callback_data_t));
cbdata->part_id = 100;
cbdata->buffer_capacity = 0;
- cbdata-> current_fd = NULL;
+ cbdata->current_fd = NULL;
cbdata->current_part = NULL;
cbdata->header_index = 0;
cbdata->header_search = 0;
- strcpy(cbdata->root_id, root_id);
- strcpy(cbdata->root_dir, dest_dir);
- message = (attachments_t*)malloc(sizeof(attachments_t));
+ strcpy (cbdata->root_id, root_id);
+ strcpy (cbdata->root_dir, dest_dir);
+ message = (attachments_t *) malloc (sizeof (attachments_t));
cbdata->message = message;
cbdata->message->parts = NULL;
cbdata->message->root_part = NULL;
@@ -809,42 +824,43 @@ mime_message_parse(http_input_stream_t *in, const char* root_id,
callbacks.part_end_cb = _mime_part_end;
callbacks.received_bytes_cb = _mime_received_bytes;
- status = MIME_parse(mime_streamreader_function,
- in, boundary, &callbacks, cbdata);
+ status = MIME_parse (mime_streamreader_function,
+ in, boundary, &callbacks, cbdata);
if (status == MIME_PARSER_OK)
{
- free(cbdata);
+ free (cbdata);
return message;
}
else
{
- log_error2("MIME parser error '%s'!",
- status == MIME_PARSER_READ_ERROR ? "read error" : "Incomplete message");
+ log_error2 ("MIME parser error '%s'!",
+ status ==
+ MIME_PARSER_READ_ERROR ? "read error" : "Incomplete message");
return NULL;
}
}
attachments_t *
-mime_message_parse_from_file(FILE *in, const char* root_id,
- const char* boundary, const char* dest_dir)
+mime_message_parse_from_file (FILE * in, const char *root_id,
+ const char *boundary, const char *dest_dir)
{
MIME_parser_status status;
MIME_callbacks callbacks;
- attachments_t* message;
+ attachments_t *message;
- mime_callback_data_t *cbdata = (mime_callback_data_t*)
- malloc(sizeof(mime_callback_data_t));
+ mime_callback_data_t *cbdata = (mime_callback_data_t *)
+ malloc (sizeof (mime_callback_data_t));
cbdata->part_id = 100;
cbdata->buffer_capacity = 0;
- cbdata-> current_fd = NULL;
+ cbdata->current_fd = NULL;
cbdata->current_part = NULL;
cbdata->header_index = 0;
cbdata->header_search = 0;
- strcpy(cbdata->root_id, root_id);
- strcpy(cbdata->root_dir, dest_dir);
- message = (attachments_t*)malloc(sizeof(attachments_t));
+ strcpy (cbdata->root_id, root_id);
+ strcpy (cbdata->root_dir, dest_dir);
+ message = (attachments_t *) malloc (sizeof (attachments_t));
cbdata->message = message;
cbdata->message->parts = NULL;
cbdata->message->root_part = NULL;
@@ -855,77 +871,82 @@ mime_message_parse_from_file(FILE *in, const char* root_id,
callbacks.part_end_cb = _mime_part_end;
callbacks.received_bytes_cb = _mime_received_bytes;
- status = MIME_parse(MIME_filereader_function,
- in, boundary, &callbacks, cbdata);
+ status = MIME_parse (MIME_filereader_function,
+ in, boundary, &callbacks, cbdata);
if (status == MIME_PARSER_OK)
{
- free(cbdata);
+ free (cbdata);
return message;
}
else
{
/* TODO (#1#): Free objects */
- log_error2("MIME parser error '%s'!",
- status == MIME_PARSER_READ_ERROR ? "general error" : "Incomplete message");
+ log_error2 ("MIME parser error '%s'!",
+ status ==
+ MIME_PARSER_READ_ERROR ? "general error" :
+ "Incomplete message");
return NULL;
}
}
-herror_t mime_get_attachments(content_type_t *ctype, http_input_stream_t *in, attachments_t **dest)
+herror_t
+mime_get_attachments (content_type_t * ctype, http_input_stream_t * in,
+ attachments_t ** dest)
{
/* MIME variables */
- attachments_t *mimeMessage;
- part_t *part, *tmp_part=NULL;
- char *boundary, *root_id;
+ attachments_t *mimeMessage;
+ part_t *part, *tmp_part = NULL;
+ char *boundary, *root_id;
/* Check for MIME message */
- if (!(ctype &&
- !strcmp(ctype->type, "multipart/related")))
- return herror_new("mime_get_attachments", MIME_ERROR_NOT_MIME_MESSAGE,
- "Not a MIME message '%s'", ctype->type);
+ if (!(ctype && !strcmp (ctype->type, "multipart/related")))
+ return herror_new ("mime_get_attachments", MIME_ERROR_NOT_MIME_MESSAGE,
+ "Not a MIME message '%s'", ctype->type);
- boundary = hpairnode_get(ctype->params, "boundary");
- root_id = hpairnode_get(ctype->params, "start");
+ boundary = hpairnode_get (ctype->params, "boundary");
+ root_id = hpairnode_get (ctype->params, "start");
if (boundary == NULL)
{
- /* TODO (#1#): Handle Error in http form */
- log_error1("'boundary' not set for multipart/related");
- return herror_new("mime_get_attachments", MIME_ERROR_NO_BOUNDARY_PARAM,
- "'boundary' not set for multipart/related");
+ /* TODO (#1#): Handle Error in http form */
+ log_error1 ("'boundary' not set for multipart/related");
+ return herror_new ("mime_get_attachments", MIME_ERROR_NO_BOUNDARY_PARAM,
+ "'boundary' not set for multipart/related");
}
if (root_id == NULL)
{
- /* TODO (#1#): Handle Error in http form */
- log_error1("'start' not set for multipart/related");
- return herror_new("mime_get_attachments", MIME_ERROR_NO_START_PARAM,
- "'start' not set for multipart/related");
+ /* TODO (#1#): Handle Error in http form */
+ log_error1 ("'start' not set for multipart/related");
+ return herror_new ("mime_get_attachments", MIME_ERROR_NO_START_PARAM,
+ "'start' not set for multipart/related");
}
- mimeMessage = mime_message_parse(in, root_id, boundary, hoption_get(HOPTION_TMP_DIR));
+ mimeMessage =
+ mime_message_parse (in, root_id, boundary, hoption_get (HOPTION_TMP_DIR));
if (mimeMessage == NULL)
{
- /* TODO (#1#): Handle Error in http form */
- log_error1("MIME Parse Error");
- return herror_new("mime_get_attachments", MIME_ERROR_PARSE_ERROR,
- "MIME Parse Error");
+ /* TODO (#1#): Handle Error in http form */
+ log_error1 ("MIME Parse Error");
+ return herror_new ("mime_get_attachments", MIME_ERROR_PARSE_ERROR,
+ "MIME Parse Error");
}
/* Find root */
if (!mimeMessage->root_part)
{
- attachments_free(mimeMessage);
- return herror_new("mime_get_attachments", MIME_ERROR_NO_ROOT_PART,
- "No root part found!");
+ attachments_free (mimeMessage);
+ return herror_new ("mime_get_attachments", MIME_ERROR_NO_ROOT_PART,
+ "No root part found!");
}
/* delete root_part from list */
part = mimeMessage->parts;
- while (part) {
+ while (part)
+ {
if (part == mimeMessage->root_part)
{
if (tmp_part)
@@ -941,5 +962,3 @@ herror_t mime_get_attachments(content_type_t *ctype, http_input_stream_t *in, at
*dest = mimeMessage;
return H_OK;
}
-
-
diff --git a/nanohttp/nanohttp-mime.h b/nanohttp/nanohttp-mime.h
index be2abfa..6b160ab 100755
--- a/nanohttp/nanohttp-mime.h
+++ b/nanohttp/nanohttp-mime.h
@@ -3,7 +3,7 @@
* | \/ | | | | \/ | | _/
* |_''_| |_| |_''_| |_'/ PARSER
*
-* $Id: nanohttp-mime.h,v 1.4 2004/11/02 23:09:26 snowdrop Exp $
+* $Id: nanohttp-mime.h,v 1.5 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -40,20 +40,9 @@
-herror_t mime_get_attachments(content_type_t *ctype,
- http_input_stream_t *in, attachments_t **dest);
+herror_t mime_get_attachments (content_type_t * ctype,
+ http_input_stream_t * in,
+ attachments_t ** dest);
#endif
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/nanohttp/nanohttp-request.c b/nanohttp/nanohttp-request.c
index 9f4fb8b..5f15e93 100755
--- a/nanohttp/nanohttp-request.c
+++ b/nanohttp/nanohttp-request.c
@@ -1,5 +1,5 @@
/******************************************************************
-* $Id: nanohttp-request.c,v 1.6 2005/12/19 14:06:16 snowdrop Exp $
+* $Id: nanohttp-request.c,v 1.7 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -34,253 +34,260 @@
/* request stuff */
-static
-hrequest_t *hrequest_new()
+static hrequest_t *
+hrequest_new ()
{
- hrequest_t * req = (hrequest_t *) malloc(sizeof(hrequest_t));
+ hrequest_t *req = (hrequest_t *) malloc (sizeof (hrequest_t));
- req->method = HTTP_REQUEST_GET;
- req->version = HTTP_1_1;
- req->query = NULL;
- req->header = NULL;
- req->in = NULL;
- req->attachments = NULL;
- req->content_type = NULL;
+ req->method = HTTP_REQUEST_GET;
+ req->version = HTTP_1_1;
+ req->query = NULL;
+ req->header = NULL;
+ req->in = NULL;
+ req->attachments = NULL;
+ req->content_type = NULL;
- return req;
+ return req;
}
-static
-hrequest_t *
-_hrequest_parse_header(char *data)
+static hrequest_t *
+_hrequest_parse_header (char *data)
{
- hrequest_t *req;
- hpair_t *hpair = NULL, *qpair = NULL, *tmppair = NULL;
-
- char *tmp;
- char *tmp2;
- char *saveptr;
- char *saveptr2;
- char *saveptr3;
- char *result;
- char *key;
- char *opt_key;
- char *opt_value;
- int firstline = 1;
-
- req = hrequest_new();
- tmp = data;
-
- for (;;) {
- result = (char *) strtok_r(tmp, "\r\n", &saveptr);
- tmp = saveptr;
-
- if (result == NULL)
- break;
-
- if (firstline) {
- firstline = 0;
- tmp2 = result;
-
- /* parse [GET|POST] [PATH] [SPEC] */
- key = (char *) strtok_r(tmp2, " ", &saveptr2);
-
- /* save method (get or post) */
- tmp2 = saveptr2;
- if (key != NULL) {
- if (!strcmp(key, "POST"))
- req->method = HTTP_REQUEST_POST;
- else
- req->method = HTTP_REQUEST_GET;
- }
- /* below is key the path and tmp2 the spec */
- key = (char *) strtok_r(tmp2, " ", &saveptr2);
-
- /* save version */
- tmp2 = saveptr2;
- if (tmp2 != NULL) {
- /*req->spec = (char *) malloc(strlen(tmp2) + 1);
- strcpy(req->spec, tmp2);
- */
- if (!strcmp(tmp2, "HTTP/1.0"))
- req-> version = HTTP_1_0;
- else
- req-> version = HTTP_1_1;
- }
- /*
- * parse and save path+query parse:
- * /path/of/target?key1=value1&key2=value2...
- */
-
- if (key != NULL) {
- tmp2 = key;
- key = (char *) strtok_r(tmp2, "?", &saveptr2);
- tmp2 = saveptr2;
-
- /* save path */
- /*req->path = (char *) malloc(strlen(key) + 1);*/
- strncpy(req->path, key, REQUEST_MAX_PATH_SIZE);
-
- /* parse options */
- for (;;) {
- key = (char *) strtok_r(tmp2, "&", &saveptr2);
- tmp2 = saveptr2;
-
- if (key == NULL)
- break;
-
- opt_key = (char *) strtok_r(key, "=", &saveptr3);
- opt_value = saveptr3;
-
- if (opt_value == NULL)
- opt_value = "";
-
- /* create option pair */
- if (opt_key != NULL) {
- tmppair = (hpair_t *) malloc(sizeof(hpair_t));
-
- if (req->query == NULL) {
- req->query = qpair = tmppair;
- } else {
- qpair->next = tmppair;
- qpair = tmppair;
- }
-
- /* fill hpairnode_t struct */
- qpair->next = NULL;
- qpair->key = (char *) malloc(strlen(opt_key) + 1);
- qpair->value = (char *) malloc(strlen(opt_value) + 1);
-
- strcpy(qpair->key, opt_key);
- strcpy(qpair->value, opt_value);
-
- }
- }
- }
- } else {
-
- /* parse "key: value" */
- /* tmp2 = result;
- key = (char *) strtok_r(tmp2, ": ", &saveptr2);
- value = saveptr2;*/
-
- /* create pair */
+ hrequest_t *req;
+ hpair_t *hpair = NULL, *qpair = NULL, *tmppair = NULL;
+
+ char *tmp;
+ char *tmp2;
+ char *saveptr;
+ char *saveptr2;
+ char *saveptr3;
+ char *result;
+ char *key;
+ char *opt_key;
+ char *opt_value;
+ int firstline = 1;
+
+ req = hrequest_new ();
+ tmp = data;
+
+ for (;;)
+ {
+ result = (char *) strtok_r (tmp, "\r\n", &saveptr);
+ tmp = saveptr;
+
+ if (result == NULL)
+ break;
+
+ if (firstline)
+ {
+ firstline = 0;
+ tmp2 = result;
+
+ /* parse [GET|POST] [PATH] [SPEC] */
+ key = (char *) strtok_r (tmp2, " ", &saveptr2);
+
+ /* save method (get or post) */
+ tmp2 = saveptr2;
+ if (key != NULL)
+ {
+ if (!strcmp (key, "POST"))
+ req->method = HTTP_REQUEST_POST;
+ else
+ req->method = HTTP_REQUEST_GET;
+ }
+ /* below is key the path and tmp2 the spec */
+ key = (char *) strtok_r (tmp2, " ", &saveptr2);
+
+ /* save version */
+ tmp2 = saveptr2;
+ if (tmp2 != NULL)
+ {
+ /* req->spec = (char *) malloc(strlen(tmp2) + 1); strcpy(req->spec,
+ tmp2); */
+ if (!strcmp (tmp2, "HTTP/1.0"))
+ req->version = HTTP_1_0;
+ else
+ req->version = HTTP_1_1;
+ }
+ /*
+ * parse and save path+query parse:
+ * /path/of/target?key1=value1&key2=value2...
+ */
+
+ if (key != NULL)
+ {
+ tmp2 = key;
+ key = (char *) strtok_r (tmp2, "?", &saveptr2);
+ tmp2 = saveptr2;
+
+ /* save path */
+ /* req->path = (char *) malloc(strlen(key) + 1); */
+ strncpy (req->path, key, REQUEST_MAX_PATH_SIZE);
+
+ /* parse options */
+ for (;;)
+ {
+ key = (char *) strtok_r (tmp2, "&", &saveptr2);
+ tmp2 = saveptr2;
+
+ if (key == NULL)
+ break;
+
+ opt_key = (char *) strtok_r (key, "=", &saveptr3);
+ opt_value = saveptr3;
+
+ if (opt_value == NULL)
+ opt_value = "";
+
+ /* create option pair */
+ if (opt_key != NULL)
+ {
+ tmppair = (hpair_t *) malloc (sizeof (hpair_t));
+
+ if (req->query == NULL)
+ {
+ req->query = qpair = tmppair;
+ }
+ else
+ {
+ qpair->next = tmppair;
+ qpair = tmppair;
+ }
+
+ /* fill hpairnode_t struct */
+ qpair->next = NULL;
+ qpair->key = (char *) malloc (strlen (opt_key) + 1);
+ qpair->value = (char *) malloc (strlen (opt_value) + 1);
+
+ strcpy (qpair->key, opt_key);
+ strcpy (qpair->value, opt_value);
+
+ }
+ }
+ }
+ }
+ else
+ {
+
+ /* parse "key: value" */
+ /* tmp2 = result; key = (char *) strtok_r(tmp2, ": ", &saveptr2); value
+ = saveptr2; */
+
+ /* create pair */
/* tmppair = (hpair_t *) malloc(sizeof(hpair_t));*/
- tmppair = hpairnode_parse(result, ":", NULL);
-
- if (req->header == NULL) {
- req->header = hpair = tmppair;
- } else {
- hpair->next = tmppair;
- hpair = tmppair;
- }
-
- /* fill pairnode_t struct */
- /*
- hpair->next = NULL;
- hpair->key = (char *) malloc(strlen(key) + 1);
- hpair->value = (char *) malloc(strlen(value) + 1);
-
- strcpy(hpair->key, key);
- strcpy(hpair->value, value);
- */
- }
- }
-
+ tmppair = hpairnode_parse (result, ":", NULL);
+
+ if (req->header == NULL)
+ {
+ req->header = hpair = tmppair;
+ }
+ else
+ {
+ hpair->next = tmppair;
+ hpair = tmppair;
+ }
+
+ /* fill pairnode_t struct */
+ /*
+ hpair->next = NULL; hpair->key = (char *) malloc(strlen(key) + 1);
+ hpair->value = (char *) malloc(strlen(value) + 1);
+
+ strcpy(hpair->key, key); strcpy(hpair->value, value); */
+ }
+ }
+
/* Check Content-type */
- tmp = hpairnode_get(req->header, HEADER_CONTENT_TYPE);
+ tmp = hpairnode_get (req->header, HEADER_CONTENT_TYPE);
if (tmp != NULL)
- req->content_type = content_type_new(tmp);
+ req->content_type = content_type_new (tmp);
- return req;
+ return req;
}
-void
-hrequest_free(hrequest_t * req)
+void
+hrequest_free (hrequest_t * req)
{
- if (req == NULL)
- return;
+ if (req == NULL)
+ return;
- hpairnode_free_deep(req->header);
- hpairnode_free_deep(req->query);
+ hpairnode_free_deep (req->header);
+ hpairnode_free_deep (req->query);
- if (req->in)
- http_input_stream_free(req->in);
+ if (req->in)
+ http_input_stream_free (req->in);
if (req->content_type)
- content_type_free(req->content_type);
+ content_type_free (req->content_type);
if (req->attachments)
- attachments_free(req->attachments);
+ attachments_free (req->attachments);
- free(req);
+ free (req);
}
herror_t
-hrequest_new_from_socket(hsocket_t sock, hrequest_t **out)
+hrequest_new_from_socket (hsocket_t sock, hrequest_t ** out)
{
- int i=0, readed;
- herror_t status;
- hrequest_t *req;
- char buffer[MAX_HEADER_SIZE+1];
- attachments_t *mimeMessage;
+ int i = 0, readed;
+ herror_t status;
+ hrequest_t *req;
+ char buffer[MAX_HEADER_SIZE + 1];
+ attachments_t *mimeMessage;
- memset(buffer, 0, MAX_HEADER_SIZE);
+ memset (buffer, 0, MAX_HEADER_SIZE);
/* Read header */
- while (i<MAX_HEADER_SIZE)
+ while (i < MAX_HEADER_SIZE)
{
- status = hsocket_read(sock, &(buffer[i]), 1, 1, &readed);
+ status = hsocket_read (sock, &(buffer[i]), 1, 1, &readed);
if (status != H_OK)
{
- if(herror_code(status) != HSOCKET_SSL_CLOSE){
- log_error1("Socket read error");
- }
- return status;
+ if (herror_code (status) != HSOCKET_SSL_CLOSE)
+ {
+ log_error1 ("Socket read error");
+ }
+ return status;
}
- buffer[i+1] = '\0'; /* for strmp */
+ buffer[i + 1] = '\0'; /* for strmp */
if (i > 3)
{
- if (!strcmp(&(buffer[i-1]), "\n\n") ||
- !strcmp(&(buffer[i-2]), "\n\r\n"))
- break;
+ if (!strcmp (&(buffer[i - 1]), "\n\n") ||
+ !strcmp (&(buffer[i - 2]), "\n\r\n"))
+ break;
}
i++;
}
/* Create response */
- req = _hrequest_parse_header(buffer);
+ req = _hrequest_parse_header (buffer);
/* Create input stream */
- req->in = http_input_stream_new(sock, req->header);
+ req->in = http_input_stream_new (sock, req->header);
/* Check for MIME message */
- if ((req->content_type &&
- !strcmp(req->content_type->type, "multipart/related")))
+ if ((req->content_type &&
+ !strcmp (req->content_type->type, "multipart/related")))
{
- status = mime_get_attachments(req->content_type, req->in, &mimeMessage);
+ status = mime_get_attachments (req->content_type, req->in, &mimeMessage);
if (status != H_OK)
{
/* TODO (#1#): Handle error */
- hrequest_free(req);
- return status;
+ hrequest_free (req);
+ return status;
}
else
{
req->attachments = mimeMessage;
- req->in = http_input_stream_new_from_file(mimeMessage->root_part->filename);
+ req->in =
+ http_input_stream_new_from_file (mimeMessage->root_part->filename);
}
}
-
+
*out = req;
return H_OK;
}
-
-
-
-
diff --git a/nanohttp/nanohttp-request.h b/nanohttp/nanohttp-request.h
index 8989247..e7b7b3e 100755
--- a/nanohttp/nanohttp-request.h
+++ b/nanohttp/nanohttp-request.h
@@ -1,5 +1,5 @@
/******************************************************************
- * $Id: nanohttp-request.h,v 1.2 2004/10/28 10:30:46 snowdrop Exp $
+ * $Id: nanohttp-request.h,v 1.3 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -21,8 +21,8 @@
*
* Email: ferhatayaz@yahoo.com
******************************************************************/
-#ifndef NANO_HTTP_REQUEST_H
-#define NANO_HTTP_REQUEST_H
+#ifndef NANO_HTTP_REQUEST_H
+#define NANO_HTTP_REQUEST_H
#include <nanohttp/nanohttp-stream.h>
#include <nanohttp/nanohttp-mime.h>
@@ -43,15 +43,9 @@ typedef struct hrequest
content_type_t *content_type;
attachments_t *attachments;
char root_part_id[150];
-}hrequest_t;
+} hrequest_t;
-herror_t hrequest_new_from_socket(hsocket_t sock, hrequest_t **out);
-void hrequest_free(hrequest_t *req);
+herror_t hrequest_new_from_socket (hsocket_t sock, hrequest_t ** out);
+void hrequest_free (hrequest_t * req);
#endif
-
-
-
-
-
-
diff --git a/nanohttp/nanohttp-response.c b/nanohttp/nanohttp-response.c
index 1447345..ee9e762 100755
--- a/nanohttp/nanohttp-response.c
+++ b/nanohttp/nanohttp-response.c
@@ -1,5 +1,5 @@
/******************************************************************
-* $Id: nanohttp-response.c,v 1.5 2005/05/27 19:28:15 snowdrop Exp $
+* $Id: nanohttp-response.c,v 1.6 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -31,196 +31,205 @@
#include <utils/alloc.h>
#endif
-static
-hresponse_t*
-hresponse_new()
+static hresponse_t *
+hresponse_new ()
{
- hresponse_t *res;
-
- /* create response object */
- res = (hresponse_t *) malloc(sizeof(hresponse_t));
- res->version = HTTP_1_1;
- res->errcode = -1;
- res->desc[0] = '\0';
- res->header = NULL;
- res->in = NULL;
- res->content_type = NULL;
- res->attachments = NULL;
- return res;
+ hresponse_t *res;
+
+ /* create response object */
+ res = (hresponse_t *) malloc (sizeof (hresponse_t));
+ res->version = HTTP_1_1;
+ res->errcode = -1;
+ res->desc[0] = '\0';
+ res->header = NULL;
+ res->in = NULL;
+ res->content_type = NULL;
+ res->attachments = NULL;
+ return res;
}
-static
-hresponse_t*
-_hresponse_parse_header(const char *buffer)
+static hresponse_t *
+_hresponse_parse_header (const char *buffer)
{
- hresponse_t *res;
- char *s1, *s2, *str;
-
- /* create response object */
- res = hresponse_new();
-
- /* *** parse spec *** */
- /* [HTTP/1.1 | 1.2] [CODE] [DESC] */
-
- /* stage 1: HTTP spec */
- str = (char *) strtok_r((char *) buffer, " ", &s2);
- s1 = s2;
- if (str == NULL) {
- log_error1("Parse error reading HTTP spec");
- return NULL;
- }
-
- if (!strcmp(str, "HTTP/1.0"))
- res->version = HTTP_1_0;
- else
- res->version = HTTP_1_1;
-
- /* stage 2: http code */
- str = (char *) strtok_r(s1, " ", &s2);
- s1 = s2;
- if (str == NULL) {
- log_error1("Parse error reading HTTP code");
- return NULL;
- }
- res->errcode = atoi(str);
-
- /* stage 3: description text */
- str = (char *) strtok_r(s1, "\r\n", &s2);
- s1 = s2;
- if (str == NULL) {
- log_error1("Parse error reading HTTP description");
- return NULL;
- }
+ hresponse_t *res;
+ char *s1, *s2, *str;
+
+ /* create response object */
+ res = hresponse_new ();
+
+ /* *** parse spec *** */
+ /* [HTTP/1.1 | 1.2] [CODE] [DESC] */
+
+ /* stage 1: HTTP spec */
+ str = (char *) strtok_r ((char *) buffer, " ", &s2);
+ s1 = s2;
+ if (str == NULL)
+ {
+ log_error1 ("Parse error reading HTTP spec");
+ return NULL;
+ }
+
+ if (!strcmp (str, "HTTP/1.0"))
+ res->version = HTTP_1_0;
+ else
+ res->version = HTTP_1_1;
+
+ /* stage 2: http code */
+ str = (char *) strtok_r (s1, " ", &s2);
+ s1 = s2;
+ if (str == NULL)
+ {
+ log_error1 ("Parse error reading HTTP code");
+ return NULL;
+ }
+ res->errcode = atoi (str);
+
+ /* stage 3: description text */
+ str = (char *) strtok_r (s1, "\r\n", &s2);
+ s1 = s2;
+ if (str == NULL)
+ {
+ log_error1 ("Parse error reading HTTP description");
+ return NULL;
+ }
/* res->desc = (char *) malloc(strlen(str) + 1);*/
- strncpy(res->desc, str, RESPONSE_MAX_DESC_SIZE);
- res->desc[strlen(str)] = '\0';
-
- /* *** parse header *** */
- /* [key]: [value] */
- for (;;) {
- str = strtok_r(s1, "\n", &s2);
- s1 = s2;
-
- /* check if header ends without body */
- if (str == NULL) {
- return res;
- }
- /* check also for end of header */
- if (!strcmp(str, "\r")) {
- break;
- }
- str[strlen(str) - 1] = '\0';
- res->header = hpairnode_parse(str, ":", res->header);
- }
+ strncpy (res->desc, str, RESPONSE_MAX_DESC_SIZE);
+ res->desc[strlen (str)] = '\0';
+
+ /* *** parse header *** */
+ /* [key]: [value] */
+ for (;;)
+ {
+ str = strtok_r (s1, "\n", &s2);
+ s1 = s2;
+
+ /* check if header ends without body */
+ if (str == NULL)
+ {
+ return res;
+ }
+ /* check also for end of header */
+ if (!strcmp (str, "\r"))
+ {
+ break;
+ }
+ str[strlen (str) - 1] = '\0';
+ res->header = hpairnode_parse (str, ":", res->header);
+ }
/* Check Content-type */
- str = hpairnode_get(res->header, HEADER_CONTENT_TYPE);
+ str = hpairnode_get (res->header, HEADER_CONTENT_TYPE);
if (str != NULL)
- res->content_type = content_type_new(str);
+ res->content_type = content_type_new (str);
- /* return response object */
- return res;
+ /* return response object */
+ return res;
}
herror_t
-hresponse_new_from_socket(hsocket_t sock, hresponse_t **out)
+hresponse_new_from_socket (hsocket_t sock, hresponse_t ** out)
{
- int i=0, readed;
- herror_t status;
- hresponse_t *res;
- attachments_t *mimeMessage;
- char buffer[MAX_HEADER_SIZE+1];
+ int i = 0, readed;
+ herror_t status;
+ hresponse_t *res;
+ attachments_t *mimeMessage;
+ char buffer[MAX_HEADER_SIZE + 1];
-read_header: /* for errorcode: 100 (continue) */
+read_header: /* for errorcode: 100 (continue) */
/* Read header */
- while (i<MAX_HEADER_SIZE)
+ while (i < MAX_HEADER_SIZE)
{
- status = hsocket_read(sock, &(buffer[i]), 1, 1, &readed);
+ status = hsocket_read (sock, &(buffer[i]), 1, 1, &readed);
if (status != H_OK)
{
- log_error1("Socket read error");
- return status;
+ log_error1 ("Socket read error");
+ return status;
}
- buffer[i+1] = '\0'; /* for strmp */
+ buffer[i + 1] = '\0'; /* for strmp */
if (i > 3)
{
- if (!strcmp(&(buffer[i-1]), "\n\n") ||
- !strcmp(&(buffer[i-2]), "\n\r\n"))
- break;
+ if (!strcmp (&(buffer[i - 1]), "\n\n") ||
+ !strcmp (&(buffer[i - 2]), "\n\r\n"))
+ break;
}
i++;
}
/* Create response */
- res = _hresponse_parse_header(buffer);
+ res = _hresponse_parse_header (buffer);
if (res == NULL)
{
- log_error1("Header parse error");
- return herror_new("hresponse_new_from_socket",
- GENERAL_HEADER_PARSE_ERROR, "Can not parse response header");
+ log_error1 ("Header parse error");
+ return herror_new ("hresponse_new_from_socket",
+ GENERAL_HEADER_PARSE_ERROR,
+ "Can not parse response header");
}
/* Chec for Errorcode: 100 (continue) */
- if (res->errcode == 100) {
- hresponse_free(res);
- i=0;
+ if (res->errcode == 100)
+ {
+ hresponse_free (res);
+ i = 0;
goto read_header;
}
/* Create input stream */
- res->in = http_input_stream_new(sock, res->header);
+ res->in = http_input_stream_new (sock, res->header);
/* Check for MIME message */
- if ((res->content_type &&
- !strcmp(res->content_type->type, "multipart/related")))
+ if ((res->content_type &&
+ !strcmp (res->content_type->type, "multipart/related")))
{
- status = mime_get_attachments(res->content_type, res->in, &mimeMessage);
+ status = mime_get_attachments (res->content_type, res->in, &mimeMessage);
if (status != H_OK)
{
/* TODO (#1#): Handle error */
- hresponse_free(res);
- return status;
+ hresponse_free (res);
+ return status;
}
else
{
res->attachments = mimeMessage;
- http_input_stream_free(res->in);
- res->in = http_input_stream_new_from_file(mimeMessage->root_part->filename);
- if (!res->in) {
- /* TODO (#1#): Handle error */
-
- } else {
- /*res->in->deleteOnExit = 1;*/
- }
+ http_input_stream_free (res->in);
+ res->in =
+ http_input_stream_new_from_file (mimeMessage->root_part->filename);
+ if (!res->in)
+ {
+ /* TODO (#1#): Handle error */
+
+ }
+ else
+ {
+ /* res->in->deleteOnExit = 1; */
+ }
}
}
- *out = res;
+ *out = res;
return H_OK;
}
-
-void
-hresponse_free(hresponse_t * res)
+
+void
+hresponse_free (hresponse_t * res)
{
- if (res == NULL)
- return;
+ if (res == NULL)
+ return;
if (res->header)
- hpairnode_free_deep(res->header);
+ hpairnode_free_deep (res->header);
if (res->in)
- http_input_stream_free(res->in);
+ http_input_stream_free (res->in);
if (res->content_type)
- content_type_free(res->content_type);
+ content_type_free (res->content_type);
if (res->attachments)
- attachments_free(res->attachments);
- free(res);
+ attachments_free (res->attachments);
+ free (res);
}
-
diff --git a/nanohttp/nanohttp-response.h b/nanohttp/nanohttp-response.h
index 63dd463..70e5348 100755
--- a/nanohttp/nanohttp-response.h
+++ b/nanohttp/nanohttp-response.h
@@ -1,5 +1,5 @@
/******************************************************************
- * $Id: nanohttp-response.h,v 1.2 2004/10/28 10:30:46 snowdrop Exp $
+ * $Id: nanohttp-response.h,v 1.3 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -21,8 +21,8 @@
*
* Email: ferhatayaz@yahoo.com
******************************************************************/
-#ifndef NANO_HTTP_RESPONSE_H
-#define NANO_HTTP_RESPONSE_H
+#ifndef NANO_HTTP_RESPONSE_H
+#define NANO_HTTP_RESPONSE_H
#include <nanohttp/nanohttp-stream.h>
#include <nanohttp/nanohttp-common.h>
@@ -41,17 +41,11 @@ typedef struct hresponse
content_type_t *content_type;
attachments_t *attachments;
char root_part_id[150];
-}hresponse_t;
+} hresponse_t;
-herror_t hresponse_new_from_socket(hsocket_t sock, hresponse_t **out);
-void hresponse_free(hresponse_t *res);
+herror_t hresponse_new_from_socket (hsocket_t sock, hresponse_t ** out);
+void hresponse_free (hresponse_t * res);
#endif
-
-
-
-
-
-
diff --git a/nanohttp/nanohttp-server.c b/nanohttp/nanohttp-server.c
index 0ff7d08..102c62a 100644
--- a/nanohttp/nanohttp-server.c
+++ b/nanohttp/nanohttp-server.c
@@ -1,5 +1,5 @@
/******************************************************************
-* $Id: nanohttp-server.c,v 1.37 2006/01/06 15:16:03 mrcsys Exp $
+* $Id: nanohttp-server.c,v 1.38 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -51,7 +51,7 @@
#else
-#include <process.h>
+#include <process.h>
#endif
@@ -62,15 +62,15 @@
typedef struct _conndata
{
- hsocket_t sock;
+ hsocket_t sock;
#ifdef WIN32
- HANDLE tid;
+ HANDLE tid;
#else
- pthread_t tid;
- pthread_attr_t attr;
+ pthread_t tid;
+ pthread_attr_t attr;
#endif
- time_t atime;
-}conndata_t;
+ time_t atime;
+} conndata_t;
/*
* -----------------------------------------------------
@@ -96,13 +96,13 @@ static conndata_t *_httpd_connection;
#ifdef WIN32
-static void WSAReaper(void *x);
+static void WSAReaper (void *x);
#else
sigset_t thrsigset;
#endif
#ifdef HAVE_SSL
-extern SSL_CTX* SSLctx;
+extern SSL_CTX *SSLctx;
#endif
@@ -118,9 +118,9 @@ httpd_init (int argc, char *argv[])
int i;
herror_t status;
- hoption_init_args(argc, argv);
+ hoption_init_args (argc, argv);
- status = hsocket_module_init ();
+ status = hsocket_module_init ();
if (status != H_OK)
return status;
@@ -159,19 +159,17 @@ httpd_init (int argc, char *argv[])
}
#ifdef WIN32
- /*
- if (_beginthread (WSAReaper, 0, NULL) == -1)
- {
- log_error1 ("Winsock reaper thread failed to start");
- return herror_new("httpd_init", THREAD_BEGIN_ERROR,
- "_beginthread() failed while starting WSAReaper");
- }
- */
+ /*
+ if (_beginthread (WSAReaper, 0, NULL) == -1) { log_error1 ("Winsock
+ reaper thread failed to start"); return herror_new("httpd_init",
+ THREAD_BEGIN_ERROR, "_beginthread() failed while starting WSAReaper");
+ } */
#endif
/* create socket */
status = hsocket_init (&_httpd_socket);
- if( status != H_OK ){
+ if (status != H_OK)
+ {
return status;
}
status = hsocket_bind (&_httpd_socket, _httpd_port);
@@ -226,10 +224,10 @@ httpd_services ()
* FUNCTION: httpd_services
* -----------------------------------------------------
*/
-static
-void hservice_free(hservice_t *service)
+static void
+hservice_free (hservice_t * service)
{
- free(service);
+ free (service);
}
/*
@@ -293,7 +291,7 @@ httpd_send_header (httpd_conn_t * res, int code, const char *text)
strcat (header, "\r\n");
/* set content-type */
- /*
+ /*
* if (res->content_type[0] == '\0') { strcat(header, "Content-Type:
* text/html\r\n"); } else { sprintf(buffer, "Content-Type: %s\r\n",
* res->content_type); strcat(header, buffer); }
@@ -303,7 +301,7 @@ httpd_send_header (httpd_conn_t * res, int code, const char *text)
strcat (header, "Server: Nano HTTPD library\r\n");
/* set _httpd_connection status */
- //strcat (header, "Connection: close\r\n");
+ // strcat (header, "Connection: close\r\n");
/* add pairs */
cur = res->header;
@@ -319,9 +317,9 @@ httpd_send_header (httpd_conn_t * res, int code, const char *text)
/* send header */
status = hsocket_nsend (res->sock, header, strlen (header));
- if (status != H_OK)
- return status;
-
+ if (status != H_OK)
+ return status;
+
res->out = http_output_stream_new (res->sock, res->header);
return H_OK;
}
@@ -339,7 +337,7 @@ httpd_send_internal_error (httpd_conn_t * conn, const char *errmsg)
#ifdef WIN32
#define snprintf(buffer, num, s1, s2) sprintf(buffer, s1,s2)
#endif
- snprintf(buflen, 5, "%d", strlen(buffer));
+ snprintf (buflen, 5, "%d", strlen (buffer));
httpd_set_header (conn, HEADER_CONTENT_LENGTH, buflen);
httpd_send_header (conn, 500, "INTERNAL");
return hsocket_nsend (conn->sock, buffer, strlen (buffer));
@@ -356,9 +354,11 @@ httpd_request_print (hrequest_t * req)
hpair_t *pair;
log_verbose1 ("++++++ Request +++++++++");
- log_verbose2 (" Method : '%s'", (req->method == HTTP_REQUEST_POST)?"POST":"GET");
+ log_verbose2 (" Method : '%s'",
+ (req->method == HTTP_REQUEST_POST) ? "POST" : "GET");
log_verbose2 (" Path : '%s'", req->path);
- log_verbose2 (" Spec : '%s'", (req->version==HTTP_1_0)?"HTTP/1.0":"HTTP/1.1");
+ log_verbose2 (" Spec : '%s'",
+ (req->version == HTTP_1_0) ? "HTTP/1.0" : "HTTP/1.1");
log_verbose1 (" Parsed query string :");
pair = req->query;
@@ -379,7 +379,8 @@ httpd_request_print (hrequest_t * req)
}
-httpd_conn_t *httpd_new(hsocket_t sock)
+httpd_conn_t *
+httpd_new (hsocket_t sock)
{
httpd_conn_t *conn = (httpd_conn_t *) malloc (sizeof (httpd_conn_t));
conn->sock = sock;
@@ -391,18 +392,21 @@ httpd_conn_t *httpd_new(hsocket_t sock)
}
-void httpd_free(httpd_conn_t *conn)
+void
+httpd_free (httpd_conn_t * conn)
{
if (conn->out != NULL)
- http_output_stream_free(conn->out);
+ http_output_stream_free (conn->out);
if (conn->header != NULL)
- hpairnode_free_deep(conn->header);
+ hpairnode_free_deep (conn->header);
- free(conn);
+ free (conn);
}
-void do_req_timeout(int signum){
+void
+do_req_timeout (int signum)
+{
/*
struct sigaction req_timeout;
memset(&req_timeout, 0, sizeof(&req_timeout));
@@ -410,12 +414,12 @@ void do_req_timeout(int signum){
sigaction(SIGALRM, &req_timeout, NULL);
*/
- // XXX this is not real pretty, is there a better way?
- log_verbose1("Thread timeout.");
+ // XXX this is not real pretty, is there a better way?
+ log_verbose1 ("Thread timeout.");
#ifdef WIN32
- _endthread ();
- #else
- pthread_exit(0);
+ _endthread ();
+#else
+ pthread_exit (0);
#endif
}
@@ -435,7 +439,7 @@ httpd_session_main (void *data)
conndata_t *conn = (conndata_t *) data;
const char *msg = "SESSION 1.0\n";
int len = strlen (msg);
- int done=0;
+ int done = 0;
char buffer[256]; /* temp buffer for recv() */
char header[4064]; /* received header */
hrequest_t *req = NULL; /* only for test */
@@ -448,14 +452,19 @@ httpd_session_main (void *data)
log_verbose1 ("starting httpd_session_main()");
#ifdef HAVE_SSL
- if( !SSLctx ){
- log_verbose1("Using HTTP");
- } else {
- log_verbose1("Using HTTPS");
- conn->sock.ssl = init_ssl(SSLctx, conn->sock.sock, SSL_SERVER);
+ if (!SSLctx)
+ {
+ log_verbose1 ("Using HTTP");
+ }
+ else
+ {
+ log_verbose1 ("Using HTTPS");
+ conn->sock.ssl = init_ssl (SSLctx, conn->sock.sock, SSL_SERVER);
hsocket_block (conn->sock, 0);
- if( conn->sock.ssl == NULL ){
- return herror_new("hsocket_accept", SSL_ERROR_INIT, "Unable to initialize SSL");
+ if (conn->sock.ssl == NULL)
+ {
+ return herror_new ("hsocket_accept", SSL_ERROR_INIT,
+ "Unable to initialize SSL");
}
}
#endif
@@ -463,69 +472,77 @@ httpd_session_main (void *data)
/* call the service */
/* req = hrequest_new_from_buffer (header);*/
- do{
- log_verbose1("starting HTTP request");
- rconn = httpd_new(conn->sock);
+ do
+ {
+ log_verbose1 ("starting HTTP request");
+ rconn = httpd_new (conn->sock);
- status = hrequest_new_from_socket (conn->sock, &req);
+ status = hrequest_new_from_socket (conn->sock, &req);
- if (status != H_OK)
+ if (status != H_OK)
+ {
+ if (herror_code (status) != HSOCKET_SSL_CLOSE)
{
- if(herror_code(status) != HSOCKET_SSL_CLOSE){
- httpd_send_internal_error (rconn, herror_message(status)/*"Request parse error!"*/);
- herror_release(status);
- }
- done=1;
+ httpd_send_internal_error (rconn, herror_message (status) /* "Request
+ parse
+ error!" */ );
+ herror_release (status);
}
- else
- {
- char *conn_str = hpairnode_get_ignore_case (req->header, HEADER_CONNECTION);
+ done = 1;
+ }
+ else
+ {
+ char *conn_str =
+ hpairnode_get_ignore_case (req->header, HEADER_CONNECTION);
#ifdef WIN32
#define strncasecmp(s1, s2, num) strncmp(s1, s2, num)
#endif
- if(conn_str && strncasecmp( conn_str, "close",5 ) == 0){
- done=1;
- }
- if(!done){
- done = req->version==HTTP_1_0?1:0;
- }
- httpd_request_print (req);
+ if (conn_str && strncasecmp (conn_str, "close", 5) == 0)
+ {
+ done = 1;
+ }
+ if (!done)
+ {
+ done = req->version == HTTP_1_0 ? 1 : 0;
+ }
+ httpd_request_print (req);
- service = httpd_find_service (req->path);
- if (service != NULL)
+ service = httpd_find_service (req->path);
+ if (service != NULL)
+ {
+ log_verbose2 ("service '%s' found", req->path);
+ if (service->func != NULL)
{
- log_verbose2 ("service '%s' found", req->path);
- if (service->func != NULL)
- {
- service->func (rconn, req);
- }
- else
- {
- sprintf (buffer,
- "service '%s' not registered properly (func == NULL)",
- req->path);
- log_verbose1 (buffer);
- httpd_send_internal_error (rconn, buffer);
- }
+ service->func (rconn, req);
}
else
{
- sprintf (buffer, "service '%s' not found", req->path);
+ sprintf (buffer,
+ "service '%s' not registered properly (func == NULL)",
+ req->path);
log_verbose1 (buffer);
httpd_send_internal_error (rconn, buffer);
}
-
- /* httpd_response_free(res); */
- /*hrequest_free (req);*/
}
- }while(!done);
+ else
+ {
+ sprintf (buffer, "service '%s' not found", req->path);
+ log_verbose1 (buffer);
+ httpd_send_internal_error (rconn, buffer);
+ }
+
+ /* httpd_response_free(res); */
+ /* hrequest_free (req); */
+ }
+ }
+ while (!done);
- hsocket_close(conn->sock);
- log_verbose1("Marking connection as available");
+ hsocket_close (conn->sock);
+ log_verbose1 ("Marking connection as available");
conn->sock.sock = 0;
- hrequest_free(req);
- httpd_free(rconn);
+ hrequest_free (req);
+ httpd_free (rconn);
#ifdef WIN32
CloseHandle ((HANDLE) conn->tid);
_endthread ();
@@ -567,10 +584,12 @@ httpd_set_header (httpd_conn_t * conn, const char *key, const char *value)
}
-void httpd_set_headers(httpd_conn_t *conn, hpair_t *header)
+void
+httpd_set_headers (httpd_conn_t * conn, hpair_t * header)
{
- while (header) {
- httpd_set_header(conn, header->key, header->value);
+ while (header)
+ {
+ httpd_set_header (conn, header->key, header->value);
header = header->next;
}
}
@@ -584,7 +603,7 @@ void httpd_set_headers(httpd_conn_t *conn, hpair_t *header)
BOOL WINAPI
httpd_term (DWORD sig)
{
- //log_debug2 ("Got signal %d", sig);
+ // log_debug2 ("Got signal %d", sig);
if (sig == _httpd_terminate_signal)
_httpd_run = 0;
return TRUE;
@@ -671,7 +690,7 @@ _httpd_start_thread (conndata_t * conn)
#ifdef PTHREAD_CREATE_DETACHED
pthread_attr_setdetachstate (&(conn->attr), PTHREAD_CREATE_DETACHED);
#endif
- pthread_sigmask(SIG_BLOCK, &thrsigset, NULL);
+ pthread_sigmask (SIG_BLOCK, &thrsigset, NULL);
err = pthread_create (&(conn->tid), &(conn->attr), httpd_session_main,
conn);
if (err)
@@ -704,8 +723,8 @@ httpd_run ()
timeout.tv_usec = 0;
#ifdef WIN32
#else
- sigemptyset(&thrsigset);
- sigaddset(&thrsigset, SIGALRM);
+ sigemptyset (&thrsigset);
+ sigaddset (&thrsigset, SIGALRM);
#endif
@@ -713,7 +732,7 @@ httpd_run ()
err = hsocket_listen (_httpd_socket);
if (err != H_OK)
{
- log_error2 ("httpd_run(): '%d'", herror_message(err));
+ log_error2 ("httpd_run(): '%d'", herror_message (err));
return err;
}
log_verbose2 ("listening to port '%d'", _httpd_port);
@@ -725,7 +744,7 @@ httpd_run ()
err = hsocket_block (_httpd_socket, 0);
if (err != H_OK)
{
- log_error2 ("httpd_run(): '%s'", herror_message(err));
+ log_error2 ("httpd_run(): '%s'", herror_message (err));
return err;
}
@@ -775,18 +794,20 @@ httpd_run ()
/* Accept a socket */
err = hsocket_accept (_httpd_socket, &(conn->sock));
- if (err != H_OK && herror_code(err) == SSL_ERROR_INIT) {
- hsocket_close(conn->sock);
+ if (err != H_OK && herror_code (err) == SSL_ERROR_INIT)
+ {
+ hsocket_close (conn->sock);
conn->sock.sock = -1;
#ifdef HAVE_SSL
conn->sock.ssl = NULL;
#endif
- log_error1(herror_message(err));
+ log_error1 (herror_message (err));
continue;
- } else if (err != H_OK)
+ }
+ else if (err != H_OK)
{
- log_error2 ("Can not accept socket: %s", herror_message(err));
- return err; /* this is hard core! */
+ log_error2 ("Can not accept socket: %s", herror_message (err));
+ return err; /* this is hard core! */
}
/* Now start a thread */
@@ -796,54 +817,65 @@ httpd_run ()
return 0;
}
-void httpd_destroy()
+void
+httpd_destroy ()
{
hservice_t *tmp, *cur = _httpd_services_head;
while (cur != NULL)
{
tmp = cur->next;
- hservice_free(cur);
+ hservice_free (cur);
cur = tmp;
}
- hsocket_module_destroy();
+ hsocket_module_destroy ();
}
#ifdef WIN32
-static
-void WSAReaper(void *x)
+static void
+WSAReaper (void *x)
{
- short int connections;
- short int i;
- char junk[10];
- int rc;
- time_t ctime;
-
- for (;;) {
- connections=0;
- ctime=time((time_t)0);
- for (i=0;i<_httpd_max_connections;i++) {
- if (_httpd_connection[i].tid==0) continue;
- GetExitCodeThread((HANDLE)_httpd_connection[i].tid,(PDWORD) &rc);
- if (rc!=STILL_ACTIVE) continue;
- connections++;
- if ((ctime-_httpd_connection[i].atime<_httpd_max_idle)||
- (_httpd_connection[i].atime==0)) continue;
- log_verbose3("Reaping socket %u from (runtime ~= %d seconds)",
- _httpd_connection[i].sock, ctime-_httpd_connection[i].atime);
- shutdown(_httpd_connection[i].sock.sock, 2);
- while (recv(_httpd_connection[i].sock.sock, junk, sizeof(junk), 0)>0) { };
- closesocket(_httpd_connection[i].sock.sock);
- _httpd_connection[i].sock.sock = 0;
- TerminateThread(_httpd_connection[i].tid, (DWORD)&rc);
- CloseHandle(_httpd_connection[i].tid);
- memset((char *)&_httpd_connection[i], 0, sizeof(_httpd_connection[i]));
- }
- Sleep(100);
- }
- return;
+ short int connections;
+ short int i;
+ char junk[10];
+ int rc;
+ time_t ctime;
+
+ for (;;)
+ {
+ connections = 0;
+ ctime = time ((time_t) 0);
+ for (i = 0; i < _httpd_max_connections; i++)
+ {
+ if (_httpd_connection[i].tid == 0)
+ continue;
+ GetExitCodeThread ((HANDLE) _httpd_connection[i].tid, (PDWORD) & rc);
+ if (rc != STILL_ACTIVE)
+ continue;
+ connections++;
+ if ((ctime - _httpd_connection[i].atime < _httpd_max_idle) ||
+ (_httpd_connection[i].atime == 0))
+ continue;
+ log_verbose3 ("Reaping socket %u from (runtime ~= %d seconds)",
+ _httpd_connection[i].sock,
+ ctime - _httpd_connection[i].atime);
+ shutdown (_httpd_connection[i].sock.sock, 2);
+ while (recv (_httpd_connection[i].sock.sock, junk, sizeof (junk), 0) >
+ 0)
+ {
+ };
+ closesocket (_httpd_connection[i].sock.sock);
+ _httpd_connection[i].sock.sock = 0;
+ TerminateThread (_httpd_connection[i].tid, (DWORD) & rc);
+ CloseHandle (_httpd_connection[i].tid);
+ memset ((char *) &_httpd_connection[i], 0,
+ sizeof (_httpd_connection[i]));
+ }
+ Sleep (100);
+ }
+ return;
}
#endif
@@ -888,7 +920,7 @@ httpd_get_postdata (httpd_conn_t * conn, hrequest_t * req, long *received,
log_error1 ("Not enough memory");
return NULL;
}
- if (http_input_stream_read(req->in, postdata, (int) content_length) > 0)
+ if (http_input_stream_read (req->in, postdata, (int) content_length) > 0)
{
*received = content_length;
postdata[content_length] = '\0';
@@ -928,14 +960,13 @@ httpd_mime_send_header (httpd_conn_t * conn,
char boundary[250];
/*
- Set Content-type
- Set multipart/related parameter
- type=..; start=.. ; start-info= ..; boundary=...
+ Set Content-type Set multipart/related parameter type=..; start=.. ;
+ start-info= ..; boundary=...
*/
- /*
- using sprintf instead of snprintf because visual c does not support snprintf
- */
+ /*
+ using sprintf instead of snprintf because visual c does not support
+ snprintf */
sprintf (buffer, "multipart/related;");
@@ -1023,8 +1054,8 @@ httpd_mime_send_file (httpd_conn_t * conn,
size_t size;
if (fd == NULL)
- return herror_new("httpd_mime_send_file", FILE_ERROR_OPEN,
- "Can not open file '%d'", filename);
+ return herror_new ("httpd_mime_send_file", FILE_ERROR_OPEN,
+ "Can not open file '%d'", filename);
status =
httpd_mime_next (conn, content_id, content_type, transfer_encoding);
@@ -1040,12 +1071,13 @@ httpd_mime_send_file (httpd_conn_t * conn,
if (size == -1)
{
fclose (fd);
- return herror_new("httpd_mime_send_file", FILE_ERROR_READ,
- "Can not read from file '%d'", filename);
+ return herror_new ("httpd_mime_send_file", FILE_ERROR_READ,
+ "Can not read from file '%d'", filename);
}
status = http_output_stream_write (conn->out, buffer, size);
- if (status != H_OK) {
+ if (status != H_OK)
+ {
fclose (fd);
return status;
}
diff --git a/nanohttp/nanohttp-server.h b/nanohttp/nanohttp-server.h
index f0550f8..101a4b7 100644
--- a/nanohttp/nanohttp-server.h
+++ b/nanohttp/nanohttp-server.h
@@ -1,5 +1,5 @@
/******************************************************************
- * $Id: nanohttp-server.h,v 1.9 2004/11/02 23:09:27 snowdrop Exp $
+ * $Id: nanohttp-server.h,v 1.10 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -21,8 +21,8 @@
*
* Email: ferhatayaz@yahoo.com
******************************************************************/
-#ifndef NANO_HTTP_SERVER_H
-#define NANO_HTTP_SERVER_H
+#ifndef NANO_HTTP_SERVER_H
+#define NANO_HTTP_SERVER_H
#include <nanohttp/nanohttp-common.h>
@@ -38,13 +38,13 @@ typedef struct httpd_conn
char content_type[25];
http_output_stream_t *out;
hpair_t *header;
-}httpd_conn_t;
+} httpd_conn_t;
/*
Service callback
*/
-typedef void (*httpd_service)(httpd_conn_t*, hrequest_t*);
+typedef void (*httpd_service) (httpd_conn_t *, hrequest_t *);
/*
@@ -55,25 +55,25 @@ typedef struct tag_hservice
char ctx[255];
httpd_service func;
struct tag_hservice *next;
-}hservice_t;
+} hservice_t;
/*
Begin httpd_* function set
*/
-herror_t httpd_init(int argc, char *argv[]);
-int httpd_register(const char* ctx, httpd_service service);
-herror_t httpd_run();
-void httpd_destroy();
+herror_t httpd_init (int argc, char *argv[]);
+int httpd_register (const char *ctx, httpd_service service);
+herror_t httpd_run ();
+void httpd_destroy ();
-hservice_t *httpd_services();
+hservice_t *httpd_services ();
-herror_t httpd_send_header(httpd_conn_t *res,
- int code, const char* text);
+herror_t httpd_send_header (httpd_conn_t * res, int code, const char *text);
-int httpd_set_header(httpd_conn_t *conn, const char *key, const char* value);
-void httpd_set_headers(httpd_conn_t *conn, hpair_t *header);
+int httpd_set_header (httpd_conn_t * conn, const char *key,
+ const char *value);
+void httpd_set_headers (httpd_conn_t * conn, hpair_t * header);
/*
unsigned char *httpd_get_postdata(httpd_conn_t *conn,
@@ -90,36 +90,36 @@ unsigned char *httpd_get_postdata(httpd_conn_t *conn,
Begin MIME multipart/related POST
Returns: HSOCKET_OK or error flag
*/
-herror_t httpd_mime_send_header(httpd_conn_t *conn,
- const char* related_start,
- const char* related_start_info,
- const char* related_type, int code, const char* text);
+herror_t httpd_mime_send_header (httpd_conn_t * conn,
+ const char *related_start,
+ const char *related_start_info,
+ const char *related_type, int code,
+ const char *text);
/**
Send boundary and part header and continue
with next part
*/
-herror_t httpd_mime_next(httpd_conn_t *conn,
- const char* content_id,
- const char* content_type,
- const char* transfer_encoding);
+herror_t httpd_mime_next (httpd_conn_t * conn,
+ const char *content_id,
+ const char *content_type,
+ const char *transfer_encoding);
/**
Send boundary and part header and continue
with next part
*/
-herror_t httpd_mime_send_file(httpd_conn_t *conn,
- const char* content_id,
- const char* content_type,
- const char* transfer_encoding,
- const char* filename);
+herror_t httpd_mime_send_file (httpd_conn_t * conn,
+ const char *content_id,
+ const char *content_type,
+ const char *transfer_encoding,
+ const char *filename);
/**
Finish MIME request
Returns: HSOCKET_OK or error flag
*/
-herror_t httpd_mime_end(httpd_conn_t *conn);
+herror_t httpd_mime_end (httpd_conn_t * conn);
#endif
-
diff --git a/nanohttp/nanohttp-socket.c b/nanohttp/nanohttp-socket.c
index 684585c..ee69561 100644
--- a/nanohttp/nanohttp-socket.c
+++ b/nanohttp/nanohttp-socket.c
@@ -1,5 +1,5 @@
/******************************************************************
-* $Id: nanohttp-socket.c,v 1.41 2006/01/06 16:17:36 snowdrop Exp $
+* $Id: nanohttp-socket.c,v 1.42 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -26,16 +26,16 @@
#include <nanohttp/nanohttp-ssl.h>
#ifdef WIN32
- #include "wsockcompat.h"
- #include <winsock2.h>
- #include <process.h>
-
- #ifndef __MINGW32__
- typedef int ssize_t;
- #endif
-
+#include "wsockcompat.h"
+#include <winsock2.h>
+#include <process.h>
+
+#ifndef __MINGW32__
+typedef int ssize_t;
+#endif
+
#else
- #include <fcntl.h>
+#include <fcntl.h>
#endif
#ifdef HAVE_CONFIG_H
@@ -78,7 +78,7 @@
#ifdef HAVE_SSL
-SSL_CTX* SSLctx = NULL;
+SSL_CTX *SSLctx = NULL;
char *SSLCert = NULL;
char *SSLPass = NULL;
char *SSLCA = NULL;
@@ -121,19 +121,22 @@ hsocket_module_destroy ()
FUNCTION: hsocket_init
----------------------------------------------------*/
herror_t
-hsocket_init (hsocket_t * sock )
+hsocket_init (hsocket_t * sock)
{
- log_verbose1("Starting hsocket init");
+ log_verbose1 ("Starting hsocket init");
/* just set the descriptor to -1 */
sock->sock = -1;
#ifdef HAVE_SSL
sock->ssl = NULL;
- if(SSLCert || SSLCertLess){
- log_verbose1("calling init ctx");
- SSLctx=initialize_ctx( SSLCert,SSLPass,SSLCA);
- if(SSLctx==NULL){
- return herror_new("hsocket_init", HSOCKET_ERROR_CONNECT, "Unable to initialize SSL CTX" );
- }
+ if (SSLCert || SSLCertLess)
+ {
+ log_verbose1 ("calling init ctx");
+ SSLctx = initialize_ctx (SSLCert, SSLPass, SSLCA);
+ if (SSLctx == NULL)
+ {
+ return herror_new ("hsocket_init", HSOCKET_ERROR_CONNECT,
+ "Unable to initialize SSL CTX");
+ }
}
#endif
return H_OK;
@@ -161,33 +164,40 @@ hsocket_open (hsocket_t * dsock, const char *hostname, int port)
sock.sock = socket (AF_INET, SOCK_STREAM, 0);
if (sock.sock <= 0)
- return herror_new("hsocket_open", HSOCKET_ERROR_CREATE, "Socket error: %d", errno);
+ return herror_new ("hsocket_open", HSOCKET_ERROR_CREATE,
+ "Socket error: %d", errno);
/* Get host data */
host = gethostbyname (hostname);
if (host == NULL)
- return herror_new("hsocket_open", HSOCKET_ERROR_GET_HOSTNAME, "Socket error: %d", errno);
+ return herror_new ("hsocket_open", HSOCKET_ERROR_GET_HOSTNAME,
+ "Socket error: %d", errno);
ip = inet_ntoa (*(struct in_addr *) *host->h_addr_list);
address.sin_addr.s_addr = inet_addr (ip);
/* set server addresss */
address.sin_family = host->h_addrtype;
- address.sin_port = htons((unsigned short)port);
+ address.sin_port = htons ((unsigned short) port);
/* connect to the server */
- if (connect (sock.sock, (struct sockaddr *) &address, sizeof (address)) != 0)
- return herror_new("hsocket_open", HSOCKET_ERROR_CONNECT, "Socket error: %d", errno);
+ if (connect (sock.sock, (struct sockaddr *) &address, sizeof (address)) !=
+ 0)
+ return herror_new ("hsocket_open", HSOCKET_ERROR_CONNECT,
+ "Socket error: %d", errno);
#ifdef HAVE_SSL
- if( !SSLctx ){
+ if (!SSLctx)
+ {
#endif
- log_verbose1("Using HTTP");
+ log_verbose1 ("Using HTTP");
dsock->sock = sock.sock;
#ifdef HAVE_SSL
- } else {
- log_verbose1("Using HTTPS");
- dsock->ssl = init_ssl(SSLctx, sock.sock, SSL_CLIENT);
+ }
+ else
+ {
+ log_verbose1 ("Using HTTPS");
+ dsock->ssl = init_ssl (SSLctx, sock.sock, SSL_CLIENT);
}
#endif
return H_OK;
@@ -201,28 +211,31 @@ hsocket_bind (hsocket_t * dsock, int port)
{
hsocket_t sock;
struct sockaddr_in addr;
- int opt=1;
+ int opt = 1;
/* create socket */
sock.sock = socket (AF_INET, SOCK_STREAM, 0);
if (sock.sock == -1)
{
log_error3 ("Can not create socket: '%s'", "Socket error: %d", errno);
- return herror_new("hsocket_bind", HSOCKET_ERROR_CREATE, "Socket error: %d", errno);
+ return herror_new ("hsocket_bind", HSOCKET_ERROR_CREATE,
+ "Socket error: %d", errno);
}
- setsockopt( sock.sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt) );
+ setsockopt (sock.sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));
/* bind socket */
addr.sin_family = AF_INET;
- addr.sin_port = htons ((unsigned short)port); /* short, network byte order */
+ addr.sin_port = htons ((unsigned short) port); /* short, network
+ byte order */
addr.sin_addr.s_addr = INADDR_ANY;
- memset (&(addr.sin_zero), '\0', 8); /* zero the rest of the
- * struct */
+ memset (&(addr.sin_zero), '\0', 8); /* zero the rest of the struct */
- if (bind (sock.sock, (struct sockaddr *) &addr, sizeof (struct sockaddr)) == -1)
+ if (bind (sock.sock, (struct sockaddr *) &addr, sizeof (struct sockaddr)) ==
+ -1)
{
log_error3 ("Can not bind: '%s'", "Socket error: %d", errno);
- return herror_new("hsocket_bind", HSOCKET_ERROR_BIND, "Socket error: %d", errno);
+ return herror_new ("hsocket_bind", HSOCKET_ERROR_BIND, "Socket error: %d",
+ errno);
}
dsock->sock = sock.sock;
return H_OK;
@@ -239,28 +252,34 @@ hsocket_accept (hsocket_t sock, hsocket_t * dest)
struct sockaddr_in addr;
if (sock.sock <= 0)
- return herror_new("hsocket_accept", HSOCKET_ERROR_NOT_INITIALIZED,
- "Called hsocket_listen() before initializing!");
+ return herror_new ("hsocket_accept", HSOCKET_ERROR_NOT_INITIALIZED,
+ "Called hsocket_listen() before initializing!");
asize = sizeof (struct sockaddr_in);
#ifdef WIN32
while (1)
{
sockfd.sock = accept (sock.sock, (struct sockaddr *) &addr, &asize);
- if (sockfd.sock == INVALID_SOCKET) {
+ if (sockfd.sock == INVALID_SOCKET)
+ {
if (WSAGetLastError () != WSAEWOULDBLOCK)
- return herror_new("hsocket_accept", HSOCKET_ERROR_ACCEPT, "Socket error: %d", errno);
- } else {
+ return herror_new ("hsocket_accept", HSOCKET_ERROR_ACCEPT,
+ "Socket error: %d", errno);
+ }
+ else
+ {
break;
}
}
-#else
+#else
/* TODO (#1#): why not a loop like in win32? */
sockfd.sock = accept (sock.sock, (struct sockaddr *) &addr, &asize);
- if (sockfd.sock == -1) {
- return herror_new("hsocket_accept", HSOCKET_ERROR_ACCEPT, "Socket error: %d", errno);
+ if (sockfd.sock == -1)
+ {
+ return herror_new ("hsocket_accept", HSOCKET_ERROR_ACCEPT,
+ "Socket error: %d", errno);
}
-#endif
+#endif
/* TODO (#1#): Write to access.log file */
log_verbose3 ("accept new socket (%d) from '%s'", sockfd.sock,
@@ -277,21 +296,22 @@ herror_t
hsocket_listen (hsocket_t sock)
{
if (sock.sock <= 0)
- return herror_new("hsocket_listen", HSOCKET_ERROR_NOT_INITIALIZED,
- "Called hsocket_listen() before initializing!");
+ return herror_new ("hsocket_listen", HSOCKET_ERROR_NOT_INITIALIZED,
+ "Called hsocket_listen() before initializing!");
if (listen (sock.sock, 15) == -1)
{
log_error3 ("Can not listen: '%s'", "Socket error: %d", errno);
- return herror_new("hsocket_listen", HSOCKET_ERROR_LISTEN, "Socket error: %d", errno);
+ return herror_new ("hsocket_listen", HSOCKET_ERROR_LISTEN,
+ "Socket error: %d", errno);
}
return H_OK;
}
#if 0
-static
-void _hsocket_wait_until_receive(hsocket_t sock)
+static void
+_hsocket_wait_until_receive (hsocket_t sock)
{
fd_set fds;
struct timeval timeout;
@@ -300,15 +320,15 @@ void _hsocket_wait_until_receive(hsocket_t sock)
timeout.tv_sec = 1;
timeout.tv_usec = 0;
- while (1)
+ while (1)
{
log_verbose1 ("waiting until receive mode");
/* zero and set file descriptior */
FD_ZERO (&fds);
FD_SET (sock, &fds);
-
+
/* select socket descriptor */
- switch (select (sock + 1, &fds, NULL, NULL, &timeout))
+ switch (select (sock + 1, &fds, NULL, NULL, &timeout))
{
case 0:
/* descriptor is not ready */
@@ -344,31 +364,40 @@ hsocket_close (hsocket_t sock)
_linger.l_linger = 30000;
setsockopt(sock, SOL_SOCKET, SO_LINGER, (const char*)&_linger, sizeof(struct linger));
*/
-
+
#ifdef WIN32
- /*shutdown(sock,SD_RECEIVE);*/
-
+ /* shutdown(sock,SD_RECEIVE); */
+
+
+ shutdown (sock.sock, SD_SEND);
+ while (recv (sock.sock, junk, sizeof (junk), 0) > 0)
+ {
+ };
+ closesocket (sock.sock);
- shutdown(sock.sock, SD_SEND);
- while (recv(sock.sock, junk, sizeof(junk), 0)>0) { };
- closesocket(sock.sock);
-
#else
/* XXX m. campbell - It seems like the while loop here needs this */
- fcntl( sock.sock, F_SETFL, O_NONBLOCK);
+ fcntl (sock.sock, F_SETFL, O_NONBLOCK);
#ifdef HAVE_SSL
- if( sock.ssl ){
- log_verbose1("Closing SSL");
- ssl_cleanup(sock.ssl);
- shutdown(sock.sock, SHUT_RDWR);
- while (recv(sock.sock, junk, sizeof(junk), 0)>0) { };
+ if (sock.ssl)
+ {
+ log_verbose1 ("Closing SSL");
+ ssl_cleanup (sock.ssl);
+ shutdown (sock.sock, SHUT_RDWR);
+ while (recv (sock.sock, junk, sizeof (junk), 0) > 0)
+ {
+ };
close (sock.sock);
- }else {
+ }
+ else
+ {
#endif
- shutdown(sock.sock, SHUT_RDWR);
- while (recv(sock.sock, junk, sizeof(junk), 0)>0) { };
- close (sock.sock);
+ shutdown (sock.sock, SHUT_RDWR);
+ while (recv (sock.sock, junk, sizeof (junk), 0) > 0)
+ {
+ };
+ close (sock.sock);
#ifdef HAVE_SSL
}
#endif
@@ -377,70 +406,80 @@ hsocket_close (hsocket_t sock)
}
#if 0
-static int _test_send_to_file(const char* filename, const byte_t* bytes,int n)
+static int
+_test_send_to_file (const char *filename, const byte_t * bytes, int n)
{
- int size;
- FILE *f = fopen(filename, "ab");
- if (!f) f = fopen(filename, "wb");
- size= fwrite(bytes, 1, n, f);
- fclose(f);
- return size;
+ int size;
+ FILE *f = fopen (filename, "ab");
+ if (!f)
+ f = fopen (filename, "wb");
+ size = fwrite (bytes, 1, n, f);
+ fclose (f);
+ return size;
}
#endif
/*--------------------------------------------------
FUNCTION: hsocket_send
----------------------------------------------------*/
herror_t
-hsocket_nsend (hsocket_t sock, const byte_t *bytes, int n)
+hsocket_nsend (hsocket_t sock, const byte_t * bytes, int n)
{
int size;
- int total=0;
+ int total = 0;
- log_verbose1( "Starting to send" );
+ log_verbose1 ("Starting to send");
#ifdef HAVE_SSL
if (sock.sock <= 0 && !sock.ssl)
#else
if (sock.sock <= 0)
#endif
- return herror_new("hsocket_nsend", HSOCKET_ERROR_NOT_INITIALIZED,
- "Called hsocket_listen() before initializing!");
+ return herror_new ("hsocket_nsend", HSOCKET_ERROR_NOT_INITIALIZED,
+ "Called hsocket_listen() before initializing!");
- //log_verbose2( "SENDING %s", bytes );
+ // log_verbose2( "SENDING %s", bytes );
/* TODO (#1#): check return value and send again until n bytes sent */
while (1)
{
#ifdef HAVE_SSL
- if(sock.ssl){
- size = SSL_write(sock.ssl, bytes + total, n);
- } else {
+ if (sock.ssl)
+ {
+ size = SSL_write (sock.ssl, bytes + total, n);
+ }
+ else
+ {
#endif
- size = send((int) sock.sock, bytes + total, n, 0);
+ size = send ((int) sock.sock, bytes + total, n, 0);
#ifdef HAVE_SSL
}
#endif
- log_verbose2("Sent %d", size );
- /* size = _test_send_to_file(filename, bytes, n);*/
+ log_verbose2 ("Sent %d", size);
+ /* size = _test_send_to_file(filename, bytes, n); */
#ifdef WIN32
if (size == INVALID_SOCKET)
- if (WSAGetLastError () == WSAEWOULDBLOCK)
- continue;
- else
- return herror_new("hsocket_nsend", HSOCKET_ERROR_SEND, "Socket error: %d", errno);
+ if (WSAGetLastError () == WSAEWOULDBLOCK)
+ continue;
+ else
+ return herror_new ("hsocket_nsend", HSOCKET_ERROR_SEND,
+ "Socket error: %d", errno);
#else
- if (size == -1){
+ if (size == -1)
+ {
#ifdef HAVE_SSL
- if(sock.ssl){
- log_error1("Send error");
- log_ssl_error(sock.ssl, size);
- }
+ if (sock.ssl)
+ {
+ log_error1 ("Send error");
+ log_ssl_error (sock.ssl, size);
+ }
#endif
- return herror_new("hsocket_nsend", HSOCKET_ERROR_SEND, "Socket error: %d", errno);
+ return herror_new ("hsocket_nsend", HSOCKET_ERROR_SEND,
+ "Socket error: %d", errno);
}
#endif
n -= size;
- total += size;
- if (n<=0) break;
+ total += size;
+ if (n <= 0)
+ break;
}
return H_OK;
}
@@ -458,7 +497,8 @@ hsocket_send (hsocket_t sock, const char *str)
return: -1 is error. read bytes otherwise
*/
herror_t
-hsocket_read (hsocket_t sock, byte_t *buffer, int total, int force, int *received)
+hsocket_read (hsocket_t sock, byte_t * buffer, int total, int force,
+ int *received)
{
int status;
int totalRead;
@@ -469,72 +509,81 @@ hsocket_read (hsocket_t sock, byte_t *buffer, int total, int force, int *receive
/*
log_verbose3("Entering hsocket_read(total=%d,force=%d)", total, force);
*/
- do {
+ do
+ {
#ifdef HAVE_SSL
- if(sock.ssl){
- struct timeval timeout;
- int i=0;
- fd_set fds;
- FD_ZERO (&fds);
- FD_SET (sock.sock, &fds);
- timeout.tv_sec = 10;
- timeout.tv_usec = 0;
+ if (sock.ssl)
+ {
+ struct timeval timeout;
+ int i = 0;
+ fd_set fds;
+ FD_ZERO (&fds);
+ FD_SET (sock.sock, &fds);
+ timeout.tv_sec = 10;
+ timeout.tv_usec = 0;
#ifdef WIN32
#else
- fcntl( sock.sock, F_SETFL, O_NONBLOCK);
-#endif
- // log_verbose1("START READ LOOP");
- //do{
- //log_verbose2("DEBUG A %d",i);
- status = SSL_read(sock.ssl, &buffer[totalRead], total - totalRead);
- if(status < 1){
- int ret = select (sock.sock + 1, &fds, NULL, NULL, &timeout);
- //log_verbose2("DEBUG %d",ret);
+ fcntl (sock.sock, F_SETFL, O_NONBLOCK);
+#endif
+ // log_verbose1("START READ LOOP");
+ // do{
+ // log_verbose2("DEBUG A %d",i);
+ status = SSL_read (sock.ssl, &buffer[totalRead], total - totalRead);
+ if (status < 1)
+ {
+ int ret = select (sock.sock + 1, &fds, NULL, NULL, &timeout);
+ // log_verbose2("DEBUG %d",ret);
#ifdef WIN32
- if (ret == SOCKET_ERROR)
- {
- wsa_error = WSAGetLastError();
- log_error2("WSAGetLastError()=%d", wsa_error);
- return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "Socket error: %d", errno);
-
- }
-#endif
- if(ret==0){
- log_verbose1("Socket timeout");
- return herror_new("hsocket_read", HSOCKET_SSL_CLOSE, "Timeout");
- } else {
- //log_verbose1("DEBUG C");
- status = SSL_read(sock.ssl, &buffer[totalRead], total - totalRead);
- }
- //log_verbose3("DEBUG D char: %d status: %d",
- // buffer[totalRead], SSL_get_error(sock.ssl, status));
+ if (ret == SOCKET_ERROR)
+ {
+ wsa_error = WSAGetLastError ();
+ log_error2 ("WSAGetLastError()=%d", wsa_error);
+ return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE,
+ "Socket error: %d", errno);
+
+ }
+#endif
+ if (ret == 0)
+ {
+ log_verbose1 ("Socket timeout");
+ return herror_new ("hsocket_read", HSOCKET_SSL_CLOSE, "Timeout");
+ }
+ else
+ {
+ // log_verbose1("DEBUG C");
+ status = SSL_read (sock.ssl, &buffer[totalRead], total - totalRead);
}
- //} while( SSL_get_error(sock.ssl, status) == SSL_ERROR_WANT_READ);
+ // log_verbose3("DEBUG D char: %d status: %d",
+ // buffer[totalRead], SSL_get_error(sock.ssl, status));
+ }
+ // } while( SSL_get_error(sock.ssl, status) == SSL_ERROR_WANT_READ);
#ifdef WIN32
#else
- fcntl( sock.sock, F_SETFL, 0);
+ fcntl (sock.sock, F_SETFL, 0);
#endif
- } else {
+ }
+ else
+ {
#else // HAVE_SSL
{
-#endif //HAVE_SSL
- status = recv(sock.sock, &buffer[totalRead], total - totalRead, 0);
+#endif // HAVE_SSL
+ status = recv (sock.sock, &buffer[totalRead], total - totalRead, 0);
#ifdef WIN32
- if (status == INVALID_SOCKET)
+ if (status == INVALID_SOCKET)
+ {
+ wsa_error = WSAGetLastError ();
+ switch (wsa_error)
{
- wsa_error = WSAGetLastError();
- switch (wsa_error)
- {
- case WSAEWOULDBLOCK:
- /* case WSAEALREADY:
- case WSAEINPROGRESS: */
- continue;
- default:
- log_error2("WSAGetLastError()=%d", wsa_error);
- return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "Socket error: %d", errno);
- }
+ case WSAEWOULDBLOCK:
+ /* case WSAEALREADY: case WSAEINPROGRESS: */
+ continue;
+ default:
+ log_error2 ("WSAGetLastError()=%d", wsa_error);
+ return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE,
+ "Socket error: %d", errno);
}
+ }
}
#else
}
@@ -548,66 +597,75 @@ hsocket_read (hsocket_t sock, byte_t *buffer, int total, int force, int *receive
*/
#ifdef HAVE_SSL
- if( sock.ssl && status < 1 ){
+ if (sock.ssl && status < 1)
+ {
- // XXX I'm not sure this err_syscall is right here...
- if( SSL_get_shutdown( sock.ssl ) == SSL_RECEIVED_SHUTDOWN ||
- SSL_get_error(sock.ssl, status) == SSL_ERROR_SYSCALL){
- *received = NULL;;
- return herror_new("hsocket_read", HSOCKET_SSL_CLOSE, "SSL Closed");
- }
- log_error2("Read error (%d)", status);
- log_ssl_error( sock.ssl, status );
- return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "SSL Error");
+ // XXX I'm not sure this err_syscall is right here...
+ if (SSL_get_shutdown (sock.ssl) == SSL_RECEIVED_SHUTDOWN ||
+ SSL_get_error (sock.ssl, status) == SSL_ERROR_SYSCALL)
+ {
+ *received = NULL;;
+ return herror_new ("hsocket_read", HSOCKET_SSL_CLOSE, "SSL Closed");
+ }
+ log_error2 ("Read error (%d)", status);
+ log_ssl_error (sock.ssl, status);
+ return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE, "SSL Error");
}
#endif
if (status == -1)
- return herror_new("hsocket_read", HSOCKET_ERROR_RECEIVE, "Socket error: %d", errno);
-#endif
-
- if (!force) {
- *received = status;
- /*
- log_verbose3("Leaving !force (received=%d)(status=%d)", *received, status);
- */
- return H_OK;
+ return herror_new ("hsocket_read", HSOCKET_ERROR_RECEIVE,
+ "Socket error: %d", errno);
+#endif
+
+ if (!force)
+ {
+ *received = status;
+ /*
+ log_verbose3("Leaving !force (received=%d)(status=%d)", *received,
+ status); */
+ return H_OK;
}
-
+
totalRead += status;
- if (totalRead == total) {
- *received = totalRead;
- /*
- log_verbose4("Leaving totalRead == total (received=%d)(status=%d)(totalRead=%d)", *received, status, totalRead);
- */
- return H_OK;
+ if (totalRead == total)
+ {
+ *received = totalRead;
+ /*
+ log_verbose4("Leaving totalRead == total
+ (received=%d)(status=%d)(totalRead=%d)", *received, status,
+ totalRead); */
+ return H_OK;
}
- } while (1);
+ }
+ while (1);
}
herror_t
-hsocket_block(hsocket_t sock, int block)
+hsocket_block (hsocket_t sock, int block)
{
#ifdef WIN32
unsigned long iMode;
#endif
if (sock.sock <= 0)
- return herror_new("hsocket_block", HSOCKET_ERROR_NOT_INITIALIZED,
- "Called hsocket_listen() before initializing!");
+ return herror_new ("hsocket_block", HSOCKET_ERROR_NOT_INITIALIZED,
+ "Called hsocket_listen() before initializing!");
#ifdef WIN32
/*#define HSOCKET_BLOCKMODE 0
#define HSOCKET_NONBLOCKMODE 1
*/
- iMode = (block==0)?1:0; /* Non block mode */
- if (ioctlsocket (sock.sock, FIONBIO, (u_long FAR *) & iMode) == INVALID_SOCKET)
+ iMode = (block == 0) ? 1 : 0; /* Non block mode */
+ if (ioctlsocket (sock.sock, FIONBIO, (u_long FAR *) & iMode) ==
+ INVALID_SOCKET)
{
- int err = WSAGetLastError();
+ int err = WSAGetLastError ();
log_error2 ("ioctlsocket error %d", err);
- return herror_new("hsocket_block", HSOCKET_ERROR_IOCTL, "Socket error: %d", err);
+ return herror_new ("hsocket_block", HSOCKET_ERROR_IOCTL,
+ "Socket error: %d", err);
}
#else /* fcntl(sock, F_SETFL, O_NONBLOCK); */
/* TODO (#1#): check for *nix the non blocking sockets */
@@ -615,5 +673,3 @@ hsocket_block(hsocket_t sock, int block)
#endif
return H_OK;
}
-
-
diff --git a/nanohttp/nanohttp-socket.h b/nanohttp/nanohttp-socket.h
index 7410690..68f6c5b 100644
--- a/nanohttp/nanohttp-socket.h
+++ b/nanohttp/nanohttp-socket.h
@@ -1,5 +1,5 @@
/******************************************************************
- * $Id: nanohttp-socket.h,v 1.18 2006/01/06 15:16:03 mrcsys Exp $
+ * $Id: nanohttp-socket.h,v 1.19 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003 Ferhat Ayaz
@@ -21,8 +21,8 @@
*
* Email: ayaz@jprogrammer.net
******************************************************************/
-#ifndef NANO_HTTP_SOCKET_H
-#define NANO_HTTP_SOCKET_H
+#ifndef NANO_HTTP_SOCKET_H
+#define NANO_HTTP_SOCKET_H
#include <nanohttp/nanohttp-common.h>
@@ -33,25 +33,27 @@
#endif
#ifdef WIN32
- #include <winsock2.h>
+#include <winsock2.h>
#endif
#ifdef WIN32
- typedef struct hsocket_t {
-#ifdef HAVE_SSL
- SSL *ssl;
+typedef struct hsocket_t
+{
+#ifdef HAVE_SSL
+ SSL *ssl;
#endif
- SOCKET sock;
- } hsocket_t;
- typedef int socklen_t;
+ SOCKET sock;
+} hsocket_t;
+typedef int socklen_t;
#else
- typedef struct hsocket_t {
+typedef struct hsocket_t
+{
#ifdef HAVE_SSL
- SSL *ssl;
+ SSL *ssl;
#endif
- int sock;
- } hsocket_t;
+ int sock;
+} hsocket_t;
#endif
@@ -62,14 +64,14 @@
@returns This function should always return H_OK.
*/
-herror_t hsocket_module_init();
+herror_t hsocket_module_init ();
/**
Destroys the socket modul. This should be called after
finishing an application.
*/
-void hsocket_module_destroy();
+void hsocket_module_destroy ();
/**
@@ -80,7 +82,7 @@ void hsocket_module_destroy();
@returns This function should always return H_OK.
*/
-herror_t hsocket_init(hsocket_t *sock );
+herror_t hsocket_init (hsocket_t * sock);
/**
@@ -88,7 +90,7 @@ herror_t hsocket_init(hsocket_t *sock );
@param sock the socket to destroy
*/
-void hsocket_free(hsocket_t sock);
+void hsocket_free (hsocket_t sock);
/**
@@ -104,7 +106,7 @@ void hsocket_free(hsocket_t sock);
<BR>HSOCKET_ERROR_GET_HOSTNAME
<BR>HSOCKET_ERROR_CONNECT
*/
-herror_t hsocket_open(hsocket_t *sock, const char* host, int port);
+herror_t hsocket_open (hsocket_t * sock, const char *host, int port);
/**
@@ -112,7 +114,7 @@ herror_t hsocket_open(hsocket_t *sock, const char* host, int port);
@param sock the socket to close
*/
-void hsocket_close(hsocket_t sock);
+void hsocket_close (hsocket_t sock);
/**
@@ -128,7 +130,7 @@ void hsocket_close(hsocket_t sock);
@see hsocket_listen
*/
-herror_t hsocket_bind(hsocket_t *sock, int port);
+herror_t hsocket_bind (hsocket_t * sock, int port);
/**
@@ -142,7 +144,7 @@ herror_t hsocket_bind(hsocket_t *sock, int port);
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_LISTEN
*/
-herror_t hsocket_listen(hsocket_t sock);
+herror_t hsocket_listen (hsocket_t sock);
/**
@@ -156,7 +158,7 @@ herror_t hsocket_listen(hsocket_t sock);
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_ACCEPT
*/
-herror_t hsocket_accept(hsocket_t sock, hsocket_t *dest);
+herror_t hsocket_accept (hsocket_t sock, hsocket_t * dest);
/**
@@ -170,7 +172,7 @@ herror_t hsocket_accept(hsocket_t sock, hsocket_t *dest);
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_SEND
*/
-herror_t hsocket_nsend(hsocket_t sock, const byte_t* bytes, int size);
+herror_t hsocket_nsend (hsocket_t sock, const byte_t * bytes, int size);
/**
@@ -183,7 +185,7 @@ herror_t hsocket_nsend(hsocket_t sock, const byte_t* bytes, int size);
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_SEND
*/
-herror_t hsocket_send(hsocket_t sock, const char* str);
+herror_t hsocket_send (hsocket_t sock, const char *str);
/**
@@ -202,7 +204,8 @@ herror_t hsocket_send(hsocket_t sock, const char* str);
the socket.
*/
-herror_t hsocket_read(hsocket_t sock, byte_t* buffer, int size, int force, int *readed);
+herror_t hsocket_read (hsocket_t sock, byte_t * buffer, int size, int force,
+ int *readed);
/**
Sets the goven socket to non-blocking socket mode.
@@ -213,18 +216,7 @@ herror_t hsocket_read(hsocket_t sock, byte_t* buffer, int size, int force, int *
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_IOCTL
*/
-herror_t hsocket_block(hsocket_t sock, int block);
+herror_t hsocket_block (hsocket_t sock, int block);
#endif
-
-
-
-
-
-
-
-
-
-
-
diff --git a/nanohttp/nanohttp-ssl.c b/nanohttp/nanohttp-ssl.c
index 766ac98..38b3595 100644
--- a/nanohttp/nanohttp-ssl.c
+++ b/nanohttp/nanohttp-ssl.c
@@ -22,7 +22,7 @@
*/
/* Enter only if --with-ssl was specified to the configure script */
-#ifdef HAVE_SSL
+#ifdef HAVE_SSL
#include <sys/types.h>
#ifndef WIN32
@@ -60,7 +60,7 @@ typedef unsigned int uint32_t;
#define MAXCHUNK 1024
#define HEADER_LEN 5
-char HEADER[HEADER_LEN] = {186, 84, 202, 86, 224};
+char HEADER[HEADER_LEN] = { 186, 84, 202, 86, 224 };
static char *pass;
/*
@@ -69,303 +69,342 @@ static char *pass;
* the SSL random number generator
*/
-void superseed()
+void
+superseed ()
{
- int buf[256], i;
+ int buf[256], i;
- srand(time(NULL));
+ srand (time (NULL));
- for(i = 0; i < 256; i++) {
- buf[i] = rand();
- } RAND_seed( (unsigned char*)buf, sizeof(buf));
+ for (i = 0; i < 256; i++)
+ {
+ buf[i] = rand ();
+ }
+ RAND_seed ((unsigned char *) buf, sizeof (buf));
}
-static int pw_cb(char* buf, int num, int rwflag, void *userdata)
+static int
+pw_cb (char *buf, int num, int rwflag, void *userdata)
{
- if( num < (int)strlen(pass) + 1)
- return(0);
+ if (num < (int) strlen (pass) + 1)
+ return (0);
- strcpy(buf, pass);
- return strlen(pass);
+ strcpy (buf, pass);
+ return strlen (pass);
}
-int verify_sn(X509* cert, int who, int nid, char* str)
+int
+verify_sn (X509 * cert, int who, int nid, char *str)
{
- char name[256];
- char buf[256];
-
- memset(name, '\0', 256);
- memset(buf, '\0', 256);
-
- if(who == CERT_SUBJECT) {
- X509_NAME_oneline(X509_get_subject_name(cert), name, 256);
- } else {
- X509_NAME_oneline(X509_get_issuer_name(cert), name, 256);
- }
-
- buf[0] = '/';
- strcat(buf, OBJ_nid2sn(nid));
- strcat(buf, "=");
- strcat(buf, str);
-
- if(strstr(name, buf)) {
- return 1;
- } else {
- return 0;
- }
+ char name[256];
+ char buf[256];
+
+ memset (name, '\0', 256);
+ memset (buf, '\0', 256);
+
+ if (who == CERT_SUBJECT)
+ {
+ X509_NAME_oneline (X509_get_subject_name (cert), name, 256);
+ }
+ else
+ {
+ X509_NAME_oneline (X509_get_issuer_name (cert), name, 256);
+ }
+
+ buf[0] = '/';
+ strcat (buf, OBJ_nid2sn (nid));
+ strcat (buf, "=");
+ strcat (buf, str);
+
+ if (strstr (name, buf))
+ {
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
}
-static int verify_cb(int prev_ok, X509_STORE_CTX* ctx)
+static int
+verify_cb (int prev_ok, X509_STORE_CTX * ctx)
{
- X509* cert = X509_STORE_CTX_get_current_cert(ctx);
- int depth = X509_STORE_CTX_get_error_depth(ctx);
- int err = X509_STORE_CTX_get_error(ctx);
+ X509 *cert = X509_STORE_CTX_get_current_cert (ctx);
+ int depth = X509_STORE_CTX_get_error_depth (ctx);
+ int err = X509_STORE_CTX_get_error (ctx);
/*
if( err = X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN ){
log_verbose1("Self signed cert in chain");
return 1;
}
*/
-#ifdef NOUSER_VERIFY /* ifdef's added by Ferhat. because of unresolved reference while compiling */
- if(depth == 0) {
- return user_verify(cert);
- } else {
+#ifdef NOUSER_VERIFY /* ifdef's added by Ferhat. because of
+ unresolved reference while compiling */
+ if (depth == 0)
+ {
+ return user_verify (cert);
+ }
+ else
+ {
#endif
- log_verbose1( "Cert ok (prev)" );
- return prev_ok;
+ log_verbose1 ("Cert ok (prev)");
+ return prev_ok;
#ifdef NOUSER_VERIFY
- }
+ }
#endif
}
#ifdef NOUSER_VERIFY
-int user_verify(X509* cert)
-{
- //TODO: Make sure that the client is providing a client cert,
- //or that the Module is providing the Module cert
- /* connect to anyone */
- log_verbose1("Validating certificate.");
- return 1;
-}
+int
+user_verify (X509 * cert)
+{
+ // TODO: Make sure that the client is providing a client cert,
+ // or that the Module is providing the Module cert
+ /* connect to anyone */
+ log_verbose1 ("Validating certificate.");
+ return 1;
+}
#endif
-SSL_CTX *initialize_ctx(char* keyfile, char* password, char* calist)
+SSL_CTX *
+initialize_ctx (char *keyfile, char *password, char *calist)
{
- SSL_CTX* ctx = NULL;
-
- if(password == NULL) password = "";
-
-
- /* Global system initialization */
- log_verbose1( "Initializing library");
- SSL_library_init();
- SSL_load_error_strings();
- ERR_load_crypto_strings();
- OpenSSL_add_ssl_algorithms();
-
- /* Create our context*/
- ctx = SSL_CTX_new( SSLv23_method() );
-
- if(ctx == NULL) {
- log_error1( "Cannot create SSL context");
- return NULL;
- }
- log_verbose1( "SSL context created ok");
-
- /* Load our keys and certificates*/
- if(keyfile != NULL && password != NULL ){
-
- if(!( SSL_CTX_use_certificate_file(ctx, keyfile, SSL_FILETYPE_PEM))){
- log_error2( "Couldn't read certificate file: %s", keyfile);
- SSL_CTX_free(ctx);
- return ctx = NULL;
- }
-
- log_verbose1("Certificate file read ok");
+ SSL_CTX *ctx = NULL;
+
+ if (password == NULL)
+ password = "";
+
+
+ /* Global system initialization */
+ log_verbose1 ("Initializing library");
+ SSL_library_init ();
+ SSL_load_error_strings ();
+ ERR_load_crypto_strings ();
+ OpenSSL_add_ssl_algorithms ();
+
+ /* Create our context */
+ ctx = SSL_CTX_new (SSLv23_method ());
+
+ if (ctx == NULL)
+ {
+ log_error1 ("Cannot create SSL context");
+ return NULL;
+ }
+ log_verbose1 ("SSL context created ok");
+
+ /* Load our keys and certificates */
+ if (keyfile != NULL && password != NULL)
+ {
+
+ if (!(SSL_CTX_use_certificate_file (ctx, keyfile, SSL_FILETYPE_PEM)))
+ {
+ log_error2 ("Couldn't read certificate file: %s", keyfile);
+ SSL_CTX_free (ctx);
+ return ctx = NULL;
+ }
- pass = password;
- SSL_CTX_set_default_passwd_cb(ctx, pw_cb);
+ log_verbose1 ("Certificate file read ok");
- if( !( SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM) ) ) {
- log_error2( "Couldn't read key file: %s", keyfile);
- SSL_CTX_free(ctx);
- return ctx = NULL;
- }
+ pass = password;
+ SSL_CTX_set_default_passwd_cb (ctx, pw_cb);
- log_verbose1("Keyfile read ok");
+ if (!(SSL_CTX_use_PrivateKey_file (ctx, keyfile, SSL_FILETYPE_PEM)))
+ {
+ log_error2 ("Couldn't read key file: %s", keyfile);
+ SSL_CTX_free (ctx);
+ return ctx = NULL;
}
- if( calist != NULL) {
- /* Load the CAs we trust */
- if( !( SSL_CTX_load_verify_locations(ctx, calist, NULL) ) ) {
- log_error2("Couldn't read CA list: %s", calist);
- SSL_CTX_free(ctx);
- return ctx = NULL;
- }
+ log_verbose1 ("Keyfile read ok");
+ }
+ if (calist != NULL)
+ {
+
+ /* Load the CAs we trust */
+ if (!(SSL_CTX_load_verify_locations (ctx, calist, NULL)))
+ {
+ log_error2 ("Couldn't read CA list: %s", calist);
+ SSL_CTX_free (ctx);
+ return ctx = NULL;
+ }
- SSL_CTX_set_client_CA_list( ctx, SSL_load_client_CA_file(calist) );
- log_verbose1("Certificate Authority contacted");
+ SSL_CTX_set_client_CA_list (ctx, SSL_load_client_CA_file (calist));
+ log_verbose1 ("Certificate Authority contacted");
- }
- SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
- verify_cb);
- log_verbose1("Verify callback registered");
+ }
+ SSL_CTX_set_verify (ctx, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,
+ verify_cb);
+ log_verbose1 ("Verify callback registered");
- SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF );
+ SSL_CTX_set_session_cache_mode (ctx, SSL_SESS_CACHE_OFF);
- /* Load randomness */
- superseed();
+ /* Load randomness */
+ superseed ();
- return ctx;
+ return ctx;
}
-void log_ssl_error(SSL* ssl, int ret)
+void
+log_ssl_error (SSL * ssl, int ret)
{
- int errqueue;
- char errorbuf[256] = "Error: ";
-
- if(ret == 0) {
- log_error1("SSL handshake was not successful, contolled shutdown");
- } else if(ret == -1) {
- log_error1("SSL handshake was not successful, fatal error at protocol");
- }
-
- errqueue = SSL_get_error(ssl, ret);
-
- switch(errqueue) {
- case SSL_ERROR_NONE:
- strcat(errorbuf, "None");
- break;
- case SSL_ERROR_ZERO_RETURN:
- strcat(errorbuf, "Zero return");
- break;
- case SSL_ERROR_WANT_READ:
- strcat(errorbuf, "Want read");
- break;
- case SSL_ERROR_WANT_WRITE:
- strcat(errorbuf, "Want write");
- break;
- case SSL_ERROR_WANT_X509_LOOKUP:
- strcat(errorbuf, "Want x509 lookup");
- break;
- case SSL_ERROR_SYSCALL:
- strcat(errorbuf, "Syscall:");
- if(ret == 0) {
- strcat(errorbuf, "Protocol violation");
- } else if(ret == -1) {
- strcat(errorbuf, "BIO reported an I/O error");
- } else {
- strcat(errorbuf, "Unknown syscall error");
- } /* if */
-
- break;
- case SSL_ERROR_SSL:
- strcat(errorbuf, "SSL library");
- while(errqueue=ERR_get_error()){
- log_error2("SSL %s", ERR_error_string(errqueue, NULL));
- }
- break;
- } /* switch code */
-
- log_error1( errorbuf);
+ int errqueue;
+ char errorbuf[256] = "Error: ";
+
+ if (ret == 0)
+ {
+ log_error1 ("SSL handshake was not successful, contolled shutdown");
+ }
+ else if (ret == -1)
+ {
+ log_error1 ("SSL handshake was not successful, fatal error at protocol");
+ }
+
+ errqueue = SSL_get_error (ssl, ret);
+
+ switch (errqueue)
+ {
+ case SSL_ERROR_NONE:
+ strcat (errorbuf, "None");
+ break;
+ case SSL_ERROR_ZERO_RETURN:
+ strcat (errorbuf, "Zero return");
+ break;
+ case SSL_ERROR_WANT_READ:
+ strcat (errorbuf, "Want read");
+ break;
+ case SSL_ERROR_WANT_WRITE:
+ strcat (errorbuf, "Want write");
+ break;
+ case SSL_ERROR_WANT_X509_LOOKUP:
+ strcat (errorbuf, "Want x509 lookup");
+ break;
+ case SSL_ERROR_SYSCALL:
+ strcat (errorbuf, "Syscall:");
+ if (ret == 0)
+ {
+ strcat (errorbuf, "Protocol violation");
+ }
+ else if (ret == -1)
+ {
+ strcat (errorbuf, "BIO reported an I/O error");
+ }
+ else
+ {
+ strcat (errorbuf, "Unknown syscall error");
+ } /* if */
+
+ break;
+ case SSL_ERROR_SSL:
+ strcat (errorbuf, "SSL library");
+ while (errqueue = ERR_get_error ())
+ {
+ log_error2 ("SSL %s", ERR_error_string (errqueue, NULL));
+ }
+ break;
+ } /* switch code */
+
+ log_error1 (errorbuf);
}
-SSL* init_ssl(SSL_CTX* ctx, int sock, int type)
+SSL *
+init_ssl (SSL_CTX * ctx, int sock, int type)
{
- int ret;
- int status;
- SSL* ssl;
+ int ret;
+ int status;
+ SSL *ssl;
#if 0
#ifdef WIN32
- BIO* rbio;
- BIO* wbio;
+ BIO *rbio;
+ BIO *wbio;
#else
- BIO* sbio;
+ BIO *sbio;
#endif
#endif
- log_verbose1("Starting SSL Initialization");
-
- ssl = SSL_new(ctx);
-
- if(ssl == NULL) {
- log_error1( "Cannot create new ssl object");
- return NULL;
- }
+ log_verbose1 ("Starting SSL Initialization");
+
+ ssl = SSL_new (ctx);
+
+ if (ssl == NULL)
+ {
+ log_error1 ("Cannot create new ssl object");
+ return NULL;
+ }
#if 0
#ifdef WIN32
- log_error1("Setting up BIO with socket");
- rbio = BIO_new_socket(sock, BIO_NOCLOSE);
- if( rbio == NULL ) {
- log_error1( "BIO_new_socket failed");
- return NULL;
- }
- SSL_set_bio(ssl, rbio, rbio);
+ log_error1 ("Setting up BIO with socket");
+ rbio = BIO_new_socket (sock, BIO_NOCLOSE);
+ if (rbio == NULL)
+ {
+ log_error1 ("BIO_new_socket failed");
+ return NULL;
+ }
+ SSL_set_bio (ssl, rbio, rbio);
#else
- sbio = BIO_new_socket(sock, BIO_NOCLOSE);
-
- if( sbio == NULL ) {
- log_error1( "BIO_new_socket failed");
- return NULL;
- }
- SSL_set_bio(ssl, sbio, sbio);
+ sbio = BIO_new_socket (sock, BIO_NOCLOSE);
+
+ if (sbio == NULL)
+ {
+ log_error1 ("BIO_new_socket failed");
+ return NULL;
+ }
+ SSL_set_bio (ssl, sbio, sbio);
#endif
#endif
- SSL_set_fd(ssl, sock);
-
- if(type == SSL_SERVER) {
- hsocket_t sock_t;
- sock_t.sock = sock;
- hsocket_block(sock_t, 1);
- ret = SSL_accept(ssl);
- hsocket_block(sock_t, 0);
- if(ret <= 0) {
- log_error1( "SSL accept error");
- log_ssl_error(ssl, ret);
- SSL_free(ssl);
- return ssl = NULL;
- } /* if error */
- } else { /* client */
- ret = SSL_connect(ssl);
- if(ret <= 0) {
- log_error1( "SSL connect error");
- log_ssl_error(ssl, ret);
- SSL_free(ssl);
- return ssl = NULL;
- } /* if error */
- /* SSL_connect should take care of this for us.
- if(SSL_get_peer_certificate(ssl) == NULL) {
- log_error1( "No certificate provided");
- SSL_free(ssl);
- return ssl = NULL;
- }
- if(SSL_get_verify_result(ssl) != X509_V_OK) {
- log_error1( "Certificate did not verify");
- SSL_free(ssl);
- return ssl = NULL;
- }
- */
- }
-
- log_verbose1("Completed SSL Initialization");
- return ssl;
+ SSL_set_fd (ssl, sock);
+
+ if (type == SSL_SERVER)
+ {
+ hsocket_t sock_t;
+ sock_t.sock = sock;
+ hsocket_block (sock_t, 1);
+ ret = SSL_accept (ssl);
+ hsocket_block (sock_t, 0);
+ if (ret <= 0)
+ {
+ log_error1 ("SSL accept error");
+ log_ssl_error (ssl, ret);
+ SSL_free (ssl);
+ return ssl = NULL;
+ } /* if error */
+ }
+ else
+ { /* client */
+ ret = SSL_connect (ssl);
+ if (ret <= 0)
+ {
+ log_error1 ("SSL connect error");
+ log_ssl_error (ssl, ret);
+ SSL_free (ssl);
+ return ssl = NULL;
+ } /* if error */
+ /* SSL_connect should take care of this for us.
+ if(SSL_get_peer_certificate(ssl) == NULL) { log_error1( "No
+ certificate provided"); SSL_free(ssl); return ssl = NULL; }
+ if(SSL_get_verify_result(ssl) != X509_V_OK) { log_error1( "Certificate
+ did not verify"); SSL_free(ssl); return ssl = NULL; } */
+ }
+
+ log_verbose1 ("Completed SSL Initialization");
+ return ssl;
}
-void ssl_cleanup(SSL* ssl)
+void
+ssl_cleanup (SSL * ssl)
{
- /* does nothing to context */
+ /* does nothing to context */
- if(ssl != NULL) {
+ if (ssl != NULL)
+ {
- SSL_shutdown(ssl);
+ SSL_shutdown (ssl);
// SSL_clear(ssl);
- SSL_free(ssl);
- ssl = NULL;
- }
+ SSL_free (ssl);
+ ssl = NULL;
+ }
}
#endif /* end of ifdef HAVE_SSL */
-
diff --git a/nanohttp/nanohttp-ssl.h b/nanohttp/nanohttp-ssl.h
index c783812..449c78c 100644
--- a/nanohttp/nanohttp-ssl.h
+++ b/nanohttp/nanohttp-ssl.h
@@ -23,7 +23,7 @@
*/
/* Do enter only if --with-ssl was specified by the configure script */
-#ifdef HAVE_SSL
+#ifdef HAVE_SSL
#ifdef TRU64
#include <arpa/inet.h>
@@ -47,9 +47,10 @@ typedef unsigned int uint32_t;
#define CERT_SUBJECT 0
#define CERT_ISSUER 1
-typedef struct Con {
- SSL* ssl;
- int sock;
+typedef struct Con
+{
+ SSL *ssl;
+ int sock;
} Con;
/*
@@ -62,7 +63,7 @@ typedef struct Con {
* Initialize the context
*/
-SSL_CTX *initialize_ctx(char *keyfile, char *password, char* calist);
+SSL_CTX *initialize_ctx (char *keyfile, char *password, char *calist);
/*
* Quick function for verifying a portion of the cert
@@ -70,7 +71,7 @@ SSL_CTX *initialize_ctx(char *keyfile, char *password, char* calist);
* returns non-zero if everything went ok
*/
-int verify_sn(X509* cert, int who, int nid, char* str);
+int verify_sn (X509 * cert, int who, int nid, char *str);
/*
* Called by framework for verify
@@ -82,22 +83,21 @@ int verify_sn(X509* cert, int who, int nid, char* str);
* This function MUST be implemented by user client/server code somewhere
*/
-int user_verify(X509* cert);
+int user_verify (X509 * cert);
/*
* Create the ssl socket and return it
* pass in the context and an open socket
*/
-SSL* init_ssl(SSL_CTX* ctx, int sock, int type);
+SSL *init_ssl (SSL_CTX * ctx, int sock, int type);
/*
* Close the ssl connection (socket is still left open)
*/
-void ssl_cleanup();
+void ssl_cleanup ();
#endif
#endif /* HAVE_SSL */
-
diff --git a/nanohttp/nanohttp-stream.c b/nanohttp/nanohttp-stream.c
index 1440e63..7700867 100755
--- a/nanohttp/nanohttp-stream.c
+++ b/nanohttp/nanohttp-stream.c
@@ -1,5 +1,5 @@
/******************************************************************
-* $Id: nanohttp-stream.c,v 1.7 2005/05/27 19:28:16 snowdrop Exp $
+* $Id: nanohttp-stream.c,v 1.8 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -29,7 +29,8 @@
#ifdef MEM_DEBUG
#include <utils/alloc.h>
#endif
-void _log_str(char *fn, char *str, int size)
+void
+_log_str (char *fn, char *str, int size)
{
/* FILE *f = fopen(fn, "ab");
if (!f) f=fopen(fn,"wb");
@@ -47,24 +48,23 @@ HTTP INPUT STREAM
-------------------------------------------------------------------
*/
-static
-int _http_stream_is_content_length(hpair_t *header)
+static int
+_http_stream_is_content_length (hpair_t * header)
{
- return
- hpairnode_get_ignore_case(header, HEADER_CONTENT_LENGTH) != NULL;
+ return hpairnode_get_ignore_case (header, HEADER_CONTENT_LENGTH) != NULL;
}
-static
-int _http_stream_is_chunked(hpair_t *header)
+static int
+_http_stream_is_chunked (hpair_t * header)
{
char *chunked;
- chunked = hpairnode_get_ignore_case(header, HEADER_TRANSFER_ENCODING);
+ chunked = hpairnode_get_ignore_case (header, HEADER_TRANSFER_ENCODING);
if (chunked != NULL)
{
- if (!strcmp(chunked, TRANSFER_ENCODING_CHUNKED))
- {
- return 1;
- }
+ if (!strcmp (chunked, TRANSFER_ENCODING_CHUNKED))
+ {
+ return 1;
+ }
}
return 0;
@@ -73,35 +73,35 @@ int _http_stream_is_chunked(hpair_t *header)
/**
Creates a new input stream.
*/
-http_input_stream_t *http_input_stream_new(hsocket_t sock, hpair_t *header)
+http_input_stream_t *
+http_input_stream_new (hsocket_t sock, hpair_t * header)
{
http_input_stream_t *result;
- char *content_length;
+ char *content_length;
/* Paranoya check */
- /*if (header == NULL)
- return NULL;
- */
+ /* if (header == NULL) return NULL; */
/* Create object */
- result = (http_input_stream_t*)malloc(sizeof(http_input_stream_t));
+ result = (http_input_stream_t *) malloc (sizeof (http_input_stream_t));
result->sock = sock;
result->err = H_OK;
/* Find connection type */
- hpairnode_dump_deep(header);
+ hpairnode_dump_deep (header);
/* Check if Content-type */
- if (_http_stream_is_content_length(header))
+ if (_http_stream_is_content_length (header))
{
- log_verbose1("Stream transfer with 'Content-length'");
- content_length = hpairnode_get_ignore_case(header, HEADER_CONTENT_LENGTH);
- result->content_length = atoi(content_length);
+ log_verbose1 ("Stream transfer with 'Content-length'");
+ content_length =
+ hpairnode_get_ignore_case (header, HEADER_CONTENT_LENGTH);
+ result->content_length = atoi (content_length);
result->received = 0;
- result->type = HTTP_TRANSFER_CONTENT_LENGTH;
+ result->type = HTTP_TRANSFER_CONTENT_LENGTH;
}
/* Check if Chunked */
- else if (_http_stream_is_chunked(header))
+ else if (_http_stream_is_chunked (header))
{
- log_verbose1("Stream transfer with 'chunked'");
+ log_verbose1 ("Stream transfer with 'chunked'");
result->type = HTTP_TRANSFER_CHUNKED;
result->chunk_size = -1;
result->received = -1;
@@ -109,7 +109,7 @@ http_input_stream_t *http_input_stream_new(hsocket_t sock, hpair_t *header)
/* Assume connection close */
else
{
- log_verbose1("Stream transfer with 'Connection: close'");
+ log_verbose1 ("Stream transfer with 'Connection: close'");
result->type = HTTP_TRANSFER_CONNECTION_CLOSE;
result->connection_closed = 0;
result->received = 0;
@@ -122,70 +122,69 @@ http_input_stream_t *http_input_stream_new(hsocket_t sock, hpair_t *header)
This function was added for MIME messages
and for debugging.
*/
-http_input_stream_t *http_input_stream_new_from_file(const char* filename)
+http_input_stream_t *
+http_input_stream_new_from_file (const char *filename)
{
http_input_stream_t *result;
- FILE *fd = fopen(filename, "rb");
+ FILE *fd = fopen (filename, "rb");
- if (fd == NULL)
+ if (fd == NULL)
return NULL;
/* Create object */
- result = (http_input_stream_t*)malloc(sizeof(http_input_stream_t));
+ result = (http_input_stream_t *) malloc (sizeof (http_input_stream_t));
result->type = HTTP_TRANSFER_FILE;
result->fd = fd;
result->deleteOnExit = 0;
- strcpy(result->filename, filename);
+ strcpy (result->filename, filename);
return result;
}
/**
Free input stream
*/
-void http_input_stream_free(http_input_stream_t *stream)
+void
+http_input_stream_free (http_input_stream_t * stream)
{
- if (stream->type == HTTP_TRANSFER_FILE && stream->fd) {
- fclose(stream->fd);
- if (stream->deleteOnExit)
- log_info2("Removing '%s'", stream->filename);
- /*remove(stream->filename);*/
- }
-
- free(stream);
+ if (stream->type == HTTP_TRANSFER_FILE && stream->fd)
+ {
+ fclose (stream->fd);
+ if (stream->deleteOnExit)
+ log_info2 ("Removing '%s'", stream->filename);
+ /* remove(stream->filename); */
+ }
+
+ free (stream);
}
-static
-int _http_input_stream_is_content_length_ready(
- http_input_stream_t *stream)
+static int
+_http_input_stream_is_content_length_ready (http_input_stream_t * stream)
{
return (stream->content_length > stream->received);
}
-static
-int _http_input_stream_is_chunked_ready(
- http_input_stream_t *stream)
+static int
+_http_input_stream_is_chunked_ready (http_input_stream_t * stream)
{
return stream->chunk_size != 0;
}
-static
-int _http_input_stream_is_connection_closed_ready(
- http_input_stream_t *stream)
+static int
+_http_input_stream_is_connection_closed_ready (http_input_stream_t * stream)
{
- return !stream->connection_closed;
+ return !stream->connection_closed;
}
-static
-int _http_input_stream_is_file_ready(
- http_input_stream_t *stream)
+static int
+_http_input_stream_is_file_ready (http_input_stream_t * stream)
{
- return !feof(stream->fd);
+ return !feof (stream->fd);
}
-static
-int _http_input_stream_content_length_read(
- http_input_stream_t *stream, byte_t *dest, int size)
+static int
+_http_input_stream_content_length_read (http_input_stream_t * stream,
+ byte_t * dest, int size)
{
herror_t status;
int read;
@@ -195,8 +194,9 @@ int _http_input_stream_content_length_read(
size = stream->content_length - stream->received;
/* read from socket */
- status = hsocket_read(stream->sock, dest, size, 1, &read);
- if (status != H_OK) {
+ status = hsocket_read (stream->sock, dest, size, 1, &read);
+ if (status != H_OK)
+ {
stream->err = status;
return -1;
}
@@ -205,106 +205,112 @@ int _http_input_stream_content_length_read(
return read;
}
-static
-int _http_input_stream_chunked_read_chunk_size(
- http_input_stream_t *stream)
+static int
+_http_input_stream_chunked_read_chunk_size (http_input_stream_t * stream)
{
- char chunk[25];
+ char chunk[25];
int status, i = 0;
int chunk_size;
herror_t err;
-
+
while (1)
{
- err = hsocket_read(stream->sock, &(chunk[i]), 1, 1, &status);
- if (status != 1) {
- stream->err = herror_new("_http_input_stream_chunked_read_chunk_size",
- GENERAL_INVALID_PARAM, "This should never happens!");
+ err = hsocket_read (stream->sock, &(chunk[i]), 1, 1, &status);
+ if (status != 1)
+ {
+ stream->err = herror_new ("_http_input_stream_chunked_read_chunk_size",
+ GENERAL_INVALID_PARAM,
+ "This should never happens!");
return -1;
- }
+ }
+
+ if (err != H_OK)
+ {
+ log_error4 ("[%d] %s(): %s ", herror_code (err), herror_func (err),
+ herror_message (err));
- if (err != H_OK) {
- log_error4("[%d] %s(): %s ", herror_code(err), herror_func(err), herror_message(err));
-
stream->err = err;
return -1;
}
if (chunk[i] == '\r' || chunk[i] == ';')
{
- chunk[i] = '\0';
+ chunk[i] = '\0';
}
else if (chunk[i] == '\n')
{
- chunk[i] = '\0'; /* double check*/
- chunk_size = strtol(chunk, (char **) NULL, 16); /* hex to dec */
- /*
- log_verbose3("chunk_size: '%s' as dec: '%d'", chunk, chunk_size);
- */
- return chunk_size;
+ chunk[i] = '\0'; /* double check */
+ chunk_size = strtol (chunk, (char **) NULL, 16); /* hex to dec */
+ /*
+ log_verbose3("chunk_size: '%s' as dec: '%d'", chunk, chunk_size); */
+ return chunk_size;
}
-
- if (i == 24) {
- stream->err = herror_new(
- "_http_input_stream_chunked_read_chunk_size", STREAM_ERROR_NO_CHUNK_SIZE,
- "reached max line == %d", i);
- return -1;
+
+ if (i == 24)
+ {
+ stream->err =
+ herror_new ("_http_input_stream_chunked_read_chunk_size",
+ STREAM_ERROR_NO_CHUNK_SIZE, "reached max line == %d", i);
+ return -1;
}
else
- i++;
+ i++;
}
/* this should never happens */
- stream->err = herror_new(
- "_http_input_stream_chunked_read_chunk_size", STREAM_ERROR_NO_CHUNK_SIZE,
- "reached max line == %d", i);
- return -1;
+ stream->err =
+ herror_new ("_http_input_stream_chunked_read_chunk_size",
+ STREAM_ERROR_NO_CHUNK_SIZE, "reached max line == %d", i);
+ return -1;
}
-static
-int _http_input_stream_chunked_read(
- http_input_stream_t *stream, byte_t *dest, int size)
+static int
+_http_input_stream_chunked_read (http_input_stream_t * stream, byte_t * dest,
+ int size)
{
int status, counter;
- int remain, read=0;
+ int remain, read = 0;
char ch;
herror_t err;
while (size > 0)
{
- remain = stream->chunk_size - stream->received ;
+ remain = stream->chunk_size - stream->received;
if (remain == 0 && stream->chunk_size != -1)
{
- /* This is not the first chunk.
- so skip new line until chunk size string */
- counter = 100; /* maximum for stop infinity */
- while (1)
+ /* This is not the first chunk. so skip new line until chunk size
+ string */
+ counter = 100; /* maximum for stop infinity */
+ while (1)
+ {
+ err = hsocket_read (stream->sock, &ch, 1, 1, &status);
+
+ if (err != H_OK)
{
- err = hsocket_read(stream->sock, &ch, 1, 1, &status );
-
- if (err != H_OK) {
- stream->err = err;
- return -1;
- }
-
- if (ch == '\n')
- {
- break;
- }
- if (counter-- == 0) {
- stream->err = herror_new("_http_input_stream_chunked_read",
- STREAM_ERROR_WRONG_CHUNK_SIZE,"Wrong chunk-size");
- return -1;
- }
+ stream->err = err;
+ return -1;
}
+
+ if (ch == '\n')
+ {
+ break;
+ }
+ if (counter-- == 0)
+ {
+ stream->err = herror_new ("_http_input_stream_chunked_read",
+ STREAM_ERROR_WRONG_CHUNK_SIZE,
+ "Wrong chunk-size");
+ return -1;
+ }
+ }
}
if (remain == 0)
{
/* receive new chunk size */
- stream->chunk_size =
- _http_input_stream_chunked_read_chunk_size(stream);
+ stream->chunk_size =
+ _http_input_stream_chunked_read_chunk_size (stream);
stream->received = 0;
if (stream->chunk_size < 0)
@@ -323,27 +329,35 @@ int _http_input_stream_chunked_read(
if (remain < size)
{
/* read from socket */
- err = hsocket_read(stream->sock, &(dest[read]), remain, 1, &status);
- if (err != H_OK) {
+ err = hsocket_read (stream->sock, &(dest[read]), remain, 1, &status);
+ if (err != H_OK)
+ {
stream->err = err;
return -1;
}
- if (status != remain) {
- stream->err = herror_new("_http_input_stream_chunked_read",
- GENERAL_INVALID_PARAM, "This should never happens(remain=%d)(status=%d)!", remain, status);
- return -1;
- }
+ if (status != remain)
+ {
+ stream->err = herror_new ("_http_input_stream_chunked_read",
+ GENERAL_INVALID_PARAM,
+ "This should never happens(remain=%d)(status=%d)!",
+ remain, status);
+ return -1;
+ }
}
else
{
/* read from socket */
- err = hsocket_read(stream->sock, &(dest[read]), size, 1, &status);
- if (status != size) {
- stream->err = herror_new("_http_input_stream_chunked_read",
- GENERAL_INVALID_PARAM, "This should never happens(size=%d)(status=%d)!", size, status);
- return -1;
- }
- if (err != H_OK) {
+ err = hsocket_read (stream->sock, &(dest[read]), size, 1, &status);
+ if (status != size)
+ {
+ stream->err = herror_new ("_http_input_stream_chunked_read",
+ GENERAL_INVALID_PARAM,
+ "This should never happens(size=%d)(status=%d)!",
+ size, status);
+ return -1;
+ }
+ if (err != H_OK)
+ {
stream->err = err;
return -1;
}
@@ -358,16 +372,17 @@ int _http_input_stream_chunked_read(
}
-static
-int _http_input_stream_connection_closed_read(
- http_input_stream_t *stream, byte_t *dest, int size)
+static int
+_http_input_stream_connection_closed_read (http_input_stream_t * stream,
+ byte_t * dest, int size)
{
int status;
herror_t err;
/* read from socket */
- err = hsocket_read(stream->sock, dest, size, 0, &status );
- if (err != H_OK) {
+ err = hsocket_read (stream->sock, dest, size, 0, &status);
+ if (err != H_OK)
+ {
stream->err = err;
return -1;
}
@@ -376,20 +391,21 @@ int _http_input_stream_connection_closed_read(
stream->connection_closed = 1;
stream->received += status;
- _log_str("stream.in", dest, size);
+ _log_str ("stream.in", dest, size);
return status;
}
-static
-int _http_input_stream_file_read(
- http_input_stream_t *stream, byte_t *dest, int size)
+static int
+_http_input_stream_file_read (http_input_stream_t * stream, byte_t * dest,
+ int size)
{
int readed;
-
- readed = fread(dest, 1, size, stream->fd);
- if (readed == -1) {
- stream->err = herror_new("_http_input_stream_file_read",
- HSOCKET_ERROR_RECEIVE, "fread() returned -1");
+
+ readed = fread (dest, 1, size, stream->fd);
+ if (readed == -1)
+ {
+ stream->err = herror_new ("_http_input_stream_file_read",
+ HSOCKET_ERROR_RECEIVE, "fread() returned -1");
return -1;
}
@@ -399,7 +415,8 @@ int _http_input_stream_file_read(
/**
Returns the actual status of the stream.
*/
-int http_input_stream_is_ready(http_input_stream_t *stream)
+int
+http_input_stream_is_ready (http_input_stream_t * stream)
{
/* paranoya check */
if (stream == NULL)
@@ -410,16 +427,16 @@ int http_input_stream_is_ready(http_input_stream_t *stream)
switch (stream->type)
{
- case HTTP_TRANSFER_CONTENT_LENGTH:
- return _http_input_stream_is_content_length_ready(stream);
- case HTTP_TRANSFER_CHUNKED:
- return _http_input_stream_is_chunked_ready(stream);
- case HTTP_TRANSFER_CONNECTION_CLOSE:
- return _http_input_stream_is_connection_closed_ready(stream);
- case HTTP_TRANSFER_FILE:
- return _http_input_stream_is_file_ready(stream);
- default:
- return 0;
+ case HTTP_TRANSFER_CONTENT_LENGTH:
+ return _http_input_stream_is_content_length_ready (stream);
+ case HTTP_TRANSFER_CHUNKED:
+ return _http_input_stream_is_chunked_ready (stream);
+ case HTTP_TRANSFER_CONNECTION_CLOSE:
+ return _http_input_stream_is_connection_closed_ready (stream);
+ case HTTP_TRANSFER_FILE:
+ return _http_input_stream_is_file_ready (stream);
+ default:
+ return 0;
}
}
@@ -428,36 +445,38 @@ int http_input_stream_is_ready(http_input_stream_t *stream)
Returns the actual read bytes
<0 on error
*/
-int http_input_stream_read(http_input_stream_t *stream,
- byte_t *dest, int size)
+int
+http_input_stream_read (http_input_stream_t * stream, byte_t * dest, int size)
{
- int readed=0;
+ int readed = 0;
/* paranoya check */
- if (stream == NULL) {
+ if (stream == NULL)
+ {
return -1;
}
-
+
/* reset error flag */
stream->err = H_OK;
switch (stream->type)
{
- case HTTP_TRANSFER_CONTENT_LENGTH:
- readed=_http_input_stream_content_length_read(stream, dest, size);
- break;
- case HTTP_TRANSFER_CHUNKED:
- readed=_http_input_stream_chunked_read(stream, dest, size);
- break;
- case HTTP_TRANSFER_CONNECTION_CLOSE:
- readed=_http_input_stream_connection_closed_read(stream, dest, size);
- break;
- case HTTP_TRANSFER_FILE:
- readed=_http_input_stream_file_read(stream, dest, size);
- break;
- default:
- stream->err = herror_new("http_input_stream_read",
- STREAM_ERROR_INVALID_TYPE, "%d is invalid stream type", stream->type);
- return -1;
+ case HTTP_TRANSFER_CONTENT_LENGTH:
+ readed = _http_input_stream_content_length_read (stream, dest, size);
+ break;
+ case HTTP_TRANSFER_CHUNKED:
+ readed = _http_input_stream_chunked_read (stream, dest, size);
+ break;
+ case HTTP_TRANSFER_CONNECTION_CLOSE:
+ readed = _http_input_stream_connection_closed_read (stream, dest, size);
+ break;
+ case HTTP_TRANSFER_FILE:
+ readed = _http_input_stream_file_read (stream, dest, size);
+ break;
+ default:
+ stream->err = herror_new ("http_input_stream_read",
+ STREAM_ERROR_INVALID_TYPE,
+ "%d is invalid stream type", stream->type);
+ return -1;
}
return readed;
@@ -477,40 +496,42 @@ HTTP OUTPUT STREAM
/**
Creates a new output stream. Transfer code will be found from header.
*/
-http_output_stream_t *http_output_stream_new(hsocket_t sock, hpair_t *header)
+http_output_stream_t *
+http_output_stream_new (hsocket_t sock, hpair_t * header)
{
http_output_stream_t *result;
- char *content_length;
+ char *content_length;
/* Paranoya check */
/* if (header == NULL)
return NULL;
*/
/* Create object */
- result = (http_output_stream_t*)malloc(sizeof(http_output_stream_t));
+ result = (http_output_stream_t *) malloc (sizeof (http_output_stream_t));
result->sock = sock;
result->sent = 0;
/* Find connection type */
-
+
/* Check if Content-type */
- if (_http_stream_is_content_length(header))
+ if (_http_stream_is_content_length (header))
{
- log_verbose1("Stream transfer with 'Content-length'");
- content_length = hpairnode_get_ignore_case(header, HEADER_CONTENT_LENGTH);
- result->content_length = atoi(content_length);
- result->type = HTTP_TRANSFER_CONTENT_LENGTH;
+ log_verbose1 ("Stream transfer with 'Content-length'");
+ content_length =
+ hpairnode_get_ignore_case (header, HEADER_CONTENT_LENGTH);
+ result->content_length = atoi (content_length);
+ result->type = HTTP_TRANSFER_CONTENT_LENGTH;
}
/* Check if Chunked */
- else if (_http_stream_is_chunked(header))
+ else if (_http_stream_is_chunked (header))
{
- log_verbose1("Stream transfer with 'chunked'");
+ log_verbose1 ("Stream transfer with 'chunked'");
result->type = HTTP_TRANSFER_CHUNKED;
}
/* Assume connection close */
else
{
- log_verbose1("Stream transfer with 'Connection: close'");
+ log_verbose1 ("Stream transfer with 'Connection: close'");
result->type = HTTP_TRANSFER_CONNECTION_CLOSE;
}
@@ -520,42 +541,44 @@ http_output_stream_t *http_output_stream_new(hsocket_t sock, hpair_t *header)
/**
Free output stream
*/
-void http_output_stream_free(http_output_stream_t *stream)
+void
+http_output_stream_free (http_output_stream_t * stream)
{
- free(stream);
+ free (stream);
}
/**
Writes 'size' bytes of 'bytes' into stream.
Returns socket error flags or H_OK.
*/
-herror_t http_output_stream_write(http_output_stream_t *stream,
- const byte_t *bytes, int size)
+herror_t
+http_output_stream_write (http_output_stream_t * stream,
+ const byte_t * bytes, int size)
{
herror_t status;
char chunked[15];
if (stream->type == HTTP_TRANSFER_CHUNKED)
{
- sprintf(chunked, "%x\r\n", size);
- status = hsocket_send(stream->sock, chunked);
+ sprintf (chunked, "%x\r\n", size);
+ status = hsocket_send (stream->sock, chunked);
if (status != H_OK)
- return status;
+ return status;
}
if (size > 0)
{
- _log_str("stream.out", (char*)bytes, size);
- status = hsocket_nsend(stream->sock, bytes, size);
+ _log_str ("stream.out", (char *) bytes, size);
+ status = hsocket_nsend (stream->sock, bytes, size);
if (status != H_OK)
- return status;
+ return status;
}
- if (stream->type == HTTP_TRANSFER_CHUNKED)
+ if (stream->type == HTTP_TRANSFER_CHUNKED)
{
- status = hsocket_send(stream->sock, "\r\n");
+ status = hsocket_send (stream->sock, "\r\n");
if (status != H_OK)
- return status;
+ return status;
}
return H_OK;
@@ -565,29 +588,25 @@ herror_t http_output_stream_write(http_output_stream_t *stream,
Writes 'strlen()' bytes of 'str' into stream.
Returns socket error flags or H_OK.
*/
-herror_t http_output_stream_write_string(http_output_stream_t *stream,
- const char *str)
+herror_t
+http_output_stream_write_string (http_output_stream_t * stream,
+ const char *str)
{
- return http_output_stream_write(stream, str, strlen(str));
+ return http_output_stream_write (stream, str, strlen (str));
}
-herror_t http_output_stream_flush(http_output_stream_t *stream)
+herror_t
+http_output_stream_flush (http_output_stream_t * stream)
{
herror_t status;
if (stream->type == HTTP_TRANSFER_CHUNKED)
{
- status = hsocket_send(stream->sock, "0\r\n\r\n");
+ status = hsocket_send (stream->sock, "0\r\n\r\n");
if (status != H_OK)
- return status;
+ return status;
}
- return H_OK;
+ return H_OK;
}
-
-
-
-
-
-
diff --git a/nanohttp/nanohttp-stream.h b/nanohttp/nanohttp-stream.h
index d0a234a..2ef12a2 100755
--- a/nanohttp/nanohttp-stream.h
+++ b/nanohttp/nanohttp-stream.h
@@ -1,5 +1,5 @@
/******************************************************************
- * $Id: nanohttp-stream.h,v 1.5 2004/11/02 23:09:27 snowdrop Exp $
+ * $Id: nanohttp-stream.h,v 1.6 2006/01/10 11:21:55 snowdrop Exp $
*
* CSOAP Project: A http client/server library in C
* Copyright (C) 2003-2004 Ferhat Ayaz
@@ -21,11 +21,11 @@
*
* Email: ferhatayaz@yahoo.com
******************************************************************/
-#ifndef NANO_HTTP_STREAM_H
-#define NANO_HTTP_STREAM_H
+#ifndef NANO_HTTP_STREAM_H
+#define NANO_HTTP_STREAM_H
#include <stdio.h>
-void _log_str(char *fn, char *str, int size);
+void _log_str (char *fn, char *str, int size);
/*
HTTP Stream modul:
@@ -77,8 +77,7 @@ typedef enum http_transfer_type
/** This transfer style will be used by MIME support
and for debug purposes.*/
HTTP_TRANSFER_FILE
-
-}http_transfer_type_t;
+} http_transfer_type_t;
/**
@@ -87,9 +86,9 @@ typedef enum http_transfer_type
*/
typedef struct http_input_stream
{
- hsocket_t sock;
+ hsocket_t sock;
herror_t err;
- http_transfer_type_t type;
+ http_transfer_type_t type;
int received;
int content_length;
int chunk_size;
@@ -98,8 +97,8 @@ typedef struct http_input_stream
/* file handling */
FILE *fd;
char filename[255];
- int deleteOnExit; /* default is 0 */
-}http_input_stream_t;
+ int deleteOnExit; /* default is 0 */
+} http_input_stream_t;
/**
@@ -109,10 +108,10 @@ typedef struct http_input_stream
typedef struct http_output_stream
{
hsocket_t sock;
- http_transfer_type_t type;
+ http_transfer_type_t type;
int content_length;
int sent;
-}http_output_stream_t;
+} http_output_stream_t;
/*
@@ -135,7 +134,7 @@ typedef struct http_output_stream
@see http_input_stream_free
*/
-http_input_stream_t *http_input_stream_new(hsocket_t sock, hpair_t *header);
+http_input_stream_t *http_input_stream_new (hsocket_t sock, hpair_t * header);
/**
@@ -151,7 +150,7 @@ http_input_stream_t *http_input_stream_new(hsocket_t sock, hpair_t *header);
@see http_input_stream_free
*/
-http_input_stream_t *http_input_stream_new_from_file(const char* filename);
+http_input_stream_t *http_input_stream_new_from_file (const char *filename);
/**
@@ -160,7 +159,7 @@ http_input_stream_t *http_input_stream_new_from_file(const char* filename);
@param stream the input stream to free.
*/
-void http_input_stream_free(http_input_stream_t *stream);
+void http_input_stream_free (http_input_stream_t * stream);
/**
@@ -170,7 +169,7 @@ void http_input_stream_free(http_input_stream_t *stream);
@returns <br>1 if there are still data to read.
<br>0 if no more data exists.
*/
-int http_input_stream_is_ready(http_input_stream_t *stream);
+int http_input_stream_is_ready (http_input_stream_t * stream);
/**
@@ -194,8 +193,8 @@ int http_input_stream_is_ready(http_input_stream_t *stream);
@returns the actual readed bytes or -1 on error.
*/
-int http_input_stream_read(http_input_stream_t *stream,
- byte_t *dest, int size);
+int http_input_stream_read (http_input_stream_t * stream,
+ byte_t * dest, int size);
/*
@@ -217,7 +216,8 @@ int http_input_stream_read(http_input_stream_t *stream,
@see http_output_stream_free
*/
-http_output_stream_t *http_output_stream_new(hsocket_t sock, hpair_t *header);
+http_output_stream_t *http_output_stream_new (hsocket_t sock,
+ hpair_t * header);
/**
@@ -226,7 +226,7 @@ http_output_stream_t *http_output_stream_new(hsocket_t sock, hpair_t *header);
@param stream the stream to free.
*/
-void http_output_stream_free(http_output_stream_t *stream);
+void http_output_stream_free (http_output_stream_t * stream);
/**
@@ -240,8 +240,8 @@ void http_output_stream_free(http_output_stream_t *stream);
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_SEND
*/
-herror_t http_output_stream_write(http_output_stream_t *stream,
- const byte_t *bytes, int size);
+herror_t http_output_stream_write (http_output_stream_t * stream,
+ const byte_t * bytes, int size);
/**
Writes a null terminated string to the stream.
@@ -253,8 +253,8 @@ herror_t http_output_stream_write(http_output_stream_t *stream,
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_SEND
*/
-herror_t http_output_stream_write_string(http_output_stream_t *stream,
- const char *str);
+herror_t http_output_stream_write_string (http_output_stream_t * stream,
+ const char *str);
/**
@@ -267,12 +267,6 @@ herror_t http_output_stream_write_string(http_output_stream_t *stream,
<BR>HSOCKET_ERROR_NOT_INITIALIZED
<BR>HSOCKET_ERROR_SEND
*/
-herror_t http_output_stream_flush(http_output_stream_t *stream);
+herror_t http_output_stream_flush (http_output_stream_t * stream);
#endif
-
-
-
-
-
-
© 2009-2020 sukimashita.com - Generated by cgit - Icons from Tango - Uses Google Analytics