root/source4/lib/tdr/tdr.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. tdr_push_expand
  2. tdr_pull_uint8
  3. tdr_push_uint8
  4. tdr_print_uint8
  5. tdr_pull_uint16
  6. tdr_push_uint16
  7. tdr_print_uint16
  8. tdr_pull_uint32
  9. tdr_push_uint32
  10. tdr_print_uint32
  11. tdr_pull_charset
  12. tdr_push_charset
  13. tdr_print_charset
  14. tdr_pull_hyper
  15. tdr_push_hyper
  16. tdr_push_NTTIME
  17. tdr_pull_NTTIME
  18. tdr_push_time_t
  19. tdr_pull_time_t
  20. tdr_print_time_t
  21. tdr_print_NTTIME
  22. tdr_print_DATA_BLOB
  23. tdr_push_DATA_BLOB
  24. tdr_pull_DATA_BLOB
  25. tdr_push_init
  26. tdr_pull_init
  27. tdr_push_to_fd
  28. tdr_print_debug_helper

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

/* [<][>][^][v][top][bottom][index][help] */