int
main(int argc, char** argv)
{
int sock;
slash_context_t* ctx;
#ifdef USE_PTHREADS
pthread_t thread;
pthread_attr_t thread_attr;
pthread_attr_init(&thread_attr);
pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
#endif
parse_opts(argc, argv);
FCGX_Init();
sl_static_init();
if(DAEMONIZE) {
daemonize();
}
sock = FCGX_OpenSocket(LISTEN, BACKLOG);
while(1) {
ctx = malloc(sizeof(slash_context_t));
FCGX_InitRequest(&ctx->request, sock, 0);
if(FCGX_Accept_r(&ctx->request) != 0) {
exit(1);
}
#ifdef USE_PTHREADS
pthread_create(&thread, &thread_attr, handle_request_thread_start, ctx);
#else
handle_request_thread_start(ctx);
#endif
}
}
void Rok4Server::initFCGI() {
int init=FCGX_Init();
if ( !socket.empty() ) {
LOGGER_INFO ( _ ( "Listening on " ) << socket );
sock = FCGX_OpenSocket ( socket.c_str(), backlog );
}
}
fcgi_api::fcgi_api(char const *socket,int backlog)
{
pthread_once(&init_fcgi,fcgi_api::init);
if(socket && socket[0]!='\0') {
fd=FCGX_OpenSocket(socket,backlog);
}
else {
fd=0; // STDIN
}
if(fd<0) {
throw cppcms_error(errno,"FCGX_OpenSocket");
}
}
int main(int argc, char **argv)
{
sc::SoundCloud::sharedInstance()->init(kInitFile);
FCGX_Init();
int socket = FCGX_OpenSocket(":2026", kMaxThreads);
std::thread threads[kMaxThreads];
for (int i = 0; i < kMaxThreads; ++i)
{
threads[i] = std::thread(ProcessFCGI, socket);
}
while (true)
{
Player::sharedInstance()->update(60);
sleep(60);
}
}
int main(void)
{
char *user, *password;
user = getenv("USER");
if (user == NULL) {
user = "******";
}
password = getenv("PASSWORD");
if (password == NULL) {
password = "******";
}
FCGX_Init();
FCGX_OpenSocket(":9000", 500);
while (FCGI_Accept() >= 0) {
char *remoteUser, *remotePassword;
remoteUser = getenv("REMOTE_USER");
remotePassword = getenv("REMOTE_PASSWD");
if ((remoteUser == NULL) || (remotePassword == NULL)
|| strcmp(remoteUser, user) || strcmp(remotePassword, password))
{
printf("Status: 401 Unauthorized\r\n"
"WWW-Authenticate: Basic realm=\"Test\"\r\n"
"\r\n");
}
else {
char *processId = getenv("QUERY_STRING");
if (processId == NULL || strlen(processId) == 0) {
processId = "0";
}
printf("Status: 200 OK\r\n"
"Variable-AUTH_TYPE: Basic\r\n"
"Variable-REMOTE_PASSWD:\r\n"
"Variable-PROCESS_ID: %s\r\n"
"\r\n", processId);
}
}
return 0;
}
int main(void)
{
FCGX_Init();
int socket = FCGX_OpenSocket(SOCKET_PATH, 0);
char* remote_addr;
FCGX_Request request;
if (FCGX_InitRequest(&request, socket, 0) != 0)
return 1;
while (1) {
FCGX_Accept_r(&request);
remote_addr = FCGX_GetParam("REMOTE_ADDR", request.envp);
FCGX_PutS("Content-type: text/plain\n\n", request.out);
FCGX_PutS(remote_addr, request.out);
FCGX_PutS("\n", request.out);
FCGX_Finish_r(&request);
}
}
CgiService::CgiService()
{
bcore = new BaseCore();
FCGX_Init();
mode_t old_mode = umask(0);
socketId = FCGX_OpenSocket(config->server_socket_path_.c_str(), config->server_children_);
if(socketId < 0)
{
Log::err("Error open socket. exit");
exit(1);
}
umask(old_mode);
pthread_attr_t* attributes = (pthread_attr_t*) malloc(sizeof(pthread_attr_t));
pthread_attr_init(attributes);
pthread_attr_setstacksize(attributes, THREAD_STACK_SIZE);
struct sigaction actions;
memset(&actions, 0, sizeof(actions));
actions.sa_flags = 0;
actions.sa_handler = SignalHandler;
sigaction(SIGHUP,&actions,NULL);
sigaction(SIGPIPE,&actions,NULL);
threads = new pthread_t[config->server_children_ + 1];
for(int i = 0; i < config->server_children_; i++)
{
if(pthread_create(&threads[i], attributes, &this->Serve, this))
{
Log::err("creating thread failed");
}
}
pthread_attr_destroy(attributes);
}
int System::run(const StringList& args)
{
if (_running)
return 1;
_running = true;
#ifdef DEBUG
_debug = true;
#else
_debug = false;
#endif
//if (_debug)
// signal(SIGSEGV, &segfault);
_cliOptions = new CliOptions(args);
//std::locale::global(std::locale("en_US.UTF-8"));
if (_cliOptions->flag(CliOptions::Version))
{
std::cout << "WebCpp v" << version() << std::endl;
return 0;
}
std::cout << "Starting WebCpp v" << version() << " <http://www.webcpp.org/>."
<< std::endl
<< "Copyright © 2011-2013 Kévin Lesénéchal <*****@*****.**>."
<< std::endl
<< "This program is free software and distributed under the "
<< std::endl
<< "GNU General Public License. See <http://www.gnu.org/licenses/>."
<< std::endl << std::endl;
char exe[512];
ssize_t exeSize;
if ((exeSize = readlink("/proc/self/exe", exe, (sizeof exe) - 1)) < 0)
return 1;
exe[exeSize] = '\0';
_absolutePath = String(exe).section("/", 0, -3);
char* dirName = get_current_dir_name();
_runDir = String(dirName);
free(dirName);
_settings = Settings::fromIniFile("WebCpp/Config.ini");
_cachedSettings.handleExceptions = _settings["General.HandleExceptions"];
_cachedSettings.behindProxy = _settings["General.BehindProxy"];
_cachedSettings.defaultTemplateEngine
= _settings["General.DefaultTemplateEngine"];
_cachedSettings.defaultContentType = _settings["Content.DefaultContentType"];
_cachedSettings.defaultCharset = _settings["Content.DefaultCharset"];
_cachedSettings.sessionsEnabled = _settings["Sessions.Enabled"];
_cachedSettings.sessionIdCookieName = _settings["Sessions.IdCookieName"];
_cachedSettings.sessionTokenCookieName
= _settings["Sessions.TokenCookieName"];
_cachedSettings.sessionIpCheck = _settings["Sessions.IpCheck"];
_cachedSettings.defaultLocale = _settings["Locale.DefaultLocale"];
DatabaseSystem::reloadDbmsList();
CodeHighlighter::reloadCodeHighlighters();
_systemRouter = new SystemRouter;
try
{
_site = Site::load();
}
catch (const Exceptions::DbConnection& e)
{
std::cerr << "Critical: " << e.message() << std::endl;
return 1;
}
TransManager::get()->reloadFromFiles();
FCGX_Init();
_socket = FCGX_OpenSocket(setting("FastCGI.Socket").toCString(), 100);
int threadsCount = setting("FastCGI.Threads");
if (threadsCount < 1)
{
std::cerr << args[0] << ": invalid number of threads." << std::endl;
return 1;
}
if ((!_debug || _cliOptions->flag(CliOptions::NoPrompt))
&& !_cliOptions->flag(CliOptions::ForcePrompt))
threadsCount--;
for (int i = 0; i < threadsCount; i++)
{
Thread* thread = new Thread(&fcgiProcessingLoop);
_threads.append(thread);
thread->start();
}
if (((!_debug || _cliOptions->flag(CliOptions::NoPrompt))
&& !_cliOptions->flag(CliOptions::ForcePrompt))
|| _cliOptions->flag(CliOptions::Debug))
fcgiProcessingLoop();
else
Shell::run();
std::cout << "Shuting down…" << std::endl;
_running = false;
for (Thread* thread : _threads)
{
//thread->stop();
thread->wait();
delete thread;
}
return 0;
}
int main(int argc, char **argv)
{
int i;
std::ostringstream conffile;
conffile << SYSCONFDIR << "/restfsd.ini";
Config conf(conffile.str());
const int THREAD_COUNT = conf.GetInteger("main","threads",2);
std::thread *id = new std::thread[THREAD_COUNT];
FCGX_Init();
socketId.store( FCGX_OpenSocket(conf.get("main","listen").c_str(), 20) );
if(socketId < 0)
{
printf("Socket isn't opened\n");
return 1;
}
//~ int pid;
//~ pid = fork();
//~ if (pid == -1)
//~ {
//~ printf("Error: Start Daemon failed (%s)\n", strerror(errno));
//~ return -1;
//~ }
//~ else if (!pid)
//~ {
//~ umask(0);
//~ setsid();
//~ //chdir("/home/sokol");
for(i = 0; i < THREAD_COUNT; i++)
{
id[i] = std::thread( doit, i, std::ref(conf) );
}
//~ sleep(1);
//~ std::cout << "main1 " << conf.get("test","test") << std::endl;
//~ for(i = 0; i < THREAD_COUNT; i++)
//~ {
//~ id[i].join();
//~ id[i].detach();
//~ }
//~ while(true) {
//~ //std::cout << "while" << std::endl;
//~ for(i = 0; i < THREAD_COUNT; i++)
//~ {
//~ id[i].join();
//~ std::cout << "thread[" << i << "].get_id: " << id[i].get_id() << std::endl;
//~ if (id[i].joinable())
//~ {
//~ id[i].join();
//~ } else
//~ {
//~ std::cout << "thread[" << i << "]: starting" << std::endl;
//~ id[i] = std::thread( doit, i, std::ref(conf) );
//~ }
//~ }
//~ //sleep(1);
//~ }
//~ close(STDIN_FILENO);
//~ close(STDOUT_FILENO);
//~ close(STDERR_FILENO);
for(i = 0; i < THREAD_COUNT; i++)
{
id[i].join();
}
//~ std::cout << "main2" << conf.get("test","test") << std::endl;
return 0;
//~ } else
//~ {
//~ printf("Start Daemon pid=(%d)\n", pid);
//~ return 0;
//~ }
}
void
Application::run(std::string path) {
FCGX_Init();
run(FCGX_OpenSocket(path.c_str(), 400));
}
int main(void)
{
unsigned int count = 0;
int socket_fdescriptor = 0;
char *buf = NULL;
FCGX_Request request;
Request_t req;
// Initialize all the elements of the structures to NULL
memset(&request, 0, sizeof(FCGX_Request) );
memset(&req, 0, sizeof(Request_t) );
if ( FCGX_Init() != 0 )
{
return (1);
}
socket_fdescriptor = FCGX_OpenSocket(PORT_FCGI, 500);
if ( socket_fdescriptor < 0 )
{
return (2);
}
buf = (char *) malloc(50 * sizeof(char) );
sprintf(buf, "The file descriptor of the socket is : %d", socket_fdescriptor);
logger("main.c", buf);
if ( buf )
{
free(buf);
}
if ( FCGX_InitRequest(&request, socket_fdescriptor, 0) < 0 )
{
return (3);
}
/* Response loop. */
while ( FCGX_Accept_r(&request) == 0 )
{
request_fill(request, &req);
request_display(req, ++count);
FCGX_FPrintF(request.out,
"Content-type: text/html\r\n"
"\r\n"
"<title>FastCGI Hello! (C, fcgi_stdio library)</title>"
"<h1>FastCGI Hello! (C, fcgi_stdio library)</h1>"
"Request number %d",
count);
FCGX_Finish_r(&request);
}
fprintf(stderr, "Error FCGX_Accept_r");
return (0);
}
int main(int argc, char* argv[], char* envp[])
{
if(argc < 7)
usage(argv);
char* root = argv[1];
char* thumbnail_root = argv[2];
char* listen_addr = argv[3];
num_workers = atoi(argv[6]);
if(num_workers < 1)
usage(argv);
struct passwd* pwd = getpwnam(argv[4]);
if (pwd == NULL)
error_errno("getpwnam_r failed", EXIT_FAILURE);
struct group* grp = getgrnam(argv[5]);
if (grp == NULL)
error_errno("getgrnam_r failed", EXIT_FAILURE);
int userid = pwd->pw_uid;
int groupid = grp->gr_gid;
if(root[strlen(root) - 1] != '/' || thumbnail_root[strlen(thumbnail_root) - 1] != '/')
error("Did you forget the ending slash in the (thumbnail) root directory path?", EXIT_FAILURE);
// TODO Some more error checking
// Initialize syslog
syslog(LOG_INFO, "Starting up\n");
#if defined(DEBUG)
setlogmask(LOG_UPTO(LOG_DEBUG));
openlog("fastresize", LOG_CONS | LOG_NDELAY | LOG_PERROR | LOG_PID, LOG_USER);
#else
setlogmask(LOG_UPTO(LOG_INFO));
openlog("fastresize", LOG_CONS, LOG_USER);
#endif
// Change the working directory
if((chdir(root)) < 0)
error("Couldn't change working directory\n", EXIT_FAILURE);
// Initialize FastCGI
syslog(LOG_INFO, "Initializing FastCGI\n");
if(FCGX_Init())
error("Could not initialize FastCGI (during FCGX_Init())", EXIT_FAILURE);
int listen_socket = FCGX_OpenSocket(listen_addr, 400);
if(listen_socket < 0)
error("Couldn't bind to FastCGI socket", EXIT_FAILURE);
// Now that we've got our socket, drop root privileges
if (getuid() == 0) {
if (setgid(groupid) != 0)
error_errno("setgid: Unable to drop group privileges", EXIT_FAILURE);
if (setuid(userid) != 0)
error_errno("setuid: Unable to drop user privileges", EXIT_FAILURE);
}
FCGX_Request request;
if(FCGX_InitRequest(&request, listen_socket, 0))
error("Couldn't initialize FastCGI request handler", EXIT_FAILURE);
// Initialize ImageMagick
syslog(LOG_INFO, "Initializing ImageMagick\n");
MagickWandGenesis();
atexit(MagickWandTerminus);
/* Fork a new master process to daemonize and exit the old one. We use
* _Exit here to not trigger the atexit that terminates ImageMagick.
*/
if(fork())
_Exit(EXIT_SUCCESS);
// Fork worker processes
syslog(LOG_INFO, "Forking workers\n");
worker_pids = calloc(num_workers, sizeof(pid_t));
if(!worker_pids)
error_errno("worker_pids: Could not allocate", 1);
for(worker_id = 0; worker_id <= num_workers; worker_id++)
{
worker_pids[worker_id] = fork();
// Exit the loop if we're the forked process
if(worker_pids[worker_id] == 0)
break;
syslog(LOG_INFO, "Forked worker with PID %d\n", worker_pids[worker_id]);
}
// The following code is only executed in the master process.
if(worker_id > num_workers)
{
syslog(LOG_INFO, "master (PID %d): Sleeping until I receive a signal.\n", getpid());
/* Sleep a little until we get a SIG{TERM,HUP,INT} or one of our
* workers died (not cool).
*/
struct sigaction exit_action;
exit_action.sa_handler = &exit_signal;
exit_action.sa_sigaction = &exit_signal;
struct sigaction worker_died_action;
worker_died_action.sa_handler = &worker_died;
worker_died_action.sa_sigaction = &worker_died;
sigaction(SIGTERM, &exit_action, NULL);
sigaction(SIGHUP, &exit_action, NULL);
sigaction(SIGINT, &exit_action, NULL);
sigaction(SIGCHLD, &worker_died_action, NULL);
pause();
// This should never™ be reached unless something funny happens.
exit(EXIT_FAILURE);
}
syslog(LOG_INFO, "Worker #%d is now listening for requests on 127.0.0.1:9000\n", worker_id);
while(FCGX_Accept_r(&request) == 0)
handle_request(&request, root, thumbnail_root);
// Exit
exit(EXIT_SUCCESS);
}
