lsteamclient: Synthesize SDK version 0.99v

For SteamUser005.

lsteamclient/cppISteamUser_SteamUser005.cpp

@@ -0,0 +1,206 @@
+#include "steam_defs.h"
+#include "steamworks_sdk_099v/steam_api.h"
+#include "steamclient_private.h"
+#include "cppISteamUser_SteamUser005.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "struct_converters_099v.h"
+HSteamUser cppISteamUser_SteamUser005_GetHSteamUser(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->GetHSteamUser();
+}
+
+void cppISteamUser_SteamUser005_LogOn(void *linux_side, CSteamID steamID)
+{
+    ((ISteamUser*)linux_side)->LogOn((CSteamID)steamID);
+}
+
+void cppISteamUser_SteamUser005_LogOff(void *linux_side)
+{
+    ((ISteamUser*)linux_side)->LogOff();
+}
+
+bool cppISteamUser_SteamUser005_BLoggedOn(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->BLoggedOn();
+}
+
+ELogonState cppISteamUser_SteamUser005_GetLogonState(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->GetLogonState();
+}
+
+bool cppISteamUser_SteamUser005_BConnected(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->BConnected();
+}
+
+CSteamID cppISteamUser_SteamUser005_GetSteamID(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->GetSteamID();
+}
+
+bool cppISteamUser_SteamUser005_IsVACBanned(void *linux_side, int nGameID)
+{
+    return ((ISteamUser*)linux_side)->IsVACBanned((int)nGameID);
+}
+
+bool cppISteamUser_SteamUser005_RequireShowVACBannedMessage(void *linux_side, int nAppID)
+{
+    return ((ISteamUser*)linux_side)->RequireShowVACBannedMessage((int)nAppID);
+}
+
+void cppISteamUser_SteamUser005_AcknowledgeVACBanning(void *linux_side, int nAppID)
+{
+    ((ISteamUser*)linux_side)->AcknowledgeVACBanning((int)nAppID);
+}
+
+void cppISteamUser_SteamUser005_SetSteam2Ticket(void *linux_side, uint8 * pubTicket, int cubTicket)
+{
+    ((ISteamUser*)linux_side)->SetSteam2Ticket((uint8 *)pubTicket, (int)cubTicket);
+}
+
+void cppISteamUser_SteamUser005_AddServerNetAddress(void *linux_side, uint32 unIP, uint16 unPort)
+{
+    ((ISteamUser*)linux_side)->AddServerNetAddress((uint32)unIP, (uint16)unPort);
+}
+
+bool cppISteamUser_SteamUser005_SetEmail(void *linux_side, const char * pchEmail)
+{
+    return ((ISteamUser*)linux_side)->SetEmail((const char *)pchEmail);
+}
+
+bool cppISteamUser_SteamUser005_SetRegistryString(void *linux_side, EConfigSubTree eRegistrySubTree, const char * pchKey, const char * pchValue)
+{
+    return ((ISteamUser*)linux_side)->SetRegistryString((EConfigSubTree)eRegistrySubTree, (const char *)pchKey, (const char *)pchValue);
+}
+
+bool cppISteamUser_SteamUser005_GetRegistryString(void *linux_side, EConfigSubTree eRegistrySubTree, const char * pchKey, char * pchValue, int cbValue)
+{
+    return ((ISteamUser*)linux_side)->GetRegistryString((EConfigSubTree)eRegistrySubTree, (const char *)pchKey, (char *)pchValue, (int)cbValue);
+}
+
+bool cppISteamUser_SteamUser005_SetRegistryInt(void *linux_side, EConfigSubTree eRegistrySubTree, const char * pchKey, int iValue)
+{
+    return ((ISteamUser*)linux_side)->SetRegistryInt((EConfigSubTree)eRegistrySubTree, (const char *)pchKey, (int)iValue);
+}
+
+bool cppISteamUser_SteamUser005_GetRegistryInt(void *linux_side, EConfigSubTree eRegistrySubTree, const char * pchKey, int * piValue)
+{
+    return ((ISteamUser*)linux_side)->GetRegistryInt((EConfigSubTree)eRegistrySubTree, (const char *)pchKey, (int *)piValue);
+}
+
+int cppISteamUser_SteamUser005_InitiateGameConnection(void *linux_side, void * pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure)
+{
+    return ((ISteamUser*)linux_side)->InitiateGameConnection((void *)pBlob, (int)cbMaxBlob, (CSteamID)steamID, (CGameID)gameID, (uint32)unIPServer, (uint16)usPortServer, (bool)bSecure);
+}
+
+void cppISteamUser_SteamUser005_TerminateGameConnection(void *linux_side, uint32 unIPServer, uint16 usPortServer)
+{
+    ((ISteamUser*)linux_side)->TerminateGameConnection((uint32)unIPServer, (uint16)usPortServer);
+}
+
+void cppISteamUser_SteamUser005_SetSelfAsPrimaryChatDestination(void *linux_side)
+{
+    ((ISteamUser*)linux_side)->SetSelfAsPrimaryChatDestination();
+}
+
+bool cppISteamUser_SteamUser005_IsPrimaryChatDestination(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->IsPrimaryChatDestination();
+}
+
+void cppISteamUser_SteamUser005_RequestLegacyCDKey(void *linux_side, uint32 nAppID)
+{
+    ((ISteamUser*)linux_side)->RequestLegacyCDKey((uint32)nAppID);
+}
+
+bool cppISteamUser_SteamUser005_SendGuestPassByEmail(void *linux_side, const char * pchEmailAccount, GID_t gidGuestPassID, bool bResending)
+{
+    return ((ISteamUser*)linux_side)->SendGuestPassByEmail((const char *)pchEmailAccount, (GID_t)gidGuestPassID, (bool)bResending);
+}
+
+bool cppISteamUser_SteamUser005_SendGuestPassByAccountID(void *linux_side, uint32 uAccountID, GID_t gidGuestPassID, bool bResending)
+{
+    return ((ISteamUser*)linux_side)->SendGuestPassByAccountID((uint32)uAccountID, (GID_t)gidGuestPassID, (bool)bResending);
+}
+
+bool cppISteamUser_SteamUser005_AckGuestPass(void *linux_side, const char * pchGuestPassCode)
+{
+    return ((ISteamUser*)linux_side)->AckGuestPass((const char *)pchGuestPassCode);
+}
+
+bool cppISteamUser_SteamUser005_RedeemGuestPass(void *linux_side, const char * pchGuestPassCode)
+{
+    return ((ISteamUser*)linux_side)->RedeemGuestPass((const char *)pchGuestPassCode);
+}
+
+uint32 cppISteamUser_SteamUser005_GetGuestPassToGiveCount(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->GetGuestPassToGiveCount();
+}
+
+uint32 cppISteamUser_SteamUser005_GetGuestPassToRedeemCount(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->GetGuestPassToRedeemCount();
+}
+
+RTime32 cppISteamUser_SteamUser005_GetGuestPassLastUpdateTime(void *linux_side)
+{
+    return ((ISteamUser*)linux_side)->GetGuestPassLastUpdateTime();
+}
+
+bool cppISteamUser_SteamUser005_GetGuestPassToGiveInfo(void *linux_side, uint32 nPassIndex, GID_t * pgidGuestPassID, PackageId_t * pnPackageID, RTime32 * pRTime32Created, RTime32 * pRTime32Expiration, RTime32 * pRTime32Sent, RTime32 * pRTime32Redeemed, char * pchRecipientAddress, int cRecipientAddressSize)
+{
+    return ((ISteamUser*)linux_side)->GetGuestPassToGiveInfo((uint32)nPassIndex, (GID_t *)pgidGuestPassID, (PackageId_t *)pnPackageID, (RTime32 *)pRTime32Created, (RTime32 *)pRTime32Expiration, (RTime32 *)pRTime32Sent, (RTime32 *)pRTime32Redeemed, (char *)pchRecipientAddress, (int)cRecipientAddressSize);
+}
+
+bool cppISteamUser_SteamUser005_GetGuestPassToRedeemInfo(void *linux_side, uint32 nPassIndex, GID_t * pgidGuestPassID, PackageId_t * pnPackageID, RTime32 * pRTime32Created, RTime32 * pRTime32Expiration, RTime32 * pRTime32Sent, RTime32 * pRTime32Redeemed)
+{
+    return ((ISteamUser*)linux_side)->GetGuestPassToRedeemInfo((uint32)nPassIndex, (GID_t *)pgidGuestPassID, (PackageId_t *)pnPackageID, (RTime32 *)pRTime32Created, (RTime32 *)pRTime32Expiration, (RTime32 *)pRTime32Sent, (RTime32 *)pRTime32Redeemed);
+}
+
+bool cppISteamUser_SteamUser005_GetGuestPassToRedeemSenderAddress(void *linux_side, uint32 nPassIndex, char * pchSenderAddress, int cSenderAddressSize)
+{
+    return ((ISteamUser*)linux_side)->GetGuestPassToRedeemSenderAddress((uint32)nPassIndex, (char *)pchSenderAddress, (int)cSenderAddressSize);
+}
+
+bool cppISteamUser_SteamUser005_GetGuestPassToRedeemSenderName(void *linux_side, uint32 nPassIndex, char * pchSenderName, int cSenderNameSize)
+{
+    return ((ISteamUser*)linux_side)->GetGuestPassToRedeemSenderName((uint32)nPassIndex, (char *)pchSenderName, (int)cSenderNameSize);
+}
+
+void cppISteamUser_SteamUser005_AcknowledgeMessageByGID(void *linux_side, const char * pchMessageGID)
+{
+    ((ISteamUser*)linux_side)->AcknowledgeMessageByGID((const char *)pchMessageGID);
+}
+
+bool cppISteamUser_SteamUser005_SetLanguage(void *linux_side, const char * pchLanguage)
+{
+    return ((ISteamUser*)linux_side)->SetLanguage((const char *)pchLanguage);
+}
+
+void cppISteamUser_SteamUser005_TrackAppUsageEvent(void *linux_side, CGameID gameID, int eAppUsageEvent, const char * pchExtraInfo)
+{
+    ((ISteamUser*)linux_side)->TrackAppUsageEvent((CGameID)gameID, (int)eAppUsageEvent, (const char *)pchExtraInfo);
+}
+
+void cppISteamUser_SteamUser005_SetAccountName(void *linux_side, const char * pchAccountName)
+{
+    ((ISteamUser*)linux_side)->SetAccountName((const char *)pchAccountName);
+}
+
+void cppISteamUser_SteamUser005_SetPassword(void *linux_side, const char * pchPassword)
+{
+    ((ISteamUser*)linux_side)->SetPassword((const char *)pchPassword);
+}
+
+void cppISteamUser_SteamUser005_SetAccountCreationTime(void *linux_side, RTime32 rt)
+{
+    ((ISteamUser*)linux_side)->SetAccountCreationTime((RTime32)rt);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamUser_SteamUser005.h

@@ -0,0 +1,45 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern HSteamUser cppISteamUser_SteamUser005_GetHSteamUser(void *);
+extern void cppISteamUser_SteamUser005_LogOn(void *, CSteamID);
+extern void cppISteamUser_SteamUser005_LogOff(void *);
+extern bool cppISteamUser_SteamUser005_BLoggedOn(void *);
+extern ELogonState cppISteamUser_SteamUser005_GetLogonState(void *);
+extern bool cppISteamUser_SteamUser005_BConnected(void *);
+extern CSteamID cppISteamUser_SteamUser005_GetSteamID(void *);
+extern bool cppISteamUser_SteamUser005_IsVACBanned(void *, int);
+extern bool cppISteamUser_SteamUser005_RequireShowVACBannedMessage(void *, int);
+extern void cppISteamUser_SteamUser005_AcknowledgeVACBanning(void *, int);
+extern void cppISteamUser_SteamUser005_SetSteam2Ticket(void *, uint8 *, int);
+extern void cppISteamUser_SteamUser005_AddServerNetAddress(void *, uint32, uint16);
+extern bool cppISteamUser_SteamUser005_SetEmail(void *, const char *);
+extern bool cppISteamUser_SteamUser005_SetRegistryString(void *, EConfigSubTree, const char *, const char *);
+extern bool cppISteamUser_SteamUser005_GetRegistryString(void *, EConfigSubTree, const char *, char *, int);
+extern bool cppISteamUser_SteamUser005_SetRegistryInt(void *, EConfigSubTree, const char *, int);
+extern bool cppISteamUser_SteamUser005_GetRegistryInt(void *, EConfigSubTree, const char *, int *);
+extern int cppISteamUser_SteamUser005_InitiateGameConnection(void *, void *, int, CSteamID, CGameID, uint32, uint16, bool);
+extern void cppISteamUser_SteamUser005_TerminateGameConnection(void *, uint32, uint16);
+extern void cppISteamUser_SteamUser005_SetSelfAsPrimaryChatDestination(void *);
+extern bool cppISteamUser_SteamUser005_IsPrimaryChatDestination(void *);
+extern void cppISteamUser_SteamUser005_RequestLegacyCDKey(void *, uint32);
+extern bool cppISteamUser_SteamUser005_SendGuestPassByEmail(void *, const char *, GID_t, bool);
+extern bool cppISteamUser_SteamUser005_SendGuestPassByAccountID(void *, uint32, GID_t, bool);
+extern bool cppISteamUser_SteamUser005_AckGuestPass(void *, const char *);
+extern bool cppISteamUser_SteamUser005_RedeemGuestPass(void *, const char *);
+extern uint32 cppISteamUser_SteamUser005_GetGuestPassToGiveCount(void *);
+extern uint32 cppISteamUser_SteamUser005_GetGuestPassToRedeemCount(void *);
+extern RTime32 cppISteamUser_SteamUser005_GetGuestPassLastUpdateTime(void *);
+extern bool cppISteamUser_SteamUser005_GetGuestPassToGiveInfo(void *, uint32, GID_t *, PackageId_t *, RTime32 *, RTime32 *, RTime32 *, RTime32 *, char *, int);
+extern bool cppISteamUser_SteamUser005_GetGuestPassToRedeemInfo(void *, uint32, GID_t *, PackageId_t *, RTime32 *, RTime32 *, RTime32 *, RTime32 *);
+extern bool cppISteamUser_SteamUser005_GetGuestPassToRedeemSenderAddress(void *, uint32, char *, int);
+extern bool cppISteamUser_SteamUser005_GetGuestPassToRedeemSenderName(void *, uint32, char *, int);
+extern void cppISteamUser_SteamUser005_AcknowledgeMessageByGID(void *, const char *);
+extern bool cppISteamUser_SteamUser005_SetLanguage(void *, const char *);
+extern void cppISteamUser_SteamUser005_TrackAppUsageEvent(void *, CGameID, int, const char *);
+extern void cppISteamUser_SteamUser005_SetAccountName(void *, const char *);
+extern void cppISteamUser_SteamUser005_SetPassword(void *, const char *);
+extern void cppISteamUser_SteamUser005_SetAccountCreationTime(void *, RTime32);
+#ifdef __cplusplus
+}
+#endif

lsteamclient/gen_wrapper.py

@@ -76,6 +76,7 @@ sdk_versions = [
     "099y",
     "099x",
     "099w",
+    "099v",
     "next",
 ]
 

lsteamclient/steam_defs.h

@@ -65,7 +65,8 @@ typedef uint32_t EUserUGCList,
         EMatchMakingType,
         AudioPlayback_Status,
         ESteamUserStatType,
