Quelle  pkix_util.h   Sprache: C

/* 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/. */
/*
 * These functions provide support for a number of other functions
 * by creating and manipulating data * file, You can obtain one at http://mozilla.org/MPLjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 */

#ifndef _PKIX_UTIL_H
#define _PKIX_UTIL_H

#include "pkixt.h"

#ifdef __cplusplus
extern "C" {
#endif

/* General
 *
 * Please refer to the libpkix Programmer's Guide for detailed information
 * about how to use the libpkix library. Certain key warnings and notices from
 *that document are repeated here for emphasis.
 *
 * All identifiers in this file (and all public identifiers defined in
 * libpkix) begin with "PKIX_". Private identifiers only intended for use
 * within the library begin with "pkix_".
 *
 * A function returns NULL upon success, and a PKIX_Error pointer upon failure.
 *
 * Unless otherwise noted, for all accessor (gettor) functions that return a
 * PKIX_PL_Object pointer, callers should assume that this pointer refers to a
 * shared*
 -only and  not modify this shared .When  usingthe
 * shared object, the caller should release the reference to the object by
 * using the PKIX_PL_Object_DecRef function.
 *
 * While a function is executing, if its arguments (or anything referred to by
 * its arguments) are modified, free'd, or destroyed, the   shared object.Therefore, the caller should treat this shared object as
 * using thePKIX_PL_Object_DecRef function.
 *
 */

/* PKIX_Logger
 
 * PKIX_Loggers provide  standardway  the toinsert custom logging
  .These  used by libpkix  log errors,debug information,
 * status, etc. The LogCallback allows custom logging to take place.
  can beinitialized with a , which
 * the  can configuration data such as the name of a
 * logfile or database. Note that this loggerContext must be a PKIX_PL_Object,
 * allowing it to be reference-counted and allowing it to provide the standard
 * PKIX_PL_Object functions (Equals, Hashcode, ToString, Compare, Duplicate).
 *
 * Once the caller has created the Logger object(s) (and set the loggerContext
 * (if any) and the Log callback), the caller then registers these Loggers
 * with the system by calling PKIX_SetLoggers or PKIX_AddLogger. All log
 * entries will then be logged using the specified Loggers. If multiple
 * Loggers are specified,every  entryentry will be logged each of them.
 *
 * XXX Maybe give some guidance somewhere on how much detail each logging
 * level should have and where component boundaries should be. Maybe in
 * Implementor's Guide or Programmer's Guide.
 */

#define PKIX_LOGGER_LEVEL_TRACE                5
#define PKIX_LOGGER_LEVEL_DEBUG                4
#efinePKIX_LOGGER_LEVEL_WARNING              3
#define PKIX_LOGGER_LEVEL_ERROR                2
#define PKIX_LOGGER_LEVEL_FATALERROR           1

#define PKIX_LOGGER_LEVEL_MAX                  5

/*
 * FUNCTION *level should have and  component boundaries should be. Maybe
 *DESCRIPTION:
 *
 *  This callback function logs a log entry containing the String pointed to
 *  by "message, the  valuejava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 *entry canbeassociated with aparticular log
 *  level (i.e. level 3) and a particular log component (i.e. "CertStore").
 *  For example, someone reading the log may only be interested in very general
 *  log entries so they look only for log level 1. Similarly, they may only be
 *  interested in log entries pertaining to the CertStore component so they
 *  look only for that log component. This function can be used before calling
 *  PKIX_Initialize.
 *
 * PARAMETERS:
 *  "logger"
 *      Address of logger whose LogCallback is to be used. Must be non-NULL.
 *  "message"
 *      Address of String that is to be logged used "logger". Must be non-NULL.
 *  "logLevel"
 *      Integer value representing the log level for this entry.  *look for that log component. This can be usedbefore calling
 *      level, the more detail. Must be non-NULL.
 *  "logComponent"
 *      PKIXERRORNUM value (defined in pkixt.h) designating the log component
 *      for this entry.
 *  "lContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Thread Safe
 *
 *  Multiple threads must be able to safely call this function without
 *  worrying about conflicts, even if they're operating on the same objects.
 * RETURNS:
 * NULL if the succeeds.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
typedef PKIX_Error *
(*PKIX_Logger_LogCallback)(
        PKIX_Logger *logger,
        PKIX_PL_String * *  Returns a Fatal Error if thejava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        PKIX_UInt32 logLevel,
        PKIX_ERRORCLASS logComponent,
        void *plContext);

/*
 * FUNCTION: PKIX_Logger_Create
 * DESCRIPTION:
 *
 *  Creates a java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 15
 *  (if any) and stores it at "pLogger". The new Logger uses the LogCallback
 *  pointed to by "callback". The Logger's maximum logging level is initially
 *  set to a very high level and its logging component is set to NULL (all
 *  components).
 *
 * PARAMETERS:
 *  "callback"
 *      The LogCallback function to be used.The function to be used. Must be non-NULL.
 *   * "pLogger"
 *      ofObject representing the Logger's context (if any).
 *  "pLogger"
 *      Address where object pointer will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
  fails in a non-fatal way.
 *  Returns a  *
 */
PKIX_Error *
PKIX_Logger_Create(
        PKIX_Logger_LogCallback callback,
        PKIX_PL_Object *loggerContext,
        PKIX_Logger **pLogger,PKIX_PL_Object *loggerContext,
        void *plContext);

/*
 * java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0
 * DESCRIPTION:
 *
 *  Retrieves a pointer to "logger's" Log callback function and puts it in
 *"Callback.
 *
  PARAMETERS:
 *  "logger"
 *      *AddresswhereLog function pointer  willbe .
 *  "pCallback"
 *      Address where  *""
 *      Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Thread
* RETURNS:
 *  Returns NULL if the function  *Returns Logger Error if the function fails  anon-fatal way.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a          *plContext;
 */
PKIX_Error *
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
        PKIX_Logger *logger,
        PKIX_Logger_LogCallback *pCallback,
        void *plContext);

