2 Unix SMB/CIFS implementation.
4 TDR (Trivial Data Representation) helper functions
5 Based loosely on ndr.c by Andrew Tridgell.
7 Copyright (C) Jelmer Vernooij 2005
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 3 of the License, or
12 (at your option) any later version.
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.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "system/filesys.h"
25 #include "system/network.h"
28 #define TDR_BASE_MARSHALL_SIZE 1024
30 #define TDR_PUSH_NEED_BYTES(tdr, n) TDR_CHECK(tdr_push_expand(tdr, tdr->data.length+(n)))
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; \
38 #define TDR_BE(tdr) ((tdr)->flags & TDR_BIG_ENDIAN)
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_SCVAL(tdr, ofs, v) SCVAL(tdr->data.data,ofs,v)
44 #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)
45 #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)
48 expand the available space in the buffer to 'size'
50 NTSTATUS tdr_push_expand(struct tdr_push *tdr, uint32_t size)
52 if (talloc_get_size(tdr->data.data) >= size) {
56 tdr->data.data = talloc_realloc(tdr, tdr->data.data, uint8_t, tdr->data.length + TDR_BASE_MARSHALL_SIZE);
58 if (tdr->data.data == NULL)
59 return NT_STATUS_NO_MEMORY;
65 NTSTATUS tdr_pull_uint8(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint8_t *v)
67 TDR_PULL_NEED_BYTES(tdr, 1);
68 *v = TDR_CVAL(tdr, tdr->offset);
73 NTSTATUS tdr_push_uint8(struct tdr_push *tdr, const uint8_t *v)
75 TDR_PUSH_NEED_BYTES(tdr, 1);
76 TDR_SCVAL(tdr, tdr->data.length, *v);
77 tdr->data.length += 1;
81 NTSTATUS tdr_print_uint8(struct tdr_print *tdr, const char *name, uint8_t *v)
83 tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
87 NTSTATUS tdr_pull_uint16(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v)
89 TDR_PULL_NEED_BYTES(tdr, 2);
90 *v = TDR_SVAL(tdr, tdr->offset);
95 NTSTATUS tdr_push_uint16(struct tdr_push *tdr, const uint16_t *v)
97 TDR_PUSH_NEED_BYTES(tdr, 2);
98 TDR_SSVAL(tdr, tdr->data.length, *v);
99 tdr->data.length += 2;
103 NTSTATUS tdr_print_uint16(struct tdr_print *tdr, const char *name, uint16_t *v)
105 tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
109 NTSTATUS tdr_pull_uint32(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint32_t *v)
111 TDR_PULL_NEED_BYTES(tdr, 4);
112 *v = TDR_IVAL(tdr, tdr->offset);
117 NTSTATUS tdr_push_uint32(struct tdr_push *tdr, const uint32_t *v)
119 TDR_PUSH_NEED_BYTES(tdr, 4);
120 TDR_SIVAL(tdr, tdr->data.length, *v);
121 tdr->data.length += 4;
125 NTSTATUS tdr_print_uint32(struct tdr_print *tdr, const char *name, uint32_t *v)
127 tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
131 NTSTATUS tdr_pull_charset(struct tdr_pull *tdr, TALLOC_CTX *ctx, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
138 length = ascii_len_n((const char*)tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
141 length = utf16_len_n(tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
145 return NT_STATUS_INVALID_PARAMETER;
150 *v = talloc_strdup(ctx, "");
154 TDR_PULL_NEED_BYTES(tdr, el_size*length);
156 ret = convert_string_talloc(ctx, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v));
159 return NT_STATUS_INVALID_PARAMETER;
162 tdr->offset += length * el_size;
167 NTSTATUS tdr_push_charset(struct tdr_push *tdr, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
169 ssize_t ret, required;
172 length = strlen(*v) + 1; /* Extra element for null character */
175 required = el_size * length;
176 TDR_PUSH_NEED_BYTES(tdr, required);
178 ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required);
181 return NT_STATUS_INVALID_PARAMETER;
184 /* Make sure the remaining part of the string is filled with zeroes */
185 if (ret < required) {
186 memset(tdr->data.data+tdr->data.length+ret, 0, required-ret);
189 tdr->data.length += required;
194 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 tdr->print(tdr, "%-25s: %s", name, *v);
203 NTSTATUS tdr_pull_ipv4address(struct tdr_pull *tdr, TALLOC_CTX *ctx,
204 const char **address)
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);
217 NTSTATUS tdr_push_ipv4address(struct tdr_push *tdr, const char **address)
219 uint32_t addr = htonl(interpret_addr(*address));
220 TDR_CHECK(tdr_push_uint32(tdr, &addr));
227 NTSTATUS tdr_print_ipv4address(struct tdr_print *tdr, const char *name,
228 const char **address)
230 tdr->print(tdr, "%-25s: %s", name, *address);
237 NTSTATUS tdr_pull_hyper(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint64_t *v)
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;
249 NTSTATUS tdr_push_hyper(struct tdr_push *tdr, uint64_t *v)
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;
261 NTSTATUS tdr_push_NTTIME(struct tdr_push *tdr, NTTIME *t)
263 TDR_CHECK(tdr_push_hyper(tdr, t));
270 NTSTATUS tdr_pull_NTTIME(struct tdr_pull *tdr, TALLOC_CTX *ctx, NTTIME *t)
272 TDR_CHECK(tdr_pull_hyper(tdr, ctx, t));
279 NTSTATUS tdr_push_time_t(struct tdr_push *tdr, time_t *t)
281 return tdr_push_uint32(tdr, (uint32_t *)t);
287 NTSTATUS tdr_pull_time_t(struct tdr_pull *tdr, TALLOC_CTX *ctx, time_t *t)
290 TDR_CHECK(tdr_pull_uint32(tdr, ctx, &tt));
295 NTSTATUS tdr_print_time_t(struct tdr_print *tdr, const char *name, time_t *t)
297 if (*t == (time_t)-1 || *t == 0) {
298 tdr->print(tdr, "%-25s: (time_t)%d", name, (int)*t);
300 tdr->print(tdr, "%-25s: %s", name, timestring(tdr, *t));
306 NTSTATUS tdr_print_NTTIME(struct tdr_print *tdr, const char *name, NTTIME *t)
308 tdr->print(tdr, "%-25s: %s", name, nt_time_string(tdr, *t));
313 NTSTATUS tdr_print_DATA_BLOB(struct tdr_print *tdr, const char *name, DATA_BLOB *r)
315 tdr->print(tdr, "%-25s: DATA_BLOB length=%u", name, r->length);
317 dump_data(10, r->data, r->length);
323 #define TDR_ALIGN(l,n) (((l) & ((n)-1)) == 0?0:((n)-((l)&((n)-1))))
326 push a DATA_BLOB onto the wire.
328 NTSTATUS tdr_push_DATA_BLOB(struct tdr_push *tdr, DATA_BLOB *blob)
330 if (tdr->flags & TDR_ALIGN2) {
331 blob->length = TDR_ALIGN(tdr->data.length, 2);
332 } else if (tdr->flags & TDR_ALIGN4) {
333 blob->length = TDR_ALIGN(tdr->data.length, 4);
334 } else if (tdr->flags & TDR_ALIGN8) {
335 blob->length = TDR_ALIGN(tdr->data.length, 8);
338 TDR_PUSH_NEED_BYTES(tdr, blob->length);
340 memcpy(tdr->data.data+tdr->data.length, blob->data, blob->length);
345 pull a DATA_BLOB from the wire.
347 NTSTATUS tdr_pull_DATA_BLOB(struct tdr_pull *tdr, TALLOC_CTX *ctx, DATA_BLOB *blob)
351 if (tdr->flags & TDR_ALIGN2) {
352 length = TDR_ALIGN(tdr->offset, 2);
353 } else if (tdr->flags & TDR_ALIGN4) {
354 length = TDR_ALIGN(tdr->offset, 4);
355 } else if (tdr->flags & TDR_ALIGN8) {
356 length = TDR_ALIGN(tdr->offset, 8);
357 } else if (tdr->flags & TDR_REMAINING) {
358 length = tdr->data.length - tdr->offset;
360 return NT_STATUS_INVALID_PARAMETER;
363 if (tdr->data.length - tdr->offset < length) {
364 length = tdr->data.length - tdr->offset;
367 TDR_PULL_NEED_BYTES(tdr, length);
369 *blob = data_blob_talloc(tdr, tdr->data.data+tdr->offset, length);
370 tdr->offset += length;
374 NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p)
376 struct tdr_push *push = talloc_zero(NULL, struct tdr_push);
379 return NT_STATUS_NO_MEMORY;
381 if (NT_STATUS_IS_ERR(push_fn(push, p))) {
382 DEBUG(1, ("Error pushing data\n"));
384 return NT_STATUS_UNSUCCESSFUL;
387 if (write(fd, push->data.data, push->data.length) < push->data.length) {
388 DEBUG(1, ("Error writing all data\n"));
389 return NT_STATUS_UNSUCCESSFUL;
397 void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
403 va_start(ap, format);
404 vasprintf(&s, format, ap);
407 for (i=0;i<tdr->level;i++) {
411 DEBUG(0,("%s\n", s));