Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Enumerations | Functions
secasn1e.c File Reference
#include "secasn1.h"

Go to the source code of this file.

Classes

struct  sec_asn1e_state_struct
struct  sec_EncoderContext_struct

Defines

#define UNEXPECTED_FLAGS
#define UNEXPECTED_FLAGS

Typedefs

typedef struct
sec_asn1e_state_struct 
sec_asn1e_state

Enumerations

enum  sec_asn1e_parse_place {
  beforeHeader, duringContents, duringGroup, duringSequence,
  afterContents, afterImplicit, afterInline, afterPointer,
  afterChoice, notInUse, beforeHeader, duringContents,
  duringGroup, duringSequence, afterContents, afterImplicit,
  afterInline, afterPointer, afterChoice, notInUse
}
enum  sec_asn1e_parse_status {
  allDone, encodeError, keepGoing, needBytes,
  allDone, encodeError, keepGoing, needBytes
}
enum  sec_asn1e_hdr_encoding {
  hdr_normal = 0, hdr_any = 1, hdr_decoder = 2, hdr_optional = 3,
  hdr_placeholder = 4, hdr_normal = 0, hdr_any = 1, hdr_decoder = 2,
  hdr_optional = 3, hdr_placeholder = 4
}

Functions

static sec_asn1e_statesec_asn1e_push_state (SEC_ASN1EncoderContext *cx, const SEC_ASN1Template *theTemplate, const void *src, PRBool new_depth)
static void sec_asn1e_scrub_state (sec_asn1e_state *state)
static void sec_asn1e_notify_before (SEC_ASN1EncoderContext *cx, void *src, int depth)
static void sec_asn1e_notify_after (SEC_ASN1EncoderContext *cx, void *src, int depth)
static sec_asn1e_statesec_asn1e_init_state_based_on_template (sec_asn1e_state *state)
static void sec_asn1e_write_part (sec_asn1e_state *state, const char *buf, unsigned long len, SEC_ASN1EncodingPart part)
static void sec_asn1e_write_identifier_bytes (sec_asn1e_state *state, unsigned char value)
int SEC_ASN1EncodeLength (unsigned char *buf, int value)
static void sec_asn1e_write_length_bytes (sec_asn1e_state *state, unsigned long value, PRBool indefinite)
static void sec_asn1e_write_contents_bytes (sec_asn1e_state *state, const char *buf, unsigned long len)
static void sec_asn1e_write_end_of_contents_bytes (sec_asn1e_state *state)
static int sec_asn1e_which_choice (void *src, const SEC_ASN1Template *theTemplate)
static unsigned long sec_asn1e_contents_length (const SEC_ASN1Template *theTemplate, void *src, PRBool disallowStreaming, PRBool insideIndefinite, sec_asn1e_hdr_encoding *pHdrException)
static void sec_asn1e_write_header (sec_asn1e_state *state)
static void sec_asn1e_write_contents_from_buf (sec_asn1e_state *state, const char *buf, unsigned long len)
static void sec_asn1e_write_contents (sec_asn1e_state *state)
static void sec_asn1e_next_in_group (sec_asn1e_state *state)
static void sec_asn1e_next_in_sequence (sec_asn1e_state *state)
static void sec_asn1e_after_contents (sec_asn1e_state *state)
SECStatus SEC_ASN1EncoderUpdate (SEC_ASN1EncoderContext *cx, const char *buf, unsigned long len)
void SEC_ASN1EncoderFinish (SEC_ASN1EncoderContext *cx)
SEC_ASN1EncoderContext * SEC_ASN1EncoderStart (const void *src, const SEC_ASN1Template *theTemplate, SEC_ASN1WriteProc output_proc, void *output_arg)
void SEC_ASN1EncoderSetNotifyProc (SEC_ASN1EncoderContext *cx, SEC_ASN1NotifyProc fn, void *arg)
void SEC_ASN1EncoderClearNotifyProc (SEC_ASN1EncoderContext *cx)
void SEC_ASN1EncoderAbort (SEC_ASN1EncoderContext *cx, int error)
void SEC_ASN1EncoderSetStreaming (SEC_ASN1EncoderContext *cx)
void SEC_ASN1EncoderClearStreaming (SEC_ASN1EncoderContext *cx)
void SEC_ASN1EncoderSetTakeFromBuf (SEC_ASN1EncoderContext *cx)
void SEC_ASN1EncoderClearTakeFromBuf (SEC_ASN1EncoderContext *cx)
SECStatus SEC_ASN1Encode (const void *src, const SEC_ASN1Template *theTemplate, SEC_ASN1WriteProc output_proc, void *output_arg)
static void sec_asn1e_encode_item_count (void *arg, const char *buf, unsigned long len, int depth, SEC_ASN1EncodingPart data_kind)
static void sec_asn1e_encode_item_store (void *arg, const char *buf, unsigned long len, int depth, SEC_ASN1EncodingPart data_kind)
static SECItem * sec_asn1e_allocate_item (PRArenaPool *poolp, SECItem *dest, unsigned long len)
SECItem * SEC_ASN1EncodeItem (PRArenaPool *poolp, SECItem *dest, const void *src, const SEC_ASN1Template *theTemplate)
static SECItem * sec_asn1e_integer (PRArenaPool *poolp, SECItem *dest, unsigned long value, PRBool make_unsigned)
SECItem * SEC_ASN1EncodeInteger (PRArenaPool *poolp, SECItem *dest, long value)
SECItem * SEC_ASN1EncodeUnsignedInteger (PRArenaPool *poolp, SECItem *dest, unsigned long value)

Class Documentation

struct sec_asn1e_state_struct

Definition at line 74 of file secasn1e.c.

Collaboration diagram for sec_asn1e_state_struct:
Class Members
struct sec_asn1e_state_struct * child
int depth
PRBool disallowStreaming
PRBool indefinite
PRBool is_string
PRBool isExplicit
PRBool may_stream
PRBool optional
struct sec_asn1e_state_struct * parent
sec_asn1e_parse_place place
void * src
unsigned char tag_modifiers
unsigned char tag_number
const SEC_ASN1Template * theTemplate
SEC_ASN1EncoderContext * top
unsigned long underlying_kind
struct sec_EncoderContext_struct

Definition at line 107 of file secasn1e.c.

Collaboration diagram for sec_EncoderContext_struct:
Class Members
sec_asn1e_state * current
PRBool during_notify
PRBool from_buf
void * notify_arg
SEC_ASN1NotifyProc notify_proc
PRArenaPool * our_pool
void * output_arg
SEC_ASN1WriteProc output_proc
sec_asn1e_parse_status status
PRBool streaming

Define Documentation


Typedef Documentation


Enumeration Type Documentation

Enumerator:
hdr_normal 
hdr_any 
hdr_decoder 
hdr_optional 
hdr_placeholder 
hdr_normal 
hdr_any 
hdr_decoder 
hdr_optional 
hdr_placeholder 

