![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to asyncsendto.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / minissdpd|
Return to asyncsendto.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / minissdpd |
1.1 misho 1: /* $Id: asyncsendto.c,v 1.12 2020/11/11 12:13:26 nanard Exp $ */
2: /* MiniUPnP project
3: * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
4: * (c) 2006-2020 Thomas Bernard
5: * This software is subject to the conditions detailed
6: * in the LICENCE file provided within the distribution */
7:
8: #include <sys/types.h>
9: #include <sys/select.h>
10: #include <sys/socket.h>
11: #include <sys/time.h>
12: #include <sys/queue.h>
13: #include <stdlib.h>
14: #include <string.h>
15: #include <unistd.h>
16: #include <syslog.h>
17: #include <errno.h>
18: #include <sys/uio.h>
19: #include <netinet/in.h>
20: #include <inttypes.h>
21:
22: #include "asyncsendto.h"
23: #include "upnputils.h"
24:
25: enum send_state {ESCHEDULED=1, EWAITREADY=2, ESENDNOW=3} state;
26:
27: /* state diagram for a packet :
28: *
29: * |
30: * V
31: * -> ESCHEDULED -> ESENDNOW -> sent
32: * ^ |
33: * | V
34: * EWAITREADY -> sent
35: */
36: struct scheduled_send {
37: LIST_ENTRY(scheduled_send) entries;
38: struct timeval ts;
39: enum send_state state;
40: int sockfd;
41: const void * buf;
42: size_t len;
43: int flags;
44: const struct sockaddr *dest_addr;
45: socklen_t addrlen;
46: const struct sockaddr_in6 *src_addr;
47: char data[];
48: };
49:
50: static LIST_HEAD(listhead, scheduled_send) send_list = { NULL };
51:
52: /*
53: * ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
54: * const struct sockaddr *dest_addr, socklen_t addrlen);
55: */
56: static ssize_t
57: send_from_to(int sockfd, const void *buf, size_t len, int flags,
58: const struct sockaddr_in6 *src_addr,
59: const struct sockaddr *dest_addr, socklen_t addrlen)
60: {
61: #ifdef IPV6_PKTINFO
62: if(src_addr) {
63: struct iovec iov;
64: struct in6_pktinfo ipi6;
65: uint8_t c[CMSG_SPACE(sizeof(ipi6))];
66: struct msghdr msg;
67: struct cmsghdr* cmsg;
68:
69: iov.iov_base = (void *)buf;
70: iov.iov_len = len;
71: memset(&msg, 0, sizeof(msg));
72: msg.msg_iov = &iov;
73: msg.msg_iovlen = 1;
74: ipi6.ipi6_addr = src_addr->sin6_addr;
75: ipi6.ipi6_ifindex = src_addr->sin6_scope_id;
76: msg.msg_control = c;
77: msg.msg_controllen = sizeof(c);
78: cmsg = CMSG_FIRSTHDR(&msg);
79: cmsg->cmsg_level = IPPROTO_IPV6;
80: cmsg->cmsg_type = IPV6_PKTINFO;
81: cmsg->cmsg_len = CMSG_LEN(sizeof(ipi6));
82: memcpy(CMSG_DATA(cmsg), &ipi6, sizeof(ipi6));
83: msg.msg_name = (void *)dest_addr;
84: msg.msg_namelen = addrlen;
85: return sendmsg(sockfd, &msg, flags);
86: } else {
87: #endif /* IPV6_PKTINFO */
88: return sendto(sockfd, buf, len, flags, dest_addr, addrlen);
89: #ifdef IPV6_PKTINFO
90: }
91: #endif /* IPV6_PKTINFO */
92: }
93:
94: /* delay = milli seconds */
95: ssize_t
96: sendto_schedule2(int sockfd, const void *buf, size_t len, int flags,
97: const struct sockaddr *dest_addr, socklen_t addrlen,
98: const struct sockaddr_in6 *src_addr,
99: unsigned int delay)
100: {
101: enum send_state state;
102: ssize_t n;
103: size_t alloc_len;
104: struct timeval tv;
105: struct scheduled_send * elt;
106:
107: if(delay == 0) {
108: /* first try to send at once */
109: n = send_from_to(sockfd, buf, len, flags, src_addr, dest_addr, addrlen);
110: if(n >= 0)
111: return n;
112: else if(errno == EAGAIN || errno == EWOULDBLOCK) {
113: /* use select() on this socket */
114: state = EWAITREADY;
115: } else if(errno == EINTR) {
116: state = ESENDNOW;
117: } else {
118: /* uncatched error */
119: return n;
120: }
121: } else {
122: state = ESCHEDULED;
123: }
124:
125: /* schedule */
126: if(upnp_gettimeofday(&tv) < 0) {
127: return -1;
128: }
129: /* allocate enough space for structure + buffers */
130: alloc_len = sizeof(struct scheduled_send) + len + addrlen;
131: if(src_addr)
132: alloc_len += sizeof(struct sockaddr_in6);
133: elt = malloc(alloc_len);
134: if(elt == NULL) {
135: syslog(LOG_ERR, "malloc failed to allocate %u bytes",
136: (unsigned)alloc_len);
137: return -1;
138: }
139: elt->state = state;
140: /* time the packet should be sent */
141: elt->ts.tv_sec = tv.tv_sec + (delay / 1000);
142: elt->ts.tv_usec = tv.tv_usec + (delay % 1000) * 1000;
143: if(elt->ts.tv_usec > 1000000) {
144: elt->ts.tv_sec++;
145: elt->ts.tv_usec -= 1000000;
146: }
147: elt->sockfd = sockfd;
148: elt->flags = flags;
149: memcpy(elt->data, dest_addr, addrlen);
150: elt->dest_addr = (struct sockaddr *)elt->data;
151: elt->addrlen = addrlen;
152: if(src_addr) {
153: elt->src_addr = (struct sockaddr_in6 *)(elt->data + addrlen);
154: memcpy((void *)elt->src_addr, src_addr, sizeof(struct sockaddr_in6));
155: elt->buf = (void *)(elt->data + addrlen + sizeof(struct sockaddr_in6));
156: } else {
157: elt->src_addr = NULL;
158: elt->buf = (void *)(elt->data + addrlen);
159: }
160: elt->len = len;
161: memcpy((void *)elt->buf, buf, len);
162: /* insert */
163: LIST_INSERT_HEAD( &send_list, elt, entries);
164: return 0;
165: }
166:
167: /* try to send at once, and queue the packet if needed */
168: ssize_t
169: sendto_or_schedule(int sockfd, const void *buf, size_t len, int flags,
170: const struct sockaddr *dest_addr, socklen_t addrlen)
171: {
172: return sendto_schedule2(sockfd, buf, len, flags, dest_addr, addrlen, NULL, 0);
173: }
174:
175: ssize_t
176: sendto_or_schedule2(int sockfd, const void *buf, size_t len, int flags,
177: const struct sockaddr *dest_addr, socklen_t addrlen,
178: const struct sockaddr_in6 *src_addr)
179: {
180: return sendto_schedule2(sockfd, buf, len, flags, dest_addr, addrlen, src_addr, 0);
181: }
182:
183: /* get_next_scheduled_send() return number of scheduled send in list */
184: int get_next_scheduled_send(struct timeval * next_send)
185: {
186: int n = 0;
187: struct scheduled_send * elt;
188: if(next_send == NULL)
189: return -1;
190: for(elt = send_list.lh_first; elt != NULL; elt = elt->entries.le_next) {
191: if(n == 0 || (elt->ts.tv_sec < next_send->tv_sec) ||
192: (elt->ts.tv_sec == next_send->tv_sec && elt->ts.tv_usec < next_send->tv_usec)) {
193: next_send->tv_sec = elt->ts.tv_sec;
194: next_send->tv_usec = elt->ts.tv_usec;
195: }
196: n++;
197: }
198: return n;
199: }
200:
201: /* update writefds for select() call
202: * return the number of packets to try to send at once */
203: int get_sendto_fds(fd_set * writefds, int * max_fd, const struct timeval * now)
204: {
205: int n = 0;
206: struct scheduled_send * elt;
207: for(elt = send_list.lh_first; elt != NULL; elt = elt->entries.le_next) {
208: if(elt->state == EWAITREADY) {
209: /* last sendto() call returned EAGAIN/EWOULDBLOCK */
210: FD_SET(elt->sockfd, writefds);
211: if(elt->sockfd > *max_fd)
212: *max_fd = elt->sockfd;
213: n++;
214: } else if((elt->ts.tv_sec < now->tv_sec) ||
215: (elt->ts.tv_sec == now->tv_sec && elt->ts.tv_usec <= now->tv_usec)) {
216: /* we waited long enough, now send ! */
217: elt->state = ESENDNOW;
218: n++;
219: }
220: }
221: return n;
222: }
223:
224: /* executed sendto() when needed */
225: int try_sendto(fd_set * writefds)
226: {
227: int ret = 0;
228: ssize_t n;
229: struct scheduled_send * elt;
230: struct scheduled_send * next;
231: for(elt = send_list.lh_first; elt != NULL; elt = next) {
232: next = elt->entries.le_next;
233: if((elt->state == ESENDNOW) ||
234: (elt->state == EWAITREADY && FD_ISSET(elt->sockfd, writefds))) {
235: #ifdef DEBUG
236: syslog(LOG_DEBUG, "%s: %d bytes on socket %d",
237: "try_sendto", (int)elt->len, elt->sockfd);
238: #endif
239: n = send_from_to(elt->sockfd, elt->buf, elt->len, elt->flags,
240: elt->src_addr, elt->dest_addr, elt->addrlen);
241: /*n = sendto(elt->sockfd, elt->buf, elt->len, elt->flags,
242: elt->dest_addr, elt->addrlen);*/
243: if(n < 0) {
244: if(errno == EINTR) {
245: /* retry at once */
246: elt->state = ESENDNOW;
247: continue;
248: } else if(errno == EAGAIN || errno == EWOULDBLOCK) {
249: /* retry once the socket is ready for writing */
250: elt->state = EWAITREADY;
251: continue;
252: } else {
253: char addr_str[64];
254: /* uncatched error */
255: if(sockaddr_to_string(elt->dest_addr, addr_str, sizeof(addr_str)) <= 0)
256: addr_str[0] = '\0';
257: syslog(LOG_ERR, "%s(sock=%d, len=%u, dest=%s): sendto: %m",
258: "try_sendto", elt->sockfd, (unsigned)elt->len,
259: addr_str);
260: ret--;
261: }
262: } else if((int)n != (int)elt->len) {
263: syslog(LOG_WARNING, "%s: %d bytes sent out of %d",
264: "try_sendto", (int)n, (int)elt->len);
265: }
266: /* remove from the list */
267: LIST_REMOVE(elt, entries);
268: free(elt);
269: }
270: }
271: return ret;
272: }
273:
274: /* maximum execution time for finalize_sendto() in milliseconds */
275: #define FINALIZE_SENDTO_DELAY (500)
276:
277: /* empty the list */
278: void finalize_sendto(void)
279: {
280: ssize_t n;
281: struct scheduled_send * elt;
282: struct scheduled_send * next;
283: fd_set writefds;
284: struct timeval deadline;
285: struct timeval now;
286: struct timeval timeout;
287: int max_fd;
288:
289: if(upnp_gettimeofday(&deadline) < 0) {
290: syslog(LOG_ERR, "gettimeofday: %m");
291: return;
292: }
293: deadline.tv_usec += FINALIZE_SENDTO_DELAY*1000;
294: if(deadline.tv_usec > 1000000) {
295: deadline.tv_sec++;
296: deadline.tv_usec -= 1000000;
297: }
298: while(send_list.lh_first) {
299: FD_ZERO(&writefds);
300: max_fd = -1;
301: for(elt = send_list.lh_first; elt != NULL; elt = next) {
302: next = elt->entries.le_next;
303: syslog(LOG_DEBUG, "finalize_sendto(): %d bytes on socket %d",
304: (int)elt->len, elt->sockfd);
305: n = send_from_to(elt->sockfd, elt->buf, elt->len, elt->flags,
306: elt->src_addr, elt->dest_addr, elt->addrlen);
307: /*n = sendto(elt->sockfd, elt->buf, elt->len, elt->flags,
308: elt->dest_addr, elt->addrlen);*/
309: if(n < 0) {
310: if(errno==EAGAIN || errno==EWOULDBLOCK) {
311: FD_SET(elt->sockfd, &writefds);
312: if(elt->sockfd > max_fd)
313: max_fd = elt->sockfd;
314: continue;
315: }
316: syslog(LOG_WARNING, "finalize_sendto(): socket=%d sendto: %m", elt->sockfd);
317: }
318: /* remove from the list */
319: LIST_REMOVE(elt, entries);
320: free(elt);
321: }
322: /* check deadline */
323: if(upnp_gettimeofday(&now) < 0) {
324: syslog(LOG_ERR, "gettimeofday: %m");
325: return;
326: }
327: if(now.tv_sec > deadline.tv_sec ||
328: (now.tv_sec == deadline.tv_sec && now.tv_usec > deadline.tv_usec)) {
329: /* deadline ! */
330: while((elt = send_list.lh_first) != NULL) {
331: LIST_REMOVE(elt, entries);
332: free(elt);
333: }
334: return;
335: }
336: /* compute timeout value */
337: timeout.tv_sec = deadline.tv_sec - now.tv_sec;
338: timeout.tv_usec = deadline.tv_usec - now.tv_usec;
339: if(timeout.tv_usec < 0) {
340: timeout.tv_sec--;
341: timeout.tv_usec += 1000000;
342: }
343: if(max_fd >= 0) {
344: if(select(max_fd + 1, NULL, &writefds, NULL, &timeout) < 0) {
345: syslog(LOG_ERR, "select: %m");
346: return;
347: }
348: }
349: }
350: }