lib/libhttp
1
0
Fork 0
mirror of https://github.com/lammertb/libhttp.git synced 2025-07-31 08:24:23 +03:00
Code Activity

Apply revised clang-format (#207) to all actively maintained source files

Browse Source
This commit is contained in:
bel
2015-10-05 20:58:14 +02:00
parent 8d901773ca
commit 4de9090577
23 changed files with 2194 additions and 1916 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
examples/embedded_c/embedded_c.c
View File

@ -28,7 +28,8 @@
int exitNow = 0; int exitNow = 0;
int ExampleHandler(struct mg_connection *conn, void *cbdata) int
ExampleHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
@ -65,7 +66,8 @@ int ExampleHandler(struct mg_connection *conn, void *cbdata)
} }
int ExitHandler(struct mg_connection *conn, void *cbdata) int
ExitHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n");
mg_printf(conn, "Server will shut down.\n"); mg_printf(conn, "Server will shut down.\n");
@ -75,7 +77,8 @@ int ExitHandler(struct mg_connection *conn, void *cbdata)
} }
int AHandler(struct mg_connection *conn, void *cbdata) int
AHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
@ -85,7 +88,8 @@ int AHandler(struct mg_connection *conn, void *cbdata)
} }
int ABHandler(struct mg_connection *conn, void *cbdata) int
ABHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
@ -95,7 +99,8 @@ int ABHandler(struct mg_connection *conn, void *cbdata)
} }
int BXHandler(struct mg_connection *conn, void *cbdata) int
BXHandler(struct mg_connection *conn, void *cbdata)
{ {
/* Handler may access the request info using mg_get_request_info */ /* Handler may access the request info using mg_get_request_info */
const struct mg_request_info *req_info = mg_get_request_info(conn); const struct mg_request_info *req_info = mg_get_request_info(conn);
@ -109,7 +114,8 @@ int BXHandler(struct mg_connection *conn, void *cbdata)
} }
int FooHandler(struct mg_connection *conn, void *cbdata) int
FooHandler(struct mg_connection *conn, void *cbdata)
{ {
/* Handler may access the request info using mg_get_request_info */ /* Handler may access the request info using mg_get_request_info */
const struct mg_request_info *req_info = mg_get_request_info(conn); const struct mg_request_info *req_info = mg_get_request_info(conn);
@ -127,7 +133,8 @@ int FooHandler(struct mg_connection *conn, void *cbdata)
} }
int WebSocketStartHandler(struct mg_connection *conn, void *cbdata) int
WebSocketStartHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
@ -190,13 +197,15 @@ struct t_ws_client {
#define ASSERT(x) \ #define ASSERT(x) \
{ \ { \
if (!(x)) { \ if (!(x)) { \
fprintf( \ fprintf(stderr, \
stderr, "Assertion failed in line %u\n", (unsigned)__LINE__); \ "Assertion failed in line %u\n", \
(unsigned)__LINE__); \
} \ } \
} }
int WebSocketConnectHandler(const struct mg_connection *conn, void *cbdata) int
WebSocketConnectHandler(const struct mg_connection *conn, void *cbdata)
{ {
struct mg_context *ctx = mg_get_context(conn); struct mg_context *ctx = mg_get_context(conn);
int reject = 1; int reject = 1;
@ -221,7 +230,8 @@ int WebSocketConnectHandler(const struct mg_connection *conn, void *cbdata)
} }
void WebSocketReadyHandler(struct mg_connection *conn, void *cbdata) void
WebSocketReadyHandler(struct mg_connection *conn, void *cbdata)
{ {
const char *text = "Hello from the websocket ready handler"; const char *text = "Hello from the websocket ready handler";
struct t_ws_client *client = mg_get_user_connection_data(conn); struct t_ws_client *client = mg_get_user_connection_data(conn);
@ -235,7 +245,8 @@ void WebSocketReadyHandler(struct mg_connection *conn, void *cbdata)
} }
int WebsocketDataHandler(struct mg_connection *conn, int
WebsocketDataHandler(struct mg_connection *conn,
int bits, int bits,
char *data, char *data,
size_t len, size_t len,
@ -253,7 +264,8 @@ int WebsocketDataHandler(struct mg_connection *conn,
} }
void WebSocketCloseHandler(const struct mg_connection *conn, void *cbdata) void
WebSocketCloseHandler(const struct mg_connection *conn, void *cbdata)
{ {
struct mg_context *ctx = mg_get_context(conn); struct mg_context *ctx = mg_get_context(conn);
struct t_ws_client *client = mg_get_user_connection_data(conn); struct t_ws_client *client = mg_get_user_connection_data(conn);
@ -270,7 +282,8 @@ void WebSocketCloseHandler(const struct mg_connection *conn, void *cbdata)
} }
void InformWebsockets(struct mg_context *ctx) void
InformWebsockets(struct mg_context *ctx)
{ {
static unsigned long cnt = 0; static unsigned long cnt = 0;
char text[32]; char text[32];
@ -281,8 +294,10 @@ void InformWebsockets(struct mg_context *ctx)
mg_lock_context(ctx); mg_lock_context(ctx);
for (i = 0; i < MAX_WS_CLIENTS; i++) { for (i = 0; i < MAX_WS_CLIENTS; i++) {
if (ws_clients[i].state == 2) { if (ws_clients[i].state == 2) {
mg_websocket_write( mg_websocket_write(ws_clients[i].conn,
ws_clients[i].conn, WEBSOCKET_OPCODE_TEXT, text, strlen(text)); WEBSOCKET_OPCODE_TEXT,
text,
strlen(text));
} }
} }
mg_unlock_context(ctx); mg_unlock_context(ctx);
@ -290,7 +305,8 @@ void InformWebsockets(struct mg_context *ctx)
#endif #endif
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
const char *options[] = {"document_root", const char *options[] = {"document_root",
DOCUMENT_ROOT, DOCUMENT_ROOT,

65
examples/embedded_cpp/embedded_cpp.cpp
View File

@ -22,15 +22,24 @@ bool exitNow = false;
class ExampleHandler : public CivetHandler class ExampleHandler : public CivetHandler
{ {
public: public:
bool handleGet(CivetServer *server, struct mg_connection *conn) { bool
handleGet(CivetServer *server, struct mg_connection *conn)
{
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>\r\n"); mg_printf(conn, "<html><body>\r\n");
mg_printf(conn, "<h2>This is an example text from a C++ handler</h2>\r\n"); mg_printf(conn,
mg_printf(conn, "<p>To see a page from the A handler <a href=\"a\">click here</a></p>\r\n"); "<h2>This is an example text from a C++ handler</h2>\r\n");
mg_printf(conn, "<p>To see a page from the A handler with a parameter <a href=\"a?param=1\">click here</a></p>\r\n"); mg_printf(conn, "<p>To see a page from the A handler <a "
mg_printf(conn, "<p>To see a page from the A/B handler <a href=\"a/b\">click here</a></p>\r\n"); "href=\"a\">click here</a></p>\r\n");
mg_printf(conn, "<p>To see a page from the *.foo handler <a href=\"xy.foo\">click here</a></p>\r\n"); mg_printf(conn, "<p>To see a page from the A handler with a parameter "
mg_printf(conn, "<p>To exit <a href=\"%s\">click here</a></p>\r\n", EXIT_URI); "<a href=\"a?param=1\">click here</a></p>\r\n");
mg_printf(conn, "<p>To see a page from the A/B handler <a "
"href=\"a/b\">click here</a></p>\r\n");
mg_printf(conn, "<p>To see a page from the *.foo handler <a "
"href=\"xy.foo\">click here</a></p>\r\n");
mg_printf(conn,
"<p>To exit <a href=\"%s\">click here</a></p>\r\n",
EXIT_URI);
mg_printf(conn, "</body></html>\r\n"); mg_printf(conn, "</body></html>\r\n");
return true; return true;
} }
@ -39,7 +48,9 @@ public:
class ExitHandler : public CivetHandler class ExitHandler : public CivetHandler
{ {
public: public:
bool handleGet(CivetServer *server, struct mg_connection *conn) { bool
handleGet(CivetServer *server, struct mg_connection *conn)
{
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n");
mg_printf(conn, "Bye!\n"); mg_printf(conn, "Bye!\n");
exitNow = true; exitNow = true;
@ -50,7 +61,11 @@ public:
class AHandler : public CivetHandler class AHandler : public CivetHandler
{ {
private: private:
bool handleAll(const char * method, CivetServer *server, struct mg_connection *conn) { bool
handleAll(const char *method,
CivetServer *server,
struct mg_connection *conn)
{
std::string s = ""; std::string s = "";
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
@ -63,11 +78,16 @@ private:
mg_printf(conn, "</body></html>\n"); mg_printf(conn, "</body></html>\n");
return true; return true;
} }
public: public:
bool handleGet(CivetServer *server, struct mg_connection *conn) { bool
handleGet(CivetServer *server, struct mg_connection *conn)
{
return handleAll("GET", server, conn); return handleAll("GET", server, conn);
} }
bool handlePost(CivetServer *server, struct mg_connection *conn) { bool
handlePost(CivetServer *server, struct mg_connection *conn)
{
return handleAll("POST", server, conn); return handleAll("POST", server, conn);
} }
}; };
@ -75,7 +95,9 @@ public:
class ABHandler : public CivetHandler class ABHandler : public CivetHandler
{ {
public: public:
bool handleGet(CivetServer *server, struct mg_connection *conn) { bool
handleGet(CivetServer *server, struct mg_connection *conn)
{
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
mg_printf(conn, "<h2>This is the AB handler!!!</h2>"); mg_printf(conn, "<h2>This is the AB handler!!!</h2>");
@ -87,27 +109,32 @@ public:
class FooHandler : public CivetHandler class FooHandler : public CivetHandler
{ {
public: public:
bool handleGet(CivetServer *server, struct mg_connection *conn) { bool
handleGet(CivetServer *server, struct mg_connection *conn)
{
/* Handler may access the request info using mg_get_request_info */ /* Handler may access the request info using mg_get_request_info */
const struct mg_request_info *req_info = mg_get_request_info(conn); const struct mg_request_info *req_info = mg_get_request_info(conn);
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
mg_printf(conn, "<h2>This is the Foo handler!!!</h2>"); mg_printf(conn, "<h2>This is the Foo handler!!!</h2>");
mg_printf(conn, "<p>The request was:<br><pre>%s %s HTTP/%s</pre></p>", mg_printf(conn,
req_info->request_method, req_info->uri, req_info->http_version); "<p>The request was:<br><pre>%s %s HTTP/%s</pre></p>",
req_info->request_method,
req_info->uri,
req_info->http_version);
mg_printf(conn, "</body></html>\n"); mg_printf(conn, "</body></html>\n");
return true; return true;
} }
}; };
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
const char * options[] = { "document_root", DOCUMENT_ROOT, const char *options[] = {
"listening_ports", PORT, 0 "document_root", DOCUMENT_ROOT, "listening_ports", PORT, 0};
};
CivetServer server(options); CivetServer server(options);

59
examples/websocket/WebSockCallbacks.c
View File

@ -19,22 +19,30 @@
#endif #endif
static void send_to_all_websockets(struct mg_context *ctx, const char * data, int data_len) { static void
send_to_all_websockets(struct mg_context *ctx, const char *data, int data_len)
{
int i; int i;
tWebSockContext *ws_ctx = (tWebSockContext *)mg_get_user_data(ctx); tWebSockContext *ws_ctx = (tWebSockContext *)mg_get_user_data(ctx);
mg_lock_context(ctx); mg_lock_context(ctx);
for (i = 0; i < MAX_NUM_OF_WEBSOCKS; i++) { for (i = 0; i < MAX_NUM_OF_WEBSOCKS; i++) {
if (ws_ctx->socketList[i] && (ws_ctx->socketList[i]->webSockState==2)) { if (ws_ctx->socketList[i]
mg_websocket_write(ws_ctx->socketList[i]->conn, WEBSOCKET_OPCODE_TEXT, data, data_len); && (ws_ctx->socketList[i]->webSockState == 2)) {
mg_websocket_write(ws_ctx->socketList[i]->conn,
WEBSOCKET_OPCODE_TEXT,
data,
data_len);
} }
} }
mg_unlock_context(ctx); mg_unlock_context(ctx);
} }
void websocket_ready_handler(struct mg_connection *conn, void *_ignored) { void
websocket_ready_handler(struct mg_connection *conn, void *_ignored)
{
int i; int i;
const struct mg_request_info *rq = mg_get_request_info(conn); const struct mg_request_info *rq = mg_get_request_info(conn);
@ -54,12 +62,16 @@ void websocket_ready_handler(struct mg_connection *conn, void *_ignored) {
break; break;
} }
} }
printf("\nNew websocket attached: %s:%u\n", rq->remote_addr, rq->remote_port); printf("\nNew websocket attached: %s:%u\n",
rq->remote_addr,
rq->remote_port);
mg_unlock_context(ctx); mg_unlock_context(ctx);
} }
static void websocket_done(tWebSockContext *ws_ctx, tWebSockInfo * wsock) { static void
websocket_done(tWebSockContext *ws_ctx, tWebSockInfo *wsock)
{
int i; int i;
@ -71,13 +83,21 @@ static void websocket_done(tWebSockContext *ws_ctx, tWebSockInfo * wsock) {
break; break;
} }
} }
printf("\nClose websocket attached: %s:%u\n", mg_get_request_info(wsock->conn)->remote_addr, mg_get_request_info(wsock->conn)->remote_port); printf("\nClose websocket attached: %s:%u\n",
mg_get_request_info(wsock->conn)->remote_addr,
mg_get_request_info(wsock->conn)->remote_port);
free(wsock); free(wsock);
} }
} }
int websocket_data_handler(struct mg_connection *conn, int flags, char *data, size_t data_len, void *_ignored) { int
websocket_data_handler(struct mg_connection *conn,
int flags,
char *data,
size_t data_len,
void *_ignored)
{
const struct mg_request_info *rq = mg_get_request_info(conn); const struct mg_request_info *rq = mg_get_request_info(conn);
tWebSockInfo *wsock = (tWebSockInfo *)rq->conn_data; tWebSockInfo *wsock = (tWebSockInfo *)rq->conn_data;
@ -93,7 +113,8 @@ int websocket_data_handler(struct mg_connection *conn, int flags, char *data, si
mg_unlock_context(ctx); mg_unlock_context(ctx);
return 1; return 1;
} }
if (((data_len>=5) && (data_len<100) && (flags==129)) || (flags==130)) { if (((data_len >= 5) && (data_len < 100) && (flags == 129))
|| (flags == 130)) {
// init command // init command
if ((wsock->webSockState == 1) && (!memcmp(data, "init ", 5))) { if ((wsock->webSockState == 1) && (!memcmp(data, "init ", 5))) {
@ -129,7 +150,9 @@ int websocket_data_handler(struct mg_connection *conn, int flags, char *data, si
} }
void connection_close_handler(const struct mg_connection *conn, void *_ignored) { void
connection_close_handler(const struct mg_connection *conn, void *_ignored)
{
const struct mg_request_info *rq = mg_get_request_info(conn); const struct mg_request_info *rq = mg_get_request_info(conn);
tWebSockInfo *wsock = (tWebSockInfo *)rq->conn_data; tWebSockInfo *wsock = (tWebSockInfo *)rq->conn_data;
@ -143,7 +166,9 @@ void connection_close_handler(const struct mg_connection *conn, void *_ignored)
} }
static void * eventMain(void * arg) { static void *
eventMain(void *arg)
{
char msg[256]; char msg[256];
struct mg_context *ctx = (struct mg_context *)arg; struct mg_context *ctx = (struct mg_context *)arg;
@ -163,7 +188,9 @@ static void * eventMain(void * arg) {
} }
void websock_send_broadcast(struct mg_context *ctx, const char * data, int data_len) { void
websock_send_broadcast(struct mg_context *ctx, const char *data, int data_len)
{
char buffer[260]; char buffer[260];
@ -176,7 +203,9 @@ void websock_send_broadcast(struct mg_context *ctx, const char * data, int data_
} }
void websock_init_lib(const struct mg_context *ctx) { void
websock_init_lib(const struct mg_context *ctx)
{
tWebSockContext *ws_ctx = (tWebSockContext *)mg_get_user_data(ctx); tWebSockContext *ws_ctx = (tWebSockContext *)mg_get_user_data(ctx);
memset(ws_ctx, 0, sizeof(*ws_ctx)); memset(ws_ctx, 0, sizeof(*ws_ctx));
@ -185,7 +214,9 @@ void websock_init_lib(const struct mg_context *ctx) {
} }
void websock_exit_lib(const struct mg_context *ctx) { void
websock_exit_lib(const struct mg_context *ctx)
{
tWebSockContext *ws_ctx = (tWebSockContext *)mg_get_user_data(ctx); tWebSockContext *ws_ctx = (tWebSockContext *)mg_get_user_data(ctx);
ws_ctx->runLoop = 0; ws_ctx->runLoop = 0;

9
examples/websocket/WebSockCallbacks.h
View File

@ -25,10 +25,15 @@ typedef struct tWebSockContext {
void websock_init_lib(const struct mg_context *ctx); void websock_init_lib(const struct mg_context *ctx);
void websock_exit_lib(const struct mg_context *ctx); void websock_exit_lib(const struct mg_context *ctx);
void websock_send_broadcast(struct mg_context *ctx, const char * data, int data_len); void
websock_send_broadcast(struct mg_context *ctx, const char *data, int data_len);
void websocket_ready_handler(struct mg_connection *conn, void *_ignored); void websocket_ready_handler(struct mg_connection *conn, void *_ignored);
int websocket_data_handler(struct mg_connection *conn, int flags, char *data, size_t data_len, void *_ignored); int websocket_data_handler(struct mg_connection *conn,
int flags,
char *data,
size_t data_len,
void *_ignored);
void connection_close_handler(const struct mg_connection *conn, void *_ignored); void connection_close_handler(const struct mg_connection *conn, void *_ignored);

24
examples/websocket/websocket.c
View File

@ -10,7 +10,8 @@
#include "civetweb.h" #include "civetweb.h"
#include "WebSockCallbacks.h" #include "WebSockCallbacks.h"
int main(void) int
main(void)
{ {
struct mg_context *ctx = 0; struct mg_context *ctx = 0;
struct mg_callbacks callback_funcs = {0}; struct mg_callbacks callback_funcs = {0};
@ -19,28 +20,33 @@ int main(void)
const char *server_options[] = { const char *server_options[] = {
/* document_root: The path to the test function websock.htm */ /* document_root: The path to the test function websock.htm */
"document_root", "../../examples/websocket", "document_root",
"../../examples/websocket",
/* port: use http standard to match websocket url in websock.htm: ws://127.0.0.1/MyWebSock */ /* port: use http standard to match websocket url in websock.htm:
/* if the port is changed here, it needs to be changed in websock.htm as well */ ws://127.0.0.1/MyWebSock */
"listening_ports", "80", /* if the port is changed here, it needs to be changed in
websock.htm as well */
"listening_ports",
"80",
NULL NULL};
};
callback_funcs.init_context = websock_init_lib; callback_funcs.init_context = websock_init_lib;
callback_funcs.exit_context = websock_exit_lib; callback_funcs.exit_context = websock_exit_lib;
ctx = mg_start(&callback_funcs, &ws_ctx, server_options); ctx = mg_start(&callback_funcs, &ws_ctx, server_options);
mg_set_websocket_handler(ctx, "/MyWebSock", mg_set_websocket_handler(ctx,
"/MyWebSock",
NULL, NULL,
websocket_ready_handler, websocket_ready_handler,
websocket_data_handler, websocket_data_handler,
connection_close_handler, connection_close_handler,
NULL); NULL);
printf("Connect to localhost:%s/websock.htm\n", mg_get_option(ctx, "listening_ports")); printf("Connect to localhost:%s/websock.htm\n",
mg_get_option(ctx, "listening_ports"));
puts("Enter an (ASCII) character or * to exit:"); puts("Enter an (ASCII) character or * to exit:");
for (;;) { for (;;) {

161
examples/websocket_client/websocket_client.c
View File

@ -24,7 +24,8 @@
const char *websocket_welcome_msg = "websocket welcome\n"; const char *websocket_welcome_msg = "websocket welcome\n";
const size_t websocket_welcome_msg_len = 18 /* strlen(websocket_welcome_msg) */; const size_t websocket_welcome_msg_len = 18 /* strlen(websocket_welcome_msg) */;
const char *websocket_acknowledge_msg = "websocket msg ok\n"; const char *websocket_acknowledge_msg = "websocket msg ok\n";
const size_t websocket_acknowledge_msg_len = 17 /* strlen(websocket_acknowledge_msg) */ ; const size_t websocket_acknowledge_msg_len =
17 /* strlen(websocket_acknowledge_msg) */;
const char *websocket_goodbye_msg = "websocket bye\n"; const char *websocket_goodbye_msg = "websocket bye\n";
const size_t websocket_goodbye_msg_len = 14 /* strlen(websocket_goodbye_msg) */; const size_t websocket_goodbye_msg_len = 14 /* strlen(websocket_goodbye_msg) */;
@ -33,9 +34,11 @@ const size_t websocket_goodbye_msg_len = 14 /* strlen(websocket_goodbye_msg) */
/* WEBSOCKET SERVER */ /* WEBSOCKET SERVER */
/*************************************************************************************/ /*************************************************************************************/
#if defined(MG_LEGACY_INTERFACE) #if defined(MG_LEGACY_INTERFACE)
int websock_server_connect(const struct mg_connection * conn) int
websock_server_connect(const struct mg_connection *conn)
#else #else
int websocket_server_connect(const struct mg_connection * conn, void * _ignored) int
websocket_server_connect(const struct mg_connection *conn, void *_ignored)
#endif #endif
{ {
printf("Server: Websocket connected\n"); printf("Server: Websocket connected\n");
@ -44,24 +47,38 @@ int websocket_server_connect(const struct mg_connection * conn, void * _ignored)
#if defined(MG_LEGACY_INTERFACE) #if defined(MG_LEGACY_INTERFACE)
void websocket_server_ready(struct mg_connection * conn) void
websocket_server_ready(struct mg_connection *conn)
#else #else
void websocket_server_ready(struct mg_connection * conn, void * _ignored) void
websocket_server_ready(struct mg_connection *conn, void *_ignored)
#endif #endif
{ {
printf("Server: Websocket ready\n"); printf("Server: Websocket ready\n");
/* Send websocket welcome message */ /* Send websocket welcome message */
mg_lock_connection(conn); mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, websocket_welcome_msg, websocket_welcome_msg_len); mg_websocket_write(conn,
WEBSOCKET_OPCODE_TEXT,
websocket_welcome_msg,
websocket_welcome_msg_len);
mg_unlock_connection(conn); mg_unlock_connection(conn);
} }
#if defined(MG_LEGACY_INTERFACE) #if defined(MG_LEGACY_INTERFACE)
int websocket_server_data(struct mg_connection * conn, int bits, char *data, size_t data_len) int
websocket_server_data(struct mg_connection *conn,
int bits,
char *data,
size_t data_len)
#else #else
int websocket_server_data(struct mg_connection * conn, int bits, char *data, size_t data_len, void *_ignored) int
websocket_server_data(struct mg_connection *conn,
int bits,
char *data,
size_t data_len,
void *_ignored)
#endif #endif
{ {
printf("Server: Got %u bytes from the client\n", data_len); printf("Server: Got %u bytes from the client\n", data_len);
@ -69,12 +86,18 @@ int websocket_server_data(struct mg_connection * conn, int bits, char *data, siz
if (data_len < 3 || 0 != memcmp(data, "bye", 3)) { if (data_len < 3 || 0 != memcmp(data, "bye", 3)) {
/* Send websocket acknowledge message */ /* Send websocket acknowledge message */
mg_lock_connection(conn); mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, websocket_acknowledge_msg, websocket_acknowledge_msg_len); mg_websocket_write(conn,
WEBSOCKET_OPCODE_TEXT,
websocket_acknowledge_msg,
websocket_acknowledge_msg_len);
mg_unlock_connection(conn); mg_unlock_connection(conn);
} else { } else {
/* Send websocket acknowledge message */ /* Send websocket acknowledge message */
mg_lock_connection(conn); mg_lock_connection(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, websocket_goodbye_msg, websocket_goodbye_msg_len); mg_websocket_write(conn,
WEBSOCKET_OPCODE_TEXT,
websocket_goodbye_msg,
websocket_goodbye_msg_len);
mg_unlock_connection(conn); mg_unlock_connection(conn);
} }
@ -83,25 +106,33 @@ int websocket_server_data(struct mg_connection * conn, int bits, char *data, siz
#if defined(MG_LEGACY_INTERFACE) #if defined(MG_LEGACY_INTERFACE)
void websocket_server_connection_close(const struct mg_connection * conn) void
websocket_server_connection_close(const struct mg_connection *conn)
#else #else
void websocket_server_connection_close(const struct mg_connection * conn, void *_ignored) void
websocket_server_connection_close(const struct mg_connection *conn,
void *_ignored)
#endif #endif
{ {
printf("Server: Close connection\n"); printf("Server: Close connection\n");
/* Can not send a websocket goodbye message here - the connection is already closed */ /* Can not send a websocket goodbye message here - the connection is already
* closed */
} }
struct mg_context * start_websocket_server() struct mg_context *
start_websocket_server()
{ {
const char * options[] = { "document_root", DOCUMENT_ROOT, const char *options[] = {"document_root",
"ssl_certificate", SSL_CERT, DOCUMENT_ROOT,
"listening_ports", PORT, "ssl_certificate",
"request_timeout_ms", "5000", SSL_CERT,
0 "listening_ports",
}; PORT,
"request_timeout_ms",
"5000",
0};
struct mg_callbacks callbacks; struct mg_callbacks callbacks;
struct mg_context *ctx; struct mg_context *ctx;
@ -119,7 +150,8 @@ struct mg_context * start_websocket_server()
/* New interface: */ /* New interface: */
ctx = mg_start(&callbacks, 0, options); ctx = mg_start(&callbacks, 0, options);
mg_set_websocket_handler(ctx, "/websocket", mg_set_websocket_handler(ctx,
"/websocket",
websocket_server_connect, websocket_server_connect,
websocket_server_ready, websocket_server_ready,
websocket_server_data, websocket_server_data,
@ -140,10 +172,16 @@ struct tclient_data {
int closed; int closed;
}; };
static int websocket_client_data_handler(struct mg_connection *conn, int flags, char *data, size_t data_len, void * user_data) static int
websocket_client_data_handler(struct mg_connection *conn,
int flags,
char *data,
size_t data_len,
void *user_data)
{ {
struct mg_context *ctx = mg_get_context(conn); struct mg_context *ctx = mg_get_context(conn);
struct tclient_data *pclient_data = (struct tclient_data *) mg_get_user_data(ctx); struct tclient_data *pclient_data =
(struct tclient_data *)mg_get_user_data(ctx);
printf("Client received data from server: "); printf("Client received data from server: ");
fwrite(data, 1, data_len, stdout); fwrite(data, 1, data_len, stdout);
@ -157,17 +195,21 @@ static int websocket_client_data_handler(struct mg_connection *conn, int flags,
return 1; return 1;
} }
static void websocket_client_close_handler(const struct mg_connection *conn, void * user_data) static void
websocket_client_close_handler(const struct mg_connection *conn,
void *user_data)
{ {
struct mg_context *ctx = mg_get_context(conn); struct mg_context *ctx = mg_get_context(conn);
struct tclient_data *pclient_data = (struct tclient_data *) mg_get_user_data(ctx); struct tclient_data *pclient_data =
(struct tclient_data *)mg_get_user_data(ctx);
printf("Client: Close handler\n"); printf("Client: Close handler\n");
pclient_data->closed++; pclient_data->closed++;
} }
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
struct mg_context *ctx = NULL; struct mg_context *ctx = NULL;
struct tclient_data client1_data = {NULL, 0, 0}; struct tclient_data client1_data = {NULL, 0, 0};
@ -186,12 +228,18 @@ int main(int argc, char *argv[])
printf("Server init\n\n"); printf("Server init\n\n");
/* Then connect a first client */ /* Then connect a first client */
newconn1 = mg_connect_websocket_client("localhost", atoi(PORT), 0, ebuf, sizeof(ebuf), newconn1 = mg_connect_websocket_client("localhost",
"/websocket", NULL, websocket_client_data_handler, websocket_client_close_handler, atoi(PORT),
0,
ebuf,
sizeof(ebuf),
"/websocket",
NULL,
websocket_client_data_handler,
websocket_client_close_handler,
&client1_data); &client1_data);
if (newconn1 == NULL) if (newconn1 == NULL) {
{
printf("Error: %s", ebuf); printf("Error: %s", ebuf);
return 1; return 1;
} }
@ -203,7 +251,9 @@ int main(int argc, char *argv[])
assert(client2_data.len == 0); assert(client2_data.len == 0);
assert(client1_data.data != NULL); assert(client1_data.data != NULL);
assert(client1_data.len == websocket_welcome_msg_len); assert(client1_data.len == websocket_welcome_msg_len);
assert(!memcmp(client1_data.data, websocket_welcome_msg, websocket_welcome_msg_len)); assert(!memcmp(client1_data.data,
websocket_welcome_msg,
websocket_welcome_msg_len));
free(client1_data.data); free(client1_data.data);
client1_data.data = NULL; client1_data.data = NULL;
client1_data.len = 0; client1_data.len = 0;
@ -217,18 +267,26 @@ int main(int argc, char *argv[])
assert(client2_data.len == 0); assert(client2_data.len == 0);
assert(client1_data.data != NULL); assert(client1_data.data != NULL);
assert(client1_data.len == websocket_acknowledge_msg_len); assert(client1_data.len == websocket_acknowledge_msg_len);
assert(!memcmp(client1_data.data, websocket_acknowledge_msg, websocket_acknowledge_msg_len)); assert(!memcmp(client1_data.data,
websocket_acknowledge_msg,
websocket_acknowledge_msg_len));
free(client1_data.data); free(client1_data.data);
client1_data.data = NULL; client1_data.data = NULL;
client1_data.len = 0; client1_data.len = 0;
/* Now connect a second client */ /* Now connect a second client */
newconn2 = mg_connect_websocket_client("localhost", atoi(PORT), 0, ebuf, sizeof(ebuf), newconn2 = mg_connect_websocket_client("localhost",
"/websocket", NULL, websocket_client_data_handler, websocket_client_close_handler, atoi(PORT),
0,
ebuf,
sizeof(ebuf),
"/websocket",
NULL,
websocket_client_data_handler,
websocket_client_close_handler,
&client2_data); &client2_data);
if (newconn2 == NULL) if (newconn2 == NULL) {
{
printf("Error: %s", ebuf); printf("Error: %s", ebuf);
return 1; return 1;
} }
@ -240,7 +298,9 @@ int main(int argc, char *argv[])
assert(client1_data.len == 0); assert(client1_data.len == 0);
assert(client2_data.data != NULL); assert(client2_data.data != NULL);
assert(client2_data.len == websocket_welcome_msg_len); assert(client2_data.len == websocket_welcome_msg_len);
assert(!memcmp(client2_data.data, websocket_welcome_msg, websocket_welcome_msg_len)); assert(!memcmp(client2_data.data,
websocket_welcome_msg,
websocket_welcome_msg_len));
free(client2_data.data); free(client2_data.data);
client2_data.data = NULL; client2_data.data = NULL;
client2_data.len = 0; client2_data.len = 0;
@ -254,7 +314,9 @@ int main(int argc, char *argv[])
assert(client2_data.len == 0); assert(client2_data.len == 0);
assert(client1_data.data != NULL); assert(client1_data.data != NULL);
assert(client1_data.len == websocket_acknowledge_msg_len); assert(client1_data.len == websocket_acknowledge_msg_len);
assert(!memcmp(client1_data.data, websocket_acknowledge_msg, websocket_acknowledge_msg_len)); assert(!memcmp(client1_data.data,
websocket_acknowledge_msg,
websocket_acknowledge_msg_len));
free(client1_data.data); free(client1_data.data);
client1_data.data = NULL; client1_data.data = NULL;
client1_data.len = 0; client1_data.len = 0;
@ -268,7 +330,9 @@ int main(int argc, char *argv[])
assert(client2_data.len == 0); assert(client2_data.len == 0);
assert(client1_data.data != NULL); assert(client1_data.data != NULL);
assert(client1_data.len == websocket_goodbye_msg_len); assert(client1_data.len == websocket_goodbye_msg_len);
assert(!memcmp(client1_data.data, websocket_goodbye_msg, websocket_goodbye_msg_len)); assert(!memcmp(client1_data.data,
websocket_goodbye_msg,
websocket_goodbye_msg_len));
free(client1_data.data); free(client1_data.data);
client1_data.data = NULL; client1_data.data = NULL;
client1_data.len = 0; client1_data.len = 0;
@ -292,7 +356,9 @@ int main(int argc, char *argv[])
assert(client1_data.len == 0); assert(client1_data.len == 0);
assert(client2_data.data != NULL); assert(client2_data.data != NULL);
assert(client2_data.len == websocket_goodbye_msg_len); assert(client2_data.len == websocket_goodbye_msg_len);
assert(!memcmp(client2_data.data, websocket_goodbye_msg, websocket_goodbye_msg_len)); assert(!memcmp(client2_data.data,
websocket_goodbye_msg,
websocket_goodbye_msg_len));
free(client2_data.data); free(client2_data.data);
client2_data.data = NULL; client2_data.data = NULL;
client2_data.len = 0; client2_data.len = 0;
@ -308,8 +374,15 @@ int main(int argc, char *argv[])
assert(client2_data.len == 0); assert(client2_data.len == 0);
/* Connect client 3 */ /* Connect client 3 */
newconn3 = mg_connect_websocket_client("localhost", atoi(PORT), 0, ebuf, sizeof(ebuf), newconn3 = mg_connect_websocket_client("localhost",
"/websocket", NULL, websocket_client_data_handler, websocket_client_close_handler, atoi(PORT),
0,
ebuf,
sizeof(ebuf),
"/websocket",
NULL,
websocket_client_data_handler,
websocket_client_close_handler,
&client3_data); &client3_data);
sleep(1); /* Client 3 should get the websocket welcome message */ sleep(1); /* Client 3 should get the websocket welcome message */
@ -322,7 +395,9 @@ int main(int argc, char *argv[])
assert(client2_data.len == 0); assert(client2_data.len == 0);
assert(client3_data.data != NULL); assert(client3_data.data != NULL);
assert(client3_data.len == websocket_welcome_msg_len); assert(client3_data.len == websocket_welcome_msg_len);
assert(!memcmp(client3_data.data, websocket_welcome_msg, websocket_welcome_msg_len)); assert(!memcmp(client3_data.data,
websocket_welcome_msg,
websocket_welcome_msg_len));
free(client3_data.data); free(client3_data.data);
client3_data.data = NULL; client3_data.data = NULL;
client3_data.len = 0; client3_data.len = 0;

12
include/CivetServer.h
View File

@ -127,7 +127,8 @@ class CIVETWEB_API CivetServer
* *
* @return the context or 0 if not running. * @return the context or 0 if not running.
*/ */
const struct mg_context *getContext() const const struct mg_context *
getContext() const
{ {
return context; return context;
} }
@ -145,7 +146,8 @@ class CIVETWEB_API CivetServer
*/ */
void addHandler(const std::string &uri, CivetHandler *handler); void addHandler(const std::string &uri, CivetHandler *handler);
void addHandler(const std::string &uri, CivetHandler &handler) void
addHandler(const std::string &uri, CivetHandler &handler)
{ {
addHandler(uri, &handler); addHandler(uri, &handler);
} }
@ -236,7 +238,8 @@ class CIVETWEB_API CivetServer
*based). *based).
* @return true if key was found * @return true if key was found
*/ */
static bool getParam(const std::string &data, static bool
getParam(const std::string &data,
const char *name, const char *name,
std::string &dst, std::string &dst,
size_t occurrence = 0) size_t occurrence = 0)
@ -275,7 +278,8 @@ class CIVETWEB_API CivetServer
* uses '+' as character for space, see RFC 1866 section 8.2.1 * uses '+' as character for space, see RFC 1866 section 8.2.1
* http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt * http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt
*/ */
static void urlDecode(const std::string &src, static void
urlDecode(const std::string &src,
std::string &dst, std::string &dst,
bool is_form_url_encoded = true) bool is_form_url_encoded = true)
{ {

5
include/civetweb.h
View File

@ -388,7 +388,6 @@ enum {
The array is terminated by a NULL name option. */ The array is terminated by a NULL name option. */
CIVETWEB_API const struct mg_option *mg_get_valid_options(void); CIVETWEB_API const struct mg_option *mg_get_valid_options(void);
struct mg_server_ports { struct mg_server_ports {
int protocol; /* 1 = IPv4, 2 = IPv6, 3 = both */ int protocol; /* 1 = IPv4, 2 = IPv6, 3 = both */
int port; /* port number */ int port; /* port number */
@ -409,12 +408,10 @@ CIVETWEB_API int mg_get_server_ports(const struct mg_context *ctx,
int size, int size,
struct mg_server_ports *ports); struct mg_server_ports *ports);
/* Deprecated. Use mg_get_server_ports instead. */ /* Deprecated. Use mg_get_server_ports instead. */
CIVETWEB_API size_t CIVETWEB_API size_t
mg_get_ports(const struct mg_context *ctx, size_t size, int *ports, int *ssl); mg_get_ports(const struct mg_context *ctx, size_t size, int *ports, int *ssl);
/* Add, edit or delete the entry in the passwords file. /* Add, edit or delete the entry in the passwords file.
This function allows an application to manipulate .htpasswd files on the This function allows an application to manipulate .htpasswd files on the
@ -755,7 +752,6 @@ CIVETWEB_API int mg_get_response(struct mg_connection *conn,
size_t ebuf_len, size_t ebuf_len,
int timeout); int timeout);
/* Check which features where set when civetweb has been compiled. /* Check which features where set when civetweb has been compiled.
Parameters: Parameters:
feature: specifies which feature should be checked feature: specifies which feature should be checked
@ -774,7 +770,6 @@ CIVETWEB_API int mg_get_response(struct mg_connection *conn,
*/ */
CIVETWEB_API unsigned mg_check_feature(unsigned feature); CIVETWEB_API unsigned mg_check_feature(unsigned feature);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */

78
src/CivetServer.cpp
View File

@ -15,43 +15,48 @@
#define UNUSED_PARAMETER(x) (void)(x) #define UNUSED_PARAMETER(x) (void)(x)
#endif #endif
bool CivetHandler::handleGet(CivetServer *server, struct mg_connection *conn) bool
CivetHandler::handleGet(CivetServer *server, struct mg_connection *conn)
{ {
UNUSED_PARAMETER(server); UNUSED_PARAMETER(server);
UNUSED_PARAMETER(conn); UNUSED_PARAMETER(conn);
return false; return false;
} }
bool CivetHandler::handlePost(CivetServer *server, struct mg_connection *conn) bool
CivetHandler::handlePost(CivetServer *server, struct mg_connection *conn)
{ {
UNUSED_PARAMETER(server); UNUSED_PARAMETER(server);
UNUSED_PARAMETER(conn); UNUSED_PARAMETER(conn);
return false; return false;
} }
bool CivetHandler::handlePut(CivetServer *server, struct mg_connection *conn) bool
CivetHandler::handlePut(CivetServer *server, struct mg_connection *conn)
{ {
UNUSED_PARAMETER(server); UNUSED_PARAMETER(server);
UNUSED_PARAMETER(conn); UNUSED_PARAMETER(conn);
return false; return false;
} }
bool CivetHandler::handleDelete(CivetServer *server, struct mg_connection *conn) bool
CivetHandler::handleDelete(CivetServer *server, struct mg_connection *conn)
{ {
UNUSED_PARAMETER(server); UNUSED_PARAMETER(server);
UNUSED_PARAMETER(conn); UNUSED_PARAMETER(conn);
return false; return false;
} }
bool CivetHandler::handleOptions(CivetServer *server, bool
struct mg_connection *conn) CivetHandler::handleOptions(CivetServer *server, struct mg_connection *conn)
{ {
UNUSED_PARAMETER(server); UNUSED_PARAMETER(server);
UNUSED_PARAMETER(conn); UNUSED_PARAMETER(conn);
return false; return false;
} }
int CivetServer::requestHandler(struct mg_connection *conn, void *cbdata) int
CivetServer::requestHandler(struct mg_connection *conn, void *cbdata)
{ {
const struct mg_request_info *request_info = mg_get_request_info(conn); const struct mg_request_info *request_info = mg_get_request_info(conn);
assert(request_info != NULL); assert(request_info != NULL);
@ -110,7 +115,8 @@ CivetServer::~CivetServer()
close(); close();
} }
void CivetServer::closeHandler(const struct mg_connection *conn) void
CivetServer::closeHandler(const struct mg_connection *conn)
{ {
const struct mg_request_info *request_info = mg_get_request_info(conn); const struct mg_request_info *request_info = mg_get_request_info(conn);
assert(request_info != NULL); assert(request_info != NULL);
@ -128,17 +134,20 @@ void CivetServer::closeHandler(const struct mg_connection *conn)
mg_unlock_context(me->context); mg_unlock_context(me->context);
} }
void CivetServer::addHandler(const std::string &uri, CivetHandler *handler) void
CivetServer::addHandler(const std::string &uri, CivetHandler *handler)
{ {
mg_set_request_handler(context, uri.c_str(), requestHandler, handler); mg_set_request_handler(context, uri.c_str(), requestHandler, handler);
} }
void CivetServer::removeHandler(const std::string &uri) void
CivetServer::removeHandler(const std::string &uri)
{ {
mg_set_request_handler(context, uri.c_str(), NULL, NULL); mg_set_request_handler(context, uri.c_str(), NULL, NULL);
} }
void CivetServer::close() void
CivetServer::close()
{ {
if (context) { if (context) {
mg_stop(context); mg_stop(context);
@ -146,7 +155,8 @@ void CivetServer::close()
} }
} }
int CivetServer::getCookie(struct mg_connection *conn, int
CivetServer::getCookie(struct mg_connection *conn,
const std::string &cookieName, const std::string &cookieName,
std::string &cookieValue) std::string &cookieValue)
{ {
@ -154,27 +164,32 @@ int CivetServer::getCookie(struct mg_connection *conn,
// http://msdn.microsoft.com/en-us/library/ms178194.aspx // http://msdn.microsoft.com/en-us/library/ms178194.aspx
char _cookieValue[4096]; char _cookieValue[4096];
const char *cookie = mg_get_header(conn, "Cookie"); const char *cookie = mg_get_header(conn, "Cookie");
int lRead = mg_get_cookie( int lRead = mg_get_cookie(cookie,
cookie, cookieName.c_str(), _cookieValue, sizeof(_cookieValue)); cookieName.c_str(),
_cookieValue,
sizeof(_cookieValue));
cookieValue.clear(); cookieValue.clear();
cookieValue.append(_cookieValue); cookieValue.append(_cookieValue);
return lRead; return lRead;
} }
const char *CivetServer::getHeader(struct mg_connection *conn, const char *
CivetServer::getHeader(struct mg_connection *conn,
const std::string &headerName) const std::string &headerName)
{ {
return mg_get_header(conn, headerName.c_str()); return mg_get_header(conn, headerName.c_str());
} }
void CivetServer::urlDecode(const char *src, void
CivetServer::urlDecode(const char *src,
std::string &dst, std::string &dst,
bool is_form_url_encoded) bool is_form_url_encoded)
{ {
urlDecode(src, strlen(src), dst, is_form_url_encoded); urlDecode(src, strlen(src), dst, is_form_url_encoded);
} }
void CivetServer::urlDecode(const char *src, void
CivetServer::urlDecode(const char *src,
size_t src_len, size_t src_len,
std::string &dst, std::string &dst,
bool is_form_url_encoded) bool is_form_url_encoded)
@ -184,9 +199,9 @@ void CivetServer::urlDecode(const char *src,
dst.clear(); dst.clear();
for (i = j = 0; i < (int)src_len; i++, j++) { for (i = j = 0; i < (int)src_len; i++, j++) {
if (i < (int)src_len - 2 && src[i] == '%' && if (i < (int)src_len - 2 && src[i] == '%'
isxdigit(*(const unsigned char *)(src + i + 1)) && && isxdigit(*(const unsigned char *)(src + i + 1))
isxdigit(*(const unsigned char *)(src + i + 2))) { && isxdigit(*(const unsigned char *)(src + i + 2))) {
a = tolower(*(const unsigned char *)(src + i + 1)); a = tolower(*(const unsigned char *)(src + i + 1));
b = tolower(*(const unsigned char *)(src + i + 2)); b = tolower(*(const unsigned char *)(src + i + 2));
dst.push_back((char)((HEXTOI(a) << 4) | HEXTOI(b))); dst.push_back((char)((HEXTOI(a) << 4) | HEXTOI(b)));
@ -199,7 +214,8 @@ void CivetServer::urlDecode(const char *src,
} }
} }
bool CivetServer::getParam(struct mg_connection *conn, bool
CivetServer::getParam(struct mg_connection *conn,
const char *name, const char *name,
std::string &dst, std::string &dst,
size_t occurrence) size_t occurrence)
@ -250,7 +266,8 @@ bool CivetServer::getParam(struct mg_connection *conn,
return false; return false;
} }
bool CivetServer::getParam(const char *data, bool
CivetServer::getParam(const char *data,
size_t data_len, size_t data_len,
const char *name, const char *name,
std::string &dst, std::string &dst,
@ -268,8 +285,8 @@ bool CivetServer::getParam(const char *data,
// data is "var1=val1&var2=val2...". Find variable first // data is "var1=val1&var2=val2...". Find variable first
for (p = data; p + name_len < e; p++) { for (p = data; p + name_len < e; p++) {
if ((p == data || p[-1] == '&') && p[name_len] == '=' && if ((p == data || p[-1] == '&') && p[name_len] == '='
!mg_strncasecmp(name, p, name_len) && 0 == occurrence--) { && !mg_strncasecmp(name, p, name_len) && 0 == occurrence--) {
// Point p to variable value // Point p to variable value
p += name_len + 1; p += name_len + 1;
@ -289,12 +306,14 @@ bool CivetServer::getParam(const char *data,
return false; return false;
} }
void CivetServer::urlEncode(const char *src, std::string &dst, bool append) void
CivetServer::urlEncode(const char *src, std::string &dst, bool append)
{ {
urlEncode(src, strlen(src), dst, append); urlEncode(src, strlen(src), dst, append);
} }
void CivetServer::urlEncode(const char *src, void
CivetServer::urlEncode(const char *src,
size_t src_len, size_t src_len,
std::string &dst, std::string &dst,
bool append) bool append)
@ -306,8 +325,8 @@ void CivetServer::urlEncode(const char *src,
dst.clear(); dst.clear();
for (; src_len > 0; src++, src_len--) { for (; src_len > 0; src++, src_len--) {
if (isalnum(*(const unsigned char *)src) || if (isalnum(*(const unsigned char *)src)
strchr(dont_escape, *(const unsigned char *)src) != NULL) { || strchr(dont_escape, *(const unsigned char *)src) != NULL) {
dst.push_back(*src); dst.push_back(*src);
} else { } else {
dst.push_back('%'); dst.push_back('%');
@ -317,7 +336,8 @@ void CivetServer::urlEncode(const char *src,
} }
} }
std::vector<int> CivetServer::getListeningPorts() std::vector<int>
CivetServer::getListeningPorts()
{ {
std::vector<int> ports(10); std::vector<int> ports(10);
std::vector<int> ssl(10); std::vector<int> ssl(10);

1546
src/civetweb.c
View File

File diff suppressed because it is too large Load Diff

264
src/main.c
View File

@ -71,8 +71,8 @@
#define printf \ #define printf \
DO_NOT_USE_THIS_FUNCTION__USE_fprintf /* Required for unit testing */ DO_NOT_USE_THIS_FUNCTION__USE_fprintf /* Required for unit testing */
#if defined(_WIN32) && \ #if defined(_WIN32) \
!defined(__SYMBIAN32__) /* WINDOWS / UNIX include block */ && !defined(__SYMBIAN32__) /* WINDOWS / UNIX include block */
#ifndef _WIN32_WINNT #ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501 /* for tdm-gcc so we can use getconsolewindow */ #define _WIN32_WINNT 0x0501 /* for tdm-gcc so we can use getconsolewindow */
#endif #endif
@ -157,12 +157,14 @@ static struct mg_option main_config_options[] = {
{"icon", CONFIG_TYPE_STRING, NULL}, {"icon", CONFIG_TYPE_STRING, NULL},
{NULL, CONFIG_TYPE_UNKNOWN, NULL}}; {NULL, CONFIG_TYPE_UNKNOWN, NULL}};
static void WINCDECL signal_handler(int sig_num) static void WINCDECL
signal_handler(int sig_num)
{ {
g_exit_flag = sig_num; g_exit_flag = sig_num;
} }
static NO_RETURN void die(const char *fmt, ...) static NO_RETURN void
die(const char *fmt, ...)
{ {
va_list ap; va_list ap;
char msg[200] = ""; char msg[200] = "";
@ -185,7 +187,8 @@ static NO_RETURN void die(const char *fmt, ...)
static int MakeConsole(void); static int MakeConsole(void);
#endif #endif
static void show_server_name(void) static void
show_server_name(void)
{ {
#ifdef WIN32 #ifdef WIN32
(void)MakeConsole(); (void)MakeConsole();
@ -194,7 +197,8 @@ static void show_server_name(void)
fprintf(stderr, "CivetWeb v%s, built on %s\n", mg_version(), __DATE__); fprintf(stderr, "CivetWeb v%s, built on %s\n", mg_version(), __DATE__);
} }
static NO_RETURN void show_usage_and_exit(const char *exeName) static NO_RETURN void
show_usage_and_exit(const char *exeName)
{ {
const struct mg_option *options; const struct mg_option *options;
int i; int i;
@ -212,8 +216,9 @@ static NO_RETURN void show_usage_and_exit(const char *exeName)
fprintf(stderr, " Show system information:\n"); fprintf(stderr, " Show system information:\n");
fprintf(stderr, " %s -I\n", exeName); fprintf(stderr, " %s -I\n", exeName);
fprintf(stderr, " Add user/change password:\n"); fprintf(stderr, " Add user/change password:\n");
fprintf( fprintf(stderr,
stderr, " %s -A <htpasswd_file> <realm> <user> <passwd>\n", exeName); " %s -A <htpasswd_file> <realm> <user> <passwd>\n",
exeName);
fprintf(stderr, " Remove user:\n"); fprintf(stderr, " Remove user:\n");
fprintf(stderr, " %s -R <htpasswd_file> <realm> <user>\n", exeName); fprintf(stderr, " %s -R <htpasswd_file> <realm> <user>\n", exeName);
fprintf(stderr, "\nOPTIONS:\n"); fprintf(stderr, "\nOPTIONS:\n");
@ -250,14 +255,15 @@ static const char *config_file_top_comment =
"# To make a change, remove leading '#', modify option's value,\n" "# To make a change, remove leading '#', modify option's value,\n"
"# save this file and then restart Civetweb.\n\n"; "# save this file and then restart Civetweb.\n\n";
static const char *get_url_to_first_open_port(const struct mg_context *ctx) static const char *
get_url_to_first_open_port(const struct mg_context *ctx)
{ {
static char url[100]; static char url[100];
const char *open_ports = mg_get_option(ctx, "listening_ports"); const char *open_ports = mg_get_option(ctx, "listening_ports");
int a, b, c, d, port, n; int a, b, c, d, port, n;
if (sscanf(open_ports, "%d.%d.%d.%d:%d%n", &a, &b, &c, &d, &port, &n) == if (sscanf(open_ports, "%d.%d.%d.%d:%d%n", &a, &b, &c, &d, &port, &n)
5) { == 5) {
snprintf(url, snprintf(url,
sizeof(url), sizeof(url),
"%s://%d.%d.%d.%d:%d", "%s://%d.%d.%d.%d:%d",
@ -281,7 +287,8 @@ static const char *get_url_to_first_open_port(const struct mg_context *ctx)
} }
#ifdef ENABLE_CREATE_CONFIG_FILE #ifdef ENABLE_CREATE_CONFIG_FILE
static void create_config_file(const struct mg_context *ctx, const char *path) static void
create_config_file(const struct mg_context *ctx, const char *path)
{ {
const struct mg_option *options; const struct mg_option *options;
const char *value; const char *value;
@ -296,8 +303,10 @@ static void create_config_file(const struct mg_context *ctx, const char *path)
options = mg_get_valid_options(); options = mg_get_valid_options();
for (i = 0; options[i].name != NULL; i++) { for (i = 0; options[i].name != NULL; i++) {
value = mg_get_option(ctx, options[i].name); value = mg_get_option(ctx, options[i].name);
fprintf( fprintf(fp,
fp, "# %s %s\n", options[i].name, value ? value : "<value>"); "# %s %s\n",
options[i].name,
value ? value : "<value>");
} }
fclose(fp); fclose(fp);
} }
@ -305,7 +314,8 @@ static void create_config_file(const struct mg_context *ctx, const char *path)
#endif #endif
#endif #endif
static char *sdup(const char *str) static char *
sdup(const char *str)
{ {
size_t len; size_t len;
char *p; char *p;
@ -317,7 +327,8 @@ static char *sdup(const char *str)
return p; return p;
} }
static const char *get_option(char **options, const char *option_name) static const char *
get_option(char **options, const char *option_name)
{ {
int i = 0; int i = 0;
const char *opt_value = NULL; const char *opt_value = NULL;
@ -339,7 +350,8 @@ static const char *get_option(char **options, const char *option_name)
return opt_value; return opt_value;
} }
static int set_option(char **options, const char *name, const char *value) static int
set_option(char **options, const char *name, const char *value)
{ {
int i, type; int i, type;
const struct mg_option *default_options = mg_get_valid_options(); const struct mg_option *default_options = mg_get_valid_options();
@ -416,7 +428,8 @@ static int set_option(char **options, const char *name, const char *value)
return 1; return 1;
} }
static void read_config_file(const char *config_file, char **options) static void
read_config_file(const char *config_file, char **options)
{ {
char line[MAX_CONF_FILE_LINE_SIZE], *p; char line[MAX_CONF_FILE_LINE_SIZE], *p;
FILE *fp = NULL; FILE *fp = NULL;
@ -452,8 +465,9 @@ static void read_config_file(const char *config_file, char **options)
} }
/* Skip spaces, \r and \n at the end of the line */ /* Skip spaces, \r and \n at the end of the line */
for (j = strlen(line) - 1; isspace(*(unsigned char *)&line[j]) || for (j = strlen(line) - 1;
iscntrl(*(unsigned char *)&line[j]);) isspace(*(unsigned char *)&line[j])
|| iscntrl(*(unsigned char *)&line[j]);)
line[j--] = 0; line[j--] = 0;
/* Find the space character between option name and value */ /* Find the space character between option name and value */
@ -484,7 +498,8 @@ static void read_config_file(const char *config_file, char **options)
} }
} }
static void process_command_line_arguments(char *argv[], char **options) static void
process_command_line_arguments(char *argv[], char **options)
{ {
char *p; char *p;
size_t i, cmd_line_opts_start = 1; size_t i, cmd_line_opts_start = 1;
@ -549,11 +564,12 @@ static void process_command_line_arguments(char *argv[], char **options)
} }
} }
static void init_server_name(int argc, const char *argv[]) static void
init_server_name(int argc, const char *argv[])
{ {
int i; int i;
assert(sizeof(main_config_options) / sizeof(main_config_options[0]) == assert(sizeof(main_config_options) / sizeof(main_config_options[0])
NUM_MAIN_OPTIONS + 1); == NUM_MAIN_OPTIONS + 1);
assert((strlen(mg_version()) + 12) < sizeof(g_server_base_name)); assert((strlen(mg_version()) + 12) < sizeof(g_server_base_name));
snprintf(g_server_base_name, snprintf(g_server_base_name,
sizeof(g_server_base_name), sizeof(g_server_base_name),
@ -562,22 +578,24 @@ static void init_server_name(int argc, const char *argv[])
g_server_name = g_server_base_name; g_server_name = g_server_base_name;
for (i = 0; i < argc - 1; i++) { for (i = 0; i < argc - 1; i++) {
if ((argv[i][0] == '-') && if ((argv[i][0] == '-')
(0 == && (0 == strcmp(argv[i] + 1,
strcmp(argv[i] + 1, main_config_options[OPTION_TITLE].name))) { main_config_options[OPTION_TITLE].name))) {
g_server_name = (char *)(argv[i + 1]); g_server_name = (char *)(argv[i + 1]);
} }
} }
g_icon_name = NULL; g_icon_name = NULL;
for (i = 0; i < argc - 1; i++) { for (i = 0; i < argc - 1; i++) {
if ((argv[i][0] == '-') && if ((argv[i][0] == '-')
(0 == strcmp(argv[i] + 1, main_config_options[OPTION_ICON].name))) { && (0 == strcmp(argv[i] + 1,
main_config_options[OPTION_ICON].name))) {
g_icon_name = (char *)(argv[i + 1]); g_icon_name = (char *)(argv[i + 1]);
} }
} }
} }
static int log_message(const struct mg_connection *conn, const char *message) static int
log_message(const struct mg_connection *conn, const char *message)
{ {
const struct mg_context *ctx = mg_get_context(conn); const struct mg_context *ctx = mg_get_context(conn);
struct tuser_data *ud = (struct tuser_data *)mg_get_user_data(ctx); struct tuser_data *ud = (struct tuser_data *)mg_get_user_data(ctx);
@ -591,14 +609,15 @@ static int log_message(const struct mg_connection *conn, const char *message)
return 0; return 0;
} }
static int is_path_absolute(const char *path) static int
is_path_absolute(const char *path)
{ {
#ifdef _WIN32 #ifdef _WIN32
return path != NULL && return path != NULL
((path[0] == '\\' && path[1] == '\\') || /* UNC path, e.g. && ((path[0] == '\\' && path[1] == '\\') || /* UNC path, e.g.
\\server\dir */ \\server\dir */
(isalpha(path[0]) && path[1] == ':' && (isalpha(path[0]) && path[1] == ':'
path[2] == '\\')); /* E.g. X:\dir */ && path[2] == '\\')); /* E.g. X:\dir */
#else #else
return path != NULL && path[0] == '/'; return path != NULL && path[0] == '/';
#endif #endif
@ -630,8 +649,8 @@ verify_existence(char **options, const char *option_name, int must_be_dir)
} }
#endif #endif
if (path != NULL && (stat(path, &st) != 0 || if (path != NULL && (stat(path, &st) != 0
((S_ISDIR(st.st_mode) ? 1 : 0) != must_be_dir))) { || ((S_ISDIR(st.st_mode) ? 1 : 0) != must_be_dir))) {
die("Invalid path for %s: [%s]: (%s). Make sure that path is either " die("Invalid path for %s: [%s]: (%s). Make sure that path is either "
"absolute, or it is relative to civetweb executable.", "absolute, or it is relative to civetweb executable.",
option_name, option_name,
@ -640,7 +659,8 @@ verify_existence(char **options, const char *option_name, int must_be_dir)
} }
} }
static void set_absolute_path(char *options[], static void
set_absolute_path(char *options[],
const char *option_name, const char *option_name,
const char *path_to_civetweb_exe) const char *path_to_civetweb_exe)
{ {
@ -682,7 +702,8 @@ static void set_absolute_path(char *options[],
#include "civetweb_lua.h" #include "civetweb_lua.h"
#include "civetweb_private_lua.h" #include "civetweb_private_lua.h"
static int run_lua(const char *file_name) static int
run_lua(const char *file_name)
{ {
struct lua_State *L; struct lua_State *L;
int lua_ret; int lua_ret;
@ -715,8 +736,10 @@ static int run_lua(const char *file_name)
if (lua_ret != LUA_OK) { if (lua_ret != LUA_OK) {
/* Error when executing the script */ /* Error when executing the script */
lua_err_txt = lua_tostring(L, -1); lua_err_txt = lua_tostring(L, -1);
fprintf( fprintf(stderr,
stderr, "Error running file %s: %s\n", file_name, lua_err_txt); "Error running file %s: %s\n",
file_name,
lua_err_txt);
} else { } else {
/* Script executed */ /* Script executed */
if (lua_type(L, -1) == LUA_TNUMBER) { if (lua_type(L, -1) == LUA_TNUMBER) {
@ -732,12 +755,12 @@ static int run_lua(const char *file_name)
} }
#endif #endif
#ifdef USE_DUKTAPE #ifdef USE_DUKTAPE
#include "duktape.h" #include "duktape.h"
static int run_duktape(const char *file_name) static int
run_duktape(const char *file_name)
{ {
duk_context *ctx = NULL; duk_context *ctx = NULL;
@ -764,14 +787,13 @@ finished:
} }
#endif #endif
#if defined(__MINGW32__) || defined(__MINGW64__) #if defined(__MINGW32__) || defined(__MINGW64__)
/* For __MINGW32/64_MAJOR/MINOR_VERSION define */ /* For __MINGW32/64_MAJOR/MINOR_VERSION define */
#include <_mingw.h> #include <_mingw.h>
#endif #endif
static void
static void start_civetweb(int argc, char *argv[]) start_civetweb(int argc, char *argv[])
{ {
struct mg_callbacks callbacks; struct mg_callbacks callbacks;
char *options[2 * MAX_OPTIONS + 1]; char *options[2 * MAX_OPTIONS + 1];
@ -966,8 +988,8 @@ static void start_civetweb(int argc, char *argv[])
} }
/* Show usage if -h or --help options are specified */ /* Show usage if -h or --help options are specified */
if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-H") || if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-H")
!strcmp(argv[1], "--help"))) { || !strcmp(argv[1], "--help"))) {
show_usage_and_exit(argv[0]); show_usage_and_exit(argv[0]);
} }
@ -1019,7 +1041,8 @@ static void start_civetweb(int argc, char *argv[])
} }
} }
static void stop_civetweb(void) static void
stop_civetweb(void)
{ {
mg_stop(g_ctx); mg_stop(g_ctx);
free(g_user_data.first_message); free(g_user_data.first_message);
@ -1063,7 +1086,8 @@ static SERVICE_STATUS_HANDLE hStatus;
static const char *service_magic_argument = "--"; static const char *service_magic_argument = "--";
static NOTIFYICONDATA TrayIcon; static NOTIFYICONDATA TrayIcon;
static void WINAPI ControlHandler(DWORD code) static void WINAPI
ControlHandler(DWORD code)
{ {
if (code == SERVICE_CONTROL_STOP || code == SERVICE_CONTROL_SHUTDOWN) { if (code == SERVICE_CONTROL_STOP || code == SERVICE_CONTROL_SHUTDOWN) {
ss.dwWin32ExitCode = 0; ss.dwWin32ExitCode = 0;
@ -1072,7 +1096,8 @@ static void WINAPI ControlHandler(DWORD code)
SetServiceStatus(hStatus, &ss); SetServiceStatus(hStatus, &ss);
} }
static void WINAPI ServiceMain(void) static void WINAPI
ServiceMain(void)
{ {
ss.dwServiceType = SERVICE_WIN32; ss.dwServiceType = SERVICE_WIN32;
ss.dwCurrentState = SERVICE_RUNNING; ss.dwCurrentState = SERVICE_RUNNING;
@ -1091,7 +1116,8 @@ static void WINAPI ServiceMain(void)
SetServiceStatus(hStatus, &ss); SetServiceStatus(hStatus, &ss);
} }
static void show_error(void) static void
show_error(void)
{ {
char buf[256]; char buf[256];
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
@ -1104,7 +1130,8 @@ static void show_error(void)
MessageBox(NULL, buf, "Error", MB_OK); MessageBox(NULL, buf, "Error", MB_OK);
} }
static void *align(void *ptr, DWORD alig) static void *
align(void *ptr, DWORD alig)
{ {
uintptr_t ul = (uintptr_t)ptr; uintptr_t ul = (uintptr_t)ptr;
ul += alig; ul += alig;
@ -1112,7 +1139,8 @@ static void *align(void *ptr, DWORD alig)
return ((void *)ul); return ((void *)ul);
} }
static void save_config(HWND hDlg, FILE *fp) static void
save_config(HWND hDlg, FILE *fp)
{ {
char value[2000] = ""; char value[2000] = "";
const char *default_value; const char *default_value;
@ -1226,8 +1254,9 @@ SettingsDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
!strcmp(value, "yes") ? BST_CHECKED !strcmp(value, "yes") ? BST_CHECKED
: BST_UNCHECKED); : BST_UNCHECKED);
} else { } else {
SetDlgItemText( SetDlgItemText(hDlg,
hDlg, ID_CONTROLS + i, value == NULL ? "" : value); ID_CONTROLS + i,
value == NULL ? "" : value);
} }
} }
break; break;
@ -1235,9 +1264,9 @@ SettingsDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
for (i = 0; default_options[i].name != NULL; i++) { for (i = 0; default_options[i].name != NULL; i++) {
name = default_options[i].name; name = default_options[i].name;
if (((default_options[i].type == CONFIG_TYPE_FILE) || if (((default_options[i].type == CONFIG_TYPE_FILE)
(default_options[i].type == CONFIG_TYPE_DIRECTORY)) && || (default_options[i].type == CONFIG_TYPE_DIRECTORY))
LOWORD(wParam) == ID_CONTROLS + i + ID_FILE_BUTTONS_DELTA) { && LOWORD(wParam) == ID_CONTROLS + i + ID_FILE_BUTTONS_DELTA) {
OPENFILENAME of; OPENFILENAME of;
BROWSEINFO bi; BROWSEINFO bi;
char path[PATH_MAX] = ""; char path[PATH_MAX] = "";
@ -1346,7 +1375,8 @@ InputDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP)
return FALSE; return FALSE;
} }
static void suggest_passwd(char *passwd) static void
suggest_passwd(char *passwd)
{ {
unsigned u; unsigned u;
char *p; char *p;
@ -1379,7 +1409,8 @@ static void add_control(unsigned char **mem,
short cy, short cy,
const char *caption); const char *caption);
static int get_password(const char *user, static int
get_password(const char *user,
const char *realm, const char *realm,
char *passwd, char *passwd,
unsigned passwd_len) unsigned passwd_len)
@ -1400,8 +1431,8 @@ static int get_password(const char *user,
wchar_t caption[1]; wchar_t caption[1];
WORD fontsiz; WORD fontsiz;
wchar_t fontface[7]; wchar_t fontface[7];
} dialog_header = {{WS_CAPTION | WS_POPUP | WS_SYSMENU | WS_VISIBLE | } dialog_header = {{WS_CAPTION | WS_POPUP | WS_SYSMENU | WS_VISIBLE
DS_SETFONT | WS_DLGFRAME, | DS_SETFONT | WS_DLGFRAME,
WS_EX_TOOLWINDOW, WS_EX_TOOLWINDOW,
0, 0,
200, 200,
@ -1449,8 +1480,8 @@ static int get_password(const char *user,
dia, dia,
0x81, 0x81,
ID_CONTROLS + 1, ID_CONTROLS + 1,
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
WS_DISABLED, | WS_DISABLED,
15 + LABEL_WIDTH, 15 + LABEL_WIDTH,
y, y,
WIDTH - LABEL_WIDTH - 25, WIDTH - LABEL_WIDTH - 25,
@ -1472,8 +1503,8 @@ static int get_password(const char *user,
dia, dia,
0x81, 0x81,
ID_CONTROLS + 2, ID_CONTROLS + 2,
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
WS_DISABLED, | WS_DISABLED,
15 + LABEL_WIDTH, 15 + LABEL_WIDTH,
y, y,
WIDTH - LABEL_WIDTH - 25, WIDTH - LABEL_WIDTH - 25,
@ -1557,16 +1588,18 @@ PasswordDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP)
ctrlId = LOWORD(wParam); ctrlId = LOWORD(wParam);
if (ctrlId == ID_ADD_USER) { if (ctrlId == ID_ADD_USER) {
/* Add user */ /* Add user */
GetWindowText( GetWindowText(GetDlgItem(hDlg, ID_ADD_USER_NAME),
GetDlgItem(hDlg, ID_ADD_USER_NAME), user, sizeof(user)); user,
GetWindowText( sizeof(user));
GetDlgItem(hDlg, ID_ADD_USER_REALM), domain, sizeof(domain)); GetWindowText(GetDlgItem(hDlg, ID_ADD_USER_REALM),
domain,
sizeof(domain));
if (get_password(user, domain, password, sizeof(password))) { if (get_password(user, domain, password, sizeof(password))) {
mg_modify_passwords_file(passfile, domain, user, password); mg_modify_passwords_file(passfile, domain, user, password);
EndDialog(hDlg, IDOK); EndDialog(hDlg, IDOK);
} }
} else if ((ctrlId >= (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 3)) && } else if ((ctrlId >= (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 3))
(ctrlId < (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 4))) { && (ctrlId < (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 4))) {
/* Modify password */ /* Modify password */
GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA * 3), GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA * 3),
user, user,
@ -1578,8 +1611,8 @@ PasswordDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP)
mg_modify_passwords_file(passfile, domain, user, password); mg_modify_passwords_file(passfile, domain, user, password);
EndDialog(hDlg, IDOK); EndDialog(hDlg, IDOK);
} }
} else if ((ctrlId >= (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 2)) && } else if ((ctrlId >= (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 2))
(ctrlId < (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 3))) { && (ctrlId < (ID_CONTROLS + ID_FILE_BUTTONS_DELTA * 3))) {
/* Remove user */ /* Remove user */
GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA * 2), GetWindowText(GetDlgItem(hDlg, ctrlId - ID_FILE_BUTTONS_DELTA * 2),
user, user,
@ -1607,7 +1640,8 @@ PasswordDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lP)
return FALSE; return FALSE;
} }
static void add_control(unsigned char **mem, static void
add_control(unsigned char **mem,
DLGTEMPLATE *dia, DLGTEMPLATE *dia,
WORD type, WORD type,
WORD id, WORD id,
@ -1648,7 +1682,8 @@ static void add_control(unsigned char **mem,
*mem = (unsigned char *)p; *mem = (unsigned char *)p;
} }
static void show_settings_dialog() static void
show_settings_dialog()
{ {
#define HEIGHT (15) #define HEIGHT (15)
#define WIDTH (460) #define WIDTH (460)
@ -1667,8 +1702,8 @@ static void show_settings_dialog()
wchar_t caption[1]; wchar_t caption[1];
WORD fontsiz; WORD fontsiz;
wchar_t fontface[7]; wchar_t fontface[7];
} dialog_header = {{WS_CAPTION | WS_POPUP | WS_SYSMENU | WS_VISIBLE | } dialog_header = {{WS_CAPTION | WS_POPUP | WS_SYSMENU | WS_VISIBLE
DS_SETFONT | WS_DLGFRAME, | DS_SETFONT | WS_DLGFRAME,
WS_EX_TOOLWINDOW, WS_EX_TOOLWINDOW,
0, 0,
200, 200,
@ -1704,8 +1739,8 @@ static void show_settings_dialog()
} else if (options[i].type == CONFIG_TYPE_BOOLEAN) { } else if (options[i].type == CONFIG_TYPE_BOOLEAN) {
cl = 0x80; cl = 0x80;
style |= BS_AUTOCHECKBOX; style |= BS_AUTOCHECKBOX;
} else if ((options[i].type == CONFIG_TYPE_FILE) || } else if ((options[i].type == CONFIG_TYPE_FILE)
(options[i].type == CONFIG_TYPE_DIRECTORY)) { || (options[i].type == CONFIG_TYPE_DIRECTORY)) {
style |= WS_BORDER | ES_AUTOHSCROLL; style |= WS_BORDER | ES_AUTOHSCROLL;
width -= 20; width -= 20;
cl = 0x81; cl = 0x81;
@ -1822,7 +1857,8 @@ static void show_settings_dialog()
#undef LABEL_WIDTH #undef LABEL_WIDTH
} }
static void change_password_file() static void
change_password_file()
{ {
#define HEIGHT (15) #define HEIGHT (15)
#define WIDTH (320) #define WIDTH (320)
@ -1844,8 +1880,8 @@ static void change_password_file()
wchar_t caption[1]; wchar_t caption[1];
WORD fontsiz; WORD fontsiz;
wchar_t fontface[7]; wchar_t fontface[7];
} dialog_header = {{WS_CAPTION | WS_POPUP | WS_SYSMENU | WS_VISIBLE | } dialog_header = {{WS_CAPTION | WS_POPUP | WS_SYSMENU | WS_VISIBLE
DS_SETFONT | WS_DLGFRAME, | DS_SETFONT | WS_DLGFRAME,
WS_EX_TOOLWINDOW, WS_EX_TOOLWINDOW,
0, 0,
200, 200,
@ -1930,8 +1966,8 @@ static void change_password_file()
dia, dia,
0x81, 0x81,
ID_CONTROLS + nelems + ID_FILE_BUTTONS_DELTA, ID_CONTROLS + nelems + ID_FILE_BUTTONS_DELTA,
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
WS_DISABLED, | WS_DISABLED,
245, 245,
y, y,
60, 60,
@ -1941,8 +1977,8 @@ static void change_password_file()
dia, dia,
0x81, 0x81,
ID_CONTROLS + nelems, ID_CONTROLS + nelems,
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
WS_DISABLED, | WS_DISABLED,
140, 140,
y, y,
100, 100,
@ -1969,8 +2005,8 @@ static void change_password_file()
dia, dia,
0x81, 0x81,
ID_ADD_USER_NAME, ID_ADD_USER_NAME,
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
WS_TABSTOP, | WS_TABSTOP,
140, 140,
y, y,
100, 100,
@ -1980,8 +2016,8 @@ static void change_password_file()
dia, dia,
0x81, 0x81,
ID_ADD_USER_REALM, ID_ADD_USER_REALM,
WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL
WS_TABSTOP, | WS_TABSTOP,
245, 245,
y, y,
60, 60,
@ -2016,8 +2052,8 @@ static void change_password_file()
dia->cy = y + 20; dia->cy = y + 20;
} while ((IDOK == DialogBoxIndirectParam( } while ((IDOK == DialogBoxIndirectParam(
NULL, dia, NULL, PasswordDlgProc, (LPARAM)path)) && NULL, dia, NULL, PasswordDlgProc, (LPARAM)path))
(!g_exit_flag)); && (!g_exit_flag));
guard--; guard--;
@ -2026,7 +2062,8 @@ static void change_password_file()
#undef LABEL_WIDTH #undef LABEL_WIDTH
} }
static int manage_service(int action) static int
manage_service(int action)
{ {
static const char *service_name = static const char *service_name =
"Civetweb"; /* TODO (mid): check using server_name instead of "Civetweb"; /* TODO (mid): check using server_name instead of
@ -2041,8 +2078,8 @@ static int manage_service(int action)
if ((hSCM = OpenSCManager(NULL, if ((hSCM = OpenSCManager(NULL,
NULL, NULL,
action == ID_INSTALL_SERVICE ? GENERIC_WRITE action == ID_INSTALL_SERVICE ? GENERIC_WRITE
: GENERIC_READ)) == : GENERIC_READ))
NULL) { == NULL) {
success = 0; success = 0;
show_error(); show_error();
} else if (action == ID_INSTALL_SERVICE) { } else if (action == ID_INSTALL_SERVICE) {
@ -2069,12 +2106,13 @@ static int manage_service(int action)
show_error(); show_error();
} }
} else if (action == ID_REMOVE_SERVICE) { } else if (action == ID_REMOVE_SERVICE) {
if ((hService = OpenService(hSCM, service_name, DELETE)) == NULL || if ((hService = OpenService(hSCM, service_name, DELETE)) == NULL
!DeleteService(hService)) { || !DeleteService(hService)) {
show_error(); show_error();
} }
} else if ((hService = OpenService( } else if ((hService =
hSCM, service_name, SERVICE_QUERY_STATUS)) == NULL) { OpenService(hSCM, service_name, SERVICE_QUERY_STATUS))
== NULL) {
success = 0; success = 0;
} }
@ -2149,8 +2187,10 @@ WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
case WM_LBUTTONUP: case WM_LBUTTONUP:
case WM_LBUTTONDBLCLK: case WM_LBUTTONDBLCLK:
hMenu = CreatePopupMenu(); hMenu = CreatePopupMenu();
AppendMenu( AppendMenu(hMenu,
hMenu, MF_STRING | MF_GRAYED, ID_SEPARATOR, g_server_name); MF_STRING | MF_GRAYED,
ID_SEPARATOR,
g_server_name);
AppendMenu(hMenu, MF_SEPARATOR, ID_SEPARATOR, ""); AppendMenu(hMenu, MF_SEPARATOR, ID_SEPARATOR, "");
service_installed = manage_service(0); service_installed = manage_service(0);
snprintf(buf, snprintf(buf,
@ -2195,7 +2235,8 @@ WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
return DefWindowProc(hWnd, msg, wParam, lParam); return DefWindowProc(hWnd, msg, wParam, lParam);
} }
static int MakeConsole(void) static int
MakeConsole(void)
{ {
DWORD err; DWORD err;
int ok = (GetConsoleWindow() != NULL); int ok = (GetConsoleWindow() != NULL);
@ -2229,7 +2270,8 @@ static int MakeConsole(void)
return ok; return ok;
} }
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR cmdline, int show) int WINAPI
WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR cmdline, int show)
{ {
WNDCLASS cls; WNDCLASS cls;
HWND hWnd; HWND hWnd;
@ -2290,8 +2332,8 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR cmdline, int show)
return (int)msg.wParam; return (int)msg.wParam;
} }
int
int main(int argc, char *argv[]) main(int argc, char *argv[])
{ {
(void)argc; (void)argc;
(void)argv; (void)argv;
@ -2299,7 +2341,6 @@ int main(int argc, char *argv[])
return WinMain(0, 0, 0, 0); return WinMain(0, 0, 0, 0);
} }
#elif defined(USE_COCOA) #elif defined(USE_COCOA)
#import <Cocoa/Cocoa.h> #import <Cocoa/Cocoa.h>
@ -2329,8 +2370,8 @@ int main(int argc, char *argv[])
} }
@end @end
int
int main(int argc, char *argv[]) main(int argc, char *argv[])
{ {
init_server_name(argc, (const char **)argv); init_server_name(argc, (const char **)argv);
start_civetweb(argc, argv); start_civetweb(argc, argv);
@ -2396,7 +2437,8 @@ int main(int argc, char *argv[])
#else #else
int main(int argc, char *argv[]) int
main(int argc, char *argv[])
{ {
init_server_name(argc, (const char **)argv); init_server_name(argc, (const char **)argv);
start_civetweb(argc, argv); start_civetweb(argc, argv);

23
src/md5.inl
View File

@ -207,7 +207,8 @@ MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
#define T63 (0x2ad7d2bb) #define T63 (0x2ad7d2bb)
#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
static void md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/) static void
md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
{ {
md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], md5_word_t a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2],
d = pms->abcd[3]; d = pms->abcd[3];
@ -270,8 +271,9 @@ static void md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
#define xbuf X /* (static only) */ #define xbuf X /* (static only) */
#endif #endif
for (i = 0; i < 16; ++i, xp += 4) for (i = 0; i < 16; ++i, xp += 4)
xbuf[i] = (md5_word_t)(xp[0]) + (md5_word_t)(xp[1] << 8) + xbuf[i] = (md5_word_t)(xp[0]) + (md5_word_t)(xp[1] << 8)
(md5_word_t)(xp[2] << 16) + (md5_word_t)(xp[3] << 24); + (md5_word_t)(xp[2] << 16)
+ (md5_word_t)(xp[3] << 24);
} }
#endif #endif
} }
@ -395,7 +397,8 @@ static void md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
pms->abcd[3] += d; pms->abcd[3] += d;
} }
MD5_STATIC void md5_init(md5_state_t *pms) MD5_STATIC void
md5_init(md5_state_t *pms)
{ {
pms->count[0] = pms->count[1] = 0; pms->count[0] = pms->count[1] = 0;
pms->abcd[0] = 0x67452301; pms->abcd[0] = 0x67452301;
@ -442,12 +445,14 @@ md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes)
memcpy(pms->buf, p, left); memcpy(pms->buf, p, left);
} }
MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16]) MD5_STATIC void
md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{ {
static const md5_byte_t pad[64] = { static const md5_byte_t pad[64] = {0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
md5_byte_t data[8]; md5_byte_t data[8];
int i; int i;

26
src/mod_duktape.inl
View File

@ -13,29 +13,27 @@
/* Note: This is only experimental support, so any API may still change. */ /* Note: This is only experimental support, so any API may still change. */
static const char *civetweb_conn_id = "\xFF" static const char *civetweb_conn_id = "\xFF"
"civetweb_conn"; "civetweb_conn";
static void *
static void *mg_duk_mem_alloc(void *udata, duk_size_t size) mg_duk_mem_alloc(void *udata, duk_size_t size)
{ {
return mg_malloc(size); return mg_malloc(size);
} }
static void *
static void *mg_duk_mem_realloc(void *udata, void *ptr, duk_size_t newsize) mg_duk_mem_realloc(void *udata, void *ptr, duk_size_t newsize)
{ {
return mg_realloc(ptr, newsize); return mg_realloc(ptr, newsize);
} }
static void
static void mg_duk_mem_free(void *udata, void *ptr) mg_duk_mem_free(void *udata, void *ptr)
{ {
mg_free(ptr); mg_free(ptr);
} }
static void static void
mg_duk_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg) mg_duk_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg)
{ {
@ -51,8 +49,8 @@ mg_duk_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg)
mg_cry(conn, "%s", msg); mg_cry(conn, "%s", msg);
} }
static duk_ret_t
static duk_ret_t duk_itf_write(duk_context *ctx) duk_itf_write(duk_context *ctx)
{ {
struct mg_connection *conn; struct mg_connection *conn;
duk_double_t ret; duk_double_t ret;
@ -82,8 +80,8 @@ static duk_ret_t duk_itf_write(duk_context *ctx)
return 1; return 1;
} }
static duk_ret_t
static duk_ret_t duk_itf_read(duk_context *ctx) duk_itf_read(duk_context *ctx)
{ {
struct mg_connection *conn; struct mg_connection *conn;
char buf[1024]; char buf[1024];
@ -107,8 +105,8 @@ static duk_ret_t duk_itf_read(duk_context *ctx)
return 1; return 1;
} }
static void
static void mg_exec_duktape_script(struct mg_connection *conn, const char *path) mg_exec_duktape_script(struct mg_connection *conn, const char *path)
{ {
duk_context *ctx = NULL; duk_context *ctx = NULL;

186
src/mod_lua.inl
View File

@ -25,7 +25,8 @@ mmap(void *addr, int64_t len, int prot, int flags, int fd, int offset)
return p; return p;
} }
static void munmap(void *addr, int64_t length) static void
munmap(void *addr, int64_t length)
{ {
/* unused parameters */ /* unused parameters */
(void)length; (void)length;
@ -51,7 +52,8 @@ static int handle_lsp_request(struct mg_connection *,
struct file *, struct file *,
struct lua_State *); struct lua_State *);
static void reg_string(struct lua_State *L, const char *name, const char *val) static void
reg_string(struct lua_State *L, const char *name, const char *val)
{ {
if (name != NULL && val != NULL) { if (name != NULL && val != NULL) {
lua_pushstring(L, name); lua_pushstring(L, name);
@ -60,7 +62,8 @@ static void reg_string(struct lua_State *L, const char *name, const char *val)
} }
} }
static void reg_int(struct lua_State *L, const char *name, int val) static void
reg_int(struct lua_State *L, const char *name, int val)
{ {
if (name != NULL) { if (name != NULL) {
lua_pushstring(L, name); lua_pushstring(L, name);
@ -69,7 +72,8 @@ static void reg_int(struct lua_State *L, const char *name, int val)
} }
} }
static void reg_boolean(struct lua_State *L, const char *name, int val) static void
reg_boolean(struct lua_State *L, const char *name, int val)
{ {
if (name != NULL) { if (name != NULL) {
lua_pushstring(L, name); lua_pushstring(L, name);
@ -78,7 +82,8 @@ static void reg_boolean(struct lua_State *L, const char *name, int val)
} }
} }
static void reg_conn_function(struct lua_State *L, static void
reg_conn_function(struct lua_State *L,
const char *name, const char *name,
lua_CFunction func, lua_CFunction func,
struct mg_connection *conn) struct mg_connection *conn)
@ -101,7 +106,8 @@ reg_function(struct lua_State *L, const char *name, lua_CFunction func)
} }
} }
static void lua_cry(struct mg_connection *conn, static void
lua_cry(struct mg_connection *conn,
int err, int err,
lua_State *L, lua_State *L,
const char *lua_title, const char *lua_title,
@ -147,7 +153,8 @@ static void lua_cry(struct mg_connection *conn,
} }
} }
static int lsp_sock_close(lua_State *L) static int
lsp_sock_close(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
if ((num_args == 1) && lua_istable(L, -1)) { if ((num_args == 1) && lua_istable(L, -1)) {
@ -159,7 +166,8 @@ static int lsp_sock_close(lua_State *L)
return 1; return 1;
} }
static int lsp_sock_recv(lua_State *L) static int
lsp_sock_recv(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
char buf[2000]; char buf[2000];
@ -179,7 +187,8 @@ static int lsp_sock_recv(lua_State *L)
return 1; return 1;
} }
static int lsp_sock_send(lua_State *L) static int
lsp_sock_send(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *buf; const char *buf;
@ -208,7 +217,8 @@ static const struct luaL_Reg luasocket_methods[] = {{"close", lsp_sock_close},
{"recv", lsp_sock_recv}, {"recv", lsp_sock_recv},
{NULL, NULL}}; {NULL, NULL}};
static int lsp_connect(lua_State *L) static int
lsp_connect(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
char ebuf[100]; char ebuf[100];
@ -216,8 +226,8 @@ static int lsp_connect(lua_State *L)
union usa sa; union usa sa;
int ok; int ok;
if ((num_args == 3) && lua_isstring(L, -3) && lua_isnumber(L, -2) && if ((num_args == 3) && lua_isstring(L, -3) && lua_isnumber(L, -2)
lua_isnumber(L, -1)) { && lua_isnumber(L, -1)) {
ok = connect_socket(NULL, ok = connect_socket(NULL,
lua_tostring(L, -3), lua_tostring(L, -3),
(int)lua_tonumber(L, -2), (int)lua_tonumber(L, -2),
@ -244,7 +254,8 @@ static int lsp_connect(lua_State *L)
return 1; return 1;
} }
static int lsp_error(lua_State *L) static int
lsp_error(lua_State *L)
{ {
lua_getglobal(L, "mg"); lua_getglobal(L, "mg");
lua_getfield(L, -1, "onerror"); lua_getfield(L, -1, "onerror");
@ -254,7 +265,8 @@ static int lsp_error(lua_State *L)
} }
/* Silently stop processing chunks. */ /* Silently stop processing chunks. */
static void lsp_abort(lua_State *L) static void
lsp_abort(lua_State *L)
{ {
int top = lua_gettop(L); int top = lua_gettop(L);
lua_getglobal(L, "mg"); lua_getglobal(L, "mg");
@ -271,7 +283,8 @@ struct lsp_var_reader_data {
unsigned state; unsigned state;
}; };
static const char *lsp_var_reader(lua_State *L, void *ud, size_t *sz) static const char *
lsp_var_reader(lua_State *L, void *ud, size_t *sz)
{ {
struct lsp_var_reader_data *reader = (struct lsp_var_reader_data *)ud; struct lsp_var_reader_data *reader = (struct lsp_var_reader_data *)ud;
const char *ret; const char *ret;
@ -299,7 +312,8 @@ static const char *lsp_var_reader(lua_State *L, void *ud, size_t *sz)
return ret; return ret;
} }
static int lsp(struct mg_connection *conn, static int
lsp(struct mg_connection *conn,
const char *path, const char *path,
const char *p, const char *p,
int64_t len, int64_t len,
@ -346,8 +360,10 @@ static int lsp(struct mg_connection *conn,
lua_ok = mg_lua_load( lua_ok = mg_lua_load(
L, lsp_var_reader, &data, chunkname, NULL); L, lsp_var_reader, &data, chunkname, NULL);
} else { } else {
lua_ok = luaL_loadbuffer( lua_ok = luaL_loadbuffer(L,
L, p + (i + 2), j - (i + 2), chunkname); p + (i + 2),
j - (i + 2),
chunkname);
} }
if (lua_ok) { if (lua_ok) {
@ -381,7 +397,8 @@ static int lsp(struct mg_connection *conn,
} }
/* mg.write: Send data to the client */ /* mg.write: Send data to the client */
static int lsp_write(lua_State *L) static int
lsp_write(lua_State *L)
{ {
struct mg_connection *conn = struct mg_connection *conn =
(struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1)); (struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1));
@ -401,7 +418,8 @@ static int lsp_write(lua_State *L)
} }
/* mg.read: Read data from the client (e.g., from a POST request) */ /* mg.read: Read data from the client (e.g., from a POST request) */
static int lsp_read(lua_State *L) static int
lsp_read(lua_State *L)
{ {
struct mg_connection *conn = struct mg_connection *conn =
(struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1)); (struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1));
@ -416,7 +434,8 @@ static int lsp_read(lua_State *L)
} }
/* mg.keep_alive: Allow Lua pages to use the http keep-alive mechanism */ /* mg.keep_alive: Allow Lua pages to use the http keep-alive mechanism */
static int lsp_keep_alive(lua_State *L) static int
lsp_keep_alive(lua_State *L)
{ {
struct mg_connection *conn = struct mg_connection *conn =
(struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1)); (struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1));
@ -439,7 +458,8 @@ static int lsp_keep_alive(lua_State *L)
} }
/* mg.include: Include another .lp file */ /* mg.include: Include another .lp file */
static int lsp_include(lua_State *L) static int
lsp_include(lua_State *L)
{ {
struct mg_connection *conn = struct mg_connection *conn =
(struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1)); (struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1));
@ -463,7 +483,8 @@ static int lsp_include(lua_State *L)
} }
/* mg.cry: Log an error. Default value for mg.onerror. */ /* mg.cry: Log an error. Default value for mg.onerror. */
static int lsp_cry(lua_State *L) static int
lsp_cry(lua_State *L)
{ {
struct mg_connection *conn = struct mg_connection *conn =
(struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1)); (struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1));
@ -480,7 +501,8 @@ static int lsp_cry(lua_State *L)
} }
/* mg.redirect: Redirect the request (internally). */ /* mg.redirect: Redirect the request (internally). */
static int lsp_redirect(lua_State *L) static int
lsp_redirect(lua_State *L)
{ {
struct mg_connection *conn = struct mg_connection *conn =
(struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1)); (struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1));
@ -499,7 +521,8 @@ static int lsp_redirect(lua_State *L)
} }
/* mg.send_file */ /* mg.send_file */
static int lsp_send_file(lua_State *L) static int
lsp_send_file(lua_State *L)
{ {
struct mg_connection *conn = struct mg_connection *conn =
(struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1)); (struct mg_connection *)lua_touserdata(L, lua_upvalueindex(1));
@ -516,7 +539,8 @@ static int lsp_send_file(lua_State *L)
} }
/* mg.get_time */ /* mg.get_time */
static int lsp_get_time(lua_State *L) static int
lsp_get_time(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
int monotonic = (num_args > 0) ? lua_toboolean(L, 1) : 0; int monotonic = (num_args > 0) ? lua_toboolean(L, 1) : 0;
@ -530,7 +554,8 @@ static int lsp_get_time(lua_State *L)
} }
/* mg.get_var */ /* mg.get_var */
static int lsp_get_var(lua_State *L) static int
lsp_get_var(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *data, *var_name; const char *data, *var_name;
@ -560,7 +585,8 @@ static int lsp_get_var(lua_State *L)
} }
/* mg.get_mime_type */ /* mg.get_mime_type */
static int lsp_get_mime_type(lua_State *L) static int
lsp_get_mime_type(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
struct vec mime_type = {0, 0}; struct vec mime_type = {0, 0};
@ -593,7 +619,8 @@ static int lsp_get_mime_type(lua_State *L)
} }
/* mg.get_cookie */ /* mg.get_cookie */
static int lsp_get_cookie(lua_State *L) static int
lsp_get_cookie(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *cookie; const char *cookie;
@ -623,7 +650,8 @@ static int lsp_get_cookie(lua_State *L)
} }
/* mg.md5 */ /* mg.md5 */
static int lsp_md5(lua_State *L) static int
lsp_md5(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *text; const char *text;
@ -651,7 +679,8 @@ static int lsp_md5(lua_State *L)
} }
/* mg.url_encode */ /* mg.url_encode */
static int lsp_url_encode(lua_State *L) static int
lsp_url_encode(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *text; const char *text;
@ -674,7 +703,8 @@ static int lsp_url_encode(lua_State *L)
} }
/* mg.url_decode */ /* mg.url_decode */
static int lsp_url_decode(lua_State *L) static int
lsp_url_decode(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *text; const char *text;
@ -699,7 +729,8 @@ static int lsp_url_decode(lua_State *L)
} }
/* mg.base64_encode */ /* mg.base64_encode */
static int lsp_base64_encode(lua_State *L) static int
lsp_base64_encode(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *text; const char *text;
@ -728,7 +759,8 @@ static int lsp_base64_encode(lua_State *L)
} }
/* mg.base64_encode */ /* mg.base64_encode */
static int lsp_base64_decode(lua_State *L) static int
lsp_base64_decode(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
const char *text; const char *text;
@ -741,8 +773,10 @@ static int lsp_base64_decode(lua_State *L)
if (text) { if (text) {
dst = (char *)mg_malloc(text_len); dst = (char *)mg_malloc(text_len);
if (dst) { if (dst) {
ret = base64_decode( ret = base64_decode((const unsigned char *)text,
(const unsigned char *)text, text_len, dst, &dst_len); text_len,
dst,
&dst_len);
if (ret != -1) { if (ret != -1) {
mg_free(dst); mg_free(dst);
return luaL_error( return luaL_error(
@ -766,7 +800,8 @@ static int lsp_base64_decode(lua_State *L)
} }
/* mg.get_response_code_text */ /* mg.get_response_code_text */
static int lsp_get_response_code_text(lua_State *L) static int
lsp_get_response_code_text(lua_State *L)
{ {
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
int type1; int type1;
@ -801,7 +836,8 @@ struct lua_websock_data {
#endif #endif
/* mg.write for websockets */ /* mg.write for websockets */
static int lwebsock_write(lua_State *L) static int
lwebsock_write(lua_State *L)
{ {
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
@ -905,7 +941,8 @@ struct laction_arg {
char txt[1]; char txt[1];
}; };
static int lua_action(struct laction_arg *arg) static int
lua_action(struct laction_arg *arg)
{ {
int err, ok; int err, ok;
struct mg_context *ctx; struct mg_context *ctx;
@ -947,7 +984,8 @@ static int lua_action(struct laction_arg *arg)
return ok; return ok;
} }
static int lua_action_free(struct laction_arg *arg) static int
lua_action_free(struct laction_arg *arg)
{ {
if (lua_action(arg)) { if (lua_action(arg)) {
mg_free(arg); mg_free(arg);
@ -955,7 +993,8 @@ static int lua_action_free(struct laction_arg *arg)
return 0; return 0;
} }
static int lwebsocket_set_timer(lua_State *L, int is_periodic) static int
lwebsocket_set_timer(lua_State *L, int is_periodic)
{ {
#if defined(USE_TIMERS) && defined(USE_WEBSOCKET) #if defined(USE_TIMERS) && defined(USE_WEBSOCKET)
int num_args = lua_gettop(L); int num_args = lua_gettop(L);
@ -987,8 +1026,8 @@ static int lwebsocket_set_timer(lua_State *L, int is_periodic)
timediff = (double)lua_tonumber(L, 2); timediff = (double)lua_tonumber(L, 2);
txt = lua_tostring(L, 1); txt = lua_tostring(L, 1);
txt_len = strlen(txt); txt_len = strlen(txt);
arg = (struct laction_arg *)mg_malloc(sizeof(struct laction_arg) + arg = (struct laction_arg *)mg_malloc(sizeof(struct laction_arg)
txt_len + 10); + txt_len + 10);
arg->state = L; arg->state = L;
arg->script = ws->script; arg->script = ws->script;
arg->pmutex = &(ws->ws_mutex); arg->pmutex = &(ws->ws_mutex);
@ -996,8 +1035,9 @@ static int lwebsocket_set_timer(lua_State *L, int is_periodic)
memcpy(arg->txt + 7, txt, txt_len); memcpy(arg->txt + 7, txt, txt_len);
arg->txt[txt_len + 7] = ')'; arg->txt[txt_len + 7] = ')';
arg->txt[txt_len + 8] = 0; arg->txt[txt_len + 8] = 0;
ok = (0 == ok =
timer_add(ctx, (0
== timer_add(ctx,
timediff, timediff,
is_periodic, is_periodic,
1, 1,
@ -1021,13 +1061,15 @@ static int lwebsocket_set_timer(lua_State *L, int is_periodic)
} }
/* mg.set_timeout for websockets */ /* mg.set_timeout for websockets */
static int lwebsocket_set_timeout(lua_State *L) static int
lwebsocket_set_timeout(lua_State *L)
{ {
return lwebsocket_set_timer(L, 0); return lwebsocket_set_timer(L, 0);
} }
/* mg.set_interval for websockets */ /* mg.set_interval for websockets */
static int lwebsocket_set_interval(lua_State *L) static int
lwebsocket_set_interval(lua_State *L)
{ {
return lwebsocket_set_timer(L, 1); return lwebsocket_set_timer(L, 1);
} }
@ -1038,7 +1080,8 @@ enum {
LUA_ENV_TYPE_LUA_WEBSOCKET = 2, LUA_ENV_TYPE_LUA_WEBSOCKET = 2,
}; };
static void prepare_lua_request_info(struct mg_connection *conn, lua_State *L) static void
prepare_lua_request_info(struct mg_connection *conn, lua_State *L)
{ {
const char *s; const char *s;
int i; int i;
@ -1100,7 +1143,8 @@ static void prepare_lua_request_info(struct mg_connection *conn, lua_State *L)
lua_rawset(L, -3); lua_rawset(L, -3);
} }
void civetweb_open_lua_libs(lua_State *L) void
civetweb_open_lua_libs(lua_State *L)
{ {
{ {
extern void luaL_openlibs(lua_State *); extern void luaL_openlibs(lua_State *);
@ -1137,7 +1181,8 @@ void civetweb_open_lua_libs(lua_State *L)
#endif #endif
} }
static void prepare_lua_environment(struct mg_context *ctx, static void
prepare_lua_environment(struct mg_context *ctx,
struct mg_connection *conn, struct mg_connection *conn,
struct lua_websock_data *ws_conn_list, struct lua_websock_data *ws_conn_list,
lua_State *L, lua_State *L,
@ -1186,8 +1231,8 @@ static void prepare_lua_environment(struct mg_context *ctx,
break; break;
} }
if (lua_env_type == LUA_ENV_TYPE_LUA_SERVER_PAGE || if (lua_env_type == LUA_ENV_TYPE_LUA_SERVER_PAGE
lua_env_type == LUA_ENV_TYPE_PLAIN_LUA_PAGE) { || lua_env_type == LUA_ENV_TYPE_PLAIN_LUA_PAGE) {
reg_conn_function(L, "cry", lsp_cry, conn); reg_conn_function(L, "cry", lsp_cry, conn);
reg_conn_function(L, "read", lsp_read, conn); reg_conn_function(L, "read", lsp_read, conn);
reg_conn_function(L, "write", lsp_write, conn); reg_conn_function(L, "write", lsp_write, conn);
@ -1231,7 +1276,6 @@ static void prepare_lua_environment(struct mg_context *ctx,
reg_string(L, "websocket_root", ctx->config[WEBSOCKET_ROOT]); reg_string(L, "websocket_root", ctx->config[WEBSOCKET_ROOT]);
#endif #endif
if (ctx->systemName != NULL) { if (ctx->systemName != NULL) {
reg_string(L, "system", ctx->systemName); reg_string(L, "system", ctx->systemName);
} }
@ -1262,7 +1306,8 @@ static void prepare_lua_environment(struct mg_context *ctx,
} }
} }
static int lua_error_handler(lua_State *L) static int
lua_error_handler(lua_State *L)
{ {
const char *error_msg = lua_isstring(L, -1) ? lua_tostring(L, -1) : "?\n"; const char *error_msg = lua_isstring(L, -1) ? lua_tostring(L, -1) : "?\n";
@ -1284,7 +1329,8 @@ static int lua_error_handler(lua_State *L)
return 0; return 0;
} }
static void *lua_allocator(void *ud, void *ptr, size_t osize, size_t nsize) static void *
lua_allocator(void *ud, void *ptr, size_t osize, size_t nsize)
{ {
(void)ud; (void)ud;
@ -1297,7 +1343,8 @@ static void *lua_allocator(void *ud, void *ptr, size_t osize, size_t nsize)
return mg_realloc(ptr, nsize); return mg_realloc(ptr, nsize);
} }
static void mg_exec_lua_script(struct mg_connection *conn, static void
mg_exec_lua_script(struct mg_connection *conn,
const char *path, const char *path,
const void **exports) const void **exports)
{ {
@ -1342,7 +1389,8 @@ static void mg_exec_lua_script(struct mg_connection *conn,
} }
} }
static int handle_lsp_request(struct mg_connection *conn, static int
handle_lsp_request(struct mg_connection *conn,
const char *path, const char *path,
struct file *filep, struct file *filep,
struct lua_State *ls) struct lua_State *ls)
@ -1367,8 +1415,8 @@ static int handle_lsp_request(struct mg_connection *conn,
} else { } else {
luaL_error(ls, "File [%s] not found", path); luaL_error(ls, "File [%s] not found", path);
} }
} else if (filep->membuf == NULL && } else if (filep->membuf == NULL
(p = mmap(NULL, && (p = mmap(NULL,
(size_t)filep->size, (size_t)filep->size,
PROT_READ, PROT_READ,
MAP_PRIVATE, MAP_PRIVATE,
@ -1389,8 +1437,8 @@ static int handle_lsp_request(struct mg_connection *conn,
fileno(filep->fp), fileno(filep->fp),
strerror(errno)); strerror(errno));
} }
} else if ((L = (ls != NULL ? ls : lua_newstate(lua_allocator, NULL))) == } else if ((L = (ls != NULL ? ls : lua_newstate(lua_allocator, NULL)))
NULL) { == NULL) {
send_http_error(conn, send_http_error(conn,
500, 500,
"%s", "%s",
@ -1423,7 +1471,8 @@ struct mg_shared_lua_websocket_list {
struct mg_shared_lua_websocket_list *next; struct mg_shared_lua_websocket_list *next;
}; };
static void *lua_websocket_new(const char *script, struct mg_connection *conn) static void *
lua_websocket_new(const char *script, struct mg_connection *conn)
{ {
struct mg_shared_lua_websocket_list **shared_websock_list = struct mg_shared_lua_websocket_list **shared_websock_list =
&(conn->ctx->shared_lua_websockets); &(conn->ctx->shared_lua_websockets);
@ -1443,8 +1492,8 @@ static void *lua_websocket_new(const char *script, struct mg_connection *conn)
} }
if (*shared_websock_list == NULL) { if (*shared_websock_list == NULL) {
/* add ws to list */ /* add ws to list */
*shared_websock_list = (struct mg_shared_lua_websocket_list *)mg_calloc( *shared_websock_list = (struct mg_shared_lua_websocket_list *)
sizeof(struct mg_shared_lua_websocket_list), 1); mg_calloc(sizeof(struct mg_shared_lua_websocket_list), 1);
if (*shared_websock_list == NULL) { if (*shared_websock_list == NULL) {
mg_unlock_context(conn->ctx); mg_unlock_context(conn->ctx);
mg_cry(conn, "Cannot create shared websocket struct, OOM"); mg_cry(conn, "Cannot create shared websocket struct, OOM");
@ -1505,7 +1554,8 @@ static void *lua_websocket_new(const char *script, struct mg_connection *conn)
return ok ? (void *)ws : NULL; return ok ? (void *)ws : NULL;
} }
static int lua_websocket_data(struct mg_connection *conn, static int
lua_websocket_data(struct mg_connection *conn,
int bits, int bits,
char *data, char *data,
size_t data_len, size_t data_len,
@ -1548,7 +1598,8 @@ static int lua_websocket_data(struct mg_connection *conn,
return ok; return ok;
} }
static int lua_websocket_ready(struct mg_connection *conn, void *ws_arg) static int
lua_websocket_ready(struct mg_connection *conn, void *ws_arg)
{ {
struct lua_websock_data *ws = (struct lua_websock_data *)(ws_arg); struct lua_websock_data *ws = (struct lua_websock_data *)(ws_arg);
int err, ok = 0; int err, ok = 0;
@ -1579,7 +1630,8 @@ static int lua_websocket_ready(struct mg_connection *conn, void *ws_arg)
return ok; return ok;
} }
static void lua_websocket_close(struct mg_connection *conn, void *ws_arg) static void
lua_websocket_close(struct mg_connection *conn, void *ws_arg)
{ {
struct lua_websock_data *ws = (struct lua_websock_data *)(ws_arg); struct lua_websock_data *ws = (struct lua_websock_data *)(ws_arg);
struct mg_shared_lua_websocket_list **shared_websock_list = struct mg_shared_lua_websocket_list **shared_websock_list =

20
src/timer.inl
View File

@ -19,7 +19,8 @@ struct ttimers {
unsigned timer_count; /* Current size of timer list */ unsigned timer_count; /* Current size of timer list */
}; };
static int timer_add(struct mg_context *ctx, static int
timer_add(struct mg_context *ctx,
double next_time, double next_time,
double period, double period,
int is_relative, int is_relative,
@ -62,7 +63,8 @@ static int timer_add(struct mg_context *ctx,
return error; return error;
} }
static void timer_thread_run(void *thread_func_param) static void
timer_thread_run(void *thread_func_param)
{ {
struct mg_context *ctx = (struct mg_context *)thread_func_param; struct mg_context *ctx = (struct mg_context *)thread_func_param;
struct timespec now; struct timespec now;
@ -73,9 +75,8 @@ static void timer_thread_run(void *thread_func_param)
#if defined(HAVE_CLOCK_NANOSLEEP) /* Linux with librt */ #if defined(HAVE_CLOCK_NANOSLEEP) /* Linux with librt */
/* TODO */ /* TODO */
while ( while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &request, &request)
clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &request, &request) == == EINTR) { /*nop*/
EINTR) { /*nop*/
; ;
} }
#else #else
@ -112,14 +113,16 @@ static unsigned __stdcall timer_thread(void *thread_func_param)
return 0; return 0;
} }
#else #else
static void *timer_thread(void *thread_func_param) static void *
timer_thread(void *thread_func_param)
{ {
timer_thread_run(thread_func_param); timer_thread_run(thread_func_param);
return NULL; return NULL;
} }
#endif /* _WIN32 */ #endif /* _WIN32 */
static int timers_init(struct mg_context *ctx) static int
timers_init(struct mg_context *ctx)
{ {
ctx->timers = (struct ttimers *)mg_calloc(sizeof(struct ttimers), 1); ctx->timers = (struct ttimers *)mg_calloc(sizeof(struct ttimers), 1);
(void)pthread_mutex_init(&ctx->timers->mutex, NULL); (void)pthread_mutex_init(&ctx->timers->mutex, NULL);
@ -130,7 +133,8 @@ static int timers_init(struct mg_context *ctx)
return 0; return 0;
} }
static void timers_exit(struct mg_context *ctx) static void
timers_exit(struct mg_context *ctx)
{ {
if (ctx->timers) { if (ctx->timers) {
(void)pthread_mutex_destroy(&ctx->timers->mutex); (void)pthread_mutex_destroy(&ctx->timers->mutex);

16
test/main.c
View File

@ -30,13 +30,13 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
/* This unit test file uses the excellent Check unit testing library. /* This unit test file uses the excellent Check unit testing library.
* The API documentation is available here: * The API documentation is available here:
* http://check.sourceforge.net/doc/check_html/index.html * http://check.sourceforge.net/doc/check_html/index.html
*/ */
int main(const int argc, char *argv[]) int
main(const int argc, char *argv[])
{ {
// Determine what tests to run // Determine what tests to run
const char *suite = NULL; const char *suite = NULL;
@ -48,14 +48,14 @@ int main(const int argc, char *argv[])
const char *const test_dir_arg = "--test-dir="; const char *const test_dir_arg = "--test-dir=";
const size_t test_dir_arg_size = strlen(test_dir_arg); const size_t test_dir_arg_size = strlen(test_dir_arg);
for (int i = 1; i < argc; ++i) { for (int i = 1; i < argc; ++i) {
if (0 == strncmp(suite_arg, argv[i], suite_arg_size) && if (0 == strncmp(suite_arg, argv[i], suite_arg_size)
(strlen(argv[i]) > suite_arg_size)) { && (strlen(argv[i]) > suite_arg_size)) {
suite = &argv[i][suite_arg_size]; suite = &argv[i][suite_arg_size];
} else if (0 == strncmp(test_case_arg, argv[i], test_case_arg_size) && } else if (0 == strncmp(test_case_arg, argv[i], test_case_arg_size)
(strlen(argv[i]) > test_case_arg_size)) { && (strlen(argv[i]) > test_case_arg_size)) {
test_case = &argv[i][test_case_arg_size]; test_case = &argv[i][test_case_arg_size];
} else if (0 == strncmp(test_dir_arg, argv[i], test_dir_arg_size) && } else if (0 == strncmp(test_dir_arg, argv[i], test_dir_arg_size)
(strlen(argv[i]) > test_dir_arg_size)) { && (strlen(argv[i]) > test_dir_arg_size)) {
set_test_directory(&argv[i][test_dir_arg_size]); set_test_directory(&argv[i][test_dir_arg_size]);
} else if (0 == strcmp("--help", argv[i])) { } else if (0 == strcmp("--help", argv[i])) {
printf( printf(

36
test/private.c
View File

@ -91,7 +91,6 @@ START_TEST(test_parse_http_message)
} }
END_TEST END_TEST
START_TEST(test_should_keep_alive) START_TEST(test_should_keep_alive)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
@ -139,7 +138,6 @@ START_TEST(test_should_keep_alive)
} }
END_TEST END_TEST
START_TEST(test_match_prefix) START_TEST(test_match_prefix)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
@ -176,7 +174,6 @@ START_TEST(test_match_prefix)
} }
END_TEST END_TEST
START_TEST(test_remove_double_dots_and_double_slashes) START_TEST(test_remove_double_dots_and_double_slashes)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
@ -205,7 +202,6 @@ START_TEST(test_remove_double_dots_and_double_slashes)
} }
END_TEST END_TEST
START_TEST(test_is_valid_uri) START_TEST(test_is_valid_uri)
{ {
/* is_valid_uri is superseeded by get_uri_type */ /* is_valid_uri is superseeded by get_uri_type */
@ -223,7 +219,6 @@ START_TEST(test_is_valid_uri)
} }
END_TEST END_TEST
START_TEST(test_next_option) START_TEST(test_next_option)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
@ -236,14 +231,14 @@ START_TEST(test_next_option)
ck_assert(next_option(NULL, &a, &b) == NULL); ck_assert(next_option(NULL, &a, &b) == NULL);
for (i = 0, p = list; (p = next_option(p, &a, &b)) != NULL; i++) { for (i = 0, p = list; (p = next_option(p, &a, &b)) != NULL; i++) {
ck_assert(i != 0 || (a.ptr == list && a.len == 3 && b.len == 0)); ck_assert(i != 0 || (a.ptr == list && a.len == 3 && b.len == 0));
ck_assert(i != 1 || (a.ptr == list + 4 && a.len == 4 && ck_assert(i != 1
b.ptr == list + 9 && b.len == 4)); || (a.ptr == list + 4 && a.len == 4 && b.ptr == list + 9
&& b.len == 4));
ck_assert(i != 2 || (a.ptr == list + 14 && a.len == 1 && b.len == 0)); ck_assert(i != 2 || (a.ptr == list + 14 && a.len == 1 && b.len == 0));
} }
} }
END_TEST END_TEST
START_TEST(test_skip_quoted) START_TEST(test_skip_quoted)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
@ -266,8 +261,8 @@ START_TEST(test_skip_quoted)
} }
END_TEST END_TEST
static int
static int alloc_printf(char **buf, size_t size, const char *fmt, ...) alloc_printf(char **buf, size_t size, const char *fmt, ...)
{ {
/* Test helper function - adapted from unit_test.c */ /* Test helper function - adapted from unit_test.c */
/* Copyright (c) 2013-2015 the Civetweb developers */ /* Copyright (c) 2013-2015 the Civetweb developers */
@ -280,7 +275,6 @@ static int alloc_printf(char **buf, size_t size, const char *fmt, ...)
return ret; return ret;
} }
START_TEST(test_alloc_vprintf) START_TEST(test_alloc_vprintf)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
@ -300,7 +294,6 @@ START_TEST(test_alloc_vprintf)
} }
END_TEST END_TEST
START_TEST(test_mg_strcasestr) START_TEST(test_mg_strcasestr)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
@ -315,14 +308,13 @@ START_TEST(test_mg_strcasestr)
} }
END_TEST END_TEST
START_TEST(test_parse_port_string) START_TEST(test_parse_port_string)
{ {
/* Adapted from unit_test.c */ /* Adapted from unit_test.c */
/* Copyright (c) 2013-2015 the Civetweb developers */ /* Copyright (c) 2013-2015 the Civetweb developers */
/* Copyright (c) 2004-2013 Sergey Lyubka */ /* Copyright (c) 2004-2013 Sergey Lyubka */
static const char *valid[] = { static const char *valid[] =
"0", { "0",
"1", "1",
"1s", "1s",
"1r", "1r",
@ -334,8 +326,7 @@ START_TEST(test_parse_port_string)
"[::]:80", "[::]:80",
"[3ffe:2a00:100:7031::1]:900", "[3ffe:2a00:100:7031::1]:900",
#endif #endif
NULL NULL };
};
static const char *invalid[] = { static const char *invalid[] = {
"99999", "1k", "1.2.3", "1.2.3.4:", "1.2.3.4:2p", NULL}; "99999", "1k", "1.2.3", "1.2.3.4:", "1.2.3.4:2p", NULL};
struct socket so; struct socket so;
@ -356,7 +347,6 @@ START_TEST(test_parse_port_string)
} }
END_TEST END_TEST
START_TEST(test_encode_decode) START_TEST(test_encode_decode)
{ {
char buf[128]; char buf[128];
@ -414,8 +404,10 @@ START_TEST(test_encode_decode)
#if defined(USE_LUA) #if defined(USE_LUA)
memset(buf, 77, sizeof(buf)); memset(buf, 77, sizeof(buf));
len = 9999; len = 9999;
ret = base64_decode( ret = base64_decode((unsigned char *)alpha_b64_enc,
(unsigned char *)alpha_b64_enc, (int)strlen(alpha_b64_enc), buf, &len); (int)strlen(alpha_b64_enc),
buf,
&len);
ck_assert_int_eq(ret, -1); ck_assert_int_eq(ret, -1);
ck_assert_uint_eq((unsigned int)len, (unsigned int)strlen(alpha)); ck_assert_uint_eq((unsigned int)len, (unsigned int)strlen(alpha));
ck_assert_str_eq(buf, alpha); ck_assert_str_eq(buf, alpha);
@ -464,8 +456,8 @@ START_TEST(test_encode_decode)
} }
END_TEST END_TEST
Suite *
Suite *make_private_suite(void) make_private_suite(void)
{ {
Suite *const suite = suite_create("Private"); Suite *const suite = suite_create("Private");

4
test/private_exe.c
View File

@ -62,8 +62,8 @@ START_TEST(test_helper_funcs)
} }
END_TEST END_TEST
Suite *
Suite *make_private_exe_suite(void) make_private_exe_suite(void)
{ {
Suite *const suite = suite_create("EXE"); Suite *const suite = suite_create("EXE");

1
test/private_exe.h
View File

@ -28,5 +28,4 @@ Suite *make_private_exe_suite(void);
/* This is a redefine for "main" in main.c */ /* This is a redefine for "main" in main.c */
int exe_main(int argc, char *argv[]); int exe_main(int argc, char *argv[]);
#endif /* TEST_PRIVATE_H_ */ #endif /* TEST_PRIVATE_H_ */

13
test/public_func.c
View File

@ -34,7 +34,6 @@
* http://check.sourceforge.net/doc/check_html/index.html * http://check.sourceforge.net/doc/check_html/index.html
*/ */
START_TEST(test_mg_version) START_TEST(test_mg_version)
{ {
const char *ver = mg_version(); const char *ver = mg_version();
@ -89,7 +88,6 @@ START_TEST(test_mg_version)
} }
END_TEST END_TEST
START_TEST(test_mg_get_valid_options) START_TEST(test_mg_get_valid_options)
{ {
int i; int i;
@ -107,7 +105,6 @@ START_TEST(test_mg_get_valid_options)
} }
END_TEST END_TEST
START_TEST(test_mg_get_builtin_mime_type) START_TEST(test_mg_get_builtin_mime_type)
{ {
ck_assert_str_eq(mg_get_builtin_mime_type("x.txt"), "text/plain"); ck_assert_str_eq(mg_get_builtin_mime_type("x.txt"), "text/plain");
@ -120,7 +117,6 @@ START_TEST(test_mg_get_builtin_mime_type)
} }
END_TEST END_TEST
START_TEST(test_mg_strncasecmp) START_TEST(test_mg_strncasecmp)
{ {
ck_assert(mg_strncasecmp("abc", "abc", 3) == 0); ck_assert(mg_strncasecmp("abc", "abc", 3) == 0);
@ -148,7 +144,6 @@ START_TEST(test_mg_strncasecmp)
} }
END_TEST END_TEST
START_TEST(test_mg_get_cookie) START_TEST(test_mg_get_cookie)
{ {
char buf[32]; char buf[32];
@ -215,7 +210,6 @@ START_TEST(test_mg_get_cookie)
} }
END_TEST END_TEST
START_TEST(test_mg_get_var) START_TEST(test_mg_get_var)
{ {
char buf[32]; char buf[32];
@ -318,7 +312,6 @@ START_TEST(test_mg_get_var)
} }
END_TEST END_TEST
START_TEST(test_mg_md5) START_TEST(test_mg_md5)
{ {
char buf[33]; char buf[33];
@ -373,7 +366,6 @@ START_TEST(test_mg_md5)
} }
END_TEST END_TEST
START_TEST(test_mg_url_encode) START_TEST(test_mg_url_encode)
{ {
char buf[20]; char buf[20];
@ -396,7 +388,6 @@ START_TEST(test_mg_url_encode)
} }
END_TEST END_TEST
START_TEST(test_mg_url_decode) START_TEST(test_mg_url_decode)
{ {
char buf[20]; char buf[20];
@ -424,8 +415,8 @@ START_TEST(test_mg_url_decode)
} }
END_TEST END_TEST
Suite *
Suite *make_public_func_suite(void) make_public_func_suite(void)
{ {
Suite *const suite = suite_create("PublicFunc"); Suite *const suite = suite_create("PublicFunc");

98
test/public_server.c
View File

@ -46,8 +46,8 @@
* http://check.sourceforge.net/doc/check_html/index.html * http://check.sourceforge.net/doc/check_html/index.html
*/ */
static const char *
static const char *locate_ssl_cert(void) locate_ssl_cert(void)
{ {
return return
#ifdef _WIN32 #ifdef _WIN32
@ -70,8 +70,8 @@ static const char *locate_ssl_cert(void)
#endif #endif
} }
static int
static int wait_not_null(void *volatile *data) wait_not_null(void *volatile *data)
{ {
int i; int i;
for (i = 0; i < 100; i++) { for (i = 0; i < 100; i++) {
@ -83,7 +83,6 @@ static int wait_not_null(void *volatile *data)
return 0; return 0;
} }
START_TEST(test_the_test_environment) START_TEST(test_the_test_environment)
{ {
char wd[300]; char wd[300];
@ -96,7 +95,6 @@ START_TEST(test_the_test_environment)
memset(wd, 0, sizeof(wd)); memset(wd, 0, sizeof(wd));
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
/* Get the current working directory */ /* Get the current working directory */
#ifdef _WIN32 #ifdef _WIN32
(void)GetCurrentDirectoryA(sizeof(wd), wd); (void)GetCurrentDirectoryA(sizeof(wd), wd);
@ -143,10 +141,10 @@ START_TEST(test_the_test_environment)
} }
END_TEST END_TEST
static void *threading_data; static void *threading_data;
static void *test_thread_func_t(void *param) static void *
test_thread_func_t(void *param)
{ {
ck_assert_ptr_eq(param, &threading_data); ck_assert_ptr_eq(param, &threading_data);
ck_assert_ptr_eq(threading_data, NULL); ck_assert_ptr_eq(threading_data, NULL);
@ -154,7 +152,6 @@ static void *test_thread_func_t(void *param)
return NULL; return NULL;
} }
START_TEST(test_threading) START_TEST(test_threading)
{ {
int ok; int ok;
@ -169,8 +166,8 @@ START_TEST(test_threading)
} }
END_TEST END_TEST
static int
static int log_msg_func(const struct mg_connection *conn, const char *message) log_msg_func(const struct mg_connection *conn, const char *message)
{ {
struct mg_context *ctx; struct mg_context *ctx;
char *ud; char *ud;
@ -185,7 +182,6 @@ static int log_msg_func(const struct mg_connection *conn, const char *message)
return 1; return 1;
} }
START_TEST(test_mg_start_stop_http_server) START_TEST(test_mg_start_stop_http_server)
{ {
struct mg_context *ctx; struct mg_context *ctx;
@ -228,7 +224,6 @@ START_TEST(test_mg_start_stop_http_server)
} }
END_TEST END_TEST
START_TEST(test_mg_start_stop_https_server) START_TEST(test_mg_start_stop_https_server)
{ {
#ifndef NO_SSL #ifndef NO_SSL
@ -260,7 +255,6 @@ START_TEST(test_mg_start_stop_https_server)
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL); ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL); ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
memset(ports, 0, sizeof(ports)); memset(ports, 0, sizeof(ports));
memset(ssl, 0, sizeof(ssl)); memset(ssl, 0, sizeof(ssl));
memset(&callbacks, 0, sizeof(callbacks)); memset(&callbacks, 0, sizeof(callbacks));
@ -288,10 +282,10 @@ START_TEST(test_mg_start_stop_https_server)
} }
END_TEST END_TEST
static struct mg_context *g_ctx; static struct mg_context *g_ctx;
static int request_test_handler(struct mg_connection *conn, void *cbdata) static int
request_test_handler(struct mg_connection *conn, void *cbdata)
{ {
int i; int i;
char chunk_data[32]; char chunk_data[32];
@ -330,7 +324,6 @@ static int request_test_handler(struct mg_connection *conn, void *cbdata)
return 1; return 1;
} }
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
/****************************************************************************/ /****************************************************************************/
/* WEBSOCKET SERVER */ /* WEBSOCKET SERVER */
@ -345,8 +338,8 @@ static const char *websocket_goodbye_msg = "websocket bye\n";
static const size_t websocket_goodbye_msg_len = static const size_t websocket_goodbye_msg_len =
14 /* strlen(websocket_goodbye_msg) */; 14 /* strlen(websocket_goodbye_msg) */;
static int
static int websock_server_connect(const struct mg_connection *conn, void *udata) websock_server_connect(const struct mg_connection *conn, void *udata)
{ {
(void)conn; (void)conn;
@ -356,8 +349,8 @@ static int websock_server_connect(const struct mg_connection *conn, void *udata)
return 0; /* return 0 to accept every connection */ return 0; /* return 0 to accept every connection */
} }
static void
static void websock_server_ready(struct mg_connection *conn, void *udata) websock_server_ready(struct mg_connection *conn, void *udata)
{ {
ck_assert_ptr_eq((void *)udata, (void *)7531); ck_assert_ptr_eq((void *)udata, (void *)7531);
printf("Server: Websocket ready\n"); printf("Server: Websocket ready\n");
@ -373,7 +366,8 @@ static void websock_server_ready(struct mg_connection *conn, void *udata)
printf("Server: Websocket ready X\n"); printf("Server: Websocket ready X\n");
} }
static int websock_server_data(struct mg_connection *conn, static int
websock_server_data(struct mg_connection *conn,
int bits, int bits,
char *data, char *data,
size_t data_len, size_t data_len,
@ -405,7 +399,8 @@ static int websock_server_data(struct mg_connection *conn,
return 1; /* return 1 to keep the connetion open */ return 1; /* return 1 to keep the connetion open */
} }
static void websock_server_close(const struct mg_connection *conn, void *udata) static void
websock_server_close(const struct mg_connection *conn, void *udata)
{ {
(void)conn; (void)conn;
@ -416,7 +411,6 @@ static void websock_server_close(const struct mg_connection *conn, void *udata)
* closed */ * closed */
} }
/****************************************************************************/ /****************************************************************************/
/* WEBSOCKET CLIENT */ /* WEBSOCKET CLIENT */
/****************************************************************************/ /****************************************************************************/
@ -426,8 +420,8 @@ struct tclient_data {
int closed; int closed;
}; };
static int
static int websocket_client_data_handler(struct mg_connection *conn, websocket_client_data_handler(struct mg_connection *conn,
int flags, int flags,
char *data, char *data,
size_t data_len, size_t data_len,
@ -454,8 +448,8 @@ static int websocket_client_data_handler(struct mg_connection *conn,
return 1; return 1;
} }
static void
static void websocket_client_close_handler(const struct mg_connection *conn, websocket_client_close_handler(const struct mg_connection *conn,
void *user_data) void *user_data)
{ {
struct mg_context *ctx = mg_get_context(conn); struct mg_context *ctx = mg_get_context(conn);
@ -471,7 +465,6 @@ static void websocket_client_close_handler(const struct mg_connection *conn,
} }
#endif #endif
START_TEST(test_request_handlers) START_TEST(test_request_handlers)
{ {
char ebuf[100]; char ebuf[100];
@ -526,7 +519,6 @@ START_TEST(test_request_handlers)
struct mg_connection *ws_client3_conn = NULL; struct mg_connection *ws_client3_conn = NULL;
#endif #endif
memset((void *)OPTIONS, 0, sizeof(OPTIONS)); memset((void *)OPTIONS, 0, sizeof(OPTIONS));
OPTIONS[opt_idx++] = "listening_ports"; OPTIONS[opt_idx++] = "listening_ports";
OPTIONS[opt_idx++] = HTTP_PORT; OPTIONS[opt_idx++] = HTTP_PORT;
@ -572,11 +564,12 @@ START_TEST(test_request_handlers)
} }
for (i = 5; i < 9; i++) { for (i = 5; i < 9; i++) {
sprintf(uri, "/U%u", i); sprintf(uri, "/U%u", i);
mg_set_request_handler( mg_set_request_handler(ctx,
ctx, uri, request_test_handler, (void *)(ptrdiff_t)i); uri,
request_test_handler,
(void *)(ptrdiff_t)i);
} }
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
mg_set_websocket_handler(ctx, mg_set_websocket_handler(ctx,
"/websocket", "/websocket",
@ -587,7 +580,6 @@ START_TEST(test_request_handlers)
(void *)7531); (void *)7531);
#endif #endif
/* Try to load non existing file */ /* Try to load non existing file */
client_conn = mg_download("localhost", client_conn = mg_download("localhost",
ipv4_port, ipv4_port,
@ -603,7 +595,6 @@ START_TEST(test_request_handlers)
ck_assert_str_eq(ri->uri, "404"); ck_assert_str_eq(ri->uri, "404");
mg_close_connection(client_conn); mg_close_connection(client_conn);
/* Get data from callback */ /* Get data from callback */
client_conn = mg_download( client_conn = mg_download(
"localhost", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request); "localhost", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request);
@ -618,7 +609,6 @@ START_TEST(test_request_handlers)
ck_assert_str_eq(buf, expected); ck_assert_str_eq(buf, expected);
mg_close_connection(client_conn); mg_close_connection(client_conn);
/* Get data from callback using http://127.0.0.1 */ /* Get data from callback using http://127.0.0.1 */
client_conn = mg_download( client_conn = mg_download(
"127.0.0.1", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request); "127.0.0.1", ipv4_port, 0, ebuf, sizeof(ebuf), "%s", request);
@ -633,7 +623,6 @@ START_TEST(test_request_handlers)
ck_assert_str_eq(buf, expected); ck_assert_str_eq(buf, expected);
mg_close_connection(client_conn); mg_close_connection(client_conn);
#if defined(USE_IPV6) #if defined(USE_IPV6)
/* Get data from callback using http://[::1] */ /* Get data from callback using http://[::1] */
client_conn = client_conn =
@ -650,7 +639,6 @@ START_TEST(test_request_handlers)
mg_close_connection(client_conn); mg_close_connection(client_conn);
#endif #endif
#if !defined(NO_SSL) #if !defined(NO_SSL)
/* Get data from callback using https://127.0.0.1 */ /* Get data from callback using https://127.0.0.1 */
client_conn = mg_download( client_conn = mg_download(
@ -679,7 +667,6 @@ START_TEST(test_request_handlers)
mg_close_connection(client_conn); mg_close_connection(client_conn);
#endif #endif
#if defined(USE_IPV6) && !defined(NO_SSL) #if defined(USE_IPV6) && !defined(NO_SSL)
/* Get data from callback using https://[::1] */ /* Get data from callback using https://[::1] */
client_conn = client_conn =
@ -734,7 +721,6 @@ START_TEST(test_request_handlers)
fwrite(encoded_file_content, 1, 52, f); fwrite(encoded_file_content, 1, 52, f);
fclose(f); fclose(f);
/* Get static data */ /* Get static data */
client_conn = mg_download("localhost", client_conn = mg_download("localhost",
ipv4_port, ipv4_port,
@ -761,7 +747,6 @@ START_TEST(test_request_handlers)
#endif #endif
mg_close_connection(client_conn); mg_close_connection(client_conn);
/* Get zipped static data - will not work if Accept-Encoding is not set */ /* Get zipped static data - will not work if Accept-Encoding is not set */
client_conn = mg_download("localhost", client_conn = mg_download("localhost",
ipv4_port, ipv4_port,
@ -806,7 +791,6 @@ START_TEST(test_request_handlers)
#endif #endif
mg_close_connection(client_conn); mg_close_connection(client_conn);
/* Get directory listing */ /* Get directory listing */
client_conn = mg_download("localhost", client_conn = mg_download("localhost",
ipv4_port, ipv4_port,
@ -830,7 +814,6 @@ START_TEST(test_request_handlers)
#endif #endif
mg_close_connection(client_conn); mg_close_connection(client_conn);
/* POST to static file (will not work) */ /* POST to static file (will not work) */
client_conn = mg_download("localhost", client_conn = mg_download("localhost",
ipv4_port, ipv4_port,
@ -854,7 +837,6 @@ START_TEST(test_request_handlers)
#endif #endif
mg_close_connection(client_conn); mg_close_connection(client_conn);
/* PUT to static file (will not work) */ /* PUT to static file (will not work) */
client_conn = mg_download("localhost", client_conn = mg_download("localhost",
ipv4_port, ipv4_port,
@ -874,7 +856,6 @@ START_TEST(test_request_handlers)
#endif #endif
mg_close_connection(client_conn); mg_close_connection(client_conn);
/* Websocket test */ /* Websocket test */
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
/* Then connect a first client */ /* Then connect a first client */
@ -1097,8 +1078,8 @@ START_TEST(test_request_handlers)
} }
END_TEST END_TEST
Suite *
Suite *make_public_server_suite(void) make_public_server_suite(void)
{ {
Suite *const suite = suite_create("PublicServer"); Suite *const suite = suite_create("PublicServer");
@ -1108,7 +1089,6 @@ Suite *make_public_server_suite(void)
TCase *const startstophttps = tcase_create("Start Stop HTTPS Server"); TCase *const startstophttps = tcase_create("Start Stop HTTPS Server");
TCase *const serverrequests = tcase_create("Server Requests"); TCase *const serverrequests = tcase_create("Server Requests");
tcase_add_test(checktestenv, test_the_test_environment); tcase_add_test(checktestenv, test_the_test_environment);
tcase_set_timeout(checktestenv, civetweb_min_test_timeout); tcase_set_timeout(checktestenv, civetweb_min_test_timeout);
suite_add_tcase(suite, checktestenv); suite_add_tcase(suite, checktestenv);
@ -1132,14 +1112,14 @@ Suite *make_public_server_suite(void)
return suite; return suite;
} }
#ifdef REPLACE_CHECK_FOR_LOCAL_DEBUGGING #ifdef REPLACE_CHECK_FOR_LOCAL_DEBUGGING
/* Used to debug test cases without using the check framework */ /* Used to debug test cases without using the check framework */
static int chk_ok = 0; static int chk_ok = 0;
static int chk_failed = 0; static int chk_failed = 0;
void main(void) void
main(void)
{ {
test_the_test_environment(0); test_the_test_environment(0);
test_threading(0); test_threading(0);
@ -1150,7 +1130,8 @@ void main(void)
printf("\nok: %i\nfailed: %i\n\n", chk_ok, chk_failed); printf("\nok: %i\nfailed: %i\n\n", chk_ok, chk_failed);
} }
void _ck_assert_failed(const char *file, int line, const char *expr, ...) void
_ck_assert_failed(const char *file, int line, const char *expr, ...)
{ {
va_list va; va_list va;
va_start(va, expr); va_start(va, expr);
@ -1161,7 +1142,8 @@ void _ck_assert_failed(const char *file, int line, const char *expr, ...)
chk_failed++; chk_failed++;
} }
void _ck_assert_msg(int cond, const char *file, int line, const char *expr, ...) void
_ck_assert_msg(int cond, const char *file, int line, const char *expr, ...)
{ {
va_list va; va_list va;
@ -1178,12 +1160,14 @@ void _ck_assert_msg(int cond, const char *file, int line, const char *expr, ...)
chk_failed++; chk_failed++;
} }
void _mark_point(const char *file, int line) void
_mark_point(const char *file, int line)
{ {
chk_ok++; chk_ok++;
} }
void tcase_fn_start(const char *fname, const char *file, int line) void
tcase_fn_start(const char *fname, const char *file, int line)
{ {
} }
void suite_add_tcase(Suite *s, TCase *tc){}; void suite_add_tcase(Suite *s, TCase *tc){};
@ -1194,11 +1178,13 @@ void _tcase_add_test(TCase *tc,
int allowed_exit_value, int allowed_exit_value,
int start, int start,
int end){}; int end){};
TCase *tcase_create(const char *name) TCase *
tcase_create(const char *name)
{ {
return NULL; return NULL;
}; };
Suite *suite_create(const char *name) Suite *
suite_create(const char *name)
{ {
return NULL; return NULL;
}; };

8
test/shared.c
View File

@ -19,7 +19,6 @@
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#if !defined(_CRT_SECURE_NO_WARNINGS) #if !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS
#endif #endif
@ -27,18 +26,19 @@
#define _CRT_SECURE_NO_DEPRECATE #define _CRT_SECURE_NO_DEPRECATE
#endif #endif
#include "shared.h" #include "shared.h"
#include <string.h> #include <string.h>
static char s_test_directory[1024] = {'\0'}; static char s_test_directory[1024] = {'\0'};
const char *get_test_directory(void) const char *
get_test_directory(void)
{ {
return s_test_directory; return s_test_directory;
} }
void set_test_directory(const char *const path) void
set_test_directory(const char *const path)
{ {
strncpy(s_test_directory, strncpy(s_test_directory,
path, path,

2
test/shared.h
View File

@ -21,9 +21,7 @@
#ifndef TEST_SHARED_H_ #ifndef TEST_SHARED_H_
#define TEST_SHARED_H_ #define TEST_SHARED_H_
const char *get_test_directory(void); const char *get_test_directory(void);
void set_test_directory(const char *const path); void set_test_directory(const char *const path);
#endif /* TEST_SHARED_H_ */ #endif /* TEST_SHARED_H_ */