dany/ant-http
1
0
Fork 0
mirror of https://github.com/lxsang/ant-http synced 2024-11-18 01:08:21 +01:00
Code Issues Actions Projects Releases Wiki Activity
dad3b25fc8
ant-http/lib/handle.c

856 lines
23 KiB
C
Raw Normal View History

add h2 implement
2020-01-15 18:27:28 +01:00
#include "handle.h"
new api
2019-12-15 12:10:06 +01:00
#define HTML_TPL "<HTML><HEAD><TITLE>%s</TITLE></HEAD><BODY><h2>%s</h2></BODY></HTML>"
use static const constant string
2019-12-15 15:04:37 +01:00
static const char* S_100 = "Continue";
static const char* S_101 = "Switching Protocols";
static const char* S_102 = "Processing";
static const char* S_103 = "Early Hints";
static const char* S_200 = "OK";
static const char* S_201 = "Created";
static const char* S_202 = "Accepted";
static const char* S_203 = "Non-Authoritative Information";
static const char* S_204 = "No Content";
static const char* S_205 = "Reset Content";
static const char* S_206 = "Partial Content";
static const char* S_207 = "Multi-Status";
static const char* S_208 = "Already Reported";
static const char* S_226 = "IM Used";
static const char* S_300 = "Multiple Choices";
static const char* S_301 = "Moved Permanently";
static const char* S_302 = "Found";
static const char* S_303 = "See Other";
static const char* S_304 = "Not Modified";
static const char* S_305 = "Use Proxy";
static const char* S_306 = "Switch Proxy";
static const char* S_307 = "Temporary Redirect";
static const char* S_308 = "Permanent Redirect";
static const char* S_400 = "Bad Request";
static const char* S_401 = "Unauthorized";
static const char* S_402 = "Payment Required";
static const char* S_403 = "Forbidden";
static const char* S_404 = "Not Found";
static const char* S_405 = "Method Not Allowed";
static const char* S_406 = "Not Acceptable";
static const char* S_407 = "Proxy Authentication Required";
static const char* S_408 = "Request Timeout";
static const char* S_409 = "Conflict";
static const char* S_410 = "Gone";
static const char* S_411 = "Length Required";
static const char* S_412 = "Precondition Failed";
static const char* S_413 = "Payload Too Large";
static const char* S_414 = "URI Too Long";
static const char* S_415 = "Unsupported Media Type";
static const char* S_416 = "Range Not Satisfiable";
static const char* S_417 = "Expectation Failed";
static const char* S_421 = "Misdirected Request";
static const char* S_422 = "Unprocessable Entity";
static const char* S_423 = "Locked";
static const char* S_424 = "Failed Dependency";
static const char* S_425 = "Too Early";
static const char* S_426 = "Upgrade Required";
static const char* S_428 = "Precondition Required";
static const char* S_429 = "Too Many Requests";
static const char* S_431 = "Request Header Fields Too Large";
static const char* S_451 = "Unavailable For Legal Reasons";
static const char* S_500 = "Internal Server Error";
static const char* S_501 = "Not Implemented";
static const char* S_502 = "Bad Gateway";
static const char* S_503 = "Service Unavailable";
static const char* S_504 = "Gateway Timeout";
static const char* S_505 = "HTTP Version Not Supported";
static const char* S_506 = "Variant Also Negotiates";
static const char* S_507 = "Insufficient Storage";
static const char* S_508 = "Loop Detected";
static const char* S_510 = "Not Extended";
static const char* S_511 = "Network Authentication Required";
static const char* S_UNOF = "Unofficial Status";
using shared library for common api
2017-07-29 22:00:34 +02:00
alow a plugin to require other plugin
2020-01-03 10:14:04 +01:00
int require_plugin(const char* name)
{
UNUSED(name);
return 0;
}
fix
2020-01-08 19:17:51 +01:00
int compressable(char* ctype)
{
UNUSED(ctype);
return 0;
}
void htdocs(antd_request_t* rq, char* dest)
{
dictionary_t xheader = (dictionary_t)dvalue(rq->request, "REQUEST_HEADER");
char* www = (char*)dvalue(xheader, "SERVER_WWW_ROOT");
if(www)
{
strcpy(dest,www);
}
}
void dbdir(char* dest)
{
UNUSED(dest);
}
void tmpdir(char* dest)
{
UNUSED(dest);
}
void plugindir(char* dest)
{
UNUSED(dest);
}
cont
2020-01-29 17:09:16 +01:00
void antd_schedule_task(antd_task_t* task)
{
UNUSED(task);
}
new api
2019-12-15 12:10:06 +01:00
const char* get_status_str(int stat)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
new api
2019-12-15 12:10:06 +01:00
switch(stat)
{
use static const constant string
2019-12-15 15:04:37 +01:00
case 100: return S_100;
case 101: return S_101;
case 102: return S_102;
case 103: return S_103;
new api
2019-12-15 12:10:06 +01:00
use static const constant string
2019-12-15 15:04:37 +01:00
case 200: return S_200;
case 201: return S_201;
case 202: return S_202;
case 203: return S_203;
case 204: return S_204;
case 205: return S_205;
case 206: return S_206;
case 207: return S_207;
case 208: return S_208;
case 226: return S_226;
new api
2019-12-15 12:10:06 +01:00
use static const constant string
2019-12-15 15:04:37 +01:00
case 300: return S_300;
case 301: return S_301;
case 302: return S_302;
case 303: return S_303;
case 304: return S_304;
case 305: return S_305;
case 306: return S_306;
case 307: return S_307;
case 308: return S_308;
new api
2019-12-15 12:10:06 +01:00
use static const constant string
2019-12-15 15:04:37 +01:00
case 400: return S_400;
case 401: return S_401;
case 402: return S_402;
case 403: return S_403;
case 404: return S_404;
case 405: return S_405;
case 406: return S_406;
case 407: return S_407;
case 408: return S_408;
case 409: return S_409;
case 410: return S_410;
case 411: return S_411;
case 412: return S_412;
case 413: return S_413;
case 414: return S_414;
case 415: return S_415;
case 416: return S_416;
case 417: return S_417;
case 421: return S_421;
case 422: return S_422;
case 423: return S_423;
case 424: return S_424;
case 425: return S_425;
case 426: return S_426;
case 428: return S_428;
case 429: return S_429;
case 431: return S_431;
case 451: return S_451;
new api
2019-12-15 12:10:06 +01:00
use static const constant string
2019-12-15 15:04:37 +01:00
case 500: return S_500;
case 501: return S_501;
case 502: return S_502;
case 503: return S_503;
case 504: return S_504;
case 505: return S_505;
case 506: return S_506;
case 507: return S_507;
case 508: return S_508;
case 510: return S_510;
case 511: return S_511;
default: return S_UNOF;
new api
2019-12-15 12:10:06 +01:00
}
using shared library for common api
2017-07-29 22:00:34 +02:00
}
new api
2019-12-15 12:10:06 +01:00
fix
2020-01-08 19:17:51 +01:00
void antd_send_header(void* cl, antd_response_header_t* res)
new api
2019-12-15 12:10:06 +01:00
{
if(!res->header)
res->header = dict();
fix
2020-01-08 19:17:51 +01:00
antd_client_t* client = (antd_client_t*) cl;
#ifdef USE_ZLIB
allow copress body with zlib
2020-01-08 22:04:10 +01:00
antd_compress_t current_zlevel = client->z_level;
fix
2020-01-08 19:17:51 +01:00
char* str = dvalue(res->header,"Content-Encoding");
if(!str)
add header verify
2020-01-09 12:18:59 +01:00
{
fix
2020-01-08 19:17:51 +01:00
// check for compress
str = dvalue(res->header,"Content-Type");
if(str)
{
allow copress body with zlib
2020-01-08 22:04:10 +01:00
if(compressable(str) && client->z_level != ANTD_CNONE)
fix
2020-01-08 19:17:51 +01:00
{
allow copress body with zlib
2020-01-08 22:04:10 +01:00
client->zstream = (z_stream *) malloc(sizeof(z_stream));
if(client->zstream)
fix
2020-01-08 19:17:51 +01:00
{
allow copress body with zlib
2020-01-08 22:04:10 +01:00
((z_stream*)client->zstream)->zalloc = Z_NULL;
((z_stream*)client->zstream)->zfree = Z_NULL;
((z_stream*)client->zstream)->opaque = Z_NULL;
if(client->z_level == ANTD_CGZ)
fix
2020-01-08 19:17:51 +01:00
{
if(deflateInit2(client->zstream,Z_BEST_COMPRESSION,Z_DEFLATED,15 | 16, 8,Z_DEFAULT_STRATEGY) != Z_OK)
{
ERROR("Cannot init gzip stream");
free(client->zstream);
client->zstream = NULL;
}
else
{
add h2 implement
2020-01-15 18:27:28 +01:00
//client->status = Z_NO_FLUSH;
fix
2020-01-08 19:17:51 +01:00
dput(res->header,"Content-Encoding", strdup("gzip"));
}
}
allow copress body with zlib
2020-01-08 22:04:10 +01:00
else
fix
2020-01-08 19:17:51 +01:00
{
if(deflateInit(client->zstream, Z_BEST_COMPRESSION) != Z_OK)
{
ERROR("Cannot init deflate stream");
free(client->zstream);
client->zstream = NULL;
}
else
{
add h2 implement
2020-01-15 18:27:28 +01:00
//client->status = Z_NO_FLUSH;
fix
2020-01-08 19:17:51 +01:00
dput(res->header,"Content-Encoding", strdup("deflate"));
}
}
}
}
}
}
allow copress body with zlib
2020-01-08 22:04:10 +01:00
client->z_level = ANTD_CNONE;
fix
2020-01-08 19:17:51 +01:00
#endif
new api
2019-12-15 12:10:06 +01:00
dput(res->header,"Server", strdup(SERVER_NAME));
const char* stat_str = get_status_str(res->status);
__t(client, "HTTP/1.1 %d %s", res->status, stat_str);
chain_t it;
for_each_assoc(it, res->header)
{
__t(client,"%s: %s", it->key, (const char*)it->value);
}
// send out cookie
if(res->cookie)
{
fix list
2019-12-22 17:33:35 +01:00
item_t el;
list_for_each(el, res->cookie)
new api
2019-12-15 12:10:06 +01:00
{
fix list
2019-12-22 17:33:35 +01:00
if(el->type == LIST_TYPE_POINTER && el->value.ptr)
{
__t(client,"Set-Cookie: %s", (char*)el->value.ptr);
}
new api
2019-12-15 12:10:06 +01:00
}
list_free(&res->cookie);
res->cookie = NULL;
}
__b(client, (unsigned char*)"\r\n", 2);
allow copress body with zlib
2020-01-08 22:04:10 +01:00
#ifdef USE_ZLIB
client->z_level = current_zlevel;
#endif
new api
2019-12-15 12:10:06 +01:00
freedict(res->header);
res->header = NULL;
using shared library for common api
2017-07-29 22:00:34 +02:00
}
new api
2019-12-15 12:10:06 +01:00
/*
bug every where
2018-02-10 11:22:41 +01:00
void octstream(void* client, char* name)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
set_status(client,200,"OK");
__t(client,"Content-Type: application/octet-stream");
__t(client,"Content-Disposition: attachment; filename=\"%s\"", name);
response(client,"");
//Content-Disposition: attachment; filename="fname.ext"
new api
2019-12-15 12:10:06 +01:00
}*/
using shared library for common api
2017-07-29 22:00:34 +02:00
fix
2020-01-08 19:17:51 +01:00
int antd_send(void *src, const void* data_in, int len_in)
{
uint8_t* data = (uint8_t*)data_in;
int len = len_in;
bug every where
2018-02-10 11:22:41 +01:00
antd_client_t * source = (antd_client_t *) src;
fix
2020-01-08 19:17:51 +01:00
#ifdef USE_ZLIB
add h2 implement
2020-01-15 18:27:28 +01:00
int status = (source->flags & CLIENT_FL_COMPRESSION_END)?Z_NO_FLUSH:Z_FINISH;
fix
2020-01-08 19:17:51 +01:00
if(source->zstream && source->z_level != ANTD_CNONE)
{
allow copress body with zlib
2020-01-08 22:04:10 +01:00
antd_compress_t current_zlevel = source->z_level;
source->z_level = ANTD_CNONE;
uint8_t buf[BUFFLEN];
z_stream* zstream = (z_stream*) source->zstream;
zstream->avail_in = (uInt)len;
zstream->next_in = (Bytef *)data_in;
len = 0;
int have = 0;
do
fix
2020-01-08 19:17:51 +01:00
{
allow copress body with zlib
2020-01-08 22:04:10 +01:00
zstream->avail_out = BUFFLEN;
zstream->next_out = buf;
add h2 implement
2020-01-15 18:27:28 +01:00
if(deflate(zstream,status) == Z_STREAM_ERROR)
allow copress body with zlib
2020-01-08 22:04:10 +01:00
{
source->z_level = current_zlevel;
data = NULL;
return -1;
}
else
{
have = BUFFLEN - zstream->avail_out;
antd_send(source, buf, have);
len += have;
}
} while(zstream->avail_out == 0);
source->z_level = current_zlevel;
return len;
fix
2020-01-08 19:17:51 +01:00
}
#endif
if(!src || !data)
allow copress body with zlib
2020-01-08 22:04:10 +01:00
{
fix
2020-01-08 19:17:51 +01:00
return -1;
}
allow copress body with zlib
2020-01-08 22:04:10 +01:00
fix
2020-01-08 19:17:51 +01:00
int written;
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
char* ptr;
new api
2019-12-15 12:10:06 +01:00
int writelen = 0;
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
int count;
fix
2020-01-08 19:17:51 +01:00
bug every where
2018-02-10 11:22:41 +01:00
#ifdef USE_OPENSSL
cont
2020-01-29 17:09:16 +01:00
if(source->stream)
bug every where
2018-02-10 11:22:41 +01:00
{
ssl alpha support
2018-02-10 12:24:01 +01:00
//LOG("SSL WRITE\n");
minor fix
2018-10-09 17:24:00 +02:00
//ret = SSL_write((SSL*) source->ssl, data, len);
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
ptr = (char* )data;
writelen = len > BUFFLEN?BUFFLEN:len;
minor fix
2018-10-09 17:24:00 +02:00
written = 0;
fd_set fds;
struct timeval timeout;
use heavy task by default
2018-10-15 12:28:04 +02:00
while (writelen > 0) //source->attempt < MAX_ATTEMPT
minor fix
2018-10-09 17:24:00 +02:00
{
add ssl debug info
2019-12-13 09:52:28 +01:00
// clear the error queue
ERR_clear_error();
cont
2020-01-29 17:09:16 +01:00
count = SSL_write (source->stream, ptr+written, writelen);
int err = SSL_get_error(source->stream, count);
minor fix
2018-10-09 17:24:00 +02:00
if (count > 0)
{
written += count;
writelen = (len - written) > BUFFLEN?BUFFLEN:(len-written);
add timeout to io read write
2019-12-21 15:02:33 +01:00
time(&source->last_io);
minor fix
2018-10-09 17:24:00 +02:00
}
else
{
add timeout to io read write
2019-12-21 15:02:33 +01:00
if(difftime( time(NULL), source->last_io) > MAX_IO_WAIT_TIME)
{
if(written == 0)
written = count;
break;
}
minor fix
2018-10-09 17:24:00 +02:00
//printf(" received equal to or less than 0\n")
switch (err)
{
case SSL_ERROR_NONE:
{
// no real error, just try again...
//LOG("SSL_ERROR_NONE \n");
use heavy task by default
2018-10-15 12:28:04 +02:00
//source->attempt++;
minor fix
2018-10-09 17:24:00 +02:00
continue;
}
case SSL_ERROR_ZERO_RETURN:
{
// peer disconnected...
add multiport support
2019-12-20 16:49:41 +01:00
// ERROR("SSLWRITE: SSL_ERROR_ZERO_RETURN: peer disconected: %d", source->sock);
minor fix
2018-10-09 17:24:00 +02:00
break;
}
case SSL_ERROR_WANT_READ:
{
// no data available right now, wait a few seconds in case new data arrives...
//printf("SSL_ERROR_WANT_READ\n");
cont
2020-01-29 17:09:16 +01:00
int sock = SSL_get_rfd(source->stream);
minor fix
2018-10-09 17:24:00 +02:00
FD_ZERO(&fds);
FD_SET(sock, &fds);
timeout.tv_sec = 0;
timeout.tv_usec = 500;
err = select(sock+1, &fds, NULL, NULL, &timeout);
if (err == 0 || (err > 0 && FD_ISSET(sock, &fds)))
fix deadlock
2018-10-14 10:57:09 +02:00
{
use heavy task by default
2018-10-15 12:28:04 +02:00
//source->attempt++;
minor fix
2018-10-09 17:24:00 +02:00
continue; // more data to read...
fix deadlock
2018-10-14 10:57:09 +02:00
}
remove err
2019-12-15 16:24:15 +01:00
//ERROR("SSL WRITE: want read but select error on the socket %d: %s", source->sock, strerror(errno));
fix deadlock
2018-10-14 10:57:09 +02:00
break;
minor fix
2018-10-09 17:24:00 +02:00
}
case SSL_ERROR_WANT_WRITE:
{
// socket not writable right now, wait a few seconds and try again...
//printf("SSL_ERROR_WANT_WRITE \n");
cont
2020-01-29 17:09:16 +01:00
int sock = SSL_get_wfd(source->stream);
minor fix
2018-10-09 17:24:00 +02:00
FD_ZERO(&fds);
FD_SET(sock, &fds);
timeout.tv_sec = 0;
timeout.tv_usec = 500;
err = select(sock+1, NULL, &fds, NULL, &timeout);
if (err == 0 || (err > 0 && FD_ISSET(sock, &fds)))
fix deadlock
2018-10-14 10:57:09 +02:00
{
use heavy task by default
2018-10-15 12:28:04 +02:00
//source->attempt++;
minor fix
2018-10-09 17:24:00 +02:00
continue; // can write more data now...
fix deadlock
2018-10-14 10:57:09 +02:00
}
remove err
2019-12-15 16:24:15 +01:00
//ERROR("SSL WRITE: want write but select error on the socket %d: %s", source->sock, strerror(errno));
fix deadlock
2018-10-14 10:57:09 +02:00
break;
minor fix
2018-10-09 17:24:00 +02:00
}
default:
{
change log mechanism
2019-12-11 23:17:42 +01:00
// other error
remove err
2019-12-15 16:24:15 +01:00
//ERROR("SSL WRITE: Unknown error on %d: %s", source->sock, ERR_error_string(ERR_get_error(), NULL) );
minor fix
2018-10-09 17:24:00 +02:00
break;
}
}
fix looping rw
2019-12-15 16:38:58 +01:00
if(written == 0)
written = count;
fix write
2019-12-19 09:52:56 +01:00
break;
minor fix
2018-10-09 17:24:00 +02:00
}
}
unkown bug
2018-10-15 21:35:57 +02:00
//source->attempt = 0;
bug every where
2018-02-10 11:22:41 +01:00
}
else
{
#endif
fix read write pb
2018-10-27 16:15:25 +02:00
ptr = (char* )data;
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
writelen = len > BUFFLEN?BUFFLEN:len;
written = 0;
while (writelen > 0)
{
cont
2020-01-29 17:09:16 +01:00
count = send(source->id, ptr+written, writelen, 0);
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
if (count > 0)
{
written += count;
writelen = (len - written) > BUFFLEN?BUFFLEN:(len-written);
add timeout to io read write
2019-12-21 15:02:33 +01:00
time(&source->last_io);
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
}
add timeout to io read write
2019-12-21 15:02:33 +01:00
else if(difftime( time(NULL), source->last_io) > MAX_IO_WAIT_TIME || (count == -1 && errno != EAGAIN && errno != EWOULDBLOCK))
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
{
fix looping rw
2019-12-15 16:38:58 +01:00
if(written == 0)
written = count;
add timeout to io read write
2019-12-21 15:02:33 +01:00
//ERROR("Error while writing: %s", strerror(errno));
new api
2019-12-15 12:10:06 +01:00
break;
//return written;
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
}
}
bug every where
2018-02-10 11:22:41 +01:00
#ifdef USE_OPENSSL
}
#endif
cleanup
2020-01-08 22:35:58 +01:00
minor fix
2018-10-09 17:24:00 +02:00
return written;
bug every where
2018-02-10 11:22:41 +01:00
}
fix
2018-05-03 15:12:10 +02:00
int antd_recv(void *src, void* data, int len)
bug every where
2018-02-10 11:22:41 +01:00
{
ssl alpha support
2018-02-10 12:24:01 +01:00
if(!src) return -1;
fix read write pb
2018-10-27 16:15:25 +02:00
int read=0;
char* ptr = NULL;
int received=0;
int readlen=0;
bug every where
2018-02-10 11:22:41 +01:00
antd_client_t * source = (antd_client_t *) src;
#ifdef USE_OPENSSL
cont
2020-01-29 17:09:16 +01:00
if(source->stream)
bug every where
2018-02-10 11:22:41 +01:00
{
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
ptr = (char* )data;
readlen = len > BUFFLEN?BUFFLEN:len;
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
read = 0;
fd_set fds;
struct timeval timeout;
use heavy task by default
2018-10-15 12:28:04 +02:00
while (readlen > 0 )//&& source->attempt < MAX_ATTEMPT
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
{
add ssl debug info
2019-12-13 09:52:28 +01:00
ERR_clear_error();
cont
2020-01-29 17:09:16 +01:00
received = SSL_read (source->stream, ptr+read, readlen);
int err = SSL_get_error(source->stream, received);
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
if (received > 0)
{
read += received;
readlen = (len - read) > BUFFLEN?BUFFLEN:(len-read);
add timeout to io read write
2019-12-21 15:02:33 +01:00
time(&source->last_io);
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
}
else
{
add timeout to io read write
2019-12-21 15:02:33 +01:00
// Timeout, quit
if(difftime( time(NULL), source->last_io) > MAX_IO_WAIT_TIME)
{
if(read == 0)
read = received;
break;
}
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
//printf(" received equal to or less than 0\n")
switch (err)
{
case SSL_ERROR_NONE:
{
// no real error, just try again...
//LOG("SSL_ERROR_NONE \n");
use heavy task by default
2018-10-15 12:28:04 +02:00
//source->attempt++;
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
continue;
}
case SSL_ERROR_ZERO_RETURN:
{
// peer disconnected...
remove err
2019-12-15 16:24:15 +01:00
//ERROR("SSL READ: SSL_ERROR_ZERO_RETURN, peer disconnected %d", source->sock);
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
break;
}
case SSL_ERROR_WANT_READ:
{
// no data available right now, wait a few seconds in case new data arrives...
//printf("SSL_ERROR_WANT_READ\n");
cont
2020-01-29 17:09:16 +01:00
int sock = SSL_get_rfd(source->stream);
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
FD_ZERO(&fds);
FD_SET(sock, &fds);
timeout.tv_sec = 0;
timeout.tv_usec = 500;
err = select(sock+1, &fds, NULL, NULL, &timeout);
if (err == 0 || (err > 0 && FD_ISSET(sock, &fds)))
fix deadlock
2018-10-14 10:57:09 +02:00
{
use heavy task by default
2018-10-15 12:28:04 +02:00
//source->attempt++;
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
continue; // more data to read...
fix deadlock
2018-10-14 10:57:09 +02:00
}
remove err
2019-12-15 16:24:15 +01:00
//ERROR("SSL READ: want read but select error on the socket %d: %s", source->sock, strerror(errno));
fix deadlock
2018-10-14 10:57:09 +02:00
break;
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
}
case SSL_ERROR_WANT_WRITE:
{
// socket not writable right now, wait a few seconds and try again...
//printf("SSL_ERROR_WANT_WRITE \n");
cont
2020-01-29 17:09:16 +01:00
int sock = SSL_get_wfd(source->stream);
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
FD_ZERO(&fds);
FD_SET(sock, &fds);
timeout.tv_sec = 0;
timeout.tv_usec = 500;
err = select(sock+1, NULL, &fds, NULL, &timeout);
if (err == 0 || (err > 0 && FD_ISSET(sock, &fds)))
fix deadlock
2018-10-14 10:57:09 +02:00
{
use heavy task by default
2018-10-15 12:28:04 +02:00
//source->attempt++;
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
continue; // can write more data now...
fix deadlock
2018-10-14 10:57:09 +02:00
}
remove err
2019-12-15 16:24:15 +01:00
//ERROR("SSL READ: want write but select error on the socket %d: %s", source->sock, strerror(errno));
fix deadlock
2018-10-14 10:57:09 +02:00
break;
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
}
default:
{
// other error
remove err
2019-12-15 16:24:15 +01:00
//ERROR("SSL READ: unkown error on %d: %s", source->sock, ERR_error_string(ERR_get_error(), NULL));
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
break;
}
}
add multiport support
2019-12-20 16:49:41 +01:00
if(read == 0)
fix looping rw
2019-12-15 16:38:58 +01:00
read = received;
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
break;
}
}
unkown bug
2018-10-15 21:35:57 +02:00
//source->attempt = 0;
fix open ssl bug
2018-10-07 01:03:05 +02:00
/*
int stat, r, st;
do{
ret = SSL_read((SSL*) source->ssl, data, len);
stat = SSL_get_error((SSL*)source->ssl, r);
} while(ret == -1 &&
(
stat == SSL_ERROR_WANT_READ ||
stat == SSL_ERROR_WANT_WRITE ||
stat == SSL_ERROR_NONE ||
(stat == SSL_ERROR_SYSCALL && r== 0 && !ERR_get_error())
));
if(ret == -1)
{
LOG("Problem reading %d %d %d\n", ret, stat, r);
}
//set_nonblock(source->sock);
*/
bug every where
2018-02-10 11:22:41 +01:00
}
else
{
#endif
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
ptr = (char* )data;
readlen = len > BUFFLEN?BUFFLEN:len;
read = 0;
add timeout to io read write
2019-12-21 15:02:33 +01:00
while (readlen > 0 )
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
{
cont
2020-01-29 17:09:16 +01:00
received = recv(((int) source->id), ptr+read, readlen, 0);
fix read write pb
2018-10-27 16:21:12 +02:00
//LOG("Read : %c\n", *ptr);
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
if (received > 0)
{
read += received;
readlen = (len - read) > BUFFLEN?BUFFLEN:(len-read);
add timeout to io read write
2019-12-21 15:02:33 +01:00
time(&source->last_io);
fix read write pb
2018-10-27 16:21:12 +02:00
//LOG("Read len is %d\n", readlen);
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
}
add timeout to io read write
2019-12-21 15:02:33 +01:00
else if( difftime( time(NULL), source->last_io) > MAX_IO_WAIT_TIME || (errno != EAGAIN && errno != EWOULDBLOCK))
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
{
fix r/w wo ssl
2019-12-21 00:22:45 +01:00
//ERROR("Error while reading: %s", strerror(errno));
fix looping rw
2019-12-15 16:38:58 +01:00
if(read ==0)
read = received;
fix read write pb
2018-10-27 16:15:25 +02:00
break;
fix read write bug wo ssl
2018-10-27 12:58:12 +02:00
}
}
fix read write pb
2018-10-27 16:15:25 +02:00
//read = recv(((int) source->sock), data, len, 0);
bug every where
2018-02-10 11:22:41 +01:00
#ifdef USE_OPENSSL
}
#endif
fix read write pb
2018-10-27 16:15:25 +02:00
//LOG("Received %d bytes\n", read);
fix
2018-06-26 13:40:53 +02:00
/*if(ret == 0)
fix
2018-05-03 15:10:44 +02:00
{
antd_close(src);
fix
2018-06-26 13:40:53 +02:00
}*/
fix openssl bug on nonblocking mode
2018-10-07 13:57:52 +02:00
return read;
bug every where
2018-02-10 11:22:41 +01:00
}
fix open ssl bug
2018-10-07 01:03:05 +02:00
void set_nonblock(int socket) {
int flags;
flags = fcntl(socket,F_GETFL,0);
//assert(flags != -1);
fcntl(socket, F_SETFL, flags | O_NONBLOCK);
}
remove un neccessary code
2018-10-07 14:20:36 +02:00
/*void set_block()
fix open ssl bug
2018-10-07 01:03:05 +02:00
{
int flags;
flags = fcntl(socket,F_GETFL,0);
//assert(flags != -1);
fcntl(socket, F_SETFL, flags & (~O_NONBLOCK));
remove un neccessary code
2018-10-07 14:20:36 +02:00
}*/
bug every where
2018-02-10 11:22:41 +01:00
int antd_close(void* src)
{
ssl alpha support
2018-02-10 12:24:01 +01:00
if(!src) return -1;
bug every where
2018-02-10 11:22:41 +01:00
antd_client_t * source = (antd_client_t *) src;
fix
2020-01-08 19:17:51 +01:00
#ifdef USE_ZLIB
//TODO: send finish data to the socket before quit
if(source->zstream)
{
add h2 implement
2020-01-15 18:27:28 +01:00
if(!(source->flags & CLIENT_FL_COMPRESSION_END) && source->z_level != ANTD_CNONE)
fix
2020-01-08 19:17:51 +01:00
{
add h2 implement
2020-01-15 18:27:28 +01:00
source->flags |= CLIENT_FL_COMPRESSION_END;
allow copress body with zlib
2020-01-08 22:04:10 +01:00
antd_send(source, "", 0);
fix
2020-01-08 19:17:51 +01:00
}
deflateEnd(source->zstream);
free(source->zstream);
allow copress body with zlib
2020-01-08 22:04:10 +01:00
source->zstream = NULL;
source->z_level = ANTD_CNONE;
fix
2020-01-08 19:17:51 +01:00
}
#endif
bug every where
2018-02-10 11:22:41 +01:00
#ifdef USE_OPENSSL
cont
2020-01-29 17:09:16 +01:00
if(source->stream){
add ssl session cache
2018-02-10 16:57:21 +01:00
//printf("SSL:Shutdown ssl\n");
//SSL_shutdown((SSL*) source->ssl);
cont
2020-01-29 17:09:16 +01:00
SSL_set_shutdown((SSL*) source->stream, SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
add ssl session cache
2018-02-10 16:57:21 +01:00
//printf("SSL:Free ssl\n");
cont
2020-01-29 17:09:16 +01:00
SSL_free((SSL*) source->stream);
open ssl still leak memory
2018-10-09 12:15:48 +02:00
//EVP_cleanup();
//ENGINE_cleanup();
CRYPTO_cleanup_all_ex_data();
ERR_remove_state(0);
ERR_free_strings();
cont
2020-01-29 17:09:16 +01:00
source->stream = NULL;
ssl alpha support
2018-02-10 12:24:01 +01:00
//LOG("Freeing SSL\n");
bug every where
2018-02-10 11:22:41 +01:00
}
#endif
ssl alpha support
2018-02-10 12:24:01 +01:00
//printf("Close sock %d\n", source->sock);
cont
2020-01-29 17:09:16 +01:00
int ret = close(source->id);
ssl alpha support
2018-02-10 12:24:01 +01:00
free(src);
fix
2018-06-26 13:40:53 +02:00
src = NULL;
ssl alpha support
2018-02-10 12:24:01 +01:00
return ret;
bug every where
2018-02-10 11:22:41 +01:00
}
using shared library for common api
2017-07-29 22:00:34 +02:00
bug every where
2018-02-10 11:22:41 +01:00
int __t(void* client, const char* fstring,...)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
int dlen;
new api
2019-12-15 12:10:06 +01:00
int st;
using shared library for common api
2017-07-29 22:00:34 +02:00
va_list arguments;
char * data;
va_start( arguments, fstring);
new api
2019-12-15 12:10:06 +01:00
dlen = vsnprintf(0,0,fstring,arguments)+1;
using shared library for common api
2017-07-29 22:00:34 +02:00
va_end(arguments);
if ((data = (char*)malloc(dlen*sizeof(char))) != 0)
{
va_start(arguments, fstring);
vsnprintf(data, dlen, fstring, arguments);
va_end(arguments);
new api
2019-12-15 12:10:06 +01:00
st = __b(client, (const unsigned char*)data, strlen(data));
remove err
2019-12-15 16:24:15 +01:00
if(st)
__b(client, (unsigned char*)"\r\n", 2);
using shared library for common api
2017-07-29 22:00:34 +02:00
free(data);
new api
2019-12-15 12:10:06 +01:00
return st;
using shared library for common api
2017-07-29 22:00:34 +02:00
}
new api
2019-12-15 12:10:06 +01:00
return 0;
using shared library for common api
2017-07-29 22:00:34 +02:00
//
}
bug every where
2018-02-10 11:22:41 +01:00
int __b(void* client, const unsigned char* data, int size)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
int sent = 0;
int buflen = 0;
new api
2019-12-15 12:10:06 +01:00
int nbytes = 0;
allow copress body with zlib
2020-01-08 22:04:10 +01:00
char* ptr = (char*)data;
new api
2019-12-15 12:10:06 +01:00
/*if(size <= BUFFLEN)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
fix websocket problem via ssh
2018-02-10 13:44:25 +01:00
nbytes = antd_send(client,data,size);
using shared library for common api
2017-07-29 22:00:34 +02:00
return (nbytes==-1?0:1);
}
else
new api
2019-12-15 12:10:06 +01:00
{*/
using shared library for common api
2017-07-29 22:00:34 +02:00
while(sent < size)
{
if(size - sent > BUFFLEN)
buflen = BUFFLEN;
else
buflen = size - sent;
allow copress body with zlib
2020-01-08 22:04:10 +01:00
nbytes = antd_send(client,ptr,buflen);
new api
2019-12-15 12:10:06 +01:00
if(nbytes == -1)
{
return 0;
}
allow copress body with zlib
2020-01-08 22:04:10 +01:00
sent += buflen;
ptr += buflen;
using shared library for common api
2017-07-29 22:00:34 +02:00
}
new api
2019-12-15 12:10:06 +01:00
//}
using shared library for common api
2017-07-29 22:00:34 +02:00
return 1;
}
update
2019-11-30 20:40:40 +01:00
int __f(void* client, const char* file)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
unsigned char buffer[BUFFLEN];
FILE *ptr;
ptr = fopen(file,"rb");
if(!ptr)
{
change log mechanism
2019-12-11 23:17:42 +01:00
LOG("Cannot read : %s", file);
using shared library for common api
2017-07-29 22:00:34 +02:00
return 0;
}
size_t size;
while(!feof(ptr))
{
size = fread(buffer,1,BUFFLEN,ptr);
allow copress body with zlib
2020-01-08 22:04:10 +01:00
if(antd_send(client,buffer,size) == -1) return 0;
using shared library for common api
2017-07-29 22:00:34 +02:00
}
fclose(ptr);
return 1;
}
new api
2019-12-15 12:10:06 +01:00
using shared library for common api
2017-07-29 22:00:34 +02:00
int upload(const char* tmp, const char* path)
{
return !rename(tmp, path);
}
new api
2019-12-15 12:10:06 +01:00
/*
void set_cookie(void* client,const char* type, dictionary_t dic, const char* name)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
set_status(client,200,"OK");
__t(client,"Content-Type: %s",type);
new api
2019-12-15 12:10:06 +01:00
chain_t assoc;
using shared library for common api
2017-07-29 22:00:34 +02:00
for_each_assoc(assoc,dic){
__t(client,"Set-Cookie: %s=%s; Path=/%s",assoc->key, (char*)assoc->value, name);
}
response(client,"");
}
new api
2019-12-15 12:10:06 +01:00
void clear_cookie(void* client, dictionary_t dic)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
set_status(client,200,"OK");
__t(client,"Content-Type: text/html; charset=utf-8");
new api
2019-12-15 12:10:06 +01:00
chain_t assoc;
using shared library for common api
2017-07-29 22:00:34 +02:00
for_each_assoc(assoc,dic){
new api
2019-12-15 12:10:06 +01:00
__t(client,"Set-Cookie: %s=%s;expires=%s",assoc->key, (char*)assoc->value, server_time());
using shared library for common api
2017-07-29 22:00:34 +02:00
}
response(client,"");
}
new api
2019-12-15 12:10:06 +01:00
*/
void antd_error(void* client, int status, const char* msg)
{
antd_response_header_t rsh;
rsh.header = dict();
rsh.cookie = NULL;
const char* stat_str = get_status_str(status);
rsh.status = status;
allow copress body with zlib
2020-01-08 22:04:10 +01:00
char* ctype = "text/html; charset=utf-8";
dput(rsh.header, "Content-Type", strdup(ctype));
new api
2019-12-15 12:10:06 +01:00
char * res_str = __s(HTML_TPL, stat_str, msg);
int clen = 0;
if(res_str)
{
clen = strlen(res_str);
}
char ibuf[20];
snprintf (ibuf, sizeof(ibuf), "%d",clen);
add protocol selection to ssl, used for http2 support in the future
2020-01-11 22:30:01 +01:00
#ifdef USE_ZLIB
allow copress body with zlib
2020-01-08 22:04:10 +01:00
if(((antd_client_t*)client)->z_level == ANTD_CNONE || !compressable(ctype))
add protocol selection to ssl, used for http2 support in the future
2020-01-11 22:30:01 +01:00
#endif
allow copress body with zlib
2020-01-08 22:04:10 +01:00
dput(rsh.header, "Content-Length", strdup(ibuf));
new api
2019-12-15 12:10:06 +01:00
antd_send_header(client, &rsh);
if(res_str)
{
//printf("%s\n", res_str);
__b(client, (unsigned char*)res_str, clen);
//__t(client, HTML_TPL, stat_str, msg);
free(res_str);
}
using shared library for common api
2017-07-29 22:00:34 +02:00
}
new api
2019-12-15 12:10:06 +01:00
int ws_enable(dictionary_t dic)
using shared library for common api
2017-07-29 22:00:34 +02:00
{
fix libantd
2018-09-18 10:33:42 +02:00
if(!dic) return 0;
char*v = (char*)dvalue(dic, "__web_socket__");
if(!v) return 0;
return atoi(v) == 1;
clear code
2017-07-29 23:54:43 +02:00
}
remove strdup calles
2019-12-22 14:33:42 +01:00
clear code
2017-07-29 23:54:43 +02:00
/**
* Read the socket request in to a buffer or size
* The data is read until the buffer is full or
* there are a carrier return character
* @param sock socket
* @param buf buffer
* @param size size of buffer
* @return number of bytes read
*/
bug every where
2018-02-10 11:22:41 +01:00
int read_buf(void* sock, char*buf,int size)
clear code
2017-07-29 23:54:43 +02:00
{
int i = 0;
char c = '\0';
int n;
while ((i < size - 1) && (c != '\n'))
{
fix websocket problem via ssh
2018-02-10 13:44:25 +01:00
n = antd_recv(sock, &c, 1);
clear code
2017-07-29 23:54:43 +02:00
if (n > 0)
{
fix read write pb
2018-10-27 16:15:25 +02:00
//LOG("Data : %c\n", c);
clear code
2017-07-29 23:54:43 +02:00
buf[i] = c;
i++;
}
else
c = '\n';
}
buf[i] = '\0';
return i;
using shared library for common api
2017-07-29 22:00:34 +02:00
}
Reference in New Issue Copy Permalink