1 #include <sys/cdefs.h>
2 #include "namespace.h"
3 #include <lib.h>
4
5 #include <assert.h>
6 #include <errno.h>
7 #include <stdlib.h>
8 #include <stdio.h>
9 #include <string.h>
10 #include <unistd.h>
11 #include <sys/ioctl.h>
12 #include <sys/socket.h>
13 #include <netinet/in.h>
14
15 #include <net/gen/in.h>
16 #include <net/gen/tcp.h>
17 #include <net/gen/tcp_io.h>
18 #include <net/gen/udp.h>
19 #include <net/gen/udp_hdr.h>
20 #include <net/gen/udp_io.h>
21
22 #include <net/gen/ip_hdr.h>
23 #include <net/gen/ip_io.h>
24
25 #define DEBUG 0
26
27 static ssize_t _tcp_recvfrom(int sock, void *__restrict buffer, size_t length,
28 int flags, struct sockaddr *__restrict address,
29 socklen_t *__restrict address_len, nwio_tcpconf_t *tcpconfp);
30 static ssize_t _udp_recvfrom(int sock, void *__restrict buffer, size_t length,
31 int flags, struct sockaddr *__restrict address,
32 socklen_t *__restrict address_len, nwio_udpopt_t *udpoptp);
33 static ssize_t _uds_recvfrom_conn(int sock, void *__restrict buffer,
34 size_t length, int flags, struct sockaddr *__restrict address,
35 socklen_t *__restrict address_len, struct sockaddr_un *uds_addr);
36 static ssize_t _uds_recvfrom_dgram(int sock, void *__restrict buffer,
37 size_t length, int flags, struct sockaddr *__restrict address,
38 socklen_t *__restrict address_len);
39
40 /*
41 * Receive a message from a socket.
42 */
43 static ssize_t
__recvfrom(int fd,void * __restrict buffer,size_t length,int flags,struct sockaddr * __restrict address,socklen_t * __restrict address_len)44 __recvfrom(int fd, void * __restrict buffer, size_t length, int flags,
45 struct sockaddr * __restrict address,
46 socklen_t * __restrict address_len)
47 {
48 message m;
49 ssize_t r;
50
51 if (address != NULL && address_len == NULL) {
52 errno = EFAULT;
53 return -1;
54 }
55
56 memset(&m, 0, sizeof(m));
57 m.m_lc_vfs_sendrecv.fd = fd;
58 m.m_lc_vfs_sendrecv.buf = (vir_bytes)buffer;
59 m.m_lc_vfs_sendrecv.len = length;
60 m.m_lc_vfs_sendrecv.flags = flags;
61 m.m_lc_vfs_sendrecv.addr = (vir_bytes)address;
62 m.m_lc_vfs_sendrecv.addr_len = (address != NULL) ? *address_len : 0;
63
64 if ((r = _syscall(VFS_PROC_NR, VFS_RECVFROM, &m)) < 0)
65 return -1;
66
67 if (address != NULL)
68 *address_len = m.m_vfs_lc_socklen.len;
69 return r;
70 }
71
recvfrom(int sock,void * __restrict buffer,size_t length,int flags,struct sockaddr * __restrict address,socklen_t * __restrict address_len)72 ssize_t recvfrom(int sock, void *__restrict buffer, size_t length,
73 int flags, struct sockaddr *__restrict address,
74 socklen_t *__restrict address_len)
75 {
76 int r;
77 nwio_tcpconf_t tcpconf;
78 nwio_udpopt_t udpopt;
79 nwio_ipopt_t ipopt;
80 struct sockaddr_un uds_addr;
81 int uds_sotype = -1;
82
83 r = __recvfrom(sock, buffer, length, flags, address, address_len);
84 if (r != -1 || (errno != ENOTSOCK && errno != ENOSYS))
85 return r;
86
87 #if DEBUG
88 fprintf(stderr, "recvfrom: for fd %d\n", sock);
89 #endif
90
91 r= ioctl(sock, NWIOGTCPCONF, &tcpconf);
92 if (r != -1 || errno != ENOTTY)
93 {
94 if (r == -1)
95 return r;
96 return _tcp_recvfrom(sock, buffer, length, flags,
97 address, address_len, &tcpconf);
98 }
99
100 r= ioctl(sock, NWIOGUDPOPT, &udpopt);
101 if (r != -1 || errno != ENOTTY)
102 {
103 if (r == -1)
104 return r;
105 return _udp_recvfrom(sock, buffer, length, flags,
106 address, address_len, &udpopt);
107 }
108
109 r= ioctl(sock, NWIOGUDSSOTYPE, &uds_sotype);
110 if (r != -1 || errno != ENOTTY)
111 {
112
113 if (r == -1) {
114 return r;
115 }
116
117 if (uds_sotype == SOCK_DGRAM) {
118 return _uds_recvfrom_dgram(sock, buffer,
119 length, flags, address, address_len);
120 } else {
121 return _uds_recvfrom_conn(sock, buffer,
122 length, flags, address, address_len,
123 &uds_addr);
124 }
125 }
126
127 r= ioctl(sock, NWIOGIPOPT, &ipopt);
128 if (r != -1 || errno != ENOTTY)
129 {
130 ip_hdr_t *ip_hdr;
131 int rd;
132 struct sockaddr_in sin;
133
134 if (r == -1) {
135 return r;
136 }
137
138 rd = read(sock, buffer, length);
139
140 if(rd < 0) return rd;
141
142 assert((size_t)rd >= sizeof(*ip_hdr));
143
144 ip_hdr= buffer;
145
146 if (address != NULL)
147 {
148 int len;
149 memset(&sin, 0, sizeof(sin));
150 sin.sin_family= AF_INET;
151 sin.sin_addr.s_addr= ip_hdr->ih_src;
152 sin.sin_len= sizeof(sin);
153 len= *address_len;
154 if ((size_t)len > sizeof(sin))
155 len= (int)sizeof(sin);
156 memcpy(address, &sin, len);
157 *address_len= sizeof(sin);
158 }
159
160 return rd;
161 }
162
163 errno = ENOTSOCK;
164 return -1;
165 }
166
_tcp_recvfrom(int sock,void * __restrict buffer,size_t length,int flags,struct sockaddr * __restrict address,socklen_t * __restrict address_len,nwio_tcpconf_t * tcpconfp)167 static ssize_t _tcp_recvfrom(int sock, void *__restrict buffer, size_t length,
168 int flags, struct sockaddr *__restrict address,
169 socklen_t *__restrict address_len, nwio_tcpconf_t *tcpconfp)
170 {
171 int r;
172 size_t len;
173 struct sockaddr_in sin;
174
175 if (flags != 0)
176 {
177 #if DEBUG
178 fprintf(stderr, "recvfrom(tcp): flags not implemented\n");
179 #endif
180 errno= ENOSYS;
181 return -1;
182 }
183
184 r = read(sock, buffer, length);
185
186 if (r >= 0 && address != NULL)
187 {
188 sin.sin_family= AF_INET;
189 sin.sin_addr.s_addr= tcpconfp->nwtc_remaddr;
190 sin.sin_port= tcpconfp->nwtc_remport;
191 sin.sin_len= sizeof(sin);
192 len= *address_len;
193 if (len > sizeof(sin))
194 len= sizeof(sin);
195 memcpy(address, &sin, len);
196 *address_len= sizeof(sin);
197 }
198
199 return r;
200 }
201
_udp_recvfrom(int sock,void * __restrict buffer,size_t length,int flags,struct sockaddr * __restrict address,socklen_t * __restrict address_len,nwio_udpopt_t * udpoptp)202 static ssize_t _udp_recvfrom(int sock, void *__restrict buffer, size_t length,
203 int flags, struct sockaddr *__restrict address,
204 socklen_t *__restrict address_len, nwio_udpopt_t *udpoptp)
205 {
206 int r, t_errno;
207 size_t buflen, len;
208 void *buf;
209 udp_io_hdr_t *io_hdrp;
210 struct sockaddr_in sin;
211
212 if (flags)
213 {
214 #if DEBUG
215 fprintf(stderr, "recvfrom(udp): flags not implemented\n");
216 #endif
217 errno= ENOSYS;
218 return -1;
219 }
220
221 if (udpoptp->nwuo_flags & NWUO_RWDATONLY)
222 {
223 if (address != NULL &&
224 (udpoptp->nwuo_flags & (NWUO_RA_SET | NWUO_RP_SET)) !=
225 (NWUO_RA_SET | NWUO_RP_SET))
226 {
227
228 #if DEBUG
229 fprintf(stderr,
230 "recvfrom(udp): RWDATONLY on unconnected socket\n");
231 #endif
232 errno= ENOTCONN;
233 return -1;
234 }
235
236 r= read(sock, buffer, length);
237 if (r == -1)
238 return r;
239
240 if (address != NULL)
241 {
242 sin.sin_family= AF_INET;
243 sin.sin_addr.s_addr= udpoptp->nwuo_remaddr;
244 sin.sin_port= udpoptp->nwuo_remport;
245 sin.sin_len= sizeof(sin);
246 len= *address_len;
247 if (len > sizeof(sin))
248 len= sizeof(sin);
249 memcpy(address, &sin, len);
250 *address_len= sizeof(sin);
251 }
252
253 return r;
254 }
255
256 buflen= sizeof(*io_hdrp) + length;
257 if (buflen < length)
258 {
259 /* Overflow */
260 errno= EMSGSIZE;
261 return -1;
262 }
263 buf= malloc(buflen);
264 if (buf == NULL)
265 return -1;
266
267 r= read(sock, buf, buflen);
268 if (r == -1)
269 {
270 t_errno= errno;
271 #if DEBUG
272 fprintf(stderr, "recvfrom(udp): read failed: %s\n",
273 strerror(errno));
274 fprintf(stderr, "udp opt flags = 0x%x\n", udpoptp->nwuo_flags);
275 #endif
276 free(buf);
277 errno= t_errno;
278 return -1;
279 }
280
281 assert((size_t)r >= sizeof(*io_hdrp));
282 length= r-sizeof(*io_hdrp);
283
284 io_hdrp= buf;
285 memcpy(buffer, &io_hdrp[1], length);
286
287 if (address != NULL)
288 {
289 sin.sin_family= AF_INET;
290 sin.sin_addr.s_addr= io_hdrp->uih_src_addr;
291 sin.sin_port= io_hdrp->uih_src_port;
292 sin.sin_len= sizeof(sin);
293 len= *address_len;
294 if (len > sizeof(sin))
295 len= sizeof(sin);
296 memcpy(address, &sin, len);
297 *address_len= sizeof(sin);
298 }
299 free(buf);
300 return length;
301 }
302
_uds_recvfrom_conn(int sock,void * __restrict buffer,size_t length,int flags,struct sockaddr * __restrict address,socklen_t * __restrict address_len,struct sockaddr_un * uds_addr)303 static ssize_t _uds_recvfrom_conn(int sock, void *__restrict buffer,
304 size_t length, int flags, struct sockaddr *__restrict address,
305 socklen_t *__restrict address_len, struct sockaddr_un *uds_addr)
306 {
307 int r;
308 size_t len;
309
310 /* for connection oriented unix domain sockets (SOCK_STREAM /
311 * SOCK_SEQPACKET)
312 */
313
314 if (flags != 0)
315 {
316 #if DEBUG
317 fprintf(stderr, "recvfrom(uds): flags not implemented\n");
318 #endif
319 errno= ENOSYS;
320 return -1;
321 }
322
323 r = read(sock, buffer, length);
324
325 if (r >= 0 && address != NULL)
326 {
327
328 len= *address_len;
329 if (len > sizeof(struct sockaddr_un))
330 len= sizeof(struct sockaddr_un);
331 memcpy(address, uds_addr, len);
332 *address_len= sizeof(struct sockaddr_un);
333 }
334
335 return r;
336 }
337
_uds_recvfrom_dgram(int sock,void * __restrict buffer,size_t length,int flags,struct sockaddr * __restrict address,socklen_t * __restrict address_len)338 static ssize_t _uds_recvfrom_dgram(int sock, void *__restrict buffer,
339 size_t length, int flags, struct sockaddr *__restrict address,
340 socklen_t *__restrict address_len)
341 {
342 int r;
343 size_t len;
344
345 /* for connectionless unix domain sockets (SOCK_DGRAM) */
346
347 if (flags != 0)
348 {
349 #if DEBUG
350 fprintf(stderr, "recvfrom(uds): flags not implemented\n");
351 #endif
352 errno= ENOSYS;
353 return -1;
354 }
355
356 r = read(sock, buffer, length);
357
358 if (r >= 0 && address != NULL)
359 {
360 len= *address_len;
361 if (len > sizeof(struct sockaddr_un))
362 len= sizeof(struct sockaddr_un);
363 ioctl(sock, NWIOGUDSFADDR, address);
364 *address_len= sizeof(struct sockaddr_un);
365 }
366
367 return r;
368 }
369
370