Make all functions return something and re enable the msvc error.

detours/creatwth.cpp

@@ -7,34 +7,15 @@
 //  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]

detours/detours.cpp

@@ -7,33 +7,15 @@
 //  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
 
 //////////////////////////////////////////////////////////////////////////////
@@ -880,7 +862,8 @@ struct _DETOUR_TRAMPOLINE
 {
     // An ARM64 instruction is 4 bytes long.
     //
-    // The overwrite is always 2 instructions plus a literal, so 16 bytes, 4 instructions.
+    // 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.
     //
     // Copied instructions can expand.
     //
@@ -915,7 +898,7 @@ struct _DETOUR_TRAMPOLINE
 C_ASSERT(sizeof(_DETOUR_TRAMPOLINE) == 184);
 
 enum {
-    SIZE_OF_JMP = 16
+    SIZE_OF_JMP = 12
 };
 
 inline ULONG fetch_opcode(PBYTE pbCode)
@@ -929,6 +912,79 @@ 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;
@@ -995,7 +1051,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
@@ -1062,7 +1118,10 @@ inline void detour_find_jmp_bounds(PBYTE pbCode,
                                    PDETOUR_TRAMPOLINE *ppLower,
                                    PDETOUR_TRAMPOLINE *ppUpper)
 {
-    // We have to place trampolines within +/- 2GB of code.
+    // 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.
+
     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));
@@ -1250,6 +1309,65 @@ 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.
@@ -1294,41 +1412,10 @@ static PDETOUR_TRAMPOLINE detour_alloc_trampoline(PBYTE pbTarget)
     // Round pbTarget down to 64KB block.
     pbTarget = pbTarget - (PtrToUlong(pbTarget) & 0xffff);
 
-    PVOID pbTry = NULL;
+    PVOID pbNewlyAllocated =
-
+        detour_alloc_trampoline_allocate_new(pbTarget, pLo, pHi);
-    // NB: We must always also start the search at an offset from pbTarget
+    if (pbNewlyAllocated != NULL) {
-    //     in order to maintain ASLR entropy.
+        s_pRegion = (DETOUR_REGION*)pbNewlyAllocated;
-
-#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;
@@ -1655,7 +1742,7 @@ LONG WINAPI DetourTransactionCommitEx(_Out_opt_ PVOID **pppFailedPointer)
 #endif // DETOURS_ARM
 
 #ifdef DETOURS_ARM64
-            PBYTE pbCode = detour_gen_jmp_immediate(o->pbTarget, NULL, o->pTrampoline->pbDetour);
+            PBYTE pbCode = detour_gen_jmp_indirect(o->pbTarget, (ULONG64*)&(o->pTrampoline->pbDetour));
             pbCode = detour_gen_brk(pbCode, o->pTrampoline->pbRemain);
             *o->ppbPointer = o->pTrampoline->rbCode;
             UNREFERENCED_PARAMETER(pbCode);

detours/detours.h

@@ -16,6 +16,34 @@
 //////////////////////////////////////////////////////////////////////////////
 //
 
+#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
@@ -61,7 +89,12 @@
 //#define DETOURS_OPTION_BITS 32
 #endif
 
-#define VER_DETOURS_BITS    DETOUR_STRINGIFY(DETOURS_BITS)
+/////////////////////////////////////////////////////////////// Helper Macros.
+//
+#define DETOURS_STRINGIFY_(x)    #x
+#define DETOURS_STRINGIFY(x)    DETOURS_STRINGIFY_(x)
+
+#define VER_DETOURS_BITS    DETOURS_STRINGIFY(DETOURS_BITS)
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -387,7 +420,6 @@ 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
@@ -396,6 +428,10 @@ 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);
@@ -431,11 +467,6 @@ 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)(
@@ -523,6 +554,8 @@ 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.
 //

detours/detver.h

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

detours/disasm.cpp

@@ -7,28 +7,15 @@
 //  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)
 
@@ -260,6 +247,11 @@ 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
 
@@ -289,6 +281,9 @@ 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];
@@ -303,6 +298,7 @@ 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;
@@ -337,6 +333,7 @@ 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;
@@ -368,8 +365,11 @@ PBYTE CDetourDis::CopyBytes(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc)
 {
     UINT nBytesFixed;
 
-    ASSERT(!m_bVex || pEntry->nFlagBits == 0);
+    if (m_bVex || m_bEvex)
-    ASSERT(!m_bVex || pEntry->nFixedSize == pEntry->nFixedSize16);
+    {
+        ASSERT(pEntry->nFlagBits == 0);
+        ASSERT(pEntry->nFixedSize == pEntry->nFixedSize16);
+    }
 
     UINT const nModOffset = pEntry->nModOffset;
     UINT const nFlagBits = pEntry->nFlagBits;
@@ -748,32 +748,41 @@ PBYTE CDetourDis::CopyFF(REFCOPYENTRY pEntry, PBYTE pbDst, PBYTE pbSrc)
     return pbOut;
 }
 
