int main(void) {
struct mg_server *server;
// Create and configure the server
server = mg_create_server(NULL);
mg_set_option(server, "listening_port", "8080");
mg_set_request_handler(server, 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(void) {
struct mg_server *server = mg_create_server(NULL, ev_handler);
time_t current_timer = 0, last_timer = time(NULL);
mg_set_option(server, "listening_port", "8080");
printf("Started on port %s\n", mg_get_option(server, "listening_port"));
for (;;) {
mg_poll_server(server, 100);
current_timer = time(NULL);
if (current_timer - last_timer > 0) {
last_timer = current_timer;
push_message(server, current_timer);
}
}
mg_destroy_server(&server);
return 0;
}
//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);
printf("RTSP Port:%d !!!!!!!!! \n", EasyAdmin_GetRTSPort());
EasyAdmin_SetRTSPort(888);
printf("HTTP Service Port:%d !!!!!!!!! \n", EasyAdmin_GetHTTPServicePort());
EasyAdmin_SetHTTPServicePort(999);
//获取Movies目录
char* moviesFolder = EasyAdmin_GetMoviesFolder();
printf("Movies Folder:%s !!!!!!!!! \n", moviesFolder);
delete moviesFolder;
EasyAdmin_SetMoviesFolder("/etc/streaming/movies/");
//获取日志目录
char* logFolder = EasyAdmin_GetErrorLogFolder();
printf("Log Folder:%s !!!!!!!!! \n", logFolder);
delete logFolder;
EasyAdmin_SetErrorLogFolder("/etc/streaming/Logs/");
//EasyAdmin_Restart();
//run server
for (;;) mg_poll_server((struct mg_server *) mongooseserver, 1000);
mg_destroy_server(&mongooseserver);
}
void msl::webserver_t::open()
{
for(size_t ii=0;ii<thread_count_m;++ii)
{
threads_m.push_back(new server_thread_t(mg_create_server(this,msl::client_thread_func_m)));
if(threads_m[ii]->server==nullptr||!mg_poll_server(threads_m[ii]->server,10))
{
close();
return;
}
}
if(threads_m.size()>0)
{
if(mg_set_option(threads_m[0]->server,"listening_port",address_m.c_str())!=0)
{
close();
return;
}
}
for(size_t ii=1;ii<threads_m.size();++ii)
mg_copy_listeners(threads_m[0]->server,threads_m[ii]->server);
for(size_t ii=0;ii<threads_m.size();++ii)
{
if(mg_set_option(threads_m[ii]->server,"document_root",webroot_m.c_str())!=0)
{
close();
return;
}
}
for(size_t ii=0;ii<threads_m.size();++ii)
{
threads_m[ii]->mutex.lock();
std::thread thread(server_thread_func_m,threads_m[ii]);
thread.detach();
}
}
void web_server(void *param)
{
user_iface_t *ui = (user_iface_t *) param;
struct mg_server *server = ui->server;
const char *err;
u4_t current_timer = 0, last_timer = timer_ms();
while (1) {
mg_poll_server(server, 0); // passing 0 effects a poll
current_timer = timer_ms();
if (time_diff(current_timer, last_timer) > WEB_SERVER_POLL_MS) {
last_timer = current_timer;
mg_iterate_over_connections(server, iterate_callback);
}
NextTaskL("web server");
}
//mg_destroy_server(&server);
}
static const char *test_mg_connect(void) {
char buf2[40] = "", buf3[40] = "", buf4[40] = "";
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);
mg_add_uri_handler(server, "/x", cb4h);
ASSERT(mg_connect(server, "", 0, 0, NULL, NULL) == 0);
ASSERT(mg_connect(server, "127.0.0.1", atoi(HTTP_PORT), 0, cb2, buf2) == 1);
ASSERT(mg_connect(server, "127.0.0.1", 29, 0, cb3, buf3) == 1);
ASSERT(mg_connect(server, "127.0.0.1", atoi(HTTP_PORT), 0, cb4, buf4) == 1);
{ int i; for (i = 0; i < 50; i++) mg_poll_server(server, 0); }
ASSERT(strcmp(buf2, "add") == 0);
ASSERT(strcmp(buf3, "1") == 0);
ASSERT(strcmp(buf4, "500 Server Error\nPOST size > 999") == 0);
mg_destroy_server(&server);
return NULL;
}
/* ::cortex::web::SockJsServer::poll() */
cx_void web_SockJsServer_poll(web_SockJsServer _this) {
/* $begin(::cortex::web::SockJsServer::poll) */
struct mg_server *server = (struct mg_server *)_this->server;
mg_poll_server(server, _this->pollTimemoutMillis);
_this->timeElapsed += _this->pollTimemoutMillis;
/* Send heartbeats for all live connections every n seconds */
if (_this->timeElapsed >= (WEB_SOCKJSSERVER_DEFAULT_HEARTBEAT_TIMEOUT * 1000)) {
cx_ll scope = cx_scopeClaim(_this);
cx_iter iter = cx_llIter(scope);
while (cx_iterHasNext(&iter)) {
cx_object o = cx_iterNext(&iter);
if (cx_instanceof(cx_type(web_SockJsServer_Connection_o), o)) {
web_SockJsServer_Connection c = web_SockJsServer_Connection(o);
mg_websocket_printf((struct mg_connection *)c->conn, WEBSOCKET_OPCODE_TEXT, "h");
}
}
cx_scopeRelease(scope);
_this->timeElapsed = 0;
}
/* $end */
}
static const char *test_server(void) {
char buf1[100] = "", buf2[100] = "";
struct mg_server *server = mg_create_server((void *) "foo");
ASSERT(server != NULL);
ASSERT(mg_set_option(server, "listening_port", LISTENING_ADDR) == NULL);
ASSERT(mg_set_option(server, "document_root", ".") == NULL);
mg_add_uri_handler(server, "/cb1", cb1);
mg_set_http_error_handler(server, error_handler);
ASSERT(mg_connect(server, "127.0.0.1", atoi(HTTP_PORT), 0, ts1, buf1) == 1);
ASSERT(mg_connect(server, "127.0.0.1", atoi(HTTP_PORT), 0, ts2, buf2) == 1);
{ int i; for (i = 0; i < 50; i++) mg_poll_server(server, 0); }
ASSERT(strcmp(buf1, "foo ? 127.0.0.1") == 0);
ASSERT(strcmp(buf2, "404 ERR: 404") == 0);
ASSERT(strcmp(static_config_options[URL_REWRITES * 2], "url_rewrites") == 0);
mg_destroy_server(&server);
ASSERT(server == NULL);
return NULL;
}
int main(int argc, char *argv[]) {
char* port = "2000";
struct mg_server *server = mg_create_server(NULL, NULL);
if (argc > 1) port = argv[1];
printf("\nHttp server listening on port %s\n", port);
mg_set_option(server, "document_root", "."); // Serve current directory
mg_set_option(server, "listening_port", port);
for (;;) {
mg_poll_server(server, 1000); // Infinite loop, Ctrl-C to stop
if (mg_get_listening_socket(server) == -1) { // unable to connect
_sleep(500);
}
}
mg_destroy_server(&server);
return 0;
}
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_server *server = mg_create_server(nullptr, ev_handler);
mg_set_option(server, "listening_port", strPort.mb_str());
mg_set_option(server, "document_root", wxFileName(mmex::getReportIndex()).GetPath().mb_str());
wxSetWorkingDirectory(mg_get_option(server, "document_root"));
// Serve requests
while (IsAlive())
{
mg_poll_server(server, 1000);
}
// Cleanup, and free server instance
mg_destroy_server(&server);
return (wxThread::ExitCode)0;
}
static const char *test_server(void) {
char buf1[100] = "1", buf2[100] = "2";
struct mg_server *server = mg_create_server((void *) "foo", evh1);
struct mg_connection *conn;
ASSERT(server != NULL);
ASSERT(mg_set_option(server, "listening_port", LISTENING_ADDR) == NULL);
ASSERT(mg_set_option(server, "document_root", ".") == NULL);
ASSERT((conn = mg_connect(server, "127.0.0.1", atoi(HTTP_PORT), 0)) != NULL);
conn->connection_param = buf1;
ASSERT((conn = mg_connect(server, "127.0.0.1", atoi(HTTP_PORT), 0)) != NULL);
conn->connection_param = buf2;
{ int i; for (i = 0; i < 50; i++) mg_poll_server(server, 1); }
ASSERT(strcmp(buf1, "1foo ? 127.0.0.1") == 0);
ASSERT(strcmp(buf2, "2ERR: 404") == 0);
ASSERT(strcmp(static_config_options[URL_REWRITES * 2], "url_rewrites") == 0);
mg_destroy_server(&server);
ASSERT(server == NULL);
return NULL;
}
void initialize_server(void){
char tmpBuf[100];
server = mg_create_server(NULL);
mg_set_option(server, "listening_port", globalOptions.port);
mg_set_option(server, "run_as_user", "root");
#ifdef DEBUG
mg_set_option(server, "document_root", "public");
#endif
mg_set_request_handler(server, request_handler);
sprintf(
tmpBuf,
"Initialized web server at port %s",
mg_get_option(server, "listening_port")
);
log_line(tmpBuf, LOG_INFO);
for(;;)
mg_poll_server(server, 1000);
}
void ouroboros_server::run()
{
mg_poll_server(mpServer, 1000);
}
void web_engine::serve()
{
if (m_http) mg_poll_server(m_server, 0);
}
void CommManager::HttpPollThread(LPVOID lpParameter)
{
mg_server* server = (mg_server*)lpParameter;
for (;;) mg_poll_server(server, 1000);
};
static void *serve(void *server) {
for (;;) mg_poll_server((struct mg_server *) server, 1000);
return NULL;
}
/* ---------------------------------------------------------------------------
** main
** -------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
int verbose=0;
const char *dev_name = "/dev/video0";
int width = 320;
int height = 240;
int fps = 10;
int c = 0;
const char * port = "8080";
V4l2DeviceFactory::IoType ioTypeIn = V4l2DeviceFactory::IOTYPE_MMAP;
std::string webroot = "webroot";
while ((c = getopt (argc, argv, "hv::" "W:H:F:r" "P:p:")) != -1)
{
switch (c)
{
case 'v': verbose = 1; if (optarg && *optarg=='v') verbose++; break;
case 'W': width = atoi(optarg); break;
case 'H': height = atoi(optarg); break;
case 'F': fps = atoi(optarg); break;
case 'r': ioTypeIn = V4l2DeviceFactory::IOTYPE_READWRITE; break;
case 'P': port = optarg; break;
case 'p': webroot = optarg; break;
case 'h':
{
std::cout << argv[0] << " [-v[v]] [-P port] [-W width] [-H height] [device]" << std::endl;
std::cout << "\t -v : verbose " << std::endl;
std::cout << "\t -v v : very verbose " << std::endl;
std::cout << "\t -P port : server port (default "<< port << ")" << std::endl;
std::cout << "\t -p path : server root path (default "<< webroot << ")" << std::endl;
std::cout << "\t -W width : V4L2 capture width (default "<< width << ")" << std::endl;
std::cout << "\t -H height: V4L2 capture height (default "<< height << ")" << std::endl;
std::cout << "\t -F fps : V4L2 capture framerate (default "<< fps << ")" << std::endl;
std::cout << "\t -r : V4L2 capture using memory mapped buffers (default use read interface)" << std::endl;
std::cout << "\t device : V4L2 capture device (default "<< dev_name << ")" << std::endl;
exit(0);
}
}
}
if (optind<argc)
{
dev_name = argv[optind];
}
// initialize log4cpp
initLogger(verbose);
// init V4L2 capture interface
int format = V4L2_PIX_FMT_JPEG;
V4L2DeviceParameters param(dev_name,format,width,height,fps,verbose);
V4l2Capture* videoCapture = V4l2DeviceFactory::CreateVideoCapture(param, ioTypeIn);
if (videoCapture == NULL)
{
LOG(WARN) << "Cannot create JPEG capture for device:" << dev_name << " => try YUYV capture";
param.m_format = V4L2_PIX_FMT_YUYV;
videoCapture = V4l2DeviceFactory::CreateVideoCapture(param, ioTypeIn);
}
if (videoCapture == NULL)
{
LOG(WARN) << "Cannot create YUYV capture for device:" << dev_name << " => keep current format";
param.m_format = 0;
videoCapture = V4l2DeviceFactory::CreateVideoCapture(param, ioTypeIn);
}
if (videoCapture == NULL)
{
LOG(WARN) << "Cannot create V4L2 capture interface for device:" << dev_name;
}
else
{
struct mg_server *server = mg_create_server(videoCapture, ev_handler);
const char* error = mg_set_option(server, "listening_port", port);
if (error != NULL)
{
LOG(WARN) << "Cannot listen on port:" << port << " " << error;
}
else
{
std::string currentPath(get_current_dir_name());
currentPath += "/";
currentPath += webroot;
mg_set_option(server, "document_root", currentPath.c_str());
chdir(mg_get_option(server, "document_root"));
LOG(NOTICE) << "Started on port:" << mg_get_option(server, "listening_port") << " webroot:" << mg_get_option(server, "document_root");
for (;;)
{
mg_poll_server(server, 10);
v4l2processing(server, videoCapture, width, height);
}
}
mg_destroy_server(&server);
delete videoCapture;
}
return 0;
}
int main(int argc, char **argv)
{
int n, option_index = 0;
struct mg_server *server = mg_create_server(NULL);
unsigned int current_timer = 0, last_timer = 0;
char *run_as_user = NULL;
char radio_song_name[512];
const char *radio_path = NULL;
char *radio_url = NULL;
char radio_added_song[512];
config_t cfg;
config_setting_t *settings;
char config_file_name[512];
struct passwd *pw = getpwuid(getuid());
char *homedir = pw->pw_dir;
sprintf(config_file_name, "%s/%s/%s", homedir, project_name, ympd_conf_file);
printf("conf = %s\n", config_file_name);
atexit(bye);
mg_set_option(server, "listening_port", "8080");
mpd.port = 6600;
strcpy(mpd.host, "127.0.0.1");
config_init(&cfg);
if(! config_read_file(&cfg, config_file_name))
{
printf("config file error %s:%d - %s\n", config_error_file(&cfg),
config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return(EXIT_FAILURE);
}
if (!config_lookup_string(&cfg, "application.radio_path", &radio_path))
{
fprintf(stderr, "No 'radio_path' setting in configuration file.\n");
}
/* drop privilges at last to ensure proper port binding */
if(run_as_user != NULL)
{
mg_set_option(server, "run_as_user", run_as_user);
free(run_as_user);
}
if (!config_lookup_string(&cfg, "streamripper.url", &radio_url))
{
fprintf(stderr, "No 'radio_url' setting in configuration file.\n");
}
printf("url = %s\n", radio_url);
start_streamripper();
printf("start_streamripper\n");
/* init_watch_radio();
printf("init_watch_radio\n");
add_watch_radio(radio_path);
printf("add_watch_radio\n");*/
mg_set_http_close_handler(server, mpd_close_handler);
mg_set_request_handler(server, server_callback);
while (!force_exit) {
current_timer = mg_poll_server(server, 200);
if(current_timer - last_timer)
{
last_timer = current_timer;
mpd_poll(server);
/* if (radio_poll(radio_song_name))
{
sprintf(radio_added_song, "%s%s", "radio/", radio_song_name);
printf("%s\n", radio_added_song);
mpd_run_update(mpd.conn, radio_added_song);
sleep(1);
mpd_run_add(mpd.conn, radio_added_song);
}*/
}
}
stop_streamripper();
close_watch_radio();
mpd_disconnect();
mg_destroy_server(&server);
config_destroy(&cfg);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
printf("====================== mSquared File Transfer Program ======================\n\n");
printf("Developed by: Mrinal Dhar 201325118 | Mounika Somisetty 201330076\n");
printf("Enter 'help' to get help about commands and other cool stuff this program can do.\n\n");
printf("============================================================================\n\n");
int serv_pid = 0;
int udpServ_pid = 0;
int i;
char cmd[1024];
char *vals[49];
WEB_PORT = strdup("8000");
if(argc == 2)
{
bzero(IP,sizeof(IP));
strcpy(IP,argv[1]);
}
else {
strcpy(IP, "127.0.0.1");
}
serv_pid = fork();
if (serv_pid == 0) {
listenSocket = socket(AF_INET,SOCK_STREAM,0);
if(listenSocket<0)
{
// printf("ERROR WHILE CREATING A SOCKET\n");
}
else {}
// printf("[SERVER] SOCKET ESTABLISHED SUCCESSFULLY\n\n");
initServer();
close(listenSocket);
}
serv_pid = fork();
if (serv_pid == 0) {
struct mg_server *server;
// Create and configure the server
server = mg_create_server(NULL, ev_handler);
mg_set_option(server, "listening_port", WEB_PORT);
// Serve request.
// printf("Web Server 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);
}
periodicCheck();
char filename[50];
char chat_msg[50];
char * returncode;
while (1) {
printf("$> ");
scanf("%[^\n]s", cmd);
// printf("THIS: %s\n", cmd);
getchar();
if (cmd[0]=='-') {
bzero(chat_msg, 50);
cpy(filename+1, cmd+1);
filename[0] = 'c';
// printf("THIS=%s", filename);
sendMsg(filename, 0);
}
else {
parse(cmd, vals);
if(!strcmp(vals[0], "FileDownload")) {
if (!strcmp(vals[1], "TCP")) {
bzero(filename, 50);
cpy(filename+2, vals[2]);
filename[0] = 'd';
filename[1] = 't';
if(!initCDTCP(filename))
break;
}
else if (!strcmp(vals[1], "UDP")) {
bzero(filename, 50);
cpy(filename+2, vals[2]);
filename[0] = 'd';
filename[1] = 'u';
// sleep(5);
if (!initUDPClient(filename+2, IP))
break;
sendMsg(filename, 0);
bzero(filename, 50);
}
}
else if (!strcmp(vals[0], "FileUpload")) {
if (!strcmp(vals[1], "TCP")) {
// printf("DOING!!\n\n");
bzero(filename, 50);
cpy(filename+2, vals[2]);
filename[0] = 'u';
filename[1] = 't';
sendMsg(filename, 0);
bzero(filename, 50);
}
else if (!strcmp(vals[1], "UDP")) {
bzero(filename, 50);
cpy(filename+2, vals[2]);
filename[0] = 'u';
filename[1] = 'u';
returncode = sendMsg(filename, 1);
// printf("GOT RCODE %s\n\n", returncode);
if (returncode[0]=='y')
{
printf("Permission granted!\n");
sleep(2);
initUDPServer(filename+2, IP);
}
bzero(filename, 50);
}
}
else if(!strcmp(vals[0], "exit")) {
close(listenSocket);
system("killall -s 9 server");
exit(0);
}
else if(!strcmp(vals[0], "FileHash")) {
if (!strcmp(vals[1], "--verify")) {
strcpy(filename, "hv");
strcat(filename, vals[2]);
sendMsg(filename, 0);
}
else if (!strcmp(vals[1], "--checkall")) {
strcpy(filename, "hc");
sendMsg(filename, 0);
}
bzero(filename, 50);
filename[0] = 'd';
filename[1] = 't';
strcpy(filename+2, "fileHashOutput.txt");
initCDTCP(filename);
}
else if(!strcmp(vals[0], "gui")) {
// THE FOLLOWING CODE TRIES TO AUTOMATICALLY OPEN FIREFOX WHEN GUI IS ACTIVATED. This has some bugs.
// char * ffox[1];
// ffox[0] = strdup("firefox ");
// strcat(ffox[0], IP);
// strcat(ffox[0], ":");
// strcat(ffox[0], WEB_PORT);
// serv_pid = fork();
// if (serv_pid==0) {
// if (execvp(ffox[0], ffox) < 0) {
// printf("*** ERROR: exec failed\n");
// exit(1);
// }
// }
}
else if (!strcmp(vals[0], "help")) {
FILE *fp = fopen("readme.txt", "rb");
while (fread(buffer, sizeof(char), 1024, fp))
{
printf("%s", buffer);
bzero(buffer,1024);
}
}
else if(!strcmp(vals[0], "IndexGet")) { /* I need indexget to work on both the remote machine and the local machine
and give output in four files: index-they.txt index-me.txt index-they-gui.txt index-me-gui.txt */
// handleIndex(1,0);
if (!strcmp(vals[1], "--shortlist")) {
strcpy(filename, "is");
sendMsg(filename, 0);
handleIndex(0,0,"\0", 0, 0);
}
else if (!strcmp(vals[1], "--longlist")) {
strcpy(filename, "il");
sendMsg(filename, 0);
handleIndex(1,0,"\0", 0, 0);
}
else if (!strcmp(vals[1], "--regex")) {
strcpy(filename, "ir");
strcat(filename, vals[2]);
sendMsg(filename, 0);
// handleIndex(1,1,vals[2], 0, 0);
}
bzero(filename, 50);
filename[0] = 'd';
filename[1] = 't';
strcpy(filename+2, "index.txt");
initCDTCP(filename);
}
continue;
}
}
printf("\nClosing connection2\n");
return 0;
}
int main(int argc, char *argv[])
{
bool gui = false;
QApplication app(argc, argv, gui);
QProxyStyle * style = new QProxyStyle();
app.setStyle(style);
struct statsd_info
{
statsd_info() : host("127.0.0.1"), port(8125), ns(std::string(ICHABOD_NAME)+"."), enabled(false) {}
std::string host;
int port;
std::string ns;
bool enabled;
};
statsd_info statsd;
int port = 9090;
QStringList args = app.arguments();
QRegExp rxPort("--port=([0-9]{1,})");
QRegExp rxVerbose("--verbosity=([0-9]{1,})");
QRegExp rxEngineVerbose("--engine-verbosity=([0-9]{1,})");
QRegExp rxConvertVerbose("--convert-verbosity=([0-9]{1,})");
QRegExp rxSlowResponseMs("--slow-response-ms=([0-9]{1,})");
QRegExp rxQuantize("--quantize=([a-zA-Z]{1,})");
QRegExp rxVersion("--version");
QRegExp rxShortVersion("-v$");
QRegExp rxStatsdHost("--statsd-host=([^ ]+)");
QRegExp rxStatsdPort("--statsd-port=([0-9]{1,})");
QRegExp rxStatsdNs("--statsd-ns=([^ ]+)");
for (int i = 1; i < args.size(); ++i) {
if (rxPort.indexIn(args.at(i)) != -1 )
{
port = rxPort.cap(1).toInt();
}
else if (rxVerbose.indexIn(args.at(i)) != -1 )
{
g_verbosity = rxVerbose.cap(1).toInt();
}
else if (rxEngineVerbose.indexIn(args.at(i)) != -1 )
{
g_engine_verbosity = rxEngineVerbose.cap(1).toInt();
}
else if (rxConvertVerbose.indexIn(args.at(i)) != -1 )
{
g_convert_verbosity = rxConvertVerbose.cap(1).toInt();
}
else if (rxSlowResponseMs.indexIn(args.at(i)) != -1 )
{
g_slow_response_ms = rxSlowResponseMs.cap(1).toInt();
}
else if (rxQuantize.indexIn(args.at(i)) != -1 )
{
g_quantize = rxQuantize.cap(1);
}
else if (rxVersion.indexIn(args.at(i)) != -1 )
{
std::cout << ICHABOD_NAME << " version " << ICHABOD_VERSION << std::endl;
std::cout << "** The GIFLIB distribution is Copyright (c) 1997 Eric S. Raymond" << std::endl;
std::cout << "** ppmquant is Copyright (C) 1989, 1991 by Jef Poskanzer." << std::endl;
std::cout << "** statsd-client-cpp is Copyright (c) 2014, Rex" << std::endl;
std::cout << "**" << std::endl;
std::cout << "** Permission to use, copy, modify, and distribute this software and its" << std::endl;
std::cout << "** documentation for any purpose and without fee is hereby granted, provided" << std::endl;
std::cout << "** that the above copyright notice appear in all copies and that both that" << std::endl;
std::cout << "** copyright notice and this permission notice appear in supporting" << std::endl;
std::cout << "** documentation. This software is provided \"as is\" without express or" << std::endl;
std::cout << "** implied warranty." << std::endl;
std::cout << "**" << std::endl;
ppm_init( &argc, argv );
return 0;
}
else if (rxShortVersion.indexIn(args.at(i)) != -1)
{
std::cout << ICHABOD_VERSION << std::endl;
return 0;
}
else if (rxStatsdHost.indexIn(args.at(i)) != -1)
{
statsd.host = rxStatsdHost.cap(1).toLocal8Bit().constData();
statsd.enabled = true;
}
else if (rxStatsdPort.indexIn(args.at(i)) != -1)
{
statsd.port = rxStatsdPort.cap(1).toInt();
statsd.enabled = true;
}
else if (rxStatsdNs.indexIn(args.at(i)) != -1)
{
statsd.ns = rxStatsdNs.cap(1).toLocal8Bit().constData();
if ( statsd.ns.length() && *statsd.ns.rbegin() != '.' )
{
statsd.ns += ".";
}
statsd.enabled = true;
}
else
{
std::cerr << "Unknown arg:" << args.at(i).toLocal8Bit().constData() << std::endl;
return -1;
}
}
ppm_init( &argc, argv );
struct mg_server *server = mg_create_server(NULL, ev_handler);
const char * err = mg_set_option(server, "listening_port", QString::number(port).toLocal8Bit().constData());
if ( err )
{
std::cerr << "Cannot bind to port:" << port << " [" << err << "], exiting." << std::endl;
return -1;
}
std::cout << ICHABOD_NAME << " " << ICHABOD_VERSION
<< " (port:" << mg_get_option(server, "listening_port")
<< " verbosity:" << g_verbosity
<< " engine verbosity:" << g_engine_verbosity
<< " convert verbosity:" << g_convert_verbosity
<< " slow-response:" << g_slow_response_ms << "ms";
if ( statsd.enabled )
{
std::cout << " statsd:" << statsd.host << ":" << statsd.port << "[" << statsd.ns << "]";
g_statsd.config(statsd.host, statsd.port, statsd.ns);
}
std::cout << ")" << std::endl;
for (;;)
{
mg_poll_server(server, 1000);
}
mg_destroy_server(&server);
return 0;
}
int main(int argc, char **argv)
{
int n, option_index = 0;
struct mg_server *server = mg_create_server(NULL, server_callback);
unsigned int current_timer = 0, last_timer = 0;
char *run_as_user = NULL;
char const *error_msg = NULL;
char *webport = "8080";
atexit(bye);
#ifdef WITH_DYNAMIC_ASSETS
mg_set_option(server, "document_root", SRC_PATH);
#endif
mpd.port = 6600;
strcpy(mpd.host, "127.0.0.1");
static struct option long_options[] = {
{"host", required_argument, 0, 'h'},
{"port", required_argument, 0, 'p'},
{"webport", required_argument, 0, 'w'},
{"dirbletoken", required_argument, 0, 'd'},
{"user", required_argument, 0, 'u'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 0 },
{"mpdpass", required_argument, 0, 'm'},
{0, 0, 0, 0 }
};
while((n = getopt_long(argc, argv, "h:p:w:u:vm:",
long_options, &option_index)) != -1) {
switch (n) {
case 'h':
strncpy(mpd.host, optarg, sizeof(mpd.host));
break;
case 'p':
mpd.port = atoi(optarg);
break;
case 'w':
webport = strdup(optarg);
break;
case 'd':
strncpy(dirble_api_token, optarg, sizeof(dirble_api_token));
break;
case 'u':
run_as_user = strdup(optarg);
break;
case 'm':
if (strlen(optarg) > 0)
mpd.password = strdup(optarg);
break;
case 'v':
fprintf(stdout, "ympd %d.%d.%d\n"
"Copyright (C) 2014 Andrew Karpow <*****@*****.**>\n"
"built " __DATE__ " "__TIME__ " ("__VERSION__")\n",
YMPD_VERSION_MAJOR, YMPD_VERSION_MINOR, YMPD_VERSION_PATCH);
return EXIT_SUCCESS;
break;
default:
fprintf(stderr, "Usage: %s [OPTION]...\n\n"
" -h, --host <host>\t\tconnect to mpd at host [localhost]\n"
" -p, --port <port>\t\tconnect to mpd at port [6600]\n"
" -w, --webport [ip:]<port>\tlisten interface/port for webserver [8080]\n"
" -u, --user <username>\t\tdrop priviliges to user after socket bind\n"
" -d, --dirbletoken <apitoken>\tDirble API token\n"
" -V, --version\t\t\tget version\n"
" -m, --mpdpass <password>\tspecifies the password to use when connecting to mpd\n"
" --help\t\t\t\tthis help\n"
, argv[0]);
return EXIT_FAILURE;
}
if(error_msg)
{
fprintf(stderr, "Mongoose error: %s\n", error_msg);
return EXIT_FAILURE;
}
}
error_msg = mg_set_option(server, "listening_port", webport);
if(error_msg) {
fprintf(stderr, "Mongoose error: %s\n", error_msg);
return EXIT_FAILURE;
}
/* drop privilges at last to ensure proper port binding */
if(run_as_user != NULL) {
error_msg = mg_set_option(server, "run_as_user", run_as_user);
free(run_as_user);
if(error_msg)
{
fprintf(stderr, "Mongoose error: %s\n", error_msg);
return EXIT_FAILURE;
}
}
while (!force_exit) {
mg_poll_server(server, 200);
current_timer = time(NULL);
if(current_timer - last_timer)
{
last_timer = current_timer;
mpd_poll(server);
}
}
mpd_disconnect();
mg_destroy_server(&server);
return EXIT_SUCCESS;
}
int main(int argc, char** argv) {
struct mg_server *server;
char buf[100];
char cert[100];
const char* pidFile = "/var/run/checkip.pid";
char port[140];
char* user = "******";
int jail_mode = FALSE;
int c;
int fd = -1;
// init variables
pid_t process_id = 0;
pid_t sid = 0;
daemon_mode = FALSE;
letsencrypt_req[0] = '\0';
letsencrypt_resp[0] = '\0';
strncpy(cert, "checkip-cert.pem", sizeof cert);
initValidIP();
jailDir[0] = '\0';
// Get the start time
time(&start);
// Parse command line for "-h -p nnn -c /path/to/file"
while((c = getopt(argc, argv, "dhj:p:u:r:R:c:")) != -1)
{
switch(c)
{
case 'c': strncpy(cert, optarg, sizeof cert);
break;
case 'd': daemon_mode = TRUE;
break;
case 'j': jail_mode = TRUE;
char* temp_dir = optarg;
if (!dir_exists(temp_dir)) {
printf("Jail root dir '%s' does not exist, or is not a directory\n", jailDir);
return -1;
}
strncpy(jailDir, realpath(temp_dir, NULL), sizeof jailDir);
break;
case 'r': strcpy(letsencrypt_req, optarg);
break;
case 'R': strcpy(letsencrypt_resp, optarg);
break;
case 'p': strcpy(port, optarg);
break;
case 'u': user = optarg;
if (!user_exists(user)) {
printf("User '%s' does not exist\n", user);
return -1;
}
break;
case 'h': usage();
return -1;
break;
case '?': printf("Invalid option '%c'\n", optopt);
usage();
return -1;
break;
default: printf("Getopt error\n");
return -100;
}
}
if (jail_mode && !daemon_mode) {
printf("-j (chroot jail) requires -d (daemon) by specified\n");
return -1;
}
strcpy(ipAddr, getIPaddr());
strcpy(port, "80,ssl://0.0.0.0:443:");
strncat(port, cert, (sizeof port)-strlen(port)-1);
// Open the log
if (daemon_mode)
openlog(NULL, LOG_CONS | LOG_PID, LOG_DAEMON);
// lock the pid file
fd = createPidFile(argv[0], pidFile, 0);
// If a daemon, fork a child process and exit the parent
if (daemon_mode) {
// 1. create a child process
process_id = fork();
if (process_id < 0) {
log_msg(daemon_mode, "fork() failed! - exiting");
exit(-1);
}
// 2. kill the parent process
if (process_id > 0)
exit(0);
// 3. unmask the file mode
umask(0);
// 4. start a new session
sid = setsid();
if (sid < 0) {
log_msg(daemon_mode, "setsid() failed! - exiting");
exit(-1);
}
// 5. redirect stdin, stdout and stderr to null
redir2null(stdin, O_RDONLY);
redir2null(stdout, O_WRONLY);
redir2null(stderr, O_RDWR); // Note stderr must be r/w
// 6. Update the PID file with the child PID
updateChildPid(fd, (long) getpid());
}
// Create and configure the server
log_msg(daemon_mode, "CheckIP version %s starting", VERSION);
printTZ();
log_msg(daemon_mode, "Using SSL certificate '%s'", cert);
server = mg_create_server(NULL, ev_handler);
mg_set_option(server, "listening_port", port);
strcpy(buf, mg_get_option(server, "listening_port"));
if (buf[0] == '\0') {
log_msg(daemon_mode, "open listening ports failed - exiting");
goto exit;
}
// chroot jail the process
if (jail_mode && !isChrooted()) {
// adjust the path
putenv("PATH=/bin:/sbin");
// set the new root dir
int err = chroot(jailDir);
if (err != 0) {
log_msg(daemon_mode, "chroot() failed! (err %d) - exiting", errno);
exit(-1);
}
log_msg(daemon_mode, "Established chroot() jail under '%s'", jailDir);
// Set the curr dir to be within the chroot
chdir("/");
}
// Trap KILL's - cause 'running' flag to be set false, HUP dumps the stats
running = -1;
signal(SIGINT, intHandler);
signal(SIGTERM, intHandler);
signal(SIGHUP, intHandler);
// load robots.txt to robots variable
loadRobots(jailDir);
// load sitemap.xml to robots variable
loadSitemap(jailDir);
// load the GeoIP database
initGeoIP();
// Log LetsEncrypt settings
if (letsencrypt_req[0] != '\0')
log_msg(daemon_mode, "LE req = '%s'\n", letsencrypt_req);
if (letsencrypt_resp[0] != '\0')
log_msg(daemon_mode, "LE resp = '%s'\n", letsencrypt_resp);
// Serve request. Hit Ctrl-C or SIGTERM to terminate the program
mg_set_option(server, "run_as_user", user);
if (user != NULL)
log_msg(daemon_mode, "Server executing as user '%s'", user);
log_msg(daemon_mode, "Listening on port %s", buf);
while (running) {
mg_poll_server(server, 250);
}
if(!daemon_mode) printf("\n");
// Get the finish time and compute the duration
exit:
time(&finish);
// Cleanup, and free server instance
mg_destroy_server(&server);
// Close and delete the pid file;
if (fd != -1) {
close(fd);
unlink(pidFile);
}
// Print stats
print_stats(daemon_mode, start, finish, "stopping after");
// Clean up GeoIP2
closeGeoIP();
if (!daemon_mode) printf("\nClean shutdown\n");
return 0;
}
void RestServer::start(){
printf("Starting on port %s\n", mg_get_option(this->server, "listening_port"));
for (;;)
mg_poll_server(server, 1000);
}
static int mg_poll(lua_State *L)
{
struct mg_context *ctx = luaL_checkudata(L, 1, MONGOOSE_LUA);
mg_poll_server(ctx->server, 10);
return MG_FALSE;
}
