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 == '*' || *addr == '\0') && port == -1)
  31         {
  32                 /* Port -1: Means UDP IPV4 port binding - Special case
  33                  * used by DNS engine.
  34                  */
  35                 memset(&servaddr, 0, sizeof(servaddr));
  36                 servaddr.in4.sin_family = AF_INET;
  37         }
  38         else if (!irc::sockets::aptosa(addr, port, servaddr))
  39                 return false;
  40
  41         ret = SE->Bind(sockfd, &servaddr.sa, sa_size(servaddr));
  42
  43         if (ret < 0)
  44         {
  45                 return false;
  46         }
  47         else
  48         {
  49                 if (dolisten)
  50                 {
  51                         if (SE->Listen(sockfd, Config->MaxConn) == -1)
  52                         {
  53                                 this->Logs->Log("SOCKET",DEFAULT,"ERROR in listen(): %s",strerror(errno));
  54                                 return false;
  55                         }
  56                         else
  57                         {
  58                                 this->Logs->Log("SOCKET",DEBUG,"New socket binding for %d with listen: %s:%d", sockfd, addr, port);
  59                                 SE->NonBlocking(sockfd);
  60                                 return true;
  61                         }
  62                 }
  63                 else
  64                 {
  65                         this->Logs->Log("SOCKET",DEBUG,"New socket binding for %d without listen: %s:%d", sockfd, addr, port);
  66                         return true;
  67                 }
  68         }
  69 }
  70
  71 // Open a TCP Socket
  72 int irc::sockets::OpenTCPSocket(const std::string& addr, int socktype)
  73 {
  74         int sockfd;
  75         int on = 1;
  76         struct linger linger = { 0, 0 };
  77         if (addr.empty())
  78         {
  79 #ifdef IPV6
  80                 sockfd = socket (PF_INET6, socktype, 0);
  81                 if (sockfd < 0)
  82 #endif
  83                         sockfd = socket (PF_INET, socktype, 0);
  84         }
  85         else if (addr.find(':') != std::string::npos)
  86                 sockfd = socket (PF_INET6, socktype, 0);
  87         else
  88                 sockfd = socket (PF_INET, socktype, 0);
  89
  90         if (sockfd < 0)
  91         {
  92                 return ERROR;
  93         }
  94         else
  95         {
  96                 setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));
  97                 /* This is BSD compatible, setting l_onoff to 0 is *NOT* http://web.irc.org/mla/ircd-dev/msg02259.html */
  98                 linger.l_onoff = 1;
  99                 linger.l_linger = 1;
 100                 setsockopt(sockfd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
 101                 return (sockfd);
 102         }
 103 }
 104
 105 int InspIRCd::BindPorts(FailedPortList &failed_ports)
 106 {
 107         int bound = 0;
 108         std::vector<ListenSocket*> old_ports(ports.begin(), ports.end());
 109
 110         ConfigTagList tags = ServerInstance->Config->ConfTags("bind");
 111         for(ConfigIter i = tags.first; i != tags.second; ++i)
 112         {
 113                 ConfigTag* tag = i->second;
 114                 std::string porttag = tag->getString("port");
 115                 std::string Addr = tag->getString("address");
 116
 117                 if (strncmp(Addr.c_str(), "::ffff:", 7) == 0)
 118                         this->Logs->Log("SOCKET",DEFAULT, "Using 4in6 (::ffff:) isn't recommended. You should bind IPv4 addresses directly instead.");
 119
 120                 irc::portparser portrange(porttag, false);
 121                 int portno = -1;
 122                 while (0 != (portno = portrange.GetToken()))
 123                 {
 124                         irc::sockets::sockaddrs bindspec;
 125                         irc::sockets::aptosa(Addr, portno, bindspec);
 126                         std::string bind_readable = irc::sockets::satouser(bindspec);
 127
 128                         bool skip = false;
 129                         for (std::vector<ListenSocket*>::iterator n = old_ports.begin(); n != old_ports.end(); ++n)
 130                         {
 131                                 if ((**n).bind_desc == bind_readable)
 132                                 {
 133                                         skip = true;
 134                                         old_ports.erase(n);
 135                                         break;
 136                                 }
 137                         }
 138                         if (!skip)
 139                         {
 140                                 ListenSocket *ll = new ListenSocket(tag, Addr, portno);
 141                                 if (ll->GetFd() > -1)
 142                                 {
 143                                         bound++;
 144                                         ports.push_back(ll);
 145                                 }
 146                                 else
 147                                 {
 148                                         failed_ports.push_back(std::make_pair(bind_readable, strerror(errno)));
 149                                         delete ll;
 150                                 }
 151                         }
 152                 }
 153         }
 154
 155         std::vector<ListenSocket*>::iterator n = ports.begin();
 156         for (std::vector<ListenSocket*>::iterator o = old_ports.begin(); o != old_ports.end(); ++o)
 157         {
 158                 while (n != ports.end() && *n != *o)
 159                         n++;
 160                 if (n == ports.end())
 161                 {
 162                         this->Logs->Log("SOCKET",ERROR,"Port bindings slipped out of vector, aborting close!");
 163                         break;
 164                 }
 165
 166                 this->Logs->Log("SOCKET",DEFAULT, "Port binding %s was removed from the config file, closing.",
 167                         (**n).bind_desc.c_str());
 168                 delete *n;
 169
 170                 // this keeps the iterator valid, pointing to the next element
 171                 n = ports.erase(n);
 172         }
 173
 174         return bound;
 175 }
 176
 177 bool irc::sockets::aptosa(const std::string& addr, int port, irc::sockets::sockaddrs& sa)
 178 {
 179         memset(&sa, 0, sizeof(sa));
 180         if (addr.empty())
 181         {
 182 #ifdef IPV6
 183                 sa.in6.sin6_family = AF_INET6;
 184                 sa.in6.sin6_port = htons(port);
 185 #else
 186                 sa.in4.sin_family = AF_INET;
 187                 sa.in4.sin_port = htons(port);
 188 #endif
 189                 return true;
 190         }
 191         else if (inet_pton(AF_INET, addr.c_str(), &sa.in4.sin_addr) > 0)
 192         {
 193                 sa.in4.sin_family = AF_INET;
 194                 sa.in4.sin_port = htons(port);
 195                 return true;
 196         }
 197         else if (inet_pton(AF_INET6, addr.c_str(), &sa.in6.sin6_addr) > 0)
 198         {
 199                 sa.in6.sin6_family = AF_INET6;
 200                 sa.in6.sin6_port = htons(port);
 201                 return true;
 202         }
 203         return false;
 204 }
 205
 206 bool irc::sockets::satoap(const irc::sockets::sockaddrs& sa, std::string& addr, int &port)
 207 {
 208         char addrv[INET6_ADDRSTRLEN+1];
 209         if (sa.sa.sa_family == AF_INET)
 210         {
 211                 if (!inet_ntop(AF_INET, &sa.in4.sin_addr, addrv, sizeof(addrv)))
 212                         return false;
 213                 addr = addrv;
 214                 port = ntohs(sa.in4.sin_port);
 215                 return true;
 216         }
 217         else if (sa.sa.sa_family == AF_INET6)
 218         {
 219                 if (!inet_ntop(AF_INET6, &sa.in6.sin6_addr, addrv, sizeof(addrv)))
 220                         return false;
 221                 addr = addrv;
 222                 port = ntohs(sa.in6.sin6_port);
 223                 return true;
 224         }
 225         return false;
 226 }
 227
 228 static const char all_zero[16] = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 };
 229
 230 std::string irc::sockets::satouser(const irc::sockets::sockaddrs& sa)
 231 {
 232         char buffer[MAXBUF];
 233         if (sa.sa.sa_family == AF_INET)
 234         {
 235                 if (sa.in4.sin_addr.s_addr == 0)
 236                 {
 237                         sprintf(buffer, "*:%u", ntohs(sa.in4.sin_port));
 238                 }
 239                 else
 240                 {
 241                         const uint8_t* bits = reinterpret_cast<const uint8_t*>(&sa.in4.sin_addr);
 242                         sprintf(buffer, "%d.%d.%d.%d:%u", bits[0], bits[1], bits[2], bits[3], ntohs(sa.in4.sin_port));
 243                 }
 244         }
 245         else if (sa.sa.sa_family == AF_INET6)
 246         {
 247                 if (!memcmp(all_zero, &sa.in6.sin6_addr, 16))
 248                 {
 249                         sprintf(buffer, "*:%u", ntohs(sa.in6.sin6_port));
 250                 }
 251                 else
 252                 {
 253                         buffer[0] = '[';
 254                         if (!inet_ntop(AF_INET6, &sa.in6.sin6_addr, buffer+1, MAXBUF - 10))
 255                                 return "<unknown>"; // should never happen, buffer is large enough
 256                         int len = strlen(buffer);
 257                         // no need for snprintf, buffer has at least 9 chars left, max short len = 5
 258                         sprintf(buffer + len, "]:%u", ntohs(sa.in6.sin6_port));
 259                 }
 260         }
 261         else
 262                 return "<unknown>";
 263         return std::string(buffer);
 264 }
 265
 266 int irc::sockets::sa_size(const irc::sockets::sockaddrs& sa)
 267 {
 268         if (sa.sa.sa_family == AF_INET)
 269                 return sizeof(sa.in4);
 270         if (sa.sa.sa_family == AF_INET6)
 271                 return sizeof(sa.in6);
 272         return 0;
 273 }
 274
 275 std::string irc::sockets::mask(irc::sockets::sockaddrs sa, unsigned int range)
 276 {
 277         unsigned char* base;
 278         unsigned int len;
 279         if (sa.sa.sa_family == AF_INET)
 280         {
 281                 base = (unsigned char*)&sa.in4.sin_addr;
 282                 len = 4;
 283         }
 284         else if (sa.sa.sa_family == AF_INET6)
 285         {
 286                 base = (unsigned char*)&sa.in6.sin6_addr;
 287                 len = 16;
 288         }
 289         else
 290                 return "";
 291         if (range > 8*len)
 292                 range = 8*len;
 293         unsigned int byte = range / 8;
 294         unsigned int bits = (-1 << (range & 7));
 295         base[byte++] &= bits;
 296         while (byte < len)
 297                 base[byte++] = 0;
 298         int dummy;
 299         std::string rv;
 300         irc::sockets::satoap(sa, rv, dummy);
 301         return rv + "/" + ConvToStr(range);
 302 }
 303