Commits

Didrole committed 6a43fc2

Updated IClient* and ISteamGameServer011 interfaces
Added ISteamMatchmaking009 and ISteamRemoteStorage005
Updated a few enums

Comments (0)

Files changed (18)

Open Steamworks/AppsCommon.h

 
 typedef enum EAppState
 {
-	k_EAppStateInvalid = 0,
-	k_EAppStateUninstalled = 1,
-	k_EAppStateUpdateRequired = 2,
-	k_EAppStateFullyInstalled = 4,
-	k_EAppStateDataEncrypted = 8,
-	k_EAppStateDataLocked = 16,
-	k_EAppStateDataCorrupt = 32,
-	k_EAppStateAppRunning = 64,
-	k_EAppStateUpdateRunning = 256,
-	k_EAppStateUpdatePaused = 512,
-	k_EAppStateUpdateSuspended = 1024,
-	k_EAppStateUninstalling = 2048,
-	k_EAppStateReconfiguring = 4096,
-	k_EAppStateDownloading = 8192,
-	k_EAppStateStaging = 16384,
-	k_EAppStateCommitting = 32768,
+	k_EAppStateInvalid			= 0,
+	k_EAppStateUninstalled		= 1,
+	k_EAppStateUpdateRequired	= 2,
+	k_EAppStateFullyInstalled	= 4,
+	k_EAppStateDataEncrypted	= 8,
+	k_EAppStateDataLocked		= 16,
+	k_EAppStateFilesMissing		= 32,
+	k_EAppStateFilesCorrupt		= 128,
+	k_EAppStateAppRunning		= 64,
+	k_EAppStateUpdateRunning	= 256,
+	k_EAppStateUpdateStopping	= 524288,
+	k_EAppStateUpdatePaused		= 512,
+	k_EAppStateUpdateStarted	= 1024,
+	k_EAppStateReconfiguring	= 4096,
+	k_EAppStateAddingFiles		= 16384,
+	k_EAppStateDownloading		= 65536,
+	k_EAppStateStaging			= 131072,
+	k_EAppStateCommitting		= 262144,
+	k_EAppStateUninstalling		= 2048,
+	k_EAppStatePreallocating	= 32768,
+	k_EAppStateValidating		= 8192,
 } EAppState;
 
 typedef enum EAppEvent
 	k_EAppEventDownloadComplete = 2,
 } EAppEvent;
 
-
+typedef enum EAppInfoSection
+{
+	k_EAppInfoSectionUnknown = 0,
+	k_EAppInfoSectionAll,
+	k_EAppInfoSectionCommon,
+	k_EAppInfoSectionExtended,
+	k_EAppInfoSectionConfig,
+	k_EAppInfoSectionStats,
+	k_EAppInfoSectionInstall,
+	k_EAppInfoSectionDepots,
+	k_EAppInfoSectionVac,
+	k_EAppInfoSectionDrm,
+	k_EAppInfoSectionUfs,
+	k_EAppInfoSectionOgg,
+	k_EAppInfoSectionItems,
+	k_EAppInfoSectionPolicies,
+	k_EAppInfoSectionSysreqs,
+} EAppInfoSection;
 
 #pragma pack( push, 8 )
 //-----------------------------------------------------------------------------

Open Steamworks/EResult.h

 	k_EResultAccountLogonDeniedNoMail = 66,		// account login denied due to 2nd factor auth failure - and no mail has been sent
 	k_EResultHardwareNotCapableOfIPT = 67,		// 
 	k_EResultIPTInitError = 68,					// 
+	k_EResultParentalControlRestrictions = 69,	// Operation failed due to parental control restrictions for current user
+	k_EResultFacebookQueryError = 70,			// Facebook query returned an error
+	k_EResultExpiredLoginAuthCode = 71,			// Expired Login Auth Code
+	k_EResultIPLoginRestrictionFailed = 72,		// IP Login Restriction Failed
 
 } EResult;
 

Open Steamworks/FriendsCommon.h

 	k_EFriendRelationshipRequestInitiator = 4,
 	k_EFriendRelationshipIgnored = 5,
 	k_EFriendRelationshipIgnoredFriend = 6,
+	k_EFriendRelationshipSuggestedFriend = 7,
 } EFriendRelationship;
 
 typedef enum EChatRoomType
 	k_EPersonaStateBusy = 2,			// user is on, but busy
 	k_EPersonaStateAway = 3,			// auto-away feature
 	k_EPersonaStateSnooze = 4,			// auto-away for a long time
+	k_EPersonaStateLookingToTrade = 5,	// Looking to Trade
+	k_EPersonaStateLookingToPlay = 6,	// Looking to Play
 	k_EPersonaStateMax,
 } EPersonaState;
 

