X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=libfcgi%2Ffcgiapp.c;h=ff8df6b6029aa51ebfcaba6c628c7bedd835498d;hb=5215a48a265b9583234d1d3c105b0c1cfcf96d21;hp=896c6d2baf50be24f244074a3cdc1a7c2c613b73;hpb=ae0319bf3eaa1cd216b7078f13fff6b451d3cd4e;p=catagits%2Ffcgi2.git diff --git a/libfcgi/fcgiapp.c b/libfcgi/fcgiapp.c index 896c6d2..ff8df6b 100644 --- a/libfcgi/fcgiapp.c +++ b/libfcgi/fcgiapp.c @@ -10,41 +10,46 @@ * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * */ - #ifndef lint -static const char rcsid[] = "$Id: fcgiapp.c,v 1.5 1999/07/27 02:17:05 roberts Exp $"; +static const char rcsid[] = "$Id: fcgiapp.c,v 1.21 2001/06/18 14:25:09 robs Exp $"; #endif /* not lint */ -#ifdef _WIN32 -#define DLLAPI __declspec(dllexport) -#endif - +#include +#include +#include /* for fcntl */ +#include +#include /* for memchr() */ +#include #include +#include +#include #include + +#include "fcgi_config.h" + +#ifdef HAVE_SYS_SOCKET_H +#include /* for getpeername */ +#endif + #ifdef HAVE_SYS_TIME_H #include #endif -#include "fcgi_config.h" #ifdef HAVE_UNISTD_H #include #endif -#include -#include -#include -#include /* for memchr() */ -#include -#include -#include -#ifdef HAVE_SYS_SOCKET_H -#include /* for getpeername */ +#ifdef HAVE_LIMITS_H +#include +#endif + +#ifdef _WIN32 +#define DLLAPI __declspec(dllexport) #endif -#include /* for fcntl */ -#include "fcgimisc.h" #include "fcgiapp.h" -#include "fcgiappmisc.h" + +#include "fcgimisc.h" #include "fastcgi.h" #include "fcgios.h" @@ -59,15 +64,13 @@ static const char rcsid[] = "$Id: fcgiapp.c,v 1.5 1999/07/27 02:17:05 roberts Ex #define LONG_DOUBLE long double #endif - /* * Globals */ static int libInitialized = 0; +static int isFastCGI = -1; static char *webServerAddressList = NULL; -static FCGX_Request reqData; -static FCGX_Request *reqDataPtr = &reqData; - +static FCGX_Request the_request; static void *Malloc(size_t size) { @@ -79,7 +82,7 @@ static void *Malloc(size_t size) static char *StringCopy(char *str) { int strLen = strlen(str); - char *newString = Malloc(strLen + 1); + char *newString = (char *)Malloc(strLen + 1); memcpy(newString, str, strLen); newString[strLen] = '\000'; return newString; @@ -419,10 +422,11 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) f = (char *) format; fStop = f + strlen(f); while (f != fStop) { - percentPtr = memchr(f, '%', fStop - f); + percentPtr = (char *)memchr(f, '%', fStop - f); if(percentPtr == NULL) percentPtr = fStop; if(percentPtr != f) { - if(FCGX_PutStr(f, percentPtr - f, stream) < 0) goto ErrorReturn; + if(FCGX_PutStr(f, percentPtr - f, stream) < 0) + goto ErrorReturn; streamCount += percentPtr - f; f = percentPtr; if(f == fStop) break; @@ -478,7 +482,8 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) * Scan flags */ n = strspn(p, "-0+ #"); - if(n > 5) goto ErrorReturn; + if(n > 5) + goto ErrorReturn; CopyAndAdvance(&fmtBuffPtr, &p, n); /* * Scan minimum field width @@ -487,7 +492,8 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) if(n == 0) { if(*p == '*') { minWidth = va_arg(arg, int); - if(abs(minWidth) > 999999) goto ErrorReturn; + if(abs(minWidth) > 999999) + goto ErrorReturn; /* * The following use of strlen rather than the * value returned from sprintf is because SUNOS4 @@ -515,7 +521,8 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) if(*p == '*') { precision = va_arg(arg, int); if(precision < 0) precision = 0; - if(precision > 999999) goto ErrorReturn; + if(precision > 999999) + goto ErrorReturn; /* * The following use of strlen rather than the * value returned from sprintf is because SUNOS4 @@ -572,10 +579,11 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) break; case 's': charPtrArg = va_arg(arg, char *); + if (!charPtrArg) charPtrArg = "(null)"; if(precision == -1) { buffReqd = strlen(charPtrArg); } else { - p = memchr(charPtrArg, '\0', precision); + p = (char *)memchr(charPtrArg, '\0', precision); buffReqd = (p == NULL) ? precision : p - charPtrArg; } @@ -619,9 +627,10 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) } else { if(auxBuffPtr == NULL || buffReqd > auxBuffLen) { if(auxBuffPtr != NULL) free(auxBuffPtr); - auxBuffPtr = Malloc(buffReqd); + auxBuffPtr = (char *)Malloc(buffReqd); auxBuffLen = buffReqd; - if(auxBuffPtr == NULL) goto ErrorReturn; + if(auxBuffPtr == NULL) + goto ErrorReturn; } buffPtr = auxBuffPtr; buffLen = auxBuffLen; @@ -656,8 +665,8 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) buffCount = strlen(buffPtr); break; case 'h': - shortArg = va_arg(arg, short); - sprintf(buffPtr, fmtBuff, shortArg); + shortArg = (short) va_arg(arg, int); + sprintf(buffPtr, fmtBuff, shortArg); buffCount = strlen(buffPtr); break; default: @@ -680,8 +689,8 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) buffCount = strlen(buffPtr); break; case 'h': - uShortArg = va_arg(arg, unsigned short); - sprintf(buffPtr, fmtBuff, uShortArg); + uShortArg = (unsigned short) va_arg(arg, int); + sprintf(buffPtr, fmtBuff, uShortArg); buffCount = strlen(buffPtr); break; default: @@ -729,7 +738,8 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) } break; case 'p': - if(sizeModifier != ' ') goto ErrorReturn; + if(sizeModifier != ' ') + goto ErrorReturn; voidPtrArg = va_arg(arg, void *); sprintf(buffPtr, fmtBuff, voidPtrArg); buffCount = strlen(buffPtr); @@ -803,7 +813,8 @@ int FCGX_VFPrintF(FCGX_Stream *stream, const char *format, va_list arg) break; } /* switch(op) */ if(performedOp) break; - if(!fastPath) goto ErrorReturn; + if(!fastPath) + goto ErrorReturn; fastPath = FALSE; } /* for (;;) */ ASSERT(buffCount < buffLen); @@ -884,6 +895,8 @@ int FCGX_FFlush(FCGX_Stream *stream) */ int FCGX_FClose(FCGX_Stream *stream) { + if (stream == NULL) return 0; + if(!stream->wasFCloseCalled) { if(!stream->isReader) { stream->emptyBuffProc(stream, TRUE); @@ -993,8 +1006,8 @@ typedef Params *ParamsPtr; static ParamsPtr NewParams(int length) { ParamsPtr result; - result = Malloc(sizeof(Params)); - result->vec = (char **) Malloc(length * sizeof(char *)); + result = (Params *)Malloc(sizeof(Params)); + result->vec = (char **)Malloc(length * sizeof(char *)); result->length = length; result->cur = result->vec; *result->cur = NULL; @@ -1009,7 +1022,7 @@ static ParamsPtr NewParams(int length) * Frees a Params structure and all the parameters it contains. * * Side effects: - * paramsPtr becomes invalid. + * env becomes invalid. * *---------------------------------------------------------------------- */ @@ -1051,8 +1064,7 @@ static void PutParam(ParamsPtr paramsPtr, char *nameValue) size = paramsPtr->cur - paramsPtr->vec; if(size >= paramsPtr->length) { paramsPtr->length *= 2; - paramsPtr->vec = - realloc(paramsPtr->vec, paramsPtr->length * sizeof(char *)); + paramsPtr->vec = (FCGX_ParamArray)realloc(paramsPtr->vec, paramsPtr->length * sizeof(char *)); paramsPtr->cur = paramsPtr->vec + size; } *paramsPtr->cur = NULL; @@ -1075,9 +1087,12 @@ char *FCGX_GetParam(const char *name, FCGX_ParamArray envp) { int len; char **p; + + if (name == NULL || envp == NULL) return NULL; + len = strlen(name); - if(len == 0) return NULL; - for (p = envp; *p != NULL; p++) { + + for (p = envp; *p; ++p) { if((strncmp(name, *p, len) == 0) && ((*p)[len] == '=')) { return *p+len+1; } @@ -1138,7 +1153,7 @@ static int ReadParams(Params *paramsPtr, FCGX_Stream *stream) * nameLen and valueLen are now valid; read the name and value * from stream and construct a standard environment entry. */ - nameValue = Malloc(nameLen + valueLen + 2); + nameValue = (char *)Malloc(nameLen + valueLen + 2); if(FCGX_GetStr(nameValue, nameLen, stream) != nameLen) { SetError(stream, FCGX_PARAMS_ERROR); free(nameValue); @@ -1293,7 +1308,7 @@ typedef struct FCGX_Stream_Data { */ static void WriteCloseRecords(struct FCGX_Stream *stream) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; /* * Enter rawWrite mode so final records won't be encapsulated as * stream data. @@ -1353,7 +1368,7 @@ static int write_it_all(int fd, char *buf, int len) */ static void EmptyBuffProc(struct FCGX_Stream *stream, int doClose) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; int cLen, eLen; /* * If the buffer contains stream data, fill in the header. @@ -1421,7 +1436,7 @@ static void EmptyBuffProc(struct FCGX_Stream *stream, int doClose) */ static int ProcessManagementRecord(int type, FCGX_Stream *stream) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; ParamsPtr paramsPtr = NewParams(3); char **pPtr; char response[64]; /* 64 = 8 + 3*(1+1+14+1)* + padding */ @@ -1494,7 +1509,7 @@ static int ProcessManagementRecord(int type, FCGX_Stream *stream) */ static int ProcessBeginRecord(int requestId, FCGX_Stream *stream) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; FCGI_BeginRequestBody body; if(requestId == 0 || data->contentLen != sizeof(body)) { return FCGX_PROTOCOL_ERROR; @@ -1555,7 +1570,7 @@ static int ProcessBeginRecord(int requestId, FCGX_Stream *stream) */ static int ProcessHeader(FCGI_Header header, FCGX_Stream *stream) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; int requestId; if(header.version != FCGI_VERSION_1) { return FCGX_UNSUPPORTED_VERSION; @@ -1591,7 +1606,7 @@ static int ProcessHeader(FCGI_Header header, FCGX_Stream *stream) */ static void FillBuffProc(FCGX_Stream *stream) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; FCGI_Header header; int headerLen = 0; int status, count; @@ -1730,12 +1745,12 @@ static FCGX_Stream *NewStream( * but also data->buff and data->buffStop. This has implications * for procs that want to swap buffers, too. */ - FCGX_Stream *stream = Malloc(sizeof(FCGX_Stream)); - FCGX_Stream_Data *data = Malloc(sizeof(FCGX_Stream_Data)); + FCGX_Stream *stream = (FCGX_Stream *)Malloc(sizeof(FCGX_Stream)); + FCGX_Stream_Data *data = (FCGX_Stream_Data *)Malloc(sizeof(FCGX_Stream_Data)); data->reqDataPtr = reqDataPtr; bufflen = AlignInt8(min(max(bufflen, 32), FCGI_MAX_LENGTH + 1)); data->bufflen = bufflen; - data->mBuff = Malloc(bufflen); + data->mBuff = (unsigned char *)Malloc(bufflen); data->buff = AlignPtr8(data->mBuff); if(data->buff != data->mBuff) { data->bufflen -= 8; @@ -1793,7 +1808,7 @@ void FreeStream(FCGX_Stream **streamPtr) if(stream == NULL) { return; } - data = stream->data; + data = (FCGX_Stream_Data *)stream->data; data->reqDataPtr = NULL; free(data->mBuff); free(data); @@ -1812,7 +1827,7 @@ void FreeStream(FCGX_Stream **streamPtr) */ static FCGX_Stream *SetReaderType(FCGX_Stream *stream, int streamType) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; ASSERT(stream->isReader); data->type = streamType; data->eorStop = FALSE; @@ -1875,7 +1890,7 @@ FCGX_Stream *CreateWriter( int bufflen, int streamType) { - FCGX_Request *reqDataPtr = Malloc(sizeof(FCGX_Request)); + FCGX_Request *reqDataPtr = (FCGX_Request *)Malloc(sizeof(FCGX_Request)); reqDataPtr->ipcFd = ipcFd; reqDataPtr->requestId = requestId; /* @@ -1904,17 +1919,10 @@ FCGX_Stream *CreateWriter( * Results: * TRUE if the process is a CGI process, FALSE if FastCGI. * - * Side effects: - * If this is a FastCGI process there's a chance that a connection - * will be accepted while performing the test. If this occurs, - * the connection is saved and used later by the FCGX_Accept logic. - * *---------------------------------------------------------------------- */ int FCGX_IsCGI(void) { - static int isFastCGI = -1; - if (isFastCGI != -1) { return !isFastCGI; } @@ -1927,7 +1935,7 @@ int FCGX_IsCGI(void) } } - isFastCGI = OS_IsFcgi(); + isFastCGI = OS_IsFcgi(FCGI_LISTENSOCK_FILENO); return !isFastCGI; } @@ -1954,7 +1962,7 @@ int FCGX_IsCGI(void) void FCGX_Finish(void) { - FCGX_Finish_r(reqDataPtr); + FCGX_Finish_r(&the_request); } /* @@ -1982,35 +1990,61 @@ void FCGX_Finish_r(FCGX_Request *reqDataPtr) return; } - if (reqDataPtr->inStream) { - int errStatus = FCGX_FClose(reqDataPtr->errStream); - int outStatus = FCGX_FClose(reqDataPtr->outStream); + /* This should probably use a 'status' member instead of 'in' */ + if (reqDataPtr->in) { + int errStatus = FCGX_FClose(reqDataPtr->err); + int outStatus = FCGX_FClose(reqDataPtr->out); - if (errStatus || outStatus - || FCGX_GetError(reqDataPtr->inStream) - || !reqDataPtr->keepConnection) + if (errStatus || outStatus || FCGX_GetError(reqDataPtr->in)) { OS_IpcClose(reqDataPtr->ipcFd); + reqDataPtr->ipcFd = -1; } + } - ASSERT(reqDataPtr->nWriters == 0); + FCGX_Free(reqDataPtr); +} + +void FCGX_Free(FCGX_Request * request) +{ + if (request == NULL) + return; - FreeStream(&reqDataPtr->inStream); - FreeStream(&reqDataPtr->outStream); - FreeStream(&reqDataPtr->errStream); + FreeStream(&request->in); + FreeStream(&request->out); + FreeStream(&request->err); + FreeParams(&request->paramsPtr); - FreeParams(&reqDataPtr->paramsPtr); + if (!request->keepConnection) + { + OS_IpcClose(request->ipcFd); + request->ipcFd = -1; } +} - if (!reqDataPtr->keepConnection) { - reqDataPtr->ipcFd = -1; +int FCGX_OpenSocket(const char *path, int backlog) +{ + int rc = OS_CreateLocalIpcFd(path, backlog); + if (rc == FCGI_LISTENSOCK_FILENO && isFastCGI == 0) { + /* XXX probably need to call OS_LibInit() again for Win */ + isFastCGI = 1; } + return rc; } - -void FCGX_InitRequest(FCGX_Request *request) +int FCGX_InitRequest(FCGX_Request *request, int sock, int flags) { memset(request, 0, sizeof(FCGX_Request)); + + /* @@@ Should check that sock is open and listening */ + request->listen_sock = sock; + + /* @@@ Should validate against "known" flags */ + request->flags = flags; + + request->ipcFd = -1; + + return 0; } /* @@ -2037,14 +2071,14 @@ int FCGX_Init(void) /* If our compiler doesn't play by the ISO rules for struct layout, halt. */ ASSERT(sizeof(FCGI_Header) == FCGI_HEADER_LEN); - FCGX_InitRequest(&reqData); + FCGX_InitRequest(&the_request, FCGI_LISTENSOCK_FILENO, 0); if (OS_LibInit(NULL) == -1) { return OS_Errno ? OS_Errno : -9997; } p = getenv("FCGI_WEB_SERVER_ADDRS"); - webServerAddressList = p ? StringCopy(p) : ""; + webServerAddressList = p ? StringCopy(p) : NULL; libInitialized = 1; return 0; @@ -2084,14 +2118,22 @@ int FCGX_Accept( FCGX_Stream **err, FCGX_ParamArray *envp) { + int rc; + if (!libInitialized) { - int rc = FCGX_Init(); - if (rc) { + if ((rc = FCGX_Init())) { return (rc < 0) ? rc : -rc; } } - return FCGX_Accept_r(in, out, err, envp, &reqData); + rc = FCGX_Accept_r(&the_request); + + *in = the_request.in; + *out = the_request.out; + *err = the_request.err; + *envp = the_request.envp; + + return rc; } /* @@ -2121,12 +2163,7 @@ int FCGX_Accept( * *---------------------------------------------------------------------- */ -int FCGX_Accept_r( - FCGX_Stream **in, - FCGX_Stream **out, - FCGX_Stream **err, - FCGX_ParamArray *envp, - FCGX_Request *reqDataPtr) +int FCGX_Accept_r(FCGX_Request *reqDataPtr) { if (!libInitialized) { return -9998; @@ -2142,7 +2179,9 @@ int FCGX_Accept_r( * return -1 to the caller, who should exit. */ if (reqDataPtr->ipcFd < 0) { - reqDataPtr->ipcFd = OS_FcgiIpcAccept(webServerAddressList); + 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; } @@ -2153,8 +2192,8 @@ int FCGX_Accept_r( * errors occur, close the connection and try again. */ reqDataPtr->isBeginProcessed = FALSE; - reqDataPtr->inStream = NewReader(reqDataPtr, 8192, 0); - FillBuffProc(reqDataPtr->inStream); + reqDataPtr->in = NewReader(reqDataPtr, 8192, 0); + FillBuffProc(reqDataPtr->in); if(!reqDataPtr->isBeginProcessed) { goto TryAgain; } @@ -2176,35 +2215,31 @@ int FCGX_Accept_r( reqDataPtr->paramsPtr = NewParams(30); PutParam(reqDataPtr->paramsPtr, StringCopy(roleStr)); } - SetReaderType(reqDataPtr->inStream, FCGI_PARAMS); - if(ReadParams(reqDataPtr->paramsPtr, reqDataPtr->inStream) >= 0) { + 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: - FreeParams(&reqDataPtr->paramsPtr); - FreeStream(&reqDataPtr->inStream); - OS_Close(reqDataPtr->ipcFd); - reqDataPtr->ipcFd = -1; +TryAgain: + FCGX_Free(reqDataPtr); + } /* for (;;) */ /* * Build the remaining data structures representing the new * request and return successfully to the caller. */ - SetReaderType(reqDataPtr->inStream, FCGI_STDIN); - reqDataPtr->outStream = NewWriter(reqDataPtr, 8192, FCGI_STDOUT); - reqDataPtr->errStream = NewWriter(reqDataPtr, 512, FCGI_STDERR); + SetReaderType(reqDataPtr->in, FCGI_STDIN); + reqDataPtr->out = NewWriter(reqDataPtr, 8192, FCGI_STDOUT); + reqDataPtr->err = NewWriter(reqDataPtr, 512, FCGI_STDERR); reqDataPtr->nWriters = 2; - *in = reqDataPtr->inStream; - *out = reqDataPtr->outStream; - *err = reqDataPtr->errStream; - *envp = reqDataPtr->paramsPtr->vec; + reqDataPtr->envp = reqDataPtr->paramsPtr->vec; return 0; } @@ -2228,7 +2263,7 @@ int FCGX_Accept_r( int FCGX_StartFilterData(FCGX_Stream *stream) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; if(data->reqDataPtr->role != FCGI_FILTER || !stream->isReader || !stream->isClosed @@ -2236,7 +2271,7 @@ int FCGX_StartFilterData(FCGX_Stream *stream) SetError(stream, FCGX_CALL_SEQ_ERROR); return -1; } - SetReaderType(reqDataPtr->inStream, FCGI_DATA); + SetReaderType(stream, FCGI_DATA); return 0; } @@ -2256,7 +2291,7 @@ int FCGX_StartFilterData(FCGX_Stream *stream) void FCGX_SetExitStatus(int status, FCGX_Stream *stream) { - FCGX_Stream_Data *data = stream->data; + FCGX_Stream_Data *data = (FCGX_Stream_Data *)stream->data; data->reqDataPtr->appStatus = status; }