5
0
mirror of https://github.com/cwinfo/matterbridge.git synced 2024-12-25 06:05:39 +00:00

Add vendor (steam)

This commit is contained in:
Wim 2017-06-22 01:00:27 +02:00
parent 1f9874102a
commit 1f91461853
117 changed files with 115543 additions and 0 deletions

26
vendor/github.com/Philipp15b/go-steam/LICENSE.txt generated vendored Normal file
View File

@ -0,0 +1,26 @@
Copyright (c) 2014 The go-steam Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

178
vendor/github.com/Philipp15b/go-steam/auth.go generated vendored Normal file
View File

@ -0,0 +1,178 @@
package steam
import (
"crypto/sha1"
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
"github.com/golang/protobuf/proto"
"sync/atomic"
"time"
)
type Auth struct {
client *Client
details *LogOnDetails
}
type SentryHash []byte
type LogOnDetails struct {
Username string
Password string
AuthCode string
TwoFactorCode string
SentryFileHash SentryHash
}
// Log on with the given details. You must always specify username and
// password. For the first login, don't set an authcode or a hash and you'll receive an error
// and Steam will send you an authcode. Then you have to login again, this time with the authcode.
// Shortly after logging in, you'll receive a MachineAuthUpdateEvent with a hash which allows
// you to login without using an authcode in the future.
//
// If you don't use Steam Guard, username and password are enough.
func (a *Auth) LogOn(details *LogOnDetails) {
if len(details.Username) == 0 || len(details.Password) == 0 {
panic("Username and password must be set!")
}
logon := new(CMsgClientLogon)
logon.AccountName = &details.Username
logon.Password = &details.Password
if details.AuthCode != "" {
logon.AuthCode = proto.String(details.AuthCode)
}
if details.TwoFactorCode != "" {
logon.TwoFactorCode = proto.String(details.TwoFactorCode)
}
logon.ClientLanguage = proto.String("english")
logon.ProtocolVersion = proto.Uint32(MsgClientLogon_CurrentProtocol)
logon.ShaSentryfile = details.SentryFileHash
atomic.StoreUint64(&a.client.steamId, uint64(NewIdAdv(0, 1, int32(EUniverse_Public), int32(EAccountType_Individual))))
a.client.Write(NewClientMsgProtobuf(EMsg_ClientLogon, logon))
}
func (a *Auth) HandlePacket(packet *Packet) {
switch packet.EMsg {
case EMsg_ClientLogOnResponse:
a.handleLogOnResponse(packet)
case EMsg_ClientNewLoginKey:
a.handleLoginKey(packet)
case EMsg_ClientSessionToken:
case EMsg_ClientLoggedOff:
a.handleLoggedOff(packet)
case EMsg_ClientUpdateMachineAuth:
a.handleUpdateMachineAuth(packet)
case EMsg_ClientAccountInfo:
a.handleAccountInfo(packet)
case EMsg_ClientWalletInfoUpdate:
case EMsg_ClientRequestWebAPIAuthenticateUserNonceResponse:
case EMsg_ClientMarketingMessageUpdate:
}
}
func (a *Auth) handleLogOnResponse(packet *Packet) {
if !packet.IsProto {
a.client.Fatalf("Got non-proto logon response!")
return
}
body := new(CMsgClientLogonResponse)
msg := packet.ReadProtoMsg(body)
result := EResult(body.GetEresult())
if result == EResult_OK {
atomic.StoreInt32(&a.client.sessionId, msg.Header.Proto.GetClientSessionid())
atomic.StoreUint64(&a.client.steamId, msg.Header.Proto.GetSteamid())
a.client.Web.webLoginKey = *body.WebapiAuthenticateUserNonce
go a.client.heartbeatLoop(time.Duration(body.GetOutOfGameHeartbeatSeconds()))
a.client.Emit(&LoggedOnEvent{
Result: EResult(body.GetEresult()),
ExtendedResult: EResult(body.GetEresultExtended()),
OutOfGameSecsPerHeartbeat: body.GetOutOfGameHeartbeatSeconds(),
InGameSecsPerHeartbeat: body.GetInGameHeartbeatSeconds(),
PublicIp: body.GetPublicIp(),
ServerTime: body.GetRtime32ServerTime(),
AccountFlags: EAccountFlags(body.GetAccountFlags()),
ClientSteamId: SteamId(body.GetClientSuppliedSteamid()),
EmailDomain: body.GetEmailDomain(),
CellId: body.GetCellId(),
CellIdPingThreshold: body.GetCellIdPingThreshold(),
Steam2Ticket: body.GetSteam2Ticket(),
UsePics: body.GetUsePics(),
WebApiUserNonce: body.GetWebapiAuthenticateUserNonce(),
IpCountryCode: body.GetIpCountryCode(),
VanityUrl: body.GetVanityUrl(),
NumLoginFailuresToMigrate: body.GetCountLoginfailuresToMigrate(),
NumDisconnectsToMigrate: body.GetCountDisconnectsToMigrate(),
})
} else if result == EResult_Fail || result == EResult_ServiceUnavailable || result == EResult_TryAnotherCM {
// some error on Steam's side, we'll get an EOF later
} else {
a.client.Emit(&LogOnFailedEvent{
Result: EResult(body.GetEresult()),
})
a.client.Disconnect()
}
}
func (a *Auth) handleLoginKey(packet *Packet) {
body := new(CMsgClientNewLoginKey)
packet.ReadProtoMsg(body)
a.client.Write(NewClientMsgProtobuf(EMsg_ClientNewLoginKeyAccepted, &CMsgClientNewLoginKeyAccepted{
UniqueId: proto.Uint32(body.GetUniqueId()),
}))
a.client.Emit(&LoginKeyEvent{
UniqueId: body.GetUniqueId(),
LoginKey: body.GetLoginKey(),
})
}
func (a *Auth) handleLoggedOff(packet *Packet) {
result := EResult_Invalid
if packet.IsProto {
body := new(CMsgClientLoggedOff)
packet.ReadProtoMsg(body)
result = EResult(body.GetEresult())
} else {
body := new(MsgClientLoggedOff)
packet.ReadClientMsg(body)
result = body.Result
}
a.client.Emit(&LoggedOffEvent{Result: result})
}
func (a *Auth) handleUpdateMachineAuth(packet *Packet) {
body := new(CMsgClientUpdateMachineAuth)
packet.ReadProtoMsg(body)
hash := sha1.New()
hash.Write(packet.Data)
sha := hash.Sum(nil)
msg := NewClientMsgProtobuf(EMsg_ClientUpdateMachineAuthResponse, &CMsgClientUpdateMachineAuthResponse{
ShaFile: sha,
})
msg.SetTargetJobId(packet.SourceJobId)
a.client.Write(msg)
a.client.Emit(&MachineAuthUpdateEvent{sha})
}
func (a *Auth) handleAccountInfo(packet *Packet) {
body := new(CMsgClientAccountInfo)
packet.ReadProtoMsg(body)
a.client.Emit(&AccountInfoEvent{
PersonaName: body.GetPersonaName(),
Country: body.GetIpCountry(),
CountAuthedComputers: body.GetCountAuthedComputers(),
AccountFlags: EAccountFlags(body.GetAccountFlags()),
FacebookId: body.GetFacebookId(),
FacebookName: body.GetFacebookName(),
})
}

53
vendor/github.com/Philipp15b/go-steam/auth_events.go generated vendored Normal file
View File

@ -0,0 +1,53 @@
package steam
import (
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
)
type LoggedOnEvent struct {
Result EResult
ExtendedResult EResult
OutOfGameSecsPerHeartbeat int32
InGameSecsPerHeartbeat int32
PublicIp uint32
ServerTime uint32
AccountFlags EAccountFlags
ClientSteamId SteamId `json:",string"`
EmailDomain string
CellId uint32
CellIdPingThreshold uint32
Steam2Ticket []byte
UsePics bool
WebApiUserNonce string
IpCountryCode string
VanityUrl string
NumLoginFailuresToMigrate int32
NumDisconnectsToMigrate int32
}
type LogOnFailedEvent struct {
Result EResult
}
type LoginKeyEvent struct {
UniqueId uint32
LoginKey string
}
type LoggedOffEvent struct {
Result EResult
}
type MachineAuthUpdateEvent struct {
Hash []byte
}
type AccountInfoEvent struct {
PersonaName string
Country string
CountAuthedComputers int32
AccountFlags EAccountFlags
FacebookId uint64 `json:",string"`
FacebookName string
}

383
vendor/github.com/Philipp15b/go-steam/client.go generated vendored Normal file
View File

@ -0,0 +1,383 @@
package steam
import (
"bytes"
"compress/gzip"
"crypto/rand"
"encoding/binary"
"fmt"
"hash/crc32"
"io/ioutil"
"net"
"sync"
"sync/atomic"
"time"
"github.com/Philipp15b/go-steam/cryptoutil"
"github.com/Philipp15b/go-steam/netutil"
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
)
// Represents a client to the Steam network.
// Always poll events from the channel returned by Events() or receiving messages will stop.
// All access, unless otherwise noted, should be threadsafe.
//
// When a FatalErrorEvent is emitted, the connection is automatically closed. The same client can be used to reconnect.
// Other errors don't have any effect.
type Client struct {
// these need to be 64 bit aligned for sync/atomic on 32bit
sessionId int32
_ uint32
steamId uint64
currentJobId uint64
Auth *Auth
Social *Social
Web *Web
Notifications *Notifications
Trading *Trading
GC *GameCoordinator
events chan interface{}
handlers []PacketHandler
handlersMutex sync.RWMutex
tempSessionKey []byte
ConnectionTimeout time.Duration
mutex sync.RWMutex // guarding conn and writeChan
conn connection
writeChan chan IMsg
writeBuf *bytes.Buffer
heartbeat *time.Ticker
}
type PacketHandler interface {
HandlePacket(*Packet)
}
func NewClient() *Client {
client := &Client{
events: make(chan interface{}, 3),
writeBuf: new(bytes.Buffer),
}
client.Auth = &Auth{client: client}
client.RegisterPacketHandler(client.Auth)
client.Social = newSocial(client)
client.RegisterPacketHandler(client.Social)
client.Web = &Web{client: client}
client.RegisterPacketHandler(client.Web)
client.Notifications = newNotifications(client)
client.RegisterPacketHandler(client.Notifications)
client.Trading = &Trading{client: client}
client.RegisterPacketHandler(client.Trading)
client.GC = newGC(client)
client.RegisterPacketHandler(client.GC)
return client
}
// Get the event channel. By convention all events are pointers, except for errors.
// It is never closed.
func (c *Client) Events() <-chan interface{} {
return c.events
}
func (c *Client) Emit(event interface{}) {
c.events <- event
}
// Emits a FatalErrorEvent formatted with fmt.Errorf and disconnects.
func (c *Client) Fatalf(format string, a ...interface{}) {
c.Emit(FatalErrorEvent(fmt.Errorf(format, a...)))
c.Disconnect()
}
// Emits an error formatted with fmt.Errorf.
func (c *Client) Errorf(format string, a ...interface{}) {
c.Emit(fmt.Errorf(format, a...))
}
// Registers a PacketHandler that receives all incoming packets.
func (c *Client) RegisterPacketHandler(handler PacketHandler) {
c.handlersMutex.Lock()
defer c.handlersMutex.Unlock()
c.handlers = append(c.handlers, handler)
}
func (c *Client) GetNextJobId() JobId {
return JobId(atomic.AddUint64(&c.currentJobId, 1))
}
func (c *Client) SteamId() SteamId {
return SteamId(atomic.LoadUint64(&c.steamId))
}
func (c *Client) SessionId() int32 {
return atomic.LoadInt32(&c.sessionId)
}
func (c *Client) Connected() bool {
c.mutex.RLock()
defer c.mutex.RUnlock()
return c.conn != nil
}
// Connects to a random Steam server and returns its address.
// If this client is already connected, it is disconnected first.
// This method tries to use an address from the Steam Directory and falls
// back to the built-in server list if the Steam Directory can't be reached.
// If you want to connect to a specific server, use `ConnectTo`.
func (c *Client) Connect() *netutil.PortAddr {
var server *netutil.PortAddr
if steamDirectoryCache.IsInitialized() {
server = steamDirectoryCache.GetRandomCM()
} else {
server = GetRandomCM()
}
c.ConnectTo(server)
return server
}
// Connects to a specific server.
// You may want to use one of the `GetRandom*CM()` functions in this package.
// If this client is already connected, it is disconnected first.
func (c *Client) ConnectTo(addr *netutil.PortAddr) {
c.ConnectToBind(addr, nil)
}
// Connects to a specific server, and binds to a specified local IP
// If this client is already connected, it is disconnected first.
func (c *Client) ConnectToBind(addr *netutil.PortAddr, local *net.TCPAddr) {
c.Disconnect()
conn, err := dialTCP(local, addr.ToTCPAddr())
if err != nil {
c.Fatalf("Connect failed: %v", err)
return
}
c.conn = conn
c.writeChan = make(chan IMsg, 5)
go c.readLoop()
go c.writeLoop()
}
func (c *Client) Disconnect() {
c.mutex.Lock()
defer c.mutex.Unlock()
if c.conn == nil {
return
}
c.conn.Close()
c.conn = nil
if c.heartbeat != nil {
c.heartbeat.Stop()
}
close(c.writeChan)
c.Emit(&DisconnectedEvent{})
}
// Adds a message to the send queue. Modifications to the given message after
// writing are not allowed (possible race conditions).
//
// Writes to this client when not connected are ignored.
func (c *Client) Write(msg IMsg) {
if cm, ok := msg.(IClientMsg); ok {
cm.SetSessionId(c.SessionId())
cm.SetSteamId(c.SteamId())
}
c.mutex.RLock()
defer c.mutex.RUnlock()
if c.conn == nil {
return
}
c.writeChan <- msg
}
func (c *Client) readLoop() {
for {
// This *should* be atomic on most platforms, but the Go spec doesn't guarantee it
c.mutex.RLock()
conn := c.conn
c.mutex.RUnlock()
if conn == nil {
return
}
packet, err := conn.Read()
if err != nil {
c.Fatalf("Error reading from the connection: %v", err)
return
}
c.handlePacket(packet)
}
}
func (c *Client) writeLoop() {
for {
c.mutex.RLock()
conn := c.conn
c.mutex.RUnlock()
if conn == nil {
return
}
msg, ok := <-c.writeChan
if !ok {
return
}
err := msg.Serialize(c.writeBuf)
if err != nil {
c.writeBuf.Reset()
c.Fatalf("Error serializing message %v: %v", msg, err)
return
}
err = conn.Write(c.writeBuf.Bytes())
c.writeBuf.Reset()
if err != nil {
c.Fatalf("Error writing message %v: %v", msg, err)
return
}
}
}
func (c *Client) heartbeatLoop(seconds time.Duration) {
if c.heartbeat != nil {
c.heartbeat.Stop()
}
c.heartbeat = time.NewTicker(seconds * time.Second)
for {
_, ok := <-c.heartbeat.C
if !ok {
break
}
c.Write(NewClientMsgProtobuf(EMsg_ClientHeartBeat, new(CMsgClientHeartBeat)))
}
c.heartbeat = nil
}
func (c *Client) handlePacket(packet *Packet) {
switch packet.EMsg {
case EMsg_ChannelEncryptRequest:
c.handleChannelEncryptRequest(packet)
case EMsg_ChannelEncryptResult:
c.handleChannelEncryptResult(packet)
case EMsg_Multi:
c.handleMulti(packet)
case EMsg_ClientCMList:
c.handleClientCMList(packet)
}
c.handlersMutex.RLock()
defer c.handlersMutex.RUnlock()
for _, handler := range c.handlers {
handler.HandlePacket(packet)
}
}
func (c *Client) handleChannelEncryptRequest(packet *Packet) {
body := NewMsgChannelEncryptRequest()
packet.ReadMsg(body)
if body.Universe != EUniverse_Public {
c.Fatalf("Invalid univserse %v!", body.Universe)
}
c.tempSessionKey = make([]byte, 32)
rand.Read(c.tempSessionKey)
encryptedKey := cryptoutil.RSAEncrypt(GetPublicKey(EUniverse_Public), c.tempSessionKey)
payload := new(bytes.Buffer)
payload.Write(encryptedKey)
binary.Write(payload, binary.LittleEndian, crc32.ChecksumIEEE(encryptedKey))
payload.WriteByte(0)
payload.WriteByte(0)
payload.WriteByte(0)
payload.WriteByte(0)
c.Write(NewMsg(NewMsgChannelEncryptResponse(), payload.Bytes()))
}
func (c *Client) handleChannelEncryptResult(packet *Packet) {
body := NewMsgChannelEncryptResult()
packet.ReadMsg(body)
if body.Result != EResult_OK {
c.Fatalf("Encryption failed: %v", body.Result)
return
}
c.conn.SetEncryptionKey(c.tempSessionKey)
c.tempSessionKey = nil
c.Emit(&ConnectedEvent{})
}
func (c *Client) handleMulti(packet *Packet) {
body := new(CMsgMulti)
packet.ReadProtoMsg(body)
payload := body.GetMessageBody()
if body.GetSizeUnzipped() > 0 {
r, err := gzip.NewReader(bytes.NewReader(payload))
if err != nil {
c.Errorf("handleMulti: Error while decompressing: %v", err)
return
}
payload, err = ioutil.ReadAll(r)
if err != nil {
c.Errorf("handleMulti: Error while decompressing: %v", err)
return
}
}
pr := bytes.NewReader(payload)
for pr.Len() > 0 {
var length uint32
binary.Read(pr, binary.LittleEndian, &length)
packetData := make([]byte, length)
pr.Read(packetData)
p, err := NewPacket(packetData)
if err != nil {
c.Errorf("Error reading packet in Multi msg %v: %v", packet, err)
continue
}
c.handlePacket(p)
}
}
func (c *Client) handleClientCMList(packet *Packet) {
body := new(CMsgClientCMList)
packet.ReadProtoMsg(body)
l := make([]*netutil.PortAddr, 0)
for i, ip := range body.GetCmAddresses() {
l = append(l, &netutil.PortAddr{
readIp(ip),
uint16(body.GetCmPorts()[i]),
})
}
c.Emit(&ClientCMListEvent{l})
}
func readIp(ip uint32) net.IP {
r := make(net.IP, 4)
r[3] = byte(ip)
r[2] = byte(ip >> 8)
r[1] = byte(ip >> 16)
r[0] = byte(ip >> 24)
return r
}

20
vendor/github.com/Philipp15b/go-steam/client_events.go generated vendored Normal file
View File

@ -0,0 +1,20 @@
package steam
import (
"github.com/Philipp15b/go-steam/netutil"
)
// When this event is emitted by the Client, the connection is automatically closed.
// This may be caused by a network error, for example.
type FatalErrorEvent error
type ConnectedEvent struct{}
type DisconnectedEvent struct{}
// A list of connection manager addresses to connect to in the future.
// You should always save them and then select one of these
// instead of the builtin ones for the next connection.
type ClientCMListEvent struct {
Addresses []*netutil.PortAddr
}

View File

@ -0,0 +1,35 @@
package community
import (
"net/http"
"net/http/cookiejar"
"net/url"
)
const cookiePath = "https://steamcommunity.com/"
func SetCookies(client *http.Client, sessionId, steamLogin, steamLoginSecure string) {
if client.Jar == nil {
client.Jar, _ = cookiejar.New(new(cookiejar.Options))
}
base, err := url.Parse(cookiePath)
if err != nil {
panic(err)
}
client.Jar.SetCookies(base, []*http.Cookie{
// It seems that, for some reason, Steam tries to URL-decode the cookie.
&http.Cookie{
Name: "sessionid",
Value: url.QueryEscape(sessionId),
},
// steamLogin is already URL-encoded.
&http.Cookie{
Name: "steamLogin",
Value: steamLogin,
},
&http.Cookie{
Name: "steamLoginSecure",
Value: steamLoginSecure,
},
})
}

127
vendor/github.com/Philipp15b/go-steam/connection.go generated vendored Normal file
View File

@ -0,0 +1,127 @@
package steam
import (
"crypto/aes"
"crypto/cipher"
"encoding/binary"
"fmt"
"io"
"net"
"sync"
"github.com/Philipp15b/go-steam/cryptoutil"
. "github.com/Philipp15b/go-steam/protocol"
)
type connection interface {
Read() (*Packet, error)
Write([]byte) error
Close() error
SetEncryptionKey([]byte)
IsEncrypted() bool
}
const tcpConnectionMagic uint32 = 0x31305456 // "VT01"
type tcpConnection struct {
conn *net.TCPConn
ciph cipher.Block
cipherMutex sync.RWMutex
}
func dialTCP(laddr, raddr *net.TCPAddr) (*tcpConnection, error) {
conn, err := net.DialTCP("tcp", laddr, raddr)
if err != nil {
return nil, err
}
return &tcpConnection{
conn: conn,
}, nil
}
func (c *tcpConnection) Read() (*Packet, error) {
// All packets begin with a packet length
var packetLen uint32
err := binary.Read(c.conn, binary.LittleEndian, &packetLen)
if err != nil {
return nil, err
}
// A magic value follows for validation
var packetMagic uint32
err = binary.Read(c.conn, binary.LittleEndian, &packetMagic)
if err != nil {
return nil, err
}
if packetMagic != tcpConnectionMagic {
return nil, fmt.Errorf("Invalid connection magic! Expected %d, got %d!", tcpConnectionMagic, packetMagic)
}
buf := make([]byte, packetLen, packetLen)
_, err = io.ReadFull(c.conn, buf)
if err == io.ErrUnexpectedEOF {
return nil, io.EOF
}
if err != nil {
return nil, err
}
// Packets after ChannelEncryptResult are encrypted
c.cipherMutex.RLock()
if c.ciph != nil {
buf = cryptoutil.SymmetricDecrypt(c.ciph, buf)
}
c.cipherMutex.RUnlock()
return NewPacket(buf)
}
// Writes a message. This may only be used by one goroutine at a time.
func (c *tcpConnection) Write(message []byte) error {
c.cipherMutex.RLock()
if c.ciph != nil {
message = cryptoutil.SymmetricEncrypt(c.ciph, message)
}
c.cipherMutex.RUnlock()
err := binary.Write(c.conn, binary.LittleEndian, uint32(len(message)))
if err != nil {
return err
}
err = binary.Write(c.conn, binary.LittleEndian, tcpConnectionMagic)
if err != nil {
return err
}
_, err = c.conn.Write(message)
return err
}
func (c *tcpConnection) Close() error {
return c.conn.Close()
}
func (c *tcpConnection) SetEncryptionKey(key []byte) {
c.cipherMutex.Lock()
defer c.cipherMutex.Unlock()
if key == nil {
c.ciph = nil
return
}
if len(key) != 32 {
panic("Connection AES key is not 32 bytes long!")
}
var err error
c.ciph, err = aes.NewCipher(key)
if err != nil {
panic(err)
}
}
func (c *tcpConnection) IsEncrypted() bool {
c.cipherMutex.RLock()
defer c.cipherMutex.RUnlock()
return c.ciph != nil
}

View File

@ -0,0 +1,38 @@
package cryptoutil
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
)
// Performs an encryption using AES/CBC/PKCS7
// with a random IV prepended using AES/ECB/None.
func SymmetricEncrypt(ciph cipher.Block, src []byte) []byte {
// get a random IV and ECB encrypt it
iv := make([]byte, aes.BlockSize, aes.BlockSize)
_, err := rand.Read(iv)
if err != nil {
panic(err)
}
encryptedIv := make([]byte, aes.BlockSize, aes.BlockSize)
newECBEncrypter(ciph).CryptBlocks(encryptedIv, iv)
// pad it, copy the IV to the first 16 bytes and encrypt the rest with CBC
encrypted := padPKCS7WithIV(src)
copy(encrypted, encryptedIv)
cipher.NewCBCEncrypter(ciph, iv).CryptBlocks(encrypted[aes.BlockSize:], encrypted[aes.BlockSize:])
return encrypted
}
// Decrypts data from the reader using AES/CBC/PKCS7 with an IV
// prepended using AES/ECB/None. The src slice may not be used anymore.
func SymmetricDecrypt(ciph cipher.Block, src []byte) []byte {
iv := src[:aes.BlockSize]
newECBDecrypter(ciph).CryptBlocks(iv, iv)
data := src[aes.BlockSize:]
cipher.NewCBCDecrypter(ciph, iv).CryptBlocks(data, data)
return unpadPKCS7(data)
}

View File

@ -0,0 +1,68 @@
package cryptoutil
import (
"crypto/cipher"
)
// From this code review: https://codereview.appspot.com/7860047/
// by fasmat for the Go crypto/cipher package
type ecb struct {
b cipher.Block
blockSize int
}
func newECB(b cipher.Block) *ecb {
return &ecb{
b: b,
blockSize: b.BlockSize(),
}
}
type ecbEncrypter ecb
// NewECBEncrypter returns a BlockMode which encrypts in electronic code book
// mode, using the given Block.
func newECBEncrypter(b cipher.Block) cipher.BlockMode {
return (*ecbEncrypter)(newECB(b))
}
func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
if len(src)%x.blockSize != 0 {
panic("cryptoutil/ecb: input not full blocks")
}
if len(dst) < len(src) {
panic("cryptoutil/ecb: output smaller than input")
}
for len(src) > 0 {
x.b.Encrypt(dst, src[:x.blockSize])
src = src[x.blockSize:]
dst = dst[x.blockSize:]
}
}
type ecbDecrypter ecb
// newECBDecrypter returns a BlockMode which decrypts in electronic code book
// mode, using the given Block.
func newECBDecrypter(b cipher.Block) cipher.BlockMode {
return (*ecbDecrypter)(newECB(b))
}
func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
if len(src)%x.blockSize != 0 {
panic("cryptoutil/ecb: input not full blocks")
}
if len(dst) < len(src) {
panic("cryptoutil/ecb: output smaller than input")
}
for len(src) > 0 {
x.b.Decrypt(dst, src[:x.blockSize])
src = src[x.blockSize:]
dst = dst[x.blockSize:]
}
}

View File

@ -0,0 +1,25 @@
package cryptoutil
import (
"crypto/aes"
)
// Returns a new byte array padded with PKCS7 and prepended
// with empty space of the AES block size (16 bytes) for the IV.
func padPKCS7WithIV(src []byte) []byte {
missing := aes.BlockSize - (len(src) % aes.BlockSize)
newSize := len(src) + aes.BlockSize + missing
dest := make([]byte, newSize, newSize)
copy(dest[aes.BlockSize:], src)
padding := byte(missing)
for i := newSize - missing; i < newSize; i++ {
dest[i] = padding
}
return dest
}
func unpadPKCS7(src []byte) []byte {
padLen := src[len(src)-1]
return src[:len(src)-int(padLen)]
}

View File

@ -0,0 +1,31 @@
package cryptoutil
import (
"crypto/rand"
"crypto/rsa"
"crypto/sha1"
"crypto/x509"
"errors"
)
// Parses a DER encoded RSA public key
func ParseASN1RSAPublicKey(derBytes []byte) (*rsa.PublicKey, error) {
key, err := x509.ParsePKIXPublicKey(derBytes)
if err != nil {
return nil, err
}
pubKey, ok := key.(*rsa.PublicKey)
if !ok {
return nil, errors.New("not an RSA public key")
}
return pubKey, nil
}
// Encrypts a message with the given public key using RSA-OAEP and the sha1 hash function.
func RSAEncrypt(pub *rsa.PublicKey, msg []byte) []byte {
b, err := rsa.EncryptOAEP(sha1.New(), rand.Reader, pub, msg, nil)
if err != nil {
panic(err)
}
return b
}

53
vendor/github.com/Philipp15b/go-steam/doc.go generated vendored Normal file
View File

@ -0,0 +1,53 @@
/*
This package allows you to automate actions on Valve's Steam network. It is a Go port of SteamKit.
To login, you'll have to create a new Client first. Then connect to the Steam network
and wait for a ConnectedCallback. Then you may call the Login method in the Auth module
with your login information. This is covered in more detail in the method's documentation. After you've
received the LoggedOnEvent, you should set your persona state to online to receive friend lists etc.
Example code
You can also find a running example in the `gsbot` package.
package main
import (
"io/ioutil"
"log"
"github.com/Philipp15b/go-steam"
"github.com/Philipp15b/go-steam/protocol/steamlang"
)
func main() {
myLoginInfo := new(steam.LogOnDetails)
myLoginInfo.Username = "Your username"
myLoginInfo.Password = "Your password"
client := steam.NewClient()
client.Connect()
for event := range client.Events() {
switch e := event.(type) {
case *steam.ConnectedEvent:
client.Auth.LogOn(myLoginInfo)
case *steam.MachineAuthUpdateEvent:
ioutil.WriteFile("sentry", e.Hash, 0666)
case *steam.LoggedOnEvent:
client.Social.SetPersonaState(steamlang.EPersonaState_Online)
case steam.FatalErrorEvent:
log.Print(e)
case error:
log.Print(e)
}
}
}
Events
go-steam emits events that can be read via Client.Events(). Although the channel has the type interface{},
only types from this package ending with "Event" and errors will be emitted.
*/
package steam

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,579 @@
// Code generated by protoc-gen-go.
// source: gcsystemmsgs.proto
// DO NOT EDIT!
package protobuf
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package protobuf is being compiled against.
const _ = proto.ProtoPackageIsVersion1
type EGCSystemMsg int32
const (
EGCSystemMsg_k_EGCMsgInvalid EGCSystemMsg = 0
EGCSystemMsg_k_EGCMsgMulti EGCSystemMsg = 1
EGCSystemMsg_k_EGCMsgGenericReply EGCSystemMsg = 10
EGCSystemMsg_k_EGCMsgSystemBase EGCSystemMsg = 50
EGCSystemMsg_k_EGCMsgAchievementAwarded EGCSystemMsg = 51
EGCSystemMsg_k_EGCMsgConCommand EGCSystemMsg = 52
EGCSystemMsg_k_EGCMsgStartPlaying EGCSystemMsg = 53
EGCSystemMsg_k_EGCMsgStopPlaying EGCSystemMsg = 54
EGCSystemMsg_k_EGCMsgStartGameserver EGCSystemMsg = 55
EGCSystemMsg_k_EGCMsgStopGameserver EGCSystemMsg = 56
EGCSystemMsg_k_EGCMsgWGRequest EGCSystemMsg = 57
EGCSystemMsg_k_EGCMsgWGResponse EGCSystemMsg = 58
EGCSystemMsg_k_EGCMsgGetUserGameStatsSchema EGCSystemMsg = 59
EGCSystemMsg_k_EGCMsgGetUserGameStatsSchemaResponse EGCSystemMsg = 60
EGCSystemMsg_k_EGCMsgGetUserStatsDEPRECATED EGCSystemMsg = 61
EGCSystemMsg_k_EGCMsgGetUserStatsResponse EGCSystemMsg = 62
EGCSystemMsg_k_EGCMsgAppInfoUpdated EGCSystemMsg = 63
EGCSystemMsg_k_EGCMsgValidateSession EGCSystemMsg = 64
EGCSystemMsg_k_EGCMsgValidateSessionResponse EGCSystemMsg = 65
EGCSystemMsg_k_EGCMsgLookupAccountFromInput EGCSystemMsg = 66
EGCSystemMsg_k_EGCMsgSendHTTPRequest EGCSystemMsg = 67
EGCSystemMsg_k_EGCMsgSendHTTPRequestResponse EGCSystemMsg = 68
EGCSystemMsg_k_EGCMsgPreTestSetup EGCSystemMsg = 69
EGCSystemMsg_k_EGCMsgRecordSupportAction EGCSystemMsg = 70
EGCSystemMsg_k_EGCMsgGetAccountDetails_DEPRECATED EGCSystemMsg = 71
EGCSystemMsg_k_EGCMsgReceiveInterAppMessage EGCSystemMsg = 73
EGCSystemMsg_k_EGCMsgFindAccounts EGCSystemMsg = 74
EGCSystemMsg_k_EGCMsgPostAlert EGCSystemMsg = 75
EGCSystemMsg_k_EGCMsgGetLicenses EGCSystemMsg = 76
EGCSystemMsg_k_EGCMsgGetUserStats EGCSystemMsg = 77
EGCSystemMsg_k_EGCMsgGetCommands EGCSystemMsg = 78
EGCSystemMsg_k_EGCMsgGetCommandsResponse EGCSystemMsg = 79
EGCSystemMsg_k_EGCMsgAddFreeLicense EGCSystemMsg = 80
EGCSystemMsg_k_EGCMsgAddFreeLicenseResponse EGCSystemMsg = 81
EGCSystemMsg_k_EGCMsgGetIPLocation EGCSystemMsg = 82
EGCSystemMsg_k_EGCMsgGetIPLocationResponse EGCSystemMsg = 83
EGCSystemMsg_k_EGCMsgSystemStatsSchema EGCSystemMsg = 84
EGCSystemMsg_k_EGCMsgGetSystemStats EGCSystemMsg = 85
EGCSystemMsg_k_EGCMsgGetSystemStatsResponse EGCSystemMsg = 86
EGCSystemMsg_k_EGCMsgSendEmail EGCSystemMsg = 87
EGCSystemMsg_k_EGCMsgSendEmailResponse EGCSystemMsg = 88
EGCSystemMsg_k_EGCMsgGetEmailTemplate EGCSystemMsg = 89
EGCSystemMsg_k_EGCMsgGetEmailTemplateResponse EGCSystemMsg = 90
EGCSystemMsg_k_EGCMsgGrantGuestPass EGCSystemMsg = 91
EGCSystemMsg_k_EGCMsgGrantGuestPassResponse EGCSystemMsg = 92
EGCSystemMsg_k_EGCMsgGetAccountDetails EGCSystemMsg = 93
EGCSystemMsg_k_EGCMsgGetAccountDetailsResponse EGCSystemMsg = 94
EGCSystemMsg_k_EGCMsgGetPersonaNames EGCSystemMsg = 95
EGCSystemMsg_k_EGCMsgGetPersonaNamesResponse EGCSystemMsg = 96
EGCSystemMsg_k_EGCMsgMultiplexMsg EGCSystemMsg = 97
EGCSystemMsg_k_EGCMsgWebAPIRegisterInterfaces EGCSystemMsg = 101
EGCSystemMsg_k_EGCMsgWebAPIJobRequest EGCSystemMsg = 102
EGCSystemMsg_k_EGCMsgWebAPIJobRequestHttpResponse EGCSystemMsg = 104
EGCSystemMsg_k_EGCMsgWebAPIJobRequestForwardResponse EGCSystemMsg = 105
EGCSystemMsg_k_EGCMsgMemCachedGet EGCSystemMsg = 200
EGCSystemMsg_k_EGCMsgMemCachedGetResponse EGCSystemMsg = 201
EGCSystemMsg_k_EGCMsgMemCachedSet EGCSystemMsg = 202
EGCSystemMsg_k_EGCMsgMemCachedDelete EGCSystemMsg = 203
EGCSystemMsg_k_EGCMsgMemCachedStats EGCSystemMsg = 204
EGCSystemMsg_k_EGCMsgMemCachedStatsResponse EGCSystemMsg = 205
EGCSystemMsg_k_EGCMsgSQLStats EGCSystemMsg = 210
EGCSystemMsg_k_EGCMsgSQLStatsResponse EGCSystemMsg = 211
EGCSystemMsg_k_EGCMsgMasterSetDirectory EGCSystemMsg = 220
EGCSystemMsg_k_EGCMsgMasterSetDirectoryResponse EGCSystemMsg = 221
EGCSystemMsg_k_EGCMsgMasterSetWebAPIRouting EGCSystemMsg = 222
EGCSystemMsg_k_EGCMsgMasterSetWebAPIRoutingResponse EGCSystemMsg = 223
EGCSystemMsg_k_EGCMsgMasterSetClientMsgRouting EGCSystemMsg = 224
EGCSystemMsg_k_EGCMsgMasterSetClientMsgRoutingResponse EGCSystemMsg = 225
EGCSystemMsg_k_EGCMsgSetOptions EGCSystemMsg = 226
EGCSystemMsg_k_EGCMsgSetOptionsResponse EGCSystemMsg = 227
EGCSystemMsg_k_EGCMsgSystemBase2 EGCSystemMsg = 500
EGCSystemMsg_k_EGCMsgGetPurchaseTrustStatus EGCSystemMsg = 501
EGCSystemMsg_k_EGCMsgGetPurchaseTrustStatusResponse EGCSystemMsg = 502
EGCSystemMsg_k_EGCMsgUpdateSession EGCSystemMsg = 503
EGCSystemMsg_k_EGCMsgGCAccountVacStatusChange EGCSystemMsg = 504
EGCSystemMsg_k_EGCMsgCheckFriendship EGCSystemMsg = 505
EGCSystemMsg_k_EGCMsgCheckFriendshipResponse EGCSystemMsg = 506
EGCSystemMsg_k_EGCMsgGetPartnerAccountLink EGCSystemMsg = 507
EGCSystemMsg_k_EGCMsgGetPartnerAccountLinkResponse EGCSystemMsg = 508
EGCSystemMsg_k_EGCMsgVSReportedSuspiciousActivity EGCSystemMsg = 509
EGCSystemMsg_k_EGCMsgDPPartnerMicroTxns EGCSystemMsg = 512
EGCSystemMsg_k_EGCMsgDPPartnerMicroTxnsResponse EGCSystemMsg = 513
EGCSystemMsg_k_EGCMsgGetIPASN EGCSystemMsg = 514
EGCSystemMsg_k_EGCMsgGetIPASNResponse EGCSystemMsg = 515
EGCSystemMsg_k_EGCMsgGetAppFriendsList EGCSystemMsg = 516
EGCSystemMsg_k_EGCMsgGetAppFriendsListResponse EGCSystemMsg = 517
)
var EGCSystemMsg_name = map[int32]string{
0: "k_EGCMsgInvalid",
1: "k_EGCMsgMulti",
10: "k_EGCMsgGenericReply",
50: "k_EGCMsgSystemBase",
51: "k_EGCMsgAchievementAwarded",
52: "k_EGCMsgConCommand",
53: "k_EGCMsgStartPlaying",
54: "k_EGCMsgStopPlaying",
55: "k_EGCMsgStartGameserver",
56: "k_EGCMsgStopGameserver",
57: "k_EGCMsgWGRequest",
58: "k_EGCMsgWGResponse",
59: "k_EGCMsgGetUserGameStatsSchema",
60: "k_EGCMsgGetUserGameStatsSchemaResponse",
61: "k_EGCMsgGetUserStatsDEPRECATED",
62: "k_EGCMsgGetUserStatsResponse",
63: "k_EGCMsgAppInfoUpdated",
64: "k_EGCMsgValidateSession",
65: "k_EGCMsgValidateSessionResponse",
66: "k_EGCMsgLookupAccountFromInput",
67: "k_EGCMsgSendHTTPRequest",
68: "k_EGCMsgSendHTTPRequestResponse",
69: "k_EGCMsgPreTestSetup",
70: "k_EGCMsgRecordSupportAction",
71: "k_EGCMsgGetAccountDetails_DEPRECATED",
73: "k_EGCMsgReceiveInterAppMessage",
74: "k_EGCMsgFindAccounts",
75: "k_EGCMsgPostAlert",
76: "k_EGCMsgGetLicenses",
77: "k_EGCMsgGetUserStats",
78: "k_EGCMsgGetCommands",
79: "k_EGCMsgGetCommandsResponse",
80: "k_EGCMsgAddFreeLicense",
81: "k_EGCMsgAddFreeLicenseResponse",
82: "k_EGCMsgGetIPLocation",
83: "k_EGCMsgGetIPLocationResponse",
84: "k_EGCMsgSystemStatsSchema",
85: "k_EGCMsgGetSystemStats",
86: "k_EGCMsgGetSystemStatsResponse",
87: "k_EGCMsgSendEmail",
88: "k_EGCMsgSendEmailResponse",
89: "k_EGCMsgGetEmailTemplate",
90: "k_EGCMsgGetEmailTemplateResponse",
91: "k_EGCMsgGrantGuestPass",
92: "k_EGCMsgGrantGuestPassResponse",
93: "k_EGCMsgGetAccountDetails",
94: "k_EGCMsgGetAccountDetailsResponse",
95: "k_EGCMsgGetPersonaNames",
96: "k_EGCMsgGetPersonaNamesResponse",
97: "k_EGCMsgMultiplexMsg",
101: "k_EGCMsgWebAPIRegisterInterfaces",
102: "k_EGCMsgWebAPIJobRequest",
104: "k_EGCMsgWebAPIJobRequestHttpResponse",
105: "k_EGCMsgWebAPIJobRequestForwardResponse",
200: "k_EGCMsgMemCachedGet",
201: "k_EGCMsgMemCachedGetResponse",
202: "k_EGCMsgMemCachedSet",
203: "k_EGCMsgMemCachedDelete",
204: "k_EGCMsgMemCachedStats",
205: "k_EGCMsgMemCachedStatsResponse",
210: "k_EGCMsgSQLStats",
211: "k_EGCMsgSQLStatsResponse",
220: "k_EGCMsgMasterSetDirectory",
221: "k_EGCMsgMasterSetDirectoryResponse",
222: "k_EGCMsgMasterSetWebAPIRouting",
223: "k_EGCMsgMasterSetWebAPIRoutingResponse",
224: "k_EGCMsgMasterSetClientMsgRouting",
225: "k_EGCMsgMasterSetClientMsgRoutingResponse",
226: "k_EGCMsgSetOptions",
227: "k_EGCMsgSetOptionsResponse",
500: "k_EGCMsgSystemBase2",
501: "k_EGCMsgGetPurchaseTrustStatus",
502: "k_EGCMsgGetPurchaseTrustStatusResponse",
503: "k_EGCMsgUpdateSession",
504: "k_EGCMsgGCAccountVacStatusChange",
505: "k_EGCMsgCheckFriendship",
506: "k_EGCMsgCheckFriendshipResponse",
507: "k_EGCMsgGetPartnerAccountLink",
508: "k_EGCMsgGetPartnerAccountLinkResponse",
509: "k_EGCMsgVSReportedSuspiciousActivity",
512: "k_EGCMsgDPPartnerMicroTxns",
513: "k_EGCMsgDPPartnerMicroTxnsResponse",
514: "k_EGCMsgGetIPASN",
515: "k_EGCMsgGetIPASNResponse",
516: "k_EGCMsgGetAppFriendsList",
517: "k_EGCMsgGetAppFriendsListResponse",
}
var EGCSystemMsg_value = map[string]int32{
"k_EGCMsgInvalid": 0,
"k_EGCMsgMulti": 1,
"k_EGCMsgGenericReply": 10,
"k_EGCMsgSystemBase": 50,
"k_EGCMsgAchievementAwarded": 51,
"k_EGCMsgConCommand": 52,
"k_EGCMsgStartPlaying": 53,
"k_EGCMsgStopPlaying": 54,
"k_EGCMsgStartGameserver": 55,
"k_EGCMsgStopGameserver": 56,
"k_EGCMsgWGRequest": 57,
"k_EGCMsgWGResponse": 58,
"k_EGCMsgGetUserGameStatsSchema": 59,
"k_EGCMsgGetUserGameStatsSchemaResponse": 60,
"k_EGCMsgGetUserStatsDEPRECATED": 61,
"k_EGCMsgGetUserStatsResponse": 62,
"k_EGCMsgAppInfoUpdated": 63,
"k_EGCMsgValidateSession": 64,
"k_EGCMsgValidateSessionResponse": 65,
"k_EGCMsgLookupAccountFromInput": 66,
"k_EGCMsgSendHTTPRequest": 67,
"k_EGCMsgSendHTTPRequestResponse": 68,
"k_EGCMsgPreTestSetup": 69,
"k_EGCMsgRecordSupportAction": 70,
"k_EGCMsgGetAccountDetails_DEPRECATED": 71,
"k_EGCMsgReceiveInterAppMessage": 73,
"k_EGCMsgFindAccounts": 74,
"k_EGCMsgPostAlert": 75,
"k_EGCMsgGetLicenses": 76,
"k_EGCMsgGetUserStats": 77,
"k_EGCMsgGetCommands": 78,
"k_EGCMsgGetCommandsResponse": 79,
"k_EGCMsgAddFreeLicense": 80,
"k_EGCMsgAddFreeLicenseResponse": 81,
"k_EGCMsgGetIPLocation": 82,
"k_EGCMsgGetIPLocationResponse": 83,
"k_EGCMsgSystemStatsSchema": 84,
"k_EGCMsgGetSystemStats": 85,
"k_EGCMsgGetSystemStatsResponse": 86,
"k_EGCMsgSendEmail": 87,
"k_EGCMsgSendEmailResponse": 88,
"k_EGCMsgGetEmailTemplate": 89,
"k_EGCMsgGetEmailTemplateResponse": 90,
"k_EGCMsgGrantGuestPass": 91,
"k_EGCMsgGrantGuestPassResponse": 92,
"k_EGCMsgGetAccountDetails": 93,
"k_EGCMsgGetAccountDetailsResponse": 94,
"k_EGCMsgGetPersonaNames": 95,
"k_EGCMsgGetPersonaNamesResponse": 96,
"k_EGCMsgMultiplexMsg": 97,
"k_EGCMsgWebAPIRegisterInterfaces": 101,
"k_EGCMsgWebAPIJobRequest": 102,
"k_EGCMsgWebAPIJobRequestHttpResponse": 104,
"k_EGCMsgWebAPIJobRequestForwardResponse": 105,
"k_EGCMsgMemCachedGet": 200,
"k_EGCMsgMemCachedGetResponse": 201,
"k_EGCMsgMemCachedSet": 202,
"k_EGCMsgMemCachedDelete": 203,
"k_EGCMsgMemCachedStats": 204,
"k_EGCMsgMemCachedStatsResponse": 205,
"k_EGCMsgSQLStats": 210,
"k_EGCMsgSQLStatsResponse": 211,
"k_EGCMsgMasterSetDirectory": 220,
"k_EGCMsgMasterSetDirectoryResponse": 221,
"k_EGCMsgMasterSetWebAPIRouting": 222,
"k_EGCMsgMasterSetWebAPIRoutingResponse": 223,
"k_EGCMsgMasterSetClientMsgRouting": 224,
"k_EGCMsgMasterSetClientMsgRoutingResponse": 225,
"k_EGCMsgSetOptions": 226,
"k_EGCMsgSetOptionsResponse": 227,
"k_EGCMsgSystemBase2": 500,
"k_EGCMsgGetPurchaseTrustStatus": 501,
"k_EGCMsgGetPurchaseTrustStatusResponse": 502,
"k_EGCMsgUpdateSession": 503,
"k_EGCMsgGCAccountVacStatusChange": 504,
"k_EGCMsgCheckFriendship": 505,
"k_EGCMsgCheckFriendshipResponse": 506,
"k_EGCMsgGetPartnerAccountLink": 507,
"k_EGCMsgGetPartnerAccountLinkResponse": 508,
"k_EGCMsgVSReportedSuspiciousActivity": 509,
"k_EGCMsgDPPartnerMicroTxns": 512,
"k_EGCMsgDPPartnerMicroTxnsResponse": 513,
"k_EGCMsgGetIPASN": 514,
"k_EGCMsgGetIPASNResponse": 515,
"k_EGCMsgGetAppFriendsList": 516,
"k_EGCMsgGetAppFriendsListResponse": 517,
}
func (x EGCSystemMsg) Enum() *EGCSystemMsg {
p := new(EGCSystemMsg)
*p = x
return p
}
func (x EGCSystemMsg) String() string {
return proto.EnumName(EGCSystemMsg_name, int32(x))
}
func (x *EGCSystemMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EGCSystemMsg_value, data, "EGCSystemMsg")
if err != nil {
return err
}
*x = EGCSystemMsg(value)
return nil
}
func (EGCSystemMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{0} }
type ESOMsg int32
const (
ESOMsg_k_ESOMsg_Create ESOMsg = 21
ESOMsg_k_ESOMsg_Update ESOMsg = 22
ESOMsg_k_ESOMsg_Destroy ESOMsg = 23
ESOMsg_k_ESOMsg_CacheSubscribed ESOMsg = 24
ESOMsg_k_ESOMsg_CacheUnsubscribed ESOMsg = 25
ESOMsg_k_ESOMsg_UpdateMultiple ESOMsg = 26
ESOMsg_k_ESOMsg_CacheSubscriptionRefresh ESOMsg = 28
ESOMsg_k_ESOMsg_CacheSubscribedUpToDate ESOMsg = 29
)
var ESOMsg_name = map[int32]string{
21: "k_ESOMsg_Create",
22: "k_ESOMsg_Update",
23: "k_ESOMsg_Destroy",
24: "k_ESOMsg_CacheSubscribed",
25: "k_ESOMsg_CacheUnsubscribed",
26: "k_ESOMsg_UpdateMultiple",
28: "k_ESOMsg_CacheSubscriptionRefresh",
29: "k_ESOMsg_CacheSubscribedUpToDate",
}
var ESOMsg_value = map[string]int32{
"k_ESOMsg_Create": 21,
"k_ESOMsg_Update": 22,
"k_ESOMsg_Destroy": 23,
"k_ESOMsg_CacheSubscribed": 24,
"k_ESOMsg_CacheUnsubscribed": 25,
"k_ESOMsg_UpdateMultiple": 26,
"k_ESOMsg_CacheSubscriptionRefresh": 28,
"k_ESOMsg_CacheSubscribedUpToDate": 29,
}
func (x ESOMsg) Enum() *ESOMsg {
p := new(ESOMsg)
*p = x
return p
}
func (x ESOMsg) String() string {
return proto.EnumName(ESOMsg_name, int32(x))
}
func (x *ESOMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ESOMsg_value, data, "ESOMsg")
if err != nil {
return err
}
*x = ESOMsg(value)
return nil
}
func (ESOMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{1} }
type EGCBaseClientMsg int32
const (
EGCBaseClientMsg_k_EMsgGCPingRequest EGCBaseClientMsg = 3001
EGCBaseClientMsg_k_EMsgGCPingResponse EGCBaseClientMsg = 3002
EGCBaseClientMsg_k_EMsgGCClientWelcome EGCBaseClientMsg = 4004
EGCBaseClientMsg_k_EMsgGCServerWelcome EGCBaseClientMsg = 4005
EGCBaseClientMsg_k_EMsgGCClientHello EGCBaseClientMsg = 4006
EGCBaseClientMsg_k_EMsgGCServerHello EGCBaseClientMsg = 4007
EGCBaseClientMsg_k_EMsgGCClientConnectionStatus EGCBaseClientMsg = 4009
EGCBaseClientMsg_k_EMsgGCServerConnectionStatus EGCBaseClientMsg = 4010
)
var EGCBaseClientMsg_name = map[int32]string{
3001: "k_EMsgGCPingRequest",
3002: "k_EMsgGCPingResponse",
4004: "k_EMsgGCClientWelcome",
4005: "k_EMsgGCServerWelcome",
4006: "k_EMsgGCClientHello",
4007: "k_EMsgGCServerHello",
4009: "k_EMsgGCClientConnectionStatus",
4010: "k_EMsgGCServerConnectionStatus",
}
var EGCBaseClientMsg_value = map[string]int32{
"k_EMsgGCPingRequest": 3001,
"k_EMsgGCPingResponse": 3002,
"k_EMsgGCClientWelcome": 4004,
"k_EMsgGCServerWelcome": 4005,
"k_EMsgGCClientHello": 4006,
"k_EMsgGCServerHello": 4007,
"k_EMsgGCClientConnectionStatus": 4009,
"k_EMsgGCServerConnectionStatus": 4010,
}
func (x EGCBaseClientMsg) Enum() *EGCBaseClientMsg {
p := new(EGCBaseClientMsg)
*p = x
return p
}
func (x EGCBaseClientMsg) String() string {
return proto.EnumName(EGCBaseClientMsg_name, int32(x))
}
func (x *EGCBaseClientMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EGCBaseClientMsg_value, data, "EGCBaseClientMsg")
if err != nil {
return err
}
*x = EGCBaseClientMsg(value)
return nil
}
func (EGCBaseClientMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{2} }
type EGCToGCMsg int32
const (
EGCToGCMsg_k_EGCToGCMsgMasterAck EGCToGCMsg = 150
EGCToGCMsg_k_EGCToGCMsgMasterAckResponse EGCToGCMsg = 151
EGCToGCMsg_k_EGCToGCMsgRouted EGCToGCMsg = 152
EGCToGCMsg_k_EGCToGCMsgRoutedReply EGCToGCMsg = 153
EGCToGCMsg_k_EMsgGCUpdateSubGCSessionInfo EGCToGCMsg = 154
EGCToGCMsg_k_EMsgGCRequestSubGCSessionInfo EGCToGCMsg = 155
EGCToGCMsg_k_EMsgGCRequestSubGCSessionInfoResponse EGCToGCMsg = 156
EGCToGCMsg_k_EGCToGCMsgMasterStartupComplete EGCToGCMsg = 157
EGCToGCMsg_k_EMsgGCToGCSOCacheSubscribe EGCToGCMsg = 158
EGCToGCMsg_k_EMsgGCToGCSOCacheUnsubscribe EGCToGCMsg = 159
EGCToGCMsg_k_EMsgGCToGCLoadSessionSOCache EGCToGCMsg = 160
EGCToGCMsg_k_EMsgGCToGCLoadSessionSOCacheResponse EGCToGCMsg = 161
EGCToGCMsg_k_EMsgGCToGCUpdateSessionStats EGCToGCMsg = 162
)
var EGCToGCMsg_name = map[int32]string{
150: "k_EGCToGCMsgMasterAck",
151: "k_EGCToGCMsgMasterAckResponse",
152: "k_EGCToGCMsgRouted",
153: "k_EGCToGCMsgRoutedReply",
154: "k_EMsgGCUpdateSubGCSessionInfo",
155: "k_EMsgGCRequestSubGCSessionInfo",
156: "k_EMsgGCRequestSubGCSessionInfoResponse",
157: "k_EGCToGCMsgMasterStartupComplete",
158: "k_EMsgGCToGCSOCacheSubscribe",
159: "k_EMsgGCToGCSOCacheUnsubscribe",
160: "k_EMsgGCToGCLoadSessionSOCache",
161: "k_EMsgGCToGCLoadSessionSOCacheResponse",
162: "k_EMsgGCToGCUpdateSessionStats",
}
var EGCToGCMsg_value = map[string]int32{
"k_EGCToGCMsgMasterAck": 150,
"k_EGCToGCMsgMasterAckResponse": 151,
"k_EGCToGCMsgRouted": 152,
"k_EGCToGCMsgRoutedReply": 153,
"k_EMsgGCUpdateSubGCSessionInfo": 154,
"k_EMsgGCRequestSubGCSessionInfo": 155,
"k_EMsgGCRequestSubGCSessionInfoResponse": 156,
"k_EGCToGCMsgMasterStartupComplete": 157,
"k_EMsgGCToGCSOCacheSubscribe": 158,
"k_EMsgGCToGCSOCacheUnsubscribe": 159,
"k_EMsgGCToGCLoadSessionSOCache": 160,
"k_EMsgGCToGCLoadSessionSOCacheResponse": 161,
"k_EMsgGCToGCUpdateSessionStats": 162,
}
func (x EGCToGCMsg) Enum() *EGCToGCMsg {
p := new(EGCToGCMsg)
*p = x
return p
}
func (x EGCToGCMsg) String() string {
return proto.EnumName(EGCToGCMsg_name, int32(x))
}
func (x *EGCToGCMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EGCToGCMsg_value, data, "EGCToGCMsg")
if err != nil {
return err
}
*x = EGCToGCMsg(value)
return nil
}
func (EGCToGCMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{3} }
func init() {
proto.RegisterEnum("EGCSystemMsg", EGCSystemMsg_name, EGCSystemMsg_value)
proto.RegisterEnum("ESOMsg", ESOMsg_name, ESOMsg_value)
proto.RegisterEnum("EGCBaseClientMsg", EGCBaseClientMsg_name, EGCBaseClientMsg_value)
proto.RegisterEnum("EGCToGCMsg", EGCToGCMsg_name, EGCToGCMsg_value)
}
var system_fileDescriptor0 = []byte{
// 1475 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x57, 0x59, 0x73, 0x1b, 0xc5,
0x13, 0xcf, 0x96, 0xfc, 0xff, 0x3f, 0x4c, 0x41, 0xd1, 0x99, 0xc4, 0x47, 0x12, 0x27, 0x4a, 0x42,
0x0e, 0x62, 0xa8, 0x3c, 0x84, 0xfb, 0x46, 0x91, 0x64, 0x5b, 0x41, 0x8e, 0x15, 0x4b, 0xb6, 0xb9,
0xcd, 0x7a, 0x35, 0xb6, 0xb6, 0x2c, 0xed, 0x2c, 0x33, 0xbb, 0x26, 0x7e, 0x0b, 0xd7, 0x57, 0xe0,
0xbe, 0x8b, 0xa3, 0xe0, 0x1b, 0xc0, 0x27, 0xe0, 0x7c, 0x81, 0x57, 0xee, 0x7c, 0x01, 0x1e, 0xb8,
0x21, 0x55, 0xf4, 0xee, 0xce, 0xce, 0xce, 0x4a, 0xb2, 0x79, 0x93, 0xe6, 0xd7, 0xdd, 0xd3, 0xdd,
0xd3, 0xfd, 0xeb, 0x5e, 0x42, 0xd7, 0x1d, 0xb9, 0x25, 0x03, 0xd6, 0xeb, 0xc9, 0x75, 0x79, 0xda,
0x17, 0x3c, 0xe0, 0x53, 0x97, 0x47, 0xc9, 0x55, 0xd5, 0x99, 0x72, 0x33, 0x3e, 0x9f, 0x93, 0xeb,
0x74, 0x0f, 0xb9, 0x66, 0x63, 0x05, 0x4f, 0xf0, 0x77, 0xcd, 0xdb, 0xb4, 0xbb, 0x6e, 0x1b, 0x76,
0xd1, 0xdd, 0xe4, 0xea, 0xf4, 0x70, 0x2e, 0xec, 0x06, 0x2e, 0x58, 0x74, 0x82, 0xec, 0x4d, 0x8f,
0x66, 0x98, 0xc7, 0x84, 0xeb, 0x2c, 0x30, 0xbf, 0xbb, 0x05, 0x84, 0x8e, 0x11, 0x9a, 0x22, 0x89,
0xd9, 0xb3, 0xb6, 0x64, 0x70, 0x86, 0x1e, 0x22, 0xfb, 0xd3, 0xf3, 0x92, 0xd3, 0x71, 0xd9, 0x26,
0xeb, 0x31, 0x2f, 0x28, 0x3d, 0x69, 0x8b, 0x36, 0x6b, 0xc3, 0x8d, 0xa6, 0x5e, 0x99, 0x7b, 0x65,
0xde, 0xeb, 0xd9, 0x5e, 0x1b, 0x6e, 0x32, 0x6f, 0x6a, 0x06, 0xb6, 0x08, 0x1a, 0x5d, 0x7b, 0xcb,
0xf5, 0xd6, 0xe1, 0x66, 0x3a, 0x4e, 0xf6, 0x64, 0x08, 0xf7, 0x53, 0xe0, 0x16, 0x7a, 0x80, 0x8c,
0xe7, 0x54, 0x66, 0xec, 0x1e, 0x93, 0x4c, 0x6c, 0x32, 0x01, 0xb7, 0xd2, 0xfd, 0x64, 0xcc, 0xd4,
0x32, 0xb0, 0xdb, 0xe8, 0x28, 0xd9, 0x9d, 0x62, 0xcb, 0x33, 0x0b, 0xec, 0x89, 0x90, 0xc9, 0x00,
0x6e, 0x37, 0x5d, 0x8b, 0x8e, 0xa5, 0xcf, 0x3d, 0x0c, 0xe9, 0x0e, 0x7a, 0x94, 0x1c, 0xca, 0x92,
0x10, 0x2c, 0xa2, 0x99, 0xc8, 0x1a, 0x5e, 0x19, 0xc8, 0xa6, 0xd3, 0x61, 0x3d, 0x1b, 0xee, 0xa4,
0x53, 0xe4, 0xc4, 0xce, 0x32, 0xda, 0xde, 0x5d, 0x43, 0xec, 0xc5, 0x72, 0x95, 0x6a, 0x63, 0xa1,
0x5a, 0x2e, 0xb5, 0xaa, 0x15, 0xb8, 0x9b, 0x1e, 0x26, 0x93, 0xc3, 0x64, 0xb4, 0x95, 0x7b, 0xcc,
0x00, 0x4b, 0xbe, 0x5f, 0xf3, 0xd6, 0xf8, 0xa2, 0xdf, 0xb6, 0x03, 0x4c, 0xf2, 0xbd, 0x66, 0x66,
0x96, 0xa2, 0xc7, 0xc5, 0xe3, 0x26, 0x93, 0xd2, 0xe5, 0x1e, 0xdc, 0x47, 0xaf, 0x25, 0xc5, 0x6d,
0x40, 0x6d, 0xbd, 0x64, 0xfa, 0x58, 0xe7, 0x7c, 0x23, 0xf4, 0x4b, 0x8e, 0xc3, 0x43, 0x2f, 0x98,
0x16, 0xbc, 0x57, 0xf3, 0xfc, 0x30, 0x80, 0xb3, 0xb9, 0xfc, 0x33, 0xaf, 0x3d, 0xdb, 0x6a, 0x35,
0xd2, 0x64, 0x96, 0xcd, 0x5b, 0xfa, 0x40, 0x7d, 0x4b, 0xc5, 0x7c, 0xf4, 0x86, 0x60, 0x2d, 0x04,
0x9b, 0x2c, 0x08, 0x7d, 0xa8, 0xd2, 0x22, 0x39, 0x90, 0x22, 0x0b, 0xcc, 0xe1, 0xa2, 0xdd, 0x0c,
0x7d, 0x9f, 0x8b, 0xa0, 0xe4, 0x04, 0x51, 0x14, 0xd3, 0xf4, 0x3a, 0x72, 0xcc, 0x48, 0x90, 0xf2,
0xae, 0xc2, 0x02, 0xdb, 0xed, 0xca, 0x15, 0x23, 0x95, 0x33, 0x66, 0x28, 0x68, 0x8a, 0xb9, 0x9b,
0xac, 0xe6, 0x05, 0x4c, 0x60, 0xd2, 0xe6, 0x30, 0x6c, 0x7b, 0x9d, 0x41, 0xcd, 0x74, 0x64, 0xda,
0xf5, 0xda, 0xca, 0x9c, 0x84, 0x73, 0x66, 0xad, 0x34, 0xb8, 0x0c, 0x4a, 0x5d, 0x26, 0x02, 0xb8,
0xdf, 0x2c, 0x4a, 0xbc, 0xbe, 0xee, 0x3a, 0x0c, 0x23, 0x92, 0x50, 0xcf, 0x77, 0x4c, 0xf6, 0x70,
0x30, 0xd7, 0xa7, 0xa2, 0x2a, 0x5f, 0xc2, 0x79, 0x33, 0x56, 0x03, 0xd0, 0x69, 0x9a, 0xcf, 0x3d,
0x75, 0xbb, 0x3d, 0x2d, 0x18, 0x53, 0x17, 0x42, 0xc3, 0x8c, 0x2e, 0x8f, 0x69, 0xfd, 0x0b, 0x74,
0x1f, 0x19, 0x35, 0x2e, 0xa8, 0x35, 0xea, 0xdc, 0xb1, 0xe3, 0x34, 0x2e, 0xd0, 0x23, 0xe4, 0xe0,
0x50, 0x48, 0x6b, 0x37, 0xe9, 0x41, 0xb2, 0x2f, 0xdf, 0xe9, 0x66, 0xe5, 0xb7, 0x4c, 0xe7, 0xd0,
0x82, 0x21, 0x01, 0x8b, 0x7d, 0x95, 0x6e, 0x60, 0xda, 0xfc, 0x92, 0x99, 0xe0, 0xa8, 0x50, 0xaa,
0x3d, 0x7c, 0x41, 0x58, 0xce, 0xdd, 0x9a, 0x1e, 0x6b, 0xad, 0x07, 0xe8, 0x24, 0x99, 0x30, 0x2c,
0xc7, 0x68, 0x8b, 0xf5, 0xfc, 0x2e, 0x16, 0x33, 0x3c, 0x48, 0x8f, 0x91, 0xc3, 0xdb, 0xa1, 0xda,
0xc6, 0x43, 0x39, 0xcf, 0x85, 0xed, 0x05, 0x33, 0x51, 0x75, 0x36, 0x6c, 0x29, 0xe1, 0xe1, 0x9c,
0xe7, 0x39, 0x4c, 0xeb, 0x3f, 0x62, 0xba, 0x38, 0x50, 0x82, 0xf0, 0x28, 0x3d, 0x4e, 0x8e, 0x6c,
0x0b, 0x6b, 0x2b, 0x8f, 0x99, 0x5d, 0x84, 0x62, 0x0d, 0x26, 0x24, 0xf7, 0xec, 0xf3, 0x11, 0x5d,
0xc1, 0x8a, 0xd9, 0x45, 0x7d, 0xa0, 0xb6, 0xf0, 0xb8, 0x59, 0x72, 0x31, 0x6f, 0xfb, 0x5d, 0x76,
0x11, 0x7f, 0x83, 0x6d, 0xe6, 0x61, 0x99, 0xad, 0x96, 0x1a, 0xb5, 0x05, 0xb6, 0xee, 0xe2, 0x23,
0x88, 0xb8, 0x03, 0xd6, 0x6c, 0x07, 0x2f, 0x61, 0x66, 0x2e, 0x13, 0xa9, 0x73, 0x7c, 0x35, 0x6d,
0xe4, 0x35, 0xb3, 0xd1, 0xfa, 0xd1, 0xd9, 0x20, 0xf0, 0xb5, 0x1f, 0x1d, 0x7a, 0x3d, 0x39, 0xb9,
0x9d, 0xe4, 0x34, 0x17, 0xd1, 0x04, 0xd0, 0xc2, 0x2e, 0xd6, 0x64, 0xe6, 0x34, 0xeb, 0x95, 0x6d,
0x2c, 0xa7, 0x36, 0x86, 0x08, 0x9f, 0x58, 0x58, 0x93, 0x93, 0xc3, 0x20, 0xad, 0xfc, 0xa9, 0x35,
0x54, 0x1b, 0xa9, 0x03, 0x3e, 0xb3, 0x30, 0x9a, 0xf1, 0x01, 0xa8, 0xc2, 0xba, 0x0c, 0x0b, 0xe3,
0x73, 0x0b, 0xb3, 0x3d, 0x36, 0xa8, 0x18, 0x57, 0xeb, 0x17, 0x16, 0x66, 0xfb, 0xd0, 0x70, 0x50,
0x5f, 0xfd, 0xa5, 0x85, 0xf5, 0x0a, 0xba, 0x30, 0x2f, 0xd4, 0x13, 0xdd, 0xaf, 0x2c, 0x2c, 0x86,
0x89, 0xfe, 0x63, 0xad, 0xf5, 0xb5, 0x85, 0x3d, 0xae, 0xc7, 0xe2, 0x9c, 0x1d, 0xbd, 0x00, 0x7a,
0x5b, 0x71, 0x05, 0x73, 0x02, 0x2e, 0xb6, 0xe0, 0x1b, 0x8b, 0x9e, 0x24, 0x47, 0xb7, 0x17, 0xd0,
0x96, 0xbe, 0xcd, 0x3b, 0x99, 0x0a, 0xaa, 0xc7, 0xe5, 0x61, 0x10, 0x4d, 0xc6, 0xef, 0x2c, 0x7c,
0x8a, 0x13, 0x3b, 0x0b, 0x69, 0x8b, 0xdf, 0x5b, 0xf4, 0x44, 0x56, 0xa8, 0x5a, 0xb8, 0xdc, 0x75,
0x71, 0x6c, 0x47, 0x94, 0xa9, 0x8c, 0xfe, 0x60, 0xd1, 0xd3, 0xe4, 0xd4, 0x7f, 0xca, 0x69, 0xbb,
0x3f, 0x5a, 0x48, 0x78, 0xd9, 0x8a, 0xc0, 0x82, 0x79, 0x3f, 0xe2, 0x15, 0x09, 0x3f, 0xe5, 0x92,
0x91, 0x01, 0x5a, 0xf3, 0x72, 0xb4, 0x76, 0xec, 0x19, 0x5c, 0x2e, 0xce, 0xc0, 0x2f, 0x05, 0x33,
0xfa, 0xa8, 0x21, 0x42, 0xe1, 0x74, 0x10, 0x6a, 0x89, 0x10, 0x47, 0x07, 0xe6, 0x3c, 0x94, 0xf0,
0x6b, 0xc1, 0x8c, 0x7e, 0xb8, 0x90, 0xbe, 0xeb, 0xb7, 0x02, 0xb2, 0x80, 0x26, 0xc7, 0x64, 0x80,
0xa6, 0x93, 0xf2, 0xf7, 0x02, 0xb6, 0x70, 0xc6, 0x23, 0x65, 0xd5, 0xc1, 0x4b, 0xb6, 0x93, 0x18,
0x29, 0x77, 0x6c, 0x0f, 0x87, 0xc7, 0x1f, 0x05, 0xb3, 0xe4, 0xca, 0x1d, 0xe6, 0x6c, 0x4c, 0x0b,
0x4c, 0x4a, 0x5b, 0x76, 0x5c, 0x1f, 0xfe, 0x2c, 0x60, 0x13, 0x16, 0xb7, 0x41, 0xb5, 0x1b, 0x7f,
0x15, 0x90, 0x70, 0x4c, 0x22, 0x6e, 0xe0, 0x3a, 0x83, 0xeb, 0x96, 0xba, 0xb2, 0xee, 0x7a, 0x1b,
0xf0, 0x77, 0x01, 0x97, 0x8c, 0xe3, 0x3b, 0xca, 0x68, 0x7b, 0xff, 0x14, 0xe8, 0xa9, 0xac, 0x6d,
0x97, 0x9a, 0xb8, 0xb4, 0xe1, 0xec, 0xc4, 0x62, 0x0e, 0xa5, 0xef, 0x3a, 0x2e, 0x0f, 0x65, 0x34,
0x47, 0x37, 0xdd, 0x60, 0x0b, 0xae, 0x14, 0xcc, 0xe7, 0xa8, 0x34, 0x94, 0xd5, 0x39, 0xd7, 0x11,
0xbc, 0x75, 0x11, 0xdf, 0xeb, 0xd2, 0x88, 0x59, 0x9b, 0x83, 0x02, 0xfa, 0xd2, 0xa7, 0x46, 0xcc,
0xde, 0x88, 0xa7, 0x49, 0xa9, 0x79, 0x1e, 0x9e, 0x1e, 0x31, 0x7b, 0x23, 0x3d, 0xd6, 0x5a, 0xcf,
0x8c, 0xe0, 0xca, 0x98, 0xe3, 0x51, 0xdf, 0x57, 0x19, 0xaa, 0x23, 0x55, 0xc1, 0xb3, 0x23, 0x66,
0x7d, 0x0e, 0xe0, 0xda, 0xce, 0x73, 0x23, 0x53, 0x3f, 0x5b, 0xe4, 0xff, 0xd5, 0xe6, 0x7c, 0xb6,
0xdf, 0xc6, 0xbf, 0x57, 0xca, 0x82, 0x45, 0x53, 0x61, 0x34, 0x77, 0x98, 0x3c, 0x35, 0x8c, 0xd1,
0xbd, 0xb1, 0xcb, 0xc9, 0x61, 0x05, 0x99, 0x4a, 0xf0, 0x2d, 0x18, 0x57, 0x94, 0xa8, 0xf4, 0x23,
0x1e, 0x68, 0x86, 0xab, 0xd2, 0x11, 0xee, 0x2a, 0xae, 0x57, 0x13, 0x6a, 0xc7, 0x35, 0xd0, 0x45,
0x4f, 0x66, 0xf8, 0x3e, 0x45, 0xe9, 0xe6, 0x45, 0x29, 0x2f, 0xc3, 0x7e, 0x35, 0x16, 0x06, 0x4d,
0xfb, 0xc9, 0xd8, 0x5d, 0x13, 0x4c, 0x76, 0x60, 0x52, 0x51, 0xf7, 0x50, 0x0f, 0x16, 0xfd, 0x16,
0xaf, 0x44, 0xde, 0x1f, 0x9c, 0xba, 0x62, 0x11, 0xc0, 0xcc, 0x44, 0xed, 0xa1, 0x3b, 0x51, 0x75,
0x4f, 0x5c, 0xb3, 0x8d, 0xb8, 0x25, 0x13, 0x2a, 0xff, 0x68, 0x5c, 0xd1, 0xa6, 0x81, 0xa8, 0xe4,
0x7d, 0x3c, 0xae, 0xda, 0x20, 0x86, 0x12, 0x4b, 0xcb, 0xac, 0xeb, 0xf0, 0x1e, 0x83, 0x77, 0x8a,
0x26, 0xd6, 0x8c, 0x77, 0xe8, 0x14, 0x7b, 0xb7, 0x68, 0x5e, 0x96, 0xe8, 0xcd, 0xb2, 0x6e, 0x97,
0xc3, 0x7b, 0x39, 0x24, 0xd1, 0x4a, 0x90, 0xf7, 0x8b, 0xaa, 0x89, 0x0d, 0x1d, 0xfc, 0x12, 0xf0,
0x58, 0xbc, 0xd9, 0xa9, 0x26, 0xfe, 0x20, 0x27, 0x94, 0xa8, 0x0f, 0x08, 0x7d, 0x58, 0x9c, 0xba,
0x5c, 0x20, 0x04, 0xe3, 0x6f, 0xf1, 0xb8, 0x3a, 0x74, 0x2f, 0xab, 0xff, 0x09, 0x4b, 0x95, 0x9c,
0x0d, 0x78, 0xde, 0xd2, 0x0d, 0xd6, 0x8f, 0xe9, 0x24, 0xbc, 0x90, 0x31, 0x96, 0x92, 0x89, 0x38,
0x0d, 0x1f, 0xf4, 0xc5, 0x6c, 0xa8, 0xe4, 0x80, 0xe4, 0x53, 0xe8, 0x25, 0xcb, 0x74, 0x55, 0x51,
0x48, 0xb8, 0x1a, 0x79, 0x1d, 0xf3, 0x48, 0xb4, 0x99, 0xc3, 0xcb, 0x96, 0xa2, 0x81, 0x58, 0x48,
0xbd, 0xc8, 0x80, 0xd4, 0x2b, 0x16, 0xbd, 0x21, 0x9e, 0xa1, 0x3b, 0x49, 0x69, 0x7f, 0x5f, 0xcd,
0x98, 0x3b, 0x17, 0x53, 0xfc, 0x2d, 0x14, 0xfa, 0xb8, 0x47, 0xfa, 0xf1, 0xd4, 0x7b, 0x2d, 0x9d,
0xa8, 0xb1, 0xd5, 0x48, 0xb4, 0x39, 0x9f, 0xaf, 0x28, 0x78, 0x3d, 0x17, 0x83, 0x21, 0x62, 0x14,
0x36, 0xbc, 0x31, 0x20, 0x54, 0xe7, 0x76, 0x5b, 0x79, 0xa6, 0xe4, 0xe1, 0xcd, 0x74, 0xf6, 0xec,
0x20, 0xa4, 0x23, 0x78, 0x6b, 0xc0, 0x62, 0x8e, 0x81, 0x93, 0xd9, 0xfa, 0xb6, 0x75, 0xf6, 0x7f,
0xb3, 0xd6, 0x25, 0x6b, 0xd7, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x05, 0xab, 0xaf, 0x14, 0xda,
0x0e, 0x00, 0x00,
}

View File

@ -0,0 +1,188 @@
/*
Includes inventory types as used in the trade package
*/
package inventory
import (
"bytes"
"encoding/json"
"fmt"
"github.com/Philipp15b/go-steam/jsont"
"strconv"
)
type GenericInventory map[uint32]map[uint64]*Inventory
func NewGenericInventory() GenericInventory {
iMap := make(map[uint32]map[uint64]*Inventory)
return GenericInventory(iMap)
}
// Get inventory for specified AppId and ContextId
func (i *GenericInventory) Get(appId uint32, contextId uint64) (*Inventory, error) {
iMap := (map[uint32]map[uint64]*Inventory)(*i)
iMap2, ok := iMap[appId]
if !ok {
return nil, fmt.Errorf("inventory for specified appId not found")
}
inv, ok := iMap2[contextId]
if !ok {
return nil, fmt.Errorf("inventory for specified contextId not found")
}
return inv, nil
}
func (i *GenericInventory) Add(appId uint32, contextId uint64, inv *Inventory) {
iMap := (map[uint32]map[uint64]*Inventory)(*i)
iMap2, ok := iMap[appId]
if !ok {
iMap2 = make(map[uint64]*Inventory)
iMap[appId] = iMap2
}
iMap2[contextId] = inv
}
type Inventory struct {
Items Items `json:"rgInventory"`
Currencies Currencies `json:"rgCurrency"`
Descriptions Descriptions `json:"rgDescriptions"`
AppInfo *AppInfo `json:"rgAppInfo"`
}
// Items key is an AssetId
type Items map[string]*Item
func (i *Items) ToMap() map[string]*Item {
return (map[string]*Item)(*i)
}
func (i *Items) Get(assetId uint64) (*Item, error) {
iMap := (map[string]*Item)(*i)
if item, ok := iMap[strconv.FormatUint(assetId, 10)]; ok {
return item, nil
}
return nil, fmt.Errorf("item not found")
}
func (i *Items) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte("[]")) {
return nil
}
return json.Unmarshal(data, (*map[string]*Item)(i))
}
type Currencies map[string]*Currency
func (c *Currencies) ToMap() map[string]*Currency {
return (map[string]*Currency)(*c)
}
func (c *Currencies) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte("[]")) {
return nil
}
return json.Unmarshal(data, (*map[string]*Currency)(c))
}
// Descriptions key format is %d_%d, first %d is ClassId, second is InstanceId
type Descriptions map[string]*Description
func (d *Descriptions) ToMap() map[string]*Description {
return (map[string]*Description)(*d)
}
func (d *Descriptions) Get(classId uint64, instanceId uint64) (*Description, error) {
dMap := (map[string]*Description)(*d)
descId := fmt.Sprintf("%v_%v", classId, instanceId)
if desc, ok := dMap[descId]; ok {
return desc, nil
}
return nil, fmt.Errorf("description not found")
}
func (d *Descriptions) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte("[]")) {
return nil
}
return json.Unmarshal(data, (*map[string]*Description)(d))
}
type Item struct {
Id uint64 `json:",string"`
ClassId uint64 `json:",string"`
InstanceId uint64 `json:",string"`
Amount uint64 `json:",string"`
Pos uint32
}
type Currency struct {
Id uint64 `json:",string"`
ClassId uint64 `json:",string"`
IsCurrency bool `json:"is_currency"`
Pos uint32
}
type Description struct {
AppId uint32 `json:",string"`
ClassId uint64 `json:",string"`
InstanceId uint64 `json:",string"`
IconUrl string `json:"icon_url"`
IconUrlLarge string `json:"icon_url_large"`
IconDragUrl string `json:"icon_drag_url"`
Name string
MarketName string `json:"market_name"`
MarketHashName string `json:"market_hash_name"`
// Colors in hex, for example `B2B2B2`
NameColor string `json:"name_color"`
BackgroundColor string `json:"background_color"`
Type string
Tradable jsont.UintBool
Marketable jsont.UintBool
Commodity jsont.UintBool
MarketTradableRestriction uint32 `json:"market_tradable_restriction,string"`
Descriptions DescriptionLines
Actions []*Action
// Application-specific data, like "def_index" and "quality" for TF2
AppData map[string]string
Tags []*Tag
}
type DescriptionLines []*DescriptionLine
func (d *DescriptionLines) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte(`""`)) {
return nil
}
return json.Unmarshal(data, (*[]*DescriptionLine)(d))
}
type DescriptionLine struct {
Value string
Type *string // Is `html` for HTML descriptions
Color *string
}
type Action struct {
Name string
Link string
}
type AppInfo struct {
AppId uint32
Name string
Icon string
Link string
}
type Tag struct {
InternalName string `json:internal_name`
Name string
Category string
CategoryName string `json:category_name`
}

View File

@ -0,0 +1,79 @@
package inventory
import (
"encoding/json"
"fmt"
"github.com/Philipp15b/go-steam/steamid"
"io/ioutil"
"net/http"
"regexp"
"strconv"
)
type InventoryApps map[string]*InventoryApp
func (i *InventoryApps) Get(appId uint32) (*InventoryApp, error) {
iMap := (map[string]*InventoryApp)(*i)
if inventoryApp, ok := iMap[strconv.FormatUint(uint64(appId), 10)]; ok {
return inventoryApp, nil
}
return nil, fmt.Errorf("inventory app not found")
}
func (i *InventoryApps) ToMap() map[string]*InventoryApp {
return (map[string]*InventoryApp)(*i)
}
type InventoryApp struct {
AppId uint32
Name string
Icon string
Link string
AssetCount uint32 `json:"asset_count"`
InventoryLogo string `json:"inventory_logo"`
TradePermissions string `json:"trade_permissions"`
Contexts Contexts `json:"rgContexts"`
}
type Contexts map[string]*Context
func (c *Contexts) Get(contextId uint64) (*Context, error) {
cMap := (map[string]*Context)(*c)
if context, ok := cMap[strconv.FormatUint(contextId, 10)]; ok {
return context, nil
}
return nil, fmt.Errorf("context not found")
}
func (c *Contexts) ToMap() map[string]*Context {
return (map[string]*Context)(*c)
}
type Context struct {
ContextId uint64 `json:"id,string"`
AssetCount uint32 `json:"asset_count"`
Name string
}
func GetInventoryApps(client *http.Client, steamId steamid.SteamId) (InventoryApps, error) {
resp, err := http.Get("http://steamcommunity.com/profiles/" + steamId.ToString() + "/inventory/")
if err != nil {
return nil, err
}
defer resp.Body.Close()
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
reg := regexp.MustCompile("var g_rgAppContextData = (.*?);")
inventoryAppsMatches := reg.FindSubmatch(respBody)
if inventoryAppsMatches == nil {
return nil, fmt.Errorf("profile inventory not found in steam response")
}
var inventoryApps InventoryApps
if err = json.Unmarshal(inventoryAppsMatches[1], &inventoryApps); err != nil {
return nil, err
}
return inventoryApps, nil
}

View File

@ -0,0 +1,28 @@
package inventory
import (
"fmt"
"net/http"
"strconv"
)
func GetPartialOwnInventory(client *http.Client, contextId uint64, appId uint32, start *uint) (*PartialInventory, error) {
// TODO: the "trading" parameter can be left off to return non-tradable items too
url := fmt.Sprintf("http://steamcommunity.com/my/inventory/json/%d/%d?trading=1", appId, contextId)
if start != nil {
url += "&start=" + strconv.FormatUint(uint64(*start), 10)
}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
panic(err)
}
return DoInventoryRequest(client, req)
}
func GetOwnInventory(client *http.Client, contextId uint64, appId uint32) (*Inventory, error) {
return GetFullInventory(func() (*PartialInventory, error) {
return GetPartialOwnInventory(client, contextId, appId, nil)
}, func(start uint) (*PartialInventory, error) {
return GetPartialOwnInventory(client, contextId, appId, &start)
})
}

View File

@ -0,0 +1,91 @@
package inventory
import (
"bytes"
"encoding/json"
"errors"
"net/http"
)
// A partial inventory as sent by the Steam API.
type PartialInventory struct {
Success bool
Error string
Inventory
More bool
MoreStart MoreStart `json:"more_start"`
}
type MoreStart uint
func (m *MoreStart) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte("false")) {
return nil
}
return json.Unmarshal(data, (*uint)(m))
}
func DoInventoryRequest(client *http.Client, req *http.Request) (*PartialInventory, error) {
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
inv := new(PartialInventory)
err = json.NewDecoder(resp.Body).Decode(inv)
if err != nil {
return nil, err
}
return inv, nil
}
func GetFullInventory(getFirst func() (*PartialInventory, error), getNext func(start uint) (*PartialInventory, error)) (*Inventory, error) {
first, err := getFirst()
if err != nil {
return nil, err
}
if !first.Success {
return nil, errors.New("GetFullInventory API call failed: " + first.Error)
}
result := &first.Inventory
var next *PartialInventory
for latest := first; latest.More; latest = next {
next, err := getNext(uint(latest.MoreStart))
if err != nil {
return nil, err
}
if !next.Success {
return nil, errors.New("GetFullInventory API call failed: " + next.Error)
}
result = Merge(result, &next.Inventory)
}
return result, nil
}
// Merges the given Inventory into a single Inventory.
// The given slice must have at least one element. The first element of the slice is used
// and modified.
func Merge(p ...*Inventory) *Inventory {
inv := p[0]
for idx, i := range p {
if idx == 0 {
continue
}
for key, value := range i.Items {
inv.Items[key] = value
}
for key, value := range i.Descriptions {
inv.Descriptions[key] = value
}
for key, value := range i.Currencies {
inv.Currencies[key] = value
}
}
return inv
}

View File

@ -0,0 +1,79 @@
package steam
import (
"bytes"
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/gamecoordinator"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
"github.com/golang/protobuf/proto"
)
type GameCoordinator struct {
client *Client
handlers []GCPacketHandler
}
func newGC(client *Client) *GameCoordinator {
return &GameCoordinator{
client: client,
handlers: make([]GCPacketHandler, 0),
}
}
type GCPacketHandler interface {
HandleGCPacket(*GCPacket)
}
func (g *GameCoordinator) RegisterPacketHandler(handler GCPacketHandler) {
g.handlers = append(g.handlers, handler)
}
func (g *GameCoordinator) HandlePacket(packet *Packet) {
if packet.EMsg != EMsg_ClientFromGC {
return
}
msg := new(CMsgGCClient)
packet.ReadProtoMsg(msg)
p, err := NewGCPacket(msg)
if err != nil {
g.client.Errorf("Error reading GC message: %v", err)
return
}
for _, handler := range g.handlers {
handler.HandleGCPacket(p)
}
}
func (g *GameCoordinator) Write(msg IGCMsg) {
buf := new(bytes.Buffer)
msg.Serialize(buf)
msgType := msg.GetMsgType()
if msg.IsProto() {
msgType = msgType | 0x80000000 // mask with protoMask
}
g.client.Write(NewClientMsgProtobuf(EMsg_ClientToGC, &CMsgGCClient{
Msgtype: proto.Uint32(msgType),
Appid: proto.Uint32(msg.GetAppId()),
Payload: buf.Bytes(),
}))
}
// Sets you in the given games. Specify none to quit all games.
func (g *GameCoordinator) SetGamesPlayed(appIds ...uint64) {
games := make([]*CMsgClientGamesPlayed_GamePlayed, 0)
for _, appId := range appIds {
games = append(games, &CMsgClientGamesPlayed_GamePlayed{
GameId: proto.Uint64(appId),
})
}
g.client.Write(NewClientMsgProtobuf(EMsg_ClientGamesPlayed, &CMsgClientGamesPlayed{
GamesPlayed: games,
}))
}

View File

@ -0,0 +1,295 @@
/*
This program generates the protobuf and SteamLanguage files from the SteamKit data.
*/
package main
import (
"bytes"
"fmt"
"go/ast"
"go/parser"
"go/token"
"io"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"strings"
)
var printCommands = false
func main() {
args := strings.Join(os.Args[1:], " ")
found := false
if strings.Contains(args, "clean") {
clean()
found = true
}
if strings.Contains(args, "steamlang") {
buildSteamLanguage()
found = true
}
if strings.Contains(args, "proto") {
buildProto()
found = true
}
if !found {
os.Stderr.WriteString("Invalid target!\nAvailable targets: clean, proto, steamlang\n")
os.Exit(1)
}
}
func clean() {
print("# Cleaning")
cleanGlob("../protocol/**/*.pb.go")
cleanGlob("../tf2/protocol/**/*.pb.go")
cleanGlob("../dota/protocol/**/*.pb.go")
os.Remove("../protocol/steamlang/enums.go")
os.Remove("../protocol/steamlang/messages.go")
}
func cleanGlob(pattern string) {
protos, _ := filepath.Glob(pattern)
for _, proto := range protos {
err := os.Remove(proto)
if err != nil {
panic(err)
}
}
}
func buildSteamLanguage() {
print("# Building Steam Language")
exePath := "./GoSteamLanguageGenerator/bin/Debug/GoSteamLanguageGenerator.exe"
if runtime.GOOS != "windows" {
execute("mono", exePath, "./SteamKit", "../protocol/steamlang")
} else {
execute(exePath, "./SteamKit", "../protocol/steamlang")
}
execute("gofmt", "-w", "../protocol/steamlang/enums.go", "../protocol/steamlang/messages.go")
}
func buildProto() {
print("# Building Protobufs")
buildProtoMap("steamclient", clientProtoFiles, "../protocol/protobuf")
buildProtoMap("tf", tf2ProtoFiles, "../tf2/protocol/protobuf")
buildProtoMap("dota", dotaProtoFiles, "../dota/protocol/protobuf")
}
func buildProtoMap(srcSubdir string, files map[string]string, outDir string) {
os.MkdirAll(outDir, os.ModePerm)
for proto, out := range files {
full := filepath.Join(outDir, out)
compileProto("SteamKit/Resources/Protobufs", srcSubdir, proto, full)
fixProto(full)
}
}
// Maps the proto files to their target files.
// See `SteamKit/Resources/Protobufs/steamclient/generate-base.bat` for reference.
var clientProtoFiles = map[string]string{
"steammessages_base.proto": "base.pb.go",
"encrypted_app_ticket.proto": "app_ticket.pb.go",
"steammessages_clientserver.proto": "client_server.pb.go",
"steammessages_clientserver_2.proto": "client_server_2.pb.go",
"content_manifest.proto": "content_manifest.pb.go",
"steammessages_unified_base.steamclient.proto": "unified/base.pb.go",
"steammessages_cloud.steamclient.proto": "unified/cloud.pb.go",
"steammessages_credentials.steamclient.proto": "unified/credentials.pb.go",
"steammessages_deviceauth.steamclient.proto": "unified/deviceauth.pb.go",
"steammessages_gamenotifications.steamclient.proto": "unified/gamenotifications.pb.go",
"steammessages_offline.steamclient.proto": "unified/offline.pb.go",
"steammessages_parental.steamclient.proto": "unified/parental.pb.go",
"steammessages_partnerapps.steamclient.proto": "unified/partnerapps.pb.go",
"steammessages_player.steamclient.proto": "unified/player.pb.go",
"steammessages_publishedfile.steamclient.proto": "unified/publishedfile.pb.go",
}
var tf2ProtoFiles = map[string]string{
"base_gcmessages.proto": "base.pb.go",
"econ_gcmessages.proto": "econ.pb.go",
"gcsdk_gcmessages.proto": "gcsdk.pb.go",
"tf_gcmessages.proto": "tf.pb.go",
"gcsystemmsgs.proto": "system.pb.go",
}
var dotaProtoFiles = map[string]string{
"base_gcmessages.proto": "base.pb.go",
"econ_gcmessages.proto": "econ.pb.go",
"gcsdk_gcmessages.proto": "gcsdk.pb.go",
"dota_gcmessages_common.proto": "dota_common.pb.go",
"dota_gcmessages_client.proto": "dota_client.pb.go",
"dota_gcmessages_client_fantasy.proto": "dota_client_fantasy.pb.go",
"gcsystemmsgs.proto": "system.pb.go",
}
func compileProto(srcBase, srcSubdir, proto, target string) {
outDir, _ := filepath.Split(target)
err := os.MkdirAll(outDir, os.ModePerm)
if err != nil {
panic(err)
}
execute("protoc", "--go_out="+outDir, "-I="+srcBase+"/"+srcSubdir, "-I="+srcBase, filepath.Join(srcBase, srcSubdir, proto))
out := strings.Replace(filepath.Join(outDir, proto), ".proto", ".pb.go", 1)
err = forceRename(out, target)
if err != nil {
panic(err)
}
}
func forceRename(from, to string) error {
if from != to {
os.Remove(to)
}
return os.Rename(from, to)
}
var pkgRegex = regexp.MustCompile(`(package \w+)`)
var pkgCommentRegex = regexp.MustCompile(`(?s)(\/\*.*?\*\/\n)package`)
var unusedImportCommentRegex = regexp.MustCompile("// discarding unused import .*\n")
var fileDescriptorVarRegex = regexp.MustCompile(`fileDescriptor\d+`)
func fixProto(path string) {
// goprotobuf is really bad at dependencies, so we must fix them manually...
// It tries to load each dependency of a file as a seperate package (but in a very, very wrong way).
// Because we want some files in the same package, we'll remove those imports to local files.
file, err := ioutil.ReadFile(path)
if err != nil {
panic(err)
}
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, path, file, parser.ImportsOnly)
if err != nil {
panic("Error parsing " + path + ": " + err.Error())
}
importsToRemove := make([]*ast.ImportSpec, 0)
for _, i := range f.Imports {
// We remove all local imports
if i.Path.Value == "\".\"" {
importsToRemove = append(importsToRemove, i)
}
}
for _, itr := range importsToRemove {
// remove the package name from all types
file = bytes.Replace(file, []byte(itr.Name.Name+"."), []byte{}, -1)
// and remove the import itself
file = bytes.Replace(file, []byte(fmt.Sprintf("import %v %v\n", itr.Name.Name, itr.Path.Value)), []byte{}, -1)
}
// remove the package comment because it just includes a list of all messages and
// collides not only with the other compiled protobuf files, but also our own documentation.
file = cutAllSubmatch(pkgCommentRegex, file, 1)
// remove warnings
file = unusedImportCommentRegex.ReplaceAllLiteral(file, []byte{})
// fix the package name
file = pkgRegex.ReplaceAll(file, []byte("package "+inferPackageName(path)))
// fix the google dependency;
// we just reuse the one from protoc-gen-go
file = bytes.Replace(file, []byte("google/protobuf"), []byte("github.com/golang/protobuf/protoc-gen-go/descriptor"), -1)
// we need to prefix local variables created by protoc-gen-go so that they don't clash with others in the same package
filename := strings.Split(filepath.Base(path), ".")[0]
file = fileDescriptorVarRegex.ReplaceAllFunc(file, func(match []byte) []byte {
return []byte(filename + "_" + string(match))
})
err = ioutil.WriteFile(path, file, os.ModePerm)
if err != nil {
panic(err)
}
}
func inferPackageName(path string) string {
pieces := strings.Split(path, string(filepath.Separator))
return pieces[len(pieces)-2]
}
func cutAllSubmatch(r *regexp.Regexp, b []byte, n int) []byte {
i := r.FindSubmatchIndex(b)
return bytesCut(b, i[2*n], i[2*n+1])
}
// Removes the given section from the byte array
func bytesCut(b []byte, from, to int) []byte {
buf := new(bytes.Buffer)
buf.Write(b[:from])
buf.Write(b[to:])
return buf.Bytes()
}
func print(text string) { os.Stdout.WriteString(text + "\n") }
func printerr(text string) { os.Stderr.WriteString(text + "\n") }
// This writer appends a "> " after every newline so that the outpout appears quoted.
type QuotedWriter struct {
w io.Writer
started bool
}
func NewQuotedWriter(w io.Writer) *QuotedWriter {
return &QuotedWriter{w, false}
}
func (w *QuotedWriter) Write(p []byte) (n int, err error) {
if !w.started {
_, err = w.w.Write([]byte("> "))
if err != nil {
return n, err
}
w.started = true
}
for i, c := range p {
if c == '\n' {
nw, err := w.w.Write(p[n : i+1])
n += nw
if err != nil {
return n, err
}
_, err = w.w.Write([]byte("> "))
if err != nil {
return n, err
}
}
}
if n != len(p) {
nw, err := w.w.Write(p[n:len(p)])
n += nw
return n, err
}
return
}
func execute(command string, args ...string) {
if printCommands {
print(command + " " + strings.Join(args, " "))
}
cmd := exec.Command(command, args...)
cmd.Stdout = NewQuotedWriter(os.Stdout)
cmd.Stderr = NewQuotedWriter(os.Stderr)
err := cmd.Run()
if err != nil {
printerr(err.Error())
os.Exit(1)
}
}

210
vendor/github.com/Philipp15b/go-steam/gsbot/gsbot.go generated vendored Normal file
View File

@ -0,0 +1,210 @@
// The GsBot package contains some useful utilites for working with the
// steam package. It implements authentication with sentries, server lists and
// logging messages and events.
//
// Every module is optional and requires an instance of the GsBot struct.
// Should a module have a `HandlePacket` method, you must register it with the
// steam.Client with `RegisterPacketHandler`. Any module with a `HandleEvent`
// method must be integrated into your event loop and should be called for each
// event you receive.
package gsbot
import (
"encoding/hex"
"encoding/json"
"fmt"
"io/ioutil"
"log"
"math/rand"
"net"
"os"
"path"
"reflect"
"time"
"github.com/Philipp15b/go-steam"
"github.com/Philipp15b/go-steam/netutil"
"github.com/Philipp15b/go-steam/protocol"
"github.com/davecgh/go-spew/spew"
)
// Base structure holding common data among GsBot modules.
type GsBot struct {
Client *steam.Client
Log *log.Logger
}
// Creates a new GsBot with a new steam.Client where logs are written to stdout.
func Default() *GsBot {
return &GsBot{
steam.NewClient(),
log.New(os.Stdout, "", 0),
}
}
// This module handles authentication. It logs on automatically after a ConnectedEvent
// and saves the sentry data to a file which is also used for logon if available.
// If you're logging on for the first time Steam may require an authcode. You can then
// connect again with the new logon details.
type Auth struct {
bot *GsBot
details *LogOnDetails
sentryPath string
machineAuthHash []byte
}
func NewAuth(bot *GsBot, details *LogOnDetails, sentryPath string) *Auth {
return &Auth{
bot: bot,
details: details,
sentryPath: sentryPath,
}
}
type LogOnDetails struct {
Username string
Password string
AuthCode string
TwoFactorCode string
}
// This is called automatically after every ConnectedEvent, but must be called once again manually
// with an authcode if Steam requires it when logging on for the first time.
func (a *Auth) LogOn(details *LogOnDetails) {
a.details = details
sentry, err := ioutil.ReadFile(a.sentryPath)
if err != nil {
a.bot.Log.Printf("Error loading sentry file from path %v - This is normal if you're logging in for the first time.\n", a.sentryPath)
}
a.bot.Client.Auth.LogOn(&steam.LogOnDetails{
Username: details.Username,
Password: details.Password,
SentryFileHash: sentry,
AuthCode: details.AuthCode,
TwoFactorCode: details.TwoFactorCode,
})
}
func (a *Auth) HandleEvent(event interface{}) {
switch e := event.(type) {
case *steam.ConnectedEvent:
a.LogOn(a.details)
case *steam.LoggedOnEvent:
a.bot.Log.Printf("Logged on (%v) with SteamId %v and account flags %v", e.Result, e.ClientSteamId, e.AccountFlags)
case *steam.MachineAuthUpdateEvent:
a.machineAuthHash = e.Hash
err := ioutil.WriteFile(a.sentryPath, e.Hash, 0666)
if err != nil {
panic(err)
}
}
}
// This module saves the server list from ClientCMListEvent and uses
// it when you call `Connect()`.
type ServerList struct {
bot *GsBot
listPath string
}
func NewServerList(bot *GsBot, listPath string) *ServerList {
return &ServerList{
bot,
listPath,
}
}
func (s *ServerList) HandleEvent(event interface{}) {
switch e := event.(type) {
case *steam.ClientCMListEvent:
d, err := json.Marshal(e.Addresses)
if err != nil {
panic(err)
}
err = ioutil.WriteFile(s.listPath, d, 0666)
if err != nil {
panic(err)
}
}
}
func (s *ServerList) Connect() (bool, error) {
return s.ConnectBind(nil)
}
func (s *ServerList) ConnectBind(laddr *net.TCPAddr) (bool, error) {
d, err := ioutil.ReadFile(s.listPath)
if err != nil {
s.bot.Log.Println("Connecting to random server.")
s.bot.Client.Connect()
return false, nil
}
var addrs []*netutil.PortAddr
err = json.Unmarshal(d, &addrs)
if err != nil {
return false, err
}
raddr := addrs[rand.Intn(len(addrs))]
s.bot.Log.Printf("Connecting to %v from server list\n", raddr)
s.bot.Client.ConnectToBind(raddr, laddr)
return true, nil
}
// This module logs incoming packets and events to a directory.
type Debug struct {
packetId, eventId uint64
bot *GsBot
base string
}
func NewDebug(bot *GsBot, base string) (*Debug, error) {
base = path.Join(base, fmt.Sprint(time.Now().Unix()))
err := os.MkdirAll(path.Join(base, "events"), 0700)
if err != nil {
return nil, err
}
err = os.MkdirAll(path.Join(base, "packets"), 0700)
if err != nil {
return nil, err
}
return &Debug{
0, 0,
bot,
base,
}, nil
}
func (d *Debug) HandlePacket(packet *protocol.Packet) {
d.packetId++
name := path.Join(d.base, "packets", fmt.Sprintf("%d_%d_%s", time.Now().Unix(), d.packetId, packet.EMsg))
text := packet.String() + "\n\n" + hex.Dump(packet.Data)
err := ioutil.WriteFile(name+".txt", []byte(text), 0666)
if err != nil {
panic(err)
}
err = ioutil.WriteFile(name+".bin", packet.Data, 0666)
if err != nil {
panic(err)
}
}
func (d *Debug) HandleEvent(event interface{}) {
d.eventId++
name := fmt.Sprintf("%d_%d_%s.txt", time.Now().Unix(), d.eventId, name(event))
err := ioutil.WriteFile(path.Join(d.base, "events", name), []byte(spew.Sdump(event)), 0666)
if err != nil {
panic(err)
}
}
func name(obj interface{}) string {
val := reflect.ValueOf(obj)
ind := reflect.Indirect(val)
if ind.IsValid() {
return ind.Type().Name()
} else {
return val.Type().Name()
}
}

View File

@ -0,0 +1,56 @@
// A simple example that uses the modules from the gsbot package and go-steam to log on
// to the Steam network.
//
// The command expects log on data, optionally with an auth code:
//
// gsbot [username] [password]
// gsbot [username] [password] [authcode]
package main
import (
"fmt"
"os"
"github.com/Philipp15b/go-steam"
"github.com/Philipp15b/go-steam/gsbot"
"github.com/Philipp15b/go-steam/protocol/steamlang"
)
func main() {
if len(os.Args) < 3 {
fmt.Println("gsbot example\nusage: \n\tgsbot [username] [password] [authcode]")
return
}
authcode := ""
if len(os.Args) > 3 {
authcode = os.Args[3]
}
bot := gsbot.Default()
client := bot.Client
auth := gsbot.NewAuth(bot, &gsbot.LogOnDetails{
os.Args[1],
os.Args[2],
authcode,
}, "sentry.bin")
debug, err := gsbot.NewDebug(bot, "debug")
if err != nil {
panic(err)
}
client.RegisterPacketHandler(debug)
serverList := gsbot.NewServerList(bot, "serverlist.json")
serverList.Connect()
for event := range client.Events() {
auth.HandleEvent(event)
debug.HandleEvent(event)
serverList.HandleEvent(event)
switch e := event.(type) {
case error:
fmt.Printf("Error: %v", e)
case *steam.LoggedOnEvent:
client.Social.SetPersonaState(steamlang.EPersonaState_Online)
}
}
}

19
vendor/github.com/Philipp15b/go-steam/jsont/jsont.go generated vendored Normal file
View File

@ -0,0 +1,19 @@
// Includes helper types for working with JSON data
package jsont
import (
"encoding/json"
)
// A boolean value that can be unmarshaled from a number in JSON.
type UintBool bool
func (u *UintBool) UnmarshalJSON(data []byte) error {
var n uint
err := json.Unmarshal(data, &n)
if err != nil {
return err
}
*u = n != 0
return nil
}

58
vendor/github.com/Philipp15b/go-steam/keys.go generated vendored Normal file
View File

@ -0,0 +1,58 @@
package steam
import (
"crypto/rsa"
"github.com/Philipp15b/go-steam/cryptoutil"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
)
var publicKeys = map[EUniverse][]byte{
EUniverse_Public: []byte{
0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xDF, 0xEC, 0x1A,
0xD6, 0x2C, 0x10, 0x66, 0x2C, 0x17, 0x35, 0x3A, 0x14, 0xB0, 0x7C, 0x59, 0x11, 0x7F, 0x9D, 0xD3,
0xD8, 0x2B, 0x7A, 0xE3, 0xE0, 0x15, 0xCD, 0x19, 0x1E, 0x46, 0xE8, 0x7B, 0x87, 0x74, 0xA2, 0x18,
0x46, 0x31, 0xA9, 0x03, 0x14, 0x79, 0x82, 0x8E, 0xE9, 0x45, 0xA2, 0x49, 0x12, 0xA9, 0x23, 0x68,
0x73, 0x89, 0xCF, 0x69, 0xA1, 0xB1, 0x61, 0x46, 0xBD, 0xC1, 0xBE, 0xBF, 0xD6, 0x01, 0x1B, 0xD8,
0x81, 0xD4, 0xDC, 0x90, 0xFB, 0xFE, 0x4F, 0x52, 0x73, 0x66, 0xCB, 0x95, 0x70, 0xD7, 0xC5, 0x8E,
0xBA, 0x1C, 0x7A, 0x33, 0x75, 0xA1, 0x62, 0x34, 0x46, 0xBB, 0x60, 0xB7, 0x80, 0x68, 0xFA, 0x13,
0xA7, 0x7A, 0x8A, 0x37, 0x4B, 0x9E, 0xC6, 0xF4, 0x5D, 0x5F, 0x3A, 0x99, 0xF9, 0x9E, 0xC4, 0x3A,
0xE9, 0x63, 0xA2, 0xBB, 0x88, 0x19, 0x28, 0xE0, 0xE7, 0x14, 0xC0, 0x42, 0x89, 0x02, 0x01, 0x11,
},
EUniverse_Beta: []byte{
0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xAE, 0xD1, 0x4B,
0xC0, 0xA3, 0x36, 0x8B, 0xA0, 0x39, 0x0B, 0x43, 0xDC, 0xED, 0x6A, 0xC8, 0xF2, 0xA3, 0xE4, 0x7E,
0x09, 0x8C, 0x55, 0x2E, 0xE7, 0xE9, 0x3C, 0xBB, 0xE5, 0x5E, 0x0F, 0x18, 0x74, 0x54, 0x8F, 0xF3,
0xBD, 0x56, 0x69, 0x5B, 0x13, 0x09, 0xAF, 0xC8, 0xBE, 0xB3, 0xA1, 0x48, 0x69, 0xE9, 0x83, 0x49,
0x65, 0x8D, 0xD2, 0x93, 0x21, 0x2F, 0xB9, 0x1E, 0xFA, 0x74, 0x3B, 0x55, 0x22, 0x79, 0xBF, 0x85,
0x18, 0xCB, 0x6D, 0x52, 0x44, 0x4E, 0x05, 0x92, 0x89, 0x6A, 0xA8, 0x99, 0xED, 0x44, 0xAE, 0xE2,
0x66, 0x46, 0x42, 0x0C, 0xFB, 0x6E, 0x4C, 0x30, 0xC6, 0x6C, 0x5C, 0x16, 0xFF, 0xBA, 0x9C, 0xB9,
0x78, 0x3F, 0x17, 0x4B, 0xCB, 0xC9, 0x01, 0x5D, 0x3E, 0x37, 0x70, 0xEC, 0x67, 0x5A, 0x33, 0x48,
},
EUniverse_Internal: []byte{
0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xA8, 0xFE, 0x01,
0x3B, 0xB6, 0xD7, 0x21, 0x4B, 0x53, 0x23, 0x6F, 0xA1, 0xAB, 0x4E, 0xF1, 0x07, 0x30, 0xA7, 0xC6,
0x7E, 0x6A, 0x2C, 0xC2, 0x5D, 0x3A, 0xB8, 0x40, 0xCA, 0x59, 0x4D, 0x16, 0x2D, 0x74, 0xEB, 0x0E,
0x72, 0x46, 0x29, 0xF9, 0xDE, 0x9B, 0xCE, 0x4B, 0x8C, 0xD0, 0xCA, 0xF4, 0x08, 0x94, 0x46, 0xA5,
0x11, 0xAF, 0x3A, 0xCB, 0xB8, 0x4E, 0xDE, 0xC6, 0xD8, 0x85, 0x0A, 0x7D, 0xAA, 0x96, 0x0A, 0xEA,
0x7B, 0x51, 0xD6, 0x22, 0x62, 0x5C, 0x1E, 0x58, 0xD7, 0x46, 0x1E, 0x09, 0xAE, 0x43, 0xA7, 0xC4,
0x34, 0x69, 0xA2, 0xA5, 0xE8, 0x44, 0x76, 0x18, 0xE2, 0x3D, 0xB7, 0xC5, 0xA8, 0x96, 0xFD, 0xE5,
0xB4, 0x4B, 0xF8, 0x40, 0x12, 0xA6, 0x17, 0x4E, 0xC4, 0xC1, 0x60, 0x0E, 0xB0, 0xC2, 0xB8, 0x40,
},
}
func GetPublicKey(universe EUniverse) *rsa.PublicKey {
bytes, ok := publicKeys[universe]
if !ok {
return nil
}
key, err := cryptoutil.ParseASN1RSAPublicKey(bytes)
if err != nil {
panic(err)
}
return key
}

43
vendor/github.com/Philipp15b/go-steam/netutil/addr.go generated vendored Normal file
View File

@ -0,0 +1,43 @@
package netutil
import (
"net"
"strconv"
"strings"
)
// An addr that is neither restricted to TCP nor UDP, but has an IP and a port.
type PortAddr struct {
IP net.IP
Port uint16
}
// Parses an IP address with a port, for example "209.197.29.196:27017".
// If the given string is not valid, this function returns nil.
func ParsePortAddr(addr string) *PortAddr {
parts := strings.Split(addr, ":")
if len(parts) != 2 {
return nil
}
ip := net.ParseIP(parts[0])
if ip == nil {
return nil
}
port, err := strconv.ParseUint(parts[1], 10, 16)
if err != nil {
return nil
}
return &PortAddr{ip, uint16(port)}
}
func (p *PortAddr) ToTCPAddr() *net.TCPAddr {
return &net.TCPAddr{p.IP, int(p.Port), ""}
}
func (p *PortAddr) ToUDPAddr() *net.UDPAddr {
return &net.UDPAddr{p.IP, int(p.Port), ""}
}
func (p *PortAddr) String() string {
return p.IP.String() + ":" + strconv.FormatUint(uint64(p.Port), 10)
}

17
vendor/github.com/Philipp15b/go-steam/netutil/http.go generated vendored Normal file
View File

@ -0,0 +1,17 @@
package netutil
import (
"net/http"
"net/url"
"strings"
)
// Version of http.Client.PostForm that returns a new request instead of executing it directly.
func NewPostForm(url string, data url.Values) *http.Request {
req, err := http.NewRequest("POST", url, strings.NewReader(data.Encode()))
if err != nil {
panic(err)
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
return req
}

13
vendor/github.com/Philipp15b/go-steam/netutil/url.go generated vendored Normal file
View File

@ -0,0 +1,13 @@
package netutil
import (
"net/url"
)
func ToUrlValues(m map[string]string) url.Values {
r := make(url.Values)
for k, v := range m {
r.Add(k, v)
}
return r
}

62
vendor/github.com/Philipp15b/go-steam/notifications.go generated vendored Normal file
View File

@ -0,0 +1,62 @@
package steam
import (
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
)
type Notifications struct {
// Maps notification types to their count. If a type is not present in the map,
// its count is zero.
notifications map[NotificationType]uint
client *Client
}
func newNotifications(client *Client) *Notifications {
return &Notifications{
make(map[NotificationType]uint),
client,
}
}
func (n *Notifications) HandlePacket(packet *Packet) {
switch packet.EMsg {
case EMsg_ClientUserNotifications:
n.handleClientUserNotifications(packet)
}
}
type NotificationType uint
const (
TradeOffer NotificationType = 1
)
func (n *Notifications) handleClientUserNotifications(packet *Packet) {
msg := new(CMsgClientUserNotifications)
packet.ReadProtoMsg(msg)
for _, notification := range msg.GetNotifications() {
typ := NotificationType(*notification.UserNotificationType)
count := uint(*notification.Count)
n.notifications[typ] = count
n.client.Emit(&NotificationEvent{typ, count})
}
// check if there is a notification in our map that isn't in the current packet
for typ, _ := range n.notifications {
exists := false
for _, t := range msg.GetNotifications() {
if NotificationType(*t.UserNotificationType) == typ {
exists = true
break
}
}
if !exists {
delete(n.notifications, typ)
n.client.Emit(&NotificationEvent{typ, 0})
}
}
}

View File

@ -0,0 +1,9 @@
package steam
// This event is emitted for every CMsgClientUserNotifications message and likewise only used for
// trade offers. Unlike the the above it is also emitted when the count of a type that was tracked
// before by this Notifications instance reaches zero.
type NotificationEvent struct {
Type NotificationType
Count uint
}

18
vendor/github.com/Philipp15b/go-steam/protocol/doc.go generated vendored Normal file
View File

@ -0,0 +1,18 @@
/*
This package includes some basics for the Steam protocol. It defines basic interfaces that are used throughout go-steam:
There is IMsg, which is extended by IClientMsg (sent after logging in) and abstracts over
the outgoing message types. Both interfaces are implemented by ClientMsgProtobuf and ClientMsg.
Msg is like ClientMsg, but it is used for sending messages before logging in.
There is also the concept of a Packet: This is a type for incoming messages where only
the header is deserialized. It therefore only contains EMsg data, job information and the remaining data.
Its contents can then be read via the Read* methods which read data into a MessageBody - a type which is Serializable and
has an EMsg.
In addition, there are extra types for communication with the Game Coordinator (GC) included in the gamecoordinator sub-package.
For outgoing messages the IGCMsg interface is used which is implemented by GCMsgProtobuf and GCMsg.
Incoming messages are of the GCPacket type and are read like regular Packets.
The actual messages and enums are in the sub-packages steamlang and protobuf, generated from the SteamKit data.
*/
package protocol

View File

@ -0,0 +1,132 @@
package gamecoordinator
import (
"io"
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
"github.com/golang/protobuf/proto"
)
// An outgoing message to the Game Coordinator.
type IGCMsg interface {
Serializer
IsProto() bool
GetAppId() uint32
GetMsgType() uint32
GetTargetJobId() JobId
SetTargetJobId(JobId)
GetSourceJobId() JobId
SetSourceJobId(JobId)
}
type GCMsgProtobuf struct {
AppId uint32
Header *MsgGCHdrProtoBuf
Body proto.Message
}
func NewGCMsgProtobuf(appId, msgType uint32, body proto.Message) *GCMsgProtobuf {
hdr := NewMsgGCHdrProtoBuf()
hdr.Msg = msgType
return &GCMsgProtobuf{
AppId: appId,
Header: hdr,
Body: body,
}
}
func (g *GCMsgProtobuf) IsProto() bool {
return true
}
func (g *GCMsgProtobuf) GetAppId() uint32 {
return g.AppId
}
func (g *GCMsgProtobuf) GetMsgType() uint32 {
return g.Header.Msg
}
func (g *GCMsgProtobuf) GetTargetJobId() JobId {
return JobId(g.Header.Proto.GetJobidTarget())
}
func (g *GCMsgProtobuf) SetTargetJobId(job JobId) {
g.Header.Proto.JobidTarget = proto.Uint64(uint64(job))
}
func (g *GCMsgProtobuf) GetSourceJobId() JobId {
return JobId(g.Header.Proto.GetJobidSource())
}
func (g *GCMsgProtobuf) SetSourceJobId(job JobId) {
g.Header.Proto.JobidSource = proto.Uint64(uint64(job))
}
func (g *GCMsgProtobuf) Serialize(w io.Writer) error {
err := g.Header.Serialize(w)
if err != nil {
return err
}
body, err := proto.Marshal(g.Body)
if err != nil {
return err
}
_, err = w.Write(body)
return err
}
type GCMsg struct {
AppId uint32
MsgType uint32
Header *MsgGCHdr
Body Serializer
}
func NewGCMsg(appId, msgType uint32, body Serializer) *GCMsg {
return &GCMsg{
AppId: appId,
MsgType: msgType,
Header: NewMsgGCHdr(),
Body: body,
}
}
func (g *GCMsg) GetMsgType() uint32 {
return g.MsgType
}
func (g *GCMsg) GetAppId() uint32 {
return g.AppId
}
func (g *GCMsg) IsProto() bool {
return false
}
func (g *GCMsg) GetTargetJobId() JobId {
return JobId(g.Header.TargetJobID)
}
func (g *GCMsg) SetTargetJobId(job JobId) {
g.Header.TargetJobID = uint64(job)
}
func (g *GCMsg) GetSourceJobId() JobId {
return JobId(g.Header.SourceJobID)
}
func (g *GCMsg) SetSourceJobId(job JobId) {
g.Header.SourceJobID = uint64(job)
}
func (g *GCMsg) Serialize(w io.Writer) error {
err := g.Header.Serialize(w)
if err != nil {
return err
}
err = g.Body.Serialize(w)
return err
}

View File

@ -0,0 +1,61 @@
package gamecoordinator
import (
"bytes"
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
"github.com/golang/protobuf/proto"
)
// An incoming, partially unread message from the Game Coordinator.
type GCPacket struct {
AppId uint32
MsgType uint32
IsProto bool
GCName string
Body []byte
TargetJobId JobId
}
func NewGCPacket(wrapper *CMsgGCClient) (*GCPacket, error) {
packet := &GCPacket{
AppId: wrapper.GetAppid(),
MsgType: wrapper.GetMsgtype(),
GCName: wrapper.GetGcname(),
}
r := bytes.NewReader(wrapper.GetPayload())
if IsProto(wrapper.GetMsgtype()) {
packet.MsgType = packet.MsgType & EMsgMask
packet.IsProto = true
header := NewMsgGCHdrProtoBuf()
err := header.Deserialize(r)
if err != nil {
return nil, err
}
packet.TargetJobId = JobId(header.Proto.GetJobidTarget())
} else {
header := NewMsgGCHdr()
err := header.Deserialize(r)
if err != nil {
return nil, err
}
packet.TargetJobId = JobId(header.TargetJobID)
}
body := make([]byte, r.Len())
r.Read(body)
packet.Body = body
return packet, nil
}
func (g *GCPacket) ReadProtoMsg(body proto.Message) {
proto.Unmarshal(g.Body, body)
}
func (g *GCPacket) ReadMsg(body MessageBody) {
body.Deserialize(bytes.NewReader(g.Body))
}

View File

@ -0,0 +1,47 @@
package protocol
import (
"io"
"math"
"strconv"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
)
type JobId uint64
func (j JobId) String() string {
if j == math.MaxUint64 {
return "(none)"
}
return strconv.FormatUint(uint64(j), 10)
}
type Serializer interface {
Serialize(w io.Writer) error
}
type Deserializer interface {
Deserialize(r io.Reader) error
}
type Serializable interface {
Serializer
Deserializer
}
type MessageBody interface {
Serializable
GetEMsg() EMsg
}
// the default details to request in most situations
const EClientPersonaStateFlag_DefaultInfoRequest = EClientPersonaStateFlag_PlayerName |
EClientPersonaStateFlag_Presence | EClientPersonaStateFlag_SourceID |
EClientPersonaStateFlag_GameExtraInfo
const DefaultAvatar = "fef49e7fa7e1997310d705b2a6158ff8dc1cdfeb"
func ValidAvatar(avatar string) bool {
return !(avatar == "0000000000000000000000000000000000000000" || len(avatar) != 40)
}

221
vendor/github.com/Philipp15b/go-steam/protocol/msg.go generated vendored Normal file
View File

@ -0,0 +1,221 @@
package protocol
import (
"github.com/golang/protobuf/proto"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
"io"
)
// Interface for all messages, typically outgoing. They can also be created by
// using the Read* methods in a PacketMsg.
type IMsg interface {
Serializer
IsProto() bool
GetMsgType() EMsg
GetTargetJobId() JobId
SetTargetJobId(JobId)
GetSourceJobId() JobId
SetSourceJobId(JobId)
}
// Interface for client messages, i.e. messages that are sent after logging in.
// ClientMsgProtobuf and ClientMsg implement this.
type IClientMsg interface {
IMsg
GetSessionId() int32
SetSessionId(int32)
GetSteamId() SteamId
SetSteamId(SteamId)
}
// Represents a protobuf backed client message with session data.
type ClientMsgProtobuf struct {
Header *MsgHdrProtoBuf
Body proto.Message
}
func NewClientMsgProtobuf(eMsg EMsg, body proto.Message) *ClientMsgProtobuf {
hdr := NewMsgHdrProtoBuf()
hdr.Msg = eMsg
return &ClientMsgProtobuf{
Header: hdr,
Body: body,
}
}
func (c *ClientMsgProtobuf) IsProto() bool {
return true
}
func (c *ClientMsgProtobuf) GetMsgType() EMsg {
return NewEMsg(uint32(c.Header.Msg))
}
func (c *ClientMsgProtobuf) GetSessionId() int32 {
return c.Header.Proto.GetClientSessionid()
}
func (c *ClientMsgProtobuf) SetSessionId(session int32) {
c.Header.Proto.ClientSessionid = &session
}
func (c *ClientMsgProtobuf) GetSteamId() SteamId {
return SteamId(c.Header.Proto.GetSteamid())
}
func (c *ClientMsgProtobuf) SetSteamId(s SteamId) {
c.Header.Proto.Steamid = proto.Uint64(uint64(s))
}
func (c *ClientMsgProtobuf) GetTargetJobId() JobId {
return JobId(c.Header.Proto.GetJobidTarget())
}
func (c *ClientMsgProtobuf) SetTargetJobId(job JobId) {
c.Header.Proto.JobidTarget = proto.Uint64(uint64(job))
}
func (c *ClientMsgProtobuf) GetSourceJobId() JobId {
return JobId(c.Header.Proto.GetJobidSource())
}
func (c *ClientMsgProtobuf) SetSourceJobId(job JobId) {
c.Header.Proto.JobidSource = proto.Uint64(uint64(job))
}
func (c *ClientMsgProtobuf) Serialize(w io.Writer) error {
err := c.Header.Serialize(w)
if err != nil {
return err
}
body, err := proto.Marshal(c.Body)
if err != nil {
return err
}
_, err = w.Write(body)
return err
}
// Represents a struct backed client message.
type ClientMsg struct {
Header *ExtendedClientMsgHdr
Body MessageBody
Payload []byte
}
func NewClientMsg(body MessageBody, payload []byte) *ClientMsg {
hdr := NewExtendedClientMsgHdr()
hdr.Msg = body.GetEMsg()
return &ClientMsg{
Header: hdr,
Body: body,
Payload: payload,
}
}
func (c *ClientMsg) IsProto() bool {
return true
}
func (c *ClientMsg) GetMsgType() EMsg {
return c.Header.Msg
}
func (c *ClientMsg) GetSessionId() int32 {
return c.Header.SessionID
}
func (c *ClientMsg) SetSessionId(session int32) {
c.Header.SessionID = session
}
func (c *ClientMsg) GetSteamId() SteamId {
return c.Header.SteamID
}
func (c *ClientMsg) SetSteamId(s SteamId) {
c.Header.SteamID = s
}
func (c *ClientMsg) GetTargetJobId() JobId {
return JobId(c.Header.TargetJobID)
}
func (c *ClientMsg) SetTargetJobId(job JobId) {
c.Header.TargetJobID = uint64(job)
}
func (c *ClientMsg) GetSourceJobId() JobId {
return JobId(c.Header.SourceJobID)
}
func (c *ClientMsg) SetSourceJobId(job JobId) {
c.Header.SourceJobID = uint64(job)
}
func (c *ClientMsg) Serialize(w io.Writer) error {
err := c.Header.Serialize(w)
if err != nil {
return err
}
err = c.Body.Serialize(w)
if err != nil {
return err
}
_, err = w.Write(c.Payload)
return err
}
type Msg struct {
Header *MsgHdr
Body MessageBody
Payload []byte
}
func NewMsg(body MessageBody, payload []byte) *Msg {
hdr := NewMsgHdr()
hdr.Msg = body.GetEMsg()
return &Msg{
Header: hdr,
Body: body,
Payload: payload,
}
}
func (m *Msg) GetMsgType() EMsg {
return m.Header.Msg
}
func (m *Msg) IsProto() bool {
return false
}
func (m *Msg) GetTargetJobId() JobId {
return JobId(m.Header.TargetJobID)
}
func (m *Msg) SetTargetJobId(job JobId) {
m.Header.TargetJobID = uint64(job)
}
func (m *Msg) GetSourceJobId() JobId {
return JobId(m.Header.SourceJobID)
}
func (m *Msg) SetSourceJobId(job JobId) {
m.Header.SourceJobID = uint64(job)
}
func (m *Msg) Serialize(w io.Writer) error {
err := m.Header.Serialize(w)
if err != nil {
return err
}
err = m.Body.Serialize(w)
if err != nil {
return err
}
_, err = w.Write(m.Payload)
return err
}

View File

@ -0,0 +1,116 @@
package protocol
import (
"bytes"
"github.com/golang/protobuf/proto"
"encoding/binary"
"fmt"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
)
// TODO: Headers are always deserialized twice.
// Represents an incoming, partially unread message.
type Packet struct {
EMsg EMsg
IsProto bool
TargetJobId JobId
SourceJobId JobId
Data []byte
}
func NewPacket(data []byte) (*Packet, error) {
var rawEMsg uint32
err := binary.Read(bytes.NewReader(data), binary.LittleEndian, &rawEMsg)
if err != nil {
return nil, err
}
eMsg := NewEMsg(rawEMsg)
buf := bytes.NewReader(data)
if eMsg == EMsg_ChannelEncryptRequest || eMsg == EMsg_ChannelEncryptResult {
header := NewMsgHdr()
header.Msg = eMsg
err = header.Deserialize(buf)
if err != nil {
return nil, err
}
return &Packet{
EMsg: eMsg,
IsProto: false,
TargetJobId: JobId(header.TargetJobID),
SourceJobId: JobId(header.SourceJobID),
Data: data,
}, nil
} else if IsProto(rawEMsg) {
header := NewMsgHdrProtoBuf()
header.Msg = eMsg
err = header.Deserialize(buf)
if err != nil {
return nil, err
}
return &Packet{
EMsg: eMsg,
IsProto: true,
TargetJobId: JobId(header.Proto.GetJobidTarget()),
SourceJobId: JobId(header.Proto.GetJobidSource()),
Data: data,
}, nil
} else {
header := NewExtendedClientMsgHdr()
header.Msg = eMsg
err = header.Deserialize(buf)
if err != nil {
return nil, err
}
return &Packet{
EMsg: eMsg,
IsProto: false,
TargetJobId: JobId(header.TargetJobID),
SourceJobId: JobId(header.SourceJobID),
Data: data,
}, nil
}
}
func (p *Packet) String() string {
return fmt.Sprintf("Packet{EMsg = %v, Proto = %v, Len = %v, TargetJobId = %v, SourceJobId = %v}", p.EMsg, p.IsProto, len(p.Data), p.TargetJobId, p.SourceJobId)
}
func (p *Packet) ReadProtoMsg(body proto.Message) *ClientMsgProtobuf {
header := NewMsgHdrProtoBuf()
buf := bytes.NewBuffer(p.Data)
header.Deserialize(buf)
proto.Unmarshal(buf.Bytes(), body)
return &ClientMsgProtobuf{ // protobuf messages have no payload
Header: header,
Body: body,
}
}
func (p *Packet) ReadClientMsg(body MessageBody) *ClientMsg {
header := NewExtendedClientMsgHdr()
buf := bytes.NewReader(p.Data)
header.Deserialize(buf)
body.Deserialize(buf)
payload := make([]byte, buf.Len())
buf.Read(payload)
return &ClientMsg{
Header: header,
Body: body,
Payload: payload,
}
}
func (p *Packet) ReadMsg(body MessageBody) *Msg {
header := NewMsgHdr()
buf := bytes.NewReader(p.Data)
header.Deserialize(buf)
body.Deserialize(buf)
payload := make([]byte, buf.Len())
buf.Read(payload)
return &Msg{
Header: header,
Body: body,
Payload: payload,
}
}

View File

@ -0,0 +1,82 @@
// Code generated by protoc-gen-go.
// source: encrypted_app_ticket.proto
// DO NOT EDIT!
package protobuf
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type EncryptedAppTicket struct {
TicketVersionNo *uint32 `protobuf:"varint,1,opt,name=ticket_version_no" json:"ticket_version_no,omitempty"`
CrcEncryptedticket *uint32 `protobuf:"varint,2,opt,name=crc_encryptedticket" json:"crc_encryptedticket,omitempty"`
CbEncrypteduserdata *uint32 `protobuf:"varint,3,opt,name=cb_encrypteduserdata" json:"cb_encrypteduserdata,omitempty"`
CbEncryptedAppownershipticket *uint32 `protobuf:"varint,4,opt,name=cb_encrypted_appownershipticket" json:"cb_encrypted_appownershipticket,omitempty"`
EncryptedTicket []byte `protobuf:"bytes,5,opt,name=encrypted_ticket" json:"encrypted_ticket,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *EncryptedAppTicket) Reset() { *m = EncryptedAppTicket{} }
func (m *EncryptedAppTicket) String() string { return proto.CompactTextString(m) }
func (*EncryptedAppTicket) ProtoMessage() {}
func (*EncryptedAppTicket) Descriptor() ([]byte, []int) { return app_ticket_fileDescriptor0, []int{0} }
func (m *EncryptedAppTicket) GetTicketVersionNo() uint32 {
if m != nil && m.TicketVersionNo != nil {
return *m.TicketVersionNo
}
return 0
}
func (m *EncryptedAppTicket) GetCrcEncryptedticket() uint32 {
if m != nil && m.CrcEncryptedticket != nil {
return *m.CrcEncryptedticket
}
return 0
}
func (m *EncryptedAppTicket) GetCbEncrypteduserdata() uint32 {
if m != nil && m.CbEncrypteduserdata != nil {
return *m.CbEncrypteduserdata
}
return 0
}
func (m *EncryptedAppTicket) GetCbEncryptedAppownershipticket() uint32 {
if m != nil && m.CbEncryptedAppownershipticket != nil {
return *m.CbEncryptedAppownershipticket
}
return 0
}
func (m *EncryptedAppTicket) GetEncryptedTicket() []byte {
if m != nil {
return m.EncryptedTicket
}
return nil
}
func init() {
proto.RegisterType((*EncryptedAppTicket)(nil), "EncryptedAppTicket")
}
var app_ticket_fileDescriptor0 = []byte{
// 162 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0xcd, 0x4b, 0x2e,
0xaa, 0x2c, 0x28, 0x49, 0x4d, 0x89, 0x4f, 0x2c, 0x28, 0x88, 0x2f, 0xc9, 0x4c, 0xce, 0x4e, 0x2d,
0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x5a, 0xcb, 0xc8, 0x25, 0xe4, 0x0a, 0x93, 0x76, 0x2c,
0x28, 0x08, 0x01, 0x4b, 0x0a, 0x49, 0x72, 0x09, 0x42, 0x94, 0xc5, 0x97, 0xa5, 0x16, 0x15, 0x67,
0xe6, 0xe7, 0xc5, 0xe7, 0xe5, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x0a, 0x49, 0x73, 0x09, 0x27,
0x17, 0x25, 0xc7, 0xc3, 0xcd, 0x84, 0xa8, 0x93, 0x60, 0x02, 0x4b, 0xca, 0x70, 0x89, 0x24, 0x27,
0x21, 0xe4, 0x4a, 0x8b, 0x53, 0x8b, 0x52, 0x12, 0x4b, 0x12, 0x25, 0x98, 0xc1, 0xb2, 0xea, 0x5c,
0xf2, 0xc8, 0xb2, 0x20, 0xd7, 0xe4, 0x97, 0xe7, 0x01, 0x2d, 0xc8, 0xc8, 0x2c, 0x80, 0x1a, 0xc3,
0x02, 0x56, 0x28, 0xc1, 0x25, 0x80, 0x50, 0x05, 0x95, 0x61, 0x05, 0xca, 0xf0, 0x38, 0xb1, 0x7a,
0x30, 0x36, 0x30, 0x32, 0x00, 0x02, 0x00, 0x00, 0xff, 0xff, 0x03, 0x8c, 0xdb, 0x92, 0xd3, 0x00,
0x00, 0x00,
}

View File

@ -0,0 +1,613 @@
// Code generated by protoc-gen-go.
// source: steammessages_base.proto
// DO NOT EDIT!
package protobuf
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type CMsgProtoBufHeader struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
ClientSessionid *int32 `protobuf:"varint,2,opt,name=client_sessionid" json:"client_sessionid,omitempty"`
RoutingAppid *uint32 `protobuf:"varint,3,opt,name=routing_appid" json:"routing_appid,omitempty"`
JobidSource *uint64 `protobuf:"fixed64,10,opt,name=jobid_source,def=18446744073709551615" json:"jobid_source,omitempty"`
JobidTarget *uint64 `protobuf:"fixed64,11,opt,name=jobid_target,def=18446744073709551615" json:"jobid_target,omitempty"`
TargetJobName *string `protobuf:"bytes,12,opt,name=target_job_name" json:"target_job_name,omitempty"`
SeqNum *int32 `protobuf:"varint,24,opt,name=seq_num" json:"seq_num,omitempty"`
Eresult *int32 `protobuf:"varint,13,opt,name=eresult,def=2" json:"eresult,omitempty"`
ErrorMessage *string `protobuf:"bytes,14,opt,name=error_message" json:"error_message,omitempty"`
Ip *uint32 `protobuf:"varint,15,opt,name=ip" json:"ip,omitempty"`
AuthAccountFlags *uint32 `protobuf:"varint,16,opt,name=auth_account_flags" json:"auth_account_flags,omitempty"`
TokenSource *uint32 `protobuf:"varint,22,opt,name=token_source" json:"token_source,omitempty"`
AdminSpoofingUser *bool `protobuf:"varint,23,opt,name=admin_spoofing_user" json:"admin_spoofing_user,omitempty"`
TransportError *int32 `protobuf:"varint,17,opt,name=transport_error,def=1" json:"transport_error,omitempty"`
Messageid *uint64 `protobuf:"varint,18,opt,name=messageid,def=18446744073709551615" json:"messageid,omitempty"`
PublisherGroupId *uint32 `protobuf:"varint,19,opt,name=publisher_group_id" json:"publisher_group_id,omitempty"`
Sysid *uint32 `protobuf:"varint,20,opt,name=sysid" json:"sysid,omitempty"`
TraceTag *uint64 `protobuf:"varint,21,opt,name=trace_tag" json:"trace_tag,omitempty"`
WebapiKeyId *uint32 `protobuf:"varint,25,opt,name=webapi_key_id" json:"webapi_key_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CMsgProtoBufHeader) Reset() { *m = CMsgProtoBufHeader{} }
func (m *CMsgProtoBufHeader) String() string { return proto.CompactTextString(m) }
func (*CMsgProtoBufHeader) ProtoMessage() {}
func (*CMsgProtoBufHeader) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} }
const Default_CMsgProtoBufHeader_JobidSource uint64 = 18446744073709551615
const Default_CMsgProtoBufHeader_JobidTarget uint64 = 18446744073709551615
const Default_CMsgProtoBufHeader_Eresult int32 = 2
const Default_CMsgProtoBufHeader_TransportError int32 = 1
const Default_CMsgProtoBufHeader_Messageid uint64 = 18446744073709551615
func (m *CMsgProtoBufHeader) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CMsgProtoBufHeader) GetClientSessionid() int32 {
if m != nil && m.ClientSessionid != nil {
return *m.ClientSessionid
}
return 0
}
func (m *CMsgProtoBufHeader) GetRoutingAppid() uint32 {
if m != nil && m.RoutingAppid != nil {
return *m.RoutingAppid
}
return 0
}
func (m *CMsgProtoBufHeader) GetJobidSource() uint64 {
if m != nil && m.JobidSource != nil {
return *m.JobidSource
}
return Default_CMsgProtoBufHeader_JobidSource
}
func (m *CMsgProtoBufHeader) GetJobidTarget() uint64 {
if m != nil && m.JobidTarget != nil {
return *m.JobidTarget
}
return Default_CMsgProtoBufHeader_JobidTarget
}
func (m *CMsgProtoBufHeader) GetTargetJobName() string {
if m != nil && m.TargetJobName != nil {
return *m.TargetJobName
}
return ""
}
func (m *CMsgProtoBufHeader) GetSeqNum() int32 {
if m != nil && m.SeqNum != nil {
return *m.SeqNum
}
return 0
}
func (m *CMsgProtoBufHeader) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgProtoBufHeader_Eresult
}
func (m *CMsgProtoBufHeader) GetErrorMessage() string {
if m != nil && m.ErrorMessage != nil {
return *m.ErrorMessage
}
return ""
}
func (m *CMsgProtoBufHeader) GetIp() uint32 {
if m != nil && m.Ip != nil {
return *m.Ip
}
return 0
}
func (m *CMsgProtoBufHeader) GetAuthAccountFlags() uint32 {
if m != nil && m.AuthAccountFlags != nil {
return *m.AuthAccountFlags
}
return 0
}
func (m *CMsgProtoBufHeader) GetTokenSource() uint32 {
if m != nil && m.TokenSource != nil {
return *m.TokenSource
}
return 0
}
func (m *CMsgProtoBufHeader) GetAdminSpoofingUser() bool {
if m != nil && m.AdminSpoofingUser != nil {
return *m.AdminSpoofingUser
}
return false
}
func (m *CMsgProtoBufHeader) GetTransportError() int32 {
if m != nil && m.TransportError != nil {
return *m.TransportError
}
return Default_CMsgProtoBufHeader_TransportError
}
func (m *CMsgProtoBufHeader) GetMessageid() uint64 {
if m != nil && m.Messageid != nil {
return *m.Messageid
}
return Default_CMsgProtoBufHeader_Messageid
}
func (m *CMsgProtoBufHeader) GetPublisherGroupId() uint32 {
if m != nil && m.PublisherGroupId != nil {
return *m.PublisherGroupId
}
return 0
}
func (m *CMsgProtoBufHeader) GetSysid() uint32 {
if m != nil && m.Sysid != nil {
return *m.Sysid
}
return 0
}
func (m *CMsgProtoBufHeader) GetTraceTag() uint64 {
if m != nil && m.TraceTag != nil {
return *m.TraceTag
}
return 0
}
func (m *CMsgProtoBufHeader) GetWebapiKeyId() uint32 {
if m != nil && m.WebapiKeyId != nil {
return *m.WebapiKeyId
}
return 0
}
type CMsgMulti struct {
SizeUnzipped *uint32 `protobuf:"varint,1,opt,name=size_unzipped" json:"size_unzipped,omitempty"`
MessageBody []byte `protobuf:"bytes,2,opt,name=message_body" json:"message_body,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CMsgMulti) Reset() { *m = CMsgMulti{} }
func (m *CMsgMulti) String() string { return proto.CompactTextString(m) }
func (*CMsgMulti) ProtoMessage() {}
func (*CMsgMulti) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{1} }
func (m *CMsgMulti) GetSizeUnzipped() uint32 {
if m != nil && m.SizeUnzipped != nil {
return *m.SizeUnzipped
}
return 0
}
func (m *CMsgMulti) GetMessageBody() []byte {
if m != nil {
return m.MessageBody
}
return nil
}
type CMsgProtobufWrapped struct {
MessageBody []byte `protobuf:"bytes,1,opt,name=message_body" json:"message_body,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CMsgProtobufWrapped) Reset() { *m = CMsgProtobufWrapped{} }
func (m *CMsgProtobufWrapped) String() string { return proto.CompactTextString(m) }
func (*CMsgProtobufWrapped) ProtoMessage() {}
func (*CMsgProtobufWrapped) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{2} }
func (m *CMsgProtobufWrapped) GetMessageBody() []byte {
if m != nil {
return m.MessageBody
}
return nil
}
type CMsgAuthTicket struct {
Estate *uint32 `protobuf:"varint,1,opt,name=estate" json:"estate,omitempty"`
Eresult *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"`
Steamid *uint64 `protobuf:"fixed64,3,opt,name=steamid" json:"steamid,omitempty"`
Gameid *uint64 `protobuf:"fixed64,4,opt,name=gameid" json:"gameid,omitempty"`
HSteamPipe *uint32 `protobuf:"varint,5,opt,name=h_steam_pipe" json:"h_steam_pipe,omitempty"`
TicketCrc *uint32 `protobuf:"varint,6,opt,name=ticket_crc" json:"ticket_crc,omitempty"`
Ticket []byte `protobuf:"bytes,7,opt,name=ticket" json:"ticket,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CMsgAuthTicket) Reset() { *m = CMsgAuthTicket{} }
func (m *CMsgAuthTicket) String() string { return proto.CompactTextString(m) }
func (*CMsgAuthTicket) ProtoMessage() {}
func (*CMsgAuthTicket) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{3} }
const Default_CMsgAuthTicket_Eresult uint32 = 2
func (m *CMsgAuthTicket) GetEstate() uint32 {
if m != nil && m.Estate != nil {
return *m.Estate
}
return 0
}
func (m *CMsgAuthTicket) GetEresult() uint32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgAuthTicket_Eresult
}
func (m *CMsgAuthTicket) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CMsgAuthTicket) GetGameid() uint64 {
if m != nil && m.Gameid != nil {
return *m.Gameid
}
return 0
}
func (m *CMsgAuthTicket) GetHSteamPipe() uint32 {
if m != nil && m.HSteamPipe != nil {
return *m.HSteamPipe
}
return 0
}
func (m *CMsgAuthTicket) GetTicketCrc() uint32 {
if m != nil && m.TicketCrc != nil {
return *m.TicketCrc
}
return 0
}
func (m *CMsgAuthTicket) GetTicket() []byte {
if m != nil {
return m.Ticket
}
return nil
}
type CCDDBAppDetailCommon struct {
Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
Icon *string `protobuf:"bytes,3,opt,name=icon" json:"icon,omitempty"`
Logo *string `protobuf:"bytes,4,opt,name=logo" json:"logo,omitempty"`
LogoSmall *string `protobuf:"bytes,5,opt,name=logo_small" json:"logo_small,omitempty"`
Tool *bool `protobuf:"varint,6,opt,name=tool" json:"tool,omitempty"`
Demo *bool `protobuf:"varint,7,opt,name=demo" json:"demo,omitempty"`
Media *bool `protobuf:"varint,8,opt,name=media" json:"media,omitempty"`
CommunityVisibleStats *bool `protobuf:"varint,9,opt,name=community_visible_stats" json:"community_visible_stats,omitempty"`
FriendlyName *string `protobuf:"bytes,10,opt,name=friendly_name" json:"friendly_name,omitempty"`
Propagation *string `protobuf:"bytes,11,opt,name=propagation" json:"propagation,omitempty"`
HasAdultContent *bool `protobuf:"varint,12,opt,name=has_adult_content" json:"has_adult_content,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCDDBAppDetailCommon) Reset() { *m = CCDDBAppDetailCommon{} }
func (m *CCDDBAppDetailCommon) String() string { return proto.CompactTextString(m) }
func (*CCDDBAppDetailCommon) ProtoMessage() {}
func (*CCDDBAppDetailCommon) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{4} }
func (m *CCDDBAppDetailCommon) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CCDDBAppDetailCommon) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CCDDBAppDetailCommon) GetIcon() string {
if m != nil && m.Icon != nil {
return *m.Icon
}
return ""
}
func (m *CCDDBAppDetailCommon) GetLogo() string {
if m != nil && m.Logo != nil {
return *m.Logo
}
return ""
}
func (m *CCDDBAppDetailCommon) GetLogoSmall() string {
if m != nil && m.LogoSmall != nil {
return *m.LogoSmall
}
return ""
}
func (m *CCDDBAppDetailCommon) GetTool() bool {
if m != nil && m.Tool != nil {
return *m.Tool
}
return false
}
func (m *CCDDBAppDetailCommon) GetDemo() bool {
if m != nil && m.Demo != nil {
return *m.Demo
}
return false
}
func (m *CCDDBAppDetailCommon) GetMedia() bool {
if m != nil && m.Media != nil {
return *m.Media
}
return false
}
func (m *CCDDBAppDetailCommon) GetCommunityVisibleStats() bool {
if m != nil && m.CommunityVisibleStats != nil {
return *m.CommunityVisibleStats
}
return false
}
func (m *CCDDBAppDetailCommon) GetFriendlyName() string {
if m != nil && m.FriendlyName != nil {
return *m.FriendlyName
}
return ""
}
func (m *CCDDBAppDetailCommon) GetPropagation() string {
if m != nil && m.Propagation != nil {
return *m.Propagation
}
return ""
}
func (m *CCDDBAppDetailCommon) GetHasAdultContent() bool {
if m != nil && m.HasAdultContent != nil {
return *m.HasAdultContent
}
return false
}
type CMsgAppRights struct {
EditInfo *bool `protobuf:"varint,1,opt,name=edit_info" json:"edit_info,omitempty"`
Publish *bool `protobuf:"varint,2,opt,name=publish" json:"publish,omitempty"`
ViewErrorData *bool `protobuf:"varint,3,opt,name=view_error_data" json:"view_error_data,omitempty"`
Download *bool `protobuf:"varint,4,opt,name=download" json:"download,omitempty"`
UploadCdkeys *bool `protobuf:"varint,5,opt,name=upload_cdkeys" json:"upload_cdkeys,omitempty"`
GenerateCdkeys *bool `protobuf:"varint,6,opt,name=generate_cdkeys" json:"generate_cdkeys,omitempty"`
ViewFinancials *bool `protobuf:"varint,7,opt,name=view_financials" json:"view_financials,omitempty"`
ManageCeg *bool `protobuf:"varint,8,opt,name=manage_ceg" json:"manage_ceg,omitempty"`
ManageSigning *bool `protobuf:"varint,9,opt,name=manage_signing" json:"manage_signing,omitempty"`
ManageCdkeys *bool `protobuf:"varint,10,opt,name=manage_cdkeys" json:"manage_cdkeys,omitempty"`
EditMarketing *bool `protobuf:"varint,11,opt,name=edit_marketing" json:"edit_marketing,omitempty"`
EconomySupport *bool `protobuf:"varint,12,opt,name=economy_support" json:"economy_support,omitempty"`
EconomySupportSupervisor *bool `protobuf:"varint,13,opt,name=economy_support_supervisor" json:"economy_support_supervisor,omitempty"`
ManagePricing *bool `protobuf:"varint,14,opt,name=manage_pricing" json:"manage_pricing,omitempty"`
BroadcastLive *bool `protobuf:"varint,15,opt,name=broadcast_live" json:"broadcast_live,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CMsgAppRights) Reset() { *m = CMsgAppRights{} }
func (m *CMsgAppRights) String() string { return proto.CompactTextString(m) }
func (*CMsgAppRights) ProtoMessage() {}
func (*CMsgAppRights) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{5} }
func (m *CMsgAppRights) GetEditInfo() bool {
if m != nil && m.EditInfo != nil {
return *m.EditInfo
}
return false
}
func (m *CMsgAppRights) GetPublish() bool {
if m != nil && m.Publish != nil {
return *m.Publish
}
return false
}
func (m *CMsgAppRights) GetViewErrorData() bool {
if m != nil && m.ViewErrorData != nil {
return *m.ViewErrorData
}
return false
}
func (m *CMsgAppRights) GetDownload() bool {
if m != nil && m.Download != nil {
return *m.Download
}
return false
}
func (m *CMsgAppRights) GetUploadCdkeys() bool {
if m != nil && m.UploadCdkeys != nil {
return *m.UploadCdkeys
}
return false
}
func (m *CMsgAppRights) GetGenerateCdkeys() bool {
if m != nil && m.GenerateCdkeys != nil {
return *m.GenerateCdkeys
}
return false
}
func (m *CMsgAppRights) GetViewFinancials() bool {
if m != nil && m.ViewFinancials != nil {
return *m.ViewFinancials
}
return false
}
func (m *CMsgAppRights) GetManageCeg() bool {
if m != nil && m.ManageCeg != nil {
return *m.ManageCeg
}
return false
}
func (m *CMsgAppRights) GetManageSigning() bool {
if m != nil && m.ManageSigning != nil {
return *m.ManageSigning
}
return false
}
func (m *CMsgAppRights) GetManageCdkeys() bool {
if m != nil && m.ManageCdkeys != nil {
return *m.ManageCdkeys
}
return false
}
func (m *CMsgAppRights) GetEditMarketing() bool {
if m != nil && m.EditMarketing != nil {
return *m.EditMarketing
}
return false
}
func (m *CMsgAppRights) GetEconomySupport() bool {
if m != nil && m.EconomySupport != nil {
return *m.EconomySupport
}
return false
}
func (m *CMsgAppRights) GetEconomySupportSupervisor() bool {
if m != nil && m.EconomySupportSupervisor != nil {
return *m.EconomySupportSupervisor
}
return false
}
func (m *CMsgAppRights) GetManagePricing() bool {
if m != nil && m.ManagePricing != nil {
return *m.ManagePricing
}
return false
}
func (m *CMsgAppRights) GetBroadcastLive() bool {
if m != nil && m.BroadcastLive != nil {
return *m.BroadcastLive
}
return false
}
var E_MsgpoolSoftLimit = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 50000,
Name: "msgpool_soft_limit",
Tag: "varint,50000,opt,name=msgpool_soft_limit,def=32",
}
var E_MsgpoolHardLimit = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 50001,
Name: "msgpool_hard_limit",
Tag: "varint,50001,opt,name=msgpool_hard_limit,def=384",
}
func init() {
proto.RegisterType((*CMsgProtoBufHeader)(nil), "CMsgProtoBufHeader")
proto.RegisterType((*CMsgMulti)(nil), "CMsgMulti")
proto.RegisterType((*CMsgProtobufWrapped)(nil), "CMsgProtobufWrapped")
proto.RegisterType((*CMsgAuthTicket)(nil), "CMsgAuthTicket")
proto.RegisterType((*CCDDBAppDetailCommon)(nil), "CCDDBAppDetailCommon")
proto.RegisterType((*CMsgAppRights)(nil), "CMsgAppRights")
proto.RegisterExtension(E_MsgpoolSoftLimit)
proto.RegisterExtension(E_MsgpoolHardLimit)
}
var base_fileDescriptor0 = []byte{
// 906 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x6f, 0x1c, 0x45,
0x10, 0x65, 0x77, 0xfd, 0x31, 0xdb, 0xde, 0x5d, 0xdb, 0x63, 0x27, 0xee, 0x98, 0x43, 0xa2, 0xbd,
0x80, 0x40, 0x72, 0xe2, 0x78, 0x1d, 0x1b, 0xdf, 0xfc, 0x71, 0xc8, 0xc5, 0x02, 0x21, 0x24, 0x8e,
0xad, 0x9e, 0x99, 0xda, 0xd9, 0xc6, 0x33, 0xdd, 0x4d, 0x77, 0x8f, 0xad, 0xcd, 0x89, 0x13, 0x57,
0xfe, 0x1a, 0xfc, 0x12, 0x6e, 0x88, 0x23, 0xd5, 0x35, 0xb3, 0x38, 0x04, 0x81, 0x72, 0x1a, 0x55,
0xd5, 0xeb, 0xaa, 0x57, 0xaf, 0xaa, 0x86, 0x71, 0x1f, 0x40, 0xd6, 0x35, 0x78, 0x2f, 0x4b, 0xf0,
0x22, 0x93, 0x1e, 0x8e, 0xac, 0x33, 0xc1, 0x1c, 0xbe, 0x28, 0x8d, 0x29, 0x2b, 0x78, 0x49, 0x56,
0xd6, 0xcc, 0x5f, 0x16, 0xe0, 0x73, 0xa7, 0x6c, 0x30, 0xae, 0x45, 0x4c, 0xff, 0x1c, 0xb0, 0xf4,
0xfa, 0xd6, 0x97, 0xdf, 0x44, 0xeb, 0xaa, 0x99, 0xbf, 0x05, 0x59, 0x80, 0x4b, 0xb7, 0xd9, 0x26,
0x25, 0x55, 0x05, 0xef, 0xbd, 0xe8, 0x7d, 0xbe, 0x91, 0x72, 0xb6, 0x93, 0x57, 0x0a, 0x74, 0x10,
0x1e, 0xeb, 0x28, 0xa3, 0x31, 0xd2, 0xc7, 0xc8, 0x7a, 0xfa, 0x84, 0x8d, 0x9d, 0x69, 0x82, 0xd2,
0xa5, 0x90, 0xd6, 0xa2, 0x7b, 0x80, 0xee, 0x71, 0xfa, 0x05, 0x1b, 0xfd, 0x60, 0x32, 0x55, 0x08,
0x6f, 0x1a, 0x97, 0x03, 0x67, 0x31, 0xcd, 0xc5, 0xfe, 0xf1, 0xf9, 0x6c, 0xf6, 0xe6, 0x6c, 0x36,
0x7b, 0x75, 0x76, 0x72, 0xf6, 0xea, 0xab, 0xd3, 0xd3, 0xe3, 0x37, 0xc7, 0xa7, 0x8f, 0xd8, 0x20,
0x5d, 0x09, 0x81, 0x6f, 0xfd, 0x0f, 0xf6, 0x80, 0x6d, 0xb7, 0x28, 0x81, 0x4f, 0x84, 0x96, 0x35,
0xf0, 0x11, 0xc2, 0x87, 0x44, 0x19, 0x7e, 0x14, 0xba, 0xa9, 0x39, 0x27, 0x62, 0x29, 0xdb, 0x04,
0x07, 0xbe, 0xa9, 0x02, 0x1f, 0x47, 0xc7, 0x45, 0xef, 0x75, 0x24, 0x0b, 0xce, 0x19, 0x27, 0x3a,
0xb5, 0xf8, 0x84, 0xde, 0x32, 0xd6, 0x57, 0x96, 0x6f, 0x13, 0xf1, 0x43, 0x96, 0xca, 0x26, 0x2c,
0x84, 0xcc, 0x73, 0xd3, 0x60, 0xbf, 0xf3, 0x4a, 0x96, 0x9e, 0xef, 0x50, 0x6c, 0x9f, 0x8d, 0x82,
0xb9, 0x03, 0xbd, 0x6a, 0xea, 0x29, 0x79, 0x3f, 0x65, 0x7b, 0xb2, 0xa8, 0x15, 0x7a, 0xad, 0x31,
0xf3, 0x28, 0x44, 0xe3, 0xc1, 0xf1, 0x03, 0x0c, 0x26, 0x98, 0x6e, 0x3b, 0x38, 0xa9, 0x31, 0xe4,
0x82, 0xa0, 0xda, 0x7c, 0xb7, 0x65, 0x73, 0x9c, 0x7e, 0xc6, 0x86, 0x1d, 0x0f, 0x94, 0x2d, 0x45,
0xef, 0xda, 0x7f, 0x34, 0x8d, 0x9c, 0x6c, 0x93, 0x55, 0xca, 0x2f, 0xc0, 0x89, 0x12, 0xe5, 0xb6,
0x02, 0x5f, 0xec, 0x51, 0xf5, 0x31, 0x5b, 0xf7, 0x4b, 0x8f, 0xe6, 0x3e, 0x99, 0xbb, 0x6c, 0x88,
0xf5, 0x72, 0x40, 0x2d, 0x4b, 0xfe, 0x24, 0xe6, 0x8c, 0x4d, 0x3f, 0x40, 0x26, 0xad, 0x12, 0x77,
0xb0, 0x8c, 0x0f, 0x9f, 0x45, 0xe4, 0xf4, 0x9c, 0x0d, 0xe3, 0xe4, 0x6f, 0x51, 0x20, 0x15, 0x31,
0x5e, 0xbd, 0x03, 0xd1, 0xe8, 0x77, 0xca, 0x5a, 0x68, 0xc7, 0x4e, 0x0d, 0x77, 0x0c, 0x45, 0x66,
0x8a, 0x25, 0x8d, 0x7c, 0x34, 0xfd, 0x92, 0xed, 0xfd, 0xbd, 0x33, 0xb8, 0x55, 0xdf, 0x3b, 0x19,
0x9f, 0xfc, 0x0b, 0xdc, 0x23, 0xf0, 0x2f, 0x3d, 0x36, 0x89, 0xe8, 0x4b, 0x14, 0xf5, 0x3b, 0x95,
0xdf, 0x41, 0x48, 0x27, 0x6c, 0x03, 0x7c, 0x90, 0x01, 0xba, 0x2a, 0xef, 0x4d, 0x2a, 0x16, 0x18,
0xc7, 0x49, 0xbd, 0xb7, 0x81, 0x03, 0xda, 0x40, 0x7c, 0x54, 0xe2, 0xb4, 0xd1, 0x5e, 0x23, 0x1b,
0xab, 0x2d, 0x04, 0x41, 0x84, 0x55, 0x16, 0xf8, 0x7a, 0x97, 0x8a, 0x05, 0x2a, 0x22, 0x72, 0x97,
0xf3, 0x0d, 0xf2, 0xe1, 0xcb, 0xd6, 0xc7, 0x37, 0x89, 0xd1, 0x1f, 0x3d, 0xb6, 0x7f, 0x7d, 0x7d,
0x73, 0x73, 0x75, 0x69, 0xed, 0x0d, 0x04, 0xa9, 0xaa, 0x6b, 0x53, 0xd7, 0x46, 0x47, 0x29, 0xdb,
0x15, 0x6e, 0x69, 0x8d, 0xd8, 0x1a, 0xed, 0x57, 0x9f, 0x76, 0x04, 0x2d, 0x95, 0x1b, 0x4d, 0x6c,
0xc8, 0xaa, 0x4c, 0x69, 0x88, 0xcb, 0x30, 0x56, 0x8d, 0x96, 0xf0, 0xb5, 0xac, 0x2a, 0x62, 0x42,
0x88, 0x60, 0x4c, 0x45, 0x1c, 0x92, 0x68, 0x15, 0x50, 0x1b, 0x62, 0x90, 0xc4, 0x42, 0x35, 0x14,
0x4a, 0xf2, 0x84, 0xcc, 0xe7, 0xec, 0x20, 0x47, 0x06, 0x8d, 0x56, 0x61, 0x29, 0xee, 0x95, 0x57,
0x59, 0x05, 0x22, 0x0a, 0xe4, 0xf9, 0x90, 0x00, 0x38, 0x9d, 0xb9, 0xc3, 0xeb, 0x2b, 0xaa, 0x65,
0xbb, 0xf2, 0x8c, 0x4a, 0xec, 0xb1, 0x2d, 0xbc, 0x62, 0x2b, 0x4b, 0x19, 0xf0, 0x22, 0xe9, 0x6c,
0x86, 0xe9, 0x33, 0xb6, 0xbb, 0x90, 0x5e, 0xc8, 0x02, 0xe5, 0x14, 0x48, 0x38, 0xe0, 0xd1, 0xd2,
0x89, 0x24, 0xd3, 0xdf, 0xfb, 0x6c, 0x4c, 0xa3, 0xb0, 0xf6, 0x5b, 0x55, 0x2e, 0x82, 0x8f, 0xdb,
0x82, 0x3c, 0x82, 0x50, 0x7a, 0x6e, 0xa8, 0xeb, 0x24, 0x0a, 0xdf, 0xed, 0x1a, 0x35, 0x9e, 0xc4,
0x8b, 0xbb, 0x57, 0xf0, 0xd0, 0x2e, 0xaf, 0x28, 0x64, 0x90, 0xa4, 0x41, 0x92, 0xee, 0xb0, 0xa4,
0x30, 0x0f, 0xba, 0x32, 0xb2, 0x9d, 0x09, 0xf1, 0x6c, 0x6c, 0xb4, 0x45, 0x5e, 0xe0, 0xae, 0x79,
0x92, 0x82, 0x32, 0x94, 0xa0, 0xc1, 0xe1, 0xc4, 0x57, 0x81, 0x8d, 0x7f, 0xa4, 0xc6, 0xa3, 0x91,
0x3a, 0x57, 0xb2, 0xf2, 0x9d, 0x40, 0x28, 0x68, 0x2d, 0x75, 0xdc, 0xa4, 0x1c, 0xca, 0x4e, 0xa5,
0xa7, 0x6c, 0xd2, 0xf9, 0xbc, 0x2a, 0x35, 0x9e, 0xd9, 0xa3, 0x38, 0x2b, 0x6c, 0x9b, 0x9b, 0xad,
0xe0, 0xd4, 0x5a, 0x2d, 0x1d, 0x8e, 0x3e, 0xc2, 0xb7, 0x56, 0x35, 0x01, 0x65, 0x31, 0xf5, 0x52,
0xf8, 0xc6, 0xc6, 0xb3, 0x6c, 0xd5, 0x49, 0xa7, 0xec, 0xf0, 0x83, 0x40, 0xfc, 0x82, 0xc3, 0x81,
0xe0, 0xd1, 0x8e, 0x3f, 0xe0, 0x60, 0x9d, 0xca, 0x63, 0xd2, 0xc9, 0xca, 0x9f, 0x39, 0xec, 0x3b,
0x97, 0x3e, 0x88, 0x4a, 0xdd, 0x03, 0xfd, 0x4c, 0x92, 0x8b, 0x4b, 0x96, 0xd6, 0xbe, 0xc4, 0xdf,
0x42, 0x85, 0xbf, 0x8c, 0x79, 0x0c, 0xd5, 0x2a, 0xa4, 0xcf, 0x8f, 0xda, 0xff, 0xf2, 0xd1, 0xea,
0xbf, 0x7c, 0x74, 0xdb, 0xde, 0xcd, 0xd7, 0x36, 0x0e, 0xd2, 0xf3, 0x5f, 0x7f, 0x1e, 0xd0, 0x3f,
0xa2, 0x7f, 0xf2, 0xfa, 0xe2, 0xea, 0x31, 0xc5, 0x42, 0xba, 0xe2, 0x63, 0x53, 0xfc, 0xd6, 0xa5,
0x18, 0x9c, 0x9c, 0xcf, 0xae, 0xd6, 0xdf, 0xf6, 0x7e, 0xea, 0x7d, 0xf2, 0x57, 0x00, 0x00, 0x00,
0xff, 0xff, 0x66, 0x1a, 0xa6, 0xfc, 0x29, 0x06, 0x00, 0x00,
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,289 @@
// Code generated by protoc-gen-go.
// source: content_manifest.proto
// DO NOT EDIT!
package protobuf
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type ContentManifestPayload struct {
Mappings []*ContentManifestPayload_FileMapping `protobuf:"bytes,1,rep,name=mappings" json:"mappings,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ContentManifestPayload) Reset() { *m = ContentManifestPayload{} }
func (m *ContentManifestPayload) String() string { return proto.CompactTextString(m) }
func (*ContentManifestPayload) ProtoMessage() {}
func (*ContentManifestPayload) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{0} }
func (m *ContentManifestPayload) GetMappings() []*ContentManifestPayload_FileMapping {
if m != nil {
return m.Mappings
}
return nil
}
type ContentManifestPayload_FileMapping struct {
Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"`
Size *uint64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
Flags *uint32 `protobuf:"varint,3,opt,name=flags" json:"flags,omitempty"`
ShaFilename []byte `protobuf:"bytes,4,opt,name=sha_filename" json:"sha_filename,omitempty"`
ShaContent []byte `protobuf:"bytes,5,opt,name=sha_content" json:"sha_content,omitempty"`
Chunks []*ContentManifestPayload_FileMapping_ChunkData `protobuf:"bytes,6,rep,name=chunks" json:"chunks,omitempty"`
Linktarget *string `protobuf:"bytes,7,opt,name=linktarget" json:"linktarget,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ContentManifestPayload_FileMapping) Reset() { *m = ContentManifestPayload_FileMapping{} }
func (m *ContentManifestPayload_FileMapping) String() string { return proto.CompactTextString(m) }
func (*ContentManifestPayload_FileMapping) ProtoMessage() {}
func (*ContentManifestPayload_FileMapping) Descriptor() ([]byte, []int) {
return content_manifest_fileDescriptor0, []int{0, 0}
}
func (m *ContentManifestPayload_FileMapping) GetFilename() string {
if m != nil && m.Filename != nil {
return *m.Filename
}
return ""
}
func (m *ContentManifestPayload_FileMapping) GetSize() uint64 {
if m != nil && m.Size != nil {
return *m.Size
}
return 0
}
func (m *ContentManifestPayload_FileMapping) GetFlags() uint32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return 0
}
func (m *ContentManifestPayload_FileMapping) GetShaFilename() []byte {
if m != nil {
return m.ShaFilename
}
return nil
}
func (m *ContentManifestPayload_FileMapping) GetShaContent() []byte {
if m != nil {
return m.ShaContent
}
return nil
}
func (m *ContentManifestPayload_FileMapping) GetChunks() []*ContentManifestPayload_FileMapping_ChunkData {
if m != nil {
return m.Chunks
}
return nil
}
func (m *ContentManifestPayload_FileMapping) GetLinktarget() string {
if m != nil && m.Linktarget != nil {
return *m.Linktarget
}
return ""
}
type ContentManifestPayload_FileMapping_ChunkData struct {
Sha []byte `protobuf:"bytes,1,opt,name=sha" json:"sha,omitempty"`
Crc *uint32 `protobuf:"fixed32,2,opt,name=crc" json:"crc,omitempty"`
Offset *uint64 `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"`
CbOriginal *uint32 `protobuf:"varint,4,opt,name=cb_original" json:"cb_original,omitempty"`
CbCompressed *uint32 `protobuf:"varint,5,opt,name=cb_compressed" json:"cb_compressed,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ContentManifestPayload_FileMapping_ChunkData) Reset() {
*m = ContentManifestPayload_FileMapping_ChunkData{}
}
func (m *ContentManifestPayload_FileMapping_ChunkData) String() string {
return proto.CompactTextString(m)
}
func (*ContentManifestPayload_FileMapping_ChunkData) ProtoMessage() {}
func (*ContentManifestPayload_FileMapping_ChunkData) Descriptor() ([]byte, []int) {
return content_manifest_fileDescriptor0, []int{0, 0, 0}
}
func (m *ContentManifestPayload_FileMapping_ChunkData) GetSha() []byte {
if m != nil {
return m.Sha
}
return nil
}
func (m *ContentManifestPayload_FileMapping_ChunkData) GetCrc() uint32 {
if m != nil && m.Crc != nil {
return *m.Crc
}
return 0
}
func (m *ContentManifestPayload_FileMapping_ChunkData) GetOffset() uint64 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return 0
}
func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbOriginal() uint32 {
if m != nil && m.CbOriginal != nil {
return *m.CbOriginal
}
return 0
}
func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbCompressed() uint32 {
if m != nil && m.CbCompressed != nil {
return *m.CbCompressed
}
return 0
}
type ContentManifestMetadata struct {
DepotId *uint32 `protobuf:"varint,1,opt,name=depot_id" json:"depot_id,omitempty"`
GidManifest *uint64 `protobuf:"varint,2,opt,name=gid_manifest" json:"gid_manifest,omitempty"`
CreationTime *uint32 `protobuf:"varint,3,opt,name=creation_time" json:"creation_time,omitempty"`
FilenamesEncrypted *bool `protobuf:"varint,4,opt,name=filenames_encrypted" json:"filenames_encrypted,omitempty"`
CbDiskOriginal *uint64 `protobuf:"varint,5,opt,name=cb_disk_original" json:"cb_disk_original,omitempty"`
CbDiskCompressed *uint64 `protobuf:"varint,6,opt,name=cb_disk_compressed" json:"cb_disk_compressed,omitempty"`
UniqueChunks *uint32 `protobuf:"varint,7,opt,name=unique_chunks" json:"unique_chunks,omitempty"`
CrcEncrypted *uint32 `protobuf:"varint,8,opt,name=crc_encrypted" json:"crc_encrypted,omitempty"`
CrcClear *uint32 `protobuf:"varint,9,opt,name=crc_clear" json:"crc_clear,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ContentManifestMetadata) Reset() { *m = ContentManifestMetadata{} }
func (m *ContentManifestMetadata) String() string { return proto.CompactTextString(m) }
func (*ContentManifestMetadata) ProtoMessage() {}
func (*ContentManifestMetadata) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{1} }
func (m *ContentManifestMetadata) GetDepotId() uint32 {
if m != nil && m.DepotId != nil {
return *m.DepotId
}
return 0
}
func (m *ContentManifestMetadata) GetGidManifest() uint64 {
if m != nil && m.GidManifest != nil {
return *m.GidManifest
}
return 0
}
func (m *ContentManifestMetadata) GetCreationTime() uint32 {
if m != nil && m.CreationTime != nil {
return *m.CreationTime
}
return 0
}
func (m *ContentManifestMetadata) GetFilenamesEncrypted() bool {
if m != nil && m.FilenamesEncrypted != nil {
return *m.FilenamesEncrypted
}
return false
}
func (m *ContentManifestMetadata) GetCbDiskOriginal() uint64 {
if m != nil && m.CbDiskOriginal != nil {
return *m.CbDiskOriginal
}
return 0
}
func (m *ContentManifestMetadata) GetCbDiskCompressed() uint64 {
if m != nil && m.CbDiskCompressed != nil {
return *m.CbDiskCompressed
}
return 0
}
func (m *ContentManifestMetadata) GetUniqueChunks() uint32 {
if m != nil && m.UniqueChunks != nil {
return *m.UniqueChunks
}
return 0
}
func (m *ContentManifestMetadata) GetCrcEncrypted() uint32 {
if m != nil && m.CrcEncrypted != nil {
return *m.CrcEncrypted
}
return 0
}
func (m *ContentManifestMetadata) GetCrcClear() uint32 {
if m != nil && m.CrcClear != nil {
return *m.CrcClear
}
return 0
}
type ContentManifestSignature struct {
Signature []byte `protobuf:"bytes,1,opt,name=signature" json:"signature,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ContentManifestSignature) Reset() { *m = ContentManifestSignature{} }
func (m *ContentManifestSignature) String() string { return proto.CompactTextString(m) }
func (*ContentManifestSignature) ProtoMessage() {}
func (*ContentManifestSignature) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{2} }
func (m *ContentManifestSignature) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
func init() {
proto.RegisterType((*ContentManifestPayload)(nil), "ContentManifestPayload")
proto.RegisterType((*ContentManifestPayload_FileMapping)(nil), "ContentManifestPayload.FileMapping")
proto.RegisterType((*ContentManifestPayload_FileMapping_ChunkData)(nil), "ContentManifestPayload.FileMapping.ChunkData")
proto.RegisterType((*ContentManifestMetadata)(nil), "ContentManifestMetadata")
proto.RegisterType((*ContentManifestSignature)(nil), "ContentManifestSignature")
}
var content_manifest_fileDescriptor0 = []byte{
// 409 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x91, 0xbd, 0x8e, 0xd4, 0x30,
0x14, 0x85, 0xc9, 0xfc, 0x26, 0x37, 0x09, 0x5a, 0xbc, 0xb0, 0x58, 0x43, 0x83, 0x96, 0x66, 0x9b,
0x4d, 0x81, 0x44, 0x49, 0xc3, 0x22, 0x44, 0x33, 0x12, 0x12, 0x0f, 0x10, 0x5d, 0x1c, 0x27, 0x6b,
0x4d, 0x62, 0x07, 0xdb, 0x29, 0x96, 0x8a, 0x17, 0xe1, 0x0d, 0x91, 0x78, 0x05, 0x6c, 0x27, 0x99,
0x1d, 0x8d, 0x28, 0x28, 0xcf, 0xf1, 0xb5, 0xcf, 0x77, 0x8f, 0xe1, 0x8a, 0x29, 0x69, 0xb9, 0xb4,
0x65, 0x87, 0x52, 0xd4, 0xdc, 0xd8, 0xa2, 0xd7, 0xca, 0xaa, 0xeb, 0x3f, 0x0b, 0xb8, 0xba, 0x1b,
0x8f, 0xf6, 0xd3, 0xc9, 0x17, 0x7c, 0x68, 0x15, 0x56, 0xe4, 0x1d, 0xc4, 0x1d, 0xf6, 0xbd, 0x90,
0x8d, 0xa1, 0xd1, 0xeb, 0xe5, 0x4d, 0xfa, 0xf6, 0x4d, 0xf1, 0xef, 0xd1, 0xe2, 0x93, 0x68, 0xf9,
0x7e, 0x9c, 0xdd, 0xfd, 0x5a, 0x40, 0x7a, 0xa2, 0xc9, 0x05, 0xc4, 0xb5, 0x93, 0x12, 0x3b, 0xee,
0x9e, 0x89, 0x6e, 0x12, 0x92, 0xc1, 0xca, 0x88, 0x1f, 0x9c, 0x2e, 0x9c, 0x5a, 0x91, 0x1c, 0xd6,
0x75, 0x8b, 0x2e, 0x63, 0xe9, 0x64, 0x4e, 0x9e, 0x43, 0x66, 0xee, 0xb1, 0x3c, 0x5e, 0x59, 0x39,
0x37, 0x23, 0x97, 0x90, 0x7a, 0x77, 0x5a, 0x82, 0xae, 0x83, 0xf9, 0x1e, 0x36, 0xec, 0x7e, 0x90,
0x07, 0x43, 0x37, 0x01, 0xef, 0xf6, 0x3f, 0xf0, 0x8a, 0x3b, 0x7f, 0xe3, 0x23, 0x5a, 0x24, 0x04,
0xa0, 0x15, 0xf2, 0x60, 0x51, 0x37, 0xdc, 0xd2, 0xad, 0x47, 0xdb, 0x21, 0x24, 0x8f, 0x03, 0x29,
0x2c, 0x5d, 0x68, 0x80, 0xce, 0xbc, 0x60, 0x9a, 0x05, 0xe6, 0x2d, 0x79, 0x0a, 0x1b, 0x55, 0xd7,
0xc6, 0x5d, 0x5b, 0x86, 0x1d, 0x1c, 0x1e, 0xfb, 0x56, 0x2a, 0x2d, 0x1a, 0x21, 0xb1, 0x0d, 0xcc,
0x39, 0x79, 0x01, 0xb9, 0x33, 0x99, 0xea, 0x7a, 0xcd, 0x8d, 0xe1, 0x55, 0xa0, 0xce, 0xaf, 0x7f,
0x47, 0xf0, 0xf2, 0x8c, 0x73, 0xcf, 0x2d, 0x56, 0x3e, 0xd1, 0x75, 0x55, 0xf1, 0x5e, 0xd9, 0x52,
0x54, 0x21, 0x36, 0xd4, 0xd1, 0x88, 0xea, 0xf8, 0x6b, 0x53, 0x67, 0xfe, 0x69, 0xcd, 0xd1, 0x0a,
0x25, 0x4b, 0x2b, 0x5c, 0x4b, 0x63, 0x77, 0xaf, 0xe0, 0x72, 0xee, 0xcd, 0x94, 0x5c, 0x32, 0xfd,
0xd0, 0x5b, 0x97, 0xeb, 0x71, 0x62, 0x42, 0xe1, 0xc2, 0xe1, 0x54, 0xc2, 0x1c, 0x1e, 0x41, 0xd7,
0xe1, 0xb5, 0x1d, 0x90, 0xf9, 0xe4, 0x84, 0x76, 0x33, 0x27, 0x0d, 0x52, 0x7c, 0x1f, 0x78, 0x39,
0x55, 0xbd, 0x3d, 0xee, 0xa6, 0xd9, 0x49, 0x46, 0x1c, 0xec, 0x67, 0x90, 0x78, 0x9b, 0xb5, 0x1c,
0x35, 0x4d, 0xc2, 0xba, 0xb7, 0x40, 0xcf, 0xb6, 0xfd, 0x2a, 0x1a, 0x89, 0x76, 0xd0, 0xdc, 0x8f,
0x9b, 0x59, 0x8c, 0x35, 0x7f, 0x58, 0x7f, 0x8e, 0x7e, 0x46, 0x4f, 0xfe, 0x06, 0x00, 0x00, 0xff,
0xff, 0xc6, 0x87, 0xdb, 0xe6, 0xaf, 0x02, 0x00, 0x00,
}

View File

@ -0,0 +1,141 @@
// Code generated by protoc-gen-go.
// source: steammessages_unified_base.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type EProtoExecutionSite int32
const (
EProtoExecutionSite_k_EProtoExecutionSiteUnknown EProtoExecutionSite = 0
EProtoExecutionSite_k_EProtoExecutionSiteSteamClient EProtoExecutionSite = 2
)
var EProtoExecutionSite_name = map[int32]string{
0: "k_EProtoExecutionSiteUnknown",
2: "k_EProtoExecutionSiteSteamClient",
}
var EProtoExecutionSite_value = map[string]int32{
"k_EProtoExecutionSiteUnknown": 0,
"k_EProtoExecutionSiteSteamClient": 2,
}
func (x EProtoExecutionSite) Enum() *EProtoExecutionSite {
p := new(EProtoExecutionSite)
*p = x
return p
}
func (x EProtoExecutionSite) String() string {
return proto.EnumName(EProtoExecutionSite_name, int32(x))
}
func (x *EProtoExecutionSite) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EProtoExecutionSite_value, data, "EProtoExecutionSite")
if err != nil {
return err
}
*x = EProtoExecutionSite(value)
return nil
}
func (EProtoExecutionSite) EnumDescriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} }
type NoResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *NoResponse) Reset() { *m = NoResponse{} }
func (m *NoResponse) String() string { return proto.CompactTextString(m) }
func (*NoResponse) ProtoMessage() {}
func (*NoResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} }
var E_Description = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.FieldOptions)(nil),
ExtensionType: (*string)(nil),
Field: 50000,
Name: "description",
Tag: "bytes,50000,opt,name=description",
}
var E_ServiceDescription = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.ServiceOptions)(nil),
ExtensionType: (*string)(nil),
Field: 50000,
Name: "service_description",
Tag: "bytes,50000,opt,name=service_description",
}
var E_ServiceExecutionSite = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.ServiceOptions)(nil),
ExtensionType: (*EProtoExecutionSite)(nil),
Field: 50008,
Name: "service_execution_site",
Tag: "varint,50008,opt,name=service_execution_site,enum=EProtoExecutionSite,def=0",
}
var E_MethodDescription = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.MethodOptions)(nil),
ExtensionType: (*string)(nil),
Field: 50000,
Name: "method_description",
Tag: "bytes,50000,opt,name=method_description",
}
var E_EnumDescription = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.EnumOptions)(nil),
ExtensionType: (*string)(nil),
Field: 50000,
Name: "enum_description",
Tag: "bytes,50000,opt,name=enum_description",
}
var E_EnumValueDescription = &proto.ExtensionDesc{
ExtendedType: (*google_protobuf.EnumValueOptions)(nil),
ExtensionType: (*string)(nil),
Field: 50000,
Name: "enum_value_description",
Tag: "bytes,50000,opt,name=enum_value_description",
}
func init() {
proto.RegisterType((*NoResponse)(nil), "NoResponse")
proto.RegisterEnum("EProtoExecutionSite", EProtoExecutionSite_name, EProtoExecutionSite_value)
proto.RegisterExtension(E_Description)
proto.RegisterExtension(E_ServiceDescription)
proto.RegisterExtension(E_ServiceExecutionSite)
proto.RegisterExtension(E_MethodDescription)
proto.RegisterExtension(E_EnumDescription)
proto.RegisterExtension(E_EnumValueDescription)
}
var base_fileDescriptor0 = []byte{
// 306 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x90, 0x4d, 0x4b, 0xc3, 0x40,
0x10, 0x86, 0x1b, 0xc5, 0x83, 0xa3, 0x48, 0x48, 0xa5, 0x88, 0x54, 0x8d, 0xe2, 0x41, 0x44, 0xb6,
0x20, 0x1e, 0x24, 0x88, 0x07, 0x4b, 0xc4, 0x8b, 0x1f, 0x18, 0xf4, 0x26, 0x21, 0x4d, 0xa6, 0x71,
0x69, 0xb2, 0x1b, 0xb2, 0xbb, 0xd5, 0xa3, 0x27, 0x7f, 0x9f, 0x47, 0x7f, 0x8e, 0xcd, 0x86, 0x80,
0xf9, 0x40, 0x8f, 0xc9, 0xfb, 0x3e, 0xb3, 0xcf, 0x0c, 0x9c, 0x08, 0x89, 0x41, 0x9a, 0xa2, 0x10,
0x41, 0x8c, 0xc2, 0x57, 0x8c, 0x4e, 0x29, 0x46, 0xfe, 0x24, 0x10, 0x48, 0x74, 0x14, 0x26, 0x14,
0x99, 0x24, 0x59, 0xce, 0x25, 0xdf, 0xb6, 0x63, 0xce, 0xe3, 0x04, 0x47, 0xfa, 0x6b, 0xa2, 0xa6,
0xa3, 0x08, 0x45, 0x98, 0xd3, 0x4c, 0xf2, 0xbc, 0x6c, 0x1c, 0xac, 0x03, 0xdc, 0xf1, 0x47, 0x14,
0x19, 0x67, 0x02, 0x8f, 0x5f, 0xa0, 0xef, 0x3e, 0x14, 0xff, 0xdd, 0x77, 0x0c, 0x95, 0xa4, 0x9c,
0x79, 0x54, 0xa2, 0x65, 0xc3, 0x70, 0xe6, 0x77, 0x04, 0x4f, 0x6c, 0xc6, 0xf8, 0x1b, 0x33, 0x7b,
0xd6, 0x21, 0xd8, 0x9d, 0x0d, 0xaf, 0x50, 0x1a, 0x6b, 0x25, 0x73, 0xc9, 0x39, 0x83, 0xb5, 0x4a,
0x60, 0x91, 0x5b, 0x3b, 0xa4, 0xd4, 0x23, 0x95, 0x1e, 0xb9, 0xa6, 0x98, 0x44, 0xf7, 0x3a, 0x15,
0x5b, 0x5f, 0x9f, 0xcb, 0xb6, 0x71, 0xb4, 0xea, 0x5c, 0x42, 0x5f, 0x60, 0x3e, 0xa7, 0x21, 0xfa,
0xbf, 0xe9, 0xbd, 0x16, 0xed, 0x95, 0xad, 0x26, 0xaf, 0x60, 0x50, 0xf1, 0x58, 0xb9, 0xf9, 0xa2,
0xd8, 0xeb, 0xdf, 0x11, 0xdf, 0x7a, 0xc4, 0xc6, 0xe9, 0x26, 0xe9, 0xd8, 0xcd, 0xf9, 0xf3, 0x28,
0xce, 0x05, 0x58, 0x29, 0xca, 0x57, 0x1e, 0xd5, 0xac, 0x77, 0x5b, 0x4f, 0xde, 0xea, 0x52, 0x53,
0xfa, 0x1c, 0x4c, 0x64, 0x2a, 0xad, 0xb1, 0xc3, 0x16, 0xeb, 0x2e, 0x2a, 0x4d, 0x72, 0x0c, 0x03,
0x4d, 0xce, 0x83, 0x44, 0xd5, 0x2f, 0xb6, 0xdf, 0xc9, 0x3f, 0x17, 0xbd, 0xc6, 0x90, 0xab, 0x95,
0x1b, 0xe3, 0xc3, 0xe8, 0xfd, 0x04, 0x00, 0x00, 0xff, 0xff, 0x5c, 0xf6, 0x07, 0xbb, 0x6e, 0x02,
0x00, 0x00,
}

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,874 @@
// Code generated by protoc-gen-go.
// source: steammessages_credentials.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type CCredentials_TestAvailablePassword_Request struct {
Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"`
ShaDigestPassword []byte `protobuf:"bytes,2,opt,name=sha_digest_password" json:"sha_digest_password,omitempty"`
AccountName *string `protobuf:"bytes,3,opt,name=account_name" json:"account_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_TestAvailablePassword_Request) Reset() {
*m = CCredentials_TestAvailablePassword_Request{}
}
func (m *CCredentials_TestAvailablePassword_Request) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_TestAvailablePassword_Request) ProtoMessage() {}
func (*CCredentials_TestAvailablePassword_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{0}
}
func (m *CCredentials_TestAvailablePassword_Request) GetPassword() string {
if m != nil && m.Password != nil {
return *m.Password
}
return ""
}
func (m *CCredentials_TestAvailablePassword_Request) GetShaDigestPassword() []byte {
if m != nil {
return m.ShaDigestPassword
}
return nil
}
func (m *CCredentials_TestAvailablePassword_Request) GetAccountName() string {
if m != nil && m.AccountName != nil {
return *m.AccountName
}
return ""
}
type CCredentials_TestAvailablePassword_Response struct {
IsValid *bool `protobuf:"varint,3,opt,name=is_valid" json:"is_valid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_TestAvailablePassword_Response) Reset() {
*m = CCredentials_TestAvailablePassword_Response{}
}
func (m *CCredentials_TestAvailablePassword_Response) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_TestAvailablePassword_Response) ProtoMessage() {}
func (*CCredentials_TestAvailablePassword_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{1}
}
func (m *CCredentials_TestAvailablePassword_Response) GetIsValid() bool {
if m != nil && m.IsValid != nil {
return *m.IsValid
}
return false
}
type CCredentials_GetSteamGuardDetails_Request struct {
IncludeNewAuthentications *bool `protobuf:"varint,1,opt,name=include_new_authentications,def=1" json:"include_new_authentications,omitempty"`
Webcookie *string `protobuf:"bytes,2,opt,name=webcookie" json:"webcookie,omitempty"`
TimestampMinimumWanted *uint32 `protobuf:"fixed32,3,opt,name=timestamp_minimum_wanted" json:"timestamp_minimum_wanted,omitempty"`
Ipaddress *int32 `protobuf:"varint,4,opt,name=ipaddress" json:"ipaddress,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_GetSteamGuardDetails_Request) Reset() {
*m = CCredentials_GetSteamGuardDetails_Request{}
}
func (m *CCredentials_GetSteamGuardDetails_Request) String() string { return proto.CompactTextString(m) }
func (*CCredentials_GetSteamGuardDetails_Request) ProtoMessage() {}
func (*CCredentials_GetSteamGuardDetails_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{2}
}
const Default_CCredentials_GetSteamGuardDetails_Request_IncludeNewAuthentications bool = true
func (m *CCredentials_GetSteamGuardDetails_Request) GetIncludeNewAuthentications() bool {
if m != nil && m.IncludeNewAuthentications != nil {
return *m.IncludeNewAuthentications
}
return Default_CCredentials_GetSteamGuardDetails_Request_IncludeNewAuthentications
}
func (m *CCredentials_GetSteamGuardDetails_Request) GetWebcookie() string {
if m != nil && m.Webcookie != nil {
return *m.Webcookie
}
return ""
}
func (m *CCredentials_GetSteamGuardDetails_Request) GetTimestampMinimumWanted() uint32 {
if m != nil && m.TimestampMinimumWanted != nil {
return *m.TimestampMinimumWanted
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Request) GetIpaddress() int32 {
if m != nil && m.Ipaddress != nil {
return *m.Ipaddress
}
return 0
}
type CCredentials_GetSteamGuardDetails_Response struct {
IsSteamguardEnabled *bool `protobuf:"varint,1,opt,name=is_steamguard_enabled" json:"is_steamguard_enabled,omitempty"`
TimestampSteamguardEnabled *uint32 `protobuf:"fixed32,2,opt,name=timestamp_steamguard_enabled" json:"timestamp_steamguard_enabled,omitempty"`
DeprecatedNewauthentication []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication `protobuf:"bytes,3,rep,name=deprecated_newauthentication" json:"deprecated_newauthentication,omitempty"`
DeprecatedMachineNameUserchosen *string `protobuf:"bytes,4,opt,name=deprecated_machine_name_userchosen" json:"deprecated_machine_name_userchosen,omitempty"`
DeprecatedTimestampMachineSteamguardEnabled *uint32 `protobuf:"fixed32,5,opt,name=deprecated_timestamp_machine_steamguard_enabled" json:"deprecated_timestamp_machine_steamguard_enabled,omitempty"`
DeprecatedAuthenticationExistsFromGeolocBeforeMintime *bool `protobuf:"varint,6,opt,name=deprecated_authentication_exists_from_geoloc_before_mintime" json:"deprecated_authentication_exists_from_geoloc_before_mintime,omitempty"`
DeprecatedMachineId *uint64 `protobuf:"varint,7,opt,name=deprecated_machine_id" json:"deprecated_machine_id,omitempty"`
SessionData []*CCredentials_GetSteamGuardDetails_Response_SessionData `protobuf:"bytes,8,rep,name=session_data" json:"session_data,omitempty"`
IsTwofactorEnabled *bool `protobuf:"varint,9,opt,name=is_twofactor_enabled" json:"is_twofactor_enabled,omitempty"`
TimestampTwofactorEnabled *uint32 `protobuf:"fixed32,10,opt,name=timestamp_twofactor_enabled" json:"timestamp_twofactor_enabled,omitempty"`
IsPhoneVerified *bool `protobuf:"varint,11,opt,name=is_phone_verified" json:"is_phone_verified,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_GetSteamGuardDetails_Response) Reset() {
*m = CCredentials_GetSteamGuardDetails_Response{}
}
func (m *CCredentials_GetSteamGuardDetails_Response) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_GetSteamGuardDetails_Response) ProtoMessage() {}
func (*CCredentials_GetSteamGuardDetails_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{3}
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetIsSteamguardEnabled() bool {
if m != nil && m.IsSteamguardEnabled != nil {
return *m.IsSteamguardEnabled
}
return false
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetTimestampSteamguardEnabled() uint32 {
if m != nil && m.TimestampSteamguardEnabled != nil {
return *m.TimestampSteamguardEnabled
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedNewauthentication() []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication {
if m != nil {
return m.DeprecatedNewauthentication
}
return nil
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedMachineNameUserchosen() string {
if m != nil && m.DeprecatedMachineNameUserchosen != nil {
return *m.DeprecatedMachineNameUserchosen
}
return ""
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedTimestampMachineSteamguardEnabled() uint32 {
if m != nil && m.DeprecatedTimestampMachineSteamguardEnabled != nil {
return *m.DeprecatedTimestampMachineSteamguardEnabled
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedAuthenticationExistsFromGeolocBeforeMintime() bool {
if m != nil && m.DeprecatedAuthenticationExistsFromGeolocBeforeMintime != nil {
return *m.DeprecatedAuthenticationExistsFromGeolocBeforeMintime
}
return false
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedMachineId() uint64 {
if m != nil && m.DeprecatedMachineId != nil {
return *m.DeprecatedMachineId
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetSessionData() []*CCredentials_GetSteamGuardDetails_Response_SessionData {
if m != nil {
return m.SessionData
}
return nil
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetIsTwofactorEnabled() bool {
if m != nil && m.IsTwofactorEnabled != nil {
return *m.IsTwofactorEnabled
}
return false
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetTimestampTwofactorEnabled() uint32 {
if m != nil && m.TimestampTwofactorEnabled != nil {
return *m.TimestampTwofactorEnabled
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response) GetIsPhoneVerified() bool {
if m != nil && m.IsPhoneVerified != nil {
return *m.IsPhoneVerified
}
return false
}
type CCredentials_GetSteamGuardDetails_Response_NewAuthentication struct {
TimestampSteamguardEnabled *uint32 `protobuf:"fixed32,1,opt,name=timestamp_steamguard_enabled" json:"timestamp_steamguard_enabled,omitempty"`
IsWebCookie *bool `protobuf:"varint,2,opt,name=is_web_cookie" json:"is_web_cookie,omitempty"`
Ipaddress *int32 `protobuf:"varint,3,opt,name=ipaddress" json:"ipaddress,omitempty"`
GeolocInfo *string `protobuf:"bytes,4,opt,name=geoloc_info" json:"geoloc_info,omitempty"`
IsRemembered *bool `protobuf:"varint,5,opt,name=is_remembered" json:"is_remembered,omitempty"`
MachineNameUserSupplied *string `protobuf:"bytes,6,opt,name=machine_name_user_supplied" json:"machine_name_user_supplied,omitempty"`
Status *int32 `protobuf:"varint,7,opt,name=status" json:"status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) Reset() {
*m = CCredentials_GetSteamGuardDetails_Response_NewAuthentication{}
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_GetSteamGuardDetails_Response_NewAuthentication) ProtoMessage() {}
func (*CCredentials_GetSteamGuardDetails_Response_NewAuthentication) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{3, 0}
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetTimestampSteamguardEnabled() uint32 {
if m != nil && m.TimestampSteamguardEnabled != nil {
return *m.TimestampSteamguardEnabled
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetIsWebCookie() bool {
if m != nil && m.IsWebCookie != nil {
return *m.IsWebCookie
}
return false
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetIpaddress() int32 {
if m != nil && m.Ipaddress != nil {
return *m.Ipaddress
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetGeolocInfo() string {
if m != nil && m.GeolocInfo != nil {
return *m.GeolocInfo
}
return ""
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetIsRemembered() bool {
if m != nil && m.IsRemembered != nil {
return *m.IsRemembered
}
return false
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetMachineNameUserSupplied() string {
if m != nil && m.MachineNameUserSupplied != nil {
return *m.MachineNameUserSupplied
}
return ""
}
func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetStatus() int32 {
if m != nil && m.Status != nil {
return *m.Status
}
return 0
}
type CCredentials_GetSteamGuardDetails_Response_SessionData struct {
MachineId *uint64 `protobuf:"varint,1,opt,name=machine_id" json:"machine_id,omitempty"`
MachineNameUserchosen *string `protobuf:"bytes,2,opt,name=machine_name_userchosen" json:"machine_name_userchosen,omitempty"`
TimestampMachineSteamguardEnabled *uint32 `protobuf:"fixed32,3,opt,name=timestamp_machine_steamguard_enabled" json:"timestamp_machine_steamguard_enabled,omitempty"`
AuthenticationExistsFromGeolocBeforeMintime *bool `protobuf:"varint,4,opt,name=authentication_exists_from_geoloc_before_mintime" json:"authentication_exists_from_geoloc_before_mintime,omitempty"`
Newauthentication []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication `protobuf:"bytes,5,rep,name=newauthentication" json:"newauthentication,omitempty"`
AuthenticationExistsFromSameIpBeforeMintime *bool `protobuf:"varint,6,opt,name=authentication_exists_from_same_ip_before_mintime" json:"authentication_exists_from_same_ip_before_mintime,omitempty"`
PublicIpv4 *uint32 `protobuf:"varint,7,opt,name=public_ipv4" json:"public_ipv4,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) Reset() {
*m = CCredentials_GetSteamGuardDetails_Response_SessionData{}
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_GetSteamGuardDetails_Response_SessionData) ProtoMessage() {}
func (*CCredentials_GetSteamGuardDetails_Response_SessionData) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{3, 1}
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetMachineId() uint64 {
if m != nil && m.MachineId != nil {
return *m.MachineId
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetMachineNameUserchosen() string {
if m != nil && m.MachineNameUserchosen != nil {
return *m.MachineNameUserchosen
}
return ""
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetTimestampMachineSteamguardEnabled() uint32 {
if m != nil && m.TimestampMachineSteamguardEnabled != nil {
return *m.TimestampMachineSteamguardEnabled
}
return 0
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetAuthenticationExistsFromGeolocBeforeMintime() bool {
if m != nil && m.AuthenticationExistsFromGeolocBeforeMintime != nil {
return *m.AuthenticationExistsFromGeolocBeforeMintime
}
return false
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetNewauthentication() []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication {
if m != nil {
return m.Newauthentication
}
return nil
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetAuthenticationExistsFromSameIpBeforeMintime() bool {
if m != nil && m.AuthenticationExistsFromSameIpBeforeMintime != nil {
return *m.AuthenticationExistsFromSameIpBeforeMintime
}
return false
}
func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetPublicIpv4() uint32 {
if m != nil && m.PublicIpv4 != nil {
return *m.PublicIpv4
}
return 0
}
type CCredentials_NewMachineNotificationDialog_Request struct {
IsApproved *bool `protobuf:"varint,1,opt,name=is_approved" json:"is_approved,omitempty"`
IsWizardComplete *bool `protobuf:"varint,2,opt,name=is_wizard_complete" json:"is_wizard_complete,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_NewMachineNotificationDialog_Request) Reset() {
*m = CCredentials_NewMachineNotificationDialog_Request{}
}
func (m *CCredentials_NewMachineNotificationDialog_Request) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_NewMachineNotificationDialog_Request) ProtoMessage() {}
func (*CCredentials_NewMachineNotificationDialog_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{4}
}
func (m *CCredentials_NewMachineNotificationDialog_Request) GetIsApproved() bool {
if m != nil && m.IsApproved != nil {
return *m.IsApproved
}
return false
}
func (m *CCredentials_NewMachineNotificationDialog_Request) GetIsWizardComplete() bool {
if m != nil && m.IsWizardComplete != nil {
return *m.IsWizardComplete
}
return false
}
type CCredentials_NewMachineNotificationDialog_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_NewMachineNotificationDialog_Response) Reset() {
*m = CCredentials_NewMachineNotificationDialog_Response{}
}
func (m *CCredentials_NewMachineNotificationDialog_Response) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_NewMachineNotificationDialog_Response) ProtoMessage() {}
func (*CCredentials_NewMachineNotificationDialog_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{5}
}
type CCredentials_ValidateEmailAddress_Request struct {
Stoken *string `protobuf:"bytes,1,opt,name=stoken" json:"stoken,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_ValidateEmailAddress_Request) Reset() {
*m = CCredentials_ValidateEmailAddress_Request{}
}
func (m *CCredentials_ValidateEmailAddress_Request) String() string { return proto.CompactTextString(m) }
func (*CCredentials_ValidateEmailAddress_Request) ProtoMessage() {}
func (*CCredentials_ValidateEmailAddress_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{6}
}
func (m *CCredentials_ValidateEmailAddress_Request) GetStoken() string {
if m != nil && m.Stoken != nil {
return *m.Stoken
}
return ""
}
type CCredentials_ValidateEmailAddress_Response struct {
WasValidated *bool `protobuf:"varint,1,opt,name=was_validated" json:"was_validated,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_ValidateEmailAddress_Response) Reset() {
*m = CCredentials_ValidateEmailAddress_Response{}
}
func (m *CCredentials_ValidateEmailAddress_Response) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_ValidateEmailAddress_Response) ProtoMessage() {}
func (*CCredentials_ValidateEmailAddress_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{7}
}
func (m *CCredentials_ValidateEmailAddress_Response) GetWasValidated() bool {
if m != nil && m.WasValidated != nil {
return *m.WasValidated
}
return false
}
type CCredentials_SteamGuardPhishingReport_Request struct {
ParamString *string `protobuf:"bytes,1,opt,name=param_string" json:"param_string,omitempty"`
IpaddressActual *uint32 `protobuf:"varint,2,opt,name=ipaddress_actual" json:"ipaddress_actual,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_SteamGuardPhishingReport_Request) Reset() {
*m = CCredentials_SteamGuardPhishingReport_Request{}
}
func (m *CCredentials_SteamGuardPhishingReport_Request) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_SteamGuardPhishingReport_Request) ProtoMessage() {}
func (*CCredentials_SteamGuardPhishingReport_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{8}
}
func (m *CCredentials_SteamGuardPhishingReport_Request) GetParamString() string {
if m != nil && m.ParamString != nil {
return *m.ParamString
}
return ""
}
func (m *CCredentials_SteamGuardPhishingReport_Request) GetIpaddressActual() uint32 {
if m != nil && m.IpaddressActual != nil {
return *m.IpaddressActual
}
return 0
}
type CCredentials_SteamGuardPhishingReport_Response struct {
IpaddressLoginattempt *uint32 `protobuf:"varint,1,opt,name=ipaddress_loginattempt" json:"ipaddress_loginattempt,omitempty"`
CountrynameLoginattempt *string `protobuf:"bytes,2,opt,name=countryname_loginattempt" json:"countryname_loginattempt,omitempty"`
StatenameLoginattempt *string `protobuf:"bytes,3,opt,name=statename_loginattempt" json:"statename_loginattempt,omitempty"`
CitynameLoginattempt *string `protobuf:"bytes,4,opt,name=cityname_loginattempt" json:"cityname_loginattempt,omitempty"`
IpaddressActual *uint32 `protobuf:"varint,5,opt,name=ipaddress_actual" json:"ipaddress_actual,omitempty"`
CountrynameActual *string `protobuf:"bytes,6,opt,name=countryname_actual" json:"countryname_actual,omitempty"`
StatenameActual *string `protobuf:"bytes,7,opt,name=statename_actual" json:"statename_actual,omitempty"`
CitynameActual *string `protobuf:"bytes,8,opt,name=cityname_actual" json:"cityname_actual,omitempty"`
SteamguardCode *string `protobuf:"bytes,9,opt,name=steamguard_code" json:"steamguard_code,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_SteamGuardPhishingReport_Response) Reset() {
*m = CCredentials_SteamGuardPhishingReport_Response{}
}
func (m *CCredentials_SteamGuardPhishingReport_Response) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_SteamGuardPhishingReport_Response) ProtoMessage() {}
func (*CCredentials_SteamGuardPhishingReport_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{9}
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetIpaddressLoginattempt() uint32 {
if m != nil && m.IpaddressLoginattempt != nil {
return *m.IpaddressLoginattempt
}
return 0
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetCountrynameLoginattempt() string {
if m != nil && m.CountrynameLoginattempt != nil {
return *m.CountrynameLoginattempt
}
return ""
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetStatenameLoginattempt() string {
if m != nil && m.StatenameLoginattempt != nil {
return *m.StatenameLoginattempt
}
return ""
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetCitynameLoginattempt() string {
if m != nil && m.CitynameLoginattempt != nil {
return *m.CitynameLoginattempt
}
return ""
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetIpaddressActual() uint32 {
if m != nil && m.IpaddressActual != nil {
return *m.IpaddressActual
}
return 0
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetCountrynameActual() string {
if m != nil && m.CountrynameActual != nil {
return *m.CountrynameActual
}
return ""
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetStatenameActual() string {
if m != nil && m.StatenameActual != nil {
return *m.StatenameActual
}
return ""
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetCitynameActual() string {
if m != nil && m.CitynameActual != nil {
return *m.CitynameActual
}
return ""
}
func (m *CCredentials_SteamGuardPhishingReport_Response) GetSteamguardCode() string {
if m != nil && m.SteamguardCode != nil {
return *m.SteamguardCode
}
return ""
}
type CCredentials_AccountLockRequest_Request struct {
ParamString *string `protobuf:"bytes,1,opt,name=param_string" json:"param_string,omitempty"`
IpaddressActual *uint32 `protobuf:"varint,2,opt,name=ipaddress_actual" json:"ipaddress_actual,omitempty"`
QueryOnly *bool `protobuf:"varint,3,opt,name=query_only" json:"query_only,omitempty"`
EmailMessageType *int32 `protobuf:"varint,4,opt,name=email_message_type" json:"email_message_type,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_AccountLockRequest_Request) Reset() {
*m = CCredentials_AccountLockRequest_Request{}
}
func (m *CCredentials_AccountLockRequest_Request) String() string { return proto.CompactTextString(m) }
func (*CCredentials_AccountLockRequest_Request) ProtoMessage() {}
func (*CCredentials_AccountLockRequest_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{10}
}
func (m *CCredentials_AccountLockRequest_Request) GetParamString() string {
if m != nil && m.ParamString != nil {
return *m.ParamString
}
return ""
}
func (m *CCredentials_AccountLockRequest_Request) GetIpaddressActual() uint32 {
if m != nil && m.IpaddressActual != nil {
return *m.IpaddressActual
}
return 0
}
func (m *CCredentials_AccountLockRequest_Request) GetQueryOnly() bool {
if m != nil && m.QueryOnly != nil {
return *m.QueryOnly
}
return false
}
func (m *CCredentials_AccountLockRequest_Request) GetEmailMessageType() int32 {
if m != nil && m.EmailMessageType != nil {
return *m.EmailMessageType
}
return 0
}
type CCredentials_AccountLockRequest_Response struct {
Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"`
AccountAlreadyLocked *bool `protobuf:"varint,2,opt,name=account_already_locked" json:"account_already_locked,omitempty"`
ExpiredLink *bool `protobuf:"varint,3,opt,name=expired_link" json:"expired_link,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_AccountLockRequest_Response) Reset() {
*m = CCredentials_AccountLockRequest_Response{}
}
func (m *CCredentials_AccountLockRequest_Response) String() string { return proto.CompactTextString(m) }
func (*CCredentials_AccountLockRequest_Response) ProtoMessage() {}
func (*CCredentials_AccountLockRequest_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{11}
}
func (m *CCredentials_AccountLockRequest_Response) GetSuccess() bool {
if m != nil && m.Success != nil {
return *m.Success
}
return false
}
func (m *CCredentials_AccountLockRequest_Response) GetAccountAlreadyLocked() bool {
if m != nil && m.AccountAlreadyLocked != nil {
return *m.AccountAlreadyLocked
}
return false
}
func (m *CCredentials_AccountLockRequest_Response) GetExpiredLink() bool {
if m != nil && m.ExpiredLink != nil {
return *m.ExpiredLink
}
return false
}
type CCredentials_LastCredentialChangeTime_Request struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_LastCredentialChangeTime_Request) Reset() {
*m = CCredentials_LastCredentialChangeTime_Request{}
}
func (m *CCredentials_LastCredentialChangeTime_Request) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_LastCredentialChangeTime_Request) ProtoMessage() {}
func (*CCredentials_LastCredentialChangeTime_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{12}
}
type CCredentials_LastCredentialChangeTime_Response struct {
TimestampLastPasswordChange *uint32 `protobuf:"fixed32,1,opt,name=timestamp_last_password_change" json:"timestamp_last_password_change,omitempty"`
TimestampLastEmailChange *uint32 `protobuf:"fixed32,2,opt,name=timestamp_last_email_change" json:"timestamp_last_email_change,omitempty"`
TimestampLastPasswordReset *uint32 `protobuf:"fixed32,3,opt,name=timestamp_last_password_reset" json:"timestamp_last_password_reset,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_LastCredentialChangeTime_Response) Reset() {
*m = CCredentials_LastCredentialChangeTime_Response{}
}
func (m *CCredentials_LastCredentialChangeTime_Response) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_LastCredentialChangeTime_Response) ProtoMessage() {}
func (*CCredentials_LastCredentialChangeTime_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{13}
}
func (m *CCredentials_LastCredentialChangeTime_Response) GetTimestampLastPasswordChange() uint32 {
if m != nil && m.TimestampLastPasswordChange != nil {
return *m.TimestampLastPasswordChange
}
return 0
}
func (m *CCredentials_LastCredentialChangeTime_Response) GetTimestampLastEmailChange() uint32 {
if m != nil && m.TimestampLastEmailChange != nil {
return *m.TimestampLastEmailChange
}
return 0
}
func (m *CCredentials_LastCredentialChangeTime_Response) GetTimestampLastPasswordReset() uint32 {
if m != nil && m.TimestampLastPasswordReset != nil {
return *m.TimestampLastPasswordReset
}
return 0
}
type CCredentials_GetAccountAuthSecret_Request struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_GetAccountAuthSecret_Request) Reset() {
*m = CCredentials_GetAccountAuthSecret_Request{}
}
func (m *CCredentials_GetAccountAuthSecret_Request) String() string { return proto.CompactTextString(m) }
func (*CCredentials_GetAccountAuthSecret_Request) ProtoMessage() {}
func (*CCredentials_GetAccountAuthSecret_Request) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{14}
}
type CCredentials_GetAccountAuthSecret_Response struct {
SecretId *int32 `protobuf:"varint,1,opt,name=secret_id" json:"secret_id,omitempty"`
Secret []byte `protobuf:"bytes,2,opt,name=secret" json:"secret,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CCredentials_GetAccountAuthSecret_Response) Reset() {
*m = CCredentials_GetAccountAuthSecret_Response{}
}
func (m *CCredentials_GetAccountAuthSecret_Response) String() string {
return proto.CompactTextString(m)
}
func (*CCredentials_GetAccountAuthSecret_Response) ProtoMessage() {}
func (*CCredentials_GetAccountAuthSecret_Response) Descriptor() ([]byte, []int) {
return credentials_fileDescriptor0, []int{15}
}
func (m *CCredentials_GetAccountAuthSecret_Response) GetSecretId() int32 {
if m != nil && m.SecretId != nil {
return *m.SecretId
}
return 0
}
func (m *CCredentials_GetAccountAuthSecret_Response) GetSecret() []byte {
if m != nil {
return m.Secret
}
return nil
}
func init() {
proto.RegisterType((*CCredentials_TestAvailablePassword_Request)(nil), "CCredentials_TestAvailablePassword_Request")
proto.RegisterType((*CCredentials_TestAvailablePassword_Response)(nil), "CCredentials_TestAvailablePassword_Response")
proto.RegisterType((*CCredentials_GetSteamGuardDetails_Request)(nil), "CCredentials_GetSteamGuardDetails_Request")
proto.RegisterType((*CCredentials_GetSteamGuardDetails_Response)(nil), "CCredentials_GetSteamGuardDetails_Response")
proto.RegisterType((*CCredentials_GetSteamGuardDetails_Response_NewAuthentication)(nil), "CCredentials_GetSteamGuardDetails_Response.NewAuthentication")
proto.RegisterType((*CCredentials_GetSteamGuardDetails_Response_SessionData)(nil), "CCredentials_GetSteamGuardDetails_Response.SessionData")
proto.RegisterType((*CCredentials_NewMachineNotificationDialog_Request)(nil), "CCredentials_NewMachineNotificationDialog_Request")
proto.RegisterType((*CCredentials_NewMachineNotificationDialog_Response)(nil), "CCredentials_NewMachineNotificationDialog_Response")
proto.RegisterType((*CCredentials_ValidateEmailAddress_Request)(nil), "CCredentials_ValidateEmailAddress_Request")
proto.RegisterType((*CCredentials_ValidateEmailAddress_Response)(nil), "CCredentials_ValidateEmailAddress_Response")
proto.RegisterType((*CCredentials_SteamGuardPhishingReport_Request)(nil), "CCredentials_SteamGuardPhishingReport_Request")
proto.RegisterType((*CCredentials_SteamGuardPhishingReport_Response)(nil), "CCredentials_SteamGuardPhishingReport_Response")
proto.RegisterType((*CCredentials_AccountLockRequest_Request)(nil), "CCredentials_AccountLockRequest_Request")
proto.RegisterType((*CCredentials_AccountLockRequest_Response)(nil), "CCredentials_AccountLockRequest_Response")
proto.RegisterType((*CCredentials_LastCredentialChangeTime_Request)(nil), "CCredentials_LastCredentialChangeTime_Request")
proto.RegisterType((*CCredentials_LastCredentialChangeTime_Response)(nil), "CCredentials_LastCredentialChangeTime_Response")
proto.RegisterType((*CCredentials_GetAccountAuthSecret_Request)(nil), "CCredentials_GetAccountAuthSecret_Request")
proto.RegisterType((*CCredentials_GetAccountAuthSecret_Response)(nil), "CCredentials_GetAccountAuthSecret_Response")
}
var credentials_fileDescriptor0 = []byte{
// 1482 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x5d, 0x6f, 0x14, 0xd5,
0x1b, 0xcf, 0x94, 0xbe, 0xec, 0x3e, 0xa5, 0x7f, 0xe8, 0x40, 0x61, 0x59, 0x0a, 0x4c, 0x06, 0xfe,
0xb6, 0xd0, 0x3a, 0x48, 0x25, 0x41, 0x25, 0xc6, 0x94, 0x56, 0x09, 0x06, 0x90, 0x00, 0x51, 0xef,
0x4e, 0x4e, 0x67, 0x4e, 0x77, 0x4f, 0x3a, 0x33, 0x67, 0x98, 0x39, 0xb3, 0x4b, 0x4d, 0x4c, 0xc4,
0x3b, 0xbc, 0xf0, 0xce, 0x0b, 0x13, 0x2f, 0x8d, 0x5f, 0xc0, 0xe8, 0x17, 0xf0, 0x2b, 0xf8, 0x25,
0xbc, 0x32, 0x7e, 0x03, 0x9f, 0x73, 0xe6, 0xec, 0xfb, 0x6c, 0xbb, 0x4b, 0xbc, 0xdc, 0x39, 0xcf,
0xcb, 0xef, 0xf9, 0x3d, 0xaf, 0x0b, 0x1b, 0x99, 0x64, 0x34, 0x8a, 0x58, 0x96, 0xd1, 0x06, 0xcb,
0x88, 0x9f, 0xb2, 0x80, 0xc5, 0x92, 0xd3, 0x30, 0xf3, 0xf4, 0x8b, 0x1f, 0x72, 0xfc, 0xed, 0x25,
0xa9, 0x90, 0xa2, 0xbe, 0x39, 0x28, 0x9c, 0xc7, 0x7c, 0x9f, 0xb3, 0x80, 0xec, 0xd1, 0x8c, 0x8d,
0x4a, 0xbb, 0x2f, 0xe0, 0xc6, 0xce, 0x4e, 0xcf, 0x1e, 0x79, 0xce, 0x32, 0xb9, 0xdd, 0xa2, 0x3c,
0xa4, 0x7b, 0x21, 0x7b, 0x42, 0xb3, 0xac, 0x2d, 0xd2, 0x80, 0x3c, 0x65, 0x2f, 0x72, 0x7c, 0xb0,
0x4f, 0x43, 0x25, 0x31, 0xdf, 0x6a, 0x96, 0x63, 0xad, 0x57, 0xed, 0x8b, 0x70, 0x26, 0x6b, 0x52,
0x12, 0x70, 0xf4, 0x25, 0x49, 0xf7, 0x71, 0x06, 0x1f, 0x4f, 0xda, 0x67, 0xe1, 0x24, 0xf5, 0x7d,
0x91, 0xc7, 0x92, 0xc4, 0x34, 0x62, 0xb5, 0x13, 0x4a, 0xc5, 0xfd, 0x08, 0x36, 0x26, 0x72, 0x99,
0x25, 0x22, 0xce, 0x98, 0xf2, 0xc9, 0x33, 0xd2, 0xa2, 0x21, 0x0f, 0xb4, 0x81, 0x8a, 0xfb, 0xf7,
0x0c, 0x5c, 0x1f, 0xb0, 0x70, 0x9f, 0xc9, 0x67, 0x2a, 0xb2, 0xfb, 0x39, 0x4d, 0x83, 0x5d, 0x26,
0xd1, 0x56, 0xd6, 0xc5, 0x9c, 0xc3, 0x45, 0x1e, 0xfb, 0x61, 0x1e, 0x30, 0x12, 0xb3, 0x36, 0xa1,
0xb9, 0x6c, 0x2a, 0x3d, 0x9f, 0x4a, 0x8e, 0xf6, 0x75, 0x18, 0x95, 0x0f, 0x66, 0x65, 0x9a, 0xb3,
0x7b, 0x9f, 0x7e, 0xfb, 0x5b, 0xed, 0x93, 0x2f, 0x9a, 0x0c, 0x25, 0x52, 0x47, 0xa4, 0x4e, 0x2c,
0xa4, 0x23, 0x85, 0x93, 0x88, 0x24, 0x0f, 0xa9, 0x64, 0x0e, 0x7e, 0x77, 0xd0, 0xc6, 0xa0, 0x09,
0x07, 0xe9, 0x0d, 0x03, 0x87, 0xc7, 0xfa, 0x39, 0xed, 0xc0, 0xfe, 0xc1, 0x82, 0x6a, 0x9b, 0xed,
0xf9, 0x42, 0x1c, 0x70, 0xa6, 0xf9, 0xa8, 0xde, 0x7b, 0x65, 0xa1, 0x83, 0xaf, 0x9f, 0xa3, 0x58,
0x9e, 0xb1, 0x74, 0x2d, 0x73, 0x34, 0x6a, 0x47, 0xc3, 0x76, 0x22, 0xea, 0x37, 0x79, 0xcc, 0x1c,
0x65, 0xdd, 0x29, 0xd4, 0x3c, 0xe7, 0xc1, 0xbe, 0x93, 0xa0, 0x49, 0xf4, 0xb6, 0xe9, 0x70, 0xb9,
0x16, 0x86, 0xce, 0x9e, 0x56, 0x0e, 0x14, 0xae, 0x06, 0x93, 0xda, 0xa7, 0x31, 0xd6, 0x31, 0xf0,
0x60, 0x17, 0xc1, 0xa8, 0x4c, 0x07, 0x8e, 0xd8, 0xd7, 0x02, 0xdb, 0x8f, 0x9c, 0x0c, 0xeb, 0x01,
0xc1, 0x7a, 0xb6, 0x03, 0x35, 0xc9, 0xb1, 0x3a, 0x24, 0x8d, 0x12, 0x12, 0xf1, 0x98, 0x47, 0x79,
0x44, 0xda, 0x34, 0x96, 0xac, 0xa0, 0x77, 0xc1, 0x5e, 0x86, 0x2a, 0x4f, 0x68, 0x10, 0xa0, 0xdf,
0xac, 0x36, 0x8b, 0x9f, 0xe6, 0xdc, 0xbf, 0x2a, 0x43, 0x65, 0x32, 0x86, 0x71, 0x13, 0xfb, 0x25,
0x58, 0xc1, 0x94, 0xe9, 0x62, 0x6b, 0x28, 0x01, 0xc2, 0x62, 0x95, 0xdb, 0xa2, 0x66, 0x2a, 0xf6,
0x35, 0x58, 0xed, 0x41, 0x28, 0x91, 0x9a, 0xd1, 0x30, 0x7c, 0x58, 0x0d, 0x18, 0x06, 0x8f, 0x2c,
0x63, 0xf9, 0x8e, 0xd0, 0x8e, 0x60, 0x4f, 0xac, 0x2f, 0x6e, 0x7d, 0xe8, 0x4d, 0x8e, 0xcb, 0x7b,
0xcc, 0xda, 0xdb, 0x03, 0x46, 0xec, 0x1b, 0xe0, 0xf6, 0x39, 0x31, 0x0c, 0xea, 0x62, 0x25, 0x8a,
0x55, 0xbf, 0x29, 0x90, 0x7b, 0x4d, 0x42, 0xd5, 0xbe, 0x03, 0x37, 0xfb, 0x64, 0xfb, 0x48, 0x34,
0x5a, 0x25, 0x91, 0xcc, 0xe9, 0x48, 0x76, 0xe0, 0x6e, 0x9f, 0xe2, 0x60, 0x18, 0x84, 0xbd, 0xe4,
0x99, 0xcc, 0xc8, 0x7e, 0x2a, 0x22, 0xd2, 0x60, 0x22, 0x14, 0x3e, 0xd9, 0x63, 0xfb, 0x22, 0x65,
0x2a, 0x39, 0xca, 0x49, 0x6d, 0x5e, 0x93, 0x86, 0x9c, 0x96, 0x20, 0xc5, 0x9e, 0x58, 0xc0, 0xe7,
0x59, 0xfb, 0x11, 0x9c, 0x34, 0x29, 0x26, 0x01, 0x95, 0xb4, 0x56, 0xd1, 0xec, 0xdc, 0x99, 0x86,
0x9d, 0x67, 0x85, 0xfe, 0x2e, 0xaa, 0xdb, 0xab, 0x70, 0x16, 0x33, 0x28, 0xdb, 0x62, 0x9f, 0xfa,
0x52, 0xa4, 0xdd, 0x80, 0xaa, 0x1a, 0xcb, 0x55, 0xb8, 0xd8, 0x0b, 0x7f, 0x54, 0x08, 0x74, 0xd4,
0x17, 0x60, 0x19, 0x4d, 0x24, 0x4d, 0x81, 0x30, 0x5b, 0x2c, 0xd5, 0x53, 0xa8, 0xb6, 0xa8, 0xf4,
0xeb, 0x7f, 0x58, 0xb0, 0x3c, 0x9a, 0x8b, 0xe3, 0xca, 0xc2, 0xd2, 0x66, 0x57, 0x60, 0x09, 0xcd,
0x62, 0x67, 0x91, 0xbe, 0xd6, 0xaa, 0x0c, 0x16, 0xad, 0xaa, 0xe3, 0x39, 0xfb, 0x0c, 0x2c, 0x1a,
0x42, 0x79, 0xbc, 0x2f, 0x4c, 0x12, 0x0b, 0xf5, 0x94, 0x45, 0x2c, 0xda, 0x63, 0xa9, 0x49, 0x51,
0xc5, 0x76, 0xa1, 0x3e, 0x92, 0x7c, 0x92, 0xe5, 0x49, 0x12, 0x2a, 0xd4, 0xf3, 0x5a, 0xf5, 0x7f,
0x30, 0x8f, 0xd8, 0x64, 0x9e, 0x69, 0xca, 0xe7, 0xea, 0x7f, 0xce, 0xc0, 0x62, 0x3f, 0x67, 0x36,
0x40, 0x5f, 0x5a, 0x2c, 0x9d, 0x96, 0x2b, 0x70, 0x7e, 0x5c, 0x51, 0xe9, 0x91, 0x60, 0x6f, 0xc2,
0xb5, 0x89, 0x2a, 0xa9, 0x68, 0xcd, 0xf7, 0xe0, 0x9d, 0xa9, 0xcb, 0x67, 0x56, 0x07, 0xf8, 0x25,
0x2c, 0x8f, 0xb6, 0xd0, 0xdc, 0x7f, 0xd1, 0x42, 0xef, 0xc3, 0xad, 0x23, 0x30, 0x65, 0x2a, 0x6a,
0x9e, 0x94, 0xd7, 0x34, 0x66, 0x28, 0xc9, 0xf7, 0x42, 0x8e, 0x19, 0x4a, 0x5a, 0xb7, 0x35, 0xad,
0x4b, 0x6e, 0x00, 0xb7, 0x06, 0xf0, 0xa0, 0xc7, 0x47, 0x05, 0x2f, 0x8f, 0x85, 0xc4, 0x2a, 0x2a,
0x9c, 0xec, 0xe2, 0x9b, 0x68, 0x74, 0x87, 0x3c, 0x5a, 0xc2, 0xb4, 0xd2, 0x04, 0x97, 0x5a, 0xab,
0x3b, 0x67, 0xea, 0x60, 0xab, 0x52, 0xe1, 0x5f, 0x29, 0x22, 0x7d, 0x11, 0x25, 0x21, 0x93, 0xa6,
0x5e, 0xdc, 0xdb, 0xb0, 0x35, 0x8d, 0x97, 0x22, 0x7a, 0xf7, 0xee, 0xd0, 0xe2, 0xf9, 0x5c, 0x6d,
0x25, 0x6c, 0xc8, 0x8f, 0x23, 0x64, 0x69, 0xbb, 0xa8, 0xbe, 0x2e, 0x26, 0x5d, 0x2f, 0xe2, 0x00,
0x53, 0xad, 0x57, 0xa5, 0xbb, 0x33, 0x34, 0x43, 0xc7, 0x28, 0x9b, 0x19, 0x8a, 0x85, 0xda, 0xa6,
0x66, 0xef, 0xa9, 0x96, 0x2f, 0x62, 0x72, 0x09, 0xbc, 0x3d, 0x60, 0xa4, 0x97, 0xaa, 0x27, 0x4d,
0x9e, 0x21, 0xfe, 0xc6, 0x53, 0x96, 0x88, 0x54, 0x76, 0x51, 0xe0, 0x0e, 0x4e, 0x68, 0x4a, 0x31,
0x13, 0x32, 0xc5, 0x57, 0xb3, 0xb6, 0x6b, 0x70, 0xba, 0xdb, 0x2e, 0x04, 0xbb, 0x37, 0xa7, 0xa1,
0x26, 0x66, 0xc9, 0xfd, 0x75, 0x06, 0xbc, 0x49, 0x3d, 0x18, 0xa8, 0x97, 0xe1, 0x5c, 0xcf, 0x18,
0xf2, 0xc5, 0x63, 0x2a, 0x25, 0x8b, 0x12, 0xa9, 0x9d, 0x2d, 0xa9, 0x95, 0xa3, 0x8f, 0x80, 0xf4,
0x50, 0xf7, 0xc0, 0x80, 0x44, 0xd1, 0x05, 0x68, 0x41, 0xb5, 0x16, 0x1b, 0x7d, 0xd7, 0x27, 0x83,
0x1a, 0x7e, 0x3e, 0x97, 0x25, 0xea, 0xb3, 0x63, 0xa3, 0x99, 0xd3, 0xae, 0xb1, 0x04, 0xfa, 0x5d,
0x9b, 0xb7, 0xf9, 0x8e, 0x56, 0xcf, 0xa9, 0x79, 0x59, 0xd0, 0x2f, 0xe7, 0xe1, 0x54, 0xd7, 0x9d,
0x79, 0xa8, 0x74, 0x1e, 0xfa, 0x7a, 0xd3, 0x17, 0x01, 0xd3, 0x13, 0xb1, 0xea, 0xbe, 0xb6, 0x60,
0x6d, 0x80, 0xb5, 0xed, 0xe2, 0xee, 0x79, 0x28, 0xfc, 0x03, 0x93, 0x89, 0x37, 0xcd, 0x88, 0x9a,
0x2b, 0xa8, 0x98, 0x1e, 0x12, 0x11, 0x87, 0x87, 0xc5, 0x09, 0xa4, 0xe2, 0x62, 0xaa, 0x6c, 0x88,
0xb9, 0xf3, 0x88, 0x3c, 0x4c, 0x98, 0x59, 0xd6, 0x2f, 0x60, 0xfd, 0x78, 0x28, 0x26, 0x75, 0xa7,
0x60, 0x21, 0xcb, 0x7d, 0x5f, 0x0d, 0xcd, 0xa2, 0x67, 0x30, 0x13, 0x9d, 0x93, 0x8d, 0x86, 0x29,
0xde, 0x10, 0x87, 0x48, 0xb8, 0x7f, 0x60, 0xb6, 0x72, 0x45, 0x81, 0x67, 0x2f, 0x13, 0x8e, 0xe6,
0x49, 0xc8, 0xe3, 0x03, 0x73, 0x91, 0xdd, 0x1c, 0xaa, 0xca, 0x87, 0x34, 0x93, 0xbd, 0xdf, 0x3b,
0x4d, 0x1a, 0x37, 0xd8, 0x73, 0xec, 0xfb, 0x0e, 0x07, 0xee, 0xcf, 0xd6, 0x50, 0x95, 0x1d, 0xa1,
0x61, 0xa0, 0xbe, 0x05, 0x97, 0x7b, 0x93, 0x32, 0xa4, 0x7d, 0xd7, 0x26, 0xf1, 0xb5, 0xb8, 0x59,
0x10, 0x03, 0xcb, 0x49, 0xcb, 0x15, 0x4c, 0x19, 0xa1, 0xe2, 0xb8, 0xf8, 0x3f, 0x5c, 0x1a, 0x67,
0x4c, 0x9d, 0x5b, 0x45, 0xdd, 0x2d, 0xb8, 0x1b, 0xa3, 0x87, 0xa6, 0x61, 0x53, 0x0d, 0xc1, 0x67,
0x0c, 0x2f, 0xf1, 0x6e, 0x5e, 0xdd, 0xcf, 0x46, 0x6f, 0xa4, 0x32, 0x61, 0x13, 0x0e, 0x2e, 0xac,
0xac, 0xf8, 0x64, 0x96, 0xc5, 0x9c, 0x1e, 0x18, 0xfa, 0x53, 0x71, 0x3e, 0x6f, 0xfd, 0x53, 0x85,
0xc5, 0x3e, 0x83, 0xf6, 0xf7, 0x16, 0xac, 0x94, 0x1e, 0xcb, 0xf6, 0x86, 0x37, 0xf9, 0x11, 0x5f,
0xdf, 0xf4, 0xa6, 0x38, 0xbf, 0xdd, 0x3a, 0x9e, 0xac, 0xe7, 0x4a, 0x65, 0x3c, 0xfb, 0x3b, 0x0b,
0xce, 0x96, 0xad, 0x0b, 0xfb, 0x86, 0x37, 0xf1, 0x7d, 0x5e, 0xdf, 0x98, 0x62, 0xfd, 0xb8, 0x17,
0x10, 0xcd, 0x4a, 0x99, 0x88, 0x67, 0xff, 0x6e, 0x81, 0x7b, 0xd4, 0x14, 0x47, 0x1b, 0x79, 0x28,
0xed, 0x2d, 0x6f, 0xea, 0xed, 0x52, 0x7f, 0xd7, 0x7b, 0x83, 0x5d, 0xb1, 0x86, 0x50, 0xaf, 0x1e,
0x0f, 0xc8, 0xb3, 0x7f, 0x42, 0x16, 0xcb, 0x76, 0xc1, 0x30, 0x8b, 0x47, 0x2d, 0x9b, 0x61, 0x16,
0x8f, 0xdc, 0x2d, 0xee, 0x06, 0x42, 0x5b, 0xeb, 0x88, 0x38, 0x34, 0x76, 0x74, 0x87, 0x38, 0x66,
0xfa, 0x38, 0x0d, 0xde, 0x62, 0xb1, 0x43, 0x1d, 0xbd, 0xbc, 0xec, 0x1f, 0x2d, 0xa8, 0x8d, 0xdb,
0x01, 0xb6, 0xe7, 0x4d, 0xb5, 0x8d, 0xea, 0x37, 0xa7, 0xdc, 0x2d, 0xee, 0x2a, 0x42, 0x1d, 0xef,
0xfe, 0x95, 0x05, 0xf6, 0xe8, 0x78, 0xb3, 0xd7, 0xbd, 0x09, 0x67, 0x71, 0xfd, 0xba, 0x37, 0xe9,
0xa8, 0x74, 0xcf, 0x21, 0x92, 0x32, 0x67, 0xbf, 0x58, 0x70, 0x19, 0x2b, 0xb2, 0x6c, 0x78, 0x75,
0xda, 0xc1, 0xf3, 0xa6, 0x9a, 0x8e, 0xc3, 0x2c, 0x1d, 0x3b, 0x1b, 0xdd, 0xab, 0x88, 0xed, 0xca,
0xd1, 0x20, 0x3c, 0xfb, 0x75, 0xd1, 0xad, 0x23, 0x33, 0xa9, 0xa4, 0x5b, 0xc7, 0x0e, 0xb9, 0x92,
0x6e, 0x1d, 0x3f, 0xe3, 0xdc, 0x1a, 0xc2, 0x2a, 0x75, 0x59, 0x3f, 0x8f, 0x2f, 0x67, 0xfa, 0x0c,
0xe1, 0xff, 0xd3, 0xb4, 0xc5, 0x7d, 0x76, 0xef, 0xc4, 0x37, 0x96, 0xf5, 0x6f, 0x00, 0x00, 0x00,
0xff, 0xff, 0x3c, 0x6e, 0x05, 0xde, 0xf0, 0x10, 0x00, 0x00,
}

View File

@ -0,0 +1,694 @@
// Code generated by protoc-gen-go.
// source: steammessages_deviceauth.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type CDeviceAuth_GetOwnAuthorizedDevices_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
IncludeCanceled *bool `protobuf:"varint,2,opt,name=include_canceled" json:"include_canceled,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) Reset() {
*m = CDeviceAuth_GetOwnAuthorizedDevices_Request{}
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetOwnAuthorizedDevices_Request) ProtoMessage() {}
func (*CDeviceAuth_GetOwnAuthorizedDevices_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{0}
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) GetIncludeCanceled() bool {
if m != nil && m.IncludeCanceled != nil {
return *m.IncludeCanceled
}
return false
}
type CDeviceAuth_GetOwnAuthorizedDevices_Response struct {
Devices []*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device `protobuf:"bytes,1,rep,name=devices" json:"devices,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response) Reset() {
*m = CDeviceAuth_GetOwnAuthorizedDevices_Response{}
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetOwnAuthorizedDevices_Response) ProtoMessage() {}
func (*CDeviceAuth_GetOwnAuthorizedDevices_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{1}
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response) GetDevices() []*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device {
if m != nil {
return m.Devices
}
return nil
}
type CDeviceAuth_GetOwnAuthorizedDevices_Response_Device struct {
AuthDeviceToken *uint64 `protobuf:"fixed64,1,opt,name=auth_device_token" json:"auth_device_token,omitempty"`
DeviceName *string `protobuf:"bytes,2,opt,name=device_name" json:"device_name,omitempty"`
IsPending *bool `protobuf:"varint,3,opt,name=is_pending" json:"is_pending,omitempty"`
IsCanceled *bool `protobuf:"varint,4,opt,name=is_canceled" json:"is_canceled,omitempty"`
LastTimeUsed *uint32 `protobuf:"varint,5,opt,name=last_time_used" json:"last_time_used,omitempty"`
LastBorrowerId *uint64 `protobuf:"fixed64,6,opt,name=last_borrower_id" json:"last_borrower_id,omitempty"`
LastAppPlayed *uint32 `protobuf:"varint,7,opt,name=last_app_played" json:"last_app_played,omitempty"`
IsLimited *bool `protobuf:"varint,8,opt,name=is_limited" json:"is_limited,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) Reset() {
*m = CDeviceAuth_GetOwnAuthorizedDevices_Response_Device{}
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) ProtoMessage() {}
func (*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{1, 0}
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetAuthDeviceToken() uint64 {
if m != nil && m.AuthDeviceToken != nil {
return *m.AuthDeviceToken
}
return 0
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetDeviceName() string {
if m != nil && m.DeviceName != nil {
return *m.DeviceName
}
return ""
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetIsPending() bool {
if m != nil && m.IsPending != nil {
return *m.IsPending
}
return false
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetIsCanceled() bool {
if m != nil && m.IsCanceled != nil {
return *m.IsCanceled
}
return false
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetLastTimeUsed() uint32 {
if m != nil && m.LastTimeUsed != nil {
return *m.LastTimeUsed
}
return 0
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetLastBorrowerId() uint64 {
if m != nil && m.LastBorrowerId != nil {
return *m.LastBorrowerId
}
return 0
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetLastAppPlayed() uint32 {
if m != nil && m.LastAppPlayed != nil {
return *m.LastAppPlayed
}
return 0
}
func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetIsLimited() bool {
if m != nil && m.IsLimited != nil {
return *m.IsLimited
}
return false
}
type CDeviceAuth_AcceptAuthorizationRequest_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
AuthDeviceToken *uint64 `protobuf:"fixed64,2,opt,name=auth_device_token" json:"auth_device_token,omitempty"`
AuthCode *uint64 `protobuf:"fixed64,3,opt,name=auth_code" json:"auth_code,omitempty"`
FromSteamid *uint64 `protobuf:"fixed64,4,opt,name=from_steamid" json:"from_steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) Reset() {
*m = CDeviceAuth_AcceptAuthorizationRequest_Request{}
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_AcceptAuthorizationRequest_Request) ProtoMessage() {}
func (*CDeviceAuth_AcceptAuthorizationRequest_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{2}
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetAuthDeviceToken() uint64 {
if m != nil && m.AuthDeviceToken != nil {
return *m.AuthDeviceToken
}
return 0
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetAuthCode() uint64 {
if m != nil && m.AuthCode != nil {
return *m.AuthCode
}
return 0
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetFromSteamid() uint64 {
if m != nil && m.FromSteamid != nil {
return *m.FromSteamid
}
return 0
}
type CDeviceAuth_AcceptAuthorizationRequest_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Response) Reset() {
*m = CDeviceAuth_AcceptAuthorizationRequest_Response{}
}
func (m *CDeviceAuth_AcceptAuthorizationRequest_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_AcceptAuthorizationRequest_Response) ProtoMessage() {}
func (*CDeviceAuth_AcceptAuthorizationRequest_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{3}
}
type CDeviceAuth_AuthorizeRemoteDevice_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
AuthDeviceToken *uint64 `protobuf:"fixed64,2,opt,name=auth_device_token" json:"auth_device_token,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) Reset() {
*m = CDeviceAuth_AuthorizeRemoteDevice_Request{}
}
func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) String() string { return proto.CompactTextString(m) }
func (*CDeviceAuth_AuthorizeRemoteDevice_Request) ProtoMessage() {}
func (*CDeviceAuth_AuthorizeRemoteDevice_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{4}
}
func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) GetAuthDeviceToken() uint64 {
if m != nil && m.AuthDeviceToken != nil {
return *m.AuthDeviceToken
}
return 0
}
type CDeviceAuth_AuthorizeRemoteDevice_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_AuthorizeRemoteDevice_Response) Reset() {
*m = CDeviceAuth_AuthorizeRemoteDevice_Response{}
}
func (m *CDeviceAuth_AuthorizeRemoteDevice_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_AuthorizeRemoteDevice_Response) ProtoMessage() {}
func (*CDeviceAuth_AuthorizeRemoteDevice_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{5}
}
type CDeviceAuth_DeauthorizeRemoteDevice_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
AuthDeviceToken *uint64 `protobuf:"fixed64,2,opt,name=auth_device_token" json:"auth_device_token,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) Reset() {
*m = CDeviceAuth_DeauthorizeRemoteDevice_Request{}
}
func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_DeauthorizeRemoteDevice_Request) ProtoMessage() {}
func (*CDeviceAuth_DeauthorizeRemoteDevice_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{6}
}
func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) GetAuthDeviceToken() uint64 {
if m != nil && m.AuthDeviceToken != nil {
return *m.AuthDeviceToken
}
return 0
}
type CDeviceAuth_DeauthorizeRemoteDevice_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_DeauthorizeRemoteDevice_Response) Reset() {
*m = CDeviceAuth_DeauthorizeRemoteDevice_Response{}
}
func (m *CDeviceAuth_DeauthorizeRemoteDevice_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_DeauthorizeRemoteDevice_Response) ProtoMessage() {}
func (*CDeviceAuth_DeauthorizeRemoteDevice_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{7}
}
type CDeviceAuth_GetUsedAuthorizedDevices_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Request) Reset() {
*m = CDeviceAuth_GetUsedAuthorizedDevices_Request{}
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Request) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetUsedAuthorizedDevices_Request) ProtoMessage() {}
func (*CDeviceAuth_GetUsedAuthorizedDevices_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{8}
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CDeviceAuth_GetUsedAuthorizedDevices_Response struct {
Devices []*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device `protobuf:"bytes,1,rep,name=devices" json:"devices,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response) Reset() {
*m = CDeviceAuth_GetUsedAuthorizedDevices_Response{}
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetUsedAuthorizedDevices_Response) ProtoMessage() {}
func (*CDeviceAuth_GetUsedAuthorizedDevices_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{9}
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response) GetDevices() []*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device {
if m != nil {
return m.Devices
}
return nil
}
type CDeviceAuth_GetUsedAuthorizedDevices_Response_Device struct {
AuthDeviceToken *uint64 `protobuf:"fixed64,1,opt,name=auth_device_token" json:"auth_device_token,omitempty"`
DeviceName *string `protobuf:"bytes,2,opt,name=device_name" json:"device_name,omitempty"`
OwnerSteamid *uint64 `protobuf:"fixed64,3,opt,name=owner_steamid" json:"owner_steamid,omitempty"`
LastTimeUsed *uint32 `protobuf:"varint,4,opt,name=last_time_used" json:"last_time_used,omitempty"`
LastAppPlayed *uint32 `protobuf:"varint,5,opt,name=last_app_played" json:"last_app_played,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) Reset() {
*m = CDeviceAuth_GetUsedAuthorizedDevices_Response_Device{}
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) ProtoMessage() {}
func (*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{9, 0}
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetAuthDeviceToken() uint64 {
if m != nil && m.AuthDeviceToken != nil {
return *m.AuthDeviceToken
}
return 0
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetDeviceName() string {
if m != nil && m.DeviceName != nil {
return *m.DeviceName
}
return ""
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetOwnerSteamid() uint64 {
if m != nil && m.OwnerSteamid != nil {
return *m.OwnerSteamid
}
return 0
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetLastTimeUsed() uint32 {
if m != nil && m.LastTimeUsed != nil {
return *m.LastTimeUsed
}
return 0
}
func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetLastAppPlayed() uint32 {
if m != nil && m.LastAppPlayed != nil {
return *m.LastAppPlayed
}
return 0
}
type CDeviceAuth_GetAuthorizedBorrowers_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
IncludeCanceled *bool `protobuf:"varint,2,opt,name=include_canceled" json:"include_canceled,omitempty"`
IncludePending *bool `protobuf:"varint,3,opt,name=include_pending" json:"include_pending,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) Reset() {
*m = CDeviceAuth_GetAuthorizedBorrowers_Request{}
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetAuthorizedBorrowers_Request) ProtoMessage() {}
func (*CDeviceAuth_GetAuthorizedBorrowers_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{10}
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) GetIncludeCanceled() bool {
if m != nil && m.IncludeCanceled != nil {
return *m.IncludeCanceled
}
return false
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) GetIncludePending() bool {
if m != nil && m.IncludePending != nil {
return *m.IncludePending
}
return false
}
type CDeviceAuth_GetAuthorizedBorrowers_Response struct {
Borrowers []*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower `protobuf:"bytes,1,rep,name=borrowers" json:"borrowers,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response) Reset() {
*m = CDeviceAuth_GetAuthorizedBorrowers_Response{}
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetAuthorizedBorrowers_Response) ProtoMessage() {}
func (*CDeviceAuth_GetAuthorizedBorrowers_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{11}
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response) GetBorrowers() []*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower {
if m != nil {
return m.Borrowers
}
return nil
}
type CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
IsPending *bool `protobuf:"varint,2,opt,name=is_pending" json:"is_pending,omitempty"`
IsCanceled *bool `protobuf:"varint,3,opt,name=is_canceled" json:"is_canceled,omitempty"`
TimeCreated *uint32 `protobuf:"varint,4,opt,name=time_created" json:"time_created,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) Reset() {
*m = CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower{}
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) ProtoMessage() {}
func (*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{11, 0}
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetIsPending() bool {
if m != nil && m.IsPending != nil {
return *m.IsPending
}
return false
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetIsCanceled() bool {
if m != nil && m.IsCanceled != nil {
return *m.IsCanceled
}
return false
}
func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetTimeCreated() uint32 {
if m != nil && m.TimeCreated != nil {
return *m.TimeCreated
}
return 0
}
type CDeviceAuth_AddAuthorizedBorrowers_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
SteamidBorrower []uint64 `protobuf:"fixed64,2,rep,name=steamid_borrower" json:"steamid_borrower,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) Reset() {
*m = CDeviceAuth_AddAuthorizedBorrowers_Request{}
}
func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_AddAuthorizedBorrowers_Request) ProtoMessage() {}
func (*CDeviceAuth_AddAuthorizedBorrowers_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{12}
}
func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) GetSteamidBorrower() []uint64 {
if m != nil {
return m.SteamidBorrower
}
return nil
}
type CDeviceAuth_AddAuthorizedBorrowers_Response struct {
SecondsToWait *int32 `protobuf:"varint,1,opt,name=seconds_to_wait" json:"seconds_to_wait,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_AddAuthorizedBorrowers_Response) Reset() {
*m = CDeviceAuth_AddAuthorizedBorrowers_Response{}
}
func (m *CDeviceAuth_AddAuthorizedBorrowers_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_AddAuthorizedBorrowers_Response) ProtoMessage() {}
func (*CDeviceAuth_AddAuthorizedBorrowers_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{13}
}
func (m *CDeviceAuth_AddAuthorizedBorrowers_Response) GetSecondsToWait() int32 {
if m != nil && m.SecondsToWait != nil {
return *m.SecondsToWait
}
return 0
}
type CDeviceAuth_RemoveAuthorizedBorrowers_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
SteamidBorrower []uint64 `protobuf:"fixed64,2,rep,name=steamid_borrower" json:"steamid_borrower,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) Reset() {
*m = CDeviceAuth_RemoveAuthorizedBorrowers_Request{}
}
func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_RemoveAuthorizedBorrowers_Request) ProtoMessage() {}
func (*CDeviceAuth_RemoveAuthorizedBorrowers_Request) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{14}
}
func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) GetSteamidBorrower() []uint64 {
if m != nil {
return m.SteamidBorrower
}
return nil
}
type CDeviceAuth_RemoveAuthorizedBorrowers_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Response) Reset() {
*m = CDeviceAuth_RemoveAuthorizedBorrowers_Response{}
}
func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Response) String() string {
return proto.CompactTextString(m)
}
func (*CDeviceAuth_RemoveAuthorizedBorrowers_Response) ProtoMessage() {}
func (*CDeviceAuth_RemoveAuthorizedBorrowers_Response) Descriptor() ([]byte, []int) {
return deviceauth_fileDescriptor0, []int{15}
}
func init() {
proto.RegisterType((*CDeviceAuth_GetOwnAuthorizedDevices_Request)(nil), "CDeviceAuth_GetOwnAuthorizedDevices_Request")
proto.RegisterType((*CDeviceAuth_GetOwnAuthorizedDevices_Response)(nil), "CDeviceAuth_GetOwnAuthorizedDevices_Response")
proto.RegisterType((*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device)(nil), "CDeviceAuth_GetOwnAuthorizedDevices_Response.Device")
proto.RegisterType((*CDeviceAuth_AcceptAuthorizationRequest_Request)(nil), "CDeviceAuth_AcceptAuthorizationRequest_Request")
proto.RegisterType((*CDeviceAuth_AcceptAuthorizationRequest_Response)(nil), "CDeviceAuth_AcceptAuthorizationRequest_Response")
proto.RegisterType((*CDeviceAuth_AuthorizeRemoteDevice_Request)(nil), "CDeviceAuth_AuthorizeRemoteDevice_Request")
proto.RegisterType((*CDeviceAuth_AuthorizeRemoteDevice_Response)(nil), "CDeviceAuth_AuthorizeRemoteDevice_Response")
proto.RegisterType((*CDeviceAuth_DeauthorizeRemoteDevice_Request)(nil), "CDeviceAuth_DeauthorizeRemoteDevice_Request")
proto.RegisterType((*CDeviceAuth_DeauthorizeRemoteDevice_Response)(nil), "CDeviceAuth_DeauthorizeRemoteDevice_Response")
proto.RegisterType((*CDeviceAuth_GetUsedAuthorizedDevices_Request)(nil), "CDeviceAuth_GetUsedAuthorizedDevices_Request")
proto.RegisterType((*CDeviceAuth_GetUsedAuthorizedDevices_Response)(nil), "CDeviceAuth_GetUsedAuthorizedDevices_Response")
proto.RegisterType((*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device)(nil), "CDeviceAuth_GetUsedAuthorizedDevices_Response.Device")
proto.RegisterType((*CDeviceAuth_GetAuthorizedBorrowers_Request)(nil), "CDeviceAuth_GetAuthorizedBorrowers_Request")
proto.RegisterType((*CDeviceAuth_GetAuthorizedBorrowers_Response)(nil), "CDeviceAuth_GetAuthorizedBorrowers_Response")
proto.RegisterType((*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower)(nil), "CDeviceAuth_GetAuthorizedBorrowers_Response.Borrower")
proto.RegisterType((*CDeviceAuth_AddAuthorizedBorrowers_Request)(nil), "CDeviceAuth_AddAuthorizedBorrowers_Request")
proto.RegisterType((*CDeviceAuth_AddAuthorizedBorrowers_Response)(nil), "CDeviceAuth_AddAuthorizedBorrowers_Response")
proto.RegisterType((*CDeviceAuth_RemoveAuthorizedBorrowers_Request)(nil), "CDeviceAuth_RemoveAuthorizedBorrowers_Request")
proto.RegisterType((*CDeviceAuth_RemoveAuthorizedBorrowers_Response)(nil), "CDeviceAuth_RemoveAuthorizedBorrowers_Response")
}
var deviceauth_fileDescriptor0 = []byte{
// 934 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0xdf, 0x4e, 0x3b, 0x45,
0x14, 0xce, 0xb6, 0x50, 0x60, 0x10, 0x91, 0x51, 0xa0, 0xec, 0x85, 0x4e, 0x56, 0x2f, 0x10, 0xca,
0x80, 0x04, 0xe3, 0xff, 0x3f, 0x20, 0xa2, 0x17, 0x26, 0x26, 0x18, 0xa3, 0x72, 0xb3, 0x99, 0xee,
0x0e, 0x74, 0x62, 0xbb, 0xbb, 0xee, 0x4c, 0x69, 0xf0, 0x8a, 0x98, 0xf8, 0x12, 0xfa, 0x06, 0x5e,
0x19, 0x13, 0xa2, 0x89, 0x5e, 0xf8, 0x0e, 0xbe, 0x8d, 0x57, 0xbf, 0xb3, 0xb3, 0xb3, 0x85, 0x6d,
0x77, 0x4b, 0xb7, 0xe1, 0xaa, 0x9b, 0x73, 0xce, 0x9c, 0xf9, 0xce, 0x99, 0xf3, 0x7d, 0xa7, 0x68,
0x47, 0x2a, 0xce, 0x7a, 0x3d, 0x2e, 0x25, 0xbb, 0xe2, 0xd2, 0xf5, 0xf9, 0xb5, 0xf0, 0x38, 0xeb,
0xab, 0x0e, 0xd5, 0x0e, 0xaf, 0x2b, 0x78, 0xa0, 0x68, 0x14, 0x87, 0x2a, 0xb4, 0x5b, 0xf9, 0xd8,
0x7e, 0x20, 0x2e, 0x05, 0xf7, 0xdd, 0x36, 0x93, 0x7c, 0x3c, 0xda, 0xf9, 0x16, 0xed, 0x7e, 0x72,
0xaa, 0xd3, 0x1d, 0x43, 0x3a, 0xf7, 0x33, 0xae, 0xbe, 0x1c, 0x04, 0xc9, 0x67, 0x18, 0x8b, 0x1f,
0xb9, 0x9f, 0xba, 0xa4, 0x7b, 0xce, 0x7f, 0xe8, 0x73, 0xa9, 0xf0, 0x2a, 0x5a, 0xd0, 0x39, 0x84,
0xdf, 0xb4, 0x88, 0xb5, 0xdd, 0xc0, 0x4d, 0xf4, 0x82, 0x08, 0xbc, 0x6e, 0xdf, 0xe7, 0xae, 0xc7,
0x02, 0x8f, 0x77, 0xb9, 0xdf, 0xac, 0x81, 0x67, 0xd1, 0xf9, 0xab, 0x86, 0x5a, 0xd3, 0xa5, 0x96,
0x51, 0x18, 0x48, 0x8e, 0x3f, 0x45, 0x0b, 0x69, 0x61, 0x12, 0x72, 0xd7, 0xb7, 0x97, 0x0f, 0x8f,
0x68, 0x95, 0xf3, 0x34, 0x35, 0xd8, 0xff, 0x5a, 0xa8, 0x91, 0x7e, 0xe2, 0x2d, 0xb4, 0x96, 0x34,
0xc9, 0xf4, 0xcb, 0x55, 0xe1, 0xf7, 0x3c, 0x30, 0xb8, 0x5f, 0x44, 0xcb, 0xc6, 0x1a, 0xb0, 0x1e,
0xd7, 0x90, 0x97, 0x30, 0x46, 0x48, 0x48, 0x37, 0xe2, 0x81, 0x2f, 0x82, 0xab, 0x66, 0x3d, 0x29,
0x23, 0x09, 0x04, 0xdb, 0xb0, 0xb6, 0x39, 0x6d, 0xdc, 0x40, 0xcf, 0x77, 0x99, 0x54, 0xae, 0x12,
0x3d, 0xee, 0xf6, 0x25, 0xd8, 0xe7, 0xc1, 0xbe, 0x92, 0x74, 0x43, 0xdb, 0xdb, 0x61, 0x1c, 0x87,
0x03, 0x1e, 0xbb, 0xd0, 0xa7, 0x86, 0xbe, 0x6f, 0x13, 0xad, 0x6a, 0x0f, 0x8b, 0x22, 0x37, 0xea,
0xb2, 0x1b, 0x38, 0xb2, 0xa0, 0x8f, 0xa4, 0x77, 0x76, 0x45, 0x4f, 0x28, 0xb0, 0x2d, 0xea, 0xd6,
0xfd, 0x6c, 0xa1, 0x5c, 0xe9, 0xc7, 0x9e, 0xc7, 0x23, 0x95, 0x95, 0xce, 0x94, 0x08, 0x03, 0xf3,
0x20, 0xe5, 0x0f, 0x53, 0x58, 0x7b, 0x4d, 0xbb, 0xd6, 0xd0, 0x92, 0x76, 0x79, 0xa1, 0xcf, 0x75,
0x95, 0x0d, 0xfc, 0x12, 0x7a, 0xee, 0x32, 0x0e, 0x7b, 0x6e, 0x96, 0x23, 0x29, 0xb3, 0xe1, 0xbc,
0x81, 0xf6, 0xa7, 0x86, 0x91, 0x3e, 0x82, 0xf3, 0x0d, 0x7a, 0x3d, 0x77, 0x24, 0x7b, 0xae, 0x73,
0xde, 0x0b, 0x15, 0x4f, 0x3d, 0xb3, 0x80, 0x76, 0x5a, 0x68, 0x67, 0x9a, 0xc4, 0x06, 0xc6, 0x77,
0xf9, 0xb1, 0x3e, 0xd5, 0x64, 0x79, 0x1a, 0x20, 0x34, 0x3f, 0xd6, 0xe5, 0xa9, 0x0d, 0x94, 0x8f,
0xc6, 0x68, 0xf0, 0x35, 0x0c, 0xcc, 0xf4, 0x14, 0x73, 0xfe, 0xb7, 0xd0, 0xde, 0x94, 0x19, 0x0c,
0x93, 0xce, 0x46, 0x99, 0xf4, 0x26, 0xad, 0x94, 0x20, 0xa3, 0xd2, 0xed, 0xec, 0x54, 0x5a, 0x47,
0x2b, 0xe1, 0x20, 0x00, 0x06, 0x64, 0xb5, 0xa4, 0x73, 0x36, 0x4e, 0x9c, 0x39, 0xcd, 0x82, 0x02,
0x7a, 0x68, 0x46, 0x39, 0x51, 0xfe, 0xd9, 0x01, 0xfa, 0x3d, 0xec, 0x13, 0xc3, 0xb2, 0x59, 0xe4,
0x29, 0xb9, 0x31, 0xf3, 0xe4, 0x08, 0xef, 0xfc, 0x67, 0x8d, 0x49, 0x62, 0xf1, 0x95, 0xa6, 0xd9,
0x9f, 0xa3, 0xa5, 0x8c, 0xee, 0xa5, 0xed, 0x9e, 0x94, 0x80, 0x66, 0x26, 0xfb, 0x02, 0x2d, 0x66,
0xdf, 0xe3, 0x95, 0xe4, 0xb5, 0xa9, 0x56, 0xa4, 0x4d, 0xa9, 0x60, 0x01, 0x95, 0x75, 0x77, 0xbd,
0x98, 0x33, 0x95, 0x35, 0x18, 0x78, 0x99, 0xa7, 0x8f, 0xef, 0x57, 0xed, 0xa3, 0x31, 0x0c, 0xb5,
0x0d, 0x30, 0xd4, 0x61, 0x3a, 0xcf, 0xf2, 0xdd, 0x2a, 0x4d, 0x6c, 0xba, 0x05, 0x6d, 0x97, 0xdc,
0x0b, 0x03, 0x5f, 0xc2, 0x0c, 0xb9, 0x03, 0x26, 0x94, 0xbe, 0x61, 0xde, 0xb9, 0xc8, 0x0f, 0x79,
0xc2, 0xa5, 0x6b, 0xfe, 0x44, 0x18, 0x0f, 0xf2, 0x72, 0x3a, 0x29, 0x77, 0x0a, 0xf3, 0xf0, 0xcf,
0x65, 0x84, 0xee, 0x4f, 0xe0, 0x5f, 0x2c, 0xb4, 0x59, 0xb2, 0x7f, 0x70, 0x8b, 0x56, 0x58, 0xa0,
0xf6, 0x5e, 0xa5, 0x9d, 0xe6, 0x38, 0x3f, 0xdd, 0x35, 0x5f, 0x86, 0x28, 0xd2, 0x15, 0x52, 0x91,
0xf0, 0x92, 0x0c, 0xc5, 0xc6, 0x27, 0x86, 0xe2, 0xf8, 0xce, 0x42, 0x76, 0xb9, 0x34, 0xe3, 0xfd,
0x8a, 0xab, 0xc4, 0x3e, 0xa0, 0x55, 0x45, 0xff, 0x08, 0x50, 0x1e, 0xa4, 0x81, 0x84, 0x05, 0x43,
0x8c, 0x3a, 0x98, 0xc4, 0x69, 0x34, 0x69, 0xdf, 0x80, 0x2f, 0x54, 0x1d, 0x1e, 0x13, 0x20, 0x7e,
0x2c, 0xf1, 0x6f, 0x16, 0x5a, 0x2f, 0x94, 0x71, 0xbc, 0x43, 0xa7, 0xde, 0x21, 0xf6, 0x2e, 0xad,
0xb0, 0x16, 0xde, 0x06, 0xa0, 0x47, 0xc3, 0x18, 0x02, 0x0a, 0x05, 0xf0, 0x92, 0x40, 0xd3, 0x4c,
0xa2, 0x3a, 0x4c, 0x91, 0x0e, 0x93, 0xc4, 0x10, 0x2d, 0x43, 0x8f, 0x7f, 0x85, 0x09, 0x28, 0x91,
0xfa, 0x91, 0x09, 0x78, 0x64, 0xd7, 0x8c, 0x4c, 0xc0, 0xa3, 0xeb, 0xe3, 0x55, 0x80, 0xfc, 0xca,
0x39, 0xbf, 0x06, 0xc1, 0xd5, 0x78, 0x0d, 0xd0, 0x5c, 0x8f, 0xf1, 0xdf, 0x16, 0x6a, 0x96, 0xa9,
0x3a, 0xde, 0xa3, 0x55, 0xf6, 0x8f, 0x4d, 0xab, 0xed, 0x0a, 0xe7, 0x63, 0x00, 0xf8, 0xfe, 0xe4,
0x11, 0xd5, 0x0f, 0x4e, 0x52, 0x5d, 0x27, 0x86, 0x9b, 0x3e, 0xb9, 0x82, 0x6d, 0x21, 0x09, 0xa0,
0xff, 0xc3, 0x42, 0x1b, 0xc5, 0x22, 0x89, 0x77, 0xe9, 0xf4, 0xea, 0x6f, 0xb7, 0xaa, 0xc8, 0xae,
0xf3, 0x01, 0xe0, 0x7e, 0xe7, 0x21, 0x6e, 0x3d, 0x95, 0xe9, 0x04, 0x80, 0xa4, 0x1a, 0x9c, 0x80,
0xef, 0xe1, 0x48, 0x0f, 0x6b, 0xc2, 0xbf, 0x03, 0xe8, 0x62, 0xb1, 0x1b, 0x01, 0x3d, 0x59, 0x6a,
0x47, 0x40, 0x3f, 0x22, 0x9f, 0xce, 0x7b, 0x00, 0xfa, 0x2d, 0x08, 0x2a, 0x07, 0x6b, 0xfe, 0x49,
0x16, 0x09, 0xc5, 0x3f, 0x16, 0xda, 0x2a, 0xd5, 0x3e, 0x4c, 0x69, 0x25, 0xfd, 0xb5, 0xf7, 0x2b,
0x6a, 0xaa, 0xf3, 0x21, 0x60, 0x7f, 0x37, 0x8d, 0x9b, 0x05, 0xbe, 0xfd, 0x1a, 0x9c, 0x27, 0x5f,
0x88, 0x76, 0xcc, 0xe2, 0x1b, 0xf2, 0x55, 0x87, 0xc5, 0x09, 0x3f, 0x25, 0x57, 0x0a, 0x7e, 0x25,
0x7c, 0xc4, 0x49, 0xd8, 0x49, 0xfd, 0xd6, 0xb2, 0x9e, 0x05, 0x00, 0x00, 0xff, 0xff, 0x27, 0xc5,
0x15, 0xba, 0x30, 0x0d, 0x00, 0x00,
}

View File

@ -0,0 +1,850 @@
// Code generated by protoc-gen-go.
// source: steammessages_gamenotifications.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type CGameNotifications_Variable struct {
Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_Variable) Reset() { *m = CGameNotifications_Variable{} }
func (m *CGameNotifications_Variable) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_Variable) ProtoMessage() {}
func (*CGameNotifications_Variable) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{0} }
func (m *CGameNotifications_Variable) GetKey() string {
if m != nil && m.Key != nil {
return *m.Key
}
return ""
}
func (m *CGameNotifications_Variable) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type CGameNotifications_LocalizedText struct {
Token *string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"`
Variables []*CGameNotifications_Variable `protobuf:"bytes,2,rep,name=variables" json:"variables,omitempty"`
RenderedText *string `protobuf:"bytes,3,opt,name=rendered_text" json:"rendered_text,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_LocalizedText) Reset() { *m = CGameNotifications_LocalizedText{} }
func (m *CGameNotifications_LocalizedText) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_LocalizedText) ProtoMessage() {}
func (*CGameNotifications_LocalizedText) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{1}
}
func (m *CGameNotifications_LocalizedText) GetToken() string {
if m != nil && m.Token != nil {
return *m.Token
}
return ""
}
func (m *CGameNotifications_LocalizedText) GetVariables() []*CGameNotifications_Variable {
if m != nil {
return m.Variables
}
return nil
}
func (m *CGameNotifications_LocalizedText) GetRenderedText() string {
if m != nil && m.RenderedText != nil {
return *m.RenderedText
}
return ""
}
type CGameNotifications_UserStatus struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
State *string `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"`
Title *CGameNotifications_LocalizedText `protobuf:"bytes,3,opt,name=title" json:"title,omitempty"`
Message *CGameNotifications_LocalizedText `protobuf:"bytes,4,opt,name=message" json:"message,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_UserStatus) Reset() { *m = CGameNotifications_UserStatus{} }
func (m *CGameNotifications_UserStatus) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_UserStatus) ProtoMessage() {}
func (*CGameNotifications_UserStatus) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{2} }
func (m *CGameNotifications_UserStatus) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CGameNotifications_UserStatus) GetState() string {
if m != nil && m.State != nil {
return *m.State
}
return ""
}
func (m *CGameNotifications_UserStatus) GetTitle() *CGameNotifications_LocalizedText {
if m != nil {
return m.Title
}
return nil
}
func (m *CGameNotifications_UserStatus) GetMessage() *CGameNotifications_LocalizedText {
if m != nil {
return m.Message
}
return nil
}
type CGameNotifications_CreateSession_Request struct {
Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
Context *uint64 `protobuf:"varint,2,opt,name=context" json:"context,omitempty"`
Title *CGameNotifications_LocalizedText `protobuf:"bytes,3,opt,name=title" json:"title,omitempty"`
Users []*CGameNotifications_UserStatus `protobuf:"bytes,4,rep,name=users" json:"users,omitempty"`
Steamid *uint64 `protobuf:"fixed64,5,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_CreateSession_Request) Reset() {
*m = CGameNotifications_CreateSession_Request{}
}
func (m *CGameNotifications_CreateSession_Request) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_CreateSession_Request) ProtoMessage() {}
func (*CGameNotifications_CreateSession_Request) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{3}
}
func (m *CGameNotifications_CreateSession_Request) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CGameNotifications_CreateSession_Request) GetContext() uint64 {
if m != nil && m.Context != nil {
return *m.Context
}
return 0
}
func (m *CGameNotifications_CreateSession_Request) GetTitle() *CGameNotifications_LocalizedText {
if m != nil {
return m.Title
}
return nil
}
func (m *CGameNotifications_CreateSession_Request) GetUsers() []*CGameNotifications_UserStatus {
if m != nil {
return m.Users
}
return nil
}
func (m *CGameNotifications_CreateSession_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CGameNotifications_CreateSession_Response struct {
Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_CreateSession_Response) Reset() {
*m = CGameNotifications_CreateSession_Response{}
}
func (m *CGameNotifications_CreateSession_Response) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_CreateSession_Response) ProtoMessage() {}
func (*CGameNotifications_CreateSession_Response) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{4}
}
func (m *CGameNotifications_CreateSession_Response) GetSessionid() uint64 {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return 0
}
type CGameNotifications_DeleteSession_Request struct {
Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"`
Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
Steamid *uint64 `protobuf:"fixed64,3,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_DeleteSession_Request) Reset() {
*m = CGameNotifications_DeleteSession_Request{}
}
func (m *CGameNotifications_DeleteSession_Request) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_DeleteSession_Request) ProtoMessage() {}
func (*CGameNotifications_DeleteSession_Request) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{5}
}
func (m *CGameNotifications_DeleteSession_Request) GetSessionid() uint64 {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return 0
}
func (m *CGameNotifications_DeleteSession_Request) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CGameNotifications_DeleteSession_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CGameNotifications_DeleteSession_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_DeleteSession_Response) Reset() {
*m = CGameNotifications_DeleteSession_Response{}
}
func (m *CGameNotifications_DeleteSession_Response) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_DeleteSession_Response) ProtoMessage() {}
func (*CGameNotifications_DeleteSession_Response) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{6}
}
type CGameNotifications_UpdateSession_Request struct {
Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"`
Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
Title *CGameNotifications_LocalizedText `protobuf:"bytes,3,opt,name=title" json:"title,omitempty"`
Users []*CGameNotifications_UserStatus `protobuf:"bytes,4,rep,name=users" json:"users,omitempty"`
Steamid *uint64 `protobuf:"fixed64,6,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_UpdateSession_Request) Reset() {
*m = CGameNotifications_UpdateSession_Request{}
}
func (m *CGameNotifications_UpdateSession_Request) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_UpdateSession_Request) ProtoMessage() {}
func (*CGameNotifications_UpdateSession_Request) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{7}
}
func (m *CGameNotifications_UpdateSession_Request) GetSessionid() uint64 {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return 0
}
func (m *CGameNotifications_UpdateSession_Request) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CGameNotifications_UpdateSession_Request) GetTitle() *CGameNotifications_LocalizedText {
if m != nil {
return m.Title
}
return nil
}
func (m *CGameNotifications_UpdateSession_Request) GetUsers() []*CGameNotifications_UserStatus {
if m != nil {
return m.Users
}
return nil
}
func (m *CGameNotifications_UpdateSession_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CGameNotifications_UpdateSession_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_UpdateSession_Response) Reset() {
*m = CGameNotifications_UpdateSession_Response{}
}
func (m *CGameNotifications_UpdateSession_Response) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_UpdateSession_Response) ProtoMessage() {}
func (*CGameNotifications_UpdateSession_Response) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{8}
}
type CGameNotifications_EnumerateSessions_Request struct {
Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
IncludeAllUserMessages *bool `protobuf:"varint,3,opt,name=include_all_user_messages" json:"include_all_user_messages,omitempty"`
IncludeAuthUserMessage *bool `protobuf:"varint,4,opt,name=include_auth_user_message" json:"include_auth_user_message,omitempty"`
Language *string `protobuf:"bytes,5,opt,name=language" json:"language,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_EnumerateSessions_Request) Reset() {
*m = CGameNotifications_EnumerateSessions_Request{}
}
func (m *CGameNotifications_EnumerateSessions_Request) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_EnumerateSessions_Request) ProtoMessage() {}
func (*CGameNotifications_EnumerateSessions_Request) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{9}
}
func (m *CGameNotifications_EnumerateSessions_Request) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CGameNotifications_EnumerateSessions_Request) GetIncludeAllUserMessages() bool {
if m != nil && m.IncludeAllUserMessages != nil {
return *m.IncludeAllUserMessages
}
return false
}
func (m *CGameNotifications_EnumerateSessions_Request) GetIncludeAuthUserMessage() bool {
if m != nil && m.IncludeAuthUserMessage != nil {
return *m.IncludeAuthUserMessage
}
return false
}
func (m *CGameNotifications_EnumerateSessions_Request) GetLanguage() string {
if m != nil && m.Language != nil {
return *m.Language
}
return ""
}
type CGameNotifications_Session struct {
Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"`
Appid *uint64 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
Context *uint64 `protobuf:"varint,3,opt,name=context" json:"context,omitempty"`
Title *CGameNotifications_LocalizedText `protobuf:"bytes,4,opt,name=title" json:"title,omitempty"`
TimeCreated *uint32 `protobuf:"varint,5,opt,name=time_created" json:"time_created,omitempty"`
TimeUpdated *uint32 `protobuf:"varint,6,opt,name=time_updated" json:"time_updated,omitempty"`
UserStatus []*CGameNotifications_UserStatus `protobuf:"bytes,7,rep,name=user_status" json:"user_status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_Session) Reset() { *m = CGameNotifications_Session{} }
func (m *CGameNotifications_Session) String() string { return proto.CompactTextString(m) }
func (*CGameNotifications_Session) ProtoMessage() {}
func (*CGameNotifications_Session) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{10} }
func (m *CGameNotifications_Session) GetSessionid() uint64 {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return 0
}
func (m *CGameNotifications_Session) GetAppid() uint64 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CGameNotifications_Session) GetContext() uint64 {
if m != nil && m.Context != nil {
return *m.Context
}
return 0
}
func (m *CGameNotifications_Session) GetTitle() *CGameNotifications_LocalizedText {
if m != nil {
return m.Title
}
return nil
}
func (m *CGameNotifications_Session) GetTimeCreated() uint32 {
if m != nil && m.TimeCreated != nil {
return *m.TimeCreated
}
return 0
}
func (m *CGameNotifications_Session) GetTimeUpdated() uint32 {
if m != nil && m.TimeUpdated != nil {
return *m.TimeUpdated
}
return 0
}
func (m *CGameNotifications_Session) GetUserStatus() []*CGameNotifications_UserStatus {
if m != nil {
return m.UserStatus
}
return nil
}
type CGameNotifications_EnumerateSessions_Response struct {
Sessions []*CGameNotifications_Session `protobuf:"bytes,1,rep,name=sessions" json:"sessions,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_EnumerateSessions_Response) Reset() {
*m = CGameNotifications_EnumerateSessions_Response{}
}
func (m *CGameNotifications_EnumerateSessions_Response) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_EnumerateSessions_Response) ProtoMessage() {}
func (*CGameNotifications_EnumerateSessions_Response) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{11}
}
func (m *CGameNotifications_EnumerateSessions_Response) GetSessions() []*CGameNotifications_Session {
if m != nil {
return m.Sessions
}
return nil
}
type CGameNotifications_GetSessionDetails_Request struct {
Sessions []*CGameNotifications_GetSessionDetails_Request_RequestedSession `protobuf:"bytes,1,rep,name=sessions" json:"sessions,omitempty"`
Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
Language *string `protobuf:"bytes,3,opt,name=language" json:"language,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_GetSessionDetails_Request) Reset() {
*m = CGameNotifications_GetSessionDetails_Request{}
}
func (m *CGameNotifications_GetSessionDetails_Request) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_GetSessionDetails_Request) ProtoMessage() {}
func (*CGameNotifications_GetSessionDetails_Request) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{12}
}
func (m *CGameNotifications_GetSessionDetails_Request) GetSessions() []*CGameNotifications_GetSessionDetails_Request_RequestedSession {
if m != nil {
return m.Sessions
}
return nil
}
func (m *CGameNotifications_GetSessionDetails_Request) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CGameNotifications_GetSessionDetails_Request) GetLanguage() string {
if m != nil && m.Language != nil {
return *m.Language
}
return ""
}
type CGameNotifications_GetSessionDetails_Request_RequestedSession struct {
Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"`
IncludeAuthUserMessage *bool `protobuf:"varint,3,opt,name=include_auth_user_message" json:"include_auth_user_message,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) Reset() {
*m = CGameNotifications_GetSessionDetails_Request_RequestedSession{}
}
func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_GetSessionDetails_Request_RequestedSession) ProtoMessage() {}
func (*CGameNotifications_GetSessionDetails_Request_RequestedSession) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{12, 0}
}
func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) GetSessionid() uint64 {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return 0
}
func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) GetIncludeAuthUserMessage() bool {
if m != nil && m.IncludeAuthUserMessage != nil {
return *m.IncludeAuthUserMessage
}
return false
}
type CGameNotifications_GetSessionDetails_Response struct {
Sessions []*CGameNotifications_Session `protobuf:"bytes,1,rep,name=sessions" json:"sessions,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_GetSessionDetails_Response) Reset() {
*m = CGameNotifications_GetSessionDetails_Response{}
}
func (m *CGameNotifications_GetSessionDetails_Response) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_GetSessionDetails_Response) ProtoMessage() {}
func (*CGameNotifications_GetSessionDetails_Response) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{13}
}
func (m *CGameNotifications_GetSessionDetails_Response) GetSessions() []*CGameNotifications_Session {
if m != nil {
return m.Sessions
}
return nil
}
type GameNotificationSettings struct {
Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
AllowNotifications *bool `protobuf:"varint,2,opt,name=allow_notifications" json:"allow_notifications,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GameNotificationSettings) Reset() { *m = GameNotificationSettings{} }
func (m *GameNotificationSettings) String() string { return proto.CompactTextString(m) }
func (*GameNotificationSettings) ProtoMessage() {}
func (*GameNotificationSettings) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{14} }
func (m *GameNotificationSettings) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *GameNotificationSettings) GetAllowNotifications() bool {
if m != nil && m.AllowNotifications != nil {
return *m.AllowNotifications
}
return false
}
type CGameNotifications_UpdateNotificationSettings_Request struct {
GameNotificationSettings []*GameNotificationSettings `protobuf:"bytes,1,rep,name=game_notification_settings" json:"game_notification_settings,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_UpdateNotificationSettings_Request) Reset() {
*m = CGameNotifications_UpdateNotificationSettings_Request{}
}
func (m *CGameNotifications_UpdateNotificationSettings_Request) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_UpdateNotificationSettings_Request) ProtoMessage() {}
func (*CGameNotifications_UpdateNotificationSettings_Request) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{15}
}
func (m *CGameNotifications_UpdateNotificationSettings_Request) GetGameNotificationSettings() []*GameNotificationSettings {
if m != nil {
return m.GameNotificationSettings
}
return nil
}
type CGameNotifications_UpdateNotificationSettings_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_UpdateNotificationSettings_Response) Reset() {
*m = CGameNotifications_UpdateNotificationSettings_Response{}
}
func (m *CGameNotifications_UpdateNotificationSettings_Response) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_UpdateNotificationSettings_Response) ProtoMessage() {}
func (*CGameNotifications_UpdateNotificationSettings_Response) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{16}
}
type CGameNotifications_OnNotificationsRequested_Notification struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_OnNotificationsRequested_Notification) Reset() {
*m = CGameNotifications_OnNotificationsRequested_Notification{}
}
func (m *CGameNotifications_OnNotificationsRequested_Notification) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_OnNotificationsRequested_Notification) ProtoMessage() {}
func (*CGameNotifications_OnNotificationsRequested_Notification) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{17}
}
func (m *CGameNotifications_OnNotificationsRequested_Notification) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CGameNotifications_OnNotificationsRequested_Notification) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
type CGameNotifications_OnUserStatusChanged_Notification struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
Sessionid *uint64 `protobuf:"varint,2,opt,name=sessionid" json:"sessionid,omitempty"`
Appid *uint32 `protobuf:"varint,3,opt,name=appid" json:"appid,omitempty"`
Status *CGameNotifications_UserStatus `protobuf:"bytes,4,opt,name=status" json:"status,omitempty"`
Removed *bool `protobuf:"varint,5,opt,name=removed" json:"removed,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CGameNotifications_OnUserStatusChanged_Notification) Reset() {
*m = CGameNotifications_OnUserStatusChanged_Notification{}
}
func (m *CGameNotifications_OnUserStatusChanged_Notification) String() string {
return proto.CompactTextString(m)
}
func (*CGameNotifications_OnUserStatusChanged_Notification) ProtoMessage() {}
func (*CGameNotifications_OnUserStatusChanged_Notification) Descriptor() ([]byte, []int) {
return gamenotifications_fileDescriptor0, []int{18}
}
func (m *CGameNotifications_OnUserStatusChanged_Notification) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CGameNotifications_OnUserStatusChanged_Notification) GetSessionid() uint64 {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return 0
}
func (m *CGameNotifications_OnUserStatusChanged_Notification) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CGameNotifications_OnUserStatusChanged_Notification) GetStatus() *CGameNotifications_UserStatus {
if m != nil {
return m.Status
}
return nil
}
func (m *CGameNotifications_OnUserStatusChanged_Notification) GetRemoved() bool {
if m != nil && m.Removed != nil {
return *m.Removed
}
return false
}
func init() {
proto.RegisterType((*CGameNotifications_Variable)(nil), "CGameNotifications_Variable")
proto.RegisterType((*CGameNotifications_LocalizedText)(nil), "CGameNotifications_LocalizedText")
proto.RegisterType((*CGameNotifications_UserStatus)(nil), "CGameNotifications_UserStatus")
proto.RegisterType((*CGameNotifications_CreateSession_Request)(nil), "CGameNotifications_CreateSession_Request")
proto.RegisterType((*CGameNotifications_CreateSession_Response)(nil), "CGameNotifications_CreateSession_Response")
proto.RegisterType((*CGameNotifications_DeleteSession_Request)(nil), "CGameNotifications_DeleteSession_Request")
proto.RegisterType((*CGameNotifications_DeleteSession_Response)(nil), "CGameNotifications_DeleteSession_Response")
proto.RegisterType((*CGameNotifications_UpdateSession_Request)(nil), "CGameNotifications_UpdateSession_Request")
proto.RegisterType((*CGameNotifications_UpdateSession_Response)(nil), "CGameNotifications_UpdateSession_Response")
proto.RegisterType((*CGameNotifications_EnumerateSessions_Request)(nil), "CGameNotifications_EnumerateSessions_Request")
proto.RegisterType((*CGameNotifications_Session)(nil), "CGameNotifications_Session")
proto.RegisterType((*CGameNotifications_EnumerateSessions_Response)(nil), "CGameNotifications_EnumerateSessions_Response")
proto.RegisterType((*CGameNotifications_GetSessionDetails_Request)(nil), "CGameNotifications_GetSessionDetails_Request")
proto.RegisterType((*CGameNotifications_GetSessionDetails_Request_RequestedSession)(nil), "CGameNotifications_GetSessionDetails_Request.RequestedSession")
proto.RegisterType((*CGameNotifications_GetSessionDetails_Response)(nil), "CGameNotifications_GetSessionDetails_Response")
proto.RegisterType((*GameNotificationSettings)(nil), "GameNotificationSettings")
proto.RegisterType((*CGameNotifications_UpdateNotificationSettings_Request)(nil), "CGameNotifications_UpdateNotificationSettings_Request")
proto.RegisterType((*CGameNotifications_UpdateNotificationSettings_Response)(nil), "CGameNotifications_UpdateNotificationSettings_Response")
proto.RegisterType((*CGameNotifications_OnNotificationsRequested_Notification)(nil), "CGameNotifications_OnNotificationsRequested_Notification")
proto.RegisterType((*CGameNotifications_OnUserStatusChanged_Notification)(nil), "CGameNotifications_OnUserStatusChanged_Notification")
}
var gamenotifications_fileDescriptor0 = []byte{
// 2245 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x8f, 0x1c, 0x47,
0x15, 0x57, 0xef, 0xec, 0x7a, 0xd7, 0x65, 0x2c, 0x91, 0x0e, 0x12, 0x93, 0xb1, 0xe3, 0xb4, 0x3b,
0x38, 0xde, 0x8d, 0x77, 0xcb, 0x78, 0x43, 0xfc, 0x01, 0x24, 0xc2, 0xbd, 0x8e, 0x4c, 0x24, 0xb3,
0x49, 0xbc, 0x9b, 0x60, 0x21, 0xc4, 0xa8, 0xa6, 0xbb, 0x66, 0xa7, 0xb3, 0x3d, 0xdd, 0x43, 0x57,
0xf5, 0x6e, 0x36, 0x07, 0x82, 0xcc, 0xd7, 0x09, 0x82, 0x48, 0x22, 0x40, 0x48, 0x91, 0x90, 0x50,
0xc4, 0x81, 0x0b, 0x87, 0x1c, 0x41, 0x48, 0x91, 0x38, 0x72, 0xcc, 0x15, 0xce, 0xfc, 0x15, 0xbc,
0xfa, 0xec, 0xee, 0x99, 0x1e, 0xef, 0xcc, 0x22, 0x11, 0x71, 0xb1, 0x3c, 0x5d, 0xf5, 0xde, 0xfb,
0xd5, 0x7b, 0xbf, 0xf7, 0x51, 0xb5, 0xe8, 0x1a, 0xe3, 0x94, 0x0c, 0x87, 0x94, 0x31, 0xb2, 0x47,
0x59, 0x77, 0x8f, 0x0c, 0x69, 0x9a, 0xf1, 0xb8, 0x1f, 0x87, 0x84, 0xc7, 0x59, 0xca, 0xb0, 0x5c,
0x0f, 0x93, 0x98, 0xa6, 0x1c, 0x8f, 0xf2, 0x8c, 0x67, 0x9d, 0xf5, 0xba, 0x48, 0x91, 0xc2, 0x6e,
0x1a, 0x75, 0x7b, 0x84, 0xd1, 0xc9, 0xdd, 0xfe, 0xbf, 0x16, 0xd0, 0xb9, 0xad, 0xbb, 0xa0, 0x76,
0xbb, 0xaa, 0xb6, 0xfb, 0x06, 0xc9, 0x63, 0xd2, 0x4b, 0xa8, 0xfb, 0x91, 0x83, 0x5a, 0xfb, 0xf4,
0xa8, 0xed, 0x78, 0xce, 0xea, 0xe9, 0xe0, 0x37, 0xce, 0xc3, 0x8f, 0xdb, 0xef, 0x39, 0xbb, 0x03,
0xea, 0xa5, 0x20, 0xe3, 0x65, 0x7d, 0x8f, 0xc3, 0xff, 0x0f, 0xf4, 0x6e, 0x2f, 0x4e, 0xe5, 0xef,
0x24, 0x0b, 0x49, 0x12, 0xbf, 0x4d, 0x23, 0x8f, 0xd3, 0xb7, 0xb8, 0xb7, 0xb1, 0xe1, 0x91, 0xf4,
0xe8, 0x70, 0x40, 0x73, 0x0a, 0xcb, 0x84, 0x7b, 0x97, 0x8c, 0x80, 0x50, 0x72, 0xc9, 0x8b, 0x99,
0xd7, 0xcf, 0x8a, 0x34, 0xf2, 0x0e, 0x63, 0x3e, 0xd0, 0x2a, 0xa4, 0x60, 0xcc, 0xe1, 0x53, 0x92,
0x78, 0x3d, 0xea, 0xb1, 0xa2, 0xc7, 0x78, 0xcc, 0x8b, 0x88, 0xaa, 0x6d, 0x72, 0xd3, 0x5e, 0x7c,
0x40, 0x53, 0xb0, 0x9e, 0x14, 0xd4, 0xfd, 0xb5, 0x83, 0x96, 0xe4, 0xff, 0xda, 0x0b, 0x12, 0xea,
0xcf, 0x04, 0xd4, 0x87, 0x12, 0xaa, 0xfc, 0x3c, 0x81, 0x95, 0x67, 0x56, 0x29, 0x9f, 0x86, 0x1c,
0xbe, 0x8e, 0x12, 0x12, 0x5a, 0x61, 0x63, 0x50, 0xa9, 0xc0, 0x9e, 0xb7, 0x45, 0x52, 0x40, 0xc9,
0x68, 0xd2, 0x17, 0x20, 0x89, 0x91, 0x97, 0x5e, 0x04, 0x0b, 0xfb, 0x34, 0xc5, 0xfe, 0x4f, 0x5a,
0xc8, 0x6b, 0x70, 0xf1, 0x3d, 0x63, 0x6a, 0x17, 0x2c, 0xb9, 0xdf, 0x44, 0x4b, 0x72, 0xbb, 0x76,
0xf4, 0x2d, 0x00, 0xff, 0xfc, 0xed, 0x06, 0x75, 0xca, 0x81, 0x43, 0x32, 0x62, 0xe2, 0x00, 0x02,
0x53, 0x44, 0x59, 0x9c, 0x03, 0x60, 0xc6, 0xf3, 0x38, 0xdd, 0xc3, 0xee, 0xcf, 0x1d, 0x74, 0xda,
0x20, 0x64, 0xe0, 0x8c, 0xd6, 0xea, 0x99, 0xcd, 0xf3, 0xf8, 0x11, 0x31, 0x0e, 0xbe, 0x0b, 0xc6,
0x1e, 0x80, 0xb1, 0x98, 0x71, 0x71, 0x50, 0x2b, 0xac, 0x1c, 0xc7, 0x26, 0x3d, 0x05, 0xd1, 0xac,
0xec, 0x52, 0xb1, 0x9b, 0x70, 0xa0, 0xc1, 0xf3, 0x53, 0x07, 0x9d, 0xcd, 0x69, 0x1a, 0x41, 0xf4,
0xa3, 0xae, 0xf0, 0x6a, 0xbb, 0x25, 0x8f, 0x98, 0x81, 0xd5, 0x7d, 0x71, 0x76, 0xcf, 0xac, 0x1a,
0x1d, 0x39, 0xfd, 0x3e, 0x98, 0xe5, 0xf0, 0x21, 0x21, 0xe9, 0x5e, 0x01, 0x34, 0x5e, 0xf7, 0xc2,
0x6c, 0x38, 0x4a, 0x28, 0x98, 0x97, 0xc1, 0xb7, 0x41, 0xb4, 0xb8, 0xc4, 0x89, 0xd6, 0xbd, 0xb8,
0x2f, 0x62, 0xa0, 0x85, 0xbc, 0x43, 0xc2, 0x3c, 0x36, 0xa2, 0xa1, 0x4c, 0x00, 0xec, 0x7f, 0xb0,
0x88, 0x9e, 0x6c, 0x70, 0xc3, 0xeb, 0x8c, 0xe6, 0x3b, 0x9c, 0xf0, 0x82, 0xb9, 0xd7, 0xd0, 0xb2,
0xcc, 0x90, 0x38, 0x92, 0x61, 0x38, 0x15, 0x78, 0x80, 0xf1, 0xbc, 0xa0, 0x90, 0x56, 0x13, 0x7a,
0x05, 0xec, 0xbe, 0x0c, 0x6a, 0xd5, 0x36, 0xec, 0xfe, 0x01, 0x68, 0xc7, 0x40, 0xda, 0xd0, 0xee,
0x7d, 0x41, 0xbb, 0x77, 0x25, 0xed, 0xec, 0x56, 0x58, 0x05, 0xaa, 0xe4, 0x94, 0x44, 0x47, 0x22,
0x17, 0xb8, 0x5e, 0x13, 0xbc, 0x57, 0x1f, 0xc1, 0xc1, 0x40, 0xb3, 0x23, 0xd8, 0x74, 0x48, 0x62,
0x0e, 0x5e, 0x13, 0xdb, 0x84, 0x0a, 0x91, 0xef, 0x62, 0x9b, 0xf9, 0x9c, 0x09, 0xdf, 0x7b, 0x24,
0x94, 0x7c, 0xe8, 0xe7, 0xd9, 0xd0, 0x2a, 0xc3, 0xd6, 0x43, 0xd1, 0xba, 0xa2, 0xaa, 0x16, 0xcd,
0x0e, 0x60, 0xd1, 0xfd, 0x31, 0xc0, 0x04, 0x3f, 0x25, 0x54, 0x3a, 0xff, 0xcc, 0xe6, 0x45, 0x7c,
0x1c, 0x23, 0x83, 0xfb, 0x70, 0x90, 0xed, 0x5d, 0x21, 0x63, 0xd8, 0xcf, 0xa0, 0xa6, 0x28, 0x22,
0x7a, 0x51, 0xcc, 0x04, 0x62, 0xc5, 0x41, 0xb0, 0xa2, 0xce, 0x23, 0xc3, 0x17, 0xe7, 0x96, 0x49,
0x02, 0xe8, 0x81, 0x95, 0x63, 0xd8, 0xfd, 0x95, 0x83, 0x96, 0x75, 0x65, 0x6a, 0x2f, 0xce, 0x0a,
0xe4, 0x7b, 0x00, 0xe4, 0x3b, 0x3b, 0x45, 0x8f, 0xcf, 0x83, 0x45, 0xfe, 0x53, 0xd6, 0x93, 0x47,
0x80, 0xf2, 0xdf, 0x5b, 0x42, 0xab, 0x0d, 0x20, 0xb6, 0x20, 0x36, 0x9c, 0xee, 0xa8, 0x6d, 0xdd,
0xfb, 0x8a, 0x93, 0xee, 0x0d, 0xb4, 0x44, 0x46, 0x23, 0x4d, 0x90, 0xb3, 0xc1, 0x2a, 0x60, 0xfb,
0x92, 0x88, 0x94, 0xfc, 0x28, 0x20, 0x84, 0x52, 0xac, 0x86, 0xb1, 0x9f, 0x41, 0x04, 0xde, 0x41,
0xcb, 0x61, 0x96, 0x4a, 0xfe, 0x0b, 0xa6, 0x2c, 0x06, 0x29, 0x88, 0xbe, 0x29, 0xcc, 0x6e, 0x58,
0x8e, 0x7a, 0x7a, 0x87, 0xae, 0x58, 0x36, 0x8c, 0x21, 0x04, 0x1d, 0x0e, 0x24, 0xf5, 0x13, 0xc6,
0xb2, 0x30, 0x1e, 0x37, 0x21, 0xb3, 0x82, 0x65, 0xa2, 0x24, 0xf7, 0xde, 0xa4, 0x21, 0x17, 0x4c,
0x51, 0xc7, 0xee, 0x91, 0x10, 0xca, 0x06, 0x30, 0xf5, 0x47, 0xf3, 0x53, 0xe0, 0x35, 0x80, 0xf8,
0x2d, 0x71, 0xba, 0x69, 0xae, 0x87, 0x9a, 0xa7, 0xbd, 0x4f, 0x6d, 0xf5, 0xa6, 0x24, 0x1c, 0x18,
0xee, 0x1b, 0x9f, 0x97, 0x0c, 0x20, 0x68, 0x49, 0xac, 0x31, 0x08, 0xbf, 0x28, 0x4c, 0x17, 0xf0,
0x23, 0x33, 0x32, 0xd8, 0x04, 0x04, 0x58, 0x20, 0x88, 0x53, 0xc8, 0x00, 0x92, 0xa8, 0x6c, 0x92,
0x61, 0x84, 0xbe, 0x20, 0x35, 0x99, 0xaa, 0xa1, 0x6d, 0x60, 0xf7, 0x13, 0xa7, 0x4c, 0xe3, 0x25,
0x99, 0xc6, 0x7f, 0x16, 0x49, 0xf9, 0x27, 0x67, 0xf5, 0x95, 0x91, 0x30, 0x40, 0x92, 0x35, 0x93,
0xbf, 0xe2, 0x0c, 0x43, 0xb2, 0x4f, 0xab, 0x65, 0x47, 0xb8, 0xae, 0x47, 0x07, 0x04, 0x4a, 0x3a,
0x98, 0x81, 0x44, 0x84, 0xa2, 0x62, 0x23, 0xb4, 0x5e, 0x66, 0xef, 0xb0, 0x80, 0xbd, 0x3d, 0x3a,
0x66, 0x1e, 0xf2, 0x33, 0xaa, 0x60, 0xeb, 0x51, 0x91, 0xb6, 0x24, 0x8a, 0x54, 0xf0, 0xaa, 0x1b,
0x8d, 0x7c, 0x3f, 0x87, 0x76, 0x1c, 0xb1, 0xb2, 0xab, 0xc9, 0x74, 0xf6, 0x63, 0xb4, 0x36, 0x03,
0x29, 0xd9, 0x08, 0xbe, 0x52, 0xf7, 0xeb, 0xe8, 0xb4, 0x56, 0xab, 0x99, 0xb9, 0x18, 0xac, 0xc1,
0x91, 0x2f, 0xed, 0x96, 0xf6, 0xe0, 0xb0, 0x3a, 0x7e, 0x8a, 0xa1, 0x91, 0x75, 0x98, 0xff, 0xee,
0x42, 0x63, 0x02, 0xdc, 0xa1, 0xa2, 0x9c, 0x8c, 0x27, 0xc0, 0xd5, 0x49, 0x53, 0xe7, 0xc1, 0x54,
0xbb, 0x6e, 0x4a, 0xa4, 0xa5, 0x14, 0xc7, 0xee, 0x75, 0x93, 0x31, 0x0b, 0x32, 0x63, 0x2e, 0xc3,
0xe6, 0xa7, 0xcb, 0x8c, 0x69, 0x48, 0x67, 0x2d, 0xf7, 0x76, 0x19, 0xc5, 0x96, 0x8c, 0x62, 0x0c,
0x92, 0xf4, 0x7f, 0x11, 0x43, 0xec, 0x5f, 0x69, 0x74, 0xfe, 0xb8, 0x43, 0x94, 0xf3, 0xfd, 0xbf,
0x34, 0xd7, 0x8f, 0xd7, 0x47, 0x11, 0xf9, 0x2f, 0xdc, 0x57, 0x48, 0xf1, 0xf9, 0xdd, 0x67, 0xe4,
0x7e, 0x39, 0x7f, 0xba, 0xcb, 0x42, 0x5b, 0x71, 0xb0, 0x1c, 0xf3, 0xe8, 0x61, 0x63, 0xf6, 0x43,
0xaf, 0x7a, 0xb9, 0xef, 0xc1, 0x2c, 0x3a, 0xee, 0x57, 0xb5, 0x59, 0x8e, 0x6d, 0x62, 0x15, 0x9c,
0x1b, 0x0e, 0xa0, 0x21, 0x43, 0x03, 0x76, 0xff, 0xe1, 0xcc, 0x97, 0xfc, 0x1f, 0x8a, 0xb4, 0xfd,
0x6d, 0x35, 0x6d, 0xcb, 0x21, 0x45, 0xa5, 0xd7, 0xe1, 0x20, 0x63, 0x54, 0xd7, 0x04, 0x33, 0x29,
0x2a, 0x07, 0x48, 0x1f, 0xe6, 0xb4, 0x9f, 0x88, 0x62, 0x58, 0x8e, 0x6e, 0xba, 0x19, 0xbf, 0xdc,
0xb7, 0x1c, 0x60, 0x1e, 0x81, 0xb1, 0x54, 0x40, 0x25, 0x89, 0xea, 0xc6, 0x75, 0x32, 0xc8, 0x53,
0x1d, 0x59, 0xed, 0x36, 0x95, 0x63, 0x5e, 0xaf, 0x34, 0xa7, 0xfe, 0x6f, 0x2b, 0x4d, 0x33, 0xd9,
0xc7, 0xe9, 0xab, 0xc9, 0xfe, 0xfb, 0x45, 0xb4, 0xde, 0xb0, 0xfb, 0xa5, 0xb4, 0x18, 0xd2, 0xbc,
0x14, 0x60, 0x96, 0xf0, 0x3f, 0xa8, 0x37, 0x4c, 0x35, 0xf5, 0x8d, 0x93, 0xdd, 0x38, 0x24, 0xa2,
0x9c, 0xc4, 0x09, 0x93, 0x1d, 0xd3, 0x33, 0x3e, 0xc4, 0x0d, 0x4c, 0x13, 0xe7, 0xe6, 0x95, 0x19,
0x4b, 0x5b, 0xb5, 0x61, 0xca, 0x29, 0x2f, 0xf2, 0x54, 0x90, 0xee, 0x17, 0x0e, 0x7a, 0x22, 0x4e,
0xc3, 0x04, 0x6e, 0x0e, 0x5d, 0x90, 0xea, 0x0a, 0x89, 0xae, 0xb9, 0x1d, 0xc9, 0xdc, 0x58, 0x09,
0xf6, 0x01, 0xd4, 0x5e, 0x25, 0x66, 0x41, 0x96, 0x25, 0x14, 0x7a, 0x2e, 0xc0, 0xa1, 0xf9, 0x10,
0x5a, 0x0f, 0x78, 0x16, 0xae, 0x2f, 0x60, 0x30, 0x97, 0x56, 0xb5, 0xb8, 0x80, 0x59, 0x89, 0x00,
0x1b, 0x64, 0x45, 0x12, 0xa9, 0x40, 0x49, 0x7b, 0x11, 0xf6, 0xee, 0xd0, 0x3e, 0x29, 0x12, 0x2e,
0x67, 0xe8, 0x3e, 0x49, 0xe0, 0x0a, 0xe6, 0xfe, 0xae, 0x0a, 0xa8, 0xe0, 0x83, 0x1a, 0x22, 0x39,
0x15, 0xad, 0x04, 0x6f, 0x01, 0x20, 0x7e, 0x42, 0x40, 0xe2, 0xb7, 0xd0, 0x0b, 0x77, 0x3c, 0x11,
0x1e, 0xa0, 0x83, 0x24, 0xd1, 0x8c, 0xe8, 0x02, 0xb4, 0x62, 0xe6, 0x67, 0xd9, 0x3c, 0x4f, 0x07,
0x5f, 0x06, 0x2c, 0xeb, 0x15, 0x2c, 0xf7, 0xcc, 0x78, 0x0d, 0x42, 0x66, 0xda, 0xaf, 0x5c, 0xd9,
0xa0, 0x7a, 0x7e, 0xb2, 0x88, 0x3a, 0x0d, 0x1c, 0xd1, 0xd4, 0x80, 0x8a, 0x36, 0x51, 0x02, 0x9f,
0x06, 0x1b, 0x4f, 0xd5, 0x59, 0xa1, 0x8e, 0x12, 0xb3, 0xb2, 0xaf, 0x6f, 0x54, 0x2b, 0xe1, 0x62,
0x70, 0x01, 0x64, 0x3a, 0x65, 0x25, 0x34, 0x47, 0xb7, 0xdb, 0x2b, 0x03, 0x57, 0xeb, 0x33, 0x19,
0xb8, 0x1e, 0x98, 0x02, 0x3c, 0xf3, 0xa4, 0xfb, 0x0c, 0x20, 0xf4, 0xc5, 0x91, 0xc2, 0x22, 0x87,
0x4b, 0x11, 0xd7, 0xc5, 0x74, 0xe2, 0x68, 0x5f, 0x43, 0x9f, 0xe3, 0xf1, 0x90, 0x76, 0x75, 0x27,
0x97, 0x81, 0x3a, 0x1b, 0x5c, 0x02, 0xe9, 0x8b, 0x6a, 0x5a, 0x1b, 0x8e, 0x81, 0x85, 0x8b, 0x90,
0xde, 0x8b, 0xdd, 0x6f, 0x68, 0x61, 0x5d, 0x27, 0x65, 0xe1, 0x3a, 0x1b, 0x3c, 0x0b, 0xc2, 0xcf,
0x08, 0xe1, 0x84, 0x30, 0xde, 0xac, 0x41, 0x0b, 0x60, 0x37, 0x42, 0x67, 0x24, 0x67, 0x99, 0x2c,
0xd3, 0xed, 0xe5, 0x99, 0x8a, 0xf9, 0x55, 0x30, 0x70, 0x45, 0x86, 0x58, 0xfe, 0x36, 0x23, 0x5c,
0x59, 0x86, 0xc7, 0x7b, 0xf0, 0x43, 0x07, 0x6d, 0xcc, 0x58, 0x69, 0xf4, 0x14, 0xf4, 0x1a, 0x5a,
0x31, 0x85, 0x00, 0x78, 0x25, 0x40, 0x9d, 0xc3, 0xd3, 0x79, 0x18, 0xf8, 0x80, 0xe8, 0x42, 0xd9,
0x51, 0x1a, 0xca, 0x09, 0xf6, 0x3f, 0x6d, 0x35, 0x96, 0xbb, 0xbb, 0x94, 0x6b, 0x2d, 0x77, 0x54,
0xc5, 0xb2, 0xe5, 0xee, 0xd5, 0x09, 0x0c, 0x2f, 0xe2, 0x79, 0x14, 0xe0, 0xfb, 0xe6, 0xf2, 0x6b,
0xd2, 0x05, 0xd7, 0x07, 0x80, 0xa7, 0x00, 0xf5, 0xb9, 0xa9, 0xb4, 0x87, 0x09, 0xfb, 0x46, 0x25,
0x83, 0xd5, 0x4d, 0x5b, 0x12, 0xe3, 0xd8, 0xb4, 0xed, 0xfc, 0xdb, 0x41, 0x9f, 0x9f, 0xb0, 0x7e,
0x73, 0x32, 0x59, 0x2d, 0xcf, 0x6a, 0x25, 0x7c, 0x8f, 0xd6, 0xcb, 0xf7, 0x31, 0x75, 0xae, 0xf5,
0xd9, 0xd6, 0x39, 0xff, 0x9d, 0x46, 0x72, 0x35, 0x85, 0x45, 0x93, 0x6b, 0x7b, 0x3e, 0x72, 0xd9,
0x30, 0x19, 0x9f, 0x8c, 0x8d, 0x4f, 0xfe, 0x1f, 0x1d, 0xd4, 0x1e, 0x17, 0xdf, 0xa1, 0x5c, 0x5c,
0xf3, 0xd9, 0xc9, 0x6f, 0x99, 0x3b, 0xe8, 0x71, 0xc8, 0xaa, 0xec, 0xb0, 0x5b, 0x7b, 0x25, 0x94,
0xd4, 0x59, 0x09, 0xae, 0x83, 0x9a, 0xcd, 0x6f, 0x57, 0xdc, 0x29, 0x1d, 0x26, 0xf7, 0x33, 0xaf,
0x2a, 0x50, 0x16, 0x5f, 0x30, 0x88, 0xfd, 0x03, 0xf4, 0xfc, 0xd4, 0x01, 0xa1, 0x09, 0xbe, 0x4d,
0x86, 0x17, 0x50, 0x47, 0x94, 0xd3, 0x1a, 0x98, 0x2e, 0xd3, 0xbb, 0xb4, 0x17, 0x9f, 0xc0, 0xd3,
0xbc, 0xe0, 0xdf, 0x44, 0xd7, 0xe7, 0xb5, 0xab, 0xa7, 0x94, 0xbf, 0x3b, 0xe8, 0x66, 0x83, 0xe8,
0x2b, 0x69, 0xed, 0xb7, 0x25, 0x7b, 0xb7, 0xfa, 0x19, 0x22, 0x3d, 0xf6, 0x0a, 0xf4, 0x02, 0xf8,
0xed, 0x96, 0x99, 0xe3, 0x2a, 0x95, 0x42, 0x8c, 0x9f, 0x35, 0xbf, 0xc1, 0xfc, 0x21, 0xde, 0x38,
0xcb, 0xf7, 0x2b, 0x19, 0x93, 0xaf, 0xd6, 0x13, 0xf8, 0x0a, 0x68, 0xbb, 0x5c, 0x09, 0xa6, 0x78,
0xcf, 0x2b, 0x25, 0xea, 0xaf, 0xbb, 0xfe, 0x5f, 0x5b, 0xe8, 0xb9, 0xc6, 0x83, 0x94, 0x95, 0x75,
0x4b, 0x8d, 0xd7, 0xf5, 0x33, 0xbc, 0x38, 0x7e, 0x86, 0x0d, 0xb0, 0xba, 0x36, 0xe5, 0x0c, 0xcc,
0x16, 0x65, 0x3b, 0xaa, 0x3f, 0xa8, 0xa6, 0xbd, 0xea, 0xb7, 0x2f, 0x81, 0x86, 0xdb, 0x8d, 0x17,
0x4a, 0xdb, 0x24, 0xf4, 0x0b, 0x6f, 0xed, 0xe9, 0xab, 0x60, 0xaa, 0xfd, 0x18, 0xcd, 0xf7, 0x8c,
0x37, 0x5a, 0xd2, 0x1b, 0xd2, 0xb7, 0x53, 0xef, 0x33, 0xd3, 0x34, 0x5a, 0x6d, 0x6f, 0xa0, 0x53,
0xba, 0x0b, 0xa9, 0x26, 0x7b, 0x5c, 0x17, 0x92, 0x1d, 0xb6, 0x52, 0x70, 0xb6, 0xe1, 0x7a, 0x53,
0x36, 0x24, 0x3b, 0x13, 0xbb, 0x77, 0xd1, 0x72, 0x4e, 0x87, 0xd9, 0x81, 0x6e, 0xae, 0x3a, 0x77,
0x2a, 0x82, 0x42, 0xa7, 0x37, 0x20, 0x62, 0xee, 0x86, 0x6b, 0x85, 0xde, 0x5b, 0x3e, 0xc9, 0x99,
0x34, 0xdf, 0xfc, 0x68, 0x05, 0x3d, 0x36, 0x81, 0x48, 0xbc, 0xd1, 0x3e, 0x26, 0x34, 0xd4, 0xae,
0xf3, 0xee, 0x1a, 0x9e, 0xf5, 0x19, 0xaa, 0xf3, 0x2c, 0x9e, 0xf9, 0x71, 0xc0, 0xbf, 0x08, 0xd0,
0x9f, 0x54, 0x6b, 0x4c, 0x3e, 0x1f, 0xb2, 0xa3, 0x34, 0x54, 0x73, 0x8e, 0x86, 0x69, 0xf1, 0xd4,
0x6e, 0xb8, 0xcd, 0x78, 0x1a, 0x5f, 0x05, 0x9a, 0xf1, 0x4c, 0xb9, 0x2f, 0x4b, 0x3c, 0x6a, 0xed,
0x38, 0x3c, 0xb5, 0x4b, 0x48, 0x33, 0x9e, 0xc6, 0x6b, 0x76, 0x33, 0x9e, 0x29, 0x57, 0x1a, 0x89,
0x47, 0xad, 0x4d, 0xc3, 0xf3, 0x3e, 0xe0, 0x99, 0x18, 0x3c, 0xdc, 0x0d, 0x3c, 0xcf, 0x4d, 0xa8,
0x83, 0xf1, 0x5c, 0xe3, 0x8c, 0x2f, 0x1f, 0x9f, 0xed, 0x3a, 0x40, 0x1b, 0x1f, 0x4f, 0xdc, 0x0f,
0x01, 0xd6, 0x44, 0xcb, 0x6a, 0x86, 0x35, 0x75, 0xe0, 0x68, 0x86, 0x35, 0xbd, 0x11, 0xfa, 0x72,
0x52, 0x84, 0x75, 0xfd, 0xc7, 0x07, 0xdb, 0xf1, 0x01, 0x9f, 0x7d, 0x25, 0x37, 0x7e, 0xfb, 0xd4,
0x41, 0x9d, 0xe9, 0xf5, 0xda, 0xbd, 0x8e, 0x4f, 0xd4, 0x57, 0x3a, 0x37, 0xf0, 0x09, 0xfb, 0xc2,
0x5d, 0xc0, 0xbe, 0x65, 0x42, 0x6d, 0x06, 0x0b, 0x52, 0xeb, 0x83, 0x32, 0xee, 0xf5, 0xa2, 0x3e,
0x76, 0x38, 0xa8, 0x54, 0x9d, 0x57, 0x41, 0xd1, 0xbd, 0xdb, 0x70, 0xce, 0xfc, 0x20, 0x0e, 0xd5,
0x3c, 0xd2, 0x2f, 0xd2, 0x50, 0xed, 0xcf, 0x69, 0x62, 0x5e, 0x20, 0xe4, 0x90, 0x22, 0xf8, 0x94,
0x67, 0x69, 0x56, 0x34, 0x68, 0x97, 0x2a, 0xa0, 0xe2, 0x6c, 0xfe, 0x73, 0x01, 0x7d, 0x71, 0xe2,
0x50, 0x5b, 0xf2, 0x4f, 0x75, 0xee, 0x07, 0x30, 0x2b, 0x4c, 0xeb, 0x5d, 0xee, 0x2d, 0x7c, 0xd2,
0x4e, 0xd7, 0x39, 0x83, 0xb7, 0x33, 0xeb, 0x9b, 0x6b, 0x70, 0xa4, 0x0d, 0xbd, 0x91, 0xa9, 0xb6,
0x64, 0x9b, 0x44, 0x36, 0x12, 0x23, 0x22, 0x1f, 0xeb, 0x76, 0x22, 0x4d, 0x1f, 0x6f, 0x68, 0x45,
0xee, 0x57, 0xf0, 0x09, 0x7a, 0x56, 0x1d, 0xcd, 0x73, 0x80, 0xe6, 0x6a, 0x75, 0xb9, 0x8e, 0xa8,
0x6c, 0x05, 0x83, 0xb2, 0xb9, 0x74, 0xc4, 0x4b, 0xda, 0x17, 0x94, 0xcf, 0xea, 0x48, 0xff, 0xf6,
0x71, 0x7b, 0x21, 0x68, 0xfd, 0xd0, 0x71, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0x0c, 0x81, 0x5e,
0xd6, 0x51, 0x1d, 0x00, 0x00,
}

View File

@ -0,0 +1,163 @@
// Code generated by protoc-gen-go.
// source: steammessages_offline.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type COffline_GetOfflineLogonTicket_Request struct {
Priority *uint32 `protobuf:"varint,1,opt,name=priority" json:"priority,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *COffline_GetOfflineLogonTicket_Request) Reset() {
*m = COffline_GetOfflineLogonTicket_Request{}
}
func (m *COffline_GetOfflineLogonTicket_Request) String() string { return proto.CompactTextString(m) }
func (*COffline_GetOfflineLogonTicket_Request) ProtoMessage() {}
func (*COffline_GetOfflineLogonTicket_Request) Descriptor() ([]byte, []int) {
return offline_fileDescriptor0, []int{0}
}
func (m *COffline_GetOfflineLogonTicket_Request) GetPriority() uint32 {
if m != nil && m.Priority != nil {
return *m.Priority
}
return 0
}
type COffline_GetOfflineLogonTicket_Response struct {
SerializedTicket []byte `protobuf:"bytes,1,opt,name=serialized_ticket" json:"serialized_ticket,omitempty"`
Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *COffline_GetOfflineLogonTicket_Response) Reset() {
*m = COffline_GetOfflineLogonTicket_Response{}
}
func (m *COffline_GetOfflineLogonTicket_Response) String() string { return proto.CompactTextString(m) }
func (*COffline_GetOfflineLogonTicket_Response) ProtoMessage() {}
func (*COffline_GetOfflineLogonTicket_Response) Descriptor() ([]byte, []int) {
return offline_fileDescriptor0, []int{1}
}
func (m *COffline_GetOfflineLogonTicket_Response) GetSerializedTicket() []byte {
if m != nil {
return m.SerializedTicket
}
return nil
}
func (m *COffline_GetOfflineLogonTicket_Response) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
type COffline_GetUnsignedOfflineLogonTicket_Request struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *COffline_GetUnsignedOfflineLogonTicket_Request) Reset() {
*m = COffline_GetUnsignedOfflineLogonTicket_Request{}
}
func (m *COffline_GetUnsignedOfflineLogonTicket_Request) String() string {
return proto.CompactTextString(m)
}
func (*COffline_GetUnsignedOfflineLogonTicket_Request) ProtoMessage() {}
func (*COffline_GetUnsignedOfflineLogonTicket_Request) Descriptor() ([]byte, []int) {
return offline_fileDescriptor0, []int{2}
}
type COffline_OfflineLogonTicket struct {
Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"`
Rtime32CreationTime *uint32 `protobuf:"fixed32,2,opt,name=rtime32_creation_time" json:"rtime32_creation_time,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *COffline_OfflineLogonTicket) Reset() { *m = COffline_OfflineLogonTicket{} }
func (m *COffline_OfflineLogonTicket) String() string { return proto.CompactTextString(m) }
func (*COffline_OfflineLogonTicket) ProtoMessage() {}
func (*COffline_OfflineLogonTicket) Descriptor() ([]byte, []int) { return offline_fileDescriptor0, []int{3} }
func (m *COffline_OfflineLogonTicket) GetAccountid() uint32 {
if m != nil && m.Accountid != nil {
return *m.Accountid
}
return 0
}
func (m *COffline_OfflineLogonTicket) GetRtime32CreationTime() uint32 {
if m != nil && m.Rtime32CreationTime != nil {
return *m.Rtime32CreationTime
}
return 0
}
type COffline_GetUnsignedOfflineLogonTicket_Response struct {
Ticket *COffline_OfflineLogonTicket `protobuf:"bytes,1,opt,name=ticket" json:"ticket,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *COffline_GetUnsignedOfflineLogonTicket_Response) Reset() {
*m = COffline_GetUnsignedOfflineLogonTicket_Response{}
}
func (m *COffline_GetUnsignedOfflineLogonTicket_Response) String() string {
return proto.CompactTextString(m)
}
func (*COffline_GetUnsignedOfflineLogonTicket_Response) ProtoMessage() {}
func (*COffline_GetUnsignedOfflineLogonTicket_Response) Descriptor() ([]byte, []int) {
return offline_fileDescriptor0, []int{4}
}
func (m *COffline_GetUnsignedOfflineLogonTicket_Response) GetTicket() *COffline_OfflineLogonTicket {
if m != nil {
return m.Ticket
}
return nil
}
func init() {
proto.RegisterType((*COffline_GetOfflineLogonTicket_Request)(nil), "COffline_GetOfflineLogonTicket_Request")
proto.RegisterType((*COffline_GetOfflineLogonTicket_Response)(nil), "COffline_GetOfflineLogonTicket_Response")
proto.RegisterType((*COffline_GetUnsignedOfflineLogonTicket_Request)(nil), "COffline_GetUnsignedOfflineLogonTicket_Request")
proto.RegisterType((*COffline_OfflineLogonTicket)(nil), "COffline_OfflineLogonTicket")
proto.RegisterType((*COffline_GetUnsignedOfflineLogonTicket_Response)(nil), "COffline_GetUnsignedOfflineLogonTicket_Response")
}
var offline_fileDescriptor0 = []byte{
// 377 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x52, 0xcd, 0x4a, 0xf3, 0x40,
0x14, 0x25, 0x5f, 0xe1, 0xab, 0x8e, 0x0a, 0x76, 0xa0, 0x10, 0x63, 0x0b, 0x43, 0x16, 0xb6, 0x8b,
0x92, 0x96, 0xba, 0x52, 0x70, 0xa3, 0x88, 0x08, 0x42, 0x41, 0x14, 0x97, 0x61, 0x4c, 0x6e, 0xe2,
0x60, 0x3a, 0x53, 0x67, 0x6e, 0x04, 0x5d, 0x89, 0xaf, 0xe2, 0x33, 0xf4, 0x01, 0x7c, 0x33, 0xf3,
0x87, 0x56, 0xac, 0xb5, 0xdd, 0x25, 0x37, 0xe7, 0xdc, 0x9c, 0x9f, 0x4b, 0x3a, 0x06, 0x81, 0x8f,
0xc7, 0x60, 0x0c, 0x8f, 0xc1, 0xf8, 0x2a, 0x8a, 0x12, 0x21, 0xc1, 0x2b, 0xa6, 0x41, 0x22, 0x40,
0xa2, 0x37, 0xd1, 0x0a, 0x95, 0xd3, 0xfb, 0x0e, 0x4c, 0xa5, 0x88, 0x04, 0x84, 0xfe, 0x2d, 0x37,
0x73, 0xd0, 0xee, 0x21, 0xd9, 0x3b, 0x19, 0x95, 0xbb, 0xfc, 0x33, 0xc0, 0xea, 0xf1, 0x42, 0xc5,
0x4a, 0x5e, 0x89, 0xe0, 0x1e, 0xd0, 0xbf, 0x84, 0x87, 0x14, 0x0c, 0xd2, 0x6d, 0xb2, 0x36, 0xd1,
0x42, 0x69, 0x81, 0x4f, 0xb6, 0xc5, 0xac, 0xee, 0x96, 0x7b, 0x43, 0x3a, 0x7f, 0x72, 0xcd, 0x44,
0x49, 0x03, 0x74, 0x87, 0x34, 0x0c, 0x68, 0xc1, 0x13, 0xf1, 0x9c, 0x69, 0xc1, 0xe2, 0x6b, 0xb1,
0x65, 0x93, 0x36, 0xc8, 0xba, 0x11, 0xb1, 0xe4, 0x98, 0x6a, 0xb0, 0xff, 0xe5, 0x23, 0x77, 0x40,
0xbc, 0xd9, 0xc5, 0xd7, 0x32, 0x07, 0x40, 0xf8, 0xbb, 0x38, 0x77, 0x44, 0x76, 0x3f, 0x19, 0x3f,
0x61, 0xf9, 0x3f, 0x78, 0x10, 0xa8, 0x54, 0xa2, 0x08, 0x4b, 0xf1, 0xb4, 0x4d, 0x9a, 0x1a, 0xc5,
0x18, 0xf6, 0x87, 0x7e, 0xa0, 0x81, 0xa3, 0x50, 0xd2, 0xcf, 0xdf, 0x0b, 0x09, 0x75, 0xd7, 0x27,
0xfd, 0xa5, 0x25, 0x54, 0x1e, 0x7b, 0xe4, 0xff, 0x8c, 0xb1, 0x8d, 0x61, 0xcb, 0x5b, 0x20, 0x69,
0xf8, 0x56, 0x23, 0xf5, 0x6a, 0x4c, 0xa7, 0x16, 0x69, 0xce, 0x0d, 0x90, 0x76, 0xbc, 0xe5, 0xda,
0x71, 0xba, 0xde, 0x92, 0x55, 0xb8, 0xe7, 0xaf, 0x53, 0xfb, 0x34, 0xc3, 0x30, 0xce, 0xbe, 0x2a,
0x61, 0x5c, 0x86, 0xac, 0xb4, 0xc8, 0xaa, 0xd3, 0x62, 0x49, 0xce, 0x66, 0xa5, 0x25, 0x16, 0x29,
0xcd, 0xf0, 0x0e, 0x58, 0x90, 0x6a, 0x9d, 0x5d, 0x0f, 0x4b, 0x33, 0x2e, 0x7d, 0xb7, 0x48, 0x7b,
0x61, 0x38, 0xb4, 0xbf, 0x62, 0x91, 0xce, 0xc0, 0x5b, 0x31, 0x76, 0xf7, 0x28, 0xf3, 0x73, 0x50,
0xf8, 0x91, 0x2c, 0x95, 0xab, 0x7a, 0x70, 0x5a, 0x19, 0xdd, 0xae, 0xf6, 0x67, 0x81, 0x20, 0x0a,
0x19, 0x9b, 0x3c, 0x99, 0x47, 0x11, 0xc0, 0x71, 0xed, 0xc5, 0xb2, 0x3e, 0x02, 0x00, 0x00, 0xff,
0xff, 0x90, 0xd3, 0xb5, 0xf7, 0x7b, 0x03, 0x00, 0x00,
}

View File

@ -0,0 +1,791 @@
// Code generated by protoc-gen-go.
// source: steammessages_parental.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type ParentalApp struct {
Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
IsAllowed *bool `protobuf:"varint,2,opt,name=is_allowed" json:"is_allowed,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ParentalApp) Reset() { *m = ParentalApp{} }
func (m *ParentalApp) String() string { return proto.CompactTextString(m) }
func (*ParentalApp) ProtoMessage() {}
func (*ParentalApp) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{0} }
func (m *ParentalApp) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *ParentalApp) GetIsAllowed() bool {
if m != nil && m.IsAllowed != nil {
return *m.IsAllowed
}
return false
}
type ParentalSettings struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
ApplistBaseId *uint32 `protobuf:"varint,2,opt,name=applist_base_id" json:"applist_base_id,omitempty"`
ApplistBaseDescription *string `protobuf:"bytes,3,opt,name=applist_base_description" json:"applist_base_description,omitempty"`
ApplistBase []*ParentalApp `protobuf:"bytes,4,rep,name=applist_base" json:"applist_base,omitempty"`
ApplistCustom []*ParentalApp `protobuf:"bytes,5,rep,name=applist_custom" json:"applist_custom,omitempty"`
Passwordhashtype *uint32 `protobuf:"varint,6,opt,name=passwordhashtype" json:"passwordhashtype,omitempty"`
Salt []byte `protobuf:"bytes,7,opt,name=salt" json:"salt,omitempty"`
Passwordhash []byte `protobuf:"bytes,8,opt,name=passwordhash" json:"passwordhash,omitempty"`
IsEnabled *bool `protobuf:"varint,9,opt,name=is_enabled" json:"is_enabled,omitempty"`
EnabledFeatures *uint32 `protobuf:"varint,10,opt,name=enabled_features" json:"enabled_features,omitempty"`
RecoveryEmail *string `protobuf:"bytes,11,opt,name=recovery_email" json:"recovery_email,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ParentalSettings) Reset() { *m = ParentalSettings{} }
func (m *ParentalSettings) String() string { return proto.CompactTextString(m) }
func (*ParentalSettings) ProtoMessage() {}
func (*ParentalSettings) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{1} }
func (m *ParentalSettings) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *ParentalSettings) GetApplistBaseId() uint32 {
if m != nil && m.ApplistBaseId != nil {
return *m.ApplistBaseId
}
return 0
}
func (m *ParentalSettings) GetApplistBaseDescription() string {
if m != nil && m.ApplistBaseDescription != nil {
return *m.ApplistBaseDescription
}
return ""
}
func (m *ParentalSettings) GetApplistBase() []*ParentalApp {
if m != nil {
return m.ApplistBase
}
return nil
}
func (m *ParentalSettings) GetApplistCustom() []*ParentalApp {
if m != nil {
return m.ApplistCustom
}
return nil
}
func (m *ParentalSettings) GetPasswordhashtype() uint32 {
if m != nil && m.Passwordhashtype != nil {
return *m.Passwordhashtype
}
return 0
}
func (m *ParentalSettings) GetSalt() []byte {
if m != nil {
return m.Salt
}
return nil
}
func (m *ParentalSettings) GetPasswordhash() []byte {
if m != nil {
return m.Passwordhash
}
return nil
}
func (m *ParentalSettings) GetIsEnabled() bool {
if m != nil && m.IsEnabled != nil {
return *m.IsEnabled
}
return false
}
func (m *ParentalSettings) GetEnabledFeatures() uint32 {
if m != nil && m.EnabledFeatures != nil {
return *m.EnabledFeatures
}
return 0
}
func (m *ParentalSettings) GetRecoveryEmail() string {
if m != nil && m.RecoveryEmail != nil {
return *m.RecoveryEmail
}
return ""
}
type CParental_EnableParentalSettings_Request struct {
Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"`
Settings *ParentalSettings `protobuf:"bytes,2,opt,name=settings" json:"settings,omitempty"`
Sessionid *string `protobuf:"bytes,3,opt,name=sessionid" json:"sessionid,omitempty"`
Enablecode *uint32 `protobuf:"varint,4,opt,name=enablecode" json:"enablecode,omitempty"`
Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_EnableParentalSettings_Request) Reset() {
*m = CParental_EnableParentalSettings_Request{}
}
func (m *CParental_EnableParentalSettings_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_EnableParentalSettings_Request) ProtoMessage() {}
func (*CParental_EnableParentalSettings_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{2}
}
func (m *CParental_EnableParentalSettings_Request) GetPassword() string {
if m != nil && m.Password != nil {
return *m.Password
}
return ""
}
func (m *CParental_EnableParentalSettings_Request) GetSettings() *ParentalSettings {
if m != nil {
return m.Settings
}
return nil
}
func (m *CParental_EnableParentalSettings_Request) GetSessionid() string {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return ""
}
func (m *CParental_EnableParentalSettings_Request) GetEnablecode() uint32 {
if m != nil && m.Enablecode != nil {
return *m.Enablecode
}
return 0
}
func (m *CParental_EnableParentalSettings_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CParental_EnableParentalSettings_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_EnableParentalSettings_Response) Reset() {
*m = CParental_EnableParentalSettings_Response{}
}
func (m *CParental_EnableParentalSettings_Response) String() string { return proto.CompactTextString(m) }
func (*CParental_EnableParentalSettings_Response) ProtoMessage() {}
func (*CParental_EnableParentalSettings_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{3}
}
type CParental_DisableParentalSettings_Request struct {
Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"`
Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_DisableParentalSettings_Request) Reset() {
*m = CParental_DisableParentalSettings_Request{}
}
func (m *CParental_DisableParentalSettings_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_DisableParentalSettings_Request) ProtoMessage() {}
func (*CParental_DisableParentalSettings_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{4}
}
func (m *CParental_DisableParentalSettings_Request) GetPassword() string {
if m != nil && m.Password != nil {
return *m.Password
}
return ""
}
func (m *CParental_DisableParentalSettings_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CParental_DisableParentalSettings_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_DisableParentalSettings_Response) Reset() {
*m = CParental_DisableParentalSettings_Response{}
}
func (m *CParental_DisableParentalSettings_Response) String() string {
return proto.CompactTextString(m)
}
func (*CParental_DisableParentalSettings_Response) ProtoMessage() {}
func (*CParental_DisableParentalSettings_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{5}
}
type CParental_GetParentalSettings_Request struct {
Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_GetParentalSettings_Request) Reset() { *m = CParental_GetParentalSettings_Request{} }
func (m *CParental_GetParentalSettings_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_GetParentalSettings_Request) ProtoMessage() {}
func (*CParental_GetParentalSettings_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{6}
}
func (m *CParental_GetParentalSettings_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CParental_GetParentalSettings_Response struct {
Settings *ParentalSettings `protobuf:"bytes,1,opt,name=settings" json:"settings,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_GetParentalSettings_Response) Reset() {
*m = CParental_GetParentalSettings_Response{}
}
func (m *CParental_GetParentalSettings_Response) String() string { return proto.CompactTextString(m) }
func (*CParental_GetParentalSettings_Response) ProtoMessage() {}
func (*CParental_GetParentalSettings_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{7}
}
func (m *CParental_GetParentalSettings_Response) GetSettings() *ParentalSettings {
if m != nil {
return m.Settings
}
return nil
}
type CParental_GetSignedParentalSettings_Request struct {
Priority *uint32 `protobuf:"varint,1,opt,name=priority" json:"priority,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_GetSignedParentalSettings_Request) Reset() {
*m = CParental_GetSignedParentalSettings_Request{}
}
func (m *CParental_GetSignedParentalSettings_Request) String() string {
return proto.CompactTextString(m)
}
func (*CParental_GetSignedParentalSettings_Request) ProtoMessage() {}
func (*CParental_GetSignedParentalSettings_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{8}
}
func (m *CParental_GetSignedParentalSettings_Request) GetPriority() uint32 {
if m != nil && m.Priority != nil {
return *m.Priority
}
return 0
}
type CParental_GetSignedParentalSettings_Response struct {
SerializedSettings []byte `protobuf:"bytes,1,opt,name=serialized_settings" json:"serialized_settings,omitempty"`
Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_GetSignedParentalSettings_Response) Reset() {
*m = CParental_GetSignedParentalSettings_Response{}
}
func (m *CParental_GetSignedParentalSettings_Response) String() string {
return proto.CompactTextString(m)
}
func (*CParental_GetSignedParentalSettings_Response) ProtoMessage() {}
func (*CParental_GetSignedParentalSettings_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{9}
}
func (m *CParental_GetSignedParentalSettings_Response) GetSerializedSettings() []byte {
if m != nil {
return m.SerializedSettings
}
return nil
}
func (m *CParental_GetSignedParentalSettings_Response) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
type CParental_SetParentalSettings_Request struct {
Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"`
Settings *ParentalSettings `protobuf:"bytes,2,opt,name=settings" json:"settings,omitempty"`
NewPassword *string `protobuf:"bytes,3,opt,name=new_password" json:"new_password,omitempty"`
Sessionid *string `protobuf:"bytes,4,opt,name=sessionid" json:"sessionid,omitempty"`
Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_SetParentalSettings_Request) Reset() { *m = CParental_SetParentalSettings_Request{} }
func (m *CParental_SetParentalSettings_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_SetParentalSettings_Request) ProtoMessage() {}
func (*CParental_SetParentalSettings_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{10}
}
func (m *CParental_SetParentalSettings_Request) GetPassword() string {
if m != nil && m.Password != nil {
return *m.Password
}
return ""
}
func (m *CParental_SetParentalSettings_Request) GetSettings() *ParentalSettings {
if m != nil {
return m.Settings
}
return nil
}
func (m *CParental_SetParentalSettings_Request) GetNewPassword() string {
if m != nil && m.NewPassword != nil {
return *m.NewPassword
}
return ""
}
func (m *CParental_SetParentalSettings_Request) GetSessionid() string {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return ""
}
func (m *CParental_SetParentalSettings_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CParental_SetParentalSettings_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_SetParentalSettings_Response) Reset() {
*m = CParental_SetParentalSettings_Response{}
}
func (m *CParental_SetParentalSettings_Response) String() string { return proto.CompactTextString(m) }
func (*CParental_SetParentalSettings_Response) ProtoMessage() {}
func (*CParental_SetParentalSettings_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{11}
}
type CParental_ValidateToken_Request struct {
UnlockToken *string `protobuf:"bytes,1,opt,name=unlock_token" json:"unlock_token,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_ValidateToken_Request) Reset() { *m = CParental_ValidateToken_Request{} }
func (m *CParental_ValidateToken_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_ValidateToken_Request) ProtoMessage() {}
func (*CParental_ValidateToken_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{12}
}
func (m *CParental_ValidateToken_Request) GetUnlockToken() string {
if m != nil && m.UnlockToken != nil {
return *m.UnlockToken
}
return ""
}
type CParental_ValidateToken_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_ValidateToken_Response) Reset() { *m = CParental_ValidateToken_Response{} }
func (m *CParental_ValidateToken_Response) String() string { return proto.CompactTextString(m) }
func (*CParental_ValidateToken_Response) ProtoMessage() {}
func (*CParental_ValidateToken_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{13}
}
type CParental_ValidatePassword_Request struct {
Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"`
Session *string `protobuf:"bytes,2,opt,name=session" json:"session,omitempty"`
SendUnlockOnSuccess *bool `protobuf:"varint,3,opt,name=send_unlock_on_success" json:"send_unlock_on_success,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_ValidatePassword_Request) Reset() { *m = CParental_ValidatePassword_Request{} }
func (m *CParental_ValidatePassword_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_ValidatePassword_Request) ProtoMessage() {}
func (*CParental_ValidatePassword_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{14}
}
func (m *CParental_ValidatePassword_Request) GetPassword() string {
if m != nil && m.Password != nil {
return *m.Password
}
return ""
}
func (m *CParental_ValidatePassword_Request) GetSession() string {
if m != nil && m.Session != nil {
return *m.Session
}
return ""
}
func (m *CParental_ValidatePassword_Request) GetSendUnlockOnSuccess() bool {
if m != nil && m.SendUnlockOnSuccess != nil {
return *m.SendUnlockOnSuccess
}
return false
}
type CParental_ValidatePassword_Response struct {
Token *string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_ValidatePassword_Response) Reset() { *m = CParental_ValidatePassword_Response{} }
func (m *CParental_ValidatePassword_Response) String() string { return proto.CompactTextString(m) }
func (*CParental_ValidatePassword_Response) ProtoMessage() {}
func (*CParental_ValidatePassword_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{15}
}
func (m *CParental_ValidatePassword_Response) GetToken() string {
if m != nil && m.Token != nil {
return *m.Token
}
return ""
}
type CParental_LockClient_Request struct {
Session *string `protobuf:"bytes,1,opt,name=session" json:"session,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_LockClient_Request) Reset() { *m = CParental_LockClient_Request{} }
func (m *CParental_LockClient_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_LockClient_Request) ProtoMessage() {}
func (*CParental_LockClient_Request) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{16} }
func (m *CParental_LockClient_Request) GetSession() string {
if m != nil && m.Session != nil {
return *m.Session
}
return ""
}
type CParental_LockClient_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_LockClient_Response) Reset() { *m = CParental_LockClient_Response{} }
func (m *CParental_LockClient_Response) String() string { return proto.CompactTextString(m) }
func (*CParental_LockClient_Response) ProtoMessage() {}
func (*CParental_LockClient_Response) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{17} }
type CParental_RequestRecoveryCode_Request struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_RequestRecoveryCode_Request) Reset() { *m = CParental_RequestRecoveryCode_Request{} }
func (m *CParental_RequestRecoveryCode_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_RequestRecoveryCode_Request) ProtoMessage() {}
func (*CParental_RequestRecoveryCode_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{18}
}
type CParental_RequestRecoveryCode_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_RequestRecoveryCode_Response) Reset() {
*m = CParental_RequestRecoveryCode_Response{}
}
func (m *CParental_RequestRecoveryCode_Response) String() string { return proto.CompactTextString(m) }
func (*CParental_RequestRecoveryCode_Response) ProtoMessage() {}
func (*CParental_RequestRecoveryCode_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{19}
}
type CParental_DisableWithRecoveryCode_Request struct {
RecoveryCode *uint32 `protobuf:"varint,1,opt,name=recovery_code" json:"recovery_code,omitempty"`
Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_DisableWithRecoveryCode_Request) Reset() {
*m = CParental_DisableWithRecoveryCode_Request{}
}
func (m *CParental_DisableWithRecoveryCode_Request) String() string { return proto.CompactTextString(m) }
func (*CParental_DisableWithRecoveryCode_Request) ProtoMessage() {}
func (*CParental_DisableWithRecoveryCode_Request) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{20}
}
func (m *CParental_DisableWithRecoveryCode_Request) GetRecoveryCode() uint32 {
if m != nil && m.RecoveryCode != nil {
return *m.RecoveryCode
}
return 0
}
func (m *CParental_DisableWithRecoveryCode_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CParental_DisableWithRecoveryCode_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_DisableWithRecoveryCode_Response) Reset() {
*m = CParental_DisableWithRecoveryCode_Response{}
}
func (m *CParental_DisableWithRecoveryCode_Response) String() string {
return proto.CompactTextString(m)
}
func (*CParental_DisableWithRecoveryCode_Response) ProtoMessage() {}
func (*CParental_DisableWithRecoveryCode_Response) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{21}
}
type CParental_ParentalSettingsChange_Notification struct {
SerializedSettings []byte `protobuf:"bytes,1,opt,name=serialized_settings" json:"serialized_settings,omitempty"`
Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
Password *string `protobuf:"bytes,3,opt,name=password" json:"password,omitempty"`
Sessionid *string `protobuf:"bytes,4,opt,name=sessionid" json:"sessionid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_ParentalSettingsChange_Notification) Reset() {
*m = CParental_ParentalSettingsChange_Notification{}
}
func (m *CParental_ParentalSettingsChange_Notification) String() string {
return proto.CompactTextString(m)
}
func (*CParental_ParentalSettingsChange_Notification) ProtoMessage() {}
func (*CParental_ParentalSettingsChange_Notification) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{22}
}
func (m *CParental_ParentalSettingsChange_Notification) GetSerializedSettings() []byte {
if m != nil {
return m.SerializedSettings
}
return nil
}
func (m *CParental_ParentalSettingsChange_Notification) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
func (m *CParental_ParentalSettingsChange_Notification) GetPassword() string {
if m != nil && m.Password != nil {
return *m.Password
}
return ""
}
func (m *CParental_ParentalSettingsChange_Notification) GetSessionid() string {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return ""
}
type CParental_ParentalUnlock_Notification struct {
Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"`
Sessionid *string `protobuf:"bytes,2,opt,name=sessionid" json:"sessionid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_ParentalUnlock_Notification) Reset() { *m = CParental_ParentalUnlock_Notification{} }
func (m *CParental_ParentalUnlock_Notification) String() string { return proto.CompactTextString(m) }
func (*CParental_ParentalUnlock_Notification) ProtoMessage() {}
func (*CParental_ParentalUnlock_Notification) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{23}
}
func (m *CParental_ParentalUnlock_Notification) GetPassword() string {
if m != nil && m.Password != nil {
return *m.Password
}
return ""
}
func (m *CParental_ParentalUnlock_Notification) GetSessionid() string {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return ""
}
type CParental_ParentalLock_Notification struct {
Sessionid *string `protobuf:"bytes,1,opt,name=sessionid" json:"sessionid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CParental_ParentalLock_Notification) Reset() { *m = CParental_ParentalLock_Notification{} }
func (m *CParental_ParentalLock_Notification) String() string { return proto.CompactTextString(m) }
func (*CParental_ParentalLock_Notification) ProtoMessage() {}
func (*CParental_ParentalLock_Notification) Descriptor() ([]byte, []int) {
return parental_fileDescriptor0, []int{24}
}
func (m *CParental_ParentalLock_Notification) GetSessionid() string {
if m != nil && m.Sessionid != nil {
return *m.Sessionid
}
return ""
}
func init() {
proto.RegisterType((*ParentalApp)(nil), "ParentalApp")
proto.RegisterType((*ParentalSettings)(nil), "ParentalSettings")
proto.RegisterType((*CParental_EnableParentalSettings_Request)(nil), "CParental_EnableParentalSettings_Request")
proto.RegisterType((*CParental_EnableParentalSettings_Response)(nil), "CParental_EnableParentalSettings_Response")
proto.RegisterType((*CParental_DisableParentalSettings_Request)(nil), "CParental_DisableParentalSettings_Request")
proto.RegisterType((*CParental_DisableParentalSettings_Response)(nil), "CParental_DisableParentalSettings_Response")
proto.RegisterType((*CParental_GetParentalSettings_Request)(nil), "CParental_GetParentalSettings_Request")
proto.RegisterType((*CParental_GetParentalSettings_Response)(nil), "CParental_GetParentalSettings_Response")
proto.RegisterType((*CParental_GetSignedParentalSettings_Request)(nil), "CParental_GetSignedParentalSettings_Request")
proto.RegisterType((*CParental_GetSignedParentalSettings_Response)(nil), "CParental_GetSignedParentalSettings_Response")
proto.RegisterType((*CParental_SetParentalSettings_Request)(nil), "CParental_SetParentalSettings_Request")
proto.RegisterType((*CParental_SetParentalSettings_Response)(nil), "CParental_SetParentalSettings_Response")
proto.RegisterType((*CParental_ValidateToken_Request)(nil), "CParental_ValidateToken_Request")
proto.RegisterType((*CParental_ValidateToken_Response)(nil), "CParental_ValidateToken_Response")
proto.RegisterType((*CParental_ValidatePassword_Request)(nil), "CParental_ValidatePassword_Request")
proto.RegisterType((*CParental_ValidatePassword_Response)(nil), "CParental_ValidatePassword_Response")
proto.RegisterType((*CParental_LockClient_Request)(nil), "CParental_LockClient_Request")
proto.RegisterType((*CParental_LockClient_Response)(nil), "CParental_LockClient_Response")
proto.RegisterType((*CParental_RequestRecoveryCode_Request)(nil), "CParental_RequestRecoveryCode_Request")
proto.RegisterType((*CParental_RequestRecoveryCode_Response)(nil), "CParental_RequestRecoveryCode_Response")
proto.RegisterType((*CParental_DisableWithRecoveryCode_Request)(nil), "CParental_DisableWithRecoveryCode_Request")
proto.RegisterType((*CParental_DisableWithRecoveryCode_Response)(nil), "CParental_DisableWithRecoveryCode_Response")
proto.RegisterType((*CParental_ParentalSettingsChange_Notification)(nil), "CParental_ParentalSettingsChange_Notification")
proto.RegisterType((*CParental_ParentalUnlock_Notification)(nil), "CParental_ParentalUnlock_Notification")
proto.RegisterType((*CParental_ParentalLock_Notification)(nil), "CParental_ParentalLock_Notification")
}
var parental_fileDescriptor0 = []byte{
// 1337 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x57, 0x41, 0x8f, 0x14, 0xc5,
0x17, 0x4f, 0xc3, 0x02, 0xbb, 0xb5, 0xb3, 0xcb, 0x52, 0xf0, 0x87, 0x66, 0xfe, 0x02, 0x65, 0x2f,
0xc2, 0x02, 0x4b, 0x6b, 0x56, 0x23, 0x26, 0x26, 0x12, 0x58, 0x0d, 0x26, 0x2e, 0x88, 0x0c, 0x8a,
0x09, 0x89, 0x9d, 0xda, 0xee, 0xda, 0xd9, 0x92, 0x9e, 0xaa, 0xb6, 0xab, 0x86, 0x75, 0x3d, 0x19,
0x63, 0xbc, 0x19, 0x2f, 0x1e, 0x34, 0xf1, 0x6e, 0xa2, 0x5e, 0x89, 0x57, 0x13, 0xbf, 0x80, 0xf1,
0x53, 0xf8, 0x31, 0x7c, 0x5d, 0xd5, 0x3d, 0xd3, 0xbd, 0xd3, 0x33, 0xd3, 0x23, 0xb7, 0x99, 0xaa,
0xf7, 0x5e, 0xfd, 0xde, 0x7b, 0xbf, 0x7a, 0xbf, 0x6a, 0xb4, 0xa6, 0x34, 0xa3, 0xbd, 0x1e, 0x53,
0x8a, 0x76, 0x99, 0x0a, 0x12, 0x9a, 0x32, 0xa1, 0x69, 0xec, 0x9b, 0xe5, 0x30, 0xe6, 0xf0, 0xcf,
0x4f, 0x52, 0xa9, 0x65, 0x7b, 0xbd, 0x6a, 0xd9, 0x17, 0x7c, 0x87, 0xb3, 0x28, 0xd8, 0xa6, 0x8a,
0x8d, 0x5a, 0x7b, 0xaf, 0xa0, 0xc5, 0xfb, 0x79, 0xac, 0x5b, 0x49, 0x82, 0x97, 0xd0, 0x11, 0x9a,
0x24, 0x3c, 0x72, 0x1d, 0xe2, 0xac, 0x2d, 0x61, 0x8c, 0x10, 0x57, 0x01, 0x8d, 0x63, 0xb9, 0xc7,
0x22, 0xf7, 0x10, 0xac, 0xcd, 0x7b, 0xbf, 0x1d, 0x42, 0x2b, 0x85, 0x4b, 0x87, 0x69, 0xcd, 0x45,
0x57, 0xe1, 0xe3, 0xe8, 0x98, 0x89, 0x9d, 0x7b, 0x1e, 0xc5, 0x67, 0xd0, 0x71, 0x08, 0x14, 0x73,
0xa5, 0xcd, 0xc9, 0x01, 0xb7, 0xee, 0x4b, 0x98, 0x20, 0xb7, 0xb2, 0x11, 0x31, 0x15, 0xa6, 0x3c,
0xd1, 0x5c, 0x0a, 0xf7, 0x30, 0x58, 0x2c, 0x60, 0x0f, 0xb5, 0xca, 0x16, 0xee, 0x1c, 0x39, 0xbc,
0xb6, 0xb8, 0xd1, 0xf2, 0xcb, 0x38, 0x2f, 0xa2, 0xe5, 0xc2, 0x26, 0xec, 0x2b, 0x2d, 0x7b, 0xee,
0x91, 0x1a, 0x2b, 0x17, 0xad, 0x24, 0x54, 0xa9, 0x3d, 0x99, 0x46, 0xbb, 0x54, 0xed, 0xea, 0xfd,
0x84, 0xb9, 0x47, 0x0d, 0x8a, 0x16, 0x9a, 0x53, 0x34, 0xd6, 0xee, 0x31, 0xf8, 0xd7, 0xc2, 0xa7,
0x50, 0xab, 0x6c, 0xe7, 0xce, 0x9b, 0x55, 0x9b, 0x3c, 0x13, 0x74, 0x3b, 0x86, 0xe4, 0x17, 0xb2,
0xe4, 0xb3, 0x88, 0xf9, 0x42, 0xb0, 0xc3, 0xa8, 0xee, 0xa7, 0x4c, 0xb9, 0xc8, 0x44, 0x3c, 0x8d,
0x96, 0x53, 0x16, 0xca, 0xa7, 0x2c, 0xdd, 0x0f, 0x58, 0x8f, 0xf2, 0xd8, 0x5d, 0xcc, 0xb2, 0xf1,
0x7e, 0x74, 0xd0, 0xda, 0x66, 0x01, 0x2a, 0x78, 0xc7, 0x38, 0x1f, 0x2c, 0x5f, 0xf0, 0x80, 0x7d,
0xd6, 0x67, 0x4a, 0xe3, 0x15, 0x34, 0x5f, 0x00, 0x31, 0x75, 0x5c, 0xc0, 0xab, 0x68, 0x5e, 0xe5,
0x56, 0xa6, 0x80, 0x8b, 0x1b, 0x27, 0xfc, 0x91, 0xea, 0x9f, 0x40, 0x0b, 0x0a, 0xfa, 0x0d, 0x25,
0x84, 0x32, 0xdb, 0x22, 0x02, 0x78, 0x0b, 0x34, 0x94, 0x51, 0x56, 0xc2, 0x0c, 0x62, 0xa9, 0x49,
0x19, 0xe6, 0xa3, 0xde, 0x35, 0x74, 0xa5, 0x01, 0x34, 0x95, 0x48, 0xa1, 0x98, 0x77, 0xaf, 0x6c,
0xfc, 0x36, 0x57, 0x33, 0x26, 0x32, 0x72, 0xf8, 0x3a, 0xba, 0xda, 0x24, 0x5e, 0x7e, 0xfa, 0x1b,
0xe8, 0xa5, 0xa1, 0xf5, 0x1d, 0xa6, 0xc7, 0x9e, 0x3c, 0x72, 0xce, 0x5d, 0x74, 0x69, 0x9a, 0xa7,
0x3d, 0xa3, 0x52, 0x6b, 0x67, 0x4c, 0xad, 0xbd, 0x9b, 0xe8, 0x5a, 0x25, 0x5c, 0x87, 0x77, 0x05,
0x8b, 0x26, 0x16, 0x22, 0xe5, 0x32, 0xe5, 0x7a, 0xdf, 0xde, 0x29, 0xef, 0x13, 0xb4, 0xde, 0x2c,
0x40, 0x8e, 0xea, 0xff, 0xe8, 0xa4, 0x62, 0x29, 0xa7, 0x31, 0xff, 0x02, 0x58, 0x57, 0x01, 0xd8,
0x32, 0x9d, 0x07, 0x7f, 0xc3, 0x44, 0xc3, 0x8f, 0x96, 0xf7, 0x83, 0x53, 0x2e, 0x55, 0x67, 0x42,
0xa9, 0xfe, 0x23, 0xdb, 0xe0, 0xb6, 0x08, 0xb6, 0x17, 0x0c, 0x5c, 0x2d, 0xe1, 0x2a, 0x1c, 0x9c,
0xab, 0x6f, 0xf9, 0x5a, 0xb9, 0x15, 0x9d, 0x09, 0xad, 0xf0, 0x6e, 0xa0, 0x0b, 0x43, 0xcb, 0x8f,
0x20, 0xf7, 0x88, 0x6a, 0xf6, 0x50, 0x3e, 0x61, 0x62, 0x80, 0x1e, 0x60, 0xf4, 0x45, 0x2c, 0xc3,
0x27, 0x81, 0xce, 0xd6, 0x6d, 0x06, 0x9e, 0x87, 0xc8, 0x78, 0xc7, 0x3c, 0x78, 0x17, 0x79, 0xa3,
0x36, 0xf7, 0xf3, 0x74, 0xa6, 0x50, 0xd8, 0xa6, 0x68, 0x8a, 0xb3, 0x80, 0xcf, 0xa3, 0xd3, 0x8a,
0x89, 0x28, 0xc8, 0x71, 0x48, 0x11, 0xa8, 0x7e, 0x18, 0x82, 0x89, 0xa9, 0xc9, 0xbc, 0xf7, 0x1a,
0x5a, 0x9d, 0x78, 0x50, 0xde, 0x61, 0x18, 0xba, 0xe5, 0x14, 0x5e, 0x46, 0x2f, 0x0c, 0xbd, 0xb6,
0x20, 0xf0, 0xa6, 0x19, 0xd8, 0x15, 0x86, 0xe7, 0x30, 0xac, 0xc3, 0x05, 0x74, 0x6e, 0x8c, 0x43,
0x9e, 0xf0, 0xe5, 0x32, 0x23, 0xf2, 0x30, 0x0f, 0xf2, 0x61, 0xb5, 0x09, 0xf3, 0xa1, 0x58, 0xab,
0x36, 0xa8, 0xde, 0x30, 0x0f, 0xd9, 0xa9, 0x99, 0x06, 0x8f, 0xb8, 0xde, 0xad, 0x0b, 0x8b, 0xff,
0x87, 0x96, 0x06, 0xb3, 0xd1, 0xcc, 0x23, 0xa7, 0x7e, 0x1e, 0xd5, 0x8d, 0x84, 0x9a, 0xa0, 0x39,
0x84, 0xaf, 0x1d, 0x74, 0x7d, 0x68, 0x7e, 0x90, 0x4b, 0x9b, 0xbb, 0x54, 0x74, 0x59, 0x70, 0x4f,
0x6a, 0xd0, 0xbf, 0x90, 0x66, 0xfa, 0x32, 0xeb, 0x55, 0xaa, 0x50, 0x60, 0x1c, 0xcb, 0xbd, 0xad,
0x72, 0x71, 0x8b, 0x1f, 0x1f, 0x5a, 0x46, 0x54, 0x4e, 0x1f, 0x25, 0x54, 0x25, 0x9a, 0xa1, 0x14,
0xcc, 0xb9, 0xd5, 0xd1, 0x68, 0x5b, 0x23, 0xb1, 0x2a, 0x9e, 0x26, 0xd8, 0xc6, 0xdf, 0xcb, 0x68,
0xbe, 0x70, 0xc0, 0x7f, 0x39, 0xe8, 0x74, 0xfd, 0x40, 0xc7, 0x57, 0xfc, 0xa6, 0x72, 0xd4, 0xbe,
0xea, 0x37, 0x97, 0x87, 0xe0, 0xab, 0x67, 0xee, 0x63, 0x6b, 0x44, 0x8a, 0xd7, 0x09, 0x29, 0x4a,
0x4c, 0x76, 0x64, 0x4a, 0xf4, 0x2e, 0x23, 0xb1, 0xec, 0x76, 0x59, 0x44, 0xb8, 0x20, 0x34, 0x0c,
0x65, 0x5f, 0xe8, 0x75, 0x22, 0x8d, 0xf6, 0xc3, 0x1b, 0x63, 0xbf, 0x30, 0x37, 0x96, 0x61, 0x3f,
0xcd, 0x82, 0x0c, 0x42, 0xe0, 0x5f, 0x1d, 0x74, 0x66, 0x8c, 0x4c, 0xe0, 0x32, 0xd0, 0x29, 0xd2,
0xd4, 0xbe, 0xe6, 0xcf, 0x20, 0x3b, 0x37, 0x20, 0xab, 0x57, 0x73, 0xab, 0x59, 0xd2, 0xc2, 0x3f,
0x3b, 0xe8, 0x64, 0x8d, 0xd8, 0xe0, 0x4b, 0x7e, 0x23, 0x19, 0x6b, 0x5f, 0xf6, 0x9b, 0x89, 0x96,
0x77, 0x13, 0x10, 0xbe, 0x09, 0x16, 0x95, 0xa2, 0xcd, 0x82, 0xf4, 0x1f, 0x07, 0x9d, 0x1d, 0x2b,
0x43, 0x78, 0xdd, 0x9f, 0x41, 0xed, 0xda, 0xd7, 0xfd, 0x59, 0xa4, 0xcd, 0x13, 0x80, 0xfd, 0xd3,
0xe7, 0xc0, 0x6e, 0x7e, 0x66, 0xdb, 0x3d, 0xd8, 0xa7, 0x9a, 0x84, 0x54, 0x90, 0xed, 0x7d, 0x02,
0xa3, 0xc2, 0xbc, 0x79, 0xb3, 0xdf, 0x99, 0x1f, 0xcc, 0x1e, 0xc6, 0x61, 0xd1, 0x34, 0xa5, 0x33,
0xa5, 0x29, 0x9d, 0x86, 0x4d, 0xe9, 0x4c, 0x6d, 0x4a, 0xe7, 0x39, 0x9a, 0x02, 0x48, 0x97, 0x2a,
0xea, 0x85, 0x89, 0x3f, 0x45, 0x10, 0xdb, 0x2f, 0xfa, 0x53, 0x95, 0xef, 0x03, 0xc0, 0x75, 0x77,
0x73, 0x97, 0x85, 0x4f, 0x08, 0xdf, 0x31, 0x47, 0x77, 0xa1, 0x30, 0x62, 0x08, 0xcd, 0x2a, 0x19,
0x31, 0x72, 0x44, 0xb8, 0x22, 0xa1, 0x04, 0xec, 0xa1, 0x9e, 0x80, 0xf4, 0x77, 0x07, 0xad, 0x1c,
0x94, 0x36, 0xbc, 0xea, 0x4f, 0x17, 0xd8, 0xf6, 0x45, 0xbf, 0x81, 0x38, 0x7a, 0x1f, 0x03, 0xe4,
0x87, 0xc5, 0xb6, 0xc1, 0x90, 0xc4, 0x94, 0x0b, 0xcd, 0x3e, 0xcf, 0x2a, 0x6a, 0xad, 0x27, 0x30,
0x84, 0x8a, 0x08, 0xfa, 0x0f, 0x33, 0x1d, 0x96, 0x44, 0x25, 0x3d, 0xfc, 0x9d, 0x83, 0xd0, 0x50,
0x2d, 0xf1, 0x39, 0x7f, 0x92, 0xea, 0xb6, 0xcf, 0xfb, 0x93, 0x35, 0xf6, 0x36, 0xe0, 0x7c, 0xcb,
0xcc, 0xe8, 0x7d, 0xa8, 0x9a, 0x10, 0x50, 0x35, 0x40, 0x62, 0xbf, 0xb5, 0x94, 0xa5, 0x27, 0x25,
0xe6, 0x74, 0xf8, 0xc4, 0x20, 0x32, 0x34, 0xac, 0xb0, 0x50, 0xc9, 0x76, 0x2a, 0xf7, 0x40, 0x98,
0xf0, 0x9f, 0xc0, 0xcf, 0x1a, 0xd5, 0xad, 0xf0, 0x73, 0x82, 0x7c, 0x57, 0xf8, 0x39, 0x51, 0xbd,
0x1f, 0x03, 0xd8, 0x47, 0xb9, 0x05, 0x9c, 0x5f, 0x88, 0x33, 0xc9, 0xc4, 0x99, 0x6c, 0x33, 0x60,
0x28, 0x94, 0x4e, 0xcb, 0xe2, 0xf6, 0xd8, 0x4d, 0xf3, 0x55, 0x43, 0x68, 0x14, 0xc1, 0x47, 0xcf,
0x90, 0xbb, 0x2a, 0x61, 0xa1, 0xbd, 0x6d, 0x05, 0x23, 0x7e, 0x19, 0x0e, 0xea, 0x83, 0xe2, 0x5d,
0x37, 0xa8, 0xc7, 0xbd, 0x1a, 0xea, 0x06, 0xf5, 0xf8, 0xc7, 0xc0, 0xeb, 0x90, 0xd1, 0xc6, 0x2d,
0xad, 0x59, 0x2f, 0xa9, 0x64, 0x94, 0x77, 0x5c, 0x8a, 0x7a, 0xb0, 0xed, 0x73, 0xe0, 0x77, 0xf6,
0xfe, 0xc8, 0xcd, 0x84, 0x6e, 0x3c, 0xe5, 0x21, 0xdb, 0xf8, 0x66, 0x0e, 0x2d, 0x17, 0xbb, 0x39,
0x4f, 0x7e, 0x72, 0xd0, 0x29, 0xdb, 0xe7, 0xea, 0x53, 0x03, 0xfb, 0xfe, 0x4c, 0xaf, 0x91, 0xf6,
0xa2, 0x7f, 0x4f, 0x0e, 0xf0, 0xdf, 0x01, 0x1c, 0x9b, 0xe5, 0x6d, 0xb2, 0x93, 0xca, 0x9e, 0xc1,
0xc1, 0xd2, 0xac, 0x15, 0x96, 0x49, 0x44, 0xee, 0x40, 0x76, 0xa1, 0x89, 0x96, 0x71, 0x67, 0x64,
0xa6, 0xe0, 0xef, 0x1d, 0xd4, 0xb2, 0xf0, 0xec, 0x1b, 0xa4, 0x42, 0x9e, 0x09, 0xcf, 0x93, 0x2a,
0x9c, 0xf7, 0x01, 0xce, 0x7b, 0x0d, 0xe0, 0x58, 0x5e, 0x0f, 0x2e, 0xd6, 0x78, 0x6a, 0x7f, 0x0b,
0x97, 0xcd, 0xc2, 0xca, 0x2e, 0x0f, 0xbe, 0xe8, 0x37, 0x78, 0xe5, 0x54, 0x21, 0x6d, 0x01, 0xa4,
0x77, 0x1b, 0x43, 0x9a, 0x72, 0xd5, 0xda, 0x3e, 0x44, 0xbb, 0x34, 0xda, 0xf7, 0x3c, 0x86, 0x28,
0x1d, 0xa3, 0xfe, 0x78, 0xe6, 0x1e, 0xba, 0x7d, 0xf8, 0x4b, 0xc7, 0xf9, 0x37, 0x00, 0x00, 0xff,
0xff, 0xc4, 0x79, 0x5c, 0x8e, 0x85, 0x11, 0x00, 0x00,
}

View File

@ -0,0 +1,456 @@
// Code generated by protoc-gen-go.
// source: steammessages_partnerapps.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type CPartnerApps_RequestUploadToken_Request struct {
Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"`
Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_RequestUploadToken_Request) Reset() {
*m = CPartnerApps_RequestUploadToken_Request{}
}
func (m *CPartnerApps_RequestUploadToken_Request) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_RequestUploadToken_Request) ProtoMessage() {}
func (*CPartnerApps_RequestUploadToken_Request) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{0}
}
func (m *CPartnerApps_RequestUploadToken_Request) GetFilename() string {
if m != nil && m.Filename != nil {
return *m.Filename
}
return ""
}
func (m *CPartnerApps_RequestUploadToken_Request) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
type CPartnerApps_RequestUploadToken_Response struct {
UploadToken *uint64 `protobuf:"varint,1,opt,name=upload_token" json:"upload_token,omitempty"`
Location *string `protobuf:"bytes,2,opt,name=location" json:"location,omitempty"`
RoutingId *uint64 `protobuf:"varint,3,opt,name=routing_id" json:"routing_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_RequestUploadToken_Response) Reset() {
*m = CPartnerApps_RequestUploadToken_Response{}
}
func (m *CPartnerApps_RequestUploadToken_Response) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_RequestUploadToken_Response) ProtoMessage() {}
func (*CPartnerApps_RequestUploadToken_Response) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{1}
}
func (m *CPartnerApps_RequestUploadToken_Response) GetUploadToken() uint64 {
if m != nil && m.UploadToken != nil {
return *m.UploadToken
}
return 0
}
func (m *CPartnerApps_RequestUploadToken_Response) GetLocation() string {
if m != nil && m.Location != nil {
return *m.Location
}
return ""
}
func (m *CPartnerApps_RequestUploadToken_Response) GetRoutingId() uint64 {
if m != nil && m.RoutingId != nil {
return *m.RoutingId
}
return 0
}
type CPartnerApps_FinishUpload_Request struct {
UploadToken *uint64 `protobuf:"varint,1,opt,name=upload_token" json:"upload_token,omitempty"`
RoutingId *uint64 `protobuf:"varint,2,opt,name=routing_id" json:"routing_id,omitempty"`
AppId *uint32 `protobuf:"varint,3,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_FinishUpload_Request) Reset() { *m = CPartnerApps_FinishUpload_Request{} }
func (m *CPartnerApps_FinishUpload_Request) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_FinishUpload_Request) ProtoMessage() {}
func (*CPartnerApps_FinishUpload_Request) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{2}
}
func (m *CPartnerApps_FinishUpload_Request) GetUploadToken() uint64 {
if m != nil && m.UploadToken != nil {
return *m.UploadToken
}
return 0
}
func (m *CPartnerApps_FinishUpload_Request) GetRoutingId() uint64 {
if m != nil && m.RoutingId != nil {
return *m.RoutingId
}
return 0
}
func (m *CPartnerApps_FinishUpload_Request) GetAppId() uint32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
type CPartnerApps_FinishUploadKVSign_Response struct {
SignedInstallscript *string `protobuf:"bytes,1,opt,name=signed_installscript" json:"signed_installscript,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_FinishUploadKVSign_Response) Reset() {
*m = CPartnerApps_FinishUploadKVSign_Response{}
}
func (m *CPartnerApps_FinishUploadKVSign_Response) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_FinishUploadKVSign_Response) ProtoMessage() {}
func (*CPartnerApps_FinishUploadKVSign_Response) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{3}
}
func (m *CPartnerApps_FinishUploadKVSign_Response) GetSignedInstallscript() string {
if m != nil && m.SignedInstallscript != nil {
return *m.SignedInstallscript
}
return ""
}
type CPartnerApps_FinishUploadLegacyDRM_Request struct {
UploadToken *uint64 `protobuf:"varint,1,opt,name=upload_token" json:"upload_token,omitempty"`
RoutingId *uint64 `protobuf:"varint,2,opt,name=routing_id" json:"routing_id,omitempty"`
AppId *uint32 `protobuf:"varint,3,opt,name=app_id" json:"app_id,omitempty"`
Flags *uint32 `protobuf:"varint,4,opt,name=flags" json:"flags,omitempty"`
ToolName *string `protobuf:"bytes,5,opt,name=tool_name" json:"tool_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Request) Reset() {
*m = CPartnerApps_FinishUploadLegacyDRM_Request{}
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Request) String() string {
return proto.CompactTextString(m)
}
func (*CPartnerApps_FinishUploadLegacyDRM_Request) ProtoMessage() {}
func (*CPartnerApps_FinishUploadLegacyDRM_Request) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{4}
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetUploadToken() uint64 {
if m != nil && m.UploadToken != nil {
return *m.UploadToken
}
return 0
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetRoutingId() uint64 {
if m != nil && m.RoutingId != nil {
return *m.RoutingId
}
return 0
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetAppId() uint32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetFlags() uint32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return 0
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetToolName() string {
if m != nil && m.ToolName != nil {
return *m.ToolName
}
return ""
}
type CPartnerApps_FinishUploadLegacyDRM_Response struct {
FileId *string `protobuf:"bytes,1,opt,name=file_id" json:"file_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Response) Reset() {
*m = CPartnerApps_FinishUploadLegacyDRM_Response{}
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Response) String() string {
return proto.CompactTextString(m)
}
func (*CPartnerApps_FinishUploadLegacyDRM_Response) ProtoMessage() {}
func (*CPartnerApps_FinishUploadLegacyDRM_Response) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{5}
}
func (m *CPartnerApps_FinishUploadLegacyDRM_Response) GetFileId() string {
if m != nil && m.FileId != nil {
return *m.FileId
}
return ""
}
type CPartnerApps_FinishUpload_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_FinishUpload_Response) Reset() { *m = CPartnerApps_FinishUpload_Response{} }
func (m *CPartnerApps_FinishUpload_Response) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_FinishUpload_Response) ProtoMessage() {}
func (*CPartnerApps_FinishUpload_Response) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{6}
}
type CPartnerApps_FindDRMUploads_Request struct {
AppId *int32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_FindDRMUploads_Request) Reset() { *m = CPartnerApps_FindDRMUploads_Request{} }
func (m *CPartnerApps_FindDRMUploads_Request) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_FindDRMUploads_Request) ProtoMessage() {}
func (*CPartnerApps_FindDRMUploads_Request) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{7}
}
func (m *CPartnerApps_FindDRMUploads_Request) GetAppId() int32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
type CPartnerApps_ExistingDRMUpload struct {
FileId *string `protobuf:"bytes,1,opt,name=file_id" json:"file_id,omitempty"`
AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"`
ActorId *int32 `protobuf:"varint,3,opt,name=actor_id" json:"actor_id,omitempty"`
SuppliedName *string `protobuf:"bytes,5,opt,name=supplied_name" json:"supplied_name,omitempty"`
Flags *uint32 `protobuf:"varint,6,opt,name=flags" json:"flags,omitempty"`
ModType *string `protobuf:"bytes,7,opt,name=mod_type" json:"mod_type,omitempty"`
Timestamp *uint32 `protobuf:"fixed32,8,opt,name=timestamp" json:"timestamp,omitempty"`
OrigFileId *string `protobuf:"bytes,9,opt,name=orig_file_id" json:"orig_file_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_ExistingDRMUpload) Reset() { *m = CPartnerApps_ExistingDRMUpload{} }
func (m *CPartnerApps_ExistingDRMUpload) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_ExistingDRMUpload) ProtoMessage() {}
func (*CPartnerApps_ExistingDRMUpload) Descriptor() ([]byte, []int) { return partnerapps_fileDescriptor0, []int{8} }
func (m *CPartnerApps_ExistingDRMUpload) GetFileId() string {
if m != nil && m.FileId != nil {
return *m.FileId
}
return ""
}
func (m *CPartnerApps_ExistingDRMUpload) GetAppId() uint32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
func (m *CPartnerApps_ExistingDRMUpload) GetActorId() int32 {
if m != nil && m.ActorId != nil {
return *m.ActorId
}
return 0
}
func (m *CPartnerApps_ExistingDRMUpload) GetSuppliedName() string {
if m != nil && m.SuppliedName != nil {
return *m.SuppliedName
}
return ""
}
func (m *CPartnerApps_ExistingDRMUpload) GetFlags() uint32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return 0
}
func (m *CPartnerApps_ExistingDRMUpload) GetModType() string {
if m != nil && m.ModType != nil {
return *m.ModType
}
return ""
}
func (m *CPartnerApps_ExistingDRMUpload) GetTimestamp() uint32 {
if m != nil && m.Timestamp != nil {
return *m.Timestamp
}
return 0
}
func (m *CPartnerApps_ExistingDRMUpload) GetOrigFileId() string {
if m != nil && m.OrigFileId != nil {
return *m.OrigFileId
}
return ""
}
type CPartnerApps_FindDRMUploads_Response struct {
Uploads []*CPartnerApps_ExistingDRMUpload `protobuf:"bytes,1,rep,name=uploads" json:"uploads,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_FindDRMUploads_Response) Reset() { *m = CPartnerApps_FindDRMUploads_Response{} }
func (m *CPartnerApps_FindDRMUploads_Response) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_FindDRMUploads_Response) ProtoMessage() {}
func (*CPartnerApps_FindDRMUploads_Response) Descriptor() ([]byte, []int) {
return partnerapps_fileDescriptor0, []int{9}
}
func (m *CPartnerApps_FindDRMUploads_Response) GetUploads() []*CPartnerApps_ExistingDRMUpload {
if m != nil {
return m.Uploads
}
return nil
}
type CPartnerApps_Download_Request struct {
FileId *string `protobuf:"bytes,1,opt,name=file_id" json:"file_id,omitempty"`
AppId *int32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_Download_Request) Reset() { *m = CPartnerApps_Download_Request{} }
func (m *CPartnerApps_Download_Request) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_Download_Request) ProtoMessage() {}
func (*CPartnerApps_Download_Request) Descriptor() ([]byte, []int) { return partnerapps_fileDescriptor0, []int{10} }
func (m *CPartnerApps_Download_Request) GetFileId() string {
if m != nil && m.FileId != nil {
return *m.FileId
}
return ""
}
func (m *CPartnerApps_Download_Request) GetAppId() int32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
type CPartnerApps_Download_Response struct {
DownloadUrl *string `protobuf:"bytes,1,opt,name=download_url" json:"download_url,omitempty"`
AppId *int32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPartnerApps_Download_Response) Reset() { *m = CPartnerApps_Download_Response{} }
func (m *CPartnerApps_Download_Response) String() string { return proto.CompactTextString(m) }
func (*CPartnerApps_Download_Response) ProtoMessage() {}
func (*CPartnerApps_Download_Response) Descriptor() ([]byte, []int) { return partnerapps_fileDescriptor0, []int{11} }
func (m *CPartnerApps_Download_Response) GetDownloadUrl() string {
if m != nil && m.DownloadUrl != nil {
return *m.DownloadUrl
}
return ""
}
func (m *CPartnerApps_Download_Response) GetAppId() int32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
func init() {
proto.RegisterType((*CPartnerApps_RequestUploadToken_Request)(nil), "CPartnerApps_RequestUploadToken_Request")
proto.RegisterType((*CPartnerApps_RequestUploadToken_Response)(nil), "CPartnerApps_RequestUploadToken_Response")
proto.RegisterType((*CPartnerApps_FinishUpload_Request)(nil), "CPartnerApps_FinishUpload_Request")
proto.RegisterType((*CPartnerApps_FinishUploadKVSign_Response)(nil), "CPartnerApps_FinishUploadKVSign_Response")
proto.RegisterType((*CPartnerApps_FinishUploadLegacyDRM_Request)(nil), "CPartnerApps_FinishUploadLegacyDRM_Request")
proto.RegisterType((*CPartnerApps_FinishUploadLegacyDRM_Response)(nil), "CPartnerApps_FinishUploadLegacyDRM_Response")
proto.RegisterType((*CPartnerApps_FinishUpload_Response)(nil), "CPartnerApps_FinishUpload_Response")
proto.RegisterType((*CPartnerApps_FindDRMUploads_Request)(nil), "CPartnerApps_FindDRMUploads_Request")
proto.RegisterType((*CPartnerApps_ExistingDRMUpload)(nil), "CPartnerApps_ExistingDRMUpload")
proto.RegisterType((*CPartnerApps_FindDRMUploads_Response)(nil), "CPartnerApps_FindDRMUploads_Response")
proto.RegisterType((*CPartnerApps_Download_Request)(nil), "CPartnerApps_Download_Request")
proto.RegisterType((*CPartnerApps_Download_Response)(nil), "CPartnerApps_Download_Response")
}
var partnerapps_fileDescriptor0 = []byte{
// 809 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x96, 0x4f, 0x6f, 0xd3, 0x4a,
0x14, 0xc5, 0xe5, 0xb6, 0x69, 0x9a, 0xe9, 0x4b, 0xdf, 0x7b, 0x56, 0x2b, 0x45, 0x11, 0xb4, 0xc6,
0x2d, 0x22, 0xb4, 0xd5, 0x50, 0x15, 0x21, 0x36, 0x08, 0x95, 0xa6, 0x7f, 0x10, 0x05, 0x84, 0x5a,
0x40, 0x6c, 0x50, 0x34, 0x75, 0x26, 0xe9, 0x08, 0xdb, 0x63, 0x3c, 0x63, 0x68, 0x77, 0x88, 0x15,
0x1b, 0x3e, 0x00, 0x7b, 0x76, 0x20, 0x24, 0x24, 0xfa, 0xfd, 0xb8, 0x33, 0xb6, 0x13, 0x3b, 0x69,
0x53, 0x23, 0x84, 0x58, 0x66, 0x7c, 0x7d, 0xee, 0x6f, 0xce, 0xdc, 0x39, 0x31, 0x5a, 0x11, 0x92,
0x12, 0xcf, 0xa3, 0x42, 0x90, 0x2e, 0x15, 0xad, 0x80, 0x84, 0xd2, 0xa7, 0x21, 0x09, 0x02, 0x81,
0xf5, 0x13, 0xc7, 0x65, 0xd4, 0x97, 0x38, 0x08, 0xb9, 0xe4, 0xf5, 0xd5, 0x7c, 0x71, 0xe4, 0xb3,
0x0e, 0xa3, 0xed, 0xd6, 0x21, 0x11, 0x74, 0xb8, 0xda, 0x7e, 0x80, 0xae, 0x35, 0x9f, 0xc4, 0x7a,
0xf7, 0x40, 0xaf, 0xb5, 0x4f, 0x5f, 0x47, 0x54, 0xc8, 0x67, 0x81, 0xcb, 0x49, 0xfb, 0x29, 0x7f,
0x45, 0xfd, 0x74, 0xc9, 0xfc, 0x0f, 0x4d, 0x75, 0x98, 0x4b, 0x7d, 0xe2, 0xd1, 0x9a, 0x61, 0x19,
0x8d, 0x8a, 0x59, 0x45, 0x25, 0x80, 0x60, 0xed, 0xda, 0x18, 0xfc, 0xac, 0xda, 0x1d, 0xd4, 0xb8,
0x58, 0x4b, 0x04, 0xdc, 0x17, 0xd4, 0x9c, 0x45, 0xff, 0x44, 0x7a, 0xbd, 0x25, 0xd5, 0x03, 0x2d,
0x38, 0xa1, 0x5a, 0xb8, 0xdc, 0x21, 0x92, 0x71, 0x5f, 0x6b, 0x56, 0x4c, 0x13, 0xa1, 0x90, 0x47,
0x92, 0xf9, 0xdd, 0x16, 0xf4, 0x19, 0x57, 0x55, 0xf6, 0x4b, 0x74, 0x25, 0xd7, 0x67, 0x87, 0xf9,
0x4c, 0x1c, 0xc5, 0x6d, 0x7a, 0xb4, 0x67, 0x37, 0xc8, 0xcb, 0x8d, 0xe9, 0xb5, 0x19, 0x34, 0x09,
0xbb, 0x48, 0xe5, 0xab, 0xf6, 0xfd, 0x81, 0x6d, 0x64, 0xe5, 0xf7, 0x9e, 0x1f, 0xb0, 0x6e, 0x66,
0x1b, 0x97, 0xd0, 0xac, 0x80, 0x05, 0xf0, 0x97, 0xf9, 0x42, 0x12, 0xd7, 0x15, 0x4e, 0xc8, 0x02,
0x19, 0xfb, 0x63, 0x7f, 0x30, 0xd0, 0xf2, 0xb9, 0x52, 0x0f, 0x69, 0x97, 0x38, 0x27, 0x5b, 0xfb,
0x8f, 0x7e, 0x1f, 0x59, 0x1d, 0x44, 0xc7, 0x25, 0x5d, 0x51, 0x9b, 0xd0, 0x3f, 0xff, 0x47, 0x15,
0xc9, 0xb9, 0xdb, 0xd2, 0x47, 0x55, 0xd2, 0x28, 0x77, 0xd1, 0x4a, 0x21, 0x92, 0x64, 0x5f, 0xff,
0xa2, 0xb2, 0x3a, 0x6b, 0xd5, 0x21, 0xde, 0xca, 0x12, 0xb2, 0x47, 0x79, 0x1e, 0xbf, 0x66, 0xdf,
0x42, 0x8b, 0x83, 0x55, 0x6d, 0xd0, 0x8d, 0xcb, 0x7a, 0x03, 0x91, 0xc1, 0x57, 0xe2, 0x25, 0xfb,
0x87, 0x81, 0xe6, 0x73, 0xef, 0x6d, 0x1f, 0x33, 0xa1, 0x76, 0xdc, 0x7b, 0x77, 0x08, 0x28, 0xa3,
0xa1, 0x87, 0x4f, 0x8d, 0x0e, 0x71, 0x24, 0x0f, 0x53, 0x53, 0x4a, 0xe6, 0x1c, 0xaa, 0x8a, 0x28,
0x08, 0x5c, 0x35, 0xfd, 0x7d, 0x27, 0xfa, 0x5e, 0x4d, 0xa6, 0xef, 0x79, 0x1c, 0x1c, 0x3f, 0x09,
0x68, 0xad, 0xac, 0x0b, 0x94, 0x7b, 0x0c, 0xee, 0x8f, 0x24, 0x5e, 0x50, 0x9b, 0x82, 0xa5, 0xb2,
0x3a, 0x19, 0x1e, 0xb2, 0x6e, 0x2b, 0x45, 0xa8, 0x68, 0x4f, 0x5e, 0xa0, 0xa5, 0xd1, 0xbb, 0x4d,
0xcc, 0x5c, 0x43, 0xe5, 0xf8, 0x5c, 0x05, 0xb0, 0x8f, 0x37, 0xa6, 0xd7, 0x17, 0xf0, 0xe8, 0xdd,
0xda, 0x1b, 0xe8, 0x72, 0xae, 0x62, 0x8b, 0xbf, 0xf5, 0x73, 0xd3, 0x7d, 0x81, 0x1d, 0x25, 0x7b,
0x67, 0xc0, 0xd1, 0x8c, 0x42, 0xff, 0x06, 0xb6, 0xd3, 0xc5, 0x28, 0x74, 0xcf, 0xd6, 0x59, 0xff,
0x8a, 0xd0, 0x74, 0x46, 0xc7, 0xfc, 0x6e, 0xa0, 0x5a, 0x02, 0x11, 0xdf, 0x85, 0xcc, 0xed, 0x36,
0x1b, 0xb8, 0x60, 0x96, 0xd4, 0xaf, 0xe3, 0xa2, 0x49, 0x61, 0x6f, 0xbc, 0x3f, 0xad, 0xdd, 0x49,
0x0a, 0xac, 0xd8, 0x47, 0x4b, 0xdf, 0x0f, 0xab, 0xc3, 0x43, 0x2b, 0x77, 0xed, 0x2c, 0xe5, 0x49,
0x5a, 0x73, 0xc3, 0x52, 0x37, 0x13, 0x6c, 0x35, 0xbf, 0x19, 0x68, 0x2e, 0x11, 0xe8, 0x59, 0xfc,
0xd7, 0x80, 0xe9, 0x31, 0x75, 0x22, 0x49, 0x0e, 0x01, 0x34, 0x4f, 0x0b, 0x79, 0xec, 0x40, 0x68,
0x2b, 0xe0, 0xd3, 0x3e, 0x70, 0x73, 0x7b, 0xf7, 0x8f, 0x03, 0xef, 0x02, 0x70, 0xf3, 0x5c, 0x60,
0x27, 0x12, 0x92, 0x7b, 0x85, 0xb8, 0xbf, 0x18, 0xc8, 0x1c, 0x4e, 0x4b, 0xd3, 0xc6, 0x17, 0xc6,
0xf5, 0x20, 0xee, 0x88, 0xcc, 0xb5, 0x77, 0x00, 0x77, 0xb3, 0xc9, 0x3d, 0x8f, 0x49, 0xcb, 0xa3,
0xf2, 0x88, 0x2b, 0x5a, 0x7d, 0xd8, 0x16, 0xf1, 0x07, 0x06, 0x82, 0x74, 0x24, 0x0d, 0xd5, 0x72,
0x82, 0xcb, 0x84, 0xe5, 0x70, 0x2f, 0x70, 0xa9, 0xa4, 0xe6, 0x67, 0x70, 0x39, 0xdb, 0xa7, 0x1f,
0x36, 0x2b, 0xb8, 0x78, 0x6a, 0xd7, 0x57, 0xf1, 0x2f, 0x04, 0xab, 0xbd, 0x06, 0xf0, 0xab, 0x79,
0xf8, 0xb3, 0xa6, 0x22, 0x63, 0xea, 0xa7, 0x01, 0xcc, 0xde, 0x44, 0x14, 0xf2, 0x75, 0x11, 0x17,
0x88, 0xed, 0xdb, 0x00, 0x75, 0x73, 0x18, 0xea, 0x9c, 0x93, 0xcf, 0xb0, 0x7d, 0x34, 0xd0, 0x4c,
0x3e, 0xf5, 0xcc, 0x25, 0x5c, 0xe0, 0x1f, 0xa0, 0x7e, 0x15, 0x17, 0x49, 0x4e, 0x1b, 0x03, 0xd8,
0xb2, 0x7a, 0x28, 0xac, 0xc7, 0x96, 0xc7, 0x61, 0x3c, 0x43, 0xea, 0xc0, 0xc7, 0x0b, 0x30, 0x30,
0x00, 0x4c, 0x52, 0xd5, 0x3a, 0x3c, 0xb1, 0xf4, 0x77, 0x88, 0xb9, 0x87, 0xa6, 0xd2, 0xa0, 0x33,
0xe7, 0xf1, 0xc8, 0x08, 0xad, 0x2f, 0xe0, 0xd1, 0x01, 0x59, 0x5f, 0x87, 0xe6, 0xf8, 0x80, 0x86,
0x6f, 0x98, 0x43, 0x13, 0x5b, 0x84, 0xf6, 0x05, 0x7a, 0x59, 0x1e, 0xf1, 0xe1, 0xf3, 0xca, 0x53,
0x2c, 0xd0, 0x3d, 0xf9, 0x22, 0x13, 0x9b, 0xe3, 0xef, 0x0c, 0xe3, 0x67, 0x00, 0x00, 0x00, 0xff,
0xff, 0xec, 0x20, 0xc0, 0x4b, 0xaf, 0x09, 0x00, 0x00,
}

View File

@ -0,0 +1,586 @@
// Code generated by protoc-gen-go.
// source: steammessages_player.steamclient.proto
// DO NOT EDIT!
package unified
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type CPlayer_GetGameBadgeLevels_Request struct {
Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_GetGameBadgeLevels_Request) Reset() { *m = CPlayer_GetGameBadgeLevels_Request{} }
func (m *CPlayer_GetGameBadgeLevels_Request) String() string { return proto.CompactTextString(m) }
func (*CPlayer_GetGameBadgeLevels_Request) ProtoMessage() {}
func (*CPlayer_GetGameBadgeLevels_Request) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{0}
}
func (m *CPlayer_GetGameBadgeLevels_Request) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
type CPlayer_GetGameBadgeLevels_Response struct {
PlayerLevel *uint32 `protobuf:"varint,1,opt,name=player_level" json:"player_level,omitempty"`
Badges []*CPlayer_GetGameBadgeLevels_Response_Badge `protobuf:"bytes,2,rep,name=badges" json:"badges,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_GetGameBadgeLevels_Response) Reset() { *m = CPlayer_GetGameBadgeLevels_Response{} }
func (m *CPlayer_GetGameBadgeLevels_Response) String() string { return proto.CompactTextString(m) }
func (*CPlayer_GetGameBadgeLevels_Response) ProtoMessage() {}
func (*CPlayer_GetGameBadgeLevels_Response) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{1}
}
func (m *CPlayer_GetGameBadgeLevels_Response) GetPlayerLevel() uint32 {
if m != nil && m.PlayerLevel != nil {
return *m.PlayerLevel
}
return 0
}
func (m *CPlayer_GetGameBadgeLevels_Response) GetBadges() []*CPlayer_GetGameBadgeLevels_Response_Badge {
if m != nil {
return m.Badges
}
return nil
}
type CPlayer_GetGameBadgeLevels_Response_Badge struct {
Level *int32 `protobuf:"varint,1,opt,name=level" json:"level,omitempty"`
Series *int32 `protobuf:"varint,2,opt,name=series" json:"series,omitempty"`
BorderColor *uint32 `protobuf:"varint,3,opt,name=border_color" json:"border_color,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_GetGameBadgeLevels_Response_Badge) Reset() {
*m = CPlayer_GetGameBadgeLevels_Response_Badge{}
}
func (m *CPlayer_GetGameBadgeLevels_Response_Badge) String() string { return proto.CompactTextString(m) }
func (*CPlayer_GetGameBadgeLevels_Response_Badge) ProtoMessage() {}
func (*CPlayer_GetGameBadgeLevels_Response_Badge) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{1, 0}
}
func (m *CPlayer_GetGameBadgeLevels_Response_Badge) GetLevel() int32 {
if m != nil && m.Level != nil {
return *m.Level
}
return 0
}
func (m *CPlayer_GetGameBadgeLevels_Response_Badge) GetSeries() int32 {
if m != nil && m.Series != nil {
return *m.Series
}
return 0
}
func (m *CPlayer_GetGameBadgeLevels_Response_Badge) GetBorderColor() uint32 {
if m != nil && m.BorderColor != nil {
return *m.BorderColor
}
return 0
}
type CPlayer_GetLastPlayedTimes_Request struct {
MinLastPlayed *uint32 `protobuf:"varint,1,opt,name=min_last_played" json:"min_last_played,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_GetLastPlayedTimes_Request) Reset() { *m = CPlayer_GetLastPlayedTimes_Request{} }
func (m *CPlayer_GetLastPlayedTimes_Request) String() string { return proto.CompactTextString(m) }
func (*CPlayer_GetLastPlayedTimes_Request) ProtoMessage() {}
func (*CPlayer_GetLastPlayedTimes_Request) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{2}
}
func (m *CPlayer_GetLastPlayedTimes_Request) GetMinLastPlayed() uint32 {
if m != nil && m.MinLastPlayed != nil {
return *m.MinLastPlayed
}
return 0
}
type CPlayer_GetLastPlayedTimes_Response struct {
Games []*CPlayer_GetLastPlayedTimes_Response_Game `protobuf:"bytes,1,rep,name=games" json:"games,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_GetLastPlayedTimes_Response) Reset() { *m = CPlayer_GetLastPlayedTimes_Response{} }
func (m *CPlayer_GetLastPlayedTimes_Response) String() string { return proto.CompactTextString(m) }
func (*CPlayer_GetLastPlayedTimes_Response) ProtoMessage() {}
func (*CPlayer_GetLastPlayedTimes_Response) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{3}
}
func (m *CPlayer_GetLastPlayedTimes_Response) GetGames() []*CPlayer_GetLastPlayedTimes_Response_Game {
if m != nil {
return m.Games
}
return nil
}
type CPlayer_GetLastPlayedTimes_Response_Game struct {
Appid *int32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
LastPlaytime *uint32 `protobuf:"varint,2,opt,name=last_playtime" json:"last_playtime,omitempty"`
Playtime_2Weeks *int32 `protobuf:"varint,3,opt,name=playtime_2weeks" json:"playtime_2weeks,omitempty"`
PlaytimeForever *int32 `protobuf:"varint,4,opt,name=playtime_forever" json:"playtime_forever,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_GetLastPlayedTimes_Response_Game) Reset() {
*m = CPlayer_GetLastPlayedTimes_Response_Game{}
}
func (m *CPlayer_GetLastPlayedTimes_Response_Game) String() string { return proto.CompactTextString(m) }
func (*CPlayer_GetLastPlayedTimes_Response_Game) ProtoMessage() {}
func (*CPlayer_GetLastPlayedTimes_Response_Game) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{3, 0}
}
func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetAppid() int32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetLastPlaytime() uint32 {
if m != nil && m.LastPlaytime != nil {
return *m.LastPlaytime
}
return 0
}
func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetPlaytime_2Weeks() int32 {
if m != nil && m.Playtime_2Weeks != nil {
return *m.Playtime_2Weeks
}
return 0
}
func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetPlaytimeForever() int32 {
if m != nil && m.PlaytimeForever != nil {
return *m.PlaytimeForever
}
return 0
}
type CPlayer_AcceptSSA_Request struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_AcceptSSA_Request) Reset() { *m = CPlayer_AcceptSSA_Request{} }
func (m *CPlayer_AcceptSSA_Request) String() string { return proto.CompactTextString(m) }
func (*CPlayer_AcceptSSA_Request) ProtoMessage() {}
func (*CPlayer_AcceptSSA_Request) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{4} }
type CPlayer_AcceptSSA_Response struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_AcceptSSA_Response) Reset() { *m = CPlayer_AcceptSSA_Response{} }
func (m *CPlayer_AcceptSSA_Response) String() string { return proto.CompactTextString(m) }
func (*CPlayer_AcceptSSA_Response) ProtoMessage() {}
func (*CPlayer_AcceptSSA_Response) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{5} }
type CPlayer_LastPlayedTimes_Notification struct {
Games []*CPlayer_GetLastPlayedTimes_Response_Game `protobuf:"bytes,1,rep,name=games" json:"games,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayer_LastPlayedTimes_Notification) Reset() { *m = CPlayer_LastPlayedTimes_Notification{} }
func (m *CPlayer_LastPlayedTimes_Notification) String() string { return proto.CompactTextString(m) }
func (*CPlayer_LastPlayedTimes_Notification) ProtoMessage() {}
func (*CPlayer_LastPlayedTimes_Notification) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{6}
}
func (m *CPlayer_LastPlayedTimes_Notification) GetGames() []*CPlayer_GetLastPlayedTimes_Response_Game {
if m != nil {
return m.Games
}
return nil
}
type CPlayerClient_GetSystemInformation_Request struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayerClient_GetSystemInformation_Request) Reset() {
*m = CPlayerClient_GetSystemInformation_Request{}
}
func (m *CPlayerClient_GetSystemInformation_Request) String() string {
return proto.CompactTextString(m)
}
func (*CPlayerClient_GetSystemInformation_Request) ProtoMessage() {}
func (*CPlayerClient_GetSystemInformation_Request) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{7}
}
type CClientSystemInfo struct {
Cpu *CClientSystemInfo_CPU `protobuf:"bytes,1,opt,name=cpu" json:"cpu,omitempty"`
VideoCard *CClientSystemInfo_VideoCard `protobuf:"bytes,2,opt,name=video_card" json:"video_card,omitempty"`
OperatingSystem *string `protobuf:"bytes,3,opt,name=operating_system" json:"operating_system,omitempty"`
Os_64Bit *bool `protobuf:"varint,4,opt,name=os_64bit" json:"os_64bit,omitempty"`
SystemRamMb *int32 `protobuf:"varint,5,opt,name=system_ram_mb" json:"system_ram_mb,omitempty"`
AudioDevice *string `protobuf:"bytes,6,opt,name=audio_device" json:"audio_device,omitempty"`
AudioDriverVersion *string `protobuf:"bytes,7,opt,name=audio_driver_version" json:"audio_driver_version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CClientSystemInfo) Reset() { *m = CClientSystemInfo{} }
func (m *CClientSystemInfo) String() string { return proto.CompactTextString(m) }
func (*CClientSystemInfo) ProtoMessage() {}
func (*CClientSystemInfo) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{8} }
func (m *CClientSystemInfo) GetCpu() *CClientSystemInfo_CPU {
if m != nil {
return m.Cpu
}
return nil
}
func (m *CClientSystemInfo) GetVideoCard() *CClientSystemInfo_VideoCard {
if m != nil {
return m.VideoCard
}
return nil
}
func (m *CClientSystemInfo) GetOperatingSystem() string {
if m != nil && m.OperatingSystem != nil {
return *m.OperatingSystem
}
return ""
}
func (m *CClientSystemInfo) GetOs_64Bit() bool {
if m != nil && m.Os_64Bit != nil {
return *m.Os_64Bit
}
return false
}
func (m *CClientSystemInfo) GetSystemRamMb() int32 {
if m != nil && m.SystemRamMb != nil {
return *m.SystemRamMb
}
return 0
}
func (m *CClientSystemInfo) GetAudioDevice() string {
if m != nil && m.AudioDevice != nil {
return *m.AudioDevice
}
return ""
}
func (m *CClientSystemInfo) GetAudioDriverVersion() string {
if m != nil && m.AudioDriverVersion != nil {
return *m.AudioDriverVersion
}
return ""
}
type CClientSystemInfo_CPU struct {
SpeedMhz *int32 `protobuf:"varint,1,opt,name=speed_mhz" json:"speed_mhz,omitempty"`
Vendor *string `protobuf:"bytes,2,opt,name=vendor" json:"vendor,omitempty"`
LogicalProcessors *int32 `protobuf:"varint,3,opt,name=logical_processors" json:"logical_processors,omitempty"`
PhysicalProcessors *int32 `protobuf:"varint,4,opt,name=physical_processors" json:"physical_processors,omitempty"`
Hyperthreading *bool `protobuf:"varint,5,opt,name=hyperthreading" json:"hyperthreading,omitempty"`
Fcmov *bool `protobuf:"varint,6,opt,name=fcmov" json:"fcmov,omitempty"`
Sse2 *bool `protobuf:"varint,7,opt,name=sse2" json:"sse2,omitempty"`
Sse3 *bool `protobuf:"varint,8,opt,name=sse3" json:"sse3,omitempty"`
Ssse3 *bool `protobuf:"varint,9,opt,name=ssse3" json:"ssse3,omitempty"`
Sse4A *bool `protobuf:"varint,10,opt,name=sse4a" json:"sse4a,omitempty"`
Sse41 *bool `protobuf:"varint,11,opt,name=sse41" json:"sse41,omitempty"`
Sse42 *bool `protobuf:"varint,12,opt,name=sse42" json:"sse42,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CClientSystemInfo_CPU) Reset() { *m = CClientSystemInfo_CPU{} }
func (m *CClientSystemInfo_CPU) String() string { return proto.CompactTextString(m) }
func (*CClientSystemInfo_CPU) ProtoMessage() {}
func (*CClientSystemInfo_CPU) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{8, 0} }
func (m *CClientSystemInfo_CPU) GetSpeedMhz() int32 {
if m != nil && m.SpeedMhz != nil {
return *m.SpeedMhz
}
return 0
}
func (m *CClientSystemInfo_CPU) GetVendor() string {
if m != nil && m.Vendor != nil {
return *m.Vendor
}
return ""
}
func (m *CClientSystemInfo_CPU) GetLogicalProcessors() int32 {
if m != nil && m.LogicalProcessors != nil {
return *m.LogicalProcessors
}
return 0
}
func (m *CClientSystemInfo_CPU) GetPhysicalProcessors() int32 {
if m != nil && m.PhysicalProcessors != nil {
return *m.PhysicalProcessors
}
return 0
}
func (m *CClientSystemInfo_CPU) GetHyperthreading() bool {
if m != nil && m.Hyperthreading != nil {
return *m.Hyperthreading
}
return false
}
func (m *CClientSystemInfo_CPU) GetFcmov() bool {
if m != nil && m.Fcmov != nil {
return *m.Fcmov
}
return false
}
func (m *CClientSystemInfo_CPU) GetSse2() bool {
if m != nil && m.Sse2 != nil {
return *m.Sse2
}
return false
}
func (m *CClientSystemInfo_CPU) GetSse3() bool {
if m != nil && m.Sse3 != nil {
return *m.Sse3
}
return false
}
func (m *CClientSystemInfo_CPU) GetSsse3() bool {
if m != nil && m.Ssse3 != nil {
return *m.Ssse3
}
return false
}
func (m *CClientSystemInfo_CPU) GetSse4A() bool {
if m != nil && m.Sse4A != nil {
return *m.Sse4A
}
return false
}
func (m *CClientSystemInfo_CPU) GetSse41() bool {
if m != nil && m.Sse41 != nil {
return *m.Sse41
}
return false
}
func (m *CClientSystemInfo_CPU) GetSse42() bool {
if m != nil && m.Sse42 != nil {
return *m.Sse42
}
return false
}
type CClientSystemInfo_VideoCard struct {
Driver *string `protobuf:"bytes,1,opt,name=driver" json:"driver,omitempty"`
DriverVersion *string `protobuf:"bytes,2,opt,name=driver_version" json:"driver_version,omitempty"`
DriverDate *uint32 `protobuf:"varint,3,opt,name=driver_date" json:"driver_date,omitempty"`
DirectxVersion *string `protobuf:"bytes,4,opt,name=directx_version" json:"directx_version,omitempty"`
OpenglVersion *string `protobuf:"bytes,5,opt,name=opengl_version" json:"opengl_version,omitempty"`
Vendorid *int32 `protobuf:"varint,6,opt,name=vendorid" json:"vendorid,omitempty"`
Deviceid *int32 `protobuf:"varint,7,opt,name=deviceid" json:"deviceid,omitempty"`
VramMb *int32 `protobuf:"varint,8,opt,name=vram_mb" json:"vram_mb,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CClientSystemInfo_VideoCard) Reset() { *m = CClientSystemInfo_VideoCard{} }
func (m *CClientSystemInfo_VideoCard) String() string { return proto.CompactTextString(m) }
func (*CClientSystemInfo_VideoCard) ProtoMessage() {}
func (*CClientSystemInfo_VideoCard) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{8, 1} }
func (m *CClientSystemInfo_VideoCard) GetDriver() string {
if m != nil && m.Driver != nil {
return *m.Driver
}
return ""
}
func (m *CClientSystemInfo_VideoCard) GetDriverVersion() string {
if m != nil && m.DriverVersion != nil {
return *m.DriverVersion
}
return ""
}
func (m *CClientSystemInfo_VideoCard) GetDriverDate() uint32 {
if m != nil && m.DriverDate != nil {
return *m.DriverDate
}
return 0
}
func (m *CClientSystemInfo_VideoCard) GetDirectxVersion() string {
if m != nil && m.DirectxVersion != nil {
return *m.DirectxVersion
}
return ""
}
func (m *CClientSystemInfo_VideoCard) GetOpenglVersion() string {
if m != nil && m.OpenglVersion != nil {
return *m.OpenglVersion
}
return ""
}
func (m *CClientSystemInfo_VideoCard) GetVendorid() int32 {
if m != nil && m.Vendorid != nil {
return *m.Vendorid
}
return 0
}
func (m *CClientSystemInfo_VideoCard) GetDeviceid() int32 {
if m != nil && m.Deviceid != nil {
return *m.Deviceid
}
return 0
}
func (m *CClientSystemInfo_VideoCard) GetVramMb() int32 {
if m != nil && m.VramMb != nil {
return *m.VramMb
}
return 0
}
type CPlayerClient_GetSystemInformation_Response struct {
SystemInfo *CClientSystemInfo `protobuf:"bytes,1,opt,name=system_info" json:"system_info,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CPlayerClient_GetSystemInformation_Response) Reset() {
*m = CPlayerClient_GetSystemInformation_Response{}
}
func (m *CPlayerClient_GetSystemInformation_Response) String() string {
return proto.CompactTextString(m)
}
func (*CPlayerClient_GetSystemInformation_Response) ProtoMessage() {}
func (*CPlayerClient_GetSystemInformation_Response) Descriptor() ([]byte, []int) {
return player_fileDescriptor0, []int{9}
}
func (m *CPlayerClient_GetSystemInformation_Response) GetSystemInfo() *CClientSystemInfo {
if m != nil {
return m.SystemInfo
}
return nil
}
func init() {
proto.RegisterType((*CPlayer_GetGameBadgeLevels_Request)(nil), "CPlayer_GetGameBadgeLevels_Request")
proto.RegisterType((*CPlayer_GetGameBadgeLevels_Response)(nil), "CPlayer_GetGameBadgeLevels_Response")
proto.RegisterType((*CPlayer_GetGameBadgeLevels_Response_Badge)(nil), "CPlayer_GetGameBadgeLevels_Response.Badge")
proto.RegisterType((*CPlayer_GetLastPlayedTimes_Request)(nil), "CPlayer_GetLastPlayedTimes_Request")
proto.RegisterType((*CPlayer_GetLastPlayedTimes_Response)(nil), "CPlayer_GetLastPlayedTimes_Response")
proto.RegisterType((*CPlayer_GetLastPlayedTimes_Response_Game)(nil), "CPlayer_GetLastPlayedTimes_Response.Game")
proto.RegisterType((*CPlayer_AcceptSSA_Request)(nil), "CPlayer_AcceptSSA_Request")
proto.RegisterType((*CPlayer_AcceptSSA_Response)(nil), "CPlayer_AcceptSSA_Response")
proto.RegisterType((*CPlayer_LastPlayedTimes_Notification)(nil), "CPlayer_LastPlayedTimes_Notification")
proto.RegisterType((*CPlayerClient_GetSystemInformation_Request)(nil), "CPlayerClient_GetSystemInformation_Request")
proto.RegisterType((*CClientSystemInfo)(nil), "CClientSystemInfo")
proto.RegisterType((*CClientSystemInfo_CPU)(nil), "CClientSystemInfo.CPU")
proto.RegisterType((*CClientSystemInfo_VideoCard)(nil), "CClientSystemInfo.VideoCard")
proto.RegisterType((*CPlayerClient_GetSystemInformation_Response)(nil), "CPlayerClient_GetSystemInformation_Response")
}
var player_fileDescriptor0 = []byte{
// 1067 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x55, 0x4d, 0x6f, 0xdb, 0x46,
0x10, 0x05, 0x2d, 0xcb, 0x96, 0x46, 0x76, 0x9c, 0x6c, 0x9c, 0x94, 0xa1, 0x5d, 0x60, 0x41, 0xa7,
0xf9, 0x70, 0x1c, 0xa2, 0x55, 0x82, 0xa2, 0x68, 0x0b, 0x04, 0xb6, 0x0f, 0x41, 0x01, 0x23, 0x48,
0xe3, 0x38, 0xa7, 0x02, 0xec, 0x8a, 0x5c, 0xc9, 0x44, 0x48, 0xae, 0xca, 0x5d, 0x29, 0x55, 0x4f,
0x45, 0xce, 0xbd, 0x15, 0xfd, 0x1b, 0xbd, 0xb9, 0xe7, 0x00, 0xfd, 0x23, 0xfd, 0x03, 0x3d, 0xf6,
0xde, 0xd9, 0x5d, 0x52, 0x1f, 0x96, 0x9d, 0xaa, 0x39, 0x18, 0xd6, 0xee, 0xbc, 0x1d, 0xbe, 0x79,
0x3b, 0xf3, 0x16, 0xee, 0x48, 0xc5, 0x59, 0x96, 0x71, 0x29, 0x59, 0x8f, 0xcb, 0xb0, 0x9f, 0xb2,
0x11, 0x2f, 0x02, 0xb3, 0x19, 0xa5, 0x09, 0xcf, 0x55, 0xd0, 0x2f, 0x84, 0x12, 0xde, 0xde, 0x2c,
0x6e, 0x90, 0x27, 0xdd, 0x84, 0xc7, 0x61, 0x87, 0x49, 0x3e, 0x8f, 0xf6, 0x1f, 0x81, 0x7f, 0xf8,
0xdc, 0xa4, 0x0a, 0x9f, 0x72, 0xf5, 0x94, 0x65, 0xfc, 0x80, 0xc5, 0x3d, 0x7e, 0xc4, 0x87, 0x3c,
0x95, 0xe1, 0x0b, 0xfe, 0xc3, 0x80, 0x4b, 0x45, 0xd6, 0xa1, 0xce, 0xfa, 0xfd, 0x24, 0x76, 0x1d,
0xea, 0xdc, 0x5b, 0xf7, 0xcf, 0x1c, 0xd8, 0x79, 0xef, 0x29, 0xd9, 0x17, 0xb9, 0xe4, 0x64, 0x13,
0xd6, 0x2c, 0xcd, 0x30, 0xd5, 0x11, 0x7b, 0x9a, 0x7c, 0x09, 0x2b, 0x1d, 0x8d, 0x96, 0xee, 0x12,
0xad, 0xdd, 0x6b, 0xb5, 0x77, 0x83, 0x05, 0x72, 0x05, 0x66, 0xd3, 0xfb, 0x1a, 0xea, 0xe6, 0x87,
0x66, 0x34, 0xc9, 0x59, 0x27, 0x57, 0x60, 0x45, 0xf2, 0x22, 0x31, 0x39, 0xf5, 0x1a, 0xbf, 0xdc,
0x11, 0x45, 0x8c, 0x39, 0x23, 0x91, 0x8a, 0xc2, 0xad, 0x19, 0xde, 0x6f, 0x9d, 0x99, 0x6a, 0x8f,
0x98, 0x54, 0x66, 0x15, 0xbf, 0x4c, 0x50, 0xaf, 0x71, 0xb5, 0xdf, 0xc1, 0x46, 0x96, 0xe4, 0x61,
0x8a, 0x61, 0x2b, 0x73, 0x59, 0xf7, 0xc1, 0xe1, 0xdb, 0x33, 0xf7, 0xc9, 0xcb, 0x53, 0x4e, 0x33,
0x21, 0x15, 0x2d, 0x78, 0x84, 0x3a, 0x52, 0x0d, 0x7b, 0x68, 0x61, 0x54, 0x61, 0x1e, 0xaa, 0x10,
0x60, 0x35, 0xa6, 0x2c, 0x2d, 0x38, 0x8b, 0x47, 0xf4, 0x75, 0x2e, 0xde, 0x48, 0xca, 0x3a, 0x62,
0xa0, 0xfc, 0x77, 0xb3, 0xe2, 0xcd, 0x93, 0x28, 0xc5, 0xfb, 0x02, 0xea, 0x3d, 0x14, 0x43, 0xe2,
0xb7, 0xb5, 0x4a, 0xf7, 0x83, 0x05, 0x0e, 0x05, 0x5a, 0x3e, 0x2f, 0x84, 0x65, 0xfd, 0x7f, 0xf6,
0xd6, 0xea, 0xe4, 0x06, 0xac, 0x8f, 0x4b, 0xd2, 0x44, 0x8d, 0x54, 0xeb, 0xe4, 0x23, 0xd8, 0xa8,
0x76, 0xc2, 0xf6, 0x1b, 0xce, 0x5f, 0x4b, 0xa3, 0x56, 0x9d, 0xb8, 0x70, 0x75, 0x1c, 0xe8, 0x8a,
0x02, 0xd5, 0x2e, 0xdc, 0x65, 0x1d, 0xf1, 0xb7, 0xe0, 0x56, 0x45, 0x66, 0x3f, 0x8a, 0x78, 0x5f,
0x1d, 0x1f, 0xef, 0x57, 0xea, 0xf9, 0xdb, 0xe0, 0x5d, 0x14, 0xb4, 0x04, 0xfd, 0xef, 0xe1, 0x76,
0x15, 0x3d, 0x5f, 0xc4, 0x33, 0xa1, 0xb0, 0x55, 0x23, 0xa6, 0x12, 0x91, 0x7f, 0x78, 0xf5, 0xfe,
0x1e, 0xec, 0x96, 0xd8, 0x43, 0x73, 0x09, 0xfa, 0xc4, 0xf1, 0x08, 0x3b, 0x3f, 0xfb, 0x26, 0xc7,
0x32, 0x32, 0x93, 0x7f, 0xcc, 0xf6, 0x9f, 0x65, 0xb8, 0x76, 0x68, 0x81, 0x13, 0x10, 0xd9, 0x81,
0x5a, 0xd4, 0x1f, 0x18, 0xdd, 0x5a, 0xed, 0x9b, 0xc1, 0x1c, 0x00, 0xd9, 0x9c, 0x90, 0x4f, 0x01,
0x86, 0x49, 0xcc, 0x45, 0x18, 0xb1, 0x22, 0x36, 0x62, 0xb6, 0xda, 0xdb, 0x17, 0x60, 0x5f, 0x69,
0xd0, 0x21, 0x62, 0xb4, 0xa2, 0xa2, 0xcf, 0x0b, 0x64, 0x90, 0xf7, 0x42, 0x69, 0x10, 0x46, 0xeb,
0x26, 0xb9, 0x0a, 0x0d, 0x21, 0xc3, 0xcf, 0x1f, 0x77, 0x12, 0x65, 0x34, 0x6e, 0xe8, 0xdb, 0xb2,
0x88, 0xb0, 0x60, 0x59, 0x98, 0x75, 0xdc, 0x7a, 0xd5, 0xd8, 0x6c, 0x10, 0x27, 0x22, 0x8c, 0xf9,
0x30, 0x89, 0xb8, 0xbb, 0x62, 0x8e, 0x6f, 0xc3, 0x66, 0xb9, 0x5b, 0x24, 0x78, 0x4d, 0x21, 0xfe,
0x49, 0xac, 0xd2, 0x5d, 0xd5, 0x51, 0xef, 0x2f, 0x07, 0x6a, 0x9a, 0xf0, 0x35, 0x68, 0xca, 0x3e,
0x47, 0x2f, 0xc8, 0x4e, 0x7f, 0x9a, 0xcc, 0xcd, 0x90, 0xe7, 0x31, 0x4e, 0xc8, 0x92, 0x49, 0xe4,
0x01, 0x49, 0x45, 0x0f, 0x2f, 0x21, 0x0d, 0xd1, 0x1f, 0x22, 0x34, 0x11, 0x51, 0x54, 0xfd, 0xb0,
0x05, 0xd7, 0xfb, 0xa7, 0x23, 0x79, 0x3e, 0x68, 0x5a, 0x82, 0xdc, 0x84, 0x2b, 0xa7, 0x23, 0xac,
0x4d, 0x9d, 0xea, 0x8e, 0xc7, 0xfa, 0x0c, 0xdf, 0x86, 0xee, 0xc1, 0x6e, 0x94, 0x89, 0xa1, 0x21,
0xda, 0x20, 0x6b, 0xb0, 0x2c, 0x25, 0x6f, 0x1b, 0x62, 0xd5, 0xea, 0x91, 0xdb, 0xa8, 0xa0, 0xd2,
0x2c, 0x9b, 0x93, 0x25, 0x7f, 0xcc, 0x5c, 0x98, 0x5e, 0x7e, 0xe6, 0xb6, 0xa6, 0x97, 0x6d, 0x77,
0x4d, 0x2f, 0xbd, 0xdf, 0x1d, 0x68, 0x4e, 0x74, 0xc6, 0xaa, 0xac, 0x10, 0xa6, 0xca, 0xa6, 0x26,
0x77, 0x4e, 0x18, 0x5b, 0xed, 0x75, 0x68, 0x95, 0xfb, 0x31, 0x53, 0xdc, 0x9a, 0x84, 0x9e, 0x87,
0x38, 0xc1, 0xd9, 0x56, 0x3f, 0x8e, 0xd1, 0xcb, 0x55, 0x16, 0xbc, 0xbd, 0xbc, 0x97, 0x8e, 0xf7,
0xeb, 0xd5, 0xdd, 0x59, 0x0d, 0x71, 0xd2, 0x56, 0x8c, 0x18, 0xb8, 0x63, 0xaf, 0x07, 0x77, 0x56,
0xcd, 0xce, 0x06, 0xac, 0x0e, 0xcb, 0x7b, 0x6c, 0x98, 0x11, 0x7a, 0x05, 0x0f, 0x16, 0xea, 0xd2,
0xd2, 0x0c, 0xee, 0x42, 0xab, 0xec, 0x86, 0x04, 0xc3, 0x65, 0x63, 0x92, 0xf9, 0x66, 0x6b, 0xff,
0x5d, 0x83, 0x15, 0x9b, 0x97, 0xfc, 0xe1, 0x00, 0x99, 0x77, 0x54, 0xb2, 0x13, 0xfc, 0xb7, 0xe1,
0x7b, 0xb7, 0x17, 0xf1, 0x64, 0xff, 0x04, 0xfd, 0xf0, 0xdb, 0x17, 0x5c, 0x0d, 0x8a, 0x5c, 0x1a,
0xdb, 0x3b, 0xd6, 0xef, 0x0b, 0x35, 0x30, 0x2a, 0xba, 0x94, 0xd1, 0x01, 0xba, 0xf2, 0x9e, 0x09,
0x99, 0x04, 0xd4, 0x78, 0x36, 0xc5, 0x02, 0xcd, 0x9e, 0x9e, 0xf0, 0x3d, 0xca, 0xf2, 0x98, 0x26,
0x5d, 0x9a, 0xa8, 0xbb, 0x12, 0x23, 0x49, 0x4a, 0x7e, 0x73, 0xc0, 0xb5, 0x85, 0xcd, 0x0f, 0xfb,
0x2c, 0xfd, 0x4b, 0x1c, 0x7c, 0x96, 0xfe, 0x65, 0x76, 0xe1, 0x07, 0x48, 0x7f, 0x17, 0x01, 0x96,
0xfb, 0x79, 0x1f, 0x97, 0x63, 0x9a, 0x2c, 0x8a, 0xc4, 0x20, 0x57, 0x24, 0x82, 0xe6, 0xd8, 0xd1,
0x88, 0x17, 0x5c, 0x6a, 0x81, 0xde, 0x56, 0xf0, 0x1e, 0x07, 0xfc, 0x18, 0xbf, 0x7a, 0xeb, 0x04,
0x75, 0xa1, 0x89, 0xd4, 0xa9, 0x31, 0x8e, 0xe3, 0x62, 0xe5, 0x3b, 0xde, 0xf7, 0x1e, 0x62, 0xf8,
0xfe, 0x3e, 0xc5, 0xb8, 0x6e, 0x20, 0xc3, 0x41, 0x83, 0xa4, 0xd4, 0x20, 0xab, 0xaf, 0x7d, 0x53,
0x29, 0xf6, 0x2c, 0x6b, 0xff, 0x5a, 0x83, 0xb5, 0xe9, 0x3e, 0x22, 0xbf, 0x38, 0x70, 0xc3, 0x38,
0xe9, 0xe8, 0xbc, 0x72, 0x9f, 0x04, 0x8b, 0x38, 0xaf, 0xd7, 0x0a, 0x9e, 0x89, 0x31, 0xd9, 0x27,
0xc8, 0xe6, 0xab, 0xe9, 0x30, 0xed, 0x16, 0x22, 0x33, 0xec, 0x90, 0x81, 0x12, 0xd5, 0x43, 0x87,
0x97, 0x9d, 0xe1, 0x13, 0x51, 0xbd, 0x89, 0x9a, 0xa1, 0x11, 0x91, 0xfc, 0xe9, 0xc0, 0xe6, 0x45,
0xad, 0x4d, 0x1e, 0x04, 0x8b, 0xbb, 0xb4, 0xb7, 0x17, 0xfc, 0x8f, 0x61, 0xf1, 0x9f, 0x23, 0xe9,
0xa3, 0xf2, 0xa8, 0xe5, 0xab, 0xc5, 0x9d, 0x70, 0x9e, 0x7a, 0xa0, 0xb5, 0xbc, 0xc9, 0x24, 0x87,
0x7d, 0xa2, 0x0d, 0x40, 0x77, 0xae, 0xa4, 0x76, 0xe8, 0x3c, 0xdd, 0x29, 0x77, 0xe6, 0xc4, 0xaf,
0x92, 0xe4, 0x53, 0xfa, 0xc8, 0x77, 0x67, 0xee, 0xd2, 0x41, 0xed, 0x67, 0xc7, 0xf9, 0x37, 0x00,
0x00, 0xff, 0xff, 0x9e, 0xe2, 0xe2, 0x67, 0xb1, 0x09, 0x00, 0x00,
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,17 @@
/*
Contains code generated from SteamKit's SteamLanguage data.
*/
package steamlang
const (
ProtoMask uint32 = 0x80000000
EMsgMask = ^ProtoMask
)
func NewEMsg(e uint32) EMsg {
return EMsg(e & EMsgMask)
}
func IsProto(e uint32) bool {
return e&ProtoMask > 0
}

97
vendor/github.com/Philipp15b/go-steam/rwu/rwu.go generated vendored Normal file
View File

@ -0,0 +1,97 @@
// Utilities for reading and writing of binary data
package rwu
import (
"encoding/binary"
"io"
)
func ReadBool(r io.Reader) (bool, error) {
var c uint8
err := binary.Read(r, binary.LittleEndian, &c)
return c != 0, err
}
func ReadUint8(r io.Reader) (uint8, error) {
var c uint8
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadUint16(r io.Reader) (uint16, error) {
var c uint16
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadUint32(r io.Reader) (uint32, error) {
var c uint32
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadUint64(r io.Reader) (uint64, error) {
var c uint64
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadInt8(r io.Reader) (int8, error) {
var c int8
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadInt16(r io.Reader) (int16, error) {
var c int16
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadInt32(r io.Reader) (int32, error) {
var c int32
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadInt64(r io.Reader) (int64, error) {
var c int64
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadString(r io.Reader) (string, error) {
c := make([]byte, 0)
var err error
for {
var b byte
err = binary.Read(r, binary.LittleEndian, &b)
if b == byte(0x0) || err != nil {
break
}
c = append(c, b)
}
return string(c), err
}
func ReadByte(r io.Reader) (byte, error) {
var c byte
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func ReadBytes(r io.Reader, num int32) ([]byte, error) {
c := make([]byte, num)
err := binary.Read(r, binary.LittleEndian, &c)
return c, err
}
func WriteBool(w io.Writer, b bool) error {
var err error
if b {
_, err = w.Write([]byte{1})
} else {
_, err = w.Write([]byte{0})
}
return err
}

144
vendor/github.com/Philipp15b/go-steam/servers.go generated vendored Normal file
View File

@ -0,0 +1,144 @@
package steam
import (
"math/rand"
"time"
"github.com/Philipp15b/go-steam/netutil"
)
// CMServers contains a list of worlwide servers
var CMServers = [][]string{
{ // North American Servers
// Chicago
"162.254.193.44:27018",
"162.254.193.44:27019",
"162.254.193.44:27020",
"162.254.193.44:27021",
"162.254.193.45:27017",
"162.254.193.45:27018",
"162.254.193.45:27019",
"162.254.193.45:27021",
"162.254.193.46:27017",
"162.254.193.46:27018",
"162.254.193.46:27019",
"162.254.193.46:27020",
"162.254.193.46:27021",
"162.254.193.47:27019",
"162.254.193.47:27020",
// Ashburn
"208.78.164.9:27017",
"208.78.164.9:27018",
"208.78.164.9:27019",
"208.78.164.10:27017",
"208.78.164.10:27018",
"208.78.164.10:27019",
"208.78.164.11:27017",
"208.78.164.11:27018",
"208.78.164.11:27019",
"208.78.164.12:27017",
"208.78.164.12:27018",
"208.78.164.12:27019",
"208.78.164.13:27017",
"208.78.164.13:27018",
"208.78.164.13:27019",
"208.78.164.14:27017",
"208.78.164.14:27018",
"208.78.164.14:27019",
},
{ // Europe Servers
// Luxembourg
"146.66.152.10:27017",
"146.66.152.10:27018",
"146.66.152.10:27019",
"146.66.152.10:27020",
"146.66.152.11:27017",
"146.66.152.11:27018",
"146.66.152.11:27019",
"146.66.152.11:27020",
// Poland
"155.133.242.8:27017",
"155.133.242.8:27018",
"155.133.242.8:27019",
"155.133.242.8:27020",
"155.133.242.9:27017",
"155.133.242.9:27018",
"155.133.242.9:27019",
"155.133.242.9:27020",
// Vienna
"146.66.155.8:27017",
"146.66.155.8:27018",
"146.66.155.8:27019",
"146.66.155.8:27020",
"185.25.182.10:27017",
"185.25.182.10:27018",
"185.25.182.10:27019",
"185.25.182.10:27020",
// London
"162.254.196.40:27017",
"162.254.196.40:27018",
"162.254.196.40:27019",
"162.254.196.40:27020",
"162.254.196.40:27021",
"162.254.196.41:27017",
"162.254.196.41:27018",
"162.254.196.41:27019",
"162.254.196.41:27020",
"162.254.196.41:27021",
"162.254.196.42:27017",
"162.254.196.42:27018",
"162.254.196.42:27019",
"162.254.196.42:27020",
"162.254.196.42:27021",
"162.254.196.43:27017",
"162.254.196.43:27018",
"162.254.196.43:27019",
"162.254.196.43:27020",
"162.254.196.43:27021",
// Stockholm
"185.25.180.14:27017",
"185.25.180.14:27018",
"185.25.180.14:27019",
"185.25.180.14:27020",
"185.25.180.15:27017",
"185.25.180.15:27018",
"185.25.180.15:27019",
"185.25.180.15:27020",
},
}
// GetRandomCM returns back a random server anywhere
func GetRandomCM() *netutil.PortAddr {
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
servers := append(CMServers[0], CMServers[1]...)
addr := netutil.ParsePortAddr(servers[rng.Int31n(int32(len(servers)))])
if addr == nil {
panic("invalid address in CMServers slice")
}
return addr
}
// GetRandomNorthAmericaCM returns back a random server in north america
func GetRandomNorthAmericaCM() *netutil.PortAddr {
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
addr := netutil.ParsePortAddr(CMServers[0][rng.Int31n(int32(len(CMServers[0])))])
if addr == nil {
panic("invalid address in CMServers slice")
}
return addr
}
// GetRandomEuropeCM returns back a random server in europe
func GetRandomEuropeCM() *netutil.PortAddr {
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
addr := netutil.ParsePortAddr(CMServers[1][rng.Int31n(int32(len(CMServers[1])))])
if addr == nil {
panic("invalid address in CMServers slice")
}
return addr
}

624
vendor/github.com/Philipp15b/go-steam/social.go generated vendored Normal file
View File

@ -0,0 +1,624 @@
package steam
import (
"bytes"
"encoding/binary"
"encoding/hex"
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/rwu"
"github.com/Philipp15b/go-steam/socialcache"
. "github.com/Philipp15b/go-steam/steamid"
"github.com/golang/protobuf/proto"
"io"
"sync"
"time"
)
// Provides access to social aspects of Steam.
type Social struct {
mutex sync.RWMutex
name string
avatar string
personaState EPersonaState
Friends *socialcache.FriendsList
Groups *socialcache.GroupsList
Chats *socialcache.ChatsList
client *Client
}
func newSocial(client *Client) *Social {
return &Social{
Friends: socialcache.NewFriendsList(),
Groups: socialcache.NewGroupsList(),
Chats: socialcache.NewChatsList(),
client: client,
}
}
// Gets the local user's avatar
func (s *Social) GetAvatar() string {
s.mutex.RLock()
defer s.mutex.RUnlock()
return s.avatar
}
// Gets the local user's persona name
func (s *Social) GetPersonaName() string {
s.mutex.RLock()
defer s.mutex.RUnlock()
return s.name
}
// Sets the local user's persona name and broadcasts it over the network
func (s *Social) SetPersonaName(name string) {
s.mutex.Lock()
defer s.mutex.Unlock()
s.name = name
s.client.Write(NewClientMsgProtobuf(EMsg_ClientChangeStatus, &CMsgClientChangeStatus{
PersonaState: proto.Uint32(uint32(s.personaState)),
PlayerName: proto.String(name),
}))
}
// Gets the local user's persona state
func (s *Social) GetPersonaState() EPersonaState {
s.mutex.RLock()
defer s.mutex.RUnlock()
return s.personaState
}
// Sets the local user's persona state and broadcasts it over the network
func (s *Social) SetPersonaState(state EPersonaState) {
s.mutex.Lock()
defer s.mutex.Unlock()
s.personaState = state
s.client.Write(NewClientMsgProtobuf(EMsg_ClientChangeStatus, &CMsgClientChangeStatus{
PersonaState: proto.Uint32(uint32(state)),
}))
}
// Sends a chat message to ether a room or friend
func (s *Social) SendMessage(to SteamId, entryType EChatEntryType, message string) {
//Friend
if to.GetAccountType() == int32(EAccountType_Individual) || to.GetAccountType() == int32(EAccountType_ConsoleUser) {
s.client.Write(NewClientMsgProtobuf(EMsg_ClientFriendMsg, &CMsgClientFriendMsg{
Steamid: proto.Uint64(to.ToUint64()),
ChatEntryType: proto.Int32(int32(entryType)),
Message: []byte(message),
}))
//Chat room
} else if to.GetAccountType() == int32(EAccountType_Clan) || to.GetAccountType() == int32(EAccountType_Chat) {
chatId := to.ClanToChat()
s.client.Write(NewClientMsg(&MsgClientChatMsg{
ChatMsgType: entryType,
SteamIdChatRoom: chatId,
SteamIdChatter: s.client.SteamId(),
}, []byte(message)))
}
}
// Adds a friend to your friends list or accepts a friend. You'll receive a FriendStateEvent
// for every new/changed friend
func (s *Social) AddFriend(id SteamId) {
s.client.Write(NewClientMsgProtobuf(EMsg_ClientAddFriend, &CMsgClientAddFriend{
SteamidToAdd: proto.Uint64(id.ToUint64()),
}))
}
// Removes a friend from your friends list
func (s *Social) RemoveFriend(id SteamId) {
s.client.Write(NewClientMsgProtobuf(EMsg_ClientRemoveFriend, &CMsgClientRemoveFriend{
Friendid: proto.Uint64(id.ToUint64()),
}))
}
// Ignores or unignores a friend on Steam
func (s *Social) IgnoreFriend(id SteamId, setIgnore bool) {
ignore := uint8(1) //True
if !setIgnore {
ignore = uint8(0) //False
}
s.client.Write(NewClientMsg(&MsgClientSetIgnoreFriend{
MySteamId: s.client.SteamId(),
SteamIdFriend: id,
Ignore: ignore,
}, make([]byte, 0)))
}
// Requests persona state for a list of specified SteamIds
func (s *Social) RequestFriendListInfo(ids []SteamId, requestedInfo EClientPersonaStateFlag) {
var friends []uint64
for _, id := range ids {
friends = append(friends, id.ToUint64())
}
s.client.Write(NewClientMsgProtobuf(EMsg_ClientRequestFriendData, &CMsgClientRequestFriendData{
PersonaStateRequested: proto.Uint32(uint32(requestedInfo)),
Friends: friends,
}))
}
// Requests persona state for a specified SteamId
func (s *Social) RequestFriendInfo(id SteamId, requestedInfo EClientPersonaStateFlag) {
s.RequestFriendListInfo([]SteamId{id}, requestedInfo)
}
// Requests profile information for a specified SteamId
func (s *Social) RequestProfileInfo(id SteamId) {
s.client.Write(NewClientMsgProtobuf(EMsg_ClientFriendProfileInfo, &CMsgClientFriendProfileInfo{
SteamidFriend: proto.Uint64(id.ToUint64()),
}))
}
// Requests all offline messages and marks them as read
func (s *Social) RequestOfflineMessages() {
s.client.Write(NewClientMsgProtobuf(EMsg_ClientFSGetFriendMessageHistoryForOfflineMessages, &CMsgClientFSGetFriendMessageHistoryForOfflineMessages{}))
}
// Attempts to join a chat room
func (s *Social) JoinChat(id SteamId) {
chatId := id.ClanToChat()
s.client.Write(NewClientMsg(&MsgClientJoinChat{
SteamIdChat: chatId,
}, make([]byte, 0)))
}
// Attempts to leave a chat room
func (s *Social) LeaveChat(id SteamId) {
chatId := id.ClanToChat()
payload := new(bytes.Buffer)
binary.Write(payload, binary.LittleEndian, s.client.SteamId().ToUint64()) // ChatterActedOn
binary.Write(payload, binary.LittleEndian, uint32(EChatMemberStateChange_Left)) // StateChange
binary.Write(payload, binary.LittleEndian, s.client.SteamId().ToUint64()) // ChatterActedBy
s.client.Write(NewClientMsg(&MsgClientChatMemberInfo{
SteamIdChat: chatId,
Type: EChatInfoType_StateChange,
}, payload.Bytes()))
}
// Kicks the specified chat member from the given chat room
func (s *Social) KickChatMember(room SteamId, user SteamId) {
chatId := room.ClanToChat()
s.client.Write(NewClientMsg(&MsgClientChatAction{
SteamIdChat: chatId,
SteamIdUserToActOn: user,
ChatAction: EChatAction_Kick,
}, make([]byte, 0)))
}
// Bans the specified chat member from the given chat room
func (s *Social) BanChatMember(room SteamId, user SteamId) {
chatId := room.ClanToChat()
s.client.Write(NewClientMsg(&MsgClientChatAction{
SteamIdChat: chatId,
SteamIdUserToActOn: user,
ChatAction: EChatAction_Ban,
}, make([]byte, 0)))
}
// Unbans the specified chat member from the given chat room
func (s *Social) UnbanChatMember(room SteamId, user SteamId) {
chatId := room.ClanToChat()
s.client.Write(NewClientMsg(&MsgClientChatAction{
SteamIdChat: chatId,
SteamIdUserToActOn: user,
ChatAction: EChatAction_UnBan,
}, make([]byte, 0)))
}
func (s *Social) HandlePacket(packet *Packet) {
switch packet.EMsg {
case EMsg_ClientPersonaState:
s.handlePersonaState(packet)
case EMsg_ClientClanState:
s.handleClanState(packet)
case EMsg_ClientFriendsList:
s.handleFriendsList(packet)
case EMsg_ClientFriendMsgIncoming:
s.handleFriendMsg(packet)
case EMsg_ClientAccountInfo:
s.handleAccountInfo(packet)
case EMsg_ClientAddFriendResponse:
s.handleFriendResponse(packet)
case EMsg_ClientChatEnter:
s.handleChatEnter(packet)
case EMsg_ClientChatMsg:
s.handleChatMsg(packet)
case EMsg_ClientChatMemberInfo:
s.handleChatMemberInfo(packet)
case EMsg_ClientChatActionResult:
s.handleChatActionResult(packet)
case EMsg_ClientChatInvite:
s.handleChatInvite(packet)
case EMsg_ClientSetIgnoreFriendResponse:
s.handleIgnoreFriendResponse(packet)
case EMsg_ClientFriendProfileInfoResponse:
s.handleProfileInfoResponse(packet)
case EMsg_ClientFSGetFriendMessageHistoryResponse:
s.handleFriendMessageHistoryResponse(packet)
}
}
func (s *Social) handleAccountInfo(packet *Packet) {
//Just fire the personainfo, Auth handles the callback
flags := EClientPersonaStateFlag_PlayerName | EClientPersonaStateFlag_Presence | EClientPersonaStateFlag_SourceID
s.RequestFriendInfo(s.client.SteamId(), EClientPersonaStateFlag(flags))
}
func (s *Social) handleFriendsList(packet *Packet) {
list := new(CMsgClientFriendsList)
packet.ReadProtoMsg(list)
var friends []SteamId
for _, friend := range list.GetFriends() {
steamId := SteamId(friend.GetUlfriendid())
isClan := steamId.GetAccountType() == int32(EAccountType_Clan)
if isClan {
rel := EClanRelationship(friend.GetEfriendrelationship())
if rel == EClanRelationship_None {
s.Groups.Remove(steamId)
} else {
s.Groups.Add(socialcache.Group{
SteamId: steamId,
Relationship: rel,
})
}
if list.GetBincremental() {
s.client.Emit(&GroupStateEvent{steamId, rel})
}
} else {
rel := EFriendRelationship(friend.GetEfriendrelationship())
if rel == EFriendRelationship_None {
s.Friends.Remove(steamId)
} else {
s.Friends.Add(socialcache.Friend{
SteamId: steamId,
Relationship: rel,
})
}
if list.GetBincremental() {
s.client.Emit(&FriendStateEvent{steamId, rel})
}
}
if !list.GetBincremental() {
friends = append(friends, steamId)
}
}
if !list.GetBincremental() {
s.RequestFriendListInfo(friends, EClientPersonaStateFlag_DefaultInfoRequest)
s.client.Emit(&FriendsListEvent{})
}
}
func (s *Social) handlePersonaState(packet *Packet) {
list := new(CMsgClientPersonaState)
packet.ReadProtoMsg(list)
flags := EClientPersonaStateFlag(list.GetStatusFlags())
for _, friend := range list.GetFriends() {
id := SteamId(friend.GetFriendid())
if id == s.client.SteamId() { //this is our client id
s.mutex.Lock()
if friend.GetPlayerName() != "" {
s.name = friend.GetPlayerName()
}
avatar := hex.EncodeToString(friend.GetAvatarHash())
if ValidAvatar(avatar) {
s.avatar = avatar
}
s.mutex.Unlock()
} else if id.GetAccountType() == int32(EAccountType_Individual) {
if (flags & EClientPersonaStateFlag_PlayerName) == EClientPersonaStateFlag_PlayerName {
if friend.GetPlayerName() != "" {
s.Friends.SetName(id, friend.GetPlayerName())
}
}
if (flags & EClientPersonaStateFlag_Presence) == EClientPersonaStateFlag_Presence {
avatar := hex.EncodeToString(friend.GetAvatarHash())
if ValidAvatar(avatar) {
s.Friends.SetAvatar(id, avatar)
}
s.Friends.SetPersonaState(id, EPersonaState(friend.GetPersonaState()))
s.Friends.SetPersonaStateFlags(id, EPersonaStateFlag(friend.GetPersonaStateFlags()))
}
if (flags & EClientPersonaStateFlag_GameDataBlob) == EClientPersonaStateFlag_GameDataBlob {
s.Friends.SetGameAppId(id, friend.GetGamePlayedAppId())
s.Friends.SetGameId(id, friend.GetGameid())
s.Friends.SetGameName(id, friend.GetGameName())
}
} else if id.GetAccountType() == int32(EAccountType_Clan) {
if (flags & EClientPersonaStateFlag_PlayerName) == EClientPersonaStateFlag_PlayerName {
if friend.GetPlayerName() != "" {
s.Groups.SetName(id, friend.GetPlayerName())
}
}
if (flags & EClientPersonaStateFlag_Presence) == EClientPersonaStateFlag_Presence {
avatar := hex.EncodeToString(friend.GetAvatarHash())
if ValidAvatar(avatar) {
s.Groups.SetAvatar(id, avatar)
}
}
}
s.client.Emit(&PersonaStateEvent{
StatusFlags: flags,
FriendId: id,
State: EPersonaState(friend.GetPersonaState()),
StateFlags: EPersonaStateFlag(friend.GetPersonaStateFlags()),
GameAppId: friend.GetGamePlayedAppId(),
GameId: friend.GetGameid(),
GameName: friend.GetGameName(),
GameServerIp: friend.GetGameServerIp(),
GameServerPort: friend.GetGameServerPort(),
QueryPort: friend.GetQueryPort(),
SourceSteamId: SteamId(friend.GetSteamidSource()),
GameDataBlob: friend.GetGameDataBlob(),
Name: friend.GetPlayerName(),
Avatar: hex.EncodeToString(friend.GetAvatarHash()),
LastLogOff: friend.GetLastLogoff(),
LastLogOn: friend.GetLastLogon(),
ClanRank: friend.GetClanRank(),
ClanTag: friend.GetClanTag(),
OnlineSessionInstances: friend.GetOnlineSessionInstances(),
PublishedSessionId: friend.GetPublishedInstanceId(),
PersonaSetByUser: friend.GetPersonaSetByUser(),
FacebookName: friend.GetFacebookName(),
FacebookId: friend.GetFacebookId(),
})
}
}
func (s *Social) handleClanState(packet *Packet) {
body := new(CMsgClientClanState)
packet.ReadProtoMsg(body)
var name string
var avatar string
if body.GetNameInfo() != nil {
name = body.GetNameInfo().GetClanName()
avatar = hex.EncodeToString(body.GetNameInfo().GetShaAvatar())
}
var totalCount, onlineCount, chattingCount, ingameCount uint32
if body.GetUserCounts() != nil {
usercounts := body.GetUserCounts()
totalCount = usercounts.GetMembers()
onlineCount = usercounts.GetOnline()
chattingCount = usercounts.GetChatting()
ingameCount = usercounts.GetInGame()
}
var events, announcements []ClanEventDetails
for _, event := range body.GetEvents() {
events = append(events, ClanEventDetails{
Id: event.GetGid(),
EventTime: event.GetEventTime(),
Headline: event.GetHeadline(),
GameId: event.GetGameId(),
JustPosted: event.GetJustPosted(),
})
}
for _, announce := range body.GetAnnouncements() {
announcements = append(announcements, ClanEventDetails{
Id: announce.GetGid(),
EventTime: announce.GetEventTime(),
Headline: announce.GetHeadline(),
GameId: announce.GetGameId(),
JustPosted: announce.GetJustPosted(),
})
}
flags := EClientPersonaStateFlag(body.GetMUnStatusFlags())
//Add stuff to group
clanid := SteamId(body.GetSteamidClan())
if (flags & EClientPersonaStateFlag_PlayerName) == EClientPersonaStateFlag_PlayerName {
if name != "" {
s.Groups.SetName(clanid, name)
}
}
if (flags & EClientPersonaStateFlag_Presence) == EClientPersonaStateFlag_Presence {
if ValidAvatar(avatar) {
s.Groups.SetAvatar(clanid, avatar)
}
}
if body.GetUserCounts() != nil {
s.Groups.SetMemberTotalCount(clanid, totalCount)
s.Groups.SetMemberOnlineCount(clanid, onlineCount)
s.Groups.SetMemberChattingCount(clanid, chattingCount)
s.Groups.SetMemberInGameCount(clanid, ingameCount)
}
s.client.Emit(&ClanStateEvent{
ClandId: clanid,
StateFlags: EClientPersonaStateFlag(body.GetMUnStatusFlags()),
AccountFlags: EAccountFlags(body.GetClanAccountFlags()),
ClanName: name,
Avatar: avatar,
MemberTotalCount: totalCount,
MemberOnlineCount: onlineCount,
MemberChattingCount: chattingCount,
MemberInGameCount: ingameCount,
Events: events,
Announcements: announcements,
})
}
func (s *Social) handleFriendResponse(packet *Packet) {
body := new(CMsgClientAddFriendResponse)
packet.ReadProtoMsg(body)
s.client.Emit(&FriendAddedEvent{
Result: EResult(body.GetEresult()),
SteamId: SteamId(body.GetSteamIdAdded()),
PersonaName: body.GetPersonaNameAdded(),
})
}
func (s *Social) handleFriendMsg(packet *Packet) {
body := new(CMsgClientFriendMsgIncoming)
packet.ReadProtoMsg(body)
message := string(bytes.Split(body.GetMessage(), []byte{0x0})[0])
s.client.Emit(&ChatMsgEvent{
ChatterId: SteamId(body.GetSteamidFrom()),
Message: message,
EntryType: EChatEntryType(body.GetChatEntryType()),
Timestamp: time.Unix(int64(body.GetRtime32ServerTimestamp()), 0),
})
}
func (s *Social) handleChatMsg(packet *Packet) {
body := new(MsgClientChatMsg)
payload := packet.ReadClientMsg(body).Payload
message := string(bytes.Split(payload, []byte{0x0})[0])
s.client.Emit(&ChatMsgEvent{
ChatRoomId: SteamId(body.SteamIdChatRoom),
ChatterId: SteamId(body.SteamIdChatter),
Message: message,
EntryType: EChatEntryType(body.ChatMsgType),
})
}
func (s *Social) handleChatEnter(packet *Packet) {
body := new(MsgClientChatEnter)
payload := packet.ReadClientMsg(body).Payload
reader := bytes.NewBuffer(payload)
name, _ := ReadString(reader)
ReadByte(reader) //0
count := body.NumMembers
chatId := SteamId(body.SteamIdChat)
clanId := SteamId(body.SteamIdClan)
s.Chats.Add(socialcache.Chat{SteamId: chatId, GroupId: clanId})
for i := 0; i < int(count); i++ {
id, chatPerm, clanPerm := readChatMember(reader)
ReadBytes(reader, 6) //No idea what this is
s.Chats.AddChatMember(chatId, socialcache.ChatMember{
SteamId: SteamId(id),
ChatPermissions: chatPerm,
ClanPermissions: clanPerm,
})
}
s.client.Emit(&ChatEnterEvent{
ChatRoomId: SteamId(body.SteamIdChat),
FriendId: SteamId(body.SteamIdFriend),
ChatRoomType: EChatRoomType(body.ChatRoomType),
OwnerId: SteamId(body.SteamIdOwner),
ClanId: SteamId(body.SteamIdClan),
ChatFlags: byte(body.ChatFlags),
EnterResponse: EChatRoomEnterResponse(body.EnterResponse),
Name: name,
})
}
func (s *Social) handleChatMemberInfo(packet *Packet) {
body := new(MsgClientChatMemberInfo)
payload := packet.ReadClientMsg(body).Payload
reader := bytes.NewBuffer(payload)
chatId := SteamId(body.SteamIdChat)
if body.Type == EChatInfoType_StateChange {
actedOn, _ := ReadUint64(reader)
state, _ := ReadInt32(reader)
actedBy, _ := ReadUint64(reader)
ReadByte(reader) //0
stateChange := EChatMemberStateChange(state)
if stateChange == EChatMemberStateChange_Entered {
_, chatPerm, clanPerm := readChatMember(reader)
s.Chats.AddChatMember(chatId, socialcache.ChatMember{
SteamId: SteamId(actedOn),
ChatPermissions: chatPerm,
ClanPermissions: clanPerm,
})
} else if stateChange == EChatMemberStateChange_Banned || stateChange == EChatMemberStateChange_Kicked ||
stateChange == EChatMemberStateChange_Disconnected || stateChange == EChatMemberStateChange_Left {
s.Chats.RemoveChatMember(chatId, SteamId(actedOn))
}
stateInfo := StateChangeDetails{
ChatterActedOn: SteamId(actedOn),
StateChange: EChatMemberStateChange(stateChange),
ChatterActedBy: SteamId(actedBy),
}
s.client.Emit(&ChatMemberInfoEvent{
ChatRoomId: SteamId(body.SteamIdChat),
Type: EChatInfoType(body.Type),
StateChangeInfo: stateInfo,
})
}
}
func readChatMember(r io.Reader) (SteamId, EChatPermission, EClanPermission) {
ReadString(r) // MessageObject
ReadByte(r) // 7
ReadString(r) //steamid
id, _ := ReadUint64(r)
ReadByte(r) // 2
ReadString(r) //Permissions
chat, _ := ReadInt32(r)
ReadByte(r) // 2
ReadString(r) //Details
clan, _ := ReadInt32(r)
return SteamId(id), EChatPermission(chat), EClanPermission(clan)
}
func (s *Social) handleChatActionResult(packet *Packet) {
body := new(MsgClientChatActionResult)
packet.ReadClientMsg(body)
s.client.Emit(&ChatActionResultEvent{
ChatRoomId: SteamId(body.SteamIdChat),
ChatterId: SteamId(body.SteamIdUserActedOn),
Action: EChatAction(body.ChatAction),
Result: EChatActionResult(body.ActionResult),
})
}
func (s *Social) handleChatInvite(packet *Packet) {
body := new(CMsgClientChatInvite)
packet.ReadProtoMsg(body)
s.client.Emit(&ChatInviteEvent{
InvitedId: SteamId(body.GetSteamIdInvited()),
ChatRoomId: SteamId(body.GetSteamIdChat()),
PatronId: SteamId(body.GetSteamIdPatron()),
ChatRoomType: EChatRoomType(body.GetChatroomType()),
FriendChatId: SteamId(body.GetSteamIdFriendChat()),
ChatRoomName: body.GetChatName(),
GameId: body.GetGameId(),
})
}
func (s *Social) handleIgnoreFriendResponse(packet *Packet) {
body := new(MsgClientSetIgnoreFriendResponse)
packet.ReadClientMsg(body)
s.client.Emit(&IgnoreFriendEvent{
Result: EResult(body.Result),
})
}
func (s *Social) handleProfileInfoResponse(packet *Packet) {
body := new(CMsgClientFriendProfileInfoResponse)
packet.ReadProtoMsg(body)
s.client.Emit(&ProfileInfoEvent{
Result: EResult(body.GetEresult()),
SteamId: SteamId(body.GetSteamidFriend()),
TimeCreated: body.GetTimeCreated(),
RealName: body.GetRealName(),
CityName: body.GetCityName(),
StateName: body.GetStateName(),
CountryName: body.GetCountryName(),
Headline: body.GetHeadline(),
Summary: body.GetSummary(),
})
}
func (s *Social) handleFriendMessageHistoryResponse(packet *Packet) {
body := new(CMsgClientFSGetFriendMessageHistoryResponse)
packet.ReadProtoMsg(body)
steamid := SteamId(body.GetSteamid())
for _, message := range body.GetMessages() {
if !message.GetUnread() {
continue // Skip already read messages
}
s.client.Emit(&ChatMsgEvent{
ChatterId: steamid,
Message: message.GetMessage(),
EntryType: EChatEntryType_ChatMsg,
Timestamp: time.Unix(int64(message.GetTimestamp()), 0),
Offline: true, // GetUnread is true
})
}
}

161
vendor/github.com/Philipp15b/go-steam/social_events.go generated vendored Normal file
View File

@ -0,0 +1,161 @@
package steam
import (
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
"time"
)
type FriendsListEvent struct{}
type FriendStateEvent struct {
SteamId SteamId `json:",string"`
Relationship EFriendRelationship
}
func (f *FriendStateEvent) IsFriend() bool {
return f.Relationship == EFriendRelationship_Friend
}
type GroupStateEvent struct {
SteamId SteamId `json:",string"`
Relationship EClanRelationship
}
func (g *GroupStateEvent) IsMember() bool {
return g.Relationship == EClanRelationship_Member
}
// Fired when someone changing their friend details
type PersonaStateEvent struct {
StatusFlags EClientPersonaStateFlag
FriendId SteamId `json:",string"`
State EPersonaState
StateFlags EPersonaStateFlag
GameAppId uint32
GameId uint64 `json:",string"`
GameName string
GameServerIp uint32
GameServerPort uint32
QueryPort uint32
SourceSteamId SteamId `json:",string"`
GameDataBlob []byte
Name string
Avatar string
LastLogOff uint32
LastLogOn uint32
ClanRank uint32
ClanTag string
OnlineSessionInstances uint32
PublishedSessionId uint32
PersonaSetByUser bool
FacebookName string
FacebookId uint64 `json:",string"`
}
// Fired when a clan's state has been changed
type ClanStateEvent struct {
ClandId SteamId `json:",string"`
StateFlags EClientPersonaStateFlag
AccountFlags EAccountFlags
ClanName string
Avatar string
MemberTotalCount uint32
MemberOnlineCount uint32
MemberChattingCount uint32
MemberInGameCount uint32
Events []ClanEventDetails
Announcements []ClanEventDetails
}
type ClanEventDetails struct {
Id uint64 `json:",string"`
EventTime uint32
Headline string
GameId uint64 `json:",string"`
JustPosted bool
}
// Fired in response to adding a friend to your friends list
type FriendAddedEvent struct {
Result EResult
SteamId SteamId `json:",string"`
PersonaName string
}
// Fired when the client receives a message from either a friend or a chat room
type ChatMsgEvent struct {
ChatRoomId SteamId `json:",string"` // not set for friend messages
ChatterId SteamId `json:",string"`
Message string
EntryType EChatEntryType
Timestamp time.Time
Offline bool
}
// Whether the type is ChatMsg
func (c *ChatMsgEvent) IsMessage() bool {
return c.EntryType == EChatEntryType_ChatMsg
}
// Fired in response to joining a chat
type ChatEnterEvent struct {
ChatRoomId SteamId `json:",string"`
FriendId SteamId `json:",string"`
ChatRoomType EChatRoomType
OwnerId SteamId `json:",string"`
ClanId SteamId `json:",string"`
ChatFlags byte
EnterResponse EChatRoomEnterResponse
Name string
}
// Fired in response to a chat member's info being received
type ChatMemberInfoEvent struct {
ChatRoomId SteamId `json:",string"`
Type EChatInfoType
StateChangeInfo StateChangeDetails
}
type StateChangeDetails struct {
ChatterActedOn SteamId `json:",string"`
StateChange EChatMemberStateChange
ChatterActedBy SteamId `json:",string"`
}
// Fired when a chat action has completed
type ChatActionResultEvent struct {
ChatRoomId SteamId `json:",string"`
ChatterId SteamId `json:",string"`
Action EChatAction
Result EChatActionResult
}
// Fired when a chat invite is received
type ChatInviteEvent struct {
InvitedId SteamId `json:",string"`
ChatRoomId SteamId `json:",string"`
PatronId SteamId `json:",string"`
ChatRoomType EChatRoomType
FriendChatId SteamId `json:",string"`
ChatRoomName string
GameId uint64 `json:",string"`
}
// Fired in response to ignoring a friend
type IgnoreFriendEvent struct {
Result EResult
}
// Fired in response to requesting profile info for a user
type ProfileInfoEvent struct {
Result EResult
SteamId SteamId `json:",string"`
TimeCreated uint32
RealName string
CityName string
StateName string
CountryName string
Headline string
Summary string
}

View File

@ -0,0 +1,111 @@
package socialcache
import (
"errors"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
"sync"
)
// Chats list is a thread safe map
// They can be iterated over like so:
// for id, chat := range client.Social.Chats.GetCopy() {
// log.Println(id, chat.Name)
// }
type ChatsList struct {
mutex sync.RWMutex
byId map[SteamId]*Chat
}
// Returns a new chats list
func NewChatsList() *ChatsList {
return &ChatsList{byId: make(map[SteamId]*Chat)}
}
// Adds a chat to the chat list
func (list *ChatsList) Add(chat Chat) {
list.mutex.Lock()
defer list.mutex.Unlock()
_, exists := list.byId[chat.SteamId]
if !exists { //make sure this doesnt already exist
list.byId[chat.SteamId] = &chat
}
}
// Removes a chat from the chat list
func (list *ChatsList) Remove(id SteamId) {
list.mutex.Lock()
defer list.mutex.Unlock()
delete(list.byId, id)
}
// Adds a chat member to a given chat
func (list *ChatsList) AddChatMember(id SteamId, member ChatMember) {
list.mutex.Lock()
defer list.mutex.Unlock()
chat := list.byId[id]
if chat == nil { //Chat doesn't exist
chat = &Chat{SteamId: id}
list.byId[id] = chat
}
if chat.ChatMembers == nil { //New chat
chat.ChatMembers = make(map[SteamId]ChatMember)
}
chat.ChatMembers[member.SteamId] = member
}
// Removes a chat member from a given chat
func (list *ChatsList) RemoveChatMember(id SteamId, member SteamId) {
list.mutex.Lock()
defer list.mutex.Unlock()
chat := list.byId[id]
if chat == nil { //Chat doesn't exist
return
}
if chat.ChatMembers == nil { //New chat
return
}
delete(chat.ChatMembers, member)
}
// Returns a copy of the chats map
func (list *ChatsList) GetCopy() map[SteamId]Chat {
list.mutex.RLock()
defer list.mutex.RUnlock()
glist := make(map[SteamId]Chat)
for key, chat := range list.byId {
glist[key] = *chat
}
return glist
}
// Returns a copy of the chat of a given SteamId
func (list *ChatsList) ById(id SteamId) (Chat, error) {
list.mutex.RLock()
defer list.mutex.RUnlock()
if val, ok := list.byId[id]; ok {
return *val, nil
}
return Chat{}, errors.New("Chat not found")
}
// Returns the number of chats
func (list *ChatsList) Count() int {
list.mutex.RLock()
defer list.mutex.RUnlock()
return len(list.byId)
}
// A Chat
type Chat struct {
SteamId SteamId `json:",string"`
GroupId SteamId `json:",string"`
ChatMembers map[SteamId]ChatMember
}
// A Chat Member
type ChatMember struct {
SteamId SteamId `json:",string"`
ChatPermissions EChatPermission
ClanPermissions EClanPermission
}

View File

@ -0,0 +1,146 @@
package socialcache
import (
"errors"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
"sync"
)
// Friends list is a thread safe map
// They can be iterated over like so:
// for id, friend := range client.Social.Friends.GetCopy() {
// log.Println(id, friend.Name)
// }
type FriendsList struct {
mutex sync.RWMutex
byId map[SteamId]*Friend
}
// Returns a new friends list
func NewFriendsList() *FriendsList {
return &FriendsList{byId: make(map[SteamId]*Friend)}
}
// Adds a friend to the friend list
func (list *FriendsList) Add(friend Friend) {
list.mutex.Lock()
defer list.mutex.Unlock()
_, exists := list.byId[friend.SteamId]
if !exists { //make sure this doesnt already exist
list.byId[friend.SteamId] = &friend
}
}
// Removes a friend from the friend list
func (list *FriendsList) Remove(id SteamId) {
list.mutex.Lock()
defer list.mutex.Unlock()
delete(list.byId, id)
}
// Returns a copy of the friends map
func (list *FriendsList) GetCopy() map[SteamId]Friend {
list.mutex.RLock()
defer list.mutex.RUnlock()
flist := make(map[SteamId]Friend)
for key, friend := range list.byId {
flist[key] = *friend
}
return flist
}
// Returns a copy of the friend of a given SteamId
func (list *FriendsList) ById(id SteamId) (Friend, error) {
list.mutex.RLock()
defer list.mutex.RUnlock()
if val, ok := list.byId[id]; ok {
return *val, nil
}
return Friend{}, errors.New("Friend not found")
}
// Returns the number of friends
func (list *FriendsList) Count() int {
list.mutex.RLock()
defer list.mutex.RUnlock()
return len(list.byId)
}
//Setter methods
func (list *FriendsList) SetName(id SteamId, name string) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.Name = name
}
}
func (list *FriendsList) SetAvatar(id SteamId, hash string) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.Avatar = hash
}
}
func (list *FriendsList) SetRelationship(id SteamId, relationship EFriendRelationship) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.Relationship = relationship
}
}
func (list *FriendsList) SetPersonaState(id SteamId, state EPersonaState) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.PersonaState = state
}
}
func (list *FriendsList) SetPersonaStateFlags(id SteamId, flags EPersonaStateFlag) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.PersonaStateFlags = flags
}
}
func (list *FriendsList) SetGameAppId(id SteamId, gameappid uint32) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.GameAppId = gameappid
}
}
func (list *FriendsList) SetGameId(id SteamId, gameid uint64) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.GameId = gameid
}
}
func (list *FriendsList) SetGameName(id SteamId, name string) {
list.mutex.Lock()
defer list.mutex.Unlock()
if val, ok := list.byId[id]; ok {
val.GameName = name
}
}
// A Friend
type Friend struct {
SteamId SteamId `json:",string"`
Name string
Avatar string
Relationship EFriendRelationship
PersonaState EPersonaState
PersonaStateFlags EPersonaStateFlag
GameAppId uint32
GameId uint64 `json:",string"`
GameName string
}

View File

@ -0,0 +1,145 @@
package socialcache
import (
"errors"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
"sync"
)
// Groups list is a thread safe map
// They can be iterated over like so:
// for id, group := range client.Social.Groups.GetCopy() {
// log.Println(id, group.Name)
// }
type GroupsList struct {
mutex sync.RWMutex
byId map[SteamId]*Group
}
// Returns a new groups list
func NewGroupsList() *GroupsList {
return &GroupsList{byId: make(map[SteamId]*Group)}
}
// Adds a group to the group list
func (list *GroupsList) Add(group Group) {
list.mutex.Lock()
defer list.mutex.Unlock()
_, exists := list.byId[group.SteamId]
if !exists { //make sure this doesnt already exist
list.byId[group.SteamId] = &group
}
}
// Removes a group from the group list
func (list *GroupsList) Remove(id SteamId) {
list.mutex.Lock()
defer list.mutex.Unlock()
delete(list.byId, id)
}
// Returns a copy of the groups map
func (list *GroupsList) GetCopy() map[SteamId]Group {
list.mutex.RLock()
defer list.mutex.RUnlock()
glist := make(map[SteamId]Group)
for key, group := range list.byId {
glist[key] = *group
}
return glist
}
// Returns a copy of the group of a given SteamId
func (list *GroupsList) ById(id SteamId) (Group, error) {
list.mutex.RLock()
defer list.mutex.RUnlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
return *val, nil
}
return Group{}, errors.New("Group not found")
}
// Returns the number of groups
func (list *GroupsList) Count() int {
list.mutex.RLock()
defer list.mutex.RUnlock()
return len(list.byId)
}
//Setter methods
func (list *GroupsList) SetName(id SteamId, name string) {
list.mutex.Lock()
defer list.mutex.Unlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
val.Name = name
}
}
func (list *GroupsList) SetAvatar(id SteamId, hash string) {
list.mutex.Lock()
defer list.mutex.Unlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
val.Avatar = hash
}
}
func (list *GroupsList) SetRelationship(id SteamId, relationship EClanRelationship) {
list.mutex.Lock()
defer list.mutex.Unlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
val.Relationship = relationship
}
}
func (list *GroupsList) SetMemberTotalCount(id SteamId, count uint32) {
list.mutex.Lock()
defer list.mutex.Unlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
val.MemberTotalCount = count
}
}
func (list *GroupsList) SetMemberOnlineCount(id SteamId, count uint32) {
list.mutex.Lock()
defer list.mutex.Unlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
val.MemberOnlineCount = count
}
}
func (list *GroupsList) SetMemberChattingCount(id SteamId, count uint32) {
list.mutex.Lock()
defer list.mutex.Unlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
val.MemberChattingCount = count
}
}
func (list *GroupsList) SetMemberInGameCount(id SteamId, count uint32) {
list.mutex.Lock()
defer list.mutex.Unlock()
id = id.ChatToClan()
if val, ok := list.byId[id]; ok {
val.MemberInGameCount = count
}
}
// A Group
type Group struct {
SteamId SteamId `json:",string"`
Name string
Avatar string
Relationship EClanRelationship
MemberTotalCount uint32
MemberOnlineCount uint32
MemberChattingCount uint32
MemberInGameCount uint32
}

View File

@ -0,0 +1,76 @@
package steam
import (
"encoding/json"
"fmt"
"math/rand"
"net/http"
"sync"
"time"
"github.com/Philipp15b/go-steam/netutil"
)
// Load initial server list from Steam Directory Web API.
// Call InitializeSteamDirectory() before Connect() to use
// steam directory server list instead of static one.
func InitializeSteamDirectory() error {
return steamDirectoryCache.Initialize()
}
var steamDirectoryCache *steamDirectory = &steamDirectory{}
type steamDirectory struct {
sync.RWMutex
servers []string
isInitialized bool
}
// Get server list from steam directory and save it for later
func (sd *steamDirectory) Initialize() error {
sd.Lock()
defer sd.Unlock()
client := new(http.Client)
resp, err := client.Get(fmt.Sprintf("https://api.steampowered.com/ISteamDirectory/GetCMList/v1/?cellId=0"))
if err != nil {
return err
}
defer resp.Body.Close()
r := struct {
Response struct {
ServerList []string
Result uint32
Message string
}
}{}
if err = json.NewDecoder(resp.Body).Decode(&r); err != nil {
return err
}
if r.Response.Result != 1 {
return fmt.Errorf("Failed to get steam directory, result: %v, message: %v\n", r.Response.Result, r.Response.Message)
}
if len(r.Response.ServerList) == 0 {
return fmt.Errorf("Steam returned zero servers for steam directory request\n")
}
sd.servers = r.Response.ServerList
sd.isInitialized = true
return nil
}
func (sd *steamDirectory) GetRandomCM() *netutil.PortAddr {
sd.RLock()
defer sd.RUnlock()
if !sd.isInitialized {
panic("steam directory is not initialized")
}
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
addr := netutil.ParsePortAddr(sd.servers[rng.Int31n(int32(len(sd.servers)))])
return addr
}
func (sd *steamDirectory) IsInitialized() bool {
sd.RLock()
defer sd.RUnlock()
isInitialized := sd.isInitialized
return isInitialized
}

View File

@ -0,0 +1,136 @@
package steamid
import (
"fmt"
"strconv"
"errors"
"regexp"
"strings"
)
type ChatInstanceFlag uint64
const (
Clan ChatInstanceFlag = 0x100000 >> 1
Lobby ChatInstanceFlag = 0x100000 >> 2
MMSLobby ChatInstanceFlag = 0x100000 >> 3
)
type SteamId uint64
func NewId(id string) (SteamId, error) {
valid, err := regexp.MatchString(`STEAM_[0-5]:[01]:\d+`, id)
if err != nil {
return SteamId(0), err
}
if valid {
id = strings.Replace(id, "STEAM_", "", -1) // remove STEAM_
splitid := strings.Split(id, ":") // split 0:1:00000000 into 0 1 00000000
universe, _ := strconv.ParseInt(splitid[0], 10, 32)
if universe == 0 { //EUniverse_Invalid
universe = 1 //EUniverse_Public
}
authServer, _ := strconv.ParseUint(splitid[1], 10, 32)
accId, _ := strconv.ParseUint(splitid[2], 10, 32)
accountType := int32(1) //EAccountType_Individual
accountId := (uint32(accId) << 1) | uint32(authServer)
return NewIdAdv(uint32(accountId), 1, int32(universe), accountType), nil
} else {
newid, err := strconv.ParseUint(id, 10, 64)
if err != nil {
return SteamId(0), err
}
return SteamId(newid), nil
}
return SteamId(0), errors.New(fmt.Sprintf("Invalid SteamId: %s\n", id))
}
func NewIdAdv(accountId, instance uint32, universe int32, accountType int32) SteamId {
s := SteamId(0)
s = s.SetAccountId(accountId)
s = s.SetAccountInstance(instance)
s = s.SetAccountUniverse(universe)
s = s.SetAccountType(accountType)
return s
}
func (s SteamId) ToUint64() uint64 {
return uint64(s)
}
func (s SteamId) ToString() string {
return strconv.FormatUint(uint64(s), 10)
}
func (s SteamId) String() string {
switch s.GetAccountType() {
case 0: // EAccountType_Invalid
fallthrough
case 1: // EAccountType_Individual
if s.GetAccountUniverse() <= 1 { // EUniverse_Public
return fmt.Sprintf("STEAM_0:%d:%d", s.GetAccountId()&1, s.GetAccountId()>>1)
} else {
return fmt.Sprintf("STEAM_%d:%d:%d", s.GetAccountUniverse(), s.GetAccountId()&1, s.GetAccountId()>>1)
}
default:
return strconv.FormatUint(uint64(s), 10)
}
}
func (s SteamId) get(offset uint, mask uint64) uint64 {
return (uint64(s) >> offset) & mask
}
func (s SteamId) set(offset uint, mask, value uint64) SteamId {
return SteamId((uint64(s) & ^(mask << offset)) | (value&mask)<<offset)
}
func (s SteamId) GetAccountId() uint32 {
return uint32(s.get(0, 0xFFFFFFFF))
}
func (s SteamId) SetAccountId(id uint32) SteamId {
return s.set(0, 0xFFFFFFFF, uint64(id))
}
func (s SteamId) GetAccountInstance() uint32 {
return uint32(s.get(32, 0xFFFFF))
}
func (s SteamId) SetAccountInstance(value uint32) SteamId {
return s.set(32, 0xFFFFF, uint64(value))
}
func (s SteamId) GetAccountType() int32 {
return int32(s.get(52, 0xF))
}
func (s SteamId) SetAccountType(t int32) SteamId {
return s.set(52, 0xF, uint64(t))
}
func (s SteamId) GetAccountUniverse() int32 {
return int32(s.get(56, 0xF))
}
func (s SteamId) SetAccountUniverse(universe int32) SteamId {
return s.set(56, 0xF, uint64(universe))
}
//used to fix the Clan SteamId to a Chat SteamId
func (s SteamId) ClanToChat() SteamId {
if s.GetAccountType() == int32(7) { //EAccountType_Clan
s = s.SetAccountInstance(uint32(Clan))
s = s.SetAccountType(8) //EAccountType_Chat
}
return s
}
//used to fix the Chat SteamId to a Clan SteamId
func (s SteamId) ChatToClan() SteamId {
if s.GetAccountType() == int32(8) { //EAccountType_Chat
s = s.SetAccountInstance(0)
s = s.SetAccountType(int32(7)) //EAccountType_Clan
}
return s
}

View File

@ -0,0 +1,51 @@
package protocol
import (
"encoding/binary"
"io"
)
type MsgGCSetItemPosition struct {
AssetId, Position uint64
}
func (m *MsgGCSetItemPosition) Serialize(w io.Writer) error {
return binary.Write(w, binary.LittleEndian, m)
}
type MsgGCCraft struct {
Recipe int16 // -2 = wildcard
numItems int16
Items []uint64
}
func (m *MsgGCCraft) Serialize(w io.Writer) error {
m.numItems = int16(len(m.Items))
return binary.Write(w, binary.LittleEndian, m)
}
type MsgGCDeleteItem struct {
ItemId uint64
}
func (m *MsgGCDeleteItem) Serialize(w io.Writer) error {
return binary.Write(w, binary.LittleEndian, m.ItemId)
}
type MsgGCNameItem struct {
Tool, Target uint64
Name string
}
func (m *MsgGCNameItem) Serialize(w io.Writer) error {
err := binary.Write(w, binary.LittleEndian, m.Tool)
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, m.Target)
if err != nil {
return err
}
_, err = w.Write([]byte(m.Name))
return err
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,545 @@
// Code generated by protoc-gen-go.
// source: gcsystemmsgs.proto
// DO NOT EDIT!
package protobuf
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type EGCSystemMsg int32
const (
EGCSystemMsg_k_EGCMsgInvalid EGCSystemMsg = 0
EGCSystemMsg_k_EGCMsgMulti EGCSystemMsg = 1
EGCSystemMsg_k_EGCMsgGenericReply EGCSystemMsg = 10
EGCSystemMsg_k_EGCMsgSystemBase EGCSystemMsg = 50
EGCSystemMsg_k_EGCMsgAchievementAwarded EGCSystemMsg = 51
EGCSystemMsg_k_EGCMsgConCommand EGCSystemMsg = 52
EGCSystemMsg_k_EGCMsgStartPlaying EGCSystemMsg = 53
EGCSystemMsg_k_EGCMsgStopPlaying EGCSystemMsg = 54
EGCSystemMsg_k_EGCMsgStartGameserver EGCSystemMsg = 55
EGCSystemMsg_k_EGCMsgStopGameserver EGCSystemMsg = 56
EGCSystemMsg_k_EGCMsgWGRequest EGCSystemMsg = 57
EGCSystemMsg_k_EGCMsgWGResponse EGCSystemMsg = 58
EGCSystemMsg_k_EGCMsgGetUserGameStatsSchema EGCSystemMsg = 59
EGCSystemMsg_k_EGCMsgGetUserGameStatsSchemaResponse EGCSystemMsg = 60
EGCSystemMsg_k_EGCMsgGetUserStatsDEPRECATED EGCSystemMsg = 61
EGCSystemMsg_k_EGCMsgGetUserStatsResponse EGCSystemMsg = 62
EGCSystemMsg_k_EGCMsgAppInfoUpdated EGCSystemMsg = 63
EGCSystemMsg_k_EGCMsgValidateSession EGCSystemMsg = 64
EGCSystemMsg_k_EGCMsgValidateSessionResponse EGCSystemMsg = 65
EGCSystemMsg_k_EGCMsgLookupAccountFromInput EGCSystemMsg = 66
EGCSystemMsg_k_EGCMsgSendHTTPRequest EGCSystemMsg = 67
EGCSystemMsg_k_EGCMsgSendHTTPRequestResponse EGCSystemMsg = 68
EGCSystemMsg_k_EGCMsgPreTestSetup EGCSystemMsg = 69
EGCSystemMsg_k_EGCMsgRecordSupportAction EGCSystemMsg = 70
EGCSystemMsg_k_EGCMsgGetAccountDetails_DEPRECATED EGCSystemMsg = 71
EGCSystemMsg_k_EGCMsgReceiveInterAppMessage EGCSystemMsg = 73
EGCSystemMsg_k_EGCMsgFindAccounts EGCSystemMsg = 74
EGCSystemMsg_k_EGCMsgPostAlert EGCSystemMsg = 75
EGCSystemMsg_k_EGCMsgGetLicenses EGCSystemMsg = 76
EGCSystemMsg_k_EGCMsgGetUserStats EGCSystemMsg = 77
EGCSystemMsg_k_EGCMsgGetCommands EGCSystemMsg = 78
EGCSystemMsg_k_EGCMsgGetCommandsResponse EGCSystemMsg = 79
EGCSystemMsg_k_EGCMsgAddFreeLicense EGCSystemMsg = 80
EGCSystemMsg_k_EGCMsgAddFreeLicenseResponse EGCSystemMsg = 81
EGCSystemMsg_k_EGCMsgGetIPLocation EGCSystemMsg = 82
EGCSystemMsg_k_EGCMsgGetIPLocationResponse EGCSystemMsg = 83
EGCSystemMsg_k_EGCMsgSystemStatsSchema EGCSystemMsg = 84
EGCSystemMsg_k_EGCMsgGetSystemStats EGCSystemMsg = 85
EGCSystemMsg_k_EGCMsgGetSystemStatsResponse EGCSystemMsg = 86
EGCSystemMsg_k_EGCMsgSendEmail EGCSystemMsg = 87
EGCSystemMsg_k_EGCMsgSendEmailResponse EGCSystemMsg = 88
EGCSystemMsg_k_EGCMsgGetEmailTemplate EGCSystemMsg = 89
EGCSystemMsg_k_EGCMsgGetEmailTemplateResponse EGCSystemMsg = 90
EGCSystemMsg_k_EGCMsgGrantGuestPass EGCSystemMsg = 91
EGCSystemMsg_k_EGCMsgGrantGuestPassResponse EGCSystemMsg = 92
EGCSystemMsg_k_EGCMsgGetAccountDetails EGCSystemMsg = 93
EGCSystemMsg_k_EGCMsgGetAccountDetailsResponse EGCSystemMsg = 94
EGCSystemMsg_k_EGCMsgGetPersonaNames EGCSystemMsg = 95
EGCSystemMsg_k_EGCMsgGetPersonaNamesResponse EGCSystemMsg = 96
EGCSystemMsg_k_EGCMsgMultiplexMsg EGCSystemMsg = 97
EGCSystemMsg_k_EGCMsgWebAPIRegisterInterfaces EGCSystemMsg = 101
EGCSystemMsg_k_EGCMsgWebAPIJobRequest EGCSystemMsg = 102
EGCSystemMsg_k_EGCMsgWebAPIJobRequestHttpResponse EGCSystemMsg = 104
EGCSystemMsg_k_EGCMsgWebAPIJobRequestForwardResponse EGCSystemMsg = 105
EGCSystemMsg_k_EGCMsgMemCachedGet EGCSystemMsg = 200
EGCSystemMsg_k_EGCMsgMemCachedGetResponse EGCSystemMsg = 201
EGCSystemMsg_k_EGCMsgMemCachedSet EGCSystemMsg = 202
EGCSystemMsg_k_EGCMsgMemCachedDelete EGCSystemMsg = 203
EGCSystemMsg_k_EGCMsgMemCachedStats EGCSystemMsg = 204
EGCSystemMsg_k_EGCMsgMemCachedStatsResponse EGCSystemMsg = 205
EGCSystemMsg_k_EGCMsgSQLStats EGCSystemMsg = 210
EGCSystemMsg_k_EGCMsgSQLStatsResponse EGCSystemMsg = 211
EGCSystemMsg_k_EGCMsgMasterSetDirectory EGCSystemMsg = 220
EGCSystemMsg_k_EGCMsgMasterSetDirectoryResponse EGCSystemMsg = 221
EGCSystemMsg_k_EGCMsgMasterSetWebAPIRouting EGCSystemMsg = 222
EGCSystemMsg_k_EGCMsgMasterSetWebAPIRoutingResponse EGCSystemMsg = 223
EGCSystemMsg_k_EGCMsgMasterSetClientMsgRouting EGCSystemMsg = 224
EGCSystemMsg_k_EGCMsgMasterSetClientMsgRoutingResponse EGCSystemMsg = 225
EGCSystemMsg_k_EGCMsgSetOptions EGCSystemMsg = 226
EGCSystemMsg_k_EGCMsgSetOptionsResponse EGCSystemMsg = 227
EGCSystemMsg_k_EGCMsgSystemBase2 EGCSystemMsg = 500
EGCSystemMsg_k_EGCMsgGetPurchaseTrustStatus EGCSystemMsg = 501
EGCSystemMsg_k_EGCMsgGetPurchaseTrustStatusResponse EGCSystemMsg = 502
EGCSystemMsg_k_EGCMsgUpdateSession EGCSystemMsg = 503
EGCSystemMsg_k_EGCMsgGCAccountVacStatusChange EGCSystemMsg = 504
EGCSystemMsg_k_EGCMsgCheckFriendship EGCSystemMsg = 505
EGCSystemMsg_k_EGCMsgCheckFriendshipResponse EGCSystemMsg = 506
EGCSystemMsg_k_EGCMsgGetPartnerAccountLink EGCSystemMsg = 507
EGCSystemMsg_k_EGCMsgGetPartnerAccountLinkResponse EGCSystemMsg = 508
EGCSystemMsg_k_EGCMsgVSReportedSuspiciousActivity EGCSystemMsg = 509
)
var EGCSystemMsg_name = map[int32]string{
0: "k_EGCMsgInvalid",
1: "k_EGCMsgMulti",
10: "k_EGCMsgGenericReply",
50: "k_EGCMsgSystemBase",
51: "k_EGCMsgAchievementAwarded",
52: "k_EGCMsgConCommand",
53: "k_EGCMsgStartPlaying",
54: "k_EGCMsgStopPlaying",
55: "k_EGCMsgStartGameserver",
56: "k_EGCMsgStopGameserver",
57: "k_EGCMsgWGRequest",
58: "k_EGCMsgWGResponse",
59: "k_EGCMsgGetUserGameStatsSchema",
60: "k_EGCMsgGetUserGameStatsSchemaResponse",
61: "k_EGCMsgGetUserStatsDEPRECATED",
62: "k_EGCMsgGetUserStatsResponse",
63: "k_EGCMsgAppInfoUpdated",
64: "k_EGCMsgValidateSession",
65: "k_EGCMsgValidateSessionResponse",
66: "k_EGCMsgLookupAccountFromInput",
67: "k_EGCMsgSendHTTPRequest",
68: "k_EGCMsgSendHTTPRequestResponse",
69: "k_EGCMsgPreTestSetup",
70: "k_EGCMsgRecordSupportAction",
71: "k_EGCMsgGetAccountDetails_DEPRECATED",
73: "k_EGCMsgReceiveInterAppMessage",
74: "k_EGCMsgFindAccounts",
75: "k_EGCMsgPostAlert",
76: "k_EGCMsgGetLicenses",
77: "k_EGCMsgGetUserStats",
78: "k_EGCMsgGetCommands",
79: "k_EGCMsgGetCommandsResponse",
80: "k_EGCMsgAddFreeLicense",
81: "k_EGCMsgAddFreeLicenseResponse",
82: "k_EGCMsgGetIPLocation",
83: "k_EGCMsgGetIPLocationResponse",
84: "k_EGCMsgSystemStatsSchema",
85: "k_EGCMsgGetSystemStats",
86: "k_EGCMsgGetSystemStatsResponse",
87: "k_EGCMsgSendEmail",
88: "k_EGCMsgSendEmailResponse",
89: "k_EGCMsgGetEmailTemplate",
90: "k_EGCMsgGetEmailTemplateResponse",
91: "k_EGCMsgGrantGuestPass",
92: "k_EGCMsgGrantGuestPassResponse",
93: "k_EGCMsgGetAccountDetails",
94: "k_EGCMsgGetAccountDetailsResponse",
95: "k_EGCMsgGetPersonaNames",
96: "k_EGCMsgGetPersonaNamesResponse",
97: "k_EGCMsgMultiplexMsg",
101: "k_EGCMsgWebAPIRegisterInterfaces",
102: "k_EGCMsgWebAPIJobRequest",
104: "k_EGCMsgWebAPIJobRequestHttpResponse",
105: "k_EGCMsgWebAPIJobRequestForwardResponse",
200: "k_EGCMsgMemCachedGet",
201: "k_EGCMsgMemCachedGetResponse",
202: "k_EGCMsgMemCachedSet",
203: "k_EGCMsgMemCachedDelete",
204: "k_EGCMsgMemCachedStats",
205: "k_EGCMsgMemCachedStatsResponse",
210: "k_EGCMsgSQLStats",
211: "k_EGCMsgSQLStatsResponse",
220: "k_EGCMsgMasterSetDirectory",
221: "k_EGCMsgMasterSetDirectoryResponse",
222: "k_EGCMsgMasterSetWebAPIRouting",
223: "k_EGCMsgMasterSetWebAPIRoutingResponse",
224: "k_EGCMsgMasterSetClientMsgRouting",
225: "k_EGCMsgMasterSetClientMsgRoutingResponse",
226: "k_EGCMsgSetOptions",
227: "k_EGCMsgSetOptionsResponse",
500: "k_EGCMsgSystemBase2",
501: "k_EGCMsgGetPurchaseTrustStatus",
502: "k_EGCMsgGetPurchaseTrustStatusResponse",
503: "k_EGCMsgUpdateSession",
504: "k_EGCMsgGCAccountVacStatusChange",
505: "k_EGCMsgCheckFriendship",
506: "k_EGCMsgCheckFriendshipResponse",
507: "k_EGCMsgGetPartnerAccountLink",
508: "k_EGCMsgGetPartnerAccountLinkResponse",
509: "k_EGCMsgVSReportedSuspiciousActivity",
}
var EGCSystemMsg_value = map[string]int32{
"k_EGCMsgInvalid": 0,
"k_EGCMsgMulti": 1,
"k_EGCMsgGenericReply": 10,
"k_EGCMsgSystemBase": 50,
"k_EGCMsgAchievementAwarded": 51,
"k_EGCMsgConCommand": 52,
"k_EGCMsgStartPlaying": 53,
"k_EGCMsgStopPlaying": 54,
"k_EGCMsgStartGameserver": 55,
"k_EGCMsgStopGameserver": 56,
"k_EGCMsgWGRequest": 57,
"k_EGCMsgWGResponse": 58,
"k_EGCMsgGetUserGameStatsSchema": 59,
"k_EGCMsgGetUserGameStatsSchemaResponse": 60,
"k_EGCMsgGetUserStatsDEPRECATED": 61,
"k_EGCMsgGetUserStatsResponse": 62,
"k_EGCMsgAppInfoUpdated": 63,
"k_EGCMsgValidateSession": 64,
"k_EGCMsgValidateSessionResponse": 65,
"k_EGCMsgLookupAccountFromInput": 66,
"k_EGCMsgSendHTTPRequest": 67,
"k_EGCMsgSendHTTPRequestResponse": 68,
"k_EGCMsgPreTestSetup": 69,
"k_EGCMsgRecordSupportAction": 70,
"k_EGCMsgGetAccountDetails_DEPRECATED": 71,
"k_EGCMsgReceiveInterAppMessage": 73,
"k_EGCMsgFindAccounts": 74,
"k_EGCMsgPostAlert": 75,
"k_EGCMsgGetLicenses": 76,
"k_EGCMsgGetUserStats": 77,
"k_EGCMsgGetCommands": 78,
"k_EGCMsgGetCommandsResponse": 79,
"k_EGCMsgAddFreeLicense": 80,
"k_EGCMsgAddFreeLicenseResponse": 81,
"k_EGCMsgGetIPLocation": 82,
"k_EGCMsgGetIPLocationResponse": 83,
"k_EGCMsgSystemStatsSchema": 84,
"k_EGCMsgGetSystemStats": 85,
"k_EGCMsgGetSystemStatsResponse": 86,
"k_EGCMsgSendEmail": 87,
"k_EGCMsgSendEmailResponse": 88,
"k_EGCMsgGetEmailTemplate": 89,
"k_EGCMsgGetEmailTemplateResponse": 90,
"k_EGCMsgGrantGuestPass": 91,
"k_EGCMsgGrantGuestPassResponse": 92,
"k_EGCMsgGetAccountDetails": 93,
"k_EGCMsgGetAccountDetailsResponse": 94,
"k_EGCMsgGetPersonaNames": 95,
"k_EGCMsgGetPersonaNamesResponse": 96,
"k_EGCMsgMultiplexMsg": 97,
"k_EGCMsgWebAPIRegisterInterfaces": 101,
"k_EGCMsgWebAPIJobRequest": 102,
"k_EGCMsgWebAPIJobRequestHttpResponse": 104,
"k_EGCMsgWebAPIJobRequestForwardResponse": 105,
"k_EGCMsgMemCachedGet": 200,
"k_EGCMsgMemCachedGetResponse": 201,
"k_EGCMsgMemCachedSet": 202,
"k_EGCMsgMemCachedDelete": 203,
"k_EGCMsgMemCachedStats": 204,
"k_EGCMsgMemCachedStatsResponse": 205,
"k_EGCMsgSQLStats": 210,
"k_EGCMsgSQLStatsResponse": 211,
"k_EGCMsgMasterSetDirectory": 220,
"k_EGCMsgMasterSetDirectoryResponse": 221,
"k_EGCMsgMasterSetWebAPIRouting": 222,
"k_EGCMsgMasterSetWebAPIRoutingResponse": 223,
"k_EGCMsgMasterSetClientMsgRouting": 224,
"k_EGCMsgMasterSetClientMsgRoutingResponse": 225,
"k_EGCMsgSetOptions": 226,
"k_EGCMsgSetOptionsResponse": 227,
"k_EGCMsgSystemBase2": 500,
"k_EGCMsgGetPurchaseTrustStatus": 501,
"k_EGCMsgGetPurchaseTrustStatusResponse": 502,
"k_EGCMsgUpdateSession": 503,
"k_EGCMsgGCAccountVacStatusChange": 504,
"k_EGCMsgCheckFriendship": 505,
"k_EGCMsgCheckFriendshipResponse": 506,
"k_EGCMsgGetPartnerAccountLink": 507,
"k_EGCMsgGetPartnerAccountLinkResponse": 508,
"k_EGCMsgVSReportedSuspiciousActivity": 509,
}
func (x EGCSystemMsg) Enum() *EGCSystemMsg {
p := new(EGCSystemMsg)
*p = x
return p
}
func (x EGCSystemMsg) String() string {
return proto.EnumName(EGCSystemMsg_name, int32(x))
}
func (x *EGCSystemMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EGCSystemMsg_value, data, "EGCSystemMsg")
if err != nil {
return err
}
*x = EGCSystemMsg(value)
return nil
}
func (EGCSystemMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{0} }
type ESOMsg int32
const (
ESOMsg_k_ESOMsg_Create ESOMsg = 21
ESOMsg_k_ESOMsg_Update ESOMsg = 22
ESOMsg_k_ESOMsg_Destroy ESOMsg = 23
ESOMsg_k_ESOMsg_CacheSubscribed ESOMsg = 24
ESOMsg_k_ESOMsg_CacheUnsubscribed ESOMsg = 25
ESOMsg_k_ESOMsg_UpdateMultiple ESOMsg = 26
ESOMsg_k_ESOMsg_CacheSubscriptionCheck ESOMsg = 27
ESOMsg_k_ESOMsg_CacheSubscriptionRefresh ESOMsg = 28
ESOMsg_k_ESOMsg_CacheSubscribedUpToDate ESOMsg = 29
)
var ESOMsg_name = map[int32]string{
21: "k_ESOMsg_Create",
22: "k_ESOMsg_Update",
23: "k_ESOMsg_Destroy",
24: "k_ESOMsg_CacheSubscribed",
25: "k_ESOMsg_CacheUnsubscribed",
26: "k_ESOMsg_UpdateMultiple",
27: "k_ESOMsg_CacheSubscriptionCheck",
28: "k_ESOMsg_CacheSubscriptionRefresh",
29: "k_ESOMsg_CacheSubscribedUpToDate",
}
var ESOMsg_value = map[string]int32{
"k_ESOMsg_Create": 21,
"k_ESOMsg_Update": 22,
"k_ESOMsg_Destroy": 23,
"k_ESOMsg_CacheSubscribed": 24,
"k_ESOMsg_CacheUnsubscribed": 25,
"k_ESOMsg_UpdateMultiple": 26,
"k_ESOMsg_CacheSubscriptionCheck": 27,
"k_ESOMsg_CacheSubscriptionRefresh": 28,
"k_ESOMsg_CacheSubscribedUpToDate": 29,
}
func (x ESOMsg) Enum() *ESOMsg {
p := new(ESOMsg)
*p = x
return p
}
func (x ESOMsg) String() string {
return proto.EnumName(ESOMsg_name, int32(x))
}
func (x *ESOMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ESOMsg_value, data, "ESOMsg")
if err != nil {
return err
}
*x = ESOMsg(value)
return nil
}
func (ESOMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{1} }
type EGCBaseClientMsg int32
const (
EGCBaseClientMsg_k_EMsgGCPingRequest EGCBaseClientMsg = 3001
EGCBaseClientMsg_k_EMsgGCPingResponse EGCBaseClientMsg = 3002
EGCBaseClientMsg_k_EMsgGCClientWelcome EGCBaseClientMsg = 4004
EGCBaseClientMsg_k_EMsgGCServerWelcome EGCBaseClientMsg = 4005
EGCBaseClientMsg_k_EMsgGCClientHello EGCBaseClientMsg = 4006
EGCBaseClientMsg_k_EMsgGCServerHello EGCBaseClientMsg = 4007
EGCBaseClientMsg_k_EMsgGCClientGoodbye EGCBaseClientMsg = 4008
EGCBaseClientMsg_k_EMsgGCServerGoodbye EGCBaseClientMsg = 4009
)
var EGCBaseClientMsg_name = map[int32]string{
3001: "k_EMsgGCPingRequest",
3002: "k_EMsgGCPingResponse",
4004: "k_EMsgGCClientWelcome",
4005: "k_EMsgGCServerWelcome",
4006: "k_EMsgGCClientHello",
4007: "k_EMsgGCServerHello",
4008: "k_EMsgGCClientGoodbye",
4009: "k_EMsgGCServerGoodbye",
}
var EGCBaseClientMsg_value = map[string]int32{
"k_EMsgGCPingRequest": 3001,
"k_EMsgGCPingResponse": 3002,
"k_EMsgGCClientWelcome": 4004,
"k_EMsgGCServerWelcome": 4005,
"k_EMsgGCClientHello": 4006,
"k_EMsgGCServerHello": 4007,
"k_EMsgGCClientGoodbye": 4008,
"k_EMsgGCServerGoodbye": 4009,
}
func (x EGCBaseClientMsg) Enum() *EGCBaseClientMsg {
p := new(EGCBaseClientMsg)
*p = x
return p
}
func (x EGCBaseClientMsg) String() string {
return proto.EnumName(EGCBaseClientMsg_name, int32(x))
}
func (x *EGCBaseClientMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EGCBaseClientMsg_value, data, "EGCBaseClientMsg")
if err != nil {
return err
}
*x = EGCBaseClientMsg(value)
return nil
}
func (EGCBaseClientMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{2} }
type EGCToGCMsg int32
const (
EGCToGCMsg_k_EGCToGCMsgMasterAck EGCToGCMsg = 150
EGCToGCMsg_k_EGCToGCMsgMasterAckResponse EGCToGCMsg = 151
EGCToGCMsg_k_EGCToGCMsgRouted EGCToGCMsg = 152
EGCToGCMsg_k_EGCToGCMsgRoutedReply EGCToGCMsg = 153
EGCToGCMsg_k_EMsgGCUpdateSubGCSessionInfo EGCToGCMsg = 154
EGCToGCMsg_k_EMsgGCRequestSubGCSessionInfo EGCToGCMsg = 155
EGCToGCMsg_k_EMsgGCRequestSubGCSessionInfoResponse EGCToGCMsg = 156
EGCToGCMsg_k_EGCToGCMsgMasterStartupComplete EGCToGCMsg = 157
EGCToGCMsg_k_EMsgGCToGCSOCacheSubscribe EGCToGCMsg = 158
EGCToGCMsg_k_EMsgGCToGCSOCacheUnsubscribe EGCToGCMsg = 159
)
var EGCToGCMsg_name = map[int32]string{
150: "k_EGCToGCMsgMasterAck",
151: "k_EGCToGCMsgMasterAckResponse",
152: "k_EGCToGCMsgRouted",
153: "k_EGCToGCMsgRoutedReply",
154: "k_EMsgGCUpdateSubGCSessionInfo",
155: "k_EMsgGCRequestSubGCSessionInfo",
156: "k_EMsgGCRequestSubGCSessionInfoResponse",
157: "k_EGCToGCMsgMasterStartupComplete",
158: "k_EMsgGCToGCSOCacheSubscribe",
159: "k_EMsgGCToGCSOCacheUnsubscribe",
}
var EGCToGCMsg_value = map[string]int32{
"k_EGCToGCMsgMasterAck": 150,
"k_EGCToGCMsgMasterAckResponse": 151,
"k_EGCToGCMsgRouted": 152,
"k_EGCToGCMsgRoutedReply": 153,
"k_EMsgGCUpdateSubGCSessionInfo": 154,
"k_EMsgGCRequestSubGCSessionInfo": 155,
"k_EMsgGCRequestSubGCSessionInfoResponse": 156,
"k_EGCToGCMsgMasterStartupComplete": 157,
"k_EMsgGCToGCSOCacheSubscribe": 158,
"k_EMsgGCToGCSOCacheUnsubscribe": 159,
}
func (x EGCToGCMsg) Enum() *EGCToGCMsg {
p := new(EGCToGCMsg)
*p = x
return p
}
func (x EGCToGCMsg) String() string {
return proto.EnumName(EGCToGCMsg_name, int32(x))
}
func (x *EGCToGCMsg) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EGCToGCMsg_value, data, "EGCToGCMsg")
if err != nil {
return err
}
*x = EGCToGCMsg(value)
return nil
}
func (EGCToGCMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{3} }
func init() {
proto.RegisterEnum("EGCSystemMsg", EGCSystemMsg_name, EGCSystemMsg_value)
proto.RegisterEnum("ESOMsg", ESOMsg_name, ESOMsg_value)
proto.RegisterEnum("EGCBaseClientMsg", EGCBaseClientMsg_name, EGCBaseClientMsg_value)
proto.RegisterEnum("EGCToGCMsg", EGCToGCMsg_name, EGCToGCMsg_value)
}
var system_fileDescriptor0 = []byte{
// 1379 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x57, 0x49, 0x73, 0x1b, 0x45,
0x14, 0xce, 0x44, 0x05, 0x87, 0x2e, 0x28, 0x5e, 0x3a, 0x89, 0xed, 0x24, 0x4e, 0x94, 0x84, 0x2c,
0xc4, 0x50, 0x39, 0x84, 0x7d, 0x47, 0x91, 0x64, 0x59, 0xc1, 0x8e, 0x15, 0x49, 0xb6, 0xd9, 0xcd,
0x78, 0xd4, 0xb6, 0xa6, 0x2c, 0x4d, 0x0f, 0xdd, 0x3d, 0x06, 0xdd, 0xf8, 0x13, 0xac, 0x61, 0xb9,
0xb0, 0xfe, 0x04, 0xf8, 0x05, 0xac, 0x17, 0xb8, 0xb2, 0x73, 0x84, 0x23, 0xfb, 0x52, 0xc5, 0x9b,
0xad, 0xa7, 0x47, 0x8b, 0xb9, 0x8d, 0xfa, 0x7b, 0x7b, 0x7f, 0xef, 0xf5, 0x13, 0xa1, 0x5b, 0x8e,
0x1c, 0x48, 0xc5, 0xfa, 0x7d, 0xb9, 0x25, 0xcf, 0xfb, 0x82, 0x2b, 0x3e, 0x77, 0xf5, 0x00, 0xb9,
0xae, 0x5a, 0x2b, 0xb7, 0xa2, 0xf3, 0x25, 0xb9, 0x45, 0xf7, 0x93, 0x1b, 0xb6, 0xd7, 0xf1, 0x04,
0xbf, 0xeb, 0xde, 0x8e, 0xdd, 0x73, 0x3b, 0xb0, 0x87, 0xee, 0x23, 0xd7, 0xa7, 0x87, 0x4b, 0x41,
0x4f, 0xb9, 0x60, 0xd1, 0x19, 0x72, 0x20, 0x3d, 0xaa, 0x31, 0x8f, 0x09, 0xd7, 0x69, 0x32, 0xbf,
0x37, 0x00, 0x42, 0xa7, 0x08, 0x4d, 0x91, 0xd8, 0xec, 0x45, 0x5b, 0x32, 0xb8, 0x40, 0x8f, 0x91,
0xc3, 0xe9, 0x79, 0xc9, 0xe9, 0xba, 0x6c, 0x87, 0xf5, 0x99, 0xa7, 0x4a, 0xcf, 0xda, 0xa2, 0xc3,
0x3a, 0x70, 0xab, 0xa9, 0x57, 0xe6, 0x5e, 0x99, 0xf7, 0xfb, 0xb6, 0xd7, 0x81, 0xdb, 0x4c, 0x4f,
0x2d, 0x65, 0x0b, 0xd5, 0xe8, 0xd9, 0x03, 0xd7, 0xdb, 0x82, 0xdb, 0xe9, 0x34, 0xd9, 0x9f, 0x21,
0xdc, 0x4f, 0x81, 0x3b, 0xe8, 0x11, 0x32, 0x9d, 0x53, 0xa9, 0xd9, 0x7d, 0x26, 0x99, 0xd8, 0x61,
0x02, 0xee, 0xa4, 0x87, 0xc9, 0x94, 0xa9, 0x65, 0x60, 0x77, 0xd1, 0x83, 0x64, 0x5f, 0x8a, 0xad,
0xd5, 0x9a, 0xec, 0x99, 0x80, 0x49, 0x05, 0x77, 0x9b, 0xa1, 0x85, 0xc7, 0xd2, 0xe7, 0x1e, 0xa6,
0x74, 0x0f, 0x3d, 0x49, 0x8e, 0x65, 0x45, 0x50, 0x2b, 0x68, 0x26, 0xb4, 0x86, 0x2e, 0x95, 0x6c,
0x39, 0x5d, 0xd6, 0xb7, 0xe1, 0x5e, 0x3a, 0x47, 0xce, 0xec, 0x2e, 0xa3, 0xed, 0xdd, 0x37, 0xc6,
0x5e, 0x24, 0x57, 0xa9, 0x36, 0x9a, 0xd5, 0x72, 0xa9, 0x5d, 0xad, 0xc0, 0xfd, 0xf4, 0x38, 0x99,
0x1d, 0x27, 0xa3, 0xad, 0x3c, 0x60, 0x26, 0x58, 0xf2, 0xfd, 0xba, 0xb7, 0xc9, 0x57, 0xfc, 0x8e,
0xad, 0xb0, 0xc8, 0x0f, 0x9a, 0x95, 0x59, 0x0d, 0x2f, 0x17, 0x8f, 0x5b, 0x4c, 0x4a, 0x97, 0x7b,
0xf0, 0x10, 0xbd, 0x91, 0x14, 0x27, 0x80, 0xda, 0x7a, 0xc9, 0x8c, 0x71, 0x91, 0xf3, 0xed, 0xc0,
0x2f, 0x39, 0x0e, 0x0f, 0x3c, 0x35, 0x2f, 0x78, 0xbf, 0xee, 0xf9, 0x81, 0x82, 0x8b, 0xb9, 0xfa,
0x33, 0xaf, 0xb3, 0xd0, 0x6e, 0x37, 0xd2, 0x62, 0x96, 0x4d, 0x2f, 0x43, 0xa0, 0xf6, 0x52, 0x31,
0x2f, 0xbd, 0x21, 0x58, 0x1b, 0xc1, 0x16, 0x53, 0x81, 0x0f, 0x55, 0x5a, 0x24, 0x47, 0x52, 0xa4,
0xc9, 0x1c, 0x2e, 0x3a, 0xad, 0xc0, 0xf7, 0xb9, 0x50, 0x25, 0x47, 0x85, 0x59, 0xcc, 0xd3, 0x9b,
0xc8, 0x29, 0xa3, 0x40, 0x49, 0x74, 0x15, 0xa6, 0x6c, 0xb7, 0x27, 0xd7, 0x8d, 0x52, 0xd6, 0xcc,
0x54, 0xd0, 0x14, 0x73, 0x77, 0x58, 0xdd, 0x53, 0x4c, 0x60, 0xd1, 0x96, 0x30, 0x6d, 0x7b, 0x8b,
0x41, 0xdd, 0x0c, 0x64, 0xde, 0xf5, 0x3a, 0x89, 0x39, 0x09, 0x97, 0x4c, 0xae, 0x34, 0xb8, 0x54,
0xa5, 0x1e, 0x13, 0x0a, 0x1e, 0x36, 0x49, 0x89, 0xee, 0x17, 0x5d, 0x87, 0x61, 0x46, 0x12, 0x16,
0xf3, 0x1d, 0x93, 0x5d, 0x1c, 0x2c, 0x0d, 0xa9, 0x24, 0xcc, 0x97, 0x70, 0xd9, 0xcc, 0xd5, 0x00,
0x74, 0x99, 0x96, 0x73, 0x57, 0xdd, 0xe9, 0xcc, 0x0b, 0xc6, 0x12, 0x87, 0xd0, 0x30, 0xb3, 0xcb,
0x63, 0x5a, 0xff, 0x0a, 0x3d, 0x44, 0x0e, 0x1a, 0x0e, 0xea, 0x8d, 0x45, 0xee, 0xd8, 0x51, 0x19,
0x9b, 0xf4, 0x04, 0x39, 0x3a, 0x16, 0xd2, 0xda, 0x2d, 0x7a, 0x94, 0x1c, 0xca, 0x77, 0xba, 0xc9,
0xfc, 0xb6, 0x19, 0x1c, 0x5a, 0x30, 0x24, 0x60, 0x65, 0x88, 0xe9, 0x06, 0xa6, 0xcd, 0xaf, 0x9a,
0x05, 0x0e, 0x89, 0x52, 0xed, 0xe3, 0x0d, 0xc2, 0x5a, 0xce, 0x6b, 0x7a, 0xac, 0xb5, 0x1e, 0xa1,
0xb3, 0x64, 0xc6, 0xb0, 0x1c, 0xa1, 0x6d, 0xd6, 0xf7, 0x7b, 0x48, 0x66, 0x78, 0x94, 0x9e, 0x22,
0xc7, 0x27, 0xa1, 0xda, 0xc6, 0x63, 0xb9, 0xc8, 0x85, 0xed, 0xa9, 0x5a, 0xc8, 0xce, 0x86, 0x2d,
0x25, 0x3c, 0x9e, 0x8b, 0x3c, 0x87, 0x69, 0xfd, 0x27, 0xcc, 0x10, 0x47, 0x28, 0x08, 0x4f, 0xd2,
0xd3, 0xe4, 0xc4, 0x44, 0x58, 0x5b, 0x79, 0xca, 0xec, 0x22, 0x14, 0x6b, 0x30, 0x21, 0xb9, 0x67,
0x5f, 0x0e, 0xc7, 0x15, 0xac, 0x9b, 0x5d, 0x34, 0x04, 0x6a, 0x0b, 0x4f, 0x9b, 0x94, 0x8b, 0xe6,
0xb6, 0xdf, 0x63, 0xcf, 0xe1, 0x37, 0xd8, 0x66, 0x1d, 0xd6, 0xd8, 0x46, 0xa9, 0x51, 0x6f, 0xb2,
0x2d, 0x17, 0x2f, 0x41, 0x44, 0x1d, 0xb0, 0x69, 0x3b, 0xe8, 0x84, 0x99, 0xb5, 0x8c, 0xa5, 0x2e,
0xf1, 0x8d, 0xb4, 0x91, 0x37, 0xcd, 0x46, 0x1b, 0x46, 0x17, 0x94, 0xf2, 0x75, 0x1c, 0x5d, 0x7a,
0x33, 0x39, 0x3b, 0x49, 0x72, 0x9e, 0x8b, 0xf0, 0x05, 0xd0, 0xc2, 0x2e, 0x72, 0x32, 0x0b, 0x9a,
0xf5, 0xcb, 0x36, 0xd2, 0xa9, 0x83, 0x29, 0xc2, 0x47, 0x16, 0x72, 0x72, 0x76, 0x1c, 0xa4, 0x95,
0x3f, 0xb6, 0xc6, 0x6a, 0xe3, 0xe8, 0x80, 0x4f, 0x2c, 0xcc, 0x66, 0x7a, 0x04, 0xaa, 0xb0, 0x1e,
0x43, 0x62, 0x7c, 0x6a, 0x61, 0xb5, 0xa7, 0x46, 0x15, 0x23, 0xb6, 0x7e, 0x66, 0x61, 0xb5, 0x8f,
0x8d, 0x07, 0xb5, 0xeb, 0xcf, 0x2d, 0xe4, 0x2b, 0x68, 0x62, 0x5e, 0x59, 0x8c, 0x75, 0xbf, 0xb0,
0x90, 0x0c, 0x33, 0xc3, 0xc7, 0x5a, 0xeb, 0x4b, 0x0b, 0x7b, 0x5c, 0x3f, 0x8b, 0x4b, 0x76, 0x78,
0x03, 0x18, 0x6d, 0xc5, 0x15, 0xcc, 0x51, 0x5c, 0x0c, 0xe0, 0x2b, 0x8b, 0x9e, 0x25, 0x27, 0x27,
0x0b, 0x68, 0x4b, 0x5f, 0xe7, 0x83, 0x4c, 0x05, 0x93, 0xcb, 0xe5, 0x81, 0x0a, 0x5f, 0xc6, 0x6f,
0x2c, 0xbc, 0x8a, 0x33, 0xbb, 0x0b, 0x69, 0x8b, 0xdf, 0x5a, 0xf4, 0x4c, 0x46, 0x54, 0x2d, 0x5c,
0xee, 0xb9, 0xf8, 0x6c, 0x87, 0x23, 0x33, 0x31, 0xfa, 0x9d, 0x45, 0xcf, 0x93, 0x73, 0xff, 0x2b,
0xa7, 0xed, 0x7e, 0x6f, 0xe1, 0xc0, 0xcb, 0x56, 0x04, 0xa6, 0x96, 0xfd, 0x70, 0xae, 0x48, 0xf8,
0x21, 0x57, 0x8c, 0x0c, 0xd0, 0x9a, 0x3f, 0x86, 0x6b, 0xc7, 0xfe, 0xd1, 0xe5, 0xe2, 0x02, 0xfc,
0x52, 0x30, 0xb3, 0x0f, 0x1b, 0x22, 0x10, 0x4e, 0x17, 0xa1, 0xb6, 0x08, 0xf0, 0xe9, 0xc0, 0x9a,
0x07, 0x12, 0x7e, 0x2d, 0x98, 0xd9, 0x8f, 0x17, 0xd2, 0xbe, 0x7e, 0x2b, 0xe0, 0x14, 0xd0, 0xc3,
0x31, 0x7e, 0x40, 0xd3, 0x97, 0xf2, 0xf7, 0x02, 0xb6, 0x70, 0x36, 0x47, 0xca, 0x49, 0x07, 0xaf,
0xda, 0x4e, 0x6c, 0xa4, 0xdc, 0xb5, 0x3d, 0x7c, 0x3c, 0xfe, 0x28, 0x98, 0x94, 0x2b, 0x77, 0x99,
0xb3, 0x3d, 0x2f, 0xb0, 0x28, 0x1d, 0xd9, 0x75, 0x7d, 0xf8, 0xb3, 0x80, 0x4d, 0x58, 0x9c, 0x80,
0xea, 0x30, 0xfe, 0x2a, 0xe0, 0xc0, 0x31, 0x07, 0x71, 0x03, 0xd7, 0x19, 0x5c, 0xb7, 0x12, 0x97,
0x8b, 0xae, 0xb7, 0x0d, 0x7f, 0x17, 0x70, 0xc9, 0x38, 0xbd, 0xab, 0x8c, 0xb6, 0xf7, 0x4f, 0x81,
0x9e, 0xcb, 0xda, 0x76, 0xb5, 0x85, 0x4b, 0x1b, 0xbe, 0x9d, 0x48, 0xe6, 0x40, 0xfa, 0xae, 0xe3,
0xf2, 0x40, 0x86, 0xef, 0xe8, 0x8e, 0xab, 0x06, 0xf0, 0x6f, 0x61, 0xee, 0x85, 0xbd, 0xe4, 0xda,
0x6a, 0x6b, 0x39, 0xdb, 0x0b, 0xa3, 0xef, 0xf5, 0xb2, 0x60, 0xe1, 0x34, 0x3d, 0x98, 0x3b, 0x8c,
0x4b, 0x04, 0x53, 0xf4, 0x40, 0xd4, 0x06, 0xf1, 0x61, 0x05, 0x3b, 0x5c, 0xf0, 0x01, 0x4c, 0x27,
0xa3, 0x24, 0xd1, 0x0f, 0xfb, 0xa7, 0x15, 0x6c, 0x48, 0x47, 0xb8, 0x1b, 0xb8, 0x96, 0xcc, 0x24,
0xbb, 0xa1, 0x81, 0xae, 0x78, 0x32, 0xc3, 0x0f, 0x25, 0xa3, 0xd0, 0x74, 0x94, 0xce, 0x33, 0x38,
0x9c, 0x8c, 0xc2, 0x51, 0xd3, 0x11, 0x7b, 0xa2, 0xc2, 0xc2, 0x91, 0x64, 0xe6, 0x4e, 0x10, 0x6a,
0xb2, 0x4d, 0xc1, 0x64, 0x17, 0x66, 0x93, 0xb9, 0x38, 0x36, 0xcc, 0x15, 0xbf, 0xcd, 0x2b, 0x61,
0x8a, 0x47, 0xe7, 0x7e, 0xb2, 0x08, 0x60, 0x05, 0x43, 0xee, 0x69, 0x9a, 0x27, 0xd4, 0x8c, 0x08,
0xd1, 0x88, 0xf8, 0x1e, 0xcf, 0xc9, 0x0f, 0xa6, 0x93, 0x99, 0x64, 0x20, 0xc9, 0x65, 0x7c, 0x38,
0x9d, 0x70, 0x2c, 0x82, 0x62, 0x4b, 0x6b, 0xac, 0xe7, 0xf0, 0x3e, 0x83, 0xb7, 0x8a, 0x26, 0xd6,
0x8a, 0x16, 0xd4, 0x14, 0x7b, 0xbb, 0x68, 0x3a, 0x8b, 0xf5, 0x16, 0x58, 0xaf, 0xc7, 0xe1, 0x9d,
0x1c, 0x12, 0x6b, 0xc5, 0xc8, 0xbb, 0xc5, 0x51, 0x5f, 0x35, 0xce, 0x3b, 0x1b, 0x03, 0x06, 0xef,
0x8d, 0xf1, 0x95, 0x62, 0xef, 0x17, 0xe7, 0x7e, 0xde, 0x4b, 0x08, 0x66, 0xdb, 0xe6, 0x11, 0x67,
0x74, 0x5b, 0x24, 0xbf, 0xe3, 0x86, 0x2f, 0x61, 0x91, 0x5f, 0xb4, 0x34, 0x57, 0x87, 0x31, 0x9d,
0xf2, 0x4b, 0x59, 0xf3, 0x27, 0x32, 0xe1, 0x78, 0xc0, 0x3b, 0x7e, 0x39, 0x9b, 0xcf, 0x39, 0x20,
0xfe, 0x57, 0xf1, 0x4a, 0x3a, 0xdd, 0xa2, 0x08, 0x93, 0x6e, 0x0c, 0x36, 0xc2, 0x60, 0xa3, 0x96,
0x0c, 0x97, 0x5c, 0x78, 0xd5, 0x4a, 0x3a, 0x2a, 0x12, 0x4a, 0xea, 0x3f, 0x22, 0x75, 0xd5, 0xa2,
0xb7, 0x44, 0xcf, 0xd1, 0x6e, 0x52, 0x3a, 0xde, 0xd7, 0xb2, 0x21, 0x98, 0xcb, 0x29, 0xfa, 0x5b,
0x11, 0xf8, 0xb8, 0x92, 0xf9, 0xd1, 0x03, 0xf2, 0x7a, 0xfa, 0x38, 0x45, 0x56, 0x43, 0xd1, 0xd6,
0x72, 0x9e, 0x3f, 0xf0, 0x46, 0x2e, 0x07, 0x43, 0xc4, 0xe0, 0x3a, 0xbc, 0x69, 0x5d, 0xbc, 0x66,
0xc1, 0x7a, 0xde, 0xda, 0xf3, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfc, 0xd8, 0x05, 0xd1, 0xae,
0x0d, 0x00, 0x00,
}

File diff suppressed because it is too large Load Diff

75
vendor/github.com/Philipp15b/go-steam/tf2/tf2.go generated vendored Normal file
View File

@ -0,0 +1,75 @@
/*
Provides access to TF2 Game Coordinator functionality.
*/
package tf2
import (
"github.com/Philipp15b/go-steam"
. "github.com/Philipp15b/go-steam/protocol/gamecoordinator"
. "github.com/Philipp15b/go-steam/tf2/protocol"
"github.com/Philipp15b/go-steam/tf2/protocol/protobuf"
)
const AppId = 440
// To use any methods of this, you'll need to SetPlaying(true) and wait for
// the GCReadyEvent.
type TF2 struct {
client *steam.Client
}
// Creates a new TF2 instance and registers it as a packet handler
func New(client *steam.Client) *TF2 {
t := &TF2{client}
client.GC.RegisterPacketHandler(t)
return t
}
func (t *TF2) SetPlaying(playing bool) {
if playing {
t.client.GC.SetGamesPlayed(AppId)
} else {
t.client.GC.SetGamesPlayed()
}
}
func (t *TF2) SetItemPosition(itemId, position uint64) {
t.client.GC.Write(NewGCMsg(AppId, uint32(protobuf.EGCItemMsg_k_EMsgGCSetSingleItemPosition), &MsgGCSetItemPosition{
itemId, position,
}))
}
// recipe -2 = wildcard
func (t *TF2) CraftItems(items []uint64, recipe int16) {
t.client.GC.Write(NewGCMsg(AppId, uint32(protobuf.EGCItemMsg_k_EMsgGCCraft), &MsgGCCraft{
Recipe: recipe,
Items: items,
}))
}
func (t *TF2) DeleteItem(itemId uint64) {
t.client.GC.Write(NewGCMsg(AppId, uint32(protobuf.EGCItemMsg_k_EMsgGCDelete), &MsgGCDeleteItem{itemId}))
}
func (t *TF2) NameItem(toolId, target uint64, name string) {
t.client.GC.Write(NewGCMsg(AppId, uint32(protobuf.EGCItemMsg_k_EMsgGCNameItem), &MsgGCNameItem{
toolId, target, name,
}))
}
type GCReadyEvent struct{}
func (t *TF2) HandleGCPacket(packet *GCPacket) {
if packet.AppId != AppId {
return
}
switch protobuf.EGCBaseClientMsg(packet.MsgType) {
case protobuf.EGCBaseClientMsg_k_EMsgGCClientWelcome:
t.handleWelcome(packet)
}
}
func (t *TF2) handleWelcome(packet *GCPacket) {
// the packet's body is pretty useless
t.client.Emit(&GCReadyEvent{})
}

84
vendor/github.com/Philipp15b/go-steam/trade/actions.go generated vendored Normal file
View File

@ -0,0 +1,84 @@
package trade
import (
"github.com/Philipp15b/go-steam/economy/inventory"
"github.com/Philipp15b/go-steam/trade/tradeapi"
"time"
)
type Slot uint
func (t *Trade) action(status *tradeapi.Status, err error) error {
if err != nil {
return err
}
t.onStatus(status)
return nil
}
// Returns the next batch of events to process. These can be queued from calls to methods
// like `AddItem` or, if there are no queued events, from a new HTTP request to Steam's API (blocking!).
// If the latter is the case, this method may also sleep before the request
// to conform to the polling interval of the official Steam client.
func (t *Trade) Poll() ([]interface{}, error) {
if t.queuedEvents != nil {
return t.Events(), nil
}
if d := time.Since(t.lastPoll); d < pollTimeout {
time.Sleep(pollTimeout - d)
}
t.lastPoll = time.Now()
err := t.action(t.api.GetStatus())
if err != nil {
return nil, err
}
return t.Events(), nil
}
func (t *Trade) GetTheirInventory(contextId uint64, appId uint32) (*inventory.Inventory, error) {
return inventory.GetFullInventory(func() (*inventory.PartialInventory, error) {
return t.api.GetForeignInventory(contextId, appId, nil)
}, func(start uint) (*inventory.PartialInventory, error) {
return t.api.GetForeignInventory(contextId, appId, &start)
})
}
func (t *Trade) GetOwnInventory(contextId uint64, appId uint32) (*inventory.Inventory, error) {
return t.api.GetOwnInventory(contextId, appId)
}
func (t *Trade) GetMain() (*tradeapi.Main, error) {
return t.api.GetMain()
}
func (t *Trade) AddItem(slot Slot, item *Item) error {
return t.action(t.api.AddItem(uint(slot), item.AssetId, item.ContextId, item.AppId))
}
func (t *Trade) RemoveItem(slot Slot, item *Item) error {
return t.action(t.api.RemoveItem(uint(slot), item.AssetId, item.ContextId, item.AppId))
}
func (t *Trade) Chat(message string) error {
return t.action(t.api.Chat(message))
}
func (t *Trade) SetCurrency(amount uint, currency *Currency) error {
return t.action(t.api.SetCurrency(amount, currency.CurrencyId, currency.ContextId, currency.AppId))
}
func (t *Trade) SetReady(ready bool) error {
return t.action(t.api.SetReady(ready))
}
// This may only be called after a successful `SetReady(true)`.
func (t *Trade) Confirm() error {
return t.action(t.api.Confirm())
}
func (t *Trade) Cancel() error {
return t.action(t.api.Cancel())
}

40
vendor/github.com/Philipp15b/go-steam/trade/doc.go generated vendored Normal file
View File

@ -0,0 +1,40 @@
/*
Allows automation of Steam Trading.
Usage
Like go-steam, this package is event-based. Call Poll() until the trade has ended, that is until the TradeEndedEvent is emitted.
// After receiving the steam.TradeSessionStartEvent
t := trade.New(sessionIdCookie, steamLoginCookie, steamLoginSecure, event.Other)
for {
eventList, err := t.Poll()
if err != nil {
// error handling here
continue
}
for _, event := range eventList {
switch e := event.(type) {
case *trade.ChatEvent:
// respond to any chat message
t.Chat("Trading is awesome!")
case *trade.TradeEndedEvent:
return
// other event handlers here
}
}
}
You can either log into steamcommunity.com and use the values of the `sessionId` and `steamLogin` cookies,
or use go-steam and after logging in with client.Web.LogOn() and receiving the WebLoggedOnEvent use the `SessionId`
and `SteamLogin` fields of steam.Web for the respective cookies.
It is important that there is no delay between the Poll() calls greater than the timeout of the Steam client
(currently five seconds before the trade partner sees a warning) or the trade will be closed automatically by Steam.
Notes
All method calls to Steam APIs are blocking. This packages' and its subpackages' types are not thread-safe and no calls to any method of the same
trade instance may be done concurrently except when otherwise noted.
*/
package trade

122
vendor/github.com/Philipp15b/go-steam/trade/trade.go generated vendored Normal file
View File

@ -0,0 +1,122 @@
package trade
import (
"errors"
"time"
"github.com/Philipp15b/go-steam/steamid"
"github.com/Philipp15b/go-steam/trade/tradeapi"
)
const pollTimeout = time.Second
type Trade struct {
ThemId steamid.SteamId
MeReady, ThemReady bool
lastPoll time.Time
queuedEvents []interface{}
api *tradeapi.Trade
}
func New(sessionId, steamLogin, steamLoginSecure string, other steamid.SteamId) *Trade {
return &Trade{
other,
false, false,
time.Unix(0, 0),
nil,
tradeapi.New(sessionId, steamLogin, steamLoginSecure, other),
}
}
func (t *Trade) Version() uint {
return t.api.Version
}
// Returns all queued events and removes them from the queue without performing a HTTP request, like Poll() would.
func (t *Trade) Events() []interface{} {
qe := t.queuedEvents
t.queuedEvents = nil
return qe
}
func (t *Trade) onStatus(status *tradeapi.Status) error {
if !status.Success {
return errors.New("trade: returned status not successful! error message: " + status.Error)
}
if status.NewVersion {
t.api.Version = status.Version
t.MeReady = status.Me.Ready == true
t.ThemReady = status.Them.Ready == true
}
switch status.TradeStatus {
case tradeapi.TradeStatus_Complete:
t.addEvent(&TradeEndedEvent{TradeEndReason_Complete})
case tradeapi.TradeStatus_Cancelled:
t.addEvent(&TradeEndedEvent{TradeEndReason_Cancelled})
case tradeapi.TradeStatus_Timeout:
t.addEvent(&TradeEndedEvent{TradeEndReason_Timeout})
case tradeapi.TradeStatus_Failed:
t.addEvent(&TradeEndedEvent{TradeEndReason_Failed})
case tradeapi.TradeStatus_Open:
// nothing
default:
// ignore too
}
t.updateEvents(status.Events)
return nil
}
func (t *Trade) updateEvents(events tradeapi.EventList) {
if len(events) == 0 {
return
}
var lastLogPos uint
for i, event := range events {
if i < t.api.LogPos {
continue
}
if event.SteamId != t.ThemId {
continue
}
if lastLogPos < i {
lastLogPos = i
}
switch event.Action {
case tradeapi.Action_AddItem:
t.addEvent(&ItemAddedEvent{newItem(event)})
case tradeapi.Action_RemoveItem:
t.addEvent(&ItemRemovedEvent{newItem(event)})
case tradeapi.Action_Ready:
t.ThemReady = true
t.addEvent(new(ReadyEvent))
case tradeapi.Action_Unready:
t.ThemReady = false
t.addEvent(new(UnreadyEvent))
case tradeapi.Action_SetCurrency:
t.addEvent(&SetCurrencyEvent{
newCurrency(event),
event.OldAmount,
event.NewAmount,
})
case tradeapi.Action_ChatMessage:
t.addEvent(&ChatEvent{
event.Text,
})
}
}
t.api.LogPos = uint(lastLogPos) + 1
}
func (t *Trade) addEvent(event interface{}) {
t.queuedEvents = append(t.queuedEvents, event)
}

View File

@ -0,0 +1,111 @@
package tradeapi
import (
"encoding/json"
"github.com/Philipp15b/go-steam/jsont"
"github.com/Philipp15b/go-steam/steamid"
"strconv"
)
type Status struct {
Success bool
Error string
NewVersion bool `json:"newversion"`
TradeStatus TradeStatus `json:"trade_status"`
Version uint
LogPos int
Me User
Them User
Events EventList
}
type TradeStatus uint
const (
TradeStatus_Open TradeStatus = 0
TradeStatus_Complete = 1
TradeStatus_Empty = 2 // when both parties trade no items
TradeStatus_Cancelled = 3
TradeStatus_Timeout = 4 // the partner timed out
TradeStatus_Failed = 5
)
type EventList map[uint]*Event
// The EventList can either be an array or an object of id -> event
func (e *EventList) UnmarshalJSON(data []byte) error {
// initialize the map if it's nil
if *e == nil {
*e = make(EventList)
}
o := make(map[string]*Event)
err := json.Unmarshal(data, &o)
// it's an object
if err == nil {
for is, event := range o {
i, err := strconv.ParseUint(is, 10, 32)
if err != nil {
panic(err)
}
(*e)[uint(i)] = event
}
return nil
}
// it's an array
var a []*Event
err = json.Unmarshal(data, &a)
if err != nil {
return err
}
for i, event := range a {
(*e)[uint(i)] = event
}
return nil
}
type Event struct {
SteamId steamid.SteamId `json:",string"`
Action Action `json:",string"`
Timestamp uint64
AppId uint32
ContextId uint64 `json:",string"`
AssetId uint64 `json:",string"`
Text string // only used for chat messages
// The following is used for SetCurrency
CurrencyId uint64 `json:",string"`
OldAmount uint64 `json:"old_amount,string"`
NewAmount uint64 `json:"amount,string"`
}
type Action uint
const (
Action_AddItem Action = 0
Action_RemoveItem = 1
Action_Ready = 2
Action_Unready = 3
Action_Accept = 4
Action_SetCurrency = 6
Action_ChatMessage = 7
)
type User struct {
Ready jsont.UintBool
Confirmed jsont.UintBool
SecSinceTouch int `json:"sec_since_touch"`
ConnectionPending bool `json:"connection_pending"`
Assets interface{}
Currency interface{} // either []*Currency or empty string
}
type Currency struct {
AppId uint64 `json:",string"`
ContextId uint64 `json:",string"`
CurrencyId uint64 `json:",string"`
Amount uint64 `json:",string"`
}

View File

@ -0,0 +1,200 @@
/*
Wrapper around the HTTP trading API for type safety 'n' stuff.
*/
package tradeapi
import (
"encoding/json"
"errors"
"fmt"
"github.com/Philipp15b/go-steam/community"
"github.com/Philipp15b/go-steam/economy/inventory"
"github.com/Philipp15b/go-steam/netutil"
"github.com/Philipp15b/go-steam/steamid"
"io/ioutil"
"net/http"
"regexp"
"strconv"
"time"
)
const tradeUrl = "https://steamcommunity.com/trade/%d/"
type Trade struct {
client *http.Client
other steamid.SteamId
LogPos uint // not automatically updated
Version uint // Incremented for each item change by Steam; not automatically updated.
// the `sessionid` cookie is sent as a parameter/POST data for CSRF protection.
sessionId string
baseUrl string
}
// Creates a new Trade based on the given cookies `sessionid`, `steamLogin`, `steamLoginSecure` and the trade partner's Steam ID.
func New(sessionId, steamLogin, steamLoginSecure string, other steamid.SteamId) *Trade {
client := new(http.Client)
client.Timeout = 10 * time.Second
t := &Trade{
client: client,
other: other,
sessionId: sessionId,
baseUrl: fmt.Sprintf(tradeUrl, other),
Version: 1,
}
community.SetCookies(t.client, sessionId, steamLogin, steamLoginSecure)
return t
}
type Main struct {
PartnerOnProbation bool
}
var onProbationRegex = regexp.MustCompile(`var g_bTradePartnerProbation = (\w+);`)
// Fetches the main HTML page and parses it. Thread-safe.
func (t *Trade) GetMain() (*Main, error) {
resp, err := t.client.Get(t.baseUrl)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
match := onProbationRegex.FindSubmatch(body)
if len(match) == 0 {
return nil, errors.New("tradeapi.GetMain: Could not find probation info")
}
return &Main{
string(match[1]) == "true",
}, nil
}
// Ajax POSTs to an API endpoint that should return a status
func (t *Trade) postWithStatus(url string, data map[string]string) (*Status, error) {
status := new(Status)
req := netutil.NewPostForm(url, netutil.ToUrlValues(data))
// Tales of Madness and Pain, Episode 1: If you forget this, Steam will return an error
// saying "missing required parameter", even though they are all there. IT WAS JUST THE HEADER, ARGH!
req.Header.Add("Referer", t.baseUrl)
resp, err := t.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
err = json.NewDecoder(resp.Body).Decode(status)
if err != nil {
return nil, err
}
return status, nil
}
func (t *Trade) GetStatus() (*Status, error) {
return t.postWithStatus(t.baseUrl+"tradestatus/", map[string]string{
"sessionid": t.sessionId,
"logpos": strconv.FormatUint(uint64(t.LogPos), 10),
"version": strconv.FormatUint(uint64(t.Version), 10),
})
}
// Thread-safe.
func (t *Trade) GetForeignInventory(contextId uint64, appId uint32, start *uint) (*inventory.PartialInventory, error) {
data := map[string]string{
"sessionid": t.sessionId,
"steamid": fmt.Sprintf("%d", t.other),
"contextid": strconv.FormatUint(contextId, 10),
"appid": strconv.FormatUint(uint64(appId), 10),
}
if start != nil {
data["start"] = strconv.FormatUint(uint64(*start), 10)
}
req, err := http.NewRequest("GET", t.baseUrl+"foreigninventory?"+netutil.ToUrlValues(data).Encode(), nil)
if err != nil {
panic(err)
}
req.Header.Add("Referer", t.baseUrl)
return inventory.DoInventoryRequest(t.client, req)
}
// Thread-safe.
func (t *Trade) GetOwnInventory(contextId uint64, appId uint32) (*inventory.Inventory, error) {
return inventory.GetOwnInventory(t.client, contextId, appId)
}
func (t *Trade) Chat(message string) (*Status, error) {
return t.postWithStatus(t.baseUrl+"chat", map[string]string{
"sessionid": t.sessionId,
"logpos": strconv.FormatUint(uint64(t.LogPos), 10),
"version": strconv.FormatUint(uint64(t.Version), 10),
"message": message,
})
}
func (t *Trade) AddItem(slot uint, itemId, contextId uint64, appId uint32) (*Status, error) {
return t.postWithStatus(t.baseUrl+"additem", map[string]string{
"sessionid": t.sessionId,
"slot": strconv.FormatUint(uint64(slot), 10),
"itemid": strconv.FormatUint(itemId, 10),
"contextid": strconv.FormatUint(contextId, 10),
"appid": strconv.FormatUint(uint64(appId), 10),
})
}
func (t *Trade) RemoveItem(slot uint, itemId, contextId uint64, appId uint32) (*Status, error) {
return t.postWithStatus(t.baseUrl+"removeitem", map[string]string{
"sessionid": t.sessionId,
"slot": strconv.FormatUint(uint64(slot), 10),
"itemid": strconv.FormatUint(itemId, 10),
"contextid": strconv.FormatUint(contextId, 10),
"appid": strconv.FormatUint(uint64(appId), 10),
})
}
func (t *Trade) SetCurrency(amount uint, currencyId, contextId uint64, appId uint32) (*Status, error) {
return t.postWithStatus(t.baseUrl+"setcurrency", map[string]string{
"sessionid": t.sessionId,
"amount": strconv.FormatUint(uint64(amount), 10),
"currencyid": strconv.FormatUint(uint64(currencyId), 10),
"contextid": strconv.FormatUint(contextId, 10),
"appid": strconv.FormatUint(uint64(appId), 10),
})
}
func (t *Trade) SetReady(ready bool) (*Status, error) {
return t.postWithStatus(t.baseUrl+"toggleready", map[string]string{
"sessionid": t.sessionId,
"version": strconv.FormatUint(uint64(t.Version), 10),
"ready": fmt.Sprint(ready),
})
}
func (t *Trade) Confirm() (*Status, error) {
return t.postWithStatus(t.baseUrl+"confirm", map[string]string{
"sessionid": t.sessionId,
"version": strconv.FormatUint(uint64(t.Version), 10),
})
}
func (t *Trade) Cancel() (*Status, error) {
return t.postWithStatus(t.baseUrl+"cancel", map[string]string{
"sessionid": t.sessionId,
})
}
func isSuccess(v interface{}) bool {
if m, ok := v.(map[string]interface{}); ok {
return m["success"] == true
}
return false
}

67
vendor/github.com/Philipp15b/go-steam/trade/types.go generated vendored Normal file
View File

@ -0,0 +1,67 @@
package trade
import (
"github.com/Philipp15b/go-steam/trade/tradeapi"
)
type TradeEndedEvent struct {
Reason TradeEndReason
}
type TradeEndReason uint
const (
TradeEndReason_Complete TradeEndReason = 1
TradeEndReason_Cancelled = 2
TradeEndReason_Timeout = 3
TradeEndReason_Failed = 4
)
func newItem(event *tradeapi.Event) *Item {
return &Item{
event.AppId,
event.ContextId,
event.AssetId,
}
}
type Item struct {
AppId uint32
ContextId uint64
AssetId uint64
}
type ItemAddedEvent struct {
Item *Item
}
type ItemRemovedEvent struct {
Item *Item
}
type ReadyEvent struct{}
type UnreadyEvent struct{}
func newCurrency(event *tradeapi.Event) *Currency {
return &Currency{
event.AppId,
event.ContextId,
event.CurrencyId,
}
}
type Currency struct {
AppId uint32
ContextId uint64
CurrencyId uint64
}
type SetCurrencyEvent struct {
Currency *Currency
OldAmount uint64
NewAmount uint64
}
type ChatEvent struct {
Message string
}

View File

@ -0,0 +1,452 @@
package tradeoffer
import (
"encoding/json"
"fmt"
"github.com/Philipp15b/go-steam/community"
"github.com/Philipp15b/go-steam/economy/inventory"
"github.com/Philipp15b/go-steam/netutil"
"github.com/Philipp15b/go-steam/steamid"
"io/ioutil"
"net/http"
"strconv"
"time"
)
type APIKey string
const apiUrl = "https://api.steampowered.com/IEconService/%s/v%d"
type Client struct {
client *http.Client
key APIKey
sessionId string
}
func NewClient(key APIKey, sessionId, steamLogin, steamLoginSecure string) *Client {
c := &Client{
new(http.Client),
key,
sessionId,
}
community.SetCookies(c.client, sessionId, steamLogin, steamLoginSecure)
return c
}
func (c *Client) GetOffer(offerId uint64) (*TradeOfferResult, error) {
resp, err := c.client.Get(fmt.Sprintf(apiUrl, "GetTradeOffer", 1) + "?" + netutil.ToUrlValues(map[string]string{
"key": string(c.key),
"tradeofferid": strconv.FormatUint(offerId, 10),
"language": "en_us",
}).Encode())
if err != nil {
return nil, err
}
defer resp.Body.Close()
t := new(struct {
Response *TradeOfferResult
})
if err = json.NewDecoder(resp.Body).Decode(t); err != nil {
return nil, err
}
if t.Response == nil || t.Response.Offer == nil {
return nil, newSteamErrorf("steam returned empty offer result\n")
}
return t.Response, nil
}
func (c *Client) GetOffers(getSent bool, getReceived bool, getDescriptions bool, activeOnly bool, historicalOnly bool, timeHistoricalCutoff *uint32) (*TradeOffersResult, error) {
if !getSent && !getReceived {
return nil, fmt.Errorf("getSent and getReceived can't be both false\n")
}
params := map[string]string{
"key": string(c.key),
}
if getSent {
params["get_sent_offers"] = "1"
}
if getReceived {
params["get_received_offers"] = "1"
}
if getDescriptions {
params["get_descriptions"] = "1"
params["language"] = "en_us"
}
if activeOnly {
params["active_only"] = "1"
}
if historicalOnly {
params["historical_only"] = "1"
}
if timeHistoricalCutoff != nil {
params["time_historical_cutoff"] = strconv.FormatUint(uint64(*timeHistoricalCutoff), 10)
}
resp, err := c.client.Get(fmt.Sprintf(apiUrl, "GetTradeOffers", 1) + "?" + netutil.ToUrlValues(params).Encode())
if err != nil {
return nil, err
}
defer resp.Body.Close()
t := new(struct {
Response *TradeOffersResult
})
if err = json.NewDecoder(resp.Body).Decode(t); err != nil {
return nil, err
}
if t.Response == nil {
return nil, newSteamErrorf("steam returned empty offers result\n")
}
return t.Response, nil
}
// action() is used by Decline() and Cancel()
// Steam only return success and error fields for malformed requests,
// hence client shall use GetOffer() to check action result
// It is also possible to implement Decline/Cancel using steamcommunity,
// which have more predictable responses
func (c *Client) action(method string, version uint, offerId uint64) error {
resp, err := c.client.Do(netutil.NewPostForm(fmt.Sprintf(apiUrl, method, version), netutil.ToUrlValues(map[string]string{
"key": string(c.key),
"tradeofferid": strconv.FormatUint(offerId, 10),
})))
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return fmt.Errorf(method+" error: status code %d", resp.StatusCode)
}
return nil
}
func (c *Client) Decline(offerId uint64) error {
return c.action("DeclineTradeOffer", 1, offerId)
}
func (c *Client) Cancel(offerId uint64) error {
return c.action("CancelTradeOffer", 1, offerId)
}
// Accept received trade offer
// It is best to confirm that offer was actually accepted
// by calling GetOffer after Accept and checking offer state
func (c *Client) Accept(offerId uint64) error {
baseurl := fmt.Sprintf("https://steamcommunity.com/tradeoffer/%d/", offerId)
req := netutil.NewPostForm(baseurl+"accept", netutil.ToUrlValues(map[string]string{
"sessionid": c.sessionId,
"serverid": "1",
"tradeofferid": strconv.FormatUint(offerId, 10),
}))
req.Header.Add("Referer", baseurl)
resp, err := c.client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
t := new(struct {
StrError string `json:"strError"`
})
if err = json.NewDecoder(resp.Body).Decode(t); err != nil {
return err
}
if t.StrError != "" {
return newSteamErrorf("accept error: %v\n", t.StrError)
}
if resp.StatusCode != 200 {
return fmt.Errorf("accept error: status code %d", resp.StatusCode)
}
return nil
}
type TradeItem struct {
AppId uint32 `json:"appid"`
ContextId uint64 `json:"contextid,string"`
Amount uint64 `json:"amount"`
AssetId uint64 `json:"assetid,string,omitempty"`
CurrencyId uint64 `json:"currencyid,string,omitempty"`
}
// Sends a new trade offer to the given Steam user. You can optionally specify an access token if you've got one.
// In addition, `counteredOfferId` can be non-nil, indicating the trade offer this is a counter for.
// On success returns trade offer id
func (c *Client) Create(other steamid.SteamId, accessToken *string, myItems, theirItems []TradeItem, counteredOfferId *uint64, message string) (uint64, error) {
// Create new trade offer status
to := map[string]interface{}{
"newversion": true,
"version": 3,
"me": map[string]interface{}{
"assets": myItems,
"currency": make([]struct{}, 0),
"ready": false,
},
"them": map[string]interface{}{
"assets": theirItems,
"currency": make([]struct{}, 0),
"ready": false,
},
}
jto, err := json.Marshal(to)
if err != nil {
panic(err)
}
// Create url parameters for request
data := map[string]string{
"sessionid": c.sessionId,
"serverid": "1",
"partner": other.ToString(),
"tradeoffermessage": message,
"json_tradeoffer": string(jto),
}
var referer string
if counteredOfferId != nil {
referer = fmt.Sprintf("https://steamcommunity.com/tradeoffer/%d/", *counteredOfferId)
data["tradeofferid_countered"] = strconv.FormatUint(*counteredOfferId, 10)
} else {
// Add token for non-friend offers
if accessToken != nil {
params := map[string]string{
"trade_offer_access_token": *accessToken,
}
paramsJson, err := json.Marshal(params)
if err != nil {
panic(err)
}
data["trade_offer_create_params"] = string(paramsJson)
referer = "https://steamcommunity.com/tradeoffer/new/?partner=" + strconv.FormatUint(uint64(other.GetAccountId()), 10) + "&token=" + *accessToken
} else {
referer = "https://steamcommunity.com/tradeoffer/new/?partner=" + strconv.FormatUint(uint64(other.GetAccountId()), 10)
}
}
// Create request
req := netutil.NewPostForm("https://steamcommunity.com/tradeoffer/new/send", netutil.ToUrlValues(data))
req.Header.Add("Referer", referer)
// Send request
resp, err := c.client.Do(req)
if err != nil {
return 0, err
}
defer resp.Body.Close()
t := new(struct {
StrError string `json:"strError"`
TradeOfferId uint64 `json:"tradeofferid,string"`
})
if err = json.NewDecoder(resp.Body).Decode(t); err != nil {
return 0, err
}
// strError code descriptions:
// 15 invalide trade access token
// 16 timeout
// 20 wrong contextid
// 25 can't send more offers until some is accepted/cancelled...
// 26 object is not in our inventory
// error code names are in internal/steamlang/enums.go EResult_name
if t.StrError != "" {
return 0, newSteamErrorf("create error: %v\n", t.StrError)
}
if resp.StatusCode != 200 {
return 0, fmt.Errorf("create error: status code %d", resp.StatusCode)
}
if t.TradeOfferId == 0 {
return 0, newSteamErrorf("create error: steam returned 0 for trade offer id")
}
return t.TradeOfferId, nil
}
func (c *Client) GetOwnInventory(contextId uint64, appId uint32) (*inventory.Inventory, error) {
return inventory.GetOwnInventory(c.client, contextId, appId)
}
func (c *Client) GetPartnerInventory(other steamid.SteamId, contextId uint64, appId uint32, offerId *uint64) (*inventory.Inventory, error) {
return inventory.GetFullInventory(func() (*inventory.PartialInventory, error) {
return c.getPartialPartnerInventory(other, contextId, appId, offerId, nil)
}, func(start uint) (*inventory.PartialInventory, error) {
return c.getPartialPartnerInventory(other, contextId, appId, offerId, &start)
})
}
func (c *Client) getPartialPartnerInventory(other steamid.SteamId, contextId uint64, appId uint32, offerId *uint64, start *uint) (*inventory.PartialInventory, error) {
data := map[string]string{
"sessionid": c.sessionId,
"partner": other.ToString(),
"contextid": strconv.FormatUint(contextId, 10),
"appid": strconv.FormatUint(uint64(appId), 10),
}
if start != nil {
data["start"] = strconv.FormatUint(uint64(*start), 10)
}
baseUrl := "https://steamcommunity.com/tradeoffer/%v/"
if offerId != nil {
baseUrl = fmt.Sprintf(baseUrl, *offerId)
} else {
baseUrl = fmt.Sprintf(baseUrl, "new")
}
req, err := http.NewRequest("GET", baseUrl+"partnerinventory/?"+netutil.ToUrlValues(data).Encode(), nil)
if err != nil {
panic(err)
}
req.Header.Add("Referer", baseUrl+"?partner="+strconv.FormatUint(uint64(other.GetAccountId()), 10))
return inventory.DoInventoryRequest(c.client, req)
}
// Can be used to verify accepted tradeoffer and find out received asset ids
func (c *Client) GetTradeReceipt(tradeId uint64) ([]*TradeReceiptItem, error) {
url := fmt.Sprintf("https://steamcommunity.com/trade/%d/receipt", tradeId)
resp, err := c.client.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
items, err := parseTradeReceipt(respBody)
if err != nil {
return nil, newSteamErrorf("failed to parse trade receipt: %v", err)
}
return items, nil
}
// Get duration of escrow in days. Call this before sending a trade offer
func (c *Client) GetPartnerEscrowDuration(other steamid.SteamId, accessToken *string) (*EscrowDuration, error) {
data := map[string]string{
"partner": strconv.FormatUint(uint64(other.GetAccountId()), 10),
}
if accessToken != nil {
data["token"] = *accessToken
}
return c.getEscrowDuration("https://steamcommunity.com/tradeoffer/new/?" + netutil.ToUrlValues(data).Encode())
}
// Get duration of escrow in days. Call this after receiving a trade offer
func (c *Client) GetOfferEscrowDuration(offerId uint64) (*EscrowDuration, error) {
return c.getEscrowDuration("http://steamcommunity.com/tradeoffer/" + strconv.FormatUint(offerId, 10))
}
func (c *Client) getEscrowDuration(queryUrl string) (*EscrowDuration, error) {
resp, err := c.client.Get(queryUrl)
if err != nil {
return nil, fmt.Errorf("failed to retrieve escrow duration: %v", err)
}
defer resp.Body.Close()
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
escrowDuration, err := parseEscrowDuration(respBody)
if err != nil {
return nil, newSteamErrorf("failed to parse escrow duration: %v", err)
}
return escrowDuration, nil
}
func (c *Client) GetOfferWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) (*TradeOfferResult, error) {
var res *TradeOfferResult
return res, withRetry(
func() (err error) {
res, err = c.GetOffer(offerId)
return err
}, retryCount, retryDelay)
}
func (c *Client) GetOffersWithRetry(getSent bool, getReceived bool, getDescriptions bool, activeOnly bool, historicalOnly bool, timeHistoricalCutoff *uint32, retryCount int, retryDelay time.Duration) (*TradeOffersResult, error) {
var res *TradeOffersResult
return res, withRetry(
func() (err error) {
res, err = c.GetOffers(getSent, getReceived, getDescriptions, activeOnly, historicalOnly, timeHistoricalCutoff)
return err
}, retryCount, retryDelay)
}
func (c *Client) DeclineWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) error {
return withRetry(
func() error {
return c.Decline(offerId)
}, retryCount, retryDelay)
}
func (c *Client) CancelWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) error {
return withRetry(
func() error {
return c.Cancel(offerId)
}, retryCount, retryDelay)
}
func (c *Client) AcceptWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) error {
return withRetry(
func() error {
return c.Accept(offerId)
}, retryCount, retryDelay)
}
func (c *Client) CreateWithRetry(other steamid.SteamId, accessToken *string, myItems, theirItems []TradeItem, counteredOfferId *uint64, message string, retryCount int, retryDelay time.Duration) (uint64, error) {
var res uint64
return res, withRetry(
func() (err error) {
res, err = c.Create(other, accessToken, myItems, theirItems, counteredOfferId, message)
return err
}, retryCount, retryDelay)
}
func (c *Client) GetOwnInventoryWithRetry(contextId uint64, appId uint32, retryCount int, retryDelay time.Duration) (*inventory.Inventory, error) {
var res *inventory.Inventory
return res, withRetry(
func() (err error) {
res, err = c.GetOwnInventory(contextId, appId)
return err
}, retryCount, retryDelay)
}
func (c *Client) GetPartnerInventoryWithRetry(other steamid.SteamId, contextId uint64, appId uint32, offerId *uint64, retryCount int, retryDelay time.Duration) (*inventory.Inventory, error) {
var res *inventory.Inventory
return res, withRetry(
func() (err error) {
res, err = c.GetPartnerInventory(other, contextId, appId, offerId)
return err
}, retryCount, retryDelay)
}
func (c *Client) GetTradeReceiptWithRetry(tradeId uint64, retryCount int, retryDelay time.Duration) ([]*TradeReceiptItem, error) {
var res []*TradeReceiptItem
return res, withRetry(
func() (err error) {
res, err = c.GetTradeReceipt(tradeId)
return err
}, retryCount, retryDelay)
}
func withRetry(f func() error, retryCount int, retryDelay time.Duration) error {
if retryCount <= 0 {
panic("retry count must be more than 0")
}
i := 0
for {
i++
if err := f(); err != nil {
// If we got steam error do not retry
if _, ok := err.(*SteamError); ok {
return err
}
if i == retryCount {
return err
}
time.Sleep(retryDelay)
continue
}
break
}
return nil
}

View File

@ -0,0 +1,19 @@
package tradeoffer
import (
"fmt"
)
// SteamError can be returned by Create, Accept, Decline and Cancel methods.
// It means we got response from steam, but it was in unknown format
// or request was declined.
type SteamError struct {
msg string
}
func (e *SteamError) Error() string {
return e.msg
}
func newSteamErrorf(format string, a ...interface{}) *SteamError {
return &SteamError{fmt.Sprintf(format, a...)}
}

View File

@ -0,0 +1,47 @@
package tradeoffer
import (
"errors"
"fmt"
"regexp"
"strconv"
)
type EscrowDuration struct {
DaysMyEscrow uint32
DaysTheirEscrow uint32
}
func parseEscrowDuration(data []byte) (*EscrowDuration, error) {
// TODO: why we are using case insensitive matching?
myRegex := regexp.MustCompile("(?i)g_daysMyEscrow[\\s=]+(\\d+);")
theirRegex := regexp.MustCompile("(?i)g_daysTheirEscrow[\\s=]+(\\d+);")
myM := myRegex.FindSubmatch(data)
theirM := theirRegex.FindSubmatch(data)
if myM == nil || theirM == nil {
// check if access token is valid
notFriendsRegex := regexp.MustCompile(">You are not friends with this user<")
notFriendsM := notFriendsRegex.FindSubmatch(data)
if notFriendsM == nil {
return nil, errors.New("regexp does not match")
} else {
return nil, errors.New("you are not friends with this user")
}
}
myEscrow, err := strconv.ParseUint(string(myM[1]), 10, 32)
if err != nil {
return nil, fmt.Errorf("failed to parse my duration into uint: %v", err)
}
theirEscrow, err := strconv.ParseUint(string(theirM[1]), 10, 32)
if err != nil {
return nil, fmt.Errorf("failed to parse their duration into uint: %v", err)
}
return &EscrowDuration{
DaysMyEscrow: uint32(myEscrow),
DaysTheirEscrow: uint32(theirEscrow),
}, nil
}

View File

@ -0,0 +1,35 @@
package tradeoffer
import (
"encoding/json"
"fmt"
"github.com/Philipp15b/go-steam/economy/inventory"
"regexp"
)
type TradeReceiptItem struct {
AssetId uint64 `json:"id,string"`
AppId uint32
ContextId uint64
Owner uint64 `json:",string"`
Pos uint32
inventory.Description
}
func parseTradeReceipt(data []byte) ([]*TradeReceiptItem, error) {
reg := regexp.MustCompile("oItem =\\s+(.+?});")
itemMatches := reg.FindAllSubmatch(data, -1)
if itemMatches == nil {
return nil, fmt.Errorf("items not found\n")
}
items := make([]*TradeReceiptItem, 0, len(itemMatches))
for _, m := range itemMatches {
item := new(TradeReceiptItem)
err := json.Unmarshal(m[1], &item)
if err != nil {
return nil, err
}
items = append(items, item)
}
return items, nil
}

View File

@ -0,0 +1,118 @@
/*
Implements methods to interact with the official Trade Offer API.
See: https://developer.valvesoftware.com/wiki/Steam_Web_API/IEconService
*/
package tradeoffer
import (
"encoding/json"
"github.com/Philipp15b/go-steam/economy/inventory"
"github.com/Philipp15b/go-steam/steamid"
)
type TradeOfferState uint
const (
TradeOfferState_Invalid TradeOfferState = 1 // Invalid
TradeOfferState_Active = 2 // This trade offer has been sent, neither party has acted on it yet.
TradeOfferState_Accepted = 3 // The trade offer was accepted by the recipient and items were exchanged.
TradeOfferState_Countered = 4 // The recipient made a counter offer
TradeOfferState_Expired = 5 // The trade offer was not accepted before the expiration date
TradeOfferState_Canceled = 6 // The sender cancelled the offer
TradeOfferState_Declined = 7 // The recipient declined the offer
TradeOfferState_InvalidItems = 8 // Some of the items in the offer are no longer available (indicated by the missing flag in the output)
TradeOfferState_CreatedNeedsConfirmation = 9 // The offer hasn't been sent yet and is awaiting email/mobile confirmation. The offer is only visible to the sender.
TradeOfferState_CanceledBySecondFactor = 10 // Either party canceled the offer via email/mobile. The offer is visible to both parties, even if the sender canceled it before it was sent.
TradeOfferState_InEscrow = 11 // The trade has been placed on hold. The items involved in the trade have all been removed from both parties' inventories and will be automatically delivered in the future.
)
type TradeOfferConfirmationMethod uint
const (
TradeOfferConfirmationMethod_Invalid TradeOfferConfirmationMethod = 0
TradeOfferConfirmationMethod_Email = 1
TradeOfferConfirmationMethod_MobileApp = 2
)
type Asset struct {
AppId uint32 `json:",string"`
ContextId uint64 `json:",string"`
AssetId uint64 `json:",string"`
CurrencyId uint64 `json:",string"`
ClassId uint64 `json:",string"`
InstanceId uint64 `json:",string"`
Amount uint64 `json:",string"`
Missing bool
}
type TradeOffer struct {
TradeOfferId uint64 `json:",string"`
TradeId uint64 `json:",string"`
OtherAccountId uint32 `json:"accountid_other"`
OtherSteamId steamid.SteamId `json:"-"`
Message string `json:"message"`
ExpirationTime uint32 `json:"expiraton_time"`
State TradeOfferState `json:"trade_offer_state"`
ToGive []*Asset `json:"items_to_give"`
ToReceive []*Asset `json:"items_to_receive"`
IsOurOffer bool `json:"is_our_offer"`
TimeCreated uint32 `json:"time_created"`
TimeUpdated uint32 `json:"time_updated"`
EscrowEndDate uint32 `json:"escrow_end_date"`
ConfirmationMethod TradeOfferConfirmationMethod `json:"confirmation_method"`
}
func (t *TradeOffer) UnmarshalJSON(data []byte) error {
type Alias TradeOffer
aux := struct {
*Alias
}{
Alias: (*Alias)(t),
}
if err := json.Unmarshal(data, &aux); err != nil {
return err
}
if t.OtherAccountId == 0 {
t.OtherSteamId = steamid.SteamId(0)
return nil
}
t.OtherSteamId = steamid.SteamId(uint64(t.OtherAccountId) + 76561197960265728)
return nil
}
type TradeOffersResult struct {
Sent []*TradeOffer `json:"trade_offers_sent"`
Received []*TradeOffer `json:"trade_offers_received"`
Descriptions []*Description
}
type TradeOfferResult struct {
Offer *TradeOffer
Descriptions []*Description
}
type Description struct {
AppId uint32 `json:"appid"`
ClassId uint64 `json:"classid,string"`
InstanceId uint64 `json:"instanceid,string"`
IconUrl string `json:"icon_url"`
IconUrlLarge string `json:"icon_url_large"`
Name string
MarketName string `json:"market_name"`
MarketHashName string `json:"market_hash_name"`
// Colors in hex, for example `B2B2B2`
NameColor string `json:"name_color"`
BackgroundColor string `json:"background_color"`
Type string
Tradable bool `json:"tradable"`
Commodity bool `json:"commodity"`
MarketTradableRestriction uint32 `json:"market_tradable_restriction"`
Descriptions inventory.DescriptionLines `json:"descriptions"`
Actions []*inventory.Action `json:"actions"`
}

83
vendor/github.com/Philipp15b/go-steam/trading.go generated vendored Normal file
View File

@ -0,0 +1,83 @@
package steam
import (
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
"github.com/golang/protobuf/proto"
)
// Provides access to the Steam client's part of Steam Trading, that is bootstrapping
// the trade.
// The trade itself is not handled by the Steam client itself, but it's a part of
// the Steam website.
//
// You'll receive a TradeProposedEvent when a friend proposes a trade. You can accept it with
// the RespondRequest method. You can request a trade yourself with RequestTrade.
type Trading struct {
client *Client
}
type TradeRequestId uint32
func (t *Trading) HandlePacket(packet *Packet) {
switch packet.EMsg {
case EMsg_EconTrading_InitiateTradeProposed:
msg := new(CMsgTrading_InitiateTradeRequest)
packet.ReadProtoMsg(msg)
t.client.Emit(&TradeProposedEvent{
RequestId: TradeRequestId(msg.GetTradeRequestId()),
Other: SteamId(msg.GetOtherSteamid()),
})
case EMsg_EconTrading_InitiateTradeResult:
msg := new(CMsgTrading_InitiateTradeResponse)
packet.ReadProtoMsg(msg)
t.client.Emit(&TradeResultEvent{
RequestId: TradeRequestId(msg.GetTradeRequestId()),
Response: EEconTradeResponse(msg.GetResponse()),
Other: SteamId(msg.GetOtherSteamid()),
NumDaysSteamGuardRequired: msg.GetSteamguardRequiredDays(),
NumDaysNewDeviceCooldown: msg.GetNewDeviceCooldownDays(),
DefaultNumDaysPasswordResetProbation: msg.GetDefaultPasswordResetProbationDays(),
NumDaysPasswordResetProbation: msg.GetPasswordResetProbationDays(),
})
case EMsg_EconTrading_StartSession:
msg := new(CMsgTrading_StartSession)
packet.ReadProtoMsg(msg)
t.client.Emit(&TradeSessionStartEvent{
Other: SteamId(msg.GetOtherSteamid()),
})
}
}
// Requests a trade. You'll receive a TradeResultEvent if the request fails or
// if the friend accepted the trade.
func (t *Trading) RequestTrade(other SteamId) {
t.client.Write(NewClientMsgProtobuf(EMsg_EconTrading_InitiateTradeRequest, &CMsgTrading_InitiateTradeRequest{
OtherSteamid: proto.Uint64(uint64(other)),
}))
}
// Responds to a TradeProposedEvent.
func (t *Trading) RespondRequest(requestId TradeRequestId, accept bool) {
var resp uint32
if accept {
resp = 0
} else {
resp = 1
}
t.client.Write(NewClientMsgProtobuf(EMsg_EconTrading_InitiateTradeResponse, &CMsgTrading_InitiateTradeResponse{
TradeRequestId: proto.Uint32(uint32(requestId)),
Response: proto.Uint32(resp),
}))
}
// This cancels a request made with RequestTrade.
func (t *Trading) CancelRequest(other SteamId) {
t.client.Write(NewClientMsgProtobuf(EMsg_EconTrading_CancelTradeRequest, &CMsgTrading_CancelTradeRequest{
OtherSteamid: proto.Uint64(uint64(other)),
}))
}

View File

@ -0,0 +1,29 @@
package steam
import (
. "github.com/Philipp15b/go-steam/protocol/steamlang"
. "github.com/Philipp15b/go-steam/steamid"
)
type TradeProposedEvent struct {
RequestId TradeRequestId
Other SteamId `json:",string"`
}
type TradeResultEvent struct {
RequestId TradeRequestId
Response EEconTradeResponse
Other SteamId `json:",string"`
// Number of days Steam Guard is required to have been active
NumDaysSteamGuardRequired uint32
// Number of days a new device cannot trade for.
NumDaysNewDeviceCooldown uint32
// Default number of days one cannot trade after a password reset.
DefaultNumDaysPasswordResetProbation uint32
// See above.
NumDaysPasswordResetProbation uint32
}
type TradeSessionStartEvent struct {
Other SteamId `json:",string"`
}

143
vendor/github.com/Philipp15b/go-steam/web.go generated vendored Normal file
View File

@ -0,0 +1,143 @@
package steam
import (
"crypto/aes"
"crypto/rand"
"encoding/base64"
"encoding/json"
"errors"
"github.com/Philipp15b/go-steam/cryptoutil"
. "github.com/Philipp15b/go-steam/protocol"
. "github.com/Philipp15b/go-steam/protocol/protobuf"
. "github.com/Philipp15b/go-steam/protocol/steamlang"
"github.com/golang/protobuf/proto"
"net/http"
"net/url"
"strconv"
"sync/atomic"
)
type Web struct {
// 64 bit alignment
relogOnNonce uint32
// The `sessionid` cookie required to use the steam website.
// This cookie may contain a characters that will need to be URL-escaped, otherwise
// Steam (probably) interprets is as a string.
// When used as an URL paramter this is automatically escaped by the Go HTTP package.
SessionId string
// The `steamLogin` cookie required to use the steam website. Already URL-escaped.
// This is only available after calling LogOn().
SteamLogin string
// The `steamLoginSecure` cookie required to use the steam website over HTTPs. Already URL-escaped.
// This is only availbile after calling LogOn().
SteamLoginSecure string
webLoginKey string
client *Client
}
func (w *Web) HandlePacket(packet *Packet) {
switch packet.EMsg {
case EMsg_ClientNewLoginKey:
w.handleNewLoginKey(packet)
case EMsg_ClientRequestWebAPIAuthenticateUserNonceResponse:
w.handleAuthNonceResponse(packet)
}
}
// Fetches the `steamLogin` cookie. This may only be called after the first
// WebSessionIdEvent or it will panic.
func (w *Web) LogOn() {
if w.webLoginKey == "" {
panic("Web: webLoginKey not initialized!")
}
go func() {
// retry three times. yes, I know about loops.
err := w.apiLogOn()
if err != nil {
err = w.apiLogOn()
if err != nil {
err = w.apiLogOn()
}
}
if err != nil {
w.client.Emit(WebLogOnErrorEvent(err))
return
}
}()
}
func (w *Web) apiLogOn() error {
sessionKey := make([]byte, 32)
rand.Read(sessionKey)
cryptedSessionKey := cryptoutil.RSAEncrypt(GetPublicKey(EUniverse_Public), sessionKey)
ciph, _ := aes.NewCipher(sessionKey)
cryptedLoginKey := cryptoutil.SymmetricEncrypt(ciph, []byte(w.webLoginKey))
data := make(url.Values)
data.Add("format", "json")
data.Add("steamid", strconv.FormatUint(w.client.SteamId().ToUint64(), 10))
data.Add("sessionkey", string(cryptedSessionKey))
data.Add("encrypted_loginkey", string(cryptedLoginKey))
resp, err := http.PostForm("https://api.steampowered.com/ISteamUserAuth/AuthenticateUser/v0001", data)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode == 401 {
// our web login key has expired, request a new one
atomic.StoreUint32(&w.relogOnNonce, 1)
w.client.Write(NewClientMsgProtobuf(EMsg_ClientRequestWebAPIAuthenticateUserNonce, new(CMsgClientRequestWebAPIAuthenticateUserNonce)))
return nil
} else if resp.StatusCode != 200 {
return errors.New("steam.Web.apiLogOn: request failed with status " + resp.Status)
}
result := new(struct {
Authenticateuser struct {
Token string
TokenSecure string
}
})
err = json.NewDecoder(resp.Body).Decode(result)
if err != nil {
return err
}
w.SteamLogin = result.Authenticateuser.Token
w.SteamLoginSecure = result.Authenticateuser.TokenSecure
w.client.Emit(new(WebLoggedOnEvent))
return nil
}
func (w *Web) handleNewLoginKey(packet *Packet) {
msg := new(CMsgClientNewLoginKey)
packet.ReadProtoMsg(msg)
w.client.Write(NewClientMsgProtobuf(EMsg_ClientNewLoginKeyAccepted, &CMsgClientNewLoginKeyAccepted{
UniqueId: proto.Uint32(msg.GetUniqueId()),
}))
// number -> string -> bytes -> base64
w.SessionId = base64.StdEncoding.EncodeToString([]byte(strconv.FormatUint(uint64(msg.GetUniqueId()), 10)))
w.client.Emit(new(WebSessionIdEvent))
}
func (w *Web) handleAuthNonceResponse(packet *Packet) {
// this has to be the best name for a message yet.
msg := new(CMsgClientRequestWebAPIAuthenticateUserNonceResponse)
packet.ReadProtoMsg(msg)
w.webLoginKey = msg.GetWebapiAuthenticateUserNonce()
// if the nonce was specifically requested in apiLogOn(),
// don't emit an event.
if atomic.CompareAndSwapUint32(&w.relogOnNonce, 1, 0) {
w.LogOn()
}
}

7
vendor/github.com/Philipp15b/go-steam/web_events.go generated vendored Normal file
View File

@ -0,0 +1,7 @@
package steam
type WebLoggedOnEvent struct{}
type WebLogOnErrorEvent error
type WebSessionIdEvent struct{}

15
vendor/github.com/davecgh/go-spew/spew/LICENSE generated vendored Normal file
View File

@ -0,0 +1,15 @@
ISC License
Copyright (c) 2012-2016 Dave Collins <dave@davec.name>
Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

152
vendor/github.com/davecgh/go-spew/spew/bypass.go generated vendored Normal file
View File

@ -0,0 +1,152 @@
// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
// NOTE: Due to the following build constraints, this file will only be compiled
// when the code is not running on Google App Engine, compiled by GopherJS, and
// "-tags safe" is not added to the go build command line. The "disableunsafe"
// tag is deprecated and thus should not be used.
// +build !js,!appengine,!safe,!disableunsafe
package spew
import (
"reflect"
"unsafe"
)
const (
// UnsafeDisabled is a build-time constant which specifies whether or
// not access to the unsafe package is available.
UnsafeDisabled = false
// ptrSize is the size of a pointer on the current arch.
ptrSize = unsafe.Sizeof((*byte)(nil))
)
var (
// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
// internal reflect.Value fields. These values are valid before golang
// commit ecccf07e7f9d which changed the format. The are also valid
// after commit 82f48826c6c7 which changed the format again to mirror
// the original format. Code in the init function updates these offsets
// as necessary.
offsetPtr = uintptr(ptrSize)
offsetScalar = uintptr(0)
offsetFlag = uintptr(ptrSize * 2)
// flagKindWidth and flagKindShift indicate various bits that the
// reflect package uses internally to track kind information.
//
// flagRO indicates whether or not the value field of a reflect.Value is
// read-only.
//
// flagIndir indicates whether the value field of a reflect.Value is
// the actual data or a pointer to the data.
//
// These values are valid before golang commit 90a7c3c86944 which
// changed their positions. Code in the init function updates these
// flags as necessary.
flagKindWidth = uintptr(5)
flagKindShift = uintptr(flagKindWidth - 1)
flagRO = uintptr(1 << 0)
flagIndir = uintptr(1 << 1)
)
func init() {
// Older versions of reflect.Value stored small integers directly in the
// ptr field (which is named val in the older versions). Versions
// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
// scalar for this purpose which unfortunately came before the flag
// field, so the offset of the flag field is different for those
// versions.
//
// This code constructs a new reflect.Value from a known small integer
// and checks if the size of the reflect.Value struct indicates it has
// the scalar field. When it does, the offsets are updated accordingly.
vv := reflect.ValueOf(0xf00)
if unsafe.Sizeof(vv) == (ptrSize * 4) {
offsetScalar = ptrSize * 2
offsetFlag = ptrSize * 3
}
// Commit 90a7c3c86944 changed the flag positions such that the low
// order bits are the kind. This code extracts the kind from the flags
// field and ensures it's the correct type. When it's not, the flag
// order has been changed to the newer format, so the flags are updated
// accordingly.
upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
upfv := *(*uintptr)(upf)
flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
flagKindShift = 0
flagRO = 1 << 5
flagIndir = 1 << 6
// Commit adf9b30e5594 modified the flags to separate the
// flagRO flag into two bits which specifies whether or not the
// field is embedded. This causes flagIndir to move over a bit
// and means that flagRO is the combination of either of the
// original flagRO bit and the new bit.
//
// This code detects the change by extracting what used to be
// the indirect bit to ensure it's set. When it's not, the flag
// order has been changed to the newer format, so the flags are
// updated accordingly.
if upfv&flagIndir == 0 {
flagRO = 3 << 5
flagIndir = 1 << 7
}
}
}
// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
// the typical safety restrictions preventing access to unaddressable and
// unexported data. It works by digging the raw pointer to the underlying
// value out of the protected value and generating a new unprotected (unsafe)
// reflect.Value to it.
//
// This allows us to check for implementations of the Stringer and error
// interfaces to be used for pretty printing ordinarily unaddressable and
// inaccessible values such as unexported struct fields.
func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
indirects := 1
vt := v.Type()
upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
if rvf&flagIndir != 0 {
vt = reflect.PtrTo(v.Type())
indirects++
} else if offsetScalar != 0 {
// The value is in the scalar field when it's not one of the
// reference types.
switch vt.Kind() {
case reflect.Uintptr:
case reflect.Chan:
case reflect.Func:
case reflect.Map:
case reflect.Ptr:
case reflect.UnsafePointer:
default:
upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
offsetScalar)
}
}
pv := reflect.NewAt(vt, upv)
rv = pv
for i := 0; i < indirects; i++ {
rv = rv.Elem()
}
return rv
}

38
vendor/github.com/davecgh/go-spew/spew/bypasssafe.go generated vendored Normal file
View File

@ -0,0 +1,38 @@
// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
// NOTE: Due to the following build constraints, this file will only be compiled
// when the code is running on Google App Engine, compiled by GopherJS, or
// "-tags safe" is added to the go build command line. The "disableunsafe"
// tag is deprecated and thus should not be used.
// +build js appengine safe disableunsafe
package spew
import "reflect"
const (
// UnsafeDisabled is a build-time constant which specifies whether or
// not access to the unsafe package is available.
UnsafeDisabled = true
)
// unsafeReflectValue typically converts the passed reflect.Value into a one
// that bypasses the typical safety restrictions preventing access to
// unaddressable and unexported data. However, doing this relies on access to
// the unsafe package. This is a stub version which simply returns the passed
// reflect.Value when the unsafe package is not available.
func unsafeReflectValue(v reflect.Value) reflect.Value {
return v
}

341
vendor/github.com/davecgh/go-spew/spew/common.go generated vendored Normal file
View File

@ -0,0 +1,341 @@
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"fmt"
"io"
"reflect"
"sort"
"strconv"
)
// Some constants in the form of bytes to avoid string overhead. This mirrors
// the technique used in the fmt package.
var (
panicBytes = []byte("(PANIC=")
plusBytes = []byte("+")
iBytes = []byte("i")
trueBytes = []byte("true")
falseBytes = []byte("false")
interfaceBytes = []byte("(interface {})")
commaNewlineBytes = []byte(",\n")
newlineBytes = []byte("\n")
openBraceBytes = []byte("{")
openBraceNewlineBytes = []byte("{\n")
closeBraceBytes = []byte("}")
asteriskBytes = []byte("*")
colonBytes = []byte(":")
colonSpaceBytes = []byte(": ")
openParenBytes = []byte("(")
closeParenBytes = []byte(")")
spaceBytes = []byte(" ")
pointerChainBytes = []byte("->")
nilAngleBytes = []byte("<nil>")
maxNewlineBytes = []byte("<max depth reached>\n")
maxShortBytes = []byte("<max>")
circularBytes = []byte("<already shown>")
circularShortBytes = []byte("<shown>")
invalidAngleBytes = []byte("<invalid>")
openBracketBytes = []byte("[")
closeBracketBytes = []byte("]")
percentBytes = []byte("%")
precisionBytes = []byte(".")
openAngleBytes = []byte("<")
closeAngleBytes = []byte(">")
openMapBytes = []byte("map[")
closeMapBytes = []byte("]")
lenEqualsBytes = []byte("len=")
capEqualsBytes = []byte("cap=")
)
// hexDigits is used to map a decimal value to a hex digit.
var hexDigits = "0123456789abcdef"
// catchPanic handles any panics that might occur during the handleMethods
// calls.
func catchPanic(w io.Writer, v reflect.Value) {
if err := recover(); err != nil {
w.Write(panicBytes)
fmt.Fprintf(w, "%v", err)
w.Write(closeParenBytes)
}
}
// handleMethods attempts to call the Error and String methods on the underlying
// type the passed reflect.Value represents and outputes the result to Writer w.
//
// It handles panics in any called methods by catching and displaying the error
// as the formatted value.
func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
// We need an interface to check if the type implements the error or
// Stringer interface. However, the reflect package won't give us an
// interface on certain things like unexported struct fields in order
// to enforce visibility rules. We use unsafe, when it's available,
// to bypass these restrictions since this package does not mutate the
// values.
if !v.CanInterface() {
if UnsafeDisabled {
return false
}
v = unsafeReflectValue(v)
}
// Choose whether or not to do error and Stringer interface lookups against
// the base type or a pointer to the base type depending on settings.
// Technically calling one of these methods with a pointer receiver can
// mutate the value, however, types which choose to satisify an error or
// Stringer interface with a pointer receiver should not be mutating their
// state inside these interface methods.
if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
v = unsafeReflectValue(v)
}
if v.CanAddr() {
v = v.Addr()
}
// Is it an error or Stringer?
switch iface := v.Interface().(type) {
case error:
defer catchPanic(w, v)
if cs.ContinueOnMethod {
w.Write(openParenBytes)
w.Write([]byte(iface.Error()))
w.Write(closeParenBytes)
w.Write(spaceBytes)
return false
}
w.Write([]byte(iface.Error()))
return true
case fmt.Stringer:
defer catchPanic(w, v)
if cs.ContinueOnMethod {
w.Write(openParenBytes)
w.Write([]byte(iface.String()))
w.Write(closeParenBytes)
w.Write(spaceBytes)
return false
}
w.Write([]byte(iface.String()))
return true
}
return false
}
// printBool outputs a boolean value as true or false to Writer w.
func printBool(w io.Writer, val bool) {
if val {
w.Write(trueBytes)
} else {
w.Write(falseBytes)
}
}
// printInt outputs a signed integer value to Writer w.
func printInt(w io.Writer, val int64, base int) {
w.Write([]byte(strconv.FormatInt(val, base)))
}
// printUint outputs an unsigned integer value to Writer w.
func printUint(w io.Writer, val uint64, base int) {
w.Write([]byte(strconv.FormatUint(val, base)))
}
// printFloat outputs a floating point value using the specified precision,
// which is expected to be 32 or 64bit, to Writer w.
func printFloat(w io.Writer, val float64, precision int) {
w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
}
// printComplex outputs a complex value using the specified float precision
// for the real and imaginary parts to Writer w.
func printComplex(w io.Writer, c complex128, floatPrecision int) {
r := real(c)
w.Write(openParenBytes)
w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
i := imag(c)
if i >= 0 {
w.Write(plusBytes)
}
w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
w.Write(iBytes)
w.Write(closeParenBytes)
}
// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
// prefix to Writer w.
func printHexPtr(w io.Writer, p uintptr) {
// Null pointer.
num := uint64(p)
if num == 0 {
w.Write(nilAngleBytes)
return
}
// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
buf := make([]byte, 18)
// It's simpler to construct the hex string right to left.
base := uint64(16)
i := len(buf) - 1
for num >= base {
buf[i] = hexDigits[num%base]
num /= base
i--
}
buf[i] = hexDigits[num]
// Add '0x' prefix.
i--
buf[i] = 'x'
i--
buf[i] = '0'
// Strip unused leading bytes.
buf = buf[i:]
w.Write(buf)
}
// valuesSorter implements sort.Interface to allow a slice of reflect.Value
// elements to be sorted.
type valuesSorter struct {
values []reflect.Value
strings []string // either nil or same len and values
cs *ConfigState
}
// newValuesSorter initializes a valuesSorter instance, which holds a set of
// surrogate keys on which the data should be sorted. It uses flags in
// ConfigState to decide if and how to populate those surrogate keys.
func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
vs := &valuesSorter{values: values, cs: cs}
if canSortSimply(vs.values[0].Kind()) {
return vs
}
if !cs.DisableMethods {
vs.strings = make([]string, len(values))
for i := range vs.values {
b := bytes.Buffer{}
if !handleMethods(cs, &b, vs.values[i]) {
vs.strings = nil
break
}
vs.strings[i] = b.String()
}
}
if vs.strings == nil && cs.SpewKeys {
vs.strings = make([]string, len(values))
for i := range vs.values {
vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
}
}
return vs
}
// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
// directly, or whether it should be considered for sorting by surrogate keys
// (if the ConfigState allows it).
func canSortSimply(kind reflect.Kind) bool {
// This switch parallels valueSortLess, except for the default case.
switch kind {
case reflect.Bool:
return true
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
return true
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
return true
case reflect.Float32, reflect.Float64:
return true
case reflect.String:
return true
case reflect.Uintptr:
return true
case reflect.Array:
return true
}
return false
}
// Len returns the number of values in the slice. It is part of the
// sort.Interface implementation.
func (s *valuesSorter) Len() int {
return len(s.values)
}
// Swap swaps the values at the passed indices. It is part of the
// sort.Interface implementation.
func (s *valuesSorter) Swap(i, j int) {
s.values[i], s.values[j] = s.values[j], s.values[i]
if s.strings != nil {
s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
}
}
// valueSortLess returns whether the first value should sort before the second
// value. It is used by valueSorter.Less as part of the sort.Interface
// implementation.
func valueSortLess(a, b reflect.Value) bool {
switch a.Kind() {
case reflect.Bool:
return !a.Bool() && b.Bool()
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
return a.Int() < b.Int()
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
return a.Uint() < b.Uint()
case reflect.Float32, reflect.Float64:
return a.Float() < b.Float()
case reflect.String:
return a.String() < b.String()
case reflect.Uintptr:
return a.Uint() < b.Uint()
case reflect.Array:
// Compare the contents of both arrays.
l := a.Len()
for i := 0; i < l; i++ {
av := a.Index(i)
bv := b.Index(i)
if av.Interface() == bv.Interface() {
continue
}
return valueSortLess(av, bv)
}
}
return a.String() < b.String()
}
// Less returns whether the value at index i should sort before the
// value at index j. It is part of the sort.Interface implementation.
func (s *valuesSorter) Less(i, j int) bool {
if s.strings == nil {
return valueSortLess(s.values[i], s.values[j])
}
return s.strings[i] < s.strings[j]
}
// sortValues is a sort function that handles both native types and any type that
// can be converted to error or Stringer. Other inputs are sorted according to
// their Value.String() value to ensure display stability.
func sortValues(values []reflect.Value, cs *ConfigState) {
if len(values) == 0 {
return
}
sort.Sort(newValuesSorter(values, cs))
}

306
vendor/github.com/davecgh/go-spew/spew/config.go generated vendored Normal file
View File

@ -0,0 +1,306 @@
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"fmt"
"io"
"os"
)
// ConfigState houses the configuration options used by spew to format and
// display values. There is a global instance, Config, that is used to control
// all top-level Formatter and Dump functionality. Each ConfigState instance
// provides methods equivalent to the top-level functions.
//
// The zero value for ConfigState provides no indentation. You would typically
// want to set it to a space or a tab.
//
// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
// with default settings. See the documentation of NewDefaultConfig for default
// values.
type ConfigState struct {
// Indent specifies the string to use for each indentation level. The
// global config instance that all top-level functions use set this to a
// single space by default. If you would like more indentation, you might
// set this to a tab with "\t" or perhaps two spaces with " ".
Indent string
// MaxDepth controls the maximum number of levels to descend into nested
// data structures. The default, 0, means there is no limit.
//
// NOTE: Circular data structures are properly detected, so it is not
// necessary to set this value unless you specifically want to limit deeply
// nested data structures.
MaxDepth int
// DisableMethods specifies whether or not error and Stringer interfaces are
// invoked for types that implement them.
DisableMethods bool
// DisablePointerMethods specifies whether or not to check for and invoke
// error and Stringer interfaces on types which only accept a pointer
// receiver when the current type is not a pointer.
//
// NOTE: This might be an unsafe action since calling one of these methods
// with a pointer receiver could technically mutate the value, however,
// in practice, types which choose to satisify an error or Stringer
// interface with a pointer receiver should not be mutating their state
// inside these interface methods. As a result, this option relies on
// access to the unsafe package, so it will not have any effect when
// running in environments without access to the unsafe package such as
// Google App Engine or with the "safe" build tag specified.
DisablePointerMethods bool
// DisablePointerAddresses specifies whether to disable the printing of
// pointer addresses. This is useful when diffing data structures in tests.
DisablePointerAddresses bool
// DisableCapacities specifies whether to disable the printing of capacities
// for arrays, slices, maps and channels. This is useful when diffing
// data structures in tests.
DisableCapacities bool
// ContinueOnMethod specifies whether or not recursion should continue once
// a custom error or Stringer interface is invoked. The default, false,
// means it will print the results of invoking the custom error or Stringer
// interface and return immediately instead of continuing to recurse into
// the internals of the data type.
//
// NOTE: This flag does not have any effect if method invocation is disabled
// via the DisableMethods or DisablePointerMethods options.
ContinueOnMethod bool
// SortKeys specifies map keys should be sorted before being printed. Use
// this to have a more deterministic, diffable output. Note that only
// native types (bool, int, uint, floats, uintptr and string) and types
// that support the error or Stringer interfaces (if methods are
// enabled) are supported, with other types sorted according to the
// reflect.Value.String() output which guarantees display stability.
SortKeys bool
// SpewKeys specifies that, as a last resort attempt, map keys should
// be spewed to strings and sorted by those strings. This is only
// considered if SortKeys is true.
SpewKeys bool
}
// Config is the active configuration of the top-level functions.
// The configuration can be changed by modifying the contents of spew.Config.
var Config = ConfigState{Indent: " "}
// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the formatted string as a value that satisfies error. See NewFormatter
// for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
return fmt.Errorf(format, c.convertArgs(a)...)
}
// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprint(w, c.convertArgs(a)...)
}
// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
return fmt.Fprintf(w, format, c.convertArgs(a)...)
}
// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
// passed with a Formatter interface returned by c.NewFormatter. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprintln(w, c.convertArgs(a)...)
}
// Print is a wrapper for fmt.Print that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
return fmt.Print(c.convertArgs(a)...)
}
// Printf is a wrapper for fmt.Printf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
return fmt.Printf(format, c.convertArgs(a)...)
}
// Println is a wrapper for fmt.Println that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
return fmt.Println(c.convertArgs(a)...)
}
// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Sprint(a ...interface{}) string {
return fmt.Sprint(c.convertArgs(a)...)
}
// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
// passed with a Formatter interface returned by c.NewFormatter. It returns
// the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
return fmt.Sprintf(format, c.convertArgs(a)...)
}
// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
// were passed with a Formatter interface returned by c.NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
func (c *ConfigState) Sprintln(a ...interface{}) string {
return fmt.Sprintln(c.convertArgs(a)...)
}
/*
NewFormatter returns a custom formatter that satisfies the fmt.Formatter
interface. As a result, it integrates cleanly with standard fmt package
printing functions. The formatter is useful for inline printing of smaller data
types similar to the standard %v format specifier.
The custom formatter only responds to the %v (most compact), %+v (adds pointer
addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
combinations. Any other verbs such as %x and %q will be sent to the the
standard fmt package for formatting. In addition, the custom formatter ignores
the width and precision arguments (however they will still work on the format
specifiers not handled by the custom formatter).
Typically this function shouldn't be called directly. It is much easier to make
use of the custom formatter by calling one of the convenience functions such as
c.Printf, c.Println, or c.Printf.
*/
func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
return newFormatter(c, v)
}
// Fdump formats and displays the passed arguments to io.Writer w. It formats
// exactly the same as Dump.
func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
fdump(c, w, a...)
}
/*
Dump displays the passed parameters to standard out with newlines, customizable
indentation, and additional debug information such as complete types and all
pointer addresses used to indirect to the final value. It provides the
following features over the built-in printing facilities provided by the fmt
package:
* Pointers are dereferenced and followed
* Circular data structures are detected and handled properly
* Custom Stringer/error interfaces are optionally invoked, including
on unexported types
* Custom types which only implement the Stringer/error interfaces via
a pointer receiver are optionally invoked when passing non-pointer
variables
* Byte arrays and slices are dumped like the hexdump -C command which
includes offsets, byte values in hex, and ASCII output
The configuration options are controlled by modifying the public members
of c. See ConfigState for options documentation.
See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
get the formatted result as a string.
*/
func (c *ConfigState) Dump(a ...interface{}) {
fdump(c, os.Stdout, a...)
}
// Sdump returns a string with the passed arguments formatted exactly the same
// as Dump.
func (c *ConfigState) Sdump(a ...interface{}) string {
var buf bytes.Buffer
fdump(c, &buf, a...)
return buf.String()
}
// convertArgs accepts a slice of arguments and returns a slice of the same
// length with each argument converted to a spew Formatter interface using
// the ConfigState associated with s.
func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
formatters = make([]interface{}, len(args))
for index, arg := range args {
formatters[index] = newFormatter(c, arg)
}
return formatters
}
// NewDefaultConfig returns a ConfigState with the following default settings.
//
// Indent: " "
// MaxDepth: 0
// DisableMethods: false
// DisablePointerMethods: false
// ContinueOnMethod: false
// SortKeys: false
func NewDefaultConfig() *ConfigState {
return &ConfigState{Indent: " "}
}

211
vendor/github.com/davecgh/go-spew/spew/doc.go generated vendored Normal file
View File

@ -0,0 +1,211 @@
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
Package spew implements a deep pretty printer for Go data structures to aid in
debugging.
A quick overview of the additional features spew provides over the built-in
printing facilities for Go data types are as follows:
* Pointers are dereferenced and followed
* Circular data structures are detected and handled properly
* Custom Stringer/error interfaces are optionally invoked, including
on unexported types
* Custom types which only implement the Stringer/error interfaces via
a pointer receiver are optionally invoked when passing non-pointer
variables
* Byte arrays and slices are dumped like the hexdump -C command which
includes offsets, byte values in hex, and ASCII output (only when using
Dump style)
There are two different approaches spew allows for dumping Go data structures:
* Dump style which prints with newlines, customizable indentation,
and additional debug information such as types and all pointer addresses
used to indirect to the final value
* A custom Formatter interface that integrates cleanly with the standard fmt
package and replaces %v, %+v, %#v, and %#+v to provide inline printing
similar to the default %v while providing the additional functionality
outlined above and passing unsupported format verbs such as %x and %q
along to fmt
Quick Start
This section demonstrates how to quickly get started with spew. See the
sections below for further details on formatting and configuration options.
To dump a variable with full newlines, indentation, type, and pointer
information use Dump, Fdump, or Sdump:
spew.Dump(myVar1, myVar2, ...)
spew.Fdump(someWriter, myVar1, myVar2, ...)
str := spew.Sdump(myVar1, myVar2, ...)
Alternatively, if you would prefer to use format strings with a compacted inline
printing style, use the convenience wrappers Printf, Fprintf, etc with
%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
%#+v (adds types and pointer addresses):
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
Configuration Options
Configuration of spew is handled by fields in the ConfigState type. For
convenience, all of the top-level functions use a global state available
via the spew.Config global.
It is also possible to create a ConfigState instance that provides methods
equivalent to the top-level functions. This allows concurrent configuration
options. See the ConfigState documentation for more details.
The following configuration options are available:
* Indent
String to use for each indentation level for Dump functions.
It is a single space by default. A popular alternative is "\t".
* MaxDepth
Maximum number of levels to descend into nested data structures.
There is no limit by default.
* DisableMethods
Disables invocation of error and Stringer interface methods.
Method invocation is enabled by default.
* DisablePointerMethods
Disables invocation of error and Stringer interface methods on types
which only accept pointer receivers from non-pointer variables.
Pointer method invocation is enabled by default.
* DisablePointerAddresses
DisablePointerAddresses specifies whether to disable the printing of
pointer addresses. This is useful when diffing data structures in tests.
* DisableCapacities
DisableCapacities specifies whether to disable the printing of
capacities for arrays, slices, maps and channels. This is useful when
diffing data structures in tests.
* ContinueOnMethod
Enables recursion into types after invoking error and Stringer interface
methods. Recursion after method invocation is disabled by default.
* SortKeys
Specifies map keys should be sorted before being printed. Use
this to have a more deterministic, diffable output. Note that
only native types (bool, int, uint, floats, uintptr and string)
and types which implement error or Stringer interfaces are
supported with other types sorted according to the
reflect.Value.String() output which guarantees display
stability. Natural map order is used by default.
* SpewKeys
Specifies that, as a last resort attempt, map keys should be
spewed to strings and sorted by those strings. This is only
considered if SortKeys is true.
Dump Usage
Simply call spew.Dump with a list of variables you want to dump:
spew.Dump(myVar1, myVar2, ...)
You may also call spew.Fdump if you would prefer to output to an arbitrary
io.Writer. For example, to dump to standard error:
spew.Fdump(os.Stderr, myVar1, myVar2, ...)
A third option is to call spew.Sdump to get the formatted output as a string:
str := spew.Sdump(myVar1, myVar2, ...)
Sample Dump Output
See the Dump example for details on the setup of the types and variables being
shown here.
(main.Foo) {
unexportedField: (*main.Bar)(0xf84002e210)({
flag: (main.Flag) flagTwo,
data: (uintptr) <nil>
}),
ExportedField: (map[interface {}]interface {}) (len=1) {
(string) (len=3) "one": (bool) true
}
}
Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
command as shown.
([]uint8) (len=32 cap=32) {
00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
00000020 31 32 |12|
}
Custom Formatter
Spew provides a custom formatter that implements the fmt.Formatter interface
so that it integrates cleanly with standard fmt package printing functions. The
formatter is useful for inline printing of smaller data types similar to the
standard %v format specifier.
The custom formatter only responds to the %v (most compact), %+v (adds pointer
addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
combinations. Any other verbs such as %x and %q will be sent to the the
standard fmt package for formatting. In addition, the custom formatter ignores
the width and precision arguments (however they will still work on the format
specifiers not handled by the custom formatter).
Custom Formatter Usage
The simplest way to make use of the spew custom formatter is to call one of the
convenience functions such as spew.Printf, spew.Println, or spew.Printf. The
functions have syntax you are most likely already familiar with:
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
spew.Println(myVar, myVar2)
spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
See the Index for the full list convenience functions.
Sample Formatter Output
Double pointer to a uint8:
%v: <**>5
%+v: <**>(0xf8400420d0->0xf8400420c8)5
%#v: (**uint8)5
%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
Pointer to circular struct with a uint8 field and a pointer to itself:
%v: <*>{1 <*><shown>}
%+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
%#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
See the Printf example for details on the setup of variables being shown
here.
Errors
Since it is possible for custom Stringer/error interfaces to panic, spew
detects them and handles them internally by printing the panic information
inline with the output. Since spew is intended to provide deep pretty printing
capabilities on structures, it intentionally does not return any errors.
*/
package spew

509
vendor/github.com/davecgh/go-spew/spew/dump.go generated vendored Normal file
View File

@ -0,0 +1,509 @@
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"encoding/hex"
"fmt"
"io"
"os"
"reflect"
"regexp"
"strconv"
"strings"
)
var (
// uint8Type is a reflect.Type representing a uint8. It is used to
// convert cgo types to uint8 slices for hexdumping.
uint8Type = reflect.TypeOf(uint8(0))
// cCharRE is a regular expression that matches a cgo char.
// It is used to detect character arrays to hexdump them.
cCharRE = regexp.MustCompile("^.*\\._Ctype_char$")
// cUnsignedCharRE is a regular expression that matches a cgo unsigned
// char. It is used to detect unsigned character arrays to hexdump
// them.
cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$")
// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
// It is used to detect uint8_t arrays to hexdump them.
cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$")
)
// dumpState contains information about the state of a dump operation.
type dumpState struct {
w io.Writer
depth int
pointers map[uintptr]int
ignoreNextType bool
ignoreNextIndent bool
cs *ConfigState
}
// indent performs indentation according to the depth level and cs.Indent
// option.
func (d *dumpState) indent() {
if d.ignoreNextIndent {
d.ignoreNextIndent = false
return
}
d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
}
// unpackValue returns values inside of non-nil interfaces when possible.
// This is useful for data types like structs, arrays, slices, and maps which
// can contain varying types packed inside an interface.
func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Interface && !v.IsNil() {
v = v.Elem()
}
return v
}
// dumpPtr handles formatting of pointers by indirecting them as necessary.
func (d *dumpState) dumpPtr(v reflect.Value) {
// Remove pointers at or below the current depth from map used to detect
// circular refs.
for k, depth := range d.pointers {
if depth >= d.depth {
delete(d.pointers, k)
}
}
// Keep list of all dereferenced pointers to show later.
pointerChain := make([]uintptr, 0)
// Figure out how many levels of indirection there are by dereferencing
// pointers and unpacking interfaces down the chain while detecting circular
// references.
nilFound := false
cycleFound := false
indirects := 0
ve := v
for ve.Kind() == reflect.Ptr {
if ve.IsNil() {
nilFound = true
break
}
indirects++
addr := ve.Pointer()
pointerChain = append(pointerChain, addr)
if pd, ok := d.pointers[addr]; ok && pd < d.depth {
cycleFound = true
indirects--
break
}
d.pointers[addr] = d.depth
ve = ve.Elem()
if ve.Kind() == reflect.Interface {
if ve.IsNil() {
nilFound = true
break
}
ve = ve.Elem()
}
}
// Display type information.
d.w.Write(openParenBytes)
d.w.Write(bytes.Repeat(asteriskBytes, indirects))
d.w.Write([]byte(ve.Type().String()))
d.w.Write(closeParenBytes)
// Display pointer information.
if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
d.w.Write(openParenBytes)
for i, addr := range pointerChain {
if i > 0 {
d.w.Write(pointerChainBytes)
}
printHexPtr(d.w, addr)
}
d.w.Write(closeParenBytes)
}
// Display dereferenced value.
d.w.Write(openParenBytes)
switch {
case nilFound == true:
d.w.Write(nilAngleBytes)
case cycleFound == true:
d.w.Write(circularBytes)
default:
d.ignoreNextType = true
d.dump(ve)
}
d.w.Write(closeParenBytes)
}
// dumpSlice handles formatting of arrays and slices. Byte (uint8 under
// reflection) arrays and slices are dumped in hexdump -C fashion.
func (d *dumpState) dumpSlice(v reflect.Value) {
// Determine whether this type should be hex dumped or not. Also,
// for types which should be hexdumped, try to use the underlying data
// first, then fall back to trying to convert them to a uint8 slice.
var buf []uint8
doConvert := false
doHexDump := false
numEntries := v.Len()
if numEntries > 0 {
vt := v.Index(0).Type()
vts := vt.String()
switch {
// C types that need to be converted.
case cCharRE.MatchString(vts):
fallthrough
case cUnsignedCharRE.MatchString(vts):
fallthrough
case cUint8tCharRE.MatchString(vts):
doConvert = true
// Try to use existing uint8 slices and fall back to converting
// and copying if that fails.
case vt.Kind() == reflect.Uint8:
// We need an addressable interface to convert the type
// to a byte slice. However, the reflect package won't
// give us an interface on certain things like
// unexported struct fields in order to enforce
// visibility rules. We use unsafe, when available, to
// bypass these restrictions since this package does not
// mutate the values.
vs := v
if !vs.CanInterface() || !vs.CanAddr() {
vs = unsafeReflectValue(vs)
}
if !UnsafeDisabled {
vs = vs.Slice(0, numEntries)
// Use the existing uint8 slice if it can be
// type asserted.
iface := vs.Interface()
if slice, ok := iface.([]uint8); ok {
buf = slice
doHexDump = true
break
}
}
// The underlying data needs to be converted if it can't
// be type asserted to a uint8 slice.
doConvert = true
}
// Copy and convert the underlying type if needed.
if doConvert && vt.ConvertibleTo(uint8Type) {
// Convert and copy each element into a uint8 byte
// slice.
buf = make([]uint8, numEntries)
for i := 0; i < numEntries; i++ {
vv := v.Index(i)
buf[i] = uint8(vv.Convert(uint8Type).Uint())
}
doHexDump = true
}
}
// Hexdump the entire slice as needed.
if doHexDump {
indent := strings.Repeat(d.cs.Indent, d.depth)
str := indent + hex.Dump(buf)
str = strings.Replace(str, "\n", "\n"+indent, -1)
str = strings.TrimRight(str, d.cs.Indent)
d.w.Write([]byte(str))
return
}
// Recursively call dump for each item.
for i := 0; i < numEntries; i++ {
d.dump(d.unpackValue(v.Index(i)))
if i < (numEntries - 1) {
d.w.Write(commaNewlineBytes)
} else {
d.w.Write(newlineBytes)
}
}
}
// dump is the main workhorse for dumping a value. It uses the passed reflect
// value to figure out what kind of object we are dealing with and formats it
// appropriately. It is a recursive function, however circular data structures
// are detected and handled properly.
func (d *dumpState) dump(v reflect.Value) {
// Handle invalid reflect values immediately.
kind := v.Kind()
if kind == reflect.Invalid {
d.w.Write(invalidAngleBytes)
return
}
// Handle pointers specially.
if kind == reflect.Ptr {
d.indent()
d.dumpPtr(v)
return
}
// Print type information unless already handled elsewhere.
if !d.ignoreNextType {
d.indent()
d.w.Write(openParenBytes)
d.w.Write([]byte(v.Type().String()))
d.w.Write(closeParenBytes)
d.w.Write(spaceBytes)
}
d.ignoreNextType = false
// Display length and capacity if the built-in len and cap functions
// work with the value's kind and the len/cap itself is non-zero.
valueLen, valueCap := 0, 0
switch v.Kind() {
case reflect.Array, reflect.Slice, reflect.Chan:
valueLen, valueCap = v.Len(), v.Cap()
case reflect.Map, reflect.String:
valueLen = v.Len()
}
if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
d.w.Write(openParenBytes)
if valueLen != 0 {
d.w.Write(lenEqualsBytes)
printInt(d.w, int64(valueLen), 10)
}
if !d.cs.DisableCapacities && valueCap != 0 {
if valueLen != 0 {
d.w.Write(spaceBytes)
}
d.w.Write(capEqualsBytes)
printInt(d.w, int64(valueCap), 10)
}
d.w.Write(closeParenBytes)
d.w.Write(spaceBytes)
}
// Call Stringer/error interfaces if they exist and the handle methods flag
// is enabled
if !d.cs.DisableMethods {
if (kind != reflect.Invalid) && (kind != reflect.Interface) {
if handled := handleMethods(d.cs, d.w, v); handled {
return
}
}
}
switch kind {
case reflect.Invalid:
// Do nothing. We should never get here since invalid has already
// been handled above.
case reflect.Bool:
printBool(d.w, v.Bool())
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
printInt(d.w, v.Int(), 10)
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
printUint(d.w, v.Uint(), 10)
case reflect.Float32:
printFloat(d.w, v.Float(), 32)
case reflect.Float64:
printFloat(d.w, v.Float(), 64)
case reflect.Complex64:
printComplex(d.w, v.Complex(), 32)
case reflect.Complex128:
printComplex(d.w, v.Complex(), 64)
case reflect.Slice:
if v.IsNil() {
d.w.Write(nilAngleBytes)
break
}
fallthrough
case reflect.Array:
d.w.Write(openBraceNewlineBytes)
d.depth++
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
d.indent()
d.w.Write(maxNewlineBytes)
} else {
d.dumpSlice(v)
}
d.depth--
d.indent()
d.w.Write(closeBraceBytes)
case reflect.String:
d.w.Write([]byte(strconv.Quote(v.String())))
case reflect.Interface:
// The only time we should get here is for nil interfaces due to
// unpackValue calls.
if v.IsNil() {
d.w.Write(nilAngleBytes)
}
case reflect.Ptr:
// Do nothing. We should never get here since pointers have already
// been handled above.
case reflect.Map:
// nil maps should be indicated as different than empty maps
if v.IsNil() {
d.w.Write(nilAngleBytes)
break
}
d.w.Write(openBraceNewlineBytes)
d.depth++
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
d.indent()
d.w.Write(maxNewlineBytes)
} else {
numEntries := v.Len()
keys := v.MapKeys()
if d.cs.SortKeys {
sortValues(keys, d.cs)
}
for i, key := range keys {
d.dump(d.unpackValue(key))
d.w.Write(colonSpaceBytes)
d.ignoreNextIndent = true
d.dump(d.unpackValue(v.MapIndex(key)))
if i < (numEntries - 1) {
d.w.Write(commaNewlineBytes)
} else {
d.w.Write(newlineBytes)
}
}
}
d.depth--
d.indent()
d.w.Write(closeBraceBytes)
case reflect.Struct:
d.w.Write(openBraceNewlineBytes)
d.depth++
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
d.indent()
d.w.Write(maxNewlineBytes)
} else {
vt := v.Type()
numFields := v.NumField()
for i := 0; i < numFields; i++ {
d.indent()
vtf := vt.Field(i)
d.w.Write([]byte(vtf.Name))
d.w.Write(colonSpaceBytes)
d.ignoreNextIndent = true
d.dump(d.unpackValue(v.Field(i)))
if i < (numFields - 1) {
d.w.Write(commaNewlineBytes)
} else {
d.w.Write(newlineBytes)
}
}
}
d.depth--
d.indent()
d.w.Write(closeBraceBytes)
case reflect.Uintptr:
printHexPtr(d.w, uintptr(v.Uint()))
case reflect.UnsafePointer, reflect.Chan, reflect.Func:
printHexPtr(d.w, v.Pointer())
// There were not any other types at the time this code was written, but
// fall back to letting the default fmt package handle it in case any new
// types are added.
default:
if v.CanInterface() {
fmt.Fprintf(d.w, "%v", v.Interface())
} else {
fmt.Fprintf(d.w, "%v", v.String())
}
}
}
// fdump is a helper function to consolidate the logic from the various public
// methods which take varying writers and config states.
func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
for _, arg := range a {
if arg == nil {
w.Write(interfaceBytes)
w.Write(spaceBytes)
w.Write(nilAngleBytes)
w.Write(newlineBytes)
continue
}
d := dumpState{w: w, cs: cs}
d.pointers = make(map[uintptr]int)
d.dump(reflect.ValueOf(arg))
d.w.Write(newlineBytes)
}
}
// Fdump formats and displays the passed arguments to io.Writer w. It formats
// exactly the same as Dump.
func Fdump(w io.Writer, a ...interface{}) {
fdump(&Config, w, a...)
}
// Sdump returns a string with the passed arguments formatted exactly the same
// as Dump.
func Sdump(a ...interface{}) string {
var buf bytes.Buffer
fdump(&Config, &buf, a...)
return buf.String()
}
/*
Dump displays the passed parameters to standard out with newlines, customizable
indentation, and additional debug information such as complete types and all
pointer addresses used to indirect to the final value. It provides the
following features over the built-in printing facilities provided by the fmt
package:
* Pointers are dereferenced and followed
* Circular data structures are detected and handled properly
* Custom Stringer/error interfaces are optionally invoked, including
on unexported types
* Custom types which only implement the Stringer/error interfaces via
a pointer receiver are optionally invoked when passing non-pointer
variables
* Byte arrays and slices are dumped like the hexdump -C command which
includes offsets, byte values in hex, and ASCII output
The configuration options are controlled by an exported package global,
spew.Config. See ConfigState for options documentation.
See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
get the formatted result as a string.
*/
func Dump(a ...interface{}) {
fdump(&Config, os.Stdout, a...)
}

419
vendor/github.com/davecgh/go-spew/spew/format.go generated vendored Normal file
View File

@ -0,0 +1,419 @@
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"bytes"
"fmt"
"reflect"
"strconv"
"strings"
)
// supportedFlags is a list of all the character flags supported by fmt package.
const supportedFlags = "0-+# "
// formatState implements the fmt.Formatter interface and contains information
// about the state of a formatting operation. The NewFormatter function can
// be used to get a new Formatter which can be used directly as arguments
// in standard fmt package printing calls.
type formatState struct {
value interface{}
fs fmt.State
depth int
pointers map[uintptr]int
ignoreNextType bool
cs *ConfigState
}
// buildDefaultFormat recreates the original format string without precision
// and width information to pass in to fmt.Sprintf in the case of an
// unrecognized type. Unless new types are added to the language, this
// function won't ever be called.
func (f *formatState) buildDefaultFormat() (format string) {
buf := bytes.NewBuffer(percentBytes)
for _, flag := range supportedFlags {
if f.fs.Flag(int(flag)) {
buf.WriteRune(flag)
}
}
buf.WriteRune('v')
format = buf.String()
return format
}
// constructOrigFormat recreates the original format string including precision
// and width information to pass along to the standard fmt package. This allows
// automatic deferral of all format strings this package doesn't support.
func (f *formatState) constructOrigFormat(verb rune) (format string) {
buf := bytes.NewBuffer(percentBytes)
for _, flag := range supportedFlags {
if f.fs.Flag(int(flag)) {
buf.WriteRune(flag)
}
}
if width, ok := f.fs.Width(); ok {
buf.WriteString(strconv.Itoa(width))
}
if precision, ok := f.fs.Precision(); ok {
buf.Write(precisionBytes)
buf.WriteString(strconv.Itoa(precision))
}
buf.WriteRune(verb)
format = buf.String()
return format
}
// unpackValue returns values inside of non-nil interfaces when possible and
// ensures that types for values which have been unpacked from an interface
// are displayed when the show types flag is also set.
// This is useful for data types like structs, arrays, slices, and maps which
// can contain varying types packed inside an interface.
func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
if v.Kind() == reflect.Interface {
f.ignoreNextType = false
if !v.IsNil() {
v = v.Elem()
}
}
return v
}
// formatPtr handles formatting of pointers by indirecting them as necessary.
func (f *formatState) formatPtr(v reflect.Value) {
// Display nil if top level pointer is nil.
showTypes := f.fs.Flag('#')
if v.IsNil() && (!showTypes || f.ignoreNextType) {
f.fs.Write(nilAngleBytes)
return
}
// Remove pointers at or below the current depth from map used to detect
// circular refs.
for k, depth := range f.pointers {
if depth >= f.depth {
delete(f.pointers, k)
}
}
// Keep list of all dereferenced pointers to possibly show later.
pointerChain := make([]uintptr, 0)
// Figure out how many levels of indirection there are by derferencing
// pointers and unpacking interfaces down the chain while detecting circular
// references.
nilFound := false
cycleFound := false
indirects := 0
ve := v
for ve.Kind() == reflect.Ptr {
if ve.IsNil() {
nilFound = true
break
}
indirects++
addr := ve.Pointer()
pointerChain = append(pointerChain, addr)
if pd, ok := f.pointers[addr]; ok && pd < f.depth {
cycleFound = true
indirects--
break
}
f.pointers[addr] = f.depth
ve = ve.Elem()
if ve.Kind() == reflect.Interface {
if ve.IsNil() {
nilFound = true
break
}
ve = ve.Elem()
}
}
// Display type or indirection level depending on flags.
if showTypes && !f.ignoreNextType {
f.fs.Write(openParenBytes)
f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
f.fs.Write([]byte(ve.Type().String()))
f.fs.Write(closeParenBytes)
} else {
if nilFound || cycleFound {
indirects += strings.Count(ve.Type().String(), "*")
}
f.fs.Write(openAngleBytes)
f.fs.Write([]byte(strings.Repeat("*", indirects)))
f.fs.Write(closeAngleBytes)
}
// Display pointer information depending on flags.
if f.fs.Flag('+') && (len(pointerChain) > 0) {
f.fs.Write(openParenBytes)
for i, addr := range pointerChain {
if i > 0 {
f.fs.Write(pointerChainBytes)
}
printHexPtr(f.fs, addr)
}
f.fs.Write(closeParenBytes)
}
// Display dereferenced value.
switch {
case nilFound == true:
f.fs.Write(nilAngleBytes)
case cycleFound == true:
f.fs.Write(circularShortBytes)
default:
f.ignoreNextType = true
f.format(ve)
}
}
// format is the main workhorse for providing the Formatter interface. It
// uses the passed reflect value to figure out what kind of object we are
// dealing with and formats it appropriately. It is a recursive function,
// however circular data structures are detected and handled properly.
func (f *formatState) format(v reflect.Value) {
// Handle invalid reflect values immediately.
kind := v.Kind()
if kind == reflect.Invalid {
f.fs.Write(invalidAngleBytes)
return
}
// Handle pointers specially.
if kind == reflect.Ptr {
f.formatPtr(v)
return
}
// Print type information unless already handled elsewhere.
if !f.ignoreNextType && f.fs.Flag('#') {
f.fs.Write(openParenBytes)
f.fs.Write([]byte(v.Type().String()))
f.fs.Write(closeParenBytes)
}
f.ignoreNextType = false
// Call Stringer/error interfaces if they exist and the handle methods
// flag is enabled.
if !f.cs.DisableMethods {
if (kind != reflect.Invalid) && (kind != reflect.Interface) {
if handled := handleMethods(f.cs, f.fs, v); handled {
return
}
}
}
switch kind {
case reflect.Invalid:
// Do nothing. We should never get here since invalid has already
// been handled above.
case reflect.Bool:
printBool(f.fs, v.Bool())
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
printInt(f.fs, v.Int(), 10)
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
printUint(f.fs, v.Uint(), 10)
case reflect.Float32:
printFloat(f.fs, v.Float(), 32)
case reflect.Float64:
printFloat(f.fs, v.Float(), 64)
case reflect.Complex64:
printComplex(f.fs, v.Complex(), 32)
case reflect.Complex128:
printComplex(f.fs, v.Complex(), 64)
case reflect.Slice:
if v.IsNil() {
f.fs.Write(nilAngleBytes)
break
}
fallthrough
case reflect.Array:
f.fs.Write(openBracketBytes)
f.depth++
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
f.fs.Write(maxShortBytes)
} else {
numEntries := v.Len()
for i := 0; i < numEntries; i++ {
if i > 0 {
f.fs.Write(spaceBytes)
}
f.ignoreNextType = true
f.format(f.unpackValue(v.Index(i)))
}
}
f.depth--
f.fs.Write(closeBracketBytes)
case reflect.String:
f.fs.Write([]byte(v.String()))
case reflect.Interface:
// The only time we should get here is for nil interfaces due to
// unpackValue calls.
if v.IsNil() {
f.fs.Write(nilAngleBytes)
}
case reflect.Ptr:
// Do nothing. We should never get here since pointers have already
// been handled above.
case reflect.Map:
// nil maps should be indicated as different than empty maps
if v.IsNil() {
f.fs.Write(nilAngleBytes)
break
}
f.fs.Write(openMapBytes)
f.depth++
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
f.fs.Write(maxShortBytes)
} else {
keys := v.MapKeys()
if f.cs.SortKeys {
sortValues(keys, f.cs)
}
for i, key := range keys {
if i > 0 {
f.fs.Write(spaceBytes)
}
f.ignoreNextType = true
f.format(f.unpackValue(key))
f.fs.Write(colonBytes)
f.ignoreNextType = true
f.format(f.unpackValue(v.MapIndex(key)))
}
}
f.depth--
f.fs.Write(closeMapBytes)
case reflect.Struct:
numFields := v.NumField()
f.fs.Write(openBraceBytes)
f.depth++
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
f.fs.Write(maxShortBytes)
} else {
vt := v.Type()
for i := 0; i < numFields; i++ {
if i > 0 {
f.fs.Write(spaceBytes)
}
vtf := vt.Field(i)
if f.fs.Flag('+') || f.fs.Flag('#') {
f.fs.Write([]byte(vtf.Name))
f.fs.Write(colonBytes)
}
f.format(f.unpackValue(v.Field(i)))
}
}
f.depth--
f.fs.Write(closeBraceBytes)
case reflect.Uintptr:
printHexPtr(f.fs, uintptr(v.Uint()))
case reflect.UnsafePointer, reflect.Chan, reflect.Func:
printHexPtr(f.fs, v.Pointer())
// There were not any other types at the time this code was written, but
// fall back to letting the default fmt package handle it if any get added.
default:
format := f.buildDefaultFormat()
if v.CanInterface() {
fmt.Fprintf(f.fs, format, v.Interface())
} else {
fmt.Fprintf(f.fs, format, v.String())
}
}
}
// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
// details.
func (f *formatState) Format(fs fmt.State, verb rune) {
f.fs = fs
// Use standard formatting for verbs that are not v.
if verb != 'v' {
format := f.constructOrigFormat(verb)
fmt.Fprintf(fs, format, f.value)
return
}
if f.value == nil {
if fs.Flag('#') {
fs.Write(interfaceBytes)
}
fs.Write(nilAngleBytes)
return
}
f.format(reflect.ValueOf(f.value))
}
// newFormatter is a helper function to consolidate the logic from the various
// public methods which take varying config states.
func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
fs := &formatState{value: v, cs: cs}
fs.pointers = make(map[uintptr]int)
return fs
}
/*
NewFormatter returns a custom formatter that satisfies the fmt.Formatter
interface. As a result, it integrates cleanly with standard fmt package
printing functions. The formatter is useful for inline printing of smaller data
types similar to the standard %v format specifier.
The custom formatter only responds to the %v (most compact), %+v (adds pointer
addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
combinations. Any other verbs such as %x and %q will be sent to the the
standard fmt package for formatting. In addition, the custom formatter ignores
the width and precision arguments (however they will still work on the format
specifiers not handled by the custom formatter).
Typically this function shouldn't be called directly. It is much easier to make
use of the custom formatter by calling one of the convenience functions such as
Printf, Println, or Fprintf.
*/
func NewFormatter(v interface{}) fmt.Formatter {
return newFormatter(&Config, v)
}

148
vendor/github.com/davecgh/go-spew/spew/spew.go generated vendored Normal file
View File

@ -0,0 +1,148 @@
/*
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
package spew
import (
"fmt"
"io"
)
// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the formatted string as a value that satisfies error. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
func Errorf(format string, a ...interface{}) (err error) {
return fmt.Errorf(format, convertArgs(a)...)
}
// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
func Fprint(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprint(w, convertArgs(a)...)
}
// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
return fmt.Fprintf(w, format, convertArgs(a)...)
}
// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
// passed with a default Formatter interface returned by NewFormatter. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
func Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
return fmt.Fprintln(w, convertArgs(a)...)
}
// Print is a wrapper for fmt.Print that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
func Print(a ...interface{}) (n int, err error) {
return fmt.Print(convertArgs(a)...)
}
// Printf is a wrapper for fmt.Printf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
func Printf(format string, a ...interface{}) (n int, err error) {
return fmt.Printf(format, convertArgs(a)...)
}
// Println is a wrapper for fmt.Println that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the number of bytes written and any write error encountered. See
// NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
func Println(a ...interface{}) (n int, err error) {
return fmt.Println(convertArgs(a)...)
}
// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
func Sprint(a ...interface{}) string {
return fmt.Sprint(convertArgs(a)...)
}
// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
// passed with a default Formatter interface returned by NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
func Sprintf(format string, a ...interface{}) string {
return fmt.Sprintf(format, convertArgs(a)...)
}
// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
// were passed with a default Formatter interface returned by NewFormatter. It
// returns the resulting string. See NewFormatter for formatting details.
//
// This function is shorthand for the following syntax:
//
// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
func Sprintln(a ...interface{}) string {
return fmt.Sprintln(convertArgs(a)...)
}
// convertArgs accepts a slice of arguments and returns a slice of the same
// length with each argument converted to a default spew Formatter interface.
func convertArgs(args []interface{}) (formatters []interface{}) {
formatters = make([]interface{}, len(args))
for index, arg := range args {
formatters[index] = NewFormatter(arg)
}
return formatters
}

31
vendor/github.com/golang/protobuf/proto/LICENSE generated vendored Normal file
View File

@ -0,0 +1,31 @@
Go support for Protocol Buffers - Google's data interchange format
Copyright 2010 The Go Authors. All rights reserved.
https://github.com/golang/protobuf
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

229
vendor/github.com/golang/protobuf/proto/clone.go generated vendored Normal file
View File

@ -0,0 +1,229 @@
// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2011 The Go Authors. All rights reserved.
// https://github.com/golang/protobuf
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Protocol buffer deep copy and merge.
// TODO: RawMessage.
package proto
import (
"log"
"reflect"
"strings"
)
// Clone returns a deep copy of a protocol buffer.
func Clone(pb Message) Message {
in := reflect.ValueOf(pb)
if in.IsNil() {
return pb
}
out := reflect.New(in.Type().Elem())
// out is empty so a merge is a deep copy.
mergeStruct(out.Elem(), in.Elem())
return out.Interface().(Message)
}
// Merge merges src into dst.
// Required and optional fields that are set in src will be set to that value in dst.
// Elements of repeated fields will be appended.
// Merge panics if src and dst are not the same type, or if dst is nil.
func Merge(dst, src Message) {
in := reflect.ValueOf(src)
out := reflect.ValueOf(dst)
if out.IsNil() {
panic("proto: nil destination")
}
if in.Type() != out.Type() {
// Explicit test prior to mergeStruct so that mistyped nils will fail
panic("proto: type mismatch")
}
if in.IsNil() {
// Merging nil into non-nil is a quiet no-op
return
}
mergeStruct(out.Elem(), in.Elem())
}
func mergeStruct(out, in reflect.Value) {
sprop := GetProperties(in.Type())
for i := 0; i < in.NumField(); i++ {
f := in.Type().Field(i)
if strings.HasPrefix(f.Name, "XXX_") {
continue
}
mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])
}
if emIn, ok := extendable(in.Addr().Interface()); ok {
emOut, _ := extendable(out.Addr().Interface())
mIn, muIn := emIn.extensionsRead()
if mIn != nil {
mOut := emOut.extensionsWrite()
muIn.Lock()
mergeExtension(mOut, mIn)
muIn.Unlock()
}
}
uf := in.FieldByName("XXX_unrecognized")
if !uf.IsValid() {
return
}
uin := uf.Bytes()
if len(uin) > 0 {
out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...))
}
}
// mergeAny performs a merge between two values of the same type.
// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
// prop is set if this is a struct field (it may be nil).
func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
if in.Type() == protoMessageType {
if !in.IsNil() {
if out.IsNil() {
out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
} else {
Merge(out.Interface().(Message), in.Interface().(Message))
}
}
return
}
switch in.Kind() {
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
reflect.String, reflect.Uint32, reflect.Uint64:
if !viaPtr && isProto3Zero(in) {
return
}
out.Set(in)
case reflect.Interface:
// Probably a oneof field; copy non-nil values.
if in.IsNil() {
return
}
// Allocate destination if it is not set, or set to a different type.
// Otherwise we will merge as normal.
if out.IsNil() || out.Elem().Type() != in.Elem().Type() {
out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
}
mergeAny(out.Elem(), in.Elem(), false, nil)
case reflect.Map:
if in.Len() == 0 {
return
}
if out.IsNil() {
out.Set(reflect.MakeMap(in.Type()))
}
// For maps with value types of *T or []byte we need to deep copy each value.
elemKind := in.Type().Elem().Kind()
for _, key := range in.MapKeys() {
var val reflect.Value
switch elemKind {
case reflect.Ptr:
val = reflect.New(in.Type().Elem().Elem())
mergeAny(val, in.MapIndex(key), false, nil)
case reflect.Slice:
val = in.MapIndex(key)
val = reflect.ValueOf(append([]byte{}, val.Bytes()...))
default:
val = in.MapIndex(key)
}
out.SetMapIndex(key, val)
}
case reflect.Ptr:
if in.IsNil() {
return
}
if out.IsNil() {
out.Set(reflect.New(in.Elem().Type()))
}
mergeAny(out.Elem(), in.Elem(), true, nil)
case reflect.Slice:
if in.IsNil() {
return
}
if in.Type().Elem().Kind() == reflect.Uint8 {
// []byte is a scalar bytes field, not a repeated field.
// Edge case: if this is in a proto3 message, a zero length
// bytes field is considered the zero value, and should not
// be merged.
if prop != nil && prop.proto3 && in.Len() == 0 {
return
}
// Make a deep copy.
// Append to []byte{} instead of []byte(nil) so that we never end up
// with a nil result.
out.SetBytes(append([]byte{}, in.Bytes()...))
return
}
n := in.Len()
if out.IsNil() {
out.Set(reflect.MakeSlice(in.Type(), 0, n))
}
switch in.Type().Elem().Kind() {
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
reflect.String, reflect.Uint32, reflect.Uint64:
out.Set(reflect.AppendSlice(out, in))
default:
for i := 0; i < n; i++ {
x := reflect.Indirect(reflect.New(in.Type().Elem()))
mergeAny(x, in.Index(i), false, nil)
out.Set(reflect.Append(out, x))
}
}
case reflect.Struct:
mergeStruct(out, in)
default:
// unknown type, so not a protocol buffer
log.Printf("proto: don't know how to copy %v", in)
}
}
func mergeExtension(out, in map[int32]Extension) {
for extNum, eIn := range in {
eOut := Extension{desc: eIn.desc}
if eIn.value != nil {
v := reflect.New(reflect.TypeOf(eIn.value)).Elem()
mergeAny(v, reflect.ValueOf(eIn.value), false, nil)
eOut.value = v.Interface()
}
if eIn.enc != nil {
eOut.enc = make([]byte, len(eIn.enc))
copy(eOut.enc, eIn.enc)
}
out[extNum] = eOut
}
}

Some files were not shown because too many files have changed in this diff Show More