lib/util Split data_blob_hex_string() into upper and lower
[ira/wip.git] / lib / util / data_blob.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Easy management of byte-length data
4    Copyright (C) Andrew Tridgell 2001
5    Copyright (C) Andrew Bartlett 2001
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22
23 const DATA_BLOB data_blob_null = { NULL, 0 };
24
25 /**
26  * @file
27  * @brief Manipulation of arbitrary data blobs
28  **/
29
30 /**
31  construct a data blob, must be freed with data_blob_free()
32  you can pass NULL for p and get a blank data blob
33 **/
34 _PUBLIC_ DATA_BLOB data_blob_named(const void *p, size_t length, const char *name)
35 {
36         DATA_BLOB ret;
37
38         if (p == NULL && length == 0) {
39                 ZERO_STRUCT(ret);
40                 return ret;
41         }
42
43         if (p) {
44                 ret.data = (uint8_t *)talloc_memdup(NULL, p, length);
45         } else {
46                 ret.data = talloc_array(NULL, uint8_t, length);
47         }
48         if (ret.data == NULL) {
49                 ret.length = 0;
50                 return ret;
51         }
52         talloc_set_name_const(ret.data, name);
53         ret.length = length;
54         return ret;
55 }
56
57 /**
58  construct a data blob, using supplied TALLOC_CTX
59 **/
60 _PUBLIC_ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name)
61 {
62         DATA_BLOB ret = data_blob_named(p, length, name);
63
64         if (ret.data) {
65                 talloc_steal(mem_ctx, ret.data);
66         }
67         return ret;
68 }
69
70
71 /**
72  reference a data blob, to the supplied TALLOC_CTX.  
73  Returns a NULL DATA_BLOB on failure
74 **/
75 _PUBLIC_ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
76 {
77         DATA_BLOB ret = *blob;
78
79         ret.data = talloc_reference(mem_ctx, blob->data);
80
81         if (!ret.data) {
82                 return data_blob(NULL, 0);
83         }
84         return ret;
85 }
86
87 /**
88  construct a zero data blob, using supplied TALLOC_CTX. 
89  use this sparingly as it initialises data - better to initialise
90  yourself if you want specific data in the blob
91 **/
92 _PUBLIC_ DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length)
93 {
94         DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, length);
95         data_blob_clear(&blob);
96         return blob;
97 }
98
99 /**
100 free a data blob
101 **/
102 _PUBLIC_ void data_blob_free(DATA_BLOB *d)
103 {
104         if (d) {
105                 talloc_free(d->data);
106                 d->data = NULL;
107                 d->length = 0;
108         }
109 }
110
111 /**
112 clear a DATA_BLOB's contents
113 **/
114 _PUBLIC_ void data_blob_clear(DATA_BLOB *d)
115 {
116         if (d->data) {
117                 memset(d->data, 0, d->length);
118         }
119 }
120
121 /**
122 free a data blob and clear its contents
123 **/
124 _PUBLIC_ void data_blob_clear_free(DATA_BLOB *d)
125 {
126         data_blob_clear(d);
127         data_blob_free(d);
128 }
129
130
131 /**
132 check if two data blobs are equal
133 **/
134 _PUBLIC_ int data_blob_cmp(const DATA_BLOB *d1, const DATA_BLOB *d2)
135 {
136         int ret;
137         if (d1->data == NULL && d2->data != NULL) {
138                 return -1;
139         }
140         if (d1->data != NULL && d2->data == NULL) {
141                 return 1;
142         }
143         if (d1->data == d2->data) {
144                 return d1->length - d2->length;
145         }
146         ret = memcmp(d1->data, d2->data, MIN(d1->length, d2->length));
147         if (ret == 0) {
148                 return d1->length - d2->length;
149         }
150         return ret;
151 }
152
153 /**
154 print the data_blob as hex string
155 **/
156 _PUBLIC_ char *data_blob_hex_string_lower(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
157 {
158         int i;
159         char *hex_string;
160
161         hex_string = talloc_array(mem_ctx, char, (blob->length*2)+1);
162         if (!hex_string) {
163                 return NULL;
164         }
165
166         /* this must be lowercase or w2k8 cannot join a samba domain,
167            as this routine is used to encode extended DNs and windows
168            only accepts lowercase hexadecimal numbers */
169         for (i = 0; i < blob->length; i++)
170                 slprintf(&hex_string[i*2], 3, "%02x", blob->data[i]);
171
172         hex_string[(blob->length*2)] = '\0';
173         return hex_string;
174 }
175
176 _PUBLIC_ char *data_blob_hex_string_upper(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
177 {
178         int i;
179         char *hex_string;
180
181         hex_string = talloc_array(mem_ctx, char, (blob->length*2)+1);
182         if (!hex_string) {
183                 return NULL;
184         }
185
186         for (i = 0; i < blob->length; i++)
187                 slprintf(&hex_string[i*2], 3, "%02X", blob->data[i]);
188
189         hex_string[(blob->length*2)] = '\0';
190         return hex_string;
191 }
192
193 /**
194   useful for constructing data blobs in test suites, while
195   avoiding const warnings
196 **/
197 _PUBLIC_ DATA_BLOB data_blob_string_const(const char *str)
198 {
199         DATA_BLOB blob;
200         blob.data = discard_const_p(uint8_t, str);
201         blob.length = str ? strlen(str) : 0;
202         return blob;
203 }
204
205 /**
206   useful for constructing data blobs in test suites, while
207   avoiding const warnings
208 **/
209 _PUBLIC_ DATA_BLOB data_blob_string_const_null(const char *str)
210 {
211         DATA_BLOB blob;
212         blob.data = discard_const_p(uint8_t, str);
213         blob.length = str ? strlen(str)+1 : 0;
214         return blob;
215 }
216
217 /**
218  * Create a new data blob from const data 
219  */
220
221 _PUBLIC_ DATA_BLOB data_blob_const(const void *p, size_t length)
222 {
223         DATA_BLOB blob;
224         blob.data = discard_const_p(uint8_t, p);
225         blob.length = length;
226         return blob;
227 }
228
229
230 /**
231   realloc a data_blob
232 **/
233 _PUBLIC_ bool data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t length)
234 {
235         blob->data = talloc_realloc(mem_ctx, blob->data, uint8_t, length);
236         if (blob->data == NULL)
237                 return false;
238         blob->length = length;
239         return true;
240 }
241
242
243 /**
244   append some data to a data blob
245 **/
246 _PUBLIC_ bool data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
247                                    const void *p, size_t length)
248 {
249         size_t old_len = blob->length;
250         size_t new_len = old_len + length;
251         if (new_len < length || new_len < old_len) {
252                 return false;
253         }
254
255         if ((const uint8_t *)p + length < (const uint8_t *)p) {
256                 return false;
257         }
258         
259         if (!data_blob_realloc(mem_ctx, blob, new_len)) {
260                 return false;
261         }
262
263         memcpy(blob->data + old_len, p, length);
264         return true;
265 }
266