projects / silc.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Added SILC Thread Queue API
[silc.git] / lib / silcasn1 / silcasn1_encode.c
diff --git a/lib/silcasn1/silcasn1_encode.c b/lib/silcasn1/silcasn1_encode.c
index d4b7077a25407e439843f8919ec54df48cfb49e1..58dfbf278bcdedbcf62961c4e7b56a2962661f85 100644 (file)
--- a/lib/silcasn1/silcasn1_encode.c
+++ b/lib/silcasn1/silcasn1_encode.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 2003 - 2006 Pekka Riikonen
+  Copyright (C) 2003 - 2007 Pekka Riikonen
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -21,6 +21,9 @@
 #include "silcasn1.h"
 #include "silcber.h"
 
+#define SILC_ASN1_BUFFER_FREE(b, stack) if (!stack) silc_buffer_purge(b);
+#define SILC_ASN1_STACK(stack, asn1) stack ? stack : asn1->orig_stack
+
 /************************** ASN.1 Encoder routines **************************/
 
 /* Encode string from UTF-8 string to other string encodings.  Encodes
@@ -36,13 +39,13 @@
     goto fail;                                                         \
   }                                                                    \
   silc_stack_push(asn1->stack2, &frame);                               \
-  s = silc_smalloc_ua(stack2, s_len + 1);                              \
+  s = silc_smalloc(stack2, s_len + 1);                                 \
   if (s) {                                                             \
     silc_utf8_decode(d, d_len, (enc), s, s_len);                       \
     s[s_len] = '\0';                                                   \
   }                                                                    \
   len = silc_ber_encoded_len(tag, s_len, indef);                       \
-  dest = silc_buffer_srealloc_size(stack1, dest,                       \
+  dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,        \
                                   silc_buffer_truelen(dest) + len);    \
   ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,       \
                        tag, s, s_len, indef);                          \
@@ -136,19 +139,21 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
       ret = silc_asn1_encoder(asn1, stack2, stack1, type, type,
                              SILC_BER_CLASS_UNIVERSAL, opts,
                              &buf, depth + 1, primitive);
-      silc_stack_pop(stack2);
 
       if (!ret) {
        SILC_LOG_DEBUG(("Error encoding explicit tag"));
+       silc_stack_pop(stack2);
        goto fail;
       }
 
       /* Encode the explicit tag */
       len = silc_ber_encoded_len(tag, silc_buffer_len(&buf), FALSE);
-      dest = silc_buffer_srealloc_size(stack1, dest,
+      dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                       silc_buffer_truelen(dest) + len);
       ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_CONSTRUCTED,
                            tag, buf.data, silc_buffer_len(&buf), FALSE);
+      SILC_ASN1_BUFFER_FREE(&buf, stack2);
+      silc_stack_pop(stack2);
       if (!ret)
        goto fail;
       if (primitive) {
@@ -188,7 +193,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
 
          /* Now encode with implicit tagging */
          len = silc_ber_encoded_len(tag, d_len, FALSE);
-         dest = silc_buffer_srealloc_size(stack1, dest,
+         dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                           silc_buffer_truelen(dest) + len);
          ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_CONSTRUCTED,
                                tag, d, d_len, FALSE);
@@ -197,7 +202,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        } else {
          /* Copy the data directly into the tree. */
          len = silc_buffer_len(node);
-         dest = silc_buffer_srealloc_size(stack1, dest,
+         dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                           silc_buffer_truelen(dest) + len);
          if (!dest)
            goto fail;
@@ -215,7 +220,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
 
        /* Encode the primitive data */
        len = silc_ber_encoded_len(tag, silc_buffer_len(prim), FALSE);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, prim->data, silc_buffer_len(prim), FALSE);
@@ -237,18 +242,20 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        silc_stack_push(stack2, &frame);
        ret = silc_asn1_encoder(asn1, stack2, stack1, rtype, rtag, rclass,
                                ropts, &buf, depth + 1, FALSE);
-       silc_stack_pop(stack2);
        if (!ret) {
          SILC_LOG_DEBUG(("Error traversing a SEQUENCE/SET"));
+         silc_stack_pop(stack2);
          goto fail;
        }
 
        /* Encode the sequence */
        len = silc_ber_encoded_len(tag, silc_buffer_len(&buf), indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_CONSTRUCTED,
                              tag, buf.data, silc_buffer_len(&buf), indef);
+       SILC_ASN1_BUFFER_FREE(&buf, stack2);
+       silc_stack_pop(stack2);
        if (!ret)
          goto fail;
        break;
@@ -282,10 +289,11 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
 
        /* Encode the integer */
        len = silc_ber_encoded_len(tag, len, indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, buf.data, silc_buffer_len(&buf), FALSE);
+       SILC_ASN1_BUFFER_FREE(&buf, stack2);
        silc_stack_pop(stack2);
        if (!ret)
          goto fail;
@@ -320,10 +328,11 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
 
        /* Encode the integer */
        len = silc_ber_encoded_len(tag, len, indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, buf.data, silc_buffer_len(&buf), FALSE);
+       SILC_ASN1_BUFFER_FREE(&buf, stack2);
        silc_stack_pop(stack2);
        if (!ret)
          goto fail;
