1/* 2 * Copyright (c) 2010 Apple Inc. All rights reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of Apple Inc. ("Apple") nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY 20 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 22 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY 23 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 * 30 * Portions of this software have been released under the following terms: 31 * 32 * (c) Copyright 1989-1993 OPEN SOFTWARE FOUNDATION, INC. 33 * (c) Copyright 1989-1993 HEWLETT-PACKARD COMPANY 34 * (c) Copyright 1989-1993 DIGITAL EQUIPMENT CORPORATION 35 * 36 * To anyone who acknowledges that this file is provided "AS IS" 37 * without any express or implied warranty: 38 * permission to use, copy, modify, and distribute this file for any 39 * purpose is hereby granted without fee, provided that the above 40 * copyright notices and this notice appears in all source code copies, 41 * and that none of the names of Open Software Foundation, Inc., Hewlett- 42 * Packard Company or Digital Equipment Corporation be used 43 * in advertising or publicity pertaining to distribution of the software 44 * without specific, written prior permission. Neither Open Software 45 * Foundation, Inc., Hewlett-Packard Company nor Digital 46 * Equipment Corporation makes any representations about the suitability 47 * of this software for any purpose. 48 * 49 * Copyright (c) 2007, Novell, Inc. All rights reserved. 50 * Redistribution and use in source and binary forms, with or without 51 * modification, are permitted provided that the following conditions 52 * are met: 53 * 54 * 1. Redistributions of source code must retain the above copyright 55 * notice, this list of conditions and the following disclaimer. 56 * 2. Redistributions in binary form must reproduce the above copyright 57 * notice, this list of conditions and the following disclaimer in the 58 * documentation and/or other materials provided with the distribution. 59 * 3. Neither the name of Novell Inc. nor the names of its contributors 60 * may be used to endorse or promote products derived from this 61 * this software without specific prior written permission. 62 * 63 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 64 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 65 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 66 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY 67 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 68 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 69 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 70 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 71 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 72 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 73 * 74 * @APPLE_LICENSE_HEADER_END@ 75 */ 76 77/* 78** 79** NAME: 80** 81** rpcpvt.idl 82** 83** FACILITY: 84** 85** Remote Procedure Call 86** 87** ABSTRACT: 88** 89** This file contains the PRIVATE interface to the Common Communications 90** Service of the RPC facility. 91** 92** NOTE WELL: The existence, signature, and semantics of anything in 93** this file is subject to change without notice and should thus not 94** be depended on by application writers. 95** 96** 97*/ 98 99[local] interface rpcpvt 100{ 101 102import "dce/lbase.idl"; 103import "dce/rpcbase.idl"; 104import "dce/iovector.idl"; 105import "dce/rpcsts.idl"; 106 107/*************************************************************************/ 108/************************ Deprecated names *****************************/ 109/*************************************************************************/ 110 111/* 112 * These are names that we used for a while, changed, but don't feel 113 * like fixing all the uses of right now. 114 */ 115const long rpc_c_authn_dce_private = rpc_c_authn_dce_secret; 116const long rpc_c_protseq_max_calls_default = rpc_c_protseq_max_reqs_default; 117 118const long rpc_s_unknown_auth_protocol = rpc_s_unknown_authn_service; 119const long rpc_s_cant_create_sock = rpc_s_cant_create_socket; 120const long rpc_s_cant_bind_sock = rpc_s_cant_bind_socket; 121const long rpc_s_cant_listen_sock = rpc_s_cant_listen_socket; 122const long rpc_s_no_ns_privilege = rpc_s_no_ns_permission; 123const long rpc_s_unsupported_authn_level = rpc_s_unsupported_protect_level; 124const long rpc_s_authn_level_mismatch = rpc_s_protect_level_mismatch; 125 126const long rpc_c_authn_level_default = rpc_c_protect_level_default; 127const long rpc_c_authn_level_none = rpc_c_protect_level_none; 128const long rpc_c_authn_level_connect = rpc_c_protect_level_connect; 129const long rpc_c_authn_level_call = rpc_c_protect_level_call; 130const long rpc_c_authn_level_pkt = rpc_c_protect_level_pkt; 131const long rpc_c_authn_level_pkt_integrity = rpc_c_protect_level_pkt_integ; 132const long rpc_c_authn_level_pkt_privacy = rpc_c_protect_level_pkt_privacy; 133 134/*********************************************************************** 135 * 136 * NSI typedefs for compatibility with existing (pre-DCE V1.0) code. 137 * 138 ***********************************************************************/ 139/* 140 * Inquiry handle. 141 */ 142typedef rpc_ns_handle_t rpc_ns_inq_handle_t, *rpc_ns_inq_handle_p_t; 143 144/* 145 * Lookup handle. 146 */ 147typedef rpc_ns_handle_t rpc_ns_lookup_handle_t, *rpc_ns_lookup_handle_p_t; 148 149/* 150 * Import handle. 151 */ 152typedef rpc_ns_handle_t rpc_ns_import_handle_t, *rpc_ns_import_handle_p_t; 153 154/*************************************************************************/ 155/******************* Comm Services Binding object **********************/ 156/*************************************************************************/ 157 158/* 159 * R P C _ B I N D I N G _ H A N D L E _ C O P Y 160 * 161 * Duplicate a binding handle. Create a duplicate handle to an existing 162 * (now shared) binding object. This is the ONLY legal way to create 163 * a duplicate handle to a shared binding object. I.E. the following 164 * C code is ILLEGAL: 165 * new_handle = existing_handle; 166 * A duplicate handle is freed by rpc_binding_free(). Duplicate handles 167 * are useful for properly managing a binding object that is concurrently 168 * shared among a number of threads. 169 */ 170void rpc_binding_handle_copy 171( 172 [in] rpc_binding_handle_t source_binding, 173 [out] rpc_binding_handle_t *destination_binding, 174 [out] unsigned32 *status 175); 176 177/* 178 * R P C _ B I N D I N G _ H A N D L E _ E Q U A L 179 * 180 * Compare two binding handles for equality. Returns true iff the two 181 * handles reference the same binding object. (see 182 * rpc_binding_handle_copy(); rpc_binding_copy() do not reference the 183 * same binding object). 184 */ 185boolean32 rpc_binding_handle_equal 186( 187 [in] rpc_binding_handle_t binding1, 188 [in] rpc_binding_handle_t binding2, 189 [out] unsigned32 *status 190); 191 192/* 193 * R P C _ B I N D I N G _ S E R V E R _ T O _ C L I E N T 194 * 195 * NOTE: This description uses old terminology. 196 * 197 * Convert a server binding handle to a client handle. The new handle's 198 * endpoint is reset and it has no associated authentication information. 199 * 200 * Server binding handles are those created by the runtime and provided 201 * to the server manager as a result of a [handle_t] RPC parameter. 202 */ 203void rpc_binding_server_to_client 204( 205 [in] rpc_binding_handle_t sbinding_handle, 206 [out] rpc_binding_handle_t *cbinding_handle, 207 [out] unsigned32 *status 208); 209 210/* 211 * R P C _ B I N D I N G _ T O _ E P M A P 212 * 213 * Given a binding handle to a server, return a binding handle to the 214 * EP map on that host. If input_binding is NULL, return a binding to 215 * the EP map on the local host. 216 */ 217void rpc_binding_to_epmap 218( 219 [in] rpc_binding_handle_t input_binding, 220 [out] rpc_binding_handle_t *output_binding, 221 [out] unsigned32 *status 222); 223 224/*************************************************************************/ 225/******************** Comm Services Server object **********************/ 226/*************************************************************************/ 227 228/* 229 * An opaque handle representing a server thread pool. 230 */ 231typedef rpc_opaque_ptr_t rpc_thread_pool_handle_t, *rpc_thread_pool_handle_p_t; 232 233/* 234 * R P C _ S E R V E R _ C R E A T E _ T H R E A D _ P O O L 235 * 236 * Create a pool of "num_threads" threads to execute incoming RPC 237 * requests. Return a handle onto that pool. 238 * The pool exists until the pool is freed; the pool's threads are created 239 * when rpc_server_listen() is called and destroyed when 240 * rpc_server_listen() returns. 241 */ 242void rpc_server_create_thread_pool 243( 244 [in] unsigned32 num_threads, 245 [out] rpc_thread_pool_handle_t *phandle, 246 [out] unsigned32 *status 247); 248 249/* 250 * R P C _ S E R V E R _ F R E E _ T H R E A D _ P O O L 251 * 252 * Destroy a thread pool once all RPCs executing using that pool 253 * complete. If wait_flag == true, block until the pool is destroyed. 254 */ 255void rpc_server_free_thread_pool 256( 257 [in, out] rpc_thread_pool_handle_t *phandle, 258 [in] boolean32 wait_flag, 259 [out] unsigned32 *status 260); 261 262/* 263 * Signature of an application-supplied function used to determine which 264 * thread pool to use for an incoming RPC request on object "obj_uuid", 265 * using the "opnum"th operation in interface "if_id". 266 * 267 * status (and phandle) return values: 268 * 0 - OK; phandle != NULL: execute the call with a phandle thread. 269 * If all phandle threads are busy, execute 270 * the call with the first available phandle 271 * thread or default pool thread (subject 272 * to runtime call rejection due to phandle 273 * max queue length limits). 274 * phandle == NULL: execute the call with a default pool 275 * thread. If all default pool threads 276 * are busy, execute the call with the 277 * first available default default pool 278 * thread (subject to runtime call rejection 279 * due to default pool max queue length 280 * limits). 281 * non-0 - failure: do not execute the call 282 */ 283typedef void (*rpc_thread_pool_fn_t) 284( 285 [in] uuid_p_t obj_uuid, 286 [in] rpc_if_id_p_t if_id, 287 [in] unsigned32 opnum, 288 [out] rpc_thread_pool_handle_t *phandle, 289 [out] unsigned32 *status 290); 291 292/* 293 * R P C _ S E R V E R _ S E T _ T H R E A D _ P O O L _ F N 294 * 295 * Supply the runtime with a function to be called to determine 296 * which pool an incoming RPC request should be run in. 297 * 298 * !!! NOTE: Your application assumes certain responsibilities if it 299 * uses thread pools. The applications's pool_fn operation is called 300 * back to from the runtime internal listener thread hence it should 301 * operate as efficiently as possible and not block for an extended period. 302 * The pool_fn MUST NOT call back into the runtime in performing its 303 * processing (e.g. it can't call rpc_object_inq_type(), ...). 304 */ 305void rpc_server_set_thread_pool_fn 306( 307 [in] rpc_thread_pool_fn_t pool_fn, 308 [out] unsigned32 *status 309); 310 311/* 312 * R P C _ S E R V E R _ S E T _ T H R E A D _ P O O L _ Q L E N 313 * 314 * Allow the application to adjust the size of a thread pool's call 315 * queue. That is, this routine allows the application to specify 316 * the maximum number of calls that will be queued for execution by 317 * a particular thread pool, if all of the pool's call threads are 318 * already in use. (Note that this function will only allow the 319 * queue size to be increased. Attempts to decrease the queue size 320 * are ignored.) 321 */ 322void rpc_server_set_thread_pool_qlen 323( 324 [in] rpc_thread_pool_handle_t phandle, 325 [in] unsigned32 queue_size, 326 [out] unsigned32 *status 327); 328 329/*************************************************************************/ 330/******************* Comm Services Tower object ************************/ 331/*************************************************************************/ 332 333/* 334 * R P C _ T O W E R _ T O _ B I N D I N G 335 * 336 * Creates a binding handle from the canonical representation 337 * of a protocol tower. 338 */ 339void rpc_tower_to_binding 340( 341 [in] byte_p_t prot_tower, 342 [out] rpc_binding_handle_t *binding, 343 [out] unsigned32 *status 344); 345 346/* 347 * R P C _ T O W E R _ V E C T O R _ F R O M _ B I N D I N G 348 * 349 * Creates a tower vector (of twr_t's) from a binding handle. 350 */ 351void rpc_tower_vector_from_binding 352( 353 [in] rpc_if_handle_t if_spec, 354 [in] rpc_binding_handle_t binding, 355 [out] rpc_tower_vector_p_t *twr_vector, 356 [out] unsigned32 *status 357); 358 359/* 360 * R P C _ T O W E R _ V E C T O R _ F R E E 361 * 362 * Free the memory allocated by the RPC runtime for the protocol towers 363 * contained in the vector and the vector itself. A NULL pointer will be 364 * returned. 365 */ 366void rpc_tower_vector_free 367( 368 [in, out] rpc_tower_vector_p_t *twr_vector, 369 [out] unsigned32 *status 370); 371 372/*************************************************************************/ 373/********************** Name Services Entry object *********************/ 374/*************************************************************************/ 375 376/* 377 * R P C _ N S _ E N T R Y _ I N Q _ R E S O L U T I O N 378 * 379 * Inquire on the resolution of a name service entry 380 */ 381void rpc_ns_entry_inq_resolution 382( 383 [in] unsigned32 entry_name_syntax, 384 [in] unsigned_char_p_t entry_name, 385 [out] unsigned_char_p_t *resolved_name, 386 [out] unsigned_char_p_t *unresolved_name, 387 [out] unsigned32 *status 388); 389 390/*************************************************************************/ 391/********************* Name Services Authentication ********************/ 392/*************************************************************************/ 393/* 394 * R P C _ N S _ S E T _ A U T H N 395 * 396 * Set the Name Services Authentication 397 */ 398void rpc_ns_set_authn 399( 400 [in] boolean32 authn, 401 [out] boolean32 *previous_authn, 402 [out] unsigned32 *status 403); 404 405/*************************************************************************/ 406/************************** Management Services ************************/ 407/*************************************************************************/ 408 409/* 410 * R P C _ M G M T _ I N Q _ D F L T _ A U T H N _ L E V E L 411 * 412 * Returns the default protection level for an authentication service. 413 */ 414void rpc_mgmt_inq_dflt_authn_level 415( 416 [in] unsigned32 authn_svc, 417 [out] unsigned32 *authn_level, 418 [out] unsigned32 *st 419); 420 421/* 422 * R P C _ M G M T _ S E T _ M A X _ C O N C U R R E N C Y 423 * 424 * Notify RPC runtime of how many concurrent RPC threads are required 425 * by the application. 426 */ 427void rpc_mgmt_set_max_concurrency 428( 429 [in] unsigned32 max_client_calls, 430 [in] unsigned32 max_server_calls, 431 [out] unsigned32 *status 432); 433 434/* 435 * R P C _ M G M T _ G E T _ M A X _ C O N C U R R E N C Y 436 * 437 * Allows an application to determine how many concurrent RPC calls can 438 * be supported by the runtime. 439 */ 440unsigned32 rpc_mgmt_get_max_concurrency 441( 442); 443 444/* 445 * R P C _ M G M T _ S E T _ S E R V E R _ C O M _ T I M E O U T 446 * 447 * Set the default comm timeout setting for all server calls. 448 */ 449void rpc_mgmt_set_server_com_timeout 450( 451 [in] unsigned32 timeout, 452 [out] unsigned32 *status 453); 454 455/* 456 * R P C _ M G M T _ I N Q _ S E R V E R _ C O M _ T I M E O U T 457 * 458 * Returns the default comm timeout setting in use for all server calls. 459 */ 460unsigned32 rpc_mgmt_inq_server_com_timeout 461( 462); 463 464/*************************************************************************/ 465/******************* Stub Services Binding object **********************/ 466/*************************************************************************/ 467 468/* 469 * R P C _ B I N D I N G _ I N Q _ C L I E N T 470 * 471 * Inquire what client address space a binding handle refers to. 472 */ 473void rpc_binding_inq_client 474( 475 [in] rpc_binding_handle_t binding_handle, 476 [out] rpc_client_handle_t *client_handle, 477 [out] unsigned32 *status 478); 479 480/*************************************************************************/ 481/******************* Stub Services Call object *************************/ 482/*************************************************************************/ 483 484/* 485 * R P C _ C A L L _ B L O C K _ U N T I L _ F R E E 486 * 487 * This routine will block until all marshaled RPC output arguments have 488 * been transmitted and acknowledged. It is provided for use by the server 489 * stub when the marshaled arguments are contained in buffers which are on 490 * stack. The danger is that the server stub would return to the RPC 491 * runtime thereby invalidating its stack and the buffer contents. 492 */ 493void rpc_call_block_until_free 494( 495 [in] rpc_call_handle_t call_handle, 496 [out] unsigned32 *status 497); 498 499/* 500 * R P C _ C A L L _ C A N C E L 501 * 502 * Forward a local cancel to the remote RPC thread identified by the call 503 * handle provided. 504 */ 505void rpc_call_cancel 506( 507 [in] rpc_call_handle_t call_handle, 508 [out] unsigned32 *status 509); 510 511/* 512 * R P C _ C A L L _ D I D _ M G R _ E X E C U T E 513 * 514 * Return whether or not the manager routine for the call identified 515 * by the call handle has executed. 516 */ 517boolean32 rpc_call_did_mgr_execute 518( 519 [in] rpc_call_handle_t call_handle, 520 [out] unsigned32 *status 521); 522 523/* 524 * R P C _ C A L L _ E N D 525 * 526 * End a Remote Procedure Call. This is the last in the sequence of 527 * calls by the client stub. 528 */ 529void rpc_call_end 530( 531 [in, out] rpc_call_handle_t *call_handle, 532 [out] unsigned32 *status 533); 534 535/* 536 * R P C _ C A L L _ T R A N S M I T _ F A U L T 537 * 538 * Forward an exception to the remote RPC thread identified by the call 539 * handle. 540 */ 541void rpc_call_transmit_fault 542( 543 [in] rpc_call_handle_t call_handle, 544 [in] rpc_iovector_p_t fault_info, 545 [out] unsigned32 *status 546); 547 548/* 549 * R P C _ C A L L _ R E C E I V E 550 * 551 * Return a buffer of marshaled arguments from the remote thread. 552 */ 553void rpc_call_receive 554( 555 [in] rpc_call_handle_t call_handle, 556 [out] rpc_iovector_elt_t *call_args, 557 [out] unsigned32 *status 558); 559 560/* 561 * R P C _ C A L L _ R E C E I V E _ F A U L T 562 * 563 * Return a buffer of marshaled fault information from the remote thread. 564 */ 565void rpc_call_receive_fault 566( 567 [in] rpc_call_handle_t call_handle, 568 [out] rpc_iovector_elt_t *fault_info, 569 [out] ndr_format_t *remote_ndr_fmt, 570 [out] unsigned32 *status 571); 572 573/* 574 * R P C _ C A L L _ S T A R T 575 * 576 * Begin a Remote Procedure Call. This is the first in a sequence of 577 * calls by the client stub. Return the information needed to marshal input 578 * arguments. 579 */ 580void rpc_call_start 581( 582 [in] rpc_binding_handle_t binding_handle, 583 [in] unsigned32 call_options, 584 [in] rpc_if_handle_t if_spec, 585 [in] unsigned32 operation_number, 586 [out] rpc_call_handle_t *call_handle, 587 [out] rpc_transfer_syntax_t *xfer_syntax, 588 [out] unsigned32 *status 589); 590 591/* 592 * R P C _ C A L L _ T R A N S C E I V E 593 * 594 * 595 * Transmit a vector of marshaled arguments to the remote thread. Use the 596 * call handle as the identifier of the RPC being performed. Block until 597 * the first buffer of marshaled output arguments has been received. 598 */ 599void rpc_call_transceive 600( 601 [in] rpc_call_handle_t call_handle, 602 [in] rpc_iovector_p_t in_call_args, 603 [out] rpc_iovector_elt_t *out_call_args, 604 [out] ndr_format_t *remote_ndr_fmt, 605 [out] unsigned32 *status 606); 607 608/* 609 * R P C _ C A L L _ T R A N S M I T 610 * 611 * Transmit a vector of marshaled arguments to the remote thread. Use the 612 * call handle as the identifier of the RPC being performed. 613 */ 614void rpc_call_transmit 615( 616 [in] rpc_call_handle_t call_handle, 617 [in] rpc_iovector_p_t call_args, 618 [out] unsigned32 *status 619); 620 621/*************************************************************************/ 622/****************** Stub Services Network object ***********************/ 623/*************************************************************************/ 624 625/* 626 * R P C _ N E T W O R K _ M A I N T A I N _ L I V E N E S S 627 * 628 * This routine tells the RPC runtime to actively keep communications alive 629 * with the process identified in the binding. 630 */ 631void rpc_network_maintain_liveness 632( 633 [in] rpc_binding_handle_t binding_handle, 634 [out] unsigned32 *status 635); 636 637/* 638 * R P C _ N E T W O R K _ M O N I T O R _ L I V E N E S S 639 * 640 * This routine tells the RPC runtime to call the routine provided if 641 * communications are lost to the process represented by the client 642 * handle provided. 643 */ 644void rpc_network_monitor_liveness 645( 646 [in] rpc_binding_handle_t binding_handle, 647 [in] rpc_client_handle_t client_handle, 648 [in] rpc_network_rundown_fn_t rundown_fn, 649 [out] unsigned32 *status 650); 651 652/* 653 * R P C _ N E T W O R K _ S T O P _ M A I N T A I N I N G 654 * 655 * This routine tells the RPC runtime to cancel rpc_network_maintain_liveness. 656 */ 657void rpc_network_stop_maintaining 658( 659 [in] rpc_binding_handle_t binding_handle, 660 [out] unsigned32 *status 661); 662 663/* 664 * R P C _ N E T W O R K _ S T O P _ M O N I T O R I N G 665 * 666 * This routine tells the RPC runtime to cancel rpc_network_monitor_liveness. 667 */ 668void rpc_network_stop_monitoring 669( 670 [in] rpc_binding_handle_t binding_handle, 671 [in] rpc_client_handle_t client_handle, 672 [out] unsigned32 *status 673); 674 675/* 676 * R P C _ N E T W O R K _ C L O S E 677 * 678 * This routine tells the RPC runtime to close the underlying 679 * association with a binding handle. 680 */ 681void rpc_network_close 682( 683 [in] rpc_binding_handle_t binding_handle, 684 [out] unsigned32 *status 685); 686 687/*************************************************************************/ 688/****************** Stub Services Utility object ***********************/ 689/*************************************************************************/ 690 691/* 692 * R P C _ U T I L _ S T R C V T 693 * 694 * Perform ASCII <-> EBCDIC conversion. 695 */ 696void rpc_util_strcvt 697( 698 [in] boolean32 to_ascii, 699 [in] unsigned32 len, 700 [in] byte_p_t src, 701 [in] byte_p_t dst 702); 703 704/*************************************************************************/ 705/******************* Comm Services Utilities **********************/ 706/*************************************************************************/ 707 708/* 709 * R P C _ S T R A L L O C 710 * 711 * Make a copy of the input string into allocated storage. 712 */ 713unsigned_char_p_t rpc_stralloc 714( 715 [in] unsigned_char_p_t string 716); 717 718} 719