steam

package module
v0.0.0-...-0b43fd5 Latest Latest
Warning

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

 Go to latest Published: Jul 24, 2014 License: BSD-3-Clause Imports: 32 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 code.google.com/p/goprotobuf/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.

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. 

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:
		client.Connect() // please do some real error handling here
		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",

	"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",

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

Functions

func GetPublicKey 

func GetPublicKey(universe EUniverse) *rsa.PublicKey

func GetRandomCM 

func GetRandomCM() *netutil.PortAddr

Types

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 ChatMsgEvent 

type ChatMsgEvent struct {
	Chatroom SteamId // not set for friend messages
	Sender   SteamId
	Message  string
	Type     EChatEntryType
}

func (*ChatMsgEvent) IsMessage 

func (c *ChatMsgEvent) IsMessage() bool

Whether the type is ChatMsg

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) 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) 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 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 Friend 

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

A thread-safe friend in a friend list which contains references to its predecessor and successor. It is mutable and will be changed by Social.

func (*Friend) Next 

func (f *Friend) Next() *Friend

func (*Friend) Prev 

func (f *Friend) Prev() *Friend

func (*Friend) Relationship 

func (f *Friend) Relationship() EFriendRelationship

func (*Friend) SteamId 

func (f *Friend) SteamId() SteamId

type FriendListEvent 

type FriendListEvent struct{}

type FriendStateEvent 

type FriendStateEvent struct {
	SteamId      SteamId
	Relationship EFriendRelationship
}

func (*FriendStateEvent) IsFriend 

func (f *FriendStateEvent) IsFriend() bool

func (*FriendStateEvent) IsMember 

func (f *FriendStateEvent) IsMember() bool

type FriendsList 

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

func (*FriendsList) ById 

func (f *FriendsList) ById(id SteamId) *Friend

func (*FriendsList) First 

func (f *FriendsList) First() *Friend

func (*FriendsList) Last 

func (f *FriendsList) Last() *Friend

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 Group 

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

Represents a group within a doubly-linked group list.

func (*Group) Next 

func (g *Group) Next() *Group

Returns the next element in the group list or nil if this group is the last in the list.

func (*Group) Prev 

func (g *Group) Prev() *Group

Returns the previous element in the group list or nil if this group is the first in the list.

func (*Group) Relationship 

func (g *Group) Relationship() EClanRelationship

func (*Group) SteamId 

func (g *Group) SteamId() SteamId

type GroupStateEvent 

type GroupStateEvent struct {
	SteamId      SteamId
	Relationship EClanRelationship
}

type GroupsList 

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

func (*GroupsList) ById 

func (list *GroupsList) ById(id SteamId) *Group

Returns the group by a SteamId or nil if there is no such group.

func (*GroupsList) First 

func (list *GroupsList) First() *Group

Returns the first group in the group list or nil if the list is empty.

func (*GroupsList) Last 

func (list *GroupsList) Last() *Group

Returns the last group in the group list or nil if the list is empty.

type LogOnDetails 

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

type LoggedOnEvent 

type LoggedOnEvent struct{}

type MachineAuthUpdateEvent 

type MachineAuthUpdateEvent struct {
	Hash SentryHash
}

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 SentryHash 

type SentryHash []byte

type Social 

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

Provides access to social aspects of Steam.

Friend and group lists are implemented as doubly-linked lists for thread-safety. They can be iterated over like so: 

for friend := client.Social.Friends.First(); friend != nil; friend = friend.Next() {
	log.Println(friend.SteamId())
}

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) HandlePacket 

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

func (*Social) RemoveFriend 

func (s *Social) RemoveFriend(id SteamId)

func (*Social) SendChatMessage 

func (s *Social) SendChatMessage(to SteamId, message string)

Sends a chat message to the given friend. Chatrooms/Group chats are not supported yet. This just calls SendMessage with EChatEntryType_ChatMsg as the entry type.

func (*Social) SendMessage 

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

Sends a chat message to the given friend. Chatrooms/Group chats are not supported yet.

func (*Social) SetName 

func (s *Social) SetName(name string)

func (*Social) SetPersonaState 

func (s *Social) SetPersonaState(state EPersonaState)

type TradeProposedEvent 

type TradeProposedEvent struct {
	RequestId TradeRequestId
	Other     SteamId
	OtherName string
}

type TradeRequestId 

type TradeRequestId uint32

type TradeResultEvent 

type TradeResultEvent struct {
	RequestId TradeRequestId
	Response  EEconTradeResponse
	Other     SteamId

	// 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
}

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.
	// It is only available after calling LogOn().
	SteamLogin 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
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.