Open Steamworks/IClientAppManager.h

 {
 };
 
+struct SHADigestWrapper_t
+{
+	uint32 A;
+	uint32 B;
+	uint32 C;
+	uint32 D;
+	uint32 E;
+};
+
 abstract_class UNSAFE_INTERFACE IClientAppManager
 {
 public:
 	virtual bool IsUsingLocalContentServer() = 0;
 
 	virtual bool BackupApp( AppId_t unAppID, uint64 ullMaxFileSize, const char *cszBackupPath ) = 0;
+	virtual bool CancelBackup( AppId_t unAppID ) = 0;
 	virtual bool RestoreApp( AppId_t unAppID, char const* cszBackupPath ) = 0;
 	virtual bool BNeedsFile( AppId_t unAppID, char const* cszFilePath, uint64 ullFileSize, uint32 uUnk ) = 0;
-	virtual bool BAddFileOnDisk( AppId_t unAppID, char const* cszFilePath, uint64 ullFileSize, uint32 uUnk, uint8 ubSha1[5] ) = 0;
+	virtual bool BAddFileOnDisk( AppId_t unAppID, char const* cszFilePath, uint64 ullFileSize, uint32 uUnk, SHADigestWrapper_t ubSha1 ) = 0;
 	virtual uint64 FinishAddingFiles( AppId_t unAppID ) = 0;
 };
 

Open Steamworks/IClientApps.h

 
 	virtual void RequestAppCallbacks( bool bOnlyMultiplayerApps ) = 0;
 
-	virtual int GetAppDataSection( AppId_t unAppID, int eSection, uint8 *pchBuffer, int cbBufferMax, bool bUseSymbolsAsKeys ) = 0;
+	virtual int GetAppDataSection( AppId_t unAppID, EAppInfoSection eSection, uint8 *pchBuffer, int cbBufferMax, bool bUseSymbolsAsKeys ) = 0;
 	virtual bool RequestAppInfoUpdate( const AppId_t *pAppIDs, int nNumAppIDs, bool bForceUpdate ) = 0;
 
 	virtual void NotifyAppEventTriggered( AppId_t unAppID, EAppEvent eAppEvent ) = 0;
 
 	virtual int GetDLCCount( AppId_t unAppID ) = 0;
 	virtual bool BGetDLCDataByIndex( AppId_t unAppID, int iIndex, AppId_t* unDLCAppID, bool *, char *, int) = 0;
+
+	virtual bool BReloadLocalAppInfoOverrides() = 0;
 };
 
 #endif // ICLIENTAPPS_H

Open Steamworks/IClientGameServer.h

 	virtual SteamAPICall_t AssociateWithClan( CSteamID clanID ) = 0;
 	virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamID ) = 0;
 
+	virtual void ForceHeartbeatViaCM() = 0;
+
 	// Ask if a user has a specific achievement for this game, will get a callback on reply
 	virtual bool _BGetUserAchievementStatus( CSteamID steamID, const char *pchAchievementName ) = 0;
 

Open Steamworks/IClientMatchmaking.h

 	virtual bool SetLobbyJoinable( CSteamID steamIDLobby, bool bLobbyJoinable ) = 0;
 	virtual CSteamID GetLobbyOwner( CSteamID steamIDLobby ) = 0;
 	virtual bool SetLobbyOwner( CSteamID steamIDLobby, CSteamID steamIDNewOwner ) = 0;
+	virtual bool SetLinkedLobby( CSteamID steamIDLobby, CSteamID steamIDLobby2 ) = 0;
 
 	virtual int GetGMSServerCount() = 0;
 	virtual bool GetGMSServerAddress( int iServer, uint32 *unServerIP, uint16 *usServerPort ) = 0;
 
 	// TODO : Check this when at least one GMS will be online.
 	virtual SteamAPICall_t BeginGMSQuery( AppId_t nAppId, int32 iRegionCode, const char* szFilterText ) = 0;
-	virtual int32 PollGMSQuery( SteamAPICall_t ) = 0;
-	virtual int32 GetGMSQueryResults( SteamAPICall_t, GMSQueryResult_t *, int32 iResultIndex ) = 0;
-	virtual void ReleaseGMSQuery( SteamAPICall_t ) = 0;
+	virtual int32 PollGMSQuery( SteamAPICall_t hGMSQuery ) = 0;
+	virtual int32 GetGMSQueryResults( SteamAPICall_t hGMSQuery, GMSQueryResult_t *pGMSQueryResult, int32 iResultIndex ) = 0;
+	virtual void ReleaseGMSQuery( SteamAPICall_t hGMSQuery ) = 0;
 };
 
 

