Rorschach/WebSocket_MQL_by_ufranco
1
0
포크 0
코드 이슈 풀 리퀘스트 Projects 릴리즈 Packages 위키 활동 Actions
WebSocket_MQL_by_ufranco/Include/WebsocketClient.mqh

870 lines
26 KiB
MQL5
Raw 고유링크 Normal View 히스토리

Обновить Include/WebsocketClient.mqh
2025-09-30 15:27:00 +00:00
//+------------------------------------------------------------------+
//| WebSocketClient.mqh |
//| Copyright 2019, MetaQuotes Software Corp. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019, MetaQuotes Software Corp."
#property link "https://www.mql5.com"
#include <Socket.mqh>
#include <Frame.mqh>
//+------------------------------------------------------------------+
//| defines |
//+------------------------------------------------------------------+
#define GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
#define HEADER_EOL "\r\n"
#define HEADER_GET "GET /"
#define HEADER_HOST "Host: "
#define HEADER_UPGRADE "Upgrade: websocket"+HEADER_EOL
#define HEADER_CONNECTION "Connection: Upgrade"+HEADER_EOL
#define HEADER_KEY "Sec-WebSocket-Key: "
#define HEADER_WS_VERSION "Sec-WebSocket-Version: 13"+HEADER_EOL+HEADER_EOL
#define HEADER_HTTP " HTTP/1.1"
enum ENUM_CLOSE_CODE // possible reasons for disconnecting sent with a close frame
{
NORMAL_CLOSE = 1000, // normal closure initiated by choice
GOING_AWAY_CLOSE, // close code for client navigating away from end point, used in browsers
PROTOCOL_ERROR_CLOSE, // close caused by some violation of a protocol, usually application defined
FRAME_TYPE_ERROR_CLOSE, // close caused by an endpoint receiving frame type that is not supportted or allowed
UNDEFINED_CLOSE_1, // close code is not defined by websocket protocol
UNUSED_CLOSE_1, // unused
UNUSED_CLOSE_2, // values
ENCODING_TYPE_ERROR_CLOSE, // close caused data in message is of wrong encoding type, usually referring to strings
APP_POLICY_ERROR_CLOSE, // close caused by violation of user policy
MESSAGE_SIZE_ERROR_CLOSE, // close caused by endpoint receiving message that is too large
EXTENSION_ERROR_CLOSE, // close caused by non compliance to or no support for specified extension of websocket protocol
SERVER_SIDE_ERROR_CLOSE, // close caused by some error that occurred on the server
UNUSED_CLOSE_3 = 1015, // unused
};
enum ENUM_WEBSOCKET_STATE
{
CLOSED = 0,
CLOSING,
CONNECTING,
CONNECTED
};
//+------------------------------------------------------------------+
//| CWebSocketClient class |
//+------------------------------------------------------------------+
class CWebSocketClient
{
private:
ENUM_WEBSOCKET_STATE m_wsclient;
CSocket m_socket;
int m_frames;
int m_maxsendsize;
uint m_total_len;
int m_msgsize;
uint m_timeout;
bool m_sent;
uchar m_txbuf[];
uchar m_rxbuf[];
uchar m_send[];
//---
bool upgrade(void);
void reset(void);
bool fillTxBuffer(ENUM_FRAME_TYPE ftype);
int send(ENUM_FRAME_TYPE frame_type);
int fillRxBuffer(void);
bool parse(CFrame& out[]);
public:
CWebSocketClient();
~CWebSocketClient();
//---
ENUM_WEBSOCKET_STATE ClientState(void);
void SetMaxSendSize(int maxsend) {if(maxsend>=0) m_maxsendsize=maxsend; else m_maxsendsize=0; }
bool Connect(const string url,const uint port,const uint timeout,bool use_tls=false,bool enablelog=false);
bool Close(ENUM_CLOSE_CODE close_code=NORMAL_CLOSE,const string msg="");
int SendString(const string message);
int SendData(uchar& message_buffer[]);
int SendPong(const string msg);
int SendPing(const string msg);
int Readable(void) { return(fillRxBuffer());}
uint Read(CFrame& out[]);
};
//+------------------------------------------------------------------+
//| constructor |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CWebSocketClient::CWebSocketClient():m_wsclient(0),
m_timeout(0),
m_frames(0),
m_total_len(0),
m_msgsize(0),
m_maxsendsize(0),
m_sent(true)
{
}
//+------------------------------------------------------------------+
//| destructor |
//+------------------------------------------------------------------+
CWebSocketClient::~CWebSocketClient()
{
}
//+------------------------------------------------------------------+
//| ClientState() |
//+------------------------------------------------------------------+
ENUM_WEBSOCKET_STATE CWebSocketClient::ClientState(void)
{
if(m_socket.IsConnected())
return(m_wsclient);
//---
if(m_wsclient!=CLOSED)
{
m_socket.Close();
m_wsclient=CLOSED;
}
//---
return(m_wsclient);
}
//+------------------------------------------------------------------+
//| reset(): Used to reinitialize class properties |
//+------------------------------------------------------------------+
void CWebSocketClient::reset(void)
{
//---
m_wsclient=0;
m_timeout=0;
m_frames=0;
m_total_len=0;
m_msgsize=0;
m_sent=true;
//---
if(ArraySize(m_send)>0)
ArrayFree(m_send);
if(ArraySize(m_rxbuf)>0)
ArrayFree(m_rxbuf);
if(ArraySize(m_txbuf)>0)
ArrayFree(m_txbuf);
//---
return;
}
//+------------------------------------------------------------------+
//|Upgrade(): requests server to accept Websocket protocol connection|
//+------------------------------------------------------------------+
bool CWebSocketClient::upgrade(void)
{
const uchar key[] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
char rsp[];
string result;
uchar src[16]= {0};
uchar sh1key[];
string keystr="";
uchar dst[];
for(int i=0; i<16; i++)
{
src[i]=(uchar)(255*MathRand()/32767);
}
int res=CryptEncode(CRYPT_BASE64,src,key,dst);
if(res<=0)
{
m_socket.Log("Crypt encode error",__LINE__,__FUNCTION__);
return(false);
}
keystr=CharArrayToString(dst,0,WHOLE_ARRAY,CP_UTF8);
if(keystr=="")
{
m_socket.Log("Char array to string error",__LINE__,__FUNCTION__);
return(false);
}
bool upgraded=false;
bool upgraderequest=false;
string request;
int ss=StringFind(m_socket.Address(),"/");
//---
if(ss>=0)
request=HEADER_GET+StringSubstr(m_socket.Address(),ss+1)+HEADER_HTTP+HEADER_EOL;
else
request=HEADER_GET+HEADER_HTTP+HEADER_EOL;
//---
if(m_socket.Port()!=80 && m_socket.Port()!=443)
request+=HEADER_HOST+m_socket.Address()+":"+IntegerToString(m_socket.Port())+HEADER_EOL;
else
request+=HEADER_HOST+m_socket.Address()+HEADER_EOL;
//---
request+=HEADER_UPGRADE+HEADER_CONNECTION+HEADER_KEY+keystr+HEADER_EOL+HEADER_WS_VERSION;
//---
m_socket.Log(request,__LINE__,__FUNCTION__);
//---
char req[];
int len=StringToCharArray(request,req)-1;
if(len<0)
{
m_socket.Log("string to char array error",__LINE__,__FUNCTION__);
return(false);
}
//---
upgraderequest=(m_socket.Send(req,(uint)len)==len)?true:false;
//---
if(!upgraderequest)
{
m_socket.Log("send error",__LINE__,__FUNCTION__);
return(false);
}
//---
uint leng=0;
uint timeout_check=GetTickCount()+m_timeout;
//---
do
{
leng=m_socket.Readable();
if(leng)
{
int rsp_len;
//--- various reading commands depending on whether the connection is secure or not
rsp_len=m_socket.Read(rsp,leng,m_timeout);
//--- analyze the response
if(rsp_len>0)
{
result+=CharArrayToString(rsp,0,rsp_len,CP_UTF8);
//--- print only the response header
if(StringFind(result,(HEADER_EOL+HEADER_EOL),0)>=0)
break;
}
}
}
while(GetTickCount()<timeout_check);
//---
m_socket.Log(result,__LINE__,__FUNCTION__);
//---
uchar _sh1[];
uchar _dest[];
uchar resp[];
string sh1confirm="";
int y=StringToCharArray(keystr+GUID,_sh1);
if(y>0)
ArrayRemove(_sh1,y-1,1);
else
{
m_socket.Log("String to char array error",__LINE__,__FUNCTION__);
}
//---
res=0;
res=CryptEncode(CRYPT_HASH_SHA1,_sh1,sh1key,_dest);
if(res>0)
if(CryptEncode(CRYPT_BASE64,_dest,key,resp)>0)
{
sh1confirm=CharArrayToString(resp,0,WHOLE_ARRAY,CP_UTF8);
m_socket.Log(sh1confirm,__LINE__,__FUNCTION__);
}
else
{
m_socket.Log("Crypt encode error",__LINE__,__FUNCTION__);
}
//---
if(StringFind(result,"Sec-WebSocket-Accept: "+sh1confirm)>=0)
{
m_wsclient=CONNECTED;
return(true);
}
else
if(StringFind(result,"Sec-WebSocket-Accept")>=0)
{
m_wsclient=CONNECTED;
return(true);
}
//---
return(false);
}
//+------------------------------------------------------------------+
//|prepareSendBuffer()prepares array buffer for socket dispatch |
//+------------------------------------------------------------------+
bool CWebSocketClient::fillTxBuffer(ENUM_FRAME_TYPE ftype)
{
uchar header[];
static int it;
static int start;
uchar masking_key[4]= {0};
int maxsend=(m_maxsendsize<7)?m_msgsize:((m_maxsendsize<126)?m_maxsendsize-6:((m_maxsendsize<65536)?m_maxsendsize-8:m_maxsendsize-14));
//---
for(int i=0; i<4; i++)
{
masking_key[i]=(uchar)(255*MathRand()/32767);
}
//---
m_socket.Log("[send]max size - "+IntegerToString(maxsend),__LINE__,__FUNCTION__);
m_socket.Log("[send]should be max size - "+IntegerToString(m_maxsendsize),__LINE__,__FUNCTION__);
int message_size=(((start+maxsend)-1)<=(m_msgsize-1))?maxsend:m_msgsize%maxsend;
bool isfinal=((((start+maxsend)-1)==(m_msgsize-1)) || (message_size<maxsend) ||(message_size<=0))?true:false;
bool isfirst=(start==0)?true:false;
//---
m_socket.Log("[send]message size - "+IntegerToString(message_size),__LINE__,__FUNCTION__);
if(isfirst)
m_socket.Log("[send]first frame",__LINE__,__FUNCTION__);
if(isfinal)
m_socket.Log("[send]final frame",__LINE__,__FUNCTION__);
//---
if(ArrayResize(header,2 + (message_size >= 126 ? 2 : 0) + (message_size >= 65536 ? 6 : 0) + (4))<0)
{
m_socket.Log("array resize error",__LINE__,__FUNCTION__);
return(false);
}
//header[0] = (isfinal)? (0x80 | 0x1) :( );
switch(ftype)
{
case CLOSE_FRAME:
header[0] = uchar(0x80|CLOSE_FRAME);
m_socket.Log("[building]close frame",__LINE__,__FUNCTION__);
break;
case PING_FRAME:
header[0] = uchar(0x80|PING_FRAME);
m_socket.Log("[building]ping frame",__LINE__,__FUNCTION__);
break;
case PONG_FRAME:
header[0] = uchar(0x80|PONG_FRAME);
m_socket.Log("[building]pong frame",__LINE__,__FUNCTION__);
break;
default:
header[0] = (isfinal)? 0x80:0x0;
m_socket.Log("[building]"+EnumToString(ftype),__LINE__,__FUNCTION__);
if(isfirst)
header[0] |=uchar(ftype);
break;
}
//---
if(message_size < 126)
{
header[1] = (uchar)(message_size & 0xff) | 0x80 ;
header[2] = masking_key[0];
header[3] = masking_key[1];
header[4] = masking_key[2];
header[5] = masking_key[3];
}
else
if(message_size < 65536)
{
header[1] = 126 | 0x80 ;
header[2] = (uchar)(message_size >> 8) & 0xff;
header[3] = (uchar)(message_size >> 0) & 0xff;
header[4] = masking_key[0];
header[5] = masking_key[1];
header[6] = masking_key[2];
header[7] = masking_key[3];
}
else
{
header[1] = 127 | 0x80;
header[2] = (uchar)(message_size >> 56) & 0xff;
header[3] = (uchar)(message_size >> 48) & 0xff;
header[4] = (uchar)(message_size >> 40) & 0xff;
header[5] = (uchar)(message_size >> 32) & 0xff;
header[6] = (uchar)(message_size >> 24) & 0xff;
header[7] = (uchar)(message_size >> 16) & 0xff;
header[8] = (uchar)(message_size >> 8) & 0xff;
header[9] = (uchar)(message_size >> 0) & 0xff;
header[10] = masking_key[0];
header[11] = masking_key[1];
header[12] = masking_key[2];
header[13] = masking_key[3];
}
//---
if(ArrayResize(m_send,ArraySize(header),message_size)<0)
{
m_socket.Log("array resize error",__LINE__,__FUNCTION__);
return(false);
}
//---
ArrayCopy(m_send,header,0,0);
//---
if(message_size)
{
if(ArrayResize(m_send,ArraySize(header)+message_size)<0)
{
m_socket.Log("array resize error",__LINE__,__FUNCTION__);
return(false);
}
//---
ArrayCopy(m_send,m_txbuf,ArraySize(header),start,message_size);
//---
int bufsize=ArraySize(m_send);
//---
int message_offset = bufsize - message_size;
//---
for(int i = 0; i < message_size; i++)
{
m_send[message_offset+ i] ^= masking_key[i&0x3];
}
}
//---
if(isfinal)
{
it=0;
start=0;
m_sent=true;
ArrayFree(m_txbuf);
}
else
{
it++;
start=it*maxsend;
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| receiver()fills rxbuf with raw message |
//+------------------------------------------------------------------+
int CWebSocketClient::fillRxBuffer(void)
{
uint leng=0;
int rsp_len=-1;
//---
uint timeout_check=GetTickCount()+m_timeout;
//---
do
{
leng=m_socket.Readable();
if(leng)
rsp_len+=m_socket.Read(m_rxbuf,leng,m_timeout);
leng=0;
}
while(GetTickCount()<timeout_check);
//---
m_socket.Log("receive size "+IntegerToString(rsp_len),__LINE__,__FUNCTION__);
//---
int m_rxsize=ArraySize(m_rxbuf);
//---
if(m_rxsize<3)
return(0);
//---
switch((uint)m_rxbuf[1])
{
case 126:
if(m_rxsize<4)
{
m_rxsize=0;
}
break;
case 127:
if(m_rxsize<10)
{
m_rxsize=0;
}
break;
default:
break;
}
//---
return(m_rxsize);
}
//+------------------------------------------------------------------+
//|int sendMessage() helper |
//+------------------------------------------------------------------+
int CWebSocketClient::send(ENUM_FRAME_TYPE frame_type)
{
//---
bool done=false;
int bytes_sent=0,sum_sent=0;
while(!m_sent)
{
done=fillTxBuffer(frame_type);
if(done && m_socket.Writable())
{
bytes_sent=m_socket.Send(m_send,(uint)ArraySize(m_send));
//---
if(bytes_sent<0)
break;
else
{
sum_sent+=bytes_sent;
ArrayFree(m_send);
}
//---
}
else
break;
}
//---
if(ArraySize(m_send)>0)
ArrayFree(m_send);
//---
m_socket.Log("",__LINE__,__FUNCTION__);
//---
return(sum_sent);
}
//+------------------------------------------------------------------+
//| parse() cleans up raw data buffer discarding unnecessary elements|
//+------------------------------------------------------------------+
bool CWebSocketClient::parse(CFrame& out[])
{
uint i,data_len=0,frames=0;
uint s=0;
m_total_len=0;
//---
int shift=0;
for(i=0; i<(uint)ArraySize(m_rxbuf); i+=(data_len+shift))
{
++frames;
m_socket.Log("value of frame is "+IntegerToString(frames)+" Value of i is "+IntegerToString(i),__LINE__,__FUNCTION__);
switch((uint)m_rxbuf[i+1])
{
case 126:
data_len=((uint)m_rxbuf[i+2]<<8)+((uint)m_rxbuf[i+3]);
shift=4;
break;
case 127:
data_len=((uint)m_rxbuf[i+2]<<56)+((uint)m_rxbuf[i+3]<<48)+((uint)m_rxbuf[i+4]<<40)+
((uint)m_rxbuf[i+5]<<32)+((uint)m_rxbuf[i+6]<<24)+((uint)m_rxbuf[i+7]<<16)+
((uint)m_rxbuf[i+8]<<8)+((uint)m_rxbuf[i+9]);
shift=10;
break;
default:
data_len=(uint)m_rxbuf[i+1];
shift=2;
break;
}
m_total_len+=data_len;
if(data_len>0)
{
if(ArraySize(out)<(int)frames)
{
if(ArrayResize(out,frames,1)<=0)
{
m_socket.Log("array resize error",__LINE__,__FUNCTION__);
return(false);
}
}
//---
if(!out[frames-1].Fill(m_rxbuf,i+shift,data_len))
{
m_socket.Log("Error adding new frame",__LINE__,__FUNCTION__);
return(false);
}
//---
switch((uchar)m_rxbuf[i])
{
case 0x1:
if(out[frames-1].MessageType()==0)
out[frames-1].SetMessageType(TEXT_FRAME);
break;
case 0x2:
if(out[frames-1].MessageType()==0)
out[frames-1].SetMessageType(BINARY_FRAME);
break;
case 0x80:
case 0x81:
if(out[frames-1].MessageType()==0)
out[frames-1].SetMessageType(TEXT_FRAME);
case 0x82:
if(out[frames-1].MessageType()==0)
out[frames-1].SetMessageType(BINARY_FRAME);
m_socket.Log("received last frame",__LINE__,__FUNCTION__);
out[frames-1].SetFinal();
break;
case 0x88:
m_socket.Log("received close frame",__LINE__,__FUNCTION__);
out[frames-1].SetMessageType(CLOSE_FRAME);
if(m_wsclient==CONNECTED)
{
ArrayCopy(m_txbuf,m_rxbuf,0,i+shift,data_len);
m_wsclient=CLOSING;
}
break;
case 0x89:
m_socket.Log("received ping frame",__LINE__,__FUNCTION__);
out[frames-1].SetMessageType(PING_FRAME);
if(m_wsclient==CONNECTED)
ArrayCopy(m_txbuf,m_rxbuf,0,i+shift,data_len);
break;
case 0x8a:
m_socket.Log("received pong frame",__LINE__,__FUNCTION__);
out[frames-1].SetMessageType(PONG_FRAME);
break;
default:
break;
}
}
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| Connect(): Used to establish connection to websocket server |
//+------------------------------------------------------------------+
bool CWebSocketClient::Connect(const string url,const uint port,const uint timeout,bool use_tls=false,bool enablelog=false)
{
reset();
//---
m_timeout=timeout;
//---
if(!m_socket.Open(url,port,m_timeout,use_tls,enablelog))
{
m_socket.Log("Connect error",__LINE__,__FUNCTION__);
return(false);
}
else
m_wsclient=CONNECTING;
//---
if(!upgrade())
return(false);
//---
m_socket.Log("ws client state "+EnumToString(m_wsclient),__LINE__,__FUNCTION__);
//---
if(m_wsclient!=CONNECTED)
{
m_wsclient=CLOSED;
m_socket.Close();
reset();
}
//---
return(m_wsclient==CONNECTED);
}
//+------------------------------------------------------------------+
//| Close() inform server client is disconnecting |
//+------------------------------------------------------------------+
bool CWebSocketClient::Close(ENUM_CLOSE_CODE close_code = NORMAL_CLOSE,const string close_reason = "")
{
ClientState();
//---
if(m_wsclient==0)
{
m_socket.Log("Client Disconnected",__LINE__,__FUNCTION__);
//---
return(true);
}
//---
if(ArraySize(m_txbuf)<=0)
{
if(close_reason!="")
{
int len=StringToCharArray(close_reason,m_txbuf,2,120,CP_UTF8)-1;
if(len<=0)
return(false);
else
ArrayRemove(m_txbuf,len,1);
}
else
{
if(ArrayResize(m_txbuf,2)<=0)
{
m_socket.Log("array resize error",__LINE__,__FUNCTION__);
return(false);
}
}
m_txbuf[0]=(uchar)(close_code>>8) & 0xff;
m_txbuf[1]=(uchar)(close_code>>0) & 0xff;
//---
}
//---
m_msgsize=ArraySize(m_txbuf);
m_sent=false;
//---
send(CLOSE_FRAME);
//---
m_socket.Close();
//---
reset();
//---
return(true);
//---
}
//+------------------------------------------------------------------+
//| Send() sends text data to websocket server |
//+------------------------------------------------------------------+
int CWebSocketClient::SendString(const string message)
{
ClientState();
//---
if(m_wsclient==CLOSED || m_wsclient==CLOSING)
{
m_socket.Log("invalid ws client handle",__LINE__,__FUNCTION__);
return(0);
}
//---
if(message=="")
{
m_socket.Log("no message specified",__LINE__,__FUNCTION__);
return(0);
}
//---
int len=StringToCharArray(message,m_txbuf,0,WHOLE_ARRAY,CP_UTF8)-1;
if(len<=0)
{
m_socket.Log("string char array error",__LINE__,__FUNCTION__);
return(0);
}
else
ArrayRemove(m_txbuf,len,1);
//---
m_msgsize=ArraySize(m_txbuf);
m_sent=false;
//---
return(send(TEXT_FRAME));
}
//+------------------------------------------------------------------+
//| Send() sends user supplied array buffer |
//+------------------------------------------------------------------+
int CWebSocketClient::SendData(uchar& message_buffer[])
{
ClientState();
//---
if(m_wsclient==CLOSED || m_wsclient==CLOSING)
{
m_socket.Log("invalid ws client handle",__LINE__,__FUNCTION__);
return(0);
}
//---
if(ArraySize(message_buffer)==0)
{
m_socket.Log("array is empty",__LINE__,__FUNCTION__);
return(0);
}
//---
if(ArrayResize(m_txbuf,ArraySize(message_buffer))<0)
{
m_socket.Log("array resize error",__LINE__,__FUNCTION__);
return(0);
}
else
ArrayCopy(m_txbuf,message_buffer);
//---
m_msgsize=ArraySize(m_txbuf);
m_sent=false;
//---
return(send(BINARY_FRAME));
}
//+------------------------------------------------------------------+
//| SendPong() sends pong response upon receiving ping |
//+------------------------------------------------------------------+
int CWebSocketClient::SendPong(const string msg="")
{
ClientState();
//---
if(m_wsclient==CLOSED || m_wsclient==CLOSING)
{
m_socket.Log("invalid ws client handle",__LINE__,__FUNCTION__);
return(0);
}
//---
if(ArraySize(m_txbuf)<=0)
{
if(msg!="")
{
int len=StringToCharArray(msg,m_txbuf,0,122,CP_UTF8)-1;
if(len<=0)
{
m_socket.Log("string to char array error",__LINE__,__FUNCTION__);
return(0);
}
else
ArrayRemove(m_txbuf,len,1);
}
}
//---
m_msgsize=ArraySize(m_txbuf);
m_sent=false;
//---
return(send(PONG_FRAME));
}
//+------------------------------------------------------------------+
//| SendPing() ping the server |
//+------------------------------------------------------------------+
int CWebSocketClient::SendPing(const string msg="")
{
ClientState();
//---
if(m_wsclient==CLOSED || m_wsclient==CLOSING)
{
m_socket.Log("invalid ws client handle",__LINE__,__FUNCTION__);
return(0);
}
//---
if(ArraySize(m_txbuf)<=0)
{
if(msg!="")
{
int len=StringToCharArray(msg,m_txbuf,0,122,CP_UTF8)-1;
if(len<=0)
{
m_socket.Log("string to char array error",__LINE__,__FUNCTION__);
return(0);
}
else
ArrayRemove(m_txbuf,len,1);
}
}
//---
m_msgsize=ArraySize(m_txbuf);
m_sent=false;
//---
return(send(PING_FRAME));
}
//+------------------------------------------------------------------+
//|Getmessage() return message frame(s) as uchar array |
//+------------------------------------------------------------------+
uint CWebSocketClient::Read(CFrame& out[])
{
ClientState();
//---
if(m_wsclient==0)
{
m_socket.Log("invalid ws client handle",__LINE__,__FUNCTION__);
return(0);
}
//---
int rx_size=ArraySize(m_rxbuf);
//---
if(rx_size<=0)
{
m_socket.Log("receive buffer is empty, Make sure to call Readable first",__LINE__,__FUNCTION__);
return(0);
}
//---clean up rxbuf
if(!parse(out))
{
ArrayFree(m_rxbuf);
return(0);
}
//---
ArrayFree(m_rxbuf);
//---
return(m_total_len);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
Reference in a new issue Copy permalink