Skip to content

Commit cf9c711

Browse files
godmode2kgodmode2k
committed
added: send/recv types, winsock2 support
1 parent 1be3f70 commit cf9c711

File tree

2 files changed

+405
-1
lines changed

2 files changed

+405
-1
lines changed

‎libs/util/CNetSockLib.cpp

Lines changed: 333 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,10 @@ Last modified: September 24, 2014
5757
#include "CNetSockLib.h"
5858

5959
//#include "util/CUtil_DEF.h"
60+
61+
#ifdef _WINDOWS
62+
#pragma comment(lib, "ws2_32.lib")
63+
#endif
6064
// ---------------------------------------------------------------
6165

6266

@@ -170,6 +174,261 @@ void CNetSockLib::__release(void) {
170174

171175

172176

177+
//! Handle I/O
178+
// ---------------------------------------------------------------
179+
CHandleIO::CHandleIO(void) : TAG("CHandleIO") {
180+
__LOGT__( TAG, "CHandleIO()" );
181+
}
182+
183+
CHandleIO::~CHandleIO(void) {
184+
__LOGT__( TAG, "~CHandleIO()" );
185+
}
186+
187+
#ifdef _WINDOWS
188+
int CHandleIO::write_int(const SOCKET socket, const int val) {
189+
#else
190+
int CHandleIO::write_int(const int socket, const int val) {
191+
#endif
192+
uint32_t _val = htonl( val );
193+
int bytes = send(socket, (char*)&_val, sizeof(_val), 0);
194+
195+
if (bytes <= 0) {
196+
//__LOGT__( TAG, "write_int(): %d\n", bytes );
197+
return -1;
198+
}
199+
200+
return bytes;
201+
}
202+
203+
#ifdef _WINDOWS
204+
int CHandleIO::write_float(const SOCKET socket, const float val) {
205+
uint32_t _val = htonf( val );
206+
#else
207+
int CHandleIO::write_float(const int socket, const float val) {
208+
uint32_t _val = g_UTIL::htonf( val );
209+
#endif
210+
int bytes = send(socket, (char*)&_val, sizeof(_val), 0);
211+
212+
if (bytes <= 0) {
213+
//__LOGT__( TAG, "write_float(): %d\n", bytes );
214+
return -1;
215+
}
216+
217+
return bytes;
218+
}
219+
220+
#ifdef _WINDOWS
221+
int CHandleIO::write_bool(const SOCKET socket, const unsigned char val) {
222+
#else
223+
int CHandleIO::write_bool(const int socket, const unsigned char val) {
224+
#endif
225+
unsigned char _val = val;
226+
int bytes = send(socket, (char*)&_val, sizeof(_val), 0);
227+
228+
if (bytes <= 0) {
229+
//__LOGT__( TAG, "write_bool(): %d\n", bytes );
230+
return -1;
231+
}
232+
233+
return bytes;
234+
}
235+
236+
#ifdef _WINDOWS
237+
int CHandleIO::write(const SOCKET socket, const unsigned char* buffer, const int len){
238+
#else
239+
int CHandleIO::write(const int socket, const unsigned char* buffer, const int len){
240+
#endif
241+
int bytes = send(socket, (char*)buffer, len, 0);
242+
if (bytes <= 0) {
243+
//__LOGT__( TAG, "write(): %d\n", bytes );
244+
return -1;
245+
}
246+
247+
return bytes;
248+
}
249+
250+
#ifdef _WINDOWS
251+
int CHandleIO::read_int(const SOCKET socket, int* val) {
252+
#else
253+
int CHandleIO::read_int(const int socket, int* val) {
254+
#endif
255+
uint32_t _val;
256+
#ifdef _WINDOWS
257+
int ret = recv(socket, (char*)&_val, sizeof(_val), MSG_WAITALL);
258+
#else
259+
int ret = recv(socket, (char*)&_val, sizeof(_val), 0 );
260+
#endif
261+
262+
*val = (int)ntohl((uint32_t)_val);
263+
return ret;
264+
}
265+
266+
#ifdef _WINDOWS
267+
int CHandleIO::read_float(const SOCKET socket, float* val) {
268+
#else
269+
int CHandleIO::read_float(const int socket, float* val) {
270+
#endif
271+
uint32_t _val;
272+
#ifdef _WINDOWS
273+
int ret = recv(socket, (char*)&_val, sizeof(_val), MSG_WAITALL);
274+
*val = (float)ntohf((uint32_t)_val);
275+
#else
276+
int ret = recv(socket, (char*)&_val, sizeof(_val), 0 );
277+
*val = (float)g_UTIL::ntohf((uint32_t)_val);
278+
#endif
279+
280+
return ret;
281+
}
282+
283+
#ifdef _WINDOWS
284+
int CHandleIO::read_bool(const SOCKET socket, unsigned char* val) {
285+
#else
286+
int CHandleIO::read_bool(const int socket, unsigned char* val) {
287+
#endif
288+
unsigned char _val;
289+
#ifdef _WINDOWS
290+
int ret = recv(socket, (char*)&_val, sizeof(_val), MSG_WAITALL);
291+
#else
292+
int ret = recv(socket, (char*)&_val, sizeof(_val), 0 );
293+
#endif
294+
295+
*val = (unsigned char)_val;
296+
297+
return ret;
298+
}
299+
300+
#ifdef _WINDOWS
301+
int CHandleIO::read(const SOCKET socket, unsigned char* buffer, const int len) {
302+
#else
303+
int CHandleIO::read(const int socket, unsigned char* buffer, const int len) {
304+
#endif
305+
return read(socket, buffer, len, 0);
306+
}
307+
308+
#ifdef _WINDOWS
309+
int CHandleIO::read(const SOCKET socket, unsigned char* buffer, const int len, const int read_len) {
310+
#else
311+
int CHandleIO::read(const int socket, unsigned char* buffer, const int len, const int read_len) {
312+
#endif
313+
char recv_buffer[1024] = { 0, };
314+
int recv_bytes = 0;
315+
int recv_bytes_total = 0;
316+
317+
//memset(recv_buffer, 0x00, sizeof(recv_buffer));
318+
memset(buffer, 0x00, len);
319+
320+
if (read_len > 0) {
321+
while (read_len > recv_bytes_total) {
322+
memset(recv_buffer, 0x00, sizeof(recv_buffer));
323+
324+
//recv_bytes = recv(socket, (char*)buffer + recv_bytes_total, read_len, 0);
325+
326+
recv_bytes = recv(socket, (char*)buffer + recv_bytes_total, read_len - recv_bytes_total, 0);
327+
//recv_bytes = recv(socket, recv_buffer, sizeof(recv_buffer), 0);
328+
329+
if (recv_bytes <= 0) break;
330+
//memcpy(buffer + recv_bytes_total, recv_buffer, recv_bytes);
331+
332+
recv_bytes_total += recv_bytes;
333+
}
334+
}
335+
else {
336+
while (1) {
337+
memset(recv_buffer, 0x00, sizeof(recv_buffer));
338+
339+
//recv_bytes = recv(socket, (char*)buffer + recv_bytes_total, len, 0);
340+
recv_bytes = recv(socket, recv_buffer, sizeof(recv_buffer), 0);
341+
342+
if (recv_bytes <= 0) break;
343+
memcpy(buffer + recv_bytes_total, recv_buffer, recv_bytes);
344+
345+
recv_bytes_total += recv_bytes;
346+
}
347+
}
348+
349+
//buffer[recv_bytes_total] = '\0';
350+
351+
//__LOGT__( TAG, "read(): total bytes = %d\n", recv_bytes_total );
352+
//__LOGT__( TAG, "read(): data = %s\n", buffer );
353+
354+
return recv_bytes_total;
355+
}
356+
357+
358+
//! Handle I/O: Client, Server
359+
// ---------------------------------------------------------------
360+
int CAsyncTaskServer::write_int(const int val) {
361+
return write_int(m_sockfd, val);
362+
}
363+
364+
int CAsyncTaskServer::write_float(const float val) {
365+
return write_float(m_sockfd, val);
366+
}
367+
368+
int CAsyncTaskServer::write_bool(const unsigned char val) {
369+
return write_bool(m_sockfd, val);
370+
}
371+
372+
int CAsyncTaskServer::write(const unsigned char* buffer, const int len) {
373+
return write(m_sockfd, buffer, len);
374+
}
375+
376+
int CAsyncTaskServer::read_int(int* val) {
377+
return read_int(m_sockfd, val);
378+
}
379+
380+
int CAsyncTaskServer::read_float(float* val) {
381+
return read_float(m_sockfd, val);
382+
}
383+
384+
int CAsyncTaskServer::read_bool(unsigned char* val) {
385+
return read_bool(m_sockfd, val);
386+
}
387+
388+
int CAsyncTaskServer::read(unsigned char* buffer, const int len) {
389+
return read(m_sockfd, buffer, len, 0);
390+
}
391+
int CAsyncTaskServer::read(unsigned char* buffer, const int len, const int read_len) {
392+
return read(m_sockfd, buffer, len, read_len);
393+
}
394+
395+
int CAsyncTaskClient::write_int(const int val) {
396+
return write_int(m_sockfd, val);
397+
}
398+
399+
int CAsyncTaskClient::write_float(const float val) {
400+
return write_float(m_sockfd, val);
401+
}
402+
403+
int CAsyncTaskClient::write_bool(const unsigned char val) {
404+
return write_bool(m_sockfd, val);
405+
}
406+
407+
int CAsyncTaskClient::write(const unsigned char* buffer, const int len) {
408+
return write(m_sockfd, buffer, len);
409+
}
410+
411+
int CAsyncTaskClient::read_int(int* val) {
412+
return read_int(m_sockfd, val);
413+
}
414+
415+
int CAsyncTaskClient::read_float(float* val) {
416+
return read_float(m_sockfd, val);
417+
}
418+
419+
int CAsyncTaskClient::read_bool(unsigned char* val) {
420+
return read_bool(m_sockfd, val);
421+
}
422+
423+
int CAsyncTaskClient::read(unsigned char* buffer, const int len) {
424+
return read(m_sockfd, buffer, len, 0);
425+
}
426+
int CAsyncTaskClient::read(unsigned char* buffer, const int len, const int read_len) {
427+
return read(m_sockfd, buffer, len, read_len);
428+
}
429+
430+
431+
173432
//! Server
174433
// ---------------------------------------------------------------
175434
CAsyncTaskServer::CAsyncTaskServer(void) : CThreadTask("SERVER"), TAG("CAsyncTaskServer") {
@@ -193,6 +452,35 @@ CAsyncTaskServer::CAsyncTaskServer(void) : CThreadTask("SERVER"), TAG("CAsyncTas
193452
CAsyncTaskServer::~CAsyncTaskServer(void) {
194453
__LOGT__( TAG, "~CAsyncTaskServer()" );
195454

455+
#ifdef __ANDROID_NDK__
456+
//! NOTE: Don't use named "__release", which is reserved in NDK
457+
___release();
458+
#else
459+
__release();
460+
#endif
461+
}
462+
463+
int CAsyncTaskServer::__init(void) {
464+
__LOGT__( TAG, "__init()" );
465+
#ifdef _WINDOWS
466+
WSADATA wsaData;
467+
int ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
468+
if (ret != NO_ERROR) {
469+
__LOGT__( TAG, "__init(): Error: WSAStartup(): %d\n", ret );
470+
return -1;
471+
}
472+
#else
473+
#endif
474+
}
475+
476+
#ifdef __ANDROID_NDK__
477+
//! NOTE: Don't use named "__release", which is reserved in NDK
478+
void CAsyncTaskServer::___release(void) {
479+
#else
480+
void CAsyncTaskServer::__release(void) {
481+
#endif
482+
__LOGT__( TAG, "__release()" );
483+
196484
server_close();
197485
}
198486

@@ -331,7 +619,11 @@ bool CAsyncTaskServer::server_open_tcp(void) {
331619

332620
m_sockfd = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP );
333621
if ( m_sockfd < 0 ) {
622+
#ifdef _WINDOWS
623+
__LOGT__( TAG, "server_open_tcp(): socket(): %ld [FAIL]", WSAGetLastError() );
624+
#else
334625
__LOGT__( TAG, "server_open_tcp(): socket() [FAIL]" );
626+
#endif
335627
server_close();
336628
return false;
337629
}
@@ -359,6 +651,19 @@ bool CAsyncTaskServer::server_open_tcp(void) {
359651
}
360652

361653

654+
#ifdef _WINDOWS
655+
// blocking mode
656+
{
657+
u_long blocking_mode = 0;
658+
ret = ioctlsocket( m_sockfd, FIONBIO, &blocking_mode );
659+
if ( ret < 0 ) {
660+
__LOGT__( TAG, "server_open_tcp(): ioctlsocket(): %ld\n", ret);
661+
return false;
662+
}
663+
}
664+
#endif
665+
666+
362667
// Prevent bind error
363668
ret = setsockopt( m_sockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse) );
364669
if ( ret < 0 ) {
@@ -669,6 +974,7 @@ void CAsyncTaskServer::server_close(void) {
669974
#ifdef _WINDOWS
670975
:shutdown( m_sockfd, SD_BOTH );
671976
::closesocket( m_sockfd );
977+
WSACleanup();
672978
#else
673979
shutdown( m_sockfd, SHUT_RDWR );
674980
close( m_sockfd );
@@ -1539,6 +1845,33 @@ namespace g_UTIL {
15391845
}
15401846
*/
15411847
} // namespace NET
1848+
1849+
#ifdef _WINDOWS
1850+
#else
1851+
// htonf, ntohf
1852+
// Source: https://beej.us/guide/bgnet/examples/pack.c
1853+
uint32_t htonf(float f) {
1854+
uint32_t p;
1855+
uint32_t sign;
1856+
1857+
if (f < 0) { sign = 1; f = -f; }
1858+
else { sign = 0; }
1859+
1860+
p = ((((uint32_t)f) & 0x7fff) << 16) | (sign << 31); // whole part and sign
1861+
p |= (uint32_t)(((f - (int)f) * 65536.0f)) & 0xffff; // fraction
1862+
1863+
return p;
1864+
}
1865+
1866+
float ntohf(uint32_t p) {
1867+
float f = ((p >> 16) & 0x7fff); // whole part
1868+
f += (p & 0xffff) / 65536.0f; // fraction
1869+
1870+
if (((p >> 31) & 0x1) == 0x1) { f = -f; } // sign bit set
1871+
1872+
return f;
1873+
}
1874+
#endif
15421875
} // namespace g_UTIL
15431876

15441877
#ifdef __cplusplus

0 commit comments

Comments
 (0)