Open Steamworks/IClientRemoteStorage.h

 	virtual bool FilePersisted( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
 	virtual int64 GetFileTimestamp( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
 
-	virtual bool SetSyncPlatforms( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile, int iUnk ) = 0;
+	virtual bool SetSyncPlatforms( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ) = 0;
 	virtual int GetSyncPlatforms( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
 
 	virtual int32 GetFileCount( AppId_t nAppId, bool bUnk1 ) = 0;
-	virtual const char *GetFileNameAndSize( AppId_t nAppId, int iFile, int *pnFileSizeInBytes, int iUnk2 ,bool bUnk1 ) = 0;
+	virtual const char *GetFileNameAndSize( AppId_t nAppId, int iFile, ERemoteStorageFileRoot *peRemoteStorageFileRoot, int *pnFileSizeInBytes, bool bUnk1 ) = 0;
 
 	virtual bool GetQuota( AppId_t nAppId, int32 *pnTotalBytes, int32 *pnAvailableBytes ) = 0;
 	
 	virtual bool IsCloudEnabledForApp( AppId_t nAppId );
 	virtual bool SetCloudEnabledForApp( AppId_t nAppId, bool bEnable );
 
-	virtual SteamAPICall_t UGCDownload( unsigned long long ) = 0;
-	virtual bool GetUGCDetails( unsigned long long,unsigned int *,char **,int *,CSteamID * ) = 0;
-	virtual int32 UGCRead( unsigned long long,void *,int ) = 0;
+	virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent, bool bUseNewCallback ) = 0; // Old callback id = 1308, new callback id = 1317
+	virtual bool GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 0;
+	virtual int32 UGCRead( UGCHandle_t hContent, void *pubDest, int32 nDestBufferSize ) = 0;
 	virtual int32 GetCachedUGCCount() = 0;
-	virtual uint64 GetCachedUGCHandle( int32 ) = 0;
+	virtual UGCHandle_t GetCachedUGCHandle( int32 iCachedContent ) = 0;
+
+	virtual SteamAPICall_t PublishFile( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *cszFileName, const char *cszPreviewFileName, AppId_t nConsumerAppId , const char *cszTitle, const char *cszDescription, ERemoteStoragePublishedFileVisibility eRemoteStoragePublishedFileVisibility, bool bOverwrite, SteamParamStringArray_t *pTags, bool bWorkshopFile ) = 0;
+	virtual SteamAPICall_t UpdatePublishedFile( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, RemoteStorageUpdatePublishedFileRequest_t remoteStorageUpdatePublishedFileRequest ) = 0;
+	virtual SteamAPICall_t GetPublishedFileDetails( uint64 ullPublishedFile ) = 0;
+	virtual SteamAPICall_t DeletePublishedFile( uint64 ullPublishedFile ) = 0;
+	virtual SteamAPICall_t EnumerateUserPublishedFiles( AppId_t nAppId, uint32 uStartIndex ) = 0;
+	virtual SteamAPICall_t SubscribePublishedFile( AppId_t nAppId, uint64 ullPublishedFile ) = 0;
+	virtual SteamAPICall_t EnumerateUserSubscribedFiles( AppId_t nAppId, uint32 uStartIndex ) = 0;
+	virtual SteamAPICall_t UnsubscribePublishedFile( AppId_t nAppId, uint64 ullPublishedFile ) = 0;
 	
-	virtual uint32 FilePersist( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
+	virtual EResult FilePersist( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
 
 	virtual bool FileFetch( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile ) = 0;
 
 	virtual bool ResolvePath( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *, char *, uint32 ) = 0;
 
-	virtual bool SetCloudEnabledForAccount( bool bEnable);
+	virtual EResult FileTouch( AppId_t nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, const char *pchFile, bool ) = 0;
+
+	virtual bool SetCloudEnabledForAccount( bool bEnable );
 
 	virtual void LoadLocalFileInfoCache( AppId_t nAppId ) = 0;
 
 	virtual void SynchronizeApp( AppId_t nAppId, bool bSyncClient, bool bSyncServer ) = 0;
 	virtual bool IsAppSyncInProgress( AppId_t nAppId ) = 0;
 
-	virtual ERemoteStorageFileRoot ERemoteStorageFileRootFromName( const char * ) = 0;
+	virtual ERemoteStorageFileRoot ERemoteStorageFileRootFromName( const char *cszName ) = 0;
 	virtual const char* PchNameFromERemoteStorageFileRoot( ERemoteStorageFileRoot eRemoteStorageFileRoot ) = 0;
 	
 	virtual bool ResetFileRequestState( AppId_t nAppId ) = 0;

Open Steamworks/IClientUser.h

 
 	virtual bool BGetGuideURL( uint32, char *, uint32 ) = 0;
 
-	virtual void GetClientAppListResponse_AddApp( unsigned int, bool,bool, bool, char  const*, unsigned long long, unsigned long long, unsigned int ) = 0;
-	virtual void GetClientAppListResponse_AddDLC( unsigned int, bool ) = 0;
+	virtual void GetClientAppListResponse_AddApp( AppId_t nAppId, bool bFavorite, bool bInstalled, bool bAutoUpdate, const char *cszCategory, const char *cszAppType, uint64 ullBytesDownloaded, uint64 ullBytesNeeded, uint32 uBytesDownloadRate ) = 0;
+	virtual void GetClientAppListResponse_AddDLC( AppId_t nAppId, bool bInstalled ) = 0;
 	virtual void GetClientAppListResponse_Done( unsigned long long ) = 0;
 	virtual void PostUIResultToClientJob( unsigned long long, EResult ) = 0;
 

Open Steamworks/ISteamGameServer011.h

 
 	// Force it to request a heartbeat from the master servers.
 	virtual void ForceHeartbeat() = 0;
+
+	virtual SteamAPICall_t AssociateWithClan( CSteamID clanID ) = 0;
+	virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamID ) = 0;
 };
 
 #endif // ISTEAMGAMESERVER011_H

Open Steamworks/ISteamMatchmaking009.h

+//==========================  Open Steamworks  ================================
+//
+// This file is part of the Open Steamworks project. All individuals associated
+// with this project do not claim ownership of the contents
+// 
+// The code, comments, and all related files, projects, resources,
+// redistributables included with this project are Copyright Valve Corporation.
+// Additionally, Valve, the Valve logo, Half-Life, the Half-Life logo, the
+// Lambda logo, Steam, the Steam logo, Team Fortress, the Team Fortress logo,
+// Opposing Force, Day of Defeat, the Day of Defeat logo, Counter-Strike, the
+// Counter-Strike logo, Source, the Source logo, and Counter-Strike Condition
+// Zero are trademarks and or registered trademarks of Valve Corporation.
+// All other trademarks are property of their respective owners.
+//
+//=============================================================================
+
+#ifndef ISTEAMMATCHMAKING009_H
+#define ISTEAMMATCHMAKING009_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "SteamTypes.h"
+#include "MatchmakingCommon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for match making services for clients to get to favorites
+//			and to operate on game lobbies.
+//-----------------------------------------------------------------------------
+abstract_class ISteamMatchmaking009
+{
+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, AppId_t *pnAppID, uint32 *pnIP, uint16 *pnConnPort, uint16 *pnQueryPort, 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( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags, uint32 rTime32LastPlayedOnServer ) =0;
+	
+	// removes the game server from the local storage; returns true if one was removed
+    virtual bool RemoveFavoriteGame( AppId_t nAppID, uint32 nIP, uint16 nConnPort, uint16 nQueryPort, uint32 unFlags ) = 0;
+
+	///////
+	// Game lobby functions
+
+	// Get a list of relevant lobbies
+	// this is an asynchronous request
+	// results will be returned by LobbyMatchList_t callback & call result, with the number of lobbies found
+	// this will never return lobbies that are full
+	// to add more filter, the filter calls below need to be call before each and every RequestLobbyList() call
+	// use the CCallResult<> object in steam_api.h to match the SteamAPICall_t call result to a function in an object, e.g.
+	/*
+		class CMyLobbyListManager
+		{
+			CCallResult<CMyLobbyListManager, LobbyMatchList_t> m_CallResultLobbyMatchList;
+			void FindLobbies()
+			{
+				// SteamMatchmaking()->AddRequestLobbyListFilter*() functions would be called here, before RequestLobbyList()
+				SteamAPICall_t hSteamAPICall = SteamMatchmaking()->RequestLobbyList();
+				m_CallResultLobbyMatchList.Set( hSteamAPICall, this, &CMyLobbyListManager::OnLobbyMatchList );
+			}
+
+			void OnLobbyMatchList( LobbyMatchList_t *pLobbyMatchList, bool bIOFailure )
+			{
+				// lobby list has be retrieved from Steam back-end, use results
+			}
+		}
+	*/
+	// 
+	virtual SteamAPICall_t RequestLobbyList() = 0;
+	// filters for lobbies
+	// this needs to be called before RequestLobbyList() to take effect
+	// these are cleared on each call to RequestLobbyList()
+	virtual void AddRequestLobbyListStringFilter( const char *pchKeyToMatch, const char *pchValueToMatch, ELobbyComparison eComparisonType ) = 0;
+	// numerical comparison
+	virtual void AddRequestLobbyListNumericalFilter( const char *pchKeyToMatch, int nValueToMatch, ELobbyComparison eComparisonType ) = 0;
+	// returns results closest to the specified value. Multiple near filters can be added, with early filters taking precedence
+	virtual void AddRequestLobbyListNearValueFilter( const char *pchKeyToMatch, int nValueToBeCloseTo ) = 0;
+	// returns only lobbies with the specified number of slots available
+	virtual void AddRequestLobbyListFilterSlotsAvailable( int nSlotsAvailable ) = 0;
+	// sets the distance for which we should search for lobbies (based on users IP address to location map on the Steam backed)
+	virtual void AddRequestLobbyListDistanceFilter( ELobbyDistanceFilter eLobbyDistanceFilter ) = 0;
+	// sets how many results to return, the lower the count the faster it is to download the lobby results & details to the client
+	virtual void AddRequestLobbyListResultCountFilter( int cMaxResults ) = 0;
+
+	virtual void AddRequestLobbyListCompatibleMembersFilter( CSteamID steamID ) = 0;
+
+	// returns the CSteamID of a lobby, as retrieved by a RequestLobbyList call
+	// should only be called after a LobbyMatchList_t callback is received
+	// iLobby is of the range [0, LobbyMatchList_t::m_nLobbiesMatching)
+	// the returned CSteamID::IsValid() will be false if iLobby is out of range
+	virtual CSteamID GetLobbyByIndex( int iLobby ) = 0;
+
+	// Create a lobby on the Steam servers.
+	// If private, then the lobby will not be returned by any RequestLobbyList() call; the CSteamID
+	// of the lobby will need to be communicated via game channels or via InviteUserToLobby()
+	// this is an asynchronous request
+	// results will be returned by LobbyCreated_t callback and call result; lobby is joined & ready to use at this pointer
+	// a LobbyEnter_t callback will also be received (since the local user is joining their own lobby)
+	virtual SteamAPICall_t CreateLobby( ELobbyType eLobbyType, int cMaxMembers ) = 0;
+
+	// Joins an existing lobby
+	// this is an asynchronous request
+	// results will be returned by LobbyEnter_t callback & call result, check m_EChatRoomEnterResponse to see if was successful
+	// lobby metadata is available to use immediately on this call completing
+	virtual SteamAPICall_t JoinLobby( CSteamID steamIDLobby ) = 0;
+
+	// Leave a lobby; this will take effect immediately on the client side
+	// other users in the lobby will be notified by a LobbyChatUpdate_t callback
+	virtual void LeaveLobby( CSteamID steamIDLobby ) = 0;
+
+	// Invite another user to the lobby
+	// the target user will receive a LobbyInvite_t callback
+	// will return true if the invite is successfully sent, whether or not the target responds
+	// returns false if the local user is not connected to the Steam servers
+	// if the other user clicks the join link, a GameLobbyJoinRequested_t will be posted if the user is in-game,
+	// or if the game isn't running yet the game will be launched with the parameter +connect_lobby <64-bit lobby id>
+	virtual bool InviteUserToLobby( CSteamID steamIDLobby, CSteamID steamIDInvitee ) = 0;
+
+	// Lobby iteration, for viewing details of users in a lobby
+	// only accessible if the lobby user is a member of the specified lobby
+	// persona information for other lobby members (name, avatar, etc.) will be asynchronously received
+	// and accessible via ISteamFriends interface
+	
+	// returns the number of users in the specified lobby
+	virtual int GetNumLobbyMembers( CSteamID steamIDLobby ) = 0;
+	// returns the CSteamID of a user in the lobby
+	// iMember is of range [0,GetNumLobbyMembers())
+	virtual CSteamID GetLobbyMemberByIndex( CSteamID steamIDLobby, int iMember ) = 0;
+
+	// Get data associated with this lobby
+	// takes a simple key, and returns the string associated with it
+	// "" will be returned if no value is set, or if steamIDLobby is invalid
+	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;
+
+	// returns the number of metadata keys set on the specified lobby
+	virtual int GetLobbyDataCount( CSteamID steamIDLobby ) = 0;
+
+	// returns a lobby metadata key/values pair by index, of range [0, GetLobbyDataCount())
+	virtual bool GetLobbyDataByIndex( CSteamID steamIDLobby, int iLobbyData, char *pchKey, int cchKeyBufferSize, char *pchValue, int cchValueBufferSize ) = 0;
+
+	// removes a metadata key from the lobby
+	virtual bool DeleteLobbyData( CSteamID steamIDLobby, const char *pchKey ) = 0;
+
+	// Gets per-user metadata 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 void 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
+	// pvMsgBody can be binary or text data, up to 4k
+	// if pvMsgBody is text, cubMsgBody should be strlen( text ) + 1, to include the null terminator
+	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;
+
+	// Refreshes metadata for a lobby you're not necessarily in right now
+	// you never do this for lobbies you're a member of, only if your
+	// 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
+	// restart are returned by a LobbyDataUpdate_t callback
+	virtual bool RequestLobbyData( CSteamID steamIDLobby ) = 0;
+	
+	// sets the game server associated with the lobby
+	// usually at this point, the users will join the specified game server
+	// either the IP/Port or the steamID of the game server has to be valid, depending on how you want the clients to be able to connect
+	virtual void SetLobbyGameServer( CSteamID steamIDLobby, uint32 unGameServerIP, uint16 unGameServerPort, CSteamID steamIDGameServer ) = 0;
+	// returns the details of a game server set in a lobby - returns false if there is no game server set, or that lobby doesn't exist
+	virtual bool GetLobbyGameServer( CSteamID steamIDLobby, uint32 *punGameServerIP, uint16 *punGameServerPort, CSteamID *psteamIDGameServer ) = 0;
+
+	// set the limit on the # of users who can join the lobby
+	virtual bool SetLobbyMemberLimit( CSteamID steamIDLobby, int cMaxMembers ) = 0;
+	// returns the current limit on the # of users who can join the lobby; returns 0 if no limit is defined
+	virtual int GetLobbyMemberLimit( CSteamID steamIDLobby ) = 0;
+
+	// updates which type of lobby it is
+	// only lobbies that are k_ELobbyTypePublic or k_ELobbyTypeInvisible, and are set to joinable, will be returned by RequestLobbyList() calls
+	virtual bool SetLobbyType( CSteamID steamIDLobby, ELobbyType eLobbyType ) = 0;
+
+	// sets whether or not a lobby is joinable - defaults to true for a new lobby
+	// if set to false, no user can join, even if they are a friend or have been invited
+	virtual bool SetLobbyJoinable( CSteamID steamIDLobby, bool bLobbyJoinable ) = 0;
+
+	// returns the current lobby owner
+	// you must be a member of the lobby to access this
+	// there always one lobby owner - if the current owner leaves, another user will become the owner
+	// it is possible (bur rare) to join a lobby just as the owner is leaving, thus entering a lobby with self as the owner
+	virtual CSteamID GetLobbyOwner( CSteamID steamIDLobby ) = 0;
+
+	// changes who the lobby owner is
+	// you must be the lobby owner for this to succeed, and steamIDNewOwner must be in the lobby
+	// after completion, the local user will no longer be the owner
+	virtual bool SetLobbyOwner( CSteamID steamIDLobby, CSteamID steamIDNewOwner ) = 0;
+
+	virtual bool SetLinkedLobby( CSteamID steamIDLobby, CSteamID steamIDLobby2 ) = 0;
+};
+
+#endif // ISTEAMMATCHMAKING009_H

Open Steamworks/ISteamRemoteStorage004.h

 	virtual void SetCloudEnabledForApp( bool bEnabled ) = 0;
 
 	// user generated content
-	virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent ) = 0;
+	virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent ) = 0; // Returns a Deprecated_RemoteStorageDownloadUGCResult_t callback
 	virtual bool	GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 0;
 	virtual int32	UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead ) = 0;
 

