src/afb-api-ws.c

   1 /*
   2  * Copyright (C) 2015, 2016, 2017 "IoT.bzh"
   3  * Author José Bollo <jose.bollo@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #define NO_PLUGIN_VERBOSE_MACRO
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <assert.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <endian.h>
  28 #include <netdb.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32
  33 #include <systemd/sd-event.h>
  34 #include "afb-api.h"
  35 #include "afb-apiset.h"
  36 #include "afb-systemd.h"
  37 #include "afb-stub-ws.h"
  38 #include "verbose.h"
  39
  40 struct api_ws
  41 {
  42         char *path;             /* path of the object for the API */
  43         char *api;              /* api name of the interface */
  44         int fd;                 /* file descriptor */
  45         sd_event_source *listensrc; /**< systemd source for server socket */
  46         struct afb_apiset *apiset;
  47 };
  48
  49 /******************************************************************************/
  50
  51 /*
  52  * create a structure api_ws not connected to the 'path'.
  53  */
  54 static struct api_ws *api_ws_make(const char *path)
  55 {
  56         struct api_ws *api;
  57         size_t length;
  58
  59         /* allocates the structure */
  60         length = strlen(path);
  61         api = calloc(1, sizeof *api + 1 + length);
  62         if (api == NULL) {
  63                 errno = ENOMEM;
  64                 goto error;
  65         }
  66
  67         /* path is copied after the struct */
  68         api->path = (char*)(api+1);
  69         memcpy(api->path, path, length + 1);
  70
  71         /* api name is at the end of the path */
  72         while (length && path[length - 1] != '/' && path[length - 1] != ':')
  73                 length = length - 1;
  74         api->api = &api->path[length];
  75         if (api->api == NULL || !afb_api_is_valid_name(api->api, 1)) {
  76                 errno = EINVAL;
  77                 goto error2;
  78         }
  79
  80         api->fd = -1;
  81         return api;
  82
  83 error2:
  84         free(api);
  85 error:
  86         return NULL;
  87 }
  88
  89 static int api_ws_socket_unix(const char *path, int server)
  90 {
  91         int fd, rc;
  92         struct sockaddr_un addr;
  93         size_t length;
  94
  95         length = strlen(path);
  96         if (length >= 108) {
  97                 errno = ENAMETOOLONG;
  98                 return -1;
  99         }
 100
 101         if (server && path[0] != '@')
 102                 unlink(path);
 103
 104         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 105         if (fd < 0)
 106                 return fd;
 107
 108         memset(&addr, 0, sizeof addr);
 109         addr.sun_family = AF_UNIX;
 110         strcpy(addr.sun_path, path);
 111         if (addr.sun_path[0] == '@')
 112                 addr.sun_path[0] = 0; /* implement abstract sockets */
 113         if (server) {
 114                 rc = bind(fd, (struct sockaddr *) &addr, (socklen_t)(sizeof addr));
 115         } else {
 116                 rc = connect(fd, (struct sockaddr *) &addr, (socklen_t)(sizeof addr));
 117         }
 118         if (rc < 0) {
 119                 close(fd);
 120                 return rc;
 121         }
 122         return fd;
 123 }
 124
 125 static int api_ws_socket_inet(const char *path, int server)
 126 {
 127         int rc, fd;
 128         const char *service, *host, *api;
 129         struct addrinfo hint, *rai, *iai;
 130
 131         /* scan the uri */
 132         api = strrchr(path, '/');
 133         service = strrchr(path, ':');
 134         if (api == NULL || service == NULL || api < service) {
 135                 errno = EINVAL;
 136                 return -1;
 137         }
 138         host = strndupa(path, service++ - path);
 139         service = strndupa(service, api - service);
 140
 141         /* get addr */
 142         memset(&hint, 0, sizeof hint);
 143         hint.ai_family = AF_INET;
 144         hint.ai_socktype = SOCK_STREAM;
 145         rc = getaddrinfo(host, service, &hint, &rai);
 146         if (rc != 0) {
 147                 errno = EINVAL;
 148                 return -1;
 149         }
 150
 151         /* get the socket */
 152         iai = rai;
 153         while (iai != NULL) {
 154                 fd = socket(iai->ai_family, iai->ai_socktype, iai->ai_protocol);
 155                 if (fd >= 0) {
 156                         if (server) {
 157                                 rc = bind(fd, iai->ai_addr, iai->ai_addrlen);
 158                         } else {
 159                                 rc = connect(fd, iai->ai_addr, iai->ai_addrlen);
 160                         }
 161                         if (rc == 0) {
 162                                 freeaddrinfo(rai);
 163                                 return fd;
 164                         }
 165                         close(fd);
 166                 }
 167                 iai = iai->ai_next;
 168         }
 169         freeaddrinfo(rai);
 170         return -1;
 171 }
 172
 173 static int api_ws_socket(const char *path, int server)
 174 {
 175         int fd, rc;
 176
 177         /* check for systemd socket */
 178         if (0 == strncmp(path, "sd:", 3))
 179                 fd = systemd_fds_for(path + 3);
 180         else {
 181                 /* check for unix socket */
 182                 if (0 == strncmp(path, "unix:", 5))
 183                         /* unix socket */
 184                         fd = api_ws_socket_unix(path + 5, server);
 185                 else
 186                         /* inet socket */
 187                         fd = api_ws_socket_inet(path, server);
 188
 189                 if (fd >= 0 && server) {
 190                         rc = 1;
 191                         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &rc, sizeof rc);
 192                         rc = listen(fd, 5);
 193                 }
 194         }
 195         /* configure the socket */
 196         if (fd >= 0) {
 197                 fcntl(fd, F_SETFD, FD_CLOEXEC);
 198                 fcntl(fd, F_SETFL, O_NONBLOCK);
 199         }
 200         return fd;
 201 }
 202
 203 /**********************************************************************************/
 204
 205 int afb_api_ws_add_client(const char *path, struct afb_apiset *apiset, int strong)
 206 {
 207         struct api_ws *apiws;
 208         struct afb_stub_ws *stubws;
 209
 210         /* create the ws client api */
 211         apiws = api_ws_make(path);
 212         if (apiws == NULL)
 213                 goto error;
 214
 215         /* connect to the service */
 216         apiws->fd = api_ws_socket(apiws->path, 0);
 217         if (apiws->fd < 0) {
 218                 ERROR("can't connect to ws service %s", apiws->path);
 219                 goto error2;
 220         }
 221
 222         stubws = afb_stub_ws_create_client(apiws->fd, apiws->api, apiset);
 223         if (!stubws) {
 224                 ERROR("can't setup client ws service to %s", apiws->path);
 225                 goto error3;
 226         }
 227         if (afb_stub_ws_client_add(stubws, apiset) < 0) {
 228                 ERROR("can't add the client to the apiset for service %s", apiws->path);
 229                 goto error4;
 230         }
 231         free(apiws);
 232         return 0;
 233 error4:
 234         afb_stub_ws_unref(stubws);
 235 error3:
 236         close(apiws->fd);
 237 error2:
 238         free(apiws);
 239 error:
 240         return -!!strong;
 241 }
 242
 243 int afb_api_ws_add_client_strong(const char *path, struct afb_apiset *apiset)
 244 {
 245         return afb_api_ws_add_client(path, apiset, 1);
 246 }
 247
 248 int afb_api_ws_add_client_weak(const char *path, struct afb_apiset *apiset)
 249 {
 250         return afb_api_ws_add_client(path, apiset, 0);
 251 }
 252
 253 static int api_ws_server_accept_client(struct api_ws *apiws, int fd)
 254 {
 255         return -!afb_stub_ws_create_server(fd, apiws->api, apiws->apiset);
 256 }
 257
 258 static void api_ws_server_accept(struct api_ws *apiws)
 259 {
 260         int rc, fd;
 261         struct sockaddr addr;
 262         socklen_t lenaddr;
 263
 264         lenaddr = (socklen_t)sizeof addr;
 265         fd = accept(apiws->fd, &addr, &lenaddr);
 266         if (fd >= 0) {
 267                 rc = api_ws_server_accept_client(apiws, fd);
 268                 if (rc >= 0)
 269                         return;
 270                 close(fd);
 271         }
 272 }
 273
 274 static int api_ws_server_connect(struct api_ws *apiws);
 275
 276 static int api_ws_server_listen_callback(sd_event_source *src, int fd, uint32_t revents, void *closure)
 277 {
 278         struct api_ws *apiws = closure;
 279
 280         if ((revents & EPOLLIN) != 0)
 281                 api_ws_server_accept(apiws);
 282         if ((revents & EPOLLHUP) != 0)
 283                 api_ws_server_connect(apiws);
 284         return 0;
 285 }
 286
 287 static void api_ws_server_disconnect(struct api_ws *apiws)
 288 {
 289         if (apiws->listensrc != NULL) {
 290                 sd_event_source_unref(apiws->listensrc);
 291                 apiws->listensrc = NULL;
 292         }
 293         if (apiws->fd >= 0) {
 294                 close(apiws->fd);
 295                 apiws->fd = -1;
 296         }
 297 }
 298
 299 static int api_ws_server_connect(struct api_ws *apiws)
 300 {
 301         int rc;
 302
 303         /* ensure disconnected */
 304         api_ws_server_disconnect(apiws);
 305
 306         /* request the service object name */
 307         apiws->fd = api_ws_socket(apiws->path, 1);
 308         if (apiws->fd < 0)
 309                 ERROR("can't create socket %s", apiws->path);
 310         else {
 311                 /* listen for service */
 312                 rc = sd_event_add_io(afb_systemd_get_event_loop(),
 313                                 &apiws->listensrc, apiws->fd, EPOLLIN,
 314                                 api_ws_server_listen_callback, apiws);
 315                 if (rc >= 0)
 316                         return 0;
 317                 close(apiws->fd);
 318                 errno = -rc;
 319                 ERROR("can't add ws object %s", apiws->path);
 320         }
 321         return -1;
 322 }
 323
 324 /* create the service */
 325 int afb_api_ws_add_server(const char *path, struct afb_apiset *apiset)
 326 {
 327         int rc;
 328         struct api_ws *apiws;
 329
 330         /* creates the ws api object */
 331         apiws = api_ws_make(path);
 332         if (apiws == NULL)
 333                 goto error;
 334
 335         /* check api name */
 336         if (!afb_apiset_lookup(apiset, apiws->api, 1)) {
 337                 ERROR("Can't provide ws-server for %s: API %s doesn't exist", path, apiws->api);
 338                 goto error2;
 339         }
 340
 341         /* connect for serving */
 342         rc = api_ws_server_connect(apiws);
 343         if (rc < 0)
 344                 goto error2;
 345
 346         apiws->apiset = afb_apiset_addref(apiset);
 347         return 0;
 348
 349 error2:
 350         free(apiws);
 351 error:
 352         return -1;
 353 }
 354
 355