/**
* get client state
* @param client WSclient_t * ptr to the client struct
* @return true = connected
*/
bool WebSocketsServer::clientIsConnected(WSclient_t * client) {
if(!client->tcp) {
return false;
}
if(client->tcp->connected()) {
if(client->status != WSC_NOT_CONNECTED) {
return true;
}
} else {
// client lost
if(client->status != WSC_NOT_CONNECTED) {
DEBUG_WEBSOCKETS("[WS-Server][%d] client connection lost.\n", client->num);
// do cleanup
clientDisconnect(client);
}
}
if(client->tcp) {
// do cleanup
DEBUG_WEBSOCKETS("[WS-Server][%d] client list cleanup.\n", client->num);
clientDisconnect(client);
}
return false;
}
/**
* get client state
* @param client WSclient_t * ptr to the client struct
* @return true = conneted
*/
bool WebSocketsClient::clientIsConnected(WSclient_t * client) {
if(!client->tcp) {
return false;
}
if(client->tcp->connected()) {
if(client->status != WSC_NOT_CONNECTED) {
return true;
}
} else {
// client lost
if(client->status != WSC_NOT_CONNECTED) {
DEBUG_WEBSOCKETS("[WS-Client] connection lost.\n");
// do cleanup
clientDisconnect(client);
}
}
if(client->tcp) {
// do cleanup
clientDisconnect(client);
}
return false;
}
int acquireBlockLocks(char* serviceName, int servicePort, char* fileName,
int numLocks, int64_t startBlocks[], int64_t lengths[]) {
int i;
int lockID;
MessageClient client = newClient(serviceName, servicePort);
Message m = newMessage();
m->type = FILE_LOCK_CLIENT_SERVICE_CLIENT_MESSAGE;
setStringParam(m, "functionName", "acquireblock");
setStringParam(m, "fileName", fileName);
setIntegerParam(m, "numLocks", numLocks);
createLongArrayParam(m, "startblocks", numLocks);
createLongArrayParam(m, "lengths", numLocks);
for (i = 0; i < numLocks; ++i) {
setLongArrayParamValue(m, "startblocks", i, startBlocks[i]);
setLongArrayParamValue(m, "lengths", i, lengths[i]);
}
//printf("acquireblocklocks: Message to be sent:\n");
//printMessage(m);
Message reply = clientCall(client, m);
clientDisconnect(client);
//printf("acquirelocks: Reply:\n");
//printMessage(reply);
lockID = getIntegerParam(reply, "lockID");
destroyMessage(m);
destroyMessage(reply);
return lockID;
}
void EventMachineThread::clientConnect()
{
qDebug() << "New connection!";
QTcpSocket* client = m_server->nextPendingConnection();
connect(client, SIGNAL(disconnected()), this, SLOT(clientDisconnect()));
connect(client, SIGNAL(readyRead()), this, SLOT(readEvents()));
m_sockets.push_back(client);
}
OOClient::OOClient(QString host, quint16 port, QObject* parent)
: QObject(parent),
m_host(host),
m_port(port),
m_connected(false)
{
connect(&m_client, SIGNAL(connected()), this, SLOT(clientConnect()));
connect(&m_client, SIGNAL(disconnect()), this, SLOT(clientDisconnect()));
//connect(&m_client, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(errorHandler(QAbstractSocket::SocketError)));
//connect(&m_client, SIGNAL(hostFound()), this, SLOT(hostFound()));
}
/**
* get client state
* @param client WSclient_t * ptr to the client struct
* @return true = conneted
*/
bool WebSocketsServer::clientIsConnected(WSclient_t * client) {
if(client->status != WSC_NOT_CONNECTED && client->tcp.connected()) {
return true;
}
if(client->status != WSC_NOT_CONNECTED) {
// cleanup
clientDisconnect(client);
}
return false;
}
void TcpServer::disconnect(int clientID, QString ip, int port)
{
for(int i = 0; i < m_clientNum; i++)
{
if(m_clientList[i]->getClientID() == clientID)
{
m_clientList.removeAt(i);
i--;
m_clientNum--;
emit clientDisconnect(clientID, ip, port);
break;
}
}
}
int main( int argc, char *argv[] ) {
clientSocket cSocket;
destSpec dest;
userOpts option = OPT_NOSELECTION;
unsigned char data[MAXDATASIZE];
size_t dataLen;
//processInputParams( argc, argv, dest );
dest.addr = "127.0.0.1";
dest.port = "3000";
// printf( "Here\n" );
if( clientConnect( &cSocket, &dest ) == -1 ) {
perror( "clientConnect" );
return 1;
}
// printf( "Here2\n" );
while( option != OPT_QUIT ) {
//Do stuff
if( option != OPT_NOSELECTION ) {
if( clientSendOpt( &cSocket, option, data, dataLen ) == -1 ) {
perror( "clientSendOpt" );
return 1;
}
}
if( option == OPT_RECV ) {
if( clientWaitForFile( &cSocket, data, dataLen ) == -1 ) { //Wait for the server's response, store it in the filename still specified in data
perror( "ClientWaitForFile Error" );
}
}
if( queryUser( &option, data, MAXDATASIZE, &dataLen ) == -1 ) {
perror( "queryUser" );
return 1;
}
}
// printf( "Here3\n" );
clientSendOpt( &cSocket, option, NULL, 0 ); //Let the server know
clientDisconnect( &cSocket );
return 0;
}
void releaseBlockLocks(char* serviceName, int servicePort,
char* fileName, int lockID) {
MessageClient client = newClient(serviceName, servicePort);
Message m = newMessage();
m->type = FILE_LOCK_CLIENT_SERVICE_CLIENT_MESSAGE;
setStringParam(m, "functionName", "releaseblock");
setStringParam(m, "fileName", fileName);
setIntegerParam(m, "lockID", lockID);
Message reply = clientCall(client, m);
clientDisconnect(client);
destroyMessage(m);
destroyMessage(reply);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
/*-------变量初始化----------*/
ServerIsStart = false;
/*-------实例化--------------*/
Server = new Tcpserver();
/*-------信号槽关联----------*/
connect(Server,SIGNAL(newconect(QString)),this,SLOT(newconnectWrite2ui(QString)));
connect(Server,SIGNAL(signal_clientDisconnect()),this,SLOT(clientDisconnect()));
}
void jus::Service::callBinary(uint32_t _transactionId, jus::Buffer& _obj) {
if (_obj.getType() == jus::Buffer::typeMessage::event) {
/*
std::string event = _obj["event"].toString().get();
if (event == "IS-ALIVE") {
// Gateway just aswer a keep alive information ...
// Nothing to do ...
} else {
JUS_ERROR("Unknow event: '" << event << "'");
}
*/
JUS_ERROR("Unknow event: '...'");
return;
}
if (_obj.getType() == jus::Buffer::typeMessage::answer) {
JUS_ERROR("Local Answer: '...'");
return;
}
//if (_obj.getType() == jus::Buffer::typeMessage::event) {
uint32_t clientId = _obj.getClientId();
std::string callFunction = _obj.getCall();
if (callFunction[0] == '_') {
if (callFunction == "_new") {
std::string userName = _obj.getParameter<std::string>(0);
std::string clientName = _obj.getParameter<std::string>(1);
std::vector<std::string> clientGroup = _obj.getParameter<std::vector<std::string>>(2);
clientConnect(clientId, userName, clientName, clientGroup);
} else if (callFunction == "_delete") {
clientDisconnect(clientId);
}
m_interfaceClient->answerValue(_transactionId, true, clientId);
return;
} else if (isFunctionAuthorized(clientId, callFunction) == true) {
callBinary2(_transactionId, clientId, callFunction, _obj);
return;
} else {
m_interfaceClient->answerError(_transactionId, "NOT-AUTHORIZED-FUNCTION", "", clientId);
return;
}
}
void AbstractServer::slotClientDisconnect() {
QTcpSocket* pClientSocket = (QTcpSocket*)sender();
qDebug() << tr("AbstractServer::slotClientDisconnect()# client ") << pClientSocket->socketDescriptor();
emit clientDisconnect(pClientSocket->socketDescriptor());
}
/**
* handle the WebSocket header reading
* @param client WSclient_t * ptr to the client struct
*/
void WebSocketsServer::handleHeader(WSclient_t * client) {
String headerLine = client->tcp.readStringUntil('\n');
headerLine.trim(); // remove \r
if(headerLine.length() > 0) {
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] RX: %s\n", client->num, headerLine.c_str());
// websocket request starts allways with GET see rfc6455
if(headerLine.startsWith("GET ")) {
// cut URL out
client->cUrl = headerLine.substring(4, headerLine.indexOf(' ', 4));
} else if(headerLine.startsWith("Connection: ")) {
// 12 = lenght of "Connection: "
if(headerLine.indexOf("Upgrade", 12)) {
client->cIsUpgrade = true;
}
} else if(headerLine.startsWith("Upgrade: ")) {
// 9 = lenght of "Upgrade: "
String low = headerLine.substring(9);
low.toLowerCase();
if(low == "websocket") {
client->cIsWebsocket = true;
}
} else if(headerLine.startsWith("Sec-WebSocket-Version: ")) {
// 23 = lenght of "Sec-WebSocket-Version: "
client->cVersion = headerLine.substring(23).toInt();
} else if(headerLine.startsWith("Sec-WebSocket-Key: ")) {
// 19 = lenght of "Sec-WebSocket-Key: "
client->cKey = headerLine.substring(19);
client->cKey.trim(); // see rfc6455
} else if(headerLine.startsWith("Sec-WebSocket-Protocol: ")) {
// 24 = lenght of "Sec-WebSocket-Protocol: "
client->cProtocol = headerLine.substring(24);
} else if(headerLine.startsWith("Sec-WebSocket-Extensions: ")) {
// 26 = lenght of "Sec-WebSocket-Extensions: "
client->cExtensions = headerLine.substring(26);
}
} else {
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Header read fin.\n", client->num);
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cURL: %s\n", client->num, client->cUrl.c_str());
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cIsUpgrade: %d\n", client->num, client->cIsUpgrade);
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cIsWebsocket: %d\n", client->num, client->cIsWebsocket);
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cKey: %s\n", client->num, client->cKey.c_str());
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cProtocol: %s\n", client->num, client->cProtocol.c_str());
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cExtensions: %s\n", client->num, client->cExtensions.c_str());
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - cVersion: %d\n", client->num, client->cVersion);
bool ok = (client->cIsUpgrade && client->cIsWebsocket);
if(ok) {
if(client->cUrl.length() == 0) {
ok = false;
}
if(client->cKey.length() == 0) {
ok = false;
}
if(client->cVersion != 13) {
ok = false;
}
}
if(ok) {
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] Websocket connection incomming.\n", client->num);
// generate Sec-WebSocket-Accept key
String sKey = acceptKey(client->cKey);
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] - sKey: %s\n", client->num, sKey.c_str());
client->status = WSC_CONNECTED;
client->tcp.write("HTTP/1.1 101 Switching Protocols\r\n"
"Server: arduino-WebSocketsServer\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Version: 13\r\n"
"Sec-WebSocket-Accept: ");
client->tcp.write(sKey.c_str(), sKey.length());
client->tcp.write("\r\n");
if(client->cProtocol.length() > 0) {
// todo add api to set Protocol of Server
client->tcp.write("Sec-WebSocket-Protocol: arduino\r\n");
}
// header end
client->tcp.write("\r\n");
// send ping
WebSockets::sendFrame(client, WSop_ping);
if(_cbEvent) {
_cbEvent(client->num, WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length());
}
} else {
DEBUG_WEBSOCKETS("[WS-Server][%d][handleHeader] no Websocket connection close.\n", client->num);
client->tcp.write("HTTP/1.1 400 Bad Request\r\n"
"Server: arduino-WebSocket-Server\r\n"
"Content-Type: text/plain\r\n"
"Content-Length: 32\r\n"
"Connection: close\r\n"
"Sec-WebSocket-Version: 13\r\n"
"\r\n"
"This is a Websocket server only!");
clientDisconnect(client);
}
}
}
/**
* handle the WebSocket header reading
* @param client WSclient_t * ptr to the client struct
*/
void WebSocketsClient::handleHeader(WSclient_t * client, String * headerLine) {
headerLine->trim(); // remove \r
if(headerLine->length() > 0) {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] RX: %s\n", headerLine->c_str());
if(headerLine->startsWith("HTTP/1.")) {
// "HTTP/1.1 101 Switching Protocols"
client->cCode = headerLine->substring(9, headerLine->indexOf(' ', 9)).toInt();
} else if(headerLine->indexOf(':')) {
String headerName = headerLine->substring(0, headerLine->indexOf(':'));
String headerValue = headerLine->substring(headerLine->indexOf(':') + 2);
if(headerName.equalsIgnoreCase("Connection")) {
if(headerValue.equalsIgnoreCase("upgrade")) {
client->cIsUpgrade = true;
}
} else if(headerName.equalsIgnoreCase("Upgrade")) {
if(headerValue.equalsIgnoreCase("websocket")) {
client->cIsWebsocket = true;
}
} else if(headerName.equalsIgnoreCase("Sec-WebSocket-Accept")) {
client->cAccept = headerValue;
client->cAccept.trim(); // see rfc6455
} else if(headerName.equalsIgnoreCase("Sec-WebSocket-Protocol")) {
client->cProtocol = headerValue;
} else if(headerName.equalsIgnoreCase("Sec-WebSocket-Extensions")) {
client->cExtensions = headerValue;
} else if(headerName.equalsIgnoreCase("Sec-WebSocket-Version")) {
client->cVersion = headerValue.toInt();
}
} else {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header error (%s)\n", headerLine->c_str());
}
(*headerLine) = "";
#if (WEBSOCKETS_NETWORK_TYPE == NETWORK_ESP8266_ASYNC)
client->tcp->readStringUntil('\n', &(client->cHttpLine), std::bind(&WebSocketsClient::handleHeader, this, client, &(client->cHttpLine)));
#endif
} else {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Header read fin.\n");
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Client settings:\n");
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cURL: %s\n", client->cUrl.c_str());
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cKey: %s\n", client->cKey.c_str());
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Server header:\n");
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cCode: %d\n", client->cCode);
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cIsUpgrade: %d\n", client->cIsUpgrade);
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cIsWebsocket: %d\n", client->cIsWebsocket);
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cAccept: %s\n", client->cAccept.c_str());
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cProtocol: %s\n", client->cProtocol.c_str());
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cExtensions: %s\n", client->cExtensions.c_str());
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] - cVersion: %d\n", client->cVersion);
bool ok = (client->cIsUpgrade && client->cIsWebsocket);
if(ok) {
switch(client->cCode) {
case 101: ///< Switching Protocols
break;
case 403: ///< Forbidden
// todo handle login
default: ///< Server dont unterstand requrst
ok = false;
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] serverCode is not 101 (%d)\n", client->cCode);
clientDisconnect(client);
break;
}
}
if(ok) {
if(client->cAccept.length() == 0) {
ok = false;
} else {
// generate Sec-WebSocket-Accept key for check
String sKey = acceptKey(client->cKey);
if(sKey != client->cAccept) {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Sec-WebSocket-Accept is wrong\n");
ok = false;
}
}
}
if(ok) {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] Websocket connection init done.\n");
headerDone(client);
runCbEvent(WStype_CONNECTED, (uint8_t *) client->cUrl.c_str(), client->cUrl.length());
} else {
DEBUG_WEBSOCKETS("[WS-Client][handleHeader] no Websocket connection close.\n");
client->tcp->write("This is a webSocket client!");
clientDisconnect(client);
}
}
}
