steam

package module
v0.0.0-...-ab14012 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 22, 2015 License: BSD-3-Clause Imports: 35 Imported by: 0

README

Steam for Go

This library implements Steam's protocol to allow automation of different actions on Steam without running an actual Steam client. It is based on SteamKit2, a .NET library.

In addition, it contains APIs to Steam Community features, like trade offers and inventories.

Some of the currently implemented features:

  • Trading and trade offers, including inventories and notifications
  • Friend and group management
  • Chatting with friends
  • Persona states (online, offline, looking to trade, etc.)
  • SteamGuard
  • Team Fortress 2: Crafting, moving, naming and deleting items

If this is useful to you, there's also the go-steamapi package that wraps some of the official Steam Web API's types.

Installation

go get github.com/Philipp15b/go-steam

Usage

You can view the documentation with the godoc tool or online on godoc.org.

You should also take a look at the following sub-packages:

Updating go-steam to a new SteamKit version

To update go-steam to a new version of SteamKit, do the following:

go get github.com/golang/protobuf/protoc-gen-go/
git submodule init && git submodule update
cd generator
go run generator.go clean proto steamlang

Replace steamlang with steamlang:nodebug if you want to exclude the String() string methods for the generated SteamLanguage enums. They make debugging much easier, but do increase binary size a bit.

Make sure that $GOPATH/bin / protoc-gen-go is in your $PATH. You'll also need protoc, the protocol buffer compiler. At the moment, we use Protocol Buffers 2.6.1 with proco-gen-go-16256d3.

To compile the Steam Language files, you also need the .NET Framework on Windows or mono on other operating systems.

Apply the protocol changes where necessary.

License

Steam for Go is licensed under the New BSD License. More information can be found in LICENSE.txt.

Documentation

Overview

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. 

package main

import (
	"github.com/Philipp15b/go-steam"
	"github.com/Philipp15b/go-steam/internal/steamlang"
	"io/ioutil"
	"log"
)

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.

Index

Constants

This section is empty.

Variables

View Source 
var CMServers = [][]string{
	{

		"72.165.61.174:27017",
		"72.165.61.174:27018",
		"72.165.61.175:27017",
		"72.165.61.175:27018",
		"72.165.61.176:27017",
		"72.165.61.176:27018",
		"72.165.61.185:27017",
		"72.165.61.185:27018",
		"72.165.61.187:27017",
		"72.165.61.187:27018",
		"72.165.61.188:27017",
		"72.165.61.188:27018",

		"209.197.29.196:27017",
		"209.197.29.197:27017",
	},
	{

		"146.66.152.12:27017",
		"146.66.152.12:27018",
		"146.66.152.12:27019",
		"146.66.152.13:27017",
		"146.66.152.13:27018",
		"146.66.152.13:27019",
		"146.66.152.14:27017",
		"146.66.152.14:27018",
		"146.66.152.14:27019",
		"146.66.152.15:27017",
		"146.66.152.15:27018",
		"146.66.152.15:27019",
	},
	{
		"103.28.54.10:27017",
		"103.28.54.11:27017",
	},
}

CMServers contains a list of worlwide servers

Functions

func GetPublicKey 

func GetPublicKey(universe EUniverse) *rsa.PublicKey

func GetRandomCM 

func GetRandomCM() *netutil.PortAddr

GetRandomCM returns back a random server anywhere

func GetRandomEuropeCM 

func GetRandomEuropeCM() *netutil.PortAddr

GetRandomEuropeCM returns back a random server in europe

func GetRandomNorthAmericaCM 

func GetRandomNorthAmericaCM() *netutil.PortAddr

GetRandomNorthAmericaCM returns back a random server in north america

func GetRandomSingaporeCM 

func GetRandomSingaporeCM() *netutil.PortAddr

GetRandomSingaporeCM returns back a random server in singapore

Types

type AccountInfoEvent 

type AccountInfoEvent struct {
	PersonaName          string
	Country              string
	PasswordSalt         []byte
	PasswordSHADisgest   []byte
	CountAuthedComputers int32
	LockedWithIpt        bool
	AccountFlags         EAccountFlags
	FacebookId           uint64 `json:",string"`
	FacebookName         string
}

type Auth 

type Auth struct {
	// contains filtered or unexported fields
}

func (*Auth) HandlePacket 

func (a *Auth) HandlePacket(packet *Packet)

func (*Auth) LogOn 

func (a *Auth) LogOn(details *LogOnDetails)

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.

type ChatActionResultEvent 

type ChatActionResultEvent struct {
	ChatRoomId SteamId `json:",string"`
	ChatterId  SteamId `json:",string"`
	Action     EChatAction
	Result     EChatActionResult
}

Fired when a chat action has completed

