external/bsd/dhcpcd/dist/control.c

   1 /*
   2  * dhcpcd - DHCP client daemon
   3  * Copyright (c) 2006-2009 Roy Marples <roy@marples.name>
   4  * All rights reserved
   5
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/stat.h>
  29 #include <sys/un.h>
  30
  31 #include <errno.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <time.h>
  36 #include <unistd.h>
  37
  38 #include "config.h"
  39 #include "common.h"
  40 #include "dhcpcd.h"
  41 #include "control.h"
  42 #include "eloop.h"
  43
  44 static int fd = -1;
  45 static char buffer[1024];
  46 static char *argvp[255];
  47
  48 struct sockaddr_un sun;
  49 struct fd_list *fds = NULL;
  50
  51 static void
  52 remove_control_data(void *arg)
  53 {
  54         struct fd_list *l, *last = NULL;
  55
  56         for (l = fds; l != NULL; l = l->next) {
  57                 if (l == arg) {
  58                         close(l->fd);
  59                         delete_event(l->fd);
  60                         if (last == NULL)
  61                                 fds = l->next;
  62                         else
  63                                 last->next = l->next;
  64                         free(l);
  65                         break;
  66                 }
  67                 last = l;
  68         }
  69 }
  70
  71 static void
  72 handle_control_data(void *arg)
  73 {
  74         struct fd_list *l = arg;
  75         ssize_t bytes;
  76         int argc;
  77         char *e, *p;
  78         char **ap;
  79
  80         bytes = read(l->fd, buffer, sizeof(buffer) - 1);
  81         if (bytes == -1 || bytes == 0) {
  82                 remove_control_data(l);
  83                 return;
  84         }
  85         buffer[bytes] = '\0';
  86         p = buffer;
  87         e = buffer + bytes;
  88         argc = 0;
  89         ap = argvp;
  90         while (p < e && (size_t)argc < sizeof(argvp)) {
  91                 argc++;
  92                 *ap++ = p;
  93                 p += strlen(p) + 1;
  94         }
  95         handle_args(l, argc, argvp);
  96 }
  97
  98 /* ARGSUSED */
  99 static void
 100 handle_control(_unused void *arg)
 101 {
 102         struct sockaddr_un run;
 103         socklen_t len;
 104         struct fd_list *l;
 105         int f;
 106
 107         len = sizeof(run);
 108         if ((f = accept(fd, (struct sockaddr *)&run, &len)) == -1)
 109                 return;
 110         l = xmalloc(sizeof(*l));
 111         l->fd = f;
 112         l->listener = 0;
 113         l->next = fds;
 114         fds = l;
 115         add_event(l->fd, handle_control_data, l);
 116 }
 117
 118 static int
 119 make_sock(void)
 120 {
 121         if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 122                 return -1;
 123         memset(&sun, 0, sizeof(sun));
 124         sun.sun_family = AF_UNIX;
 125         strlcpy(sun.sun_path, CONTROLSOCKET, sizeof(sun.sun_path));
 126         return sizeof(sun.sun_family) + strlen(sun.sun_path) + 1;
 127 }
 128
 129 int
 130 start_control(void)
 131 {
 132         int len;
 133
 134         if ((len = make_sock()) == -1)
 135                 return -1;
 136         unlink(CONTROLSOCKET);
 137         if (bind(fd, (struct sockaddr *)&sun, len) == -1 ||
 138             chmod(CONTROLSOCKET,
 139                 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP) == -1 ||
 140             set_cloexec(fd) == -1 ||
 141             set_nonblock(fd) == -1 ||
 142             listen(fd, sizeof(fds)) == -1)
 143         {
 144                 close(fd);
 145                 return -1;
 146         }
 147         add_event(fd, handle_control, NULL);
 148         return fd;
 149 }
 150
 151 int
 152 stop_control(void)
 153 {
 154         int retval = 0;
 155         struct fd_list *l, *ll;
 156
 157         delete_event(fd);
 158         if (shutdown(fd, SHUT_RDWR) == -1)
 159                 retval = 1;
 160         fd = -1;
 161         if (unlink(CONTROLSOCKET) == -1)
 162                 retval = -1;
 163
 164         l = fds;
 165         while (l != NULL) {
 166                 ll = l->next;
 167                 delete_event(l->fd);
 168                 shutdown(l->fd, SHUT_RDWR);
 169                 free(l);
 170                 l = ll;
 171         }
 172
 173         return retval;
 174 }
 175
 176 int
 177 open_control(void)
 178 {
 179         int len;
 180
 181         if ((len = make_sock()) == -1)
 182                 return -1;
 183         return connect(fd, (struct sockaddr *)&sun, len);
 184 }
 185
 186 int
 187 send_control(int argc, char * const *argv)
 188 {
 189         char *p = buffer;
 190         int i;
 191         size_t len;
 192
 193         if (argc > 255) {
 194                 errno = ENOBUFS;
 195                 return -1;
 196         }
 197         for (i = 0; i < argc; i++) {
 198                 len = strlen(argv[i]) + 1;
 199                 if ((p - buffer) + len > sizeof(buffer)) {
 200                         errno = ENOBUFS;
 201                         return -1;
 202                 }
 203                 memcpy(p, argv[i], len);
 204                 p += len;
 205         }
 206         return write(fd, buffer, p - buffer);
 207 }