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 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 = 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 = ntohs(tserv->s_port);
  53                 }
  54                 errno = old_errno;
  55         }
  56         return (uint16_t)port_nr;
  57 }
  58
  59
  60 /* "Old" networking API - only IPv4 */
  61
  62
  63 void bb_lookup_host(struct sockaddr_in *s_in, const char *host)
  64 {
  65         struct hostent *he;
  66
  67         memset(s_in, 0, sizeof(struct sockaddr_in));
  68         s_in->sin_family = AF_INET;
  69         he = xgethostbyname(host);
  70         memcpy(&(s_in->sin_addr), he->h_addr_list[0], he->h_length);
  71 }
  72
  73 int xconnect_tcp_v4(struct sockaddr_in *s_addr)
  74 {
  75         int s = xsocket(AF_INET, SOCK_STREAM, 0);
  76         xconnect(s, (struct sockaddr*) s_addr, sizeof(*s_addr));
  77         return s;
  78 }
  79
  80
  81 /* "New" networking API */
  82
  83
  84 int get_nport(len_and_sockaddr *lsa)
  85 {
  86 #if ENABLE_FEATURE_IPV6
  87         if (lsa->sa.sa_family == AF_INET6) {
  88                 return lsa->sin6.sin6_port;
  89         }
  90 #endif
  91         if (lsa->sa.sa_family == AF_INET) {
  92                 return lsa->sin.sin_port;
  93         }
  94         return -1;
  95         /* What? UNIX socket? IPX?? :) */
  96 }
  97
  98 void set_nport(len_and_sockaddr *lsa, unsigned port)
  99 {
 100 #if ENABLE_FEATURE_IPV6
 101         if (lsa->sa.sa_family == AF_INET6) {
 102                 lsa->sin6.sin6_port = port;
 103                 return;
 104         }
 105 #endif
 106         if (lsa->sa.sa_family == AF_INET) {
 107                 lsa->sin.sin_port = port;
 108                 return;
 109         }
 110         /* What? UNIX socket? IPX?? :) */
 111 }
 112
 113 /* peer: "1.2.3.4[:port]", "www.google.com[:port]"
 114  * port: if neither of above specifies port #
 115  */
 116 static len_and_sockaddr* str2sockaddr(const char *host, int port, int ai_flags)
 117 {
 118         int rc;
 119         len_and_sockaddr *r; // = NULL;
 120         struct addrinfo *result = NULL;
 121         const char *org_host = host; /* only for error msg */
 122         const char *cp;
 123         struct addrinfo hint;
 124
 125         /* Ugly parsing of host:addr */
 126         if (ENABLE_FEATURE_IPV6 && host[0] == '[') {
 127                 host++;
 128                 cp = strchr(host, ']');
 129                 if (!cp || cp[1] != ':') /* Malformed: must have [xx]:nn */
 130                         bb_error_msg_and_die("bad address '%s'", org_host);
 131                         //return r; /* return NULL */
 132         } else {
 133                 cp = strrchr(host, ':');
 134                 if (ENABLE_FEATURE_IPV6 && cp && strchr(host, ':') != cp) {
 135                         /* There is more than one ':' (e.g. "::1") */
 136                         cp = NULL; /* it's not a port spec */
 137                 }
 138         }
 139         if (cp) {
 140                 int sz = cp - host + 1;
 141                 host = safe_strncpy(alloca(sz), host, sz);
 142                 if (ENABLE_FEATURE_IPV6 && *cp != ':')
 143                         cp++; /* skip ']' */
 144                 cp++; /* skip ':' */
 145                 port = xatou16(cp);
 146         }
 147
 148         memset(&hint, 0 , sizeof(hint));
 149         /* hint.ai_family = AF_UNSPEC; - zero anyway */
 150 #if !ENABLE_FEATURE_IPV6
 151         hint.ai_family = AF_INET; /* do not try to find IPv6 */
 152 #endif
 153         /* Needed. Or else we will get each address thrice (or more)
 154          * for each possible socket type (tcp,udp,raw...): */
 155         hint.ai_socktype = SOCK_STREAM;
 156         hint.ai_flags = ai_flags;
 157         rc = getaddrinfo(host, NULL, &hint, &result);
 158         if (rc || !result)
 159                 bb_error_msg_and_die("bad address '%s'", org_host);
 160         r = xmalloc(offsetof(len_and_sockaddr, sa) + result->ai_addrlen);
 161         r->len = result->ai_addrlen;
 162         memcpy(&r->sa, result->ai_addr, result->ai_addrlen);
 163         set_nport(r, htons(port));
 164         freeaddrinfo(result);
 165         return r;
 166 }
 167
 168 len_and_sockaddr* host2sockaddr(const char *host, int port)
 169 {
 170         return str2sockaddr(host, port, 0);
 171 }
 172
 173 static len_and_sockaddr* dotted2sockaddr(const char *host, int port)
 174 {
 175         return str2sockaddr(host, port, NI_NUMERICHOST);
 176 }
 177
 178 int xsocket_stream(len_and_sockaddr **lsap)
 179 {
 180         len_and_sockaddr *lsa;
 181         int fd;
 182         int len = sizeof(struct sockaddr_in);
 183         int family = AF_INET;
 184
 185 #if ENABLE_FEATURE_IPV6
 186         fd = socket(AF_INET6, SOCK_STREAM, 0);
 187         if (fd >= 0) {
 188                 len = sizeof(struct sockaddr_in6);
 189                 family = AF_INET6;
 190         } else
 191 #endif
 192         {
 193                 fd = xsocket(AF_INET, SOCK_STREAM, 0);
 194         }
 195         lsa = xzalloc(offsetof(len_and_sockaddr, sa) + len);
 196         lsa->len = len;
 197         lsa->sa.sa_family = family;
 198         *lsap = lsa;
 199         return fd;
 200 }
 201
 202 int create_and_bind_stream_or_die(const char *bindaddr, int port)
 203 {
 204         int fd;
 205         len_and_sockaddr *lsa;
 206
 207         if (bindaddr && bindaddr[0]) {
 208                 lsa = dotted2sockaddr(bindaddr, port);
 209                 /* currently NULL check is in str2sockaddr */
 210                 //if (!lsa)
 211                 //      bb_error_msg_and_die("bad address '%s'", bindaddr);
 212                 /* user specified bind addr dictates family */
 213                 fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 214         } else {
 215                 fd = xsocket_stream(&lsa);
 216         }
 217         setsockopt_reuseaddr(fd);
 218         xbind(fd, &lsa->sa, lsa->len);
 219         free(lsa);
 220         return fd;
 221 }
 222
 223 int create_and_connect_stream_or_die(const char *peer, int port)
 224 {
 225         int fd;
 226         len_and_sockaddr *lsa;
 227
 228         lsa = host2sockaddr(peer, port);
 229         /* currently NULL check is in str2sockaddr */
 230         //if (!lsa)
 231         //      bb_error_msg_and_die("bad address '%s'", peer);
 232         fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 233         setsockopt_reuseaddr(fd);
 234         xconnect(fd, &lsa->sa, lsa->len);
 235         free(lsa);
 236         return fd;
 237 }
 238
 239 int xconnect_stream(const len_and_sockaddr *lsa)
 240 {
 241         int fd = xsocket(lsa->sa.sa_family, SOCK_STREAM, 0);
 242         xconnect(fd, &lsa->sa, lsa->len);
 243         return fd;
 244 }
 245
 246 static char* sockaddr2str(const struct sockaddr *sa, socklen_t salen, int flags)
 247 {
 248         char host[128];
 249         char serv[16];
 250         int rc = getnameinfo(sa, salen,
 251                         host, sizeof(host),
 252                         serv, sizeof(serv),
 253                         flags | NI_NUMERICSERV /* do not resolve port# */
 254         );
 255         if (rc) return NULL;
 256 // We probably need to use [%s]:%s for IPv6...
 257         return xasprintf("%s:%s", host, serv);
 258 }
 259
 260 char* xmalloc_sockaddr2host(const struct sockaddr *sa, socklen_t salen)
 261 {
 262         return sockaddr2str(sa, salen, 0);
 263 }
 264
 265 char* xmalloc_sockaddr2dotted(const struct sockaddr *sa, socklen_t salen)
 266 {
 267         return sockaddr2str(sa, salen, NI_NUMERICHOST);
 268 }