Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 21:57:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
openmohaa/code/gamespy/GP/gp.h

1632 lines
33 KiB
C
Raw Permalink Normal View History

Added gamespy SDK
2023-02-04 21:00:01 +01:00
/*
gp.h
GameSpy Presence SDK
Dan "Mr. Pants" Schoenblum
Copyright 1999-2007 GameSpy Industries, Inc
devsupport@gamespy.com
***********************************************************************
Please see the GameSpy Presence SDK documentation for more information
**********************************************************************/
#ifndef _GP_H_
#define _GP_H_
// necessary for gsi_char and UNICODE support
#include "../common/gsCommon.h"
#ifdef __cplusplus
extern "C" {
#endif
//ENUMS
////////
typedef enum _GPEnum
{
// Callbacks
////////////
GP_ERROR = 0,
GP_RECV_BUDDY_REQUEST,
GP_RECV_BUDDY_STATUS,
GP_RECV_BUDDY_MESSAGE,
GP_RECV_BUDDY_UTM,
GP_RECV_GAME_INVITE,
GP_TRANSFER_CALLBACK,
GP_RECV_BUDDY_AUTH,
GP_RECV_BUDDY_REVOKE,
// Global States.
/////////////////
GP_INFO_CACHING = 0x0100,
GP_SIMULATION,
GP_INFO_CACHING_BUDDY_AND_BLOCK_ONLY,
// Blocking
///////////
GP_BLOCKING = 1,
GP_NON_BLOCKING = 0,
// Firewall
///////////
GP_FIREWALL = 1,
GP_NO_FIREWALL = 0,
// Check Cache
//////////////
GP_CHECK_CACHE = 1,
GP_DONT_CHECK_CACHE = 0,
// Is Valid Email.
// PANTS|02.15.00
//////////////////
GP_VALID = 1,
GP_INVALID = 0,
// Fatal Error.
///////////////
GP_FATAL = 1,
GP_NON_FATAL = 0,
// Sex
//////
GP_MALE = 0x0500,
GP_FEMALE,
GP_PAT,
// Profile Search.
//////////////////
GP_MORE = 0x0600,
GP_DONE,
// Set Info
///////////
GP_NICK = 0x0700,
GP_UNIQUENICK,
GP_EMAIL,
GP_PASSWORD,
GP_FIRSTNAME,
GP_LASTNAME,
GP_ICQUIN,
GP_HOMEPAGE,
GP_ZIPCODE,
GP_COUNTRYCODE,
GP_BIRTHDAY,
GP_SEX,
GP_CPUBRANDID,
GP_CPUSPEED,
GP_MEMORY,
GP_VIDEOCARD1STRING,
GP_VIDEOCARD1RAM,
GP_VIDEOCARD2STRING,
GP_VIDEOCARD2RAM,
GP_CONNECTIONID,
GP_CONNECTIONSPEED,
GP_HASNETWORK,
GP_OSSTRING,
GP_AIMNAME, // PANTS|03.20.01
GP_PIC,
GP_OCCUPATIONID,
GP_INDUSTRYID,
GP_INCOMEID,
GP_MARRIEDID,
GP_CHILDCOUNT,
GP_INTERESTS1,
// New Profile.
///////////////
GP_REPLACE = 1,
GP_DONT_REPLACE = 0,
// Is Connected.
////////////////
GP_CONNECTED = 1,
GP_NOT_CONNECTED = 0,
// Public mask.
///////////////
GP_MASK_NONE = 0x00000000,
GP_MASK_HOMEPAGE = 0x00000001,
GP_MASK_ZIPCODE = 0x00000002,
GP_MASK_COUNTRYCODE = 0x00000004,
GP_MASK_BIRTHDAY = 0x00000008,
GP_MASK_SEX = 0x00000010,
GP_MASK_EMAIL = 0x00000020,
GP_MASK_ALL = 0xFFFFFFFF,
// Status
/////////
GP_OFFLINE = 0,
GP_ONLINE = 1,
GP_PLAYING = 2,
GP_STAGING = 3,
GP_CHATTING = 4,
GP_AWAY = 5,
// Session flags
/////////////////
GP_SESS_IS_CLOSED = 0x00000001,
GP_SESS_IS_OPEN = 0x00000002,
GP_SESS_HAS_PASSWORD = 0x00000004,
GP_SESS_IS_BEHIND_NAT = 0x00000008,
GP_SESS_IS_RANKED = 0x000000010,
// CPU Brand ID
///////////////
GP_INTEL = 1,
GP_AMD,
GP_CYRIX,
GP_MOTOROLA,
GP_ALPHA,
// Connection ID.
/////////////////
GP_MODEM = 1,
GP_ISDN,
GP_CABLEMODEM,
GP_DSL,
GP_SATELLITE,
GP_ETHERNET,
GP_WIRELESS,
// Transfer callback type.
// *** the transfer is ended when these types are received
//////////////////////////
GP_TRANSFER_SEND_REQUEST = 0x800, // arg->num == numFiles
GP_TRANSFER_ACCEPTED,
GP_TRANSFER_REJECTED, // ***
GP_TRANSFER_NOT_ACCEPTING, // ***
GP_TRANSFER_NO_CONNECTION, // ***
GP_TRANSFER_DONE, // ***
GP_TRANSFER_CANCELLED, // ***
GP_TRANSFER_LOST_CONNECTION, // ***
GP_TRANSFER_ERROR, // ***
GP_TRANSFER_THROTTLE, // arg->num == Bps
GP_FILE_BEGIN,
GP_FILE_PROGRESS, // arg->num == numBytes
GP_FILE_END,
GP_FILE_DIRECTORY,
GP_FILE_SKIP,
GP_FILE_FAILED, // arg->num == error
// GP_FILE_FAILED error
///////////////////////
GP_FILE_READ_ERROR = 0x900,
GP_FILE_WRITE_ERROR,
GP_FILE_DATA_ERROR,
// Transfer Side.
/////////////////
GP_TRANSFER_SENDER = 0xA00,
GP_TRANSFER_RECEIVER,
// UTM send options.
////////////////////
GP_DONT_ROUTE = 0xB00, // only send direct
// Quiet mode flags.
////////////////////
GP_SILENCE_NONE = 0x00000000,
GP_SILENCE_MESSAGES = 0x00000001,
GP_SILENCE_UTMS = 0x00000002,
GP_SILENCE_LIST = 0x00000004, // includes requests, auths, and revokes
GP_SILENCE_ALL = 0xFFFFFFFF,
// Flags for checking if newer version of status info is supported
GP_NEW_STATUS_INFO_SUPPORTED = 0xC00,
GP_NEW_STATUS_INFO_NOT_SUPPORTED = 0xC01
} GPEnum;
//RESULTS
//////////
typedef enum _GPResult
{
GP_NO_ERROR,
GP_MEMORY_ERROR,
GP_PARAMETER_ERROR,
GP_NETWORK_ERROR,
GP_SERVER_ERROR,
GP_MISC_ERROR,
GP_COUNT
} GPResult;
//ERROR CODES
/////////////
//#define GP_ERROR_TYPE(errorCode) ((errorCode) >> 8)
typedef enum _GPErrorCode
{
// General.
///////////
GP_GENERAL = 0x0000,
GP_PARSE,
GP_NOT_LOGGED_IN,
GP_BAD_SESSKEY,
GP_DATABASE,
GP_NETWORK,
GP_FORCED_DISCONNECT,
GP_CONNECTION_CLOSED,
GP_UDP_LAYER,
// Login.
/////////
GP_LOGIN = 0x0100,
GP_LOGIN_TIMEOUT,
GP_LOGIN_BAD_NICK,
GP_LOGIN_BAD_EMAIL,
GP_LOGIN_BAD_PASSWORD,
GP_LOGIN_BAD_PROFILE,
GP_LOGIN_PROFILE_DELETED,
GP_LOGIN_CONNECTION_FAILED,
GP_LOGIN_SERVER_AUTH_FAILED,
GP_LOGIN_BAD_UNIQUENICK,
GP_LOGIN_BAD_PREAUTH,
// Newuser.
///////////
GP_NEWUSER = 0x0200,
GP_NEWUSER_BAD_NICK,
GP_NEWUSER_BAD_PASSWORD,
GP_NEWUSER_UNIQUENICK_INVALID,
GP_NEWUSER_UNIQUENICK_INUSE,
// Updateui.
////////////
GP_UPDATEUI = 0x0300,
GP_UPDATEUI_BAD_EMAIL,
// Newprofile.
//////////////
GP_NEWPROFILE = 0x0400,
GP_NEWPROFILE_BAD_NICK,
GP_NEWPROFILE_BAD_OLD_NICK,
// Updatepro.
/////////////
GP_UPDATEPRO = 0x0500,
GP_UPDATEPRO_BAD_NICK,
// Addbuddy.
////////////
GP_ADDBUDDY = 0x0600,
GP_ADDBUDDY_BAD_FROM,
GP_ADDBUDDY_BAD_NEW,
GP_ADDBUDDY_ALREADY_BUDDY,
// Authadd.
///////////
GP_AUTHADD = 0x0700,
GP_AUTHADD_BAD_FROM,
GP_AUTHADD_BAD_SIG,
// Status.
//////////
GP_STATUS = 0x0800,
// Bm.
//////
GP_BM = 0x0900,
GP_BM_NOT_BUDDY,
GP_BM_EXT_INFO_NOT_SUPPORTED,
GP_BM_BUDDY_OFFLINE,
// Getprofile.
//////////////
GP_GETPROFILE = 0x0A00,
GP_GETPROFILE_BAD_PROFILE,
// Delbuddy.
////////////
GP_DELBUDDY = 0x0B00,
GP_DELBUDDY_NOT_BUDDY,
// Delprofile.
/////////////
GP_DELPROFILE = 0x0C00,
GP_DELPROFILE_LAST_PROFILE,
// Search.
//////////
GP_SEARCH = 0x0D00,
GP_SEARCH_CONNECTION_FAILED,
GP_SEARCH_TIMED_OUT,
// Check.
/////////
GP_CHECK = 0x0E00,
GP_CHECK_BAD_EMAIL,
GP_CHECK_BAD_NICK,
GP_CHECK_BAD_PASSWORD,
// Revoke.
//////////
GP_REVOKE = 0x0F00,
GP_REVOKE_NOT_BUDDY,
// Registeruniquenick.
//////////////////////
GP_REGISTERUNIQUENICK = 0x1000,
GP_REGISTERUNIQUENICK_TAKEN,
GP_REGISTERUNIQUENICK_RESERVED,
GP_REGISTERUNIQUENICK_BAD_NAMESPACE,
// Register cdkey.
//////////////////
GP_REGISTERCDKEY = 0x1100,
GP_REGISTERCDKEY_BAD_KEY,
GP_REGISTERCDKEY_ALREADY_SET,
GP_REGISTERCDKEY_ALREADY_TAKEN,
// AddBlock.
////////////
GP_ADDBLOCK = 0x1200,
GP_ADDBLOCK_ALREADY_BLOCKED,
// RemoveBlock.
///////////////
GP_REMOVEBLOCK = 0x1300,
GP_REMOVEBLOCK_NOT_BLOCKED
} GPErrorCode;
//STRING LENGTHS
////////////////
#define GP_NICK_LEN 31
#define GP_UNIQUENICK_LEN 21
#define GP_FIRSTNAME_LEN 31
#define GP_LASTNAME_LEN 31
#define GP_EMAIL_LEN 51
#define GP_PASSWORD_LEN 31
#define GP_PASSWORDENC_LEN ((((GP_PASSWORD_LEN+2)*4)/3)+1)
#define GP_HOMEPAGE_LEN 76
#define GP_ZIPCODE_LEN 11
#define GP_COUNTRYCODE_LEN 3
#define GP_PLACE_LEN 128
#define GP_AIMNAME_LEN 51
#define GP_REASON_LEN 1025
#define GP_STATUS_STRING_LEN 256
#define GP_LOCATION_STRING_LEN 256
#define GP_ERROR_STRING_LEN 256
#define GP_AUTHTOKEN_LEN 256
#define GP_PARTNERCHALLENGE_LEN 256
#define GP_CDKEY_LEN 65
#define GP_CDKEYENC_LEN ((((GP_CDKEY_LEN+2)*4)/3)+1)
#define GP_LOGIN_TICKET_LEN 25
#define GP_RICH_STATUS_LEN 256
#define GP_STATUS_BASIC_STR_LEN 33
// Random number seed for PASSWORDENC and CDKEYENC
// MUST MATCH SERVER - If you change this, you'll have to
// release an updated server
#define GP_XOR_SEED 0x79707367 // "gspy"
// Well known values for partner ID.
#define GP_PARTNERID_GAMESPY 0
#define GP_PARTNERID_IGN 10
// Maximum number of namespaces that can be searched for a uniquenick
#define GP_MAX_NAMESPACEIDS 16
//TYPES
////////
// GPConnection
///////////////
typedef void * GPConnection;
// GPProfile
////////////
typedef int GPProfile;
// GPTransfer
/////////////
typedef int GPTransfer;
// GPCallback
/////////////
typedef void (* GPCallback)(
GPConnection * connection,
void * arg,
void * param
);
//STRUCTURES
/////////////
// GPErrorArg
/////////////
typedef struct
{
GPResult result;
GPErrorCode errorCode;
gsi_char * errorString;
GPEnum fatal;
} GPErrorArg;
// GPConnectResponseArg
////////////////////////
typedef struct
{
GPResult result;
GPProfile profile;
gsi_char uniquenick[GP_UNIQUENICK_LEN];
} GPConnectResponseArg;
// GPNewUserResponseArg
///////////////////////
typedef struct
{
GPResult result;
GPProfile profile;
} GPNewUserResponseArg;
// GPCheckResponseArg
/////////////////////
typedef struct
{
GPResult result;
GPProfile profile;
} GPCheckResponseArg;
// GPSuggestUniqueNickResponseArg
/////////////////////////////////
typedef struct
{
GPResult result;
int numSuggestedNicks;
gsi_char ** suggestedNicks;
} GPSuggestUniqueNickResponseArg;
// GPRegisterUniqueNickResponseArg
//////////////////////////////////
typedef struct
{
GPResult result;
} GPRegisterUniqueNickResponseArg;
// GPRegisterCdKeyResponseArg
//////////////////////////////////
typedef struct
{
GPResult result;
} GPRegisterCdKeyResponseArg;
// GPNewProfileResponseArg
//////////////////////////
typedef struct
{
GPResult result;
GPProfile profile;
} GPNewProfileResponseArg;
// GPDeleteProfileResponseArg
/////////////////////////////
typedef struct
{
GPResult result;
GPProfile profile;
} GPDeleteProfileResponseArg;
// GPProfileSearchMatch
///////////////////////
typedef struct
{
GPProfile profile;
gsi_char nick[GP_NICK_LEN];
gsi_char uniquenick[GP_UNIQUENICK_LEN];
int namespaceID;
gsi_char firstname[GP_FIRSTNAME_LEN];
gsi_char lastname[GP_LASTNAME_LEN];
gsi_char email[GP_EMAIL_LEN];
} GPProfileSearchMatch;
// GPProfileSearchResponseArg
/////////////////////////////
typedef struct
{
GPResult result;
int numMatches;
GPEnum more;
GPProfileSearchMatch * matches;
} GPProfileSearchResponseArg;
// GPGetInfoResponseArg
///////////////////////
typedef struct
{
GPResult result;
GPProfile profile;
gsi_char nick[GP_NICK_LEN];
gsi_char uniquenick[GP_UNIQUENICK_LEN];
gsi_char email[GP_EMAIL_LEN];
gsi_char firstname[GP_FIRSTNAME_LEN];
gsi_char lastname[GP_LASTNAME_LEN];
gsi_char homepage[GP_HOMEPAGE_LEN];
int icquin;
gsi_char zipcode[GP_ZIPCODE_LEN];
gsi_char countrycode[GP_COUNTRYCODE_LEN];
float longitude; // negative is west, positive is east. (0, 0) means unknown.
float latitude; // negative is south, positive is north. (0, 0) means unknown.
gsi_char place[GP_PLACE_LEN]; // e.g., "USA|California|Irvine", "South Korea|Seoul", "Turkey"
int birthday;
int birthmonth;
int birthyear;
GPEnum sex;
GPEnum publicmask;
gsi_char aimname[GP_AIMNAME_LEN];
int pic;
int occupationid;
int industryid;
int incomeid;
int marriedid;
int childcount;
int interests1;
int ownership1;
int conntypeid;
} GPGetInfoResponseArg;
// GPRecvBuddyRequestArg
////////////////////////
typedef struct
{
GPProfile profile;
unsigned int date;
gsi_char reason[GP_REASON_LEN];
} GPRecvBuddyRequestArg;
// GPBuddyStatus
////////////////
typedef struct
{
GPProfile profile;
GPEnum status;
gsi_char statusString[GP_STATUS_STRING_LEN];
gsi_char locationString[GP_LOCATION_STRING_LEN];
unsigned int ip;
int port;
GPEnum quietModeFlags;
} GPBuddyStatus;
// BETA
//GPBuddyStatusInfo
///////////////////
typedef struct
{
GPProfile profile;
GPEnum statusState;
unsigned int buddyIp;
unsigned short buddyPort;
unsigned int hostIp;
unsigned int hostPrivateIp;
unsigned short queryPort;
unsigned short hostPort;
unsigned int sessionFlags;
gsi_char richStatus[GP_RICH_STATUS_LEN];
gsi_char gameType[GP_STATUS_BASIC_STR_LEN];
gsi_char gameVariant[GP_STATUS_BASIC_STR_LEN];
gsi_char gameMapName[GP_STATUS_BASIC_STR_LEN];
GPEnum quietModeFlags;
GPEnum newStatusInfoFlag;
} GPBuddyStatusInfo;
//GPGetBuddyStatusInfoKeysArg
/////////////////////////////
typedef struct
{
GPProfile profile;
gsi_char **keys;
gsi_char **values;
int numKeys;
} GPGetBuddyStatusInfoKeysArg;
// GPRecvBuddyStatusArg
///////////////////////
typedef struct
{
GPProfile profile;
unsigned int date;
int index;
} GPRecvBuddyStatusArg;
// GPRecvBuddyMessageArg
////////////////////////
typedef struct
{
GPProfile profile;
unsigned int date;
gsi_char * message;
} GPRecvBuddyMessageArg;
typedef struct
{
GPProfile profile;
unsigned int date;
gsi_char * message;
} GPRecvBuddyUTMArg;
typedef struct
{
GPProfile profile;
unsigned int date;
} GPRecvBuddyAuthArg;
typedef struct
{
GPProfile profile;
unsigned int date;
} GPRecvBuddyRevokeArg;
// GPTransferCallbackArg;
/////////////////////////
typedef struct
{
GPTransfer transfer;
GPEnum type;
int index;
int num;
gsi_char * message;
} GPTransferCallbackArg;
// GPIsValidEmailResponseArg
////////////////////////////
typedef struct
{
GPResult result;
gsi_char email[GP_EMAIL_LEN];
GPEnum isValid;
} GPIsValidEmailResponseArg;
// GPGetUserNicksResponseArg
////////////////////////////
typedef struct
{
GPResult result;
gsi_char email[GP_EMAIL_LEN];
int numNicks; // If 0, then the email/password did not match.
gsi_char ** nicks;
gsi_char ** uniquenicks;
} GPGetUserNicksResponseArg;
// GPRecvGameInviteArg
//////////////////////
typedef struct
{
GPProfile profile;
int productID;
gsi_char location[GP_LOCATION_STRING_LEN];
} GPRecvGameInviteArg;
// GPFindPlayerMatch
////////////////////
typedef struct
{
GPProfile profile;
gsi_char nick[GP_NICK_LEN];
GPEnum status;
gsi_char statusString[GP_STATUS_STRING_LEN];
} GPFindPlayerMatch;
// GPFindPlayersResponseArg
///////////////////////////
typedef struct
{
GPResult result;
int productID; //PANTS|06.06.00 - added by request for JED
int numMatches;
GPFindPlayerMatch * matches;
} GPFindPlayersResponseArg;
// GPGetReverseBuddiesResponseArg
/////////////////////////////////
typedef struct
{
GPResult result;
int numProfiles;
GPProfileSearchMatch * profiles;
} GPGetReverseBuddiesResponseArg;
typedef struct
{
GPProfile profile;
gsi_char uniqueNick[GP_UNIQUENICK_LEN];
} GPUniqueMatch;
typedef struct
{
GPResult result;
int numOfUniqueMatchs;
GPUniqueMatch *matches;
} GPGetReverseBuddiesListResponseArg;
//GLOBALS
/////////
/* The hostnames of the connection manager
server and the search manager server.
If the app resolves either or both hostnames,
the IP(s) can be stored in the string(s) before
calling gpInitialize */
extern char GPConnectionManagerHostname[64];
extern char GPSearchManagerHostname[64];
//FUNCTIONS
////////////
#ifndef GSI_UNICODE
#define gpConnect gpConnectA
#define gpConnectNewUser gpConnectNewUserA
#define gpConnectUniqueNick gpConnectUniqueNickA
#define gpConnectPreAuthenticated gpConnectPreAuthenticatedA
#define gpCheckUser gpCheckUserA
#define gpNewUser gpNewUserA
#define gpSuggestUniqueNick gpSuggestUniqueNickA
#define gpRegisterUniqueNick gpRegisterUniqueNickA
#define gpRegisterCdKey gpRegisterCdKeyA
#define gpGetErrorString gpGetErrorStringA
#define gpNewProfile gpNewProfileA
#define gpProfileSearch gpProfileSearchA
#define gpProfileSearchUniquenick gpProfileSearchUniquenickA
#define gpSetInfos gpSetInfosA
#define gpSendBuddyRequest gpSendBuddyRequestA
#ifndef GP_NEW_STATUS_INFO
#define gpSetStatus gpSetStatusA
#endif
#ifdef GP_NEW_STATUS_INFO
// BETA
#define gpSetStatusInfo gpSetStatusInfoA
#endif
#define gpSendBuddyMessage gpSendBuddyMessageA
#define gpSendBuddyUTM gpSendBuddyUTMA
#define gpIsValidEmail gpIsValidEmailA
#define gpGetUserNicks gpGetUserNicksA
#define gpSetInfoCacheFilename gpSetInfoCacheFilenameA
#define gpSendFiles gpSendFilesA
#define gpAcceptTransfer gpAcceptTransferA
#define gpRejectTransfer gpRejectTransferA
#define gpSetTransferDirectory gpSetTransferDirectoryA
#define gpGetFileName gpGetFileNameA
#define gpGetFilePath gpGetFilePathA
#define gpInvitePlayer gpInvitePlayerA
#ifdef GP_NEW_STATUS_INFO
// BETA
#define gpAddStatusInfoKey gpAddStatusInfoKeyA
#define gpSetStatusInfoKey gpSetStatusInfoKeyA
#define gpGetStatusInfoKeyVal gpGetStatusInfoKeyValA
#define gpDelStatusInfoKey gpDelStatusInfoKeyA
#endif
#else
#define gpConnect gpConnectW
#define gpConnectNewUser gpConnectNewUserW
#define gpConnectUniqueNick gpConnectUniqueNickW
#define gpConnectPreAuthenticated gpConnectPreAuthenticatedW
#define gpCheckUser gpCheckUserW
#define gpNewUser gpNewUserW
#define gpSuggestUniqueNick gpSuggestUniqueNickW
#define gpRegisterUniqueNick gpRegisterUniqueNickW
#define gpRegisterCdKey gpRegisterCdKeyW
#define gpGetErrorString gpGetErrorStringW
#define gpNewProfile gpNewProfileW
#define gpProfileSearch gpProfileSearchW
#define gpProfileSearchUniquenick gpProfileSearchUniquenickW
#define gpSetInfos gpSetInfosW
#define gpSendBuddyRequest gpSendBuddyRequestW
#ifndef GP_NEW_STATUS_INFO
#define gpSetStatus gpSetStatusW
#endif
#ifdef GP_NEW_STATUS_INFO
// BETA
#define gpSetStatusInfo gpSetStatusInfoW
#endif
#define gpSendBuddyMessage gpSendBuddyMessageW
#define gpSendBuddyUTM gpSendBuddyUTMW
#define gpIsValidEmail gpIsValidEmailW
#define gpGetUserNicks gpGetUserNicksW
#define gpSetInfoCacheFilename gpSetInfoCacheFilenameW
#define gpSendFiles gpSendFilesW
#define gpAcceptTransfer gpAcceptTransferW
#define gpRejectTransfer gpRejectTransferW
#define gpSetTransferDirectory gpSetTransferDirectoryW
#define gpGetFileName gpGetFileNameW
#define gpGetFilePath gpGetFilePathW
#define gpInvitePlayer gpInvitePlayerW
// #ifdef GP_NEW_STATUS_INFO
// BETA
// #define gpAddStatusInfoKey gpAddStatusInfoKeyW
// #define gpSetStatusInfoKey gpSetStatusInfoKeyW
// #define gpGetStatusInfoKeyVal gpGetStatusInfoKeyValW
// #define gpDelStatusInfoKey gpDelStatusInfoKeyW
// #endif
#endif
// gpInitialize
///////////////
GPResult gpInitialize
(
GPConnection * connection,
int productID, // The productID is a unique ID that identifies your product
int namespaceID, // The namespaceID identified which namespace to login under. A namespaceID of 0 indicates that no
// namespace should be used. A namespaceID of 1 represents the default GameSpy namespace
int partnerID // The partnerID identifies the account system being used.
// Use GP_PARTNERID_GAMESPY for GSID accounts.
// Use GP_PARTNERID_IGN for IGN accounts.
);
// gpDestroy
////////////
void gpDestroy(
GPConnection * connection
);
// gpEnable
///////////
GPResult gpEnable
(
GPConnection * connection,
GPEnum state
);
// gpDisable
////////////
GPResult gpDisable
(
GPConnection * connection,
GPEnum state
);
// gpProcess
////////////
GPResult gpProcess
(
GPConnection * connection
);
// gpSetCallback
////////////////
GPResult gpSetCallback
(
GPConnection * connection,
GPEnum func,
GPCallback callback,
void * param
);
// gpConnect
////////////
GPResult gpConnect
(
GPConnection * connection,
const gsi_char nick[GP_NICK_LEN],
const gsi_char email[GP_EMAIL_LEN],
const gsi_char password[GP_PASSWORD_LEN],
GPEnum firewall,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpConnectNewUser
///////////////////
GPResult gpConnectNewUser
(
GPConnection * connection,
const gsi_char nick[GP_NICK_LEN],
const gsi_char uniquenick[GP_UNIQUENICK_LEN],
const gsi_char email[GP_EMAIL_LEN],
const gsi_char password[GP_PASSWORD_LEN],
const gsi_char cdkey[GP_CDKEY_LEN],
GPEnum firewall,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpConnectUniqueNick
//////////////////////
GPResult gpConnectUniqueNick
(
GPConnection * connection,
const gsi_char uniquenick[GP_UNIQUENICK_LEN],
const gsi_char password[GP_PASSWORD_LEN],
GPEnum firewall,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpConnectPreAuthenticated
////////////////////////////
GPResult gpConnectPreAuthenticated
(
GPConnection * connection,
const gsi_char authtoken[GP_AUTHTOKEN_LEN],
const gsi_char partnerchallenge[GP_PARTNERCHALLENGE_LEN],
GPEnum firewall,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpDisconnect
///////////////
void gpDisconnect
(
GPConnection * connection
);
// gpIsConnected
////////////////
GPResult gpIsConnected
(
GPConnection * connection,
GPEnum * connected
);
// gpCheckUser
//////////////
GPResult gpCheckUser
(
GPConnection * connection,
const gsi_char nick[GP_NICK_LEN],
const gsi_char email[GP_EMAIL_LEN],
const gsi_char password[GP_PASSWORD_LEN],
GPEnum blocking,
GPCallback callback,
void * param
);
// gpNewUser
////////////
GPResult gpNewUser
(
GPConnection * connection,
const gsi_char nick[GP_NICK_LEN],
const gsi_char uniquenick[GP_UNIQUENICK_LEN],
const gsi_char email[GP_EMAIL_LEN],
const gsi_char password[GP_PASSWORD_LEN],
const gsi_char cdkey[GP_CDKEY_LEN],
GPEnum blocking,
GPCallback callback,
void * param
);
// gpSuggestUniqueNick
//////////////////////
GPResult gpSuggestUniqueNick
(
GPConnection * connection,
const gsi_char desirednick[GP_UNIQUENICK_LEN],
GPEnum blocking,
GPCallback callback,
void * param
);
// gpRegisterUniqueNick
///////////////////////
GPResult gpRegisterUniqueNick
(
GPConnection * connection,
const gsi_char uniquenick[GP_UNIQUENICK_LEN],
const gsi_char cdkey[GP_CDKEY_LEN],
GPEnum blocking,
GPCallback callback,
void * param
);
// gpRegisterCdKey
///////////////////////
GPResult gpRegisterCdKey
(
GPConnection * connection,
const gsi_char cdkey[GP_CDKEY_LEN],
GPEnum blocking,
GPCallback callback,
void * param
);
// gpGetErrorCode
/////////////////
GPResult gpGetErrorCode(
GPConnection * connection,
GPErrorCode * errorCode
);
// gpGetErrorString
///////////////////
GPResult gpGetErrorString(
GPConnection * connection,
gsi_char errorString[GP_ERROR_STRING_LEN]
);
// gpNewProfile
///////////////
GPResult gpNewProfile(
GPConnection * connection,
const gsi_char nick[GP_NICK_LEN],
GPEnum replace,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpDeleteProfile
//////////////////
GPResult gpDeleteProfile(
GPConnection * connection,
GPCallback callback,
void * param
);
// gpProfileFromID
// PANTS|09.11.00 - A GPProfile is now the same
// as a profileid. This function is no longer needed
// and will be removed in a future version of GP.
/////////////////////////////////////////////////////
GPResult gpProfileFromID(
GPConnection * connection,
GPProfile * profile,
int id
);
// gpIDFromProfile
// PANTS|09.11.00 - A GPProfile is now the same
// as a profileid. This function is no longer needed
// and will be removed in a future version of GP.
/////////////////////////////////////////////////////
GPResult gpIDFromProfile(
GPConnection * connection,
GPProfile profile,
int * id
);
// gpUserIDFromProfile
//////////////////
GPResult gpUserIDFromProfile(
GPConnection * connection,
GPProfile profile,
int * userid
);
// gpProfileSearch
//////////////////
GPResult gpProfileSearch(
GPConnection * connection,
const gsi_char nick[GP_NICK_LEN],
const gsi_char uniquenick[GP_UNIQUENICK_LEN],
const gsi_char email[GP_EMAIL_LEN],
const gsi_char firstname[GP_FIRSTNAME_LEN],
const gsi_char lastname[GP_LASTNAME_LEN],
int icquin,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpProfileSearchUniquenick
////////////////////////////
GPResult gpProfileSearchUniquenick(
GPConnection * connection,
const gsi_char uniquenick[GP_UNIQUENICK_LEN],
const int namespaceIDs[GP_MAX_NAMESPACEIDS],
int numNamespaces,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpGetInfo
////////////
GPResult gpGetInfo(
GPConnection * connection,
GPProfile profile,
GPEnum checkCache,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpGetInfoNoWait
//////////////////
GPResult gpGetInfoNoWait(
GPConnection * connection,
GPProfile profile,
GPGetInfoResponseArg * arg
);
// gpSetInfoi
/////////////
GPResult gpSetInfoi(
GPConnection * connection,
GPEnum info,
int value
);
// gpSetInfos
/////////////
GPResult gpSetInfos(
GPConnection * connection,
GPEnum info,
const gsi_char * value
);
// gpSetInfod
/////////////
GPResult gpSetInfod(
GPConnection * connection,
GPEnum info,
int day,
int month,
int year
);
// gpSetInfoMask
////////////////
GPResult gpSetInfoMask(
GPConnection * connection,
GPEnum mask
);
// gpSendBuddyRequest
/////////////////////
GPResult gpSendBuddyRequest(
GPConnection * connection,
GPProfile profile,
const gsi_char reason[GP_REASON_LEN]
);
// gpAuthBuddyRequest
/////////////////////
GPResult gpAuthBuddyRequest(
GPConnection * connection,
GPProfile profile
);
// gpDenyBuddyRequest
// PANTS|09.11.00
/////////////////////
GPResult gpDenyBuddyRequest(
GPConnection * connection,
GPProfile profile
);
// gpDeleteBuddy
////////////////
GPResult gpDeleteBuddy(
GPConnection * connection,
GPProfile profile
);
// gpAddToBlockedList
/////////////////////
GPResult gpAddToBlockedList(
GPConnection * connection,
GPProfile profile
);
// gpRemoveFromBlockedList
/////////////////////
GPResult gpRemoveFromBlockedList(
GPConnection * connection,
GPProfile profile
);
// gpGetNumBlocked
//////////////////
GPResult gpGetNumBlocked(
GPConnection * connection,
int * numBlocked
);
// gpGetBlockedProfile
/////////////////////
GPResult gpGetBlockedProfile(
GPConnection * connection,
int index,
GPProfile * profile
);
// gpIsBlocked
// returns gsi_true if blocked, gsi_false if not blocked
////////////////////////////////////////////////////////
gsi_bool gpIsBlocked(
GPConnection * connection,
GPProfile profile
);
// gpGetNumBuddies
//////////////////
GPResult gpGetNumBuddies(
GPConnection * connection,
int * numBuddies
);
// gpGetBuddyStatus
///////////////////
#ifndef GP_NEW_STATUS_INFO
GPResult gpGetBuddyStatus(
GPConnection * connection,
int index,
GPBuddyStatus * status
);
#endif
#ifdef GP_NEW_STATUS_INFO
//
//////////////////////////////
GPResult gpGetBuddyStatusInfo(
GPConnection * connection,
int index,
GPBuddyStatusInfo * statusInfo
);
GPResult gpSetBuddyAddr(
GPConnection *connection,
int index,
unsigned int buddyIp,
unsigned short buddyPort
);
#endif
// gpGetBuddyIndex
//////////////////
GPResult gpGetBuddyIndex(
GPConnection * connection,
GPProfile profile,
int * index
);
// gpIsBuddy
// returns 1 if a buddy, 0 if not a buddy
////////////
int gpIsBuddy(
GPConnection * connection,
GPProfile profile
);
int gpIsBuddyConnectionOpen(
GPConnection * connection,
GPProfile profile
);
// gpSetStatus
//////////////
#ifndef GP_NEW_STATUS_INFO
GPResult gpSetStatus(
GPConnection * connection,
GPEnum status,
const gsi_char statusString[GP_STATUS_STRING_LEN],
const gsi_char locationString[GP_LOCATION_STRING_LEN]
);
#endif
#ifdef GP_NEW_STATUS_INFO
GPResult gpSetStatusInfo(
GPConnection *connection,
GPEnum statusState,
unsigned int hostIp,
unsigned int hostPrivateIp,
unsigned short queryPort,
unsigned short hostPort,
unsigned int sessionFlags,
const gsi_char *richStatus,
int richStatusLen,
const gsi_char *gameType,
int gameTypeLen,
const gsi_char *gameVariant,
int gameVariantLen,
const gsi_char *gameMapName,
int gameMapNameLen
);
GPResult gpAddStatusInfoKey(GPConnection *connection, const gsi_char *keyName, const gsi_char *keyValue);
GPResult gpSetStatusInfoKey(GPConnection *connection, const gsi_char *keyName, const gsi_char *keyValue);
GPResult gpGetStatusInfoKeyVal(GPConnection *connection, const gsi_char *keyName, gsi_char **keyValue);
GPResult gpDelStatusInfoKey(GPConnection *connection, const gsi_char *keyName);
GPResult gpGetBuddyStatusInfoKeys(GPConnection *connection, int index, GPCallback callback, void *userData);
#endif
// gpSendBuddyMessage
/////////////////////
GPResult gpSendBuddyMessage(
GPConnection * connection,
GPProfile profile,
const gsi_char * message
);
// gpSendBuddyUTM
/////////////////////
GPResult gpSendBuddyUTM(
GPConnection * connection,
GPProfile profile,
const gsi_char * message,
int sendOption // GP_DONT_ROUTE
);
// PANTS|02.15.00
// Added gpIsValidEmail and gpGetUserNicks for login wizard.
////////////////////////////////////////////////////////////
// gpIsValidEmail
/////////////////
GPResult gpIsValidEmail(
GPConnection * connection,
const gsi_char email[GP_EMAIL_LEN],
GPEnum blocking,
GPCallback callback,
void * param
);
// gpGetUserNicks
/////////////////
GPResult gpGetUserNicks(
GPConnection * connection,
const gsi_char email[GP_EMAIL_LEN],
const gsi_char password[GP_PASSWORD_LEN],
GPEnum blocking,
GPCallback callback,
void * param
);
// *DEPRECATED*
// gpSetInvitableGames
//////////////////////
GPResult gpSetInvitableGames(
GPConnection * connection,
int numProductIDs,
const int * productIDs
);
// *DEPRECATED*
// gpFindPlayers
////////////////
GPResult gpFindPlayers(
GPConnection * connection,
int productID,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpInvitePlayer
/////////////////
GPResult gpInvitePlayer(
GPConnection * connection,
GPProfile profile,
int productID,
const gsi_char location[GP_LOCATION_STRING_LEN]
);
// gpGetReverseBuddies
// Get profiles that have you on their buddy list.
//////////////////////////////////////////////////
GPResult gpGetReverseBuddies(
GPConnection * connection,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpGetReverseBuddiesList
// Get profile ids and unique nicks for profiles
// that have you on their buddy list.
//////////////////////////////////////////////////
GPResult gpGetReversBuddiesList( GPConnection * connection,
GPProfile *targets, int numOfTargets,
GPEnum blocking,
GPCallback callback,
void * param
);
// gpRevokeBuddyAuthorization
/////////////////////////////
GPResult gpRevokeBuddyAuthorization(
GPConnection * connection,
GPProfile profile
);
// gpSetCdKey
GPResult gpSetCdKey(
GPConnection * connection,
const gsi_char cdkeyhash,
GPCallback callback
);
// gpGetLoginTicket
/////////////////////////////
GPResult gpGetLoginTicket(
GPConnection * connection,
char loginTicket[GP_LOGIN_TICKET_LEN]
);
// gpSetQuietMode
/////////////////
GPResult gpSetQuietMode(
GPConnection * connection,
GPEnum flags
);
#ifndef NOFILE
// gpiSetInfoCacheFilename
// Should be called before gpIntialize.
///////////////////////////////////////
void gpSetInfoCacheFilename(
const gsi_char * filename
);
///////////////////
// FILE TRANSFER //
///////////////////
typedef void (* gpSendFilesCallback)(
GPConnection * connection,
int index,
const gsi_char ** path,
const gsi_char ** name,
void * param
);
GPResult gpSendFiles(
GPConnection * connection,
GPTransfer * transfer,
GPProfile profile,
const gsi_char * message,
gpSendFilesCallback callback,
void * param
);
GPResult gpAcceptTransfer(
GPConnection * connection,
GPTransfer transfer,
const gsi_char * message
);
GPResult gpRejectTransfer(
GPConnection * connection,
GPTransfer transfer,
const gsi_char * message
);
GPResult gpFreeTransfer(
GPConnection * connection,
GPTransfer transfer
);
GPResult gpSetTransferData(
GPConnection * connection,
GPTransfer transfer,
void * userData
);
void * gpGetTransferData(
GPConnection * connection,
GPTransfer transfer
);
GPResult gpSetTransferDirectory(
GPConnection * connection,
GPTransfer transfer,
const gsi_char * directory
);
// NOTE: THROTTLING IS NOT CURRENTLY IMPLEMENTED
GPResult gpSetTransferThrottle(
GPConnection * connection,
GPTransfer transfer,
int throttle
);
// NOTE: THROTTLING IS NOT CURRENTLY IMPLEMENTED
GPResult gpGetTransferThrottle(
GPConnection * connection,
GPTransfer transfer,
int * throttle
);
GPResult gpGetTransferProfile(
GPConnection * connection,
GPTransfer transfer,
GPProfile * profile
);
GPResult gpGetTransferSide(
GPConnection * connection,
GPTransfer transfer,
GPEnum * side
);
GPResult gpGetTransferSize(
GPConnection * connection,
GPTransfer transfer,
int * size
);
GPResult gpGetTransferProgress(
GPConnection * connection,
GPTransfer transfer,
int * progress
);
GPResult gpGetNumFiles(
GPConnection * connection,
GPTransfer transfer,
int * num
);
GPResult gpGetCurrentFile(
GPConnection * connection,
GPTransfer transfer,
int * index
);
GPResult gpSkipFile(
GPConnection * connection,
GPTransfer transfer,
int index
);
GPResult gpGetFileName(
GPConnection * connection,
GPTransfer transfer,
int index,
gsi_char ** name
);
GPResult gpGetFilePath(
GPConnection * connection,
GPTransfer transfer,
int index,
gsi_char ** path
);
GPResult gpGetFileSize(
GPConnection * connection,
GPTransfer transfer,
int index,
int * size
);
GPResult gpGetFileProgress(
GPConnection * connection,
GPTransfer transfer,
int index,
int * progress
);
GPResult gpGetFileModificationTime(
GPConnection * connection,
GPTransfer transfer,
int index,
gsi_time * modTime
);
GPResult gpGetNumTransfers(
GPConnection * connection,
int * num
);
GPResult gpGetTransfer(
GPConnection * connection,
int index,
GPTransfer * transfer
);
#endif
#ifdef _DEBUG
// gpProfilesReport
// PANTS|09.11.00
///////////////////
void gpProfilesReport(
GPConnection * connection,
void (* report)(const char * output)
);
#endif
#ifdef __cplusplus
}
#endif
#endif
Reference in a new issue Copy permalink