crypto/o_str.c

   1 /*
   2  * Copyright 2003-2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include "e_os.h"
  11 #include <limits.h>
  12 #include <openssl/crypto.h>
  13 #include "internal/cryptlib.h"
  14
  15 char *CRYPTO_strdup(const char *str, const char* file, int line)
  16 {
  17     char *ret;
  18
  19     if (str == NULL)
  20         return NULL;
  21     ret = CRYPTO_malloc(strlen(str) + 1, file, line);
  22     if (ret != NULL)
  23         strcpy(ret, str);
  24     return ret;
  25 }
  26
  27 char *CRYPTO_strndup(const char *str, size_t s, const char* file, int line)
  28 {
  29     size_t maxlen;
  30     char *ret;
  31
  32     if (str == NULL)
  33         return NULL;
  34
  35     maxlen = OPENSSL_strnlen(str, s);
  36
  37     ret = CRYPTO_malloc(maxlen + 1, file, line);
  38     if (ret) {
  39         memcpy(ret, str, maxlen);
  40         ret[maxlen] = '\0';
  41     }
  42     return ret;
  43 }
  44
  45 void *CRYPTO_memdup(const void *data, size_t siz, const char* file, int line)
  46 {
  47     void *ret;
  48
  49     if (data == NULL || siz >= INT_MAX)
  50         return NULL;
  51
  52     ret = CRYPTO_malloc(siz, file, line);
  53     if (ret == NULL) {
  54         CRYPTOerr(CRYPTO_F_CRYPTO_MEMDUP, ERR_R_MALLOC_FAILURE);
  55         return NULL;
  56     }
  57     return memcpy(ret, data, siz);
  58 }
  59
  60 size_t OPENSSL_strnlen(const char *str, size_t maxlen)
  61 {
  62     const char *p;
  63
  64     for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
  65
  66     return p - str;
  67 }
  68
  69 size_t OPENSSL_strlcpy(char *dst, const char *src, size_t size)
  70 {
  71     size_t l = 0;
  72     for (; size > 1 && *src; size--) {
  73         *dst++ = *src++;
  74         l++;
  75     }
  76     if (size)
  77         *dst = '\0';
  78     return l + strlen(src);
  79 }
  80
  81 size_t OPENSSL_strlcat(char *dst, const char *src, size_t size)
  82 {
  83     size_t l = 0;
  84     for (; size > 0 && *dst; size--, dst++)
  85         l++;
  86     return l + OPENSSL_strlcpy(dst, src, size);
  87 }
  88
  89 int OPENSSL_hexchar2int(unsigned char c)
  90 {
  91 #ifdef CHARSET_EBCDIC
  92     c = os_toebcdic[c];
  93 #endif
  94
  95     switch (c) {
  96     case '0':
  97         return 0;
  98     case '1':
  99         return 1;
 100     case '2':
 101         return 2;
 102     case '3':
 103         return 3;
 104     case '4':
 105           return 4;
 106     case '5':
 107           return 5;
 108     case '6':
 109           return 6;
 110     case '7':
 111           return 7;
 112     case '8':
 113           return 8;
 114     case '9':
 115           return 9;
 116     case 'a': case 'A':
 117           return 0x0A;
 118     case 'b': case 'B':
 119           return 0x0B;
 120     case 'c': case 'C':
 121           return 0x0C;
 122     case 'd': case 'D':
 123           return 0x0D;
 124     case 'e': case 'E':
 125           return 0x0E;
 126     case 'f': case 'F':
 127           return 0x0F;
 128     }
 129     return -1;
 130 }
 131
 132 /*
 133  * Give a string of hex digits convert to a buffer
 134  */
 135 unsigned char *OPENSSL_hexstr2buf(const char *str, long *len)
 136 {
 137     unsigned char *hexbuf, *q;
 138     unsigned char ch, cl;
 139     int chi, cli;
 140     const unsigned char *p;
 141     size_t s;
 142
 143     s = strlen(str);
 144     if ((hexbuf = OPENSSL_malloc(s >> 1)) == NULL) {
 145         CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF, ERR_R_MALLOC_FAILURE);
 146         return NULL;
 147     }
 148     for (p = (const unsigned char *)str, q = hexbuf; *p; ) {
 149         ch = *p++;
 150         if (ch == ':')
 151             continue;
 152         cl = *p++;
 153         if (!cl) {
 154             CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF,
 155                       CRYPTO_R_ODD_NUMBER_OF_DIGITS);
 156             OPENSSL_free(hexbuf);
 157             return NULL;
 158         }
 159         cli = OPENSSL_hexchar2int(cl);
 160         chi = OPENSSL_hexchar2int(ch);
 161         if (cli < 0 || chi < 0) {
 162             OPENSSL_free(hexbuf);
 163             CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF, CRYPTO_R_ILLEGAL_HEX_DIGIT);
 164             return NULL;
 165         }
 166         *q++ = (unsigned char)((chi << 4) | cli);
 167     }
 168
 169     if (len)
 170         *len = q - hexbuf;
 171     return hexbuf;
 172 }
 173
 174 /*
 175  * Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its
 176  * hex representation @@@ (Contents of buffer are always kept in ASCII, also
 177  * on EBCDIC machines)
 178  */
 179 char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len)
 180 {
 181     static const char hexdig[] = "0123456789ABCDEF";
 182     char *tmp, *q;
 183     const unsigned char *p;
 184     int i;
 185
 186     if (len == 0)
 187         return OPENSSL_zalloc(1);
 188
 189     if ((tmp = OPENSSL_malloc(len * 3)) == NULL) {
 190         CRYPTOerr(CRYPTO_F_OPENSSL_BUF2HEXSTR, ERR_R_MALLOC_FAILURE);
 191         return NULL;
 192     }
 193     q = tmp;
 194     for (i = 0, p = buffer; i < len; i++, p++) {
 195         *q++ = hexdig[(*p >> 4) & 0xf];
 196         *q++ = hexdig[*p & 0xf];
 197         *q++ = ':';
 198     }
 199     q[-1] = 0;
 200 #ifdef CHARSET_EBCDIC
 201     ebcdic2ascii(tmp, tmp, q - tmp - 1);
 202 #endif
 203
 204     return tmp;
 205 }
 206
 207 int openssl_strerror_r(int errnum, char *buf, size_t buflen)
 208 {
 209 #if defined(_MSC_VER) && _MSC_VER>=1400
 210     return !strerror_s(buf, buflen, errnum);
 211 #elif defined(_GNU_SOURCE)
 212     char *err;
 213
 214     /*
 215      * GNU strerror_r may not actually set buf.
 216      * It can return a pointer to some (immutable) static string in which case
 217      * buf is left unused.
 218      */
 219     err = strerror_r(errnum, buf, buflen);
 220     if (err == NULL || buflen == 0)
 221         return 0;
 222     /*
 223      * If err is statically allocated, err != buf and we need to copy the data.
 224      * If err points somewhere inside buf, OPENSSL_strlcpy can handle this,
 225      * since src and dest are not annotated with __restrict and the function
 226      * reads src byte for byte and writes to dest.
 227      * If err == buf we do not have to copy anything.
 228      */
 229     if (err != buf)
 230         OPENSSL_strlcpy(buf, err, buflen);
 231     return 1;
 232 #elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
 233       (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
 234     /*
 235      * We can use "real" strerror_r. The OpenSSL version differs in that it
 236      * gives 1 on success and 0 on failure for consistency with other OpenSSL
 237      * functions. Real strerror_r does it the other way around
 238      */
 239     return !strerror_r(errnum, buf, buflen);
 240 #else
 241     char *err;
 242
 243     /* Fall back to non-thread safe strerror()...its all we can do */
 244     if (buflen < 2)
 245         return 0;
 246     err = strerror(errnum);
 247     /* Can this ever happen? */
 248     if (err == NULL)
 249         return 0;
 250     OPENSSL_strlcpy(buf, err, buflen);
 251     return 1;
 252 #endif
 253 }