Code Coverage: vinyl-cache/lib/libvinyl/vus.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright 2018 UPLEX - Nils Goroll Systemoptimierung
2
 * All rights reserved.
3
 *
4
 * Author: Geoffrey Simmons <geoffrey.simmons@uplex.de>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 */
29
30
#include <sys/socket.h>
31
#include <sys/un.h>
32
33
#include <unistd.h>
34
#include <string.h>
35
#include <poll.h>
36
#include <stdio.h>
37
38
#include "vdef.h"
39
#include "vas.h"
40
#include "vus.h"
41
#include "vtcp.h"
42
43
static int
44
sun_init(struct sockaddr_un *uds, const char *path, const char **err)
45 694
{
46 694
        AN(uds);
47 694
        AN(path);
48 694
        assert(VUS_is(path));
49
50 694
        if (err)
51 571
                *err = NULL;
52
53 694
        if (vstrlen(path) + 1 > sizeof(uds->sun_path)) {
54 2
                errno = ENAMETOOLONG;
55 2
                if (err)
56 2
                        *err = "Path too long for a Unix domain socket";
57 2
                return (-1);
58 2
        }
59 692
        if (! vstrcmp(path, "@")) {
60 0
                errno = EINVAL;
61 0
                if (err)
62 0
                        *err = "The empty abstract socket name is not"
63 0
                            " supported";
64 0
                return (-1);
65 0
        }
66 692
        memset(uds->sun_path, 0, sizeof(uds->sun_path));
67 692
        if (*path == '@')
68 1
                bprintf(uds->sun_path, "%c%s", 0, path + 1);
69 691
        else
70 691
                bprintf(uds->sun_path, "%s", path);
71 692
        uds->sun_family = PF_UNIX;
72 692
        return (0);
73 692
}
74
75
int
76
VUS_resolver(const char *path, vus_resolved_f *func, void *priv,
77
             const char **err)
78 571
{
79 571
        struct sockaddr_un uds;
80 571
        int ret;
81
82 571
        AN(err);
83
84 571
        ret = sun_init(&uds, path, err);
85 571
        if (ret)
86 2
                return (ret);
87
88 569
        assert(uds.sun_path[1] != '\0');
89
90 569
        if (func != NULL)
91 569
                ret = func(priv, &uds);
92 569
        return (ret);
93 569
}
94
95
int
96
VUS_bind(const struct sockaddr_un *uds, const char **errp)
97 136
{
98 136
        int sd, e;
99 136
        socklen_t sl;
100
101 136
        sl = VUS_socklen(uds);
102
103 136
        if (errp != NULL)
104 61
                *errp = NULL;
105
106 136
        sd = socket(PF_UNIX, SOCK_STREAM, 0);
107 136
        if (sd < 0) {
108 0
                if (errp != NULL)
109 0
                        *errp = "socket(2)";
110 0
                return (-1);
111 0
        }
112
113 136
        if (unlink(uds->sun_path) != 0 && errno != ENOENT) {
114 0
                if (errp != NULL)
115 0
                        *errp = "unlink(2)";
116 0
                e = errno;
117 0
                closefd(&sd);
118 0
                errno = e;
119 0
                return (-1);
120 0
        }
121
122 136
        if (bind(sd, (const void*)uds, sl) != 0) {
123 1
                if (errp != NULL)
124 0
                        *errp = "bind(2)";
125 1
                e = errno;
126 1
                closefd(&sd);
127 1
                errno = e;
128 1
                return (-1);
129 1
        }
130 135
        return (sd);
131 136
}
132
133
int
134
VUS_connect(const char *path, int msec)
135 123
{
136 123
        int s, i;
137 123
        struct pollfd fds[1];
138 123
        struct sockaddr_un uds;
139 123
        socklen_t sl;
140
141 123
        if (path == NULL)
142 0
                return (-1);
143 123
        i = sun_init(&uds, path, NULL);
144 123
        if (i)
145 0
                return (i);
146
147 123
        assert(uds.sun_path[1] != '\0');
148
149 123
        sl = VUS_socklen(&uds);
150
151 123
        AN(sl);
152
153 123
        s = socket(PF_UNIX, SOCK_STREAM, 0);
154 123
        if (s < 0)
155 0
                return (s);
156
157
        /* Set the socket non-blocking */
158 123
        if (msec != 0)
159 123
                VTCP_nonblocking(s);
160
161 123
        i = connect(s, (const void*)&uds, sl);
162 123
        if (i == 0 && msec > 0)
163 123
                VTCP_blocking(s);
164 123
        if (i == 0)
165 123
                return (s);
166 0
        if (errno != EINPROGRESS) {
167 0
                closefd(&s);
168 0
                return (-1);
169 0
        }
170
171 0
        if (msec < 0) {
172
                /*
173
                 * Caller is responsible for waiting and
174
                 * calling VTCP_connected
175
                 */
176 0
                return (s);
177 0
        }
178
179 0
        assert(msec > 0);
180
        /* Exercise our patience, polling for write */
181 0
        fds[0].fd = s;
182 0
        fds[0].events = POLLWRNORM;
183 0
        fds[0].revents = 0;
184 0
        i = poll(fds, 1, msec);
185
186 0
        if (i == 0) {
187
                /* Timeout, close and give up */
188 0
                closefd(&s);
189 0
                errno = ETIMEDOUT;
190 0
                return (-1);
191 0
        }
192
193 0
        return (VTCP_connected(s));
194 0
}
195
196
socklen_t
197
VUS_socklen(const struct sockaddr_un *uds)
198 614
{
199 614
        socklen_t sl;
200 614
        const char *p;
201 614
        if (*uds->sun_path)
202 613
                sl = sizeof(*uds);
203 1
        else {
204 1
                p = strchr(uds->sun_path + 1, '\0');
205 1
                assert(p != NULL);
206 1
                sl = p - (const char*)uds;
207 1
        }
208 614
        assert(sl <= sizeof(*uds));
209 614
        return sl;
210 614
}