int bridge_request_destroy(bridge_request_t *self)
{
json_object_put(self->response);
json_tokener_free(self->tokener);
FCGX_Free(&self->request, TRUE);
return 0;
}
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);
}
/*
*----------------------------------------------------------------------
*
* FCGX_Finish_r --
*
* Finishes the current request from the HTTP server.
*
* Side effects:
*
* Finishes the request accepted by (and frees any
* storage allocated by) the previous call to FCGX_Accept.
*
* 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.
*
*----------------------------------------------------------------------
*/
void FCGX_Finish_r(FCGX_Request * reqDataPtr)
{
int close;
if (reqDataPtr == NULL) {
return;
}
close = !reqDataPtr->keepConnection;
/* This should probably use a 'status' member instead of 'in' */
if (reqDataPtr->in) {
close |= FCGX_FClose(reqDataPtr->err);
close |= FCGX_FClose(reqDataPtr->out);
close |= FCGX_GetError(reqDataPtr->in);
}
FCGX_Free(reqDataPtr, close);
}
void
fastcgi_request_traits::destroy(FCGX_Request *req) {
FCGX_Free(req, 1);
}
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 (select(req->listen_sock+1, &readfds, NULL, NULL, NULL) < 1) {
return Qnil;
}
status = FCGX_Accept_r(req);
if (status >= 0) {
fcgi_data *data;
fcgi_stream_data *stream_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_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data);
stream_data->stream = req->in;
stream_data->req = obj;
data->out = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data);
stream_data->stream = req->out;
stream_data->req = obj;
data->err = Data_Make_Struct(cFCGIStream, fcgi_stream_data, fcgi_stream_mark, fcgi_stream_free, stream_data);
stream_data->stream = req->err;
stream_data->req = obj;
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 {
FCGX_Free(req, 1);
free(req);
return Qnil;
}
}
static void fcgi_free_req(fcgi_data *data)
{
FCGX_Free(data->req, 1);
free(data->req);
free(data);
}
~Worker4CloseThread(){
FCGX_Free(&request, 0);
}
/*
*----------------------------------------------------------------------
*
* 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* 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;
}
