]> git.gag.com Git - debian/amanda/blob - common-src/dgram.c
Imported Upstream version 3.3.3
[debian/amanda] / common-src / dgram.c
1 /*
2  * Amanda, The Advanced Maryland Automatic Network Disk Archiver
3  * Copyright (c) 1991-1999 University of Maryland at College Park
4  * Copyright (c) 2007-2012 Zmanda, Inc.  All Rights Reserved.
5  * All Rights Reserved.
6  *
7  * Permission to use, copy, modify, distribute, and sell this software and its
8  * documentation for any purpose is hereby granted without fee, provided that
9  * the above copyright notice appear in all copies and that both that
10  * copyright notice and this permission notice appear in supporting
11  * documentation, and that the name of U.M. not be used in advertising or
12  * publicity pertaining to distribution of the software without specific,
13  * written prior permission.  U.M. makes no representations about the
14  * suitability of this software for any purpose.  It is provided "as is"
15  * without express or implied warranty.
16  *
17  * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
19  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
20  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
21  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
22  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23  *
24  * Author: James da Silva, Systems Design and Analysis Group
25  *                         Computer Science Department
26  *                         University of Maryland at College Park
27  */
28 /* 
29  * $Id: dgram.c,v 1.32 2006/07/05 19:54:20 martinea Exp $
30  *
31  * library routines to marshall/send, recv/unmarshall UDP packets
32  */
33 #include "amanda.h"
34 #include "arglist.h"
35 #include "dgram.h"
36 #include "util.h"
37 #include "conffile.h"
38 #include "sockaddr-util.h"
39
40 void
41 dgram_socket(
42     dgram_t *   dgram,
43     int         socket)
44 {
45     if(socket < 0 || socket >= (int)FD_SETSIZE) {
46         error(_("dgram_socket: socket %d out of range (0 .. %d)\n"),
47               socket, (int)FD_SETSIZE-1);
48         /*NOTREACHED*/
49     }
50     dgram->socket = socket;
51 }
52
53
54 int
55 dgram_bind(
56     dgram_t *   dgram,
57     sa_family_t family,
58     in_port_t * portp)
59 {
60     int s, retries;
61     socklen_t_equiv len;
62     sockaddr_union name;
63     int save_errno;
64     int *portrange;
65     int sndbufsize = MAX_DGRAM;
66
67     portrange = getconf_intrange(CNF_RESERVED_UDP_PORT);
68     *portp = (in_port_t)0;
69     g_debug("dgram_bind: setting up a socket with family %d", family);
70     if((s = socket(family, SOCK_DGRAM, 0)) == -1) {
71         save_errno = errno;
72         dbprintf(_("dgram_bind: socket() failed: %s\n"),
73                   strerror(save_errno));
74         errno = save_errno;
75         return -1;
76     }
77     if(s < 0 || s >= (int)FD_SETSIZE) {
78         dbprintf(_("dgram_bind: socket out of range: %d\n"),
79                   s);
80         aclose(s);
81         errno = EMFILE;                         /* out of range */
82         return -1;
83     }
84
85     /* try setting the buffer size (= maximum allowable UDP packet size) */
86     if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
87                    (void *) &sndbufsize, sizeof(sndbufsize)) < 0) {
88        dbprintf("dgram_bind: could not set udp send buffer to %d: %s (ignored)\n",
89                  sndbufsize, strerror(errno));
90     }
91
92     SU_INIT(&name, family);
93     SU_SET_INADDR_ANY(&name);
94
95     /*
96      * If a port range was specified, we try to get a port in that
97      * range first.  Next, we try to get a reserved port.  If that
98      * fails, we just go for any port.
99      * 
100      * In all cases, not to use port that's assigned to other services. 
101      *
102      * It is up to the caller to make sure we have the proper permissions
103      * to get the desired port, and to make sure we return a port that
104      * is within the range it requires.
105      */
106     for (retries = 0; ; retries++) {
107         if (bind_portrange(s, &name, portrange[0], portrange[1], "udp") == 0)
108             goto out;
109         dbprintf(_("dgram_bind: Could not bind to port in range: %d - %d.\n"),
110                   portrange[0], portrange[1]);
111         if (retries >= BIND_CYCLE_RETRIES) {
112             dbprintf(_("dgram_bind: Giving up...\n"));
113             break;
114         }
115
116         dbprintf(_("dgram_bind: Retrying entire range after 10 second delay.\n"));
117         sleep(15);
118     }
119
120     save_errno = errno;
121     dbprintf(_("dgram_bind: bind(in6addr_any) failed: %s\n"),
122                   strerror(save_errno));
123     aclose(s);
124     errno = save_errno;
125     return -1;
126
127 out:
128     /* find out what name was actually used */
129
130     len = (socklen_t_equiv)sizeof(name);
131     if(getsockname(s, (struct sockaddr *)&name, &len) == -1) {
132         save_errno = errno;
133         dbprintf(_("dgram_bind: getsockname() failed: %s\n"), strerror(save_errno));
134         errno = save_errno;
135         aclose(s);
136         return -1;
137     }
138     *portp = SU_GET_PORT(&name);
139     dgram->socket = s;
140
141     dbprintf(_("dgram_bind: socket %d bound to %s\n"),
142               dgram->socket, str_sockaddr(&name));
143     return 0;
144 }
145
146
147 int
148 dgram_send_addr(
149     sockaddr_union      *addr,
150     dgram_t *           dgram)
151 {
152     int s, rc;
153     int socket_opened;
154     int save_errno;
155     int max_wait;
156     int wait_count;
157 #if defined(USE_REUSEADDR)
158     const int on = 1;
159     int r;
160 #endif
161
162     dbprintf(_("dgram_send_addr(addr=%p, dgram=%p)\n"),
163               addr, dgram);
164     dump_sockaddr(addr);
165     dbprintf(_("dgram_send_addr: %p->socket = %d\n"),
166               dgram, dgram->socket);
167     if(dgram->socket != -1) {
168         s = dgram->socket;
169         socket_opened = 0;
170     } else {
171         int sndbufsize = MAX_DGRAM;
172
173         g_debug("dgram_send_addr: setting up a socket with family %d", SU_GET_FAMILY(addr));
174         if((s = socket(SU_GET_FAMILY(addr), SOCK_DGRAM, 0)) == -1) {
175             save_errno = errno;
176             dbprintf(_("dgram_send_addr: socket() failed: %s\n"),
177                       strerror(save_errno));
178             errno = save_errno;
179             return -1;
180         }
181         socket_opened = 1;
182 #ifdef USE_REUSEADDR
183         r = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
184                 (void *)&on, (socklen_t_equiv)sizeof(on));
185         if (r < 0) {
186             dbprintf(_("dgram_send_addr: setsockopt(SO_REUSEADDR) failed: %s\n"),
187                       strerror(errno));
188         }
189 #endif
190
191         /* try setting the buffer size (= maximum allowable UDP packet size) */
192         if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
193                        (void *) &sndbufsize, sizeof(sndbufsize)) < 0) {
194            dbprintf("dgram_send_addr: could not set udp send buffer to %d: %s (ignored)\n",
195                      sndbufsize, strerror(errno));
196         }
197     }
198
199     if(s < 0 || s >= (int)FD_SETSIZE) {
200         dbprintf(_("dgram_send_addr: socket out of range: %d\n"), s);
201         errno = EMFILE;                         /* out of range */
202         rc = -1;
203     } else {
204         max_wait = 300 / 5;                             /* five minutes */
205         wait_count = 0;
206         rc = 0;
207         while(sendto(s,
208                  dgram->data,
209                  dgram->len,
210                  0, 
211                  (struct sockaddr *)addr,
212                  SS_LEN(addr)) == -1) {
213 #ifdef ECONNREFUSED
214             if(errno == ECONNREFUSED && wait_count++ < max_wait) {
215                 sleep(5);
216                 dbprintf(_("dgram_send_addr: sendto(%s): retry %d after ECONNREFUSED\n"),
217                       str_sockaddr(addr),
218                       wait_count);
219                 continue;
220             }
221 #endif
222 #ifdef EAGAIN
223             if(errno == EAGAIN && wait_count++ < max_wait) {
224                 sleep(5);
225                 dbprintf(_("dgram_send_addr: sendto(%s): retry %d after EAGAIN\n"),
226                       str_sockaddr(addr),
227                       wait_count);
228                 continue;
229             }
230 #endif
231             save_errno = errno;
232             dbprintf(_("dgram_send_addr: sendto(%s) failed: %s \n"),
233                   str_sockaddr(addr),
234                   strerror(save_errno));
235             errno = save_errno;
236             rc = -1;
237             break;
238         }
239     }
240
241     if(socket_opened) {
242         save_errno = errno;
243         if(close(s) == -1) {
244             dbprintf(_("dgram_send_addr: close(%s): failed: %s\n"),
245                       str_sockaddr(addr),
246                       strerror(errno));
247             /*
248              * Calling function should not care that the close failed.
249              * It does care about the send results though.
250              */
251         }
252         errno = save_errno;
253     }
254
255     return rc;
256 }
257
258
259
260 ssize_t
261 dgram_recv(
262     dgram_t *           dgram,
263     int                 timeout,
264     sockaddr_union *fromaddr)
265 {
266     SELECT_ARG_TYPE ready;
267     struct timeval to;
268     ssize_t size;
269     int sock;
270     socklen_t_equiv addrlen;
271     ssize_t nfound;
272     int save_errno;
273
274     sock = dgram->socket;
275
276     FD_ZERO(&ready);
277     FD_SET(sock, &ready);
278     to.tv_sec = timeout;
279     to.tv_usec = 0;
280
281     dbprintf(_("dgram_recv(dgram=%p, timeout=%u, fromaddr=%p)\n"),
282                 dgram, timeout, fromaddr);
283     
284     nfound = (ssize_t)select(sock+1, &ready, NULL, NULL, &to);
285     if(nfound <= 0 || !FD_ISSET(sock, &ready)) {
286         save_errno = errno;
287         if(nfound < 0) {
288             dbprintf(_("dgram_recv: select() failed: %s\n"), strerror(save_errno));
289         } else if(nfound == 0) {
290             dbprintf(plural(_("dgram_recv: timeout after %d second\n"),
291                             _("dgram_recv: timeout after %d seconds\n"),
292                             timeout),
293                      timeout);
294             nfound = 0;
295         } else if (!FD_ISSET(sock, &ready)) {
296             int i;
297
298             for(i = 0; i < sock + 1; i++) {
299                 if(FD_ISSET(i, &ready)) {
300                     dbprintf(_("dgram_recv: got fd %d instead of %d\n"), i, sock);
301                 }
302             }
303             save_errno = EBADF;
304             nfound = -1;
305         }
306         errno = save_errno;
307         return nfound;
308     }
309
310     addrlen = (socklen_t_equiv)sizeof(sockaddr_union);
311     size = recvfrom(sock, dgram->data, (size_t)MAX_DGRAM, 0,
312                     (struct sockaddr *)fromaddr, &addrlen);
313     if(size == -1) {
314         save_errno = errno;
315         dbprintf(_("dgram_recv: recvfrom() failed: %s\n"), strerror(save_errno));
316         errno = save_errno;
317         return -1;
318     }
319     dump_sockaddr(fromaddr);
320     dgram->len = (size_t)size;
321     dgram->data[size] = '\0';
322     dgram->cur = dgram->data;
323     return size;
324 }
325
326
327 void
328 dgram_zero(
329     dgram_t *   dgram)
330 {
331     dgram->cur = dgram->data;
332     dgram->len = 0;
333     *(dgram->cur) = '\0';
334 }
335
336 printf_arglist_function1(int dgram_cat, dgram_t *, dgram, const char *, fmt)
337 {
338     ssize_t bufsize;
339     va_list argp;
340     int len;
341
342     assert(dgram != NULL);
343     assert(fmt != NULL);
344
345     assert(dgram->len == (size_t)(dgram->cur - dgram->data));
346     assert(dgram->len < SIZEOF(dgram->data));
347
348     bufsize = (ssize_t)(sizeof(dgram->data) - dgram->len);
349     if (bufsize <= 0)
350         return -1;
351
352     arglist_start(argp, fmt);
353     len = g_vsnprintf(dgram->cur, (size_t)bufsize, fmt, argp);
354     arglist_end(argp);
355     if(len < 0) {
356         return -1;
357     } else if((ssize_t)len > bufsize) {
358         dgram->len = sizeof(dgram->data);
359         dgram->cur = dgram->data + dgram->len;
360         return -1;
361     }
362     else {
363         dgram->len += len;
364         dgram->cur = dgram->data + dgram->len;
365     }
366     return 0;
367 }
368
369 void
370 dgram_eatline(
371     dgram_t *   dgram)
372 {
373     char *p = dgram->cur;
374     char *end = dgram->data + dgram->len;
375
376     while(p < end && *p && *p != '\n')
377         p++;
378     if(*p == '\n')
379         p++;
380     dgram->cur = p;
381 }