Release v0.16.0-rc2

If slack detects a text contains an url it changes it to <http://url|url>.
Strip the |url so that http://url remains.

README.md

@@ -3,7 +3,8 @@
 
 ![matterbridge.gif](https://s15.postimg.org/qpjhp6y3f/matterbridge.gif)
 
-Simple bridge between Mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat, Hipchat(via xmpp) and Matrix with REST API.
+Simple bridge between Mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat, Hipchat(via xmpp), Matrix and Steam.
+Has a REST API.
 
 # Table of Contents
  * [Features](#features)
@@ -20,7 +21,8 @@ Simple bridge between Mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, R
  * [Thanks](#thanks)
 
 # Features
-* Relays public channel messages between multiple mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat, Hipchat (via xmpp) and Matrix. Pick and mix.
+* Relays public channel messages between multiple mattermost, IRC, XMPP, Gitter, Slack, Discord, Telegram, Rocket.Chat, Hipchat (via xmpp), Matrix and Steam. 
+  Pick and mix.
 * Matterbridge can also work with private groups on your mattermost/slack.
 * Allow for bridging the same bridges, which means you can eg bridge between multiple mattermosts.
 * The bridge is now a gateway which has support multiple in and out bridges. (and supports multiple gateways).
@@ -38,11 +40,13 @@ Accounts to one of the supported bridges
 * [Hipchat](https://www.hipchat.com)
 * [Rocket.chat](https://rocket.chat)
 * [Matrix](https://matrix.org)
+* [Steam](https://store.steampowered.com/)
 
 # Installing
 ## Binaries
 Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
-* Latest stable release [v0.15.0](https://github.com/42wim/matterbridge/releases/latest)
+* Latest rc release (with steam support) [v0.16.0-rc2](https://github.com/42wim/matterbridge/releases/latest)
+* Latest stable release [v0.15.0](https://github.com/42wim/matterbridge/releases/tag/v0.15.0)
 
 ## Building
 Go 1.6+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
@@ -63,7 +67,10 @@ matterbridge
 * [matterbridge.toml.sample](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for documentation and an example.
 * [matterbridge.toml.simple](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.simple) for a simple example.
 
-## Examples
+## Create a configuration.
+See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.
+
+## Examples 
 ### Bridge mattermost (off-topic) - irc (#testing)
 ```
 [irc]

bridge/bridge.go

@@ -10,6 +10,7 @@ import (
 	"github.com/42wim/matterbridge/bridge/mattermost"
 	"github.com/42wim/matterbridge/bridge/rocketchat"
 	"github.com/42wim/matterbridge/bridge/slack"
+	"github.com/42wim/matterbridge/bridge/steam"
 	"github.com/42wim/matterbridge/bridge/telegram"
 	"github.com/42wim/matterbridge/bridge/xmpp"
 	log "github.com/Sirupsen/logrus"
@@ -75,6 +76,9 @@ func New(cfg *config.Config, bridge *config.Bridge, c chan config.Message) *Brid
 	case "matrix":
 		b.Config = cfg.Matrix[name]
 		b.Bridger = bmatrix.New(cfg.Matrix[name], bridge.Account, c)
+	case "steam":
+		b.Config = cfg.Steam[name]
+		b.Bridger = bsteam.New(cfg.Steam[name], bridge.Account, c)
 	case "api":
 		b.Config = cfg.Api[name]
 		b.Bridger = api.New(cfg.Api[name], bridge.Account, c)

bridge/config/config.go

@@ -39,7 +39,8 @@ type ChannelInfo struct {
 }
 
 type Protocol struct {
-	BindAddress            string // mattermost, slack
+	AuthCode               string // steam
+	BindAddress            string // mattermost, slack // DEPRECATED
 	Buffer                 int    // api
 	EditSuffix             string // mattermost, slack, discord, telegram, gitter
 	EditDisable            bool   // mattermost, slack, discord, telegram, gitter
@@ -67,14 +68,19 @@ type Protocol struct {
 	RemoteNickFormat       string // all protocols
 	Server                 string // IRC,mattermost,XMPP,discord
 	ShowJoinPart           bool   // all protocols
+	ShowEmbeds             bool   // discord
 	SkipTLSVerify          bool   // IRC, mattermost
 	Team                   string // mattermost
 	Token                  string // gitter, slack, discord, api
-	URL                    string // mattermost, slack, matrix
+	URL                    string // mattermost, slack // DEPRECATED
 	UseAPI                 bool   // mattermost, slack
 	UseSASL                bool   // IRC
 	UseTLS                 bool   // IRC
 	UseFirstName           bool   // telegram
+	UseInsecureURL         bool   // telegram
+	WebhookBindAddress     string // mattermost, slack
+	WebhookURL             string // mattermost, slack
+	WebhookUse             string // mattermost, slack, discord
 }
 
 type ChannelOptions struct {
@@ -109,6 +115,7 @@ type Config struct {
 	Mattermost         map[string]Protocol
 	Matrix             map[string]Protocol
 	Slack              map[string]Protocol
+	Steam              map[string]Protocol
 	Gitter             map[string]Protocol
 	Xmpp               map[string]Protocol
 	Discord            map[string]Protocol
@@ -124,6 +131,28 @@ func NewConfig(cfgfile string) *Config {
 	if _, err := toml.DecodeFile(cfgfile, &cfg); err != nil {
 		log.Fatal(err)
 	}
+	fail := false
+	for k, v := range cfg.Mattermost {
+		res := Deprecated(v, "mattermost."+k)
+		if res {
+			fail = res
+		}
+	}
+	for k, v := range cfg.Slack {
+		res := Deprecated(v, "slack."+k)
+		if res {
+			fail = res
+		}
+	}
+	for k, v := range cfg.Rocketchat {
+		res := Deprecated(v, "rocketchat."+k)
+		if res {
+			fail = res
+		}
+	}
+	if fail {
+		log.Fatalf("Fix your config. Please see changelog for more information")
+	}
 	return &cfg
 }
 
@@ -174,3 +203,17 @@ func GetIconURL(msg *Message, cfg *Protocol) string {
 	iconURL = strings.Replace(iconURL, "{PROTOCOL}", protocol, -1)
 	return iconURL
 }
+
+func Deprecated(cfg Protocol, account string) bool {
+	if cfg.BindAddress != "" {
+		log.Printf("ERROR: %s BindAddress is deprecated, you need to change it to WebhookBindAddress.", account)
+	} else if cfg.URL != "" {
+		log.Printf("ERROR: %s URL is deprecated, you need to change it to WebhookURL.", account)
+	} else if cfg.UseAPI == true {
+		log.Printf("ERROR: %s UseAPI is deprecated, it's enabled by default, please remove it from your config file.", account)
+	} else {
+		return false
+	}
+	return true
+	//log.Fatalf("ERROR: Fix your config: %s", account)
+}

bridge/discord/discord.go

@@ -19,6 +19,8 @@ type bdiscord struct {
 	UseChannelID  bool
 	userMemberMap map[string]*discordgo.Member
 	guildID       string
+	webhookID     string
+	webhookToken  string
 	sync.RWMutex
 }
 
@@ -35,12 +37,23 @@ func New(cfg config.Protocol, account string, c chan config.Message) *bdiscord {
 	b.Remote = c
 	b.Account = account
 	b.userMemberMap = make(map[string]*discordgo.Member)
+	if b.Config.WebhookURL != "" {
+		flog.Debug("Configuring Discord Incoming Webhook")
+		webhookURLSplit := strings.Split(b.Config.WebhookURL, "/")
+		b.webhookToken = webhookURLSplit[len(webhookURLSplit)-1]
+		b.webhookID = webhookURLSplit[len(webhookURLSplit)-2]
+	}
 	return b
 }
 
 func (b *bdiscord) Connect() error {
 	var err error
 	flog.Info("Connecting")
+	if b.Config.WebhookURL == "" {
+		flog.Info("Connecting using token")
+	} else {
+		flog.Info("Connecting using webhookurl (for posting) and token")
+	}
 	if !strings.HasPrefix(b.Config.Token, "Bot ") {
 		b.Config.Token = "Bot " + b.Config.Token
 	}
@@ -101,7 +114,21 @@ func (b *bdiscord) Send(msg config.Message) error {
 		flog.Errorf("Could not find channelID for %v", msg.Channel)
 		return nil
 	}
-	b.c.ChannelMessageSend(channelID, msg.Username+msg.Text)
+	if b.Config.WebhookURL == "" {
+		flog.Debugf("Broadcasting using token (API)")
+		b.c.ChannelMessageSend(channelID, msg.Username+msg.Text)
+	} else {
+		flog.Debugf("Broadcasting using Webhook")
+		b.c.WebhookExecute(
+			b.webhookID,
+			b.webhookToken,
+			true,
+			&discordgo.WebhookParams{
+				Content:   msg.Text,
+				Username:  msg.Username,
+				AvatarURL: msg.Avatar,
+			})
+	}
 	return nil
 }
 
@@ -122,6 +149,10 @@ func (b *bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 	if m.Author.Username == b.Nick {
 		return
 	}
+	// if using webhooks, do not relay if it's ours
+	if b.Config.WebhookURL != "" && m.Author.Bot && m.Author.ID == b.webhookID {
+		return
+	}
 	if len(m.Attachments) > 0 {
 		for _, attach := range m.Attachments {
 			m.Content = m.Content + "\n" + attach.URL
@@ -130,7 +161,7 @@ func (b *bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 	if m.Content == "" {
 		return
 	}
-	flog.Debugf("Sending message from %s on %s to gateway", m.Author.Username, b.Account)
+	flog.Debugf("Receiving message %#v", m.Message)
 	channelName := b.getChannelName(m.ChannelID)
 	if b.UseChannelID {
 		channelName = "ID:" + m.ChannelID
@@ -141,7 +172,16 @@ func (b *bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 	}
 	m.Message.Content = b.stripCustomoji(m.Message.Content)
 	m.Message.Content = b.replaceChannelMentions(m.Message.Content)
-	b.Remote <- config.Message{Username: username, Text: m.ContentWithMentionsReplaced(), Channel: channelName,
+
+	text := m.ContentWithMentionsReplaced()
+	if b.Config.ShowEmbeds && m.Message.Embeds != nil {
+		for _, embed := range m.Message.Embeds {
+			text = text + "embed: " + embed.Title + " - " + embed.Description + " - " + embed.URL + "\n"
+		}
+	}
+
+	flog.Debugf("Sending message from %s on %s to gateway", m.Author.Username, b.Account)
+	b.Remote <- config.Message{Username: username, Text: text, Channel: channelName,
 		Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg",
 		UserID: m.Author.ID}
 }

bridge/irc/irc.go

@@ -5,8 +5,13 @@ import (
 	"fmt"
 	"github.com/42wim/matterbridge/bridge/config"
 	log "github.com/Sirupsen/logrus"
+	"github.com/paulrosania/go-charset/charset"
+	_ "github.com/paulrosania/go-charset/data"
+	"github.com/saintfish/chardet"
 	ircm "github.com/sorcix/irc"
 	"github.com/thoj/go-ircevent"
+	"io"
+	"io/ioutil"
 	"regexp"
 	"sort"
 	"strconv"
@@ -251,6 +256,28 @@ func (b *Birc) handlePrivMsg(event *irc.Event) {
 	// strip IRC colors
 	re := regexp.MustCompile(`[[:cntrl:]](\d+,|)\d+`)
 	msg = re.ReplaceAllString(msg, "")
+
+	// detect what were sending so that we convert it to utf-8
+	detector := chardet.NewTextDetector()
+	result, err := detector.DetectBest([]byte(msg))
+	if err != nil {
+		flog.Infof("detection failed for msg: %#v", msg)
+		return
+	}
+	flog.Debugf("detected %s confidence %#v", result.Charset, result.Confidence)
+	var r io.Reader
+	r, err = charset.NewReader(result.Charset, strings.NewReader(msg))
+	// if we're not sure, just pick ISO-8859-1
+	if result.Confidence < 80 {
+		r, err = charset.NewReader("ISO-8859-1", strings.NewReader(msg))
+	}
+	if err != nil {
+		flog.Errorf("charset to utf-8 conversion failed: %s", err)
+		return
+	}
+	output, _ := ioutil.ReadAll(r)
+	msg = string(output)
+
 	flog.Debugf("Sending message from %s on %s to gateway", event.Arguments[0], b.Account)
 	b.Remote <- config.Message{Username: event.Nick, Text: msg, Channel: event.Arguments[0], Account: b.Account, UserID: event.User + "@" + event.Host}
 }

bridge/mattermost/mattermost.go

@@ -55,12 +55,18 @@ func (b *Bmattermost) Command(cmd string) string {
 }
 
 func (b *Bmattermost) Connect() error {
-	if !b.Config.UseAPI {
-		flog.Info("Connecting webhooks")
-		b.mh = matterhook.New(b.Config.URL,
+	if b.Config.WebhookURL != "" && b.Config.WebhookBindAddress != "" {
+		flog.Info("Connecting using webhookurl and webhookbindaddress")
+		b.mh = matterhook.New(b.Config.WebhookURL,
 			matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
-				BindAddress: b.Config.BindAddress})
+				BindAddress: b.Config.WebhookBindAddress})
+	} else if b.Config.WebhookURL != "" {
+		flog.Info("Connecting using webhookurl (for posting) and token")
+		b.mh = matterhook.New(b.Config.WebhookURL,
+			matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
+				DisableServer: true})
 	} else {
+		flog.Info("Connecting using token")
 		b.mc = matterclient.New(b.Config.Login, b.Config.Password,
 			b.Config.Team, b.Config.Server)
 		b.mc.SkipTLSVerify = b.Config.SkipTLSVerify
@@ -85,7 +91,7 @@ func (b *Bmattermost) Disconnect() error {
 
 func (b *Bmattermost) JoinChannel(channel string) error {
 	// we can only join channels using the API
-	if b.Config.UseAPI {
+	if b.Config.WebhookURL == "" && b.Config.WebhookBindAddress == "" {
 		return b.mc.JoinChannel(b.mc.GetChannelId(channel, ""))
 	}
 	return nil
@@ -100,7 +106,7 @@ func (b *Bmattermost) Send(msg config.Message) error {
 	if b.Config.PrefixMessagesWithNick {
 		message = nick + message
 	}
-	if !b.Config.UseAPI {
+	if b.Config.WebhookURL != "" {
 		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
 		matterMessage.IconURL = msg.Avatar
 		matterMessage.Channel = channel
@@ -119,12 +125,13 @@ func (b *Bmattermost) Send(msg config.Message) error {
 }
 
 func (b *Bmattermost) handleMatter() {
-	flog.Debugf("Choosing API based Mattermost connection: %t", b.Config.UseAPI)
 	mchan := make(chan *MMMessage)
-	if b.Config.UseAPI {
-		go b.handleMatterClient(mchan)
-	} else {
+	if b.Config.WebhookBindAddress != "" && b.Config.WebhookURL != "" {
+		flog.Debugf("Choosing webhooks based receiving")
 		go b.handleMatterHook(mchan)
+	} else {
+		flog.Debugf("Choosing login (api) based receiving")
+		go b.handleMatterClient(mchan)
 	}
 	for message := range mchan {
 		flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.Account)

bridge/rocketchat/rocketchat.go

@@ -41,10 +41,10 @@ func (b *Brocketchat) Command(cmd string) string {
 
 func (b *Brocketchat) Connect() error {
 	flog.Info("Connecting webhooks")
-	b.mh = matterhook.New(b.Config.URL,
+	b.mh = matterhook.New(b.Config.WebhookURL,
 		matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
 			DisableServer: true})
-	b.rh = rockethook.New(b.Config.URL, rockethook.Config{BindAddress: b.Config.BindAddress})
+	b.rh = rockethook.New(b.Config.WebhookURL, rockethook.Config{BindAddress: b.Config.WebhookBindAddress})
 	go b.handleRocketHook()
 	return nil
 }

bridge/slack/slack.go

@@ -52,11 +52,16 @@ func (b *Bslack) Command(cmd string) string {
 }
 
 func (b *Bslack) Connect() error {
-	flog.Info("Connecting")
-	if !b.Config.UseAPI {
-		b.mh = matterhook.New(b.Config.URL,
-			matterhook.Config{BindAddress: b.Config.BindAddress})
+	if b.Config.WebhookURL != "" && b.Config.WebhookBindAddress != "" {
+		flog.Info("Connecting using webhookurl and webhookbindaddress")
+		b.mh = matterhook.New(b.Config.WebhookURL,
+			matterhook.Config{BindAddress: b.Config.WebhookBindAddress})
+	} else if b.Config.WebhookURL != "" {
+		flog.Info("Connecting using webhookurl (for posting) and token")
+		b.mh = matterhook.New(b.Config.WebhookURL,
+			matterhook.Config{DisableServer: true})
 	} else {
+		flog.Info("Connecting using token")
 		b.sc = slack.New(b.Config.Token)
 		b.rtm = b.sc.NewRTM()
 		go b.rtm.ManageConnection()
@@ -73,7 +78,7 @@ func (b *Bslack) Disconnect() error {
 
 func (b *Bslack) JoinChannel(channel string) error {
 	// we can only join channels using the API
-	if b.Config.UseAPI {
+	if b.Config.WebhookURL == "" || b.Config.WebhookBindAddress == "" {
 		if strings.HasPrefix(b.Config.Token, "xoxb") {
 			// TODO check if bot has already joined channel
 			return nil
@@ -96,7 +101,7 @@ func (b *Bslack) Send(msg config.Message) error {
 	if b.Config.PrefixMessagesWithNick {
 		message = nick + " " + message
 	}
-	if !b.Config.UseAPI {
+	if b.Config.WebhookURL != "" {
 		matterMessage := matterhook.OMessage{IconURL: b.Config.IconURL}
 		matterMessage.Channel = channel
 		matterMessage.UserName = nick
@@ -169,22 +174,24 @@ func (b *Bslack) getChannelByID(ID string) (*slack.Channel, error) {
 }
 
 func (b *Bslack) handleSlack() {
-	flog.Debugf("Choosing API based slack connection: %t", b.Config.UseAPI)
 	mchan := make(chan *MMMessage)
-	if b.Config.UseAPI {
-		go b.handleSlackClient(mchan)
-	} else {
+	if b.Config.WebhookBindAddress != "" && b.Config.WebhookURL != "" {
+		flog.Debugf("Choosing webhooks based receiving")
 		go b.handleMatterHook(mchan)
+	} else {
+		flog.Debugf("Choosing token based receiving")
+		go b.handleSlackClient(mchan)
 	}
 	time.Sleep(time.Second)
 	flog.Debug("Start listening for Slack messages")
 	for message := range mchan {
 		// do not send messages from ourself
-		if b.Config.UseAPI && message.Username == b.si.User.Name {
+		if b.Config.WebhookURL == "" && b.Config.WebhookBindAddress == "" && message.Username == b.si.User.Name {
 			continue
 		}
 		texts := strings.Split(message.Text, "\n")
 		for _, text := range texts {
+			text = b.replaceURL(text)
 			flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.Account)
 			b.Remote <- config.Message{Text: text, Username: message.Username, Channel: message.Channel, Account: b.Account, Avatar: b.getAvatar(message.Username), UserID: message.UserID}
 		}
@@ -279,3 +286,11 @@ func (b *Bslack) replaceMention(text string) string {
 	}
 	return text
 }
+
+func (b *Bslack) replaceURL(text string) string {
+	results := regexp.MustCompile(`<(.*?)\|.*?>`).FindAllStringSubmatch(text, -1)
+	for _, r := range results {
+		text = strings.Replace(text, r[0], r[1], -1)
+	}
+	return text
+}

bridge/steam/steam.go

@@ -0,0 +1,160 @@
+package bsteam
+
+import (
+	"fmt"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/Philipp15b/go-steam"
+	"github.com/Philipp15b/go-steam/protocol/steamlang"
+	"github.com/Philipp15b/go-steam/steamid"
+	log "github.com/Sirupsen/logrus"
+	//"io/ioutil"
+	"strconv"
+	"sync"
+	"time"
+)
+
+type Bsteam struct {
+	c         *steam.Client
+	connected chan struct{}
+	Config    *config.Protocol
+	Remote    chan config.Message
+	Account   string
+	userMap   map[steamid.SteamId]string
+	sync.RWMutex
+}
+
+var flog *log.Entry
+var protocol = "steam"
+
+func init() {
+	flog = log.WithFields(log.Fields{"module": protocol})
+}
+
+func New(cfg config.Protocol, account string, c chan config.Message) *Bsteam {
+	b := &Bsteam{}
+	b.Config = &cfg
+	b.Remote = c
+	b.Account = account
+	b.userMap = make(map[steamid.SteamId]string)
+	b.connected = make(chan struct{})
+	return b
+}
+
+func (b *Bsteam) Connect() error {
+	flog.Info("Connecting")
+	b.c = steam.NewClient()
+	go b.handleEvents()
+	go b.c.Connect()
+	select {
+	case <-b.connected:
+		flog.Info("Connection succeeded")
+	case <-time.After(time.Second * 30):
+		return fmt.Errorf("connection timed out")
+	}
+	return nil
+}
+
+func (b *Bsteam) Disconnect() error {
+	b.c.Disconnect()
+	return nil
+
+}
+
+func (b *Bsteam) JoinChannel(channel string) error {
+	id, err := steamid.NewId(channel)
+	if err != nil {
+		return err
+	}
+	b.c.Social.JoinChat(id)
+	return nil
+}
+
+func (b *Bsteam) Send(msg config.Message) error {
+	id, err := steamid.NewId(msg.Channel)
+	if err != nil {
+		return err
+	}
+	b.c.Social.SendMessage(id, steamlang.EChatEntryType_ChatMsg, msg.Username+msg.Text)
+	return nil
+}
+
+func (b *Bsteam) getNick(id steamid.SteamId) string {
+	b.RLock()
+	defer b.RUnlock()
+	if name, ok := b.userMap[id]; ok {
+		return name
+	}
+	return "unknown"
+}
+
+func (b *Bsteam) handleEvents() {
+	myLoginInfo := new(steam.LogOnDetails)
+	myLoginInfo.Username = b.Config.Login
+	myLoginInfo.Password = b.Config.Password
+	myLoginInfo.AuthCode = b.Config.AuthCode
+	// Attempt to read existing auth hash to avoid steam guard.
+	// Maybe works
+	//myLoginInfo.SentryFileHash, _ = ioutil.ReadFile("sentry")
+	for event := range b.c.Events() {
+		//flog.Info(event)
+		switch e := event.(type) {
+		case *steam.ChatMsgEvent:
+			flog.Debugf("Receiving ChatMsgEvent: %#v", e)
+			flog.Debugf("Sending message from %s on %s to gateway", b.getNick(e.ChatterId), b.Account)
+			// for some reason we have to remove 0x18000000000000
+			channel := int64(e.ChatRoomId) - 0x18000000000000
+			msg := config.Message{Username: b.getNick(e.ChatterId), Text: e.Message, Channel: strconv.FormatInt(channel, 10), Account: b.Account, UserID: strconv.FormatInt(int64(e.ChatterId), 10)}
+			b.Remote <- msg
+		case *steam.PersonaStateEvent:
+			flog.Debugf("PersonaStateEvent: %#v\n", e)
+			b.Lock()
+			b.userMap[e.FriendId] = e.Name
+			b.Unlock()
+		case *steam.ConnectedEvent:
+			b.c.Auth.LogOn(myLoginInfo)
+		case *steam.MachineAuthUpdateEvent:
+			/*
+				flog.Info("authupdate", e)
+				flog.Info("hash", e.Hash)
+				ioutil.WriteFile("sentry", e.Hash, 0666)
+			*/
+		case *steam.LogOnFailedEvent:
+			flog.Info("Logon failed", e)
+			switch e.Result {
+			case steamlang.EResult_AccountLogonDeniedNeedTwoFactorCode:
+				{
+					flog.Info("Steam guard isn't letting me in! Enter 2FA code:")
+					var code string
+					fmt.Scanf("%s", &code)
+					myLoginInfo.TwoFactorCode = code
+				}
+			case steamlang.EResult_AccountLogonDenied:
+				{
+					flog.Info("Steam guard isn't letting me in! Enter auth code:")
+					var code string
+					fmt.Scanf("%s", &code)
+					myLoginInfo.AuthCode = code
+				}
+			default:
+				log.Errorf("LogOnFailedEvent: ", e.Result)
+				// TODO: Handle EResult_InvalidLoginAuthCode
+				return
+			}
+		case *steam.LoggedOnEvent:
+			flog.Debugf("LoggedOnEvent: %#v", e)
+			b.connected <- struct{}{}
+			flog.Debugf("setting online")
+			b.c.Social.SetPersonaState(steamlang.EPersonaState_Online)
+		case *steam.DisconnectedEvent:
+			flog.Info("Disconnected")
+			flog.Info("Attempting to reconnect...")
+			b.c.Connect()
+		case steam.FatalErrorEvent:
+			flog.Error(e)
+		case error:
+			flog.Error(e)
+		default:
+			flog.Debugf("unknown event %#v", e)
+		}
+	}
+}

bridge/telegram/telegram.go

@@ -114,18 +114,18 @@ func (b *Btelegram) handleRecv(updates <-chan tgbotapi.Update) {
 		if username == "" {
 			username = "unknown"
 		}
-		if message.Sticker != nil {
+		if message.Sticker != nil && b.Config.UseInsecureURL {
 			text = text + " " + b.getFileDirectURL(message.Sticker.FileID)
 		}
-		if message.Video != nil {
+		if message.Video != nil && b.Config.UseInsecureURL {
 			text = text + " " + b.getFileDirectURL(message.Video.FileID)
 		}
-		if message.Photo != nil {
+		if message.Photo != nil && b.Config.UseInsecureURL {
 			photos := *message.Photo
 			// last photo is the biggest
 			text = text + " " + b.getFileDirectURL(photos[len(photos)-1].FileID)
 		}
-		if message.Document != nil {
+		if message.Document != nil && b.Config.UseInsecureURL {
 			text = text + " " + message.Document.FileName + " : " + b.getFileDirectURL(message.Document.FileID)
 		}
 		if text != "" {

changelog.md

@@ -1,3 +1,44 @@
+# v0.16.0-rc2
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## Bugfix since rc1
+* steam: Fix channel id bug in steam (channels are off by 0x18000000000000)
+* telegram: Add UseInsecureURL option for telegram (default false)
+  WARNING! If enabled this will relay GIF/stickers/documents and other attachments as URLs
+  Those URLs will contain your bot-token. This may not be what you want.
+  For now there is no secure way to relay GIF/stickers/documents without seeing your token.
+* irc: detect charset and try to convert it to utf-8 before sending it to other bridges. #209 #210
+* general: various improvements
+
+
+# v0.16.0-rc1
+## Breaking Changes
+* URL,UseAPI,BindAddress is deprecated. Your config has to be updated.
+  * URL => WebhookURL
+  * BindAddress => WebhookBindAddress
+  * UseAPI => removed 
+  This change allows you to specify a WebhookURL and a token (slack,discord), so that
+  messages will be sent with the webhook, but received via the token (API)
+  If you have not specified WebhookURL and WebhookBindAddress the API (login or token) 
+  will be used automatically. (no need for UseAPI)
+
+## New features
+* steam: New protocol support added (http://store.steampowered.com/)
+* discord: WebhookURL posting support added (thanks @saury07) #204
+  Discord API does not allow to change the name of the user posting, but webhooks does.
+
+## Bugfix
+* general: samechannelgateway now relays messages correct again #207
+* slack: Remove label from URLs (slack). #205
+
 # v0.15.0
 ## New features
 * general: add option IgnoreMessages for all protocols (see mattebridge.toml.sample)

gateway/gateway.go

@@ -5,6 +5,7 @@ import (
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
 	log "github.com/Sirupsen/logrus"
+	//	"github.com/davecgh/go-spew/spew"
 	"regexp"
 	"strings"
 	"time"
@@ -181,6 +182,17 @@ func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []con
 		if _, ok := gw.Channels[getChannelID(*msg)]; !ok {
 			continue
 		}
+		// add gateway to message
+		gw.validGatewayDest(msg, channel)
+
+		// do samechannelgateway logic
+		if channel.SameChannel[msg.Gateway] {
+			if msg.Channel == channel.Name && msg.Account != dest.Account {
+				channels = append(channels, *channel)
+			}
+			continue
+		}
+
 		if channel.Direction == "out" && channel.Account == dest.Account && gw.validGatewayDest(msg, channel) {
 			channels = append(channels, *channel)
 		}

matterbridge.go

@@ -12,7 +12,7 @@ import (
 )
 
 var (
-	version = "0.15.0"
+	version = "0.16.0-rc2"
 	githash string
 )
 

matterbridge.toml.sample

@@ -199,43 +199,17 @@ ShowJoinPart=false
 #REQUIRED
 
 [mattermost.work]
-#### Settings for webhook matterbridge.
-#### These settings will not be used when useAPI is enabled
-
-#Url is your incoming webhook url as specified in mattermost. 
-#See account settings - integrations - incoming webhooks on mattermost.
-#REQUIRED (unless useAPI=true)
-URL="https://yourdomain/hooks/yourhookkey"
-
-#Address to listen on for outgoing webhook requests from mattermost.
-#See account settings - integrations - outgoing webhooks on mattermost.
-#This setting will not be used when using -plus switch which doesn't use 
-#webhooks
-#REQUIRED (unless useAPI=true)
-BindAddress="0.0.0.0:9999"
-
-#Icon that will be showed in mattermost. 
-#OPTIONAL
-IconURL="http://youricon.png"
-
-#### Settings for matterbridge -plus
-#### Thse settings will only be used when using the -plus switch.
-
-#### Settings for using matterbridge API
-#OPTIONAL
-useAPI=false
-
 #The mattermost hostname. (do not prefix it with http or https)
-#REQUIRED (when useAPI=true)
+#REQUIRED (when not using webhooks)
 Server="yourmattermostserver.domain" 
 
 #Your team on mattermost. 
-#REQUIRED (when useAPI=true)
+#REQUIRED (when not using webhooks)
 Team="yourteam"
 
 #login/pass of your bot. 
 #Use a dedicated user for this and not your own! 
-#REQUIRED (when useAPI=true)
+#REQUIRED (when not using webhooks)
 Login="yourlogin"
 Password="yourpass"
 
@@ -243,7 +217,30 @@ Password="yourpass"
 #OPTIONAL (default false)
 NoTLS=false
 
-#### Shared settings for matterbridge and -plus
+#### Settings for webhook matterbridge.
+#NOT RECOMMENDED TO USE INCOMING/OUTGOING WEBHOOK. USE DEDICATED BOT USER WHEN POSSIBLE!
+#You don't need to configure this, if you have configured the settings 
+#above.
+
+#Url is your incoming webhook url as specified in mattermost. 
+#See account settings - integrations - incoming webhooks on mattermost.
+#If specified, messages will be sent to mattermost using this URL
+#OPTIONAL
+WebhookURL="https://yourdomain/hooks/yourhookkey"
+
+#Address to listen on for outgoing webhook requests from mattermost.
+#See account settings - integrations - outgoing webhooks on mattermost.
+#If specified, messages will be received from mattermost on this ip:port
+#(this will only work if WebhookURL above is also configured)
+#OPTIONAL 
+WebhookBindAddress="0.0.0.0:9999"
+
+#Icon that will be showed in mattermost. 
+#This only works when WebhookURL is configured
+#OPTIONAL
+IconURL="http://youricon.png"
+
+#### End settings for webhook matterbridge.
 
 #Enable to not verify the certificate on your mattermost server. 
 #e.g. when using selfsigned certificates
@@ -345,15 +342,20 @@ ShowJoinPart=false
 #In this example we use [slack.hobby]
 #REQUIRED
 [slack.hobby]
-#### Settings for webhook matterbridge.
-#### These settings will not be used when useAPI is enabled
+#Token to connect with the Slack API
+#You'll have to use a test/api-token using a dedicated user and not a bot token.
+#See https://github.com/42wim/matterbridge/issues/75 for more info.
+#Use https://api.slack.com/custom-integrations/legacy-tokens
+#REQUIRED (when not using webhooks)
+Token="yourslacktoken"
 
+#### Settings for webhook matterbridge.
 #NOT RECOMMENDED TO USE INCOMING/OUTGOING WEBHOOK. USE SLACK API
 #AND DEDICATED BOT USER WHEN POSSIBLE!
 #Url is your incoming webhook url as specified in slack
 #See account settings - integrations - incoming webhooks on slack
-#REQUIRED (unless useAPI=true)
-URL="https://hooks.slack.com/services/yourhook"
+#OPTIONAL
+WebhookURL="https://hooks.slack.com/services/yourhook"
 
 #NOT RECOMMENDED TO USE INCOMING/OUTGOING WEBHOOK. USE SLACK API
 #AND DEDICATED BOT USER WHEN POSSIBLE!
@@ -361,21 +363,8 @@ URL="https://hooks.slack.com/services/yourhook"
 #See account settings - integrations - outgoing webhooks on slack
 #This setting will not be used when useAPI is eanbled
 #webhooks
-#REQUIRED (unless useAPI=true)
-BindAddress="0.0.0.0:9999"
-
-#### Settings for using slack API (RECOMMENDED)
 #OPTIONAL
-useAPI=false
-
-#Token to connect with the Slack API
-#You'll have to use a test/api-token using a dedicated user and not a bot token.
-#See https://github.com/42wim/matterbridge/issues/75 for more info.
-#Use https://api.slack.com/custom-integrations/legacy-tokens
-#REQUIRED (when useAPI=true)
-Token="yourslacktoken"
-
-#### Shared settings for webhooks and API
+WebhookBindAddress="0.0.0.0:9999"
 
 #Icon that will be showed in slack
 #The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
@@ -450,6 +439,14 @@ Token="Yourtokenhere"
 #REQUIRED
 Server="yourservername"
 
+#Shows title, description and URL of embedded messages (sent by other bots)
+#OPTIONAL (default false)
+ShowEmbeds=false
+
+#Specify WebhookURL. If given, will relay messages using the Webhook, which gives a better look to messages.
+#OPTIONAL (default empty)
+WebhookURL="Yourwebhooktokenhere"
+
 #Disable sending of edits to other bridges
 #OPTIONAL (default false)
 EditDisable=false
@@ -506,6 +503,12 @@ MessageFormat=""
 #OPTIONAL (default false)
 UseFirstName=false
 
+#WARNING! If enabled this will relay GIF/stickers/documents and other attachments as URLs
+#Those URLs will contain your bot-token. This may not be what you want.
+#For now there is no secure way to relay GIF/stickers/documents without seeing your token.
+#OPTIONAL (default false)
+UseInsecureURL=false
+
 #Disable sending of edits to other bridges
 #OPTIONAL (default false)
 EditDisable=false
@@ -551,12 +554,12 @@ ShowJoinPart=false
 #Read #https://rocket.chat/docs/administrator-guides/integrations/#how-to-create-a-new-incoming-webhook
 #See administration - integrations - new integration - incoming webhook
 #REQUIRED
-URL="https://yourdomain/hooks/yourhookkey"
+WebhookURL="https://yourdomain/hooks/yourhookkey"
 
 #Address to listen on for outgoing webhook requests from rocketchat.
 #See administration - integrations - new integration - outgoing webhook
 #REQUIRED 
-BindAddress="0.0.0.0:9999"
+WebhookBindAddress="0.0.0.0:9999"
 
 #Your nick/username as specified in your incoming webhook "Post as" setting
 #REQUIRED
@@ -656,6 +659,55 @@ RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
 #OPTIONAL (default false)
 ShowJoinPart=false
 
+###################################################################
+#steam section
+###################################################################
+[steam]
+#You can configure multiple servers "[steam.name]" or "[steam.name2]"
+#In this example we use [steam.gamechat]
+#REQUIRED
+
+[steam.gamechat]
+#login/pass of your bot. 
+#Use a dedicated user for this and not your own account! 
+#REQUIRED 
+Login="yourlogin"
+Password="yourpass"
+
+#steamguard mail authcode (not the 2FA code)
+#OPTIONAL 
+Authcode="ABCE12"
+
+#Whether to prefix messages from other bridges to matrix with the sender's nick. 
+#Useful if username overrides for incoming webhooks isn't enabled on the 
+#matrix server. If you set PrefixMessagesWithNick to true, each message 
+#from bridge to matrix will by default be prefixed by the RemoteNickFormat setting. i
+#OPTIONAL (default false)
+PrefixMessagesWithNick=false
+
+#Nicks you want to ignore. 
+#Messages from those users will not be sent to other bridges.
+#OPTIONAL
+IgnoreNicks="spammer1 spammer2"
+
+#Messages you want to ignore. 
+#Messages matching these regexp will be ignored and not sent to other bridges
+#See https://regex-golang.appspot.com/assets/html/index.html for more regex info
+#OPTIONAL (example below ignores messages starting with ~~ or messages containing badword
+IgnoreMessages="^~~ badword"
+
+#RemoteNickFormat defines how remote users appear on this bridge 
+#The string "{NICK}" (case sensitive) will be replaced by the actual nick / username.
+#The string "{BRIDGE}" (case sensitive) will be replaced by the sending bridge
+#The string "{PROTOCOL}" (case sensitive) will be replaced by the protocol used by the bridge
+#OPTIONAL (default empty)
+RemoteNickFormat="[{PROTOCOL}] <{NICK}> "
+
+#Enable to show users joins/parts from other bridges 
+#Only works hiding/show messages from irc and mattermost bridge for now
+#OPTIONAL (default false)
+ShowJoinPart=false
+
 
 ###################################################################
 #API
@@ -744,6 +796,9 @@ enable=true
     #rocketchat - #channel (# is required (also needed for private channels!)
     #matrix     - #channel:server (eg #yourchannel:matrix.org) 
     #           - encrypted rooms are not supported in matrix
+    #steam      - chatid (a large number). 
+    #             The number in the URL when you click "enter chat room" in the browser
+    #                  
     #REQUIRED
     channel="#testing"
 

matterclient/matterclient.go

@@ -65,6 +65,7 @@ type MMClient struct {
 	WsSequence    int64
 	WsPingChan    chan *model.WebSocketResponse
 	ServerVersion string
+	OnWsConnect   func()
 }
 
 func New(login, pass, team, server string) *MMClient {
@@ -100,10 +101,8 @@ func (m *MMClient) Login() error {
 		Jitter: true,
 	}
 	uriScheme := "https://"
-	wsScheme := "wss://"
 	if m.NoTLS {
 		uriScheme = "http://"
-		wsScheme = "ws://"
 	}
 	// login to mattermost
 	m.Client = model.NewClient(uriScheme + m.Credentials.Server)
@@ -182,6 +181,24 @@ func (m *MMClient) Login() error {
 	// set our team id as default route
 	m.Client.SetTeamId(m.Team.Id)
 
+	m.wsConnect()
+
+	return nil
+}
+
+func (m *MMClient) wsConnect() {
+	b := &backoff.Backoff{
+		Min:    time.Second,
+		Max:    5 * time.Minute,
+		Jitter: true,
+	}
+
+	m.WsConnected = false
+	wsScheme := "wss://"
+	if m.NoTLS {
+		wsScheme = "ws://"
+	}
+
 	// setup websocket connection
 	wsurl := wsScheme + m.Credentials.Server + model.API_URL_SUFFIX_V3 + "/users/websocket"
 	header := http.Header{}
@@ -190,6 +207,7 @@ func (m *MMClient) Login() error {
 	m.log.Debugf("WsClient: making connection: %s", wsurl)
 	for {
 		wsDialer := &websocket.Dialer{Proxy: http.ProxyFromEnvironment, TLSClientConfig: &tls.Config{InsecureSkipVerify: m.SkipTLSVerify}}
+		var err error
 		m.WsClient, _, err = wsDialer.Dial(wsurl, header)
 		if err != nil {
 			d := b.Duration()
@@ -199,15 +217,12 @@ func (m *MMClient) Login() error {
 		}
 		break
 	}
-	b.Reset()
 
 	m.log.Debug("WsClient: connected")
 	m.WsSequence = 1
 	m.WsPingChan = make(chan *model.WebSocketResponse)
 	// only start to parse WS messages when login is completely done
 	m.WsConnected = true
-
-	return nil
 }
 
 func (m *MMClient) Logout() error {
@@ -215,6 +230,10 @@ func (m *MMClient) Logout() error {
 	m.WsQuit = true
 	m.WsClient.Close()
 	m.WsClient.UnderlyingConn().Close()
+	if strings.Contains(m.Credentials.Pass, model.SESSION_COOKIE_TOKEN) {
+		m.log.Debug("Not invalidating session in logout, credential is a token")
+		return nil
+	}
 	_, err := m.Client.Logout()
 	if err != nil {
 		return err
@@ -240,12 +259,12 @@ func (m *MMClient) WsReceiver() {
 		if _, rawMsg, err = m.WsClient.ReadMessage(); err != nil {
 			m.log.Error("error:", err)
 			// reconnect
-			m.Login()
+			m.wsConnect()
 		}
 
 		var event model.WebSocketEvent
 		if err := json.Unmarshal(rawMsg, &event); err == nil && event.IsValid() {
-			m.log.Debugf("WsReceiver: %#v", event)
+			m.log.Debugf("WsReceiver event: %#v", event)
 			msg := &Message{Raw: &event, Team: m.Credentials.Team}
 			m.parseMessage(msg)
 			m.MessageChan <- msg
@@ -254,7 +273,7 @@ func (m *MMClient) WsReceiver() {
 
 		var response model.WebSocketResponse
 		if err := json.Unmarshal(rawMsg, &response); err == nil && response.IsValid() {
-			m.log.Debugf("WsReceiver: %#v", response)
+			m.log.Debugf("WsReceiver response: %#v", response)
 			m.parseResponse(response)
 			continue
 		}
@@ -287,7 +306,8 @@ func (m *MMClient) parseActionPost(rmsg *Message) {
 	data := model.PostFromJson(strings.NewReader(rmsg.Raw.Data["post"].(string)))
 	// we don't have the user, refresh the userlist
 	if m.GetUser(data.UserId) == nil {
-		m.UpdateUsers()
+		m.log.Infof("User %s is not known, ignoring message %s", data)
+		return
 	}
 	rmsg.Username = m.GetUserName(data.UserId)
 	rmsg.Channel = m.GetChannelName(data.ChannelId)
@@ -348,9 +368,21 @@ func (m *MMClient) GetChannelName(channelId string) string {
 	m.RLock()
 	defer m.RUnlock()
 	for _, t := range m.OtherTeams {
-		for _, channel := range append(*t.Channels, *t.MoreChannels...) {
-			if channel.Id == channelId {
-				return channel.Name
+		if t == nil {
+			continue
+		}
+		if t.Channels != nil {
+			for _, channel := range *t.Channels {
+				if channel.Id == channelId {
+					return channel.Name
+				}
+			}
+		}
+		if t.MoreChannels != nil {
+			for _, channel := range *t.MoreChannels {
+				if channel.Id == channelId {
+					return channel.Name
+				}
 			}
 		}
 	}
@@ -496,17 +528,15 @@ func (m *MMClient) UpdateLastViewed(channelId string) {
 }
 
 func (m *MMClient) UsernamesInChannel(channelId string) []string {
-	res, err := m.Client.GetMyChannelMembers()
+	res, err := m.Client.GetProfilesInChannel(channelId, 0, 50000, "")
 	if err != nil {
 		m.log.Errorf("UsernamesInChannel(%s) failed: %s", channelId, err)
 		return []string{}
 	}
-	members := res.Data.(*model.ChannelMembers)
+	members := res.Data.(map[string]*model.User)
 	result := []string{}
-	for _, channel := range *members {
-		if channel.ChannelId == channelId {
-			result = append(result, m.GetUser(channel.UserId).Username)
-		}
+	for _, member := range members {
+		result = append(result, member.Nickname)
 	}
 	return result
 }
@@ -598,7 +628,9 @@ func (m *MMClient) GetTeamFromChannel(channelId string) string {
 	var channels []*model.Channel
 	for _, t := range m.OtherTeams {
 		channels = append(channels, *t.Channels...)
-		channels = append(channels, *t.MoreChannels...)
+		if t.MoreChannels != nil {
+			channels = append(channels, *t.MoreChannels...)
+		}
 		for _, c := range channels {
 			if c.Id == channelId {
 				return t.Id
@@ -630,8 +662,17 @@ func (m *MMClient) GetUsers() map[string]*model.User {
 }
 
 func (m *MMClient) GetUser(userId string) *model.User {
-	m.RLock()
-	defer m.RUnlock()
+	m.Lock()
+	defer m.Unlock()
+	u, ok := m.Users[userId]
+	if !ok {
+		res, err := m.Client.GetProfilesByIds([]string{userId})
+		if err != nil {
+			return nil
+		}
+		u = res.Data.(map[string]*model.User)[userId]
+		m.Users[userId] = u
+	}
 	return m.Users[userId]
 }
 
@@ -644,7 +685,7 @@ func (m *MMClient) GetUserName(userId string) string {
 }
 
 func (m *MMClient) GetStatus(userId string) string {
-	res, err := m.Client.GetStatuses()
+	res, err := m.Client.GetStatusesByIds([]string{userId})
 	if err != nil {
 		return ""
 	}
@@ -684,6 +725,12 @@ func (m *MMClient) GetTeamId() string {
 }
 
 func (m *MMClient) StatusLoop() {
+	retries := 0
+	backoff := time.Second * 60
+	if m.OnWsConnect != nil {
+		m.OnWsConnect()
+	}
+	m.log.Debug("StatusLoop:", m.OnWsConnect)
 	for {
 		if m.WsQuit {
 			return
@@ -694,14 +741,23 @@ func (m *MMClient) StatusLoop() {
 			select {
 			case <-m.WsPingChan:
 				m.log.Debug("WS PONG received")
+				backoff = time.Second * 60
 			case <-time.After(time.Second * 5):
-				m.Logout()
-				m.WsQuit = false
-				m.Login()
-				go m.WsReceiver()
+				if retries > 3 {
+					m.Logout()
+					m.WsQuit = false
+					m.Login()
+					if m.OnWsConnect != nil {
+						m.OnWsConnect()
+					}
+					go m.WsReceiver()
+				} else {
+					retries++
+					backoff = time.Second * 5
+				}
 			}
 		}
-		time.Sleep(time.Second * 60)
+		time.Sleep(backoff)
 	}
 }
 

vendor/github.com/Philipp15b/go-steam/LICENSE.txt

@@ -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.

vendor/github.com/Philipp15b/go-steam/auth.go

@@ -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(),
+	})
+}

vendor/github.com/Philipp15b/go-steam/auth_events.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/client.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/client_events.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/community/community.go

@@ -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,
+		},
+	})
+}

vendor/github.com/Philipp15b/go-steam/connection.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/cryptoutil.go

@@ -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)
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/ecb.go

@@ -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:]
+	}
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/pkcs7.go

@@ -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)]
+}

vendor/github.com/Philipp15b/go-steam/cryptoutil/rsa.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/doc.go

@@ -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

vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/system.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory.go

@@ -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`
+}

vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory_apps.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/economy/inventory/own.go

@@ -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)
+	})
+}

vendor/github.com/Philipp15b/go-steam/economy/inventory/partial.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/gamecoordinator.go

@@ -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,
+	}))
+}

vendor/github.com/Philipp15b/go-steam/generator/generator.go

@@ -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)
+	}
+}

