int main(void) {
struct mg_mgr mgr;
struct mg_connection *nc;
struct mg_bind_opts bind_opts;
const char *err;
mg_mgr_init(&mgr, NULL);
memset(&bind_opts, 0, sizeof(bind_opts));
bind_opts.ssl_cert = s_ssl_cert;
bind_opts.ssl_key = s_ssl_key;
bind_opts.error_string = &err;
printf("Starting SSL server on port %s, cert from %s, key from %s\n",
s_http_port, bind_opts.ssl_cert, bind_opts.ssl_key);
nc = mg_bind_opt(&mgr, s_http_port, ev_handler, bind_opts);
if (nc == NULL) {
printf("Failed to create listener: %s\n", err);
return 1;
}
// 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";
for (;;) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return 0;
}
int server_shutdown(struct mg_mgr& mgr)
{
/* Cleanup */
mg_mgr_free(&mgr);
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_);
}
int main(int argc, char *argv[]) {
struct mg_mgr mgr;
int i;
mg_mgr_init(&mgr, NULL);
/* Process command line arguments */
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], s_show_headers_opt) == 0) {
s_show_headers = 1;
} else if (strcmp(argv[i], "--hexdump") == 0 && i + 1 < argc) {
mgr.hexdump_file = argv[++i];
} else {
break;
}
}
if (i + 1 != argc) {
fprintf(stderr, "Usage: %s [%s] [--hexdump <file>] <URL>\n",
argv[0], s_show_headers_opt);
exit(EXIT_FAILURE);
}
mg_connect_http(&mgr, ev_handler, argv[i], NULL, NULL);
while (s_exit_flag == 0) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return 0;
}
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;
}
wxThread::ExitCode SendStatsThread::Entry()
{
std::cout << m_url << std::endl;
struct mg_mgr mgr;
struct mg_connection *nc;
mg_mgr_init(&mgr, this);
std::string user_agent = "User-Agent: " + wxGetOsDescription().ToStdString() + "\r\n";
std::cout << user_agent << std::endl;
nc = mg_connect_http(&mgr, SendStatsThread::ev_handler, m_url.c_str(), user_agent.c_str(), NULL); // GET
if (nc != nullptr)
{
mg_set_protocol_http_websocket(nc);
time_t ts_start = time(NULL);
time_t ts_end = ts_start;
this->m_end = false;
while (!this->m_end)
{
if ((ts_end - ts_start) >= 1) // 1 sec
{
std::cout << "timeout" << std::endl;
break;
}
ts_end = mg_mgr_poll(&mgr, 1000);
}
}
mg_mgr_free(&mgr);
return nullptr;
}
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;
}
int main(int argc, char *argv[])
{
struct ev_loop *loop = EV_DEFAULT;
ev_signal sig_watcher;
struct mg_mgr mgr;
ev_signal_init(&sig_watcher, signal_cb, SIGINT);
ev_signal_start(loop, &sig_watcher);
mg_mgr_init(&mgr, NULL, loop);
/* Process command line arguments */
if (argc != 2) {
fprintf(stderr, "Usage: %s <domain>\n", argv[0]);
exit(0);
}
mg_resolve_async(&mgr, argv[1], MG_DNS_A_RECORD, dns_resolve_cb, argv[1]);
ev_run(loop, 0);
printf("exit...\n");
mg_mgr_free(&mgr);
return 0;
}
int main(int argc, char *argv[]) {
struct mg_mgr mgr;
struct mg_connection *nc;
char *address = s_default_address;
if (argc > 1) {
address = argv[1];
}
printf("Using %s as CoAP server\n", address);
mg_mgr_init(&mgr, 0);
nc = mg_connect(&mgr, address, coap_handler);
if (nc == NULL) {
printf("Unable to connect to %s\n", address);
return -1;
}
mg_set_protocol_coap(nc);
while (!s_time_to_exit) {
mg_mgr_poll(&mgr, 1000000);
}
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);
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;
}
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;
}
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;
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;
}
TestHttpClient::TestHttpClient()
: stop_(false) {
std::atomic_bool is_run(false);
on_text_ = [](struct mg_connection*, const std::string & text) {};
on_binary_ = [](struct mg_connection*, const std::vector<uint8_t> & bytes) {};
on_closed_ = [](struct mg_connection*) {};
mg_mgr_init(&mgr_, this);
boost::mutex mutex;
boost::condition_variable cond;
boost::thread t([&]() {
mutex.lock();
is_run = true;
cond.notify_one();
mutex.unlock();
while(!stop_) {
mg_mgr_poll(&mgr_, 1000);
}
mg_mgr_free(&mgr_);
});
thread_.swap(t);
while (!is_run) {
const boost::chrono::seconds d(1);
boost::mutex::scoped_lock lock(mutex);
cond.wait_for(lock, d);
}
}
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;
}
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;
}
Server::~Server() {
delete m_apiServer;
mg_mgr_free(&m_mgr);
if (m_storage) {
delete m_storage;
}
delete m_storageCfg;
}
// FreeRTOS task to start Mongoose.
static void mongooseTask(void *data) {
struct mg_mgr mgr;
struct mg_connection *connection;
ESP_LOGD(tag, ">> mongooseTask");
g_mongooseStopRequest = 0; // Unset the stop request since we are being asked to start.
mg_mgr_init(&mgr, NULL);
connection = mg_bind(&mgr, ":80", mongoose_event_handler);
if (connection == NULL) {
ESP_LOGE(tag, "No connection from the mg_bind().");
mg_mgr_free(&mgr);
ESP_LOGD(tag, "<< mongooseTask");
vTaskDelete(NULL);
return;
}
mg_set_protocol_http_websocket(connection);
// Keep processing until we are flagged that there is a stop request.
while (!g_mongooseStopRequest) {
mg_mgr_poll(&mgr, 1000);
}
// We have received a stop request, so stop being a web server.
mg_mgr_free(&mgr);
g_mongooseStarted = 0;
// Since we HAVE ended mongoose, time to invoke the callback.
if (g_callback) {
g_callback(1);
}
ESP_LOGD(tag, "<< mongooseTask");
vTaskDelete(NULL);
return;
} // mongooseTask
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);
}
wxThread::ExitCode WebServerThread::Entry()
{
// Get user setting
int webserverPort = Model_Setting::instance().GetIntSetting("WEBSERVERPORT", 8080);
const wxString& strPort = wxString::Format("%d", webserverPort);
// Create and configure the server
struct mg_mgr mgr;
mg_mgr_init(&mgr, NULL);
struct mg_connection* nc = mg_bind(&mgr, strPort.c_str(), ev_handler);
if (nc == nullptr)
{
wxLogDebug(wxString::Format("mg_bind(%s) failed", strPort));
mg_mgr_free(&mgr);
return (wxThread::ExitCode)-1;
}
mg_set_protocol_http_websocket(nc);
std::string document_root(wxFileName(mmex::getReportIndex()).GetPath().c_str());
s_http_server_opts.document_root = document_root.c_str();
s_http_server_opts.enable_directory_listing = "yes";
wxSetWorkingDirectory(wxString(s_http_server_opts.document_root));
// Serve requests
while (IsAlive())
{
mg_mgr_poll(&mgr, 1000);
}
// Cleanup, and free server instance
mg_mgr_free(&mgr);
return nullptr;
}
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(void) {
struct mg_mgr mgr;
struct mg_connection *nc;
mg_mgr_init(&mgr, NULL);
nc = mg_connect_http(&mgr, ev_handler, s_url, NULL, NULL);
mg_set_protocol_http_websocket(nc);
printf("Starting RESTful client against %s\n", s_url);
while (s_exit_flag == 0) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return 0;
}
// 发送一次请求，并回调处理，然后关闭本次连接
void HttpClient::SendReq(const std::string &url, ReqCallback req_callback)
{
// 给回调函数赋值
s_req_callback = req_callback;
mg_mgr mgr;
mg_mgr_init(&mgr, NULL);
auto connection = mg_connect_http(&mgr, OnHttpEvent, url.c_str(), NULL, NULL);
mg_set_protocol_http_websocket(connection);
printf("Send http request %s\n", url.c_str());
// loop
while (s_exit_flag == 0)
mg_mgr_poll(&mgr, 500);
mg_mgr_free(&mgr);
}
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(int argc, char **argv) {
struct mg_mgr mgr;
struct mg_connection *nc;
const char *chat_server_url = argc > 1 ? argv[1] : "ws://127.0.0.1:8000";
mg_mgr_init(&mgr, NULL);
nc = mg_connect_ws(&mgr, ev_handler, chat_server_url, "ws_chat", NULL);
if (nc == NULL) {
fprintf(stderr, "Invalid address\n");
return 1;
}
while (!s_done) {
mg_mgr_poll(&mgr, 100);
}
mg_mgr_free(&mgr);
return 0;
}
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;
}
void imcs_thread() {
{
mg_mgr_init(imcs_mgmgrHandle, NULL);
}
{
imcs_mgconnectionHandle = mg_connect(imcs_mgmgrHandle, imcs_charServer, imcs_handler);
}
{
do {
mg_mgr_poll(imcs_mgmgrHandle, 1000);
} while (pthread_mutex_trylock(&imcs_pthreadmutexRunning) != 0);
pthread_mutex_unlock(&imcs_pthreadmutexRunning);
}
{
mg_mgr_free(imcs_mgmgrHandle);
}
}
int main(void) {
struct mg_mgr mgr;
struct mg_connection *nc;
srand(mg_time());
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 = ".";
mg_register_http_endpoint(nc, "/login.html", login_handler);
mg_register_http_endpoint(nc, "/logout", logout_handler);
mg_set_timer(nc, mg_time() + SESSION_CHECK_INTERVAL);
printf("Starting web server on port %s\n", s_http_port);
for (;;) {
mg_mgr_poll(&mgr, 1000);
}
mg_mgr_free(&mgr);
return 0;
}
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;
}
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);
mg_mgr_init(&mgr, NULL);
nc = mg_bind(&mgr, s_http_port, ev_handler);
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);
return 0;
}
