sbin/hastd/proto_uds.c

   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 }