librpc/ndr/ndr_string.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    routines for marshalling/unmarshalling string 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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "librpc/ndr/libndr.h"
  24
  25 /**
  26   pull a general string from the wire
  27 */
  28 _PUBLIC_ enum ndr_err_code ndr_pull_string(struct ndr_pull *ndr, int ndr_flags, const char **s)
  29 {
  30         char *as=NULL;
  31         uint32_t len1, ofs, len2;
  32         uint16_t len3;
  33         size_t conv_src_len = 0, converted_size;
  34         int do_convert = 1, chset = CH_UTF16;
  35         unsigned byte_mul = 2;
  36         unsigned flags = ndr->flags;
  37         unsigned c_len_term = 0;
  38
  39         if (!(ndr_flags & NDR_SCALARS)) {
  40                 return NDR_ERR_SUCCESS;
  41         }
  42
  43         if (NDR_BE(ndr)) {
  44                 chset = CH_UTF16BE;
  45         }
  46
  47         if (flags & LIBNDR_FLAG_STR_ASCII) {
  48                 chset = CH_DOS;
  49                 byte_mul = 1;
  50                 flags &= ~LIBNDR_FLAG_STR_ASCII;
  51         }
  52
  53         if (flags & LIBNDR_FLAG_STR_UTF8) {
  54                 chset = CH_UTF8;
  55                 byte_mul = 1;
  56                 flags &= ~LIBNDR_FLAG_STR_UTF8;
  57         }
  58
  59         if (flags & LIBNDR_FLAG_STR_RAW8) {
  60                 do_convert = 0;
  61                 byte_mul = 1;
  62                 flags &= ~LIBNDR_FLAG_STR_RAW8;
  63         }
  64
  65         flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
  66         if (flags & LIBNDR_FLAG_STR_CHARLEN) {
  67                 c_len_term = 1;
  68                 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
  69         }
  70
  71         switch (flags & LIBNDR_STRING_FLAGS) {
  72         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
  73         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
  74                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
  75                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &ofs));
  76                 if (ofs != 0) {
  77                         return ndr_pull_error(ndr, NDR_ERR_STRING, "non-zero array offset with string flags 0x%x\n",
  78                                               ndr->flags & LIBNDR_STRING_FLAGS);
  79                 }
  80                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len2));
  81                 if (len2 > len1) {
  82                         return ndr_pull_error(ndr, NDR_ERR_STRING,
  83                                               "Bad string lengths len1=%u ofs=%u len2=%u\n",
  84                                               len1, ofs, len2);
  85                 } else if (len1 != len2) {
  86                         DEBUG(6,("len1[%u] != len2[%u] '%s'\n", len1, len2, as));
  87                 }
  88                 conv_src_len = len2 + c_len_term;
  89                 break;
  90
  91         case LIBNDR_FLAG_STR_SIZE4:
  92         case LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
  93                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
  94                 conv_src_len = len1 + c_len_term;
  95                 break;
  96
  97         case LIBNDR_FLAG_STR_LEN4:
  98         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_NOTERM:
  99                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &ofs));
 100                 if (ofs != 0) {
 101                         return ndr_pull_error(ndr, NDR_ERR_STRING, "non-zero array offset with string flags 0x%x\n",
 102                                               ndr->flags & LIBNDR_STRING_FLAGS);
 103                 }
 104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
 105                 conv_src_len = len1 + c_len_term;
 106                 break;
 107
 108         case LIBNDR_FLAG_STR_SIZE2:
 109         case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM:
 110                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
 111                 conv_src_len = len3 + c_len_term;
 112                 break;
 113
 114         case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_BYTESIZE:
 115                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
 116                 conv_src_len = len3;
 117                 byte_mul = 1; /* the length is now absolute */
 118                 break;
 119
 120         case LIBNDR_FLAG_STR_NULLTERM:
 121                 /*
 122                  * We ensure that conv_str_len cannot return 0 by
 123                  * requring that there be enough bytes for at least
 124                  * the NULL terminator
 125                  */
 126                 if (byte_mul == 1) {
 127                         NDR_PULL_NEED_BYTES(ndr, 1);
 128                         conv_src_len = ascii_len_n((const char *)(ndr->data+ndr->offset), ndr->data_size - ndr->offset);
 129                 } else {
 130                         NDR_PULL_NEED_BYTES(ndr, 2);
 131                         conv_src_len = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
 132                 }
 133                 byte_mul = 1; /* the length is now absolute */
 134                 break;
 135
 136         case LIBNDR_FLAG_STR_NOTERM:
 137                 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
 138                         return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
 139                                               ndr->flags & LIBNDR_STRING_FLAGS);
 140                 }
 141                 conv_src_len = ndr->data_size - ndr->offset;
 142                 byte_mul = 1; /* the length is now absolute */
 143                 break;
 144
 145         default:
 146                 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 147                                       ndr->flags & LIBNDR_STRING_FLAGS);
 148         }
 149
 150         NDR_PULL_NEED_BYTES(ndr, conv_src_len * byte_mul);
 151         if (conv_src_len == 0) {
 152                 as = talloc_strdup(ndr->current_mem_ctx, "");
 153                 converted_size = 0;
 154         } else {
 155                 if (!do_convert) {
 156                         as = talloc_strndup(ndr->current_mem_ctx,
 157                                             (char *)ndr->data + ndr->offset,
 158                                             conv_src_len);
 159                         if (!as) {
 160                                 return ndr_pull_error(ndr, NDR_ERR_ALLOC,
 161                                                       "Failed to talloc_strndup() in RAW8 ndr_string_pull()");
 162                         }
 163                         converted_size = MIN(strlen(as)+1, conv_src_len);
 164                 } else if (!convert_string_talloc(ndr->current_mem_ctx, chset,
 165                                            CH_UNIX, ndr->data + ndr->offset,
 166                                            conv_src_len * byte_mul,
 167                                            (void **)(void *)&as,
 168                                            &converted_size)) {
 169                         return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 170                                               "Bad character conversion with flags 0x%x", flags);
 171                 }
 172         }
 173
 174         /* this is a way of detecting if a string is sent with the wrong
 175            termination */
 176         if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
 177                 if (as && converted_size > 0 && as[converted_size-1] == '\0') {
 178                         DEBUG(6,("short string '%s', sent with NULL termination despite NOTERM flag in IDL\n", as));
 179                 }
 180         } else {
 181                 if (as && converted_size > 0 && as[converted_size-1] != '\0') {
 182                         DEBUG(6,("long string '%s', send without NULL termination (which was expected)\n", as));
 183                 }
 184         }
 185
 186         NDR_CHECK(ndr_pull_advance(ndr, conv_src_len * byte_mul));
 187         *s = as;
 188
 189         return NDR_ERR_SUCCESS;
 190 }
 191
 192
 193 /**
 194   push a general string onto the wire
 195 */
 196 _PUBLIC_ enum ndr_err_code ndr_push_string(struct ndr_push *ndr, int ndr_flags, const char *s)
 197 {
 198         ssize_t s_len, c_len;
 199         size_t d_len;
 200         int do_convert = 1, chset = CH_UTF16;
 201         unsigned flags = ndr->flags;
 202         unsigned byte_mul = 2;
 203         uint8_t *dest = NULL;
 204
 205         if (!(ndr_flags & NDR_SCALARS)) {
 206                 return NDR_ERR_SUCCESS;
 207         }
 208
 209         if (NDR_BE(ndr)) {
 210                 chset = CH_UTF16BE;
 211         }
 212
 213         s_len = s?strlen(s):0;
 214
 215         if (flags & LIBNDR_FLAG_STR_ASCII) {
 216                 chset = CH_DOS;
 217                 byte_mul = 1;
 218                 flags &= ~LIBNDR_FLAG_STR_ASCII;
 219         }
 220
 221         if (flags & LIBNDR_FLAG_STR_UTF8) {
 222                 chset = CH_UTF8;
 223                 byte_mul = 1;
 224                 flags &= ~LIBNDR_FLAG_STR_UTF8;
 225         }
 226
 227         if (flags & LIBNDR_FLAG_STR_RAW8) {
 228                 do_convert = 0;
 229                 byte_mul = 1;
 230                 flags &= ~LIBNDR_FLAG_STR_RAW8;
 231         }
 232
 233         flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
 234
 235         if (!(flags & LIBNDR_FLAG_STR_NOTERM)) {
 236                 s_len++;
 237         }
 238
 239         if (s_len == 0) {
 240                 d_len = 0;
 241                 dest = (uint8_t *)talloc_strdup(ndr, "");
 242         } else if (!do_convert) {
 243                 d_len = s_len;
 244                 dest = (uint8_t *)talloc_strndup(ndr, s, s_len);
 245         } else if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
 246                                    (void **)(void *)&dest, &d_len))
 247         {
 248                 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 249                                       "Bad character push conversion with flags 0x%x", flags);
 250         }
 251
 252         if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
 253                 c_len = d_len;
 254                 flags &= ~LIBNDR_FLAG_STR_BYTESIZE;
 255         } else if (flags & LIBNDR_FLAG_STR_CHARLEN) {
 256                 c_len = (d_len / byte_mul)-1;
 257                 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
 258         } else {
 259                 c_len = d_len / byte_mul;
 260         }
 261
 262         switch ((flags & LIBNDR_STRING_FLAGS) & ~LIBNDR_FLAG_STR_NOTERM) {
 263         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 267                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 268                 break;
 269
 270         case LIBNDR_FLAG_STR_LEN4:
 271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 273                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 274                 break;
 275
 276         case LIBNDR_FLAG_STR_SIZE4:
 277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 278                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 279                 break;
 280
 281         case LIBNDR_FLAG_STR_SIZE2:
 282                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, c_len));
 283                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 284                 break;
 285
 286         case LIBNDR_FLAG_STR_NULLTERM:
 287                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 288                 break;
 289
 290         default:
 291                 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
 292                         NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 293                         break;
 294                 }
 295
 296                 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 297                                       ndr->flags & LIBNDR_STRING_FLAGS);
 298         }
 299
 300         talloc_free(dest);
 301
 302         return NDR_ERR_SUCCESS;
 303 }
 304
 305 /**
 306   push a general string onto the wire
 307 */
 308 _PUBLIC_ size_t ndr_string_array_size(struct ndr_push *ndr, const char *s)
 309 {
 310         size_t c_len;
 311         unsigned flags = ndr->flags;
 312         unsigned byte_mul = 2;
 313         unsigned c_len_term = 1;
 314
 315         if (flags & LIBNDR_FLAG_STR_RAW8) {
 316                 c_len = s?strlen(s):0;
 317         } else {
 318                 c_len = s?strlen_m(s):0;
 319         }
 320
 321         if (flags & (LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_RAW8|LIBNDR_FLAG_STR_UTF8)) {
 322                 byte_mul = 1;
 323         }
 324
 325         if (flags & LIBNDR_FLAG_STR_NOTERM) {
 326                 c_len_term = 0;
 327         }
 328
 329         c_len = c_len + c_len_term;
 330
 331         if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
 332                 c_len = c_len * byte_mul;
 333         }
 334
 335         return c_len;
 336 }
 337
 338 _PUBLIC_ void ndr_print_string(struct ndr_print *ndr, const char *name, const char *s)
 339 {
 340         if (NDR_HIDE_SECRET(ndr)) {
 341                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
 342                 return;
 343         }
 344         if (s) {
 345                 ndr->print(ndr, "%-25s: '%s'", name, s);
 346         } else {
 347                 ndr->print(ndr, "%-25s: NULL", name);
 348         }
 349 }
 350
 351 _PUBLIC_ uint32_t ndr_size_string(int ret, const char * const* string, int flags)
 352 {
 353         /* FIXME: Is this correct for all strings ? */
 354         if(!(*string)) return ret;
 355         return ret+strlen(*string)+1;
 356 }
 357
 358 static uint32_t guess_string_array_size(struct ndr_pull *ndr, int ndr_flags)
 359 {
 360         /*
 361          * Here we could do something clever like count the number of zeros in
 362          * the ndr data, but it is probably sufficient to pick a lowish number
 363          * (compared to the overhead of the talloc header) and let the
 364          * expontential resizing deal with longer arrays.
 365          */
 366         return 5;
 367 }
 368
 369 static enum ndr_err_code extend_string_array(struct ndr_pull *ndr,
 370                                              const char ***_a,
 371                                              uint32_t *count)
 372 {
 373         const char **a = *_a;
 374         uint32_t inc = *count / 4 + 3;
 375         uint32_t alloc_size = *count + inc;
 376
 377         if (alloc_size < *count) {
 378                 /* overflow ! */
 379                 return NDR_ERR_ALLOC;
 380         }
 381         /*
 382          * We allocate and zero two more bytes than we report back, so that
 383          * the string array will always be NULL terminated.
 384          */
 385         a = talloc_realloc(ndr->current_mem_ctx, a,
 386                            const char *,
 387                            alloc_size);
 388         NDR_ERR_HAVE_NO_MEMORY(a);
 389
 390         memset(a + *count, 0, inc * sizeof(a[0]));
 391         *_a = a;
 392         *count = alloc_size - 2;
 393         return NDR_ERR_SUCCESS;
 394 }
 395
 396 /**
 397   pull a general string array from the wire
 398 */
 399 _PUBLIC_ enum ndr_err_code ndr_pull_string_array(struct ndr_pull *ndr, int ndr_flags, const char ***_a)
 400 {
 401         const char **a = NULL;
 402         uint32_t count;
 403         unsigned flags = ndr->flags;
 404         unsigned saved_flags = ndr->flags;
 405         uint32_t alloc_size;
 406
 407         if (!(ndr_flags & NDR_SCALARS)) {
 408                 return NDR_ERR_SUCCESS;
 409         }
 410
 411         alloc_size = guess_string_array_size(ndr, ndr_flags);
 412         a = talloc_zero_array(ndr->current_mem_ctx, const char *, alloc_size + 2);
 413         NDR_ERR_HAVE_NO_MEMORY(a);
 414
 415         switch (flags & (LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_STR_NOTERM)) {
 416         case LIBNDR_FLAG_STR_NULLTERM:
 417                 /*
 418                  * here the strings are null terminated
 419                  * but also the array is null terminated if LIBNDR_FLAG_REMAINING
 420                  * is specified
 421                  */
 422                 for (count = 0;; count++) {
 423                         TALLOC_CTX *tmp_ctx;
 424                         const char *s = NULL;
 425                         if (count == alloc_size) {
 426                                 NDR_CHECK(extend_string_array(ndr,
 427                                                               &a,
 428                                                               &alloc_size));
 429                         }
 430
 431                         tmp_ctx = ndr->current_mem_ctx;
 432                         ndr->current_mem_ctx = a;
 433                         NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
 434                         ndr->current_mem_ctx = tmp_ctx;
 435                         if ((ndr->data_size - ndr->offset) == 0 && ndr->flags & LIBNDR_FLAG_REMAINING)
 436                         {
 437                                 a[count] = s;
 438                                 break;
 439                         }
 440                         if (strcmp("", s)==0) {
 441                                 a[count] = NULL;
 442                                 break;
 443                         } else {
 444                                 a[count] = s;
 445                         }
 446                 }
 447
 448                 *_a =a;
 449                 break;
 450
 451         case LIBNDR_FLAG_STR_NOTERM:
 452                 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
 453                         return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
 454                                               ndr->flags & LIBNDR_STRING_FLAGS);
 455                 }
 456                 /*
 457                  * here the strings are not null terminated
 458                  * but separated by a null terminator
 459                  *
 460                  * which means the same as:
 461                  * Every string is null terminated exept the last
 462                  * string is terminated by the end of the buffer
 463                  *
 464                  * as LIBNDR_FLAG_STR_NULLTERM also end at the end
 465                  * of the buffer, we can pull each string with this flag
 466                  *
 467                  * The big difference with the case LIBNDR_FLAG_STR_NOTERM +
 468                  * LIBNDR_FLAG_REMAINING is that the last string will not be null terminated
 469                  */
 470                 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 471                 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
 472
 473                 for (count = 0; ((ndr->data_size - ndr->offset) > 0); count++) {
 474                         TALLOC_CTX *tmp_ctx;
 475                         const char *s = NULL;
 476                         if (count == alloc_size) {
 477                                 NDR_CHECK(extend_string_array(ndr,
 478                                                               &a,
 479                                                               &alloc_size));
 480                         }
 481
 482                         tmp_ctx = ndr->current_mem_ctx;
 483                         ndr->current_mem_ctx = a;
 484                         NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
 485                         ndr->current_mem_ctx = tmp_ctx;
 486                         a[count] = s;
 487                 }
 488
 489                 a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 1);
 490                 NDR_ERR_HAVE_NO_MEMORY(a);
 491                 *_a = a;
 492                 break;
 493
 494         default:
 495                 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 496                                       ndr->flags & LIBNDR_STRING_FLAGS);
 497         }
 498
 499         ndr->flags = saved_flags;
 500         return NDR_ERR_SUCCESS;
 501 }
 502
 503 /**
 504   push a general string array onto the wire
 505 */
 506 _PUBLIC_ enum ndr_err_code ndr_push_string_array(struct ndr_push *ndr, int ndr_flags, const char **a)
 507 {
 508         uint32_t count;
 509         unsigned flags = ndr->flags;
 510         unsigned saved_flags = ndr->flags;
 511
 512         if (!(ndr_flags & NDR_SCALARS)) {
 513                 return NDR_ERR_SUCCESS;
 514         }
 515
 516         switch (flags & LIBNDR_STRING_FLAGS) {
 517         case LIBNDR_FLAG_STR_NULLTERM:
 518                 for (count = 0; a && a[count]; count++) {
 519                         NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
 520                 }
 521                 /* If LIBNDR_FLAG_REMAINING then we do not add a null terminator to the array */
 522                 if (!(flags & LIBNDR_FLAG_REMAINING))
 523                 {
 524                         NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
 525                 }
 526                 break;
 527
 528         case LIBNDR_FLAG_STR_NOTERM:
 529                 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
 530                         return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
 531                                               ndr->flags & LIBNDR_STRING_FLAGS);
 532                 }
 533
 534                 for (count = 0; a && a[count]; count++) {
 535                         if (count > 0) {
 536                                 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 537                                 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
 538                                 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
 539                                 ndr->flags = saved_flags;
 540                         }
 541                         NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
 542                 }
 543
 544                 break;
 545
 546         default:
 547                 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 548                                       ndr->flags & LIBNDR_STRING_FLAGS);
 549         }
 550
 551         ndr->flags = saved_flags;
 552         return NDR_ERR_SUCCESS;
 553 }
 554
 555 _PUBLIC_ void ndr_print_string_array(struct ndr_print *ndr, const char *name, const char **a)
 556 {
 557         uint32_t count;
 558         uint32_t i;
 559
 560         for (count = 0; a && a[count]; count++) {}
 561
 562         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 563         ndr->depth++;
 564         for (i=0;i<count;i++) {
 565                 char *idx=NULL;
 566                 if (asprintf(&idx, "[%d]", i) != -1) {
 567                         ndr_print_string(ndr, idx, a[i]);
 568                         free(idx);
 569                 }
 570         }
 571         ndr->depth--;
 572 }
 573
 574 _PUBLIC_ size_t ndr_size_string_array(const char **a, uint32_t count, int flags)
 575 {
 576         uint32_t i;
 577         size_t size = 0;
 578         int rawbytes = 0;
 579
 580         if (flags & LIBNDR_FLAG_STR_RAW8) {
 581                 rawbytes = 1;
 582                 flags &= ~LIBNDR_FLAG_STR_RAW8;
 583         }
 584
 585         switch (flags & LIBNDR_STRING_FLAGS) {
 586         case LIBNDR_FLAG_STR_NULLTERM:
 587                 for (i = 0; i < count; i++) {
 588                         size += rawbytes?strlen(a[i]) + 1:strlen_m_term(a[i]);
 589                 }
 590                 break;
 591         case LIBNDR_FLAG_STR_NOTERM:
 592                 for (i = 0; i < count; i++) {
 593                         size += rawbytes?strlen(a[i]):strlen_m(a[i]);
 594                 }
 595                 break;
 596         default:
 597                 return 0;
 598         }
 599
 600         return size;
 601 }
 602
 603 /**
 604  * Return number of elements in a string including the last (zeroed) element
 605  */
 606 _PUBLIC_ uint32_t ndr_string_length(const void *_var, uint32_t element_size)
 607 {
 608         uint32_t i;
 609         uint8_t zero[4] = {0,0,0,0};
 610         const char *var = (const char *)_var;
 611
 612         for (i = 0; memcmp(var+i*element_size,zero,element_size) != 0; i++);
 613
 614         return i+1;
 615 }
 616
 617 /**
 618  * @brief Get the string length including the null terminator if available.
 619  *
 620  * This checks the string length based on the elements. The returned number
 621  * includes the terminating null byte(s) if found.
 622  *
 623  * @param[in]  _var    The string the calculate the length for.
 624  *
 625  * @param[in]  length  The length of the buffer passed by _var.
 626  *
 627  * @param[in]  element_size The element_size of a string char in bytes.
 628  *
 629  * @return The length of the strings or 0.
 630  */
 631 static uint32_t ndr_string_n_length(const void *_var,
 632                                     size_t length,
 633                                     uint32_t element_size)
 634 {
 635         size_t i = 0;
 636         uint8_t zero[4] = {0,0,0,0};
 637         const char *var = (const char *)_var;
 638         int cmp;
 639
 640         if (element_size > 4) {
 641                 return 0;
 642         }
 643
 644         for (i = 0; i < length; i++, var += element_size) {
 645                 cmp = memcmp(var, zero, element_size);
 646                 if (cmp == 0) {
 647                         break;
 648                 }
 649         }
 650
 651         if (i == length) {
 652                 return length;
 653         }
 654
 655         return i + 1;
 656 }
 657
 658 _PUBLIC_ enum ndr_err_code ndr_check_string_terminator(struct ndr_pull *ndr, uint32_t count, uint32_t element_size)
 659 {
 660         uint32_t i;
 661         uint32_t save_offset;
 662
 663         save_offset = ndr->offset;
 664         NDR_CHECK(ndr_pull_advance(ndr, (count - 1) * element_size));
 665         NDR_PULL_NEED_BYTES(ndr, element_size);
 666
 667         for (i = 0; i < element_size; i++) {
 668                  if (ndr->data[ndr->offset+i] != 0) {
 669                         ndr->offset = save_offset;
 670
 671                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "String terminator not present or outside string boundaries");
 672                  }
 673         }
 674
 675         ndr->offset = save_offset;
 676
 677         return NDR_ERR_SUCCESS;
 678 }
 679
 680 _PUBLIC_ enum ndr_err_code ndr_pull_charset(struct ndr_pull *ndr, int ndr_flags, const char **var, uint32_t length, uint8_t byte_mul, charset_t chset)
 681 {
 682         size_t converted_size;
 683
 684         if (length == 0) {
 685                 *var = talloc_strdup(ndr->current_mem_ctx, "");
 686                 return NDR_ERR_SUCCESS;
 687         }
 688
 689         if (NDR_BE(ndr) && chset == CH_UTF16) {
 690                 chset = CH_UTF16BE;
 691         }
 692
 693         if ((byte_mul != 0) && (length > UINT32_MAX/byte_mul)) {
 694                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE, "length overflow");
 695         }
 696         NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
 697
 698         if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
 699                                    ndr->data+ndr->offset, length*byte_mul,
 700                                    discard_const_p(void *, var),
 701                                    &converted_size))
 702         {
 703                 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 704                                       "Bad character conversion");
 705         }
 706         NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
 707
 708         return NDR_ERR_SUCCESS;
 709 }
 710
 711 _PUBLIC_ enum ndr_err_code ndr_pull_charset_to_null(struct ndr_pull *ndr, int ndr_flags, const char **var, uint32_t length, uint8_t byte_mul, charset_t chset)
 712 {
 713         size_t converted_size;
 714         uint32_t str_len;
 715
 716         if (length == 0) {
 717                 *var = talloc_strdup(ndr->current_mem_ctx, "");
 718                 return NDR_ERR_SUCCESS;
 719         }
 720
 721         if (NDR_BE(ndr) && chset == CH_UTF16) {
 722                 chset = CH_UTF16BE;
 723         }
 724
 725         NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
 726
 727         str_len = ndr_string_n_length(ndr->data+ndr->offset, length, byte_mul);
 728         if (str_len == 0) {
 729                 return ndr_pull_error(ndr, NDR_ERR_LENGTH,
 730                                       "Invalid length");
 731         }
 732
 733         if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
 734                                    ndr->data+ndr->offset, str_len*byte_mul,
 735                                    discard_const_p(void *, var),
 736                                    &converted_size))
 737         {
 738                 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 739                                       "Bad character conversion");
 740         }
 741         NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
 742
 743         return NDR_ERR_SUCCESS;
 744 }
 745
 746 _PUBLIC_ enum ndr_err_code ndr_push_charset(struct ndr_push *ndr, int ndr_flags, const char *var, uint32_t length, uint8_t byte_mul, charset_t chset)
 747 {
 748         size_t required;
 749
 750         if (NDR_BE(ndr) && chset == CH_UTF16) {
 751                 chset = CH_UTF16BE;
 752         }
 753
 754         if ((byte_mul != 0) && (length > SIZE_MAX/byte_mul)) {
 755                 return ndr_push_error(ndr, NDR_ERR_LENGTH, "length overflow");
 756         }
 757         required = byte_mul * length;
 758
 759         NDR_PUSH_NEED_BYTES(ndr, required);
 760
 761         if (required) {
 762                 size_t size = 0;
 763
 764                 if (var == NULL) {
 765                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 766                 }
 767
 768                 if (!convert_string(CH_UNIX, chset,
 769                              var, strlen(var),
 770                              ndr->data+ndr->offset, required, &size)) {
 771                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 772                                       "Bad character conversion");
 773                 }
 774
 775                 /* Make sure the remaining part of the string is filled with zeroes */
 776                 if (size < required) {
 777                         memset(ndr->data+ndr->offset+size, 0, required-size);
 778                 }
 779         }
 780
 781         ndr->offset += required;
 782
 783         return NDR_ERR_SUCCESS;
 784 }
 785
 786 _PUBLIC_ enum ndr_err_code ndr_push_charset_to_null(struct ndr_push *ndr, int ndr_flags, const char *var, uint32_t length, uint8_t byte_mul, charset_t chset)
 787 {
 788         const char *str = var;
 789
 790         if (str == NULL) {
 791                 str = "\0"; /* i.e. two zero bytes, for UTF16 null word. */
 792                 length = 1;
 793         }
 794
 795         return ndr_push_charset(ndr, ndr_flags, str, length, byte_mul, chset);
 796 }
 797
 798 /* Return number of elements in a string in the specified charset */
 799 _PUBLIC_ uint32_t ndr_charset_length(const void *var, charset_t chset)
 800 {
 801         switch (chset) {
 802         /* case CH_UTF16: this has the same value as CH_UTF16LE */
 803         case CH_UTF16LE:
 804         case CH_UTF16BE:
 805         case CH_UTF16MUNGED:
 806         case CH_UTF8:
 807                 return strlen_m_ext_term((const char *)var, CH_UNIX, chset);
 808         case CH_DOS:
 809         case CH_UNIX:
 810                 return strlen((const char *)var)+1;
 811         }
 812
 813         /* Fallback, this should never happen */
 814         return strlen((const char *)var)+1;
 815 }