template<class T, USHORT default_port> BOOL CHttpAgentT<T, default_port>::SendRequest(CONNID dwConnID, LPCSTR lpszMethod, LPCSTR lpszPath, const THeader lpHeaders[], int iHeaderCount, const BYTE* pBody, int iLength)
{
THttpObj* pHttpObj = FindHttpObj(dwConnID);
if(pHttpObj == nullptr)
{
::SetLastError(ERROR_OBJECT_NOT_FOUND);
return FALSE;
}
WSABUF szBuffer[2];
CStringA strHeader;
LPCSTR lpszHost = nullptr;
USHORT usPort = 0;
BOOL bConnect = (_stricmp(lpszMethod, HTTP_METHOD_CONNECT) == 0);
if(!bConnect)
{
GetRemoteHost(dwConnID, &lpszHost, &usPort);
if(usPort == default_port) usPort = 0;
}
CStringA strPath;
::AdjustRequestPath(bConnect, lpszPath, strPath);
pHttpObj->SetRequestPath(lpszMethod, strPath);
pHttpObj->ReloadCookies();
::MakeRequestLine(lpszMethod, strPath, m_enLocalVersion, strHeader);
::MakeHeaderLines(lpHeaders, iHeaderCount, &pHttpObj->GetCookieMap(), iLength, TRUE, -1, lpszHost, usPort, strHeader);
::MakeHttpPacket(strHeader, pBody, iLength, szBuffer);
return SendPackets(dwConnID, szBuffer, 2);
}
void AutomaticTest(int NumBuffers)
{
m_AutoamticTest = true;
m_IncomingBuffersAccumulator.Advise(this);
m_IncomingBuffersAccumulator.Clear();
for (int i = 0; i < NumBuffers; ++i)
{
GenerateTestBuffer();
SendPackets();
}
while(!m_TestMap.empty())
SendPackets();
Assert(m_IncomingBuffersAccumulator.IsEmpty());
m_IncomingBuffersAccumulator.Clear();
}
template<class T, USHORT default_port> BOOL CHttpAgentT<T, default_port>::SendWSMessage(CONNID dwConnID, BOOL bFinal, BYTE iReserved, BYTE iOperationCode, const BYTE lpszMask[4], BYTE* pData, int iLength, ULONGLONG ullBodyLen)
{
WSABUF szBuffer[2];
BYTE szHeader[HTTP_MAX_WS_HEADER_LEN];
if(!::MakeWSPacket(bFinal, iReserved, iOperationCode, lpszMask, pData, iLength, ullBodyLen, szHeader, szBuffer))
return FALSE;
return SendPackets(dwConnID, szBuffer, 2);
}
BOOL CTcpClient::Send(const BYTE* pBuffer, int iLength, int iOffset)
{
ASSERT(pBuffer && iLength > 0);
if(iOffset != 0) pBuffer += iOffset;
WSABUF buffer;
buffer.len = iLength;
buffer.buf = (char*)pBuffer;
return SendPackets(&buffer, 1);
}
BOOL CTcpServer::Send(CONNID dwConnID, const BYTE* pBuffer, int iLength, int iOffset)
{
ASSERT(pBuffer && iLength > 0);
if(iOffset != 0) pBuffer += iOffset;
WSABUF buffer;
buffer.len = iLength;
buffer.buf = (char*)pBuffer;
return SendPackets(dwConnID, &buffer, 1);
}
void
CAR6KMini::car6k_sendEapolKeyMsg (A_UINT8 descType,
A_BOOL secure, A_BOOL mic, A_BOOL ack, A_BOOL tx,
A_UINT32 index, A_UINT8 isPW,
A_BOOL doEncrypt,
A_UINT64 keyRSC,
const A_UINT8 nonce[],
const A_UINT32 keyLength,
A_UINT32 keyDataLen,
const A_UINT8 *keyData,
const A_UINT32 keyBufferLength,
A_UINT8 *bssid)
{
STATION *station;
station = GetStation(bssid,0);
NDIS_STATUS Status;
PNDIS_PACKET pPacket;
PNDIS_BUFFER pBuffer;
A_UINT32 *magic;
A_UINT16 length;
memset (m_wpa_buffer, 0 , sizeof (m_wpa_buffer));
crypto_sendEapolKeyMsg ( descType,secure, mic, ack, tx,
index, isPW,doEncrypt,keyRSC,
nonce,keyLength,keyDataLen,
keyData, keyBufferLength,
bssid,m_CurrentAddress,m_keyCounter,&replayCtr,
station,m_wpa_buffer,&length);
NdisAllocatePacket (&Status, &pPacket, m_TxPacketPool);
magic = (UINT32 *) pPacket->ProtocolReserved;
if (NDIS_STATUS_SUCCESS != Status)
{
NDIS_DEBUG_PRINTF (ATH_LOG_ERR, "AR6K: ERROR - NdisAllocatePacket failed\n");
return;
}
NdisAllocateBuffer (&Status, &pBuffer, m_TxBufferPool, m_wpa_buffer, length);
if (NDIS_STATUS_SUCCESS != Status)
{
NdisFreePacket (pPacket);
NDIS_DEBUG_PRINTF (ATH_LOG_ERR, "AR6K: ERROR - NdisAllocateBuffer failed\n");
return;
}
pBuffer->Next = NULL;
NdisChainBufferAtFront (pPacket,pBuffer);
*(magic) = TAG_WPA_SEND_PCK;
SendPackets (&pPacket,1);
return;
}
void Client::Logic()
{
clock_t time = clock();
clock_t actime = time;
SOCKET bsock;
SocketBase bcomm;
sockaddr_in &bsin = bcomm.Connect( PORT_BROADCAST );
bsock = bcomm.CreateSocket();
bcomm.Bind();
bcomm.SetBroadcast( true );
int keysize = int( key.size() + 1 );
int portsize = sizeof port;
char *message = new char[ keysize + portsize ];
//memcpy( message, this.key.c_str(), keysize );
//memcpy( message + keysize, &this.port, portsize );
while ( running )
{
LONGLONG flowend = Clock() - flowstart;
if ( flowend > 1000000LL )
{
flowstart = Clock();
currentdatasent = 0;
float l = GetRTT();
if ( l < 0.0001f )
BandWidth += 512;
else if ( l > 0.001f )
BandWidth -= 512;
}
if ( !ServerFound )
{
FindServer( bsock, message, portsize, keysize );
}
SendPackets();
ReceivePackets();
HandlePackets();
UpdateRTT();
Sleep( 10 );
}
}
BOOL CTcpServer::SendSmallFile(CONNID dwConnID, LPCTSTR lpszFileName, const LPWSABUF pHead, const LPWSABUF pTail)
{
CAtlFile file;
CAtlFileMapping<> fmap;
WSABUF szBuf[3];
HRESULT hr = ::MakeSmallFilePackage(lpszFileName, file, fmap, szBuf, pHead, pTail);
if(FAILED(hr))
{
::SetLastError(HRESULT_CODE(hr));
return FALSE;
}
return SendPackets(dwConnID, szBuf, 3);
}
void G2Node::OnPacketSent(const bs::error_code& err)
{
if(closed_) return;
if(!err)
{
packetBuf_.clear();
dispatchQueue_.pop();
if(!dispatchQueue_.empty()) SendPackets();
}
else if(err != ba::error::operation_aborted)
{
System::LogDev() << "G2Node::OnPacketSent " << myInfo_.endpoint.ToString() << " " << err.message() << std::endl;
DetachMe();
}
}
void CBaseServer::PostFrame()
{
//SV_CheckVars();
// Send messages back to the clients that had packets read this frame
SendPackets();
// save the entire world state if recording a serverdemo
//SV_RecordDemoMessage();
// send a heartbeat to the master if needed
//Master_Heartbeat();
// clear teleport flags, etc for next frame
//SV_PrepWorldFrame();
};
BOOL CTcpClient::SendSmallFile(LPCTSTR lpszFileName, const LPWSABUF pHead, const LPWSABUF pTail)
{
CFile file;
CFileMapping fmap;
WSABUF szBuf[3];
HRESULT hr = ::MakeSmallFilePackage(lpszFileName, file, fmap, szBuf, pHead, pTail);
if(FAILED(hr))
{
::SetLastError(hr);
return FALSE;
}
return SendPackets(szBuf, 3);
}
BOOL CTcpAgent::SendSmallFile(CONNID dwConnID, LPCTSTR lpszFileName, const LPWSABUF pHead, const LPWSABUF pTail)
{
ASSERT(lpszFileName != nullptr);
CAtlFile file;
HRESULT hr = file.Create(lpszFileName, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING);
if(SUCCEEDED(hr))
{
ULONGLONG ullLen;
hr = file.GetSize(ullLen);
if(SUCCEEDED(hr))
{
ULONGLONG ullTotal = ullLen + (pHead ? pHead->len : 0) + (pTail ? pTail->len : 0);
if(ullLen > 0 && ullTotal <= MAX_SMALL_FILE_SIZE)
{
CAtlFileMapping<> fmap;
hr = fmap.MapFile(file);
if(SUCCEEDED(hr))
{
WSABUF bufs[3] = {0};
bufs[1].len = (ULONG)ullLen;
bufs[1].buf = fmap;
if(pHead) memcpy(&bufs[0], pHead, sizeof(WSABUF));
if(pTail) memcpy(&bufs[2], pTail, sizeof(WSABUF));
return SendPackets(dwConnID, bufs, 3);
}
}
else if(ullLen == 0)
hr = HRESULT_FROM_WIN32(ERROR_FILE_INVALID);
else
hr = HRESULT_FROM_WIN32(ERROR_FILE_TOO_LARGE);
}
}
::SetLastError(hr & 0x0000FFFF);
return FALSE;
}
QTSS_Error QTSSRTPFileModuleDispatch(QTSS_Role inRole, QTSS_RoleParamPtr inParamBlock)
{
switch (inRole)
{
case QTSS_Register_Role:
return Register(&inParamBlock->regParams);
case QTSS_Initialize_Role:
return Initialize(&inParamBlock->initParams);
case QTSS_RereadPrefs_Role:
return RereadPrefs();
case QTSS_RTSPPreProcessor_Role:
return ProcessRTSPRequest(&inParamBlock->rtspPreProcessorParams);
case QTSS_RTPSendPackets_Role:
return SendPackets(&inParamBlock->rtpSendPacketsParams);
case QTSS_ClientSessionClosing_Role:
return DestroySession(&inParamBlock->clientSessionClosingParams);
}
return QTSS_NoErr;
}
void CServer::Run ()
{
while (m_bRun)
{
if (static_cast<int> (m_vpClients.size ()) > 1)
{
ReceivePackets ();
if (m_Clock.getElapsedTime () >= sf::milliseconds (1000 / m_uiTickRate))
{
SendPackets ();
m_Clock.restart ();
}
}
else
ListenOnIncomingConnections ();
if (sf::Keyboard::isKeyPressed (sf::Keyboard::Escape))
m_bRun = false;
sf::sleep (sf::milliseconds (1));
}
}
void G2Node::Send(const G2::Packet& packet)
{
dispatchQueue_.push(packet);
if(packetBuf_.empty())
SendPackets();
}
// This is the main entry point in to the control code
// and will be run in it's own thread
void *ControlRun(void *pParam){
struct sockaddr_in FromAddr;
socklen_t SockaddrLen;
struct timeval NowTime;
BYTE PacketBuffer[max(sizeof(MASTERPACKET), sizeof(CLIENTPACKET)) + 2];
int PacketSize, i, j;
//pthread_t idWriteStatsFileThread;
// Clear stats
memset(&ClientStats, 0, sizeof(ClientStats));
// Open UDP connection to server
memset(&MasterAddr, 0, sizeof(MasterAddr));
MasterAddr.sin_family = AF_INET;
MasterAddr.sin_addr.s_addr = inet_addr(Config.MasterIp);
MasterAddr.sin_port = htons(Config.MasterPort);
hControlPort = socket(PF_INET, SOCK_DGRAM, 0);
if(hControlPort < 0){
Log(LOG_ERR, "Failed to open client socket");
return NULL;
}
// Bind it to a local port
memset(&LocalAddr, 0, sizeof(LocalAddr));
LocalAddr.sin_family = AF_INET;
LocalAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
LocalAddr.sin_port = htons(0);
if(bind(hControlPort, (struct sockaddr *)&LocalAddr, sizeof(LocalAddr)) != 0){
close(hControlPort);
Log(LOG_ERR, "Failed to bind to client port");
return NULL;
}
// Get initial wireless data
GetWirelessState();
// Store intial background processing time
gettimeofday(&LastCtrlBackgroundTime, NULL);
LastCtrlBackgroundTime.tv_sec -= 8;
// Set the initial status
ClientStatus = CS_REGISTER;
// Send register packet
SendRegisterPacket();
// Set an initial last Rx time
gettimeofday(&LastRxActivityTime, NULL);
// Setup cleanup function (closes the port)
pthread_cleanup_push((void*)ControlCleanup, NULL);
// While we should run (helps exit a thread cleanly)
while(!ExitControlThread){
struct timeval Timeout;
fd_set readfds;
int SelRet;
FD_ZERO(&readfds);
FD_SET(hControlPort, &readfds);
// Wait 2 sec for UDP data
Timeout.tv_sec = 2;
Timeout.tv_usec = 0;
SelRet = select(hControlPort+1, &readfds, NULL, NULL, &Timeout);
// Error in select
if(SelRet < 0){
// Select error
Log(LOG_ERR, "Error waiting for master packet");
}
// Data pending
else if(SelRet > 0){
// Get packet from master
SockaddrLen = sizeof(FromAddr);
PacketSize = recvfrom(hControlPort, PacketBuffer, sizeof(PacketBuffer), 0, (struct sockaddr *)&FromAddr, &SockaddrLen);
// Check packet size
if(PacketSize != sizeof(MASTERPACKET) + 2){
// Wrong sized packet
Log(LOG_ERR, "Client got packet of incorrect size");
}
else{
// Check the checksum
for(i = 0, j = 0; i < sizeof(MASTERPACKET); i++){
j <<= 8;
j += PacketBuffer[i];
}
if(PacketBuffer[i] != (USHORT)j){
// Corrupted packet
Log(LOG_ERR, "Client got corrupted packet");
}
else{
int Packets, Bytes, Queue, k;
if(ClientStatus != CS_CONNECTED)
Log(LOG_INFO, "Client registered");
// Update the status and last activity time
ClientStatus = CS_CONNECTED;
gettimeofday(&LastRxActivityTime, NULL);
// Incriment poll count
ClientStats.Polls++;
// Send Packets up to allowed amount
SendPackets(((MASTERPACKET*)PacketBuffer)->MaxPacketsToSend, ((MASTERPACKET*)PacketBuffer)->MaxBytesToSend);
// Wait for access to the packet queue
pthread_mutex_lock(&PacketQueueMutex);
// Work out packets/bytes left in queues
Packets = 0;
Bytes = 0;
for(Queue = 0; Queue < PacketQueues; Queue++){
k = PacketQueueTail[Queue];
while(PacketQueueHead[Queue] != k){
Packets++;
Bytes += ((ipq_packet_msg_t *)&PacketQueue[Queue][k * sizeof(struct ipq_packet_msg)])->data_len;
k++;
if(k >= Config.Queue)
k = 0;
}
}
// Release access to the packet queue
pthread_mutex_unlock(&PacketQueueMutex);
// Send 'done' packet
memset(PacketBuffer, 0, sizeof(PacketBuffer));
((CLIENTPACKET*)PacketBuffer)->TypeId = CLIENTID_END;
((CLIENTPACKET*)PacketBuffer)->Rate = CurrentRate;
((CLIENTPACKET*)PacketBuffer)->Signal = CurrentSignal;
((CLIENTPACKET*)PacketBuffer)->Noise = CurrentNoise;
((CLIENTPACKET*)PacketBuffer)->PacketsInQueue = Packets;
((CLIENTPACKET*)PacketBuffer)->BytesInQueue = Bytes;
for(i = 0, j = 0; i < sizeof(CLIENTPACKET); i++){
j <<= 8;
j += PacketBuffer[i];
}
PacketBuffer[i] = (USHORT)j;
sendto(hControlPort, &PacketBuffer, sizeof(CLIENTPACKET)+2, 0, (struct sockaddr *)&MasterAddr, sizeof(MasterAddr));
// Update the last activity time
gettimeofday(&LastTxActivityTime, NULL);
}
}
}
// Do background processing here, this should run at least every 2 sec
// Get current time
gettimeofday(&NowTime, NULL);
// If no Tx or Rx recently
if(NowTime.tv_sec > LastRxActivityTime.tv_sec + SERVERREREGISTER &&
NowTime.tv_sec > LastTxActivityTime.tv_sec + SERVERREREGISTER){
// Reregister
SendRegisterPacket();
}
// If no Rx for ages
if(NowTime.tv_sec > LastRxActivityTime.tv_sec + SERVERTIMEOUT && ClientStatus != CS_NOSERVER){
Log(LOG_INFO, "Client lost master connection");
// Wait for access to the packet queue
pthread_mutex_lock(&PacketQueueMutex);
for(i = 0; i < PacketQueues; i++){
// Send any/all packets in queue
while(PacketQueueHead[i] != PacketQueueTail[i]){
// Send the packet
ipq_set_verdict(hIpq, ((ipq_packet_msg_t *)&PacketQueue[i][PacketQueueTail[i] * sizeof(struct ipq_packet_msg)])->packet_id, NF_ACCEPT, 0, NULL);
PacketQueueTail[i]++;
if(PacketQueueTail[i] >= Config.Queue)
PacketQueueTail[i] = 0;
}
}
// Release access to the packet queue
pthread_mutex_unlock(&PacketQueueMutex);
// Update the status to allow packets straight through
ClientStatus = CS_NOSERVER;
}
// If no background processing for 10 sec (approx.)
if(NowTime.tv_sec >= LastCtrlBackgroundTime.tv_sec + 10){
// Update wireless data
GetWirelessState();
// Store intial background processing time
gettimeofday(&LastCtrlBackgroundTime, NULL);
if(Config.StatsFilename[0] != 0x00){
// Start file write function in own threa
//idWriteStatsFileThread = 0;
//pthread_create(&idWriteStatsFileThread, NULL, &WriteStatsFile, NULL);
// TODO: Figure out why doing it in a thread dies sooner or later (no further updates)
WriteStatsFile(NULL);
}
//Reset poll count
ClientStats.Polls = 0;
}
}
// Call and clear cleanup function
pthread_cleanup_pop(1);
return NULL;
}
void ProcessSockets(void)
{
if (socketpool.length >= events.capacity)
{
bprintf("Reserving more space for events\n");
vec_reserve(&events, socketpool.length * 2);
}
bprintf("Entering epoll_wait\n");
int total = epoll_wait(EpollHandle, &vec_first(&events), events.capacity, config->readtimeout * 1000);
if (total == -1)
{
if (errno != EINTR)
fprintf(stderr, "Error processing sockets: %s\n", strerror(errno));
return;
}
for (int i = 0; i < total; ++i)
{
epoll_t *ev = &(events.data[i]);
socket_t s;
if (FindSocket(ev->data.fd, &s) == -1)
{
bfprintf(stderr, "Unknown FD in multiplexer: %d\n", ev->data.fd);
// We don't know what socket this is. Someone added something
// stupid somewhere so shut this shit down now.
// We have to create a temporary socket_t object to remove it
// from the multiplexer, then we can close it.
socket_t tmp = { ev->data.fd, 0, 0, 0, 0 };
RemoveFromMultiplexer(tmp);
close(ev->data.fd);
continue;
}
// Call our event.
CallEvent(EV_SOCKETACTIVITY, &s);
if (ev->events & (EPOLLHUP | EPOLLERR))
{
bprintf("Epoll error reading socket %d, destroying.\n", s.fd);
DestroySocket(s, 1);
continue;
}
// Process socket write events
if (ev->events & EPOLLOUT && SendPackets(s) == -1)
{
bprintf("Destorying socket due to send failure!\n");
DestroySocket(s, 1);
}
// process socket read events.
if (ev->events & EPOLLIN && ReceivePackets(s) == -1)
{
bprintf("Destorying socket due to receive failure!\n");
DestroySocket(s, 1);
}
}
}
