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 *conn);
  69 static void udscs_do_read(struct udscs_connection *conn);
  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 *conn)
 169 {
 170     struct udscs_buf *wbuf, *next_wbuf;
 171
 172     wbuf = conn->write_buf;
 173     while (wbuf) {
 174         next_wbuf = wbuf->next;
 175         free(wbuf->buf);
 176         free(wbuf);
 177         wbuf = next_wbuf;
 178     }
 179
 180     free(conn->data.buf);
 181
 182     if (conn->prev)
 183         conn->prev->next = conn->next;
 184
 185     close(conn->fd);
 186     free(conn);
 187 }
 188
 189 int udscs_server_fill_fds(struct udscs_server *server, fd_set *readfds,
 190         fd_set *writefds)
 191 {
 192     struct udscs_connection *conn;
 193     int nfds = server->fd + 1;
 194
 195     FD_SET(server->fd, readfds);
 196
 197     conn = server->connections_head.next;
 198     while (conn) {
 199         int conn_nfds = udscs_client_fill_fds(conn, readfds, writefds);
 200         if (conn_nfds > nfds)
 201             nfds = conn_nfds;
 202
 203         conn = conn->next;
 204     }
 205
 206     return nfds;
 207 }
 208
 209 int udscs_client_fill_fds(struct udscs_connection *conn, fd_set *readfds,
 210         fd_set *writefds)
 211 {
 212     FD_SET(conn->fd, readfds);
 213     if (conn->write_buf)
 214         FD_SET(conn->fd, writefds);
 215
 216     return conn->fd + 1;
 217 }
 218
 219 static void udscs_server_accept(struct udscs_server *server) {
 220     struct udscs_connection *new_conn, *conn;
 221     struct sockaddr_un address;
 222     socklen_t address_length = sizeof(address);
 223     int fd;
 224
 225     fd = accept(server->fd, (struct sockaddr *)&address, &address_length);
 226     if (fd == -1) {
 227         if (errno == EINTR)
 228             return;
 229         perror("accept");
 230         return;
 231     }
 232
 233     new_conn = calloc(1, sizeof(*conn));
 234     if (!new_conn) {
 235         fprintf(stderr, "out of memory, disconnecting client\n");
 236         close(fd);
 237         return;
 238     }
 239
 240     new_conn->fd = fd;
 241     new_conn->read_callback = server->read_callback;
 242     new_conn->disconnect_callback = server->disconnect_callback;
 243
 244     conn = &server->connections_head;
 245     while (conn->next)
 246         conn = conn->next;
 247
 248     new_conn->prev = conn;
 249     conn->next = new_conn;
 250 }
 251
 252 void udscs_server_handle_fds(struct udscs_server *server, fd_set *readfds,
 253         fd_set *writefds)
 254 {
 255     struct udscs_connection *conn;
 256
 257     if (FD_ISSET(server->fd, readfds))
 258         udscs_server_accept(server);
 259
 260     conn = server->connections_head.next;
 261     while (conn) {
 262         udscs_client_handle_fds(conn, readfds, writefds);
 263         conn = conn->next;
 264     }
 265 }
 266
 267 void udscs_client_handle_fds(struct udscs_connection *conn, fd_set *readfds,
 268         fd_set *writefds)
 269 {
 270     if (FD_ISSET(conn->fd, readfds))
 271         udscs_do_read(conn);
 272
 273     if (FD_ISSET(conn->fd, writefds))
 274         udscs_do_write(conn);
 275 }
 276
 277 int udscs_write(struct udscs_connection *conn,
 278         struct udscs_message_header *header, const uint8_t *data)
 279 {
 280     struct udscs_buf *wbuf, *new_wbuf;
 281
 282     new_wbuf = malloc(sizeof(*new_wbuf));
 283     if (!new_wbuf)
 284         return -1;
 285
 286     new_wbuf->pos = 0;
 287     new_wbuf->size = sizeof(*header) + header->size;
 288     new_wbuf->next = NULL;
 289     new_wbuf->buf = malloc(new_wbuf->size);
 290     if (!new_wbuf->buf) {
 291         free(new_wbuf);
 292         return -1;
 293     }
 294
 295     memcpy(new_wbuf->buf, header, sizeof(*header));
 296     memcpy(new_wbuf->buf + sizeof(*header), data, header->size);
 297
 298     if (!conn->write_buf) {
 299         conn->write_buf = new_wbuf;
 300         return 0;
 301     }
 302
 303     /* FIXME maybe limit the write_buf stack depth ? */
 304     wbuf = conn->write_buf;
 305     while (wbuf->next)
 306         wbuf = wbuf->next;
 307
 308     wbuf->next = wbuf;
 309
 310     return 0;
 311 }
 312
 313 int udscs_server_write_all(struct udscs_server *server,
 314         struct udscs_message_header *header, const uint8_t *data)
 315 {
 316     struct udscs_connection *conn;
 317
 318     conn = server->connections_head.next;
 319     while (conn) {
 320         if (udscs_write(conn, header, data))
 321             return -1;
 322         conn = conn->next;
 323     }
 324
 325     return 0;
 326 }
 327
 328 static void udscs_do_read(struct udscs_connection *conn)
 329 {
 330     ssize_t n;
 331     size_t to_read;
 332     uint8_t *dest;
 333
 334     if (conn->header_read < sizeof(conn->header)) {
 335         to_read = sizeof(conn->header) - conn->header_read;
 336         dest = (uint8_t *)&conn->header + conn->header_read;
 337     } else {
 338         to_read = conn->data.size - conn->data.pos;
 339         dest = conn->data.buf + conn->data.pos;
 340     }
 341
 342     n = read(conn->fd, dest, to_read);
 343     if (n < 0) {
 344         if (errno == EINTR)
 345             return;
 346         perror("reading from unix domain socket");
 347         if (conn->disconnect_callback)
 348             conn->disconnect_callback(conn);
 349         udscs_destroy_connection(conn);
 350         return;
 351     }
 352
 353     if (conn->header_read < sizeof(conn->header)) {
 354         conn->header_read += n;
 355         if (conn->header_read == sizeof(conn->header)) {
 356             if (conn->header.size == 0) {
 357                 if (conn->read_callback)
 358                     conn->read_callback(conn, &conn->header, NULL);
 359                 conn->header_read = 0;
 360             } else {
 361                 conn->data.pos = 0;
 362                 conn->data.size = conn->header.size;
 363                 conn->data.buf = malloc(conn->data.size);
 364                 if (!conn->data.buf) {
 365                     fprintf(stderr, "out of memory, disconnecting client\n");
 366                     if (conn->disconnect_callback)
 367                         conn->disconnect_callback(conn);
 368                     udscs_destroy_connection(conn);
 369                     return;
 370                 }
 371             }
 372         }
 373     } else {
 374         conn->data.pos += n;
 375         if (conn->data.pos == conn->data.size) {
 376             if (conn->read_callback)
 377                 conn->read_callback(conn, &conn->header, conn->data.buf);
 378             free(conn->data.buf);
 379             conn->header_read = 0;
 380             memset(&conn->data, 0, sizeof(conn->data));
 381         }
 382     }
 383 }
 384
 385 static void udscs_do_write(struct udscs_connection *conn)
 386 {
 387     ssize_t n;
 388     size_t to_write;
 389
 390     struct udscs_buf* wbuf = conn->write_buf;
 391     if (!wbuf) {
 392         fprintf(stderr,
 393                 "do_write called on a connection without a write buf ?!\n");
 394         return;
 395     }
 396
 397     to_write = wbuf->size - wbuf->pos;
 398     n = write(conn->fd, wbuf->buf + wbuf->pos, to_write);
 399     if (n < 0) {
 400         if (errno == EINTR)
 401             return;
 402         perror("writing to unix domain socket");
 403         if (conn->disconnect_callback)
 404             conn->disconnect_callback(conn);
 405         udscs_destroy_connection(conn);
 406         return;
 407     }
 408
 409     wbuf->pos += n;
 410     if (wbuf->pos == wbuf->size) {
 411         conn->write_buf = wbuf->next;
 412         free(wbuf->buf);
 413         free(wbuf);
 414     }
 415 }
 416