struct mg_context * start_websocket_server()
{
const char * options[] = { "document_root", DOCUMENT_ROOT,
"ssl_certificate", SSL_CERT,
"listening_ports", PORT,
"request_timeout_ms", "5000",
0
};
struct mg_callbacks callbacks;
struct mg_context *ctx;
memset(&callbacks, 0, sizeof(callbacks));
#if defined(MG_LEGACY_INTERFACE)
/* Obsolete: */
callbacks.websocket_connect = websock_server_connect;
callbacks.websocket_ready = websocket_server_ready;
callbacks.websocket_data = websocket_server_data;
callbacks.connection_close = websocket_server_connection_close;
ctx = mg_start(&callbacks, 0, options);
#else
/* New interface: */
ctx = mg_start(&callbacks, 0, options);
mg_set_websocket_handler(ctx, "/websocket",
websocket_server_connect,
websocket_server_ready,
websocket_server_data,
websocket_server_connection_close,
NULL);
#endif
return ctx;
}
int main(void) {
struct mg_callbacks callbacks;
struct mg_context *ctx;
// Initialize random number generator. It will be used later on for
// the session identifier creation.
srand((unsigned) time(0));
// Setup and start Civetweb
memset(&callbacks, 0, sizeof(callbacks));
callbacks.begin_request = begin_request_handler;
if ((ctx = mg_start(&callbacks, NULL, options)) == NULL) {
printf("%s\n", "Cannot start chat server, fatal exit");
exit(EXIT_FAILURE);
}
// Wait until enter is pressed, then exit
printf("Chat server started on ports %s, press enter to quit.\n",
mg_get_option(ctx, "listening_ports"));
getchar();
mg_stop(ctx);
printf("%s\n", "Chat server stopped.");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
const char * options[] = { "document_root", DOCUMENT_ROOT,
"listening_ports", PORT, 0
};
struct mg_callbacks callbacks;
struct mg_context *ctx;
memset(&callbacks, 0, sizeof(callbacks));
ctx = mg_start(&callbacks, 0, options);
mg_set_request_handler(ctx,EXAMPLE_URI, ExampleHandler,0);
mg_set_request_handler(ctx,EXIT_URI, ExitHandler,0);
mg_set_request_handler(ctx,"/a", AHandler,0);
mg_set_request_handler(ctx,"/a/b", ABHandler,0);
mg_set_request_handler(ctx,"**.foo$", FooHandler,0);
printf("Browse files at http://localhost:%s/\n", PORT);
printf("Run example at http://localhost:%s%s\n", PORT, EXAMPLE_URI);
printf("Exit at http://localhost:%s%s\n", PORT, EXIT_URI);
while (!exitNow) {
#ifdef _WIN32
Sleep(1000);
#else
sleep(1);
#endif
}
printf("Bye!\n");
return 0;
}
int httpserver_init(unsigned port)
{
char str[16];
snprintf(str, sizeof(str), "%u", port);
str[sizeof(str) - 1] = 0;
const char* options[] =
{
"listening_ports", str,
NULL, NULL
};
memset(&s_httpserver_callbacks, 0, sizeof(s_httpserver_callbacks));
s_httpserver_ctx = mg_start(&s_httpserver_callbacks, NULL, options);
if (s_httpserver_ctx == NULL)
return -1;
mg_set_request_handler(s_httpserver_ctx, "/" BASIC_INFO, httpserver_handle_basic_info, NULL);
mg_set_request_handler(s_httpserver_ctx, "/" MEMORY_MAP, httpserver_handle_mmaps, NULL);
mg_set_request_handler(s_httpserver_ctx, "/" MEMORY_MAP "/", httpserver_handle_mmaps, NULL);
return 0;
}
static int ml_aitvaras_init(lua_State* l) {
checkargs(0, "aitvaras.init");
invocation_cs = async_make_cs();
mempool_init(&invocation_pool, sizeof(Invocation));
cb_l = l;
lua_getglobal(l, "aitvaras");
if(!_validate_conf(l))
return luaL_error(l, "invalid configuration");
const char* lobby_addr = _getstr(l, "lobby_addr");
const char* server_addr = _getstr(l, "server_addr");
char* enlist_req = alloca(strlen(lobby_addr) + strlen("/enlist") + 1);
strcpy(enlist_req, lobby_addr);
strcat(enlist_req, "/enlist");
http_post(enlist_req, false, server_addr, NULL, _enlist_cb);
aatree_init(&clients);
const char* options[] = {
"listening_ports", _getstr(l, "listening_port"),
"document_root", _getstr(l, "document_root"),
NULL
};
mg_ctx = mg_start(mg_callback, NULL, options);
lua_pop(l, 1);
return 0;
}
static void
test_set_option(void)
{
struct {
const char *opt_name; /* Option name */
const char *opt_value; /* Option value */
int result; /* Expected result */
} tests[] = {
{"aliases", "a,b,c", 0}, /* Zero length value */
{"aliases", "a=,b=c,c=d", 0}, /* Zero length value */
{"aliases", "=a,b=c,c=d", 0}, /* Zero length key */
{"aliases", "a=b,b=c,c=d", 1}, /* OK */
{"not_existent_option", "", -1}, /* Unknown option */
{NULL, NULL, 0}
};
struct mg_context *ctx;
int i;
ctx = mg_start();
for (i = 0; tests[i].opt_name != NULL; i++) {
if (mg_set_option(ctx, tests[i].opt_name,
tests[i].opt_value) != tests[i].result)
fail("%s: mg_set_option(%s): failed expectation",
__func__, tests[i].opt_name);
}
mg_stop(ctx);
}
int cg_init(cg_configuration *cg_conf)
{
int rval = 0;
struct mg_context *ctx;
struct mg_callbacks callbacks;
const char *options[] = {
"listening_ports", "8901",
"document_root", "websocket_html_root",
NULL
};
// Setting all callback pointers to 0
memset(&callbacks, 0, sizeof(callbacks));
// Initialize
callbacks.websocket_ready = websocket_ready_handler;
// Respond to data received
callbacks.websocket_data = websocket_data_handler;
// Start the server
ctx = mg_start(&callbacks, NULL, options);
// Wait until the user press something
getchar();
// Stopping the server
mg_stop(ctx);
return rval;
}
TMongSrv::TMongSrv(const int& _PortN, const bool& FixedPortNP,
const PNotify& _Notify, int Threads) :
Notify(_Notify), PortN(_PortN), HomeNrFPath(
TStr::GetNrFPath(TDir::GetCurDir())), Rnd(TTm::GetMSecsFromOsStart()) {
ClientsLock = new TCriticalSection();
const char *options[] = {
//"document_root", HomeNrFPath.GetCStr(),
"listening_ports", TInt::GetStr(PortN).GetCStr(), "num_threads",
TInt::GetStr(Threads).GetCStr(),
//"enable_keep_alive", "yes",
//"auth_domain", TStr("").GetCStr(),
0 };
Ctx = mg_start(&HandleRequest, NULL, options);
IAssertR(Ctx != NULL, "Web-Server: Server failed to start!");
TChA MsgChA;
MsgChA += "Web-Server: Started at port ";
MsgChA += TInt::GetStr(PortN);
MsgChA += ".";
TNotify::OnNotify(Notify, ntInfo, MsgChA);
PMongSrv Pt(this);
Registry.AddDat(PortN, Pt);
}
END_TEST
START_TEST(test_mg_start_stop_https_server)
{
#ifndef NO_SSL
struct mg_context *ctx;
size_t ports_cnt;
int ports[16];
int ssl[16];
struct mg_callbacks callbacks;
char errmsg[256];
const char *OPTIONS[8]; /* initializer list here is rejected by CI test */
int opt_idx = 0;
const char *ssl_cert = locate_ssl_cert();
ck_assert(ssl_cert != NULL);
memset((void *)OPTIONS, 0, sizeof(OPTIONS));
#if !defined(NO_FILES)
OPTIONS[opt_idx++] = "document_root";
OPTIONS[opt_idx++] = ".";
#endif
OPTIONS[opt_idx++] = "listening_ports";
OPTIONS[opt_idx++] = "8080r,8443s";
OPTIONS[opt_idx++] = "ssl_certificate";
OPTIONS[opt_idx++] = ssl_cert;
ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
memset(ports, 0, sizeof(ports));
memset(ssl, 0, sizeof(ssl));
memset(&callbacks, 0, sizeof(callbacks));
memset(errmsg, 0, sizeof(errmsg));
callbacks.log_message = log_msg_func;
ctx = mg_start(&callbacks, (void *)errmsg, OPTIONS);
test_sleep(1);
ck_assert_str_eq(errmsg, "");
ck_assert(ctx != NULL);
ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
ck_assert_uint_eq(ports_cnt, 2);
ck_assert_int_eq(ports[0], 8080);
ck_assert_int_eq(ssl[0], 0);
ck_assert_int_eq(ports[1], 8443);
ck_assert_int_eq(ssl[1], 1);
ck_assert_int_eq(ports[2], 0);
ck_assert_int_eq(ssl[2], 0);
test_sleep(1);
mg_stop(ctx);
#endif
}
static void start_mongoose(int argc, char *argv[]) {
char *options[MAX_OPTIONS];
int i;
// Edit passwords file if -A option is specified
if (argc > 1 && !strcmp(argv[1], "-A")) {
if (argc != 6) {
show_usage_and_exit();
}
exit(mg_modify_passwords_file(argv[2], argv[3], argv[4], argv[5]) ?
EXIT_SUCCESS : EXIT_FAILURE);
}
// Show usage if -h or --help options are specified
if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
show_usage_and_exit();
}
/* Update config based on command line arguments */
process_command_line_arguments(argv, options);
/* Setup signal handler: quit on Ctrl-C */
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
/* Start Mongoose */
ctx = mg_start(&mongoose_callback, NULL, (const char **) options);
for (i = 0; options[i] != NULL; i++) {
free(options[i]);
}
if (ctx == NULL) {
die("%s", "Failed to start Mongoose.");
}
}
/* Main program: Set callbacks and start the server. */
int main(void)
{
/* Test server will use this port */
const char * PORT = "8080";
/* Startup options for the server */
struct mg_context *ctx;
const char *options[] = {
"listening_ports", PORT,
NULL};
struct mg_callbacks callbacks;
memset(&callbacks, 0, sizeof(callbacks));
callbacks.begin_request = begin_request_handler;
callbacks.upload = upload_handler;
/* Display a welcome message */
printf("File upload demo.\n");
printf("Open http://localhost:%s/ in your browser.\n\n", PORT);
/* Start the server */
ctx = mg_start(&callbacks, NULL, options);
/* Wait until thr user hits "enter", then stop the server */
getchar();
mg_stop(ctx);
return 0;
}
web_engine::web_engine(emu_options &options)
: m_options(options),
m_machine(NULL),
m_ctx(NULL),
m_lastupdatetime(0),
m_exiting_core(false)
{
struct mg_callbacks callbacks;
// List of options. Last element must be NULL.
const char *web_options[] = {
"listening_ports", options.http_port(),
"document_root", options.http_path(),
NULL
};
// Prepare callbacks structure.
memset(&callbacks, 0, sizeof(callbacks));
callbacks.begin_request = begin_request_handler_static;
callbacks.websocket_ready = websocket_ready_handler_static;
callbacks.websocket_data = websocket_data_handler_static;
callbacks.http_error = begin_http_error_handler_static;
// Start the web server.
if (m_options.http()) {
m_ctx = mg_start(&callbacks, this, web_options);
mg_start_thread(websocket_keepalive_static, this);
}
}
void Start()
{
Internal("Http::Start","()");
if (enabled && !ctx)
{
// Try listening on the configured port number (8080 by default)
// and advance foward until one is available
for (int i = 0; i<100; ++i)
{
string j = print_string(port+i);
const char *options[3] = { "listening_ports", j.c_str(), NULL};
ctx = mg_start(&callback, NULL, options);
if (ctx)
break;
}
const char *option = NULL;
if (ctx)
option = mg_get_option(ctx,"listening_ports");
if (option)
{
Info("Listening for HTTP connections on port ",option);
}
else
{
Info("Not listening for HTTP connections.");
}
}
}
static void start_mongoose(void)
{
#ifndef __ANDROID_
const char *options[] = {
"listening_ports", "8080",
"document_root", ".",
NULL
};
/* Setup signal handler: quit on Ctrl-C */
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
#else
const char *options[] = {
"listening_ports", "8080",
"document_root", "/mnt/sdcard/",
NULL
};
#endif
/* Start Mongoose, and put hls_sys_t hls_glb->hls_ctx->m3u8_download_q to mongoose */
ctx = mg_start(&mongoose_callback, NULL, (const char **) options);
if (ctx == NULL) {
die("%s", "Failed to start Mongoose.");
}
}
void run_ssdp(int port, const char *pFriendlyName, const char * pModelName, const char *pUuid) {
struct sockaddr sa;
socklen_t len = sizeof(sa);
if(pFriendlyName) {
strncpy(friendly_name, pFriendlyName, sizeof(friendly_name));
friendly_name[255] = '\0';
} else {
strcpy(friendly_name, "DIAL server sample");
}
if(pModelName) {
strncpy(model_name, pModelName, sizeof(model_name));
uuid[255] = '\0';
} else {
strcpy(model_name, "deadbeef-dead-beef-dead-beefdeadbeef");
}
if(pUuid) {
strncpy(uuid, pUuid, sizeof(uuid));
uuid[255] = '\0';
} else {
strcpy(uuid, "deadbeef-dead-beef-dead-beefdeadbeef");
}
dial_port = port;
get_local_address();
ctx = mg_start(&request_handler, NULL, SSDP_PORT);
if (mg_get_listen_addr(ctx, &sa, &len)) {
my_port = ntohs(((struct sockaddr_in *)&sa)->sin_port);
}
printf("SSDP listening on %s:%d\n", ip_addr, my_port);
handle_mcast();
}
END_TEST
START_TEST(test_mg_start_stop_http_server)
{
struct mg_context *ctx;
const char *OPTIONS[] = {
"document_root", ".", "listening_ports", "8080", NULL,
};
size_t ports_cnt;
int ports[16];
int ssl[16];
memset(ports, 0, sizeof(ports));
memset(ssl, 0, sizeof(ssl));
ctx = mg_start(NULL, NULL, OPTIONS);
ck_assert(ctx != NULL);
ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
ck_assert_uint_eq(ports_cnt, 1);
ck_assert_int_eq(ports[0], 8080);
ck_assert_int_eq(ssl[0], 0);
ck_assert_int_eq(ports[1], 0);
ck_assert_int_eq(ssl[1], 0);
mg_Sleep(1);
mg_stop(ctx);
}
int main(int argc, char **argv)
{
printf("rtvd %s\n", RTVD_VERSION);
char *port = "8080";
if (argc > 1)
port = argv[1];
char *webPath = malloc(128);
strcpy(webPath,"./");
//if (get_conf_string("System", "WebServerPath", webPath) != RETURN_SUCCESS) {
// mg_set_option(ctx, "root", "./www");
// } else {
mg_set_option(ctx, "root", webPath);
// }
mg_set_option(ctx, "ports", port);
//Test_InPutTs();
mg_bind_to_uri(ctx, "/test", &show_post, "7");
mg_bind_to_uri(ctx, "/stati", &stati_handler, "8");
mg_bind_to_uri(ctx, "/s", &stream_page_handler, "9");
mg_bind_to_uri(ctx, "/si", &stream_info_handler, "10");
mg_bind_to_uri(ctx, "/ss", &stream_static_handler, "11");
mg_bind_to_uri(ctx, "/pcr", &stream_pcr_handler, "12");
mg_bind_to_uri(ctx, "/ajax/start_flow", &stream_start_flow_handler, "13");
mg_bind_to_uri(ctx, "/ajax/stop_flow", &stream_stop_flow_handler, "14");
mg_bind_to_error_code(ctx, 404, &test_error, NULL);
ctx = mg_start();
printf("Mongoose %s started on port(s) [%s], serving directory [%s]\n",
mg_version(),
mg_get_option(ctx, "listening_ports"),
mg_get_option(ctx, "root"));
while (1) {sleep(1);}
}
static void test_mg_upload(void) {
static const char *boundary = "OOO___MY_BOUNDARY___OOO";
struct mg_context *ctx;
struct mg_connection *conn;
char ebuf[100], buf[20], *file_data, *post_data = NULL;
int file_len, post_data_len;
ASSERT((ctx = mg_start(&CALLBACKS, NULL, OPTIONS)) != NULL);
ASSERT((file_data = read_file("mongoose.c", &file_len)) != NULL);
post_data_len = alloc_printf(&post_data, 0,
"--%s\r\n"
"Content-Disposition: form-data; "
"name=\"file\"; "
"filename=\"%s\"\r\n\r\n"
"%.*s\r\n"
"--%s\r\n",
boundary, upload_filename,
file_len, file_data, boundary);
ASSERT(post_data_len > 0);
ASSERT((conn = mg_download("localhost", atoi(HTTPS_PORT), 1,
ebuf, sizeof(ebuf),
"POST /upload HTTP/1.1\r\n"
"Content-Length: %d\r\n"
"Content-Type: multipart/form-data; "
"boundary=%s\r\n\r\n"
"%.*s", post_data_len, boundary,
post_data_len, post_data)) != NULL);
free(file_data), free(post_data);
ASSERT(mg_read(conn, buf, sizeof(buf)) == (int) strlen(upload_ok_message));
ASSERT(memcmp(buf, upload_ok_message, strlen(upload_ok_message)) == 0);
mg_close_connection(conn);
mg_stop(ctx);
}
static void WINAPI
ServiceMain(void)
{
char path[MAX_PATH], *p, *av[] = {"mongoose_service", NULL, NULL};
struct mg_context *ctx;
av[1] = path;
ss.dwServiceType = SERVICE_WIN32;
ss.dwCurrentState = SERVICE_RUNNING;
ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
hStatus = RegisterServiceCtrlHandler(service_name, ControlHandler);
SetServiceStatus(hStatus, &ss);
GetModuleFileName(NULL, path, sizeof(path));
if ((p = strrchr(path, DIRSEP)) != NULL)
*++p = '\0';
strcat(path, CONFIG_FILE); /* woo ! */
Sleep(3000);
if ((ctx = mg_start()) != NULL) {
process_command_line_arguments(ctx, av);
while (ss.dwCurrentState == SERVICE_RUNNING)
Sleep(1000);
mg_stop(ctx);
}
ss.dwCurrentState = SERVICE_STOPPED;
ss.dwWin32ExitCode = (DWORD) -1;
SetServiceStatus(hStatus, &ss);
}
int
main_ztv_webui_init(int argc, char *argv[])
{
if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'A') {
if (argc != 6)
show_usage_and_exit();
exit(mg_edit_passwords(argv[2], argv[3], argv[4],argv[5]));
}
if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")))
show_usage_and_exit();
#ifndef _WIN32
(void) signal(SIGCHLD, signal_handler);
#endif /* _WIN32 */
(void) signal(SIGTERM, signal_handler);
(void) signal(SIGINT, signal_handler);
if ((ctx = mg_start()) == NULL) {
(void) printf("%s\n", "Cannot initialize Mongoose context");
exit(EXIT_FAILURE);
}
process_command_line_arguments(ctx, argv);
if (mg_get_option(ctx, "ports") == NULL &&
mg_set_option(ctx, "ports", "8080") != 1)
exit(EXIT_FAILURE);
printf("Mongoose %s started on port(s) [%s], serving directory [%s]\n",
mg_version(),
mg_get_option(ctx, "ports"),
mg_get_option(ctx, "root"));
mg_set_uri_callback(ctx, "/login", &login_page, NULL);
mg_set_uri_callback(ctx, "/ztv", &ztv_page, NULL);
mg_set_uri_callback(ctx, "/share.apk", &share_pkg,NULL);
mg_set_uri_callback(ctx, "/shs", &shs_page, NULL);
mg_set_uri_callback(ctx, "/about", &shs_page, NULL);
mg_set_uri_callback(ctx, "/uploadfile", &upload_page, NULL);
mg_set_uri_callback(ctx, "/upload.html", &upload_input_page, NULL);
mg_set_uri_callback(ctx, "/upload.htm", &upload_input_page, NULL);
mg_set_uri_callback(ctx, "/r.html", &rili_page, NULL);
mg_set_uri_callback(ctx, "/r.manifest", &r_manifest_page, NULL);
mg_set_uri_callback(ctx, "/http302Jobs.mp4", &http302Jobs_mp4_page, NULL);
mg_set_uri_callback(ctx, "/bbs.html", &bbs_input_page, NULL);
mg_set_uri_callback(ctx, "/bbs", &bbs_page, NULL);
fflush(stdout);
/* while (exit_flag == 0)
sleep(1);
(void) printf("Exiting on signal %d, "
"waiting for all threads to finish...", exit_flag);
fflush(stdout);
mg_stop(ctx);
(void) printf("%s", " done.\n"); */
return (EXIT_SUCCESS);
}
void Server::start() {
//initializes Mongoose
ctx = mg_start(&event_handler, NULL, options);
if (ctx == NULL)
throw 42;
_log.log(LOG_STATUS,"PerVERT Server started on port %s.\n", mg_get_option(ctx, "listening_ports"));
}
static void test_user_data(void) {
struct mg_context *ctx;
ASSERT((ctx = mg_start(user_data_tester, (void *) 123, OPTIONS)) != NULL);
ASSERT(ctx->user_data == (void *) 123);
call_user(fc(ctx), MG_NEW_REQUEST);
mg_stop(ctx);
}
int main(void) {
struct mg_context *ctx;
const char *options[] = {"listening_ports", LISTENING_PORT, NULL};
ctx = mg_start(callback, NULL, options);
pause();
return 0;
}
static void test_mg_download(void) {
char *p1, *p2, ebuf[100];
int len1, len2, port = atoi(HTTPS_PORT);
struct mg_connection *conn;
struct mg_context *ctx;
ASSERT((ctx = mg_start(event_handler, NULL, OPTIONS)) != NULL);
ASSERT(mg_download(NULL, port, 0, ebuf, sizeof(ebuf), "") == NULL);
ASSERT(mg_download("localhost", 0, 0, ebuf, sizeof(ebuf), "") == NULL);
ASSERT(mg_download("localhost", port, 1, ebuf, sizeof(ebuf), "") == NULL);
// Fetch nonexistent file, should see 404
ASSERT((conn = mg_download("localhost", port, 1, ebuf, sizeof(ebuf), "%s",
"GET /gimbec HTTP/1.0\r\n\r\n")) != NULL);
ASSERT(strcmp(conn->request_info.uri, "404") == 0);
mg_close_connection(conn);
// Fetch mongoose.c, should succeed
ASSERT((conn = mg_download("localhost", port, 1, ebuf, sizeof(ebuf), "%s",
"GET /mongoose.c HTTP/1.0\r\n\r\n")) != NULL);
ASSERT(!strcmp(conn->request_info.uri, "200"));
ASSERT((p1 = read_conn(conn, &len1)) != NULL);
ASSERT((p2 = read_file("mongoose.c", &len2)) != NULL);
ASSERT(len1 == len2);
ASSERT(memcmp(p1, p2, len1) == 0);
free(p1), free(p2);
mg_close_connection(conn);
// Fetch in-memory file, should succeed.
ASSERT((conn = mg_download("localhost", port, 1, ebuf, sizeof(ebuf), "%s",
"GET /blah HTTP/1.1\r\n\r\n")) != NULL);
ASSERT((p1 = read_conn(conn, &len1)) != NULL);
ASSERT(len1 == (int) strlen(inmemory_file_data));
ASSERT(memcmp(p1, inmemory_file_data, len1) == 0);
free(p1);
mg_close_connection(conn);
// Test SSL redirect, IP address
ASSERT((conn = mg_download("localhost", atoi(HTTP_PORT), 0,
ebuf, sizeof(ebuf), "%s",
"GET /foo HTTP/1.1\r\n\r\n")) != NULL);
ASSERT(strcmp(conn->request_info.uri, "302") == 0);
ASSERT(strcmp(mg_get_header(conn, "Location"),
"https://127.0.0.1:" HTTPS_PORT "/foo") == 0);
mg_close_connection(conn);
// Test SSL redirect, Host:
ASSERT((conn = mg_download("localhost", atoi(HTTP_PORT), 0,
ebuf, sizeof(ebuf), "%s",
"GET /foo HTTP/1.1\r\nHost: a.b:77\n\n")) != NULL);
ASSERT(strcmp(conn->request_info.uri, "302") == 0);
ASSERT(strcmp(mg_get_header(conn, "Location"),
"https://a.b:" HTTPS_PORT "/foo") == 0);
mg_close_connection(conn);
mg_stop(ctx);
}
int main(void) {
struct mg_context *ctx;
const char *options[] = {"listening_ports", "8080", NULL};
ctx = mg_start(options, event_handler, NULL);
getchar(); // Wait until user hits "enter"
mg_stop(ctx);
return 0;
}
void MongooseServer::Start()
{
if (!IsRunning())
{
std::string port = boost::lexical_cast<std::string>(port_);
if (ssl_)
{
port += "s";
}
const char *options[] = {
// Set the TCP port for the HTTP server
"listening_ports", port.c_str(),
// Optimization reported by Chris Hafey
// https://groups.google.com/d/msg/orthanc-users/CKueKX0pJ9E/_UCbl8T-VjIJ
"enable_keep_alive", (keepAlive_ ? "yes" : "no"),
// Set the SSL certificate, if any. This must be the last option.
ssl_ ? "ssl_certificate" : NULL,
certificate_.c_str(),
NULL
};
#if MONGOOSE_USE_CALLBACKS == 0
pimpl_->context_ = mg_start(&Callback, this, options);
#elif MONGOOSE_USE_CALLBACKS == 1
struct mg_callbacks callbacks;
memset(&callbacks, 0, sizeof(callbacks));
callbacks.begin_request = Callback;
pimpl_->context_ = mg_start(&callbacks, this, options);
#else
#error Please set MONGOOSE_USE_CALLBACKS
#endif
if (!pimpl_->context_)
{
throw OrthancException("Unable to launch the Mongoose server");
}
}
}
static void start_mongoose(int argc, char *argv[]) {
struct mg_callbacks callbacks;
char *options[MAX_OPTIONS];
int i;
// Edit passwords file if -A option is specified
if (argc > 1 && !strcmp(argv[1], "-A")) {
if (argc != 6) {
show_usage_and_exit();
}
exit(mg_modify_passwords_file(argv[2], argv[3], argv[4], argv[5]) ?
EXIT_SUCCESS : EXIT_FAILURE);
}
// Show usage if -h or --help options are specified
if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
show_usage_and_exit();
}
options[0] = NULL;
set_option(options, "document_root", ".");
// Update config based on command line arguments
process_command_line_arguments(argv, options);
// Make sure we have absolute paths for files and directories
// https://github.com/valenok/mongoose/issues/181
set_absolute_path(options, "document_root", argv[0]);
set_absolute_path(options, "put_delete_auth_file", argv[0]);
set_absolute_path(options, "cgi_interpreter", argv[0]);
set_absolute_path(options, "access_log_file", argv[0]);
set_absolute_path(options, "error_log_file", argv[0]);
set_absolute_path(options, "global_auth_file", argv[0]);
set_absolute_path(options, "ssl_certificate", argv[0]);
// Make extra verification for certain options
verify_existence(options, "document_root", 1);
verify_existence(options, "cgi_interpreter", 0);
verify_existence(options, "ssl_certificate", 0);
// Setup signal handler: quit on Ctrl-C
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
// Start Mongoose
memset(&callbacks, 0, sizeof(callbacks));
callbacks.log_message = &log_message;
ctx = mg_start(&callbacks, NULL, (const char **) options);
for (i = 0; options[i] != NULL; i++) {
free(options[i]);
}
if (ctx == NULL) {
die("%s", "Failed to start Mongoose.");
}
}
/**
* @brief Thread to handle WebService requests
* @return never returns until shutdown
*
* Receives requests over a web socket and acts on them.
*/
void *WebServiceThread( void *arg )
{
char *port;
char *logdir;
char buf[1024];
char **options;
struct mg_context *ctx;
pthread_mutex_lock( startupMutex );
port = pb_get_setting( "webServicePort" );
if( !port || !atoi(port) ) {
LogPrintNoArg( LOG_CRIT, "No WebService Port defined. Aborting!" );
return;
}
logdir = pb_get_setting( "webServiceLogDir" );
if( !logdir ) {
logdir = memstrlink( "/tmp" );
}
LogPrint( LOG_DEBUG, "Web Service listening on port %s", port );
LogPrint( LOG_DEBUG, "Web Logs in %s", logdir );
options = CREATEN(char *, 7);
options[0] = memstrlink("ports");
options[1] = memstrdup(port);
options[2] = memstrlink("access_log");
sprintf( buf, "%s/access.log", logdir );
options[3] = memstrdup(buf);
options[4] = memstrlink("error_log");
sprintf( buf, "%s/error.log", logdir );
options[5] = memstrdup(buf);
options[6] = NULL;
memfree( port );
memfree( logdir );
mg_set_allocs( &webServiceAllocs );
/*
* Initialize mongoose context.
* Start listening on port specified.
*/
ctx = mg_start(webServiceCallback, NULL, (const char **)options);
while( !GlobalAbort ) {
sleep(1);
}
mg_stop(ctx);
LogPrintNoArg(LOG_INFO, "Ending WebServiceThread");
return( NULL );
}
void HttpServer::Run(std::string indexDirectory)
{
//Some options ( Last option must be NULL )
const char *options[] = {"listening_ports", "2828", "document_root", indexDirectory.c_str(), NULL};
//Setup callbacks, i.e. nothing to do :)
struct mg_callbacks callbacks;
memset(&callbacks, 0, sizeof(callbacks));
ctx = mg_start(&callbacks, NULL, options);
}
int
mongoosed_main(int argc, char *argv[])
{
char dflt_port[5] = "80";
#if !defined(NO_AUTH)
if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'A') {
if (argc != 6)
show_usage_and_exit(argv[0]);
exit(mg_edit_passwords(argv[2], argv[3], argv[4],argv[5]));
}
#endif /* NO_AUTH */
if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")))
show_usage_and_exit(argv[0]);
#if defined(_WIN32)
(void) sprintf(service_name, "Mongoose %s", mg_version());
try_to_run_as_nt_service();
#endif /* _WIN32 */
#ifndef _WIN32
(void) signal(SIGCHLD, signal_handler);
#endif /* _WIN32 */
(void) signal(SIGTERM, signal_handler);
(void) signal(SIGINT, signal_handler);
if ((ctx = mg_start()) == NULL) {
(void) printf("%s\n", "Cannot initialize Mongoose context");
exit(EXIT_FAILURE);
}
process_command_line_arguments(ctx, argv);
if (mg_get_option(ctx, "ports") == NULL &&
mg_set_option(ctx, "ports", dflt_port /*"8080"*/) != 1)
exit(EXIT_FAILURE);
printf("Mongoose %s started on port(s) [%s], serving directory [%s]\n",
mg_version(),
mg_get_option(ctx, "ports"),
mg_get_option(ctx, "root"));
fflush(stdout);
while (exit_flag == 0)
sleep(1);
(void) printf("Exiting on signal %d, "
"waiting for all threads to finish...", exit_flag);
fflush(stdout);
mg_stop(ctx);
(void) printf("%s", " done.\n");
return (EXIT_SUCCESS);
}
