r10027: Use blob length for keeping track of buffer length, add TODO
[bbaumbach/samba-autobuild/.git] / source4 / lib / tdr / tdr.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    TDR (Trivial Data Representation) helper functions
5      Based loosely on ndr.c by Andrew Tridgell.
6
7    Copyright (C) Jelmer Vernooij 2005
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "system/network.h"
26 #include "system/filesys.h"
27
28 #define TDR_BASE_MARSHALL_SIZE 1024
29
30 #define TDR_PUSH_NEED_BYTES(tdr, n) TDR_CHECK(tdr_push_expand(tdr, tdr->data.length+(n)))
31
32 #define TDR_PULL_NEED_BYTES(tdr, n) do { \
33         if ((n) > tdr->data.length || tdr->offset + (n) > tdr->data.length) { \
34                 return NT_STATUS_BUFFER_TOO_SMALL; \
35         } \
36 } while(0)
37
38 #define TDR_BE(tdr) ((tdr)->flags & TDR_BIG_ENDIAN)
39
40 #define TDR_CVAL(tdr, ofs) CVAL(tdr->data.data,ofs)
41 #define TDR_SVAL(tdr, ofs) (TDR_BE(tdr)?RSVAL(tdr->data.data,ofs):SVAL(tdr->data.data,ofs))
42 #define TDR_IVAL(tdr, ofs) (TDR_BE(tdr)?RIVAL(tdr->data.data,ofs):IVAL(tdr->data.data,ofs))
43 #define TDR_IVALS(tdr, ofs) (TDR_BE(tdr)?RIVALS(tdr->data.data,ofs):IVALS(tdr->data.data,ofs))
44 #define TDR_SCVAL(tdr, ofs, v) SCVAL(tdr->data.data,ofs,v)
45 #define TDR_SSVAL(tdr, ofs, v) do { if (TDR_BE(tdr))  { RSSVAL(tdr->data.data,ofs,v); } else SSVAL(tdr->data.data,ofs,v); } while (0)
46 #define TDR_SIVAL(tdr, ofs, v) do { if (TDR_BE(tdr))  { RSIVAL(tdr->data.data,ofs,v); } else SIVAL(tdr->data.data,ofs,v); } while (0)
47 #define TDR_SIVALS(tdr, ofs, v) do { if (TDR_BE(tdr))  { RSIVALS(tdr->data.data,ofs,v); } else SIVALS(tdr->data.data,ofs,v); } while (0)
48
49 /*
50   expand the available space in the buffer to 'size'
51 */
52 NTSTATUS tdr_push_expand(struct tdr_push *tdr, uint32_t size)
53 {
54         if (talloc_get_size(tdr->data.data) >= size) {
55                 return NT_STATUS_OK;
56         }
57
58         tdr->data.data = talloc_realloc(tdr, tdr->data.data, uint8_t, tdr->data.length + TDR_BASE_MARSHALL_SIZE);
59
60         if (tdr->data.data == NULL)
61                 return NT_STATUS_NO_MEMORY;
62
63         return NT_STATUS_OK;
64 }
65
66
67 NTSTATUS tdr_pull_uint8(struct tdr_pull *tdr, uint8_t *v)
68 {
69         TDR_PULL_NEED_BYTES(tdr, 1);
70         *v = TDR_CVAL(tdr, tdr->offset);
71         tdr->offset += 1;
72         return NT_STATUS_OK;
73 }
74
75 NTSTATUS tdr_push_uint8(struct tdr_push *tdr, const uint8_t *v)
76 {
77         TDR_PUSH_NEED_BYTES(tdr, 1);
78         TDR_SCVAL(tdr, tdr->data.length, *v);
79         tdr->data.length += 1;
80         return NT_STATUS_OK;
81 }
82
83 NTSTATUS tdr_print_uint8(struct tdr_print *tdr, const char *name, uint8_t *v)
84 {
85         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
86         return NT_STATUS_OK;
87 }
88
89 NTSTATUS tdr_pull_uint16(struct tdr_pull *tdr, uint16_t *v)
90 {
91         TDR_PULL_NEED_BYTES(tdr, 2);
92         *v = TDR_SVAL(tdr, tdr->offset);
93         tdr->offset += 2;
94         return NT_STATUS_OK;
95 }
96
97 NTSTATUS tdr_push_uint16(struct tdr_push *tdr, const uint16_t *v)
98 {
99         TDR_PUSH_NEED_BYTES(tdr, 2);
100         TDR_SSVAL(tdr, tdr->data.length, *v);
101         tdr->data.length += 2;
102         return NT_STATUS_OK;
103 }
104
105 NTSTATUS tdr_print_uint16(struct tdr_print *tdr, const char *name, uint16_t *v)
106 {
107         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
108         return NT_STATUS_OK;
109 }
110
111 NTSTATUS tdr_pull_uint32(struct tdr_pull *tdr, uint32_t *v)
112 {
113         TDR_PULL_NEED_BYTES(tdr, 4);
114         *v = TDR_IVAL(tdr, tdr->offset);
115         tdr->offset += 4;
116         return NT_STATUS_OK;
117 }
118
119 NTSTATUS tdr_push_uint32(struct tdr_push *tdr, const uint32_t *v)
120 {
121         TDR_PUSH_NEED_BYTES(tdr, 4);
122         TDR_SIVAL(tdr, tdr->data.length, *v);
123         tdr->data.length += 4;
124         return NT_STATUS_OK;
125 }
126
127 NTSTATUS tdr_print_uint32(struct tdr_print *tdr, const char *name, uint32_t *v)
128 {
129         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
130         return NT_STATUS_OK;
131 }
132
133 NTSTATUS tdr_pull_charset(struct tdr_pull *tdr, const char **v, uint32_t length, uint32_t el_size, int chset)
134 {
135         int ret;
136
137         if (length == -1) {
138                 switch (chset) {
139                         case CH_DOS:
140                                 length = ascii_len_n((const char*)tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
141                                 break;
142                         case CH_UTF16:
143                                 length = utf16_len_n(tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
144                                 break;
145
146                         default:
147                                 return NT_STATUS_INVALID_PARAMETER;
148                 }
149         }
150
151         if (length == 0) {
152                 *v = talloc_strdup(tdr, "");
153                 return NT_STATUS_OK;
154         }
155
156         TDR_PULL_NEED_BYTES(tdr, el_size*length);
157         
158         ret = convert_string_talloc(tdr, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v));
159
160         if (ret == -1) {
161                 return NT_STATUS_INVALID_PARAMETER;
162         }
163
164         tdr->offset += length * el_size;
165
166         return NT_STATUS_OK;
167 }
168
169 NTSTATUS tdr_push_charset(struct tdr_push *tdr, const char **v, uint32_t length, uint32_t el_size, int chset)
170 {
171         ssize_t ret, required;
172
173         required = el_size * length;
174         TDR_PUSH_NEED_BYTES(tdr, required);
175
176         ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required);
177
178         if (ret == -1) {
179                 return NT_STATUS_INVALID_PARAMETER;
180         }
181
182         /* Make sure the remaining part of the string is filled with zeroes */
183         if (ret < required) {
184                 memset(tdr->data.data+tdr->data.length+ret, 0, required-ret);
185         }
186         
187         tdr->data.length += required;
188                                                  
189         return NT_STATUS_OK;
190 }
191
192 NTSTATUS tdr_print_charset(struct tdr_print *tdr, const char *name, const char **v, uint32_t length, uint32_t el_size, int chset)
193 {
194         tdr->print(tdr, "%-25s: %s", name, *v);
195         return NT_STATUS_OK;
196 }
197
198 /*
199   pull a ipv4address
200 */
201 NTSTATUS tdr_pull_ipv4address(struct tdr_pull *tdr, const char **address)
202 {
203         struct ipv4_addr in;
204         TDR_CHECK(tdr_pull_uint32(tdr, &in.addr));
205         in.addr = htonl(in.addr);
206         *address = talloc_strdup(tdr, sys_inet_ntoa(in));
207         NT_STATUS_HAVE_NO_MEMORY(*address);
208         return NT_STATUS_OK;
209 }
210
211 /*
212   push a ipv4address
213 */
214 NTSTATUS tdr_push_ipv4address(struct tdr_push *tdr, const char **address)
215 {
216         uint32_t addr = htonl(interpret_addr(*address));
217         TDR_CHECK(tdr_push_uint32(tdr, &addr));
218         return NT_STATUS_OK;
219 }
220
221 /*
222   print a ipv4address
223 */
224 NTSTATUS tdr_print_ipv4address(struct tdr_print *tdr, const char *name, 
225                            const char **address)
226 {
227         tdr->print(tdr, "%-25s: %s", name, *address);
228         return NT_STATUS_OK;
229 }
230
231 /*
232   parse a hyper
233 */
234 NTSTATUS tdr_pull_hyper(struct tdr_pull *tdr, uint64_t *v)
235 {
236         TDR_PULL_NEED_BYTES(tdr, 8);
237         *v = TDR_IVAL(tdr, tdr->offset);
238         *v |= (uint64_t)(TDR_IVAL(tdr, tdr->offset+4)) << 32;
239         tdr->offset += 8;
240         return NT_STATUS_OK;
241 }
242
243 /*
244   push a hyper
245 */
246 NTSTATUS tdr_push_hyper(struct tdr_push *tdr, uint64_t *v)
247 {
248         TDR_PUSH_NEED_BYTES(tdr, 8);
249         TDR_SIVAL(tdr, tdr->data.length, ((*v) & 0xFFFFFFFF));
250         TDR_SIVAL(tdr, tdr->data.length+4, ((*v)>>32));
251         tdr->data.length += 8;
252         return NT_STATUS_OK;
253 }
254
255
256
257 /*
258   push a NTTIME
259 */
260 NTSTATUS tdr_push_NTTIME(struct tdr_push *tdr, NTTIME *t)
261 {
262         TDR_CHECK(tdr_push_hyper(tdr, t));
263         return NT_STATUS_OK;
264 }
265
266 /*
267   pull a NTTIME
268 */
269 NTSTATUS tdr_pull_NTTIME(struct tdr_pull *tdr, NTTIME *t)
270 {
271         TDR_CHECK(tdr_pull_hyper(tdr, t));
272         return NT_STATUS_OK;
273 }
274
275 /*
276   push a time_t
277 */
278 NTSTATUS tdr_push_time_t(struct tdr_push *tdr, time_t *t)
279 {
280         return tdr_push_uint32(tdr, (uint32_t *)t);
281 }
282
283 /*
284   pull a time_t
285 */
286 NTSTATUS tdr_pull_time_t(struct tdr_pull *tdr, time_t *t)
287 {
288         uint32_t tt;
289         TDR_CHECK(tdr_pull_uint32(tdr, &tt));
290         *t = tt;
291         return NT_STATUS_OK;
292 }
293
294 NTSTATUS tdr_print_time_t(struct tdr_print *tdr, const char *name, time_t *t)
295 {
296         if (*t == (time_t)-1 || *t == 0) {
297                 tdr->print(tdr, "%-25s: (time_t)%d", name, (int)*t);
298         } else {
299                 tdr->print(tdr, "%-25s: %s", name, timestring(tdr, *t));
300         }
301
302         return NT_STATUS_OK;
303 }
304
305 NTSTATUS tdr_print_NTTIME(struct tdr_print *tdr, const char *name, NTTIME *t)
306 {
307         tdr->print(tdr, "%-25s: %s", name, nt_time_string(tdr, *t));
308
309         return NT_STATUS_OK;
310 }
311
312 NTSTATUS tdr_print_DATA_BLOB(struct tdr_print *tdr, const char *name, DATA_BLOB *r)
313 {
314         tdr->print(tdr, "%-25s: DATA_BLOB length=%u", name, r->length);
315         if (r->length) {
316                 dump_data(10, r->data, r->length);
317         }
318
319         return NT_STATUS_OK;
320 }
321
322 #define TDR_ALIGN(l,n) (((l) & ((n)-1)) == 0?0:((n)-((l)&((n)-1))))
323
324 /*
325   push a DATA_BLOB onto the wire. 
326 */
327 NTSTATUS tdr_push_DATA_BLOB(struct tdr_push *tdr, DATA_BLOB *blob)
328 {
329         if (tdr->flags & TDR_ALIGN2) {
330                 blob->length = TDR_ALIGN(tdr->data.length, 2);
331         } else if (tdr->flags & TDR_ALIGN4) {
332                 blob->length = TDR_ALIGN(tdr->data.length, 4);
333         } else if (tdr->flags & TDR_ALIGN8) {
334                 blob->length = TDR_ALIGN(tdr->data.length, 8);
335         }
336
337         TDR_PUSH_NEED_BYTES(tdr, blob->length);
338         
339         memcpy(tdr->data.data+tdr->data.length, blob->data, blob->length);
340         return NT_STATUS_OK;
341 }
342
343 /*
344   pull a DATA_BLOB from the wire. 
345 */
346 NTSTATUS tdr_pull_DATA_BLOB(struct tdr_pull *tdr, DATA_BLOB *blob)
347 {
348         uint32_t length;
349
350         if (tdr->flags & TDR_ALIGN2) {
351                 length = TDR_ALIGN(tdr->offset, 2);
352         } else if (tdr->flags & TDR_ALIGN4) {
353                 length = TDR_ALIGN(tdr->offset, 4);
354         } else if (tdr->flags & TDR_ALIGN8) {
355                 length = TDR_ALIGN(tdr->offset, 8);
356         } else if (tdr->flags & TDR_REMAINING) {
357                 length = tdr->data.length - tdr->offset;
358         } else {
359                 return NT_STATUS_INVALID_PARAMETER;
360         }
361
362         if (tdr->data.length - tdr->offset < length) {
363                 length = tdr->data.length - tdr->offset;
364         }
365
366         TDR_PULL_NEED_BYTES(tdr, length);
367
368         *blob = data_blob_talloc(tdr, tdr->data.data+tdr->offset, length);
369         tdr->offset += length;
370         return NT_STATUS_OK;
371 }
372
373 NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p)
374 {
375         struct tdr_push *push = talloc_zero(NULL, struct tdr_push);
376
377         if (push == NULL)
378                 return NT_STATUS_NO_MEMORY;
379
380         if (NT_STATUS_IS_ERR(push_fn(push, p))) {
381                 DEBUG(1, ("Error pushing data\n"));
382                 talloc_free(push);
383                 return NT_STATUS_UNSUCCESSFUL;
384         }
385
386         if (write(fd, push->data.data, push->data.length) < push->data.length) {
387                 DEBUG(1, ("Error writing all data\n"));
388                 return NT_STATUS_UNSUCCESSFUL;
389         }
390
391         talloc_free(push);
392
393         return NT_STATUS_OK;
394 }