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