steam

package module
v1.0.10 Latest Latest
Warning

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

 Go to latest Published: Oct 19, 2024 License: BSD-3-Clause Imports: 33 Imported by: 1

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 with two-factor authentication
  • 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/dotabook/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:

Working with go-steam

Whether you want to develop your own Steam bot or directly work on go-steam itself, there are are few things to know.

  • If something is not working, check first if the same operation works (under the same conditions!) in the Steam client on that account. Maybe there's something go-steam doesn't handle correctly or you're missing a warning that's not obviously shown in go-steam. This is particularly important when working with trading since there are restrictions, for example newly authorized devices will not be able to trade for seven days.
  • Since Steam does not maintain a public API for most of the things go-steam implements, you can expect that sometimes things break randomly. Especially the trade and tradeoffer packages have been affected in the past.
  • Always gather as much information as possible. When you file an issue, be as precise and complete as you can. This makes debugging way easier.
  • If you haven't noticed yet, expect to find lots of things out yourself. Debugging can be complicated and Steam's internals are too.
  • Sometimes things break and other SteamKit ports are fixed already. Maybe take a look what people are saying over there? There's also the SteamKit IRC channel.

Updating go-steam to a new SteamKit version

Go source code is generated with code in the generator directory. Look at generator/README.md for more information on how to use the generator.

Then, after generating new Go source files, update go-steam as 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.

Example code

You can also find a running example in the `gsbot` package. 

package main

