[thirdparty/systemd.git] / socket-util.c

/*-*- Mode: C; c-basic-offset: 8 -*-*/

#include <assert.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <stdio.h>

#include "macro.h"
#include "util.h"
#include "socket-util.h"

int address_parse(Address *a, const char *s) {
        int r;
        char *e, *n;
        unsigned u;

        assert(a);
        assert(s);

        memset(a, 0, sizeof(*a));

        if (*s == '[') {
                /* IPv6 in [x:.....:z]:p notation */

                if (!(e = strchr(s+1, ']')))
                        return -EINVAL;

                if (!(n = strndup(s+1, e-s-1)))
                        return -ENOMEM;

                errno = 0;
                if (inet_pton(AF_INET6, n, &a->sockaddr.in6.sin6_addr) <= 0) {
                        free(n);
                        return errno != 0 ? -errno : -EINVAL;
                }

                free(n);

                e++;
                if (*e != ':')
                        return -EINVAL;

                e++;
                if ((r = safe_atou(e, &u)) < 0)
                        return r;

                if (u <= 0 || u > 0xFFFF)
                        return -EINVAL;

                a->sockaddr.in6.sin6_family = AF_INET6;
                a->sockaddr.in6.sin6_port = htons((uint16_t) u);
                a->size = sizeof(struct sockaddr_in6);
                a->bind_ipv6_only = true;

        } else if (*s == '/') {
                /* AF_UNIX socket */

                size_t l;

                l = strlen(s);
                if (l >= sizeof(a->sockaddr.un.sun_path))
                        return -EINVAL;

                a->sockaddr.un.sun_family = AF_UNIX;
                memcpy(a->sockaddr.un.sun_path, s, l);
                a->size = sizeof(sa_family_t) + l + 1;

        } else if (*s == '=') {
                /* Abstract AF_UNIX socket */
                size_t l;

                l = strlen(s+1);
                if (l >= sizeof(a->sockaddr.un.sun_path) - 1)
                        return -EINVAL;

                a->sockaddr.un.sun_family = AF_UNIX;
                memcpy(a->sockaddr.un.sun_path+1, s+1, l);
                a->size = sizeof(struct sockaddr_un);

        } else {

                if ((e = strchr(s, ':'))) {

                        /* IPv4 in w.x.y.z:p notation */
                        if (!(n = strndup(s, e-s)))
                                return -ENOMEM;

                        errno = 0;
                        if (inet_pton(AF_INET, n, &a->sockaddr.in4.sin_addr) <= 0) {
                                free(n);
                                return errno != 0 ? -errno : -EINVAL;
                        }

                        free(n);

                        e++;
                        if ((r = safe_atou(e, &u)) < 0)
                                return r;

                        if (u <= 0 || u > 0xFFFF)
                                return -EINVAL;

                        a->sockaddr.in4.sin_family = AF_INET;
                        a->sockaddr.in4.sin_port = htons((uint16_t) u);
                        a->size = sizeof(struct sockaddr_in);
                } else {

                        /* Just a port */
                        if ((r = safe_atou(s, &u)) < 0)
                                return r;

                        if (u <= 0 || u > 0xFFFF)
                                return -EINVAL;

                        a->sockaddr.in6.sin6_family = AF_INET6;
                        memcpy(&a->sockaddr.in6.sin6_addr, &in6addr_any, INET6_ADDRSTRLEN);
                        a->sockaddr.in6.sin6_port = htons((uint16_t) u);
                        a->size = sizeof(struct sockaddr_in6);
                }
        }

        return 0;
}

int address_verify(const Address *a) {
        assert(a);

        switch (address_family(a)) {
                case AF_INET:
                        if (a->size != sizeof(struct sockaddr_in))
                                return -EINVAL;

                        if (a->sockaddr.in4.sin_port == 0)
                                return -EINVAL;

                        return 0;

                case AF_INET6:
                        if (a->size != sizeof(struct sockaddr_in6))
                                return -EINVAL;

                        if (a->sockaddr.in6.sin6_port == 0)
                                return -EINVAL;

                        return 0;

                case AF_UNIX:
                        if (a->size < sizeof(sa_family_t))
                                return -EINVAL;

                        if (a->size > sizeof(sa_family_t)) {

                                if (a->sockaddr.un.sun_path[0] == 0) {
                                        /* abstract */
                                        if (a->size != sizeof(struct sockaddr_un))
                                                return -EINVAL;
                                } else {
                                        char *e;

                                        /* path */
                                        if (!(e = memchr(a->sockaddr.un.sun_path, 0, sizeof(a->sockaddr.un.sun_path))))
                                                return -EINVAL;

                                        if (a->size != sizeof(sa_family_t) + (e - a->sockaddr.un.sun_path) + 1)
                                                return -EINVAL;
                                }
                        }

                        return 0;

                default:
                        return -EAFNOSUPPORT;
        }
}

