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); }