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     const char * const *type_to_string;
  44     int no_types;
  45     FILE *logfile;
  46     FILE *errfile;
  47     struct ucred peer_cred;
  48     void *user_data;
  49
  50     /* Read stuff, single buffer, separate header and data buffer */
  51     int header_read;
  52     struct udscs_message_header header;
  53     struct udscs_buf data;
  54
  55     /* Writes are stored in a linked list of buffers, with both the header
  56        + data for a single message in 1 buffer. */
  57     struct udscs_buf *write_buf;
  58
  59     /* Callbacks */
  60     udscs_read_callback read_callback;
  61     udscs_disconnect_callback disconnect_callback;
  62
  63     struct udscs_connection *next;
  64     struct udscs_connection *prev;
  65 };
  66
  67 struct udscs_server {
  68     int fd;
  69     const char * const *type_to_string;
  70     int no_types;
  71     FILE *logfile;
  72     FILE *errfile;
  73     struct udscs_connection connections_head;
  74     udscs_connect_callback connect_callback;
  75     udscs_read_callback read_callback;
  76     udscs_disconnect_callback disconnect_callback;
  77 };
  78
  79 static void udscs_do_write(struct udscs_connection **connp);
  80 static void udscs_do_read(struct udscs_connection **connp);
  81
  82
  83 struct udscs_server *udscs_create_server(const char *socketname,
  84     udscs_connect_callback connect_callback,
  85     udscs_read_callback read_callback,
  86     udscs_disconnect_callback disconnect_callback,
  87     const char * const type_to_string[], int no_types,
  88     FILE *logfile, FILE *errfile)
  89 {
  90     int c;
  91     struct sockaddr_un address;
  92     struct udscs_server *server;
  93
  94     server = calloc(1, sizeof(*server));
  95     if (!server)
  96         return NULL;
  97
  98     server->logfile = logfile;
  99     server->errfile = errfile;
 100     server->type_to_string = type_to_string;
 101     server->no_types = no_types;
 102
 103     server->fd = socket(PF_UNIX, SOCK_STREAM, 0);
 104     if (server->fd == -1) {
 105         fprintf(server->errfile, "creating unix domain socket: %s\n",
 106                 strerror(errno));
 107         free(server);
 108         return NULL;
 109     }
 110
 111     address.sun_family = AF_UNIX;
 112     snprintf(address.sun_path, sizeof(address.sun_path), "%s", socketname);
 113     c = bind(server->fd, (struct sockaddr *)&address, sizeof(address));
 114     if (c != 0) {
 115         fprintf(server->errfile, "bind %s: %s\n", socketname, strerror(errno));
 116         free(server);
 117         return NULL;
 118     }
 119
 120     c = listen(server->fd, 5);
 121     if (c != 0) {
 122         fprintf(server->errfile, "listen: %s\n", strerror(errno));
 123         free(server);
 124         return NULL;
 125     }
 126
 127     server->connect_callback = connect_callback;
 128     server->read_callback = read_callback;
 129     server->disconnect_callback = disconnect_callback;
 130
 131     return server;
 132 }
 133
 134 void udscs_destroy_server(struct udscs_server *server)
 135 {
 136     struct udscs_connection *conn, *next_conn;
 137
 138     if (!server)
 139         return;
 140
 141     conn = server->connections_head.next;
 142     while (conn) {
 143         next_conn = conn->next;
 144         udscs_destroy_connection(&conn);
 145         conn = next_conn;
 146     }
 147     close(server->fd);
 148     free(server);
 149 }
 150
 151 struct udscs_connection *udscs_connect(const char *socketname,
 152     udscs_read_callback read_callback,
 153     udscs_disconnect_callback disconnect_callback,
 154     const char * const type_to_string[], int no_types,
 155     FILE *logfile, FILE *errfile)
 156 {
 157     int c;
 158     struct sockaddr_un address;
 159     struct udscs_connection *conn;
 160
 161     conn = calloc(1, sizeof(*conn));
 162     if (!conn)
 163         return NULL;
 164
 165     conn->logfile = logfile;
 166     conn->errfile = errfile;
 167     conn->type_to_string = type_to_string;
 168     conn->no_types = no_types;
 169
 170     conn->fd = socket(PF_UNIX, SOCK_STREAM, 0);
 171     if (conn->fd == -1) {
 172         fprintf(conn->errfile, "creating unix domain socket: %s\n",
 173                 strerror(errno));
 174         free(conn);
 175         return NULL;
 176     }
 177
 178     address.sun_family = AF_UNIX;
 179     snprintf(address.sun_path, sizeof(address.sun_path), "%s", socketname);
 180     c = connect(conn->fd, (struct sockaddr *)&address, sizeof(address));
 181     if (c != 0) {
 182         fprintf(conn->errfile, "connect %s: %s\n", socketname,
 183                 strerror(errno));
 184         free(conn);
 185         return NULL;
 186     }
 187
 188     conn->read_callback = read_callback;
 189     conn->disconnect_callback = disconnect_callback;
 190
 191     if (conn->logfile)
 192         fprintf(conn->logfile, "%p connected to %s\n", conn, socketname);
 193
 194     return conn;
 195 }
 196
 197 void udscs_destroy_connection(struct udscs_connection **connp)
 198 {
 199     struct udscs_buf *wbuf, *next_wbuf;
 200     struct udscs_connection *conn = *connp;
 201
 202     if (!conn)
 203         return;
 204
 205     if (conn->disconnect_callback)
 206         conn->disconnect_callback(conn);
 207
 208     wbuf = conn->write_buf;
 209     while (wbuf) {
 210         next_wbuf = wbuf->next;
 211         free(wbuf->buf);
 212         free(wbuf);
 213         wbuf = next_wbuf;
 214     }
 215
 216     free(conn->data.buf);
 217
 218     if (conn->next)
 219         conn->next->prev = conn->prev;
 220     if (conn->prev)
 221         conn->prev->next = conn->next;
 222
 223     close(conn->fd);
 224
 225     if (conn->logfile)
 226         fprintf(conn->logfile, "%p disconnected\n", conn);
 227
 228     free(conn);
 229     *connp = NULL;
 230 }
 231
 232 struct ucred udscs_get_peer_cred(struct udscs_connection *conn)
 233 {
 234     return conn->peer_cred;
 235 }
 236
 237 int udscs_server_fill_fds(struct udscs_server *server, fd_set *readfds,
 238         fd_set *writefds)
 239 {
 240     struct udscs_connection *conn;
 241     int nfds = server->fd + 1;
 242
 243     if (!server)
 244         return -1;
 245
 246     FD_SET(server->fd, readfds);
 247
 248     conn = server->connections_head.next;
 249     while (conn) {
 250         int conn_nfds = udscs_client_fill_fds(conn, readfds, writefds);
 251         if (conn_nfds > nfds)
 252             nfds = conn_nfds;
 253
 254         conn = conn->next;
 255     }
 256
 257     return nfds;
 258 }
 259
 260 int udscs_client_fill_fds(struct udscs_connection *conn, fd_set *readfds,
 261         fd_set *writefds)
 262 {
 263     if (!conn)
 264         return -1;
 265
 266     FD_SET(conn->fd, readfds);
 267     if (conn->write_buf)
 268         FD_SET(conn->fd, writefds);
 269
 270     return conn->fd + 1;
 271 }
 272
 273 static void udscs_server_accept(struct udscs_server *server) {
 274     struct udscs_connection *new_conn, *conn;
 275     struct sockaddr_un address;
 276     socklen_t length = sizeof(address);
 277     int r, fd;
 278
 279     fd = accept(server->fd, (struct sockaddr *)&address, &length);
 280     if (fd == -1) {
 281         if (errno == EINTR)
 282             return;
 283         fprintf(server->errfile, "accept: %s\n", strerror(errno));
 284         return;
 285     }
 286
 287     new_conn = calloc(1, sizeof(*conn));
 288     if (!new_conn) {
 289         fprintf(server->errfile, "out of memory, disconnecting new client\n");
 290         close(fd);
 291         return;
 292     }
 293
 294     new_conn->fd = fd;
 295     new_conn->logfile = server->logfile;
 296     new_conn->errfile = server->errfile;
 297     new_conn->type_to_string = server->type_to_string;
 298     new_conn->no_types = server->no_types;
 299     new_conn->read_callback = server->read_callback;
 300     new_conn->disconnect_callback = server->disconnect_callback;
 301
 302     length = sizeof(new_conn->peer_cred);
 303     r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &new_conn->peer_cred, &length);
 304     if (r != 0) {
 305         fprintf(server->errfile,
 306                 "Could not get peercred, disconnecting new client\n");
 307         close(fd);
 308         free(new_conn);
 309         return;
 310     }
 311
 312     conn = &server->connections_head;
 313     while (conn->next)
 314         conn = conn->next;
 315
 316     new_conn->prev = conn;
 317     conn->next = new_conn;
 318
 319     if (server->logfile)
 320         fprintf(server->logfile, "new client accepted: %p, pid: %d\n",
 321                 new_conn, (int)new_conn->peer_cred.pid);
 322
 323     if (server->connect_callback)
 324         server->connect_callback(new_conn);
 325 }
 326
 327 void udscs_server_handle_fds(struct udscs_server *server, fd_set *readfds,
 328         fd_set *writefds)
 329 {
 330     struct udscs_connection *conn, *next_conn;
 331
 332     if (!server)
 333         return;
 334
 335     if (FD_ISSET(server->fd, readfds))
 336         udscs_server_accept(server);
 337
 338     conn = server->connections_head.next;
 339     while (conn) {
 340         /* conn maybe destroyed by udscs_client_handle_fds (when disconnected),
 341            so get the next connection first. */
 342         next_conn = conn->next;
 343         udscs_client_handle_fds(&conn, readfds, writefds);
 344         conn = next_conn;
 345     }
 346 }
 347
 348 void udscs_client_handle_fds(struct udscs_connection **connp, fd_set *readfds,
 349         fd_set *writefds)
 350 {
 351     if (!*connp)
 352         return;
 353
 354     if (FD_ISSET((*connp)->fd, readfds))
 355         udscs_do_read(connp);
 356
 357     if (*connp && FD_ISSET((*connp)->fd, writefds))
 358         udscs_do_write(connp);
 359 }
 360
 361 int udscs_write(struct udscs_connection *conn, uint32_t type, uint32_t opaque,
 362         const uint8_t *data, uint32_t size)
 363 {
 364     struct udscs_buf *wbuf, *new_wbuf;
 365     struct udscs_message_header header;
 366
 367     new_wbuf = malloc(sizeof(*new_wbuf));
 368     if (!new_wbuf)
 369         return -1;
 370
 371     new_wbuf->pos = 0;
 372     new_wbuf->size = sizeof(header) + size;
 373     new_wbuf->next = NULL;
 374     new_wbuf->buf = malloc(new_wbuf->size);
 375     if (!new_wbuf->buf) {
 376         free(new_wbuf);
 377         return -1;
 378     }
 379
 380     header.type = type;
 381     header.opaque = opaque;
 382     header.size = size;
 383
 384     memcpy(new_wbuf->buf, &header, sizeof(header));
 385     memcpy(new_wbuf->buf + sizeof(header), data, size);
 386
 387     if (conn->logfile) {
 388         if (type < conn->no_types)
 389             fprintf(conn->logfile, "%p sent %s, opaque: %u, size %u\n",
 390                     conn, conn->type_to_string[type], opaque, size);
 391         else
 392             fprintf(conn->logfile,
 393                     "%p sent invalid message %u, opaque: %u, size %u\n",
 394                     conn, type, opaque, size);
 395     }
 396
 397     if (!conn->write_buf) {
 398         conn->write_buf = new_wbuf;
 399         return 0;
 400     }
 401
 402     /* maybe we should limit the write_buf stack depth ? */
 403     wbuf = conn->write_buf;
 404     while (wbuf->next)
 405         wbuf = wbuf->next;
 406
 407     wbuf->next = new_wbuf;
 408
 409     return 0;
 410 }
 411
 412 int udscs_server_write_all(struct udscs_server *server,
 413         uint32_t type, uint32_t opaque,
 414         const uint8_t *data, uint32_t size)
 415 {
 416     struct udscs_connection *conn;
 417
 418     conn = server->connections_head.next;
 419     while (conn) {
 420         if (udscs_write(conn, type, opaque, data, size))
 421             return -1;
 422         conn = conn->next;
 423     }
 424
 425     return 0;
 426 }
 427
 428 int udscs_server_for_all_clients(struct udscs_server *server,
 429     udscs_for_all_clients_callback func, void *priv)
 430 {
 431     int r = 0;
 432     struct udscs_connection *conn, *next_conn;
 433
 434     if (!server)
 435         return 0;
 436
 437     conn = server->connections_head.next;
 438     while (conn) {
 439         /* Get next conn as func may destroy the current conn */
 440         next_conn = conn->next;
 441         r += func(&conn, priv);
 442         conn = next_conn;
 443     }
 444     return r;
 445 }
 446
 447 static void udscs_read_complete(struct udscs_connection **connp)
 448 {
 449     struct udscs_connection *conn = *connp;
 450
 451     if (conn->logfile) {
 452         if (conn->header.type < conn->no_types)
 453             fprintf(conn->logfile, "%p received %s, opaque: %u, size %u\n",
 454                     conn, conn->type_to_string[conn->header.type],
 455                     conn->header.opaque, conn->header.size);
 456         else
 457             fprintf(conn->logfile,
 458                     "%p received invalid message %u, opaque: %u, size %u\n",
 459                     conn, conn->header.type, conn->header.opaque,
 460                     conn->header.size);
 461     }
 462
 463     if (conn->read_callback) {
 464         conn->read_callback(connp, &conn->header, conn->data.buf);
 465         if (!*connp) /* Was the connection disconnected by the callback ? */
 466             return;
 467     }
 468
 469     conn->header_read = 0;
 470     memset(&conn->data, 0, sizeof(conn->data));
 471 }
 472
 473 static void udscs_do_read(struct udscs_connection **connp)
 474 {
 475     ssize_t n;
 476     size_t to_read;
 477     uint8_t *dest;
 478     struct udscs_connection *conn = *connp;
 479
 480     if (conn->header_read < sizeof(conn->header)) {
 481         to_read = sizeof(conn->header) - conn->header_read;
 482         dest = (uint8_t *)&conn->header + conn->header_read;
 483     } else {
 484         to_read = conn->data.size - conn->data.pos;
 485         dest = conn->data.buf + conn->data.pos;
 486     }
 487
 488     n = read(conn->fd, dest, to_read);
 489     if (n < 0) {
 490         if (errno == EINTR)
 491             return;
 492         fprintf(conn->errfile,
 493                 "reading unix domain socket: %s, disconnecting %p\n",
 494                 strerror(errno), conn);
 495     }
 496     if (n <= 0) {
 497         udscs_destroy_connection(connp);
 498         return;
 499     }
 500
 501     if (conn->header_read < sizeof(conn->header)) {
 502         conn->header_read += n;
 503         if (conn->header_read == sizeof(conn->header)) {
 504             if (conn->header.size == 0) {
 505                 udscs_read_complete(connp);
 506                 return;
 507             }
 508             conn->data.pos = 0;
 509             conn->data.size = conn->header.size;
 510             conn->data.buf = malloc(conn->data.size);
 511             if (!conn->data.buf) {
 512                 fprintf(conn->errfile, "out of memory, disconnecting %p\n",
 513                         conn);
 514                 udscs_destroy_connection(connp);
 515                 return;
 516             }
 517         }
 518     } else {
 519         conn->data.pos += n;
 520         if (conn->data.pos == conn->data.size)
 521             udscs_read_complete(connp);
 522     }
 523 }
 524
 525 static void udscs_do_write(struct udscs_connection **connp)
 526 {
 527     ssize_t n;
 528     size_t to_write;
 529     struct udscs_connection *conn = *connp;
 530
 531     struct udscs_buf* wbuf = conn->write_buf;
 532     if (!wbuf) {
 533         fprintf(conn->errfile,
 534                 "%p do_write called on a connection without a write buf ?!\n",
 535                 conn);
 536         return;
 537     }
 538
 539     to_write = wbuf->size - wbuf->pos;
 540     n = write(conn->fd, wbuf->buf + wbuf->pos, to_write);
 541     if (n < 0) {
 542         if (errno == EINTR)
 543             return;
 544         fprintf(conn->errfile,
 545                 "writing to unix domain socket: %s, disconnecting %p\n",
 546                 strerror(errno), conn);
 547         udscs_destroy_connection(connp);
 548         return;
 549     }
 550
 551     wbuf->pos += n;
 552     if (wbuf->pos == wbuf->size) {
 553         conn->write_buf = wbuf->next;
 554         free(wbuf->buf);
 555         free(wbuf);
 556     }
 557 }
 558
 559 void udscs_set_user_data(struct udscs_connection *conn, void *data)
 560 {
 561     conn->user_data = data;
 562 }
 563
 564 void *udscs_get_user_data(struct udscs_connection *conn)
 565 {
 566     if (!conn)
 567         return NULL;
 568
 569     return conn->user_data;
 570 }