-PBYTE CDetourDis::CopyVexCommon(BYTE m, PBYTE pbDst, PBYTE pbSrc)
+PBYTE CDetourDis::CopyVexEvexCommon(BYTE m, PBYTE pbDst, PBYTE pbSrc, BYTE p)
 // 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 Invalid = { 0xC4, ENTRY_Invalid };
+    static const COPYENTRY ceInvalid = { 0xC4, ENTRY_Invalid };
 
-    m_bVex = TRUE;
+    switch (p & 3) {
-    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
@@ -835,6 +844,78 @@ 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;
@@ -1030,11 +1111,11 @@ const CDetourDis::COPYENTRY CDetourDis::s_rceCopyTable[257] =
 #ifdef DETOURS_X64
     { 0x60, ENTRY_Invalid },                            // Invalid
     { 0x61, ENTRY_Invalid },                            // Invalid
-    { 0x62, ENTRY_Invalid },                            // Invalid (not yet implemented Intel EVEX support)
+    { 0x62, ENTRY_CopyEvex },                           // EVEX / AVX512
 #else
     { 0x60, ENTRY_CopyBytes1 },                         // PUSHAD
     { 0x61, ENTRY_CopyBytes1 },                         // POPAD
-    { 0x62, ENTRY_CopyBytes2Mod },                      // BOUND /r
+    { 0x62, ENTRY_CopyEvex },                           // BOUND /r and EVEX / AVX512
 #endif
     { 0x63, ENTRY_CopyBytes2Mod },                      // 32bit ARPL /r, 64bit MOVSXD
     { 0x64, ENTRY_CopyBytesSegment },                   // FS prefix
@@ -1084,7 +1165,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_CopyBytes2Mod },                      // POP /0
+    { 0x8F, ENTRY_CopyXop },                            // POP /0 or AMD XOP
     { 0x90, ENTRY_CopyBytes1 },                         // NOP
     { 0x91, ENTRY_CopyBytes1 },                         // XCHG
     { 0x92, ENTRY_CopyBytes1 },                         // XCHG

detours/image.cpp

@@ -9,39 +9,18 @@
 //  Used for for payloads, byways, and imports.
 //
 
-#if _MSC_VER >= 1900
+#if _MSC_VER < 1299
-#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
 {
 //////////////////////////////////////////////////////////////////////////////
@@ -1714,17 +1693,13 @@ BOOL CImage::Write(HANDLE hFile)
         m_nNextFileAddr = Max(m_SectionHeaders[n].PointerToRawData +
                               m_SectionHeaders[n].SizeOfRawData,
                               m_nNextFileAddr);
-#if 0
+        // Old images have VirtualSize == 0 as a matter of course, e.g. NT 3.1.
-        m_nNextVirtAddr = Max(m_SectionHeaders[n].VirtualAddress +
+        // In which case, use SizeOfRawData instead.
-                              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);
 
@@ -1857,7 +1832,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;
@@ -1899,7 +1874,7 @@ BOOL CImage::Write(HANDLE hFile)
             }
             piidDst++;
         }
-        ZeroMemory(piidDst, sizeof(piidDst));
+        ZeroMemory(piidDst, sizeof(*piidDst));
 
         //////////////////////////////////////////////////////////////////////////
         //

detours/modules.cpp

@@ -9,27 +9,6 @@
 //  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"
@@ -38,10 +17,6 @@
 #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]
 
@@ -164,8 +139,8 @@ PDETOUR_SYM_INFO DetourLoadImageHlp(VOID)
     return pSymInfo;
 }
 
-PVOID WINAPI DetourFindFunction(_In_ PCSTR pszModule,
+PVOID WINAPI DetourFindFunction(_In_ LPCSTR pszModule,
-                                _In_ PCSTR pszFunction)
+                                _In_ LPCSTR pszFunction)
 {
     /////////////////////////////////////////////// First, try GetProcAddress.
     //

dll/base.h

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

dll/dll.cpp

@@ -1016,56 +1016,67 @@ 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 )
@@ -1081,31 +1092,37 @@ 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 )
@@ -1116,16 +1133,19 @@ 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 )

