//
|
// ClientSocket.h
|
// GoldRich
|
//
|
// Created by WindShan on 2017/3/8.
|
// Copyright © 2017年 WindShan. All rights reserved.
|
//
|
|
#ifndef ClientSocket_h
|
#define ClientSocket_h
|
|
#include <sys/socket.h>
|
#include <fcntl.h>
|
#include <errno.h>
|
#include <netinet/in.h>
|
#include <arpa/inet.h>
|
|
#define SOCKET unsigned int
|
#define SOCKET_ERROR -1
|
#define INVALID_SOCKET -1
|
|
#include "pthread.h"
|
#include "IClientSocket.h"
|
|
|
#define call_func_no_param(f) if(f != nullptr){f();}
|
#define call_func_one_param(f,p) if(f != nullptr){f(p);}
|
|
#include "NetStream.h"
|
|
#ifndef INADDR_NONE
|
#define INADDR_NONE 0xffffffff
|
#endif // !INADDR_NONE
|
|
enum connect_status
|
{
|
con_status_ing = 1,
|
con_status_suc = 0,
|
con_status_err = -1,
|
con_status_timeout = -2,
|
|
con_status_called_err = -100,
|
con_status_called_timeout = -101,
|
};
|
|
|
static int init_sock_reference = 0;
|
typedef struct __package
|
{
|
int size;
|
char* buf;
|
}send_package,rec_package;
|
|
|
class CClientSocket
|
{
|
public:
|
CClientSocket(void)
|
:success_call(nullptr),
|
timeout_call(nullptr),
|
error_call(nullptr),
|
receive_call(nullptr),
|
socket_handle(INVALID_SOCKET),
|
out_time(20),
|
ser_addr(0),
|
ser_port(0)
|
{
|
con_status = con_status_err;
|
|
def_recbuf_size = 64*1024;
|
def_sendbuf_size = 64*1024;
|
|
def_buf = new char[def_recbuf_size];
|
memset(def_buf,0,def_recbuf_size);
|
|
pRecStream = new CNetStream;
|
}
|
|
~CClientSocket(void)
|
{
|
success_call = nullptr;
|
error_call = nullptr;
|
timeout_call = nullptr;
|
receive_call = nullptr;
|
|
if (socket_handle != INVALID_SOCKET)
|
{
|
Close();
|
socket_handle = INVALID_SOCKET;
|
}
|
|
if (pRecStream)
|
{
|
pRecStream->detach();
|
delete pRecStream;
|
}
|
|
if (def_buf)
|
{
|
delete []def_buf;
|
def_buf = nullptr;
|
}
|
|
for (list<send_package>::iterator i = lst_send.begin();i != lst_send.end();i++)
|
{
|
ClosePkg(*i);
|
}
|
lst_send.clear();
|
}
|
public:
|
static int InitSockEnv()
|
{
|
init_sock_reference++;
|
|
return 1;
|
}
|
|
static void UninitSockEnv()
|
{
|
init_sock_reference--;
|
}
|
public:
|
int Connect(const char* ip,short port,int outTime,on_connect_success sc,on_connect_time_out tm,on_connect_error er,on_receive_package re)
|
{
|
|
Clear();
|
|
success_call = sc;
|
timeout_call = tm;
|
error_call = er;
|
receive_call = re;
|
|
ser_addr = inet_addr(ip);
|
ser_port = port;
|
out_time = outTime;
|
if (ip == 0 || strlen(ip) > 15 || ser_addr == INADDR_NONE)
|
{
|
con_status = con_status_err;
|
call_func_no_param(error_call);
|
con_status = con_status_called_err;
|
return -1;
|
}
|
|
|
socket_handle = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
|
if (socket_handle == INVALID_SOCKET)
|
{
|
Close();
|
con_status = con_status_err;
|
call_func_no_param(error_call);
|
con_status = con_status_called_err;
|
|
return -1;
|
}
|
|
|
int nRes = 0;
|
#ifdef WIN32
|
unsigned long mod = 1;
|
nRes = ioctlsocket(socket_handle,FIONBIO,&mod);
|
#else
|
// 设置为非阻塞方式
|
nRes = fcntl(socket_handle,F_SETFL,O_NONBLOCK);
|
#endif
|
|
if (nRes < 0 )
|
{
|
Close();
|
con_status = con_status_err;
|
call_func_no_param(error_call);
|
con_status = con_status_called_err;
|
|
return -1;
|
}
|
|
con_status = con_status_ing;
|
pthread_create(&t_id,nullptr,connect_thread_func,this);
|
|
|
return 1;
|
}
|
int SendStream(CNetStream* pStream)
|
{
|
if (pStream == nullptr){
|
return -1;
|
}
|
|
return CreateNewPkg(pStream->getLenth(),pStream->getData());
|
}
|
int Close()
|
{
|
return close(m_sockClient);
|
}
|
|
|
//you should call this function in circle
|
void process()
|
{
|
DoReceive();
|
|
CheckErr();
|
|
switch (con_status)
|
{
|
case con_status_suc:
|
{
|
Flush();
|
break;
|
}
|
case con_status_err:
|
{
|
call_func_no_param(error_call);
|
con_status = con_status_called_err;
|
break;
|
}
|
case con_status_called_err:
|
break;
|
case con_status_ing:
|
break;
|
case con_status_timeout:
|
break;
|
case con_status_called_timeout:
|
break;
|
|
default:
|
break;
|
}
|
|
}
|
|
private:
|
int GetError()
|
{
|
int err = 0;
|
#ifdef WIN32
|
err = WSAGetLastError();
|
if(err != WSAEWOULDBLOCK) {
|
#else
|
err = errno;
|
if(err != EINPROGRESS && err != EAGAIN)
|
{
|
#endif
|
return 1;
|
}
|
|
return 0;
|
}
|
|
int DoConnectProcess()
|
{
|
sockaddr_in addr_in;
|
memset((void*)&addr_in,0,sizeof(addr_in));
|
|
addr_in.sin_family = AF_INET;
|
addr_in.sin_port = htons(ser_port);
|
addr_in.sin_addr.s_addr = ser_addr;
|
|
if (connect(socket_handle,(sockaddr*)&addr_in,sizeof(addr_in)) == SOCKET_ERROR)
|
{
|
if (GetError() == 1)
|
{
|
Close();
|
con_status = con_status_err;
|
/*call_func_no_param(error_call);
|
con_status = con_status_called_err;*/
|
|
return -1;
|
}
|
|
timeval timeout;
|
timeout.tv_sec = out_time;
|
timeout.tv_usec = 0;
|
fd_set writeset,exceptset;
|
FD_ZERO(&writeset);
|
FD_ZERO(&exceptset);
|
FD_SET(socket_handle,&writeset);
|
FD_SET(socket_handle,&exceptset);
|
|
int ret = select(FD_SETSIZE,nullptr,&writeset,&exceptset,&timeout);
|
if (ret < 0)
|
{
|
Close();
|
con_status = con_status_err;
|
/*call_func_no_param(error_call);
|
con_status = con_status_called_err;*/
|
|
return -1;
|
}
|
else if (ret == 0)
|
{
|
Close();
|
con_status = con_status_timeout;
|
call_func_no_param(timeout_call);
|
con_status = con_status_called_timeout;
|
}
|
|
ret = FD_ISSET(socket_handle,&exceptset);
|
if(ret){
|
Close();
|
con_status = con_status_err;
|
/*call_func_no_param(error_call);
|
con_status = con_status_called_err;*/
|
|
return -1;
|
}
|
}
|
|
struct linger so_linger;
|
so_linger.l_onoff = 1;
|
so_linger.l_linger = 5;
|
|
setsockopt(socket_handle,SOL_SOCKET,SO_LINGER,(const char*)&so_linger,sizeof(so_linger));
|
setsockopt(socket_handle,SOL_SOCKET,SO_RCVBUF,(const char*)&def_recbuf_size,sizeof(int));
|
setsockopt(socket_handle,SOL_SOCKET,SO_SNDBUF,(const char*)&def_sendbuf_size,sizeof(int));
|
|
con_status = con_status_suc;
|
call_func_no_param(success_call);
|
|
|
return 1;
|
}
|
static void* connect_thread_func(void* arg)
|
{
|
CClientSocket* pObj = (CClientSocket*)arg;
|
if (pObj != nullptr)
|
{
|
pObj->DoConnectProcess();
|
}
|
|
return 0;
|
}
|
|
int CheckErr()
|
{
|
if (con_status == con_status_ing){
|
return -1;
|
}
|
|
if (con_status == con_status_called_err || con_status == con_status_called_timeout){
|
con_status = con_status_called_err;
|
return -1;
|
}
|
|
if (socket_handle == INVALID_SOCKET || con_status == con_status_err){
|
con_status = con_status_err;
|
return -1;
|
}
|
|
char buf[1];
|
int nRet = recv(socket_handle,buf,1,MSG_PEEK);
|
if(nRet == 0)
|
{
|
Close();
|
con_status = con_status_err;
|
|
return -1;
|
}
|
else if(nRet < 0)
|
{
|
if (GetError() == 1)
|
{
|
Close();
|
con_status = con_status_err;
|
|
return -1;
|
}
|
}
|
|
con_status = con_status_suc;
|
|
return 1;
|
}
|
|
int CreateNewPkg(int size,const char* buf)
|
{
|
if (size > 0 && buf != nullptr)
|
{
|
send_package pkg;
|
pkg.size = size;
|
pkg.buf = new char[size];
|
memcpy(pkg.buf,buf,pkg.size);
|
lst_send.push_back(pkg);
|
|
return 1;
|
}
|
|
return -1;
|
}
|
|
int ClosePkg(send_package& pkg)
|
{
|
if (pkg.buf)
|
{
|
delete []pkg.buf;
|
pkg.buf = nullptr;
|
pkg.size = 0;
|
return 1;
|
}
|
|
return -1;
|
}
|
|
int Flush()
|
{
|
if (lst_send.size() > 0) // have send data
|
{
|
list<send_package>::iterator iPkg = lst_send.begin();
|
int sd_size = send(socket_handle,iPkg->buf,iPkg->size,0);
|
if (sd_size >= iPkg->size)
|
{
|
ClosePkg(*iPkg);
|
lst_send.pop_front();
|
return 1;
|
}
|
else
|
{
|
printf("send err ,data is to larage!>>>>>>");
|
return -1;
|
}
|
}
|
|
return 1;
|
}
|
|
int DoReceive()
|
{
|
|
if(con_status != con_status_suc) { return -1; }
|
|
int rec_size = recv(socket_handle,def_buf,def_recbuf_size,0);
|
|
if (rec_size > 0 )
|
{
|
pRecStream->attach(def_buf,def_recbuf_size,rec_size);
|
call_func_one_param(receive_call,pRecStream);
|
pRecStream->detach();
|
|
return 1;
|
}
|
else if (rec_size == 0)
|
{
|
Close();
|
con_status = con_status_err;
|
|
return -1;
|
}
|
else
|
{
|
if (GetError() == 1)
|
{
|
Close();
|
return -1;
|
}
|
}
|
|
return 1;
|
}
|
|
void Clear()
|
{
|
if (socket_handle != INVALID_SOCKET){
|
Close();
|
socket_handle = INVALID_SOCKET;
|
}
|
|
success_call = nullptr;
|
error_call = nullptr;
|
timeout_call = nullptr;
|
receive_call = nullptr;
|
|
ser_addr = 0;
|
ser_port = 0;
|
out_time = 20;
|
|
if (def_buf != nullptr){
|
memset(def_buf,0,def_recbuf_size);
|
}
|
|
con_status = con_status_err;
|
|
for (list<send_package>::iterator i = lst_send.begin();i != lst_send.end();i++)
|
{
|
ClosePkg(*i);
|
}
|
lst_send.clear();
|
}
|
|
|
private://member data
|
on_connect_success success_call;
|
on_connect_time_out timeout_call;
|
on_connect_error error_call;
|
on_receive_package receive_call;
|
|
SOCKET socket_handle;
|
|
unsigned long ser_addr;
|
short ser_port;
|
unsigned long out_time;
|
|
int con_status;
|
|
int def_recbuf_size;
|
int def_sendbuf_size;
|
|
char* def_buf;
|
CNetStream* pRecStream;
|
|
list<send_package> lst_send;
|
list<rec_package> lst_rec;
|
|
|
|
|
pthread_t t_id;
|
pthread_t rec_tid;
|
};
|
|
#endif /* ClientSocket_h */
|
