void ProcessFCGI(int socket)
{
FCGX_Request* cgiRequest = new FCGX_Request();
FCGX_InitRequest(cgiRequest, socket, 0);
Request request;
while(true)
{
FCGX_Accept_r(cgiRequest);
char** envp = cgiRequest->envp;
for ( ; *envp; ++envp)
{
printf("%s\n", *envp);
}
request.parse(cgiRequest);
if (request.isCorrect())
{
Response response = sc::SoundCloud::sharedInstance()->executeRequest(request);
response.doResponse(cgiRequest->out);
}
}
delete cgiRequest;
}
static VALUE fcgi_s_accept(VALUE self)
{
int status;
FCGX_Request *req;
fd_set readfds;
req = ALLOC(FCGX_Request);
status = FCGX_InitRequest(req,0,0);
if (status != 0) {
rb_raise(eFCGIError, "FCGX_Init() failed");
return Qnil;
}
FD_ZERO(&readfds);
FD_SET(req->listen_sock, &readfds);
if (rb_thread_select(req->listen_sock+1, &readfds, NULL, NULL, NULL) < 1) {
return Qnil;
}
status = FCGX_Accept_r(req);
if (status >= 0) {
fcgi_data *data;
char **env;
VALUE obj,key, value;
char *pkey,*pvalue;
int flags, fd;
/* Unset NONBLOCKING */
fd = ((FCGX_Request*) req)->ipcFd;
flags = fcntl(fd, F_GETFL);
if (flags & O_NONBLOCK) {
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
}
obj = Data_Make_Struct(self, fcgi_data, fcgi_mark, fcgi_free_req, data);
data->req = req;
data->in = Data_Wrap_Struct(cFCGIStream, 0, 0, req->in);
data->out = Data_Wrap_Struct(cFCGIStream, 0, 0, req->out);
data->err = Data_Wrap_Struct(cFCGIStream, 0, 0, req->err);
data->env = rb_hash_new();
env = req->envp;
for (; *env; env++) {
int size = 0;
pkey = *env;
pvalue = pkey;
while( *(pvalue++) != '=') size++;
key = rb_str_new(pkey, size);
value = rb_str_new2(pvalue);
OBJ_TAINT(key);
OBJ_TAINT(value);
rb_hash_aset(data->env, key, value);
}
return obj;
} else {
return Qnil;
}
}
void
fastcgi::accept() {
assert(!accepted());
if (0 != FCGX_Accept_r(req_.get())) {
throw fatal_error();
}
}
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 *process(void *a)
{
char **envp;
const char *data;
int res;
FCGX_Request req;
json_object *json;
json_object *jarray;
FCGX_InitRequest(&req, 0, 0);
while(1)
{
res = FCGX_Accept_r(&req);
if(res < 0)
{
break;
}
json = json_object_new_object();
jarray = json_object_new_array();
return_header(&req, 200, NULL, "application/json");
for(envp = req.envp; *envp != NULL; envp++)
{
//FIXME jsonurlencode...
json_object_array_add(jarray, json_object_new_string(*envp));
}
json_object_object_add(json, "env", jarray);
data = json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY);
FCGX_FPrintF(req.out, "%s\n", data);
json_object_put(json);
FCGX_Finish_r(&req);
}
return NULL;
}
void *CgiService::Serve(void *data)
{
CgiService *csrv = (CgiService*)data;
Core *core = new Core();
// core->set_server_ip(Config::Instance()->server_ip_);
// core->set_redirect_script(Config::Instance()->redirect_script_);
FCGX_Request request;
if(FCGX_InitRequest(&request, csrv->socketId, 0) != 0)
{
Log::err("Can not init request");
return nullptr;
}
for(;;)
{
static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&accept_mutex);
int rc = FCGX_Accept_r(&request);
pthread_mutex_unlock(&accept_mutex);
if(rc < 0)
{
Log::err("Can not accept new request");
break;
}
csrv->ProcessRequest(&request, core);
}
return nullptr;
}
int
FastcgiRequest::accept() {
int status = FCGX_Accept_r(&fcgiRequest_);
if (status >= 0 && (logTimes_|| statistics_)) {
gettimeofday(&accept_time_, NULL);
}
return status;
}
cgi_session *fcgi_api::accept_session()
{
FCGX_Request *request=new FCGX_Request();
FCGX_InitRequest(request,fd,FCGI_FAIL_ACCEPT_ON_INTR);
if(FCGX_Accept_r(request)<0) {
delete request;
return NULL;
}
return new fcgi_session(request,NULL);
}
virtual void run(){
for (;;) {
int rc = FCGX_Accept_r(&request);
if (rc < 0) break;
if(!doRequest(request)){
FCGX_FPrintF(request.out, "Content-type: text/html\r\n\r\n");
FCGX_Finish_r(&request);
}
}
};
/*
* fcgi_Request methods
*/
static PyObject *
fcgi_Request_accept(fcgi_Request *self)
{
int rc;
char **e;
Py_BEGIN_ALLOW_THREADS
rc = FCGX_Accept_r(&self->r);
Py_END_ALLOW_THREADS
if (rc < 0) {
/*
* FCGX_Accept_r returns (0 - errno) on error,
* so PyErr_SetFromErrno should work just fine
*/
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
/* clear any existing environment */
PyDict_Clear(self->env);
if (self->r.envp == NULL) {
Py_RETURN_NONE;
}
/* fill in the environment */
for (e = self->r.envp; *e != NULL; e++)
{
PyObject *k, *v;
char *p = strchr(*e, '=');
if (p == NULL)
continue;
k = PyString_FromStringAndSize(*e, (int)(p-*e));
if (k == NULL) {
PyErr_Clear();
continue;
}
v = PyString_FromString(p + 1);
if (v == NULL) {
PyErr_Clear();
Py_DECREF(k);
continue;
}
if (PyDict_SetItem(self->env, k, v) != 0)
PyErr_Clear();
Py_DECREF(k);
Py_DECREF(v);
}
Py_RETURN_NONE;
}
bool Request::accept() {
// One time library init on first request
static LibraryInitializer initializer;
free();
auto initResult = FCGX_InitRequest(&request, 0, FCGI_FAIL_ACCEPT_ON_INTR);
if( initResult != 0 ) {
throw Exception("Request failed to initialize");
}
if(FCGX_Accept_r(&request) != 0) return false;
inited = true;
return true;
}
void
Application::run(int listen_socket) {
FCGX_Request *request = new FCGX_Request();
FCGX_InitRequest(request, listen_socket, 0);
while (FCGX_Accept_r(request) == 0) {
boost::thread(&::Ambrogio::Application::__run_session, request, &_router, debug);
request = new FCGX_Request();
FCGX_InitRequest(request, listen_socket, 0);
}
{ Request req(request); }
}
void HttpWorkThread::Run()
{
HttpRequestX request;
HttpResponseX response(&request);
int loop_count = 0;
FCGX_InitRequest(request.GetFCGX_Request(), 0, 0);
while(1)
{
int iRet = FCGX_Accept_r(request.GetFCGX_Request() ); // >= 0
if (iRet < 0)
{
LOGINFO("FCGX_Accept_r return %d", iRet);
break;
}
bool matched = false;
request.Init();
if(response.Init() != 0) {
LOGERR("response init error");
break;
}
// 依次匹配各个handler
for (size_t i = 0; i < vs_handler_.size(); i++)
{
HttpHandlerX * handler = vs_handler_[i];
if (handler->Matches(request.GetScriptName()) ) {
handler->DoService(request, response);
matched = true;
break;
}
}
if(!matched) {
LOGERR("Request URL not found: %s", request.GetScriptName());
response.SendError(404);
}
request.Destroy();
FCGX_Finish_r( request.GetFCGX_Request() );
loop_count++;
//if(loop_count > m_max_loop_count){
// break;
//}
}
// 依次释放各handler的资源
// 释放线程对应的资源
}
static void *doit(void *a)
{
int rc, thread_id = (int)a;
int i = 0;
pid_t pid = getpid();
FCGX_Request request;
char *server_name;
FCGX_InitRequest(&request, 0, 0);
for (;;)
{
static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t counts_mutex = PTHREAD_MUTEX_INITIALIZER;
/* Some platforms require accept() serialization, some don't.. */
pthread_mutex_lock(&accept_mutex);
rc = FCGX_Accept_r(&request);
pthread_mutex_unlock(&accept_mutex);
if (rc < 0)
break;
server_name = FCGX_GetParam("SERVER_NAME", request.envp);
FCGX_FPrintF( request.out,
"Content-type: text/html\r\n"
"\r\n"
"<title>FastCGI Hello! (multi-threaded C, fcgiapp library)</title>"
"<h1>FastCGI Hello! (multi-threaded C, fcgiapp library)</h1>"
"Thread %d, Process %ld<p>"
"Request counts for %d threads running on host <i>%s</i><p><code>",
thread_id, pid, THREAD_COUNT, server_name ? server_name : "?" );
//sleep(2);
pthread_mutex_lock(&counts_mutex);
++counts[thread_id];
i++;
FCGX_FPrintF( request.out, "%5d ", i );
//for (i = 0; i < THREAD_COUNT; i++)
// FCGX_FPrintF(request.out, "%5d " , counts[i]);
pthread_mutex_unlock(&counts_mutex);
FCGX_Finish_r(&request);
}
return NULL;
}
int main(void) {
//int sock;
FCGX_Request request;
FCGX_Init();
//sock = FCGX_OpenSocket(":2005", 5);
FCGX_InitRequest(&request, 0, 0);
while (FCGX_Accept_r(&request) >= 0) {
handle_request(&request);
FCGX_Finish_r(&request);
}
return EXIT_SUCCESS;
}
void run()
{
FCGX_Request raw_request;
FCGX_InitRequest(&raw_request, 0, 0);
while(FCGX_Accept_r(&raw_request) == 0)
{
HttpResponse response(raw_request);
HttpRequest request(&response);
try{
handle(request, response);
}catch(std::exception& e){
response.err() << "Exception: " << e.what() << std::endl;
throw;
}
FCGX_Finish_r(&raw_request);
}
}
int main()
{
CHICKEN_run(C_toplevel);
FCGX_Request* request = malloc(sizeof(FCGX_Request));
FCGX_Init();
FCGX_InitRequest(request, 0, 0);
while (FCGX_Accept_r(request) == 0)
{
http_handle_request(request);
FCGX_Finish_r(request);
}
FCGX_Free(request, 1);
free(request);
}
int main ()
{
log_open();
lsp::g_conf = new lsp::LSP_CONF();
load_configuration();
// load ext module first
lsp::mod_mgr.load();
FCGX_Init();
lsp::REQBAG request;
FCGX_InitRequest(&request, 0, 0);
openlog("luasp_fcgi", LOG_CONS | LOG_PID, 0);
log(LOG_INFO, "%s", "luasp_fcgi start working...");
while (FCGX_Accept_r(&request) >= 0) {
request.header_out = false;
lsp::LUABAG luabag;
if (!luabag_init(&luabag))
{
// log(LOG_INFO, "%s", "lua_fcgi init failed!!");
}
int result = luabag_run(&luabag, &request);
if (0 != result)
{
output_error_page(&request, result);
// log(LOG_INFO, "%s", "lua_fcgi run script failed!!");
}
if (!luabag_cleanup(&luabag))
{
// log(LOG_INFO, "%s", "lua_fcgi cleanup failed!!!");
}
FCGX_Finish_r(&request);
} /* while */
log(LOG_INFO, "%s", "luasp_fcgi stoped!");
delete lsp::g_conf;
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);
}
}
void fcgiccExec(
void (&func)(cgicc::FCgiCC<Env, In, Out, Err> &),
void (&except)(const E &)
) {
FCGX_Request request;
FCGX_Init();
FCGX_InitRequest(&request, 0, 0);
while (FCGX_Accept_r(&request) == 0) {
try {
cgicc::FCgiCC<Env, In, Out, Err> cgi{
request, std::cin, std::cout, std::cerr // TODO: create new stream
};
func(cgi);
} catch (const E &e) {
except(e);
}
}
}
int FCGX_Accept(FCGX_Stream ** in,
FCGX_Stream ** out, FCGX_Stream ** err, FCGX_ParamArray * envp)
{
int rc;
if (!libInitialized) {
rc = FCGX_Init();
if (rc) {
return rc;
}
}
rc = FCGX_Accept_r(&the_request);
*in = the_request.in;
*out = the_request.out;
*err = the_request.err;
*envp = the_request.envp;
return rc;
}
static void *doit(void *a){
FCGX_Request request;
int rc;
char *filename;
UNUSED(a);
FCGX_InitRequest(&request, 0, /* FCGI_FAIL_ACCEPT_ON_INTR */ 0);
while(1){
int fd;
//Some platforms require accept() serialization, some don't. The documentation claims it to be thread safe
// static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
// pthread_mutex_lock(&accept_mutex);
rc = FCGX_Accept_r(&request);
// pthread_mutex_unlock(&accept_mutex);
if(rc < 0)
break;
//get the filename
if((filename = FCGX_GetParam("SCRIPT_FILENAME", request.envp)) == NULL){
FORBIDDEN(request.out);
//don't try to open directories
}else if(filename[strlen(filename)-1] == '/'){
FORBIDDEN(request.out);
//open the file
}else if((fd = open(filename, O_RDONLY)) == -1){
NOTFOUND(request.out, filename);
//no error, serve it
}else{
SENDFILE(request.out, filename);
close(fd);
}
FCGX_Finish_r(&request);
}
return NULL;
}
WebRequest *FCGIStream::getNextRequest(int timeoutsec)
{
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(0, &rfds);
struct timeval timeout;
timeout.tv_sec = timeoutsec;
timeout.tv_usec = 0;
for(;;) {
int result = select(FD_SETSIZE, &rfds, 0, 0, &timeout);
if (result == 0)
return 0; // timeout
else if (result == -1) {
if (errno != EINTR) {
perror("select");
exit(1); // FIXME: throw exception
} else {
// EINTR, try again
}
} else
break;
}
FCGX_Request *request = new FCGX_Request();
FCGX_InitRequest(request, 0, 0);
if (FCGX_Accept_r(request) == 0) {
return new FCGIRequest(request);
} else {
LOG_ERROR("could not FCGX_Accept ?");
delete request;
exit(1); // FIXME: throw exception
}
}
/* TODO: Comment */
static void *doit(void *a){
int rc, thread_id = (pthread_t) a;
FCGX_Request request;
apr_pool_t* pool;
struct range_request* rr;
struct libcrange *lr;
char *config_file = NULL;
char * r_query; /* range query */
int r_status = 0;
apr_initialize();
atexit(apr_terminate);
apr_pool_create(&pool, NULL);
config_file = LIBCRANGE_CONF;
lr = libcrange_new(pool, config_file);
/* malloc for query */
r_query = (char *)malloc(QUERY_STR_SIZE);
FCGX_InitRequest(&request, 0, 0);
for (;;)
{
static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
apr_pool_t* sub_pool;
apr_pool_create(&sub_pool, pool);
/* zero it out */
bzero(r_query, QUERY_STR_SIZE);
r_status = 0;
/* Some platforms require accept() serialization, some don't.. */
pthread_mutex_lock(&accept_mutex);
rc = FCGX_Accept_r(&request);
pthread_mutex_unlock(&accept_mutex);
if (rc < 0)
break;
r_status = get_range_query(&request, r_query);
rr = range_expand(lr, sub_pool, r_query);
FCGX_FPrintF(request.out, "Content-type: text/plain\r\n");
/* set headers */
if (range_request_has_warnings(rr)) {
const char *warnings = range_request_warnings(rr);
FCGX_FPrintF(request.out,
"RangeException: %s\r\nRange_FCGI_Thread_Id: %d\r\n",
warnings, thread_id);
}
/* End Delimiter */
FCGX_FPrintF(request.out, "\r\n");
/* r_status == 1, then wants list */
if (r_status == 1) {
const char **nodes = range_request_nodes(rr);
while(*nodes) {
FCGX_FPrintF(request.out, "%s\n", *nodes++);
}
} else if (r_status == 0) {
FCGX_FPrintF(request.out, "%s\n", range_request_compressed(rr));
}
apr_pool_destroy(sub_pool);
FCGX_Finish_r(&request);
} /* for (;;) */
/* free, what I hogged :-) */
free(r_query);
apr_pool_destroy(pool);
return NULL;
}
bool accept() override { return FCGX_Accept_r(&m_request) == 0; }
void WebInterface::worker() {
/* Backup the stdio streambufs */
std::streambuf * cin_streambuf = std::cin.rdbuf();
std::streambuf * cout_streambuf = std::cout.rdbuf();
std::streambuf * cerr_streambuf = std::cerr.rdbuf();
const std::string kw_title(KW_TITLE);
const std::string kw_head(KW_HEAD);
const std::string kw_menu(KW_MENU);
const std::string kw_content(KW_CONTENT);
FCGX_Request request;
/* Initialize FastCGI library and request */
FCGX_Init();
FCGX_InitRequest(&request, 0, FCGI_FAIL_ACCEPT_ON_INTR);
LOG_DBG("FastCGI initialization success!");
while (!stop_flag_) {
if(FCGX_Accept_r(&request) >= 0) {
fcgi_streambuf cin_fcgi_streambuf(request.in);
fcgi_streambuf cout_fcgi_streambuf(request.out);
fcgi_streambuf cerr_fcgi_streambuf(request.err);
std::cin.rdbuf(&cin_fcgi_streambuf);
std::cout.rdbuf(&cout_fcgi_streambuf);
std::cerr.rdbuf(&cerr_fcgi_streambuf);
/* getting the uri from the request */
std::string uri;
const char *uri_param = FCGX_GetParam("REQUEST_URI", request.envp);
if(!uri_param) {
LOG_ERR("Failed to retrieve the request URI environment value!");
uri = URI_PAGE_ERROR;
} else {
uri = uri_param;
}
LOG_DBG("Request received: %s", uri.c_str());
/* Check if URI is a file in the home folder and get the mime of
* that file (by extension) */
std::string path;
std::string mime = if_file_get_mime(uri, &path);
if (!mime.empty()) {
/* This is a file we need to serve */
StringPtr file_data = Utils::read_file(path);
std::cout << "Content-type: " << mime << "\r\n\r\n";
std::cout << *(file_data);
file_data.reset();
} else {
/* Parse the URI */
std::map<std::string, std::string> uri_data = parseURI(uri);
LOG_DBG("URI Parsed, page requested: %s",
uri_data[URI_PAGE].c_str());
/* Generate and serve the page depending on the URI */
StringPtr page;
std::string content_type = "text/html";
/* Main page requested */
if (uri_data[URI_PAGE].compare(URI_PAGE_MAIN) == 0) {
bool success = false;
/* Check if a command was sent from the client. */
if (uri_data.find(URI_PAGE_COMMAND) != uri_data.end()) {
success = add_command(uri_data[URI_PAGE_COMMAND]);
}
std::string s;
/* Check if the request was sent from javascript or pure HTML */
if(uri_data.find(URI_PAGE_SOURCE) != uri_data.end()) {
LOG_DBG("This query's source IS javascript: %s, Source: %s",
uri.c_str(), (uri_data[URI_PAGE_SOURCE]).c_str());
content_type = "application/json";
page = generate_command_json(success);
} else {
LOG_DBG("This query's source IS NOT javascript: %s", uri.c_str());
/* Just generate a standard main page */
page = generate_main_page();
}
/* Log page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_LOG) == 0) {
page = generate_log_page();
/* Status page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_STATUS) == 0) {
page = generate_status_page();
/* Console lines JSON page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_CL) == 0) {
if (uri_data.find(URI_PAGE_BEFORE) != uri_data.end()) {
content_type = "application/json";
page = generate_cljson_before(
uri_data[URI_PAGE_BEFORE]);
} else if (uri_data.find(URI_PAGE_AFTER)
!= uri_data.end()) {
content_type = "application/json";
page = generate_cljson_after(uri_data[URI_PAGE_AFTER]);
} else {
page = generate_error_page();
}
/* Log lines JSON page requested */
} else if (uri_data[URI_PAGE].compare(URI_PAGE_LL) == 0) {
if (uri_data.find(URI_PAGE_BEFORE) != uri_data.end()) {
content_type = "application/json";
page = generate_lljson_before(
uri_data[URI_PAGE_BEFORE]);
} else if (uri_data.find(URI_PAGE_AFTER)
!= uri_data.end()) {
content_type = "application/json";
page = generate_lljson_after(uri_data[URI_PAGE_AFTER]);
} else {
page = generate_error_page();
}
} else {
page = generate_error_page();
}
/* Output the generated page with the correct content type */
std::cout << "Content-type: " << content_type << "\r\n\r\n";
std::cout << *(page.get());
}
}
else {
LOG_TRC("FCGX_Aceept_r returned less than 0!");
}
}
LOG_TRC("Out of accept request loop!");
// Free request strucure
FCGX_Finish_r(&request);
// Flag the thread as not running anymore.
running_ = false;
// restore stdio streambufs
std::cin.rdbuf(cin_streambuf);
std::cout.rdbuf(cout_streambuf);
std::cerr.rdbuf(cerr_streambuf);
}
int main(int argc, char** argv){
(void)argc;
(void)argv;
openlog("eqbeats", LOG_PID, LOG_USER);
struct eqbeats_ctx eq;
if(eqbeats_init(&eq, "", NULL, EQBEATS_INIT_SETUP) != 0){
log("eqbeats initialization failed");
exit(1);
}
setenv("EQBEATS_DIR", eq.root, 0);
DB::setPgDatabase(eq.pg);
if(!DB::connect((std::string)argv[0] + "-" + number(getpid()))){
log("critical error: couldn't connect to PostgreSQL");
exit(1);
}
uint32_t buf = 0;
int urandom = open("/dev/urandom", O_RDONLY);
if(urandom != -1) {
read(urandom, &buf, 4);
close(urandom);
srand(buf);
} else {
log("Couldn't open /dev/urandom, random seed will be predictable.");
srand(getpid() ^ time(NULL));
}
MagickWandGenesis();
FCGX_Request request;
FCGX_Init();
FCGX_InitRequest(&request, 0, 0);
FCgiIO o;
ctemplate::AddModifier("x-irc", new IrcEscape);
ctemplate::AddXssSafeModifier("x-email", new EmailEscape);
ctemplate::AddXssSafeModifier("x-format", new Formatter);
cache.SetTemplateRootDirectory(TEMPLATES_DIR);
void (*callbacks[])(Document*) = {
Pages::statics, Pages::home,
Pages::track, Pages::trackMisc, Pages::tracks, Pages::oembed, Pages::trackActions, Pages::trackUpload, Pages::art, Pages::license,
Pages::account, Pages::login, Pages::user, Pages::users, Pages::registration, Pages::passwordReset,
Pages::playlist, Pages::playlistActions,
Pages::comment, Pages::socialActions, Pages::favorites,
Pages::featureActions,
#ifdef HAVE_LIBHIREDIS
Pages::stats,
#endif
0
};
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = &signalCatch;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGQUIT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
pid_t child;
int rc;
while(FCGX_Accept_r(&request) == 0){
resetTimer();
if(eqbeats_health_check(&eq) < 0)
continue; /* let it return 502 */
DB::healthCheck(); /* redis */
headers = request.envp;
o.attach(&request);
try { cgi = cgicc::Cgicc(&o); }
catch(std::runtime_error &err){
log((std::string)"CgiCc error: " + err.what());
//continue;
}
path = stripSlash(cgi.getEnvironment().getScriptName());
Document doc;
// Nope
if (cgi.getElementByValue("PHPE9568F34-D428-11d2-A769-00AA001ACF42") != cgi.getElements().end() ||
cgi.getElementByValue("PHPE9568F35-D428-11d2-A769-00AA001ACF42") != cgi.getElements().end() ||
cgi.getElementByValue("PHPE9568F36-D428-11d2-A769-00AA001ACF42") != cgi.getElements().end()){
doc.redirect("http://youtu.be/gvdf5n-zI14");
}
if (getenv("EQBEATS_HTTPS") && !cgi.getEnvironment().usingHTTPS() && cgi.getElements().size() == 0)
doc.moved(eqbeatsUrl() + path);
Session::start();
for(int i=0; !doc && callbacks[i]; i++)
callbacks[i](&doc);
Session::fill(doc.rootDict());
o << doc.generate();
Session::destroy();
FCGX_Finish_r(&request);
while((child = waitpid(-1, &rc, WNOHANG)) > 0) // wait for zombies
syslog(WIFEXITED(rc) ? LOG_NOTICE : LOG_ERR, "%d exited with %d.", child, WEXITSTATUS(rc));
}
MagickWandTerminus();
DB::close();
eqbeats_end(&eq);
return 0;
}
static void *doit(int id, Config &conf)
{
FCGX_Request request;
if(FCGX_InitRequest(&request, socketId.load(), 0) != 0)
{
//ошибка при инициализации структуры запроса
printf("Can not init request\n");
return NULL;
}
Router router(&request, &conf);
router.addHandler("OPTIONS", "/users/login", &OptUsersLogin);
router.addHandler("GET", "/users/login", &UsersInfo);
router.addHandler("POST", "/users/login", &PostUsersLogin);
router.addHandler("OPTIONS", "/users/add", &OptUsersAdd);
router.addHandler("POST", "/users/add", &PostUsersAdd);
router.addHandler("OPTIONS", ".*", &OptDirs);
router.addHandler("OPTIONS", "/dirs/(?<id>\\d+)", &OptDirs);
router.addHandler("POST", "/dirs", &PostCreateDir);
router.addHandler("GET", "/dirs/(\\d+)", &GetDir);
router.addHandler("DELETE", "/dirs/(\\d+)", &DelDir);
router.addHandler("POST", "/files/(\\d+)/(.+)", &PutFile);
router.addHandler("GET", "/files/(\\d+)", &GetFile);
router.addHandler("DELETE", "/files/(\\d+)", &DelFile);
for(;;)
{
static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&accept_mutex);
int rc = FCGX_Accept_r(&request);
pthread_mutex_unlock(&accept_mutex);
if(rc < 0)
{
//ошибка при получении запроса
printf("Can not accept new request\n");
break;
}
std::streambuf * cin_streambuf = std::cin.rdbuf();
std::streambuf * cout_streambuf = std::cout.rdbuf();
std::streambuf * cerr_streambuf = std::cerr.rdbuf();
fcgi_streambuf cin_fcgi_streambuf(request.in);
fcgi_streambuf cout_fcgi_streambuf(request.out);
fcgi_streambuf cerr_fcgi_streambuf(request.err);
std::cin.rdbuf(&cin_fcgi_streambuf);
std::cout.rdbuf(&cout_fcgi_streambuf);
std::cerr.rdbuf(&cerr_fcgi_streambuf);
try
{
router.Run();
}
catch (Error &e)
{
router.SetStatus(e.http_code());
router.AddHeader("Content-Type", "application/json; charset=utf-8");
router.AddContent(e.what());
router.AcceptContent();
}
catch (std::exception &e)
{
std::cerr << e.what();
router.SetStatus(Httpstatus::InternalServerError);
router.AddHeader("Content-Type", "text/plain; charset=utf-8");
router.AddContent(e.what());
router.AcceptContent();
}
FCGX_Finish_r(&request);
//завершающие действия - запись статистики, логгирование ошибок и т.п.
router.Cleanup();
std::cin.rdbuf(cin_streambuf);
std::cout.rdbuf(cout_streambuf);
std::cerr.rdbuf(cerr_streambuf);
}
return NULL;
}
void* Rok4Server::thread_loop ( void* arg ) {
Rok4Server* server = ( Rok4Server* ) ( arg );
FCGX_Request fcgxRequest;
if ( FCGX_InitRequest ( &fcgxRequest, server->sock, FCGI_FAIL_ACCEPT_ON_INTR ) !=0 ) {
LOGGER_FATAL ( _ ( "Le listener FCGI ne peut etre initialise" ) );
}
while ( server->isRunning() ) {
std::string content;
bool postRequest;
int rc;
if ( ( rc=FCGX_Accept_r ( &fcgxRequest ) ) < 0 ) {
if ( rc != -4 ) { // Cas différent du redémarrage
LOGGER_ERROR ( _ ( "FCGX_InitRequest renvoie le code d'erreur" ) << rc );
}
//std::cerr <<"FCGX_InitRequest renvoie le code d'erreur" << rc << std::endl;
break;
}
//DEBUG: La boucle suivante permet de lister les valeurs dans fcgxRequest.envp
/*char **p;
for (p = fcgxRequest.envp; *p; ++p) {
LOGGER_DEBUG((char*)*p);
}*/
Request* request;
postRequest = ( server->servicesConf.isPostEnabled() ?strcmp ( FCGX_GetParam ( "REQUEST_METHOD",fcgxRequest.envp ),"POST" ) ==0:false );
if ( postRequest ) { // Post Request
char* contentBuffer = ( char* ) malloc ( sizeof ( char ) *200 );
while ( FCGX_GetLine ( contentBuffer,200,fcgxRequest.in ) ) {
content.append ( contentBuffer );
}
free ( contentBuffer );
contentBuffer= NULL;
LOGGER_DEBUG ( _ ( "Request Content :" ) << std::endl << content );
request = new Request ( FCGX_GetParam ( "QUERY_STRING", fcgxRequest.envp ),
FCGX_GetParam ( "HTTP_HOST", fcgxRequest.envp ),
FCGX_GetParam ( "SCRIPT_NAME", fcgxRequest.envp ),
FCGX_GetParam ( "HTTPS", fcgxRequest.envp ),
content );
} else { // Get Request
/* On espère récupérer le nom du host tel qu'il est exprimé dans la requete avec HTTP_HOST.
* De même, on espère récupérer le path tel qu'exprimé dans la requête avec SCRIPT_NAME.
*/
request = new Request ( FCGX_GetParam ( "QUERY_STRING", fcgxRequest.envp ),
FCGX_GetParam ( "HTTP_HOST", fcgxRequest.envp ),
FCGX_GetParam ( "SCRIPT_NAME", fcgxRequest.envp ),
FCGX_GetParam ( "HTTPS", fcgxRequest.envp )
);
}
server->processRequest ( request, fcgxRequest );
delete request;
FCGX_Finish_r ( &fcgxRequest );
FCGX_Free ( &fcgxRequest,1 );
}
LOGGER_DEBUG ( _ ( "Extinction du thread" ) );
Logger::stopLogger();
return 0;
}
int bridge_request_accept(bridge_request_t *self)
{
return FCGX_Accept_r(&self->request);
}
