drm-lease-manager/lease-server.c

   1 /* Copyright 2020-2021 IGEL Co., Ltd.
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include "lease-server.h"
  17 #include "log.h"
  18 #include "socket-path.h"
  19
  20 #include <assert.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <poll.h>
  24 #include <stdlib.h>
  25 #include <sys/epoll.h>
  26 #include <sys/file.h>
  27 #include <sys/socket.h>
  28 #include <sys/stat.h>
  29 #include <sys/types.h>
  30 #include <sys/un.h>
  31 #include <unistd.h>
  32
  33 #define SOCK_LOCK_SUFFIX ".lock"
  34
  35 /* ACTIVE_CLIENTS
  36  * An 'active' client is one that either
  37  *  - owns a lease, or
  38  *  - is requesting ownership of a lease (which will
  39  *    disconnect the current owner if granted)
  40  *
  41  * There can only be at most one of each kind of client at the same
  42  * time. Any other client connections are queued in the
  43  * listen() backlog, waiting to be accept()'ed.
  44  */
  45 #define ACTIVE_CLIENTS 2
  46
  47 struct ls_socket {
  48         int fd;
  49         bool is_server;
  50         union {
  51                 struct ls_server *server;
  52                 struct ls_client *client;
  53         };
  54 };
  55
  56 struct ls_client {
  57         struct ls_socket socket;
  58         struct ls_server *serv;
  59         bool is_connected;
  60 };
  61
  62 struct ls_server {
  63         struct lease_handle *lease_handle;
  64         struct sockaddr_un address;
  65         int server_socket_lock;
  66
  67         struct ls_socket listen;
  68         struct ls_client clients[ACTIVE_CLIENTS];
  69 };
  70
  71 struct ls {
  72         int epoll_fd;
  73
  74         struct ls_server *servers;
  75         int nservers;
  76 };
  77
  78 static struct ls_client *client_connect(struct ls *ls, struct ls_server *serv)
  79 {
  80         int cfd = accept(serv->listen.fd, NULL, NULL);
  81         if (cfd < 0) {
  82                 DEBUG_LOG("accept failed on %s: %s\n", serv->address.sun_path,
  83                           strerror(errno));
  84                 return NULL;
  85         }
  86
  87         struct ls_client *client = NULL;
  88
  89         for (int i = 0; i < ACTIVE_CLIENTS; i++) {
  90                 client = &serv->clients[i];
  91                 if (!client->is_connected)
  92                         break;
  93         }
  94         if (!client) {
  95                 close(cfd);
  96                 return NULL;
  97         }
  98
  99         client->socket.fd = cfd;
 100
 101         struct epoll_event ev = {
 102             .events = POLLHUP,
 103             .data.ptr = &client->socket,
 104         };
 105         if (epoll_ctl(ls->epoll_fd, EPOLL_CTL_ADD, cfd, &ev)) {
 106                 DEBUG_LOG("epoll_ctl add failed: %s\n", strerror(errno));
 107                 close(cfd);
 108                 return NULL;
 109         }
 110
 111         client->is_connected = true;
 112         return client;
 113 }
 114
 115 static int create_socket_lock(struct sockaddr_un *addr)
 116 {
 117         int lock_fd;
 118
 119         int lockfile_len = sizeof(addr->sun_path) + sizeof(SOCK_LOCK_SUFFIX);
 120         char lockfile[lockfile_len];
 121         int len = snprintf(lockfile, lockfile_len, "%s%s", addr->sun_path,
 122                            SOCK_LOCK_SUFFIX);
 123
 124         if (len < 0 || len >= lockfile_len) {
 125                 DEBUG_LOG("Can't create socket lock filename\n");
 126                 return -1;
 127         }
 128
 129         lock_fd = open(lockfile, O_CREAT | O_RDWR,
 130                        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
 131
 132         if (lock_fd < 0) {
 133                 ERROR_LOG("Cannot access runtime directory\n");
 134                 return -1;
 135         }
 136
 137         if (flock(lock_fd, LOCK_EX | LOCK_NB)) {
 138                 ERROR_LOG(
 139                     "socket %s: in use.  Possible duplicate lease name or "
 140                     "mutiple drm-lease-manager instances running\n",
 141                     addr->sun_path);
 142                 close(lock_fd);
 143                 return -1;
 144         }
 145
 146         return lock_fd;
 147 }
 148
 149 static bool server_setup(struct ls *ls, struct ls_server *serv,
 150                          struct lease_handle *lease_handle)
 151 {
 152         struct sockaddr_un *address = &serv->address;
 153
 154         if (!sockaddr_set_lease_server_path(address, lease_handle->name))
 155                 return false;
 156
 157         int socket_lock = create_socket_lock(address);
 158         if (socket_lock < 0)
 159                 return false;
 160
 161         /* The socket address is now owned by this instance, so any existing
 162          * sockets can safely be removed */
 163         unlink(address->sun_path);
 164
 165         address->sun_family = AF_UNIX;
 166
 167         int server_socket = socket(PF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
 168         if (server_socket < 0) {
 169                 DEBUG_LOG("Socket creation failed: %s\n", strerror(errno));
 170                 return false;
 171         }
 172
 173         if (bind(server_socket, (struct sockaddr *)address, sizeof(*address))) {
 174                 ERROR_LOG("Failed to create named socket at %s: %s\n",
 175                           address->sun_path, strerror(errno));
 176                 close(server_socket);
 177                 return false;
 178         }
 179
 180         if (listen(server_socket, 0)) {
 181                 DEBUG_LOG("listen failed on %s: %s\n", address->sun_path,
 182                           strerror(errno));
 183                 close(server_socket);
 184                 unlink(address->sun_path);
 185                 return false;
 186         }
 187
 188         for (int i = 0; i < ACTIVE_CLIENTS; i++) {
 189                 struct ls_client *client = &serv->clients[i];
 190                 client->serv = serv;
 191                 client->socket.client = client;
 192         }
 193
 194         serv->lease_handle = lease_handle;
 195         serv->server_socket_lock = socket_lock;
 196
 197         serv->listen.fd = server_socket;
 198         serv->listen.server = serv;
 199         serv->listen.is_server = true;
 200
 201         struct epoll_event ev = {
 202             .events = POLLIN,
 203             .data.ptr = &serv->listen,
 204         };
 205
 206         if (epoll_ctl(ls->epoll_fd, EPOLL_CTL_ADD, server_socket, &ev)) {
 207                 DEBUG_LOG("epoll_ctl add failed: %s\n", strerror(errno));
 208                 close(server_socket);
 209                 unlink(address->sun_path);
 210                 return false;
 211         }
 212
 213         INFO_LOG("Lease server (%s) initialized at %s\n", lease_handle->name,
 214                  address->sun_path);
 215         return true;
 216 }
 217
 218 static void server_shutdown(struct ls *ls, struct ls_server *serv)
 219 {
 220         if (unlink(serv->address.sun_path)) {
 221                 WARN_LOG("Server socket %s delete failed: %s\n",
 222                          serv->address.sun_path, strerror(errno));
 223         }
 224
 225         epoll_ctl(ls->epoll_fd, EPOLL_CTL_DEL, serv->listen.fd, NULL);
 226         close(serv->listen.fd);
 227
 228         for (int i = 0; i < ACTIVE_CLIENTS; i++)
 229                 ls_disconnect_client(ls, &serv->clients[i]);
 230
 231         close(serv->server_socket_lock);
 232 }
 233
 234 struct ls *ls_create(struct lease_handle **lease_handles, int count)
 235 {
 236         assert(lease_handles);
 237         assert(count > 0);
 238
 239         struct ls *ls = calloc(1, sizeof(struct ls));
 240         if (!ls) {
 241                 DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno));
 242                 return NULL;
 243         }
 244
 245         ls->servers = calloc(count, sizeof(struct ls_server));
 246         if (!ls->servers) {
 247                 DEBUG_LOG("Memory allocation failed: %s\n", strerror(errno));
 248                 goto err;
 249         }
 250
 251         ls->epoll_fd = epoll_create1(0);
 252         if (ls->epoll_fd < 0) {
 253                 DEBUG_LOG("epoll_create failed: %s\n", strerror(errno));
 254                 goto err;
 255         }
 256
 257         for (int i = 0; i < count; i++) {
 258                 if (!server_setup(ls, &ls->servers[i], lease_handles[i]))
 259                         goto err;
 260                 ls->nservers++;
 261         }
 262         return ls;
 263 err:
 264         ls_destroy(ls);
 265         return NULL;
 266 }
 267
 268 void ls_destroy(struct ls *ls)
 269 {
 270         assert(ls);
 271
 272         for (int i = 0; i < ls->nservers; i++)
 273                 server_shutdown(ls, &ls->servers[i]);
 274
 275         close(ls->epoll_fd);
 276         free(ls->servers);
 277         free(ls);
 278 }
 279
 280 bool ls_get_request(struct ls *ls, struct ls_req *req)
 281 {
 282         assert(ls);
 283         assert(req);
 284
 285         int request = -1;
 286         while (request < 0) {
 287                 struct epoll_event ev;
 288                 if (epoll_wait(ls->epoll_fd, &ev, 1, -1) < 0) {
 289                         if (errno == EINTR)
 290                                 continue;
 291                         DEBUG_LOG("epoll_wait failed: %s\n", strerror(errno));
 292                         return false;
 293                 }
 294
 295                 struct ls_socket *sock = ev.data.ptr;
 296                 assert(sock);
 297
 298                 struct ls_server *server;
 299                 struct ls_client *client;
 300
 301                 if (sock->is_server) {
 302                         if (!(ev.events & POLLIN))
 303                                 continue;
 304
 305                         server = sock->server;
 306                         client = client_connect(ls, server);
 307                         if (client)
 308                                 request = LS_REQ_GET_LEASE;
 309                 } else {
 310                         if (!(ev.events & POLLHUP))
 311                                 continue;
 312
 313                         client = sock->client;
 314                         server = client->serv;
 315                         request = LS_REQ_RELEASE_LEASE;
 316                 }
 317
 318                 req->lease_handle = server->lease_handle;
 319                 req->client = client;
 320                 req->type = request;
 321         }
 322         return true;
 323 }
 324
 325 bool ls_send_fd(struct ls *ls, struct ls_client *client, int fd)
 326 {
 327         assert(ls);
 328         assert(client);
 329
 330         if (fd < 0)
 331                 return false;
 332
 333         char data[1];
 334         struct iovec iov = {
 335             .iov_base = data,
 336             .iov_len = sizeof(data),
 337         };
 338
 339         char ctrl_buf[CMSG_SPACE(sizeof(int))] = {0};
 340
 341         struct msghdr msg = {
 342             .msg_iov = &iov,
 343             .msg_iovlen = 1,
 344             .msg_controllen = sizeof(ctrl_buf),
 345             .msg_control = ctrl_buf,
 346         };
 347
 348         struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
 349         cmsg->cmsg_level = SOL_SOCKET;
 350         cmsg->cmsg_type = SCM_RIGHTS;
 351         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 352         *((int *)CMSG_DATA(cmsg)) = fd;
 353
 354         struct ls_server *serv = client->serv;
 355
 356         if (sendmsg(client->socket.fd, &msg, 0) < 0) {
 357                 DEBUG_LOG("sendmsg failed on %s: %s\n", serv->address.sun_path,
 358                           strerror(errno));
 359                 return false;
 360         }
 361
 362         INFO_LOG("Lease request granted on %s\n", serv->address.sun_path);
 363         return true;
 364 }
 365
 366 void ls_disconnect_client(struct ls *ls, struct ls_client *client)
 367 {
 368         assert(ls);
 369         assert(client);
 370
 371         if (!client->is_connected)
 372                 return;
 373
 374         epoll_ctl(ls->epoll_fd, EPOLL_CTL_DEL, client->socket.fd, NULL);
 375         close(client->socket.fd);
 376         client->is_connected = false;
 377 }