usr/src/lib/libmlrpc/common/libmlrpc.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  23  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
  24  */
  25
  26 #ifndef _LIBMLRPC_H
  27 #define _LIBMLRPC_H
  28
  29 #include <sys/types.h>
  30 #include <sys/uio.h>
  31
  32 #include <smb/wintypes.h>
  33 #include <libmlrpc/ndr.h>
  34
  35 #ifdef  __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 /*
  40  * An MSRPC compatible implementation of OSF DCE RPC.  DCE RPC is derived
  41  * from the Apollo Network Computing Architecture (NCA) RPC implementation.
  42  *
  43  * CAE Specification (1997)
  44  * DCE 1.1: Remote Procedure Call
  45  * Document Number: C706
  46  * The Open Group
  47  * ogspecs@opengroup.org
  48  *
  49  * This implementation is based on the DCE Remote Procedure Call spec with
  50  * enhancements to support Unicode strings.  The diagram below shows the
  51  * DCE RPC layers compared against ONC SUN RPC.
  52  *
  53  *      NDR RPC Layers          Sun RPC Layers          Remark
  54  *      +---------------+       +---------------+       +---------------+
  55  *      +---------------+       +---------------+
  56  *      | Application   |       | Application   |       The application
  57  *      +---------------+       +---------------+
  58  *      | Hand coded    |       | RPCGEN gen'd  |       Where the real
  59  *      | client/server |       | client/server |       work happens
  60  *      | srvsvc.ndl    |       | *_svc.c *_clnt|
  61  *      | srvsvc.c      |       |               |
  62  *      +---------------+       +---------------+
  63  *      | RPC Library   |       | RPC Library   |       Calls/Return
  64  *      | ndr_*.c       |       |               |       Binding/PMAP
  65  *      +---------------+       +---------------+
  66  *      | RPC Protocol  |       | RPC Protocol  |       Headers, Auth,
  67  *      | rpcpdu.ndl    |       |               |
  68  *      +---------------+       +---------------+
  69  *      | IDL gen'd     |       | RPCGEN gen'd  |       Aggregate
  70  *      | NDR stubs     |       | XDR stubs     |       Composition
  71  *      | *__ndr.c      |       | *_xdr.c       |
  72  *      +---------------+       +---------------+
  73  *      | NDR Represen  |       | XDR Represen  |       Byte order, padding
  74  *      +---------------+       +---------------+
  75  *      | Packet Heaps  |       | Network Conn  |       DCERPC does not talk
  76  *      | ndo_*.c       |       | clnt_{tcp,udp}|       directly to network.
  77  *      +---------------+       +---------------+
  78  *
  79  * There are two major differences between the DCE RPC and ONC RPC:
  80  *
  81  * 1. NDR RPC only generates or processes packets from buffers.  Other
  82  *    layers must take care of packet transmission and reception.
  83  *    The packet heaps are managed through a simple interface provided
  84  *    by the Network Data Representation (NDR) module called ndr_stream_t.
  85  *    ndo_*.c modules implement the different flavors (operations) of
  86  *    packet heaps.
  87  *
  88  *    ONC RPC communicates directly with the network.  You have to do
  89  *    something special for the RPC packet to be placed in a buffer
  90  *    rather than sent to the wire.
  91  *
  92  * 2. NDR RPC uses application provided heaps to support operations.
  93  *    A heap is a single, monolithic chunk of memory that NDR RPC manages
  94  *    as it allocates.  When the operation and its result are done, the
  95  *    heap is disposed of as a single item.  The transaction, which
  96  *    is the anchor of most operations, contains the necessary book-
  97  *    keeping for the heap.
  98  *
  99  *    ONC RPC uses malloc() liberally throughout its run-time system.
 100  *    To free results, ONC RPC supports an XDR_FREE operation that
 101  *    traverses data structures freeing memory as it goes, whether
 102  *    it was malloc'd or not.
 103  */
 104
 105 /*
 106  * Dispatch Return Code (DRC)
 107  *
 108  *      0x8000  15:01   Set to indicate a fault, clear indicates status
 109  *      0x7F00  08:07   Status/Fault specific
 110  *      0x00FF  00:08   PTYPE_... of PDU, 0xFF for header
 111  */
 112 #define NDR_DRC_OK                              0x0000
 113 #define NDR_DRC_MASK_FAULT                      0x8000
 114 #define NDR_DRC_MASK_SPECIFIER                  0xFF00
 115 #define NDR_DRC_MASK_PTYPE                      0x00FF
 116
 117 /* Fake PTYPE DRC discriminators */
 118 #define NDR_DRC_PTYPE_RPCHDR(DRC)               ((DRC) | 0x00FF)
 119 #define NDR_DRC_PTYPE_API(DRC)                  ((DRC) | 0x00AA)
 120
 121 /* DRC Recognizers */
 122 #define NDR_DRC_IS_OK(DRC)      (((DRC) & NDR_DRC_MASK_SPECIFIER) == 0)
 123 #define NDR_DRC_IS_FAULT(DRC)   (((DRC) & NDR_DRC_MASK_FAULT) != 0)
 124
 125 /*
 126  * (Un)Marshalling category specifiers
 127  */
 128 #define NDR_DRC_FAULT_MODE_MISMATCH             0x8100
 129 #define NDR_DRC_RECEIVED                        0x0200
 130 #define NDR_DRC_FAULT_RECEIVED_RUNT             0x8300
 131 #define NDR_DRC_FAULT_RECEIVED_MALFORMED        0x8400
 132 #define NDR_DRC_DECODED                         0x0500
 133 #define NDR_DRC_FAULT_DECODE_FAILED             0x8600
 134 #define NDR_DRC_ENCODED                         0x0700
 135 #define NDR_DRC_FAULT_ENCODE_FAILED             0x8800
 136 #define NDR_DRC_FAULT_ENCODE_TOO_BIG            0x8900
 137 #define NDR_DRC_SENT                            0x0A00
 138 #define NDR_DRC_FAULT_SEND_FAILED               0x8B00
 139
 140 /*
 141  * Resource category specifier
 142  */
 143 #define NDR_DRC_FAULT_RESOURCE_1                0x9100
 144 #define NDR_DRC_FAULT_RESOURCE_2                0x9200
 145
 146 /*
 147  * Parameters. Usually #define'd with useful alias
 148  */
 149 #define NDR_DRC_FAULT_PARAM_0_INVALID           0xC000
 150 #define NDR_DRC_FAULT_PARAM_0_UNIMPLEMENTED     0xD000
 151 #define NDR_DRC_FAULT_PARAM_1_INVALID           0xC100
 152 #define NDR_DRC_FAULT_PARAM_1_UNIMPLEMENTED     0xD100
 153 #define NDR_DRC_FAULT_PARAM_2_INVALID           0xC200
 154 #define NDR_DRC_FAULT_PARAM_2_UNIMPLEMENTED     0xD200
 155 #define NDR_DRC_FAULT_PARAM_3_INVALID           0xC300
 156 #define NDR_DRC_FAULT_PARAM_3_UNIMPLEMENTED     0xD300
 157
 158 #define NDR_DRC_FAULT_OUT_OF_MEMORY             0xF000
 159
 160 /* RPCHDR */
 161 #define NDR_DRC_FAULT_RPCHDR_MODE_MISMATCH      0x81FF
 162 #define NDR_DRC_FAULT_RPCHDR_RECEIVED_RUNT      0x83FF
 163 #define NDR_DRC_FAULT_RPCHDR_DECODE_FAILED      0x86FF
 164 #define NDR_DRC_FAULT_RPCHDR_PTYPE_INVALID      0xC0FF  /* PARAM_0_INVALID */
 165 #define NDR_DRC_FAULT_RPCHDR_PTYPE_UNIMPLEMENTED 0xD0FF /* PARAM_0_UNIMP */
 166
 167 /* Request */
 168 #define NDR_DRC_FAULT_REQUEST_PCONT_INVALID     0xC000  /* PARAM_0_INVALID */
 169 #define NDR_DRC_FAULT_REQUEST_OPNUM_INVALID     0xC100  /* PARAM_1_INVALID */
 170
 171 /* Bind */
 172 #define NDR_DRC_BINDING_MADE                    0x000B  /* OK */
 173 #define NDR_DRC_FAULT_BIND_PCONT_BUSY           0xC00B  /* PARAM_0_INVALID */
 174 #define NDR_DRC_FAULT_BIND_UNKNOWN_SERVICE      0xC10B  /* PARAM_1_INVALID */
 175 #define NDR_DRC_FAULT_BIND_NO_SLOTS             0x910B  /* RESOURCE_1 */
 176
 177 /* API */
 178 #define NDR_DRC_FAULT_API_SERVICE_INVALID       0xC0AA  /* PARAM_0_INVALID */
 179 #define NDR_DRC_FAULT_API_BIND_NO_SLOTS         0x91AA  /* RESOURCE_1 */
 180 #define NDR_DRC_FAULT_API_OPNUM_INVALID         0xC1AA  /* PARAM_1_INVALID */
 181
 182 struct ndr_xa;
 183 struct ndr_client;
 184
 185 typedef struct ndr_stub_table {
 186         int             (*func)(void *, struct ndr_xa *);
 187         unsigned short  opnum;
 188 } ndr_stub_table_t;
 189
 190 typedef struct ndr_service {
 191         char            *name;
 192         char            *desc;
 193         char            *endpoint;
 194         char            *sec_addr_port;
 195         char            *abstract_syntax_uuid;
 196         int             abstract_syntax_version;
 197         char            *transfer_syntax_uuid;
 198         int             transfer_syntax_version;
 199         unsigned        bind_instance_size;
 200         int             (*bind_req)();
 201         int             (*unbind_and_close)();
 202         int             (*call_stub)(struct ndr_xa *);
 203         ndr_typeinfo_t  *interface_ti;
 204         ndr_stub_table_t *stub_table;
 205 } ndr_service_t;
 206
 207 /*
 208  * The list of bindings is anchored at a connection.  Nothing in the
 209  * RPC mechanism allocates them.  Binding elements which have service==0
 210  * indicate free elements.  When a connection is instantiated, at least
 211  * one free binding entry should also be established.  Something like
 212  * this should suffice for most (all) situations:
 213  *
 214  *      struct connection {
 215  *              ....
 216  *              ndr_binding_t *binding_list_head;
 217  *              ndr_binding_t binding_pool[N_BINDING_POOL];
 218  *              ....
 219  *      };
 220  *
 221  *      init_connection(struct connection *conn) {
 222  *              ....
 223  *              ndr_svc_binding_pool_init(&conn->binding_list_head,
 224  *                  conn->binding_pool, N_BINDING_POOL);
 225  */
 226 typedef struct ndr_binding {
 227         struct ndr_binding      *next;
 228         ndr_p_context_id_t      p_cont_id;
 229         unsigned char           which_side;
 230         struct ndr_client       *clnt;
 231         ndr_service_t           *service;
 232         void                    *instance_specific;
 233 } ndr_binding_t;
 234
 235 #define NDR_BIND_SIDE_CLIENT    1
 236 #define NDR_BIND_SIDE_SERVER    2
 237
 238 #define NDR_BINDING_TO_SPECIFIC(BINDING, TYPE) \
 239         ((TYPE *) (BINDING)->instance_specific)
 240
 241 /*
 242  * The binding list space must be provided by the application library
 243  * for use by the underlying RPC library.  We need at least two binding
 244  * slots per connection.
 245  */
 246 #define NDR_N_BINDING_POOL      2
 247
 248 typedef struct ndr_pipe {
 249         void                    *np_listener;
 250         const char              *np_endpoint;
 251         struct smb_netuserinfo  *np_user;
 252         int                     (*np_send)(struct ndr_pipe *, void *, size_t);
 253         int                     (*np_recv)(struct ndr_pipe *, void *, size_t);
 254         int                     np_fid;
 255         uint16_t                np_max_xmit_frag;
 256         uint16_t                np_max_recv_frag;
 257         ndr_binding_t           *np_binding;
 258         ndr_binding_t           np_binding_pool[NDR_N_BINDING_POOL];
 259 } ndr_pipe_t;
 260
 261 /*
 262  * Number of bytes required to align SIZE on the next dword/4-byte
 263  * boundary.
 264  */
 265 #define NDR_ALIGN4(SIZE)        ((4 - (SIZE)) & 3);
 266
 267 /*
 268  * DCE RPC strings (CAE section 14.3.4) are represented as varying or varying
 269  * and conformant one-dimensional arrays. Characters can be single-byte
 270  * or multi-byte as long as all characters conform to a fixed element size,
 271  * i.e. UCS-2 is okay but UTF-8 is not a valid DCE RPC string format. The
 272  * string is terminated by a null character of the appropriate element size.
 273  *
 274  * MSRPC strings should always be varying/conformant and not null terminated.
 275  * This format uses the size_is, first_is and length_is attributes (CAE
 276  * section 4.2.18).
 277  *
 278  *      typedef struct string {
 279  *              DWORD size_is;
 280  *              DWORD first_is;
 281  *              DWORD length_is;
 282  *              wchar_t string[ANY_SIZE_ARRAY];
 283  *      } string_t;
 284  *
 285  * The size_is attribute is used to specify the number of data elements in
 286  * each dimension of an array.
 287  *
 288  * The first_is attribute is used to define the lower bound for significant
 289  * elements in each dimension of an array. For strings this is always 0.
 290  *
 291  * The length_is attribute is used to define the number of significant
 292  * elements in each dimension of an array. For strings this is typically
 293  * the same as size_is. Although it might be (size_is - 1) if the string
 294  * is null terminated.
 295  *
 296  *   4 bytes   4 bytes   4 bytes  2bytes 2bytes 2bytes 2bytes
 297  * +---------+---------+---------+------+------+------+------+
 298  * |size_is  |first_is |length_is| char | char | char | char |
 299  * +---------+---------+---------+------+------+------+------+
 300  *
 301  * Unfortunately, not all MSRPC Unicode strings are null terminated, which
 302  * means that the recipient has to manually null-terminate the string after
 303  * it has been unmarshalled.  There may be a wide-char pad following a
 304  * string, and it may sometimes contains zero, but it's not guaranteed.
 305  *
 306  * To deal with this, MSRPC sometimes uses an additional wrapper with two
 307  * more fields, as shown below.
 308  *      length: the array length in bytes excluding terminating null bytes
 309  *      maxlen: the array length in bytes including null terminator bytes
 310  *      LPTSTR: converted to a string_t by NDR
 311  *
 312  * typedef struct ms_string {
 313  *              WORD length;
 314  *              WORD maxlen;
 315  *              LPTSTR str;
 316  * } ms_string_t;
 317  */
 318 typedef struct ndr_mstring {
 319         uint16_t length;
 320         uint16_t allosize;
 321         LPTSTR str;
 322 } ndr_mstring_t;
 323
 324 /*
 325  * A number of heap areas are used during marshalling and unmarshalling.
 326  * Under some circumstances these areas can be discarded by the library
 327  * code, i.e. on the server side before returning to the client and on
 328  * completion of a client side bind.  In the case of a client side RPC
 329  * call, these areas must be preserved after an RPC returns to give the
 330  * caller time to take a copy of the data.  In this case the client must
 331  * call ndr_clnt_free_heap to free the memory.
 332  *
 333  * The heap management data definition looks a bit like this:
 334  *
 335  * heap -> +---------------+     +------------+
 336  *         | iovec[0].base | --> | data block |
 337  *         | iovec[0].len  |     +------------+
 338  *         +---------------+
 339  *                ::
 340  *                ::
 341  * iov  -> +---------------+     +------------+
 342  *         | iovec[n].base | --> | data block |
 343  *         | iovec[n].len  |     +------------+
 344  *         +---------------+     ^            ^
 345  *                               |            |
 346  *    next ----------------------+            |
 347  *    top  -----------------------------------+
 348  *
 349  */
 350
 351 /*
 352  * Setting MAXIOV to 384 will use ((8 * 384) + 16) = 3088 bytes
 353  * of the first heap block.
 354  */
 355 #define NDR_HEAP_MAXIOV         384
 356 #define NDR_HEAP_BLKSZ          8192
 357
 358 typedef struct ndr_heap {
 359         struct iovec iovec[NDR_HEAP_MAXIOV];
 360         struct iovec *iov;
 361         int iovcnt;
 362         char *top;
 363         char *next;
 364 } ndr_heap_t;
 365
 366 /*
 367  * Alternate varying/conformant string definition
 368  * - for non-null-terminated strings.
 369  */
 370 typedef struct ndr_vcs {
 371         /*
 372          * size_is (actually a copy of length_is) will
 373          * be inserted here by the marshalling library.
 374          */
 375         uint32_t vc_first_is;
 376         uint32_t vc_length_is;
 377         uint16_t buffer[ANY_SIZE_ARRAY];
 378 } ndr_vcs_t;
 379
 380 typedef struct ndr_vcstr {
 381         uint16_t wclen;
 382         uint16_t wcsize;
 383         ndr_vcs_t *vcs;
 384 } ndr_vcstr_t;
 385
 386 typedef struct ndr_vcb {
 387         /*
 388          * size_is (actually a copy of length_is) will
 389          * be inserted here by the marshalling library.
 390          */
 391         uint32_t vc_first_is;
 392         uint32_t vc_length_is;
 393         uint8_t buffer[ANY_SIZE_ARRAY];
 394 } ndr_vcb_t;
 395
 396 typedef struct ndr_vcbuf {
 397         uint16_t len;
 398         uint16_t size;
 399         ndr_vcb_t *vcb;
 400 } ndr_vcbuf_t;
 401
 402 ndr_heap_t *ndr_heap_create(void);
 403 void ndr_heap_destroy(ndr_heap_t *);
 404 void *ndr_heap_dupmem(ndr_heap_t *, const void *, size_t);
 405 void *ndr_heap_malloc(ndr_heap_t *, unsigned);
 406 void *ndr_heap_strdup(ndr_heap_t *, const char *);
 407 int ndr_heap_mstring(ndr_heap_t *, const char *, ndr_mstring_t *);
 408 void ndr_heap_mkvcs(ndr_heap_t *, char *, ndr_vcstr_t *);
 409 void ndr_heap_mkvcb(ndr_heap_t *, uint8_t *, uint32_t, ndr_vcbuf_t *);
 410 int ndr_heap_used(ndr_heap_t *);
 411 int ndr_heap_avail(ndr_heap_t *);
 412
 413 #define NDR_MALLOC(XA, SZ)      ndr_heap_malloc((XA)->heap, SZ)
 414 #define NDR_NEW(XA, T)          ndr_heap_malloc((XA)->heap, sizeof (T))
 415 #define NDR_NEWN(XA, T, N)      ndr_heap_malloc((XA)->heap, sizeof (T)*(N))
 416 #define NDR_STRDUP(XA, S)       ndr_heap_strdup((XA)->heap, (S))
 417 #define NDR_MSTRING(XA, S, OUT) ndr_heap_mstring((XA)->heap, (S), (OUT))
 418 #define NDR_SIDDUP(XA, S)       ndr_heap_dupmem((XA)->heap, (S), smb_sid_len(S))
 419
 420 typedef struct ndr_xa {
 421         unsigned short          ptype;          /* high bits special */
 422         unsigned short          opnum;
 423         ndr_stream_t            recv_nds;
 424         ndr_hdr_t               recv_hdr;
 425         ndr_stream_t            send_nds;
 426         ndr_hdr_t               send_hdr;
 427         ndr_binding_t           *binding;       /* what we're using */
 428         ndr_binding_t           *binding_list;  /* from connection */
 429         ndr_heap_t              *heap;
 430         ndr_pipe_t              *pipe;
 431 } ndr_xa_t;
 432
 433 /*
 434  * 20-byte opaque id used by various RPC services.
 435  */
 436 CONTEXT_HANDLE(ndr_hdid) ndr_hdid_t;
 437
 438 typedef struct ndr_client {
 439         /* transport stuff (xa_* members) */
 440         int (*xa_init)(struct ndr_client *, ndr_xa_t *);
 441         int (*xa_exchange)(struct ndr_client *, ndr_xa_t *);
 442         int (*xa_read)(struct ndr_client *, ndr_xa_t *);
 443         void (*xa_preserve)(struct ndr_client *, ndr_xa_t *);
 444         void (*xa_destruct)(struct ndr_client *, ndr_xa_t *);
 445         void (*xa_release)(struct ndr_client *);
 446         void                    *xa_private;
 447         int                     xa_fd;
 448
 449         ndr_hdid_t              *handle;
 450         ndr_binding_t           *binding;
 451         ndr_binding_t           *binding_list;
 452         ndr_binding_t           binding_pool[NDR_N_BINDING_POOL];
 453
 454         boolean_t               nonull;
 455         boolean_t               heap_preserved;
 456         ndr_heap_t              *heap;
 457         ndr_stream_t            *recv_nds;
 458         ndr_stream_t            *send_nds;
 459
 460         uint32_t                next_call_id;
 461         unsigned                next_p_cont_id;
 462 } ndr_client_t;
 463
 464 typedef struct ndr_handle {
 465         ndr_hdid_t              nh_id;
 466         struct ndr_handle       *nh_next;
 467         ndr_pipe_t              *nh_pipe;
 468         const ndr_service_t     *nh_svc;
 469         ndr_client_t            *nh_clnt;
 470         void                    *nh_data;
 471         void                    (*nh_data_free)(void *);
 472 } ndr_handle_t;
 473
 474 #define NDR_PDU_SIZE_HINT_DEFAULT       (16*1024)
 475 #define NDR_BUF_MAGIC                   0x4E425546      /* NBUF */
 476
 477 typedef struct ndr_buf {
 478         uint32_t                nb_magic;
 479         ndr_stream_t            nb_nds;
 480         ndr_heap_t              *nb_heap;
 481         ndr_typeinfo_t          *nb_ti;
 482 } ndr_buf_t;
 483
 484 /* ndr_ops.c */
 485 int nds_initialize(ndr_stream_t *, unsigned, int, ndr_heap_t *);
 486 void nds_destruct(ndr_stream_t *);
 487 void nds_show_state(ndr_stream_t *);
 488
 489 /* ndr_client.c */
 490 int ndr_clnt_bind(ndr_client_t *, ndr_service_t *, ndr_binding_t **);
 491 int ndr_clnt_call(ndr_binding_t *, int, void *);
 492 void ndr_clnt_free_heap(ndr_client_t *);
 493
 494 /* ndr_marshal.c */
 495 ndr_buf_t *ndr_buf_init(ndr_typeinfo_t *);
 496 void ndr_buf_fini(ndr_buf_t *);
 497 int ndr_buf_decode(ndr_buf_t *, unsigned, unsigned, const char *data, size_t,
 498     void *);
 499 int ndr_decode_call(ndr_xa_t *, void *);
 500 int ndr_encode_return(ndr_xa_t *, void *);
 501 int ndr_encode_call(ndr_xa_t *, void *);
 502 int ndr_decode_return(ndr_xa_t *, void *);
 503 int ndr_decode_pdu_hdr(ndr_xa_t *);
 504 int ndr_encode_pdu_hdr(ndr_xa_t *);
 505 void ndr_decode_frag_hdr(ndr_stream_t *, ndr_common_header_t *);
 506 void ndr_remove_frag_hdr(ndr_stream_t *);
 507 void ndr_show_hdr(ndr_common_header_t *);
 508 unsigned ndr_bind_ack_hdr_size(ndr_xa_t *);
 509 unsigned ndr_alter_context_rsp_hdr_size(void);
 510
 511 /* ndr_server.c */
 512 void ndr_pipe_worker(ndr_pipe_t *);
 513
 514 int ndr_generic_call_stub(ndr_xa_t *);
 515
 516 /* ndr_svc.c */
 517 ndr_stub_table_t *ndr_svc_find_stub(ndr_service_t *, int);
 518 ndr_service_t *ndr_svc_lookup_name(const char *);
 519 ndr_service_t *ndr_svc_lookup_uuid(ndr_uuid_t *, int, ndr_uuid_t *, int);
 520 int ndr_svc_register(ndr_service_t *);
 521 void ndr_svc_unregister(ndr_service_t *);
 522 void ndr_svc_binding_pool_init(ndr_binding_t **, ndr_binding_t pool[], int);
 523 ndr_binding_t *ndr_svc_find_binding(ndr_xa_t *, ndr_p_context_id_t);
 524 ndr_binding_t *ndr_svc_new_binding(ndr_xa_t *);
 525
 526 int ndr_uuid_parse(char *, ndr_uuid_t *);
 527 void ndr_uuid_unparse(ndr_uuid_t *, char *);
 528
 529 ndr_hdid_t *ndr_hdalloc(const ndr_xa_t *, const void *);
 530 void ndr_hdfree(const ndr_xa_t *, const ndr_hdid_t *);
 531 ndr_handle_t *ndr_hdlookup(const ndr_xa_t *, const ndr_hdid_t *);
 532 void ndr_hdclose(ndr_pipe_t *);
 533
 534 ssize_t ndr_uiomove(caddr_t, size_t, enum uio_rw, struct uio *);
 535
 536 /*
 537  * An ndr_client_t is created while binding a client connection to hold
 538  * the context for calls made using that connection.
 539  *
 540  * Handles are RPC call specific and we use an inheritance mechanism to
 541  * ensure that each handle has a pointer to the client_t.  When the top
 542  * level (bind) handle is released, we close the connection.
 543  *
 544  * There are some places in libmlsvc where the code assumes that the
 545  * handle member is first in this struct.  careful
 546  */
 547 typedef struct mlrpc_handle {
 548         ndr_hdid_t      handle;         /* keep first */
 549         ndr_client_t    *clnt;
 550 } mlrpc_handle_t;
 551
 552 int mlrpc_clh_create(mlrpc_handle_t *, void *);
 553 uint32_t mlrpc_clh_bind(mlrpc_handle_t *, ndr_service_t *);
 554 void mlrpc_clh_unbind(mlrpc_handle_t *);
 555 void *mlrpc_clh_free(mlrpc_handle_t *);
 556
 557 int ndr_rpc_call(mlrpc_handle_t *, int, void *);
 558 int ndr_rpc_get_ssnkey(mlrpc_handle_t *, unsigned char *, size_t);
 559 void *ndr_rpc_malloc(mlrpc_handle_t *, size_t);
 560 ndr_heap_t *ndr_rpc_get_heap(mlrpc_handle_t *);
 561 void ndr_rpc_release(mlrpc_handle_t *);
 562 void ndr_rpc_set_nonull(mlrpc_handle_t *);
 563
 564 boolean_t ndr_is_null_handle(mlrpc_handle_t *);
 565 boolean_t ndr_is_bind_handle(mlrpc_handle_t *);
 566 void ndr_inherit_handle(mlrpc_handle_t *, mlrpc_handle_t *);
 567
 568 #ifdef  __cplusplus
 569 }
 570 #endif
 571
 572 #endif  /* _LIBMLRPC_H */