@@ -343,7 +352,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        /* Get OID words from the string */
        cp = strchr(oidstr, '.');
        while (cp) {
-         if (sscanf(oidstr, "%lu", (unsigned long *)&oid) != 1) {
+         if (sscanf(oidstr, "%lu", &oid) != 1) {
            SILC_LOG_DEBUG(("Malformed OID string"));
            goto fail;
          }
@@ -354,7 +363,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
          cp = strchr(oidstr, '.');
 
          if (!cp) {
-           if (sscanf(oidstr, "%lu", (unsigned long *)&oid) != 1) {
+           if (sscanf(oidstr, "%lu", &oid) != 1) {
              SILC_LOG_DEBUG(("Malformed OID string"));
              goto fail;
            }
@@ -410,10 +419,11 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        }
 
        len = silc_ber_encoded_len(tag, silc_buffer_len(&buf), indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, buf.data, silc_buffer_len(&buf), FALSE);
+       SILC_ASN1_BUFFER_FREE(&buf, stack2);
        silc_stack_pop(stack2);
        if (!ret)
          goto fail;
@@ -428,7 +438,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
 
        assert(indef == FALSE);
        len = silc_ber_encoded_len(tag, 1, FALSE);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, val, 1, FALSE);
@@ -459,10 +469,11 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        silc_buffer_push(&buf, 1);
 
        len = silc_ber_encoded_len(tag, silc_buffer_len(&buf), indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, buf.data, silc_buffer_len(&buf), indef);
+       SILC_ASN1_BUFFER_FREE(&buf, stack2);
        silc_stack_pop(stack2);
        if (!ret)
          goto fail;
@@ -472,14 +483,21 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
     case SILC_ASN1_TAG_NULL:
       {
        /* Encode empty BER block */
+       SilcBool val = va_arg(asn1->ap, SilcUInt32);
+
        assert(indef == FALSE);
+
+       if (!val)
+         break;
+
        len = silc_ber_encoded_len(tag, 0, FALSE);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, NULL, 0, FALSE);
        if (!ret)
          goto fail;
+
        break;
       }
 
@@ -497,7 +515,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        }
 
        len = silc_ber_encoded_len(tag, strlen(timestr), indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, timestr, strlen(timestr), indef);
@@ -520,7 +538,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        }
 
        len = silc_ber_encoded_len(tag, strlen(timestr), indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, timestr, strlen(timestr), indef);
@@ -544,7 +562,7 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
        }
 
        len = silc_ber_encoded_len(tag, d_len, indef);
-       dest = silc_buffer_srealloc_size(stack1, dest,
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
                                         silc_buffer_truelen(dest) + len);
        ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
                              tag, d, d_len, indef);
@@ -555,8 +573,17 @@ silc_asn1_encoder(SilcAsn1 asn1, SilcStack stack1, SilcStack stack2,
 
     case SILC_ASN1_TAG_OCTET_STRING:
       {
-       /* Octet string.  We put it in as 8-bit ASCII */
-       SILC_ASN1_ENCODE_STRING(SILC_STRING_ASCII);
+       /* Octet string.  Put data as is. */
+       unsigned char *d = va_arg(asn1->ap, unsigned char *);
+       SilcUInt32 d_len = va_arg(asn1->ap, SilcUInt32);
+
+       len = silc_ber_encoded_len(tag, d_len, indef);
+       dest = silc_buffer_srealloc_size(SILC_ASN1_STACK(stack1, asn1), dest,
+                                        silc_buffer_truelen(dest) + len);
+       ret = silc_ber_encode(dest, ber_class, SILC_BER_ENC_PRIMITIVE,
+                             tag, d, d_len, indef);
+       if (!ret)
+         goto fail;
        break;
       }
 
@@ -674,7 +701,7 @@ SilcBool silc_asn1_encode(SilcAsn1 asn1, SilcBuffer dest, ...)
   SilcAsn1Options opts;
   SilcBerClass ber_class;
   SilcStackFrame frame1, frame2;
-  SilcStack stack1 = NULL;
+  SilcStack stack1 = NULL, orig;
   SilcBool ret;
 
   if (!asn1)
@@ -682,11 +709,13 @@ SilcBool silc_asn1_encode(SilcAsn1 asn1, SilcBuffer dest, ...)
 
   va_start(asn1->ap, dest);
 
+  orig = asn1->orig_stack;
+  asn1->orig_stack = NULL;
+
   /* Get the first arguments and call the encoder. */
   SILC_ASN1_ARGS(asn1, type, tag, ber_class, opts);
   if (!type) {
     va_end(asn1->ap);
-    asn1->ap = NULL;
     return FALSE;
   }
 
@@ -699,6 +728,7 @@ SilcBool silc_asn1_encode(SilcAsn1 asn1, SilcBuffer dest, ...)
         that stack aware calls revert to normal allocation routines. */
       stack1 = asn1->stack1;
       asn1->stack1 = NULL;
+      asn1->orig_stack = orig;
     }
 
     if (o & SILC_ASN1_ACCUMUL) {
@@ -740,8 +770,9 @@ SilcBool silc_asn1_encode(SilcAsn1 asn1, SilcBuffer dest, ...)
   if (stack1 && !asn1->stack1)
     asn1->stack1 = stack1;
 
+  asn1->orig_stack = orig;
+
   va_end(asn1->ap);
-  asn1->ap = NULL;
 
   return ret;
 }
SILC - Secure Internet Live Conferencing