int main(void) {
struct mg_mgr mgr;
struct mg_connection *nc1;
struct mg_connection *nc2;
const char *port1 = "127.0.0.1:80", *port2 = "[::1]:80";
oom_adjust_setup();
mg_mgr_init(&mgr, NULL);
nc1 = mg_bind(&mgr, port1, ev_handler);
nc2 = mg_bind(&mgr, port2, ev_handler);
mg_set_protocol_http_websocket(nc1);
mg_set_protocol_http_websocket(nc2);
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
__android_log_print(ANDROID_LOG_INFO, THIS_FILE, "AdAway Native Webserver: starting");
while (s_sig_num == 0) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
__android_log_print(ANDROID_LOG_INFO, THIS_FILE, "AdAway Native Webserver: exited on signal %d", s_sig_num);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
struct mg_mgr mgr;
struct mg_connection *nc;
if (argc != 2) {
fprintf(stderr, "Usage: %s <listening_addr>\n", argv[0]);
exit(EXIT_FAILURE);
}
printf("Listening on: [%s]\n", argv[1]);
mg_mgr_init(&mgr, NULL);
/*
* mg_bind() creates a listening connection on a given ip:port and
* with an attached event handler.
* The event handler will only trigger TCP events until the http
* protocol handler is installed.
*/
if ((nc = mg_bind(&mgr, argv[1], ev_handler)) == NULL) {
fprintf(stderr, "Error binding to %s\n", argv[1]);
exit(EXIT_FAILURE);
}
mg_set_protocol_http_websocket(nc);
web_root_opts.document_root = "./web_root";
/*
* We explicitly hand over control to the Mongoose manager
* in this event loop and we can easily multiplex other activities.
*/
for (;;) {
mg_mgr_poll(&mgr, 1000);
}
return EXIT_SUCCESS;
}
int main(void) {
struct mg_mgr mgr;
struct mg_connection *nc;
mkfifo(DSP_FIFO_IN, S_IRUSR | S_IWUSR);
if (NULL == (dsp_in = fopen(DSP_FIFO_IN, "w"))) {
perror("[Server] fopen("DSP_FIFO_IN")");
return 2;
}
mkfifo(DSP_FIFO_OUT, S_IRUSR | S_IWUSR);
if (NULL == (dsp_out = fopen(DSP_FIFO_OUT, "r"))) {
perror("[Server] fopen("DSP_FIFO_OUT")");
return 2;
}
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, ev_handler);
s_http_server_opts.document_root = "htdocs";
mg_set_protocol_http_websocket(nc);
printf("[Server] Started on port %s\n", s_http_port);
while (0 == s_signal_received) {
mg_mgr_poll(&mgr, 200);
}
mg_mgr_free(&mgr);
fclose(dsp_in);
fclose(dsp_out);
return 0;
}
int main(void)
{
struct mg_mgr mgr;
struct mg_connection *nc;
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
setvbuf(stdout, NULL, _IOLBF, 0);
setvbuf(stderr, NULL, _IOLBF, 0);
load_source_data();
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, ev_handler);
s_http_server_opts.document_root = ".";
s_http_server_opts.enable_directory_listing = "yes";
mg_set_protocol_http_websocket(nc);
printf("Started on port %s\n", s_http_port);
while (s_signal_received == 0)
{
mg_mgr_poll(&mgr, 200);
}
mg_mgr_free(&mgr);
save_source_data( s_source_path );
return 0;
}
void tws::mongoose::server::start()
{
pimpl_->stop_ = false;
struct mg_mgr server_;
struct mg_connection* conn_;
tws_mongoose_http_config conf = tws_mongoose_read_config_file();
mg_mgr_init(&server_, NULL);
conn_ = mg_bind(&server_,
boost::lexical_cast<std::string>(conf.listening_port).c_str(),
tws_mongoose_event_handler);
mg_set_protocol_http_websocket(conn_);
if(conf.max_threads > 1)
mg_enable_multithreading(conn_);
\
while(pimpl_->stop_ == false)
{
mg_mgr_poll(&server_, 1000);
}
mg_mgr_free(&server_);
}
static int init_web_server(const struct sys_config *cfg) {
/*
* Usually, we start to connect/listen in
* EVENT_STAMODE_GOT_IP/EVENT_SOFTAPMODE_STACONNECTED handlers
* The only obvious reason for this is to specify IP address
* in `mg_bind` function. But it is not clear, for what we have to
* provide IP address in case of ESP
*/
if (cfg->http.hidden_files) {
s_http_server_opts.hidden_file_pattern = strdup(cfg->http.hidden_files);
}
listen_conn = mg_bind(&sj_mgr, cfg->http.listen_addr, mongoose_ev_handler);
if (!listen_conn) {
LOG(LL_ERROR, ("Error binding to [%s]", cfg->http.listen_addr));
return 0;
} else {
mg_register_http_endpoint(listen_conn, "/conf/", conf_handler);
mg_register_http_endpoint(listen_conn, "/reboot", reboot_handler);
mg_register_http_endpoint(listen_conn, "/ro_vars", ro_vars_handler);
mg_register_http_endpoint(listen_conn, "/upload", upload_handler);
mg_set_protocol_http_websocket(listen_conn);
LOG(LL_INFO, ("HTTP server started on [%s]", cfg->http.listen_addr));
}
return 1;
}
int main(void) {
struct mg_mgr mgr;
struct mg_connection *nc;
cs_stat_t st;
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, ev_handler);
if (nc == NULL) {
fprintf(stderr, "Cannot bind to %s\n", s_http_port);
exit(1);
}
// Set up HTTP server parameters
mg_set_protocol_http_websocket(nc);
s_http_server_opts.document_root = "web_root"; // Set up web root directory
if (mg_stat(s_http_server_opts.document_root, &st) != 0) {
fprintf(stderr, "%s", "Cannot find web_root directory, exiting\n");
exit(1);
}
printf("Starting web server on port %s\n", s_http_port);
for (;;) {
static time_t last_time;
time_t now = time(NULL);
mg_mgr_poll(&mgr, 1000);
if (now - last_time > 0) {
push_data_to_all_websocket_connections(&mgr);
last_time = now;
}
}
mg_mgr_free(&mgr);
return 0;
}
int main(void) {
struct mg_mgr mgr;
struct mg_connection *nc;
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
mg_mgr_init(&mgr, 0);
nc = mg_bind(&mgr, s_default_address, coap_handler);
if (nc == NULL) {
printf("Unable to start listener at %s\n", s_default_address);
return -1;
}
printf("Listening for CoAP messages at %s\n", s_default_address);
mg_set_protocol_coap(nc);
while (!s_sig_received) {
mg_mgr_poll(&mgr, 1000000);
}
printf("Exiting on signal %d\n", s_sig_received);
mg_mgr_free(&mgr);
return 0;
}
/**
* @brief Run the web server listening at the given port.
*
* This function does not return.
*
* @param [in] port The port number of which to listen.
* @return N/A.
*/
void WebServer::start(uint16_t port) {
ESP_LOGD(tag, "WebServer task starting");
struct mg_mgr mgr;
mg_mgr_init(&mgr, NULL);
std::stringstream stringStream;
stringStream << ':' << port;
struct mg_connection *mgConnection = mg_bind(&mgr, stringStream.str().c_str(), mongoose_event_handler_web_server);
if (mgConnection == NULL) {
ESP_LOGE(tag, "No connection from the mg_bind()");
vTaskDelete(NULL);
return;
}
struct WebServerUserData *pWebServerUserData = new WebServerUserData();
pWebServerUserData->pWebServer = this;
pWebServerUserData->pMultiPart = nullptr;
mgConnection->user_data = pWebServerUserData; // Save the WebServer instance reference in user_data.
ESP_LOGD(tag, "start: User_data address 0x%d", (uint32_t)pWebServerUserData);
mg_set_protocol_http_websocket(mgConnection);
ESP_LOGD(tag, "WebServer listening on port %d", port);
while (1) {
mg_mgr_poll(&mgr, 2000);
}
} // run
bool ccMongooseWebServer::Start()
{
if (_mgr != NULL)
return false;
_mgr = new struct mg_mgr;
mg_mgr_init(_mgr, NULL);
_mgr->user_data = this;
_nc = mg_bind(_mgr, _strHttpPorts.c_str(), ev_handler);
// Set up HTTP server parameters
mg_set_protocol_http_websocket(_nc);
s_http_server_opts.document_root = "."; // Serve current directory
s_http_server_opts.enable_directory_listing = "yes";
printf("Starting web server on port %s\n", _strHttpPorts.c_str());
_bIsStopThread = false;
_pPollThread = new std::thread(std::bind(&ccMongooseWebServer::DoRunThread, this));
return true;
}
int main(void) {
struct mg_mgr mgr;
const char *port1 = "1234", *port2 = "127.0.0.1:17000";
mg_mgr_init(&mgr, NULL);
mg_bind(&mgr, port1, ev_handler);
mg_bind(&mgr, port2, ev_handler);
printf("Starting echo mgr on ports %s, %s\n", port1, port2);
for (;;) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return 0;
}
int main(int argc, char *argv[]) {
struct mg_mgr mgr;
struct mg_connection *nc;
int i;
mg_mgr_init(&mgr, NULL);
s_our_ip_addr = inet_addr("127.0.0.1");
/* Parse command line arguments */
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-D") == 0) {
mgr.hexdump_file = argv[++i];
} else if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) {
s_listening_addr = argv[++i];
} else {
s_our_ip_addr = inet_addr(argv[i]);
}
}
fprintf(stderr, "Listening on '%s'\n", s_listening_addr);
if ((nc = mg_bind(&mgr, s_listening_addr, ev_handler)) == NULL) {
fprintf(stderr, "cannot bind to socket\n");
exit(1);
}
mg_set_protocol_dns(nc);
while (s_exit_flag == 0) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return 0;
}
void *VSCPMQTTBrokerThread::Entry()
{
struct mg_mgr mgr;
struct mg_connection *nc;
struct mg_mqtt_broker brk;
const char *address = "0.0.0.0:1883";
// Check pointers
if ( NULL == m_pCtrlObject ) return NULL;
// We need to create a clientobject and add this object to the list
m_pClientItem = new CClientItem;
if ( NULL == m_pClientItem ) {
m_pCtrlObject->logMsg( _( "[VSCP MQTT Broker] Unable to allocate memory for client.\n" ) );
return NULL;
}
// This is now an active Client
m_pClientItem->m_bOpen = true;
m_pClientItem->m_type = CLIENT_ITEM_INTERFACE_TYPE_CLIENT_UDP;
m_pClientItem->m_strDeviceName = _("VSCP MQTT Broker: Started at ");
wxDateTime now = wxDateTime::Now();
m_pClientItem->m_strDeviceName += now.FormatISODate();
m_pClientItem->m_strDeviceName += _(" ");
m_pClientItem->m_strDeviceName += now.FormatISOTime();
// Add the client to the Client List
m_pCtrlObject->m_wxClientMutex.Lock();
m_pCtrlObject->addClient( m_pClientItem );
m_pCtrlObject->m_wxClientMutex.Unlock();
// Clear the filter (Allow everything )
vscp_clearVSCPFilter( &m_pClientItem->m_filterVSCP );
mg_mgr_init( &mgr, this );
mg_mqtt_broker_init( &brk, NULL );
if ( ( nc = mg_bind( &mgr,
m_pCtrlObject->m_strMQTTBrokerInterfaceAddress.mbc_str(),
mg_mqtt_broker ) ) == NULL) {
m_pCtrlObject->logMsg( _("VSCP MQTT Broker: Faild to bind to requested address.\n") );
return NULL;
}
nc->user_data = &brk;
m_pCtrlObject->logMsg( _("VSCP MQTT Broker: Thread started.\n") );
while ( !TestDestroy() && !m_bQuit ) {
mg_mgr_poll( &mgr, 1000 );
}
// release the server
//ns_mgr_free( &m_pCtrlObject->m_mgrTcpIpServer );
mg_mgr_free( &mgr );
m_pCtrlObject->logMsg( _( "VSCP MQTT Broker: Quit.\n" ) );
return NULL;
}
Server::Server() {
/**Creo el server**/
this->configuration=Configuration::getConfiguration();
mg_mgr_init(&mgr, NULL); //Inicializo el Mongoose manager
string http_port=this->configuration->getStringAttribute("http_port");
nc = mg_bind(&mgr, http_port.c_str(), Server::staticEvHandler); //Creo la conexion que escucha.
mg_set_protocol_http_websocket(nc); //Conecta al event handler de http con la conexion.
}
int main(int argc, char* argv[])
{
if (VIPS_INIT(argv[0])) {
vips_error_exit("Unable to start VIPS");
}
int ret = 0;
// Initialize and open database
ret = init_dbfile(argc, argv[1]);
if (ret == 0) {
print_header(&db_file->header);
// Initialize signal handler and kill previous one
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
struct mg_mgr mgr;
struct mg_connection* nc;
// Create listening connection
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, db_event_handler);
if (nc != NULL) {
// Set up HTTP server parameters
mg_set_protocol_http_websocket(nc);
s_http_server_opts.document_root = "."; // Serve current directory
s_http_server_opts.enable_directory_listing = "yes";
// Listening loop
printf("Starting web server on port %s,\nserving %s\n", s_http_port,
s_http_server_opts.document_root);
while (!s_sig_received) {
mg_mgr_poll(&mgr, 1000);
}
printf("Exiting on signal %d\n", s_sig_received);
} else {
fprintf(stderr, "Unable to create web server on port %s\n", s_http_port);
}
mg_mgr_free(&mgr);
}
// Close database and free the pointer
do_close(db_file);
free(db_file);
// Print error message if there was an error
if (ret) {
fprintf(stderr, "ERROR: %s\n", ERROR_MESSAGES[ret]);
}
vips_shutdown();
return ret;
}
bool BasicHttp::Start(){
mg_mgr_init(&_mgr, NULL);
auto nc = mg_bind(&_mgr, _port, EvHandler);
if(nullptr == nc)
return false;
mg_set_protocol_http_websocket(nc);
return true;
}
int init_server(struct mg_mgr& mgr, struct mg_connection*& nc, struct mg_serve_http_opts& s_http_server_opts)
{
/* Open listening socket */
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, ev_handler);
mg_set_protocol_http_websocket(nc); //not sure if it needed
s_http_server_opts.document_root = "web/web_root";
return 0;
}
void server::warmup() {
for (int i = 0; i < 4; ++i) {
struct mg_mgr* mgMgr = new mg_mgr;
vectorMgr.push_back(mgMgr);
mg_mgr_init(mgMgr, this);
mg_bind(mgMgr, s_http_port, ev_handler);
}
for(mg_mgr*mgMgr: vectorMgr){ mg_start_thread(run,mgMgr); }
while(true){
sleep(1);
}
std::cout<< "this is a test" << std::endl;
}
JNIEXPORT void JNICALL Java_com_zcwfeng_fastdev_ndk_NdkJniUtils_openServer(void) {
// TODO
struct mg_mgr mgr;
struct mg_connection *nc;
/* Open listening socket */
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, ev_handler);
mg_set_protocol_http_websocket(nc);
// s_http_server_opts.document_root = "web_root";
/* Parse command line arguments */
// for (i = 1; i < argc; i++) {
// if (strcmp(argv[i], "-D") == 0) {
// mgr.hexdump_file = argv[++i];
// } else if (strcmp(argv[i], "-f") == 0) {
// s_db_path = argv[++i];
// } else if (strcmp(argv[i], "-r") == 0) {
// s_http_server_opts.document_root = argv[++i];
// }
// }
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
/* Open database */
if ((s_db_handle = db_open(s_db_path)) == NULL) {
fprintf(stderr, "Cannot open DB [%s]\n", s_db_path);
exit(EXIT_FAILURE);
}
/* Run event loop until signal is received */
printf("Starting RESTful server on port %s\n", s_http_port);
while (s_sig_num == 0) {
mg_mgr_poll(&mgr, 1000);
}
/* Cleanup */
mg_mgr_free(&mgr);
db_close(&s_db_handle);
printf("Exiting on signal %d\n", s_sig_num);
}
/** WebServer constructor
* Wraps the mongoose server
* Protects the resources using the RAII pattern.
*
* \param port Is the port of listener socket, as string.
*/
WebServer::WebServer(const std::string &port) : httpPort(port),
suggestionsGenerator(users),
requestManager(users, suggestionsGenerator) {
keepAlive = true;
mg_mgr_init(&eventManager, NULL);
networkConnection = mg_bind(&eventManager, httpPort.c_str(), eventHandler);
networkConnection->user_data = this;
serverOptions.document_root = ".";
serverOptions.dav_document_root = ".";
serverOptions.enable_directory_listing = "yes";
mg_set_protocol_http_websocket(networkConnection);
Log::instance()->append("Starting web server on port " + httpPort, Log::INFO);
}
int main(int argc, char *argv[]) {
struct mg_mgr mgr;
struct mg_connection *nc;
int i;
/* Open listening socket */
mg_mgr_init(&mgr, NULL);
/* configure frontend web server */
nc = mg_bind(&mgr, s_frontend_port, frontend_handler);
mg_set_protocol_http_websocket(nc);
s_frontend_server_opts.document_root = "frontend";
s_frontend_server_opts.url_rewrites =
"/api=http://localhost:8001,/=frontend/hello.html";
/* configure backend web server */
nc = mg_bind(&mgr, s_backend_port, backend_handler);
mg_set_protocol_http_websocket(nc);
s_backend_server_opts.document_root = "backend";
/* Parse command line arguments */
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-D") == 0) {
mgr.hexdump_file = argv[++i];
} else if (strcmp(argv[i], "-r") == 0) {
s_frontend_server_opts.document_root = argv[++i];
}
}
printf("Starting web server on port %s\n", s_frontend_port);
for (;;) {
mg_mgr_poll(&mgr, 1000);
}
}
static void mg_task(void *arg) {
LOG(LL_INFO, ("MG task running"));
GPIO_IF_LedToggle(MCU_RED_LED_GPIO);
osi_MsgQCreate(&s_v7_q, "MG", sizeof(struct event), 32 /* len */);
sl_Start(NULL, NULL, NULL);
data_init_sensors(TMP006_ADDR, BM222_ADDR);
cc3200_fs_init();
#if defined(WIFI_STA_SSID)
if (!wifi_setup_sta(WIFI_STA_SSID, WIFI_STA_PASS)) {
LOG(LL_ERROR, ("Error setting up WiFi station"));
}
#elif defined(WIFI_AP_SSID)
if (!wifi_setup_ap(WIFI_AP_SSID, WIFI_AP_PASS, WIFI_AP_CHAN)) {
LOG(LL_ERROR, ("Error setting up WiFi AP"));
}
#else
#error WiFi not configured
#endif
/* We don't need SimpleLink's web server. */
sl_NetAppStop(SL_NET_APP_HTTP_SERVER_ID);
mg_mgr_init(&mg_mgr, NULL);
const char *err = "";
struct mg_bind_opts opts;
memset(&opts, 0, sizeof(opts));
opts.error_string = &err;
struct mg_connection *nc = mg_bind(&mg_mgr, "80", mg_ev_handler);
if (nc != NULL) {
mg_set_protocol_http_websocket(nc);
nc->ev_timer_time = mg_time(); /* Start data collection */
} else {
LOG(LL_ERROR, ("Failed to create listener: %s", err));
}
while (1) {
struct event e;
mg_mgr_poll(&mg_mgr, 0);
if (osi_MsgQRead(&s_v7_q, &e, 1) != OSI_OK) continue;
}
}
static void mg_init(struct mg_mgr *mgr) {
WiFi_Params wifiParams;
WiFi_Handle handle;
LOG(LL_INFO, ("MG task running"));
/* Open WiFi driver */
WiFi_Params_init(&wifiParams);
wifiParams.bitRate = 2000000;
handle = WiFi_open(Board_WIFI, Board_WIFI_SPI, NULL, &wifiParams);
if (handle == NULL) {
System_abort("WiFi driver failed to open.");
}
sl_Start(0, 0, 0);
sl_fs_init();
#if defined(WIFI_STA_SSID)
if (!wifi_setup_sta(WIFI_STA_SSID, WIFI_STA_PASS)) {
LOG(LL_ERROR, ("Error setting up WiFi station"));
}
#elif defined(WIFI_AP_SSID)
if (!wifi_setup_ap(WIFI_AP_SSID, WIFI_AP_PASS, WIFI_AP_CHAN)) {
LOG(LL_ERROR, ("Error setting up WiFi AP"));
}
#else
#error WiFi not configured
#endif
/* We don't need SimpleLink's web server. */
sl_NetAppStop(SL_NET_APP_HTTP_SERVER_ID);
const char *err = "";
struct mg_bind_opts opts;
memset(&opts, 0, sizeof(opts));
opts.error_string = &err;
struct mg_connection *nc = mg_bind(mgr, "80", mg_ev_handler);
if (nc != NULL) {
mg_set_protocol_http_websocket(nc);
} else {
LOG(LL_ERROR, ("Failed to create listener: %s", err));
}
}
bool TsHttpRpc::init_http()
{
char addr[128] = { 0 };
ex_strformat(addr, 128, "tcp://localhost:%d", TS_HTTP_RPC_PORT);
struct mg_connection* nc = NULL;
nc = mg_bind(&m_mg_mgr, addr, _mg_event_handler);
if (nc == NULL) {
EXLOGE("[rpc] TsHttpRpc::init_http() localhost:%d\n", TS_HTTP_RPC_PORT);
return false;
}
nc->user_data = this;
mg_set_protocol_http_websocket(nc);
return _on_init();
}
static void mg_init(struct mg_mgr *mgr) {
LOG(LL_INFO, ("MG task running"));
stop_nwp(); /* See function description in wifi.c */
int role = sl_Start(0, 0, 0);
if (role < 0) {
LOG(LL_ERROR, ("Failed to start NWP"));
return;
}
LOG(LL_INFO, ("NWP started"));
GPIO_IF_LedToggle(MCU_RED_LED_GPIO);
data_init_sensors(TMP006_ADDR, BM222_ADDR);
sl_fs_init();
#if defined(WIFI_STA_SSID)
if (!wifi_setup_sta(WIFI_STA_SSID, WIFI_STA_PASS)) {
LOG(LL_ERROR, ("Error setting up WiFi station"));
}
#elif defined(WIFI_AP_SSID)
if (!wifi_setup_ap(WIFI_AP_SSID, WIFI_AP_PASS, WIFI_AP_CHAN)) {
LOG(LL_ERROR, ("Error setting up WiFi AP"));
}
#else
#error WiFi not configured
#endif
/* We don't need SimpleLink's web server. */
sl_NetAppStop(SL_NET_APP_HTTP_SERVER_ID);
const char *err = "";
struct mg_bind_opts opts;
memset(&opts, 0, sizeof(opts));
opts.error_string = &err;
struct mg_connection *nc = mg_bind(mgr, "80", mg_ev_handler);
if (nc != NULL) {
mg_set_protocol_http_websocket(nc);
nc->ev_timer_time = mg_time(); /* Start data collection */
} else {
LOG(LL_ERROR, ("Failed to create listener: %s", err));
}
}
int main(int argc, char *argv[]) {
struct mg_mgr mgr;
if (argc != 3) {
fprintf(stderr, "Usage: %s <port> <client|server>\n", argv[0]);
exit(EXIT_FAILURE);
} else if (strcmp(argv[2], "client") == 0) {
sock_t fds[2];
struct mg_connection *ioconn, *server_conn;
mg_mgr_init(&mgr, NULL);
// Connect to the pubsub server
server_conn = mg_connect(&mgr, argv[1], client_handler);
if (server_conn == NULL) {
fprintf(stderr, "Cannot connect to port %s\n", argv[1]);
exit(EXIT_FAILURE);
}
server_conn->flags |= MG_F_USER_2; // Mark this as a client connection
// Create a socketpair and give one end to the thread that reads stdin
mg_socketpair(fds, SOCK_STREAM);
mg_start_thread(stdin_thread, &fds[1]);
// The other end of a pair goes inside the server
ioconn = mg_add_sock(&mgr, fds[0], client_handler);
ioconn->flags |= MG_F_USER_1; // Mark this so we know this is a stdin
ioconn->user_data = server_conn;
} else {
// Server code path
mg_mgr_init(&mgr, NULL);
mg_bind(&mgr, argv[1], server_handler);
printf("Starting pubsub server on port %s\n", argv[1]);
}
for (;;) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return EXIT_SUCCESS;
}
int main(void) {
struct mg_mgr mgr;
struct mg_connection *nc;
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, ev_handler);
// Set up HTTP server parameters
mg_set_protocol_http_websocket(nc);
s_http_server_opts.document_root = "."; // Serve current directory
s_http_server_opts.enable_directory_listing = "yes";
printf("Starting web server on port %s\n", s_http_port);
for (;;) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return 0;
}
static void mg_task(void *arg) {
struct mg_mgr mgr;
struct mg_connection *nc;
printf("SDK version: %s\n", system_get_sdk_version());
setup_ap();
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, MG_LISTEN_ADDR, ev_handler);
if (nc == NULL) {
printf("Error setting up listener!\n");
return;
}
mg_set_protocol_http_websocket(nc);
while (1) {
mg_mgr_poll(&mgr, 1000);
}
}
int main(int argc, char **argv) {
signal(SIGINT, signal_handler);
if (sqlite3_open("tpod.db", &db) != SQLITE_OK) {
printf("failed to open database: %s\n", sqlite3_errmsg(db));
cleanup();
return 1;
}
mpg123_init();
ao_initialize();
if (strcmp("-s", argv[1]) == 0) {
struct mg_mgr mgr;
struct mg_connection *con;
mg_mgr_init(&mgr, NULL);
con = mg_bind(&mgr, "8080", ev_handler);
mg_set_protocol_http_websocket(con);
mg_enable_multithreading(con);
s_http_server_opts.document_root = "./static";
while (srv) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
cleanup();
exit(130);
} else {
mode = 1;
play_stream(argv[1]);
cleanup();
}
return 0;
}
static void mg_task(void *arg) {
struct mg_mgr mgr;
struct mg_connection *nc;
cs_log_set_level(LL_INFO);
LOG(LL_INFO, ("SDK version: %s", system_get_sdk_version()));
setup_ap();
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, MG_LISTEN_ADDR, ev_handler);
if (nc == NULL) {
LOG(LL_ERROR, ("Error setting up listener!"));
return;
}
mg_set_protocol_http_websocket(nc);
while (1) {
mg_mgr_poll(&mgr, 1000);
}
}
