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 void set_port(len_and_sockaddr *lsa, unsigned port)
  87 {
  88 #if ENABLE_FEATURE_IPV6
  89         if (lsa->sa.sa_family == AF_INET6) {
  90                 lsa->sin6.sin6_port = port;
  91                 return;
  92         }
  93 #endif
  94         if (lsa->sa.sa_family == AF_INET) {
  95                 lsa->sin.sin_port = port;
  96                 return;
  97         }
  98         /* What? UNIX socket? IPX?? :) */
  99 }
 100
 101 /* peer: "1.2.3.4[:port]", "www.google.com[:port]"
 102  * port: if neither of above specifies port #
 103  */
 104 static len_and_sockaddr* str2sockaddr(const char *host, int 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         struct addrinfo hint;
 112
 113         /* Ugly parsing of host:addr */
 114         if (ENABLE_FEATURE_IPV6 && host[0] == '[') {
 115                 host++;
 116                 cp = strchr(host, ']');
 117                 if (!cp || cp[1] != ':') /* Malformed: must have [xx]:nn */
 118                         bb_error_msg_and_die("bad address '%s'", org_host);
 119                         //return r; /* return NULL */
 120         } else {
 121                 cp = strrchr(host, ':');
 122                 if (ENABLE_FEATURE_IPV6 && cp && strchr(host, ':') != cp) {
 123                         /* There is more than one ':' (e.g. "::1") */
 124                         cp = NULL; /* it's not a port spec */
 125                 }
 126         }
 127         if (cp) {
 128                 int sz = cp - host + 1;
 129                 host = safe_strncpy(alloca(sz), host, sz);
 130                 if (ENABLE_FEATURE_IPV6 && *cp != ':')
 131                         cp++; /* skip ']' */
 132                 cp++; /* skip ':' */
 133                 port = xatou16(cp);
 134         }
 135
 136         memset(&hint, 0 , sizeof(hint));
 137         /* hint.ai_family = AF_UNSPEC; - zero anyway */
 138 #if !ENABLE_FEATURE_IPV6
 139         hint.ai_family = AF_INET; /* do not try to find IPv6 */
 140 #endif
 141         /* Needed. Or else we will get each address thrice (or more)
 142          * for each possible socket type (tcp,udp,raw...): */
 143         hint.ai_socktype = SOCK_STREAM;
 144         hint.ai_flags = ai_flags;
 145         rc = getaddrinfo(host, NULL, &hint, &result);
 146         if (rc || !result)
 147                 bb_error_msg_and_die("bad address '%s'", org_host);
 148         r = xmalloc(offsetof(len_and_sockaddr, sa) + result->ai_addrlen);
 149         r->len = result->ai_addrlen;
 150         memcpy(&r->sa, result->ai_addr, result->ai_addrlen);
 151         set_port(r, port);
 152         freeaddrinfo(result);
 153         return r;
 154 }
 155
 156 len_and_sockaddr* host2sockaddr(const char *host, int port)
 157 {
 158         return str2sockaddr(host, port, 0);
 159 }
 160
 161 static len_and_sockaddr* dotted2sockaddr(const char *host, int port)
 162 {
 163         return str2sockaddr(host, port, NI_NUMERICHOST);
 164 }
 165
 166 static int xsocket_stream(len_and_sockaddr *lsa)
 167 {
 168         int fd;
 169 #if ENABLE_FEATURE_IPV6
 170         fd = socket(AF_INET6, SOCK_STREAM, 0);
 171         lsa->sa.sa_family = AF_INET6;
 172         lsa->len = sizeof(struct sockaddr_in6);
 173         if (fd >= 0)
 174                 return fd;
 175 #endif
 176         fd = xsocket(AF_INET, SOCK_STREAM, 0);
 177         lsa->sa.sa_family = AF_INET;
 178         lsa->len = sizeof(struct sockaddr_in);
 179         return fd;
 180 }
 181
 182 int create_and_bind_stream_or_die(const char *bindaddr, int port)
 183 {
 184         int fd;
 185         len_and_sockaddr *lsa;
 186
 187         if (bindaddr && bindaddr[0]) {
 188                 lsa = dotted2sockaddr(bindaddr, port);
 189                 /* currently NULL check is in str2sockaddr */
 190                 //if (!lsa)
 191                 //      bb_error_msg_and_die("bad address '%s'", bindaddr);
 192                 /* user specified bind addr dictates family */
 193                 fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 194         } else {
 195                 lsa = xzalloc(offsetof(len_and_sockaddr, sa) +
 196                         USE_FEATURE_IPV6(sizeof(struct sockaddr_in6))
 197                         SKIP_FEATURE_IPV6(sizeof(struct sockaddr_in))
 198                 );
 199                 fd = xsocket_stream(lsa);
 200         }
 201         setsockopt_reuseaddr(fd);
 202         xbind(fd, &lsa->sa, lsa->len);
 203         free(lsa);
 204         return fd;
 205 }
 206
 207 int create_and_connect_stream_or_die(const char *peer, int port)
 208 {
 209         int fd;
 210         len_and_sockaddr *lsa;
 211
 212         lsa = host2sockaddr(peer, port);
 213         /* currently NULL check is in str2sockaddr */
 214         //if (!lsa)
 215         //      bb_error_msg_and_die("bad address '%s'", peer);
 216         fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 217         setsockopt_reuseaddr(fd);
 218         xconnect(fd, &lsa->sa, lsa->len);
 219         free(lsa);
 220         return fd;
 221 }
 222
 223 int xconnect_stream(const len_and_sockaddr *lsa)
 224 {
 225         int fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 226         xconnect(fd, &lsa->sa, lsa->len);
 227         return fd;
 228 }
 229
 230 static char* sockaddr2str(const struct sockaddr *sa, socklen_t salen, int flags)
 231 {
 232         char host[128];
 233         char serv[16];
 234         int rc = getnameinfo(sa, salen,
 235                         host, sizeof(host),
 236                         serv, sizeof(serv),
 237                         flags | NI_NUMERICSERV /* do not resolve port# */
 238         );
 239         if (rc) return NULL;
 240         return xasprintf("%s:%s", host, serv);
 241 }
 242
 243 char* xmalloc_sockaddr2host(const struct sockaddr *sa, socklen_t salen)
 244 {
 245         return sockaddr2str(sa, salen, 0);
 246 }
 247
 248 char* xmalloc_sockaddr2dotted(const struct sockaddr *sa, socklen_t salen)
 249 {
 250         return sockaddr2str(sa, salen, NI_NUMERICHOST);
 251 }