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 (!do_convert) {
 240                 d_len = s_len;
 241                 dest = (uint8_t *)talloc_strndup(ndr, s, s_len);
 242         } else if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
 243                                    (void **)(void *)&dest, &d_len))
 244         {
 245                 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 246                                       "Bad character push conversion with flags 0x%x", flags);
 247         }
 248
 249         if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
 250                 c_len = d_len;
 251                 flags &= ~LIBNDR_FLAG_STR_BYTESIZE;
 252         } else if (flags & LIBNDR_FLAG_STR_CHARLEN) {
 253                 c_len = (d_len / byte_mul)-1;
 254                 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
 255         } else {
 256                 c_len = d_len / byte_mul;
 257         }
 258
 259         switch ((flags & LIBNDR_STRING_FLAGS) & ~LIBNDR_FLAG_STR_NOTERM) {
 260         case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
 261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 264                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 265                 break;
 266
 267         case LIBNDR_FLAG_STR_LEN4:
 268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 270                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 271                 break;
 272
 273         case LIBNDR_FLAG_STR_SIZE4:
 274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
 275                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 276                 break;
 277
 278         case LIBNDR_FLAG_STR_SIZE2:
 279                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, c_len));
 280                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 281                 break;
 282
 283         case LIBNDR_FLAG_STR_NULLTERM:
 284                 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 285                 break;
 286
 287         default:
 288                 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
 289                         NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
 290                         break;
 291                 }
 292
 293                 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 294                                       ndr->flags & LIBNDR_STRING_FLAGS);
 295         }
 296
 297         talloc_free(dest);
 298
 299         return NDR_ERR_SUCCESS;
 300 }
 301
 302 /**
 303   push a general string onto the wire
 304 */
 305 _PUBLIC_ size_t ndr_string_array_size(struct ndr_push *ndr, const char *s)
 306 {
 307         size_t c_len;
 308         unsigned flags = ndr->flags;
 309         unsigned byte_mul = 2;
 310         unsigned c_len_term = 1;
 311
 312         if (flags & LIBNDR_FLAG_STR_RAW8) {
 313                 c_len = s?strlen(s):0;
 314         } else {
 315                 c_len = s?strlen_m(s):0;
 316         }
 317
 318         if (flags & (LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_RAW8|LIBNDR_FLAG_STR_UTF8)) {
 319                 byte_mul = 1;
 320         }
 321
 322         if (flags & LIBNDR_FLAG_STR_NOTERM) {
 323                 c_len_term = 0;
 324         }
 325
 326         c_len = c_len + c_len_term;
 327
 328         if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
 329                 c_len = c_len * byte_mul;
 330         }
 331
 332         return c_len;
 333 }
 334
 335 _PUBLIC_ void ndr_print_string(struct ndr_print *ndr, const char *name, const char *s)
 336 {
 337         if (s) {
 338                 ndr->print(ndr, "%-25s: '%s'", name, s);
 339         } else {
 340                 ndr->print(ndr, "%-25s: NULL", name);
 341         }
 342 }
 343
 344 _PUBLIC_ uint32_t ndr_size_string(int ret, const char * const* string, int flags)
 345 {
 346         /* FIXME: Is this correct for all strings ? */
 347         if(!(*string)) return ret;
 348         return ret+strlen(*string)+1;
 349 }
 350
 351 static uint32_t guess_string_array_size(struct ndr_pull *ndr, int ndr_flags)
 352 {
 353         /*
 354          * Here we could do something clever like count the number of zeros in
 355          * the ndr data, but it is probably sufficient to pick a lowish number
 356          * (compared to the overhead of the talloc header) and let the
 357          * expontential resizing deal with longer arrays.
 358          */
 359         return 5;
 360 }
 361
 362 static enum ndr_err_code extend_string_array(struct ndr_pull *ndr,
 363                                              const char ***_a,
 364                                              uint32_t *count)
 365 {
 366         const char **a = *_a;
 367         uint32_t inc = *count / 4 + 3;
 368         uint32_t alloc_size = *count + inc;
 369
 370         if (alloc_size < *count) {
 371                 /* overflow ! */
 372                 return NDR_ERR_ALLOC;
 373         }
 374         /*
 375          * We allocate and zero two more bytes than we report back, so that
 376          * the string array will always be NULL terminated.
 377          */
 378         a = talloc_realloc(ndr->current_mem_ctx, a,
 379                            const char *,
 380                            alloc_size);
 381         NDR_ERR_HAVE_NO_MEMORY(a);
 382
 383         memset(a + *count, 0, inc * sizeof(a[0]));
 384         *_a = a;
 385         *count = alloc_size - 2;
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 /**
 390   pull a general string array from the wire
 391 */
 392 _PUBLIC_ enum ndr_err_code ndr_pull_string_array(struct ndr_pull *ndr, int ndr_flags, const char ***_a)
 393 {
 394         const char **a = NULL;
 395         uint32_t count;
 396         unsigned flags = ndr->flags;
 397         unsigned saved_flags = ndr->flags;
 398         uint32_t alloc_size;
 399
 400         if (!(ndr_flags & NDR_SCALARS)) {
 401                 return NDR_ERR_SUCCESS;
 402         }
 403
 404         alloc_size = guess_string_array_size(ndr, ndr_flags);
 405         a = talloc_zero_array(ndr->current_mem_ctx, const char *, alloc_size + 2);
 406         NDR_ERR_HAVE_NO_MEMORY(a);
 407
 408         switch (flags & (LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_STR_NOTERM)) {
 409         case LIBNDR_FLAG_STR_NULLTERM:
 410                 /*
 411                  * here the strings are null terminated
 412                  * but also the array is null terminated if LIBNDR_FLAG_REMAINING
 413                  * is specified
 414                  */
 415                 for (count = 0;; count++) {
 416                         TALLOC_CTX *tmp_ctx;
 417                         const char *s = NULL;
 418                         if (count == alloc_size) {
 419                                 NDR_CHECK(extend_string_array(ndr,
 420                                                               &a,
 421                                                               &alloc_size));
 422                         }
 423
 424                         tmp_ctx = ndr->current_mem_ctx;
 425                         ndr->current_mem_ctx = a;
 426                         NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
 427                         ndr->current_mem_ctx = tmp_ctx;
 428                         if ((ndr->data_size - ndr->offset) == 0 && ndr->flags & LIBNDR_FLAG_REMAINING)
 429                         {
 430                                 a[count] = s;
 431                                 break;
 432                         }
 433                         if (strcmp("", s)==0) {
 434                                 a[count] = NULL;
 435                                 break;
 436                         } else {
 437                                 a[count] = s;
 438                         }
 439                 }
 440
 441                 *_a =a;
 442                 break;
 443
 444         case LIBNDR_FLAG_STR_NOTERM:
 445                 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
 446                         return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
 447                                               ndr->flags & LIBNDR_STRING_FLAGS);
 448                 }
 449                 /*
 450                  * here the strings are not null terminated
 451                  * but separated by a null terminator
 452                  *
 453                  * which means the same as:
 454                  * Every string is null terminated exept the last
 455                  * string is terminated by the end of the buffer
 456                  *
 457                  * as LIBNDR_FLAG_STR_NULLTERM also end at the end
 458                  * of the buffer, we can pull each string with this flag
 459                  *
 460                  * The big difference with the case LIBNDR_FLAG_STR_NOTERM +
 461                  * LIBNDR_FLAG_REMAINING is that the last string will not be null terminated
 462                  */
 463                 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 464                 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
 465
 466                 for (count = 0; ((ndr->data_size - ndr->offset) > 0); count++) {
 467                         TALLOC_CTX *tmp_ctx;
 468                         const char *s = NULL;
 469                         if (count == alloc_size) {
 470                                 NDR_CHECK(extend_string_array(ndr,
 471                                                               &a,
 472                                                               &alloc_size));
 473                         }
 474
 475                         tmp_ctx = ndr->current_mem_ctx;
 476                         ndr->current_mem_ctx = a;
 477                         NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
 478                         ndr->current_mem_ctx = tmp_ctx;
 479                         a[count] = s;
 480                 }
 481
 482                 a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 1);
 483                 NDR_ERR_HAVE_NO_MEMORY(a);
 484                 *_a = a;
 485                 break;
 486
 487         default:
 488                 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 489                                       ndr->flags & LIBNDR_STRING_FLAGS);
 490         }
 491
 492         ndr->flags = saved_flags;
 493         return NDR_ERR_SUCCESS;
 494 }
 495
 496 /**
 497   push a general string array onto the wire
 498 */
 499 _PUBLIC_ enum ndr_err_code ndr_push_string_array(struct ndr_push *ndr, int ndr_flags, const char **a)
 500 {
 501         uint32_t count;
 502         unsigned flags = ndr->flags;
 503         unsigned saved_flags = ndr->flags;
 504
 505         if (!(ndr_flags & NDR_SCALARS)) {
 506                 return NDR_ERR_SUCCESS;
 507         }
 508
 509         switch (flags & LIBNDR_STRING_FLAGS) {
 510         case LIBNDR_FLAG_STR_NULLTERM:
 511                 for (count = 0; a && a[count]; count++) {
 512                         NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
 513                 }
 514                 /* If LIBNDR_FLAG_REMAINING then we do not add a null terminator to the array */
 515                 if (!(flags & LIBNDR_FLAG_REMAINING))
 516                 {
 517                         NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
 518                 }
 519                 break;
 520
 521         case LIBNDR_FLAG_STR_NOTERM:
 522                 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
 523                         return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
 524                                               ndr->flags & LIBNDR_STRING_FLAGS);
 525                 }
 526
 527                 for (count = 0; a && a[count]; count++) {
 528                         if (count > 0) {
 529                                 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
 530                                 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
 531                                 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
 532                                 ndr->flags = saved_flags;
 533                         }
 534                         NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
 535                 }
 536
 537                 break;
 538
 539         default:
 540                 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
 541                                       ndr->flags & LIBNDR_STRING_FLAGS);
 542         }
 543
 544         ndr->flags = saved_flags;
 545         return NDR_ERR_SUCCESS;
 546 }
 547
 548 _PUBLIC_ void ndr_print_string_array(struct ndr_print *ndr, const char *name, const char **a)
 549 {
 550         uint32_t count;
 551         uint32_t i;
 552
 553         for (count = 0; a && a[count]; count++) {}
 554
 555         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 556         ndr->depth++;
 557         for (i=0;i<count;i++) {
 558                 char *idx=NULL;
 559                 if (asprintf(&idx, "[%d]", i) != -1) {
 560                         ndr_print_string(ndr, idx, a[i]);
 561                         free(idx);
 562                 }
 563         }
 564         ndr->depth--;
 565 }
 566
 567 _PUBLIC_ size_t ndr_size_string_array(const char **a, uint32_t count, int flags)
 568 {
 569         uint32_t i;
 570         size_t size = 0;
 571         int rawbytes = 0;
 572
 573         if (flags & LIBNDR_FLAG_STR_RAW8) {
 574                 rawbytes = 1;
 575                 flags &= ~LIBNDR_FLAG_STR_RAW8;
 576         }
 577
 578         switch (flags & LIBNDR_STRING_FLAGS) {
 579         case LIBNDR_FLAG_STR_NULLTERM:
 580                 for (i = 0; i < count; i++) {
 581                         size += rawbytes?strlen(a[i]) + 1:strlen_m_term(a[i]);
 582                 }
 583                 break;
 584         case LIBNDR_FLAG_STR_NOTERM:
 585                 for (i = 0; i < count; i++) {
 586                         size += rawbytes?strlen(a[i]):strlen_m(a[i]);
 587                 }
 588                 break;
 589         default:
 590                 return 0;
 591         }
 592
 593         return size;
 594 }
 595
 596 /**
 597  * Return number of elements in a string including the last (zeroed) element
 598  */
 599 _PUBLIC_ uint32_t ndr_string_length(const void *_var, uint32_t element_size)
 600 {
 601         uint32_t i;
 602         uint8_t zero[4] = {0,0,0,0};
 603         const char *var = (const char *)_var;
 604
 605         for (i = 0; memcmp(var+i*element_size,zero,element_size) != 0; i++);
 606
 607         return i+1;
 608 }
 609
 610 /**
 611  * @brief Get the string length including the null terminator if available.
 612  *
 613  * This checks the string length based on the elements. The returned number
 614  * includes the terminating null byte(s) if found.
 615  *
 616  * @param[in]  _var    The string the calculate the length for.
 617  *
 618  * @param[in]  length  The length of the buffer passed by _var.
 619  *
 620  * @param[in]  element_size The element_size of a string char in bytes.
 621  *
 622  * @return The length of the strings or 0.
 623  */
 624 static uint32_t ndr_string_n_length(const void *_var,
 625                                     size_t length,
 626                                     uint32_t element_size)
 627 {
 628         size_t i = 0;
 629         uint8_t zero[4] = {0,0,0,0};
 630         const char *var = (const char *)_var;
 631         int cmp;
 632
 633         if (element_size > 4) {
 634                 return 0;
 635         }
 636
 637         for (i = 0; i < length; i++, var += element_size) {
 638                 cmp = memcmp(var, zero, element_size);
 639                 if (cmp == 0) {
 640                         break;
 641                 }
 642         }
 643
 644         if (i == length) {
 645                 return length;
 646         }
 647
 648         return i + 1;
 649 }
 650
 651 _PUBLIC_ enum ndr_err_code ndr_check_string_terminator(struct ndr_pull *ndr, uint32_t count, uint32_t element_size)
 652 {
 653         uint32_t i;
 654         uint32_t save_offset;
 655
 656         save_offset = ndr->offset;
 657         NDR_CHECK(ndr_pull_advance(ndr, (count - 1) * element_size));
 658         NDR_PULL_NEED_BYTES(ndr, element_size);
 659
 660         for (i = 0; i < element_size; i++) {
 661                  if (ndr->data[ndr->offset+i] != 0) {
 662                         ndr->offset = save_offset;
 663
 664                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "String terminator not present or outside string boundaries");
 665                  }
 666         }
 667
 668         ndr->offset = save_offset;
 669
 670         return NDR_ERR_SUCCESS;
 671 }
 672
 673 _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)
 674 {
 675         size_t converted_size;
 676
 677         if (length == 0) {
 678                 *var = talloc_strdup(ndr->current_mem_ctx, "");
 679                 return NDR_ERR_SUCCESS;
 680         }
 681
 682         if (NDR_BE(ndr) && chset == CH_UTF16) {
 683                 chset = CH_UTF16BE;
 684         }
 685
 686         if ((byte_mul != 0) && (length > UINT32_MAX/byte_mul)) {
 687                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE, "length overflow");
 688         }
 689         NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
 690
 691         if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
 692                                    ndr->data+ndr->offset, length*byte_mul,
 693                                    discard_const_p(void *, var),
 694                                    &converted_size))
 695         {
 696                 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 697                                       "Bad character conversion");
 698         }
 699         NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
 700
 701         return NDR_ERR_SUCCESS;
 702 }
 703
 704 _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)
 705 {
 706         size_t converted_size;
 707         uint32_t str_len;
 708
 709         if (length == 0) {
 710                 *var = talloc_strdup(ndr->current_mem_ctx, "");
 711                 return NDR_ERR_SUCCESS;
 712         }
 713
 714         if (NDR_BE(ndr) && chset == CH_UTF16) {
 715                 chset = CH_UTF16BE;
 716         }
 717
 718         NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
 719
 720         str_len = ndr_string_n_length(ndr->data+ndr->offset, length, byte_mul);
 721         if (str_len == 0) {
 722                 return ndr_pull_error(ndr, NDR_ERR_LENGTH,
 723                                       "Invalid length");
 724         }
 725
 726         if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
 727                                    ndr->data+ndr->offset, str_len*byte_mul,
 728                                    discard_const_p(void *, var),
 729                                    &converted_size))
 730         {
 731                 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
 732                                       "Bad character conversion");
 733         }
 734         NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
 735
 736         return NDR_ERR_SUCCESS;
 737 }
 738
 739 _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)
 740 {
 741         size_t required;
 742
 743         if (NDR_BE(ndr) && chset == CH_UTF16) {
 744                 chset = CH_UTF16BE;
 745         }
 746
 747         if ((byte_mul != 0) && (length > SIZE_MAX/byte_mul)) {
 748                 return ndr_push_error(ndr, NDR_ERR_LENGTH, "length overflow");
 749         }
 750         required = byte_mul * length;
 751
 752         NDR_PUSH_NEED_BYTES(ndr, required);
 753
 754         if (required) {
 755                 size_t size = 0;
 756
 757                 if (var == NULL) {
 758                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 759                 }
 760
 761                 if (!convert_string(CH_UNIX, chset,
 762                              var, strlen(var),
 763                              ndr->data+ndr->offset, required, &size)) {
 764                         return ndr_push_error(ndr, NDR_ERR_CHARCNV,
 765                                       "Bad character conversion");
 766                 }
 767
 768                 /* Make sure the remaining part of the string is filled with zeroes */
 769                 if (size < required) {
 770                         memset(ndr->data+ndr->offset+size, 0, required-size);
 771                 }
 772         }
 773
 774         ndr->offset += required;
 775
 776         return NDR_ERR_SUCCESS;
 777 }
 778
 779 _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)
 780 {
 781         const char *str = var;
 782
 783         if (str == NULL) {
 784                 str = "\0"; /* i.e. two zero bytes, for UTF16 null word. */
 785                 length = 1;
 786         }
 787
 788         return ndr_push_charset(ndr, ndr_flags, str, length, byte_mul, chset);
 789 }
 790
 791 /* Return number of elements in a string in the specified charset */
 792 _PUBLIC_ uint32_t ndr_charset_length(const void *var, charset_t chset)
 793 {
 794         switch (chset) {
 795         /* case CH_UTF16: this has the same value as CH_UTF16LE */
 796         case CH_UTF16LE:
 797         case CH_UTF16BE:
 798         case CH_UTF16MUNGED:
 799         case CH_UTF8:
 800                 return strlen_m_ext_term((const char *)var, CH_UNIX, chset);
 801         case CH_DOS:
 802         case CH_UNIX:
 803                 return strlen((const char *)var)+1;
 804         }
 805
 806         /* Fallback, this should never happen */
 807         return strlen((const char *)var)+1;
 808 }