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 #ifdef _WIN32
  74                 closesocket( m_sock );
  75 #else
  76                 close( m_sock );
  77 #endif
  78         }
  79 }
  80
  81 bool Data::Connect( const std::string& addr, int port )
  82 {
  83         if( ( m_sock = socket( PF_INET, SOCK_STREAM, 0 ) ) == -1 )
  84         {
  85                 throw SessionErrorException;
  86         }
  87
  88         sockaddr_in sa;
  89
  90         sa.sin_family = AF_INET;
  91         sa.sin_port = htons( port );
  92         sa.sin_addr.s_addr = inet_addr( addr.c_str() );
  93         memset( sa.sin_zero, 0, sizeof( sa.sin_zero ) );
  94
  95         return connect( m_sock, (sockaddr*)&sa, sizeof( sockaddr ) ) != -1;
  96 }
  97
  98 bool Data::Accept( int sock )
  99 {
 100         sockaddr_in addr;
 101         socklen_t size = sizeof( addr );
 102
 103         int incoming = accept( sock, (sockaddr*)&addr, &size );
 104
 105         if( incoming == -1 )
 106         {
 107                 return false;
 108         }
 109
 110         m_sock = incoming;
 111
 112         return true;
 113 }
 114
 115 void Data::Tick()
 116 {
 117         if( m_mode == M_UPLOAD )
 118         {
 119                 Send();
 120         }
 121         else
 122         {
 123                 Receive();
 124         }
 125 }
 126
 127 void Data::Send()
 128 {
 129         int len = m_data->Read( m_buf, BufSize );
 130
 131         if( len == 0 )
 132         {
 133                 m_session.lock()->DataConnectionFinished();
 134         }
 135         else
 136         {
 137                 int pos = 0;
 138                 char *ptr = m_buf;
 139
 140                 while( pos != len && CanSend() )
 141                 {
 142                         int size = send( m_sock, ptr, len - pos, 0 );
 143
 144                         if( size == -1 )
 145                         {
 146                                 throw SessionErrorException;
 147                         }
 148                         else if( size == 0 )
 149                         {
 150                                 m_session.lock()->DataConnectionError();
 151                                 return;
 152                         }
 153
 154                         pos += size;
 155                         ptr += size;
 156                 }
 157
 158                 if( pos != len )
 159                 {
 160                         m_data->Store( ptr, len - pos );
 161                 }
 162         }
 163 }
 164
 165 void Data::Receive()
 166 {
 167         int total = 0;
 168
 169         while( total < BufSize && CanReceive() )
 170         {
 171                 int size = recv( m_sock, m_buf, BufSize - total, 0 );
 172                 if( size == -1 )
 173                 {
 174                         throw SessionErrorException;
 175                 }
 176                 else if( size == 0 )
 177                 {
 178                         m_session.lock()->DataConnectionFinished();
 179                         return;
 180                 }
 181                 else
 182                 {
 183                         int writeSize = m_data->Write( m_buf, size );
 184
 185                         if( writeSize != size )
 186                         {
 187                                 m_session.lock()->OutOfSpace();
 188                                 return;
 189                         }
 190                 }
 191
 192                 total += size;
 193         }
 194 }
 195
 196 bool Data::CanSend()
 197 {
 198         fd_set fd;
 199         FD_ZERO( &fd );
 200         FD_SET( m_sock, &fd );
 201         timeval tv;
 202         tv.tv_sec = 0;
 203         tv.tv_usec = 0;
 204         select( m_sock + 1, NULL, &fd, NULL, &tv );
 205
 206         return FD_ISSET( m_sock, &fd );
 207 }
 208
 209 bool Data::CanReceive()
 210 {
 211         fd_set fd;
 212         FD_ZERO( &fd );
 213         FD_SET( m_sock, &fd );
 214         timeval tv;
 215         tv.tv_sec = 0;
 216         tv.tv_usec = 0;
 217         select( m_sock + 1, &fd, NULL, NULL, &tv );
 218
 219         return FD_ISSET( m_sock, &fd );
 220 }