1 /*- 2 * Copyright (c) 2009-2010 The FreeBSD Foundation 3 * All rights reserved. 4 * 5 * This software was developed by Pawel Jakub Dawidek under sponsorship from 6 * the FreeBSD Foundation. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 /* UDS - UNIX Domain Socket */ 34 35 #include <sys/un.h> 36 37 #include <assert.h> 38 #include <errno.h> 39 #include <stdbool.h> 40 #include <stdint.h> 41 #include <stdio.h> 42 #include <string.h> 43 #include <unistd.h> 44 45 #include "hast.h" 46 #include "proto_impl.h" 47 48 #define UDS_CTX_MAGIC 0xd541c 49 struct uds_ctx { 50 int uc_magic; 51 struct sockaddr_un uc_sun; 52 int uc_fd; 53 int uc_side; 54 #define UDS_SIDE_CLIENT 0 55 #define UDS_SIDE_SERVER_LISTEN 1 56 #define UDS_SIDE_SERVER_WORK 2 57 }; 58 59 static void uds_close(void *ctx); 60 61 static int 62 uds_addr(const char *addr, struct sockaddr_un *sunp) 63 { 64 65 if (addr == NULL) 66 return (-1); 67 68 if (strncasecmp(addr, "uds://", 6) == 0) 69 addr += 6; 70 else if (strncasecmp(addr, "unix://", 7) == 0) 71 addr += 7; 72 else if (addr[0] == '/' && /* If it starts from /... */ 73 strstr(addr, "://") == NULL)/* ...and there is no prefix... */ 74 ; /* ...we assume its us. */ 75 else 76 return (-1); 77 78 sunp->sun_family = AF_UNIX; 79 if (strlcpy(sunp->sun_path, addr, sizeof(sunp->sun_path)) >= 80 sizeof(sunp->sun_path)) { 81 return (ENAMETOOLONG); 82 } 83 sunp->sun_len = SUN_LEN(sunp); 84 85 return (0); 86 } 87 88 static int 89 uds_common_setup(const char *addr, void **ctxp, int side) 90 { 91 struct uds_ctx *uctx; 92 int ret; 93 94 uctx = malloc(sizeof(*uctx)); 95 if (uctx == NULL) 96 return (errno); 97 98 /* Parse given address. */ 99 if ((ret = uds_addr(addr, &uctx->uc_sun)) != 0) { 100 free(uctx); 101 return (ret); 102 } 103 104 uctx->uc_fd = socket(AF_UNIX, SOCK_STREAM, 0); 105 if (uctx->uc_fd == -1) { 106 ret = errno; 107 free(uctx); 108 return (ret); 109 } 110 111 uctx->uc_side = side; 112 uctx->uc_magic = UDS_CTX_MAGIC; 113 *ctxp = uctx; 114 115 return (0); 116 } 117 118 static int 119 uds_client(const char *addr, void **ctxp) 120 { 121 122 return (uds_common_setup(addr, ctxp, UDS_SIDE_CLIENT)); 123 } 124 125 static int 126 uds_connect(void *ctx) 127 { 128 struct uds_ctx *uctx = ctx; 129 130 assert(uctx != NULL); 131 assert(uctx->uc_magic == UDS_CTX_MAGIC); 132 assert(uctx->uc_side == UDS_SIDE_CLIENT); 133 assert(uctx->uc_fd >= 0); 134 135 if (connect(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun, 136 sizeof(uctx->uc_sun)) < 0) { 137 return (errno); 138 } 139 140 return (0); 141 } 142 143 static int 144 uds_server(const char *addr, void **ctxp) 145 { 146 struct uds_ctx *uctx; 147 int ret; 148 149 ret = uds_common_setup(addr, ctxp, UDS_SIDE_SERVER_LISTEN); 150 if (ret != 0) 151 return (ret); 152 153 uctx = *ctxp; 154 155 unlink(uctx->uc_sun.sun_path); 156 if (bind(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun, 157 sizeof(uctx->uc_sun)) < 0) { 158 ret = errno; 159 uds_close(uctx); 160 return (ret); 161 } 162 if (listen(uctx->uc_fd, 8) < 0) { 163 ret = errno; 164 uds_close(uctx); 165 return (ret); 166 } 167 168 return (0); 169 } 170 171 static int 172 uds_accept(void *ctx, void **newctxp) 173 { 174 struct uds_ctx *uctx = ctx; 175 struct uds_ctx *newuctx; 176 socklen_t fromlen; 177 int ret; 178 179 assert(uctx != NULL); 180 assert(uctx->uc_magic == UDS_CTX_MAGIC); 181 assert(uctx->uc_side == UDS_SIDE_SERVER_LISTEN); 182 assert(uctx->uc_fd >= 0); 183 184 newuctx = malloc(sizeof(*newuctx)); 185 if (newuctx == NULL) 186 return (errno); 187 188 fromlen = sizeof(uctx->uc_sun); 189 newuctx->uc_fd = accept(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun, 190 &fromlen); 191 if (newuctx->uc_fd < 0) { 192 ret = errno; 193 free(newuctx); 194 return (ret); 195 } 196 197 newuctx->uc_side = UDS_SIDE_SERVER_WORK; 198 newuctx->uc_magic = UDS_CTX_MAGIC; 199 *newctxp = newuctx; 200 201 return (0); 202 } 203 204 static int 205 uds_send(void *ctx, const unsigned char *data, size_t size) 206 { 207 struct uds_ctx *uctx = ctx; 208 209 assert(uctx != NULL); 210 assert(uctx->uc_magic == UDS_CTX_MAGIC); 211 assert(uctx->uc_fd >= 0); 212 213 return (proto_common_send(uctx->uc_fd, data, size)); 214 } 215 216 static int 217 uds_recv(void *ctx, unsigned char *data, size_t size) 218 { 219 struct uds_ctx *uctx = ctx; 220 221 assert(uctx != NULL); 222 assert(uctx->uc_magic == UDS_CTX_MAGIC); 223 assert(uctx->uc_fd >= 0); 224 225 return (proto_common_recv(uctx->uc_fd, data, size)); 226 } 227 228 static int 229 uds_descriptor(const void *ctx) 230 { 231 const struct uds_ctx *uctx = ctx; 232 233 assert(uctx != NULL); 234 assert(uctx->uc_magic == UDS_CTX_MAGIC); 235 236 return (uctx->uc_fd); 237 } 238 239 static bool 240 uds_address_match(const void *ctx __unused, const char *addr __unused) 241 { 242 243 assert(!"proto_address_match() not supported on UNIX domain sockets"); 244 abort(); 245 } 246 247 static void 248 uds_local_address(const void *ctx, char *addr, size_t size) 249 { 250 const struct uds_ctx *uctx = ctx; 251 struct sockaddr_un sun; 252 socklen_t sunlen; 253 254 assert(uctx != NULL); 255 assert(uctx->uc_magic == UDS_CTX_MAGIC); 256 assert(addr != NULL); 257 258 sunlen = sizeof(sun); 259 if (getsockname(uctx->uc_fd, (struct sockaddr *)&sun, &sunlen) < 0) { 260 strlcpy(addr, "N/A", size); 261 return; 262 } 263 assert(sun.sun_family == AF_UNIX); 264 if (sun.sun_path[0] == '\0') { 265 strlcpy(addr, "N/A", size); 266 return; 267 } 268 snprintf(addr, size, "uds://%s", sun.sun_path); 269 } 270 271 static void 272 uds_remote_address(const void *ctx, char *addr, size_t size) 273 { 274 const struct uds_ctx *uctx = ctx; 275 struct sockaddr_un sun; 276 socklen_t sunlen; 277 278 assert(uctx != NULL); 279 assert(uctx->uc_magic == UDS_CTX_MAGIC); 280 assert(addr != NULL); 281 282 sunlen = sizeof(sun); 283 if (getpeername(uctx->uc_fd, (struct sockaddr *)&sun, &sunlen) < 0) { 284 strlcpy(addr, "N/A", size); 285 return; 286 } 287 assert(sun.sun_family == AF_UNIX); 288 if (sun.sun_path[0] == '\0') { 289 strlcpy(addr, "N/A", size); 290 return; 291 } 292 snprintf(addr, size, "uds://%s", sun.sun_path); 293 } 294 295 static void 296 uds_close(void *ctx) 297 { 298 struct uds_ctx *uctx = ctx; 299 300 assert(uctx != NULL); 301 assert(uctx->uc_magic == UDS_CTX_MAGIC); 302 303 if (uctx->uc_fd >= 0) 304 close(uctx->uc_fd); 305 unlink(uctx->uc_sun.sun_path); 306 uctx->uc_magic = 0; 307 free(uctx); 308 } 309 310 static struct hast_proto uds_proto = { 311 .hp_name = "uds", 312 .hp_client = uds_client, 313 .hp_connect = uds_connect, 314 .hp_server = uds_server, 315 .hp_accept = uds_accept, 316 .hp_send = uds_send, 317 .hp_recv = uds_recv, 318 .hp_descriptor = uds_descriptor, 319 .hp_address_match = uds_address_match, 320 .hp_local_address = uds_local_address, 321 .hp_remote_address = uds_remote_address, 322 .hp_close = uds_close 323 }; 324 325 static __constructor void 326 uds_ctor(void) 327 { 328 329 proto_register(&uds_proto); 330 } 331