Source File
wire_tracer.go
Belonging Package
github.com/gotd/td/mtproto
package mtprotoimport ()// WireTracer observes the plaintext MTProto traffic and the lifecycle of a// connection, e.g. to record wire traces for debugging or for comparing the// client behavior with other implementations.//// Callbacks are called synchronously from the connection goroutines, so// implementations must be safe for concurrent use and must return quickly.//// Calls are not ordered by wire order: incoming messages are decrypted// concurrently, and outgoing messages are reported by concurrent writers// just before they are written, so a reported outgoing message may never// reach the wire if the write fails. Order by message id where needed.//// The tracer never receives auth key material: only auth key ids.type WireTracer interface {// OnMessage is called for every encrypted message: outgoing messages// just before encryption and incoming messages after decryption and// msg_key check, before session and msg_id checks (rejected messages// are reported too, followed by a WireRejected event).//// The body is the serialized message body as sent or received// (including gzip_packed and msg_container). It is only valid during// the call: the tracer must not modify or retain it, and must copy it// if needed.OnMessage(m WireMessage, body []byte)// OnEvent is called on connection, key, session and request lifecycle// events.OnEvent(e WireEvent)}// WireDirection is the direction of a traced message.type WireDirection uint8// Message directions.const (// WireOut is a message sent by the client.WireOut WireDirection = iota + 1// WireIn is a message received from the server.WireIn)// String implements fmt.Stringer.func ( WireDirection) () string {switch {case WireOut:return "out"case WireIn:return "in"default:return "unknown"}}// WireConn identifies the connection of a traced message or event.type WireConn struct {// ID is unique for every Conn of the process, starting from 1.ID int64// DC is the DC id of the connection used for key exchange// (Options.DC): 10000 is added for test DCs.DC int}// WireMessage is the header of a traced message.type WireMessage struct {Conn WireConnDirection WireDirection// AuthKeyID is the id of the auth key the message is encrypted with.AuthKeyID [8]byte// TempKey is true if the message is encrypted with a temporary// (PFS) key.TempKey boolSalt int64SessionID int64MessageID int64SeqNo int32}// WireEventType is the type of a WireEvent.type WireEventType uint8// Event types.const (// WireConnStart is reported before dialing.WireConnStart WireEventType = iota + 1// WireConnUp is reported when the transport connection is established.WireConnUp// WireConnDown is reported when the connection is closed, Err is the// reason (nil on graceful close).WireConnDown// WireKeyCreated is reported when a new auth key is created by key// exchange: AuthKeyID, TempKey and ExpiresAt (temporary keys).WireKeyCreated// WireKeySet is reported when the connection starts using an auth key// for messages, including after the key is re-created because the server// did not find it: AuthKeyID, TempKey and ExpiresAt (temporary keys).WireKeySet// WireSessionNew is reported when the client session id changes:// Old and New.WireSessionNew// WireSaltChange is reported when the server salt changes: Old and New.// Salts set by key exchange are implied by WireKeyCreated.WireSaltChange// WireDecryptFailed is reported when an incoming message can't be// decrypted or fails the msg_key check: Err.WireDecryptFailed// WireRejected is reported when a decrypted incoming message is// rejected: MessageID and Reason ("bad_session" or "bad_msg_id").WireRejected// WireRequest is reported when a request is going to be sent:// MessageID, SeqNo and TypeID (of the encoded request, e.g. a// wrapper like invokeWithLayer).WireRequest// WireRequestResend is reported when a request is re-encoded and sent// again after bad_server_salt: MessageID and Reason ("bad_server_salt").// Retransmits after an ack timeout reuse the message id and are only// visible as repeated outgoing messages.WireRequestResend// WireRequestDone is reported when a request is finished: MessageID,// Err (nil on success, RPC or context error otherwise) and Latency.WireRequestDone)var wireTypeNames = [...]string{WireConnStart: "conn_start",WireConnUp: "conn_up",WireConnDown: "conn_down",WireKeyCreated: "key_created",WireKeySet: "key_set",WireSessionNew: "session_new",WireSaltChange: "salt_change",WireDecryptFailed: "decrypt_failed",WireRejected: "rejected",WireRequest: "request",WireRequestResend: "request_resend",WireRequestDone: "request_done",}// String implements fmt.Stringer.func ( WireEventType) () string {if int() < len(wireTypeNames) && wireTypeNames[] != "" {return wireTypeNames[]}return "unknown"}// WireEvent is a connection lifecycle event. Fields are set depending on// Type.type WireEvent struct {Type WireEventTypeConn WireConn// AuthKeyID, TempKey and ExpiresAt (unix seconds, temporary keys only)// describe the auth key of key events.AuthKeyID [8]byteTempKey boolExpiresAt int64// Old and New are session ids or salts.Old, New int64MessageID int64SeqNo int32TypeID uint32Latency time.DurationReason stringErr error}var wireConnID atomic.Int64func ( *Conn) () WireConn {return WireConn{ID: .wireID, DC: .dcID}}// traceEvent reports e if tracing is enabled. Callers on hot paths should// check c.wire before building the event.func ( *Conn) ( WireEvent) {if .wire == nil {return}.Conn = .wireConn().wire.OnEvent()}func ( *Conn) ( WireDirection, crypto.AuthKey, , , int64, int32, []byte) {.wire.OnMessage(WireMessage{Conn: .wireConn(),Direction: ,AuthKeyID: .ID,TempKey: .pfs,Salt: ,SessionID: ,MessageID: ,SeqNo: ,}, )}// traceKey reports a key event for the current auth key.func ( *Conn) ( WireEventType, crypto.AuthKey, bool) {if .wire == nil {return}var int64if {.sessionMux.RLock()= .tempKeyExpiry.sessionMux.RUnlock()}.traceEvent(WireEvent{Type: , AuthKeyID: .ID, TempKey: , ExpiresAt: })}func ( *Conn) (, int64) {if .wire == nil || == {return}.traceEvent(WireEvent{Type: WireSessionNew, Old: , New: })}// traceRequestStart reports a request that is going to be sent and returns// the start time for traceRequestDone.func ( *Conn) ( rpc.Request) time.Time {:= .clock.Now().traceEvent(WireEvent{Type: WireRequest, MessageID: .MsgID, SeqNo: .SeqNo, TypeID: peekID(.Input)})return}// traceRequestDone reports the result of a request.func ( *Conn) ( rpc.Request, time.Time, error) {.traceEvent(WireEvent{Type: WireRequestDone, MessageID: .MsgID, Latency: .clock.Now().Sub(), Err: })}// traceResend reports a request sent again with the same message id.func ( *Conn) ( rpc.Request, string) {.traceEvent(WireEvent{Type: WireRequestResend, MessageID: .MsgID, SeqNo: .SeqNo, Reason: })}// traceRejected reports a rejected incoming message.func ( *Conn) ( int64, string) {.traceEvent(WireEvent{Type: WireRejected, MessageID: , Reason: })}
![]() |
The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |