src/net-core/socket.cpp

   1 /***************************************************************************
   2  *                                                                         *
   3  *   Copyright (C) 2006 David Brodsky                                      *
   4  *                                                                         *
   5  *   This library is free software; you can redistribute it and/or         *
   6  *   modify it under the terms of the GNU Library General Public           *
   7  *   License as published by the Free Software Foundation and appearing    *
   8  *   in the file LICENSE.LGPL included in the packaging of this file.      *
   9  *                                                                         *
  10  *   This library is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
  13  *   Library General Public License for more details.                      *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 #include <sys/un.h>
  18 #include <errno.h>
  19 #include <fcntl.h>
  20 #include <netdb.h>
  21
  22 #include <tairon/core/log.h>
  23
  24 #include "socket.h"
  25
  26 #include "deleter.h"
  27 #include "poll.h"
  28 #include "socketnotifier.h"
  29
  30 namespace Tairon
  31 {
  32
  33 namespace Net
  34 {
  35
  36 const size_t Socket::bufLength = 65536;
  37
  38 /* {{{ Socket::Socket(Family, Type) */
  39 Socket::Socket(Family family, Type type)
  40 {
  41         fd = socket(family, type, 0);
  42         if (fd == -1)
  43                 throw SocketException("Cannot create socket", errno);
  44
  45         init();
  46 }
  47 /* }}} */
  48
  49 /* {{{ Socket::Socket(int sd) */
  50 Socket::Socket(int sd) : fd(sd)
  51 {
  52         if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1)
  53                 throw SocketException("Cannot set nonblocking socket", errno);
  54
  55         init();
  56
  57         notifier->setReadyReadFunctor(Tairon::Core::methodFunctor(this, &Socket::readyRead));
  58         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::readyWrite));
  59 }
  60 /* }}} */
  61
  62 /* {{{ Socket::~Socket() */
  63 Socket::~Socket()
  64 {
  65         // deleting notifier also deletes all created functors
  66         delete notifier;
  67         delete [] inBuffer;
  68 }
  69 /* }}} */
  70
  71 /* {{{ Socket::close() */
  72 void Socket::close()
  73 {
  74         connectedSignal.disable();
  75         errorSignal.disable();
  76         readyReadSignal.disable();
  77         readyWriteSignal.disable();
  78
  79         // this also removes socket from polling
  80         ::close(fd);
  81
  82         Poll::self()->addDeleter(createDeleter(this));
  83 }
  84 /* }}} */
  85
  86 /* {{{ Socket::connected() */
  87 void Socket::connected()
  88 {
  89         DEBUG((const char *) String("Socket::connected " + String::number(fd)));
  90
  91         Poll::self()->unregisterSocket(fd);
  92         delete notifier->getReadyWriteFunctor();
  93         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::readyWrite));
  94
  95         int err;
  96         socklen_t len = sizeof(err);
  97         getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
  98         if (err == 0) {
  99                 notifier->setReadyReadFunctor(Tairon::Core::methodFunctor(this, &Socket::readyRead));
 100                 // don't register socket for reading, wait for the ready method
 101                 connectedSignal.emit(this);
 102         } else
 103                 errorSignal.emit(this, err);
 104 }
 105 /* }}} */
 106
 107 /* {{{ Socket::connect(const String &) */
 108 void Socket::connect(const String &path)
 109 {
 110         if (path.length() >= 108) // length of struct socaddr_un.sun_path field
 111                 throw SocketException("Path for unix socket is too long", 0);
 112
 113         if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1)
 114                 throw SocketException("Cannot set nonblocking socket", errno);
 115
 116         sockaddr_un addr;
 117         addr.sun_family = AF_UNIX;
 118         memcpy(addr.sun_path, path.data(), path.length());
 119         addr.sun_path[path.length()] = 0;
 120
 121         int ret = ::connect(fd, (sockaddr *) &addr, sizeof(addr));
 122         if ((ret == -1) && (errno != EINPROGRESS))
 123                 throw SocketException("Error while connecting", errno);
 124
 125         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::connected));
 126
 127         Poll::self()->registerSocketToWrite(fd, notifier);
 128 }
 129 /* }}} */
 130
 131 /* {{{ Socket::connect(const String &, uint16_t) */
 132 void Socket::connect(const String &address, uint16_t port)
 133 {
 134         if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1)
 135                 throw SocketException("Cannot set nonblocking socket", errno);
 136
 137         struct hostent *host = gethostbyname(address);
 138         if (!host)
 139                 throw SocketException("Cannot resolve host name", h_errno);
 140
 141         if (host->h_addrtype != AF_INET)
 142                 throw SocketException("Invalid address type", host->h_addrtype);
 143
 144         if (!(*host->h_addr_list))
 145                 throw SocketException("Zero length list of addresses", 0);
 146
 147         sockaddr_in addr;
 148         addr.sin_family = AF_INET;
 149         addr.sin_port = htons(port);
 150         memcpy(&(addr.sin_addr.s_addr), *(host->h_addr_list), sizeof(addr.sin_addr.s_addr));
 151
 152         int ret = ::connect(fd, (sockaddr *) &addr, sizeof(addr));
 153         if ((ret == -1) && (errno != EINPROGRESS))
 154                 throw SocketException("Error while connecting", errno);
 155
 156         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::connected));
 157
 158         Poll::self()->registerSocketToWrite(fd, notifier);
 159 }
 160 /* }}} */
 161
 162 /* {{{ Socket::error() */
 163 void Socket::error()
 164 {
 165         int err;
 166         socklen_t len = sizeof(err);
 167         getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
 168         Poll::self()->unregisterSocket(fd);
 169         errorSignal.emit(this, err);
 170 }
 171 /* }}} */
 172
 173 /* {{{ Socket::init() */
 174 void Socket::init()
 175 {
 176         inBuffer = new char[bufLength];
 177         notifier = new SocketNotifier(0, 0, Tairon::Core::methodFunctor(this, &Socket::error));
 178 }
 179 /* }}} */
 180
 181 /* {{{ Socket::read(size_t) */
 182 String Socket::read(size_t max)
 183 {
 184         ssize_t len = recv(fd, inBuffer, bufLength < max ? bufLength : max, MSG_DONTWAIT);
 185         if (len == 0) // connection has been closed
 186                 throw SocketException("Connection has been closed", 0);
 187         else if (len < 0)
 188                 if (errno != EAGAIN) {
 189                         throw SocketException("Error while reading from socket", errno);
 190                 } else
 191                         len = 0;
 192         try {
 193                 Poll::self()->addSocketToRead(fd, notifier);
 194         } catch (const PollException &) { // do nothing
 195         }
 196         return String(inBuffer, len);
 197 }
 198 /* }}} */
 199
 200 /* {{{ Socket::readyRead() */
 201 void Socket::readyRead()
 202 {
 203         DEBUG((const char *) String("Socket::readyRead " + String::number((int) this)));
 204
 205         // don't make signal storm - if processing of the signals takes much time
 206         // in another thread, then there can be new data and many new signals would
 207         // be emitted
 208         try {
 209                 Poll::self()->delSocketToRead(fd, notifier);
 210         } catch (const PollException &) {
 211         }
 212         readyReadSignal.emit(this);
 213 }
 214 /* }}} */
 215
 216 /* {{{ Socket::readTo(void *, size_t) */
 217 size_t Socket::readTo(void *buf, size_t length)
 218 {
 219         ssize_t len = recv(fd, buf, length, MSG_DONTWAIT);
 220         if (len == 0) // connection has been closed
 221                 throw SocketException("Connection has been closed", 0);
 222         else if (len < 0)
 223                 if (errno != EAGAIN)
 224                         throw SocketException("Error while reading from socket", errno);
 225                 else
 226                         len = 0;
 227         try {
 228                 Poll::self()->addSocketToRead(fd, notifier);
 229         } catch (const PollException &) { // do nothing
 230         }
 231         return len;
 232 }
 233 /* }}} */
 234
 235 /* {{{ Socket::ready() */
 236 void Socket::ready()
 237 {
 238         Poll::self()->registerSocketToRead(fd, notifier);
 239 }
 240 /* }}} */
 241
 242 /* {{{ Socket::readyWrite() */
 243 void Socket::readyWrite()
 244 {
 245         Poll::self()->delSocketToWrite(fd, notifier);
 246         readyWriteSignal.emit(this);
 247 }
 248 /* }}} */
 249
 250 /* {{{ Socket::write(const String &, bool) */
 251 size_t Socket::write(const String &data, bool block)
 252 {
 253         return write(data.data(), data.length(), block);
 254 }
 255 /* }}} */
 256
 257 /* {{{ Socket::write(const char *, size_t, bool) */
 258 size_t Socket::write(const char *data, size_t length, bool block)
 259 {
 260         ssize_t sent = send(fd, data, length, block ? 0 : MSG_DONTWAIT);
 261         if (sent == -1) {
 262                 if (errno != EAGAIN)
 263                         throw SocketException("Error while writing to socket", errno);
 264                 try {
 265                         Poll::self()->addSocketToWrite(fd, notifier);
 266                 } catch (const PollException &) { // do nothing
 267                 }
 268                 return 0;
 269         }
 270         return sent;
 271 }
 272 /* }}} */
 273
 274
 275 /* {{{ SocketException::SocketException(const String &, int) */
 276 SocketException::SocketException(const String &desc, int err) : Tairon::Core::Exception(desc), errorNumber(err)
 277 {
 278         DEBUG((const char *) String(desc + " (" + String::number(errorNumber) + ")"));
 279 }
 280 /* }}} */
 281
 282 };
 283
 284 };
 285
 286 // vim: ai sw=4 ts=4 noet fdm=marker