-        EConfigSubTree
+        EConfigSubTree,
+        ELogonState
 ;
 
 /* these are PODs, so just copy the data. hopefully the

lsteamclient/steamworks_sdk_099v/isteamapps.h

@@ -0,0 +1,38 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to app data in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMAPPS_H
+#define ISTEAMAPPS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: interface to app data
+//-----------------------------------------------------------------------------
+class ISteamApps
+{
+public:
+	// returns 0 if the key does not exist
+	// this may be true on first call, since the app data may not be cached locally yet
+	// If you expect it to exists wait for the AppDataChanged_t after the first failure and ask again
+	virtual int GetAppData( AppId_t nAppID, const char *pchKey, char *pchValue, int cchValueMax ) = 0;
+};
+
+#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION001"
+
+//-----------------------------------------------------------------------------
+// Purpose: called when new information about an app has arrived
+//-----------------------------------------------------------------------------
+struct AppDataChanged_t
+{
+	enum { k_iCallback = k_iSteamAppsCallbacks + 1 };
+	uint32	m_nAppID;		// appid that changed
+	bool	m_bBySteamUI;	// change came from SteamUI
+	bool	m_bCDDBUpdate;	// the cddb entry for this app changed
+};
+
+#endif // ISTEAMAPPS_H

lsteamclient/steamworks_sdk_099v/isteamclient.h

@@ -0,0 +1,137 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: Main interface for loading and accessing Steamworks API's from the 
+//			Steam client.
+//			For most uses, this code is wrapped inside of SteamAPI_Init()
+//=============================================================================
+
+#ifndef ISTEAMCLIENT_H
+#define ISTEAMCLIENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steamtypes.h"
+#include "steamclientpublic.h"
+
+// handle to a communication pipe to the Steam client
+typedef int32 HSteamPipe;
+// handle to single instance of a steam user
+typedef int32 HSteamUser;
+// function prototype
+#if defined( POSIX ) && !defined( _CYGWIN )
+#define __cdecl
+#endif
+extern "C" typedef void (__cdecl *SteamAPIWarningMessageHook_t)(int, const char *);
+
+// interface predec
+class ISteamUser;
+class ISteamGameServer;
+class ISteamFriends;
+class ISteamUtils;
+class ISteamMatchmaking;
+class ISteamContentServer;
+class ISteamMasterServerUpdater;
+class ISteamMatchmakingServers;
+class ISteamUserStats;
+class ISteamApps;
+class ISteamNetworking;
+
+//-----------------------------------------------------------------------------
+// Purpose: Interface to creating a new steam instance, or to
+//			connect to an existing steam instance, whether it's in a
+//			different process or is local.
+//
+//			For most scenarios this is all handled automatically via SteamAPI_Init().
+//			You'll only need to use these interfaces if you have a more complex versioning scheme,
+//			where you want to get different versions of the same interface in different dll's in your project.
+//-----------------------------------------------------------------------------
+class ISteamClient
+{
+public:
+	// Creates a communication pipe to the Steam client
+	virtual HSteamPipe CreateSteamPipe() = 0;
+
+	// Releases a previously created communications pipe
+	virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0;
+
+	virtual HSteamUser CreateGlobalUser( HSteamPipe *phSteamPipe ) = 0;
+
+	// connects to an existing global user, failing if none exists
+	// used by the game to coordinate with the steamUI
+	virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0;
+
+	// used by game servers, create a steam user that won't be shared with anyone else
+	virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe ) = 0;
+
+	// removes an allocated user
+	virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0;
+
+	// retrieves the ISteamUser interface associated with the handle
+	virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	virtual void *GetIVAC( HSteamUser hSteamUser ) = 0;
+
+	// retrieves the ISteamGameServer interface associated with the handle
+	virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// set the local IP and Port to bind to
+	// this must be set before CreateLocalUser()
+	virtual void SetLocalIPBinding( uint32 unIP, uint16 usPort ) = 0; 
+
+	virtual const char *GetUniverseName( EUniverse eUniverse ) = 0;
+
+	// returns the ISteamFriends interface
+	virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// returns the ISteamUtils interface
+	virtual ISteamUtils *GetISteamUtils( HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	virtual void *GetISteamBilling( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// returns the ISteamMatchmaking interface
+	virtual ISteamMatchmaking *GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	virtual ISteamApps *GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// returns the ISteamContentServer interface
+	virtual ISteamContentServer *GetISteamContentServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// returns the ISteamMasterServerUpdater interface
+	virtual ISteamMasterServerUpdater *GetISteamMasterServerUpdater( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// returns the ISteamMatchmakingServers interface
+	virtual ISteamMatchmakingServers *GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// this needs to be called every frame to process matchmaking results
+	// redundant if you're already calling SteamAPI_RunCallbacks()
+	virtual void RunFrame() = 0;
+
+	// returns the number of IPC calls made since the last time this function was called
+	// Used for perf debugging so you can understand how many IPC calls your game makes per frame
+	// Every IPC call is at minimum a thread context switch if not a process one so you want to rate
+	// control how often you do them.
+	virtual uint32 GetIPCCallCount() = 0;
+};
+
+#define STEAMCLIENT_INTERFACE_VERSION		"SteamClient006"
+
+//-----------------------------------------------------------------------------
+// Purpose: Base values for callback identifiers, each callback must
+//			have a unique ID.
+//-----------------------------------------------------------------------------
+enum { k_iSteamUserCallbacks = 100 };
+enum { k_iSteamGameServerCallbacks = 200 };
+enum { k_iSteamFriendsCallbacks = 300 };
+enum { k_iSteamBillingCallbacks = 400 };
+enum { k_iSteamMatchmakingCallbacks = 500 };
+enum { k_iSteamContentServerCallbacks = 600 };
+enum { k_iSteamUtilsCallbacks = 700 };
+enum { k_iClientFriendsCallbacks = 800 };
+enum { k_iClientUserCallbacks = 900 };
+enum { k_iSteamAppsCallbacks = 1000 };
+enum { k_iSteamUserStatsCallbacks = 1100 };
+enum { k_iSteamNetworkingCallbacks = 1200 };
+
+
+#endif // ISTEAMCLIENT_H

lsteamclient/steamworks_sdk_099v/isteamfriends.h

@@ -0,0 +1,167 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to both friends list data and general information about users
+//
+//=============================================================================
+
+#ifndef ISTEAMFRIENDS_H
+#define ISTEAMFRIENDS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: set of relationships to other users
+//-----------------------------------------------------------------------------
+enum EFriendRelationship
+{
+	k_EFriendRelationshipNone = 0,
+	k_EFriendRelationshipBlocked = 1,
+	k_EFriendRelationshipRequestRecipient = 2,
+	k_EFriendRelationshipFriend = 3,
+	k_EFriendRelationshipRequestInitiator = 4,
+	k_EFriendRelationshipIgnored = 5,
+	k_EFriendRelationshipIgnoredFriend = 6,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: list of states a friend can be in
+//-----------------------------------------------------------------------------
+enum EPersonaState
+{
+	k_EPersonaStateOffline = 0,			// friend is not currently logged on
+	k_EPersonaStateOnline = 1,			// friend is logged on
+	k_EPersonaStateBusy = 2,			// user is on, but busy
+	k_EPersonaStateAway = 3,			// auto-away feature
+	k_EPersonaStateSnooze = 4,			// auto-away for a long time
+	k_EPersonaStateMax,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: flags for enumerating friends list, or quickly checking a the relationship between users
+//-----------------------------------------------------------------------------
+enum k_EFriendFlags
+{
+	k_EFriendFlagNone			= 0x00,
+	k_EFriendFlagBlocked		= 0x01,
+	k_EFriendFlagFriendshipRequested	= 0x02,
+	k_EFriendFlagImmediate		= 0x04,			// "regular" friend
+	k_EFriendFlagClanMember		= 0x08,
+	k_EFriendFlagOnGameServer	= 0x10,	
+	// k_EFriendFlagHasPlayedWith	= 0x20,	// not currently used
+	// k_EFriendFlagFriendOfFriend	= 0x40, // not currently used
+	k_EFriendFlagRequestingFriendship = 0x80,
+	k_EFriendFlagRequestingInfo = 0x100,
+	k_EFriendFlagIgnored		= 0x200,
+	k_EFriendFlagIgnoredFriend	= 0x400,
+	k_EFriendFlagAll			= 0xFFFF,
+};
+
+// maximum number of characters in a users name
+enum { k_cchPersonaNameMax = 128 };
+
+// size limit on chat room or member metadata
+const uint32 k_cubChatMetadataMax = 4096;
+
+//-----------------------------------------------------------------------------
+// Purpose: interface to accessing information about individual users,
+//			that can be a friend, in a group, on a game server or in a lobby with the local user
+//-----------------------------------------------------------------------------
+class ISteamFriends
+{
+public:
+	// returns the local players name - guaranteed to not be NULL.
+	// this is the same name as on the users community profile page
+	// this is stored in UTF-8 format
+	// like all the other interface functions that return a char *, it's important that this pointer is not saved
+	// off; it will eventually be free'd or re-allocated
+	virtual const char *GetPersonaName() = 0;
+	
+	virtual void SetPersonaName( const char *pchPersonaName ) = 0;
+	virtual EPersonaState GetPersonaState() = 0;
+	virtual void SetPersonaState( EPersonaState ePersonaState ) = 0;
+	virtual bool AddFriend( CSteamID steamIDFriend ) = 0;
+	virtual bool RemoveFriend( CSteamID steamIDFriend ) = 0;
+	virtual bool HasFriend( CSteamID steamIDFriend ) = 0;
+	virtual EFriendRelationship GetFriendRelationship( CSteamID steamIDFriend ) = 0;
+	virtual EPersonaState GetFriendPersonaState( CSteamID steamIDFriend ) = 0;
+	virtual bool Deprecated_GetFriendGamePlayed( CSteamID steamIDFriend, int32 *pnGameID, uint32 *punGameIP, uint16 *pusGamePort ) = 0;
+	virtual const char *GetFriendPersonaName( CSteamID steamIDFriend ) = 0;
+	virtual int32 AddFriendByName( const char *pchEmailOrAccountName ) = 0;
+	virtual int GetFriendCount() = 0;
+	virtual CSteamID GetFriendByIndex( int iFriend ) = 0;
+	virtual void SendMsgToFriend( CSteamID steamIDFriend, EChatEntryType eChatEntryType, const char *pchMsgBody ) = 0;
+	virtual void SetFriendRegValue( CSteamID steamIDFriend, const char *pchKey, const char *pchValue ) = 0;
+	virtual const char *GetFriendRegValue( CSteamID steamIDFriend, const char *pchKey ) = 0;
+	virtual const char *GetFriendPersonaNameHistory( CSteamID steamIDFriend, int iPersonaName ) = 0;
+	virtual int GetChatMessage( CSteamID steamIDFriend, int iChatID, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0;
+
+	virtual bool SendMsgToFriend( CSteamID steamIDFriend, EChatEntryType eChatEntryType, const void *pvMsgBody, int cubMsgBody ) = 0;
+	virtual int GetChatIDOfChatHistoryStart( CSteamID steamIDFriend ) = 0;
+	virtual void SetChatHistoryStart( CSteamID steamIDFriend, int iChatID ) = 0;
+	virtual void ClearChatHistory( CSteamID steamIDFriend ) = 0;
+	virtual bool InviteFriendByEmail( const char *pchEmailAccount ) = 0;
+	virtual int GetBlockedFriendCount() = 0;
+	virtual bool GetFriendGamePlayed( CSteamID steamIDFriend, uint64 *pulGameID, uint32 *punGameIP, uint16 *pusGamePort ) = 0;
+	virtual bool GetFriendGamePlayed2( CSteamID steamIDFriend, uint64 *pulGameID, uint32 *punGameIP, uint16 *pusGamePort, uint16 *pusQueryPort ) = 0;
+};
+
+#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends001"
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a friends' status changes
+//-----------------------------------------------------------------------------
+struct PersonaStateChange_t
+{
+	enum { k_iCallback = k_iSteamFriendsCallbacks + 4 };
+	
+	uint64 m_ulSteamID;		// steamID of the friend who changed
+	int m_nChangeFlags;		// what's changed
+};
+
+
+// used in PersonaStateChange_t::m_nChangeFlags to describe what's changed about a user
+// these flags describe what the client has learned has changed recently, so on startup you'll see a name, avatar & relationship change for every friend
+enum EPersonaChange
+{
+	k_EPersonaChangeName		= 0x001,
+	k_EPersonaChangeStatus		= 0x002,
+	k_EPersonaChangeComeOnline	= 0x004,
+	k_EPersonaChangeGoneOffline	= 0x008,
+	k_EPersonaChangeGamePlayed	= 0x010,
+	k_EPersonaChangeGameServer	= 0x020,
+	k_EPersonaChangeAvatar		= 0x040,
+	k_EPersonaChangeJoinedSource= 0x080,
+	k_EPersonaChangeLeftSource	= 0x100,
+	k_EPersonaChangeRelationshipChanged = 0x200,
+	k_EPersonaChangeNameFirstSet = 0x400,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: posted when game overlay activates or deactivates
+//			the game can use this to be pause or resume single player games
+//-----------------------------------------------------------------------------
+struct GameOverlayActivated_t
+{
+	enum { k_iCallback = k_iSteamFriendsCallbacks + 31 };
+	uint8 m_bActive;	// true if it's just been activated, false otherwise
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the user tries to join a different game server from their friends list
+//			game client should attempt to connect to specified server when this is received
+//-----------------------------------------------------------------------------
+struct GameServerChangeRequested_t
+{
+	enum { k_iCallback = k_iSteamFriendsCallbacks + 32 };
+	char m_rgchServer[64];		// server address ("127.0.0.1:27015", "tf2.valvesoftware.com")
+	char m_rgchPassword[64];	// server password, if any
+};
+
+#endif // ISTEAMFRIENDS_H

lsteamclient/steamworks_sdk_099v/isteamgameserver.h

@@ -0,0 +1,110 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam for game servers
+//
+//=============================================================================
+
+#ifndef ISTEAMGAMESERVER_H
+#define ISTEAMGAMESERVER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for authenticating users via Steam to play on a game server
+//-----------------------------------------------------------------------------
+class ISteamGameServer
+{
+public:
+	virtual void LogOn() = 0;
+	virtual void LogOff() = 0;
+	virtual bool BLoggedOn() = 0;
+	virtual void GSSetSpawnCount( uint32 ucSpawn ) = 0;
+	virtual bool GSGetSteam2GetEncryptionKeyToSendToNewClient( void *pvEncryptionKey, uint32 *pcbEncryptionKey, uint32 cbMaxEncryptionKey ) = 0;
+	virtual bool GSSendSteam2UserConnect(  uint32 unUserID, const void *pvRawKey, uint32 unKeyLen, uint32 unIPPublic, uint16 usPort, const void *pvCookie, uint32 cubCookie ) = 0;
+	virtual bool GSSendSteam3UserConnect( CSteamID steamID, uint32 unIPPublic, const void *pvCookie, uint32 cubCookie ) = 0;
+	virtual bool GSRemoveUserConnect( uint32 unUserID ) = 0;
+	virtual bool GSSendUserDisconnect( CSteamID steamID, uint32 unUserID ) = 0;
+	virtual bool GSSendUserStatusResponse( CSteamID steamID, int nSecondsConnected, int nSecondsSinceLast ) = 0;
+	virtual bool Obsolete_GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax, int cBotPlayers, int unGamePort, const char *pchServerName, const char *pchGameDir, const char *pchMapName, const char *pchVersion ) = 0;
+	virtual bool GSUpdateStatus( int cPlayers, int cPlayersMax, int cBotPlayers, const char *pchServerName, const char *pchMapName ) = 0;
+	virtual bool BSecure() = 0;
+	virtual CSteamID GetSteamID() = 0;
+	virtual bool GSSetServerType( int32 nGameAppId, uint32 unServerFlags, uint32 unGameIP, uint32 unGamePort, const char *pchGameDir, const char *pchVersion ) = 0;
+	virtual bool GSSetServerType2( int32 nGameAppId, uint32 unServerFlags, uint32 unGameIP, uint16 unGamePort, uint16 unSpectatorPort, uint16 usQueryPort, const char *pchGameDir, const char *pchVersion, bool bLANMode ) = 0;
+	virtual bool GSUpdateStatus2( int cPlayers, int cPlayersMax, int cBotPlayers, const char *pchServerName, const char *pSpectatorServerName, const char *pchMapName ) = 0;
+	virtual bool GSCreateUnauthenticatedUser( CSteamID *pSteamID ) = 0;
+	virtual bool GSSetUserData( CSteamID steamID, const char *pPlayerName, uint32 nFrags ) = 0;
+	virtual void GSUpdateSpectatorPort( uint16 unSpectatorPort ) = 0;
+	virtual void GSSetGameType( const char *pchType ) = 0;
+};
+
+#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer002"
+
+// game server flags
+const uint32 k_unServerFlagNone			= 0x00;
+const uint32 k_unServerFlagActive		= 0x01;		// server has users playing
+const uint32 k_unServerFlagSecure		= 0x02;		// server wants to be secure
+const uint32 k_unServerFlagDedicated	= 0x04;		// server is dedicated
+const uint32 k_unServerFlagLinux		= 0x08;		// linux build
+const uint32 k_unServerFlagPassworded	= 0x10;		// password protected
+const uint32 k_unServerFlagPrivate		= 0x20;		// server shouldn't list on master server and
+													// won't enforce authentication of users that connect to the server.
+													// Useful when you run a server where the clients may not
+													// be connected to the internet but you want them to play (i.e LANs)
+
+
+
+// callbacks
+
+
+// client has been approved to connect to this game server
+struct GSClientApprove_t
+{
+	enum { k_iCallback = k_iSteamGameServerCallbacks + 1 };
+	CSteamID m_SteamID;
+};
+
+
+// client has been denied to connection to this game server
+struct GSClientDeny_t
+{
+	enum { k_iCallback = k_iSteamGameServerCallbacks + 2 };
+	CSteamID m_SteamID;
+	EDenyReason m_eDenyReason;
+	char m_rgchOptionalText[128];
+};
+
+
+// request the game server should kick the user
+struct GSClientKick_t
+{
+	enum { k_iCallback = k_iSteamGameServerCallbacks + 3 };
+	CSteamID m_SteamID;
+	EDenyReason m_eDenyReason;
+};
+
+// NOTE: callback values 4 and 5 are skipped because they are used for old deprecated callbacks, 
+// do not reuse them here.
+
+// client achievement info
+struct GSClientAchievementStatus_t
+{
+	enum { k_iCallback = k_iSteamGameServerCallbacks + 6 };
+	uint64 m_SteamID;
+	char m_pchAchievement[128];
+	bool m_bUnlocked;
+};
+
+
+// received when the game server requests to be displayed as secure (VAC protected)
+// m_bSecure is true if the game server should display itself as secure to users, false otherwise
+struct GSPolicyResponse_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 15 };
+	uint8 m_bSecure;
+};
+
+#endif // ISTEAMGAMESERVER_H

lsteamclient/steamworks_sdk_099v/isteammasterserverupdater.h

@@ -0,0 +1,103 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam for retrieving list of game servers
+//
+//=============================================================================
+
+#ifndef ISTEAMMASTERSERVERUPDATER_H
+#define ISTEAMMASTERSERVERUPDATER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+#define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE	((uint16)-1)
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Game engines use this to tell the Steam master servers
+// about their games so their games can show up in the server browser.
+//-----------------------------------------------------------------------------
+class ISteamMasterServerUpdater
+{
+public:
+
+	// Call this as often as you like to tell the master server updater whether or not
+	// you want it to be active (default: off).
+	virtual void SetActive( bool bActive ) = 0;
+
+	// You usually don't need to modify this.
+	// Pass -1 to use the default value for iHeartbeatInterval.
+	// Some mods change this.
+	virtual void SetHeartbeatInterval( int iHeartbeatInterval ) = 0;
+
+
+// These are in GameSocketShare mode, where instead of ISteamMasterServerUpdater creating its own
+// socket to talk to the master server on, it lets the game use its socket to forward messages
+// back and forth. This prevents us from requiring server ops to open up yet another port
+// in their firewalls.
+//
+// the IP address and port should be in host order, i.e 127.0.0.1 == 0x7f000001
+	
+	// These are used when you've elected to multiplex the game server's UDP socket
+	// rather than having the master server updater use its own sockets.
+	// 
+	// Source games use this to simplify the job of the server admins, so they 
+	// don't have to open up more ports on their firewalls.
+	
+	// Call this when a packet that starts with 0xFFFFFFFF comes in. That means
+	// it's for us.
+	virtual bool HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) = 0;
+
+	// AFTER calling HandleIncomingPacket for any packets that came in that frame, call this.
+	// This gets a packet that the master server updater needs to send out on UDP.
+	// It returns the length of the packet it wants to send, or 0 if there are no more packets to send.
+	// Call this each frame until it returns 0.
+	virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0;
+
+
+// Functions to set various fields that are used to respond to queries.
+	
+	// Call this to set basic data that is passed to the server browser.
+	virtual void SetBasicServerData(
+		unsigned short nProtocolVersion,
+		bool bDedicatedServer,
+		const char *pRegionName,
+		const char *pProductName,
+		unsigned short nMaxReportedClients,
+		bool bPasswordProtected,
+		const char *pGameDescription ) = 0;
+
+	// Call this to clear the whole list of key/values that are sent in rules queries.
+	virtual void ClearAllKeyValues() = 0;
+	
+	// Call this to add/update a key/value pair.
+	virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0;
+
+
+	// You can call this upon shutdown to clear out data stored for this game server and
+	// to tell the master servers that this server is going away.
+	virtual void NotifyShutdown() = 0;
+
+	// Returns true if the master server has requested a restart.
+	// Only returns true once per request.
+	virtual bool WasRestartRequested() = 0;
+
+	// Force it to request a heartbeat from the master servers.
+	virtual void ForceHeartbeat() = 0;
+	
+	// Manually edit and query the master server list.
+	// It will provide name resolution and use the default master server port if none is provided.
+	virtual bool AddMasterServer( const char *pServerAddress ) = 0;
+	virtual bool RemoveMasterServer( const char *pServerAddress ) = 0;
+
+	virtual int GetNumMasterServers() = 0;
+	
+	// Returns the # of bytes written to pOut.
+	virtual int GetMasterServerAddress( int iServer, char *pOut, int outBufferSize ) = 0;
+};
+
+#define STEAMMASTERSERVERUPDATER_INTERFACE_VERSION "SteamMasterServerUpdater001"
+
+#endif // ISTEAMMASTERSERVERUPDATER_H

lsteamclient/steamworks_sdk_099v/isteammatchmaking.h

@@ -0,0 +1,435 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam managing game server/client match making
+//
+//=============================================================================
+
+#ifndef ISTEAMMATCHMAKING
+#define ISTEAMMATCHMAKING
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steamtypes.h"
+#include "steamclientpublic.h"
+#include "matchmakingtypes.h" 
+#include "isteamclient.h"
+#include "isteamfriends.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for match making services for clients to get to favorites
+//			and to operate on game lobbies.
+//-----------------------------------------------------------------------------
+class ISteamMatchmaking
+{
+public:
+	// game server favorites storage
+	// saves basic details about a multiplayer game server locally
+
+	// returns the number of favorites servers the user has stored
+	virtual int GetFavoriteGameCount() = 0;
+	
+	// returns the details of the game server
+	// iGame is of range [0,GetFavoriteGameCount())
+	// *pnIP, *pnConnPort are filled in the with IP:port of the game server
+	// *punFlags specify whether the game server was stored as an explicit favorite or in the history of connections
+	// *pRTime32LastPlayedOnServer is filled in the with the Unix time the favorite was added
+	virtual bool GetFavoriteGame( int iGame, uint32 *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint32 *punFlags, uint32 *pRTime32LastPlayedOnServer ) = 0;
+
+	// adds the game server to the local list; updates the time played of the server if it already exists in the list
+	virtual int AddFavoriteGame( uint32 nAppID, uint32 nIP, uint16 nConnPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer ) = 0;
+	
+	// removes the game server from the local storage; returns true if one was removed
+	virtual bool RemoveFavoriteGame( uint32 nAppID, uint32 nIP, uint16 nConnPort, uint32 unFlags ) = 0;
+
+	virtual bool GetFavoriteGame2( int iGame, uint32 *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint16 *pnQueryPort, uint32 *punFlags, uint32 *pRTime32LastPlayedOnServer ) = 0;
+	virtual int AddFavoriteGame2( uint32 nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer ) = 0;
+	virtual bool RemoveFavoriteGame2( uint32 nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags ) = 0;
+
+	///////
+	// Game lobby functions
+	virtual void RequestLobbyList( uint64 ulGameID, MatchMakingKeyValuePair_t *pFilters, uint32 nFilters ) = 0;
+
+	virtual CSteamID GetLobbyByIndex( int iLobby ) = 0;
+	virtual void CreateLobby( uint64 ulGameID, bool bPrivate ) = 0;
+	virtual void JoinLobby( CSteamID steamIDLobby ) = 0;
+	virtual void LeaveLobby( CSteamID steamIDLobby ) = 0;
+	virtual bool InviteUserToLobby( CSteamID steamIDLobby, CSteamID steamIDInvitee ) = 0;
+	virtual int GetNumLobbyMembers( CSteamID steamIDLobby ) = 0;
+	virtual CSteamID GetLobbyMemberByIndex( CSteamID steamIDLobby, int iMember ) = 0;
+
+	virtual const char *GetLobbyData( CSteamID SteamIDLobby, const char *pchKey ) = 0;
+
+	// Sets a key/value pair in the lobby metadata
+	// each user in the lobby will be broadcast this new value, and any new users joining will receive any existing data
+	// this can be used to set lobby names, map, etc.
+	// to reset a key, just set it to ""
+	// other users in the lobby will receive notification of the lobby data change via a LobbyDataUpdate_t callback
+	virtual bool SetLobbyData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) = 0;
+
+	// As above, but gets per-user data for someone in this lobby
+	virtual const char *GetLobbyMemberData( CSteamID steamIDLobby, CSteamID steamIDUser, const char *pchKey ) = 0;
+	// Sets per-user metadata (for the local user implicitly)
+	virtual bool SetLobbyMemberData( CSteamID steamIDLobby, const char *pchKey, const char *pchValue ) = 0;
+	
+	// Broadcasts a chat message to the all the users in the lobby
+	// users in the lobby (including the local user) will receive a LobbyChatMsg_t callback
+	// returns true if the message is successfully sent
+	virtual bool SendLobbyChatMsg( CSteamID steamIDLobby, const void *pvMsgBody, int cubMsgBody ) = 0;
+	// Get a chat message as specified in a LobbyChatMsg_t callback
+	// iChatID is the LobbyChatMsg_t::m_iChatID value in the callback
+	// *pSteamIDUser is filled in with the CSteamID of the member
+	// *pvData is filled in with the message itself
+	// return value is the number of bytes written into the buffer
+	virtual int GetLobbyChatEntry( CSteamID steamIDLobby, int iChatID, CSteamID *pSteamIDUser, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0;
+
+	// Fetch metadata for a lobby you're not necessarily in right now
+	// this will send down all the metadata associated with a lobby
+	// this is an asynchronous call
+	// returns false if the local user is not connected to the Steam servers
+	virtual bool RequestLobbyData( CSteamID steamIDLobby ) = 0;
+
+};
+#define STEAMMATCHMAKING_INTERFACE_VERSION "SteamMatchMaking001"
+
+
+//-----------------------------------------------------------------------------
+// Callback interfaces for server list functions (see ISteamMatchmakingServers below)
+//
+// The idea here is that your game code implements objects that implement these
+// interfaces to receive callback notifications after calling asynchronous functions
+// inside the ISteamMatchmakingServers() interface below.
+//
+// This is different than normal Steam callback handling due to the potentially
+// large size of server lists.
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after a server list refresh
+// or an individual server update.
+//
+// Since you get these callbacks after requesting full list refreshes you will
+// usually implement this interface inside an object like CServerBrowser.  If that
+// object is getting destructed you should use ISteamMatchMakingServers()->CancelQuery()
+// to cancel any in-progress queries so you don't get a callback into the destructed
+// object and crash.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingServerListResponse
+{
+public:
+	// Server has responded ok with updated data
+	virtual void ServerResponded( int iServer ) = 0; 
+
+	// Server has failed to respond
+	virtual void ServerFailedToRespond( int iServer ) = 0; 
+
+	// A list refresh you had initiated is now 100% completed
+	virtual void RefreshComplete( EMatchMakingServerResponse response ) = 0; 
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after pinging an individual server 
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->PingServer() call below.  If you are 
+// destructing an object that implements this interface then you should call 
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress.  Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingPingResponse
+{
+public:
+	// Server has responded successfully and has updated data
+	virtual void ServerResponded( gameserveritem_t &server ) = 0;
+
+	// Server failed to respond to the ping request
+	virtual void ServerFailedToRespond() = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after requesting details on
+// who is playing on a particular server.
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->PlayerDetails() call below.  If you are 
+// destructing an object that implements this interface then you should call 
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress.  Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingPlayersResponse
+{
+public:
+	// Got data on a new player on the server -- you'll get this callback once per player
+	// on the server which you have requested player data on.
+	virtual void AddPlayerToList( const char *pchName, int nScore, float flTimePlayed ) = 0;
+
+	// The server failed to respond to the request for player details
+	virtual void PlayersFailedToRespond() = 0;
+
+	// The server has finished responding to the player details request 
+	// (ie, you won't get anymore AddPlayerToList callbacks)
+	virtual void PlayersRefreshComplete() = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback interface for receiving responses after requesting rules
+// details on a particular server.
+//
+// These callbacks all occur in response to querying an individual server
+// via the ISteamMatchmakingServers()->ServerRules() call below.  If you are 
+// destructing an object that implements this interface then you should call 
+// ISteamMatchmakingServers()->CancelServerQuery() passing in the handle to the query
+// which is in progress.  Failure to cancel in progress queries when destructing
+// a callback handler may result in a crash when a callback later occurs.
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingRulesResponse
+{
+public:
+	// Got data on a rule on the server -- you'll get one of these per rule defined on
+	// the server you are querying
+	virtual void RulesResponded( const char *pchRule, const char *pchValue ) = 0;
+
+	// The server failed to respond to the request for rule details
+	virtual void RulesFailedToRespond() = 0;
+
+	// The server has finished responding to the rule details request 
+	// (ie, you won't get anymore RulesResponded callbacks)
+	virtual void RulesRefreshComplete() = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Typedef for handle type you will receive when querying details on an individual server.
+//-----------------------------------------------------------------------------
+typedef int HServerQuery;
+const int HSERVERQUERY_INVALID = 0xffffffff;
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for match making services for clients to get to game lists and details
+//-----------------------------------------------------------------------------
+class ISteamMatchmakingServers
+{
+public:
+	// Request a new list of servers of a particular type.  These calls each correspond to one of the EMatchMakingType values.
+	virtual void RequestInternetServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual void RequestLANServerList( AppId_t iApp, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual void RequestFriendsServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual void RequestFavoritesServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual void RequestHistoryServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+	virtual void RequestSpectatorServerList( AppId_t iApp, MatchMakingKeyValuePair_t **ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse ) = 0;
+
+	// Get details on a given server in the list, you can get the valid range of index
+	// values by calling GetServerCount().  You will also receive index values in 
+	// ISteamMatchmakingServerListResponse::ServerResponded() callbacks
+	virtual gameserveritem_t *GetServerDetails( EMatchMakingType eType, int iServer ) = 0; 
+
+	// Cancel an request which is operation on the given list type.  You should call this to cancel
+	// any in-progress requests before destructing a callback object that may have been passed 
+	// to one of the above list request calls.  Not doing so may result in a crash when a callback
+	// occurs on the destructed object.
+	virtual void CancelQuery( EMatchMakingType eType ) = 0; 
+
+	// Ping every server in your list again but don't update the list of servers
+	virtual void RefreshQuery( EMatchMakingType eType ) = 0; 
+
+	// Returns true if the list is currently refreshing its server list
+	virtual bool IsRefreshing( EMatchMakingType eType ) = 0; 
+
+	// How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1
+	virtual int GetServerCount( EMatchMakingType eType ) = 0; 
+
+	// Refresh a single server inside of a query (rather than all the servers )
+	virtual void RefreshServer( EMatchMakingType eType, int iServer ) = 0; 
+
+
+	//-----------------------------------------------------------------------------
+	// Queries to individual servers directly via IP/Port
+	//-----------------------------------------------------------------------------
+
+	// Request updated ping time and other details from a single server
+	virtual HServerQuery PingServer( uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse ) = 0; 
+
+	// Request the list of players currently playing on a server
+	virtual HServerQuery PlayerDetails( uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse ) = 0;
+
+	// Request the list of rules that the server is running (See ISteamMasterServerUpdater->SetKeyValue() to set the rules server side)
+	virtual HServerQuery ServerRules( uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse ) = 0; 
+
+	// Cancel an outstanding Ping/Players/Rules query from above.  You should call this to cancel
+	// any in-progress requests before destructing a callback object that may have been passed 
+	// to one of the above calls to avoid crashing when callbacks occur.
+	virtual void CancelServerQuery( HServerQuery hServerQuery ) = 0; 
+};
+#define STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION "SteamMatchMakingServers001"
+
+//-----------------------------------------------------------------------------
+// Callbacks for ISteamMatchmaking which go through the regular Steam callback registration system
+//-----------------------------------------------------------------------------
+
+// game server flags
+const uint32 k_unFavoriteFlagNone			= 0x00;
+const uint32 k_unFavoriteFlagFavorite		= 0x01; // this game favorite entry is for the favorites list
+const uint32 k_unFavoriteFlagHistory		= 0x02; // this game favorite entry is for the history list
+
+// callbacks
+
+
+//-----------------------------------------------------------------------------
+// Purpose: a server was added/removed from the favorites list, you should refresh now
+//-----------------------------------------------------------------------------
+struct FavoritesListChanged_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 2 };
+	uint32 m_nIP; // an IP of 0 means reload the whole list, any other value means just one server
+	uint32 m_nQueryPort;
+	uint32 m_nConnPort;
+	uint32 m_nAppID;
+	uint32 m_nFlags;
+	bool m_bAdd; // true if this is adding the entry, otherwise it is a remove
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Someone has invited you to join a Lobby
+//-----------------------------------------------------------------------------
+struct LobbyInvite_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 3 };
+
+	uint64 m_ulSteamIDUser;		// Steam ID of the person making the invite
+	uint64 m_ulSteamIDLobby;	// Steam ID of the Lobby
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sent on entering a Lobby
+//			m_EChatRoomEnterResponse will be set to k_EChatRoomEnterResponseSuccess on success,
+//			or a higher value on failure (see enum EChatRoomEnterResponse)
+//-----------------------------------------------------------------------------
+struct LobbyEnter_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 4 };
+
+	uint64 m_ulSteamIDLobby;							// SteamID of the Lobby you have entered
+	uint32 m_rgfChatPermissions;						// Permissions of the current user
+	bool m_bLocked;										// If true, then only invited users may join
+	uint32 m_EChatRoomEnterResponse;	// EChatRoomEnterResponse
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The lobby metadata has changed
+//			if m_ulSteamIDMember is the steamID of a lobby member, use GetLobbyMemberData() to access per-user details
+//			if m_ulSteamIDMember == m_ulSteamIDLobby, use GetLobbyData() to access lobby metadata
+//-----------------------------------------------------------------------------
+struct LobbyDataUpdate_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 5 };
+
+	uint64 m_ulSteamIDLobby;		// steamID of the Lobby
+	uint64 m_ulSteamIDMember;		// steamID of the member whose data changed, or the room itself
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The lobby chat room state has changed
+//			this is usually sent when a user has joined or left the lobby
+//-----------------------------------------------------------------------------
+struct LobbyChatUpdate_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 6 };
+
+	uint64 m_ulSteamIDLobby;			// Lobby ID
+	uint64 m_ulSteamIDUserChanged;		// user who's status in the lobby just changed - can be recipient
+	uint64 m_ulSteamIDMakingChange;		// Chat member who made the change (different from SteamIDUserChange if kicking, muting, etc.)
+										// for example, if one user kicks another from the lobby, this will be set to the id of the user who initiated the kick
+	uint32 m_rgfChatMemberStateChange;	// bitfield of EChatMemberStateChange values
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A chat message for this lobby has been sent
+//			use GetLobbyChatEntry( m_iChatID ) to retrieve the contents of this message
+//-----------------------------------------------------------------------------
+struct LobbyChatMsg_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 7 };
+
+	uint64 m_ulSteamIDLobby;			// the lobby id this is in
+	uint64 m_ulSteamIDUser;			// steamID of the user who has sent this message
+	uint8 m_eChatEntryType;			// type of message
+	uint32 m_iChatID;				// index of the chat entry to lookup
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A game created a game for all the members of the lobby to join,
+//			as triggered by a SetLobbyGameServer()
+//			it's up to the individual clients to take action on this; the usual
+//			game behavior is to leave the lobby and connect to the specified game server
+//-----------------------------------------------------------------------------
+struct LobbyGameCreated_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 9 };
+
+	uint64 m_ulSteamIDLobby;		// the lobby we were in
+	uint64 m_ulSteamIDGameServer;	// the new game server that has been created or found for the lobby members
+	uint32 m_unIP;					// IP & Port of the game server (if any)
+	uint16 m_usPort;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Number of matching lobbies found
+//			iterate the returned lobbies with GetLobbyByIndex(), from values 0 to m_nLobbiesMatching-1
+//-----------------------------------------------------------------------------
+struct LobbyMatchList_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 10 };
+	uint32 m_nLobbiesMatching;		// Number of lobbies that matched search criteria and we have SteamIDs for
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the lobby is being forcefully closed
+//			lobby details functions will no longer be updated
+//-----------------------------------------------------------------------------
+struct LobbyClosing_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 11 };
+	uint64 m_ulSteamIDLobby;			// Lobby
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the local user has been kicked from the lobby
+//			lobby details functions will no longer be updated
+//-----------------------------------------------------------------------------
+struct LobbyKicked_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 12 };
+	uint64 m_ulSteamIDLobby;			// Lobby
+	uint64 m_ulSteamIDAdmin;			// User who kicked you
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Result of our request to create a Lobby
+//			m_eResult == k_EResultOK on success
+//			at this point, the local user may not have finishing joining this lobby;
+//			game code should wait until the subsequent LobbyEnter_t callback is received
+//-----------------------------------------------------------------------------
+struct LobbyCreated_t
+{
+	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 13 };
+	EResult m_eResult;				// Result
+	uint64 m_ulSteamIDLobby;		// chat room, zero if failed
+};
+
+#endif // ISTEAMMATCHMAKING

lsteamclient/steamworks_sdk_099v/isteamnetworking.h

@@ -0,0 +1,135 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam managing network connections between game clients & servers
+//
+//=============================================================================
+
+#ifndef ISTEAMNETWORKING
+#define ISTEAMNETWORKING
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steamtypes.h"
+#include "steamclientpublic.h"
+
+// handle to a socket
+typedef uint32 SNetSocket_t;
+typedef uint32 SNetListenSocket_t;
+
+
+// connection progress indicators
+enum ESNetSocketState
+{
+	k_ESNetSocketStateInvalid = 0,						
+
+	// communication is valid
+	k_ESNetSocketStateConnected = 1,				
+	
+	// states while establishing a connection
+	k_ESNetSocketStateInitiated = 10,				// the connection state machine has started
+
+	// p2p connections
+	k_ESNetSocketStateLocalCandidatesFound = 11,	// we've found our local IP info
+	k_ESNetSocketStateReceivedRemoteCandidates = 12,// we've received information from the remote machine, via the Steam back-end, about their IP info
+
+	// direct connections
+	k_ESNetSocketStateChallengeHandshake = 15,		// we've received a challenge packet from the server
+
+	// failure states
+	k_ESNetSocketStateDisconnecting = 21,			// the API shut it down, and we're in the process of telling the other end	
+	k_ESNetSocketStateLocalDisconnect = 22,			// the API shut it down, and we've completed shutdown
+	k_ESNetSocketStateTimeoutDuringConnect = 23,	// we timed out while trying to creating the connection
+	k_ESNetSocketStateRemoteEndDisconnected = 24,	// the remote end has disconnected from us
+	k_ESNetSocketStateConnectionBroken = 25,		// connection has been broken; either the other end has disappeared or our local network connection has broke
+
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for making connections and sending data between clients,
+//			traversing NAT's where possible
+//-----------------------------------------------------------------------------
+class ISteamNetworking
+{
+public:
+	// creates a socket and listens others to connect
+	// will trigger a SocketStatusCallback_t callback on another client connecting
+	// nVirtualP2PPort is the unique ID that the client will connect to, in case you have multiple ports
+	//		this can usually just be 0 unless you want multiple sets of connections
+	// unIP is the local IP address to bind to
+	//		pass in 0 if you just want the default local IP
+	// unPort is the port to use
+	//		pass in 0 if you don't want users to be able to connect via IP/Port, but expect to be always peer-to-peer connections only
+	virtual SNetListenSocket_t CreateListenSocket( int nVirtualP2PPort, uint32 nIP, uint16 nPort ) = 0;
+
+	// creates a socket and begin connection to a remote destination
+	// can connect via a known steamID (client or game server), or directly to an IP
+	// on success will trigger a SocketConnectCallback_t callback
+	// on failure or timeout will trigger a SocketConnectionFailureCallback_t callback
+	virtual SNetSocket_t CreateP2PConnectionSocket( CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec ) = 0;
+	virtual SNetSocket_t CreateConnectionSocket( uint32 nIP, uint16 nPort, int nTimeoutSec ) = 0;
+
+	// disconnects the connection to the socket, if any, and invalidates the handle
+	// any unread data on the socket will be thrown away
+	// if bNotifyRemoteEnd is set, socket will not be completely destroyed until the remote end acknowledges the disconnect
+	virtual bool DestroySocket( SNetSocket_t hSocket, bool bNotifyRemoteEnd ) = 0;
+	// destroying a listen socket will automatically kill all the regular sockets generated from it
+	virtual bool DestroyListenSocket( SNetListenSocket_t hSocket, bool bNotifyRemoteEnd ) = 0;
+
+	// sending data
+	// must be a handle to a connected socket
+	// data size cannot be more than 8k, although in UDP mode (default),
+	// it's recommended packets be no larger than 1300 bytes
+	// use the reliable flag with caution; although the resend rate is pretty aggressive,
+	// it can still cause stalls in receiving data (like TCP)
+	virtual bool SendDataOnSocket( SNetSocket_t hSocket, void *pubData, uint32 cubData, bool bReliable ) = 0;
+
+	// receiving data
+	// returns false if there is no data remaining
+	// fills out *pcubMsgSize with the size of the next message, in bytes
+	virtual bool IsDataAvailableOnSocket( SNetSocket_t hSocket, uint32 *pcubMsgSize ) = 0; 
+
+	// fills in pubDest with the contents of the message
+	// messages are always complete, of the same size as was sent (i.e. packetized, not streaming)
+	// if *pcubMsgSize < cubDest, only partial data is written
+	// returns false if no data is available
+	virtual bool RetrieveDataFromSocket( SNetSocket_t hSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize ) = 0; 
+
+	// checks for data from any socket that has been connected off this listen socket
+	// returns false if there is no data remaining
+	// fills out *pcubMsgSize with the size of the next message, in bytes
+	// fills out *phSocket with the socket that data is available on
+	virtual bool IsDataAvailable( SNetListenSocket_t hListenSocket, uint32 *pcubMsgSize, SNetSocket_t *phSocket ) = 0;
+
+	// retrieves data from any socket that has been connected off this listen socket
+	// fills in pubDest with the contents of the message
+	// messages are always complete, of the same size as was sent (i.e. packetized, not streaming)
+	// if *pcubMsgSize < cubDest, only partial data is written
+	// returns false if no data is available
+	// fills out *phSocket with the socket that data is available on
+	virtual bool RetrieveData( SNetListenSocket_t hListenSocket, void *pubDest, uint32 cubDest, uint32 *pcubMsgSize, SNetSocket_t *phSocket ) = 0;
+
+	// returns information about the specified socket, filling out the contents of the pointers
+	virtual bool GetSocketInfo( SNetSocket_t hSocket, CSteamID *pSteamIDRemote, int *peSocketStatus, uint32 *punIPRemote, uint16 *punPortRemote ) = 0;
+
+	// returns which local port the listen socket is bound to
+	// *pnIP and *pnPort will be 0 if the socket is set to listen for P2P connections only
+	virtual bool GetListenSocketInfo( SNetListenSocket_t hListenSocket, uint32 *pnIP, uint16 *pnPort ) = 0;
+	
+};
+#define STEAMNETWORKING_INTERFACE_VERSION "SteamNetworking001"
+
+
+// callback notification - status of a socket has changed
+struct SocketStatusCallback_t
+{ 
+	enum { k_iCallback = k_iSteamNetworkingCallbacks + 1 };
+	SNetSocket_t m_hSocket;				// the socket used to send/receive data to the remote host
+	SNetListenSocket_t m_hListenSocket;	// this is the server socket that we were listening on; NULL if this was an outgoing connection
+	CSteamID m_steamIDRemote;			// remote steamID we have connected to, if it has one
+	int m_eSNetSocketState;				// socket state, ESNetSocketState
+};
+
+
+#endif // ISTEAMNETWORKING

lsteamclient/steamworks_sdk_099v/isteamuser.h

@@ -0,0 +1,153 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to user account information in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMUSER_H
+#define ISTEAMUSER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+// structure that contains client callback data
+// see callbacks documentation for more details
+struct CallbackMsg_t
+{
+	HSteamUser m_hSteamUser;
+	int m_iCallback;
+	uint8 *m_pubParam;
+	int m_cubParam;
+};
+
+// reference to a steam call, to filter results by
+typedef int32 HSteamCall;
+enum EConfigSubTree {
+    EConfigSubTree_stub
+};
+
+enum ELogonState {
+    ELogonState_stub
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing and manipulating a steam account
+//			associated with one client instance
+//-----------------------------------------------------------------------------
+class ISteamUser
+{
+public:
+	virtual HSteamUser GetHSteamUser() = 0;
+	virtual void LogOn( CSteamID steamID ) = 0;
+	virtual void LogOff() = 0;
+	virtual bool BLoggedOn() = 0;
+	virtual ELogonState GetLogonState() = 0;
+	virtual bool BConnected() = 0;
+	virtual CSteamID GetSteamID() = 0;
+	virtual bool IsVACBanned( int nGameID ) = 0;
+	virtual bool RequireShowVACBannedMessage( int nAppID ) = 0;
+	virtual void AcknowledgeVACBanning( int nAppID ) = 0;
+	virtual void SetSteam2Ticket( uint8 *pubTicket, int cubTicket ) = 0;
+	virtual void AddServerNetAddress( uint32 unIP, uint16 unPort ) = 0;
+	virtual bool SetEmail( const char *pchEmail ) = 0;
+	virtual bool SetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, const char *pchValue ) = 0;
+	virtual bool GetRegistryString( EConfigSubTree eRegistrySubTree, const char *pchKey, char *pchValue, int cbValue ) = 0;
+	virtual bool SetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int iValue ) = 0;
+	virtual bool GetRegistryInt( EConfigSubTree eRegistrySubTree, const char *pchKey, int *piValue ) = 0;
+	virtual int InitiateGameConnection( void *pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
+	virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
+	virtual void SetSelfAsPrimaryChatDestination() = 0;
+	virtual bool IsPrimaryChatDestination() = 0;
+	virtual void RequestLegacyCDKey( uint32 nAppID ) = 0;
+	virtual bool SendGuestPassByEmail( const char *pchEmailAccount, GID_t gidGuestPassID, bool bResending ) = 0;
+	virtual bool SendGuestPassByAccountID( uint32 uAccountID, GID_t gidGuestPassID, bool bResending ) = 0;
+	virtual bool AckGuestPass(const char *pchGuestPassCode) = 0;
+	virtual bool RedeemGuestPass(const char *pchGuestPassCode) = 0;
+	virtual uint32 GetGuestPassToGiveCount() = 0;
+	virtual uint32 GetGuestPassToRedeemCount() = 0;
+	virtual RTime32 GetGuestPassLastUpdateTime() = 0;
+	virtual bool GetGuestPassToGiveInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed, char *pchRecipientAddress, int cRecipientAddressSize ) = 0;
+	virtual bool GetGuestPassToRedeemInfo( uint32 nPassIndex, GID_t *pgidGuestPassID, PackageId_t *pnPackageID, RTime32 *pRTime32Created, RTime32 *pRTime32Expiration, RTime32 *pRTime32Sent, RTime32 *pRTime32Redeemed) = 0;
+	virtual bool GetGuestPassToRedeemSenderAddress( uint32 nPassIndex, char* pchSenderAddress, int cSenderAddressSize ) = 0;
+	virtual bool GetGuestPassToRedeemSenderName( uint32 nPassIndex, char* pchSenderName, int cSenderNameSize ) = 0;
+	virtual void AcknowledgeMessageByGID( const char *pchMessageGID ) = 0;
+	virtual bool SetLanguage( const char *pchLanguage ) = 0;
+	virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
+	virtual void SetAccountName( const char *pchAccountName ) = 0;
+	virtual void SetPassword( const char *pchPassword ) = 0;
+	virtual void SetAccountCreationTime( RTime32 rt ) = 0;
+};
+
+#define STEAMUSER_INTERFACE_VERSION "SteamUser005"
+
+
+// callbacks
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a connections to the Steam back-end has been established
+//			this means the Steam client now has a working connection to the Steam servers
+//			usually this will have occurred before the game has launched, and should
+//			only be seen if the user has dropped connection due to a networking issue
+//			or a Steam server update
+//-----------------------------------------------------------------------------
+struct SteamServersConnected_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 1 };
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: called when a connection attempt has failed
+//			this will occur periodically if the Steam client is not connected, 
+//			and has failed in it's retry to establish a connection
+//-----------------------------------------------------------------------------
+struct SteamServerConnectFailure_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 2 };
+	EResult m_eResult;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called if the client has lost connection to the Steam servers
+//			real-time services will be disabled until a matching SteamServersConnected_t has been posted
+//-----------------------------------------------------------------------------
+struct SteamServersDisconnected_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 3 };
+	EResult m_eResult;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sent by the Steam server to the client telling it to disconnect from the specified game server,
+//			which it may be in the process of or already connected to.
+//			The game client should immediately disconnect upon receiving this message.
+//			This can usually occur if the user doesn't have rights to play on the game server.
+//-----------------------------------------------------------------------------
+struct ClientGameServerDeny_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 13 };
+
+	uint32 m_uAppID;
+	uint32 m_unGameServerIP;
+	uint16 m_usGameServerPort;
+	uint16 m_bSecure;
+	uint32 m_uReason;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the callback system for this client is in an error state (and has flushed pending callbacks)
+//			When getting this message the client should disconnect from Steam, reset any stored Steam state and reconnect.
+//			This usually occurs in the rare event the Steam client has some kind of fatal error.
+//-----------------------------------------------------------------------------
+struct CallbackPipeFailure_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 17 };
+};
+
+
+#endif // ISTEAMUSER_H

lsteamclient/steamworks_sdk_099v/isteamuserstats.h

@@ -0,0 +1,87 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to user account information in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMUSERSTATS_H
+#define ISTEAMUSERSTATS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+// size limit on stat or achievement name
+const uint32 k_cchStatNameMax = 128;
+
+class ISteamUserStats
+{
+public:
+       virtual uint32 GetNumStats( CGameID nGameID ) = 0;
+       virtual const char *GetStatName( CGameID nGameID, uint32 iStat ) = 0;
+       virtual ESteamUserStatType GetStatType( CGameID nGameID, const char *pchName ) = 0;
+       virtual uint32 GetNumAchievements( CGameID nGameID ) = 0;
+       virtual const char *GetAchievementName( CGameID nGameID, uint32 iAchievement ) = 0;
+       virtual uint32 GetNumGroupAchievements( CGameID nGameID ) = 0;
+       virtual const char *GetGroupAchievementName( CGameID nGameID, uint32 iAchievement ) = 0;
+       virtual bool RequestCurrentStats( CGameID nGameID ) = 0;
+       virtual bool GetStat( CGameID nGameID, const char *pchName, int32 *pData ) = 0;
+       virtual bool GetStat( CGameID nGameID, const char *pchName, float *pData ) = 0;
+       virtual bool SetStat( CGameID nGameID, const char *pchName, int32 nData ) = 0;
+       virtual bool SetStat( CGameID nGameID, const char *pchName, float fData ) = 0;
+       virtual bool UpdateAvgRateStat( CGameID nGameID, const char *pchName, float flCountThisSession, double dSessionLength ) = 0;
+       virtual bool GetAchievement( CGameID nGameID, const char *pchName, bool *pbAchieved ) = 0;
+       virtual bool GetGroupAchievement( CGameID nGameID, const char *pchName, bool *pbAchieved ) = 0;
+       virtual bool SetAchievement( CGameID nGameID, const char *pchName ) = 0;
+       virtual bool SetGroupAchievement( CGameID nGameID, const char *pchName ) = 0;
+       virtual bool StoreStats( CGameID nGameID ) = 0;
+       virtual bool ClearAchievement( CGameID nGameID, const char *pchName ) = 0;
+       virtual bool ClearGroupAchievement( CGameID nGameID, const char *pchName ) = 0;
+       virtual int GetAchievementIcon( CGameID nGameID, const char *pchName ) = 0;
+       virtual const char *GetAchievementDisplayAttribute( CGameID nGameID, const char *pchName, const char *pchKey ) = 0;
+};
+
+
+#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION001"
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the latests stats and achievements have been received
+//			from the server
+//-----------------------------------------------------------------------------
+struct UserStatsReceived_t
+{
+	enum { k_iCallback = k_iSteamUserStatsCallbacks + 1 };
+	uint64		m_nGameID;		// Game these stats are for
+	EResult		m_eResult;		// Success / error fetching the stats
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: result of a request to store the user stats for a game
+//-----------------------------------------------------------------------------
+struct UserStatsStored_t
+{
+	enum { k_iCallback = k_iSteamUserStatsCallbacks + 2 };
+	uint64		m_nGameID;		// Game these stats are for
+	EResult		m_eResult;		// success / error
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: result of a request to store the achievements for a game, or an 
+//			"indicate progress" call. If both m_nCurProgress and m_nMaxProgress
+//			are zero, that means the achievement has been fully unlocked.
+//-----------------------------------------------------------------------------
+struct UserAchievementStored_t
+{
+	enum { k_iCallback = k_iSteamUserStatsCallbacks + 3 };
+
+	uint64		m_nGameID;				// Game this is for
+	bool		m_bGroupAchievement;	// if this is a "group" achievement
+	char		m_rgchAchievementName[k_cchStatNameMax];		// name of the achievement
+	uint32		m_nCurProgress;			// current progress towards the achievement
+	uint32		m_nMaxProgress;			// "out of" this many
+};
+
+
+#endif // ISTEAMUSER_H

lsteamclient/steamworks_sdk_099v/isteamutils.h

@@ -0,0 +1,77 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to utility functions in Steam
+//
+//=============================================================================
+
+#ifndef ISTEAMUTILS_H
+#define ISTEAMUTILS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: interface to user independent utility functions
+//-----------------------------------------------------------------------------
+class ISteamUtils
+{
+public:
+	// return the number of seconds since the user 
+	virtual uint32 GetSecondsSinceAppActive() = 0;
+	virtual uint32 GetSecondsSinceComputerActive() = 0;
+
+	// the universe this client is connecting to
+	virtual EUniverse GetConnectedUniverse() = 0;
+
+	// Steam server time - in PST, number of seconds since January 1, 1970 (i.e unix time)
+	virtual uint32 GetServerRealTime() = 0;
+
+	// returns the 2 digit ISO 3166-1-alpha-2 format country code this client is running in (as looked up via an IP-to-location database)
+	// e.g "US" or "UK".
+	virtual const char *GetIPCountry() = 0;
+
+	// returns true if the image exists, and valid sizes were filled out
+	virtual bool GetImageSize( int iImage, uint32 *pnWidth, uint32 *pnHeight ) = 0;
+
+	// returns true if the image exists, and the buffer was successfully filled out
+	// results are returned in RGBA format
+	// the destination buffer size should be 4 * height * width * sizeof(char)
+	virtual bool GetImageRGBA( int iImage, uint8 *pubDest, int nDestBufferSize ) = 0;
+
+	// returns the IP of the reporting server for valve - currently only used in Source engine games
+	virtual bool GetCSERIPPort( uint32 *unIP, uint16 *usPort ) = 0;
+
+	// return the amount of battery power left in the current system in % [0..100], 255 for being on AC power
+	virtual uint8 GetCurrentBatteryPower() = 0;
+
+	// returns the appID of the current process
+	virtual uint32 GetAppID() = 0;
+};
+
+#define STEAMUTILS_INTERFACE_VERSION "SteamUtils002"
+
+
+// callbacks
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The country of the user changed
+//-----------------------------------------------------------------------------
+struct IPCountry_t
+{
+	enum { k_iCallback = k_iSteamUtilsCallbacks + 1 };
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fired when running on a laptop and less than 10 minutes of battery is left, fires then every minute
+//-----------------------------------------------------------------------------
+struct LowBatteryPower_t
+{
+	enum { k_iCallback = k_iSteamUtilsCallbacks + 2 };
+	uint8 m_nMinutesBatteryLeft;
+};
+
+#endif // ISTEAMUTILS_H

lsteamclient/steamworks_sdk_099v/matchmakingtypes.h

@@ -0,0 +1,239 @@
+//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef MATCHMAKINGTYPES_H
+#define MATCHMAKINGTYPES_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#ifdef POSIX
+#define _snprintf snprintf
+#endif
+
+struct MatchMakingKeyValuePair_t
+{
+	MatchMakingKeyValuePair_t() { m_szKey[0] = m_szValue[0] = 0; }
+	MatchMakingKeyValuePair_t( const char *pchKey, const char *pchValue )
+	{
+		strncpy( m_szKey, pchKey, sizeof(m_szKey) ); // this is a public header, use basic c library string funcs only!
+		strncpy( m_szValue, pchValue, sizeof(m_szValue) );
+	}
+	char m_szKey[ 256 ];
+	char m_szValue[ 256 ];
+};
+
+
+enum EMatchMakingServerResponse
+{
+	eServerResponded = 0,
+	eServerFailedToRespond,
+	eNoServersListedOnMasterServer // for the Internet query type, returned in response callback if no servers of this type match
+};
+
+enum EMatchMakingType
+{
+	eInternetServer = 0,
+	eLANServer,
+	eFriendsServer,
+	eFavoritesServer,
+	eHistoryServer,
+	eSpectatorServer,
+	eInvalidServer 
+};
+
+
+// servernetadr_t is all the addressing info the serverbrowser needs to know about a game server,
+// namely: its IP, its connection port, and its query port.
+class servernetadr_t 
+{
+public:
+	
+	void	Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort );
+#ifdef NETADR_H
+	void	Init( const netadr_t &ipAndQueryPort, uint16 usConnectionPort );
+	netadr_t& GetIPAndQueryPort();
+#endif
+	
+	// Access the query port.
+	uint16	GetQueryPort() const;
+	void	SetQueryPort( uint16 usPort );
+
+	// Access the connection port.
+	uint16	GetConnectionPort() const;
+	void	SetConnectionPort( uint16 usPort );
+
+	// Access the IP
+	uint32 GetIP() const;
+	void SetIP( uint32 );
+
+	// This gets the 'a.b.c.d:port' string with the connection port (instead of the query port).
+	const char *GetConnectionAddressString() const;
+	const char *GetQueryAddressString() const;
+
+	// Comparison operators and functions.
+	bool	operator<(const servernetadr_t &netadr) const;
+	void operator=( const servernetadr_t &that )
+	{
+		m_usConnectionPort = that.m_usConnectionPort;
+		m_usQueryPort = that.m_usQueryPort;
+		m_unIP = that.m_unIP;
+	}
+
+	
+private:
+	const char *ToString( uint32 unIP, uint16 usPort ) const;
+	uint16	m_usConnectionPort;	// (in HOST byte order)
+	uint16	m_usQueryPort;
+	uint32  m_unIP;
+};
+
+
+inline void	servernetadr_t::Init( unsigned int ip, uint16 usQueryPort, uint16 usConnectionPort )
+{
+	m_unIP = ip;
+	m_usQueryPort = usQueryPort;
+	m_usConnectionPort = usConnectionPort;
+}
+
+#ifdef NETADR_H
+inline void	servernetadr_t::Init( const netadr_t &ipAndQueryPort, uint16 usConnectionPort )
+{
+	Init( ipAndQueryPort.GetIP(), ipAndQueryPort.GetPort(), usConnectionPort );
+}
+
+inline netadr_t& servernetadr_t::GetIPAndQueryPort()
+{
+	static netadr_t netAdr;
+	netAdr.SetIP( m_unIP );
+	netAdr.SetPort( m_usQueryPort );
+	return netAdr;
+}
+#endif
+
+inline uint16 servernetadr_t::GetQueryPort() const
+{
+	return m_usQueryPort;
+}
+
+inline void	servernetadr_t::SetQueryPort( uint16 usPort )
+{
+	m_usQueryPort = usPort;
+}
+
+inline uint16 servernetadr_t::GetConnectionPort() const
+{
+	return m_usConnectionPort;
+}
+
+inline void	servernetadr_t::SetConnectionPort( uint16 usPort )
+{
+	m_usConnectionPort = usPort;
+}
+
+inline uint32 servernetadr_t::GetIP() const
+{
+	return m_unIP;
+}
+
+inline void	servernetadr_t::SetIP( uint32 unIP )
+{
+	m_unIP = unIP;
+}
+
+inline const char *servernetadr_t::ToString( uint32 unIP, uint16 usPort ) const
+{
+	static char s[4][64];
+	static int nBuf = 0;
+	unsigned char *ipByte = (unsigned char *)&unIP;
+	_snprintf (s[nBuf], sizeof( s[nBuf] ), "%u.%u.%u.%u:%i", (int)(ipByte[3]), (int)(ipByte[2]), (int)(ipByte[1]), (int)(ipByte[0]), usPort );
+	const char *pchRet = s[nBuf];
+	++nBuf;
+	nBuf %= ( (sizeof(s)/sizeof(s[0])) );
+	return pchRet;
+}
+
+inline const char* servernetadr_t::GetConnectionAddressString() const
+{
+	return ToString( m_unIP, m_usConnectionPort );
+}
+
+inline const char* servernetadr_t::GetQueryAddressString() const
+{
+	return ToString( m_unIP, m_usQueryPort );	
+}
+
+inline bool servernetadr_t::operator<(const servernetadr_t &netadr) const
+{
+	return ( m_unIP < netadr.m_unIP ) || ( m_unIP == netadr.m_unIP && m_usQueryPort < netadr.m_usQueryPort );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Data describing a single server
+//-----------------------------------------------------------------------------
+class gameserveritem_t
+{
+public:
+	gameserveritem_t();
+
+	const char* GetName() const;
+	void SetName( const char *pName );
+
+public:
+	servernetadr_t m_NetAdr;		// IP/Query Port/Connection Port for this server
+	int m_nPing;					// current ping time in milliseconds
+	bool m_bHadSuccessfulResponse;	// server has responded successfully in the past
+	bool m_bDoNotRefresh;			// server is marked as not responding and should no longer be refreshed
+	char m_szGameDir[32];			// current game directory
+	char m_szMap[32];				// current map
+	char m_szGameDescription[64];	// game description
+	int m_nAppID;					// Steam App ID of this server
+	int m_nPlayers;					// current number of players on the server
+	int m_nMaxPlayers;				// Maximum players that can join this server
+	int m_nBotPlayers;				// Number of bots (i.e simulated players) on this server
+	bool m_bPassword;				// true if this server needs a password to join
+	bool m_bSecure;					// Is this server protected by VAC
+	uint32 m_ulTimeLastPlayed;		// time (in unix time) when this server was last played on (for favorite/history servers)
+	int	m_nServerVersion;			// server version as reported to Steam
+
+private:
+	char m_szServerName[64];		//  Game server name
+
+	// For data added after SteamMatchMaking001 add it here
+public:
+	char m_szGameTags[128];			// the tags this server exposes
+};
+
+
+inline gameserveritem_t::gameserveritem_t()
+{
+	m_szGameDir[0] = m_szMap[0] = m_szGameDescription[0] = m_szServerName[0] = 0;
+	m_bHadSuccessfulResponse = m_bDoNotRefresh = m_bPassword = m_bSecure = false;
+	m_nPing = m_nAppID = m_nPlayers = m_nMaxPlayers = m_nBotPlayers = m_ulTimeLastPlayed = m_nServerVersion = 0;
+	m_szGameTags[0] = 0;
+}
+
+inline const char* gameserveritem_t::GetName() const
+{
+	// Use the IP address as the name if nothing is set yet.
+	if ( m_szServerName[0] == 0 )
+		return m_NetAdr.GetConnectionAddressString();
+	else
+		return m_szServerName;
+}
+
+inline void gameserveritem_t::SetName( const char *pName )
+{
+	strncpy( m_szServerName, pName, sizeof( m_szServerName ) );
+}
+
+
+#endif // MATCHMAKINGTYPES_H

lsteamclient/steamworks_sdk_099v/steam_api.h

@@ -0,0 +1,308 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef STEAM_API_H
+#define STEAM_API_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+#include "isteamuser.h"
+#include "isteamfriends.h"
+#include "isteamutils.h"
+#include "isteammatchmaking.h"
+#include "isteamuserstats.h"
+#include "isteamapps.h"
+#include "isteamnetworking.h"
+
+// Steam API export macro
+#if defined( _WIN32 ) && !defined( _X360 )
+	#if defined( STEAM_API_EXPORTS )
+	#define S_API extern "C" __declspec( dllexport ) 
+	#elif defined( STEAM_API_NODLL )
+	#define S_API extern "C"
+	#else
+	#define S_API extern "C" __declspec( dllimport ) 
+	#endif // STEAM_API_EXPORTS
+#elif defined( _LINUX )
+	#if defined( STEAM_API_EXPORTS )
+	#define S_API extern "C" __attribute__ ((visibility("default"))) 
+	#else
+	#define S_API extern "C" 
+	#endif // STEAM_API_EXPORTS
+#else // !WIN32
+	#if defined( STEAM_API_EXPORTS )
+	#define S_API extern "C"  
+	#else
+	#define S_API extern "C" 
+	#endif // STEAM_API_EXPORTS
+#endif
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+//	Steam API setup & shutdown
+//
+//	These functions manage loading, initializing and shutdown of the steamclient.dll
+//
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+// S_API void SteamAPI_Init(); (see below)
+S_API void SteamAPI_Shutdown();
+
+// crash dump recording functions
+S_API void SteamAPI_WriteMiniDump( uint32 uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID );
+S_API void SteamAPI_SetMiniDumpComment( const char *pchMsg );
+
+// interface pointers, configured by SteamAPI_Init()
+S_API ISteamClient *SteamClient();
+
+
+//
+// VERSION_SAFE_STEAM_API_INTERFACES is usually not necessary, but it provides safety against releasing
+// new steam_api.dll's without recompiling/rereleasing modules that use it.
+//
+// If you use VERSION_SAFE_STEAM_API_INTERFACES, then you should call SteamAPI_InitSafe(). Also, to get the 
+// Steam interfaces, you must create and Init() a CSteamAPIContext (below) and use the interfaces in there.
+//
+// If you don't use VERSION_SAFE_STEAM_API_INTERFACES, then you can use SteamAPI_Init() and the SteamXXXX() 
+// functions below to get at the Steam interfaces.
+//
+#ifdef VERSION_SAFE_STEAM_API_INTERFACES
+S_API bool SteamAPI_InitSafe();
+#else
+S_API bool SteamAPI_Init();
+
+S_API ISteamUser *SteamUser();
+S_API ISteamFriends *SteamFriends();
+S_API ISteamUtils *SteamUtils();
+S_API ISteamMatchmaking *SteamMatchmaking();
+S_API ISteamUserStats *SteamUserStats();
+S_API ISteamApps *SteamApps();
+S_API ISteamNetworking *SteamNetworking();
+S_API ISteamMatchmakingServers *SteamMatchmakingServers();
+#endif // VERSION_SAFE_STEAM_API_INTERFACES
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+//	steam callback helper functions
+//
+//	The following classes/macros are used to be able to easily multiplex callbacks 
+//	from the Steam API into various objects in the app in a thread-safe manner
+//
+//	These functors are triggered via the SteamAPI_RunCallbacks() function, mapping the callback
+//  to as many functions/objects as are registered to it
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+S_API void SteamAPI_RunCallbacks();
+
+
+
+// functions used by the utility CCallback objects to receive callbacks
+S_API void SteamAPI_RegisterCallback( class CCallbackBase *pCallback, int iCallback );
+S_API void SteamAPI_UnregisterCallback( class CCallbackBase *pCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: base for callbacks, 
+//			used only by CCallback, shouldn't be used directly
+//-----------------------------------------------------------------------------
+class CCallbackBase
+{
+public:
+	CCallbackBase() { m_nCallbackFlags = 0; }
+	// don't add a virtual destructor because we export this binary interface across dll's
+	virtual void Run( void *pvParam ) = 0;
+
+protected:
+	enum { k_ECallbackFlagsRegistered = 0x01, k_ECallbackFlagsGameServer = 0x02 };
+	uint8 m_nCallbackFlags;
+private:
+	int m_iCallback;
+	friend class CCallbackMgr;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: maps a steam callback to a class member function
+//			template params: T = local class, P = parameter struct
+//-----------------------------------------------------------------------------
+template< class T, class P, bool bGameServer >
+class CCallback : private CCallbackBase
+{
+public:
+	typedef void (T::*func_t)( P* );
+
+	// If you can't support constructing a callback with the correct parameters
+	// then uncomment the empty constructor below and manually call
+	// ::Register() for your object
+	//CCallback() {}
+	
+	// constructor for initializing this object in owner's constructor
+	CCallback( T *pObj, func_t func ) : m_pObj( pObj ), m_Func( func )
+	{
+		if ( bGameServer )
+		{
+			m_nCallbackFlags |= k_ECallbackFlagsGameServer;
+		}
+
+		Register( pObj, func );
+	}
+
+	~CCallback()
+	{
+		SteamAPI_UnregisterCallback( this );
+	}
+
+	// manual registration of the callback
+	void Register( T *pObj, func_t func )
+	{
+		m_pObj = pObj;
+		m_Func = func;
+		SteamAPI_RegisterCallback( this, P::k_iCallback );
+	}
+
+private:
+	virtual void Run( void *pvParam )
+	{
+		(m_pObj->*m_Func)( (P *)pvParam );
+	}
+
+	T *m_pObj;
+	func_t m_Func;
+};
+
+
+// utility macro for declaring the function and callback object together
+#define STEAM_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, false > var; void func( param *pParam )
+
+
+#ifdef _WIN32
+// disable this warning; this pattern need for steam callback registration
+#pragma warning( disable: 4355 )	// 'this' : used in base member initializer list
+#endif
+
+
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+//	steamclient.dll private wrapper functions
+//
+//	The following functions are part of abstracting API access to the steamclient.dll, but should only be used in very specific cases
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+// pumps out all the steam messages, calling the register callback
+S_API void Steam_RunCallbacks( HSteamPipe hSteamPipe, bool bGameServerCallbacks );
+
+// register the callback funcs to use to interact with the steam dll
+S_API void Steam_RegisterInterfaceFuncs( void *hModule );
+
+// returns the HSteamUser of the last user to dispatch a callback
+S_API HSteamUser Steam_GetHSteamUserCurrent();
+
+// returns the filename path of the current running Steam process, used if you need to load an explicit steam dll by name
+S_API const char *SteamAPI_GetSteamInstallPath();
+
+
+#ifdef VERSION_SAFE_STEAM_API_INTERFACES
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// VERSION_SAFE_STEAM_API_INTERFACES uses CSteamAPIContext to provide interfaces to each module in a way that 
+// lets them each specify the interface versions they are compiled with.
+//
+// It's important that these stay inlined in the header so the calling module specifies the interface versions
+// for whatever Steam API version it has.
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+
+S_API HSteamPipe GetHSteamPipe();
+S_API HSteamUser GetHSteamUser();
+
+class CSteamAPIContext
+{
+public:
+	CSteamAPIContext();
+	void Clear();
+
+	bool Init();
+
+	ISteamUser*			SteamUser()							{ return m_pSteamUser; }
+	ISteamFriends*		SteamFriends()						{ return m_pSteamFriends; }
+	ISteamUtils*		SteamUtils()						{ return m_pSteamUtils; }
+	ISteamMatchmaking*	SteamMatchmaking()					{ return m_pSteamMatchmaking; }
+	ISteamUserStats*	SteamUserStats()					{ return m_pSteamUserStats; }
+	ISteamApps*			SteamApps()							{ return m_pSteamApps; }
+	ISteamMatchmakingServers*	SteamMatchmakingServers()	{ return m_pSteamMatchmakingServers; }
+	ISteamNetworking*	SteamNetworking()					{ return m_pSteamNetworking; }
+
+private:
+	ISteamUser		*m_pSteamUser;
+	ISteamFriends	*m_pSteamFriends;
+	ISteamUtils		*m_pSteamUtils;
+	ISteamMatchmaking	*m_pSteamMatchmaking;
+	ISteamUserStats		*m_pSteamUserStats;
+	ISteamApps			*m_pSteamApps;
+	ISteamMatchmakingServers	*m_pSteamMatchmakingServers;
+	ISteamNetworking	*m_pSteamNetworking;
+};
+
+inline CSteamAPIContext::CSteamAPIContext()
+{
+	Clear();
+}
+
+inline void CSteamAPIContext::Clear()
+{
+	m_pSteamUser = NULL;
+	m_pSteamFriends = NULL;
+	m_pSteamUtils = NULL;
+	m_pSteamMatchmaking = NULL;
+	m_pSteamUserStats = NULL;
+	m_pSteamApps = NULL;
+	m_pSteamMatchmakingServers = NULL;
+	m_pSteamNetworking = NULL;
+}
+
+// This function must be inlined so the module using steam_api.dll gets the version names they want.
+inline bool CSteamAPIContext::Init()
+{
+	if ( !SteamClient() )
+		return false;
+
+	HSteamUser hSteamUser = GetHSteamUser();
+	HSteamPipe hSteamPipe = GetHSteamPipe();
+
+	m_pSteamUser = SteamClient()->GetISteamUser( hSteamUser, hSteamPipe, STEAMUSER_INTERFACE_VERSION );
+	if ( !m_pSteamUser )
+		return false;
+
+	m_pSteamFriends = SteamClient()->GetISteamFriends( hSteamUser, hSteamPipe, STEAMFRIENDS_INTERFACE_VERSION );
+	if ( !m_pSteamFriends )
+		return false;
+
+	m_pSteamUtils = SteamClient()->GetISteamUtils( hSteamUser, STEAMUTILS_INTERFACE_VERSION );
+	if ( !m_pSteamUtils )
+		return false;
+
+	m_pSteamMatchmaking = SteamClient()->GetISteamMatchmaking( hSteamUser, hSteamPipe, STEAMMATCHMAKING_INTERFACE_VERSION );
+	if ( !m_pSteamMatchmaking )
+		return false;
+
+	m_pSteamMatchmakingServers = SteamClient()->GetISteamMatchmakingServers( hSteamUser, hSteamPipe, STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION );
+	if ( !m_pSteamMatchmakingServers )
+		return false;
+
+	m_pSteamUserStats = SteamClient()->GetISteamUserStats( hSteamUser, hSteamPipe, STEAMUSERSTATS_INTERFACE_VERSION );
+	if ( !m_pSteamUserStats )
+		return false;
+	
+	m_pSteamApps = SteamClient()->GetISteamApps( hSteamUser, hSteamPipe, STEAMAPPS_INTERFACE_VERSION );
+	if ( !m_pSteamApps )
+		return false;
+
+	m_pSteamNetworking = SteamClient()->GetISteamNetworking( hSteamUser, hSteamPipe, STEAMNETWORKING_INTERFACE_VERSION );
+	if ( !m_pSteamNetworking )
+		return false;
+
+	return true;
+}
+
+#endif // VERSION_SAFE_STEAM_API_INTERFACES
+
+#endif // STEAM_API_H

lsteamclient/steamworks_sdk_099v/steam_gameserver.h

@@ -0,0 +1,45 @@
+//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef STEAM_GAMESERVER_H
+#define STEAM_GAMESERVER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steam_api.h"
+#include "isteamgameserver.h"
+#include "isteammasterserverupdater.h"
+
+enum EServerMode
+{
+	eServerModeNoAuthentication = 1, // Don't authenticate user logins and don't list on the server list
+	eServerModeAuthentication = 2, // Authenticate users, list on the server list, don't run VAC on clients that connect
+	eServerModeAuthenticationAndSecure = 3, // Authenticate users, list on the server list and VAC protect clients
+};													
+
+// Note: if you pass MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE for usQueryPort, then it will use "GameSocketShare" mode, 
+// which means that the game is responsible for sending and receiving UDP packets for the master 
+// server updater. See references to GameSocketShare in isteammasterserverupdater.h.
+//
+// Pass 0 for usGamePort or usSpectatorPort if you're not using that. Then, the master server updater will report 
+// what's running based on that.
+S_API bool SteamGameServer_Init( uint32 unIP, uint16 usPort, uint16 usGamePort, uint16 usSpectatorPort, uint16 usQueryPort, EServerMode eServerMode, int nGameAppId, const char *pchGameDir, const char *pchVersionString );
+S_API void SteamGameServer_Shutdown();
+S_API void SteamGameServer_RunCallbacks();
+
+S_API bool SteamGameServer_BSecure();
+S_API uint64 SteamGameServer_GetSteamID();
+
+S_API ISteamGameServer *SteamGameServer();
+S_API ISteamUtils *SteamGameServerUtils();
+S_API ISteamMasterServerUpdater *SteamMasterServerUpdater();
+S_API ISteamNetworking *SteamGameServerNetworking();
+
+#define STEAM_GAMESERVER_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, true > var; void func( param *pParam )
+
+
+#endif // STEAM_GAMESERVER_H

lsteamclient/steamworks_sdk_099v/steamclientpublic.h

@@ -0,0 +1,732 @@
+//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAMCLIENTPUBLIC_H
+#define STEAMCLIENTPUBLIC_H
+#ifdef _WIN32
+#pragma once
+#endif
+//lint -save -e1931 -e1927 -e1924 -e613 -e726
+
+// This header file defines the interface between the calling application and the code that
+// knows how to communicate with the connection manager (CM) from the Steam service 
+
+// This header file is intended to be portable; ideally this 1 header file plus a lib or dll
+// is all you need to integrate the client library into some other tree.  So please avoid
+// including or requiring other header files if possible.  This header should only describe the 
+// interface layer, no need to include anything about the implementation.
+
+#include "steamtypes.h"
+
+
+// General result codes
+enum EResult
+{
+	k_EResultOK	= 1,							// success
+	k_EResultFail = 2,							// generic failure 
+	k_EResultNoConnection = 3,					// no/failed network connection
+//	k_EResultNoConnectionRetry = 4,				// OBSOLETE - removed
+	k_EResultInvalidPassword = 5,				// password/ticket is invalid
+	k_EResultLoggedInElsewhere = 6,				// same user logged in elsewhere
+	k_EResultInvalidProtocolVer = 7,			// protocol version is incorrect
+	k_EResultInvalidParam = 8,					// a parameter is incorrect
+	k_EResultFileNotFound = 9,					// file was not found
+	k_EResultBusy = 10,							// called method busy - action not taken
+	k_EResultInvalidState = 11,					// called object was in an invalid state
+	k_EResultInvalidName = 12,					// name is invalid
+	k_EResultInvalidEmail = 13,					// email is invalid
+	k_EResultDuplicateName = 14,				// name is not unique
+	k_EResultAccessDenied = 15,					// access is denied
+	k_EResultTimeout = 16,						// operation timed out
+	k_EResultBanned = 17,						// VAC2 banned
+	k_EResultAccountNotFound = 18,				// account not found
+	k_EResultInvalidSteamID = 19,				// steamID is invalid
+	k_EResultServiceUnavailable = 20,			// The requested service is currently unavailable
+	k_EResultNotLoggedOn = 21,					// The user is not logged on
+	k_EResultPending = 22,						// Request is pending (may be in process, or waiting on third party)
+	k_EResultEncryptionFailure = 23,			// Encryption or Decryption failed
+	k_EResultInsufficientPrivilege = 24,		// Insufficient privilege
+	k_EResultLimitExceeded = 25,				// Too much of a good thing
+	k_EResultRevoked = 26,						// Access has been revoked (used for revoked guest passes)
+	k_EResultExpired = 27,						// License/Guest pass the user is trying to access is expired
+	k_EResultAlreadyRedeemed = 28,				// Guest pass has already been redeemed by account, cannot be acked again
+	k_EResultDuplicateRequest = 29,				// The request is a duplicate and the action has already occurred in the past, ignored this time
+	k_EResultAlreadyOwned = 30,					// All the games in this guest pass redemption request are already owned by the user
+	k_EResultIPNotFound = 31,					// IP address not found
+	k_EResultPersistFailed = 32,				// failed to write change to the data store
+	k_EResultLockingFailed = 33,				// failed to acquire access lock for this operation
+	k_EResultLogonSessionReplaced = 34,
+	k_EResultConnectFailed = 35,
+	k_EResultHandshakeFailed = 36,
+	k_EResultIOFailure = 37,
+	k_EResultRemoteDisconnect = 38,
+	k_EResultShoppingCartNotFound = 39,			// failed to find the shopping cart requested
+	k_EResultBlocked = 40,						// a user didn't allow it
+	k_EResultIgnored = 41,						// target is ignoring sender
+};
+
+// Result codes to GSHandleClientDeny/Kick
+typedef enum
+{
+	k_EDenyInvalidVersion = 1,
+	k_EDenyGeneric = 2,
+	k_EDenyNotLoggedOn = 3,
+	k_EDenyNoLicense = 4,
+	k_EDenyCheater = 5,
+	k_EDenyLoggedInElseWhere = 6,
+	k_EDenyUnknownText = 7,
+	k_EDenyIncompatibleAnticheat = 8,
+	k_EDenyMemoryCorruption = 9,
+	k_EDenyIncompatibleSoftware = 10,
+	k_EDenySteamConnectionLost = 11,
+	k_EDenySteamConnectionError = 12,
+	k_EDenySteamResponseTimedOut = 13,
+	k_EDenySteamValidationStalled = 14,
+} EDenyReason;
+
+// Steam universes.  Each universe is a self-contained Steam instance.
+enum EUniverse
+{
+	k_EUniverseInvalid = 0,
+	k_EUniversePublic = 1,
+	k_EUniverseBeta = 2,
+	k_EUniverseInternal = 3,
+	k_EUniverseDev = 4,
+	k_EUniverseRC = 5,
+
+	k_EUniverseMax
+};
+
+// Steam account types
+enum EAccountType
+{
+	k_EAccountTypeInvalid = 0,			
+	k_EAccountTypeIndividual = 1,		// single user account
+	k_EAccountTypeMultiseat = 2,		// multiseat (e.g. cybercafe) account
+	k_EAccountTypeGameServer = 3,		// game server account
+	k_EAccountTypeAnonGameServer = 4,	// anonymous game server account
+	k_EAccountTypePending = 5,			// pending
+	k_EAccountTypeContentServer = 6,	// content server
+	k_EAccountTypeClan = 7,
+	k_EAccountTypeChat = 8,
+	k_EAccountTypeP2PSuperSeeder = 9,	// a fake steamid used by superpeers to seed content to users of Steam P2P stuff
+	k_EAccountTypeAnonUser = 10,
+
+	// Max of 16 items in this field
+	k_EAccountTypeMax
+};
+
+
+//-----------------------------------------------------------------------------
+// types of user game stats fields
+// WARNING: DO NOT RENUMBER EXISTING VALUES - STORED IN DATABASE
+//-----------------------------------------------------------------------------
+enum ESteamUserStatType
+{
+	k_ESteamUserStatTypeINVALID = 0,
+	k_ESteamUserStatTypeINT = 1,
+	k_ESteamUserStatTypeFLOAT = 2,
+	// Read as FLOAT, set with count / session length
+	k_ESteamUserStatTypeAVGRATE = 3,
+	k_ESteamUserStatTypeACHIEVEMENTS = 4,
+	k_ESteamUserStatTypeGROUPACHIEVEMENTS = 5,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Chat Entry Types (previously was only friend-to-friend message types)
+//-----------------------------------------------------------------------------
+enum EChatEntryType
+{
+	k_EChatEntryTypeChatMsg = 1,		// Normal text message from another user
+	k_EChatEntryTypeTyping = 2,			// Another user is typing (not used in multi-user chat)
+	k_EChatEntryTypeInviteGame = 3,		// Invite from other user into that users current game
+	k_EChatEntryTypeEmote = 4,			// text emote message
+	k_EChatEntryTypeLobbyGameStart = 5,	// lobby game is starting
+	// Above are previous FriendMsgType entries, now merged into more generic chat entry types
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Chat Room Enter Responses
+//-----------------------------------------------------------------------------
+enum EChatRoomEnterResponse
+{
+	k_EChatRoomEnterResponseSuccess = 1,		// Success
+	k_EChatRoomEnterResponseDoesntExist = 2,	// Chat doesn't exist (probably closed)
+	k_EChatRoomEnterResponseNotAllowed = 3,		// General Denied - You don't have the permissions needed to join the chat
+	k_EChatRoomEnterResponseFull = 4,			// Chat room has reached its maximum size
+	k_EChatRoomEnterResponseError = 5,			// Unexpected Error
+	k_EChatRoomEnterResponseBanned = 6,			// You are banned from this chat room and may not join
+};
+
+
+typedef void (*PFNLegacyKeyRegistration)( const char *pchCDKey, const char *pchInstallPath );
+typedef bool (*PFNLegacyKeyInstalled)();
+
+
+#pragma pack( push, 1 )		
+
+// Steam ID structure (64 bits total)
+class CSteamID
+{
+public:
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Constructor
+	//-----------------------------------------------------------------------------
+	CSteamID()
+	{
+		m_unAccountID = 0;
+		m_EAccountType = k_EAccountTypeInvalid;
+		m_EUniverse = k_EUniverseInvalid;
+		m_unAccountInstance = 0;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Constructor
+	// Input  : unAccountID -	32-bit account ID
+	//			eUniverse -		Universe this account belongs to
+	//			eAccountType -	Type of account
+	//-----------------------------------------------------------------------------
+	CSteamID( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
+	{
+		Set( unAccountID, eUniverse, eAccountType );
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Constructor
+	// Input  : unAccountID -	32-bit account ID
+	//			unAccountInstance - instance 
+	//			eUniverse -		Universe this account belongs to
+	//			eAccountType -	Type of account
+	//-----------------------------------------------------------------------------
+	CSteamID( uint32 unAccountID, unsigned int unAccountInstance, EUniverse eUniverse, EAccountType eAccountType )
+	{
+#if defined(_SERVER) && defined(Assert)
+		Assert( ! ( ( k_EAccountTypeIndividual == eAccountType ) && ( 1 != unAccountInstance ) ) );	// enforce that for individual accounts, instance is always 1
+#endif // _SERVER
+		InstancedSet( unAccountID, unAccountInstance, eUniverse, eAccountType );
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Constructor
+	// Input  : ulSteamID -		64-bit representation of a Steam ID
+	// Note:	Will not accept a uint32 or int32 as input, as that is a probable mistake.
+	//			See the stubbed out overloads in the private: section for more info.
+	//-----------------------------------------------------------------------------
+	CSteamID( uint64 ulSteamID )
+	{
+		SetFromUint64( ulSteamID );
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Sets parameters for steam ID
+	// Input  : unAccountID -	32-bit account ID
+	//			eUniverse -		Universe this account belongs to
+	//			eAccountType -	Type of account
+	//-----------------------------------------------------------------------------
+	void Set( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType )
+	{
+		m_unAccountID = unAccountID;
+		m_EUniverse = eUniverse;
+		m_EAccountType = eAccountType;
+		m_unAccountInstance = 1;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Sets parameters for steam ID
+	// Input  : unAccountID -	32-bit account ID
+	//			eUniverse -		Universe this account belongs to
+	//			eAccountType -	Type of account
+	//-----------------------------------------------------------------------------
+	void InstancedSet( uint32 unAccountID, uint32 unInstance, EUniverse eUniverse, EAccountType eAccountType )
+	{
+		m_unAccountID = unAccountID;
+		m_EUniverse = eUniverse;
+		m_EAccountType = eAccountType;
+		m_unAccountInstance = unInstance;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Initializes a steam ID from its 52 bit parts and universe/type
+	// Input  : ulIdentifier - 52 bits of goodness
+	//-----------------------------------------------------------------------------
+	void FullSet( uint64 ulIdentifier, EUniverse eUniverse, EAccountType eAccountType )
+	{
+		m_unAccountID = ( ulIdentifier & 0xFFFFFFFF );						// account ID is low 32 bits
+		m_unAccountInstance = ( ( ulIdentifier >> 32 ) & 0xFFFFF );			// account instance is next 20 bits
+		m_EUniverse = eUniverse;
+		m_EAccountType = eAccountType;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Initializes a steam ID from its 64-bit representation
+	// Input  : ulSteamID -		64-bit representation of a Steam ID
+	//-----------------------------------------------------------------------------
+	void SetFromUint64( uint64 ulSteamID )
+	{
+		m_unAccountID = ( ulSteamID & 0xFFFFFFFF );							// account ID is low 32 bits
+		m_unAccountInstance = ( ( ulSteamID >> 32 ) & 0xFFFFF );			// account instance is next 20 bits
+
+		m_EAccountType = ( EAccountType ) ( ( ulSteamID >> 52 ) & 0xF );	// type is next 4 bits
+		m_EUniverse = ( EUniverse ) ( ( ulSteamID >> 56 ) & 0xFF );			// universe is next 8 bits
+	}
+
+
+#if defined( INCLUDED_STEAM_COMMON_STEAMCOMMON_H ) 
+	//-----------------------------------------------------------------------------
+	// Purpose: Initializes a steam ID from a Steam2 ID structure
+	// Input:	pTSteamGlobalUserID -	Steam2 ID to convert
+	//			eUniverse -				universe this ID belongs to
+	//-----------------------------------------------------------------------------
+	void SetFromSteam2( TSteamGlobalUserID *pTSteamGlobalUserID, EUniverse eUniverse )
+	{
+		m_unAccountID = pTSteamGlobalUserID->m_SteamLocalUserID.Split.Low32bits * 2 + 
+			pTSteamGlobalUserID->m_SteamLocalUserID.Split.High32bits;
+		m_EUniverse = eUniverse;		// set the universe
+		m_EAccountType = k_EAccountTypeIndividual; // Steam 2 accounts always map to account type of individual
+		m_unAccountInstance = 1;	// individual accounts always have an account instance ID of 1
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Fills out a Steam2 ID structure
+	// Input:	pTSteamGlobalUserID -	Steam2 ID to write to
+	//-----------------------------------------------------------------------------
+	void ConvertToSteam2( TSteamGlobalUserID *pTSteamGlobalUserID ) const
+	{
+		// only individual accounts have any meaning in Steam 2, only they can be mapped
+		// Assert( m_EAccountType == k_EAccountTypeIndividual );
+
+		pTSteamGlobalUserID->m_SteamInstanceID = 0;
+		pTSteamGlobalUserID->m_SteamLocalUserID.Split.High32bits = m_unAccountID % 2;
+		pTSteamGlobalUserID->m_SteamLocalUserID.Split.Low32bits = m_unAccountID / 2;
+	}
+#endif // defined( INCLUDED_STEAM_COMMON_STEAMCOMMON_H )
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Converts steam ID to its 64-bit representation
+	// Output : 64-bit representation of a Steam ID
+	//-----------------------------------------------------------------------------
+	uint64 ConvertToUint64() const
+	{
+		return (uint64) ( ( ( (uint64) m_EUniverse ) << 56 ) + ( ( (uint64) m_EAccountType ) << 52 ) + 
+			( ( (uint64) m_unAccountInstance ) << 32 ) + m_unAccountID );
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Converts the static parts of a steam ID to a 64-bit representation.
+	//			For multiseat accounts, all instances of that account will have the
+	//			same static account key, so they can be grouped together by the static
+	//			account key.
+	// Output : 64-bit static account key
+	//-----------------------------------------------------------------------------
+	uint64 GetStaticAccountKey() const
+	{
+		// note we do NOT include the account instance (which is a dynamic property) in the static account key
+		return (uint64) ( ( ( (uint64) m_EUniverse ) << 56 ) + ((uint64) m_EAccountType << 52 ) + m_unAccountID );
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: create an anonymous game server login to be filled in by the AM
+	//-----------------------------------------------------------------------------
+	void CreateBlankAnonLogon( EUniverse eUniverse )
+	{
+		m_unAccountID = 0;
+		m_EAccountType = k_EAccountTypeAnonGameServer;
+		m_EUniverse = eUniverse;
+		m_unAccountInstance = 0;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: create an anonymous game server login to be filled in by the AM
+	//-----------------------------------------------------------------------------
+	void CreateBlankAnonUserLogon( EUniverse eUniverse )
+	{
+		m_unAccountID = 0;
+		m_EAccountType = k_EAccountTypeAnonUser;
+		m_EUniverse = eUniverse;
+		m_unAccountInstance = 0;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is this an anonymous game server login that will be filled in?
+	//-----------------------------------------------------------------------------
+	bool BBlankAnonAccount() const
+	{
+		return m_unAccountID == 0 && BAnonAccount() && m_unAccountInstance == 0;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is this a game server account id?
+	//-----------------------------------------------------------------------------
+	bool BGameServerAccount() const
+	{
+		return m_EAccountType == k_EAccountTypeGameServer || m_EAccountType == k_EAccountTypeAnonGameServer;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is this a content server account id?
+	//-----------------------------------------------------------------------------
+	bool BContentServerAccount() const
+	{
+		return m_EAccountType == k_EAccountTypeContentServer;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is this a clan account id?
+	//-----------------------------------------------------------------------------
+	bool BClanAccount() const
+	{
+		return m_EAccountType == k_EAccountTypeClan;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is this a chat account id?
+	//-----------------------------------------------------------------------------
+	bool BChatAccount() const
+	{
+		return m_EAccountType == k_EAccountTypeChat;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is this an individual user account id?
+	//-----------------------------------------------------------------------------
+	bool BIndividualAccount() const
+	{
+		return m_EAccountType == k_EAccountTypeIndividual;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is this an anonymous account?
+	//-----------------------------------------------------------------------------
+	bool BAnonAccount() const
+	{
+		return m_EAccountType == k_EAccountTypeAnonUser || m_EAccountType == k_EAccountTypeAnonGameServer;
+	}
+
+
+	// simple accessors
+	void SetAccountID( uint32 unAccountID )		{ m_unAccountID = unAccountID; }
+	uint32 GetAccountID() const					{ return m_unAccountID; }
+	uint32 GetUnAccountInstance() const			{ return m_unAccountInstance; }
+	EAccountType GetEAccountType() const		{ return ( EAccountType ) m_EAccountType; }
+	EUniverse GetEUniverse() const				{ return m_EUniverse; }
+	void SetEUniverse( EUniverse eUniverse )	{ m_EUniverse = eUniverse; }
+	bool IsValid() const						{ return ( m_EAccountType != k_EAccountTypeInvalid && m_EUniverse != k_EUniverseInvalid ); }
+
+	// this set of functions is hidden, will be moved out of class
+	explicit CSteamID( const char *pchSteamID, EUniverse eDefaultUniverse = k_EUniverseInvalid );
+	char * Render() const;				// renders this steam ID to string
+	static char * Render( uint64 ulSteamID );	// static method to render a uint64 representation of a steam ID to a string
+
+	void SetFromString( const char *pchSteamID, EUniverse eDefaultUniverse );
+	bool SetFromSteam2String( const char *pchSteam2ID, EUniverse eUniverse );
+
+	bool operator==( const CSteamID &val ) const
+	{
+		return ( ( val.m_unAccountID == m_unAccountID ) && ( val.m_unAccountInstance == m_unAccountInstance )
+			&& ( val.m_EAccountType == m_EAccountType ) &&  ( val.m_EUniverse == m_EUniverse ) );
+	} 
+
+	bool operator!=( const CSteamID &val ) const { return !operator==( val ); }
+	bool operator<( const CSteamID &val ) const { return ConvertToUint64() < val.ConvertToUint64(); }
+	bool operator>( const CSteamID &val ) const { return ConvertToUint64() > val.ConvertToUint64(); }
+
+	// DEBUG function
+	bool BValidExternalSteamID() const;
+
+private:
+	// These are defined here to prevent accidental implicit conversion of a u32AccountID to a CSteamID.
+	// If you get a compiler error about an ambiguous constructor/function then it may be because you're
+	// passing a 32-bit int to a function that takes a CSteamID. You should explicitly create the SteamID
+	// using the correct Universe and account Type/Instance values.
+	CSteamID( uint32 );
+	CSteamID( int32 );
+
+#ifdef _WIN32
+#pragma warning(push)
+#pragma warning(disable:4201)	// nameless union is nonstandard
+	// 64 bits total
+	union
+	{
+		struct
+		{
+#endif
+			uint32				m_unAccountID : 32;			// unique account identifier
+			unsigned int		m_unAccountInstance : 20;	// dynamic instance ID (used for multiseat type accounts only)
+			unsigned int		m_EAccountType : 4;			// type of account - can't show as EAccountType, due to signed / unsigned difference
+			EUniverse			m_EUniverse : 8;			// universe this account belongs to
+#ifdef _WIN32
+		};
+
+		uint64 m_unAll64Bits;
+	};
+#pragma warning(pop)			// no more anonymous unions until next time
+#endif
+};
+
+const int k_unSteamAccountIDMask = 0xFFFFFFFF;
+const int k_unSteamAccountInstanceMask = 0x000FFFFF;
+
+
+// Special flags for Chat accounts - they go in the top 8 bits
+// of the steam ID's "instance", leaving 12 for the actual instances
+enum EChatSteamIDInstanceFlags
+{
+	k_EChatAccountInstanceMask = 0x00000FFF, // top 8 bits are flags
+
+	k_EChatInstanceFlagClan = ( k_unSteamAccountInstanceMask + 1 ) >> 1,	// top bit
+	k_EChatInstanceFlagLobby = ( k_unSteamAccountInstanceMask + 1 ) >> 2,	// next one down, etc
+
+	// Max of 8 flags
+};
+
+
+// generic invalid CSteamID
+const CSteamID k_steamIDNil;
+
+// This steamID comes from a user game connection to an out of date GS that hasnt implemented the protocol
+// to provide its steamID
+const CSteamID k_steamIDOutofDateGS( 0, 0, k_EUniverseInvalid, k_EAccountTypeInvalid );
+// This steamID comes from a user game connection to an sv_lan GS
+const CSteamID k_steamIDLanModeGS( 0, 0, k_EUniversePublic, k_EAccountTypeInvalid );
+// This steamID can come from a user game connection to a GS that has just booted but hasnt yet even initialized
+// its steam3 component and started logging on.
+const CSteamID k_steamIDNotInitYetGS( 1, 0, k_EUniverseInvalid, k_EAccountTypeInvalid );
+
+
+#ifdef STEAM
+// Returns the matching chat steamID, with the default instance of 0
+// If the steamID passed in is already of type k_EAccountTypeChat it will be returned with the same instance
+CSteamID ChatIDFromSteamID( CSteamID &steamID );
+// Returns the matching clan steamID, with the default instance of 0
+// If the steamID passed in is already of type k_EAccountTypeClan it will be returned with the same instance
+CSteamID ClanIDFromSteamID( CSteamID &steamID );
+// Asserts steamID type before conversion
+CSteamID ChatIDFromClanID( CSteamID &steamIDClan );
+// Asserts steamID type before conversion
+CSteamID ClanIDFromChatID( CSteamID &steamIDChat );
+
+#endif // _STEAM
+
+
+//-----------------------------------------------------------------------------
+// Purpose: encapsulates an appID/modID pair
+//-----------------------------------------------------------------------------
+class CGameID
+{
+public:
+	CGameID()
+	{
+		m_ulGameID = 0;
+	}
+
+	explicit CGameID( uint64 ulGameID )
+	{
+		m_ulGameID = ulGameID;
+	}
+
+	explicit CGameID( int32 nAppID )
+	{
+		m_ulGameID = 0;
+		m_gameID.m_nAppID = nAppID;
+	}
+
+	explicit CGameID( uint32 nAppID )
+	{
+		m_ulGameID = 0;
+		m_gameID.m_nAppID = nAppID;
+	}
+
+	CGameID( uint32 nAppID, uint32 nModID )
+	{
+		m_ulGameID = 0;
+		m_gameID.m_nAppID = nAppID;
+		m_gameID.m_nModID = nModID;
+		m_gameID.m_nType = k_EGameIDTypeGameMod;
+	}
+
+	// Hidden functions used only by Steam
+	explicit CGameID( const char *pchGameID );
+	char * Render() const;				// renders this Game ID to string
+	static char * Render( uint64 ulGameID );	// static method to render a uint64 representation of a Game ID to a string
+
+	// must include checksum_crc.h first to get this functionality
+#if defined( CHECKSUM_CRC_H )
+	CGameID( uint32 nAppID, const char *pchModPath )
+	{
+		m_ulGameID = 0;
+		m_gameID.m_nAppID = nAppID;
+		m_gameID.m_nType = k_EGameIDTypeGameMod;
+
+		char rgchModDir[MAX_PATH];
+		Q_FileBase( pchModPath, rgchModDir, sizeof( rgchModDir ) );
+		CRC32_t crc32;
+		CRC32_Init( &crc32 );
+		CRC32_ProcessBuffer( &crc32, rgchModDir, Q_strlen( rgchModDir ) );
+		CRC32_Final( &crc32 );
+
+		// set the high-bit on the mod-id 
+		// reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique
+		// replacement for appID's
+		m_gameID.m_nModID = crc32 | (0x80000000);
+	}
+
+	CGameID( const char *pchExePath, const char *pchAppName )
+	{
+		m_ulGameID = 0;
+		m_gameID.m_nAppID = 0;
+		m_gameID.m_nType = k_EGameIDTypeShortcut;
+
+		CRC32_t crc32;
+		CRC32_Init( &crc32 );
+		CRC32_ProcessBuffer( &crc32, pchExePath, Q_strlen( pchExePath ) );
+		CRC32_ProcessBuffer( &crc32, pchAppName, Q_strlen( pchAppName ) );
+		CRC32_Final( &crc32 );
+
+		// set the high-bit on the mod-id 
+		// reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique
+		// replacement for appID's
+		m_gameID.m_nModID = crc32 | (0x80000000);
+	}
+#endif
+
+	void SetAsShortcut()
+	{
+		m_gameID.m_nAppID = 0;
+		m_gameID.m_nType = k_EGameIDTypeShortcut;
+	}
+
+	void SetAsP2PFile()
+	{
+		m_gameID.m_nAppID = 0;
+		m_gameID.m_nType = k_EGameIDTypeP2P;
+	}
+
+	uint64 ToUint64() const
+	{
+		return m_ulGameID;
+	}
+
+	uint64 *GetUint64Ptr()
+	{
+		return &m_ulGameID;
+	}
+
+	bool IsMod() const
+	{
+		return ( m_gameID.m_nType == k_EGameIDTypeGameMod );
+	}
+
+	bool IsShortcut() const
+	{
+		return ( m_gameID.m_nType == k_EGameIDTypeShortcut );
+	}
+
+	bool IsP2PFile() const
+	{
+		return ( m_gameID.m_nType == k_EGameIDTypeP2P );
+	}
+
+	bool IsSteamApp() const
+	{
+		return ( m_gameID.m_nType == k_EGameIDTypeApp );
+	}
+		
+
+
+	uint32 ModID() const
+	{
+		return m_gameID.m_nModID;
+	}
+
+	uint32 AppID() const
+	{
+		return m_gameID.m_nAppID;
+	}
+
+	bool operator == ( const CGameID &rhs ) const
+	{
+		return m_ulGameID == rhs.m_ulGameID;
+	}
+
+	bool operator != ( const CGameID &rhs ) const
+	{
+		return !(*this == rhs);
+	}
+
+	bool operator < ( const CGameID &rhs ) const
+	{
+		return ( m_ulGameID < rhs.m_ulGameID );
+	}
+
+	bool IsValid() const
+	{
+		return ( m_ulGameID != 0 );
+	}
+
+	void Reset() 
+	{
+		m_ulGameID = 0;
+	}
+
+
+
+private:
+	enum EGameIDType
+	{
+		k_EGameIDTypeApp		= 0,
+		k_EGameIDTypeGameMod	= 1,
+		k_EGameIDTypeShortcut	= 2,
+		k_EGameIDTypeP2P		= 3,
+	};
+
+	struct GameID_t
+	{
+		unsigned int m_nAppID : 24;
+		unsigned int m_nType : 8;
+		unsigned int m_nModID : 32;
+	};
+
+	union
+	{
+		uint64 m_ulGameID;
+		GameID_t m_gameID;
+	};
+};
+
+#pragma pack( pop )
+
+const int k_cchGameExtraInfoMax = 64;
+
+
+// Max number of credit cards stored for one account
+const int k_nMaxNumCardsPerAccount = 1;
+
+
+//-----------------------------------------------------------------------------
+// Constants used for query ports.
+//-----------------------------------------------------------------------------
+
+#define QUERY_PORT_NOT_INITIALIZED		0xFFFF	// We haven't asked the GS for this query port's actual value yet.
+#define QUERY_PORT_ERROR				0xFFFE	// We were unable to get the query port for this server.
+
+#endif // STEAMCLIENTPUBLIC_H

lsteamclient/steamworks_sdk_099v/steamtypes.h

@@ -0,0 +1,92 @@
+//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAMTYPES_H
+#define STEAMTYPES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#if defined( __GNUC__ ) && !defined(POSIX)
+	#if __GNUC__ < 4
+		#error "Steamworks requires GCC 4.X (4.2 or 4.4 have been tested)"
+	#endif
+	#define POSIX 1
+#endif
+
+// Steam-specific types. Defined here so this header file can be included in other code bases.
+#ifndef WCHARTYPES_H
+typedef unsigned char uint8;
+#endif
+
+
+#if defined(__x86_64__) || defined(_WIN64)
+#define X64BITS
+#endif
+
+typedef unsigned char uint8;
+typedef signed char int8;
+
+#if defined( _WIN32 )
+
+typedef __int16 int16;
+typedef unsigned __int16 uint16;
+typedef __int32 int32;
+typedef unsigned __int32 uint32;
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+
+#ifdef X64BITS
+typedef __int64 intp;				// intp is an integer that can accomodate a pointer
+typedef unsigned __int64 uintp;		// (ie, sizeof(intp) >= sizeof(int) && sizeof(intp) >= sizeof(void *)
+#else
+typedef __int32 intp;
+typedef unsigned __int32 uintp;
+#endif
+
+#else // _WIN32
+
+typedef short int16;
+typedef unsigned short uint16;
+typedef int int32;
+typedef unsigned int uint32;
+typedef long long int64;
+typedef unsigned long long uint64;
+#ifdef X64BITS
+typedef long long intp;
+typedef unsigned long long uintp;
+#else
+typedef int intp;
+typedef unsigned int uintp;
+#endif
+
+#endif // else _WIN32
+
+const int k_cubDigestSize = 20;							// CryptoPP::SHA::DIGESTSIZE
+const int k_cubSaltSize   = 8;
+
+typedef	uint8 SHADigest_t[ k_cubDigestSize ];
+typedef	uint8 Salt_t[ k_cubSaltSize ];
+
+typedef uint64 GID_t;		// globally unique identifier
+
+// this is baked into client messages and interfaces as an int, 
+// make sure we never break this.
+typedef uint32 PackageId_t;
+const PackageId_t k_uPackageIdInvalid = 0xFFFFFFFF;
+
+
+// this is baked into client messages and interfaces as an int, 
+// make sure we never break this.
+typedef uint32 AppId_t;
+const AppId_t k_uAppIdInvalid = 0xFFFFFFFF;
+
+// RTime32
+// We use this 32 bit time representing real world time.
+// It offers 1 second resolution beginning on January 1, 1970 (Unix time)
+typedef uint32 RTime32;
+
+#endif // STEAMTYPES_H

lsteamclient/winISteamUser.c

@@ -2288,3 +2288,343 @@ winISteamUser_SteamUser006 *create_winISteamUser_SteamUser006(void *linux_side)
     return r;
 }
 
+#include "cppISteamUser_SteamUser005.h"
+
+typedef struct __winISteamUser_SteamUser005 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamUser_SteamUser005;
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetHSteamUser, 4)
+HSteamUser __thiscall winISteamUser_SteamUser005_GetHSteamUser(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetHSteamUser(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_LogOn, 12)
+void __thiscall winISteamUser_SteamUser005_LogOn(winISteamUser_SteamUser005 *_this, CSteamID steamID)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_LogOn(_this->linux_side, steamID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_LogOff, 4)
+void __thiscall winISteamUser_SteamUser005_LogOff(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_LogOff(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_BLoggedOn, 4)
+bool __thiscall winISteamUser_SteamUser005_BLoggedOn(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_BLoggedOn(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetLogonState, 4)
+ELogonState __thiscall winISteamUser_SteamUser005_GetLogonState(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetLogonState(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_BConnected, 4)
+bool __thiscall winISteamUser_SteamUser005_BConnected(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_BConnected(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetSteamID, 8)
+CSteamID *__thiscall winISteamUser_SteamUser005_GetSteamID(winISteamUser_SteamUser005 *_this, CSteamID *_r)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamUser_SteamUser005_GetSteamID(_this->linux_side);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_IsVACBanned, 8)
+bool __thiscall winISteamUser_SteamUser005_IsVACBanned(winISteamUser_SteamUser005 *_this, int nGameID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_IsVACBanned(_this->linux_side, nGameID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_RequireShowVACBannedMessage, 8)
+bool __thiscall winISteamUser_SteamUser005_RequireShowVACBannedMessage(winISteamUser_SteamUser005 *_this, int nAppID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_RequireShowVACBannedMessage(_this->linux_side, nAppID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_AcknowledgeVACBanning, 8)
+void __thiscall winISteamUser_SteamUser005_AcknowledgeVACBanning(winISteamUser_SteamUser005 *_this, int nAppID)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_AcknowledgeVACBanning(_this->linux_side, nAppID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetSteam2Ticket, 12)
+void __thiscall winISteamUser_SteamUser005_SetSteam2Ticket(winISteamUser_SteamUser005 *_this, uint8 * pubTicket, int cubTicket)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_SetSteam2Ticket(_this->linux_side, pubTicket, cubTicket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_AddServerNetAddress, 10)
+void __thiscall winISteamUser_SteamUser005_AddServerNetAddress(winISteamUser_SteamUser005 *_this, uint32 unIP, uint16 unPort)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_AddServerNetAddress(_this->linux_side, unIP, unPort);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetEmail, 8)
+bool __thiscall winISteamUser_SteamUser005_SetEmail(winISteamUser_SteamUser005 *_this, const char * pchEmail)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_SetEmail(_this->linux_side, pchEmail);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetRegistryString, 16)
+bool __thiscall winISteamUser_SteamUser005_SetRegistryString(winISteamUser_SteamUser005 *_this, EConfigSubTree eRegistrySubTree, const char * pchKey, const char * pchValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_SetRegistryString(_this->linux_side, eRegistrySubTree, pchKey, pchValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetRegistryString, 20)
+bool __thiscall winISteamUser_SteamUser005_GetRegistryString(winISteamUser_SteamUser005 *_this, EConfigSubTree eRegistrySubTree, const char * pchKey, char * pchValue, int cbValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetRegistryString(_this->linux_side, eRegistrySubTree, pchKey, pchValue, cbValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetRegistryInt, 16)
+bool __thiscall winISteamUser_SteamUser005_SetRegistryInt(winISteamUser_SteamUser005 *_this, EConfigSubTree eRegistrySubTree, const char * pchKey, int iValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_SetRegistryInt(_this->linux_side, eRegistrySubTree, pchKey, iValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetRegistryInt, 16)
+bool __thiscall winISteamUser_SteamUser005_GetRegistryInt(winISteamUser_SteamUser005 *_this, EConfigSubTree eRegistrySubTree, const char * pchKey, int * piValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetRegistryInt(_this->linux_side, eRegistrySubTree, pchKey, piValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_InitiateGameConnection, 35)
+int __thiscall winISteamUser_SteamUser005_InitiateGameConnection(winISteamUser_SteamUser005 *_this, void * pBlob, int cbMaxBlob, CSteamID steamID, CGameID gameID, uint32 unIPServer, uint16 usPortServer, bool bSecure)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_InitiateGameConnection(_this->linux_side, pBlob, cbMaxBlob, steamID, gameID, unIPServer, usPortServer, bSecure);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_TerminateGameConnection, 10)
+void __thiscall winISteamUser_SteamUser005_TerminateGameConnection(winISteamUser_SteamUser005 *_this, uint32 unIPServer, uint16 usPortServer)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_TerminateGameConnection(_this->linux_side, unIPServer, usPortServer);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetSelfAsPrimaryChatDestination, 4)
+void __thiscall winISteamUser_SteamUser005_SetSelfAsPrimaryChatDestination(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_SetSelfAsPrimaryChatDestination(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_IsPrimaryChatDestination, 4)
+bool __thiscall winISteamUser_SteamUser005_IsPrimaryChatDestination(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_IsPrimaryChatDestination(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_RequestLegacyCDKey, 8)
+void __thiscall winISteamUser_SteamUser005_RequestLegacyCDKey(winISteamUser_SteamUser005 *_this, uint32 nAppID)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_RequestLegacyCDKey(_this->linux_side, nAppID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SendGuestPassByEmail, 17)
+bool __thiscall winISteamUser_SteamUser005_SendGuestPassByEmail(winISteamUser_SteamUser005 *_this, const char * pchEmailAccount, GID_t gidGuestPassID, bool bResending)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_SendGuestPassByEmail(_this->linux_side, pchEmailAccount, gidGuestPassID, bResending);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SendGuestPassByAccountID, 17)
+bool __thiscall winISteamUser_SteamUser005_SendGuestPassByAccountID(winISteamUser_SteamUser005 *_this, uint32 uAccountID, GID_t gidGuestPassID, bool bResending)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_SendGuestPassByAccountID(_this->linux_side, uAccountID, gidGuestPassID, bResending);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_AckGuestPass, 8)
+bool __thiscall winISteamUser_SteamUser005_AckGuestPass(winISteamUser_SteamUser005 *_this, const char * pchGuestPassCode)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_AckGuestPass(_this->linux_side, pchGuestPassCode);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_RedeemGuestPass, 8)
+bool __thiscall winISteamUser_SteamUser005_RedeemGuestPass(winISteamUser_SteamUser005 *_this, const char * pchGuestPassCode)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_RedeemGuestPass(_this->linux_side, pchGuestPassCode);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetGuestPassToGiveCount, 4)
+uint32 __thiscall winISteamUser_SteamUser005_GetGuestPassToGiveCount(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetGuestPassToGiveCount(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetGuestPassToRedeemCount, 4)
+uint32 __thiscall winISteamUser_SteamUser005_GetGuestPassToRedeemCount(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetGuestPassToRedeemCount(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetGuestPassLastUpdateTime, 4)
+RTime32 __thiscall winISteamUser_SteamUser005_GetGuestPassLastUpdateTime(winISteamUser_SteamUser005 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetGuestPassLastUpdateTime(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetGuestPassToGiveInfo, 40)
+bool __thiscall winISteamUser_SteamUser005_GetGuestPassToGiveInfo(winISteamUser_SteamUser005 *_this, uint32 nPassIndex, GID_t * pgidGuestPassID, PackageId_t * pnPackageID, RTime32 * pRTime32Created, RTime32 * pRTime32Expiration, RTime32 * pRTime32Sent, RTime32 * pRTime32Redeemed, char * pchRecipientAddress, int cRecipientAddressSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetGuestPassToGiveInfo(_this->linux_side, nPassIndex, pgidGuestPassID, pnPackageID, pRTime32Created, pRTime32Expiration, pRTime32Sent, pRTime32Redeemed, pchRecipientAddress, cRecipientAddressSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetGuestPassToRedeemInfo, 32)
+bool __thiscall winISteamUser_SteamUser005_GetGuestPassToRedeemInfo(winISteamUser_SteamUser005 *_this, uint32 nPassIndex, GID_t * pgidGuestPassID, PackageId_t * pnPackageID, RTime32 * pRTime32Created, RTime32 * pRTime32Expiration, RTime32 * pRTime32Sent, RTime32 * pRTime32Redeemed)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetGuestPassToRedeemInfo(_this->linux_side, nPassIndex, pgidGuestPassID, pnPackageID, pRTime32Created, pRTime32Expiration, pRTime32Sent, pRTime32Redeemed);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetGuestPassToRedeemSenderAddress, 16)
+bool __thiscall winISteamUser_SteamUser005_GetGuestPassToRedeemSenderAddress(winISteamUser_SteamUser005 *_this, uint32 nPassIndex, char * pchSenderAddress, int cSenderAddressSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetGuestPassToRedeemSenderAddress(_this->linux_side, nPassIndex, pchSenderAddress, cSenderAddressSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_GetGuestPassToRedeemSenderName, 16)
+bool __thiscall winISteamUser_SteamUser005_GetGuestPassToRedeemSenderName(winISteamUser_SteamUser005 *_this, uint32 nPassIndex, char * pchSenderName, int cSenderNameSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_GetGuestPassToRedeemSenderName(_this->linux_side, nPassIndex, pchSenderName, cSenderNameSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_AcknowledgeMessageByGID, 8)
+void __thiscall winISteamUser_SteamUser005_AcknowledgeMessageByGID(winISteamUser_SteamUser005 *_this, const char * pchMessageGID)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_AcknowledgeMessageByGID(_this->linux_side, pchMessageGID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetLanguage, 8)
+bool __thiscall winISteamUser_SteamUser005_SetLanguage(winISteamUser_SteamUser005 *_this, const char * pchLanguage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUser_SteamUser005_SetLanguage(_this->linux_side, pchLanguage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_TrackAppUsageEvent, 20)
+void __thiscall winISteamUser_SteamUser005_TrackAppUsageEvent(winISteamUser_SteamUser005 *_this, CGameID gameID, int eAppUsageEvent, const char * pchExtraInfo)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_TrackAppUsageEvent(_this->linux_side, gameID, eAppUsageEvent, pchExtraInfo);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetAccountName, 8)
+void __thiscall winISteamUser_SteamUser005_SetAccountName(winISteamUser_SteamUser005 *_this, const char * pchAccountName)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_SetAccountName(_this->linux_side, pchAccountName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetPassword, 8)
+void __thiscall winISteamUser_SteamUser005_SetPassword(winISteamUser_SteamUser005 *_this, const char * pchPassword)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_SetPassword(_this->linux_side, pchPassword);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUser_SteamUser005_SetAccountCreationTime, 8)
+void __thiscall winISteamUser_SteamUser005_SetAccountCreationTime(winISteamUser_SteamUser005 *_this, RTime32 rt)
+{
+    TRACE("%p\n", _this);
+    cppISteamUser_SteamUser005_SetAccountCreationTime(_this->linux_side, rt);
+}
+
+extern vtable_ptr winISteamUser_SteamUser005_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamUser_SteamUser005,
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetHSteamUser)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_LogOn)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_LogOff)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_BLoggedOn)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetLogonState)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_BConnected)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetSteamID)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_IsVACBanned)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_RequireShowVACBannedMessage)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_AcknowledgeVACBanning)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetSteam2Ticket)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_AddServerNetAddress)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetEmail)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetRegistryString)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetRegistryString)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetRegistryInt)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetRegistryInt)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_InitiateGameConnection)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_TerminateGameConnection)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetSelfAsPrimaryChatDestination)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_IsPrimaryChatDestination)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_RequestLegacyCDKey)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SendGuestPassByEmail)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SendGuestPassByAccountID)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_AckGuestPass)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_RedeemGuestPass)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetGuestPassToGiveCount)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetGuestPassToRedeemCount)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetGuestPassLastUpdateTime)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetGuestPassToGiveInfo)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetGuestPassToRedeemInfo)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetGuestPassToRedeemSenderAddress)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_GetGuestPassToRedeemSenderName)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_AcknowledgeMessageByGID)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetLanguage)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_TrackAppUsageEvent)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetAccountName)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetPassword)
+        VTABLE_ADD_FUNC(winISteamUser_SteamUser005_SetAccountCreationTime)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamUser_SteamUser005 *create_winISteamUser_SteamUser005(void *linux_side)
+{
+    winISteamUser_SteamUser005 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamUser_SteamUser005));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamUser_SteamUser005_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+

lsteamclient/win_constructors.h

@@ -141,4 +141,5 @@ extern void *create_winISteamFriends_SteamFriends001(void *);
 extern void *create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION001(void *);
 extern void *create_winISteamGameServer_SteamGameServer002(void *);
 extern void *create_winISteamUser_SteamUser006(void *);
+extern void *create_winISteamUser_SteamUser005(void *);
 extern void *create_winISteamNetworkingSocketsSerialized_SteamNetworkingSocketsSerialized002(void *);

lsteamclient/win_constructors_table.dat

@@ -145,5 +145,6 @@
     {"STEAMUSERSTATS_INTERFACE_VERSION001", &create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION001},
     {"SteamGameServer002", &create_winISteamGameServer_SteamGameServer002},
     {"SteamUser006", &create_winISteamUser_SteamUser006},
+    {"SteamUser005", &create_winISteamUser_SteamUser005},
     {"SteamNetworkingSocketsSerialized002", &create_winISteamNetworkingSocketsSerialized_SteamNetworkingSocketsSerialized002},
     {"SteamNetworkingSocketsSerialized001", &create_winISteamNetworkingSocketsSerialized_SteamNetworkingSocketsSerialized002}, /* alias */