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);
}
