telegabber/telegram/connect.go

190 lines
4.9 KiB
Go
Raw Normal View History

2019-11-05 00:25:15 +00:00
package telegram
import (
"github.com/pkg/errors"
"math"
2019-11-05 00:25:15 +00:00
2019-11-24 17:10:29 +00:00
"dev.narayana.im/narayana/telegabber/xmpp/gateway"
log "github.com/sirupsen/logrus"
2019-11-05 00:25:15 +00:00
"github.com/zelenin/go-tdlib/client"
)
const chatsLimit int32 = 999
2019-11-25 19:42:11 +00:00
type clientAuthorizer struct {
TdlibParameters chan *client.TdlibParameters
PhoneNumber chan string
Code chan string
State chan client.AuthorizationState
Password chan string
}
func (stateHandler *clientAuthorizer) Handle(c *client.Client, state client.AuthorizationState) error {
stateHandler.State <- state
switch state.AuthorizationStateType() {
case client.TypeAuthorizationStateWaitTdlibParameters:
_, err := c.SetTdlibParameters(&client.SetTdlibParametersRequest{
Parameters: <-stateHandler.TdlibParameters,
})
return err
case client.TypeAuthorizationStateWaitEncryptionKey:
_, err := c.CheckDatabaseEncryptionKey(&client.CheckDatabaseEncryptionKeyRequest{})
return err
case client.TypeAuthorizationStateWaitPhoneNumber:
_, err := c.SetAuthenticationPhoneNumber(&client.SetAuthenticationPhoneNumberRequest{
PhoneNumber: <-stateHandler.PhoneNumber,
Settings: &client.PhoneNumberAuthenticationSettings{
AllowFlashCall: false,
IsCurrentPhoneNumber: false,
AllowSmsRetrieverApi: false,
},
})
return err
case client.TypeAuthorizationStateWaitCode:
_, err := c.CheckAuthenticationCode(&client.CheckAuthenticationCodeRequest{
Code: <-stateHandler.Code,
})
return err
case client.TypeAuthorizationStateWaitRegistration:
return client.ErrNotSupportedAuthorizationState
case client.TypeAuthorizationStateWaitPassword:
_, err := c.CheckAuthenticationPassword(&client.CheckAuthenticationPasswordRequest{
Password: <-stateHandler.Password,
})
return err
case client.TypeAuthorizationStateReady:
return nil
case client.TypeAuthorizationStateLoggingOut:
return client.ErrNotSupportedAuthorizationState
case client.TypeAuthorizationStateClosing:
return client.ErrNotSupportedAuthorizationState
case client.TypeAuthorizationStateClosed:
return client.ErrNotSupportedAuthorizationState
}
return client.ErrNotSupportedAuthorizationState
}
func (stateHandler *clientAuthorizer) Close() {
close(stateHandler.TdlibParameters)
close(stateHandler.PhoneNumber)
close(stateHandler.Code)
close(stateHandler.State)
close(stateHandler.Password)
}
2019-11-05 00:25:15 +00:00
// Connect starts TDlib connection
func (c *Client) Connect() error {
if c.online {
return nil
}
log.Warn("Connecting to Telegram network...")
2019-11-25 19:42:11 +00:00
c.authorizer = &clientAuthorizer{
TdlibParameters: make(chan *client.TdlibParameters, 1),
PhoneNumber: make(chan string, 1),
Code: make(chan string, 1),
State: make(chan client.AuthorizationState, 10),
Password: make(chan string, 1),
}
2019-11-29 00:51:41 +00:00
c.locks.authorizationReady.Add(1)
2019-11-24 17:10:29 +00:00
go c.interactor()
2019-11-24 17:10:29 +00:00
c.authorizer.TdlibParameters <- c.parameters
2019-11-05 00:25:15 +00:00
2019-11-24 17:10:29 +00:00
tdlibClient, err := client.NewClient(c.authorizer, c.logVerbosity)
2019-11-05 00:25:15 +00:00
if err != nil {
2019-11-24 17:10:29 +00:00
return errors.Wrap(err, "Couldn't initialize a Telegram client instance")
2019-11-05 00:25:15 +00:00
}
c.client = tdlibClient
c.online = true
2019-11-29 00:51:41 +00:00
c.locks.authorizationReady.Done()
2019-11-05 00:25:15 +00:00
2019-11-29 00:51:41 +00:00
go c.updateHandler()
2019-11-05 00:25:15 +00:00
return nil
}
// Disconnect drops TDlib connection
func (c *Client) Disconnect() {
if !c.online {
return
}
log.Warn("Disconnecting from Telegram network...")
// TODO: send unavailable presence to cached chats
2019-12-03 22:43:48 +00:00
c.client.Destroy()
c.online = false
}
2019-11-24 17:10:29 +00:00
func (c *Client) interactor() {
for {
state, ok := <-c.authorizer.State
if !ok {
return
}
stateType := state.AuthorizationStateType()
log.Infof("Telegram authorization state: %#v", stateType)
2019-11-29 00:51:41 +00:00
log.Debugf("%#v", state)
2019-11-24 17:10:29 +00:00
switch stateType {
case client.TypeAuthorizationStateWaitPhoneNumber:
log.Warn("Logging in...")
if c.Session.Login != "" {
c.authorizer.PhoneNumber <- c.Session.Login
} else {
gateway.SendMessage(c.jid, "", "Please, enter your Telegram login via /login 12345", c.xmpp)
}
case client.TypeAuthorizationStateWaitCode:
log.Warn("Waiting for authorization code...")
gateway.SendMessage(c.jid, "", "Please, enter authorization code via /code 12345", c.xmpp)
case client.TypeAuthorizationStateWaitPassword:
log.Warn("Waiting for 2FA password...")
gateway.SendMessage(c.jid, "", "Please, enter 2FA passphrase via /password 12345", c.xmpp)
case client.TypeAuthorizationStateReady:
var err error
2019-11-29 00:51:41 +00:00
c.locks.authorizationReady.Wait()
2019-11-24 17:10:29 +00:00
log.Warn("Authorization successful!")
c.me, err = c.client.GetMe()
if err != nil {
log.Error("Could not retrieve me info")
} else if c.Session.Login == "" {
c.Session.Login = c.me.PhoneNumber
}
_, err = c.client.GetChats(&client.GetChatsRequest{
OffsetOrder: client.JsonInt64(math.MaxInt64),
Limit: chatsLimit,
})
if err != nil {
log.Error("Could not retrieve chats")
}
2019-11-29 00:51:41 +00:00
gateway.SendPresence(c.xmpp, c.jid, gateway.SPStatus("Logged in "+c.Session.Login))
2019-11-24 17:10:29 +00:00
return
}
}
2019-11-05 00:25:15 +00:00
}