int address_print(const Address *a, char **p) {
        int r;
        assert(a);
        assert(p);

        if ((r = address_verify(a)) < 0)
                return r;

        switch (address_family(a)) {
                case AF_INET: {
                        char *ret;

                        if (!(ret = new(char, INET_ADDRSTRLEN+1+5+1)))
                                return -ENOMEM;

                        if (!inet_ntop(AF_INET, &a->sockaddr.in4.sin_addr, ret, INET_ADDRSTRLEN)) {
                                free(ret);
                                return -errno;
                        }

                        sprintf(strchr(ret, 0), ":%u", ntohs(a->sockaddr.in4.sin_port));
                        *p = ret;
                        return 0;
                }

                case AF_INET6: {
                        char *ret;

                        if (!(ret = new(char, 1+INET6_ADDRSTRLEN+2+5+1)))
                                return -ENOMEM;

                        ret[0] = '[';
                        if (!inet_ntop(AF_INET6, &a->sockaddr.in6.sin6_addr, ret+1, INET6_ADDRSTRLEN)) {
                                free(ret);
                                return -errno;
                        }

                        sprintf(strchr(ret, 0), "]:%u", ntohs(a->sockaddr.in6.sin6_port));
                        *p = ret;
                        return 0;
                }

                case AF_UNIX: {
                        char *ret;

                        if (a->size <= sizeof(sa_family_t)) {

                                if (!(ret = strdup("<unamed>")))
                                        return -ENOMEM;

                        } else if (a->sockaddr.un.sun_path[0] == 0) {
                                /* abstract */

                                /* FIXME: We assume we can print the
                                 * socket path here and that it hasn't
                                 * more than one NUL byte. That is
                                 * actually an invalid assumption */

                                if (!(ret = new(char, sizeof(a->sockaddr.un.sun_path)+1)))
                                        return -ENOMEM;

                                ret[0] = '=';
                                memcpy(ret+1, a->sockaddr.un.sun_path+1, sizeof(a->sockaddr.un.sun_path)-1);
                                ret[sizeof(a->sockaddr.un.sun_path)] = 0;

                        } else {

                                if (!(ret = strdup(a->sockaddr.un.sun_path)))
                                        return -ENOMEM;
                        }

                        *p = ret;
                        return 0;
                }

                default:
                        return -EINVAL;
        }
}

