proton-bridge/internal/imap/backend.go

// Copyright (c) 2021 Proton Technologies AG
//
// This file is part of ProtonMail Bridge.
//
// ProtonMail 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.
//
// ProtonMail 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 ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.

// Package imap provides IMAP server of the Bridge.
package imap

import (
	"strings"
	"sync"
	"time"

	"github.com/ProtonMail/proton-bridge/internal/bridge"
	"github.com/ProtonMail/proton-bridge/internal/events"
	"github.com/ProtonMail/proton-bridge/pkg/listener"
	"github.com/emersion/go-imap"
	goIMAPBackend "github.com/emersion/go-imap/backend"
)

type panicHandler interface {
	HandlePanic()
}

type imapBackend struct {
	panicHandler  panicHandler
	bridge        bridger
	updates       chan goIMAPBackend.Update
	eventListener listener.Listener

	users       map[string]*imapUser
	usersLocker sync.Locker

	imapCache     map[string]map[string]string
	imapCachePath string
	imapCacheLock *sync.RWMutex

	updatesBlocking       map[string]bool
	updatesBlockingLocker sync.Locker
}

// NewIMAPBackend returns struct implementing go-imap/backend interface.
func NewIMAPBackend(
	panicHandler panicHandler,
	eventListener listener.Listener,
	cache cacheProvider,
	bridge *bridge.Bridge,
) *imapBackend { //nolint[golint]
	bridgeWrap := newBridgeWrap(bridge)
	backend := newIMAPBackend(panicHandler, cache, bridgeWrap, eventListener)

	go backend.monitorDisconnectedUsers()

	return backend
}

func newIMAPBackend(
	panicHandler panicHandler,
	cache cacheProvider,
	bridge bridger,
	eventListener listener.Listener,
) *imapBackend {
	return &imapBackend{
		panicHandler:  panicHandler,
		bridge:        bridge,
		updates:       make(chan goIMAPBackend.Update),
		eventListener: eventListener,

		users:       map[string]*imapUser{},
		usersLocker: &sync.Mutex{},

		imapCachePath: cache.GetIMAPCachePath(),
		imapCacheLock: &sync.RWMutex{},

		updatesBlocking:       map[string]bool{},
		updatesBlockingLocker: &sync.Mutex{},
	}
}

func (ib *imapBackend) getUser(address string) (*imapUser, error) {
	ib.usersLocker.Lock()
	defer ib.usersLocker.Unlock()

	address = strings.ToLower(address)
	imapUser, ok := ib.users[address]
	if ok {
		return imapUser, nil
	}
	return ib.createUser(address)
}

// createUser require that address MUST be in lowercase.
func (ib *imapBackend) createUser(address string) (*imapUser, error) {
	log.WithField("address", address).Debug("Creating new IMAP user")

	user, err := ib.bridge.GetUser(address)
	if err != nil {
		return nil, err
	}

	// Make sure you return the same user for all valid addresses when in combined mode.
	if user.IsCombinedAddressMode() {
		address = strings.ToLower(user.GetPrimaryAddress())
		if combinedUser, ok := ib.users[address]; ok {
			return combinedUser, nil
		}
	}

	// Client can log in only using address so we can properly close all IMAP connections.
	var addressID string
	if addressID, err = user.GetAddressID(address); err != nil {
		return nil, err
	}

	newUser, err := newIMAPUser(ib.panicHandler, ib, user, addressID, address)
	if err != nil {
		return nil, err
	}

	ib.users[address] = newUser

	return newUser, nil
}

// deleteUser removes a user from the users map.
// This is a safe operation even if the user doesn't exist so it is no problem if it is done twice.
func (ib *imapBackend) deleteUser(address string) {
	log.WithField("address", address).Debug("Deleting IMAP user")

	ib.usersLocker.Lock()
	defer ib.usersLocker.Unlock()

	delete(ib.users, strings.ToLower(address))
}

// Login authenticates a user.
func (ib *imapBackend) Login(_ *imap.ConnInfo, username, password string) (goIMAPBackend.User, error) {
	// Called from go-imap in goroutines - we need to handle panics for each function.
	defer ib.panicHandler.HandlePanic()

	imapUser, err := ib.getUser(username)
	if err != nil {
		log.WithError(err).Warn("Cannot get user")
		return nil, err
	}

	if err := imapUser.user.CheckBridgeLogin(password); err != nil {
		log.WithError(err).Error("Could not check bridge password")
		if err := imapUser.Logout(); err != nil {
			log.WithError(err).Warn("Could not logout user after unsuccessful login check")
		}
		// Apple Mail sometimes generates a lot of requests very quickly.
		// It's therefore good to have a timeout after a bad login so that we can slow
		// those requests down a little bit.
		time.Sleep(10 * time.Second)
		return nil, err
	}

	// The update channel should be nil until we try to login to IMAP for the first time
	// so that it doesn't make bridge slow for users who are only using bridge for SMTP
	// (otherwise the store will be locked for 1 sec per email during synchronization).
	if store := imapUser.user.GetStore(); store != nil {
		store.SetChangeNotifier(ib)
	}

	return imapUser, nil
}

// Updates returns a channel of updates for IMAP IDLE extension.
func (ib *imapBackend) Updates() <-chan goIMAPBackend.Update {
	// Called from go-imap in goroutines - we need to handle panics for each function.
	defer ib.panicHandler.HandlePanic()

	return ib.updates
}

func (ib *imapBackend) CreateMessageLimit() *uint32 {
	return nil
}

// monitorDisconnectedUsers removes users when it receives a close connection event for them.
func (ib *imapBackend) monitorDisconnectedUsers() {
	ch := make(chan string)
	ib.eventListener.Add(events.CloseConnectionEvent, ch)

	for address := range ch {
		// delete the user to ensure future imap login attempts use the latest bridge user
		// (bridge user might be removed-readded so we want to use the new bridge user object).
		ib.deleteUser(address)
	}
}