/** * \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; }