virtual int ReadData(int fd)
{
int err = 0;
int clientFd = -1;
std::string ip;
int port = 0;
do {
err = mListenSocket->Accept(clientFd, ip, port);
if (0 != err) {
break;
}
TcpSocket *clientSocket = new TcpSocket();
err = clientSocket->Create(clientFd);
if (0 != err) {
break;
}
debug_log("accpeter accept client " << ip << ":" << port);
clientSocket->SetAddr(ip, port);
AcceptContext *ctx = new AcceptContext(clientSocket);
mNetService->Enqueue(ctx);
OperContext::DecRef(ctx);
} while(0);
return 0;
}
void c_communication(c_serveur& sett)
{
TcpSocket svr;
svr.connect(sett.c_ip,55001);
c_infoPlayer<<c_pseudo;
svr.send(c_infoPlayer);
cout<<"Communication lancee"<<endl;
while(c_connected)
{
c_attendre.lock();
svr.send(c_sortant);
c_sortant.clear();
c_sortant<<false<<"";
c_attendre.unlock();
bool a;
string b;
if(svr.receive(c_entrant) == Socket::Done)
{
//system("cls");
c_entrant>>a>>b;
if(!a)
c_msgsRecus = b;
}
else
{
void client()
{
TcpSocket socket;
Socket::Status status = socket.connect(IpAddress::getLocalAddress(), DH_PORT);
if (status != Socket::Status::Done)
{
perror("connection to server failed");
return;
}
mpz_t secret;
CurveRef curve = client_receive_curve(socket);
PointRef p = client_create_key(socket, curve, secret);
client_send_key(socket, p);
PointRef remoteKey = client_receive_key(socket);
PointRef sharedSecret = PointCreateMultiple(remoteKey, secret, curve);
char *desc = PointCreateDescription(sharedSecret);
cout << "Secret: " << desc << endl;
free(desc);
mpz_clear(secret);
CurveDestroy(curve);
PointDestroy(p);
PointDestroy(remoteKey);
PointDestroy(sharedSecret);
socket.disconnect();
}
void TcpSocketServer::broadcast(DataToSend* data)
{
if (data == NULL) return;
if (data->getType() != DataToSend::DS_READER)
{
for (Clients::iterator itr = _clients.begin(), end = _clients.end(); itr != end; ++itr)
{
TcpSocket* client = *itr;
client->send(data);
}
}
else
{
Ref<StreamReader> reader = data->getReader();
ASSERT_THROW(reader->isSeekable(), EX_NOT_SUPPORTED);
size_t pos = reader->tell();
for (Clients::iterator itr = _clients.begin(), end = _clients.end(); itr != end; ++itr)
{
reader->seek(pos);
TcpSocket* client = *itr;
client->send(data);
}
}
}
void* dabInputSlipThread(void* args)
{
dabInputSlipData* data = (dabInputSlipData*)args;
TcpSocket* client;
while ((client = data->server->accept()) != NULL) {
int size = 0;
etiLog.log(info, "SLIP server got a new client.\n");
#ifdef _WIN32
WaitForSingleObject(data->semWrite, INFINITE);
WaitForSingleObject(data->semQueue, INFINITE);
#else
sem_wait(&data->semWrite);
sem_wait(&data->semQueue);
#endif
UdpPacket* packet = data->packets[data->nbPackets];
#ifdef _WIN32
ReleaseSemaphore(data->semQueue, 1, NULL);
#else
sem_post(&data->semQueue);
#endif
while ((size = client->read(packet->getData(), packet->getSize()))
> 0) {
packet->setLength(size);
#ifdef _WIN32
WaitForSingleObject(data->semQueue, INFINITE);
#else
sem_wait(&data->semQueue);
#endif
data->nbPackets++;
#ifdef _WIN32
ReleaseSemaphore(data->semQueue, 1, NULL);
#else
sem_post(&data->semQueue);
#endif
#ifdef _WIN32
WaitForSingleObject(data->semWrite, INFINITE);
WaitForSingleObject(data->semQueue, INFINITE);
#else
sem_wait(&data->semWrite);
sem_wait(&data->semQueue);
#endif
packet = data->packets[data->nbPackets];
#ifdef _WIN32
ReleaseSemaphore(data->semQueue, 1, NULL);
#else
sem_post(&data->semQueue);
#endif
}
etiLog.log(info, "SLIP server client deconnected.\n");
client->close();
}
etiLog.log(error, "SLIP thread can't accept new client (%s)\n",
inetErrDesc, inetErrMsg);
return NULL;
}
//======================================================================================
TcpSocket* TcpSocket::Accept() {
struct sockaddr_in sa;
socklen_t len = sizeof(sa);
Log.i(SOCK_TAG, "TcpSocket::Accept m_iSocket=%u", m_iSocket);
int ret = accept(m_iSocket, (struct sockaddr*) &sa, &len);
if (-1 == ret){
Log.e(SOCK_TAG, "TcpSocket::Accept -1!");
return NULL;
}
if (0 == ret) {
Log.e(SOCK_TAG, "TcpSocket::Accept 0!");
return NULL;
}
TcpSocket *pNew = new TcpSocket(m_pSelector);
pNew->m_iSocket = ret;
//pNew->m_ip = ntohl(sa.sin_addr.s_addr);
//pNew->m_iPort = ntohs(sa.sin_port);
pNew->m_ip = sa.sin_addr.s_addr;
pNew->m_iPort = sa.sin_port;
pNew->m_bConnected = true;
pNew->m_iLastRecvTime = SelectorEPoll::getInstance().m_iHaoMiao;
pNew->setTimeout(m_iTimeout);
pNew->SetNBlock();
Log.i(SOCK_TAG, "TcpSocket accept %s:%u", ip2str(pNew->m_ip), pNew->m_iPort);
return pNew;
}
void run()
{
TcpSocket socket;
socket.connect("127.0.0.1", mPort);
T::Send(socket, mValue);
}
int onHeadersComplete(http_parser *parser)
{
TcpSocket *socket = static_cast<TcpSocket*>(parser->data);
#ifndef NO_LOG
sLog(LogEndpoint::LogLevel::DEBUG) << " === parsed header ====";
const QHash<QString, QSharedPointer<QString>> &headers = socket->getHeader().getHeaderInfo();
QHash<QString, QSharedPointer<QString>>::const_iterator i = headers.constBegin();
while (i != headers.constEnd())
{
sLog(LogEndpoint::LogLevel::DEBUG) << i.key() << *(i.value().data());
++i;
}
sLog(LogEndpoint::LogLevel::DEBUG) << " === ============= ====";
sLogFlush();
#endif
QWeakPointer<QString> host = socket->getHeader().getHeaderInfo("Host");
if (!host.isNull())
{
socket->getHeader().setHost(*host.data());
}
return 0;
}
/**
*函数介绍:有请求连接，新建一个socket
*输入参数:int socketId,新建socket的SocketDescriptor
*返回值:无
*/
void TcpServer::incomingConnection(int socketId)
{
TcpSocket *socket = new TcpSocket(socketId,this);
//设置socket描述符
socket->setSocketDescriptor(socketId);
//写入系统日志
//Global::systemLog->append(tr("网络通信服务端有新的连接请求"), QString(tr("服务端接收新的连接请求,socket描述符 = %1.")).arg(socketId), SystemLog::INFO);
qDebug()<<"服务端有新的连接,socketDescriptor:"<<socket->socketDescriptor();
//新建了一个socket连接
addServerSocket(socketId);
//获得客户端数据
connect(socket, SIGNAL(haveReadDataSignal(QByteArray,int)), this, SLOT(getClientMessage(QByteArray,int)));
//信号槽:跟踪服务端Socket状态
connect(socket,SIGNAL(stateChanged(QAbstractSocket::SocketState)),this,SLOT(getServerSocketState(QAbstractSocket::SocketState)));
//信号槽:服务端socket出现错误
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(serverSocketError(QAbstractSocket::SocketError)));
//与客户端断开某socket连接，服务端状态发生改变
connect(socket, SIGNAL(disconnectedBeforeDeleteSignal(int)), this, SLOT(removeServerSocket(int)));
//与客户端断开连接，输出服务器当前连接
//connect(socket, SIGNAL(disconnectedBeforeDeleteSignal(int)), this, SLOT(getAllConnection()));
//与客户端连接上后，输出服务器当前连接
//connect(socket, SIGNAL(connectedForServerSignal(int)), this, SLOT(getAllConnection()));
//与客户端连接上后，输出服务器当前连接
//connect(socket, SIGNAL(connectedForServerSignal(int)), this, SLOT(addServerSocket(int)));
}
int FileService::on_connect(Socket *socket)
{
TcpSocket * tcpsock = dynamic_cast<TcpSocket *> (socket);
tcpsock->set_recv_buffer_size(1000 * 1024);
//dlog1("FileServer new connection %s %d \n", socket->remote_addr.get_ip().c_str(), socket->remote_addr.get_port());
return FSM_END;
}
void TcpSocketServer::broadcast(const void* data, size_t size)
{
for (Clients::iterator itr = _clients.begin(), end = _clients.end(); itr != end; ++itr)
{
TcpSocket* client = *itr;
client->send(data, size);
}
}
bool Accept(TcpSocket& clientSocket) const
{
clientSocket.Close();
InetAddr& clientAddr = clientSocket.Addr();
int connFd = accept(m_Fd, (struct sockaddr*)&clientAddr.m_Addr, &clientAddr.m_AddrLen);
clientSocket.m_Fd = connFd;
return connFd != -1;
}
void ChooseConnectionDlg::on_actionCreateTcpClient_triggered()
{
TcpSocket * port = sConMgr2.createTcpSocket();
port->setName(tr("New TCP client"));
port->setHost("localhost");
port->setPort(80);
this->focusNewConn(port);
}
void run()
{
TcpSocket socket;
socket.connect("127.0.0.1", mPort);
TcpInt32TestSender::Send(socket, mIntValue);
TcpStringTestSender::Send(socket, mStringValue);
TcpFloatTestSender::Send(socket, mFloatValue);
TcpBoolTestSender::Send(socket, mBoolValue);
}
BOOL WINAPI SkylarkApp::CtrlCHandlerRoutine(__in DWORD dwCtrlType)
{
LOG("Ctrl+C handler");
TheApp().quit = true;
Cout() << "Ctrl + C\n";
TcpSocket h;
h.Connect("127.0.0.1", TheApp().port);
h.Put("quit");
return TRUE;
}
void SkylarkApp::Quit()
{
quit = true;
#ifdef PLATFORM_POSIX
Broadcast(SIGTERM);
#endif
TcpSocket s;
s.Timeout(100);
s.Connect("127.0.0.1", port);
}
bool readLinesFromClientTest(const int linesize=TcpSocket::DEFAULT_MAX_MSG){
cout << "Starting readLinesFromClientTest(" << linesize << ") ...\n";
string message("Passaro verde abandona ninho. \nEscuto!\n");
pid_t child;
// client code
if ((child=fork())==0){
try {
TcpSocket toServer;
cout << " Forked child waiting a bit\n";
sleep(1);
cout << " Forked child connecting to server\n";
toServer.connect("127.0.0.1",LOCALPORT);
cout << " Forked child connected: " << toServer << endl;
cout << " Forked child sending to server\n";
toServer.writeline(message);
cout << " Forked child closing connection to server\n";
toServer.close();
cout << " Forked child exiting\n";
exit(0);
} catch (std::exception& e) {
cout << " Forked child exception: " << e.what() << endl;
exit(-1);
}
return false; // for clarity
}
// server code
TcpSocket* connectedSocket;
try {
TcpSocket serverSocket;
connectedSocket = bindListenAccept(LOCALPORT, serverSocket);
std::string clientmessage;
cout << " Reading one (at most " << linesize << " chars long) line from client\n";
// Read a line
connectedSocket->setMaxReceive(linesize);
while ((*connectedSocket) >> clientmessage);
if (clientmessage.empty())
throw std::runtime_error("clinet message is empty");
cout << " Read: \"" << clientmessage << "\"\n";
if (!(clientmessage.compare(message) == 0)){
throw std::runtime_error("Messages dont match");
}
checkChild(child);
serverSocket.close();
connectedSocket->close();
cout << "Done!\n";
delete connectedSocket;
return true;
} catch (std::exception& e) {
cout << " Server exception: " << e.what() << endl;
cout << "Failed!\n";
checkChild(child, true);
delete connectedSocket;
return false;
}
}
String Request(const String& r)
{
TcpSocket s;
if(!s.Connect(CommandLine().GetCount() ? CommandLine()[0] : "127.0.0.1", 3214)) {
Cout() << "Unable to connect to server!\n";
SetExitCode(1);
return Null;
}
s.Put(r + '\n');
return s.GetLine();
}
int main()
{
socket.receive(recvChar, 1024, received);
cout << recvChar << endl;
Socket::Status status = socket.connect("localhost", 10006);
socket.send(sendChar, 1024);
return 0;
}
bool TcpSocketServer::update()
{
if (!isValid())
return false;
sockaddr_in clientAddr = { 0 };
socklen_t addrLen = sizeof(clientAddr);
SOCKET accepted = ::accept(_handle, (sockaddr*)&clientAddr, &addrLen);
if (accepted != INVALID_SOCKET)
{
String peerAddr = inet_ntoa(clientAddr.sin_addr);
uint16 peerPort = clientAddr.sin_port;
TcpSocket* client = _listener ? _listener->onAccept(this, accepted, peerAddr, peerPort) : NULL;
if (client == NULL)
{
::closesocket(accepted);
LOG(0, "++ ServerSocket: '%s: %d' refused\n", peerAddr.c_str(), peerPort);
}
else
{
LOG(0, "++ ServerSocket: '%s: %d' accepted\n", peerAddr.c_str(), peerPort);
_clients.insert(client);
}
}
else
{
int err = getLastError();
if (err != ERR_WOULD_BLOCK)
return error("Listen", err);
}
for (Clients::iterator itr = _clients.begin(), end = _clients.end(); itr != end; )
{
TcpSocket* client = *itr;
if (!client->update())
{
if (_listener) _listener->onDisconnected(this, client);
_clients.erase(itr++);
}
else
{
++itr;
}
}
if (_listener) _listener->onUpdate();
return true;
}
bool sendReceiveObjectTest(){
cout << "sendReceiveObjectTest() ...\n";
Object tosend('c', 34, true, "cinco");
pid_t child;
// client code
if ((child=fork())==0){
try {
TcpSocket toServer;
cout << " Forked child waiting a bit\n";
sleep(1);
cout << " Forked child connecting to server\n";
toServer.connect("127.0.0.1",LOCALPORT);
cout << " Forked child connected: " << toServer << endl;
cout << " Forked child sending to server\n";
toServer.write(reinterpret_cast<char *>(&tosend), sizeof(Object));
cout << " Forked child closing connection to server\n";
toServer.close();
cout << " Forked child exiting\n";
exit(0);
} catch (std::exception& e) {
cout << " Forked child exception: " << e.what() << endl;
exit(-1);
}
return false; // for clarity
}
// server code
TcpSocket* connectedSocket;
try {
TcpSocket serverSocket;
connectedSocket = bindListenAccept(LOCALPORT, serverSocket);
std::string clientmessage;
cout << " Reading one object from client\n";
// Read the object
Object received;
int len = connectedSocket->read(reinterpret_cast<char *>(&received), sizeof(Object));
cout << " Read: " << len << " bytes from " << *connectedSocket << endl;
if (!(tosend.compare(received) == 0))
throw std::runtime_error("objects dont match");
cout << " Server read " << received << endl;
checkChild(child);
serverSocket.close();
connectedSocket->close();
cout << "Done!\n";
delete connectedSocket;
return true;
} catch (std::exception& e) {
cout << " Server exception: " << e.what() << endl;
cout << "Failed!\n";
checkChild(child, true);
delete connectedSocket;
return false;
}
}
/**
*函数介绍:回复客户端数据
*输入参数:回复数据QByteArray result,套接字描述符 descriptor
*返回值:无
*/
void TcpServer::replyClientMessage(QByteArray result,int descriptor)
{
TcpSocket *serverSocket;
if(descriptor!=-1)
{
//获得服务端套接字
serverSocket = getServerSocket(descriptor);
//发送数据
if(serverSocket)
serverSocket->sendMessage(result);
qDebug()<<"正在回复数据。。。。。。";
}
}
void Worker::discardClient()
{
TcpSocket* socket = static_cast<TcpSocket*>(sender());
#ifndef NO_LOG
qDebug() << "thread id" << thread()->currentThreadId();
qDebug() << "release socket" << socket << socket->m_id;
//qDebug() << "finish serving client inside" << m_name;
sLog() << m_name << "finished request.";
sLogFlush();
#endif
socket->deleteLater();
m_idleSemaphore.release();
}
bool Accept(TcpSocket& connection, bool blocking = true) const
{
if (!IsListening())
{
throw std::runtime_error("TcpSocket.Accept - Called on a socket that does not have listening mode enabled");
}
auto newSocket = SOCKET(0);
auto address = sockaddr_in();
auto tryAgain = bool();
do
{
tryAgain = false;
if (!Winsock::Accept(socket, address, newSocket))
{
switch (WSAGetLastError())
{
case WSAEWOULDBLOCK:
//if (!IsBlocking())
//{
// throw std::runtime_error("TcpSocket.Accept - Received would-block error for non-blocking socket");
//}
return false;
case WSAECONNRESET:
tryAgain = true;
break;
default:
return false;
}
}
} while (tryAgain);
if (connection.IsOpen())
{
connection.Close();
}
connection.socket = newSocket;
connection.isListening = false;
if (!Winsock::IoctlSocket(connection.socket, blocking))
{
throw std::runtime_error("TcpSocket.Accept - Unable to set blocking mode on new connection");
}
connection.isBlocking = blocking;
return true;
}
void Worker::newSocket(qintptr socket)
{
//qDebug() << m_name << " is handling a new request; thread id" << thread()->currentThreadId();
TcpSocket* s = new TcpSocket(this);
s->m_id = static_cast<unsigned int>(rand());
connect(s, SIGNAL(readyRead()), this, SLOT(readClient()));
connect(s, SIGNAL(disconnected()), this, SLOT(discardClient()));
s->setSocketDescriptor(socket);
s->setTimeout(1000*60*2);
#ifndef NO_LOG
sLog() << m_name << " receive a new request from ip:" << s->peerAddress().toString();
#endif
}
bool SocketTest::tcpSocketTest()
{
SimpleServer server;
server.start();
System::Sleep(500);
TEST_ASSERT(server.start_flag)
TEST_ASSERT_MSG(server.bind_flag, server.msg.text())
TEST_ASSERT_MSG(!server.aborted, server.msg.text())
// create tcp socket
TcpSocket client;
client.connect(TCP_TEST_HOST, TCP_TEST_PORT);
TEST_ASSERT(client.getRemoteAddress().getPort() == TCP_TEST_PORT);
client.send(TEST_MESSAGE1);
TEST_ASSERT_MSG(!server.aborted, server.msg.text())
System::Sleep(100);
TEST_ASSERT_MSG(!server.aborted, server.msg.text())
TEST_ASSERT(server.msg1_flag)
// test if something is already running on a port
Socket psocket;
TEST_THROWS(psocket.bind(TCP_TEST_PORT), Net::Errors::SocketException);
String in;
client.readUntil(in, '!');
TEST_ASSERT(in == TEST_MESSAGE2);
client.readUntil(in, '.', 2000);
TEST_ASSERT_MSG(in == TEST_MESSAGE3, in.text());
client.readUntil(in, '!', 2000);
TEST_ASSERT(in == TEST_MESSAGE4);
client.readUntil(in, "#@", 2000);
TEST_ASSERT(in == TEST_MESSAGE5);
return true;
}
int main(void) {
TcpSocket servSocket;
servSocket.create();
servSocket.connect("127.0.0.1", 9999);
Message msg;
msg.add("type", "login");
msg.add("user", "root");
msg.add("pwd", "root");
servSocket << msg;
servSocket.close();
return 0;
}
void ProtocolSender::sendPackage(const TcpSocket& tcpSocket, const Data& data)
const {
int dataLength = data.getLength();
char digits = Math::countDigits(dataLength);
// Primero envio los digitos de la longitud.
Data digitsData(&digits, 1);
tcpSocket.sendData(digitsData);
// Ahora la longitud en si misma convirtiendo esta a char*.
stringstream ss;
ss << dataLength;
Data length(ss.str().c_str(), (int)digits); // No se envia el '\0'
tcpSocket.sendData(length);
// Finalmente, los datos.
tcpSocket.sendData(data);
}
/**
* Process all received connection from socket.
*
* \param fd opened tcp socket server kfile context.
*
*/
void tcpsocket_serverPoll(KFile *fd)
{
TcpSocket *socket = TCPSOCKET_CAST(fd);
if (!socket->sock)
socket->sock = netconn_accept(socket->server_sock);
if (!socket->sock)
{
LOG_ERR("Unable to connect with client\n");
return;
}
socket->handler(fd);
}
int test_tcp_srv()
{
int ret;
char buf[128] = {0};
TcpSocket tcp_srv;
// open
tcp_srv.open();
tcp_srv.setReuseAddr(1);
tcp_srv.show();
// bind
if (tcp_srv.bind(SocketIpv4Address("0.0.0.0", 8888)) < 0) {
perror("bind");
return -1;
}
tcp_srv.show();
// listen
if (tcp_srv.listen() < 0) {
perror("listen");
return -1;
}
tcp_srv.show();
// accept
TcpSocket *sock = tcp_srv.accept();
sock->show();
while(1) {
ret = sock->recvMsg(buf, sizeof(buf));
if (ret == 0) {
fprintf(stdout, "close the fd[%d]\n", sock->getSocketFd());
break;
} else if (ret < 0) {
perror("read");
break;
}
printf("ret: %d buf: %s\n", ret, buf);
}
tcp_srv.close();
return 0;
}
