diff options
Diffstat (limited to 'gcsdk/steammessages.proto')
| -rw-r--r-- | gcsdk/steammessages.proto | 860 |
1 files changed, 860 insertions, 0 deletions
diff --git a/gcsdk/steammessages.proto b/gcsdk/steammessages.proto new file mode 100644 index 0000000..5eda1a4 --- /dev/null +++ b/gcsdk/steammessages.proto @@ -0,0 +1,860 @@ +//====== Copyright 1996-2010, Valve Corporation, All rights reserved. ======= +// +// Purpose: The file defines our Google Protocol Buffers which are used in over +// the wire messages between servers as well as between clients and servers. +// +//============================================================================= + +// We care more about speed than code size +option optimize_for = SPEED; + +// We don't use the service generation functionality +option cc_generic_services = false; + + +// +// STYLE NOTES: +// +// Use CamelCase CMsgMyMessageName style names for messages. +// +// Use lowercase _ delimited names like my_steam_id for field names, this is non-standard for Steam, +// but plays nice with the Google formatted code generation. +// +// Try not to use required fields ever. Only do so if you are really really sure you'll never want them removed. +// Optional should be preffered as it will make versioning easier and cleaner in the future if someone refactors +// your message and wants to remove or rename fields. +// +// Use fixed64 for JobId_t, GID_t, or SteamID. This is appropriate for any field that is normally +// going to be larger than 2^56. Otherwise use int64 for 64 bit values that are frequently smaller +// than 2^56 as it will safe space on the wire in those cases. +// +// Similar to fixed64, use fixed32 for RTime32 or other 32 bit values that are frequently larger than +// 2^28. It will safe space in those cases, otherwise use int32 which will safe space for smaller values. +// An exception to this rule for RTime32 is if the value will frequently be zero rather than set to an actual +// time. +// + +import "google/protobuf/descriptor.proto"; + +extend google.protobuf.FieldOptions { + optional bool key_field = 60000 [ default = false ]; +} + + +extend google.protobuf.MessageOptions{ + // Allows us to customize the pooling for different messages + optional int32 msgpool_soft_limit = 60000 [default=32]; + optional int32 msgpool_hard_limit = 60001 [default=384]; +} + +enum GCProtoBufMsgSrc +{ + GCProtoBufMsgSrc_Unspecified = 0; + GCProtoBufMsgSrc_FromSystem = 1; + GCProtoBufMsgSrc_FromSteamID = 2; + GCProtoBufMsgSrc_FromGC = 3; + GCProtoBufMsgSrc_ReplySystem = 4; +}; + +// +// Message header, every protcol buffer based message starts with this. +// +message CMsgProtoBufHeader +{ + option (msgpool_soft_limit) = 256; + option (msgpool_hard_limit) = 1024; + + // All fields here are optional. + + // Client message header fields + optional fixed64 client_steam_id = 1; // SteamID of the client sending this, typically set in all client originated messages. + optional int32 client_session_id = 2; // SessionID of the client on the CM + + // Source appId for inter-gc messages + optional uint32 source_app_id = 3; // appId of source GC message sender + + // Job routing (may be set on client or inter-server messages) + optional fixed64 job_id_source = 10 [ default = 0xFFFFFFFFFFFFFFFF ]; // JobID that sent this message + optional fixed64 job_id_target = 11 [ default = 0xFFFFFFFFFFFFFFFF ]; // The target job which is expected to be waiting on this message + optional string target_job_name = 12; // the type of job to start when this message is received + + optional int32 eresult = 13 [default = 2]; // For response jobs, the corresponding eresult + optional string error_message = 14; // Optionally an error message in case of failure. Mostly used for debugging purpose. + + // Where did this message originally enter the system? From a client, from another GC, etc + optional GCProtoBufMsgSrc gc_msg_src = 200; + // If this came from another GC, what is the GC that it came from + optional uint32 gc_dir_index_source = 201; +} + + +// +// Used to serialize CWebAPIKey objects. +// +message CMsgWebAPIKey +{ + optional uint32 status = 1 [ default = 0xFF ]; + optional uint32 account_id = 2 [ default = 0 ]; + optional uint32 publisher_group_id = 3 [ default = 0 ]; + optional uint32 key_id = 4; + optional string domain = 5; +} + + +// +// An HTTP request message +// +message CMsgHttpRequest +{ + message RequestHeader + { + optional string name = 1; + optional string value = 2; + } + + message QueryParam + { + optional string name = 1; + optional bytes value = 2; + } + + optional uint32 request_method = 1; + optional string hostname = 2; + optional string url = 3; + repeated RequestHeader headers = 4; + repeated QueryParam get_params = 5; + repeated QueryParam post_params = 6; + optional bytes body = 7; + optional uint32 absolute_timeout = 8; +} + + +// +// A web API request +// +message CMsgWebAPIRequest +{ + optional string UNUSED_job_name = 1; // no longer used + optional string interface_name = 2; + optional string method_name = 3; + optional uint32 version = 4; + optional CMsgWebAPIKey api_key = 5; + optional CMsgHttpRequest request = 6; + optional uint32 routing_app_id = 7; +} + + +// +// An HTTP response +// +message CMsgHttpResponse +{ + message ResponseHeader + { + optional string name = 1; + optional string value = 2; + } + + optional uint32 status_code = 1; + repeated ResponseHeader headers = 2; + optional bytes body = 3; +} + +// +// Message struct for k_EMsgAMFindAccounts +// +message CMsgAMFindAccounts +{ + optional uint32 search_type = 1; + optional string search_string = 2; +} + + +// +// Message struct for k_EMsgAMFindAccountsResponse +// +message CMsgAMFindAccountsResponse +{ + repeated fixed64 steam_id = 1; +} + +// +// k_EMsgNotifyWatchdog +// +message CMsgNotifyWatchdog +{ + optional uint32 source = 1; // Alert source + optional uint32 alert_type = 2; // type of alert + optional uint32 alert_destination = 3; // destination for alert + optional bool critical = 4; // Is the alert critical + optional uint32 time = 5; // world time that alert occurred + optional uint32 appid = 6; // app to forward the alert to for alerts with alert_type set to AppID + optional string text = 7; // Alert text +} + +// +// k_EGCMsgGetLicenses +// +message CMsgAMGetLicenses +{ + optional fixed64 steamid = 1; // the steam ID to fetch licenses for +} + + +// +// Used by CMsgAMGetLicensesResponse +// +message CMsgPackageLicense +{ + optional uint32 package_id = 1; // ID of the package this license is for + optional uint32 time_created = 2; // RTime32 when the license was granted + optional uint32 owner_id = 3; // the original owner if this license. if this is different from given steamid, it's a borrowed package +} + +// +// k_EMsgAMGetLicensesResponse +// +message CMsgAMGetLicensesResponse +{ + repeated CMsgPackageLicense license = 1; // the list of licenses the user owns + optional uint32 result = 2; // result code, k_EResultOK on success + +} + + +// +// k_EMsgAMGetUserGameStats +// +message CMsgAMGetUserGameStats +{ + optional fixed64 steam_id = 1; // ID of user + optional fixed64 game_id = 2; // Game ID of stats to get + repeated uint32 stats = 3; +} + + +// +// k_EMsgAMGetUserGameStatsResponse +// +message CMsgAMGetUserGameStatsResponse +{ + optional fixed64 steam_id = 1; // ID of user + optional fixed64 game_id = 2; // Game ID + optional int32 eresult = 3 [default = 2]; // EResult with result of query. (Fields following are only valid if this is EResultOK.) + + message Stats + { + optional uint32 stat_id = 1; + optional uint32 stat_value = 2; // There are 4 of these, really only 8 bits each. Yay for compression! + } + + message Achievement_Blocks + { + optional uint32 achievement_id = 1; + optional uint32 achievement_bit_id = 2; + optional fixed32 unlock_time = 3; // There are only 32 of these, matching the achievment bitfields, we check on the receiver that + } + + repeated Stats stats = 4; + + repeated Achievement_Blocks achievement_blocks = 5; + +} + + +// k_EMsgAdminGCGetCommandList +message CMsgGCGetCommandList +{ + optional uint32 app_id = 1; + optional string command_prefix = 2; // prefix of the command to filter by +}; + +// k_EMsgAdminGCGetCommandListResponse +message CMsgGCGetCommandListResponse +{ + repeated string command_name = 1; // a list of command names +}; + +// +// k_EGCMsgMemCachedGet +// +message CGCMsgMemCachedGet +{ + repeated string keys = 1; +} + +// +// k_EGCMsgMemCachedGetResponse +// +message CGCMsgMemCachedGetResponse +{ + message ValueTag + { + optional bool found = 1; + optional bytes value = 2; + } + + repeated ValueTag values = 1; +} + +// +// k_EGCMsgMemCachedSet +// +message CGCMsgMemCachedSet +{ + message KeyPair + { + optional string name = 1; + optional bytes value = 2; + } + + repeated KeyPair keys = 1; +} + +// +// k_EGCMsgMemCachedDelete +// +message CGCMsgMemCachedDelete +{ + repeated string keys = 1; +} + +// +// k_EGCMsgMemCachedStats +// +message CGCMsgMemCachedStats +{ + // Nothing, yet. +} + +// +// k_EGCMsgMemCachedStatsResponse +// +message CGCMsgMemCachedStatsResponse +{ + optional uint64 curr_connections = 1; + optional uint64 cmd_get = 2; + optional uint64 cmd_set = 3; + optional uint64 cmd_flush = 4; + optional uint64 get_hits = 5; + optional uint64 get_misses = 6; + optional uint64 delete_hits = 7; + optional uint64 delete_misses = 8; + optional uint64 bytes_read = 9; + optional uint64 bytes_written = 10; + optional uint64 limit_maxbytes = 11; + optional uint64 curr_items = 12; + optional uint64 evictions = 13; + optional uint64 bytes = 14; +} + +// +// k_EGCMsgSQLStats +// +message CGCMsgSQLStats +{ + optional uint32 schema_catalog = 1; +} + +// +// k_EGCMsgSQLStatsResponse +// +message CGCMsgSQLStatsResponse +{ + optional uint32 threads = 1; + optional uint32 threads_connected = 2; + optional uint32 threads_active = 3; + optional uint32 operations_submitted = 4; + optional uint32 prepared_statements_executed = 5; + optional uint32 non_prepared_statements_executed = 6; + optional uint32 deadlock_retries = 7; + optional uint32 operations_timed_out_in_queue = 8; + optional uint32 errors = 9; +} + +// k_EMsgAMAddFreeLicense +message CMsgAMAddFreeLicense +{ + optional fixed64 steamid = 1; // SteamID of account + optional uint32 ip_public = 2; // IP of client (zero if not a client-initiated message) + optional uint32 packageid = 3; // ID for package to purchase. Should be k_uPackageIdInvalid if shopping cart gid set + optional string store_country_code = 4; // country code to use for purchase +}; + +// k_EMsgAMAddFreeLicenseResponse +message CMsgAMAddFreeLicenseResponse +{ + optional int32 eresult = 1 [default = 2]; // EResult with result of Purchase. + optional int32 purchase_result_detail = 2; // Detailed result information + optional fixed64 transid = 3; // ID of the created transaction +}; + + +// +// k_EGCMsgGetIPLocation +// +message CGCMsgGetIPLocation +{ + repeated fixed32 ips = 1; +} + +// +// k_EGCMsgGetIPLocationResponse +// +message CIPLocationInfo +{ + optional uint32 ip = 1; + optional float latitude = 2; + optional float longitude = 3; + optional string country = 4; + optional string state = 5; + optional string city = 6; +} + +message CGCMsgGetIPLocationResponse +{ + repeated CIPLocationInfo infos = 1; +} + + +// +// k_EGCMsgSystemStatsSchema +// +message CGCMsgSystemStatsSchema +{ + optional uint32 gc_app_id = 1; + optional bytes schema_kv = 2; +} + +// +// k_EGCMsgGetSystemStats +// +message CGCMsgGetSystemStats +{ +} + +// +// k_EGCMsgGetSystemStatsResponse +// +message CGCMsgGetSystemStatsResponse +{ + optional uint32 gc_app_id = 1; + optional bytes stats_kv = 2; + // statically included in GCHost's stats + optional uint32 active_jobs = 3; + optional uint32 yielding_jobs = 4; + optional uint32 user_sessions = 5; + optional uint32 game_server_sessions = 6; + optional uint32 socaches = 7; + optional uint32 socaches_to_unload = 8; + optional uint32 socaches_loading = 9; + optional uint32 writeback_queue = 10; + optional uint32 steamid_locks = 11; + optional uint32 logon_queue = 12; + optional uint32 logon_jobs = 13; +} + +// k_EGCMsgSendEmail +message CMsgAMSendEmail +{ + message ReplacementToken + { + optional string token_name = 1; + optional string token_value = 2; + } + message PersonaNameReplacementToken + { + optional fixed64 steamid = 1; + optional string token_name = 2; + } + optional fixed64 steamid = 1; + optional uint32 email_msg_type = 2; + optional uint32 email_format = 3; + repeated PersonaNameReplacementToken persona_name_tokens = 5; + + optional uint32 source_gc = 6; + repeated ReplacementToken tokens = 7; +} + +// k_EGCMsgSendEmailResponse +message CMsgAMSendEmailResponse +{ + optional uint32 eresult = 1 [default = 2]; +} + +// k_EGCMsgGetEmailTemplate +message CMsgGCGetEmailTemplate +{ + optional uint32 app_id = 1; + optional uint32 email_msg_type = 2; + optional int32 email_lang = 3; + optional int32 email_format = 4; +} + +// k_EGCMsgGetEmailTemplateResponse +message CMsgGCGetEmailTemplateResponse +{ + optional uint32 eresult = 1 [default = 2]; + optional bool template_exists = 2; + optional string template = 3; +} + +// k_EMsgAMGrantGuestPasses2 +message CMsgAMGrantGuestPasses2 +{ + optional fixed64 steam_id = 1; + optional uint32 package_id = 2; + optional int32 passes_to_grant = 3; + optional int32 days_to_expiration = 4; + optional int32 action = 5; +} + +// k_EMsgAMGrantGuestPasses2Response +message CMsgAMGrantGuestPasses2Response +{ + optional int32 eresult = 1 [default = 2]; + optional int32 passes_granted = 2 [default = 0]; +} + +// k_EGCMsgGetAccountDetails +message CGCSystemMsg_GetAccountDetails +{ + option (msgpool_soft_limit) = 128; + option (msgpool_hard_limit) = 512; + + optional fixed64 steamid = 1; // User to get details for + optional uint32 appid = 2; // appid of the source GC +} + +message CGCSystemMsg_GetAccountDetails_Response +{ + option (msgpool_soft_limit) = 128; + option (msgpool_hard_limit) = 512; + + optional uint32 eresult_deprecated = 1 [ default = 2 ]; // Result of the request + optional string account_name = 2; // Login name for the user + optional string persona_name = 3; // Diplay name for the user + optional bool is_profile_public = 4; // Is the user's profile public + optional bool is_inventory_public = 5; // Is the user's inventory public + //optional bool is_trusted = 6; // Is the user trusted + optional bool is_vac_banned = 7; // Is the user vac banned + optional bool is_cyber_cafe = 8; // Is the user a cybe cafe + optional bool is_school_account = 9; // Is the user a school account + optional bool is_limited = 10; // Is the user limited + optional bool is_subscribed = 11; // Is the user subscribed to this app + optional uint32 package = 12; // The package the user owns the app through + optional bool is_free_trial_account = 13; // Is the user playing the game for free + optional uint32 free_trial_expiration = 14; // If the user is playing for free, when does it expire? + optional bool is_low_violence = 15; // Is the user restricted to low-violence for this app + optional bool is_account_locked_down = 16; // Is the user's account locked + optional bool is_community_banned = 17; // Is the user banned from performing community actions + optional bool is_trade_banned = 18; // Is the user banned from trading items to other users on Steam + optional uint32 trade_ban_expiration = 19; // The time at which the user is unbanned from trading + optional uint32 accountid = 20; // The account ID of the user we're responding about + optional uint32 suspension_end_time = 21; // If suspended (ban that ends), the date/time the suspension ends + optional string currency = 22; // The currency associated with this account + optional uint32 steam_level = 23; // The Steam level of the user + optional uint32 friend_count = 24; // Number of friends + optional uint32 account_creation_time = 25; // Time when the account was created + optional bool is_steamguard_enabled = 27; // Is SteamGuard enabled + optional bool is_phone_verified = 28; // Has a verified phone number + optional bool is_two_factor_auth_enabled = 29; // Has SteamGuard two factor auth + optional uint32 two_factor_enabled_time = 30; // Time two factor was added + optional uint32 phone_verification_time = 31; // Time phone was verified + optional uint64 phone_id = 33; // Phone identifier + optional bool is_phone_identifying = 34; // Phone is useful for identity +} + +// +// k_EGCMsgCheckClanMembership +// +message CMsgGCCheckClanMembership +{ + optional fixed64 steamid = 1; // [ (description) = "User whose group memberships we want" ]; + optional uint32 clanid = 2; // [ (description) = "Clan to check membership against" ]; + +} + +message CMsgGCCheckClanMembership_Response +{ + optional bool ismember = 1; // [ (description) = "Whether the user in question is a member of the group in question" ]; +} + +// +// k_EGCMsgGetPersonaNames +// +message CMsgGCGetPersonaNames +{ + repeated fixed64 steamids = 1; // Users whose persona names we want +} + +message CMsgGCGetPersonaNames_Response +{ + message PersonaName + { + optional fixed64 steamid = 1; // User we could get a name for + optional string persona_name = 2; // Display name for that user + } + + repeated PersonaName succeeded_lookups = 1; // Users we could get names for + repeated fixed64 failed_lookup_steamids = 2; // Users we failed to get a names for +} + + +// +// k_EGCMsgCheckFriendship +// +message CMsgGCCheckFriendship +{ + optional fixed64 steamid_left = 1; // User whose friends list we'll load + optional fixed64 steamid_right = 2; // User to look for in the list we load +} + +message CMsgGCCheckFriendship_Response +{ + optional bool success = 1; // Whether the API calls all succeeded + optional bool found_friendship = 2; // Denotes whether the users are friends (false on API failure) +} + + +// +// k_EGCMsgMasterSetDirectory +// +message CMsgGCMsgMasterSetDirectory +{ + message SubGC + { + optional uint32 dir_index = 1; // The index in the GC directory indicating what role this GC serves + optional string name = 2; // A string to give the GC a name for asserts/logs/connection, etc + optional string box = 3; // The box that this GC is expected to be associated with + optional string command_line = 4; // Additional command line parameters to provide for this GC instance + optional string gc_binary = 5; // The binary that should be launched for this GC. This can be left blank to launch the default binary + } + + optional uint32 master_dir_index = 1; // The index of the master GC so that it knows how to setup the routing tables to include the master and sub GCs + repeated SubGC dir = 2; // A listing of the various sub GCs that the GCH should create +} + +message CMsgGCMsgMasterSetDirectory_Response +{ + optional int32 eresult = 1 [default = 2]; // Could the GC start the processes? It doesn't mean they will all get initialized and each sub GC still needs to ack, but catches failure earlier +} + +// +// k_EGCMsgWebAPIJobRequestForwardResponse +// +message CMsgGCMsgWebAPIJobRequestForwardResponse +{ + optional uint32 dir_index = 1; // The directory index of the GC which has been delegated to handle this particular WebAPI request +} + +// +// k_EGCMsgGetPurchaseTrustStatus +// +message CGCSystemMsg_GetPurchaseTrust_Request +{ + optional fixed64 steamid = 1; // User to get details for +} + +message CGCSystemMsg_GetPurchaseTrust_Response +{ + optional bool has_prior_purchase_history = 1; // The user has prior purchase history with no recent gaps in purchase activity + optional bool has_no_recent_password_resets = 2; // The user hasn't had their password reset recently + optional bool is_wallet_cash_trusted = 3; // False if the user has recently used a new payment method to fund his or her wallet + optional uint32 time_all_trusted = 4; // The time that the user will be trusted in all of the given fields if he or she were to complete a microtransaction right now +} + +// k_EMsgGCHAccountVacStatusChange +message CMsgGCHAccountVacStatusChange +{ + optional fixed64 steam_id = 1; + optional uint32 app_id = 2; + optional uint32 rtime_vacban_starts = 3; + optional bool is_banned_now = 4; + optional bool is_banned_future = 5; +} + +// k_EMsgGCHAccountTradeBanStatusChange +message CMsgGCHAccountTradeBanStatusChange +{ + optional fixed64 steamid = 1; + optional uint32 appid = 2; + optional bool is_banned = 3; + optional uint32 time_banned_until = 4; +} + +// k_EMsgGCHAccountLockStatusChange +message CMsgGCHAccountLockStatusChange +{ + optional fixed64 steamid = 1; + optional uint32 appid = 2; + optional bool is_locked = 3; +} + +// k_EMsgGCHVacVerificationChange +message CMsgGCHVacVerificationChange +{ + optional fixed64 steamid = 1; + optional uint32 appid = 2; + optional bool is_verified = 3; +} + +// k_EMsgGCHAccountPhoneNumberChange +message CMsgGCHAccountPhoneNumberChange +{ + optional fixed64 steamid = 1; + optional uint32 appid = 2; + optional uint64 phone_id = 3; + optional bool is_verified = 4; + optional bool is_identifying = 5; +} + +// k_EMsgGCHAccountTwoFactorChange +message CMsgGCHAccountTwoFactorChange +{ + optional fixed64 steamid = 1; + optional uint32 appid = 2; + optional bool twofactor_enabled = 3; +} + +// +// k_EGCMsgGetPartnerAccountLink +// +message CMsgGCGetPartnerAccountLink +{ + optional fixed64 steamid = 1; // User whose partner account link details we want to get +} + +message CMsgGCGetPartnerAccountLink_Response +{ + optional uint32 pwid = 1; // Perfect World ID (not specified if not linked) + optional uint32 nexonid = 2; // Nexon ID (not specified if not linked) +} + + +// +// k_EGCMsgMasterSetWebAPIRouting and k_EGCMsgMasterSetClientMsgRouting +// +message CMsgGCRoutingInfo +{ + enum RoutingMethod + { + RANDOM = 0; // random instead of round-robin so that we don't need to track state per routing pool + DISCARD = 1; + CLIENT_STEAMID = 2; + PROTOBUF_FIELD_UINT64 = 3; + WEBAPI_PARAM_UINT64 = 4; + } + + repeated uint32 dir_index = 1; // One or more directory indices which are potential targets for this route + optional RoutingMethod method = 2 [ default = RANDOM ]; // Method by which the route choses its target from multiple dir_index values + optional RoutingMethod fallback = 3 [ default = DISCARD ]; // Fallback method to use when default method is not applicable (eg, field can't be parsed) + optional uint32 protobuf_field = 4; // For PROTOBUF_FIELD_UINT64, the protobuf field number to decode as a uint64 for routing + optional string webapi_param = 5; // For WEBAPI_PARAM_UINT64 method, the case-insensitive name of the webapi parameter +} + +message CMsgGCMsgMasterSetWebAPIRouting +{ + message Entry + { + optional string interface_name = 1; + optional string method_name = 2; + optional CMsgGCRoutingInfo routing = 3; + } + repeated Entry entries = 1; +} + +message CMsgGCMsgMasterSetClientMsgRouting +{ + message Entry + { + optional uint32 msg_type = 1; // Client message ID to be routed; top bit is ignored for historical reasons + optional CMsgGCRoutingInfo routing = 2; + } + repeated Entry entries = 1; +} + +message CMsgGCMsgMasterSetWebAPIRouting_Response +{ + optional int32 eresult = 1 [ default = 2 ]; // Success or failure code from the GCH when processing k_EGCMsgMasterSetWebAPIRouting +} + +message CMsgGCMsgMasterSetClientMsgRouting_Response +{ + optional int32 eresult = 1 [ default = 2 ]; // Success or failure code from the GCH when processing k_EGCMsgMasterSetClientMsgRouting +} + + +// k_EGCMsgSetOptions +message CMsgGCMsgSetOptions +{ + enum Option + { + // Notifications (aka "data streams" - unsoliticed messages from Steam) - default disabled, specify to opt-in + NOTIFY_USER_SESSIONS = 0; + NOTIFY_SERVER_SESSIONS = 1; + NOTIFY_ACHIEVEMENTS = 2; + NOTIFY_VAC_ACTION = 3; + + // todo: other options? should start options higher up, like 20+, to save room for streams? + } + repeated Option options = 1; + + + // The client_msg_ranges field indicates which client messages, if any, this GC should receive copies of + message MessageRange + { + required uint32 low = 1; + required uint32 high = 2; + } + repeated MessageRange client_msg_ranges = 2; + + + // The GCSQL version field is only read by the GC.EXE host to determine support for enums, etc; the GCH doesn't care + enum GCSQLVersion + { + GCSQL_VERSION_BASELINE = 1; // baseline + GCSQL_VERSION_BOOLTYPE = 2; // added explicit support for bool types (instead of int8) + } + optional GCSQLVersion gcsql_version = 3; +} + + +// k_EMsgGCHUpdateSession +message CMsgGCHUpdateSession +{ + optional fixed64 steam_id = 1; + optional uint32 app_id = 2; + optional bool online = 3; + optional fixed64 server_steam_id = 4; // For a game client, the steam_id of the current server + optional uint32 server_addr = 5; // The IP address of the current server (or self for server state) + optional uint32 server_port = 6; // The IP port of the server (or self for server state) + optional uint32 os_type = 7; + optional uint32 client_addr = 8; // For a game client, the public IP address of the client + + message ExtraField + { + optional string name = 1; + optional string value = 2; + } + repeated ExtraField extra_fields = 9; +} + +// +// k_EGCMsgVSReportedSuspiciousActivity +// +message CMsgNotificationOfSuspiciousActivity +{ + optional fixed64 steamid = 1; + optional uint32 appid = 2; + + message MultipleGameInstances + { + optional uint32 app_instance_count = 1; + repeated fixed64 other_steamids = 2; + } + optional MultipleGameInstances multiple_instances = 3; +} + +// Do not remove this comment due to a bug on the Mac OS X protobuf compiler + |