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
SLPOpen(const char * pcLang,SLPBoolean isAsync,SLPHandle * phSLP)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
slp_cleanup_handle(slp_handle_impl_t * hp)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
SLPClose(SLPHandle hSLP)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