~schuster/mysql-proxy/remove_unix_socket

« back to all changes in this revision

Viewing changes to tests/unit/t_network_socket.c

  • Committer: michael.schuster at oracle
  • Date: 2010-05-10 11:49:40 UTC
  • Revision ID: michael.schuster@oracle.com-20100510114940-10ociz5ruzvzm3h0
fix diversion

Show diffs side-by-side

added added

removed removed

Lines of Context:
37
37
#if GLIB_CHECK_VERSION(2, 16, 0)
38
38
#define C(x) x, sizeof(x) - 1
39
39
 
 
40
#ifndef WIN32
 
41
#define LOCAL_SOCK "/tmp/mysql-proxy-test.socket"
 
42
 
 
43
typedef struct {
 
44
        char    sockname[sizeof(LOCAL_SOCK) + 10];
 
45
} local_unix_t;
 
46
 
 
47
static local_unix_t     *pp = NULL;
 
48
static local_unix_t local_test_arg;
 
49
#endif /* WIN32 */
 
50
 
40
51
void test_network_socket_new() {
41
52
        network_socket *sock;
42
53
 
303
314
 
304
315
#ifndef WIN32
305
316
 
306
 
#define LOCAL_SOCK "/tmp/mysql-proxy-test.socket"
307
 
 
308
 
typedef struct {
309
 
        char    sockname[sizeof(LOCAL_SOCK) + 10];
310
 
} local_unix_t;
311
 
 
312
 
static local_unix_t     *pp = NULL;
313
 
 
314
 
void t_network_localsocket_setup(local_unix_t *p)
315
 
{
316
 
        g_assert(p != NULL);
317
 
        snprintf(p->sockname, sizeof(p->sockname), LOCAL_SOCK ".%d", (int)getpid());
318
 
        pp = p;
319
 
}
320
 
 
321
 
void t_network_localsocket_teardown(local_unix_t *p)
322
 
{
323
 
        g_assert(p != NULL);
324
 
        (void) g_unlink(p->sockname);
325
 
        pp = NULL;
326
 
}
327
 
 
328
317
/**
329
318
 * test if _is_local() works on unix-domain sockets
330
319
 *
331
320
 * MacOS X 10.4 doesn't report a .sa_family for one of the sides of the connection if it is a unix-socket 
332
321
 */
333
 
void t_network_socket_is_local_unix(local_unix_t *p)
334
 
{
 
322
void t_network_socket_is_local_unix() {
335
323
        network_socket *s_sock; /* the server side socket, listening for requests */
336
324
        network_socket *c_sock; /* the client side socket, that connects */
337
325
        network_socket *a_sock; /* the server side, accepted socket */
340
328
        g_log_set_always_fatal(G_LOG_FATAL_MASK); /* gtest modifies the fatal-mask */
341
329
 
342
330
        s_sock = network_socket_new();
343
 
        network_address_set_address(s_sock->dst, p->sockname);
 
331
        network_address_set_address(s_sock->dst, "/tmp/mysql-proxy-test.socket");
344
332
 
345
333
        c_sock = network_socket_new();
346
 
        network_address_set_address(c_sock->dst, p->sockname);
 
334
        network_address_set_address(c_sock->dst, "/tmp/mysql-proxy-test.socket");
 
335
 
347
336
 
348
337
        /* hack together a network_socket_accept() which we don't have in this tree yet */
349
338
        g_assert_cmpint(NETWORK_SOCKET_SUCCESS, ==, network_socket_bind(s_sock));
350
339
 
351
 
        g_assert_cmpint(g_access(p->sockname, 0), ==, 0);
352
 
 
353
340
        g_assert_cmpint(NETWORK_SOCKET_SUCCESS, ==, network_socket_connect(c_sock));
354
341
 
355
342
        a_sock = network_socket_accept(s_sock);
358
345
        g_assert_cmpint(TRUE, ==, network_address_is_local(s_sock->dst, a_sock->dst));
359
346
 
360
347
        network_socket_free(a_sock);
361
 
        g_assert_cmpint(g_access(p->sockname, 0), ==, 0);
362
348
        network_socket_free(c_sock);
363
 
        g_assert_cmpint(g_access(p->sockname, 0), ==, 0);
364
349
        network_socket_free(s_sock);
365
 
        g_assert_cmpint(g_access(p->sockname, 0), ==, -1);
366
 
}
367
 
#endif /* WIN32 */
368
 
 
369
 
#ifndef WIN32
370
 
local_unix_t local_test_arg;
 
350
 
 
351
        g_unlink("/tmp/mysql-proxy-test.socket");
 
352
}
 
353
 
 
354
void t_network_localsocket_setup(local_unix_t *p) {
 
355
        g_assert(p != NULL);
 
356
        snprintf(p->sockname, sizeof(p->sockname), LOCAL_SOCK ".%d", (int)getpid());
 
357
        pp = p;
 
358
}
 
359
 
 
360
void t_network_localsocket_teardown(local_unix_t *p) {
 
361
        g_assert(p != NULL);
 
362
        if (p->sockname[0] != '\0') {
 
363
                (void) g_unlink(p->sockname);
 
364
                p->sockname[0] = '\0';
 
365
        }
 
366
        pp = NULL;
 
367
}
371
368
 
372
369
void exitfunc(int sig) {
373
 
/*      printf("debug: socket name is %s (addr: %p)\n", pp->sockname, pp); */
374
370
        if (pp != NULL && pp->sockname[0] != '\0')
375
371
                (void) g_unlink(pp->sockname);
376
372
 
377
373
        abort();
378
374
}
379
375
 
380
 
#endif
381
 
 
 
376
/**
 
377
 * test if local sockets are removed at shutdown
 
378
 * this is an extension of _is_local_unix(), therefore looks much like it;
 
379
 * just in case, we leave all tests from that function in as well.
 
380
 */
 
381
void t_network_socket_rem_local_unix(local_unix_t *p) {
 
382
        network_socket *s_sock; /* the server side socket, listening for requests */
 
383
        network_socket *c_sock; /* the client side socket, that connects */
 
384
        network_socket *a_sock; /* the server side, accepted socket */
 
385
 
 
386
        /*
 
387
         * if an assertion fails, we receive the ABORT signal. We need to
 
388
         * close the unix socket in that case too. The regular teardown function
 
389
         * is not called in this case, so we install our own handler.
 
390
         */
 
391
        signal(SIGABRT, exitfunc);
 
392
        g_test_bug("42220");
 
393
        g_log_set_always_fatal(G_LOG_FATAL_MASK); /* gtest modifies the fatal-mask */
 
394
 
 
395
        s_sock = network_socket_new();
 
396
        network_address_set_address(s_sock->dst, p->sockname);
 
397
 
 
398
        c_sock = network_socket_new();
 
399
        network_address_set_address(c_sock->dst, p->sockname);
 
400
 
 
401
        g_assert_cmpint(NETWORK_SOCKET_SUCCESS, ==, network_socket_bind(s_sock));
 
402
 
 
403
        g_assert_cmpint(g_access(p->sockname, 0), ==, 0);
 
404
 
 
405
        g_assert_cmpint(NETWORK_SOCKET_SUCCESS, ==, network_socket_connect(c_sock));
 
406
 
 
407
        a_sock = network_socket_accept(s_sock);
 
408
        g_assert(a_sock);
 
409
 
 
410
        g_assert_cmpint(TRUE, ==, network_address_is_local(s_sock->dst, a_sock->dst));
 
411
 
 
412
        network_socket_free(a_sock);
 
413
        g_assert_cmpint(g_access(p->sockname, 0), ==, 0);
 
414
        network_socket_free(c_sock);
 
415
        g_assert_cmpint(g_access(p->sockname, 0), ==, 0);
 
416
        network_socket_free(s_sock);
 
417
        g_assert_cmpint(g_access(p->sockname, 0), ==, -1);
 
418
 
 
419
        /* re-establish default signal disposition */
 
420
        signal(SIGABRT, SIG_DFL);
 
421
}
 
422
 
 
423
#endif /* WIN32 */
382
424
 
383
425
int main(int argc, char **argv) {
384
 
 
385
426
        g_test_init(&argc, &argv, NULL);
386
427
        g_test_bug_base("http://bugs.mysql.com/");
387
428
 
392
433
        g_test_add_func("/core/network_queue_peek_string", test_network_queue_peek_string);
393
434
        g_test_add_func("/core/network_queue_pop_string", test_network_queue_pop_string);
394
435
#ifndef WIN32
 
436
        g_test_add_func("/core/network_socket_is_local_unix",t_network_socket_is_local_unix);
395
437
 
396
 
        g_test_add("/core/network_socket_is_local_unix", local_unix_t, &local_test_arg,
397
 
                        t_network_localsocket_setup, t_network_socket_is_local_unix, 
 
438
        g_test_add("/core/network_socket_rem_local_unix", local_unix_t,
 
439
                        &local_test_arg,
 
440
                        t_network_localsocket_setup, t_network_socket_rem_local_unix, 
398
441
                        t_network_localsocket_teardown);
399
 
 
400
 
        signal(SIGABRT, exitfunc);
401
 
        /* g_test_add_func("/core/network_socket_is_local_unix", t_network_socket_is_local_unix);*/
402
 
#endif
 
442
#endif /* WIN32 */
403
443
#if 0
404
444
        /**
405
445
         * disabled for now until we fixed the _to_read() on HP/UX and AIX (and MacOS X)