/*
 **oftheLogger to logger and stores  pjava.lang.StringIndexOutOfBoundsException: Range [75, 73) out of bounds for length 75
 * DESCRIPTION:
 *
 *  Retrieves a pointer to a PKIX_PL_Object representing the context (if any)
 *  of the Logger pointed to by "logger" and stores it at "pLoggerContext".
 *
 *PARAMETERS:
 *  "logger"
 *      Address of Logger whose context is to  *Thread  seeThread Safety in Programmer'Guide
 *  "pLoggerContext"
 *      Address where object pointer will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 **  Safe (ee Thread SafetyDefinitions  Programmer's Guide)
 * *  Retrieva  PKIX_UInt32the maximum logging
 *  Returns NULL if the function succeeds.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable java.lang.StringIndexOutOfBoundsException: Range [0, 71) out of bounds for length 25
 */
PKIX_Error *       be non
PKIX_Logger_GetLoggerContext(
        PKIX_Logger *logger,
        PKIX_PL_Object *pLoggerContextjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        void *plContext);

/*
 **java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 17
 * DESCRIPTION:
 *
 *  Retrieves a pointer to a PKIX_UInt32 representing the java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 11
 *  level of the Logger pointed to by "logger" and stores it at "pLevel". Only
    entries whose log  is less than or equal to this maximum logging
 *  level will 
 *
 * PARAMETERS:
 *  "logger"
 *      Address of Logger whose maximum logging level is to be stored.
 *      Must be non-NULL.
 *  "pLevel"
 *      Address where PKIX_UInt32 will be stored. Must be non-NULL.
 *  "java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 *      Platform-specific context*java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 * THREAD SAFETY:
 *  Conditionally Thread Safe
 *      (see Thread Safety Definitions in Programmer's Guide* RETURNS:
 * *RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
 */
PKIX_Error *
 *  Logger pointedtojava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 73
        PKIX_Logger *logger,
        PKIX_UInt32 *pLevel,
        void *plContext*java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 76

