zhangmeng
2024-04-22 16935f4aebffdd1b6580b844391a0aa0f4f3012b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
//
// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech>
// Copyright 2018 Capitar IT Group BV <info@capitar.com>
//
// This software is supplied under the terms of the MIT License, a
// copy of which should be located in the distribution where this
// file was obtained (LICENSE.txt).  A copy of the license may also be
// found online at https://opensource.org/licenses/MIT.
//
 
#include <nuts.h>
 
#include <nng/compat/nanomsg/nn.h>
 
    void
test_buffer_options(void)
{
    nng_socket s1;
    int        val;
    size_t     sz;
    char *     opt;
 
    char *cases[] = {
        NNG_OPT_RECVBUF,
        NNG_OPT_SENDBUF,
        NULL,
    };
 
    NUTS_PASS(nng_pair1_open(&s1));
    for (int i = 0; (opt = cases[i]) != NULL; i++) {
 
        NUTS_CASE(opt);
 
        // Can't receive a size into zero bytes.
        sz = 0;
        NUTS_FAIL(nng_socket_get(s1, opt, &val, &sz), NNG_EINVAL);
 
        // Can set a valid size
        NUTS_PASS(nng_socket_set_int(s1, opt, 1234));
        NUTS_PASS(nng_socket_get_int(s1, opt, &val));
        NUTS_TRUE(val == 1234);
 
        val = 0;
        sz  = sizeof(val);
        NUTS_PASS(nng_socket_get(s1, opt, &val, &sz));
        NUTS_TRUE(val == 1234);
        NUTS_TRUE(sz == sizeof(val));
 
        // Can't set a negative size
        NUTS_FAIL(nng_socket_set_int(s1, opt, -5), NNG_EINVAL);
 
        // Can't pass a buf too small for size
        sz  = sizeof(val) - 1;
        val = 1;
        NUTS_FAIL(nng_socket_set(s1, opt, &val, sz), NNG_EINVAL);
        // Buffer sizes are limited to sane levels
        NUTS_FAIL(nng_socket_set_int(s1, opt, 0x100000), NNG_EINVAL);
    }
    NUTS_PASS(nng_close(s1));
}
 
void
test_buffer_legacy(void)
{
    nng_socket s1;
    char *     opt;
 
    char *cases[] = {
        NNG_OPT_RECVBUF,
        NNG_OPT_SENDBUF,
        NULL,
    };
    int legacy[] = {
        NN_RCVBUF,
        NN_SNDBUF,
    };
 
    NUTS_PASS(nng_pair1_open(&s1));
    for (int i = 0; (opt = cases[i]) != NULL; i++) {
        int    cnt;
        int    os = (int) s1.id;
        size_t sz;
        int    nno = legacy[i];
 
        NUTS_CASE(opt);
 
        sz = sizeof(cnt);
        NUTS_PASS(nng_socket_set_int(s1, opt, 10));
        NUTS_TRUE(
            nn_getsockopt(os, NN_SOL_SOCKET, nno, &cnt, &sz) == 0);
        NUTS_TRUE(cnt == 10240); // 1k multiple
 
        cnt = 1;
        NUTS_TRUE(
            nn_setsockopt(os, NN_SOL_SOCKET, nno, &cnt, sz) == 0);
        NUTS_TRUE(
            nn_getsockopt(os, NN_SOL_SOCKET, nno, &cnt, &sz) == 0);
        NUTS_TRUE(cnt == 1024); // round up!
        NUTS_PASS(nng_socket_get_int(s1, opt, &cnt));
        NUTS_TRUE(cnt == 1);
 
        NUTS_TRUE(
            nn_setsockopt(os, NN_SOL_SOCKET, nno, &cnt, 100) == -1);
        NUTS_TRUE(nn_errno() == EINVAL);
    }
    NUTS_PASS(nng_close(s1));
}
 
NUTS_TESTS = {
    { "buffer options", test_buffer_options },
    { "buffer legacy", test_buffer_legacy },
    { NULL, NULL },
};