type ChatEnterEvent 

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 joining a chat

type ChatInviteEvent 

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 when a chat invite is received

type ChatMemberInfoEvent 

type ChatMemberInfoEvent struct {
	ChatRoomId      SteamId `json:",string"`
	Type            EChatInfoType
	StateChangeInfo StateChangeDetails
}

Fired in response to a chat member's info being received

type ChatMsgEvent 

type ChatMsgEvent struct {
	ChatRoomId SteamId `json:",string"` // not set for friend messages
	ChatterId  SteamId `json:",string"`
	Message    string
	EntryType  EChatEntryType
}

Fired when the client receives a message from either a friend or a chat room

func (*ChatMsgEvent) IsMessage 

func (c *ChatMsgEvent) IsMessage() bool

Whether the type is ChatMsg

type ClanEventDetails 

type ClanEventDetails struct {
	Id         uint64 `json:",string"`
	EventTime  uint32
	Headline   string
	GameId     uint64 `json:",string"`
	JustPosted bool
}

type ClanStateEvent 

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
}

Fired when a clan's state has been changed

type Client 

type Client struct {
	Auth          *Auth
	Social        *Social
	Web           *Web
	Notifications *Notifications
	Trading       *Trading
	GC            *GameCoordinator

	ConnectionTimeout time.Duration
	// contains filtered or unexported fields
}

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.

func NewClient 

func NewClient() *Client

func (*Client) Connect 

func (c *Client) Connect() *netutil.PortAddr

Connects to a random server of the included list of connection managers and returns the address. If this client is already connected, it is disconnected first.

You will receive a ServerListEvent after logging in which contains a new list of servers of which you should choose one yourself and connect with ConnectTo since the included list may not always be up to date.

func (*Client) ConnectEurope 

func (c *Client) ConnectEurope() *netutil.PortAddr

ConnectEurope Connects to a random Europe server on the Steam network

func (*Client) ConnectNorthAmerica 

func (c *Client) ConnectNorthAmerica() *netutil.PortAddr

ConnectNorthAmerica Connects to a random North American server on the Steam network

func (*Client) ConnectSingapore 

func (c *Client) ConnectSingapore() *netutil.PortAddr

ConnectSingapore Connects to a random SG server on the Steam network

func (*Client) ConnectTo 

func (c *Client) ConnectTo(addr *netutil.PortAddr)

Connects to a specific server. If this client is already connected, it is disconnected first.

func (*Client) ConnectToBind 

func (c *Client) ConnectToBind(addr *netutil.PortAddr, local *net.TCPAddr)

Connects to a specific server, and binds to a specified local IP

func (*Client) Connected 

func (c *Client) Connected() bool

func (*Client) Disconnect 

func (c *Client) Disconnect()

func (*Client) Emit 

func (c *Client) Emit(event interface{})

func (*Client) Errorf 

func (c *Client) Errorf(format string, a ...interface{})

Emits an error formatted with fmt.Errorf.

func (*Client) Events 

func (c *Client) Events() <-chan interface{}

Get the event channel. By convention all events are pointers, except for errors. It is never closed.

func (*Client) Fatalf 

func (c *Client) Fatalf(format string, a ...interface{})

Emits a FatalErrorEvent formatted with fmt.Errorf and disconnects.

func (*Client) GetNextJobId 

func (c *Client) GetNextJobId() JobId

func (*Client) RegisterPacketHandler 

func (c *Client) RegisterPacketHandler(handler PacketHandler)

Registers a PacketHandler that receives all incoming packets.

func (*Client) SessionId 

func (c *Client) SessionId() int32

func (*Client) SteamId 

func (c *Client) SteamId() SteamId

func (*Client) Write 

func (c *Client) Write(msg IMsg)

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.

type ClientCMListEvent 

type ClientCMListEvent struct {
	Addresses []*netutil.PortAddr
}

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 ConnectedEvent 

type ConnectedEvent struct{}

type DisconnectedEvent 

type DisconnectedEvent struct{}

type FatalErrorEvent 

type FatalErrorEvent error

When this event is emitted by the Client, the connection is automatically closed. This may be caused by a network error, for example.

type FriendAddedEvent 

type FriendAddedEvent struct {
	Result      EResult
	SteamId     SteamId `json:",string"`
	PersonaName string
}

Fired in response to adding a friend to your friends list

type FriendStateEvent 

type FriendStateEvent struct {
	SteamId      SteamId `json:",string"`
	Relationship EFriendRelationship
}

func (*FriendStateEvent) IsFriend 

func (f *FriendStateEvent) IsFriend() bool

type FriendsListEvent 

type FriendsListEvent struct{}

type GCPacketHandler 

type GCPacketHandler interface {
	HandleGCPacket(*GCPacket)
}

