/* * Copyright (c) 2010 Apple Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of Apple Inc. ("Apple") nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Portions of this software have been released under the following terms: * * (c) Copyright 1989-1993 OPEN SOFTWARE FOUNDATION, INC. * (c) Copyright 1989-1993 HEWLETT-PACKARD COMPANY * (c) Copyright 1989-1993 DIGITAL EQUIPMENT CORPORATION * * To anyone who acknowledges that this file is provided "AS IS" * without any express or implied warranty: * permission to use, copy, modify, and distribute this file for any * purpose is hereby granted without fee, provided that the above * copyright notices and this notice appears in all source code copies, * and that none of the names of Open Software Foundation, Inc., Hewlett- * Packard Company or Digital Equipment Corporation be used * in advertising or publicity pertaining to distribution of the software * without specific, written prior permission. Neither Open Software * Foundation, Inc., Hewlett-Packard Company nor Digital * Equipment Corporation makes any representations about the suitability * of this software for any purpose. * * Copyright (c) 2007, Novell, Inc. All rights reserved. * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of Novell Inc. nor the names of its contributors * may be used to endorse or promote products derived from this * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * @APPLE_LICENSE_HEADER_END@ */ /* ** ** ** NAME: ** ** COMTWR.C ** ** FACILITY: ** ** Remote procedure call (RPC) ** ** ABSTRACT: ** ** Set of routines supporting operations that create and manipulate the ** canonical representation of a protocol tower. ** ** **/ #include <commonp.h> /* Private defs for Common component */ #include <com.h> /* Private COM defs for other RPC components */ #include <comp.h> /* Privates for COM Services component */ #include <comtwr.h> /* Private tower defs */ #include <comtwrref.h> /* Private tower ref defs for other RPC components */ /* **++ ** ROUTINE NAME: rpc__tower_free ** ** SCOPE: PRIVATE - declared in comtwr.h ** ** DESCRIPTION: ** ** Releases memory used by a tower that was dynamically created. ** Towers are dynamically created by calling the ** rpc__tower_from_tower_ref routine. ** ** INPUTS: none ** ** INPUT/OUTPUTS: ** ** tower Canonical representation of a protocol tower. ** Nulled on return. ** ** OUTPUTS: ** ** status Returns the status code from the free ** operation. This status code indicates whether the ** routine completed successfully and, if not, why. ** Returns rpc_s_ok. ** ** IMPLICIT INPUTS: none ** ** IMPLICIT OUTPUTS: none ** ** FUNCTION VALUE: none ** ** SIDE EFFECTS: none ** **-- */ PRIVATE void rpc__tower_free ( twr_p_t *tower, unsigned32 *status ) { CODING_ERROR (status); RPC_MEM_FREE (*tower, RPC_C_MEM_TOWER); *tower = NULL; *status = rpc_s_ok; return; } /* **++ ** ROUTINE NAME: rpc__tower_from_tower_ref ** ** SCOPE: PRIVATE - declared in comtwr.h ** ** DESCRIPTION: ** ** This routine creates the canonical representation of a protocol tower ** from a runtime reference representation of a protocol tower. ** ** INPUTS: ** ** tower_ref Runtime reference representation of a protocol tower. ** ** INPUT/OUTPUTS: none ** ** OUTPUTS: ** ** tower Returns a pointer to the canonical representation ** of a protocol tower. ** ** status Returns the status code from the ** tower from tower_ref operation. This status code ** indicates whether the routine completed ** successfully and, if not, why. ** Returns ** rpc_s_ok ** or status from a called routine. ** ** IMPLICIT INPUTS: none ** ** IMPLICIT OUTPUTS: none ** ** FUNCTION VALUE: ** ** void ** ** SIDE EFFECTS: none ** **-- */ PRIVATE void rpc__tower_from_tower_ref ( rpc_tower_ref_p_t tower_ref, twr_p_t *tower, unsigned32 *status ) { byte_p_t tower_p; unsigned16 twr_rep_16; unsigned32 i, floor_size, octet_length; /* * Calculate the size of the tower octet string. */ for (i = 0, octet_length = 0; i < tower_ref->count; i++) { octet_length += (tower_ref->floor[i]->prot_id_count + RPC_C_TOWER_FLR_LHS_COUNT_SIZE + tower_ref->floor[i]->address_count + RPC_C_TOWER_FLR_RHS_COUNT_SIZE); } octet_length += RPC_C_TOWER_FLR_COUNT_SIZE; /* * Allocate the tower structure to hold the * canonical representation of the tower. */ RPC_MEM_ALLOC ( *tower, twr_p_t, sizeof (twr_t) + octet_length - 1, RPC_C_MEM_TOWER, RPC_C_MEM_WAITOK ); /* * Initialize the tower length in the tower structure. */ (*tower)->tower_length = octet_length; /* * Form the tower octet string starting * with the tower floor count size. */ tower_p = (*tower)->tower_octet_string; /* * Convert the tower count to little endian * and copy it to the octet string. */ twr_rep_16 = tower_ref->count; RPC_RESOLVE_ENDIAN_INT16 (twr_rep_16); memcpy ((char *)tower_p, (char *)&twr_rep_16, RPC_C_TOWER_FLR_COUNT_SIZE); tower_p += RPC_C_TOWER_FLR_COUNT_SIZE; /* * And now copy each tower floor to the octet string. */ for (i=0; i < tower_ref->count; i++) { floor_size = RPC_C_TOWER_FLR_LHS_COUNT_SIZE + tower_ref->floor[i]->prot_id_count + RPC_C_TOWER_FLR_RHS_COUNT_SIZE + tower_ref->floor[i]->address_count; memcpy ((char *)tower_p, (char *)tower_ref->floor[i]->octet_string, floor_size); tower_p += floor_size; } *status = rpc_s_ok; return; } /* **++ ** ROUTINE NAME: rpc__tower_to_tower_ref ** ** SCOPE: PRIVATE - declared in comtwr.h ** ** DESCRIPTION: ** ** Creates a runtime reference representation of a protocol tower ** from a canonical representation of a protocol tower. ** ** INPUTS: ** ** tower Canonical representation of a protocol tower. ** ** INPUT/OUTPUTS: none ** ** OUTPUTS: ** ** tower_ref Returns a pointer to a reference representation ** of a protocol tower. ** status Returns the status code from the tower to tower ref ** operation. This status code indicates whether the ** routine completed successfully and, if not, why. ** Returns ** rpc_s_ok ** or status from a called routine. ** ** IMPLICIT INPUTS: none ** ** IMPLICIT OUTPUTS: none ** ** FUNCTION VALUE: void ** ** SIDE EFFECTS: none ** **-- */ PRIVATE void rpc__tower_to_tower_ref ( twr_p_t tower, rpc_tower_ref_p_t *tower_ref, unsigned32 *status ) { unsigned16 floor_count; CODING_ERROR (status); /* * Get the tower floor count and correct for proper endian. */ memcpy ((char *) &floor_count, (char *) tower->tower_octet_string, RPC_C_TOWER_FLR_COUNT_SIZE); RPC_RESOLVE_ENDIAN_INT16 (floor_count); /* * Allocate and initialize the tower reference structure to be returned. */ rpc__tower_ref_alloc (tower->tower_octet_string, floor_count, 1, tower_ref, status); /* * Return status from the tower ref allocate operation. */ return; } /* **++ ** ROUTINE NAME: rpc_tower_to_binding ** ** SCOPE: PUBLIC - declared in rpc.idl ** ** DESCRIPTION: ** ** Creates a binding handle from a canonical representation of a ** protocol tower. After the caller is finished with the binding, the ** rpc_binding_free routine must be called to release the memory used ** by the binding. ** ** Note, this is an SPI routine - available to outside the runtime, ** but only to other DCE components. ** ** INPUTS: ** ** prot_tower A single protocol tower (DNA$Tower attribute value) ** to convert to a binding handle. ** ** INPUT/OUTPUTS: none ** ** OUTPUTS: ** ** binding Returns a binding handle. ** status Returns the status code from the tower-to-binding ** operation. This status code indicates whether the ** routine completed successfully and, if not, why. ** Returns ** rpc_s_ok ** or status from a called routine. ** ** IMPLICIT INPUTS: none ** ** IMPLICIT OUTPUTS: none ** ** FUNCTION VALUE: void ** ** SIDE EFFECTS: none ** **-- */ PUBLIC void rpc_tower_to_binding ( byte_p_t prot_tower, rpc_binding_handle_t *binding, unsigned32 *status ) { rpc_binding_rep_p_t binding_rep; rpc_protocol_id_t prot_id; rpc_addr_p_t rpc_addr; CODING_ERROR (status); RPC_VERIFY_INIT (); /* * Null binding in case of error before finishing. */ *binding = NULL; /* * Obtain an RPC address for the tower. */ rpc__naf_tower_flrs_to_addr (prot_tower, &rpc_addr, status); if (*status != rpc_s_ok) { return; } prot_id = RPC_PROTSEQ_INQ_PROT_ID(rpc_addr->rpc_protseq_id); /* * Allocate and initialize a binding rep. */ binding_rep = rpc__binding_alloc (false, &uuid_g_nil_uuid, prot_id, rpc_addr, status); /* * Return binding handle to user. */ *binding = (rpc_binding_handle_t) binding_rep; /* * Return status from rpc__binding_alloc */ return; } /* **++ ** ROUTINE NAME: rpc_tower_vector_from_binding ** ** SCOPE: PUBLIC - declared in rpc.idl ** ** DESCRIPTION: ** ** Creates a vector of twr_t's from a binding handle. After the caller is ** finished with the tower vector, the rpc_tower_vector_free routine must be ** called to release the memory used by the vector. ** ** Note, this is an SPI routine - available to outside the runtime, ** but only to other DCE components. ** ** INPUTS: ** ** if_spec Interface spec to combine with a binding ** handle to form a tower vector. ** ** binding Binding handle to combine with an interface ** spec to form a tower vector. ** ** INPUT/OUTPUTS: none ** ** OUTPUTS: ** ** tower_vector Returns an allocated tower vector. ** ** status Returns the status code from the ** tower-vector-from-binding operation. ** This status code indicates whether the ** routine completed successfully and, if not, why. ** Returns ** rpc_s_ok ** rpc_s_no_interfaces ** or status from a called routine. ** ** IMPLICIT INPUTS: none ** ** IMPLICIT OUTPUTS: none ** ** FUNCTION VALUE: void ** ** SIDE EFFECTS: none ** **-- */ PUBLIC void rpc_tower_vector_from_binding ( rpc_if_handle_t if_spec, rpc_binding_handle_t binding, rpc_tower_vector_p_t *twr_vector, unsigned32 *status ) { rpc_tower_ref_vector_t *tower_ref_vector; unsigned int i; unsigned32 temp_status; CODING_ERROR (status); RPC_VERIFY_INIT (); /* * Null the twr_vector in case of error before finishing. */ *twr_vector = NULL; if (if_spec == NULL) { *status = rpc_s_no_interfaces; return; } /* * Convert the binding to a vector of tower refs. */ rpc__tower_ref_vec_from_binding ((rpc_if_rep_p_t)if_spec, binding, &tower_ref_vector, status); if (*status != rpc_s_ok) { /* * No need to goto CLEANUP; since a tower_ref_vector wasn't * returned to us. */ return; } /* * Allocate a rpc_tower_vector_t based on the number of returned * tower refs. */ RPC_MEM_ALLOC ( *twr_vector, rpc_tower_vector_p_t, sizeof (rpc_tower_vector_t) + (tower_ref_vector->count - 1) * sizeof (twr_p_t), RPC_C_MEM_TOWER_VECTOR, RPC_C_MEM_WAITOK ); (*twr_vector)->count = tower_ref_vector->count; /* * For each returned tower ref convert the tower ref to a twr_t and * store the twr_t in the rpc_tower_vector_t. */ for (i = 0; i < tower_ref_vector->count; i++) { rpc__tower_from_tower_ref (tower_ref_vector->tower[i], &(*twr_vector)->tower[i], status); if (*status != rpc_s_ok) { RPC_MEM_FREE (*twr_vector, RPC_C_MEM_TOWER_VECTOR); goto CLEANUP; } } CLEANUP: /* * Free the tower_ref_vector returned from * rpc__tower_ref_vec_from_binding(). */ rpc__tower_ref_vec_free (&tower_ref_vector, &temp_status); /* * If we got this far successfully, return whatever the result from * rpc__tower_ref_vec_free(). Otherwise, return the previous error * in status. */ if (*status == rpc_s_ok) { *status = temp_status; } return; } /* **++ ** ROUTINE NAME: rpc_tower_vector_free ** ** SCOPE: PRIVATE - declared in comtwrref.h ** ** DESCRIPTION: ** ** Releases memory associated with a tower vector, ** including the towers as well as the vector. ** ** INPUTS: none ** ** INPUT/OUTPUTS: ** ** twr_vector The tower vector to free. Nulled on return. ** ** OUTPUTS: ** ** status Returns the status code from the tower free ** operation. This status code is a value that ** indicates whether the routine completed ** successfully and, if not, why. ** Returns ** rpc_s_ok ** or status from a called routine. ** ** IMPLICIT INPUTS: none ** ** IMPLICIT OUTPUTS: none ** ** FUNCTION VALUE: void ** ** SIDE EFFECTS: none ** **-- */ PRIVATE void rpc_tower_vector_free ( rpc_tower_vector_p_t *twr_vector, unsigned32 *status ) { unsigned32 i; CODING_ERROR (status); /* * Free each tower reference in the vector. */ for (i=0; i < (*twr_vector)->count; i++) { rpc__tower_free (&((*twr_vector)->tower[i]), status); if (*status != rpc_s_ok) { return; } } /* * Free the tower vector structure and set pointer to NULL. */ RPC_MEM_FREE (*twr_vector, RPC_C_MEM_TOWER_VECTOR); *twr_vector = NULL; *status = rpc_s_ok; return; }