The Tor Browser: comparison security/nss/lib/base/error.c

--1:000000000000
+:157fc3c40621
+/* 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/. */
+/*
+* error.c
+*
+* This file contains the code implementing the per-thread error
+* stacks upon which most NSS routines report their errors.
+*/
+#ifndef BASE_H
+#include "base.h"
+#endif /* BASE_H */
+#include <limits.h> /* for UINT_MAX */
+#include <string.h> /* for memmove */
+#define NSS_MAX_ERROR_STACK_COUNT 16 /* error codes */
+/*
+* The stack itself has a header, and a sequence of integers.
+* The header records the amount of space (as measured in stack
+* slots) already allocated for the stack, and the count of the
+* number of records currently being used.
+*/
+struct stack_header_str {
+PRUint16 space;
+PRUint16 count;
+};
+struct error_stack_str {
+struct stack_header_str header;
+PRInt32 stack[1];
+};
+typedef struct error_stack_str error_stack;
+/*
+* error_stack_index
+*
+* Thread-private data must be indexed.  This is that index.
+* See PR_NewThreadPrivateIndex for more information.
+*
+* Thread-private data indexes are in the range [0, 127].
+*/
+#define INVALID_TPD_INDEX UINT_MAX
+static PRUintn error_stack_index = INVALID_TPD_INDEX;
+/*
+* call_once
+*
+* The thread-private index must be obtained (once!) at runtime.
+* This block is used for that one-time call.
+*/
+static PRCallOnceType error_call_once;
+/*
+* error_once_function
+*
+* This is the once-called callback.
+*/
+static PRStatus
+error_once_function ( void)
+{
+return PR_NewThreadPrivateIndex(&error_stack_index, PR_Free);
+}
+/*
+* error_get_my_stack
+*
+* This routine returns the calling thread's error stack, creating
+* it if necessary.  It may return NULL upon error, which implicitly
+* means that it ran out of memory.
+*/
+static error_stack *
+error_get_my_stack ( void)
+{
+PRStatus st;
+error_stack *rv;
+PRUintn new_size;
+PRUint32 new_bytes;
+error_stack *new_stack;
+if( INVALID_TPD_INDEX == error_stack_index ) {
+st = PR_CallOnce(&error_call_once, error_once_function);
+if( PR_SUCCESS != st ) {
+return (error_stack *)NULL;
+}
+}
+rv = (error_stack *)PR_GetThreadPrivate(error_stack_index);
+if( (error_stack *)NULL == rv ) {
+/* Doesn't exist; create one */
+new_size = 16;
+} else if( rv->header.count == rv->header.space  &&
+rv->header.count  < NSS_MAX_ERROR_STACK_COUNT ) {
+/* Too small, expand it */
+new_size = PR_MIN( rv->header.space * 2, NSS_MAX_ERROR_STACK_COUNT);
+} else {
+/* Okay, return it */
+return rv;
+}
+new_bytes = (new_size * sizeof(PRInt32)) + sizeof(error_stack);
+/* Use NSPR's calloc/realloc, not NSS's, to avoid loops! */
+new_stack = PR_Calloc(1, new_bytes);
+if( (error_stack *)NULL != new_stack ) {
+if( (error_stack *)NULL != rv ) {
+	(void)nsslibc_memcpy(new_stack,rv,rv->header.space);
+}
+new_stack->header.space = new_size;
+}
+/* Set the value, whether or not the allocation worked */
+PR_SetThreadPrivate(error_stack_index, new_stack);
+return new_stack;
+}
+/*
+* The error stack
+*
+* The public methods relating to the error stack are:
+*
+*  NSS_GetError
+*  NSS_GetErrorStack
+*
+* The nonpublic methods relating to the error stack are:
+*
+*  nss_SetError
+*  nss_ClearErrorStack
+*
+*/
+/*
+* NSS_GetError
+*
+* This routine returns the highest-level (most general) error set
+* by the most recent NSS library routine called by the same thread
+* calling this routine.
+*
+* This routine cannot fail.  However, it may return zero, which
+* indicates that the previous NSS library call did not set an error.
+*
+* Return value:
+*  0 if no error has been set
+*  A nonzero error number
+*/
+NSS_IMPLEMENT PRInt32
+NSS_GetError ( void)
+{
+error_stack *es = error_get_my_stack();
+if( (error_stack *)NULL == es ) {
+return NSS_ERROR_NO_MEMORY; /* Good guess! */
+}
+if( 0 == es->header.count ) {
+return 0;
+}
+return es->stack[ es->header.count-1 ];
+}
+/*
+* NSS_GetErrorStack
+*
+* This routine returns a pointer to an array of integers, containing
+* the entire sequence or "stack" of errors set by the most recent NSS
+* library routine called by the same thread calling this routine.
+* NOTE: the caller DOES NOT OWN the memory pointed to by the return
+* value.  The pointer will remain valid until the calling thread
+* calls another NSS routine.  The lowest-level (most specific) error
+* is first in the array, and the highest-level is last.  The array is
+* zero-terminated.  This routine may return NULL upon error; this
+* indicates a low-memory situation.
+*
+* Return value:
+*  NULL upon error, which is an implied NSS_ERROR_NO_MEMORY
+*  A NON-caller-owned pointer to an array of integers
+*/
+NSS_IMPLEMENT PRInt32 *
+NSS_GetErrorStack ( void)
+{
+error_stack *es = error_get_my_stack();
+if( (error_stack *)NULL == es ) {
+return (PRInt32 *)NULL;
+}
+/* Make sure it's terminated */
+es->stack[ es->header.count ] = 0;
+return es->stack;
+}
+/*
+* nss_SetError
+*
+* This routine places a new error code on the top of the calling
+* thread's error stack.  Calling this routine wiht an error code
+* of zero will clear the error stack.
+*/
+NSS_IMPLEMENT void
+nss_SetError ( PRUint32 error)
+{
+error_stack *es;
+if( 0 == error ) {
+nss_ClearErrorStack();
+return;
+}
+es = error_get_my_stack();
+if( (error_stack *)NULL == es ) {
+/* Oh, well. */
+return;
+}
+if (es->header.count < es->header.space) {
+es->stack[ es->header.count++ ] = error;
+} else {
+memmove(es->stack, es->stack + 1,
+		(es->header.space - 1) * (sizeof es->stack[0]));
+es->stack[ es->header.space - 1 ] = error;
+}
+return;
+}
+/*
+* nss_ClearErrorStack
+*
+* This routine clears the calling thread's error stack.
+*/
+NSS_IMPLEMENT void
+nss_ClearErrorStack ( void)
+{
+error_stack *es = error_get_my_stack();
+if( (error_stack *)NULL == es ) {
+/* Oh, well. */
+return;
+}
+es->header.count = 0;
+es->stack[0] = 0;
+return;
+}
+/*
+* nss_DestroyErrorStack
+*
+* This routine frees the calling thread's error stack.
+*/
+NSS_IMPLEMENT void
+nss_DestroyErrorStack ( void)
+{
+if( INVALID_TPD_INDEX != error_stack_index ) {
+PR_SetThreadPrivate(error_stack_index, NULL);
+}
+return;
+}

The Tor Browser / file comparison

comparison: security/nss/lib/base/error.c

security/nss/lib/base/error.c