int address_listen(const Address *a, int backlog) {
        int r, fd;
        assert(a);

        if ((r = address_verify(a)) < 0)
                return r;

        if ((fd = socket(address_family(a), a->type, 0)) < 0)
                return -errno;

        if (bind(fd, &a->sockaddr.sa, a->size) < 0) {
                close_nointr(fd);
                return -errno;
        }

        if (a->type == SOCK_STREAM)
                if (listen(fd, backlog) < 0) {
                        close_nointr(fd);
                        return -errno;
                }

        if (address_family(a) == AF_INET6) {
                int flag = a->bind_ipv6_only;

                if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &flag, sizeof(flag)) < 0) {
                        close_nointr(fd);
                        return -errno;
                }
        }

        return 0;
}
Commit	Line	Data
42f4e3c4 LP	1	/-- Mode: C; c-basic-offset: 8 --/
	2
	3	#include <assert.h>
	4	#include <string.h>
	5	#include <unistd.h>
	6	#include <errno.h>
	7	#include <stdlib.h>
	8	#include <arpa/inet.h>
	9	#include <stdio.h>
	10
	11	#include "macro.h"
	12	#include "util.h"
	13	#include "socket-util.h"
	14
	15	int address_parse(Address a, const char s) {
	16	int r;
	17	char e, n;
	18	unsigned u;
	19
	20	assert(a);
	21	assert(s);
	22
	23	memset(a, 0, sizeof(*a));
	24
	25	if (*s == '[') {
	26	/* IPv6 in [x:.....:z]:p notation */
	27
	28	if (!(e = strchr(s+1, ']')))
	29	return -EINVAL;
	30
	31	if (!(n = strndup(s+1, e-s-1)))
	32	return -ENOMEM;
	33
	34	errno = 0;
	35	if (inet_pton(AF_INET6, n, &a->sockaddr.in6.sin6_addr) <= 0) {
	36	free(n);
	37	return errno != 0 ? -errno : -EINVAL;
	38	}
	39
	40	free(n);
	41
	42	e++;
	43	if (*e != ':')
	44	return -EINVAL;
	45
	46	e++;
	47	if ((r = safe_atou(e, &u)) < 0)
	48	return r;
	49
	50	if (u <= 0 \|\| u > 0xFFFF)
	51	return -EINVAL;
	52
	53	a->sockaddr.in6.sin6_family = AF_INET6;
	54	a->sockaddr.in6.sin6_port = htons((uint16_t) u);
	55	a->size = sizeof(struct sockaddr_in6);
	56	a->bind_ipv6_only = true;
	57
	58	} else if (*s == '/') {
	59	/* AF_UNIX socket */
	60
	61	size_t l;
	62
	63	l = strlen(s);
	64	if (l >= sizeof(a->sockaddr.un.sun_path))
65	return -EINVAL;
66
67	a->sockaddr.un.sun_family = AF_UNIX;
68	memcpy(a->sockaddr.un.sun_path, s, l);
69	a->size = sizeof(sa_family_t) + l + 1;
70
71	} else if (*s == '=') {
72	/* Abstract AF_UNIX socket */
73	size_t l;
74
75	l = strlen(s+1);
76	if (l >= sizeof(a->sockaddr.un.sun_path) - 1)
77	return -EINVAL;
78
79	a->sockaddr.un.sun_family = AF_UNIX;
80	memcpy(a->sockaddr.un.sun_path+1, s+1, l);
81	a->size = sizeof(struct sockaddr_un);
82
83	} else {
84
85	if ((e = strchr(s, ':'))) {
86
87	/* IPv4 in w.x.y.z:p notation */
88	if (!(n = strndup(s, e-s)))
89	return -ENOMEM;
90
91	errno = 0;
92	if (inet_pton(AF_INET, n, &a->sockaddr.in4.sin_addr) <= 0) {
93	free(n);
94	return errno != 0 ? -errno : -EINVAL;
95	}
96
97	free(n);
98
99	e++;
100	if ((r = safe_atou(e, &u)) < 0)
101	return r;
102
103	if (u <= 0 \|\| u > 0xFFFF)
104	return -EINVAL;
105
106	a->sockaddr.in4.sin_family = AF_INET;
107	a->sockaddr.in4.sin_port = htons((uint16_t) u);
108	a->size = sizeof(struct sockaddr_in);
109	} else {
110
111	/* Just a port */
112	if ((r = safe_atou(s, &u)) < 0)
113	return r;
114
115	if (u <= 0 \|\| u > 0xFFFF)
116	return -EINVAL;
117
118	a->sockaddr.in6.sin6_family = AF_INET6;
119	memcpy(&a->sockaddr.in6.sin6_addr, &in6addr_any, INET6_ADDRSTRLEN);
120	a->sockaddr.in6.sin6_port = htons((uint16_t) u);
121	a->size = sizeof(struct sockaddr_in6);
122	}
123	}
124
125	return 0;
126	}
127
128	int address_verify(const Address *a) {
129	assert(a);
130
131	switch (address_family(a)) {
132	case AF_INET:
133	if (a->size != sizeof(struct sockaddr_in))
134	return -EINVAL;
135
136	if (a->sockaddr.in4.sin_port == 0)
137	return -EINVAL;
138
139	return 0;
140
141	case AF_INET6:
142	if (a->size != sizeof(struct sockaddr_in6))
143	return -EINVAL;
144
145	if (a->sockaddr.in6.sin6_port == 0)
146	return -EINVAL;
147
148	return 0;
149
150	case AF_UNIX:
151	if (a->size < sizeof(sa_family_t))
152	return -EINVAL;
153
154	if (a->size > sizeof(sa_family_t)) {
155
156	if (a->sockaddr.un.sun_path[0] == 0) {
157	/* abstract */
158	if (a->size != sizeof(struct sockaddr_un))
159	return -EINVAL;
160	} else {
161	char *e;
162
163	/* path */
164	if (!(e = memchr(a->sockaddr.un.sun_path, 0, sizeof(a->sockaddr.un.sun_path))))
165	return -EINVAL;
166
167	if (a->size != sizeof(sa_family_t) + (e - a->sockaddr.un.sun_path) + 1)
168	return -EINVAL;
169	}
170	}
171
172	return 0;
173
174	default:
175	return -EAFNOSUPPORT;
176	}
177	}
178
179	int address_print(const Address a, char *p) {
180	int r;
181	assert(a);
182	assert(p);
183
184	if ((r = address_verify(a)) < 0)
185	return r;
186
187	switch (address_family(a)) {
188	case AF_INET: {
189	char *ret;
190
191	if (!(ret = new(char, INET_ADDRSTRLEN+1+5+1)))
192	return -ENOMEM;
193
194	if (!inet_ntop(AF_INET, &a->sockaddr.in4.sin_addr, ret, INET_ADDRSTRLEN)) {
195	free(ret);
196	return -errno;
197	}
198
199	sprintf(strchr(ret, 0), ":%u", ntohs(a->sockaddr.in4.sin_port));
200	*p = ret;
201	return 0;
202	}
203
204	case AF_INET6: {
205	char *ret;
206
207	if (!(ret = new(char, 1+INET6_ADDRSTRLEN+2+5+1)))
208	return -ENOMEM;
209
210	ret[0] = '[';
211	if (!inet_ntop(AF_INET6, &a->sockaddr.in6.sin6_addr, ret+1, INET6_ADDRSTRLEN)) {
212	free(ret);
213	return -errno;
214	}
215
216	sprintf(strchr(ret, 0), "]:%u", ntohs(a->sockaddr.in6.sin6_port));
217	*p = ret;
218	return 0;
219	}
220
221	case AF_UNIX: {
222	char *ret;
223
224	if (a->size <= sizeof(sa_family_t)) {
225
226	if (!(ret = strdup("<unamed>")))
227	return -ENOMEM;
228
229	} else if (a->sockaddr.un.sun_path[0] == 0) {
230	/* abstract */
231
232	/* FIXME: We assume we can print the
233	* socket path here and that it hasn't
234	* more than one NUL byte. That is
235	* actually an invalid assumption */
236
237	if (!(ret = new(char, sizeof(a->sockaddr.un.sun_path)+1)))
238	return -ENOMEM;
239
240	ret[0] = '=';
241	memcpy(ret+1, a->sockaddr.un.sun_path+1, sizeof(a->sockaddr.un.sun_path)-1);
242	ret[sizeof(a->sockaddr.un.sun_path)] = 0;
243
244	} else {
245
246	if (!(ret = strdup(a->sockaddr.un.sun_path)))
247	return -ENOMEM;
248	}
249
250	*p = ret;
251	return 0;
252	}
253
254	default:
255	return -EINVAL;
256	}
257	}
258
259	int address_listen(const Address *a, int backlog) {
260	int r, fd;
261	assert(a);
262
263	if ((r = address_verify(a)) < 0)
264	return r;
265
266	if ((fd = socket(address_family(a), a->type, 0)) < 0)
267	return -errno;
268
269	if (bind(fd, &a->sockaddr.sa, a->size) < 0) {
270	close_nointr(fd);
271	return -errno;
272	}
273
274	if (a->type == SOCK_STREAM)
275	if (listen(fd, backlog) < 0) {
276	close_nointr(fd);
277	return -errno;
278	}
279
280	if (address_family(a) == AF_INET6) {
281	int flag = a->bind_ipv6_only;
282
283	if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &flag, sizeof(flag)) < 0) {
284	close_nointr(fd);
285	return -errno;
286	}
287	}
288
289	return 0;
290	}