mirror of
https://github.com/openmoh/openmohaa.git
synced 2025-04-28 13:47:58 +03:00
592 lines
21 KiB
C
592 lines
21 KiB
C
/*
|
|
gpiPS3.c
|
|
GameSpy Presence SDK
|
|
|
|
devsupport@gamespy.com
|
|
|
|
***********************************************************************
|
|
Please see the GameSpy Presence SDK documentation for more information
|
|
**********************************************************************/
|
|
|
|
//INCLUDES
|
|
//////////
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "gpi.h"
|
|
|
|
#ifdef _PS3
|
|
//GLOBALS
|
|
//////////
|
|
uint8_t gpi_np_pool[SCE_NP_MIN_POOL_SIZE];
|
|
SceNpCommunicationId gpi_communication_id = {
|
|
{'N','P','X','S','0','0','0','0','5'},
|
|
'\0',
|
|
0,
|
|
0
|
|
};
|
|
|
|
//FUNCTIONS
|
|
///////////
|
|
int gpiNpBasicCallback(
|
|
int event,
|
|
int retCode,
|
|
uint32_t reqId,
|
|
void *arg
|
|
)
|
|
{
|
|
// No-op - can ignore any events
|
|
////////////////////////////////
|
|
return 0;
|
|
}
|
|
|
|
GPResult gpiInitializeNpBasic(
|
|
GPConnection * connection
|
|
)
|
|
{
|
|
int ret = 0;
|
|
GPIConnection * iconnection = (GPIConnection*)*connection;
|
|
|
|
iconnection->npInitialized = gsi_true;
|
|
|
|
// Initial NP init - after this we wait for status to get to online
|
|
////////////////////////////////////////////////////////////////////
|
|
ret = sceNpInit(SCE_NP_MIN_POOL_SIZE, gpi_np_pool);
|
|
|
|
if (ret == SCE_NP_ERROR_ALREADY_INITIALIZED)
|
|
{
|
|
// If already initialized - DO NOT terminate after sync (game might need it)
|
|
////////////////////////////////////////////////////////////////////////////
|
|
iconnection->npBasicGameInitialized = gsi_true;
|
|
}
|
|
else if (ret < 0)
|
|
{
|
|
iconnection->npBasicGameInitialized = gsi_true;
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiInitializeNpBasic: sceNpInit() failed, NP-functionality disabled. ret = 0x%x\n", ret);
|
|
return GP_MISC_ERROR;
|
|
}
|
|
else
|
|
iconnection->npBasicGameInitialized = gsi_false; //GP initialized, so destroy after complete
|
|
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
// Freeing up transaction list darray
|
|
void gpiNpTransactionListFree(void *element)
|
|
{
|
|
npIdLookupTrans *aTrans = (npIdLookupTrans *)element;
|
|
freeclear(aTrans->npIdForAdd);
|
|
}
|
|
|
|
|
|
GPResult gpiCheckNpStatus(
|
|
GPConnection * connection
|
|
)
|
|
{
|
|
int ret = 0;
|
|
int status = SCE_NP_MANAGER_STATUS_OFFLINE;
|
|
SceNpId npId;
|
|
GPIConnection * iconnection = (GPIConnection*)*connection;
|
|
|
|
// Get NP status
|
|
////////////////
|
|
ret = sceNpManagerGetStatus(&status);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiCheckNpStatus: sceNpGetStatus() failed. ret = 0x%x\n", ret);
|
|
}
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"gpiCheckNpStatus: sceNpGetStatus - status = %d\n", status);
|
|
|
|
|
|
// If NP status != online after the timeout period, stop syncing
|
|
////////////////////////////////////////////////////////////////
|
|
if (status != SCE_NP_MANAGER_STATUS_ONLINE && (current_time() - iconnection->loginTime > GPI_NP_STATUS_TIMEOUT))
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiCheckNpStatus: NP Status not online - timed out\n");
|
|
|
|
// Flag to stop the sync process
|
|
////////////////////////////////
|
|
iconnection->npPerformBuddySync = gsi_false;
|
|
iconnection->npPerformBlockSync = gsi_false;
|
|
|
|
return GP_MISC_ERROR;
|
|
}
|
|
|
|
// Once status is online, finish NP init
|
|
////////////////////////////////////////
|
|
if (status == SCE_NP_MANAGER_STATUS_ONLINE)
|
|
{
|
|
iconnection->loginTime = current_time();
|
|
|
|
// Note - we ignore error messages here - if something fails we really don't care
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
if (!iconnection->npBasicGameInitialized)
|
|
{
|
|
ret = sceNpBasicInit(); //obsolete?
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiCheckNpStatus: sceNpBasicInit() failed. ret = 0x%x\n", ret);
|
|
}
|
|
|
|
ret = sceNpBasicRegisterHandler(&gpi_communication_id, gpiNpBasicCallback, NULL);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiCheckNpStatus: sceNpBasicRegisterHandler() failed. ret = 0x%x\n", ret);
|
|
}
|
|
}
|
|
|
|
ret = sceNpLookupInit();
|
|
if (ret == SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED)
|
|
{
|
|
// If already initialized - DO NOT terminate after GP destroy (game might need it)
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
iconnection->npLookupGameInitialized = gsi_true;
|
|
}
|
|
else if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiCheckNpStatus: sceNpLookupInit() failed. ret = 0x%x\n", ret);
|
|
iconnection->npLookupGameInitialized = gsi_true;
|
|
}
|
|
else
|
|
iconnection->npLookupGameInitialized = gsi_false;
|
|
|
|
// Regardless of game, create a title context id for GP to use for lookups
|
|
///////////////////////////////////////////////////////////////////////////
|
|
ret = sceNpManagerGetNpId(&npId);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiCheckNpStatus: sceNpManagerGetNpId() failed. ret = 0x%x\n", ret);
|
|
}
|
|
|
|
ret = sceNpLookupCreateTitleCtx(&gpi_communication_id, &npId);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"gpiCheckNpStatus: sceNpLookupCreateTitleCtx() failed. ret = 0x%x\n", ret);
|
|
}
|
|
|
|
iconnection->npLookupTitleCtxId = ret;
|
|
|
|
// Mark status retrieval completed
|
|
//////////////////////////////////
|
|
iconnection->npStatusRetrieved = gsi_true;
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"gpiCheckNpStatus: NP is now initialized with status.\n");
|
|
|
|
iconnection->npTransactionList = ArrayNew(sizeof(npIdLookupTrans), 1, gpiNpTransactionListFree);
|
|
if (!iconnection->npTransactionList)
|
|
Error(connection, GP_MEMORY_ERROR, "Out of memory.");
|
|
}
|
|
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
GPResult gpiDestroyNpBasic(
|
|
GPConnection * connection
|
|
)
|
|
{
|
|
GPIConnection * iconnection = (GPIConnection*)*connection;
|
|
|
|
// Explicitly destroy title context we used for lookup
|
|
//////////////////////////////////////////////////////
|
|
if (iconnection->npLookupTitleCtxId >= 0)
|
|
sceNpLookupDestroyTitleCtx(iconnection->npLookupTitleCtxId);
|
|
|
|
// Do not destroy NpLookup or NpBasic if Game is using it
|
|
/////////////////////////////////////////////////////////
|
|
if (!iconnection->npLookupGameInitialized)
|
|
sceNpLookupTerm();
|
|
|
|
if (!iconnection->npBasicGameInitialized)
|
|
{
|
|
sceNpBasicUnregisterHandler();
|
|
|
|
// Obsolete?
|
|
sceNpBasicTerm();
|
|
|
|
sceNpTerm();
|
|
}
|
|
|
|
// Free up transaction list used for NP lookups
|
|
///////////////////////////////////////////////
|
|
if (iconnection->npTransactionList)
|
|
ArrayFree(iconnection->npTransactionList);
|
|
|
|
iconnection->npInitialized = gsi_false;
|
|
iconnection->npStatusRetrieved = gsi_false;
|
|
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
GPResult gpiSyncNpBuddies(
|
|
GPConnection * connection
|
|
)
|
|
{
|
|
int ret;
|
|
SceNpId npId; //Buffer to store friend list entry's NP ID
|
|
gsi_u32 i, count = 0;
|
|
GPIConnection * iconnection = (GPIConnection*)*connection;
|
|
|
|
|
|
// Flag sync as complete so we don't do it more than once per login
|
|
////////////////////////////////////////////////////////////////////
|
|
iconnection->npPerformBuddySync = gsi_false;
|
|
|
|
// Get buddy count
|
|
///////////////////
|
|
ret = sceNpBasicGetFriendListEntryCount(&count);
|
|
if ( ret < 0 )
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3BuddySync: Failed to get NP friend list count\n");
|
|
}
|
|
|
|
// Loop through each buddy, check for existence of GSID account
|
|
///////////////////////////////////////////////////////////////
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
memset(&npId, 0x00, sizeof(npId));
|
|
ret = sceNpBasicGetFriendListEntry(i, &npId);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3BuddySync: Failed to get NP friend entry #%d\n", i);
|
|
return GP_MISC_ERROR;
|
|
}
|
|
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BuddySync: NP friend entry #%d, npid = %s. Queueing Search.\n", i, npId.handle.data);
|
|
|
|
gpiProfileSearchUniquenick(connection, npId.handle.data, &iconnection->namespaceID,
|
|
1, GP_NON_BLOCKING, (GPCallback)gpiSyncNpBuddiesCallback, NULL);
|
|
}
|
|
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
void gpiSyncNpBuddiesCallback(
|
|
GPConnection * pconnection,
|
|
GPProfileSearchResponseArg * arg,
|
|
void * param
|
|
)
|
|
{
|
|
if(arg->result == GP_NO_ERROR)
|
|
{
|
|
if(arg->numMatches == 1)
|
|
{
|
|
// Check if already a buddy
|
|
////////////////////////////
|
|
if (!gpIsBuddy(pconnection, arg->matches[0].profile))
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BuddySync: NP Buddy \"%s\" found in namespace %d. Sending Request.\n",
|
|
arg->matches[0].uniquenick, arg->matches[0].namespaceID);
|
|
|
|
// Send the add request
|
|
////////////////////////
|
|
gpSendBuddyRequest(pconnection, arg->matches[0].profile, _T("PS3 Buddy Sync"));
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BuddySync: \"%s\" is already a buddy\n", arg->matches[0].uniquenick);
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BuddySync: No suitable match found\n");
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3BuddySync: Buddy Search FAILED!\n");
|
|
|
|
GSI_UNUSED(pconnection);
|
|
GSI_UNUSED(param);
|
|
}
|
|
|
|
GPResult gpiSyncNpBlockList(
|
|
GPConnection * connection
|
|
)
|
|
{
|
|
int ret;
|
|
SceNpId npId; //Buffer to store block list entry's NP ID
|
|
gsi_u32 i, count = 0;
|
|
GPIConnection * iconnection = (GPIConnection*)*connection;
|
|
|
|
|
|
// Flag sync as complete so we don't do it more than once per login
|
|
////////////////////////////////////////////////////////////////////
|
|
iconnection->npPerformBlockSync = gsi_false;
|
|
|
|
// Get block list count
|
|
///////////////////////
|
|
ret = sceNpBasicGetBlockListEntryCount(&count);
|
|
if ( ret < 0 )
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3BlockSync: Failed to get NP block list count\n");
|
|
}
|
|
|
|
// Loop through each entry, check for existence of GSID account
|
|
///////////////////////////////////////////////////////////////
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
memset(&npId, 0x00, sizeof(npId));
|
|
ret = sceNpBasicGetBlockListEntry(i, &npId);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3BlockSync: Failed to get NP block entry #%d\n", i);
|
|
return GP_MISC_ERROR;
|
|
}
|
|
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BlockSync: NP block entry #%d, npid = %s. Queueing Search.\n", i, npId.handle.data);
|
|
|
|
gpiProfileSearchUniquenick(connection, npId.handle.data, &iconnection->namespaceID,
|
|
1, GP_NON_BLOCKING, (GPCallback)gpiSyncNpBlockListCallback, NULL);
|
|
}
|
|
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
void gpiSyncNpBlockListCallback(
|
|
GPConnection * pconnection,
|
|
GPProfileSearchResponseArg * arg,
|
|
void * param
|
|
)
|
|
{
|
|
GPIProfile * pProfile;
|
|
GPIConnection * iconnection = (GPIConnection*)*pconnection;
|
|
|
|
if(arg->result == GP_NO_ERROR)
|
|
{
|
|
if(arg->numMatches == 1)
|
|
{
|
|
// Check if already blocked
|
|
////////////////////////////
|
|
if(!gpiGetProfile(pconnection, arg->matches[0].profile, &pProfile) || !pProfile->blocked)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BlockSync: NP Block Entry \"%s\" found in namespace %d. Adding to BlockedList.\n",
|
|
arg->matches[0].uniquenick, arg->matches[0].namespaceID);
|
|
|
|
// Add to GP Blocked List - set lock to make sure we dont try to add to NP list
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
iconnection->npSyncLock = gsi_true;
|
|
gpiAddToBlockedList(pconnection, arg->matches[0].profile);
|
|
iconnection->npSyncLock = gsi_false;
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BlockSync: \"%s\" is already blocked\n", arg->matches[0].uniquenick);
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3BlockSync: No suitable match found\n");
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3BlockSync: Block Entry Search FAILED!\n");
|
|
|
|
GSI_UNUSED(param);
|
|
}
|
|
|
|
GPResult gpiAddToNpBlockList(
|
|
GPConnection * connection,
|
|
int profileid
|
|
)
|
|
{
|
|
GPIConnection * iconnection = (GPIConnection*)*connection;
|
|
// TODO: consider developer method for cache input in order to check HDD cache?
|
|
|
|
// If NP status not resolved, don't bother with lookup
|
|
///////////////////////////////////////////////////////
|
|
if (!iconnection->npTransactionList || iconnection->npLookupTitleCtxId < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: Cancelling add - NP status not yet resolved.\n");
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
// Do an info lookup to find out if this player has an NP account.
|
|
/////////////////////////////////////////////////////////////////
|
|
gpiGetInfo(connection, profileid, GP_CHECK_CACHE, GP_NON_BLOCKING,
|
|
(GPCallback)gpiAddToNpBlockListInfoCallback, NULL);
|
|
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
void gpiAddToNpBlockListInfoCallback(
|
|
GPConnection * pconnection,
|
|
GPGetInfoResponseArg * arg,
|
|
void * param
|
|
)
|
|
{
|
|
SceNpOnlineId onlineId;
|
|
int ret;
|
|
npIdLookupTrans transaction;
|
|
GPIConnection * iconnection = (GPIConnection*)*pconnection;
|
|
#ifdef GSI_UNICODE
|
|
char asciiUniquenick[GP_UNIQUENICK_LEN];
|
|
#endif
|
|
|
|
if(arg->result == GP_NO_ERROR)
|
|
{
|
|
// Make sure its a PS3 uniquenick (e.g. we have the uniquenick)
|
|
///////////////////////////////////////////////////////////////
|
|
if (_tcslen(arg->uniquenick) != 0)
|
|
{
|
|
memset(&onlineId, 0, sizeof(onlineId));
|
|
|
|
#ifdef GSI_UNICODE
|
|
UCS2ToAsciiString(arg->uniquenick, (char*)asciiUniquenick);
|
|
strncpy(onlineId.data, asciiUniquenick, SCE_NET_NP_ONLINEID_MAX_LENGTH);
|
|
#else
|
|
strncpy(onlineId.data, arg->uniquenick, SCE_NET_NP_ONLINEID_MAX_LENGTH);
|
|
#endif
|
|
|
|
if (ArrayLength(iconnection->npTransactionList) < GPI_NP_NUM_TRANSACTIONS)
|
|
{
|
|
ret = sceNpLookupCreateTransactionCtx(iconnection->npLookupTitleCtxId);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: sceNpLookupCreateTransactionCtx() failed. ret = 0x%x\n", ret);
|
|
}
|
|
else
|
|
{
|
|
transaction.npIdForAdd = (SceNpId*)gsimalloc(sizeof(SceNpId));
|
|
if(transaction.npIdForAdd == NULL)
|
|
{
|
|
sceNpLookupDestroyTransactionCtx(ret);
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: Out of memory.\n");
|
|
return;
|
|
}
|
|
transaction.npTransId = ret;
|
|
transaction.npLookupDone = gsi_false;
|
|
ArrayAppend(iconnection->npTransactionList, &transaction);
|
|
|
|
// Perform NP lookup to get the NpId
|
|
/////////////////////////////////////
|
|
ret = sceNpLookupNpIdAsync(transaction.npTransId, &onlineId,
|
|
transaction.npIdForAdd, 0, NULL);
|
|
if (ret < 0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: sceNpLookupNpIdAsync() failed. ret = 0x%x\n", ret);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Can only have a max of 32 simultaneous transactions (based on PS3 lib)
|
|
/////////////////////////////////////////////////////////////////////////
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_WarmError,
|
|
"PS3AddToNpBlockList: Transactions limit reached for np lookups\n");
|
|
}
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: Profile [%d] does not have a uniquenick in namespace %d!\n",
|
|
arg->profile, iconnection->namespaceID);
|
|
}
|
|
else
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: Player Info lookup FAILED!\n");
|
|
|
|
GSI_UNUSED(pconnection);
|
|
GSI_UNUSED(param);
|
|
}
|
|
|
|
GPResult gpiProcessNp(GPConnection * connection)
|
|
{
|
|
int i, ret=0;
|
|
GPIConnection * iconnection = (GPIConnection*)*connection;
|
|
npIdLookupTrans * transaction;
|
|
|
|
// Check for uninitialized transaction darray
|
|
//////////////////////////////////////////////
|
|
if (!iconnection->npTransactionList)
|
|
return GP_NO_ERROR;
|
|
|
|
// Need to process Sysutil for the Async lookups
|
|
/////////////////////////////////////////////////
|
|
if (ArrayLength(iconnection->npTransactionList) > 0)
|
|
cellSysutilCheckCallback();
|
|
|
|
// Loop through all current transactions, check if complete
|
|
///////////////////////////////////////////////////////////
|
|
for (i=0; i < ArrayLength(iconnection->npTransactionList); i++)
|
|
{
|
|
// Grab next transaction in the list
|
|
/////////////////////////////////////
|
|
transaction = (npIdLookupTrans *)ArrayNth(iconnection->npTransactionList, i);
|
|
|
|
if (!transaction->npLookupDone)
|
|
{
|
|
if (sceNpLookupPollAsync(transaction->npTransId, &ret)==0)
|
|
transaction->npLookupDone = gsi_true;
|
|
}
|
|
else
|
|
{
|
|
if (ret<0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: sceNpLookupWaitAsync. ret = 0x%x\n", ret);
|
|
if (ret == (int)SCE_NP_COMMUNITY_SERVER_ERROR_NO_SUCH_USER_NPID)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: Player '%s' is not an NP user.\n",
|
|
transaction->npIdForAdd->handle.data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Found an NpId, try to add
|
|
/////////////////////////////
|
|
ret = sceNpBasicAddBlockListEntry(transaction->npIdForAdd);
|
|
if (ret == (int)SCE_NP_BASIC_ERROR_BUSY)
|
|
{
|
|
// Oh nice, NP is too busy to help us.... keep on trying
|
|
/////////////////////////////////////////////////////////
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3AddToNpBlockList: SCE_NP_BASIC_ERROR_BUSY. continue trying to add to NP\n");
|
|
return GP_NO_ERROR;
|
|
}
|
|
else if ( ret < 0 )
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: sceNpBasicAddBlockListEntry() failed. ret = 0x%x\n", ret);
|
|
}
|
|
else
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_Comment,
|
|
"PS3AddToNpBlockList: Player '%s' added to NP Block list.\n",
|
|
transaction->npIdForAdd->handle.data);
|
|
}
|
|
}
|
|
|
|
ret = sceNpLookupDestroyTransactionCtx(transaction->npTransId);
|
|
if (ret<0)
|
|
{
|
|
gsDebugFormat(GSIDebugCat_GP, GSIDebugType_Misc, GSIDebugLevel_HotError,
|
|
"PS3AddToNpBlockList: sceNpLookupDestroyTransactionCtx() failed. ret = 0x%x\n", ret);
|
|
}
|
|
|
|
// Delete Transaction when its complete
|
|
////////////////////////////////////////
|
|
ArrayDeleteAt(iconnection->npTransactionList, i);
|
|
}
|
|
}
|
|
|
|
return GP_NO_ERROR;
|
|
}
|
|
|
|
#endif
|