udscs.c

   1 /*  udscs.c Unix Domain Socket Client Server framework. A framework for quickly
   2     creating select() based servers capable of handling multiple clients and
   3     matching select() based clients using variable size messages.
   4
   5     Copyright 2010 Red Hat, Inc.
   6
   7     Red Hat Authors:
   8     Hans de Goede <hdegoede@redhat.com>
   9
  10     This program is free software: you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation, either version 3 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <sys/socket.h>
  30 #include <sys/un.h>
  31 #include "udscs.h"
  32
  33 struct udscs_buf {
  34     uint8_t *buf;
  35     size_t pos;
  36     size_t size;
  37
  38     struct udscs_buf *next;
  39 };
  40
  41 struct udscs_connection {
  42     int fd;
  43
  44     /* Read stuff, single buffer, separate header and data buffer */
  45     int header_read;
  46     struct udscs_message_header header;
  47     struct udscs_buf data;
  48
  49     /* Writes are stored in a linked list of buffers, with both the header
  50        + data for a single message in 1 buffer. */
  51     struct udscs_buf *write_buf;
  52
  53     /* Callbacks */
  54     udscs_read_callback read_callback;
  55     udscs_disconnect_callback disconnect_callback;
  56
  57     struct udscs_connection *next;
  58     struct udscs_connection *prev;
  59 };
  60
  61 struct udscs_server {
  62     int fd;
  63     struct udscs_connection connections_head;
  64     udscs_read_callback read_callback;
  65     udscs_disconnect_callback disconnect_callback;
  66 };
  67
  68 static void udscs_do_write(struct udscs_connection **connp);
  69 static void udscs_do_read(struct udscs_connection **connp);
  70
  71
  72 struct udscs_server *udscs_create_server(const char *socketname,
  73     udscs_read_callback read_callback,
  74     udscs_disconnect_callback disconnect_callback)
  75 {
  76     int c;
  77     struct sockaddr_un address;
  78     struct udscs_server *server;
  79
  80     server = calloc(1, sizeof(*server));
  81     if (!server)
  82         return NULL;
  83
  84     server->fd = socket(PF_UNIX, SOCK_STREAM, 0);
  85     if (server->fd == -1) {
  86         perror("creating unix domain socket");
  87         free(server);
  88         return NULL;
  89     }
  90
  91     c = unlink(socketname);
  92     if (c != 0 && errno != ENOENT) {
  93         fprintf(stderr, "unlink %s: %s\n", socketname, strerror(errno));
  94         free(server);
  95         return NULL;
  96     }
  97
  98     address.sun_family = AF_UNIX;
  99     snprintf(address.sun_path, sizeof(address.sun_path), "%s", socketname);
 100     c = bind(server->fd, (struct sockaddr *)&address, sizeof(address));
 101     if (c != 0) {
 102         fprintf(stderr, "bind %s: %s\n", socketname, strerror(errno));
 103         free(server);
 104         return NULL;
 105     }
 106
 107     c = listen(server->fd, 5);
 108     if (c != 0) {
 109         perror("listen");
 110         free(server);
 111         return NULL;
 112     }
 113
 114     server->read_callback = read_callback;
 115     server->disconnect_callback = disconnect_callback;
 116
 117     return server;
 118 }
 119
 120 void udscs_destroy_server(struct udscs_server *server)
 121 {
 122     struct udscs_connection *conn, *next_conn;
 123
 124     conn = server->connections_head.next;
 125     while (conn) {
 126         next_conn = conn->next;
 127         udscs_destroy_connection(&conn);
 128         conn = next_conn;
 129     }
 130     close(server->fd);
 131     free(server);
 132 }
 133
 134 struct udscs_connection *udscs_connect(const char *socketname,
 135     udscs_read_callback read_callback,
 136     udscs_disconnect_callback disconnect_callback)
 137 {
 138     int c;
 139     struct sockaddr_un address;
 140     struct udscs_connection *conn;
 141
 142     conn = calloc(1, sizeof(*conn));
 143     if (!conn)
 144         return NULL;
 145
 146     conn->fd = socket(PF_UNIX, SOCK_STREAM, 0);
 147     if (conn->fd == -1) {
 148         perror("creating unix domain socket");
 149         free(conn);
 150         return NULL;
 151     }
 152
 153     address.sun_family = AF_UNIX;
 154     snprintf(address.sun_path, sizeof(address.sun_path), "%s", socketname);
 155     c = connect(conn->fd, (struct sockaddr *)&address, sizeof(address));
 156     if (c != 0) {
 157         fprintf(stderr, "connect %s: %s\n", socketname, strerror(errno));
 158         free(conn);
 159         return NULL;
 160     }
 161
 162     conn->read_callback = read_callback;
 163     conn->disconnect_callback = disconnect_callback;
 164
 165     return conn;
 166 }
 167
 168 void udscs_destroy_connection(struct udscs_connection **connp)
 169 {
 170     struct udscs_buf *wbuf, *next_wbuf;
 171     struct udscs_connection *conn = *connp;
 172
 173     if (conn->disconnect_callback)
 174         conn->disconnect_callback(conn);
 175
 176     wbuf = conn->write_buf;
 177     while (wbuf) {
 178         next_wbuf = wbuf->next;
 179         free(wbuf->buf);
 180         free(wbuf);
 181         wbuf = next_wbuf;
 182     }
 183
 184     free(conn->data.buf);
 185
 186     if (conn->prev)
 187         conn->prev->next = conn->next;
 188
 189     close(conn->fd);
 190     free(conn);
 191     *connp = NULL;
 192 }
 193
 194 int udscs_server_fill_fds(struct udscs_server *server, fd_set *readfds,
 195         fd_set *writefds)
 196 {
 197     struct udscs_connection *conn;
 198     int nfds = server->fd + 1;
 199
 200     FD_SET(server->fd, readfds);
 201
 202     conn = server->connections_head.next;
 203     while (conn) {
 204         int conn_nfds = udscs_client_fill_fds(conn, readfds, writefds);
 205         if (conn_nfds > nfds)
 206             nfds = conn_nfds;
 207
 208         conn = conn->next;
 209     }
 210
 211     return nfds;
 212 }
 213
 214 int udscs_client_fill_fds(struct udscs_connection *conn, fd_set *readfds,
 215         fd_set *writefds)
 216 {
 217     FD_SET(conn->fd, readfds);
 218     if (conn->write_buf)
 219         FD_SET(conn->fd, writefds);
 220
 221     return conn->fd + 1;
 222 }
 223
 224 static void udscs_server_accept(struct udscs_server *server) {
 225     struct udscs_connection *new_conn, *conn;
 226     struct sockaddr_un address;
 227     socklen_t address_length = sizeof(address);
 228     int fd;
 229
 230     fd = accept(server->fd, (struct sockaddr *)&address, &address_length);
 231     if (fd == -1) {
 232         if (errno == EINTR)
 233             return;
 234         perror("accept");
 235         return;
 236     }
 237
 238     new_conn = calloc(1, sizeof(*conn));
 239     if (!new_conn) {
 240         fprintf(stderr, "out of memory, disconnecting client\n");
 241         close(fd);
 242         return;
 243     }
 244
 245     new_conn->fd = fd;
 246     new_conn->read_callback = server->read_callback;
 247     new_conn->disconnect_callback = server->disconnect_callback;
 248
 249     conn = &server->connections_head;
 250     while (conn->next)
 251         conn = conn->next;
 252
 253     new_conn->prev = conn;
 254     conn->next = new_conn;
 255 }
 256
 257 void udscs_server_handle_fds(struct udscs_server *server, fd_set *readfds,
 258         fd_set *writefds)
 259 {
 260     struct udscs_connection *conn, *next_conn;
 261
 262     if (FD_ISSET(server->fd, readfds))
 263         udscs_server_accept(server);
 264
 265     conn = server->connections_head.next;
 266     while (conn) {
 267         /* conn maybe destroyed by udscs_client_handle_fds (when disconnected),
 268            so get the next connection first. */
 269         next_conn = conn->next;
 270         udscs_client_handle_fds(&conn, readfds, writefds);
 271         conn = next_conn;
 272     }
 273 }
 274
 275 void udscs_client_handle_fds(struct udscs_connection **connp, fd_set *readfds,
 276         fd_set *writefds)
 277 {
 278     if (FD_ISSET((*connp)->fd, readfds))
 279         udscs_do_read(connp);
 280
 281     if (*connp && FD_ISSET((*connp)->fd, writefds))
 282         udscs_do_write(connp);
 283 }
 284
 285 int udscs_write(struct udscs_connection *conn,
 286         struct udscs_message_header *header, const uint8_t *data)
 287 {
 288     struct udscs_buf *wbuf, *new_wbuf;
 289
 290     new_wbuf = malloc(sizeof(*new_wbuf));
 291     if (!new_wbuf)
 292         return -1;
 293
 294     new_wbuf->pos = 0;
 295     new_wbuf->size = sizeof(*header) + header->size;
 296     new_wbuf->next = NULL;
 297     new_wbuf->buf = malloc(new_wbuf->size);
 298     if (!new_wbuf->buf) {
 299         free(new_wbuf);
 300         return -1;
 301     }
 302
 303     memcpy(new_wbuf->buf, header, sizeof(*header));
 304     memcpy(new_wbuf->buf + sizeof(*header), data, header->size);
 305
 306     if (!conn->write_buf) {
 307         conn->write_buf = new_wbuf;
 308         return 0;
 309     }
 310
 311     /* FIXME maybe limit the write_buf stack depth ? */
 312     wbuf = conn->write_buf;
 313     while (wbuf->next)
 314         wbuf = wbuf->next;
 315
 316     wbuf->next = wbuf;
 317
 318     return 0;
 319 }
 320
 321 int udscs_server_write_all(struct udscs_server *server,
 322         struct udscs_message_header *header, const uint8_t *data)
 323 {
 324     struct udscs_connection *conn;
 325
 326     conn = server->connections_head.next;
 327     while (conn) {
 328         if (udscs_write(conn, header, data))
 329             return -1;
 330         conn = conn->next;
 331     }
 332
 333     return 0;
 334 }
 335
 336 static void udscs_do_read(struct udscs_connection **connp)
 337 {
 338     ssize_t n;
 339     size_t to_read;
 340     uint8_t *dest;
 341     int r;
 342     struct udscs_connection *conn = *connp;
 343
 344     if (conn->header_read < sizeof(conn->header)) {
 345         to_read = sizeof(conn->header) - conn->header_read;
 346         dest = (uint8_t *)&conn->header + conn->header_read;
 347     } else {
 348         to_read = conn->data.size - conn->data.pos;
 349         dest = conn->data.buf + conn->data.pos;
 350     }
 351
 352     n = read(conn->fd, dest, to_read);
 353     if (n < 0) {
 354         if (errno == EINTR)
 355             return;
 356         perror("reading from unix domain socket");
 357     }
 358     if (n <= 0) {
 359         udscs_destroy_connection(connp);
 360         return;
 361     }
 362
 363     if (conn->header_read < sizeof(conn->header)) {
 364         conn->header_read += n;
 365         if (conn->header_read == sizeof(conn->header)) {
 366             if (conn->header.size == 0) {
 367                 if (conn->read_callback) {
 368                     r = conn->read_callback(conn, &conn->header, NULL);
 369                     if (r == -1) {
 370                         udscs_destroy_connection(connp);
 371                         return;
 372                     }
 373                 }
 374                 conn->header_read = 0;
 375             } else {
 376                 conn->data.pos = 0;
 377                 conn->data.size = conn->header.size;
 378                 conn->data.buf = malloc(conn->data.size);
 379                 if (!conn->data.buf) {
 380                     fprintf(stderr, "out of memory, disconnecting client\n");
 381                     udscs_destroy_connection(connp);
 382                     return;
 383                 }
 384             }
 385         }
 386     } else {
 387         conn->data.pos += n;
 388         if (conn->data.pos == conn->data.size) {
 389             if (conn->read_callback) {
 390                 r = conn->read_callback(conn, &conn->header, conn->data.buf);
 391                 if (r == -1) {
 392                     udscs_destroy_connection(connp);
 393                     return;
 394                 }
 395             }
 396             free(conn->data.buf);
 397             conn->header_read = 0;
 398             memset(&conn->data, 0, sizeof(conn->data));
 399         }
 400     }
 401 }
 402
 403 static void udscs_do_write(struct udscs_connection **connp)
 404 {
 405     ssize_t n;
 406     size_t to_write;
 407     struct udscs_connection *conn = *connp;
 408
 409     struct udscs_buf* wbuf = conn->write_buf;
 410     if (!wbuf) {
 411         fprintf(stderr,
 412                 "do_write called on a connection without a write buf ?!\n");
 413         return;
 414     }
 415
 416     to_write = wbuf->size - wbuf->pos;
 417     n = write(conn->fd, wbuf->buf + wbuf->pos, to_write);
 418     if (n < 0) {
 419         if (errno == EINTR)
 420             return;
 421         perror("writing to unix domain socket");
 422         udscs_destroy_connection(connp);
 423         return;
 424     }
 425
 426     wbuf->pos += n;
 427     if (wbuf->pos == wbuf->size) {
 428         conn->write_buf = wbuf->next;
 429         free(wbuf->buf);
 430         free(wbuf);
 431     }
 432 }