import (
	"io/ioutil"
	"log"

	"github.com/dotabook/go-steam/v3"
	"github.com/dotabook/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.

Index

Constants

This section is empty.

Variables

View Source 
var CMServers = []string{
	"155.133.248.52:27018",
	"162.254.197.40:27018",
	"162.254.197.180:27019",
	"155.133.248.50:27019",
	"162.254.197.181:27017",
	"162.254.197.42:27019",
	"162.254.197.180:27017",
	"162.254.197.181:27018",
	"162.254.197.42:27018",
	"155.133.248.50:27017",
	"155.133.248.52:27019",
	"155.133.248.51:27019",
	"155.133.248.53:27019",
	"155.133.248.51:27017",
	"155.133.248.53:27017",
	"155.133.248.52:27017",
	"155.133.248.50:27018",
	"162.254.197.180:27018",
	"162.254.197.40:27017",
	"162.254.197.40:27019",
	"162.254.197.42:27017",
	"162.254.197.181:27019",
	"155.133.248.53:27018",
	"155.133.248.51:27018",
	"146.66.152.11:27017",
	"146.66.152.10:27019",
	"146.66.152.10:27017",
	"146.66.152.10:27018",
	"146.66.152.11:27019",
	"162.254.198.133:27017",
	"162.254.198.133:27018",
	"162.254.198.130:27019",
	"162.254.198.130:27017",
	"162.254.198.132:27018",
	"162.254.198.130:27018",
	"162.254.198.132:27017",
	"162.254.198.132:27019",
	"162.254.198.131:27019",
	"162.254.198.131:27017",
	"146.66.152.11:27018",
	"162.254.198.131:27018",
	"162.254.198.133:27019",
	"185.25.182.77:27017",
	"185.25.182.76:27018",
	"185.25.182.76:27019",
	"185.25.182.77:27018",
	"185.25.182.76:27017",
	"185.25.182.77:27019",
	"162.254.196.67:27019",
	"162.254.196.67:27018",
	"162.254.196.83:27018",
	"162.254.196.84:27018",
	"162.254.196.83:27017",
	"162.254.196.84:27017",
	"162.254.196.68:27019",
	"162.254.196.68:27017",
	"162.254.196.84:27019",
	"162.254.196.67:27017",
	"162.254.196.83:27019",
	"162.254.196.68:27018",
	"146.66.155.101:27017",
	"146.66.155.101:27018",
	"146.66.155.100:27017",
	"146.66.155.100:27018",
	"146.66.155.101:27019",
	"146.66.155.100:27019",
	"155.133.230.50:27017",
	"155.133.230.34:27018",
	"155.133.230.34:27017",
	"155.133.230.50:27019",
	"155.133.230.34:27019",
	"155.133.230.50:27018",
	"162.254.192.100:27017",
	"162.254.192.108:27017",
	"155.133.246.68:27017",
	"155.133.246.68:27018",
	"155.133.246.68:27019",
	"155.133.246.69:27019",
	"155.133.246.69:27017",
	"155.133.246.69:27018",
	"162.254.192.108:27018",
	"162.254.192.101:27018",
	"162.254.192.101:27019",
	"162.254.192.109:27018",
	"162.254.192.100:27018",
	"162.254.192.109:27017",
	"162.254.192.109:27019",
	"162.254.192.108:27019",
	"162.254.192.101:27017",
	"162.254.192.100:27019",
	"162.254.193.46:27019",
	"162.254.193.6:27018",
	"162.254.193.47:27018",
	"162.254.193.6:27019",
	"162.254.193.7:27018",
	"162.254.193.7:27017",
	"162.254.193.7:27019",
	"162.254.193.47:27017",
	"162.254.193.47:27019",
	"162.254.193.46:27018",
}

CMServers contains a list of worlwide servers

Functions

func GetPublicKey 

func GetPublicKey(universe steamlang.EUniverse) *rsa.PublicKey

func GetRandomCM 

func GetRandomCM() *netutil.PortAddr

GetRandomCM returns a random server from a built-in IP list.

Prefer Client.Connect(), which uses IPs from the Steam Directory, which is always more up-to-date.

func InitializeSteamDirectory 

func InitializeSteamDirectory() error

Load initial server list from Steam Directory Web API. Call InitializeSteamDirectory() before Connect() to use steam directory server list instead of static one.

Types

type AccountInfoEvent 

type AccountInfoEvent struct {
	PersonaName          string
	Country              string
	CountAuthedComputers int32
	AccountFlags         steamlang.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 *protocol.Packet)

func (*Auth) LogOn 

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

Log on with the given details. You must always specify username and password OR username and loginkey. For the first login, don't set an authcode or a hash and you'll 

receive an error (EResult_AccountLogonDenied)

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.

After the event EMsg_ClientNewLoginKey is received you can use the LoginKey to login instead of using the password.

type ChatActionResultEvent 

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

Fired when a chat action has completed

type ChatEnterEvent 

type ChatEnterEvent struct {
	ChatRoomId    steamid.SteamId `json:",string"`
	FriendId      steamid.SteamId `json:",string"`
	ChatRoomType  steamlang.EChatRoomType
	OwnerId       steamid.SteamId `json:",string"`
	ClanId        steamid.SteamId `json:",string"`
	ChatFlags     byte
	EnterResponse steamlang.EChatRoomEnterResponse
	Name          string
}

Fired in response to joining a chat

type ChatInviteEvent 

type ChatInviteEvent struct {
	InvitedId    steamid.SteamId `json:",string"`
	ChatRoomId   steamid.SteamId `json:",string"`
	PatronId     steamid.SteamId `json:",string"`
	ChatRoomType steamlang.EChatRoomType
	FriendChatId steamid.SteamId `json:",string"`
	ChatRoomName string
	GameId       uint64 `json:",string"`
}

Fired when a chat invite is received

type ChatMemberInfoEvent 

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

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

type ChatMsgEvent 

type ChatMsgEvent struct {
	ChatRoomId steamid.SteamId `json:",string"` // not set for friend messages
	ChatterId  steamid.SteamId `json:",string"`
	Message    string
	EntryType  steamlang.EChatEntryType
	Timestamp  time.Time
	Offline    bool
}

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 {
	ClanId              steamid.SteamId `json:",string"`
	AccountFlags        steamlang.EAccountFlags
	ClanName            string
	Avatar              []byte
	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, error)

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 (*Client) ConnectTo 

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

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 (*Client) ConnectToBind 

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

Connects to a specific server, and binds to a specified local IP 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() protocol.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.SteamId

func (*Client) Write 

func (c *Client) Write(msg protocol.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      steamlang.EResult
	SteamId     steamid.SteamId `json:",string"`
	PersonaName string
}

Fired in response to adding a friend to your friends list

type FriendStateEvent 

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

func (*FriendStateEvent) IsFriend 

func (f *FriendStateEvent) IsFriend() bool

type FriendsListEvent 

type FriendsListEvent struct{}

type GCPacketHandler 

type GCPacketHandler interface {
	HandleGCPacket(*gamecoordinator.GCPacket)
}

type GameCoordinator 

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

func (*GameCoordinator) HandlePacket 

func (g *GameCoordinator) HandlePacket(packet *protocol.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 gamecoordinator.IGCMsg)

type GroupStateEvent 

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

func (*GroupStateEvent) IsMember 

func (g *GroupStateEvent) IsMember() bool

type IgnoreFriendEvent 

type IgnoreFriendEvent struct {
	Result steamlang.EResult
}

Fired in response to ignoring a friend

type LogOnDetails 

type LogOnDetails struct {
	Username string

	// If logging into an account without a login key, the account's password.
	Password string

	// If you have a Steam Guard email code, you can provide it here.
	AuthCode string

	// If you have a Steam Guard mobile two-factor authentication code, you can provide it here.
	TwoFactorCode  string
	SentryFileHash SentryHash
	LoginKey       string

	// true if you want to get a login key which can be used in lieu of
	// a password for subsequent logins. false or omitted otherwise.
	ShouldRememberPassword bool
}

type LogOnFailedEvent 

type LogOnFailedEvent struct {
	Result steamlang.EResult
}

type LoggedOffEvent 

type LoggedOffEvent struct {
	Result steamlang.EResult
}

type LoggedOnEvent 

type LoggedOnEvent struct {
	Result                    steamlang.EResult
	ExtendedResult            steamlang.EResult
	OutOfGameSecsPerHeartbeat int32
	InGameSecsPerHeartbeat    int32
	PublicIp                  uint32
	ServerTime                uint32
	AccountFlags              steamlang.EAccountFlags
	ClientSteamId             steamid.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 *protocol.Packet)

type PacketHandler 

type PacketHandler interface {
	HandlePacket(*protocol.Packet)
}

type PersonaStateEvent 

type PersonaStateEvent struct {
	StatusFlags            steamlang.EClientPersonaStateFlag
	FriendId               steamid.SteamId `json:",string"`
	State                  steamlang.EPersonaState
	StateFlags             steamlang.EPersonaStateFlag
	GameAppId              uint32
	GameId                 uint64 `json:",string"`
	GameName               string
	GameServerIp           uint32
	GameServerPort         uint32
	QueryPort              uint32
	SourceSteamId          steamid.SteamId `json:",string"`
	GameDataBlob           []byte
	Name                   string
	Avatar                 []byte
	LastLogOff             uint32
	LastLogOn              uint32
	ClanRank               uint32
	ClanTag                string
	OnlineSessionInstances uint32
	PersonaSetByUser       bool
	RichPresence           []*protobuf.CMsgClientPersonaState_Friend_KV
}

Fired when someone changing their friend details

type ProfileInfoEvent 

type ProfileInfoEvent struct {
	Result      steamlang.EResult
	SteamId     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.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.SteamId, user steamid.SteamId)

Bans the specified chat member from the given chat room

func (*Social) GetAvatar 

func (s *Social) GetAvatar() []byte

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() steamlang.EPersonaState

Gets the local user's persona state

func (*Social) HandlePacket 

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

func (*Social) IgnoreFriend 

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

Ignores or unignores a friend on Steam

func (*Social) JoinChat 

func (s *Social) JoinChat(id steamid.SteamId)

Attempts to join a chat room

func (*Social) KickChatMember 

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

Kicks the specified chat member from the given chat room

func (*Social) LeaveChat 

func (s *Social) LeaveChat(id steamid.SteamId)

Attempts to leave a chat room

func (*Social) RemoveFriend 

func (s *Social) RemoveFriend(id steamid.SteamId)

Removes a friend from your friends list

func (*Social) RequestFriendInfo 

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

Requests persona state for a specified SteamId

func (*Social) RequestFriendListInfo 

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

Requests persona state for a list of specified SteamIds

func (*Social) RequestOfflineMessages 

func (s *Social) RequestOfflineMessages()

Requests all offline messages and marks them as read

func (*Social) RequestProfileInfo 

func (s *Social) RequestProfileInfo(id steamid.SteamId)

Requests profile information for a specified SteamId

func (*Social) SendMessage 

func (s *Social) SendMessage(to steamid.SteamId, entryType steamlang.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 steamlang.EPersonaState)

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

func (*Social) UnbanChatMember 

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

Unbans the specified chat member from the given chat room

type StateChangeDetails 

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

type TradeProposedEvent 

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

type TradeRequestId 

type TradeRequestId uint32

type TradeResultEvent 

type TradeResultEvent struct {
	RequestId TradeRequestId
	Response  steamlang.EEconTradeResponse
	Other     steamid.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.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.SteamId)

This cancels a request made with RequestTrade.

func (*Trading) HandlePacket 

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

func (*Trading) RequestTrade 

func (t *Trading) RequestTrade(other steamid.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 *protocol.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 WebLogOnErrorEvent 

type WebLogOnErrorEvent error

type WebLoggedOnEvent 

type WebLoggedOnEvent struct{}

type WebSessionIdEvent 

type WebSessionIdEvent struct{}

Source Files

View all Source files

Directories

Path Synopsis
csgo
protocol/protobuf
dota
protocol/protobuf
economy
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.
Includes helper types for working with JSON data
 Includes helper types for working with JSON 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.
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.
protocol
protocol/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.