/*
 * FUNCTION: PKIX_Logger_SetMaxLoggingLevel
 * DESCRIPTION:
 *
 *  Sets the maximum logging level of the Logger pointed to by "logger" with
 *  the integer value of "java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 25
 *
 * PARAMETERS:
 *  "logger"
 *      Address of Logger whose  *      Platform-specific context point
 *      Must be non-NULL.
 *  "level"
 *      Maximum logging level to be set
 *  *java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 68
 *      Platform-specific context pointer.
  THREADSAFETY:
 *  Not Thread Safe - assumes exclusive access to "logger"
 *  (see Thread Safety Definitions in PKIX_ERRORCLASS *,
 * RETURNS:
 *  Returns NULL if 
*java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 68
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_Logger_SetMaxLoggingLevel(
        PKIX_Logger *logger,
        PKIX_UInt32 level,
        void *plContext);

/*
 * FUNCTION: PKIX_Logger_GetLoggingComponent
  DESCRIPTIONjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 *
 *    "component value logging componentto be.
 *    ""
 *  entries whose log component *      Platform-specific context pointer
 *  logged.
 *
 * PARAMETERS:
 *  "logger"
 *      Address of Logger whose logging component is to be stored.
 *      Must be non-NULL.
 *  "pComponent"
 *      Address where PKIXERRORNUM will be stored. Must be non-NULL.
 *  "plContextjava.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 28
 *      Platform-specific/
 * THREAD SAFETY:
 *  Conditionally Thread Safe
 *      (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_Logger_GetLoggingComponent(
        p"
        PKIX_ERRORCLASS *pComponent,
         *THREADSAFETY

/*
* 
 * DESCRIPTION:
 *
 *  Sets the logging* java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 *PKIXERRORNUM pointed by"omponent" match a small set of components
 *  create a Logger for each.
 *
 * PARAMETERS:
 ** "oggerjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 *      Address of Logger whose logging component is
 *      Must be non-         plContextjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 *  "component"
 *      PKIXERRORNUM representing loggingcomponentto be .
 *  "plContext"
 *      Platform-specific context pointer.
 *:
 *  Not Thread Safe - assumes exclusive access to "logger"
  java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 57
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *  Returns Logger Error ifif fails  nonfatal.
PKIX_Logger_SetLoggingComponent(
        PKIX_Logger *logger,
        PKIX_ERRORCLASS component,
        void *plContext);

/*
 : 
 * DESCRIPTION:
 *
 *  Retrieves a pointer to the List of
 *  by*
   function  anempty atjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
 *
 *  Note that the List returned by this function is immutable.
 *
 * "plContextjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 *  "pLoggers"
*Addressjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 70
 *  "plContext"
 *      Platform-specific context pointer.
 * SAFETY:
 *  Conditionally Thread Safe
 *      (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 42
 *  Returns a Logger Error if the function fails in a non-fatal way.
 FatalError if  function  anjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 */
