void CMyTcpServer::incomingConnection( int socketDescriptor ) { // client endpoint / connectToHost CPeerSocket* pSocket = new CPeerSocket( this ); pSocket->setSocketDescriptor( socketDescriptor ); //addPendingConnection( pSocket ); connect( pSocket, SIGNAL( disconnected( ) ), this, SLOT( HandleDisconnect( ) ) ); if ( GetMgmtTCPFlag( ) ) { connect( pSocket, SIGNAL( readyRead( ) ), this, SLOT( GetMgmtStream( ) ) ); } else { connect( pSocket, SIGNAL( readyRead( ) ), this, SLOT( GetStream( ) ) ); } connect( pSocket, SIGNAL( error( QAbstractSocket::SocketError ) ), this, SLOT( TcpError( QAbstractSocket::SocketError ) ) ); QString strKey; QString strMsg; GetKeyMsg( pSocket, strKey, strMsg, true ); clientHash.insert( strKey, pSocket ); emit NotifyMessage( strMsg ); }
quint64 CTcpClient::SendData( const QByteArray & byteArray ) { HandleDisconnect( ); quint64 nRet = 0; int nPackageSize = 10 * 1024 * 1024; int nTotalSize = byteArray.count( ); int nMode = nTotalSize / nPackageSize; int nSurplus = nTotalSize % nPackageSize; const char* pData = byteArray.data( ); const char* pPkgData = NULL; if ( 0 == nMode ) { // < 10M nRet += write( byteArray ); } else { // >= 10M int nIndex = 0; for ( nIndex = 0; nIndex < nMode; nIndex++ ) { pPkgData = ( pData + nIndex * nPackageSize ); nRet += write( pPkgData, nPackageSize ); } if ( 0 != nSurplus ) { pPkgData = ( pData + nIndex * nPackageSize ); nRet += write( pPkgData, nSurplus ); } } if ( !flush( ) ) { waitForBytesWritten( ); } return nRet; }
void CTcpClient::TcpError( QAbstractSocket::SocketError socketError ) { QString strMsg; CNetCommFunction::GetErrorMsg( strMsg, socketError, this ); strMsg = "Tcp socket :\r\n" + strMsg; emit NotifyMessage( strMsg ); HandleDisconnect( ); }
CTcpClient::CTcpClient(QObject *parent) : QTcpSocket(parent) { pData = NULL; Clear( ); pData = new QByteArray( ); pTextCodec = NULL; connect( this, SIGNAL( disconnected( ) ), this, SLOT( HandleDisconnect( ) ) ); connect( this, SIGNAL( error( QAbstractSocket::SocketError ) ), this, SLOT( TcpError( QAbstractSocket::SocketError ) ) ); }
TcpEdge::TcpEdge(const Address &local, const Address &remote, bool outgoing, QTcpSocket *socket) : Edge(local, remote, outgoing), _socket(socket, &QObject::deleteLater) { socket->setParent(0); socket->setSocketOption(QAbstractSocket::KeepAliveOption, 1); QObject::connect(socket, SIGNAL(readyRead()), this, SLOT(Read())); QObject::connect(socket, SIGNAL(disconnected()), this, SLOT(HandleDisconnect())); QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(HandleError(QAbstractSocket::SocketError))); }
void ConnectionManager::CreateConnection(const QSharedPointer<Edge> &pedge, const Id &rem_id) { QSharedPointer<Connection> con(new Connection(pedge, _local_id, rem_id), &QObject::deleteLater); con->SetSharedPointer(con); _con_tab.AddConnection(con); qDebug() << "Handle new connection:" << con->ToString(); QObject::connect(con.data(), SIGNAL(CalledDisconnect()), this, SLOT(HandleDisconnect())); QObject::connect(con.data(), SIGNAL(Disconnected(const QString &)), this, SLOT(HandleDisconnected(const QString &))); emit NewConnection(con); }
bool NetServer::ServerStep() { // use lastTic to keep track of how many tics per second we have; control "tics per second" // perform any periodic, timed events here ENetEvent event; int status = enet_host_service(server, &event, HOST_TIMEOUT); if (status < 0) return false; // ERROR happened! Server shut down! TimedEvent(); if (status == 0) return true; // nothing to do, try again later switch(event.type) { case ENET_EVENT_TYPE_CONNECT: { printf ("A new client (%d) connected from %x:%u.\n", event.peer, event.peer -> address.host, event.peer -> address.port); client *c = new client; char hostname[256] = "error"; enet_address_get_host_ip(&event.peer->address, hostname, 256); printf("%s connected\n", hostname); if (event.peer != master) { c->hostname = string(hostname); c->peer = event.peer; c->state = ST_AUTH; // associate peer with the client object for them event.peer->data = c; // Call HandleConnect method of the game logic // if it returns false, then that means connection denied, otherwise specifies state client is in // also add to list of clients if (HandleConnect(event.peer)) { bool client_added = false; for (size_t i = 0; i < clients.size(); i++) { if (clients.at(i)->state == ST_EMPTY) { clients.at(i) = c; client_added = true; break; } } if (!client_added) clients.push_back(c); } else { enet_peer_disconnect(event.peer, 121); } } else { MasterCheckin(); } break; } case ENET_EVENT_TYPE_DISCONNECT: { if (event.peer != master) { printf ("%d disconnected.\n", event.peer); // Call HandleDisconnect method some form of id for the connection HandleDisconnect(323, event.peer); // free up this client slot for reuse ((client*) event.peer->data)->state = ST_EMPTY; } else { printf ("Master timed out.\n"); master = 0; } break; } case ENET_EVENT_TYPE_RECEIVE: { char hostname[256] = "error"; enet_address_get_host_ip(&event.peer->address, hostname, 256); printf("receiving packet.\n"); printf ("A packet of length %u ", event.packet -> dataLength); printf("containing %s ", event.packet -> data); printf("was received from %s ", hostname); printf("on channel %u.\n", event.channelID); /*printf ("A packet of length %u containing %s was received from %s on channel %u.\n", event.packet -> dataLength, event.packet -> data, ((client*)event.peer -> data)->hostname.c_str(), event.channelID);*/ client *c = (client*) event.peer->data; // Call Packet Handler to deal with packets, and send a response HandlePacket(event.packet->data, event.packet->dataLength, event.peer); if (event.packet->referenceCount == 0) enet_packet_destroy(event.packet); break; } default: break; } enet_host_flush(server); return true; }
// Update void _Server::Update(double FrameTime) { //if(std::abs(std::fmod(Time, 1.0)) >= 0.99) // std::cout << "Server: O=" << ObjectManager->Objects.size() << " B=" << BattleManager->Objects.size() << std::endl; // Update network Network->Update(FrameTime); // Get events _NetworkEvent NetworkEvent; while(Network->GetNetworkEvent(NetworkEvent)) { switch(NetworkEvent.Type) { case _NetworkEvent::CONNECT: HandleConnect(NetworkEvent); break; case _NetworkEvent::DISCONNECT: HandleDisconnect(NetworkEvent); break; case _NetworkEvent::PACKET: HandlePacket(*NetworkEvent.Data, NetworkEvent.Peer); delete NetworkEvent.Data; break; } } // Update objects ObjectManager->Update(FrameTime); // Spawn battles for(auto &BattleEvent : BattleEvents) StartBattle(BattleEvent); BattleEvents.clear(); // Update maps MapManager->Update(FrameTime); // Update battles BattleManager->Update(FrameTime); // Check if updates should be sent if(Network->NeedsUpdate()) { Network->ResetUpdateTimer(); if(Network->GetPeers().size() > 0) { // Send object updates for(auto &Map : MapManager->Objects) { Map->SendObjectUpdates(); } } } // Wait for peers to disconnect if(StartDisconnect) { Network->DisconnectAll(); StartDisconnect = false; StartShutdown = true; } else if(StartShutdown && Network->GetPeers().size() == 0) { Done = true; } TimeSteps++; Time += FrameTime; // Update scripting environment Scripting->InjectTime(Time); // Update clock Clock += FrameTime * MAP_CLOCK_SPEED; if(Clock >= MAP_DAY_LENGTH) Clock -= MAP_DAY_LENGTH; // Update autosave SaveTime += FrameTime; if(SaveTime >= DEFAULT_AUTOSAVE_PERIOD) { SaveTime = 0; // Save players for(auto &Object : ObjectManager->Objects) { Save->SavePlayer(Object); } } }
////////////////////////////////////////////////////////////////////// // This is the high level download function for the Download Mode. // // Inputs: Fuses (platformsettings) and the TIM. // Outputs: Returns a pointer to the next image which we will transfer // control to. // // It mainly determines the download mode (TIM or FBF) and calls the // appropriate download routine. ////////////////////////////////////////////////////////////////////// pIMAGE_INFO_3_4_0 DetermineModeAndDownload( pFUSE_SET pFuses, pTIM pTIM_h ) { pIMAGE_INFO_3_4_0 pBootImageInfo = NULL; FUNC_STATUS fs_Retval; volatile pProtocolISR pPortInterrupt; volatile pProtocolCmd pCommand; int start_time =0, cur_time=0; fs_Retval.ErrorCode = GeneralError; #if ZIMI_PB05 int mTimeOut; extern UINT_T back_image_key; if(back_image_key) //Onkey + reset mTimeOut =4; else mTimeOut =1; #endif InitDefaultPort( pFuses ); //time_count_enable = 0; // The download port is opened. Get all the images and burn them to flash. // Start by trying to get a TIM followed by individual files. // If that fails, then try getting an FBF bundle. // If that fails as well, then treat this a a fatal error. start_time = GetOSCR0(); do { pPortInterrupt = getProtocolISR(); if(time_count_enable) { cur_time = GetOSCR0(); if(OSCR0IntervalInSec(start_time, cur_time) >mTimeOut) //xyl define { pBootImageInfo = NULL; goto shutdown; } } if (upload_times == 0) { goto disconnect; // no upload any more } if(pPortInterrupt->PreambleReceived == FALSE) { #if I2C resetTimer(); // reset charger 32s timer for key pressed download #endif fs_Retval.ErrorCode = SeqError; continue; } time_count_enable= 0; start_time = GetOSCR0(); while (pPortInterrupt->CommandReceived == FALSE) { cur_time = GetOSCR0(); if(OSCR0IntervalInSec(start_time, cur_time) > PROTOCOL_WAITTIME) //wait for command { pBootImageInfo = NULL; goto shutdown; } } pCommand = getProtocolCmd(); switch(pCommand->Command) { case GetVersionCmd: // Used to differentiate from UPLOAD. isDownload = TRUE; #if I2C #if OLED_SUPPORT || LED_DISPLAY SoftwareUpgrade_Start(); #endif #endif // Request the TIM first as originally implemented. // The new TIM is stored at pTIM_h->pConstTIM. // USB DMA can not access SQU, so OBM download DKB_NTIM to DDR, and then copy it to SQU // it will be fixed on Y0 board fs_Retval = HandleRequest( DDR_DOWNLOAD_AREA_ADDR, TIMIDENTIFIER ); //fs_Retval = HandleRequest( (UINT_T)pTIM_h->pConsTIM, TIMIDENTIFIER ); if (fs_Retval.ErrorCode == NoError) { // Before we call the TIM Download function which actually does the downloading, // copy the tim from its download location to its load address. memcpy(pTIM_h->pConsTIM, DDR_DOWNLOAD_AREA_ADDR, 1024); // pTIM_h is the newly downloaded TIM. // It has a list of all the images that need to be downloaded and burned. // The DownloadImages function will use DDR to hold the images while writing them to flash. pBootImageInfo = TIMDownloadMain( pTIM_h ); } else // download failed { FatalError(fs_Retval.ErrorCode); } break; case UploadDataHeaderCmd: // UPLOAD_DATA_AREA is in DDR // upload size limitted 0x1d00000 - 0x1000 fs_Retval = HandleRequest( (UINT_T)UPLOAD_DATA_AREA, NULL); if (fs_Retval.ErrorCode == NoError) // upload successfully { upload_times--; fs_Retval.ErrorCode = GeneralError; // wait for next upload upload_nand_spare = FALSE; // clear it } else // upload failed { FatalError(fs_Retval.ErrorCode); } // Does not matter if we had an error. Boot anyway. break; default: unknown_protocol_command(getProtocolCmd()); FatalError(UnknownProtocolCmd); } }while (fs_Retval.ErrorCode != NoError); disconnect: HandleDisconnect(); shutdown: ShutdownPort(CI2_USB_D); return pBootImageInfo; }
quint64 CTcpClient::SendData( const char * data, qint64 maxSize ) { HandleDisconnect( ); return write( data, maxSize ); }