The Tor Browser: security/nss/cmd/httpserv/httpserv.c@141e0f1194b1 (annotated)

security/nss/cmd/httpserv/httpserv.c@141e0f1194b1 (annotated)

security/nss/cmd/httpserv/httpserv.c

Wed, 31 Dec 2014 07:16:47 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:16:47 +0100
branch: TOR_BUG_9701
changeset 3: 141e0f1194b1
permissions: -rw-r--r--

Revert simplistic fix pending revisit of Mozilla integration attempt.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <stdio.h>
 #include <string.h>
 #include "secutil.h"
 #if defined(XP_UNIX)
 #include <unistd.h>
 #endif
 #if defined(_WINDOWS)
 #include <process.h>	/* for getpid() */
 #endif
 #include <signal.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include "nspr.h"
 #include "prio.h"
 #include "prerror.h"
 #include "prnetdb.h"
 #include "prclist.h"
 #include "plgetopt.h"
 #include "pk11func.h"
 #include "nss.h"
 #include "nssb64.h"
 #include "sechash.h"
 #include "cert.h"
 #include "certdb.h"
 #include "ocsp.h"
 #include "ocspti.h"
 #include "ocspi.h"
 #ifndef PORT_Sprintf
 #define PORT_Sprintf sprintf
 #endif
 #ifndef PORT_Strstr
 #define PORT_Strstr strstr
 #endif
 #ifndef PORT_Malloc
 #define PORT_Malloc PR_Malloc
 #endif
 static int handle_connection( PRFileDesc *, PRFileDesc *, int );
 /* data and structures for shutdown */
 static int	stopping;
 static PRBool  noDelay;
 static int	verbose;
 static PRThread * acceptorThread;
 static PRLogModuleInfo *lm;
 #define PRINTF  if (verbose)  printf
 #define FPRINTF if (verbose) fprintf
 #define FLUSH	if (verbose) { fflush(stdout); fflush(stderr); }
 #define VLOG(arg) PR_LOG(lm,PR_LOG_DEBUG,arg)
 static void
 Usage(const char *progName)
 {
     fprintf(stderr,
 "Usage: %s -p port [-Dbv]\n"
 "         [-t threads] [-i pid_file]\n"
 "         [-A nickname -C crl-filename]... [-O method]\n"
 "         [-d dbdir] [-f password_file] [-w password] [-P dbprefix]\n"
 "-D means disable Nagle delays in TCP\n"
 "-b means try binding to the port and exit\n"
 "-v means verbose output\n"
 "-t threads -- specify the number of threads to use for connections.\n"
 "-i pid_file file to write the process id of httpserv\n"
 "Parameters -A, -C and -O are used to provide an OCSP server at /ocsp?\n"
 "-A a nickname of a CA certificate\n"
 "-C a CRL filename corresponding to the preceding CA nickname\n"
 "-O allowed HTTP methods for OCSP requests: get, post, all, random, get-unknown\n"
 "   random means: randomly fail if request method is GET, POST always works\n"
 "   get-unknown means: status unknown for GET, correct status for POST\n"
 "Multiple pairs of parameters -A and -C are allowed.\n"
 "If status for a cert from an unknown CA is requested, the cert from the\n"
 "first -A parameter will be used to sign the unknown status response.\n"
 "NSS database parameters are used only if OCSP parameters are used.\n"
 	,progName);
 }
 static const char *
 errWarn(char * funcString)
 {
     PRErrorCode  perr      = PR_GetError();
     const char * errString = SECU_Strerror(perr);
     fprintf(stderr, "httpserv: %s returned error %d:\n%s\n",
             funcString, perr, errString);
     return errString;
 }
 static void
 errExit(char * funcString)
 {
     errWarn(funcString);
     exit(3);
 }
 #define MAX_VIRT_SERVER_NAME_ARRAY_INDEX  10
 /**************************************************************************
 ** Begin thread management routines and data.
 **************************************************************************/
 #define MIN_THREADS 3
 #define DEFAULT_THREADS 8
 #define MAX_THREADS 4096
 #define MAX_PROCS 25
 static int  maxThreads = DEFAULT_THREADS;
 typedef struct jobStr {
     PRCList     link;
     PRFileDesc *tcp_sock;
     PRFileDesc *model_sock;
     int         requestCert;
 } JOB;
 static PZLock    * qLock; /* this lock protects all data immediately below */
 static PRLock    * lastLoadedCrlLock; /* this lock protects lastLoadedCrl variable */
 static PZCondVar * jobQNotEmptyCv;
 static PZCondVar * freeListNotEmptyCv;
 static PZCondVar * threadCountChangeCv;
 static int  threadCount;
 static PRCList  jobQ;
 static PRCList  freeJobs;
 static JOB *jobTable;
 SECStatus
 setupJobs(int maxJobs)
 {
     int i;
     jobTable = (JOB *)PR_Calloc(maxJobs, sizeof(JOB));
     if (!jobTable)
     	return SECFailure;
     PR_INIT_CLIST(&jobQ);
     PR_INIT_CLIST(&freeJobs);
     for (i = 0; i < maxJobs; ++i) {
 	JOB * pJob = jobTable + i;
 	PR_APPEND_LINK(&pJob->link, &freeJobs);
     }
     return SECSuccess;
 }
 typedef int startFn(PRFileDesc *a, PRFileDesc *b, int c);
 typedef enum { rs_idle = 0, rs_running = 1, rs_zombie = 2 } runState;
 typedef struct perThreadStr {
     PRFileDesc *a;
     PRFileDesc *b;
     int         c;
     int         rv;
     startFn  *  startFunc;
     PRThread *  prThread;
     runState	state;
 } perThread;
 static perThread *threads;
 void
 thread_wrapper(void * arg)
 {
     perThread * slot = (perThread *)arg;
     slot->rv = (* slot->startFunc)(slot->a, slot->b, slot->c);
     /* notify the thread exit handler. */
     PZ_Lock(qLock);
     slot->state = rs_zombie;
     --threadCount;
     PZ_NotifyAllCondVar(threadCountChangeCv);
     PZ_Unlock(qLock);
 }
 int
 jobLoop(PRFileDesc *a, PRFileDesc *b, int c)
 {
     PRCList * myLink = 0;
     JOB     * myJob;
     PZ_Lock(qLock);
     do {
 	myLink = 0;
 	while (PR_CLIST_IS_EMPTY(&jobQ) && !stopping) {
             PZ_WaitCondVar(jobQNotEmptyCv, PR_INTERVAL_NO_TIMEOUT);
 	}
 	if (!PR_CLIST_IS_EMPTY(&jobQ)) {
 	    myLink = PR_LIST_HEAD(&jobQ);
 	    PR_REMOVE_AND_INIT_LINK(myLink);
 	}
 	PZ_Unlock(qLock);
 	myJob = (JOB *)myLink;
 	/* myJob will be null when stopping is true and jobQ is empty */
 	if (!myJob)
 	    break;
 	handle_connection( myJob->tcp_sock, myJob->model_sock,
 			   myJob->requestCert);
 	PZ_Lock(qLock);
 	PR_APPEND_LINK(myLink, &freeJobs);
 	PZ_NotifyCondVar(freeListNotEmptyCv);
     } while (PR_TRUE);
     return 0;
 }
 SECStatus
 launch_threads(
     startFn    *startFunc,
     PRFileDesc *a,
     PRFileDesc *b,
     int         c,
     PRBool      local)
 {
     int i;
     SECStatus rv = SECSuccess;
     /* create the thread management serialization structs */
     qLock               = PZ_NewLock(nssILockSelfServ);
     jobQNotEmptyCv      = PZ_NewCondVar(qLock);
     freeListNotEmptyCv  = PZ_NewCondVar(qLock);
     threadCountChangeCv = PZ_NewCondVar(qLock);
     /* create monitor for crl reload procedure */
     lastLoadedCrlLock   = PR_NewLock();
     /* allocate the array of thread slots */
     threads = PR_Calloc(maxThreads, sizeof(perThread));
     if ( NULL == threads )  {
         fprintf(stderr, "Oh Drat! Can't allocate the perThread array\n");
         return SECFailure;
     }
     /* 5 is a little extra, intended to keep the jobQ from underflowing.
     ** That is, from going empty while not stopping and clients are still
     ** trying to contact us.
     */
     rv = setupJobs(maxThreads + 5);
     if (rv != SECSuccess)
     	return rv;
     PZ_Lock(qLock);
     for (i = 0; i < maxThreads; ++i) {
     	perThread * slot = threads + i;
 	slot->state = rs_running;
 	slot->a = a;
 	slot->b = b;
 	slot->c = c;
 	slot->startFunc = startFunc;
 	slot->prThread = PR_CreateThread(PR_USER_THREAD,
 			thread_wrapper, slot, PR_PRIORITY_NORMAL,
                         (PR_TRUE==local)?PR_LOCAL_THREAD:PR_GLOBAL_THREAD,
                         PR_UNJOINABLE_THREAD, 0);
 	if (slot->prThread == NULL) {
 	    printf("httpserv: Failed to launch thread!\n");
 	    slot->state = rs_idle;
 	    rv = SECFailure;
 	    break;
 	}
 	++threadCount;
     }
     PZ_Unlock(qLock);
     return rv;
 }
 #define DESTROY_CONDVAR(name) if (name) { \
         PZ_DestroyCondVar(name); name = NULL; }
 #define DESTROY_LOCK(name) if (name) { \
         PZ_DestroyLock(name); name = NULL; }
 void
 terminateWorkerThreads(void)
 {
     VLOG(("httpserv: server_thead: waiting on stopping"));
     PZ_Lock(qLock);
     PZ_NotifyAllCondVar(jobQNotEmptyCv);
     while (threadCount > 0) {
 	PZ_WaitCondVar(threadCountChangeCv, PR_INTERVAL_NO_TIMEOUT);
     }
     /* The worker threads empty the jobQ before they terminate. */
     PORT_Assert(PR_CLIST_IS_EMPTY(&jobQ));
     PZ_Unlock(qLock);
     DESTROY_CONDVAR(jobQNotEmptyCv);
     DESTROY_CONDVAR(freeListNotEmptyCv);
     DESTROY_CONDVAR(threadCountChangeCv);
     PR_DestroyLock(lastLoadedCrlLock);
     DESTROY_LOCK(qLock);
     PR_Free(jobTable);
     PR_Free(threads);
 }
 /**************************************************************************
 ** End   thread management routines.
 **************************************************************************/
 PRBool NoReuse         = PR_FALSE;
 PRBool disableLocking  = PR_FALSE;
 static secuPWData  pwdata = { PW_NONE, 0 };
 struct caRevoInfoStr
 {
     PRCList link;
     char *nickname;
     char *crlFilename;
     CERTCertificate *cert;
     CERTOCSPCertID *id;
     CERTSignedCrl *crl;
 };
 typedef struct caRevoInfoStr caRevoInfo;
 /* Created during app init. No locks necessary,
  * because later on, only read access will occur. */
 static caRevoInfo *caRevoInfos = NULL;
 static enum {
   ocspGetOnly, ocspPostOnly, ocspGetAndPost, ocspRandomGetFailure, ocspGetUnknown
 } ocspMethodsAllowed = ocspGetAndPost;
 static const char stopCmd[] = { "GET /stop " };
 static const char getCmd[]  = { "GET " };
 static const char EOFmsg[]  = { "EOF\r\n\r\n\r\n" };
 static const char outHeader[] = {
     "HTTP/1.0 200 OK\r\n"
     "Server: Generic Web Server\r\n"
     "Date: Tue, 26 Aug 1997 22:10:05 GMT\r\n"
     "Content-type: text/plain\r\n"
     "\r\n"
 };
 static const char outOcspHeader[] = {
     "HTTP/1.0 200 OK\r\n"
     "Server: Generic OCSP Server\r\n"
     "Content-type: application/ocsp-response\r\n"
     "\r\n"
 };
 static const char outBadRequestHeader[] = {
     "HTTP/1.0 400 Bad Request\r\n"
     "Server: Generic OCSP Server\r\n"
     "\r\n"
 };
 void stop_server()
 {
     stopping = 1;
     PR_Interrupt(acceptorThread);
     PZ_TraceFlush();
 }
 /* Will only work if the original input to url encoding was
  * a base64 encoded buffer. Will only decode the sequences used
  * for encoding the special base64 characters, and fail if any
  * other encoded chars are found.
  * Will return SECSuccess if input could be processed.
  * Coversion is done in place.
  */
 static SECStatus
 urldecode_base64chars_inplace(char *buf)
 {
     char *walk;
     size_t remaining_bytes;
     if (!buf || !*buf)
 	return SECFailure;
     walk = buf;
     remaining_bytes = strlen(buf) + 1; /* include terminator */
     while (*walk) {
 	if (*walk == '%') {
 	    if (!PL_strncasecmp(walk, "%2B", 3)) {
 		*walk = '+';
 	    } else if (!PL_strncasecmp(walk, "%2F", 3)) {
 		*walk = '/';
 	    } else if (!PL_strncasecmp(walk, "%3D", 3)) {
 		*walk = '=';
 	    } else {
 		return SECFailure;
 	    }
 	    remaining_bytes -= 3;
 	    ++walk;
 	    memmove(walk, walk+2, remaining_bytes);
 	} else {
 	    ++walk;
 	    --remaining_bytes;
 	}
     }
     return SECSuccess;
 }
 int
 handle_connection(
     PRFileDesc *tcp_sock,
     PRFileDesc *model_sock,
     int         requestCert
     )
 {
     PRFileDesc *       ssl_sock = NULL;
     PRFileDesc *       local_file_fd = NULL;
     char  *            pBuf;			/* unused space at end of buf */
     const char *       errString;
     PRStatus           status;
     int                bufRem;			/* unused bytes at end of buf */
     int                bufDat;			/* characters received in buf */
     int                newln    = 0;		/* # of consecutive newlns */
     int                firstTime = 1;
     int                reqLen;
     int                rv;
     int                numIOVs;
     PRSocketOptionData opt;
     PRIOVec            iovs[16];
     char               msgBuf[160];
     char               buf[10240];
     char               fileName[513];
     char *getData = NULL; /* inplace conversion */
     SECItem postData;
     PRBool isOcspRequest = PR_FALSE;
     PRBool isPost;
     postData.data = NULL;
     postData.len = 0;
     pBuf   = buf;
     bufRem = sizeof buf;
     VLOG(("httpserv: handle_connection: starting"));
     opt.option             = PR_SockOpt_Nonblocking;
     opt.value.non_blocking = PR_FALSE;
     PR_SetSocketOption(tcp_sock, &opt);
     VLOG(("httpserv: handle_connection: starting\n"));
 	ssl_sock = tcp_sock;
     if (noDelay) {
 	opt.option         = PR_SockOpt_NoDelay;
 	opt.value.no_delay = PR_TRUE;
 	status = PR_SetSocketOption(ssl_sock, &opt);
 	if (status != PR_SUCCESS) {
 	    errWarn("PR_SetSocketOption(PR_SockOpt_NoDelay, PR_TRUE)");
             if (ssl_sock) {
 	        PR_Close(ssl_sock);
             }
 	    return SECFailure;
 	}
     }
     while (1) {
 	const char *post;
 	const char *foundStr = NULL;
 	const char *tmp = NULL;
 	newln = 0;
 	reqLen = 0;
 	rv = PR_Read(ssl_sock, pBuf, bufRem - 1);
 	if (rv == 0 ||
 	    (rv < 0 && PR_END_OF_FILE_ERROR == PR_GetError())) {
 	    if (verbose)
 		errWarn("HDX PR_Read hit EOF");
 	    break;
 	}
 	if (rv < 0) {
 	    errWarn("HDX PR_Read");
 	    goto cleanup;
 	}
 	/* NULL termination */
 	pBuf[rv] = 0;
 	if (firstTime) {
 	    firstTime = 0;
 	}
 	pBuf   += rv;
 	bufRem -= rv;
 	bufDat = pBuf - buf;
 	/* Parse the input, starting at the beginning of the buffer.
 	 * Stop when we detect two consecutive \n's (or \r\n's)
 	 * as this signifies the end of the GET or POST portion.
 	 * The posted data follows.
 	 */
 	while (reqLen < bufDat && newln < 2) {
 	    int octet = buf[reqLen++];
 	    if (octet == '\n') {
 		newln++;
 	    } else if (octet != '\r') {
 		newln = 0;
 	    }
 	}
 	/* came to the end of the buffer, or second newln
 	 * If we didn't get an empty line (CRLFCRLF) then keep on reading.
 	 */
 	if (newln < 2)
 	    continue;
 	/* we're at the end of the HTTP request.
 	 * If the request is a POST, then there will be one more
 	 * line of data.
 	 * This parsing is a hack, but ok for SSL test purposes.
 	 */
 	post = PORT_Strstr(buf, "POST ");
 	if (!post || *post != 'P')
 	    break;
 	postData.data = (void*)(buf + reqLen);
 	tmp = "content-length: ";
 	foundStr = PL_strcasestr(buf, tmp);
 	if (foundStr) {
 	    int expectedPostLen;
 	    int havePostLen;
 	    expectedPostLen = atoi(foundStr+strlen(tmp));
 	    havePostLen = bufDat - reqLen;
 	    if (havePostLen >= expectedPostLen) {
 		postData.len = expectedPostLen;
 		break;
 	    }
 	} else {
 	    /* use legacy hack */
 	    /* It's a post, so look for the next and final CR/LF. */
 	    while (reqLen < bufDat && newln < 3) {
 		int octet = buf[reqLen++];
 		if (octet == '\n') {
 		    newln++;
 		}
 	    }
 	    if (newln == 3)
 		break;
 	}
     } /* read loop */
     bufDat = pBuf - buf;
     if (bufDat) do {	/* just close if no data */
 	/* Have either (a) a complete get, (b) a complete post, (c) EOF */
 	if (reqLen > 0) {
 	    PRBool isGetOrPost = PR_FALSE;
 	    unsigned skipChars = 0;
 	    isPost = PR_FALSE;
 	    if (!strncmp(buf, getCmd, sizeof getCmd - 1)) {
 		isGetOrPost = PR_TRUE;
 		skipChars = 4;
 	    }
 	    else if (!strncmp(buf, "POST ", 5)) {
 		isGetOrPost = PR_TRUE;
 		isPost = PR_TRUE;
 		skipChars = 5;
 	    }
 	    if (isGetOrPost) {
 		char *      fnBegin = buf;
 		char *      fnEnd;
 		char *      fnstart = NULL;
 		PRFileInfo  info;
 		fnBegin += skipChars;
 		fnEnd = strpbrk(fnBegin, " \r\n");
 		if (fnEnd) {
 		    int fnLen = fnEnd - fnBegin;
 		    if (fnLen < sizeof fileName) {
 			strncpy(fileName, fnBegin, fnLen);
 			fileName[fnLen] = 0;	/* null terminate */
 			fnstart = fileName;
 			/* strip initial / because our root is the current directory*/
 			while (*fnstart && *fnstart=='/')
 			    ++fnstart;
 		    }
 		}
 		if (fnstart) {
 		    if (!strncmp(fnstart, "ocsp", 4)) {
 			if (isPost) {
 			    if (postData.data) {
 				isOcspRequest = PR_TRUE;
 			    }
 			} else {
 			    if (!strncmp(fnstart, "ocsp/", 5)) {
 				isOcspRequest = PR_TRUE;
 				getData = fnstart + 5;
 			    }
 			}
 		    } else {
 			/* try to open the file named.
 			* If successful, then write it to the client.
 			*/
 			status = PR_GetFileInfo(fnstart, &info);
 			if (status == PR_SUCCESS &&
 			    info.type == PR_FILE_FILE &&
 			    info.size >= 0 ) {
 			    local_file_fd = PR_Open(fnstart, PR_RDONLY, 0);
 			}
 		    }
 		}
 	    }
 	}
 	numIOVs = 0;
 	iovs[numIOVs].iov_base = (char *)outHeader;
 	iovs[numIOVs].iov_len  = (sizeof(outHeader)) - 1;
 	numIOVs++;
 	if (isOcspRequest && caRevoInfos) {
 	    CERTOCSPRequest *request = NULL;
 	    PRBool failThisRequest = PR_FALSE;
 	    if (ocspMethodsAllowed == ocspGetOnly && postData.len) {
 		failThisRequest = PR_TRUE;
 	    } else if (ocspMethodsAllowed == ocspPostOnly && getData) {
 		failThisRequest = PR_TRUE;
 	    } else if (ocspMethodsAllowed == ocspRandomGetFailure && getData) {
 		if (!(rand() % 2)) {
 		    failThisRequest = PR_TRUE;
 		}
 	    }
 	    if (failThisRequest) {
 		PR_Write(ssl_sock, outBadRequestHeader, strlen(outBadRequestHeader));
 		break;
 	    }
 	    /* get is base64, post is binary.
 	     * If we have base64, convert into the (empty) postData array.
 	     */
 	    if (getData) {
 		if (urldecode_base64chars_inplace(getData) == SECSuccess) {
 		    NSSBase64_DecodeBuffer(NULL, &postData, getData, strlen(getData));
 		}
 	    }
 	    if (postData.len) {
 		request = CERT_DecodeOCSPRequest(&postData);
 	    }
 	    if (!request || !request->tbsRequest ||
 	        !request->tbsRequest->requestList ||
 	        !request->tbsRequest->requestList[0]) {
 		PORT_Sprintf(msgBuf, "Cannot decode OCSP request.\r\n");
 		iovs[numIOVs].iov_base = msgBuf;
 		iovs[numIOVs].iov_len  = PORT_Strlen(msgBuf);
 		numIOVs++;
 	    } else {
 	      /* TODO: support more than one request entry */
 	      CERTOCSPCertID *reqid = request->tbsRequest->requestList[0]->reqCert;
 	      const caRevoInfo *revoInfo = NULL;
 	      PRBool unknown = PR_FALSE;
 	      PRBool revoked = PR_FALSE;
 	      PRTime nextUpdate = 0;
 	      PRTime revoDate = 0;
 	      PRCList *caRevoIter;
 	      caRevoIter = &caRevoInfos->link;
 	      do {
 		  CERTOCSPCertID *caid;
 		  revoInfo = (caRevoInfo*)caRevoIter;
 		  caid = revoInfo->id;
 		  if (SECOID_CompareAlgorithmID(&reqid->hashAlgorithm,
 		                                &caid->hashAlgorithm) == SECEqual
 		      &&
 		      SECITEM_CompareItem(&reqid->issuerNameHash,
 					  &caid->issuerNameHash) == SECEqual
 		      &&
 		      SECITEM_CompareItem(&reqid->issuerKeyHash,
 					  &caid->issuerKeyHash) == SECEqual) {
 		      break;
 		  }
 		  revoInfo = NULL;
 		  caRevoIter = PR_NEXT_LINK(caRevoIter);
 	      } while (caRevoIter != &caRevoInfos->link);
 	      if (!revoInfo) {
 		  unknown = PR_TRUE;
 		  revoInfo = caRevoInfos;
 	      } else {
 		  CERTCrl *crl = &revoInfo->crl->crl;
 		  CERTCrlEntry *entry = NULL;
 		  DER_DecodeTimeChoice(&nextUpdate, &crl->nextUpdate);
 		  if (crl->entries) {
 		      int iv = 0;
 		      /* assign, not compare */
 		      while ((entry = crl->entries[iv++])) {
 			  if (SECITEM_CompareItem(&reqid->serialNumber,
 						  &entry->serialNumber) == SECEqual) {
 			      break;
 			  }
 		      }
 		  }
 		  if (entry) {
 		      /* revoked status response */
 		      revoked = PR_TRUE;
 		      DER_DecodeTimeChoice(&revoDate, &entry->revocationDate);
 		  } else {
 		      /* else good status response */
 		      if (!isPost && ocspMethodsAllowed == ocspGetUnknown) {
 			  unknown = PR_TRUE;
 			  nextUpdate = PR_Now() + 60*60*24 * PR_USEC_PER_SEC; /*tomorrow*/
 			  revoDate = PR_Now() - 60*60*24 * PR_USEC_PER_SEC; /*yesterday*/
 		      }
 		  }
 	      }
 	      {
 		  PRTime now = PR_Now();
 		  PLArenaPool *arena = NULL;
 		  CERTOCSPSingleResponse *sr;
 		  CERTOCSPSingleResponse **singleResponses;
 		  SECItem *ocspResponse;
 		  arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
 		  if (unknown) {
 		      sr = CERT_CreateOCSPSingleResponseUnknown(arena, reqid, now,
 								&nextUpdate);
 		  } else if (revoked) {
 		      sr = CERT_CreateOCSPSingleResponseRevoked(arena, reqid, now,
 			  &nextUpdate, revoDate, NULL);
 		  } else {
 		      sr = CERT_CreateOCSPSingleResponseGood(arena, reqid, now,
 							    &nextUpdate);
 		  }
 		  /* meaning of value 2: one entry + one end marker */
 		  singleResponses = PORT_ArenaNewArray(arena, CERTOCSPSingleResponse*, 2);
 		  singleResponses[0] = sr;
 		  singleResponses[1] = NULL;
 		  ocspResponse = CERT_CreateEncodedOCSPSuccessResponse(arena,
 				      revoInfo->cert, ocspResponderID_byName, now,
 				      singleResponses, &pwdata);
 		  if (!ocspResponse) {
 		      PORT_Sprintf(msgBuf, "Failed to encode response\r\n");
 		      iovs[numIOVs].iov_base = msgBuf;
 		      iovs[numIOVs].iov_len  = PORT_Strlen(msgBuf);
 		      numIOVs++;
 		  } else {
 		      PR_Write(ssl_sock, outOcspHeader, strlen(outOcspHeader));
 		      PR_Write(ssl_sock, ocspResponse->data, ocspResponse->len);
 		      PORT_FreeArena(arena, PR_FALSE);
 		  }
 	      }
 	      break;
 	    }
 	} else if (local_file_fd) {
 	    PRInt32     bytes;
 	    int         errLen;
             bytes = PR_TransmitFile(ssl_sock, local_file_fd, outHeader,
                                     sizeof outHeader - 1,
                                     PR_TRANSMITFILE_KEEP_OPEN,
                                     PR_INTERVAL_NO_TIMEOUT);
             if (bytes >= 0) {
                 bytes -= sizeof outHeader - 1;
                 FPRINTF(stderr,
                         "httpserv: PR_TransmitFile wrote %d bytes from %s\n",
                         bytes, fileName);
                 break;
             }
             errString = errWarn("PR_TransmitFile");
             errLen = PORT_Strlen(errString);
             errLen = PR_MIN(errLen, sizeof msgBuf - 1);
             PORT_Memcpy(msgBuf, errString, errLen);
             msgBuf[errLen] = 0;
             iovs[numIOVs].iov_base = msgBuf;
             iovs[numIOVs].iov_len  = PORT_Strlen(msgBuf);
             numIOVs++;
 	} else if (reqLen <= 0) {	/* hit eof */
 	    PORT_Sprintf(msgBuf, "Get or Post incomplete after %d bytes.\r\n",
 			 bufDat);
 	    iovs[numIOVs].iov_base = msgBuf;
 	    iovs[numIOVs].iov_len  = PORT_Strlen(msgBuf);
 	    numIOVs++;
 	} else if (reqLen < bufDat) {
 	    PORT_Sprintf(msgBuf, "Discarded %d characters.\r\n",
 	                 bufDat - reqLen);
 	    iovs[numIOVs].iov_base = msgBuf;
 	    iovs[numIOVs].iov_len  = PORT_Strlen(msgBuf);
 	    numIOVs++;
 	}
 	if (reqLen > 0) {
 	    if (verbose > 1)
 	    	fwrite(buf, 1, reqLen, stdout);	/* display it */
 	    iovs[numIOVs].iov_base = buf;
 	    iovs[numIOVs].iov_len  = reqLen;
 	    numIOVs++;
 	}
 	rv = PR_Writev(ssl_sock, iovs, numIOVs, PR_INTERVAL_NO_TIMEOUT);
 	if (rv < 0) {
 	    errWarn("PR_Writev");
 	    break;
 	}
     } while (0);
 cleanup:
     if (ssl_sock) {
         PR_Close(ssl_sock);
     } else if (tcp_sock) {
         PR_Close(tcp_sock);
     }
     if (local_file_fd)
 	PR_Close(local_file_fd);
     VLOG(("httpserv: handle_connection: exiting\n"));
     /* do a nice shutdown if asked. */
     if (!strncmp(buf, stopCmd, sizeof stopCmd - 1)) {
         VLOG(("httpserv: handle_connection: stop command"));
         stop_server();
     }
     VLOG(("httpserv: handle_connection: exiting"));
     return SECSuccess;	/* success */
 }
 #ifdef XP_UNIX
 void sigusr1_handler(int sig)
 {
     VLOG(("httpserv: sigusr1_handler: stop server"));
     stop_server();
 }
 #endif
 SECStatus
 do_accepts(
     PRFileDesc *listen_sock,
     PRFileDesc *model_sock,
     int         requestCert
     )
 {
     PRNetAddr   addr;
     PRErrorCode  perr;
 #ifdef XP_UNIX
     struct sigaction act;
 #endif
     VLOG(("httpserv: do_accepts: starting"));
     PR_SetThreadPriority( PR_GetCurrentThread(), PR_PRIORITY_HIGH);
     acceptorThread = PR_GetCurrentThread();
 #ifdef XP_UNIX
     /* set up the signal handler */
     act.sa_handler = sigusr1_handler;
     sigemptyset(&act.sa_mask);
     act.sa_flags = 0;
     if (sigaction(SIGUSR1, &act, NULL)) {
         fprintf(stderr, "Error installing signal handler.\n");
         exit(1);
     }
 #endif
     while (!stopping) {
 	PRFileDesc *tcp_sock;
 	PRCList    *myLink;
 	FPRINTF(stderr, "\n\n\nhttpserv: About to call accept.\n");
 	tcp_sock = PR_Accept(listen_sock, &addr, PR_INTERVAL_NO_TIMEOUT);
 	if (tcp_sock == NULL) {
     	    perr      = PR_GetError();
 	    if ((perr != PR_CONNECT_RESET_ERROR &&
 	         perr != PR_PENDING_INTERRUPT_ERROR) || verbose) {
 		errWarn("PR_Accept");
 	    }
 	    if (perr == PR_CONNECT_RESET_ERROR) {
 		FPRINTF(stderr,
 		        "Ignoring PR_CONNECT_RESET_ERROR error - continue\n");
 		continue;
 	    }
 	    stopping = 1;
 	    break;
 	}
         VLOG(("httpserv: do_accept: Got connection\n"));
 	PZ_Lock(qLock);
 	while (PR_CLIST_IS_EMPTY(&freeJobs) && !stopping) {
             PZ_WaitCondVar(freeListNotEmptyCv, PR_INTERVAL_NO_TIMEOUT);
 	}
 	if (stopping) {
 	    PZ_Unlock(qLock);
             if (tcp_sock) {
 	        PR_Close(tcp_sock);
             }
 	    break;
 	}
 	myLink = PR_LIST_HEAD(&freeJobs);
 	PR_REMOVE_AND_INIT_LINK(myLink);
 	/* could release qLock here and reaquire it 7 lines below, but
 	** why bother for 4 assignment statements?
 	*/
 	{
 	    JOB * myJob = (JOB *)myLink;
 	    myJob->tcp_sock    = tcp_sock;
 	    myJob->model_sock  = model_sock;
 	    myJob->requestCert = requestCert;
 	}
 	PR_APPEND_LINK(myLink, &jobQ);
 	PZ_NotifyCondVar(jobQNotEmptyCv);
 	PZ_Unlock(qLock);
     }
     FPRINTF(stderr, "httpserv: Closing listen socket.\n");
     VLOG(("httpserv: do_accepts: exiting"));
     if (listen_sock) {
         PR_Close(listen_sock);
     }
     return SECSuccess;
 }
 PRFileDesc *
 getBoundListenSocket(unsigned short port)
 {
     PRFileDesc *       listen_sock;
     int                listenQueueDepth = 5 + (2 * maxThreads);
     PRStatus	       prStatus;
     PRNetAddr          addr;
     PRSocketOptionData opt;
     addr.inet.family = PR_AF_INET;
     addr.inet.ip     = PR_INADDR_ANY;
     addr.inet.port   = PR_htons(port);
     listen_sock = PR_NewTCPSocket();
     if (listen_sock == NULL) {
 	errExit("PR_NewTCPSocket");
     }
     opt.option = PR_SockOpt_Nonblocking;
     opt.value.non_blocking = PR_FALSE;
     prStatus = PR_SetSocketOption(listen_sock, &opt);
     if (prStatus < 0) {
         PR_Close(listen_sock);
 	errExit("PR_SetSocketOption(PR_SockOpt_Nonblocking)");
     }
     opt.option=PR_SockOpt_Reuseaddr;
     opt.value.reuse_addr = PR_TRUE;
     prStatus = PR_SetSocketOption(listen_sock, &opt);
     if (prStatus < 0) {
         PR_Close(listen_sock);
 	errExit("PR_SetSocketOption(PR_SockOpt_Reuseaddr)");
     }
 #ifndef WIN95
     /* Set PR_SockOpt_Linger because it helps prevent a server bind issue
      * after clean shutdown . See bug 331413 .
      * Don't do it in the WIN95 build configuration because clean shutdown is
      * not implemented, and PR_SockOpt_Linger causes a hang in ssl.sh .
      * See bug 332348 */
     opt.option=PR_SockOpt_Linger;
     opt.value.linger.polarity = PR_TRUE;
     opt.value.linger.linger = PR_SecondsToInterval(1);
     prStatus = PR_SetSocketOption(listen_sock, &opt);
     if (prStatus < 0) {
         PR_Close(listen_sock);
         errExit("PR_SetSocketOption(PR_SockOpt_Linger)");
     }
 #endif
     prStatus = PR_Bind(listen_sock, &addr);
     if (prStatus < 0) {
         PR_Close(listen_sock);
 	errExit("PR_Bind");
     }
     prStatus = PR_Listen(listen_sock, listenQueueDepth);
     if (prStatus < 0) {
         PR_Close(listen_sock);
 	errExit("PR_Listen");
     }
     return listen_sock;
 }
 void
 server_main(
     PRFileDesc *        listen_sock,
     int                 requestCert,
     SECKEYPrivateKey ** privKey,
     CERTCertificate **  cert,
     const char *expectedHostNameVal)
 {
     PRFileDesc *model_sock	= NULL;
     /* Now, do the accepting, here in the main thread. */
     do_accepts(listen_sock, model_sock, requestCert);
     terminateWorkerThreads();
         if (model_sock) {
             PR_Close(model_sock);
         }
 }
 int          numChildren;
 PRProcess *  child[MAX_PROCS];
 PRProcess *
 haveAChild(int argc, char **argv, PRProcessAttr * attr)
 {
     PRProcess *  newProcess;
     newProcess = PR_CreateProcess(argv[0], argv, NULL, attr);
     if (!newProcess) {
 	errWarn("Can't create new process.");
     } else {
 	child[numChildren++] = newProcess;
     }
     return newProcess;
 }
 /* slightly adjusted version of ocsp_CreateCertID (not using issuer) */
 static CERTOCSPCertID *
 ocsp_CreateSelfCAID(PLArenaPool *arena, CERTCertificate *cert, PRTime time)
 {
     CERTOCSPCertID *certID;
     void *mark = PORT_ArenaMark(arena);
     SECStatus rv;
     PORT_Assert(arena != NULL);
     certID = PORT_ArenaZNew(arena, CERTOCSPCertID);
     if (certID == NULL) {
 	goto loser;
     }
     rv = SECOID_SetAlgorithmID(arena, &certID->hashAlgorithm, SEC_OID_SHA1,
 			       NULL);
     if (rv != SECSuccess) {
 	goto loser;
     }
     if (CERT_GetSubjectNameDigest(arena, cert, SEC_OID_SHA1,
                                   &(certID->issuerNameHash)) == NULL) {
         goto loser;
     }
     certID->issuerSHA1NameHash.data = certID->issuerNameHash.data;
     certID->issuerSHA1NameHash.len = certID->issuerNameHash.len;
     if (CERT_GetSubjectNameDigest(arena, cert, SEC_OID_MD5,
                                   &(certID->issuerMD5NameHash)) == NULL) {
         goto loser;
     }
     if (CERT_GetSubjectNameDigest(arena, cert, SEC_OID_MD2,
                                   &(certID->issuerMD2NameHash)) == NULL) {
         goto loser;
     }
     if (CERT_GetSubjectPublicKeyDigest(arena, cert, SEC_OID_SHA1,
 				       &certID->issuerKeyHash) == NULL) {
 	goto loser;
     }
     certID->issuerSHA1KeyHash.data = certID->issuerKeyHash.data;
     certID->issuerSHA1KeyHash.len = certID->issuerKeyHash.len;
     /* cache the other two hash algorithms as well */
     if (CERT_GetSubjectPublicKeyDigest(arena, cert, SEC_OID_MD5,
 				       &certID->issuerMD5KeyHash) == NULL) {
 	goto loser;
     }
     if (CERT_GetSubjectPublicKeyDigest(arena, cert, SEC_OID_MD2,
 				       &certID->issuerMD2KeyHash) == NULL) {
 	goto loser;
     }
     PORT_ArenaUnmark(arena, mark);
     return certID;
 loser:
     PORT_ArenaRelease(arena, mark);
     return NULL;
 }
 /* slightly adjusted version of CERT_CreateOCSPCertID */
 CERTOCSPCertID*
 cert_CreateSelfCAID(CERTCertificate *cert, PRTime time)
 {
     PLArenaPool *arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
     CERTOCSPCertID *certID;
     PORT_Assert(arena != NULL);
     if (!arena)
 	return NULL;
     certID = ocsp_CreateSelfCAID(arena, cert, time);
     if (!certID) {
 	PORT_FreeArena(arena, PR_FALSE);
 	return NULL;
     }
     certID->poolp = arena;
     return certID;
 }
 int
 main(int argc, char **argv)
 {
     char *               progName    = NULL;
     const char *         dir         = ".";
     char *               passwd      = NULL;
     char *               pwfile      = NULL;
     const char *         pidFile     = NULL;
     char *               tmp;
     PRFileDesc *         listen_sock;
     int                  optionsFound = 0;
     unsigned short       port        = 0;
     SECStatus            rv;
     PRStatus             prStatus;
     PRBool               bindOnly = PR_FALSE;
     PRBool               useLocalThreads = PR_FALSE;
     PLOptState		*optstate;
     PLOptStatus          status;
     char                 emptyString[] = { "" };
     char*                certPrefix = emptyString;
     caRevoInfo		*revoInfo = NULL;
     PRCList             *caRevoIter = NULL;
     PRBool               provideOcsp = PR_FALSE;
     tmp = strrchr(argv[0], '/');
     tmp = tmp ? tmp + 1 : argv[0];
     progName = strrchr(tmp, '\\');
     progName = progName ? progName + 1 : tmp;
     PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
     /* please keep this list of options in ASCII collating sequence.
     ** numbers, then capital letters, then lower case, alphabetical.
     */
     optstate = PL_CreateOptState(argc, argv,
         "A:C:DO:P:bd:f:hi:p:t:vw:");
     while ((status = PL_GetNextOpt(optstate)) == PL_OPT_OK) {
 	++optionsFound;
 	switch(optstate->option) {
 	/* A first, must be followed by C. Any other order is an error.
 	 * A creates the object. C completes and moves into list.
 	 */
 	case 'A':
 	  provideOcsp = PR_TRUE;
 	  if (revoInfo) { Usage(progName); exit(0); }
 	  revoInfo = PORT_New(caRevoInfo);
 	  revoInfo->nickname = PORT_Strdup(optstate->value);
 	  break;
 	case 'C':
 	  if (!revoInfo) { Usage(progName); exit(0); }
 	  revoInfo->crlFilename = PORT_Strdup(optstate->value);
 	  if (!caRevoInfos) {
 	      PR_INIT_CLIST(&revoInfo->link);
 	      caRevoInfos = revoInfo;
 	  } else {
 	      PR_APPEND_LINK(&revoInfo->link, &caRevoInfos->link);
 	  }
 	  revoInfo = NULL;
 	  break;
 	case 'O':
 	  if (!PL_strcasecmp(optstate->value, "all")) {
 	      ocspMethodsAllowed = ocspGetAndPost;
 	  } else if (!PL_strcasecmp(optstate->value, "get")) {
 	      ocspMethodsAllowed = ocspGetOnly;
 	  } else if (!PL_strcasecmp(optstate->value, "post")) {
 	      ocspMethodsAllowed = ocspPostOnly;
 	  } else if (!PL_strcasecmp(optstate->value, "random")) {
 	      ocspMethodsAllowed = ocspRandomGetFailure;
 	  } else if (!PL_strcasecmp(optstate->value, "get-unknown")) {
 	      ocspMethodsAllowed = ocspGetUnknown;
 	  } else {
 	      Usage(progName); exit(0);
 	  }
 	  break;
 	case 'D': noDelay = PR_TRUE; break;
 	case 'P': certPrefix = PORT_Strdup(optstate->value); break;
         case 'b': bindOnly = PR_TRUE; break;
 	case 'd': dir = optstate->value; break;
 	case 'f':
             pwdata.source = PW_FROMFILE;
             pwdata.data = pwfile = PORT_Strdup(optstate->value);
             break;
         case 'h': Usage(progName); exit(0); break;
 	case 'i': pidFile = optstate->value; break;
 	case 'p': port = PORT_Atoi(optstate->value); break;
 	case 't':
 	    maxThreads = PORT_Atoi(optstate->value);
 	    if ( maxThreads > MAX_THREADS ) maxThreads = MAX_THREADS;
 	    if ( maxThreads < MIN_THREADS ) maxThreads = MIN_THREADS;
 	    break;
 	case 'v': verbose++; break;
 	case 'w':
             pwdata.source = PW_PLAINTEXT;
             pwdata.data = passwd = PORT_Strdup(optstate->value);
             break;
 	default:
 	case '?':
 	    fprintf(stderr, "Unrecognized or bad option specified.\n");
 	    fprintf(stderr, "Run '%s -h' for usage information.\n", progName);
 	    exit(4);
 	    break;
 	}
     }
     PL_DestroyOptState(optstate);
     if (status == PL_OPT_BAD) {
 	fprintf(stderr, "Unrecognized or bad option specified.\n");
 	fprintf(stderr, "Run '%s -h' for usage information.\n", progName);
 	exit(5);
     }
     if (!optionsFound) {
 	Usage(progName);
 	exit(51);
     }
     /* The -b (bindOnly) option is only used by the ssl.sh test
      * script on Linux to determine whether a previous httpserv
      * process has fully died and freed the port.  (Bug 129701)
      */
     if (bindOnly) {
         listen_sock = getBoundListenSocket(port);
         if (!listen_sock) {
             exit(1);
         }
         if (listen_sock) {
             PR_Close(listen_sock);
         }
         exit(0);
     }
     if (port == 0) {
 	fprintf(stderr, "Required argument 'port' must be non-zero value\n");
 	exit(7);
     }
     if (pidFile) {
 	FILE *tmpfile=fopen(pidFile,"w+");
 	if (tmpfile) {
 	    fprintf(tmpfile,"%d",getpid());
 	    fclose(tmpfile);
 	}
     }
     tmp = getenv("TMP");
     if (!tmp)
 	tmp = getenv("TMPDIR");
     if (!tmp)
 	tmp = getenv("TEMP");
     /* we're an ordinary single process server. */
     listen_sock = getBoundListenSocket(port);
     prStatus = PR_SetFDInheritable(listen_sock, PR_FALSE);
     if (prStatus != PR_SUCCESS)
         errExit("PR_SetFDInheritable");
     lm = PR_NewLogModule("TestCase");
     /* set our password function */
     PK11_SetPasswordFunc(SECU_GetModulePassword);
     if (provideOcsp) {
 	/* Call the NSS initialization routines */
 	rv = NSS_Initialize(dir, certPrefix, certPrefix, SECMOD_DB, NSS_INIT_READONLY);
 	if (rv != SECSuccess) {
 	    fputs("NSS_Init failed.\n", stderr);
 		    exit(8);
 	}
 	if (caRevoInfos) {
 	  caRevoIter = &caRevoInfos->link;
 	  do {
 	      PRFileDesc *inFile;
 	      int rv = SECFailure;
 	      SECItem crlDER;
 	      crlDER.data = NULL;
 	      revoInfo = (caRevoInfo*)caRevoIter;
 	      revoInfo->cert = CERT_FindCertByNickname(
 		  CERT_GetDefaultCertDB(), revoInfo->nickname);
 	      if (!revoInfo->cert) {
 		  fprintf(stderr, "cannot find cert with nickname %s\n",
 			  revoInfo->nickname);
 		  exit(1);
 	      }
 	      inFile = PR_Open(revoInfo->crlFilename, PR_RDONLY, 0);
 	      if (inFile) {
 		rv = SECU_ReadDERFromFile(&crlDER, inFile, PR_FALSE, PR_FALSE);
 		PR_Close(inFile);
 		inFile = NULL;
 	      }
 	      if (rv != SECSuccess) {
 		  fprintf(stderr, "unable to read crl file %s\n",
 			  revoInfo->crlFilename);
 		  exit(1);
 	      }
 	      revoInfo->crl =
 		  CERT_DecodeDERCrlWithFlags(NULL, &crlDER, SEC_CRL_TYPE,
 					     CRL_DECODE_DEFAULT_OPTIONS);
 	      if (!revoInfo->crl) {
 		  fprintf(stderr, "unable to decode crl file %s\n",
 			  revoInfo->crlFilename);
 		  exit(1);
 	      }
 	      if (CERT_CompareName(&revoInfo->crl->crl.name,
 				   &revoInfo->cert->subject) != SECEqual) {
 		  fprintf(stderr, "CRL %s doesn't match cert identified by preceding nickname %s\n",
 			  revoInfo->crlFilename, revoInfo->nickname);
 		  exit(1);
 	      }
 	      revoInfo->id = cert_CreateSelfCAID(revoInfo->cert, PR_Now());
 	      caRevoIter = PR_NEXT_LINK(caRevoIter);
 	  } while (caRevoIter != &caRevoInfos->link);
 	}
     }
 /* allocate the array of thread slots, and launch the worker threads. */
     rv = launch_threads(&jobLoop, 0, 0, 0, useLocalThreads);
     if (rv == SECSuccess) {
 	server_main(listen_sock, 0, 0, 0,
 );
     }
     VLOG(("httpserv: server_thread: exiting"));
     if (provideOcsp) {
 	if (caRevoInfos) {
 	    PRCList *caRevoIter;
 	    caRevoIter = &caRevoInfos->link;
 	    do {
 		caRevoInfo *revoInfo = (caRevoInfo*)caRevoIter;
 		if (revoInfo->nickname)
 		    PORT_Free(revoInfo->nickname);
 		if (revoInfo->crlFilename)
 		    PORT_Free(revoInfo->crlFilename);
 		if (revoInfo->cert)
 		    CERT_DestroyCertificate(revoInfo->cert);
 		if (revoInfo->id)
 		    CERT_DestroyOCSPCertID(revoInfo->id);
 		if (revoInfo->crl)
 		    SEC_DestroyCrl(revoInfo->crl);
 		caRevoIter = PR_NEXT_LINK(caRevoIter);
 	    } while (caRevoIter != &caRevoInfos->link);
 	}
 	if (NSS_Shutdown() != SECSuccess) {
 	    SECU_PrintError(progName, "NSS_Shutdown");
 	    PR_Cleanup();
 	    exit(1);
 	}
     }
     if (passwd) {
         PORT_Free(passwd);
     }
     if (pwfile) {
         PORT_Free(pwfile);
     }
     if (certPrefix && certPrefix != emptyString) {
         PORT_Free(certPrefix);
     }
     PR_Cleanup();
     printf("httpserv: normal termination\n");
     return 0;
 }

The Tor Browser / annotate

security/nss/cmd/httpserv/httpserv.c@141e0f1194b1 (annotated)

security/nss/cmd/httpserv/httpserv.c