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->mem_ctx, "");
 447                         break;
 448                 }
 449                 NDR_PULL_NEED_BYTES(ndr, len2*2);
 450                 ret = convert_string_talloc(ndr->mem_ctx, 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                 NDR_CHECK(ndr_pull_uint32(ndr, &len1));
 476                 NDR_PULL_NEED_BYTES(ndr, len1*2);
 477                 if (len1 == 0) {
 478                         *s = talloc_strdup(ndr->mem_ctx, "");
 479                         break;
 480                 }
 481                 ret = convert_string_talloc(ndr->mem_ctx, chset, CH_UNIX,
 482                                             ndr->data+ndr->offset,
 483                                             len1*2,
 484                                             (const void **)&as);
 485                 if (ret == -1) {
 486                         return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 487                                               "Bad character conversion");
 488                 }
 489                 NDR_CHECK(ndr_pull_advance(ndr, len1*2));
 490                 *s = as;
 491                 break;
 492
 493         case LIBNDR_FLAG_STR_NULLTERM:
 494                 len1 = strnlen_w(ndr->data+ndr->offset,
 495                                  (ndr->data_size - ndr->offset)/2);
 496                 if (len1*2+2 <= ndr->data_size - ndr->offset) {
 497                         len1++;
 498                 }
 499                 ret = convert_string_talloc(ndr->mem_ctx, chset, CH_UNIX,
 500                                             ndr->data+ndr->offset,
 501                                             len1*2,
 502                                             (const void **)s);
 503                 if (ret == -1) {
 504                         return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 505                                               "Bad character conversion");
 506                 }
 507                 NDR_CHECK(ndr_pull_advance(ndr, len1*2));
 508                 break;
 509
 510         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 511         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 512                 NDR_CHECK(ndr_pull_uint32(ndr, &len1));
 513                 NDR_CHECK(ndr_pull_uint32(ndr, &ofs));
 514                 NDR_CHECK(ndr_pull_uint32(ndr, &len2));
 515                 if (len2 > len1) {
 516                         return ndr_pull_error(ndr, NDR_ERR_STRING,
 517                                               "Bad ascii string lengths len1=%u ofs=%u len2=%u\n",
 518                                               len1, ofs, len2);
 519                 }
 520                 NDR_ALLOC_N(ndr, as, (len2+1));
 521                 NDR_CHECK(ndr_pull_bytes(ndr, as, len2));
 522                 as[len2] = 0;
 523                 (*s) = as;
 524                 break;
 525
 526         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4:
 527                 NDR_CHECK(ndr_pull_uint32(ndr, &ofs));
 528                 NDR_CHECK(ndr_pull_uint32(ndr, &len2));
 529                 NDR_ALLOC_N(ndr, as, (len2+1));
 530                 NDR_CHECK(ndr_pull_bytes(ndr, as, len2));
 531                 as[len2] = 0;
 532                 (*s) = as;
 533                 break;
 534
 535         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE2:
 536                 NDR_CHECK(ndr_pull_uint16(ndr, &len3));
 537                 NDR_ALLOC_N(ndr, as, (len3+1));
 538                 NDR_CHECK(ndr_pull_bytes(ndr, as, len3));
 539                 as[len3] = 0;
 540                 (*s) = as;
 541                 break;
 542
 543         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM:
 544                 len1 = strnlen(ndr->data+ndr->offset, (ndr->data_size - ndr->offset));
 545                 if (len1+1 <= ndr->data_size - ndr->offset) {
 546                         len1++;
 547                 }
 548                 NDR_ALLOC_N(ndr, as, (len1+1));
 549                 NDR_CHECK(ndr_pull_bytes(ndr, as, len1));
 550                 as[len1] = 0;
 551                 (*s) = as;
 552                 break;
 553
 554         default:
 555                 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 556                                       ndr->flags & LIBNDR_STRING_FLAGS);
 557         }
 558
 559         return NT_STATUS_OK;
 560 }
 561
 562
 563 /*
 564   push a general string onto the wire
 565 */
 566 NTSTATUS ndr_push_string(struct ndr_push *ndr, int ndr_flags, const char *s)
 567 {
 568         ssize_t s_len, c_len;
 569         int ret;
 570         int chset = CH_UCS2;
 571
 572         if (!(ndr_flags & NDR_SCALARS)) {
 573                 return NT_STATUS_OK;
 574         }
 575
 576         if (NDR_BE(ndr)) {
 577                 chset = CH_UCS2BE;
 578         }
 579
 580         s_len = s?strlen(s):0;
 581         c_len = s?strlen_m(s):0;
 582
 583         switch (ndr->flags & LIBNDR_STRING_FLAGS) {
 584         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 585                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 586                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 587                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 588                 NDR_PUSH_NEED_BYTES(ndr, c_len*2 + 2);
 589                 ret = convert_string(CH_UNIX, chset,
 590                                      s, s_len+1,
 591                                      ndr->data+ndr->offset, c_len*2 + 2);
 592                 if (ret == -1) {
 593                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 594                                               "Bad character conversion");
 595                 }
 596                 ndr->offset += c_len*2 + 2;
 597                 break;
 598
 599         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 600                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 601                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 602                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 603                 NDR_PUSH_NEED_BYTES(ndr, c_len*2);
 604                 ret = convert_string(CH_UNIX, chset,
 605                                      s, s_len,
 606                                      ndr->data+ndr->offset, c_len*2);
 607                 if (ret == -1) {
 608                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 609                                               "Bad character conversion");
 610                 }
 611                 ndr->offset += c_len*2;
 612                 break;
 613
 614         case LIBNDR_FLAG_STR_SIZE4:
 615                 NDR_CHECK(ndr_push_uint32(ndr, c_len + 1));
 616                 NDR_PUSH_NEED_BYTES(ndr, c_len*2 + 2);
 617                 ret = convert_string(CH_UNIX, chset,
 618                                      s, s_len + 1,
 619                                      ndr->data+ndr->offset, c_len*2 + 2);
 620                 if (ret == -1) {
 621                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 622                                               "Bad character conversion");
 623                 }
 624                 ndr->offset += c_len*2 + 2;
 625                 break;
 626
 627         case LIBNDR_FLAG_STR_NULLTERM:
 628                 NDR_PUSH_NEED_BYTES(ndr, c_len*2 + 2);
 629                 ret = convert_string(CH_UNIX, chset,
 630                                      s, s_len+1,
 631                                      ndr->data+ndr->offset, c_len*2 + 2);
 632                 if (ret == -1) {
 633                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 634                                               "Bad character conversion");
 635                 }
 636                 ndr->offset += c_len*2 + 2;
 637                 break;
 638
 639         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 640                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 641                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 642                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 643                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 644                 ret = convert_string(CH_UNIX, CH_DOS,
 645                                      s, s_len + 1,
 646                                      ndr->data+ndr->offset, c_len + 1);
 647                 if (ret == -1) {
 648                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 649                                               "Bad character conversion");
 650                 }
 651                 ndr->offset += c_len + 1;
 652                 break;
 653
 654         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
 655                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 656                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 657                 NDR_CHECK(ndr_push_uint32(ndr, c_len));
 658                 NDR_PUSH_NEED_BYTES(ndr, c_len);
 659                 ret = convert_string(CH_UNIX, CH_DOS,
 660                                      s, s_len,
 661                                      ndr->data+ndr->offset, c_len);
 662                 if (ret == -1) {
 663                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 664                                               "Bad character conversion");
 665                 }
 666                 ndr->offset += c_len;
 667                 break;
 668
 669         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_LEN4:
 670                 NDR_CHECK(ndr_push_uint32(ndr, 0));
 671                 NDR_CHECK(ndr_push_uint32(ndr, c_len+1));
 672                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 673                 ret = convert_string(CH_UNIX, CH_DOS,
 674                                      s, s_len + 1,
 675                                      ndr->data+ndr->offset, c_len + 1);
 676                 if (ret == -1) {
 677                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 678                                               "Bad character conversion");
 679                 }
 680                 ndr->offset += c_len + 1;
 681                 break;
 682
 683         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_SIZE2:
 684                 NDR_CHECK(ndr_push_uint16(ndr, c_len+1));
 685                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 686                 ret = convert_string(CH_UNIX, CH_DOS,
 687                                      s, s_len + 1,
 688                                      ndr->data+ndr->offset, c_len + 1);
 689                 if (ret == -1) {
 690                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 691                                               "Bad character conversion");
 692                 }
 693                 ndr->offset += c_len + 1;
 694                 break;
 695
 696         case LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM:
 697                 NDR_PUSH_NEED_BYTES(ndr, c_len + 1);
 698                 ret = convert_string(CH_UNIX, CH_DOS,
 699                                      s, s_len+1,
 700                                      ndr->data+ndr->offset, c_len + 1);
 701                 if (ret == -1) {
 702                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 703                                               "Bad character conversion");
 704                 }
 705                 ndr->offset += c_len + 1;
 706                 break;
 707
 708         default:
 709                 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 710                                       ndr->flags & LIBNDR_STRING_FLAGS);
 711         }
 712
 713         return NT_STATUS_OK;
 714 }
 715
 716 /*
 717   push a NTTIME
 718 */
 719 NTSTATUS ndr_push_NTTIME(struct ndr_push *ndr, NTTIME t)
 720 {
 721         NDR_CHECK(ndr_push_uint64(ndr, t));
 722         return NT_STATUS_OK;
 723 }
 724
 725 /*
 726   pull a NTTIME
 727 */
 728 NTSTATUS ndr_pull_NTTIME(struct ndr_pull *ndr, NTTIME *t)
 729 {
 730         NDR_CHECK(ndr_pull_uint64(ndr, t));
 731         return NT_STATUS_OK;
 732 }
 733
 734 /*
 735   push a time_t
 736 */
 737 NTSTATUS ndr_push_time_t(struct ndr_push *ndr, time_t t)
 738 {
 739         return ndr_push_uint32(ndr, t);
 740 }
 741
 742 /*
 743   pull a time_t
 744 */
 745 NTSTATUS ndr_pull_time_t(struct ndr_pull *ndr, time_t *t)
 746 {
 747         uint32_t tt;
 748         NDR_CHECK(ndr_pull_uint32(ndr, &tt));
 749         *t = tt;
 750         return NT_STATUS_OK;
 751 }
 752
 753
 754 void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type)
 755 {
 756         ndr->print(ndr, "%s: struct %s", name, type);
 757 }
 758
 759 void ndr_print_uint8(struct ndr_print *ndr, const char *name, uint8_t v)
 760 {
 761         ndr->print(ndr, "%-25s: 0x%02x (%u)", name, v, v);
 762 }
 763
 764 void ndr_print_uint16(struct ndr_print *ndr, const char *name, uint16_t v)
 765 {
 766         ndr->print(ndr, "%-25s: 0x%04x (%u)", name, v, v);
 767 }
 768
 769 void ndr_print_uint32(struct ndr_print *ndr, const char *name, uint32_t v)
 770 {
 771         ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
 772 }
 773
 774 void ndr_print_uint64(struct ndr_print *ndr, const char *name, uint64_t v)
 775 {
 776         ndr->print(ndr, "%-25s: 0x%08x%08x", name, (uint32_t)(v >> 32), (uint32_t)(v & 0xFFFFFFFF));
 777 }
 778
 779 void ndr_print_int64(struct ndr_print *ndr, const char *name, int64_t v)
 780 {
 781         ndr->print(ndr, "%-25s: 0x%08x%08x (%lld)", name,
 782                    (uint32_t)(v >> 32),
 783                    (uint32_t)(v & 0xFFFFFFFF),
 784                    v);
 785 }
 786
 787 void ndr_print_HYPER_T(struct ndr_print *ndr, const char *name, HYPER_T v)
 788 {
 789         ndr->print(ndr, "%-25s: 0x%08x%08x", name, (uint32_t)(v >> 32), (uint32_t)(v & 0xFFFFFFFF));
 790 }
 791
 792 void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p)
 793 {
 794         if (p) {
 795                 ndr->print(ndr, "%-25s: *", name);
 796         } else {
 797                 ndr->print(ndr, "%-25s: NULL", name);
 798         }
 799 }
 800
 801 void ndr_print_string(struct ndr_print *ndr, const char *name, const char *s)
 802 {
 803         if (s) {
 804                 ndr->print(ndr, "%-25s: '%s'", name, s);
 805         } else {
 806                 ndr->print(ndr, "%-25s: NULL", name);
 807         }
 808 }
 809
 810 void ndr_print_NTTIME(struct ndr_print *ndr, const char *name, NTTIME t)
 811 {
 812         ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr->mem_ctx, t));
 813 }
 814
 815 void ndr_print_time_t(struct ndr_print *ndr, const char *name, time_t t)
 816 {
 817         if (t == (time_t)-1 || t == 0) {
 818                 ndr->print(ndr, "%-25s: (time_t)%d", name, (int)t);
 819         } else {
 820                 ndr->print(ndr, "%-25s: %s", name, timestring(ndr->mem_ctx, t));
 821         }
 822 }
 823
 824 void ndr_print_union(struct ndr_print *ndr, const char *name, uint16_t level, const char *type)
 825 {
 826         ndr->print(ndr, "%-25s: union %s(case %u)", name, type, level);
 827 }
 828
 829 void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level)
 830 {
 831         ndr->print(ndr, "UNKNOWN LEVEL %u", level);
 832 }
 833
 834 void ndr_print_array_HYPER_T(struct ndr_print *ndr, const char *name,
 835                             const HYPER_T *data, uint32_t count)
 836 {
 837         int i;
 838
 839         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 840         ndr->depth++;
 841         for (i=0;i<count;i++) {
 842                 char *idx=NULL;
 843                 asprintf(&idx, "[%d]", i);
 844                 if (idx) {
 845                         ndr_print_HYPER_T(ndr, idx, data[i]);
 846                         free(idx);
 847                 }
 848         }
 849         ndr->depth--;
 850 }
 851
 852 void ndr_print_array_uint32(struct ndr_print *ndr, const char *name,
 853                             const uint32_t *data, uint32_t count)
 854 {
 855         int i;
 856
 857         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 858         ndr->depth++;
 859         for (i=0;i<count;i++) {
 860                 char *idx=NULL;
 861                 asprintf(&idx, "[%d]", i);
 862                 if (idx) {
 863                         ndr_print_uint32(ndr, idx, data[i]);
 864                         free(idx);
 865                 }
 866         }
 867         ndr->depth--;
 868 }
 869
 870 void ndr_print_array_uint16(struct ndr_print *ndr, const char *name,
 871                             const uint16_t *data, uint32_t count)
 872 {
 873         int i;
 874
 875         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 876         ndr->depth++;
 877         for (i=0;i<count;i++) {
 878                 char *idx=NULL;
 879                 asprintf(&idx, "[%d]", i);
 880                 if (idx) {
 881                         ndr_print_uint16(ndr, idx, data[i]);
 882                         free(idx);
 883                 }
 884         }
 885         ndr->depth--;
 886 }
 887
 888 void ndr_print_array_uint8(struct ndr_print *ndr, const char *name,
 889                            const uint8_t *data, uint32_t count)
 890 {
 891         int i;
 892
 893         if (count <= 600 && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
 894                 char s[1202];
 895                 for (i=0;i<count;i++) {
 896                         snprintf(&s[i*2], 3, "%02x", data[i]);
 897                 }
 898                 s[i*2] = 0;
 899                 ndr->print(ndr, "%-25s: %s", name, s);
 900                 return;
 901         }
 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_uint8(ndr, idx, data[i]);
 910                         free(idx);
 911                 }
 912         }
 913         ndr->depth--;
 914 }
 915
 916 /*
 917   build a GUID from a string
 918 */
 919 NTSTATUS GUID_from_string(const char *s, struct GUID *guid)
 920 {
 921         uint32_t time_low;
 922         uint32_t time_mid, time_hi_and_version;
 923         uint32_t clock_seq[2];
 924         uint32_t node[6];
 925         int i;
 926
 927         if (11 != sscanf(s, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 928                          &time_low, &time_mid, &time_hi_and_version,
 929                          &clock_seq[0], &clock_seq[1],
 930                          &node[0], &node[1], &node[2], &node[3], &node[4], &node[5])) {
 931                 return NT_STATUS_INVALID_PARAMETER;
 932         }
 933
 934         guid->time_low = time_low;
 935         guid->time_mid = time_mid;
 936         guid->time_hi_and_version = time_hi_and_version;
 937         guid->clock_seq[0] = clock_seq[0];
 938         guid->clock_seq[1] = clock_seq[1];
 939         for (i=0;i<6;i++) {
 940                 guid->node[i] = node[i];
 941         }
 942
 943         return NT_STATUS_OK;
 944 }
 945
 946 /*
 947   its useful to be able to display these in debugging messages
 948 */
 949 const char *GUID_string(TALLOC_CTX *mem_ctx, const struct GUID *guid)
 950 {
 951         return talloc_asprintf(mem_ctx,
 952                                "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 953                                guid->time_low, guid->time_mid,
 954                                guid->time_hi_and_version,
 955                                guid->clock_seq[0],
 956                                guid->clock_seq[1],
 957                                guid->node[0], guid->node[1],
 958                                guid->node[2], guid->node[3],
 959                                guid->node[4], guid->node[5]);
 960 }
 961
 962 void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid)
 963 {
 964         ndr->print(ndr, "%-25s: %s", name, GUID_string(ndr->mem_ctx, guid));
 965 }
 966
 967 void ndr_print_DATA_BLOB(struct ndr_print *ndr, const char *name, DATA_BLOB r)
 968 {
 969         ndr->print(ndr, "%-25s: DATA_BLOB length=%u", name, r.length);
 970         if (r.length) {
 971                 dump_data(10, r.data, r.length);
 972         }
 973 }
 974
 975
 976 /*
 977   push a DATA_BLOB onto the wire.
 978 */
 979 NTSTATUS ndr_push_DATA_BLOB(struct ndr_push *ndr, DATA_BLOB blob)
 980 {
 981         if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
 982                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
 983                         blob.length = NDR_ALIGN(ndr, 2);
 984                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
 985                         blob.length = NDR_ALIGN(ndr, 4);
 986                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
 987                         blob.length = NDR_ALIGN(ndr, 8);
 988                 }
 989                 NDR_PUSH_ALLOC_SIZE(ndr, blob.data, blob.length);
 990                 data_blob_clear(&blob);
 991         } else if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
 992                 NDR_CHECK(ndr_push_uint32(ndr, blob.length));
 993         }
 994         NDR_CHECK(ndr_push_bytes(ndr, blob.data, blob.length));
 995         return NT_STATUS_OK;
 996 }
 997
 998 /*
 999   pull a DATA_BLOB from the wire.
1000 */
1001 NTSTATUS ndr_pull_DATA_BLOB(struct ndr_pull *ndr, DATA_BLOB *blob)
1002 {
1003         uint32_t length;
1004
1005         if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
1006                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1007                         length = NDR_ALIGN(ndr, 2);
1008                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1009                         length = NDR_ALIGN(ndr, 4);
1010                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1011                         length = NDR_ALIGN(ndr, 8);
1012                 }
1013                 if (ndr->data_size - ndr->offset < length) {
1014                         length = ndr->data_size - ndr->offset;
1015                 }
1016         } else if (ndr->flags & LIBNDR_FLAG_REMAINING) {
1017                 length = ndr->data_size - ndr->offset;
1018         } else {
1019                 NDR_CHECK(ndr_pull_uint32(ndr, &length));
1020         }
1021         NDR_PULL_NEED_BYTES(ndr, length);
1022         *blob = data_blob_talloc(ndr->mem_ctx, ndr->data+ndr->offset, length);
1023         ndr->offset += length;
1024         return NT_STATUS_OK;
1025 }