bool SocketIOClient::connect(char thehostname[], int theport) { if (!client.connect(thehostname, theport)) return false; hostname = thehostname; port = theport; sendHandshake(hostname); return readHandshake(); }
void AsyncCDDBPLookup::doHandshake() { sendHandshake(); state_ = WaitingForHandshake; }
bool WebSocketClient::connect() { if (_client.connect(_server, _port)) { sendHandshake(); return readHandshake(); } return false; }
bool Nimbits::connectSocket(String points[], int count) { bool result = false; char path[256]; path[0] = '\0'; byte uuidNumber[16]; String pointJson = arrayToJson(points, count); strcat(path, "/socket?token="); strcat(path, _authToken.c_str()); if (count > 0) { strcat(path, "&points="); strcat(path, pointJson.c_str()); } if (ethernetClient.connect(_hostname.c_str(), _port)) { sendHandshake(path); result = readHandshake(); } return result; }
bool XSocketClient::connect(char hostname[], int port) { bool result = false; if (_client.connect(hostname, port)) { sendHandshake(); result = readHandshake(); } return result; }
bool WebSocketClient::connect() { bool result = false; if (_client.connect()) { sendHandshake(); result = readHandshake(); } return result; }
bool SocketIOClient::connect(unsigned int id, char thehostname[], int theport) { ID = id; if (!client.connect(thehostname, theport)) return false; hostname = thehostname; port = theport; sendHandshake(hostname); bool ret = readHandshake(); socketHandshake(); return ret; }
void AmpacheListEngine::run() { QThread::setTerminationEnabled(true); m_stop = false; if (m_updateSourceInfo || m_removeSourceInfo) { return; } //Create media list based on engine argument and filter QList<MediaItem> mediaList; QString engineArg = m_mediaListProperties.engineArg(); QStringList engineFilterList = m_mediaListProperties.engineFilterList(); if (!engineFilterList.isEmpty()) { QString server = m_mediaListProperties.filterFieldValue("server"); QString request = m_mediaListProperties.filterFieldValue("request"); m_pendingRequest["server"] = server; m_pendingRequest["request"] = request; if (request == "root") { QString username = m_mediaListProperties.filterFieldValue("username"); QString key = m_mediaListProperties.filterFieldValue("key"); //Handshake m_pendingRequest["username"] = username; m_pendingRequest["key"] = key; sendHandshake(server, username, key); } else { QString requestUrlStr = server + m_mediaListProperties.filterFieldValue("requestPath"); KUrl requestUrl(requestUrlStr); if (!requestUrl.isEmpty()) { QString targetFile = QString("bangarang/temp/%1").arg(QString("ampacheResult-%1-%2").arg(m_requestSignature, m_subRequestSignature)); KUrl targetUrl = KUrl(KStandardDirs::locateLocal("data", targetFile, true)); connectDownloader(); emit download(requestUrl, targetUrl); } } //Start event loop to wait for feed results exec(); } else { //Return no results m_mediaListProperties.summary = i18np("1 item", "%1 items", mediaList.count()); m_mediaListProperties.type = QString("Categories"); emit results(m_requestSignature, mediaList, m_mediaListProperties, true, m_subRequestSignature); } }
inline void OmniApp::start() { if (mOmni.activeStereo()) { Window::displayMode(Window::displayMode() | Window::STEREO_BUF); } create(); if (mOmni.fullScreen()) { fullScreen(true); cursorHide(true); } if (!bSlave) { if(oscSend().opened()) sendHandshake(); mAudioIO.start(); } Main::get().start(); }
// check if a target is connected, and attempt to connect if not bool VASTnet::validateConnection (id_t host_id) { // if it's message to self or already connected if (_manager->getID () == host_id || _manager->isConnected (host_id) == true) return true; // resolve address of host std::map<id_t, Addr>::iterator it = _id2addr.find (host_id); if (it == _id2addr.end ()) return false; IPaddr &remote_addr = it->second.publicIP; // otherwise try to initiate connection & send handshake message if (_manager->connect (host_id, remote_addr.host, remote_addr.port) == false) return false; sendHandshake (host_id); return true; }
//-------------------------------------------------------------- void ofxMatrixNetworkServer::update() { //for each client lets send them a message letting them know what port they are connected on for(int i = 0; i < getLastID(); i++){ if(isClientConnected(i)){ //if we don't have a string allocated yet: lets create one //if(i >= storeText.size() ){ // storeText.push_back( string() ); //} //if we don't have a string allocated yet: lets create one if(i >= tx_valid.size() ){ tx_valid.push_back(0); } //we only want to update the text we have recieved there is data string str = receive(i); if(str == "handshake"){ ofLog(OF_LOG_NOTICE, "handshake with client " + ofToString(i)); sendHandshake(i); tx_valid[i] = 1; }else if(str.find_first_of("nextframe") != -1){ //ofLog(OF_LOG_NOTICE, "nextframe for client " + ofToString(i) + " - " + str); tx_valid[i] = 2; }else if(str == "disconnect"){ ofLog(OF_LOG_NOTICE, "disconnect client " + ofToString(i)); sendDisconnect(i); disconnectClient(i); tx_valid[i] = 0; } //if(str.length() > 0){ // storeText[i] = str; //} }else{ tx_valid[i] = 0; } } }
void handleCloseHandshake() { if (recvHandshake() == MODE_COMPLETE) sendHandshake(MODE_COMPLETE); }
int startConnection(int port) { if (SendSocket != INVALID_SOCKET || RecvSocket != INVALID_SOCKET) { return 0; } WSADATA wsaData; int iResult; //---------------------- // Initialize Winsock iResult = WSAStartup(MAKEWORD(2, 2), &wsaData); if (iResult != NO_ERROR) { printf("WSAStartup failed with error: %d\n", iResult); return 0; } //--------------------------------------------- // Create a socket for sending data SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (SendSocket == INVALID_SOCKET) { printf("socket failed with error: %ld\n", WSAGetLastError()); closeConnection(); return 0; } //--------------------------------------------- // Create a socket for recving data RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (SendSocket == INVALID_SOCKET) { printf("socket failed with error: %ld\n", WSAGetLastError()); closeConnection(); return 0; } //----------------------------------------------- // Bind the socket to any address and the specified port. SendAddr.sin_family = AF_INET; SendAddr.sin_port = htons(port); SendAddr.sin_addr.s_addr = htonl(INADDR_ANY); iResult = bind(RecvSocket, (SOCKADDR *) & SendAddr, sizeof (SendAddr)); if (iResult != 0) { wprintf(L"bind failed with error %d\n", WSAGetLastError()); closeConnection(); return 0; } //--------------------------------------------- // Set up the RecvAddr structure with the IP address of // the receiver RecvAddr.sin_family = AF_INET; RecvAddr.sin_port = htons(port+1); if (recvHandshake() != MODE_READY) { printf("Sender not ready"); closeConnection(); return 0; } sendHandshake(MODE_READY); // set receive timeout to 1 if (!setTimeout(RecvSocket,-1)) { closeConnection(); return 0; } return 1; }
void GroupClient::retrieveData(GroupSocket *const /* socket */, const Messages message, const QVariantMap &data) { if (message == Messages::STATE_KICKED) { emit messageBox(QString("You got kicked! Reason: %1").arg(data["text"].toString())); stop(); return; } if (socket.getProtocolState() == ProtocolState::AwaitingLogin) { // Login state. either REQ_HANDSHAKE, REQ_LOGIN, or ACK should come if (message == Messages::REQ_HANDSHAKE) { sendHandshake(data); } else if (message == Messages::REQ_LOGIN) { assert(!NO_OPEN_SSL); socket.setProtocolVersion(proposedProtocolVersion); socket.startClientEncrypted(); } else if (message == Messages::ACK) { // aha! logged on! sendMessage(&socket, Messages::REQ_INFO); socket.setProtocolState(ProtocolState::AwaitingInfo); } else { // ERROR: unexpected message marker! // try to ignore? qWarning("(AwaitingLogin) Unexpected message marker. Trying to ignore."); } } else if (socket.getProtocolState() == ProtocolState::AwaitingInfo) { // almost connected. awaiting full information about the connection if (message == Messages::UPDATE_CHAR) { emit scheduleAction(new AddCharacter(data)); } else if (message == Messages::STATE_LOGGED) { socket.setProtocolState(ProtocolState::Logged); } else if (message == Messages::REQ_ACK) { sendMessage(&socket, Messages::ACK); } else { // ERROR: unexpected message marker! // try to ignore? qWarning("(AwaitingInfo) Unexpected message marker. Trying to ignore."); } } else if (socket.getProtocolState() == ProtocolState::Logged) { if (message == Messages::ADD_CHAR) { emit scheduleAction(new AddCharacter(data)); } else if (message == Messages::REMOVE_CHAR) { emit scheduleAction(new RemoveCharacter(data)); } else if (message == Messages::UPDATE_CHAR) { emit scheduleAction(new UpdateCharacter(data)); } else if (message == Messages::RENAME_CHAR) { emit scheduleAction(new RenameCharacter(data)); } else if (message == Messages::GTELL) { emit gTellArrived(data); } else if (message == Messages::REQ_ACK) { sendMessage(&socket, Messages::ACK); } else { // ERROR: unexpected message marker! // try to ignore? qWarning("(Logged) Unexpected message marker. Trying to ignore."); } } }
void *handleClient(void *args) { pthread_detach(pthread_self()); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); pthread_cleanup_push(&cleanup_client, args); int buffer_length = 0, string_length = 1, reads = 1; ws_client *n = args; n->thread_id = pthread_self(); pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); char buffer[BUFFERSIZE]; n->string = (char *) malloc(sizeof(char)); if (n->string == NULL) { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); handshake_error("Couldn't allocate memory.", ERROR_INTERNAL, n); pthread_exit((void *) EXIT_FAILURE); } printf("Client connected with the following information:\n" "\tSocket: %d\n" "\tAddress: %s\n\n", n->socket_id, (char *) n->client_ip); printf("Checking whether client is valid ...\n\n"); fflush(stdout); /** * Getting headers and doing reallocation if headers is bigger than our * allocated memory. */ do { memset(buffer, '\0', BUFFERSIZE); if ((buffer_length = recv(n->socket_id, buffer, BUFFERSIZE, 0)) <= 0){ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); handshake_error("Didn't receive any headers from the client.", ERROR_BAD, n); pthread_exit((void *) EXIT_FAILURE); } if (reads == 1 && strlen(buffer) < 14) { handshake_error("SSL request is not supported yet.", ERROR_NOT_IMPL, n); pthread_exit((void *) EXIT_FAILURE); } string_length += buffer_length; char *tmp = realloc(n->string, string_length); if (tmp == NULL) { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); handshake_error("Couldn't reallocate memory.", ERROR_INTERNAL, n); pthread_exit((void *) EXIT_FAILURE); } n->string = tmp; tmp = NULL; memset(n->string + (string_length-buffer_length-1), '\0', buffer_length+1); memcpy(n->string + (string_length-buffer_length-1), buffer, buffer_length); reads++; } while( strncmp("\r\n\r\n", n->string + (string_length-5), 4) != 0 && strncmp("\n\n", n->string + (string_length-3), 2) != 0 && strncmp("\r\n\r\n", n->string + (string_length-8-5), 4) != 0 && strncmp("\n\n", n->string + (string_length-8-3), 2) != 0 ); printf("User connected with the following headers:\n%s\n\n", n->string); fflush(stdout); ws_header *h = header_new(); if (h == NULL) { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); handshake_error("Couldn't allocate memory.", ERROR_INTERNAL, n); pthread_exit((void *) EXIT_FAILURE); } n->headers = h; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); if ( parseHeaders(n->string, n, port) < 0 ) { pthread_exit((void *) EXIT_FAILURE); } if ( sendHandshake(n) < 0 && n->headers->type != UNKNOWN ) { pthread_exit((void *) EXIT_FAILURE); } list_add(l, n); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); printf("Client has been validated and is now connected\n\n"); printf("> "); fflush(stdout); uint64_t next_len = 0; char next[BUFFERSIZE]; memset(next, '\0', BUFFERSIZE); while (1) { if ( communicate(n, next, next_len) != CONTINUE) { break; } pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); if (n->headers->protocol == CHAT) { list_multicast(l, n); } else if (n->headers->protocol == ECHO) { list_multicast_one(l, n, n->message); } else { list_multicast_one(l, n, n->message); } pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); if (n->message != NULL) { memset(next, '\0', BUFFERSIZE); memcpy(next, n->message->next, n->message->next_len); next_len = n->message->next_len; message_free(n->message); free(n->message); n->message = NULL; } } printf("Shutting client down..\n\n"); printf("> "); fflush(stdout); pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); list_remove(l, n); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_cleanup_pop(0); pthread_exit((void *) EXIT_SUCCESS); }
ConnectionState Connection::update(double time) { // if CLOSED or CONNECTED, nothing happens // if CONNECTING or HANDSHAKING, incomming packets are proccessed for update Address sender; int size; switch(state) { case CONNECTING: // accept only connectionResponse (and get its connectionId) while (size = socket.receive(sender,buffer, NSL_MAX_UDP_PACKET_SIZE)) { if (size != 6) { continue; } // reset buffer stream bufferStream->resetStream(size); if (bufferStream->read<uint16>() != applicationId) { continue; } connectionId = bufferStream->read<int32>(); state = HANDSHAKING; sendHandshake(time); return state; } if (lastRequest + NSL_TIMEOUT_CLIENT_CONNECTION_REQUEST < time) { sendConnectionRequest(time); } break; case HANDSHAKING: // accept only handshakeResponse (and get its status) while (size = socket.receive(sender,buffer,NSL_MAX_UDP_PACKET_SIZE)) { if (size < 7) { continue; } // reset buffer stream bufferStream->resetStream(size); if (bufferStream->read<uint16>() != applicationId) { continue; } if (bufferStream->read<uint32>() != connectionId) { continue; } // process handshake response switch (bufferStream->readByte()) { case NSL_CONNECTION_FLAG_DISCONNECT: state = CLOSED; return state; case NSL_CONNECTION_FLAG_UPDATE: state = CONNECTED; bufferedMessage = bufferStream->createSubreader(size - 7, true); return state; case NSL_CONNECTION_FLAG_COMPRESSED_UPDATE: state = CONNECTED; #ifdef NSL_COMPRESS bufferedMessage = decompressStream(bufferStream); #else throw Exception(NSL_EXCEPTION_LIBRARY_ERROR, "NSL: Compressed update was received from server, but compression is turned of on client"); #endif return state; default: throw Exception(NSL_EXCEPTION_LIBRARY_ERROR, "NSL: protocol error, received not expected data."); } } if (lastRequest + NSL_TIMEOUT_CLIENT_HANDSHAKE < time) { sendHandshake(time); } break; case CLOSED: // throw away all incomming packets so they will not mess later while (size = socket.receive(sender,buffer,NSL_MAX_UDP_PACKET_SIZE)) {} default: break; } return state; }