forked from Silverfish/proton-bridge
fb4a0e77af
Add a dedicated go-routine whose sole responsibility is to manage the life time of the IMAP and SMTP servers and their listeners. The current implementation behaves the same way as the previous state. The new behavior will be implemented in a follow MR.
621 lines
16 KiB
Go
621 lines
16 KiB
Go
// Copyright (c) 2023 Proton AG
|
|
//
|
|
// This file is part of Proton Mail Bridge.
|
|
//
|
|
// Proton Mail Bridge is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Proton Mail Bridge is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Proton Mail Bridge. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package bridge
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"path/filepath"
|
|
|
|
"github.com/ProtonMail/gluon"
|
|
"github.com/ProtonMail/gluon/connector"
|
|
"github.com/ProtonMail/gluon/logging"
|
|
"github.com/ProtonMail/proton-bridge/v3/cpc"
|
|
"github.com/ProtonMail/proton-bridge/v3/internal/events"
|
|
"github.com/ProtonMail/proton-bridge/v3/internal/safe"
|
|
"github.com/ProtonMail/proton-bridge/v3/internal/user"
|
|
"github.com/emersion/go-smtp"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// ServerManager manages the IMAP & SMTP servers and their listeners.
|
|
type ServerManager struct {
|
|
requests *cpc.CPC
|
|
|
|
imapServer *gluon.Server
|
|
imapListener net.Listener
|
|
|
|
smtpServer *smtp.Server
|
|
smtpListener net.Listener
|
|
}
|
|
|
|
func newServerManager() *ServerManager {
|
|
return &ServerManager{
|
|
requests: cpc.NewCPC(),
|
|
}
|
|
}
|
|
|
|
func (sm *ServerManager) Init(bridge *Bridge) error {
|
|
imapServer, err := createIMAPServer(bridge)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
smtpServer := createSMTPServer(bridge)
|
|
|
|
sm.imapServer = imapServer
|
|
sm.smtpServer = smtpServer
|
|
|
|
bridge.tasks.Once(func(ctx context.Context) {
|
|
logging.DoAnnotated(ctx, func(ctx context.Context) {
|
|
sm.run(ctx, bridge)
|
|
}, logging.Labels{
|
|
"service": "server-manager",
|
|
})
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sm *ServerManager) CloseServers(ctx context.Context) error {
|
|
defer sm.requests.Close()
|
|
_, err := sm.requests.SendWithReply(ctx, &smRequestClose{})
|
|
|
|
return err
|
|
}
|
|
|
|
func (sm *ServerManager) RestartIMAP(ctx context.Context) error {
|
|
_, err := sm.requests.SendWithReply(ctx, &smRequestRestartIMAP{})
|
|
|
|
return err
|
|
}
|
|
|
|
func (sm *ServerManager) RestartSMTP(ctx context.Context) error {
|
|
_, err := sm.requests.SendWithReply(ctx, &smRequestRestartSMTP{})
|
|
|
|
return err
|
|
}
|
|
|
|
func (sm *ServerManager) AddIMAPUser(ctx context.Context, user *user.User) error {
|
|
_, err := sm.requests.SendWithReply(ctx, &smRequestAddIMAPUser{user: user})
|
|
|
|
return err
|
|
}
|
|
|
|
func (sm *ServerManager) RemoveIMAPUser(ctx context.Context, user *user.User, withData bool) error {
|
|
_, err := sm.requests.SendWithReply(ctx, &smRequestRemoveIMAPUser{
|
|
user: user,
|
|
withData: withData,
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
func (sm *ServerManager) SetGluonDir(ctx context.Context, gluonDir string) error {
|
|
_, err := sm.requests.SendWithReply(ctx, &smRequestSetGluonDir{
|
|
dir: gluonDir,
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
func (sm *ServerManager) AddGluonUser(ctx context.Context, conn connector.Connector, passphrase []byte) (string, error) {
|
|
reply, err := cpc.SendWithReplyType[string](ctx, sm.requests, &smRequestAddGluonUser{
|
|
conn: conn,
|
|
passphrase: passphrase,
|
|
})
|
|
|
|
return reply, err
|
|
}
|
|
|
|
func (sm *ServerManager) RemoveGluonUser(ctx context.Context, gluonID string) error {
|
|
_, err := sm.requests.SendWithReply(ctx, &smRequestRemoveGluonUser{
|
|
userID: gluonID,
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
func (sm *ServerManager) run(ctx context.Context, bridge *Bridge) {
|
|
eventCh, cancel := bridge.GetEvents()
|
|
defer cancel()
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
sm.handleClose(ctx, bridge)
|
|
return
|
|
|
|
case evt := <-eventCh:
|
|
switch evt.(type) {
|
|
case events.ConnStatusDown:
|
|
// Handle connect down.
|
|
|
|
case events.ConnStatusUp:
|
|
// Handle connect up.
|
|
|
|
case events.AllUsersLoaded:
|
|
if err := sm.serveIMAP(ctx, bridge); err != nil {
|
|
logrus.WithError(err).Error("Failed to start IMAP server")
|
|
}
|
|
|
|
if err := sm.serveSMTP(bridge); err != nil {
|
|
logrus.WithError(err).Error("Failed to start SMTP server")
|
|
}
|
|
}
|
|
|
|
case request, ok := <-sm.requests.ReceiveCh():
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
switch r := request.Value.(type) {
|
|
case *smRequestClose:
|
|
sm.handleClose(ctx, bridge)
|
|
request.SendReply(ctx, nil, nil)
|
|
return
|
|
|
|
case *smRequestRestartSMTP:
|
|
err := sm.restartSMTP(bridge)
|
|
request.SendReply(ctx, nil, err)
|
|
|
|
case *smRequestRestartIMAP:
|
|
err := sm.restartIMAP(ctx, bridge)
|
|
request.SendReply(ctx, nil, err)
|
|
|
|
case *smRequestAddIMAPUser:
|
|
err := sm.handleAddIMAPUser(ctx, r.user)
|
|
request.SendReply(ctx, nil, err)
|
|
|
|
case *smRequestRemoveIMAPUser:
|
|
err := sm.handleRemoveIMAPUser(ctx, r.user, r.withData)
|
|
request.SendReply(ctx, nil, err)
|
|
|
|
case *smRequestSetGluonDir:
|
|
err := sm.handleSetGluonDir(ctx, bridge, r.dir)
|
|
request.SendReply(ctx, nil, err)
|
|
|
|
case *smRequestAddGluonUser:
|
|
id, err := sm.handleAddGluonUser(ctx, r.conn, r.passphrase)
|
|
request.SendReply(ctx, id, err)
|
|
|
|
case *smRequestRemoveGluonUser:
|
|
err := sm.handleRemoveGluonUser(ctx, r.userID)
|
|
request.SendReply(ctx, nil, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sm *ServerManager) handleClose(ctx context.Context, bridge *Bridge) {
|
|
// Close the IMAP server.
|
|
if err := sm.closeIMAPServer(ctx, bridge); err != nil {
|
|
logrus.WithError(err).Error("Failed to close IMAP server")
|
|
}
|
|
|
|
// Close the SMTP server.
|
|
if err := sm.closeSMTPServer(bridge); err != nil {
|
|
logrus.WithError(err).Error("Failed to close SMTP server")
|
|
}
|
|
}
|
|
|
|
func (sm *ServerManager) handleAddIMAPUser(ctx context.Context, user *user.User) error {
|
|
if sm.imapServer == nil {
|
|
return fmt.Errorf("no imap server instance running")
|
|
}
|
|
|
|
imapConn, err := user.NewIMAPConnectors()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create IMAP connectors: %w", err)
|
|
}
|
|
|
|
for addrID, imapConn := range imapConn {
|
|
log := logrus.WithFields(logrus.Fields{
|
|
"userID": user.ID(),
|
|
"addrID": addrID,
|
|
})
|
|
|
|
if gluonID, ok := user.GetGluonID(addrID); ok {
|
|
log.WithField("gluonID", gluonID).Info("Loading existing IMAP user")
|
|
|
|
// Load the user, checking whether the DB was newly created.
|
|
isNew, err := sm.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey())
|
|
if err != nil {
|
|
return fmt.Errorf("failed to load IMAP user: %w", err)
|
|
}
|
|
|
|
if isNew {
|
|
// If the DB was newly created, clear the sync status; gluon's DB was not found.
|
|
logrus.Warn("IMAP user DB was newly created, clearing sync status")
|
|
|
|
// Remove the user from IMAP so we can clear the sync status.
|
|
if err := sm.imapServer.RemoveUser(ctx, gluonID, false); err != nil {
|
|
return fmt.Errorf("failed to remove IMAP user: %w", err)
|
|
}
|
|
|
|
// Clear the sync status -- we need to resync all messages.
|
|
if err := user.ClearSyncStatus(); err != nil {
|
|
return fmt.Errorf("failed to clear sync status: %w", err)
|
|
}
|
|
|
|
// Add the user back to the IMAP server.
|
|
if isNew, err := sm.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey()); err != nil {
|
|
return fmt.Errorf("failed to add IMAP user: %w", err)
|
|
} else if isNew {
|
|
panic("IMAP user should already have a database")
|
|
}
|
|
} else if status := user.GetSyncStatus(); !status.HasLabels {
|
|
// Otherwise, the DB already exists -- if the labels are not yet synced, we need to re-create the DB.
|
|
if err := sm.imapServer.RemoveUser(ctx, gluonID, true); err != nil {
|
|
return fmt.Errorf("failed to remove old IMAP user: %w", err)
|
|
}
|
|
|
|
if err := user.RemoveGluonID(addrID, gluonID); err != nil {
|
|
return fmt.Errorf("failed to remove old IMAP user ID: %w", err)
|
|
}
|
|
|
|
gluonID, err := sm.imapServer.AddUser(ctx, imapConn, user.GluonKey())
|
|
if err != nil {
|
|
return fmt.Errorf("failed to add IMAP user: %w", err)
|
|
}
|
|
|
|
if err := user.SetGluonID(addrID, gluonID); err != nil {
|
|
return fmt.Errorf("failed to set IMAP user ID: %w", err)
|
|
}
|
|
|
|
log.WithField("gluonID", gluonID).Info("Re-created IMAP user")
|
|
}
|
|
} else {
|
|
log.Info("Creating new IMAP user")
|
|
|
|
gluonID, err := sm.imapServer.AddUser(ctx, imapConn, user.GluonKey())
|
|
if err != nil {
|
|
return fmt.Errorf("failed to add IMAP user: %w", err)
|
|
}
|
|
|
|
if err := user.SetGluonID(addrID, gluonID); err != nil {
|
|
return fmt.Errorf("failed to set IMAP user ID: %w", err)
|
|
}
|
|
|
|
log.WithField("gluonID", gluonID).Info("Created new IMAP user")
|
|
}
|
|
}
|
|
|
|
// Trigger a sync for the user, if needed.
|
|
user.TriggerSync()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sm *ServerManager) handleRemoveIMAPUser(ctx context.Context, user *user.User, withData bool) error {
|
|
if sm.imapServer == nil {
|
|
return fmt.Errorf("no imap server instance running")
|
|
}
|
|
|
|
logrus.WithFields(logrus.Fields{
|
|
"userID": user.ID(),
|
|
"withData": withData,
|
|
}).Debug("Removing IMAP user")
|
|
|
|
for addrID, gluonID := range user.GetGluonIDs() {
|
|
if err := sm.imapServer.RemoveUser(ctx, gluonID, withData); err != nil {
|
|
return fmt.Errorf("failed to remove IMAP user: %w", err)
|
|
}
|
|
|
|
if withData {
|
|
if err := user.RemoveGluonID(addrID, gluonID); err != nil {
|
|
return fmt.Errorf("failed to remove IMAP user ID: %w", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func createIMAPServer(bridge *Bridge) (*gluon.Server, error) {
|
|
gluonDataDir, err := bridge.GetGluonDataDir()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get Gluon Database directory: %w", err)
|
|
}
|
|
|
|
return newIMAPServer(
|
|
bridge.vault.GetGluonCacheDir(),
|
|
gluonDataDir,
|
|
bridge.curVersion,
|
|
bridge.tlsConfig,
|
|
bridge.reporter,
|
|
bridge.logIMAPClient,
|
|
bridge.logIMAPServer,
|
|
bridge.imapEventCh,
|
|
bridge.tasks,
|
|
bridge.uidValidityGenerator,
|
|
bridge.panicHandler,
|
|
)
|
|
}
|
|
|
|
func createSMTPServer(bridge *Bridge) *smtp.Server {
|
|
return newSMTPServer(bridge, bridge.tlsConfig, bridge.logSMTP)
|
|
}
|
|
|
|
func (sm *ServerManager) closeSMTPServer(bridge *Bridge) error {
|
|
// We close the listener ourselves even though it's also closed by smtpServer.Close().
|
|
// This is because smtpServer.Serve() is called in a separate goroutine and might be executed
|
|
// after we've already closed the server. However, go-smtp has a bug; it blocks on the listener
|
|
// even after the server has been closed. So we close the listener ourselves to unblock it.
|
|
logrus.Info("Closing SMTP server")
|
|
|
|
if sm.smtpListener != nil {
|
|
if err := sm.smtpListener.Close(); err != nil {
|
|
return fmt.Errorf("failed to close SMTP listener: %w", err)
|
|
}
|
|
}
|
|
|
|
if err := sm.smtpServer.Close(); err != nil {
|
|
logrus.WithError(err).Debug("Failed to close SMTP server (expected -- we close the listener ourselves)")
|
|
}
|
|
|
|
bridge.publish(events.SMTPServerStopped{})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sm *ServerManager) closeIMAPServer(ctx context.Context, bridge *Bridge) error {
|
|
logrus.Info("Closing IMAP server")
|
|
|
|
if sm.imapServer != nil {
|
|
if err := sm.imapServer.Close(ctx); err != nil {
|
|
return fmt.Errorf("failed to close IMAP server: %w", err)
|
|
}
|
|
|
|
sm.imapServer = nil
|
|
}
|
|
|
|
if sm.imapListener != nil {
|
|
if err := sm.imapListener.Close(); err != nil {
|
|
return fmt.Errorf("failed to close IMAP listener: %w", err)
|
|
}
|
|
|
|
sm.imapListener = nil
|
|
}
|
|
|
|
bridge.publish(events.IMAPServerStopped{})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sm *ServerManager) restartIMAP(ctx context.Context, bridge *Bridge) error {
|
|
logrus.Info("Restarting IMAP server")
|
|
|
|
if sm.imapListener != nil {
|
|
if err := sm.imapListener.Close(); err != nil {
|
|
return fmt.Errorf("failed to close IMAP listener: %w", err)
|
|
}
|
|
|
|
sm.imapListener = nil
|
|
|
|
bridge.publish(events.IMAPServerStopped{})
|
|
}
|
|
|
|
return sm.serveIMAP(ctx, bridge)
|
|
}
|
|
|
|
func (sm *ServerManager) restartSMTP(bridge *Bridge) error {
|
|
logrus.Info("Restarting SMTP server")
|
|
|
|
if err := sm.closeSMTPServer(bridge); err != nil {
|
|
return fmt.Errorf("failed to close SMTP: %w", err)
|
|
}
|
|
|
|
bridge.publish(events.SMTPServerStopped{})
|
|
|
|
sm.smtpServer = newSMTPServer(bridge, bridge.tlsConfig, bridge.logSMTP)
|
|
|
|
return sm.serveSMTP(bridge)
|
|
}
|
|
|
|
func (sm *ServerManager) serveSMTP(bridge *Bridge) error {
|
|
port, err := func() (int, error) {
|
|
logrus.WithFields(logrus.Fields{
|
|
"port": bridge.vault.GetSMTPPort(),
|
|
"ssl": bridge.vault.GetSMTPSSL(),
|
|
}).Info("Starting SMTP server")
|
|
|
|
smtpListener, err := newListener(bridge.vault.GetSMTPPort(), bridge.vault.GetSMTPSSL(), bridge.tlsConfig)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to create SMTP listener: %w", err)
|
|
}
|
|
|
|
sm.smtpListener = smtpListener
|
|
|
|
bridge.tasks.Once(func(context.Context) {
|
|
if err := sm.smtpServer.Serve(smtpListener); err != nil {
|
|
logrus.WithError(err).Info("SMTP server stopped")
|
|
}
|
|
})
|
|
|
|
if err := bridge.vault.SetSMTPPort(getPort(smtpListener.Addr())); err != nil {
|
|
return 0, fmt.Errorf("failed to store SMTP port in vault: %w", err)
|
|
}
|
|
|
|
return getPort(smtpListener.Addr()), nil
|
|
}()
|
|
|
|
if err != nil {
|
|
bridge.publish(events.SMTPServerError{
|
|
Error: err,
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
bridge.publish(events.SMTPServerReady{
|
|
Port: port,
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sm *ServerManager) serveIMAP(ctx context.Context, bridge *Bridge) error {
|
|
port, err := func() (int, error) {
|
|
if sm.imapServer == nil {
|
|
return 0, fmt.Errorf("no IMAP server instance running")
|
|
}
|
|
|
|
logrus.WithFields(logrus.Fields{
|
|
"port": bridge.vault.GetIMAPPort(),
|
|
"ssl": bridge.vault.GetIMAPSSL(),
|
|
}).Info("Starting IMAP server")
|
|
|
|
imapListener, err := newListener(bridge.vault.GetIMAPPort(), bridge.vault.GetIMAPSSL(), bridge.tlsConfig)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to create IMAP listener: %w", err)
|
|
}
|
|
|
|
sm.imapListener = imapListener
|
|
|
|
if err := sm.imapServer.Serve(ctx, sm.imapListener); err != nil {
|
|
return 0, fmt.Errorf("failed to serve IMAP: %w", err)
|
|
}
|
|
|
|
if err := bridge.vault.SetIMAPPort(getPort(imapListener.Addr())); err != nil {
|
|
return 0, fmt.Errorf("failed to store IMAP port in vault: %w", err)
|
|
}
|
|
|
|
return getPort(imapListener.Addr()), nil
|
|
}()
|
|
|
|
if err != nil {
|
|
bridge.publish(events.IMAPServerError{
|
|
Error: err,
|
|
})
|
|
|
|
return err
|
|
}
|
|
|
|
bridge.publish(events.IMAPServerReady{
|
|
Port: port,
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sm *ServerManager) handleSetGluonDir(ctx context.Context, bridge *Bridge, newGluonDir string) error {
|
|
return safe.RLockRet(func() error {
|
|
currentGluonDir := bridge.GetGluonCacheDir()
|
|
newGluonDir = filepath.Join(newGluonDir, "gluon")
|
|
if newGluonDir == currentGluonDir {
|
|
return fmt.Errorf("new gluon dir is the same as the old one")
|
|
}
|
|
|
|
if err := sm.closeIMAPServer(context.Background(), bridge); err != nil {
|
|
return fmt.Errorf("failed to close IMAP: %w", err)
|
|
}
|
|
|
|
if err := bridge.moveGluonCacheDir(currentGluonDir, newGluonDir); err != nil {
|
|
logrus.WithError(err).Error("failed to move GluonCacheDir")
|
|
|
|
if err := bridge.vault.SetGluonDir(currentGluonDir); err != nil {
|
|
return fmt.Errorf("failed to revert GluonCacheDir: %w", err)
|
|
}
|
|
}
|
|
|
|
bridge.heartbeat.SetCacheLocation(newGluonDir)
|
|
|
|
gluonDataDir, err := bridge.GetGluonDataDir()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get Gluon Database directory: %w", err)
|
|
}
|
|
|
|
imapServer, err := newIMAPServer(
|
|
bridge.vault.GetGluonCacheDir(),
|
|
gluonDataDir,
|
|
bridge.curVersion,
|
|
bridge.tlsConfig,
|
|
bridge.reporter,
|
|
bridge.logIMAPClient,
|
|
bridge.logIMAPServer,
|
|
bridge.imapEventCh,
|
|
bridge.tasks,
|
|
bridge.uidValidityGenerator,
|
|
bridge.panicHandler,
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create new IMAP server: %w", err)
|
|
}
|
|
|
|
sm.imapServer = imapServer
|
|
|
|
for _, bridgeUser := range bridge.users {
|
|
if err := sm.handleAddIMAPUser(ctx, bridgeUser); err != nil {
|
|
return fmt.Errorf("failed to add users to new IMAP server: %w", err)
|
|
}
|
|
}
|
|
|
|
if err := sm.serveIMAP(ctx, bridge); err != nil {
|
|
return fmt.Errorf("failed to serve IMAP: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}, bridge.usersLock)
|
|
}
|
|
|
|
func (sm *ServerManager) handleAddGluonUser(ctx context.Context, conn connector.Connector, passphrase []byte) (string, error) {
|
|
if sm.imapServer == nil {
|
|
return "", fmt.Errorf("no imap server instance running")
|
|
}
|
|
|
|
return sm.imapServer.AddUser(ctx, conn, passphrase)
|
|
}
|
|
|
|
func (sm *ServerManager) handleRemoveGluonUser(ctx context.Context, userID string) error {
|
|
if sm.imapServer == nil {
|
|
return fmt.Errorf("no imap server instance running")
|
|
}
|
|
|
|
return sm.imapServer.RemoveUser(ctx, userID, true)
|
|
}
|
|
|
|
type smRequestClose struct{}
|
|
|
|
type smRequestRestartIMAP struct{}
|
|
|
|
type smRequestRestartSMTP struct{}
|
|
|
|
type smRequestAddIMAPUser struct {
|
|
user *user.User
|
|
}
|
|
|
|
type smRequestRemoveIMAPUser struct {
|
|
user *user.User
|
|
withData bool
|
|
}
|
|
|
|
type smRequestSetGluonDir struct {
|
|
dir string
|
|
}
|
|
|
|
type smRequestAddGluonUser struct {
|
|
conn connector.Connector
|
|
passphrase []byte
|
|
}
|
|
|
|
type smRequestRemoveGluonUser struct {
|
|
userID string
|
|
}
|