3 #include "../Engine.hh"

     6 

     7 NetworkSocket::NetworkSocket (int family, int socktype, int protocol) :

     8     fd(-1), family(family), socktype(socktype), protocol(protocol), bound(false)

     9 {

    10 

    11 }

    12         

    13 NetworkSocket::NetworkSocket (int fd) :

    14     fd(fd), family(0), socktype(0), protocol(0), bound(false)

    15 {

    16     

    17 }

    18         

    19 NetworkSocket::~NetworkSocket (void) {

    20     // close any remaining socket

    21     if (fd >= 0)

    22         force_close();

    23 }

    24         

    25 void NetworkSocket::lazy_socket (int family, int socktype, int protocol) {

    26     // if we already have a socket, exit

    27     if (fd >= 0)

    28         return;

    29     

    30     // check that we don't have conflicting family/type/protocol

    31     if (

    32         (this->family && family != this->family) || 

    33         (this->socktype && socktype != this->socktype) || 

    34         (this->protocol && protocol != this->protocol)

    35     )

    36         throw NetworkSocketError(*this, "socket.create", "family/socktype/protocol mismatch");

    37     

    38     // create the socket or fail

    39     if ((fd = ::socket(family, socktype, protocol)) < 0)

    40         throw NetworkSocketOSError(*this, "socket");

    41 

    42     // update our family/type/protocol

    43     this->family = family;

    44     this->socktype = socktype;

    45     this->protocol = protocol;

    46 }

    47         

    48 void NetworkSocket::force_close (void) {

    49     // use closesocket

    50     if (::closesocket(fd))

    51         Engine::log(WARN, "socket.force_close") << "error closing socket: " /* XXX: errno */;

    52     

    53     // invalidate fd

    54     fd = -1;

    55 }

    56 

    57 void NetworkSocket::bind (const NetworkAddress &addr) {

    58     // get our addrinfo

    59     addrinfo *r, *results = addr.get_addrinfo(family, socktype, protocol, AI_PASSIVE);

    60     

    61     // find the right address to bind to

    62     for (r = results; r; r = r->ai_next) {

    63         // create socket if needed, warn on errors

    64         try {

    65             lazy_socket(r->ai_family, r->ai_socktype, r->ai_protocol);

    66 

    67         } catch (NetworkSocketError &e) {

    68             Engine::log(WARN, "socket.bind") << "unable to create socket for " << r << ": " << e.what();

    69             continue;

    70         }

    71 

    72         // bind it, warn on errors

    73         if (::bind(fd, r->ai_addr, r->ai_addrlen)) {

    74             Engine::log(WARN, "socket.bind") << "unable to bind on " << r /* XXX: errno */ ;

    75             

    76             // close the bad socket

    77             force_close();

    78 

    79             continue;

    80 

    81         } else {

    82             // we have a bound socket, break

    83             break;

    84         }

    85     }

    86    

    87     // release our addrinfo

    88     freeaddrinfo(results);

    89 

    90     // if we failed to bind, r is a NULL pointer

    91     if (r == NULL)

    92         throw NetworkSocketError(*this, "bind", "unable to bind on any addresses");

    93 

    94     // mark ourselves as bound

    95     bound = true;

    96 }

    97         

    98 void NetworkSocket::listen (int backlog) {

    99     // just call listen

   100     if (::listen(fd, backlog))

   101         throw NetworkSocketOSError(*this, "listen");

   102 }

   103         

   104 NetworkAddress NetworkSocket::get_local_address (void) {

   105     sockaddr_storage addr;

   106     socklen_t addrlen = sizeof(addr);

   107 

   108     // do getsockname()

   109     if (::getsockname(fd, (sockaddr *) &addr, &addrlen))

   110         throw NetworkSocketOSError(*this, "getsockname");

   111 

   112     // return addr

   113     return NetworkAddress((sockaddr *) &addr, addrlen);

   114 }

   115 

   116 NetworkAddress NetworkSocket::get_remote_address (void) {

   117     sockaddr_storage addr;

   118     socklen_t addrlen = sizeof(addr);

   119 

   120     // do getpeername()

   121     if (::getpeername(fd, (sockaddr *) &addr, &addrlen))

   122         throw NetworkSocketOSError(*this, "getpeername");

   123 

   124     // return addr

   125     return NetworkAddress((sockaddr *) &addr, addrlen);

   126 }

   127         

   128 void NetworkSocket::set_nonblocking (bool nonblocking) {

   129     // XXX: linux-specific

   130     if (fcntl(fd, F_SETFL, O_NONBLOCK, nonblocking ? 1 : 0) == -1)

   131         throw NetworkSocketOSError(*this, "fcntl(F_SETFL, O_NONBLOCK)");

   132 }

   133  

   134 NetworkSocket* NetworkSocket::accept (NetworkAddress *src) {

   135     int new_fd;

   136     sockaddr_storage addr;

   137     socklen_t addrlen = sizeof(addr);

   138 

   139     // try and get the FD

   140     if ((new_fd = ::accept(fd, (sockaddr *) &addr, &addrlen)))

   141         throw NetworkSocketOSError(*this, "accept");

   142     

   143     // allocate new NetworkSocket for new_fd

   144     NetworkSocket *socket = new NetworkSocket(new_fd);

   145     

   146     // update src

   147     if (src)

   148         src->set_sockaddr((sockaddr *) &addr, addrlen);    

   149 

   150     // done

   151     return socket;

   152 }

   153         

   154 void NetworkSocket::connect (const NetworkAddress &addr) {

   155     // get our addrinfo

   156     addrinfo *r, *results = addr.get_addrinfo(family, socktype, protocol);

   157     

   158     // find the right address to bind to

   159     for (r = results; r; r = r->ai_next) {

   160         // create socket if needed, warn on errors

   161         try {

   162             lazy_socket(r->ai_family, r->ai_socktype, r->ai_protocol);

   163 

   164         } catch (NetworkSocketError &e) {

   165             Engine::log(WARN, "socket.connect") << "unable to create socket for " << r << ": " << e.what();

   166             continue;

   167         }

   168 

   169         // connect it, warn on errors

   170         if (::connect(fd, r->ai_addr, r->ai_addrlen)) {

   171             Engine::log(WARN, "socket.connect") << "unable to connect to " << r /* XXX: errno */ ;

   172             

   173             // close unless bound, to not keep invalid sockets hanging around

   174             if (!bound)

   175                 force_close();

   176 

   177             continue;

   178 

   179         } else {

   180             // we have a connected socket, break

   181             break;

   182         }

   183     }

   184    

   185     // release our addrinfo

   186     freeaddrinfo(results);

   187 

   188     // if we failed to connect, r is a NULL pointer

   189     if (r == NULL)

   190         throw NetworkSocketError(*this, "connect", "unable to connect to any addresses");

   191 }

   192         

   193 size_t NetworkSocket::send (const char *buf, size_t size, const NetworkAddress *dest) {

   194     ssize_t ret;

   195     

   196     // use send or sendto?

   197     if (dest) {

   198         const sockaddr *addr;

   199         socklen_t addr_len;

   200         

   201         // get destination address

   202         addr = dest->get_sockaddr(addr_len);

   203         

   204         // sendto()

   205         if ((ret = ::sendto(fd, buf, size, 0, addr, addr_len)) < 0 && errno != EAGAIN)

   206             throw NetworkSocketOSError(*this, "sendto");

   207 

   208     } else {

   209         // send()

   210         if ((ret = ::send(fd, buf, size, 0)) < 0 && errno != EAGAIN)

   211             throw NetworkSocketOSError(*this, "send");

   212 

   213     }

   214     

   215     // sanity-check

   216     if (ret == 0) {

   217         // XXX: not sure what this means...

   218         Engine::log(ERROR, "socket.send") << "send[to] returned zero, trying again...";

   219         return 0;

   220     }

   221     

   222     // EAGAIN?

   223     if (ret < 0)

   224         return 0;

   225     

   226     // return number of bytes sent

   227     return ret;

   228 }

   229 

   230 size_t NetworkSocket::recv (char *buf, size_t size, NetworkAddress *src) {

   231     ssize_t ret;

   232 

   233     // use recv or recvfrom?

   234     if (src) {

   235         sockaddr_storage addr;

   236         socklen_t addr_len = sizeof(addr);

   237 

   238         // recvfrom()

   239         if ((ret = ::recvfrom(fd, buf, size, 0, (sockaddr *) &addr, &addr_len)) < 0 && errno != EAGAIN)

   240             throw NetworkSocketOSError(*this, "recvfrom");

   241 

   242         // modify src...

   243         src->set_sockaddr((sockaddr *) &addr, addr_len);

   244 

   245     } else {

   246         // recv

   247         if ((ret = ::recv(fd, buf, size, 0)) < 0 && errno != EAGAIN)

   248             throw NetworkSocketOSError(*this, "recv");

   249 

   250     }

   251 

   252     // EOF?

   253     if (ret == 0)

   254         throw NetworkSocketEOFError(*this, "recv");

   255 

   256     // EAGAIN?

   257     if (ret < 0)

   258         return 0;

   259     

   260     // return number of bytes received

   261     return ret;

   262 }

   263         

   264 void NetworkSocket::close (void) {

   265     // use closesocket

   266     if (::closesocket(fd))

   267         throw NetworkSocketOSError(*this, "close");

   268     

   269     // invalidate fd

   270     fd = -1;

   271 }