Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2005 Kungliga Tekniska Högskolan
       3             :  * (Royal Institute of Technology, Stockholm, Sweden).
       4             :  * All rights reserved.
       5             :  *
       6             :  * Redistribution and use in source and binary forms, with or without
       7             :  * modification, are permitted provided that the following conditions
       8             :  * are met:
       9             :  *
      10             :  * 1. Redistributions of source code must retain the above copyright
      11             :  *    notice, this list of conditions and the following disclaimer.
      12             :  *
      13             :  * 2. Redistributions in binary form must reproduce the above copyright
      14             :  *    notice, this list of conditions and the following disclaimer in the
      15             :  *    documentation and/or other materials provided with the distribution.
      16             :  *
      17             :  * 3. Neither the name of the Institute nor the names of its contributors
      18             :  *    may be used to endorse or promote products derived from this software
      19             :  *    without specific prior written permission.
      20             :  *
      21             :  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
      22             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      23             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      24             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
      25             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      26             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      27             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      28             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      29             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      30             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      31             :  * SUCH DAMAGE.
      32             :  */
      33             : 
      34             : #include "der_locl.h"
      35             : #include <hex.h>
      36             : 
      37             : RCSID("$Id$");
      38             : 
      39             : int ASN1CALL
      40        1302 : der_parse_hex_heim_integer (const char *p, heim_integer *data)
      41             : {
      42          48 :     ssize_t len;
      43             : 
      44        1302 :     data->length = 0;
      45        1302 :     data->negative = 0;
      46        1302 :     data->data = NULL;
      47             : 
      48        1302 :     if (*p == '-') {
      49           0 :         p++;
      50           0 :         data->negative = 1;
      51             :     }
      52             : 
      53        1302 :     len = strlen(p);
      54        1302 :     if (len <= 0) {
      55           0 :         data->data = NULL;
      56           0 :         data->length = 0;
      57           0 :         return EINVAL;
      58             :     }
      59             : 
      60        1302 :     data->length = (len / 2) + 1;
      61        1302 :     data->data = malloc(data->length);
      62        1302 :     if (data->data == NULL) {
      63           0 :         data->length = 0;
      64           0 :         return ENOMEM;
      65             :     }
      66             : 
      67        1302 :     len = hex_decode(p, data->data, data->length);
      68        1302 :     if (len < 0) {
      69           0 :         free(data->data);
      70           0 :         data->data = NULL;
      71           0 :         data->length = 0;
      72           0 :         return EINVAL;
      73             :     }
      74             : 
      75             :     {
      76        1302 :         unsigned char *q = data->data;
      77        1302 :         while(len > 0 && *q == 0) {
      78           0 :             q++;
      79           0 :             len--;
      80             :         }
      81        1302 :         data->length = len;
      82        1302 :         memmove(data->data, q, len);
      83             :     }
      84        1302 :     return 0;
      85             : }
      86             : 
      87             : int ASN1CALL
      88           0 : der_print_hex_heim_integer (const heim_integer *data, char **p)
      89             : {
      90           0 :     ssize_t len;
      91           0 :     char *q;
      92             : 
      93           0 :     len = hex_encode(data->data, data->length, p);
      94           0 :     if (len < 0)
      95           0 :         return ENOMEM;
      96             : 
      97           0 :     if (data->negative) {
      98           0 :         len = asprintf(&q, "-%s", *p);
      99           0 :         free(*p);
     100           0 :         if (len < 0)
     101           0 :             return ENOMEM;
     102           0 :         *p = q;
     103             :     }
     104           0 :     return 0;
     105             : }
     106             : 
     107             : int ASN1CALL
     108       20280 : der_print_heim_oid (const heim_oid *oid, char delim, char **str)
     109             : {
     110       20280 :     struct rk_strpool *p = NULL;
     111         785 :     size_t i;
     112             : 
     113       20280 :     if (oid->length == 0)
     114           0 :         return EINVAL;
     115             : 
     116      162240 :     for (i = 0; i < oid->length ; i++) {
     117      141960 :         p = rk_strpoolprintf(p, "%d", oid->components[i]);
     118      141960 :         if (p && i < oid->length - 1)
     119      121680 :             p = rk_strpoolprintf(p, "%c", delim);
     120      141960 :         if (p == NULL) {
     121           0 :             *str = NULL;
     122           0 :             return ENOMEM;
     123             :         }
     124             :     }
     125             : 
     126       20280 :     *str = rk_strpoolcollect(p);
     127       20280 :     if (*str == NULL)
     128           0 :         return ENOMEM;
     129       19495 :     return 0;
     130             : }
     131             : 
     132             : int ASN1CALL
     133           0 : der_parse_heim_oid (const char *str, const char *sep, heim_oid *data)
     134             : {
     135           0 :     char *s, *w, *brkt, *endptr;
     136           0 :     unsigned int *c;
     137           0 :     long l;
     138             : 
     139           0 :     data->length = 0;
     140           0 :     data->components = NULL;
     141             : 
     142           0 :     if (sep == NULL)
     143           0 :         sep = ".";
     144             : 
     145           0 :     s = strdup(str);
     146             : 
     147           0 :     for (w = strtok_r(s, sep, &brkt);
     148           0 :          w != NULL;
     149           0 :          w = strtok_r(NULL, sep, &brkt)) {
     150             : 
     151           0 :         c = realloc(data->components,
     152           0 :                     (data->length + 1) * sizeof(data->components[0]));
     153           0 :         if (c == NULL) {
     154           0 :             der_free_oid(data);
     155           0 :             free(s);
     156           0 :             return ENOMEM;
     157             :         }
     158           0 :         data->components = c;
     159             : 
     160           0 :         l = strtol(w, &endptr, 10);
     161           0 :         if (*endptr != '\0' || l < 0 || l > INT_MAX) {
     162           0 :             der_free_oid(data);
     163           0 :             free(s);
     164           0 :             return EINVAL;
     165             :         }
     166           0 :         data->components[data->length++] = (unsigned int)l;
     167             :     }
     168           0 :     free(s);
     169           0 :     return 0;
     170             : }