@cfg_get.<group_name>.<var_name> is documented
[sip-router] / tsend.c
1 /*
2  * $Id$
3  *
4  * Copyright (C) 2001-2003 FhG Fokus
5  *
6  * This file is part of ser, a free SIP server.
7  *
8  * ser is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * For a license to use the ser software under conditions
14  * other than those described here, or to purchase support for this
15  * software, please contact iptel.org by e-mail at the following addresses:
16  *    info@iptel.org
17  *
18  * ser is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
26  */
27 /*
28  * send with timeout for stream and datagram sockets
29  * 
30  * History:
31  * --------
32  *  2004-02-26  created by andrei
33  *  2003-03-03  switched to heavy macro use, added tsend_dgram_ev (andrei) 
34  *  2006-02-03  tsend* will wait forever if timeout==-1 (andrei)
35  */
36
37 #include <string.h>
38 #include <errno.h>
39 #include <sys/poll.h>
40
41 #include <sys/types.h>
42 #include <sys/socket.h>
43 #include <sys/uio.h>
44
45 #include "dprint.h"
46 #include "timer.h"
47 #include "timer_ticks.h"
48
49 /* the functions below are very similar => some generic macros */
50 #define TSEND_INIT \
51         int n; \
52         struct pollfd pf; \
53         ticks_t expire; \
54         s_ticks_t diff; \
55         expire=get_ticks_raw()+MS_TO_TICKS((ticks_t)timeout); \
56         pf.fd=fd; \
57         pf.events=POLLOUT
58
59 #define TSEND_POLL(f_name) \
60 poll_loop: \
61         while(1){ \
62                 if (timeout==-1) \
63                         n=poll(&pf, 1, -1); \
64                 else{ \
65                         diff=expire-get_ticks_raw(); \
66                         if (diff<=0){ \
67                                 LOG(L_ERR, "ERROR: " f_name ": send timeout (%d)\n", timeout);\
68                                 goto error; \
69                         } \
70                         n=poll(&pf, 1, TICKS_TO_MS((ticks_t)diff)); \
71                 } \
72                 if (n<0){ \
73                         if (errno==EINTR) continue; /* signal, ignore */ \
74                         LOG(L_ERR, "ERROR: " f_name ": poll failed: %s [%d]\n", \
75                                         strerror(errno), errno); \
76                         goto error; \
77                 }else if (n==0){ \
78                         /* timeout */ \
79                         LOG(L_ERR, "ERROR: " f_name ": send timeout (p %d)\n", timeout); \
80                         goto error; \
81                 } \
82                 if (pf.revents&POLLOUT){ \
83                         /* we can write again */ \
84                         goto again; \
85                 }else if (pf.revents&(POLLERR|POLLHUP|POLLNVAL)){ \
86                         LOG(L_ERR, "ERROR: " f_name ": bad poll flags %x\n", \
87                                         pf.revents); \
88                         goto error; \
89                 } \
90                 /* if POLLIN or POLLPRI or other non-harmful events happened,    \
91                  * continue ( although poll should never signal them since we're  \
92                  * not interested in them => we should never reach this point) */ \
93         } 
94
95
96 #define TSEND_ERR_CHECK(f_name)\
97         if (n<0){ \
98                 if (errno==EINTR) goto again; \
99                 else if (errno!=EAGAIN && errno!=EWOULDBLOCK){ \
100                         LOG(L_ERR, "ERROR: " f_name ": failed to send: (%d) %s\n", \
101                                         errno, strerror(errno)); \
102                         goto error; \
103                 }else goto poll_loop; \
104         }
105         
106
107
108 /* sends on fd (which must be O_NONBLOCK if you want a finite timeout); if it
109  * cannot send any data
110  * in timeout milliseconds it will return ERROR
111  * if timeout==-1, it waits forever
112  * returns: -1 on error, or number of bytes written
113  *  (if less than len => couldn't send all)
114  *  bugs: signals will reset the timer
115  */
116 int tsend_stream(int fd, char* buf, unsigned int len, int timeout)
117 {
118         int written;
119         TSEND_INIT;
120         
121         written=0;
122 again:
123         n=send(fd, buf, len,
124 #ifdef HAVE_MSG_NOSIGNAL
125                         MSG_NOSIGNAL
126 #else
127                         0
128 #endif
129                 );
130         TSEND_ERR_CHECK("tsend_stream");
131         written+=n; 
132         if (n<(int)len){ 
133                 /* partial write */ 
134                 buf+=n; 
135                 len-=n; 
136         }else{ 
137                 /* successful full write */ 
138                 return written;
139         }
140         TSEND_POLL("tsend_stream");
141 error:
142         return -1;
143 }
144
145
146
147 /* sends on dgram fd (which must be O_NONBLOCK); if it cannot send any data
148  * in timeout milliseconds it will return ERROR
149  * returns: -1 on error, or number of bytes written
150  *  (if less than len => couldn't send all)
151  *  bugs: signals will reset the timer
152  */
153 int tsend_dgram(int fd, char* buf, unsigned int len, 
154                                 const struct sockaddr* to, socklen_t tolen, int timeout)
155 {
156         TSEND_INIT;
157 again:
158         n=sendto(fd, buf, len, 0, to, tolen);
159         TSEND_ERR_CHECK("tsend_dgram");
160         /* we don't care about partial writes: they shouldn't happen on 
161          * a datagram socket */
162         return n;
163         TSEND_POLL("tsend_datagram");
164 error:
165         return -1;
166 }
167
168         
169 /* sends on connected datagram fd (which must be O_NONBLOCK); 
170  * if it cannot send any data in timeout milliseconds it will return ERROR
171  * returns: -1 on error, or number of bytes written
172  *  (if less than len => couldn't send all)
173  *  bugs: signals will reset the timer
174  */
175
176 int tsend_dgram_ev(int fd, const struct iovec* v, int count, int timeout)
177 {
178         TSEND_INIT;
179 again:
180         n=writev(fd, v, count);
181         TSEND_ERR_CHECK("tsend_datagram_ev");
182         return n;
183         TSEND_POLL("tsend_datagram_ev");
184 error:
185         return -1;
186 }
187