git.gag.com Git - debian/amanda/blob - 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 2006/07/05 19:54:20 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 #if defined(USE_REUSEADDR)
  61     const int on = 1;
  62     int r;
  63 #endif
  64
  65     *portp = (in_port_t)0;
  66     if((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
  67         save_errno = errno;
  68         dbprintf(("%s: dgram_bind: socket() failed: %s\n",
  69                   debug_prefix(NULL),
  70                   strerror(save_errno)));
  71         errno = save_errno;
  72         return -1;
  73     }
  74     if(s < 0 || s >= (int)FD_SETSIZE) {
  75         dbprintf(("%s: dgram_bind: socket out of range: %d\n",
  76                   debug_prefix(NULL),
  77                   s));
  78         aclose(s);
  79         errno = EMFILE;                         /* out of range */
  80         return -1;
  81     }
  82
  83     memset(&name, 0, SIZEOF(name));
  84     name.sin_family = (sa_family_t)AF_INET;
  85     name.sin_addr.s_addr = INADDR_ANY;
  86
  87 #ifdef USE_REUSEADDR
  88     r = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
  89         (void *)&on, (socklen_t)sizeof(on));
  90     if (r < 0) {
  91         dbprintf(("%s: dgram_bind: setsockopt(SO_REUSEADDR) failed: %s\n",
  92                   debug_prefix(NULL),
  93                   strerror(errno)));
  94     }
  95 #endif
  96
  97     /*
  98      * If a port range was specified, we try to get a port in that
  99      * range first.  Next, we try to get a reserved port.  If that
 100      * fails, we just go for any port.
 101      *
 102      * In all cases, not to use port that's assigned to other services.
 103      *
 104      * It is up to the caller to make sure we have the proper permissions
 105      * to get the desired port, and to make sure we return a port that
 106      * is within the range it requires.
 107      */
 108     for (retries = 0; ; retries++) {
 109 #ifdef UDPPORTRANGE
 110         if (bind_portrange(s, &name, UDPPORTRANGE, "udp") == 0)
 111             goto out;
 112         dbprintf(("%s: dgram_bind: Could to bind to port in range: %d - %d.\n",
 113                   debug_prefix(NULL), UDPPORTRANGE));
 114 #endif
 115
 116         if (bind_portrange(s, &name, (in_port_t)512,
 117                 (in_port_t)(IPPORT_RESERVED - 1), "udp") == 0)
 118             goto out;
 119         dbprintf(("%s: dgram_bind: Could to bind to port in range: 512 - %d.\n",
 120                   debug_prefix(NULL), IPPORT_RESERVED - 1));
 121
 122         name.sin_port = INADDR_ANY;
 123         if (bind(s, (struct sockaddr *)&name, (socklen_t)sizeof(name)) == 0)
 124             goto out;
 125         dbprintf(("%s: dgram_bind: Could to bind to any port: %s\n",
 126                   debug_prefix(NULL), strerror(errno)));
 127
 128         if (retries >= BIND_CYCLE_RETRIES) {
 129             dbprintf(("%s: dgram_bind: Giving up...\n", debug_prefix(NULL)));
 130             break;
 131         }
 132
 133         dbprintf(("%s: dgram_bind: Retrying entire range after 10 second delay.\n",
 134                   debug_prefix(NULL)));
 135         sleep(15);
 136     }
 137
 138     save_errno = errno;
 139     dbprintf(("%s: dgram_bind: bind(INADDR_ANY) failed: %s\n",
 140                   debug_prefix(NULL),
 141                   strerror(save_errno)));
 142     aclose(s);
 143     errno = save_errno;
 144     return -1;
 145
 146 out:
 147     /* find out what name was actually used */
 148
 149     len = (socklen_t)sizeof(name);
 150     if(getsockname(s, (struct sockaddr *)&name, &len) == -1) {
 151         save_errno = errno;
 152         dbprintf(("%s: dgram_bind: getsockname() failed: %s\n",
 153                   debug_prefix(NULL),
 154                   strerror(save_errno)));
 155         errno = save_errno;
 156         aclose(s);
 157         return -1;
 158     }
 159     *portp = (in_port_t)ntohs(name.sin_port);
 160     dgram->socket = s;
 161
 162     dbprintf(("%s: dgram_bind: socket bound to %s.%d\n",
 163               debug_prefix_time(NULL),
 164               inet_ntoa(name.sin_addr),
 165               *portp));
 166     return 0;
 167 }
 168
 169
 170 int
 171 dgram_send_addr(
 172     struct sockaddr_in  addr,
 173     dgram_t *           dgram)
 174 {
 175     int s, rc;
 176     int socket_opened;
 177     struct sockaddr_in addr_save;
 178     int save_errno;
 179     int max_wait;
 180     int wait_count;
 181 #if defined(USE_REUSEADDR)
 182     const int on = 1;
 183     int r;
 184 #endif
 185
 186     dbprintf(("%s: dgram_send_addr(addr=%p, dgram=%p)\n",
 187                         debug_prefix(NULL), &addr, dgram));
 188     dump_sockaddr(&addr);
 189     dbprintf(("%s: dgram_send_addr: %p->socket = %d\n",
 190                         debug_prefix(NULL), dgram, dgram->socket));
 191     if(dgram->socket != -1) {
 192         s = dgram->socket;
 193         socket_opened = 0;
 194     } else {
 195         if((s = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
 196             save_errno = errno;
 197             dbprintf(("%s: dgram_send_addr: socket() failed: %s\n",
 198                       debug_prefix(NULL),
 199                       strerror(save_errno)));
 200             errno = save_errno;
 201             return -1;
 202         }
 203         socket_opened = 1;
 204 #ifdef USE_REUSEADDR
 205         r = setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
 206                 (void *)&on, (socklen_t)sizeof(on));
 207         if (r < 0) {
 208             dbprintf(("%s: dgram_send_addr: setsockopt(SO_REUSEADDR) failed: %s\n",
 209                           debug_prefix(NULL),
 210                           strerror(errno)));
 211         }
 212 #endif
 213     }
 214
 215     memcpy(&addr_save, &addr, SIZEOF(addr));
 216     if(s < 0 || s >= FD_SETSIZE) {
 217         dbprintf(("%s: dgram_send_addr: socket out of range: %d\n",
 218                   debug_prefix(NULL),
 219                   s));
 220         errno = EMFILE;                         /* out of range */
 221         rc = -1;
 222     } else {
 223         max_wait = 300 / 5;                             /* five minutes */
 224         wait_count = 0;
 225         rc = 0;
 226         while(sendto(s,
 227                  dgram->data,
 228                  dgram->len,
 229                  0,
 230                  (struct sockaddr *)&addr,
 231                  (int)sizeof(struct sockaddr_in)) == -1) {
 232 #ifdef ECONNREFUSED
 233             if(errno == ECONNREFUSED && wait_count++ < max_wait) {
 234                 sleep(5);
 235                 dbprintf(("%s: dgram_send_addr: sendto(%s.%hu): retry %d after ECONNREFUSED\n",
 236                       debug_prefix_time(NULL),
 237                       inet_ntoa(addr_save.sin_addr),
 238                       (in_port_t)ntohs(addr.sin_port),
 239                       wait_count));
 240                 continue;
 241             }
 242 #endif
 243 #ifdef EAGAIN
 244             if(errno == EAGAIN && wait_count++ < max_wait) {
 245                 sleep(5);
 246                 dbprintf(("%s: dgram_send_addr: sendto(%s.%hu): retry %d after EAGAIN\n",
 247                       debug_prefix_time(NULL),
 248                       inet_ntoa(addr_save.sin_addr),
 249                       (in_port_t)ntohs(addr.sin_port),
 250                       wait_count));
 251                 continue;
 252             }
 253 #endif
 254             save_errno = errno;
 255             dbprintf(("%s: dgram_send_addr: sendto(%s.%d) failed: %s \n",
 256                   debug_prefix_time(NULL),
 257                   inet_ntoa(addr_save.sin_addr),
 258                   (int) ntohs(addr.sin_port),
 259                   strerror(save_errno)));
 260             errno = save_errno;
 261             rc = -1;
 262             break;
 263         }
 264     }
 265
 266     if(socket_opened) {
 267         save_errno = errno;
 268         if(close(s) == -1) {
 269             dbprintf(("%s: dgram_send_addr: close(%s.%d): failed: %s\n",
 270                       debug_prefix(NULL),
 271                       inet_ntoa(addr_save.sin_addr),
 272                       (int) ntohs(addr.sin_port),
 273                       strerror(errno)));
 274             /*
 275              * Calling function should not care that the close failed.
 276              * It does care about the send results though.
 277              */
 278         }
 279         errno = save_errno;
 280     }
 281
 282     return rc;
 283 }
 284
 285
 286 int
 287 dgram_send(
 288     char *      hostname,
 289     in_port_t   port,
 290     dgram_t *   dgram)
 291 {
 292     struct sockaddr_in name;
 293     struct hostent *hp;
 294     int save_errno;
 295
 296     if((hp = gethostbyname(hostname)) == 0) {
 297         save_errno = errno;
 298         dbprintf(("%s: dgram_send: gethostbyname(%s) failed\n",
 299                   debug_prefix_time(NULL),
 300                   hostname));
 301         errno = save_errno;
 302         return -1;
 303     }
 304     memcpy(&name.sin_addr, hp->h_addr, (size_t)hp->h_length);
 305     name.sin_family = (sa_family_t)AF_INET;
 306     name.sin_port = (in_port_t)htons(port);
 307
 308     return dgram_send_addr(name, dgram);
 309 }
 310
 311
 312 ssize_t
 313 dgram_recv(
 314     dgram_t *           dgram,
 315     int                 timeout,
 316     struct sockaddr_in *fromaddr)
 317 {
 318     SELECT_ARG_TYPE ready;
 319     struct timeval to;
 320     ssize_t size;
 321     int sock;
 322     socklen_t addrlen;
 323     ssize_t nfound;
 324     int save_errno;
 325
 326     sock = dgram->socket;
 327
 328     FD_ZERO(&ready);
 329     FD_SET(sock, &ready);
 330     to.tv_sec = timeout;
 331     to.tv_usec = 0;
 332
 333     dbprintf(("%s: dgram_recv(dgram=%p, timeout=%u, fromaddr=%p)\n",
 334                 debug_prefix_time(NULL), timeout, fromaddr));
 335     dump_sockaddr(fromaddr);
 336
 337     nfound = (ssize_t)select(sock+1, &ready, NULL, NULL, &to);
 338     if(nfound <= 0 || !FD_ISSET(sock, &ready)) {
 339         save_errno = errno;
 340         if(nfound < 0) {
 341             dbprintf(("%s: dgram_recv: select() failed: %s\n",
 342                       debug_prefix_time(NULL),
 343                       strerror(save_errno)));
 344         } else if(nfound == 0) {
 345             dbprintf(("%s: dgram_recv: timeout after %d second%s\n",
 346                       debug_prefix_time(NULL),
 347                       timeout,
 348                       (timeout == 1) ? "" : "s"));
 349             nfound = 0;
 350         } else if (!FD_ISSET(sock, &ready)) {
 351             int i;
 352
 353             for(i = 0; i < sock + 1; i++) {
 354                 if(FD_ISSET(i, &ready)) {
 355                     dbprintf(("%s: dgram_recv: got fd %d instead of %d\n",
 356                               debug_prefix_time(NULL),
 357                               i,
 358                               sock));
 359                 }
 360             }
 361             save_errno = EBADF;
 362             nfound = -1;
 363         }
 364         errno = save_errno;
 365         return nfound;
 366     }
 367
 368     addrlen = (socklen_t)sizeof(struct sockaddr_in);
 369     size = recvfrom(sock, dgram->data, (size_t)MAX_DGRAM, 0,
 370                     (struct sockaddr *)fromaddr, &addrlen);
 371     if(size == -1) {
 372         save_errno = errno;
 373         dbprintf(("%s: dgram_recv: recvfrom() failed: %s\n",
 374                   debug_prefix(NULL),
 375                   strerror(save_errno)));
 376         errno = save_errno;
 377         return -1;
 378     }
 379     dgram->len = (size_t)size;
 380     dgram->data[size] = '\0';
 381     dgram->cur = dgram->data;
 382     return size;
 383 }
 384
 385
 386 void
 387 dgram_zero(
 388     dgram_t *   dgram)
 389 {
 390     dgram->cur = dgram->data;
 391     dgram->len = 0;
 392     *(dgram->cur) = '\0';
 393 }
 394
 395 printf_arglist_function1(int dgram_cat, dgram_t *, dgram, const char *, fmt)
 396 {
 397     ssize_t bufsize;
 398     va_list argp;
 399     int len;
 400
 401     assert(dgram != NULL);
 402     assert(fmt != NULL);
 403
 404     assert(dgram->len == (size_t)(dgram->cur - dgram->data));
 405     assert(dgram->len < SIZEOF(dgram->data));
 406
 407     bufsize = (ssize_t)(sizeof(dgram->data) - dgram->len);
 408     if (bufsize <= 0)
 409         return -1;
 410
 411     arglist_start(argp, fmt);
 412     len = vsnprintf(dgram->cur, (size_t)bufsize, fmt, argp);
 413     arglist_end(argp);
 414     if((ssize_t)len > bufsize) {
 415         dgram->len = sizeof(dgram->data);
 416         dgram->cur = dgram->data + dgram->len;
 417         return -1;
 418     }
 419     else {
 420         arglist_start(argp, fmt);
 421         dgram->len += vsnprintf(dgram->cur, (size_t)bufsize, fmt, argp);
 422         arglist_end(argp);
 423         dgram->cur = dgram->data + dgram->len;
 424     }
 425     return 0;
 426 }
 427
 428 void
 429 dgram_eatline(
 430     dgram_t *   dgram)
 431 {
 432     char *p = dgram->cur;
 433     char *end = dgram->data + dgram->len;
 434
 435     while(p < end && *p && *p != '\n')
 436         p++;
 437     if(*p == '\n')
 438         p++;
 439     dgram->cur = p;
 440 }