C++ Sockets Library

00001 
00005 /*
00006 Copyright (C) 2010-2011  Anders Hedstrom
00007 
00008 This library is made available under the terms of the GNU GPL, with
00009 the additional exemption that compiling, linking, and/or using OpenSSL 
00010 is allowed.
00011 
00012 If you would like to use this library in a closed-source application,
00013 a separate license agreement is available. For information about 
00014 the closed-source license agreement for the C++ sockets library,
00015 please visit http://www.alhem.net/Sockets/license.html and/or
00016 email license@alhem.net.
00017 
00018 This program is free software; you can redistribute it and/or
00019 modify it under the terms of the GNU General Public License
00020 as published by the Free Software Foundation; either version 2
00021 of the License, or (at your option) any later version.
00022 
00023 This program is distributed in the hope that it will be useful,
00024 but WITHOUT ANY WARRANTY; without even the implied warranty of
00025 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00026 GNU General Public License for more details.
00027 
00028 You should have received a copy of the GNU General Public License
00029 along with this program; if not, write to the Free Software
00030 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00031 */
00032 #include "SocketHandlerEp.h"
00033 #include "Exception.h"
00034 #include "IMutex.h"
00035 #include "Utility.h"
00036 
00037 #include <errno.h>
00038 
00039 
00040 #ifdef SOCKETS_NAMESPACE
00041 namespace SOCKETS_NAMESPACE {
00042 #endif
00043 
00044 
00045 SocketHandlerEp::SocketHandlerEp(StdLog *p)
00046 :SocketHandler(p)
00047 ,m_epoll(-1)
00048 {
00049 #ifdef LINUX
00050         m_epoll = epoll_create(FD_SETSIZE);
00051         if (m_epoll == -1)
00052         {
00053                 throw Exception(StrError(Errno));
00054         }
00055 #endif
00056 }
00057 
00058 
00059 SocketHandlerEp::SocketHandlerEp(IMutex& mutex, StdLog *p)
00060 :SocketHandler(mutex, p)
00061 ,m_epoll(-1)
00062 {
00063 #ifdef LINUX
00064         m_epoll = epoll_create(FD_SETSIZE);
00065         if (m_epoll == -1)
00066         {
00067                 throw Exception(StrError(Errno));
00068         }
00069 #endif
00070 }
00071 
00072 
00073 SocketHandlerEp::SocketHandlerEp(IMutex& mutex, ISocketHandler& parent, StdLog *p)
00074 :SocketHandler(mutex, parent, p)
00075 ,m_epoll(-1)
00076 {
00077 #ifdef LINUX
00078         m_epoll = epoll_create(FD_SETSIZE);
00079         if (m_epoll == -1)
00080         {
00081                 throw Exception(StrError(Errno));
00082         }
00083 #endif
00084 }
00085 
00086 
00087 SocketHandlerEp::~SocketHandlerEp()
00088 {
00089 #ifdef LINUX
00090         if (m_epoll != -1)
00091         {
00092                 close(m_epoll);
00093         }
00094 #endif
00095 }
00096 
00097 
00098 ISocketHandler *SocketHandlerEp::Create(StdLog *log)
00099 {
00100         return new SocketHandlerEp(log);
00101 }
00102 
00103 
00104 ISocketHandler *SocketHandlerEp::Create(IMutex& mutex, ISocketHandler& parent, StdLog *log)
00105 {
00106         return new SocketHandlerEp(mutex, parent, log);
00107 }
00108 
00109 
00110 #ifdef LINUX
00111 void SocketHandlerEp::ISocketHandler_Add(Socket *p,bool bRead,bool bWrite)
00112 {
00113         struct epoll_event stat;
00114         SOCKET s = p -> GetSocket();
00115         stat.data.ptr = p;
00116         stat.events = (bRead ? EPOLLIN : 0) | (bWrite ? EPOLLOUT : 0);
00117         if (epoll_ctl(m_epoll, EPOLL_CTL_ADD, s, &stat) == -1)
00118         {
00119                 LogError(NULL, "epoll_ctl: EPOLL_CTL_ADD", Errno, StrError(Errno));
00120         }
00121 }
00122 
00123 
00124 void SocketHandlerEp::ISocketHandler_Mod(Socket *p,bool r,bool w)
00125 {
00126         struct epoll_event stat;
00127         SOCKET s = p -> GetSocket();
00128         stat.data.ptr = p;
00129         stat.events = (r ? EPOLLIN : 0) | (w ? EPOLLOUT : 0);
00130         if (epoll_ctl(m_epoll, EPOLL_CTL_MOD, s, &stat) == -1)
00131         {
00132 //              LogError(NULL, "epoll_ctl: EPOLL_CTL_MOD", Errno, StrError(Errno));
00133         }
00134 }
00135 
00136 
00137 void SocketHandlerEp::ISocketHandler_Del(Socket *p)
00138 {
00139         struct epoll_event stat;
00140         stat.events = 0;
00141         stat.data.ptr = p;
00142         if (epoll_ctl(m_epoll, EPOLL_CTL_DEL, p -> GetSocket(), &stat) == -1)
00143         {
00144 //              LogError(NULL, "epoll_ctl: EPOLL_CTL_DEL", Errno, StrError(Errno));
00145         }
00146 }
00147 
00148 
00149 int SocketHandlerEp::ISocketHandler_Select(struct timeval *tsel)
00150 {
00151         int n;
00152         if (m_b_use_mutex)
00153         {
00154                 m_mutex.Unlock();
00155                 n = epoll_wait(m_epoll, m_events, MAX_EVENTS_EP_WAIT, tsel ? tsel -> tv_sec * 1000 + tsel -> tv_usec / 1000 : -1);
00156                 m_mutex.Lock();
00157         }
00158         else
00159         {
00160                 n = epoll_wait(m_epoll, m_events, MAX_EVENTS_EP_WAIT, tsel ? tsel -> tv_sec * 1000 + tsel -> tv_usec / 1000 : -1);
00161         }
00162         if (n == -1)
00163         {
00164                 LogError(NULL, "epoll_wait", Errno, StrError(Errno));
00165         }
00166         else
00167         if (!n)
00168         {
00169         }
00170         else
00171         if (n > 0)
00172         {
00173                 for (int x = 0; x < n; x++)
00174                 {
00175                         Socket *p = static_cast<Socket *>(m_events[x].data.ptr);
00176                         if ((m_events[x].events & EPOLLIN) || (m_events[x].events & EPOLLHUP))
00177                         {
00178 #ifdef HAVE_OPENSSL
00179                                 if (p -> IsSSLNegotiate())
00180                                 {
00181                                         p -> SSLNegotiate();
00182                                 }
00183                                 else
00184 #endif
00185                                 {
00186                                         p -> OnRead();
00187                                 }
00188                         }
00189                         if (m_events[x].events & EPOLLOUT)
00190                         {
00191 #ifdef HAVE_OPENSSL
00192                                 if (p -> IsSSLNegotiate())
00193                                 {
00194                                         p -> SSLNegotiate();
00195                                 }
00196                                 else
00197 #endif
00198                                 {
00199                                         p -> OnWrite();
00200                                 }
00201                         }
00202                         if (m_events[x].events & EPOLLERR)
00203                         {
00204                                 p -> OnException();
00205                         }
00206                 }
00207         }
00208         return n;
00209 }
00210 #endif
00211 
00212 
00213 #ifdef SOCKETS_NAMESPACE
00214 }
00215 #endif
00216
SocketHandlerEp.cpp
