void Tercon::convertData(QByteArray strData){
TerconData data;
bool convertIsOK=false;
strData = strData.simplified();
QString tempStr = strData;
int indexSeparator = tempStr.indexOf(QRegExp("[tRU]"));
QString unitAndNumberData = tempStr.left(indexSeparator+1);
tempStr.remove(0,indexSeparator+1);
if(indexSeparator==-1){
emit message(tr("Ошибка чтения данных Теркона\n"
"(разделитель не обнаружен): ")+strData+".",Shared::warning);
return;
}
data.value = tempStr.toDouble(&convertIsOK);
if (!convertIsOK){
emit message(tr("Ошибка чтения данных Теркона\n"
"(невозможно преобразовать строку в число): ")+strData+".",Shared::warning);
return;
}
data.unit = unitAndNumberData.at(unitAndNumberData.size()-1);
unitAndNumberData.chop(1);
data.channel = unitAndNumberData.toShort(&convertIsOK);
if (!convertIsOK){
emit message(tr("Ошибка чтения данных Теркона\n"
"(неверный номер канала): ")+strData+".",Shared::warning);
return;
}
data.deviceNumber = deviceNumber;
emit dataSend(data);
}
int connectionSendResponse(connection *con) {
// char *message;
// int dataBytes;
// void *data;
// if (handleResponse(con->res, &message, &dataBytes, &data)) {
// return 1;
// }
int socketFD = con->tArgs->socketFD;
response *res = con->res;
if (res->dataBytes > 0) {
dataSend(socketFD, res->message, res->dataBytes, res->data);
} else {
// Ignore errors in sending message
messageSend(socketFD, res->message);
}
responseWipe(res);
return 0;
}
bool CUpDownClient::ProcessPeerCacheQuery(const uchar* packet, UINT size)
{
const bool bDebug = (thePrefs.GetDebugClientTCPLevel() > 0);
if (bDebug)
DebugRecv("OP_PeerCacheQuery", this);
if (socket == NULL){
ASSERT(0);
return false;
}
CSafeMemFile dataRecv(packet, size);
uint8 uPCVersion = dataRecv.ReadUInt8();
if (uPCVersion != PCPCK_VERSION){
if (bDebug)
Debug(_T(" ***Invalid packet version: 0x%02x\n"), uPCVersion);
ASSERT(0);
return false;
}
uint8 uPCOpcode = dataRecv.ReadUInt8();
if (uPCOpcode != PCOP_REQ){
if (bDebug)
Debug(_T(" ***Invalid packet opcode: 0x%02x\n"), uPCOpcode);
ASSERT(0);
return false;
}
uint32 uCacheIP = 0;
uint16 uCachePort = 0;
uint32 uPushId = 0;
uchar aucFileHash[16];
uint32 uRemoteIP = 0;
md4clr(aucFileHash);
CString strInfo;
UINT uTags = dataRecv.ReadUInt8();
while (uTags--)
{
CTag tag(&dataRecv, GetUnicodeSupport()!=utf8strNone);
if (tag.GetNameID() == PCTAG_CACHEIP && tag.IsInt())
{
uCacheIP = tag.GetInt();
if (bDebug)
strInfo.AppendFormat(_T(" CacheIP=%s"), ipstr(uCacheIP));
}
else if (tag.GetNameID() == PCTAG_CACHEPORT && tag.IsInt())
{
uCachePort = (uint16)tag.GetInt();
if (bDebug)
strInfo.AppendFormat(_T(" CachePort=%u"), uCachePort);
}
else if (tag.GetNameID() == PCTAG_PUSHID && tag.IsInt())
{
uPushId = tag.GetInt();
if (bDebug)
strInfo.AppendFormat(_T(" PushId=%u"), uPushId);
}
else if (tag.GetNameID() == PCTAG_FILEID && tag.IsHash() && tag.GetHash() != NULL)
{
md4cpy(aucFileHash, tag.GetHash());
if (bDebug)
strInfo.AppendFormat(_T(" FileId=%s"), md4str(aucFileHash));
}
else if (tag.GetNameID() == PCTAG_PUBLICIP && tag.IsInt())
{
uRemoteIP = tag.GetInt();
if (bDebug)
strInfo.AppendFormat(_T(" PublicIP=%s"), ipstr(uRemoteIP));
}
else
{
if (bDebug)
strInfo.AppendFormat(_T(" ***UnkTag: %s"), tag.GetFullInfo());
ASSERT(0);
}
}
if (bDebug)
{
if (dataRecv.GetPosition() < dataRecv.GetLength())
strInfo.AppendFormat(_T(" ***AddData: %u bytes"), (UINT)(dataRecv.GetLength() - dataRecv.GetPosition()));
Debug(_T("%s\n"), strInfo);
}
if (uCacheIP == 0 || uCachePort == 0 || uPushId == 0 || isnulmd4(aucFileHash)){
if (thePrefs.GetVerbose())
AddDebugLogLine(false, _T("Invalid PeerCacheQuery; %s"), DbgGetClientInfo());
return false;
}
CKnownFile* pUploadFile = theApp.sharedfiles->GetFileByID(aucFileHash);
if (pUploadFile == NULL){
if (thePrefs.GetVerbose())
AddDebugLogLine(false, _T("PeerCacheQuery reqfile does not match ed2k reqfile; %s"), DbgGetClientInfo());
return false;
}
if (m_pPCUpSocket != NULL)
{
SetPeerCacheUpState(PCUS_NONE);
m_pPCUpSocket->Safe_Delete();
ASSERT( m_pPCUpSocket == NULL );
}
m_pPCUpSocket = new CPeerCacheUpSocket(this);
m_pPCUpSocket->SetTimeOut(GetPeerCacheSocketUploadTimeout());
m_pPCUpSocket->Create();
SOCKADDR_IN sockAddr = {0};
sockAddr.sin_family = AF_INET;
sockAddr.sin_port = htons(uCachePort);
sockAddr.sin_addr.S_un.S_addr = uCacheIP;
//Try to always tell the socket to WaitForOnConnect before you call Connect.
m_pPCUpSocket->WaitForOnConnect();
m_pPCUpSocket->Connect((SOCKADDR*)&sockAddr, sizeof sockAddr);
CStringA strPCRequest;
strPCRequest.AppendFormat("GIVE %u\r\n", uPushId);
if (thePrefs.GetDebugClientTCPLevel() > 0){
DebugSend("PeerCache-GIVE", this, pUploadFile->GetFileHash());
Debug(_T(" %hs\n"), strPCRequest);
}
CRawPacket* pHttpPacket = new CRawPacket(strPCRequest);
theStats.AddUpDataOverheadFileRequest(pHttpPacket->size);
m_pPCUpSocket->SendPacket(pHttpPacket);
m_pPCUpSocket->SetHttpState(HttpStateRecvExpected);
m_bPeerCacheUpHit = false;
SetPeerCacheUpState(PCUS_WAIT_CACHE_REPLY);
//theApp.uploadBandwidthThrottler->AddToStandardList(0, m_pPCUpSocket);
CSafeMemFile dataSend(128);
dataSend.WriteUInt8(PCPCK_VERSION);
dataSend.WriteUInt8(PCOP_RES);
dataSend.WriteUInt8(3);
CTag tagPushId(PCTAG_PUSHID, uPushId);
tagPushId.WriteNewEd2kTag(&dataSend);
CTag tagPublicIP(PCTAG_PUBLICIP, theApp.GetPublicIP());
tagPublicIP.WriteNewEd2kTag(&dataSend);
CTag tagFileId(PCTAG_FILEID, (BYTE*)aucFileHash);
tagFileId.WriteNewEd2kTag(&dataSend);
if (thePrefs.GetDebugClientTCPLevel() > 0){
DebugSend("OP__PeerCacheAnswer", this, aucFileHash);
Debug(_T(" PushId=%u PublicIP=%s FileId=%s\n"), tagPushId.GetInt(), ipstr(tagPublicIP.GetInt()), md4str(tagFileId.GetHash()));
}
Packet* pEd2kPacket = new Packet(&dataSend, OP_EMULEPROT, OP_PEERCACHE_ANSWER);
theStats.AddUpDataOverheadFileRequest(pEd2kPacket->size);
socket->SendPacket(pEd2kPacket);
return true;
}
void ServerCatchcopy::reply(quint32 client,quint32 orderId,quint32 returnCode,QStringList returnList)
{
int index=0;
while(index<ClientList.size())
{
if(ClientList.at(index).id==client)
{
if(ClientList.at(index).socket->isValid() && ClientList.at(index).socket->state()==QLocalSocket::ConnectedState)
{
if(!ClientList.at(index).queryNoReplied.contains(orderId))
{
qWarning() << "Reply to missing query or previously replied";
return;
}
ClientList[index].queryNoReplied.removeOne(orderId);
//cut string list and send it as block of 32KB
QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_4_4);
out << int(0);
out << orderId;
out << returnCode;
out << returnList;
out.device()->seek(0);
out << block.size();
emit dataSend(client,orderId,returnCode,block);
emit dataSend(client,orderId,returnCode,returnList);
do
{
QByteArray blockToSend;
int byteWriten;
blockToSend=block.left(32*1024);//32KB
block.remove(0,blockToSend.size());
byteWriten = ClientList[index].socket->write(blockToSend);
if(!ClientList[index].socket->isValid())
{
error_string="Socket is not valid";
emit error(error_string);
return;
}
if(ClientList[index].socket->errorString()!="Unknown error" && ClientList[index].socket->errorString()!="")
{
error_string="Error with socket: "+ClientList[index].socket->errorString();
emit error(error_string);
return;
}
if(blockToSend.size()!=byteWriten)
{
error_string="All the bytes have not be written";
emit error(error_string);
return;
}
}
while(block.size());
}
else
{
error_string="Socket is not valid or not connected";
emit error(error_string);
}
return;
}
index++;
}
qWarning() << "Client id not found:" << client;
}