type GameCoordinator 

type GameCoordinator struct {
	// contains filtered or unexported fields
}

func (*GameCoordinator) HandlePacket 

func (g *GameCoordinator) HandlePacket(packet *Packet)

func (*GameCoordinator) RegisterPacketHandler 

func (g *GameCoordinator) RegisterPacketHandler(handler GCPacketHandler)

func (*GameCoordinator) SetGamesPlayed 

func (g *GameCoordinator) SetGamesPlayed(appIds ...uint64)

Sets you in the given games. Specify none to quit all games.

func (*GameCoordinator) Write 

func (g *GameCoordinator) Write(msg IGCMsg)

type GroupStateEvent 

type GroupStateEvent struct {
	SteamId      SteamId `json:",string"`
	Relationship EClanRelationship
}

func (*GroupStateEvent) IsMember 

func (g *GroupStateEvent) IsMember() bool

type IgnoreFriendEvent 

type IgnoreFriendEvent struct {
	Result EResult
}

Fired in response to ignoring a friend

type LogOnDetails 

type LogOnDetails struct {
	Username       string
	Password       string
	AuthCode       string
	SentryFileHash SentryHash
}

type LoggedOffEvent 

type LoggedOffEvent struct {
	Result EResult
}

type LoggedOnEvent 

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 LoginKeyEvent 

type LoginKeyEvent struct {
	UniqueId uint32
	LoginKey string
}

type MachineAuthUpdateEvent 

type MachineAuthUpdateEvent struct {
	Hash []byte
}

type NotificationEvent 

type NotificationEvent struct {
	Type  NotificationType
	Count uint
}

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 NotificationType 

type NotificationType uint
const (
	TradeOffer NotificationType = 1
)

type Notifications 

type Notifications struct {
	// contains filtered or unexported fields
}

func (*Notifications) HandlePacket 

func (n *Notifications) HandlePacket(packet *Packet)

type PacketHandler 

type PacketHandler interface {
	HandlePacket(*Packet)
}

type PersonaStateEvent 

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 someone changing their friend details

type ProfileInfoEvent 

type ProfileInfoEvent struct {
	Result      EResult
	SteamId     SteamId `json:",string"`
	TimeCreated uint32
	RealName    string
	CityName    string
	StateName   string
	CountryName string
	Headline    string
	Summary     string
}

Fired in response to requesting profile info for a user

type SentryHash 

type SentryHash []byte

type Social 

type Social struct {
	Friends *socialcache.FriendsList
	Groups  *socialcache.GroupsList
	Chats   *socialcache.ChatsList
	// contains filtered or unexported fields
}

Provides access to social aspects of Steam.

func (*Social) AddFriend 

func (s *Social) AddFriend(id SteamId)

Adds a friend to your friends list or accepts a friend. You'll receive a FriendStateEvent for every new/changed friend

func (*Social) BanChatMember 

func (s *Social) BanChatMember(room SteamId, user SteamId)

Bans the specified chat member from the given chat room

func (*Social) GetAvatar 

func (s *Social) GetAvatar() string

Gets the local user's avatar

func (*Social) GetPersonaName 

func (s *Social) GetPersonaName() string

Gets the local user's persona name

func (*Social) GetPersonaState 

func (s *Social) GetPersonaState() EPersonaState

Gets the local user's persona state

func (*Social) HandlePacket 

func (s *Social) HandlePacket(packet *Packet)

func (*Social) IgnoreFriend 

func (s *Social) IgnoreFriend(id SteamId, setIgnore bool)

Ignores or unignores a friend on Steam

func (*Social) JoinChat 

func (s *Social) JoinChat(id SteamId)

Attempts to join a chat room

func (*Social) KickChatMember 

func (s *Social) KickChatMember(room SteamId, user SteamId)

Kicks the specified chat member from the given chat room

func (*Social) LeaveChat 

func (s *Social) LeaveChat(id SteamId)

Attempts to leave a chat room

func (*Social) RemoveFriend 

func (s *Social) RemoveFriend(id SteamId)

Removes a friend from your friends list

func (*Social) RequestFriendInfo 

func (s *Social) RequestFriendInfo(id SteamId, requestedInfo EClientPersonaStateFlag)

Requests persona state for a specified SteamId

func (*Social) RequestFriendListInfo 

func (s *Social) RequestFriendListInfo(ids []SteamId, requestedInfo EClientPersonaStateFlag)

Requests persona state for a list of specified SteamIds

func (*Social) RequestProfileInfo 

func (s *Social) RequestProfileInfo(id SteamId)

Requests profile information for a specified SteamId

func (*Social) SendMessage 

func (s *Social) SendMessage(to SteamId, entryType EChatEntryType, message string)

Sends a chat message to ether a room or friend

