listen.c

   1 /*
   2  * uhttpd - Tiny single-threaded httpd
   3  *
   4  *   Copyright (C) 2010-2012 Jo-Philipp Wich <xm@subsignal.org>
   5  *   Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
   6  *
   7  *  Licensed under the Apache License, Version 2.0 (the "License");
   8  *  you may not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *  Unless required by applicable law or agreed to in writing, software
  14  *  distributed under the License is distributed on an "AS IS" BASIS,
  15  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *  See the License for the specific language governing permissions and
  17  *  limitations under the License.
  18  */
  19
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <netinet/tcp.h>
  23 #include <netdb.h>
  24
  25 #include "uhttpd.h"
  26
  27 struct listener {
  28         struct list_head list;
  29         struct uloop_fd fd;
  30         int socket;
  31         int n_clients;
  32         struct sockaddr_in6 addr;
  33         bool tls;
  34         bool blocked;
  35 };
  36
  37 static LIST_HEAD(listeners);
  38 static int n_blocked;
  39
  40 static void uh_block_listener(struct listener *l)
  41 {
  42         uloop_fd_delete(&l->fd);
  43         n_blocked++;
  44         l->blocked = true;
  45 }
  46
  47 void uh_unblock_listeners(void)
  48 {
  49         struct listener *l;
  50
  51         if (!n_blocked && conf.max_requests &&
  52             n_clients >= conf.max_requests)
  53                 return;
  54
  55         list_for_each_entry(l, &listeners, list) {
  56                 if (!l->blocked)
  57                         continue;
  58
  59                 n_blocked--;
  60                 l->blocked = false;
  61                 uloop_fd_add(&l->fd, ULOOP_READ);
  62         }
  63 }
  64
  65 static void listener_cb(struct uloop_fd *fd, unsigned int events)
  66 {
  67         struct listener *l = container_of(fd, struct listener, fd);
  68
  69         uh_accept_client(fd->fd);
  70
  71         if (conf.max_requests && n_clients >= conf.max_requests)
  72                 uh_block_listener(l);
  73 }
  74
  75 void uh_setup_listeners(void)
  76 {
  77         struct listener *l;
  78
  79         list_for_each_entry(l, &listeners, list) {
  80                 l->fd.cb = listener_cb;
  81                 uloop_fd_add(&l->fd, ULOOP_READ);
  82         }
  83 }
  84
  85 int uh_socket_bind(const char *host, const char *port, bool tls)
  86 {
  87         int sock = -1;
  88         int yes = 1;
  89         int status;
  90         int bound = 0;
  91         struct listener *l = NULL;
  92         struct addrinfo *addrs = NULL, *p = NULL;
  93         static struct addrinfo hints = {
  94                 .ai_family = AF_UNSPEC,
  95                 .ai_socktype = SOCK_STREAM,
  96                 .ai_flags = AI_PASSIVE,
  97         };
  98
  99         if ((status = getaddrinfo(host, port, &hints, &addrs)) != 0) {
 100                 fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(status));
 101                 return -1;
 102         }
 103
 104         /* try to bind a new socket to each found address */
 105         for (p = addrs; p; p = p->ai_next) {
 106                 /* get the socket */
 107                 sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
 108                 if (sock < 0) {
 109                         perror("socket()");
 110                         goto error;
 111                 }
 112
 113                 /* "address already in use" */
 114                 if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))) {
 115                         perror("setsockopt()");
 116                         goto error;
 117                 }
 118
 119                 /* TCP keep-alive */
 120                 if (conf.tcp_keepalive > 0) {
 121                         int ret = 0;
 122 #ifdef linux
 123                         int tcp_ka_idl, tcp_ka_int, tcp_ka_cnt;
 124
 125                         tcp_ka_idl = 1;
 126                         tcp_ka_cnt = 3;
 127                         tcp_ka_int = conf.tcp_keepalive;
 128                         ret =   setsockopt(sock, SOL_TCP, TCP_KEEPIDLE,  &tcp_ka_idl, sizeof(tcp_ka_idl)) ||
 129                                 setsockopt(sock, SOL_TCP, TCP_KEEPINTVL, &tcp_ka_int, sizeof(tcp_ka_int)) ||
 130                                 setsockopt(sock, SOL_TCP, TCP_KEEPCNT,   &tcp_ka_cnt, sizeof(tcp_ka_cnt));
 131 #endif
 132
 133                         if (ret || setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes)))
 134                                 fprintf(stderr, "Notice: Unable to enable TCP keep-alive: %s\n",
 135                                         strerror(errno));
 136                 }
 137
 138                 /* required to get parallel v4 + v6 working */
 139                 if (p->ai_family == AF_INET6 &&
 140                     setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof(yes)) < 0) {
 141                         perror("setsockopt()");
 142                         goto error;
 143                 }
 144
 145                 /* bind */
 146                 if (bind(sock, p->ai_addr, p->ai_addrlen) < 0) {
 147                         perror("bind()");
 148                         goto error;
 149                 }
 150
 151                 /* listen */
 152                 if (listen(sock, UH_LIMIT_CLIENTS) < 0) {
 153                         perror("listen()");
 154                         goto error;
 155                 }
 156
 157                 fd_cloexec(sock);
 158
 159                 l = calloc(1, sizeof(*l));
 160                 if (!l)
 161                         goto error;
 162
 163                 l->fd.fd = sock;
 164                 l->tls = tls;
 165                 list_add_tail(&l->list, &listeners);
 166
 167                 continue;
 168
 169 error:
 170                 if (sock > -1)
 171                         close(sock);
 172         }
 173
 174         freeaddrinfo(addrs);
 175
 176         return bound;
 177 }