Data.cpp

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