void t01_server_min(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_listen_point *lp=onion_buffer_listen_point_new();
onion_add_listen_point(server,NULL,NULL,lp);
onion_set_root_handler(server, onion_handler_static("Succedded", 200));
onion_request *req=onion_request_new(lp);
onion_request_write(req, "GET ",4);
onion_request_write(req, "/",1);
onion_request_write(req, " HTTP/1.1\r\n",11);
onion_request_write(req, "\r\n",2);
const char *buffer=onion_buffer_listen_point_get_buffer_data(req);
FAIL_IF_EQUAL_STR(buffer,"");
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 200 OK\r\n");
FAIL_IF_NOT_STRSTR(buffer, "\r\nContent-Length: 9\r\n");
FAIL_IF_NOT_STRSTR(buffer, "libonion");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\nSuccedded");
onion_request_free(req);
onion_free(server);
END_LOCAL();
}
void t01_handle_static_request(){
INIT_LOCAL();
char ok;
onion *server=onion_new(0);
onion_listen_point *lp=onion_buffer_listen_point_new();
onion_add_listen_point(server, NULL, NULL, lp);
onion_request *request=onion_request_new(lp);
FILL(request,"GET / HTTP/1.1\n");
onion_handler *handler=onion_handler_static("Not ready",302);
FAIL_IF_NOT(handler);
onion_set_root_handler(server, handler);
onion_response *response=onion_response_new(request);
ok=onion_handler_handle(handler, request, response);
FAIL_IF_NOT_EQUAL(ok, OCS_PROCESSED);
onion_response_free(response);
const char *buffer=onion_buffer_listen_point_get_buffer_data(request);
FAIL_IF_EQUAL_STR(buffer,"");
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 302 REDIRECT\r\n");
FAIL_IF_NOT_STRSTR(buffer, "\r\nContent-Length: 9\r\n");
FAIL_IF_NOT_STRSTR(buffer, "libonion");
FAIL_IF_STRSTR(buffer, "License: AGPL"); // License is now LGPL, no need to advertise
FAIL_IF_STRSTR(buffer, "License");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\nNot ready");
onion_request_free(request);
onion_free(server);
END_LOCAL();
}
void t01_codecs_base64_decode(){
INIT_LOCAL();
{
/// Text from wikipedia. Leviathan by Hobbes.
char *orig ="dGVzdDphYWE=";
char *realtext="test:aaa";
char *res=onion_base64_decode(orig, NULL);
FAIL_IF_NOT_EQUAL_STR(res,realtext);
free(res);
}
{
/// Text from wikipedia. Leviathan by Hobbes.
char *orig ="TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz\n"
"IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg\n"
"dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu\n"
"dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo\n"
"ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=\n";
char *realtext="Man is distinguished, not only by his reason, but by this singular passion from other animals,"
" which is a lust of the mind, that by a perseverance of delight in the continued and"
" indefatigable generation of knowledge, exceeds the short vehemence of any carnal pleasure.";
int l;
char *res=onion_base64_decode(orig, &l);
//fprintf(stderr,"l %d len %ld\n",l,strlen(realtext));
FAIL_IF_NOT_EQUAL(l,strlen(realtext));
FAIL_IF_NOT_EQUAL_STR(res,realtext);
free(res);
}
END_LOCAL();
}
void t05_post_content_json(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_listen_point *lp=onion_buffer_listen_point_new();
json_response post_json = { 0 };
onion_add_listen_point(server,NULL,NULL,lp);
onion_set_root_handler(server, onion_handler_new((void*)&post_json_check,&post_json,NULL));
onion_request *req=onion_request_new(lp);
#define POST_HEADER "POST / HTTP/1.1\nContent-Type: application/json\nContent-Length: %d\n\n"
char tmp[1024];
int json_length=sizeof(JSON_EXAMPLE);
ONION_DEBUG("Post size is about %d",json_length);
snprintf(tmp, sizeof(tmp), POST_HEADER, json_length);
// ONION_DEBUG("%s",tmp);
onion_request_write(req,tmp,strlen(tmp));
onion_request_write(req,JSON_EXAMPLE,json_length);
// ONION_DEBUG("%s",JSON_EXAMPLE);
FAIL_IF_NOT_EQUAL_INT(post_json.processed, 2);
onion_request_free(req);
onion_free(server);
END_LOCAL();
}
void t08_server_with_error_404(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_listen_point *lp=onion_buffer_listen_point_new();
onion_add_listen_point(server,NULL,NULL,lp);
onion_url *urls=onion_url_new();
onion_set_root_handler(server, onion_url_to_handler(urls));
onion_request *req=onion_request_new(lp);
#define S "GET / HTTP/1.1"
onion_request_write(req, S,sizeof(S)-1); // send it all, but the final 0.
#undef S
const char *buffer=onion_buffer_listen_point_get_buffer_data(req);
FAIL_IF_NOT_EQUAL_STR(buffer,"");
onion_request_write(req, "\n",1); // finish this request. no \n\n before to check possible bugs.
onion_request_write(req, "\n",1); // finish this request. no \n\n before to check possible bugs. The last \n was not processed, as was overflowing.
buffer=onion_buffer_listen_point_get_buffer_data(req);
FAIL_IF_EQUAL_STR(buffer,"");
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 404 NOT FOUND\r\n");
FAIL_IF_NOT_STRSTR(buffer, "libonion");
onion_request_free(req);
onion_free(server);
END_LOCAL();
}
void t16_soft_dup_dict_in_dict(){
INIT_LOCAL();
onion_dict *orig=onion_dict_new();
char tmp[9];
int i;
for (i=0;i<256;i++){
sprintf(tmp,"%08X",rand());
onion_dict_add(orig, tmp, tmp, OD_DUP_ALL);
}
onion_dict_add(orig, "0", "no frees", 0);
onion_dict *subdict=onion_dict_new();
onion_dict_add(subdict,"subdict","test",0);
onion_dict_add(orig, "subdict", subdict, OD_DICT|OD_FREE_VALUE);
onion_dict *dest=onion_dict_dup(orig);
FAIL_IF_NOT(orig==dest);
/// Check they have exactly the same keys.
onion_dict_preorder(orig, cmpdict, dest);
onion_dict_preorder(dest, cmpdict, orig);
onion_dict_free(orig);
onion_dict_free(dest);
END_LOCAL();
}
void t04_server_overflow(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_listen_point *lp=onion_buffer_listen_point_new();
onion_add_listen_point(server,NULL,NULL,lp);
onion_set_root_handler(server, onion_handler_static("Succedded", 200));
onion_block *long_req=onion_block_new();
onion_block_add_str(long_req,"GET / HTTP/1.1\n");
int i;
for(i=0;i<1000;i++){
onion_block_add_str(long_req,"Header-1: This is header1 Header-2: This is header 2 ");
}
onion_request *req=onion_request_new(lp);
onion_request_write(req, onion_block_data(long_req),onion_block_size(long_req)-1); // send it all, but the final 0.
const char *buffer=onion_buffer_listen_point_get_buffer_data(req);
FAIL_IF_NOT_EQUAL_STR(buffer,"");
onion_request_write(req, "\n\n",2); // finish this request. no \n\n before to check possible bugs.
buffer=onion_buffer_listen_point_get_buffer_data(req);
FAIL_IF_EQUAL_STR(buffer,"");
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 200 OK\r\n");
FAIL_IF_NOT_STRSTR(buffer, "\r\nContent-Length: 9\r\n");
FAIL_IF_NOT_STRSTR(buffer, "libonion");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\nSuccedded");
onion_block_free(long_req);
onion_request_free(req);
onion_free(server);
END_LOCAL();
}
void t06_empty(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_add_listen_point(server,NULL,NULL,onion_buffer_listen_point_new());
onion_request *request;
char buffer[4096];
memset(buffer,0,sizeof(buffer));
request=onion_request_new(server->listen_points[0]);
onion_response *response=onion_response_new(request);
// onion_response_write_headers(response);
onion_response_flush(response);
onion_response_free(response);
buffer[sizeof(buffer)-1]=0;
strncpy(buffer,onion_buffer_listen_point_get_buffer_data(request),sizeof(buffer)-1);
onion_request_free(request);
onion_free(server);
FAIL_IF_NOT_STRSTR(buffer, "Server:");
FAIL_IF_NOT_STRSTR(buffer, "Content-Type:");
// ONION_DEBUG(buffer);
END_LOCAL();
}
void t01_create_add_free(){
INIT_LOCAL();
onion_dict *dict;
const char *value;
dict=onion_dict_new();
FAIL_IF_EQUAL(dict,NULL);
// Get before anything in
value=onion_dict_get(dict, "Request");
FAIL_IF_NOT_EQUAL(value,NULL);
// basic add
onion_dict_add(dict, "Request", "GET /", OD_DUP_ALL);
value=onion_dict_get(dict, "Request");
FAIL_IF_NOT_EQUAL_STR(value,"GET /");
// basic remove
onion_dict_remove(dict, "Request");
value=onion_dict_get(dict, "Request");
FAIL_IF_NOT_EQUAL(value,NULL);
onion_dict_free(dict);
END_LOCAL();
}
void t02_full_cycle_http10(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_add_listen_point(server,NULL,NULL,onion_buffer_listen_point_new());
onion_request *request;
char buffer[4096];
memset(buffer,0,sizeof(buffer));
request=onion_request_new(server->listen_points[0]);
onion_response *response=onion_response_new(request);
onion_response_set_length(response, 30);
FAIL_IF_NOT_EQUAL(response->length,30);
onion_response_write_headers(response);
onion_response_write0(response,"123456789012345678901234567890");
FAIL_IF_NOT_EQUAL(response->sent_bytes,30);
onion_response_free(response);
strncpy(buffer,onion_buffer_listen_point_get_buffer_data(request),sizeof(buffer));
onion_request_free(request);
onion_free(server);
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.0 200 OK\r\n");
FAIL_IF_NOT_STRSTR(buffer, "Connection: Keep-Alive\r\n");
FAIL_IF_NOT_STRSTR(buffer, "Content-Length: 30\r\n");
FAIL_IF_NOT_STRSTR(buffer, "Server: libonion");
FAIL_IF_NOT_STRSTR(buffer, "coralbits");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\n123456789012345678901234567890");
END_LOCAL();
}
void t05_printf(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_add_listen_point(server,NULL,NULL,onion_buffer_listen_point_new());
onion_request *request;
char buffer[4096];
memset(buffer,0,sizeof(buffer));
request=onion_request_new(server->listen_points[0]);
onion_response *response=onion_response_new(request);
onion_response_printf(response, "%s %d %p", "Hello world", 123, NULL);
onion_response_flush(response);
onion_response_free(response);
buffer[sizeof(buffer)-1]=0;
strncpy(buffer,onion_buffer_listen_point_get_buffer_data(request),sizeof(buffer)-1);
onion_request_free(request);
onion_free(server);
FAIL_IF_NOT_STRSTR(buffer, "Hello world 123 (nil)");
END_LOCAL();
}
void t10_repeated_header(){
INIT_LOCAL();
onion_request *req;
int ok;
onion_set_max_post_size(server, 1024);
req=onion_request_new(custom_io);
FAIL_IF_EQUAL(req,NULL);
FAIL_IF_NOT_EQUAL(req->connection.fd, -1);
{
const char *query="GET / HTTP/1.0\n"
"Content-Type: application/x-www-form-urlencoded\n"
"Host: 127.0.0.1\n\r"
"Content-Length: 24\n"
"Accept-Language: en\n"
"Content-Type: application/x-www-form-urlencoded-bis\n\n";
ok=onion_request_write(req,query,strlen(query));
}
FAIL_IF_EQUAL(ok,OCS_INTERNAL_ERROR);
FAIL_IF_NOT_EQUAL_STR(onion_request_get_header(req,"Host"),"127.0.0.1");
FAIL_IF_NOT_EQUAL_STR(onion_request_get_header(req,"Content-Length"),"24");
FAIL_IF_NOT_EQUAL_STR(onion_request_get_header(req,"Content-Type"),"application/x-www-form-urlencoded");
onion_request_free(req);
END_LOCAL();
}
void t06_create_add_free_POST_toobig(){
INIT_LOCAL();
onion_request *req;
int ok;
req=onion_request_new(custom_io);
FAIL_IF_EQUAL(req,NULL);
FAIL_IF_NOT_EQUAL(req->connection.fd, -1);
onion_set_max_post_size(server, 10); // Very small limit
const char *query="POST /myurl%20/is/very/deeply/nested?test=test&query2=query%202&more_query=%20more%20query+10 HTTP/1.0\n"
"Host: 127.0.0.1\n\rContent-Length: 24\n"
"Other-Header: My header is very long and with spaces...\r\n\r\npost_data=1&post_data2=2&post_data=1&post_data2=2";
int i; // Straight write, with clean (keep alive like)
for (i=0;i<10;i++){
FAIL_IF_NOT_EQUAL(req->flags,0);
ok=REQ_WRITE(req,query);
FAIL_IF_NOT_EQUAL(ok,OCS_INTERNAL_ERROR);
onion_request_clean(req);
FAIL_IF_NOT_EQUAL(req->GET,NULL);
}
onion_request_free(req);
END_LOCAL();
}
void t06_codecs_c_unicode(){
INIT_LOCAL();
const char *text="\302Hola!";
char *res=onion_c_quote_new(text);
FAIL_IF_NOT_STRSTR(res,"\\302");
FAIL_IF_NOT_STRSTR(res,"\\302Hola!");
free(res);
text="€";
res=onion_c_quote_new(text);
FAIL_IF_NOT_STRSTR(text,"€");
FAIL_IF_NOT_EQUAL_STR(res,"\"\\342\\202\\254\"");
free(res);
text="\377";
res=onion_c_quote_new(text);
FAIL_IF_NOT_EQUAL_STR(res,"\"\\377\"");
free(res);
END_LOCAL();
}
void t02_server_full(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_listen_point *lp=onion_buffer_listen_point_new();
onion_add_listen_point(server,NULL,NULL,lp);
onion_set_root_handler(server, onion_handler_static("Succedded", 200));
onion_request *req=onion_request_new(lp);
#define S "GET / HTTP/1.1\r\nHeader-1: This is header1\r\nHeader-2: This is header 2\r\n"
onion_request_write(req, S,sizeof(S)-1); // send it all, but the final 0.
#undef S
const char *buffer=onion_buffer_listen_point_get_buffer_data(req);
FAIL_IF_NOT_EQUAL_STR(buffer,"");
onion_request_write(req, "\n",1); // finish this request. no \n\n before to check possible bugs.
buffer=onion_buffer_listen_point_get_buffer_data(req);
FAIL_IF_EQUAL_STR(buffer,"");
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 200 OK\r\n");
FAIL_IF_NOT_STRSTR(buffer, "\r\nContent-Length: 9\r\n");
FAIL_IF_NOT_STRSTR(buffer, "libonion");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\nSuccedded");
onion_request_free(req);
onion_free(server);
END_LOCAL();
}
void t12_dict_in_dict(){
INIT_LOCAL();
onion_dict *A=onion_dict_new();
onion_dict *B=onion_dict_new();
onion_dict *C=onion_dict_new();
onion_dict *D=onion_dict_new();
int i;
for (i=0;i<16;i++){
char tmp[9];
sprintf(tmp,"%08X",rand());
onion_dict_add(A, tmp, tmp, OD_DUP_ALL);
sprintf(tmp,"%08X",rand());
onion_dict_add(B, tmp, tmp, OD_DUP_ALL);
sprintf(tmp,"%08X",rand());
onion_dict_add(C, tmp, tmp, OD_DUP_ALL);
sprintf(tmp,"%08X",rand());
onion_dict_add(D, tmp, tmp, OD_DUP_ALL);
}
onion_dict_add(A, "B", B, OD_DICT|OD_FREE_VALUE);
onion_dict_add(A, "C", C, OD_DICT|OD_FREE_VALUE);
onion_dict_add(A, "D", D, OD_DICT|OD_FREE_VALUE);
FAIL_IF_NOT_EQUAL((onion_dict*)onion_dict_get(A, "B"), NULL);
FAIL_IF_NOT_EQUAL((onion_dict*)onion_dict_get(A, "C"), NULL);
FAIL_IF_NOT_EQUAL((onion_dict*)onion_dict_get(A, "D"), NULL);
FAIL_IF_NOT_EQUAL((onion_dict*)onion_dict_get_dict(A, "B"), B);
FAIL_IF_NOT_EQUAL((onion_dict*)onion_dict_get_dict(A, "C"), C);
FAIL_IF_NOT_EQUAL((onion_dict*)onion_dict_get_dict(A, "D"), D);
{
onion_block *tmpA=onion_dict_to_json(A);
onion_block *tmpB=onion_dict_to_json(B);
onion_block *tmpC=onion_dict_to_json(C);
onion_block *tmpD=onion_dict_to_json(D);
/*
ONION_DEBUG("Json is: %s",tmpA);
ONION_DEBUG("Json is: %s",tmpB);
ONION_DEBUG("Json is: %s",tmpC);
ONION_DEBUG("Json is: %s",tmpD);
*/
FAIL_IF_EQUAL( strstr(onion_block_data(tmpA), onion_block_data(tmpB)), NULL);
FAIL_IF_EQUAL( strstr(onion_block_data(tmpA), onion_block_data(tmpC)), NULL);
FAIL_IF_EQUAL( strstr(onion_block_data(tmpA), onion_block_data(tmpD)), NULL);
onion_block_free(tmpA);
onion_block_free(tmpB);
onion_block_free(tmpC);
onion_block_free(tmpD);
}
B=onion_dict_hard_dup(A);
onion_dict_free(A);
onion_dict_free(B);
END_LOCAL();
}
void t07_codecs_html(){
INIT_LOCAL();
char *encoded=onion_html_quote("<\"Hello\">");
FAIL_IF_NOT_EQUAL_STR( encoded, "<"Hello">");
free(encoded);
END_LOCAL();
}
void t02_handle_generic_request(){
INIT_LOCAL();
onion *server=onion_new(0);
onion_listen_point *lp=onion_buffer_listen_point_new();
onion_add_listen_point(server, NULL, NULL, lp);
onion_url *url=onion_url_new();
int error;
error=onion_url_add_handler(url, "^$", onion_handler_static("Not ready",302));
FAIL_IF(error);
error=onion_url_add_handler(url, "^a.*$", onion_handler_static("any",200));
FAIL_IF(error);
error=onion_url_add_static(url, "^.*", "Internal error", 500);
FAIL_IF(error);
onion_set_root_handler(server, onion_url_to_handler(url));
onion_request *request;
request=onion_request_new(lp);
FILL(request,"GET / HTTP/1.1\n");
onion_request_process(request);
const char *buffer=onion_buffer_listen_point_get_buffer_data(request);
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 302 REDIRECT\r\n");
FAIL_IF_NOT_STRSTR(buffer, "Content-Length: 9\r\n");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\nNot ready");
onion_request_free(request);
// gives error, as such url does not exist.
request=onion_request_new(lp);
FILL(request,"GET /error HTTP/1.1\n");
onion_request_process(request);
buffer=onion_buffer_listen_point_get_buffer_data(request);
ONION_DEBUG("<%s>", buffer);
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 500 INTERNAL ERROR\r\n");
FAIL_IF_NOT_STRSTR(buffer, "Content-Length: 14\r\n");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\nInternal error");
onion_request_free(request);
request=onion_request_new(lp);
FILL(request,"GET /any HTTP/1.1\n");
onion_request_process(request);
buffer=onion_buffer_listen_point_get_buffer_data(request);
FAIL_IF_NOT_STRSTR(buffer, "HTTP/1.1 200 OK\r\n");
FAIL_IF_NOT_STRSTR(buffer, "Content-Length: 3\r\n");
FAIL_IF_NOT_STRSTR(buffer, "\r\n\r\nany");
onion_request_free(request);
onion_free(server);
END_LOCAL();
}
void t03_create_and_free_a_lot_random(unsigned int n){
INIT_LOCAL();
onion_dict *dict;
const char *value;
unsigned int i;
dict=onion_dict_new();
FAIL_IF_EQUAL(dict,NULL);
// Linear add
for (i=0;i<n;i++){
char key[16], val[16];
sprintf(key,"key %d",R1(i));
sprintf(val,"val %d",R2(i));
onion_dict_add(dict, key, val, OD_DUP_ALL);
}
// Linear get
for (i=0;i<n;i++){
char key[16], val[16];
sprintf(key,"key %d",R1(i));
sprintf(val,"val %d",R2(i));
value=onion_dict_get(dict, key);
FAIL_IF_NOT_EQUAL_STR(val,value);
}
// remove all
for (i=n;i>0;i--){
char key[16];
int removed;
sprintf(key,"key %d",R1(i-1));
//fprintf(stderr,"%s %d\n",key,i-1);
removed=onion_dict_remove(dict, key);
FAIL_IF_NOT_EQUAL(removed,1);
}
// check removed all
for (i=0;i<n;i++){
char key[16], val[16];
sprintf(key,"key %d",R1(i));
sprintf(val,"val %d",R1(i));
value=onion_dict_get(dict, key);
//fprintf(stderr,"%s %s\n",key,value);
FAIL_IF_NOT_EQUAL(NULL,value);
FAIL_IF_NOT_EQUAL_STR(NULL,value);
}
onion_dict_free(dict);
END_LOCAL();
}
void t01_url() {
INIT_LOCAL();
onion_url *url = onion_url_new();
onion_url_add_handler(url, "^handler1.$",
onion_handler_new((onion_handler_handler) handler1,
NULL, NULL));
onion_url_add(url, "handler2/", handler2);
onion_url_add_with_data(url, "^handler(3|4)/", handler3, NULL, NULL);
onion_set_root_handler(server, onion_url_to_handler(url));
onion_request *req = onion_request_new(onion_get_listen_point(server, 0));
#define R "GET /handler1/ HTTP/1.1\n\n"
onion_request_write(req, R, sizeof(R));
onion_request_process(req);
FAIL_IF_NOT_EQUAL_INT(handler_called, 1);
FAIL_IF_NOT_EQUAL_STR(urltxt, "");
free(urltxt);
urltxt = NULL;
onion_request_clean(req);
onion_request_write(req, "GET /handler2/ HTTP/1.1\n\n", sizeof(R));
onion_request_process(req);
FAIL_IF_NOT_EQUAL_INT(handler_called, 2);
ONION_DEBUG("%s", urltxt);
FAIL_IF_NOT_EQUAL_STR(urltxt, "");
free(urltxt);
urltxt = NULL;
onion_request_clean(req);
onion_request_write(req, "GET /handler3/hello HTTP/1.1\n\n", sizeof(R) + 5);
onion_request_process(req);
FAIL_IF_NOT_EQUAL_INT(handler_called, 3);
FAIL_IF_NOT_EQUAL_STR(urltxt, "hello");
free(urltxt);
urltxt = NULL;
handler_called = 0;
onion_request_clean(req);
onion_request_write(req, "GET /handler2/hello HTTP/1.1\n\n", sizeof(R) + 5);
onion_request_process(req);
FAIL_IF_NOT_EQUAL_INT(handler_called, 0);
FAIL_IF_EQUAL_STR(urltxt, "");
free(urltxt);
urltxt = NULL;
onion_request_free(req);
onion_url_free(url);
onion_set_root_handler(server, NULL);
END_LOCAL();
}
void t05_context(){
INIT_LOCAL();
Onion::Dict dict(defaultContext());
ONION_DEBUG("Render");
// This is important as otemplate templates need ownership as they
// will free the pointer. These way we use the internal refcount to avoid double free.
onion_dict_dup(dict.c_handler());
index_html_template(dict.c_handler());
END_LOCAL();
}
void t01_test_mime(){
INIT_LOCAL();
FAIL_IF_NOT_EQUAL_STR("text/plain", onion_mime_get("txt"));
FAIL_IF_NOT_EQUAL_STR("text/plain", onion_mime_get("fdsfds"));
FAIL_IF_NOT_EQUAL_STR("text/html", onion_mime_get("html"));
FAIL_IF_NOT_EQUAL_STR("image/png", onion_mime_get("file.png"));
FAIL_IF_NOT_EQUAL_STR("application/javascript", onion_mime_get("js"));
onion_mime_set(NULL);
END_LOCAL();
}
void t18_json_escape_codes(){
INIT_LOCAL();
onion_dict *d=onion_dict_from_json("{ \"hello\": \"Hello\\nworld\", \"second\":\"second\" }");
FAIL_IF_NOT_STRSTR(onion_dict_get(d, "hello"), "Hello\nworld");
FAIL_IF_NOT_STRSTR(onion_dict_get(d, "second"), "second");
onion_dict_free(d);
d=onion_dict_from_json("{ \"hello\": \"\\uD83D\\uDE02\" }");
FAIL_IF_NOT_STRSTR(onion_dict_get(d, "hello"), "😂");
onion_dict_free(d);
d=onion_dict_from_json("{ \"hello\": \"\\uD83D\\uDE03\" }"); // Another code point
FAIL_IF_STRSTR(onion_dict_get(d, "hello"), "😂");
onion_dict_free(d);
d=onion_dict_from_json("{ \"hello\": \"\\u007b\" }"); // simple unicode
FAIL_IF_NOT_STRSTR(onion_dict_get(d, "hello"), "{");
onion_dict_free(d);
d=onion_dict_from_json("{ \"hello\": \"\\\"Quote\" }"); // Escape quote
FAIL_IF_NOT_STRSTR(onion_dict_get(d, "hello"), "\"Quote");
onion_dict_free(d);
d=onion_dict_from_json("{ \"hello\": \"\"Quote\" }"); // Must fail
FAIL_IF_NOT_EQUAL(d, NULL);
d=onion_dict_new();
onion_dict_add(d, "hello", "Hello\nWorld\\", 0);
onion_dict_add(d, "second", "123", 0);
onion_block *b=onion_dict_to_json(d);
FAIL_IF_NOT_EQUAL_STR(onion_block_data(b),"{\"hello\":\"Hello\\nWorld\\\\\", \"second\":\"123\"}");
onion_block_free(b);
onion_dict_free(d);
d=onion_dict_new();
onion_dict_add(d, "hello", "😂\t\n😂", 0);
b=onion_dict_to_json(d);
FAIL_IF_NOT_EQUAL_STR(onion_block_data(b),"{\"hello\":\"😂\\t\\n😂\"}");
onion_block_free(b);
onion_dict_free(d);
d=onion_dict_new();
onion_dict_add(d, "hello", "\02\03\x7f", 0);
b=onion_dict_to_json(d);
FAIL_IF_NOT_EQUAL_STR(onion_block_data(b),"{\"hello\":\"\\u0002\\u0003\\u007F\"}");
onion_block_free(b);
onion_dict_free(d);
END_LOCAL();
}
// This fixes that whenever a session is created, but no new data is added, it does not set the proper cookie
void t04_lot_of_sessionid(){
INIT_LOCAL();
onion *o=onion_new(O_ONE_LOOP);
onion_server_set_write(o->server, empty_write);
onion_url *url=onion_root_url(o);
onion_url_add(url, "^.*", ask_session);
char sessionid[256];
char tmp[1024];
char tmp2[4096];
onion_request *req;
int i;
set_data_on_session=1;
req=onion_request_new(o->server, NULL, NULL);
req->fullpath="/";
onion_request_process(req);
FAIL_IF_NOT_EQUAL_INT(onion_dict_count(o->server->sessions->sessions), 1);
FAIL_IF_EQUAL_STR(lastsessionid,"");
strcpy(sessionid, lastsessionid);
req->fullpath=NULL;
onion_request_free(req);
req=onion_request_new(o->server, NULL, NULL);
req->fullpath="/";
snprintf(tmp,sizeof(tmp)," sessionid=xx%sxx;",lastsessionid);
strcpy(tmp2,"Cookie:");
for(i=0;i<64;i++)
strncat(tmp2, tmp, sizeof(tmp2));
snprintf(tmp,sizeof(tmp)," sessionid=%s\n",lastsessionid);
strncat(tmp2, tmp, sizeof(tmp2));
ONION_DEBUG("Set cookies (%d bytes): %s",strlen(tmp2),tmp2);
strcpy(tmp,"GET /\n");
onion_request_write(req,tmp,strlen(tmp)); // Here is the problem, at parsing too long headers
onion_request_write(req,tmp2,strlen(tmp2)); // Here is the problem, at parsing too long headers
onion_request_write(req,"\n",1);
//onion_dict_add(req->headers, "Cookie", tmp2, 0);
onion_request_process(req);
FAIL_IF_NOT_EQUAL_INT(onion_dict_count(o->server->sessions->sessions), 1);
FAIL_IF_EQUAL_STR(lastsessionid,"");
FAIL_IF_NOT_EQUAL_STR(lastsessionid, sessionid);
FAIL_IF_NOT(has_set_cookie);
onion_request_free(req);
onion_free(o);
END_LOCAL();
}
void t05_create_add_free_POST(){
INIT_LOCAL();
onion_request *req;
int ok;
req=onion_request_new(custom_io);
FAIL_IF_EQUAL(req,NULL);
FAIL_IF_NOT_EQUAL(req->connection.fd, -1);
const char *query="POST /myurl%20/is/very/deeply/nested?test=test&query2=query%202&more_query=%20more%20query+10 HTTP/1.0\n"
"Host: 127.0.0.1\n\rContent-Length: 50\n"
"Other-Header: My header is very long and with spaces...\r\n\r\nempty_post=&post_data=1&post_data2=2&empty_post_2=\n";
int i; // Straight write, with clean (keep alive like)
for (i=0;i<10;i++){
FAIL_IF_NOT_EQUAL(req->flags,0);
ok=REQ_WRITE(req,query);
FAIL_IF_NOT_EQUAL(ok, OCS_CLOSE_CONNECTION);
FAIL_IF_EQUAL(req->flags,OR_GET|OR_HTTP11);
FAIL_IF_EQUAL(req->headers, NULL);
FAIL_IF_NOT_EQUAL_STR( onion_dict_get(req->headers,"Host"), "127.0.0.1");
FAIL_IF_NOT_EQUAL_STR( onion_dict_get(req->headers,"Other-Header"), "My header is very long and with spaces...");
FAIL_IF_NOT_EQUAL_STR(req->fullpath,"/myurl /is/very/deeply/nested");
FAIL_IF_NOT_EQUAL_STR(req->path,"myurl /is/very/deeply/nested");
FAIL_IF_EQUAL(req->GET,NULL);
FAIL_IF_NOT_EQUAL_STR( onion_dict_get(req->GET,"test"), "test");
FAIL_IF_NOT_EQUAL_STR( onion_dict_get(req->GET,"query2"), "query 2");
FAIL_IF_NOT_EQUAL_STR( onion_dict_get(req->GET,"more_query"), " more query 10");
const onion_dict *post=onion_request_get_post_dict(req);
FAIL_IF_EQUAL(post,NULL);
FAIL_IF_NOT_EQUAL_STR( onion_dict_get(post,"post_data"), "1");
FAIL_IF_NOT_EQUAL_STR( onion_dict_get(post,"post_data2"), "2");
FAIL_IF_NOT_EQUAL_STR( onion_request_get_post(req, "empty_post"), "");
FAIL_IF_NOT_EQUAL_STR( onion_request_get_post(req, "empty_post_2"), "");
onion_request_clean(req);
FAIL_IF_NOT_EQUAL(req->GET,NULL);
}
onion_request_free(req);
END_LOCAL();
}
void t14_dict_case_insensitive(){
INIT_LOCAL();
onion_dict *d=onion_dict_new();
onion_dict_add(d,"Test","OK", 0);
FAIL_IF_NOT_EQUAL(onion_dict_get(d,"test"),NULL);
onion_dict_set_flags(d,OD_ICASE);
FAIL_IF_NOT_EQUAL_STR(onion_dict_get(d,"test"),"OK");
onion_dict_free(d);
END_LOCAL();
}
void t06_null_add(){
INIT_LOCAL();
onion_dict *dict;
dict=onion_dict_new();
onion_dict_add(dict,"b",NULL,0);
onion_dict_add(dict,"a",NULL,0);
onion_dict_add(dict,"c","1",0);
FAIL_IF_NOT_EQUAL_STR(onion_dict_get(dict,"c"),"1");
FAIL_IF_NOT_EQUAL(onion_dict_get(dict,"a"),NULL);
onion_dict_free(dict);
END_LOCAL();
}
void t01_url(){
INIT_LOCAL();
Onion::Onion o;
// Create an empty url handler
Onion::Url url(o);
url.add("", [](Onion::Request &req, Onion::Response &res){
return Onion::render_to_response(_04_templates_html, std::map<std::string,std::string>{{"test","ok"}} , res);
});
o.listen();
END_LOCAL();
}
void t01_websocket_server_no_ws() {
INIT_LOCAL();
memset(&ws_status, 0, sizeof(ws_status));
onion *o = websocket_server_new();
onion_request *req = onion_request_new(onion_get_listen_point(o, 0));
onion_request_write0(req, "GET /\n\n");
onion_request_process(req);
FAIL_IF(ws_status.is_connected);
FAIL_IF_NOT_EQUAL_INT(ws_status.connected, 1);
onion_request_free(req);
onion_free(o);
END_LOCAL();
}
void t02_post_a_lot() {
INIT_LOCAL();
onion *o = onion_new(O_ONE);
onion_set_root_handler(o,
onion_handler_new((void *)return_length, NULL, NULL));
pthread_t pt;
pthread_create(&pt, NULL, (void *)POST_a_lot, NULL);
onion_listen(o);
pthread_join(pt, NULL);
onion_free(o);
END_LOCAL();
}
