static void KeyMapF(void *elem, void *clientData)
{
SBKeyValuePair *kv = (SBKeyValuePair *)elem;
SBServerEnumData *ped = (SBServerEnumData *)clientData;
#ifndef GSI_UNICODE
ped->EnumFn((char *)kv->key, (char *)kv->value, ped->instance);
#else
unsigned short key_W[UKEY_LENGTH_MAX];
unsigned short value_W[UVALUE_LENGTH_MAX];
UTF8ToUCS2String(kv->key, key_W);
UTF8ToUCS2String(kv->value, value_W);
ped->EnumFn(key_W, value_W, ped->instance);
#endif
}
static void ptaCallPatchCallback
(
ptaPatchData * data,
PTBool available,
PTBool mandatory,
const char * versionName,
int fileID,
const char * downloadURL
)
{
if(data->callback)
{
#ifndef GSI_UNICODE
data->callback(available, mandatory, versionName, fileID, downloadURL, data->param);
#else
unsigned short versionName_W[255];
unsigned short downloadURL_W[PTA_MAX_STRING_SIZE*2];
UTF8ToUCS2String(versionName, versionName_W);
AsciiToUCS2String(downloadURL, downloadURL_W);
data->callback(available, mandatory, versionName_W, fileID, downloadURL_W, data->param);
#endif
}
gsifree(data);
}
static void ptaCallFilePlanetInfoCallback
(
ptaFilePlanetInfoData * data,
PTBool found,
const char * description,
const char * size,
int numMirrors,
char ** mirrorNames,
char ** mirrorURLs
)
{
int i;
if(data->callback)
{
if (!found)
data->callback(data->fileID, PTFalse, NULL, NULL, 0, NULL, NULL, data->param);
else
{
#ifndef GSI_UNICODE
data->callback(data->fileID, found, description, size, numMirrors, (const char**)mirrorNames, (const char**)mirrorURLs, data->param);
#else
unsigned short description_W[255];
unsigned short size_W[1024];
unsigned short** mirrorNames_W;
unsigned short** mirrorURLs_W;
int i;
UTF8ToUCS2String(description, description_W);
AsciiToUCS2String(size, size_W);
mirrorNames_W = UTF8ToUCS2StringArrayAlloc((const UTF8String *)mirrorNames, numMirrors);
mirrorURLs_W = UTF8ToUCS2StringArrayAlloc((const UTF8String *)mirrorURLs, numMirrors);
data->callback(data->fileID, found, description_W, size_W, numMirrors, (const unsigned short**)mirrorNames_W, (const unsigned short**)mirrorURLs_W, data->param);
for (i=0; i < numMirrors; i++)
{
gsifree(mirrorNames[i]);
gsifree(mirrorURLs[i]);
}
gsifree(mirrorNames);
gsifree(mirrorURLs);
#endif
}
}
for(i = 0 ; i < numMirrors ; i++)
{
gsifree(mirrorNames[i]);
gsifree(mirrorURLs[i]);
}
gsifree(data);
}
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;
}
