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         init();
  53
  54         notifier->setReadyReadFunctor(Tairon::Core::methodFunctor(this, &Socket::readyRead));
  55         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::readyWrite));
  56 }
  57 /* }}} */
  58
  59 /* {{{ Socket::~Socket() */
  60 Socket::~Socket()
  61 {
  62         // deleting notifier also deletes all created functors
  63         delete notifier;
  64         delete [] inBuffer;
  65 }
  66 /* }}} */
  67
  68 /* {{{ Socket::close() */
  69 void Socket::close()
  70 {
  71         connectedSignal.disable();
  72         errorSignal.disable();
  73         readyReadSignal.disable();
  74         readyWriteSignal.disable();
  75
  76         // this also removes socket from polling
  77         ::close(fd);
  78
  79         Poll::self()->addDeleter(createDeleter(this));
  80 }
  81 /* }}} */
  82
  83 /* {{{ Socket::connected() */
  84 void Socket::connected()
  85 {
  86         DEBUG((const char *) String("Socket::connected " + String::number(fd)));
  87
  88         fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & (!O_NONBLOCK));
  89
  90         Poll::self()->unregisterSocket(fd);
  91         delete notifier->getReadyWriteFunctor();
  92         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::readyWrite));
  93
  94         int err;
  95         socklen_t len = sizeof(err);
  96         getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
  97         if (err == 0) {
  98                 notifier->setReadyReadFunctor(Tairon::Core::methodFunctor(this, &Socket::readyRead));
  99                 // don't register socket for reading, wait for the ready method
 100                 connectedSignal.emit(this);
 101         } else
 102                 errorSignal.emit(this, err);
 103 }
 104 /* }}} */
 105
 106 /* {{{ Socket::connect(const String &) */
 107 void Socket::connect(const String &path)
 108 {
 109         if (path.length() >= 108) // length of struct socaddr_un.sun_path field
 110                 throw SocketException("Path for unix socket is too long", 0);
 111
 112         if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1)
 113                 throw SocketException("Cannot set nonblocking socket", errno);
 114
 115         sockaddr_un addr;
 116         addr.sun_family = AF_UNIX;
 117         memcpy(addr.sun_path, path.data(), path.length());
 118         addr.sun_path[path.length()] = 0;
 119
 120         int ret = ::connect(fd, (sockaddr *) &addr, sizeof(addr));
 121         if ((ret == -1) && (errno != EINPROGRESS))
 122                 throw SocketException("Error while connecting", errno);
 123
 124         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::connected));
 125
 126         Poll::self()->registerSocketToWrite(fd, notifier);
 127 }
 128 /* }}} */
 129
 130 /* {{{ Socket::connect(const String &, uint16_t) */
 131 void Socket::connect(const String &address, uint16_t port)
 132 {
 133         if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1)
 134                 throw SocketException("Cannot set nonblocking socket", errno);
 135
 136         struct hostent *host = gethostbyname(address);
 137         if (!host)
 138                 throw SocketException("Cannot resolve host name", h_errno);
 139
 140         if (host->h_addrtype != AF_INET)
 141                 throw SocketException("Invalid address type", host->h_addrtype);
 142
 143         if (!(*host->h_addr_list))
 144                 throw SocketException("Zero length list of addresses", 0);
 145
 146         sockaddr_in addr;
 147         addr.sin_family = AF_INET;
 148         addr.sin_port = htons(port);
 149         memcpy(&(addr.sin_addr.s_addr), *(host->h_addr_list), sizeof(addr.sin_addr.s_addr));
 150
 151         int ret = ::connect(fd, (sockaddr *) &addr, sizeof(addr));
 152         if ((ret == -1) && (errno != EINPROGRESS))
 153                 throw SocketException("Error while connecting", errno);
 154
 155         notifier->setReadyWriteFunctor(Tairon::Core::methodFunctor(this, &Socket::connected));
 156
 157         Poll::self()->registerSocketToWrite(fd, notifier);
 158 }
 159 /* }}} */
 160
 161 /* {{{ Socket::error() */
 162 void Socket::error()
 163 {
 164         int err;
 165         socklen_t len = sizeof(err);
 166         getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
 167         Poll::self()->unregisterSocket(fd);
 168         errorSignal.emit(this, err);
 169 }
 170 /* }}} */
 171
 172 /* {{{ Socket::init() */
 173 void Socket::init()
 174 {
 175         inBuffer = new char[bufLength];
 176         notifier = new SocketNotifier(0, 0, Tairon::Core::methodFunctor(this, &Socket::error));
 177 }
 178 /* }}} */
 179
 180 /* {{{ Socket::read(size_t) */
 181 String Socket::read(size_t max)
 182 {
 183         ssize_t len = recv(fd, inBuffer, bufLength < max ? bufLength : max, MSG_DONTWAIT);
 184         if (len == 0) // connection has been closed
 185                 throw SocketException("Connection has been closed", 0);
 186         else if (len < 0)
 187                 if ((errno != EAGAIN) && (errno != EINTR)) {
 188                         throw SocketException("Error while reading from socket", errno);
 189                 } else
 190                         len = 0;
 191         try {
 192                 Poll::self()->addSocketToRead(fd, notifier);
 193         } catch (const PollException &) { // do nothing
 194         }
 195         return String(inBuffer, len);
 196 }
 197 /* }}} */
 198
 199 /* {{{ Socket::readyRead() */
 200 void Socket::readyRead()
 201 {
 202         DEBUG((const char *) String("Socket::readyRead " + String::number((int) this)));
 203
 204         // don't make signal storm - if processing of the signals takes much time
 205         // in another thread, then there can be new data and many new signals would
 206         // be emitted
 207         try {
 208                 Poll::self()->delSocketToRead(fd, notifier);
 209         } catch (const PollException &) {
 210         }
 211         readyReadSignal.emit(this);
 212 }
 213 /* }}} */
 214
 215 /* {{{ Socket::readTo(void *, size_t) */
 216 size_t Socket::readTo(void *buf, size_t length)
 217 {
 218         ssize_t len = recv(fd, buf, length, MSG_DONTWAIT);
 219         if (len == 0) // connection has been closed
 220                 throw SocketException("Connection has been closed", 0);
 221         else if (len < 0)
 222                 if ((errno != EAGAIN) && (errno != EINTR))
 223                         throw SocketException("Error while reading from socket", errno);
 224                 else
 225                         len = 0;
 226         try {
 227                 Poll::self()->addSocketToRead(fd, notifier);
 228         } catch (const PollException &) { // do nothing
 229         }
 230         return len;
 231 }
 232 /* }}} */
 233
 234 /* {{{ Socket::ready() */
 235 void Socket::ready()
 236 {
 237         Poll::self()->registerSocketToRead(fd, notifier);
 238 }
 239 /* }}} */
 240
 241 /* {{{ Socket::readyWrite() */
 242 void Socket::readyWrite()
 243 {
 244         Poll::self()->delSocketToWrite(fd, notifier);
 245         readyWriteSignal.emit(this);
 246 }
 247 /* }}} */
 248
 249 /* {{{ Socket::write(const String &, bool) */
 250 size_t Socket::write(const String &data, bool block)
 251 {
 252         return write(data.data(), data.length(), block);
 253 }
 254 /* }}} */
 255
 256 /* {{{ Socket::write(const char *, size_t, bool) */
 257 size_t Socket::write(const char *data, size_t length, bool block)
 258 {
 259         ssize_t sent = send(fd, data, length, block ? 0 : MSG_DONTWAIT);
 260         if (sent == -1) {
 261                 if ((errno != EAGAIN) && (errno != EINTR))
 262                         throw SocketException("Error while writing to socket", errno);
 263                 try {
 264                         Poll::self()->addSocketToWrite(fd, notifier);
 265                 } catch (const PollException &) { // do nothing
 266                 }
 267                 return 0;
 268         }
 269         return sent;
 270 }
 271 /* }}} */
 272
 273
 274 /* {{{ SocketException::SocketException(const String &, int) */
 275 SocketException::SocketException(const String &desc, int err) : Tairon::Core::Exception(desc), errorNumber(err)
 276 {
 277         DEBUG((const char *) String(desc + " (" + String::number(errorNumber) + ")"));
 278 }
 279 /* }}} */
 280
 281 };
 282
 283 };
 284
 285 // vim: ai sw=4 ts=4 noet fdm=marker