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 "pjdlog.h" 47 #include "proto_impl.h" 48 49 #define UDS_CTX_MAGIC 0xd541c 50 struct uds_ctx { 51 int uc_magic; 52 struct sockaddr_un uc_sun; 53 int uc_fd; 54 int uc_side; 55 #define UDS_SIDE_CLIENT 0 56 #define UDS_SIDE_SERVER_LISTEN 1 57 #define UDS_SIDE_SERVER_WORK 2 58 }; 59 60 static void uds_close(void *ctx); 61 62 static int 63 uds_addr(const char *addr, struct sockaddr_un *sunp) 64 { 65 66 if (addr == NULL) 67 return (-1); 68 69 if (strncasecmp(addr, "uds://", 6) == 0) 70 addr += 6; 71 else if (strncasecmp(addr, "unix://", 7) == 0) 72 addr += 7; 73 else if (addr[0] == '/' && /* If it starts from /... */ 74 strstr(addr, "://") == NULL)/* ...and there is no prefix... */ 75 ; /* ...we assume its us. */ 76 else 77 return (-1); 78 79 sunp->sun_family = AF_UNIX; 80 if (strlcpy(sunp->sun_path, addr, sizeof(sunp->sun_path)) >= 81 sizeof(sunp->sun_path)) { 82 return (ENAMETOOLONG); 83 } 84 sunp->sun_len = SUN_LEN(sunp); 85 86 return (0); 87 } 88 89 static int 90 uds_common_setup(const char *addr, void **ctxp, int side) 91 { 92 struct uds_ctx *uctx; 93 int ret; 94 95 uctx = malloc(sizeof(*uctx)); 96 if (uctx == NULL) 97 return (errno); 98 99 /* Parse given address. */ 100 if ((ret = uds_addr(addr, &uctx->uc_sun)) != 0) { 101 free(uctx); 102 return (ret); 103 } 104 105 uctx->uc_fd = socket(AF_UNIX, SOCK_STREAM, 0); 106 if (uctx->uc_fd == -1) { 107 ret = errno; 108 free(uctx); 109 return (ret); 110 } 111 112 uctx->uc_side = side; 113 uctx->uc_magic = UDS_CTX_MAGIC; 114 *ctxp = uctx; 115 116 return (0); 117 } 118 119 static int 120 uds_client(const char *addr, void **ctxp) 121 { 122 123 return (uds_common_setup(addr, ctxp, UDS_SIDE_CLIENT)); 124 } 125 126 static int 127 uds_connect(void *ctx) 128 { 129 struct uds_ctx *uctx = ctx; 130 131 assert(uctx != NULL); 132 assert(uctx->uc_magic == UDS_CTX_MAGIC); 133 assert(uctx->uc_side == UDS_SIDE_CLIENT); 134 assert(uctx->uc_fd >= 0); 135 136 if (connect(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun, 137 sizeof(uctx->uc_sun)) < 0) { 138 return (errno); 139 } 140 141 return (0); 142 } 143 144 static int 145 uds_server(const char *addr, void **ctxp) 146 { 147 struct uds_ctx *uctx; 148 int ret; 149 150 ret = uds_common_setup(addr, ctxp, UDS_SIDE_SERVER_LISTEN); 151 if (ret != 0) 152 return (ret); 153 154 uctx = *ctxp; 155 156 unlink(uctx->uc_sun.sun_path); 157 if (bind(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun, 158 sizeof(uctx->uc_sun)) < 0) { 159 ret = errno; 160 uds_close(uctx); 161 return (ret); 162 } 163 if (listen(uctx->uc_fd, 8) < 0) { 164 ret = errno; 165 uds_close(uctx); 166 return (ret); 167 } 168 169 return (0); 170 } 171 172 static int 173 uds_accept(void *ctx, void **newctxp) 174 { 175 struct uds_ctx *uctx = ctx; 176 struct uds_ctx *newuctx; 177 socklen_t fromlen; 178 int ret; 179 180 assert(uctx != NULL); 181 assert(uctx->uc_magic == UDS_CTX_MAGIC); 182 assert(uctx->uc_side == UDS_SIDE_SERVER_LISTEN); 183 assert(uctx->uc_fd >= 0); 184 185 newuctx = malloc(sizeof(*newuctx)); 186 if (newuctx == NULL) 187 return (errno); 188 189 fromlen = sizeof(uctx->uc_sun); 190 newuctx->uc_fd = accept(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun, 191 &fromlen); 192 if (newuctx->uc_fd < 0) { 193 ret = errno; 194 free(newuctx); 195 return (ret); 196 } 197 198 newuctx->uc_side = UDS_SIDE_SERVER_WORK; 199 newuctx->uc_magic = UDS_CTX_MAGIC; 200 *newctxp = newuctx; 201 202 return (0); 203 } 204 205 static int 206 uds_send(void *ctx, const unsigned char *data, size_t size) 207 { 208 struct uds_ctx *uctx = ctx; 209 210 assert(uctx != NULL); 211 assert(uctx->uc_magic == UDS_CTX_MAGIC); 212 assert(uctx->uc_fd >= 0); 213 214 return (proto_common_send(uctx->uc_fd, data, size)); 215 } 216 217 static int 218 uds_recv(void *ctx, unsigned char *data, size_t size) 219 { 220 struct uds_ctx *uctx = ctx; 221 222 assert(uctx != NULL); 223 assert(uctx->uc_magic == UDS_CTX_MAGIC); 224 assert(uctx->uc_fd >= 0); 225 226 return (proto_common_recv(uctx->uc_fd, data, size)); 227 } 228 229 static int 230 uds_descriptor(const void *ctx) 231 { 232 const struct uds_ctx *uctx = ctx; 233 234 assert(uctx != NULL); 235 assert(uctx->uc_magic == UDS_CTX_MAGIC); 236 237 return (uctx->uc_fd); 238 } 239 240 static bool 241 uds_address_match(const void *ctx __unused, const char *addr __unused) 242 { 243 244 assert(!"proto_address_match() not supported on UNIX domain sockets"); 245 abort(); 246 } 247 248 static void 249 uds_local_address(const void *ctx, char *addr, size_t size) 250 { 251 const struct uds_ctx *uctx = ctx; 252 struct sockaddr_un sun; 253 socklen_t sunlen; 254 255 assert(uctx != NULL); 256 assert(uctx->uc_magic == UDS_CTX_MAGIC); 257 assert(addr != NULL); 258 259 sunlen = sizeof(sun); 260 if (getsockname(uctx->uc_fd, (struct sockaddr *)&sun, &sunlen) < 0) { 261 PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size); 262 return; 263 } 264 assert(sun.sun_family == AF_UNIX); 265 if (sun.sun_path[0] == '\0') { 266 PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size); 267 return; 268 } 269 PJDLOG_VERIFY(snprintf(addr, size, "uds://%s", sun.sun_path) < (ssize_t)size); 270 } 271 272 static void 273 uds_remote_address(const void *ctx, char *addr, size_t size) 274 { 275 const struct uds_ctx *uctx = ctx; 276 struct sockaddr_un sun; 277 socklen_t sunlen; 278 279 assert(uctx != NULL); 280 assert(uctx->uc_magic == UDS_CTX_MAGIC); 281 assert(addr != NULL); 282 283 sunlen = sizeof(sun); 284 if (getpeername(uctx->uc_fd, (struct sockaddr *)&sun, &sunlen) < 0) { 285 PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size); 286 return; 287 } 288 assert(sun.sun_family == AF_UNIX); 289 if (sun.sun_path[0] == '\0') { 290 PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size); 291 return; 292 } 293 snprintf(addr, size, "uds://%s", sun.sun_path); 294 } 295 296 static void 297 uds_close(void *ctx) 298 { 299 struct uds_ctx *uctx = ctx; 300 301 assert(uctx != NULL); 302 assert(uctx->uc_magic == UDS_CTX_MAGIC); 303 304 if (uctx->uc_fd >= 0) 305 close(uctx->uc_fd); 306 unlink(uctx->uc_sun.sun_path); 307 uctx->uc_magic = 0; 308 free(uctx); 309 } 310 311 static struct hast_proto uds_proto = { 312 .hp_name = "uds", 313 .hp_client = uds_client, 314 .hp_connect = uds_connect, 315 .hp_server = uds_server, 316 .hp_accept = uds_accept, 317 .hp_send = uds_send, 318 .hp_recv = uds_recv, 319 .hp_descriptor = uds_descriptor, 320 .hp_address_match = uds_address_match, 321 .hp_local_address = uds_local_address, 322 .hp_remote_address = uds_remote_address, 323 .hp_close = uds_close 324 }; 325 326 static __constructor void 327 uds_ctor(void) 328 { 329 330 proto_register(&uds_proto, false); 331 } 332