/**
* \brief 发送指令
* \param pstrCmd 待发送的内容
* \param nCmdLen 待发送内容的大小
* \param buffer 是否需要缓冲
* \return 发送是否成功
*/
bool CSocket::sendCmd(const void *pstrCmd,const int nCmdLen,const bool buffer)
{
//Zebra::logger->debug("CSocket::sendCmd");
if (NULL == pstrCmd || nCmdLen <= 0)
return false;
bool retval = true;
// Zebra::logger->debug("期望目标：%s : %u", getIP(), getPort());
// Zebra::logger->debug16("希望发送：", (BYTE*)pstrCmd, nCmdLen);
if (buffer)
{
// 直接把数据加密压缩封包后放到发送缓冲_enc_queue
t_StackCmdQueue _raw_queue;
packetAppend(pstrCmd,nCmdLen,_raw_queue);
mutex.lock();
_enc_queue.put(_raw_queue.rd_buf(),_raw_queue.rd_size());
mutex.unlock();
}
else
{
t_StackCmdQueue _raw_queue;
packetAppend(pstrCmd,nCmdLen,_raw_queue);
mutex.lock();
retval = sendRawDataIM(_raw_queue.rd_buf(),_raw_queue.rd_size());
mutex.unlock();
}
return retval;
}
/**
* \brief 发送指令
* \param pstrCmd 待发送的内容
* \param nCmdLen 待发送内容的大小
* \param buffer 是否需要缓冲
* \return 发送是否成功
*/
bool zSocket::sendCmd(const void *pstrCmd, const int nCmdLen, const bool buffer)
{
//Zebra::logger->trace("zSocket::sendCmd");
if (NULL == pstrCmd || nCmdLen <= 0)
return false;
bool retval = true;
if (buffer)
{
t_StackCmdQueue _raw_queue;
packetAppendNoEnc(pstrCmd, nCmdLen, _raw_queue);
mutex.lock();
_snd_queue.put(_raw_queue.rd_buf(), _raw_queue.rd_size());
_current_cmd = _raw_queue.rd_size();
mutex.unlock();
}
else
{
t_StackCmdQueue _raw_queue;
packetAppend(pstrCmd, nCmdLen, _raw_queue);
mutex.lock();
retval = sendRawDataIM(_raw_queue.rd_buf(), _raw_queue.rd_size());
mutex.unlock();
}
return retval;
}
int
vtWrite(VtSession *z, uint8_t score[VtScoreSize], int type, uint8_t *buf,
int n)
{
Packet *p = packetAlloc();
packetAppend(p, buf, n);
return vtWritePacket(z, score, type, p);
}
int
vtAddString(Packet *p, char *s)
{
uint8_t buf[2];
int n;
if(s == nil) {
vtSetError(ENullString);
return 0;
}
n = strlen(s);
if(n > VtMaxStringSize) {
vtSetError(EBigString);
return 0;
}
buf[0] = n>>8;
buf[1] = n;
packetAppend(p, buf, 2);
packetAppend(p, (uint8_t*)s, n);
return 1;
}
int
vtHello(VtSession *z)
{
Packet *p;
uint8_t buf[10];
char *sid;
int crypto, codec;
sid = nil;
p = packetAlloc();
if(!vtAddString(p, vtGetVersion(z)))
goto Err;
if(!vtAddString(p, vtGetUid(z)))
goto Err;
buf[0] = vtGetCryptoStrength(z);
buf[1] = 0;
buf[2] = 0;
packetAppend(p, buf, 3);
p = vtRPC(z, VtQHello, p);
if(p == nil)
return 0;
if(!vtGetString(p, &sid))
goto Err;
if(!packetConsume(p, buf, 2))
goto Err;
if(packetSize(p) != 0) {
vtSetError(EProtocolBotch);
goto Err;
}
crypto = buf[0];
codec = buf[1];
USED(crypto);
USED(codec);
packetFree(p);
vtLock(z->lk);
z->sid = sid;
z->auth.state = VtAuthOK;
vtSha1Free(z->inHash);
z->inHash = nil;
vtSha1Free(z->outHash);
z->outHash = nil;
vtUnlock(z->lk);
return 1;
Err:
packetFree(p);
vtMemFree(sid);
return 0;
}
Packet *
vtReadPacket(VtSession *z, uint8_t score[VtScoreSize], int type, int n)
{
Packet *p;
uint8_t buf[10];
if(n < 0 || n > VtMaxLumpSize) {
vtSetError(ELumpSize);
return nil;
}
p = packetAlloc();
if(memcmp(score, vtZeroScore, VtScoreSize) == 0)
return p;
packetAppend(p, score, VtScoreSize);
buf[0] = type;
buf[1] = 0; /* pad */
buf[2] = n >> 8;
buf[3] = n;
packetAppend(p, buf, 4);
return vtRPC(z, VtQRead, p);
}
bool Socket::sendCmd(const void *cmd,const DWORD cmdLen,const bool buffer)
{
LogCheckCondition(cmd && cmdLen,false,"套接字发送失败参数不合法");
bool retval = true;
StackCmdQueue rawQueue;
if(buffer)
{
packetAppendNoEnc(cmd,cmdLen,rawQueue);
m_mutex.lock();
m_sendQueue.put(rawQueue.rdBuffer(),rawQueue.rdSize());
m_currentCmd = rawQueue.rdSize();
m_mutex.unlock();
}
else
{
packetAppend(cmd,cmdLen,rawQueue);
m_mutex.lock();
retval = sendRawDataIM(rawQueue.rdBuffer(),rawQueue.rdSize());
m_currentCmd = rawQueue.rdSize();
m_mutex.unlock();
}
return retval;
}
//______________________________________________________________________________
// Open the envelope, starting at the crypto layer.
// If successful, the envelope is processed
// otherwise, the envelope is discarded.
// The purpose of this entry point is to allow
// integration with our POSIX network-based library
// (in this case, the IP address and UDP port are
// known only to POSIX, and the HeaderIpUdp flag is
// not set so this code never receives UDP/IP headers.)
//______________________________________________________________________________
Packet*
envelopeOpenStartingAtCrypto(NetInterface *ni,
EnvelopeBuffer payload,
EnvelopeLocal envelopeLocal,
EnvelopeRemote envelopeRemote)
{
ASSERT(NULL != ni);
Packet *packet = NULL;
if (ni->headers & HeaderCrypto)
{
if (! cryptoExtract(&payload, &envelopeRemote))
{
goto done;
}
}
Tunnel *tunnel = _envelopeFindTunnel(ni, &envelopeRemote);
if (tunnel)
{
if (envelopeRemote.publicKeyPresent)
{
if (0!=memcmp(envelopeRemote.ephemeralPublicKey, tunnel->envelopeRemote.ephemeralPublicKey, CryptoBoxPublicKeySize))
{
debugXPrint(envelopeDebug,
"oops, public key present on existing tunnel "
"does not match tunnel's key\n");
debugXPrint(tunnelDebug, "packet key = $[pubboxkey]", envelopeRemote.ephemeralPublicKey);
debugXPrint(tunnelDebug, "tunnel key = $[pubboxkey]", tunnel->envelopeRemote.ephemeralPublicKey);
goto done; // A bad packet.
}
}
}
else if (! ni->locked)
{ // Create a new tunnel.
if ((ni->headers & HeaderCrypto) && (!envelopeRemote.publicKeyPresent))
{
debugXPrint(envelopeDebug, "oops, public key not present on created tunnel\n");
envelopeRemotePrint(&envelopeRemote);
goto done; // Not really a bug, just a bad packet.
}
tunnel = _envelopeCreateTunnel(ni, &envelopeRemote);
if (NULL == tunnel)
{
goto done;
}
debugXPrint(envelopeDebug, "New tunnel created.\n");
envelopeLocalPrint(&envelopeLocal);
envelopeRemotePrint(&envelopeRemote);
}
else
{
goto done;
}
static char buffer[2048];
EnvelopeBuffer cleartext = {buffer, sizeof (buffer)};
if (ni->headers & HeaderCrypto)
{
if (envelopeRemote.nonce <= tunnel->envelopeRemote.nonce)
{
debugXPrint(envelopeDebug,
"bad nonce, ignored -- nonce = $[lluint] el nonce = $[lluint] tunnel nonce = $[lluint]\n",
envelopeRemote.nonce, envelopeLocal.nonce, tunnel->envelopeRemote.nonce);
goto done;
}
if (! cryptoDecrypt(payload, &cleartext, &envelopeLocal, &envelopeRemote, tunnel))
{
if (! cryptoComputeSymmetricKey(&ni->envelopeLocal, &tunnel->envelopeRemote, NetCryptoKeyPermanent))
{
goto done;
}
if (! cryptoDecrypt(payload, &cleartext, &envelopeLocal, &envelopeRemote, tunnel))
{
goto done;
}
}
debugXPrint(envelopeDebug, "Packet decrypted. nonce=$[lluint]\n", envelopeRemote.nonce);
tunnel->envelopeRemote.nonce = envelopeRemote.nonce;
}
else
{
cleartext = payload;
}
ulong length = cleartext.size;
packet = packetAllocate(length);
packet->tunnel = tunnel;
packetAppend(packet, (uint8_t *) cleartext.start, length);
resetCurrent(packet);
debugXPrint(envelopeDebug, "Before tunnelIsNewPacket.\n");
// now process the packet for the reliability and connection layers
if (tunnelIsNewPacket(packet))
{
debugXPrint(envelopeDebug, "valid packet found!\n");
envelopeRemotePrint(&envelopeRemote);
goto done;
}
// Not useful; toss.
packetFree(packet);
packet = NULL;
done:
return packet;
}
