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