source4/librpc/ndr/ndr_basic.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    routines for marshalling/unmarshalling basic types
   5
   6    Copyright (C) Andrew Tridgell 2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 #define NDR_BE(ndr) (((ndr)->flags & (LIBNDR_FLAG_BIGENDIAN|LIBNDR_FLAG_LITTLE_ENDIAN)) == LIBNDR_FLAG_BIGENDIAN)
  26 #define NDR_SVAL(ndr, ofs) (NDR_BE(ndr)?RSVAL(ndr->data,ofs):SVAL(ndr->data,ofs))
  27 #define NDR_IVAL(ndr, ofs) (NDR_BE(ndr)?RIVAL(ndr->data,ofs):IVAL(ndr->data,ofs))
  28 #define NDR_SSVAL(ndr, ofs, v) do { if (NDR_BE(ndr))  { RSSVAL(ndr->data,ofs,v); } else SSVAL(ndr->data,ofs,v); } while (0)
  29 #define NDR_SIVAL(ndr, ofs, v) do { if (NDR_BE(ndr))  { RSIVAL(ndr->data,ofs,v); } else SIVAL(ndr->data,ofs,v); } while (0)
  30
  31 /*
  32   parse a uint8
  33 */
  34 NTSTATUS ndr_pull_uint8(struct ndr_pull *ndr, uint8_t *v)
  35 {
  36         NDR_PULL_NEED_BYTES(ndr, 1);
  37         *v = CVAL(ndr->data, ndr->offset);
  38         ndr->offset += 1;
  39         return NT_STATUS_OK;
  40 }
  41
  42
  43 /*
  44   parse a uint16
  45 */
  46 NTSTATUS ndr_pull_uint16(struct ndr_pull *ndr, uint16_t *v)
  47 {
  48         NDR_PULL_ALIGN(ndr, 2);
  49         NDR_PULL_NEED_BYTES(ndr, 2);
  50         *v = NDR_SVAL(ndr, ndr->offset);
  51         ndr->offset += 2;
  52         return NT_STATUS_OK;
  53 }
  54
  55
  56 /*
  57   parse a uint32_t
  58 */
  59 NTSTATUS ndr_pull_uint32(struct ndr_pull *ndr, uint32_t *v)
  60 {
  61         NDR_PULL_ALIGN(ndr, 4);
  62         NDR_PULL_NEED_BYTES(ndr, 4);
  63         *v = NDR_IVAL(ndr, ndr->offset);
  64         ndr->offset += 4;
  65         return NT_STATUS_OK;
  66 }
  67
  68 /*
  69   parse a pointer
  70 */
  71 NTSTATUS ndr_pull_ptr(struct ndr_pull *ndr, uint32_t *v)
  72 {
  73         NTSTATUS status;
  74         status = ndr_pull_uint32(ndr, v);
  75         if (*v != 0) {
  76                 ndr->ptr_count++;
  77         }
  78         return status;
  79 }
  80
  81 /*
  82   parse a uint64
  83 */
  84 NTSTATUS ndr_pull_uint64(struct ndr_pull *ndr, uint64_t *v)
  85 {
  86         NDR_PULL_ALIGN(ndr, 4);
  87         NDR_PULL_NEED_BYTES(ndr, 8);
  88         *v = NDR_IVAL(ndr, ndr->offset);
  89         *v |= (uint64_t)(NDR_IVAL(ndr, ndr->offset+4)) << 32;
  90         ndr->offset += 8;
  91         return NT_STATUS_OK;
  92 }
  93
  94 /*
  95   parse a int64
  96 */
  97 NTSTATUS ndr_pull_int64(struct ndr_pull *ndr, int64_t *v)
  98 {
  99         return ndr_pull_uint64(ndr, (uint64_t *)v);
 100 }
 101
 102 /*
 103   parse a HYPER_T
 104 */
 105 NTSTATUS ndr_pull_HYPER_T(struct ndr_pull *ndr, HYPER_T *v)
 106 {
 107         NDR_PULL_ALIGN(ndr, 8);
 108         return ndr_pull_uint64(ndr, v);
 109 }
 110
 111 /*
 112   pull a NTSTATUS
 113 */
 114 NTSTATUS ndr_pull_NTSTATUS(struct ndr_pull *ndr, NTSTATUS *status)
 115 {
 116         uint32_t v;
 117         NDR_CHECK(ndr_pull_uint32(ndr, &v));
 118         *status = NT_STATUS(v);
 119         return NT_STATUS_OK;
 120 }
 121
 122 /*
 123   push a NTSTATUS
 124 */
 125 NTSTATUS ndr_push_NTSTATUS(struct ndr_push *ndr, NTSTATUS status)
 126 {
 127         return ndr_push_uint32(ndr, NT_STATUS_V(status));
 128 }
 129
 130 void ndr_print_NTSTATUS(struct ndr_print *ndr, const char *name, NTSTATUS *r)
 131 {
 132         ndr->print(ndr, "%-25s: %s", name, nt_errstr(*r));
 133 }
 134
 135 /*
 136   pull a WERROR
 137 */
 138 NTSTATUS ndr_pull_WERROR(struct ndr_pull *ndr, WERROR *status)
 139 {
 140         uint32_t v;
 141         NDR_CHECK(ndr_pull_uint32(ndr, &v));
 142         *status = W_ERROR(v);
 143         return NT_STATUS_OK;
 144 }
 145
 146 /*
 147   push a WERROR
 148 */
 149 NTSTATUS ndr_push_WERROR(struct ndr_push *ndr, WERROR status)
 150 {
 151         return ndr_push_uint32(ndr, W_ERROR_V(status));
 152 }
 153
 154 void ndr_print_WERROR(struct ndr_print *ndr, const char *name, WERROR *r)
 155 {
 156         ndr->print(ndr, "%-25s: %s", name, win_errstr(*r));
 157 }
 158
 159 /*
 160   parse a set of bytes
 161 */
 162 NTSTATUS ndr_pull_bytes(struct ndr_pull *ndr, char *data, uint32_t n)
 163 {
 164         NDR_PULL_NEED_BYTES(ndr, n);
 165         memcpy(data, ndr->data + ndr->offset, n);
 166         ndr->offset += n;
 167         return NT_STATUS_OK;
 168 }
 169
 170 /*
 171   pull an array of uint8
 172 */
 173 NTSTATUS ndr_pull_array_uint8(struct ndr_pull *ndr, int ndr_flags, char *data, uint32_t n)
 174 {
 175         if (!(ndr_flags & NDR_SCALARS)) {
 176                 return NT_STATUS_OK;
 177         }
 178         return ndr_pull_bytes(ndr, data, n);
 179 }
 180
 181
 182 /*
 183   pull an array of uint16
 184 */
 185 NTSTATUS ndr_pull_array_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *data, uint32_t n)
 186 {
 187         uint32_t i;
 188         if (!(ndr_flags & NDR_SCALARS)) {
 189                 return NT_STATUS_OK;
 190         }
 191         for (i=0;i<n;i++) {
 192                 NDR_CHECK(ndr_pull_uint16(ndr, &data[i]));
 193         }
 194         return NT_STATUS_OK;
 195 }
 196
 197 /*
 198   pull a const array of uint32_t
 199 */
 200 NTSTATUS ndr_pull_array_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *data, uint32_t n)
 201 {
 202         uint32_t i;
 203         if (!(ndr_flags & NDR_SCALARS)) {
 204                 return NT_STATUS_OK;
 205         }
 206         for (i=0;i<n;i++) {
 207                 NDR_CHECK(ndr_pull_uint32(ndr, &data[i]));
 208         }
 209         return NT_STATUS_OK;
 210 }
 211
 212 /*
 213   pull a const array of HYPER_T
 214 */
 215 NTSTATUS ndr_pull_array_HYPER_T(struct ndr_pull *ndr, int ndr_flags, HYPER_T *data, uint32_t n)
 216 {
 217         uint32_t i;
 218         if (!(ndr_flags & NDR_SCALARS)) {
 219                 return NT_STATUS_OK;
 220         }
 221         for (i=0;i<n;i++) {
 222                 NDR_CHECK(ndr_pull_HYPER_T(ndr, &data[i]));
 223         }
 224         return NT_STATUS_OK;
 225 }
 226
 227 /*
 228   push a uint8
 229 */
 230 NTSTATUS ndr_push_uint8(struct ndr_push *ndr, uint8_t v)
 231 {
 232         NDR_PUSH_NEED_BYTES(ndr, 1);
 233         SCVAL(ndr->data, ndr->offset, v);
 234         ndr->offset += 1;
 235         return NT_STATUS_OK;
 236 }
 237
 238 /*
 239   push a uint16
 240 */
 241 NTSTATUS ndr_push_uint16(struct ndr_push *ndr, uint16_t v)
 242 {
 243         NDR_PUSH_ALIGN(ndr, 2);
 244         NDR_PUSH_NEED_BYTES(ndr, 2);
 245         NDR_SSVAL(ndr, ndr->offset, v);
 246         ndr->offset += 2;
 247         return NT_STATUS_OK;
 248 }
 249
 250 /*
 251   push a uint32_t
 252 */
 253 NTSTATUS ndr_push_uint32(struct ndr_push *ndr, uint32_t v)
 254 {
 255         NDR_PUSH_ALIGN(ndr, 4);
 256         NDR_PUSH_NEED_BYTES(ndr, 4);
 257         NDR_SIVAL(ndr, ndr->offset, v);
 258         ndr->offset += 4;
 259         return NT_STATUS_OK;
 260 }
 261
 262 /*
 263   push a uint64
 264 */
 265 NTSTATUS ndr_push_uint64(struct ndr_push *ndr, uint64_t v)
 266 {
 267         NDR_PUSH_ALIGN(ndr, 4);
 268         NDR_PUSH_NEED_BYTES(ndr, 8);
 269         NDR_SIVAL(ndr, ndr->offset, (v & 0xFFFFFFFF));
 270         NDR_SIVAL(ndr, ndr->offset+4, (v>>32));
 271         ndr->offset += 8;
 272         return NT_STATUS_OK;
 273 }
 274
 275 /*
 276   push a int64
 277 */
 278 NTSTATUS ndr_push_int64(struct ndr_push *ndr, int64_t v)
 279 {
 280         return ndr_push_uint64(ndr, (uint64_t)v);
 281 }
 282
 283 /*
 284   push a HYPER_T
 285 */
 286 NTSTATUS ndr_push_HYPER_T(struct ndr_push *ndr, HYPER_T v)
 287 {
 288         NDR_PUSH_ALIGN(ndr, 8);
 289         return ndr_push_uint64(ndr, v);
 290 }
 291
 292 NTSTATUS ndr_push_align(struct ndr_push *ndr, size_t size)
 293 {
 294         NDR_PUSH_ALIGN(ndr, size);
 295         return NT_STATUS_OK;
 296 }
 297
 298 NTSTATUS ndr_pull_align(struct ndr_pull *ndr, size_t size)
 299 {
 300         NDR_PULL_ALIGN(ndr, size);
 301         return NT_STATUS_OK;
 302 }
 303
 304 /*
 305   push some bytes
 306 */
 307 NTSTATUS ndr_push_bytes(struct ndr_push *ndr, const char *data, uint32_t n)
 308 {
 309         NDR_PUSH_NEED_BYTES(ndr, n);
 310         memcpy(ndr->data + ndr->offset, data, n);
 311         ndr->offset += n;
 312         return NT_STATUS_OK;
 313 }
 314
 315 /*
 316   push some zero bytes
 317 */
 318 NTSTATUS ndr_push_zero(struct ndr_push *ndr, uint32_t n)
 319 {
 320         NDR_PUSH_NEED_BYTES(ndr, n);
 321         memset(ndr->data + ndr->offset, 0, n);
 322         ndr->offset += n;
 323         return NT_STATUS_OK;
 324 }
 325
 326 /*
 327   push an array of uint8
 328 */
 329 NTSTATUS ndr_push_array_uint8(struct ndr_push *ndr, int ndr_flags, const char *data, uint32_t n)
 330 {
 331         if (!(ndr_flags & NDR_SCALARS)) {
 332                 return NT_STATUS_OK;
 333         }
 334         return ndr_push_bytes(ndr, data, n);
 335 }
 336
 337 /*
 338   push an array of uint16
 339 */
 340 NTSTATUS ndr_push_array_uint16(struct ndr_push *ndr, int ndr_flags, const uint16_t *data, uint32_t n)
 341 {
 342         int i;
 343         if (!(ndr_flags & NDR_SCALARS)) {
 344                 return NT_STATUS_OK;
 345         }
 346         for (i=0;i<n;i++) {
 347                 NDR_CHECK(ndr_push_uint16(ndr, data[i]));
 348         }
 349         return NT_STATUS_OK;
 350 }
 351
 352 /*
 353   push an array of uint32_t
 354 */
 355 NTSTATUS ndr_push_array_uint32(struct ndr_push *ndr, int ndr_flags, const uint32_t *data, uint32_t n)
 356 {
 357         int i;
 358         if (!(ndr_flags & NDR_SCALARS)) {
 359                 return NT_STATUS_OK;
 360         }
 361         for (i=0;i<n;i++) {
 362                 NDR_CHECK(ndr_push_uint32(ndr, data[i]));
 363         }
 364         return NT_STATUS_OK;
 365 }
 366
 367 /*
 368   push an array of HYPER_T
 369 */
 370 NTSTATUS ndr_push_array_HYPER_T(struct ndr_push *ndr, int ndr_flags, const HYPER_T *data, uint32_t n)
 371 {
 372         int i;
 373         if (!(ndr_flags & NDR_SCALARS)) {
 374                 return NT_STATUS_OK;
 375         }
 376         for (i=0;i<n;i++) {
 377                 NDR_CHECK(ndr_push_HYPER_T(ndr, data[i]));
 378         }
 379         return NT_STATUS_OK;
 380 }
 381
 382 /*
 383   save the current position
 384  */
 385 void ndr_push_save(struct ndr_push *ndr, struct ndr_push_save *save)
 386 {
 387         save->offset = ndr->offset;
 388 }
 389
 390 /*
 391   restore the position
 392  */
 393 void ndr_push_restore(struct ndr_push *ndr, struct ndr_push_save *save)
 394 {
 395         ndr->offset = save->offset;
 396 }
 397
 398 /*
 399   push a 1 if a pointer is non-NULL, otherwise 0
 400 */
 401 NTSTATUS ndr_push_ptr(struct ndr_push *ndr, const void *p)
 402 {
 403         uint32_t ptr = 0;
 404         if (p) {
 405                 /* we do this to ensure that we generate unique ref ids,
 406                    which means we can handle the case where a MS programmer
 407                    forgot to mark a pointer as unique */
 408                 ndr->ptr_count++;
 409                 ptr = ndr->ptr_count;
 410         }
 411         return ndr_push_uint32(ndr, ptr);
 412 }
 413
 414
 415 /*
 416   pull a general string from the wire
 417 */
 418 NTSTATUS ndr_pull_string(struct ndr_pull *ndr, int ndr_flags, const char **s)
 419 {
 420         char *as=NULL;
 421         uint32_t len1, ofs, len2;
 422         uint16_t len3;
 423         int ret;
 424         int chset = CH_UCS2;
 425
 426         if (!(ndr_flags & NDR_SCALARS)) {
 427                 return NT_STATUS_OK;
 428         }
 429
 430         if (NDR_BE(ndr)) {
 431                 chset = CH_UCS2BE;
 432         }
 433
 434         switch (ndr->flags & LIBNDR_STRING_FLAGS) {
 435         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 436         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 437                 NDR_CHECK(ndr_pull_uint32(ndr, &len1));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, &ofs));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, &len2));
 440                 if (len2 > len1) {
 441                         return ndr_pull_error(ndr, NDR_ERR_STRING,
 442                                               "Bad string lengths len1=%u ofs=%u len2=%u\n",
 443                                               len1, ofs, len2);
 444                 }
 445                 if (len2 == 0) {
 446                         *s = talloc_strdup(ndr, "");
 447                         break;
 448                 }
 449                 NDR_PULL_NEED_BYTES(ndr, len2*2);
 450                 ret = convert_string_talloc(ndr, chset, CH_UNIX,
 451                                             ndr->data+ndr->offset,
 452                                             len2*2,
 453                                             (const void **)&as);
 454                 if (ret == -1) {
 455                         return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 456                                               "Bad character conversion");
 457                 }
 458                 NDR_CHECK(ndr_pull_advance(ndr, len2*2));
 459
 460                 /* this is a way of detecting if a string is sent with the wrong
 461                    termination */
 462                 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
 463                         if (strlen(as) < len2) {
 464                                 DEBUG(6,("short string '%s'\n", as));
 465                         }
 466                 } else {
 467                         if (strlen(as) == len2) {
 468                                 DEBUG(6,("long string '%s'\n", as));
 469                         }
 470                 }
 471                 *s = as;
 472                 break;
 473
 474         case LIBNDR_FLAG_STR_SIZE4:
 475         case LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 476                 NDR_CHECK(ndr_pull_uint32(ndr, &len1));
 477                 NDR_PULL_NEED_BYTES(ndr, len1*2);
 478                 if (len1 == 0) {
 479                         *s = talloc_strdup(ndr, "");
 480                         break;
 481                 }
 482                 ret = convert_string_talloc(ndr, chset, CH_UNIX,
 483                                             ndr->data+ndr->offset,
 484                                             len1*2,
 485                                             (const void **)&as);
 486                 if (ret == -1) {
 487                         return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 488                                               "Bad character conversion");
 489                 }
 490                 NDR_CHECK(ndr_pull_advance(ndr, len1*2));
 491
 492                 /* this is a way of detecting if a string is sent with the wrong
 493                    termination */
 494                 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
 495                         if (strlen(as) < len1) {
 496                                 DEBUG(6,("short string '%s'\n", as));
 497                         }
 498                 } else {
 499                         if (strlen(as) == len1) {
 500                                 DEBUG(6,("long string '%s'\n", as));
 501                         }
 502                 }
 503                 *s = as;
 504                 break;
 505
 506         case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_BYTESIZE:
 507                 NDR_CHECK(ndr_pull_uint16(ndr, &len3));
 508                 NDR_PULL_NEED_BYTES(ndr, len3);
 509                 if (len3 == 0) {
 510                         *s = talloc_strdup(ndr, "");
 511                         break;
 512                 }
 513                 ret = convert_string_talloc(ndr, chset, CH_UNIX,
 514                                             ndr->data+ndr->offset,
 515                                             len3,
 516                                             (const void **)&as);
 517                 if (ret == -1) {
 518                         return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 519                                               "Bad character conversion");
 520                 }
 521                 NDR_CHECK(ndr_pull_advance(ndr, len3));
 522                 *s = as;
 523                 break;
 524
 525         case LIBNDR_FLAG_STR_NULLTERM:
 526                 len1 = strnlen_w(ndr->data+ndr->offset,
 527                                  (ndr->data_size - ndr->offset)/2);
 528                 if (len1*2+2 <= ndr->data_size - ndr->offset) {
 529                         len1++;
 530                 }
 531                 ret = convert_string_talloc(ndr, chset, CH_UNIX,
 532                                             ndr->data+ndr->offset,
 533                                             len1*2,
 534                                             (const void **)&as);
 535                 if (ret == -1) {
 536                         return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 537                                               "Bad character conversion");
 538                 }
 539                 NDR_CHECK(ndr_pull_advance(ndr, len1*2));
 540                 *s = as;
 541                 break;
 542
 543         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 544         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 545                 NDR_CHECK(ndr_pull_uint32(ndr, &len1));
 546                 NDR_CHECK(ndr_pull_uint32(ndr, &ofs));
 547                 NDR_CHECK(ndr_pull_uint32(ndr, &len2));
 548                 if (len2 > len1) {
 549                         return ndr_pull_error(ndr, NDR_ERR_STRING,
 550                                               "Bad ascii string lengths len1=%u ofs=%u len2=%u\n",
 551                                               len1, ofs, len2);
 552                 }
 553                 NDR_ALLOC_N(ndr, as, (len2+1));
 554                 NDR_CHECK(ndr_pull_bytes(ndr, as, len2));
 555                 as[len2] = 0;
 556                 *s = as;
 557                 break;
 558
 559         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4:
 560                 NDR_CHECK(ndr_pull_uint32(ndr, &ofs));
 561                 NDR_CHECK(ndr_pull_uint32(ndr, &len2));
 562                 NDR_ALLOC_N(ndr, as, (len2+1));
 563                 NDR_CHECK(ndr_pull_bytes(ndr, as, len2));
 564                 as[len2] = 0;
 565                 *s = as;
 566                 break;
 567
 568         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE2:
 569                 NDR_CHECK(ndr_pull_uint16(ndr, &len3));
 570                 NDR_ALLOC_N(ndr, as, (len3+1));
 571                 NDR_CHECK(ndr_pull_bytes(ndr, as, len3));
 572                 as[len3] = 0;
 573                 *s = as;
 574                 break;
 575
 576         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM:
 577                 len1 = strnlen(ndr->data+ndr->offset, (ndr->data_size - ndr->offset));
 578                 if (len1+1 <= ndr->data_size - ndr->offset) {
 579                         len1++;
 580                 }
 581                 NDR_ALLOC_N(ndr, as, (len1+1));
 582                 NDR_CHECK(ndr_pull_bytes(ndr, as, len1));
 583                 as[len1] = 0;
 584                 *s = as;
 585                 break;
 586
 587         default:
 588                 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 589                                       ndr->flags & LIBNDR_STRING_FLAGS);
 590         }
 591
 592         return NT_STATUS_OK;
 593 }
 594
 595
 596 /*
 597   push a general string onto the wire
 598 */
 599 NTSTATUS ndr_push_string(struct ndr_push *ndr, int ndr_flags, const char *s)
 600 {
 601         ssize_t s_len, c_len;
 602         int ret;
 603         int chset = CH_UCS2;
 604
 605         if (!(ndr_flags & NDR_SCALARS)) {
 606                 return NT_STATUS_OK;
 607         }
 608
 609         if (NDR_BE(ndr)) {
 610                 chset = CH_UCS2BE;
 611         }
 612
 613         s_len = s?strlen(s):0;
 614         c_len = s?strlen_m(s):0;
 615
 616         switch (ndr->flags & LIBNDR_STRING_FLAGS) {
 617         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 618                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 619                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 620                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 621                 NDR_PUSH_NEED_BYTES(ndr, c_len*2 + 2);
 622                 ret = convert_string(CH_UNIX, chset,
 623                                      s, s_len+1,
 624                                      ndr->data+ndr->offset, c_len*2 + 2);
 625                 if (ret == -1) {
 626                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 627                                               "Bad character conversion");
 628                 }
 629                 ndr->offset += c_len*2 + 2;
 630                 break;
 631
 632         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 633                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 634                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 635                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 636                 NDR_PUSH_NEED_BYTES(ndr, c_len*2);
 637                 ret = convert_string(CH_UNIX, chset,
 638                                      s, s_len,
 639                                      ndr->data+ndr->offset, c_len*2);
 640                 if (ret == -1) {
 641                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 642                                               "Bad character conversion");
 643                 }
 644                 ndr->offset += c_len*2;
 645                 break;
 646
 647         case LIBNDR_FLAG_STR_SIZE4:
 648                 NDR_CHECK(ndr_push_uint32(ndr, c_len + 1));
 649                 NDR_PUSH_NEED_BYTES(ndr, c_len*2 + 2);
 650                 ret = convert_string(CH_UNIX, chset,
 651                                      s, s_len + 1,
 652                                      ndr->data+ndr->offset, c_len*2 + 2);
 653                 if (ret == -1) {
 654                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 655                                               "Bad character conversion");
 656                 }
 657                 ndr->offset += c_len*2 + 2;
 658                 break;
 659
 660         case LIBNDR_FLAG_STR_NULLTERM:
 661                 NDR_PUSH_NEED_BYTES(ndr, c_len*2 + 2);
 662                 ret = convert_string(CH_UNIX, chset,
 663                                      s, s_len+1,
 664                                      ndr->data+ndr->offset, c_len*2 + 2);
 665                 if (ret == -1) {
 666                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 667                                               "Bad character conversion");
 668                 }
 669                 ndr->offset += c_len*2 + 2;
 670                 break;
 671
 672         case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_BYTESIZE:
 673                 NDR_CHECK(ndr_push_uint16(ndr, c_len*2));
 674                 NDR_PUSH_NEED_BYTES(ndr, c_len*2);
 675                 ret = convert_string(CH_UNIX, chset,
 676                                      s, s_len,
 677                                      ndr->data+ndr->offset, c_len*2);
 678                 if (ret == -1) {
 679                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 680                                               "Bad character conversion");
 681                 }
 682                 ndr->offset += c_len*2;
 683                 break;
 684
 685         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 686                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 687                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 688                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 689                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 690                 ret = convert_string(CH_UNIX, CH_DOS,
 691                                      s, s_len + 1,
 692                                      ndr->data+ndr->offset, c_len + 1);
 693                 if (ret == -1) {
 694                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 695                                               "Bad character conversion");
 696                 }
 697                 ndr->offset += c_len + 1;
 698                 break;
 699
 700         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 701                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 702                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 703                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 704                 NDR_PUSH_NEED_BYTES(ndr, c_len);
 705                 ret = convert_string(CH_UNIX, CH_DOS,
 706                                      s, s_len,
 707                                      ndr->data+ndr->offset, c_len);
 708                 if (ret == -1) {
 709                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 710                                               "Bad character conversion");
 711                 }
 712                 ndr->offset += c_len;
 713                 break;
 714
 715         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4:
 716                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 717                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 718                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 719                 ret = convert_string(CH_UNIX, CH_DOS,
 720                                      s, s_len + 1,
 721                                      ndr->data+ndr->offset, c_len + 1);
 722                 if (ret == -1) {
 723                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 724                                               "Bad character conversion");
 725                 }
 726                 ndr->offset += c_len + 1;
 727                 break;
 728
 729         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE2:
 730                 NDR_CHECK(ndr_push_uint16(ndr, c_len+1));
 731                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 732                 ret = convert_string(CH_UNIX, CH_DOS,
 733                                      s, s_len + 1,
 734                                      ndr->data+ndr->offset, c_len + 1);
 735                 if (ret == -1) {
 736                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 737                                               "Bad character conversion");
 738                 }
 739                 ndr->offset += c_len + 1;
 740                 break;
 741
 742         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM:
 743                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 744                 ret = convert_string(CH_UNIX, CH_DOS,
 745                                      s, s_len+1,
 746                                      ndr->data+ndr->offset, c_len + 1);
 747                 if (ret == -1) {
 748                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 749                                               "Bad character conversion");
 750                 }
 751                 ndr->offset += c_len + 1;
 752                 break;
 753
 754         default:
 755                 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 756                                       ndr->flags & LIBNDR_STRING_FLAGS);
 757         }
 758
 759         return NT_STATUS_OK;
 760 }
 761
 762 /*
 763   push a NTTIME
 764 */
 765 NTSTATUS ndr_push_NTTIME(struct ndr_push *ndr, NTTIME t)
 766 {
 767         NDR_CHECK(ndr_push_uint64(ndr, t));
 768         return NT_STATUS_OK;
 769 }
 770
 771 /*
 772   pull a NTTIME
 773 */
 774 NTSTATUS ndr_pull_NTTIME(struct ndr_pull *ndr, NTTIME *t)
 775 {
 776         NDR_CHECK(ndr_pull_uint64(ndr, t));
 777         return NT_STATUS_OK;
 778 }
 779
 780 /*
 781   push a time_t
 782 */
 783 NTSTATUS ndr_push_time_t(struct ndr_push *ndr, time_t t)
 784 {
 785         return ndr_push_uint32(ndr, t);
 786 }
 787
 788 /*
 789   pull a time_t
 790 */
 791 NTSTATUS ndr_pull_time_t(struct ndr_pull *ndr, time_t *t)
 792 {
 793         uint32_t tt;
 794         NDR_CHECK(ndr_pull_uint32(ndr, &tt));
 795         *t = tt;
 796         return NT_STATUS_OK;
 797 }
 798
 799
 800 void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type)
 801 {
 802         ndr->print(ndr, "%s: struct %s", name, type);
 803 }
 804
 805 void ndr_print_uint8(struct ndr_print *ndr, const char *name, uint8_t v)
 806 {
 807         ndr->print(ndr, "%-25s: 0x%02x (%u)", name, v, v);
 808 }
 809
 810 void ndr_print_uint16(struct ndr_print *ndr, const char *name, uint16_t v)
 811 {
 812         ndr->print(ndr, "%-25s: 0x%04x (%u)", name, v, v);
 813 }
 814
 815 void ndr_print_uint32(struct ndr_print *ndr, const char *name, uint32_t v)
 816 {
 817         ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
 818 }
 819
 820 void ndr_print_uint64(struct ndr_print *ndr, const char *name, uint64_t v)
 821 {
 822         ndr->print(ndr, "%-25s: 0x%08x%08x", name, (uint32_t)(v >> 32), (uint32_t)(v & 0xFFFFFFFF));
 823 }
 824
 825 void ndr_print_int64(struct ndr_print *ndr, const char *name, int64_t v)
 826 {
 827         ndr->print(ndr, "%-25s: 0x%08x%08x (%lld)", name,
 828                    (uint32_t)(v >> 32),
 829                    (uint32_t)(v & 0xFFFFFFFF),
 830                    v);
 831 }
 832
 833 void ndr_print_HYPER_T(struct ndr_print *ndr, const char *name, HYPER_T v)
 834 {
 835         ndr->print(ndr, "%-25s: 0x%08x%08x", name, (uint32_t)(v >> 32), (uint32_t)(v & 0xFFFFFFFF));
 836 }
 837
 838 void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p)
 839 {
 840         if (p) {
 841                 ndr->print(ndr, "%-25s: *", name);
 842         } else {
 843                 ndr->print(ndr, "%-25s: NULL", name);
 844         }
 845 }
 846
 847 void ndr_print_string(struct ndr_print *ndr, const char *name, const char *s)
 848 {
 849         if (s) {
 850                 ndr->print(ndr, "%-25s: '%s'", name, s);
 851         } else {
 852                 ndr->print(ndr, "%-25s: NULL", name);
 853         }
 854 }
 855
 856 void ndr_print_NTTIME(struct ndr_print *ndr, const char *name, NTTIME t)
 857 {
 858         ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr, t));
 859 }
 860
 861 void ndr_print_time_t(struct ndr_print *ndr, const char *name, time_t t)
 862 {
 863         if (t == (time_t)-1 || t == 0) {
 864                 ndr->print(ndr, "%-25s: (time_t)%d", name, (int)t);
 865         } else {
 866                 ndr->print(ndr, "%-25s: %s", name, timestring(ndr, t));
 867         }
 868 }
 869
 870 void ndr_print_union(struct ndr_print *ndr, const char *name, uint16_t level, const char *type)
 871 {
 872         ndr->print(ndr, "%-25s: union %s(case %u)", name, type, level);
 873 }
 874
 875 void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level)
 876 {
 877         ndr->print(ndr, "UNKNOWN LEVEL %u", level);
 878 }
 879
 880 void ndr_print_array_HYPER_T(struct ndr_print *ndr, const char *name,
 881                             const HYPER_T *data, uint32_t count)
 882 {
 883         int i;
 884
 885         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 886         ndr->depth++;
 887         for (i=0;i<count;i++) {
 888                 char *idx=NULL;
 889                 asprintf(&idx, "[%d]", i);
 890                 if (idx) {
 891                         ndr_print_HYPER_T(ndr, idx, data[i]);
 892                         free(idx);
 893                 }
 894         }
 895         ndr->depth--;
 896 }
 897
 898 void ndr_print_array_uint32(struct ndr_print *ndr, const char *name,
 899                             const uint32_t *data, uint32_t count)
 900 {
 901         int i;
 902
 903         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 904         ndr->depth++;
 905         for (i=0;i<count;i++) {
 906                 char *idx=NULL;
 907                 asprintf(&idx, "[%d]", i);
 908                 if (idx) {
 909                         ndr_print_uint32(ndr, idx, data[i]);
 910                         free(idx);
 911                 }
 912         }
 913         ndr->depth--;
 914 }
 915
 916 void ndr_print_array_uint16(struct ndr_print *ndr, const char *name,
 917                             const uint16_t *data, uint32_t count)
 918 {
 919         int i;
 920
 921         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 922         ndr->depth++;
 923         for (i=0;i<count;i++) {
 924                 char *idx=NULL;
 925                 asprintf(&idx, "[%d]", i);
 926                 if (idx) {
 927                         ndr_print_uint16(ndr, idx, data[i]);
 928                         free(idx);
 929                 }
 930         }
 931         ndr->depth--;
 932 }
 933
 934 void ndr_print_array_uint8(struct ndr_print *ndr, const char *name,
 935                            const uint8_t *data, uint32_t count)
 936 {
 937         int i;
 938
 939         if (count <= 600 && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
 940                 char s[1202];
 941                 for (i=0;i<count;i++) {
 942                         snprintf(&s[i*2], 3, "%02x", data[i]);
 943                 }
 944                 s[i*2] = 0;
 945                 ndr->print(ndr, "%-25s: %s", name, s);
 946                 return;
 947         }
 948
 949         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 950         ndr->depth++;
 951         for (i=0;i<count;i++) {
 952                 char *idx=NULL;
 953                 asprintf(&idx, "[%d]", i);
 954                 if (idx) {
 955                         ndr_print_uint8(ndr, idx, data[i]);
 956                         free(idx);
 957                 }
 958         }
 959         ndr->depth--;
 960 }
 961
 962 /*
 963   build a GUID from a string
 964 */
 965 NTSTATUS GUID_from_string(const char *s, struct GUID *guid)
 966 {
 967         uint32_t time_low;
 968         uint32_t time_mid, time_hi_and_version;
 969         uint32_t clock_seq[2];
 970         uint32_t node[6];
 971         int i;
 972
 973         if (11 != sscanf(s, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 974                          &time_low, &time_mid, &time_hi_and_version,
 975                          &clock_seq[0], &clock_seq[1],
 976                          &node[0], &node[1], &node[2], &node[3], &node[4], &node[5])) {
 977                 return NT_STATUS_INVALID_PARAMETER;
 978         }
 979
 980         guid->time_low = time_low;
 981         guid->time_mid = time_mid;
 982         guid->time_hi_and_version = time_hi_and_version;
 983         guid->clock_seq[0] = clock_seq[0];
 984         guid->clock_seq[1] = clock_seq[1];
 985         for (i=0;i<6;i++) {
 986                 guid->node[i] = node[i];
 987         }
 988
 989         return NT_STATUS_OK;
 990 }
 991
 992 /*
 993   its useful to be able to display these in debugging messages
 994 */
 995 const char *GUID_string(TALLOC_CTX *mem_ctx, const struct GUID *guid)
 996 {
 997         return talloc_asprintf(mem_ctx,
 998                                "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 999                                guid->time_low, guid->time_mid,
1000                                guid->time_hi_and_version,
1001                                guid->clock_seq[0],
1002                                guid->clock_seq[1],
1003                                guid->node[0], guid->node[1],
1004                                guid->node[2], guid->node[3],
1005                                guid->node[4], guid->node[5]);
1006 }
1007
1008 void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid)
1009 {
1010         ndr->print(ndr, "%-25s: %s", name, GUID_string(ndr, guid));
1011 }
1012
1013 void ndr_print_DATA_BLOB(struct ndr_print *ndr, const char *name, DATA_BLOB r)
1014 {
1015         ndr->print(ndr, "%-25s: DATA_BLOB length=%u", name, r.length);
1016         if (r.length) {
1017                 dump_data(10, r.data, r.length);
1018         }
1019 }
1020
1021
1022 /*
1023   push a DATA_BLOB onto the wire.
1024 */
1025 NTSTATUS ndr_push_DATA_BLOB(struct ndr_push *ndr, DATA_BLOB blob)
1026 {
1027         if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
1028                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1029                         blob.length = NDR_ALIGN(ndr, 2);
1030                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1031                         blob.length = NDR_ALIGN(ndr, 4);
1032                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1033                         blob.length = NDR_ALIGN(ndr, 8);
1034                 }
1035                 NDR_PUSH_ALLOC_SIZE(ndr, blob.data, blob.length);
1036                 data_blob_clear(&blob);
1037         } else if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
1038                 NDR_CHECK(ndr_push_uint32(ndr, blob.length));
1039         }
1040         NDR_CHECK(ndr_push_bytes(ndr, blob.data, blob.length));
1041         return NT_STATUS_OK;
1042 }
1043
1044 /*
1045   pull a DATA_BLOB from the wire.
1046 */
1047 NTSTATUS ndr_pull_DATA_BLOB(struct ndr_pull *ndr, DATA_BLOB *blob)
1048 {
1049         uint32_t length;
1050
1051         if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
1052                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1053                         length = NDR_ALIGN(ndr, 2);
1054                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1055                         length = NDR_ALIGN(ndr, 4);
1056                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1057                         length = NDR_ALIGN(ndr, 8);
1058                 }
1059                 if (ndr->data_size - ndr->offset < length) {
1060                         length = ndr->data_size - ndr->offset;
1061                 }
1062         } else if (ndr->flags & LIBNDR_FLAG_REMAINING) {
1063                 length = ndr->data_size - ndr->offset;
1064         } else {
1065                 NDR_CHECK(ndr_pull_uint32(ndr, &length));
1066         }
1067         NDR_PULL_NEED_BYTES(ndr, length);
1068         *blob = data_blob_talloc(ndr, ndr->data+ndr->offset, length);
1069         ndr->offset += length;
1070         return NT_STATUS_OK;
1071 }