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 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <stdlib.h>
28 #include <strings.h>
29 #include <unistd.h>
30 #include <stddef.h>
31 #include <assert.h>
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <thread.h>
35 #include <synch.h>
36 #include <libilb_impl.h>
37 #include <libilb.h>
38
39 /* Assertion: the calling thread has a hold on the handle */
40 static void
41 i_ilb_socket_set_err(ilb_handle_t h, ilb_status_t err)
42 {
43 ilb_handle_impl_t *hi = (ilb_handle_impl_t *)h;
44
45 if (h == ILB_INVALID_HANDLE)
46 return;
47 hi->h_valid = B_FALSE;
48 hi->h_error = err;
49 }
50
51 ilb_status_t
52 ilb_open(ilb_handle_t *hp)
53 {
54 ilb_handle_impl_t *hi = NULL;
55 int s = -1;
56 struct sockaddr_un sa = {AF_UNIX, SOCKET_PATH};
57 ilb_status_t rc = ILB_STATUS_OK;
58 int sobufsz;
59
60 if (hp == NULL)
61 return (ILB_STATUS_EINVAL);
62
63 hi = calloc(sizeof (*hi), 1);
64 if (hi == NULL)
65 return (ILB_STATUS_ENOMEM);
66
67 if (cond_init(&hi->h_cv, USYNC_THREAD, NULL) != 0) {
68 rc = ILB_STATUS_INTERNAL;
69 goto out;
70 }
71
72 if (mutex_init(&hi->h_lock, USYNC_THREAD | LOCK_ERRORCHECK, NULL)
73 != 0) {
74 rc = ILB_STATUS_INTERNAL;
75 goto out;
76 }
77
78 hi->h_busy = B_FALSE;
79
80 if ((s = socket(PF_UNIX, SOCK_SEQPACKET, 0)) == -1 ||
81 connect(s, (struct sockaddr *)&sa, sizeof (sa.sun_path))
82 == -1) {
83 rc = ILB_STATUS_SOCKET;
84 goto out;
85 }
86
87 /* The socket buffer must be at least the max size of a message */
88 sobufsz = ILBD_MSG_SIZE;
89 if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sobufsz,
90 sizeof (sobufsz)) != 0) {
91 rc = ILB_STATUS_SOCKET;
92 (void) close(s);
93 goto out;
94 }
95 if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &sobufsz,
96 sizeof (sobufsz)) != 0) {
97 rc = ILB_STATUS_SOCKET;
98 (void) close(s);
99 goto out;
100 }
101
102 hi->h_socket = s;
103 hi->h_valid = B_TRUE;
104
105 out:
106 if (rc != ILB_STATUS_OK && s != -1)
107 (void) close(s);
108
109 if (rc == ILB_STATUS_OK) {
110 *hp = (ilb_handle_t)hi;
111 } else {
112 free(hi);
113 *hp = ILB_INVALID_HANDLE;
114 }
115 return (rc);
116 }
117
118 ilb_status_t
119 ilb_close(ilb_handle_t h)
120 {
121 ilb_handle_impl_t *hi = (ilb_handle_impl_t *)h;
122
123 if (h == ILB_INVALID_HANDLE)
124 return (ILB_STATUS_EINVAL);
125
126 if (mutex_lock(&hi->h_lock) != 0)
127 return (ILB_STATUS_INTERNAL);
128
129 /* Somebody has done a close, no need to do anything. */
130 if (hi->h_closing) {
131 return (ILB_STATUS_OK);
132 } else {
133 hi->h_closing = B_TRUE;
134 hi->h_error = ILB_STATUS_HANDLE_CLOSING;
135 }
136
137 /* Wait until there is nobody waiting. */
138 while (hi->h_waiter > 0) {
139 if (cond_wait(&hi->h_cv, &hi->h_lock) != 0) {
140 (void) mutex_unlock(&hi->h_lock);
141 return (ILB_STATUS_INTERNAL);
142 }
143 }
144 /* No one is waiting, proceed to free the handle. */
145
146 (void) close(hi->h_socket);
147 (void) mutex_destroy(&hi->h_lock);
148 (void) cond_destroy(&hi->h_cv);
149 free(hi);
150 return (ILB_STATUS_OK);
151 }
152
153 /*
154 * Unified routine to communicate with ilbd.
155 *
156 * If ic is non-NULL, it means that the caller wants to send something
157 * to ilbd and expects a reply. If ic is NULL, it means that the caller
158 * only expects to receive from ilbd.
159 *
160 * The rbuf is the buffer supplied by the caller for receiving. If it
161 * is NULL, it means that there is no reply expected.
162 *
163 * This function will not close() the socket to kernel unless there is
164 * an error. If the transaction only consists of one exchange, the caller
165 * can use i_ilb_close_comm() to close() the socket when done.
166 */
167 ilb_status_t
168 i_ilb_do_comm(ilb_handle_t h, ilb_comm_t *ic, size_t ic_sz, ilb_comm_t *rbuf,
169 size_t *rbufsz)
170 {
171 ilb_status_t rc = ILB_STATUS_OK;
172 int r, s;
173 ilb_handle_impl_t *hi = (ilb_handle_impl_t *)h;
174
175 assert(rbuf != NULL);
176 if (h == ILB_INVALID_HANDLE)
177 return (ILB_STATUS_EINVAL);
178
179 if (mutex_lock(&hi->h_lock) != 0)
180 return (ILB_STATUS_INTERNAL);
181
182 hi->h_waiter++;
183 while (hi->h_busy) {
184 if (cond_wait(&hi->h_cv, &hi->h_lock) != 0) {
185 hi->h_waiter--;
186 (void) cond_signal(&hi->h_cv);
187 (void) mutex_unlock(&hi->h_lock);
188 return (ILB_STATUS_INTERNAL);
189 }
190 }
191
192 if (!hi->h_valid || hi->h_closing) {
193 hi->h_waiter--;
194 (void) cond_signal(&hi->h_cv);
195 (void) mutex_unlock(&hi->h_lock);
196 return (hi->h_error);
197 }
198
199 hi->h_busy = B_TRUE;
200 (void) mutex_unlock(&hi->h_lock);
201
202 s = hi->h_socket;
203
204 r = send(s, ic, ic_sz, 0);
205 if (r < ic_sz) {
206 rc = ILB_STATUS_WRITE;
207 goto socket_error;
208 }
209 rc = ILB_STATUS_OK;
210
211 if ((r = recv(s, rbuf, *rbufsz, 0)) <= 0) {
212 rc = ILB_STATUS_READ;
213 } else {
214 *rbufsz = r;
215 goto out;
216 }
217
218 socket_error:
219 i_ilb_socket_set_err(h, rc);
220
221 out:
222 (void) mutex_lock(&hi->h_lock);
223 hi->h_busy = B_FALSE;
224 hi->h_waiter--;
225 (void) cond_signal(&hi->h_cv);
226 (void) mutex_unlock(&hi->h_lock);
227
228 return (rc);
229 }
230
231 void
232 i_ilb_close_comm(ilb_handle_t h)
233 {
234 (void) ilb_close(h);
235 }