lib/libc/sysvipc/sockets.c

   1 /**
   2  * Copyright (c) 2013 Larisa Grigore.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/param.h>
  28 #include <sys/un.h>
  29 #include <sys/uio.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <err.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <signal.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40
  41 #include "sysvipc_utils.h"
  42 #include "sysvipc_sockets.h"
  43
  44 #define MAX_CONN        10
  45
  46 int
  47 init_socket(const char *sockfile)
  48 {
  49         struct sockaddr_un un_addr;
  50         int sock;
  51
  52         /* create server socket */
  53         if ( (sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
  54                 sysv_print_err("init socket");
  55                 return (-1);
  56         }
  57
  58         /* bind it */
  59         memset(&un_addr, 0, sizeof(un_addr));
  60         un_addr.sun_len = sizeof(un_addr);
  61         un_addr.sun_family = AF_UNIX;
  62         strcpy(un_addr.sun_path, sockfile);
  63
  64         unlink(un_addr.sun_path);
  65
  66         if (bind(sock, (struct sockaddr *)&un_addr, sizeof(un_addr)) < 0) {
  67                 close(sock);
  68                 sysv_print_err("bind");
  69                 return (-1);
  70         }
  71
  72         if (listen(sock, MAX_CONN) < 0) {
  73                 close(sock);
  74                 sysv_print_err("listen");
  75                 return (-1);
  76         }
  77
  78         /* turn on credentials passing */
  79         return (sock);
  80 }
  81
  82 int
  83 handle_new_connection(int sock)
  84 {
  85         int fd, flags;
  86
  87         do {
  88                 fd = accept(sock, NULL, NULL);
  89         } while (fd < 0 && errno == EINTR);
  90
  91         if (fd < 0) {
  92                 sysv_print_err("accept");
  93                 return (-1);
  94         }
  95
  96         flags = fcntl(fd, F_GETFL, 0);
  97         fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
  98
  99         return (fd);
 100 }
 101
 102 int
 103 connect_to_daemon(const char *sockfile)
 104 {
 105         int sock, flags;
 106         struct sockaddr_un serv_addr;
 107
 108         if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 109                 sysv_print_err("socket(%d)\n", sock);
 110                 return (-1);
 111         }
 112
 113         flags = fcntl(sock, F_GETFL, 0);
 114         fcntl(sock, F_SETFL, flags & ~O_NONBLOCK);
 115
 116         memset(&serv_addr, 0, sizeof(serv_addr));
 117         serv_addr.sun_family = AF_UNIX;
 118         strcpy(serv_addr.sun_path, sockfile);
 119
 120         if (connect(sock, (struct sockaddr *)&serv_addr,
 121                                 sizeof(serv_addr)) < 0) {
 122                 close(sock);
 123                 sysv_print_err("connect(%d)\n", sock);
 124                 return (-1);
 125         }
 126
 127         return (sock);
 128 }
 129
 130 int
 131 send_fd(int sock, int fd)
 132 {
 133         struct msghdr msg;
 134         struct iovec vec;
 135 #ifndef HAVE_ACCRIGHTS_IN_MSGHDR
 136         union {
 137                 struct cmsghdr hdr;
 138                 char buf[CMSG_SPACE(sizeof(int))];
 139         } cmsgbuf;
 140         struct cmsghdr *cmsg;
 141 #endif
 142         int result = 0;
 143         ssize_t n;
 144
 145         memset(&msg, 0, sizeof(msg));
 146
 147         if (fd < 0)
 148                 result = errno;
 149         else {
 150 #ifdef HAVE_ACCRIGHTS_IN_MSGHDR
 151                 msg.msg_accrights = (caddr_t)&fd;
 152                 msg.msg_accrightslen = sizeof(fd);
 153 #else
 154                 msg.msg_control = (caddr_t)cmsgbuf.buf;
 155                 msg.msg_controllen = sizeof(cmsgbuf.buf);
 156                 cmsg = CMSG_FIRSTHDR(&msg);
 157                 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 158                 cmsg->cmsg_level = SOL_SOCKET;
 159                 cmsg->cmsg_type = SCM_RIGHTS;
 160                 *(int *)CMSG_DATA(cmsg) = fd;
 161 #endif
 162         }
 163
 164         vec.iov_base = (caddr_t)&result;
 165         vec.iov_len = sizeof(int);
 166         msg.msg_iov = &vec;
 167         msg.msg_iovlen = 1;
 168
 169         if ((n = sendmsg(sock, &msg, 0)) == -1) {
 170                 sysv_print_err("sendmsg(%d)\n", sock);
 171                 return (-1);
 172         }
 173         if (n != sizeof(int)) {
 174                 sysv_print_err("sendmsg: expected sent 1 got %ld\n",
 175                                 (long)n);
 176                 return (-1);
 177         }
 178
 179         return (0);
 180 }
 181
 182 /**/
 183 int
 184 receive_fd(int sock)
 185 {
 186         struct msghdr msg;
 187         struct iovec vec;
 188 #ifndef HAVE_ACCRIGHTS_IN_MSGHDR
 189         union {
 190                 struct cmsghdr hdr;
 191                 char buf[CMSG_SPACE(sizeof(int))];
 192         } cmsgbuf;
 193         struct cmsghdr *cmsg;
 194 #endif
 195         ssize_t n;
 196         int result;
 197         int fd;
 198
 199         memset(&msg, 0, sizeof(msg));
 200         vec.iov_base = (caddr_t)&result;
 201         vec.iov_len = sizeof(int);
 202         msg.msg_iov = &vec;
 203         msg.msg_iovlen = 1;
 204
 205 #ifdef HAVE_ACCRIGHTS_IN_MSGHDR
 206         msg.msg_accrights = (caddr_t)&fd;
 207         msg.msg_accrightslen = sizeof(fd);
 208 #else
 209         msg.msg_control = &cmsgbuf.buf;
 210         msg.msg_controllen = sizeof(cmsgbuf.buf);
 211 #endif
 212
 213         if ((n = recvmsg(sock, &msg, 0)) == -1)
 214                 sysv_print_err("recvmsg\n");
 215         if (n != sizeof(int)) {
 216                 sysv_print_err("recvmsg: expected received 1 got %ld\n",
 217                                 (long)n);
 218         }
 219         if (result == 0) {
 220                 cmsg = CMSG_FIRSTHDR(&msg);
 221                 if (cmsg == NULL) {
 222                         sysv_print_err("no message header\n");
 223                         return (-1);
 224                 }
 225                 if (cmsg->cmsg_type != SCM_RIGHTS)
 226                         sysv_print_err("expected type %d got %d\n",
 227                                         SCM_RIGHTS, cmsg->cmsg_type);
 228
 229                 fd = (*(int *)CMSG_DATA(cmsg));
 230                 return (fd);
 231         } else {
 232                 errno = result;
 233                 return (-1);
 234         }
 235 }
 236
 237 static void
 238 close_fds(int *fds, int num_fds) {
 239         int i;
 240
 241         for (i=0; i < num_fds; i++)
 242                 close(fds[i]);
 243 }
 244
 245 /* Send with the message, credentials too. */
 246 int
 247 send_msg_with_cred(int sock, char *buffer, size_t size) {
 248         struct msghdr msg;
 249         struct iovec vec;
 250         ssize_t n;
 251
 252         struct {
 253                 struct cmsghdr hdr;
 254                 char cred[CMSG_SPACE(sizeof(struct cmsgcred))];
 255         } cmsg;
 256
 257         memset(&cmsg, 0, sizeof(cmsg));
 258         cmsg.hdr.cmsg_len =  CMSG_LEN(sizeof(struct cmsgcred));
 259         cmsg.hdr.cmsg_level = SOL_SOCKET;
 260         cmsg.hdr.cmsg_type = SCM_CREDS;
 261
 262         memset(&msg, 0, sizeof(struct msghdr));
 263         msg.msg_iov = &vec;
 264         msg.msg_iovlen = 1;
 265         msg.msg_control = (caddr_t)&cmsg;
 266         msg.msg_controllen = CMSG_SPACE(sizeof(struct cmsgcred));
 267
 268         vec.iov_base = buffer;
 269         vec.iov_len = size;
 270
 271         if ((n = sendmsg(sock, &msg, 0)) == -1) {
 272                 sysv_print_err("sendmsg on fd %d\n", sock);
 273                 return (-1);
 274         }
 275
 276         return (0);
 277 }
 278
 279 /* Receive a message and the credentials of the sender. */
 280 int
 281 receive_msg_with_cred(int sock, char *buffer, size_t size,
 282                 struct cmsgcred *cred) {
 283         struct msghdr msg = { .msg_name = NULL };
 284         struct iovec vec;
 285         ssize_t n;
 286         int result;
 287         struct cmsghdr *cmp;
 288         struct {
 289                 struct cmsghdr hdr;
 290                 char cred[CMSG_SPACE(sizeof(struct cmsgcred))];
 291         } cmsg;
 292
 293         memset(&msg, 0, sizeof(msg));
 294         vec.iov_base = buffer;
 295         vec.iov_len = size;
 296         msg.msg_iov = &vec;
 297         msg.msg_iovlen = 1;
 298
 299         msg.msg_control = &cmsg;
 300         msg.msg_controllen = sizeof(cmsg);
 301
 302         do {
 303                 n = recvmsg(sock, &msg, 0);
 304         } while (n < 0 && errno == EINTR);
 305
 306         if (n < 0) {
 307                 sysv_print_err("recvmsg on fd %d\n", sock);
 308                 return (-1);
 309         }
 310
 311         if (n == 0) {
 312                 return (-1);
 313         }
 314
 315         result = -1;
 316         cmp = CMSG_FIRSTHDR(&msg);
 317
 318         while(cmp != NULL) {
 319                 if (cmp->cmsg_level == SOL_SOCKET
 320                                 && cmp->cmsg_type  == SCM_CREDS) {
 321                         if (cred)
 322                                 memcpy(cred, CMSG_DATA(cmp), sizeof(*cred));
 323                         result = n;
 324                 } else if (cmp->cmsg_level == SOL_SOCKET
 325                                 && cmp->cmsg_type  == SCM_RIGHTS) {
 326                         close_fds((int *) CMSG_DATA(cmp),
 327                                         (cmp->cmsg_len - CMSG_LEN(0))
 328                                         / sizeof(int));
 329                 }
 330                 cmp = CMSG_NXTHDR(&msg, cmp);
 331         }
 332
 333         return (result);
 334 }