MickSlash
/
goldberg_emulator
mirror of https://gitlab.com/Mr_Goldberg/goldberg_emulator.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Compare commits

base: MickSlash:714904b9843025036648b87f22d045f7ce1a1e97
Branches Tags
MickSlash:master
MickSlash:test_ci
MickSlash:inventory_pr
MickSlash:0.2.5
MickSlash:v0.2.4
MickSlash:v0.2.3
MickSlash:v0.2.2
..
compare: MickSlash:3b3dc98b3a997c2b6344ea2aca2d5d66f665b799
Branches Tags
MickSlash:master
MickSlash:test_ci
MickSlash:inventory_pr
MickSlash:0.2.5
MickSlash:v0.2.4
MickSlash:v0.2.3
MickSlash:v0.2.2

No commits in common. "714904b9843025036648b87f22d045f7ce1a1e97" and "3b3dc98b3a997c2b6344ea2aca2d5d66f665b799" have entirely different histories.
714904b984 ... 3b3dc98b3a

18 changed files with 211 additions and 538 deletions
Show Stats Expand all files Collapse all files

21
detours/creatwth.cpp
View File

@ -7,15 +7,34 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
//
#if _MSC_VER >= 1900
#pragma warning(push)
#pragma warning(disable:4091) // empty typedef
#endif
#define _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS 1
#define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1
#include <windows.h>
#include <stddef.h>
#pragma warning(push)
#if _MSC_VER > 1400
#pragma warning(disable:6102 6103) // /analyze warnings
#endif
#include <strsafe.h>
#pragma warning(pop)
// #define DETOUR_DEBUG 1
#define DETOURS_INTERNAL
#include "detours.h"
#include <stddef.h>
#if DETOURS_VERSION != 0x4c0c1 // 0xMAJORcMINORcPATCH
#error detours.h version mismatch
#endif
#if _MSC_VER >= 1900
#pragma warning(pop)
#endif
#define IMPORT_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]
#define BOUND_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT]
#define CLR_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR]

203
detours/detours.cpp
View File

