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