void CRemoteConsole :: readPendingDatagrams()
{
while (m_UDPSocket->hasPendingDatagrams()) {
QByteArray datagram;
datagram.resize(m_UDPSocket->pendingDatagramSize());
QHostAddress sender;
quint16 senderPort;
m_UDPSocket->readDatagram(datagram.data(), datagram.size(),
&sender, &senderPort);
ProcessPacket( datagram, sender, senderPort );
// echo
m_UDPSocket->writeDatagram(datagram.data(), sender, senderPort);
}
}
void NetClient::ProcessIn( void )
{
SDL_mutexP( Lock );
// Process the entire incoming packet buffer.
while( ! InBuffer.empty() )
{
Packet *packet = InBuffer.front();
ProcessPacket( packet );
delete packet;
InBuffer.pop();
}
SDL_mutexV( Lock );
}
int main()
{
int saddr_size , data_size;
struct sockaddr saddr;
fptr=fopen("sniffer.csv","w");
if(fptr==NULL)
{
printf("Error!");
exit(1);
}
fprintf(fptr,"TCP,UDP,ICMP,ARP,DHCP,Total\n");
unsigned char *buffer = (unsigned char *) malloc(65536); //Its Big!
logfile=fopen("snifferlog.txt","w");
if(logfile==NULL)
{
printf("Unable to create log.txt file.");
}
printf("Starting...\n");
int sock_raw = socket( AF_PACKET , SOCK_RAW , htons(ETH_P_ALL)) ;
if(sock_raw < 0)
{
//Print the error with proper message
perror("Socket Error");
return 1;
}
while(1)
{
saddr_size = sizeof saddr;
//Receive a packet
data_size = recvfrom(sock_raw , buffer , 65536 , 0 , &saddr , (socklen_t*)&saddr_size);
if(data_size <0 )
{
printf("Recvfrom error , failed to get packets\n");
return 1;
}
//Now process the packet
ProcessPacket(buffer , data_size);
}
fclose(fptr);
close(sock_raw);
printf("Finished");
return 0;
}
void Server::Run()
{
Logger::Print("Server is now online and listening to incoming traffic");
m_IsRunning = true;
int nextAvailableID = 0;
ENetEvent event;
while (m_IsRunning)
{
while (enet_host_service(m_ENetHost, &event, 1000) > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
{
Client* c = new Client(this, event.peer, nextAvailableID);
m_Clients.insert(std::pair<int, Client*>(nextAvailableID, c));
nextAvailableID++;
event.peer->data = c;
Logger::Print("A new client connected from %x:%u assigned with id %d", event.peer->address.host, event.peer->address.port, m_Clients.size() - 1);
break;
}
case ENET_EVENT_TYPE_RECEIVE:
{
ProcessPacket(event.packet, event.peer);
enet_packet_destroy(event.packet);
break;
}
case ENET_EVENT_TYPE_DISCONNECT:
{
m_ClientsMutex.lock();
Client* c = m_Clients[event.data];
event.peer->data = NULL;
int playerID = c->GetPlayerID();
m_Clients.erase(playerID);
//delete c; //Delete the client after removed it reference from all other places
//BroadcastPacket(std::make_shared<PacketPlayerDisconnected>(playerID), nullptr);
Logger::Print("Client %d has disconnected", playerID);
m_ClientsMutex.unlock();
break;
}
}
}
}
m_IsRunning = false;
}
/****************************************************************************
* DecodeBlock: the whole thing
****************************************************************************
* This function must be fed with kate packets.
****************************************************************************/
static subpicture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
block_t *p_block;
kate_packet kp;
if( !pp_block || !*pp_block )
return NULL;
p_block = *pp_block;
*pp_block = NULL;
if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
{
#ifdef HAVE_TIGER
if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY)
{
/* Hmm, should we wait before flushing the renderer ? I think not, but not certain... */
vlc_mutex_lock( &p_sys->lock );
tiger_renderer_seek( p_sys->p_tr, 0 );
vlc_mutex_unlock( &p_sys->lock );
}
#endif
if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
{
p_sys->i_max_stop = VLC_TS_INVALID;
block_Release( p_block );
return NULL;
}
}
/* Block to Kate packet */
kate_packet_wrap(&kp, p_block->i_buffer, p_block->p_buffer);
if( !p_sys->b_has_headers )
{
if( ProcessHeaders( p_dec ) )
{
block_Release( *pp_block );
return NULL;
}
p_sys->b_has_headers = true;
}
return ProcessPacket( p_dec, &kp, pp_block );
}
void SocketHandler::OnRead()
{
char *curChar = new char;
while(m_socket->read(curChar, 1) > (qint64)0)
{
if(*curChar != 0x00)
{
if(*curChar != '\n' && *curChar != '\r')
m_packet += *curChar;
}
else // Fin d'un packet détectée
{
ProcessPacket(m_packet);
m_packet = "";
}
}
}
void NetworkManager::ProcessQueuedPackets()
{
//look at the front packet...
while( !mPacketQueue.empty() )
{
ReceivedPacket& nextPacket = mPacketQueue.front();
if( Timing::sInstance.GetTimef() > nextPacket.GetReceivedTime() )
{
ProcessPacket( nextPacket.GetPacketBuffer(), nextPacket.GetFromPlayer() );
mPacketQueue.pop();
}
else
{
break;
}
}
}
void Server::ReadPacket()
{
DWORD iobyte, ioflag = 0;
int ret = WSARecv(sock, &WSA_recv_buf, 1, &iobyte, &ioflag, NULL, NULL);
if (ret != 0)
{
int err_code = WSAGetLastError();
cout << "Recv Error : " << err_code << endl;
}
cout << "recv" << endl;
BYTE *ptr = reinterpret_cast<BYTE*>(Recv_buf);
while (0 != iobyte)
{
if (in_packet_size == 0)
{
in_packet_size = ptr[0];
}
if (iobyte + save_packet_size >= in_packet_size)
{
memcpy(Complete_buf + save_packet_size,
ptr,
in_packet_size - save_packet_size);
ProcessPacket(Complete_buf);
ptr += in_packet_size - save_packet_size;
iobyte -= in_packet_size - save_packet_size;
in_packet_size = 0;
save_packet_size = 0;
}
else
{
memcpy(Complete_buf + save_packet_size, ptr, iobyte);
save_packet_size += iobyte;
iobyte = 0;
}
}
}
/****************************************************************************
* DecodeBlock: the whole thing
****************************************************************************
* This function must be fed with ogg packets.
****************************************************************************/
static block_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
ogg_packet oggpacket;
if( !pp_block ) return NULL;
if( *pp_block )
{
/* Block to Ogg packet */
oggpacket.packet = (*pp_block)->p_buffer;
oggpacket.bytes = (*pp_block)->i_buffer;
}
else
{
if( p_sys->b_packetizer ) return NULL;
/* Block to Ogg packet */
oggpacket.packet = NULL;
oggpacket.bytes = 0;
}
oggpacket.granulepos = -1;
oggpacket.b_o_s = 0;
oggpacket.e_o_s = 0;
oggpacket.packetno = 0;
/* Check for headers */
if( !p_sys->b_has_headers )
{
if( ProcessHeaders( p_dec ) )
{
if( *pp_block )
block_Release( *pp_block );
return NULL;
}
p_sys->b_has_headers = true;
}
return ProcessPacket( p_dec, &oggpacket, pp_block );
}
//-----------------------------------------------------------------------------------------------
//Private Methods
//-----------------------------------------------------------------------------------------------
void Server::ReceiveMessagesFromClientsIfAny()
{
Network& theNetwork = Network::GetInstance();
int bytesReceived = 0;
CS6Packet receivedPacket;
do
{
bytesReceived = 0;
ZeroMemory( &receivedPacket, sizeof( receivedPacket ) );
bytesReceived = theNetwork.ReceiveUDPMessage( ( char* )&receivedPacket, sizeof( receivedPacket ), m_listenConnectionID );
if( bytesReceived == sizeof( CS6Packet ) )
{
ProcessPacket( receivedPacket );
}
}
while ( bytesReceived > 0 );
}
void StartSniffing(SOCKET sniffer)
{
BYTE *Buffer = new BYTE[65536]; //Its Big!
int mangobyte;
if (Buffer == NULL)
{
printf("malloc() failed.\n");
return;
}
do
{
mangobyte = recvfrom(sniffer,(char*)Buffer,65536,0,0,0); //Eat as much as u can
if(mangobyte > 0) ProcessPacket(Buffer, mangobyte);
else printf( "recvfrom() failed.\n");
}
while (mangobyte > 0);
delete [] Buffer;
}
bool CServerSocket::PacketReceived(Packet* packet)
{
#ifndef _DEBUG
try {
#endif
theStats.AddDownDataOverheadServer(packet->size);
if (packet->prot == OP_PACKEDPROT)
{
uint32 uComprSize = packet->size;
if (!packet->UnPackPacket(250000)){
if (thePrefs.GetVerbose())
DebugLogError(_T("Failed to decompress server TCP packet: protocol=0x%02x opcode=0x%02x size=%u"), packet ? packet->prot : 0, packet ? packet->opcode : 0, packet ? packet->size : 0);
return true;
}
packet->prot = OP_EDONKEYPROT;
if (thePrefs.GetDebugServerTCPLevel() > 1)
Debug(_T("Received compressed server TCP packet; opcode=0x%02x size=%u uncompr size=%u\n"), packet->opcode, uComprSize, packet->size);
}
if (packet->prot == OP_EDONKEYPROT)
{
ProcessPacket((const BYTE*)packet->pBuffer, packet->size, packet->opcode);
}
else
{
if (thePrefs.GetVerbose())
DebugLogWarning(_T("Received server TCP packet with unknown protocol: protocol=0x%02x opcode=0x%02x size=%u"), packet ? packet->prot : 0, packet ? packet->opcode : 0, packet ? packet->size : 0);
}
#ifndef _DEBUG
}
catch(...)
{
if (thePrefs.GetVerbose())
DebugLogError(_T("Error: Unhandled exception while processing server TCP packet: protocol=0x%02x opcode=0x%02x size=%u"), packet ? packet->prot : 0, packet ? packet->opcode : 0, packet ? packet->size : 0);
ASSERT(0);
return false;
}
#endif
return true;
}
int main()
{
int saddr_size , data_size;
struct sockaddr saddr;
unsigned char *buffer = (unsigned char *) malloc(65536); //Its Big!
logfile=fopen("log.txt","w");
if(logfile==NULL)
{
printf("Unable to create log.txt file.");
}
printf("Starting...\n");
int sock_raw = socket( AF_PACKET , SOCK_RAW , htons(ETH_P_ALL)) ;
//setsockopt(sock_raw , SOL_SOCKET , SO_BINDTODEVICE , "eth0" , strlen("eth0")+ 1 );
if(sock_raw < 0)
{
//Print the error with proper message
perror("Socket Error");
return 1;
}
while(1)
{
saddr_size = sizeof saddr;
//Receive a packet
data_size = recvfrom(sock_raw , buffer , 65536 , 0 , &saddr , (socklen_t*)&saddr_size);
if(data_size <0 )
{
printf("Recvfrom error , failed to get packets\n");
return 1;
}
//Now process the packet
ProcessPacket(buffer , data_size);
}
close(sock_raw);
printf("Finished");
return 0;
}
void AReplayPlayer::SeekToIncident(EPlaybackDirection NewDirection) {
Direction = NewDirection;
Paused = true;
msgpack_object* obj = NULL;
while (true) {
if (Direction == EPlaybackDirection::PD_Forward) {
obj = NextPacket();
}
else{
obj = PrevPacket();
}
if (!obj) {
Paused = true;
Time = CurrentTime;
Stats->SetTimePaused(CurrentTime - StartTime);
return;
}
if (!(obj->type == MSGPACK_OBJECT_ARRAY)) {
continue;
}
check(obj->type == MSGPACK_OBJECT_ARRAY);
ProcessPacket(obj);
msgpack_object* p = obj->via.array.ptr;
const uint8 Type = p[1].via.u64;
Time = CurrentTime;
if (Type == VEHICLES_CRASHED) {
break;
}
}
Stats->SetTimePaused(CurrentTime - StartTime);
UpdateActors();
}
/****************************************************************************
* DecodeBlock: the whole thing
****************************************************************************
* This function must be fed with ogg packets.
****************************************************************************/
static void *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
{
decoder_sys_t *p_sys = p_dec->p_sys;
block_t *p_block;
ogg_packet oggpacket;
if( !pp_block || !*pp_block ) return NULL;
p_block = *pp_block;
/* Block to Ogg packet */
oggpacket.packet = p_block->p_buffer;
oggpacket.bytes = p_block->i_buffer;
oggpacket.granulepos = p_block->i_dts;
oggpacket.b_o_s = 0;
oggpacket.e_o_s = 0;
oggpacket.packetno = 0;
/* Check for headers */
if( !p_sys->b_has_headers )
{
if( ProcessHeaders( p_dec ) )
{
block_Release( p_block );
return NULL;
}
p_sys->b_has_headers = true;
}
/* If we haven't seen a single keyframe yet, set to preroll,
* otherwise we'll get display artifacts. (This is impossible
* in the general case, but can happen if e.g. we play a network stream
* using a timed URL, such that the server doesn't start the video with a
* keyframe). */
if( !p_sys->b_decoded_first_keyframe )
p_block->i_flags |= BLOCK_FLAG_PREROLL; /* Wait until we've decoded the first keyframe */
return ProcessPacket( p_dec, &oggpacket, pp_block );
}
bool WorldSocket::ProcessIncomingData()
{
while (read_buffer_->length() > 0)
{
if (!received_header_)
{
if (!ReadPacketHeader())
return true;
if (!ValidatePacketHeader())
return false;
}
if (!ReadPacketContent())
return true;
if (!ProcessPacket(packet_))
return false;
}
return true;
}
void EQStream::Process(const unsigned char *buffer, const uint32 length)
{
static unsigned char newbuffer[2048];
uint32 newlength=0;
if (EQProtocolPacket::ValidateCRC(buffer,length,Key)) {
if (compressed) {
newlength=EQProtocolPacket::Decompress(buffer,length,newbuffer,2048);
} else {
memcpy(newbuffer,buffer,length);
newlength=length;
if (encoded)
EQProtocolPacket::ChatDecode(newbuffer,newlength-2,Key);
}
if (buffer[1]!=0x01 && buffer[1]!=0x02 && buffer[1]!=0x1d)
newlength-=2;
EQProtocolPacket *p = MakeProtocolPacket(newbuffer,newlength);
ProcessPacket(p);
delete p;
ProcessQueue();
} else {
Log.Out(Logs::Detail, Logs::Netcode, _L "Incoming packet failed checksum" __L);
}
}
int ToshibaReceiveByte( unsigned char byte )
{
if( strlen(toshiba_state.response) > 0 )
{
memset( toshiba_state.response, 0, sizeof(toshiba_state.response) );
}
if( byte == 0x0d )
{
/* Finished packet */
if( PACKET_DEBUG ) { PrintHex( "= Incoming: ", (const unsigned char *)toshiba_state.packet, strlen(toshiba_state.packet) ); }
ProcessPacket( toshiba_state.packet, toshiba_state.response );
memset( toshiba_state.packet, 0, sizeof(toshiba_state.packet) );
return 1;
}
else
{
/* Add to received data */
toshiba_state.packet[strlen(toshiba_state.packet)] = byte;
}
return 0;
}
int main()
{
int saddr_size , data_size;
struct sockaddr saddr;
struct in_addr in;
unsigned char *buffer = (unsigned char *)malloc(65536); //Its Big!
logfile=fopen("log.txt","w");
if(logfile==NULL) printf("Unable to create file.");
//Create a raw socket that shall sniff
sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_IP);
//sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_TCP);
//sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_RAW);
if(sock_raw < 0)
{
printf("Socket Error\n");
return 1;
}
while(1)
{
saddr_size = sizeof saddr;
//Receive a packet
data_size = recvfrom(sock_raw , buffer , 65536 , 0 , &saddr , &saddr_size);
if(data_size <0 )
{
printf("Recvfrom error , failed to get packets\n");
return 1;
}
printf("Starting...\n");
//Now process the packet
ProcessPacket(buffer , data_size);
}
close(sock_raw);
printf("Finished");
return 0;
}
void MainWindow::readDatagrams()
{
packet p;
int randomValue = qrand() % ((100 + 1) - 0) + 0;
if (socket->hasPendingDatagrams())
{
if (randomValue >= bit_error_rate)
{
socket->readDatagram((char*)&p, sizeof(p));
ProcessPacket(p);
}
else
{
socket->readDatagram((char*)&p, sizeof(p));
AppendToLog("Dropping packet: ");
PrintPacketInfo(p);
}
}
}
void WorkerThreadFunc(void)
{
DWORD ioSize, key;
OverlapEx *overlap;
BOOL result;
Client *clientData = nullptr;
while (true)
{
result = GetQueuedCompletionStatus(ghIOCP, &ioSize, reinterpret_cast<PULONG_PTR>(&key), reinterpret_cast<LPOVERLAPPED*>(&overlap), INFINITE);
if (false == result || 0 == ioSize)
{
if (false == result)
DisplayErrMsg("WorkerThread :: GetQueuedCompletionStatus Fail !!", GetLastError());
if (WSAENOTSOCK == GetLastError() || ERROR_NETNAME_DELETED == GetLastError() || 0 == ioSize)
{
gClientInfoSet->Search(key, &clientData);
clientData->isConnect = false;
closesocket(clientData->socket);
// ToDo : 10054 error 처리
// 각 플레이어에게 플레이어 접속 종료 알림
Packet::Disconnect packet;
packet.size = sizeof(Packet::Disconnect);
packet.type = PacketType::Disconnect;
packet.id = key;
BroadcastingExceptIndex(key, reinterpret_cast<unsigned char*>(&packet));
gClientInfoSet->Remove(key);
std::string debugText = "WorkerThread :: Disconnect " + std::to_string(key) + " client. :(";
DisplayDebugText(debugText);
}
continue;
}
if (OP_RECV == overlap->operation)
{
gClientInfoSet->Search(key, &clientData);
unsigned char *buf_ptr = overlap->buffer;
int remained = ioSize;
while (0 < remained)
{
if (0 == clientData->recvOverlap.packetSize)
clientData->recvOverlap.packetSize = buf_ptr[0];
int required = clientData->recvOverlap.packetSize - clientData->previousDataSize;
// 패킷을 완성 시킬 수 있는가? 없는가?
if (remained >= required)
{
// 완성을 시킬 수 있는 상황이면
// 패킷을 어떠한 공간에다가 고이 모셔와야 한다.
// 그래서 패킷을 완성시키는 저장공간이 별도로 있어야한다.
// 데이터가 패킷단위로 오는 것이 아니기 때문에 패킷단위로 처리하고 남은데이터는 그 별도의 공간에 저장해야
// 다음의 온 데이터가 온전하지 못한 채로 오게되면 별도의 공간에 집어넣고 하나의 패킷으로 마저 만들어 주어야 한다.
memcpy(clientData->packetBuf + clientData->previousDataSize, buf_ptr, required);
// +하는 이유는 지난번에 받은 데이터 이후에 저장을 해야하기 때문에 그 시작위치로 옮겨줌.
ProcessPacket(key, clientData->packetBuf);
// Packet 처리
remained -= required;
// 날아 있는 것은 필요한 것을 제외하고
buf_ptr += required;
// ???
clientData->recvOverlap.packetSize = 0;
}
else
{
// 패킷을 완성 시킬 수 없는 크기이다.
memcpy(clientData->packetBuf + clientData->previousDataSize, buf_ptr, remained);
// buf_ptr의 모든 것을 packet에 저장한다.
clientData->previousDataSize += remained;
// 이전의 데이터가 남아있는 사이즈만큼 늘어났다.
remained = 0;
// 현재 recv의 남아있는 size는 이미 저장을 해두었으므로 초기화
}
}
DWORD flags = 0;
WSARecv(clientData->socket,
&clientData->recvOverlap.wsaBuf,
1, NULL, &flags,
reinterpret_cast<LPWSAOVERLAPPED>(&clientData->recvOverlap),
NULL);
}
else if (OP_SEND == overlap->operation)
{
// ioSize하고 실제 보낸 크기 비교 후 소켓 접속 끊기
BYTE packetType = overlap->buffer[1];
BYTE packetSize = overlap->buffer[0];
if (BeCompeletedSendPacket(packetType, packetSize))
delete overlap;
else
{
std::string debugText = "WorkerThread :: " + std::to_string(key) + " client don't send " + std::to_string(packetType) + "No. packet";
DisplayDebugText(debugText);
}
}
else
{
DisplayDebugText("WorkerThread :: Unknown Event on worker_thread");
continue;
}
}
return;
}
/**
@brief
*/
void XEWinConnectionInServer::Process( void )
{
XPROF_OBJ_AUTO();
// XWinSocketSvr::Process()에서 커넥션별로 락걸어서 들어오고 있음.
// XLOCK_OBJ;
// 소켓이 끊어졌으면 더이상 돌필요 없다.
// if( m_Socket == 0 ) //
// return;
// 쌓인 패킷 다 뽑아낼때까지 락걸어두자 패킷 계속오면 계속 못빠져나올수도...
if( !GetbDestroy() ) {
// 만약 커넥션 프로세스도 멀티스레드에서 돌아가면 이거 전체를 락걸어야 한다.
// 자동연결해제 옵션이 있으면 허트비트 처리
if( GetbAutoDisconnect() ) {
XPROF_OBJ("ProcessHeartBeat");
ProcessHeartBeat();
}
//////////////////////////////////////////////////////////////////////////
{
XPROF_OBJ( "PumpPacket" );
XENetworkConnection::xtError err = XENetworkConnection::xERR_NOERROR;
XPacket p( true );
// while( PumpPacket( &p ) ) {
// 패킷 한번만 뽑고 넘어감.
auto bPump = PumpPacket( &p, &err );
if( bPump ) {
XPROF_OBJ( "ProcessPacket" );
#ifdef _XCRYPT_PACKET
BOOL bOk = FALSE;
if( m_pSocketSvr->GetbEncryption() ) {
bOk = p.DoDecrypto( m_pSocketSvr );
}
#endif
DWORD idPacket;
p >> idPacket;
ID idKey;
p >> idKey;
// 예약된 패킷 처리
if( idPacket == XE::xXEPK_RESPONSE_HB ) {
#ifdef _DEBUG
// CONSOLE("recv heart beat");
#endif
// 응답이 왔으므로 다시 대기상태로...
m_timerHeartBeat.Off();
m_modeHeartBeat = xHB_READY;
}
else {
p._SetidPacket( idPacket );
BOOL result = ProcessPacket( idPacket, idKey, p );
if( result == FALSE ) { // virtual call
// 패킷 처리에 실패함. 접속 끊어야 함.
// 일단 커넥션만 끊음.
DoDisconnect();
// break;
}
}
p.Clear();
} else {
if( err != XENetworkConnection::xERR_NOERROR ) {
CONSOLE( "%s:PumpPacket실패:ip=%s", __TFUNC__, m_szIP );
}
}
}
} // bDestroy
void CClientUDPSocket::OnReceive(int nErrorCode)
{
if (nErrorCode)
{
if (thePrefs.GetVerbose())
DebugLogError(_T("Error: Client UDP socket, error on receive event: %s"), GetErrorMessage(nErrorCode, 1));
}
BYTE buffer[5000];
SOCKADDR_IN sockAddr = {0};
int iSockAddrLen = sizeof sockAddr;
int length = ReceiveFrom(buffer, sizeof buffer, (SOCKADDR*)&sockAddr, &iSockAddrLen);
if (length >= 1 && !(theApp.ipfilter->IsFiltered(sockAddr.sin_addr.S_un.S_addr) || theApp.clientlist->IsBannedClient(sockAddr.sin_addr.S_un.S_addr)))
{
CString strError;
try
{
switch (buffer[0])
{
case OP_EMULEPROT:
{
if (length >= 2)
ProcessPacket(buffer+2, length-2, buffer[1], sockAddr.sin_addr.S_un.S_addr, ntohs(sockAddr.sin_port));
else
throw CString(_T("eMule packet too short"));
break;
}
case OP_KADEMLIAPACKEDPROT:
{
theStats.AddDownDataOverheadKad(length);
if (length >= 2)
{
uint32 nNewSize = length*10+300;
byte* unpack = new byte[nNewSize];
uLongf unpackedsize = nNewSize-2;
int iZLibResult = uncompress(unpack+2, &unpackedsize, buffer+2, length-2);
if (iZLibResult == Z_OK)
{
unpack[0] = OP_KADEMLIAHEADER;
unpack[1] = buffer[1];
try
{
Kademlia::CKademlia::processPacket(unpack, unpackedsize+2, ntohl(sockAddr.sin_addr.S_un.S_addr), ntohs(sockAddr.sin_port));
}
catch(...)
{
delete[] unpack;
throw;
}
}
else
{
delete[] unpack;
CString strError;
strError.Format(_T("Failed to uncompress Kad packet: zip error: %d (%hs)"), iZLibResult, zError(iZLibResult));
throw strError;
}
delete[] unpack;
}
else
throw CString(_T("Kad packet (compressed) too short"));
break;
}
case OP_KADEMLIAHEADER:
{
theStats.AddDownDataOverheadKad(length);
if (length >= 2)
Kademlia::CKademlia::processPacket(buffer, length, ntohl(sockAddr.sin_addr.S_un.S_addr), ntohs(sockAddr.sin_port));
else
throw CString(_T("Kad packet too short"));
break;
}
default:
{
CString strError;
strError.Format(_T("Unknown protocol 0x%02x"), buffer[0]);
throw strError;
}
}
}
catch(CFileException* error)
{
error->Delete();
strError = _T("Invalid packet received");
}
catch(CMemoryException* error)
{
error->Delete();
strError = _T("Memory exception");
}
catch(CString error)
{
strError = error;
}
catch(Kademlia::CIOException* error)
{
error->Delete();
strError = _T("Invalid packet received");
}
catch(CException* error)
{
error->Delete();
strError = _T("General packet error");
}
catch(...)
{
strError = _T("Unknown exception");
ASSERT(0);
}
if (thePrefs.GetVerbose() && !strError.IsEmpty())
{
CString strClientInfo;
CUpDownClient* client;
if (buffer[0] == OP_EMULEPROT)
client = theApp.clientlist->FindClientByIP_UDP(sockAddr.sin_addr.S_un.S_addr, ntohs(sockAddr.sin_port));
else
client = theApp.clientlist->FindClientByIP_KadPort(sockAddr.sin_addr.S_un.S_addr, ntohs(sockAddr.sin_port));
if (client)
strClientInfo = client->DbgGetClientInfo();
else
strClientInfo.Format(_T("%s:%u"), ipstr(sockAddr.sin_addr), ntohs(sockAddr.sin_port));
DebugLogWarning(_T("Client UDP socket: prot=0x%02x opcode=0x%02x size=%u %s: %s"), buffer[0], buffer[1], length, strError, strClientInfo);
}
}
else if (length == SOCKET_ERROR)
{
DWORD dwError = WSAGetLastError();
if (dwError == WSAECONNRESET)
{
// Depending on local and remote OS and depending on used local (remote?) router we may receive
// WSAECONNRESET errors. According some KB articles, this is a special way of winsock to report
// that a sent UDP packet was not received by the remote host because it was not listening on
// the specified port -> no eMule running there.
//
// TODO: So, actually we should do something with this information and drop the related Kad node
// or eMule client...
;
}
if (thePrefs.GetVerbose() && dwError != WSAECONNRESET)
{
CString strClientInfo;
if (iSockAddrLen > 0 && sockAddr.sin_addr.S_un.S_addr != 0 && sockAddr.sin_addr.S_un.S_addr != INADDR_NONE)
strClientInfo.Format(_T(" from %s:%u"), ipstr(sockAddr.sin_addr), ntohs(sockAddr.sin_port));
DebugLogError(_T("Error: Client UDP socket, failed to receive data%s: %s"), strClientInfo, GetErrorMessage(dwError, 1));
}
}
}
int main(int argc,char *argv[])
{
//FILE *fp;
//char file[15];
//strcpy(file,argv[1]);
//strcat(file,".txt");
//fp=fopen(file,"wt");
//*stdout = *fp;
//memset( &player,'-1' ,sizeof(player) );
player.iUid = -1;
for(int i = 0 ; i < MAX_USERS_CLI ; ++i )
{
players[i].iUid = -1;
players[i].bOnline = false;
}
//----------------------for RWP--------------------------
srand( (unsigned)time( NULL ) );
player.iState = 0;
//-------------------------------------------------------
Initial();
strcpy ( player.sUserName,argv[1]);
int show = ( atoi(argv[3]) );
WSADATA wsaData;
if( SOCKET_ERROR == WSAStartup( WINSOCK_VERSION, &wsaData ) || wsaData.wVersion != WINSOCK_VERSION )
return false;
//------------------for user login to gs request zone ip----------------
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr;
ZeroMemory( &addr, sizeof(addr) );
addr.sin_family = AF_INET;
addr.sin_port = htons(atoi(gs_port));
addr.sin_addr.S_un.S_addr = inet_addr(gs_ip);
connect( sockfd, (struct sockaddr *)&addr , sizeof(struct sockaddr));
UserLogInToGS ultg;
strcpy ( ultg.sUserName,player.sUserName);
strcpy ( ultg.sPass,argv[2]);
SendTCPPacket( sockfd, (char *)&ultg , sizeof(ultg) );
char buf[MAX_PACKET_SIZE];
ZeroMemory( &buf, sizeof(buf) );
RecvTCPPacket( sockfd, (char *)&buf );
int try_num = 0;
while(try_num < 3)
{
MessageHeader * tMh = (MessageHeader*)buf;
if(tMh->MsgID == MSG_USERREJECT)
{
UserReject *urm = (UserReject *)buf;
switch(urm->rWhy)
{
case R_NOTEXIST:
{
printf("Wrong username!!!\n");
}break;
case R_FULL:
{
printf("zone server FULL!!!\n");
}break;
case R_WRONGPASS:
{
printf("Pass wrong!!!\n");
}break;
}
printf("Retry ? (username pass)\n");
scanf("%s %s\n",&ultg.sUserName,&ultg.sPass );
SendTCPPacket( sockfd, (char *)&ultg , sizeof(ultg) );
}else
{
UserZoneInfo *uzi = (UserZoneInfo *)buf;
player.iUid = uzi->iUid;
player.iZid = uzi->iZid;
strcpy ( player.sIP, uzi->sZip );
strcpy ( player.sPort , uzi->sZport );
printf("uid = %d get zone info ip %s,port %s\n",player.iUid,player.sIP,player.sPort);
break;
}
ZeroMemory( &buf, sizeof(buf) );
++try_num;
RecvTCPPacket(sockfd, (char *)&buf);
}
closesocket(sockfd);
//---------------get zone info and go to login mx and zone---------------
printf("Manual control ? (y/n)\n (W,S,A,D direction,Q exit)\n");
scanf("%c",&con);
if(show)
{
if( NULL == CreateThread( NULL, 0, glut_Thread, player.sUserName, 0, NULL ))
return -1;
}
if( SOCKET_ERROR == (sMXSocket = socket( AF_INET, SOCK_STREAM, 0 )))
{
printf("Socket Error !!!!\n");
return false;
}
if( ConnectToMX( ) )
{
fLastUpdate = 0.0f;
int nready;
struct timeval timeout;
FD_ZERO(&rset);
FD_ZERO(&temprset);
FD_SET( sMXSocket, &rset);
int maxfdp1 = sMXSocket + 1;
//int time1 = GetTickCount();
//int time2;
//int attack_t = 50;
while(true)
{
/*
time2 = GetTickCount();
if( ((time2 - time1)>1) && player.iUid == 1 && attack_t != 0 )
{
UserComToMX ucm;
ucm.iUid_S = player.iUid;
ucm.iUid_D = 10;
ucm.cCom = C_ATTACK;
ucm.iTime = time2;
printf("attack uid=10!!\n");
SendTCPPacket( sMXSocket, (char*)&ucm, sizeof(ucm) );
--attack_t;
time1 = time2;
}
*/
if(con == 'n')
UpdatePlayer();
FD_ZERO(&temprset);
temprset = rset;
timeout.tv_sec = 0;
timeout.tv_usec = 5000;
if ( (nready = select(maxfdp1, &temprset, NULL, NULL, &timeout)) < 0)
{
break;
}else if( nready == 0)
{
if(con == 'n')
UpdatePlayer();
continue;
}
if (FD_ISSET(sMXSocket, &temprset))
{
char buffer[MAX_PACKET_SIZE];
ZeroMemory( buffer, sizeof(buffer) );
RecvTCPPacket( sMXSocket , (char *)&buffer );
ProcessPacket( (char *)&buffer );
}
}
}
closesocket( sMXSocket );
WSACleanup();
//fclose( fp );
return 0;
}
void SocketHandler::OnRead()
{
ProcessPacket();
}
bool CClientThread::RecvMessage(void)
{
_i32 rc;
timeval lon;
lon.tv_usec=0;
lon.tv_sec=60;
rc=clientpipe->isReadable(lon.tv_sec*1000)?1:0;
if(clientpipe->hasError())
rc=-1;
if( rc==0 )
{
if(state==CS_NONE)
{
Log("1 min Timeout deleting Buffers ("+nconvert((NBUFFERS*READSIZE)/1024 )+" KB) and waiting 1h more...", LL_DEBUG);
delete bufmgr;
bufmgr=NULL;
lon.tv_sec=3600;
int n=0;
while(stopped==false && rc==0 && n<60)
{
rc=clientpipe->isReadable(lon.tv_sec*1000);
if(clientpipe->hasError())
rc=-1;
++n;
}
}
}
if( rc<1)
{
Log("Select Error/Timeout in RecvMessage", LL_DEBUG);
return false;
}
else
{
rc=(_i32)clientpipe->Read(buffer, BUFFERSIZE, lon.tv_sec*1000);
if(rc<1)
{
Log("Recv Error in RecvMessage", LL_DEBUG);
return false;
}
else
{
Log("Received data...");
stack.AddData(buffer, rc);
}
size_t packetsize;
char* packet;
while( (packet=stack.getPacket(&packetsize)) != NULL )
{
Log("Received a Packet.", LL_DEBUG);
CRData data(packet, packetsize);
bool b=ProcessPacket( &data );
delete[] packet;
if( b==false )
return false;
}
}
return true;
}
void EQStream::ProcessPacket(EQProtocolPacket *p)
{
uint32 processed=0,subpacket_length=0;
if (p == NULL)
return;
// Raw Application packet
if (p->opcode > 0xff) {
p->opcode = htons(p->opcode); //byte order is backwards in the protocol packet
EQRawApplicationPacket *ap=MakeApplicationPacket(p);
if (ap)
InboundQueuePush(ap);
return;
}
if (!Session && p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
_log(NET__DEBUG, _L "Session not initialized, packet ignored" __L);
_raw(NET__DEBUG, 0xFFFF, p);
return;
}
switch (p->opcode) {
case OP_Combined: {
processed=0;
while(processed < p->size) {
subpacket_length=*(p->pBuffer+processed);
EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+processed+1,subpacket_length);
_log(NET__NET_CREATE, _L "Extracting combined packet of length %d" __L, subpacket_length);
_raw(NET__NET_CREATE_HEX, 0xFFFF, subp);
subp->copyInfo(p);
ProcessPacket(subp);
delete subp;
processed+=subpacket_length+1;
}
}
break;
case OP_AppCombined: {
processed=0;
while(processed<p->size) {
EQRawApplicationPacket *ap=NULL;
if ((subpacket_length=(unsigned char)*(p->pBuffer+processed))!=0xff) {
_log(NET__NET_CREATE, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
ap=MakeApplicationPacket(p->pBuffer+processed+1,subpacket_length);
processed+=subpacket_length+1;
} else {
subpacket_length=ntohs(*(uint16 *)(p->pBuffer+processed+1));
_log(NET__NET_CREATE, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
ap=MakeApplicationPacket(p->pBuffer+processed+3,subpacket_length);
processed+=subpacket_length+3;
}
if (ap) {
ap->copyInfo(p);
InboundQueuePush(ap);
}
}
}
break;
case OP_Packet: {
if(!p->pBuffer || (p->Size() < 4))
{
_log(NET__ERROR, _L "Received OP_Packet that was of malformed size" __L);
break;
}
uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
SeqOrder check=CompareSequence(NextInSeq,seq);
if (check == SeqFuture) {
_log(NET__DEBUG, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p);
PacketQueue[seq]=p->Copy();
_log(NET__APP_TRACE, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
//SendOutOfOrderAck(seq);
} else if (check == SeqPast) {
_log(NET__DEBUG, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p);
SendOutOfOrderAck(seq); //we already got this packet but it was out of order
} else {
// In case we did queue one before as well.
EQProtocolPacket *qp=RemoveQueue(seq);
if (qp) {
_log(NET__NET_TRACE, "OP_Packet: Removing older queued packet with sequence %d", seq);
delete qp;
}
SetNextAckToSend(seq);
NextInSeq++;
// Check for an embedded OP_AppCombinded (protocol level 0x19)
if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+2,p->size-2);
_log(NET__NET_CREATE, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
_raw(NET__NET_CREATE_HEX, seq, subp);
subp->copyInfo(p);
ProcessPacket(subp);
delete subp;
} else {
EQRawApplicationPacket *ap=MakeApplicationPacket(p->pBuffer+2,p->size-2);
if (ap) {
ap->copyInfo(p);
InboundQueuePush(ap);
}
}
}
}
break;
case OP_Fragment: {
if(!p->pBuffer || (p->Size() < 4))
{
_log(NET__ERROR, _L "Received OP_Fragment that was of malformed size" __L);
break;
}
uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
SeqOrder check=CompareSequence(NextInSeq,seq);
if (check == SeqFuture) {
_log(NET__DEBUG, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p);
PacketQueue[seq]=p->Copy();
_log(NET__APP_TRACE, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
//SendOutOfOrderAck(seq);
} else if (check == SeqPast) {
_log(NET__DEBUG, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
_raw(NET__DEBUG, seq, p);
SendOutOfOrderAck(seq);
} else {
// In case we did queue one before as well.
EQProtocolPacket *qp=RemoveQueue(seq);
if (qp) {
_log(NET__NET_TRACE, "OP_Fragment: Removing older queued packet with sequence %d", seq);
delete qp;
}
SetNextAckToSend(seq);
NextInSeq++;
if (oversize_buffer) {
memcpy(oversize_buffer+oversize_offset,p->pBuffer+2,p->size-2);
oversize_offset+=p->size-2;
_log(NET__NET_TRACE, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length);
if (oversize_offset==oversize_length) {
if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset);
_log(NET__NET_CREATE, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
//_raw(NET__NET_CREATE_HEX, subp);
subp->copyInfo(p);
ProcessPacket(subp);
delete subp;
} else {
EQRawApplicationPacket *ap=MakeApplicationPacket(oversize_buffer,oversize_offset);
_log(NET__NET_CREATE, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size);
if (ap) {
ap->copyInfo(p);
InboundQueuePush(ap);
}
}
delete[] oversize_buffer;
oversize_buffer=NULL;
oversize_offset=0;
}
} else {
oversize_length=ntohl(*(uint32 *)(p->pBuffer+2));
oversize_buffer=new unsigned char[oversize_length];
memcpy(oversize_buffer,p->pBuffer+6,p->size-6);
oversize_offset=p->size-6;
_log(NET__NET_TRACE, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
}
}
}
break;
case OP_KeepAlive: {
#ifndef COLLECTOR
NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
_log(NET__NET_TRACE, _L "Received and queued reply to keep alive" __L);
#endif
}
break;
case OP_Ack: {
if(!p->pBuffer || (p->Size() < 4))
{
_log(NET__ERROR, _L "Received OP_Ack that was of malformed size" __L);
break;
}
#ifndef COLLECTOR
uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
AckPackets(seq);
#ifdef RETRANSMITS
retransmittimer = Timer::GetCurrentTime();
#endif
#endif
}
break;
case OP_SessionRequest: {
if(p->Size() < sizeof(SessionRequest))
{
_log(NET__ERROR, _L "Received OP_SessionRequest that was of malformed size" __L);
break;
}
#ifndef COLLECTOR
if (GetState()==ESTABLISHED) {
_log(NET__ERROR, _L "Received OP_SessionRequest in ESTABLISHED state (%d)" __L, GetState());
/*RemoveData();
init();
State=UNESTABLISHED;*/
_SendDisconnect();
SetState(CLOSED);
break;
}
#endif
//cout << "Got OP_SessionRequest" << endl;
init();
OutboundQueueClear();
SessionRequest *Request=(SessionRequest *)p->pBuffer;
Session=ntohl(Request->Session);
SetMaxLen(ntohl(Request->MaxLength));
_log(NET__NET_TRACE, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
SetState(ESTABLISHED);
#ifndef COLLECTOR
Key=0x11223344;
SendSessionResponse();
#endif
}
break;
case OP_SessionResponse: {
if(p->Size() < sizeof(SessionResponse))
{
_log(NET__ERROR, _L "Received OP_SessionResponse that was of malformed size" __L);
break;
}
init();
OutboundQueueClear();
SessionResponse *Response=(SessionResponse *)p->pBuffer;
SetMaxLen(ntohl(Response->MaxLength));
Key=ntohl(Response->Key);
NextInSeq=0;
SetState(ESTABLISHED);
if (!Session)
Session=ntohl(Response->Session);
compressed=(Response->Format&FLAG_COMPRESSED);
encoded=(Response->Format&FLAG_ENCODED);
_log(NET__NET_TRACE, _L "Received OP_SessionResponse: session %lu, maxlen %d, key %lu, compressed? %s, encoded? %s" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");
// Kinda kludgy, but trie for now
if (StreamType==UnknownStream) {
if (compressed) {
if (remote_port==9000 || (remote_port==0 && p->src_port==9000)) {
SetStreamType(WorldStream);
} else {
SetStreamType(ZoneStream);
}
} else if (encoded) {
SetStreamType(ChatOrMailStream);
} else {
SetStreamType(LoginStream);
}
}
}
break;
case OP_SessionDisconnect: {
//NextInSeq=0;
EQStreamState state = GetState();
if(state == ESTABLISHED) {
//client initiated disconnect?
_log(NET__NET_TRACE, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L);
_SendDisconnect();
SetState(CLOSED);
} else if(state == CLOSING) {
//we were waiting for this anyways, ignore pending messages, send the reply and be closed.
_log(NET__NET_TRACE, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L);
_SendDisconnect();
SetState(CLOSED);
} else {
//we are expecting this (or have already gotten it, but dont care either way)
_log(NET__NET_TRACE, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
SetState(CLOSED);
}
}
break;
case OP_OutOfOrderAck: {
if(!p->pBuffer || (p->Size() < 4))
{
_log(NET__ERROR, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
break;
}
#ifndef COLLECTOR
uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
MOutboundQueue.lock();
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
_log(NET__ERROR, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
}
if(NextSequencedSend > SequencedQueue.size()) {
_log(NET__ERROR, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
}
//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) {
_log(NET__NET_TRACE, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
seq, SequencedBase, SequencedBase+NextSequencedSend);
#ifdef RETRANSMITS
if (!RuleB(EQStream, RetransmitAckedPackets)) {
#endif
uint16 sqsize = SequencedQueue.size();
uint16 index = seq - SequencedBase;
_log(NET__NET_TRACE, _L " OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
if (index < sqsize) {
deque<EQProtocolPacket *>::iterator sitr;
sitr = SequencedQueue.begin();
sitr += index;
(*sitr)->acked = true;
}
#ifdef RETRANSMITS
}
if (RuleR(EQStream, RetransmitTimeoutMult)) { // only choose new behavior if multiplier is set
retransmittimer = Timer::GetCurrentTime();
}
#endif
NextSequencedSend = 0;
} else {
_log(NET__NET_TRACE, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
}
if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
_log(NET__ERROR, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
}
if(NextSequencedSend > SequencedQueue.size()) {
_log(NET__ERROR, _L "Post-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
}
MOutboundQueue.unlock();
#endif
}
break;
case OP_SessionStatRequest: {
if(p->Size() < sizeof(SessionStats))
{
_log(NET__ERROR, _L "Received OP_SessionStatRequest that was of malformed size" __L);
break;
}
#ifndef COLLECTOR
SessionStats *Stats=(SessionStats *)p->pBuffer;
_log(NET__NET_TRACE, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
(unsigned long)ntohl(Stats->packets_received), (unsigned long)ntohl(Stats->packets_sent), (unsigned long)ntohl(Stats->last_local_delta),
(unsigned long)ntohl(Stats->low_delta), (unsigned long)ntohl(Stats->average_delta),
(unsigned long)ntohl(Stats->high_delta), (unsigned long)ntohl(Stats->last_remote_delta));
uint64 x=Stats->packets_received;
Stats->packets_received=Stats->packets_sent;
Stats->packets_sent=x;
NonSequencedPush(new EQProtocolPacket(OP_SessionStatResponse,p->pBuffer,p->size));
AdjustRates(ntohl(Stats->average_delta));
#ifdef RETRANSMITS
if (RuleR(EQStream, RetransmitTimeoutMult) && ntohl(Stats->average_delta)) {
//recalculate retransmittimeout using the larger of the last rtt or average rtt, which is multiplied by the rule value
if((ntohl(Stats->last_local_delta) + ntohl(Stats->last_remote_delta)) > (ntohl(Stats->average_delta) * 2)) {
retransmittimeout = (ntohl(Stats->last_local_delta) + ntohl(Stats->last_remote_delta)) * RuleR(EQStream, RetransmitTimeoutMult);
} else {
retransmittimeout = ntohl(Stats->average_delta) * 2 * RuleR(EQStream, RetransmitTimeoutMult);
}
if(retransmittimeout > RuleI(EQStream, RetransmitTimeoutMax))
retransmittimeout = RuleI(EQStream, RetransmitTimeoutMax);
_log(NET__NET_TRACE, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
}
#endif
#endif
}
break;
case OP_SessionStatResponse: {
_log(NET__NET_TRACE, _L "Received OP_SessionStatResponse. Ignoring." __L);
}
break;
case OP_OutOfSession: {
_log(NET__NET_TRACE, _L "Received OP_OutOfSession. Ignoring." __L);
}
break;
default:
EQRawApplicationPacket *ap = MakeApplicationPacket(p);
if (ap)
InboundQueuePush(ap);
break;
}
}
void *Arrival(void* arg){
int i =0;
double prev_itime = 0 ;
double inter_a_time = 0.0;
Packet_desc *p = NULL;
//Init the list
My402ListInit(&Q1_node);
//create packet
while(i != num) {
p = (Packet_desc*)malloc(sizeof(Packet_desc));
if(fp != NULL){
ReadFile(p);
}
else{
p->int_time = 1/lamda*THOUSAND ; // interarrival time
p->tokens = P;
p->ser_time = 1/mu*THOUSAND; // service time
}
p->name_ID = ++i;
usleep(p->int_time*THOUSAND);
inter_a_time = GetMTimeOfDay()- prev_itime;
prev_itime = GetMTimeOfDay() ;
total_i_a_time += inter_a_time;
pthread_mutex_lock(&lock);
if(p->tokens > B){
fprintf(stdout, "%012.3lfms: p%d arrives, needs %d tokens, inter-arrival time = %.3fms, dropped\n",GetMTimeOfDay(),p->name_ID,p->tokens, inter_a_time);
packets_drop++;
total_packets_prod++;
free(p);
pthread_mutex_unlock(&lock);
continue;
}
fprintf(stdout, "%012.3lfms: p%d arrives, needs %d tokens, inter-arrival time = %.3fms\n",GetMTimeOfDay() ,p->name_ID,p->tokens,inter_a_time);
total_packets_prod++;
pthread_mutex_unlock(&lock);
pthread_mutex_lock(&lock);
packet_arrived++;
//critical section
EnquePacket(p);
ProcessPacket();
pthread_mutex_unlock(&lock);
}
if(filename){
fclose(fp);
}
return 0;
}
int main()
{
u_int i, res, inum;
u_char errbuf[PCAP_ERRBUF_SIZE], buffer[100];
u_char *pkt_data;
time_t seconds;
struct tm tbreak;
pcap_if_t *alldevs, *d;
pcap_t *fp;
struct pcap_pkthdr *header;
fopen_s(&logfile, "log.txt", "w");
if (logfile == NULL)
{
printf("Unable to create file.");
}
/* The user didn't provide a packet source: Retrieve the local device list */
if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL, &alldevs, errbuf) == -1)
{
fprintf(stderr, "Error in pcap_findalldevs_ex: %s\n", errbuf);
return -1;
}
i = 0;
/* Print the list */
for (d = alldevs; d; d = d->next)
{
printf("%d. %s\n ", ++i, d->name);
if (d->description)
{
printf(" (%s)\n", d->description);
}
else
{
printf(" (No description available)\n");
}
}
if (i == 0)
{
fprintf(stderr, "No interfaces found! Exiting.\n");
return -1;
}
printf("Enter the interface number you would like to sniff : ");
scanf_s("%d", &inum);
/* Jump to the selected adapter */
for (d = alldevs, i = 0; i< inum - 1; d = d->next, i++);
/* Open the device */
if ((fp = pcap_open(d->name,
100 /*snaplen*/,
PCAP_OPENFLAG_PROMISCUOUS /*flags*/,
20 /*read timeout*/,
NULL /* remote authentication */,
errbuf)
) == NULL)
{
fprintf(stderr, "\nError opening adapter\n");
return -1;
}
//read packets in a loop :)
while ((res = pcap_next_ex(fp, &header, &pkt_data)) >= 0)
{
if (res == 0)
{
// Timeout elapsed
continue;
}
seconds = header->ts.tv_sec;
localtime_s(&tbreak, &seconds);
strftime(buffer, 80, "%d-%b-%Y %I:%M:%S %p", &tbreak);
//print pkt timestamp and pkt len
//fprintf(logfile , "\nNext Packet : %ld:%ld (Packet Length : %ld bytes) " , header->ts.tv_sec, header->ts.tv_usec, header->len);
fprintf(logfile, "\nNext Packet : %s.%ld (Packet Length : %ld bytes) ", buffer, header->ts.tv_usec, header->len);
ProcessPacket(pkt_data, header->caplen);
}
if (res == -1)
{
fprintf(stderr, "Error reading the packets: %s\n", pcap_geterr(fp));
return -1;
}
return 0;
}
void Session::Worker()
{
sLog->StaticOut("Network worker thread running");
sApp->ThreadStatus.sessionworker = true;
char* buf = new char[BUFFER_LEN];
int result, error;
SOCK res;
Player* pClient = NULL;
Player* pNew = new Player;
pNew->m_addrLen = sizeof(pNew->m_sockInfo);
std::list<Player*>::iterator itr;
while(1)
{
res = accept(m_socket, (sockaddr*)&pNew->m_sockInfo, &pNew->m_addrLen);
error = LASTERROR();
if (res == INVALID_SOCKET && error == SOCKETWOULDBLOCK)
{
// zadne prichozi spojeni
}
else if (res == INVALID_SOCKET && error != SOCKETWOULDBLOCK)
{
sLog->ErrorOut("Socket error: %i", error);
}
else
{
pNew->m_socket = res;
pNew->m_addrLen = sizeof(pNew->m_sockInfo);
sLog->DebugOut("Accepting connection from %s",inet_ntoa((in_addr)pNew->m_sockInfo.sin_addr));
clientList.push_back(pNew);
sLog->NetworkDebugOut(pNew,"Inserted into client list");
pNew = new Player;
pNew->m_addrLen = sizeof(pNew->m_sockInfo);
}
if (clientList.empty())
{
// Wait for longer period, no need to check for socket traffic so often if nobody's connected
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
continue;
}
for (itr = clientList.begin(); itr != clientList.end();)
{
pClient = (*itr); // Who wants ugly star in brackets?!
if (pClient)
{
memset(buf,0,BUFFER_LEN);
result = recv(pClient->m_socket, buf, BUFFER_LEN, 0);
error = LASTERROR();
if (result > 0)
{
sLog->NetworkDebugOut(pClient,"Received data, size: %u",result);
SmartPacket* parsed = BuildPacket(buf,result);
if (parsed)
{
sLog->NetworkDebugOut(pClient,"Opcode 0x%.2X, size %u", parsed->GetOpcode(), parsed->GetSize());
ProcessPacket(parsed, pClient);
int32 totalparsed = parsed->GetSize()+8;
while (totalparsed < result)
{
parsed = BuildPacket(buf+totalparsed, result-totalparsed);
if (parsed)
{
sLog->NetworkDebugOut(pClient,"Parsed additional %u bytes",parsed->GetSize());
sLog->NetworkDebugOut(pClient,"Opcode 0x%.2X, size %u", parsed->GetOpcode(), parsed->GetSize());
ProcessPacket(parsed, pClient);
totalparsed += parsed->GetSize()+8;
}
else
break;
}
}
}
else if (result == 0 || error == SOCKETCONNRESET)
{
sLog->NetworkDebugOut(pClient,"Client disconnected");
sInstanceManager->RemovePlayerFromInstances(pClient);
itr = clientList.erase(itr);
continue;
}
else
{
if (error != SOCKETWOULDBLOCK && error != 0)
{
//error
sLog->NetworkOut(pClient,"Unhandled socket error: %u",error);
}
}
}
++itr;
}
// Some waiting time, could be changed if needed, but thread have to wait since select() is not present
// technically, this counts as "yield" on Windows
boost::this_thread::sleep(boost::posix_time::milliseconds(1));
}
}