@ -7,15 +7,33 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
//
#pragma warning(disable:4068) // unknown pragma (suppress)
#if _MSC_VER >= 1900
#pragma warning(push)
#pragma warning(disable:4091) // empty typedef
#endif
#define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1
#include <windows.h>
#if (_MSC_VER < 1299)
#pragma warning(disable: 4710)
#endif
//#define DETOUR_DEBUG 1
#define DETOURS_INTERNAL
#include "detours.h"
#if DETOURS_VERSION != 0x4c0c1 // 0xMAJORcMINORcPATCH
#error detours.h version mismatch
#endif
#if _MSC_VER >= 1900
#pragma warning(pop)
#endif
#define NOTHROW
//////////////////////////////////////////////////////////////////////////////
@ -862,8 +880,7 @@ struct _DETOUR_TRAMPOLINE
{
// An ARM64 instruction is 4 bytes long.
//
// The overwrite is always composed of 3 instructions (12 bytes) which perform an indirect jump
// using _DETOUR_TRAMPOLINE::pbDetour as the address holding the target location.
// The overwrite is always 2 instructions plus a literal, so 16 bytes, 4 instructions.
//
// Copied instructions can expand.
//
@ -898,7 +915,7 @@ struct _DETOUR_TRAMPOLINE
C_ASSERT(sizeof(_DETOUR_TRAMPOLINE) == 184);
enum {
SIZE_OF_JMP = 12
SIZE_OF_JMP = 16
};
inline ULONG fetch_opcode(PBYTE pbCode)
@ -912,79 +929,6 @@ inline void write_opcode(PBYTE &pbCode, ULONG Opcode)
pbCode += 4;
}
struct ARM64_INDIRECT_JMP {
struct {
ULONG Rd : 5;
ULONG immhi : 19;
ULONG iop : 5;
ULONG immlo : 2;
ULONG op : 1;
} ardp;
struct {
ULONG Rt : 5;
ULONG Rn : 5;
ULONG imm : 12;
ULONG opc : 2;
ULONG iop1 : 2;
ULONG V : 1;
ULONG iop2 : 3;
ULONG size : 2;
} ldr;
ULONG br;
};
#pragma warning(push)
#pragma warning(disable:4201)
union ARM64_INDIRECT_IMM {
struct {
ULONG64 pad : 12;
ULONG64 adrp_immlo : 2;
ULONG64 adrp_immhi : 19;
};
LONG64 value;
};
#pragma warning(pop)
PBYTE detour_gen_jmp_indirect(BYTE *pbCode, ULONG64 *pbJmpVal)
{
// adrp x17, [jmpval]
// ldr x17, [x17, jmpval]
// br x17
struct ARM64_INDIRECT_JMP *pIndJmp;
union ARM64_INDIRECT_IMM jmpIndAddr;
jmpIndAddr.value = (((LONG64)pbJmpVal) & 0xFFFFFFFFFFFFF000) -
(((LONG64)pbCode) & 0xFFFFFFFFFFFFF000);
pIndJmp = (struct ARM64_INDIRECT_JMP *)pbCode;
pbCode = (BYTE *)(pIndJmp + 1);
pIndJmp->ardp.Rd = 17;
pIndJmp->ardp.immhi = jmpIndAddr.adrp_immhi;
pIndJmp->ardp.iop = 0x10;
pIndJmp->ardp.immlo = jmpIndAddr.adrp_immlo;
pIndJmp->ardp.op = 1;
pIndJmp->ldr.Rt = 17;
pIndJmp->ldr.Rn = 17;
pIndJmp->ldr.imm = (((ULONG64)pbJmpVal) & 0xFFF) / 8;
pIndJmp->ldr.opc = 1;
pIndJmp->ldr.iop1 = 1;
pIndJmp->ldr.V = 0;
pIndJmp->ldr.iop2 = 7;
pIndJmp->ldr.size = 3;
pIndJmp->br = 0xD61F0220;
return pbCode;
}
PBYTE detour_gen_jmp_immediate(PBYTE pbCode, PBYTE *ppPool, PBYTE pbJmpVal)
{
PBYTE pbLiteral;
@ -1051,7 +995,7 @@ inline PBYTE detour_skip_jmp(PBYTE pbCode, PVOID *ppGlobals)
the bottom 12 bits cleared to zero, and then writes the result to a general-purpose register. This permits the
calculation of the address at a 4KB aligned memory region. In conjunction with an ADD (immediate) instruction, or
a Load/Store instruction with a 12-bit immediate offset, this allows for the calculation of, or access to, any address
within +/- 4GB of the current PC.
within ±4GB of the current PC.
PC-rel. addressing
This section describes the encoding of the PC-rel. addressing instruction class. The encodings in this section are
@ -1118,10 +1062,7 @@ inline void detour_find_jmp_bounds(PBYTE pbCode,
PDETOUR_TRAMPOLINE *ppLower,
PDETOUR_TRAMPOLINE *ppUpper)
{
// The encoding used by detour_gen_jmp_indirect actually enables a
// displacement of +/- 4GiB. In the future, this could be changed to
// reflect that. For now, just reuse the x86 logic which is plenty.
// We have to place trampolines within +/- 2GB of code.
ULONG_PTR lo = detour_2gb_below((ULONG_PTR)pbCode);
ULONG_PTR hi = detour_2gb_above((ULONG_PTR)pbCode);
DETOUR_TRACE(("[%p..%p..%p]\n", lo, pbCode, hi));
@ -1309,65 +1250,6 @@ static PVOID detour_alloc_region_from_hi(PBYTE pbLo, PBYTE pbHi)
return NULL;
}
static PVOID detour_alloc_trampoline_allocate_new(PBYTE pbTarget,
PDETOUR_TRAMPOLINE pLo,
PDETOUR_TRAMPOLINE pHi)
{
PVOID pbTry = NULL;
// NB: We must always also start the search at an offset from pbTarget
// in order to maintain ASLR entropy.
#if defined(DETOURS_64BIT)
// Try looking 1GB below or lower.
if (pbTry == NULL && pbTarget > (PBYTE)0x40000000) {
pbTry = detour_alloc_region_from_hi((PBYTE)pLo, pbTarget - 0x40000000);
}
// Try looking 1GB above or higher.
if (pbTry == NULL && pbTarget < (PBYTE)0xffffffff40000000) {
pbTry = detour_alloc_region_from_lo(pbTarget + 0x40000000, (PBYTE)pHi);
}
// Try looking 1GB below or higher.
if (pbTry == NULL && pbTarget > (PBYTE)0x40000000) {
pbTry = detour_alloc_region_from_lo(pbTarget - 0x40000000, pbTarget);
}
// Try looking 1GB above or lower.
if (pbTry == NULL && pbTarget < (PBYTE)0xffffffff40000000) {
pbTry = detour_alloc_region_from_hi(pbTarget, pbTarget + 0x40000000);
}
#endif
// Try anything below.
if (pbTry == NULL) {
pbTry = detour_alloc_region_from_hi((PBYTE)pLo, pbTarget);
}
// try anything above.
if (pbTry == NULL) {
pbTry = detour_alloc_region_from_lo(pbTarget, (PBYTE)pHi);
}
return pbTry;
}
PVOID WINAPI DetourAllocateRegionWithinJumpBounds(_In_ LPCVOID pbTarget,
_Out_ PDWORD pcbAllocatedSize)
{
PDETOUR_TRAMPOLINE pLo;
PDETOUR_TRAMPOLINE pHi;
detour_find_jmp_bounds((PBYTE)pbTarget, &pLo, &pHi);
PVOID pbNewlyAllocated =
detour_alloc_trampoline_allocate_new((PBYTE)pbTarget, pLo, pHi);
if (pbNewlyAllocated == NULL) {
DETOUR_TRACE(("Couldn't find available memory region!\n"));
*pcbAllocatedSize = 0;
return NULL;
}
*pcbAllocatedSize = DETOUR_REGION_SIZE;
return pbNewlyAllocated;
}
static PDETOUR_TRAMPOLINE detour_alloc_trampoline(PBYTE pbTarget)
{
// We have to place trampolines within +/- 2GB of target.
@ -1412,10 +1294,41 @@ static PDETOUR_TRAMPOLINE detour_alloc_trampoline(PBYTE pbTarget)
// Round pbTarget down to 64KB block.
pbTarget = pbTarget - (PtrToUlong(pbTarget) & 0xffff);
PVOID pbNewlyAllocated =
detour_alloc_trampoline_allocate_new(pbTarget, pLo, pHi);
if (pbNewlyAllocated != NULL) {
s_pRegion = (DETOUR_REGION*)pbNewlyAllocated;
PVOID pbTry = NULL;
// NB: We must always also start the search at an offset from pbTarget
// in order to maintain ASLR entropy.
#if defined(DETOURS_64BIT)
// Try looking 1GB below or lower.
if (pbTry == NULL && pbTarget > (PBYTE)0x40000000) {
pbTry = detour_alloc_region_from_hi((PBYTE)pLo, pbTarget - 0x40000000);
}
// Try looking 1GB above or higher.
if (pbTry == NULL && pbTarget < (PBYTE)0xffffffff40000000) {
pbTry = detour_alloc_region_from_lo(pbTarget + 0x40000000, (PBYTE)pHi);
}
// Try looking 1GB below or higher.
if (pbTry == NULL && pbTarget > (PBYTE)0x40000000) {
pbTry = detour_alloc_region_from_lo(pbTarget - 0x40000000, pbTarget);
}
// Try looking 1GB above or lower.
if (pbTry == NULL && pbTarget < (PBYTE)0xffffffff40000000) {
pbTry = detour_alloc_region_from_hi(pbTarget, pbTarget + 0x40000000);
}
#endif
// Try anything below.
if (pbTry == NULL) {
pbTry = detour_alloc_region_from_hi((PBYTE)pLo, pbTarget);
}
// try anything above.
if (pbTry == NULL) {
pbTry = detour_alloc_region_from_lo(pbTarget, (PBYTE)pHi);
}
if (pbTry != NULL) {
s_pRegion = (DETOUR_REGION*)pbTry;
s_pRegion->dwSignature = DETOUR_REGION_SIGNATURE;
s_pRegion->pFree = NULL;
s_pRegion->pNext = s_pRegions;
@ -1742,7 +1655,7 @@ LONG WINAPI DetourTransactionCommitEx(_Out_opt_ PVOID **pppFailedPointer)
#endif // DETOURS_ARM
#ifdef DETOURS_ARM64
PBYTE pbCode = detour_gen_jmp_indirect(o->pbTarget, (ULONG64*)&(o->pTrampoline->pbDetour));
PBYTE pbCode = detour_gen_jmp_immediate(o->pbTarget, NULL, o->pTrampoline->pbDetour);
pbCode = detour_gen_brk(pbCode, o->pTrampoline->pbRemain);
*o->ppbPointer = o->pTrampoline->rbCode;
UNREFERENCED_PARAMETER(pbCode);

47
detours/detours.h
View File

@ -16,34 +16,6 @@
//////////////////////////////////////////////////////////////////////////////
//
#ifdef DETOURS_INTERNAL
#define _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS 1
#define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1
#pragma warning(disable:4068) // unknown pragma (suppress)
#if _MSC_VER >= 1900
#pragma warning(push)
#pragma warning(disable:4091) // empty typedef
#endif
#include <windows.h>
#if (_MSC_VER < 1310)
#else
#pragma warning(push)
#if _MSC_VER > 1400
#pragma warning(disable:6102 6103) // /analyze warnings
#endif
#include <strsafe.h>
#pragma warning(pop)
#endif
#endif // DETOURS_INTERNAL
//////////////////////////////////////////////////////////////////////////////
//
#undef DETOURS_X64
#undef DETOURS_X86
#undef DETOURS_IA64
@ -89,12 +61,7 @@
//#define DETOURS_OPTION_BITS 32
#endif
/////////////////////////////////////////////////////////////// Helper Macros.
//
#define DETOURS_STRINGIFY_(x) #x
#define DETOURS_STRINGIFY(x) DETOURS_STRINGIFY_(x)
#define VER_DETOURS_BITS DETOURS_STRINGIFY(DETOURS_BITS)
#define VER_DETOURS_BITS DETOUR_STRINGIFY(DETOURS_BITS)
//////////////////////////////////////////////////////////////////////////////
//
@ -420,6 +387,7 @@ typedef struct _DETOUR_EXE_RESTORE
#ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC // some environments do not have this
BYTE raw[sizeof(IMAGE_NT_HEADERS64) +
sizeof(IMAGE_SECTION_HEADER) * 32];
C_ASSERT(sizeof(IMAGE_NT_HEADERS64) == 0x108);
#else
BYTE raw[0x108 + sizeof(IMAGE_SECTION_HEADER) * 32];
#endif
@ -428,10 +396,6 @@ typedef struct _DETOUR_EXE_RESTORE
} DETOUR_EXE_RESTORE, *PDETOUR_EXE_RESTORE;
#ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC
C_ASSERT(sizeof(IMAGE_NT_HEADERS64) == 0x108);
#endif
// The size can change, but assert for clarity due to the muddying #ifdefs.
#ifdef _WIN64
C_ASSERT(sizeof(DETOUR_EXE_RESTORE) == 0x688);
@ -467,6 +431,11 @@ typedef struct _DETOUR_EXE_HELPER
0,\
}
/////////////////////////////////////////////////////////////// Helper Macros.
//
#define DETOURS_STRINGIFY(x) DETOURS_STRINGIFY_(x)
#define DETOURS_STRINGIFY_(x) #x
///////////////////////////////////////////////////////////// Binary Typedefs.
//
typedef BOOL (CALLBACK *PF_DETOUR_BINARY_BYWAY_CALLBACK)(
@ -554,8 +523,6 @@ PVOID WINAPI DetourCopyInstruction(_In_opt_ PVOID pDst,
_Out_opt_ LONG *plExtra);
BOOL WINAPI DetourSetCodeModule(_In_ HMODULE hModule,
_In_ BOOL fLimitReferencesToModule);
PVOID WINAPI DetourAllocateRegionWithinJumpBounds(_In_ LPCVOID pbTarget,
_Out_ PDWORD pcbAllocatedSize);
///////////////////////////////////////////////////// Loaded Binary Functions.
//

4
detours/detver.h
View File

@ -14,8 +14,8 @@
#include <detours.h>
#else
#ifndef DETOURS_STRINGIFY
#define DETOURS_STRINGIFY_(x) #x
#define DETOURS_STRINGIFY(x) DETOURS_STRINGIFY_(x)
#define DETOURS_STRINGIFY_(x) #x
#endif
#define VER_FILEFLAGSMASK 0x3fL
@ -24,4 +24,4 @@
#define VER_FILETYPE 0x00000002L
#define VER_FILESUBTYPE 0x00000000L
#endif
#define VER_DETOURS_BITS DETOURS_STRINGIFY(DETOURS_BITS)
#define VER_DETOURS_BITS DETOUR_STRINGIFY(DETOURS_BITS)

143
detours/disasm.cpp
View File

@ -7,15 +7,28 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
//
#if _MSC_VER >= 1900
#pragma warning(push)
#pragma warning(disable:4091) // empty typedef
#endif
#define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1
#include <windows.h>
#include <limits.h>
// #define DETOUR_DEBUG 1
#define DETOURS_INTERNAL
#include "detours.h"
#include <limits.h>
#if DETOURS_VERSION != 0x4c0c1 // 0xMAJORcMINORcPATCH
#error detours.h version mismatch
#endif
#if _MSC_VER >= 1900
#pragma warning(pop)
#endif
#undef ASSERT
#define ASSERT(x)
@ -247,11 +260,6 @@ class CDetourDis
#define ENTRY_CopyFF ENTRY_DataIgnored &CDetourDis::CopyFF
#define ENTRY_CopyVex2 ENTRY_DataIgnored &CDetourDis::CopyVex2
#define ENTRY_CopyVex3 ENTRY_DataIgnored &CDetourDis::CopyVex3
#define ENTRY_CopyEvex ENTRY_DataIgnored &CDetourDis::CopyEvex // 62, 3 byte payload, then normal with implied prefixes like vex
#define ENTRY_CopyXop ENTRY_DataIgnored &CDetourDis::CopyXop // 0x8F ... POP /0 or AMD XOP
#define ENTRY_CopyBytesXop 5, 5, 4, 0, 0, &CDetourDis::CopyBytes // 0x8F xop1 xop2 opcode modrm
#define ENTRY_CopyBytesXop1 6, 6, 4, 0, 0, &CDetourDis::CopyBytes // 0x8F xop1 xop2 opcode modrm ... imm8
#define ENTRY_CopyBytesXop4 9, 9, 4, 0, 0, &CDetourDis::CopyBytes // 0x8F xop1 xop2 opcode modrm ... imm32
#define ENTRY_Invalid ENTRY_DataIgnored &CDetourDis::Invalid
#define ENTRY_End ENTRY_DataIgnored NULL
@ -281,9 +289,6 @@ class CDetourDis
PBYTE CopyVex2(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc);
PBYTE CopyVex3(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc);
PBYTE CopyVexCommon(BYTE m, PBYTE pbDst, PBYTE pbSrc);
PBYTE CopyVexEvexCommon(BYTE m, PBYTE pbDst, PBYTE pbSrc, BYTE p);
PBYTE CopyEvex(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc);
PBYTE CopyXop(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc);
protected:
static const COPYENTRY s_rceCopyTable[257];
@ -298,7 +303,6 @@ class CDetourDis
BOOL m_bAddressOverride;
BOOL m_bRaxOverride; // AMD64 only
BOOL m_bVex;
BOOL m_bEvex;
BOOL m_bF2;
BOOL m_bF3; // x86 only
BYTE m_nSegmentOverride;
@ -333,7 +337,6 @@ CDetourDis::CDetourDis(_Out_opt_ PBYTE *ppbTarget, _Out_opt_ LONG *plExtra)
m_bF2 = FALSE;
m_bF3 = FALSE;
m_bVex = FALSE;
m_bEvex = FALSE;
m_ppbTarget = ppbTarget ? ppbTarget : &m_pbScratchTarget;
m_plExtra = plExtra ? plExtra : &m_lScratchExtra;
@ -365,11 +368,8 @@ PBYTE CDetourDis::CopyBytes(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc)
{
UINT nBytesFixed;
if (m_bVex || m_bEvex)
{
ASSERT(pEntry->nFlagBits == 0);
ASSERT(pEntry->nFixedSize == pEntry->nFixedSize16);
}
ASSERT(!m_bVex || pEntry->nFlagBits == 0);
ASSERT(!m_bVex || pEntry->nFixedSize == pEntry->nFixedSize16);
UINT const nModOffset = pEntry->nModOffset;
UINT const nFlagBits = pEntry->nFlagBits;
@ -748,42 +748,33 @@ PBYTE CDetourDis::CopyFF(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc)
return pbOut;
}
PBYTE CDetourDis::CopyVexEvexCommon(BYTE m, PBYTE pbDst, PBYTE pbSrc, BYTE p)
PBYTE CDetourDis::CopyVexCommon(BYTE m, PBYTE pbDst, PBYTE pbSrc)
// m is first instead of last in the hopes of pbDst/pbSrc being
// passed along efficiently in the registers they were already in.
{
static const COPYENTRY ceF38 = { 0x38, ENTRY_CopyBytes2Mod };
static const COPYENTRY ceF3A = { 0x3A, ENTRY_CopyBytes2Mod1 };
static const COPYENTRY ceInvalid = { 0xC4, ENTRY_Invalid };
static const COPYENTRY Invalid = { 0xC4, ENTRY_Invalid };
switch (p & 3) {
m_bVex = TRUE;
REFCOPYENTRY pEntry;
switch (m) {
default: pEntry = &Invalid; break;
case 1: pEntry = &s_rceCopyTable0F[pbSrc[0]]; break;
case 2: pEntry = &ceF38; break;
case 3: pEntry = &ceF3A; break;
}
switch (pbSrc[-1] & 3) { // p in last byte
case 0: break;
case 1: m_bOperandOverride = TRUE; break;
case 2: m_bF3 = TRUE; break;
case 3: m_bF2 = TRUE; break;
}
REFCOPYENTRY pEntry;
switch (m) {
default: return Invalid(&ceInvalid, pbDst, pbSrc);
case 1: pEntry = &s_rceCopyTable0F[pbSrc[0]];
return (this->*pEntry->pfCopy)(pEntry, pbDst, pbSrc);
case 2: return CopyBytes(&ceF38, pbDst, pbSrc);
case 3: return CopyBytes(&ceF3A, pbDst, pbSrc);
}
}
PBYTE CDetourDis::CopyVexCommon(BYTE m, PBYTE pbDst, PBYTE pbSrc)
// m is first instead of last in the hopes of pbDst/pbSrc being
// passed along efficiently in the registers they were already in.
{
m_bVex = TRUE;
BYTE const p = (BYTE)(pbSrc[-1] & 3); // p in last byte
return CopyVexEvexCommon(m, pbDst, pbSrc, p);
}
PBYTE CDetourDis::CopyVex3(REFCOPYENTRY, PBYTE pbDst, PBYTE pbSrc)
// 3 byte VEX prefix 0xC4
{
@ -844,78 +835,6 @@ PBYTE CDetourDis::CopyVex2(REFCOPYENTRY, PBYTE pbDst, PBYTE pbSrc)
return CopyVexCommon(1, pbDst + 2, pbSrc + 2);
}
PBYTE CDetourDis::CopyEvex(REFCOPYENTRY, PBYTE pbDst, PBYTE pbSrc)
// 62, 3 byte payload, x86 with implied prefixes like Vex
// for 32bit, mode 0xC0 else fallback to bound /r
{
// NOTE: Intel and Wikipedia number these differently.
// Intel says 0-2, Wikipedia says 1-3.
BYTE const p0 = pbSrc[1];
#ifdef DETOURS_X86
const static COPYENTRY ceBound = { 0x62, ENTRY_CopyBytes2Mod };
if ((p0 & 0xC0) != 0xC0) {
return CopyBytes(&ceBound, pbDst, pbSrc);
}
#endif
static const COPYENTRY ceInvalid = { 0x62, ENTRY_Invalid };
if ((p0 & 0x0C) != 0)
return Invalid(&ceInvalid, pbDst, pbSrc);
BYTE const p1 = pbSrc[2];
if ((p1 & 0x04) != 0x04)
return Invalid(&ceInvalid, pbDst, pbSrc);
// Copy 4 byte prefix.
*(UNALIGNED ULONG *)pbDst = *(UNALIGNED ULONG*)pbSrc;
m_bEvex = TRUE;
#ifdef DETOURS_X64
m_bRaxOverride |= !!(p1 & 0x80); // w
#endif
return CopyVexEvexCommon(p0 & 3u, pbDst + 4, pbSrc + 4, p1 & 3u);
}
PBYTE CDetourDis::CopyXop(REFCOPYENTRY, PBYTE pbDst, PBYTE pbSrc)
/* 3 byte AMD XOP prefix 0x8F
byte0: 0x8F
byte1: RXBmmmmm
byte2: WvvvvLpp
byte3: opcode
mmmmm >= 8, else pop
mmmmm only otherwise defined for 8, 9, A.
pp is like VEX but only instructions with 0 are defined
*/
{
const static COPYENTRY cePop = { 0x8F, ENTRY_CopyBytes2Mod };
const static COPYENTRY ceXop = { 0x8F, ENTRY_CopyBytesXop };
const static COPYENTRY ceXop1 = { 0x8F, ENTRY_CopyBytesXop1 };
const static COPYENTRY ceXop4 = { 0x8F, ENTRY_CopyBytesXop4 };
BYTE const m = (BYTE)(pbSrc[1] & 0x1F);
ASSERT(m <= 10);
switch (m)
{
default:
return CopyBytes(&cePop, pbDst, pbSrc);
case 8: // modrm with 8bit immediate
return CopyBytes(&ceXop1, pbDst, pbSrc);
case 9: // modrm with no immediate
return CopyBytes(&ceXop, pbDst, pbSrc);
case 10: // modrm with 32bit immediate
return CopyBytes(&ceXop4, pbDst, pbSrc);
}
}
//////////////////////////////////////////////////////////////////////////////
//
PBYTE CDetourDis::s_pbModuleBeg = NULL;
@ -1111,11 +1030,11 @@ const CDetourDis::COPYENTRY CDetourDis::s_rceCopyTable[257] =
#ifdef DETOURS_X64
{ 0x60, ENTRY_Invalid }, // Invalid
{ 0x61, ENTRY_Invalid }, // Invalid
{ 0x62, ENTRY_CopyEvex }, // EVEX / AVX512
{ 0x62, ENTRY_Invalid }, // Invalid (not yet implemented Intel EVEX support)
#else
{ 0x60, ENTRY_CopyBytes1 }, // PUSHAD
{ 0x61, ENTRY_CopyBytes1 }, // POPAD
{ 0x62, ENTRY_CopyEvex }, // BOUND /r and EVEX / AVX512
{ 0x62, ENTRY_CopyBytes2Mod }, // BOUND /r
#endif
{ 0x63, ENTRY_CopyBytes2Mod }, // 32bit ARPL /r, 64bit MOVSXD
{ 0x64, ENTRY_CopyBytesSegment }, // FS prefix
@ -1165,7 +1084,7 @@ const CDetourDis::COPYENTRY CDetourDis::s_rceCopyTable[257] =
{ 0x8C, ENTRY_CopyBytes2Mod }, // MOV /r
{ 0x8D, ENTRY_CopyBytes2Mod }, // LEA /r
{ 0x8E, ENTRY_CopyBytes2Mod }, // MOV /r
{ 0x8F, ENTRY_CopyXop }, // POP /0 or AMD XOP
{ 0x8F, ENTRY_CopyBytes2Mod }, // POP /0
{ 0x90, ENTRY_CopyBytes1 }, // NOP
{ 0x91, ENTRY_CopyBytes1 }, // XCHG
{ 0x92, ENTRY_CopyBytes1 }, // XCHG

35
detours/image.cpp
View File

@ -9,18 +9,39 @@
// Used for for payloads, byways, and imports.
//
#if _MSC_VER < 1299
#if _MSC_VER >= 1900
#pragma warning(push)
#pragma warning(disable:4091) // empty typedef
#endif
#define _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS 1
#define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1
#include <windows.h>
#if _MSC_VER >= 1310
#pragma warning(push)
#if _MSC_VER > 1400
#pragma warning(disable:6102 6103) // /analyze warnings
#endif
#include <strsafe.h>
#pragma warning(pop)
#endif
#if (_MSC_VER < 1299)
#pragma warning(disable: 4710)
#endif
// #define DETOUR_DEBUG 1
#define DETOURS_INTERNAL
#include "detours.h"
#if DETOURS_VERSION != 0x4c0c1 // 0xMAJORcMINORcPATCH
#error detours.h version mismatch
#endif
#if _MSC_VER >= 1900
#pragma warning(pop)
#endif
namespace Detour
{
//////////////////////////////////////////////////////////////////////////////
@ -1693,13 +1714,17 @@ BOOL CImage::Write(HANDLE hFile)
m_nNextFileAddr = Max(m_SectionHeaders[n].PointerToRawData +
m_SectionHeaders[n].SizeOfRawData,
m_nNextFileAddr);
// Old images have VirtualSize == 0 as a matter of course, e.g. NT 3.1.
// In which case, use SizeOfRawData instead.
#if 0
m_nNextVirtAddr = Max(m_SectionHeaders[n].VirtualAddress +
m_SectionHeaders[n].Misc.VirtualSize,
m_nNextVirtAddr);
#else
m_nNextVirtAddr = Max(m_SectionHeaders[n].VirtualAddress +
(m_SectionHeaders[n].Misc.VirtualSize
? m_SectionHeaders[n].Misc.VirtualSize
: SectionAlign(m_SectionHeaders[n].SizeOfRawData)),
m_nNextVirtAddr);
#endif
m_nExtraOffset = Max(m_nNextFileAddr, m_nExtraOffset);
@ -1832,7 +1857,7 @@ BOOL CImage::Write(HANDLE hFile)
for (CImageImportFile *pImportFile = m_pImportFiles;
pImportFile != NULL; pImportFile = pImportFile->m_pNextFile) {
ZeroMemory(piidDst, sizeof(*piidDst));
ZeroMemory(piidDst, sizeof(piidDst));
nameTable.Allocate(pImportFile->m_pszName, (DWORD *)&piidDst->Name);
piidDst->TimeDateStamp = 0;
piidDst->ForwarderChain = pImportFile->m_nForwarderChain;
@ -1874,7 +1899,7 @@ BOOL CImage::Write(HANDLE hFile)
}
piidDst++;
}
ZeroMemory(piidDst, sizeof(*piidDst));
ZeroMemory(piidDst, sizeof(piidDst));
//////////////////////////////////////////////////////////////////////////
//

29
detours/modules.cpp
View File

@ -9,6 +9,27 @@
// Module enumeration functions.
//
#define _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS 1
#pragma warning(disable:4068) // unknown pragma (suppress)
#if _MSC_VER >= 1900
#pragma warning(push)
#pragma warning(disable:4091) // empty typedef
#endif
#define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1
#include <windows.h>
#if (_MSC_VER < 1310)
#else
#pragma warning(push)
#if _MSC_VER > 1400
#pragma warning(disable:6102 6103) // /analyze warnings
#endif
#include <strsafe.h>
#pragma warning(pop)
#endif
// #define DETOUR_DEBUG 1
#define DETOURS_INTERNAL
#include "detours.h"
@ -17,6 +38,10 @@
#error detours.h version mismatch
#endif
#if _MSC_VER >= 1900
#pragma warning(pop)
#endif
#define CLR_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR]
#define IAT_DIRECTORY OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IAT]
@ -139,8 +164,8 @@ PDETOUR_SYM_INFO DetourLoadImageHlp(VOID)
return pSymInfo;
}
PVOID WINAPI DetourFindFunction(_In_ LPCSTR pszModule,
_In_ LPCSTR pszFunction)
PVOID WINAPI DetourFindFunction(_In_ PCSTR pszModule,
_In_ PCSTR pszFunction)
{
/////////////////////////////////////////////// First, try GetProcAddress.
//

1
dll/base.h
View File

@ -42,6 +42,7 @@
#if defined(__WINDOWS__)
#define STEAM_WIN32
#pragma warning( disable : 4716)
#ifndef NOMINMAX
# define NOMINMAX
#endif

20
dll/dll.cpp
View File

@ -1016,67 +1016,56 @@ STEAMCLIENT_API void Breakpad_SteamWriteMiniDumpUsingExceptionInfoWithBuildId( i
STEAMCLIENT_API bool Steam_BConnected( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return true;
}
STEAMCLIENT_API bool Steam_BLoggedOn( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return true;
}
STEAMCLIENT_API bool Steam_BReleaseSteamPipe( HSteamPipe hSteamPipe )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API HSteamUser Steam_ConnectToGlobalUser( HSteamPipe hSteamPipe )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return 0;
}
STEAMCLIENT_API HSteamUser Steam_CreateGlobalUser( HSteamPipe *phSteamPipe )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return 0;
}
STEAMCLIENT_API HSteamUser Steam_CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return 0;
}
STEAMCLIENT_API HSteamPipe Steam_CreateSteamPipe()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return 0;
}
STEAMCLIENT_API bool Steam_GSBLoggedOn( void *phSteamHandle )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API bool Steam_GSBSecure( void *phSteamHandle)
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API bool Steam_GSGetSteam2GetEncryptionKeyToSendToNewClient( void *phSteamHandle, void *pvEncryptionKey, uint32 *pcbEncryptionKey, uint32 cbMaxEncryptionKey )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API uint64 Steam_GSGetSteamID()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return 0;
}
STEAMCLIENT_API void Steam_GSLogOff( void *phSteamHandle )
@ -1092,37 +1081,31 @@ STEAMCLIENT_API void Steam_GSLogOn( void *phSteamHandle )
STEAMCLIENT_API bool Steam_GSRemoveUserConnect( void *phSteamHandle, uint32 unUserID )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API bool Steam_GSSendSteam2UserConnect( void *phSteamHandle, uint32 unUserID, const void *pvRawKey, uint32 unKeyLen, uint32 unIPPublic, uint16 usPort, const void *pvCookie, uint32 cubCookie )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API bool Steam_GSSendSteam3UserConnect( void *phSteamHandle, uint64 steamID, uint32 unIPPublic, const void *pvCookie, uint32 cubCookie )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API bool Steam_GSSendUserDisconnect( void *phSteamHandle, uint64 ulSteamID, uint32 unUserID )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API bool Steam_GSSendUserStatusResponse( void *phSteamHandle, uint64 ulSteamID, int nSecondsConnected, int nSecondsSinceLast )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API bool Steam_GSSetServerType( void *phSteamHandle, int32 nAppIdServed, uint32 unServerFlags, uint32 unGameIP, uint32 unGamePort, const char *pchGameDir, const char *pchVersion )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API void Steam_GSSetSpawnCount( void *phSteamHandle, uint32 ucSpawn )
@ -1133,19 +1116,16 @@ STEAMCLIENT_API void Steam_GSSetSpawnCount( void *phSteamHandle, uint32 ucSpawn
STEAMCLIENT_API bool Steam_GSUpdateStatus( void *phSteamHandle, int cPlayers, int cPlayersMax, int cBotPlayers, const char *pchServerName, const char *pchMapName )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
}
STEAMCLIENT_API void* Steam_GetGSHandle( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return NULL;
}
STEAMCLIENT_API int Steam_InitiateGameConnection( HSteamUser hUser, HSteamPipe hSteamPipe, void *pBlob, int cbMaxBlob, uint64 steamID, int nGameAppID, uint32 unIPServer, uint16 usPortServer, bool bSecure )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return 0;
}
STEAMCLIENT_API void Steam_LogOff( HSteamUser hUser, HSteamPipe hSteamPipe )