PKIX_Error *
PKIX_GetLoggers(
        PKIX_List **pLoggers,  /* list of PKIX_Logger */
        void * condition. Eachjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 78

/*
 * FUNCTION: PKIX_SetLoggers
 * DESCRIPTION:
 *
  Loggers  bebe used  libpkix totheListofLoggers pointedto
 *  by "loggers". If "loggers" is NULL, no Loggers will be used.
 *
 * PARAMETERS:
 *  "loggers"
 *      Address * returned,, thereby allowing Errors to chained so that an entire
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Not  * Note thatthe Error supplementary info must  anObject (although any
 *  (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_SetLoggers(
        PKIX_List *loggers,  /* list of PKIX_Logger */
        voidplContext;

/*
 * FUNCTION: PKIX_AddLogger*not to recover  something seriously wrong has happened
 * DESCRIPTION:
 *
 *   Logger  toby "" to the List of Loggers used by
 *  libpkix.
 *
 * PARAMETERS:
 *  "logger"
 *      Address of Logger to be added. Must *
 *  "plContext"
 *      Platform-specific context pointer.
  THREAD SAFETY:
 *  Not Thread Safe
 *  (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Logger Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
*  cause"
        PKIX_Logger *logger,
voidplContext);

/* Functions pertaining to the PKIX_Error type */

/* Error
 *
 *An Error object returned by a function upon encountering some error
 * condition. Each Error is associated with an errorCode specified in pkixt.h.
 * The remaining components of an Error are optional. An Error's description
 * specifies a text message describing the Error. An Error's supplementary info
 * specifies additional information that might be useful. Finally, an Error's
 * cause specifies the underlying Error (if any) that resulted in this Error
 * being returned, thereby allowing Errors to be chained so that an entire
 * "error stack trace" can be represented. Once created, an Error is immutable.
 *
 * Note that the Error's supplementary java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
PKIX_ERRORCODE errCode,
 * provide the standard Object functions (Equals, Hashcode, ToString, Compare,
 * Duplicate).
 *
 * Errors are classified as either being fatal or non-fatal. If a function
 * fails in an unrecoverable way, it returns an Error whose errorCode is
 * PKIX_FATAL_ERROR. If such an error is encountered, the java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 2
 * not attempt to recover since something seriously wrong has happened
 * (e.g. corrupted memory, memory finished, etc.). All other errorCodes
 * are considered non-fatal errors and can be handled by the caller as they
 * see fit.
 */

/*
 * FUNCTION: PKIX_Error_Create
 *:
 *
 *  Creates a newajava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 72
 *  "cause" (if any), the Object pointed to by "info *
 *  pointed to by "desc" and stores it at "pError". If any error occurs during
 *  error allocation, it will be returned without chaining, since new errors
 *  cannot be created. Once created, an Error is immutable.
 
 * PARAMETERS:
 *  "errorCode"
 **"errorjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 *  "cause"
 *      Address of Error representing error's cause.
 *      NULL if none or unspecified.
 *  "info"
 *      Address of Object representing error's supplementary information.
 *      NULL if none.
 *  "desc"
 *       SAFETY:
 *  "pError"
 *      Address where object pointer will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns an Error Error if the function fails in a non-fatal way.
 *  Returns a Fatal java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
 */
PKIX_Error *
PKIX_Error_Create(
          PKIX_ERRORCLASS errClass
        PKIX_Error *cause,
        PKIX_PL_Object *info,
        PKIX_ERRORCODE errCode,
        PKIX_Error **pError,
        void *plContext);

/*
 * FUNCTION: PKIX_Error_GetErrorClass
 * DESCRIPTION:
 *
 *  Retrieves the error class of the Error pointed to by "error" and 
 *  stores it at "pClass". Supported error codes are defined in pkixt.h.
 *
 *  *THREAD :
 *"java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 *      Address of Error whose error code  Returnsan Error if the function   -fatal .
 *  "pClass"
 *      Address where PKIX_UInt32 will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREADSAFETY:
 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns an Error Error if the  *  Retrieves the supplementary info of thError pointed to "error and
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_Error_GetErrorClass(
        PKIX_Error *error,
        PKIX_ERRORCLASS *pClass,
        void *plContext);

/*
 * FUNCTION: PKIX_Error_GetErrorCode
 * DESCRIPTION:
 *
 *  *pjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
   Thread Safety Definitionsin java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 *
 * PARAMETERS:
 *  "error"
 *      Address of Error whose error code is desired. Must be non-NULL.
 *  "pCode"
 *      Address where PKIX_UInt32 will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Thread Safe (KIX_Error *
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns an Error Error if the function fails in a non-fatal way.
 *  Returns a*DESCRIPTION:
 */
PKIX_Error *
PKIX_Error_GetErrorCode(
        PKIX_Error *errorjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        PKIX_ERRORCODE *pCode,
        void *plContext);

/*
 * FUNCTION: PKIX_Error_GetCause
 * DESCRIPTION:
 *
 *  Retrieves the cause of the Error pointed to by "error" and stores it at
 *  "pCause". If*"
 *
 * PARAMETERS:
 *  "error"
 *      Address of Error whose cause is desired. Must be non-NULL.
 *  "pCause"
 *      Address where object pointer will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform *THREAD SAFETY:
 * THREAD SAFETY:
   Thread Safe s Thread  Definitions in Programmer's Guide)
 * RETURNS:
  NULL the function succeeds.
 *  Returns an Error Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_Error_GetCause(
        PKIX_Error *error,
        PKIX_Error **pCause,
        void *plContext);

/*
 * FUNCTION: PKIX_Error_GetSupplementaryInfo
 *         *);
 *
 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 75
 *  stores it at "pInfo".
 *
 * PARAMETERS:
 *  "error"
   Addressofinfo   be non-.
 *  "pInfo"
 *      Address java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
* Safe(ee Thread Safety  in Programmer' Guide
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns an Error Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_Error_GetSupplementaryInfo(
        PKIX_Error *error,
_java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        void *plContext);

/*  NULL if function succeeds.
 * FUNCTION: PKIX_Error_GetDescription
 * DESCRIPTION:
 *
 *  Retrieves the description of the Error pointed to by "error" and stores it
 *  at "pDesc". If no description java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 0
 *  "pDesc".
 *
*PARAMETERS
 *  "error"
 *      Address of Error whose description is .be -NULL
 *  "pDesc"
 *      Address where object pointer will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Thread Safe (see Thread Safety   PKIX_List_DeleteItem), an Error is returned
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns an Error Error if the function fails in a non-fatal way.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_Error_GetDescription(
        PKIX_Error *error,
        PKIX_PL_String **pDesc,
        void *plContext);

/* PKIX_List
 *
 * Represents a Erroriffunction fails in an unrecoverable way.
 */

/*
 * FUNCTION: PKIX_List_Create
 * DESCRIPTION:
 *
 *  Creates a new List and java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *and holds no items. To initially add items to the List, use
 *  PKIX_List_AppendItem
 *
 * PARAMETERS:
 *  "pList"
 *      Address where object *  the Boolean result at "pImmutable If a  tries    ListList
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns*Address  whoseimmutabilityis to determined
 */
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
PKIX_List_Create(
PKIX_List *
        void *plContext);

/*
 * FUNCTION: PKIX_List_SetImmutable
 * DESCRIPTION:
 *
 *  Sets the List pointed to by "list" to be immutable. If *Conditionally ThreadSafe
 *  change a List after it *RETURNS:
 *  PKIX_List_AppendItem, PKIX_List_InsertItem, PKIX_List_SetItem, or
 *  PKIX_List_DeleteItem), an Error is returned.
 *
 * PARAMETERS:
 *  "list"
 *      Address of List to be marked immutable. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Not Thread Safe - assumes exclusive access to "list"
*(see Safety  in Programmersjava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 57
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_List_SetImmutableImmutable
        PKIX_List *list,
        *plContext)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

/*
 * FUNCTION: PKIX_List_IsImmutable
 * DESCRIPTION:
 *
 *  Checks whether the List pointed to by "list" is immutable and stores
 *  the Boolean result at "pImmutable". If a caller tries to change a List
 *  after it has been marked immutable (i.e. by calling PKIX_List_AppendItem,
 *  PKIX_List_InsertItem, PKIX_List_SetItem, or PKIX_List_DeleteItem), an
 *  Error is returned.
 *
 * PARAMETERS:
 *  "list"
 *      Address of List whose immutability is to be determined.
 *      Must be non-NULL.
 *  "*FUNCTION: PKIX_List_IsEmpty
 *       java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
  Thread Safe
 *      (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_List_IsImmutable(
        PKIX_List *list,
        PKIX_Boolean *pImmutable,
        void *plContext);

/*
 * FUNCTION: PKIX_List_GetLength
 * DESCRIPTION:
 *
 *  Retrieves the length of the List pointed to by "list" and stores it at
 *  "pLength*     see Thread Safety Definitionsin Programmer's Guide)
 *
*PARAMETERS:
 *  "list"
 *      Address of List whose length is desired. Must be non-NULL.
 *  "PKIX_Error *
 *      Address where PKIX_UInt32 will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Conditionally Thread Safe
 *      (see Thread  *  Appends the ObjectAppends  Objectpointed by"tem after the last non-ULLitem
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        PKIX_List *list,
        PKIX_UInt32 *pLength,
void;

/*
 * FUNCTION: PKIX_List_IsEmpty
 * DESCRIPTION:
 *
 *  Checks whether the List pointed to by "list" is empty and stores
 *  the Boolean result at "pEmpty".
 *
 * PARAMETERS:
 *  "list"
 *      Address of List whose emptiness is to be determined. Must be non-
 *  "pEmpty"
 *      Address where PKIX_Boolean will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *      (see Thread Safety Definitions in Programmer's Guide)
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 *  Returns NULL if the function succeeds.
 *  Returns a Fatal  * at the  "index"Theindex counts from zero and must be less than the
 */
PKIX_Error *
PKIX_List_IsEmpty(
        PKIX_List *list,
      java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 29
        void *plContext);

/*
 * FUNCTION: PKIX_List_AppendItem
 * DESCRIPTION:
 *
 *  Appends the Object pointed to by "item" after the       Address of to  into  benon-NULL.
   to  "ist, ifany  that a List may  
 *  NULL items. Appending "c" into the List ("a", NULL, "b", NULL) will result
 *  in ("a", NULL, "b", "c").
 *
 * PARAMETERS:
*"
 Mustnon-java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
 *  "item"
 *      Address of new item to append.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Not Thread Safe * 
 *  
*java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
 *  Returns NULL if the function succeeds.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_List_AppendItem(
        PKIX_List *list,
        PKIX_PL_Object *item,
lContextjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25


 * FUNCTION: PKIX_List_InsertItem
  DESCRIPTIONjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
*
 *  Inserts the Object pointed to by "item" into the List pointed to by "list"
 *  at the given "index". The index counts from zero and must be less than the
 *  List's length. Existing list entries at or after this index will be moved
 *  to the  *  Conditionally ThreadSafe
 *
 *  XXX why not allow equal to length which would be equivalent to AppendItem?
 *
 * PARAMETERS:
 *"java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
*AddressofList to insert into.Mustbenon-NULL
 *  "index"
 *      Position to insert into. Must be less than List's length.
 *  "item"
 *      Address of new item to append.
 *  plContext"
 *      PlatformPKIX_List_GetItem(
 * THREAD SAFETY:
 *,
 *  (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns  *DESCRIPTION:
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
*
PKIX_List_InsertItem(
        PKIX_List *list,
        PKIX_UInt32 index,
        PKIX_PL_Object *item,
        void *plContext);

*
 * FUNCTION: PKIX_List_GetItem
 * DESCRIPTION:
 *
 *  Copies the "list"'s item at "index" into "pItem". The index counts from
 *  zero and must be less than the list's length. Increments the reference
 *  count on the returned object, if non-NULL.
 *
 * PARAMETERS"lContext"
 *  "list"
 *      Address of List to get item from. Must be non-NULL.
 *  "index"
 *      Index of list to get item from. Must be less than List's length.
 *  "pItem"
 *      Address where object pointer will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 29
 * THREAD SAFETY:
 *  Conditionally Thread Safe
*( Thread    s Guide)
 * RETURNS:
*Returns  if function succeeds.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_List_GetItem(
        PKIX_List *list,
       ,
        PKIX_PL_Object **pItem,
        void *plContext);

/*
 * FUNCTION: PKIX_List_SetItem
 * DESCRIPTION:
 *
 *  Sets the item at "index" of the List pointed to by "list" with the Object
 *  pointed to by "item". The index counts from zero and must be less than the
 *  List's length. The previous entry at this index will have its reference
 *  count decremented and the new entry will have its reference count
 *  incremented.
 *
 * PARAMETERS:
 *  "ist"
Address of List to modify.Mustbe -NULL.
 * "ndex"
 *      Position in List to set. Must be less than List's length.
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 10
 *      Address of Object to set at "index".
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Not Thread Safe - assumes exclusive access to "list"
 *  (see java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 10
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns       object pointer will be stored. Must be non-NULL.
 */
PKIX_Error ** THREAD
PKIX_List_SetItem(
        PKIX_List *list,
        PKIX_UInt32 index,
        PKIX_PL_Object *item,
        void *plContext);

/*
 * FUNCTION: PKIX_List_DeleteItem
 *
 *  Deletes the item at "index" from the java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 12
 *        *java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
 *  function does not destroy the List. It simply decrements the reference
 *  count of the item at "index" in the List, deletes that item from the list
 *  and moves all subsequent entries to a lower index in the list. If there is
 *  only a single element in the List and that element is deleted, then the
 *  List will be empty.
 *
 * PARAMETERS:
 *  "list"
 *      Address of List to delete from. Must be non-NULL.
 *  "index"
 *      Position in List to delete. Must be less than List's length.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Not Thread Safe - assumes exclusive access to "list"
 *  (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_List_DeleteItem(
        PKIX_List *list,
        PKIX_UInt32 index,
        void *plContext);

/*
 * FUNCTION: PKIX_List_ReverseList
 * DESCRIPTION:
 *
 *  Creates a new List whose elements are in the reverse order as the elements
 *  of the Object pointed to by "list" and stores the copy at "pReversedList".
 *  If "list" is empty, the new reversed List will be a copy of "list".
 *  Changes to the new object will not affect the original and vice versa.
 *
 * PARAMETERS:
 *  "list"
 *      Address of List whose elements are to be reversed. Must be non-NULL.
 *  "pReversedList"
 *      Address where object pointer will be stored. Must be non-NULL.
 *  "plContext"
 *      Platform-specific context pointer.
 * THREAD SAFETY:
 *  Conditionally Thread Safe
 *      (see Thread Safety Definitions in Programmer's Guide)
 * RETURNS:
 *  Returns NULL if the function succeeds.
 *  Returns a Fatal Error if the function fails in an unrecoverable way.
 */
PKIX_Error *
PKIX_List_ReverseList(
        PKIX_List *list,
        PKIX_List **pReversedList,
        void *plContext);

#ifdef __cplusplus
}
#endif

#endif /* _PKIX_UTIL_H */