Xbox360Archives/XBDM
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Xoro-1337
2025-11-06 15:36:24 -05:00
parent a738b93280
commit b24c1ddcbc
45 changed files with 65790 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

721
xbdm/imp/KernelExports.h Normal file
View File

@@ -0,0 +1,721 @@
#pragma once
#include "XeCrypt.h"
#include "kernelp.h"
typedef unsigned long long QWORD;
typedef long NTSTATUS;
#define NT_EXTRACT_ST(Status) ((((ULONG)(Status)) >> 30)& 0x3)
#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
#define NT_INFORMATION(Status) (NT_EXTRACT_ST(Status) == 1)
#define NT_WARNING(Status) (NT_EXTRACT_ST(Status) == 2)
#define NT_ERROR(Status) (NT_EXTRACT_ST(Status) == 3)
// IRQL values
#define PASSIVE_LEVEL 0
#define LOW_LEVEL 0
#define APC_LEVEL 1
#define DISPATCH_LEVEL 2
// Create disposition values.
#define FILE_SUPERSEDE 0x00000000
#define FILE_OPEN 0x00000001
#define FILE_CREATE 0x00000002
#define FILE_OPEN_IF 0x00000003
#define FILE_OVERWRITE 0x00000004
#define FILE_OVERWRITE_IF 0x00000005
#define FILE_MAXIMUM_DISPOSITION 0x00000005
// Create/open option flags.
#define FILE_DIRECTORY_FILE 0x00000001
#define FILE_WRITE_THROUGH 0x00000002
#define FILE_SEQUENTIAL_ONLY 0x00000004
#define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
#define FILE_SYNCHRONOUS_IO_ALERT 0x00000010
#define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
#define FILE_NON_DIRECTORY_FILE 0x00000040
#define FILE_CREATE_TREE_CONNECTION 0x00000080
#define FILE_COMPLETE_IF_OPLOCKED 0x00000100
#define FILE_NO_EA_KNOWLEDGE 0x00000200
#define FILE_OPEN_REMOTE_INSTANCE 0x00000400
#define FILE_RANDOM_ACCESS 0x00000800
#define FILE_DELETE_ON_CLOSE 0x00001000
#define FILE_OPEN_BY_FILE_ID 0x00002000
#define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000
#define FILE_NO_COMPRESSION 0x00008000
#define FILE_RESERVE_OPFILTER 0x00100000
#define FILE_OPEN_REPARSE_POINT 0x00200000
#define FILE_OPEN_NO_RECALL 0x00400000
#define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000
typedef enum _FS_INFORMATION_CLASS {
FileFsVolumeInformation=1,
FileFsLabelInformation,
FileFsSizeInformation,
FileFsDeviceInformation,
FileFsAttributeInformation,
FileFsControlInformation,
FileFsFullSizeInformation,
FileFsObjectIdInformation,
FileFsMaximumInformation
} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
typedef enum _FILE_INFORMATION_CLASS {
FileDirectoryInformation = 1,
FileFullDirectoryInformation,
FileBothDirectoryInformation,
FileBasicInformation,
FileStandardInformation,
FileInternalInformation,
FileEaInformation,
FileAccessInformation,
FileNameInformation,
FileRenameInformation,
FileLinkInformation,
FileNamesInformation,
FileDispositionInformation,
FilePositionInformation,
FileFullEaInformation,
FileModeInformation,
FileAlignmentInformation,
FileAllInformation,
FileAllocationInformation,
FileEndOfFileInformation,
FileAlternateNameInformation,
FileStreamInformation,
FilePipeInformation,
FilePipeLocalInformation,
FilePipeRemoteInformation,
FileMailslotQueryInformation,
FileMailslotSetInformation,
FileCompressionInformation,
FileObjectIdInformation,
FileCompletionInformation,
FileMoveClusterInformation,
FileQuotaInformation,
FileReparsePointInformation,
FileNetworkOpenInformation,
FileAttributeTagInformation,
FileTrackingInformation,
FileIdBothDirectoryInformation,
FileIdFullDirectoryInformation,
FileValidDataLengthInformation,
FileShortNameInformation,
FileIoCompletionNotificationInformation,
FileIoStatusBlockRangeInformation,
FileIoPriorityHintInformation,
FileSfioReserveInformation,
FileSfioVolumeInformation,
FileHardLinkInformation,
FileProcessIdsUsingFileInformation,
FileNormalizedNameInformation,
FileNetworkPhysicalNameInformation,
FileIdGlobalTxDirectoryInformation,
FileIsRemoteDeviceInformation,
FileAttributeCacheInformation,
FileNumaNodeInformation,
FileStandardLinkInformation,
FileRemoteProtocolInformation,
FileMaximumInformation
} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
typedef struct _FILE_FS_SIZE_INFORMATION {
LARGE_INTEGER TotalAllocationUnits;
LARGE_INTEGER AvailableAllocationUnits;
ULONG SectorsPerAllocationUnit;
ULONG BytesPerSector;
} FILE_FS_SIZE_INFORMATION, *PFILE_FS_SIZE_INFORMATION;
typedef struct _FILE_NETWORK_OPEN_INFORMATION {
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
LARGE_INTEGER AllocationSize;
LARGE_INTEGER EndOfFile;
ULONG FileAttributes;
ULONG Unknown;
} FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
typedef struct _ANSI_STRING {
USHORT Length;
USHORT MaximumLength;
PCHAR Buffer;
} ANSI_STRING, *PANSI_STRING;
typedef struct _FILE_DISPOSITION_INFORMATION {
BOOLEAN DeleteFile;
} FILE_DISPOSITION_INFORMATION;
typedef struct _FILE_RENAME_INFORMATION {
BOOLEAN ReplaceIfExists;
HANDLE RootDirectory;
ANSI_STRING FileName;
} FILE_RENAME_INFORMATION, *PFILE_RENAME_INFORMATION;
typedef struct _XEX_HEADER_STRING {
ULONG Size;
UCHAR Data[1];
} XEX_HEADER_STRING, *PXEX_HEADER_STRING;
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWCHAR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
typedef void (*pfnTitleTerminateRoutine)();
typedef struct _EX_TITLE_TERMINATE_REGISTRATION {
pfnTitleTerminateRoutine NotificationRoutine;
DWORD Priority;
LIST_ENTRY ListEntry;
} EX_TITLE_TERMINATE_REGISTRATION, *PEX_TITLE_TERMINATE_REGISTRATION;
typedef struct _EX_THREAD_REGISTRATION *PEX_THREAD_REGISTRATION;
typedef void (*pfnThreadNotificationRoutine)(PEX_THREAD_REGISTRATION ThisRegistration, PKTHREAD Thread, BOOL Creating);
typedef struct _EX_THREAD_REGISTRATION {
pfnThreadNotificationRoutine NotificationRoutine;
DWORD Priority;
LIST_ENTRY ListEntry;
} EX_THREAD_REGISTRATION;
typedef struct _XEX_IMPORT_DESCRIPTOR {
DWORD Size;
DWORD NameTableSize;
DWORD ModuleCount;
} XEX_IMPORT_DESCRIPTOR, *PXEX_IMPORT_DESCRIPTOR;
typedef struct _HV_IMAGE_IMPORT_TABLE {
BYTE NextImportDigest[0x14];
DWORD ModuleNumber;
DWORD Version[0x02];
BYTE Unused;
BYTE ModuleIndex;
WORD ImportCount;
} HV_IMAGE_IMPORT_TABLE, *PHV_IMAGE_IMPORT_TABLE;
typedef struct _XEX_IMPORT_TABLE {
DWORD TableSize;
HV_IMAGE_IMPORT_TABLE ImportTable;
} XEX_IMPORT_TABLE, *PXEX_IMPORT_TABLE;
typedef struct _LDR_DATA_TABLE_ENTRY {
LIST_ENTRY InLoadOrderLinks;
LIST_ENTRY InClosureOrderLinks;
LIST_ENTRY InInitializationOrderLinks;
VOID* NtHeadersBase;
VOID* ImageBase;
DWORD SizeOfNtImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
DWORD Flags;
DWORD SizeOfFullImage;
VOID* EntryPoint;
WORD LoadCount;
WORD ModuleIndex;
VOID* DllBaseOriginal;
DWORD CheckSum;
DWORD ModuleLoadFlags;
DWORD TimeDateStamp;
VOID* LoadedImports;
VOID* XexHeaderBase;
union {
ANSI_STRING LoadFileName;
struct {
struct _LDR_DATA_TABLE_ENTRY* ClosureRoot;
struct _LDR_DATA_TABLE_ENTRY* TraversalParent;
} asEntry;
};
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
typedef struct _XBOX_HARDWARE_INFO {
DWORD Flags;
BYTE NumberOfProcessors;
BYTE PCIBridgeRevisionID;
BYTE Reserved[6];
WORD BldrMagic;
WORD BldrFlags;
} XBOX_HARDWARE_INFO, *PXBOX_HARDWARE_INFO;
typedef struct _KERNEL_VERSION {
WORD Major;
WORD Minor;
WORD Build;
BYTE ApprovalType;
BYTE QFE;
} KERNEL_VERSION, *PKERNEL_VERSION;
typedef struct _D3DPRIVATE_RECT {
LONG x1, y1;
LONG x2, y2;
} D3DPRIVATE_RECT, *PD3DPRIVATE_RECT;
typedef struct _D3DFILTER_PARAMETERS {
FLOAT Nyquist;
FLOAT FlickerFilter;
FLOAT Beta;
} D3DFILTER_PARAMETERS, *PD3DFILTER_PARAMETERS;
typedef struct _D3DPRIVATE_SCALER_PARAMETERS {
D3DPRIVATE_RECT ScalerSourceRect;
LONG ScaledOutputWidth;
LONG ScaledOutputHeight;
DWORD VerticalFilterType;
D3DFILTER_PARAMETERS VerticalFilterParameters;
DWORD HorizontalFilterType;
D3DFILTER_PARAMETERS HorizontalFilterParameters;
} D3DPRIVATE_SCALER_PARAMETERS, *PD3DPRIVATE_SCALER_PARAMETERS;
typedef struct _DISPLAY_INFORMATION {
USHORT FrontBufferWidth;
USHORT FrontBufferHeight;
CHAR FrontBufferColorFormat;
CHAR FrontBufferPixelFormat;
D3DPRIVATE_SCALER_PARAMETERS ScalerParameters;
USHORT DisplayWindowOverscanLeft;
USHORT DisplayWindowOverscanTop;
USHORT DisplayWindowOverscanRight;
USHORT DisplayWindowOverscanBottom;
USHORT DisplayWidth;
USHORT DisplayHeight;
FLOAT DisplayRefreshRate;
UINT DisplayInterlaced;
CHAR DisplayColorFormat;
USHORT ActualDisplayWidth;
} DISPLAY_INFORMATION, *PDISPLAY_INFORMATION;
typedef struct _XEX_EXECUTION_ID {
DWORD MediaID;
DWORD Version;
DWORD BaseVersion;
union {
struct {
WORD PublisherID;
WORD GameID;
};
DWORD TitleID;
};
BYTE Platform;
BYTE ExecutableType;
BYTE DiscNum;
BYTE DiscsInSet;
DWORD SaveGameID;
} XEX_EXECUTION_ID, *PXEX_EXECUTION_ID;
// Valid values for the Attributes field
#define OBJ_INHERIT 0x00000002L
#define OBJ_PERMANENT 0x00000010L
#define OBJ_EXCLUSIVE 0x00000020L
#define OBJ_CASE_INSENSITIVE 0x00000040L
#define OBJ_OPENIF 0x00000080L
#define OBJ_OPENLINK 0x00000100L
#define OBJ_VALID_ATTRIBUTES 0x000001F2L
typedef struct _OBJECT_ATTRIBUTES {
HANDLE RootDirectory;
PANSI_STRING ObjectName;
ULONG Attributes;
} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
// object type strings
#define OBJ_TYP_SYMBLINK 0x626d7953
#define OBJ_TYP_DIRECTORY 0x65726944
#define OBJ_TYP_DEVICE 0x69766544
#define OBJ_TYP_EVENT 0x76657645
#define OBJ_TYP_DEBUG 0x63706d64
typedef struct _OBJECT_DIRECTORY_INFORMATION {
ANSI_STRING Name;
DWORD Type;
CHAR NameEx[MAX_PATH];
} OBJECT_DIRECTORY_INFORMATION, *POBJECT_DIRECTORY_INFORMATION;
typedef struct _IO_STATUS_BLOCK {
union {
NTSTATUS Status;
PVOID Pointer;
} st;
ULONG_PTR Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
typedef VOID (NTAPI *PIO_APC_ROUTINE) (
IN PVOID ApcContext,
IN PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG Reserved
);
typedef struct _FILE_DIRECTORY_INFORMATION {
ULONG NextEntryOffset;
ULONG FileIndex;
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
LARGE_INTEGER EndOfFile;
LARGE_INTEGER AllocationSize;
ULONG FileAttributes;
ULONG FileNameLength;
CHAR FileName[MAX_PATH];
} FILE_DIRECTORY_INFORMATION, *PFILE_DIRECTORY_INFORMATION;
typedef struct FILE_BASIC_INFORMATION {
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
ULONG FileAttributes;
} FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
typedef struct _TRANSLATE_SYMLINK
{
DWORD reserved;
PANSI_STRING name;
} TRANSLATE_SYMLINK, *PTRANSLATE_SYMLINK;
typedef struct _DRIVER_OBJECT
{
DWORD Unk[3];
LPVOID Create;
LPVOID Close; // This appears to be when files are closed?
LPVOID Read;
LPVOID Write;
LPVOID QueryInformation;
LPVOID SetInformation;
LPVOID FlushBuffers;
LPVOID QueryVolumeInformation;
LPVOID DirectoryControl;
LPVOID Unk2;
LPVOID CloseHandle; // This appears to be when handles are closed
} DRIVER_OBJECT, *PDRIVER_OBJECT;
#define InitializeObjectAttributes( p, n, a, r){ \
(p)->RootDirectory = r; \
(p)->Attributes = a; \
(p)->ObjectName = n; \
}
NTSTATUS ExGetXConfigSetting(USHORT Category, USHORT Entry, LPVOID Buffer, DWORD cchBuffer, LPDWORD cchOutBuffer);
NTSTATUS ExSetXConfigSetting(USHORT Category, USHORT Entry, LPVOID Buffer, DWORD cchBuffer);
extern XBOX_HARDWARE_INFO* XboxHardwareInfo;
extern KERNEL_VERSION* XboxKrnlVersion;
extern KERNEL_VERSION* XboxKrnlBaseVersion;
extern PLDR_DATA_TABLE_ENTRY* XexExecutableModuleHandle;
extern CONST LPCSTR ExLoadedImageName;
extern DWORD ObDirectoryObjectType;
extern DWORD ObSymbolicLinkObjectType;
extern DWORD IoDeviceObjectType;
extern DWORD* KeDebugMonitorData;
extern DWORD *KeTimeStampBundle;
void KeQuerySystemTime(PULARGE_INTEGER Time);
VOID VdGetCurrentDisplayInformation(PDISPLAY_INFORMATION DisplayInfo);
DWORD KeGetCurrentProcessType();
void ExRegisterTitleTerminateNotification(PEX_TITLE_TERMINATE_REGISTRATION pRegistration, BOOL Register);
void ExRegisterThreadNotification(PEX_THREAD_REGISTRATION pRegistration, BOOL Register);
void RtlInitAnsiString(PANSI_STRING DestinationString, const char* SourceString);
PIMAGE_NT_HEADERS RtlImageNtHeader(PVOID ModuleAddress);
PVOID RtlImageDirectoryEntryToData(PVOID BaseAddress, BOOL MappedAsImage, USHORT Directory, PULONG Size);
void* RtlImageXexHeaderField(void* XexHeaderBase, DWORD Key);
HRESULT XexStartExecutable(FARPROC TitleProcessInitThreadProc);
BOOL XexCheckExecutablePrivilege(DWORD Privilege);
NTSTATUS XexGetModuleHandle(LPCSTR XexName, HMODULE *ModuleHandle);
NTSTATUS XexGetProcedureAddress(HMODULE ModuleHandle, DWORD dwOrdinal, PVOID OutAddress);
NTSTATUS ObCreateSymbolicLink(PANSI_STRING, PANSI_STRING);
NTSTATUS ObDeleteSymbolicLink(PANSI_STRING);
NTSTATUS ObTranslateSymbolicLink(IN PVOID, OUT PANSI_STRING);
NTSTATUS ObOpenObjectByPointer(PVOID Object, PHANDLE Handle);
NTSTATUS NtOpenSymbolicLinkObject(PHANDLE LinkHandle, POBJECT_ATTRIBUTES ObjectAttributes);
NTSTATUS NtQuerySymbolicLinkObject(HANDLE LinkHandle, PANSI_STRING LinkTarget, PULONG ReturnedLength);
NTSTATUS NtQueryVolumeInformationFile(HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, PVOID FileSystemInformation, ULONG Length, FS_INFORMATION_CLASS FileSystemInformationClass); //FILE_FS_SIZE_INFORMATION NormalSizeInfo);
NTSTATUS NtClose(HANDLE Handle);
NTSTATUS NtQueryInformationFile(HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock,
PVOID FileInformation, ULONG Length, FILE_INFORMATION_CLASS FileInformationClass);
NTSTATUS XeKeysGetKey(DWORD KeyNum, void* KeyBuffer, DWORD* KeySize);
NTSTATUS XeKeysSetKey(DWORD KeyNum, void* KeyBuffer, DWORD* KeySize);
NTSTATUS XeKeysGetConsoleID(void* KeyBuffer, char* KeyString);
BOOL MmIsAddressValid(VOID* Address);
PVOID MmCreateKernelStack(DWORD Size, DWORD Type);
DWORD MmGetPhysicalAddress(VOID* Address);
void HalReturnToFirmware(DWORD);
void XapiThreadStartup(void (__cdecl *StartRoutine)(void*), void* StartContext);
DWORD ExCreateThread(PHANDLE pHandle, DWORD dwStackSize,
LPDWORD lpThreadId, VOID* apiThreadStartup ,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter, DWORD dwCreationFlagsMod);
HRESULT HalOpenCloseODDTray(BOOL Open);
NTSTATUS NtSetSystemTime(IN PULARGE_INTEGER SystemTime, OUT PULARGE_INTEGER PreviousTime OPTIONAL);
NTSTATUS NtCreateFile(HANDLE* FileHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes,
PIO_STATUS_BLOCK IoStatusBlock, PLARGE_INTEGER AllocationSize, ULONG FileAttributes,
ULONG ShareAccess, ULONG CreateDisposition, ULONG CreateOptions);
NTSTATUS NtOpenFile(PHANDLE FileHandle, ACCESS_MASK DesiredAccess, POBJECT_ATTRIBUTES ObjectAttributes,
PIO_STATUS_BLOCK IoStatusBlock, ULONG ShareAccess, ULONG OpenOptions);
NTSTATUS NtQueryDirectoryFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,
PIO_STATUS_BLOCK IoStatusBlock, PVOID FileInformation, ULONG Length, PANSI_STRING FileMask, PVOID Unk);
NTSTATUS NtQueryFullAttributesFile(POBJECT_ATTRIBUTES ObjectAttributes, PFILE_NETWORK_OPEN_INFORMATION Attributes );
NTSTATUS NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext,
PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, PLARGE_INTEGER ByteOffset);
NTSTATUS NtWriteFile(HANDLE FileHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK IoStatusBlock, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER ByteOffset OPTIONAL);
NTSTATUS NtOpenDirectoryObject(PHANDLE DirectoryHandle, POBJECT_ATTRIBUTES ObjectAttributes);
NTSTATUS NtQueryDirectoryObject(HANDLE DirectoryHandle, PVOID Buffer, ULONG Length,
BOOLEAN ReturnSingleEntry, PULONG Context, PULONG ReturnLength);
NTSTATUS NtSetInformationFile(HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock,
PVOID FileInformation, ULONG Length, DWORD FileInformationClass);
NTSTATUS NtClose(HANDLE Handle);
NTSTATUS IoCreateDevice(PDRIVER_OBJECT DriverObject, ULONG DeviceExtensionSize, PANSI_STRING DeviceName,
DWORD DeviceType, ULONG DeviceCharacteristics, LPDWORD *DeviceObject);
NTSTATUS IoInvalidDeviceRequest();
UINT32 __stdcall XexLoadExecutable(char* xexName, PHANDLE handle, UINT32 typeInfo, UINT32 ver);
UINT32 __stdcall XexLoadImageFromMemory(char* XexBuffer, DWORD Size, char* xexName, DWORD Flags, DWORD MinVersion, HMODULE* Module);
DWORD KeSuspendThread(HANDLE hThread);
PVOID ExAllocatePoolWithTag(SIZE_T NumberOfBytes, ULONG Tag);
PVOID ExAllocatePoolTypeWithTag(SIZE_T NumberOfBytes, ULONG Tag, ULONG Type);
VOID ExFreePool(PVOID P);
DWORD KeResumeThread(HANDLE hThread);
HRESULT ObLookupAnyThreadByThreadId(DWORD dwThreadId, PKTHREAD *pthr);
VOID ObDereferenceObject(PVOID Object);
NTSTATUS ObReferenceObjectByHandle(HANDLE Handle, DWORD ObjectType, PVOID *Object);
BYTE KfRaiseIrql(BYTE irql);
BYTE KeRaiseIrqlToDpcLevel();
VOID KfLowerIrql(BYTE Irql);
VOID KeEnterCriticalRegion();
VOID KeLeaveCriticalRegion();
BYTE KfAcquireSpinLock(LPVOID Object);
VOID KfReleaseSpinLock(LPVOID Object, BYTE Irql);
VOID KeAcquireSpinLockAtRaisedIrql(LPVOID Object);
VOID KeReleaseSpinLockFromRaisedIrql(LPVOID Object);
NTSTATUS ObCreateObject(PVOID ObjectType, POBJECT_ATTRIBUTES ObjectAttributes, DWORD Unknown, PVOID *Object);
NTSTATUS ObInsertObject(PVOID Object, POBJECT_ATTRIBUTES ObjectAttributes, DWORD Unk, PHANDLE Handle);
VOID IoDeleteDevice(PVOID Object);
NTSTATUS NtCreateDirectoryObject(PHANDLE DirectoryHandle, POBJECT_ATTRIBUTES ObjectAttributes);
BOOL ExTerminateThread(DWORD ReturnCode);
BOOL KeSetEvent(HANDLE Event, DWORD Increment, BOOL Wait);
VOID KeResetEvent(HANDLE Event);
VOID KeSetBasePriorityThread(PKTHREAD Thread, DWORD Priority);
VOID KeSweepIcacheRange(PVOID Address, DWORD cbBytes);
INT KeQueryBasePriorityThread(PVOID pThread);
NTSTATUS ObReferenceObjectByName(PANSI_STRING ObjectName, ULONG Attributes, DWORD ObjectType, DWORD Unk, PVOID *Object);
NTSTATUS IoCompleteRequest(PVOID IoRequest, DWORD Unk);
VOID IoSetShareAccess(ACCESS_MASK DesiredAccess, ULONG DesiredShareAccess, PVOID FileObject, PVOID ShareAccess);
PVOID MmDbgReadCheck(PVOID pAddress);
PVOID MmDbgWriteCheck(PVOID pAddress, PHANDLE pHandle);
VOID MmDbgReleaseAddress(PVOID pAddress, PHANDLE pHandle);
VOID KeSetSpecialPurposeRegister(DWORD dwRegister, ULONGLONG ulValue);
ULONG_PTR KeIpiGenericCall(LPVOID BroadcastFunction, ULONG_PTR Context);
VOID KeStallExecutionProcessor(DWORD);
NTSTATUS KeWaitForSingleObject(PVOID Object, DWORD WaitReason, DWORD WaitMode, BOOL Alertable, PLARGE_INTEGER Timeout);
PVOID XexPcToFileHeader(PVOID address, PLDR_DATA_TABLE_ENTRY* ldatOut);
VOID KeInitializeEvent(PKEVENT Event, DWORD Type, BOOL State);
HRESULT RtlNtStatusToDosError(NTSTATUS Status);
VOID VdDisplayFatalError(DWORD Error);
typedef struct _FILE_OBJECT
{
WORD Type; // 00
WORD Size; // 02
PVOID DeviceObject; // 04
PVOID CustomData; // 08
} FILE_OBJECT, *PFILE_OBJECT;
typedef struct _PARAMS_EVERYWHERE
{
DWORD Unk[18]; // 00 - 44
PANSI_STRING FileName; // 48
} PARAMS_EVERYWHERE, *PPARAMS_EVERYWHERE;
typedef struct _MORE_DRIVER_PARAMS
{
DWORD Unk; // 00
union {
struct {
DWORD dwDesiredAccess; // 04
BYTE bCreationDisposition; // 08
BYTE Unk2; // 09
WORD wCreateOptions; // 0A
DWORD Unk3; // 0C
} CreateFile;
struct {
DWORD dwBytesRequested;
} ReadFile;
};
PANSI_STRING FileName; // 10
DWORD Unk4; // 14
PFILE_OBJECT FileObject; // 18
// 1c
} MORE_DRIVER_PARAMS, *PMORE_DRIVER_PARAMS;
typedef struct _DRIVER_PARAMS
{
DWORD Unk[4]; // 00
// 04
// 08
// 0C
NTSTATUS Status; // 10
DWORD BytesRead; // 14
DWORD Unk2; // 18
PVOID DataBuffer; // 1C
DWORD Unk3[12]; // 20
// 24
// 28
// 2c
// 30
// 34
// 38
// 3c
// 40
// 44
// 48
// 4c
PMORE_DRIVER_PARAMS MoreParams; // 50
} DRIVER_PARAMS, *PDRIVER_PARAMS;
#ifndef InitializeListHead
//
// VOID
// InitializeListHead(
// PLIST_ENTRY ListHead
// );
//
#define InitializeListHead(ListHead) (\
(ListHead)->Flink = (ListHead)->Blink = (ListHead))
//
// BOOLEAN
// IsListEmpty(
// PLIST_ENTRY ListHead
// );
//
#define IsListEmpty(ListHead) \
((ListHead)->Flink == (ListHead))
//
// PLIST_ENTRY
// RemoveHeadList(
// PLIST_ENTRY ListHead
// );
//
#define RemoveHeadList(ListHead) \
(ListHead)->Flink;\
{RemoveEntryList((ListHead)->Flink)}
//
// PLIST_ENTRY
// RemoveTailList(
// PLIST_ENTRY ListHead
// );
//
#define RemoveTailList(ListHead) \
(ListHead)->Blink;\
{RemoveEntryList((ListHead)->Blink)}
//
// VOID
// RemoveEntryList(
// PLIST_ENTRY Entry
// );
//
#define RemoveEntryList(Entry) {\
PLIST_ENTRY _EX_Blink;\
PLIST_ENTRY _EX_Flink;\
_EX_Flink = (Entry)->Flink;\
_EX_Blink = (Entry)->Blink;\
_EX_Blink->Flink = _EX_Flink;\
_EX_Flink->Blink = _EX_Blink;\
}
//
// VOID
// InsertTailList(
// PLIST_ENTRY ListHead,
// PLIST_ENTRY Entry
// );
//
#define InsertTailList(ListHead,Entry) {\
PLIST_ENTRY _EX_Blink;\
PLIST_ENTRY _EX_ListHead;\
_EX_ListHead = (ListHead);\
_EX_Blink = _EX_ListHead->Blink;\
(Entry)->Flink = _EX_ListHead;\
(Entry)->Blink = _EX_Blink;\
_EX_Blink->Flink = (Entry);\
_EX_ListHead->Blink = (Entry);\
}
//
// VOID
// InsertHeadList(
// PLIST_ENTRY ListHead,
// PLIST_ENTRY Entry
// );
//
#define InsertHeadList(ListHead,Entry) {\
PLIST_ENTRY _EX_Flink;\
PLIST_ENTRY _EX_ListHead;\
_EX_ListHead = (ListHead);\
_EX_Flink = _EX_ListHead->Flink;\
(Entry)->Flink = _EX_Flink;\
(Entry)->Blink = _EX_ListHead;\
_EX_Flink->Blink = (Entry);\
_EX_ListHead->Flink = (Entry);\
}
#endif // InitializeListHead

809
xbdm/imp/XeCrypt.h Normal file
View File

@@ -0,0 +1,809 @@
// ---------------------------------------------------------------------------------------
// xecrypt.h
//
// Copyright (C) Microsoft Corporation
// ---------------------------------------------------------------------------------------
#ifndef _XECRYPT_H_
#define _XECRYPT_H_
#ifdef __cplusplus
extern "C" {
#endif
typedef unsigned __int64 QWORD;
#define XECRYPTAPI __stdcall
// ---------------------------------------------------------------------------------------
// DES Cipher
//
// These functions implement symmetric encryption and decryption with the DES cipher.
//
// The DES block size is 8 bytes and the DES key size is 8 bytes.
//
// XeCryptDesKey initializes an XECRYPT_DES_STATE structure from a DES key.
//
// XeCryptDesEcb encrypts or decrypts a single DES block.
//
// XeCryptDesCbc encrypts or decrypts a contiguous series of blocks using cipher block
// chaining. On input the pbFeed parameter is the initialization vector. On output the
// pbFeed parameter is filled with the final ciphertext block.
// ---------------------------------------------------------------------------------------
typedef struct {
unsigned long keytab[16][2];
} XECRYPT_DES_STATE;
#define XECRYPT_DES_BLOCK_SIZE (8)
#define XECRYPT_DES_KEY_SIZE (8)
void XECRYPTAPI XeCryptDesParity(const BYTE * pbInp, DWORD cbInp, BYTE * pbOut);
void XECRYPTAPI XeCryptDesKey(XECRYPT_DES_STATE * pDesState, const BYTE * pbKey);
void XECRYPTAPI XeCryptDesEcb(const XECRYPT_DES_STATE * pDesState, const BYTE * pbInp, BYTE * pbOut, BOOL fEncrypt);
void XECRYPTAPI XeCryptDesCbc(const XECRYPT_DES_STATE * pDesState, const BYTE * pbInp, DWORD cbInp, BYTE * pbOut, BYTE * pbFeed, BOOL fEncrypt);
// ---------------------------------------------------------------------------------------
// DES3 Cipher
//
// These functions implement symmetric encryption and decryption with the DES3 cipher.
//
// The DES3 block size is 8 bytes and the DES3 key size is 24 bytes.
//
// XeCryptDes3Key initializes an XECRYPT_DES3_STATE structure from a DES3 key.
//
// XeCryptDes3Ecb encrypts or decrypts a single DES block.
//
// XeCryptDes3Cbc encrypts or decrypts a contiguous series of blocks using cipher block
// chaining. On input the pbFeed parameter is the initialization vector. On output the
// pbFeed parameter is filled with the final ciphertext block.
// ---------------------------------------------------------------------------------------
typedef struct {
XECRYPT_DES_STATE aDesState[3];
} XECRYPT_DES3_STATE;
#define XECRYPT_DES3_KEY_SIZE (24)
void XECRYPTAPI XeCryptDes3Key(XECRYPT_DES3_STATE * pDes3State, const BYTE * pbKey);
void XECRYPTAPI XeCryptDes3Ecb(const XECRYPT_DES3_STATE * pDes3State, const BYTE * pbInp, BYTE * pbOut, BOOL fEncrypt);
void XECRYPTAPI XeCryptDes3Cbc(const XECRYPT_DES3_STATE * pDes3State, const BYTE * pbInp, DWORD cbInp, BYTE * pbOut, BYTE * pbFeed, BOOL fEncrypt);
// ---------------------------------------------------------------------------------------
// AES Cipher
//
// These functions implement symmetric encryption and decryption with the AES cipher.
//
// The AES block size is 16 bytes and the AES key size is 16 bytes.
//
// XeCryptAesKey initializes an XECRYPT_AES_STATE structure from an AES key.
//
// XeCryptAesEcb encrypts or decrypts a single AES block.
//
// XeCryptAesCbc encrypts or decrypts a contiguous series of blocks using cipher block
// chaining. On input the pbFeed parameter is the initialization vector. On output the
// pbFeed parameter is filled with the final ciphertext block.
// ---------------------------------------------------------------------------------------
typedef struct {
BYTE keytabenc[11][4][4];
BYTE keytabdec[11][4][4];
} XECRYPT_AES_STATE;
#define XECRYPT_AES_BLOCK_SIZE (16)
#define XECRYPT_AES_KEY_SIZE (16)
void XECRYPTAPI XeCryptAesKey(XECRYPT_AES_STATE * pAesState, const BYTE * pbKey);
void XECRYPTAPI XeCryptAesEcb(const XECRYPT_AES_STATE * pAesState, const BYTE * pbInp, BYTE * pbOut, BOOL fEncrypt);
void XECRYPTAPI XeCryptAesCbc(const XECRYPT_AES_STATE * pAesState, const BYTE * pbInp, DWORD cbInp, BYTE * pbOut, BYTE * pbFeed, BOOL fEncrypt);
// ---------------------------------------------------------------------------------------
// RC4 Stream Cipher
//
// These functions implement the RC4 stream cipher.
//
// The RC4 key size can be anywhere from zero to 256 bytes long.
//
// XeCryptRc4Key initializes an XECRYPT_RC4_STATE from an RC4 key.
//
// XeCryptRc4Ecb encrypts or decrypts a stream of bytes.
//
// XeCryptRc4 combines both of the previous functions for convenience.
// ---------------------------------------------------------------------------------------
typedef struct {
BYTE S[256];
BYTE i,j;
} XECRYPT_RC4_STATE;
void XECRYPTAPI XeCryptRc4Key(XECRYPT_RC4_STATE * pRc4State, const BYTE * pbKey, DWORD cbKey);
void XECRYPTAPI XeCryptRc4Ecb(XECRYPT_RC4_STATE * pRc4State, BYTE * pbInpOut, DWORD cbInpOut);
void XECRYPTAPI XeCryptRc4(const BYTE * pbKey, DWORD cbKey, BYTE * pbInpOut, DWORD cbInpOut);
// ---------------------------------------------------------------------------------------
// SHA
//
// These functions implement the SHA-1 one-way hash algorithm. The result of the hash of
// any number of bytes is a digest of 20 bytes.
//
// XeCryptShaInit initializes an XECRYPT_SHA_STATE structure.
//
// Next, for each block of bytes that are to be hashed, call XeCryptShaUpdate. There is
// no limit to the size of the block, and it doesn't matter how the blocks are divided.
//
// Finally, call XeCryptShaFinal to compute the digest. Note that after calling this
// function the digest is available in the "state". The cbOut parameter can be less
// than 20 if only a prefix of the resulting digest is needed. It can be zero if the
// resulting digest will be read directly from the state structure.
//
// For convenience, all of these operations are combined by a single call to XeCryptSha.
// ---------------------------------------------------------------------------------------
typedef struct {
DWORD count;
DWORD state[5];
BYTE buffer[64];
} XECRYPT_SHA_STATE;
#define XECRYPT_SHA_DIGEST_SIZE (20)
void XECRYPTAPI XeCryptShaInit(XECRYPT_SHA_STATE * pShaState);
void XECRYPTAPI XeCryptShaUpdate(XECRYPT_SHA_STATE * pShaState, const BYTE * pbInp, DWORD cbInp);
void XECRYPTAPI XeCryptShaFinal(XECRYPT_SHA_STATE * pShaState, BYTE * pbOut, DWORD cbOut);
void XECRYPTAPI XeCryptSha(const BYTE * pbInp1, DWORD cbInp1, const BYTE * pbInp2, DWORD cbInp2, const BYTE * pbInp3, DWORD cbInp3, BYTE * pbOut, DWORD cbOut);
void XECRYPTAPI XeCryptRotSumSha(const BYTE * pbInp1, DWORD cbInp1, const BYTE * pbInp2, DWORD cbInp2, BYTE * pbOut, DWORD cbOut);
// ---------------------------------------------------------------------------------------
// HMAC-SHA
//
// These functions implement the keyed HMAC-SHA-1 algorithm. The result is a digest of
// 20 bytes.
//
// First, initialize an XECRYPT_HMACSHA_STATE structure by calling XeCryptHmacShaInit with
// a key of up to 64 bytes.
//
// Next, for each block of bytes that are to be hashed, call XeCryptHmacShaUpdate. There
// is no limit to the size of the block, and it doesn't matter how the blocks are divided.
//
// Finally, call XeCryptHmacShaFinal to compute the digest. The cbOut parameter can be
// less than 20 if only a prefix of the resulting digest is needed.
//
// For convenience, all of these operations are combined by a single call to XeCryptSha.
//
// The XeCryptHmacShaVerify function computes the digest just like a single call to
// XeCryptHmacSha, then compares the resulting digest to the expected digest passed in
// through the pbVer/cbVer arguments. Note that cbVer can be less than 20 if only a
// prefix of the resulting digest should be compared. The result is TRUE if the
// computed and expected digests match, and FALSE otherwise.
// ---------------------------------------------------------------------------------------
typedef struct {
XECRYPT_SHA_STATE ShaState[2];
} XECRYPT_HMACSHA_STATE;
void XECRYPTAPI XeCryptHmacShaInit(XECRYPT_HMACSHA_STATE * pHmacShaState, const BYTE * pbKey, DWORD cbKey);
void XECRYPTAPI XeCryptHmacShaUpdate(XECRYPT_HMACSHA_STATE * pHmacShaState, const BYTE * pbInp, DWORD cbInp);
void XECRYPTAPI XeCryptHmacShaFinal(XECRYPT_HMACSHA_STATE * pHmacShaState, BYTE * pbOut, DWORD cbOut);
void XECRYPTAPI XeCryptHmacSha(const BYTE * pbKey, DWORD cbKey, const BYTE * pbInp1, DWORD cbInp1, const BYTE * pbInp2, DWORD cbInp2, const BYTE * pbInp3, DWORD cbInp3, BYTE * pbOut, DWORD cbOut);
BOOL XECRYPTAPI XeCryptHmacShaVerify(const BYTE * pbKey, DWORD cbKey, const BYTE * pbInp1, DWORD cbInp1, const BYTE * pbInp2, DWORD cbInp2, const BYTE * pbInp3, DWORD cbInp3, const BYTE * pbVer, DWORD cbVer);
// ---------------------------------------------------------------------------------------
// MD5
//
// These functions implement the MD5 one-way hash algorithm. The result of the hash of
// any number of bytes is a digest of 16 bytes.
//
// First, initialize an XECRYPT_MD5_STATE structure by calling XeCryptMd5Init.
//
// Next, for each block of bytes that are to be hashed, call XeCryptMd5Update. There is
// no limit to the size of the block, and it doesn't matter how the blocks are divided.
//
// Finally, call XeCryptMd5Final to compute the digest. Note that after calling this
// function the digest is available in the "state". The cbOut parameter can be less
// than 16 if only a prefix of the resulting digest is needed. It can be zero if the
// resulting digest will be read directly from the state structure.
//
// For convenience, all of these operations are combined by a single call to XeCryptMd5.
// ---------------------------------------------------------------------------------------
typedef struct {
DWORD count;
DWORD buf[4];
BYTE in[64];
} XECRYPT_MD5_STATE;
#define XECRYPT_MD5_DIGEST_SIZE (16)
void XECRYPTAPI XeCryptMd5Init(XECRYPT_MD5_STATE * pMd5State);
void XECRYPTAPI XeCryptMd5Update(XECRYPT_MD5_STATE * pMd5State, const BYTE * pbInp, DWORD cbInp);
void XECRYPTAPI XeCryptMd5Final(XECRYPT_MD5_STATE * pMd5State, BYTE * pbOut, DWORD cbOut);
void XECRYPTAPI XeCryptMd5(const BYTE * pbInp1, DWORD cbInp1, const BYTE * pbInp2, DWORD cbInp2, const BYTE * pbInp3, DWORD cbInp3, BYTE * pbOut, DWORD cbOut);
// ---------------------------------------------------------------------------------------
// HMAC-MD5
//
// These functions implement the keyed HMAC-MD5 algorithm. The result is a digest of
// 16 bytes.
//
// First, initialize an XECRYPT_HMACMD5_STATE structure by calling XeCryptHmacMd5Init with
// a key of up to 64 bytes.
//
// Next, for each block of bytes that are to be hashed, call XeCryptHmacMd5Update. There
// is no limit to the size of the block, and it doesn't matter how the blocks are divided.
//
// Finally, call XeCryptHmacMd5Final to compute the digest. The cbOut parameter can be
// less than 20 if only a prefix of the resulting digest is needed.
//
// For convenience, all of these operations are combined by a single call to XeCryptMd5.
// ---------------------------------------------------------------------------------------
typedef struct {
XECRYPT_MD5_STATE Md5State[2];
} XECRYPT_HMACMD5_STATE;
void XECRYPTAPI XeCryptHmacMd5Init(XECRYPT_HMACMD5_STATE * pHmacMd5State, const BYTE * pbKey, DWORD cbKey);
void XECRYPTAPI XeCryptHmacMd5Update(XECRYPT_HMACMD5_STATE * pHmacMd5State, const BYTE * pbInp, DWORD cbInp);
void XECRYPTAPI XeCryptHmacMd5Final(XECRYPT_HMACMD5_STATE * pHmacMd5State, BYTE * pbOut, DWORD cbOut);
void XECRYPTAPI XeCryptHmacMd5(const BYTE * pbKey, DWORD cbKey, const BYTE * pbInp1, DWORD cbInp1, const BYTE * pbInp2, DWORD cbInp2, const BYTE * pbInp3, DWORD cbInp3, BYTE * pbOut, DWORD cbOut);
// ---------------------------------------------------------------------------------------
// Big Number Representations
//
// Multiple precision numbers are arranged as an array of digits, with the least
// significant digit coming first ("little-endian digit ordering"), regardless
// of the word size or byte ordering of the digit itself.
//
// A single digit is either a DWORD (4 bytes) or a QWORD (8 bytes). A bignum that
// consists of a series of DWORD digits is tagged "BnDw", whereas a bignum that
// consists of a series of QWORD digits is tagged "BnQw". A bignum function
// is tagged with one of these two to specify the digit size it expects, and it
// takes a length parameter that specifies the number of digits in the number.
//
// Consider a 8-byte number written in radix 256 notation. Here R=256.
//
// b7*(R^7)+b6*(R^6)+b5*(R^5)+b4*(R^5)+b3*(R^3)+b2*(R^2)+b1*(R^1)+b0*(R^0)
//
// A BnDw bignum consists of a series of DWORD digits. The DWORD can be encoded
// in either little-endian or big-endian byte ordering. Thus there are two
// possible formats for these digits.
//
// DwLe [b0 b1 b2 b3][b4 b5 b6 b7]
// DwBe [b3 b2 b1 b0][b7 b6 b5 b4]
//
// A BnQw bignum consists of a series of QWORD digits. The QWORD can be encoded
// in either little-endian or big-endian byte ordering. Thus there are two
// possible formats for these digits.
//
// QwLe [b0 b1 b2 b3 b4 b5 b6 b7]
// QwBe [b7 b6 b5 b4 b3 b2 b1 b0]
//
// A particular platform has a natural byte order (Le or Be). We use the tag Ne
// to mean the natural byte order.
//
// Most low level bignum routines require inputs that are in QwNe format. That
// is, QWORD digits in natural byte order for the platform. They take an array
// of QWORD digits and a count of digits. The caller is responsible for converting
// the bignum into the expected format.
//
// A full complement of conversion functions is available. The BnDw functions
// will convert a bignum made up of a series of DWORD digits between DwLe, DwBe,
// and DwNe formats. The BnQw functions will convert a bignum made up of a series
// of QWORD digits between QwLe, QwBe, and QwNe formats. The BnQw functions can
// also convert between BnDw and BnQw bignum formats, but since the length parameter
// specifies the number of QWORD digits, the BnDw bignum must contain an even number
// of DWORD digits.
//
// When a bignum is to be stored or used on multiple platforms, the application
// must choose a concrete representation for the number. In the case of digital
// signatures, we choose to store them in QwBe format. This was chosen to match
// the natural word size and byte ordering of the Xenon console, so that the
// signature checking code would be as small and fast as possible on that platform.
// ---------------------------------------------------------------------------------------
void XECRYPTAPI XeCryptBnDw_Zero(DWORD * pdw, DWORD cdw);
void XECRYPTAPI XeCryptBnDw_Copy(const DWORD * pdwInp, DWORD * pdwOut, DWORD cdw);
void XECRYPTAPI XeCryptBnDw_SwapLeBe(const DWORD * pdwInp, DWORD * pdwOut, DWORD cdw);
void XECRYPTAPI XeCryptBnQw_Zero(QWORD * pqw, DWORD cqw);
void XECRYPTAPI XeCryptBnQw_Copy(const QWORD * pqwInp, QWORD * pqwOut, DWORD cqw);
void XECRYPTAPI XeCryptBnQw_SwapLeBe(const QWORD * pqwInp, QWORD * pqwOut, DWORD cqw);
void XECRYPTAPI XeCryptBnQw_SwapDwQw(const QWORD * pqwInp, QWORD * pqwOut, DWORD cqw);
void XECRYPTAPI XeCryptBnQw_SwapDwQwLeBe(const QWORD * pqwInp, QWORD * pqwOut, DWORD cqw);
#define XeCryptBnDw_DwLeToDwLe XeCryptBnDw_Copy
#define XeCryptBnDw_DwLeToDwBe XeCryptBnDw_SwapLeBe
#define XeCryptBnDw_DwBeToDwLe XeCryptBnDw_SwapLeBe
#define XeCryptBnDw_DwBeToDwBe XeCryptBnDw_Copy
#define XeCryptBnQw_DwLeToDwLe XeCryptBnQw_Copy
#define XeCryptBnQw_DwLeToDwBe XeCryptBnQw_SwapLeBe
#define XeCryptBnQw_DwLeToQwLe XeCryptBnQw_Copy
#define XeCryptBnQw_DwLeToQwBe XeCryptBnQw_SwapDwQwLeBe
#define XeCryptBnQw_DwBeToDwLe XeCryptBnQw_SwapLeBe
#define XeCryptBnQw_DwBeToDwBe XeCryptBnQw_Copy
#define XeCryptBnQw_DwBeToQwLe XeCryptBnQw_SwapLeBe
#define XeCryptBnQw_DwBeToQwBe XeCryptBnQw_SwapDwQw
#define XeCryptBnQw_QwLeToDwLe XeCryptBnQw_Copy
#define XeCryptBnQw_QwLeToDwBe XeCryptBnQw_SwapLeBe
#define XeCryptBnQw_QwLeToQwLe XeCryptBnQw_Copy
#define XeCryptBnQw_QwLeToQwBe XeCryptBnQw_SwapDwQwLeBe
#define XeCryptBnQw_QwBeToDwLe XeCryptBnQw_SwapDwQwLeBe
#define XeCryptBnQw_QwBeToDwBe XeCryptBnQw_SwapDwQw
#define XeCryptBnQw_QwBeToQwLe XeCryptBnQw_SwapDwQwLeBe
#define XeCryptBnQw_QwBeToQwBe XeCryptBnQw_Copy
#ifdef _M_PPCBE
#define XeCryptBnDw_DwLeToDwNe XeCryptBnDw_DwLeToDwBe
#define XeCryptBnDw_DwBeToDwNe XeCryptBnDw_DwBeToDwBe
#define XeCryptBnDw_DwNeToDwLe XeCryptBnDw_DwBeToDwLe
#define XeCryptBnDw_DwNeToDwBe XeCryptBnDw_DwBeToDwBe
#define XeCryptBnQw_DwLeToDwNe XeCryptBnQw_DwLeToDwBe
#define XeCryptBnQw_DwLeToQwNe XeCryptBnQw_DwLeToQwBe
#define XeCryptBnQw_DwBeToDwNe XeCryptBnQw_DwBeToDwBe
#define XeCryptBnQw_DwBeToQwNe XeCryptBnQw_DwBeToQwBe
#define XeCryptBnQw_QwLeToDwNe XeCryptBnQw_QwLeToDwBe
#define XeCryptBnQw_QwLeToQwNe XeCryptBnQw_QwLeToQwBe
#define XeCryptBnQw_QwBeToDwNe XeCryptBnQw_QwBeToDwBe
#define XeCryptBnQw_QwBeToQwNe XeCryptBnQw_QwBeToQwBe
#define XeCryptBnQw_DwNeToDwLe XeCryptBnQw_DwBeToDwLe
#define XeCryptBnQw_DwNeToDwBe XeCryptBnQw_DwBeToDwBe
#define XeCryptBnQw_DwNeToQwLe XeCryptBnQw_DwBeToQwLe
#define XeCryptBnQw_DwNeToQwBe XeCryptBnQw_DwBeToQwBe
#define XeCryptBnQw_QwNeToDwLe XeCryptBnQw_QwBeToDwLe
#define XeCryptBnQw_QwNeToDwBe XeCryptBnQw_QwBeToDwBe
#define XeCryptBnQw_QwNeToQwLe XeCryptBnQw_QwBeToQwLe
#define XeCryptBnQw_QwNeToQwBe XeCryptBnQw_QwBeToQwBe
#else
#define XeCryptBnDw_DwLeToDwNe XeCryptBnDw_DwLeToDwLe
#define XeCryptBnDw_DwBeToDwNe XeCryptBnDw_DwBeToDwLe
#define XeCryptBnDw_DwNeToDwLe XeCryptBnDw_DwLeToDwLe
#define XeCryptBnDw_DwNeToDwBe XeCryptBnDw_DwLeToDwBe
#define XeCryptBnQw_DwLeToDwNe XeCryptBnQw_DwLeToDwLe
#define XeCryptBnQw_DwLeToQwNe XeCryptBnQw_DwLeToQwLe
#define XeCryptBnQw_DwBeToDwNe XeCryptBnQw_DwBeToDwLe
#define XeCryptBnQw_DwBeToQwNe XeCryptBnQw_DwBeToQwLe
#define XeCryptBnQw_QwLeToDwNe XeCryptBnQw_QwLeToDwLe
#define XeCryptBnQw_QwLeToQwNe XeCryptBnQw_QwLeToQwLe
#define XeCryptBnQw_QwBeToDwNe XeCryptBnQw_QwBeToDwLe
#define XeCryptBnQw_QwBeToQwNe XeCryptBnQw_QwBeToQwLe
#define XeCryptBnQw_DwNeToDwLe XeCryptBnQw_DwLeToDwLe
#define XeCryptBnQw_DwNeToDwBe XeCryptBnQw_DwLeToDwBe
#define XeCryptBnQw_DwNeToQwLe XeCryptBnQw_DwLeToQwLe
#define XeCryptBnQw_DwNeToQwBe XeCryptBnQw_DwLeToQwBe
#define XeCryptBnQw_QwNeToDwLe XeCryptBnQw_QwLeToDwLe
#define XeCryptBnQw_QwNeToDwBe XeCryptBnQw_QwLeToDwBe
#define XeCryptBnQw_QwNeToQwLe XeCryptBnQw_QwLeToQwLe
#define XeCryptBnQw_QwNeToQwBe XeCryptBnQw_QwLeToQwBe
#endif
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeCompare
//
// This function compares two multiple precision numbers in BnQwNe format and returns:
//
// -1 if aqwA[] < aqwB[]
// 0 if aqwA[] = aqwB[]
// +1 if aqwA[] > aqwB[]
// ---------------------------------------------------------------------------------------
int XECRYPTAPI XeCryptBnQwNeCompare(const QWORD * pqwA, const QWORD * pqwB, DWORD cqw);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeModInv
//
// This function computes the 2-adic inverse of a QWORD (mod 2^64).
// ---------------------------------------------------------------------------------------
QWORD XECRYPTAPI XeCryptBnQwNeModInv(QWORD qw);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeModMul
//
// This function performs Montgomery multiplication.
//
// All numbers must be in BnQwNe format and have cqw digits.
//
// The result of this function is:
//
// aqwA[] * aqwB[]
// aqwC[] = --------------- MOD aqwM[]
// 2^(cqw*64)
// ---------------------------------------------------------------------------------------
void XECRYPTAPI XeCryptBnQwNeModMul(const QWORD * pqwA, const QWORD * pqwB, QWORD * pqwC, QWORD qwMI, const QWORD * pqwM, DWORD cqw);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeModExp
//
// This function performs modular exponentiation.
//
// All numbers must be in BnQwNe format and have cqw digits.
//
// The result of this function is:
//
// aqwA[] = (aqwB[] ^ aqwC[]) MOD aqwM[]
//
// This function returns FALSE if there was not enough memory to allocate storage for
// intermediate results, or if one or more of the inputs is invalid (such as zero modulus),
// otherwise TRUE is returned.
// ---------------------------------------------------------------------------------------
BOOL XECRYPTAPI XeCryptBnQwNeModExp(QWORD * pqwA, const QWORD * pqwB, const QWORD * pqwC, const QWORD * pqwM, DWORD cqw);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeModExpRoot
//
// This function performs modular exponentiation to an exponent and modulus given by its
// prime factors and coefficients. This is a support routine for exponentiating to a
// private RSA key. It is more efficient than exponentiating to the private exponent
// directly, but the result is otherwise the same.
//
// All numbers must be in BnQwNe format. The pqwA and pqwB numbers have cqw * 2 digits.
// All of the other numbers have cqw digits.
//
// The result of this function is:
//
// aqwA[] = (aqwB[] ^ aqwC[]) MOD aqwM[]
//
// where aqwC[] and aqwM[] are implicitly provided by their constituent parts.
//
// This function returns FALSE if there was not enough memory to allocate storage for
// intermediate results, or if one or more of the inputs is invalid (such as a zero modulus),
// otherwise TRUE is returned.
// ---------------------------------------------------------------------------------------
BOOL XECRYPTAPI XeCryptBnQwNeModExpRoot(QWORD * pqwA, const QWORD * pqwB, const QWORD * pqwPP, const QWORD * pqwQQ, const QWORD * pqwDP, const QWORD * pqwDQ, const QWORD * pqwCR, DWORD cqw);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeRsaPubCrypt
// XeCryptBnQwNeRsaPrvCrypt
//
// These functions performs modular exponentiation of a message to the public or private
// exponent of the given RSA key.
//
// The aqwA[] parameter must be in BnQwNe format and have cqw digits. It's value must
// be less than the modulus.
//
// The result of this function is:
//
// aqwB[] = (aqwA[] ^ dwPubExp) MOD aqwM[] (XeCryptBnQwNeRsaPubCrypt)
// aqwB[] = (aqwA[] ^ aqwPrvExp[]) MOD aqwM[] (XeCryptBnQwNeRsaPrvCrypt)
// ---------------------------------------------------------------------------------------
typedef struct {
DWORD cqw; // Number of QWORD digits in modulus
DWORD dwPubExp; // Public exponent
QWORD qwReserved; // Reserved (was qwMI)
// QWORD aqwM[cqw]; // [BnQwNe] Modulus
// QWORD aqwP[cqw/2]; // [BnQwNe] Private prime P
// QWORD aqwQ[cqw/2]; // [BnQwNe] Private prime Q
// QWORD aqwDP[cqw/2]; // [BnQwNe] Private exponent P
// QWORD aqwDQ[cqw/2]; // [BnQwNe] Private exponent Q
// QWORD aqwCR[cqw/2]; // [BnQwNe] Private coefficient
} XECRYPT_RSA;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[16]; // [BnQwNe] Modulus
} XECRYPT_RSAPUB_1024;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[24]; // [BnQwNe] Modulus
} XECRYPT_RSAPUB_1536;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[32]; // [BnQwNe] Modulus
} XECRYPT_RSAPUB_2048;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[64]; // [BnQwNe] Modulus
} XECRYPT_RSAPUB_4096;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[16]; // [BnQwNe] Modulus
QWORD aqwP[8]; // [BnQwNe] Private prime P
QWORD aqwQ[8]; // [BnQwNe] Private prime Q
QWORD aqwDP[8]; // [BnQwNe] Private exponent P
QWORD aqwDQ[8]; // [BnQwNe] Private exponent Q
QWORD aqwCR[8]; // [BnQwNe] Private coefficient
} XECRYPT_RSAPRV_1024;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[24]; // [BnQwNe] Modulus
QWORD aqwP[12]; // [BnQwNe] Private prime P
QWORD aqwQ[12]; // [BnQwNe] Private prime Q
QWORD aqwDP[12]; // [BnQwNe] Private exponent P
QWORD aqwDQ[12]; // [BnQwNe] Private exponent Q
QWORD aqwCR[12]; // [BnQwNe] Private coefficient
} XECRYPT_RSAPRV_1536;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[32]; // [BnQwNe] Modulus
QWORD aqwP[16]; // [BnQwNe] Private prime P
QWORD aqwQ[16]; // [BnQwNe] Private prime Q
QWORD aqwDP[16]; // [BnQwNe] Private exponent P
QWORD aqwDQ[16]; // [BnQwNe] Private exponent Q
QWORD aqwCR[16]; // [BnQwNe] Private coefficient
} XECRYPT_RSAPRV_2048;
typedef struct {
XECRYPT_RSA Rsa; // Common header
QWORD aqwM[64]; // [BnQwNe] Modulus
QWORD aqwP[32]; // [BnQwNe] Private prime P
QWORD aqwQ[32]; // [BnQwNe] Private prime Q
QWORD aqwDP[32]; // [BnQwNe] Private exponent P
QWORD aqwDQ[32]; // [BnQwNe] Private exponent Q
QWORD aqwCR[32]; // [BnQwNe] Private coefficient
} XECRYPT_RSAPRV_4096;
BOOL XECRYPTAPI XeCryptBnQwNeRsaPubCrypt(const QWORD * pqwA, QWORD * pqwB, const XECRYPT_RSA * pRsa);
BOOL XECRYPTAPI XeCryptBnQwNeRsaPrvCrypt(const QWORD * pqwA, QWORD * pqwB, const XECRYPT_RSA * pRsa);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeRsaKeyGen
//
// This function generates a random RSA key pair.
//
// The cbits parameter specifies the number of bits in the modulus. It must be a multiple
// of 128, and must be between 512 and 4096.
//
// The dwPubExp parameter specifies the public exponent.
//
// The pRsaPub and pRsaPrv parameters must point to XECRYPT_RSA structures that are large
// enough to hold the public and private keys requested. The public key structure needs
// to be at least sizeof(XECRYPT_RSA) + (cbits / 8) bytes big. The private key structure
// needs to be at least sizeof(XECRYPT_RSA) + (((cbits / 2) * 7) / 8) bytes big.
// ---------------------------------------------------------------------------------------
BOOL XECRYPTAPI XeCryptBnQwNeRsaKeyGen(DWORD cbits, DWORD dwPubExp, XECRYPT_RSA * pRsaPub, XECRYPT_RSA * pRsaPrv);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwBeSigFormat
// XeCryptBnQwBeSigCreate
// XeCryptBnQwBeSigVerify
//
// These functions format, create, and verify digital signatures using an RSA key pair.
//
// The size of the RSA key must be 2048 bits and the public exponent must be 3 or 65537.
// The size of a digital signature is 256 bytes. The signature is represented as a bignum
// in BnQwBe format. This allows for processing digital signatures on platforms with
// different byte orders.
//
// The XeCryptBnQwBeSigFormat function takes a 20 byte hash and a 10 byte fixed salt value
// and generates a digital signature using the PKCS #1 v2.1 RSASSA-PSS algorithm. The
// hash function is SHA and the MGF function is RC4. The resulting digital signature
// is stored in the XECRYPT_SIG structure.
//
// The XeCryptBnQwBeSigCreate function takes a 20 byte hash and a 10 byte fixed salt
// value, generates a digital signature, and then pre-compensates it by multiplying the
// signature by a scale factor derived from the modulus in the public key. This
// pre-compensation is used to simplify verification later.
//
// The XeCryptQwBeSigVerify function takes an encrypted digital signature, a 20 byte hash
// a 10 byte fixed salt value, and an RSA public key. It returns TRUE if the digital
// signature, when decrypted with the RSA public key, matches the result of formatting
// a digital signature with the 20 byte hash and 10 byte salt value, and FALSE otherwise.
// ---------------------------------------------------------------------------------------
typedef struct { // [BnQwBe]
QWORD aqwPad[28]; // Padding
BYTE bOne; // 0x01
BYTE abSalt[10]; // Salt
BYTE abHash[20]; // Hash
BYTE bEnd; // 0xBC
} XECRYPT_SIG;
void XECRYPTAPI XeCryptBnQwBeSigFormat(XECRYPT_SIG * pSig, const BYTE * pbHash, const BYTE * pbSalt);
BOOL XECRYPTAPI XeCryptBnQwBeSigCreate(XECRYPT_SIG * pSig, const BYTE * pbHash, const BYTE * pbSalt, const XECRYPT_RSA * pRsa);
BOOL XECRYPTAPI XeCryptBnQwBeSigVerify(XECRYPT_SIG * pSig, const BYTE * pbHash, const BYTE * pbSalt, const XECRYPT_RSA * pRsa);
// ---------------------------------------------------------------------------------------
// XeCryptBnDwLePkcs1Format
// XeCryptBnDwLePkcs1Verify
//
// These functions format and verify a SHA digest in PKCS#1 format and BnDwLe bignum
// representation. This format matches what was used on Xbox 1 and what is normally
// produced by nCipher devices.
//
// The pbHash argument specifies the digest to format or verify.
//
// When formatting, the dwType argument selects one of three encoding formats, as follows.
//
// 0: [HashReversed][140400051A02030E2B05060930213000][FF ... FF][0100]
// 1: [HashReversed][14041A02030E2B050607301F3000][FF ... FF][0100]
// >1: [HashReversed][00][FF ... FF][0100]
//
// On Xbox 1, signatures would always be encoded using format 0, but any of these formats
// were accepted by the verification routine. We follow the same rules when calling
// XeCryptBnDwLePkcs1Verify.
//
// The pbSig argument specifies the buffer to place the formatted signature, or the buffer
// containing the signature to verify.
//
// The cbSig argument specifies the size of the signature buffer. It should be equal to
// the number of bytes in the RSA key modulus. For example, if this siguature is used
// with an RSA key whose modulus is 1024 bits, you would specify 128 for this argument.
// ---------------------------------------------------------------------------------------
void XECRYPTAPI XeCryptBnDwLePkcs1Format(const BYTE * pbHash, DWORD dwType, BYTE * pbSig, DWORD cbSig);
BOOL XECRYPTAPI XeCryptBnDwLePkcs1Verify(const BYTE * pbHash, const BYTE * pbSig, DWORD cbSig);
// ---------------------------------------------------------------------------------------
// XeCryptBnDwLeDhModExp
//
// These functions perform Diffie-Hellman modular exponentiation.
//
// The inputs and outputs are in BnDwLe format for compatibility with legacy applications.
// Note, however, that the XECRYPT_DH structure is always BnQwNe format.
//
// The pDh argument can be NULL in any of these functions, in which case the standard
// 768-bit Oakley Group 1 constants will be used.
//
// The XeCryptBnDwLeDhModExp function performs modular exponentiation. The pdwA argument
// specifies the base to be exponentiated. If it is NULL, then the generator in the
// XECRYPT_DH structure is used as the base.
//
// The pdwB argument specifies the exponent.
//
// The result is stored in the pdwC argument.
//
// aqwC[] = ((pqwA ? pqwA[] : pDh->aqwG[]) ^ aqwB[]) MOD pDh->aqwM[]
//
// The XeCryptBnDwLeDhInvalBase function returns TRUE if the pdwA argument is an invalid
// base for exponentiation. A valid base is 1 < aqwA[] < (aqwM[]-1).
//
// The XeCryptBnDwLeDhEqualBase function returns TRUE if the pdwA argument is equal to
// the pDh->aqwG[].
// ---------------------------------------------------------------------------------------
typedef struct {
DWORD cqw; // Number of QWORD digits in modulus
DWORD dwReserved; // Reserved
// QWORD aqwM[cqw]; // [BnQwNe] Modulus
// QWORD aqwG[cqw]; // [BnQwNe] Generator
} XECRYPT_DH;
typedef struct {
XECRYPT_DH Dh; // Common header
QWORD aqwM[12]; // [BnQwNe] Modulus
QWORD aqwG[12]; // [BnQwNe] Generator
} XECRYPT_DH_768;
typedef struct {
XECRYPT_DH Dh; // Common header
QWORD aqwM[16]; // [BnQwNe] Modulus
QWORD aqwB[16]; // [BnQwNe] Generator
} XECRYPT_DH_1024;
BOOL XECRYPTAPI XeCryptBnDwLeDhModExp(const DWORD * pdwA, const DWORD * pdwB, DWORD * pdwC, const XECRYPT_DH * pDh);
BOOL XECRYPTAPI XeCryptBnDwLeDhInvalBase(const DWORD * pdwA, const XECRYPT_DH * pDh);
BOOL XECRYPTAPI XeCryptBnDwLeDhEqualBase(const DWORD * pdwA, const XECRYPT_DH * pDh);
// ---------------------------------------------------------------------------------------
// XeCryptBnQwNeEcSigVerify
//
// This function uses eliptic curve exponentiation to verify a digital signature.
//
// The pEcPub argument specifies the public key to use when verifying the signature.
//
// The pbMsg argument is the same sequence of bytes that was used when the signature
// was generated.
//
// The cbMsg argument specifies the number of byte in pbMsg.
//
// The pbSig argument is the sequence of bytes that make up the signature. The size of
// this signature is defined by the sum of the cbitR, cbitS, and cbitA fields of the
// public key, rounded up to the next byte.
//
// If the public key fails to verify the supplied signature, FALSE is returned. If the
// public key successfully verifies the signature, then the sequence number that was
// encoded in the signature is returned in the pqwSeq out argument. The number of bits
// in the sequence number is given by the cbitN field of the public key.
// ---------------------------------------------------------------------------------------
typedef struct {
DWORD cqw; // Number of QWORD digits in modulus
BYTE cbitR; // This many bits of signature form R
BYTE cbitS; // This many bits of signature form S (after R)
BYTE cbitA; // This many bits of signature form A (after S)
BYTE cbitN; // This many bits of sequence number are returned
// QWORD aqwM[cqw]; // [BnQwNe] Modulus
// QWORD aqwC[cqw*2]; // [BnQwNe] Curve
// QWORD aqwG[cqw*2]; // [BnQwNe] Generator
// QWORD aqwGX[cqw*2]; // [BnQwNe] Generator ^ X (private exponent)
} XECRYPT_ECPUB;
typedef struct {
XECRYPT_ECPUB EcPub; // Common header
QWORD aqwM[8]; // [BnQwNe] Modulus
QWORD aqwC[16]; // [BnQwNe] Curve
QWORD aqwG[16]; // [BnQwNe] Generator
QWORD aqwGP[16]; // [BnQwNe] Generator ^ X (private exponent)
} XECRYPT_ECPUB_512;
BOOL XECRYPTAPI XeCryptBnQwNeEcSigVerify(const XECRYPT_ECPUB * pEcPub, const BYTE * pbMsg, DWORD cbMsg, const BYTE * pbSig, QWORD * pqwSeq);
// ---------------------------------------------------------------------------------------
// XeCryptRandom
//
// This function generates a series of cryptographically strong random bits.
// ---------------------------------------------------------------------------------------
void XECRYPTAPI XeCryptRandom(BYTE * pb, DWORD cb);
// ---------------------------------------------------------------------------------------
// Parve Cipher
//
// These functions implement symmetric encryption and CBC MAC generation using the Parve
// cipher. There is no support for symmetric decryption.
//
// The Parve block size is 8 bytes and the key size is 8 bytes.
//
// XeCryptParveEcb encrypts a single Parve block with the given key and the given Sbox.
// The pbKey parameter points to an 8 byte key. The pbSbox parameter points to a 256
// "private key" array. The pbInp parameter points to the 8 bytes to be encrypted. The
// pbOut parameter points to a location to store the encrypted 8 bytes. The pbInp and
// pbOut parameters can point to the same location.
//
// XeCryptParveCbcMac computes an 8 byte MAC from a contiguous series of Parve blocks
// using cipher block chaining. The pbKey parameter specifies the key to use. The
// pbSbox parameter points to a 256 "private key" array. The pbIv argument specifies the
// 8 byte initialization vector to use. The pbOut parameter specifies the location to
// store the 8 byte MAC result.
// ---------------------------------------------------------------------------------------
#define XECRYPT_PARVE_BLOCK_SIZE (8)
#define XECRYPT_PARVE_KEY_SIZE (8)
#define XECRYPT_PARVE_SBOX_SIZE (256)
#define XECRYPT_PARVE_MAC_SIZE (8)
void XECRYPTAPI XeCryptParveEcb(const BYTE * pbKey, const BYTE * pbSbox, const BYTE * pbInp, BYTE * pbOut);
void XECRYPTAPI XeCryptParveCbcMac(const BYTE * pbKey, const BYTE * pbSbox, const BYTE * pbIv, const BYTE * pbInp, DWORD cbInp, BYTE * pbOut);
// ---------------------------------------------------------------------------------------
// XeCryptChainAndSumMac
//
// This function implements the Chain & Sum MAC algorithm.
//
// The pdwCD parameter points to a pair of DWORD values that will be used as the C and D
// constants of the algorithm.
//
// The pdwAB parameter points to a pair of DWORD values that will be used as the A and B
// constants of the algorithm.
//
// The pdwInp parameter points to a series of DWORD values to be consumed as input to
// the algorithm. The cdwInp parameter specifies the number of DWORD values in this
// array. It must be a multiple of two, as the input is consumed in pairs. If it is
// an odd number, it will be truncated.
//
// The pdwOut parameter points to a location in which a pair of DWORD results are stored.
// ---------------------------------------------------------------------------------------
void XECRYPTAPI XeCryptChainAndSumMac(const DWORD * pdwCD, const DWORD * pdwAB, const DWORD * pdwInp, DWORD cdwInp, DWORD * pdwOut);
#ifdef __cplusplus
};
#endif
#endif

119
xbdm/imp/automation.h Normal file
View File

@@ -0,0 +1,119 @@
#pragma once
/*++
Copyright (c) Microsoft Corporation
Module Name:
Automation.h
Abstract:
This module contains the code to interact with the test automation
framework. This consists of providing the hooks into the system for
recording the interaction between the title and the system for future
playback and the spoofing of function calls for unit testing UI or
to unit test functions by directly altering input parameters.
The majority of the work is accomplished by coordinating with the
TestXex application for manipulating the message. This coordination
is done synchronously and should not be too expensive. Unfortunately
making it asynchronous (even for async messaging) isn't an option if
we need to spoof the hr or other parameters.
--*/
// More useful and descriptive definitions to work with for code readers.
#define AUTO_PROCEED false // Corresponds to a result of S_FALSE
#define AUTO_SKIP true // Corresponds to a result of S_OK
#define AUTO_PRESEND true
#define AUTO_POSTSEND false
#if TESTAUTOMATION
/* There are three states of interest to automation:
1. I didn't do anything, proceed as normal
2. I altered the parameters proceed as normal
3. I altered the results skip the remaining operations
From a behaviour point of view the 1st and 2nd can be rolled into
each other.
*/
typedef HRESULT (WINAPI *SetupOverlappedFunction)(
PXOVERLAPPED pOverlapped,
PXASYNCMESSAGE pMsg
);
bool
WINAPI
AutomationSetNotification(
DWORD *pdwMessage,
ULONG_PTR *ppParam,
DWORD *pdwUser,
HRESULT *phr
);
bool
WINAPI
AutomationSendAsyncMessage(
HXAMAPP hxamapp,
PXASYNCMESSAGE pMsg,
HRESULT *phr
);
bool
WINAPI
AutomationSendMessage(
bool fIsPresend,
HXAMAPP hxamapp,
DWORD dwMessage,
UINT_PTR *ppParam1,
UINT_PTR *ppParam2,
HRESULT *phr
);
bool
WINAPI
AutomationSendAppLoadMessage(
LPCSTR pszSysApp
);
VOID
WINAPI
AutomationInitialize();
VOID
WINAPI
AutomationCleanup();
VOID
WINAPI
AutomationTitleShutdown();
BOOL
WINAPI
AutomationAsyncMessageInProgress(
PXASYNCMESSAGE pMsg
);
BOOL
WINAPI
AutomationInputGetState(
IN DWORD dwUserIndex,
IN OUT XINPUT_STATE *pXInputState
);
#else // !TESTAUTOMATION
#define g_fAutomation FALSE
#define AutomationInitialize()
#define AutomationCleanup()
#define AutomationTitleShutdown()
#define AutomationSetNotification(A, B, C, D) AUTO_PROCEED
#define AutomationSendAsyncMessage(A, B, C) FALSE
#define AutomationSendMessage(A, B, C, D, E, F) AUTO_PROCEED
#define AutomationAsyncMessageInProgress(A) FALSE
#define AutomationInputGetState(A, B) FALSE
#define AutomationSendAppLoadMessage(A) AUTO_PROCEED
#endif // TESTAUTOMATION

383
xbdm/imp/cabinet.h Normal file
View File

@@ -0,0 +1,383 @@
/*** cabinet.h - Definitions for Cabinet File structure
*
* Author:
* Benjamin W. Slivka
*
* History:
* 15-Aug-1993 bens Initial version
* 05-Sep-1993 bens Added Overview section
* 29-Nov-1993 chuckst Added disk names to folder first & next
* Used "CF" consistently
* Eliminated redundant cch fields
* 09-Feb-1994 chuckst merged in some related global constants
* 09-Mar-1994 bens Add RESERVE defintions (for encryption)
* 17-Mar-1994 bens Improve comments about split CFDATA structures
* 25-Mar-1994 bens Add cabinet set ID
* 13-May-1994 bens Define bad value for iCabinet
*
* Overview:
* This file contains definitions for the Diamond Cabinet File format.
* A Cabinet File exists to store one or more files. Usually these
* files have been compressed, but that is not required. It is also
* possible for a cabinet file to contain only a portion of a larger
* file.
*
* In designing this format, the following goals where achieved:
* 1) Minimize overhead in the CF format
* ==> Where ever possible BYTEs or USHORTs were used, rather
* than using LONGs, even though the latter would be easier
* to manipulate on certain RISC platforms.
* 2) Support little-endian and big-endian byte ordering.
* ==> For simplicity on x86 systems, multi-byte numbers are
* stored in a little-endian form, but the code to read and
* write these numbers operates correctly on either type of
* computer.
*
* A cabinet file contains the following structures in the following
* order:
* Name Description
* ----------- -------------------
* CFHEADER Cabinet description
* [CFRESERVE] Optional RESERVED control information in CFHEADER
* CFFOLDER(s) Folder descriptions
* [reserved] Optional RESERVED data per folder
* CFFILE(s) File descriptions
* CFDATA(s) Data blocks
* [reserved] Optional RESERVED data per data block
*
* Data Integrity Strategy:
* The Cabinet File has built-in data integrity checks, since it is
* possible for customers to have damaged diskettes, or for accidental
* or malicious damage to occur. Rather than doing an individual
* checksum for the entire cabinet file (which would have a dramatic
* impact on the speed of installation from floppy disk, since the
* entire file would need to be read), we have per-component
* checksums, and compute and check them as we read the various
* components of the file.
*
* 1) Checksum CFHEADER
* 2) Store cabinet file length in CFHEADER (to detect file truncation)
* 3) Checksum entire set of CFFOLDER structures
* 4) Checksum entire set of CFFILE structures
* 5) Checksum each (compressed) data block independantly
*
* This approach allows us to avoid reading unnecessary parts of the
* file cabinet (though reading all of CFFOLDER and CFFILE structures
* would otherwise not be required in all cases), while still providing
* adequate integrity checking.
*/
#ifndef INCLUDED_CABINET
#define INCLUDED_CABINET 1
//** Pack structures tightly in cabinet files!
#pragma pack(1)
/*** verCF - Cabinet File format version
*
* The low-order byte is interpreted as a decimal number for the minor
* (1/100ths) portion of the version number.
* The high-order byte is interpreted as a decimal number for the major
* portion of the version number.
*
* Examples:
* 0x0000 0.00
* 0x010A 1.10
* 0x0410 4.16
*
* History:
* 1.01 Original
* 1.02 Added flags field, changed signature
* 1.03 Added setId,iCabinet so FDI can ensure correct cabinet
* on continuation.
*/
#define verCF 0x0103 // CF version 1.03
/*** Various cabinet file limits
*
*/
#define cMAX_FOLDERS_PER_CABINET (ifoldMASK-1)
#define cMAX_FILES_PER_CABINET 65535
/*** cbRESERVE_XXX_MAX - Maximum size of RESERVE sections
*
* NOTE: cbRESERVE_HEADER_MAX is a fair bit less than 64K because in
* the 16-bit version of this code, we want to have a USHORT
* variable that holds the size of the CFHEADER structure +
* the size of the CFRESERVE structure + the size of the per-header
* reserved data.
*/
//BUGBUG 16-Mar-1994 bens Define better bound for cbRESERVE_HEADER_MAX
#define cbRESERVE_HEADER_MAX 60000 // Fits in a USHORT
#define cbRESERVE_FOLDER_MAX 255 // Fits in a BYTE
#define cbRESERVE_DATA_MAX 255 // Fits in a BYTE
/*** ifoldXXXX - Special values for CFFILE.iFolder
*
*/
#define ifoldMASK 0xFFFC // Low two bits zero
#define ifoldCONTINUED_FROM_PREV 0xFFFD
#define ifoldCONTINUED_TO_NEXT 0xFFFE
#define ifoldCONTINUED_PREV_AND_NEXT 0xFFFF
#define IS_CONTD_FORWARD(ifold) ((ifold & 0xfffe) == ifoldCONTINUED_TO_NEXT)
#define IS_CONTD_BACK(ifold) ((ifold & 0xfffd) == ifoldCONTINUED_FROM_PREV)
#ifndef MAKESIG
/*** MAKESIG - Construct a 4 byte signature
*
* Entry:
* ch1,ch2,ch3,ch4 - four characters
*
* Exit:
* returns unsigned long
*/
#define MAKESIG(ch1,ch2,ch3,ch4) \
( ((unsigned long)ch1) + \
(((unsigned long)ch2)<< 8) + \
(((unsigned long)ch3)<<16) + \
(((unsigned long)ch4)<<24) )
#endif // !MAKESIG
#define sigCFHEADER MAKESIG('M','S','C','F') // CFHEADER signature
/*** cfhdrXXX - bit flags for cfheader.flags field
*
*/
#define cfhdrPREV_CABINET 0x0001 // Set if previous cab/disk present
#define cfhdrNEXT_CABINET 0x0002 // Set if next cab/disk present
#define cfhdrRESERVE_PRESENT 0x0004 // Set if RESERVE_CONTROL is present
typedef unsigned long CHECKSUM; /* checksum */
typedef unsigned long UOFF; /* uoff - uncompressed offset */
typedef unsigned long COFF; /* coff - cabinet file offset */
/*** CFHEADER - Cabinet File Header
*
*/
typedef struct {
//** LONGs are first, to ensure alignment
long sig; // Cabinet File identification string
CHECKSUM csumHeader; // Structure checksum (excluding csumHeader!)
long cbCabinet; // Total length of file (consistency check)
CHECKSUM csumFolders; // Checksum of CFFOLDER list
COFF coffFiles; // Location in cabinet file of CFFILE list
CHECKSUM csumFiles; // Checksum of CFFILE list
//** SHORTs are next, to ensure alignment
USHORT version; // Cabinet File version (verCF)
USHORT cFolders; // Count of folders (CFIFOLDERs) in cabinet
USHORT cFiles; // Count of files (CFIFILEs) in cabinet
USHORT flags; // Flags to indicate optional data presence
USHORT setID; // Cabinet set ID (identifies set of cabinets)
USHORT iCabinet; // Cabinet number in set (0 based)
#define iCABINET_BAD 0xFFFF // Illegal number for iCabinet
//** If flags has the cfhdrRESERVE_PRESENT bit set, then a CFRESERVE
// structure appears here, followed possibly by some CFHEADER reserved
// space. The CFRESERVE structure has fields to define how much reserved
// space is present in the CFHEADER, CFFOLDER, and CFDATA structures.
// If CFRESERVE.cbCFHeader is non-zero, then abReserve[] immediately
// follows the CFRESERVE structure. Note that all of these sizes are
// multiples of 4 bytes, to ensure structure alignment!
//
// CFRESERVE cfres; // Reserve information
// BYTE abReserve[]; // Reserved data space
//
//** The following fields presence depends upon the settings in the flags
// field above. If cfhdrPREV_CABINET is set, then there are two ASCIIZ
// strings to describe the previous disk and cabinet.
//
// NOTE: This "previous" cabinet is not necessarily the immediately
// preceding cabinet! While it usually will be, if a file is
// continued into the current cabinet, then the "previous"
// cabinet identifies the cabinet where the folder that contains
// this file *starts*! For example, if EXCEL.EXE starts in
// cabinet excel.1 and is continued through excel.2 to excel.3,
// then cabinet excel.3 will point back to *cabinet.1*, since
// that is where you have to start in order to extract EXCEL.EXE.
//
// char szCabinetPrev[]; // Prev Cabinet filespec
// char szDiskPrev[]; // Prev descriptive disk name
//
// Similarly, If cfhdrNEXT_CABINET is set, then there are two ASCIIZ
// strings to describe the next disk and cabinet:
//
// char szCabinetNext[]; // Next Cabinet filespec
// char szDiskNext[]; // Next descriptive disk name
//
} CFHEADER; /* cfheader */
/*** CFRESERVE - Cabinet File Reserved data information
*
* This structure is present in the middle of the CFHEADER structure if
* CFHEADER.flags has the cfhdrRESERVE_PRESENT bit set. This structure
* defines the sizes of all the reserved data sections in the CFHEADER,
* CFFOLDER, and CFDATA structures.
*
* These reserved sizes can be zero (although it would be silly to have
* all of them be zero), but otherwise must be a multiple of 4, to ensure
* structure alignment for RISC machines.
*/
typedef struct {
USHORT cbCFHeader; // Size of abReserve in CFHEADER structure
BYTE cbCFFolder; // Size of abReserve in CFFOLDER structure
BYTE cbCFData; // Size of abReserve in CFDATA structure
} CFRESERVE; /* cfreserve */
#define cbCF_HEADER_BAD 0xFFFF // Bad value for CFRESERVE.cbCFHeader
/*** CFFOLDER - Cabinet Folder
*
* This structure describes a partial or complete "compression unit".
* A folder is by definition a stream of compressed data. To retrieve
* an uncompressed data from a folder, you *must* start decompressing
* the data at the start of the folder, regardless of how far into the
* folder the data you want actually starts.
*
* Folders may start in one cabinet, and continue on to one or more
* succeeding cabinets. In general, if a folder has been continued over
* a cabinet boundary, Diamond/FCI will terminate that folder as soon as
* the current file has been completely compressed. Generally this means
* that a folder would span at most two cabinets, but if the file is really
* large, it could span more than two cabinets.
*
* Note: CFFOLDERs actually refer to folder *fragments*, not necessarily
* complete folders. You know that a CFFOLDER is the beginning of a
* folder (as opposed to a continuation in a subsequent cabinet file)
* if a file starts in it (i.e., the CFFILE.uoffFolderStart field is
* 0).
*/
typedef struct {
COFF coffCabStart; // Offset in cabinet file of first CFDATA
// block for this folder.
USHORT cCFData; // Count of CFDATAs for this folder that
// are actually in this cabinet. Note that
// a folder can continue into another cabinet
// and have many more CFDATA blocks in that
// cabinet, *and* a folder may have started
// in a previous cabinet. This count is
// only of CFDATAs for this folder that are
// (at least partially) in this cabinet.
short typeCompress; // Indicates compression type for all CFDATA
// blocks for this folder. The valid values
// are defined in the types.h built into
// fci.h/fdi.h.
//** If CFHEADER.flags has the cfhdrRESERVE_PRESENT bit set, and
// CFRESERVE.cbCFFolder is non-zero, then abReserve[] appears here.
//
// BYTE abReserve[]; // Reserved data space
//
} CFFOLDER; /* cffolder */
/*** CFFILE - Cabinet File structure describing a single file in the cabinet
*
* NOTE: iFolder is used to indicatate continuation cases, so we have to
* calculate the real iFolder by examining the cabinet files:
*
* ifoldCONTINUED_FROM_PREV
* This file ends in this cabinet, but is continued from a
* previous cabinet. Therefore, the portion of the file contained
* in *this* cabinet *must* start in the first folder.
*
* NOTE: szCabinetPrev is the name of the cabinet where this file
* *starts*, which is not necessarily the immediately
* preceeding cabinet! Since it only makes sense to
* decompress a file from its start, the starting cabinet
* is what is important!
*
* ifoldCONTINUED_TO_NEXT
* This file starts in this cabinet, but is continued to the next
* cabinet. Therfore, this file must start in the *last* folder
* in this cabinet.
*
* ifoldCONTINUED_PREV_AND_NEXT
* This file is the *middle* portion of a file that started in a
* previous cabinet and is continued in the next cabinet. Since
* this cabinet only contain this piece of a single file, there
* is only a single folder fragment in this cabinet.
*/
typedef struct {
long cbFile; // Uncompressed size of file
UOFF uoffFolderStart; // Offset in folder IN UNCOMPRESSED BYTES
// of the start of this file
USHORT iFolder; // Index of folder containing this file;
// 0 is first folder in this cabinet.
// See ifoldCONTINUED_XXXX values above
// for treatment of continuation files.
USHORT date; // Date stamp in FAT file system format
USHORT time; // Time stamp in FAT file system format
USHORT attribs; // Attribute in FAT file system format
// char szName[]; // File name (may include path characters)
} CFFILE; /* cffile */
/*** CFDATA - Cabinet File structure describing a data block
*
*/
typedef struct {
CHECKSUM csum; // Checksum (excluding this field itself!)
// of this structure and the data that
// follows. If this CFDATA structure is
// continued to the next cabinet, then
// the value of this field is ignored
// (and set to zero).
USHORT cbData; // Size of ab[] data that resides in the
// current cabinet. A CFDATA may be split
// across a cabinet boundary, so this
// value indicates only the amount of data
// store in this cabinet.
USHORT cbUncomp; // Uncompressed size of ab[] data; if this
// CFDATA block is continued to the next
// cabinet, then this value is zero!
// If this CFDATA block the remainder of
// of a CFDATA block that started in the
// previous cabinet, then this value is
// the total size of the uncompressed data
// represented by the two CFDATA blocks!
//** If CFHEADER.flags has the cfhdrRESERVE_PRESENT bit set, and
// CFRESERVE.cbCFData is non-zero, then abReserve[] appears here.
//
// BYTE abReserve[]; // Reserved data space
//
//** The actual data follows here, cbData bytes in length.
//
// BYTE ab[]; // Data
//
} CFDATA; /* cfdata */
//** Attribute Bit to use for Run after extract
#define RUNATTRIB 0x40
//** Revert to default structure packing!
#pragma pack()
#endif // !INCLUDED_CABINET

58
xbdm/imp/consolecert.h Normal file
View File

@@ -0,0 +1,58 @@
/************************************************************************
* *
* consolecert.h -- Xenon Console Certificate Definition *
* *
* Copyright (c) Microsoft Corp. All rights reserved. *
* *
************************************************************************/
#ifndef _CONSOLECERT_H_
#define _CONSOLECERT_H_
#define CONSOLE_PUBLIC_KEY_EXPONENT_SIZE 4
#define CONSOLE_PUBLIC_KEY_MODULUS_SIZE 128
#define CONSOLE_ID_SIZE 5
#define CONSOLE_CERT_PART_NUMBER_SIZE 11
#define CONSOLE_CERTIFICATE_RESERVED_SIZE 6
#define CONSOLE_CERTIFICATE_HASH_SIZE 20
#define CONSOLE_CERTIFICATE_SIGNATURE_SIZE 256
#pragma pack(push, 1)
typedef struct _CONSOLE_PUBLIC_KEY
{
BYTE PublicExponent[CONSOLE_PUBLIC_KEY_EXPONENT_SIZE]; // In Big endian
BYTE Modulus[CONSOLE_PUBLIC_KEY_MODULUS_SIZE]; // In QWORD Big endian
} CONSOLE_PUBLIC_KEY;
typedef struct _XE_CONSOLE_CERTIFICATE
{
USHORT CertSize; // Size of this sturcture (424)
BYTE ConsoleId[CONSOLE_ID_SIZE]; // Uniquely ids console
BYTE ConsolePartNumber[CONSOLE_CERT_PART_NUMBER_SIZE]; // Identifies mfg part number
BYTE Reserved[CONSOLE_CERTIFICATE_RESERVED_SIZE]; // Reserved for future use
ULONG ConsoleType; // States whether console is a retail or dev/test kit
UINT64 ManufacturingDate; // Date of mfg for console
CONSOLE_PUBLIC_KEY ConsolePublicKey; // Console's Public Key
BYTE Signature[CONSOLE_CERTIFICATE_SIGNATURE_SIZE]; // RsaSign(MasterKey.Private, CertSize thru ConsolePublicKey)
} XE_CONSOLE_CERTIFICATE;
typedef struct _XE_CONSOLE_SIGNATURE
{
XE_CONSOLE_CERTIFICATE Cert;
BYTE Signature[CONSOLE_PUBLIC_KEY_MODULUS_SIZE];
} XE_CONSOLE_SIGNATURE;
#define XE_CONSOLE_TYPE_MASK 0x00FFFFFF
#define XE_CONSOLE_TYPE_DEVKIT 0x00000001
#define XE_CONSOLE_TYPE_RETAIL 0x00000002
#define XE_CONSOLE_TYPE_TESTKIT 0x40000000
#define XE_CONSOLE_TYPE_TEMPORARY_KEY 0x80000000
#pragma pack(pop)
#endif // _CONSOLECERT_H_

368
xbdm/imp/contentpkg.h Normal file
View File

@@ -0,0 +1,368 @@
/************************************************************************
* *
* contentpkg.h -- Xenon Content Package Definition *
* *
* Copyright (c) Microsoft Corp. All rights reserved. *
* *
************************************************************************/
#ifndef _CONTENTPKG_H_
#define _CONTENTPKG_H_
#include "consolecert.h"
#pragma pack(push, 1)
//
// Everything in the header is stored in big-endian format.
//
//------------------------------------------------------------------------------
typedef enum _XCONTENT_SIGNATURE_TYPE
{
CONSOLE_SIGNED = 'CON ',
LIVE_SIGNED = 'LIVE',
PIRS_SIGNED = 'PIRS',
} XCONTENT_SIGNATURE_TYPE;
//------------------------------------------------------------------------------
typedef struct _XCONTENT_SIGNATURE {
BYTE Signature[256];
BYTE Reserved[296];
} XCONTENT_SIGNATURE, *PXCONTENT_SIGNATURE;
C_ASSERT(sizeof(XE_CONSOLE_SIGNATURE) == sizeof(XCONTENT_SIGNATURE));
//------------------------------------------------------------------------------
#define XCONTENT_UNRESTRICTED_LICENSEE ((ULONGLONG) 0xFFFFFFFFFFFFFFFF)
#define XCONTENT_LICENSE_FLAG_REQUIRE_ONLINE 0x00000001
typedef struct _XCONTENT_LICENSE {
ULONGLONG LicenseeId;
DWORD LicenseBits;
DWORD LicenseFlags;
} XCONTENT_LICENSE, *PXCONTENT_LICENSE;
//------------------------------------------------------------------------------
typedef struct _XCONTENT_HEADER {
//
// Indicates how the content was signed.
//
XCONTENT_SIGNATURE_TYPE SignatureType;
//
// Signature information. The signature covers the remainder of this
// XCONTENT_HEADER structure starting immediately after the signature
// field.
//
union {
XE_CONSOLE_SIGNATURE ConsoleSignature;
XCONTENT_SIGNATURE ContentSignature;
} Signature;
//
// Licensing information a fixed array of 16 license descriptors.
//
XCONTENT_LICENSE LicenseDescriptors[16];
//
// ContentId is the SHA-1 digest of the XCONTENT_METADATA header and all
// subsequent headers. This digests everything up to the start of the
// package file system blob, including the alignment padding, even though
// the padding is not included in SizeOfHeaders below. In other words,
// round the SizeOfHeaders value up to the next alignment boundary, then
// subtract sizeof(XCONTENT_HEADER), and that's how many bytes to hash
// starting after immediately this XCONTENT_HEADER structure.
//
BYTE ContentId[XECRYPT_SHA_DIGEST_SIZE];
//
// Specifies the total size of useable header information, including this
// header, but not including any alignment padding (even though the
// padding is included in the ContentId digest).
//
ULONG SizeOfHeaders;
} XCONTENT_HEADER, *PXCONTENT_HEADER;
//------------------------------------------------------------------------------
#define XCONTENT_THUMBNAIL_WIDTH 64
#define XCONTENT_THUMBNAIL_HEIGHT 64
#define XCONTENT_THUMBNAIL_BITDEPTH 32
#define XCONTENT_THUMBNAIL_SIZE (XCONTENT_THUMBNAIL_WIDTH * XCONTENT_THUMBNAIL_HEIGHT * (XCONTENT_THUMBNAIL_BITDEPTH / 8))
typedef struct _XCONTENT_METADATA {
//
// Type of content represented (XCONTENTTYPE_*).
//
DWORD ContentType;
//
// Reserved value for future extensibility, must be zero.
//
DWORD Reserved1;
//
// Size of file system blob after headers. Note that some helper routines
// choose to add in the size of the header block as well when passing this
// information around for convenience, but in storage/when hashed this
// should only include the file system blob.
//
LARGE_INTEGER ContentSize;
//
// Execution ID of the title for which content package was generated.
//
XEX_EXECUTION_ID ExecutionId;
//
// ID of console on which this content was created, or all zeros if not
// created by a console.
//
BYTE ConsoleId[CONSOLE_ID_SIZE];
//
// XUID of user that created this content package, or all zeros if not
// created by a user.
//
ULONGLONG Creator;
//
// Root digest of files and other information generated by the embedded
// file system.
//
BYTE StfsVolumeDescriptor[36];
//
// Reserved bytes for future extensibility, must be zero.
//
BYTE Reserved2[96];
//
// ID of device on which content package was created.
//
BYTE DeviceId[20];
//
// Display name for content package.
//
WCHAR DisplayName[9][XCONTENT_MAX_DISPLAYNAME_LENGTH];
//
// Description of content package.
//
WCHAR Description[9][XCONTENT_MAX_DISPLAYNAME_LENGTH];
//
// Name of publisher of content package.
//
WCHAR Publisher[64];
//
// Title Name for content package.
//
WCHAR TitleName[64];
//
// Package flags.
//
union {
struct {
//
// Bit indicating whether this content package may be transferred
// to another profile.
//
BYTE ProfileTransfer : 1;
//
// Bit indicating whether this content package may be transferred
// to another device.
//
BYTE DeviceTransfer : 1;
//
// Reserved bits, must be 0.
//
BYTE Reserved : 6;
} Bits;
BYTE FlagsAsBYTE;
} Flags;
//
// Embedded content package thumbnail size in bytes.
//
DWORD ThumbnailSize;
//
// Embedded content package title thumbnail size in bytes.
//
DWORD TitleThumbnailSize;
//
// Embedded content package thumbnail graphic icon.
//
BYTE Thumbnail[XCONTENT_THUMBNAIL_SIZE];
//
// Embedded content package title thumbnail graphic icon.
//
BYTE TitleThumbnail[XCONTENT_THUMBNAIL_SIZE];
} XCONTENT_METADATA, *PXCONTENT_METADATA;
//------------------------------------------------------------------------------
typedef struct _XCONTENT_METADATA_TITLE_CONTENT {
//
// Reserved, must be zero. This is used to make the structure the same
// size as XCONTENT_METADATA_INSTALLER_PROGRESS_CACHE (when part of the
// XCONTENT_METADATA_INSTALLER structure).
//
BYTE Reserved[5620];
} XCONTENT_METADATA_TITLE_CONTENT;
//------------------------------------------------------------------------------
typedef struct _XCONTENT_METADATA_INSTALLER_SYSTEM_UPDATE {
//
// Current version for which update applies, or 0 for all derivatives of
// the base version.
//
DWORD CurrentVersion;
//
// New version to which the update will upgrade.
//
DWORD NewVersion;
//
// Reserved, must be zero. This is used to make the structure the same
// size as XCONTENT_METADATA_INSTALLER_PROGRESS_CACHE when combined with
// the XCONTENT_METADATA_INSTALLER structure.
//
BYTE Reserved[5608];
} XCONTENT_METADATA_INSTALLER_SYSTEM_UPDATE;
//------------------------------------------------------------------------------
typedef struct _XCONTENT_METADATA_INSTALLER_TITLE_UPDATE {
//
// System version to which update is restricted, or 0 for all system
// versions.
//
DWORD SystemVersion;
//
// New version to which the update will upgrade.
//
DWORD NewVersion;
//
// Reserved, must be zero. This is used to make the structure the same
// size as XCONTENT_METADATA_INSTALLER_PROGRESS_CACHE when combined with
// the XCONTENT_METADATA_INSTALLER structure.
//
BYTE Reserved[5608];
} XCONTENT_METADATA_INSTALLER_TITLE_UPDATE;
//------------------------------------------------------------------------------
typedef struct _XCONTENT_METADATA_INSTALLER_PROGRESS_CACHE {
//
// Download installer progress cache information.
//
XONLINECONTENT_RESUME_HEADER ResumeHeader;
//
// Extra storage space for CAB resume information.
//
BYTE CabResumeData[XONLINECONTENT_MAX_SINGLE_FILE_RESUME_DATA_SIZE];
} XCONTENT_METADATA_INSTALLER_PROGRESS_CACHE;
//------------------------------------------------------------------------------
typedef enum _INSTALLER_METADATA_TYPE
{
INSTALLER_METADATA_TYPE_SYSTEM_UPDATE = 'SUPD',
INSTALLER_METADATA_TYPE_TITLE_UPDATE = 'TUPD',
INSTALLER_METADATA_TYPE_PROGRESS_CACHE_SYSTEM_UPDATE = 'P$SU',
INSTALLER_METADATA_TYPE_PROGRESS_CACHE_TITLE_UPDATE = 'P$TU',
INSTALLER_METADATA_TYPE_PROGRESS_CACHE_TITLE_CONTENT = 'P$TC',
} INSTALLER_METADATA_TYPE;
//------------------------------------------------------------------------------
typedef struct _XCONTENT_METADATA_INSTALLER {
//
// Type of installer package.
//
INSTALLER_METADATA_TYPE MetaDataType;
//
// Union of type specific metadata structures.
//
union {
XCONTENT_METADATA_INSTALLER_SYSTEM_UPDATE SystemUpdate;
XCONTENT_METADATA_INSTALLER_TITLE_UPDATE TitleUpdate;
XCONTENT_METADATA_INSTALLER_PROGRESS_CACHE InstallProgressCache;
} MetaData;
} XCONTENT_METADATA_INSTALLER;
C_ASSERT(sizeof(XCONTENT_METADATA_TITLE_CONTENT) == sizeof(XCONTENT_METADATA_INSTALLER));
//------------------------------------------------------------------------------
//
// Headers must be zero padded to meet this alignment requirement for the start
// of the embedded file system volume.
//
#define XCONTENT_FILE_SYSTEM_ALIGNMENT (4 * 1024)
#define XCONTENT_ROUND_UP_TO_ALIGNMENT(size) (((size) + (XCONTENT_FILE_SYSTEM_ALIGNMENT - 1)) & (~(XCONTENT_FILE_SYSTEM_ALIGNMENT - 1)))
#define XCONTENT_ALIGNMENT_PADDING_NEEDED(size) (XCONTENT_ROUND_UP_TO_ALIGNMENT(size) - (size))
//
// The file system blob/tools expect to deal with volumes that are marked as
// having sizes that are even multiples of a megabyte.
//
#define XCONTENT_FILE_SYSTEM_VOLUME_SIZE_UNITS (1024 * 1024)
#define XCONTENT_ROUND_UP_TO_VOLUME_SIZE(size) (((size) + (XCONTENT_FILE_SYSTEM_VOLUME_SIZE_UNITS - 1)) & (~(XCONTENT_FILE_SYSTEM_VOLUME_SIZE_UNITS - 1)))
//
// Define reasonable maximum values for content package header fields (or
// implied values). The constants are somewhat arbitrary, but chosen to be
// small enough so as to to avoid 32 bit integer overflow issues. This
// simplifies validation for the consumer to just needing to validate the
// individual pieces against their respective values.
//
#define XCONTENT_MIN_HEADERS_SIZE (sizeof(XCONTENT_HEADER) + sizeof(XCONTENT_METADATA))
#define XCONTENT_MAX_OTHER_METADATA_SIZE 0x01000000
#define XCONTENT_MAX_HEADERS_SIZE 0x10000000
C_ASSERT(((DWORD) XCONTENT_MAX_HEADERS_SIZE + (DWORD) sizeof(XCONTENT_HEADER)) > (DWORD) XCONTENT_MAX_HEADERS_SIZE);
C_ASSERT(((DWORD) XCONTENT_MAX_HEADERS_SIZE + (DWORD) sizeof(XCONTENT_HEADER) + (DWORD) sizeof(XCONTENT_METADATA)) > (DWORD) XCONTENT_MAX_HEADERS_SIZE);
C_ASSERT(((DWORD) XCONTENT_MAX_HEADERS_SIZE + (DWORD) sizeof(XCONTENT_HEADER) + (DWORD) sizeof(XCONTENT_METADATA) + (DWORD) XCONTENT_MAX_OTHER_METADATA_SIZE) > (DWORD) XCONTENT_MAX_HEADERS_SIZE);
C_ASSERT(((DWORD) XCONTENT_MAX_HEADERS_SIZE + (DWORD) sizeof(XCONTENT_HEADER) + (DWORD) sizeof(XCONTENT_METADATA) + (DWORD) XCONTENT_MAX_OTHER_METADATA_SIZE + (DWORD) XCONTENT_FILE_SYSTEM_ALIGNMENT) > (DWORD) XCONTENT_MAX_HEADERS_SIZE);
#define XCONTENT_MIN_CONTENT_SIZE 256
#define XCONTENT_MAX_CONTENT_SIZE 0x00000000FFFFFFFF
#pragma pack(pop)
#endif // _CONTENTPKG_H_

419
xbdm/imp/kernelp.h Normal file
View File

@@ -0,0 +1,419 @@
// kernelp.h
// THE ACCURACY OF THIS DATA IS UNDETERMINED!!
#ifndef _KERNELP_DEFINES_H
#define _KERNELP_DEFINES_H
// *********** PACKING STARTS HERE **************//
#pragma pack(push, 1)
// *********** PACKING STARTS HERE **************//
typedef struct _OBJECT_HANDLE_TABLE{
LONG HandleCount;
DWORD FirstFreeTableOffset;
DWORD TableAllocation;
PVOID RootTable; // was VOID ***
PVOID BuiltinRootTable[8];// was VOID **
DWORD SpinLock;
BYTE PoolType;
BYTE Discriminant;
BYTE Terminating;
} OBJECT_HANDLE_TABLE, *POBJECT_HANDLE_TABLE;
typedef struct _KAPC{
short Type;
BYTE ApcMode;
BYTE Inserted;
struct _KTHREAD * Thread;
LIST_ENTRY ApcListEntry;
void * KernelRoutine; // function ptr
void * RundownRoutine; // function ptr
void * NormalRoutine; // function ptr
void * NormalContext;
void * SystemArgument1;
void * SystemArgument2;
} KAPC, *PKAPC; // 40
typedef struct _DISPATCHER_HEADER{
BYTE Type;
BYTE Absolute;
BYTE ProcessType;
BYTE Inserted;
long SignalState;
LIST_ENTRY WaitListHead;
} DISPATCHER_HEADER, *PDISPATCHER_HEADER; // 16
typedef struct _KEVENT{
DISPATCHER_HEADER Header;
} KEVENT, *PKEVENT; // 16
typedef struct _KDPC{
short Type;
BYTE InsertedNumber;
BYTE TargetNumber;
LIST_ENTRY DpcListEntry;
void * DeferredRoutine; // function *
void * DeferredContext;
void * SystemArgument1;
void * SystemArgument2;
} KDPC, *PKDPC; // 28
typedef struct _KWAIT_BLOCK{
LIST_ENTRY WaitListEntry;
struct _KTHREAD* Thread;
void * Object;
struct _KWAIT_BLOCK * NextWaitBlock;
USHORT WaitKey;
USHORT WaitType;
} KWAIT_BLOCK, *PKWAIT_BLOCK; // 24
typedef struct _KTIMER{
DISPATCHER_HEADER Header;
ULARGE_INTEGER DueTime;
LIST_ENTRY TimerListEntry;
PKDPC Dpc;
long Period;
} KTIMER, *PKTIMER; // 40
typedef struct _KPROCESS{
DWORD ThreadListLock;
LIST_ENTRY ThreadListHead;
long ThreadQuantum;
DWORD DirectoryTableBase;
DWORD ThreadCount;
BYTE IdlePriorityClass;
BYTE NormalPriorityClass;
BYTE TimeCriticalPriorityClass;
BYTE DisableQuantum;
DWORD DefaultKernelStackSize;
void * TlsStaticDataImage;
DWORD SizeOfTlsStaticData;
DWORD SizeOfTlsStaticDataImage;
USHORT SizeOfTlsSlots;
BYTE Terminating;
BYTE ProcessType;
DWORD TlsSlotBitmap[8];
DWORD FileObjectListLock;
LIST_ENTRY FileObjectListHead;
void * Win32DefaultHeapHandle;
} KPROCESS, *PKPROCESS; // 96
typedef struct _KSEMAPHORE{
DISPATCHER_HEADER Header;
INT32 Limit;
} KSEMAPHORE, *PKSEMAPHORE; // 20
typedef struct _KQUEUE{
DISPATCHER_HEADER Header;
LIST_ENTRY EntryListHead;
DWORD CurrentCount;
DWORD MaximumCount;
LIST_ENTRY ThreadListHead;
} KQUEUE, *PKQUEUE; // 40
typedef struct _KINTERRUPT{
void * ServiceRoutine; // function *
void * ServiceContext;
DWORD SpinLock;
DWORD ServiceCount;
BYTE BusIrql;
BYTE Irql;
BYTE Connected : 1; // this bitfield may need swapping
BYTE Mode : 7;
BYTE TargetNumber;
} KINTERRUPT, *PKINTERRUPT; // 20
typedef struct _KTRAP_FRAME{
STACK_FRAME_HEADER Header;
ULONGLONG Gpr0;
ULONGLONG Gpr1;
ULONGLONG Gpr2;
ULONGLONG Gpr3;
ULONGLONG Gpr4;
ULONGLONG Gpr5;
ULONGLONG Gpr6;
ULONGLONG Gpr7;
ULONGLONG Gpr8;
ULONGLONG Gpr9;
ULONGLONG Gpr10;
ULONGLONG Gpr11;
ULONGLONG Gpr12;
ULONGLONG Gpr13;
ULONGLONG Gpr14;
ULONGLONG Gpr15;
ULONGLONG Gpr16;
ULONGLONG Gpr17;
ULONGLONG Gpr18;
ULONGLONG Gpr19;
ULONGLONG Gpr20;
ULONGLONG Gpr21;
ULONGLONG Gpr22;
ULONGLONG Gpr23;
ULONGLONG Gpr24;
ULONGLONG Gpr25;
ULONGLONG Gpr26;
ULONGLONG Gpr27;
ULONGLONG Gpr28;
ULONGLONG Gpr29;
ULONGLONG Gpr30;
ULONGLONG Gpr31;
union{
struct{
BYTE OldIrql;
PKINTERRUPT InterruptObject;
BYTE InterruptIrql;
} asIrq;
BYTE ExceptionRecord[80];
};
ULONGLONG Ctr;
DWORD Lr;
DWORD Iar;
DWORD Cr;
DWORD Msr;
DWORD Xer;
DWORD UserModeControl;
} KTRAP_FRAME, *PKTRAP_FRAME; // 448
typedef struct _KTHREAD{
DISPATCHER_HEADER Header;
LIST_ENTRY MutantListHead;
KTIMER Timer;
KWAIT_BLOCK TimerWaitBlock;
DWORD KernelTime;
void * StackBase;
void * StackLimit;
void * KernelStack;
void * TlsData;
BYTE State;
BYTE Alerted[2];
BYTE Alertable;
BYTE Priority;
BYTE FpuExceptionEnable;
BYTE CreateProcessType;
BYTE CurrentProcessType;
LIST_ENTRY ApcListHead[2];
PKPROCESS Process;
BYTE KernelApcInProgress;
BYTE KernelApcPending;
BYTE UserApcPending;
BYTE ApcQueueable;
DWORD ApcQueueLock;
DWORD ContextSwitches;
LIST_ENTRY ReadyListEntry;
union{
struct{
USHORT MsrEnableMaskHigh;
USHORT MsrEnableMaskLow;
};
DWORD MsrEnableMask;
};
long WaitStatus;
BYTE WaitIrql;
BYTE WaitMode;
BYTE WaitNext;
BYTE WaitReason;
PKWAIT_BLOCK WaitBlockList;
DWORD Padding1;
DWORD KernelApcDisable;
long Quantum;
char Saturation;
BYTE BasePriority;
BYTE PriorityDecrement;
BYTE DisableBoost;
char SuspendCount;
BYTE Preempted;
BYTE HasTerminated;
BYTE CurrentProcessor;
struct _KPRCB* CurrentPrcb;
struct _KPRCB* AffinityPrcb;
BYTE IdlePriorityClass;
BYTE NormalPriorityClass;
BYTE TimeCriticalPriorityClass;
BYTE HasAsyncTerminated;
DWORD ActiveTimerListLock;
void * StackAllocatedBase;
KAPC SuspendApc;
KSEMAPHORE SuspendSemaphore;
LIST_ENTRY ThreadListEntry;
DWORD Padding2;
PKQUEUE Queue;
LIST_ENTRY QueueListEntry;
void * UserModeDispatcher; // function *
PKTRAP_FRAME UserModeTrapFrame;
LARGE_INTEGER CreateTime;
LARGE_INTEGER ExitTime;
long ExitStatus;
LIST_ENTRY ActiveTimerListHead;
void * ThreadId;
void * StartAddress; // function *
LIST_ENTRY IrpList;
void * DebugMonitorData;
DWORD LastWin32ErrorCode;
void * Win32CurrentFiber;
DWORD Padding3;
DWORD CreateOptions;
float Vscr[4];
float Vr[4][128];
double Fpscr;
double Fpr[32];
KAPC TerminateApc;
} KTHREAD, *PKTHREAD; // 2736
// *********** PACKING ENDS HERE **************//
#pragma pack(pop)
// *********** PACKING ENDS HERE **************//
typedef struct _KPRCB{
PKTHREAD CurrentThread;
PKTHREAD NextThread;
PKTHREAD IdleThread;
BYTE Number;
DWORD SetMember;
DWORD DpcTime;
DWORD InterruptTime;
DWORD InterruptCount;
volatile DWORD IpiFrozen;
volatile void * CurrentPacket[3];
volatile DWORD TargetSet;
volatile void * WorkerRoutine; // function *
struct _KPRCB * SignalDone;
volatile DWORD RequestSummary;
DWORD DpcInterruptRequested;
DWORD DpcLock;
LIST_ENTRY DpcListHead;
DWORD DpcRoutineActive;
DWORD ReadyListLock;
DWORD IdleThreadActive;
SINGLE_LIST_ENTRY DeferredReadyListHead;
DWORD ReadySummary;
DWORD ReadySummaryMask;
LIST_ENTRY DispatcherReadyListHead[32];
KDPC ThreadReaperDpc;
LIST_ENTRY ThreadReaperListHead;
KDPC SwitchProcessorThreadDpc;
} KPRCB, *PKPRCB; // 424
// *********** PACKING STARTS AGAIN HERE **************//
#pragma pack(push, 1)
// *********** PACKING STARTS AGAIN HERE **************//
typedef struct _KPCR{
PVOID TlsData;
union{
struct{
USHORT MsrEnableMaskHigh;
USHORT MsrEnableMaskLow;
};
DWORD MsrEnableMask;
};
union{
struct{
BYTE DispatchInterrupt;
BYTE ApcInterrupt;
} SIAsBytes;
USHORT SoftwareInterrupt;
};
union{
struct{
BYTE DpcFpuStateSaved;
BYTE DpcVpuStateSaved;
} DpcAsBytes;
USHORT DpcFpuVpuStateSaved;
};
BYTE DpcCurrentProcessType;
BYTE QuantumEnd;
BYTE TimerRequest;
BYTE HvCr0Save;
PKTHREAD FpuOwnerThread;
PKTHREAD VpuOwnerThread;
BYTE CurrentIrql;
BYTE BackgroundSchedulingActive;
union{
struct{
BYTE StartBackgroundScheduling;
BYTE StopBackgroundScheduling;
} StartStopAsBytes;
USHORT StartStopBackgroundScheduling;
};
DWORD TimerHand;
union{
struct{
ULONGLONG LrIarSave;
ULONGLONG CrMsrSave;
ULONGLONG Gpr13Save;
} gpSave;
struct{
DWORD Gpr1Restore;
DWORD IarRestore;
DWORD CrRestore;
DWORD MsrRestore;
} gpRest;
};
ULONGLONG HvGpr1Save;
ULONGLONG HvGpr3Save;
ULONGLONG HvGpr4Save;
ULONGLONG HvGpr5Save;
DWORD UserModeControl;
void * PanicStack;
DWORD DarSave;
DWORD DsisrSave;
void * DbgLastDpcRoutine;
DWORD OnInterruptStack;
void * StackBase;
void * StackLimit;
void * InterruptStackBase;
void * InterruptStackLimit;
void * InterruptRoutine[32];
KPRCB PrcbData;
PKPRCB Prcb;
DWORD Unused;
DWORD * PixCurrent;
DWORD * PixLimit;
DWORD * ProfilerCurrent;
DWORD * ProfilerLimit;
DWORD ProfilerFlags;
ULONGLONG Contention;
DWORD * MonitorProfileData;
}KPCR, *PKPCR; // 728? adds up to 724
typedef struct _KPCR_PAGE{
union{
struct{
KPCR Pcr;
DWORD IdleThreadData[ANYSIZE_ARRAY]; // 4096 - 728 ?
} AsSeparate;
BYTE PcrAsUCHARs[4096];
};
} KPCR_PAGE, *PKPCR_PAGE; // 4096
// *********** PACKING ENDS AGAIN HERE **************//
#pragma pack(pop)
// *********** PACKING ENDS AGAIN HERE **************//
//C_ASSERT(sizeof(KPCR_PAGE) == 4096);
//C_ASSERT(sizeof(KSEMAPHORE) == 20);
//C_ASSERT(sizeof(KTIMER) == 40);
//C_ASSERT(sizeof(DISPATCHER_HEADER) == 16);
//C_ASSERT(sizeof(STACK_FRAME_HEADER) == 80);
//C_ASSERT(sizeof(KDPC) == 28);
//C_ASSERT(sizeof(KWAIT_BLOCK) == 24);
//C_ASSERT(sizeof(KPROCESS) == 96);
//C_ASSERT(sizeof(KQUEUE) == 40);
//C_ASSERT(sizeof(KPCR) == 724); // was 728???
//C_ASSERT(sizeof(KPRCB) == 424);
//C_ASSERT(sizeof(KTRAP_FRAME) == 448);
//C_ASSERT(sizeof(KTHREAD) == 2736);
//C_ASSERT(sizeof(KINTERRUPT) == 20);
//C_ASSERT(sizeof(KEVENT) == 16);
//C_ASSERT(sizeof(DISPATCHER_HEADER) == 16);
//C_ASSERT(sizeof(KAPC) == 40);
#endif //_KERNELP_DEFINES_H

169
xbdm/imp/xamcache.h Normal file
View File

@@ -0,0 +1,169 @@
/************************************************************************
* *
* xamcache.h -- This module defines the XAM cache API *
* *
* Copyright (c) Microsoft Corp. All rights reserved. *
* *
************************************************************************/
#ifndef __XAMCACHE_H__
#define __XAMCACHE_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef enum _XAM_CACHE_FILE_TYPE
{
XAM_CACHE_ALL, // special invalid cache type used to signify all cache types
XAM_CACHE_GAME_TILE, // Single tile, dwIdentifier = dwTitleId, qwIdentifier = qwImageId
XAM_CACHE_ACHIEVEMENT_TILE, // Single tile, dwIdentifier = dwTitleId, qwIdentifier = qwImageId
XAM_CACHE_GAMER_TILE, // Single tile, dwIdentifier = dwTitleId, qwIdentifier = qwImageId
XAM_CACHE_GAMER_TILE_SMALL, // Single tile, dwIdentifier = dwTitleId, qwIdentifier = qwImageId
XAM_CACHE_CUSTOM_GAMER_TILE, // dwIdentifier = <unused>, qwIdentifier = qwUserId that owns tile
XAM_CACHE_CUSTOM_GAMER_TILE_SMALL, // dwIdentifier = <unused>, qwIdentifier = qwUserId that owns tile
XAM_CACHE_FRIEND_MUTE_LIST, // dwIdentifier = <unused>, qwIdentifier = qwUserId that owns list
XAM_CACHE_TICKETS, // dwIdentifier = <unused>, qwIdentifier = qwUserId that owns tickets
XAM_CACHE_TITLE_NAMES, // dwIdentifier = <unused>, qwIdentifier = <unused>
XAM_CACHE_RECENT_PLAYERS, // dwIdentifier = <unused>, qwIdentifier = qwUserId that owns list
XAM_CACHE_TITLE_UPDATE, // dwIdentifier = dwTitleId, qwIdentifier = dwTitleBaseVersion << 32 | dwCurrentSystemVersion
XAM_CACHE_SYSTEM_UPDATE, // dwIdentifier = dwTitleId, qwIdentifier = dwBaseVersion << 32 | dwCurrentSystemVersion
XAM_CACHE_DASHBOARD_APP, // dwIdentifier = dwTitleId of App
XAM_CACHE_SPA_FILE, // dwIdentifier = dwTitleId,qwIdentifier = edition
XAM_CACHE_GAME_INVITE, // dwIdentifier = <unused>, qwIdentifier = <unused>
XAM_CACHE_GAMER_TAG // dwIdentifier = <unused>, qwIdentifier = <unused>
} XAM_CACHE_FILE_TYPE;
// XamCacheStoreFile and XamCacheFetchFile are APIs for
// simple synchronous access.
XBOXAPI
DWORD
WINAPI
XamCacheStoreFile(
IN XAM_CACHE_FILE_TYPE FileType,
IN DWORD dwIdentifier,
IN ULONGLONG qwIdentifier,
IN ULONGLONG qwVersion,
IN PVOID pvBuffer,
IN DWORD cbBuffer
);
XBOXAPI
DWORD
WINAPI
XamCacheFetchFile(
IN XAM_CACHE_FILE_TYPE FileType,
IN DWORD dwIdentifier,
IN ULONGLONG qwIdentifier,
OUT ULONGLONG* pqwVersion,
OUT PVOID pvBuffer,
IN OUT PDWORD pcbBuffer
);
XBOXAPI
DWORD
WINAPI
XamCacheDeleteFile(
IN XAM_CACHE_FILE_TYPE FileType,
IN DWORD dwIdentifier,
IN ULONGLONG qwIdentifier
);
#define XAM_COF_FETCH 0x0000
#define XAM_COF_STORE 0x0001
#define XAM_COF_STORE_RESUME 0x0003 // XAM_COF_STORE + supports resume
#define XAM_COF_GET_PATH_ONLY 0x1000 // XamCacheOpenFile does not open file - provides path
#define XAM_COF_NO_LOCK 0x2000 // valid only with XAM_COF_FETCH and XAM_COF_GET_PATH_ONLY
// does not lock file in cache
typedef struct _XAM_CACHE_OPEN_FILE *PXAM_CACHE_OPEN_FILE;
typedef void (*PFNONCACHEDEVICEREMOVED)(PXAM_CACHE_OPEN_FILE CacheFile);
typedef struct _XAM_CACHE_OPEN_FILE
{
//
// Caller must fill out before calling XamCacheOpenFile
//
DWORD Flags;
XAM_CACHE_FILE_TYPE FileType;
DWORD dwIdentifier;
ULONGLONG qwIdentifier;
//
// XAM_COF_FETCH - caller must fill out before calling XamCacheOpenFile
// XAM_COF_STORE - filled out by XamCacheOpenFile
//
ULONGLONG qwVersion;
DWORD cbSize;
//
// Filled out by XamCacheOpenFile
//
HANDLE hFile;
char FilePath[MAX_PATH];
//
// Notification
//
PFNONCACHEDEVICEREMOVED OnCacheDeviceRemoved OPTIONAL;
ULONG_PTR Context;
//
// Internal use only
//
ULONG_PTR Reserved[2];
PVOID pvMountedPackage;
CHAR PackageFilePath[MAX_PATH];
} XAM_CACHE_OPEN_FILE;
XBOXAPI
DWORD
WINAPI
XamCacheOpenFile(
IN OUT PXAM_CACHE_OPEN_FILE pCacheOpenFile
);
XBOXAPI
DWORD
WINAPI
XamCacheRenameFile(
IN PXAM_CACHE_OPEN_FILE pCacheOpenFile,
IN DWORD dwIdentifier,
IN ULONGLONG qwIdentifier,
IN ULONGLONG qwVersion
);
XBOXAPI
VOID
WINAPI
XamCacheCloseFile(
IN PXAM_CACHE_OPEN_FILE pCacheOpenFile,
IN BOOL fDelete
);
XBOXAPI
BOOL
WINAPI
XamCacheReset(
IN XAM_CACHE_FILE_TYPE FileType
);
#ifdef __cplusplus
}
#endif
#endif // __XAMCACHE_H__

240
xbdm/imp/xamdbg.h Normal file
View File

@@ -0,0 +1,240 @@
/*++
Copyright (c) Microsoft Corporation
Module Name:
xamdbg.h
Abstract:
This module defines the debug and logging APIs used by XAM applications
--*/
#include <stdarg.h>
#include <stdio.h>
#ifndef __XAMDBG_H__
#define __XAMDBG_H__
#ifdef __cplusplus
extern "C" {
#endif
#if DBG
#define XAM_FEATURE_ASSERT 1
#define XAM_FEATURE_TRACE 1
#else // DBG
#define XAM_FEATURE_ASSERT 0
#define XAM_FEATURE_TRACE 0
#endif // !DBG
//
// XAM debug flags enable granular control over the debug output made by
// applications
//
#define XAMDBG_PRINT_LEVEL_MASK 0x0000000F
#define XAMDBG_BREAK_LEVEL_MASK 0x000000F0
#define XAMDBG_FLAG_ENABLED 0x00000100
#define XAMDBG_PRINT_LEVEL_SHIFT 0
#define XAMDBG_BREAK_LEVEL_SHIFT 4
#define XAMDBG_LEVEL_TRACE XDBG_TRACE
#define XAMDBG_LEVEL_WARNING XDBG_WARNING
#define XAMDBG_LEVEL_ERROR XDBG_ERROR
#define XAMDBG_TAG(P, B, F) ((P << XAMDBG_PRINT_LEVEL_SHIFT) | (B << XAMDBG_BREAK_LEVEL_SHIFT) | F)
#define XAMDBG_TAG_PRINT_LEVEL(X) ((X & XAMDBG_PRINT_LEVEL_MASK) >> XAMDBG_PRINT_LEVEL_SHIFT)
#define XAMDBG_TAG_BREAK_LEVEL(X) ((X & XAMDBG_BREAK_LEVEL_MASK) >> XAMDBG_BREAK_LEVEL_SHIFT)
//
// Inline breakpoint
//
#ifndef DbgBreak
#ifdef XAM_FEATURE_ASSERT
#define XamDbgBreak() __debugbreak()
#else
#define XamDbgBreak()
#endif
#endif
//
// The print macro is used by other macros to wrap XamDbgPrint
//
#if !defined(_PREFAST_)
#if XAM_FEATURE_TRACE
#define XAMPRINT(b, lvl, sz, ...) do { BOOL f = XamDbgPrint(lvl, sz, ##__VA_ARGS__); if(f && b) { XamDbgBreak(); } } while (0);
#else // XAM_FEATURE_TRACE
#define XAMPRINT(b, lvl, sz, ...)
#endif // !XAM_FEATURE_TRACE
#else // _PREFAST_
#define XAMPRINT(b, lvl, sz)
#define XAMPRINT(b, lvl, sz, a1)
#define XAMPRINT(b, lvl, sz, a1, a2)
#define XAMPRINT(b, lvl, sz, a1, a2, a3)
#define XAMPRINT(b, lvl, sz, a1, a2, a3, a4)
#define XAMPRINT(b, lvl, sz, a1, a2, a3, a4, a5)
#define XAMPRINT(b, lvl, sz, a1, a2, a3, a4, a5, a6)
#define XAMPRINT(b, lvl, sz, a1, a2, a3, a4, a5, a6, a7)
#define XAMPRINT(b, lvl, sz, a1, a2, a3, a4, a5, a6, a7, a8)
#define XAMPRINT(b, lvl, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9)
#define XAMPRINT(b, lvl, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
#endif // _PREFAST_
//
// Trace macros print out a debug message if the system app's debug level is
// sufficiently low
//
#if !defined(_PREFAST_)
#if XAM_FEATURE_TRACE
#define XAMTRCLINE() do { XAMPRINT(TRUE, XDBG_TRACE, __FILE__ " @ " __LINE__ "\n"); } while(0)
#define XAMTRC(tag, sz, ...) do { XAMPRINT(TRUE, XDBG_TRACE, sz, ##__VA_ARGS__); } while(0);
#define XAMWRN(tag, sz, ...) do { XAMPRINT(TRUE, XDBG_WARNING, sz, ##__VA_ARGS__); } while(0);
#define XAMERR(tag, sz, ...) do { XAMPRINT(TRUE, XDBG_ERROR, sz, ##__VA_ARGS__); } while(0);
#else // XAM_FEATURE_TRACE
#define XAMTRCLINE()
#define XAMTRC(tag, sz, ...)
#define XAMWRN(tag, sz, ...)
#define XAMERR(tag, sz, ...)
#endif // !XAM_FEATURE_TRACE
#else // _PREFAST_
#define XAMTRC(tag, sz)
#define XAMTRC(tag, sz, a1)
#define XAMTRC(tag, sz, a1, a2)
#define XAMTRC(tag, sz, a1, a2, a3)
#define XAMTRC(tag, sz, a1, a2, a3, a4)
#define XAMTRC(tag, sz, a1, a2, a3, a4, a5)
#define XAMTRC(tag, sz, a1, a2, a3, a4, a5, a6)
#define XAMTRC(tag, sz, a1, a2, a3, a4, a5, a6, a7)
#define XAMTRC(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8)
#define XAMTRC(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9)
#define XAMTRC(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
#define XAMWRN(tag, sz)
#define XAMWRN(tag, sz, a1)
#define XAMWRN(tag, sz, a1, a2)
#define XAMWRN(tag, sz, a1, a2, a3)
#define XAMWRN(tag, sz, a1, a2, a3, a4)
#define XAMWRN(tag, sz, a1, a2, a3, a4, a5)
#define XAMWRN(tag, sz, a1, a2, a3, a4, a5, a6)
#define XAMWRN(tag, sz, a1, a2, a3, a4, a5, a6, a7)
#define XAMWRN(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8)
#define XAMWRN(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9)
#define XAMWRN(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
#define XAMERR(tag, sz)
#define XAMERR(tag, sz, a1)
#define XAMERR(tag, sz, a1, a2)
#define XAMERR(tag, sz, a1, a2, a3)
#define XAMERR(tag, sz, a1, a2, a3, a4)
#define XAMERR(tag, sz, a1, a2, a3, a4, a5)
#define XAMERR(tag, sz, a1, a2, a3, a4, a5, a6)
#define XAMERR(tag, sz, a1, a2, a3, a4, a5, a6, a7)
#define XAMERR(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8)
#define XAMERR(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9)
#define XAMERR(tag, sz, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
#endif // _PREFAST_
//
// Traps causes a debugger to be broken into
//
#if !defined(_PREFAST_)
#if XAM_FEATURE_ASSERT
#define XAMTRAPLINE() do { XAMPRINT(FALSE, XDBG_TRACE, __FILE__ " @ " __LINE__ "\n"); DbgBreak(); } while(0);
#define XAMTRAP(sz, ...) do { XAMPRINT(FALSE, XDBG_TRACE, sz, ##__VA_ARGS__); } while(0);
#else // XAM_FEATURE_ASSERT
#define XAMTRAPLINE()
#define XAMTRAP(sz, ...)
#endif // !XAM_FEATURE_ASSERT
#else // _PREFAST_
#define XAMTRAP(sz)
#define XAMTRAP(sz, a1)
#define XAMTRAP(sz, a1, a2)
#define XAMTRAP(sz, a1, a2, a3)
#define XAMTRAP(sz, a1, a2, a3, a4)
#define XAMTRAP(sz, a1, a2, a3, a4, a5)
#define XAMTRAP(sz, a1, a2, a3, a4, a5, a6)
#define XAMTRAP(sz, a1, a2, a3, a4, a5, a6, a7)
#define XAMTRAP(sz, a1, a2, a3, a4, a5, a6, a7, a8)
#define XAMTRAP(sz, a1, a2, a3, a4, a5, a6, a7, a8, a9)
#define XAMTRAP(sz, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
#endif // _PREFAST_
//
// Compatibility with prior XAM debug instrumentation
//
#define TraceSz0 XAMTRC
#define TraceSz1 XAMTRC
#define TraceSz2 XAMTRC
#define TraceSz3 XAMTRC
#define TraceSz4 XAMTRC
#define TraceSz5 XAMTRC
#define TraceSz6 XAMTRC
#define TraceSz7 XAMTRC
#define TraceSz8 XAMTRC
#define TraceSz9 XAMTRC
#define TraceSz10 XAMTRC
#define WarnSz0 XAMWRN
#define WarnSz1 XAMWRN
#define WarnSz2 XAMWRN
#define WarnSz3 XAMWRN
#define WarnSz4 XAMWRN
#define WarnSz5 XAMWRN
#define WarnSz6 XAMWRN
#define WarnSz7 XAMWRN
#define WarnSz8 XAMWRN
#define WarnSz9 XAMWRN
#define WarnSz10 XAMWRN
#define ErrorSz0 XAMERR
#define ErrorSz1 XAMERR
#define ErrorSz2 XAMERR
#define ErrorSz3 XAMERR
#define ErrorSz4 XAMERR
#define ErrorSz5 XAMERR
#define ErrorSz6 XAMERR
#define ErrorSz7 XAMERR
#define ErrorSz8 XAMERR
#define ErrorSz9 XAMERR
#define ErrorSz10 XAMERR
#define TrapSz0 XAMTRAP
#define TrapSz1 XAMTRAP
#define TrapSz2 XAMTRAP
#define TrapSz3 XAMTRAP
#define TrapSz4 XAMTRAP
#define TrapSz5 XAMTRAP
#define TrapSz6 XAMTRAP
#define TrapSz7 XAMTRAP
#define TrapSz8 XAMTRAP
#define TrapSz9 XAMTRAP
#define TrapSz10 XAMTRAP
#define Assert NT_ASSERT
#ifdef __cplusplus
};
#endif
#endif // __XAMDBG_H__

3622
xbdm/imp/xamp.h Normal file
View File

@@ -0,0 +1,3622 @@
#ifndef __XAMP_H__
#define __XAMP_H__
typedef ULONG XMSG_HANDLE;
#include <windef.h>
#include <winbase.h>
#include <kernelp.h>
#include <KernelExports.h>
#include "xboxp.h"
#include "xdbg.h"
#include "xamdbg.h"
#include "winsockx.h"
#include "xonlinep.h"
#include "xex.h"
#include "xecrypt.h"
#include "xcabinet.h"
#include "contentpkg.h"
#include "xamcache.h"
//
// Define NTSTATUS if it's not already defined
//
#if !defined(_NTDEF_)
typedef LONG NTSTATUS;
#endif
//
// Force a reference to the kernel build number
//
#pragma comment(linker, "/include:XboxKrnlBuildNumber")
#pragma warning(push)
#pragma warning(disable: 4201) // unnamed struct/union
#ifdef __cplusplus
extern "C" {
#endif
#define APPSZ_TESTXEX ("testxex.xex")
#define APPSZ_CERT ("cert.xex")
#define APPSZ_HUDUI ("hud.xex")
// App IDs
// Apps that load UI resource should have a unique id
// that helps XUI cache resources across dll loads
#define XAM_APP_ID_NONE (~0u)
#define XAM_APP_ID_HUD 0
#define XAM_APP_ID_FRIENDS 1
#define XAM_APP_ID_DEVICESELECTOR 2
#define XAM_APP_ID_SIGNIN 3
#define XAM_APP_ID_TEMPAPP 4
#define XAM_APP_ID_TESTXEX 5
#define XAM_APP_ID_FEEDBACK 6
#define XAM_APP_ID_MARKETPLACE 7
#define XAM_APP_ID_MUSICPLAYER 8
#define XAM_APP_ID_VOICEMAIL 9
#define XAM_APP_ID_QUICKCHAT 10
#define XAM_APP_ID_VK 11
#define XAM_APP_ID_UPDATER 12
#define XAM_APP_ID_GAMEPROFILE 13
#define XAM_APP_ID_CREATEPROFILE 14
#define XAM_APP_ID_MINIMUSICPLAYER 15
#define XAM_APP_ID_CERT 16
#define HXAMAPP_TESTXEX ((HXAMAPP)0x000000F9)
#define HXAMAPP_CERT ((HXAMAPP)0x000000F8)
// Returns true if the xam app's xex image doesn't always have to be
// loaded in the xam.
#define XAMAPP_OPTIONAL(h) ( ((h) == HXAMAPP_TESTXEX) || ((h) == HXAMAPP_CERT) )
#define MSGAREA_TESTXEX (0x0006)
#define XM_SYS_STORAGEDEVICECHANGE MSGID(MSGAREA_SYSTEM, 0x000F)
#define IsLiveBaseCustomProcessingMsg(msg) (MSG_NUMBER(msg) & 0x8000)
//
// NOTE: these are duplicated in \private\inc\xonp.h for codegen
//
#define XM_LIVEBASE_LOGONCONNECT MSGID(MSGAREA_XLIVEBASE, 0x8001)
#define XM_LIVEBASE_LOGONGETSERVICEINFO MSGID(MSGAREA_XLIVEBASE, 0x8007)
#define XM_LIVEBASE_PRESENCEGETSEQNUM MSGID(MSGAREA_XLIVEBASE, 0x8017)
#define XM_LIVEBASE_PRESENCESET MSGID(MSGAREA_XLIVEBASE, 0x8018)
#define XM_LIVEBASE_PRESENCEENUMCREATE MSGID(MSGAREA_XLIVEBASE, 0x8019)
#define XM_LIVEBASE_PRESENCEENUM MSGID(MSGAREA_XLIVEBASE, 0x801A)
#define XM_LIVEBASE_PRESENCEENUMCLOSE MSGID(MSGAREA_XLIVEBASE, 0x801B)
#define XM_LIVEBASE_PRESENCEGETSTATE MSGID(MSGAREA_XLIVEBASE, 0x801C)
#define XM_LIVEBASE_PRESENCESETSTATE MSGID(MSGAREA_XLIVEBASE, 0x801D)
#define XM_LIVEBASE_PRESENCESUBSCRIBE MSGID(MSGAREA_XLIVEBASE, 0x801E)
#define XM_LIVEBASE_PRESENCEUNSUBSCRIBE MSGID(MSGAREA_XLIVEBASE, 0x801F)
#define XM_LIVEBASE_FRIENDSENUMCREATE MSGID(MSGAREA_XLIVEBASE, 0x8020)
#define XM_LIVEBASE_FRIENDSENUM MSGID(MSGAREA_XLIVEBASE, 0x8021)
#define XM_LIVEBASE_FRIENDSENUMCLOSE MSGID(MSGAREA_XLIVEBASE, 0x8022)
#define XM_LIVEBASE_INVITEGETINFO MSGID(MSGAREA_XLIVEBASE, 0x8023)
#define XM_LIVEBASE_MSGENUMERATE MSGID(MSGAREA_XLIVEBASE, 0x8024)
#define XM_LIVEBASE_MSGGETSUMMARY MSGID(MSGAREA_XLIVEBASE, 0x8025)
#define XM_LIVEBASE_MSGCREATE MSGID(MSGAREA_XLIVEBASE, 0x8026)
#define XM_LIVEBASE_MSGDESTROY MSGID(MSGAREA_XLIVEBASE, 0x8027)
#define XM_LIVEBASE_MSGSETPROP MSGID(MSGAREA_XLIVEBASE, 0x8028)
#define XM_LIVEBASE_MSGGETPROP MSGID(MSGAREA_XLIVEBASE, 0x8029)
#define XM_LIVEBASE_MSGGETDETAILS MSGID(MSGAREA_XLIVEBASE, 0x802A)
#define XM_LIVEBASE_MSGGETDETAILSSUMMARY MSGID(MSGAREA_XLIVEBASE, 0x802B)
#define XM_LIVEBASE_MSGGETDETAILSPROPERTY MSGID(MSGAREA_XLIVEBASE, 0x802C)
#define XM_LIVEBASE_MSGSETFLAGS MSGID(MSGAREA_XLIVEBASE, 0x802D)
#define XM_LIVEBASE_MSGDELETE MSGID(MSGAREA_XLIVEBASE, 0x802E)
#define XM_LIVEBASE_MSGINVITESEND MSGID(MSGAREA_XLIVEBASE, 0x802F)
#define XM_LIVEBASE_MSGINVITEANSWER MSGID(MSGAREA_XLIVEBASE, 0x8030)
#define XM_LIVEBASE_MSGINVITEREVOKE MSGID(MSGAREA_XLIVEBASE, 0x8031)
#define XM_LIVEBASE_GETTASKPROGRESS MSGID(MSGAREA_XLIVEBASE, 0x8032)
#define XM_LIVEBASE_GETREQUESTTHROTTLE MSGID(MSGAREA_XLIVEBASE, 0x8033)
#define XM_LIVEBASE_SETREQUESTTHROTTLE MSGID(MSGAREA_XLIVEBASE, 0x8034)
#define XM_LIVEBASE_STORAGEBUILDSERVERPATH MSGID(MSGAREA_XLIVEBASE, 0x8035)
#define XM_LIVEBASE_EXPIREMARKETPLACECOUNTSCACHE MSGID(MSGAREA_XLIVEBASE, 0x8036)
#define XM_LIVEBASE_PRESENCEINITIALIZE MSGID(MSGAREA_XLIVEBASE, 0x8037)
#define XM_LIVEBASE_CONTENTGETINPROGRESSMETADATA MSGID(MSGAREA_XLIVEBASE, 0x8038)
#define XM_BASE_DEVICEFORMAT MSGID(MSGAREA_XBASE, 0x000B)
#define XM_BASE_CONTENTCOPYMOVE MSGID(MSGAREA_XBASE, 0x000C)
#define XM_BASE_DEVICERENAME MSGID(MSGAREA_XBASE, 0x000D)
#define XM_BASE_CONTENTAGGREGATEENUMERATE MSGID(MSGAREA_XBASE, 0x000E)
#define XM_BASE_CONTENAGGREGATETCREATEENUM MSGID(MSGAREA_XBASE, 0x000F)
#define XM_BASE_CONTENTAGGREGATECLOSEENUM MSGID(MSGAREA_XBASE, 0x0010)
#define XM_BASE_CONTENTGETMETADATA MSGID(MSGAREA_XBASE, 0x0011)
#define XM_BASE_CONTENTSETTHUMBNAIL MSGID(MSGAREA_XBASE, 0x0012)
#define XM_BASE_CONTENTGETTHUMBNAIL MSGID(MSGAREA_XBASE, 0x0013)
#define XM_BASE_CONTENTGETCREATOR MSGID(MSGAREA_XBASE, 0x0014)
#define XM_BASE_DEVICEGETSTATE MSGID(MSGAREA_XBASE, 0x0015)
#define XM_BASE_CONTENTRESOLVE MSGID(MSGAREA_XBASE, 0x0016)
#define XM_BASE_CONTENTGETLICENSEMASK MSGID(MSGAREA_XBASE, 0x0017)
#define XM_BASE_CONTENTFLUSH MSGID(MSGAREA_XBASE, 0x0018)
#define XM_BASE_CONTENTINSTALL MSGID(MSGAREA_XBASE, 0x0019)
#define XM_BASE_CONTENTGETATTRIBUTES MSGID(MSGAREA_XBASE, 0x001A)
#define XM_BASE_PROFILEENUMERATE MSGID(MSGAREA_XBASE, 0x3001)
#define XM_BASE_PROFILECREATEENUM MSGID(MSGAREA_XBASE, 0x3002)
#define XM_BASE_PROFILECLOSEENUM MSGID(MSGAREA_XBASE, 0x3003)
#define XM_BASE_PROFILELOAD MSGID(MSGAREA_XBASE, 0x3004)
#define XM_BASE_PROFILESAVE MSGID(MSGAREA_XBASE, 0x3005)
#define XM_BASE_PROFILEDELETE MSGID(MSGAREA_XBASE, 0x3006)
#define XM_BASE_PROFILERENAME MSGID(MSGAREA_XBASE, 0x3007)
//
// TestXEX Messages
//
#define XM_TEST_PRESENDMESSAGE MSGID(MSGAREA_TESTXEX, 0x0001)
#define XM_TEST_POSTSENDMESSAGE MSGID(MSGAREA_TESTXEX, 0x0002)
#define XM_TEST_SENDASYNCMESSAGE MSGID(MSGAREA_TESTXEX, 0x0003)
#define XM_TEST_SENDNOTIFICATION MSGID(MSGAREA_TESTXEX, 0x0004)
#define XM_TEST_ASYNCMESSAGEINUSE MSGID(MSGAREA_TESTXEX, 0x0005)
#define XM_TEST_SETMEDIACODE MSGID(MSGAREA_TESTXEX, 0x0006)
#define XM_TEST_ENABLEUITIMING MSGID(MSGAREA_TESTXEX, 0x0007)
#define XM_TEST_DUMPUITIMING MSGID(MSGAREA_TESTXEX, 0x0008)
#define XM_TEST_UIAPPLOAD MSGID(MSGAREA_TESTXEX, 0x0009)
#define XM_TEST_ENABLEAUTOMATION MSGID(MSGAREA_TESTXEX, 0x0011)
#define XM_TEST_DISABLEAUTOMATION MSGID(MSGAREA_TESTXEX, 0x0012)
#define XM_TEST_STARTSCRIPTENGINE MSGID(MSGAREA_TESTXEX, 0x0013)
#define XM_TEST_STOPSCRIPTENGINE MSGID(MSGAREA_TESTXEX, 0x0014)
#define XM_TEST_RUNSCRIPT MSGID(MSGAREA_TESTXEX, 0x0015)
#define XM_TEST_SETTITLESTARTUPSCRIPT MSGID(MSGAREA_TESTXEX, 0x0016)
#define XM_TEST_SETDLLENGINEPATH MSGID(MSGAREA_TESTXEX, 0x0017)
#define XM_TEST_UPDATETESTCOMMAND MSGID(MSGAREA_TESTXEX, 0x0018)
#define XM_TEST_STARTMESSAGESPOOF MSGID(MSGAREA_TESTXEX, 0x0021)
#define XM_TEST_STOPMESSAGESPOOF MSGID(MSGAREA_TESTXEX, 0x0022)
#define XM_TEST_STARTASYNCMESSAGESPOOF MSGID(MSGAREA_TESTXEX, 0x0023)
#define XM_TEST_STOPASYNCMESSAGESPOOF MSGID(MSGAREA_TESTXEX, 0x0024)
#define XM_TEST_STARTMESSAGETIMER MSGID(MSGAREA_TESTXEX, 0x0031)
#define XM_TEST_STOPMESSAGETIMER MSGID(MSGAREA_TESTXEX, 0x0032)
#define XM_TEST_STARTMESSAGELOG MSGID(MSGAREA_TESTXEX, 0x0033)
#define XM_TEST_STOPMESSAGELOG MSGID(MSGAREA_TESTXEX, 0x0034)
#define XM_TEST_OCCLUSIONQUERYBEGIN MSGID(MSGAREA_TESTXEX, 0x0040)
#define XM_TEST_OCCLUSIONQUERYEND MSGID(MSGAREA_TESTXEX, 0x0041)
#define XM_TEST_OCCLUSIONQUERYGETDATA MSGID(MSGAREA_TESTXEX, 0x0042)
#define XM_TEST_CHANGEXEXINFO MSGID(MSGAREA_TESTXEX, 0x0051)
#define XM_TEST_DELETESPAFILE MSGID(MSGAREA_TESTXEX, 0x0052)
#define XM_TEST_RESETFILECACHE MSGID(MSGAREA_TESTXEX, 0x0053)
#define TEST_SPA_FILENAME_SIZE 64
typedef struct
{
DWORD dwTitleID;
CHAR szSpaFilename[TEST_SPA_FILENAME_SIZE];
} TEST_CHANGEXEXINFO_MSG, *PTEST_CHANGEXEXINFO_MSG;
//
// XGI
//
#define XM_XGI_RECOVERTITLE MSGID(MSGAREA_XGI, 0x0003)
#define XM_XGI_SYNC MSGID(MSGAREA_XGI, 0x0004)
#define XM_XGI_CONTENTOPENED MSGID(MSGAREA_XGI, 0x0005)
#define XM_XGI_USERSETCONTEXT MSGID(MSGAREA_XGI, 0x0006)
#define XM_XGI_USERSETPROPERTY MSGID(MSGAREA_XGI, 0x0007)
#define XM_XGI_WRITEACHIEVEMENT MSGID(MSGAREA_XGI, 0x0008)
#define XM_XGI_CREATEENUM MSGID(MSGAREA_XGI, 0x0009)
#define XM_XGI_ACHIEVEMENTENUMERATE MSGID(MSGAREA_XGI, 0x000A)
#define XM_XGI_CLOSEENUM MSGID(MSGAREA_XGI, 0x000B)
#define XM_XGI_READSETTINGS MSGID(MSGAREA_XGI, 0x000C)
#define XM_XGI_WRITESETTINGS MSGID(MSGAREA_XGI, 0x000D)
#define XM_XGI_SESSIONCREATE MSGID(MSGAREA_XGI, 0x0010)
#define XM_XGI_SESSIONDELETE MSGID(MSGAREA_XGI, 0x0011)
#define XM_XGI_SESSIONJOIN MSGID(MSGAREA_XGI, 0x0012)
#define XM_XGI_SESSIONLEAVE MSGID(MSGAREA_XGI, 0x0013)
#define XM_XGI_SESSIONSTART MSGID(MSGAREA_XGI, 0x0014)
#define XM_XGI_SESSIONEND MSGID(MSGAREA_XGI, 0x0015)
#define XM_XGI_SESSIONSEARCH MSGID(MSGAREA_XGI, 0x0016)
#define XM_XGI_SESSIONCONFIG MSGID(MSGAREA_XGI, 0x0017)
#define XM_XGI_SESSIONMODIFY MSGID(MSGAREA_XGI, 0x0018)
#define XM_XGI_SESSIONINVITE MSGID(MSGAREA_XGI, 0x0019)
#define XM_XGI_SESSIONARBITRATE MSGID(MSGAREA_XGI, 0x001A)
#define XM_XGI_SESSIONSEARCHBYID MSGID(MSGAREA_XGI, 0x001B)
#define XM_XGI_SESSIONSEARCHEX MSGID(MSGAREA_XGI, 0x001C)
#define XM_XGI_VIEWRESET MSGID(MSGAREA_XGI, 0x0020)
#define XM_XGI_STATSREAD MSGID(MSGAREA_XGI, 0x0021)
#define XM_XGI_STATSENUMCREATE MSGID(MSGAREA_XGI, 0x0022)
#define XM_XGI_STATSENUMERATE MSGID(MSGAREA_XGI, 0x0023)
#define XM_XGI_STATSCLOSEENUM MSGID(MSGAREA_XGI, 0x0024)
#define XM_XGI_STATSWRITE MSGID(MSGAREA_XGI, 0x0025)
#define XM_XGI_STATSFLUSH MSGID(MSGAREA_XGI, 0x0026)
#define XM_XGI_READTILE MSGID(MSGAREA_XGI, 0x0030)
#define XM_XGI_WRITETILE MSGID(MSGAREA_XGI, 0x0031)
#define XM_XGI_READTILETOTEXTURE MSGID(MSGAREA_XGI, 0x0032)
#define XM_XGI_WRITEGAMERTILE MSGID(MSGAREA_XGI, 0x0033)
#define XM_XGI_PREPAREGAMERTILES MSGID(MSGAREA_XGI, 0x0034)
#define XM_XGI_INITFLASHTILES MSGID(MSGAREA_XGI, 0x0035)
#define XM_XGI_INVALIDATEGAMERTILECACHE MSGID(MSGAREA_XGI, 0x0036)
#define XM_XGI_READSTRING MSGID(MSGAREA_XGI, 0x0038)
#define XM_XGI_TITLEENUMERATE MSGID(MSGAREA_XGI, 0x0050)
#define XM_XMP_PLAYUSERCONTENT MSGID(MSGAREA_XMP, 0x0001)
#define XM_XMP_PLAYTITLEPLAYLIST MSGID(MSGAREA_XMP, 0x0002)
#define XM_XMP_CONTINUE MSGID(MSGAREA_XMP, 0x0003)
#define XM_XMP_STOP MSGID(MSGAREA_XMP, 0x0004)
#define XM_XMP_PAUSE MSGID(MSGAREA_XMP, 0x0005)
#define XM_XMP_NEXT MSGID(MSGAREA_XMP, 0x0006)
#define XM_XMP_PREVIOUS MSGID(MSGAREA_XMP, 0x0007)
#define XM_XMP_SETPLAYBACKBEHAVIOR MSGID(MSGAREA_XMP, 0x0008)
#define XM_XMP_GETSTATUS MSGID(MSGAREA_XMP, 0x0009)
#define XM_XMP_MOVESONG MSGID(MSGAREA_XMP, 0x000A)
#define XM_XMP_GETVOLUME MSGID(MSGAREA_XMP, 0x000B)
#define XM_XMP_SETVOLUME MSGID(MSGAREA_XMP, 0x000C)
#define XM_XMP_CREATETITLEPLAYLIST MSGID(MSGAREA_XMP, 0x000D)
#define XM_XMP_GETNOWPLAYING MSGID(MSGAREA_XMP, 0x000E)
#define XM_XMP_ADDSONGS MSGID(MSGAREA_XMP, 0x0011)
#define XM_XMP_REMOVESONGS MSGID(MSGAREA_XMP, 0x0012)
#define XM_XMP_DELETETITLEPLAYLIST MSGID(MSGAREA_XMP, 0x0013)
#define XM_XMP_CREATESONGENUMERATOR MSGID(MSGAREA_XMP, 0x0014)
#define XM_XMP_ENUMERATESONG MSGID(MSGAREA_XMP, 0x0015)
#define XM_XMP_CLOSESONGENUMERATOR MSGID(MSGAREA_XMP, 0x0016)
#define XM_XMP_CREATETITLEPLAYLISTENUMERATOR MSGID(MSGAREA_XMP, 0x0017)
#define XM_XMP_ENUMERATETITLEPLAYLIST MSGID(MSGAREA_XMP, 0x0018)
#define XM_XMP_CLOSETITLEPLAYLISTENUMERATOR MSGID(MSGAREA_XMP, 0x0019)
#define XM_XMP_SETPLAYBACKCONTROLLER MSGID(MSGAREA_XMP, 0x001A)
#define XM_XMP_GETPLAYBACKCONTROLLER MSGID(MSGAREA_XMP, 0x001B)
#define XM_XMP_CREATEMEDIACONTAINERENUMERATOR MSGID(MSGAREA_XMP, 0x001C)
#define XM_XMP_ENUMERATEMEDIACONTAINER MSGID(MSGAREA_XMP, 0x001D)
#define XM_XMP_CLOSEMEDIACONTAINERENUMERATOR MSGID(MSGAREA_XMP, 0x001E)
#define XM_XMP_CREATEPHOTOENUMERATOR MSGID(MSGAREA_XMP, 0x001F)
#define XM_XMP_ENUMERATEPHOTO MSGID(MSGAREA_XMP, 0x0020)
#define XM_XMP_CLOSEPHOTOENUMERATOR MSGID(MSGAREA_XMP, 0x0021)
#define XM_XMP_CREATEVIDEOENUMERATOR MSGID(MSGAREA_XMP, 0x0022)
#define XM_XMP_ENUMERATEVIDEO MSGID(MSGAREA_XMP, 0x0023)
#define XM_XMP_CLOSEVIDEOENUMERATOR MSGID(MSGAREA_XMP, 0x0024)
#define XM_XMP_CREATEUSERPLAYLISTENUMERATOR MSGID(MSGAREA_XMP, 0x0025)
#define XM_XMP_ENUMERATEUSERPLAYLIST MSGID(MSGAREA_XMP, 0x0026)
#define XM_XMP_CLOSEUSERPLAYLISTENUMERATOR MSGID(MSGAREA_XMP, 0x0027)
#define XM_XMP_EMPTYPLAYLIST MSGID(MSGAREA_XMP, 0x0028)
#define XM_XMP_GETPLAYBACKBEHAVIOR MSGID(MSGAREA_XMP, 0x0029)
#define XM_XMP_GETTOTALNUMBEROFITEMS MSGID(MSGAREA_XMP, 0x002A)
#define XM_XMP_GETMEDIASOURCES MSGID(MSGAREA_XMP, 0x002B)
#define XM_XMP_GETMEDIASTREAM MSGID(MSGAREA_XMP, 0x002C)
#define XM_XMP_GETPHOTOTHUMBNAILSTREAM MSGID(MSGAREA_XMP, 0x002D)
#define XM_XMP_GETTITLEPLAYLISTBUFFERSIZE MSGID(MSGAREA_XMP, 0x002E)
#define XM_XMP_DASHINIT MSGID(MSGAREA_XMP, 0x002F)
#define XM_XMP_GETTITLEINFO MSGID(MSGAREA_XMP, 0x0030)
#define XM_XMP_GETNUMSONGSINTITLEPLAYLIST MSGID(MSGAREA_XMP, 0x0031)
#define XM_XMP_IMPORTALBUM MSGID(MSGAREA_XMP, 0x0032)
#define XM_XMP_GETBEATEFFECTOUTPUT MSGID(MSGAREA_XMP, 0x0033)
#define XM_XMP_EDITALBUM MSGID(MSGAREA_XMP, 0x0034)
#define XM_XMP_EDITTRACK MSGID(MSGAREA_XMP, 0x0035)
#define XM_XMP_DELETEMEDIA MSGID(MSGAREA_XMP, 0x0036)
#define XM_XMP_DELETECONTAINER MSGID(MSGAREA_XMP, 0x0037)
#define XM_XMP_GETMEDIASOURCEINFO MSGID(MSGAREA_XMP, 0x0038)
#define XM_XMP_COMMITPLAYLIST MSGID(MSGAREA_XMP, 0x0039)
#define XM_XMP_CHANGEWMCSERVER MSGID(MSGAREA_XMP, 0x003A)
#define XM_XMP_PLAYMEDIACONTAINER MSGID(MSGAREA_XMP, 0x003B)
#define XM_XMP_RENAMECONTAINER MSGID(MSGAREA_XMP, 0x003C)
#define XM_XMP_CAPTUREOUTPUT MSGID(MSGAREA_XMP, 0x003D)
#define XM_XMP_CREATEMEDIAOBJECTENUMERATOR MSGID(MSGAREA_XMP, 0x003E)
#define XM_XMP_ENUMERATEMEDIAOBJECT MSGID(MSGAREA_XMP, 0x003F)
#define XM_XMP_CLOSEMEDIAOBJECTENUMERATOR MSGID(MSGAREA_XMP, 0x0040)
#define XM_XMP_CREATETITLEPLAYLISTSONGENUMERATOR MSGID(MSGAREA_XMP, 0x0041)
#define XM_XMP_ENUMERATETITLEPLAYLISTSONG MSGID(MSGAREA_XMP, 0x0042)
#define XM_XMP_CLOSETITLEPLAYLISTSONGENUMERATOR MSGID(MSGAREA_XMP, 0x0043)
#define XM_XMP_SETMEDIASOURCEWORKSPACE MSGID(MSGAREA_XMP, 0x0044)
#define XM_XMP_GETNUMTITLEPLAYLISTS MSGID(MSGAREA_XMP, 0x0045)
#define XM_XMP_GETMEDIASOURCE MSGID(MSGAREA_XMP, 0x0046)
#define XM_XMP_DELETEALLLOCALMUSIC MSGID(MSGAREA_XMP, 0x0047)
#define XM_XMP_REMOVESONGSWITHSOURCE MSGID(MSGAREA_XMP, 0x0048)
#define XM_XMP_RESTARTPLAYBACK MSGID(MSGAREA_XMP, 0x0049)
#define XM_XMP_SETDASHNOWPLAYINGQUEUEMODE MSGID(MSGAREA_XMP, 0x004A)
#define XM_XMP_GETDASHNOWPLAYINGQUEUEMODE MSGID(MSGAREA_XMP, 0x004B)
#define XM_XMP_ENTERCDRIPPINGMODE MSGID(MSGAREA_XMP, 0x004C)
#define XM_XMP_LEAVECDRIPPINGMODE MSGID(MSGAREA_XMP, 0x004D)
//
// UVBase Messages
//
#define XM_UVBASE_REQUESTVOICECHAT MSGID(MSGAREA_UVBASE, 0x0001)
#define XM_UVBASE_QUITVOICECHAT MSGID(MSGAREA_UVBASE, 0x0002)
#define XM_UVBASE_ENUMERATEVOICECHATS MSGID(MSGAREA_UVBASE, 0x0003)
#define XM_UVBASE_SWITCHTOVOICECHAT MSGID(MSGAREA_UVBASE, 0x0004)
#define XM_UVBASE_CONNECTTOVOICECHAT MSGID(MSGAREA_UVBASE, 0x0005)
#define XM_UVBASE_CALLBACKUSERTOVOICECHAT MSGID(MSGAREA_UVBASE, 0x0006)
#define XM_UVBASE_CREATEVOICEMAIL MSGID(MSGAREA_UVBASE, 0x0007)
#define XM_UVBASE_RECORDVOICEMAIL MSGID(MSGAREA_UVBASE, 0x0008)
#define XM_UVBASE_PLAYVOICEMAIL MSGID(MSGAREA_UVBASE, 0x0009)
#define XM_UVBASE_STOPVOICEMAIL MSGID(MSGAREA_UVBASE, 0x000A)
#define XM_UVBASE_CLOSEVOICEMAIL MSGID(MSGAREA_UVBASE, 0x000B)
#define XM_UVBASE_ENUMERATECHANNELS MSGID(MSGAREA_UVBASE, 0x000C)
//
// We reverse the RSHOULDER and LSHOULDER constants to be consistent with old
// Xbox1 input that had the order BLACK then WHITE.
//
#define VK_PAD_XE 0x5808
#define VK_PAD_BINDING 0x5809
//
// Combination codes reserved by XUI input processing.
// Do not define conflicting public values.
//
// #define VK_PAD_A_OR_START 0x5840
// #define VK_PAD_B_OR_BACK 0x5841
// #define VK_NONE 0x5842
// ...
// Reserved through 0x584F
//
//------------------------------------------------------------------------------
// Debug instrumentation
//
XBOXAPI
VOID
WINAPI
XamDbgSetOutputLevel(
IN HXAMAPP hxamapp OPTIONAL,
IN ULONG ulLevel
);
XBOXAPI
VOID
WINAPI
XamDbgSetBreakLevel(
IN HXAMAPP hxamapp OPTIONAL,
IN ULONG ulLevel
);
XBOXAPI
BOOL
WINAPI
XamDbgPrint(
IN ULONG ulLevel,
IN LPCSTR pszFormat,
...
);
typedef struct _TESTXEXMESSAGE
{
HXAMAPP hxamapp;
DWORD dwMessage;
UINT_PTR pParam1;
UINT_PTR pParam2;
HRESULT hr;
} TESTXEXMESSAGE, *PTESTXEXMESSAGE;
typedef struct _TESTXEXXUILOCK
{
BOOL fWait;
DWORD dwTime;
} TESTXEXXUILOCK, *PTESTXEXXUILOCK;
typedef struct _TESTXEXSYSINFO
{
DWORD dwBuildVer;
DWORD dwBuildFlags;
DWORD dwHardwareVer;
} TESTXEXSYSINFO, *PTESTXEXSYSINFO;
BOOL
WINAPI
XamSetAutomation(
IN BOOL fAutomation
);
#ifndef XUIElementPropVal
typedef struct XUIElementPropVal XUIElementPropVal;
#endif
HRESULT
WINAPI
XamApplySkin(
IN DWORD dwUserIndex,
IN LPCSTR pszSkinModule, OPTIONAL
IN CONST XUIElementPropVal* pPropBkgnd OPTIONAL
);
HRESULT
WINAPI
XamGetBkgndDefault(
OUT XUIElementPropVal* pPropBkgnd
);
HRESULT
WINAPI
XamGetDefaultSystemImage(
OUT PBYTE* ppbImage,
OUT PDWORD pcbImage OPTIONAL
);
typedef enum
{
XAM_DEFAULT_IMAGE_SYSTEM = 0,
XAM_DEFAULT_IMAGE_DASHICON = 1,
XAM_DEFAULT_IMAGE_ID_COUNT = 2
} XAM_DEFAULT_IMAGE_ID;
HRESULT
WINAPI
XamGetDefaultImage(
IN XAM_DEFAULT_IMAGE_ID dwImageId,
OUT PBYTE* ppbImage,
OUT PDWORD pcbImage OPTIONAL
);
#ifndef HXUIBRUSH
typedef struct _XUIBRUSH* HXUIBRUSH;
#endif
VOID
XamSendMessageToLoadedApps(
IN DWORD dwMessage,
IN UINT_PTR pParam1,
IN UINT_PTR pParam2
);
DWORD
WINAPI
XamFormatMessage(
OUT LPWSTR pszOut,
IN DWORD cchOut,
IN LPCWSTR pszTemplate,
...
);
typedef enum
{
XAMDATEFORMAT_dMyyyy = 0,
XAMDATEFORMAT_dMMyyyy,
XAMDATEFORMAT_ddMMyyyy,
XAMDATEFORMAT_Mdyyyy,
XAMDATEFORMAT_yyyyMd,
XAMDATEFORMAT_yyyyMMdd,
XAMDATEFORMAT_MMyy,
} XAMDATEFORMAT;
XAMDATEFORMAT XamGetLocaleDateFormat(
IN DWORD dwCountry
);
VOID
WINAPI
XamFormatTimeString(
IN DWORD dwUserIndex,
IN FILETIME ft,
OUT LPWSTR pszBuff,
IN ULONG cchBuff
);
VOID
WINAPI
XamFormatDateString(
IN DWORD dwUserIndex,
IN FILETIME ft,
OUT LPWSTR pszBuff,
IN ULONG cchBuff
);
INT
WINAPI
XamUniSortCmpString(
LPCWSTR pszString1,
LPCWSTR pszString2,
UINT nMaxLen
);
#ifndef HXUIOBJ
typedef struct _XUIOBJ* HXUIOBJ;
#endif
HRESULT
WINAPI
XamGetRootObj(
OUT HXUIOBJ* phRootObj
);
typedef enum
{
XHUDOPENSTATE_NONE = 0,
XHUDOPENSTATE_HALF,
XHUDOPENSTATE_FULL,
XHUDOPENSTATE_ERROR,
//-----------------
XHUDOPENSTATE_COUNT
} XHUDOPENSTATE, *PXHUDOPENSTATE;
typedef VOID (CALLBACK *PFNMSGBOXRETURN)(
IN INT iButtonPressed,
OUT PXHUDOPENSTATE pHudRestoreState
);
HRESULT
WINAPI
XamShowMessageBox(
IN OPTIONAL HXUIOBJ hOwner, // HXUIOBJ to be notified on Completion. (optional)
IN LPCWSTR pszTitle, // Title text.
IN LPCWSTR pszText, // Message text.
IN DWORD cButtons, // Count of buttons in rgButtons.
IN LPCWSTR* rgButtons, // Array of text strings for buttons.
IN DWORD dwFocusButton, // Set focus to a button with this index,
IN OPTIONAL PFNMSGBOXRETURN pfnMsgBoxReturn, // Callback function called on Completion. (optional)
IN DWORD dwFlags // Flags
);
#define MAX_RESOURCE_PATH 128
HRESULT
WINAPI
XamBuildResourceLocator(
IN OPTIONAL HINSTANCE hInstance, // HINSTANCE of the module from which to load resources.
IN LPCWSTR pszContainer, // Resource container name (i.e. section name or package name)
IN OPTIONAL LPCWSTR pszResource, // Resource name
OUT LPWSTR pszResourceLocator, // Sting buffer to recieve the locator string.
IN DWORD cchResourceLocator // Count of characters in pszResourceLocator.
);
HRESULT
WINAPI
XamBuildSharedSystemResourceLocator(
IN LPCWSTR pszResource, // Resource name
OUT LPWSTR pszResourceLocator, // Sting buffer to recieve the locator string.
IN DWORD cchResourceLocator // Count of characters in pszResourceLocator.
);
HRESULT
WINAPI
XamBuildGamercardResourceLocator(
IN LPCWSTR pszResource, // Resource name
OUT LPWSTR pszResourceLocator, // Sting buffer to recieve the locator string.
IN DWORD cchResourceLocator // Count of characters in pszResourceLocator.
);
HRESULT
WINAPI
XamBuildDynamicResourceLocator(
IN DWORD dwAppId, // Unique application id
IN OPTIONAL HINSTANCE hInstance, // HINSTANCE of the module from which to load resources.
IN LPCWSTR pszContainer, // Resource container name (i.e. section name or package name)
IN OPTIONAL LPCWSTR pszResource, // Resource name
OUT LPWSTR pszResourceLocator, // Sting buffer to recieve the locator string.
IN DWORD cchResourceLocator // Count of characters in pszResourceLocator.
);
DWORD
WINAPI
XamCustomSetBannerImage(
IN const VOID * pvTexture,
IN const VOID * pvBits,
IN DWORD dwFlags
);
BOOL
WINAPI
XAutomationpBindController(
IN DWORD dwUserIndex
);
BOOL
WINAPI
XAutomationpUnbindController(
IN DWORD dwUserIndex
);
BOOL
WINAPI
XAutomationpInputXenonButton(
IN DWORD dwUserIndex
);
BOOL
WINAPI
XAutomationpInputSetState(
IN DWORD dwUserIndex,
IN PXINPUT_GAMEPAD pXGamepad
);
BOOL
WINAPI
XAutomationpInputPress(
IN DWORD dwUserIndex,
IN DWORD dwVkey
);
BOOL
WINAPI
XamEnableOverdraw(
IN BOOL fEnable
);
#define XAMINLINE FORCEINLINE
//
// Crt initialization for system apps
//
BOOL WINAPI _CrtInit();
VOID WINAPI _CrtTerm();
BOOL WINAPI _CrtThreadInit();
VOID WINAPI _CrtThreadTerm();
//
// XamApp SPIs
//
DWORD
WINAPI
XamNavigate(
IN DWORD dwUserIndex,
IN LPCSTR pszShortcut,
IN ULONGLONG qwParam1,
IN DWORD dwParam2
);
BOOL
WINAPI
XamAppRequestLoad(
VOID
);
BOOL
WINAPI
XamAppRequestLoadEx(
XHUDOPENSTATE OpenState
);
VOID
WINAPI
XamAppUnrequestLoad(
VOID
);
HRESULT
WINAPI
XamAppUnloadStack(
IN BOOL fWaitForCompletion // specified whether the call should block until the app stack is fully unloaded
);
HRESULT
WINAPI
XamAppLoad(
IN LPCSTR pszSysApp,
IN DWORD dwUserIndex, // user index from which the app will accept input.
IN PVOID pvAppParams OPTIONAL, // params that will be passed to the app as the first param of XM_SET_PARAMS
IN DWORD cbAppParams OPTIONAL, // size of data pointed to by pvAppParams
IN PXOVERLAPPED pxoverlapped OPTIONAL, // xoverlapped struct to signal when the operation is completed
OUT PHXAMAPP phxamapp OPTIONAL
);
void
WINAPI
XamAppUnloadSelf();
#define XSYSLOADINPUT_NONE 0x00000000
#define XSYSLOADINPUT_FIRSTLOAD 0x00000001
#define XSYSLOADINPUT_RELOAD 0x00000002
typedef struct _XSYSLOADINPUT
{
DWORD dwFlags; // See XSYSLOADINPUT_*
PVOID pvParam;
HINSTANCE hInstance;
DWORD dwUserIndex;
} XSYSLOADINPUT, *PXSYSLOADINPUT;
typedef struct _XSYSLOADOUTPUT
{
DWORD cbPersist;
} XSYSLOADOUTPUT;
//
// XM_SYS_STORAGEDEVICECHANGE
//
typedef enum
{
DEVICESTATE_NONE = 0,
DEVICESTATE_ADD,
DEVICESTATE_REMOVE,
DEVICESTATE_IDLE,
DEVICESTATE_UNFORMATTED,
DEVICESTATE_IGNORE,
DEVICESTATE_FORCE_DWORD = 0xFFFFFFFF
} DEVICESTATE;
typedef struct XSTORAGEDEVICECHANGE_PARAMS
{
CHAR szDevicePath[MAX_PATH];
BOOL fRemoved;
DWORD deviceType;
DWORD deviceId;
DEVICESTATE eState;
} XSTORAGEDEVICECHANGE_PARAMS, *PXSTORAGEDEVICECHANGE_PARAMS;
DWORD
WINAPI
XamRegisterSysApp(
IN HINSTANCE hInstance,
IN HXAMAPP hXamApp,
IN PMESSAGEPROC pfnMessageProc,
IN DWORD dwAppId
);
DWORD
WINAPI
XamUnregisterSysApp(
IN HINSTANCE hInstance,
IN HXAMAPP hXamApp,
IN DWORD dwAppId
);
typedef enum
{
XCODEC_TYPE_AAC = 0,
//-----------------
XCODEC_TYPE_COUNT
} XCODEC_TYPE, *PXCODEC_TYPE;
#define XCODEC_TYPE_AAC_TITLE_ID 0xFFFE07DF
#define XCODEC_TYPE_AAC_CONTENTTYPE XCONTENTTYPE_MARKETPLACE
typedef
PVOID
(*PFN_CREATE_CODEC_INSTANCE)();
VOID
WINAPI
XMPRegisterCodec(
IN XCODEC_TYPE xcodectype,
IN PFN_CREATE_CODEC_INSTANCE pfnCreateCodec
);
PFN_CREATE_CODEC_INSTANCE
XMPGetCodecCreationFunction(
IN XCODEC_TYPE xcodectype
);
DECLSPEC_NORETURN
VOID
XamTerminateTitle(
VOID
);
//------------------------------------------------------------------------------
// XAM Scheduler
//------------------------------------------------------------------------------
typedef HRESULT (WINAPI *PXAMTASKPROC)(
IN PVOID pvParam
);
typedef PVOID HXAMTASK, *PHXAMTASK;
typedef PVOID HXAMTASKQUEUE, *PHXAMTASKQUEUE;
typedef PVOID HXAMTASKOBJ, *PHXAMTASKOBJ; // Generic handle, either XAMTASK or XAMTASKQUEUE
// Type of task
#define XAMPROPERTY_TYPE_WAIT 0x00000001 // waits on a kernel handle and calls taskproc when signaled
#define XAMPROPERTY_TYPE_DEDICATED 0x00000002 // dedicated thread, will do work and exit
#define XAMPROPERTY_TYPE_POOLED 0x00000004 // reuse some kind of thread pool
#define XAMPROPERTY_TYPE_PERIODIC 0x00000008 // reuse some kind of thread pool, run at regular intervals
#define XAMPROPERTY_TYPE_UI 0x00000010
#define _XAMPROPERTY_TYPE_MASK_ 0x0000001F
// When this task wakes up and does processing
#define XAMPROPERTY_WAKEUP_IO 0x00000100 // burst of CPU usage but mostly waiting on I/O
#define XAMPROPERTY_WAKEUP_NETWORK 0x00000200 // burst of CPU usage but mostly waiting on N/W
#define XAMPROPERTY_WAKEUP_OFTENWAIT 0x00000400 // calling WaitFor*Object* often
#define _XAMPROPERTY_WAKEUP_MASK_ 0x00000700
// Task CPU usage
#define XAMPROPERTY_CPUUSAGE_LO 0x00001000 // e.g.: waiting and processing notifications
#define XAMPROPERTY_CPUUSAGE_HI 0x00002000 // e.g.: CODEC, encrypting, animations?
#define _XAMPROPERTY_CPUUSAGE_MASK_ 0x00003000
// Duration
#define XAMPROPERTY_DURATION_VERYSHORT 0x00010000
#define XAMPROPERTY_DURATION_SHORT 0x00020000
#define XAMPROPERTY_DURATION_LONG 0x00040000
// 0x00080000 // Taken below
#define _XAMPROPERTY_DURATION_MASK_ 0x00070000
// Priority
#define XAMPROPERTY_PRI_LO 0x00100000
#define XAMPROPERTY_PRI_NORMAL 0x00200000
#define XAMPROPERTY_PRI_HI 0x00400000
#define XAMPROPERTY_PRI_BACKGROUND 0x00800000
#define XAMPROPERTY_PRI_FOREGROUND 0x00080000
#define _XAMPROPERTY_PRI_LOHIMASK_ 0x00700000
#define _XAMPROPERTY_PRI_XGROUNDMASK_ 0x00880000
#define _XAMPROPERTY_PRI_MASK_ 0x00F80000
// Misc
#define XAMPROPERTY_MISC_FIREONCE 0x01000000
#define XAMPROPERTY_MISC_ONTITLEBEHALF 0x02000000
#define XAMPROPERTY_MISC_ONSYSTEMBEHALF 0x04000000
#define XAMPROPERTY_MISC_WAITONHANDLE 0x08000000 // By default, we expect a waitable kernel object (e.g. KEVENT)
#define XAMPROPERTY_MISC_SERIALQUEUE 0x10000000 // hxamtaskqueue needs to be set
#define XAMPROPERTY_MISC_FORCE_GROUND 0x20000000 // forces _XAMPROPERTY_PRI_XGROUNDMASK_ to be followed. Do not use this except in extreme cases!
#define _XAMPROPERTY_MISC_BEHALFMASK_ 0x06000000
#define _XAMPROPERTY_MISC_MASK_ 0x1F000000
typedef struct _XAMTASKATTRIBUTES
{
DWORD dwProperties; // Zero or more XAMPROPERTY_*
union
{
// mandatory for XAMPROPERTY_TYPE_PERIODIC
DWORD dwPeriod; // Period in millisec, only for XAMPROPERTY_TYPE_PERIODIC
// mandatory to have one of these for XAMPROPERTY_TYPE_WAIT
PVOID pvWaitable; // Pointer to waitable kernel object, e.g.: KEVENT
HANDLE hWaitable; // (1) HANDLE to waitable object, requires XAMPROPERTY_MISC_WAITONHANDLE
// (2) Make sure to DuplicateHandle it! CloseHandle will automatically
// get called on it when the task is deleted.
// (3) If using this rather than hWaitable, then the task scheduling can
// fail if the HANDLE is invalid. That would be a caller error.
// (4) The HANDLE needs to be a system process HANDLE.
// optionally for XAMPROPERTY_TYPE_POOLED (which is mutually exclusive with XAMPROPERTY_TYPE_WAIT)
HXAMTASKQUEUE hxamtaskqueue;
};
} XAMTASKATTRIBUTES, *PXAMTASKATTRIBUTES;
HRESULT
XamTaskSchedule(
IN PXAMTASKPROC pxamtaskproc,
IN PVOID pvParam,
IN PXAMTASKATTRIBUTES pxamtaskattribs OPTIONAL, // If NULL, default properties will be used
OUT PHXAMTASK phxamtask
);
// Usage
// Create a task using XamTaskCreate, can fail if out of memory
// Modify it using XamTaskModify, this cannot fail
// Schedule it using XamTaskReschedule, this cannot fail
HRESULT
XamTaskCreate(
OUT PHXAMTASK phxamtask
);
VOID
XamTaskReschedule(
IN HXAMTASK hxamtask
);
HRESULT
XamTaskSchedulerInitialize(
VOID
);
VOID
XamTaskCloseHandle(
IN HXAMTASKOBJ hxamtaskobj
);
VOID
XamTaskCancel(
IN HXAMTASK hxamtask
);
// Wait for task to be "done" or "cancelled"
VOID
XamTaskWaitOnCompletion(
IN HXAMTASK hxamtask
);
// S_OK: completed
// E_PENDING: not completed
HRESULT
XamTaskGetStatus(
IN HXAMTASK hxamtask
);
BOOL
XamTaskShouldExit(
VOID
);
#define XAMTASKMODIFY_NONE 0x00000000
#define XAMTASKMODIFY_TASKPROC 0x00000001
#define XAMTASKMODIFY_PVPARAM 0x00000002
#define XAMTASKMODIFY_ATTRIBUTES 0x00000004
VOID
XamTaskModify(
IN HXAMTASK hxamtask,
IN DWORD dwFlags,
IN PXAMTASKPROC pxamtaskproc,
IN PVOID pvParam,
IN PXAMTASKATTRIBUTES pxamtaskattribs
);
VOID
XamTaskActivateXenonButtonHandler(
IN DWORD dwPortInput
);
HXAMTASK
XamTaskGetCurrentTask(
VOID
);
DWORD
XamTaskQueryProperty(
IN HXAMTASK hxamtask,
IN DWORD dwPropertyMask
);
HRESULT
XamTaskGetAttributes(
IN HXAMTASK hxamtask,
IN OUT PXAMTASKATTRIBUTES pxamtaskattribs
);
HRESULT
XamTaskGetWaitableObject(
IN HXAMTASK hxamtask,
OUT PHANDLE ph
);
HRESULT
XamTaskCreateQueue(
OUT PHXAMTASKQUEUE phxamtaskqueue
);
HRESULT
XamTaskGetCompletionStatus(
IN HXAMTASK hxamtask
);
// Not XamTask function, but close enough
BOOL
XamExecutingOnBehalfOfTitle(
VOID
);
#define XNFLAG_INTERNAL (0x80000000)
#define XNMASK_AREA (0x7e000000)
#define XNMASK_VERSION (0x01FF0000)
#define XNID_INTERNAL(Version, Area, Index)(DWORD)(XNID(Version, Area, Index) | XNFLAG_INTERNAL)
//
// This version number needs to be bumped up each time we add a notification
// after a final release. When a game links to an xdk, this version number
// is linked into the game and only notifications with version less than or
// equal to XNID_CURRENTVERSION will be send to the title. This scheme will
// help keep new notitifications from breaking existing titles.
//
#define XNID_CURRENTVERSION (0)
#define XNOTIFY_FEEDBACK (0x00000010)
#define _XNAREA_FEEDBACK (4)
#define XN_SYS_TITLELOAD XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0001)
#define XN_SYS_TIMEZONE XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0002)
#define XN_SYS_LANGUAGE XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0003)
#define XN_SYS_VIDEOFLAGS XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0004)
#define XN_SYS_AUDIOFLAGS XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0005)
#define XN_SYS_PARENTALCONTROLGAMES XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0006)
#define XN_SYS_PARENTALCONTROLPASSWORD XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0007)
#define XN_SYS_PARENTALCONTROLMOVIES XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0008)
#define XN_SYS_DASHCONTEXTCHANGED XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x000c)
#define XN_SYS_DISCMEDIACHANGED XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x000d)
#define XN_SYS_THEMECHANGED XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x000f)
#define XN_SYS_SYSTEMUPDATECHANGED XNID_INTERNAL(0, _XNAREA_SYSTEM, 0x0010)
#define XN_LIVE_INVITE_RECEIVED XNID_INTERNAL(0, _XNAREA_LIVE, 0x0004)
#define XN_LIVE_INVITE_ANSWER_RECEIVED XNID_INTERNAL(0, _XNAREA_LIVE, 0x0005)
#define XN_LIVE_MESSAGE_LIST_CHANGED XNID_INTERNAL(0, _XNAREA_LIVE, 0x0006)
#define XN_LIVE_POINTS_BALANCE_CHANGED XNID_INTERNAL(0, _XNAREA_LIVE, 0x000B)
#define XN_LIVE_PLAYERSLIST_CHANGED XNID_INTERNAL(0, _XNAREA_LIVE, 0x000C)
#define XN_LIVE_ITEM_PURCHASED XNID_INTERNAL(0, _XNAREA_LIVE, 0x000D)
#define XN_FRIENDS_REQUEST_RECEIVED XNID_INTERNAL(0, _XNAREA_FRIENDS, 0x0004)
#define XN_FRIENDS_ANSWER_RECEIVED XNID_INTERNAL(0, _XNAREA_FRIENDS, 0x0005)
#define XN_FRIENDS_REQUEST_RESULT XNID_INTERNAL(0, _XNAREA_FRIENDS, 0x0006)
//
// Feedback notifications
//
#define XN_FEEDBACK_FIRST XNID(0, _XNAREA_FEEDBACK, 0x0001)
#define XN_FEEDBACK_COMPLAINT_SENT XNID_INTERNAL(0, _XNAREA_FEEDBACK, 0x0001)
#define XN_FEEDBACK_PR_SENT XNID_INTERNAL(0, _XNAREA_FEEDBACK, 0x0002)
#define XN_FEEDBACK_PR_CHANGED XNID_INTERNAL(0, _XNAREA_FEEDBACK, 0x0003)
#define XN_FEEDBACK_LAST XNID(0, _XNAREA_FEEDBACK, 0x0004)
#define XN_XMP_MEDIASOURCECONNECTIONCHANGED XNID_INTERNAL(0, _XNAREA_XMP, 0x0004)
#define XN_XMP_TITLEPLAYLISTCONTENTCHANGED XNID_INTERNAL(0, _XNAREA_XMP, 0x0005)
#define XN_XMP_LOCALMEDIACONTENTCHANGED XNID_INTERNAL(0, _XNAREA_XMP, 0x0006)
#define XN_XMP_DASHNOWPLAYINGQUEUEMODECHANGED XNID_INTERNAL(0, _XNAREA_XMP, 0x0007)
HANDLE
WINAPI
XamNotifyCreateListener(
IN ULONGLONG qwAreas,
IN DWORD dwVersion
);
HANDLE
WINAPI
XamNotifyCreateListenerInternal(
IN ULONGLONG qwAreas,
IN BOOL fReceiveInternalNotifications,
IN DWORD dwVersion
);
#define XNotifyCreateListenerInternal(qwAreas, fReceiveInternalNotifications) \
XamNotifyCreateListenerInternal(qwAreas, fReceiveInternalNotifications, XNID_CURRENTVERSION)
VOID
WINAPI
XNotifyBroadcast(
IN DWORD dwNotificationId,
IN ULONG_PTR param
);
HRESULT
WINAPI
XNotifyRegisterArea(
IN ULONGLONG qwArea,
IN DWORD dwMinGlobalMessage,
IN DWORD dwMaxGlobalMessage
);
VOID
WINAPI
XNotifyResetGlobalListener();
VOID
WINAPI
XNotifyFreeTitleHandles();
VOID
WINAPI
XNotifyFreeUIAppHandles();
VOID
WINAPI
XNotifyTitleStartup();
#define XNOTIFYUI_TYPE_FRIENDONLINE 0
#define XNOTIFYUI_TYPE_GAMEINVITE 1
#define XNOTIFYUI_TYPE_FRIENDREQUEST 2
#define XNOTIFYUI_TYPE_GENERIC 3
#define XNOTIFYUI_TYPE_MULTIPENDING 4
#define XNOTIFYUI_TYPE_PERSONALMESSAGE 5
#define XNOTIFYUI_TYPE_SIGNEDOUT 6
#define XNOTIFYUI_TYPE_SIGNEDIN 7
#define XNOTIFYUI_TYPE_SIGNEDINLIVE 8
#define XNOTIFYUI_TYPE_SIGNEDINNEEDPASS 9
#define XNOTIFYUI_TYPE_CHATREQUEST 10
#define XNOTIFYUI_TYPE_CONNECTIONLOST 11
#define XNOTIFYUI_TYPE_DOWNLOADCOMPLETE 12
#define XNOTIFYUI_TYPE_SONGPLAYING 13
#define XNOTIFYUI_TYPE_PREFERRED_REVIEW 14
#define XNOTIFYUI_TYPE_AVOID_REVIEW 15
#define XNOTIFYUI_TYPE_COMPLAINT 16
#define XNOTIFYUI_TYPE_CHATCALLBACK 17
#define XNOTIFYUI_TYPE_REMOVEDMU 18
#define XNOTIFYUI_TYPE_REMOVEDGAMEPAD 19
#define XNOTIFYUI_TYPE_CHATJOIN 20
#define XNOTIFYUI_TYPE_CHATLEAVE 21
#define XNOTIFYUI_TYPE_GAMEINVITESENT 22
#define XNOTIFYUI_TYPE_CANCELPERSISTENT 23
#define XNOTIFYUI_TYPE_CHATCALLBACKSENT 24
#define XNOTIFYUI_TYPE_MULTIFRIENDONLINE 25
#define XNOTIFYUI_TYPE_ONEFRIENDONLINE 26
#define XNOTIFYUI_TYPE_ACHIEVEMENT 27
#define XNOTIFYUI_TYPE_HYBRIDDISC 28
#define XNOTIFYUI_TYPE_MAX 28
#define XNOTIFYUI_PRIORITY_LOW 0
#define XNOTIFYUI_PRIORITY_DEFAULT 1
#define XNOTIFYUI_PRIORITY_HIGH 2
#define XNOTIFYUI_PRIORITY_PERSISTENT 3
VOID
WINAPI
XNotifyUISetOptions(
BOOL fShow,
BOOL fPlaySound
);
VOID
WINAPI
XNotifyUIGetOptions(
BOOL* pfShow,
BOOL* pfPlaySound
);
DWORD
WINAPI
XamInputGetState(
IN DWORD dwUserIndex,
IN DWORD dwFlags,
OUT PXINPUT_STATE pState
);
DWORD
WINAPI
XamInputGetCapabilities(
IN DWORD dwUserIndex,
IN DWORD dwFlags,
OUT PXINPUT_CAPABILITIES pCapabilities
);
DWORD
WINAPI
XamInputSetState(
IN DWORD dwUserIndex,
IN DWORD dwFlags,
IN PXINPUT_VIBRATION pVibration,
IN BYTE bAmplitude OPTIONAL,
IN BYTE bFrequency OPTIONAL,
IN BYTE bOffset OPTIONAL
);
DWORD
WINAPI
XamInputGetDeviceStats(
IN DWORD dwUserIndex,
OUT PXINPUT_DEVICE_STATS pDeviceStats
);
DWORD
WINAPI
XamInputGetKeystroke(
IN DWORD dwUserIndex,
IN DWORD dwFlags,
OUT PXINPUT_KEYSTROKE pKeystroke
);
DWORD
WINAPI
XamInputGetKeystrokeEx(
IN OUT PDWORD pdwUserIndex,
IN DWORD dwFlags,
OUT PXINPUT_KEYSTROKE pKeystroke
);
DWORD
WINAPI
XamInputGetKeystrokeHud(
IN DWORD dwUserIndex,
OUT PXINPUT_KEYSTROKE pKeystroke
);
DWORD
WINAPI
XamInputSetLayoutKeyboard(
IN DWORD dwUserIndex,
IN DWORD dwLanguage
);
DWORD
WINAPI
XamInputResetLayoutKeyboard(
IN DWORD dwUserIndex
);
WORD
WINAPI
XamInputToggleKeyLocks(
IN DWORD dwUserIndex,
IN WORD wToggleMask
);
VOID
XamInputEnableAutobind(
IN BOOL Enable
);
DWORD
XamEnableSystemAppInput(
IN DWORD dwUserIndex,
IN BOOL Enable
);
#define XDASHCONTEXT_NONE 0
#define XDASHCONTEXT_TROUBLESHOOTER 1
#define XDASHCONTEXT_ACCOUNTRECOVERY 2
#define XDASHCONTEXT_OOBE 3
VOID
XamSetDashContext(
IN DWORD dwDashContext
);
DWORD
XamGetDashContext(
VOID
);
DWORD
XamGetCurrentTitleId(
VOID
);
BOOL
WINAPI
XamIsCurrentTitleDash(
VOID
);
XBOXAPI
ULONG
WINAPI
XamGetSystemVersion(
VOID
);
XBOXAPI
NTSTATUS
WINAPI
XamGetGameRatings(
OUT PUCHAR* ppGameRatings,
OUT PULONG pcGameRatings
);
XBOXAPI
DWORD
WINAPI
XamGetWCNConfigFile(
OUT LPSTR pszFile,
IN DWORD cchFile
);
DECLSPEC_NORETURN
XBOXAPI
VOID
WINAPI
XamLaunchNewImage(
IN LPCSTR pszImagePath,
IN DWORD dwFlags
);
//------------------------------------------------------------------------------
// XVoice APIs
//------------------------------------------------------------------------------
#ifdef __XVOICE_H__
XBOXAPI
HRESULT
WINAPI
XamVoiceCreate(
IN DWORD dwUserIndex,
IN DWORD dwMaxAttachedPackets,
OUT PXVOICE_HANDLE phHandle
);
XBOXAPI
BOOL
WINAPI
XamVoiceHeadsetPresent(
IN XVOICE_HANDLE hObject
);
XBOXAPI
HRESULT
WINAPI
XamVoiceSubmitPacket(
IN XVOICE_HANDLE hObject,
IN BOOL fInput,
IN OUT PXMEDIAPACKET Packet
);
XBOXAPI
BOOL
WINAPI
XamVoiceClose(
IN XVOICE_HANDLE hObject
);
#endif __XVOICE_H__
#define XA_NONE 0x00000000
#define XA_REVIEW 0x00000000 // Tag XamAlloc callswith
// this if you're not sure
// what flags to use
#define XA_DEFAULT 0x00000000
// Type of memory
#define XA_WORKSPACE 0x10000000
#define XA_HEAP 0x20000000
#define XA_PHYSICAL 0x40000000
#define XA_XMP 0x80000000
#define _XA_TYPE_MASK_ 0xF0000000
// Modifiers
#define XA_PERMANENT 0x01000000
#define XA_UIRUNTIME 0x02000000
#define XA_CHARGESYSTEM 0x04000000
#define XA_CHARGETITLE 0x08000000
// By default all allocations thru XamAlloc are zero'ed out, pass this flag in to
// avoid that.
#define XA_NOZEROMEMORY 0x00100000
// Internalto XamAlloc use only, do not use
#define _XA_DEBUGHEAP_ 0x00010000
#define _XA_CHARGE_MASK_ 0x0C000000
#define _XA_LIFETIME_MASK_ 0x03000000
#define _XA_MODIFIER_MASK_ 0x0F100000
// Don't touch the _HXAMAPP_MASK_ values!
//#define XA_DONTTOUCH_ _HXAMAPP_MASK_
HRESULT
WINAPI
XamAlloc(
IN DWORD dwFlags,
IN DWORD cb,
OUT PVOID* ppv
);
// Use only for physical allocs
HRESULT
WINAPI
XamAllocEx(
IN DWORD dwFlagsEx,
IN DWORD dwFlags,
IN DWORD cb,
OUT PVOID* ppv
);
VOID
WINAPI
XamFree(
IN PVOID pv
);
SIZE_T
WINAPI
XamAllocSize(
IN PVOID pv
);
//------------------------------------------------------------------------------
// Session handle helpers
//------------------------------------------------------------------------------
DWORD
WINAPI
XamSessionCreateHandle(HANDLE* ph);
DWORD
WINAPI
XamSessionRefObjByHandle(HANDLE h, void** ppSessionStruct);
//------------------------------------------------------------------------------
DWORD
XamGetOverlappedResult(
IN PXOVERLAPPED lpXOverlapped,
OUT LPDWORD pdwResult,
IN BOOL bWait
);
DWORD
XamGetOverlappedExtendedError(
IN PXOVERLAPPED lpXOverlapped
);
DWORD
XamEnumerate(
IN HANDLE hEnum,
IN DWORD dwFlags,
IN PVOID pvBuffer,
IN DWORD cbBuffer,
OUT PDWORD pcItemsReturned OPTIONAL,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentCreate(
IN DWORD dwUserIndex,
IN LPCSTR pszRootName,
IN CONST XCONTENT_DATA* pcd,
IN DWORD dwContentFlags,
OUT PDWORD pdwDisposition OPTIONAL,
OUT PDWORD pdwLicenseMask OPTIONAL,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentCreateEx(
IN DWORD dwUserIndex,
IN LPCSTR pszRootName,
IN CONST XCONTENT_DATA* pcd,
IN DWORD dwContentFlags,
OUT PDWORD pdwDisposition OPTIONAL,
OUT PDWORD pdwLicenseMask OPTIONAL,
IN DWORD dwFileCacheSize,
IN ULARGE_INTEGER uliContentSize,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentCreateInternal(
IN LPCSTR pszRootName,
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
IN DWORD dwContentFlags,
OUT PDWORD pdwDisposition OPTIONAL,
OUT PDWORD pdwLicenseMask OPTIONAL,
IN DWORD dwFileCacheSize,
IN ULARGE_INTEGER uliContentSize,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentOpenFile(
IN DWORD dwUserIndex,
IN LPCSTR pszRootName,
IN LPCSTR pszFileName,
IN DWORD dwContentFlags,
IN DWORD dwFileCacheSize,
OUT PDWORD pdwLicenseMask OPTIONAL,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentOpenFileInternal(
IN DWORD dwUserIndex,
IN LPCSTR pszRootName,
IN LPCSTR pszFileName,
IN DWORD dwContentFlags,
IN DWORD dwFileCacheSize,
OUT PXCONTENT_DATA_INTERNAL pcdi OPTIONAL,
OUT PDWORD pdwLicenseMask OPTIONAL,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentInstall(
IN DWORD dwUserIndex,
IN XCONTENTDEVICEID DeviceID,
IN LPCSTR pszFileName,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentDelete(
IN DWORD dwUserIndex,
IN CONST XCONTENT_DATA* pcd,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentDeleteInternal(
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentResolve(
IN DWORD dwUserIndex,
IN CONST XCONTENT_DATA* pcd,
OUT LPSTR pszPath,
IN DWORD cchPath,
IN BOOL fCreateDir,
IN LPCSTR pszRootName, OPTIONAL
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentResolveInternal(
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
OUT LPSTR pszPath,
IN DWORD cchPath,
IN BOOL fCreateDir,
IN LPCSTR pszRootName, OPTIONAL
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentGetAttributes(
IN DWORD dwUserIndex,
IN CONST XCONTENT_DATA* pcd,
OUT LPWIN32_FILE_ATTRIBUTE_DATA pfad,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentGetAttributesInternal(
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
OUT LPWIN32_FILE_ATTRIBUTE_DATA pfad,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentCopyInternal(
IN CONST XUID* pXuidDst, OPTIONAL
IN CONST XCONTENTDEVICEID* pDeviceIdDst, OPTIONAL
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentMoveInternal(
IN CONST XUID* pXuidDst, OPTIONAL
IN CONST XCONTENTDEVICEID* pDeviceIdDst, OPTIONAL
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
#define XCONTENT_COPYFLAG_NONE 0x00000000
#define XCONTENT_COPYFLAG_DELETESOURCE 0x00000001
#define XCONTENT_COPYFLAG_DEVICETRANSFER 0x00000002
#define XCONTENT_COPYFLAG_PROFILETRANSFER 0x00000004
DWORD
XamContentClose(
IN LPCSTR pszRootName,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentFlush(
IN LPCSTR pszRootName,
IN PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentCreateEnumerator(
IN DWORD dwUserIndex,
IN XCONTENTDEVICEID DeviceID,
IN DWORD dwContentType,
IN DWORD dwContentFlags,
IN DWORD cItem,
OUT PDWORD pcbBuffer, OPTIONAL
OUT PHANDLE phEnum
);
DWORD
XamContentCreateEnumeratorInternal(
IN XUID xuid,
IN XCONTENTDEVICEID dwDeviceId,
IN DWORD dwContentType,
IN DWORD dwTitleId,
IN DWORD dwContentFlags,
IN DWORD cItem,
OUT PDWORD pcbBuffer, OPTIONAL
OUT PHANDLE phEnum
);
DWORD
XamContentCreateDeviceEnumerator(
IN DWORD dwContentTypes,
IN DWORD dwFlags,
IN DWORD cItem,
OUT PDWORD pcbBuffer OPTIONAL,
OUT PHANDLE phEnum
);
#define COMMONUSER_XUID ((XUID) -1)
DWORD
XamContentAggregateCreateEnumerator(
IN XUID xuid,
IN XCONTENTDEVICEID DeviceId,
IN DWORD dwContentType,
IN DWORD dwTitleId,
OUT PHANDLE phEnum
);
DWORD
XamContentGetDeviceState(
IN XCONTENTDEVICEID DeviceID,
IN OUT PXOVERLAPPED pOverlapped
);
DWORD
XamContentGetDeviceData(
IN XCONTENTDEVICEID DeviceID,
OUT PXDEVICE_DATA pDeviceData
);
DWORD
XamContentGetDeviceName(
IN XCONTENTDEVICEID DeviceID,
OUT LPWSTR pwszName,
IN DWORD cchName
);
DWORD
XamContentGetMetaDataInternal(
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
OUT XCONTENT_METADATA* pContentMetaData,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentSetThumbnail(
IN DWORD dwUserIndex,
IN CONST XCONTENT_DATA* pcd,
IN CONST BYTE* pbThumbnail,
IN DWORD cbThumbnail,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentGetThumbnail(
IN DWORD dwUserIndex,
IN CONST XCONTENT_DATA* pContentData,
OUT PBYTE pbThumbnail, OPTIONAL
IN OUT PDWORD pcbThumbnail,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentGetCreator(
IN DWORD dwUserIndex,
IN CONST XCONTENT_DATA* pContentData,
OUT BOOL* pfUserIsCreator,
OUT PXUID pxuid, OPTIONAL
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentSetThumbnailInternal(
IN CONST XCONTENT_DATA_INTERNAL* pcdi,
IN CONST BYTE* pbThumbnail,
IN DWORD cbThumbnail,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
XamContentGetLicenseMask(
OUT DWORD* pdwLicenseMask,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
#define XCONTENT_PACKAGE_FS_DEVICE_PREFIX "\\Device\\Package_"
#define XCONTENT_MAX_PACKAGE_FS_DEVICE_NAME 64
#define XCONTENT_PKGFLAG_KEEP_OPEN_ON_TITLE_TERMINATE 0x00000001
#define XCONTENT_PKGFLAG_DONT_UPDATE_DIGESTS_ON_CLOSE 0x00000002
#define COMMON_XCONTENT_PKGFLAGS (XCONTENT_PKGFLAG_KEEP_OPEN_ON_TITLE_TERMINATE | \
XCONTENT_PKGFLAG_DONT_UPDATE_DIGESTS_ON_CLOSE)
typedef struct _XCONTENT_MOUNTED_PACKAGE
{
PVOID pvFsDeviceObject;
PVOID pvFsBlockCache;
LIST_ENTRY leMountedPackages;
DWORD dwFlags;
HANDLE hPackageFile;
DWORD dwOpenRefCount;
RTL_CRITICAL_SECTION csHeaderLock;
XCONTENT_HEADER ContentHeader;
XCONTENT_METADATA ContentMetaData;
PBYTE pbOtherMetaData;
DWORD dwOtherMetaDataSize;
XCONTENTDEVICEID DeviceIDLocked;
CHAR szFsDeviceName[XCONTENT_MAX_PACKAGE_FS_DEVICE_NAME];
CHAR szPackageFilePath[MAX_PATH];
} XCONTENT_MOUNTED_PACKAGE, *PXCONTENT_MOUNTED_PACKAGE;
#define XCONTENT_CREATEPKG_KEEP_OPEN_ON_TITLE_TERMINATE XCONTENT_PKGFLAG_KEEP_OPEN_ON_TITLE_TERMINATE
#define XCONTENT_CREATEPKG_DONT_UPDATE_DIGESTS_ON_CLOSE XCONTENT_PKGFLAG_DONT_UPDATE_DIGESTS_ON_CLOSE
#define XCONTENT_CREATEPKG_OVERWRITE 0x00010000
#define VALID_XCONTENT_CREATEPKG_FLAGS (XCONTENT_CREATEPKG_KEEP_OPEN_ON_TITLE_TERMINATE | \
XCONTENT_CREATEPKG_DONT_UPDATE_DIGESTS_ON_CLOSE | \
XCONTENT_CREATEPKG_OVERWRITE)
DWORD
XamContentCreateAndMountPackage(
IN LPCSTR szPackagePath,
IN HANDLE hFileToUse OPTIONAL,
IN CONST XCONTENT_METADATA* pMetaData,
IN CONST BYTE* pbOtherMetaData OPTIONAL,
IN DWORD dwOtherMetaDataSize,
IN DWORD dwFlags,
IN XCONTENTDEVICEID DeviceIDToLock,
OUT PXCONTENT_MOUNTED_PACKAGE* ppMountedPackage
);
#define XCONTENT_OPENPKG_DONT_VERIFY_SIGNATURE 0x00010000
#define XCONTENT_OPENPKG_COPY_EXISTING_HANDLE 0x00020000
#define VALID_XCONTENT_OPENPKG_FLAGS (XCONTENT_OPENPKG_DONT_VERIFY_SIGNATURE | \
XCONTENT_OPENPKG_COPY_EXISTING_HANDLE)
DWORD
XamContentOpenPackageFile(
IN LPCSTR szPackagePath,
IN DWORD dwContentType,
IN DWORD dwFlags,
OUT HANDLE * phPackageFile,
OUT PXCONTENT_MOUNTED_PACKAGE* ppExistingMountedPackage,
OUT XCONTENT_HEADER * pContentHeader,
OUT XCONTENT_METADATA * pContentMetaData,
OUT BYTE * pbOtherMetaData OPTIONAL,
IN OUT DWORD * pdwOtherMetaDataSize OPTIONAL
);
#define XCONTENT_MOUNTPKG_KEEP_OPEN_ON_TITLE_TERMINATE XCONTENT_PKGFLAG_KEEP_OPEN_ON_TITLE_TERMINATE
#define XCONTENT_MOUNTPKG_DONT_UPDATE_DIGESTS_ON_CLOSE XCONTENT_PKGFLAG_DONT_UPDATE_DIGESTS_ON_CLOSE
#define VALID_XCONTENT_MOUNTPKG_FLAGS (XCONTENT_MOUNTPKG_KEEP_OPEN_ON_TITLE_TERMINATE | \
XCONTENT_MOUNTPKG_DONT_UPDATE_DIGESTS_ON_CLOSE)
DWORD
XamContentMountPackage(
IN HANDLE hPackageFile,
IN LPCSTR szPackagePath,
IN const XCONTENT_HEADER * pContentHeader,
IN const XCONTENT_METADATA * pContentMetaData,
IN const BYTE * pbOtherMetaData OPTIONAL,
IN DWORD dwOtherMetaDataSize,
IN DWORD dwFlags,
IN XCONTENTDEVICEID DeviceIDToLock,
OUT PXCONTENT_MOUNTED_PACKAGE * ppMountedPackage
);
DWORD
XamContentWritePackageHeader(
IN XCONTENT_MOUNTED_PACKAGE * pMountedPackage
);
DWORD
XamContentFlushPackage(
IN XCONTENT_MOUNTED_PACKAGE * pMountedPackage
);
DWORD
XamContentDismountAndClosePackage(
IN XCONTENT_MOUNTED_PACKAGE * pMountedPackage
);
DWORD
XamContentClosePackageFile(
IN HANDLE hPackageFile
);
DWORD
XamContentLockUnlockPackageHeaders(
IN XCONTENT_MOUNTED_PACKAGE * pMountedPackage,
IN BOOL fLock
);
DWORD
XamContentEstimatePackageSize(
IN DWORD cbContentSize
);
#define XamContentReferencePackage(pkg) ObReferenceObject((pkg)->pvFsDeviceObject)
#define XamContentDereferencePackage(pkg) ObDereferenceObject((pkg)->pvFsDeviceObject)
#define XamContentSetPackageFlags(pkg, flags) ((DWORD) InterlockedOr((LONG*) (&(pkg)->dwFlags), (LONG) (flags)))
#define XamContentClearPackageFlags(pkg, flags) ((DWORD) InterlockedAnd((LONG*) (&(pkg)->dwFlags), (LONG) (~(flags))))
DWORD
XamContentLaunchImage(
IN DWORD dwUserIndex,
IN CONST XCONTENT_DATA* pContentData,
IN LPCSTR pszImagePath
);
DWORD
XamContentLaunchImageInternal(
IN CONST XCONTENT_DATA_INTERNAL* pContentData,
IN LPCSTR pszImagePath
);
typedef struct _XDEVICERENAMEPARAM
{
XCONTENTDEVICEID DeviceID;
LPCWSTR pwszName;
DWORD cchName;
} XDEVICERENAMEPARAM, *PXDEVICERENAMEPARAM;
//------------------------------------------------------------------------------
// XamUser functions and flags
//------------------------------------------------------------------------------
#define XAMUSER_NONE 0x00000000
#define XAMUSER_XUID_OFFLINE 0x00000001
#define XAMUSER_XUID_ONLINE 0x00000002
#define XAMUSER_XUID_GUEST 0x00000004
#define XAMUSER_RECOVER_ACCOUNT 0x80000000
#define XAMUSERLOGON_OFFLINEONLY 0x00000001
#define XAMUSERLOGON_FORCELIVELOGOFF 0x00000002 // requires XAMUSERLOGON_OFFLINEONLY
#define XAMUSERLOGON_ADDUSERS 0x00000004
#define XAMUSERLOGON_REMOVEUSERS 0x00000008
#define XAMUSERLOGON_FOREGROUNDPRI 0x00000010
#define XAMUSERLOGON_NOPOPUPNOTIFICATION 0x00000020
#define XAMUSERLOGON_DONTWAITFORCOMPLETION 0x00000040
#define XAMUSERLOGON_ALLOWMACHINEACCOUNTONLY 0x00000080
#define XAMUSERLOGON_CHECKONLINETICKETSONLY 0x00000100
#define XAMUSERLOGON_ALLOWDEFAULTUSER 0x00000200
#define XAMUSERLOGON_ALLOWUSERSWITHREQUIREDMESSAGE 0x00000400
#define XAMUSERLOGON_RESTRICTEDPOPUPNOTIFICATION 0x00000800
HRESULT
WINAPI
XamUserGetXUID(
IN DWORD dwUserIndex,
IN DWORD dwFlags, // XAMUSER_XUID_ONLINE, OFFLINE or EITHER
OUT PXUID pxuid
);
HRESULT
WINAPI
XamUserGetIndexFromXUID(
IN XUID xuid,
IN DWORD dwFlags,
OUT PDWORD pdwUserIndex
);
HRESULT
WINAPI
XamUserGetGamerTag(
IN DWORD dwUserIndex,
OUT LPWSTR pszGamerTag,
IN DWORD cchGamerTag
);
HRESULT
WINAPI
XamUserLogon(
IN CONST XUID* rgUsers,
IN DWORD dwFlags,
IN PXOVERLAPPED pOverlapped OPTIONAL
);
#ifndef PROFILEENUMRESULT
typedef struct _PROFILEENUMRESULT PROFILEENUMRESULT;
#endif
HRESULT
WINAPI
XamUserLogonEx(
IN CONST PROFILEENUMRESULT* rgUsers,
IN DWORD dwFlags,
IN PXOVERLAPPED pOverlapped OPTIONAL
);
HRESULT
WINAPI
XamUserFlushLogonQueue(
IN PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
WINAPI
XamUserGetUserIndexMask(
IN DWORD dwFlags // See XAMUSER_
);
DWORD
WINAPI
XamUserGetRequestedUserIndexMask(
IN DWORD dwFlags // See XAMUSER_
);
DWORD
WINAPI
XamGetUserPresetPresenceState(
IN DWORD dwUserIndex
);
VOID
WINAPI
XamSetUserPresetPresenceState(
IN DWORD dwUserIndex,
IN DWORD dwStateFlags
);
BOOL
WINAPI
XamUserIsOnlineEnabled(
IN DWORD dwUserIndex
);
DWORD
WINAPI
XamUserGetUserFlags(
IN DWORD dwUserIndex
);
DWORD
WINAPI
XamUserGetUserFlagsFromXUID(
IN XUID xuid
);
DWORD
WINAPI
XamUserGetCachedUserFlags(
IN DWORD dwUserIndex
);
BYTE
WINAPI
XamUserGetOnlineCountryFromXUID(
IN XUID xuid
);
BYTE
WINAPI
XamUserGetMembershipTier(
IN DWORD dwUserIndex
);
BYTE
WINAPI
XamUserGetMembershipTierFromXUID(
IN XUID xuid
);
BOOL
WINAPI
XamUserIsGuest(
IN DWORD dwUserIndex
);
// Macros to use with XamUserGetUserIndexMask. Given a user index and a bit
// mask, tells if a user index bit is on or off.
#define XAMUSER_MASK_USERINDEX_X(__dwUserIndex__, __dw__) (!!((__dw__) & (1 << (__dwUserIndex__))))
#define XAMUSER_MASK_USERINDEX_0(__dw__) XAMUSER_USERINDEX_X(0, __dw__)
#define XAMUSER_MASK_USERINDEX_1(__dw__) XAMUSER_USERINDEX_X(1, __dw__)
#define XAMUSER_MASK_USERINDEX_2(__dw__) XAMUSER_USERINDEX_X(2, __dw__)
#define XAMUSER_MASK_USERINDEX_3(__dw__) XAMUSER_USERINDEX_X(3, __dw__)
HRESULT
WINAPI
XamUserGetDeviceContext(
IN DWORD dwUserIndex,
IN UCHAR ucDeviceCategory,
OUT PULONG_PTR pulDeviceContext
);
HRESULT
WINAPI
XamUserLookupDevice(
IN ULONG_PTR ulDeviceContext,
IN UCHAR ucDeviceCategory,
OUT PDWORD pdwUserIndex
);
HRESULT
WINAPI
XamUserBindDeviceCallback(
IN ULONG_PTR ulUserIdentifier,
IN ULONG_PTR ulDeviceContext,
IN UCHAR ucDeviceCategory,
IN BOOLEAN fUnbindUser,
OUT PUCHAR pucAssignedUser
);
DWORD
WINAPI
XamUserCheckPrivilege(
IN DWORD dwUserIndex,
IN DWORD PrivilegeType,
OUT PBOOL pfResult
);
DWORD
WINAPI
XamUserAreUsersFriends(
IN DWORD dwUserIndex,
IN PXUID pXuids,
IN DWORD dwXuidCount,
OUT PBOOL pfResult OPTIONAL,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
// Defines for XAMACCOUNTINFO's dwMask, indicate valid fields.
// Keep these bits packed together as much as possible. Might use some
// remaining bits for versioning at a later time.
#define XAMPROFILE_NONE 0x00000000
#define XAMPROFILE_PASSCODE 0x10000000 // set if password field is valid
#define XAMPROFILE_ONLINEENABLED 0x20000000 // set if account is online enabled
#define XAMPROFILE_VERSIONMASK 0x000000FF
#define XAMPROFILE_VERSION1 1
#define XAMPROFILE_CURRENTVERSION XAMPROFILE_VERSION1
#define XAMPROFILE_MAX_HD 32
#define XAMPROFILE_MAX_MU 8
#define XAMACCOUNT_LIVEFLAG_ACCTREQUIRESMGMT 0x00000001
#define XAMACCOUNT_PASSCODELENGTH 4
#define XAMACCOUNT_ONLINEDOMAINSIZE 20
#define XAMACCOUNT_ONLINEKERBEROSREALMSIZE 24
#define XAMACCOUNT_ONLINEKEYLENGTH 16
#define XAMACCOUNT_USERPASSPORTMEMBERNAMESIZE (113 + 1)
#define XAMACCOUNT_USERPASSPORTPASSWORDSIZE (16 + 16)
#define XAMACCOUNT_OWNERPASSPORTMEMBERNAMESIZE XAMACCOUNT_USERPASSPORTMEMBERNAMESIZE
#define XAMUSER_ISTEAMXUID IsTeamXUID
#define XAMUSER_ISOFFLINEXUID IsOfflineXUID
#define XAMUSER_ISONLINEXUID IsOnlineXUID
#define XAMUSER_ISGUESTXUID IsGuestXUID
#pragma pack(push, 1)
typedef struct _XAMACCOUNTINFO
{
DWORD dwReserved; // Don't touch outside of XamProfile* functions
DWORD dwLiveFlags;
WCHAR szGamerTag[XUSER_NAME_SIZE];
XUID xuidOnline;
DWORD dwCachedUserFlags;
DWORD dwOnlineServiceNetworkID;
BYTE rgbPasscode[XAMACCOUNT_PASSCODELENGTH];
CHAR szOnlineDomain[XAMACCOUNT_ONLINEDOMAINSIZE];
CHAR szOnlineKerberosRealm[XAMACCOUNT_ONLINEKERBEROSREALMSIZE];
BYTE rgbOnlineKey[XAMACCOUNT_ONLINEKEYLENGTH];
CHAR szUserPassportMembername[XAMACCOUNT_USERPASSPORTMEMBERNAMESIZE];
CHAR rgcUserPassportPassword[XAMACCOUNT_USERPASSPORTPASSWORDSIZE];
CHAR szOwnerPassportMembername[XAMACCOUNT_OWNERPASSPORTMEMBERNAMESIZE];
} XAMACCOUNTINFO, *PXAMACCOUNTINFO;
#pragma pack(pop)
typedef struct _USER_PAYMENT_INFO USER_PAYMENT_INFO, *PUSER_PAYMENT_INFO;
typedef struct _PASSPORT_SESSION_TOKEN PASSPORT_SESSION_TOKEN;
HRESULT
WINAPI
XamProfileCreate(
IN DWORD dwFlags, // XAMUSER_XUID_ONLINE, OFFLINE or both
IN OUT PXCONTENTDEVICEID pDeviceID,
IN XUID xuidOffline,
IN CONST XAMACCOUNTINFO* paccountinfo,
IN CONST USER_PAYMENT_INFO* puserpaymentinfo,
IN CONST PASSPORT_SESSION_TOKEN* puserPassportToken,
IN CONST PASSPORT_SESSION_TOKEN* pownerPassportToken,
OUT PVOID* ppvContext
);
HRESULT
WINAPI
XamProfileGetCreationStatus(
IN PVOID pvContext,
OUT PXUID pxuidOffline
);
HRESULT
WINAPI
XamProfileDelete(
IN XCONTENTDEVICEID DeviceID,
IN XUID xuidOffline
);
typedef struct _PROFILEENUMRESULT
{
XUID xuidOffline;
XAMACCOUNTINFO xai;
XCONTENTDEVICEID DeviceID;
} PROFILEENUMRESULT, *PPROFILEENUMRESULT;
DWORD
WINAPI
XamProfileCreateEnumerator(
IN XCONTENTDEVICEID DeviceID,
OUT PHANDLE phEnum
);
DWORD
WINAPI
XamProfileEnumerate(
IN HANDLE hEnum,
IN DWORD dwFlags,
OUT PPROFILEENUMRESULT pProfileEnumResult,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
WINAPI
XamProfileFindAccount(
IN XUID xuidOffline,
OUT PXAMACCOUNTINFO pAccountInfo,
OUT PXCONTENTDEVICEID pDeviceID OPTIONAL
);
DWORD
WINAPI
XamProfileRenameAccount(
IN XUID xuidOffline,
IN LPCWSTR pszName
);
DWORD
WINAPI
XamProfileOpen(
IN XUID xuidOffline,
IN LPCSTR pszRootName,
IN DWORD dwFlags,
OUT PXCONTENT_DATA_INTERNAL pcdi OPTIONAL
);
DWORD
WINAPI
XamProfileClose(
IN LPCSTR pszRootName
);
HRESULT
WINAPI
XamProfileLoadAccountInfo(
IN XCONTENTDEVICEID DeviceID,
IN XUID xuidOffline,
OUT PXAMACCOUNTINFO pAccountInfo
);
HRESULT
WINAPI
XamProfileSaveAccountInfo(
IN XCONTENTDEVICEID DeviceID,
IN XUID xuidOffline,
IN XAMACCOUNTINFO * pAccountInfo
);
__inline
BOOL
XamProfileIsParentalControlled(
IN CONST XAMACCOUNTINFO* pAccountInfo
)
{
return ((pAccountInfo->dwCachedUserFlags & XONLINE_USER_PARENTAL_CONTROLLED) != 0);
}
BOOL
WINAPI
XamAreMixedAccountsSignedIn(
);
//
// Contains information need to process an async message. This structure
// is pointed to by the InternalContext field from the XOVERLAPPED structure.
// In some cases, when some user data needs to be associated with the message,
// memory for the user data and this structure is allocated in a single
// allocation.
//
typedef struct _XASYNCMESSAGE
{
HXAMAPP hxamapp;
DWORD dwMessage;
PXOVERLAPPED pOverlapped;
PVOID pBuffer;
PVOID UserEvent;
PVOID Apc;
HXAMTASK hXamTask;
} XASYNCMESSAGE, *PXASYNCMESSAGE;
//
// XAM Boot Data
//
// This is shared between XAM and XBDM, so be sure to keep it backward
// compatible.
//
typedef enum _XAM_BOOT_REASON
{
XAM_BOOT_SYSTEM_START = 0,
XAM_BOOT_LAUNCH_MEDIA,
XAM_BOOT_LAUNCH_NEW_IMAGE,
XAM_BOOT_USER_REQUEST,
XAM_BOOT_DEBUG_REQUEST,
XAM_BOOT_RECOVERY,
XAM_BOOT_MFG_LOADER,
XAM_BOOT_DUMP,
XAM_BOOT_LAUNCH_DASHBOARD,
XAM_BOOT_LAUNCH_ANY_DASHBOARD,
} XAM_BOOT_REASON;
#define XAM_MAX_LAUNCH_PATH 256
#define XAM_BOOT_DATA_FLAG_TITLE 0x00000001
#define XAM_BOOT_DATA_FLAG_UNLOAD_HUD 0x00000002
#define XAM_BOOT_DATA_FLAG_BOUND_PATH 0x00000004
#define XAM_BOOT_DATA_FLAG_ASSUME_DVD 0x00000010
#define XAM_BOOT_DATA_FLAG_DASH_ARCADE 0x00000020
#define XAM_BOOT_DATA_FLAG_HYBRID_FORCE_DVD 0x00000040
#define XAM_BOOT_DATA_FLAG_HYBRID_FORCE_GAME 0x00000080
#define XAM_BOOT_DATA_FLAG_HYBRID_NO_NOTIFY 0x00000100
#pragma pack(push, 4)
typedef struct _XAM_BOOT_DATA_BLOCK
{
//
// Base (1888) structure
//
XAM_BOOT_REASON Reason;
DWORD Flags;
PVOID ImagePhysicalBase;
ULONG ImageSize;
CHAR ImageName[XAM_MAX_LAUNCH_PATH];
CHAR DDrive[XAM_MAX_LAUNCH_PATH];
CHAR CommandLine[XAM_MAX_LAUNCH_PATH];
//
// Fields added after build 1888
//
DWORD MinVersion;
} XAM_BOOT_DATA_BLOCK;
#pragma pack(pop)
HRESULT
WINAPI
XMsgAcquireAsyncMessageFromOverlapped(
IN PXOVERLAPPED pOverlapped,
OUT PXASYNCMESSAGE* ppMsg
);
HRESULT
WINAPI
XMsgReleaseAsyncMessageToOverlapped(
IN PXASYNCMESSAGE pMsg,
IN PXOVERLAPPED pOverlapped
);
//------------------------------------------------------------------------------
// System-defined string ids used in the SPA file
//------------------------------------------------------------------------------
#define X_STRINGID_TITLE 0x8000
typedef struct
{
DWORD dwTitleId;
ULONGLONG qwId;
DWORD dwUserIndex;
WCHAR* pwsz;
PDWORD pcch;
} XGI_READSTRING_MSG;
//------------------------------------------------------------------------------
// Tiles/Images/Pictures
//------------------------------------------------------------------------------
typedef enum
{
XTILETYPE_ACHIEVEMENT = 0,
XTILETYPE_GAME_ICON = 1,
XTILETYPE_GAMER_TILE = 2,
XTILETYPE_GAMER_TILE_SMALL = 3,
XTILETYPE_LOCAL_GAMER_TILE = 4,
XTILETYPE_LOCAL_GAMER_TILE_SMALL = 5,
XTILETYPE_BKGND = 6,
XTILETYPE_AWARDED_GAMER_TILE = 7,
XTILETYPE_AWARDED_GAMER_TILE_SMALL = 8,
XTILETYPE_GAMER_TILE_BY_IMAGE_ID = 9,
} XTILETYPE;
#define X_IMAGEID_FLAGS_LARGE 0x00020000
#define X_IMAGEID_FLAGS_SMALL 0x00010000
// number of tiles available to users to pick
#define NUM_FLASH_TILES 12
// total number of tiles available, including one for xbox 1 users
#define NUM_FLASH_TILES_ALL NUM_FLASH_TILES + 1
//
// System defined image ids
//
#define X_IMAGEID_DEFAULT_TITLEID XENON_DASH_TITLE_ID
#define X_IMAGEID_DEFAULT_TILE 0x0 + X_IMAGEID_FLAGS_LARGE
#define X_IMAGEID_DEFAULT_TILE_SMALL 0x0 + X_IMAGEID_FLAGS_SMALL
#define X_IMAGEID_GAME 0x8000
#define X_IMAGEID_GAMER 0x8001
#define X_IMAGEID_GAMER_SMALL 0x8002
#define X_IMAGEID_BKGND 0x8003
#define X_IMAGEID_GAME_MARKETPLACE 0x8004
typedef struct
{
DWORD dwUserIndex;
DWORD dwNumXuids;
CONST XUID* rgXuids;
} XGI_PREPAREGAMERTILES_MSG;
typedef struct
{
XTILETYPE eTileType;
DWORD dwTitleId; // Used for game tile and achievements
ULONGLONG qwImageId;
DWORD dwUserIndex; // Used for achievements
PBYTE pbImage;
PDWORD pcbBuffer;
DWORD cbBuffer;
DWORD dwPitch;
DWORD dwHeight;
} XGI_READWRITETILE_MSG;
typedef struct
{
BOOL fForEnumerate; // Making available for enumeration, or making it the gamer's tile?
DWORD dwUserIndex;
DWORD dwTitleId; // Title id of the granting title
DWORD dwImageId; // Image id of the 64x64 tile
DWORD dwImageIdSmall; // Image id of the 32x32 tile
BOOL fUpdateSetting; // Update profile setting as a part of writing tile? (only if fForEnumeate = false)
} XGI_WRITEGAMERTILE_MSG;
XBOXAPI
DWORD
WINAPI
XamUserCreateAchievementEnumerator(
IN DWORD dwTitleId, // A title in your family or 0 for the current title
IN DWORD dwUserIndex, // User index of locally signed-in user making the request
IN XUID xuidRequestee, // XUID of remote user whose titles are enumerated (or INVALID_XUID for a local enumeration)
IN DWORD dwDetailFlags, // Get the descriptions, etc.
IN DWORD dwStartingIndex, // Number of achievements to skip before enumerating
IN DWORD cItem, // Number of achievements to retrieve per enumeration
OUT PDWORD pcbBuffer, // Size of buffer needed to enumerate
OUT PHANDLE ph // Handle to created enumerator
);
XBOXAPI
DWORD
WINAPI
XamUserCreateStatsEnumerator(
IN DWORD dwTitleId, // Title id to read stats for, 0 if current
IN XGI_STATS_ENUMERATOR_TYPE enumType, // Type of enumeration to be performed
IN ULONGLONG qwPivot, // Rank, rating to start from, or user to pivot around, depending on type
IN DWORD dwNumRows, // Number of rows to retrieve
IN DWORD dwNumStatsSpecs, // Number of specs in the pSpecs parameter
IN CONST XUSER_STATS_SPEC* pSpecs, // Array of stats specs to retrieve
OUT PDWORD pcbBuffer, // Size of buffer needed to enumerate
OUT PHANDLE ph // Handle to created enumerator
);
XBOXAPI
DWORD
WINAPI
XamUserCreateTitlesPlayedEnumerator(
IN DWORD dwTitleId, // A title in your family or 0 for the current title
IN DWORD dwUserIndex, // User index of locally signed-in user making the request
IN XUID xuid, // XUID of remote user whose titles are enumerated (or INVALID_XUID for a local enumeration)
IN DWORD dwStartingIndex, // Number to skip before enumerating
IN DWORD cItem, // Number to retrieve per enumeration
OUT PDWORD pcbBuffer, // Size of buffer needed to enumerate
OUT PHANDLE ph // Handle to created enumerator
);
void
XamInitFlashTiles(void);
XBOXAPI
DWORD
WINAPI
XamPrepareGamerTiles(
IN DWORD dwUserIndex, // User index of user reading gamer tiles
IN DWORD dwNumXuids, // number of xuids in rgXuids
IN CONST XUID* rgXuids // List of users to prepare tiles for
);
XBOXAPI
DWORD
WINAPI
XamReadTile(
IN XTILETYPE eTileType,
IN DWORD dwTitleId,
IN ULONGLONG qwImageId,
IN DWORD dwUserIndex, // User index of profile to search in
IN PBYTE pbImage,
IN OUT PDWORD pcbBuffer,
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
XBOXAPI
DWORD
WINAPI
XamReadTileToTexture(
IN XTILETYPE eTileType,
IN DWORD dwTitleId,
IN ULONGLONG qwImageId,
IN DWORD dwUserIndex, // User index of profile to search in
IN OUT PBYTE pbTextureBuffer,
IN DWORD dwPitch,
IN DWORD dwHeight,
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
XBOXAPI
DWORD
WINAPI
XamWriteGamerTile(
IN DWORD dwUserIndex,
IN DWORD dwTitleId,
IN DWORD dwImageId,
IN DWORD dwImageIdSmall,
IN BOOL fForEnumeration,
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
XBOXAPI
DWORD
WINAPI
XamWriteTile(
IN XTILETYPE eTileType,
IN DWORD dwTitleId,
IN ULONGLONG qwImageId,
IN DWORD dwUserIndex,
IN PBYTE pbImage,
IN OUT DWORD cbImage,
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
DWORD
WINAPI
XamParseGamerTileKey(
IN PXUSER_DATA pKey,
OUT PDWORD pdwTitleId,
OUT PDWORD pdwImageId,
OUT PDWORD pdwImageIdSmall
);
XBOXAPI
DWORD
WINAPI
XamReadString(
IN DWORD dwTitleId,
IN ULONGLONG qwStringId,
IN DWORD dwUserIndex, // User index of profile to search in
IN WCHAR* pwsz,
IN OUT PDWORD pcch,
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
XBOXAPI
DWORD
XamGetCachedTitleName(
IN DWORD dwTitleId,
OUT LPWSTR pwsz,
IN OUT PDWORD pcch
);
XBOXAPI
DWORD
XamGetCachedGamerTag(
IN XUID xuid,
OUT LPSTR psz,
IN OUT PDWORD pcch
);
XBOXAPI
DWORD
XamGetCachedGamerTagW(
IN XUID xuid,
OUT LPWSTR pwsz,
IN OUT PDWORD pcch
);
XBOXAPI
HRESULT
WINAPI
XamReadImage(
IN DWORD dwTileFlags,
IN DWORD dwTitleId,
IN DWORD dwUserIndex,
IN ULONGLONG qwImageId,
OUT HXUIBRUSH* phBrush
);
XBOXAPI
HRESULT
WINAPI
XamDecompressPNGToTexture(
IN PBYTE pbPng,
IN DWORD cbPng,
IN PBYTE pbTexture,
IN DWORD dwPitch,
IN DWORD dwHeight
);
//------------------------------------------------------------------------------
// Server synchronization (profile settings, achievements, title list, etc.)
//------------------------------------------------------------------------------
typedef struct
{
DWORD dwUserIndexMask;
} XGI_SYNC_MSG;
XBOXAPI
DWORD
WINAPI
XamUserProfileSync(
IN DWORD dwUserIndexMask, // Who to sync (bitmap of user indexes (LSB == user index 0))
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
//------------------------------------------------------------------------------
// Title tracking and recovery
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Titles-played list
//------------------------------------------------------------------------------
// The XUSER_TITLE_PLAYED structure defines the info stored for each title
// ever played. It's used in both the SPIs and as the format stored in a profile
// file.
//
// If this format changes then all existing title records in all profiles will
// be invalidated. That's why there are unused members for adding new info later.
// Just be sure that the size of the structure (including alignment packing)
// remains the same!
typedef struct tagXUSER_TITLE_PLAYED
{
DWORD dwTitleId;
DWORD dwAchievementsPossible;
DWORD dwAchievementsEarned;
DWORD dwCredPossible;
DWORD dwCredEarned;
DWORD dwUnused1;
DWORD dwUnused2;
DWORD dwUnused3;
FILETIME ftLastLoaded; // Only changed if online
WCHAR wszTitleName[64]; // Includes null-terminator
} XUSER_TITLE_PLAYED;
typedef struct
{
DWORD dwUserIndex;
CONST XUSER_TITLE_PLAYED* pTitleToRecover;
} XGI_RECOVERTITLE_MSG;
XBOXAPI
DWORD
WINAPI
XamProfileRecoverTitle(
IN DWORD dwUserIndex,
IN CONST XUSER_TITLE_PLAYED* pTitleToRecover,
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
//------------------------------------------------------------------------------
// Profile settings
//------------------------------------------------------------------------------
XBOXAPI
DWORD
WINAPI
XamUserReadProfileSettings(
IN DWORD dwTitleId, // A title in your family or 0 for the current title
IN DWORD dwUserIndexRequester, // User index of requesting user. Used for permission checking.
IN DWORD dwNumFor, // Count of XUIDs in pxuidFor
IN CONST XUID* pxuidFor, // Pointer to array of XUIDs to request settings for
IN DWORD dwNumSettingIds, // Count of setting ids in pdwSettingIds
IN CONST DWORD* pdwSettingIds, // Pointer to array of settings to retrieve
IN OUT DWORD* pcbResults, // Size of pResults buffer. If *pchResults is 0 then required size is returned.
IN OUT PXUSER_READ_PROFILE_SETTING_RESULT pResults,
IN OUT PXOVERLAPPED pXOverlapped OPTIONAL
);
XBOXAPI
DWORD
WINAPI
XamUserWriteProfileSettings(
IN DWORD dwTitleId,
IN DWORD dwUserIndex, // User index of player whose settings are written
IN DWORD dwNumSettings, // Count of settings in pSettings
IN CONST PXUSER_PROFILE_SETTING pSettings, // Pointer to array of settings to set
IN PXOVERLAPPED pXOverlapped OPTIONAL
);
//------------------------------------------------------------------------------
// Messaging UI APIs
//------------------------------------------------------------------------------
XBOXAPI
DWORD
WINAPI
XamShowMessageComposeUI(
IN DWORD dwUserIndex,
IN CONST XUID* pXuidRecipients OPTIONAL,
IN UINT cRecipients,
IN LPCWSTR pszText OPTIONAL
);
XBOXAPI
DWORD
WINAPI
XamShowGameInviteUI(
IN DWORD dwUserIndex,
IN CONST XUID* pXuidRecipients OPTIONAL,
IN UINT cRecipients,
IN LPCWSTR pszText OPTIONAL
);
XBOXAPI
DWORD
WINAPI
XamShowFriendRequestUI(
IN DWORD dwUserIndex,
IN XUID xuidUser
);
XBOXAPI
DWORD
WINAPI
XamShowPrivateChatInviteUI(
IN DWORD dwUserIndex,
IN DWORD dwChannel
);
//------------------------------------------------------------------------------
// Virtual keyboard API
//------------------------------------------------------------------------------
typedef struct _XVIRTUALKBDUI_PARAMS
{
DWORD dwUserIndex;
DWORD cchResultText;
DWORD dwFlags;
LPCWSTR pDefaultText;
LPCWSTR pTitleText;
LPCWSTR pDescriptionText;
LPWSTR pResultText;
PXOVERLAPPED pOverlapped;
} XVIRTUALKBDUI_PARAMS, *PXVIRTUALKBDUI_PARAMS;
XBOXAPI
DWORD
WINAPI
XamShowKeyboardUI(
IN DWORD dwUserIndex,
IN DWORD dwFlags,
IN LPCWSTR pDefaultText,
IN LPCWSTR pTitleText,
IN LPCWSTR pDescriptionText,
OUT LPWSTR pResultText,
IN DWORD cchResultText,
IN OUT PXOVERLAPPED pOverlapped
);
//------------------------------------------------------------------------------
// QuickChat UI API
//------------------------------------------------------------------------------
typedef struct _XSHOWQUICKCHATUI_PARAMS
{
DWORD dwUserIndex;
} XSHOWQUICKCHATUI_PARAMS, *PXSHOWQUICKCHATUI_PARAMS;
XBOXAPI
DWORD
WINAPI
XamShowQuickChatUI(
IN DWORD dwUserIndex
);
//------------------------------------------------------------------------------
// VoiceMail application API
//------------------------------------------------------------------------------
#define XSHOWVOICEMAILUI_RESULTS_NONE 0x00000000
#define XSHOWVOICEMAILUI_RESULTS_RECORDED 0x00000001
#define XSHOWVOICEMAILUI_RESULTS_ACCEPTED 0x00000002
typedef struct _XVOICEMAILUI_RESULTS
{
DWORD dwResults;
DWORD cbRecordedBufferSize;
} XVOICEMAILUI_RESULTS, *PXVOICEMAILUI_RESULTS;
#define XSHOWVOICEMAILUI_FLAGS_PLAYVOICE 0x00000001
#define XSHOWVOICEMAILUI_FLAGS_RECORDVOICE 0x00000002
#define XSHOWVOICEMAILUI_FLAGS_RESERVED1 0x00000004
#define XSHOWVOICEMAILUI_FLAGS_RESERVED2 0x00000008
typedef struct _XVOICEMAILUI_PARAMS
{
DWORD dwUserIndex;
DWORD dwFlags;
PBYTE pbBuffer;
DWORD cbBufferSize;
DWORD cbRecordedBufferSize;
WORD wCodec;
PXVOICEMAILUI_RESULTS pResults;
} XVOICEMAILUI_PARAMS, *PXVOICEMAILUI_PARAMS;
XBOXAPI
DWORD
WINAPI
XamShowVoiceMailUI(
IN DWORD dwUserIndex,
IN DWORD dwFlags,
IN PBYTE pbBuffer,
IN DWORD cbBufferSize,
IN DWORD cbRecordedBufferSize,
IN WORD wCodec,
OUT PXVOICEMAILUI_RESULTS pResults
);
//------------------------------------------------------------------------------
// GamerProfile application API types
//------------------------------------------------------------------------------
#define XGAMERPROFILE_MODE_GAMERCARD 0x00
#define XGAMERPROFILE_MODE_GAMES 0x01
#define XGAMERPROFILE_MODE_ACHIEVEMENTS 0x02
#define XGAMERPROFILE_MODE_EDIT 0x03
typedef struct _XGAMERPROFILE_PARAMS
{
DWORD dwUserIndex;
DWORD dwMode;
XUID xuidTarget;
DWORD dwTitleId;
} XGAMERPROFILE_PARAMS, *PXGAMERPROFILE_PARAMS;
//------------------------------------------------------------------------------
// GamerProfile application APIs
//------------------------------------------------------------------------------
XBOXAPI
DWORD
WINAPI
XamShowGamerCardUI(
IN DWORD dwUserIndex
);
XBOXAPI
DWORD
WINAPI
XamShowGamerCardUIForXUID(
IN DWORD dwUserIndex,
IN XUID xuidPlayer,
IN BOOL fDisableChatButton
);
//
// API to show the Achievements UI
//
XBOXAPI
DWORD
WINAPI
XamShowAchievementsUI(
IN DWORD dwUserIndex,
IN DWORD dwTitleId
);
XBOXAPI
DWORD
WINAPI
XamShowGamesUI(
IN DWORD dwUserIndex,
IN XUID xuidTarget
);
typedef struct _XSHOWFRIENDSUI_PARAMS
{
DWORD dwUserIndex;
DWORD dwFlags;
XUID rgXuidRecipients[100];
UINT cRecipients;
WCHAR szText[256];
ULONGLONG qwParam;
DWORD dwChannel;
} XSHOWFRIENDSUI_PARAMS, *PXSHOWFRIENDSUI_PARAMS;
#define XSHOWFRIENDSUI_FLAGS_SHOWMESSAGES (0x01)
#define XSHOWFRIENDSUI_FLAGS_COMPOSEMESSAGE (0x02)
#define XSHOWFRIENDSUI_FLAGS_GAMEINVITE (0x04)
#define XSHOWFRIENDSUI_FLAGS_FRIENDREQUEST (0x08)
#define XSHOWFRIENDSUI_FLAGS_SHOWPLAYERS (0x10)
#define XSHOWFRIENDSUI_FLAGS_GAMERPROFILE (0x20)
#define XSHOWFRIENDSUI_FLAGS_QUICKCHAT (0x40)
#define XSHOWFRIENDSUI_FLAGS_DISABLECHAT (0x80)
#define XSHOWFRIENDSUI_FLAGS_PRIVATECHATINVITE (0x100)
#define XSHOWFRIENDSUI_FLAGS_SHOWRECENTMESSAGE (0x200)
#define XSHOWFRIENDSUI_FLAGS_PRIVATECHATCHANNEL (0x400)
#define XSHOWFRIENDSUI_FLAGS_INVOKEDBYPRIVATECHAT (0x800)
XBOXAPI
DWORD
WINAPI
XamShowFriendsUI(
IN DWORD dwUserIndex
);
XBOXAPI
DWORD
WINAPI
XamShowPlayersUI(
IN DWORD dwUserIndex
);
XBOXAPI
DWORD
WINAPI
XamShowMessagesUI(
IN DWORD dwUserIndex
);
XBOXAPI
DWORD
WINAPI
XamShowMessagesUIEx(
IN DWORD dwUserIndex,
IN DWORD dwFlags
);
XBOXAPI
DWORD
WINAPI
XamShowRecentMessageUI(
IN DWORD dwUserIndex,
IN ULONGLONG qwParam
);
XBOXAPI
DWORD
WINAPI
XamShowRecentMessageUIEx(
IN DWORD dwFlags,
IN DWORD dwUserIndex,
IN ULONGLONG qwParam,
IN DWORD dwChannel
);
XBOXAPI
DWORD
WINAPI
XamShowFriendsUIp(
IN DWORD dwUserIndex,
IN DWORD dwFlags
);
typedef struct _XSHOWSIGNINUI_PARAMS
{
DWORD dwUserIndex;
DWORD cPanes;
DWORD dwFlags;
PXOVERLAPPED pOverlapped;
} XSHOWSIGNINUI_PARAMS, *PXSHOWSIGNINUI_PARAMS;
XBOXAPI
DWORD
WINAPI
XamShowSigninUI(
IN DWORD cPanes,
IN DWORD dwFlags
);
XBOXAPI
DWORD
WINAPI
XamShowSigninUIEx(
IN DWORD cPanes,
IN DWORD dwFlags,
IN OUT PXOVERLAPPED pxov
);
XBOXAPI
DWORD
WINAPI
XamShowSigninUIp(
IN DWORD dwUserIndex,
IN DWORD cPanes,
IN DWORD dwFlags
);
XBOXAPI
DWORD
WINAPI
XamShowPasscodeVerifyUI(
IN DWORD dwUserIndex,
OUT PMESSAGEBOX_RESULT pResult,
IN OUT PXOVERLAPPED pOverlapped
);
XBOXAPI
DWORD
WINAPI
XamShowDirtyDiscErrorUI(
IN DWORD dwUserIndex
);
//------------------------------------------------------------------------------
// Feedback application APIs
//------------------------------------------------------------------------------
//
// Feedback API
//
#define FEEDBACK_ENTRYPOINT_PLAYERREVIEW 0
#define FEEDBACK_ENTRYPOINT_COMPLAINT 1
#define FEEDBACK_ENTRYPOINT_REPUTATION 2
typedef struct _XSHOWFEEDBACKUI_PARAMS
{
DWORD dwUserIndex;
XUID _xuidFeedbackTarget;
DWORD _dEntryPoint;
} XSHOWFEEDBACKUI_PARAMS, *PXSHOWFEEDBACKUI_PARAMS;
//
// API to show the feedback UI
//
XBOXAPI
DWORD
WINAPI
XamShowPlayerReviewUI(
IN DWORD dwUserIndex,
IN XUID XuidFeedbackTarget
);
XBOXAPI
DWORD
WINAPI
XamShowComplaintUI(
IN DWORD dwUserIndex,
IN XUID XuidFeedbackTarget
);
XBOXAPI
DWORD
WINAPI
XamShowReputationUI(
IN DWORD dwUserIndex
);
XBOXAPI
DWORD
WINAPI
XamContentGetMarketplaceCounts(
IN DWORD dwUserIndex,
IN DWORD dwContentCategories,
IN DWORD cbResults,
IN OUT XOFFERING_CONTENTAVAILABLE_RESULT* pResults,
IN PXOVERLAPPED pXOverlapped OPTIONAL
);
#define XSHOWMARKETPLACEUI_ACTIVETITLEID 0
typedef struct _MP_BILLING_ACCOUNT_INFO
{
BOOL fEditMode;
BYTE bPaymentTypeId;
WCHAR wszPaymentInstrumentId[MAX_INSTANCE_ID_LENGTH];
WCHAR wszStreet1[MAX_STREET_SIZE];
WCHAR wszStreet2[MAX_STREET_SIZE];
WCHAR wszCity[MAX_CITY_SIZE];
WCHAR wszDistrict[MAX_DISTRICT_SIZE];
WCHAR wszState[MAX_STATE_SIZE];
WCHAR wszPostalCode[MAX_POSTALCODE_SIZE];
WCHAR wszPhonePrefix[MAX_PHONE_PREFIX_SIZE];
WCHAR wszPhoneNumber[MAX_PHONE_NUMBER_SIZE];
WCHAR wszPhoneExtension[MAX_PHONE_EXTENSION_SIZE];
BYTE bCardTypeId;
WCHAR wszCreditAccountHolderName[MAX_CC_NAME_SIZE];
WCHAR wszCreditAccountNumber[MAX_CC_NUMBER_SIZE];
WCHAR wszCreditCCVNumber[MAX_CC_CCV_NUMBER_SIZE];
FILETIME ftExpirationDate;
WCHAR wszDebitAccountHolderName[MAX_DD_NAME_SIZE];
WCHAR wszDebitAccountNumber[MAX_DD_NUMBER_SIZE];
WCHAR wszDebitBankCode[MAX_DD_BANK_CODE_SIZE];
WCHAR wszDebitBranchCode[MAX_DD_BRANCH_CODE_SIZE];
WCHAR wszDebitCheckDigits[MAX_DD_CHECK_DIGITS_SIZE];
} MP_BILLING_ACCOUNT_INFO, *PMP_BILLING_ACCOUNT_INFO;
typedef struct _XSHOWMARKETPLACEUI_PARAMS
{
DWORD dwUserIndex;
XUID UserXuid;
DWORD dwEntryPoint;
ULONGLONG qwOfferID;
DWORD dwOfferType;
DWORD dwContentCategories;
DWORD dwTitleId;
BYTE bOnlineCountry;
PMP_BILLING_ACCOUNT_INFO pBillingInfo;
PXOVERLAPPED pOverlapped;
} XSHOWMARKETPLACEUI_PARAMS, *PXSHOWMARKETPLACEUI_PARAMS;
//
// XamShowMarketplaceUI - This is a private SPI that will be called by the Dashboard
// and the public XShowMarketplaceUI to display and
// enumerate content specific to the title specified by the
// dwTitleId parameter.
//
// dwUserIndex - The index of the currently signed in user for which content
// should be displayed
// dwEntryPoint - The starting location of the Marketplace HUD UI (See the
// XSHOWMARKETPLACEUI_ENTRYPOINTS enum)
// qwOfferID - If the entry point is specific to an offer the offering
// ID needs to be provided, otherwise this can be 0.
// dwOfferType - This can be used to filter the content list by offer type.
// dwContentCategories - If the title wishes to display only certain types of
// items (i.e. cars, maps, weapons, etc), they can use
// this category bit filter.
// dwTitleId - The Title Id of the the title that the content should be
// displayed for.
//
XBOXAPI
DWORD
WINAPI
XamShowMarketplaceUI(
IN DWORD dwUserIndex,
IN DWORD dwEntryPoint,
IN ULONGLONG qwOfferID,
IN DWORD dwOfferType,
IN DWORD dwContentCategories,
IN DWORD dwTitleId
);
XBOXAPI
DWORD
WINAPI
XamShowForcedNameChangeUI(
IN DWORD dwUserIndex
);
XBOXAPI
DWORD
WINAPI
XamShowSignupCreditCardUI(
IN BYTE bOnlineCountry,
IN OUT PMP_BILLING_ACCOUNT_INFO pCreditCardInfo,
IN BOOL fParentCreditCard,
IN OUT PXOVERLAPPED pOverlapped
);
typedef struct _XSHOWDEVICESELECTORUI_PARAMS
{
DWORD dwUserIndex;
DWORD dwContentType;
DWORD dwContentFlags;
ULARGE_INTEGER uliBytesRequested;
PXCONTENTDEVICEID pDeviceID;
PXOVERLAPPED pOverlapped;
} XSHOWDEVICESELECTORUI_PARAMS, *PXSHOWDEVICESELECTORUI_PARAMS;
XBOXAPI
DWORD
WINAPI
XamShowDeviceSelectorUI(
IN DWORD dwUserIndex,
IN DWORD dwContentType,
IN DWORD dwContentFlags,
IN ULARGE_INTEGER uliBytesRequested,
OUT PXCONTENTDEVICEID pDeviceID,
IN OUT PXOVERLAPPED pOverlapped
);
//------------------------------------------------------------------------------
// Updater application APIs
//------------------------------------------------------------------------------
#define XSHOWUPDATER_UPDATESOURCE_LIVE 0x00000001
#define XSHOWUPDATER_UPDATESOURCE_GAMEDISC 0x00000002
#define XSHOWUPDATER_UPDATESOURCE_STORAGE 0x00000003
#define XSHOWUPDATER_UPDATESOURCE_CACHE 0x00000004
#define XSHOWUPDATER_UPDATESOURCEMASK 0x0000000F
#define XSHOWUPDATER_LAUNCHING_DASH 0x00000010
typedef struct _XSHOWUPDATERUI_PARAMS
{
DWORD dwUserIndex;
DWORD dwUpdateFlags;
char szUpdatePath[MAX_PATH];
XEX_EXECUTION_ID ExecutionId;
char szTitleToLaunchWhenDone[XAM_MAX_LAUNCH_PATH];
char szTitleToLaunchDDrive[XAM_MAX_LAUNCH_PATH];
} XSHOWUPDATERUI_PARAMS, *PXSHOWUPDATERUI_PARAMS;
XBOXAPI
DWORD
WINAPI
XamShowUpdaterUI(
IN DWORD dwUserIndex,
IN DWORD dwUpdateFlags,
IN LPCSTR pszUpdatePath OPTIONAL,
IN CONST XEX_EXECUTION_ID* pExecutionId OPTIONAL,
IN LPCSTR pszTitleToLaunchWhenDone OPTIONAL,
IN LPCSTR pszTitleToLaunchDDrive OPTIONAL
);
XBOXAPI
HRESULT
WINAPI
XamUpdateStart(
IN CONST CHAR* pszUpdatePath OPTIONAL,
IN DWORD dwShowUpdaterFlags,
IN CONST XEX_EXECUTION_ID* pExecutionId OPTIONAL,
IN CONST CHAR* pszTitleToLaunchWhenDone OPTIONAL,
IN CONST CHAR* pszTitleToLaunchDDrive OPTIONAL,
OUT PHANDLE phUpdate
);
XBOXAPI
HRESULT
WINAPI
XamUpdateGetProgress(
IN HANDLE hUpdate,
OUT PDWORD pdwUpdateStateId OPTIONAL,
OUT PDWORD pdwPercentComplete OPTIONAL,
OUT ULONGLONG* pqwNumerator OPTIONAL,
OUT ULONGLONG* pqwDenominator OPTIONAL
);
XBOXAPI
void
WINAPI
XamUpdateGetExtenderInstance(
IN HANDLE hUpdate,
IN CONST CHAR* szSectionName,
OUT HINSTANCE* phInstance
);
XBOXAPI
void
WINAPI
XamUpdateFinish(
IN HANDLE hUpdate
);
XBOXAPI
HRESULT
WINAPI
XamUpdateAllocateExtenderBuffer(
IN HANDLE hUpdate,
IN DWORD dwExtenderSize,
OUT BYTE** ppbBuffer
);
XBOXAPI
HRESULT
WINAPI
XamUpdateAttachExtenderInstance(
IN HANDLE hUpdate,
IN HINSTANCE hInstance
);
XBOXAPI
VOID
WINAPI
XamRestartTitleLoadAfterUpdate(
VOID
);
XBOXAPI
VOID
WINAPI
XamUIThreadDisableFontPatching(
VOID
);
XBOXAPI
VOID
WINAPI
XamUIThreadEnableFontPatching(
VOID
);
XBOXAPI
DWORD
WINAPI
XamUpdateGetBaseSystemVersion(
VOID
);
XBOXAPI
DWORD
WINAPI
XamUpdateGetCurrentSystemVersion(
VOID
);
//------------------------------------------------------------------------------
// MessageBox and Live Upsell UI APIs (both are provided by the HUD sysapp)
//------------------------------------------------------------------------------
#define MESSAGEBOX_OPTION_MESSAGEBOX 0
#define MESSAGEBOX_OPTION_LIVEUPSELL 1
#define XMB_TITLEMAX 32
#define XMB_TEXTMAX 256
#define XMB_BUTTONTEXTMAX 32
typedef struct _MESSAGEBOX_PARAMS
{
DWORD dwOption;
DWORD dwUserIndex;
WCHAR szTitle[XMB_TITLEMAX];
WCHAR szText[XMB_TEXTMAX];
DWORD cButtons;
WCHAR rgButtons[XMB_MAXBUTTONS][XMB_BUTTONTEXTMAX];
DWORD dwFocusButton;
DWORD dwFlags;
PMESSAGEBOX_RESULT pResult;
PXOVERLAPPED pOverlapped;
} MESSAGEBOX_PARAMS, *PMESSAGEBOX_PARAMS;
XBOXAPI
DWORD
WINAPI
XamShowMessageBoxUI(
IN DWORD dwUserIndex,
IN LPCWSTR pszTitle,
IN LPCWSTR pszText,
IN DWORD cButtons,
IN LPCWSTR* rgButtons,
IN DWORD dwFocusButton,
IN DWORD dwFlags,
OUT PMESSAGEBOX_RESULT pResult,
IN OUT PXOVERLAPPED pOverlapped
);
#define MESSAGEBOXEX_ID_PAL50_INCOMPATIBLE 1
XBOXAPI
DWORD
WINAPI
XamShowMessageBoxUIEx(
IN DWORD dwUserIndex,
IN LPCWSTR pszTitle,
IN LPCWSTR pszText,
IN DWORD cButtons,
IN LPCWSTR* rgButtons,
IN DWORD dwFocusButton,
IN DWORD dwFlags,
IN DWORD dwMessageID,
OUT PMESSAGEBOX_RESULT pResult,
IN OUT PXOVERLAPPED pOverlapped
);
XBOXAPI
DWORD
WINAPI
XamShowLiveUpsellUI(
VOID
);
//------------------------------------------------------------------------------
// Create Profile UI API
//------------------------------------------------------------------------------
#define XCREATEPROFILE_MODE_CREATENEW 0x00
#define XCREATEPROFILE_MODE_SIGNUP 0x01
#define XCREATEPROFILE_MODE_RECOVER 0x02
typedef struct _XCREATEPROFILEUI_PARAMS
{
DWORD dwUserIndex;
DWORD dwMode;
XUID xuid;
} XCREATEPROFILEUI_PARAMS, *PXSHOWCREATEPROFILEUI_PARAMS;
#define XENON_SIGNUP_TITLE_ID 0xFFFE07DE
XBOXAPI
DWORD
WINAPI
XamShowCreateProfileUI(
IN DWORD dwUserIndex
);
XBOXAPI
DWORD
WINAPI
XamShowLiveSignupUI(
IN DWORD dwUserIndex,
IN BOOL fRecoverAccount
);
//------------------------------------------------------------------------------
// RecentPlayers Cache APIs
//------------------------------------------------------------------------------
XBOXAPI
DWORD
WINAPI
XamUserAddRecentPlayer(
IN DWORD dwUserIndex,
IN XUID pUser,
IN DWORD dwFlags,
IN DWORD dwTitleID,
IN DWORD dwRating,
IN LPCSTR szGamertag
);
XBOXAPI
DWORD
WINAPI
XamUserUpdateRecentPlayer(
IN DWORD dwUserIndex,
IN XUID xuidUser,
IN DWORD dwFlags,
IN DWORD dwRating,
IN LPCSTR szGamertag
);
XBOXAPI
DWORD
WINAPI
XamUserCreatePlayerEnumerator(
IN DWORD dwUserIndex,
IN DWORD dwStartingIndex,
IN DWORD cItem,
OUT PDWORD pcbBuffer,
OUT PHANDLE ph
);
//------------------------------------------------------------------------------
// Error code helpers
//------------------------------------------------------------------------------
__inline
DWORD
Win32FromHRESULT(
IN HRESULT hr
)
{
DWORD dw;
if (SUCCEEDED(hr))
{
dw = ERROR_SUCCESS;
}
else if (FACILITY_WIN32 == HRESULT_FACILITY(hr))
{
dw = (hr & ~0xFFFF0000);
}
else
{
dw = ERROR_FUNCTION_FAILED;
}
return dw;
}
//------------------------------------------------------------------------------
// XN_SYS_DISCMEDIACHANGED parameter and support API
//------------------------------------------------------------------------------
#define XDISCMEDIATYPE_NONE 0
#define XDISCMEDIATYPE_GAMEDISC 1
#define XDISCMEDIATYPE_XBOXGAME 2
#define XDISCMEDIATYPE_UNKNOWN 3
#define XDISCMEDIATYPE_DVDA 4
#define XDISCMEDIATYPE_DVD 5
#define XDISCMEDIATYPE_VCD 6
#define XDISCMEDIATYPE_CDAUDIO 7
#define XDISCMEDIATYPE_CDDATA 8
#define XDISCMEDIATYPE_GAMEDVDHYBRID 9
#define MAX_TITLE_TILE 16384
#define MAX_TITLE_NAME 23 // Includes null-terminator
typedef struct _XGAMEINFO
{
DWORD dwTitleId;
WCHAR wszTitleName[MAX_TITLE_NAME];
} XGAMEINFO, *PXGAMEINFO;
HRESULT
WINAPI
XamGetGameInfo(
OUT PXGAMEINFO pGameDiscInfo
);
XBOXAPI
VOID
WINAPI
XamGetMediaInfo(
DWORD* pdwMediaType,
DWORD* pdwTitleId
);
//------------------------------------------------------------------------------
// Inactivity settings SPI
//------------------------------------------------------------------------------
#define XAMINACTIVITY_SCREENSAVER 0
#define XAMINACTIVITY_AUTOSHUTOFF 1
#define XAMINACTIVITY_COUNT 2
#define XAMSCREENSAVER_OFFVALUE 4096
#define XAMSCREENSAVER_ONVALUE 10
HRESULT
WINAPI
XamEnableInactivityProcessing(
IN DWORD InactivityIndex,
IN BOOL Enable
);
HRESULT
WINAPI
XamSetInactivityTime(
IN DWORD InactivityIndex,
IN DWORD Minutes
);
VOID
WINAPI
XamSetInactivityTimeFromConfig(
DWORD InactivityIndex
);
VOID
XamResetInactivity(
VOID
);
XBOXAPI
BOOL
WINAPI
XamIsSysUiInvokedByXenonButton(
VOID
);
XBOXAPI
BOOL
WINAPI
XamIsSysUiInvokedByTitle(
VOID
);
XBOXAPI
BOOL
WINAPI
XamIsUIActive(
VOID
);
XBOXAPI
VOID
WINAPI
XamSysUiDisableAutoClose(
BOOL fLeaveOpen
);
//------------------------------------------------------------------------------
// Power Management SPI
//------------------------------------------------------------------------------
typedef enum _XAMPOWERMODE
{
XAMPOWERMODE_QUIET = 0,
XAMPOWERMODE_FULL,
} XAMPOWERMODE, *PXAMPOWERMODE;
XBOXAPI
DWORD
WINAPI
XamSetPowerMode(
IN XAMPOWERMODE PowerMode
);
//------------------------------------------------------------------------------
// Challenge Response SPI
//------------------------------------------------------------------------------
XBOXAPI
DWORD
WINAPI
XamExecuteChallenge(
IN PBYTE Image,
IN DWORD ImageSize,
IN PBYTE Arguments,
IN DWORD ArgumentsSize,
IN PBYTE ResultBuffer,
IN DWORD ResultBufferSize
);
//-----------------------------------------------------------------------------
// Internal Utility methods that are NOT exported via DLL.
//-----------------------------------------------------------------------------
NTSTATUS
XamQuerySymbolicLink(
LPCSTR SymbolicLinkName,
LPSTR DeviceNameBuffer,
DWORD DeviceNameBufferSize
);
#ifdef __cplusplus
};
#endif
#pragma warning(pop)
#endif // __XAMP_H__

1402
xbdm/imp/xboxp.h Normal file
View File

@@ -0,0 +1,1402 @@
//
// All APIs unique to Xbox that live in XAPILIB.LIB should be
// defined in this header file
//
#ifndef _XBOXP_
#define _XBOXP_
#ifdef __cplusplus
extern "C" {
#endif
#include "xbox.h"
#ifdef __cplusplus
}
#endif
#pragma warning(push)
#pragma warning(disable: 4201) // unnamed struct/union
#define XBOXAPI
#ifdef __cplusplus
extern "C" {
#endif
#define GUEST_SELECTOR_XUID ((XUID) 0xE000000000000000)
XBOXAPI
FORCEINLINE
BOOL
WINAPI
IsOfflineXUID(
XUID xuid
)
{
return (xuid & 0xF000000000000000) == 0xE000000000000000;
}
XBOXAPI
FORCEINLINE
BOOL
WINAPI
IsOnlineXUID(
XUID xuid
)
{
return (xuid & 0xFFFF000000000000) == 0x0009000000000000;
}
XBOXAPI
FORCEINLINE
BOOL
WINAPI
IsGuestXUID(
XUID xuid
)
{
DWORD HighPart;
HighPart = (DWORD)(xuid >> 48);
return ((HighPart & 0x000F) == 0x9) && ((HighPart & 0x00C0) > 0);
}
#define MAX_DISPLAY_BLOCKS 50001
XBOXAPI
DWORD
WINAPI
XGetDisplayBlocks(
IN LPCSTR szPathName
);
XBOXAPI
HANDLE
WINAPI
XapipCreateThread(
IN LPSECURITY_ATTRIBUTES lpThreadAttributes OPTIONAL,
IN DWORD dwStackSize OPTIONAL,
IN LPTHREAD_START_ROUTINE lpStartAddress,
IN LPVOID lpParameter OPTIONAL,
IN DWORD dwCreationFlags OPTIONAL,
IN DWORD dwThreadProcessor,
OUT LPDWORD lpThreadId OPTIONAL
);
#define XSAVEGAME_NOCOPY 1
XBOXAPI
DWORD
WINAPI
XCreateSaveGame(
IN LPCSTR szRootPathName,
IN LPCWSTR wszSaveGameName,
IN DWORD dwCreationDisposition,
IN DWORD dwCreateFlags,
OUT LPSTR szPathBuffer,
IN UINT uSize
);
XBOXAPI
DWORD
WINAPI
XDeleteSaveGame(
IN LPCSTR szRootPathName,
IN LPCWSTR wszSaveGameName
);
#define MAX_GAMENAME 128
typedef struct _XGAME_FIND_DATA {
WIN32_FIND_DATAA wfd;
CHAR szSaveGameDirectory[MAX_PATH];
WCHAR szSaveGameName[MAX_GAMENAME];
} XGAME_FIND_DATA, *PXGAME_FIND_DATA;
XBOXAPI
HANDLE
WINAPI
XFindFirstSaveGame(
IN LPCSTR szRootPathName,
OUT PXGAME_FIND_DATA pFindGameData
);
XBOXAPI
BOOL
WINAPI
XFindNextSaveGame(
IN HANDLE hFindGame,
OUT PXGAME_FIND_DATA pFindGameData
);
XBOXAPI
BOOL
WINAPI
XFindClose(
IN HANDLE hFind
);
#define MAX_NICKNAME 32
XBOXAPI
BOOL
WINAPI
XSetNicknameW(
IN LPCWSTR wszNickname,
IN BOOL fPreserveCase
);
#define XSetNickname XSetNicknameW
XBOXAPI
HANDLE
WINAPI
XFindFirstNicknameW(
IN BOOL fThisTitleOnly,
OUT LPWSTR wszNickname,
IN UINT uSize
);
#define XFindFirstNickname XFindFirstNicknameW
XBOXAPI
BOOL
WINAPI
XFindNextNicknameW(
IN HANDLE hFindNickname,
OUT LPWSTR wszNickname,
IN UINT uSize
);
#define XFindNextNickname XFindNextNicknameW
typedef ULONGLONG XOFFERING_ID;
#define MAX_CONTENT_DISPLAY_NAME 128
typedef struct _XCONTENT_FIND_DATA {
WIN32_FIND_DATAA wfd;
XOFFERING_ID qwOfferingId;
DWORD dwFlags;
CHAR szContentDirectory[MAX_PATH];
WCHAR szDisplayName[MAX_CONTENT_DISPLAY_NAME];
} XCONTENT_FIND_DATA, *PXCONTENT_FIND_DATA;
XBOXAPI
HANDLE
WINAPI
XFindFirstContent(
IN LPCSTR szRootPathName,
IN DWORD dwFlagFilter,
OUT PXCONTENT_FIND_DATA pFindContentData
);
XBOXAPI
BOOL
WINAPI
XFindNextContent(
IN HANDLE hFindContent,
OUT PXCONTENT_FIND_DATA pFindContentData
);
XBOXAPI
BOOL
WINAPI
XGetContentInstallLocation(
IN DWORD dwTitleID,
IN LPCSTR szSourceMetadataFileName,
OUT LPSTR szInstallDirectory
);
XBOXAPI
BOOL
WINAPI
XGetContentInstallLocationFromIDs(
IN DWORD dwTitleID,
IN XOFFERING_ID xOfferingID,
OUT LPSTR szInstallDirectory
);
XBOXAPI
BOOL
WINAPI
XInstallContentSignatures(
IN DWORD dwTitleID,
IN LPCSTR szSourceMetadataFileName,
IN LPCSTR szDestinationDirectory
);
XBOXAPI
BOOL
WINAPI
XCreateContentSimple(
IN DWORD dwTitleID,
IN XOFFERING_ID xOfferingID,
IN DWORD dwContentFlags,
IN LPCWSTR wszContentName,
IN LPCSTR szDestinationDirectory
);
XBOXAPI
BOOL
WINAPI
XRemoveContent(
IN LPCSTR szDirectoryName
);
XBOXAPI
HANDLE
WINAPI
XLoadContentSignaturesWithFileName(
IN DWORD dwTitleID,
IN LPCSTR szMetadataFileName
);
XBOXAPI
BOOL
WINAPI
XLocateSignatureByNameEx(
IN HANDLE hSignature,
IN LPCSTR szFileName,
IN DWORD dwFileOffset,
IN OUT LPDWORD pdwDataSize,
OUT LPBYTE* ppbSignatureData,
OUT LPDWORD pdwSignatureSize
);
XBOXAPI
BOOL
WINAPI
XLocateNextSignature(
IN HANDLE hSignature,
OUT LPSTR* pszFileName,
OUT LPDWORD pdwFileNameLength,
OUT LPDWORD pdwFileOffset,
OUT LPDWORD pdwDataSize,
OUT LPBYTE* ppbSignatureData,
OUT LPDWORD pdwSignatureSize
);
XBOXAPI
BOOL
WINAPI
XInstallContentSignaturesWithFileName(
IN DWORD dwTitleID,
IN LPCSTR szSourceMetadataFileName,
IN LPCSTR szDestinationName,
IN DWORD dwInstallFlags
);
XBOXAPI
BOOL
WINAPI
XInstallContentSignaturesEx(
IN DWORD dwTitleID,
IN LPCSTR szSourceMetadataFileName,
IN LPCSTR szInstallDirectory,
IN DWORD dwInstallFlags
);
#define XSIG_INSTALL_NO_CHECK_SIGNATURE 0x00000001
#define XSIG_INSTALL_MARK_AS_INSTALLED 0x00000002
#define XCALCSIG_LIVE_SIGNATURE_SIZE 100
typedef struct {
DWORD SignatureFlags;
BYTE LiveSignature[XCALCSIG_LIVE_SIGNATURE_SIZE];
} XCONTSIG_LIVE_SIGNATURE_INFO, *PXCONTSIG_LIVE_SIGNATURE_INFO;
XBOXAPI
HANDLE
WINAPI
XLoadContentSignaturesEx(
IN DWORD dwTitleID,
IN LPCSTR szDirectoryName
);
#define XLoadContentSignatures(lpDirectoryName) \
XLoadContentSignaturesEx(0, lpDirectoryName)
XBOXAPI
BOOL
WINAPI
XLocateLiveSignature(
IN HANDLE hSignature,
OUT PXCONTSIG_LIVE_SIGNATURE_INFO pxlsInfo,
OUT PBYTE pbLiveDigest
);
XBOXAPI
BOOL
WINAPI
XLocateSignatureByIndex(
IN HANDLE hSignature,
IN DWORD dwSignatureIndex,
OUT LPBYTE* ppbSignatureData,
OUT LPDWORD pdwSignatureSize
);
XBOXAPI
BOOL
WINAPI
XLocateSignatureByName(
IN HANDLE hSignature,
IN LPCSTR szFileName,
IN DWORD dwFileOffset,
IN DWORD dwDataSize,
OUT LPBYTE* ppbSignatureData,
OUT LPDWORD pdwSignatureSize
);
XBOXAPI
BOOL
WINAPI
XCalculateContentSignature(
IN LPBYTE pbData,
IN DWORD dwDataSize,
OUT LPBYTE pbSignature,
IN OUT LPDWORD pdwSignatureSize
);
XBOXAPI
VOID
WINAPI
XCloseContentSignatures(
IN HANDLE hSignature
);
XBOXAPI
VOID
WINAPI
XComputeContentSignatureKey(
IN ULONG dwTitleID,
OUT PUCHAR pbSignatureKey
);
XBOXAPI
DWORD
WINAPI
XGetLocale();
#define XC_VIDEO_STANDARD_PAL_M 4
//
// Index for reserved fields in XVIDEO_MODE
//
#define XVIDEO_MODE_INDEX_PIXEL_CLOCK 0
#define XC_AV_PACK_SDC 0 // Standard-definition component
#define XC_AV_PACK_SCART 1 // SCART (composite and RGB SDTV)
#define XC_AV_PACK_RFU 2 // RF SDTV
#define XC_AV_PACK_HDC 3 // High-definition component
#define XC_AV_PACK_RESERVED 4 // Reserved
#define XC_AV_PACK_CSV 5 // Composite/S-Video
#define XC_AV_PACK_PC 6 // PC (output RGB VGA, hsync/vsync/DDC)
#define XC_AV_PACK_NONE 7 // Indicates no AV pack plugged in
#define XC_AV_PACK_MAX 8
XBOXAPI
DWORD
WINAPI
XGetAVPack(
VOID
);
XBOXAPI
DWORD
WINAPI
XGetVideoStandard(
VOID
);
#define XC_VIDEO_FLAGS_LETTERBOX 0x00000010
#define XC_VIDEO_FLAGS_PAL_60Hz 0x00000040
//
// Analog speaker configuration values are a enumeration while digital values
// are a bitmask. 0 is not a valid analog value, but 0 in the digital word
// indicates that no digital encoding or preencoded output is allowed on the
// digital channel. In that case, the digital channel will output the same
// data as the analog.
//
#define XC_AUDIO_FLAGS_SURROUND 0x00000001
#define XC_AUDIO_FLAGS_MONO 0x00000002
#define XC_AUDIO_FLAGS_ENABLE_DOLBYDIGITAL 0x00010000
#define XC_AUDIO_FLAGS_ENABLE_WMAPRO 0x00020000
#define XC_AUDIO_FLAGS_BASICMASK 0x0000FFFF
#define XC_AUDIO_FLAGS_ENCODEDMASK 0xFFFF0000
#define XC_AUDIO_FLAGS_BASIC(c) ((DWORD)(c) & XC_AUDIO_FLAGS_BASICMASK)
#define XC_AUDIO_FLAGS_ENCODED(c) ((DWORD)(c) & XC_AUDIO_FLAGS_ENCODEDMASK)
#define XC_AUDIO_FLAGS_COMBINED(b,e) (XC_AUDIO_FLAGS_BASIC(b) | XC_AUDIO_FLAGS_ENCODED(e))
#define XC_AUDIO_FLAGS_DEFAULT XC_AUDIO_FLAGS_COMBINED(XC_AUDIO_FLAGS_SURROUND, XC_AUDIO_FLAGS_ENABLE_DOLBYDIGITAL)
XBOXAPI
DWORD
WINAPI
XGetAudioFlags(
VOID
);
#define XC_CONSOLE_REGION_NA 0x00
#define XC_CONSOLE_REGION_ASIA 0x01
#define XC_CONSOLE_REGION_EUROPE 0x02
#define XC_CONSOLE_REGION_RESTOFWORLD 0x03
#define XC_CONSOLE_REGION_DEVKIT 0x7F
#define XC_GAME_REGION(region, subregion) \
((XC_CONSOLE_REGION_##region << 8) | (subregion))
#define XC_GAME_REGION_NA_ALL XC_GAME_REGION(NA, 0xFF)
#define XC_GAME_REGION_ASIA_ALL XC_GAME_REGION(ASIA, 0xFF)
#define XC_GAME_REGION_ASIA_JAPAN XC_GAME_REGION(ASIA, 0x01)
#define XC_GAME_REGION_ASIA_CHINA XC_GAME_REGION(ASIA, 0x02)
#define XC_GAME_REGION_ASIA_REST XC_GAME_REGION(ASIA, 0xFC)
#define XC_GAME_REGION_EUROPE_ALL XC_GAME_REGION(EUROPE, 0xFF)
#define XC_GAME_REGION_EUROPE_AUNZ XC_GAME_REGION(EUROPE, 0x01)
#define XC_GAME_REGION_EUROPE_REST XC_GAME_REGION(EUROPE, 0xFE)
#define XC_GAME_REGION_RESTOFWORLD_ALL XC_GAME_REGION(RESTOFWORLD, 0xFF)
#define XC_GAME_REGION_DEVKIT_ALL XC_GAME_REGION(DEVKIT, 0xFF)
#define XC_GAME_REGION_MANUFACTURING 0x8000
#define XC_GAME_REGION_REGION(region) \
(((region) & 0xFF00) >> 8)
//
// These flags are stored in the retail flags (XCONFIG_USER_RETAIL_FLAGS).
//
#define XC_MISC_FLAG_AUTOPOWERDOWN 0x00000001
#define XC_MISC_FLAG_DONT_USE_DST 0x00000002
#define XC_MISC_FLAG_CONNECTIONNOTICE 0x00000004
#define XC_MISC_FLAG_24HCLOCK 0x00000008
#define XC_MISC_FLAG_NO_NOTIFY_DISPLAY 0x00000010
#define XC_MISC_FLAG_NO_NOTIFY_SOUND 0x00000020
#define XC_MISC_FLAG_OOBE_HAS_RUN 0x00000040
#define XC_MISC_FLAG_ALL_MASK ((XC_MISC_FLAG_AUTOPOWERDOWN) | (XC_MISC_FLAG_DONT_USE_DST) | (XC_MISC_FLAG_CONNECTIONNOTICE) | \
(XC_MISC_FLAG_24HCLOCK) | (XC_MISC_FLAG_NO_NOTIFY_DISPLAY) | (XC_MISC_FLAG_NO_NOTIFY_SOUND) | \
(XC_MISC_FLAG_OOBE_HAS_RUN))
#define XINPUT_GAMEPAD_XE 0x0400
#define XINPUT_GAMEPAD_BINDING 0x0800
#define XINPUT_FLAG_SYSTEMAPP 0x80000000
#define XINPUT_MAX_RAW_BUFFER (32)
typedef struct _XINPUT_RAW
{
BYTE Buffer[XINPUT_MAX_RAW_BUFFER];
BYTE Length;
DWORD dwPacketNumber;
} XINPUT_RAW, *PXINPUT_RAW;
//
// The master vibration level is stored as a user profile setting. It may be
// one of the following. These are redundant definitions. The actual profile
// enum values may be found in xonline.h, but this header includes these
// definitions for the driver and other system components.
//
#define XINPUT_VIBRATION_LEVEL_NONE 0
#define XINPUT_VIBRATION_LEVEL_LOW 1
#define XINPUT_VIBRATION_LEVEL_MEDIUM 2
#define XINPUT_VIBRATION_LEVEL_HIGH 3
#define XINPUT_VIBRATION_LEVEL_MAX 4
//
// Battery level may only be one of the following
//
#define XINPUT_BATTERY_LEVEL_LITTLE 0
#define XINPUT_BATTERY_LEVEL_LOW 1
#define XINPUT_BATTERY_LEVEL_MEDIUM 2
#define XINPUT_BATTERY_LEVEL_HIGH 3
#define XINPUT_BATTERY_LEVEL_MAX 4
//
// Wireless signal strength may be reported as one of the following values
//
#define XINPUT_SIGNAL_STRENGTH_VERY_LOW 0
#define XINPUT_SIGNAL_STRENGTH_LOW 1
#define XINPUT_SIGNAL_STRENGTH_MEDIUM 2
#define XINPUT_SIGNAL_STRENGTH_GOOD 3
#define XINPUT_SIGNAL_STRENGTH_MAX 4
typedef struct _XINPUT_DEVICE_STATS {
ULONG ulBatteryLevel;
ULONG ulSignalStrength;
ULONG ulDeviceType;
ULONG ulDevicePort;
ULONG ulDeviceVersion;
} XINPUT_DEVICE_STATS, *PXINPUT_DEVICE_STATS;
XBOXAPI
DWORD
WINAPI
XInputSetStateEx(
IN DWORD dwUserIndex,
IN PXINPUT_VIBRATION pVibration,
IN BYTE bAmplitude OPTIONAL,
IN BYTE bFrequency OPTIONAL,
IN BYTE bOffset OPTIONAL
);
XBOXAPI
DWORD
WINAPI
XInputRawState(
IN DWORD dwUserIndex,
IN DWORD dwFlags,
IN BOOL fSetState,
IN PXINPUT_RAW pRawState
);
typedef struct _XINPUT_POLLING_PARAMETERS
{
BYTE fAutoPoll:1;
BYTE fInterruptOut:1;
BYTE ReservedMBZ1:6;
BYTE bInputInterval;
BYTE bOutputInterval;
BYTE ReservedMBZ2;
} XINPUT_POLLING_PARAMETERS, *PXINPUT_POLLING_PARAMETERS;
typedef struct _XINPUT_DEVICE_DESCRIPTION
{
WORD wVendorID;
WORD wProductID;
WORD wVersion;
} XINPUT_DEVICE_DESCRIPTION, *PXINPUT_DEVICE_DESCRIPTION;
XBOXAPI
DWORD
WINAPI
XInputGetDeviceDescription(
IN HANDLE hDevice,
OUT PXINPUT_DEVICE_DESCRIPTION pDescription
);
#define XINPUT_LIGHTGUN_CALIBRATION_CENTER_X 0
#define XINPUT_LIGHTGUN_CALIBRATION_CENTER_Y 0
#define XINPUT_LIGHTGUN_CALIBRATION_UPPERLEFT_X -25000
#define XINPUT_LIGHTGUN_CALIBRATION_UPPERLEFT_Y 25000
typedef struct _XINPUT_LIGHTGUN_CALIBRATION_OFFSETS
{
WORD wCenterX;
WORD wCenterY;
WORD wUpperLeftX;
WORD wUpperLeftY;
} XINPUT_LIGHTGUN_CALIBRATION_OFFSETS, *PXINPUT_LIGHTGUN_CALIBRATION_OFFSETS;
//
// XVoice APIs
//
typedef PVOID XVOICE_HANDLE, *PXVOICE_HANDLE;
typedef struct XMEDIAPACKET *PXMEDIAPACKET;
#ifdef __XVOICE_H__
XBOXAPI
HRESULT
WINAPI
XVoiceCreate(
IN DWORD dwUserIndex,
IN DWORD dwMaxAttachedPackets,
OUT PXVOICE_HANDLE phHandle
);
XBOXAPI
HRESULT
WINAPI
XVoiceSubmitPacket(
IN XVOICE_HANDLE hObject,
IN BOOL fInput,
IN OUT PXMEDIAPACKET pPacket
);
XBOXAPI
BOOL
WINAPI
XVoiceClose(
IN XVOICE_HANDLE hObject
);
#endif // __XVOICE_H__
XBOXAPI
DWORD
WINAPI
XCleanDrive(
IN CHAR chDrive
);
XBOXAPI
BOOL
WINAPI
XapiRecovery(
IN BOOL QuickFormat
);
#define XINIT_LIMIT_DEVKIT_MEMORY 0x00000004
#define XINIT_NO_SETUP_HARD_DISK 0x00000008
#define XINIT_DONT_MODIFY_HARD_DISK 0x00000010
XBOXAPI
DWORD
WINAPI
XMountUtilityDriveInternal(
IN DWORD dwTitleId,
IN BOOL fFormatClean,
IN DWORD dwBytesPerCluster,
IN SIZE_T dwFileCacheSize
);
XBOXAPI
BOOL
WINAPI
XFormatUtilityDrive(
VOID
);
XBOXAPI
DWORD
WINAPI
XMountAlternateTitleA(
IN LPCSTR szRootPath,
IN DWORD dwAltTitleId,
OUT PCHAR pchDrive
);
#define XMountAlternateTitle XMountAlternateTitleA
XBOXAPI
DWORD
WINAPI
XUnmountAlternateTitleA(
IN CHAR chDrive
);
#define XUnmountAlternateTitle XUnmountAlternateTitleA
XBOXAPI
DWORD
WINAPI
XGetDiskSectorSizeA(
IN LPCSTR szRootPathName
);
#define XGetDiskSectorSize XGetDiskSectorSizeA
#define XBOX_HD_SECTOR_SIZE 512
#define XBOX_DVD_SECTOR_SIZE 2048
#define XBOX_MU_SECTOR_SIZE 4096
XBOXAPI
DWORD
WINAPI
XGetDiskClusterSizeA(
IN LPCSTR szRootPathName
);
#define XGetDiskClusterSize XGetDiskClusterSizeA
#ifdef _XBOX_ //only define this if xbox.h was already included.
#include <pshpack1.h>
typedef struct _XDCS_DVD_CODE_INFORMATION
{
WORD bcdVersion;
DWORD dwCodeLength;
} XDCS_DVD_CODE_INFORMATION, *PXDCS_DVD_CODE_INFORMATION;
#include <poppack.h>
typedef struct _XDCS_ASYNC_DOWNLOAD_REQUEST
{
DWORD dwDeviceInstance;
PVOID pvBuffer;
ULONG ulOffset;
ULONG ulLength;
ULONG ulBytesRead;
ULONG ulStatus;
HANDLE hCompleteEvent;
} XDCS_ASYNC_DOWNLOAD_REQUEST, *PXDCS_ASYNC_DOWNLOAD_REQUEST;
DWORD
WINAPI
XDCSGetInformation(
IN DWORD dwPort,
OUT PDWORD pdwDeviceInstance,
OUT PXDCS_DVD_CODE_INFORMATION pDvdCodeInformation
);
DWORD
WINAPI
XDCSDownloadCode(
DWORD dwDeviceInstance,
PVOID pvBuffer,
ULONG ulOffset,
ULONG ulLength,
PULONG pulBytesRead
);
DWORD
WINAPI
XDCSDownloadCodeAsync(
IN OUT PXDCS_ASYNC_DOWNLOAD_REQUEST pXDCSDownloadRequest
);
#endif //_XBOX_
BOOL
WINAPI
XapiSetLocalTime(
IN CONST SYSTEMTIME* lpLocalTime
);
DWORD
WINAPI
XapipQueryTimeZoneInformation(
OUT PTIME_ZONE_INFORMATION TimeZoneInformation,
OUT PBOOL pfUseDST
);
DWORD
WINAPI
XapipSetTimeZoneInformation(
IN PTIME_ZONE_INFORMATION TimeZoneInformation
);
BOOL
WINAPI
XapipUseDaylightSavingTime();
#define MAX_LAUNCH_DATA_SIZE 1020
#define XLDEMO_RUNMODE_KIOSKMODE 0x01
#define XLDEMO_RUNMODE_USERSELECTED 0x02
#define MAX_LAUNCH_CMDLINE_SIZE 256
//
// Structures and enumerations for LaunchData.
//
#define XDASHLAUNCHDATA_RESERVED_SIZE (MAX_LAUNCH_DATA_SIZE - 12)
#define XDASHLAUNCHDATA_COMMAND_DEFAULT 0
#define XDASHLAUNCHDATA_COMMAND_SIGNUP 1
#define XDASHLAUNCHDATA_COMMAND_NETWORKTROUBLESHOOTER 2
#define XDASHLAUNCHDATA_COMMAND_ARCADE 3
#define XDASHLAUNCHDATA_COMMAND_MEMORY 4
#define XDASHLAUNCHDATA_COMMAND_MUSIC 6
#define XDASHLAUNCHDATA_COMMAND_DVD 7
#define XDASHLAUNCHDATA_COMMAND_MCXDOWNLOADER 8 // MCX depends on this value *never* changing
#define XDASHLAUNCHDATA_COMMAND_MEDIANETWORKTROUBLESHOOTER 9
#define XDASHLAUNCHDATA_COMMAND_ACCOUNTMANAGE_HOME 10
#define XDASHLAUNCHDATA_COMMAND_ACCOUNTMANAGE_PRIVACY 11
#define XDASHLAUNCHDATA_COMMAND_ACCOUNTMANAGE_ACCEPTTOU 12
#define XDASHLAUNCHDATA_COMMAND_ACCOUNTMANAGE_BILLING 13
#define XDASHLAUNCHDATA_COMMAND_GAMES_DEMOS 14
#define XDASHLAUNCHDATA_COMMAND_GAMES_TRAILERS 15
#define XDASHLAUNCHDATA_COMMAND_RETURNFROMENTRYPOINT_MUSIC 16
#define XDASHLAUNCHDATA_COMMAND_MARKETPLACE_TILES 17
#define XDASHLAUNCHDATA_COMMAND_SETTINGS 18
#define XDASHLAUNCHDATA_COMMAND_RETURNFROMENTRYPOINT_GAMES 19
#define XDASHLAUNCHDATA_COMMAND_FAMILYSETTINGS 20
#define XDASHLAUNCHDATA_COMMAND_RETURNFROMENTRYPOINT_SYSTEM 21
#define XDASHLAUNCHDATA_COMMAND_OOBE_WELCOME 22
#define XDASHLAUNCHDATA_COMMAND_GAMES_ARCADE 23
typedef struct _XDASHLAUNCHDATA
{
DWORD dwVersion;
DWORD dwCommand;
DWORD dwUserIndex;
BYTE Reserved[XDASHLAUNCHDATA_RESERVED_SIZE];
} XDASHLAUNCHDATA;
XBOXAPI
DWORD
WINAPI
XSetLaunchData(
IN PVOID pLaunchData,
IN DWORD dwLaunchDataSize
);
XBOXAPI
DWORD
WINAPI
XGetLaunchDataSize(
OUT LPDWORD pdwLaunchDataSize
);
XBOXAPI
DWORD
WINAPI
XGetLaunchData(
OUT PVOID pBuffer,
IN DWORD dwBufferSize
);
DECLSPEC_NORETURN
XBOXAPI
VOID
WINAPI
XLaunchNewImage(
IN LPCSTR szImagePath,
IN DWORD dwFlags
);
// XLaunchNewImage keyword constants.
// Titles depend on these strings staying the same.
#define XLAUNCH_KEYWORD_DETECT_MEDIA "XLNI_DET_MEDIA"
#define XLAUNCH_FLAG_FROM_MEMORY 0x00000001
#define XLAUNCH_FLAG_DETECT_MEDIA 0x00000002
#define XLAUNCH_FLAG_NO_ABSOLUTE_PATHS 0x00000004
#define XLAUNCH_FLAG_NO_PACKAGES 0x00000008
#define XLAUNCH_FLAG_UNLOAD_HUD 0x00000010
#define XLAUNCH_FLAG_BOUND_PATH 0x00000020
#define XLAUNCH_FLAG_SYSTEM_VERSION 0x00000040
#define XLAUNCH_FLAG_ASSUME_DVD 0x00000080
#define XLAUNCH_FLAG_DASH_ARCADE 0x00000100
#define XLAUNCH_FLAG_HYBRID_FORCE_DVD 0x00000200
#define XLAUNCH_FLAG_HYBRID_FORCE_GAME 0x00000400
#define XLAUNCH_FLAG_HYBRID_NO_NOTIFY 0x00000800
#define XTRAY_STATE_CLOSED 0
#define XTRAY_STATE_CLOSING 1
#define XTRAY_STATE_OPEN 2
#define XTRAY_STATE_OPENING 3
#define XTRAY_STATE_READING 4
XBOXAPI
DWORD
WINAPI
XGetTrayState(
VOID
);
XBOXAPI
HRESULT
WINAPI
XLaunchMedia(
VOID
);
XBOXAPI
VOID
WINAPI
XLaunchNewImageEx(
IN LPCSTR szImagePath,
IN LPCSTR szDDrivePath,
IN LPCSTR szCmdLine,
IN DWORD dwFlags
);
typedef struct _XSWAPDISC_RESULTS
{
DWORD dwNewDiscNumber;
} XSWAPDISC_RESULTS, *PXSWAPDISC_RESULTS;
XBOXAPI
DWORD
WINAPI
XSwapDiscAndLaunchNewImage(
IN LPCWSTR wszDiscName,
IN DWORD dwDiscNumber,
IN LPCSTR szImagePath,
IN DWORD dwFlags,
OUT PXSWAPDISC_RESULTS pResults OPTIONAL,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
//
// Register or deregister a notification routine
// which will be called when a thread is created or deleted.
//
// NOTE: The XTHREAD_NOTIFICATION structure must remain
// valid until the thread notification routine is deregistered.
// For example, you can use a global variable for this.
// But you should NOT use a local variable inside a function.
//
DWORD
WINAPI
XGetFilePhysicalSortKey(
IN HANDLE hFile
);
VOID
WINAPI
XSetProcessHeap(
IN HANDLE hHeap
);
#define XCALCSIG_SIGNATURE_SIZE 20
typedef union {
BYTE Signature[XCALCSIG_SIGNATURE_SIZE];
BYTE LiveSignature[XCALCSIG_LIVE_SIGNATURE_SIZE];
} XCALCSIG_SIGNATURE, *PXCALCSIG_SIGNATURE;
#define XCALCSIG_FLAG_SAVE_GAME (0x00000000)
#define XCALCSIG_FLAG_NON_ROAMABLE (0x00000001)
#define XCALCSIG_FLAG_CONTENT (0x00000002)
#define XCALCSIG_FLAG_DIGEST (0x00000004)
#define XCALCSIG_FLAG_ONLINE (0x00000008)
XBOXAPI
HANDLE
WINAPI
XCalculateSignatureBegin(
IN DWORD dwFlags
);
XBOXAPI
HANDLE
WINAPI
XCalculateSignatureBeginEx(
IN DWORD dwFlags,
IN DWORD dwAltTitleId
);
XBOXAPI
DWORD
WINAPI
XCalculateSignatureUpdate(
IN HANDLE hCalcSig,
IN CONST BYTE* pbData,
IN ULONG cbData
);
XBOXAPI
DWORD
WINAPI
XCalculateSignatureEnd(
IN HANDLE hCalcSig,
OUT PXCALCSIG_SIGNATURE pSignature
);
XBOXAPI
ULONG
WINAPI
XAutoPowerDownTimeRemaining(
VOID
);
typedef VOID (*FLASH_PROGRESS_ROUTINE)(ULONG BytesWritten);
XBOXAPI
DWORD
WINAPI
XapiFlashKernelImage(
IN PVOID ImageBuffer,
IN SIZE_T ImageSize,
IN BOOL IgnoreVersionChecking,
IN BOOL ForceStockImage,
IN FLASH_PROGRESS_ROUTINE ProgressRoutine OPTIONAL
);
XBOXAPI
BOOL
WINAPI
XapiReplaceRootDirectoryFile(
IN HANDLE hVolume,
IN LPCSTR szReplacedFileName,
IN LPCSTR szReplacementFileName,
IN BOOL fCleanupMode
);
// XOVERLAPPED::InternalLow is a Win32 error code. If the operation is pending
// the value is ERROR_IO_PENDING, else it is the result of the operation.
#define XCONTENTTYPE_NONE 0x00000000
#define XCONTENTTYPE_PROFILE 0x00010000
#define XCONTENTTYPE_GAMERPICTURE 0x00020000
#define XCONTENTTYPE_THEMATICSKIN 0x00030000
#define XCONTENTTYPE_CACHE 0x00040000
#define XCONTENTTYPE_STORAGEDOWNLOAD 0x00050000
#define XCONTENTTYPE_XBOXSAVEDGAME 0x00060000
#define XCONTENTTYPE_XBOXDOWNLOAD 0x00070000
#define XCONTENTTYPE_GAMEDEMO 0x00080000
#define XCONTENTTYPE_VIDEO 0x00090000
#define XCONTENTTYPE_GAMETITLE 0x000A0000
#define XCONTENTTYPE_INSTALLER 0x000B0000
#define XCONTENTTYPE_GAMETRAILER 0x000C0000
#define XCONTENTTYPE_ARCADE 0x000D0000
#define XCONTENTTYPE_PRIVATEMASK 0xFFFF0000
#define XCONTENTTYPE_PUBLICMASK 0x0000FFFF
#define XCONTENTTYPE_VALID (XCONTENTTYPE_PRIVATEMASK | XCONTENTTYPE_PUBLICMASK)
#define XCONTENTTYPE_ANY XCONTENTTYPE_VALID
#define _XCONTENTFLAG_CREATIONMASK_ 0x0000000F
#define XCONTENTFLAG_DISALLOWSOURCEDEVICESELECTION 0x00000400
#define XCONTENTFLAG_EXECUTE 0x04000000
// Private enumeration scoping
#define XCONTENTFLAG_OWNER 0x10000000
#define XCONTENTFLAG_TITLE 0x20000000
#define XCONTENTFLAG_TYPE 0x40000000
#define XCONTENTFLAG_ENUM_SCOPING_MASK (XCONTENTFLAG_ENUM_EXCLUDECOMMON | \
XCONTENTFLAG_OWNER | \
XCONTENTFLAG_TITLE | \
XCONTENTFLAG_TYPE)
#define XCONTENTFLAGS_VALID (XCONTENTFLAG_NONE | \
XCONTENTFLAG_CREATENEW | \
XCONTENTFLAG_CREATEALWAYS | \
XCONTENTFLAG_OPENEXISTING | \
XCONTENTFLAG_OPENALWAYS | \
XCONTENTFLAG_TRUNCATEEXISTING | \
XCONTENTFLAG_NOPROFILE_TRANSFER | \
XCONTENTFLAG_STRONG_SIGNED | \
XCONTENTFLAG_NODEVICE_TRANSFER | \
XCONTENTFLAG_MANAGESTORAGE | \
XCONTENTFLAG_FORCE_SHOW_UI | \
XCONTENTFLAG_DISALLOWSOURCEDEVICESELECTION | \
XCONTENTFLAG_ENUM_EXCLUDECOMMON | \
XCONTENTFLAG_EXECUTE | \
XCONTENTFLAG_OWNER | \
XCONTENTFLAG_TITLE | \
XCONTENTFLAG_TYPE)
#ifdef __cplusplus
typedef struct _XCONTENT_DATA_INTERNAL : public XCONTENT_DATA {
#else // __cplusplus
typedef struct _XCONTENT_DATA_INTERNAL {
XCONTENT_DATA;
#endif // !__cplusplus
XUID xuid;
DWORD dwTitleId;
} XCONTENT_DATA_INTERNAL, *PXCONTENT_DATA_INTERNAL;
#define XCONTENTDEVICETYPE_NONE ((XCONTENTDEVICETYPE)0)
#define XCONTENTDEVICETYPE_SYSTEMMU ((XCONTENTDEVICETYPE)3)
#define XCONTENTDEVICETYPE_USBMASS ((XCONTENTDEVICETYPE)16)
#define XCONTENTDEVICETYPE_MASK 0xF
//
// This flag is OR'd into a device type if the device is unformatted
//
#define XCONTENTDEVICEFLAG_UNFORMATTED ((XCONTENTDEVICETYPE)0x80000000)
//
// This flag can be supplied to XContentCreateDeviceEnumerator to enumerate
// USB mass storage devices
//
#define XCONTENTDEVICEFLAG_USBMASS (0x40000000)
typedef struct _XCREATECONTENTPARAM
{
DWORD dwUserIndex;
CHAR szRootName[64];
union
{
XCONTENT_DATA cd;
XCONTENT_DATA_INTERNAL cdi;
};
DWORD dwContentFlags;
PDWORD pdwDisposition;
PDWORD pdwLicenseMask;
DWORD dwFileCacheSize;
ULARGE_INTEGER uliContentSize;
PXOVERLAPPED pOverlapped;
DWORD cbContentData;
} XCREATECONTENTPARAM, *PXCREATECONTENTPARAM;
typedef PVOID HXAMAPP;
#define XENUMHEADERFLAG_NONE 0x00000000
#define XENUMHEADERFLAG_FOREGROUND_PRI 0x00000001
typedef struct _XENUMERATORHEADER
{
HXAMAPP hxamapp;
DWORD dwMsgIDEnum;
DWORD dwMsgIDCloseEnum;
DWORD dwUserIndex;
DWORD cItemsRequested;
DWORD dwEnumFlags;
} XENUMERATORHEADER, *PXENUMERATORHEADER;
DWORD
WINAPI
XContentCreateDeviceEnumerator(
IN DWORD dwContentTypes,
IN DWORD dwFlags,
IN DWORD cItem,
OUT PDWORD pcbBuffer OPTIONAL,
OUT PHANDLE phEnum
);
DWORD
WINAPI
XContentFormatDevice(
IN XCONTENTDEVICEID DeviceID,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
);
DWORD
WINAPI
XContentRenameDevice(
IN XCONTENTDEVICEID DeviceID,
IN LPCWSTR pwszName,
IN DWORD cchName
);
typedef struct _XENUMERATEPARAM
{
DWORD dwUserIndex;
DWORD dwFlags;
PVOID pvPrivateEnumStructure;
PVOID pvBuffer;
DWORD cbBuffer;
DWORD cItemsRequested;
PDWORD pcItemsReturned;
PXOVERLAPPED pxoverlapped;
} XENUMERATEPARAM;
// Enumeration flags
#define ENUMERATEFLAG_NONE 0x00000000
#define ENUMERATEFLAG_BACK 0x00000001
#define ENUMERATEFLAG_FOREGROUND 0x00000002
#define ENUMERATEFLAG_MATCHINGINSTANCE 0x00000004
#define ENUMERATEFLAG_INCLUDEPARTIALDOWNLOADS 0x00000008
#define ENUMERATEFLAG_INCLUDECORRUPTCONTENT 0x00000010
//-----------------------------------------------------------------------------
// Private Game Instrumentation structures and functions
//-----------------------------------------------------------------------------
typedef struct
{
DWORD dwUserIndex;
XUID xuid;
DWORD dwContextId;
DWORD dwContextValue;
} XGI_USERSETCONTEXT_MSG, *PXGI_USERSETCONTEXT_MSG;
typedef struct
{
DWORD dwUserIndex;
XUID xuid;
DWORD dwPropertyId;
DWORD cbValue;
CONST VOID* pvValue;
} XGI_USERSETPROPERTY_MSG;
// General enumererator structure for XGI title and achievement enumerations
typedef struct _XENUMERATOR_XGI
{
DWORD dwTitleId;
XUID xuid;
DWORD dwUserIndex;
DWORD dwDetailFlags;
DWORD dwCurrentOffset;
BOOL fServer;
} XENUMERATOR_XGI, *PXENUMERATOR_XGI;
typedef struct _XGI_CREATEENUM_MSG
{
DWORD dwTitleId; // A title in your family or 0 for the current title
DWORD dwUserIndex; // User index of locally signed-in user whose "things" are enumerated
XUID xuid; // XUID of remote user whose "things" are enumerated
DWORD dwDetailFlags; // Get the descriptions, etc. (used for achievements)
DWORD dwStartingIndex; // Number to start at
PXENUMERATOR_XGI pxenum;
} XGI_CREATEENUM_MSG, *PXGI_CREATEENUM_MSG;
// Message passed to system app to write an achievement
typedef struct
{
DWORD dwNumAchievements; // Number of structs in pAchievements
CONST XUSER_ACHIEVEMENT* pAchievements; // Achievement/user tuple to set
} XGI_WRITEACHIEVEMENT_MSG;
//-----------------------------------------------------------------------------
// Internal functions
//-----------------------------------------------------------------------------
DWORD XVerifySameFamily(DWORD dwTitleId);
//
// Internal only privileges
//
#define XPRIVILEGE_ADD_FRIEND 255 // on|off
#define XPRIVILEGE_MULTIPLAYER_ENABLED_BY_TIER 253 // on|off
#define XPRIVILEGE_VIDEO_MESSAGING_SEND 250 // on|off
#define XPRIVILEGE_XBOX1_LIVE_ACCESS 242 // on|off
#define X_PROPERTY_MODIFIER_MASK 0x0F000000
#define X_PROPERTY_MATCHTYPE_MASK 0x00F00000
#define X_PROPERTY_RESERVED_MASK 0x000F0000
// These must match the X_ATTRIBUTE_TYPE_MASK value defines
#define X_PROPERTY_MODIFIER_PARAM 0x02000000
#define X_PROPERTY_MODIFIER_BUILTIN 0x03000000
#define X_PROPERTY_MODIFIER_CONSTANT 0x05000000
// These must match the X_ATTRIBUTE_DATATYPE_MASK value defines
#define X_PROPERTY_MATCHTYPE_INTEGER 0x00000000
#define X_PROPERTY_MATCHTYPE_STRING 0x00100000
#define X_PROPERTY_MATCHTYPE_BLOB 0x00200000
#define X_PROPERTY_MATCHTYPE_NULL 0x00F00000
// Picture keys are in the format of XXXXXXXXXYYYYYYYYZZZZZZZZ
// where
// XXXXXXXX is the title id associated with the picture (in hex)
// YYYYYYYY is the normal picture image id (in hex)
// ZZZZZZZZ is the small picture image id (in hex)
//
#define XUSER_PICTURE_KEY_LEN ((sizeof(DWORD) * 2) * 3)
// Add room for a terminating null
#define XUSER_PICTURE_KEY_CHARS (XUSER_PICTURE_KEY_LEN + 1)
// Stats APIs
//-----------------------------------------------------------------------------
// Private stats structures and functions
//-----------------------------------------------------------------------------
typedef struct _XGI_VIEWRESET_MSG
{
DWORD dwUserIndex;
DWORD dwViewId;
} XGI_VIEWRESET_MSG, *PXGI_VIEWRESET_MSG;
typedef struct _XGI_STATSREAD_MSG
{
DWORD dwTitleId;
DWORD dwNumXuids;
CONST XUID* pXuids;
DWORD dwNumStatsSpecs;
CONST XUSER_STATS_SPEC* pSpecs;
DWORD cbResults;
PXUSER_STATS_READ_RESULTS pResults;
} XGI_STATSREAD_MSG, *PXGI_STATSREAD_MSG;
typedef struct _XGI_STATSENUM_MSG
{
DWORD dwTitleId;
DWORD dwRankStart;
DWORD dwNumRows;
DWORD dwNumStatsSpecs;
CONST XUSER_STATS_SPEC* pSpecs;
DWORD cbBuffer;
PHANDLE ph; // Handle to created enumerator
} XGI_STATSENUM_MSG, *PXGI_STATSENUM_MSG;
typedef enum _XGI_STATS_ENUMERATOR_TYPE
{
XGI_STATS_ENUM_BY_XUID,
XGI_STATS_ENUM_BY_RANK,
XGI_STATS_ENUM_BY_RANK_PER_SPEC,
XGI_STATS_ENUM_BY_RATING
} XGI_STATS_ENUMERATOR_TYPE;
// Data held by each stats enumerator.
typedef struct _XENUMERATOR_STATS
{
DWORD dwTitleId;
XGI_STATS_ENUMERATOR_TYPE enumType;
ULONGLONG qwPivot;
PDWORD pStaringRanks;
DWORD dwNumStatsSpecs;
PXUSER_STATS_SPEC pSpecs;
} XENUMERATOR_STATS, *PXENUMERATOR_STATS;
typedef struct _XGI_CREATESTATSENUM_MSG
{
DWORD dwTitleId;
PXENUMERATOR_STATS pStatsEnum;
} XGI_CREATESTATSENUM_MSG, *PXGI_CREATESTATSENUM_MSG;
// Signin UI API
#define XSSUI_FLAGS_ADDUSER 0x00010000
#define XSSUI_FLAGS_COMPLETESIGNIN 0x00020000
#define XSSUI_FLAGS_SHOWONLYPARENTALLYCONTROLLED 0x00040000
#define XSSUI_FLAGS_ENABLE_GUEST 0x00080000
#define XSSUI_FLAGS_DISALLOWRELOAD 0x00100000
#define XSSUI_FLAGS_VALID (XSSUI_FLAGS_SHOWONLYONLINEENABLED | \
XSSUI_FLAGS_LOCALSIGNINONLY | \
XSSUI_FLAGS_ADDUSER | \
XSSUI_FLAGS_COMPLETESIGNIN | \
XSSUI_FLAGS_SHOWONLYPARENTALLYCONTROLLED | \
XSSUI_FLAGS_ENABLE_GUEST | \
XSSUI_FLAGS_DISALLOWRELOAD)
XBOXAPI
DWORD
WINAPI
XShowSigninUIp(
IN DWORD dwUserIndex,
IN DWORD cPanes,
IN DWORD dwFlags
);
typedef enum _XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINTS {
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_ADDPOINTS = XSHOWMARKETPLACEUI_ENTRYPOINT_MAX,
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_PREPAIDCODE,
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_FNC,
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_GAMERTAGPURCHASE,
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_SIGNUP_CREDITCARD,
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_SIGNUP_PARENTCREDITCARD,
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_FILTERED_CONTENTLIST,
XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINT_MAX
} XSHOWMARKETPLACEUI_PRIVATE_ENTRYPOINTS;
#define XMB_ICONMASK 0x00000003
#define XMB_WAITANIMATION 0x00001000
#define XMB_LIVEPASSCODEMODE 0x00030000
#define XMB_MODEMASK 0x00030000
#define MAXACTIONTEXTLENGTH 30
#define MAXACTIONS 3
XBOXAPI
VOID
WINAPI
XCustomGetActionSetting(
IN DWORD dwActionIndex,
OUT DWORD* pdwFlags,
OUT LPWSTR szActionText,
IN DWORD cchMaxText
);
XBOXAPI
VOID
WINAPI
XCustomBroadcastActionEvent(
IN DWORD dwUserIndex,
IN DWORD dwActionIndex,
IN XUID xuid
);
#ifndef HXUIBRUSH
typedef struct _XUIBRUSH* HXUIBRUSH;
#endif
HRESULT
WINAPI
XCustomGetBannerImage(
OUT HXUIBRUSH* phBrush
);
#ifdef __cplusplus
}
#endif
#pragma warning(pop)
#endif // _XBOXP_

362
xbdm/imp/xcabinet.h Normal file
View File

@@ -0,0 +1,362 @@
// ---------------------------------------------------------------------------------------
// xcabinet.h
//
// Copyright (C) Microsoft Corporation
// ---------------------------------------------------------------------------------------
#ifndef __XCABINET_H__
#define __XCABINET_H__
// ---------------------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------------------
#ifdef __cplusplus
extern "C" {
#endif
#include "xecrypt.h"
#include "cabinet.h"
#ifdef __cplusplus
}
#endif
#pragma pack(push, 1)
// ---------------------------------------------------------------------------------------
//
// Define the real RC4 SHA1 structures and functions
//
#define RC4_CONFOUNDER_LEN 8
typedef struct _RC4_SHA_HEADER {
BYTE Checksum[XECRYPT_SHA_DIGEST_SIZE];
BYTE Confounder[RC4_CONFOUNDER_LEN];
} RC4_SHA_HEADER, *PRC4_SHA_HEADER;
//
// Define a structure that describes an extended CFFOLDER entry
// that also has an associated HMAC (per-folder reserved data)
//
typedef struct
{
CFFOLDER cffolder; // CFFOLDER
RC4_SHA_HEADER hmac; // RC4 SHA1 Hmac
} CFFOLDER_HMAC, *PCFFOLDER_HMAC;
//
// Define a union of all known CAB flags
//
#define cfhdrFLAGS_ALL (cfhdrPREV_CABINET | \
cfhdrNEXT_CABINET | \
cfhdrRESERVE_PRESENT)
//
// Define our header cache structure
//
typedef struct
{
CFHEADER cfheader; // Cabinet file header
CFRESERVE cfreserve; // Reserved data specification
RC4_SHA_HEADER digestFolders; // CFFOLDERS digest
RC4_SHA_HEADER digestFiles; // CFFILES digest
} XONLINECONTENT_HEADER, *PXONLINECONTENT_HEADER;
//
// Define sizes related to the fixed header
//
#define XONLINECONTENT_FIXED_HEADER_SIZE \
(sizeof(XONLINECONTENT_HEADER))
#define XONLINECONTENT_FIXED_HEADER_SIZE_WITH_HMAC \
(XONLINECONTENT_FIXED_HEADER_SIZE + \
sizeof(RC4_SHA_HEADER))
#define XONLINECONTENT_FIXED_HEADER_SIZE_WITH_HMAC_AND_CHECKPOINT \
(XONLINECONTENT_FIXED_HEADER_SIZE + \
sizeof(RC4_SHA_HEADER) + sizeof(DWORD))
#define XONLINECONTENT_COMPLETE_HEADER_SIZE \
(XONLINECONTENT_FIXED_HEADER_SIZE_WITH_HMAC_AND_CHECKPOINT + \
XONLINECONTENT_PK_SIGNATURE_SIZE)
#define XONLINECONTENT_CHECKPOINT \
(XONLINECONTENT_FIXED_HEADER_SIZE + \
sizeof(RC4_SHA_HEADER))
//
// Define the maximum number of CFFOLDER entries allowed in a content package.
//
#define XONLINECONTENT_MAX_CFFOLDER ((DWORD)100)
//
// Define a threshold size for the minimum folder size to justify the
// additional folder overhead.
//
#define XONLINECONTENT_MIN_FOLDER_SIZE ((DWORD)(5 * 1024)) // 5KB
//
// Define the "attribute" flag to indicate that the current folder is a
// continuation from the same file in the previous folder.
//
#define XONLINECONTENT_FOLDER_CONTINUATION ((WORD)0x8000)
//
// Define the minimum size for a CFFILE entry (+ 2 == one character name + NULL
// terminator).
//
#define XONLINECONTENT_MIN_CFFILE_SIZE ((DWORD)(sizeof(CFFILE) + 2))
//
// Define the maximum number of CFFILE entries allowed in a content package.
//
#define XONLINECONTENT_MAX_CFFILE ((DWORD)1000000)
C_ASSERT(XONLINECONTENT_MAX_CFFILE <= (0xFFFFFFFF / XONLINECONTENT_MIN_CFFILE_SIZE));
//
// Define the size of a PK signature.
//
#define XONLINECONTENT_PK_SIGNATURE_SIZE 256
#ifndef BSAFE_PUB_KEY
//
// BUGBUG:
//
// BSAFE_PUB_KEY not defined in XeCrypt yet, so we define it here
//
typedef struct {
DWORD magic; /* Should always be RSA1 */
DWORD keylen; // size of modulus buffer
DWORD bitlen; // # of bits in modulus
DWORD datalen; // max number of bytes to be encoded
DWORD pubexp; //public exponent
} BSAFE_PUB_KEY, FAR *LPBSAFE_PUB_KEY;
#endif
//
// Define the max size of a public key
//
#define XONLINECONTENT_MAX_PUBLIC_KEY_SIZE \
(XONLINECONTENT_PK_SIGNATURE_SIZE + \
sizeof(BSAFE_PUB_KEY) + \
(sizeof(DWORD) * 4))
//
// Define the various reserve values
//
#define XONLINECONTENT_HEADER_RESERVE_SIZE \
((sizeof(RC4_SHA_HEADER) * 3) + sizeof(DWORD) + \
XONLINECONTENT_PK_SIGNATURE_SIZE)
#define XONLINECONTENT_PERFOLDER_RESERVE_SIZE \
(sizeof(RC4_SHA_HEADER))
//
// Define the smallest possible size for a content package
//
#define XONLINECONTENT_MIN_CONTENT_SIZE \
(sizeof(CFHEADER) + sizeof(CFRESERVE) + \
XONLINECONTENT_HEADER_RESERVE_SIZE)
//
// Define a confounder for the version stamp
//
#define XONLINECONTENT_CHECKPOINT_CONFOUNDER ((DWORD)0x5aef320b)
//
// Define the prefix for files with special installation meaning
//
#define XINSTALLER_SPECIAL_NAME_PREFIX "$install_"
//
// Define the fixed name of the package within the CAB
//
#define XINSTALLER_PACKAGE_FILE_NAME "$package"
//
// Define the installation extender prefix and suffix
//
#define XINSTALLER_EXTENDER_FILE_NAME_PREFIX XINSTALLER_SPECIAL_NAME_PREFIX
#define XINSTALLER_EXTENDER_FILE_NAME_SUFFIX ".xex"
//
// We deal with clusters a lot, so define the size of a cluster
//
#define XBOX_CLUSTER_SIZE (1 << 14)
// ---------------------------------------------------------------------------------------
typedef enum _XONLINECONTENT_RESUME_STATE
{
XONLINECONTENT_RESUME_STATE_FILE_HEADERS_NOT_READY = 'FILH',
XONLINECONTENT_RESUME_STATE_NEW_FOLDER = 'FOLD',
XONLINECONTENT_RESUME_STATE_NEW_FOLDER_RESUME_ATTEMPT_2 = 'FOL2',
XONLINECONTENT_RESUME_STATE_NEW_FOLDER_RESUME_ATTEMPT_3 = 'FOL3',
} XONLINECONTENT_RESUME_STATE;
typedef struct _XONLINECONTENT_RESUME_HEADER {
//
// Resume state identifier.
//
XONLINECONTENT_RESUME_STATE ResumeState;
//
// Index of current file being downloaded/processed.
//
DWORD dwCurrentFileIndex;
//
// Offset into current file being downloaded/processed.
//
LARGE_INTEGER liCurrentFileOffset;
//
// Number of bytes successfully downloaded/processed.
//
LARGE_INTEGER liBytesProcessed;
//
// Last-modified timestamp for resuming download/processing.
//
LARGE_INTEGER liLastModified;
} XONLINECONTENT_RESUME_HEADER;
#define XONLINECONTENT_MAX_SINGLE_FILE_RESUME_DATA_SIZE \
(XONLINECONTENT_COMPLETE_HEADER_SIZE + \
(XONLINECONTENT_MAX_CFFOLDER * sizeof(CFFOLDER_HMAC)) + \
(XONLINECONTENT_MAX_CFFOLDER * sizeof(CFFILE)))
// ---------------------------------------------------------------------------------------
//
// Content delivery
//
//
// The CFFILE structure has a WORD field for the file time which
// we will hijack for our special flags. Xbox content will use thie
// field to indicate special options instead of the file time.
// The following bits are defined for the time field, and honored
// by the content installation API.
//
// This flag indicates that the file should be copied to the
// user partition rather than the title area
#define XONLINECONTENT_A_USER_DATA (0x0001)
// This flag indicates that this file is a continuation of
// a file in the previous folder. The data in this file should
// be appended to the previous file. This file must be the first
// file in the folder.
#define XONLINECONTENT_A_CONTINUED_FROM_PREV (0x0002)
// This flag indicates that this file will be continued into the
// next folder. The data in the next folder should be appended to
// this file. This file must be the last file in the folder.
#define XONLINECONTENT_A_CONTINUED_INTO_NEXT (0x0004)
//
// Define the size of the download buffer. This cannot be
// less than XONLINECONTENT_LZX_OUTPUT_SIZE
//
#define XONLINECONTENT_DL_BUFFER_SIZE (1024 * 64)
//
// Define the LZX decoder history window size, this should be no
// less than 32k (ROM decompressor uses 128k)
//
#define XONLINECONTENT_LZX_WINDOW_SIZE CHUNK_SIZE
//
// Define the output buffer for decompress. This must not be
// less than 32k
//#define XONLINECONTENT_LZX_OUTPUT_SIZE \
// ((CHUNK_SIZE) + XBOX_HD_SECTOR_SIZE)
#define XONLINECONTENT_LZX_OUTPUT_SIZE \
(CHUNK_SIZE)
//
// TODO: From \public\i386\sdk\inc\fdi.h. Need byte reversal?
//
/*** tcompXXX - Diamond compression types
*
* These are passed to FCIAddFile(), and are also stored in the CFFOLDER
* structures in cabinet files.
*
* NOTE: We reserve bits for the TYPE, QUANTUM_LEVEL, and QUANTUM_MEM
* to provide room for future expansion. Since this value is stored
* in the CFDATA records in the cabinet file, we don't want to
* have to change the format for existing compression configurations
* if we add new ones in the future. This will allows us to read
* old cabinet files in the future.
*/
typedef unsigned short TCOMP; /* tcomp */
#define tcompMASK_TYPE 0x000F // Mask for compression type
#define tcompTYPE_NONE 0x0000 // No compression
#define tcompTYPE_MSZIP 0x0001 // MSZIP
#define tcompTYPE_QUANTUM 0x0002 // Quantum
#define tcompTYPE_LZX 0x0003 // LZX
#define tcompBAD 0x000F // Unspecified compression type
#define tcompMASK_LZX_WINDOW 0x1F00 // Mask for LZX Compression Memory
#define tcompLZX_WINDOW_LO 0x0F00 // Lowest LZX Memory (15)
#define tcompLZX_WINDOW_HI 0x1500 // Highest LZX Memory (21)
#define tcompSHIFT_LZX_WINDOW 8 // Amount to shift over to get int
#define tcompMASK_QUANTUM_LEVEL 0x00F0 // Mask for Quantum Compression Level
#define tcompQUANTUM_LEVEL_LO 0x0010 // Lowest Quantum Level (1)
#define tcompQUANTUM_LEVEL_HI 0x0070 // Highest Quantum Level (7)
#define tcompSHIFT_QUANTUM_LEVEL 4 // Amount to shift over to get int
#define tcompMASK_QUANTUM_MEM 0x1F00 // Mask for Quantum Compression Memory
#define tcompQUANTUM_MEM_LO 0x0A00 // Lowest Quantum Memory (10)
#define tcompQUANTUM_MEM_HI 0x1500 // Highest Quantum Memory (21)
#define tcompSHIFT_QUANTUM_MEM 8 // Amount to shift over to get int
#define tcompMASK_RESERVED 0xE000 // Reserved bits (high 3 bits)
#define CompressionTypeFromTCOMP(tc) \
((tc) & tcompMASK_TYPE)
#define CompressionLevelFromTCOMP(tc) \
(((tc) & tcompMASK_QUANTUM_LEVEL) >> tcompSHIFT_QUANTUM_LEVEL)
#define CompressionMemoryFromTCOMP(tc) \
(((tc) & tcompMASK_QUANTUM_MEM) >> tcompSHIFT_QUANTUM_MEM)
#define TCOMPfromTypeLevelMemory(t,l,m) \
(((m) << tcompSHIFT_QUANTUM_MEM ) | \
((l) << tcompSHIFT_QUANTUM_LEVEL) | \
( t ))
#define LZXCompressionWindowFromTCOMP(tc) \
(((tc) & tcompMASK_LZX_WINDOW) >> tcompSHIFT_LZX_WINDOW)
#define TCOMPfromLZXWindow(w) \
(((w) << tcompSHIFT_LZX_WINDOW ) | \
( tcompTYPE_LZX ))
#pragma pack(pop)
#endif // ! defined __XCABINET_H__

266
xbdm/imp/xdbg.h Normal file
View File

@@ -0,0 +1,266 @@
/*++
Copyright (c) 1989-2000 Microsoft Corporation
Module Name:
xdbg.h
Abstract:
Internal debug header for XBox OS and library components
--*/
#ifndef _XDBG_H
#define _XDBG_H
#ifdef _DEBUG
#define DBG 1
#endif
#ifndef ASSERT
#if DBG
#define ASSERT( exp ) \
if (!(exp)) \
RtlAssert( #exp, __FILE__, __LINE__, NULL )
#else // DBG
#define ASSERT( exp )
#endif // DBG
#endif // ! ASSERT
#ifndef ASSERTMSG
#if DBG
#define ASSERTMSG( msg, exp ) \
if (!(exp)) \
RtlAssert( #exp, __FILE__, __LINE__, msg )
#else // DBG
#define ASSERTMSG( msg, exp )
#endif // DBG
#endif // ! ASSERTMSG
#if 0
#ifndef RIP
#if DBG
#define RIP(msg) \
do{ LPCSTR _ = (msg); \
_asm { mov eax, BREAKPOINT_RIP } \
_asm { mov ecx, _ } \
_asm { int 2dh } \
_asm { int 3 } \
} while(0)
#else // DBG
#define RIP(msg) {}
#endif // DBG
#endif // ! RIP
#ifndef RIP_ON_NOT_TRUE
#if DBG
#define RIP_ON_NOT_TRUE(ApiName, Expression) \
do{ \
if(!(Expression)) \
{ \
UCHAR _[512]; \
_snprintf(_, sizeof(_), "%s: parameter check failed. (%s) was not true.\n", ApiName, #Expression);\
_[511]='\0'; \
_asm { mov eax, BREAKPOINT_RIP } \
_asm { mov ecx, _ } \
_asm { int 2dh } \
_asm { int 3 } \
} \
}while(0)
#else // DBG
#define RIP_ON_NOT_TRUE(ApiName, Expression)
#endif // DBG
#endif // !RIP_ON_NOT_TRUE
#ifndef RIP_ON_NOT_TRUE_WITH_MESSAGE
#if DBG
#define RIP_ON_NOT_TRUE_WITH_MESSAGE(Expression, Message) \
do{ \
if(!(Expression)) \
{ \
RIP(Message); \
} \
}while(0)
#else // DBG
#define RIP_ON_NOT_TRUE_WITH_MESSAGE(Expression, Message)
#endif // DBG
#endif // !RIP_ON_NOT_TRUE_WITH_MESSAGE
#endif // 0
#define XDBG_ERROR 1
#define XDBG_WARNING 2
#define XDBG_TRACE 3
#define XDBG_ENTRY 4
#define XDBG_EXIT 5
#ifndef XDBG_COMPILE_LEVEL
#define XDBG_COMPILE_LEVEL XDBG_WARNING
#endif // ! XDBG_COMPILE_LEVEL
#ifndef XDBGPRINT
#if DBG
#define XDBGPRINT RtlDebugPrint
#else // DBG
#define XDBGPRINT 1 ? (void)0 : (void)
#endif // DBG
#endif // ! XDBGPRINT
#ifndef XDBGERR
#if DBG && (XDBG_COMPILE_LEVEL >= XDBG_ERROR)
#define XDBGERR RtlDebugError
#else // DBG
#define XDBGERR 1 ? (void)0 : (void)
#endif // DBG
#endif // ! XDBGERR
#ifndef XDBGWRN
#if DBG && (XDBG_COMPILE_LEVEL >= XDBG_WARNING)
#define XDBGWRN RtlDebugWarning
#else // DBG
#define XDBGWRN 1 ? (void)0 : (void)
#endif // DBG
#endif // ! XDBGWRN
#ifndef XDBGTRC
#if DBG && (XDBG_COMPILE_LEVEL >= XDBG_TRACE)
#define XDBGTRC RtlDebugTrace
#else // DBG
#define XDBGTRC 1 ? (void)0 : (void)
#endif // DBG
#endif // ! XDBGTRC
#ifndef XDBGENT
#if DBG && (XDBG_COMPILE_LEVEL >= XDBG_ENTRY)
#define XDBGENT RtlDebugEntry
#else // DBG
#define XDBGENT 1 ? (void)0 : (void)
#endif // DBG
#endif // ! XDBGENT
#ifndef XDBGEXT
#if DBG && (XDBG_COMPILE_LEVEL >= XDBG_EXIT)
#define XDBGEXT RtlDebugExit
#else // DBG
#define XDBGEXT 1 ? (void)0 : (void)
#endif // DBG
#endif // ! XDBGEXT
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _NTSYSTEM_
#define XKERNELAPI
#else // _NTSYSTEM_
#define XKERNELAPI DECLSPEC_IMPORT
#endif // _NTSYSTEM_
#if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
#define XDBGAPI __stdcall
#define XDBGAPIV __cdecl
#else
#define XDBGAPI
#define XDBGAPIV
#endif
XKERNELAPI
VOID
XDBGAPI
RtlAssert(
LPCSTR FailedAssertion,
LPCSTR FileName,
ULONG LineNumber,
PCHAR Message
);
ULONG
_cdecl
DbgPrint(
PCH Format,
...
);
VOID
RtlDebugError(const CHAR* Module,
const CHAR* Format,
...
);
VOID
_cdecl
RtlDebugWarning(const CHAR* Module,
const CHAR* Format,
...
);
VOID
_cdecl
RtlDebugTrace(const CHAR* Module,
const CHAR* Format,
...
);
VOID
_cdecl
RtlDebugEntry(const CHAR* Module,
const CHAR* Format,
...
);
VOID
_cdecl
RtlDebugExit(const CHAR* Module,
const CHAR* Format,
...
);
VOID
_cdecl
RtlDebugPrint(ULONG Level,
const CHAR* Module,
const CHAR* Format,
...
);
int
_cdecl
RtlSprintf( CHAR *Buffer,
const CHAR *Format,
...
);
int
_cdecl
RtlSnprintf(CHAR *Buffer,
int SizeInBytes,
const CHAR *Format,
...
);
int
_cdecl
RtlVsnprintf(CHAR *Buffer,
int SizeInBytes,
const CHAR *Format,
va_list va
);
int
_cdecl
RtlVsprintf(CHAR *Buffer,
const CHAR *Format,
va_list va
);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // _XDBG_H

704
xbdm/imp/xex.h Normal file
View File

@@ -0,0 +1,704 @@
/*++
Copyright (c) 2000-2005 Microsoft Corporation
Module Name:
xex.h
Abstract:
This module contains the structures that describe the Xenon Executable (XEX)
format.
--*/
#ifndef _XEX_H_
#define _XEX_H_
#include "xexhv.h"
#pragma warning(push)
#pragma warning(disable:4201)
#define MAX_XEX_HEADERS_SIZE (64 * 1024)
typedef struct _XEX_SECURITY_INFO {
//
// The size of this header.
//
ULONG Size;
//
// Specifies the total size of the image as loaded in memory (not
// including headers).
//
ULONG ImageSize;
//
// The root of trust for this image.
//
HV_IMAGE_INFO ImageInfo;
//
// Specifies the allowed media sources for this image.
//
ULONG AllowedMediaTypes;
//
// The number of page ranges.
//
ULONG PageDescriptorCount;
//
// The individual page descriptors follow this structure.
//
} XEX_SECURITY_INFO, *PXEX_SECURITY_INFO;
//
// All valid media types from which images may be loaded.
// N.B. Any media that may be inserted through the optical disc drive should be
// added to XEX_MEDIA_TYPE_DISC_MEDIA_MASK
//
#define XEX_MEDIA_TYPE_HARD_DISK 0x00000001
#define XEX_MEDIA_TYPE_DVD_X2 0x00000002
#define XEX_MEDIA_TYPE_DVD_CD 0x00000004
#define XEX_MEDIA_TYPE_DVD_5_RO 0x00000008
#define XEX_MEDIA_TYPE_DVD_9_RO 0x00000010
#define XEX_MEDIA_TYPE_FLASH 0x00000020
#define XEX_MEDIA_TYPE_MEMORY_UNIT 0x00000080
#define XEX_MEDIA_TYPE_MASS_STORAGE 0x00000100
#define XEX_MEDIA_TYPE_NETWORK_FILESYSTEM 0x00000200
#define XEX_MEDIA_TYPE_UNKNOWN_SOURCE 0x00000400
#define XEX_MEDIA_TYPE_PACKAGE_MASK 0xFF000000
#define XEX_MEDIA_TYPE_PACKAGE(PackageType) \
(1 << ((PackageType) + 24))
#define XEX_PACKAGE_TYPE_UNKNOWN 0x00
#define XEX_PACKAGE_TYPE_ANY_CONSOLE 0x01
#define XEX_PACKAGE_TYPE_THIS_CONSOLE 0x02
#define XEX_PACKAGE_TYPE_XBOX_LIVE 0x03
#define XEX_PACKAGE_TYPE_XBOX_PLATFORM 0x04
#define XEX_NUMBER_OF_PACKAGE_TYPES 0x05
#define XEX_MEDIA_TYPE_DISC_MEDIA_MASK \
(XEX_MEDIA_TYPE_DVD_X2 | \
XEX_MEDIA_TYPE_DVD_CD | \
XEX_MEDIA_TYPE_DVD_5_RO | \
XEX_MEDIA_TYPE_DVD_9_RO)
//
// Everything in the header is stored in big-endian format.
//
typedef struct _IMAGE_XEX_HEADER {
//
// Contains XEX_HEADER_MAGIC.
//
ULONG Magic;
//
// Flags describing the load policy of this object to the loader.
//
ULONG ModuleFlags;
//
// Specifies the total size of header information, including this
// header.
//
ULONG SizeOfHeaders;
//
// Specifies the size of header information that can be discarded
// after the load is complete.
//
ULONG SizeOfDiscardableHeaders;
//
// A pointer to the security information for this module (in the file,
// this a RVA).
//
PXEX_SECURITY_INFO SecurityInfo;
//
// Specifies the number of entries in the header field directory.
//
ULONG HeaderDirectoryEntryCount;
} IMAGE_XEX_HEADER, *PIMAGE_XEX_HEADER;
#define XEX_HEADER_MAGIC 'XEX2'
//
// The type of this object. This is a union of policy bits that describe
// the way the loader will treat this module:
//
#define XEX_MODULE_FLAG_TITLE_PROCESS 0x0001
#define XEX_MODULE_FLAG_TITLE_IMPORTS 0x0002
#define XEX_MODULE_FLAG_DEBUGGER 0x0004
#define XEX_MODULE_FLAG_DLL 0x0008
#define XEX_MODULE_FLAG_PATCH 0x0010
#define XEX_MODULE_FLAG_PATCH_FULL 0x0020
#define XEX_MODULE_FLAG_PATCH_DELTA 0x0040
#define XEX_MODULE_TYPE_TITLE \
(XEX_MODULE_FLAG_TITLE_PROCESS)
#define XEX_MODULE_TYPE_TITLE_DLL \
(XEX_MODULE_FLAG_TITLE_PROCESS | XEX_MODULE_FLAG_DLL)
#define XEX_MODULE_TYPE_SYSTEM_APP \
(XEX_MODULE_FLAG_DLL)
#define XEX_MODULE_TYPE_SYSTEM_DLL \
(XEX_MODULE_FLAG_DLL | XEX_MODULE_FLAG_TITLE_IMPORTS)
#define XEX_MODULE_FLAG_BOUND_PATH 0x40000000
#define XEX_MODULE_FLAG_SILENT_LOAD 0x80000000
//
// After the header structure is a list of header directory entries. Each
// entry is an ordered pair of (key, value). The keys correspond to the types
// of header data that can be present. The upper 24 bits of the key number
// describe the type of data described (exe name, title ID, loader policy,
// whatever), and the lower 8 bits describe the size of the data in DWORDs. If
// the size is 0, there is no data; if the size is 1, the value in the header
// is the value of the data; if the size is more than 1, the value in the
// header is the file offset to the location of the data. The size 255 has a
// special meaning, indicating that the referenced data describes its own size
// in its first DWORD.
//
typedef struct _IMAGE_XEX_DIRECTORY_ENTRY {
ULONG Key;
ULONG Value;
} IMAGE_XEX_DIRECTORY_ENTRY, *PIMAGE_XEX_DIRECTORY_ENTRY;
#define XEX_HEADER_STRUCT(key, struct) \
(((key) << 8) | (sizeof (struct) >> 2))
#define XEX_HEADER_FIXED_SIZE(key, size) \
(((key) << 8) | ((size) >> 2))
#define XEX_HEADER_ULONG(key) \
(((key) << 8) | 1)
#define XEX_HEADER_FLAG(key) \
((key) << 8)
#define XEX_HEADER_SIZEDSTRUCT(key) \
(((key) << 8) | 0xFF)
#define XEX_HEADER_STRING(key) \
XEX_HEADER_SIZEDSTRUCT(key)
//
// A section header.
//
#define XEX_SECTION_NAME_LENGTH 8
typedef struct _XEX_SECTION_HEADER {
//
// Name of this section
//
CHAR SectionName[XEX_SECTION_NAME_LENGTH];
//
// Base address of this section
//
ULONG VirtualAddress;
//
// Size of this section as loaded
//
ULONG VirtualSize;
} XEX_SECTION_HEADER, *PXEX_SECTION_HEADER;
//
// The section table is a ULONG size of the total table followed by
// individual section entries stored in base address order. The count
// is determined from the size of the table.
//
#define XEX_HEADER_SECTION_TABLE \
XEX_HEADER_SIZEDSTRUCT(2)
//
// A description of blockwise data in this image.
//
typedef struct _XEX_DATA_DESCRIPTOR {
//
// The size of the data area.
//
ULONG Size;
//
// The root digest of the data area.
//
UCHAR DataDigest[20];
} XEX_DATA_DESCRIPTOR, *PXEX_DATA_DESCRIPTOR;
typedef struct _XEX_COMPRESSED_DATA_DESCRIPTOR {
//
// The size of the compression window.
//
ULONG WindowSize;
//
// The descriptor of the first data block.
//
XEX_DATA_DESCRIPTOR FirstDescriptor;
} XEX_COMPRESSED_DATA_DESCRIPTOR, *PXEX_COMPRESSED_DATA_DESCRIPTOR;
#define XEX_DEFAULT_COMPRESSION_WINDOW 0x8000
typedef struct _XEX_FILE_DATA_DESCRIPTOR {
//
// The size of this header.
//
ULONG Size;
//
// Data flags.
//
USHORT Flags;
//
// The format of data in this image.
//
USHORT Format;
//
// Format-specific data follows this header.
//
} XEX_FILE_DATA_DESCRIPTOR, *PXEX_FILE_DATA_DESCRIPTOR;
#define XEX_DATA_FLAG_ENCRYPTED 0x0001
#define XEX_DATA_FORMAT_NONE 0x0000
#define XEX_DATA_FORMAT_RAW 0x0001
#define XEX_DATA_FORMAT_COMPRESSED 0x0002
#define XEX_DATA_FORMAT_DELTA_COMPRESSED 0x0003
#define XEX_FILE_DATA_DESCRIPTOR_HEADER \
XEX_HEADER_SIZEDSTRUCT(3)
//
// Patch files identify the base file they're patching by including the
// hash of the base file headers.
//
#define XEX_PATCH_FILE_BASE_REFERENCE \
XEX_HEADER_FIXED_SIZE(4, 20)
//
// Delta patch files include the following header.
//
typedef struct _XEX_DELTA_PATCH_DESCRIPTOR {
//
// The size of this header.
//
ULONG Size;
//
// The version of the target file.
//
ULONG TargetVersion;
//
// The version of the source file.
//
ULONG SourceVersion;
//
// The hash of HV_IMAGE_INFO.Signature[] of the source file.
//
UCHAR DigestSource[20];
//
// The deobfuscated ImageKey of the source file encrypted with the
// deobfuscated ImageKey of the target file.
//
UCHAR ImageKeySource[16];
//
// The size of the XEX headers of the target file.
//
ULONG SizeOfTargetHeaders;
//
// The offset into the source XEX headers to copy into the target
// headers buffer before delta decompression begins.
//
ULONG DeltaHeadersSourceOffset;
//
// The size of the source XEX headers starting at the above offset
// to copy into the target headers buffer before delta decompression
// begins.
//
ULONG DeltaHeadersSourceSize;
//
// The offet into the target XEX headers buffer to copy the source
// headers range given above before delta decompression begins.
//
ULONG DeltaHeadersTargetOffset;
//
// The offset into the source image to copy into the target image
// buffer before delta decompression begins.
//
ULONG DeltaImageSourceOffset;
//
// The size of the source image starting at the above offset to copy
// into the target image buffer before delta decompression begins.
//
ULONG DeltaImageSourceSize;
//
// The offset into the target image buffer to copy the source image
// range given above before delta decompression begins.
//
ULONG DeltaImageTargetOffset;
//
// Following this header is a series of LZX_DELTA_CHUNK structures
// that describe the transformation of the source file headers into
// the target file headers.
//
} XEX_DELTA_PATCH_DESCRIPTOR, * PXEX_DELTA_PATCH_DESCRIPTOR;
#define XEX_HEADER_DELTA_PATCH_DESCRIPTOR \
XEX_HEADER_SIZEDSTRUCT(5)
//
// The bound pathname of this image, if it can run from only one location.
//
#define XEX_HEADER_BOUND_PATH \
XEX_HEADER_STRING(0x0080)
//
// The original base address of this image, if different from the load
// address.
//
#define XEX_HEADER_ORIGINAL_BASE_ADDRESS \
XEX_HEADER_ULONG(0x0100)
//
// The entry point of this image.
//
#define XEX_HEADER_ENTRY_POINT \
XEX_HEADER_FLAG(0x0101)
//
// The base of the PE image.
//
#define XEX_HEADER_PE_BASE \
XEX_HEADER_ULONG(0x0102)
//
// A single table of imports.
//
#define XEX_HEADER_IMPORTS \
XEX_HEADER_SIZEDSTRUCT(0x0103)
//
// The address of the PE export table.
//
#define XEX_HEADER_PE_EXPORTS \
XEX_HEADER_STRUCT(0xE104, IMAGE_DATA_DIRECTORY)
//
// Image information for debugging.
//
typedef struct _XEX_VITAL_STATS {
ULONG CheckSum;
ULONG TimeDateStamp;
} XEX_VITAL_STATS, *PXEX_VITAL_STATS;
#define XEX_HEADER_VITAL_STATS \
XEX_HEADER_STRUCT(0x0180, XEX_VITAL_STATS)
//
// Callcap import information.
//
typedef struct _XEX_CALLCAP_IMPORTS {
ULONG BeginFunctionThunkAddress;
ULONG EndFunctionThunkAddress;
} XEX_CALLCAP_IMPORTS, *PXEX_CALLCAP_IMPORTS;
#define XEX_HEADER_CALLCAP_IMPORTS \
XEX_HEADER_STRUCT(0x0181, XEX_CALLCAP_IMPORTS)
//
// Fastcap information.
//
#define XEX_HEADER_FASTCAP_ENABLED \
XEX_HEADER_FLAG(0x0182)
//
// PE Module name
//
#define XEX_HEADER_PE_MODULE_NAME \
XEX_HEADER_STRING(0x0183)
#if defined(_M_PPCBE)
#pragma bitfield_order(push, lsb_to_msb)
#endif
//
// Define the length of the library name stored in a library version structure.
//
#define XEXIMAGE_LIBRARY_VERSION_NAME_LENGTH 8
//
// Define the structure of a XBE library version descriptor.
//
typedef struct _XEXIMAGE_LIBRARY_VERSION {
//
// Specifies ASCII text padded with nulls to identify the library.
//
UCHAR LibraryName[XEXIMAGE_LIBRARY_VERSION_NAME_LENGTH];
//
// Specifies the major version number of the library.
//
USHORT MajorVersion;
//
// Specifies the minor version number of the library.
//
USHORT MinorVersion;
//
// Specifies the build version number of the library.
//
USHORT BuildVersion;
//
// Specifies the QFE version number of the library.
//
USHORT QFEVersion : 8;
//
// The QFEVersion was 13 bits. Lets leach it down to 8 bits and leave ourselves some more bits for flags.
//
USHORT Unused : 4;
#if 0 // Features are unsupported for now.
//
// Specifies whether this is actually a feature and not a library
//
USHORT LibFeature : 1;
#endif
//
// Specifies whether this version stamp pertains to the module itself.
//
USHORT XEXVersion : 1;
//
// Specifies the approved status of this library
// 0 = unapproved
// 1 = conditionally approved
// 2 = approved
USHORT ApprovedLibrary : 2;
//
// Specifies TRUE if this is a debug build of the library, else FALSE.
//
USHORT DebugBuild : 1;
} XEXIMAGE_LIBRARY_VERSION, *PXEXIMAGE_LIBRARY_VERSION;
// People tend to initialize the raw bits of the XEXIMAGE_LIBRARY_VERSION struct.
// Here are some helpfull defines for doing that.
#define LIBVER_DEBUG_BIT 0x8000
#define LIBVER_APPROVED_BIT 0x4000
#define LIBVER_CONDITIONAL_BIT 0x2000
#define LIBVER_XBEVERSION_BIT 0x1000
#define LIBVER_FEATURE_BIT 0x0800
#define LIBVER_UNUSED_BITS 0x0700
#define LIBVER_QFEVERSION_BITS 0x00FF
#if defined(_M_PPCBE)
#pragma bitfield_order(pop)
#endif
//
// The build version table.
//
#define XEX_HEADER_BUILD_VERSIONS \
XEX_HEADER_SIZEDSTRUCT(0x0200)
//
// A descriptor for static TLS data.
//
typedef struct _XEX_TLS_DATA {
ULONG TlsSlotCount;
PVOID AddressOfRawData;
ULONG SizeOfRawData;
ULONG SizeOfTlsData;
} XEX_TLS_DATA, *PXEX_TLS_DATA;
#define XEX_HEADER_TLS_DATA \
XEX_HEADER_STRUCT(0x201, XEX_TLS_DATA)
//
// The default stack size for threads created in this process.
//
#define XEX_HEADER_STACK_SIZE \
XEX_HEADER_FLAG(0x0202)
//
// The default filesystem cache size.
//
#define XEX_HEADER_FSCACHE_SIZE \
XEX_HEADER_ULONG(0x203)
//
// Size of the initial XAPI heap
//
#define XEX_HEADER_XAPI_HEAP_SIZE \
XEX_HEADER_ULONG(0x0204)
//
// Executable privilege settings. Settings are numbered from 0 through
// 1024, where the high 5 bits indicate which header field in the range
// 0x300 through 0x31F contains the privilege bit and the low 5 bits indicate
// which bit of the header field contains the privilege bit.
//
//
// This flag allows a title to control whether the system forcibly reboots the
// running title when certain events happen (such as tray ejection, etc.). The
// title may be required to do some notification handling if this privilege is
// specified.
//
#define XEX_PRIVILEGE_NO_FORCE_REBOOT 0
//
// Allow the system to create foreground tasks on behalf of the title.
//
#define XEX_PRIVILEGE_FOREGROUND_TASKS 1
//
// Do not create a mapping to the optical disc drive. Note that, if the title
// lives on a disc in the drive, the title's D:\ and GAME:\ mappings will still
// be created to point at the root of the optical media, but the CdRom0:\
// mapping will not be created.
//
#define XEX_PRIVILEGE_NO_ODD_MAPPING 2
//
// Indicates that the title is capable of handling MCE button press on remote
// control and that system should not have special processing for it.
//
#define XEX_PRIVILEGE_HANDLE_MCE_INPUT 3
//
// This privilege restricts the use of the Xbox 360 Guide (HUD). When this
// privilege is specified, the main menu of the guide will display a message
// saying it is disabled. Any extra user functionality such as voice chats
// will also be disabled.
//
#define XEX_PRIVILEGE_RESTRICT_HUD_FEATURES 4
//
// Indicates that a title handles controller disconnections by displaying a
// message to the user directing him to reconnect it.
//
#define XEX_PRIVILEGE_HANDLE_GAMEPAD_DISCONNECT 5
//
// This privilege allows titles to create insecure sockets that do not use
// the XSP networking protocol wrapper.
//
#define XEX_PRIVILEGE_INSECURE_SOCKETS 6
//
// This privilege configures XNet to allow interoperability with the original
// Xbox's XSP networking protocol.
//
#define XEX_PRIVILEGE_XBOX_1_XSP_INTEROP 7
//
// This privilege indicates that the title is allowed to set dash context
// information which can modify the way Guide (HUD) behaves in some cases.
//
#define XEX_PRIVILEGE_SET_DASH_CONTEXT 8
//
// This privilege indicates to the Guide (HUD) that the title exposes a game
// voice channel, which should be shown to the user when appropriate (e.g. in
// QuickChat).
//
#define XEX_PRIVILEGE_TITLE_USES_GAME_VOICE_CHANNEL 9
//
// This privilege indicates that the title does not support PAL50
//
#define XEX_PRIVILEGE_TITLE_PAL50_INCOMPATIBLE 10
//
// This privilege indicates that the title can use an insecured utitilty cache
// partition (i.e. XMountUtitliyDrive will mount the cache partition using FATX
// instead of STFS).
//
#define XEX_PRIVILEGE_TITLE_INSECURE_UTILITYDRIVE 11
#define XEX_HEADER_EXECUTION_ID \
XEX_HEADER_STRUCT(0x400, XEX_EXECUTION_ID)
//
// Array of custom Live service IDs to request
//
typedef struct _XEX_SERVICE_ID_LIST {
ULONG Size;
ULONG CustomServiceIDs[4];
} XEX_SERVICE_ID_LIST, *PXEX_SERVICE_ID_LIST;
#define XEX_HEADER_SERVICE_ID_LIST \
XEX_HEADER_SIZEDSTRUCT(0x401)
//
// Size of the title workspace area.
//
#define XEX_HEADER_WORKSPACE_SIZE \
XEX_HEADER_ULONG(0x0402)
//
// Game rating by region
//
#define XEX_NUMBER_GAME_RATING_SYSTEMS 64
#define XEX_HEADER_GAME_RATINGS \
XEX_HEADER_FIXED_SIZE(0x403, XEX_NUMBER_GAME_RATING_SYSTEMS)
//
// System Link LAN key
//
#define XEX_LAN_KEY_SIZE 16
#define XEX_HEADER_LAN_KEY \
XEX_HEADER_FIXED_SIZE(0x404, XEX_LAN_KEY_SIZE)
//
// MS logo information.
//
#define XEX_HEADER_MSLOGO \
XEX_HEADER_SIZEDSTRUCT(0x0405)
#pragma warning(pop)
#endif // _XEX_H_

155
xbdm/imp/xexhv.h Normal file
View File

@@ -0,0 +1,155 @@
/*++
Copyright (c) 2000-2005 Microsoft Corporation
Module Name:
xexhv.h
Abstract:
This module defines the structures of the Xenon Executable (XEX)
format that are used by the hypervisor.
--*/
#ifndef _XEXHV_H_
#define _XEXHV_H_
//
// Define the root security information of an executable image.
//
typedef struct _HV_IMAGE_INFO {
//
// The signature of this object.
//
UCHAR Signature[256];
//
// The size of this object.
//
ULONG InfoSize;
//
// Flags describing this image.
//
ULONG ImageFlags;
//
// Specifies the address at which this module is to be loaded.
//
ULONG LoadAddress;
//
// The hash of the image's first page descriptor.
//
UCHAR ImageHash[20];
//
// The number of import tables for this image.
//
ULONG ImportTableCount;
//
// The digest of the first import table.
//
UCHAR ImportDigest[20];
//
// Specifies the media identifier for this image. This must immediately
// follow the import/export information.
//
UCHAR MediaID[16];
//
// Specifies the key used to encrypt this image.
//
UCHAR ImageKey[16];
//
// The address of this image's export table, if any.
//
ULONG ExportTableAddress;
//
// The hash of the header information.
//
UCHAR HeaderHash[20];
//
// Game regions in which this image is allowed to run.
//
ULONG GameRegion;
} HV_IMAGE_INFO, *PHV_IMAGE_INFO;
#define XEX_SECURITY_FLAG_MFG_MODE 0x00000006
#define XEX_SECURITY_FLAG_MFG_UTIL 0x00000002 // runs in verified mfg mode
#define XEX_SECURITY_FLAG_MFG_SUPPORT 0x00000004 // runs in all mfg modes
#define XEX_SECURITY_FLAG_MFG_AWARE 0x00000006 // runs in all modes
#define XEX_SECURITY_FLAG_XGD2_MEDIA 0x00000008
#define XEX_SECURITY_FLAG_HV_PRIVS_MASK 0x000FFF00
#define XEX_SECURITY_FLAG_HV_PRIVS_SHIFT 8
#define XEX_SECURITY_FLAG_SMALL_PAGES 0x10000000
#define XEX_SECURITY_FLAG_NO_REGION 0x20000000
#define XEX_SECURITY_FLAG_REVOCABLE 0x40000000
#define XEX_SECURITY_FLAG_REQUIRE_COOKIE 0x80000000
#define XEX_HV_PRIVILEGE_CARDEA_KEY 0
#define XEX_HV_PRIVILEGE_XEIKA_KEY 1
#define XEX_HV_PRIVILEGE_TITLE_USER_MODE 2
#define XEX_HV_PRIVILEGE_SYSTEM_USER_MODE 3
#define XEX_HV_PRIVILEGE_ORANGE_0 4
#define XEX_HV_PRIVILEGE_ORANGE_1 5
#define XEX_HV_PRIVILEGE_ORANGE_2 6
//
// Define a page descriptor for image data.
//
typedef struct _HV_PAGE_INFO {
//
// Information describing the page range. The high 3 bits describe the
// page access policy, and the low 29 bits are the number of pages over
// which to apply it.
//
ULONG PageDescription;
//
// The digest of the next range's page descriptor plus the next range's
// data.
//
UCHAR DataDigest[20];
} HV_PAGE_INFO, *PHV_PAGE_INFO;
#define XEX_SECURITY_PAGE_COUNT_SHIFT 4
#define XEX_SECURITY_PAGE_PROTECT_MASK 0x0000000F
#define XEX_SECURITY_PAGE_ENCRYPT 0x00000008
#define XEX_SECURITY_PAGE_PROTECT 0x00000004
#define XEX_SECURITY_PAGE_NOEXECUTE 0x00000002
#define XEX_SECURITY_PAGE_NOWRITE 0x00000001
#define XEX_SECURITY_PAGE_CODE \
(XEX_SECURITY_PAGE_NOWRITE)
#define XEX_SECURITY_PAGE_READONLY \
(XEX_SECURITY_PAGE_NOEXECUTE | XEX_SECURITY_PAGE_NOWRITE)
#define XEX_SECURITY_PAGE_READWRITE \
(XEX_SECURITY_PAGE_NOEXECUTE)
//
// Define the header for image exports.
//
typedef struct _HV_IMAGE_EXPORT_TABLE {
ULONG Magic[3];
ULONG ModuleNumber[2];
ULONG Version[3];
ULONG ImageBaseAddress;
ULONG Count;
ULONG Base;
} HV_IMAGE_EXPORT_TABLE, *PHV_IMAGE_EXPORT_TABLE;
#define XEX_EXPORT_MAGIC_0 0x48000000
#define XEX_EXPORT_MAGIC_1 0x00485645
#define XEX_EXPORT_MAGIC_2 0x48000000
#endif // _XEXHV_H_

181
xbdm/imp/xinput.h Normal file
View File

@@ -0,0 +1,181 @@
/*++
Copyright (c) Microsoft Corporation
Module Name:
xinput.h
Abstract:
This module defines xinput structures
--*/
#ifndef _XINPUT_H
#define _XINPUT_H
//
// Define the values for HID keycodes
//
#define USBHID_KEYCODE_A 0x04
#define USBHID_KEYCODE_Z 0x1D
#define USBHID_KEYCODE_1 0x1E
#define USBHID_KEYCODE_9 0x26
#define USBHID_KEYCODE_0 0x27
#define USBHID_KEYCODE_RETURN 0x28
#define USBHID_KEYCODE_QUESTION 0x38
#define USBHID_KEYCODE_CAPSLOCK 0x39
#define USBHID_KEYCODE_KEYPADNUMLOCK 0x53
#define USBHID_KEYCODE_KEYPADBACKSLASH 0x54
#define USBHID_KEYCODE_KEYPADDECIMAL 0x63
#define USBHID_KEYCODE_LCONTROL 0xE0
#define USBHID_KEYCODE_LSHIFT 0xE1
#define USBHID_KEYCODE_LALT 0xE2
#define USBHID_KEYCODE_LGUI 0xE3
#define USBHID_KEYCODE_RCONTROL 0xE4
#define USBHID_KEYCODE_RSHIFT 0xE5
#define USBHID_KEYCODE_RALT 0xE6
#define USBHID_KEYCODE_RGUI 0xE7
//
// Define the values for HID key modifier
//
#define USBHID_MODIFIER_LCTRL 0x01
#define USBHID_MODIFIER_LSHIFT 0x02
#define USBHID_MODIFIER_LALT 0x04
#define USBHID_MODIFIER_LGUI 0x08
#define USBHID_MODIFIER_RCTRL 0x10
#define USBHID_MODIFIER_RSHIFT 0x20
#define USBHID_MODIFIER_RALT 0x40
#define USBHID_MODIFIER_RGUI 0x80
//
// Define the values for HID LEDs
//
#define USBHID_LED_NUMLOCK 0x01
#define USBHID_LED_CAPSLOCK 0x02
#define USBHID_LED_SCROLLLOCK 0x04
//
// Internal state needed by the API
//
#define INTERNAL_STATE_INDEX_SYSAPP 0
#define INTERNAL_STATE_INDEX_TITLE 1
typedef struct _GAMEPAD_STATE_DATA {
DWORD LastPacketNumber;
UCHAR AnalogPressedState;
WORD ButtonPressedState;
WORD LeftThumbPressedState;
WORD RightThumbPressedState;
} GAMEPAD_STATE_DATA, *PGAMEPAD_STATE_DATA;
typedef struct _INTERNAL_KEYSTROKE_QUEUE {
XINPUT_KEYSTROKE Data[10]; // worst possible case, 6 real keys + 4 modifiers
UCHAR Size;
UCHAR Count;
UCHAR InIndex;
UCHAR OutIndex;
} INTERNAL_KEYSTROKE_QUEUE, *PINTERNAL_KEYSTROKE_QUEUE;
//
// Language Support for Keyboards. Each language
// is implemented as an XINPUT_LANGUAGE_SERVICE.
//
#define MAX_LANGUAGE_SERVICE_AREA 8
typedef BOOL (*PFNXINPUTPROCESSLANG)(PXINPUT_KEYSTROKE pKeystroke, PVOID pvStateArea);
typedef DWORD (*PFNXINPUTRESETLANGSTATEAREA)(PVOID pvStateArea);
typedef BOOL (*PFNXINPUTLANGISKEYPENDING)(PVOID pvStateArea);
typedef struct _XINPUT_LANGUAGE_SERVICE
{
DWORD dwLanguage;
PFNXINPUTRESETLANGSTATEAREA pfnResetStateArea;
PFNXINPUTPROCESSLANG pfnProcess;
PFNXINPUTLANGISKEYPENDING pfnIsKeyPending;
WORD wSupportedModifiers;
} XINPUT_LANGUAGE_SERVICE, *PXINPUT_LANGUAGE_SERVICE;
//
// Languages
//
#ifdef __cplusplus
extern "C" {
#endif
extern XINPUT_LANGUAGE_SERVICE XAM_EnglishLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_EnglishUKLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_JapaneseLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_GermanLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_FrenchLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_FrenchCanadaLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_ItalianLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_SpanishLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_ChineseBopomofoLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_ChineseChajeiLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_KoreanLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_SwedishLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_PortuguesePTLanguageSupport;
extern XINPUT_LANGUAGE_SERVICE XAM_PortugueseBRLanguageSupport;
#ifdef __cplusplus
}
#endif
typedef struct _INTERNAL_STATE_DATA {
//
// these are 256-bit arrays that reflect the per-process
// state of the keyboard as last reported
//
UCHAR DownHIDKeys[32]; // snapshot of keys held down (using USB HIDs)
UCHAR DownVirtualKeys[32]; // snapshot of keys held down (using VK_* codes)
INTERNAL_KEYSTROKE_QUEUE PendingKeystrokes; // actual keystrokes (key up and down events)
GAMEPAD_STATE_DATA GamepadState[XUSER_MAX_COUNT];
DWORD LastReturnedPacketNumber[XUSER_MAX_COUNT];
UCHAR LastReturnedConnectedState[XUSER_MAX_COUNT];
DWORD LastKeyTime;
WORD LastKeyDown;
WORD LastKeyFlags;
UCHAR LastKeyDownHidCode;
UCHAR LastKeyDevice; // 0: None, 1: Gamepad, 2: Keyboard
UCHAR SlowRepeat;
} INTERNAL_STATE_DATA, *PINTERNAL_STATE_DATA;
//
// Per-keyboard, as oppose to per-process per-keyboard state.
// Basically, the language settings, and the lock flags.
//
typedef struct _INTERNAL_KEYBOARD_STATE {
PXINPUT_LANGUAGE_SERVICE pLanguageService;
UCHAR LanguageStateArea[MAX_LANGUAGE_SERVICE_AREA];
WORD wLockFlags;
} INTERNAL_KEYBOARD_STATE, *PINTERNAL_KEYBOARD_STATE;
typedef struct _INTERNAL_IR_STATE {
KSPIN_LOCK SpinLock;
ULONG ButtonCode;
ULONG LastToggle;
ULONG SendUpButtonCode;
ULONG LastSMCNotificationTime;
ULONG LastKeyDownTime;
UCHAR SlowRepeat;
} INTERNAL_IR_STATE, *PINTERNAL_IR_STATE;
#endif // _XINPUT_H

9489
xbdm/imp/xonlinep.h Normal file
View File

@@ -0,0 +1,9489 @@
/*
* Version 1.1859
*
* xonlinep.h
*
* This module contains the private definitions for Xbox Live
*
* Created on 11/19/05 at 04:36:34.
*/
#ifndef __XONLINEP__
#define __XONLINEP__
#ifdef __cplusplus
extern "C" {
#endif
#include <xonline.h>
//
// Temporary method used to identify titles. Must be called prior to
// logging on.
//
void
WINAPI
XNetLogonSetTitleID(
IN DWORD dwTitleID
);
//
// Internal error codes to forward info within the client logon process
//
#define XONLINE_E_LOGON_NO_IP_ADDRESS _HRESULT_TYPEDEF_(0x80151901L)
#define XONLINE_E_LOGON_NO_DNS_SERVICE _HRESULT_TYPEDEF_(0x80151902L)
#define XONLINE_E_LOGON_DNS_LOOKUP_FAILED _HRESULT_TYPEDEF_(0x80151903L)
#define XONLINE_E_LOGON_DNS_LOOKUP_TIMEDOUT _HRESULT_TYPEDEF_(0x80151904L)
#define XONLINE_E_LOGON_INVALID_XBOX_ONLINE_INFO _HRESULT_TYPEDEF_(0x80151905L)
#define XONLINE_E_LOGON_MACS_FAILED _HRESULT_TYPEDEF_(0x80151906L)
#define XONLINE_E_LOGON_MACS_TIMEDOUT _HRESULT_TYPEDEF_(0x80151907L)
#define XONLINE_E_LOGON_AUTHENTICATION_FAILED _HRESULT_TYPEDEF_(0x80151908L)
#define XONLINE_E_LOGON_AUTHENTICATION_TIMEDOUT _HRESULT_TYPEDEF_(0x80151909L)
#define XONLINE_E_LOGON_AUTHORIZATION_FAILED _HRESULT_TYPEDEF_(0x8015190AL)
#define XONLINE_E_LOGON_AUTHORIZATION_TIMEDOUT _HRESULT_TYPEDEF_(0x8015190BL)
#define XONLINE_E_LOGON_XBOX_ACCOUNT_INVALID _HRESULT_TYPEDEF_(0x8015190CL)
#define XONLINE_E_LOGON_XBOX_ACCOUNT_BANNED _HRESULT_TYPEDEF_(0x8015190DL)
#define XONLINE_E_LOGON_SG_SERVICE_FAILED _HRESULT_TYPEDEF_(0x8015190EL)
#define XONLINE_E_LOGON_PRESENCE_SERVICE_FAILED _HRESULT_TYPEDEF_(0x8015190FL)
#define XONLINE_E_LOGON_PRESENCE_SERVICE_TIMEDOUT _HRESULT_TYPEDEF_(0x80151910L)
#define XONLINE_E_LOGON_TIMEDOUT _HRESULT_TYPEDEF_(0x80151911L)
#define XONLINE_E_LOGON_UNKNOWN_TITLE _HRESULT_TYPEDEF_(0x80151912L)
#define XONLINE_E_LOGON_INTERNAL_ERROR _HRESULT_TYPEDEF_(0x80151913L)
#define XONLINE_E_LOGON_MACHINE_AUTHENTICATION_FAILED _HRESULT_TYPEDEF_(0x80151914L)
#define XONLINE_E_LOGON_TGT_REVOKED _HRESULT_TYPEDEF_(0x80151915L)
#define XONLINE_E_LOGON_CACHE_MISS _HRESULT_TYPEDEF_(0x80151916L)
#define XONLINE_E_LOGON_NOT_UPNP_NAT _HRESULT_TYPEDEF_(0x80151917L)
#define XONLINE_E_LOGON_INCONCLUSIVE_UPNP_NAT _HRESULT_TYPEDEF_(0x80151918L)
#define XONLINE_E_LOGON_UPNP_NAT_HARD_FAILURE _HRESULT_TYPEDEF_(0x80151919L)
#define XONLINE_E_LOGON_UPNP_PORT_UNAVAILABLE _HRESULT_TYPEDEF_(0x8015191AL)
#define XOnlineIsPrivateLogonHR( hr ) (((hr) & 0xFFFFFF00L) == 0x80151900L)
// XUID compatibility macros
#define XOnlineIsUserGuest IsGuestXUID
//
// Xbox Live Service ID
//
#define XONLINE_PRESENCE_SERVICE 1
#define XONLINE_STRING_SERVICE 2
#define XONLINE_AUTO_UPDATE_SERVICE 3
#define XONLINE_CONTENT_AVAILABLE_SERVICE 4
#define XONLINE_BASE_SUBSCRIPTION_SERVICE XONLINE_CONTENT_AVAILABLE_SERVICE
#define XONLINE_USER_ACCOUNT_SERVICE 5
#define XONLINE_MATCHMAKING_SERVICE 6
#define XONLINE_STATISTICS_SERVICE 7
#define XONLINE_FEEDBACK_SERVICE 8
#define XONLINE_BILLING_OFFERING_SERVICE 9
#define XONLINE_NICKNAME_VERIFICATION_SERVICE XONLINE_BILLING_OFFERING_SERVICE
#define XONLINE_DIAGNOSTIC_LOGGING_SERVICE 10
#define XONLINE_TOU_SERVICE 11
#define XONLINE_SIGNATURE_SERVICE 12
#define XONLINE_QUERY_SERVICE 13
#define XONLINE_NAME_RESOLUTION_SERVICE 14
#define XONLINE_STORAGE_SERVICE 15
#define XONLINE_ARBITRATION_SERVICE 16
#define XONLINE_USAGE_DATA_SERVICE 17
#define XONLINE_MESSAGING_SERVICE 18
#define XONLINE_TEAM_SERVICE 19
#define XONLINE_NAT_TYPE_DETECTION_SERVICE 20
#define XONLINE_DRM_SERVICE 21
// These services are for testing against the SGs
#define XONLINE_SG_SITE_1_AUTH_SERVICE 129
#define XONLINE_SG_SITE_2_AUTH_SERVICE 130
#define XONLINE_SG_SITE_1_TEST_SERVICE 129
#define XONLINE_SG_SITE_2_TEST_SERVICE 130
#define XONLINE_UPNP_NAT_SERVICE 0xFFFFFFFF
#define XONLINE_MAX_SERVICE 21
#define XONLINE_INVALID_SERVICE 0
#define XONLINE_S_LOGON_USER_MESSAGE_ENUMERATION_NEEDED _HRESULT_TYPEDEF_(0x001512F1L)
//
// Service info
//
#define XNET_LOGON_SERVICE_INFO_INSECURE 0x0001 // service IP & port is insecure
#pragma pack(push, 4)
typedef struct _XNET_LOGON_SERVICE_INFO
{
DWORD dwServiceID;
IN_ADDR inaService;
WORD wServicePort;
WORD wFlags;
} XNET_LOGON_SERVICE_INFO, *PXNET_LOGON_SERVICE_INFO;
#pragma pack(pop)
//
// Logon flags
//
#define XNET_LOGON_FLAG_GET_NEW_TICKETS_ONLY 0x00000001
#define XNET_LOGON_FLAG_UPDATE_SERVICE_ONLY 0x00000002
#define XNET_LOGON_FLAG_REFRESH_TICKETS_ONLY 0x00010000
#define XONLINE_MAX_LOGON_USERS 4
#define XONLINE_GAMERTAG_SIZE 16
#define XONLINE_MAX_GAMERTAG_LENGTH (XONLINE_GAMERTAG_SIZE - 1)
#define XONLINE_PASSCODE_LENGTH 4
#define XONLINE_USERDOMAIN_SIZE 20
#define XONLINE_MAX_USERDOMAIN_LENGTH (XONLINE_USERDOMAIN_SIZE - 1)
#define XONLINE_KERBEROSREALM_SIZE 24
#define XONLINE_MAX_KERBEROSREALM_LENGTH (XONLINE_KERBEROSREALM_SIZE - 1)
#define XONLINE_KEY_LENGTH 16
//
// A structure that contains the 64-bit XUID plus the user flags
//
#pragma pack(push, 4)
typedef struct _XUIDWITHFLAGS {
XUID qwUserID;
DWORD dwUserFlags;
} XUIDWITHFLAGS, *PXUIDWITHFLAGS;
#pragma pack(pop)
//
// Used in dwUserFlags in XUIDWITHFLAGS
//
#define XONLINE_USER_GUEST_MASK 0x00000003
#define XONLINE_USER_NOSHOW_RATING_MASK 0x0000001C
#define XONLINE_USER_DISCONNECT_RATING_MASK 0x000000E0
#define XONLINE_USER_COUNTRY_MASK 0x0000ff00
#define XONLINE_USER_VOICE_NOT_ALLOWED 0x00010000
#define XONLINE_USER_PURCHASE_NOT_ALLOWED 0x00020000
#define XONLINE_USER_NICKNAME_NOT_ALLOWED 0x00040000
#define XONLINE_USER_SHARED_CONTENT_NOT_ALLOWED 0x00080000
#define XONLINE_USER_PARENTAL_CONTROLLED 0x01000000
#define XONLINE_USER_MEMBERSHIP_TIER_MASK 0x00F00000
#define XOnlineUserFlagsMembershipTier(dwUserFlags) ((BYTE)(((dwUserFlags) & XONLINE_USER_MEMBERSHIP_TIER_MASK) >> 20))
#define XOnlineUserFlagsCountryId(dwUserFlags) ((BYTE)(((dwUserFlags) & XONLINE_USER_COUNTRY_MASK) >> 8))
#define XOnlineUserFlagsGuestNumber(dwUserFlags) ((dwUserFlags) & XONLINE_USER_GUEST_MASK)
#define XOnlineUserFlagsSetGuestNumber(dwUserFlags,guestNumber) ((dwUserFlags) = ((dwUserFlags) & ~XONLINE_USER_GUEST_MASK) | (guestNumber & XONLINE_USER_GUEST_MASK))
#define XOnlineUserFlagsIsUserGuest(dwUserFlags) (((dwUserFlags) & XONLINE_USER_GUEST_MASK) != 0)
//
// Compatibility macros
//
#define XOnlineUserCountryId XamUserGetOnlineCountryFromXUID
#define XOnlineUserMembershipTier XamUserGetMembershipTierFromXUID
//
// Used in dwUserOptions in XNET_LOGON_USER
//
#define XNET_LOGON_USER_OPTION_REQUIRE_PASSCODE 0x00000001
#pragma pack(push, 4)
typedef struct _XNET_LOGON_USER
{
XUIDWITHFLAGS xuid;
DWORD dwServiceNetworkID;
CHAR szGamertag[XONLINE_GAMERTAG_SIZE];
DWORD dwUserOptions;
BYTE passcode[XONLINE_PASSCODE_LENGTH];
CHAR domain[XONLINE_USERDOMAIN_SIZE];
CHAR kerberosRealm[XONLINE_KERBEROSREALM_SIZE];
BYTE key[XONLINE_KEY_LENGTH];
HRESULT hr;
} XNET_LOGON_USER, *PXNET_LOGON_USER;
#pragma pack(pop)
typedef enum _XNET_LOGON_NAT_TYPE
{
XNET_LOGON_NAT_TYPE_OPEN = 1,
XNET_LOGON_NAT_TYPE_MODERATE,
XNET_LOGON_NAT_TYPE_STRICT
} XNET_LOGON_NAT_TYPE;
typedef enum _XNET_LOGON_DNS_TYPE
{
XNET_LOGON_DNS_MACS,
XNET_LOGON_DNS_AS,
XNET_LOGON_DNS_TGS,
XNET_LOGON_DNS_XDS,
XNET_LOGON_DNS_MAINTENANCE,
NUM_XNET_LOGON_DNS_TYPES
} XNET_LOGON_DNS_TYPE;
#define XNET_LOGON_MAX_DNS_NAME_LENGTH 80 // 80 characters, including NULL termination
//
// If 2 or 3 bits are used in any status flag, then the meaning is as follows
//
#define XNET_LOGON_STATUS_INITIAL 0x0
#define XNET_LOGON_STATUS_START 0x1
#define XNET_LOGON_STATUS_SUCCESS 0x2
#define XNET_LOGON_STATUS_FAIL 0x3
#define XNET_LOGON_STATUS_SOCKET_FAIL 0x4
#define XNET_LOGON_STATUS_RECV_FAIL 0x5
#define XNET_LOGON_STATUS_MEMORY_FAIL 0x6
#define XNET_LOGON_STATUS_TIMEOUT_FAIL 0x7
//
// Meaning of bits on the Online Logon Status DWORD
//
#define XNET_LOGON_STATUS_XNET_FAILED 0x00000001
#define XNET_LOGON_STATUS_EEPROM_FAILED 0x00000002
#define XNET_LOGON_STATUS_GENEALOGY_FAILED 0x00000004
#define XNET_LOGON_STATUS_OUT_OF_MEMORY 0x00000008
#define XNET_LOGON_STATUS_USER_KEY_INCORRECT 0x00000010
#define XNET_LOGON_STATUS_UPNP_EXCHANGE 0x00000060
#define XNET_LOGON_STATUS_UPNP_EXCHANGE_SHIFT 5
#define XNET_LOGON_STATUS_MACS_EXCHANGE 0x00000380
#define XNET_LOGON_STATUS_MACS_EXCHANGE_SHIFT 7
#define XNET_LOGON_STATUS_AS_EXCHANGE 0x00001C00
#define XNET_LOGON_STATUS_AS_EXCHANGE_SHIFT 10
#define XNET_LOGON_STATUS_TGS_EXCHANGE 0x0000E000
#define XNET_LOGON_STATUS_TGS_EXCHANGE_SHIFT 13
#define XNET_LOGON_STATUS_MACS_DNS_LOOKUP 0x00030000
#define XNET_LOGON_STATUS_MACS_DNS_LOOKUP_SHIFT 16
#define XNET_LOGON_STATUS_AS_DNS_LOOKUP 0x000C0000
#define XNET_LOGON_STATUS_AS_DNS_LOOKUP_SHIFT 18
#define XNET_LOGON_STATUS_TGS_DNS_LOOKUP 0x00300000
#define XNET_LOGON_STATUS_TGS_DNS_LOOKUP_SHIFT 20
#define XNET_LOGON_STATUS_MACHINE_ACCOUNT_LOOKUP 0x00C00000
#define XNET_LOGON_STATUS_MACHINE_ACCOUNT_LOOKUP_SHIFT 22
#define XNET_LOGON_STATUS_COMBINED_TICKET_CACHE 0x03000000
#define XNET_LOGON_STATUS_COMBINED_TICKET_CACHE_SHIFT 24
#define XNET_LOGON_STATUS_SERVICE_TICKET_CACHE 0x0C000000
#define XNET_LOGON_STATUS_SERVICE_TICKET_CACHE_SHIFT 26
#define XNET_LOGON_STATUS_SG_EXCHANGE 0x30000000
#define XNET_LOGON_STATUS_SG_EXCHANGE_SHIFT 28
//
// The following values are not reported with Xbox 360.
//
#define XONLINE_LOGON_STATUS_PRESENCE_EXCHANGE 0xC0000000
#define XONLINE_LOGON_STATUS_PRESENCE_EXCHANGE_SHIFT 30
//
// Macros to get/set a logon status field
//
#define XNetLogonSetStatus(dwStatus, field, status) (dwStatus = ((dwStatus) & ~(field)) | ((status) << field##_SHIFT));
#define XNetLogonGetStatus(dwStatus, field) (((dwStatus) & (field)) >> field##_SHIFT)
//
// To load any override information for our live services
//
HRESULT
WINAPI
XNetLogonInitOverrideInfo();
HRESULT
WINAPI
XNetLogonTaskStart(
IN const XNET_LOGON_USER * pUsers,
IN DWORD dwFlags
);
HRESULT
WINAPI
XNetLogonTaskContinue(
);
void
WINAPI
XNetLogonTaskClose(
);
XNET_LOGON_USER *
WINAPI
XNetLogonGetLoggedOnUsers(
);
HRESULT
WINAPI
XNetLogonGetNatType(
OUT XNET_LOGON_NAT_TYPE * pNatType
);
HRESULT
WINAPI
XNetLogonGetServiceInfo(
IN DWORD dwServiceID,
OUT PXNET_LOGON_SERVICE_INFO pServiceInfo
);
DWORD *
WINAPI
XNetLogonGetUserPrivileges(
IN ULONGLONG qwUserId
);
//
// Override console certificate passed up to Live (devkit only).
// The buffer is expected to contain an XE_CONSOLE_CERTIFICATE structure.
//
BOOL
WINAPI
XNetLogonSetConsoleCertificate(
IN const BYTE * pbConsoleCertificate,
IN DWORD dwConsoleCertificateSize
);
HRESULT
WINAPI
XNetLogonGetMachineID(
IN OUT ULONGLONG * pqwMachineID
);
DWORD
WINAPI
XNetLogonGetTitleID(
IN DWORD dwServiceID
);
DWORD
WINAPI
XNetLogonGetTitleVersion(
);
DWORD
WINAPI
XNetLogonGetServiceNetworkID();
void
WINAPI
XNetLogonGetDnsString(
IN XNET_LOGON_DNS_TYPE DnsType,
IN OUT char * pszBuffer,
IN DWORD dwBufferLength
);
void
WINAPI
XNetLogonGetExtendedStatus(
OUT DWORD * pdwStatus,
OUT DWORD * pdwStatusError
);
BOOL
WINAPI
XNetLogonClearTicketCaches(
IN DWORD dwFlags
);
#define XONLINE_SERVICE_INFO_INSECURE 0x0001 // reserved flag, service IP & port is insecure
#define XONLINE_SERVICE_INFO_HOSTNAME_PTR 0x0002 // reserved flag, dwServiceID is a pointer to a hostname string instead
// ====================================================================
// XOnline Teams
//
//
// Team/Team Member structure flags
//
#define XONLINE_TEAM_MSG_RECRUIT 0x00000001
#define XONLINE_TEAM_MSG_GAME_INVITE 0x00000002
#define XONLINE_TEAM_MEMBER_RECRUITED 0x00000004
//
// XOnlineTeamMembersEnumerate flags
//
#define XONLINE_TEAM_SHOW_RECRUITS 0x00000001
typedef enum {
XONLINE_TEAM_DELETE = 0x00000001,
XONLINE_TEAM_MODIFY_DATA = 0x00000002,
XONLINE_TEAM_MODIFY_MEMBER_PERMISSIONS = 0x00000004,
XONLINE_TEAM_DELETE_MEMBER = 0x00000008,
XONLINE_TEAM_RECRUIT_MEMBERS = 0x00000010,
XONLINE_TEAM_LIVE_PERMISSIONS_ALL = 0xFFFFFFFF
} XONLINE_TEAM_LIVE_PERMISSIONS;
// for some reason, xlivegen doesn't recgonize double
// or DOUBLE types natively.
typedef double __XLIVEGEN_DOUBLE;
// These settings are neither readable nor writable by titles
#define XPROFILE_PERMISSIONS XPROFILEID( XUSER_DATA_TYPE_INT32, sizeof(DWORD), 0)
#define XPROFILE_GAMER_TYPE XPROFILEID( XUSER_DATA_TYPE_INT32, sizeof(DWORD), 1)
#define XPROFILE_GAMER_PRESENCE_USER_STATE XPROFILEID( XUSER_DATA_TYPE_INT32, sizeof(DWORD), 7)
#define XPROFILE_GAMERCARD_TIER XPROFILEID( XUSER_DATA_TYPE_INT32, sizeof(DWORD), 58)
// This constant is used to verify a title doesn't try to write to an invalid
// setting id. BE SURE TO UPDATE THIS IF YOU ADD ANY MORE PROFILE SETTING IDS!
#define XPROFILE_MAX_SETTING_ID 59
// This is an approximation of the total size of all profile settings. It's
// important that this size remains smaller than the size of the response
// buffer in SettingsTracker::Sync or the server won't be able to return all
// the settings in one shot. Until the protocol supports multiple round trips
// to read all the settings this is a limitation we must live with even if it
// means not adding any more settings.
#define XPROFILE_MAX_AGGREGATE_SIZE ((3 * XPROFILE_SETTING_MAX_SIZE) + \
XPROFILE_SETTING_MAX_PICTURE_KEY_PATH + \
XPROFILE_SETTING_MAX_GAMERCARD_MOTTO + \
(40 * sizeof(DWORD)))
// XPROFILE_GAMERCARD_TIER_OPTIONS == XONLINE_TIER_TYPE. Do not redefine the values.
// XPROFILE_GAMERCARD_TIER_OPTIONS == XONLINE_TIER_TYPE. Do not redefine the values.
DWORD
WINAPI
XSessionGetInvitationData (
IN DWORD dwUserIndex,
OUT PXSESSION_INFO pSessionInfo
);
//-----------------------------------------------------------------------------
// Private Session API message structures
//-----------------------------------------------------------------------------
// This struct is stored in a session handle
// It only contains a pointer to the SessionTracker object allocated in
// XGI for now, but I've defined a struct for ease of expansion and for
// more legible code.
typedef struct tagSESSION_STRUCT
{
void* pSessionTracker;
} SESSION_STRUCT;
typedef struct
{
SESSION_STRUCT* pSessionStruct;
DWORD dwFlags;
DWORD dwMaxPublicSlots;
DWORD dwMaxPrivateSlots;
DWORD dwUserIndex;
PXSESSION_INFO pSessionInfo;
ULONGLONG* pqwSessionNonce;
} XGI_SESSIONCREATE_MSG;
typedef struct
{
SESSION_STRUCT* pSessionStruct;
DWORD dwFlags;
DWORD dwMaxPublicSlots;
DWORD dwMaxPrivateSlots;
} XGI_SESSIONMODIFY_MSG;
typedef struct
{
SESSION_STRUCT* pSessionStruct;
DWORD dwUsers;
const XUID* pXuids;
const DWORD* pdwUserIndexes;
const BOOL* pfPrivateSlots;
} XGI_SESSIONMANAGE_MSG;
typedef struct
{
SESSION_STRUCT* pSessionStruct;
DWORD dwFlags;
ULONGLONG qwSessionNonce;
} XGI_SESSIONSTATE_MSG;
typedef struct
{
SESSION_STRUCT* pSessionStruct;
DWORD dwFlags;
ULONGLONG qwSessionNonce;
DWORD dwSessionDurationSec;
DWORD cbResultsBuffer;
PXSESSION_REGISTRATION_RESULTS pResults;
} XGI_SESSIONREGISTER_MSG;
typedef struct
{
DWORD dwProcedureIndex;
DWORD dwUserIndex;
DWORD dwNumResults;
WORD wNumProperties;
WORD wNumContexts;
PXUSER_PROPERTY pSearchProperties;
PXUSER_CONTEXT pSearchContexts;
DWORD cbResultsBuffer;
PXSESSION_SEARCHRESULT_HEADER pSearchResults;
} XGI_SESSIONSEARCH_MSG;
typedef struct
{
DWORD dwProcedureIndex;
DWORD dwUserIndex;
DWORD dwNumResults;
WORD wNumProperties;
WORD wNumContexts;
PXUSER_PROPERTY pSearchProperties;
PXUSER_CONTEXT pSearchContexts;
DWORD cbResultsBuffer;
PXSESSION_SEARCHRESULT_HEADER pSearchResults;
DWORD dwNumUsers;
} XGI_SESSIONSEARCHEX_MSG;
typedef struct
{
DWORD dwUserIndex;
XNKID sessionID;
DWORD cbResultsBuffer;
PXSESSION_SEARCHRESULT_HEADER pSearchResults;
} XGI_SESSIONSEARCHBYID_MSG;
typedef struct
{
DWORD dwUserIndex;
PXSESSION_INFO pSessionInfo;
} XGI_SESSIONINVITE_MSG;
typedef struct
{
SESSION_STRUCT* pSessionStruct;
XUID xuid;
DWORD dwNumViews;
CONST XSESSION_VIEW_PROPERTIES* pViews;
} XGI_STATSWRITE_MSG;
//-----------------------------------------------------------------------------
// Session APIs
//-----------------------------------------------------------------------------
#define XSESSION_SEARCH_BY_ID_PROC 0xFFFFFFFF // Global query to find a session by session ID. Available in all titles. Param 0 must be SessionID
#define XSESSION_CREATE_PRIVATE_MODIFIERS_MASK 0x00001000
#define XSESSION_CREATE_PRIVATE_FORCE_UDP 0x00001000 // Arbitrated session results will only be reported in udp
//-----------------------------------------------------------------------------
// Mute List APIs
//-----------------------------------------------------------------------------
typedef struct _XUSER_MUTELIST_REQUEST
{
DWORD dwUserIndex;
XUID Xuid;
DWORD dwResult;
} XUSER_MUTELIST_REQUEST;
XBOXAPI
DWORD
WINAPI
XUserpMuteListAdd(
DWORD dwUserIndex,
XUID XuidRemoteTalker
);
XBOXAPI
DWORD
WINAPI
XUserpMuteListRemove(
DWORD dwUserIndex,
XUID XuidRemoteTalker
);
//-----------------------------------------------------------------------------
// Private Arbitration APIs
//-----------------------------------------------------------------------------
#define XARB_FLAG_IS_TOURNAMENT 0x0001
#define XARB_FLAG_CAN_EXTEND_TIME 0x0002
#define XARB_FLAG_USES_SESSION_HOST 0x0004
#define XARB_FLAG_FOR_TEAMS 0x0008
#define XARB_FLAG_FFA 0x0010
#define XARB_FLAG_IS_PUBLISHER_TOURNAMENT 0x0020
#define XARB_FLAG_I_VOLUNTARILY_QUIT 0x8000
#define XARB_FLAG_I_WAS_HOST 0x4000
#define XARB_FLAG_LOST_CONNECTIVITY 0x2000
#define XARB_FLAG_LOST_CONNECTIVITY_SUBMITTED 0x1000
#define XARB_FLAG_TYPE_1_SUSPICIOUS_INFO_SUBMITTED 0x0800
#define XARB_FLAG_TYPE_2_SUSPICIOUS_INFO_SUBMITTED 0x0400
#define XARB_FLAG_TYPE_3_SUSPICIOUS_INFO_SUBMITTED 0x0200
#define XARB_FLAG_STATS_BUNDLE_SUBMITTED 0x0100
#define XARB_FLAG_TOURNAMENT_BUNDLE_SUBMITTED 0x0080
extern const CHAR *rgszFunctionNames[];
#define ORDINAL_0206_XFriendsCreateEnumerator (WORD)0x0206
#define ORDINAL_0586_XInviteGetAcceptedInfo (WORD)0x0586
#define ORDINAL_0583_XInviteSend (WORD)0x0583
#define ORDINAL_000b_XPresenceCreateEnumerator (WORD)0x000b
#define ORDINAL_0010_XPresenceInitialize (WORD)0x0010
#define ORDINAL_000d_XPresenceSubscribe (WORD)0x000d
#define ORDINAL_000e_XPresenceUnsubscribe (WORD)0x000e
#define ORDINAL_0e15_XStorageDelete (WORD)0x0e15
#define ORDINAL_0e11_XStorageDownloadToMemory (WORD)0x0e11
#define ORDINAL_0e14_XStorageEnumerate (WORD)0x0e14
#define ORDINAL_0e13_XStorageUploadFromMemory (WORD)0x0e13
#define ORDINAL_0801_XStringVerify (WORD)0x0801
#define ORDINAL_0914_XContentDownload (WORD)0x0914
#define ORDINAL_0917_XContentDownloadGetInProgressMetadata (WORD)0x0917
#define ORDINAL_0913_XContentGetReferral (WORD)0x0913
#define ORDINAL_0916_XContentRefreshLicense (WORD)0x0916
#define ORDINAL_0915_XContentRefreshLicenseSubTask (WORD)0x0915
#define ORDINAL_0207_XFriendsRequestWorker (WORD)0x0207
#define ORDINAL_0584_XInviteAnswer (WORD)0x0584
#define ORDINAL_0585_XInviteRevoke (WORD)0x0585
#define ORDINAL_0587_XInviteSendMessage (WORD)0x0587
#define ORDINAL_0800_XLookupTitleName (WORD)0x0800
#define ORDINAL_0506_XMessageCreate (WORD)0x0506
#define ORDINAL_0511_XMessageDelete (WORD)0x0511
#define ORDINAL_0505_XMessageDeleteWorker (WORD)0x0505
#define ORDINAL_0507_XMessageDestroy (WORD)0x0507
#define ORDINAL_050f_XMessageDetailsGetProperty (WORD)0x050f
#define ORDINAL_050e_XMessageDetailsGetSummary (WORD)0x050e
#define ORDINAL_05a1_XMessageDownloadAttachmentToMemory (WORD)0x05a1
#define ORDINAL_0501_XMessageEnumerate (WORD)0x0501
#define ORDINAL_0513_XMessageEnumerateWorker (WORD)0x0513
#define ORDINAL_050d_XMessageGetDetails (WORD)0x050d
#define ORDINAL_0503_XMessageGetDetailsWorker (WORD)0x0503
#define ORDINAL_0509_XMessageGetProperty (WORD)0x0509
#define ORDINAL_0502_XMessageGetSummary (WORD)0x0502
#define ORDINAL_0514_XMessageGetSummaryWorker (WORD)0x0514
#define ORDINAL_0581_XMessageInviteAnswerWorker (WORD)0x0581
#define ORDINAL_0582_XMessageInviteRevokeWorker (WORD)0x0582
#define ORDINAL_0580_XMessageInviteSendWorker (WORD)0x0580
#define ORDINAL_050b_XMessageRevoke (WORD)0x050b
#define ORDINAL_0512_XMessageSend (WORD)0x0512
#define ORDINAL_050a_XMessageSendWorker (WORD)0x050a
#define ORDINAL_0510_XMessageSetFlags (WORD)0x0510
#define ORDINAL_0504_XMessageSetFlagsWorker (WORD)0x0504
#define ORDINAL_0508_XMessageSetProperty (WORD)0x0508
#define ORDINAL_0100_XOnlineMatchCreate (WORD)0x0100
#define ORDINAL_0102_XOnlineMatchDelete (WORD)0x0102
#define ORDINAL_0006_XOnlineMatchRegisterSession (WORD)0x0006
#define ORDINAL_0104_XOnlineMatchSearch (WORD)0x0104
#define ORDINAL_0101_XOnlineMatchUpdate (WORD)0x0101
#define ORDINAL_0300_XOnlineQueryAdd (WORD)0x0300
#define ORDINAL_0306_XOnlineQueryFindFromIds (WORD)0x0306
#define ORDINAL_0301_XOnlineQueryRemove (WORD)0x0301
#define ORDINAL_0302_XOnlineQueryRemoveId (WORD)0x0302
#define ORDINAL_0305_XOnlineQuerySearch (WORD)0x0305
#define ORDINAL_0307_XOnlineQuerySelect (WORD)0x0307
#define ORDINAL_0303_XOnlineQueryUpdate (WORD)0x0303
#define ORDINAL_0304_XOnlineQueryUpdateId (WORD)0x0304
#define ORDINAL_0400_XOnlineTeamCreate (WORD)0x0400
#define ORDINAL_0401_XOnlineTeamDelete (WORD)0x0401
#define ORDINAL_0407_XOnlineTeamEnumerate (WORD)0x0407
#define ORDINAL_0408_XOnlineTeamEnumerateByUserXUID (WORD)0x0408
#define ORDINAL_0404_XOnlineTeamJoin (WORD)0x0404
#define ORDINAL_0402_XOnlineTeamMemberRecruit (WORD)0x0402
#define ORDINAL_0403_XOnlineTeamMemberRecruitByName (WORD)0x0403
#define ORDINAL_0405_XOnlineTeamMemberRemove (WORD)0x0405
#define ORDINAL_0406_XOnlineTeamMemberSetProperties (WORD)0x0406
#define ORDINAL_0409_XOnlineTeamMembersEnumerate (WORD)0x0409
#define ORDINAL_040a_XOnlineTeamSetProperties (WORD)0x040a
#define ORDINAL_0203_XOnlinepFriendsAcceptRequest (WORD)0x0203
#define ORDINAL_0204_XOnlinepFriendsRejectRequest (WORD)0x0204
#define ORDINAL_0202_XOnlinepFriendsRemove (WORD)0x0202
#define ORDINAL_0200_XOnlinepFriendsRequest (WORD)0x0200
#define ORDINAL_0201_XOnlinepFriendsRequestByName (WORD)0x0201
#define ORDINAL_0a00_XOnlinepMuteListAdd (WORD)0x0a00
#define ORDINAL_0a01_XOnlinepMuteListRemove (WORD)0x0a01
#define ORDINAL_0003_XOnlinepNotificationSendDequeue (WORD)0x0003
#define ORDINAL_0009_XOnlinepPeerSubscribe (WORD)0x0009
#define ORDINAL_000a_XOnlinepPeerUnsubscribe (WORD)0x000a
#define ORDINAL_0600_XOnlinepSetUserSettings2 (WORD)0x0600
#define ORDINAL_0008_XPresenceGetLocalSession (WORD)0x0008
#define ORDINAL_0007_XPresenceGetPeerSession (WORD)0x0007
#define ORDINAL_000c_XPresenceGetState (WORD)0x000c
#define ORDINAL_0002_XPresenceSendAlives (WORD)0x0002
#define ORDINAL_000f_XPresenceSendDeadUsers (WORD)0x000f
#define ORDINAL_0004_XPresenceSetState (WORD)0x0004
#define ORDINAL_0005_XPresenceUpdateStateFlags (WORD)0x0005
#define ORDINAL_0d01_XResolveName (WORD)0x0d01
#define ORDINAL_0c02_XSignatureCheckRevocation (WORD)0x0c02
#define ORDINAL_0c01_XSignatureVerify (WORD)0x0c01
#define ORDINAL_0e04_XStorageDeleteWorker (WORD)0x0e04
#define ORDINAL_0e10_XStorageDownloadToDirectoryInternal (WORD)0x0e10
#define ORDINAL_0e01_XStorageDownloadWorker (WORD)0x0e01
#define ORDINAL_0e03_XStorageEnumerateWorker (WORD)0x0e03
#define ORDINAL_0e12_XStorageUploadFromDirectoryInternal (WORD)0x0e12
#define ORDINAL_0e02_XStorageUploadWorker (WORD)0x0e02
#define ORDINAL_0802_XStringLookup (WORD)0x0802
#define ORDINAL_0952_XUpdateDownload (WORD)0x0952
#define ORDINAL_0951_XUpdateGetReferral (WORD)0x0951
#define ORDINAL_0b00_XUserAddAffiliate (WORD)0x0b00
#define ORDINAL_1003_XUserEnumerateReceivedReviews (WORD)0x1003
#define ORDINAL_1002_XUserEnumerateSentReviews (WORD)0x1002
#define ORDINAL_0a02_XUserFindUser (WORD)0x0a02
#define ORDINAL_1004_XUserGetAggregateReviews (WORD)0x1004
#define ORDINAL_0b01_XUserIsAffiliate (WORD)0x0b01
#define ORDINAL_0b02_XUserQueryAffiliate (WORD)0x0b02
#define ORDINAL_1005_XUserSubmitComplaint (WORD)0x1005
#define ORDINAL_1001_XUserSubmitPlayerReview (WORD)0x1001
#define ORDINAL_0621__XAccountAcceptTermsOfUse (WORD)0x0621
#define ORDINAL_061f__XAccountAcknowledgeDowngrade (WORD)0x061f
#define ORDINAL_060c__XAccountAddPaymentInstrument (WORD)0x060c
#define ORDINAL_061a__XAccountChangeGamertag (WORD)0x061a
#define ORDINAL_061c__XAccountChangeSubscriptionPaymentInstrument (WORD)0x061c
#define ORDINAL_061b__XAccountCreateLiveAccount (WORD)0x061b
#define ORDINAL_060a__XAccountCreateLiveAccountOld (WORD)0x060a
#define ORDINAL_0611__XAccountGetAccountInfo (WORD)0x0611
#define ORDINAL_0627__XAccountGetAccountInfoFromPassport (WORD)0x0627
#define ORDINAL_060e__XAccountGetLinkedGamertag (WORD)0x060e
#define ORDINAL_060b__XAccountGetPaymentInstruments (WORD)0x060b
#define ORDINAL_0602__XAccountGetPointsBalance (WORD)0x0602
#define ORDINAL_0614__XAccountGetPostalCode (WORD)0x0614
#define ORDINAL_0604__XAccountGetUserInfo (WORD)0x0604
#define ORDINAL_0616__XAccountGetUserSubscriptionDetails (WORD)0x0616
#define ORDINAL_0624__XAccountGetUserType (WORD)0x0624
#define ORDINAL_0625__XAccountLinkXbox1Account (WORD)0x0625
#define ORDINAL_0618__XAccountMigrateXbox1User (WORD)0x0618
#define ORDINAL_0626__XAccountMigrateXboxComUser (WORD)0x0626
#define ORDINAL_0620__XAccountQuery (WORD)0x0620
#define ORDINAL_0605__XAccountRecoverAccount (WORD)0x0605
#define ORDINAL_060d__XAccountRemovePaymentInstrument (WORD)0x060d
#define ORDINAL_0619__XAccountReserveGamertag (WORD)0x0619
#define ORDINAL_0610__XAccountSetAccountInfo (WORD)0x0610
#define ORDINAL_0622__XAccountSetStatus (WORD)0x0622
#define ORDINAL_061e__XAccountTroubleshoot (WORD)0x061e
#define ORDINAL_0601__XAccountUpdateParentalControls (WORD)0x0601
#define ORDINAL_0615__XAccountUpdatePaymentInstrument (WORD)0x0615
#define ORDINAL_0623__XAccountVerifyBillingInfo (WORD)0x0623
#define ORDINAL_0617__XAccountVerifyBillingToken (WORD)0x0617
#define ORDINAL_061d__XAccountVerifyParentCreditCard (WORD)0x061d
#define ORDINAL_0909__XBannerGetHotList (WORD)0x0909
#define ORDINAL_0908__XBannerGetList (WORD)0x0908
#define ORDINAL_0902__XOfferingContentAvailable (WORD)0x0902
#define ORDINAL_0901__XOfferingContentDetails (WORD)0x0901
#define ORDINAL_0900__XOfferingContentEnumerate (WORD)0x0900
#define ORDINAL_0912__XOfferingEnumerateGenres (WORD)0x0912
#define ORDINAL_0911__XOfferingEnumerateTitlesByFilter (WORD)0x0911
#define ORDINAL_0910__XOfferingGetTitleDetails (WORD)0x0910
#define ORDINAL_0903__XOfferingInternalUpdateAccessTimes (WORD)0x0903
#define ORDINAL_0906__XOfferingPurchase (WORD)0x0906
#define ORDINAL_0907__XOfferingPurchaseGamertag (WORD)0x0907
#define ORDINAL_0905__XOfferingSubscriptionDetails (WORD)0x0905
#define ORDINAL_0904__XOfferingSubscriptionEnumerate (WORD)0x0904
#define ORDINAL_0f00__XOnlineArbitrationRegister (WORD)0x0f00
#define ORDINAL_0f02__XOnlineArbitrationReportResult (WORD)0x0f02
#define ORDINAL_0f01__XOnlineArbitrationTimeExtend (WORD)0x0f01
#define ORDINAL_070e__XOnlineStatsEnumerateByRank (WORD)0x070e
#define ORDINAL_070f__XOnlineStatsEnumerateByRating (WORD)0x070f
#define ORDINAL_070d__XOnlineStatsEnumerateByXuid (WORD)0x070d
#define ORDINAL_0705__XOnlineStatsPost (WORD)0x0705
#define ORDINAL_0703__XOnlineStatsRead (WORD)0x0703
#define ORDINAL_0706__XOnlineStatsReset (WORD)0x0706
#define ORDINAL_0609__XPassportChangePasswordInternal (WORD)0x0609
#define ORDINAL_0607__XPassportCreateInternal (WORD)0x0607
#define ORDINAL_0606__XPassportGetEncryptedProxyParameters (WORD)0x0606
#define ORDINAL_0613__XPassportGetMemberName (WORD)0x0613
#define ORDINAL_060f__XPassportGetSecretQuestions (WORD)0x060f
#define ORDINAL_0612__XPassportGetUserData (WORD)0x0612
#define ORDINAL_0608__XPassportLoginInternal (WORD)0x0608
#define ORDINAL_0709__XProfileClearTitle (WORD)0x0709
#define ORDINAL_070b__XProfileEnumAchievements (WORD)0x070b
#define ORDINAL_0708__XProfileEnumTitles (WORD)0x0708
#define ORDINAL_0711__XProfileReadOnlineSettings (WORD)0x0711
#define ORDINAL_070a__XProfileSyncAchievements (WORD)0x070a
#define ORDINAL_0710__XProfileSyncOnlineSettings (WORD)0x0710
#define ORDINAL_0707__XProfileSyncTitles (WORD)0x0707
#define X_ATTRIBUTE_DATATYPE_MASK 0x00f00000
#define X_ATTRIBUTE_DATATYPE_INTEGER 0x00000000
#define X_ATTRIBUTE_DATATYPE_STRING 0x00100000
#define X_ATTRIBUTE_DATATYPE_BLOB 0x00200000
#define X_MAX_STRING_ATTRIBUTE_LEN 400
#define X_MAX_BLOB_ATTRIBUTE_LEN 800
#define XONLINE_MATCH_MAX_ATTRIBUTES 64
#define XONLINE_MATCH_MAX_SEARCH_RESULTS 50
#define MAX_GAMERTAG_SIZE 16
#define MAX_FRIENDS 100
#define MAX_MUTELISTUSERS 250
#define NOTIF_NUM_NOTIFICATIONS 12
#define NOTIF_MAX_QVAL 16
#define NOTIF_MAX_TITLE_STATE_BYTES 8
#define NOTIF_MAX_NICKNAME_BYTES 24
#define NOTIF_MAX_RICH_PRESENCE_BYTES 128
#define MAX_TITLE_STATE_BYTES 256
#define PQUEUE_BUDDY_REQ 0
#define PQUEUE_LIST_CHANGE 1
#define PQUEUE_PRESENCE 2
#define PQUEUE_INVITE 3
#define PQUEUE_INVITE_ANSWER 4
#define PQUEUE_PEER_PRESENCE 6
#define PQUEUE_PRESENCE_2 7
#define PQUEUE_LOCAL_INVITED 16
#define PQUEUE_LOCAL_INVITE_ANSWERED 17
#define PQUEUE_LOCAL_INVITE_REVOKED 18
#define XONLINE_MAX_PARENTAL_CONTROL_SOURCE_NAME_LENGTH 100
#define MAX_FIRSTNAME_SIZE 64
#define MAX_LASTNAME_SIZE 64
#define MAX_EMAIL_SIZE 129
#define MAX_PHONE_PREFIX_SIZE 12
#define MAX_PHONE_NUMBER_SIZE 12
#define MAX_PHONE_EXTENSION_SIZE 12
#define MAX_STREET_SIZE 128
#define MAX_CITY_SIZE 64
#define MAX_DISTRICT_SIZE 64
#define MAX_STATE_SIZE 64
#define MAX_POSTALCODE_SIZE 16
#define MAX_CC_NAME_SIZE 64
#define MAX_CC_NUMBER_SIZE 24
#define MAX_CC_CCV_NUMBER_SIZE 4
#define MAX_DD_NAME_SIZE 64
#define MAX_DD_NUMBER_SIZE 24
#define MAX_DD_BANK_CODE_SIZE 64
#define MAX_DD_BRANCH_CODE_SIZE 64
#define MAX_DD_CHECK_DIGITS_SIZE 64
#define MAX_TOKEN_SIZE 26
#define MAX_INSTANCE_ID_LENGTH 17
#define XONLINE_USERDOMAIN_SIZE 20
#define XONLINE_REALM_NAME_SIZE 24
#define XONLINE_KEY_LENGTH 16
#define XONLINE_PASSPORT_MEMBER_NAME_MAX_LEN 113
#define XONLINE_PASSPORT_SECRET_QUESTION_MIN_LEN 5
#define XONLINE_PASSPORT_SECRET_QUESTION_MAX_LEN 64
#define XONLINE_PASSPORT_LOGIN_TOKEN_REQUEST_MAX_LEN 2000
#define XONLINE_PASSPORT_PUBLIC_KEY_MODULUS_MAX_LEN 128
#define XONLINE_PASSPORT_ENCRYPTED_PASSWORD_MAX_LEN 384
#define XONLINE_PASSPORT_ENCRYPTED_SESSION_KEY_MAX_LEN 128
#define XONLINE_PASSPORT_SECRET_QUESTION_MAX_COUNT 10
#define XONLINE_XUACS_MAX_PAYMENT_INSTRUMENTS 10
#define XONLINE_XUACS_MAX_POSTAL_CODE_MATCHES 20
#define XONLINE_XUACS_MAX_SUBSCRIPTION_DESCRIPTION_LENGTH 500
#define XONLINE_XUACS_MAX_SUBSCRIPTION_FRIENDLY_NAME_LENGTH 50
#define XONLINE_XUACS_MAX_ISO_CODE_LENGTH 3
#define XONLINE_XUACS_MAX_FORMATTED_PRICE_LENGTH 20
#define XONLINE_XBOS_MAX_OFFER_PRICE_TEXT_LENGTH 50
#define XONLINE_XBOS_MAX_OFFER_NAME_LENGTH 100
#define XONLINE_XBOS_MAX_PRICES_PER_OFFER 10
#define XONLINE_XBOS_MAX_OFFERS_ENUMERATED 100
#define XONLINE_XBOS_MAX_TITLES_ENUMERATED 100
#define XONLINE_XBOS_MAX_OFFER_SELL_TEXT_LENGTH 1000
#define XONLINE_XBOS_MAX_TITLE_NAME_LENGTH 100
#define XONLINE_CONTENT_ID_LEN 20
#define XONLINE_XBOS_MAX_TITLE_TITLE_LENGTH 60
#define XONLINE_XBOS_MAX_TITLE_SELL_TEXT_LENGTH 1000
#define XONLINE_XBOS_MAX_TITLE_DEVELOPER_LENGTH 60
#define XONLINE_XBOS_MAX_TITLE_PUBLISHER_LENGTH 60
#define XONLINE_XBOS_MAX_TITLE_GENRE_LENGTH 60
#define XONLINE_XBOS_MAX_GENRE_NAME_LENGTH 255
#define XONLINE_XBOS_MAX_GENRES_ENUMERATED 50
#define XONLINE_BANNER_MAX_COUNT 128
#define XONLINE_BANNER_MAX_PATH 128
#define XONLINE_BANNER_MAX_TITLE_NAME 200
#define XONLINE_BANNER_MAX_OFFER_NAME 200
#define XONLINE_QUERY_MAX_ATTRIBUTES 32
#define XONLINE_QUERY_MAX_STRING_ATTRIBUTE_LEN 128
#define XONLINE_QUERY_MAX_BLOB_ATTRIBUTE_LEN 128
#define XONLINE_QUERY_MAX_FIND_NUM_ENTITYIDS 10
#define XONLINE_MAX_TEAM_COUNT 8
#define XONLINE_MAX_TEAM_MEMBER_COUNT 64
#define XONLINE_MAX_TEAM_NAME_SIZE 16
#define XONLINE_MAX_TEAM_DESCRIPTION_SIZE 256
#define XONLINE_MAX_TEAM_MOTTO_SIZE 256
#define XONLINE_MAX_TEAM_URL_SIZE 256
#define XONLINE_MAX_TEAM_NAME_BYTES 32
#define XONLINE_MAX_TEAM_DESCRIPTION_BYTES 512
#define XONLINE_MAX_TEAM_MOTTO_BYTES 512
#define XONLINE_MAX_TEAM_URL_BYTES 512
#define XONLINE_MAX_TEAM_DATA_SIZE 100
#define XONLINE_MAX_TEAM_MEMBER_DATA_SIZE 100
#define XPROFILE_SETTING_MAX_COUNT 32
#define XPROFILE_SETTING_MAX_READ_USERS 16
#define XPROFILE_SETTING_MAX_RETURN_SETTINGS 512
#define XPROFILE_MAX_SYNC_SETTINGS_REQUEST 32
#define XPROFILE_MAX_SYNC_SETTINGS_RESULTS 128
#define XPROFILE_SETTING_MAX_SIZE 1000
#define XONLINE_STAT_ATTRS_IN_SPEC 64
#define XONLINE_STAT_MAX_PROCEDURE_COUNT 100
#define XONLINE_STAT_MAX_PARAM_COUNT 256
#define XONLINE_STAT_MAX_SPECS 64
#define XONLINE_MAX_STATS_USER_COUNT 101
#define XONLINE_MAX_STATS_ROW_COUNT 100
#define XSTAT_PROC_DATA_TYPE_NULL 0
#define XSTAT_PROC_DATA_TYPE_INT8 1
#define XSTAT_PROC_DATA_TYPE_INT16 2
#define XSTAT_PROC_DATA_TYPE_INT32 3
#define XSTAT_PROC_DATA_TYPE_INT64 4
#define XSTAT_PROC_DATA_TYPE_DOUBLE 5
#define XSTAT_PROC_DATA_TYPE_PUID 7
#define XPROFILE_MAX_TITLE_NAME_LEN 23
#define XPROFILE_MAX_SYNC_TITLES_REQUEST 32
#define XPROFILE_MAX_SYNC_TITLES_RESULTS 32
#define XPROFILE_MAX_ENUM_TITLE 32
#define XPROFILE_MAX_REPLACE_IDS 10
#define XPROFILE_MAX_NEXT_IDS 10
#define XPROFILE_MAX_ACHIEVEMENT_NAME_LEN 32
#define XPROFILE_MAX_ACHIEVEMENT_DESC_LEN 100
#define XPROFILE_MAX_ACHIEVEMENT_HOWTO_LEN 100
#define XPROFILE_MAX_SYNC_ACHIEVEMENTS_REQUEST 32
#define XPROFILE_MAX_SYNC_ACHIEVEMENTS_RESULTS 32
#define XPROFILE_MAX_ENUM_ACHIEVEMENTS 200
#define XMSG_MAX_NUM_MESSAGES 125
#define XMSG_MAX_PROPS 256
#define XMSG_MAX_DETAILS 4096
#define XONLINE_LIVE_SIGNATURE_SIZE 100
#define XSIGNATURE_MAX_SIGNATURES_TO_VERIFY 1
#define XSIGNATURE_MAX_CONTENT_TUPLES 32
#define XONLINE_MAX_PATHNAME_DOMAIN_LENGTH 63
#define XSTORAGE_MAX_SIGNATURE_SIZE 20
#define XSTORAGE_MAX_ATTRIBUTES_SIZE 256
#define XSTORAGE_DOWNLOAD_WORKER_EXTRA_OBJECT_SIZE 256
#define XSTORAGE_UPLOAD_WORKER_EXTRA_OBJECT_SIZE 256
#define XSTORAGE_MISC_WORKER_EXTRA_OBJECT_SIZE 256
#define XSTORAGE_MAX_DISPLAYNAME 128
#define XSTORAGE_DOWNLOAD_TO_DIRECTORY_EXTRA_OBJECT_SIZE_INTERNAL 200000
#define XSTORAGE_UPLOAD_FROM_DIRECTORY_EXTRA_OBJECT_SIZE 80000
#define XMESSAGE_SEND_EXTRA_OBJECT_SIZE 1500
#define XMESSAGE_DOWNLOAD_ATTACH_TO_MEM_EXTRA_OBJECT_SIZE 1024
#define XFRIENDS_REQUEST_EXTRA_OBJECT_SIZE 1500
#define XREFERRAL_MAX_URL_SIZE 500
#define XCONTENT_REFERRAL_MAX_URL_COUNT 10
#define XCONTENT_MAX_PATH 256
#define XCONTENT_HEADER_MAX_SIZE 2048
#define XCONTENT_DOWNLOAD_EXTRA_OBJECT_SIZE 250000
#define XUPDATE_DOWNLOAD_EXTRA_OBJECT_SIZE 250000
#define XARB_MAX_REGISTRANTS_IN_SESSION 64
#define XARB_MAX_USERS_IN_SESSION 4
#define XARB_MAX_SUSPICIOUS_INFO_MESSAGE_LENGTH 256
#define XARB_MAX_COMP_BUNDLE_BYTES 0
#define FB_REVIEW_MAX_TYPE 10
#define XFB_MAX_ENUM_REVIEW_RESULTS 100
#define XFB_MAX_AGG_REVIEW_RESULTS FB_REVIEW_MAX_TYPE
//
// Note: these must be kept in sync with the same list in
// xonline\main\private\common\genx\xon\inc\xonline.x:
//
#define XONLINE_FRIENDSTATE_ENUM_RESERVED1 0x00030000
#define XONLINE_FRIENDSTATE_ENUM_RESERVED2 0x00040000
#define XONLINE_FRIENDSTATE_ENUM_RESERVED3 0x00050000
#define XONLINE_FRIENDSTATE_ENUM_RESERVED4 0x00060000
C_ASSERT(XONLINE_MAX_LOGON_USERS == XUSER_MAX_COUNT);
C_ASSERT(XONLINE_GAMERTAG_SIZE == XUSER_NAME_SIZE);
#define DASH_TITLE_ID 0xFFFE0000
#define XENON_DASH_TITLE_ID 0xFFFE07D1
// ====================================================================
// Logon related
//
#define XONLINE_S_LOGON_USER_MESSAGE_ENUMERATION_NEEDED _HRESULT_TYPEDEF_(0x001512F1L)
XAMINLINE
BOOL
XNetLogonTitleIDIsSamePublisher(
IN DWORD dwServiceID,
IN DWORD dwTitleID
)
{
return HIWORD(dwTitleID) == HIWORD(XNetLogonGetTitleID(dwServiceID));
}
// ====================================================================
// XOnline Task Throttling
//
#define XONLINE_THROTTLE_FLAG_DELAY 0x00000001 // delay starting each new operation until the throttle delay period expires, must always be specified for Xenon
#define XONLINE_THROTTLE_FLAG_FAIL 0x00000002 // return XONLINE_E_TASK_THROTTLED for new tasks that are started during the throttle delay period
#define XONLINE_THROTTLE_FLAG_CANCEL_PREVIOUS 0x00000004 // force the previous task of the same type to fail with XONLINE_E_TASK_ABORTED_BY_DUPLICATE when possible
#define XONLINE_THROTTLE_FLAG_RIP 0x00000008 // RIP in debug, not supported on Xenon
#define XONLINE_THROTTLE_FLAG_IGNORE_SERVER 0x00000010 // ignore any changes in the delay or flags that the server requests, debug/devkit only
#define XONLINE_THROTTLE_FLAG_FROM_END 0x00000020 // throttle time is enforced from when the last task finished instead of started, not supported on Xbox 1
#define XONLINE_VALID_THROTTLE_FLAGS (XONLINE_THROTTLE_FLAG_DELAY | \
XONLINE_THROTTLE_FLAG_FAIL | \
XONLINE_THROTTLE_FLAG_CANCEL_PREVIOUS | \
XONLINE_THROTTLE_FLAG_RIP | \
XONLINE_THROTTLE_FLAG_IGNORE_SERVER | \
XONLINE_THROTTLE_FLAG_FROM_END)
typedef struct _XONLINE_REQUEST_THROTTLE_SETTINGS
{
DWORD dwThrottleDelayMs; // delay enforced between tasks, in milliseconds
DWORD dwThrottleFlags; // throttle flags in use, see XONLINE_THROTTLE_FLAG_xxx
} XONLINE_REQUEST_THROTTLE_SETTINGS, *PXONLINE_REQUEST_THROTTLE_SETTINGS;
// ====================================================================
// XOnline Matchmaking
//
typedef enum
{
MATCH_OP_CREATE = 0,
MATCH_OP_SEARCH,
MATCH_OP_INVALID
} MATCH_OP;
#define DW_LEN_HTTP_RESP_HDR 200
#define DW_LEN_SENDBUFFER (400 + DW_LEN_HTTP_RESP_HDR)
#define X_ATTRIBUTE_TYPE_MASK 0x0F000000
#define X_ATTRIBUTE_TYPE_SESSION 0x00000000
#define X_ATTRIBUTE_TYPE_PARAM 0x02000000
#define X_ATTRIBUTE_TYPE_BUILTIN 0x03000000
#define X_ATTRIBUTE_TYPE_CONSTANT 0x05000000
#define X_ATTRIBUTE_RESERVED ~(X_ATTRIBUTE_SCOPE_MASK | \
X_ATTRIBUTE_DATATYPE_MASK | \
X_ATTRIBUTE_TYPE_MASK | \
X_ATTRIBUTE_ID_MASK)
// NOTE: Changing these values impacts both the client and the server.
#define X_MATCH_MAX_QUERY_PARAMS 20
#define X_MATCH_MAX_QUERY_RESULTS 50
#define X_MATCH_MAX_TITLE_SCHEMA_ATTRS 40
#define X_MATCH_MAX_ATTRIBUTE_DATA 4096
#define X_ATTRIBUTE_SCOPE_MASK 0x80000000
#define X_ATTRIBUTE_SCOPE_GLOBAL 0x80000000
#define X_ATTRIBUTE_RESERVED1_MASK 0x70000000
#define X_ATTRIBUTE_RESERVED2_MASK 0x000F0000
#define X_ATTRIBUTE_RESERVED3_MASK 0x0F000000
#define X_MATCH_PROTOCOL_VERSION 0x01000000 // 1.0.0000
#define X_MIN_SEARCH_RESULT_COLUMNS 8
//
// Reserved title search sproc indices
//
#define X_SSINDEX_GET_SESSION (DWORD)-1 // special sproc to retrieve session by session id
#define XMATCH_QUERYID_FLAG_SUMMARY_QUERY 0x80000000
#define XMATCH_QUERYID_FLAG_RESERVED 0x7FFF0000
//
// This structure defines a session. When used on the client, will be
// included in a larger structure pre-pended with an async task struct.
// The following structure is identical to the host advertisement wire
// protocol.
// The raw data for session title, application data and attributes will
// typically follow this structure in the same area of memory, and on the
// wire.
//
typedef struct _XMATCH_SESSION
{
DWORD dwMessageLength;
XNKID SessionID;
DWORD dwTitleID;
XNADDR HostAddress;
DWORD dwPublicOpen;
DWORD dwPrivateOpen;
DWORD dwPublicFilled;
DWORD dwPrivateFilled;
DWORD dwNumAttributes;
} XMATCH_SESSION, *PXMATCH_SESSION;
//
// This structure is passed up to delete a session.
//
typedef struct _XMATCH_SESSION_DELETE
{
DWORD dwMessageLength;
XNKID SessionID;
DWORD dwTitleID;
} XMATCH_SESSION_DELETE, *PXMATCH_SESSION_DELETE;
//
// This structure defines the information passed to the server
// to initiate a search for a game session.
//
#define XONLINE_MATCH_FLAG_NAT_TYPE_MASK 0x0003
#define XONLINE_MATCH_FLAGS_RESERVED 0xFFFC
typedef struct _XMATCH_SEARCH
{
DWORD dwMessageLength;
DWORD dwTitleID;
DWORD dwProcedureIndex;
XNADDR ClientAddress;
WORD wNumUsers;
WORD wFlags;
DWORD dwNumParameters;
} XMATCH_SEARCH, *PXMATCH_SEARCH;
// ====================================================================
// SGADDR
#pragma pack(push, 1)
typedef struct _SGADDR {
IN_ADDR inaSg; // IP address of the SG for the client
DWORD dwSpiSg; // Pseudo-random identifier assigned by the SG
ULONGLONG qwXboxID; // Unique identifier of client machine account
BYTE abReserved[4]; // Reserved (must be zero)
} SGADDR;
#pragma pack(pop)
//
// This structure is the body of dead xbox requests.
//
typedef struct _XMATCH_DEAD_XBOX
{
DWORD dwMessageLength;
SGADDR sgaddr;
DWORD dwTitleID;
DWORD dwTitleRegion;
ULONGLONG aqwUserID[XONLINE_MAX_LOGON_USERS];
} XMATCH_DEAD_XBOX, *PXMATCH_DEAD_XBOX;
//
// This structure is the body of dead SG requests.
//
typedef struct _XMATCH_DEAD_SG
{
DWORD dwMessageLength;
SGADDR sgaddr;
} XMATCH_DEAD_SG, *PXMATCH_DEAD_SG;
#pragma pack(push, 1)
// NOTE: The client doesn't use this at all
typedef struct _XMATCH_SEARCHRESULT_HEADER
{
DWORD dwMessageLength;
USHORT nNumSearchResults;
USHORT fFlags; // Unused, always zero
DWORD dwLoggingThreshold; // Unused, always zero
} XMATCH_SEARCHRESULT_HEADER, *PXMATCH_SEARCHRESULT_HEADER;
typedef struct _XMATCH_SEARCHRESULT
{
DWORD dwResultLength;
XNKID SessionID;
XNADDR HostAddress;
XNKEY KeyExchangeKey;
DWORD dwPublicOpen;
DWORD dwPrivateOpen;
DWORD dwPublicFilled;
DWORD dwPrivateFilled;
DWORD dwNumAttributes;
} XMATCH_SEARCHRESULT, *PXMATCH_SEARCHRESULT;
#pragma pack(pop)
//
// Notifications
//
typedef enum P_MSG_TYPES
{
// Incoming messages
PMSG_MIN_REQ_TYPE = 1000,
PMSG_HELLO = 1000,
PMSG_ALIVE = 1001,
PMSG_SYNC = 1002,
PMSG_REFRESH = 1003,
PMSG_ADD = 1004,
PMSG_DELETE = 1005,
PMSG_ACCEPT = 1006,
PMSG_REJECT = 1007,
PMSG_BLOCK = 1008,
PMSG_UNBLOCK = 1009,
PMSG_INVITE = 1010,
PMSG_CANCEL = 1011,
PMSG_INVITE_ANSWER = 1012,
PMSG_NICKNAME = 1013,
PMSG_STATE = 1014,
PMSG_DEAD_XBOX = 1015,
PMSG_DEAD_SG = 1016,
PMSG_ANNOUNCE = 1017,
PMSG_SUBSCRIBED = 1018,
PMSG_UNSUBSCRIBE = 1019,
PMSG_ADDED = 1020,
PMSG_ACCEPTED = 1021,
PMSG_REMOVED = 1022,
PMSG_KICK = 1023,
PMSG_DEAD_USER = 1024,
PMSG_ALIVE_2 = 1025,
PMSG_WEB_FRIENDS = 1026,
PMSG_WEB_ALIVE = 1027,
PMSG_WEB_ANNOUNCE = 1028,
PMSG_WEB_SUBSCRIBED = 1029,
PMSG_WEB_UNSUBSCRIBE = 1030,
PMSG_PEER_SESSION = 1031,
PMSG_TEAM_LIST_TEAMS = 1032,
PMSG_TEAM_LIST_MEMBERS = 1033,
PMSG_TEAM_CREATE = 1034,
PMSG_TEAM_DELETE = 1035,
PMSG_TEAM_REMOVE = 1036,
PMSG_TEAM_MANAGE_TEAM = 1037,
PMSG_TEAM_MANAGE_MEMBER = 1038,
PMSG_TEAM_RECRUIT = 1039,
PMSG_TEAM_JOIN = 1040,
PMSG_TEAM_GET_TICKET = 1041,
PMSG_PEER_SUBSCRIBE = 1042,
PMSG_PEER_UNSUBSCRIBE = 1043,
PMSG_WATCH_START = 1044,
PMSG_WATCH_STOP = 1045,
PMSG_ADD_2 = 1046,
PMSG_INVITE_2 = 1047,
PMSG_ALIVE_INTERNAL = 1048,
PMSG_STATE_2 = 1049,
PMSG_GET_STATE = 1050,
PMSG_TEAM_CREATE_XE = 1051,
PMSG_TEAM_MANAGE_TEAM_XE = 1052,
PMSG_ADD_AFFILIATES = 1053,
PMSG_IS_AFFILIATE = 1054,
PMSG_QUERY_AFFILIATES = 1055,
PMSG_GET_PRESENCE_INFO = 1056,
PMSG_PRESENCE_INFO_REPLY = 1057,
PMSG_INVALIDATE_USER = 1058,
PMSG_FIND_USER = 1059,
PMSG_CHECK_TITLE_MESSAGES = 1060,
PMSG_TEAM_LIST_USER_TEAMS = 1061,
PMSG_MAX_REQ_TYPE = 1061,
// Outgoing messages
PMSG_MIN_REPLY_TYPE = 1101,
PMSG_ALIVE_REPLY = 1101,
PMSG_SYNC_REPLY = 1102,
PMSG_WEB_FRIENDS_REPLY = 1103,
PMSG_WEB_ALIVE_REPLY = 1104,
PMSG_PEER_SESSION_REPLY = 1105,
PMSG_INVITE_REPLY = 1106,
PMSG_TEAM_LIST_TEAMS_REPLY = 1107,
PMSG_TEAM_LIST_MEMBERS_REPLY = 1108,
PMSG_TEAM_CREATE_REPLY = 1109,
PMSG_TEAM_DELETE_REPLY = 1110,
PMSG_TEAM_REMOVE_REPLY = 1111,
PMSG_TEAM_MANAGE_TEAM_REPLY = 1112,
PMSG_TEAM_MANAGE_MEMBER_REPLY = 1113,
PMSG_TEAM_RECRUIT_REPLY = 1114,
PMSG_TEAM_JOIN_REPLY = 1115,
PMSG_TEAM_GET_TICKET_REPLY = 1116,
PMSG_PEER_SUBSCRIBE_REPLY = 1117,
PMSG_PEER_UNSUBSCRIBE_REPLY = 1118,
PMSG_GET_STATE_REPLY = 1119,
PMSG_IS_AFFILIATE_REPLY = 1120,
PMSG_QUERY_AFFILIATES_REPLY = 1121,
PMSG_FIND_USER_REPLY = 1122,
PMSG_CHECK_TITLE_MESSAGES_REPLY = 1123,
PMSG_TEAM_LIST_USER_TEAMS_REPLY = 1124,
PMSG_MAX_REPLY_TYPE = 1124
};
#define P_STATE_MASK_NONE 0x0000
#define P_STATE_MASK_ONLINE 0x0001 // Set if online
#define P_STATE_MASK_PLAYING 0x0002 // Set if playing a game
#define P_STATE_MASK_CLOAKED 0x0004 // Set to fake being offline
#define P_STATE_MASK_VOICE 0x0008 // Set if supports voice
#define P_STATE_MASK_JOINABLE 0x0010 // Set if session is joinable
#define P_STATE_MASK_GUESTS 0x0060
#define P_STATE_MASK_RESERVED0 0x0080
#define P_STATE_MASK_SENTREQUEST 0x40000000
#define P_STATE_MASK_RECEIVEDREQUEST 0x80000000
#define P_BUDDY_STATUS_OK 0 // Mutualy accepted buddy
#define P_BUDDY_STATUS_PENDING 1 // Buddy request pending accetance
#define P_BUDDY_STATUS_REQUEST 2 // Buddy request to accept or reject
// Internal cloaked state
#define XONLINE_FRIENDSTATE_FLAG_CLOAKED 0x00000004
// Used by all Presence and Notification protocols that accept an answer member
typedef enum P_INVITE_REPLIES
{
PINVITE_REPLY_NO = 0,
PINVITE_REPLY_YES = 1,
PINVITE_REPLY_NEVER = 2
};
typedef enum Q_MSG_TYPES
{
//
// Incoming messages
//
QMSG_MIN_REQ_TYPE = 0,
QMSG_HELLO = 0,
QMSG_USER_INFO = 1,
QMSG_ADD = 2,
QMSG_DELETE = 3,
QMSG_DELETE_MATCHES = 4,
QMSG_DEAD_XBOX = 5,
QMSG_DEAD_SG = 6,
QMSG_LIST = 7,
QMSG_DEQUEUE = 8,
QMSG_DEAD_USER = 9,
QMSG_WEB_USER_INFO = 10,
QMSG_WEB_PRESENCE = 11,
QMSG_WEB_LIST = 12,
QMSG_ENUM_MESSAGES = 13,
QMSG_MESSAGE_SUMMARY = 14,
QMSG_MESSAGE_DETAILS = 15,
QMSG_DELETE_MESSAGE = 16,
QMSG_SEND_MESSAGE = 17,
QMSG_REVOKE_MESSAGE = 18,
QMSG_DELETE_TITLE = 19,
QMSG_ENUM_TITLES = 20,
QMSG_MESSAGE_FLAGS = 21,
QMSG_ENUM_SYSTEM_MESSAGES = 22,
QMSG_SYSTEM_MESSAGE_DETAILS = 23,
QMSG_DELETE_SYSTEM_MESSAGE = 24,
QMSG_SEND_SYSTEM_MESSAGE = 25,
QMSG_REVOKE_MESSAGE_EX = 26,
QMSG_ENUM_MESSAGES_2 = 27,
QMSG_MESSAGE_SUMMARY_2 = 28,
QMSG_MAX_REQ_TYPE = 28,
//
// Outgoing messages
//
QMSG_MIN_REPLY_TYPE = 100,
QMSG_LIST_REPLY = 100,
QMSG_WEB_LIST_REPLY = 101,
QMSG_ENUM_MESSAGES_REPLY = 102,
QMSG_MESSAGE_SUMMARY_REPLY = 103,
QMSG_MESSAGE_DETAILS_REPLY = 104,
QMSG_DELETE_MESSAGE_REPLY = 105,
QMSG_SEND_MESSAGE_REPLY = 106,
QMSG_REVOKE_MESSAGE_REPLY = 107,
QMSG_DELETE_TITLE_REPLY = 108,
QMSG_ENUM_TITLES_REPLY = 109,
QMSG_MESSAGE_FLAGS_REPLY = 110,
QMSG_ENUM_SYSTEM_MESSAGES_REPLY = 111,
QMSG_SYSTEM_MESSAGE_DETAILS_REPLY = 112,
QMSG_DELETE_SYSTEM_MESSAGE_REPLY = 113,
QMSG_SEND_SYSTEM_MESSAGE_REPLY = 114,
QMSG_ENUM_MESSAGES_2_REPLY = 115,
QMSG_MESSAGE_SUMMARY_2_REPLY = 116,
QMSG_MAX_REPLY_TYPE = 116
};
#define XONLINE_FRIENDSTATE_MASK_REQUESTFLAGS (XONLINE_FRIENDSTATE_FLAG_RECEIVEDREQUEST | XONLINE_FRIENDSTATE_FLAG_SENTREQUEST)
#define XONLINE_FRIENDSTATE_MASK_CLIENTFLAGS (XONLINE_FRIENDSTATE_MASK_REQUESTFLAGS | XONLINE_FRIENDSTATE_FLAG_INVITEREJECTED | XONLINE_FRIENDSTATE_FLAG_INVITEACCEPTED | XONLINE_FRIENDSTATE_FLAG_RECEIVEDINVITE | XONLINE_FRIENDSTATE_FLAG_SENTINVITE)
// Errors returned by Presence/Notification = 0x801520XX
#define XONLINE_E_NOTIFICATION_SERVER_BUSY _HRESULT_TYPEDEF_(0x80152001L)
#define XONLINE_E_NOTIFICATION_LIST_FULL _HRESULT_TYPEDEF_(0x80152002L)
#define XONLINE_E_NOTIFICATION_BLOCKED _HRESULT_TYPEDEF_(0x80152003L)
#define XONLINE_E_NOTIFICATION_FRIEND_PENDING _HRESULT_TYPEDEF_(0x80152004L)
#define XONLINE_E_NOTIFICATION_FLUSH_TICKETS _HRESULT_TYPEDEF_(0x80152005L)
#define XONLINE_E_NOTIFICATION_TOO_MANY_REQUESTS _HRESULT_TYPEDEF_(0x80152006L)
#define XONLINE_E_NOTIFICATION_USER_ALREADY_EXISTS _HRESULT_TYPEDEF_(0x80152007L)
#define XONLINE_E_NOTIFICATION_USER_NOT_FOUND _HRESULT_TYPEDEF_(0x80152008L)
#define XONLINE_E_NOTIFICATION_OTHER_LIST_FULL _HRESULT_TYPEDEF_(0x80152009L)
#define XONLINE_E_NOTIFICATION_SELF _HRESULT_TYPEDEF_(0x8015200AL)
#define XONLINE_E_NOTIFICATION_SAME_TITLE _HRESULT_TYPEDEF_(0x8015200BL)
#define XONLINE_E_NOTIFICATION_NO_TASK _HRESULT_TYPEDEF_(0x8015200CL)
#define XONLINE_E_NOTIFICATION_NOT_INITIALIZED _HRESULT_TYPEDEF_(0x8015200DL)
#define XONLINE_E_NOTIFICATION_TOO_MANY_SUBS _HRESULT_TYPEDEF_(0x8015200EL)
#define XONLINE_S_NOTIFICATION_NO_PEER_SUBSCRIBE _HRESULT_TYPEDEF_(0x0015200EL)
// Errors returned by teams = 0x801521XX
#define XONLINE_E_TEAMS_SERVER_BUSY _HRESULT_TYPEDEF_(0x80152100L)
#define XONLINE_E_TEAMS_TEAM_FULL _HRESULT_TYPEDEF_(0x80152101L)
#define XONLINE_E_TEAMS_MEMBER_PENDING _HRESULT_TYPEDEF_(0x80152102L)
#define XONLINE_E_TEAMS_TOO_MANY_REQUESTS _HRESULT_TYPEDEF_(0x80152103L)
#define XONLINE_E_TEAMS_USER_ALREADY_EXISTS _HRESULT_TYPEDEF_(0x80152104L)
#define XONLINE_E_TEAMS_USER_NOT_FOUND _HRESULT_TYPEDEF_(0x80152105L)
#define XONLINE_E_TEAMS_USER_TEAMS_FULL _HRESULT_TYPEDEF_(0x80152106L)
#define XONLINE_E_TEAMS_SELF _HRESULT_TYPEDEF_(0x80152107L)
#define XONLINE_E_TEAMS_NO_TASK _HRESULT_TYPEDEF_(0x80152108L)
#define XONLINE_E_TEAMS_TOO_MANY_TEAMS _HRESULT_TYPEDEF_(0x80152109L)
#define XONLINE_E_TEAMS_TEAM_ALREADY_EXISTS _HRESULT_TYPEDEF_(0x8015210AL)
#define XONLINE_E_TEAMS_TEAM_NOT_FOUND _HRESULT_TYPEDEF_(0x8015210BL)
#define XONLINE_E_TEAMS_INSUFFICIENT_PRIVILEGES _HRESULT_TYPEDEF_(0x8015210CL)
#define XONLINE_E_TEAMS_NAME_CONTAINS_BAD_WORDS _HRESULT_TYPEDEF_(0x8015210DL)
#define XONLINE_E_TEAMS_DESCRIPTION_CONTAINS_BAD_WORDS _HRESULT_TYPEDEF_(0x8015210EL)
#define XONLINE_E_TEAMS_MOTTO_CONTAINS_BAD_WORDS _HRESULT_TYPEDEF_(0x8015210FL)
#define XONLINE_E_TEAMS_URL_CONTAINS_BAD_WORDS _HRESULT_TYPEDEF_(0x80152110L)
#define XONLINE_E_TEAMS_NOT_A_MEMBER _HRESULT_TYPEDEF_(0x80152111L)
#define XONLINE_E_TEAMS_NO_ADMIN _HRESULT_TYPEDEF_(0x80152112L)
// Errors returned by offering service = 0x801530XX + 0x801531XX
#define XONLINE_S_OFFERING_NEW_CONTENT _HRESULT_TYPEDEF_(0x00153101L) // new content is available
#define XONLINE_S_OFFERING_NO_NEW_CONTENT _HRESULT_TYPEDEF_(0x00153102L) // no new content is available
#define XONLINE_E_OFFERING_BAD_REQUEST _HRESULT_TYPEDEF_(0x80153001L) // server received incorrectly formatted request
#define XONLINE_E_OFFERING_INVALID_USER _HRESULT_TYPEDEF_(0x80153002L) // cannot find account for this user
#define XONLINE_E_OFFERING_INVALID_OFFER_ID _HRESULT_TYPEDEF_(0x80153003L) // offer does not exist
#define XONLINE_E_OFFERING_INELIGIBLE_FOR_OFFER _HRESULT_TYPEDEF_(0x80153004L) // )] private /title not allowed to purchase offer
#define XONLINE_E_OFFERING_OFFER_EXPIRED _HRESULT_TYPEDEF_(0x80153005L) // offer no longer available
#define XONLINE_E_OFFERING_SERVICE_UNREACHABLE _HRESULT_TYPEDEF_(0x80153006L) // apparent connectivity problems
#define XONLINE_E_OFFERING_PURCHASE_BLOCKED _HRESULT_TYPEDEF_(0x80153007L) // this user is not allowed to make purchases
#define XONLINE_E_OFFERING_PURCHASE_DENIED _HRESULT_TYPEDEF_(0x80153008L) // this user's payment is denied by billing provider
#define XONLINE_E_OFFERING_BILLING_SERVER_ERROR _HRESULT_TYPEDEF_(0x80153009L) // nonspecific billing provider error
#define XONLINE_E_OFFERING_OFFER_NOT_CANCELABLE _HRESULT_TYPEDEF_(0x8015300AL) // either this offer doesn't exist, or it's marked as un-cancelable
#define XONLINE_E_OFFERING_NOTHING_TO_CANCEL _HRESULT_TYPEDEF_(0x8015300BL) // this user doesn't have one of these anyways
#define XONLINE_E_OFFERING_ALREADY_OWN_MAX _HRESULT_TYPEDEF_(0x8015300CL) // this user already owns the maximum allowed
#define XONLINE_E_OFFERING_NO_CHARGE _HRESULT_TYPEDEF_(0x8015300DL) // this is a free offer; no purchase is necessary
#define XONLINE_E_OFFERING_PERMISSION_DENIED _HRESULT_TYPEDEF_(0x8015300EL) // permission denied
#define XONLINE_E_OFFERING_NAME_TAKEN _HRESULT_TYPEDEF_(0x8015300FL) // Name given to XOnlineVerifyNickname is taken (dosen't vet)
// DMP-specific client XBOS/XUACS HRESULTS = 0x801534XX
#define XONLINE_E_DMP_E_UNKNOWN_ERROR _HRESULT_TYPEDEF_(0x80153410L) // Generic DMP error. See server event log for specific details about what went wrong.
#define XONLINE_E_DMP_E_REQUEST_CANNOT_BE_COMPLETED _HRESULT_TYPEDEF_(0x80153411L) // The request cannot be completed due to user state. If the user is disabled then AddPromotionalBalance cannot be called upon that user.
#define XONLINE_E_DMP_E_INSUFFICIENT_BALANCE _HRESULT_TYPEDEF_(0x80153412L) // There is not sufficient balance to support this transaction
#define XONLINE_E_DMP_E_MAX_BALANCE_EXCEEDED _HRESULT_TYPEDEF_(0x80153413L) // The result point balance will exceed the policy max balance
#define XONLINE_E_DMP_E_MAX_ACQUISITION_EXCEEDED _HRESULT_TYPEDEF_(0x80153414L) // The point amount exceeds the policy max acquisition limit per transaction
#define XONLINE_E_DMP_E_MAX_CONSUMPTION_EXCEEDED _HRESULT_TYPEDEF_(0x80153415L) // The user consumption per period of time would exceed the policy limit
#define XONLINE_E_DMP_E_NO_MORE_PROMO_POINTS _HRESULT_TYPEDEF_(0x80153416L) // There are no more points to distribute for this tenant sku combination. All the promo points for this partner's promotional SKU are gone already!
#define XONLINE_E_DMP_E_PROMOTION_LIMIT_LIFE_MAX _HRESULT_TYPEDEF_(0x80153417L) // The promotional points user obtained would exceed the sku limit. There is a configurable per user limit on each promotion. The partner sets it in offer modeling time
#define XONLINE_E_DMP_E_PROMO_EXPIRED _HRESULT_TYPEDEF_(0x80153418L) // The promotional SKU has expired. The enddate for a promo is a configured limit set by the partner. If a request comes in after that configured deadline then the request is rejected
// Errors returned by xcbk service = 0x801535XX
// Errors returned by uacs service = 0x801540XX
#define XONLINE_S_ACCOUNTS_NAME_TAKEN _HRESULT_TYPEDEF_(0x00000010L)
#define XONLINE_E_ACCOUNTS_NAME_TAKEN _HRESULT_TYPEDEF_(0x80154000L)
#define XONLINE_E_ACCOUNTS_INVALID_USER _HRESULT_TYPEDEF_(0x80154002L)
#define XONLINE_E_ACCOUNTS_BAD_CREDIT_CARD _HRESULT_TYPEDEF_(0x80154003L)
#define XONLINE_E_ACCOUNTS_BAD_BILLING_ADDRESS _HRESULT_TYPEDEF_(0x80154004L)
#define XONLINE_E_ACCOUNTS_ACCOUNT_BANNED _HRESULT_TYPEDEF_(0x80154005L)
#define XONLINE_E_ACCOUNTS_PERMISSION_DENIED _HRESULT_TYPEDEF_(0x80154006L)
#define XONLINE_E_ACCOUNTS_INVALID_VOUCHER _HRESULT_TYPEDEF_(0x80154007L)
#define XONLINE_E_ACCOUNTS_DATA_CHANGED _HRESULT_TYPEDEF_(0x80154008L) // unexpected modifications made during request. commit is aborted to avoid overwriting modifcations.
#define XONLINE_E_ACCOUNTS_VOUCHER_ALREADY_USED _HRESULT_TYPEDEF_(0x80154009L)
#define XONLINE_E_ACCOUNTS_OPERATION_BLOCKED _HRESULT_TYPEDEF_(0x8015400AL)
#define XONLINE_E_ACCOUNTS_POSTAL_CODE_REQUIRED _HRESULT_TYPEDEF_(0x8015400BL)
#define XONLINE_E_ACCOUNTS_TRY_AGAIN_LATER _HRESULT_TYPEDEF_(0x8015400CL)
#define XONLINE_E_ACCOUNTS_NOT_A_RENEWAL_OFFER _HRESULT_TYPEDEF_(0x8015400DL)
#define XONLINE_E_ACCOUNTS_RENEWAL_IS_LOCKED _HRESULT_TYPEDEF_(0x8015400EL)
#define XONLINE_E_ACCOUNTS_VOUCHER_REQUIRED _HRESULT_TYPEDEF_(0x8015400FL)
#define XONLINE_E_ACCOUNTS_ALREADY_DEPROVISIONED _HRESULT_TYPEDEF_(0x80154010L)
#define XONLINE_E_ACCOUNTS_INVALID_PRIVILEGE _HRESULT_TYPEDEF_(0x80154011L)
#define XONLINE_E_ACCOUNTS_INVALID_SIGNED_PASSPORT_PUID _HRESULT_TYPEDEF_(0x80154012L)
#define XONLINE_E_ACCOUNTS_PASSPORT_ALREADY_LINKED _HRESULT_TYPEDEF_(0x80154013L)
#define XONLINE_E_ACCOUNTS_MIGRATE_NOT_XBOX1_USER _HRESULT_TYPEDEF_(0x80154014L)
#define XONLINE_E_ACCOUNTS_MIGRATE_BAD_SUBSCRIPTION _HRESULT_TYPEDEF_(0x80154015L)
#define XONLINE_E_ACCOUNTS_PASSPORT_NOT_LINKED _HRESULT_TYPEDEF_(0x80154016L)
#define XONLINE_E_ACCOUNTS_NOT_XENON_USER _HRESULT_TYPEDEF_(0x80154017L)
#define XONLINE_E_ACCOUNTS_CREDIT_CARD_REQUIRED _HRESULT_TYPEDEF_(0x80154018L)
#define XONLINE_E_ACCOUNTS_MIGRATE_NOT_XBOXCOM_USER _HRESULT_TYPEDEF_(0x80154019L)
#define XONLINE_E_ACCOUNTS_NOT_A_VOUCHER_OFFER _HRESULT_TYPEDEF_(0x8015401AL)
#define XONLINE_E_ACCOUNTS_REACHED_TRIAL_OFFER_LIMIT _HRESULT_TYPEDEF_(0x8015401BL)
#define XONLINE_E_ACCOUNTS_XBOX1_MANAGEMENT_BLOCKED _HRESULT_TYPEDEF_(0x8015401CL)
#define XONLINE_E_ACCOUNTS_OFFLINE_XUID_ALREADY_USED _HRESULT_TYPEDEF_(0x8015401DL)
#define XONLINE_E_ACCOUNTS_BILLING_PROVIDER_TIMEOUT _HRESULT_TYPEDEF_(0x8015401EL)
#define XONLINE_E_ACCOUNTS_MIGRATION_OFFER_NOT_FOUND _HRESULT_TYPEDEF_(0x8015401FL)
// Errors returned by Notification = 0x801550XX
#define XONLINE_E_NOTIFICATION_BAD_CONTENT_TYPE _HRESULT_TYPEDEF_(0x80155000L)
#define XONLINE_E_NOTIFICATION_REQUEST_TOO_SMALL _HRESULT_TYPEDEF_(0x80155001L)
#define XONLINE_E_NOTIFICATION_INVALID_MESSAGE_TYPE _HRESULT_TYPEDEF_(0x80155002L)
#define XONLINE_E_NOTIFICATION_NO_ADDRESS _HRESULT_TYPEDEF_(0x80155003L)
#define XONLINE_E_NOTIFICATION_INVALID_PUID _HRESULT_TYPEDEF_(0x80155004L)
#define XONLINE_E_NOTIFICATION_NO_CONNECTION _HRESULT_TYPEDEF_(0x80155005L)
#define XONLINE_E_NOTIFICATION_SEND_FAILED _HRESULT_TYPEDEF_(0x80155006L)
#define XONLINE_E_NOTIFICATION_RECV_FAILED _HRESULT_TYPEDEF_(0x80155007L)
#define XONLINE_E_NOTIFICATION_MESSAGE_TRUNCATED _HRESULT_TYPEDEF_(0x80155008L)
#define XONLINE_E_NOTIFICATION_INVALID_TITLE_ID _HRESULT_TYPEDEF_(0x80155009L)
#define XONLINE_E_NOTIFICATION_NO_DATA _HRESULT_TYPEDEF_(0x8015200DL)
#define XONLINE_S_NOTIFICATION_NO_PEER_SUBSCRIBE _HRESULT_TYPEDEF_(0x0015200EL)
// Errors returned by Messages = 0x80155AXX
#define XONLINE_E_MESSAGE_INVALID_MESSAGE_ID _HRESULT_TYPEDEF_(0x80155A01L) // the specified message was not found
#define XONLINE_E_MESSAGE_PROPERTY_DOWNLOAD_REQUIRED _HRESULT_TYPEDEF_(0x80155A02L) // the property was too large to fit into the details block, it must be retrieved separately using XOnlineMessageDownloadAttachmentxxx
#define XONLINE_E_MESSAGE_PROPERTY_NOT_FOUND _HRESULT_TYPEDEF_(0x80155A03L) // the specified property tag was not found
#define XONLINE_E_MESSAGE_NO_VALID_SENDS_TO_REVOKE _HRESULT_TYPEDEF_(0x80155A04L) // no valid sends to revoke were found
#define XONLINE_E_MESSAGE_NO_MESSAGE_DETAILS _HRESULT_TYPEDEF_(0x80155A05L) // the specified message does not have any details
#define XONLINE_E_MESSAGE_INVALID_TITLE_ID _HRESULT_TYPEDEF_(0x80155A06L) // an invalid title ID was specified
#define XONLINE_E_MESSAGE_SENDER_BLOCKED _HRESULT_TYPEDEF_(0x80155A07L) // a send failed because the recipient has blocked the sender
#define XONLINE_E_MESSAGE_MAX_DETAILS_SIZE_EXCEEDED _HRESULT_TYPEDEF_(0x80155A08L) // the property couldn't be added because the maximum details size would be exceeded
#define XONLINE_E_MESSAGE_INVALID_MESSAGE_TYPE _HRESULT_TYPEDEF_(0x80155A09L)
#define XONLINE_E_MESSAGE_USER_OPTED_OUT _HRESULT_TYPEDEF_(0x80155A0AL) // a send failed because the message is marketing and the recipient has opted-out for the sending title
// Success codes returned by Messages = 0x00155AXX
#define XONLINE_S_MESSAGE_PENDING_SYNC _HRESULT_TYPEDEF_(0x00155A01L) // updated message list is currently being retrieved (after logon or disabling summary refresh), returned results may be out of date
// Errors returned by uodb procs = 0x801560XX
#define XONLINE_E_UODB_KEY_ALREADY_EXISTS _HRESULT_TYPEDEF_(0x80156000L) // service key already exists when attempting to insert key
// Errors returned by billing services = 0x80162XXX - 0x8016EXXX
#define XONLINE_E_BILLING_AUTHORIZATION_FAILED _HRESULT_TYPEDEF_(0x80167611) // Credit card authorization failed; user should update credit card info in Dash.
#define XONLINE_E_BILLING_CREDIT_CARD_EXPIRED _HRESULT_TYPEDEF_(0x80167531) // The credit card has expired or will expire this month; user should update card info in Dash.
#define XONLINE_E_BILLING_NON_ACTIVE_ACCOUNT _HRESULT_TYPEDEF_(0x80169d94) // The account specified is no longer active; user should call customer service
#define XONLINE_E_BILLING_INVALID_PAYMENT_INSTRUMENT_STATUS _HRESULT_TYPEDEF_(0x80169e7f) // User's payment instrument is in a bad state. They should call customer service to rectify the issue.
// generated from xonline/private/common/mc/sps25/imperr/imperr.pl
#define XONLINE_E_BILLING_BAN_NULL_INPUT_PARAMETER _HRESULT_TYPEDEF_(0x80167594) // Null input parameter passed to a Ban API
#define XONLINE_E_BILLING_ALREADY_BANNED _HRESULT_TYPEDEF_(0x80167599) // Already banned
#define XONLINE_E_BILLING_NOT_BANNED _HRESULT_TYPEDEF_(0x8016759e) // Not banned
#define XONLINE_E_BILLING_BANNEDPERSON _HRESULT_TYPEDEF_(0x801675bc) // This account is banned
#define XONLINE_E_BILLING_COUNTRY_CURRENCY_PI_MISMATCH _HRESULT_TYPEDEF_(0x801675c1) // There is a country/currency/payment instrument type mismatch
#define XONLINE_E_BILLING_INVALID_PAYMENT_INSTRUMENT_TYPE _HRESULT_TYPEDEF_(0x801675c8) // The payment instrument type specified is invalid
#define XONLINE_E_BILLING_INVALID_CREDIT_CARD_TYPE _HRESULT_TYPEDEF_(0x801675cb) // The credit card type specified is invalid
#define XONLINE_E_BILLING_DECRYPTION_FAILURE _HRESULT_TYPEDEF_(0x801675d0) // There was a failure during decryption. Make sure data is encrypted correctly
#define XONLINE_E_BILLING_BANNED_PAYMENT_INSTRUMENT _HRESULT_TYPEDEF_(0x801675c6) // The payment instrument specified is banned.
#define XONLINE_E_BILLING_INVALID_DD_ACCOUNT _HRESULT_TYPEDEF_(0x801675e4) // Direct Debit account validation failed
#define XONLINE_E_BILLING_DD_CONCATENATED_STRING_LENGTH_EXCEEDS_24 _HRESULT_TYPEDEF_(0x801675e9) // The concatenated DD account number exceeds 24.
#define XONLINE_E_BILLING_INVALID_CREDIT_CARD_NUMBER _HRESULT_TYPEDEF_(0x80167530) // The credit card number is invalid
#define XONLINE_E_BILLING_AVS_FAILED _HRESULT_TYPEDEF_(0x8016760c) // Address verification failed
#define XONLINE_E_BILLING_PAYMENT_PROVIDER_CONNECTION_FAILED _HRESULT_TYPEDEF_(0x8016761b) // Unable to connect to payment provider
#define XONLINE_E_BILLING_DD_INVALID_COUNTRY _HRESULT_TYPEDEF_(0x8016762f) // Invalid country code.
#define XONLINE_E_BILLING_DD_INVALID_ACCOUNT_FORMAT _HRESULT_TYPEDEF_(0x80167634) // Invalid account format.
#define XONLINE_E_BILLING_DD_INVALID_BANKCODE_FORMAT _HRESULT_TYPEDEF_(0x80167639) // Invalid bank code format.
#define XONLINE_E_BILLING_DD_INVALID_BRANCHCODE_FORMAT _HRESULT_TYPEDEF_(0x8016763e) // Invalid branch code format.
#define XONLINE_E_BILLING_DD_INVALID_CHECKDIGIT_FORMAT _HRESULT_TYPEDEF_(0x80167643) // Invalid check digit format.
#define XONLINE_E_BILLING_DD_ACCOUNT_MISSING _HRESULT_TYPEDEF_(0x80167648) // account missing.
#define XONLINE_E_BILLING_DD_BANKCODE_MISSING _HRESULT_TYPEDEF_(0x8016764d) // bank code missing.
#define XONLINE_E_BILLING_DD_BRANCHCODE_MISSING _HRESULT_TYPEDEF_(0x80167652) // branch code missing.
#define XONLINE_E_BILLING_DD_CHECKDIGIT_MISSING _HRESULT_TYPEDEF_(0x80167657) // check digit missing.
#define XONLINE_E_BILLING_DD_ERROR_IN_FIELDS _HRESULT_TYPEDEF_(0x8016765c) // There are fields errors.
#define XONLINE_E_BILLING_DD_INVALID_ACCOUNT_VALUE _HRESULT_TYPEDEF_(0x80167661) // Invalid account VALUE.
#define XONLINE_E_BILLING_DD_INVALID_BANKCODE_VALUE _HRESULT_TYPEDEF_(0x80167666) // Invalid bank code VALUE.
#define XONLINE_E_BILLING_DD_INVALID_BRANCHCODE_VALUE _HRESULT_TYPEDEF_(0x8016766b) // Invalid branch code VALUE.
#define XONLINE_E_BILLING_DD_INVALID_CHECKDIGIT_VALUE _HRESULT_TYPEDEF_(0x80167670) // Invalid check digit VALUE.
#define XONLINE_E_BILLING_DD_INVALID_ACCOUNT_HOLDER_NAME _HRESULT_TYPEDEF_(0x8016767a) // A direct debit account holder name can't be longer than 35 characters.
#define XONLINE_E_BILLING_PAYMENT_PROVIDER_CONNECTION_TIMEOUT _HRESULT_TYPEDEF_(0x8016767f) // Payment provider connection timed out
#define XONLINE_E_BILLING_ALREADY_IN_SPECIFIED_STATE _HRESULT_TYPEDEF_(0x80169c41) // The object is already in the desired state.
#define XONLINE_E_BILLING_REQUIRED_FIELD_MISSING _HRESULT_TYPEDEF_(0x80169c45) // Required field missing
#define XONLINE_E_BILLING_ACTIVE_SUBSCRIPTIONS _HRESULT_TYPEDEF_(0x80169c46) // The account has subscriptions on it.
#define XONLINE_E_BILLING_INVALID_ACCOUNT_SOUCE _HRESULT_TYPEDEF_(0x80169c4d) // Account source is not valid.
#define XONLINE_E_BILLING_INVALID_CREATION_DATE _HRESULT_TYPEDEF_(0x80169c4e) // Creation date cannot be later than current time.
#define XONLINE_E_BILLING_EXCEEDING_TAX_EXEMPT_LIMITS _HRESULT_TYPEDEF_(0x80169c55) // No more tax exemptions allowed for this account.
#define XONLINE_E_BILLING_GENERATE_NEXT_ID _HRESULT_TYPEDEF_(0x80169c59) // Generating next id
#define XONLINE_E_BILLING_INVALID_STATE_FOR_COUNTRY _HRESULT_TYPEDEF_(0x80169c5f) // The specified state for the country is invalid
#define XONLINE_E_BILLING_INVALID_BILLABLE_ACCOUNT_ID _HRESULT_TYPEDEF_(0x80169cc2) // Invalid account
#define XONLINE_E_BILLING_INVALID_BILLABLE_ACCOUNT_STATUS_ID _HRESULT_TYPEDEF_(0x80169cc7) // The account status specified is invalid
#define XONLINE_E_BILLING_INVALID_PHONE_TYPE _HRESULT_TYPEDEF_(0x80169cd6) // Invalid Phone Type
#define XONLINE_E_BILLING_INVALID_OFFERING_ID _HRESULT_TYPEDEF_(0x80169ce5) // Invalid Offering was specified
#define XONLINE_E_BILLING_INVALID_COUNTRY_CODE _HRESULT_TYPEDEF_(0x80169cea) // The country code specified is not valid
#define XONLINE_E_BILLING_INVALID_ADDRESS_ID _HRESULT_TYPEDEF_(0x80169cef) // The address id specified is not valid.
#define XONLINE_E_BILLING_INVALID_PAYMENT_METHOD_ID _HRESULT_TYPEDEF_(0x80169cf9) // The payment instrument ID specified is invalid.
#define XONLINE_E_BILLING_SUBSCRIPTION_ALREADY_CANCELED _HRESULT_TYPEDEF_(0x80169d08) // The subscription has already been cancelled.
#define XONLINE_E_BILLING_INVALID_SUBSCRIPTION_ID _HRESULT_TYPEDEF_(0x80169d0d) // The subscription id specified is invalid
#define XONLINE_E_BILLING_INVALID_PERIOD_TO_PROCESS _HRESULT_TYPEDEF_(0x80169d2b) // An invalid period was specified.
#define XONLINE_E_BILLING_INVALID_SUBSCRIPTION_STATUS _HRESULT_TYPEDEF_(0x80169d3a) // An invalid subscription status was specified or the state of the specified subscription does not allow this operation.
#define XONLINE_E_BILLING_VATID_DOESNOTHAVEEXPDATE _HRESULT_TYPEDEF_(0x80169d95) // VATIDs do not have an expiration date
#define XONLINE_E_BILLING_TAXID_EXPDATE _HRESULT_TYPEDEF_(0x80169d96) // Expiration date was not specified
#define XONLINE_E_BILLING_INVALID_TAX_EXEMPT_TYPE _HRESULT_TYPEDEF_(0x80169d97) // Invalid Tax Exempt specified
#define XONLINE_E_BILLING_NO_ACTIVE_SUBSCRIPTION _HRESULT_TYPEDEF_(0x80169d99) // No active subscription for adding service instance
#define XONLINE_E_BILLING_INVALID_SERVICE_INSTANCE _HRESULT_TYPEDEF_(0x80169d9e) // Invalid service instance for adding new user
#define XONLINE_E_BILLING_ADD_USER_TO_SERVICE_INSTANCE _HRESULT_TYPEDEF_(0x80169da3) // Failed to add a new user to a service instance
#define XONLINE_E_BILLING_INVALID_BILLABLEACCTSTATUS _HRESULT_TYPEDEF_(0x80169da8) // The attempted status change operation is inappropriate
#define XONLINE_E_BILLING_SERVICE_INSTANCES_NONE _HRESULT_TYPEDEF_(0x80169dbc) // No service instances available for specified billable account
#define XONLINE_E_BILLING_ACCOUNT_CLOSED _HRESULT_TYPEDEF_(0x80169dd1) // The Account is already closed
#define XONLINE_E_BILLING_BILLINGPERIOD_PAST _HRESULT_TYPEDEF_(0x80169dd6) // This period occurs in the past
#define XONLINE_E_BILLING_INVALID_ADJUSTMENTGUID _HRESULT_TYPEDEF_(0x80169dd7) // Invalid AdjustmentGUID
#define XONLINE_E_BILLING_INVALID_ADJUSMENT_FOR_PERIOD _HRESULT_TYPEDEF_(0x80169dd8) // This Adjustment not applicable to the specified period
#define XONLINE_E_BILLING_ADJUSTMENT_TOOBIG _HRESULT_TYPEDEF_(0x80169dd9) // Adjustment amount is too big
#define XONLINE_E_BILLING_ADJUSTMENT_TOOSMALL _HRESULT_TYPEDEF_(0x80169ddb) // Adjustment amount is too small
#define XONLINE_E_BILLING_INVALID_LOCALE _HRESULT_TYPEDEF_(0x80169de5) // Locale string is not a valid locale
#define XONLINE_E_BILLING_INVALID_CUSTOMER_TYPE _HRESULT_TYPEDEF_(0x80169de6) // Customer type is not valid
#define XONLINE_E_BILLING_INVALID_CURRENCY _HRESULT_TYPEDEF_(0x80169de7) // Currency string is not a valid currency
#define XONLINE_E_BILLING_DATE_EXPIRED _HRESULT_TYPEDEF_(0x80169de8) // The date is already expired
#define XONLINE_E_BILLING_GUID_EXISTS _HRESULT_TYPEDEF_(0x80169de9) // The guid passed in already exists in the system
#define XONLINE_E_BILLING_INVALID_VIOLATION_ID _HRESULT_TYPEDEF_(0x80169dec) // The specified Violation Id is invalid
#define XONLINE_E_BILLING_MISSING_VIOLATION_ID _HRESULT_TYPEDEF_(0x80169ded) // The Violation Id is required
#define XONLINE_E_BILLING_NEEDTODEPROVISION _HRESULT_TYPEDEF_(0x80169def) // You should deprovision some serviceinstances to proceed
#define XONLINE_E_BILLING_PARTIALCONV_INITIATED _HRESULT_TYPEDEF_(0x80169df0) // Partial Conversion is already initiated.
#define XONLINE_E_BILLING_PARTIALCONV_EXPECTED _HRESULT_TYPEDEF_(0x80169df2) // The subscription is expected to be in the partial state.
#define XONLINE_E_BILLING_INVALID_CATEGORY_NAME _HRESULT_TYPEDEF_(0x80169df3) // Category string is not a valid catergory
#define XONLINE_E_BILLING_OFFERING_NOT_PURCHASEABLE _HRESULT_TYPEDEF_(0x80169df5) // Offering is not purchaseable at this time
#define XONLINE_E_BILLING_OFFERING_ACCOUNT_CURRENCY_MISMATCH _HRESULT_TYPEDEF_(0x80169df6) // The offering currency does not match the account currency
#define XONLINE_E_BILLING_OFFERING_PAYMENT_INSTRUMENT_MISMATCH _HRESULT_TYPEDEF_(0x80169df7) // The specified offering does not support the given payment instrument type
#define XONLINE_E_BILLING_INVALID_DATE _HRESULT_TYPEDEF_(0x80169df8) // A date specified is not a valid date.
#define XONLINE_E_BILLING_CANNOT_EXCEED_MAX_OWNERSHIP _HRESULT_TYPEDEF_(0x80169df9) // Cannot exceed max ownership for this offering
#define XONLINE_E_BILLING_INVALID_RESOURCE_ID _HRESULT_TYPEDEF_(0x80169e02) // Invalid resource ID.
#define XONLINE_E_BILLING_UNIT_OF_MEASURE_MISMATCH _HRESULT_TYPEDEF_(0x80169e03) // The unit of measure reported in the usage event doesn't match the one configed in billing system.
#define XONLINE_E_BILLING_INVALID_OFFERING_FOR_LOCALE _HRESULT_TYPEDEF_(0x80169e05) // Offering doesn't exist for this Locale.
#define XONLINE_E_BILLING_NOT_A_BASE_OFFERING _HRESULT_TYPEDEF_(0x80169e06) // Offering is not a base offering.
#define XONLINE_E_BILLING_INVALID_ACCOUNT_STATUS _HRESULT_TYPEDEF_(0x80169e16) // Account state does not allow this operation.
#define XONLINE_E_BILLING_ACTIVE_SUBSCRIPTIONS_EXIST _HRESULT_TYPEDEF_(0x80169e1b) // Active subscriptions exist on this payment instrument.
#define XONLINE_E_BILLING_PRIMARY_PHONE_REQUIRED _HRESULT_TYPEDEF_(0x80169e25) // Primary phone required for payment instruments.
#define XONLINE_E_BILLING_EMAIL_REQUIRED _HRESULT_TYPEDEF_(0x80169e2a) // An Email address on the account is required for this operation.
#define XONLINE_E_BILLING_ACCOUNT_NOT_CLOSED _HRESULT_TYPEDEF_(0x80169e2b) // The account should be in CLOSED state to perform this operation.
#define XONLINE_E_BILLING_INVALID_VIOLATION _HRESULT_TYPEDEF_(0x80169e13) // Violation is invalid.
#define XONLINE_E_BILLING_SUBSCRIPTION_IS_CANCELLED _HRESULT_TYPEDEF_(0x80169e14) // The subscription is cancelled, and cannot change status.
#define XONLINE_E_BILLING_NO_VIOLATION _HRESULT_TYPEDEF_(0x80169e15) // No violation exists on this subscription.
#define XONLINE_E_BILLING_EXISTS_VIOLATION _HRESULT_TYPEDEF_(0x80169e17) // There are violations on this subscription.
#define XONLINE_E_BILLING_END_DATE_IN_THE_PAST _HRESULT_TYPEDEF_(0x80169e33) // The end date passed in is in the past.
#define XONLINE_E_BILLING_END_DATE_BEYOND_MAX _HRESULT_TYPEDEF_(0x80169e34) // The end date passed in is beyond the maximum allowable end date for this subscription.
#define XONLINE_E_BILLING_VIOLATION_ALREADY_SET _HRESULT_TYPEDEF_(0x80169e3e) // The violation is already set.
#define XONLINE_E_BILLING_NO_VIOLATION_SET _HRESULT_TYPEDEF_(0x80169e43) // No violation of this ID is set.
#define XONLINE_E_BILLING_INVALID_CONVERSION _HRESULT_TYPEDEF_(0x80169e4d) // This conversion path is not allowed.
#define XONLINE_E_BILLING_SUBS_NOT_INTERMEDIATE _HRESULT_TYPEDEF_(0x80169e4e) // The subscription is not in the partial state.
#define XONLINE_E_BILLING_OFFERING_NOT_PUBLISHED _HRESULT_TYPEDEF_(0x80169e52) // The Offering is not published.
#define XONLINE_E_BILLING_CONVERSION_NEEDTODEPROVISION _HRESULT_TYPEDEF_(0x80169e53) // Some ServiceInstances need to be deprovisioned inorder to continue.
#define XONLINE_E_BILLING_INVALID_MANDATE_STATUS _HRESULT_TYPEDEF_(0x80169e57) // The mandate status specified is not valid.
#define XONLINE_E_BILLING_PI_ALREADY_GOOD _HRESULT_TYPEDEF_(0x80169e61) // Payment instrument status is already GOOD.
#define XONLINE_E_BILLING_PI_ALREADY_DECLINED _HRESULT_TYPEDEF_(0x80169e66) // Payment instrument status is already DECLINED.
#define XONLINE_E_BILLING_PI_IS_DISABLED _HRESULT_TYPEDEF_(0x80169e6b) // Payment instrument status is DISABLED and cannot be changed to any other status.
#define XONLINE_E_BILLING_INVALID_OFFERING_GUID _HRESULT_TYPEDEF_(0x80169e84) // Invalid Offering GUID.
#define XONLINE_E_BILLING_OFFERING_REQUIRES_PI _HRESULT_TYPEDEF_(0x80169e89) // The offering specified requires a payment instrument to be specified.
#define XONLINE_E_BILLING_DELAYED_PROVISIONING_COMPONENTS_EXIST _HRESULT_TYPEDEF_(0x80169e93) // The offering cannot be purchased because it has delayed provisioning components.
#define XONLINE_E_BILLING_INVALID_AMOUNT_FOR_CURRENCY _HRESULT_TYPEDEF_(0x80169e99) // Amount cannot be adjusted because it does not follow guideline of Currency (JPY or KRW).
#define XONLINE_E_BILLING_INVALID_EMAIL_ADDRESS _HRESULT_TYPEDEF_(0x80169ea2) // The email address specified is not a valid email address.
#define XONLINE_E_BILLING_INVALID_TAX_EXEMPT_STATUS _HRESULT_TYPEDEF_(0x80169eac) // The tax exemption status specified is invalid.
#define XONLINE_E_BILLING_INVALID_OLD_PAYMENT_INSTRUMENT_STATUS _HRESULT_TYPEDEF_(0x80169eb6) // The status of the old payment instrument does not allow this operation.
#define XONLINE_E_BILLING_LAST_ADMIN_ROLE _HRESULT_TYPEDEF_(0x8016c3c3) // It is illegal to remove the last administrator role on the account.
#define XONLINE_E_BILLING_UPDATING_MEMBERNAME _HRESULT_TYPEDEF_(0x8016c3c8) // Error updating membername.
#define XONLINE_E_BILLING_OBJECT_ROLE_LIMIT_EXCEEDED _HRESULT_TYPEDEF_(0x8016c3cd) // This object has exceeded it's role limit of 100.
#define XONLINE_E_BILLING_MALFORMED_REQUEST _HRESULT_TYPEDEF_(0x8016ab7d) // Provision.dll: Provision request malformed
#define XONLINE_E_BILLING_WRONG_INPUT_PARAMETERS _HRESULT_TYPEDEF_(0x8016ab7e) // Provision.dll: Wrong input parameters
#define XONLINE_E_BILLING_MPF_CALL_FAILED _HRESULT_TYPEDEF_(0x8016ab7f) // Provision.dll: Microsoft Provisioning Framework call failed. %1
#define XONLINE_E_BILLING_XML_OPERATION_ERROR _HRESULT_TYPEDEF_(0x8016ab80) // Provision.dll: Error during XML manipulation. %1
#define XONLINE_E_BILLING_MPF_CREATE _HRESULT_TYPEDEF_(0x8016ab81) // Provision.dll: MPF client instantiation failed. %1
#define XONLINE_E_BILLING_CREATION _HRESULT_TYPEDEF_(0x8016ab82) // Provision.dll: General error in sturtup code. %1
#define XONLINE_E_BILLING_INCREMENT_TOTAL _HRESULT_TYPEDEF_(0x80164e39) // Cannot update total as requested.
#define XONLINE_E_BILLING_RES_NOT_BELONG_TO_OBJECT _HRESULT_TYPEDEF_(0x80164e57) // The resource doesn't belong to this service instance.
#define XONLINE_E_BILLING_DECLINING_BALANCE _HRESULT_TYPEDEF_(0x80164e5c) // The payment instrument on the current subscription has a declining balance
#define XONLINE_E_BILLING_DUPLICATE_TRACKING_GUID _HRESULT_TYPEDEF_(0x80164e75) // Attempted to insert Duplicate Tracking Guid into detail_event table.
#define XONLINE_E_BILLING_INVALID_EXPIRATION_DATE _HRESULT_TYPEDEF_(0x80164ea7) // The credit card expiration date specified is invalid
#define XONLINE_E_BILLING_UNKNOWN_MANDATE_STATUS _HRESULT_TYPEDEF_(0x80164eac) // The mandate status specified is invalid
#define XONLINE_E_BILLING_INVALID_CURRENCY2 _HRESULT_TYPEDEF_(0x80164ec0) // The input currency is incorrect.
#define XONLINE_E_BILLING_INVALID_BILLING_PERIOD _HRESULT_TYPEDEF_(0x80164f42) // Invalid billing period passed
#define XONLINE_E_BILLING_INVALID_ANNIV _HRESULT_TYPEDEF_(0x80164f9c) // Invalid billing anniversary date passed in as argument.
#define XONLINE_E_BILLING_INVALID_LINEITEM_ID _HRESULT_TYPEDEF_(0x80164ff6) // Invalid line item id
#define XONLINE_E_BILLING_LINE_ITEM_ID_NOT_OPEN _HRESULT_TYPEDEF_(0x80165046) // the specified line_item_id is not associated with a open record
#define XONLINE_E_BILLING_LINEITEM_ALREADY_OFFSET _HRESULT_TYPEDEF_(0x8016504b) // The line item has already been offset!
#define XONLINE_E_BILLING_INVALID_OFFSET_AMOUNT _HRESULT_TYPEDEF_(0x80165050) // Offset amount must be greater than 0 but no greater than original amount!
#define XONLINE_E_BILLING_CANNOT_OFFSET_HARD_SOFT_DECLINED _HRESULT_TYPEDEF_(0x80165055) // cannot offset line item which is soft/hard declined!
#define XONLINE_E_BILLING_AMOUNT_NOT_COLLECTED_YET _HRESULT_TYPEDEF_(0x8016505a) // Amount has not been collected yet, cannot be offset and immediately settled.
#define XONLINE_E_BILLING_CANNOT_OFFSET_ZERO_AMOUNT _HRESULT_TYPEDEF_(0x8016505f) // Cannot offset zero amount
#define XONLINE_E_BILLING_AMOUNT_IN_PROCESS _HRESULT_TYPEDEF_(0x80165064) // Amount in the process of being sent to the bank, cannot offset.
#define XONLINE_E_BILLING_INVALID_CREDIT_AMOUNT _HRESULT_TYPEDEF_(0x80165082) // Credit amount should not be 0.
#define XONLINE_E_BILLING_OFFSET_IMM_SETTLE_IN_PROG _HRESULT_TYPEDEF_(0x8016509b) // It's not allowed to offset line item which is immediate_settle_in_progress state.
#define XONLINE_E_BILLING_SA_IN_STATE_UNOFFSETABLE _HRESULT_TYPEDEF_(0x801650a5) // The status of the settlement amount containing the line item indicates that the item can't be offset.
#define XONLINE_E_BILLING_OFFSET_AMOUNT_GREATER_THAN_ORIGINAL _HRESULT_TYPEDEF_(0x801650aa) // The offset amount should never be greater than the original item amount.
#define XONLINE_E_BILLING_RES_BALANCE_CHANGE_ON_NONACTIVE_SUBS _HRESULT_TYPEDEF_(0x801650af) // It's not allowed to change a resource balance for a nonactive subscription.
#define XONLINE_E_BILLING_PMN_INSERT_FAILURE _HRESULT_TYPEDEF_(0x801661bc) // The member name for this passport could not be added.
#define XONLINE_E_BILLING_BADSAMECARDUSEDMULTIPLETIMES _HRESULT_TYPEDEF_(0x801661d0) // The same payment card number has been used for multiple times.
#define XONLINE_E_BILLING_PI_ALREADY_ON_ACCOUNT _HRESULT_TYPEDEF_(0x801661df) // The same payment instrument is already on the given account
#define XONLINE_E_BILLING_PUID_ROLE_LIMIT_EXCEEDED _HRESULT_TYPEDEF_(0x801661e4) // This Passport ID has exceeded it's role limit of 100.
#define XONLINE_E_BILLING_XPATHOBJECT_NOTFOUND _HRESULT_TYPEDEF_(0x80162710) // A select node operation failed.
#define XONLINE_E_BILLING_NOPERMISSION _HRESULT_TYPEDEF_(0x80162711) // Access Denied
#define XONLINE_E_BILLING_CANNOT_REMOVE_SELF _HRESULT_TYPEDEF_(0x80162712) // Cannot remove self from object
#define XONLINE_E_BILLING_BADXML _HRESULT_TYPEDEF_(0x80162713) // The XML passed in may be malformed or may not meet the SPK requirements for this API
#define XONLINE_E_BILLING_INVALIDCOMMENTSIZE _HRESULT_TYPEDEF_(0x80162714) // Comment text length must be 1 to 512
#define XONLINE_E_BILLING_BADCANCELMODE _HRESULT_TYPEDEF_(0x80162715) // The cancel mode specified is invalid
#define XONLINE_E_BILLING_INVALID_BUF_SIZE _HRESULT_TYPEDEF_(0x80162716) // The input parameter has a wrong size
#define XONLINE_E_BILLING_INVALID_ROLE _HRESULT_TYPEDEF_(0x80162717) // The role specified is invalid
#define XONLINE_E_BILLING_INVALID_PPORT_ID _HRESULT_TYPEDEF_(0x80162718) // The passport id specified is invalid
#define XONLINE_E_BILLING_INVALID_ARG _HRESULT_TYPEDEF_(0x8016271a) // The argument specified is invalid
#define XONLINE_E_BILLING_UNKNOWN_SERVER_FAILURE _HRESULT_TYPEDEF_(0x8016271f) // Unknown server failure.
#define XONLINE_E_BILLING_INVALID_STATUS_VALUE _HRESULT_TYPEDEF_(0x80162720) // Invalid Status. Must be ENABLED or SUSPENDED.
#define XONLINE_E_BILLING_INVALID_FILTER _HRESULT_TYPEDEF_(0x80162721) // The filter field is invalid. It must be one of "Base", "Upgrade", "Downgrade", or "Renewal", or leave the filter empty.
#define XONLINE_E_BILLING_MISSING_CATEGORY _HRESULT_TYPEDEF_(0x80162722) // The Category field is missing.
#define XONLINE_E_BILLING_FIELD_TOO_SHORT _HRESULT_TYPEDEF_(0x80162723) // The input field is too short.
#define XONLINE_E_BILLING_FIELD_TOO_LONG _HRESULT_TYPEDEF_(0x80162724) // The input field is too long.
#define XONLINE_E_BILLING_BADZIP _HRESULT_TYPEDEF_(0x80162725) // The specified zip code is incorrect
#define XONLINE_E_BILLING_ONLYONENODE _HRESULT_TYPEDEF_(0x80162726) // Only one of these nodes should be passed in.
#define XONLINE_E_BILLING_CSR_AUTHZ_FAILED _HRESULT_TYPEDEF_(0x80162728) // Only CSR callers can invoke this API.
#define XONLINE_E_BILLING_NOT_ACCOUNT_ADMIN _HRESULT_TYPEDEF_(0x80162729) // The caller is not an administrator of the specified account.
#define XONLINE_E_BILLING_DELEGATE_ID_UNSPECIFIED _HRESULT_TYPEDEF_(0x8016272a) // The delegate passport id must be specified for CSR callers.
#define XONLINE_E_BILLING_REQUESTER_ID_UNSPECIFIED _HRESULT_TYPEDEF_(0x8016272b) // The requester passport id must be specified.
#define XONLINE_E_BILLING_INVALID_FLAG_VALUE _HRESULT_TYPEDEF_(0x8016272c) // Boolean Value must be 0, 1
#define XONLINE_E_BILLING_PROVISIONING_INACTIVE_SUBSCRIPTION _HRESULT_TYPEDEF_(0x8016272d) // Provisioning service instance for subscription status being different than active
#define XONLINE_E_BILLING_INVALID_OBJECT_ID _HRESULT_TYPEDEF_(0x8016272e) // The Object specified is invalid.
#define XONLINE_E_BILLING_PARTNERNOTINBILLING _HRESULT_TYPEDEF_(0x80162738) // The calling partner is not registered in our database.
#define XONLINE_E_BILLING_RATING_FAILURE _HRESULT_TYPEDEF_(0x8016273d) // A rating error has occurred, check the event log and the tracer.
#define XONLINE_S_BILLING_SVR2_STARTED _HRESULT_TYPEDEF_(0x80162742) // BDKSVR2 started.
#define XONLINE_S_BILLING_CSR_API_CALL_MADE _HRESULT_TYPEDEF_(0x80162743) // CSR call made.
#define XONLINE_E_BILLING_CSR_CALL_FROM_NONCSR _HRESULT_TYPEDEF_(0x80162744) // CSR call ATTEMPT BY NON CSR CALLER
#define XONLINE_E_BILLING_TRANS_BALANCE_MISMATCHING_ACCTS _HRESULT_TYPEDEF_(0x8016274c) // from and to PI not on the same account in TransferBalance
#define XONLINE_E_BILLING_TRANS_BALANCE_TO_PI_INVALID _HRESULT_TYPEDEF_(0x80162751) // transfer-to PI not in good status in TransferBalance
#define XONLINE_E_BILLING_TRANS_BALANCE_TO_SAME_PI _HRESULT_TYPEDEF_(0x80162756) // transfer-to same PI in TransferBalance
#define XONLINE_E_BILLING_TRANS_BALANCE_NOT_ALLOW _HRESULT_TYPEDEF_(0x8016275b) // Transferring a balance between the Payment Instrument types is not allowed
#define XONLINE_E_BILLING_INTERNAL_ERROR _HRESULT_TYPEDEF_(0x80162760) // Internal database inconsistencies were detected.
#define XONLINE_E_BILLING_OUTSTANDING_BALANCE _HRESULT_TYPEDEF_(0x80162765) // A outstanding balance exists on this payment instrument.
#define XONLINE_E_BILLING_INVALID_REFERRALDATA_XML _HRESULT_TYPEDEF_(0x8016276a) // Invalid ReferralData XML. Check to make sure it exists, is between 1 and 1024 characters, and is valid xml.
#define XONLINE_E_BILLING_INVALID_GUID _HRESULT_TYPEDEF_(0x8016276f) // The guid specified is invalid
#define XONLINE_E_BILLING_UNSUPPORTED_PAYMENT_INSTRUMENT _HRESULT_TYPEDEF_(0x80162774) // unsupported payment instrument type for settlebalance
#define XONLINE_E_BILLING_SUBSCRIPTION_INACTIVE _HRESULT_TYPEDEF_(0x80162779) // The subscription is not active.
#define XONLINE_E_BILLING_INVALID_PM_FOR_STOP_PAYMENTS _HRESULT_TYPEDEF_(0x8016277e) // Cannot stop payments for Qwest payment method type.
#define XONLINE_E_BILLING_EXCEEDS_MAX_NUMBER_OF_USAGE_EVENTS _HRESULT_TYPEDEF_(0x80162783) // The number of usage events reported through one ReportUsageEvent() call exceeds the maximum system can handle.
#define XONLINE_E_BILLING_FIELD_NOT_UPDATEABLE _HRESULT_TYPEDEF_(0x80162788) // A field specified is not updateable.
#define XONLINE_E_BILLING_DEFERRED_COMPUTE_ONLY_NOT_SUPPORTED _HRESULT_TYPEDEF_(0x8016278d) // Calling CancelSubscription with an end date and in compute only mode is not supported.
#define XONLINE_E_BILLING_SETTLE_SHOULD_BE_THE_LAST_EVENT _HRESULT_TYPEDEF_(0x8016278e) // The SETTLE type event should be the last one in the event list of importsettlebillingitems.
#define XONLINE_E_BILLING_PAYMENT_METHOD_NO_LONGER_VALID _HRESULT_TYPEDEF_(0x8016278f) // The payment method used to pay for the line item is no long valid.
#define XONLINE_E_BILLING_PROCESS_USAGE_EVENTS _HRESULT_TYPEDEF_(0x80162790) // Failed to process some of the usage events.
#define XONLINE_E_BILLING_WRONG_OBJECT_ID_TYPE _HRESULT_TYPEDEF_(0x80162791) // The object ID does not contain account, subscription info.
#define XONLINE_E_BILLING_INVALID_PHONE_VALUE _HRESULT_TYPEDEF_(0x80162792) // The field contains invalid characters for a phone number
#define XONLINE_E_BILLING_INVALID_AMOUNT_VALUE _HRESULT_TYPEDEF_(0x80162797) // Amount value is invalid
#define XONLINE_E_BILLING_MISMATCH_ACCTID_IN_CLOSEBALANCE _HRESULT_TYPEDEF_(0x80162793) // The Payment InstrumentId and the Line Item Id do not match
#define XONLINE_E_BILLING_INTERNAL_ADD_COMMENT_FAILED _HRESULT_TYPEDEF_(0x80162794) // InternalAddComment failed. This needs to be escalated to SPG development.
#define XONLINE_E_BILLING_INVALID_IMMEDIATE_SETTLE_VALUE _HRESULT_TYPEDEF_(0x80162795) // Only FALSE is supported for the immediate settle flag.
#define XONLINE_E_BILLING_NO_RECORDS_FOR_STOP_PAYMENTS _HRESULT_TYPEDEF_(0x8016279c) // No eligible records were found for StopPayments API call.
#define XONLINE_E_BILLING_TAXWARE_FAILURE _HRESULT_TYPEDEF_(0x8016ea60) // A taxware error has occurred, check the event log and the tracer.
#define XONLINE_E_BILLING_ADDRESS_VALIDATION_FAILURE _HRESULT_TYPEDEF_(0x8016ea61) // An error has occurred while validating address, check the event log and the tracer.
#define XONLINE_E_BILLING_ZIP_INVALID _HRESULT_TYPEDEF_(0x8016ea6b) // VERAZIP: ZIP Code has not been found in the database.
#define XONLINE_E_BILLING_STATE_INVALID _HRESULT_TYPEDEF_(0x8016ea6c) // VERAZIP: Invalid State Code passed.
#define XONLINE_E_BILLING_ZIP_CITY_MISSING _HRESULT_TYPEDEF_(0x8016ea6d) // VERAZIP: No Zip Code or City Name passed.
#define XONLINE_E_BILLING_STATE_ZIP_INVALID _HRESULT_TYPEDEF_(0x8016ea6e) // VERAZIP: State Code/ZIP Code combination passed has not been found.
#define XONLINE_E_BILLING_STATE_CITY_INVALID _HRESULT_TYPEDEF_(0x8016ea6f) // VERAZIP: State Code/City Name combination passed has not been found.
#define XONLINE_E_BILLING_STATE_ZIP_CITY_INVALID _HRESULT_TYPEDEF_(0x8016ea70) // VERAZIP: State Code/ZIP Code/City Name combination passed has not been found. Neither State Code/ZIP Code combination nor State Code/City Name combination could be found. Currently BDK doesn't return any data, this text is from VeraZip documentation.
#define XONLINE_E_BILLING_STATE_ZIP_CITY_INVALID2 _HRESULT_TYPEDEF_(0x8016ea71) // VERAZIP: State Code, ZIP Code and City Name combination passed has not been found. Returned all ZIP codes associated with State Code/City Name combination. Currently BDK doesn't return any data, this text is from VeraZip documentation.
#define XONLINE_E_BILLING_STATE_ZIP_CITY_INVALID3 _HRESULT_TYPEDEF_(0x8016ea72) // VERAZIP: State Code, ZIP Code and City Name combination passed has not been found. Returned all City Names and ZIP Code Extensions associated with State Code/ Zip Code combination. Currently BDK doesn't return any data, this text is from VeraZip documentation.
#define XONLINE_E_BILLING_STATE_ZIP_CITY_INVALID4 _HRESULT_TYPEDEF_(0x8016ea73) // VERAZIP: State Code, ZIP Code and City Name combination passed has not been found. The error could be because you didn't pass in the state code.
#define XONLINE_E_BILLING_MULTIPLE_COUNTIES_FOUND _HRESULT_TYPEDEF_(0x8016ea7d) // VERAZIP: Two or more counties were found for State Code, ZIP Code and City Name combination. Returned all County Codes. Currently BDK doesn't return any data, this text is from VeraZip documentation.
#define XONLINE_E_BILLING_ZIP_INVALID_FOR_ENTERED_STATE _HRESULT_TYPEDEF_(0x8016ea7e) // VERAZIP: Zip Code not valid for State Code entered. Defaulted to State Code that matches ZIP Code entered.
#define XONLINE_E_BILLING_STATE_ZIP_COVERS_MULTIPLE_CITIES _HRESULT_TYPEDEF_(0x8016ea89) // VERAZIP: Valid State Code and Zip Code passed, but the Zip Code covers multiple City Names. Returned all City Names for this ZIP Code. Currently BDK doesn't return any data, this text is from VeraZip documentation.
#define XONLINE_E_BILLING_MULTIPLE_CITIES_FOUND _HRESULT_TYPEDEF_(0x8016ea8a) // VERAZIP: Valid State Code and City Name passed, but the city has multiple ZIP Codes. Returned all ZIP Codes for this city. Currently BDK doesn't return any data, this text is from VeraZip documentation.
#define XONLINE_E_BILLING_BAD_CITYNAME_LENGTH _HRESULT_TYPEDEF_(0x8016ea8b) // City name length is incorrect.
#define XONLINE_E_BILLING_BAD_COUNTRYCODE_LENGTH _HRESULT_TYPEDEF_(0x8016ea8c) // Country code length is incorrect.
#define XONLINE_E_BILLING_BAD_STATECODE_LENGTH _HRESULT_TYPEDEF_(0x8016ea8d) // State/Province code length is incorrect.
#define XONLINE_E_BILLING_BAD_ZIPCODE_LENGTH _HRESULT_TYPEDEF_(0x8016ea8e) // Zip code length is incorrect.
#define XONLINE_E_BILLING_BAD_PRODUCTCODE_LENGTH _HRESULT_TYPEDEF_(0x8016ea8f) // Product code length is incorrect.
#define XONLINE_E_BILLING_BAD_BUSINESSLOCATIONCODE_LENGTH _HRESULT_TYPEDEF_(0x8016ea90) // Business location code length is incorrect.
#define XONLINE_E_BILLING_BAD_TRANSACTIONDATE_LENGTH _HRESULT_TYPEDEF_(0x8016ea91) // Transaction date length is incorrect.
#define XONLINE_E_BILLING_BAD_VATREGISTRATION_LENGTH _HRESULT_TYPEDEF_(0x8016ea92) // VAT registration length is incorrect.
#define XONLINE_E_BILLING_BAD_CURRENCYCODE_LENGTH _HRESULT_TYPEDEF_(0x8016ea93) // Currency code length is incorrect.
#define XONLINE_E_BILLING_BAD_WTCODE_LENGTH _HRESULT_TYPEDEF_(0x8016ea94) // WorldTax code length is incorrect.
#define XONLINE_E_BILLING_INVALID_INPUT_TO_TAXWARE_OR_VERAZIP _HRESULT_TYPEDEF_(0x8016ea95) // Invalid input parameter was passed to TaxWare or the VeraZip system.
#define XONLINE_E_BILLING_UNSUPPORTED_CHAR_EXIST _HRESULT_TYPEDEF_(0x8016ea9c) // There are unsupported characters or sequences of characters existing in the input BSTR or XML.
#define XONLINE_E_BILLING_PI_IN_DECLINE _HRESULT_TYPEDEF_(0x801650c8) // the payment instrument already has declines on it, transferbalance not allowed
//
// Macro for detecting error status.
// Error codes start at 400 (HTTP_STATUS_BAD_REQUEST).
//
#define XONLINE_HTTPSTATUS_ANYERROR(status) ((status >= 400) ? TRUE : FALSE)
//
// HRs for _XPassport* APIs
//
#define XONLINE_E_PASSPORT_NAME_ALREADY_TAKEN _HRESULT_TYPEDEF_(0x8015d001) // Failed to create passport: name already taken
#define XONLINE_E_PASSPORT_WRONG_NAME_OR_PASSWORD _HRESULT_TYPEDEF_(0x8015d002) // Wrong password and/or membername dose not exist.
#define XONLINE_E_PASSPORT_LOCKED_OUT _HRESULT_TYPEDEF_(0x8015d003) // The credential is locked out.
#define XONLINE_E_PASSPORT_FORCE_RENAME _HRESULT_TYPEDEF_(0x8015d004) // The credential is in a forced renamed state
#define XONLINE_E_PASSPORT_FORCE_CHANGE_PASSWORD _HRESULT_TYPEDEF_(0x8015d005) // The password has to be changed.
#define XONLINE_E_PASSPORT_FORCE_CHANGE_SQ_SA _HRESULT_TYPEDEF_(0x8015d006) // The secret question and answer has to be changed.
#define XONLINE_E_PASSPORT_PASSWORD_EXPIRED _HRESULT_TYPEDEF_(0x8015d007) // The password for the account has expired.
#define XONLINE_E_PASSPORT_REQUIRE_EMAIL_VALIDATION _HRESULT_TYPEDEF_(0x8015d008) // The account is blocked pending email address validation.
#define XONLINE_E_FORBIDDEN_WORD _HRESULT_TYPEDEF_(0x8015d009) // String contained words that are forbidden by namespace administrator, examine input.
#define XONLINE_E_PASSWORD_BLANK _HRESULT_TYPEDEF_(0x8015d00a) // The password is blank.
#define XONLINE_E_PASSWORD_TOO_SHORT _HRESULT_TYPEDEF_(0x8015d00b) // The password is too short
#define XONLINE_E_PASSWORD_TOO_LONG _HRESULT_TYPEDEF_(0x8015d00c) // The password is too long
#define XONLINE_E_PASSWORD_CONTAINS_MEMBER_NAME _HRESULT_TYPEDEF_(0x8015d00d) // The password contains the member name.
#define XONLINE_E_PASSWORD_CONTAINS_INVALID_CHARACTERS _HRESULT_TYPEDEF_(0x8015d00e) // The password contains invalid characters.
#define XONLINE_E_SQ_CONTAINS_PASSWORD _HRESULT_TYPEDEF_(0x8015d00f) // The secret question contains the password.
#define XONLINE_E_SA_CONTAINS_PASSWORD _HRESULT_TYPEDEF_(0x8015d010) // The answer for the secret question contains the password.
#define XONLINE_E_PASSWORD_CONTAINS_SA _HRESULT_TYPEDEF_(0x8015d011) // The password validation code detected the answer to the secret question in the password.
#define XONLINE_E_SQ_CONTAINS_SA _HRESULT_TYPEDEF_(0x8015d015) // The secret question contains the answer.
#define XONLINE_E_SA_TOO_SHORT _HRESULT_TYPEDEF_(0x8015d017)
#define XONLINE_E_SA_CONTAINS_SQ _HRESULT_TYPEDEF_(0x8015d018) // The answer to the secret question contains that question.
#define XONLINE_E_SA_CONTAINS_MEMBER_NAME _HRESULT_TYPEDEF_(0x8015d019) // The answer for the secret question contains the member name.
#define XONLINE_E_MEMBER_NAME_TOO_SHORT _HRESULT_TYPEDEF_(0x8015d01a) // The signin name is too short.
#define XONLINE_E_MEMBER_NAME_INVALID _HRESULT_TYPEDEF_(0x8015d01b) // The signin name is incomplete or has invalid characters.
#define XONLINE_E_PASSPORT_INVALID_DOMAIN _HRESULT_TYPEDEF_(0x8015d01c) // Cannot create EASI passport on reserved domain (e.g. hotmail.com)
#define XONLINE_E_PASSPORT_INVALID_POSTAL_CODE _HRESULT_TYPEDEF_(0x8015d01d) // The postal code specified is invalid
//
// Values used in passcodes
//
typedef enum {
XONLINE_PASSCODE_DPAD_UP = 1,
XONLINE_PASSCODE_DPAD_DOWN,
XONLINE_PASSCODE_DPAD_LEFT,
XONLINE_PASSCODE_DPAD_RIGHT,
XONLINE_PASSCODE_GAMEPAD_X,
XONLINE_PASSCODE_GAMEPAD_Y,
XONLINE_PASSCODE_GAMEPAD_LEFT_TRIGGER = 9,
XONLINE_PASSCODE_GAMEPAD_RIGHT_TRIGGER,
XONLINE_PASSCODE_GAMEPAD_LEFT_SHOULDER,
XONLINE_PASSCODE_GAMEPAD_RIGHT_SHOULDER
} XONLINE_PASSCODE_TYPE;
#pragma pack(push, 1)
typedef struct _USER_ACCOUNT_STATUS_INFO
{
// Xbox Live user policy
BOOL bNewTermsOfService;
BOOL bForcedNameChangeRequired;
FILETIME ftSuspendedUntil;
WORD wTotalDaysSuspended;
FILETIME ftVoiceBannedUntil;
WORD wTotalDaysVoiceBanned;
// Billing-related information
HRESULT hrBillingAccountStatus;
} USER_ACCOUNT_STATUS_INFO;
#pragma pack(pop)
//
// Define maximum sizes for various fields in the request
//
#define MAX_FIRSTNAME_SIZE 64
#define MAX_LASTNAME_SIZE 64
#define MAX_EMAIL_SIZE 129
#define MAX_PHONE_PREFIX_SIZE 12
#define MAX_PHONE_NUMBER_SIZE 12
#define MAX_PHONE_EXTENSION_SIZE 12
#define MAX_STREET_SIZE 128
#define MAX_CITY_SIZE 64
#define MAX_DISTRICT_SIZE 64
#define MAX_STATE_SIZE 64
#define MAX_COUNTRYCODE_SIZE 2
#define MAX_POSTALCODE_SIZE 16
#define MAX_CC_NAME_SIZE 64
#define MAX_CC_TYPE_SIZE 32
#define MAX_CC_NUMBER_SIZE 24
#define MAX_CC_EXPIRATION_SIZE 6
#define MAX_CC_CCV_NUMBER_SIZE 4
#define MAX_DD_BANK_CODE_SIZE 64
#define MAX_DD_BRANCH_CODE_SIZE 64
#define MAX_DD_CHECK_DIGITS_SIZE 64
#define ACCOUNT_PIN_LENGTH 4
#define VOUCHER_LENGTH 25
#define MAX_VOUCHER_SIZE VOUCHER_LENGTH+1
#define MAX_BILLING_TOKEN_SIZE MAX_VOUCHER_SIZE
#define PRIVILEGES_DWORD_LENGTH 8
#define MAX_PRIVILEGE_BITS 256
//
// Privilege bits (also defined in server tree's xonline.x)
//
#define XONLINE_PRIVILEGE_MAX 255
// Add Friends
#define XONLINE_PRIVILEGE_ADD_FRIEND 255 // private, internal only - on|off
// Sessions
#define XONLINE_PRIVILEGE_MULTIPLAYER_SESSIONS 254 // on|off (on is modified by FRIENDS_ONLY)
#define XONLINE_PRIVILEGE_MULTIPLAYER_ENABLED_BY_TIER 253 // private, internal only - on|off
// Communications
#define XONLINE_PRIVILEGE_COMMUNICATIONS 252 // on|off (on is modified by FRIENDS_ONLY)
#define XONLINE_PRIVILEGE_COMMUNICATIONS_FRIENDS_ONLY 251 // on=friends only | off=everyone
// Sending video messages is restricted by tier and needs a second bit
#define XONLINE_PRIVILEGE_VIDEO_MESSAGING_SEND 250 // private, internal only - on|off
// Profile
#define XONLINE_PRIVILEGE_PROFILE_VIEWING 249 // on|off (on is modified by FRIENDS_ONLY)
#define XONLINE_PRIVILEGE_PROFILE_VIEWING_FRIENDS_ONLY 248 // on=friends only | off=everyone
// Viewing of User Created Content
#define XONLINE_PRIVILEGE_USER_CREATED_CONTENT 247 // on|off (on is modified by FRIENDS_ONLY)
#define XONLINE_PRIVILEGE_USER_CREATED_CONTENT_FRIENDS_ONLY 246 // sharing on=friends only | off=everyone
// Premium Content Purchases
#define XONLINE_PRIVILEGE_PURCHASE_CONTENT 245 // on|off
// Presence
#define XONLINE_PRIVILEGE_PRESENCE 244 // on|off (on is modified by FRIENDS_ONLY)
#define XONLINE_PRIVILEGE_PRESENCE_FRIENDS_ONLY 243 // on=friends only | off=everyone
// Backward Compatibility
#define XONLINE_PRIVILEGE_XBOX1_LIVE_ACCESS 242 // private, internal only - on|off
#define XONLINE_PRIVILEGE_MIN 242
typedef enum {
XONLINE_PARENTAL_CONTROL_GROUP_OPEN = 0,
XONLINE_PARENTAL_CONTROL_GROUP_MEDIUM = 1,
XONLINE_PARENTAL_CONTROL_GROUP_RESTRICTED = 2
} XONLINE_PARENTAL_CONTROL_GROUP_TYPE;
typedef enum {
XONLINE_PAYMENT_INSTRUMENT_NONE = 0,
XONLINE_PAYMENT_INSTRUMENT_CREDIT_CARD = 1,
XONLINE_PAYMENT_INSTRUMENT_DIRECT_DEBIT = 2
} XONLINE_PAYMENT_INSTRUMENT_TYPE;
typedef enum {
XONLINE_CREDIT_CARD_VISA = 0,
XONLINE_CREDIT_CARD_MASTER_CARD = 1,
XONLINE_CREDIT_CARD_AMEX = 2,
XONLINE_CREDIT_CARD_DISCOVER = 3,
XONLINE_CREDIT_CARD_JCB = 4,
XONLINE_CREDIT_CARD_DINERS = 5,
XONLINE_CREDIT_CARD_KLCC = 6
} XONLINE_CREDIT_CARD_TYPE;
typedef enum {
XONLINE_TIER_INVALID = 0,
XONLINE_TIER_BRONZE = 3,
XONLINE_TIER_SILVER = 6
} XONLINE_TIER_TYPE;
typedef enum {
XONLINE_SUBSCRIPTION_PENDING = 0,
XONLINE_SUBSCRIPTION_ENABLED = 1,
XONLINE_SUBSCRIPTION_SUSPENDED = 2,
XONLINE_SUBSCRIPTION_EXPIRED = 3,
XONLINE_SUBSCRIPTION_CANCELED = 4,
XONLINE_SUBSCRIPTION_EXPIRED_NO_VIOLATIONS = 128
} XONLINE_SUBSCRIPTION_STATUS_TYPE;
typedef enum {
XONLINE_GENRE_BASE = 0,
XONLINE_GENRE_XARCADE = 116000000
} XONLINE_GENRE_TYPE;
typedef enum {
XONLINE_DMP_STATUS_ACTIVE = 0,
XONLINE_DMP_STATUS_DISABLED = 1,
XONLINE_DMP_STATUS_CLOSED = 2
} XONLINE_DMP_STATUS_TYPE;
typedef enum {
XONLINE_GET_POINTS_BALANCE_RESPONSE_ABOVE_LOW_BALANCE = 0x0001
} XONLINE_GET_POINTS_BALANCE_RESPONSE_FLAGS;
typedef enum {
XONLINE_GET_POINTS_BALANCE_DETAILS_RESPONSE_ABOVE_LOW_BALANCE = 0x0001
} XONLINE_GET_POINTS_BALANCE_DETAILS_RESPONSE_FLAGS;
typedef enum {
XONLINE_OFFERING_TYPE_SUBSCRIPTION = 0x00000001,
XONLINE_OFFERING_TYPE_CONTENT = 0x00000002,
XONLINE_OFFERING_TYPE_RENEWAL = 0x00000004,
XONLINE_OFFERING_TYPE_POINTS_BUNDLE = 0x00000008,
XONLINE_OFFERING_TYPE_GAMERTAG_CHANGE = 0x00000010,
XONLINE_OFFERING_TYPE_GAME_DEMO = 0x00000020,
XONLINE_OFFERING_TYPE_GAME_TRAILER = 0x00000040,
XONLINE_OFFERING_TYPE_THEME = 0x00000080,
XONLINE_OFFERING_TYPE_GAMEPLAY = 0x00000100,
XONLINE_OFFERING_TYPE_FULL_GAME = 0x00000200,
XONLINE_OFFERING_TYPE_PROMO_POINTS = 0x00000400,
XONLINE_OFFERING_TYPE_TILE = 0x00000800,
XONLINE_OFFERING_TYPE_ARCADE = 0x00002000
} XONLINE_OFFERING_TYPE;
typedef enum {
XONLINE_TAX_TYPE_NO_TAX = 0,
XONLINE_TAX_TYPE_DEFAULT = 1,
XONLINE_TAX_TYPE_GST = 2,
XONLINE_TAX_TYPE_VAT = 3,
XONLINE_TAX_TYPE_NOT_APPLICABLE = 4
} XONLINE_TAX_TYPE;
typedef enum {
XONLINE_OFFERING_FREQUENCY_ONE_TIME_CHARGE = 0,
XONLINE_OFFERING_FREQUENCY_MONTHLY = 1,
XONLINE_OFFERING_FREQUENCY_QUARTERLY = 2,
XONLINE_OFFERING_FREQUENCY_BIANNUALLY = 3,
XONLINE_OFFERING_FREQUENCY_ANNUALLY = 4
} XONLINE_OFFERING_FREQUENCY;
typedef enum {
XONLINE_OFFERING_RELATION_NONE = 1,
XONLINE_OFFERING_RELATION_BASE = 0,
XONLINE_OFFERING_RELATION_RENEWAL = 3
} XONLINE_OFFERING_RELATION;
typedef enum {
XONLINE_PAYMENT_TYPE_CREDIT_CARD = 0x00000001,
XONLINE_PAYMENT_TYPE_TOKEN = 0x00000002,
XONLINE_PAYMENT_TYPE_POINTS = 0x00000004
} XONLINE_PAYMENT_TYPE;
typedef enum {
XONLINE_CONTENT_ENUMERATE_USER_PLAYED_GAME_FILTER = 0x0001,
XONLINE_CONTENT_ENUMERATE_USER_HAS_PURCHASED_FILTER = 0x0002,
XONLINE_CONTENT_ENUMERATE_NEW_CONTENT_ONLY_FILTER = 0x0004
} XONLINE_CONTENT_ENUMERATE_FLAGS;
typedef enum {
XONLINE_BASIC_CONTENT_INFO_USER_HAS_PURCHASED = 0x0001,
XONLINE_BASIC_CONTENT_INFO_USER_HAS_VIEWED = 0x0002,
XONLINE_BASIC_CONTENT_INFO_IS_UNRESTRICTED = 0x0004
} XONLINE_BASIC_CONTENT_INFO_FLAGS;
typedef enum {
XONLINE_SUBSCRIPTION_QUERY_FOR_NEW = 0x0001,
XONLINE_SUBSCRIPTION_QUERY_FOR_RENEWALS = 0x0002,
XONLINE_SUBSCRIPTION_QUERY_FOR_CURRENT = 0x0004,
XONLINE_SUBSCRIPTION_QUERY_FOR_EXPIRED = 0x0008
} XONLINE_SUBSCRIPTION_ENUMERATE_FLAGS;
typedef enum {
XONLINE_BASIC_CONTENT_INFO_USER_IS_SUBSCRIBED = 0x0001
} XONLINE_BASIC_SUBSCRIPTION_INFO_FLAGS;
typedef enum {
XONLINE_SUBSCRIPTION_CONVERT_MODE_CONVERT = 0,
XONLINE_SUBSCRIPTION_CONVERT_MODE_RENEW = 1,
XONLINE_SUBSCRIPTION_CONVERT_MODE_INVALID = 2
} XONLINE_SUBSCRIPTION_CONVERT_MODE;
typedef enum {
XONLINE_TITLE_QUERY_FOR_NEW = 0x0001,
XONLINE_TITLE_QUERY_FOR_PLAYED = 0x0002
} XONLINE_TITLE_ENUMERATE_FLAGS;
#define XONLINE_OFFERING_BITFILTER_ALL = 0xFFFFFFFF;
#pragma pack(push, 4)
typedef struct _USER_XNAME
{
WCHAR wszGamerTag[XONLINE_GAMERTAG_SIZE];
} USER_XNAME;
typedef struct _USER_ACCOUNT_INFO
{
USER_XNAME xname;
BYTE rgbPasscode[XONLINE_PASSCODE_LENGTH];
FILETIME ftBirthdate;
} USER_ACCOUNT_INFO;
typedef struct _USER_PAYMENT_INFO
{
WCHAR wszFirstName[MAX_FIRSTNAME_SIZE];
WCHAR wszLastName[MAX_LASTNAME_SIZE];
WCHAR wszStreet1[MAX_STREET_SIZE];
WCHAR wszStreet2[MAX_STREET_SIZE];
WCHAR wszDistrict[MAX_STREET_SIZE];
WCHAR wszCity[MAX_CITY_SIZE];
WCHAR wszState[MAX_STATE_SIZE];
BYTE bCountryId;
WORD wLanguageId;
WCHAR wszPostalCode[MAX_POSTALCODE_SIZE];
WCHAR wszPhonePrefix[MAX_PHONE_PREFIX_SIZE];
WCHAR wszPhoneNumber[MAX_PHONE_NUMBER_SIZE];
WCHAR wszPhoneExtension[MAX_PHONE_EXTENSION_SIZE];
BYTE bPaymentTypeId;
WCHAR wszCardHolder[MAX_CC_NAME_SIZE];
BYTE bCardTypeId;
WCHAR wszCardNumber[MAX_CC_NUMBER_SIZE];
FILETIME ftCardExpiration;
WCHAR wszEmail[MAX_EMAIL_SIZE];
WCHAR wszBankCode[MAX_DD_BANK_CODE_SIZE];
WCHAR wszBranchCode[MAX_DD_BRANCH_CODE_SIZE];
WCHAR wszCheckDigits[MAX_DD_CHECK_DIGITS_SIZE];
WCHAR wszVoucher[MAX_VOUCHER_SIZE];
BYTE bMsftOptIn;
BYTE bPartnerOptIn;
ULONGLONG qwOfferId;
FILETIME ftBirthdate;
} USER_PAYMENT_INFO;
#pragma pack(pop)
//
// Calculate the maximum request buffer size * 3 for UTF8 conversion
//
#define MAX_CREATE_OWNER_ACCT_STRINGS (3 * ( \
XONLINE_GAMERTAG_SIZE + \
MAX_FIRSTNAME_SIZE + \
MAX_LASTNAME_SIZE + \
MAX_STREET_SIZE + \
MAX_STREET_SIZE + \
MAX_DISTRICT_SIZE + \
MAX_CITY_SIZE + \
MAX_STATE_SIZE + \
MAX_POSTALCODE_SIZE + \
MAX_PHONE_PREFIX_SIZE + \
MAX_PHONE_NUMBER_SIZE + \
MAX_PHONE_EXTENSION_SIZE + \
MAX_CC_NAME_SIZE + \
MAX_CC_NUMBER_SIZE + \
MAX_EMAIL_SIZE + \
MAX_DD_BANK_CODE_SIZE + \
MAX_DD_BRANCH_CODE_SIZE + \
MAX_DD_CHECK_DIGITS_SIZE + \
MAX_VOUCHER_SIZE))
#pragma pack(push, 1)
struct CREATE_OWNER_ACCT_REQUEST
{
ULONGLONG qwMachinePuid;
DWORD dwTitleId;
FILETIME ftBirthdate;
BYTE bMSSpam;
BYTE bPartnerSpam;
BYTE bCountryId;
WORD wLanguageId;
BYTE bCardTypeId;
FILETIME ftCardExpiration;
BYTE rgbData[MAX_CREATE_OWNER_ACCT_STRINGS];
};
struct CREATE_OWNER_ACCT_RESPONSE
{
ULONGLONG qwUserID;
BYTE rgbKey[XONLINE_KEY_LENGTH];
CHAR szDomain[XONLINE_USERDOMAIN_SIZE];
CHAR szRealm[XONLINE_KERBEROSREALM_SIZE];
};
#pragma pack(pop)
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef _countof
#define _countof(array) (sizeof(array)/sizeof(array[0]))
#endif
typedef DWORD MSGTIME;
#define FT_MSGTIME_BEGIN 0x01C2B128BA2B4000 // 1/1/2003 - used for conversion between FILETIME and MSGTIME
#define FileTimeToMsgTime( pFileTime ) (MSGTIME)( ( *((ULONGLONG*)(pFileTime)) - FT_MSGTIME_BEGIN ) / 10000000 )
XAMINLINE
FILETIME
MsgTimeToFileTime( MSGTIME mt)
{
ULONGLONG ull = ((ULONGLONG)(mt) * 10000000 + FT_MSGTIME_BEGIN);
return *((FILETIME*)&ull);
}
//
// Game Invites
//
typedef enum
{
XMSG_INVITE_ANSWER_NO = 0,
XMSG_INVITE_ANSWER_YES = 1,
XMSG_INVITE_ANSWER_NEVER = 2,
XMSG_INVITE_ANSWER_INVALID = 3
} XMSG_INVITE_ANSWER_TYPE;
#pragma pack(push, 1)
typedef union _XMSG_PROPERTY_DATA
{
WORD wPropOffset;
WORD wData;
BYTE bData;
} XMSG_PROPERTY_DATA, *PXMSG_PROPERTY_DATA;
typedef struct _XMSG_PROPERTY
{
WORD wPropTag;
XMSG_PROPERTY_DATA Data;
} XMSG_PROPERTY, *PXMSG_PROPERTY;
typedef struct _XMSG_PROPERTY_INTERNAL
{
WORD wPropTag; // This property's type and unique identifier
union
{
WORD wPropOffset; // The offset from the start of rgbData of this property's data
WORD wData; // For type XONLINE_MSG_PROP_TYPE_I2 this contains the actual data
BYTE bData; // For type XONLINE_MSG_PROP_TYPE_I1 and XONLINE_MSG_PROP_TYPE_BOOL this contains the actual data
};
} XMSG_PROPERTY_INTERNAL, *PXMSG_PROPERTY_INTERNAL;
typedef struct _XMSG_DETAILS_INTERNAL
{
WORD wPropCount;
WORD cbData;
// XMSG_PROPERTY_INTERNAL rgProperties[wPropCount]
// BYTE rgbData[cbData]
} XMSG_DETAILS_INTERNAL, *PXMSG_DETAILS_INTERNAL;
typedef WORD XMSG_PROPERTY_STRING_INTERNAL;
typedef WORD XMSG_PROPERTY_BINARY_INTERNAL;
typedef struct _XMSG_PROPERTY_ATTACHMENT_INTERNAL
{
DWORD cbAttach;
DWORD dwAttachFlags;
DWORD cbAttachUrl;
} XMSG_PROPERTY_ATTACHMENT_INTERNAL;
typedef struct _P_ALIVE_2_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
WORD cbAcctName;
XNADDR xnaddr;
XNKID xnkid;
XNKEY xnkey;
DWORD dwBuddyListVersion;
DWORD dwBlockListVersion;
//XBOX_LIBRARY_VERSION clientVersion;
WORD wMajorVersion;
WORD wMinorVersion;
WORD wBuildNumber;
WORD wQFENumber;
DWORD dwTitleID;
DWORD dwTitleVersion;
DWORD dwTitleRegion;
WORD ipportI;
IN_ADDR ipaI;
ULONGLONG liNonce;
ULONGLONG liTimeInit;
// CHAR szAcctName[cbAcctName]
} P_ALIVE_2_MSG_INTERNAL;
typedef struct _P_DEAD_USER_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
} P_DEAD_USER_MSG_INTERNAL;
typedef struct _P_ADD_2_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwSenderID;
ULONGLONG qwBuddyID;
DWORD dwMessageFlags;
WORD cbDetails;
CHAR szBuddyAcctName[XONLINE_GAMERTAG_SIZE];
// BYTE rgbDetails[cbDetails];
}P_ADD_2_MSG_INTERNAL;
typedef struct _P_INVITE_2_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwSenderContext;
DWORD dwTitleID;
DWORD dwMessageFlags;
WORD cInvitees;
WORD cbDetails;
// ULONGLONG rgqwInvitees[cInvitees];
// BYTE pbDetails[cbDetails];
} P_INVITE_2_MSG_INTERNAL;
typedef struct _P_INVITE_ANSWER_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwHostID;
XNKID MatchSessionID;
WORD wAnswer;
} P_INVITE_ANSWER_MSG_INTERNAL;
typedef struct _P_CANCEL_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
XNKID SessionID;
WORD cInvitees;
// ULONGLONG rgqwInviteeIDs[cInvitees];
} P_CANCEL_MSG_INTERNAL;
typedef struct _P_FIND_USER_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwFindID;
CHAR szSenderName[XONLINE_GAMERTAG_SIZE];
} P_FIND_USER_MSG_INTERNAL;
typedef struct _Q_DEQUEUE_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
WORD wQType;
DWORD dwStartItemID;
WORD wMaxItems;
DWORD dwMaxTotalItemDataSize;
} Q_DEQUEUE_MSG_INTERNAL;
typedef struct _Q_SEND_MESSAGE_MSG_INTERNAL
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwSenderContext;
DWORD dwMessageFlags;
DWORD dwSenderTitleID;
WORD wExpireMinutes;
WORD cbDetails;
WORD cRecipients;
BYTE bMessageType;
CHAR szSenderName[15];
// ULONGLONG rgqwRecipientIDs[cRecipients];
// XMSG_DETAILS Details;
} Q_SEND_MESSAGE_MSG_INTERNAL;
#pragma pack(pop)
typedef struct _XMSG_PROPERTY_BINARY
{
WORD cbData;
BYTE *rgbData;
} XMSG_PROPERTY_BINARY, *PXMSG_PROPERTY_BINARY;
typedef struct _XMSG_PROPERTY_STRING
{
WORD cbString;
WCHAR *szString;
} XMSG_PROPERTY_STRING, *PXMSG_PROPERTY_STRING;
typedef struct _XMSG_PROPERTY_ATTACHMENT
{
DWORD cbAttach;
DWORD dwAttachFlags;
DWORD cbAttachUrl;
CHAR szAttachUrl;
} XMSG_PROPERTY_ATTACHMENT, *PXMSG_PROPERTY_ATTACHMENT;
#define XONLINE_MSG_MAX_SUMMARY_NEEDED_IDS 4
#define XONLINE_MAX_ALTERNATE_TITLE_ID 4
typedef struct _XUSER_PRIVILEGE_MSG
{
XUID xuidUser;
PXUID pXuids;
DWORD dwXuidCount;
BOOL fResult;
DWORD dwPrivilege;
PXOVERLAPPED pOverlapped;
} XUSER_PRIVILEGE_MSG, *PXUSER_PRIVILEGE_MSG;
#define X_AFFILIATE_INDEX_TO_FLAG(dwIndex) (1 << dwIndex)
#define X_AFFILIATE_FLAG_TO_INDEX(dwFlag) \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_ENCOUNTERED_INDEX) ? X_AFFILIATE_ENCOUNTERED_INDEX : \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_COMPLETED_GAME_INDEX) ? X_AFFILIATE_COMPLETED_GAME_INDEX : \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_POSITIVE_FEEDBACK_INDEX) ? X_AFFILIATE_POSITIVE_FEEDBACK_INDEX : \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_NEGATIVE_FEEDBACK_INDEX) ? X_AFFILIATE_NEGATIVE_FEEDBACK_INDEX : \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_AVOIDING_ME_INDEX) ? X_AFFILIATE_AVOIDING_ME_INDEX : \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_FRIEND_INDEX) ? X_AFFILIATE_FRIEND_INDEX : \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_BLOCK_INDEX) ? X_AFFILIATE_BLOCK_INDEX : \
(dwFlag) == X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_MUTE_INDEX) ? X_AFFILIATE_MUTE_INDEX : X_AFFILIATE_INDEX_ERROR
#define X_AFFILIATE_CLIENT_FLAGS \
(X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_COMPLETED_GAME_INDEX) | X_AFFILIATE_INDEX_TO_FLAG(X_AFFILIATE_ENCOUNTERED_INDEX))
typedef struct _XUSER_PLAYERLIST_USER
{
ULONGLONG qwPlayerID;
DWORD dwFlags;
DWORD dwTitleID;
MSGTIME mtUpdated;
DWORD dwRating;
CHAR szGamertag[XONLINE_GAMERTAG_SIZE];
BOOLEAN fPendingAdd;
WORD wNextPending;
} XUSER_PLAYERLIST_USER;
typedef struct _XUSER_PLAYERLIST_ITEM
{
XUID xuidUser;
DWORD dwFlags;
DWORD dwTitleID;
DWORD dwRating;
char szGamertag[XONLINE_GAMERTAG_SIZE];
} XUSER_PLAYERLIST_ITEM;
typedef struct _XUSER_ADDPLAYER_MSG
{
DWORD dwUserIndex;
DWORD dwResult;
XUSER_PLAYERLIST_ITEM item;
} XUSER_ADDPLAYER_MSG;
typedef struct _XUSER_PLAYER_ENUM
{
DWORD dwUserIndex;
DWORD dwStartingIndex;
DWORD cItem;
} XUSER_PLAYER_ENUM;
typedef struct _XUSER_ENUMPLAYER_MSG
{
DWORD dwUserIndex;
DWORD dwStartingIndex;
DWORD cItem;
XUSER_PLAYER_ENUM* pxenum;
} XUSER_ENUMPLAYER_MSG;
//[end_import_internal(STRUCTS)]
//[begin_import]
DWORD
XUserCreatePlayerEnumerator(
IN DWORD dwUserIndex,
IN DWORD dwStartingIndex,
IN DWORD cItem,
OUT DWORD * pcbBuffer,
OUT HANDLE * ph
);
//[end_import]
//-----------------------------------------------------------------------------
// Update download structures
//-----------------------------------------------------------------------------
typedef HRESULT (WINAPI * PFNDOWNLOADINSTALLNEWFILE)(IN void * pvUserData,
IN const char * szFileName,
IN DWORD dwFileDataSize,
IN BOOL bResume);
typedef HRESULT (WINAPI * PFNDOWNLOADINSTALLFILEDATABEGIN)(IN void * pvUserData,
IN const char * szFileName,
IN BOOL bResume);
typedef HRESULT (WINAPI * PFNDOWNLOADINSTALLPROCESSDATA)(IN void * pvUserData,
IN const BYTE * pbData,
IN DWORD dwDataSize,
IN HANDLE hFile,
IN LARGE_INTEGER * pliFileOffset,
IN BOOL bResume);
typedef HRESULT (WINAPI * PFNDOWNLOADINSTALLFILEDATAEND)(IN void * pvUserData,
IN BOOL bResume);
typedef struct _DOWNLOAD_INSTALLER
{
void * pvUserData; // user context pointer associated with download task
PFNDOWNLOADINSTALLNEWFILE pfnDownloadInstallNewFile; // download installer new file handler
PFNDOWNLOADINSTALLFILEDATABEGIN pfnDownloadInstallFileDataBegin; // download installer file data begin handler
PFNDOWNLOADINSTALLPROCESSDATA pfnDownloadInstallProcessData; // download installer file data processing function
PFNDOWNLOADINSTALLFILEDATAEND pfnDownloadInstallFileDataEnd; // download installer file data end handler
} DOWNLOAD_INSTALLER;
#pragma pack(push, 1)
typedef struct _XONLINE_ATTRIBUTE_STRING
{
WORD Length;
WCHAR *lpValue;
} XONLINE_ATTRIBUTE_STRING, *PXONLINE_ATTRIBUTE_STRING;
typedef struct _XONLINE_ATTRIBUTE_BLOB
{
WORD Length;
BYTE *pbValue;
} XONLINE_ATTRIBUTE_BLOB, *PXONLINE_ATTRIBUTE_BLOB;
typedef union _XONLINE_ATTRIBUTE_DATA
{
ULONGLONG integer;
XONLINE_ATTRIBUTE_STRING string;
XONLINE_ATTRIBUTE_BLOB blob;
} XONLINE_ATTRIBUTE_DATA, *PXONLINE_ATTRIBUTE_DATA;
typedef struct _XONLINE_ATTRIBUTE
{
DWORD dwAttributeID;
XONLINE_ATTRIBUTE_DATA info;
} XONLINE_ATTRIBUTE, *PXONLINE_ATTRIBUTE;
typedef struct _XONLINE_MATCH_SESSION_INFO
{
XNKID SessionID;
XNKEY KeyExchangeKey;
} XONLINE_MATCH_SESSION_INFO, *PXONLINE_MATCH_SESSION_INFO;
typedef struct _XONLINE_MATCH_SEARCHRESULT
{
DWORD dwReserved;
XNKID SessionID;
XNADDR HostAddress;
XNKEY KeyExchangeKey;
DWORD dwPublicOpen;
DWORD dwPrivateOpen;
DWORD dwPublicFilled;
DWORD dwPrivateFilled;
DWORD dwNumAttributes;
DWORD *pAttributeOffsets;
XONLINE_ATTRIBUTE *pAttributes;
} XONLINE_MATCH_SEARCHRESULT, *PXONLINE_MATCH_SEARCHRESULT;
typedef struct _XONLINE_MATCH_SEARCHRESULT_HEADER
{
DWORD dwReserved;
USHORT NumSearchResults;
USHORT Flags;
DWORD LoggingThreshold;
XONLINE_MATCH_SEARCHRESULT *pResults;
} XONLINE_MATCH_SEARCHRESULT_HEADER, *PXONLINE_MATCH_SEARCHRESULT_HEADER;
typedef struct _XMATCH_SESSION_CREATE_REQUEST
{
DWORD dwMessageLength;
XNKID SessionID;
DWORD dwTitleID;
XNADDR HostAddress;
DWORD dwPublicOpen;
DWORD dwPrivateOpen;
DWORD dwPublicFilled;
DWORD dwPrivateFilled;
DWORD dwNumAttributes;
DWORD *pAttributeOffsets;
XONLINE_ATTRIBUTE *pAttributes;
XONLINE_MATCH_SESSION_INFO *pSessionInfo;
} XMATCH_SESSION_CREATE_REQUEST;
typedef struct _XMATCH_SESSION_UPDATE_REQUEST
{
DWORD dwMessageLength;
XNKID SessionID;
DWORD dwTitleID;
XNADDR HostAddress;
DWORD dwPublicOpen;
DWORD dwPrivateOpen;
DWORD dwPublicFilled;
DWORD dwPrivateFilled;
DWORD dwNumAttributes;
DWORD *pAttributeOffsets;
XONLINE_ATTRIBUTE *pAttributes;
} XMATCH_SESSION_UPDATE_REQUEST;
typedef struct _XMATCH_SESSION_DELETE_REQUEST
{
DWORD dwMessageLength;
XNKID SessionID;
DWORD dwTitleID;
} XMATCH_SESSION_DELETE_REQUEST;
typedef struct _XMATCH_SEARCH_REQUEST
{
DWORD dwMessageLength;
DWORD dwTitleID;
DWORD dwProcedureIndex;
XNADDR HostAddress;
WORD wNumUsers;
WORD wFlags;
DWORD dwNumAttributes;
DWORD *pAttributeOffsets;
XONLINE_ATTRIBUTE *pAttributes;
XONLINE_MATCH_SEARCHRESULT_HEADER *pSearchResults;
} XMATCH_SEARCH_REQUEST;
typedef struct _STRING_LOOKUP_RESPONSE
{
WORD wNumStrings;
STRING_DATA *pStringData;
} STRING_LOOKUP_RESPONSE;
typedef struct _STRING_V1_TITLE_ID_REQUEST
{
WORD wType;
WORD wLanguage;
WORD wNumTitles;
DWORD *pTitleIDs;
STRING_LOOKUP_RESPONSE *pResults;
} STRING_V1_TITLE_ID_REQUEST;
typedef struct _STRING_LOOKUP_2_REQUEST
{
DWORD dwTitleID;
WORD wNumStrings;
WORD wLocaleLen;
CHAR *szLocale;
DWORD *pStringIDs;
STRING_LOOKUP_RESPONSE *pResults;
} STRING_LOOKUP_2_REQUEST;
typedef struct _STRING_VERIFY_2_REQUEST
{
DWORD dwTitleID;
DWORD dwFlags;
WORD wLocaleLen;
WORD wNumStrings;
CHAR *szLocale;
STRING_DATA *pStringData;
STRING_VERIFY_RESPONSE *pResults;
} STRING_VERIFY_2_REQUEST;
typedef struct _BASE_MSG_HEADER
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
} BASE_MSG_HEADER;
typedef struct _P_REPLY_BUDDY
{
ULONGLONG qwBuddyID;
WORD cbAcctName;
BYTE bStatus;
CHAR *szAcctName;
} P_REPLY_BUDDY;
typedef struct _P_REPLY_BLOCK
{
ULONGLONG qwBlockID;
} P_REPLY_BLOCK;
typedef struct _P_ALIVE_REPLY_MSG
{
BASE_MSG_HEADER MsgHeader;
HRESULT hr;
DWORD dwBuddyListVersion;
WORD cBuddiesSent;
DWORD dwBlockListVersion;
WORD cBlocksSent;
P_REPLY_BUDDY *pBuddies;
P_REPLY_BLOCK *pBlocks;
} P_ALIVE_REPLY_MSG;
typedef struct _XPRESENCE_ALIVE_REPLY
{
P_ALIVE_REPLY_MSG *pAliveReplies;
} XPRESENCE_ALIVE_REPLY, *PPRESENCE_ALIVE_REPLY;
typedef struct _XBOX_LIBRARY_VERSION
{
WORD wMajorVersion;
WORD wMinorVersion;
WORD wBuildNumber;
WORD wQFENumber;
} XBOX_LIBRARY_VERSION;
typedef struct _P_ALIVE_2_MSG
{
BASE_MSG_HEADER MsgHeader;
ULONGLONG qwUserID;
WORD cbAcctName;
XNADDR xnaddr;
XNKID xnkid;
XNKEY xnkey;
DWORD dwBuddyListVersion;
DWORD dwBlockListVersion;
XBOX_LIBRARY_VERSION clientVersion;
DWORD dwTitleID;
DWORD dwTitleVersion;
DWORD dwTitleRegion;
WORD ipportI;
IN_ADDR ipaI;
ULONGLONG liNonce;
ULONGLONG liTimeInit;
CHAR *szAcctName;
} P_ALIVE_2_MSG;
typedef struct _XPRESENCE_SEND_ALIVE
{
P_ALIVE_2_MSG *pAlives;
XPRESENCE_ALIVE_REPLY *pAliveReply;
} XPRESENCE_SEND_ALIVE;
typedef struct _P_DEAD_USER_MSG
{
BASE_MSG_HEADER MsgHeader;
ULONGLONG qwUserID;
} P_DEAD_USER_MSG;
typedef struct _XPRESENCE_SEND_DEAD_USER
{
P_DEAD_USER_MSG *pDeadUsers;
} XPRESENCE_SEND_DEAD_USER;
typedef struct _P_LIST_CHANGE_ITEM
{
DWORD dwListVersion;
ULONGLONG qwTargetID;
WORD wOperationID;
HRESULT hr;
WORD cbTargetAcctName;
CHAR *szTargetAcctName;
} P_LIST_CHANGE_ITEM;
typedef struct _P_PRESENCE_ITEM
{
ULONGLONG qwBuddyID;
DWORD dwTitleID;
DWORD dwState;
XNKID MatchSessionID;
WORD cbNickname;
WORD cbTitleStuff;
BYTE *rgbNickName;
BYTE *rgbTitleStuff;
} P_PRESENCE_ITEM;
typedef struct _P_PEER_PRESENCE_ITEM
{
ULONGLONG qwUserID;
DWORD dwTitleID;
DWORD dwState;
XNKID MatchSessionID;
WORD cbTitleStuff;
BYTE *rgbTitleStuff;
} P_PEER_PRESENCE_ITEM;
typedef struct _P_PRESENCE_2_ITEM
{
ULONGLONG qwUserID;
DWORD dwTitleID;
DWORD dwState;
XNKID MatchSessionID;
MSGTIME mtUserTime;
WORD cbRichPresence;
WORD cbData;
WCHAR *wszRichPresence;
BYTE *rgbData;
} P_PRESENCE_2_ITEM;
typedef struct _P_INVITE_ACTION_ITEM
{
ULONGLONG qwTargetID;
DWORD dwContext;
XNKID SessionID;
} P_INVITE_ACTION_ITEM;
typedef struct _P_INVITATION_ITEM
{
ULONGLONG qwHostID;
XNKID MatchSessionID;
DWORD dwTitleID;
FILETIME ftSent;
} P_INVITATION_ITEM;
typedef struct _P_INVITATION_ANSWER_ITEM
{
ULONGLONG qwInviteeID;
XNKID MatchSessionID;
ULONGLONG ftSent;
WORD wAnswer;
} P_INVITATION_ANSWER_ITEM;
typedef union _Q_REPLY_ITEM
{
P_LIST_CHANGE_ITEM ChangeItem;
P_PRESENCE_ITEM PresenceItem;
P_INVITATION_ITEM InvitationItem;
P_INVITATION_ANSWER_ITEM AnswerItem;
P_PEER_PRESENCE_ITEM PeerPresenceItem;
P_PRESENCE_2_ITEM RichPresenceItem;
P_INVITE_ACTION_ITEM InviteActionItem;
} Q_REPLY_ITEM;
typedef struct _Q_LIST_ITEM
{
DWORD dwItemID;
WORD wItemLen;
Q_REPLY_ITEM ReplyItem;
} Q_LIST_ITEM;
typedef struct _Q_LIST_REPLY_MSG
{
BASE_MSG_HEADER MsgHeader;
ULONGLONG qwUserID;
WORD wQType;
HRESULT hr;
DWORD dwNextItemID;
WORD wQLeft;
WORD wNumItems;
DWORD dwTotalItemDataSize;
DWORD cdwQVals;
DWORD *rgdwQVals;
Q_LIST_ITEM *rgItems;
} Q_LIST_REPLY_MSG, *PQ_LIST_REPLY_MSG;
typedef struct _Q_DEQUEUE_MSG
{
BASE_MSG_HEADER MsgHeader;
ULONGLONG qwUserID;
WORD wQType;
DWORD dwStartItemID;
WORD wMaxItems;
DWORD dwMaxTotalItemDataSize;
} Q_DEQUEUE_MSG;
typedef struct _XNOTIFICATION_SEND_DEQUEUE
{
Q_DEQUEUE_MSG pDequeueMsg[1];
Q_LIST_REPLY_MSG *pReply;
} XNOTIFICATION_SEND_DEQUEUE;
typedef struct _PRESENCE_SET_STATE
{
XUID UserXuid;
DWORD dwStateFlags;
XNKID sessionID;
DWORD cbState;
BYTE *pbState;
} PRESENCE_SET_STATE;
typedef struct _PRESENCE_GET_STATE
{
XUID UserXuid;
DWORD pdwStateFlags[1];
XNKID pSessionID[1];
} PRESENCE_GET_STATE;
typedef struct _NOTIFICATION_UPDATE_STATE_FLAGS
{
XUID UserXuid;
DWORD dwStateFlagsSet;
DWORD dwStateFlagsClear;
} NOTIFICATION_UPDATE_STATE_FLAGS;
typedef struct _PRESENCE_SET_GAME_SESSION
{
XUID UserXuid;
XNKID sessionID;
} PRESENCE_SET_GAME_SESSION;
typedef struct _GET_SESSION_RESULTS
{
ULONGLONG qwHostUserID;
DWORD dwTitleID;
DWORD dwTitleVersion;
DWORD dwTitleRegion;
XNADDR xnaddr;
XNKID xkid;
XNKEY xnkey;
} GET_SESSION_RESULTS, *PGET_SESSION_RESULTS;
typedef struct _P_PEER_SESSION_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
XUID qwHostUserID;
GET_SESSION_RESULTS *pResults;
} P_PEER_SESSION_MSG;
typedef struct _P_GET_PEER_SESSION
{
GET_SESSION_RESULTS *pResults;
} P_GET_PEER_SESSION;
typedef struct _P_PEER_SUBSCRIBE_REPLY_MSG
{
BYTE pbInternal[32];
HRESULT hr;
} P_PEER_SUBSCRIBE_REPLY_MSG;
typedef struct _P_PEER_SUBSCRIBE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
WORD cSrcUserIDs;
ULONGLONG *rgqwSrcUserIDs;
P_PEER_SUBSCRIBE_REPLY_MSG *pResults;
} P_PEER_SUBSCRIBE_MSG;
typedef struct _P_PEER_UNSUBSCRIBE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
} P_PEER_UNSUBSCRIBE_MSG;
typedef struct _P_PRESENCE_ENUM_CREATE_MSG
{
DWORD dwUserIndex;
DWORD cPeers;
XUID *pPeers;
DWORD dwStartingIndex;
DWORD dwPeersToReturn;
DWORD pcbBuffer[1];
HANDLE ph[1];
} P_PRESENCE_ENUM_CREATE_MSG;
typedef struct _P_PRESENCE_SUBSCRIBE_MSG
{
DWORD dwUserIndex;
DWORD cPeers;
XUID *pPeers;
} P_PRESENCE_SUBSCRIBE_MSG;
typedef struct _P_PRESENCE_INITIALIZE_MSG
{
DWORD cPeerSubscriptions;
} P_PRESENCE_INITIALIZE_MSG;
typedef struct _SET_USER_SETTINGS2_REQUEST_STRUCT
{
XUID qwUserId;
WORD bTier;
WORD dwUserFlags;
DWORD rgPrivileges[8];
} SET_USER_SETTINGS2_REQUEST_STRUCT;
typedef struct _UPDATE_PARENTAL_CONTROLS_STRUCT
{
XUID qwUserId;
DWORD rgGrantPrivileges[8];
DWORD rgRestrictPrivileges[8];
WORD wSourceLength;
WCHAR *wszSource;
} UPDATE_PARENTAL_CONTROLS_STRUCT;
typedef struct _GET_POINTS_BALANCE_RESPONSE
{
DWORD dwPointsBalance;
BYTE bDMPAccountStatus;
BYTE bResponseFlags;
} GET_POINTS_BALANCE_RESPONSE;
typedef struct _GET_POINTS_BALANCE_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
GET_POINTS_BALANCE_RESPONSE *pResults;
} GET_POINTS_BALANCE_REQUEST;
typedef struct _PHONE_INFO
{
WORD wPhonePrefixLength;
WCHAR *wszPhonePrefix;
WORD wPhoneNumberLength;
WCHAR *wszPhoneNumber;
WORD wPhoneExtensionLength;
WCHAR *wszPhoneExtension;
} PHONE_INFO;
typedef struct _CREDIT_CARD_INFO
{
BYTE bCardTypeId;
WORD wAccountHolderNameLength;
WCHAR *wszAccountHolderName;
WORD wAccountNumberLength;
WCHAR *wszAccountNumber;
WORD wCCVNumberLength;
WCHAR *wszCCVNumber;
FILETIME ftExpirationDate;
} CREDIT_CARD_INFO;
typedef struct _DIRECT_DEBIT_INFO
{
WORD wAccountHolderNameLength;
WCHAR *wszAccountHolderName;
WORD wAccountNumberLength;
WCHAR *wszAccountNumber;
WORD wBankCodeLength;
WCHAR *wszBankCode;
WORD wBranchCodeLength;
WCHAR *wszBranchCode;
WORD wCheckDigitsLength;
WCHAR *wszCheckDigits;
} DIRECT_DEBIT_INFO;
typedef struct _CREATE_LIVE_ACCOUNT_RESPONSE
{
ULONGLONG qwUserId;
BYTE abXboxKey[16];
BYTE abXenonKey[16];
} CREATE_LIVE_ACCOUNT_RESPONSE;
typedef struct _CREATE_LIVE_ACCOUNT_REQUEST_OLD
{
ULONGLONG qwMachineId;
ULONGLONG qwTitleId;
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
WORD wGamertagLength;
WCHAR *wszGamertag;
ULONGLONG qwUserPassportPuid;
ULONGLONG qwOwnerPassportPuid;
ULONGLONG qwOfferId;
WORD wBillingTokenLength;
WCHAR *wszBillingToken;
FILETIME ftBirthdate;
WORD wEmailLength;
WCHAR *wszEmail;
WORD wLanguageId;
BYTE bCountryId;
DWORD dwParentalControlGroupId;
BYTE bMsftOptIn;
BYTE bPartnerOptIn;
ADDRESS_INFO address;
PHONE_INFO phone;
BYTE bPaymentTypeId;
CREDIT_CARD_INFO creditCard;
DIRECT_DEBIT_INFO directDebit;
CREATE_LIVE_ACCOUNT_RESPONSE *pResponse;
} CREATE_LIVE_ACCOUNT_REQUEST_OLD;
typedef struct _CREATE_LIVE_ACCOUNT_REQUEST
{
ULONGLONG qwMachineId;
ULONGLONG qwOfflineXuid;
DWORD dwTitleId;
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
WORD wGamertagLength;
WCHAR *wszGamertag;
BYTE abSignedUserPassportPuid[28];
BYTE abSignedOwnerPassportPuid[28];
ULONGLONG qwOfferId;
WORD wBillingTokenLength;
WCHAR *wszBillingToken;
FILETIME ftBirthdate;
WORD wEmailLength;
WCHAR *wszEmail;
WORD wLanguageId;
BYTE bCountryId;
DWORD dwParentalControlGroupId;
BYTE bMsftOptIn;
BYTE bPartnerOptIn;
ADDRESS_INFO address;
PHONE_INFO phone;
BYTE bPaymentTypeId;
CREDIT_CARD_INFO creditCard;
DIRECT_DEBIT_INFO directDebit;
WORD wReservedBytesLength;
BYTE *pbReservedBytes;
CREATE_LIVE_ACCOUNT_RESPONSE *pResponse;
} CREATE_LIVE_ACCOUNT_REQUEST;
typedef struct _GET_USER_INFO_REQUEST
{
ULONGLONG qwUserId;
ULONGLONG qwMachineId;
DWORD dwTitleId;
GET_USER_INFO_RESPONSE *pResponse;
} GET_USER_INFO_REQUEST;
typedef struct _RECOVER_ACCOUNT_RESPONSE
{
ULONGLONG qwUserId;
ULONGLONG qwOfflineXuid;
BYTE pKey[16];
WORD wGamertagLength;
WCHAR *wszGamertag;
WORD wDomainLength;
WCHAR *wszDomain;
WORD wRealmLength;
WCHAR *wszRealm;
} RECOVER_ACCOUNT_RESPONSE;
typedef struct _RECOVER_ACCOUNT_REQUEST
{
ULONGLONG qwMachineId;
BYTE pSignedPuid[28];
RECOVER_ACCOUNT_RESPONSE *pResponse;
} RECOVER_ACCOUNT_REQUEST;
typedef struct _PASSPORT_ENCRYPTED_PROXY_PARAMETERS
{
WORD wLoginTokenRequestLength;
BYTE *pbLoginTokenRequest;
DWORD dwPublicKeyPublicExponent;
WORD wPublicKeyModulusLength;
BYTE *pbPublicKeyModulus;
BYTE abPublicKeyDigest[20];
} PASSPORT_ENCRYPTED_PROXY_PARAMETERS;
typedef struct _PASSPORT_GET_ENCRYPTED_PROXY_PARAMETERS_REQUEST
{
DWORD dwDummy;
PASSPORT_ENCRYPTED_PROXY_PARAMETERS *pResponse;
} PASSPORT_GET_ENCRYPTED_PROXY_PARAMETERS_REQUEST;
typedef struct _PASSPORT_SESSION_TOKEN
{
BYTE abSessionToken[28];
} PASSPORT_SESSION_TOKEN;
typedef struct _PASSPORT_CREATE_REQUEST
{
WORD wPassportMemberNameLength;
CHAR *szPassportMemberName;
WORD wSecretQuestionLength;
WCHAR *szSecretQuestion;
WORD wEncryptedPasswordLength;
BYTE *pbEncryptedPassword;
PASSPORT_SESSION_TOKEN *pSessionToken;
} PASSPORT_CREATE_REQUEST;
typedef struct _PASSPORT_LOGIN_REQUEST
{
WORD wPassportMemberNameLength;
CHAR *szPassportMemberName;
WORD wEncryptedSessionKeyLength;
BYTE *pbencryptedSessionKey;
WORD wEncryptedPasswordLength;
BYTE *pbEncryptedPassword;
WORD wEncryptedTokenRequestLength;
BYTE *pbEncryptedTokenRequest;
PASSPORT_SESSION_TOKEN *pSessionToken;
} PASSPORT_LOGIN_REQUEST;
typedef struct _PASSPORT_CHANGE_PASSWORD_REQUEST
{
PASSPORT_SESSION_TOKEN pSessionToken[1];
WORD wPassportMemberNameLength;
CHAR *szPassportMemberName;
WORD wEncryptedPasswordLength;
BYTE *pbEncryptedPassword;
} PASSPORT_CHANGE_PASSWORD_REQUEST;
typedef struct _PAYMENT_INSTRUMENT_INFO
{
WORD wPaymentInstrumentIdLength;
WCHAR *wszPaymentInstrumentId;
BYTE bPaymentTypeId;
ADDRESS_INFO address;
PHONE_INFO phone;
CREDIT_CARD_INFO creditCard;
DIRECT_DEBIT_INFO directDebit;
} PAYMENT_INSTRUMENT_INFO;
typedef struct _GET_PAYMENT_INSTRUMENTS_RESPONSE
{
WORD wCount;
PAYMENT_INSTRUMENT_INFO *pPaymentInstruments;
} GET_PAYMENT_INSTRUMENTS_RESPONSE;
typedef struct _GET_PAYMENT_INSTRUMENTS_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
WORD wMaxResults;
GET_PAYMENT_INSTRUMENTS_RESPONSE *pResponse;
} GET_PAYMENT_INSTRUMENTS_REQUEST;
typedef struct _ADD_PAYMENT_INSTRUMENT_RESPONSE
{
WORD wPaymentInstrumentIdLength;
WCHAR *wszPaymentInstrumentId;
} ADD_PAYMENT_INSTRUMENT_RESPONSE;
typedef struct _ADD_PAYMENT_INSTRUMENT_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
ADDRESS_INFO addressInfo;
PHONE_INFO phoneInfo;
BYTE bPaymentTypeId;
CREDIT_CARD_INFO creditCardInfo;
DIRECT_DEBIT_INFO directDebitInfo;
ADD_PAYMENT_INSTRUMENT_RESPONSE *pResponse;
} ADD_PAYMENT_INSTRUMENT_REQUEST;
typedef struct _REMOVE_PAYMENT_INSTRUMENT_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
WORD wPaymentInstrumentIdLength;
WCHAR *wszPaymentInstrumentId;
} REMOVE_PAYMENT_INSTRUMENT_REQUEST;
typedef struct _UPDATE_PAYMENT_INSTRUMENT_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
WORD wPaymentInstrumentIdLength;
WCHAR *wszPaymentInstrumentId;
ADDRESS_INFO addressInfo;
PHONE_INFO phoneInfo;
CREDIT_CARD_INFO creditCardInfo;
DIRECT_DEBIT_INFO directDebitInfo;
} UPDATE_PAYMENT_INSTRUMENT_REQUEST;
typedef struct _GET_LINKED_GAMERTAG_RESPONSE
{
XUID qwUserPuid;
WORD wGamertagLength;
WCHAR *wszGamertag;
} GET_LINKED_GAMERTAG_RESPONSE;
typedef struct _GET_LINKED_GAMERTAG_REQUEST
{
BYTE pSignedPuid[28];
GET_LINKED_GAMERTAG_RESPONSE *pResponse;
} GET_LINKED_GAMERTAG_REQUEST;
typedef struct _PASSPORT_SECRET_QUESTION
{
WORD wSecretQuestionLength;
WCHAR *szSecretQuestion;
} PASSPORT_SECRET_QUESTION;
typedef struct _PASSPORT_GET_SECRET_QUESTION_RESPONSE
{
WORD wSecretQuestionsCount;
PASSPORT_SECRET_QUESTION *pSecretQuestions;
} PASSPORT_GET_SECRET_QUESTION_RESPONSE;
typedef struct _PASSPORT_GET_SECRET_QUESTIONS_REQUEST
{
WORD wCountryId;
WORD wLanguageId;
PASSPORT_GET_SECRET_QUESTION_RESPONSE *pResult;
} PASSPORT_GET_SECRET_QUESTIONS_REQUEST;
typedef struct _SET_ACCOUNT_INFO_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
FILETIME ftBirthdate;
WORD wEmailLength;
WCHAR *wszEmail;
ADDRESS_INFO address;
PHONE_INFO phone;
WORD wLanguageId;
BYTE bMsftOptIn;
BYTE bParterOptIn;
} SET_ACCOUNT_INFO_REQUEST;
typedef struct _GET_ACCOUNT_INFO_RESPONSE
{
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
FILETIME ftBirthdate;
WORD wEmailLength;
WCHAR *wszEmail;
ADDRESS_INFO addressInfo;
PHONE_INFO phoneInfo;
WORD wLanguageId;
BYTE bCountryId;
BYTE bMsftOptIn;
BYTE bParterOptIn;
} GET_ACCOUNT_INFO_RESPONSE;
typedef struct _GET_ACCOUNT_INFO_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
DWORD dwTitleId;
GET_ACCOUNT_INFO_RESPONSE *pResponse;
} GET_ACCOUNT_INFO_REQUEST;
typedef struct _PASSPORT_GET_USER_DATA_RESPONSE
{
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
FILETIME ftBirthdate;
ADDRESS_INFO address;
PHONE_INFO phone;
BYTE bCountryId;
WORD wEmailLength;
WCHAR *wszEmail;
} PASSPORT_GET_USER_DATA_RESPONSE;
typedef struct _PASSPORT_GET_USER_DATA_REQUEST
{
PASSPORT_SESSION_TOKEN pSessionToken[1];
PASSPORT_GET_USER_DATA_RESPONSE *pResult;
} PASSPORT_GET_USER_DATA_REQUEST;
typedef struct _PASSPORT_GET_MEMBER_NAME_RESPONSE
{
WORD wUserPmnLength;
WCHAR *wszUserPmn;
WORD wParentPmnLength;
WCHAR *wszParentPmn;
} PASSPORT_GET_MEMBER_NAME_RESPONSE;
typedef struct _PASSPORT_GET_MEMBER_NAME_REQUEST
{
ULONGLONG qwUserId;
PASSPORT_GET_MEMBER_NAME_RESPONSE *pResult;
} PASSPORT_GET_MEMBER_NAME_REQUEST;
typedef struct _POSTAL_CODE_MATCH
{
WORD wPostalCodeLength;
WCHAR *wszPostalCode;
WORD wStateLength;
WCHAR *wszState;
WORD wCityLength;
WCHAR *wszCity;
WORD wStreetLength;
WCHAR *wszStreet;
} POSTAL_CODE_MATCH;
typedef struct _GET_POSTAL_CODE_RESPONSE
{
BYTE bCount;
POSTAL_CODE_MATCH *pMatches;
} GET_POSTAL_CODE_RESPONSE;
typedef struct _GET_POSTAL_CODE_REQUEST
{
BYTE bCountryId;
WORD wPostalCodeLength;
WCHAR *wszPostalCode;
GET_POSTAL_CODE_RESPONSE *pResponse;
} GET_POSTAL_CODE_REQUEST;
typedef struct _GET_USER_SUBSCRIPTION_DETAILS_DATA
{
DWORD dwWholePart;
BYTE bFractionalPart;
BYTE bCurrencyFormat;
WORD wISOCodeLength;
WCHAR *wszISOCode;
WORD wFormattedPriceLength;
WCHAR *wszFormattedPrice;
DWORD dwOfferingDetails;
} GET_USER_SUBSCRIPTION_DETAILS_DATA;
typedef struct _GET_USER_SUBSCRIPTION_DETAILS_RESPONSE
{
WORD wSubscriptionIdLength;
WCHAR *wszSubscriptionId;
WORD wDescriptionLength;
WCHAR *wszDescription;
BYTE bCurrentOfferStatus;
WORD wFriendlyNameLength;
WCHAR *wszFriendlyName;
BYTE bAnniversaryDate;
FILETIME ftPurchaseDate;
FILETIME ftActivationDate;
FILETIME ftEndDate;
BYTE bHasViolations;
DWORD dwRenewalGracePeriod;
BYTE bRenewalOfferStatus;
ULONGLONG qwRenewalOfferId;
GET_USER_SUBSCRIPTION_DETAILS_DATA currentOfferDetails;
GET_USER_SUBSCRIPTION_DETAILS_DATA renewalOfferDetails;
PAYMENT_INSTRUMENT_INFO paymentInstrument;
} GET_USER_SUBSCRIPTION_DETAILS_RESPONSE;
typedef struct _GET_USER_SUBSCRIPTION_DETAILS_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
ULONGLONG qwOfferId;
WORD wInstanceIdLength;
WCHAR *wszInstanceId;
GET_USER_SUBSCRIPTION_DETAILS_RESPONSE *pResponse;
} GET_USER_SUBSCRIPTION_DETAILS_REQUEST;
typedef struct _VERIFY_BILLING_TOKEN_RESPONSE
{
ULONGLONG qwOfferId;
DWORD dwOfferTypeId;
} VERIFY_BILLING_TOKEN_RESPONSE;
typedef struct _VERIFY_BILLING_TOKEN_REQUEST
{
BYTE bCountryId;
WORD wBillingTokenLength;
WCHAR *wszBillingToken;
VERIFY_BILLING_TOKEN_RESPONSE *pResponse;
} VERIFY_BILLING_TOKEN_REQUEST;
typedef struct _MIGRATE_XBOX1_USER_RESPONSE
{
ULONGLONG qwUserId;
BYTE abXenonKey[16];
WORD wGamertagLength;
WCHAR *wszGamertag;
WORD wDomainLength;
WCHAR *wszDomain;
WORD wRealmLength;
WCHAR *wszRealm;
DWORD dwParentalControlGroupId;
DWORD dwCultureId;
} MIGRATE_XBOX1_USER_RESPONSE;
typedef struct _MIGRATE_XBOX1_USER_REQUEST
{
PASSPORT_SESSION_TOKEN pUserSessionToken[1];
PASSPORT_SESSION_TOKEN pParentSessionToken[1];
ULONGLONG qwOfflineXuid;
WORD wUserPassportMemberNameLength;
CHAR *szUserPassportMemberName;
DWORD dwTitleId;
ULONGLONG qwMachineId;
WORD wLanguageId;
WORD wReservedBytesLength;
BYTE *pbReservedBytes;
MIGRATE_XBOX1_USER_RESPONSE *pResponse;
} MIGRATE_XBOX1_USER_REQUEST;
typedef struct _OFFER_PRICE
{
DWORD dwPaymentType;
BYTE bTaxType;
DWORD dwWholePrice;
DWORD dwFractionalPrice;
WORD wPriceTextLength;
WCHAR *wszPriceText;
} OFFER_PRICE;
typedef struct _ACCOUNT_SUGGESTED_GAMERTAG
{
WORD wGamertagLength;
WCHAR *wszGamertag;
} ACCOUNT_SUGGESTED_GAMERTAG;
typedef struct _ACCOUNT_RESERVE_GAMERTAG_RESPONSE
{
DWORD dwHresult;
WORD wGamertagCount;
ACCOUNT_SUGGESTED_GAMERTAG *pGamertags;
} ACCOUNT_RESERVE_GAMERTAG_RESPONSE;
typedef struct _ACCOUNT_RESERVE_GAMERTAG_REQUEST
{
ULONGLONG qwMachineId;
BYTE bCountryId;
WORD wMaxSuggestedNames;
WORD wGamertagLength;
WCHAR *wszGamertag;
ACCOUNT_RESERVE_GAMERTAG_RESPONSE *pResponse;
} ACCOUNT_RESERVE_GAMERTAG_REQUEST;
typedef struct _ACCOUNT_CHANGE_GAMERTAG_RESPONSE
{
BYTE abKey[16];
} ACCOUNT_CHANGE_GAMERTAG_RESPONSE;
typedef struct _ACCOUNT_CHANGE_GAMERTAG_REQUEST
{
ULONGLONG qwMachineId;
ULONGLONG qwUserId;
WORD wGamertagLength;
WCHAR *wszGamertag;
ACCOUNT_CHANGE_GAMERTAG_RESPONSE *pResponse;
} ACCOUNT_CHANGE_GAMERTAG_REQUEST;
typedef struct _CHANGE_SUBSCRIPTION_PAYMENT_INSTRUMENT_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
WORD wInstanceIdLength;
WCHAR *wszInstanceId;
WORD wPaymentInstrumentIdLength;
WCHAR *wszPaymentInstrumentId;
} CHANGE_SUBSCRIPTION_PAYMENT_INSTRUMENT_REQUEST;
typedef struct _VERIFY_PARENT_CREDIT_CARD_REQUEST
{
ULONGLONG qwMachineId;
DWORD dwTitleId;
PASSPORT_SESSION_TOKEN pParentSessionToken[1];
WORD wParentPassportMemberNameLength;
CHAR *szParentPassportMemberName;
WORD wLanguageId;
BYTE bCountryId;
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
WORD wEmailLength;
WCHAR *wszEmail;
ADDRESS_INFO address;
PHONE_INFO phone;
CREDIT_CARD_INFO creditCardInfo;
} VERIFY_PARENT_CREDIT_CARD_REQUEST;
typedef struct _ACCOUNT_TROUBLESHOOT_RESPONSE
{
BOOL fNewTOS;
BOOL fNameChangeRequired;
BOOL fDowngraded;
FILETIME suspendedUntil;
WORD wTotalDaysSuspended;
FILETIME voiceBannedUntil;
WORD wTotalDaysVoiceBanned;
DWORD dwBillingHr;
WORD wReservedBytesLength;
BYTE *pbReservedBytes;
} ACCOUNT_TROUBLESHOOT_RESPONSE;
typedef struct _ACCOUNT_TROUBLESHOOT_REQUEST
{
ULONGLONG qwUserId;
ULONGLONG qwMachineId;
WORD wReservedBytesLength;
BYTE *pbReservedBytes;
ACCOUNT_TROUBLESHOOT_RESPONSE *pResponse;
} ACCOUNT_TROUBLESHOOT_REQUEST;
typedef struct _ACCOUNT_ACKNOWLEDGE_DOWNGRADE_REQUEST
{
ULONGLONG qwUserId;
} ACCOUNT_ACKNOWLEDGE_DOWNGRADE_REQUEST;
typedef struct _ACCOUNT_QUERY_RESPONSE
{
WORD wResponseBytesLength;
BYTE *pbResponseBytes;
} ACCOUNT_QUERY_RESPONSE;
typedef struct _ACCOUNT_QUERY_REQUEST
{
DWORD dwRequestType;
WORD wRequestBytesLength;
BYTE *pbRequestBytes;
ACCOUNT_QUERY_RESPONSE *pResults;
} ACCOUNT_QUERY_REQUEST;
typedef struct _ACCOUNT_ACCEPT_TOU_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
} ACCOUNT_ACCEPT_TOU_REQUEST;
typedef struct _ACCOUNT_SET_STATUS_REQUEST
{
XUID qwUserId;
DWORD dwNewTermsOfService;
DWORD dwForceNameChangeRequired;
FILETIME ftSuspendedUntil;
WORD wTotalDaysSuspended;
FILETIME ftVoiceBannedUntil;
WORD wTotalDaysVoiceBanned;
DWORD dwBillingHr;
DWORD dwResetPassword;
} ACCOUNT_SET_STATUS_REQUEST;
typedef struct _ACCOUNT_VERIFY_BILLING_INFO_RESPONSE
{
XUID qwUserPuid;
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
FILETIME ftBirthdate;
WORD wEmailLength;
WCHAR *wszEmail;
ADDRESS_INFO addressInfo;
PHONE_INFO phoneInfo;
WORD wLanguageId;
BYTE bCountryId;
BYTE bMsftOptIn;
BYTE bParterOptIn;
} ACCOUNT_VERIFY_BILLING_INFO_RESPONSE;
typedef struct _ACCOUNT_VERIFY_BILLING_INFO_REQUEST
{
ULONGLONG qwMachineId;
WORD wGamertagLength;
WCHAR *wszGamertag;
PHONE_INFO phone;
WORD wPostalCodeLength;
WCHAR *wszPostalCode;
WORD wAccountHolderNameLength;
WCHAR *wszAccountHolderName;
WORD wAccountNumberLength;
WCHAR *wszAccountNumber;
ACCOUNT_VERIFY_BILLING_INFO_RESPONSE *pResponse;
} ACCOUNT_VERIFY_BILLING_INFO_REQUEST;
typedef struct _ACCOUNT_GET_USER_TYPE_RESPONSE
{
BYTE bUserType;
} ACCOUNT_GET_USER_TYPE_RESPONSE;
typedef struct _ACCOUNT_GET_USER_TYPE_REQUEST
{
ULONGLONG qwMachineId;
WORD wGamertagLength;
WCHAR *wszGamertag;
ACCOUNT_GET_USER_TYPE_RESPONSE *pResponse;
} ACCOUNT_GET_USER_TYPE_REQUEST;
typedef struct _ACCOUNT_LINK_XBOX1_ACCOUNT_REQUEST
{
ULONGLONG qwMachineId;
DWORD dwTitleId;
WORD wGamertagLength;
WCHAR *wszGamertag;
PASSPORT_SESSION_TOKEN pUserSessionToken[1];
PASSPORT_SESSION_TOKEN pParentSessionToken[1];
PHONE_INFO phoneInfo;
WORD wPostalCodeLength;
WCHAR *wszPostalCode;
WORD wAccountHolderNameLength;
WCHAR *wszAccountHolderName;
WORD wAccountNumberLength;
WCHAR *wszAccountNumber;
} ACCOUNT_LINK_XBOX1_ACCOUNT_REQUEST;
typedef struct _MIGRATE_XBOX_COM_USER_RESPONSE
{
ULONGLONG qwUserId;
BYTE abXenonKey[16];
WORD wGamertagLength;
WCHAR *wszGamertag;
WORD wDomainLength;
WCHAR *wszDomain;
WORD wRealmLength;
WCHAR *wszRealm;
DWORD dwParentalControlGroupId;
DWORD dwCultureId;
} MIGRATE_XBOX_COM_USER_RESPONSE;
typedef struct _MIGRATE_XBOX_COM_USER_REQUEST
{
PASSPORT_SESSION_TOKEN pUserSessionToken[1];
ULONGLONG qwOfflineXuid;
DWORD dwTitleId;
ULONGLONG qwMachineId;
BYTE bCountryId;
WORD wLanguageId;
ULONGLONG qwOfferId;
WORD wBillingTokenLength;
WCHAR *wszBillingToken;
WORD wFirstNameLength;
WCHAR *wszFirstName;
WORD wLastNameLength;
WCHAR *wszLastName;
WORD wEmailLength;
WCHAR *wszEmail;
ADDRESS_INFO address;
PHONE_INFO phone;
BYTE bPaymentTypeId;
CREDIT_CARD_INFO creditCard;
DIRECT_DEBIT_INFO directDebit;
MIGRATE_XBOX_COM_USER_RESPONSE *pResponse;
} MIGRATE_XBOX_COM_USER_REQUEST;
typedef struct _GET_ACCOUNT_INFO_FROM_PASSPORT_REQUEST
{
PASSPORT_SESSION_TOKEN pSessionToken[1];
ULONGLONG qwMachineId;
DWORD dwTitleId;
GET_ACCOUNT_INFO_RESPONSE *pResponse;
} GET_ACCOUNT_INFO_FROM_PASSPORT_REQUEST;
typedef struct _BASIC_CONTENT_INFO
{
ULONGLONG qwOfferID;
WORD wOfferNameLength;
WCHAR *wszOfferName;
DWORD dwOfferType;
BYTE contentId[20];
DWORD dwTitleID;
DWORD dwTitleCategory;
WORD wTitleNameLength;
WCHAR *wszTitleName;
BYTE bTierRequired;
WORD wGameRating;
WORD wResponseFlags;
DWORD dwPackageSize;
DWORD dwInstallSize;
DWORD dwSellTextLength;
WCHAR *wszSellText;
BYTE bPricesLength;
OFFER_PRICE *pPrices;
} BASIC_CONTENT_INFO;
typedef struct _CONTENT_ENUMERATE_RESPONSE
{
WORD wOffersReturned;
BASIC_CONTENT_INFO *pInfos;
DWORD dwOffersTotal;
} CONTENT_ENUMERATE_RESPONSE;
typedef struct _CONTENT_ENUMERATE_REQUEST
{
XUID qwUserId;
BYTE bCountryId;
WORD wLanguageId;
WORD wGameRating;
DWORD dwOfferType;
DWORD dwPaymentType;
BYTE bTier;
DWORD dwTitleId;
DWORD dwTitleCategories;
BYTE bRequestFlags;
DWORD dwStartingIndex;
DWORD dwMaxResults;
CONTENT_ENUMERATE_RESPONSE *pResults;
} CONTENT_ENUMERATE_REQUEST;
typedef struct _CONTENT_DETAILS_RESPONSE
{
BASIC_CONTENT_INFO basicInfo;
} CONTENT_DETAILS_RESPONSE;
typedef struct _CONTENT_DETAILS_REQUEST
{
XUID qwUserId;
BYTE bCountryId;
WORD wLanguageId;
ULONGLONG qwOfferID;
DWORD dwPaymentType;
BYTE bTierRequired;
BYTE bRatingSystem;
CONTENT_DETAILS_RESPONSE *pResults;
} CONTENT_DETAILS_REQUEST;
typedef struct _CONTENT_AVAILABLE_RESPONSE
{
BYTE bNewOffersLength;
DWORD *pdwNewOffers;
BYTE bTotalOffersLength;
DWORD *pdwTotalOffers;
} CONTENT_AVAILABLE_RESPONSE;
typedef struct _CONTENT_AVAILABLE_REQUEST
{
XUID qwUserId;
BYTE bCountryId;
BYTE bTier;
DWORD dwTitleId;
CONTENT_AVAILABLE_RESPONSE *pResults;
} CONTENT_AVAILABLE_REQUEST;
typedef struct _UPDATE_ACCESS_TIMES_REQUEST
{
XUID qwUserId;
DWORD dwTitleId;
DWORD dwTitleCategories;
} UPDATE_ACCESS_TIMES_REQUEST;
typedef struct _BASIC_SUBSCRIPTION_INFO
{
ULONGLONG qwOfferID;
WORD wOfferNameLength;
WCHAR *wszOfferName;
DWORD dwOfferType;
BYTE bRelationType;
BYTE bConvertMode;
WORD wInstanceIdLength;
WCHAR *wszInstanceId;
DWORD dwTitleID;
DWORD dwTitleCategories;
WORD wTitleNameLength;
WCHAR *wszTitleName;
WORD wGameRating;
BYTE bDuration;
BYTE bFrequency;
BYTE bTierProvided;
BYTE bTierRequired;
DWORD dwSellTextLength;
WCHAR *wszSellText;
ULONGLONG qwRelatedOfferID;
WORD wResponseFlags;
BYTE bPricesLength;
OFFER_PRICE *pPrices;
} BASIC_SUBSCRIPTION_INFO;
typedef struct _SUBSCRIPTION_ENUMERATE_RESPONSE
{
WORD wOffersReturned;
BASIC_SUBSCRIPTION_INFO *pInfos;
DWORD dwOffersTotal;
} SUBSCRIPTION_ENUMERATE_RESPONSE;
typedef struct _SUBSCRIPTION_ENUMERATE_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
BYTE bUserTier;
BYTE bCountryId;
WORD wLanguageId;
WORD wGameRating;
DWORD dwOfferType;
DWORD dwPaymentType;
DWORD dwTitleId;
DWORD dwTitleCategories;
WORD wRequestFlags;
DWORD dwStartingIndex;
DWORD dwMaxResults;
SUBSCRIPTION_ENUMERATE_RESPONSE *pResults;
} SUBSCRIPTION_ENUMERATE_REQUEST;
typedef struct _SUBSCRIPTION_DETAILS_RESPONSE
{
BASIC_SUBSCRIPTION_INFO basicInfo;
} SUBSCRIPTION_DETAILS_RESPONSE;
typedef struct _SUBSCRIPTION_DETAILS_REQUEST
{
XUID qwUserId;
ULONGLONG qwMachineId;
BYTE bCountryId;
WORD wLanguageId;
ULONGLONG qwOfferID;
DWORD dwPaymentType;
BYTE bUserTier;
BYTE bRatingSystem;
SUBSCRIPTION_DETAILS_RESPONSE *pResults;
} SUBSCRIPTION_DETAILS_REQUEST;
typedef struct _OFFER_PURCHASE_REQUEST
{
XUID qwUserId;
BYTE bCountryId;
WORD wLanguageId;
BYTE bUserTier;
ULONGLONG qwMachineId;
ULONGLONG qwOfferID;
DWORD dwPaymentType;
WORD wPaymentInstrumentId;
WCHAR *wszPaymentInstrumentId;
WORD wTokenLength;
WCHAR *wszToken;
} OFFER_PURCHASE_REQUEST;
typedef struct _OFFER_PURCHASE_GAMERTAG_RESPONSE
{
BYTE bNewKeyLength;
BYTE *pbNewKey;
} OFFER_PURCHASE_GAMERTAG_RESPONSE;
typedef struct _OFFER_PURCHASE_GAMERTAG_REQUEST
{
XUID qwUserId;
BYTE bCountryId;
WORD wLanguageId;
BYTE bUserTier;
ULONGLONG qwMachineId;
ULONGLONG qwOfferID;
DWORD dwPaymentType;
WORD wTokenLength;
WCHAR *wszToken;
WORD wGamertagLength;
WCHAR *wszGamertag;
OFFER_PURCHASE_GAMERTAG_RESPONSE *pResults;
} OFFER_PURCHASE_GAMERTAG_REQUEST;
typedef struct _TITLE_DETAILS_RESPONSE
{
WORD wGameRating;
WORD wTitleLength;
WCHAR *wszTitle;
WORD wSellTextLength;
WCHAR *wszSellText;
WORD wDeveloperLength;
WCHAR *wszDeveloper;
WORD wPublisherLength;
WCHAR *wszPublisher;
WORD wGenreLength;
WCHAR *wszGenre;
BYTE bSubscriptionContent;
BYTE bThemeContent;
BYTE bDemoContent;
BYTE bTrailerContent;
BYTE bPlayed;
} TITLE_DETAILS_RESPONSE;
typedef struct _TITLE_DETAILS_REQUEST
{
XUID qwUserId;
DWORD dwTitleId;
BYTE bCountryId;
WORD wLanguageId;
BYTE bTierRequired;
TITLE_DETAILS_RESPONSE *pResults;
} TITLE_DETAILS_REQUEST;
typedef struct _BASIC_TITLE_INFO
{
WORD wTitleLength;
WCHAR *wszTitle;
DWORD dwTitleId;
BYTE bPlayed;
DWORD dwPurchasedContentCount;
DWORD dwTotalContentCount;
BYTE bNewContentExists;
} BASIC_TITLE_INFO;
typedef struct _ENUMERATE_TITLES_BY_FILTER_RESPONSE
{
DWORD dwTitlesReturned;
BASIC_TITLE_INFO *pInfos;
DWORD dwTotalTitleCount;
} ENUMERATE_TITLES_BY_FILTER_RESPONSE;
typedef struct _ENUMERATE_TITLES_BY_FILTER_REQUEST
{
XUID qwUserId;
BYTE bCountryId;
WORD wLanguageId;
DWORD dwStartingIndex;
DWORD dwMaxResults;
WORD wGameRating;
BYTE bTierRequired;
DWORD dwGenreId;
DWORD dwOfferType;
WORD wRequestFlags;
ENUMERATE_TITLES_BY_FILTER_RESPONSE *pResults;
} ENUMERATE_TITLES_BY_FILTER_REQUEST;
typedef struct _BASIC_GENRE_INFO
{
DWORD dwGenreId;
WORD wGenreNameLength;
WCHAR *wszGenreName;
} BASIC_GENRE_INFO;
typedef struct _ENUMERATE_GENRES_RESPONSE
{
WORD wGenresReturned;
BASIC_GENRE_INFO *pInfos;
DWORD dwTotalGenreCount;
} ENUMERATE_GENRES_RESPONSE;
typedef struct _ENUMERATE_GENRES_REQUEST
{
BYTE bCountryId;
WORD wLanguageId;
DWORD dwStartingIndex;
DWORD dwMaxResults;
WORD wGameRating;
BYTE bTierRequired;
DWORD dwOfferType;
DWORD dwParentGenreId;
ENUMERATE_GENRES_RESPONSE *pResults;
} ENUMERATE_GENRES_REQUEST;
typedef struct _BANNER_LIST_ENTRY
{
BYTE bBannerType;
BYTE isMyGame;
WORD wWidth;
WORD wHeight;
WORD cbPath;
WCHAR *wszPath;
} BANNER_LIST_ENTRY;
typedef struct _BANNER_LIST_RESULT
{
FILETIME ftExpiry;
DWORD dwCultureId;
WORD wBannerCountTotal;
WORD wCount;
BANNER_LIST_ENTRY *bannerList;
} BANNER_LIST_RESULT;
typedef struct _BANNER_GET_LIST_REQUEST
{
ULONGLONG qwUserId;
DWORD dwLangId;
BYTE bLevel;
DWORD dwStartingIndex;
DWORD dwMaxResults;
BANNER_LIST_RESULT *pResult;
} BANNER_GET_LIST_REQUEST;
typedef struct _BANNER_HOTLIST_ENTRY
{
BYTE bBannerType;
BYTE isMyGame;
WORD wWidth;
WORD wHeight;
WORD cbPath;
WCHAR *wszPath;
DWORD dwTitleId;
WORD cbTitleName;
WCHAR *wszTitleName;
ULONGLONG qwOfferId;
WORD cbOfferName;
WCHAR *wszOfferName;
OFFER_PRICE offerPrice;
FILETIME ftDateApproved;
} BANNER_HOTLIST_ENTRY;
typedef struct _BANNER_HOTLIST_RESULT
{
FILETIME ftExpiry;
DWORD dwCultureId;
WORD wBannerCountTotal;
WORD wCount;
BANNER_HOTLIST_ENTRY *bannerList;
} BANNER_HOTLIST_RESULT;
typedef struct _BANNER_GET_HOTLIST_REQUEST
{
ULONGLONG qwUserId;
DWORD dwLangId;
BYTE bLevel;
DWORD dwStartingIndex;
DWORD dwMaxResults;
BANNER_HOTLIST_RESULT *pResult;
} BANNER_GET_HOTLIST_REQUEST;
typedef struct _P_BLOCK_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
XUID qwBlockID;
} P_BLOCK_MSG;
typedef struct _P_UNBLOCK_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
XUID qwBlockID;
} P_UNBLOCK_MSG;
typedef struct _P_FIND_USER_REPLY_MSG
{
ULONGLONG qwFoundID;
CHAR szGamerTag[16];
} P_FIND_USER_REPLY_MSG;
typedef struct _P_FIND_USER_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
XUID qwFindID;
CHAR szSenderName[16];
P_FIND_USER_REPLY_MSG *pResults;
} P_FIND_USER_MSG;
typedef struct _XONLINE_QUERY_ATTRIBUTE_INTEGER
{
DWORD Length;
ULONGLONG qwValue;
} XONLINE_QUERY_ATTRIBUTE_INTEGER, *PXONLINE_QUERY_ATTRIBUTE_INTEGER;
typedef struct _XONLINE_QUERY_ATTRIBUTE_STRING
{
DWORD Length;
WCHAR *lpValue;
} XONLINE_QUERY_ATTRIBUTE_STRING, *PXONLINE_QUERY_ATTRIBUTE_STRING;
typedef struct _XONLINE_QUERY_ATTRIBUTE_BLOB
{
DWORD Length;
BYTE *pbValue;
} XONLINE_QUERY_ATTRIBUTE_BLOB, *PXONLINE_QUERY_ATTRIBUTE_BLOB;
typedef union _XONLINE_QUERY_ATTRIBUTE_DATA
{
XONLINE_QUERY_ATTRIBUTE_INTEGER integer;
XONLINE_QUERY_ATTRIBUTE_STRING string;
XONLINE_QUERY_ATTRIBUTE_BLOB blob;
} XONLINE_QUERY_ATTRIBUTE_DATA, *PXONLINE_QUERY_ATTRIBUTE_DATA;
typedef struct _XONLINE_QUERY_ATTRIBUTE
{
DWORD dwAttributeID;
XONLINE_QUERY_ATTRIBUTE_DATA info;
} XONLINE_QUERY_ATTRIBUTE, *PXONLINE_QUERY_ATTRIBUTE;
typedef struct _XONLINE_QUERY_ATTRIBUTE_SPEC
{
DWORD dwType;
DWORD dwLength;
} XONLINE_QUERY_ATTRIBUTE_SPEC, *PXONLINE_QUERY_ATTRIBUTE_SPEC;
typedef struct _QUERY_ADD_RESULT
{
ULONGLONG entityId;
} QUERY_ADD_RESULT, *PQUERY_ADD_RESULT;
typedef struct _QUERY_ADD_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
ULONGLONG qwTeamId;
DWORD dwDatasetId;
DWORD dwNumAttributes;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
QUERY_ADD_RESULT *pEntityId;
} QUERY_ADD_REQUEST;
typedef struct _QUERY_REMOVE_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
ULONGLONG qwTeamId;
DWORD dwDatasetId;
DWORD dwProcIndex;
DWORD dwNumAttributes;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
} QUERY_REMOVE_REQUEST;
typedef struct _QUERY_REMOVEID_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
ULONGLONG qwTeamId;
DWORD dwDatasetId;
ULONGLONG qwEntityId;
} QUERY_REMOVEID_REQUEST;
typedef struct _QUERY_UPDATE_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
ULONGLONG qwTeamId;
DWORD dwDatasetId;
DWORD dwProcIndex;
DWORD dwNumAttributes;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
} QUERY_UPDATE_REQUEST;
typedef struct _QUERY_UPDATEID_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
ULONGLONG qwTeamId;
DWORD dwDatasetId;
DWORD dwProcIndex;
ULONGLONG qwEntityId;
DWORD dwNumAttributes;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
} QUERY_UPDATEID_REQUEST;
typedef struct _QUERY_SEARCH_RESULT
{
DWORD dwTotalResults;
DWORD dwReturnedResults;
DWORD dwNumResultAttributes;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
} QUERY_SEARCH_RESULT, *PQUERY_SEARCH_RESULT;
typedef struct _QUERY_SEARCH_REQUEST
{
DWORD dwTitleId;
DWORD dwDatasetId;
DWORD dwProcIndex;
DWORD dwPage;
DWORD dwResultsPerPage;
DWORD dwNumResultSpecs;
DWORD dwNumAttributes;
XONLINE_QUERY_ATTRIBUTE_SPEC *pSpecs;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
QUERY_SEARCH_RESULT *pResults;
} QUERY_SEARCH_REQUEST;
typedef struct _QUERY_FINDFROMIDS_RESULT
{
DWORD dwReturnedResults;
DWORD dwNumResultAttributes;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
} QUERY_FINDFROMIDS_RESULT, *PQUERY_FINDFROMIDS_RESULT;
typedef struct _QUERY_FINDFROMIDS_REQUEST
{
DWORD dwTitleId;
DWORD dwDatasetId;
DWORD dwProcIndex;
DWORD dwNumResultSpecs;
DWORD dwNumIds;
XONLINE_QUERY_ATTRIBUTE_SPEC *pSpecs;
ULONGLONG *pqwEntityIds;
QUERY_FINDFROMIDS_RESULT *pResults;
} QUERY_FINDFROMIDS_REQUEST;
typedef struct _QUERY_SELECT_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
ULONGLONG qwTeamId;
DWORD dwDatasetId;
ULONGLONG qwEntityId;
DWORD dwActionId;
DWORD dwNumAttributes;
XONLINE_QUERY_ATTRIBUTE *pAttributes;
} QUERY_SELECT_REQUEST;
typedef struct _XONLINE_TEAM
{
ULONGLONG qwTeamID;
DWORD dwNumMembers;
WORD cbTeamName;
WORD cbTeamDescription;
WORD cbTeamMotto;
WORD cbTeamURL;
WORD cbTeamData;
ULONGLONG ftCreated;
WCHAR *wszTeamName;
WCHAR *wszTeamDescription;
WCHAR *wszTeamMotto;
WCHAR *wszTeamURL;
BYTE *pbTeamData;
} XONLINE_TEAM, *PXONLINE_TEAM;
typedef struct _XONLINE_USER_TEAM
{
ULONGLONG qwTeamID;
BOOL fMember;
WORD cbTeamName;
WCHAR *wszTeamName;
} XONLINE_USER_TEAM, *PXONLINE_USER_TEAM;
typedef struct _XONLINE_TEAM_MEMBER
{
ULONGLONG qwMemberID;
BYTE cbMemberName;
BOOL fMember;
DWORD dwMemberPriv;
WORD cbMemberData;
ULONGLONG ftJoined;
CHAR *szMemberName;
BYTE *pbMemberData;
} XONLINE_TEAM_MEMBER;
typedef struct _TEAM_ENUM_RESULTS
{
DWORD cTeams;
XONLINE_TEAM *rgsTeams;
} TEAM_ENUM_RESULTS, *PTEAM_ENUM_RESULTS;
typedef struct _TEAM_ENUM_BY_XUID_RESULTS
{
DWORD cTeams;
XONLINE_USER_TEAM *rgsTeams;
} TEAM_ENUM_BY_XUID_RESULTS, *PTEAM_ENUM_BY_XUID_RESULTS;
typedef struct _P_TEAM_LIST_TEAMS_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
DWORD dwTeamCount;
ULONGLONG *rgqwTeamIDs;
TEAM_ENUM_RESULTS *pvResults;
} P_TEAM_LIST_TEAMS_MSG;
typedef struct _P_TEAM_LIST_TEAMS_MSG_XUID
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
TEAM_ENUM_BY_XUID_RESULTS *pvResults;
} P_TEAM_LIST_TEAMS_MSG_XUID;
typedef struct _TEAM_MEM_ENUM_RESULTS
{
ULONGLONG qwTeamID;
WORD cMembers;
XONLINE_TEAM_MEMBER *rgsMembers;
} TEAM_MEM_ENUM_RESULTS, *PTEAM_MEM_ENUM_RESULTS;
typedef struct _P_TEAM_LIST_MEMBERS_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
BOOL fShowRecruits;
TEAM_MEM_ENUM_RESULTS *pvResults;
} P_TEAM_LIST_MEMBERS_MSG;
typedef struct _TEAM_CREATE_RESULTS
{
ULONGLONG qwTeamID;
ULONGLONG ftCreated;
} TEAM_CREATE_RESULTS, *PTEAM_CREATE_RESULTS;
typedef struct _P_TEAM_CREATE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
DWORD dwMaxMembers;
WORD cbTeamName;
WORD cbTeamDescription;
WORD cbTeamMotto;
WORD cbTeamURL;
WORD cbTeamData;
WORD cbCreatorData;
WCHAR *wszTeamName;
WCHAR *wszTeamDescription;
WCHAR *wszTeamMotto;
WCHAR *wszTeamURL;
BYTE *pbTeamData;
BYTE *pbCreatorData;
TEAM_CREATE_RESULTS *pvResults;
} P_TEAM_CREATE_MSG;
typedef struct _P_TEAM_DELETE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
} P_TEAM_DELETE_MSG;
typedef struct _P_TEAM_REMOVE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
XUID qwMemberID;
} P_TEAM_REMOVE_MSG;
typedef struct _P_TEAM_MANAGE_TEAM_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
WORD cbTeamName;
WORD cbTeamDescription;
WORD cbTeamMotto;
WORD cbTeamURL;
WORD cbTeamData;
WCHAR *wszTeamName;
WCHAR *wszTeamDescription;
WCHAR *wszTeamMotto;
WCHAR *wszTeamURL;
BYTE *pbTeamData;
} P_TEAM_MANAGE_TEAM_MSG;
typedef struct _P_TEAM_MANAGE_MEMBER_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
XUID qwMemberID;
DWORD dwMemberPriv;
WORD cbMemberData;
BYTE *pbMemberData;
} P_TEAM_MANAGE_MEMBER_MSG;
typedef struct _P_TEAM_RECRUIT_MSG_XUID
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
XUID qwMemberID;
CHAR szMemberName[16];
DWORD dwMemberPriv;
DWORD dwMessageFlags;
WORD cbMemberData;
WORD cbDetails;
BYTE *pbMemberData;
} P_TEAM_RECRUIT_MSG_XUID;
typedef struct _P_TEAM_RECRUIT_MSG_NAME
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
ULONGLONG qwMemberID;
CHAR szMemberName[16];
DWORD dwMemberPriv;
DWORD dwMessageFlags;
WORD cbMemberData;
WORD cbDetails;
BYTE *pbMemberData;
} P_TEAM_RECRUIT_MSG_NAME;
typedef struct _P_TEAM_JOIN_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwTitleID;
ULONGLONG qwTeamID;
DWORD dwRecruitMsgID;
BYTE bAnswer;
} P_TEAM_JOIN_MSG;
typedef struct _XUSER_ONLINE_PROFILE_SETTING
{
DWORD source;
ULONGLONG qwUserId;
DWORD dwSettingId;
WORD cbSize;
BYTE *pbValue;
} XUSER_ONLINE_PROFILE_SETTING, *PXUSER_ONLINE_PROFILE_SETTING;
typedef struct _XPROFILE_SETTING_SYNC_RESULT
{
FILETIME ftVersion;
WORD wTotalSettings;
WORD wSettingsLen;
XUSER_ONLINE_PROFILE_SETTING *pSettings;
} XPROFILE_SETTING_SYNC_RESULT, *PXPROFILE_SETTING_SYNC_RESULT;
typedef struct _XPROFILE_SETTING_SYNC_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
FILETIME ftVersion;
WORD wStartingIndex;
WORD wSettingsLen;
XUSER_ONLINE_PROFILE_SETTING *pSettings;
XPROFILE_SETTING_SYNC_RESULT *pResults;
} XPROFILE_SETTING_SYNC_REQUEST;
typedef struct _XPROFILE_SETTING_READ_RESULT
{
WORD wSettingsLen;
XUSER_ONLINE_PROFILE_SETTING *pSettings;
} XPROFILE_SETTING_READ_RESULT, *PXPROFILE_SETTING_READ_RESULT;
typedef struct _XPROFILE_SETTING_READ_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
WORD wForUserIdsLen;
ULONGLONG *pqwUserIds;
WORD wSettingIdsLen;
DWORD *pdwSettingIds;
XPROFILE_SETTING_READ_RESULT *pResults;
} XPROFILE_SETTING_READ_REQUEST;
typedef union _XSTAT_PROC_DATA
{
BYTE bNull;
BYTE bData;
SHORT sData;
LONG nData;
LONGLONG i64Data;
__XLIVEGEN_DOUBLE dblData;
ULONGLONG qwPuid;
} XSTAT_PROC_DATA;
typedef struct _XSTAT_PROC_PARAM
{
BYTE bType;
XSTAT_PROC_DATA Value;
} XSTAT_PROC_PARAM;
typedef struct _XSTAT_PROC
{
WORD wProcId;
WORD wParamCount;
XSTAT_PROC_PARAM *pParams;
} XSTAT_PROC;
typedef struct _XSTATS_POST_REQUEST
{
DWORD dwTitleId;
WORD wNumProcs;
XSTAT_PROC *pProcs;
} XSTATS_POST_REQUEST;
typedef struct _XONLINE_STATS_SPEC
{
DWORD dwViewId;
DWORD dwNumColumnIds;
WORD *pAttrId;
} XONLINE_STATS_SPEC;
typedef struct _XONLINE_STATS_COLUMN
{
WORD wColumnId;
BYTE bType;
XSTAT_PROC_DATA Value;
} XONLINE_STATS_COLUMN;
typedef struct _XONLINE_STATS_ROW
{
XUID xuid;
DWORD dwRank;
LONGLONG i64Rating;
DWORD cbGamerTag;
CHAR *pszGamerTag;
DWORD dwNumColumns;
XONLINE_STATS_COLUMN *pColumns;
} XONLINE_STATS_ROW;
typedef struct _XONLINE_STATS_VIEW
{
ULONGLONG qwViewId;
DWORD dwViewSize;
DWORD dwRowCount;
XONLINE_STATS_ROW *pRows;
} XONLINE_STATS_VIEW;
typedef struct _XONLINE_STATS_READ_RESULTS
{
DWORD dwNumViews;
XONLINE_STATS_VIEW *pViews;
} XONLINE_STATS_READ_RESULTS;
typedef struct _XONLINE_STATS_READ_REQUEST
{
DWORD dwTitleId;
DWORD dwNumXuids;
XUID *pXuids;
DWORD dwNumSpecs;
XONLINE_STATS_SPEC *pSpecs;
XONLINE_STATS_READ_RESULTS *pResults;
} XONLINE_STATS_READ_REQUEST;
typedef struct _XONLINE_STATS_ENUM_RESULTS
{
WORD wNumViews;
XONLINE_STATS_VIEW *pViews;
} XONLINE_STATS_ENUM_RESULTS;
typedef struct _XONLINE_STATS_ENUM_BY_USER_REQUEST
{
DWORD dwTitleId;
XUID Xuid;
DWORD dwPageSize;
DWORD dwNumSpecs;
XONLINE_STATS_SPEC *pSpecs;
XONLINE_STATS_ENUM_RESULTS *pResults;
} XONLINE_STATS_ENUM_BY_USER_REQUEST;
typedef struct _XONLINE_STATS_ENUM_BY_RANK_REQUEST
{
DWORD dwTitleId;
ULONGLONG qwRank;
DWORD dwPageSize;
DWORD dwNumSpecs;
XONLINE_STATS_SPEC *pSpecs;
XONLINE_STATS_ENUM_RESULTS *pResults;
} XONLINE_STATS_ENUM_BY_RANK_REQUEST;
typedef struct _XONLINE_STATS_ENUM_BY_RATING_REQUEST
{
DWORD dwTitleId;
LONGLONG i64Rating;
DWORD dwPageSize;
DWORD dwNumSpecs;
XONLINE_STATS_SPEC *pSpecs;
XONLINE_STATS_ENUM_RESULTS *pResults;
} XONLINE_STATS_ENUM_BY_RATING_REQUEST;
typedef struct _XSTATS_RESET_REQUEST
{
DWORD dwTitleId;
ULONGLONG qwUserId;
DWORD dwLeaderBoardId;
} XSTATS_RESET_REQUEST;
typedef struct _XPROFILE_TITLE
{
DWORD dwTitleId;
WORD cbTitleName;
WCHAR *pszTitleName;
FILETIME ftLastPlayed;
DWORD dwCredEarned;
WORD wAchievementsEarned;
WORD wAchievementsPossible;
DWORD dwCredPossible;
DWORD dwSequence;
DWORD dwMinutesPlayedOnline;
} XPROFILE_TITLE;
typedef struct _XPROFILE_SYNC_TITLES_RESULT
{
FILETIME ftVersion;
WORD wTotalTitles;
WORD wNumTitles;
XPROFILE_TITLE *pTitles;
} XPROFILE_SYNC_TITLES_RESULT;
typedef struct _XPROFILE_SYNC_TITLES_REQUEST
{
XUID qwUserId;
WORD wLocaleId;
WORD wStartingIndex;
FILETIME ftLastSync;
WORD wNumTitles;
XPROFILE_TITLE *pTitles;
XPROFILE_SYNC_TITLES_RESULT *pResults;
} XPROFILE_SYNC_TITLES_REQUEST;
typedef struct
{
WORD wNumTitles;
XPROFILE_TITLE *pTitles;
} XPROFILE_ENUM_TITLES_RESULT, XPROFILE_ENUM_TITLES_RESULT;
typedef struct _XPROFILE_ENUM_TITLES_REQUEST
{
XUID qwUserId;
XUID qwForUserId;
WORD wLocaleId;
WORD wStartingIndex;
WORD wMaxTitles;
XPROFILE_ENUM_TITLES_RESULT *pResults;
} XPROFILE_ENUM_TITLES_REQUEST;
typedef struct _XPROFILE_CLEAR_TITLE_REQUEST
{
XUID qwUserId;
DWORD dwTitleId;
} XPROFILE_CLEAR_TITLE_REQUEST;
typedef struct _XPROFILE_ACHIEVEMENT
{
DWORD dwAchievementId;
FILETIME ftAchieved;
DWORD dwSequence;
DWORD dwFlags;
BYTE bType;
DWORD dwCred;
DWORD dwImageId;
BYTE cbTitleLen;
WCHAR *pszTitle;
BYTE cbDescriptionLen;
WCHAR *pszDescription;
BYTE cbHowToLen;
WCHAR *pszHowTo;
BYTE bNextIdsLen;
DWORD *pdwNextIds;
BYTE bReplaceIdsLen;
DWORD *pdwReplaceIds;
} XPROFILE_ACHIEVEMENT;
typedef struct _XPROFILE_ACHIEVEMENT_SYNC_REQUEST
{
DWORD dwAchievementId;
FILETIME ftAchieved;
DWORD dwSequence;
DWORD dwFlags;
BYTE bType;
DWORD dwCred;
DWORD dwImageId;
BYTE cbTitleLen;
WCHAR *pszTitle;
BYTE cbDescriptionLen;
WCHAR *pszDescription;
BYTE cbHowToLen;
WCHAR *pszHowTo;
BYTE bNextIdsLen;
DWORD *pdwNextIds;
BYTE bReplaceIdsLen;
DWORD *pdwReplaceIds;
} XPROFILE_ACHIEVEMENT_SYNC_REQUEST;
typedef struct _XPROFILE_SYNC_ACHIEVEMENTS_RESULT
{
FILETIME ftVersion;
WORD wTotalAchievements;
WORD wAchievementCount;
XPROFILE_ACHIEVEMENT *pAchievements;
} XPROFILE_SYNC_ACHIEVEMENTS_RESULT;
typedef struct _XPROFILE_SYNC_ACHIEVEMENTS_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
FILETIME ftVersion;
WORD wLocaleId;
WORD wStartingIndex;
WORD wAchievementCount;
XPROFILE_ACHIEVEMENT_SYNC_REQUEST *pAchievements;
XPROFILE_SYNC_ACHIEVEMENTS_RESULT *pResult;
} XPROFILE_SYNC_ACHIEVEMENTS_REQUEST;
typedef struct _XPROFILE_ENUM_ACHIEVEMENTS_RESULT
{
WORD wAchievementsCount;
XPROFILE_ACHIEVEMENT *pAchievements;
} XPROFILE_ENUM_ACHIEVEMENTS_RESULT;
typedef struct _XPROFILE_ENUM_ACHIEVEMENTS_REQUEST
{
DWORD dwTitleId;
XUID qwUserId;
ULONGLONG qwForPuid;
WORD wLocaleId;
WORD wStartingIndex;
WORD wMaxAchievements;
XPROFILE_ENUM_ACHIEVEMENTS_RESULT *pResult;
} XPROFILE_ENUM_ACHIEVEMENTS_REQUEST;
typedef struct _XMSG_DETAILS
{
WORD wPropCount;
WORD cbData;
XMSG_PROPERTY *rgProperties;
BYTE *rgbData;
} XMSG_DETAILS, *PXMSG_DETAILS;
typedef struct _Q_MESSAGE_SUMMARY
{
ULONGLONG qwSenderID;
ULONGLONG qwSenderContext;
MSGTIME mtSentTime;
DWORD dwMessageID;
DWORD dwMessageFlags;
DWORD dwSenderTitleID;
WORD wExpireMinutes;
WORD cbDetails;
BYTE bMessageType;
CHAR szSenderName[15];
} Q_MESSAGE_SUMMARY;
typedef struct _Q_MESSAGE_SUMMARY_2
{
ULONGLONG qwSenderID;
ULONGLONG qwSenderContext;
MSGTIME mtSentTime;
DWORD dwMessageID;
DWORD dwMessageFlags;
DWORD dwSenderTitleID;
WORD wExpireMinutes;
WORD cbDetails;
BYTE bMessageType;
CHAR szSenderName[15];
WCHAR szSubject[20];
} Q_MESSAGE_SUMMARY_2;
typedef struct _XMSG_SUMMARY
{
ULONGLONG qwSenderID;
ULONGLONG qwMessageContext;
FILETIME ftSentTime;
DWORD dwMessageID;
DWORD dwMessageFlags;
DWORD dwSenderTitleID;
WORD wExpireMinutes;
WORD cbDetails;
BYTE bMsgType;
CHAR szSenderName[15];
WCHAR szSubject[20];
} XMSG_SUMMARY, *PXMSG_SUMMARY;
typedef struct _XMSG_SEND_RECIPIENT_RESULT
{
ULONGLONG qwUserID;
DWORD dwResult;
} XMSG_SEND_RECIPIENT_RESULT, *PXMSG_SEND_RECIPIENT_RESULT;
typedef struct _XMSG_ENUMERATE_REQUEST
{
XUID XuidUser;
DWORD pcMsgSummaries[1];
XMSG_SUMMARY pMsgSummaries[1];
} XMSG_ENUMERATE_REQUEST;
typedef struct _XMSG_SUMMARY_REQUEST
{
XUID XuidUser;
DWORD dwMessageID;
XMSG_SUMMARY pMsgSummary[1];
} XMSG_SUMMARY_REQUEST, *PXMSG_SUMMARY_REQUEST;
typedef struct _XMSG_CREATE_REQUEST
{
DWORD dwMsgType;
DWORD cProperties;
ULONGLONG qwMessageContext;
DWORD dwMessageFlags;
DWORD dwExpireMinutes;
XMSG_HANDLE phMsg[1];
} XMSG_CREATE_REQUEST, *PXMSG_CREATE_REQUEST;
typedef struct _XMSG_DESTROY
{
XMSG_HANDLE hMsg;
} XMSG_DESTROY, *PXMSG_DESTROY;
typedef struct _XMSG_SET_PROP_REQUEST
{
XMSG_HANDLE hMsg;
WORD wPropTag;
DWORD dwPropValueSize;
BYTE pbPropValue[1];
DWORD dwAttachmentFlags;
} XMSG_SET_PROP_REQUEST, *PXMSG_SET_PROP_REQUEST;
typedef struct _XMSG_GET_PROP_REQUEST
{
XMSG_HANDLE hMsg;
WORD wPropTag;
DWORD dwPropValueBufferSize;
BYTE pbPropValue[1];
DWORD pcbPropValue[1];
DWORD pdwAttachmentFlags[1];
} XMSG_GET_PROP_REQUEST, *PXMSG_GET_PROP_REQUEST;
typedef struct _XMSG_ENUM_RESULTS
{
WORD cMessages;
Q_MESSAGE_SUMMARY_2 *pMessages;
} XMSG_ENUM_RESULTS, *PXMSG_ENUM_RESULTS;
typedef struct _Q_ENUM_MESSAGES_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
XMSG_ENUM_RESULTS *pResults;
} Q_ENUM_MESSAGES_MSG;
typedef struct _Q_MESSAGE_SUMMARY_REPLY_MSG
{
Q_MESSAGE_SUMMARY_2 summary;
} Q_MESSAGE_SUMMARY_REPLY_MSG;
typedef struct _Q_MESSAGE_SUMMARY_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
DWORD dwMessageID;
Q_MESSAGE_SUMMARY_REPLY_MSG *pResults;
} Q_MESSAGE_SUMMARY_MSG;
typedef struct _XMSG_DETAILS_RESULTS
{
Q_MESSAGE_SUMMARY summary;
XMSG_DETAILS details;
} XMSG_DETAILS_RESULTS, *PXMSG_DETAILS_RESULTS;
typedef struct _XMSG_DETAILS_BLOB
{
BYTE rgbDetailsBlob[4096];
} XMSG_DETAILS_BLOB, *PXMSG_DETAILS_BLOB;
typedef struct _XMSG_DETAILS_REQUEST
{
XUID XuidUser;
DWORD dwMessageID;
DWORD dwFlagsToSet;
DWORD dwFlagsToClear;
DWORD cbResults;
XMSG_DETAILS_BLOB pResults[1];
XOVERLAPPED pXOverlapped[1];
} XMSG_DETAILS_REQUEST;
typedef struct _Q_MESSAGE_DETAILS_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwMessageID;
DWORD dwFlagsToSet;
DWORD dwFlagsToClear;
XMSG_DETAILS_BLOB *pResults;
} Q_MESSAGE_DETAILS_MSG;
typedef struct _XMSG_DETAILS_GET_SUMMARY
{
XMSG_DETAILS_BLOB pDetails[1];
XMSG_SUMMARY pMsgSummary[1];
DWORD pcProperties[1];
ULONGLONG pqwAttachmentsSize[1];
} XMSG_DETAILS_GET_SUMMARY;
typedef struct _XMSG_DETAILS_GET_PROPERTY
{
XMSG_DETAILS_BLOB pDetails[1];
WORD wPropTag;
DWORD cbPropValueBuffer;
BYTE pbPropValue[1];
DWORD pcbPropValue[1];
DWORD pdwAttachmentFlags[1];
} XMSG_DETAILS_GET_PROPERTY;
typedef struct _XMSG_DELETE_REQUEST
{
XUID XuidUser;
DWORD dwMessageID;
BOOL fBlockSender;
XOVERLAPPED pXOverlapped[1];
} XMSG_DELETE_REQUEST;
typedef struct _Q_DELETE_MESSAGE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwMessageID;
DWORD dwFlags;
} Q_DELETE_MESSAGE_MSG;
typedef struct _XMSG_SEND_RESULT
{
WORD cRecipients;
XMSG_SEND_RECIPIENT_RESULT *pRecipients;
} XMSG_SEND_RESULT;
typedef struct _Q_SEND_MESSAGE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwSenderContext;
DWORD dwMessageFlags;
DWORD dwSenderTitleID;
WORD wExpireMinutes;
WORD cbDetails;
WORD cRecipients;
BYTE bMessageType;
CHAR szSenderName[15];
ULONGLONG *qwRecipientIDs;
XMSG_DETAILS *pDetails;
XMSG_SEND_RESULT *pResults;
} Q_SEND_MESSAGE_MSG;
typedef struct _Q_REVOKE_MESSAGE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
ULONGLONG qwSenderContext;
WORD cRecipients;
BYTE bMessageType;
XMSG_SEND_RECIPIENT_RESULT *pRecipients;
} Q_REVOKE_MESSAGE_MSG;
typedef struct _XMSG_FLAGS_REQUEST
{
XUID XuidUser;
DWORD dwMessageID;
DWORD dwFlagsToSet;
DWORD dwFlagsToClear;
XOVERLAPPED pXOverlapped[1];
} XMSG_FLAGS_REQUEST;
typedef struct _Q_MESSAGE_FLAGS_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwUserID;
DWORD dwMessageID;
DWORD dwSetFlags;
DWORD dwUnsetFlags;
} Q_MESSAGE_FLAGS_MSG;
typedef struct _P_ADD_2_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwSenderID;
ULONGLONG qwBuddyID;
DWORD dwMessageFlags;
WORD cbDetails;
CHAR *szBuddyAcctName;
XMSG_DETAILS *pDetails;
} P_ADD_2_MSG;
typedef struct _P_DELETE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwSenderID;
XUID qwBuddyID;
} P_DELETE_MSG;
typedef struct _P_ACCEPT_REQUEST_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwSenderID;
XUID qwBuddyID;
} P_ACCEPT_REQUEST_MSG;
typedef struct _P_REJECT_REQUEST_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
XUID qwSenderID;
XUID qwBuddyID;
BOOL Block;
} P_REJECT_REQUEST_MSG;
typedef struct _P_FRIENDS_ENUM_CREATE_MSG
{
DWORD dwUserIndex;
DWORD dwStartingIndex;
DWORD dwFriendsToReturn;
DWORD pcbBuffer[1];
HANDLE ph[1];
} P_FRIENDS_ENUM_CREATE_MSG;
typedef struct _P_INVITE_2_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwSenderContext;
DWORD dwTitleID;
DWORD dwMessageFlags;
WORD cInvitees;
WORD cbDetails;
ULONGLONG *pqwInviteeIDs;
XMSG_DETAILS *pDetails;
} P_INVITE_2_MSG;
typedef struct _XMSG_GAME_INVITE_CANCEL
{
XUID XuidUser;
WORD cInvitees;
XUID *pXuidInvitees;
XNKID SessionID;
XOVERLAPPED pXOverlapped[1];
} XMSG_GAME_INVITE_CANCEL;
typedef struct _P_CANCEL_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
XNKID SessionID;
WORD cInvitees;
ULONGLONG *pqwInviteeIDs;
} P_CANCEL_MSG;
typedef struct _XMSG_GAMEINVITE_ANSWER_INFO
{
XUID xuidInvitingUser;
DWORD dwTitleID;
XNKID sessionID;
XNADDR xnaddrHost;
XNKEY xnkeyHost;
} XMSG_GAMEINVITE_ANSWER_INFO, *PXMSG_GAMEINVITE_ANSWER_INFO;
typedef struct _XMSG_GAME_INVITE_ANSWER
{
XUID XuidUser;
XMSG_GAMEINVITE_ANSWER_INFO pAnswerInfo[1];
XMSG_INVITE_ANSWER_TYPE Answer;
BOOL fFromGameInvite;
XOVERLAPPED pXOverlapped[1];
} XMSG_GAME_INVITE_ANSWER;
typedef struct _P_INVITE_ANSWER_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwHostID;
XNKID MatchSessionID;
WORD wAnswer;
} P_INVITE_ANSWER_MSG;
typedef struct _XMSG_GAME_INVITE_GET_ACCEPTED
{
DWORD dwUserIndex;
XINVITE_INFO pInfo[1];
} XMSG_GAME_INVITE_GET_ACCEPTED;
typedef struct _P_ADD_AFFILIATES_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
DWORD dwListFlags;
DWORD dwTitleID;
WORD cwAffiliates;
ULONGLONG *pqwAfilliateIDs;
} P_ADD_AFFILIATES_MSG;
typedef struct _P_IS_AFFILIATE_REPLY_MSG
{
HRESULT hr;
ULONGLONG qwAffiliateID;
DWORD dwListFlags;
} P_IS_AFFILIATE_REPLY_MSG;
typedef struct _P_IS_AFFILIATE_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
ULONGLONG qwAffiliateID;
P_IS_AFFILIATE_REPLY_MSG *pReply;
} P_IS_AFFILIATE_MSG;
typedef struct _P_QUERY_AFFILIATES_REPLY_DATA_MSG
{
ULONGLONG qwAffiliateID;
DWORD dwListFlags;
DWORD dwTitleID;
ULONGLONG qwSessionID;
MSGTIME mtDateUpdated;
CHAR szGamerTag[16];
} P_QUERY_AFFILIATES_REPLY_DATA_MSG;
typedef struct _P_QUERY_AFFILIATES_REPLY_MSG
{
HRESULT hr;
DWORD cdwResults;
P_QUERY_AFFILIATES_REPLY_DATA_MSG *rgResults;
} P_QUERY_AFFILIATES_REPLY_MSG;
typedef struct _P_QUERY_AFFILIATES_MSG
{
DWORD dwMsgType;
DWORD dwMsgLen;
DWORD dwSeqNum;
SGADDR sgaddr;
ULONGLONG qwUserID;
DWORD dwListFlags;
DWORD cdwLimit;
DWORD dwOnlineTitleID;
P_QUERY_AFFILIATES_REPLY_MSG *pReply;
} P_QUERY_AFFILIATES_MSG;
typedef struct _XSIGNATURE_TO_VERIFY
{
BYTE rgbDigest[20];
BYTE rgbOnlineSignature[100];
} XSIGNATURE_TO_VERIFY;
typedef struct _XSIGNATURE_VERIFY_RESPONSE
{
HRESULT hrResult;
} XSIGNATURE_VERIFY_RESPONSE;
typedef struct _XSIGNATURE_VERIFY_REQUEST
{
XSIGNATURE_TO_VERIFY *pSignaturesToVerify;
XSIGNATURE_VERIFY_RESPONSE *pResponse;
} XSIGNATURE_VERIFY_REQUEST;
typedef struct _XSIGNATURE_CONTENT_TUPLE
{
DWORD dwTitleId;
DWORD dwTitleVersion;
ULONGLONG qwConsolePuid;
BYTE pConsoleId[5];
ULONGLONG pUserPuids[4];
BYTE pDigest[20];
} XSIGNATURE_CONTENT_TUPLE;
typedef struct _XSIGNATURE_CHECK_REVOCATION_RESPONSE
{
DWORD dwNumHrs;
HRESULT *pHrs;
} XSIGNATURE_CHECK_REVOCATION_RESPONSE;
typedef struct _XSIGNATURE_CHECK_REVOCATION_REQUEST
{
DWORD dwNumContentTuples;
XSIGNATURE_CONTENT_TUPLE *pTuples;
XSIGNATURE_CHECK_REVOCATION_RESPONSE *pResponse;
} XSIGNATURE_CHECK_REVOCATION_REQUEST;
typedef struct _XSTORAGE_ENDPOINT
{
IN_ADDR inaPrimaryAddress;
WORD wPrimaryPort;
IN_ADDR inaAlternateAddress;
WORD wAlternatePort;
} XSTORAGE_ENDPOINT;
typedef struct _XRESOLVE_DOMAIN_STRING
{
WORD wNumStringChars;
WCHAR *pwszString;
} XRESOLVE_DOMAIN_STRING;
typedef struct _XRESOLVE_NAME_RESPONSE
{
XSTORAGE_ENDPOINT StorageEndpoint;
FILETIME ftExpiration;
XRESOLVE_DOMAIN_STRING ResolveDomainStringRule;
} XRESOLVE_NAME_RESPONSE;
typedef struct _XRESOLVE_NAME_REQUEST
{
XRESOLVE_DOMAIN_STRING pResolveString[1];
XRESOLVE_NAME_RESPONSE *pResponse;
} XRESOLVE_NAME_REQUEST;
typedef struct _XSTORAGE_PATH_STRING
{
WORD wNumPathChars;
WCHAR *pwszPath;
} XSTORAGE_PATH_STRING;
typedef struct _XSTORAGE_ACCESS_TOKEN
{
WORD wOperation;
WORD wAccessTokenVersion;
DWORD dwServiceId;
DWORD dwFlags;
ULONGLONG qwUserId;
ULONGLONG qwXboxId;
} XSTORAGE_ACCESS_TOKEN;
typedef struct _XSTORAGE_ACCESS_TOKEN_READ
{
FILETIME ftTokenExpirationDate;
WORD wSignatureSize;
BYTE *prgbSignature;
} XSTORAGE_ACCESS_TOKEN_READ;
typedef struct _XSTORAGE_ACCESS_TOKEN_WRITE
{
FILETIME ftTokenExpirationDate;
FILETIME ftFileExpirationDate;
DWORD dwMaxFileSize;
WORD wSignatureSize;
BYTE *prgbSignature;
} XSTORAGE_ACCESS_TOKEN_WRITE;
typedef struct _XSTORAGE_DOWNLOAD_RESPONSE
{
DWORD dwTitleId;
DWORD dwTitleVersion;
ULONGLONG qwOwnerId;
BYTE bCountryId;
ULONGLONG qwXboxId;
BYTE bCompressionType;
DWORD dwContentType;
BYTE rgbLiveSignature[100];
DWORD dwInstallSize;
FILETIME ftCreated;
WORD wAttributesSize;
DWORD dwPackageSize;
BYTE *prgbAttributes;
} XSTORAGE_DOWNLOAD_RESPONSE;
typedef struct _XSTORAGE_DOWNLOAD_REQUEST
{
XSTORAGE_ACCESS_TOKEN pStorageAccessToken[1];
XSTORAGE_PATH_STRING pStoragePathString[1];
XSTORAGE_ACCESS_TOKEN_READ pStorageAccessTokenRead[1];
DWORD dwTitleId;
DWORD dwTitleVersion;
BYTE bCountryId;
DWORD dwRangeStart;
DWORD dwRangeEnd;
FILETIME pftLastModified[1];
XSTORAGE_DOWNLOAD_RESPONSE *pResponse;
} XSTORAGE_DOWNLOAD_REQUEST;
typedef struct _XSTORAGE_UPLOAD_REQUEST
{
XSTORAGE_ACCESS_TOKEN pStorageAccessToken[1];
XSTORAGE_PATH_STRING pStoragePathString[1];
XSTORAGE_ACCESS_TOKEN_WRITE pStorageAccessTokenWrite[1];
DWORD dwTitleId;
DWORD dwTitleVersion;
BYTE bCountryId;
BYTE bCompressionType;
DWORD dwContentType;
BYTE *prgbDigest;
BYTE *prgbLiveSignature;
DWORD dwInstallSize;
WORD wAttributesSize;
DWORD dwPackageSize;
BYTE *prgbAttributes;
} XSTORAGE_UPLOAD_REQUEST;
typedef struct _XSTORAGE_ENUMERATE_REQUEST
{
XSTORAGE_ACCESS_TOKEN pStorageAccessToken[1];
XSTORAGE_PATH_STRING pStoragePathString[1];
XSTORAGE_ACCESS_TOKEN_READ pStorageAccessTokenRead[1];
DWORD dwTitleId;
DWORD dwTitleVersion;
BYTE bCountryId;
DWORD dwStartingIndex;
DWORD dwEndingIndex;
FILETIME ftLastModified;
XSTORAGE_ENUMERATE_RESULTS *pResults;
} XSTORAGE_ENUMERATE_REQUEST;
typedef struct _XSTORAGE_DELETE_REQUEST
{
XSTORAGE_ACCESS_TOKEN pStorageAccessToken[1];
XSTORAGE_PATH_STRING pStoragePathString[1];
XSTORAGE_ACCESS_TOKEN_READ pStorageAccessTokenRead[1];
DWORD dwTitleId;
DWORD dwTitleVersion;
} XSTORAGE_DELETE_REQUEST;
typedef struct _XSTORAGE_DOWNLOAD_TO_DIRECTORY_RESULTS_INTERNAL
{
XCONTENT_DATA ContentData;
} XSTORAGE_DOWNLOAD_TO_DIRECTORY_RESULTS_INTERNAL;
typedef struct _XSTORAGE_DOWNLOAD_TO_DIRECTORY_PARAMS_INTERNAL
{
DWORD dwUserIndex;
DWORD dwServerPathLength;
WCHAR *wszServerPath;
DWORD dwDisplayNameLength;
WCHAR *wszDisplayName;
XCONTENTDEVICEID DeviceID;
XSTORAGE_DOWNLOAD_TO_DIRECTORY_RESULTS_INTERNAL *pResults;
} XSTORAGE_DOWNLOAD_TO_DIRECTORY_PARAMS_INTERNAL;
typedef struct _XSTORAGE_DOWNLOAD_TO_MEMORY_PARAMS
{
DWORD dwUserIndex;
DWORD dwServerPathLength;
WCHAR *wszServerPath;
DWORD dwBufferSize;
DWORD dwBufferPointer;
XSTORAGE_DOWNLOAD_TO_MEMORY_RESULTS *pResults;
} XSTORAGE_DOWNLOAD_TO_MEMORY_PARAMS;
typedef struct _XSTORAGE_UPLOAD_FROM_DIRECTORY_PARAMS_INTERNAL
{
DWORD dwUserIndex;
DWORD dwServerPathLength;
WCHAR *wszServerPath;
DWORD dwLocalPathLength;
CHAR *szLocalPath;
} XSTORAGE_UPLOAD_FROM_DIRECTORY_PARAMS_INTERNAL;
typedef struct _XSTORAGE_UPLOAD_FROM_MEMORY_PARAMS
{
DWORD dwUserIndex;
DWORD dwServerPathLength;
WCHAR *wszServerPath;
DWORD dwBufferSize;
DWORD dwBufferPointer;
} XSTORAGE_UPLOAD_FROM_MEMORY_PARAMS;
typedef struct _XSTORAGE_ENUMERATE_PARAMS
{
DWORD dwUserIndex;
DWORD dwServerPathLength;
WCHAR *wszServerPath;
DWORD dwStartingIndex;
DWORD dwMaxResultsToReturn;
XSTORAGE_ENUMERATE_RESULTS *pResults;
} XSTORAGE_ENUMERATE_PARAMS;
typedef struct _XSTORAGE_DELETE_PARAMS
{
DWORD dwUserIndex;
DWORD dwServerPathLength;
WCHAR *wszServerPath;
} XSTORAGE_DELETE_PARAMS;
typedef struct _XMSG_SEND_PARAMS
{
XUID XuidSender;
XMSG_HANDLE hMsg;
DWORD cRecipients;
XUID *pXuidRecipients;
XMSG_SEND_RESULT *pResults;
} XMSG_SEND_PARAMS;
typedef struct _XMSG_DOWNLOAD_ATTACH_TO_MEM_PARAMS
{
XUID XuidUser;
DWORD dwDetailsBlobsPointer;
DWORD dwPropTag;
DWORD dwBufferSize;
DWORD dwBufferPointer;
} XMSG_DOWNLOAD_ATTACH_TO_MEM_PARAMS;
typedef struct _XFRIENDS_REQUEST_PARAMS
{
XUID XuidFromUser;
XUID qwBuddyID;
DWORD dwUserNameSize;
XMSG_HANDLE hMsg;
} XFRIENDS_REQUEST_PARAMS;
typedef struct _XFRIENDS_REQUEST_BY_NAME_PARAMS
{
XUID XuidFromUser;
XUID qwBuddyID;
DWORD dwUserNameSize;
CHAR *szUserName;
XMSG_HANDLE hMsg;
} XFRIENDS_REQUEST_BY_NAME_PARAMS;
typedef struct _XMSG_INVITE_SEND_PARAMS
{
DWORD dwUserIndex;
DWORD dwNumInvitees;
XUID *pXuidInvitees;
DWORD cchText;
WCHAR *pszText;
XMSG_HANDLE hMsg;
} XMSG_INVITE_SEND_PARAMS;
typedef struct _XMSG_INVITE_SEND_MESSAGE_PARAMS
{
DWORD dwUserIndex;
DWORD dwNumInvitees;
XUID *pXuidInvitees;
DWORD cchText;
WCHAR *pszText;
XMSG_HANDLE hMsg;
} XMSG_INVITE_SEND_MESSAGE_PARAMS;
typedef struct _XREFERRAL_LOCATION
{
WORD wRank;
WORD wUrlSize;
CHAR *pszUrl;
} XREFERRAL_LOCATION;
typedef struct _XCONTENT_REFERRAL_RESPONSE
{
DWORD dwPackageSize;
DWORD dwInstallSize;
BYTE rgbSymKey[16];
BYTE rgbPubKey[284];
WORD wNumLocations;
XREFERRAL_LOCATION *pReferralLocations;
} XCONTENT_REFERRAL_RESPONSE;
typedef struct _XCONTENT_REFERRAL_REQUEST
{
ULONGLONG qwUserId;
BYTE abContentId[20];
XCONTENT_REFERRAL_RESPONSE *pResults;
} XCONTENT_REFERRAL_REQUEST;
typedef struct _XCONTENT_REFRESH_LICENSE_RESPONSE
{
WORD wContentHeaderLength;
BYTE *pbContentHeader;
} XCONTENT_REFRESH_LICENSE_RESPONSE;
typedef struct _XCONTENT_REFRESH_LICENSE_REQUEST
{
ULONGLONG qwUserId;
ULONGLONG qwMachineId;
WORD wContentHeaderLength;
BYTE *pbContentHeader;
XCONTENT_REFRESH_LICENSE_RESPONSE *pResults;
} XCONTENT_REFRESH_LICENSE_REQUEST;
typedef struct _XCONTENT_DOWNLOAD_PARAMS
{
DWORD dwUserIndex;
BYTE *pbContentId;
DWORD dwTargetDirectoryLength;
CHAR *szTargetDirectory;
DWORD dwFlags;
} XCONTENT_DOWNLOAD_PARAMS;
typedef struct _XCONTENT_DOWNLOAD_GET_INPROGRESS_METADATA
{
DWORD dwUserIndex;
BYTE *pbContentId;
DWORD dwTargetDirectoryLength;
CHAR *szTargetDirectory;
BYTE pContentHeader[1];
BYTE pContentMetaData[1];
BYTE pbOtherMetaData[1];
DWORD pdwOtherMetaDataSize[1];
} XCONTENT_DOWNLOAD_GET_INPROGRESS_METADATA;
typedef struct _XUPDATE_REFERRAL_RESPONSE
{
WORD wFlags;
WORD wNumLocations;
DWORD dwPackageSize;
DWORD dwInstallSize;
DWORD dwVersion;
BYTE rgbSymKey[16];
BYTE rgbPubKey[284];
XREFERRAL_LOCATION *pReferralLocations;
} XUPDATE_REFERRAL_RESPONSE;
typedef struct _XUPDATE_REFERRAL_REQUEST
{
ULONGLONG qwMachineId;
DWORD dwTitleId;
DWORD dwVersion;
XUPDATE_REFERRAL_RESPONSE *pResults;
} XUPDATE_REFERRAL_REQUEST;
typedef struct _XUPDATE_DOWNLOAD_RESULTS
{
CHAR szPackagePath[260];
} XUPDATE_DOWNLOAD_RESULTS;
typedef struct _XUPDATE_DOWNLOAD_PARAMS
{
DWORD dwTitleId;
DWORD dwVersion;
XUPDATE_DOWNLOAD_RESULTS *pResults;
} XUPDATE_DOWNLOAD_PARAMS;
typedef struct _XUID_AND_FLAGS
{
XUID xuid;
DWORD dwUserFlags;
} XUID_AND_FLAGS;
typedef struct _XARB_REGISTRANT
{
ULONGLONG qwMachineID;
BYTE bTrustworthiness;
BYTE bNumUsers;
XUID_AND_FLAGS *rgUsers;
} XARB_REGISTRANT;
typedef struct _XARB_REGISTER_REPLY
{
WORD wNumRegistrants;
XARB_REGISTRANT *rgRegistrants;
} XARB_REGISTER_REPLY;
typedef struct _XARB_REGISTER_REQUEST
{
WORD wProtocolVersion;
WORD wFlags;
DWORD dwTitleId;
ULONGLONG qwSessionId;
ULONGLONG qwSessionNonce;
WORD wMaxSessionSeconds;
XARB_REGISTER_REPLY *pReply;
} XARB_REGISTER_REQUEST;
typedef struct _XARB_TIMEEXTEND_REQUEST
{
WORD wProtocolVersion;
WORD wRequestFlags;
DWORD dwTitleID;
ULONGLONG qwSessionID;
ULONGLONG qwSessionNonce;
WORD wMaxSessionSecondsFromNow;
} XARB_TIMEEXTEND_REQUEST;
typedef struct _XARB_REPORT_LOST_MACHINES
{
BYTE bNumLostConnectivityMachineIDs;
ULONGLONG *pLostConnectivityMachineIDs;
} XARB_REPORT_LOST_MACHINES;
typedef struct _XARB_REPORT_SUSPICIOUS_INFO
{
BYTE bMessageLength;
CHAR *pszMessage;
BYTE bNumRelatedMachineIDs;
ULONGLONG *pRelatedMachineIDs;
BYTE bNumRelatedUsers;
ULONGLONG *pRelatedUsers;
} XARB_REPORT_SUSPICIOUS_INFO;
typedef struct _XARB_REPORT_BYTE_BUNDLE
{
DWORD cbBundle;
BYTE *pBundle;
} XARB_REPORT_BYTE_BUNDLE;
typedef struct _XARB_REPORT_STATS_BUNDLE
{
DWORD cbStats;
XSTATS_POST_REQUEST Stats;
} XARB_REPORT_STATS_BUNDLE;
typedef struct _XARB_REPORT_REQUEST
{
WORD wProtocolVersion;
WORD wFlags;
DWORD dwTitleID;
ULONGLONG qwSessionID;
ULONGLONG qwSessionNonce;
XARB_REPORT_LOST_MACHINES *pLostMachines;
XARB_REPORT_SUSPICIOUS_INFO *pSuspiciousInfo;
XARB_REPORT_STATS_BUNDLE *pStatsBundle;
XARB_REPORT_BYTE_BUNDLE *pCompsBundle;
} XARB_REPORT_REQUEST;
typedef struct _FB_PLAYER_REVIEW
{
ULONGLONG qwSenderID;
ULONGLONG qwTargetID;
DWORD dwTitleID;
DWORD dwType;
ULONGLONG qwContext;
ULONGLONG ftSubmitted;
} FB_PLAYER_REVIEW;
typedef struct _FB_AGGREGATE_REVIEW
{
ULONGLONG qwTargetID;
DWORD dwCount;
DWORD dwType;
} FB_AGGREGATE_REVIEW;
typedef struct _FB_PLAYER_REVIEW_REQUEST
{
ULONGLONG qwSenderID;
ULONGLONG qwTargetID;
DWORD dwTitleID;
DWORD dwType;
ULONGLONG qwContext;
} FB_PLAYER_REVIEW_REQUEST;
typedef struct _FB_ENUM_REVIEWS_RESPONSE
{
DWORD hr;
DWORD cReviews;
FB_PLAYER_REVIEW *pReviews;
} FB_ENUM_REVIEWS_RESPONSE;
typedef struct _FB_ENUM_SENT_REVIEWS_REQUEST
{
ULONGLONG qwSenderID;
DWORD dwPageID;
DWORD dwResultsPerPage;
FB_ENUM_REVIEWS_RESPONSE *pResults;
} FB_ENUM_SENT_REVIEWS_REQUEST;
typedef struct _FB_ENUM_RECD_REVIEWS_REQUEST
{
ULONGLONG qwTargetID;
DWORD dwPageID;
DWORD dwResultsPerPage;
FB_ENUM_REVIEWS_RESPONSE *pResults;
} FB_ENUM_RECD_REVIEWS_REQUEST;
typedef struct _FB_GET_AGG_REVIEWS_RESPONSE
{
DWORD hr;
DWORD cAggReviews;
FB_AGGREGATE_REVIEW *pAggReviews;
} FB_GET_AGG_REVIEWS_RESPONSE;
typedef struct _FB_GET_AGG_REVIEWS_REQUEST
{
ULONGLONG qwTargetID;
FB_GET_AGG_REVIEWS_RESPONSE *pResults;
} FB_GET_AGG_REVIEWS_REQUEST;
typedef struct _FB_SUBMIT_COMPAINT_REQUEST
{
ULONGLONG qwSenderID;
ULONGLONG qwTargetID;
DWORD dwTitleID;
DWORD dwType;
ULONGLONG qwContext;
} FB_SUBMIT_COMPAINT_REQUEST;
#pragma pack(pop)
XBOXAPI
DWORD
WINAPI
_XOfferingUpdateAccessTimes(
IN DWORD dwUserIndex,
IN DWORD dwTitleId,
IN DWORD dwTitleContentCategories,
OUT XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingExpireMarketplaceCountsCache(
IN DWORD dwUserIndex,
OUT XOVERLAPPED *pXOverlapped
);
XAMINLINE
WORD
WINAPI
_XOfferConstructRating(WORD wRatingSystem, WORD wRating)
{
return (WORD) ((wRatingSystem << 8) | wRating);
}
XAMINLINE
DWORD
WINAPI
_XOfferPriceSizeMax()
{
return sizeof(OFFER_PRICE) +
(XONLINE_XBOS_MAX_OFFER_PRICE_TEXT_LENGTH * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XOfferBasicContentInfoSizeMax(DWORD dwNumPrices)
{
return sizeof(BASIC_CONTENT_INFO) +
(XONLINE_XBOS_MAX_OFFER_NAME_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_TITLE_NAME_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_OFFER_SELL_TEXT_LENGTH * sizeof(WCHAR)) +
(dwNumPrices * _XOfferPriceSizeMax());
}
XAMINLINE
DWORD
WINAPI
_XOfferBasicSubscriptionInfoSizeMax(DWORD dwNumPrices)
{
return sizeof(BASIC_SUBSCRIPTION_INFO) +
(XONLINE_XBOS_MAX_OFFER_NAME_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_TITLE_NAME_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_OFFER_SELL_TEXT_LENGTH * sizeof(WCHAR)) +
(dwNumPrices * _XOfferPriceSizeMax());
}
XAMINLINE
DWORD
WINAPI
_XOfferContentEnumerateResponseSize(DWORD dwMaxOffersReturned, DWORD dwNumPrices)
{
return sizeof(CONTENT_ENUMERATE_RESPONSE) +
(dwMaxOffersReturned * _XOfferBasicContentInfoSizeMax(dwNumPrices));
}
XAMINLINE
DWORD
WINAPI
_XOfferSubscriptionEnumerateResponseSize(DWORD dwMaxOffersReturned, DWORD dwNumPrices)
{
return sizeof(SUBSCRIPTION_ENUMERATE_RESPONSE) +
(dwMaxOffersReturned * _XOfferBasicSubscriptionInfoSizeMax(dwNumPrices));
}
XAMINLINE
DWORD
WINAPI
_XOfferContentDetailsResponseSize(DWORD dwNumPrices)
{
return sizeof(CONTENT_DETAILS_RESPONSE) + _XOfferBasicContentInfoSizeMax(dwNumPrices);
}
XAMINLINE
DWORD
WINAPI
_XOfferSubscriptionDetailsResponseSize(DWORD dwNumPrices)
{
return sizeof(SUBSCRIPTION_DETAILS_RESPONSE) + _XOfferBasicSubscriptionInfoSizeMax(dwNumPrices);
}
XAMINLINE
DWORD
WINAPI
_XOfferBasicTitleInfoResponseSize()
{
return sizeof(BASIC_TITLE_INFO) +
(XONLINE_XBOS_MAX_TITLE_TITLE_LENGTH * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XOfferEnumerateTitlesByFilterResponseSize(DWORD dwNumResults)
{
return sizeof(ENUMERATE_TITLES_BY_FILTER_RESPONSE) + (dwNumResults * _XOfferBasicTitleInfoResponseSize());
}
XAMINLINE
DWORD
WINAPI
_XOfferGetTitleDetailsResponseSize()
{
return sizeof(TITLE_DETAILS_RESPONSE) +
(XONLINE_XBOS_MAX_TITLE_TITLE_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_TITLE_SELL_TEXT_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_TITLE_DEVELOPER_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_TITLE_PUBLISHER_LENGTH * sizeof(WCHAR)) +
(XONLINE_XBOS_MAX_TITLE_GENRE_LENGTH * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XOfferBasicGenreInfoResponseSize()
{
return sizeof(BASIC_GENRE_INFO) +
(XONLINE_XBOS_MAX_GENRE_NAME_LENGTH * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XBannerGetListResponseSize(int entries)
{
const int cbEntrySizeMax = sizeof(BANNER_LIST_ENTRY)
+ XONLINE_BANNER_MAX_PATH * sizeof(WCHAR); // wszPath
return sizeof(BANNER_LIST_RESULT)
+ entries * cbEntrySizeMax; // bannerList
}
XAMINLINE
DWORD
WINAPI
_XBannerGetHotListResponseSize(int entries)
{
const int cbEntrySizeMax = sizeof(BANNER_HOTLIST_ENTRY)
+ XONLINE_BANNER_MAX_PATH * sizeof(WCHAR) // wszPath
+ XONLINE_BANNER_MAX_TITLE_NAME * sizeof(WCHAR) // wszTitleName
+ XONLINE_BANNER_MAX_OFFER_NAME * sizeof(WCHAR) // wszOfferName
+ XONLINE_XBOS_MAX_OFFER_PRICE_TEXT_LENGTH * sizeof(WCHAR); // offerPrice.wszPriceText
return sizeof(BANNER_HOTLIST_RESULT)
+ entries * cbEntrySizeMax; // bannerList
}
XAMINLINE
DWORD
WINAPI
_XAccountGetPointsBalanceResponseSize()
{
return sizeof(GET_POINTS_BALANCE_RESPONSE);
}
XAMINLINE
DWORD
WINAPI
_XOfferPurchaseGamertagResponseSize()
{
return sizeof(OFFER_PURCHASE_GAMERTAG_RESPONSE) + (XONLINE_KEY_LENGTH * sizeof(BYTE));
}
XAMINLINE
DWORD
WINAPI
_XOfferEnumerateGenresResponseSize(DWORD dwNumResults)
{
return sizeof(ENUMERATE_GENRES_RESPONSE) + (dwNumResults * _XOfferBasicGenreInfoResponseSize());
}
XAMINLINE
DWORD
WINAPI
_XAccountGetCreateLiveAccountResponseSize()
{
return sizeof(CREATE_LIVE_ACCOUNT_RESPONSE);
}
XAMINLINE
DWORD
WINAPI
_XAccountGetUserInfoResponseSize()
{
return sizeof(GET_USER_INFO_RESPONSE) +
(MAX_FIRSTNAME_SIZE * sizeof(WCHAR)) +
(MAX_LASTNAME_SIZE * sizeof(WCHAR)) +
(MAX_EMAIL_SIZE * sizeof(WCHAR)) +
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street1
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street2
(MAX_CITY_SIZE * sizeof(WCHAR)) +
(MAX_DISTRICT_SIZE * sizeof(WCHAR)) +
(MAX_STATE_SIZE * sizeof(WCHAR)) +
(MAX_POSTALCODE_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountRecoverAccountResponseSize()
{
return sizeof(RECOVER_ACCOUNT_RESPONSE) +
(XONLINE_KEY_LENGTH * sizeof(BYTE)) +
(XONLINE_GAMERTAG_SIZE * sizeof(WCHAR)) +
(XONLINE_USERDOMAIN_SIZE * sizeof(WCHAR)) +
(XONLINE_REALM_NAME_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetAddPaymentInstrumentResponseSize()
{
return sizeof(ADD_PAYMENT_INSTRUMENT_RESPONSE) +
((MAX_INSTANCE_ID_LENGTH) * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetPaymentInstrumentsResponseSize()
{
return sizeof(GET_PAYMENT_INSTRUMENTS_RESPONSE) +
(XONLINE_XUACS_MAX_PAYMENT_INSTRUMENTS *
(sizeof(PAYMENT_INSTRUMENT_INFO) +
(MAX_INSTANCE_ID_LENGTH * sizeof(WCHAR)) +
// ADDRESS_INFO strings
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street1
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street2
(MAX_CITY_SIZE * sizeof(WCHAR)) +
(MAX_DISTRICT_SIZE * sizeof(WCHAR)) +
(MAX_STATE_SIZE * sizeof(WCHAR)) +
(MAX_POSTALCODE_SIZE * sizeof(WCHAR)) +
// PHONE_INFO strings
(MAX_PHONE_PREFIX_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_EXTENSION_SIZE * sizeof(WCHAR)) +
// CREDIT_CARD_INFO strings
(MAX_CC_NAME_SIZE * sizeof(WCHAR)) +
(MAX_CC_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_CC_CCV_NUMBER_SIZE * sizeof(WCHAR)) +
// DIRECT_DEBIT_INFO strings
(MAX_DD_NAME_SIZE * sizeof(WCHAR)) +
(MAX_DD_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_DD_BANK_CODE_SIZE * sizeof(WCHAR)) +
(MAX_DD_BRANCH_CODE_SIZE * sizeof(WCHAR)) +
(MAX_DD_CHECK_DIGITS_SIZE * sizeof(WCHAR))
));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetAccountInfoResponseSize()
{
return sizeof(GET_ACCOUNT_INFO_RESPONSE) +
(MAX_FIRSTNAME_SIZE * sizeof(WCHAR)) +
(MAX_LASTNAME_SIZE * sizeof(WCHAR)) +
(MAX_EMAIL_SIZE * sizeof(WCHAR)) +
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street1
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street2
(MAX_CITY_SIZE * sizeof(WCHAR)) +
(MAX_DISTRICT_SIZE * sizeof(WCHAR)) +
(MAX_STATE_SIZE * sizeof(WCHAR)) +
(MAX_POSTALCODE_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_PREFIX_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_EXTENSION_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetAccountInfoFromPassportResponseSize()
{
return sizeof(GET_ACCOUNT_INFO_RESPONSE) +
(MAX_FIRSTNAME_SIZE * sizeof(WCHAR)) +
(MAX_LASTNAME_SIZE * sizeof(WCHAR)) +
(MAX_EMAIL_SIZE * sizeof(WCHAR)) +
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street1
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street2
(MAX_CITY_SIZE * sizeof(WCHAR)) +
(MAX_DISTRICT_SIZE * sizeof(WCHAR)) +
(MAX_STATE_SIZE * sizeof(WCHAR)) +
(MAX_POSTALCODE_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_PREFIX_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_EXTENSION_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetPostalCodeResponseSize()
{
return sizeof(GET_POSTAL_CODE_RESPONSE) +
(XONLINE_XUACS_MAX_POSTAL_CODE_MATCHES *
(sizeof(POSTAL_CODE_MATCH) +
(MAX_POSTALCODE_SIZE * sizeof(WCHAR)) +
(MAX_STATE_SIZE * sizeof(WCHAR)) +
(MAX_CITY_SIZE * sizeof(WCHAR)) +
(MAX_STREET_SIZE * sizeof(WCHAR))));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetUserSubscriptionDetailsResponseSize()
{
return sizeof(GET_USER_SUBSCRIPTION_DETAILS_RESPONSE) +
(MAX_INSTANCE_ID_LENGTH * sizeof(WCHAR)) +
(XONLINE_XUACS_MAX_SUBSCRIPTION_DESCRIPTION_LENGTH * sizeof(WCHAR)) +
(XONLINE_XUACS_MAX_SUBSCRIPTION_FRIENDLY_NAME_LENGTH * sizeof(WCHAR)) +
// GET_USER_SUBSCRIPTION_DETAILS_DATA strings
(XONLINE_XUACS_MAX_ISO_CODE_LENGTH * sizeof(WCHAR)) +
(XONLINE_XUACS_MAX_FORMATTED_PRICE_LENGTH * sizeof(WCHAR)) +
// GET_USER_SUBSCRIPTION_DETAILS_DATA strings
(XONLINE_XUACS_MAX_ISO_CODE_LENGTH * sizeof(WCHAR)) +
(XONLINE_XUACS_MAX_FORMATTED_PRICE_LENGTH * sizeof(WCHAR)) +
// PAYMENT_INSTRUMENT_INFO strings
(MAX_INSTANCE_ID_LENGTH * sizeof(WCHAR)) +
// ADDRESS_INFO strings
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street1
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street2
(MAX_CITY_SIZE * sizeof(WCHAR)) +
(MAX_DISTRICT_SIZE * sizeof(WCHAR)) +
(MAX_STATE_SIZE * sizeof(WCHAR)) +
(MAX_POSTALCODE_SIZE * sizeof(WCHAR)) +
// PHONE_INFO strings
(MAX_PHONE_PREFIX_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_EXTENSION_SIZE * sizeof(WCHAR)) +
// CREDIT_CARD_INFO strings
(MAX_CC_NAME_SIZE * sizeof(WCHAR)) +
(MAX_CC_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_CC_CCV_NUMBER_SIZE * sizeof(WCHAR)) +
// DIRECT_DEBIT_INFO strings
(MAX_DD_NAME_SIZE * sizeof(WCHAR)) +
(MAX_DD_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_DD_BANK_CODE_SIZE * sizeof(WCHAR)) +
(MAX_DD_BRANCH_CODE_SIZE * sizeof(WCHAR)) +
(MAX_DD_CHECK_DIGITS_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetVerifyBillingTokenResponseSize()
{
return sizeof(VERIFY_BILLING_TOKEN_RESPONSE);
}
XAMINLINE
DWORD
WINAPI
_XAccountGetMigrateXbox1UserResponseSize()
{
return sizeof(MIGRATE_XBOX1_USER_RESPONSE) +
(MAX_GAMERTAG_SIZE * sizeof(WCHAR)) +
(XONLINE_USERDOMAIN_SIZE * sizeof(WCHAR)) +
(XONLINE_REALM_NAME_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountGetMigrateXboxComUserResponseSize()
{
return sizeof(MIGRATE_XBOX_COM_USER_RESPONSE) +
(MAX_GAMERTAG_SIZE * sizeof(WCHAR)) +
(XONLINE_USERDOMAIN_SIZE * sizeof(WCHAR)) +
(XONLINE_REALM_NAME_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XAccountReserveGamertagResponseSize(DWORD dwNumResults)
{
return sizeof(ACCOUNT_RESERVE_GAMERTAG_RESPONSE) +
(dwNumResults * (sizeof(ACCOUNT_SUGGESTED_GAMERTAG) +
((MAX_GAMERTAG_SIZE+1) * sizeof(WCHAR))));
}
XAMINLINE
DWORD
WINAPI
_XAccountVerifyBillingInfoResponseSize()
{
return sizeof(ACCOUNT_VERIFY_BILLING_INFO_RESPONSE) +
(MAX_FIRSTNAME_SIZE * sizeof(WCHAR)) +
(MAX_LASTNAME_SIZE * sizeof(WCHAR)) +
(MAX_EMAIL_SIZE * sizeof(WCHAR)) +
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street1
(MAX_STREET_SIZE * sizeof(WCHAR)) + // street2
(MAX_CITY_SIZE * sizeof(WCHAR)) +
(MAX_DISTRICT_SIZE * sizeof(WCHAR)) +
(MAX_STATE_SIZE * sizeof(WCHAR)) +
(MAX_POSTALCODE_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_PREFIX_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_NUMBER_SIZE * sizeof(WCHAR)) +
(MAX_PHONE_EXTENSION_SIZE * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XPassportGetEncryptedProxyParametersResponseSize()
{
return sizeof(PASSPORT_ENCRYPTED_PROXY_PARAMETERS) +
(XONLINE_PASSPORT_LOGIN_TOKEN_REQUEST_MAX_LEN * sizeof(BYTE)) +
(XONLINE_PASSPORT_PUBLIC_KEY_MODULUS_MAX_LEN * sizeof(BYTE));
}
XAMINLINE
DWORD
WINAPI
_XPassportGetSecretQuestionsResponseSize()
{
return sizeof(PASSPORT_GET_SECRET_QUESTION_RESPONSE) +
(XONLINE_PASSPORT_SECRET_QUESTION_MAX_COUNT *
(sizeof(PASSPORT_SECRET_QUESTION) +
(XONLINE_PASSPORT_SECRET_QUESTION_MAX_LEN+1) * sizeof(WCHAR))
);
}
XAMINLINE
DWORD
WINAPI
_XPassportGetUserDataResponseSize()
{
return sizeof(PASSPORT_GET_USER_DATA_RESPONSE) +
((MAX_FIRSTNAME_SIZE+1) * sizeof(WCHAR)) +
((MAX_LASTNAME_SIZE+1) * sizeof(WCHAR)) +
((MAX_STREET_SIZE+1) * sizeof(WCHAR)) +
((MAX_STREET_SIZE+1) * sizeof(WCHAR)) +
((MAX_CITY_SIZE+1) * sizeof(WCHAR)) +
((MAX_DISTRICT_SIZE+1) * sizeof(WCHAR)) +
((MAX_STATE_SIZE+1) * sizeof(WCHAR)) +
((MAX_POSTALCODE_SIZE+1) * sizeof(WCHAR)) +
((MAX_PHONE_PREFIX_SIZE+1) * sizeof(WCHAR)) +
((MAX_PHONE_NUMBER_SIZE+1) * sizeof(WCHAR)) +
((MAX_PHONE_EXTENSION_SIZE+1) * sizeof(WCHAR));
}
XAMINLINE
DWORD
WINAPI
_XPassportGetMemberNameResponseSize()
{
return sizeof(PASSPORT_GET_MEMBER_NAME_RESPONSE) +
((XONLINE_PASSPORT_MEMBER_NAME_MAX_LEN+1) * sizeof(CHAR)) +
((XONLINE_PASSPORT_MEMBER_NAME_MAX_LEN+1) * sizeof(CHAR));
}
XBOXAPI
DWORD
WINAPI
_XPassportCreate(
IN PASSPORT_ENCRYPTED_PROXY_PARAMETERS* pProxyParameters,
IN CHAR *szPassportMemberName,
IN CHAR *szPassword,
IN WCHAR *szSecretQuestion,
IN WCHAR *szSecretAnswer,
IN DWORD cbSessionToken,
OUT PASSPORT_SESSION_TOKEN *pSessionToken,
IN OPTIONAL XOVERLAPPED *pXOverlapped);
XBOXAPI
DWORD
WINAPI
_XPassportChangePassword(
IN PASSPORT_ENCRYPTED_PROXY_PARAMETERS* pProxyParameters,
IN PASSPORT_SESSION_TOKEN* pSessionToken,
IN CHAR *szPassportMemberName,
IN CHAR *szOldPassword,
IN CHAR *szPassword,
IN WCHAR *szSecretQuestion,
IN WCHAR *szSecretAnswer,
IN OPTIONAL XOVERLAPPED *pXOverlapped);
XBOXAPI
DWORD
WINAPI
_XPassportLogin(
IN PASSPORT_ENCRYPTED_PROXY_PARAMETERS* pProxyParameters,
IN CHAR* szPassportMemberName,
IN CHAR* szPassword,
OUT PASSPORT_SESSION_TOKEN *pSessionToken,
IN OPTIONAL XOVERLAPPED *pXOverlapped);
#define XONLINE_LOGON_FLAG_TICKETS_ONLY 0x00000001
#define XONLINE_LOGON_FLAG_UPDATE_SERVICE_ONLY 0x00000002
XBOXAPI
DWORD
XOnlineLogon(
IN const XNET_LOGON_USER *rgLogonUsers,
IN DWORD dwFlags,
OUT XOVERLAPPED *pXOverlapped OPTIONAL
);
XBOXAPI
DWORD
XOnlineLogoff(
OUT XOVERLAPPED *pXOverlapped OPTIONAL
);
XAMINLINE
HRESULT
WINAPI
XOnlineGetLogonHR(
VOID
)
{
return XMsgInProcessCall(HXAMAPP_XLIVEBASE, XM_LIVEBASE_LOGONGETHR,
(UINT_PTR)NULL, (UINT_PTR)NULL);
}
XAMINLINE
HRESULT
WINAPI
XOnlineGetLogonUsers(PXNET_LOGON_USER pUsers)
{
return XMsgInProcessCall(HXAMAPP_XLIVEBASE, XM_LIVEBASE_LOGONGETUSERS, (UINT_PTR)pUsers, (UINT_PTR)NULL);
}
XAMINLINE
DWORD
WINAPI
XOnlineGetLogonID(
VOID
)
{
DWORD dwID;
if (FAILED(XMsgInProcessCall(HXAMAPP_XLIVEBASE, XM_LIVEBASE_LOGONGETID, (UINT_PTR)&dwID, (UINT_PTR)NULL)))
{
dwID = 0;
}
return dwID;
}
XBOXAPI
DWORD
WINAPI
XStorageDownloadToDirectoryGetProgress(
IN XOVERLAPPED *pXOverlapped,
OUT OPTIONAL DWORD *pdwPercentComplete,
OUT OPTIONAL ULONGLONG *pqwNumerator,
OUT OPTIONAL ULONGLONG *pqwDenominator
);
XBOXAPI
DWORD
WINAPI
XStorageUploadFromDirectoryGetProgress(
IN XOVERLAPPED *pXOverlapped,
OUT OPTIONAL DWORD *pdwPercentComplete,
OUT OPTIONAL ULONGLONG *pqwNumerator,
OUT OPTIONAL ULONGLONG *pqwDenominator
);
XBOXAPI
DWORD
WINAPI
XMessageSendGetProgress(
IN XOVERLAPPED *pXOverlapped,
OUT OPTIONAL DWORD *pdwPercentComplete,
OUT OPTIONAL ULONGLONG *pqwNumerator,
OUT OPTIONAL ULONGLONG *pqwDenominator
);
XBOXAPI
DWORD
WINAPI
XMessageDownloadAttachmentToMemoryGetProgress(
IN XOVERLAPPED *pXOverlapped,
OUT OPTIONAL DWORD *pdwPercentComplete,
OUT OPTIONAL ULONGLONG *pqwNumerator,
OUT OPTIONAL ULONGLONG *pqwDenominator
);
XBOXAPI
DWORD
WINAPI
XContentDownloadGetProgress(
IN XOVERLAPPED *pXOverlapped,
OUT OPTIONAL DWORD *pdwPercentComplete,
OUT OPTIONAL ULONGLONG *pqwNumerator,
OUT OPTIONAL ULONGLONG *pqwDenominator
);
XBOXAPI
DWORD
WINAPI
XUpdateDownloadGetProgress(
IN XOVERLAPPED *pXOverlapped,
OUT OPTIONAL DWORD *pdwPercentComplete,
OUT OPTIONAL ULONGLONG *pqwNumerator,
OUT OPTIONAL ULONGLONG *pqwDenominator
);
//
// Generic online task progress monitoring
//
XBOXAPI
DWORD
WINAPI
XOnlineGetTaskProgress(
IN XOVERLAPPED *pXOverlapped,
OUT OPTIONAL DWORD *pdwPercentComplete,
OUT OPTIONAL ULONGLONG *pqwNumerator,
OUT OPTIONAL ULONGLONG *pqwDenominator
);
//
// Throttle setting access (debug only)
//
XBOXAPI
DWORD
WINAPI
XOnlineGetRequestThrottleSettings(
IN DWORD dwOrdinal,
OUT XONLINE_REQUEST_THROTTLE_SETTINGS *pRequestThrottleSettings
);
XBOXAPI
DWORD
WINAPI
XOnlineSetRequestThrottleSettings(
IN DWORD dwOrdinal,
IN const XONLINE_REQUEST_THROTTLE_SETTINGS *pRequestThrottleSettings
);
//
// Privileges
//
XAMINLINE
BOOL
WINAPI
XOnlineCheckUserPrivilege(
IN XUID xuidUser,
IN DWORD dwPrivilege
)
{
XUSER_PRIVILEGE_MSG Msg;
ZeroMemory(&Msg, sizeof(XUSER_PRIVILEGE_MSG));
Msg.xuidUser = xuidUser;
Msg.dwPrivilege = dwPrivilege;
if (FAILED(XMsgInProcessCall(HXAMAPP_XLIVEBASE, XM_LIVEBASE_LOGONCHECKUSERPRIVILEGE,
(UINT_PTR)&Msg, (UINT_PTR)NULL) ))
{
Msg.fResult = FALSE;
}
return Msg.fResult;
}
XAMINLINE
BOOL
WINAPI
XOnlineAreUsersFriends(
IN XUID xuidUser,
IN PXUID pXuids,
IN DWORD dwXuidCount,
IN OUT PXOVERLAPPED pOverlapped OPTIONAL
)
{
XUSER_PRIVILEGE_MSG Msg;
ZeroMemory(&Msg, sizeof(XUSER_PRIVILEGE_MSG));
Msg.xuidUser = xuidUser;
Msg.pXuids = pXuids;
Msg.dwXuidCount = dwXuidCount;
Msg.pOverlapped = pOverlapped;
if (FAILED(XMsgInProcessCall(HXAMAPP_XLIVEBASE, XM_LIVEBASE_AREUSERSFRIENDS,
(UINT_PTR)&Msg, (UINT_PTR)NULL) ))
{
Msg.fResult = FALSE;
}
return Msg.fResult;
}
//
// UACS helper functions
//
BOOL
WINAPI
XOnlinepGetPrivilegeBit(
DWORD *rgPrivileges,
DWORD dwPrivilegeBit
);
void
WINAPI
XOnlinepSetPrivilegeBit(
DWORD *rgPrivileges,
DWORD dwPrivilegeBit,
BOOL bValue
);
XBOXAPI
DWORD
WINAPI
XContentDownload(
IN DWORD dwUserIndex,
IN const BYTE *pbContentId,
IN const CHAR *szTargetDirectory,
IN DWORD dwFlags,
IN PBYTE pbWorkspaceToUse,
IN OUT DWORD * pcbWorkspaceToUse,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XContentDownloadGetInProgressMetadata(
IN DWORD dwUserIndex,
IN const BYTE *pbContentId,
IN const CHAR *szTargetDirectory,
OUT BYTE *pContentHeader,
OUT BYTE *pContentMetaData,
OUT BYTE *pbOtherMetaData,
OUT DWORD *pdwOtherMetaDataSize
);
XBOXAPI
HRESULT
WINAPI
XContentGetReferral_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XContentGetReferral_Setup(
IN ULONGLONG qwUserId,
IN const BYTE *abContentId,
IN DWORD cbResults,
OUT XCONTENT_REFERRAL_RESPONSE *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XContentRefreshLicense(
IN ULONGLONG qwUserId,
IN WORD wContentHeaderLength,
IN const BYTE *pbContentHeader,
IN DWORD cbResults,
OUT XCONTENT_REFRESH_LICENSE_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
HRESULT
WINAPI
XContentRefreshLicenseSubTask_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XContentRefreshLicenseSubTask_Setup(
IN ULONGLONG qwUserId,
IN WORD wContentHeaderLength,
IN const BYTE *pbContentHeader,
IN DWORD cbResults,
OUT XCONTENT_REFRESH_LICENSE_RESPONSE *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XFriendsRequestWorker_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XFriendsRequestWorker_Setup(
IN ULONGLONG qwSenderID,
IN ULONGLONG qwBuddyID,
IN DWORD dwMessageFlags,
IN WORD cbDetails,
IN DWORD dwBuddyAcctNameSize,
IN const CHAR *szBuddyAcctName,
IN const XMSG_DETAILS *pDetails,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XInviteAnswer(
IN XUID XuidUser,
IN const XMSG_GAMEINVITE_ANSWER_INFO *pAnswerInfo,
IN XMSG_INVITE_ANSWER_TYPE Answer,
IN BOOL fFromGameInvite,
OUT XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XInviteRevoke(
IN XUID XuidUser,
IN WORD cInvitees,
IN const XUID *pXuidInvitees,
IN XNKID SessionID,
OUT XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XInviteSendMessage(
IN DWORD dwUserIndex,
IN DWORD dwNumInvitees,
IN const XUID *pXuidInvitees,
IN const WCHAR *pszText,
IN XMSG_HANDLE hMsg,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XLookupTitleName(
IN DWORD dwType,
IN DWORD dwNumTitles,
IN const DWORD *pTitleIDs,
IN DWORD dwLanguage,
IN DWORD cbResults,
OUT STRING_LOOKUP_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageCreate(
IN DWORD dwMsgType,
IN DWORD cProperties,
IN ULONGLONG qwMessageContext,
IN DWORD dwMessageFlags,
IN DWORD dwExpireMinutes,
OUT XMSG_HANDLE *phMsg
);
XBOXAPI
DWORD
WINAPI
XMessageDelete(
IN XUID XuidUser,
IN DWORD dwMessageID,
IN BOOL fBlockSender,
OUT XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageDeleteWorker(
IN XUID qwUserID,
IN DWORD dwMessageID,
IN DWORD dwFlags,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageDestroy(
IN XMSG_HANDLE hMsg
);
XBOXAPI
DWORD
WINAPI
XMessageDetailsGetProperty(
IN const XMSG_DETAILS_BLOB *pDetails,
IN WORD wPropTag,
IN DWORD cbPropValueBuffer,
OUT BYTE *pbPropValue,
OUT DWORD *pcbPropValue,
OUT DWORD *pdwAttachmentFlags
);
XBOXAPI
DWORD
WINAPI
XMessageDetailsGetSummary(
IN const XMSG_DETAILS_BLOB *pDetails,
OUT XMSG_SUMMARY *pMsgSummary,
OUT DWORD *pcProperties,
OUT ULONGLONG *pqwAttachmentsSize
);
XBOXAPI
DWORD
WINAPI
XMessageDownloadAttachmentToMemory(
IN XUID XuidUser,
IN const XMSG_DETAILS_BLOB *pDetailsBlob,
IN DWORD dwPropTag,
IN DWORD dwBufferSize,
IN const BYTE *pbBuffer,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageEnumerate(
IN XUID XuidUser,
OUT DWORD *pcMsgSummaries,
OUT XMSG_SUMMARY *pMsgSummaries
);
XBOXAPI
DWORD
WINAPI
XMessageEnumerateWorker(
IN ULONGLONG qwUserID,
IN DWORD cbResults,
OUT XMSG_ENUM_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageGetDetails(
IN XUID XuidUser,
IN DWORD dwMessageID,
IN DWORD dwFlagsToSet,
IN DWORD dwFlagsToClear,
IN DWORD cbResults,
OUT XMSG_DETAILS_BLOB *pResults,
OUT XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageGetDetailsWorker(
IN XUID qwUserID,
IN DWORD dwMessageID,
IN DWORD dwFlagsToSet,
IN DWORD dwFlagsToClear,
IN DWORD cbResults,
OUT XMSG_DETAILS_BLOB *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageGetProperty(
IN XMSG_HANDLE hMsg,
IN WORD wPropTag,
IN DWORD dwPropValueBufferSize,
OUT BYTE *pbPropValue,
OUT DWORD *pcbPropValue,
OUT DWORD *pdwAttachmentFlags
);
XBOXAPI
DWORD
WINAPI
XMessageGetSummary(
IN XUID XuidUser,
IN DWORD dwMessageID,
OUT XMSG_SUMMARY *pMsgSummary
);
XBOXAPI
DWORD
WINAPI
XMessageGetSummaryWorker(
IN ULONGLONG qwUserID,
IN DWORD dwMessageID,
IN DWORD cbResults,
OUT Q_MESSAGE_SUMMARY_REPLY_MSG *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageInviteAnswerWorker(
IN DWORD dwMsgLen,
IN ULONGLONG qwUserID,
IN ULONGLONG qwHostID,
IN XNKID MatchSessionID,
IN WORD wAnswer,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageInviteRevokeWorker(
IN DWORD dwMsgLen,
IN ULONGLONG qwUserID,
IN XNKID SessionID,
IN WORD cInvitees,
IN const ULONGLONG *pqwInviteeIDs,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
HRESULT
WINAPI
XMessageInviteSendWorker_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XMessageInviteSendWorker_Setup(
IN DWORD dwMsgLen,
IN ULONGLONG qwUserID,
IN ULONGLONG qwSenderContext,
IN DWORD dwMessageFlags,
IN WORD cInvitees,
IN WORD cbDetails,
IN const ULONGLONG *pqwInviteeIDs,
IN const XMSG_DETAILS *pDetails,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XMessageRevoke(
IN XUID qwUserID,
IN WORD cRecipients,
IN const XMSG_SEND_RECIPIENT_RESULT *pRecipients,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageSend(
IN XUID XuidSender,
IN XMSG_HANDLE hMsg,
IN DWORD cRecipients,
IN const XUID *pXuidRecipients,
IN DWORD cbResults,
OUT XMSG_SEND_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
HRESULT
WINAPI
XMessageSendWorker_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XMessageSendWorker_Setup(
IN DWORD dwMsgLen,
IN ULONGLONG qwUserID,
IN ULONGLONG qwSenderContext,
IN DWORD dwMessageFlags,
IN WORD wExpireMinutes,
IN WORD cbDetails,
IN WORD cRecipients,
IN BYTE bMessageType,
IN const CHAR *szSenderName,
IN const ULONGLONG *qwRecipientIDs,
IN const XMSG_DETAILS *pDetails,
IN DWORD cbResults,
OUT XMSG_SEND_RESULT *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XMessageSetFlags(
IN XUID XuidUser,
IN DWORD dwMessageID,
IN DWORD dwFlagsToSet,
IN DWORD dwFlagsToClear,
OUT XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageSetFlagsWorker(
IN XUID qwUserID,
IN DWORD dwMessageID,
IN DWORD dwSetFlags,
IN DWORD dwUnsetFlags,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XMessageSetProperty(
IN XMSG_HANDLE hMsg,
IN WORD wPropTag,
IN DWORD dwPropValueSize,
IN const BYTE *pbPropValue,
IN DWORD dwAttachmentFlags
);
XBOXAPI
DWORD
WINAPI
XOnlineMatchCreate(
IN DWORD dwPublicFilled,
IN DWORD dwPublicOpen,
IN DWORD dwPrivateFilled,
IN DWORD dwPrivateOpen,
IN DWORD dwNumAttributes,
IN const XONLINE_ATTRIBUTE *pAttributes,
IN DWORD cbMinRequest,
IN DWORD cbResults,
OUT XONLINE_MATCH_SESSION_INFO *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineMatchDelete(
IN XNKID SessionID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineMatchRegisterSession(
IN XUID UserXuid,
IN XNKID sessionID
);
XBOXAPI
DWORD
WINAPI
XOnlineMatchSearch(
IN DWORD dwProcedureIndex,
IN DWORD dwNumResults,
IN DWORD dwNumAttributes,
IN const XONLINE_ATTRIBUTE *pAttributes,
IN DWORD cbMinRequest,
IN WORD wNumUsers,
IN DWORD cbResults,
OUT XONLINE_MATCH_SEARCHRESULT_HEADER *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineMatchUpdate(
IN XNKID SessionID,
IN DWORD dwPublicFilled,
IN DWORD dwPublicOpen,
IN DWORD dwPrivateFilled,
IN DWORD dwPrivateOpen,
IN DWORD dwNumAttributes,
IN const XONLINE_ATTRIBUTE *pAttributes,
IN DWORD cbMinRequest,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQueryAdd(
IN XUID qwUserId,
IN ULONGLONG qwTeamId,
IN DWORD dwDatasetId,
IN DWORD dwNumAttributes,
IN const XONLINE_QUERY_ATTRIBUTE *pAttributes,
IN DWORD cbResults,
OUT QUERY_ADD_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQueryFindFromIds(
IN DWORD dwDatasetId,
IN DWORD dwProcIndex,
IN DWORD dwNumResultSpecs,
IN const XONLINE_QUERY_ATTRIBUTE_SPEC *pSpecs,
IN DWORD dwNumIds,
IN const ULONGLONG *pqwEntityIds,
IN DWORD cbResults,
OUT QUERY_FINDFROMIDS_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQueryRemove(
IN XUID qwUserId,
IN ULONGLONG qwTeamId,
IN DWORD dwDatasetId,
IN DWORD dwProcIndex,
IN DWORD dwNumAttributes,
IN const XONLINE_QUERY_ATTRIBUTE *pAttributes,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQueryRemoveId(
IN XUID qwUserId,
IN ULONGLONG qwTeamId,
IN DWORD dwDatasetId,
IN ULONGLONG qwEntityId,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQuerySearch(
IN DWORD dwDatasetId,
IN DWORD dwProcIndex,
IN DWORD dwPage,
IN DWORD dwResultsPerPage,
IN DWORD dwNumResultSpecs,
IN const XONLINE_QUERY_ATTRIBUTE_SPEC *pSpecs,
IN DWORD dwNumAttributes,
IN const XONLINE_QUERY_ATTRIBUTE *pAttributes,
IN DWORD cbResults,
OUT QUERY_SEARCH_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQuerySelect(
IN XUID qwUserId,
IN ULONGLONG qwTeamId,
IN DWORD dwDatasetId,
IN ULONGLONG qwEntityId,
IN DWORD dwActionId,
IN DWORD dwNumAttributes,
IN const XONLINE_QUERY_ATTRIBUTE *pAttributes,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQueryUpdate(
IN XUID qwUserId,
IN ULONGLONG qwTeamId,
IN DWORD dwDatasetId,
IN DWORD dwProcIndex,
IN DWORD dwNumAttributes,
IN const XONLINE_QUERY_ATTRIBUTE *pAttributes,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineQueryUpdateId(
IN XUID qwUserId,
IN ULONGLONG qwTeamId,
IN DWORD dwDatasetId,
IN DWORD dwProcIndex,
IN ULONGLONG qwEntityId,
IN DWORD dwNumAttributes,
IN const XONLINE_QUERY_ATTRIBUTE *pAttributes,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamCreate(
IN XUID qwUserID,
IN const WCHAR *wszTeamName,
IN const WCHAR *wszTeamDescription,
IN const WCHAR *wszTeamMotto,
IN const WCHAR *wszTeamURL,
IN WORD cbTeamData,
IN const BYTE *pbTeamData,
IN WORD cbCreatorData,
IN const BYTE *pbCreatorData,
IN DWORD cbResults,
OUT TEAM_CREATE_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamDelete(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamEnumerate(
IN XUID qwUserID,
IN DWORD dwTeamCount,
IN const ULONGLONG *rgqwTeamIDs,
IN DWORD cbResults,
OUT TEAM_ENUM_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamEnumerateByUserXUID(
IN XUID qwUserID,
IN DWORD cbResults,
OUT TEAM_ENUM_BY_XUID_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamJoin(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN BYTE bAnswer,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamMemberRecruit(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN XUID qwMemberID,
IN DWORD dwMemberPriv,
IN WORD cbMemberData,
IN const BYTE *pbMemberData,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamMemberRecruitByName(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN const CHAR *szMemberName,
IN DWORD dwMemberPriv,
IN WORD cbMemberData,
IN const BYTE *pbMemberData,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamMemberRemove(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN XUID qwMemberID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamMemberSetProperties(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN XUID qwMemberID,
IN DWORD dwMemberPriv,
IN WORD cbMemberData,
IN const BYTE *pbMemberData,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamMembersEnumerate(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN BOOL fShowRecruits,
IN DWORD cbResults,
OUT TEAM_MEM_ENUM_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineTeamSetProperties(
IN XUID qwUserID,
IN ULONGLONG qwTeamID,
IN const WCHAR *wszTeamName,
IN const WCHAR *wszTeamDescription,
IN const WCHAR *wszTeamMotto,
IN const WCHAR *wszTeamURL,
IN WORD cbTeamData,
IN const BYTE *pbTeamData,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepFriendsAcceptRequest(
IN XUID qwSenderID,
IN XUID qwBuddyID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepFriendsRejectRequest(
IN XUID qwSenderID,
IN XUID qwBuddyID,
IN BOOL Block,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepFriendsRemove(
IN XUID qwSenderID,
IN XUID qwBuddyID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepFriendsRequest(
IN XUID XuidFromUser,
IN XUID qwBuddyID,
IN XMSG_HANDLE hMsg,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepFriendsRequestByName(
IN XUID XuidFromUser,
IN const CHAR *szUserName,
IN XMSG_HANDLE hMsg,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepMuteListAdd(
IN XUID qwUserID,
IN XUID qwBlockID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepMuteListRemove(
IN XUID qwUserID,
IN XUID qwBlockID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepNotificationSendDequeue(
IN const Q_DEQUEUE_MSG *pDequeueMsg,
IN DWORD cbResults,
OUT Q_LIST_REPLY_MSG *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepPeerSubscribe(
IN XUID qwUserID,
IN WORD cSrcUserIDs,
IN const ULONGLONG *rgqwSrcUserIDs,
IN DWORD cbResults,
OUT P_PEER_SUBSCRIBE_REPLY_MSG *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepPeerUnsubscribe(
IN XUID qwUserID,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlinepSetUserSettings2(
IN XUID qwUserId,
IN WORD bTier,
IN WORD dwUserFlags,
IN const DWORD *rgPrivileges,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XPresenceGetLocalSession(
IN DWORD cbResults,
OUT GET_SESSION_RESULTS *pResults
);
XBOXAPI
DWORD
WINAPI
XPresenceGetPeerSession(
IN XUID qwUserID,
IN XUID qwHostUserID,
IN DWORD cbResults,
OUT GET_SESSION_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XPresenceGetState(
IN XUID UserXuid,
OUT DWORD *pdwStateFlags,
OUT XNKID *pSessionID
);
XBOXAPI
DWORD
WINAPI
XPresenceSendAlives(
IN DWORD cAlivesToSend,
IN const P_ALIVE_2_MSG *pAlives,
IN DWORD cbResults,
OUT XPRESENCE_ALIVE_REPLY *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XPresenceSendDeadUsers(
IN DWORD cDeadUsersToSend,
IN const P_DEAD_USER_MSG *pDeadUsers,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XPresenceSetState(
IN XUID UserXuid,
IN DWORD dwStateFlags,
IN XNKID sessionID,
IN DWORD cbState,
IN const BYTE *pbState
);
XBOXAPI
DWORD
WINAPI
XPresenceUpdateStateFlags(
IN XUID UserXuid,
IN DWORD dwStateFlagsSet,
IN DWORD dwStateFlagsClear
);
XBOXAPI
HRESULT
WINAPI
XResolveName_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XResolveName_Setup(
IN const XRESOLVE_DOMAIN_STRING *pResolveString,
IN DWORD cbResults,
OUT XRESOLVE_NAME_RESPONSE *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XSignatureCheckRevocation(
IN DWORD dwNumContentTuples,
IN const XSIGNATURE_CONTENT_TUPLE *pTuples,
IN DWORD cbResults,
OUT XSIGNATURE_CHECK_REVOCATION_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
HRESULT
WINAPI
XSignatureVerify_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XSignatureVerify_Setup(
IN DWORD dwNumSignaturesToVerify,
IN const XSIGNATURE_TO_VERIFY *pSignaturesToVerify,
IN DWORD cbResults,
OUT XSIGNATURE_VERIFY_RESPONSE *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XStorageDeleteWorker_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XStorageDeleteWorker_Setup(
IN XUID UserXuid,
IN const XSTORAGE_ACCESS_TOKEN *pStorageAccessToken,
IN const XSTORAGE_PATH_STRING *pStoragePathString,
IN const XSTORAGE_ACCESS_TOKEN_READ *pStorageAccessTokenRead,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XStorageDownloadToDirectoryInternal(
IN DWORD dwUserIndex,
IN const WCHAR *wszServerPath,
IN const WCHAR *wszDisplayName,
IN XCONTENTDEVICEID DeviceID,
IN DWORD cbResults,
OUT XSTORAGE_DOWNLOAD_TO_DIRECTORY_RESULTS_INTERNAL *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
HRESULT
WINAPI
XStorageDownloadWorker_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XStorageDownloadWorker_Setup(
IN XUID UserXuid,
IN const XSTORAGE_ACCESS_TOKEN *pStorageAccessToken,
IN const XSTORAGE_PATH_STRING *pStoragePathString,
IN const XSTORAGE_ACCESS_TOKEN_READ *pStorageAccessTokenRead,
IN DWORD dwRangeStart,
IN DWORD dwRangeEnd,
IN const FILETIME *pftLastModified,
IN DWORD cbResults,
OUT XSTORAGE_DOWNLOAD_RESPONSE *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XStorageEnumerateWorker_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XStorageEnumerateWorker_Setup(
IN XUID UserXuid,
IN const XSTORAGE_ACCESS_TOKEN *pStorageAccessToken,
IN const XSTORAGE_PATH_STRING *pStoragePathString,
IN const XSTORAGE_ACCESS_TOKEN_READ *pStorageAccessTokenRead,
IN DWORD dwStartingIndex,
IN DWORD dwEndingIndex,
IN DWORD cbResults,
OUT XSTORAGE_ENUMERATE_RESULTS *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XStorageUploadFromDirectoryInternal(
IN DWORD dwUserIndex,
IN const WCHAR *wszServerPath,
IN const CHAR *szLocalPath,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
HRESULT
WINAPI
XStorageUploadWorker_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XStorageUploadWorker_Setup(
IN XUID UserXuid,
IN const XSTORAGE_ACCESS_TOKEN *pStorageAccessToken,
IN const XSTORAGE_PATH_STRING *pStoragePathString,
IN const XSTORAGE_ACCESS_TOKEN_WRITE *pStorageAccessTokenWrite,
IN BYTE bCompressionType,
IN DWORD dwContentType,
IN DWORD dwDigestSize,
IN const BYTE *prgbDigest,
IN DWORD dwLiveSignatureSize,
IN const BYTE *prgbLiveSignature,
IN DWORD dwInstallSize,
IN WORD wAttributesSize,
IN DWORD dwPackageSize,
IN const BYTE *prgbAttributes,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XStringLookup(
IN DWORD dwTitleID,
IN const CHAR *szLocale,
IN DWORD dwNumStrings,
IN const DWORD *pStringIDs,
IN DWORD cbResults,
OUT STRING_LOOKUP_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUpdateDownload(
IN DWORD dwTitleId,
IN DWORD dwVersion,
IN DWORD cbResults,
OUT XUPDATE_DOWNLOAD_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
HRESULT
WINAPI
XUpdateGetReferral_GetContextSize(
OUT DWORD *pcbContextSize,
OUT DWORD *pcbRequestWireBuffer,
OUT DWORD *pcbResponseWireBuffer
);
XBOXAPI
HRESULT
WINAPI
XUpdateGetReferral_Setup(
IN DWORD dwTitleId,
IN DWORD dwVersion,
IN DWORD cbResults,
OUT XUPDATE_REFERRAL_RESPONSE *pResults,
IN PVOID pvParentTask,
IN PBYTE pbSubTask,
IN DWORD cbSubTask,
IN PBYTE pbRequestWireBuffer,
IN DWORD cbRequestWireBuffer,
IN PBYTE pbResponseWireBuffer,
IN DWORD cbResponseWireBuffer
);
XBOXAPI
DWORD
WINAPI
XUserAddAffiliate(
IN ULONGLONG qwUserID,
IN DWORD dwListFlags,
IN DWORD dwTitleID,
IN WORD cwAffiliates,
IN const ULONGLONG *pqwAfilliateIDs,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserEnumerateReceivedReviews(
IN ULONGLONG qwTargetID,
IN DWORD dwPageID,
IN DWORD dwResultsPerPage,
IN DWORD cbResults,
OUT FB_ENUM_REVIEWS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserEnumerateSentReviews(
IN ULONGLONG qwSenderID,
IN DWORD dwPageID,
IN DWORD dwResultsPerPage,
IN DWORD cbResults,
OUT FB_ENUM_REVIEWS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserFindUser(
IN XUID qwUserID,
IN XUID qwFindID,
IN const CHAR *szSenderName,
IN DWORD cbResults,
OUT P_FIND_USER_REPLY_MSG *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserGetAggregateReviews(
IN ULONGLONG qwTargetID,
IN DWORD cbResults,
OUT FB_GET_AGG_REVIEWS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserIsAffiliate(
IN ULONGLONG qwUserID,
IN ULONGLONG qwAffiliateID,
IN DWORD cbResults,
OUT P_IS_AFFILIATE_REPLY_MSG *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserQueryAffiliate(
IN ULONGLONG qwUserID,
IN DWORD dwListFlags,
IN DWORD cdwLimit,
IN DWORD dwOnlineTitleID,
IN DWORD cbResults,
OUT P_QUERY_AFFILIATES_REPLY_MSG *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserSubmitComplaint(
IN ULONGLONG qwSenderID,
IN ULONGLONG qwTargetID,
IN DWORD dwTitleID,
IN DWORD dwType,
IN ULONGLONG qwContext,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XUserSubmitPlayerReview(
IN ULONGLONG qwSenderID,
IN ULONGLONG qwTargetID,
IN DWORD dwTitleID,
IN DWORD dwType,
IN ULONGLONG qwContext,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountAcceptTermsOfUse(
IN XUID qwUserId,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountAcknowledgeDowngrade(
IN ULONGLONG qwUserId,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountAddPaymentInstrument(
IN XUID qwUserId,
IN ADDRESS_INFO addressInfo,
IN PHONE_INFO phoneInfo,
IN BYTE bPaymentTypeId,
IN CREDIT_CARD_INFO creditCardInfo,
IN DIRECT_DEBIT_INFO directDebitInfo,
IN DWORD cbResults,
OUT ADD_PAYMENT_INSTRUMENT_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountChangeGamertag(
IN DWORD dwUserIndex,
IN const WCHAR *wszGamertag,
IN DWORD cbResults,
OUT ACCOUNT_CHANGE_GAMERTAG_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountChangeSubscriptionPaymentInstrument(
IN XUID qwUserId,
IN const WCHAR *wszInstanceId,
IN const WCHAR *wszPaymentInstrumentId,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountCreateLiveAccount(
IN ULONGLONG qwOfflineXuid,
IN const WCHAR *wszFirstName,
IN const WCHAR *wszLastName,
IN const WCHAR *wszGamertag,
IN const BYTE *abSignedUserPassportPuid,
IN const BYTE *abSignedOwnerPassportPuid,
IN ULONGLONG qwOfferId,
IN const WCHAR *wszBillingToken,
IN FILETIME ftBirthdate,
IN const WCHAR *wszEmail,
IN WORD wLanguageId,
IN BYTE bCountryId,
IN DWORD dwParentalControlGroupId,
IN BYTE bMsftOptIn,
IN BYTE bPartnerOptIn,
IN ADDRESS_INFO address,
IN PHONE_INFO phone,
IN BYTE bPaymentTypeId,
IN CREDIT_CARD_INFO creditCard,
IN DIRECT_DEBIT_INFO directDebit,
IN WORD wReservedBytesLength,
IN const BYTE *pbReservedBytes,
IN DWORD cbResults,
OUT CREATE_LIVE_ACCOUNT_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountCreateLiveAccountOld(
IN const WCHAR *wszFirstName,
IN const WCHAR *wszLastName,
IN const WCHAR *wszGamertag,
IN ULONGLONG qwUserPassportPuid,
IN ULONGLONG qwOwnerPassportPuid,
IN ULONGLONG qwOfferId,
IN const WCHAR *wszBillingToken,
IN FILETIME ftBirthdate,
IN const WCHAR *wszEmail,
IN WORD wLanguageId,
IN BYTE bCountryId,
IN DWORD dwParentalControlGroupId,
IN BYTE bMsftOptIn,
IN BYTE bPartnerOptIn,
IN ADDRESS_INFO address,
IN PHONE_INFO phone,
IN BYTE bPaymentTypeId,
IN CREDIT_CARD_INFO creditCard,
IN DIRECT_DEBIT_INFO directDebit,
IN DWORD cbResults,
OUT CREATE_LIVE_ACCOUNT_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetAccountInfo(
IN XUID qwUserId,
IN DWORD cbResults,
OUT GET_ACCOUNT_INFO_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetAccountInfoFromPassport(
IN const PASSPORT_SESSION_TOKEN *pSessionToken,
IN DWORD cbResults,
OUT GET_ACCOUNT_INFO_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetLinkedGamertag(
IN const BYTE *pSignedPuid,
IN DWORD cbResults,
OUT GET_LINKED_GAMERTAG_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetPaymentInstruments(
IN XUID qwUserId,
IN DWORD cbResults,
OUT GET_PAYMENT_INSTRUMENTS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetPointsBalance(
IN XUID qwUserId,
IN DWORD cbResults,
OUT GET_POINTS_BALANCE_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetPostalCode(
IN BYTE bCountryId,
IN const WCHAR *wszPostalCode,
IN DWORD cbResults,
OUT GET_POSTAL_CODE_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetUserInfo(
IN DWORD dwUserIndex,
IN DWORD cbResults,
OUT GET_USER_INFO_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetUserSubscriptionDetails(
IN XUID qwUserId,
IN ULONGLONG qwOfferId,
IN const WCHAR *wszInstanceId,
IN DWORD cbResults,
OUT GET_USER_SUBSCRIPTION_DETAILS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountGetUserType(
IN const WCHAR *wszGamertag,
IN DWORD cbResults,
OUT ACCOUNT_GET_USER_TYPE_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountLinkXbox1Account(
IN const WCHAR *wszGamertag,
IN const PASSPORT_SESSION_TOKEN *pUserSessionToken,
IN const PASSPORT_SESSION_TOKEN *pParentSessionToken,
IN PHONE_INFO phoneInfo,
IN const WCHAR *wszPostalCode,
IN const WCHAR *wszAccountHolderName,
IN const WCHAR *wszAccountNumber,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountMigrateXbox1User(
IN const PASSPORT_SESSION_TOKEN *pUserSessionToken,
IN const PASSPORT_SESSION_TOKEN *pParentSessionToken,
IN ULONGLONG qwOfflineXuid,
IN const CHAR *szUserPassportMemberName,
IN WORD wLanguageId,
IN WORD wReservedBytesLength,
IN const BYTE *pbReservedBytes,
IN DWORD cbResults,
OUT MIGRATE_XBOX1_USER_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountMigrateXboxComUser(
IN const PASSPORT_SESSION_TOKEN *pUserSessionToken,
IN ULONGLONG qwOfflineXuid,
IN BYTE bCountryId,
IN WORD wLanguageId,
IN ULONGLONG qwOfferId,
IN const WCHAR *wszBillingToken,
IN const WCHAR *wszFirstName,
IN const WCHAR *wszLastName,
IN const WCHAR *wszEmail,
IN ADDRESS_INFO address,
IN PHONE_INFO phone,
IN BYTE bPaymentTypeId,
IN CREDIT_CARD_INFO creditCard,
IN DIRECT_DEBIT_INFO directDebit,
IN DWORD cbResults,
OUT MIGRATE_XBOX_COM_USER_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountQuery(
IN DWORD dwRequestType,
IN WORD wRequestBytesLength,
IN const BYTE *pbRequestBytes,
IN DWORD cbResults,
OUT ACCOUNT_QUERY_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountRecoverAccount(
IN const BYTE *pSignedPuid,
IN DWORD cbResults,
OUT RECOVER_ACCOUNT_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountRemovePaymentInstrument(
IN XUID qwUserId,
IN const WCHAR *wszPaymentInstrumentId,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountReserveGamertag(
IN BYTE bCountryId,
IN WORD wMaxSuggestedNames,
IN const WCHAR *wszGamertag,
IN DWORD cbResults,
OUT ACCOUNT_RESERVE_GAMERTAG_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountSetAccountInfo(
IN XUID qwUserId,
IN const WCHAR *wszFirstName,
IN const WCHAR *wszLastName,
IN FILETIME ftBirthdate,
IN const WCHAR *wszEmail,
IN ADDRESS_INFO address,
IN PHONE_INFO phone,
IN WORD wLanguageId,
IN BYTE bMsftOptIn,
IN BYTE bParterOptIn,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountSetStatus(
IN XUID qwUserId,
IN DWORD dwNewTermsOfService,
IN DWORD dwForceNameChangeRequired,
IN FILETIME ftSuspendedUntil,
IN WORD wTotalDaysSuspended,
IN FILETIME ftVoiceBannedUntil,
IN WORD wTotalDaysVoiceBanned,
IN DWORD dwBillingHr,
IN DWORD dwResetPassword,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountTroubleshoot(
IN ULONGLONG qwUserId,
IN WORD wReservedBytesLength,
IN const BYTE *pbReservedBytes,
IN DWORD cbResults,
OUT ACCOUNT_TROUBLESHOOT_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountUpdateParentalControls(
IN XUID qwUserId,
IN const DWORD *rgGrantPrivileges,
IN const DWORD *rgRestrictPrivileges,
IN const WCHAR *wszSource,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountUpdatePaymentInstrument(
IN XUID qwUserId,
IN const WCHAR *wszPaymentInstrumentId,
IN ADDRESS_INFO addressInfo,
IN PHONE_INFO phoneInfo,
IN CREDIT_CARD_INFO creditCardInfo,
IN DIRECT_DEBIT_INFO directDebitInfo,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountVerifyBillingInfo(
IN const WCHAR *wszGamertag,
IN PHONE_INFO phone,
IN const WCHAR *wszPostalCode,
IN const WCHAR *wszAccountHolderName,
IN const WCHAR *wszAccountNumber,
IN DWORD cbResults,
OUT ACCOUNT_VERIFY_BILLING_INFO_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountVerifyBillingToken(
IN BYTE bCountryId,
IN const WCHAR *wszBillingToken,
IN DWORD cbResults,
OUT VERIFY_BILLING_TOKEN_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XAccountVerifyParentCreditCard(
IN const PASSPORT_SESSION_TOKEN *pParentSessionToken,
IN const CHAR *szParentPassportMemberName,
IN WORD wLanguageId,
IN BYTE bCountryId,
IN const WCHAR *wszFirstName,
IN const WCHAR *wszLastName,
IN const WCHAR *wszEmail,
IN ADDRESS_INFO address,
IN PHONE_INFO phone,
IN CREDIT_CARD_INFO creditCardInfo,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XBannerGetHotList(
IN ULONGLONG qwUserId,
IN DWORD dwLangId,
IN DWORD dwStartingIndex,
IN DWORD dwMaxResults,
IN DWORD cbResults,
OUT BANNER_HOTLIST_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XBannerGetList(
IN ULONGLONG qwUserId,
IN DWORD dwLangId,
IN DWORD cbResults,
OUT BANNER_LIST_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingContentAvailable(
IN XUID qwUserId,
IN BYTE bTier,
IN DWORD dwTitleId,
IN DWORD cbResults,
OUT CONTENT_AVAILABLE_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingContentDetails(
IN XUID qwUserId,
IN WORD wLanguageId,
IN ULONGLONG qwOfferID,
IN DWORD dwPaymentType,
IN BYTE bRatingSystem,
IN DWORD cbResults,
OUT CONTENT_DETAILS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingContentEnumerate(
IN XUID qwUserId,
IN WORD wLanguageId,
IN WORD wGameRating,
IN DWORD dwOfferType,
IN DWORD dwPaymentType,
IN BYTE bTier,
IN DWORD dwTitleId,
IN DWORD dwTitleCategories,
IN BYTE bRequestFlags,
IN DWORD dwStartingIndex,
IN DWORD dwMaxResults,
IN DWORD cbResults,
OUT CONTENT_ENUMERATE_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingEnumerateGenres(
IN XUID UserXuid,
IN WORD wLanguageId,
IN DWORD dwStartingIndex,
IN DWORD dwMaxResults,
IN WORD wGameRating,
IN BYTE bTierRequired,
IN DWORD dwOfferType,
IN DWORD dwParentGenreId,
IN DWORD cbResults,
OUT ENUMERATE_GENRES_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingEnumerateTitlesByFilter(
IN XUID qwUserId,
IN WORD wLanguageId,
IN DWORD dwStartingIndex,
IN DWORD dwMaxResults,
IN WORD wGameRating,
IN BYTE bTierRequired,
IN DWORD dwGenreId,
IN DWORD dwOfferType,
IN WORD wRequestFlags,
IN DWORD cbResults,
OUT ENUMERATE_TITLES_BY_FILTER_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingGetTitleDetails(
IN XUID qwUserId,
IN DWORD dwTitleId,
IN BYTE bCountryId,
IN WORD wLanguageId,
IN BYTE bTierRequired,
IN DWORD cbResults,
OUT TITLE_DETAILS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingInternalUpdateAccessTimes(
IN XUID qwUserId,
IN DWORD dwTitleId,
IN DWORD dwTitleCategories,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingPurchase(
IN XUID qwUserId,
IN WORD wLanguageId,
IN BYTE bUserTier,
IN ULONGLONG qwOfferID,
IN DWORD dwPaymentType,
IN const WCHAR *wszPaymentInstrumentId,
IN const WCHAR *wszToken,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingPurchaseGamertag(
IN XUID qwUserId,
IN WORD wLanguageId,
IN BYTE bUserTier,
IN ULONGLONG qwOfferID,
IN DWORD dwPaymentType,
IN const WCHAR *wszToken,
IN const WCHAR *wszGamertag,
IN DWORD cbResults,
OUT OFFER_PURCHASE_GAMERTAG_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingSubscriptionDetails(
IN XUID qwUserId,
IN BYTE bCountryId,
IN WORD wLanguageId,
IN ULONGLONG qwOfferID,
IN DWORD dwPaymentType,
IN BYTE bUserTier,
IN BYTE bRatingSystem,
IN DWORD cbResults,
OUT SUBSCRIPTION_DETAILS_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOfferingSubscriptionEnumerate(
IN XUID qwUserId,
IN BYTE bUserTier,
IN BYTE bCountryId,
IN WORD wLanguageId,
IN WORD wGameRating,
IN DWORD dwOfferType,
IN DWORD dwPaymentType,
IN DWORD dwTitleId,
IN DWORD dwTitleCategories,
IN WORD wRequestFlags,
IN DWORD dwStartingIndex,
IN DWORD dwMaxResults,
IN DWORD cbResults,
OUT SUBSCRIPTION_ENUMERATE_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineArbitrationRegister(
IN WORD wFlags,
IN ULONGLONG qwSessionId,
IN ULONGLONG qwSessionNonce,
IN WORD wMaxSessionSeconds,
IN DWORD cbResults,
OUT XARB_REGISTER_REPLY *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineArbitrationReportResult(
IN WORD wFlags,
IN ULONGLONG qwSessionID,
IN ULONGLONG qwSessionNonce,
IN BYTE bReportLostMachines,
IN const XARB_REPORT_LOST_MACHINES *pLostMachines,
IN BYTE cSuspiciousInfo,
IN const XARB_REPORT_SUSPICIOUS_INFO *pSuspiciousInfo,
IN BYTE bSubmitStatsBundle,
IN const XARB_REPORT_STATS_BUNDLE *pStatsBundle,
IN BYTE bSubmitCompsBundle,
IN const XARB_REPORT_BYTE_BUNDLE *pCompsBundle,
IN DWORD cbMinRequest,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineArbitrationTimeExtend(
IN ULONGLONG qwSessionID,
IN ULONGLONG qwSessionNonce,
IN WORD wMaxSessionSecondsFromNow,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineStatsEnumerateByRank(
IN DWORD dwTitleId,
IN ULONGLONG qwRank,
IN DWORD dwPageSize,
IN DWORD dwNumSpecs,
IN const XONLINE_STATS_SPEC *pSpecs,
IN DWORD cbResults,
OUT XONLINE_STATS_ENUM_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineStatsEnumerateByRating(
IN DWORD dwTitleId,
IN LONGLONG i64Rating,
IN DWORD dwPageSize,
IN DWORD dwNumSpecs,
IN const XONLINE_STATS_SPEC *pSpecs,
IN DWORD cbResults,
OUT XONLINE_STATS_ENUM_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineStatsEnumerateByXuid(
IN DWORD dwTitleId,
IN XUID Xuid,
IN DWORD dwPageSize,
IN DWORD dwNumSpecs,
IN const XONLINE_STATS_SPEC *pSpecs,
IN DWORD cbResults,
OUT XONLINE_STATS_ENUM_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineStatsPost(
IN WORD wNumProcs,
IN const XSTAT_PROC *pProcs,
IN DWORD cbMinRequest,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineStatsRead(
IN DWORD dwTitleId,
IN DWORD dwNumXuids,
IN const XUID *pXuids,
IN DWORD dwNumSpecs,
IN const XONLINE_STATS_SPEC *pSpecs,
IN DWORD cbResults,
OUT XONLINE_STATS_READ_RESULTS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XOnlineStatsReset(
IN DWORD dwTitleId,
IN ULONGLONG qwUserId,
IN DWORD dwLeaderBoardId,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XPassportChangePasswordInternal(
IN const PASSPORT_SESSION_TOKEN *pSessionToken,
IN const CHAR *szPassportMemberName,
IN WORD wEncryptedPasswordLength,
IN const BYTE *pbEncryptedPassword,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XPassportCreateInternal(
IN const CHAR *szPassportMemberName,
IN const WCHAR *szSecretQuestion,
IN WORD wEncryptedPasswordLength,
IN const BYTE *pbEncryptedPassword,
IN DWORD cbResults,
OUT PASSPORT_SESSION_TOKEN *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XPassportGetEncryptedProxyParameters(
IN DWORD dwDummy,
IN DWORD cbResults,
OUT PASSPORT_ENCRYPTED_PROXY_PARAMETERS *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XPassportGetMemberName(
IN DWORD dwUserIndex,
IN DWORD cbResults,
OUT PASSPORT_GET_MEMBER_NAME_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XPassportGetSecretQuestions(
IN WORD wCountryId,
IN WORD wLanguageId,
IN DWORD cbResults,
OUT PASSPORT_GET_SECRET_QUESTION_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XPassportGetUserData(
IN const PASSPORT_SESSION_TOKEN *pSessionToken,
IN DWORD cbResults,
OUT PASSPORT_GET_USER_DATA_RESPONSE *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XPassportLoginInternal(
IN const CHAR *szPassportMemberName,
IN WORD wEncryptedSessionKeyLength,
IN const BYTE *pbencryptedSessionKey,
IN WORD wEncryptedPasswordLength,
IN const BYTE *pbEncryptedPassword,
IN WORD wEncryptedTokenRequestLength,
IN const BYTE *pbEncryptedTokenRequest,
IN DWORD cbResults,
OUT PASSPORT_SESSION_TOKEN *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XProfileClearTitle(
IN XUID qwUserId,
IN DWORD dwTitleId,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XProfileEnumAchievements(
IN DWORD dwTitleId,
IN XUID qwUserId,
IN ULONGLONG qwForPuid,
IN WORD wLocaleId,
IN WORD wStartingIndex,
IN WORD wMaxAchievements,
IN DWORD cbResults,
OUT XPROFILE_ENUM_ACHIEVEMENTS_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XProfileEnumTitles(
IN XUID qwUserId,
IN XUID qwForUserId,
IN WORD wLocaleId,
IN WORD wStartingIndex,
IN WORD wMaxTitles,
IN DWORD cbResults,
OUT XPROFILE_ENUM_TITLES_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XProfileReadOnlineSettings(
IN XUID qwUserId,
IN WORD wForUserIdsLen,
IN const ULONGLONG *pqwUserIds,
IN WORD wSettingIdsLen,
IN const DWORD *pdwSettingIds,
IN DWORD cbResults,
OUT XPROFILE_SETTING_READ_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XProfileSyncAchievements(
IN DWORD dwTitleId,
IN XUID qwUserId,
IN FILETIME ftVersion,
IN WORD wLocaleId,
IN WORD wStartingIndex,
IN WORD wAchievementCount,
IN const XPROFILE_ACHIEVEMENT_SYNC_REQUEST *pAchievements,
IN DWORD cbResults,
OUT XPROFILE_SYNC_ACHIEVEMENTS_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XProfileSyncOnlineSettings(
IN DWORD dwTitleId,
IN XUID qwUserId,
IN FILETIME ftVersion,
IN WORD wStartingIndex,
IN WORD wSettingsLen,
IN const XUSER_ONLINE_PROFILE_SETTING *pSettings,
IN DWORD cbMinRequest,
IN DWORD cbResults,
OUT XPROFILE_SETTING_SYNC_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
XBOXAPI
DWORD
WINAPI
_XProfileSyncTitles(
IN XUID qwUserId,
IN WORD wLocaleId,
IN WORD wStartingIndex,
IN FILETIME ftLastSync,
IN WORD wNumTitles,
IN const XPROFILE_TITLE *pTitles,
IN DWORD cbResults,
OUT XPROFILE_SYNC_TITLES_RESULT *pResults,
IN OUT OPTIONAL XOVERLAPPED *pXOverlapped
);
//
// Statistics
//
#define XUSER_STATS_SYSTEM_ATTRIBUTE_MASK 0x8000
#define XUSER_STATS_RANK ((WORD)0xFFFF)
#define XUSER_STATS_RATING ((WORD)0xFFFE)
#define XUSER_STATS_GAMERTAG ((WORD)0xFFFD)
#define XONLINE_STAT_COMPTYPE_EQUAL 1 // if the current stored stat value equals the specified value
#define XONLINE_STAT_COMPTYPE_GREATER 2 // if the current stored stat value is greater than the specified value
#define XONLINE_STAT_COMPTYPE_GREATER_OR_EQUAL 3 // if the current stored stat value is greater than or equal to the specified value
#define XONLINE_STAT_COMPTYPE_LESS 4 // if the current stored stat value is less than the specified value
#define XONLINE_STAT_COMPTYPE_LESS_OR_EQUAL 5 // if the current stored stat value is less than or equal to the specified value
#define XONLINE_STAT_COMPTYPE_EXISTS 6 // if the current stored stat value exists (specified value is ignored)
#define XONLINE_STAT_COMPTYPE_NOT_EXISTS 7 // if the current stored stat value does not exist (specified value is ignored)
#define XONLINE_STAT_COMPTYPE_NOT_EQUAL 8 // if the current stored stat value does not equal the specified value
#define XONLINE_STAT_PROCID_REPLACE 0x8001 // use XONLINE_STAT_UPDATE structure
#define XONLINE_STAT_PROCID_ADD 0x8003 // use XONLINE_STAT_UPDATE structure
#define XONLINE_STAT_PROCID_CONDITIONAL 0x8007 // use XONLINE_STAT_CONDITIONAL structure
#define XONLINE_STAT_PROCID_MIN 0x8009
#define XONLINE_STAT_PROCID_MAX 0x800B
#define XONLINE_STAT_PROCID_MUSIGMA 0x800D // use XONLINE_STAT_CONDITIONAL structure
// Internal helper functions
DWORD XOnlinepStatsPostMinRequestSize(WORD wNumProcs, const XSTAT_PROC *pProcs);
DWORD XOnlinepArbReportMinRequestSize(
int bReportLostMachines,
XARB_REPORT_LOST_MACHINES *pLostMachines,
int cSuspiciousInfo,
XARB_REPORT_SUSPICIOUS_INFO *pSuspiciousInfo,
int bSubmitStatsBundle,
XARB_REPORT_STATS_BUNDLE *pStatsBundle,
int bSubmitCompsBundle,
XARB_REPORT_BYTE_BUNDLE *pCompsBundle);
//
// Competitions
//
//
// Attribute IDs
//
#define XONLINE_QUERY_ENTITY_ID 0x80000000
#define XONLINE_QUERY_OWNER_PUID 0x80000001
#define XONLINE_COMP_ATTR_ID 0x80010000
#define XONLINE_COMP_ATTR_REG_OPEN 0x80010001
#define XONLINE_COMP_ATTR_REG_CLOSE 0x80010002
#define XONLINE_COMP_ATTR_COMP_START 0x80010003
#define XONLINE_COMP_ATTR_COMP_CLEANUP 0x80010004
#define XONLINE_COMP_ATTR_COMP_CLEANUP_DAYS 0x80010004
#define XONLINE_COMP_ATTR_ROUND_FREQUENCY 0x80010005
#define XONLINE_COMP_ATTR_ROUND_INTERVAL 0x80010006
#define XONLINE_COMP_ATTR_ROUND_DAY_MASK 0x80010007
#define XONLINE_COMP_ATTR_ROUNDS 0x80010008
#define XONLINE_COMP_ATTR_CURRENT_ROUND 0x80010009
#define XONLINE_COMP_ATTR_CURRENT_ROUND_START 0x8001000A
#define XONLINE_COMP_ATTR_CURRENT_ROUND_END 0x8001000B
#define XONLINE_COMP_ATTR_ROUND_DURATION_MIN 0x8001000B
#define XONLINE_COMP_ATTR_ROUND_ONE_START 0x8001000C
#define XONLINE_COMP_ATTR_ROUND_ONE_END 0x8001000D
#define XONLINE_COMP_ATTR_AUTOPROGRESS_DEADLINE 0x8001000F
#define XONLINE_COMP_ATTR_IS_TEAM_COMP 0x80010010
#define XONLINE_COMP_ATTR_TEAM_SIZE 0x80010011
#define XONLINE_COMP_ATTR_MAX_PUBLIC_SLOTS 0x80010012
#define XONLINE_COMP_ATTR_MAX_PRIVATE_SLOTS 0x80010013
#define XONLINE_COMP_ATTR_MIN_SLOTS 0x80010014
#define XONLINE_COMP_ATTR_BYES 0x80010016
#define XONLINE_COMP_ATTR_BYES_GRANTED 0x80010017
#define XONLINE_COMP_ATTR_PUBLIC_ENTRANTS 0x80010018
#define XONLINE_COMP_ATTR_PRIVATE_ENTRANTS 0x80010019
#define XONLINE_COMP_ATTR_REMINDER_MIN 0x8001001A
#define XONLINE_COMP_ATTR_PLAY_BEFORE_MIN 0x8001001B
#define XONLINE_COMP_ATTR_PLAY_AFTER_MIN 0x8001001C
#define XONLINE_COMP_ATTR_STATUS 0x8001001D
#define XONLINE_COMP_ATTR_ROUND0_LEADERBOARD_ID 0x80010020
#define XONLINE_COMP_ATTR_DEBUG_ADVANCE_TIME 0x80010023
#define XONLINE_COMP_ATTR_NAME 0x8011000E
#define XONLINE_COMP_ATTR_RESULTS 0x80210000
#define XONLINE_COMP_ATTR_ENTRANT_PUID 0x80020000
#define XONLINE_COMP_ATTR_ENTRANT_STATUS 0x80020001
#define XONLINE_COMP_ATTR_ENTRANT_TRUST 0x80020002
#define XONLINE_COMP_ATTR_ENTRANT_CURRENT_ROUND 0x80020003
#define XONLINE_COMP_ATTR_ENTRANT_PRIVATE_SLOT 0x80020004
#define XONLINE_COMP_ATTR_ENTRANT_SEED 0x80020005
#define XONLINE_COMP_ATTR_ENTRANT_ELIMINATED 0x80020006
#define XONLINE_COMP_ATTR_ENTRANT_CURRENT_EVENT 0x80020007
#define XONLINE_COMP_ATTR_ENTRANT_CURRENT_START 0x80020008
#define XONLINE_COMP_ATTR_ENTRANT_COMP_SORT 0x80020009
#define XONLINE_COMP_ATTR_ENTRANT_CURRENT_INDEX 0x8002000a
#define XONLINE_COMP_ATTR_ENTRANT_HRESULT 0x8002000b
#define XONLINE_COMP_ATTR_ENTRANT_SCORE 0x8002000c
#define XONLINE_COMP_ATTR_EVENT_ENTITY_ID 0x80030000
#define XONLINE_COMP_ATTR_EVENT_TOPOLOGY_ID 0x80030001
#define XONLINE_COMP_ATTR_EVENT_ROUND 0x80030002
#define XONLINE_COMP_ATTR_EVENT_START 0x80030003
#define XONLINE_COMP_ATTR_EVENT_NEXT_ENTITY 0x80030006
#define XONLINE_COMP_ATTR_EVENT_NEXT_START 0x80030007
#define XONLINE_COMP_ATTR_EVENT_P1 0x80030008
#define XONLINE_COMP_ATTR_EVENT_P1_GAMERTAG 0x81130008
#define XONLINE_COMP_ATTR_EVENT_P1_CHECKIN 0x80030009
#define XONLINE_COMP_ATTR_EVENT_P1_TRUST 0x8023000A
#define XONLINE_COMP_ATTR_EVENT_P2 0x8003000B
#define XONLINE_COMP_ATTR_EVENT_P2_GAMERTAG 0x8113000B
#define XONLINE_COMP_ATTR_EVENT_P2_CHECKIN 0x8003000C
#define XONLINE_COMP_ATTR_EVENT_P2_TRUST 0x8023000D
#define XONLINE_COMP_ATTR_EVENT_WINNER 0x8003000E
#define XONLINE_COMP_ATTR_EVENT_LOSER 0x8003000F
#define XONLINE_COMP_ATTR_EVENT_MIN 0x80030010
#define XONLINE_COMP_ATTR_EVENT_MAX 0x80030011
#define XONLINE_COMP_ATTR_BRACKET_ID 0x80040001
#define XONLINE_COMP_ATTR_BRACKET_SLOTS 0x80040002
#define XONLINE_COMP_ATTR_BRACKET_ENTRANTS 0x80040003
#define XONLINE_COMP_ATTR_BRACKET_BYES 0x80040004
#define XONLINE_COMP_ATTR_BRACKET_BYES_GRANTED 0x80040005
#define XONLINE_COMP_ATTR_BRACKET_ROUND_START 0x80040006
#define XONLINE_COMP_ATTR_BRACKET_END 0x80040008
#define XONLINE_COMP_ATTR_BRACKET_START 0x80040009
#define XONLINE_COMP_ATTR_BRACKET_STATUS 0x8004000A
#define XONLINE_COMP_ATTR_BRACKET_APD 0x8004000B
#define XONLINE_COMP_ATTR_BRACKET_LEADERBOARD 0x8004000C
#define XONLINE_COMP_ATTR_BRACKET_MIN_ROUND 0x820400F0
#define XONLINE_COMP_ATTR_BRACKET_MAX_ROUND 0x820400F1
//
// Competition status codes
//
#define XONLINE_COMP_STATUS_PRE_INIT 0
#define XONLINE_COMP_STATUS_ACTIVE 1
#define XONLINE_COMP_STATUS_COMPLETE 2
#define XONLINE_COMP_STATUS_CANCELED 0xFFFFFFFF
//
// Entrant status codes
//
#define XONLINE_COMP_STATUS_ENTRANT_REGISTERED 0
#define XONLINE_COMP_STATUS_ENTRANT_PLAYING 1
#define XONLINE_COMP_STATUS_ENTRANT_FORFEIT 2
#define XONLINE_COMP_STATUS_ENTRANT_PASS 4
#define XONLINE_COMP_STATUS_ENTRANT_FINAL 5
#define XONLINE_COMP_STATUS_ENTRANT_ELIMINATED 0xFFFFFFFF
//
// Multilevel constants
//
// Use this value for the Entity ID when calling XOnlineCompeitionSubmitResults for a multi-level competition
#define XONLINE_COMP_MULTILEVEL_ENTITY_ID 0xffffffff
//
// Multilevel bracket status Codes
//
#define XONLINE_COMP_STATUS_BRACKET_PRE_INIT 0
#define XONLINE_COMP_STATUS_BRACKET_CHECKIN 1
#define XONLINE_COMP_STATUS_BRACKET_IN_PROGRESS 2
#define XONLINE_COMP_STATUS_BRACKET_COMPLETE 3
#define XONLINE_COMP_STATUS_BRACKET_FINAL 4
//
// Multilevel entrant procs
//
#define XONLINE_COMP_ML_ENTRANTS_SEARCH_ONE 0x10001
#define XONLINE_COMP_ML_ENTRANTS_SEARCH_PUID 0x10001
#define XONLINE_COMP_ML_ENTRANTS_SEARCH_STATUS 0x10002
//
// Multilevel update procs
//
#define XONLINE_COMP_ML_ENTRANTS_UPDATE_ROUND 0x10001
#define XONLINE_COMP_ML_ENTRANTS_UPDATE_STATUS 0x10002
//
// Multilevel bracket procs
//
#define XONLINE_COMP_ML_BRACKET_SEARCH_ROUND 0x10001
#define XONLINE_COMP_ML_BRACKET_UPDATEID_SLOT_INFO 0x10001
//
// Action IDs
//
#define XONLINE_COMP_ACTION_JOIN 1
#define XONLINE_COMP_ACTION_JOIN_PRIVATE 2
#define XONLINE_COMP_ACTION_WITHDRAW 3
#define XONLINE_COMP_ACTION_CHECKIN 4
#define XONLINE_COMP_ACTION_REQUEST_BYE 5
#define XONLINE_COMP_ACTION_REQUEST_PASS 6
#define XONLINE_COMP_ACTION_SUBMIT_RESULTS 7
#define XONLINE_COMP_ACTION_FORFEIT 8
#define XONLINE_COMP_ACTION_CANCEL 9
#define XONLINE_COMP_ACTION_EJECT 10
#define XONLINE_COMP_ACTION_DEBUG_ADVANCE_TIME 99
//
// Limits
//
#define XONLINE_COMP_MAX_FREQUENCY 60
#define XONLINE_COMP_MIN_DURATION_MINS 5
#define XONLINE_COMP_MIN_JOB_DELAY 1
#define XONLINE_COMP_CHECKIN_WIN_SECS 5 * 60
#define XONLINE_COMP_MIN_CLEANUP_DAYS 1
#define XONLINE_COMP_MAX_CLEANUP_DAYS 365
#define XONLINE_COMP_DEFAULT_CLEANUP_DAYS 5
//
// Defined types of competition intervals
//
typedef enum
{
XONLINE_COMP_INTERVAL_MINUTE = 2,
XONLINE_COMP_INTERVAL_HOUR = 3,
XONLINE_COMP_INTERVAL_DAILY = 4,
XONLINE_COMP_INTERVAL_WEEKLY = 5
} XONLINE_COMP_INTERVAL_UNIT;
// Day mask data type
typedef DWORD XONLINE_COMP_DAY_MASK;
//
// Day Mask Constants
//
#define XONLINE_COMP_DAY_MASK_ALL 0x007F
#define XONLINE_COMP_DAY_MASK_SUNDAY 0x0001
#define XONLINE_COMP_DAY_MASK_MONDAY 0x0002
#define XONLINE_COMP_DAY_MASK_TUESDAY 0x0004
#define XONLINE_COMP_DAY_MASK_WEDNESDAY 0x0008
#define XONLINE_COMP_DAY_MASK_THURSDAY 0x0010
#define XONLINE_COMP_DAY_MASK_FRIDAY 0x0020
#define XONLINE_COMP_DAY_MASK_SATURDAY 0x0040
typedef union
{
DWORD dwUnitsOfTime;
XONLINE_COMP_DAY_MASK DayMask;
} XONLINE_COMP_UNITS_OR_MASK;
//
// User-friendly structure for Single Eliminations
//
typedef struct
{
DWORD dwPrivateSlots;
DWORD dwPublicSlots;
DWORD dwMinimumPlayers;
FILETIME ftRegistrationOpen;
FILETIME ftRegistrationClose;
FILETIME ftCompetitionStart;
FILETIME ftRoundOneStart;
FILETIME ftRoundOneEnd;
DWORD dwMatchReminderAdvanceMinutes;
XONLINE_COMP_INTERVAL_UNIT Interval;
XONLINE_COMP_UNITS_OR_MASK UnitOrMask; // Mask when Interval = Day, otherwise Units of time of type Interval
BOOL fTeamCompetition;
DWORD dwTeamSize;
} XONLINE_COMP_SINGLE_ELIMINATION_ATTRIBUTES;
typedef XONLINE_COMP_SINGLE_ELIMINATION_ATTRIBUTES *PXONLINE_COMP_SINGLE_ELIMINATION_ATTRIBUTES;
//
// Structure returning results for a created competition
//
typedef struct
{
ULONGLONG qwCompetitionID;
} XONLINE_COMP_CREATE_RESULTS;
typedef XONLINE_COMP_CREATE_RESULTS *PXONLINE_COMP_CREATE_RESULTS;
//
// Topology results structure
//
typedef struct
{
DWORD dwBaseWidth;
DWORD dwRoundsReturned;
DWORD dwTotalResultEntries;
DWORD dwResultsSize;
PBYTE pbResults;
DWORD dwNumResultAttributeSpecs;
PXONLINE_QUERY_ATTRIBUTE_SPEC pResultAttributeSpecs;
} XONLINE_COMP_TOPOLOGY_SE_RESULTS;
typedef XONLINE_COMP_TOPOLOGY_SE_RESULTS *PXONLINE_COMP_TOPOLOGY_SE_RESULTS;
#define TOPOLOGY_ID(roundNumber, eventNumber) (((roundNumber) << 16) + (eventNumber))
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionCreate(
XUID UserXuid,
DWORD dwTemplate,
ULONGLONG qwTeamID,
DWORD dwNumCompetitionAttributes,
XONLINE_QUERY_ATTRIBUTE *pCompetitionAttributes,
PXONLINE_COMP_CREATE_RESULTS *ppEntityId,
PXOVERLAPPED pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionCreateSingleElimination(
XUID UserXuid,
DWORD dwTemplate,
ULONGLONG qwTeamID,
const XONLINE_COMP_SINGLE_ELIMINATION_ATTRIBUTES *pDefaultAttributes,
DWORD dwNumAdditionalAttributes,
const XONLINE_QUERY_ATTRIBUTE *pAdditionalAttributes,
PXONLINE_COMP_CREATE_RESULTS *ppEntityId,
PXOVERLAPPED pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionSearch(
DWORD dwQueryID,
DWORD dwDatasetID,
DWORD dwPage,
DWORD dwResultsPerPage,
DWORD dwNumSearchAttributes,
XONLINE_QUERY_ATTRIBUTE *pSearchAttributes,
DWORD dwNumResultAttributeSpecs,
XONLINE_QUERY_ATTRIBUTE_SPEC *pResultAttributeSpecs,
PQUERY_SEARCH_RESULT *ppResults,
PXOVERLAPPED pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionManageEntrant(
DWORD dwAction,
XUID UserId,
DWORD dwDatasetID,
ULONGLONG qwTeamID,
ULONGLONG qwCompetitionID,
DWORD dwNumAttributes,
XONLINE_QUERY_ATTRIBUTE *pAttributes,
PVOID *ppvResults,
PXOVERLAPPED pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionCheckin(
XUID UserXuid,
DWORD dwDatasetID,
ULONGLONG qwTeamID,
ULONGLONG qwCompetitionID,
ULONGLONG qwEventID,
PVOID *ppvResults,
PXOVERLAPPED pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionCancel(
XUID UserXuid,
DWORD dwDatasetID,
ULONGLONG qwTeamID,
ULONGLONG qwCompetitionID,
PVOID *ppvResults,
PXOVERLAPPED pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionSubmitResults(
XUID UserId,
DWORD dwDatasetID,
ULONGLONG qwTeamId,
ULONGLONG qwCompetitionID,
ULONGLONG qwEventId,
XUID WinnerXuid,
XUID LoserXuid,
PVOID *ppvResults,
PXOVERLAPPED pXOverlapped
);
XBOXAPI
DWORD
WINAPI
XOnlineCompetitionTopology(
DWORD dwTemplate,
ULONGLONG qwCompetitionID,
DWORD dwPage,
DWORD dwResultsPerPage,
DWORD dwStartingEventTopologyID,
DWORD dwEndingEventTopologyID,
DWORD dwNumResultAttributeSpecs,
XONLINE_QUERY_ATTRIBUTE_SPEC *pResultAttributeSpecs,
PQUERY_SEARCH_RESULT *ppResults,
PXOVERLAPPED pXOverlapped
);
//
// Messaging
//
//DECLARE_HANDLE(XMSG_HANDLE);
//typedef XMSG_HANDLE* PXMSG_HANDLE;
//
// Message Flags
//
#define XONLINE_MSG_FLAG_REQUIRED 0x00000001 // The user is required to read this message
#define XONLINE_MSG_FLAG_RECOMMENDED 0x00000002 // The user has a system recommended message
#define XONLINE_MSG_FLAG_HAS_VOICE 0x00000004 // This message contains a voice attachment
#define XONLINE_MSG_FLAG_HAS_TEXT 0x00000008 // This message contains a text body
#define XONLINE_MSG_FLAG_READ 0x00000010 // This message has been read
#define XONLINE_MSG_FLAG_NON_EXPORTABLE 0x00000020 // This message should only be displayed on Xbox consoles, not the web
#define XONLINE_MSG_FLAG_TEAM_CONTEXT 0x00000040 // This message's sender context refers to a team ID
#define XONLINE_MSG_FLAG_COMP_CONTEXT 0x00000080 // This message's sender context refers to a competition event or entity ID
#define XONLINE_MSG_FLAG_ALTERNATE_TITLE 0x00000100 // This message is from an alternate Title of the currently logged on title (only available on Xbox consoles)
#define XONLINE_MSG_FLAG_MARKETING 0x00000200 // Used on title-sent messages to indicate the message is marketing-related and opt-in settings should be checked
#define XONLINE_MSG_FLAGS_TITLE_RESERVED 0xFF000000 // Flags reserved for title custom messages
#define XONLINE_MSG_FLAG_SENDER_IS_FRIEND 0x00800000 // Used by Notification to detect invites that should go to V1 clients, also used by clients to allow cross-title invites
#define XONLINE_MSG_FLAG_RECV_DETAILS_NEEDED 0x00200000 // Used by the client on received summaries to indicate that the title has requested downloading details
#define XONLINE_MSG_FLAG_SEND_MSG_OWNED 0x00200000 // Used by the client on message sends to indicate that the message handle is owned by the Send operation
#define XONLINE_MSG_FLAGS_RESERVED 0x005FFC00 // Flags reserved for future use
#define XONLINE_MSG_FLAGS_VALID_SEND_MASK ( XONLINE_MSG_FLAGS_TITLE_RESERVED | \
XONLINE_MSG_FLAG_NON_EXPORTABLE | \
XONLINE_MSG_FLAG_REQUIRED | \
XONLINE_MSG_FLAG_RECOMMENDED | \
XONLINE_MSG_FLAG_HAS_VOICE | \
XONLINE_MSG_FLAG_HAS_TEXT | \
XONLINE_MSG_FLAG_TEAM_CONTEXT | \
XONLINE_MSG_FLAG_COMP_CONTEXT | \
XONLINE_MSG_FLAG_MARKETING ) // Flags valid in a call to send a message
#define XONLINE_MSG_FLAGS_TITLE_SETABLE ( XONLINE_MSG_FLAG_READ | \
XONLINE_MSG_FLAGS_TITLE_RESERVED ) // Flags a title is allowed to set on an already sent message
#define XONLINE_MSG_FLAGS_TITLE_CLEARABLE ( XONLINE_MSG_FLAGS_TITLE_RESERVED ) // Flags a title is allowed to clear on an already sent message
//
// Message Property Types
//
#define XONLINE_MSG_PROP_TYPE_NULL ((BYTE) 1) // The property contains no data
#define XONLINE_MSG_PROP_TYPE_I1 ((BYTE) 2) // The property value points to 8-bits of data
#define XONLINE_MSG_PROP_TYPE_I2 ((BYTE) 3) // The property value points to 16-bits of data
#define XONLINE_MSG_PROP_TYPE_I4 ((BYTE) 4) // The property value points to 32-bits of data
#define XONLINE_MSG_PROP_TYPE_I8 ((BYTE) 5) // The property value points to 64-bits of data
#define XONLINE_MSG_PROP_TYPE_STRING ((BYTE) 6) // The property value points to a NULL-terminated wide character string
#define XONLINE_MSG_PROP_TYPE_FILETIME ((BYTE) 7) // The property value points to a time value
#define XONLINE_MSG_PROP_TYPE_BINARY ((BYTE) 8) // The property value points to a binary blob that fits in the message details
#define XONLINE_MSG_PROP_TYPE_ATTACHMENT ((BYTE) 9) // The property value points to a binary blob (or directory path, depending on attachment flags) that will be uploaded to storage during XOnlineMessageSend
#define XONLINE_MSG_PROP_TYPE_BOOL ((BYTE) 10) // The property value points to a boolean value (1=TRUE, 0=FALSE)
#define XONLINE_MSG_PROP_TYPE_STRING_ID ((BYTE) 11) // The property value contains a string ID whose text can be requested from the string service
//
// Attachment Flags
//
#define XONLINE_MSG_ATTACHMENT_FLAG_NON_EXPORTABLE 0x00000001 // This attachment should not be visible when the message is displayed on the web
#define XONLINE_MSG_ATTACHMENT_FLAG_DIRECTORY 0x00000002 // The property value points to an ANSI path string to a local directory that will be uploaded to storage, instead of a binary blob
#define XONLINE_MSG_ATTACHMENT_FLAGS_RESERVED 0xFFFFFFFC // Flags reserved for future use
//
// Message Property Tags
// Property tags occupy a word where the upper byte indicates the property's data type, and
// the lower byte indicates a unique identifier for the property. Property identifiers only
// need to be unique within a given message type.
//
#define XONLINE_MSG_PROP_TAG(type, id) ((BYTE)(type) << 8 | (BYTE)(id))
#define XOnlineMessageGetPropId(tag) (BYTE)((WORD)(tag) & 0xFF)
#define XOnlineMessageGetPropType(tag) (BYTE)((WORD)(tag) >> 8)
//
// Message Property IDs
// Property IDs should adhere to the following ranges:
//
// Range Purpose
// 0x00-0x7F Reserved for use by titles
// 0x80-0xBF Reserved for use by Microsoft for non-global properties
// 0xC0-0xFF Reserved for use by Microsoft for properties that span all message types
#define XONLINE_MSG_PROP_ID_BUILTIN 0x80 // Used for properties defined by Microsoft
#define XONLINE_MSG_PROP_ID_GLOBAL 0x40 // Used for properties that can span all message types
//
// Message IDs
//
#define XONLINE_MSG_ID_SEND_FAILED 0x80000000 // NOTE: This high bit must not be used so that send can use it to return failed HRESULTs
#define XONLINE_MSG_ID_SYSTEM_MESSAGE 0x40000000 // A message sent by the Live service or a publisher
#define XONLINE_MSG_ID_TRANSIENT_MESSAGE 0x20000000 // A special type of message that goes away when the sender goes offline
#define XONLINE_MSG_ID_BASE_MASK 0x00FFFFFF
#define XONLINE_MSG_ID_RESERVED_MASK 0x1F000000
#define IsMsgTransient( msgid ) ( ( msgid ) & XONLINE_MSG_ID_TRANSIENT_MESSAGE )
//
// Message Notifications (Internal)
//
#define XONLINE_MSG_NOTIFICATION_FLAG_SAME_TITLE 0x000001
#define XONLINE_MSG_NOTIFICATION_FLAG_SAME_PUBLISHER 0x000002
#define XONLINE_MSG_NOTIFICATION_FLAG_INVITE_FROM_FRIEND 0x000004
#define XONLINE_MSG_NOTIFICATION_FLAG_HAS_VOICE 0x000008
#define XONLINE_MSG_NOTIFICATION_FLAG_HAS_TEXT 0x000010
#define XONLINE_MSG_NOTIFICATION_FLAG_ALT_TITLE 0x000020
#define XONLINE_MSG_NOTIFICATION_FLAG_TITLE_RESERVED 0xFF0000
#define XONLINE_MSG_NOTIFICATION_FLAG_RESERVED 0x00FFC0
#pragma pack(push, 1)
struct Q_MESSAGE_NOTIFICATION
{
DWORD dwTypeAndFlags; // The upper byte is the message type
};
#define XOnlineMessageNotificationGetMsgType( dwTypeAndFlags ) (BYTE)( ( dwTypeAndFlags ) >> 24 )
#define XOnlineMessageNotificationGetFlags( dwTypeAndFlags ) (DWORD)( ( dwTypeAndFlags ) & 0x00FFFFFF )
typedef struct Q_MESSAGE_NOTIFICATION XONLINE_MESSAGE_NOTIFICATION;
#pragma pack(pop)
//
// Message Types
//
// A message type establishes the purpose of the message and the properties that
// are required for a message of that type.
//
#define XONLINE_MSG_TYPE_TITLE_CUSTOM ((BYTE) 1) // context: title defined; required props: title defined
#define XONLINE_MSG_TYPE_FRIEND_REQUEST ((BYTE) 2) // context: 0; required props: none
#define XONLINE_MSG_TYPE_GAME_INVITE ((BYTE) 3) // context: see msg flags; required props: XONLINE_MSG_PROP_SESSION_ID
#define XONLINE_MSG_TYPE_TEAM_RECRUIT ((BYTE) 4) // context: inviting team ID; required props: none
#define XONLINE_MSG_TYPE_COMP_REMINDER ((BYTE) 5) // context: comp event ID; required props: XONLINE_MSG_PROP_COMP_NAME, XONLINE_MSG_PROP_COMP_EVENT_START
#define XONLINE_MSG_TYPE_COMP_REQUEST ((BYTE) 6) // context: comp entity ID; required props: XONLINE_MSG_PROP_COMP_NAME, XONLINE_MSG_PROP_COMP_START, XONLINE_MSG_PROP_COMP_REG_CLOSE
#define XONLINE_MSG_TYPE_LIVE_MESSAGE ((BYTE) 7) // context: 0 required props: XONLINE_MSG_PROP_SYSTEM_TEXT
#define XONLINE_MSG_TYPE_PERSONAL_MESSAGE ((BYTE) 8) // context: 0 required props: XONLINE_MSG_PROP_TEXT, XONLINE_MSG_PROP_VOICE_DATA.
#define XONLINE_MSG_TYPE_VIDEO_MESSAGE ((BYTE) 9) // context: 0 required props: XONLINE_MSG_PROP_TEXT, XONLINE_MSG_PROP_VIDEO_DATA
#define XONLINE_MSG_TYPE_QUICK_CHAT_INVITE ((BYTE) 10) // context: 0
//
// Global property tags, allowed in any message type
//
// All message types can contain a voice attachment specified in the following properties. All three
// of the following properties should be specified together. The XONLINE_MSG_FLAG_HAS_VOICE message
// flag can be used to test for the presence of these properties before the message details have been
// retrieved.
#define XONLINE_MSG_PROP_VOICE_DATA XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_ATTACHMENT, XONLINE_MSG_PROP_ID_GLOBAL | XONLINE_MSG_PROP_ID_BUILTIN | 1)
#define XONLINE_MSG_PROP_VOICE_DATA_CODEC XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_GLOBAL | XONLINE_MSG_PROP_ID_BUILTIN | 2)
#define XONLINE_MSG_PROP_VOICE_DATA_DURATION XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I4, XONLINE_MSG_PROP_ID_GLOBAL | XONLINE_MSG_PROP_ID_BUILTIN | 3)
// All message types can contain a text summary specified in the following properties. Both
// of the following properties should be specified together. The XONLINE_MSG_FLAG_HAS_TEXT message
// flag can be used to test for the presence of these properties before the message details have been
// retrieved. The text should be 256 characters or less and may be used by Live anywhere that a text
// summary of the message is useful, such as in a Messenger Alert, on the web, or in the Dashboard.
#define XONLINE_MSG_PROP_TEXT XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING, XONLINE_MSG_PROP_ID_GLOBAL | XONLINE_MSG_PROP_ID_BUILTIN | 4)
#define XONLINE_MSG_PROP_TEXT_LANGUAGE XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I4, XONLINE_MSG_PROP_ID_GLOBAL | XONLINE_MSG_PROP_ID_BUILTIN | 5)
//
//Video Message Properties
//
#define XONLINE_MSG_PROP_VIDEO_FRAME_DATA XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_ATTACHMENT, XONLINE_MSG_PROP_ID_BUILTIN | 1)
#define XONLINE_MSG_PROP_VIDEO_FRAME_CODEC XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 2) //This defines the First Frame of the Video as JPG, BMP...etc if we wanted to show the First Frame of the Video in the HUD.
#define XONLINE_MSG_PROP_VIDEO_DATA XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_ATTACHMENT, XONLINE_MSG_PROP_ID_BUILTIN | 3)
#define XONLINE_MSG_PROP_VIDEO_DATA_CODEC XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 4)
#define XONLINE_MSG_PROP_VIDEO_DATA_DURATION XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I4, XONLINE_MSG_PROP_ID_BUILTIN | 5)
//
// Invite message properties
//
#define XONLINE_MSG_PROP_SESSION_ID XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I8, XONLINE_MSG_PROP_ID_BUILTIN | 1)
#define XONLINE_MSG_PROP_SESSION_DESCRIPTION XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING, XONLINE_MSG_PROP_ID_BUILTIN | 2)
#define XONLINE_MSG_PROP_SESSION_HOST_XNADDR XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_BINARY, XONLINE_MSG_PROP_ID_BUILTIN | 3)
#define XONLINE_MSG_PROP_SESSION_HOST_KEY XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_BINARY, XONLINE_MSG_PROP_ID_BUILTIN | 4)
//
// Live system message properties
//
#define XONLINE_MSG_PROP_SYSTEM_TEXT XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING_ID, XONLINE_MSG_PROP_ID_BUILTIN | 1)
//
// Team Recruit message properties
//
#define XONLINE_MSG_PROP_TEAM_NAME XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING, XONLINE_MSG_PROP_ID_BUILTIN | 1)
//
// Competitions message properties
//
#define XONLINE_MSG_PROP_COMP_DATASET XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I4, XONLINE_MSG_PROP_ID_BUILTIN | 0x1 )
#define XONLINE_MSG_PROP_COMP_NAME XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING, XONLINE_MSG_PROP_ID_BUILTIN | 0x2 )
#define XONLINE_MSG_PROP_COMP_START XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_FILETIME, XONLINE_MSG_PROP_ID_BUILTIN | 0x3 )
#define XONLINE_MSG_PROP_COMP_ROUND XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 0x4 )
#define XONLINE_MSG_PROP_COMP_OPPONENT XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING_ID, XONLINE_MSG_PROP_ID_BUILTIN | 0x5 )
#define XONLINE_MSG_PROP_COMP_ADMIN XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I8, XONLINE_MSG_PROP_ID_BUILTIN | 0x6 )
#define XONLINE_MSG_PROP_COMP_REG_CLOSE XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_FILETIME, XONLINE_MSG_PROP_ID_BUILTIN | 0x7 )
#define XONLINE_MSG_PROP_COMP_PRIVATE_SLOTS XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 0x8 )
#define XONLINE_MSG_PROP_COMP_PUBLIC_SLOTS XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 0x9 )
#define XONLINE_MSG_PROP_COMP_UNITS XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 0xA )
#define XONLINE_MSG_PROP_COMP_INTERVAL XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 0xB )
#define XONLINE_MSG_PROP_COMP_DAYMASK XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 0xC )
#define XONLINE_MSG_PROP_COMP_DESCRIPTION XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING, XONLINE_MSG_PROP_ID_BUILTIN | 0xD )
#define XONLINE_MSG_PROP_COMP_URL XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING, XONLINE_MSG_PROP_ID_BUILTIN | 0xE )
#define XONLINE_MSG_PROP_COMP_EVENT_ID XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I8, XONLINE_MSG_PROP_ID_BUILTIN | 0x10 )
#define XONLINE_MSG_PROP_COMP_EVENT_START XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_FILETIME, XONLINE_MSG_PROP_ID_BUILTIN | 0x11 )
//
// HUD message properties. These properties act the same as game invite
// properties. This is so that some day they may be merged.
//
#define XONLINE_HUD_MSG_PROP_SESSION_ID XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I8, XONLINE_MSG_PROP_ID_BUILTIN | 1)
#define XONLINE_HUD_MSG_PROP_SESSION_DESCRIPTION XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_STRING, XONLINE_MSG_PROP_ID_BUILTIN | 2)
#define XONLINE_HUD_MSG_PROP_SESSION_HOST_XNADDR XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_BINARY, XONLINE_MSG_PROP_ID_BUILTIN | 3)
#define XONLINE_HUD_MSG_PROP_SESSION_HOST_KEY XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_BINARY, XONLINE_MSG_PROP_ID_BUILTIN | 4)
#define XONLINE_HUD_MSG_PROP_VOICECHAT_PORT XONLINE_MSG_PROP_TAG(XONLINE_MSG_PROP_TYPE_I2, XONLINE_MSG_PROP_ID_BUILTIN | 5)
//
// Voice Codec types (values for XONLINE_MSG_PROP_VOICE_DATA_CODEC)
//
#define XONLINE_PROP_VOICE_DATA_CODEC_WMAVOICE_V90 1
#define XONLINE_PROP_VOICE_DATA_CODEC_SASE3200 2
// Write to the global settings rather than title-specific settings.
// We use the Dash titleid for mysteries having to do with xbox.com.
#define XPROFILE_TITLEID_GLOBAL_SETTINGS XENON_DASH_TITLE_ID
// Values for the stored Profile: User State
typedef enum _XPROFILE_GAMER_PRESENCE_USER_STATE_VALUE
{
XPROFILE_GAMER_PRESENCE_USER_STATE_VALUE_ONLINE = 0,
XPROFILE_GAMER_PRESENCE_USER_STATE_VALUE_AWAY,
XPROFILE_GAMER_PRESENCE_USER_STATE_VALUE_BUSY,
XPROFILE_GAMER_PRESENCE_USER_STATE_VALUE_APPEAROFFLINE
} XPROFILE_GAMER_PRESENCE_USER_STATE_VALUE;
typedef struct
{
XOVERLAPPED* pXOverlapped;
DWORD dwTitleId; // A title in your family or 0 for the current title
DWORD dwUserIndex; // User index of the requesting user
DWORD dwNumFor; // Number of users (indexes or XUIDs) whose setings are read
const XUID* pxuidFor; // Pointer to array of XUIDs to request settings for
DWORD dwNumSettingIds; // Number of settings in pSettingIds
const DWORD* pSettingIds; // Settings to retrieve for list of users
DWORD cbResults;
PXUSER_READ_PROFILE_SETTING_RESULT pResults;
} XGI_READSETTINGS_MSG;
typedef struct
{
XOVERLAPPED* pXOverlapped;
DWORD dwTitleId;
DWORD dwUserIndex; // User index of the player whose settings are written
DWORD dwNumSettings; // Number of settings in pSettings
const XUSER_PROFILE_SETTING* pSettings; // Settings to set
} XGI_WRITESETTINGS_MSG;
//-----------------------------------------------------------------------------
// XBOS API structs
//-----------------------------------------------------------------------------
typedef struct
{
DWORD dwUserIndex;
DWORD dwTitleId;
DWORD dwContentCategories;
XOFFERING_CONTENTAVAILABLE_RESULT *pResults;
} LIVEBASE_CONTENTAVAILABLE_MSG;
//-----------------------------------------------------------------------------
// XM_LIVEBASE_PRESENCESET message structures
//-----------------------------------------------------------------------------
typedef struct
{
DWORD dwContextId;
DWORD dwContextValue;
} PRESENCE_CONTEXT;
typedef struct
{
DWORD dwPropertyId; // Includes type; use XPROPERTYTYPEFROMID
DWORD cbData; // Count of bytes in pbData
// BYTE pbData; // Property value starts here
// Strings and binary are prefixed with a WORD length.
// Strings are wide chars (UTF-16) and are not NULL-terminated.
} PRESENCE_PROPERTY;
// This is the maximum total number of bytes for contexts and properties
// that LiveBase will accept, cache and send up to the servers.
#define MAX_LIVEBASE_PRESENCE 256
typedef struct
{
XUID xuidUser; // UserID
DWORD dwPresenceMode; // The value of the presence mode context (X_CONTEXT_PRESENCE)
DWORD dwNumContexts; // Number PRESENCE_CONTEXTs at beginning of rgbPayload
DWORD dwNumProperties; // Number PRESENCE_PROPERTY after contexts in rgbPayload
BYTE rgbPayload[MAX_LIVEBASE_PRESENCE];
} LIVEBASE_SETPRESENCE_MSG;
#ifdef __cplusplus
}
#endif
#endif // __XONLINEP__