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