Print this page
1575 untangle libmlrpc ... (libmlrpc)

Split Close
Expand all
Collapse all
          --- old/usr/src/lib/libmlrpc/common/ndr_heap.c
          +++ new/usr/src/lib/libmlrpc/common/ndr_heap.c
↓ open down ↓ 13 lines elided ↑ open up ↑
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  /*
  22   22   * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23   23   * Use is subject to license terms.
       24 + *
       25 + * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
  24   26   */
  25   27  
  26   28  /*
  27   29   * NDR heap management. The heap is used for temporary storage by
  28   30   * both the client and server side library routines.  In order to
  29   31   * support the different requirements of the various RPCs, the heap
  30   32   * can grow dynamically if required.  We start with a single block
  31   33   * and perform sub-allocations from it.  If an RPC requires more space
  32   34   * we will continue to add it a block at a time.  This means that we
  33   35   * don't hog lots of memory on every call to support the few times
↓ open down ↓ 5 lines elided ↑ open up ↑
  39   41   * be marshalled or unmarshalled and we need it all to be there until
  40   42   * the point that the entire heap is no longer required.
  41   43   */
  42   44  
  43   45  #include <sys/errno.h>
  44   46  #include <stdlib.h>
  45   47  #include <string.h>
  46   48  #include <strings.h>
  47   49  #include <sys/uio.h>
  48   50  
  49      -#include <smbsrv/libsmb.h>
  50      -#include <smbsrv/libmlrpc.h>
  51      -#include <smbsrv/smb_sid.h>
       51 +#include <libmlrpc.h>
       52 +#include <ndr_wchar.h>
  52   53  
  53   54  /*
  54   55   * Allocate a heap structure and the first heap block.  For many RPC
  55   56   * operations this will be the only time we need to malloc memory
  56   57   * in this instance of the heap.  The only point of note here is that
  57   58   * we put the heap management data in the first block to avoid a
  58   59   * second malloc. Make sure that sizeof(ndr_heap_t) is smaller
  59   60   * than NDR_HEAP_BLKSZ.
  60   61   *
  61   62   * Note that the heap management data is at the start of the first block.
↓ open down ↓ 85 lines elided ↑ open up ↑
 147  148                  heap->iov->iov_len = 0;
 148  149                  heap->top = p + incr_size;
 149  150          }
 150  151  
 151  152          heap->next = p + size;
 152  153          heap->iov->iov_len += size;
 153  154          return ((void *)p);
 154  155  }
 155  156  
 156  157  /*
      158 + * Convenience function to copy some memory into the heap.
      159 + */
      160 +void *
      161 +ndr_heap_dupmem(ndr_heap_t *heap, const void *mem, size_t len)
      162 +{
      163 +        void *p;
      164 +
      165 +        if (mem == NULL)
      166 +                return (NULL);
      167 +
      168 +        if ((p = ndr_heap_malloc(heap, len)) != NULL)
      169 +                (void) memcpy(p, mem, len);
      170 +
      171 +        return (p);
      172 +}
      173 +
      174 +/*
 157  175   * Convenience function to do heap strdup.
 158  176   */
 159  177  void *
 160  178  ndr_heap_strdup(ndr_heap_t *heap, const char *s)
 161  179  {
 162  180          int len;
 163  181          void *p;
 164  182  
 165  183          if (s == NULL)
 166  184                  return (NULL);
 167  185  
 168  186          /*
 169  187           * We don't need to clutter the heap with empty strings.
 170  188           */
 171  189          if ((len = strlen(s)) == 0)
 172  190                  return ("");
 173  191  
 174      -        if ((p = ndr_heap_malloc(heap, len+1)) != NULL)
 175      -                (void) strcpy((char *)p, s);
      192 +        p = ndr_heap_dupmem(heap, s, len+1);
 176  193  
 177  194          return (p);
 178  195  }
 179  196  
 180  197  /*
 181  198   * Make an ndr_mstring_t from a regular string.
 182  199   */
 183  200  int
 184  201  ndr_heap_mstring(ndr_heap_t *heap, const char *s, ndr_mstring_t *out)
 185  202  {
      203 +        size_t slen;
      204 +
 186  205          if (s == NULL || out == NULL)
 187  206                  return (-1);
 188  207  
 189      -        out->length = smb_wcequiv_strlen(s);
 190      -        out->allosize = out->length + sizeof (smb_wchar_t);
      208 +        /*
      209 +         * Determine the WC strlen of s
      210 +         * Was ndr__wcequiv_strlen(s)
      211 +         */
      212 +        slen = ndr__mbstowcs(NULL, s, NDR_STRING_MAX);
      213 +        if (slen == (size_t)-1)
      214 +                return (-1);
 191  215  
      216 +        out->length = slen * sizeof (ndr_wchar_t);
      217 +        out->allosize = out->length + sizeof (ndr_wchar_t);
      218 +
 192  219          if ((out->str = ndr_heap_strdup(heap, s)) == NULL)
 193  220                  return (-1);
 194  221  
 195  222          return (0);
 196  223  }
 197  224  
 198  225  /*
 199  226   * Our regular string marshalling always creates null terminated strings
 200  227   * but some Windows clients and servers are pedantic about the string
 201  228   * formats they will accept and require non-null terminated strings.
 202  229   * This function can be used to build a wide-char, non-null terminated
 203  230   * string in the heap as a varying/conformant array.  We need to do the
 204  231   * wide-char conversion here because the marshalling code won't be
 205  232   * aware that this is really a string.
 206  233   */
 207  234  void
 208  235  ndr_heap_mkvcs(ndr_heap_t *heap, char *s, ndr_vcstr_t *vc)
 209  236  {
      237 +        size_t slen;
 210  238          int mlen;
 211  239  
 212      -        vc->wclen = smb_wcequiv_strlen(s);
      240 +        /*
      241 +         * Determine the WC strlen of s
      242 +         * Was ndr__wcequiv_strlen(s)
      243 +         */
      244 +        slen = ndr__mbstowcs(NULL, s, NDR_STRING_MAX);
      245 +        if (slen == (size_t)-1)
      246 +                slen = 0;
      247 +
      248 +        vc->wclen = slen * sizeof (ndr_wchar_t);
 213  249          vc->wcsize = vc->wclen;
 214  250  
 215      -        mlen = sizeof (ndr_vcs_t) + vc->wcsize + sizeof (smb_wchar_t);
 216      -
      251 +        /*
      252 +         * alloc one extra wchar for a null
      253 +         * See slen + 1 arg for mbstowcs
      254 +         */
      255 +        mlen = sizeof (ndr_vcs_t) + vc->wcsize + sizeof (ndr_wchar_t);
 217  256          vc->vcs = ndr_heap_malloc(heap, mlen);
 218  257  
 219  258          if (vc->vcs) {
 220  259                  vc->vcs->vc_first_is = 0;
 221      -                vc->vcs->vc_length_is = vc->wclen / sizeof (smb_wchar_t);
 222      -                (void) smb_mbstowcs((smb_wchar_t *)vc->vcs->buffer, s,
 223      -                    vc->vcs->vc_length_is);
      260 +                vc->vcs->vc_length_is = slen;
      261 +                (void) ndr__mbstowcs(vc->vcs->buffer, s, slen + 1);
 224  262          }
 225  263  }
 226  264  
 227  265  void
 228  266  ndr_heap_mkvcb(ndr_heap_t *heap, uint8_t *data, uint32_t datalen,
 229  267      ndr_vcbuf_t *vcbuf)
 230  268  {
 231  269          int mlen;
 232  270  
 233  271          if (data == NULL || datalen == 0) {
↓ open down ↓ 9 lines elided ↑ open up ↑
 243  281          vcbuf->vcb = ndr_heap_malloc(heap, mlen);
 244  282  
 245  283          if (vcbuf->vcb) {
 246  284                  vcbuf->vcb->vc_first_is = 0;
 247  285                  vcbuf->vcb->vc_length_is = datalen;
 248  286                  bcopy(data, vcbuf->vcb->buffer, datalen);
 249  287          }
 250  288  }
 251  289  
 252  290  /*
 253      - * Duplcate a SID in the heap.
      291 + * Removed ndr_heap_siddup(), now using ndr_heap_dupmem().
 254  292   */
 255      -smb_sid_t *
 256      -ndr_heap_siddup(ndr_heap_t *heap, smb_sid_t *sid)
 257      -{
 258      -        smb_sid_t *new_sid;
 259      -        unsigned size;
 260  293  
 261      -        if (sid == NULL)
 262      -                return (NULL);
 263      -
 264      -        size = smb_sid_len(sid);
 265      -
 266      -        if ((new_sid = ndr_heap_malloc(heap, size)) == NULL)
 267      -                return (NULL);
 268      -
 269      -        bcopy(sid, new_sid, size);
 270      -        return (new_sid);
 271      -}
 272      -
 273  294  int
 274  295  ndr_heap_used(ndr_heap_t *heap)
 275  296  {
 276  297          int used = 0;
 277  298          int i;
 278  299  
 279  300          for (i = 0; i < NDR_HEAP_MAXIOV; ++i)
 280  301                  used += heap->iovec[i].iov_len;
 281  302  
 282  303          return (used);
↓ open down ↓ 15 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX