void telnet_console_connection::release() {
if (console->should_log(DEBUG))
console->log().xprintf("(CONSOLE) releasing connection from "
"%{Addr}.\n", peeraddr());
console_connection::release();
}
int sockinetbuf::peerhost(char *hostname, size_t hostnameLen) const
{
hostname[0] = '\0';
sockinetaddr sin = peeraddr();
if (sin.family() != af_inet) return -1;
return sin.gethostname(hostname, hostnameLen);
}
void netinit(T_Connect *conn,T_NetHead *head)
{
T_SRV_Var *srvp=(T_SRV_Var *)conn->Var;
GDA *gp=(GDA *)srvp->var;
char addr[16],*envp;
envp=getenv("SENDSIZE");
if(envp && isdigit(*envp)) conn->MTU=atoi(envp);
envp=getenv("TIMEOUT");
if(envp && isdigit(*envp)) srvp->o_timeout=conn->timeout=60*atoi(envp);
else srvp->o_timeout=conn->timeout=0;
peeraddr(conn->Socket,addr);
ShowLog(2,"连接 %s,TCB:%d,timeout=%d",addr,srvp->TCB_no,conn->timeout);
gp->server=NULL;
gp->data=NULL;
conn->only_do=Transfer;
conn->freevar=freevar;
}
int RecvPack(T_Connect *connect,T_NetHead *nethead)
{
char headbuf[HEADPACKLENGTH+1],addr[16];
int i,n;
u_int crc;
char *zbuf;
memset(nethead->para,0,sizeof(nethead->para));
nethead->data=NULL;
peeraddr(connect->Socket,addr);
i=RecvNet(connect->Socket,headbuf,HEADPACKLENGTH,connect->timeout);
if(i<HEADPACKLENGTH){
if(i==TIMEOUTERR) {
ShowLog(1,"%s:head TIMEOUT %d second's",__FUNCTION__,
connect->timeout);
return i;
}
ShowLog(1,"RecvPack Head LENERR i=%d,err=%d,%s",i,errno,strerror(errno));
return LENGERR;
}
if(connect->CryptFlg & DO_CRYPT)
enigma2_decrypt(&connect->t,headbuf,HEADPACKLENGTH);
i=NetHeadDispack(nethead,headbuf,connect->family[29]);
if(i!=0) {
ShowLog(1,"aft NetHeadDispack len=%d,PKGERR %s",i, addr);
showpack(1,headbuf,HEADPACKLENGTH);
return(FORMATERR);
}
if(!nethead->T_LEN) return 0;
if(connect->CryptFlg&UNDO_ZIP) {
i=nethead->T_LEN+1;
} else {
i=nethead->PKG_LEN+1;
if(nethead->T_LEN <nethead->PKG_LEN) i+=nethead->T_LEN+1;
}
n=connect->RecvLen-i;
if(!connect->RecvBuffer || n<0 || n>32768){
if(connect->RecvBuffer) {
free(connect->RecvBuffer);
connect->RecvBuffer=0;
}
connect->RecvLen=0;
connect->RecvBuffer=malloc(i);
if(!connect->RecvBuffer) return MEMERR;
connect->RecvLen=i;
}
if(!(connect->CryptFlg&UNDO_ZIP) && nethead->T_LEN != nethead->PKG_LEN) {
zbuf=connect->RecvBuffer+nethead->PKG_LEN+1;
} else zbuf=connect->RecvBuffer;
i=RecvNet(connect->Socket,zbuf,nethead->T_LEN,5);
if(i != (nethead->T_LEN)) {
if(TIMEOUTERR == i) {
ShowLog(1,"%s:recv body TIMEOUT",__FUNCTION__);
return i;
}
ShowLog(1,"%s,Recv Body T_LEN=%d i=%d,errno=%d",__FUNCTION__,
nethead->T_LEN,i,errno);
free(connect->RecvBuffer);
connect->RecvBuffer=0;
connect->RecvLen=0;
return i<0?SYSERR:LENGERR;
}
crc=ssh_crc32((const unsigned char *)zbuf, nethead->T_LEN);
if((connect->CryptFlg & CHECK_CRC) && (crc != nethead->PKG_CRC)) {
ShowLog(1,"RecvPack:PKG_CRC=%08X,crc=%08X,PKG_LEN=%d,T_LEN=%d,head=%s",
nethead->PKG_CRC,crc,nethead->PKG_LEN,nethead->T_LEN,headbuf);
return CRCERR;
}
pack_decode(zbuf, nethead->T_LEN,connect);
if(zbuf != connect->RecvBuffer) {
size_t sz=qlz_size_decompressed(zbuf);
if(nethead->T_LEN<9 || nethead->PKG_LEN != sz) {
ShowLog(1,"unzip error T_LEN=%d,sz=%ld,PKG_LEN=%d,ADDR=%s",nethead->T_LEN, sz,nethead->PKG_LEN,addr);
return FORMATERR;
}
i=qlz_decompress(zbuf,connect->RecvBuffer);
if(i!=nethead->PKG_LEN) {
ShowLog(1,"RecvPack:PKG_LEN=%d,T_LEN=%d,unzip_size=%d",
nethead->PKG_LEN,nethead->T_LEN,i);
return LENGERR;
}
} //else if(connect->CryptFlg & UNDO_ZIP)
// ShowLog(5,"%s:UNDO_ZIP %s,T_LEN=%d,PKG_LEN=%d,data=%s",__FUNCTION__,
// *connect->Host?connect->Host:"Client",nethead->T_LEN,nethead->PKG_LEN,connect->RecvBuffer);
if(!(connect->CryptFlg & UNDO_ZIP)) connect->RecvBuffer[nethead->PKG_LEN]=0;
nethead->data=connect->RecvBuffer;
return 0;
}
int RecvPack(T_Connect *connect,T_NetHead *nethead)
{
char headbuf[HEADPACKLENGTH+1],addr[16];
int i,n;
u_int crc;
char *zbuf;
n_zero(PARANUM,nethead->para);
nethead->data=0;
memset(headbuf,0,sizeof(headbuf));
i=RecvNet(connect->Socket,headbuf,HEADPACKLENGTH,connect->timeout);
//free SendBuffer
if(i<HEADPACKLENGTH){
if(i==TIMEOUTERR) {
ShowLog(1,"%s:head TIMEOUT %d second's",__FUNCTION__,
connect->timeout);
return i;
}
ShowLog(1,"RecvPack Head LENERR i=%d,err=%d,%s",i,errno,strerror(errno));
return LENGERR;
}
headbuf[HEADPACKLENGTH]=0;
i=NetHeadDispack(nethead,headbuf,connect->family[29]);
if(i!=0) {
peeraddr(connect->Socket,addr);
ShowLog(1,"aft NetHeadDispack len=%d,PKGERR %s:%.48s",i, addr,headbuf);
showpack(1,headbuf,HEADPACKLENGTH);
return(FORMATERR);
}
if(!nethead->T_LEN) return 0;
i=((connect->CryptFlg&UNDO_ZIP)?nethead->T_LEN:nethead->PKG_LEN)+1;
n=connect->RecvLen-i;
if(n<0 || n>SDBC_BLKSZ){
if( connect->RecvBuffer)
free(connect->RecvBuffer);
connect->RecvBuffer=0;
connect->RecvLen=0;
connect->RecvBuffer=malloc(i);
if(!connect->RecvBuffer) return MEMERR;
connect->RecvLen=i;
}
if(!(connect->CryptFlg&UNDO_ZIP) && nethead->T_LEN != nethead->PKG_LEN) {
zbuf=malloc(nethead->T_LEN);
if(!zbuf) {
RecvNet(connect->Socket,connect->RecvBuffer,nethead->T_LEN,3);
return MEMERR;
}
} else zbuf=connect->RecvBuffer;
i=RecvNet(connect->Socket,zbuf,nethead->T_LEN,3);
if(i < (nethead->T_LEN)) {
if(TIMEOUTERR == i) {
ShowLog(1,"%s:recv body TIMEOUT",__FUNCTION__);
return i;
}
if(zbuf!=connect->RecvBuffer) free(zbuf);
ShowLog(1,"%s,Recv Body T_LEN=%d i=%d,errno=%d",__FUNCTION__,
nethead->T_LEN,i,errno);
free(connect->RecvBuffer);
connect->RecvBuffer=0;
connect->RecvLen=0;
return i<0?SYSERR:LENGERR;
}
crc=ssh_crc32((const unsigned char *)zbuf, nethead->T_LEN);
if((connect->CryptFlg & CHECK_CRC) && (crc != nethead->PKG_CRC)) {
ShowLog(1,"RecvPack:PKG_CRC=%08X,crc=%08X,PKG_LEN=%d,T_LEN=%d,head=%s",
nethead->PKG_CRC,crc,nethead->PKG_LEN,nethead->T_LEN,headbuf);
return CRCERR;
}
pack_decode(zbuf, nethead->T_LEN,connect);
if(zbuf != connect->RecvBuffer) {
if(nethead->T_LEN<9 || nethead->PKG_LEN != qlz_size_decompressed(zbuf)) {
ShowLog(1,"unzip error T_LEN=%d,ADDR=%s",nethead->T_LEN, addr);
return FORMATERR;
}
i=qlz_decompress(zbuf,connect->RecvBuffer);
free(zbuf);
if(i!=nethead->PKG_LEN) {
ShowLog(1,"RecvPack:PKG_LEN=%d,T_LEN=%d,unzip_size=%d",
nethead->PKG_LEN,nethead->T_LEN,i);
return LENGERR;
}
}
connect->RecvBuffer[nethead->PKG_LEN]=0;
nethead->data=connect->RecvBuffer;
return 0;
}
int sockinetbuf::peerport() const
{
sockinetaddr sin = peeraddr();
if (sin.family() != af_inet) return -1;
return sin.getport();
}
bool NATClient::receivePacket( char* p_buffer, int /*len*/, const RNReplicaNet::XPAddress& senderaddr )
{
tNATData* p_data = reinterpret_cast< tNATData* >( p_buffer );
if ( ( p_data->_cmd & NAT_CMD_MASK ) != NAT_CMD_MASK )
return false;
// this packet comes from other clients, not from NAT server
if ( p_data->_cmd == int( NAT_PUNCH_HOLE ) )
{
log_verbose << "NATClient: hole punching packet received from: " << senderaddr.Export() << std::endl;
return true;
}
if ( _serverAddress != senderaddr )
return false;
switch ( p_data->_cmd )
{
case NAT_ACK_REGISTER_CLIENT:
{
_state = eIdle;
log_verbose << "NATClient: registered on server" << std::endl;
}
break;
case NAT_RCV_CLIENT_INFO:
{
// just to be sure
if ( _requestMap.find( p_data->_peerSID ) == _requestMap.end() )
{
log_error << "NATClient: received unrequested client info, peer sid " << p_data->_peerSID << std::endl;
break;
}
// check for port forwarding
RNReplicaNet::XPAddress mappedaddress( p_data->_fwdPort ? p_data->_fwdPort : p_data->_peerPort, p_data->_peerIP[ 0 ], p_data->_peerIP[ 1 ], p_data->_peerIP[ 2 ], p_data->_peerIP[ 3 ] );
log_verbose << "NATClient: receiving NAT info for sid " << p_data->_peerSID << std::endl;
// forward the mapped address to recipient
_requestMap[ p_data->_peerSID ]->receiveAddressMap( p_data->_peerSID, mappedaddress );
// remove the callback from internal map
_requestMap.erase( _requestMap.find( p_data->_peerSID ) );
// continue idling
_state = eIdle;
}
break;
case NAT_RCV_CLIENT_QUERY:
{
log_verbose << "NATClient: client has been queried by sid " << p_data->_peerSID << std::endl;
if ( yaf3d::NetworkDevice::get()->getSessionID() != p_data->_ownSID )
{
log_warning << "NATClient: wrong query destination " << p_data->_ownSID << std::endl;
}
// we punch a hole, only if port forwarding is not enabled!
if ( !_forwardedPort )
{
// send a dummy packet to peer client in order to punch a hole in our fw
tNATData data;
memset( &data, 0, sizeof( data ) );
data._cmd = NAT_PUNCH_HOLE;
RNReplicaNet::XPAddress peeraddr( p_data->_peerPort, p_data->_peerIP[ 0 ], p_data->_peerIP[ 1 ], p_data->_peerIP[ 2 ], p_data->_peerIP[ 3 ] );
_p_socket->Send( reinterpret_cast< char* >( &data ), sizeof( data ), peeraddr );
log_verbose << "NATClient: punching a hole for peer: " << peeraddr.Export() << std::endl;
}
}
break;
default:
{
log_warning << "NATClient: received unknown command packet from NAT server" << std::endl;
return false;
}
}
return true;
}
