/**
* start mongoose thread
*/
int start_proxy(void)
{
init_server_name();
start_mongoose();
hls_info("%s started on port(s) %s with web root [%s]\n",
server_name, mg_get_option(ctx, "listening_ports"),
mg_get_option(ctx, "document_root"));
#ifndef __ANDROID_
while (exit_flag == 0) {
sleep(1);
}
hls_info("\nExiting on signal %d, waiting for all threads to finish...\n",
exit_flag);
#else
/* wait here for destroy signal */
sem_wait(&hls_live_sem);
hls_info("\nExiting on signal sem_post, waiting for all threads to finish...\n");
#endif
fflush(stdout);
mg_stop(ctx);
hls_info("%s", " done.\n");
hls_info(">>>>>>>>>>>>>>>>>>>[mongoose proxy thread] exit...\n");
return EXIT_SUCCESS;
}
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);}
}
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);
}
static const char *get_url_to_first_open_port(const struct mg_server *server) {
static char url[100];
const char *s = mg_get_option(server, "listening_port");
const char *cert = mg_get_option(server, "ssl_certificate");
snprintf(url, sizeof(url), "%s://%s%s",
cert == NULL ? "http" : "https",
s == NULL || strchr(s, ':') == NULL ? "127.0.0.1:" : "", s);
return url;
}
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);
}
int main(int argc, char *argv[]) {
init_server_name();
start_mongoose(argc, argv);
printf("%s serving [%s] on port %s\n",
server_name, mg_get_option(server, "document_root"),
mg_get_option(server, "listening_port"));
fflush(stdout); // Needed, Windows terminals might not be line-buffered
serving_thread_func(server);
printf("Exiting on signal %d ...", exit_flag);
fflush(stdout);
mg_destroy_server(&server);
printf("%s\n", " done.");
return EXIT_SUCCESS;
}
void SocketHandler::run( LPVOID lpStatus )
{
const callbackFn fPtr = reinterpret_cast<callbackFn>( lpStatus );
struct mg_server *server = mg_create_server( NULL );
const int buflen = 32;
char buf[buflen];
const char *result;
int currentPort = DEFAULT_PORT;
_snprintf( buf, buflen, "127.0.0.1:%i", currentPort );
while ( result = mg_set_option( server, "listening_port", buf ) )
{
USE_DEBUG( "Error \"%s\" opening http listen socket %s\n", result, buf );
Sleep( 100 );
currentPort = rand() % ( MAX_PORT - MIN_PORT ) + MIN_PORT;
_snprintf( buf, buflen, "127.0.0.1:%i", currentPort );
}
listenPort = currentPort;
mg_set_option( server, "document_root", documentRoot.c_str() );
mg_set_option( server, "extra_mime_types", ".mp4=video/mp4" );
USE_DEBUG( "Started on %s with root at %s\n",
mg_get_option( server, "listening_port" ),
mg_get_option( server, "document_root" ) );
canLoop = true;
time_t lastTime = time( NULL );
while ( canLoop )
{
mg_poll_server( server, 100 );
const time_t current_time = time( NULL );
if ( fPtr && lastTime < current_time )
{
lastTime = current_time;
fPtr();
}
// Sleep( 20 );
// USE_DEBUG( "." );
}
USE_DEBUG( "Webserver shuts down...\n" );
mg_destroy_server( &server );
USE_DEBUG( "Webserver is shut down.\n" );
}
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(void) {
struct mg_server *server;
//Start network configurations
//setup_ap();
//setup_dhcp();
//setup_iptables();
// Create and configure the server
server = mg_create_server(NULL, ev_handler);
mg_set_option(server, "document_root", ".");
mg_set_option(server, "listening_port", "8080");
limparRotas();
init_resources_table();
criar_tabela();
//registra a rota do log do cliente
add_route("/login", handle_post_request);
// Serve request. Hit Ctrl-C to terminate the program
printf("Starting on port %s\n", mg_get_option(server, "listening_port"));
for (;;) {
mg_poll_server(server, 1000);
}
// Cleanup, and free server instance
mg_destroy_server(&server);
return 0;
}
static const char *test_mg_set_option(void) {
struct mg_server *server = mg_create_server(NULL, NULL);
ASSERT(mg_set_option(server, "listening_port", "0") == NULL);
ASSERT(mg_get_option(server, "listening_port")[0] != '\0');
mg_destroy_server(&server);
return NULL;
}
static void edit_config_file(void) {
const char **names, *value;
FILE *fp;
int i;
char cmd[200];
// Create config file if it is not present yet
if ((fp = fopen(config_file, "r")) != NULL) {
fclose(fp);
} else if ((fp = fopen(config_file, "a+")) != NULL) {
fprintf(fp,
"# Mongoose web server configuration file.\n"
"# Lines starting with '#' and empty lines are ignored.\n"
"# For detailed description of every option, visit\n"
"# http://code.google.com/p/mongoose/wiki/MongooseManual\n\n");
names = mg_get_valid_option_names();
for (i = 0; names[i] != NULL; i += 3) {
value = mg_get_option(ctx, names[i]);
fprintf(fp, "# %s %s\n", names[i + 1], *value ? value : "<value>");
}
fclose(fp);
}
snprintf(cmd, sizeof(cmd), "notepad.exe %s", config_file);
WinExec(cmd, SW_SHOW);
}
int main(void){
struct mg_server *server;
// Start network configurations
setup_ap();
setup_dhcp();
setup_iptables();
// Create and configure the server
server = mg_create_server(NULL, ev_handler);
mg_set_option(server, "document_root", ".");
mg_set_option(server, "listening_port", "8080");
init_routes_table();
init_resources_table();
set_path_404("/404.html");
set_path_index("/index.html");
// Serve request. Hit Ctrl-C to terminate the program
printf("Starting on port %s\n", mg_get_option(server, "listening_port"));
for (;;) {
mg_poll_server(server, 1000);
}
// Cleanup, and free server instance
mg_destroy_server(&server);
return 0;
}
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
bbs_page(struct mg_connection *conn,
const struct mg_request_info *ri, void *data)
{
append_msg_data_to_bbs_file(conn, mg_get_option(ctx, "root"));
return ;
}
static void
upload_page(struct mg_connection *conn,
const struct mg_request_info *ri, void *data)
{
save_post_file_data_to_dir(conn, mg_get_option(ctx, "root"));
return ;
}
int main(int argc, char** argv)
{
core_loop_initialize(&_core);
init_server_name();
start_monguvse(argc, argv);
fprintf(stderr, "%s started on port(s) %s with web root [%s]\n",
_server_name, mg_get_option(_ctx, "listening_ports"),
mg_get_option(_ctx, "document_root"));
fprintf(stderr, "Starts the core loop\n");
uv_run(_core.loop);
core_loop_destroy(&_core);
return 0;
}
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"));
}
int main(int argc, char *argv[]) {
init_server_name();
start_mongoose(argc, argv);
printf("%s started on port(s) %s with web root [%s]\n",
server_name, mg_get_option(ctx, "listening_ports"),
mg_get_option(ctx, "document_root"));
while (exit_flag == 0) {
sleep(1);
}
printf("Exiting on signal %d, waiting for all threads to finish...",
exit_flag);
fflush(stdout);
mg_stop(ctx);
printf("%s", " done.\n");
return EXIT_SUCCESS;
}
static void *serve_thread_func(void *param) {
struct mg_server *server = (struct mg_server *) param;
printf("Listening on port %s\n", mg_get_option(server, "listening_port"));
while (s_received_signal == 0) {
mg_poll_server(server, 1000);
}
mg_destroy_server(&server);
return NULL;
}
int main (int argc, const char * argv[])
{
helper_num = 0;
helper1 = 0;
helper2 = 0;
helper3 = 0;
SN1_par = 100;
SN2_par = 100;
SN3_par = 100;
struct mg_context *ctx;
(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);
}
mg_set_option(ctx, "ports", "9909");
mg_set_option(ctx, "max_threads", "10");
mg_set_option(ctx, "dir_list", "no"); // Disable directory listing
mg_set_uri_callback(ctx, "/*", get, NULL); // Setting callback handler.
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);
getchar();
exit_flag = 9;
(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);
}
/**
* Incia el servidor en el puerto especificado.
* @param puerto El puerto a ser utilizado.
*/
void Servidor::iniciar(char *puerto){
webServer = mg_create_server(NULL, ev_handler);
mg_set_option(webServer, "listening_port", puerto);
printf("Starting on port %s\n", mg_get_option(webServer, "listening_port"));
for (;;) {
mg_poll_server(webServer, 1000);
}
}
void ofxWebServer::start(const char** options)
{
ctx = mg_start(NULL,options); // Start Mongoose serving thread
if (ctx == NULL) {
(void) printf("%s\n", "Cannot initialize Mongoose context");
exit(EXIT_FAILURE);
}
printf("Mongoose %s web server started on port(s) %s with web root [%s]\n",
mg_version(), mg_get_option(ctx, "listening_ports"),
mg_get_option(ctx, "document_root"));
/*#ifdef MACOSX
mg_set_option(ctx, "cgi_interp", ofToDataPath("php/php-cgi").c_str());
#endif*/
// TODOmg_set_error_callback(ctx, 404, ccwServer::show404, NULL);
// TODOmg_set_error_callback(ctx, 403, ccwServer::show403, NULL);
}
int main(void) {
struct mg_server *server = mg_create_server(NULL);
mg_set_option(server, "listening_port", "8080");
mg_add_uri_handler(server, "/", handler);
printf("Starting on port %s\n", mg_get_option(server, "listening_port"));
for (;;) {
mg_poll_server(server, 1000);
}
mg_destroy_server(&server);
return 0;
}
int main(int argc, char *argv[]) {
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
pid_t pid = 0;
pid = fork();
if (pid < 0) {
fprintf(stderr, "fork failed!\n");
exit(1);
}
if (pid > 0) {
sleep(1);
exit(0);
}
umask(0);
setsid();
chdir("/");
init_server_name();
start_server(argc, argv);
pid = getpid();
printf("%s started on port(s) %s with document root [%s], pid [%d]\n",
server_name, mg_get_option(ctx, "listening_ports"),
mg_get_option(ctx, "document_root"), pid);
char *pidfile = (char *)mg_get_option(ctx, "pidfile");
if (*pidfile) {
FILE *fp = fopen(pidfile, "w+");
fprintf(fp, "%d", pid);
fclose(fp);
}
while (exit_flag == 0) {
sleep(1);
}
printf("Exiting on signal %d, waiting for all threads to finish...",
exit_flag);
printf("%s", " done.\n");
fflush(stdout);
mg_stop(ctx);
return EXIT_SUCCESS;
}
void web_server_init(ws_init_t type)
{
user_iface_t *ui = user_iface;
if (type == WS_INIT_START) {
// send private/public ip addrs to registry
FILE *pf = popen("hostname -i", "r");
char ip_pvt[64];
fscanf(pf, "%16s", ip_pvt);
pclose(pf);
char ip_pub[64];
pf = popen("curl -s ident.me", "r");
fscanf(pf, "%16s", ip_pub);
pclose(pf);
char *bp;
asprintf(&bp, "curl -s -o /dev/null http://%s/php/register.php?reg=%d.%s.%d.%s",
LOGGING_HOST, SERIAL_NUMBER, ip_pvt, ui->port, ip_pub);
lprintf("private ip: %s public ip: %s\n", ip_pvt, ip_pub);
system(bp);
free(bp);
}
if (type == WS_INIT_CREATE) {
// if specified, override the port number of the first UI
if (port_override) {
lprintf("overriding port from %d -> %d for \"%s\"\n",
user_iface[0].port, port_override, user_iface[0].name);
user_iface[0].port = port_override;
}
}
// create webserver port(s)
while (ui->port) {
if (type == WS_INIT_CREATE) {
ui->server = mg_create_server(NULL, ev_handler);
char *s_port;
asprintf(&s_port, "%d", ui->port);
if (mg_set_option(ui->server, "listening_port", s_port) != NULL) {
lprintf("network port %d for \"%s\" in use\n", ui->port, ui->name);
lprintf("app already running in background?\ntry \"make stop\" (or \"m stop\") first\n");
xit(-1);
}
lprintf("webserver for \"%s\" on port %s\n", ui->name, mg_get_option(ui->server, "listening_port"));
free(s_port);
} else { // WS_INIT_START
CreateTaskP(&web_server, LOW_PRIORITY, ui);
}
ui++;
}
}
int main(void) {
struct mg_server *server = mg_create_server(NULL, NULL);
mg_set_option(server, "listening_port", "127.0.0.1:3255");
mg_set_option(server, "document_root", ".");
mg_set_option(server, "index_files", "bank.cgi");
printf("Starting on port %s\n", mg_get_option(server, "listening_port"));
for (;;) mg_poll_server(server, 1000);
mg_destroy_server(&server);
return 0;
}
int main(void) {
struct mg_context *ctx;
struct mg_callbacks callbacks;
struct WSAData wsaData;
char *localIp;
char passwdBuff[52];
const char *options[] = {
"listening_ports", "8080",
"num_threads", "1",
"authentication_domain", realm,
"document_root", "resources/",
NULL
};
memset(&callbacks, 0, sizeof(callbacks));
callbacks.begin_request = begin_request_handler;
// Attempt to deduce the local IP
if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
return -1;
localIp = deduce_ip();
WSACleanup();
if(localIp != NULL) {
printf("Starting remote control server on IP\n"
"+------------------+\n"
"| %-16s |\n"
"+------------------+\n", localIp);
}
// Generate the htpasswd file
printf("Please enter password (%i characters max., leave blank for none): ",
(sizeof passwdBuff)-2); // 2 for \n\0
my_gets(passwdBuff, sizeof passwdBuff);
generate_htpasswd(passwdBuff);
// Start Mongoose
ctx = mg_start(&callbacks, NULL, options);
printf("Listening ports: \t%s\n\n", mg_get_option(ctx, "listening_ports"));
printf("Press <ENTER> to terminate.\n");
getchar();
printf("Exiting...\n");
mg_stop(ctx);
return EXIT_SUCCESS;
}
int main(void) {
s_server = mg_create_server(NULL, ev_handler);
mg_set_option(s_server, "listening_port", "8080");
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
printf("Started on port %s\n", mg_get_option(s_server, "listening_port"));
while (s_signal_received == 0) {
mg_poll_server(s_server, 100);
}
mg_destroy_server(&s_server);
return 0;
}
int start_mongoose(int ether)
{
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 Mongoose
const char* options[] =
{
"document_root", ODI_HOME,
"listening_ports", WEB_SERVER_PORT,
//"access_log_file", "/odi/log/mongoose_access",
"error_log_file", "/odi/log/mongoose_error",
"enable_directory_listing", "no",
"ssl_certificate", SSL_KEY_FILE,
"request_timeout_ms", REQUESTED_TIME_OUT,
NULL
};
if ((ctx = mg_start(options, event_handler, NULL)) == NULL)
{
logger_error("%s\n", "Cannot start REMOTEM, fatal exit");
exit(EXIT_FAILURE);
}
logger_remotem("Web server root directory is %s, started on ports %s",
mg_get_option(ctx, "document_root"), mg_get_option(ctx, "listening_ports"));
strcpy(downloading_status, "Idle");
get_config_info();
if (ether) configure_network();
DVR_ID = getSerial();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
struct mg_server *server = mg_create_server(NULL);
mg_set_option(server, "listening_port", "8080");
mg_set_option(server, "document_root", argc > 1 ? argv[1] : ".");
mg_add_uri_handler(server, "/ws", handler);
mg_start_thread(timer_thread, server);
printf("Started on port %s\n", mg_get_option(server, "listening_port"));
for (;;) {
mg_poll_server(server, 3000);
}
mg_destroy_server(&server);
return 0;
}
