Klient.cpp 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334
  1. #include <openssl/bio.h>
  2. #include <openssl/ssl.h>
  3. #include "Klient.h"
  4. #ifndef WIN32
  5. #include <string.h>
  6. #include <netdb.h>
  7. #endif
  8. #include <Key.h>
  9. #include <Datei.h>
  10. using namespace Network;
  11. // inhalt der Klient Klasse aus Klient.h
  12. // Konstruktor
  13. Klient::Klient()
  14. : ReferenceCounter()
  15. {
  16. memset( &server, 0, sizeof( server ) );
  17. server.sin_family = AF_INET;
  18. downStreamBytes = 0;
  19. upStreamBytes = 0;
  20. sock = 0;
  21. sendeKey = 0;
  22. empfangKey = 0;
  23. }
  24. // Destruktoe
  25. Klient::~Klient()
  26. {
  27. if( sock )
  28. trenne();
  29. if( sendeKey )
  30. sendeKey->release();
  31. if( empfangKey )
  32. empfangKey->release();
  33. }
  34. // nicht constant
  35. void Klient::setSendeKeyZ( Encryption::Key *key ) // Setzt den Key fürs Senden
  36. {
  37. if( sendeKey )
  38. sendeKey->release();
  39. sendeKey = key;
  40. }
  41. void Klient::setEmpfangKeyZ( Encryption::Key *key ) // Setzt den Key fürs Empfangen
  42. {
  43. if( empfangKey )
  44. empfangKey->release();
  45. empfangKey = key;
  46. }
  47. void Klient::setSendeKey( char *key, int len ) // Setzt den Key fürs Senden
  48. {
  49. if( !sendeKey )
  50. sendeKey = new Encryption::Key();
  51. sendeKey->setKey( key, len );
  52. }
  53. void Klient::setEmpfangKey( char *key, int len ) // Setzt den Key fürs Empfangen
  54. {
  55. if( !empfangKey )
  56. empfangKey = new Encryption::Key();
  57. empfangKey->setKey( key, len );
  58. }
  59. bool Klient::verbinde( unsigned short port, const char *ip ) // verbindet mit Server
  60. {
  61. if( sendeKey )
  62. sendeKey->setPos( 0 );
  63. if( empfangKey )
  64. empfangKey->setPos( 0 );
  65. if( sock )
  66. closesocket( sock );
  67. sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
  68. long sIp = inet_addr( ip ); // ip addresse
  69. if( sIp == INADDR_NONE )
  70. {
  71. struct hostent *pHostInfo = gethostbyname( ip );
  72. if( pHostInfo == 0 )
  73. return 0;
  74. sIp = *(long *)pHostInfo->h_addr_list[ 0 ];
  75. }
  76. memcpy( (char *)&server.sin_addr, &sIp, sizeof( sIp ) );
  77. server.sin_port = htons( port ); // port
  78. if( connect( sock, (struct sockaddr *)&server, sizeof( server ) ) < 0 ) // verbinden
  79. return 0; // Fehler
  80. return 1;
  81. }
  82. bool Klient::sende( const char *nachricht, int len ) // sendet zum Server
  83. {
  84. int ll = 0;
  85. while( len > 0 )
  86. {
  87. #ifdef WIN32
  88. int l = send( sock, nachricht + ll, len, 0 );
  89. #else
  90. int l = (int)send( sock, nachricht + ll, len, MSG_NOSIGNAL );
  91. #endif
  92. if( l <= 0 )
  93. return 0; // Fehler
  94. len -= l;
  95. ll += l;
  96. }
  97. upStreamBytes += ll;
  98. return 1;
  99. }
  100. bool Klient::getNachricht( char *nachricht, int len ) // empfängt Nachricht
  101. {
  102. int ll = 0;
  103. while( len > 0 )
  104. {
  105. int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
  106. if( l <= 0 )
  107. return 0; // Fehler
  108. len -= l;
  109. ll += l;
  110. }
  111. downStreamBytes += ll;
  112. return 1;
  113. }
  114. bool Klient::sendeEncrypted( const char *nachricht, int len ) // sendet zum Server
  115. {
  116. if( !sendeKey )
  117. return sende( nachricht, len );
  118. Encryption::Bytes *n = new Encryption::Bytes( nachricht, len );
  119. sendeKey->codieren( dynamic_cast<Framework::Encryption::Bytes *>( n->getThis() ) );
  120. int ll = 0;
  121. while( len > 0 )
  122. {
  123. #ifdef WIN32
  124. int l = send( sock, n->getBytes() + ll, len, 0 );
  125. #else
  126. int l = (int)send( sock, n->getBytes() + ll, len, MSG_NOSIGNAL );
  127. #endif
  128. if( l <= 0 )
  129. {
  130. n->release();
  131. return 0; // Fehler
  132. }
  133. len -= l;
  134. ll += l;
  135. }
  136. upStreamBytes += ll;
  137. n->release();
  138. return 1;
  139. }
  140. bool Klient::getNachrichtEncrypted( char *nachricht, int len ) // empfängt Nachricht
  141. {
  142. if( !empfangKey )
  143. return getNachricht( nachricht, len );
  144. int ll = 0;
  145. while( len > 0 )
  146. {
  147. int l = (int)recv( sock, nachricht + ll, len, MSG_WAITALL );
  148. if( l <= 0 )
  149. return 0; // Fehler
  150. len -= l;
  151. ll += l;
  152. }
  153. Encryption::Bytes *n = new Encryption::Bytes();
  154. n->setBytesZ( nachricht, ll );
  155. empfangKey->decodieren( n );
  156. downStreamBytes += ll;
  157. return 1;
  158. }
  159. int Klient::getDownloadBytes( bool reset ) // gibt die anzahl von empfangen bytes zurück
  160. {
  161. int ret = downStreamBytes;
  162. if( reset )
  163. downStreamBytes = 0;
  164. return ret;
  165. }
  166. int Klient::getUploadBytes( bool reset ) // gibt die anzahl von versendeter bytes zurück
  167. {
  168. int ret = upStreamBytes;
  169. if( reset )
  170. upStreamBytes = 0;
  171. return ret;
  172. }
  173. bool Klient::trenne() // Trennt die Verbindung zum Server
  174. {
  175. if( !sock )
  176. return 1;
  177. if( sendeKey )
  178. sendeKey->setPos( 0 );
  179. if( empfangKey )
  180. empfangKey->setPos( 0 );
  181. if( closesocket( sock ) < 0 ) // verbindung Trennen
  182. return 0; // Fehler
  183. sock = 0;
  184. return 1;
  185. }
  186. // constant
  187. bool Klient::hatNachricht( int zeit ) // Wartet eine Zeit Lang auf eine Nachricht
  188. {
  189. #ifdef WIN32
  190. fd_set set = { 1, { sock } };
  191. timeval time = { zeit / 1000, zeit };
  192. return select( 0, &set, 0, 0, &time ) == 1;
  193. #else
  194. return 1;
  195. #endif
  196. }
  197. unsigned short Klient::getServerPort() const // gibt den Port zurück
  198. {
  199. return htons( server.sin_port );
  200. }
  201. const char *Klient::getServerIp() const // gibt die Ip zurück
  202. {
  203. return inet_ntoa( server.sin_addr );
  204. }
  205. // Inhalt der SSLKlient Klasse aus Klient.h
  206. // Konstruktor
  207. SSLKlient::SSLKlient()
  208. : ReferenceCounter()
  209. {
  210. ctx = SSL_CTX_new( SSLv23_client_method() );
  211. ip = 0;
  212. port = 0;
  213. bio = BIO_new_ssl_connect( ctx );
  214. BIO_get_ssl( bio, &ssl );
  215. downStreamBytes = 0;
  216. upStreamBytes = 0;
  217. connected = 0;
  218. }
  219. // Destruktor
  220. SSLKlient::~SSLKlient()
  221. {
  222. if( this->ip )
  223. this->ip->release();
  224. if( connected )
  225. trenne();
  226. BIO_free_all( bio );
  227. SSL_CTX_free( ctx );
  228. #ifdef WIN32
  229. OPENSSL_thread_stop();
  230. #endif
  231. }
  232. bool SSLKlient::verbinde( unsigned short port, const char *ip ) // verbindet mit Server
  233. {
  234. this->port = port;
  235. if( this->ip )
  236. this->ip->release();
  237. this->ip = new Text( ip );
  238. Text adr = ip;
  239. adr += ":";
  240. adr += port;
  241. BIO_set_conn_hostname( bio, adr );
  242. connected = BIO_do_connect( bio ) > 0;
  243. if( connected && BIO_do_handshake( bio ) <= 0 )
  244. trenne();
  245. return connected;
  246. }
  247. bool SSLKlient::sende( const char *nachricht, int len ) // sendet zum Server
  248. {
  249. int ll = 0;
  250. while( len > 0 )
  251. {
  252. int l = SSL_write( ssl, nachricht + ll, len );
  253. if( l <= 0 )
  254. return 0; // Fehler
  255. len -= l;
  256. ll += l;
  257. }
  258. upStreamBytes += ll;
  259. return 1;
  260. }
  261. bool SSLKlient::getNachricht( char *nachricht, int len ) // empfängt Nachricht
  262. {
  263. if( !connected )
  264. return 0;
  265. int ll = 0;
  266. while( len > 0 )
  267. {
  268. int l = SSL_read( ssl, nachricht + ll, len );
  269. if( l <= 0 )
  270. return 0; // Fehler
  271. len -= l;
  272. ll += l;
  273. }
  274. downStreamBytes += ll;
  275. return 1;
  276. }
  277. int SSLKlient::getDownloadBytes( bool reset ) // gibt die anzahl von empfangen bytes zurück
  278. {
  279. int ret = downStreamBytes;
  280. if( reset )
  281. downStreamBytes = 0;
  282. return ret;
  283. }
  284. int SSLKlient::getUploadBytes( bool reset ) // gibt die anzahl von versendeter bytes zurück
  285. {
  286. int ret = upStreamBytes;
  287. if( reset )
  288. upStreamBytes = 0;
  289. return ret;
  290. }
  291. bool SSLKlient::trenne() // Trennt die Verbindung zum Server
  292. {
  293. BIO_ssl_shutdown( bio );
  294. connected = 0;
  295. return 1;
  296. }
  297. // constant
  298. unsigned short SSLKlient::getServerPort() const // gibt den Port des Servers zurück
  299. {
  300. return port;
  301. }
  302. const char *SSLKlient::getServerIp() const // gibt die Ip des Servers zurück
  303. {
  304. return ip->getText();
  305. }