libbb/xconnect.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Utility routines.
   4  *
   5  * Connect to host at port using address resolution from getaddrinfo
   6  *
   7  */
   8
   9 #include <netinet/in.h>
  10 #include "libbb.h"
  11
  12 static const int one = 1;
  13 int setsockopt_reuseaddr(int fd)
  14 {
  15         return setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
  16 }
  17 int setsockopt_broadcast(int fd)
  18 {
  19         return setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one));
  20 }
  21
  22 void xconnect(int s, const struct sockaddr *s_addr, socklen_t addrlen)
  23 {
  24         if (connect(s, s_addr, addrlen) < 0) {
  25                 if (ENABLE_FEATURE_CLEAN_UP)
  26                         close(s);
  27                 if (s_addr->sa_family == AF_INET)
  28                         bb_perror_msg_and_die("%s (%s)",
  29                                 "cannot connect to remote host",
  30                                 inet_ntoa(((struct sockaddr_in *)s_addr)->sin_addr));
  31                 bb_perror_msg_and_die("cannot connect to remote host");
  32         }
  33 }
  34
  35 /* Return network byte ordered port number for a service.
  36  * If "port" is a number use it as the port.
  37  * If "port" is a name it is looked up in /etc/services, if it isnt found return
  38  * default_port */
  39 unsigned bb_lookup_port(const char *port, const char *protocol, unsigned default_port)
  40 {
  41         unsigned port_nr = htons(default_port);
  42         if (port) {
  43                 int old_errno;
  44
  45                 /* Since this is a lib function, we're not allowed to reset errno to 0.
  46                  * Doing so could break an app that is deferring checking of errno. */
  47                 old_errno = errno;
  48                 port_nr = bb_strtou(port, NULL, 10);
  49                 if (errno || port_nr > 65535) {
  50                         struct servent *tserv = getservbyname(port, protocol);
  51                         if (tserv)
  52                                 port_nr = tserv->s_port;
  53                 } else {
  54                         port_nr = htons(port_nr);
  55                 }
  56                 errno = old_errno;
  57         }
  58         return port_nr;
  59 }
  60
  61
  62 /* "Old" networking API - only IPv4 */
  63
  64
  65 void bb_lookup_host(struct sockaddr_in *s_in, const char *host)
  66 {
  67         struct hostent *he;
  68
  69         memset(s_in, 0, sizeof(struct sockaddr_in));
  70         s_in->sin_family = AF_INET;
  71         he = xgethostbyname(host);
  72         memcpy(&(s_in->sin_addr), he->h_addr_list[0], he->h_length);
  73 }
  74
  75 int xconnect_tcp_v4(struct sockaddr_in *s_addr)
  76 {
  77         int s = xsocket(AF_INET, SOCK_STREAM, 0);
  78         xconnect(s, (struct sockaddr*) s_addr, sizeof(*s_addr));
  79         return s;
  80 }
  81
  82
  83 /* "New" networking API */
  84
  85
  86 /* So far we do not expose struct and helpers to libbb */
  87 typedef struct len_and_sockaddr {
  88         int len;
  89         union {
  90                 struct sockaddr sa;
  91                 struct sockaddr_in sin;
  92 #if ENABLE_FEATURE_IPV6
  93                 struct sockaddr_in6 sin6;
  94 #endif
  95         };
  96 } len_and_sockaddr;
  97 //extern int xsocket_stream_ip4or6(sa_family_t *fp);
  98 //extern len_and_sockaddr* host2sockaddr(const char *host, int def_port);
  99 //extern len_and_sockaddr* dotted2sockaddr(const char *dotted, int def_port);
 100
 101 /* peer: "1.2.3.4[:port]", "www.google.com[:port]"
 102  * def_port: if neither of above specifies port #
 103  */
 104 static len_and_sockaddr* str2sockaddr(const char *host, int def_port, int ai_flags)
 105 {
 106         int rc;
 107         len_and_sockaddr *r; // = NULL;
 108         struct addrinfo *result = NULL;
 109         const char *org_host = host; /* only for error msg */
 110         const char *cp;
 111         char service[sizeof(int)*3 + 1];
 112         struct addrinfo hint;
 113
 114         /* Ugly parsing of host:addr */
 115         if (ENABLE_FEATURE_IPV6 && host[0] == '[') {
 116                 host++;
 117                 cp = strchr(host, ']');
 118                 if (!cp || cp[1] != ':') /* Malformed: must have [xx]:nn */
 119                         bb_error_msg_and_die("bad address '%s'", org_host);
 120                         //return r; /* return NULL */
 121         } else {
 122                 cp = strrchr(host, ':');
 123                 if (ENABLE_FEATURE_IPV6 && cp && strchr(host, ':') != cp) {
 124                         /* There is more than one ':' (e.g. "::1") */
 125                         cp = NULL; /* it's not a port spec */
 126                 }
 127         }
 128         if (cp) {
 129                 host = safe_strncpy(alloca(cp - host + 1), host, cp - host);
 130                 if (ENABLE_FEATURE_IPV6 && *cp != ':')
 131                         cp++; /* skip ']' */
 132                 cp++; /* skip ':' */
 133         } else {
 134                 utoa_to_buf(def_port, service, sizeof(service));
 135                 cp = service;
 136         }
 137
 138         memset(&hint, 0 , sizeof(hint));
 139         /* hint.ai_family = AF_UNSPEC; - zero anyway */
 140 #if !ENABLE_FEATURE_IPV6
 141         hint.ai_family = AF_INET; /* do not try to find IPv6 */
 142 #endif
 143         /* Needed. Or else we will get each address thrice (or more)
 144          * for each possible socket type (tcp,udp,raw...): */
 145         hint.ai_socktype = SOCK_STREAM;
 146         hint.ai_flags = ai_flags | AI_NUMERICSERV;
 147         rc = getaddrinfo(host, cp, &hint, &result);
 148         if (rc || !result)
 149                 bb_error_msg_and_die("bad address '%s'", org_host);
 150         r = xmalloc(offsetof(len_and_sockaddr, sa) + result->ai_addrlen);
 151         r->len = result->ai_addrlen;
 152         memcpy(&r->sa, result->ai_addr, result->ai_addrlen);
 153         freeaddrinfo(result);
 154         return r;
 155 }
 156
 157 static len_and_sockaddr* host2sockaddr(const char *host, int def_port)
 158 {
 159         return str2sockaddr(host, def_port, 0);
 160 }
 161
 162 static len_and_sockaddr* dotted2sockaddr(const char *host, int def_port)
 163 {
 164         return str2sockaddr(host, def_port, NI_NUMERICHOST);
 165 }
 166
 167 static int xsocket_stream_ip4or6(len_and_sockaddr *lsa)
 168 {
 169         int fd;
 170 #if ENABLE_FEATURE_IPV6
 171         fd = socket(AF_INET6, SOCK_STREAM, 0);
 172         lsa->sa.sa_family = AF_INET6;
 173         lsa->len = sizeof(struct sockaddr_in6);
 174         if (fd >= 0)
 175                 return fd;
 176 #endif
 177         fd = xsocket(AF_INET, SOCK_STREAM, 0);
 178         lsa->sa.sa_family = AF_INET;
 179         lsa->len = sizeof(struct sockaddr_in);
 180         return fd;
 181 }
 182
 183 int create_and_bind_stream_or_die(const char *bindaddr, int port)
 184 {
 185         int fd;
 186         len_and_sockaddr *lsa;
 187
 188         if (bindaddr) {
 189                 lsa = dotted2sockaddr(bindaddr, port);
 190                 /* currently NULL check is in str2sockaddr */
 191                 //if (!lsa)
 192                 //      bb_error_msg_and_die("bad address '%s'", bindaddr);
 193                 /* user specified bind addr dictates family */
 194                 fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 195         } else {
 196                 lsa = xzalloc(offsetof(len_and_sockaddr, sa) +
 197                         USE_FEATURE_IPV6(sizeof(struct sockaddr_in6))
 198                         SKIP_FEATURE_IPV6(sizeof(struct sockaddr_in))
 199                 );
 200                 fd = xsocket_stream_ip4or6(lsa);
 201         }
 202         setsockopt_reuseaddr(fd);
 203         xbind(fd, &lsa->sa, lsa->len);
 204         free(lsa);
 205         return fd;
 206 }
 207
 208 int create_and_connect_stream_or_die(const char *peer, int port)
 209 {
 210         int fd;
 211         len_and_sockaddr *lsa;
 212
 213         lsa = host2sockaddr(peer, port);
 214         /* currently NULL check is in str2sockaddr */
 215         //if (!lsa)
 216         //      bb_error_msg_and_die("bad address '%s'", peer);
 217         fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 218         setsockopt_reuseaddr(fd);
 219         xconnect(fd, &lsa->sa, lsa->len);
 220         free(lsa);
 221         return fd;
 222 }