Data.cpp

   1 #include <unistd.h>
   2 #include <sys/types.h>
   3 #include <sys/socket.h>
   4 #include <netinet/in.h>
   5 #include <arpa/inet.h>
   6 #include <string.h>
   7 #include <errno.h>
   8 #include <sys/select.h>
   9 #include "Data.hpp"
  10 #include "Session.hpp"
  11 #include "Exceptions.hpp"
  12 #include "DataBufferFile.hpp"
  13 #include "DataBufferListing.hpp"
  14
  15 Data::Data( const SessionWPtr& session, FILE* file, Mode mode )
  16         : m_sock( 0 )
  17         , m_mode( mode )
  18         , m_session( session )
  19         , m_buf( new char[BufSize] )
  20         , m_data( new DataBufferFile( file ) )
  21 {
  22 }
  23
  24 Data::Data( const SessionWPtr& session, const std::list<std::string>& list )
  25         : m_sock( 0 )
  26         , m_mode( M_UPLOAD )
  27         , m_session( session )
  28         , m_buf( new char[BufSize] )
  29         , m_data( new DataBufferListing( list ) )
  30 {
  31 }
  32
  33 Data::~Data()
  34 {
  35         delete[] m_buf;
  36
  37         if( m_sock != 0 )
  38         {
  39                 close( m_sock );
  40         }
  41 }
  42
  43 bool Data::Connect( const std::string& addr, int port )
  44 {
  45         if( ( m_sock = socket( PF_INET, SOCK_STREAM, 0 ) ) == -1 )
  46         {
  47                 throw SessionErrorException;
  48         }
  49
  50         sockaddr_in sa;
  51
  52         sa.sin_family = AF_INET;
  53         sa.sin_port = htons( port );
  54         sa.sin_addr.s_addr = inet_addr( addr.c_str() );
  55         memset( sa.sin_zero, 0, sizeof( sa.sin_zero ) );
  56
  57         return connect( m_sock, (sockaddr*)&sa, sizeof( sockaddr ) ) != -1;
  58 }
  59
  60 bool Data::Accept( int sock )
  61 {
  62         sockaddr_in addr;
  63         socklen_t size = sizeof( addr );
  64
  65         int incoming = accept( sock, (sockaddr*)&addr, &size );
  66
  67         if( incoming == -1 )
  68         {
  69                 return false;
  70         }
  71
  72         m_sock = incoming;
  73
  74         return true;
  75 }
  76
  77 void Data::Tick()
  78 {
  79         if( m_mode == M_UPLOAD )
  80         {
  81                 Send();
  82         }
  83         else
  84         {
  85                 Receive();
  86         }
  87 }
  88
  89 void Data::Send()
  90 {
  91         int len = m_data->Read( m_buf, BufSize );
  92
  93         if( len == 0 )
  94         {
  95                 SessionPtr sptr = m_session.lock();
  96                 if( !sptr )
  97                 {
  98                         throw "Data lost its Session";
  99                 }
 100                 sptr->DataConnectionFinished();
 101         }
 102         else
 103         {
 104                 int pos = 0;
 105                 char *ptr = m_buf;
 106
 107                 while( pos != len )
 108                 {
 109                         int size = send( m_sock, ptr, len - pos, 0 );
 110
 111                         if( size == -1 )
 112                         {
 113                                 throw SessionErrorException;
 114                         }
 115                         else if( size == 0 )
 116                         {
 117                                 SessionPtr sptr = m_session.lock();
 118                                 if( !sptr )
 119                                 {
 120                                         throw "Data lost its Session";
 121                                 }
 122                                 sptr->DataConnectionError();
 123
 124                                 return;
 125                         }
 126
 127                         pos += size;
 128                         ptr += size;
 129                 }
 130         }
 131 }
 132
 133 void Data::Receive()
 134 {
 135         int size = recv( m_sock, m_buf, BufSize, 0 );
 136
 137         if( size == -1 )
 138         {
 139                 throw SessionErrorException;
 140         }
 141         else if( size == 0 )
 142         {
 143                 SessionPtr sptr = m_session.lock();
 144                 if( !sptr )
 145                 {
 146                         throw "Data lost its Session";
 147                 }
 148                 sptr->DataConnectionFinished();
 149         }
 150         else
 151         {
 152                 int writeSize = m_data->Write( m_buf, size );
 153
 154                 if( writeSize != size )
 155                 {
 156                         SessionPtr sptr = m_session.lock();
 157                         if( !sptr )
 158                         {
 159                                 throw "Data lost its Session";
 160                         }
 161                         sptr->OutOfSpace();
 162                 }
 163         }
 164 }
 165
 166 bool Data::CanSend()
 167 {
 168         fd_set fd;
 169         FD_ZERO( &fd );
 170         FD_SET( m_sock, &fd );
 171         timeval tv;
 172         tv.tv_sec = 0;
 173         tv.tv_usec = 0;
 174         select( m_sock + 1, NULL, &fd, NULL, &tv );
 175
 176         return FD_ISSET( m_sock, &fd );
 177 }
 178
 179 bool Data::CanReceive()
 180 {
 181         fd_set fd;
 182         FD_ZERO( &fd );
 183         FD_SET( m_sock, &fd );
 184         timeval tv;
 185         tv.tv_sec = 0;
 186         tv.tv_usec = 0;
 187         select( m_sock + 1, &fd, NULL, NULL, &tv );
 188
 189         return FD_ISSET( m_sock, &fd );
 190 }