Open Steamworks/ISteamRemoteStorage005.h

+//==========================  Open Steamworks  ================================
+//
+// This file is part of the Open Steamworks project. All individuals associated
+// with this project do not claim ownership of the contents
+// 
+// The code, comments, and all related files, projects, resources,
+// redistributables included with this project are Copyright Valve Corporation.
+// Additionally, Valve, the Valve logo, Half-Life, the Half-Life logo, the
+// Lambda logo, Steam, the Steam logo, Team Fortress, the Team Fortress logo,
+// Opposing Force, Day of Defeat, the Day of Defeat logo, Counter-Strike, the
+// Counter-Strike logo, Source, the Source logo, and Counter-Strike Condition
+// Zero are trademarks and or registered trademarks of Valve Corporation.
+// All other trademarks are property of their respective owners.
+//
+//=============================================================================
+
+#ifndef ISTEAMREMOTESTORAGE005_H
+#define ISTEAMREMOTESTORAGE005_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "SteamTypes.h"
+#include "RemoteStorageCommon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Functions for accessing, reading and writing files stored remotely 
+//			and cached locally
+//-----------------------------------------------------------------------------
+abstract_class ISteamRemoteStorage005
+{
+public:
+	// NOTE
+	//
+	// Filenames are case-insensitive, and will be converted to lowercase automatically.
+	// So "foo.bar" and "Foo.bar" are the same file, and if you write "Foo.bar" then
+	// iterate the files, the filename returned will be "foo.bar".
+	//
+
+	// file operations
+	virtual bool	FileWrite( const char *pchFile, const void *pvData, int32 cubData ) = 0;
+	virtual int32	FileRead( const char *pchFile, void *pvData, int32 cubDataToRead ) = 0;
+	virtual bool	FileForget( const char *pchFile ) = 0;
+	virtual bool	FileDelete( const char *pchFile ) = 0;
+	virtual SteamAPICall_t FileShare( const char *pchFile ) = 0;
+	virtual bool	SetSyncPlatforms( const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ) = 0;
+
+	// file information
+	virtual bool	FileExists( const char *pchFile ) = 0;
+	virtual bool	FilePersisted( const char *pchFile ) = 0;
+	virtual int32	GetFileSize( const char *pchFile ) = 0;
+	virtual int64	GetFileTimestamp( const char *pchFile ) = 0;
+	virtual ERemoteStoragePlatform GetSyncPlatforms( const char *pchFile ) = 0;
+
+	// iteration
+	virtual int32 GetFileCount() = 0;
+	virtual const char *GetFileNameAndSize( int iFile, int32 *pnFileSizeInBytes ) = 0;
+
+	// configuration management
+	virtual bool GetQuota( int32 *pnTotalBytes, int32 *puAvailableBytes ) = 0;
+	virtual bool IsCloudEnabledForAccount() = 0;
+	virtual bool IsCloudEnabledForApp() = 0;
+	virtual void SetCloudEnabledForApp( bool bEnabled ) = 0;
+
+	// user generated content
+	virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent ) = 0; // Returns a RemoteStorageDownloadUGCResult_t callback
+	virtual bool	GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 0;
+	virtual int32	UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead ) = 0;
+
+	// user generated content iteration
+	virtual int32	GetCachedUGCCount() = 0;
+	virtual	UGCHandle_t GetCachedUGCHandle( int32 iCachedContent ) = 0;
+
+	virtual SteamAPICall_t PublishFile( const char *cszFileName, const char *cszPreviewFileName, AppId_t nConsumerAppId, const char *cszTitle, const char *cszDescription, ERemoteStoragePublishedFileVisibility eRemoteStoragePublishedFileVisibility, SteamParamStringArray_t *pTags ) = 0;
+	virtual SteamAPICall_t PublishWorkshopFile( const char *cszFileName, const char *cszPreviewFileName, AppId_t nConsumerAppId, const char *cszTitle, const char *cszDescription, bool bOverwrite, SteamParamStringArray_t *pTags ) = 0;
+	virtual SteamAPICall_t UpdatePublishedFile( RemoteStorageUpdatePublishedFileRequest_t remoteStorageUpdatePublishedFileRequest ) = 0;
+	virtual SteamAPICall_t GetPublishedFileDetails( uint64 ullPublishedFile ) = 0;
+	virtual SteamAPICall_t DeletePublishedFile( uint64 ullPublishedFile ) = 0;
+	virtual SteamAPICall_t EnumerateUserPublishedFiles( uint32 uStartIndex ) = 0;
+	virtual SteamAPICall_t SubscribePublishedFile( uint64 ullPublishedFile ) = 0;
+	virtual SteamAPICall_t EnumerateUserSubscribedFiles( uint32 uStartIndex ) = 0;
+	virtual SteamAPICall_t UnsubscribePublishedFile( uint64 ullPublishedFile ) = 0;
+};
+
+#endif // ISTEAMREMOTESTORAGE005_H

