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;
}
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;
}
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(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;
}
void ofxWebServer::setLogging(bool setting) {
if (setting == false){
mg_set_option(ctx, "access_log", NULL);
mg_set_option(ctx, "error_log", NULL);
} else {
mg_set_option(ctx, "access_log", aLogFile.c_str());
mg_set_option(ctx, "error_log", eLogFile.c_str());
}
}
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 _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 ofxWebServer::start(string str, int port) {
ctx = mg_start();
mg_set_option(ctx,"ports",ofToString(port).c_str());
mg_set_error_callback(ctx, 404, ccwServer::show404, NULL);
mg_set_error_callback(ctx, 403, ccwServer::show403, NULL);
#ifdef TARGET_OSX
mg_set_option(ctx, "root", "/Applications/CCW/data/plugins/WebGUI/client/");
#endif
#ifdef _WIN32
mg_set_option(ctx, "root", ".\\data\\plugins\\WebGUI\\client\\");
#endif
}
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 *server = mg_create_server(NULL);
mg_set_option(server, "listening_port", "8080");
mg_set_option(server, "document_root", ".");
mg_set_auth_handler(server, auth_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 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()
{
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);
}
}
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;
}
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 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;
}
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()));
}
///////////////////////
//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;
}
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;
}
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
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);
}
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());
}
}
void
http_start(const char *web_root_, const char *doc_root_)
{
replace_str(&doc_root, doc_root_);
replace_str(&web_root, web_root_);
http_stop();
ctx = mg_start();
mg_set_option(ctx, "root", web_root);
mg_set_option(ctx, "ports", http_port);
mg_set_uri_callback(ctx, "/", &show_index, NULL);
mg_set_uri_callback(ctx, "/eval", &eval_script, NULL);
mg_set_uri_callback(ctx, "/get_files", &get_files, NULL);
mg_set_uri_callback(ctx, "/open_file", &open_file, NULL);
mg_set_uri_callback(ctx, "/upload_file", &upload_file, NULL);
mg_set_uri_callback(ctx, "/upload_script", &upload_script, NULL);
}
//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);
}
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
}
int main(void)
{
struct mg_server *server = mg_create_server(NULL, event_handler);
//printf("%s\n", sqlite3_libversion());
//db_init();
//db_insert();
mg_set_option(server, "document_root", ".");
mg_set_option(server, "listening_port", "8080");
printf("web service is working now\n");
for (;;)
{
mg_poll_server(server, 1000); // Infinite loop, Ctrl-C to stop
}
mg_destroy_server(&server);
return 0;
}
void Java_vladimir_fileserver_MainActivity_startNativeServer(JNIEnv* env, jclass clazz, jstring path) {
const char *path_utf8 = (*env)->GetStringUTFChars(env, path, NULL);
server_loop = 1;
struct mg_server *server;
server = mg_create_server(NULL, NULL);
__android_log_print(ANDROID_LOG_VERBOSE, "HTTP", "server created");
mg_set_option(server, "document_root", path_utf8); // Serve current directory
mg_set_option(server, "listening_port", "8090"); // Open port 8080
__android_log_print(ANDROID_LOG_VERBOSE, "HTTP", "root path %s", path_utf8);
__android_log_print(ANDROID_LOG_VERBOSE, "HTTP", "port 8090");
__android_log_print(ANDROID_LOG_VERBOSE, "HTTP", "starting loop...");
while (server_loop) {
mg_poll_server(server, 500); // Infinite loop, Ctrl-C to stop
}
__android_log_print(ANDROID_LOG_VERBOSE, "HTTP", "stopping...");
mg_destroy_server(&server);
__android_log_print(ANDROID_LOG_VERBOSE, "HTTP", "stopped");
}
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;
}