func (*Social) SetPersonaName 

func (s *Social) SetPersonaName(name string)

Sets the local user's persona name and broadcasts it over the network

func (*Social) SetPersonaState 

func (s *Social) SetPersonaState(state EPersonaState)

Sets the local user's persona state and broadcasts it over the network

func (*Social) UnbanChatMember 

func (s *Social) UnbanChatMember(room SteamId, user SteamId)

Unbans the specified chat member from the given chat room

type StateChangeDetails 

type StateChangeDetails struct {
	ChatterActedOn SteamId `json:",string"`
	StateChange    EChatMemberStateChange
	ChatterActedBy SteamId `json:",string"`
}

type TradeProposedEvent 

type TradeProposedEvent struct {
	RequestId TradeRequestId
	Other     SteamId `json:",string"`
}

type TradeRequestId 

type TradeRequestId uint32

type TradeResultEvent 

type TradeResultEvent struct {
	RequestId TradeRequestId
	Response  EEconTradeResponse
	Other     SteamId `json:",string"`
	// Number of days Steam Guard is required to have been active
	NumDaysSteamGuardRequired uint32
	// Number of days a new device cannot trade for.
	NumDaysNewDeviceCooldown uint32
	// Default number of days one cannot trade after a password reset.
	DefaultNumDaysPasswordResetProbation uint32
	// See above.
	NumDaysPasswordResetProbation uint32
}

type TradeSessionStartEvent 

type TradeSessionStartEvent struct {
	Other SteamId `json:",string"`
}

type Trading 

type Trading struct {
	// contains filtered or unexported fields
}

Provides access to the Steam client's part of Steam Trading, that is bootstrapping the trade. The trade itself is not handled by the Steam client itself, but it's a part of the Steam website.

You'll receive a TradeProposedEvent when a friend proposes a trade. You can accept it with the RespondRequest method. You can request a trade yourself with RequestTrade.

func (*Trading) CancelRequest 

func (t *Trading) CancelRequest(other SteamId)

This cancels a request made with RequestTrade.

func (*Trading) HandlePacket 

func (t *Trading) HandlePacket(packet *Packet)

func (*Trading) RequestTrade 

func (t *Trading) RequestTrade(other SteamId)

Requests a trade. You'll receive a TradeResultEvent if the request fails or if the friend accepted the trade.

func (*Trading) RespondRequest 

func (t *Trading) RespondRequest(requestId TradeRequestId, accept bool)

Responds to a TradeProposedEvent.

type Web 

type Web struct {

	// The `sessionid` cookie required to use the steam website.
	// This cookie may contain a characters that will need to be URL-escaped, otherwise
	// Steam (probably) interprets is as a string.
	// When used as an URL paramter this is automatically escaped by the Go HTTP package.
	SessionId string
	// The `steamLogin` cookie required to use the steam website. Already URL-escaped.
	// This is only available after calling LogOn().
	SteamLogin string
	// The `steamLoginSecure` cookie required to use the steam website over HTTPs. Already URL-escaped.
	// This is only availbile after calling LogOn().
	SteamLoginSecure string
	// contains filtered or unexported fields
}

func (*Web) HandlePacket 

func (w *Web) HandlePacket(packet *Packet)

func (*Web) LogOn 

func (w *Web) LogOn()

Fetches the `steamLogin` cookie. This may only be called after the first WebSessionIdEvent or it will panic.

type WebLoggedOnEvent 

type WebLoggedOnEvent struct{}

type WebSessionIdEvent 

type WebSessionIdEvent struct{}

Source Files

View all Source files

Directories

Path Synopsis
inventory
Includes inventory types as used in the trade package
 Includes inventory types as used in the trade package
This program generates the protobuf and SteamLanguage files from the SteamKit data.
 This program generates the protobuf and SteamLanguage files from the SteamKit data.
This package includes some basics for the Steam protocol.
 This package includes some basics for the Steam protocol.
gamecoordinator
protobuf
protobuf/unified
steamlang
Contains code generated from SteamKit's SteamLanguage data.
 Contains code generated from SteamKit's SteamLanguage data.
Includes helper types for working with JSON data
 Includes helper types for working with JSON data
Utilities for reading and writing of binary data
 Utilities for reading and writing of binary data
tf2
Provides access to TF2 Game Coordinator functionality.
 Provides access to TF2 Game Coordinator functionality.
internal
internal/protobuf
Allows automation of Steam Trading.
 Allows automation of Steam Trading.
tradeapi
Wrapper around the HTTP trading API for type safety 'n' stuff.
 Wrapper around the HTTP trading API for type safety 'n' stuff.
Implements methods to interact with the official Trade Offer API.
 Implements methods to interact with the official Trade Offer API.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.