Definition at line 66 of file secasn1e.c.

             {
    hdr_normal      = 0,  /* encode header normally */
    hdr_any         = 1,  /* header already encoded in content */
    hdr_decoder     = 2,  /* template only used by decoder. skip it. */
    hdr_optional    = 3,  /* optional component, to be omitted */
    hdr_placeholder = 4   /* place holder for from_buf content */
} sec_asn1e_hdr_encoding;
Enumerator:
beforeHeader 
duringContents 
duringGroup 
duringSequence 
afterContents 
afterImplicit 
afterInline 
afterPointer 
afterChoice 
notInUse 
beforeHeader 
duringContents 
duringGroup 
duringSequence 
afterContents 
afterImplicit 
afterInline 
afterPointer 
afterChoice 
notInUse 

Definition at line 46 of file secasn1e.c.

Enumerator:
allDone 
encodeError 
keepGoing 
needBytes 
allDone 
encodeError 
keepGoing 
needBytes 

Definition at line 59 of file secasn1e.c.


Function Documentation

static void sec_asn1e_after_contents ( sec_asn1e_state state) [static]

Definition at line 1233 of file secasn1e.c.

{
    PORT_Assert (state->place == afterContents);

    if (state->indefinite)
       sec_asn1e_write_end_of_contents_bytes (state);

    /*
     * Just make my parent be the current state.  It will then clean
     * up after me and free me (or reuse me).
     */
    state->top->current = state->parent;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static SECItem* sec_asn1e_allocate_item ( PRArenaPool poolp,
SECItem *  dest,
unsigned long  len 
) [static]

Definition at line 1514 of file secasn1e.c.

{
    if (poolp != NULL) {
       void *release;

       release = PORT_ArenaMark (poolp);
       if (dest == NULL)
           dest = (SECItem*)PORT_ArenaAlloc (poolp, sizeof(SECItem));
       if (dest != NULL) {
           dest->data = (unsigned char*)PORT_ArenaAlloc (poolp, len);
           if (dest->data == NULL) {
              dest = NULL;
           }
       }
       if (dest == NULL) {
           /* one or both allocations failed; release everything */
           PORT_ArenaRelease (poolp, release);
       } else {
           /* everything okay; unmark the arena */
           PORT_ArenaUnmark (poolp, release);
       }
    } else {
       SECItem *indest;

       indest = dest;
       if (dest == NULL)
           dest = (SECItem*)PORT_Alloc (sizeof(SECItem));
       if (dest != NULL) {
           dest->type = siBuffer;
           dest->data = (unsigned char*)PORT_Alloc (len);
           if (dest->data == NULL) {
              if (indest == NULL)
                  PORT_Free (dest);
              dest = NULL;
           }
       }
    }

    return dest;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned long sec_asn1e_contents_length ( const SEC_ASN1Template theTemplate,
void src,
PRBool  disallowStreaming,
PRBool  insideIndefinite,
sec_asn1e_hdr_encoding pHdrException 
) [static]

Definition at line 511 of file secasn1e.c.

{
    unsigned long encode_kind, underlying_kind;
    PRBool isExplicit, optional, universal, may_stream;
    unsigned long len;

    /*
     * This function currently calculates the length in all cases
     * except the following: when writing out the contents of a 
     * template that belongs to a state where it was a sub-template
     * with the SEC_ASN1_MAY_STREAM bit set and it's parent had the
     * optional bit set.  The information that the parent is optional
     * and that we should return the length of 0 when that length is 
     * present since that means the optional field is no longer present.
     * So we add the disallowStreaming flag which is passed in when
     * writing the contents, but for all recursive calls to 
     * sec_asn1e_contents_length, we pass PR_FALSE, because this
     * function correctly calculates the length for children templates
     * from that point on.  Confused yet?  At least you didn't have
     * to figure it out.  ;)  -javi
     */
    encode_kind = theTemplate->kind;

    universal = ((encode_kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL)
              ? PR_TRUE : PR_FALSE;

    isExplicit = (encode_kind & SEC_ASN1_EXPLICIT) ? PR_TRUE : PR_FALSE;
    encode_kind &= ~SEC_ASN1_EXPLICIT;

    optional = (encode_kind & SEC_ASN1_OPTIONAL) ? PR_TRUE : PR_FALSE;
    encode_kind &= ~SEC_ASN1_OPTIONAL;

    PORT_Assert (!(isExplicit && universal));    /* bad templates */

    may_stream = (encode_kind & SEC_ASN1_MAY_STREAM) ? PR_TRUE : PR_FALSE;
    encode_kind &= ~SEC_ASN1_MAY_STREAM;

    /* Just clear this to get it out of the way; we do not need it here */
    encode_kind &= ~SEC_ASN1_DYNAMIC;

    if (encode_kind & SEC_ASN1_NO_STREAM) {
       disallowStreaming = PR_TRUE;
    }
    encode_kind &= ~SEC_ASN1_NO_STREAM;

    if (encode_kind & SEC_ASN1_CHOICE) {
       void *src2;
       int indx = sec_asn1e_which_choice(src, theTemplate);
       if (0 == indx) {
           /* XXX set an error? "choice not found" */
           /* state->top->status = encodeError; */
           return 0;
       }

        src2 = (void *)
               ((char *)src - theTemplate->offset + theTemplate[indx].offset);

        return sec_asn1e_contents_length(&theTemplate[indx], src2, 
                                    disallowStreaming, insideIndefinite,
                                    pHdrException);
    }

    if ((encode_kind & (SEC_ASN1_POINTER | SEC_ASN1_INLINE)) || !universal) {
       /* XXX any bits we want to disallow (PORT_Assert against) here? */
       theTemplate = SEC_ASN1GetSubtemplate (theTemplate, src, PR_TRUE);
       if (encode_kind & SEC_ASN1_POINTER) {
           src = *(void **)src;
           if (src == NULL) {
              *pHdrException = optional ? hdr_optional : hdr_normal;
              return 0;
           }
       } else if (encode_kind & SEC_ASN1_INLINE) {
           /* check that there are no extraneous bits */
           if (optional) {
              if (PR_FALSE != SEC_ASN1IsTemplateSimple(theTemplate)) {
                  /* we now know that the target is a SECItem*, so we can check
                     if the source contains one */
                  SECItem* target = (SECItem*)src;
                  if (!target || !target->data || !target->len) {
                     /* no valid data to encode subtemplate */
                     *pHdrException = hdr_optional;
                     return 0;
                  }
              } else {
                  PORT_Assert(0); /* complex templates not handled as inline
                                       optional */
              }
           }
       }

       src = (char *)src + theTemplate->offset;

       /* recurse to find the length of the subtemplate */
       len = sec_asn1e_contents_length (theTemplate, src, disallowStreaming, 
                                        insideIndefinite, pHdrException);
       if (len == 0 && optional) {
           *pHdrException = hdr_optional;
       } else if (isExplicit) {
           if (*pHdrException == hdr_any) {
              /* *we* do not want to add in a header, 
              ** but our caller still does. 
              */
              *pHdrException = hdr_normal;
           } else if (*pHdrException == hdr_normal) {
              /* if the inner content exists, our length is
               * len(identifier) + len(length) + len(innercontent)
               * XXX we currently assume len(identifier) == 1;
               * to support a high-tag-number this would need to be smarter.
               */
              len += 1 + SEC_ASN1LengthLength (len);
           }
       }
       return len;
    }
    underlying_kind = encode_kind;

    /* This is only used in decoding; it plays no part in encoding.  */
    if (underlying_kind & SEC_ASN1_SAVE) {
       /* check that there are no extraneous bits */
       PORT_Assert (underlying_kind == SEC_ASN1_SAVE);
       *pHdrException = hdr_decoder;
       return 0;
    }

#define UNEXPECTED_FLAGS \
 (SEC_ASN1_EXPLICIT | SEC_ASN1_OPTIONAL | SEC_ASN1_INLINE | SEC_ASN1_POINTER |\
  SEC_ASN1_DYNAMIC | SEC_ASN1_MAY_STREAM | SEC_ASN1_SAVE | SEC_ASN1_SKIP)

    /* Having any of these bits is not expected here...  */
    PORT_Assert ((underlying_kind & UNEXPECTED_FLAGS) == 0);
    underlying_kind &= ~UNEXPECTED_FLAGS;
#undef UNEXPECTED_FLAGS

    if (underlying_kind & SEC_ASN1_CHOICE) {
       void *src2;
       int indx = sec_asn1e_which_choice(src, theTemplate);
       if (0 == indx) {
           /* XXX set an error? "choice not found" */
           /* state->top->status = encodeError; */
           return 0;
       }

        src2 = (void *)
              ((char *)src - theTemplate->offset + theTemplate[indx].offset);
        len = sec_asn1e_contents_length(&theTemplate[indx], src2, 
                                       disallowStreaming, insideIndefinite, 
                                   pHdrException);
    } else {
      switch (underlying_kind) {
      case SEC_ASN1_SEQUENCE_OF:
      case SEC_ASN1_SET_OF:
       {
           const SEC_ASN1Template *tmpt;
           void *sub_src;
           unsigned long sub_len;
           void **group;

           len = 0;

           group = *(void ***)src;
           if (group == NULL)
              break;

           tmpt = SEC_ASN1GetSubtemplate (theTemplate, src, PR_TRUE);

           for (; *group != NULL; group++) {
              sub_src = (char *)(*group) + tmpt->offset;
              sub_len = sec_asn1e_contents_length (tmpt, sub_src, 
                                                   disallowStreaming,
                                               insideIndefinite,
                                                     pHdrException);
              len += sub_len;
              /*
               * XXX The 1 below is the presumed length of the identifier;
               * to support a high-tag-number this would need to be smarter.
               */
              if (*pHdrException == hdr_normal)
                  len += 1 + SEC_ASN1LengthLength (sub_len);
           }
       }
       break;

      case SEC_ASN1_SEQUENCE:
      case SEC_ASN1_SET:
       {
           const SEC_ASN1Template *tmpt;
           void *sub_src;
           unsigned long sub_len;

           len = 0;
           for (tmpt = theTemplate + 1; tmpt->kind; tmpt++) {
              sub_src = (char *)src + tmpt->offset;
              sub_len = sec_asn1e_contents_length (tmpt, sub_src, 
                                                   disallowStreaming,
                                               insideIndefinite,
                                                     pHdrException);
              len += sub_len;
              /*
               * XXX The 1 below is the presumed length of the identifier;
               * to support a high-tag-number this would need to be smarter.
               */
              if (*pHdrException == hdr_normal)
                  len += 1 + SEC_ASN1LengthLength (sub_len);
           }
       }
       break;

      case SEC_ASN1_BIT_STRING:
       /* convert bit length to byte */
       len = (((SECItem *)src)->len + 7) >> 3;
       /* bit string contents involve an extra octet */
       if (len)
           len++;
       break;

      case SEC_ASN1_INTEGER:
       /* ASN.1 INTEGERs are signed.
        * If the source is an unsigned integer, the encoder will need 
        * to handle the conversion here.
        */
       {
           unsigned char *buf = ((SECItem *)src)->data;
           SECItemType integerType = ((SECItem *)src)->type;
           len = ((SECItem *)src)->len;
           while (len > 0) {
              if (*buf != 0) {
                  if (*buf & 0x80 && integerType == siUnsignedInteger) {
                     len++; /* leading zero needed to make number signed */
                  }
                  break; /* reached beginning of number */
              }
              if (len == 1) {
                  break; /* the number 0 */
              }
              if (buf[1] & 0x80) {
                  break; /* leading zero already present */
              } 
              /* extraneous leading zero, keep going */
              buf++;
              len--;
           }
       }
       break;

      default:
       len = ((SECItem *)src)->len;
       break;
      }  /* end switch */

#ifndef WHAT_PROBLEM_DOES_THIS_SOLVE
      /* if we're streaming, we may have a secitem w/len 0 as placeholder */
      if (!len && insideIndefinite && may_stream && !disallowStreaming) {
         len = 1;
      }
#endif
    }    /* end else */

    if (len == 0 && optional)
       *pHdrException = hdr_optional;
    else if (underlying_kind == SEC_ASN1_ANY)
       *pHdrException = hdr_any;
    else 
       *pHdrException = hdr_normal;

    return len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_encode_item_count ( void arg,
const char *  buf,
unsigned long  len,
int  depth,
SEC_ASN1EncodingPart  data_kind 
) [static]

Definition at line 1479 of file secasn1e.c.

{
    unsigned long *count;

    count = (unsigned long*)arg;
    PORT_Assert (count != NULL);

    *count += len;
}

Here is the caller graph for this function:

static void sec_asn1e_encode_item_store ( void arg,
const char *  buf,
unsigned long  len,
int  depth,
SEC_ASN1EncodingPart  data_kind 
) [static]

Definition at line 1493 of file secasn1e.c.

{
    SECItem *dest;

    dest = (SECItem*)arg;
    PORT_Assert (dest != NULL);

    PORT_Memcpy (dest->data + dest->len, buf, len);
    dest->len += len;
}

Here is the caller graph for this function:

Definition at line 197 of file secasn1e.c.

{
    PRBool isExplicit, is_string, may_stream, optional, universal; 
    PRBool disallowStreaming;
    unsigned char tag_modifiers;
    unsigned long encode_kind, under_kind;
    unsigned long tag_number;
    PRBool isInline = PR_FALSE;


    encode_kind = state->theTemplate->kind;

    universal = ((encode_kind & SEC_ASN1_CLASS_MASK) == SEC_ASN1_UNIVERSAL)
              ? PR_TRUE : PR_FALSE;

    isExplicit = (encode_kind & SEC_ASN1_EXPLICIT) ? PR_TRUE : PR_FALSE;
    encode_kind &= ~SEC_ASN1_EXPLICIT;

    optional = (encode_kind & SEC_ASN1_OPTIONAL) ? PR_TRUE : PR_FALSE;
    encode_kind &= ~SEC_ASN1_OPTIONAL;

    PORT_Assert (!(isExplicit && universal));    /* bad templates */

    may_stream = (encode_kind & SEC_ASN1_MAY_STREAM) ? PR_TRUE : PR_FALSE;
    encode_kind &= ~SEC_ASN1_MAY_STREAM;

    disallowStreaming = (encode_kind & SEC_ASN1_NO_STREAM) ? PR_TRUE : PR_FALSE;
    encode_kind &= ~SEC_ASN1_NO_STREAM;

    /* Just clear this to get it out of the way; we do not need it here */
    encode_kind &= ~SEC_ASN1_DYNAMIC;

    if( encode_kind & SEC_ASN1_CHOICE ) {
      under_kind = SEC_ASN1_CHOICE;
    } else if ((encode_kind & (SEC_ASN1_POINTER | SEC_ASN1_INLINE)) || 
        (!universal && !isExplicit)) {
       const SEC_ASN1Template *subt;
       void *src = NULL;

       PORT_Assert ((encode_kind & (SEC_ASN1_ANY | SEC_ASN1_SKIP)) == 0);

       sec_asn1e_scrub_state (state);

       if (encode_kind & SEC_ASN1_POINTER) {
           src = *(void **)state->src;
           state->place = afterPointer;

           if (src == NULL) {
              /*
               * If this is optional, but NULL, then the field does
               * not need to be encoded.  In this case we are done;
               * we do not want to push a subtemplate.
               */
              if (optional)
                  return state;

              /*
               * XXX this is an error; need to figure out
               * how to handle this
               */
           }
       } else {
           src = state->src;
           if (encode_kind & SEC_ASN1_INLINE) {
              /* check that there are no extraneous bits */
              /* PORT_Assert (encode_kind == SEC_ASN1_INLINE && !optional); */
              state->place = afterInline;
              isInline = PR_TRUE;
           } else {
              /*
               * Save the tag modifiers and tag number here before moving
               * on to the next state in case this is a member of a
               * SEQUENCE OF
               */
              state->tag_modifiers = (unsigned char)
                  (encode_kind & (SEC_ASN1_TAG_MASK & ~SEC_ASN1_TAGNUM_MASK));
              state->tag_number = (unsigned char)
                  (encode_kind & SEC_ASN1_TAGNUM_MASK);
              
              state->place = afterImplicit;
              state->optional = optional;
           }
       }

       subt = SEC_ASN1GetSubtemplate (state->theTemplate, state->src, PR_TRUE);
       if (isInline && optional) {
           /* we only handle a very limited set of optional inline cases at
              this time */
           if (PR_FALSE != SEC_ASN1IsTemplateSimple(subt)) {
              /* we now know that the target is a SECItem*, so we can check
                 if the source contains one */
              SECItem* target = (SECItem*)state->src;
              if (!target || !target->data || !target->len) {
                  /* no valid data to encode subtemplate */
                  return state;
              }
           } else {
              PORT_Assert(0); /* complex templates are not handled as
                               inline optional */
           }
       }
       state = sec_asn1e_push_state (state->top, subt, src, PR_FALSE);
       if (state == NULL)
           return state;

       if (universal) {
           /*
            * This is a POINTER or INLINE; just init based on that
            * and we are done.
            */
           return sec_asn1e_init_state_based_on_template (state);
       }

       /*
        * This is an implicit, non-universal (meaning, application-private
        * or context-specific) field.  This results in a "magic" tag but
        * encoding based on the underlying type.  We pushed a new state
        * that is based on the subtemplate (the underlying type), but
        * now we will sort of alias it to give it some of our properties
        * (tag, optional status, etc.).
        *
        * NB: ALL the following flags in the subtemplate are disallowed
        *     and/or ignored: EXPLICIT, OPTIONAL, INNER, INLINE, POINTER.
        */

       under_kind = state->theTemplate->kind;
       if ((under_kind & SEC_ASN1_MAY_STREAM) && !disallowStreaming) {
           may_stream = PR_TRUE;
       }
       under_kind &= ~(SEC_ASN1_MAY_STREAM | SEC_ASN1_DYNAMIC);
    } else {
       under_kind = encode_kind;
    }

    /*
     * Sanity check that there are no unwanted bits marked in under_kind.
     * These bits were either removed above (after we recorded them) or
     * they simply should not be found (signalling a bad/broken template).
     * XXX is this the right set of bits to test here? (i.e. need to add
     * or remove any?)
     */
#define UNEXPECTED_FLAGS \
 (SEC_ASN1_EXPLICIT | SEC_ASN1_OPTIONAL | SEC_ASN1_SKIP | SEC_ASN1_INNER | \
  SEC_ASN1_DYNAMIC | SEC_ASN1_MAY_STREAM | SEC_ASN1_INLINE | SEC_ASN1_POINTER)

    PORT_Assert ((under_kind & UNEXPECTED_FLAGS) == 0);
    under_kind &= ~UNEXPECTED_FLAGS;
#undef UNEXPECTED_FLAGS

    if (encode_kind & SEC_ASN1_ANY) {
       PORT_Assert (encode_kind == under_kind);
       tag_modifiers = 0;
       tag_number = 0;
       is_string = PR_TRUE;
    } else {
       tag_modifiers = (unsigned char)
              (encode_kind & (SEC_ASN1_TAG_MASK & ~SEC_ASN1_TAGNUM_MASK));
       /*
        * XXX This assumes only single-octet identifiers.  To handle
        * the HIGH TAG form we would need to do some more work, especially
        * in how to specify them in the template, because right now we
        * do not provide a way to specify more *tag* bits in encode_kind.
        */
       tag_number = encode_kind & SEC_ASN1_TAGNUM_MASK;

       is_string = PR_FALSE;
       switch (under_kind & SEC_ASN1_TAGNUM_MASK) {
         case SEC_ASN1_SET:
           /*
            * XXX A plain old SET (as opposed to a SET OF) is not implemented.
            * If it ever is, remove this assert...
            */
           PORT_Assert ((under_kind & SEC_ASN1_GROUP) != 0);
           /* fallthru */
         case SEC_ASN1_SEQUENCE:
           tag_modifiers |= SEC_ASN1_CONSTRUCTED;
           break;
         case SEC_ASN1_BIT_STRING:
         case SEC_ASN1_BMP_STRING: 
         case SEC_ASN1_GENERALIZED_TIME:
         case SEC_ASN1_IA5_STRING:
         case SEC_ASN1_OCTET_STRING:
         case SEC_ASN1_PRINTABLE_STRING:
         case SEC_ASN1_T61_STRING:
         case SEC_ASN1_UNIVERSAL_STRING: 
         case SEC_ASN1_UTC_TIME:
         case SEC_ASN1_UTF8_STRING:
         case SEC_ASN1_VISIBLE_STRING: 
           /*
            * We do not yet know if we will be constructing the string,
            * so we have to wait to do this final tag modification.
            */
           is_string = PR_TRUE;
           break;
       }
    }

    state->tag_modifiers = tag_modifiers;
    state->tag_number = (unsigned char)tag_number;
    state->underlying_kind = under_kind;
    state->isExplicit = isExplicit;
    state->may_stream = may_stream;
    state->is_string = is_string;
    state->optional = optional;
    state->disallowStreaming = disallowStreaming;

    sec_asn1e_scrub_state (state);

    return state;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static SECItem* sec_asn1e_integer ( PRArenaPool poolp,
SECItem *  dest,
unsigned long  value,
PRBool  make_unsigned 
) [static]

Definition at line 1589 of file secasn1e.c.

{
    unsigned long copy;
    unsigned char sign;
    int len = 0;

    /*
     * Determine the length of the encoded value (minimum of 1).
     */
    copy = value;
    do {
       len++;
       sign = (unsigned char)(copy & 0x80);
       copy >>= 8;
    } while (copy);

    /*
     * If this is an unsigned encoding, and the high bit of the last
     * byte we counted was set, we need to add one to the length so
     * we put a high-order zero byte in the encoding.
     */
    if (sign && make_unsigned)
       len++;

    /*
     * Allocate the item (if necessary) and the data pointer within.
     */
    dest = sec_asn1e_allocate_item (poolp, dest, len);
    if (dest == NULL)
       return NULL;

    /*
     * Store the value, byte by byte, in the item.
     */
    dest->len = len;
    while (len) {
       dest->data[--len] = (unsigned char)value;
       value >>= 8;
    }
    PORT_Assert (value == 0);

    return dest;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_next_in_group ( sec_asn1e_state state) [static]

Definition at line 1142 of file secasn1e.c.

{
    sec_asn1e_state *child;
    void **group;
    void *member;

    PORT_Assert (state->place == duringGroup);
    PORT_Assert (state->child != NULL);

    child = state->child;

    group = *(void ***)state->src;

    /*
     * Find placement of current item.
     */
    member = (char *)(state->child->src) - child->theTemplate->offset;
    while (*group != member)
       group++;

    /*
     * Move forward to next item.
     */
    group++;
    if (*group == NULL) {
       /*
        * That was our last one; we are done now.
        */
       child->place = notInUse;
       state->place = afterContents;
       return;
    }
    child->src = (char *)(*group) + child->theTemplate->offset;

    /*
     * Re-"push" child.
     */
    sec_asn1e_scrub_state (child);
    state->top->current = child;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_next_in_sequence ( sec_asn1e_state state) [static]

Definition at line 1189 of file secasn1e.c.

{
    sec_asn1e_state *child;

    PORT_Assert (state->place == duringSequence);
    PORT_Assert (state->child != NULL);

    child = state->child;

    /*
     * Do the "after" field notification.
     */
    sec_asn1e_notify_after (state->top, child->src, child->depth);

    /*
     * Move forward.
     */
    child->theTemplate++;
    if (child->theTemplate->kind == 0) {
       /*
        * We are done with this sequence.
        */
       child->place = notInUse;
       state->place = afterContents;
       return;
    }

    /*
     * Reset state and push.
     */

    child->src = (char *)state->src + child->theTemplate->offset;

    /*
     * Do the "before" field notification.
     */
    sec_asn1e_notify_before (state->top, child->src, child->depth);

    state->top->current = child;
    (void) sec_asn1e_init_state_based_on_template (child);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_notify_after ( SEC_ASN1EncoderContext *  cx,
void src,
int  depth 
) [static]

Definition at line 185 of file secasn1e.c.

{
    if (cx->notify_proc == NULL)
       return;

    cx->during_notify = PR_TRUE;
    (* cx->notify_proc) (cx->notify_arg, PR_FALSE, src, depth);
    cx->during_notify = PR_FALSE;
}

Here is the caller graph for this function:

static void sec_asn1e_notify_before ( SEC_ASN1EncoderContext *  cx,
void src,
int  depth 
) [static]

Definition at line 173 of file secasn1e.c.

{
    if (cx->notify_proc == NULL)
       return;

    cx->during_notify = PR_TRUE;
    (* cx->notify_proc) (cx->notify_arg, PR_TRUE, src, depth);
    cx->during_notify = PR_FALSE;
}

Here is the caller graph for this function:

static sec_asn1e_state* sec_asn1e_push_state ( SEC_ASN1EncoderContext *  cx,
const SEC_ASN1Template theTemplate,
const void src,
PRBool  new_depth 
) [static]

Definition at line 126 of file secasn1e.c.

{
    sec_asn1e_state *state, *new_state;

    state = cx->current;

    new_state = (sec_asn1e_state*)PORT_ArenaZAlloc (cx->our_pool, 
                                              sizeof(*new_state));
    if (new_state == NULL) {
       cx->status = encodeError;
       return NULL;
    }

    new_state->top = cx;
    new_state->parent = state;
    new_state->theTemplate = theTemplate;
    new_state->place = notInUse;
    if (src != NULL)
       new_state->src = (char *)src + theTemplate->offset;

    if (state != NULL) {
       new_state->depth = state->depth;
       if (new_depth)
           new_state->depth++;
       state->child = new_state;
    }

    cx->current = new_state;
    return new_state;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_scrub_state ( sec_asn1e_state state) [static]

Definition at line 161 of file secasn1e.c.

{
    /*
     * Some default "scrubbing".
     * XXX right set of initializations?
     */
    state->place = beforeHeader;
    state->indefinite = PR_FALSE;
}

Here is the caller graph for this function:

static int sec_asn1e_which_choice ( void src,
const SEC_ASN1Template theTemplate 
) [static]

Definition at line 493 of file secasn1e.c.

{
  int rv;
  unsigned int which = *(unsigned int *)src;

  for( rv = 1, theTemplate++; theTemplate->kind != 0; rv++, theTemplate++ ) {
    if( which == theTemplate->size ) {
      return rv;
    }
  }

  return 0;
}

Here is the caller graph for this function:

static void sec_asn1e_write_contents ( sec_asn1e_state state) [static]

Definition at line 1033 of file secasn1e.c.

{
    unsigned long len = 0;

    PORT_Assert (state->place == duringContents);

    switch (state->underlying_kind) {
      case SEC_ASN1_SET:
      case SEC_ASN1_SEQUENCE:
       PORT_Assert (0);
       break;

      case SEC_ASN1_BIT_STRING:
       {
           SECItem *item;
           char rem;

           item = (SECItem *)state->src;
           len = (item->len + 7) >> 3;
           rem = (unsigned char)((len << 3) - item->len); /* remaining bits */
           sec_asn1e_write_contents_bytes (state, &rem, 1);
           sec_asn1e_write_contents_bytes (state, (char *) item->data, len);
       }
       break;

      case SEC_ASN1_BMP_STRING:
       /* The number of bytes must be divisable by 2 */
       if ((((SECItem *)state->src)->len) % 2) {
           SEC_ASN1EncoderContext *cx;

           cx = state->top;
           cx->status = encodeError;
           break;
       }
       /* otherwise, fall through to write the content */
       goto process_string;

      case SEC_ASN1_UNIVERSAL_STRING:
       /* The number of bytes must be divisable by 4 */
       if ((((SECItem *)state->src)->len) % 4) {
           SEC_ASN1EncoderContext *cx;

           cx = state->top;
           cx->status = encodeError;
           break;
       }
       /* otherwise, fall through to write the content */
       goto process_string;

      case SEC_ASN1_INTEGER:
       /* ASN.1 INTEGERs are signed.  If the source is an unsigned
       * integer, the encoder will need to handle the conversion here.
       */
       {
           unsigned int blen;
           unsigned char *buf;
           SECItemType integerType;
           blen = ((SECItem *)state->src)->len;
           buf = ((SECItem *)state->src)->data;
           integerType = ((SECItem *)state->src)->type;
           while (blen > 0) {
              if (*buf & 0x80 && integerType == siUnsignedInteger) {
                  char zero = 0; /* write a leading 0 */
                  sec_asn1e_write_contents_bytes(state, &zero, 1);
                  /* and then the remaining buffer */
                  sec_asn1e_write_contents_bytes(state, 
                                             (char *)buf, blen); 
                  break;
              } 
              /* Check three possibilities:
               * 1.  No leading zeros, msb of MSB is not 1;
               * 2.  The number is zero itself;
               * 3.  Encoding a signed integer with a leading zero,
               *     keep the zero so that the number is positive.
               */
              if (*buf != 0 || 
                   blen == 1 || 
                   (buf[1] & 0x80 && integerType != siUnsignedInteger) ) 
              {
                  sec_asn1e_write_contents_bytes(state, 
                                             (char *)buf, blen); 
                  break;
              }
              /* byte is 0, continue */
              buf++;
              blen--;
           }
       }
       /* done with this content */
       break;
                     
process_string:                    
      default:
       {
           SECItem *item;

           item = (SECItem *)state->src;
           sec_asn1e_write_contents_bytes (state, (char *) item->data,
                                       item->len);
       }
       break;
    }
    state->place = afterContents;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_write_contents_bytes ( sec_asn1e_state state,
const char *  buf,
unsigned long  len 
) [static]

Definition at line 476 of file secasn1e.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_write_contents_from_buf ( sec_asn1e_state state,
const char *  buf,
unsigned long  len 
) [static]

Definition at line 962 of file secasn1e.c.

{
    PORT_Assert (state->place == duringContents);
    PORT_Assert (state->top->from_buf);
    PORT_Assert (state->may_stream && !state->disallowStreaming);

    /*
     * Probably they just turned on "take from buf", but have not
     * yet given us any bytes.  If there is nothing in the buffer
     * then we have nothing to do but return and wait.
     */
    if (buf == NULL || len == 0) {
       state->top->status = needBytes;
       return;
    }
    /*
     * We are streaming, reading from a passed-in buffer.
     * This means we are encoding a simple string or an ANY.
     * For the former, we need to put out a substring, with its
     * own identifier and length.  For an ANY, we just write it
     * out as is (our caller is required to ensure that it
     * is a properly encoded entity).
     */
    PORT_Assert (state->is_string);              /* includes ANY */
    if (state->underlying_kind != SEC_ASN1_ANY) {
       unsigned char identifier;

       /*
        * Create the identifier based on underlying_kind.  We cannot
        * use tag_number and tag_modifiers because this can be an
        * implicitly encoded field.  In that case, the underlying
        * substrings *are* encoded with their real tag.
        */
       identifier = (unsigned char)
                           (state->underlying_kind & SEC_ASN1_TAG_MASK);
       /*
        * The underlying kind should just be a simple string; there
        * should be no bits like CONTEXT_SPECIFIC or CONSTRUCTED set.
        */
       PORT_Assert ((identifier & SEC_ASN1_TAGNUM_MASK) == identifier);
       /*
        * Write out the tag and length for the substring.
        */
       sec_asn1e_write_identifier_bytes (state, identifier);
       if (state->underlying_kind == SEC_ASN1_BIT_STRING) {
           char byte;
           /*
            * Assume we have a length in bytes but we need to output
            * a proper bit string.  This interface only works for bit
            * strings that are full multiples of 8.  If support for
            * real, variable length bit strings is needed then the
            * caller will have to know to pass in a bit length instead
            * of a byte length and then this code will have to
            * perform the encoding necessary (length written is length
            * in bytes plus 1, and the first octet of string is the
            * number of bits remaining between the end of the bit
            * string and the next byte boundary).
            */
           sec_asn1e_write_length_bytes (state, len + 1, PR_FALSE);
           byte = 0;
           sec_asn1e_write_contents_bytes (state, &byte, 1);
       } else {
           sec_asn1e_write_length_bytes (state, len, PR_FALSE);
       }
    }
    sec_asn1e_write_contents_bytes (state, buf, len);
    state->top->status = needBytes;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 484 of file secasn1e.c.

{
    const char eoc[2] = {0, 0};

    sec_asn1e_write_part (state, eoc, 2, SEC_ASN1_EndOfContents);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_write_header ( sec_asn1e_state state) [static]

Definition at line 782 of file secasn1e.c.

{
    unsigned long contents_length;
    unsigned char tag_number, tag_modifiers;
    sec_asn1e_hdr_encoding hdrException = hdr_normal;
    PRBool indefinite = PR_FALSE;

    PORT_Assert (state->place == beforeHeader);

    tag_number = state->tag_number;
    tag_modifiers = state->tag_modifiers;

    if (state->underlying_kind == SEC_ASN1_ANY) {
       state->place = duringContents;
       return;
    }

    if (state->underlying_kind & SEC_ASN1_CHOICE) {
       int indx = sec_asn1e_which_choice(state->src, state->theTemplate);
       if( 0 == indx ) {
           /* XXX set an error? "choice not found" */
           state->top->status = encodeError;
           return;
       }
       state->place = afterChoice;
       state = sec_asn1e_push_state(state->top, &state->theTemplate[indx],
                            (char *)state->src - state->theTemplate->offset, 
                            PR_TRUE);
       if (state) {
           /*
            * Do the "before" field notification.
            */
           sec_asn1e_notify_before (state->top, state->src, state->depth);
           state = sec_asn1e_init_state_based_on_template (state);
       }
       return;
    }

    /* The !isString test below is apparently intended to ensure that all 
    ** constructed types receive indefinite length encoding.
    */
   indefinite = (PRBool) 
       (state->top->streaming && state->may_stream && 
        (state->top->from_buf || !state->is_string));

    /*
     * If we are doing a definite-length encoding, first we have to
     * walk the data structure to calculate the entire contents length.
     * If we are doing an indefinite-length encoding, we still need to 
     * know if the contents is:
     *    optional and to be omitted, or 
     *    an ANY (header is pre-encoded), or 
     *    a SAVE or some other kind of template used only by the decoder.
     * So, we call this function either way.
     */
    contents_length = sec_asn1e_contents_length (state->theTemplate,
                                           state->src, 
                                                 state->disallowStreaming,
                                           indefinite,
                                                 &hdrException);
    /*
     * We might be told explicitly not to put out a header.
     * But it can also be the case, via a pushed subtemplate, that
     * sec_asn1e_contents_length could not know that this field is
     * really optional.  So check for that explicitly, too.
     */
    if (hdrException != hdr_normal || 
       (contents_length == 0 && state->optional)) {
       state->place = afterContents;
       if (state->top->streaming && 
           state->may_stream && 
           state->top->from_buf) {
           /* we did not find an optional indefinite string, so we 
            * don't encode it.  However, if TakeFromBuf is on, we stop 
            * here anyway to give our caller a chance to intercept at the 
            * same point where we would stop if the field were present. 
            */
           state->top->status = needBytes;
       }
       return;
    }

    if (indefinite) {
       /*
        * We need to put out an indefinite-length encoding.
        * The only universal types that can be constructed are SETs,
        * SEQUENCEs, and strings; so check that it is one of those,
        * or that it is not universal (e.g. context-specific).
        */
       state->indefinite = PR_TRUE;
       PORT_Assert ((tag_number == SEC_ASN1_SET)
                   || (tag_number == SEC_ASN1_SEQUENCE)
                   || ((tag_modifiers & SEC_ASN1_CLASS_MASK) != 0)
                   || state->is_string);
       tag_modifiers |= SEC_ASN1_CONSTRUCTED;
       contents_length = 0;
    }

    sec_asn1e_write_identifier_bytes (state, 
                                (unsigned char)(tag_number | tag_modifiers));
    sec_asn1e_write_length_bytes (state, contents_length, state->indefinite);

    if (contents_length == 0 && !state->indefinite) {
       /*
        * If no real contents to encode, then we are done with this field.
        */
       state->place = afterContents;
       return;
    }

    /*
     * An EXPLICIT is nothing but an outer header, which we have already
     * written.  Now we need to do the inner header and contents.
     */
    if (state->isExplicit) {
       const SEC_ASN1Template *subt =
             SEC_ASN1GetSubtemplate(state->theTemplate, state->src, PR_TRUE);
       state->place = afterContents;
       state = sec_asn1e_push_state (state->top, subt, state->src, PR_TRUE);
       if (state != NULL)
           state = sec_asn1e_init_state_based_on_template (state);
       return;
    }

    switch (state->underlying_kind) {
      case SEC_ASN1_SET_OF:
      case SEC_ASN1_SEQUENCE_OF:
       /*
        * We need to push a child to handle each member.
        */
       {
           void **group;
           const SEC_ASN1Template *subt;

           group = *(void ***)state->src;
           if (group == NULL || *group == NULL) {
              /*
               * Group is empty; we are done.
               */
              state->place = afterContents;
              return;
           }
           state->place = duringGroup;
           subt = SEC_ASN1GetSubtemplate (state->theTemplate, state->src,
                                      PR_TRUE);
           state = sec_asn1e_push_state (state->top, subt, *group, PR_TRUE);
           if (state != NULL)
              state = sec_asn1e_init_state_based_on_template (state);
       }
       break;

      case SEC_ASN1_SEQUENCE:
      case SEC_ASN1_SET:
       /*
        * We need to push a child to handle the individual fields.
        */
       state->place = duringSequence;
       state = sec_asn1e_push_state (state->top, state->theTemplate + 1,
                                  state->src, PR_TRUE);
       if (state != NULL) {
           /*
            * Do the "before" field notification.
            */
           sec_asn1e_notify_before (state->top, state->src, state->depth);
           state = sec_asn1e_init_state_based_on_template (state);
       }
       break;

      default:
       /*
        * I think we do not need to do anything else.
        * XXX Correct?
        */
       state->place = duringContents;
       break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_write_identifier_bytes ( sec_asn1e_state state,
unsigned char  value 
) [static]

Definition at line 427 of file secasn1e.c.

{
    char byte;

    byte = (char) value;
    sec_asn1e_write_part (state, &byte, 1, SEC_ASN1_Identifier);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_write_length_bytes ( sec_asn1e_state state,
unsigned long  value,
PRBool  indefinite 
) [static]

Definition at line 457 of file secasn1e.c.

{
    int lenlen;
    unsigned char buf[sizeof(unsigned long) + 1];

    if (indefinite) {
       PORT_Assert (value == 0);
       buf[0] = 0x80;
       lenlen = 1;
    } else {
       lenlen = SEC_ASN1EncodeLength(buf,value);
    }

    sec_asn1e_write_part (state, (char *) buf, lenlen, SEC_ASN1_Length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void sec_asn1e_write_part ( sec_asn1e_state state,
const char *  buf,
unsigned long  len,
SEC_ASN1EncodingPart  part 
) [static]

Definition at line 410 of file secasn1e.c.

{
    SEC_ASN1EncoderContext *cx;

    cx = state->top;
    (* cx->output_proc) (cx->output_arg, buf, len, state->depth, part);
}

Here is the caller graph for this function:

SECStatus SEC_ASN1Encode ( const void src,
const SEC_ASN1Template theTemplate,
SEC_ASN1WriteProc  output_proc,
void output_arg 
)

Definition at line 1457 of file secasn1e.c.

{
    SEC_ASN1EncoderContext *ecx;
    SECStatus rv;

    ecx = SEC_ASN1EncoderStart (src, theTemplate, output_proc, output_arg);
    if (ecx == NULL)
       return SECFailure;

    rv = SEC_ASN1EncoderUpdate (ecx, NULL, 0);

    SEC_ASN1EncoderFinish (ecx);
    return rv;
}
SECItem* SEC_ASN1EncodeInteger ( PRArenaPool poolp,
SECItem *  dest,
long  value 
)

Definition at line 1636 of file secasn1e.c.

{
    return sec_asn1e_integer (poolp, dest, (unsigned long) value, PR_FALSE);
}
SECItem* SEC_ASN1EncodeItem ( PRArenaPool poolp,
SECItem *  dest,
const void src,
const SEC_ASN1Template theTemplate 
)

Definition at line 1557 of file secasn1e.c.

{
    unsigned long encoding_length;
    SECStatus rv;

    PORT_Assert (dest == NULL || dest->data == NULL);

    encoding_length = 0;
    rv = SEC_ASN1Encode (src, theTemplate,
                      sec_asn1e_encode_item_count, &encoding_length);
    if (rv != SECSuccess)
       return NULL;

    dest = sec_asn1e_allocate_item (poolp, dest, encoding_length);
    if (dest == NULL)
       return NULL;

    /* XXX necessary?  This really just checks for a bug in the allocate fn */
    PORT_Assert (dest->data != NULL);
    if (dest->data == NULL)
       return NULL;

    dest->len = 0;
    (void) SEC_ASN1Encode (src, theTemplate, sec_asn1e_encode_item_store, dest);

    PORT_Assert (encoding_length == dest->len);
    return dest;
}
int SEC_ASN1EncodeLength ( unsigned char *  buf,
int  value 
)

Definition at line 436 of file secasn1e.c.

                                                   {
    int lenlen;

    lenlen = SEC_ASN1LengthLength (value);
    if (lenlen == 1) {
       buf[0] = value;
    } else {
       int i;

       i = lenlen - 1;
       buf[0] = 0x80 | i;
       while (i) {
           buf[i--] = value;
           value >>= 8;
       }
        PORT_Assert (value == 0);
    }
    return lenlen;
}
void SEC_ASN1EncoderAbort ( SEC_ASN1EncoderContext *  cx,
int  error 
)

Definition at line 1400 of file secasn1e.c.

void SEC_ASN1EncoderClearNotifyProc ( SEC_ASN1EncoderContext *  cx)

Definition at line 1393 of file secasn1e.c.

{
    cx->notify_proc = NULL;
    cx->notify_arg = NULL;  /* not necessary; just being clean */
}
void SEC_ASN1EncoderClearStreaming ( SEC_ASN1EncoderContext *  cx)

Definition at line 1417 of file secasn1e.c.

{
    /* XXX is there a way to check that we are "between" fields here? */

    cx->streaming = PR_FALSE;
}
void SEC_ASN1EncoderClearTakeFromBuf ( SEC_ASN1EncoderContext *  cx)

Definition at line 1440 of file secasn1e.c.

{
    /* we should actually be taking from buf *now* */
    PORT_Assert (cx->from_buf);
    if (! cx->from_buf)            /* if not, just do nothing */
       return;

    cx->from_buf = PR_FALSE;

    if (cx->status == needBytes) {
       cx->status = keepGoing;
       cx->current->place = afterContents;
    }
}
void SEC_ASN1EncoderFinish ( SEC_ASN1EncoderContext *  cx)

Definition at line 1331 of file secasn1e.c.

{
    /*
     * XXX anything else that needs to be finished?
     */

    PORT_FreeArena (cx->our_pool, PR_FALSE);
}
void SEC_ASN1EncoderSetNotifyProc ( SEC_ASN1EncoderContext *  cx,
SEC_ASN1NotifyProc  fn,
void arg 
)

Definition at line 1384 of file secasn1e.c.

{
    cx->notify_proc = fn;
    cx->notify_arg = arg;
}
void SEC_ASN1EncoderSetStreaming ( SEC_ASN1EncoderContext *  cx)

Definition at line 1408 of file secasn1e.c.

{
    /* XXX is there a way to check that we are "between" fields here? */

    cx->streaming = PR_TRUE;
}
void SEC_ASN1EncoderSetTakeFromBuf ( SEC_ASN1EncoderContext *  cx)

Definition at line 1426 of file secasn1e.c.

{
    /* 
     * XXX is there a way to check that we are "between" fields here?  this
     * needs to include a check for being in between groups of items in
     * a SET_OF or SEQUENCE_OF.
     */
    PORT_Assert (cx->streaming);

    cx->from_buf = PR_TRUE;
}
SEC_ASN1EncoderContext* SEC_ASN1EncoderStart ( const void src,
const SEC_ASN1Template theTemplate,
SEC_ASN1WriteProc  output_proc,
void output_arg 
)

Definition at line 1342 of file secasn1e.c.

{
    PRArenaPool *our_pool;
    SEC_ASN1EncoderContext *cx;

    our_pool = PORT_NewArena (SEC_ASN1_DEFAULT_ARENA_SIZE);
    if (our_pool == NULL)
       return NULL;

    cx = (SEC_ASN1EncoderContext*)PORT_ArenaZAlloc (our_pool, sizeof(*cx));
    if (cx == NULL) {
       PORT_FreeArena (our_pool, PR_FALSE);
       return NULL;
    }

    cx->our_pool = our_pool;
    cx->output_proc = output_proc;
    cx->output_arg = output_arg;

    cx->status = keepGoing;

    if (sec_asn1e_push_state(cx, theTemplate, src, PR_FALSE) == NULL
       || sec_asn1e_init_state_based_on_template (cx->current) == NULL) {
       /*
        * Trouble initializing (probably due to failed allocations)
        * requires that we just give up.
        */
       PORT_FreeArena (our_pool, PR_FALSE);
       return NULL;
    }

    return cx;
}
SECStatus SEC_ASN1EncoderUpdate ( SEC_ASN1EncoderContext *  cx,
const char *  buf,
unsigned long  len 
)

Definition at line 1260 of file secasn1e.c.

{
    sec_asn1e_state *state;

    if (cx->status == needBytes) {
       cx->status = keepGoing;
    }

    while (cx->status == keepGoing) {
       state = cx->current;
       switch (state->place) {
         case beforeHeader:
           sec_asn1e_write_header (state);
           break;
         case duringContents:
           if (cx->from_buf)
              sec_asn1e_write_contents_from_buf (state, buf, len);
           else
              sec_asn1e_write_contents (state);
           break;
         case duringGroup:
           sec_asn1e_next_in_group (state);
           break;
         case duringSequence:
           sec_asn1e_next_in_sequence (state);
           break;
         case afterContents:
           sec_asn1e_after_contents (state);
           break;
         case afterImplicit:
         case afterInline:
         case afterPointer:
         case afterChoice:
           /*
            * These states are more documentation than anything.
            * They just need to force a pop.
            */
           PORT_Assert (!state->indefinite);
           state->place = afterContents;
           break;
         case notInUse:
         default:
           /* This is not an error, but rather a plain old BUG! */
           PORT_Assert (0);
           cx->status = encodeError;
           break;
       }

       if (cx->status == encodeError)
           break;

       /* It might have changed, so we have to update our local copy.  */
       state = cx->current;

       /* If it is NULL, we have popped all the way to the top.  */
       if (state == NULL) {
           cx->status = allDone;
           break;
       }
    }

    if (cx->status == encodeError) {
       return SECFailure;
    }

    return SECSuccess;
}
SECItem* SEC_ASN1EncodeUnsignedInteger ( PRArenaPool poolp,
SECItem *  dest,
unsigned long  value 
)

Definition at line 1643 of file secasn1e.c.

{
    return sec_asn1e_integer (poolp, dest, value, PR_TRUE);
}