src/socket.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2009 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 /* $Core */
  15
  16 #include "inspircd.h"
  17 #include "socket.h"
  18 #include "socketengine.h"
  19 using irc::sockets::sockaddrs;
  20
  21 /** This will bind a socket to a port. It works for UDP/TCP.
  22  * It can only bind to IP addresses, if you wish to bind to hostnames
  23  * you should first resolve them using class 'Resolver'.
  24  */
  25 bool InspIRCd::BindSocket(int sockfd, int port, const char* addr, bool dolisten)
  26 {
  27         sockaddrs servaddr;
  28         int ret;
  29
  30         if (*addr == '*')
  31                 addr = "";
  32
  33         if (*addr)
  34         {
  35                 irc::sockets::aptosa(addr, port, &servaddr);
  36         }
  37         else
  38         {
  39                 memset(&servaddr, 0, sizeof(servaddr));
  40                 if (port == -1)
  41                 {
  42                         /* Port -1: Means UDP IPV4 port binding - Special case
  43                          * used by DNS engine.
  44                          */
  45                         servaddr.in4.sin_family = AF_INET;
  46                 }
  47                 else
  48                 {
  49                         /* No address */
  50 #ifdef IPV6
  51                         /* Default to ipv6 bind to all */
  52                         servaddr.in6.sin6_family = AF_INET6;
  53                         servaddr.in6.sin6_port = htons(port);
  54 #else
  55                         /* Bind ipv4 to all */
  56                         servaddr.in4.sin_family = AF_INET;
  57                         servaddr.in4.sin_port = htons(port);
  58 #endif
  59                 }
  60         }
  61         ret = SE->Bind(sockfd, &servaddr.sa, sa_size(servaddr));
  62
  63         if (ret < 0)
  64         {
  65                 return false;
  66         }
  67         else
  68         {
  69                 if (dolisten)
  70                 {
  71                         if (SE->Listen(sockfd, Config->MaxConn) == -1)
  72                         {
  73                                 this->Logs->Log("SOCKET",DEFAULT,"ERROR in listen(): %s",strerror(errno));
  74                                 return false;
  75                         }
  76                         else
  77                         {
  78                                 this->Logs->Log("SOCKET",DEBUG,"New socket binding for %d with listen: %s:%d", sockfd, addr, port);
  79                                 SE->NonBlocking(sockfd);
  80                                 return true;
  81                         }
  82                 }
  83                 else
  84                 {
  85                         this->Logs->Log("SOCKET",DEBUG,"New socket binding for %d without listen: %s:%d", sockfd, addr, port);
  86                         return true;
  87                 }
  88         }
  89 }
  90
  91 // Open a TCP Socket
  92 int irc::sockets::OpenTCPSocket(const char* addr, int socktype)
  93 {
  94         int sockfd;
  95         int on = 1;
  96         addr = addr;
  97         struct linger linger = { 0, 0 };
  98         if (!*addr)
  99         {
 100 #ifdef IPV6
 101                 sockfd = socket (PF_INET6, socktype, 0);
 102                 if (sockfd < 0)
 103 #endif
 104                         sockfd = socket (PF_INET, socktype, 0);
 105         }
 106         else if (strchr(addr,':'))
 107                 sockfd = socket (PF_INET6, socktype, 0);
 108         else
 109                 sockfd = socket (PF_INET, socktype, 0);
 110
 111         if (sockfd < 0)
 112         {
 113                 return ERROR;
 114         }
 115         else
 116         {
 117                 setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
 118                 /* This is BSD compatible, setting l_onoff to 0 is *NOT* http://web.irc.org/mla/ircd-dev/msg02259.html */
 119                 linger.l_onoff = 1;
 120                 linger.l_linger = 1;
 121                 setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger));
 122                 return (sockfd);
 123         }
 124 }
 125
 126 // XXX: it would be VERY nice to genericize this so all listen stuff (server/client) could use the one function. -- w00t
 127 int InspIRCd::BindPorts(FailedPortList &failed_ports)
 128 {
 129         char configToken[MAXBUF], Addr[MAXBUF], Type[MAXBUF];
 130         int bound = 0;
 131         bool started_with_nothing = (ports.size() == 0);
 132         std::vector<std::pair<std::string, int> > old_ports;
 133
 134         /* XXX: Make a copy of the old ip/port pairs here */
 135         for (std::vector<ListenSocketBase *>::iterator o = ports.begin(); o != ports.end(); ++o)
 136                 old_ports.push_back(make_pair((*o)->GetIP(), (*o)->GetPort()));
 137
 138         for (int count = 0; count < Config->ConfValueEnum("bind"); count++)
 139         {
 140                 Config->ConfValue("bind", "port", count, configToken, MAXBUF);
 141                 Config->ConfValue("bind", "address", count, Addr, MAXBUF);
 142                 Config->ConfValue("bind", "type", count, Type, MAXBUF);
 143
 144                 if (strncmp(Addr, "::ffff:", 7) == 0)
 145                         this->Logs->Log("SOCKET",DEFAULT, "Using 4in6 (::ffff:) isn't recommended. You should bind IPv4 addresses directly instead.");
 146
 147                 if ((!*Type) || (!strcmp(Type,"clients")))
 148                 {
 149                         irc::portparser portrange(configToken, false);
 150                         int portno = -1;
 151                         while (0 != (portno = portrange.GetToken()))
 152                         {
 153                                 if (*Addr == '*')
 154                                         *Addr = 0;
 155
 156                                 bool skip = false;
 157                                 for (std::vector<ListenSocketBase *>::iterator n = ports.begin(); n != ports.end(); ++n)
 158                                 {
 159                                         if (((*n)->GetIP() == Addr) && ((*n)->GetPort() == portno))
 160                                         {
 161                                                 skip = true;
 162                                                 /* XXX: Here, erase from our copy of the list */
 163                                                 for (std::vector<std::pair<std::string, int> >::iterator k = old_ports.begin(); k != old_ports.end(); ++k)
 164                                                 {
 165                                                         if ((k->first == Addr) && (k->second == portno))
 166                                                         {
 167                                                                 old_ports.erase(k);
 168                                                                 break;
 169                                                         }
 170                                                 }
 171                                         }
 172                                 }
 173                                 if (!skip)
 174                                 {
 175                                         ClientListenSocket *ll = new ClientListenSocket(this, portno, Addr);
 176                                         if (ll->GetFd() > -1)
 177                                         {
 178                                                 bound++;
 179                                                 ports.push_back(ll);
 180                                         }
 181                                         else
 182                                         {
 183                                                 failed_ports.push_back(std::make_pair((*Addr ? Addr : "*") + std::string(":") + ConvToStr(portno), strerror(errno)));
 184                                         }
 185                                 }
 186                         }
 187                 }
 188         }
 189
 190         /* XXX: Here, anything left in our copy list, close as removed */
 191         if (!started_with_nothing)
 192         {
 193                 for (size_t k = 0; k < old_ports.size(); ++k)
 194                 {
 195                         for (std::vector<ListenSocketBase *>::iterator n = ports.begin(); n != ports.end(); ++n)
 196                         {
 197                                 if (((*n)->GetIP() == old_ports[k].first) && ((*n)->GetPort() == old_ports[k].second))
 198                                 {
 199                                         this->Logs->Log("SOCKET",DEFAULT,"Port binding %s:%d was removed from the config file, closing.", old_ports[k].first.c_str(), old_ports[k].second);
 200                                         delete *n;
 201                                         ports.erase(n);
 202                                         break;
 203                                 }
 204                         }
 205                 }
 206         }
 207
 208         return bound;
 209 }
 210
 211 bool irc::sockets::aptosa(const char* addr, int port, irc::sockets::sockaddrs* sa)
 212 {
 213         memset(sa, 0, sizeof(*sa));
 214         if (!addr || !*addr)
 215         {
 216 #ifdef IPV6
 217                 sa->in6.sin6_family = AF_INET6;
 218                 sa->in6.sin6_port = htons(port);
 219 #else
 220                 sa->in4.sin_family = AF_INET;
 221                 sa->in4.sin_port = htons(port);
 222 #endif
 223                 return true;
 224         }
 225         else if (inet_pton(AF_INET, addr, &sa->in4.sin_addr) > 0)
 226         {
 227                 sa->in4.sin_family = AF_INET;
 228                 sa->in4.sin_port = htons(port);
 229                 return true;
 230         }
 231         else if (inet_pton(AF_INET6, addr, &sa->in6.sin6_addr) > 0)
 232         {
 233                 sa->in6.sin6_family = AF_INET6;
 234                 sa->in6.sin6_port = htons(port);
 235                 return true;
 236         }
 237         return false;
 238 }
 239
 240 bool irc::sockets::satoap(const irc::sockets::sockaddrs* sa, std::string& addr, int &port) {
 241         char addrv[INET6_ADDRSTRLEN+1];
 242         if (sa->sa.sa_family == AF_INET)
 243         {
 244                 if (!inet_ntop(AF_INET, &sa->in4.sin_addr, addrv, sizeof(addrv)))
 245                         return false;
 246                 addr = addrv;
 247                 port = ntohs(sa->in4.sin_port);
 248                 return true;
 249         }
 250         else if (sa->sa.sa_family == AF_INET6)
 251         {
 252                 if (!inet_ntop(AF_INET6, &sa->in6.sin6_addr, addrv, sizeof(addrv)))
 253                         return false;
 254                 addr = addrv;
 255                 port = ntohs(sa->in6.sin6_port);
 256                 return true;
 257         }
 258         return false;
 259 }
 260
 261 static const char all_zero[16] = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 };
 262
 263 std::string irc::sockets::satouser(const irc::sockets::sockaddrs* sa) {
 264         char buffer[MAXBUF];
 265         if (sa->sa.sa_family == AF_INET)
 266         {
 267                 if (sa->in4.sin_addr.s_addr == 0)
 268                 {
 269                         sprintf(buffer, "*:%u", ntohs(sa->in4.sin_port));
 270                 }
 271                 else
 272                 {
 273                         const uint8_t* bits = reinterpret_cast<const uint8_t*>(&sa->in4.sin_addr);
 274                         sprintf(buffer, "%d.%d.%d.%d:%u", bits[0], bits[1], bits[2], bits[3], ntohs(sa->in4.sin_port));
 275                 }
 276         }
 277         else if (sa->sa.sa_family == AF_INET6)
 278         {
 279                 if (!memcmp(all_zero, &sa->in6.sin6_addr, 16))
 280                 {
 281                         sprintf(buffer, "*:%u", ntohs(sa->in6.sin6_port));
 282                 }
 283                 else
 284                 {
 285                         buffer[0] = '[';
 286                         if (!inet_ntop(AF_INET6, &sa->in6.sin6_addr, buffer+1, MAXBUF - 10))
 287                                 return "<unknown>"; // should never happen, buffer is large enough
 288                         int len = strlen(buffer);
 289                         // no need for snprintf, buffer has at least 9 chars left, max short len = 5
 290                         sprintf(buffer + len, "]:%u", ntohs(sa->in6.sin6_port));
 291                 }
 292         }
 293         else
 294                 return "<unknown>";
 295         return std::string(buffer);
 296 }
 297
 298 int irc::sockets::sa_size(irc::sockets::sockaddrs& sa)
 299 {
 300         if (sa.sa.sa_family == AF_INET)
 301                 return sizeof(sa.in4);
 302         if (sa.sa.sa_family == AF_INET6)
 303                 return sizeof(sa.in6);
 304         return 0;
 305 }