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 3 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, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "system/filesys.h"
  25 #include "system/network.h"
  26 #include "tdr/tdr.h"
  27 #include "param/param.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, tdr->iconv_convenience, 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(tdr->iconv_convenience, 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,
 205                                                           const char **address)
 206 {
 207         struct in_addr in;
 208         TDR_CHECK(tdr_pull_uint32(tdr, ctx, &in.s_addr));
 209         in.s_addr = htonl(in.s_addr);
 210         *address = talloc_strdup(tdr, 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   push a NTTIME
 261 */
 262 NTSTATUS tdr_push_NTTIME(struct tdr_push *tdr, NTTIME *t)
 263 {
 264         TDR_CHECK(tdr_push_hyper(tdr, t));
 265         return NT_STATUS_OK;
 266 }
 267
 268 /**
 269   pull a NTTIME
 270 */
 271 NTSTATUS tdr_pull_NTTIME(struct tdr_pull *tdr, TALLOC_CTX *ctx, NTTIME *t)
 272 {
 273         TDR_CHECK(tdr_pull_hyper(tdr, ctx, t));
 274         return NT_STATUS_OK;
 275 }
 276
 277 /**
 278   push a time_t
 279 */
 280 NTSTATUS tdr_push_time_t(struct tdr_push *tdr, time_t *t)
 281 {
 282         return tdr_push_uint32(tdr, (uint32_t *)t);
 283 }
 284
 285 /**
 286   pull a time_t
 287 */
 288 NTSTATUS tdr_pull_time_t(struct tdr_pull *tdr, TALLOC_CTX *ctx, time_t *t)
 289 {
 290         uint32_t tt;
 291         TDR_CHECK(tdr_pull_uint32(tdr, ctx, &tt));
 292         *t = tt;
 293         return NT_STATUS_OK;
 294 }
 295
 296 NTSTATUS tdr_print_time_t(struct tdr_print *tdr, const char *name, time_t *t)
 297 {
 298         if (*t == (time_t)-1 || *t == 0) {
 299                 tdr->print(tdr, "%-25s: (time_t)%d", name, (int)*t);
 300         } else {
 301                 tdr->print(tdr, "%-25s: %s", name, timestring(tdr, *t));
 302         }
 303
 304         return NT_STATUS_OK;
 305 }
 306
 307 NTSTATUS tdr_print_NTTIME(struct tdr_print *tdr, const char *name, NTTIME *t)
 308 {
 309         tdr->print(tdr, "%-25s: %s", name, nt_time_string(tdr, *t));
 310
 311         return NT_STATUS_OK;
 312 }
 313
 314 NTSTATUS tdr_print_DATA_BLOB(struct tdr_print *tdr, const char *name, DATA_BLOB *r)
 315 {
 316         tdr->print(tdr, "%-25s: DATA_BLOB length=%u", name, r->length);
 317         if (r->length) {
 318                 dump_data(10, r->data, r->length);
 319         }
 320
 321         return NT_STATUS_OK;
 322 }
 323
 324 #define TDR_ALIGN(l,n) (((l) & ((n)-1)) == 0?0:((n)-((l)&((n)-1))))
 325
 326 /*
 327   push a DATA_BLOB onto the wire.
 328 */
 329 NTSTATUS tdr_push_DATA_BLOB(struct tdr_push *tdr, DATA_BLOB *blob)
 330 {
 331         if (tdr->flags & TDR_ALIGN2) {
 332                 blob->length = TDR_ALIGN(tdr->data.length, 2);
 333         } else if (tdr->flags & TDR_ALIGN4) {
 334                 blob->length = TDR_ALIGN(tdr->data.length, 4);
 335         } else if (tdr->flags & TDR_ALIGN8) {
 336                 blob->length = TDR_ALIGN(tdr->data.length, 8);
 337         }
 338
 339         TDR_PUSH_NEED_BYTES(tdr, blob->length);
 340
 341         memcpy(tdr->data.data+tdr->data.length, blob->data, blob->length);
 342         return NT_STATUS_OK;
 343 }
 344
 345 /*
 346   pull a DATA_BLOB from the wire.
 347 */
 348 NTSTATUS tdr_pull_DATA_BLOB(struct tdr_pull *tdr, TALLOC_CTX *ctx, DATA_BLOB *blob)
 349 {
 350         uint32_t length;
 351
 352         if (tdr->flags & TDR_ALIGN2) {
 353                 length = TDR_ALIGN(tdr->offset, 2);
 354         } else if (tdr->flags & TDR_ALIGN4) {
 355                 length = TDR_ALIGN(tdr->offset, 4);
 356         } else if (tdr->flags & TDR_ALIGN8) {
 357                 length = TDR_ALIGN(tdr->offset, 8);
 358         } else if (tdr->flags & TDR_REMAINING) {
 359                 length = tdr->data.length - tdr->offset;
 360         } else {
 361                 return NT_STATUS_INVALID_PARAMETER;
 362         }
 363
 364         if (tdr->data.length - tdr->offset < length) {
 365                 length = tdr->data.length - tdr->offset;
 366         }
 367
 368         TDR_PULL_NEED_BYTES(tdr, length);
 369
 370         *blob = data_blob_talloc(tdr, tdr->data.data+tdr->offset, length);
 371         tdr->offset += length;
 372         return NT_STATUS_OK;
 373 }
 374
 375 struct tdr_push *tdr_push_init(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic)
 376 {
 377         struct tdr_push *push = talloc_zero(mem_ctx, struct tdr_push);
 378
 379         if (push == NULL)
 380                 return NULL;
 381
 382         push->iconv_convenience = talloc_reference(push, ic);
 383
 384         return push;
 385 }
 386
 387 struct tdr_pull *tdr_pull_init(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic)
 388 {
 389         struct tdr_pull *pull = talloc_zero(mem_ctx, struct tdr_pull);
 390
 391         if (pull == NULL)
 392                 return NULL;
 393
 394         pull->iconv_convenience = talloc_reference(pull, ic);
 395
 396         return pull;
 397 }
 398
 399 NTSTATUS tdr_push_to_fd(int fd, struct smb_iconv_convenience *iconv_convenience, tdr_push_fn_t push_fn, const void *p)
 400 {
 401         struct tdr_push *push = tdr_push_init(NULL, iconv_convenience);
 402
 403         if (push == NULL)
 404                 return NT_STATUS_NO_MEMORY;
 405
 406         if (NT_STATUS_IS_ERR(push_fn(push, p))) {
 407                 DEBUG(1, ("Error pushing data\n"));
 408                 talloc_free(push);
 409                 return NT_STATUS_UNSUCCESSFUL;
 410         }
 411
 412         if (write(fd, push->data.data, push->data.length) < push->data.length) {
 413                 DEBUG(1, ("Error writing all data\n"));
 414                 return NT_STATUS_UNSUCCESSFUL;
 415         }
 416
 417         talloc_free(push);
 418
 419         return NT_STATUS_OK;
 420 }
 421
 422 void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
 423 {
 424         va_list ap;
 425         char *s = NULL;
 426         int i;
 427
 428         va_start(ap, format);
 429         vasprintf(&s, format, ap);
 430         va_end(ap);
 431
 432         for (i=0;i<tdr->level;i++) { DEBUG(0,("    ")); }
 433
 434         DEBUG(0,("%s\n", s));
 435         free(s);
 436 }