1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009-2010 The FreeBSD Foundation
5 * All rights reserved.
6 *
7 * This software was developed by Pawel Jakub Dawidek under sponsorship from
8 * the FreeBSD Foundation.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD: stable/11/sbin/hastd/proto_uds.c 330449 2018-03-05 07:26:05Z eadler $");
34
35/* UDS - UNIX Domain Socket */
36
37#include <sys/types.h>
38#include <sys/socket.h>
39#include <sys/un.h>
40
41#include <errno.h>
42#include <stdbool.h>
43#include <stdint.h>
44#include <stdio.h>
45#include <string.h>
46#include <unistd.h>
47
48#include "pjdlog.h"
49#include "proto_impl.h"
50
51#define	UDS_CTX_MAGIC	0xd541c
52struct uds_ctx {
53	int			uc_magic;
54	struct sockaddr_un	uc_sun;
55	int			uc_fd;
56	int			uc_side;
57#define	UDS_SIDE_CLIENT		0
58#define	UDS_SIDE_SERVER_LISTEN	1
59#define	UDS_SIDE_SERVER_WORK	2
60	pid_t			uc_owner;
61};
62
63static void uds_close(void *ctx);
64
65static int
66uds_addr(const char *addr, struct sockaddr_un *sunp)
67{
68
69	if (addr == NULL)
70		return (-1);
71
72	if (strncasecmp(addr, "uds://", 6) == 0)
73		addr += 6;
74	else if (strncasecmp(addr, "unix://", 7) == 0)
75		addr += 7;
76	else if (addr[0] == '/' &&	/* If it starts from /... */
77	    strstr(addr, "://") == NULL)/* ...and there is no prefix... */
78		;			/* ...we assume its us. */
79	else
80		return (-1);
81
82	sunp->sun_family = AF_UNIX;
83	if (strlcpy(sunp->sun_path, addr, sizeof(sunp->sun_path)) >=
84	    sizeof(sunp->sun_path)) {
85		return (ENAMETOOLONG);
86	}
87	sunp->sun_len = SUN_LEN(sunp);
88
89	return (0);
90}
91
92static int
93uds_common_setup(const char *addr, void **ctxp, int side)
94{
95	struct uds_ctx *uctx;
96	int ret;
97
98	uctx = malloc(sizeof(*uctx));
99	if (uctx == NULL)
100		return (errno);
101
102	/* Parse given address. */
103	if ((ret = uds_addr(addr, &uctx->uc_sun)) != 0) {
104		free(uctx);
105		return (ret);
106	}
107
108	uctx->uc_fd = socket(AF_UNIX, SOCK_STREAM, 0);
109	if (uctx->uc_fd == -1) {
110		ret = errno;
111		free(uctx);
112		return (ret);
113	}
114
115	uctx->uc_side = side;
116	uctx->uc_owner = 0;
117	uctx->uc_magic = UDS_CTX_MAGIC;
118	*ctxp = uctx;
119
120	return (0);
121}
122
123static int
124uds_client(const char *srcaddr, const char *dstaddr, void **ctxp)
125{
126	int ret;
127
128	ret = uds_common_setup(dstaddr, ctxp, UDS_SIDE_CLIENT);
129	if (ret != 0)
130		return (ret);
131
132	PJDLOG_ASSERT(srcaddr == NULL);
133
134	return (0);
135}
136
137static int
138uds_connect(void *ctx, int timeout)
139{
140	struct uds_ctx *uctx = ctx;
141
142	PJDLOG_ASSERT(uctx != NULL);
143	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
144	PJDLOG_ASSERT(uctx->uc_side == UDS_SIDE_CLIENT);
145	PJDLOG_ASSERT(uctx->uc_fd >= 0);
146	PJDLOG_ASSERT(timeout >= -1);
147
148	if (connect(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun,
149	    sizeof(uctx->uc_sun)) == -1) {
150		return (errno);
151	}
152
153	return (0);
154}
155
156static int
157uds_connect_wait(void *ctx, int timeout)
158{
159	struct uds_ctx *uctx = ctx;
160
161	PJDLOG_ASSERT(uctx != NULL);
162	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
163	PJDLOG_ASSERT(uctx->uc_side == UDS_SIDE_CLIENT);
164	PJDLOG_ASSERT(uctx->uc_fd >= 0);
165	PJDLOG_ASSERT(timeout >= 0);
166
167	return (0);
168}
169
170static int
171uds_server(const char *addr, void **ctxp)
172{
173	struct uds_ctx *uctx;
174	int ret;
175
176	ret = uds_common_setup(addr, ctxp, UDS_SIDE_SERVER_LISTEN);
177	if (ret != 0)
178		return (ret);
179
180	uctx = *ctxp;
181
182	(void)unlink(uctx->uc_sun.sun_path);
183	if (bind(uctx->uc_fd, (struct sockaddr *)&uctx->uc_sun,
184	    sizeof(uctx->uc_sun)) == -1) {
185		ret = errno;
186		uds_close(uctx);
187		return (ret);
188	}
189	uctx->uc_owner = getpid();
190	if (listen(uctx->uc_fd, 8) == -1) {
191		ret = errno;
192		uds_close(uctx);
193		return (ret);
194	}
195
196	return (0);
197}
198
199static int
200uds_accept(void *ctx, void **newctxp)
201{
202	struct uds_ctx *uctx = ctx;
203	struct uds_ctx *newuctx;
204	socklen_t fromlen;
205	int ret;
206
207	PJDLOG_ASSERT(uctx != NULL);
208	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
209	PJDLOG_ASSERT(uctx->uc_side == UDS_SIDE_SERVER_LISTEN);
210	PJDLOG_ASSERT(uctx->uc_fd >= 0);
211
212	newuctx = malloc(sizeof(*newuctx));
213	if (newuctx == NULL)
214		return (errno);
215
216	fromlen = sizeof(newuctx->uc_sun);
217	newuctx->uc_fd = accept(uctx->uc_fd,
218	    (struct sockaddr *)&newuctx->uc_sun, &fromlen);
219	if (newuctx->uc_fd == -1) {
220		ret = errno;
221		free(newuctx);
222		return (ret);
223	}
224
225	newuctx->uc_side = UDS_SIDE_SERVER_WORK;
226	newuctx->uc_magic = UDS_CTX_MAGIC;
227	*newctxp = newuctx;
228
229	return (0);
230}
231
232static int
233uds_send(void *ctx, const unsigned char *data, size_t size, int fd)
234{
235	struct uds_ctx *uctx = ctx;
236
237	PJDLOG_ASSERT(uctx != NULL);
238	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
239	PJDLOG_ASSERT(uctx->uc_fd >= 0);
240
241	return (proto_common_send(uctx->uc_fd, data, size, fd));
242}
243
244static int
245uds_recv(void *ctx, unsigned char *data, size_t size, int *fdp)
246{
247	struct uds_ctx *uctx = ctx;
248
249	PJDLOG_ASSERT(uctx != NULL);
250	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
251	PJDLOG_ASSERT(uctx->uc_fd >= 0);
252
253	return (proto_common_recv(uctx->uc_fd, data, size, fdp));
254}
255
256static int
257uds_descriptor(const void *ctx)
258{
259	const struct uds_ctx *uctx = ctx;
260
261	PJDLOG_ASSERT(uctx != NULL);
262	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
263
264	return (uctx->uc_fd);
265}
266
267static void
268uds_local_address(const void *ctx, char *addr, size_t size)
269{
270	const struct uds_ctx *uctx = ctx;
271	struct sockaddr_un sun;
272	socklen_t sunlen;
273
274	PJDLOG_ASSERT(uctx != NULL);
275	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
276	PJDLOG_ASSERT(addr != NULL);
277
278	sunlen = sizeof(sun);
279	if (getsockname(uctx->uc_fd, (struct sockaddr *)&sun, &sunlen) == -1) {
280		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
281		return;
282	}
283	PJDLOG_ASSERT(sun.sun_family == AF_UNIX);
284	if (sun.sun_path[0] == '\0') {
285		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
286		return;
287	}
288	PJDLOG_VERIFY(snprintf(addr, size, "uds://%s", sun.sun_path) < (ssize_t)size);
289}
290
291static void
292uds_remote_address(const void *ctx, char *addr, size_t size)
293{
294	const struct uds_ctx *uctx = ctx;
295	struct sockaddr_un sun;
296	socklen_t sunlen;
297
298	PJDLOG_ASSERT(uctx != NULL);
299	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
300	PJDLOG_ASSERT(addr != NULL);
301
302	sunlen = sizeof(sun);
303	if (getpeername(uctx->uc_fd, (struct sockaddr *)&sun, &sunlen) == -1) {
304		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
305		return;
306	}
307	PJDLOG_ASSERT(sun.sun_family == AF_UNIX);
308	if (sun.sun_path[0] == '\0') {
309		PJDLOG_VERIFY(strlcpy(addr, "N/A", size) < size);
310		return;
311	}
312	snprintf(addr, size, "uds://%s", sun.sun_path);
313}
314
315static void
316uds_close(void *ctx)
317{
318	struct uds_ctx *uctx = ctx;
319
320	PJDLOG_ASSERT(uctx != NULL);
321	PJDLOG_ASSERT(uctx->uc_magic == UDS_CTX_MAGIC);
322
323	if (uctx->uc_fd >= 0)
324		close(uctx->uc_fd);
325	/*
326	 * Unlink the socket only if we are the owner and this is descriptor
327	 * we listen on.
328	 */
329	if (uctx->uc_side == UDS_SIDE_SERVER_LISTEN &&
330	    uctx->uc_owner == getpid()) {
331		PJDLOG_ASSERT(uctx->uc_sun.sun_path[0] != '\0');
332		if (unlink(uctx->uc_sun.sun_path) == -1) {
333			pjdlog_errno(LOG_WARNING,
334			    "Unable to unlink socket file %s",
335			    uctx->uc_sun.sun_path);
336		}
337	}
338	uctx->uc_owner = 0;
339	uctx->uc_magic = 0;
340	free(uctx);
341}
342
343static struct proto uds_proto = {
344	.prt_name = "uds",
345	.prt_client = uds_client,
346	.prt_connect = uds_connect,
347	.prt_connect_wait = uds_connect_wait,
348	.prt_server = uds_server,
349	.prt_accept = uds_accept,
350	.prt_send = uds_send,
351	.prt_recv = uds_recv,
352	.prt_descriptor = uds_descriptor,
353	.prt_local_address = uds_local_address,
354	.prt_remote_address = uds_remote_address,
355	.prt_close = uds_close
356};
357
358static __constructor void
359uds_ctor(void)
360{
361
362	proto_register(&uds_proto, false);
363}
364