252 lines
7.5 KiB
C++
252 lines
7.5 KiB
C++
#include "Sockets.h"
|
|
#include "SocketPort.h"
|
|
#include "BluePad.h"
|
|
#include "stdTools.h"
|
|
|
|
#include <sstream>
|
|
|
|
//---------------------------------------------------------------------------
|
|
THSocket::THSocket() {
|
|
parent = NULL;
|
|
id = -1;
|
|
sp = NULL;
|
|
m_exe_thread_read = true;
|
|
m_threadid_read = NULL;
|
|
m_exe_thread_write = true;
|
|
m_threadid_write = NULL;
|
|
|
|
|
|
length_write = 0;
|
|
memset(data_write, 0, sizeof(data_write));
|
|
|
|
len_read = 0;
|
|
memset(data_read, 0, sizeof(data_read));
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
THSocket::~THSocket() {
|
|
|
|
//Îñòàíàâëèâàþ ïîòîêè è äîæèäàþñü èõ çàâåðøåíèÿ
|
|
m_exe_thread_read = false;
|
|
m_threadid_read->join();
|
|
delete m_threadid_read;
|
|
|
|
Sleep(10);
|
|
m_exe_thread_write = false;
|
|
Sleep(10);
|
|
m_threadid_write->join();
|
|
delete m_threadid_write;
|
|
|
|
//Çàêðûâàþ è óäàëÿþ ñîêåò
|
|
sp->Close();
|
|
delete sp;
|
|
sp = NULL;
|
|
|
|
id = -1;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//Äëÿ ÷òåíèÿ äàííûõ èç ñîêåòîâ
|
|
void THSocket::thread_func_read(void *pData)
|
|
{
|
|
THSocket* sock = (THSocket*)pData;
|
|
|
|
char data[65500];
|
|
while (sock->m_exe_thread_read) { //Ïîòîê íàìåðòâî íå äîëæåí òîðìîçèòüñÿ èíà÷å èç íåãî íå âûéäåò (ôóíêöèÿ Read äîëæíà áûòü ñ òàéìàóòîì)
|
|
|
|
int size = sock->sp->Read(data, sizeof(data));
|
|
//Åñëè óäàëîñü ÷òî ëèáî ïðî÷èòàòü òî ïåðåïèñûâàåì ì ìàññèâ
|
|
if (size > 0) {
|
|
|
|
sock->parent->m_mutexList.lock();
|
|
for (int i = 0; i < size; i++) {
|
|
if (sock->len_read + i >= sizeof(sock->data_read))
|
|
break;
|
|
sock->data_read[sock->len_read + i] = data[i];
|
|
}
|
|
sock->len_read += size;
|
|
sock->parent->m_mutexList.unlock();
|
|
|
|
std::stringstream ss;
|
|
ss << "--------------------------------------------------Read from soket = " << size;
|
|
Utility::logrotate(sock->m_LogFilePath + Utility::sp3() + "log.txt", ss.str()); //TODO çàêîìåíòèòü êàê îòëàæó
|
|
}
|
|
}
|
|
//TODO çàêîìåíòèòü êàê îòëàæó
|
|
if (sock->m_SaveLog) {
|
|
std::stringstream ss;
|
|
ss << "========== END SOCK READ THREAD ID = " << sock->id << " ==========";
|
|
Utility::logrotate(sock->m_LogFilePath + Utility::sp3() + "log.txt", ss.str());
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//Ïîòîê äëÿ çàïèñè äàííûõ â ñîêåò
|
|
void THSocket::thread_func_write(void *pData)
|
|
{
|
|
THSocket* sock = (THSocket*)pData;
|
|
char data[65535];
|
|
int len = 0;
|
|
while (sock->m_exe_thread_write) {
|
|
|
|
//Ïåðåïèñûâàþ äàííûå äëÿ îòïðàâêè íà ñåðâåð â ëîêàëüíóþ ïåðåìåííóþ
|
|
sock->parent->m_mutexList.lock();
|
|
for (int i = 0; i < sock->length_write; i++) {
|
|
data[i] = sock->data_write[i];
|
|
}
|
|
len = sock->length_write;
|
|
sock->parent->m_mutexList.unlock();
|
|
|
|
if (len > 0) {
|
|
//Îòïðàâëÿþ äàííûå â ñîêåò
|
|
int size = sock->sp->Write(data, len);
|
|
|
|
//Ñäâèãàþ äàííûå íà êîëè÷åñòâî îòïðàâëåííûõ äàííûõ
|
|
sock->parent->m_mutexList.lock();
|
|
for (int i = 0; i < sock->length_write - size; i++) {
|
|
sock->data_write[i] = sock->data_write[i + size];
|
|
}
|
|
sock->length_write -= size;
|
|
sock->parent->m_mutexList.unlock();
|
|
|
|
std::stringstream ss;
|
|
ss << "--------------------------------------------------Write to soket = " << size << " from = " << len;
|
|
Utility::logrotate(sock->m_LogFilePath + Utility::sp3() + "log.txt", ss.str()); //TODO çàêîìåíòèòü êàê îòëàæó
|
|
}
|
|
}
|
|
//TODO çàêîìåíòèòü êàê îòëàæó
|
|
if (sock->m_SaveLog) {
|
|
std::stringstream ss;
|
|
ss << "========== END SOCK WRITE THREAD ID = " << sock->id << " ==========";
|
|
Utility::logrotate(sock->m_LogFilePath + Utility::sp3() + "log.txt", ss.str());
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
Sockets::Sockets(BluePad* bp)
|
|
{
|
|
m_bp = bp;
|
|
m_LogFilePath = m_bp->m_LogFilePath;
|
|
|
|
m_list = new TSimpleList<THSocket*>(10, true); //Äåëàþ âëàäåëüöåì ÷òîáû ñïèñîê ñàì îáúåêòû óäàëÿë
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
Sockets::~Sockets()
|
|
{
|
|
delete m_list;
|
|
};
|
|
//---------------------------------------------------------------------------
|
|
//ñîçäàòü íîâûé ñîêåò è çàïóñòèòü ïîòîêè íà ÷òåíèå è çèïèñü
|
|
//timeout - òàéìàóò â ñåêóíäàõ (òîëüêî íà ÷òî?)
|
|
bool Sockets::openSoket(int id, std::string address, int port, int timeout)
|
|
{
|
|
bool result = true;
|
|
|
|
SocketPort* sp = new SocketPort();
|
|
sp->Open(address.c_str(), port);
|
|
if (sp->isOpen()) {
|
|
|
|
//Äîáàâëÿåì ñîçäàííûé îáúåêò â ìàññèâ
|
|
THSocket* ths = new THSocket();
|
|
ths->m_LogFilePath = m_LogFilePath;
|
|
ths->id = id;
|
|
ths->sp = sp;
|
|
ths->parent = this;
|
|
ths->m_threadid_read = new std::thread(THSocket::thread_func_read, (void*)ths);
|
|
ths->m_threadid_write = new std::thread(THSocket::thread_func_write, (void*)ths);
|
|
|
|
m_mutexList.lock();
|
|
m_list->add(ths);
|
|
m_mutexList.unlock();
|
|
|
|
|
|
std::stringstream ss;
|
|
ss << "========== OPEN SOCK THREAD ID = " << id << " ==========";
|
|
Utility::logrotate(m_LogFilePath + Utility::sp3() + "log.txt", ss.str());
|
|
}
|
|
else {
|
|
result = false;
|
|
delete sp;
|
|
}
|
|
return result;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//Çàêðûòü óäàëèòü ñîêåò è îñòàíîâèòü ñâÿçàííûå ñ íèì ïîòîêè
|
|
bool Sockets::closeSoket(int id) {
|
|
TSimpleList<THSocket*>* list = new TSimpleList<THSocket*>(10,true);
|
|
|
|
m_mutexList.lock();
|
|
for (int i = 0; i<m_list->count(); i++) {
|
|
if (m_list->get(i)->id == id) {
|
|
list->add(m_list->get(i));
|
|
m_list->rem(i);
|
|
i--;
|
|
// break íå ñòàâèòü, ìîãóò áûòü îäèíàêîâûå id
|
|
}
|
|
}
|
|
m_mutexList.unlock();
|
|
|
|
delete list; //Íå â ìþòåêñå à òî ïîâèñíåò èç-çà join ïðè óäàëåíèè
|
|
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
// Çàïèñàòü äàííûå äëÿ ïîñëåäóþùåé îòïðàâêè â îòäåëüíîì ïîòîêå
|
|
bool Sockets::sendData(int id, char* data, int len) {
|
|
|
|
std::lock_guard<std::mutex> lock(m_mutexList);
|
|
|
|
for (int i = 0; i<m_list->count(); i++) {
|
|
if (m_list->get(i)->id == id) {
|
|
|
|
THSocket* ths = m_list->get(i);
|
|
|
|
//Äîïèñûâàåì äàííûå â êîíåö ìàññèâà äëÿ ïîñëåäóþùåé îòïðàâêè íà ñåðâåð
|
|
for (int i = 0; i < len; i++) {
|
|
if (ths->length_write + i >= sizeof(ths->data_write))
|
|
break;
|
|
ths->data_write[ths->length_write + i] = data[i];
|
|
}
|
|
ths->length_write += len;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//Ïåðåáèðàåì ìàññèâ è ïðîâåðÿåì åñòü ëè äàííûå äëÿ îòïðàâêè è åñëè åñòü òî ñîçäà¸ì îáúåêò äàííûõ êîòîðûé áóäåò îòïðàâëåí ÷åðåç ïîñëåäîâàòåëüíûé ïîðò â îòäåëüíîì ïîòîêå
|
|
DataToSend* Sockets::getDataToSend() {
|
|
|
|
std::lock_guard<std::mutex> lock(m_mutexList);
|
|
|
|
DataToSend* result = NULL;
|
|
|
|
for (int i = 0; i<m_list->count(); i++) {
|
|
if (m_list->get(i)->len_read > 0) {
|
|
|
|
m_list->get(i)->len_read += 1;
|
|
|
|
result = new DataToSend();
|
|
//Ïîäãîòàâëèâàþ ïàêåò 01: RECEIVE DATA äëÿ îòïðàâêè ïîëó÷åííûõ äàíûõ ñ ñåðâåðà íà ïèíïàä
|
|
result->mas[0] = 0x3E; // '>': start paket (ASCII symbol '>')
|
|
result->mas[1] = 0x40; // EXTERNAL INTERNET COMMANDS
|
|
result->mas[2] = 0x00; // 00
|
|
result->mas[3] = ((char*)&m_list->get(i)->len_read)[1]; //LH length of DATA (ñòàðøèé íàèáîëåå çíà÷àùèé áàéò)
|
|
result->mas[4] = ((char*)&m_list->get(i)->len_read)[0]; //LL length of DATA
|
|
result->mas[5] = 0x01; //SUBCMD: 01: RECEIVE DATA
|
|
for (int j = 0; j < m_list->get(i)->len_read; j++) {
|
|
result->mas[6+j] = m_list->get(i)->data_read[j];
|
|
}
|
|
result->len = 6 + m_list->get(i)->len_read;
|
|
result->calcCRC();
|
|
result->log_text = "getDataToSend()";
|
|
|
|
m_list->get(i)->len_read = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
//---------------------------------------------------------------------------
|