Open Steamworks/MatchmakingCommon.h

 #define STEAMMATCHMAKING_INTERFACE_VERSION_006 "SteamMatchMaking006"
 #define STEAMMATCHMAKING_INTERFACE_VERSION_007 "SteamMatchMaking007"
 #define STEAMMATCHMAKING_INTERFACE_VERSION_008 "SteamMatchMaking008"
-
+#define STEAMMATCHMAKING_INTERFACE_VERSION_009 "SteamMatchMaking009"
 
 
 

Open Steamworks/Open Steamworks.vcproj

 <?xml version="1.0" encoding="Windows-1252"?>
 <VisualStudioProject
 	ProjectType="Visual C++"
-	Version="9.00"
+	Version="9,00"
 	Name="Open Steamworks"
 	ProjectGUID="{A0C16874-A8AD-48C4-AE6E-DECF5C70D7FB}"
 	RootNamespace="SteamclientAPI"
 						>
 					</File>
 					<File
+						RelativePath=".\ISteamMatchmaking009.h"
+						>
+					</File>
+					<File
 						RelativePath=".\MatchmakingCommon.h"
 						>
 					</File>
 						>
 					</File>
 					<File
+						RelativePath=".\ISteamRemoteStorage005.h"
+						>
+					</File>
+					<File
 						RelativePath=".\RemoteStorageCommon.h"
 						>
 					</File>