dll/steam_applist.cpp

@@ -20,27 +20,32 @@
 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;
 }

dll/steam_gamesearch.h

@@ -71,6 +71,7 @@ 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;
 }
 
 
@@ -80,6 +81,7 @@ 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;
 }
 
 
@@ -88,6 +90,7 @@ 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;
 }
 
 
@@ -96,11 +99,13 @@ 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;
 }
 
 
@@ -108,6 +113,7 @@ EGameSearchErrorCode_t DeclineGame()
 EGameSearchErrorCode_t RetrieveConnectionDetails( CSteamID steamIDHost, char *pchConnectionDetails, int cubConnectionDetails )
 {
     PRINT_DEBUG("Steam_Game_Search::RetrieveConnectionDetails\n");
+    return k_EGameSearchErrorCode_Failed_Offline;
 }
 
 
@@ -115,6 +121,7 @@ EGameSearchErrorCode_t RetrieveConnectionDetails( CSteamID steamIDHost, char *pc
 EGameSearchErrorCode_t EndGameSearch()
 {
     PRINT_DEBUG("Steam_Game_Search::EndGameSearch\n");
+    return k_EGameSearchErrorCode_Failed_Offline;
 }
 
 
@@ -125,6 +132,7 @@ EGameSearchErrorCode_t EndGameSearch()
 EGameSearchErrorCode_t SetGameHostParams( const char *pchKey, const char *pchValue )
 {
     PRINT_DEBUG("Steam_Game_Search::SetGameHostParams\n");
+    return k_EGameSearchErrorCode_Failed_Offline;
 }
 
 
@@ -132,6 +140,7 @@ 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;
 }
 
 
@@ -143,6 +152,7 @@ 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;
 }
 
 
@@ -152,6 +162,7 @@ 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;
 }
 
 
@@ -160,6 +171,7 @@ EGameSearchErrorCode_t HostConfirmGameStart( uint64 ullUniqueGameID )
 EGameSearchErrorCode_t CancelRequestPlayersForGame()
 {
     PRINT_DEBUG("Steam_Game_Search::CancelRequestPlayersForGame\n");
+    return k_EGameSearchErrorCode_Failed_Offline;
 }
 
 
@@ -167,6 +179,7 @@ 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;
 }
 
 
@@ -175,6 +188,7 @@ 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()

dll/steam_inventory.h

@@ -441,6 +441,7 @@ 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;
 }
 
 
@@ -480,6 +481,7 @@ 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;
 }
 
 
@@ -496,6 +498,7 @@ 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;
 }
 
 
@@ -507,6 +510,7 @@ bool ExchangeItems( SteamInventoryResult_t *pResultHandle,
 bool TransferItemQuantity( SteamInventoryResult_t *pResultHandle, SteamItemInstanceID_t itemIdSource, uint32 unQuantity, SteamItemInstanceID_t itemIdDest )
 {
     PRINT_DEBUG("TransferItemQuantity\n");
+    return false;
 }
 
 
@@ -534,7 +538,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\n");
+    PRINT_DEBUG("TriggerItemDrop %p %i\n", pResultHandle, dropListDefinition);
     //TODO: if gameserver return false
     return true;
 }
@@ -725,6 +729,7 @@ STEAM_CALL_RESULT( SteamInventoryEligiblePromoItemDefIDs_t )
 SteamAPICall_t RequestEligiblePromoItemDefinitionsIDs( CSteamID steamID )
 {
     PRINT_DEBUG("RequestEligiblePromoItemDefinitionsIDs\n");
+    return 0;
 }
 
 
@@ -737,6 +742,7 @@ 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;
 }
 
 
@@ -749,6 +755,7 @@ 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;
 }
 
 
@@ -793,6 +800,7 @@ 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
@@ -808,39 +816,46 @@ 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()

dll/steam_musicremote.cpp

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

dll/steam_networking_sockets.h

@@ -242,11 +242,13 @@ 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
@@ -270,11 +272,13 @@ 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
@@ -354,12 +358,14 @@ 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;
 }
 
 
@@ -471,6 +477,7 @@ 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
@@ -538,6 +545,7 @@ void SetConnectionName( HSteamNetConnection hPeer, const char *pszName )
 bool GetConnectionName( HSteamNetConnection hPeer, char *pszName, int nMaxLen )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionName\n");
+    return false;
 }
 
 