vendor/github.com/Philipp15b/go-steam/gsbot/gsbot.go

@@ -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()
+	}
+}

vendor/github.com/Philipp15b/go-steam/gsbot/gsbot/gsbot.go

@@ -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)
+		}
+	}
+}

vendor/github.com/Philipp15b/go-steam/jsont/jsont.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/keys.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/netutil/addr.go

@@ -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)
+}

vendor/github.com/Philipp15b/go-steam/netutil/http.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/netutil/url.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/notifications.go

@@ -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})
+		}
+	}
+}

vendor/github.com/Philipp15b/go-steam/notifications_events.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/protocol/doc.go

@@ -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

vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/msg.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/packet.go

@@ -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))
+}

vendor/github.com/Philipp15b/go-steam/protocol/internal.go

@@ -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)
+}

vendor/github.com/Philipp15b/go-steam/protocol/msg.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/protocol/packet.go

@@ -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,
+	}
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/app_ticket.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/base.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/content_manifest.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/base.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/credentials.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/deviceauth.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/gamenotifications.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/offline.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/parental.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/partnerapps.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/player.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/protocol/steamlang/steamlang.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/rwu/rwu.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/servers.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/social.go

@@ -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
+		})
+	}
+}

vendor/github.com/Philipp15b/go-steam/social_events.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/socialcache/chats.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/socialcache/friends.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/socialcache/groups.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/steam_directory.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/steamid/steamid.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/tf2/protocol/econ.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/tf2/protocol/protobuf/system.pb.go

@@ -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,
+}

vendor/github.com/Philipp15b/go-steam/tf2/tf2.go

@@ -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{})
+}

vendor/github.com/Philipp15b/go-steam/trade/actions.go

@@ -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())
+}

vendor/github.com/Philipp15b/go-steam/trade/doc.go

@@ -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

vendor/github.com/Philipp15b/go-steam/trade/trade.go

@@ -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)
+}

vendor/github.com/Philipp15b/go-steam/trade/tradeapi/status.go

@@ -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"`
+}

vendor/github.com/Philipp15b/go-steam/trade/tradeapi/trade.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/trade/types.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/tradeoffer/client.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/tradeoffer/error.go

@@ -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...)}
+}

vendor/github.com/Philipp15b/go-steam/tradeoffer/escrow.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/tradeoffer/receipt.go

@@ -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
+}

vendor/github.com/Philipp15b/go-steam/tradeoffer/tradeoffer.go

@@ -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"`
+}