t/unit/frontend/connection_test.c

   1 /*
   2  * SysDB - t/unit/frontend/connection_test.c
   3  * Copyright (C) 2014 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #if HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif /* HAVE_CONFIG_H */
  31
  32 #include "frontend/connection.h"
  33 #include "frontend/connection-private.h"
  34 #include "utils/os.h"
  35 #include "libsysdb_test.h"
  36
  37 #include "utils/strbuf.h"
  38
  39 #include <assert.h>
  40 #include <check.h>
  41
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45
  46 #include <pthread.h>
  47
  48 #include <sys/types.h>
  49 #include <sys/socket.h>
  50 #include <sys/un.h>
  51
  52 static char username[1024];
  53
  54 /*
  55  * private helper functions
  56  */
  57
  58 static void
  59 mock_conn_destroy(sdb_conn_t *conn)
  60 {
  61         if (SDB_OBJ(conn)->name)
  62                 free(SDB_OBJ(conn)->name);
  63         sdb_strbuf_destroy(conn->buf);
  64         sdb_strbuf_destroy(conn->errbuf);
  65         if (conn->fd >= 0)
  66                 close(conn->fd);
  67         if (conn->username)
  68                 free(conn->username);
  69         free(conn);
  70 } /* mock_conn_destroy */
  71
  72 static sdb_conn_t *
  73 mock_conn_create(void)
  74 {
  75         sdb_conn_t *conn;
  76
  77         char tmp_file[] = "connection_test_socket.XXXXXX";
  78
  79         conn = calloc(1, sizeof(*conn));
  80         if (! conn) {
  81                 fail("INTERNAL ERROR: failed to allocate connection object");
  82                 return NULL;
  83         }
  84
  85         SDB_OBJ(conn)->name = strdup("mock_connection");
  86         SDB_OBJ(conn)->ref_cnt = 1;
  87
  88         conn->buf = sdb_strbuf_create(0);
  89         conn->errbuf = sdb_strbuf_create(0);
  90         if ((! conn->buf) || (! conn->errbuf)) {
  91                 mock_conn_destroy(conn);
  92                 fail("INTERNAL ERROR: failed to allocate connection object");
  93                 return NULL;
  94         }
  95
  96         conn->fd = mkstemp(tmp_file);
  97         if (conn->fd < 0) {
  98                 mock_conn_destroy(conn);
  99                 fail("INTERNAL ERROR: failed to allocate connection object");
 100                 return NULL;
 101         }
 102
 103         unlink(tmp_file);
 104
 105         conn->username = strdup(username);
 106         assert(conn->username);
 107
 108         conn->cmd = SDB_CONNECTION_IDLE;
 109         conn->cmd_len = 0;
 110         return conn;
 111 } /* mock_conn_create */
 112
 113 static void
 114 mock_conn_rewind(sdb_conn_t *conn)
 115 {
 116         lseek(conn->fd, 0, SEEK_SET);
 117 } /* mock_conn_rewind */
 118
 119 static void
 120 mock_conn_truncate(sdb_conn_t *conn)
 121 {
 122         int status;
 123         lseek(conn->fd, 0, SEEK_SET);
 124         status = ftruncate(conn->fd, 0);
 125         fail_unless(status == 0,
 126                         "INTERNAL ERROR: ftruncate(%d, 0) = %d; expected: 0",
 127                         conn->fd, status);
 128 } /* mock_conn_truncate */
 129
 130 static int
 131 mock_unixsock_listener(char *socket_path)
 132 {
 133         struct sockaddr_un sa;
 134         int fd, status;
 135
 136         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 137         fail_unless(fd >= 0,
 138                         "INTERNAL ERROR: socket() = %d; expected: >=0", fd);
 139
 140         memset(&sa, 0, sizeof(sa));
 141         sa.sun_family = AF_UNIX;
 142         strncpy(sa.sun_path, socket_path, sizeof(sa.sun_path));
 143
 144         status = bind(fd, (struct sockaddr *)&sa, sizeof(sa));
 145         fail_unless(status == 0,
 146                         "INTERNAL ERROR: bind() = %d; expected: 0", status);
 147         status = listen(fd, 32);
 148         fail_unless(status == 0,
 149                         "INTERNAL ERROR: listen() = %d; expected: 0", status);
 150
 151         return fd;
 152 } /* mock_unixsock */
 153
 154 static void *
 155 mock_client(void *arg)
 156 {
 157         char *socket_path = arg;
 158
 159         struct sockaddr_un sa;
 160         int fd, check;
 161
 162         fd = socket(AF_UNIX, SOCK_STREAM, /* protocol = */ 0);
 163         fail_unless(fd >= 0,
 164                         "INTERNAL ERROR: socket() = %d; expected: >= 0", fd);
 165
 166         memset(&sa, 0, sizeof(sa));
 167         sa.sun_family = AF_UNIX;
 168         strncpy(sa.sun_path, socket_path, sizeof(sa.sun_path));
 169
 170         check = connect(fd, (struct sockaddr *)&sa, sizeof(sa));
 171         fail_unless(check == 0,
 172                         "INTERNAL ERROR: connect() = %d; expected: 0", check);
 173
 174         close(fd);
 175         return NULL;
 176 } /* mock_client */
 177
 178 static void
 179 connection_startup(sdb_conn_t *conn)
 180 {
 181         ssize_t check, expected;
 182
 183         expected = 2 * sizeof(uint32_t) + strlen(username);
 184         check = sdb_connection_send(conn, SDB_CONNECTION_STARTUP,
 185                         (uint32_t)strlen(username), username);
 186         fail_unless(check == expected,
 187                         "sdb_connection_send(STARTUP, %s) = %zi; expected: %zi",
 188                         username, check, expected);
 189
 190         mock_conn_rewind(conn);
 191         check = sdb_connection_handle(conn);
 192         fail_unless(check == expected,
 193                         "On startup: sdb_connection_handle() = %zi; expected: %zi",
 194                         check, expected);
 195
 196         fail_unless(sdb_strbuf_len(conn->errbuf) == 0,
 197                         "sdb_connection_handle() left %zu bytes in the error "
 198                         "buffer (%s); expected: 0", sdb_strbuf_len(conn->errbuf),
 199                         sdb_strbuf_string(conn->errbuf));
 200
 201         mock_conn_truncate(conn);
 202 } /* connection_startup */
 203
 204 /*
 205  * tests
 206  */
 207
 208 START_TEST(test_conn_accept)
 209 {
 210         char socket_path[] = "connection_test_socket.XXXXXX";
 211         int fd, check;
 212
 213         sdb_conn_t *conn;
 214
 215         pthread_t thr;
 216
 217         conn = sdb_connection_accept(-1);
 218         fail_unless(conn == NULL,
 219                         "sdb_connection_accept(-1) = %p; expected: NULL", conn);
 220
 221         fd = mkstemp(socket_path);
 222         unlink(socket_path);
 223         close(fd);
 224
 225         fd = mock_unixsock_listener(socket_path);
 226         check = pthread_create(&thr, /* attr = */ NULL, mock_client, socket_path);
 227         fail_unless(check == 0,
 228                         "INTERNAL ERROR: pthread_create() = %i; expected: 0", check);
 229
 230         conn = sdb_connection_accept(fd);
 231         fail_unless(conn != NULL,
 232                         "sdb_connection_accept(%d) = %p; expected: <conn>", fd, conn);
 233
 234         unlink(socket_path);
 235         sdb_connection_close(conn);
 236         sdb_object_deref(SDB_OBJ(conn));
 237         pthread_join(thr, NULL);
 238 }
 239 END_TEST
 240
 241 /* test connection setup and very basic commands */
 242 START_TEST(test_conn_setup)
 243 {
 244         sdb_conn_t *conn = mock_conn_create();
 245
 246         struct {
 247                 uint32_t code;
 248                 const char *msg;
 249                 const char *err;
 250         } golden_data[] = {
 251                 /* code == UINT32_MAX => no data will be sent */
 252                 { UINT32_MAX,             NULL,       NULL },
 253                 { SDB_CONNECTION_IDLE,    "fakedata", "Authentication required" },
 254                 { SDB_CONNECTION_PING,    NULL,       "Authentication required" },
 255                 { SDB_CONNECTION_STARTUP, username,   NULL },
 256                 { SDB_CONNECTION_PING,    NULL,       NULL },
 257                 { SDB_CONNECTION_IDLE,    NULL,       "Invalid command 0" },
 258                 { SDB_CONNECTION_PING,    "fakedata", NULL },
 259                 { SDB_CONNECTION_IDLE,    NULL,       "Invalid command 0" },
 260         };
 261
 262         size_t i;
 263
 264         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 265                 ssize_t check, expected = 0;
 266
 267                 mock_conn_truncate(conn);
 268
 269                 if (golden_data[i].code != UINT32_MAX) {
 270                         expected = 2 * sizeof(uint32_t)
 271                                 + (golden_data[i].msg ? strlen(golden_data[i].msg) : 0);
 272
 273                         check = sdb_connection_send(conn, golden_data[i].code,
 274                                         (uint32_t)(golden_data[i].msg
 275                                                 ? strlen(golden_data[i].msg) : 0),
 276                                         golden_data[i].msg);
 277                         fail_unless(check == expected,
 278                                         "sdb_connection_send(%d, %s) = %zi; expected: %zi",
 279                                         golden_data[i].code,
 280                                         golden_data[i].msg ? golden_data[i].msg : "<null>",
 281                                         check, expected);
 282                 }
 283
 284                 mock_conn_rewind(conn);
 285                 check = sdb_connection_handle(conn);
 286                 fail_unless(check == expected,
 287                                 "sdb_connection_handle() = %zi; expected: %zi",
 288                                 check, expected);
 289
 290                 fail_unless(sdb_strbuf_len(conn->buf) == 0,
 291                                 "sdb_connection_handle() left %zu bytes in the buffer; "
 292                                 "expected: 0", sdb_strbuf_len(conn->buf));
 293
 294                 if (golden_data[i].err) {
 295                         const char *err = sdb_strbuf_string(conn->errbuf);
 296                         fail_unless(strcmp(err, golden_data[i].err) == 0,
 297                                         "sdb_connection_handle(): got error '%s'; "
 298                                         "expected: '%s'", err, golden_data[i].err);
 299                 }
 300                 else
 301                         fail_unless(sdb_strbuf_len(conn->errbuf) == 0,
 302                                         "sdb_connection_handle() left %zu bytes in the error "
 303                                         "buffer (%s); expected: 0", sdb_strbuf_len(conn->errbuf),
 304                                         sdb_strbuf_string(conn->errbuf));
 305         }
 306
 307         mock_conn_destroy(conn);
 308 }
 309 END_TEST
 310
 311 /* test simple I/O on open connections */
 312 START_TEST(test_conn_io)
 313 {
 314         sdb_conn_t *conn = mock_conn_create();
 315
 316         struct {
 317                 uint32_t code;
 318                 uint32_t msg_len;
 319                 const char *msg;
 320                 size_t buf_len; /* number of bytes we expect in conn->buf */
 321                 const char *err;
 322         } golden_data[] = {
 323                 /* code == UINT32_MAX => this is a follow-up package */
 324                 { SDB_CONNECTION_PING,    20, "9876543210",  0, "Authentication required" },
 325                 { UINT32_MAX,             -1, "9876543210",  0, "Authentication required" },
 326                 { SDB_CONNECTION_PING,    10, "9876543210",  0, "Authentication required" },
 327                 { SDB_CONNECTION_IDLE,    10, "9876543210",  0, "Authentication required" },
 328                 { SDB_CONNECTION_IDLE,    20, "9876543210",  0, "Authentication required" },
 329                 { UINT32_MAX,             -1, "9876543210",  0, "Authentication required" },
 330                 { SDB_CONNECTION_STARTUP, -1, NULL,          0, NULL },
 331                 { SDB_CONNECTION_PING,    20, "9876543210", 10, NULL },
 332                 { UINT32_MAX,             -1, "9876543210",  0, NULL },
 333                 { SDB_CONNECTION_IDLE,    20, "9876543210",  0, "Invalid command 0" },
 334                 { UINT32_MAX,             -1, "9876543210",  0, "Invalid command 0" },
 335                 { SDB_CONNECTION_IDLE,    20, "9876543210",  0, "Invalid command 0" },
 336                 { UINT32_MAX,             -1, "9876543210",  0, "Invalid command 0" },
 337                 { SDB_CONNECTION_PING,    10, "9876543210",  0, NULL },
 338                 { SDB_CONNECTION_PING,    20, "9876543210", 10, NULL },
 339                 { UINT32_MAX,             -1, "9876543210",  0, NULL },
 340         };
 341
 342         size_t i;
 343
 344         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 345                 size_t msg_len = golden_data[i].msg ? strlen(golden_data[i].msg) : 0;
 346                 char buffer[2 * sizeof(uint32_t) + msg_len];
 347                 size_t offset = 0;
 348
 349                 ssize_t check;
 350
 351                 mock_conn_truncate(conn);
 352
 353                 if (golden_data[i].code == SDB_CONNECTION_STARTUP) {
 354                         connection_startup(conn);
 355                         continue;
 356                 }
 357
 358                 if (golden_data[i].code != UINT32_MAX) {
 359                         uint32_t tmp;
 360
 361                         tmp = htonl(golden_data[i].code);
 362                         memcpy(buffer, &tmp, sizeof(tmp));
 363                         tmp = htonl(golden_data[i].msg_len);
 364                         memcpy(buffer + sizeof(tmp), &tmp, sizeof(tmp));
 365
 366                         msg_len += 2 * sizeof(uint32_t);
 367                         offset += 2 * sizeof(uint32_t);
 368                 }
 369
 370                 memcpy(buffer + offset, golden_data[i].msg,
 371                                 strlen(golden_data[i].msg));
 372
 373                 check = sdb_write(conn->fd, msg_len, buffer);
 374                 fail_unless(check == (ssize_t)msg_len,
 375                                 "sdb_write(%s) = %zi; expected: %zu",
 376                                 check, msg_len);
 377
 378                 mock_conn_rewind(conn);
 379                 check = sdb_connection_handle(conn);
 380                 fail_unless(check == (ssize_t)msg_len,
 381                                 "sdb_connection_handle() = %zi; expected: %zu",
 382                                 check, msg_len);
 383
 384                 if (golden_data[i].buf_len) {
 385                         /* partial commands need to be stored in the object */
 386                         fail_unless(conn->cmd == golden_data[i].code,
 387                                         "sdb_connection_handle() set partial command "
 388                                         "to %u; expected: %u", conn->cmd, golden_data[i].code);
 389                         fail_unless(conn->cmd_len > golden_data[i].buf_len,
 390                                         "sdb_connection_handle() set partial command length "
 391                                         "to %u; expected: > %u", conn->cmd_len,
 392                                         golden_data[i].buf_len);
 393                 }
 394                 else {
 395                         fail_unless(conn->cmd == SDB_CONNECTION_IDLE,
 396                                         "sdb_connection_handle() did not reset command; "
 397                                         "got %u; expected: %u", conn->cmd, SDB_CONNECTION_IDLE);
 398                         fail_unless(conn->cmd_len == 0,
 399                                         "sdb_connection_handle() did not reset command length; "
 400                                         "got %u; expected: 0", conn->cmd_len);
 401                 }
 402
 403                 fail_unless(sdb_strbuf_len(conn->buf) == golden_data[i].buf_len,
 404                                 "sdb_connection_handle() left %zu bytes in the buffer; "
 405                                 "expected: %zu", sdb_strbuf_len(conn->buf),
 406                                 golden_data[i].buf_len);
 407
 408                 if (golden_data[i].err) {
 409                         const char *err = sdb_strbuf_string(conn->errbuf);
 410                         fail_unless(strcmp(err, golden_data[i].err) == 0,
 411                                         "sdb_connection_handle(): got error '%s'; "
 412                                         "expected: '%s'", err, golden_data[i].err);
 413                 }
 414                 else
 415                         fail_unless(sdb_strbuf_len(conn->errbuf) == 0,
 416                                         "sdb_connection_handle() left %zu bytes in the error "
 417                                         "buffer; expected: 0", sdb_strbuf_len(conn->errbuf));
 418         }
 419
 420         mock_conn_destroy(conn);
 421 }
 422 END_TEST
 423
 424 Suite *
 425 fe_conn_suite(void)
 426 {
 427         Suite *s = suite_create("frontend::connection");
 428         TCase *tc;
 429
 430         char *tmp = sdb_get_current_user();
 431         assert(tmp);
 432         strcpy(username, tmp);
 433         free(tmp);
 434
 435         tc = tcase_create("core");
 436         tcase_add_test(tc, test_conn_accept);
 437         tcase_add_test(tc, test_conn_setup);
 438         tcase_add_test(tc, test_conn_io);
 439         suite_add_tcase(s, tc);
 440
 441         return s;
 442 } /* fe_conn_suite */
 443
 444 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 445