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