void
IrcSocket::SendPing ()
{
if (knowHostName) {
if (needPing) {
qDebug () << "send ping goes to " << peerAddress();
QString msg (QString ("PING %1").arg (hostName));
SendData (msg);
}
needPing = true;
} else {
qDebug () << " cannot PING, unknown host name for " << peerAddress();
qDebug () << " guess is " << hostName;
}
}
void TcpSocket::readClient()
{
qDebug() << "readClientInServer";
QDataStream in(this);
in.setVersion(QDataStream::Qt_4_6);
if (nextBlockSize == 0)
{
if (bytesAvailable() < sizeof(quint64))
return;
in >> nextBlockSize;
}
if ((quint64)bytesAvailable() < nextBlockSize)
return;
QString requestType;
in >> requestType;
if(requestType == "GET")
sendInfo();
else if (requestType == "CLICK" || requestType == "RIGHT" || requestType == "DOUBLE")
{
int i,j;
in >> i >> j;
qDebug() << requestType << QString::number(i) << QString::number(j);
emit updateSocks(requestType,i,j);
emitter = peerAddress().toString();
}
void TcpClientManager::manage()
// Slot appelé par started() lors de l'exécution d'un nouveau thread
{
// Récupère le QTcpSocket du client à l'aide de son descripteur
if(! setSocketDescriptor(_socketDescriptor) )
{
emit sig_finished();
return;
}
// TODO : Signaler intruderEjected si ce n'est pas un reader puis quitter
QString clientAddress = peerAddress().toString();
if(bddisNotAReaderAddress(clientAddress))
{
abort();
emit sig_intruderEjected(clientAddress);
emit sig_finished();
return;
}
Reader* reader = bddgetReaderByAddress(clientAddress);
reader->isConnected(true);
bddsetReader(reader);
emit sig_readerConnected();
// TODO : Signaler readerDetected si c'est un reader
// emit sig_readerConnected(Reader*);
}
void Connection::processReadyRead()
{
qDebug() << "processReadyRead .";
m_localHostName = this->peerName();// QString(m_buffer);
m_localHostAddress = peerAddress().toString();
m_localHostPort = QString::number(peerPort());
qDebug() << "you have connected: " << m_localHostName << m_localHostAddress << m_localHostPort;
// if (!hasEnoughData())
// return;
// m_buffer = read(numBytesForCurrentDataType);
// if (m_buffer.size() != numBytesForCurrentDataType)
// {
// abort();
// return;
// }
// if (!isValid())
// {
// abort();
// return;
// }
// emit readyForUse();
// do
// {
// if (!readProtocolHeader())
// return;
// if (!hasEnoughData())
// return;
// processData();
// } while (bytesAvailable() > 0);
}
void
IrcSocket::DidConnect ()
{
hostName = peerAddress().toString();
emit connected (this);
scriptTimer->start (1000);
pingTimer->start (2*60*1000);
}
void Connection::processReadyRead()
{
if (state == WaitingForGreeting)
{
if (!readProtocolHeader())
return;
if (currentDataType != Greeting)
{
abort();
return;
}
state = ReadingGreeting;
}
if (state == ReadingGreeting)
{
if (!hasEnoughData())
return;
buffer = read(numBytesForCurrentDataType);
if (buffer.size() != numBytesForCurrentDataType)
{
abort();
return;
}
username = QString(buffer) + '@' + peerAddress().toString() + ':' + QString::number(peerPort());
currentDataType = Undefined;
numBytesForCurrentDataType = 0;
buffer.clear();
if (!isValid())
{
abort();
return;
}
if (!isGreetingMessageSent)
sendGreetingMessage();
pingTimer.start();
pongTime.start();
state = ReadyForUse;
emit readyForUse();
}
do
{
if (currentDataType == Undefined)
{
if (!readProtocolHeader())
return;
}
if (!hasEnoughData())
return;
processData();
} while (bytesAvailable() > 0);
}
void Socket::thisReadData() {
buffer+=readAll();
int pos=buffer.indexOf('}');
for (;pos>=0;pos=buffer.indexOf('}')) {
QString t=buffer.mid(0,pos+1);
buffer=buffer.mid(pos+1,buffer.size()-pos);
emit readVariantMap(socketID,peerAddress().toString(),peerPort(),QJsonDocument::fromJson(t.toUtf8()).toVariant().toMap());
}
}
QList<THttpRequest> THttpSocket::read()
{
T_TRACEFUNC("");
QList<THttpRequest> reqList;
if (canReadRequest()) {
if (fileBuffer.isOpen()) {
fileBuffer.close();
THttpRequest req(readBuffer, fileBuffer.fileName(), peerAddress());
reqList << req;
} else {
reqList = THttpRequest::generate(readBuffer, peerAddress());
}
readBuffer.clear();
lengthToRead = -1;
}
return reqList;
}
void pServer::onConnection()
{
auto socket = _server.nextPendingConnection();
auto addr = socket->peerAddress();
auto it = _limits.find(addr);
if (it == _limits.end()) {
it = _limits.insert(addr, 0);
} else {
if (it.value() > pServer::LIMIT) {
socket->disconnectFromHost();
socket->deleteLater();
return;
}
}
// qDebug() << "Connected: " << socket->peerAddress().toString() << " with used limit " << it.value() << " bytes";
new pSocket(socket, pThreadPool::getNextThread(), it.value());
Logger::log(socket->peerAddress().toString() + socket->peerName(), it.value());
}
folly::SocketAddress MessageHeader::getPeerAddress() {
folly::SocketAddress address;
if (peerAddress()[0] == '\0') {
return address;
}
try {
if (isUnixDomainSocket()) {
auto sp = folly::StringPiece(peerAddress(), kAddressMaxSize);
sp.removePrefix(kUnixSocketPrefix);
if (!sp.empty()) {
address.setFromPath(sp);
}
} else {
address.setFromIpPort(peerAddress(), peerPort());
}
} catch (const std::exception& ex) {
VLOG(2) << "Error parsing address: " << ex.what();
}
return address;
}
static void _netconfServiceMessageHandler(void *renv,Service &svc,const Dictionary &msg)
{
if (!renv)
return; // sanity check
const RuntimeEnvironment *_r = (const RuntimeEnvironment *)renv;
try {
//TRACE("from netconf:\n%s",msg.toString().c_str());
const std::string &type = msg.get("type");
if (type == "netconf-response") {
uint64_t inRePacketId = strtoull(msg.get("requestId").c_str(),(char **)0,16);
uint64_t nwid = strtoull(msg.get("nwid").c_str(),(char **)0,16);
Address peerAddress(msg.get("peer").c_str());
if (peerAddress) {
if (msg.contains("error")) {
Packet::ErrorCode errCode = Packet::ERROR_INVALID_REQUEST;
const std::string &err = msg.get("error");
if (err == "OBJ_NOT_FOUND")
errCode = Packet::ERROR_OBJ_NOT_FOUND;
Packet outp(peerAddress,_r->identity.address(),Packet::VERB_ERROR);
outp.append((unsigned char)Packet::VERB_NETWORK_CONFIG_REQUEST);
outp.append(inRePacketId);
outp.append((unsigned char)errCode);
outp.append(nwid);
_r->sw->send(outp,true);
} else if (msg.contains("netconf")) {
const std::string &netconf = msg.get("netconf");
if (netconf.length() < 2048) { // sanity check
Packet outp(peerAddress,_r->identity.address(),Packet::VERB_OK);
outp.append((unsigned char)Packet::VERB_NETWORK_CONFIG_REQUEST);
outp.append(inRePacketId);
outp.append(nwid);
outp.append((uint16_t)netconf.length());
outp.append(netconf.data(),netconf.length());
outp.compress();
_r->sw->send(outp,true);
}
}
}
}
} catch (std::exception &exc) {
LOG("unexpected exception parsing response from netconf service: %s",exc.what());
} catch ( ... ) {
LOG("unexpected exception parsing response from netconf service: unknown exception");
}
}
void ResourceRequester::readMessage()
{
QDataStream in(this);
in.setVersion(QDataStream::Qt_4_7);
quint32 new_version;
if(nextBlockSize == 0)
{
if(bytesAvailable() < sizeof(quint32))
return;
in >>nextBlockSize;
if(0 == nextBlockSize)
{
qDebug()<<"-----------------------------------------------";
qDebug()<<"reource is the newest,do not need to update..";
qDebug()<<"-----------------------------------------------";
close();
return;
}
}
if(bytesAvailable() < nextBlockSize)
return;
resource_list.clear();
in>>new_version>>resource_list;
qDebug()<<"remote resource version change:"<<remote_res_peer.value()
<<"->"<<new_version;
remote_res_peer.value() = new_version;
/*
qDebug()<<"----------------------------------------------------------------";
qDebug()<<"----------------------------------------------------------------";
for(int i = 0; i < resource_list.size(); i++)
{
qDebug()<<">>>>resource id:"<<resource_list.at(i).id.toHex();
}
qDebug()<<"----------------------------------------------------------------";
qDebug()<<"----------------------------------------------------------------";
*/
t_ip_port rpc(peerAddress().toIPv4Address(), peerPort());
close();
updateResource(rpc);
emit net_resource_list_update((QObject *)&resid2peer_map, (QObject*)&resid2pro_map);
}
int Socket::accept()
{
int peerfd = ::accept(sockfd_, NULL, NULL);
if(-1 == peerfd)
{
perror("accept error");
exit(EXIT_FAILURE);
}
InetAddress local = localAddress(peerfd);
InetAddress peer = peerAddress(peerfd);
printf("connected! %s:%d -> %s:%d\n",
local.ip().c_str(),
local.port(),
peer.ip().c_str(),
peer.port());
return peerfd;
}
THttpRequest THttpSocket::read()
{
T_TRACEFUNC("");
THttpRequest req;
if (canReadRequest()) {
int idx = readBuffer.indexOf("\r\n\r\n");
if (idx > 0) {
if (fileBuffer.isOpen()) {
fileBuffer.close();
req.setRequest(readBuffer.left(idx + 4), fileBuffer.fileName());
} else {
req.setRequest(readBuffer.left(idx + 4), readBuffer.mid(idx + 4));
}
readBuffer.clear();
req.setClientAddress(peerAddress());
}
}
return req;
}
void TcpServer::newConnectionCallback(const TcpConnectionPtr& connection)
{
std::cout << "thread id = " << std::this_thread::get_id() << std::endl;
//构造通信地址结构
tcp::socket& socket = connection->socket();
std::string remote_address = socket.remote_endpoint().address().to_string();
uint16_t remote_port = socket.remote_endpoint().port();
InetAddress peerAddress(remote_address, remote_port);
//设置链接回调
connection->setWriteCompletedCallback(_writeCompletedCallback);
connection->setReadCompletedCallback(_readCompletedCallback);
connection->setConnectionClosedCallback(_connectionClosedCallback);
if (_newConnectionCallback)
{
_newConnectionCallback(connection, peerAddress);
}
}
void TcpServer::incomingConnection(qintptr socketDescriptor) //多线程必须在此函数里捕获新连接.
{
if (tcpClient->size() > maxPendingConnections())//继承重写此函数后，QTcpServer默认的判断最大连接数失效，自己实现
{
QTcpSocket tcp;
tcp.setSocketDescriptor(socketDescriptor);
tcp.disconnectFromHost();
return;
}
auto th = ThreadHandle::getClass().getThread();
auto tcpTemp = new TcpSocket(socketDescriptor);
QString ip = tcpTemp->peerAddress().toString();
qint16 port = tcpTemp->peerPort();
connect(tcpTemp,&TcpSocket::sockDisConnect,this,&TcpServer::sockDisConnectSlot);//NOTE:断开连接的处理，从列表移除，并释放断开的Tcpsocket，此槽必须实现，线程管理计数也是考的他
connect(this,&TcpServer::sentDisConnect,tcpTemp,&TcpSocket::disConTcp);//断开信号
tcpTemp->moveToThread(th);//把tcp类移动到新的线程，从线程管理类中获取
tcpClient->insert(socketDescriptor,tcpTemp);//插入到连接信息中
emit connectClient(socketDescriptor,ip,port);
}
void Connection::metadataReceivedData(const QByteArray &msg)
{
bool ok=false;
char reply[256];
switch(0xFF&msg[2]) {
case 0x01: // Set Connection Context
if(msg.size()==4) {
conn_is_isolated=msg[3]==0x00;
ok=true;
}
break;
case 0x02: // Send Full State
emit fullStateRequested(conn_id);
ok=true;
break;
case 0x03: // Connection Ping
reply[0]=0x04;
reply[1]=0x01;
reply[2]=0x03;
write(reply,3);
ok=true;
break;
default:
break;
}
if(!ok) {
syslog(LOG_WARNING,"receieved unknown metadata message %s from %s:%d",
(const char *)LPMessage::dump(msg).toAscii(),
(const char *)peerAddress().toString().toAscii(),
0xFFFF&peerPort());
}
}
void TCPSocket::onRecv(const MutableBuffer& buf)
{
TraceLS(this) << "Recv: " << buf.size() << endl;
onSocketRecv(buf, peerAddress());
}
int TCPSocket::send(const char* data, std::size_t len, int flags)
{
return send(data, len, peerAddress(), flags);
}
void Socket::emitDisconnect() {
emit sockDisconnect(socketID,peerAddress().toString(),peerPort());
}
bool MessageHeader::isUnixDomainSocket() const {
return folly::StringPiece(peerAddress(), kAddressMaxSize)
.startsWith(kUnixSocketPrefix);
}
