source/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, TALLOC_CTX *ctx, 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, TALLOC_CTX *ctx, 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, TALLOC_CTX *ctx, 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, TALLOC_CTX *ctx, 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(ctx, "");
 153                 return NT_STATUS_OK;
 154         }
 155
 156         TDR_PULL_NEED_BYTES(tdr, el_size*length);
 157
 158         ret = convert_string_talloc(ctx, 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         if (length == -1) {
 174                 length = strlen(*v) + 1; /* Extra element for null character */
 175         }
 176
 177         required = el_size * length;
 178         TDR_PUSH_NEED_BYTES(tdr, required);
 179
 180         ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required);
 181
 182         if (ret == -1) {
 183                 return NT_STATUS_INVALID_PARAMETER;
 184         }
 185
 186         /* Make sure the remaining part of the string is filled with zeroes */
 187         if (ret < required) {
 188                 memset(tdr->data.data+tdr->data.length+ret, 0, required-ret);
 189         }
 190
 191         tdr->data.length += required;
 192
 193         return NT_STATUS_OK;
 194 }
 195
 196 NTSTATUS tdr_print_charset(struct tdr_print *tdr, const char *name, const char **v, uint32_t length, uint32_t el_size, int chset)
 197 {
 198         tdr->print(tdr, "%-25s: %s", name, *v);
 199         return NT_STATUS_OK;
 200 }
 201
 202 /*
 203   pull a ipv4address
 204 */
 205 NTSTATUS tdr_pull_ipv4address(struct tdr_pull *tdr, TALLOC_CTX *ctx, const char **address)
 206 {
 207         struct ipv4_addr in;
 208         TDR_CHECK(tdr_pull_uint32(tdr, ctx, &in.addr));
 209         in.addr = htonl(in.addr);
 210         *address = talloc_strdup(tdr, sys_inet_ntoa(in));
 211         NT_STATUS_HAVE_NO_MEMORY(*address);
 212         return NT_STATUS_OK;
 213 }
 214
 215 /*
 216   push a ipv4address
 217 */
 218 NTSTATUS tdr_push_ipv4address(struct tdr_push *tdr, const char **address)
 219 {
 220         uint32_t addr = htonl(interpret_addr(*address));
 221         TDR_CHECK(tdr_push_uint32(tdr, &addr));
 222         return NT_STATUS_OK;
 223 }
 224
 225 /*
 226   print a ipv4address
 227 */
 228 NTSTATUS tdr_print_ipv4address(struct tdr_print *tdr, const char *name,
 229                            const char **address)
 230 {
 231         tdr->print(tdr, "%-25s: %s", name, *address);
 232         return NT_STATUS_OK;
 233 }
 234
 235 /*
 236   parse a hyper
 237 */
 238 NTSTATUS tdr_pull_hyper(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint64_t *v)
 239 {
 240         TDR_PULL_NEED_BYTES(tdr, 8);
 241         *v = TDR_IVAL(tdr, tdr->offset);
 242         *v |= (uint64_t)(TDR_IVAL(tdr, tdr->offset+4)) << 32;
 243         tdr->offset += 8;
 244         return NT_STATUS_OK;
 245 }
 246
 247 /*
 248   push a hyper
 249 */
 250 NTSTATUS tdr_push_hyper(struct tdr_push *tdr, uint64_t *v)
 251 {
 252         TDR_PUSH_NEED_BYTES(tdr, 8);
 253         TDR_SIVAL(tdr, tdr->data.length, ((*v) & 0xFFFFFFFF));
 254         TDR_SIVAL(tdr, tdr->data.length+4, ((*v)>>32));
 255         tdr->data.length += 8;
 256         return NT_STATUS_OK;
 257 }
 258
 259
 260
 261 /*
 262   push a NTTIME
 263 */
 264 NTSTATUS tdr_push_NTTIME(struct tdr_push *tdr, NTTIME *t)
 265 {
 266         TDR_CHECK(tdr_push_hyper(tdr, t));
 267         return NT_STATUS_OK;
 268 }
 269
 270 /*
 271   pull a NTTIME
 272 */
 273 NTSTATUS tdr_pull_NTTIME(struct tdr_pull *tdr, TALLOC_CTX *ctx, NTTIME *t)
 274 {
 275         TDR_CHECK(tdr_pull_hyper(tdr, ctx, t));
 276         return NT_STATUS_OK;
 277 }
 278
 279 /*
 280   push a time_t
 281 */
 282 NTSTATUS tdr_push_time_t(struct tdr_push *tdr, time_t *t)
 283 {
 284         return tdr_push_uint32(tdr, (uint32_t *)t);
 285 }
 286
 287 /*
 288   pull a time_t
 289 */
 290 NTSTATUS tdr_pull_time_t(struct tdr_pull *tdr, TALLOC_CTX *ctx, time_t *t)
 291 {
 292         uint32_t tt;
 293         TDR_CHECK(tdr_pull_uint32(tdr, ctx, &tt));
 294         *t = tt;
 295         return NT_STATUS_OK;
 296 }
 297
 298 NTSTATUS tdr_print_time_t(struct tdr_print *tdr, const char *name, time_t *t)
 299 {
 300         if (*t == (time_t)-1 || *t == 0) {
 301                 tdr->print(tdr, "%-25s: (time_t)%d", name, (int)*t);
 302         } else {
 303                 tdr->print(tdr, "%-25s: %s", name, timestring(tdr, *t));
 304         }
 305
 306         return NT_STATUS_OK;
 307 }
 308
 309 NTSTATUS tdr_print_NTTIME(struct tdr_print *tdr, const char *name, NTTIME *t)
 310 {
 311         tdr->print(tdr, "%-25s: %s", name, nt_time_string(tdr, *t));
 312
 313         return NT_STATUS_OK;
 314 }
 315
 316 NTSTATUS tdr_print_DATA_BLOB(struct tdr_print *tdr, const char *name, DATA_BLOB *r)
 317 {
 318         tdr->print(tdr, "%-25s: DATA_BLOB length=%u", name, r->length);
 319         if (r->length) {
 320                 dump_data(10, r->data, r->length);
 321         }
 322
 323         return NT_STATUS_OK;
 324 }
 325
 326 #define TDR_ALIGN(l,n) (((l) & ((n)-1)) == 0?0:((n)-((l)&((n)-1))))
 327
 328 /*
 329   push a DATA_BLOB onto the wire.
 330 */
 331 NTSTATUS tdr_push_DATA_BLOB(struct tdr_push *tdr, DATA_BLOB *blob)
 332 {
 333         if (tdr->flags & TDR_ALIGN2) {
 334                 blob->length = TDR_ALIGN(tdr->data.length, 2);
 335         } else if (tdr->flags & TDR_ALIGN4) {
 336                 blob->length = TDR_ALIGN(tdr->data.length, 4);
 337         } else if (tdr->flags & TDR_ALIGN8) {
 338                 blob->length = TDR_ALIGN(tdr->data.length, 8);
 339         }
 340
 341         TDR_PUSH_NEED_BYTES(tdr, blob->length);
 342
 343         memcpy(tdr->data.data+tdr->data.length, blob->data, blob->length);
 344         return NT_STATUS_OK;
 345 }
 346
 347 /*
 348   pull a DATA_BLOB from the wire.
 349 */
 350 NTSTATUS tdr_pull_DATA_BLOB(struct tdr_pull *tdr, TALLOC_CTX *ctx, DATA_BLOB *blob)
 351 {
 352         uint32_t length;
 353
 354         if (tdr->flags & TDR_ALIGN2) {
 355                 length = TDR_ALIGN(tdr->offset, 2);
 356         } else if (tdr->flags & TDR_ALIGN4) {
 357                 length = TDR_ALIGN(tdr->offset, 4);
 358         } else if (tdr->flags & TDR_ALIGN8) {
 359                 length = TDR_ALIGN(tdr->offset, 8);
 360         } else if (tdr->flags & TDR_REMAINING) {
 361                 length = tdr->data.length - tdr->offset;
 362         } else {
 363                 return NT_STATUS_INVALID_PARAMETER;
 364         }
 365
 366         if (tdr->data.length - tdr->offset < length) {
 367                 length = tdr->data.length - tdr->offset;
 368         }
 369
 370         TDR_PULL_NEED_BYTES(tdr, length);
 371
 372         *blob = data_blob_talloc(tdr, tdr->data.data+tdr->offset, length);
 373         tdr->offset += length;
 374         return NT_STATUS_OK;
 375 }
 376
 377 NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p)
 378 {
 379         struct tdr_push *push = talloc_zero(NULL, struct tdr_push);
 380
 381         if (push == NULL)
 382                 return NT_STATUS_NO_MEMORY;
 383
 384         if (NT_STATUS_IS_ERR(push_fn(push, p))) {
 385                 DEBUG(1, ("Error pushing data\n"));
 386                 talloc_free(push);
 387                 return NT_STATUS_UNSUCCESSFUL;
 388         }
 389
 390         if (write(fd, push->data.data, push->data.length) < push->data.length) {
 391                 DEBUG(1, ("Error writing all data\n"));
 392                 return NT_STATUS_UNSUCCESSFUL;
 393         }
 394
 395         talloc_free(push);
 396
 397         return NT_STATUS_OK;
 398 }
 399
 400 void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
 401 {
 402         va_list ap;
 403         char *s = NULL;
 404         int i;
 405
 406         va_start(ap, format);
 407         vasprintf(&s, format, ap);
 408         va_end(ap);
 409
 410         for (i=0;i<tdr->level;i++) {
 411                 DEBUG(0,("    "));
 412         }
 413
 414         DEBUG(0,("%s\n", s));
 415         free(s);
 416 }