Open Steamworks/RemoteStorageCommon.h

 #define STEAMREMOTESTORAGE_INTERFACE_VERSION_002 "STEAMREMOTESTORAGE_INTERFACE_VERSION002"
 #define STEAMREMOTESTORAGE_INTERFACE_VERSION_003 "STEAMREMOTESTORAGE_INTERFACE_VERSION003"
 #define STEAMREMOTESTORAGE_INTERFACE_VERSION_004 "STEAMREMOTESTORAGE_INTERFACE_VERSION004"
+#define STEAMREMOTESTORAGE_INTERFACE_VERSION_005 "STEAMREMOTESTORAGE_INTERFACE_VERSION005"
 
 #define CLIENTREMOTESTORAGE_INTERFACE_VERSION "CLIENTREMOTESTORAGE_INTERFACE_VERSION001"
 
 {
 	k_ERemoteStorageFileRootInvalid = 0,
 	k_ERemoteStorageFileRootDefault,
+	k_ERemoteStorageFileRootGameInstall,
+	k_ERemoteStorageFileRootWinMyDocuments,
+	k_ERemoteStorageFileRootWinAppDataLocal,
+	k_ERemoteStorageFileRootWinAppDataRoaming,
+	k_ERemoteStorageFileRootSteamUserBaseStorage,
+	k_ERemoteStorageFileRootMacHome,
+	k_ERemoteStorageFileRootMacAppSupport,
+	k_ERemoteStorageFileRootMacDocuments,
 	k_ERemoteStorageFileRootMax
 } ERemoteStorageFileRoot;
 
 } EResolveConflict;
 
 
