int bridge_request_handle(bridge_request_t *self)
{
int ret;
char *buffer;
struct json_object *in_json;
if ((ret = bridge_request_getinput(self, &buffer)) != 0) {
bridge_request_fatal(self);
goto out;
}
in_json = json_tokener_parse_ex(self->tokener, buffer, -1);
if (!in_json) {
bridge_request_fatal(self);
ret = -1;
goto cleanup;
}
ret = bridge_request_call_json_dbus(self, in_json);
cleanup:
json_object_put(in_json);
json_tokener_reset(self->tokener);
free(buffer);
out:
if (ret != 0)
FCGX_Finish_r(&self->request);
return ret;
}
bool doRequest(FCGX_Request& request){
map<string, string> mapParam;
string query_string = FCGX_GetParam("QUERY_STRING", request.envp);
ParseParam(mapParam, query_string);
map<string, string>::iterator itU = mapParam.find("uid");
if(itU == mapParam.end()){
return false;
}
int userId;
try{
userId = boost::lexical_cast<int>((*itU).second);
}catch(...){
return false;
}
TipPtr tp;
try{
tp = QuestCacheAdapter::instance().showTip(userId);
if(tp->id==-1)
return false;
}catch(...){
return false;
}
string res = "Content-type: text/html\r\n\r\n" + tp->content;
FCGX_FPrintF(request.out, res.c_str());
FCGX_Finish_r(&request);
return true;
}
FastcgiRequest::~FastcgiRequest() {
boost::uint64_t microsec = 0;
if (logTimes_ || statistics_) {
gettimeofday(&finish_time_, NULL);
microsec = (finish_time_.tv_sec - accept_time_.tv_sec) *
1000000 + (finish_time_.tv_usec - accept_time_.tv_usec);
}
if (logTimes_) {
double res = static_cast<double>(microsec) / 1000000.0;
logger_->info("handling %s taken %08f seconds", url_.c_str(), res);
}
if (statistics_) {
try {
statistics_->add(handler_ ? handler_->id : DAEMON_STRING, request_->status(), microsec);
}
catch (const std::exception &e) {
logger_->error("Exception caught while update statistics: %s", e.what());
}
catch (...) {
logger_->error("Unknown exception caught while update statistics");
}
}
FCGX_Finish_r(&fcgiRequest_);
}
int bridge_request_call_dbus_json(bridge_request_t *self, DBusMessage *in_dbus)
{
DBusMessageIter it;
DBusError err;
struct json_object *result = 0;
int ret = 0;
if (dbus_message_get_type(in_dbus) == DBUS_MESSAGE_TYPE_ERROR) {
dbus_error_init(&err);
(void)dbus_set_error_from_message(&err, in_dbus);
bridge_request_error(self, err.message ? err.message : err.name);
dbus_error_free(&err);
ret = EINVAL;
goto finish;
}
if (dbus_message_iter_init(in_dbus, &it)) {
if ((ret = bridge_request_json_params(self, &it, &result, dbus_message_iter_has_next(&it))) != 0)
goto finish;
}
if ((ret = bridge_request_send_response(self, 0, result)) != 0) {
bridge_request_error(self, "Out of memory.");
}
finish:
if (result)
json_object_put(result);
dbus_message_unref(in_dbus);
FCGX_Finish_r(&self->request);
self->next = self->bridge->head;
self->bridge->head = self;
return ret;
}
static VALUE fcgi_finish(VALUE self)
{
fcgi_data *data;
fcgi_stream_data *stream_data;
Data_Get_Struct(self, fcgi_data, data);
if (Qnil != data->in) {
Data_Get_Struct(data->in, fcgi_stream_data, stream_data);
stream_data->req = Qnil; stream_data->stream = NULL;
}
if (Qnil != data->out) {
Data_Get_Struct(data->out, fcgi_stream_data, stream_data);
stream_data->req = Qnil; stream_data->stream = NULL;
}
if (Qnil != data->err) {
Data_Get_Struct(data->err, fcgi_stream_data, stream_data);
stream_data->req = Qnil; stream_data->stream = NULL;
}
data->in = data->out = data->err = Qnil;
FCGX_Finish_r(data->req);
return Qtrue;
}
foreign_t
fcgi_finish(void)
{
fcgi_context *ctxt;
FCGI_debug("fcgi_finish()");
if ( FCGX_IsCGI() )
{ return TRUE;
}
ctxt = pthread_getspecific(key);
Sflush(Suser_output);
Sflush(Suser_error);
FCGX_Finish_r(ctxt->req);
ctxt->req = NULL;
ctxt->fcgi_in = ctxt->fcgi_out = ctxt->fcgi_err = NULL;
ctxt->env = NULL;
Suser_input->handle = ctxt->h_in;
Suser_input->functions = ctxt->fn_in;
Suser_output->handle = ctxt->h_out;
Suser_output->functions = ctxt->fn_out;
Suser_error->handle = ctxt->h_err;
Suser_error->functions = ctxt->fn_err;
return TRUE;
}
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;
}
static PyObject *
fcgi_Request_finish(fcgi_Request *self)
{
Py_BEGIN_ALLOW_THREADS
FCGX_Finish_r(&self->r);
Py_END_ALLOW_THREADS
Py_RETURN_NONE;
}
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);
}
}
};
static VALUE fcgi_finish(VALUE self)
{
fcgi_data *data;
Data_Get_Struct(self, fcgi_data, data);
FCGX_Finish_r(data->req);
return Qtrue;
}
void CgiService::Response(FCGX_Request *req,
const std::string &out,
const std::string &cookie,
const std::string &cookie_track)
{
FCGX_FPrintF(req->out,"Content-type: text/html\r\n");
FCGX_FPrintF(req->out,"Set-Cookie: %s\r\n", cookie.c_str());
FCGX_FPrintF(req->out,"Set-Cookie: %s\r\n", cookie_track.c_str());
FCGX_FPrintF(req->out,"Status: 200 OK\r\n");
FCGX_FFlush(req->out);
FCGX_FPrintF(req->out,"\r\n%s\n", out.c_str());
FCGX_Finish_r(req);
}
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);
}
}
static unsigned long
request_release_(CONTAINER_REQUEST *me)
{
unsigned long r;
r = cw_release(&(me->lock), &(me->refcount));
if(!r)
{
DPRINTF(me->cw, "freeing request %08lx", (unsigned long) me);
FCGX_Finish_r(me->request);
cw_request_info_destroy(&(me->info));
me->cw->api->release(me->cw);
me->endpoint->api->release(me->endpoint);
pthread_mutex_destroy(&(me->lock));
free(me);
}
return r;
}
static void
fcgi_Request_dealloc(fcgi_Request *self)
{
/* these can be NULL, a fcgi_Stream instance,
* this macro covers all the bases
*/
close_stream(self->s_in);
close_stream(self->s_out);
close_stream(self->s_err);
Py_XDECREF(self->env);
Py_BEGIN_ALLOW_THREADS
FCGX_Finish_r(&self->r);
Py_END_ALLOW_THREADS
self->ob_type->tp_free((PyObject*)self);
}
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);
}
}
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;
}
void CgiService::Response(FCGX_Request *req, int status)
{
FCGX_FPrintF(req->out,"Content-type: text/html\r\n");
FCGX_FPrintF(req->out,"Status: ");
switch (status)
{
case 200:
FCGX_FPrintF(req->out,"200 OK");
break;
case 301:
FCGX_FPrintF(req->out,"301 Moved Permanently");
break;
case 302:
FCGX_FPrintF(req->out,"302 Found");
break;
case 307:
FCGX_FPrintF(req->out,"307 Temporary Redirect");
break;
case 400:
FCGX_FPrintF(req->out,"400 Bad Request");
break;
case 403:
FCGX_FPrintF(req->out,"403 Forbidden");
break;
case 500:
FCGX_FPrintF(req->out,"500 Internal Server Error");
break;
case 503:
FCGX_FPrintF(req->out,"503 Service Unavailable");
break;
default:
FCGX_FPrintF(req->out,"200 OK");
break;
}
FCGX_FPrintF(req->out,"\r\n");
FCGX_FFlush(req->out);
FCGX_Finish_r(req);
}
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
fastcgi::finish() {
if (accepted()) {
FCGX_Finish_r(req_.get());
}
}
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;
}
/* 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;
}
fcgi_stream::~fcgi_stream()
{
FCGX_Finish_r(&request);
};
void release() override { FCGX_Finish_r(&m_request); }
/*
*----------------------------------------------------------------------
*
* FCGX_Accept_r --
*
* Accepts a new request from the HTTP server.
*
* Results:
* 0 for successful call, -1 for error.
*
* Side effects:
*
* Finishes the request accepted by (and frees any
* storage allocated by) the previous call to FCGX_Accept.
* Creates input, output, and error streams and
* assigns them to *in, *out, and *err respectively.
* Creates a parameters data structure to be accessed
* via getenv(3) (if assigned to environ) or by FCGX_GetParam
* and assigns it to *envp.
*
* DO NOT retain pointers to the envp array or any strings
* contained in it (e.g. to the result of calling FCGX_GetParam),
* since these will be freed by the next call to FCGX_Finish
* or FCGX_Accept.
*
*----------------------------------------------------------------------
*/
int FCGX_Accept_r(FCGX_Request * reqDataPtr)
{
if (!libInitialized) {
return -9998;
}
/* Finish the current request, if any. */
FCGX_Finish_r(reqDataPtr);
for (;;) {
/*
* If a connection isn't open, accept a new connection (blocking).
* If an OS error occurs in accepting the connection,
* return -1 to the caller, who should exit.
*/
if (reqDataPtr->ipcFd < 0) {
int fail_on_intr =
reqDataPtr->flags & FCGI_FAIL_ACCEPT_ON_INTR;
reqDataPtr->ipcFd =
OS_Accept(reqDataPtr->listen_sock, fail_on_intr,
webServerAddressList);
if (reqDataPtr->ipcFd < 0) {
return (errno > 0) ? (0 - errno) : -9999;
}
}
/*
* A connection is open. Read from the connection in order to
* get the request's role and environment. If protocol or other
* errors occur, close the connection and try again.
*/
reqDataPtr->isBeginProcessed = FALSE;
reqDataPtr->in = NewReader(reqDataPtr, 8192, 0);
FillBuffProc(reqDataPtr->in);
if (!reqDataPtr->isBeginProcessed) {
goto TryAgain;
}
{
char *roleStr;
switch (reqDataPtr->role) {
case FCGI_RESPONDER:
roleStr = "FCGI_ROLE=RESPONDER";
break;
case FCGI_AUTHORIZER:
roleStr = "FCGI_ROLE=AUTHORIZER";
break;
case FCGI_FILTER:
roleStr = "FCGI_ROLE=FILTER";
break;
default:
goto TryAgain;
}
reqDataPtr->paramsPtr = NewParams(30);
PutParam(reqDataPtr->paramsPtr, StringCopy(roleStr));
}
SetReaderType(reqDataPtr->in, FCGI_PARAMS);
if (ReadParams(reqDataPtr->paramsPtr, reqDataPtr->in) >= 0) {
/*
* Finished reading the environment. No errors occurred, so
* leave the connection-retry loop.
*/
break;
}
/*
* Close the connection and try again.
*/
TryAgain:
FCGX_Free(reqDataPtr, 1);
} /* for (;;) */
/*
* Build the remaining data structures representing the new
* request and return successfully to the caller.
*/
SetReaderType(reqDataPtr->in, FCGI_STDIN);
reqDataPtr->out = NewWriter(reqDataPtr, 8192, FCGI_STDOUT);
reqDataPtr->err = NewWriter(reqDataPtr, 512, FCGI_STDERR);
reqDataPtr->nWriters = 2;
reqDataPtr->envp = reqDataPtr->paramsPtr->vec;
return 0;
}
void FCGX_Finish(void)
{
FCGX_Finish_r(&the_request);
}