@@ -568,6 +576,7 @@ 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.
@@ -687,6 +696,7 @@ 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)
@@ -791,6 +801,7 @@ int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, SteamNetworkingMe
 bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo_t *pInfo )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionInfo\n");
+    return false;
 }
 
 
@@ -813,6 +824,7 @@ 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;
 }
  
 
@@ -827,6 +839,7 @@ int ReceiveMessagesOnConnection( HSteamNetConnection hConn, SteamNetworkingMessa
 int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, SteamNetworkingMessage001_t **ppOutMessages, int nMaxMessages )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::ReceiveMessagesOnListenSocket\n");
+    return -1;
 }
  
 
@@ -834,6 +847,7 @@ int ReceiveMessagesOnListenSocket( HSteamListenSocket hSocket, SteamNetworkingMe
 bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo001_t *pInfo )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionInfo\n");
+    return false;
 }
 
 
@@ -842,6 +856,7 @@ bool GetConnectionInfo( HSteamNetConnection hConn, SteamNetConnectionInfo001_t *
 bool GetQuickConnectionStatus( HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus *pStats )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetQuickConnectionStatus\n");
+    return false;
 }
 
 
@@ -855,6 +870,7 @@ 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.
@@ -864,6 +880,7 @@ 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.
@@ -952,6 +969,9 @@ 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.
@@ -980,6 +1000,7 @@ 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
@@ -992,6 +1013,7 @@ ESteamNetworkingAvailability InitAuthentication()
 ESteamNetworkingAvailability GetAuthenticationStatus( SteamNetAuthenticationStatus_t *pDetails )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetAuthenticationStatus\n");
+    return k_ESteamNetworkingAvailability_Current;
 }
 
 /// Create a new poll group.
@@ -1000,6 +1022,7 @@ ESteamNetworkingAvailability GetAuthenticationStatus( SteamNetAuthenticationStat
 HSteamNetPollGroup CreatePollGroup()
 {
     PRINT_DEBUG("Steam_Networking_Sockets::CreatePollGroup\n");
+    return k_HSteamNetPollGroup_Invalid;
 }
 
 /// Destroy a poll group created with CreatePollGroup().
@@ -1010,6 +1033,7 @@ 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
@@ -1029,6 +1053,7 @@ 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
@@ -1049,6 +1074,7 @@ bool SetConnectionPollGroup( HSteamNetConnection hConn, HSteamNetPollGroup hPoll
 int ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::ReceiveMessagesOnPollGroup\n");
+    return -1; 
 }
 
 
@@ -1066,6 +1092,7 @@ int ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, SteamNetworkingMe
 bool ReceivedRelayAuthTicket( const void *pvTicket, int cbTicket, SteamDatagramRelayAuthTicket *pOutParsedTicket )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::ReceivedRelayAuthTicket\n");
+    return false;
 }
 
 
@@ -1078,6 +1105,7 @@ 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.
@@ -1089,6 +1117,7 @@ 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
@@ -1103,6 +1132,7 @@ 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
@@ -1114,11 +1144,13 @@ 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;
 }
 
 //
@@ -1139,6 +1171,7 @@ uint16 GetHostedDedicatedServerPort()
 SteamNetworkingPOPID GetHostedDedicatedServerPOPID()
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetHostedDedicatedServerPOPID\n");
+    return 0;
 }
 
 
@@ -1238,6 +1271,7 @@ HSteamListenSocket CreateHostedDedicatedServerListenSocket( int nVirtualPort, in
 bool GetConnectionDebugText( HSteamNetConnection hConn, char *pOut, int nOutCCH )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetConnectionDebugText\n");
+    return false;
 }
 
 
@@ -1248,6 +1282,7 @@ 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
@@ -1262,6 +1297,7 @@ bool SetConfigurationValue( ESteamNetworkingConfigurationValue eConfigValue, int
 const char *GetConfigurationValueName( ESteamNetworkingConfigurationValue eConfigValue )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetConfigurationValueName\n");
+    return NULL;
 }
 
 
@@ -1273,11 +1309,13 @@ 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;
 }
 
 
@@ -1285,6 +1323,7 @@ bool SetConfigurationString( ESteamNetworkingConfigurationString eConfigString,
 const char *GetConfigurationStringName( ESteamNetworkingConfigurationString eConfigString )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetConfigurationStringName\n");
+    return NULL;
 }
 
 
