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 int mg_create(lua_State *L) { const char* port = luaL_checkstring(L, 1); luaL_checktype(L, 2, LUA_TFUNCTION); int refws = luaL_ref(L, LUA_REGISTRYINDEX); luaL_checktype(L, 2, LUA_TFUNCTION); int refweb = luaL_ref(L, LUA_REGISTRYINDEX); struct mg_context *ctx = lua_newuserdata(L, sizeof(struct mg_context) ); struct mg_server *server = mg_create_server(ctx, event_handler); const char* err = mg_set_option(server, "listening_port", port); if(err) { luaL_error(L, "%s %s", err, port); } luaL_getmetatable(L, MONGOOSE_LUA); lua_setmetatable(L, -2); ctx->server = server; ctx->vm = L; ctx->callbackweb = refweb; ctx->callbackws = refws; return MG_TRUE; }
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 brubeck_http_endpoint_init(struct brubeck_server *server, const char *listen) { struct mg_server *mongoose = mg_create_server(server, event_handler); mg_set_option(mongoose, "listening_port", listen); pthread_create(&server->stats.thread, NULL, &stats_thread, mongoose); }
static int webserver_handler() { int retval = 1; switch(webserver_state) { case WEBSERVER_STATE_INIT: webserver = mg_create_server(NULL, ev_handler); mg_set_option(webserver, "listening_port", webserver_listeningport); mg_set_option(webserver, "document_root", webserver_documentroot); mg_set_option(webserver, "enable_directory_listing", "no"); mg_set_option(webserver, "index_files", ""); mg_set_option(webserver, "auth_domain", webserver_domain); webserver_state = WEBSERVER_STATE_POLLING; break; case WEBSERVER_STATE_POLLING: mg_poll_server(webserver, 1000); break; case WEBSERVER_STATE_EXITING: mg_destroy_server(&webserver); retval = 0; default: assert(false); } return retval; }
/////////////////////// //test <test.dict> int main(int argc, char * argv[]) { struct mg_server * server; // if(argc < 2) { printf("demo: %s <test.dict>\n", argv[0]); exit(0); } // dbox = dict_init(); dict_load(dbox, argv[1]); // server = mg_create_server(NULL, ev_handler); // mg_set_option(server, "listening_port", "8089"); // for(;;) { mg_poll_server(server, 1000); } // mg_destroy_server(&server); // dict_free(dbox); // return 0; }
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; }
WebAccess::WebAccess(Doc *doc, VirtualConsole *vcInstance, SimpleDesk *sdInstance, QObject *parent) : QThread(parent) , m_doc(doc) , m_vc(vcInstance) , m_sd(sdInstance) , m_server(NULL) , m_conn(NULL) , m_running(false) , m_pendingProjectLoaded(false) { Q_ASSERT(s_instance == NULL); Q_ASSERT(m_doc != NULL); Q_ASSERT(m_vc != NULL); s_instance = this; m_server = mg_create_server(NULL, event_handler); mg_set_option(m_server, "listening_port", "9999"); start(); #if defined(Q_WS_X11) || defined(Q_OS_LINUX) m_netConfig = new WebAccessNetwork(); #endif connect(m_vc, SIGNAL(loaded()), this, SLOT(slotVCLoaded())); }
static void start_mongoose(int argc, char *argv[]) { char *options[MAX_OPTIONS]; int i; if ((server = mg_create_server(NULL)) == NULL) { die("%s", "Failed to start Mongoose."); } // Edit passwords file if -A option is specified if (argc > 1 && !strcmp(argv[1], "-A")) { if (argc != 6) { show_usage_and_exit(); } exit(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", "."); set_option(options, "listening_port", "8080"); // 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); for (i = 0; options[i] != NULL; i += 2) { const char *msg = mg_set_option(server, options[i], options[i + 1]); if (msg != NULL) die("Failed to set option [%s]: %s", options[i], msg); free(options[i]); free(options[i + 1]); } // Setup signal handler: quit on Ctrl-C signal(SIGTERM, signal_handler); signal(SIGINT, signal_handler); #ifndef _WIN32 signal(SIGCHLD, signal_handler); #endif }
static void* web_SockJsServer_threadRun(void *data) { web_SockJsServer _this = web_SockJsServer(data); struct mg_server *server = mg_create_server(_this, web_SockJsServer_request); mg_set_option(server, "listening_port", "8000"); _this->server = (cx_word)server; web_SockJsServer_run(_this); mg_destroy_server(&server); return NULL; }
int main(void) { struct mg_server *server1, *server2; server1 = mg_create_server((void *) "1"); server2 = mg_create_server((void *) "2"); mg_add_uri_handler(server1, "/", request_handler); mg_add_uri_handler(server2, "/", request_handler); // Make both server1 and server2 listen on the same socket mg_set_option(server1, "listening_port", "8080"); mg_set_listening_socket(server2, mg_get_listening_socket(server1)); // server1 goes to separate thread, server 2 runs in main thread. // IMPORTANT: NEVER LET DIFFERENT THREADS HANDLE THE SAME SERVER. mg_start_thread(serve, server1); serve(server2); return 0; }
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; }
/** * 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); } }
bool HTTPServer::startPolling() { // Create and configure the server if ((server = mg_create_server(this, ev_handler)) == NULL) { return false; } char tmp_port[30]; sprintf(tmp_port,"%s:%d", GetAddress().c_str(),GetPort()); mg_set_option(server, "listening_port", tmp_port); serving_thread_func(server); return true; }
int _tmain(int argc, _TCHAR* argv[]) { struct mg_server *server = mg_create_server(NULL); mg_set_option(server, "document_root", "."); // Serve current directory mg_set_option(server, "listening_port", "80"); // Open port 8080 mg_add_uri_handler(server, "/callPython/", event_handler); for (;;) { mg_poll_server(server, 1000); // Infinite loop, Ctrl-C to stop } mg_destroy_server(&server); return 0; }
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 mem_web::start_web() { struct mg_server *server = mg_create_server(NULL, NULL); mg_set_option(server, "document_root", "."); // Serve current directory mg_set_option(server, "listening_port", "8080"); // Open port 8080 for (;;) { mg_poll_server(server, 1000); // Infinite loop, Ctrl-C to stop } mg_destroy_server(&server); return 0; }
int main(void) { struct mg_server *proxy_server = mg_create_server(NULL, ev_handler); struct mg_server *ws1_server = mg_create_server(NULL, ws_handler); struct mg_server *ws2_server = mg_create_server(NULL, ws_handler); size_t i; // Configure proxy server to listen on port 2014 mg_set_option(proxy_server, "listening_port", "2014"); //mg_set_option(proxy_server, "enable_proxy", "yes"); // Configure two websocket echo servers: // ws1 is WS, listening on 9001 // ws2 is WSS, listening on 9002 // Note that HTML page thinks that ws1 is WSS, and ws2 is WS, // where in reality it is vice versa and proxy server makes the decision. mg_set_option(ws1_server, "listening_port", "9001"); mg_set_option(ws2_server, "listening_port", "9002"); mg_set_option(ws2_server, "ssl_certificate", "certs/ws2_server.pem"); // Setup signal handlers signal(SIGTERM, signal_handler); signal(SIGINT, signal_handler); // Start SSL wrappers, each in it's own thread for (i = 0; i < ARRAY_SIZE(s_wrappers); i++) { ns_start_thread(wrapper_thread_func, &s_wrappers[i]); } // Start websocket servers in separate threads mg_start_thread(serve_thread_func, ws1_server); mg_start_thread(serve_thread_func, ws2_server); // Finally, start proxy server in this thread: this call blocks serve_thread_func(proxy_server); printf("Existing on signal %d\n", s_received_signal); return EXIT_SUCCESS; }
int main() { struct mg_server *server = mg_create_server(NULL, event_handler); mg_set_option(server, "Partyfy", "."); mg_set_option(server, "listening_port", "8080"); const char *username = "******"; //size_t size; char *password = getpass("Enter the password for the account\n"); sp_session *sp; spconfig.application_key_size = g_appkey_size; sp_error err = sp_session_create(&spconfig, &sp); if(SP_ERROR_OK != err) { fprintf(stderr, "Unable to create session: %s\n", sp_error_message(err)); exit(1); } g_sess = sp; pthread_mutex_init(&g_notify_mutex, NULL); pthread_cond_init(&g_notify_cond, NULL); sp_session_login(g_sess, username, password, 0, NULL); // See if the user logged in successfully printConnectionState(); int timeout = 0; sp_connectionstate state = sp_session_connectionstate(g_sess); while (state != SP_CONNECTION_STATE_LOGGED_IN) { sp_session_process_events(g_sess, &timeout); printf("Logging in...\n"); usleep(100000); state = sp_session_connectionstate(g_sess); } //audio_init(&g_audiofifo); printf("Logged in\n"); for(;;) { mg_poll_server(server, 1000); sp_session_process_events(g_sess, &timeout); //while(!g_notify_do) // pthread_cond_wait(&g_notify_cond, &g_notify_mutex); //g_notify_do = 0; //pthread_mutex_unlock(&g_notify_mutex); //if(g_playback_done) { // g_playback_done = 0; //} //pthread_mutex_lock(&g_notify_mutex); } mg_destroy_server(&server); }
void RestfulApi::run() { qDebug()<<"Webserver API running in a process thread: " << currentThreadId(); // Create and configure the server server = mg_create_server(NULL, ev_handler); mg_set_option(server, "listening_port", "38000"); mg_set_option(server, "document_root", "."); qDebug() << "Society Pro Web API. by Central Services. Listening at port 38000..."; for (;;) { mg_poll_server(server, 1000); } }
int web_init(struct engine* eng, const char* port) { memset(&web, 0, sizeof(web)); web.engine = eng; web.server = mg_create_server(NULL, event_handler); mg_set_option(web.server, "document_root", "static"); mg_set_option(web.server, "listening_port", port); errno = 0; mg_poll_server(web.server, 0); return errno; }
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; }
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(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; }
result_t webserver_init(int port) { char port_str[32]; str_itos(port_str, port); struct mg_server* server = mg_create_server(NULL, webserver_request_handler); if (server == NULL) { log_printf(LOG_WARNING, "starting httpd server failed - service will not be available."); return RET_FAIL; } mg_set_option(server, "listening_port", port_str); g_prf.server = server; log_printf(LOG_TEXT, "httpd debug server started on port '%s'", port_str); return RET_OK; }
static const char *test_ssl(void) { static const char *ssl_cert = "examples/ssl_cert.pem"; char buf1[100] = ""; struct mg_server *server = mg_create_server(NULL); ASSERT(mg_set_option(server, "listening_port", LISTENING_ADDR) == NULL); ASSERT(mg_set_option(server, "document_root", ".") == NULL); ASSERT(mg_set_option(server, "ssl_certificate", ssl_cert) == NULL); ASSERT(mg_connect(server, "127.0.0.1", atoi(HTTP_PORT), 1, us1, buf1) == 1); { int i; for (i = 0; i < 50; i++) mg_poll_server(server, 1000); } ASSERT(strcmp(buf1, "1") == 0); mg_destroy_server(&server); return NULL; }
web_engine::web_engine(emu_options &options) : m_options(options), m_machine(NULL), m_server(NULL), //m_lastupdatetime(0), m_exiting_core(false), m_http(m_options.http()) { if (m_http) { m_server = mg_create_server(this, ev_handler); mg_set_option(m_server, "listening_port", options.http_port()); mg_set_option(m_server, "document_root", options.http_path()); } }
//Mongoose void mongooseThread::Entry() { struct mg_server *mongooseserver; // Create and configure the server mongooseserver = mg_create_server((void *) "1", ::ev_handler); //WEB监听端口 char listening_port[6]; sprintf(listening_port, "%d", sHttpPort); mg_set_option(mongooseserver, "listening_port", listening_port); mg_set_option(mongooseserver, "document_root", sDocumentRoot); //donot use it printf("mongoose listen on port:%s document path:%s \n", listening_port , sDocumentRoot); //run server for (;;) mg_poll_server((struct mg_server *) mongooseserver, 1000); mg_destroy_server(&mongooseserver); }
void server_start() { da_init(rcon_data.plugin_handlers); //darray_init(&rcon_data.plugin_handlers); struct rcon_handler test_plugin_handler; test_plugin_handler.action = "test_plugin"; test_plugin_handler.handle_func = &handle_version; rcon_add_handler(&test_plugin_handler); rcon_data.server = mg_create_server(NULL, ev_handler); mg_set_option(rcon_data.server, "listening_port", "8080"); rcon_data.run_thread = true; pthread_create(&rcon_data.server_thread, NULL, thread_runner, NULL); }