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.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 }