func (d *Service) RegisterProtocols(srv *rpc.Server, xp rpc.Transporter, connID libkb.ConnectionID, g *libkb.GlobalContext) error {
protocols := []rpc.Protocol{
keybase1.AccountProtocol(NewAccountHandler(xp, g)),
keybase1.BTCProtocol(NewBTCHandler(xp, g)),
keybase1.ConfigProtocol(NewConfigHandler(xp, g, d)),
keybase1.CryptoProtocol(NewCryptoHandler(xp, g)),
keybase1.CtlProtocol(NewCtlHandler(xp, d, g)),
keybase1.DebuggingProtocol(NewDebuggingHandler(xp)),
keybase1.DeviceProtocol(NewDeviceHandler(xp, g)),
keybase1.FavoriteProtocol(NewFavoriteHandler(xp, g)),
keybase1.IdentifyProtocol(NewIdentifyHandler(xp, g)),
keybase1.LoginProtocol(NewLoginHandler(xp, g)),
keybase1.ProveProtocol(NewProveHandler(xp, g)),
keybase1.SessionProtocol(NewSessionHandler(xp, g)),
keybase1.SignupProtocol(NewSignupHandler(xp, g)),
keybase1.SigsProtocol(NewSigsHandler(xp, g)),
keybase1.PGPProtocol(NewPGPHandler(xp, g)),
keybase1.RevokeProtocol(NewRevokeHandler(xp, g)),
keybase1.TestProtocol(NewTestHandler(xp, g)),
keybase1.TrackProtocol(NewTrackHandler(xp, g)),
keybase1.UserProtocol(NewUserHandler(xp, g)),
keybase1.NotifyCtlProtocol(NewNotifyCtlHandler(xp, connID, g)),
keybase1.DelegateUiCtlProtocol(NewDelegateUICtlHandler(xp, connID, g)),
}
for _, proto := range protocols {
if err := srv.Register(proto); err != nil {
return err
}
}
return nil
}
// OnConnect is called by the rpc library to indicate we have connected to
// gregord
func (g *gregorHandler) OnConnect(ctx context.Context, conn *rpc.Connection,
cli rpc.GenericClient, srv *rpc.Server) error {
g.Lock()
defer g.Unlock()
g.Debug("connected")
g.Debug("registering protocols")
if err := srv.Register(gregor1.OutgoingProtocol(g)); err != nil {
return err
}
// Use the client parameter instead of conn.GetClient(), since we can get stuck
// in a recursive loop if we keep retrying on reconnect.
if err := g.auth(ctx, cli); err != nil {
return err
}
g.pushState(keybase1.PushReason_RECONNECTED)
// Sync down events since we have been dead
replayedMsgs, consumedMsgs, err := g.serverSync(ctx, gregor1.IncomingClient{Cli: cli})
if err != nil {
g.Errorf("sync failure: %s", err)
} else {
g.Debug("sync success: replayed: %d consumed: %d",
len(replayedMsgs), len(consumedMsgs))
}
return nil
}
func RegisterProtocolsWithContext(prots []rpc.Protocol, g *libkb.GlobalContext) (err error) {
var srv *rpc.Server
if srv, _, err = GetRPCServer(g); err != nil {
return
}
prots = append(prots, NewLogUIProtocol())
for _, p := range prots {
if err = srv.Register(p); err != nil {
if _, ok := err.(rpc.AlreadyRegisteredError); !ok {
return err
}
err = nil
}
}
return
}
func (d *Service) RegisterProtocols(srv *rpc.Server, xp rpc.Transporter, connID libkb.ConnectionID, logReg *logRegister, g *libkb.GlobalContext) (shutdowners []Shutdowner, err error) {
rekeyHandler := NewRekeyHandler(xp, g, d.gregor)
// The rekeyHandler implements Shutdowner interface to stop the timer
// properly
shutdowners = append(shutdowners, rekeyHandler)
protocols := []rpc.Protocol{
keybase1.AccountProtocol(NewAccountHandler(xp, g)),
keybase1.BTCProtocol(NewBTCHandler(xp, g)),
keybase1.ConfigProtocol(NewConfigHandler(xp, connID, g, d)),
keybase1.CryptoProtocol(NewCryptoHandler(g)),
keybase1.CtlProtocol(NewCtlHandler(xp, d, g)),
keybase1.DebuggingProtocol(NewDebuggingHandler(xp)),
keybase1.DelegateUiCtlProtocol(NewDelegateUICtlHandler(xp, connID, g)),
keybase1.DeviceProtocol(NewDeviceHandler(xp, g)),
keybase1.FavoriteProtocol(NewFavoriteHandler(xp, g)),
keybase1.FsProtocol(newFSHandler(xp, g)),
keybase1.IdentifyProtocol(NewIdentifyHandler(xp, g)),
keybase1.KbfsProtocol(NewKBFSHandler(xp, g)),
keybase1.LogProtocol(NewLogHandler(xp, logReg, g)),
keybase1.LoginProtocol(NewLoginHandler(xp, g)),
keybase1.NotifyCtlProtocol(NewNotifyCtlHandler(xp, connID, g)),
keybase1.PGPProtocol(NewPGPHandler(xp, g)),
keybase1.RevokeProtocol(NewRevokeHandler(xp, g)),
keybase1.ProveProtocol(NewProveHandler(xp, g)),
keybase1.SaltpackProtocol(NewSaltpackHandler(xp, g)),
keybase1.SecretKeysProtocol(NewSecretKeysHandler(xp, g)),
keybase1.SessionProtocol(NewSessionHandler(xp, g)),
keybase1.SignupProtocol(NewSignupHandler(xp, g)),
keybase1.SigsProtocol(NewSigsHandler(xp, g)),
keybase1.TestProtocol(NewTestHandler(xp, g)),
keybase1.TrackProtocol(NewTrackHandler(xp, g)),
keybase1.UserProtocol(NewUserHandler(xp, g)),
keybase1.ApiserverProtocol(NewAPIServerHandler(xp, g)),
keybase1.PaperprovisionProtocol(NewPaperProvisionHandler(xp, g)),
keybase1.RekeyProtocol(rekeyHandler),
keybase1.GregorProtocol(newGregorRPCHandler(xp, g, d.gregor)),
}
for _, proto := range protocols {
if err = srv.Register(proto); err != nil {
return
}
}
return
}
// OnConnect implements the ConnectionHandler interface.
func (k *KeybaseDaemonRPC) OnConnect(ctx context.Context,
conn *rpc.Connection, rawClient rpc.GenericClient,
server *rpc.Server) error {
protocols := []rpc.Protocol{
keybase1.LogUiProtocol(daemonLogUI{k.daemonLog}),
keybase1.IdentifyUiProtocol(daemonIdentifyUI{k.daemonLog}),
keybase1.NotifySessionProtocol(k),
keybase1.NotifyUsersProtocol(k),
}
for _, p := range protocols {
err := server.Register(p)
if err != nil {
if _, ok := err.(rpc.AlreadyRegisteredError); !ok {
return err
}
}
}
// Using conn.GetClient() here would cause problematic
// recursion.
c := keybase1.NotifyCtlClient{Cli: rawClient}
err := c.SetNotifications(ctx, keybase1.NotificationChannels{
Session: true,
Users: true,
})
if err != nil {
return err
}
// Introduce ourselves. TODO: move this to SharedKeybaseConnection
// somehow?
configClient := keybase1.ConfigClient{Cli: rawClient}
err = configClient.HelloIAm(ctx, keybase1.ClientDetails{
Pid: os.Getpid(),
ClientType: keybase1.ClientType_KBFS,
Argv: os.Args,
Version: VersionString(),
})
if err != nil {
return err
}
return nil
}
// OnConnect implements the ConnectionHandler interface.
func (md *MDServerRemote) OnConnect(ctx context.Context,
conn *rpc.Connection, client rpc.GenericClient,
server *rpc.Server) (err error) {
defer func() {
if err == nil {
md.config.Reporter().Notify(ctx,
connectionNotification(connectionStatusConnected))
}
}()
md.log.Debug("MDServerRemote: OnConnect called with a new connection")
// we'll get replies asynchronously as to not block the connection
// for doing other active work for the user. they will be sent to
// the FolderNeedsRekey handler.
if err := server.Register(keybase1.MetadataUpdateProtocol(md)); err != nil {
if _, ok := err.(rpc.AlreadyRegisteredError); !ok {
return err
}
}
// reset auth -- using md.client here would cause problematic recursion.
c := keybase1.MetadataClient{Cli: client}
pingIntervalSeconds, err := md.resetAuth(ctx, c)
switch err.(type) {
case nil:
case NoCurrentSessionError:
default:
return err
}
md.config.KBFSOps().PushConnectionStatusChange(MDServiceName, nil)
// start pinging
md.resetPingTicker(pingIntervalSeconds)
return nil
}