+struct RemoteStorageUpdatePublishedFileRequest_t;
+enum ERemoteStoragePublishedFileVisibility;
+struct SteamParamStringArray_t;
+
 #pragma pack( push, 8 )
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // Purpose: The result of a call to UGCDownload()
 //-----------------------------------------------------------------------------
-struct RemoteStorageDownloadUGCResult_t
+struct Deprecated_RemoteStorageDownloadUGCResult_t
 {
 	enum { k_iCallback = k_iClientRemoteStorageCallbacks + 8 };
 	EResult m_eResult;				// The result of the operation.
 	uint64 m_ulSteamIDOwner;		// Steam ID of the user who created this content.
 };
 
+//-----------------------------------------------------------------------------
+// Purpose: The result of a call to UGCDownload()
+//-----------------------------------------------------------------------------
+struct RemoteStorageDownloadUGCResult_t
+{
+	enum { k_iCallback = k_iClientRemoteStorageCallbacks + 17 };
+	EResult m_eResult;				// The result of the operation.
+	UGCHandle_t m_hFile;			// The handle to the file that was attempted to be downloaded.
+	AppId_t m_nAppID;				// ID of the app that created this file.
+	int32 m_nSizeInBytes;			// The size of the file that was downloaded, in bytes.
+	char m_pchFileName[260];		// The name of the file that was downloaded.
+	uint64 m_ulSteamIDOwner;		// Steam ID of the user who created this content.
+};
+
 #pragma pack( pop )
 
 

Open Steamworks/Steamclient.h

 #include "ISteamMatchmaking006.h"
 #include "ISteamMatchmaking007.h"
 #include "ISteamMatchmaking008.h"
+#include "ISteamMatchmaking009.h"
 
 // matchmaking servers
 #include "ISteamMatchmakingServers001.h"
 // remote storage
 #include "ISteamRemoteStorage001.h"
 #include "ISteamRemoteStorage002.h"
+#include "ISteamRemoteStorage003.h"
 #include "ISteamRemoteStorage004.h"
-#include "ISteamRemoteStorage003.h"
+#include "ISteamRemoteStorage005.h"
 
 // content server
 #include "ISteamContentServer001.h"

Open Steamworks/TSteamSubscription.h

 	eHardwarePromo = 5,
 	eGift = 6,
 	eAutoGrant = 7,
-	eNumBillingTypes = 8,
+	OEMTicket = 8,
+	eRecurringOption = 9,
+	eNumBillingTypes = 10,
 } EBillingType;