GPResult gpiBuddyHandleKeyRequest(GPConnection *connection, GPIPeer *peer) { char *message; // get all the keys and put them in the message part of bm ////////////////////////////////////////////////////////// CHECK_RESULT(gpiSaveKeysToBuffer(connection, &message)); // Done in case we haven't set any keys if (message == NULL) message = ""; CHECK_RESULT(gpiSendBuddyMessage(connection, peer->profile, GPI_BM_KEYS_REPLY, message, GP_DONT_ROUTE, NULL)); if (strcmp(message, "")!= 0) freeclear(message); return GP_NO_ERROR; }
GPResult gpiProcessRecvBuddyMessage( GPConnection * connection, const char * input ) { char buffer[4096]; int type; int profileid; time_t date; GPICallback callback; GPIProfile * profile; GPIBuddyStatus * buddyStatus; char intValue[16]; char * str; unsigned short port; int productID; GPIConnection * iconnection = (GPIConnection*)*connection; char strTemp[max(GP_STATUS_STRING_LEN, GP_LOCATION_STRING_LEN)]; // Check the type of bm. //////////////////////// if(!gpiValueForKey(input, "\\bm\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); type = atoi(buffer); // Get the profile this is from. //////////////////////////////// if(!gpiValueForKey(input, "\\f\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); profileid = atoi(buffer); // Get the time. //////////////// if(!gpiValueForKey(input, "\\date\\", buffer, sizeof(buffer))) date = time(NULL); else date = atoi(buffer); // What type of message is this? //////////////////////////////// switch(type) { case GPI_BM_MESSAGE: // Call the callback. ///////////////////// callback = iconnection->callbacks[GPI_RECV_BUDDY_MESSAGE]; if(callback.callback != NULL) { GPRecvBuddyMessageArg * arg; arg = (GPRecvBuddyMessageArg *)gsimalloc(sizeof(GPRecvBuddyMessageArg)); if(arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); #ifndef GSI_UNICODE arg->message = (char *)gsimalloc(strlen(buffer) + 1); if(arg->message == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); strcpy(arg->message, buffer); arg->profile = (GPProfile)profileid; arg->date = (unsigned int)date; #else arg->message = (unsigned short*)gsimalloc(strlen(buffer)*2+2); if(arg->message == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); UTF8ToUCS2String(buffer, arg->message); arg->profile = (GPProfile)profileid; arg->date = (unsigned int)date; #endif CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_MESSAGE)); } break; case GPI_BM_UTM: // Call the callback. ///////////////////// callback = iconnection->callbacks[GPI_RECV_BUDDY_UTM]; if(callback.callback != NULL) { GPRecvBuddyUTMArg * arg; arg = (GPRecvBuddyUTMArg *)gsimalloc(sizeof(GPRecvBuddyUTMArg)); if(arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); #ifndef GSI_UNICODE arg->message = (char *)gsimalloc(strlen(buffer) + 1); if(arg->message == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); strcpy(arg->message, buffer); arg->profile = (GPProfile)profileid; arg->date = (unsigned int)date; #else arg->message = (unsigned short*)gsimalloc(strlen(buffer)*2+2); if(arg->message == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); UTF8ToUCS2String(buffer, arg->message); arg->profile = (GPProfile)profileid; arg->date = (unsigned int)date; #endif CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDYUTM)); } break; case GPI_BM_REQUEST: // Get the profile, adding if needed. ///////////////////////////////////// profile = gpiProfileListAdd(connection, profileid); if(!profile) Error(connection, GP_MEMORY_ERROR, "Out of memory."); // Get the reason. ////////////////// if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); // Find where the sig starts. ///////////////////////////// str = strstr(buffer, "|signed|"); if(str == NULL) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); // Get the sig out of the message. ////////////////////////////////// *str = '\0'; str += 8; if(strlen(str) != 32) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); freeclear(profile->authSig); profile->authSig = goastrdup(str); profile->requestCount++; // Call the callback. ///////////////////// callback = iconnection->callbacks[GPI_RECV_BUDDY_REQUEST]; if(callback.callback != NULL) { GPRecvBuddyRequestArg * arg; arg = (GPRecvBuddyRequestArg *)gsimalloc(sizeof(GPRecvBuddyRequestArg)); if(arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); #ifndef GSI_UNICODE strzcpy(arg->reason, buffer, GP_REASON_LEN); #else UTF8ToUCS2String(buffer, arg->reason); #endif arg->profile = (GPProfile)profileid; arg->date = (unsigned int)date; CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDDYREQUEST)); } break; case GPI_BM_AUTH: // call the callback callback = iconnection->callbacks[GPI_RECV_BUDDY_AUTH]; if(callback.callback != NULL) { GPRecvBuddyAuthArg * arg; arg = (GPRecvBuddyAuthArg *)gsimalloc(sizeof(GPRecvBuddyAuthArg)); if (arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); arg->profile = (GPProfile)profileid; arg->date = (unsigned int)date; CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDYAUTH)); } break; case GPI_BM_REVOKE: // call the callback callback = iconnection->callbacks[GPI_RECV_BUDDY_REVOKE]; if(callback.callback != NULL) { GPRecvBuddyRevokeArg * arg; arg = (GPRecvBuddyRevokeArg *)gsimalloc(sizeof(GPRecvBuddyRevokeArg)); if (arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); arg->profile = (GPProfile)profileid; arg->date = (unsigned int)date; CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_BUDDYREVOKE)); } break; case GPI_BM_STATUS: // Get the profile, adding if needed. ///////////////////////////////////// profile = gpiProfileListAdd(connection, profileid); if(!profile) Error(connection, GP_MEMORY_ERROR, "Out of memory."); // Make sure profile wasn't blocked prior to getting the status update ////////////////////////////////////////////////////////////////////// if (!profile->blocked) { // This is a buddy. /////////////////// if(!profile->buddyStatus) { profile->buddyStatus = (GPIBuddyStatus *)gsimalloc(sizeof(GPIBuddyStatus)); if(!profile->buddyStatus) Error(connection, GP_MEMORY_ERROR, "Out of memory."); memset(profile->buddyStatus, 0, sizeof(GPIBuddyStatus)); if (profile->buddyStatusInfo) { profile->buddyStatus->buddyIndex = profile->buddyStatusInfo->buddyIndex; gpiRemoveBuddyStatusInfo(profile->buddyStatusInfo); profile->buddyStatusInfo = NULL; } else profile->buddyStatus->buddyIndex = iconnection->profileList.numBuddies++; } // Get the buddy status. //////////////////////// buddyStatus = profile->buddyStatus; // Get the msg. /////////////// if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); // Get the status. ////////////////// if(!gpiValueForKey(buffer, "|s|", intValue, sizeof(intValue))) { CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); } else { buddyStatus->status = (GPEnum)atoi(intValue); } // Get the status string. ///////////////////////// freeclear(buddyStatus->statusString); if(!gpiValueForKey(buffer, "|ss|", strTemp, GP_STATUS_STRING_LEN)) strTemp[0] = '\0'; buddyStatus->statusString = goastrdup(strTemp); if(!buddyStatus->statusString) Error(connection, GP_MEMORY_ERROR, "Out of memory."); // Get the location string. /////////////////////////// freeclear(buddyStatus->locationString); if(!gpiValueForKey(buffer, "|ls|", strTemp, GP_LOCATION_STRING_LEN)) strTemp[0] = '\0'; buddyStatus->locationString = goastrdup(strTemp); if(!buddyStatus->locationString) Error(connection, GP_MEMORY_ERROR, "Out of memory."); // Get the ip. ////////////// if(!gpiValueForKey(buffer, "|ip|", intValue, sizeof(intValue))) buddyStatus->ip = 0; else buddyStatus->ip = htonl((unsigned int)atoi(intValue)); // Get the port. //////////////// if(!gpiValueForKey(buffer, "|p|", intValue, sizeof(intValue))) buddyStatus->port = 0; else { port = (unsigned short)atoi(intValue); buddyStatus->port = htons(port); } // Get the quiet mode flags. //////////////////////////// if(!gpiValueForKey(buffer, "|qm|", intValue, sizeof(intValue))) buddyStatus->quietModeFlags = GP_SILENCE_NONE; else buddyStatus->quietModeFlags = (GPEnum)atoi(intValue); // Call the callback. ///////////////////// callback = iconnection->callbacks[GPI_RECV_BUDDY_STATUS]; if(callback.callback != NULL) { GPRecvBuddyStatusArg * arg; arg = (GPRecvBuddyStatusArg *)gsimalloc(sizeof(GPRecvBuddyStatusArg)); if(arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); arg->profile = (GPProfile)profileid; arg->index = buddyStatus->buddyIndex; arg->date = (unsigned int)date; CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_STATUS)); } } break; case GPI_BM_INVITE: // Get the msg. /////////////// if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); // Find the productid. ////////////////////// str = strstr(buffer, "|p|"); if(str == NULL) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); // Skip the |p|. //////////////// str += 3; if(str[0] == '\0') CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); // Get the productid. ///////////////////// productID = atoi(str); // Find the location string (optional - older versions won't have) str = strstr(buffer, "|l|"); if(str != NULL) strzcpy(strTemp, (str+3), sizeof(strTemp)); else strTemp[0] = '\0'; // no location, set to empty string // Call the callback. ///////////////////// callback = iconnection->callbacks[GPI_RECV_GAME_INVITE]; if(callback.callback != NULL) { GPRecvGameInviteArg * arg; arg = (GPRecvGameInviteArg *)gsimalloc(sizeof(GPRecvGameInviteArg)); if(arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); arg->profile = (GPProfile)profileid; arg->productID = productID; #ifdef GSI_UNICODE AsciiToUCS2String(strTemp, arg->location); #else strcpy(arg->location, strTemp); #endif CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, 0)); } break; case GPI_BM_PING: // Get the msg. /////////////// if(!gpiValueForKey(input, "\\msg\\", buffer, sizeof(buffer))) CallbackFatalError(connection, GP_NETWORK_ERROR, GP_PARSE, "Unexpected data was received from the server."); // Send back a pong. //////////////////// gpiSendBuddyMessage(connection, profileid, GPI_BM_PONG, "1", 0, NULL); break; #ifndef NOFILE case GPI_BM_PONG: // Lets the transfers handle this. ////////////////////////////////// gpiTransfersHandlePong(connection, profileid, NULL); break; #endif } return GP_NO_ERROR; }
static GPResult gpiProcessPeerConnected( GPConnection * connection, GPIPeer * peer ) { GPIConnection * iconnection = (GPIConnection*)*connection; //int len; GSUdpPeerState aPeerState; GPIBool connClosed; GPICallback callback; char * buffer; int type; int messageLen; GPResult result; GS_ASSERT(peer); if (!peer) return GP_NETWORK_ERROR; // Send stuff. ////////////// if(peer->outputBuffer.len) { //result = gpiSendFromBuffer(connection, peer->sock, &peer->outputBuffer, &connClosed, GPITrue, "PR"); result = gpiSendBufferToPeer(connection, peer->ip, peer->port, &peer->outputBuffer, &connClosed, GPITrue); if(connClosed || (result != GP_NO_ERROR)) { peer->state = GPI_PEER_DISCONNECTED; return GP_NO_ERROR; } } // Send outgoing messages. ////////////////////////// if(!peer->outputBuffer.len) { CHECK_RESULT(gpiPeerSendMessages(connection, peer)); if(peer->state == GPI_PEER_DISCONNECTED) return GP_NO_ERROR; } // Read messages. ///////////////// /* result = gpiRecvToBuffer(connection, peer->sock, &peer->inputBuffer, &len, &connClosed, "PR"); if(result != GP_NO_ERROR) { peer->state = GPI_PEER_DISCONNECTED; return GP_NO_ERROR; } */ if(peer->inputBuffer.len > 0) { peer->timeout = (time(NULL) + GPI_PEER_TIMEOUT); } // Grab the message header. /////////////////////////// do { // Read a message. ////////////////// CHECK_RESULT(gpiReadMessageFromBuffer(connection, &peer->inputBuffer, &buffer, &type, &messageLen)); if(buffer != NULL) { // Got a message! ///////////////// switch(type) { case GPI_BM_MESSAGE: callback = iconnection->callbacks[GPI_RECV_BUDDY_MESSAGE]; if(callback.callback != NULL) { GPRecvBuddyMessageArg * arg; arg = (GPRecvBuddyMessageArg *)gsimalloc(sizeof(GPRecvBuddyMessageArg)); if(arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); arg->profile = peer->profile; #ifndef GSI_UNICODE arg->message = goastrdup(buffer); #else arg->message = UTF8ToUCS2StringAlloc(buffer); #endif arg->date = (unsigned int)time(NULL); CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_MESSAGE)); } break; case GPI_BM_UTM: callback = iconnection->callbacks[GPI_RECV_BUDDY_UTM]; if (callback.callback != NULL) { GPRecvBuddyUTMArg * arg; arg = (GPRecvBuddyUTMArg *)gsimalloc(sizeof(GPRecvBuddyUTMArg)); if(arg == NULL) Error(connection, GP_MEMORY_ERROR, "Out of memory."); arg->profile = peer->profile; #ifndef GSI_UNICODE arg->message = goastrdup(buffer); #else arg->message = UTF8ToUCS2StringAlloc(buffer); #endif arg->date = (unsigned int)time(NULL); CHECK_RESULT(gpiAddCallback(connection, callback, arg, NULL, GPI_ADD_MESSAGE)); } break; case GPI_BM_PING: // Send back a pong. //////////////////// gpiSendBuddyMessage(connection, peer->profile, GPI_BM_PONG, "1", 0, NULL); break; #ifndef NOFILE case GPI_BM_PONG: // Lets the transfers handle this. ////////////////////////////////// gpiTransfersHandlePong(connection, peer->profile, peer); break; #endif case GPI_BM_KEYS_REQUEST: CHECK_RESULT(gpiBuddyHandleKeyRequest(connection, peer)); break; case GPI_BM_KEYS_REPLY: CHECK_RESULT(gpiBuddyHandleKeyReply(connection, peer, buffer)); // Let the keys request reply handler take care of this. //////////////////////////////////////////////////////// break; case GPI_BM_FILE_SEND_REQUEST: case GPI_BM_FILE_SEND_REPLY: case GPI_BM_FILE_BEGIN: case GPI_BM_FILE_END: case GPI_BM_FILE_DATA: case GPI_BM_FILE_SKIP: case GPI_BM_FILE_TRANSFER_THROTTLE: case GPI_BM_FILE_TRANSFER_CANCEL: case GPI_BM_FILE_TRANSFER_KEEPALIVE: // Handle a transfer protocol message. ////////////////////////////////////// gpiHandleTransferMessage(connection, peer, type, peer->inputBuffer.buffer, buffer, messageLen); break; default: break; } // Remove it from the buffer. ///////////////////////////// gpiClipBufferToPosition(connection, &peer->inputBuffer); } } while(buffer); gsUdpEngineGetPeerState(peer->ip, peer->port, &aPeerState); //if(connClosed) if (aPeerState == GS_UDP_PEER_CLOSED) peer->state = GPI_PEER_DISCONNECTED; return GP_NO_ERROR; }