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