5
dll/steam_applist.cpp
View File

@ -20,32 +20,27 @@
uint32 Steam_Applist::GetNumInstalledApps()
{
PRINT_DEBUG("Steam_Applist::GetNumInstalledApps\n");
return 0;
}
uint32 Steam_Applist::GetInstalledApps( AppId_t *pvecAppID, uint32 unMaxAppIDs )
{
PRINT_DEBUG("Steam_Applist::GetInstalledApps\n");
return 0;
}
// returns -1 if no name was found
int Steam_Applist::GetAppName( AppId_t nAppID, STEAM_OUT_STRING() char *pchName, int cchNameMax )
{
PRINT_DEBUG("Steam_Applist::GetAppName\n");
return -1;
}
// returns -1 if no dir was found
int Steam_Applist::GetAppInstallDir( AppId_t nAppID, char *pchDirectory, int cchNameMax )
{
PRINT_DEBUG("Steam_Applist::GetAppInstallDir\n");
return -1;
}
// return the buildid of this app, may change at any time based on backend updates to the game
int Steam_Applist::GetAppBuildId( AppId_t nAppID )
{
PRINT_DEBUG("Steam_Applist::GetAppBuildId\n");
return 10;
}

14
dll/steam_gamesearch.h
View File

@ -71,7 +71,6 @@ Steam_Game_Search(class Settings *settings, class Networking *network, class Ste
EGameSearchErrorCode_t AddGameSearchParams( const char *pchKeyToFind, const char *pchValuesToFind )
{
PRINT_DEBUG("Steam_Game_Search::AddGameSearchParams\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -81,7 +80,6 @@ EGameSearchErrorCode_t AddGameSearchParams( const char *pchKeyToFind, const char
EGameSearchErrorCode_t SearchForGameWithLobby( CSteamID steamIDLobby, int nPlayerMin, int nPlayerMax )
{
PRINT_DEBUG("Steam_Game_Search::SearchForGameWithLobby\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -90,7 +88,6 @@ EGameSearchErrorCode_t SearchForGameWithLobby( CSteamID steamIDLobby, int nPlaye
EGameSearchErrorCode_t SearchForGameSolo( int nPlayerMin, int nPlayerMax )
{
PRINT_DEBUG("Steam_Game_Search::SearchForGameSolo\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -99,13 +96,11 @@ EGameSearchErrorCode_t SearchForGameSolo( int nPlayerMin, int nPlayerMax )
EGameSearchErrorCode_t AcceptGame()
{
PRINT_DEBUG("Steam_Game_Search::AcceptGame\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
EGameSearchErrorCode_t DeclineGame()
{
PRINT_DEBUG("Steam_Game_Search::DeclineGame\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -113,7 +108,6 @@ EGameSearchErrorCode_t DeclineGame()
EGameSearchErrorCode_t RetrieveConnectionDetails( CSteamID steamIDHost, char *pchConnectionDetails, int cubConnectionDetails )
{
PRINT_DEBUG("Steam_Game_Search::RetrieveConnectionDetails\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -121,7 +115,6 @@ EGameSearchErrorCode_t RetrieveConnectionDetails( CSteamID steamIDHost, char *pc
EGameSearchErrorCode_t EndGameSearch()
{
PRINT_DEBUG("Steam_Game_Search::EndGameSearch\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -132,7 +125,6 @@ EGameSearchErrorCode_t EndGameSearch()
EGameSearchErrorCode_t SetGameHostParams( const char *pchKey, const char *pchValue )
{
PRINT_DEBUG("Steam_Game_Search::SetGameHostParams\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -140,7 +132,6 @@ EGameSearchErrorCode_t SetGameHostParams( const char *pchKey, const char *pchVal
EGameSearchErrorCode_t SetConnectionDetails( const char *pchConnectionDetails, int cubConnectionDetails )
{
PRINT_DEBUG("Steam_Game_Search::SetConnectionDetails\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -152,7 +143,6 @@ EGameSearchErrorCode_t SetConnectionDetails( const char *pchConnectionDetails, i
EGameSearchErrorCode_t RequestPlayersForGame( int nPlayerMin, int nPlayerMax, int nMaxTeamSize )
{
PRINT_DEBUG("Steam_Game_Search::RequestPlayersForGame\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -162,7 +152,6 @@ EGameSearchErrorCode_t RequestPlayersForGame( int nPlayerMin, int nPlayerMax, in
EGameSearchErrorCode_t HostConfirmGameStart( uint64 ullUniqueGameID )
{
PRINT_DEBUG("Steam_Game_Search::HostConfirmGameStart\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -171,7 +160,6 @@ EGameSearchErrorCode_t HostConfirmGameStart( uint64 ullUniqueGameID )
EGameSearchErrorCode_t CancelRequestPlayersForGame()
{
PRINT_DEBUG("Steam_Game_Search::CancelRequestPlayersForGame\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -179,7 +167,6 @@ EGameSearchErrorCode_t CancelRequestPlayersForGame()
EGameSearchErrorCode_t SubmitPlayerResult( uint64 ullUniqueGameID, CSteamID steamIDPlayer, EPlayerResult_t EPlayerResult )
{
PRINT_DEBUG("Steam_Game_Search::SubmitPlayerResult\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
@ -188,7 +175,6 @@ EGameSearchErrorCode_t SubmitPlayerResult( uint64 ullUniqueGameID, CSteamID stea
EGameSearchErrorCode_t EndGame( uint64 ullUniqueGameID )
{
PRINT_DEBUG("Steam_Game_Search::EndGame\n");
return k_EGameSearchErrorCode_Failed_Offline;
}
void RunCallbacks()

17
dll/steam_inventory.h
View File

@ -441,7 +441,6 @@ bool DeserializeResult( SteamInventoryResult_t *pOutResultHandle, STEAM_BUFFER_C
bool GenerateItems( SteamInventoryResult_t *pResultHandle, STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength )
{
PRINT_DEBUG("GenerateItems\n");
return false;
}
@ -481,7 +480,6 @@ STEAM_METHOD_DESC(ConsumeItem() removes items from the inventory permanently.)
bool ConsumeItem( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemConsume, uint32 unQuantity )
{
PRINT_DEBUG("ConsumeItem\n");
return false;
}
@ -498,7 +496,6 @@ bool ExchangeItems( SteamInventoryResult_t *pResultHandle,
STEAM_ARRAY_COUNT(unArrayDestroyLength) const SteamItemInstanceID_t *pArrayDestroy, STEAM_ARRAY_COUNT(unArrayDestroyLength) const uint32 *punArrayDestroyQuantity, uint32 unArrayDestroyLength )
{
PRINT_DEBUG("ExchangeItems\n");
return false;
}
@ -510,7 +507,6 @@ bool ExchangeItems( SteamInventoryResult_t *pResultHandle,
bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest )
{
PRINT_DEBUG("TransferItemQuantity\n");
return false;
}
@ -538,7 +534,7 @@ void SendItemDropHeartbeat()
STEAM_METHOD_DESC(Playtime credit must be consumed and turned into item drops by your game.)
bool TriggerItemDrop( SteamInventoryResult_t *pResultHandle, SteamItemDef_t dropListDefinition )
{
PRINT_DEBUG("TriggerItemDrop %p %i\n", pResultHandle, dropListDefinition);
PRINT_DEBUG("TriggerItemDrop\n");
//TODO: if gameserver return false
return true;
}
@ -729,7 +725,6 @@ STEAM_CALL_RESULT( SteamInventoryEligiblePromoItemDefIDs_t )
SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID )
{
PRINT_DEBUG("RequestEligiblePromoItemDefinitionsIDs\n");
return 0;
}
@ -742,7 +737,6 @@ bool GetEligiblePromoItemDefinitionIDs(
STEAM_DESC(Size of array is passed in and actual size used is returned in this param) uint32 *punItemDefIDsArraySize )
{
PRINT_DEBUG("GetEligiblePromoItemDefinitionIDs\n");
return false;
}
@ -755,7 +749,6 @@ STEAM_CALL_RESULT( SteamInventoryStartPurchaseResult_t )
SteamAPICall_t StartPurchase( STEAM_ARRAY_COUNT(unArrayLength) const SteamItemDef_t *pArrayItemDefs, STEAM_ARRAY_COUNT(unArrayLength) const uint32 *punArrayQuantity, uint32 unArrayLength )
{
PRINT_DEBUG("StartPurchase\n");
return 0;
}
@ -800,7 +793,6 @@ bool GetItemsWithPrices( STEAM_ARRAY_COUNT(unArrayLength) STEAM_OUT_ARRAY_COUNT(
bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pCurrentPrice, uint64 *pBasePrice )
{
PRINT_DEBUG("GetItemPrice\n");
return false;
}
// Retrieves the price for the item definition id
@ -816,46 +808,39 @@ bool GetItemPrice( SteamItemDef_t iDefinition, uint64 *pPrice )
SteamInventoryUpdateHandle_t StartUpdateProperties()
{
PRINT_DEBUG("StartUpdateProperties\n");
return 0;
}
// Remove the property on the item
bool RemoveProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName )
{
PRINT_DEBUG("RemoveProperty\n");
return false;
}
// Accessor methods to set properties on items
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, const char *pchPropertyValue )
{
PRINT_DEBUG("SetProperty\n");
return false;
}
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, bool bValue )
{
PRINT_DEBUG("SetProperty\n");
return false;
}
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, int64 nValue )
{
PRINT_DEBUG("SetProperty\n");
return false;
}
bool SetProperty( SteamInventoryUpdateHandle_t handle, SteamItemInstanceID_t nItemID, const char *pchPropertyName, float flValue )
{
PRINT_DEBUG("SetProperty\n");
return false;
}
// Submit the update request by handle
bool SubmitUpdateProperties( SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle )
{
PRINT_DEBUG("SubmitUpdateProperties\n");
return false;
}
void RunCallbacks()

96
dll/steam_musicremote.cpp
View File

@ -20,203 +20,171 @@
// Service Definition
bool Steam_MusicRemote::RegisterSteamMusicRemote( const char *pchName )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("RegisterSteamMusicRemote\n");
}
bool Steam_MusicRemote::DeregisterSteamMusicRemote()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("DeregisterSteamMusicRemote\n");
}
bool Steam_MusicRemote::BIsCurrentMusicRemote()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("BIsCurrentMusicRemote\n");
}
bool Steam_MusicRemote::BActivationSuccess( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("BActivationSuccess\n");
}
bool Steam_MusicRemote::SetDisplayName( const char *pchDisplayName )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("SetDisplayName\n");
}
bool Steam_MusicRemote::SetPNGIcon_64x64( void *pvBuffer, uint32 cbBufferLength )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("SetPNGIcon_64x64\n");
}
// Abilities for the user interface
bool Steam_MusicRemote::EnablePlayPrevious(bool bValue)
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("EnablePlayPrevious\n");
}
bool Steam_MusicRemote::EnablePlayNext( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("EnablePlayNext\n");
}
bool Steam_MusicRemote::EnableShuffled( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("EnableShuffled\n");
}
bool Steam_MusicRemote::EnableLooped( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("EnableLooped\n");
}
bool Steam_MusicRemote::EnableQueue( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("EnableQueue\n");
}
bool Steam_MusicRemote::EnablePlaylists( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("EnablePlaylists\n");
}
// Status
bool Steam_MusicRemote::UpdatePlaybackStatus( AudioPlayback_Status nStatus )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("UpdatePlaybackStatus\n");
}
bool Steam_MusicRemote::UpdateShuffled( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("UpdateShuffled\n");
}
bool Steam_MusicRemote::UpdateLooped( bool bValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("UpdateLooped\n");
}
bool Steam_MusicRemote::UpdateVolume( float flValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("UpdateVolume\n");
}
// volume is between 0.0 and 1.0
// Current Entry
bool Steam_MusicRemote::CurrentEntryWillChange()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("CurrentEntryWillChange\n");
}
bool Steam_MusicRemote::CurrentEntryIsAvailable( bool bAvailable )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("CurrentEntryIsAvailable\n");
}
bool Steam_MusicRemote::UpdateCurrentEntryText( const char *pchText )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("UpdateCurrentEntryText\n");
}
bool Steam_MusicRemote::UpdateCurrentEntryElapsedSeconds( int nValue )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("UpdateCurrentEntryElapsedSeconds\n");
}
bool Steam_MusicRemote::UpdateCurrentEntryCoverArt( void *pvBuffer, uint32 cbBufferLength )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("UpdateCurrentEntryCoverArt\n");
}
bool Steam_MusicRemote::CurrentEntryDidChange()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("CurrentEntryDidChange\n");
}
// Queue
bool Steam_MusicRemote::QueueWillChange()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("QueueWillChange\n");
}
bool Steam_MusicRemote::ResetQueueEntries()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("ResetQueueEntries\n");
}
bool Steam_MusicRemote::SetQueueEntry( int nID, int nPosition, const char *pchEntryText )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("SetQueueEntry\n");
}
bool Steam_MusicRemote::SetCurrentQueueEntry( int nID )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("SetCurrentQueueEntry\n");
}
bool Steam_MusicRemote::QueueDidChange()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("QueueDidChange\n");
}
// Playlist
bool Steam_MusicRemote::PlaylistWillChange()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("PlaylistWillChange\n");
}
bool Steam_MusicRemote::ResetPlaylistEntries()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("ResetPlaylistEntries\n");
}
bool Steam_MusicRemote::SetPlaylistEntry( int nID, int nPosition, const char *pchEntryText )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("SetPlaylistEntry\n");
}
bool Steam_MusicRemote::SetCurrentPlaylistEntry( int nID )
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("SetCurrentPlaylistEntry\n");
}
bool Steam_MusicRemote::PlaylistDidChange()
{
PRINT_DEBUG("%s\n", __FUNCTION__);
return false;
PRINT_DEBUG("PlaylistDidChange\n");
}

46
dll/steam_networking_sockets.h
View File

@ -242,13 +242,11 @@ HSteamListenSocket CreateListenSocket( int nSteamConnectVirtualPort, uint32 nIP,
HSteamListenSocket CreateListenSocketIP( const SteamNetworkingIPAddr &localAddress )
{
PRINT_DEBUG("Steam_Networking_Sockets::CreateListenSocketIP old\n");
return k_HSteamListenSocket_Invalid;
}
HSteamListenSocket CreateListenSocketIP( const SteamNetworkingIPAddr &localAddress, int nOptions, const SteamNetworkingConfigValue_t *pOptions )
{
PRINT_DEBUG("Steam_Networking_Sockets::CreateListenSocketIP\n");
return k_HSteamListenSocket_Invalid;
}
/// Creates a connection and begins talking to a "server" over UDP at the
@ -272,13 +270,11 @@ HSteamListenSocket CreateListenSocketIP( const SteamNetworkingIPAddr &localAddre
HSteamNetConnection ConnectByIPAddress( const SteamNetworkingIPAddr &address )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectByIPAddress old\n");
return k_HSteamNetConnection_Invalid;
}
HSteamNetConnection ConnectByIPAddress( const SteamNetworkingIPAddr &address, int nOptions, const SteamNetworkingConfigValue_t *pOptions )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectByIPAddress\n");
return k_HSteamNetConnection_Invalid;
}
/// Like CreateListenSocketIP, but clients will connect using ConnectP2P
@ -358,14 +354,12 @@ HSteamNetConnection ConnectP2P( const SteamNetworkingIdentity &identityRemote, i
HSteamNetConnection ConnectBySteamID( CSteamID steamIDTarget, int nVirtualPort )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectBySteamID\n");
return k_HSteamNetConnection_Invalid;
}
//#endif
HSteamNetConnection ConnectByIPv4Address( uint32 nIP, uint16 nPort )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectByIPv4Address\n");
return k_HSteamNetConnection_Invalid;
}
@ -477,7 +471,6 @@ bool CloseConnection( HSteamNetConnection hPeer, int nReason, const char *pszDeb
bool CloseListenSocket( HSteamListenSocket hSocket, const char *pszNotifyRemoteReason )
{
PRINT_DEBUG("Steam_Networking_Sockets::CloseListenSocket old\n");
return false;
}
/// Destroy a listen socket. All the connections that were accepting on the listen
@ -545,7 +538,6 @@ void SetConnectionName( HSteamNetConnection hPeer, const char *pszName )
bool GetConnectionName( HSteamNetConnection hPeer, char *pszName, int nMaxLen )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionName\n");
return false;
}
@ -576,7 +568,6 @@ bool GetConnectionName( HSteamNetConnection hPeer, char *pszName, int nMaxLen )
EResult SendMessageToConnection( HSteamNetConnection hConn, const void *pData, uint32 cbData, ESteamNetworkingSendType eSendType )
{
PRINT_DEBUG("Steam_Networking_Sockets::SendMessageToConnection old\n");
return k_EResultFail;
}
/// Send a message to the remote host on the specified connection.
@ -696,7 +687,6 @@ void SendMessages( int nMessages, SteamNetworkingMessage_t *const *pMessages, in
EResult FlushMessagesOnConnection( HSteamNetConnection hConn )
{
PRINT_DEBUG("Steam_Networking_Sockets::FlushMessagesOnConnection\n");
return k_EResultOK;
}
static void free_steam_message_data(SteamNetworkingMessage_t *pMsg)
@ -801,7 +791,6 @@ int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, SteamNetworkingMe
bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionInfo\n");
return false;
}
@ -824,7 +813,6 @@ bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pIn
int ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessage001_t **ppOutMessages, int nMaxMessages )
{
PRINT_DEBUG("Steam_Networking_Sockets::ReceiveMessagesOnConnection\n");
return -1;
}
@ -839,7 +827,6 @@ int ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessa
int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, SteamNetworkingMessage001_t **ppOutMessages, int nMaxMessages )
{
PRINT_DEBUG("Steam_Networking_Sockets::ReceiveMessagesOnListenSocket\n");
return -1;
}
@ -847,7 +834,6 @@ int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, SteamNetworkingMe
bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo001_t *pInfo )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionInfo\n");
return false;
}
@ -856,7 +842,6 @@ bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo001_t *
bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetQuickConnectionStatus\n");
return false;
}
@ -870,7 +855,6 @@ bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickCo
int GetDetailedConnectionStatus( HSteamNetConnection hConn, char *pszBuf, int cbBuf )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetDetailedConnectionStatus\n");
return -1;
}
/// Returns local IP and port that a listen socket created using CreateListenSocketIP is bound to.
@ -880,7 +864,6 @@ int GetDetailedConnectionStatus( HSteamNetConnection hConn, char *pszBuf, int cb
bool GetListenSocketAddress( HSteamListenSocket hSocket, SteamNetworkingIPAddr *address )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetListenSocketAddress\n");
return false;
}
/// Returns information about the listen socket.
@ -969,9 +952,6 @@ bool CreateSocketPair( HSteamNetConnection *pOutConnection1, HSteamNetConnection
bool GetIdentity( SteamNetworkingIdentity *pIdentity )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetIdentity\n");
if (!pIdentity) return false;
pIdentity->SetSteamID(settings->get_local_steam_id());
return true;
}
/// Indicate our desire to be ready participate in authenticated communications.
@ -1000,7 +980,6 @@ bool GetIdentity( SteamNetworkingIdentity *pIdentity )
ESteamNetworkingAvailability InitAuthentication()
{
PRINT_DEBUG("Steam_Networking_Sockets::InitAuthentication\n");
return k_ESteamNetworkingAvailability_Current;
}
/// Query our readiness to participate in authenticated communications. A
@ -1013,7 +992,6 @@ ESteamNetworkingAvailability InitAuthentication()
ESteamNetworkingAvailability GetAuthenticationStatus( SteamNetAuthenticationStatus_t *pDetails )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetAuthenticationStatus\n");
return k_ESteamNetworkingAvailability_Current;
}
/// Create a new poll group.
@ -1022,7 +1000,6 @@ ESteamNetworkingAvailability GetAuthenticationStatus( SteamNetAuthenticationStat
HSteamNetPollGroup CreatePollGroup()
{
PRINT_DEBUG("Steam_Networking_Sockets::CreatePollGroup\n");
return k_HSteamNetPollGroup_Invalid;
}
/// Destroy a poll group created with CreatePollGroup().
@ -1033,7 +1010,6 @@ HSteamNetPollGroup CreatePollGroup()
bool DestroyPollGroup( HSteamNetPollGroup hPollGroup )
{
PRINT_DEBUG("Steam_Networking_Sockets::DestroyPollGroup\n");
return false;
}
/// Assign a connection to a poll group. Note that a connection may only belong to a
@ -1053,7 +1029,6 @@ bool DestroyPollGroup( HSteamNetPollGroup hPollGroup )
bool SetConnectionPollGroup( HSteamNetConnection hConn, HSteamNetPollGroup hPollGroup )
{
PRINT_DEBUG("Steam_Networking_Sockets::SetConnectionPollGroup\n");
return false;
}
/// Same as ReceiveMessagesOnConnection, but will return the next messages available
@ -1074,7 +1049,6 @@ bool SetConnectionPollGroup( HSteamNetConnection hConn, HSteamNetPollGroup hPoll
int ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages )
{
PRINT_DEBUG("Steam_Networking_Sockets::ReceiveMessagesOnPollGroup\n");
return -1;
}
@ -1092,7 +1066,6 @@ int ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, SteamNetworkingMe
bool ReceivedRelayAuthTicket( const void *pvTicket, int cbTicket, SteamDatagramRelayAuthTicket *pOutParsedTicket )
{
PRINT_DEBUG("Steam_Networking_Sockets::ReceivedRelayAuthTicket\n");
return false;
}
@ -1105,7 +1078,6 @@ bool ReceivedRelayAuthTicket( const void *pvTicket, int cbTicket, SteamDatagramR
int FindRelayAuthTicketForServer( CSteamID steamID, int nVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket )
{
PRINT_DEBUG("Steam_Networking_Sockets::FindRelayAuthTicketForServer old\n");
return 0;
}
/// Search cache for a ticket to talk to the server on the specified virtual port.
@ -1117,7 +1089,6 @@ int FindRelayAuthTicketForServer( CSteamID steamID, int nVirtualPort, SteamDatag
int FindRelayAuthTicketForServer( const SteamNetworkingIdentity &identityGameServer, int nVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket )
{
PRINT_DEBUG("Steam_Networking_Sockets::FindRelayAuthTicketForServer\n");
return 0;
}
/// Client call to connect to a server hosted in a Valve data center, on the specified virtual
@ -1132,7 +1103,6 @@ int FindRelayAuthTicketForServer( const SteamNetworkingIdentity &identityGameSer
HSteamNetConnection ConnectToHostedDedicatedServer( const SteamNetworkingIdentity &identityTarget, int nVirtualPort )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectToHostedDedicatedServer old\n");
return k_HSteamListenSocket_Invalid;
}
/// Client call to connect to a server hosted in a Valve data center, on the specified virtual
@ -1144,13 +1114,11 @@ HSteamNetConnection ConnectToHostedDedicatedServer( const SteamNetworkingIdentit
HSteamNetConnection ConnectToHostedDedicatedServer( CSteamID steamIDTarget, int nVirtualPort )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectToHostedDedicatedServer older\n");
return k_HSteamListenSocket_Invalid;
}
HSteamNetConnection ConnectToHostedDedicatedServer( const SteamNetworkingIdentity &identityTarget, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectToHostedDedicatedServer\n");
return k_HSteamListenSocket_Invalid;
}
//
@ -1171,7 +1139,6 @@ uint16 GetHostedDedicatedServerPort()
SteamNetworkingPOPID GetHostedDedicatedServerPOPID()
{
PRINT_DEBUG("Steam_Networking_Sockets::GetHostedDedicatedServerPOPID\n");
return 0;
}
@ -1271,7 +1238,6 @@ HSteamListenSocket CreateHostedDedicatedServerListenSocket( int nVirtualPort, in
bool GetConnectionDebugText( HSteamNetConnection hConn, char *pOut, int nOutCCH )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionDebugText\n");
return false;
}
@ -1282,7 +1248,6 @@ bool GetConnectionDebugText( HSteamNetConnection hConn, char *pOut, int nOutCCH
int32 GetConfigurationValue( ESteamNetworkingConfigurationValue eConfigValue )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConfigurationValue\n");
return -1;
}
// Returns true if successfully set
@ -1297,7 +1262,6 @@ bool SetConfigurationValue( ESteamNetworkingConfigurationValue eConfigValue, int
const char *GetConfigurationValueName( ESteamNetworkingConfigurationValue eConfigValue )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConfigurationValueName\n");
return NULL;
}
@ -1309,13 +1273,11 @@ const char *GetConfigurationValueName( ESteamNetworkingConfigurationValue eConfi
int32 GetConfigurationString( ESteamNetworkingConfigurationString eConfigString, char *pDest, int32 destSize )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConfigurationString\n");
return -1;
}
bool SetConfigurationString( ESteamNetworkingConfigurationString eConfigString, const char *pString )
{
PRINT_DEBUG("Steam_Networking_Sockets::SetConfigurationString\n");
return false;
}
@ -1323,7 +1285,6 @@ bool SetConfigurationString( ESteamNetworkingConfigurationString eConfigString,
const char *GetConfigurationStringName( ESteamNetworkingConfigurationString eConfigString )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConfigurationStringName\n");
return NULL;
}
@ -1334,14 +1295,12 @@ const char *GetConfigurationStringName( ESteamNetworkingConfigurationString eCon
int32 GetConnectionConfigurationValue( HSteamNetConnection hConn, ESteamNetworkingConnectionConfigurationValue eConfigValue )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionConfigurationValue\n");
return -1;
}
// Returns true if successfully set
bool SetConnectionConfigurationValue( HSteamNetConnection hConn, ESteamNetworkingConnectionConfigurationValue eConfigValue, int32 nValue )
{
PRINT_DEBUG("Steam_Networking_Sockets::SetConnectionConfigurationValue\n");
return false;
}
/// Generate an authentication blob that can be used to securely login with
@ -1377,7 +1336,6 @@ bool SetConnectionConfigurationValue( HSteamNetConnection hConn, ESteamNetworkin
EResult GetGameCoordinatorServerLogin( SteamDatagramGameCoordinatorServerLogin *pLoginInfo, int *pcbSignedBlob, void *pBlob )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetGameCoordinatorServerLogin\n");
return k_EResultFail;
}
//
@ -1423,7 +1381,6 @@ EResult GetGameCoordinatorServerLogin( SteamDatagramGameCoordinatorServerLogin *
HSteamNetConnection ConnectP2PCustomSignaling( ISteamNetworkingConnectionCustomSignaling *pSignaling, const SteamNetworkingIdentity *pPeerIdentity, int nOptions, const SteamNetworkingConfigValue_t *pOptions )
{
PRINT_DEBUG("Steam_Networking_Sockets::ConnectP2PCustomSignaling\n");
return k_HSteamNetConnection_Invalid;
}
/// Called when custom signaling has received a message. When your
@ -1458,7 +1415,6 @@ HSteamNetConnection ConnectP2PCustomSignaling( ISteamNetworkingConnectionCustomS
bool ReceivedP2PCustomSignal( const void *pMsg, int cbMsg, ISteamNetworkingCustomSignalingRecvContext *pContext )
{
PRINT_DEBUG("Steam_Networking_Sockets::ReceivedP2PCustomSignal\n");
return false;
}
//
@ -1475,7 +1431,6 @@ bool ReceivedP2PCustomSignal( const void *pMsg, int cbMsg, ISteamNetworkingCusto
bool GetCertificateRequest( int *pcbBlob, void *pBlob, SteamNetworkingErrMsg &errMsg )
{
PRINT_DEBUG("Steam_Networking_Sockets::GetCertificateRequest\n");
return false;
}
/// Set the certificate. The certificate blob should be the output of
@ -1483,7 +1438,6 @@ bool GetCertificateRequest( int *pcbBlob, void *pBlob, SteamNetworkingErrMsg &er
bool SetCertificate( const void *pCertificate, int cbCertificate, SteamNetworkingErrMsg &errMsg )
{
PRINT_DEBUG("Steam_Networking_Sockets::SetCertificate\n");
return false;
}
// TEMP KLUDGE Call to invoke all queued callbacks.

10
dll/steam_networking_utils.h
View File

@ -188,28 +188,24 @@ bool IsPingMeasurementInProgress()
int GetPingToDataCenter( SteamNetworkingPOPID popID, SteamNetworkingPOPID *pViaRelayPoP )
{
PRINT_DEBUG("Steam_Networking_Utils::GetPingToDataCenter\n");
return 0;
}
int GetDirectPingToPOP( SteamNetworkingPOPID popID )
{
PRINT_DEBUG("Steam_Networking_Utils::GetDirectPingToPOP\n");
return 0;
}
int GetPOPCount()
{
PRINT_DEBUG("Steam_Networking_Utils::GetPOPCount\n");
return 0;
}
int GetPOPList( SteamNetworkingPOPID *list, int nListSz )
{
PRINT_DEBUG("Steam_Networking_Utils::GetPOPList\n");
return 0;
}
@ -295,7 +291,6 @@ bool SetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigS
ESteamNetworkingConfigDataType eDataType, const void *pArg )
{
PRINT_DEBUG("Steam_Networking_Utils::SetConfigValue\n");
return false;
}
@ -310,7 +305,6 @@ ESteamNetworkingGetConfigValueResult GetConfigValue( ESteamNetworkingConfigValue
ESteamNetworkingConfigDataType *pOutDataType, void *pResult, size_t *cbResult )
{
PRINT_DEBUG("Steam_Networking_Utils::GetConfigValue\n");
return k_ESteamNetworkingGetConfigValue_BadValue;
}
@ -321,7 +315,6 @@ ESteamNetworkingGetConfigValueResult GetConfigValue( ESteamNetworkingConfigValue
bool GetConfigValueInfo( ESteamNetworkingConfigValue eValue, const char **pOutName, ESteamNetworkingConfigDataType *pOutDataType, ESteamNetworkingConfigScope *pOutScope, ESteamNetworkingConfigValue *pOutNextValue )
{
PRINT_DEBUG("Steam_Networking_Utils::GetConfigValueInfo\n");
return false;
}
@ -329,7 +322,6 @@ bool GetConfigValueInfo( ESteamNetworkingConfigValue eValue, const char **pOutNa
ESteamNetworkingConfigValue GetFirstConfigValue()
{
PRINT_DEBUG("Steam_Networking_Utils::GetFirstConfigValue\n");
return k_ESteamNetworkingConfig_Invalid;
}
@ -343,7 +335,6 @@ void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr &addr, char *bu
bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr )
{
PRINT_DEBUG("Steam_Networking_Utils::SteamNetworkingIPAddr_ParseString\n");
return false;
}
void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf )
@ -354,7 +345,6 @@ void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity,
bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr )
{
PRINT_DEBUG("Steam_Networking_Utils::SteamNetworkingIdentity_ParseString\n");
return false;
}

10
dll/steam_parties.h
View File

@ -71,19 +71,16 @@ Steam_Parties(class Settings *settings, class Networking *network, class SteamCa
uint32 GetNumActiveBeacons()
{
PRINT_DEBUG("Steam_Parties::GetNumActiveBeacons\n");
return 0;
}
PartyBeaconID_t GetBeaconByIndex( uint32 unIndex )
{
PRINT_DEBUG("Steam_Parties::GetBeaconByIndex\n");
return k_ulPartyBeaconIdInvalid;
}
bool GetBeaconDetails( PartyBeaconID_t ulBeaconID, CSteamID *pSteamIDBeaconOwner, STEAM_OUT_STRUCT() SteamPartyBeaconLocation_t *pLocation, STEAM_OUT_STRING_COUNT(cchMetadata) char *pchMetadata, int cchMetadata )
{
PRINT_DEBUG("Steam_Parties::GetBeaconDetails\n");
return false;
}
@ -93,7 +90,6 @@ STEAM_CALL_RESULT( JoinPartyCallback_t )
SteamAPICall_t JoinParty( PartyBeaconID_t ulBeaconID )
{
PRINT_DEBUG("Steam_Parties::JoinParty\n");
return 0;
}
@ -104,13 +100,11 @@ SteamAPICall_t JoinParty( PartyBeaconID_t ulBeaconID )
bool GetNumAvailableBeaconLocations( uint32 *puNumLocations )
{
PRINT_DEBUG("Steam_Parties::GetNumAvailableBeaconLocations\n");
return false;
}
bool GetAvailableBeaconLocations( SteamPartyBeaconLocation_t *pLocationList, uint32 uMaxNumLocations )
{
PRINT_DEBUG("Steam_Parties::GetAvailableBeaconLocations\n");
return false;
}
@ -122,7 +116,6 @@ STEAM_CALL_RESULT( CreateBeaconCallback_t )
SteamAPICall_t CreateBeacon( uint32 unOpenSlots, SteamPartyBeaconLocation_t *pBeaconLocation, const char *pchConnectString, const char *pchMetadata )
{
PRINT_DEBUG("Steam_Parties::CreateBeacon\n");
return 0;
}
@ -150,7 +143,6 @@ STEAM_CALL_RESULT( ChangeNumOpenSlotsCallback_t )
SteamAPICall_t ChangeNumOpenSlots( PartyBeaconID_t ulBeacon, uint32 unOpenSlots )
{
PRINT_DEBUG("Steam_Parties::ChangeNumOpenSlots\n");
return 0;
}
@ -158,7 +150,6 @@ SteamAPICall_t ChangeNumOpenSlots( PartyBeaconID_t ulBeacon, uint32 unOpenSlots
bool DestroyBeacon( PartyBeaconID_t ulBeacon )
{
PRINT_DEBUG("Steam_Parties::DestroyBeacon\n");
return false;
}
@ -166,7 +157,6 @@ bool DestroyBeacon( PartyBeaconID_t ulBeacon )
bool GetBeaconLocationData( SteamPartyBeaconLocation_t BeaconLocation, ESteamPartyBeaconLocationData eData, STEAM_OUT_STRING_COUNT(cchDataStringOut) char *pchDataStringOut, int cchDataStringOut )
{
PRINT_DEBUG("Steam_Parties::GetBeaconLocationData\n");
return false;
}

42
dll/steam_remote_storage.h
View File

@ -405,13 +405,11 @@ SteamAPICall_t UGCDownload( UGCHandle_t hContent )
bool GetUGCDownloadProgress( UGCHandle_t hContent, int32 *pnBytesDownloaded, int32 *pnBytesExpected )
{
PRINT_DEBUG("Steam_Remote_Storage::GetUGCDownloadProgress\n");
return false;
}
bool GetUGCDownloadProgress( UGCHandle_t hContent, uint32 *pnBytesDownloaded, uint32 *pnBytesExpected )
{
PRINT_DEBUG("Steam_Remote_Storage::GetUGCDownloadProgress old\n");
return false;
}
@ -419,7 +417,6 @@ bool GetUGCDownloadProgress( UGCHandle_t hContent, uint32 *pnBytesDownloaded, ui
bool GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, STEAM_OUT_STRING() char **ppchName, int32 *pnFileSizeInBytes, STEAM_OUT_STRUCT() CSteamID *pSteamIDOwner )
{
PRINT_DEBUG("Steam_Remote_Storage::GetUGCDetails\n");
return false;
}
@ -463,13 +460,11 @@ int32 UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 c
int32 GetCachedUGCCount()
{
PRINT_DEBUG("Steam_Remote_Storage::GetCachedUGCCount\n");
return 0;
}
UGCHandle_t GetCachedUGCHandle( int32 iCachedContent )
{
PRINT_DEBUG("Steam_Remote_Storage::GetCachedUGCHandle\n");
return k_UGCHandleInvalid;
}
@ -522,74 +517,62 @@ STEAM_CALL_RESULT( RemoteStoragePublishFileProgress_t )
SteamAPICall_t PublishWorkshopFile( const char *pchFile, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags, EWorkshopFileType eWorkshopFileType )
{
PRINT_DEBUG("Steam_Remote_Storage::PublishWorkshopFile\n");
return 0;
}
PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest( PublishedFileId_t unPublishedFileId )
{
PRINT_DEBUG("Steam_Remote_Storage::CreatePublishedFileUpdateRequest\n");
return 0;
}
bool UpdatePublishedFileFile( PublishedFileUpdateHandle_t updateHandle, const char *pchFile )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFileFile\n");
return false;
}
SteamAPICall_t PublishFile( const char *pchFile, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags )
{
PRINT_DEBUG("Steam_Remote_Storage::PublishFile\n");
return 0;
}
SteamAPICall_t PublishWorkshopFile( const char *pchFile, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, SteamParamStringArray_t *pTags )
{
PRINT_DEBUG("Steam_Remote_Storage::PublishWorkshopFile old\n");
return 0;
}
SteamAPICall_t UpdatePublishedFile( RemoteStorageUpdatePublishedFileRequest_t updatePublishedFileRequest )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFile\n");
return 0;
}
bool UpdatePublishedFilePreviewFile( PublishedFileUpdateHandle_t updateHandle, const char *pchPreviewFile )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFilePreviewFile\n");
return false;
}
bool UpdatePublishedFileTitle( PublishedFileUpdateHandle_t updateHandle, const char *pchTitle )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFileTitle\n");
return false;
}
bool UpdatePublishedFileDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchDescription )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFileDescription\n");
return false;
}
bool UpdatePublishedFileVisibility( PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFileVisibility\n");
return false;
}
bool UpdatePublishedFileTags( PublishedFileUpdateHandle_t updateHandle, SteamParamStringArray_t *pTags )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFileTags\n");
return false;
}
STEAM_CALL_RESULT( RemoteStorageUpdatePublishedFileResult_t )
SteamAPICall_t CommitPublishedFileUpdate( PublishedFileUpdateHandle_t updateHandle )
{
PRINT_DEBUG("Steam_Remote_Storage::CommitPublishedFileUpdate\n");
return 0;
}
// Gets published file details for the given publishedfileid. If unMaxSecondsOld is greater than 0,
@ -598,30 +581,19 @@ SteamAPICall_t CommitPublishedFileUpdate( PublishedFileUpdateHandle_t updateHand
STEAM_CALL_RESULT( RemoteStorageGetPublishedFileDetailsResult_t )
SteamAPICall_t GetPublishedFileDetails( PublishedFileId_t unPublishedFileId, uint32 unMaxSecondsOld )
{
PRINT_DEBUG("Steam_Remote_Storage::GetPublishedFileDetails %llu\n", unPublishedFileId);
//TODO: check what this function really returns
return 0;
/*
std::lock_guard<std::recursive_mutex> lock(global_mutex);
RemoteStorageGetPublishedFileDetailsResult_t data = {};
data.m_eResult = k_EResultFail;
data.m_nPublishedFileId = unPublishedFileId;
return callback_results->addCallResult(data.k_iCallback, &data, sizeof(data));
*/
PRINT_DEBUG("Steam_Remote_Storage::GetPublishedFileDetails\n");
}
STEAM_CALL_RESULT( RemoteStorageGetPublishedFileDetailsResult_t )
SteamAPICall_t GetPublishedFileDetails( PublishedFileId_t unPublishedFileId )
{
PRINT_DEBUG("Steam_Remote_Storage::GetPublishedFileDetails old\n");
return GetPublishedFileDetails(unPublishedFileId, 0);
}
STEAM_CALL_RESULT( RemoteStorageDeletePublishedFileResult_t )
SteamAPICall_t DeletePublishedFile( PublishedFileId_t unPublishedFileId )
{
PRINT_DEBUG("Steam_Remote_Storage::DeletePublishedFile\n");
return 0;
}
// enumerate the files that the current user published with this app
@ -642,7 +614,6 @@ STEAM_CALL_RESULT( RemoteStorageSubscribePublishedFileResult_t )
SteamAPICall_t SubscribePublishedFile( PublishedFileId_t unPublishedFileId )
{
PRINT_DEBUG("Steam_Remote_Storage::SubscribePublishedFile\n");
return 0;
}
STEAM_CALL_RESULT( RemoteStorageEnumerateUserSubscribedFilesResult_t )
@ -663,34 +634,29 @@ STEAM_CALL_RESULT( RemoteStorageUnsubscribePublishedFileResult_t )
SteamAPICall_t UnsubscribePublishedFile( PublishedFileId_t unPublishedFileId )
{
PRINT_DEBUG("Steam_Remote_Storage::UnsubscribePublishedFile\n");
return 0;
}
bool UpdatePublishedFileSetChangeDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchChangeDescription )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdatePublishedFileSetChangeDescription\n");
return false;
}
STEAM_CALL_RESULT( RemoteStorageGetPublishedItemVoteDetailsResult_t )
SteamAPICall_t GetPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId )
{
PRINT_DEBUG("Steam_Remote_Storage::GetPublishedItemVoteDetails\n");
return 0;
}
STEAM_CALL_RESULT( RemoteStorageUpdateUserPublishedItemVoteResult_t )
SteamAPICall_t UpdateUserPublishedItemVote( PublishedFileId_t unPublishedFileId, bool bVoteUp )
{
PRINT_DEBUG("Steam_Remote_Storage::UpdateUserPublishedItemVote\n");
return 0;
}
STEAM_CALL_RESULT( RemoteStorageGetPublishedItemVoteDetailsResult_t )
SteamAPICall_t GetUserPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId )
{
PRINT_DEBUG("Steam_Remote_Storage::GetUserPublishedItemVoteDetails\n");
return 0;
}
STEAM_CALL_RESULT( RemoteStorageEnumerateUserPublishedFilesResult_t )
@ -717,28 +683,24 @@ STEAM_CALL_RESULT( RemoteStoragePublishFileProgress_t )
SteamAPICall_t PublishVideo( EWorkshopVideoProvider eVideoProvider, const char *pchVideoAccount, const char *pchVideoIdentifier, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags )
{
PRINT_DEBUG("Steam_Remote_Storage::PublishVideo\n");
return 0;
}
STEAM_CALL_RESULT( RemoteStoragePublishFileProgress_t )
SteamAPICall_t PublishVideo(const char *pchFileName, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags )
{
PRINT_DEBUG("Steam_Remote_Storage::PublishVideo old\n");
return 0;
}
STEAM_CALL_RESULT( RemoteStorageSetUserPublishedFileActionResult_t )
SteamAPICall_t SetUserPublishedFileAction( PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction )
{
PRINT_DEBUG("Steam_Remote_Storage::SetUserPublishedFileAction\n");
return 0;
}
STEAM_CALL_RESULT( RemoteStorageEnumeratePublishedFilesByUserActionResult_t )
SteamAPICall_t EnumeratePublishedFilesByUserAction( EWorkshopFileAction eAction, uint32 unStartIndex )
{
PRINT_DEBUG("Steam_Remote_Storage::EnumeratePublishedFilesByUserAction\n");
return 0;
}
// this method enumerates the public view of workshop files
@ -746,7 +708,6 @@ STEAM_CALL_RESULT( RemoteStorageEnumerateWorkshopFilesResult_t )
SteamAPICall_t EnumeratePublishedWorkshopFiles( EWorkshopEnumerationType eEnumerationType, uint32 unStartIndex, uint32 unCount, uint32 unDays, SteamParamStringArray_t *pTags, SteamParamStringArray_t *pUserTags )
{
PRINT_DEBUG("Steam_Remote_Storage::EnumeratePublishedWorkshopFiles\n");
return 0;
}
@ -754,7 +715,6 @@ STEAM_CALL_RESULT( RemoteStorageDownloadUGCResult_t )
SteamAPICall_t UGCDownloadToLocation( UGCHandle_t hContent, const char *pchLocation, uint32 unPriority )
{
PRINT_DEBUG("Steam_Remote_Storage::UGCDownloadToLocation\n");
return 0;
}
};

4
dll/steam_user_stats.h
View File

@ -778,7 +778,6 @@ STEAM_CALL_RESULT( GlobalAchievementPercentagesReady_t )
SteamAPICall_t RequestGlobalAchievementPercentages()
{
PRINT_DEBUG("RequestGlobalAchievementPercentages\n");
return 0;
}
@ -788,7 +787,6 @@ SteamAPICall_t RequestGlobalAchievementPercentages()
int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved )
{
PRINT_DEBUG("GetMostAchievedAchievementInfo\n");
return -1;
}
@ -798,7 +796,6 @@ int GetMostAchievedAchievementInfo( char *pchName, uint32 unNameBufLen, float *p
int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved )
{
PRINT_DEBUG("GetNextMostAchievedAchievementInfo\n");
return -1;
}
@ -806,7 +803,6 @@ int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, char *pchName, ui
bool GetAchievementAchievedPercent( const char *pchName, float *pflPercent )
{
PRINT_DEBUG("GetAchievementAchievedPercent\n");
return false;
}