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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright (c) 1999 by Sun Microsystems, Inc. 24 * All rights reserved. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <thread.h> 32 #include <synch.h> 33 #include <syslog.h> 34 #include <arpa/inet.h> 35 #include <slp-internal.h> 36 #include <slp_net_utils.h> 37 38 SLPError SLPOpen(const char *pcLang, SLPBoolean isAsync, SLPHandle *phSLP) { 39 slp_handle_impl_t *hp; 40 41 if (!pcLang || !phSLP) { 42 return (SLP_PARAMETER_BAD); 43 } 44 45 /* allocate the handle */ 46 if (!(hp = malloc(sizeof (*hp)))) { 47 slp_err(LOG_CRIT, 0, "SLPOpen", "out of memory"); 48 return (SLP_MEMORY_ALLOC_FAILED); 49 } 50 51 /* initialize outcall synchronization */ 52 hp->pending_outcall = SLP_FALSE; 53 (void) mutex_init(&(hp->outcall_lock), NULL, NULL); 54 (void) cond_init(&(hp->outcall_cv), NULL, NULL); 55 hp->close_on_end = SLP_FALSE; 56 hp->consumer_tid = 0; 57 58 /* locale property overrides argument */ 59 if (!(hp->locale = SLPGetProperty(SLP_CONFIG_LOCALE))) { 60 hp->locale = pcLang; 61 } 62 /* Make sure the language string is under our ownership */ 63 if (!(hp->locale = strdup(hp->locale))) { 64 free(hp); 65 slp_err(LOG_CRIT, 0, "SLPOpen", "out of memory"); 66 return (SLP_MEMORY_ALLOC_FAILED); 67 } 68 69 hp->cancel = 0; 70 71 /* Asynchronous operation? */ 72 if (isAsync) 73 hp->async = SLP_TRUE; 74 else 75 hp->async = SLP_FALSE; 76 77 /* TCP vars -- these are NULL until actually needed */ 78 hp->tcp_lock = NULL; 79 hp->tcp_wait = NULL; 80 hp->tcp_ref_cnt = 0; 81 82 /* Consumer / Producer pipe */ 83 hp->q = NULL; 84 85 /* Interface info, loaded on demand */ 86 hp->ifinfo = NULL; 87 88 /* force multicast, false by default */ 89 hp->force_multicast = SLP_FALSE; 90 91 /* internal call, false by default */ 92 hp->internal_call = SLP_FALSE; 93 94 *phSLP = hp; 95 return (SLP_OK); 96 } 97 98 void slp_cleanup_handle(slp_handle_impl_t *hp) { 99 /* free the handle */ 100 if (hp->tcp_lock) free(hp->tcp_lock); 101 if (hp->tcp_wait) free(hp->tcp_wait); 102 if (hp->ifinfo) { 103 slp_free_ifinfo(hp->ifinfo); 104 free(hp->ifinfo); 105 } 106 free((void *) hp->locale); 107 free(hp); 108 } 109 110 void SLPClose(SLPHandle hSLP) { 111 slp_handle_impl_t *hp = (slp_handle_impl_t *)hSLP; 112 113 if (!hSLP) { 114 return; 115 } 116 117 /* 118 * If an outcall is pending on this handle: 119 * If we are being called from a callback resulting 120 * from the outcall associated with this handle or 121 * if close_on_end has already been set: 122 * just set close on end and return -- the cleanup 123 * will be done when the outcall is finished. 124 * else 125 * wait on the outcall cv for the outcall to complete 126 * Proceed with cleanup 127 */ 128 (void) mutex_lock(&(hp->outcall_lock)); 129 if (hp->pending_outcall) { 130 /* end the consumer thread */ 131 /* this will also kill the producer thread and close net */ 132 hp->cancel = 1; 133 if (hp->q) { 134 if (slp_enqueue_at_head(hp->q, NULL) != SLP_OK) { 135 goto cleanup; 136 } 137 } 138 139 if (thr_self() == hp->consumer_tid || hp->close_on_end) { 140 /* SLPClose called from callback */ 141 hp->close_on_end = SLP_TRUE; 142 (void) mutex_unlock(&(hp->outcall_lock)); 143 return; 144 } 145 /* else not called from callback; wait for outcall to end */ 146 while (hp->pending_outcall) { 147 (void) cond_wait(&(hp->outcall_cv), &(hp->outcall_lock)); 148 } 149 } 150 (void) mutex_unlock(&(hp->outcall_lock)); 151 152 cleanup: 153 slp_cleanup_handle(hp); 154 } 155