@@ -1295,12 +1334,14 @@ 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
@@ -1336,6 +1377,7 @@ bool SetConnectionConfigurationValue( HSteamNetConnection hConn, ESteamNetworkin
 EResult GetGameCoordinatorServerLogin( SteamDatagramGameCoordinatorServerLogin *pLoginInfo, int *pcbSignedBlob, void *pBlob )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::GetGameCoordinatorServerLogin\n");
+    return k_EResultFail;
 }
 
 //
@@ -1381,6 +1423,7 @@ 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
@@ -1415,6 +1458,7 @@ HSteamNetConnection ConnectP2PCustomSignaling( ISteamNetworkingConnectionCustomS
 bool ReceivedP2PCustomSignal( const void *pMsg, int cbMsg, ISteamNetworkingCustomSignalingRecvContext *pContext )
 {
     PRINT_DEBUG("Steam_Networking_Sockets::ReceivedP2PCustomSignal\n");
+    return false;
 }
 
 //
@@ -1431,6 +1475,7 @@ 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
@@ -1438,6 +1483,7 @@ 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.

dll/steam_networking_utils.h

@@ -188,24 +188,28 @@ 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;
 }
 
 
@@ -291,6 +295,7 @@ bool SetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigS
     ESteamNetworkingConfigDataType eDataType, const void *pArg )
 {
     PRINT_DEBUG("Steam_Networking_Utils::SetConfigValue\n");
+    return false;
 }
 
 
@@ -305,6 +310,7 @@ ESteamNetworkingGetConfigValueResult GetConfigValue( ESteamNetworkingConfigValue
     ESteamNetworkingConfigDataType *pOutDataType, void *pResult, size_t *cbResult )
 {
     PRINT_DEBUG("Steam_Networking_Utils::GetConfigValue\n");
+    return k_ESteamNetworkingGetConfigValue_BadValue;
 }
 
 
@@ -315,6 +321,7 @@ 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;
 }
 
 
@@ -322,6 +329,7 @@ bool GetConfigValueInfo( ESteamNetworkingConfigValue eValue, const char **pOutNa
 ESteamNetworkingConfigValue GetFirstConfigValue()
 {
     PRINT_DEBUG("Steam_Networking_Utils::GetFirstConfigValue\n");
+    return k_ESteamNetworkingConfig_Invalid;
 }
 
 
@@ -335,6 +343,7 @@ 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 )
@@ -345,6 +354,7 @@ void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity,
 bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr )
 {
     PRINT_DEBUG("Steam_Networking_Utils::SteamNetworkingIdentity_ParseString\n");
+    return false;
 }
 
 

dll/steam_parties.h

@@ -71,16 +71,19 @@ 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;
 }
 
 
@@ -90,6 +93,7 @@ STEAM_CALL_RESULT( JoinPartyCallback_t )
 SteamAPICall_t JoinParty( PartyBeaconID_t ulBeaconID )
 {
     PRINT_DEBUG("Steam_Parties::JoinParty\n");
+    return 0;
 }
 
 
@@ -100,11 +104,13 @@ 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;
 }
 
 
@@ -116,6 +122,7 @@ 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;
 }
 
 
@@ -143,6 +150,7 @@ STEAM_CALL_RESULT( ChangeNumOpenSlotsCallback_t )
 SteamAPICall_t ChangeNumOpenSlots( PartyBeaconID_t ulBeacon, uint32 unOpenSlots )
 {
     PRINT_DEBUG("Steam_Parties::ChangeNumOpenSlots\n");
+    return 0;
 }
 
 
@@ -150,6 +158,7 @@ SteamAPICall_t ChangeNumOpenSlots( PartyBeaconID_t ulBeacon, uint32 unOpenSlots
 bool DestroyBeacon( PartyBeaconID_t ulBeacon )
 {
     PRINT_DEBUG("Steam_Parties::DestroyBeacon\n");
+    return false;
 }
 
 
@@ -157,6 +166,7 @@ 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;
 }
 
 

dll/steam_remote_storage.h

@@ -405,11 +405,13 @@ 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;
 }
 
 
@@ -417,6 +419,7 @@ 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;
 }
 
 
@@ -460,11 +463,13 @@ 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;
 }
 
 
@@ -517,62 +522,74 @@ 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,
@@ -581,19 +598,30 @@ 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\n");
+    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));
+*/
 }
 
 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
@@ -614,6 +642,7 @@ 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 )
@@ -634,29 +663,34 @@ 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 )
@@ -683,24 +717,28 @@ 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
@@ -708,6 +746,7 @@ 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;
 }
 
 
@@ -715,6 +754,7 @@ 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;
 }
 
 };

dll/steam_user_stats.h

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