imapserver: implement support for NOTIFY

Author: WhyNotHugo

imapserver/capability.go

@@ -93,6 +93,7 @@ func (c *Conn) availableCaps() []imap.Cap {
 			imap.CapCreateSpecialUse,
 			imap.CapLiteralPlus,
 			imap.CapUnauthenticate,
+			imap.CapNotify,
 		})
 
 		if appendLimitSession, ok := c.session.(SessionAppendLimit); ok {

imapserver/conn.go

@@ -153,6 +153,9 @@ func (c *Conn) serve() {
 	if _, ok := c.session.(SessionUnauthenticate); !ok && caps.Has(imap.CapUnauthenticate) {
 		panic("imapserver: server advertises UNAUTHENTICATE but session doesn't support it")
 	}
+	if _, ok := c.session.(SessionNotify); !ok && caps.Has(imap.CapNotify) {
+		panic("imapserver: server advertises NOTIFY but session doesn't support it")
+	}
 
 	c.state = imap.ConnStateNotAuthenticated
 	statusType := imap.StatusResponseTypeOK
@@ -253,6 +256,8 @@ func (c *Conn) readCommand(dec *imapwire.Decoder) error {
 		err = c.handleNamespace(dec)
 	case "IDLE":
 		err = c.handleIdle(dec)
+	case "NOTIFY":
+		err = c.handleNotify(dec)
 	case "SELECT", "EXAMINE":
 		err = c.handleSelect(tag, dec, name == "EXAMINE")
 		sendOK = false

imapserver/notify.go

@@ -0,0 +1,248 @@
+package imapserver
+
+import (
+	"strings"
+
+	"github.com/emersion/go-imap/v2"
+	"github.com/emersion/go-imap/v2/internal/imapwire"
+)
+
+func (c *Conn) handleNotify(dec *imapwire.Decoder) error {
+	options, err := readNotifyOptions(dec)
+	if err != nil {
+		return err
+	}
+
+	if err := c.checkState(imap.ConnStateAuthenticated); err != nil {
+		return err
+	}
+
+	session, ok := c.session.(SessionNotify)
+	if !ok {
+		return &imap.Error{
+			Type: imap.StatusResponseTypeBad,
+			Text: "NOTIFY not supported",
+		}
+	}
+
+	w := &UpdateWriter{conn: c, allowExpunge: true}
+	return session.Notify(w, options)
+}
+
+// readNotifyOptions parses the NOTIFY command arguments from the decoder.
+// Returns nil options for NOTIFY NONE, or populated options for NOTIFY SET.
+func readNotifyOptions(dec *imapwire.Decoder) (*imap.NotifyOptions, error) {
+	if !dec.ExpectSP() {
+		return nil, dec.Err()
+	}
+
+	// Check for NONE or SET
+	var atom string
+	if !dec.ExpectAtom(&atom) {
+		return nil, dec.Err()
+	}
+
+	atom = strings.ToUpper(atom)
+	if atom == "NONE" {
+		// NOTIFY NONE - disable all notifications
+		if !dec.ExpectCRLF() {
+			return nil, dec.Err()
+		}
+		return nil, nil
+	} else if atom == "SET" {
+		// NOTIFY SET - set notifications
+		options := &imap.NotifyOptions{}
+
+		// Parse items until we hit CRLF
+		for {
+			// We need at least a space before each item
+			if !dec.SP() {
+				return nil, &imap.Error{
+					Type: imap.StatusResponseTypeBad,
+					Text: "Expected SP after SET or between items",
+				}
+			}
+
+			// Parse a list
+			isList, err := dec.List(func() error {
+				// First element in the list: check if it's STATUS or a mailbox spec
+				var firstAtom string
+				if dec.Atom(&firstAtom) {
+					firstAtom = strings.ToUpper(firstAtom)
+					if firstAtom == "STATUS" {
+						// This is the STATUS parameter
+						options.STATUS = true
+						return nil
+					}
+
+					// It's a mailbox spec or SUBTREE, parse as a notify item
+					item, err := parseNotifyItemFromAtom(dec, firstAtom)
+					if err != nil {
+						return err
+					}
+					options.Items = append(options.Items, *item)
+					return nil
+				}
+
+				// Not an atom, try to parse as mailbox list
+				item, err := parseNotifyItemMailboxList(dec)
+				if err != nil {
+					return err
+				}
+				options.Items = append(options.Items, *item)
+				return nil
+			})
+			if err != nil {
+				return nil, err
+			}
+			if !isList {
+				return nil, &imap.Error{
+					Type: imap.StatusResponseTypeBad,
+					Text: "Expected list",
+				}
+			}
+
+			// Check if we're done (CRLF)
+			if dec.CRLF() {
+				break
+			}
+		}
+
+		if len(options.Items) == 0 && !options.STATUS {
+			return nil, &imap.Error{
+				Type: imap.StatusResponseTypeBad,
+				Text: "NOTIFY SET requires at least one mailbox specification",
+			}
+		}
+
+		return options, nil
+	} else {
+		return nil, &imap.Error{
+			Type: imap.StatusResponseTypeBad,
+			Text: "Expected NONE or SET",
+		}
+	}
+}
+
+// parseNotifyItemFromAtom parses a notify item that starts with an atom (mailbox spec or SUBTREE)
+func parseNotifyItemFromAtom(dec *imapwire.Decoder, firstAtom string) (*imap.NotifyItem, error) {
+	item := &imap.NotifyItem{}
+
+	switch firstAtom {
+	case "SELECTED", "SELECTED-DELAYED", "PERSONAL", "INBOXES", "SUBSCRIBED":
+		item.MailboxSpec = imap.NotifyMailboxSpec(firstAtom)
+
+		// Check for optional events list
+		if dec.SP() {
+			err := dec.ExpectList(func() error {
+				return readNotifyEvent(dec, item)
+			})
+			if err != nil {
+				return nil, err
+			}
+		}
+		return item, nil
+
+	case "SUBTREE":
+		// SUBTREE mailbox-list [event-list]
+		item.Subtree = true
+
+		if !dec.ExpectSP() {
+			return nil, dec.Err()
+		}
+
+		// Read mailbox list
+		err := dec.ExpectList(func() error {
+			var mailbox string
+			if !dec.ExpectMailbox(&mailbox) {
+				return dec.Err()
+			}
+			item.Mailboxes = append(item.Mailboxes, mailbox)
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		// Check for optional events list
+		if dec.SP() {
+			err := dec.ExpectList(func() error {
+				return readNotifyEvent(dec, item)
+			})
+			if err != nil {
+				return nil, err
+			}
+		}
+		return item, nil
+
+	default:
+		return nil, &imap.Error{
+			Type: imap.StatusResponseTypeBad,
+			Text: "Invalid mailbox specification: " + firstAtom,
+		}
+	}
+}
+
+// parseNotifyItemMailboxList parses a notify item that starts with a mailbox list
+func parseNotifyItemMailboxList(dec *imapwire.Decoder) (*imap.NotifyItem, error) {
+	item := &imap.NotifyItem{}
+
+	// We're already inside a list, so we need to see if the first element is a mailbox or a list
+	// The decoder is positioned at the start of the list content
+	// Try to parse as a nested mailbox list
+	isList, err := dec.List(func() error {
+		var mailbox string
+		if !dec.ExpectMailbox(&mailbox) {
+			return dec.Err()
+		}
+		item.Mailboxes = append(item.Mailboxes, mailbox)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if !isList {
+		return nil, &imap.Error{
+			Type: imap.StatusResponseTypeBad,
+			Text: "Expected mailbox list",
+		}
+	}
+
+	// Check for optional events list
+	if dec.SP() {
+		err := dec.ExpectList(func() error {
+			return readNotifyEvent(dec, item)
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return item, nil
+}
+
+func readNotifyEvent(dec *imapwire.Decoder, item *imap.NotifyItem) error {
+	var event string
+	if !dec.ExpectAtom(&event) {
+		return dec.Err()
+	}
+
+	// Validate event name
+	switch imap.NotifyEvent(event) {
+	case imap.NotifyEventMessageNew,
+		imap.NotifyEventMessageExpunge,
+		imap.NotifyEventFlagChange,
+		imap.NotifyEventAnnotationChange,
+		imap.NotifyEventMailboxName,
+		imap.NotifyEventSubscriptionChange,
+		imap.NotifyEventMailboxMetadataChange,
+		imap.NotifyEventServerMetadataChange:
+		item.Events = append(item.Events, imap.NotifyEvent(event))
+		return nil
+	default:
+		return &imap.Error{
+			Type: imap.StatusResponseTypeBad,
+			Text: "Unknown NOTIFY event: " + event,
+		}
+	}
+}