bool L2Game_CharacterDelete::parse( L2_VERSION ver ) { ver = L2_VERSION_T1; if( getPacketType() != 0x0D ) return false; p_charSlot = readD(); return true; }
bool L2Login_PlayFail::parse( L2_VERSION ver /*= L2_VERSION_T1*/ ) { UNREFERENCED_PARAMETER(ver); if( getPacketType() != 0x06 ) return false; if( !canReadBytes(1) ) return false; p_reasonCode = readUChar(); return true; }
bool L2Login_LoginOK::parse( L2_VERSION ver /*= L2_VERSION_T23*/ ) { UNREFERENCED_PARAMETER(ver); if( getPacketType() != 0x03 ) return false; if( !canReadBytes( 8 ) ) return false; // we need at least 8 bytes of sessionKey1 readBytes( p_sessionKey1, 8 ); // ignore the rest return true; }
uint8_t *getPacketHash(Packet *pkt, int i) { int type = getPacketType(pkt); if(type == 0 || type == 1){ //WHOHAS and IHAVE return pkt->payload + 20 + SHA1_HASH_SIZE * i; } else if (type == 2){ //GET return pkt->payload + 16 + SHA1_HASH_SIZE * i; } else { return NULL; } }
uint32_t ControlPacket::getControlInfo(uint32_t *information, int &size) { if (getPacketType() == HANDSHAKE && information) { *information++ = *m_Version; *information++ = *m_Type; *information++ = *m_ISN; *information++ = *m_MSS; *information++ = *m_FlightFlagSize; *information++ = *m_ReqType; size = 6; return 1; } else if (getPacketType() == ACK && information) { *information++ = *m_packetSeq; *information++ = *m_RTT; *information++ = *m_RTTVar; *information++ = *m_availBuffer; *information++ = *m_packRecvRate; *information++ = *m_linkCap; size = 6; return 1; } else if (getPacketType() == NAK && information) { *information++ = *m_LossInfo; size = 1; return 1; } else if (getPacketType() == DropRequest && information) { *information++ = *m_firstMessage; *information++ = *m_lastMessage; size = 2; return 1; } else return -1; }
void ClientData::ClientThreadGetInfo() // NEW THREAD TO RECEIVE INFORMATIONS FROM THE SERVER { Packet packetType; while (GameLogic::getGameOn()) { if (!getPacketType(packetType)) std::cout << "Failed to get packet from server..." << std::endl; if (!processPacket(packetType)) std::cout << "Failed to process packet from server..." << std::endl; } cout << "Lost connection to the server - ClientThread" << endl; if (closeConnection()) cout << "Socket was closed successfuly" << endl; else cout << "Couldn't close the socket" << endl; }
Message::Message(UDPpacket *p) { packet = p; if ( packet != NULL ) { ip = packet->address.host; port = packet->address.port; message_type = getPacketType(packet); message_target = getPacketTarget(packet); } else { ip = 0; port = 0; message_type = 0; message_target = 0; } }
bool HTTPPacket::encodeStartLine(DataBuffer *output) { if (PT_REQUEST == getPacketType()) { const char *methodStr = getMethodString(); const char *uri = getURI(); if( NULL == methodStr || NULL == uri) { return false; } output->writeBytes(methodStr, strlen(methodStr)); output->writeBytes(" ", 1); output->writeBytes(uri, strlen(uri)); output->writeBytes(" ", 1); if (HTTP_1_0 == getVersion()) { output->writeBytes("HTTP/1.0", 8); } else { output->writeBytes("HTTP/1.1", 8); } output->writeBytes("\r\n ", 2); } else { int statusCode = getStatusCode(); if (0 == statusCode) { return false; } if (HTTP_1_0 == getVersion()) { output->writeBytes("HTTP/1.0", 8); } else { output->writeBytes("HTTP/1.1", 8); } output->writeBytes(" ", 1); char codeStr[32]; snprintf(codeStr, 32, "%d", statusCode); output->writeBytes(codeStr, 3); output->writeBytes(" ", 1); const char *reasonPhrase = getReasonPhrase(); if (NULL != reasonPhrase) { output->writeBytes(reasonPhrase, strlen(reasonPhrase)); } output->writeBytes("\r\n", 2); } return true; }
//Documentation in header file uint8_t dhcp_requestIP(uint16_t timeout_ms) { //Get a timer int8_t timer = timer_get(); timer_set(timer,timeout_ms); //Send dhcp discover packet dhcp_sendDiscover(); do { //Wait for a packet to arrive //If no packets arrive in time, return 0 while(enc28j60Read(EPKTCNT) == 0) if(timer_check(timer) == TIMER_EXPIRED) { //Release the timer timer_release(timer); return 0; } //Receive packet ns.plength = enc28j60PacketReceive(ns.pbuf, ns.pbuf_size); //Check if packet is DHCP! if(ns.plength > 0) if(getPacketType() == DHCP) dhcp_handlePacket(); } while(ns.ipAcquired == 0); //Release the timer timer_release(timer); //Return success return ns.ipAcquired; }
/** * This creates a master list for the floor, gets updates * from the inbound switchboard, adds these updates to the master file and sends that to the outbound * switchboard for distribution to players on that floor. * Takes packets: * IPC_PKT_0 0xB0 PKT_SERVER_SETUP pktB0 - uses maxplayers * IPC_PKT_1 0xB1 PKT_NEW_CLIENT pktB1 - uses playerNo * PKT_POS_UPDATE pkt10 - uses whole packet * Sends packets: * PKT_ALL_POS_UPDATE pkt11 - uses whole packet * * Revisions: * -# February 20, 2014: There is currently no error checking, handling or correction in place. This will come * in later updates. * For Milestone 1 only a small part of the functionality is in place. * Takes packets 10 * Sends packets 11 * * -# February 27, 2014: Added error messages for data inconsistencies, send and receive errors * Now using outbound mask * * @param[in] ipcSocks The Sockets to communicate with other controllers * @return void * * @designer Andrew Burian & Chris Holisky * @author Chris Holisky * * @date February 20, 2014 */ void* GameplayController(void* ipcSocks) { SOCKET outswitchSock; SOCKET gameplaySock; int i = 0; int j = 0; packet_t pType = -1; floorNo_t playerFloor = 0; floorNo_t newFloor = 0; playerNo_t thisPlayer = 0; packet_t outPType = 0; int errPacket = 0; int errFloor = 0; int errOut = 0; int wrongPacket = 0; int updated[MAX_PLAYERS] = {0}; int maxPlayers = 0; OUTMASK m; gameplaySock = ((SOCKET*) ipcSocks)[0]; outswitchSock = ((SOCKET*) ipcSocks)[1]; //create structs for buffers PKT_POS_UPDATE *bufPlayerIn = malloc(sizeof(PKT_POS_UPDATE)); PKT_ALL_POS_UPDATE *bufPlayerAll = malloc(sizeof(PKT_ALL_POS_UPDATE)); PKT_FLOOR_MOVE_REQUEST *bufFloorMoveReq = malloc(sizeof(PKT_FLOOR_MOVE_REQUEST)); PKT_FLOOR_MOVE *bufFloorMove = malloc(sizeof(PKT_FLOOR_MOVE)); PKT_MIN_ALL_POS_UPDATE *minAllPos = malloc(sizeof(PKT_MIN_ALL_POS_UPDATE)); PKT_MIN_POS_UPDATE *minPos = malloc(sizeof(PKT_MIN_POS_UPDATE)); PKT_SERVER_SETUP *bufipcPkt0 = malloc(sizeof(PKT_SERVER_SETUP)); PKT_NEW_CLIENT *bufipcPkt1 = malloc(sizeof(PKT_NEW_CLIENT)); PKT_LOST_CLIENT *bufipcPkt2 = malloc(sizeof(PKT_LOST_CLIENT)); PKT_FORCE_MOVE *bufipcPkt3 = malloc(sizeof(PKT_FORCE_MOVE)); // Zero out initial memory bzero(bufPlayerIn, sizeof(PKT_POS_UPDATE)); bzero(bufPlayerAll, sizeof(PKT_ALL_POS_UPDATE)); bzero(bufFloorMoveReq, sizeof(PKT_FLOOR_MOVE_REQUEST)); bzero(bufFloorMove, sizeof(PKT_FLOOR_MOVE)); bzero(minAllPos, sizeof(PKT_MIN_ALL_POS_UPDATE)); bzero(minPos, sizeof(PKT_MIN_POS_UPDATE)); bzero(bufipcPkt0, sizeof(ipcPacketSizes[0])); bzero(bufipcPkt1, sizeof(ipcPacketSizes[1])); bzero(bufipcPkt2, sizeof(ipcPacketSizes[2])); bzero(bufipcPkt3, sizeof(ipcPacketSizes[3])); //Create array of floor structures PKT_ALL_POS_UPDATE floorArray[MAX_FLOORS + 1]; bzero(floorArray, sizeof(PKT_ALL_POS_UPDATE) * (MAX_FLOORS + 1)); for (i = 0; i <= MAX_FLOORS; i++) { floorArray[i].floor = i; } getPacketType(gameplaySock); getPacket(gameplaySock, bufipcPkt0, ipcPacketSizes[0]); maxPlayers = bufipcPkt0->maxPlayers + 1; DEBUG(DEBUG_INFO, "GP> Setup Complete"); while (RUNNING) { //get packet type. Save to int. pType = getPacketType(gameplaySock); //switch to handle each type of packet switch (pType) { case -1: break; case 0xB1: //new player packet DEBUG(DEBUG_INFO, "GP> Receive packet 0xB1"); bzero(bufipcPkt1, sizeof(ipcPacketSizes[1])); if (getPacket(gameplaySock, bufipcPkt1, ipcPacketSizes[1]) == -1) { //couldn't read packet errPacket++; fprintf(stderr, "Gameplay Controller - error reading packet 0xB1. Count:%d\n", errPacket); break; } //get player information, set to position 50,50 on floor 0 bzero(bufFloorMove, netPacketSizes[13]); thisPlayer = bufipcPkt1->playerNo; playerFloor = 0; bufFloorMove->newFloor = playerFloor; getSpawn(bufipcPkt1->playerNo, playerFloor, &bufFloorMove->xPos, &bufFloorMove->yPos); //add player to floor array floorArray[0].playersOnFloor[thisPlayer] = 1; //send floor change packet DEBUG(DEBUG_INFO, "GP> Sending packet 13"); //set outbound mask for outbound server OUT_ZERO(m); OUT_SET(m, thisPlayer); outPType = 13; if (write(outswitchSock, &outPType, sizeof(outPType)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, bufFloorMove, netPacketSizes[13]) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, &m, sizeof(OUTMASK)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } //send packet 11 to players on floor DEBUG(DEBUG_INFO, "GP> Sending packet 11 to floor 0"); outPType = MIN_11; floorArray[playerFloor].xPos[thisPlayer] = bufFloorMove->xPos; floorArray[playerFloor].yPos[thisPlayer] = bufFloorMove->yPos; floorArray[playerFloor].xVel[thisPlayer] = 0; floorArray[playerFloor].yVel[thisPlayer] = 0; //set outbound mask for outbound server OUT_ZERO(m); for (i = 0; i < MAX_PLAYERS; i++) { if (floorArray[playerFloor].playersOnFloor[i] == 1) { OUT_SET(m, i); } } encapsulate_all_pos_update(&floorArray[0], minAllPos); if (write(outswitchSock, &outPType, sizeof(outPType)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, minAllPos, netPacketSizes[MIN_11]) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, &m, sizeof(OUTMASK)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } break; case 0xB2: //lost or quit client DEBUG(DEBUG_INFO, "GP> Received packet 0xB2"); bzero(bufipcPkt2, ipcPacketSizes[2]); if (getPacket(gameplaySock, bufipcPkt2, ipcPacketSizes[2]) == -1) { //couldn't read packet errPacket++; fprintf(stderr, "Gameplay Controller - error reading packet 0xB2. Count:%d\n", errPacket); break; } for (i = 0; i < MAX_FLOORS + 1; i++) { floorArray[i].playersOnFloor[bufipcPkt2->playerNo] = 0; } break; case 0xB3: // Force floor change DEBUG(DEBUG_INFO, "GP> Received packet 0xB3"); bzero(bufipcPkt3, ipcPacketSizes[3]); if (getPacket(gameplaySock, bufipcPkt3, ipcPacketSizes[3]) == -1) { //couldn't read packet errPacket++; fprintf(stderr, "Gameplay Controller - error reading packet 0xB3. Count:%d\n", errPacket); break; } // Find the player's floor for (i = 0; i < MAX_FLOORS; ++i) { if (floorArray[i].playersOnFloor[bufipcPkt3->playerNo]) { // found player break; } } // remove player from floor floorArray[i].playersOnFloor[bufipcPkt3->playerNo] = 0; // add them to the new floor floorArray[bufipcPkt3->newFloor].playersOnFloor[bufipcPkt3->playerNo] = 1; // prepare outbound packet bufFloorMove->newFloor = bufipcPkt3->newFloor; // put them in new locations getSpawn(bufipcPkt3->playerNo, bufipcPkt3->newFloor, &bufFloorMove->xPos, &bufFloorMove->yPos); // send the player floor move outPType = 13; OUT_ZERO(m); OUT_SET(m, bufipcPkt3->playerNo); write(outswitchSock, &outPType, sizeof(packet_t)); write(outswitchSock, bufFloorMove, netPacketSizes[13]); write(outswitchSock, &m, sizeof(OUTMASK)); DEBUG(DEBUG_INFO, "CP> Sending packet 13"); //send updated data to all players on old floor outPType = MIN_11; //set outbound mask for outbound server OUT_ZERO(m); for (j = 0; j < MAX_PLAYERS; j++) { if (floorArray[i].playersOnFloor[j] == 1) { OUT_SET(m, j); } } encapsulate_all_pos_update(&floorArray[i], minAllPos); write(outswitchSock, &outPType, sizeof(packet_t)); write(outswitchSock, minAllPos, netPacketSizes[MIN_11]); write(outswitchSock, &m, sizeof(OUTMASK)); DEBUG(DEBUG_INFO, "CP> Sending packet 16"); //send updated data to all players on new floor //set outbound mask for outbound server OUT_ZERO(m); for (j = 0; j < MAX_PLAYERS; j++) { if (floorArray[bufipcPkt3->newFloor].playersOnFloor[j] == 1) { OUT_SET(m, j); } } encapsulate_all_pos_update(&floorArray[bufipcPkt3->newFloor], minAllPos); write(outswitchSock, &outPType, sizeof(packet_t)); write(outswitchSock, minAllPos, netPacketSizes[MIN_11]); write(outswitchSock, &m, sizeof(OUTMASK)); DEBUG(DEBUG_INFO, "CP> Sending packet 16"); break; case MIN_10: getPacket(gameplaySock, minPos, netPacketSizes[MIN_10]); decapsulate_pos_update(minPos, bufPlayerIn); /* no break */ case 10: //player position update if(pType == 10){ // Not a min packet if (getPacket(gameplaySock, bufPlayerIn, netPacketSizes[10]) == -1) { //couldn't read packet errPacket++; fprintf(stderr, "Gameplay Controller - error reading packet 10. Count:%d\n", errPacket); break; } } //get floor number from incoming packet playerFloor = (bufPlayerIn->floor); //check to see if the floor number falls in the valid range if (playerFloor < 0 || playerFloor > MAX_FLOORS) { DEBUG(DEBUG_ALRM, "Received pkt 10 with whack floor data"); break; } //get player number from incoming packet thisPlayer = (*bufPlayerIn).playerNumber; //check to see if the player number falls in the valid range if (thisPlayer < 0 || thisPlayer > maxPlayers) { DEBUG(DEBUG_ALRM, "Received pkt 10 with whack player number data"); break; } //is this player supposed to be on this floor? if (floorArray[playerFloor].playersOnFloor[thisPlayer] != 1) { /* * handle error - this means that the player is sending a * packet with the wrong floor number. Perhaps pop up a big * message calling them a dirty cheater or just ignore this * packet as corrupt. If we ignore, we will probably want to * put in a count so that if several bad floor packets come in * from this player we can figure out if we didn't get their * floor update. */ if(DEBUG_ON && DEBUG_LEVEL >= DEBUG_WARN){ errFloor++; fprintf(stderr, "Gameplay Controller - player %d floor incorrect: %d. Count:%d\n", thisPlayer, playerFloor, errFloor); } break; } //put position and velocity in update packet floorArray[playerFloor].xPos[thisPlayer] = bufPlayerIn->xPos; floorArray[playerFloor].yPos[thisPlayer] = bufPlayerIn->yPos; floorArray[playerFloor].xVel[thisPlayer] = bufPlayerIn->xVel; floorArray[playerFloor].yVel[thisPlayer] = bufPlayerIn->yVel; updated[thisPlayer] = 1; break; case 0xB4: // Timer tick, send update //set packet type for outbound server outPType = MIN_11; DEBUG(DEBUG_INFO, "Sending game update"); //set outbound mask for outbound server for(j = 0; j < MAX_FLOORS + 1; ++j){ OUT_ZERO(m); for (i = 0; i < MAX_PLAYERS; i++) { if (floorArray[j].playersOnFloor[i] == 1) { OUT_SET(m, i); } } for(i = 0; i < MAX_PLAYERS; ++i){ if(!updated[i] && floorArray[j].playersOnFloor[i]){ // Player on this floor needs predictive update floorArray[j].xPos[i] += floorArray[j].xVel[i]; floorArray[j].yPos[i] += floorArray[j].yVel[i]; } } encapsulate_all_pos_update(&floorArray[j], minAllPos); //send packet type and then packet to outbound switchboard if (write(outswitchSock, &outPType, sizeof(outPType)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, minAllPos, netPacketSizes[MIN_11]) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, &m, sizeof(OUTMASK)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } } for(i = 0; i < MAX_PLAYERS; ++i){ updated[i] = 0; } break; case 12: //floor change DEBUG(DEBUG_INFO, "GP> Received packet 12"); bzero(bufFloorMoveReq, sizeof(*bufFloorMoveReq)); if (getPacket(gameplaySock, bufFloorMoveReq, netPacketSizes[12]) == -1) { //couldn't read packet if(DEBUG_ON && DEBUG_LEVEL >= DEBUG_WARN){ errPacket++; fprintf(stderr, "Gameplay Controller - error reading packet 12. Count:%d\n", errPacket); } /* * handle error here. Perhaps check the size of the packet as well? */ break; } //get information from floor move request playerFloor = bufFloorMoveReq->current_floor; newFloor = bufFloorMoveReq->desired_floor; thisPlayer = bufFloorMoveReq->playerNumber; if(!floorArray[playerFloor].playersOnFloor[thisPlayer] || (playerFloor == FLOOR_LOBBY && newFloor != FLOOR_LOBBY)){ DEBUG(DEBUG_WARN, "Player moving off wrong floor or escaping lobby rejected"); break; } //set information for floor move bzero(bufFloorMove, sizeof(*bufFloorMove)); bufFloorMove->newFloor = newFloor; bufFloorMove->xPos = bufFloorMoveReq->desired_xPos; bufFloorMove->yPos = bufFloorMoveReq->desired_yPos; DEBUG(DEBUG_INFO, "GP> Sending packet 13"); //set outbound mask to send only to this player OUT_ZERO(m); OUT_SET(m, thisPlayer); outPType = 13; if (write(outswitchSock, &outPType, sizeof(outPType)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, bufFloorMove, netPacketSizes[13]) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, &m, sizeof(OUTMASK)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } DEBUG(DEBUG_INFO, "GP> Sending packet 16 to old floor"); //send updated data to all players on old floor outPType = MIN_11; //remove this player from the floor floorArray[playerFloor].playersOnFloor[thisPlayer] = 0; //set outbound mask for outbound server OUT_ZERO(m); for (i = 0; i < MAX_PLAYERS; i++) { if (floorArray[playerFloor].playersOnFloor[i] == 1) { OUT_SET(m, i); } } encapsulate_all_pos_update(&floorArray[playerFloor], minAllPos); if (write(outswitchSock, &outPType, sizeof(outPType)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, minAllPos, netPacketSizes[MIN_11]) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, &m, sizeof(OUTMASK)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } //Send updated player position to all players on the new floor //put position and velocity in update packet floorArray[newFloor].xPos[thisPlayer] = bufFloorMove->xPos; floorArray[newFloor].yPos[thisPlayer] = bufFloorMove->yPos; floorArray[newFloor].xVel[thisPlayer] = 0; floorArray[newFloor].yVel[thisPlayer] = 0; //add this player to the new floor floorArray[newFloor].playersOnFloor[thisPlayer] = 1; //set outbound mask for outbound server OUT_ZERO(m); for (i = 0; i < MAX_PLAYERS; i++) { if (floorArray[newFloor].playersOnFloor[i] == 1) { OUT_SET(m, i); } } DEBUG(DEBUG_INFO, "GP> Sending packet 16 to new floor"); encapsulate_all_pos_update(&floorArray[newFloor], minAllPos); if (write(outswitchSock, &outPType, sizeof(outPType)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, minAllPos, netPacketSizes[MIN_11]) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } if (write(outswitchSock, &m, sizeof(OUTMASK)) == -1) { errOut++; fprintf(stderr, "Gameplay Controller - sending to outbound switchboard. Count:%d\n", errOut); } break; default: if(DEBUG_ON && DEBUG_LEVEL >= DEBUG_WARN){ wrongPacket++; fprintf(stderr, "Gameplay Controller - received unknown packet type:%d Count:%d\n", pType, wrongPacket); } break; } pType = -1; } free(bufPlayerAll); free(bufPlayerIn); return 0; }
void handlePacket(Packet *pkt) { if(verifyPacket(pkt)) { int type = getPacketType(pkt); switch(type) { case 0: { // WHOHAS fprintf(stderr,"->WHOHAS\n"); Packet *pktIHAVE = newPacketIHAVE(pkt); enqueue(nonCongestQueue, (void *)pktIHAVE); break; } case 1: { // IHAVE fprintf(stderr,"->IHAVE\n"); int peerIndex = searchPeer(&(pkt->src)); int peerID = peerInfo.peerList[peerIndex].peerID; newPacketGET(pkt, downloadPool[peerID].getQueue); idle = 0; break; } case 2: { // GET fprintf(stderr,"->GET\n"); if(numConnUp == maxConn){ fprintf(stderr,"->GET request denied.\n"); freePacket(pkt); break; } numConnUp++; int peerIndex = searchPeer(&(pkt->src)); int peerID = peerInfo.peerList[peerIndex].peerID; if(downloadPool[peerID].connected == 0){ clearQueue(uploadPool[peerID].ackWaitQueue); initWindows(&(downloadPool[peerID].rw), &(uploadPool[peerID].sw)); newPacketDATA(pkt, uploadPool[peerID].dataQueue); uploadPool[peerID].connID++; gettimeofday(&(uploadPool[peerID].startTime), NULL); } else { fprintf(stderr,"Only one-way connection is allowed.\n"); freePacket(pkt); } break; } case 3: { // DATA fprintf(stderr,"->DATA"); int peerIndex = searchPeer(&(pkt->src)); int peerID = peerInfo.peerList[peerIndex].peerID; if(1 == updateGetSingleChunk(pkt, peerID)) { downloadPool[peerID].connected = 0; numConnDown--; updateGetChunk(); } break; } case 4: { // ACK fprintf(stderr,"->ACK\n"); int peerIndex = searchPeer(&(pkt->src)); int peerID = peerInfo.peerList[peerIndex].peerID; updateACKQueue(pkt, peerID); break; } case 5: // DENIED default: fprintf(stderr,"DENIED\n"); } } else { fprintf(stderr,"Invalid packet!\n"); } freePacket(pkt); return; }
unsigned int L2Game_RequestUserCommand::read_commandID() { readReset(); getPacketType(); return readUInt(); }
int L2Game_NewCharacterSuccess::read_templatesCount() { readReset(); getPacketType(); return readInt(); }