r15356: Remove unused 'flags' argument from socket_send() and friends.
[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 #include "tdr/tdr.h"
28
29 #define TDR_BASE_MARSHALL_SIZE 1024
30
31 #define TDR_PUSH_NEED_BYTES(tdr, n) TDR_CHECK(tdr_push_expand(tdr, tdr->data.length+(n)))
32
33 #define TDR_PULL_NEED_BYTES(tdr, n) do { \
34         if ((n) > tdr->data.length || tdr->offset + (n) > tdr->data.length) { \
35                 return NT_STATUS_BUFFER_TOO_SMALL; \
36         } \
37 } while(0)
38
39 #define TDR_BE(tdr) ((tdr)->flags & TDR_BIG_ENDIAN)
40
41 #define TDR_CVAL(tdr, ofs) CVAL(tdr->data.data,ofs)
42 #define TDR_SVAL(tdr, ofs) (TDR_BE(tdr)?RSVAL(tdr->data.data,ofs):SVAL(tdr->data.data,ofs))
43 #define TDR_IVAL(tdr, ofs) (TDR_BE(tdr)?RIVAL(tdr->data.data,ofs):IVAL(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
48 /*
49   expand the available space in the buffer to 'size'
50 */
51 NTSTATUS tdr_push_expand(struct tdr_push *tdr, uint32_t size)
52 {
53         if (talloc_get_size(tdr->data.data) >= size) {
54                 return NT_STATUS_OK;
55         }
56
57         tdr->data.data = talloc_realloc(tdr, tdr->data.data, uint8_t, tdr->data.length + TDR_BASE_MARSHALL_SIZE);
58
59         if (tdr->data.data == NULL)
60                 return NT_STATUS_NO_MEMORY;
61
62         return NT_STATUS_OK;
63 }
64
65
66 NTSTATUS tdr_pull_uint8(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint8_t *v)
67 {
68         TDR_PULL_NEED_BYTES(tdr, 1);
69         *v = TDR_CVAL(tdr, tdr->offset);
70         tdr->offset += 1;
71         return NT_STATUS_OK;
72 }
73
74 NTSTATUS tdr_push_uint8(struct tdr_push *tdr, const uint8_t *v)
75 {
76         TDR_PUSH_NEED_BYTES(tdr, 1);
77         TDR_SCVAL(tdr, tdr->data.length, *v);
78         tdr->data.length += 1;
79         return NT_STATUS_OK;
80 }
81
82 NTSTATUS tdr_print_uint8(struct tdr_print *tdr, const char *name, uint8_t *v)
83 {
84         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
85         return NT_STATUS_OK;
86 }
87
88 NTSTATUS tdr_pull_uint16(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v)
89 {
90         TDR_PULL_NEED_BYTES(tdr, 2);
91         *v = TDR_SVAL(tdr, tdr->offset);
92         tdr->offset += 2;
93         return NT_STATUS_OK;
94 }
95
96 NTSTATUS tdr_push_uint16(struct tdr_push *tdr, const uint16_t *v)
97 {
98         TDR_PUSH_NEED_BYTES(tdr, 2);
99         TDR_SSVAL(tdr, tdr->data.length, *v);
100         tdr->data.length += 2;
101         return NT_STATUS_OK;
102 }
103
104 NTSTATUS tdr_print_uint16(struct tdr_print *tdr, const char *name, uint16_t *v)
105 {
106         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
107         return NT_STATUS_OK;
108 }
109
110 NTSTATUS tdr_pull_uint32(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint32_t *v)
111 {
112         TDR_PULL_NEED_BYTES(tdr, 4);
113         *v = TDR_IVAL(tdr, tdr->offset);
114         tdr->offset += 4;
115         return NT_STATUS_OK;
116 }
117
118 NTSTATUS tdr_push_uint32(struct tdr_push *tdr, const uint32_t *v)
119 {
120         TDR_PUSH_NEED_BYTES(tdr, 4);
121         TDR_SIVAL(tdr, tdr->data.length, *v);
122         tdr->data.length += 4;
123         return NT_STATUS_OK;
124 }
125
126 NTSTATUS tdr_print_uint32(struct tdr_print *tdr, const char *name, uint32_t *v)
127 {
128         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
129         return NT_STATUS_OK;
130 }
131
132 NTSTATUS tdr_pull_charset(struct tdr_pull *tdr, TALLOC_CTX *ctx, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
133 {
134         int ret;
135
136         if (length == -1) {
137                 switch (chset) {
138                         case CH_DOS:
139                                 length = ascii_len_n((const char*)tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
140                                 break;
141                         case CH_UTF16:
142                                 length = utf16_len_n(tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
143                                 break;
144
145                         default:
146                                 return NT_STATUS_INVALID_PARAMETER;
147                 }
148         }
149
150         if (length == 0) {
151                 *v = talloc_strdup(ctx, "");
152                 return NT_STATUS_OK;
153         }
154
155         TDR_PULL_NEED_BYTES(tdr, el_size*length);
156         
157         ret = convert_string_talloc(ctx, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v));
158
159         if (ret == -1) {
160                 return NT_STATUS_INVALID_PARAMETER;
161         }
162
163         tdr->offset += length * el_size;
164
165         return NT_STATUS_OK;
166 }
167
168 NTSTATUS tdr_push_charset(struct tdr_push *tdr, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
169 {
170         ssize_t ret, required;
171
172         if (length == -1) {
173                 length = strlen(*v) + 1; /* Extra element for null character */
174         }
175
176         required = el_size * length;
177         TDR_PUSH_NEED_BYTES(tdr, required);
178
179         ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required);
180
181         if (ret == -1) {
182                 return NT_STATUS_INVALID_PARAMETER;
183         }
184
185         /* Make sure the remaining part of the string is filled with zeroes */
186         if (ret < required) {
187                 memset(tdr->data.data+tdr->data.length+ret, 0, required-ret);
188         }
189         
190         tdr->data.length += required;
191                                                  
192         return NT_STATUS_OK;
193 }
194
195 NTSTATUS tdr_print_charset(struct tdr_print *tdr, const char *name, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
196 {
197         tdr->print(tdr, "%-25s: %s", name, *v);
198         return NT_STATUS_OK;
199 }
200
201 /*
202   pull a ipv4address
203 */
204 NTSTATUS tdr_pull_ipv4address(struct tdr_pull *tdr, TALLOC_CTX *ctx, const char **address)
205 {
206         struct ipv4_addr in;
207         TDR_CHECK(tdr_pull_uint32(tdr, ctx, &in.addr));
208         in.addr = htonl(in.addr);
209         *address = talloc_strdup(tdr, sys_inet_ntoa(in));
210         NT_STATUS_HAVE_NO_MEMORY(*address);
211         return NT_STATUS_OK;
212 }
213
214 /*
215   push a ipv4address
216 */
217 NTSTATUS tdr_push_ipv4address(struct tdr_push *tdr, const char **address)
218 {
219         uint32_t addr = htonl(interpret_addr(*address));
220         TDR_CHECK(tdr_push_uint32(tdr, &addr));
221         return NT_STATUS_OK;
222 }
223
224 /*
225   print a ipv4address
226 */
227 NTSTATUS tdr_print_ipv4address(struct tdr_print *tdr, const char *name, 
228                            const char **address)
229 {
230         tdr->print(tdr, "%-25s: %s", name, *address);
231         return NT_STATUS_OK;
232 }
233
234 /*
235   parse a hyper
236 */
237 NTSTATUS tdr_pull_hyper(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint64_t *v)
238 {
239         TDR_PULL_NEED_BYTES(tdr, 8);
240         *v = TDR_IVAL(tdr, tdr->offset);
241         *v |= (uint64_t)(TDR_IVAL(tdr, tdr->offset+4)) << 32;
242         tdr->offset += 8;
243         return NT_STATUS_OK;
244 }
245
246 /*
247   push a hyper
248 */
249 NTSTATUS tdr_push_hyper(struct tdr_push *tdr, uint64_t *v)
250 {
251         TDR_PUSH_NEED_BYTES(tdr, 8);
252         TDR_SIVAL(tdr, tdr->data.length, ((*v) & 0xFFFFFFFF));
253         TDR_SIVAL(tdr, tdr->data.length+4, ((*v)>>32));
254         tdr->data.length += 8;
255         return NT_STATUS_OK;
256 }
257
258
259
260 /*
261   push a NTTIME
262 */
263 NTSTATUS tdr_push_NTTIME(struct tdr_push *tdr, NTTIME *t)
264 {
265         TDR_CHECK(tdr_push_hyper(tdr, t));
266         return NT_STATUS_OK;
267 }
268
269 /*
270   pull a NTTIME
271 */
272 NTSTATUS tdr_pull_NTTIME(struct tdr_pull *tdr, TALLOC_CTX *ctx, NTTIME *t)
273 {
274         TDR_CHECK(tdr_pull_hyper(tdr, ctx, t));
275         return NT_STATUS_OK;
276 }
277
278 /*
279   push a time_t
280 */
281 NTSTATUS tdr_push_time_t(struct tdr_push *tdr, time_t *t)
282 {
283         return tdr_push_uint32(tdr, (uint32_t *)t);
284 }
285
286 /*
287   pull a time_t
288 */
289 NTSTATUS tdr_pull_time_t(struct tdr_pull *tdr, TALLOC_CTX *ctx, time_t *t)
290 {
291         uint32_t tt;
292         TDR_CHECK(tdr_pull_uint32(tdr, ctx, &tt));
293         *t = tt;
294         return NT_STATUS_OK;
295 }
296
297 NTSTATUS tdr_print_time_t(struct tdr_print *tdr, const char *name, time_t *t)
298 {
299         if (*t == (time_t)-1 || *t == 0) {
300                 tdr->print(tdr, "%-25s: (time_t)%d", name, (int)*t);
301         } else {
302                 tdr->print(tdr, "%-25s: %s", name, timestring(tdr, *t));
303         }
304
305         return NT_STATUS_OK;
306 }
307
308 NTSTATUS tdr_print_NTTIME(struct tdr_print *tdr, const char *name, NTTIME *t)
309 {
310         tdr->print(tdr, "%-25s: %s", name, nt_time_string(tdr, *t));
311
312         return NT_STATUS_OK;
313 }
314
315 NTSTATUS tdr_print_DATA_BLOB(struct tdr_print *tdr, const char *name, DATA_BLOB *r)
316 {
317         tdr->print(tdr, "%-25s: DATA_BLOB length=%u", name, r->length);
318         if (r->length) {
319                 dump_data(10, r->data, r->length);
320         }
321
322         return NT_STATUS_OK;
323 }
324
325 #define TDR_ALIGN(l,n) (((l) & ((n)-1)) == 0?0:((n)-((l)&((n)-1))))
326
327 /*
328   push a DATA_BLOB onto the wire. 
329 */
330 NTSTATUS tdr_push_DATA_BLOB(struct tdr_push *tdr, DATA_BLOB *blob)
331 {
332         if (tdr->flags & TDR_ALIGN2) {
333                 blob->length = TDR_ALIGN(tdr->data.length, 2);
334         } else if (tdr->flags & TDR_ALIGN4) {
335                 blob->length = TDR_ALIGN(tdr->data.length, 4);
336         } else if (tdr->flags & TDR_ALIGN8) {
337                 blob->length = TDR_ALIGN(tdr->data.length, 8);
338         }
339
340         TDR_PUSH_NEED_BYTES(tdr, blob->length);
341         
342         memcpy(tdr->data.data+tdr->data.length, blob->data, blob->length);
343         return NT_STATUS_OK;
344 }
345
346 /*
347   pull a DATA_BLOB from the wire. 
348 */
349 NTSTATUS tdr_pull_DATA_BLOB(struct tdr_pull *tdr, TALLOC_CTX *ctx, DATA_BLOB *blob)
350 {
351         uint32_t length;
352
353         if (tdr->flags & TDR_ALIGN2) {
354                 length = TDR_ALIGN(tdr->offset, 2);
355         } else if (tdr->flags & TDR_ALIGN4) {
356                 length = TDR_ALIGN(tdr->offset, 4);
357         } else if (tdr->flags & TDR_ALIGN8) {
358                 length = TDR_ALIGN(tdr->offset, 8);
359         } else if (tdr->flags & TDR_REMAINING) {
360                 length = tdr->data.length - tdr->offset;
361         } else {
362                 return NT_STATUS_INVALID_PARAMETER;
363         }
364
365         if (tdr->data.length - tdr->offset < length) {
366                 length = tdr->data.length - tdr->offset;
367         }
368
369         TDR_PULL_NEED_BYTES(tdr, length);
370
371         *blob = data_blob_talloc(tdr, tdr->data.data+tdr->offset, length);
372         tdr->offset += length;
373         return NT_STATUS_OK;
374 }
375
376 NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p)
377 {
378         struct tdr_push *push = talloc_zero(NULL, struct tdr_push);
379
380         if (push == NULL)
381                 return NT_STATUS_NO_MEMORY;
382
383         if (NT_STATUS_IS_ERR(push_fn(push, p))) {
384                 DEBUG(1, ("Error pushing data\n"));
385                 talloc_free(push);
386                 return NT_STATUS_UNSUCCESSFUL;
387         }
388
389         if (write(fd, push->data.data, push->data.length) < push->data.length) {
390                 DEBUG(1, ("Error writing all data\n"));
391                 return NT_STATUS_UNSUCCESSFUL;
392         }
393
394         talloc_free(push);
395
396         return NT_STATUS_OK;
397 }
398
399 void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
400 {
401         va_list ap;
402         char *s = NULL;
403         int i;
404
405         va_start(ap, format);
406         vasprintf(&s, format, ap);
407         va_end(ap);
408
409         for (i=0;i<tdr->level;i++) {
410                 DEBUG(0,("    "));
411         }
412
413         DEBUG(0,("%s\n", s));
414         free(s);
415 }