git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/bnet_server.c

   1 /*
   2    Copyright (C) 2000-2004 Kern Sibbald and John Walker
   3
   4    This program is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU General Public License as
   6    published by the Free Software Foundation; either version 2 of
   7    the License, or (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public
  15    License along with this program; if not, write to the Free
  16    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  17    MA 02111-1307, USA.
  18
  19  */
  20  /*
  21   * Originally written by Kern Sibbald for inclusion in apcupsd,
  22   *  but heavily modified for Bacula
  23   *
  24   *   Version $Id$
  25   */
  26
  27 #include "bacula.h"
  28 #undef DEV_BSIZE
  29 #include <netinet/in.h>
  30 #include <sys/socket.h>
  31 #include <stdlib.h>
  32 #include <arpa/inet.h>
  33 #include <netdb.h>
  34 #ifdef HAVE_ARPA_NAMESER_H
  35 #include <arpa/nameser.h>
  36 #endif
  37 #ifdef HAVE_RESOLV_H
  38 #include <resolv.h>
  39 #endif
  40
  41
  42 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  43
  44 #ifdef HAVE_LIBWRAP
  45 #include "tcpd.h"
  46 int allow_severity = LOG_NOTICE;
  47 int deny_severity = LOG_WARNING;
  48 #endif
  49
  50 static bool quit = false;
  51
  52 void bnet_stop_thread_server(pthread_t tid)
  53 {
  54    quit = true;
  55    if (!pthread_equal(tid, pthread_self())) {
  56       pthread_kill(tid, TIMEOUT_SIGNAL);
  57    }
  58 }
  59
  60 /*
  61         Become Threaded Network Server
  62     This function is able to handle multiple server ips in
  63     ipv4 and ipv6 style. The Addresse are give in a comma
  64     seperated string in bind_addr
  65     In the moment it is inpossible to bind different ports.
  66 */
  67 void
  68 bnet_thread_server(dlist *addrs, int max_clients, workq_t *client_wq,
  69                    void *handle_client_request(void *bsock))
  70 {
  71    int newsockfd, stat;
  72    socklen_t clilen;
  73    struct sockaddr cli_addr;       /* client's address */
  74    int tlog;
  75    int turnon = 1;
  76 #ifdef HAVE_LIBWRAP
  77    struct request_info request;
  78 #endif
  79    IPADDR *p;
  80    struct s_sockfd {
  81       dlink link;                     /* this MUST be the first item */
  82       int fd;
  83       int port;
  84    } *fd_ptr = NULL;
  85    char buf[128];
  86    dlist sockfds;
  87
  88    char allbuf[256 * 10];
  89    Dmsg1(100, "Addresses %s\n", build_addresses_str(addrs, allbuf, sizeof(allbuf)));
  90
  91    foreach_dlist(p, addrs) {
  92       /* Allocate on stack frame -- no need to free */
  93       fd_ptr = (s_sockfd *)alloca(sizeof(s_sockfd));
  94       fd_ptr->port = p->get_port_net_order();
  95       /*
  96        * Open a TCP socket
  97        */
  98       for (tlog= 60; (fd_ptr->fd=socket(p->get_family(), SOCK_STREAM, 0)) < 0; tlog -= 10) {
  99          if (tlog <= 0) {
 100             berrno be;
 101             char curbuf[256];
 102             Emsg3(M_ABORT, 0, _("Cannot open stream socket. ERR=%s. Current %s All %s\n"),
 103                        be.strerror(),
 104                        p->build_address_str(curbuf, sizeof(curbuf)),
 105                        build_addresses_str(addrs, allbuf, sizeof(allbuf)));
 106          }
 107          bmicrosleep(10, 0);
 108       }
 109       /*
 110        * Reuse old sockets
 111        */
 112       if (setsockopt(fd_ptr->fd, SOL_SOCKET, SO_REUSEADDR, (sockopt_val_t)&turnon,
 113            sizeof(turnon)) < 0) {
 114          berrno be;
 115          Emsg1(M_WARNING, 0, _("Cannot set SO_REUSEADDR on socket: %s\n"),
 116                be.strerror());
 117       }
 118
 119       int tmax = 30 * (60 / 5);    /* wait 30 minutes max */
 120       /* FIXME i can go to a endless loop i get a invalid address */
 121       for (tlog = 0; bind(fd_ptr->fd, p->get_sockaddr(), p->get_sockaddr_len()) < 0; tlog -= 5) {
 122          berrno be;
 123          if (tlog <= 0) {
 124             tlog = 2 * 60;         /* Complain every 2 minutes */
 125             Emsg2(M_WARNING, 0, _("Cannot bind port %d: ERR=%s. Retrying ...\n"),
 126                   ntohs(fd_ptr->port), be.strerror());
 127          }
 128          bmicrosleep(5, 0);
 129          if (--tmax <= 0) {
 130             Emsg2(M_ABORT, 0, _("Cannot bind port %d: ERR=%s.\n"), ntohs(fd_ptr->port),
 131                   be.strerror());
 132          }
 133       }
 134       listen(fd_ptr->fd, 5);       /* tell system we are ready */
 135       sockfds.append(fd_ptr);
 136    }
 137    /* Start work queue thread */
 138    if ((stat = workq_init(client_wq, max_clients, handle_client_request)) != 0) {
 139       berrno be;
 140       be.set_errno(stat);
 141       Emsg1(M_ABORT, 0, _("Could not init client queue: ERR=%s\n"), be.strerror());
 142    }
 143    /*
 144     * Wait for a connection from the client process.
 145     */
 146    for (; !quit;) {
 147       unsigned int maxfd = 0;
 148       fd_set sockset;
 149       FD_ZERO(&sockset);
 150       foreach_dlist(fd_ptr, &sockfds) {
 151          FD_SET((unsigned)fd_ptr->fd, &sockset);
 152          maxfd = maxfd > (unsigned)fd_ptr->fd ? maxfd : fd_ptr->fd;
 153       }
 154       errno = 0;
 155       if ((stat = select(maxfd + 1, &sockset, NULL, NULL, NULL)) < 0) {
 156          berrno be;                   /* capture errno */
 157          if (errno == EINTR || errno == EAGAIN) {
 158             continue;
 159          }
 160          /* Error, get out */
 161          foreach_dlist(fd_ptr, &sockfds) {
 162             close(fd_ptr->fd);
 163             free((void *)fd_ptr);
 164          }
 165          Emsg1(M_FATAL, 0, _("Error in select: %s\n"), be.strerror());
 166          break;
 167       }
 168
 169       foreach_dlist(fd_ptr, &sockfds) {
 170          if (FD_ISSET(fd_ptr->fd, &sockset)) {
 171             /* Got a connection, now accept it. */
 172             do {
 173                clilen = sizeof(cli_addr);
 174                newsockfd = accept(fd_ptr->fd, &cli_addr, &clilen);
 175             } while (newsockfd < 0 && (errno == EINTR || errno == EAGAIN));
 176             if (newsockfd < 0) {
 177                continue;
 178             }
 179 #ifdef HAVE_LIBWRAP
 180             P(mutex);              /* hosts_access is not thread safe */
 181             request_init(&request, RQ_DAEMON, my_name, RQ_FILE, newsockfd, 0);
 182             fromhost(&request);
 183             if (!hosts_access(&request)) {
 184                V(mutex);
 185 #ifndef HAVE_INET_NTOP
 186                Jmsg2(NULL, M_SECURITY, 0,
 187                      _("Connection from %s:%d refused by hosts.access\n"),
 188                      inet_ntoa(((sockaddr_in *)&cli_addr)->sin_addr),
 189                      ntohs(((sockaddr_in *)&cli_addr)->sin_port));
 190 #else
 191                Jmsg2(NULL, M_SECURITY, 0,
 192                      _("Connection from %s:%d refused by hosts.access\n"),
 193                      inet_ntop(clilen == sizeof(sockaddr_in) ? AF_INET : AF_INET6,
 194                                &clilen, buf, clilen),
 195                      ntohs(clilen == sizeof(sockaddr_in) ?
 196                            ((sockaddr_in *)&cli_addr)->sin_port :
 197                             ((sockaddr_in6 *)&cli_addr)->sin6_port));
 198 #endif
 199                close(newsockfd);
 200                continue;
 201             }
 202             V(mutex);
 203 #endif
 204
 205             /*
 206              * Receive notification when connection dies.
 207              */
 208             if (setsockopt(newsockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon,
 209                  sizeof(turnon)) < 0) {
 210                berrno be;
 211                Emsg1(M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 212                      be.strerror());
 213             }
 214
 215             /* see who client is. i.e. who connected to us. */
 216             P(mutex);
 217 #ifdef HAVE_INET_NTOP
 218             inet_ntop(clilen == sizeof(sockaddr_in) ? AF_INET : AF_INET6, &clilen,
 219                       buf, sizeof(buf));
 220 #else
 221             bstrncpy(buf, inet_ntoa(((sockaddr_in *)&cli_addr)->sin_addr), sizeof(buf));      /* NOT thread safe, use mutex */
 222 #endif
 223             V(mutex);
 224             BSOCK *bs;
 225             bs = init_bsock(NULL, newsockfd, "client", buf, fd_ptr->port, &cli_addr);
 226             if (bs == NULL) {
 227                Jmsg0(NULL, M_ABORT, 0, _("Could not create client BSOCK.\n"));
 228             }
 229
 230             /* Queue client to be served */
 231             if ((stat = workq_add(client_wq, (void *)bs, NULL, 0)) != 0) {
 232                berrno be;
 233                be.set_errno(stat);
 234                Jmsg1(NULL, M_ABORT, 0, _("Could not add job to client queue: ERR=%s\n"),
 235                      be.strerror());
 236             }
 237          }
 238       }
 239    }
 240
 241    /* Stop work queue thread */
 242    if ((stat = workq_destroy(client_wq)) != 0) {
 243       berrno be;
 244       be.set_errno(stat);
 245       Emsg1(M_FATAL, 0, _("Could not destroy client queue: ERR=%s\n"),
 246             be.strerror());
 247    }
 248 }
 249
 250
 251 #ifdef REALLY_USED
 252 /*
 253  * Bind an address so that we may accept connections
 254  * one at a time.
 255  */
 256 BSOCK *bnet_bind(int port)
 257 {
 258    int sockfd;
 259    struct sockaddr_in serv_addr;   /* our address */
 260    int tlog;
 261    int turnon = 1;
 262
 263    /*
 264     * Open a TCP socket
 265     */
 266    for (tlog = 0; (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0; tlog -= 10) {
 267       if (errno == EINTR || errno == EAGAIN) {
 268          continue;
 269       }
 270       if (tlog <= 0) {
 271          tlog = 2 * 60;
 272          Emsg1(M_ERROR, 0, _("Cannot open stream socket: %s\n"), strerror(errno));
 273       }
 274       bmicrosleep(60, 0);
 275    }
 276
 277    /*
 278     * Reuse old sockets
 279     */
 280    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 281       Emsg1(M_WARNING, 0, _("Cannot set SO_REUSEADDR on socket: %s\n"),
 282             strerror(errno));
 283    }
 284
 285    /*
 286     * Bind our local address so that the client can send to us.
 287     */
 288    bzero((char *)&serv_addr, sizeof(serv_addr));
 289    serv_addr.sin_family = AF_INET;
 290    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 291    serv_addr.sin_port = htons(port);
 292
 293    for (tlog = 0; bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0;
 294         tlog -= 5) {
 295       berrno be;
 296       if (errno == EINTR || errno == EAGAIN) {
 297          continue;
 298       }
 299       if (tlog <= 0) {
 300          tlog = 2 * 60;
 301          Emsg2(M_WARNING, 0, _("Cannot bind port %d: ERR=%s: retrying ...\n"), port,
 302                be.strerror());
 303       }
 304       bmicrosleep(5, 0);
 305    }
 306    listen(sockfd, 1);              /* tell system we are ready */
 307    return init_bsock(NULL, sockfd, _("Server socket"), _("client"), port,
 308                      &serv_addr);
 309 }
 310
 311 /*
 312  * Accept a single connection
 313  */
 314 BSOCK *bnet_accept(BSOCK * bsock, char *who)
 315 {
 316    fd_set ready, sockset;
 317    int newsockfd, stat, len;
 318    socklen_t clilen;
 319    struct sockaddr_in cli_addr;    /* client's address */
 320    char *caller, *buf;
 321    BSOCK *bs;
 322    int turnon = 1;
 323 #ifdef HAVE_LIBWRAP
 324    struct request_info request;
 325 #endif
 326
 327    /*
 328     * Wait for a connection from the client process.
 329     */
 330    FD_ZERO(&sockset);
 331    FD_SET((unsigned)bsock->fd, &sockset);
 332
 333    for (;;) {
 334       /*
 335        * Wait for a connection from a client process.
 336        */
 337       ready = sockset;
 338       if ((stat = select(bsock->fd + 1, &ready, NULL, NULL, NULL)) < 0) {
 339          if (errno == EINTR || errno = EAGAIN) {
 340             errno = 0;
 341             continue;
 342          }
 343          Emsg1(M_FATAL, 0, _("Error in select: %s\n"), strerror(errno));
 344          newsockfd = -1;
 345          break;
 346       }
 347       do {
 348          clilen = sizeof(cli_addr);
 349          newsockfd = accept(bsock->fd, (struct sockaddr *)&cli_addr, &clilen);
 350       } while (newsockfd < 0 && (errno == EINTR || errno = EAGAIN));
 351       if (newsockfd >= 0) {
 352          break;
 353       }
 354    }
 355
 356 #ifdef HAVE_LIBWRAP
 357    P(mutex);
 358    request_init(&request, RQ_DAEMON, my_name, RQ_FILE, newsockfd, 0);
 359    fromhost(&request);
 360    if (!hosts_access(&request)) {
 361       V(mutex);
 362       Emsg2(M_SECURITY, 0, _("Connection from %s:%d refused by hosts.access\n"),
 363             inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
 364       close(newsockfd);
 365       return NULL;
 366    }
 367    V(mutex);
 368 #endif
 369
 370    /*
 371     * Receive notification when connection dies.
 372     */
 373    if (setsockopt(newsockfd, SOL_SOCKET, SO_KEEPALIVE, (sockopt_val_t)&turnon, sizeof(turnon)) < 0) {
 374       Emsg1(M_WARNING, 0, _("Cannot set SO_KEEPALIVE on socket: %s\n"),
 375             strerror(errno));
 376    }
 377
 378    /* see who client is. I.e. who connected to us.
 379     * return it in the input message buffer.
 380     */
 381    if ((caller = inet_ntoa(cli_addr.sin_addr)) != NULL) {
 382       pm_strcpy(&bsock->msg, caller);
 383    } else {
 384       bsock->msg[0] = 0;
 385    }
 386    bsock->msglen = strlen(bsock->msg);
 387
 388    if (newsockfd < 0) {
 389       Emsg2(M_FATAL, 0, _("Socket accept error for %s. ERR=%s\n"), who,
 390             strerror(errno));
 391       return NULL;
 392    } else {
 393       if (caller == NULL) {
 394          caller = "unknown";
 395       }
 396       len = strlen(caller) + strlen(who) + 3;
 397       buf = (char *)malloc(len);
 398       bstrncpy(buf, len, who);
 399       bstrncat(buf, len, ": ");
 400       bstrncat(buf, len, caller);
 401       bs = init_bsock(NULL, newsockfd, "client", buf, bsock->port, &cli_addr);
 402       free(buf);
 403       return bs;                   /* return new BSOCK */
 404    }
 405 }
 406
 407 #endif