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