75.2 IMAP: новый сервер на Reactor Netty (STARTTLS, 993, IDLE, UIDPLUS, MOVE)
Старый IMAP (выключен, .block() на сетевом потоке) удалён, написан заново:
- ImapServer: декодер целых команд с литералами ({n} после "+ Ready", {n+}),
команды по одной на рабочем потоке; STARTTLS (без выполнения открытого текста
после него) и неявный TLS; IDLE с опросом раз в 5 с до DONE
- ImapSession: IMAP4rev1 + LITERAL+, SASL-IR, IDLE, UIDPLUS, MOVE, UNSELECT,
NAMESPACE, SPECIAL-USE, ID; FETCH (ENVELOPE, BODYSTRUCTURE, BODY[section]<partial>),
SEARCH, STORE, COPY/MOVE с COPYUID, APPEND с APPENDUID, EXPUNGE/UID EXPUNGE
- MimeTree: части письма по байтам — размеры BODYSTRUCTURE совпадают с BODY[]
- V4: UID на папку выдаёт триггер (перенос из веба тоже получает новый UID),
флаги \Answered/\Deleted, message_sources — письмо как пришло (SMTP, APPEND)
или собранное один раз (MimeSource); правка черновика сбрасывает его
- тесты: настоящий клиент Angus IMAP, сырые литералы/IDLE/подмешивание (47 всего)
- живая проверка: обновление V3 -> V4 на PostgreSQL с письмами, Python imaplib:
STARTTLS, 993, папки, вложения, поиск, APPEND/COPY/MOVE/EXPUNGE, IDLE — 0 ошибок
α
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,285 @@
|
||||
package com.mailserver.imap;
|
||||
|
||||
import com.mailserver.domain.Attachment;
|
||||
import com.mailserver.domain.Message;
|
||||
import com.mailserver.domain.User;
|
||||
import com.mailserver.repository.AttachmentRepository;
|
||||
import com.mailserver.repository.MessageRepository;
|
||||
import com.mailserver.repository.UserRepository;
|
||||
import com.mailserver.service.LocalDelivery;
|
||||
import com.mailserver.service.MailService;
|
||||
import com.mailserver.service.MessageSources;
|
||||
import com.mailserver.service.UserService;
|
||||
import jakarta.mail.Session;
|
||||
import jakarta.mail.internet.InternetAddress;
|
||||
import jakarta.mail.internet.MimeMessage;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import org.springframework.r2dbc.core.DatabaseClient;
|
||||
import org.springframework.web.server.ResponseStatusException;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
import java.time.Instant;
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.ZoneOffset;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Properties;
|
||||
import java.util.UUID;
|
||||
|
||||
/** {@link ImapStore} over the mail server's PostgreSQL tables (the same data the web client shows). */
|
||||
public class DbImapStore implements ImapStore {
|
||||
|
||||
private static final Logger log = LoggerFactory.getLogger(DbImapStore.class);
|
||||
|
||||
private final DatabaseClient db;
|
||||
private final UserRepository users;
|
||||
private final UserService userService;
|
||||
private final MailService mailService;
|
||||
private final MessageRepository messages;
|
||||
private final AttachmentRepository attachments;
|
||||
private final MessageSources sources;
|
||||
private final String hostname;
|
||||
|
||||
public DbImapStore(DatabaseClient db, UserRepository users, UserService userService, MailService mailService,
|
||||
MessageRepository messages, AttachmentRepository attachments, MessageSources sources,
|
||||
String hostname) {
|
||||
this.db = db;
|
||||
this.users = users;
|
||||
this.userService = userService;
|
||||
this.mailService = mailService;
|
||||
this.messages = messages;
|
||||
this.attachments = attachments;
|
||||
this.sources = sources;
|
||||
this.hostname = hostname;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Account authenticate(String username, String password) {
|
||||
User user = users.findByEmail(username.trim().toLowerCase(Locale.ROOT)).block();
|
||||
if (user == null || !user.isActive() || !userService.checkPassword(user, password)) {
|
||||
return null;
|
||||
}
|
||||
return new Account(user.getId(), user.getEmail());
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<Mailbox> mailboxes(long userId) {
|
||||
return db.sql("SELECT id, name, is_system, uid_validity, uid_next FROM folders WHERE user_id = :u ORDER BY id")
|
||||
.bind("u", userId)
|
||||
.map(row -> new Mailbox(row.get("id", Long.class), row.get("name", String.class),
|
||||
Boolean.TRUE.equals(row.get("is_system", Boolean.class)),
|
||||
row.get("uid_validity", Long.class), row.get("uid_next", Long.class)))
|
||||
.all().collectList().block();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Mailbox create(long userId, String name) {
|
||||
try {
|
||||
var created = mailService.createFolder(userId, name).block();
|
||||
return mailboxes(userId).stream().filter(m -> m.id() == created.id()).findFirst().orElseThrow();
|
||||
} catch (ResponseStatusException e) {
|
||||
throw new Refused(e.getReason());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void rename(long userId, Mailbox mailbox, String newName) {
|
||||
try {
|
||||
mailService.renameFolder(mailbox.id(), userId, newName).block();
|
||||
} catch (ResponseStatusException e) {
|
||||
throw new Refused(e.getReason());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void delete(long userId, Mailbox mailbox) {
|
||||
try {
|
||||
mailService.deleteFolder(mailbox.id(), userId).block();
|
||||
} catch (ResponseStatusException e) {
|
||||
throw new Refused(e.getReason());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<Entry> entries(long folderId) {
|
||||
return db.sql("SELECT id, uid, is_read, is_flagged, is_answered, is_deleted, received_at FROM messages "
|
||||
+ "WHERE folder_id = :f ORDER BY uid")
|
||||
.bind("f", folderId)
|
||||
.map(row -> new Entry(row.get("id", Long.class), row.get("uid", Long.class),
|
||||
Boolean.TRUE.equals(row.get("is_read", Boolean.class)),
|
||||
Boolean.TRUE.equals(row.get("is_flagged", Boolean.class)),
|
||||
Boolean.TRUE.equals(row.get("is_answered", Boolean.class)),
|
||||
Boolean.TRUE.equals(row.get("is_deleted", Boolean.class)),
|
||||
instant(row.get("received_at"))))
|
||||
.all().collectList().block();
|
||||
}
|
||||
|
||||
@Override
|
||||
public byte[] source(long messageId) {
|
||||
byte[] raw = sources.get(messageId).block();
|
||||
if (raw != null) {
|
||||
return raw;
|
||||
}
|
||||
Message message = messages.findById(messageId).block();
|
||||
if (message == null) {
|
||||
return new byte[0];
|
||||
}
|
||||
try {
|
||||
List<Attachment> files = attachments.findByMessageId(messageId).collectList().block();
|
||||
raw = MimeSource.build(message, files, hostname);
|
||||
} catch (Exception e) {
|
||||
log.warn("IMAP: cannot build message {}: {}", messageId, e.toString());
|
||||
return ("Subject: " + message.getSubject() + "\r\n\r\n" + message.getBody()).getBytes();
|
||||
}
|
||||
sources.put(messageId, raw).block();
|
||||
return raw;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setFlags(long messageId, boolean seen, boolean flagged, boolean answered, boolean deleted) {
|
||||
db.sql("UPDATE messages SET is_read = :s, is_flagged = :f, is_answered = :a, is_deleted = :d WHERE id = :id")
|
||||
.bind("s", seen).bind("f", flagged).bind("a", answered).bind("d", deleted).bind("id", messageId)
|
||||
.then().block();
|
||||
}
|
||||
|
||||
@Override
|
||||
public long append(long userId, Mailbox target, byte[] raw, boolean seen, boolean flagged, boolean answered,
|
||||
boolean deleted, Instant internalDate) {
|
||||
try {
|
||||
MimeMessage mime = new MimeMessage(Session.getInstance(new Properties()), new ByteArrayInputStream(raw));
|
||||
Message message = new Message();
|
||||
message.setFolderId(target.id());
|
||||
String senderEmail = "unknown@" + hostname;
|
||||
String senderName = null;
|
||||
if (mime.getFrom() != null && mime.getFrom().length > 0 && mime.getFrom()[0] instanceof InternetAddress from) {
|
||||
senderEmail = from.getAddress();
|
||||
senderName = from.getPersonal();
|
||||
}
|
||||
message.setSenderEmail(senderEmail);
|
||||
message.setSenderName(senderName);
|
||||
String to = LocalDelivery.addresses(mime, jakarta.mail.Message.RecipientType.TO);
|
||||
message.setRecipientEmail(to == null ? "" : to);
|
||||
message.setCcEmail(LocalDelivery.addresses(mime, jakarta.mail.Message.RecipientType.CC));
|
||||
message.setSubject(mime.getSubject() == null ? "" : mime.getSubject());
|
||||
LocalDelivery.Body body = LocalDelivery.body(mime);
|
||||
message.setBody(body.text());
|
||||
message.setHtml(body.html());
|
||||
message.setRead(seen);
|
||||
message.setFlagged(flagged);
|
||||
message.setSpam(target.system() && "Spam".equals(target.name()));
|
||||
message.setReceivedAt(internalDate == null ? Instant.now() : internalDate);
|
||||
String messageId = mime.getMessageID();
|
||||
message.setMessageId(messageId == null ? UUID.randomUUID().toString() : messageId.replaceAll("^<|>$", ""));
|
||||
message.setMessageSize((long) raw.length);
|
||||
Message stored = messages.save(message).block();
|
||||
for (LocalDelivery.FilePart file : LocalDelivery.attachments(mime)) {
|
||||
mailService.storeIncomingAttachment(stored.getId(), file.name(), file.contentType(), file.bytes());
|
||||
}
|
||||
sources.put(stored.getId(), raw).block();
|
||||
setFlags(stored.getId(), seen, flagged, answered, deleted);
|
||||
return uid(stored.getId());
|
||||
} catch (Refused e) {
|
||||
throw e;
|
||||
} catch (Exception e) {
|
||||
log.warn("IMAP APPEND to {} failed: {}", target.name(), e.toString());
|
||||
throw new Refused("Cannot store the message: " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<Long> copy(long userId, List<Entry> list, Mailbox target) {
|
||||
boolean spam = target.system() && "Spam".equals(target.name());
|
||||
List<Long> uids = new ArrayList<>();
|
||||
for (Entry entry : list) {
|
||||
Long newId = db.sql("INSERT INTO messages (folder_id, sender_email, sender_name, recipient_email, cc_email, "
|
||||
+ "subject, body, is_html, is_read, is_flagged, is_spam, is_answered, is_deleted, message_size, "
|
||||
+ "received_at, message_id) "
|
||||
+ "SELECT :t, sender_email, sender_name, recipient_email, cc_email, subject, body, is_html, "
|
||||
+ "is_read, is_flagged, :spam, is_answered, is_deleted, message_size, received_at, message_id "
|
||||
+ "FROM messages WHERE id = :id RETURNING id")
|
||||
.bind("t", target.id()).bind("spam", spam).bind("id", entry.id())
|
||||
.map(row -> row.get("id", Long.class)).one().block();
|
||||
if (newId == null) {
|
||||
continue;
|
||||
}
|
||||
for (Attachment attachment : attachments.findByMessageId(entry.id()).collectList().block()) {
|
||||
copyAttachment(attachment, newId);
|
||||
}
|
||||
db.sql("INSERT INTO message_sources (message_id, raw) SELECT :n, raw FROM message_sources WHERE message_id = :o")
|
||||
.bind("n", newId).bind("o", entry.id()).then().block();
|
||||
uids.add(uid(newId));
|
||||
}
|
||||
return uids;
|
||||
}
|
||||
|
||||
private void copyAttachment(Attachment attachment, long newMessageId) {
|
||||
try {
|
||||
Path from = Paths.get(attachment.getFilePath());
|
||||
Path to = from.resolveSibling(UUID.randomUUID() + "_" + from.getFileName().toString().replaceFirst("^[0-9a-f-]{36}_", ""));
|
||||
Files.copy(from, to);
|
||||
Attachment copy = new Attachment();
|
||||
copy.setMessageId(newMessageId);
|
||||
copy.setFilename(attachment.getFilename());
|
||||
copy.setContentType(attachment.getContentType());
|
||||
copy.setSizeBytes(attachment.getSizeBytes());
|
||||
copy.setFilePath(to.toString());
|
||||
copy.setContentId(attachment.getContentId());
|
||||
attachments.save(copy).block();
|
||||
} catch (IOException e) {
|
||||
log.warn("IMAP COPY: attachment {} not copied: {}", attachment.getFilePath(), e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<Long> move(long userId, List<Entry> list, Mailbox target) {
|
||||
boolean spam = target.system() && "Spam".equals(target.name());
|
||||
List<Long> uids = new ArrayList<>();
|
||||
for (Entry entry : list) {
|
||||
Long uid = db.sql("UPDATE messages SET folder_id = :t, is_spam = :spam WHERE id = :id RETURNING uid")
|
||||
.bind("t", target.id()).bind("spam", spam).bind("id", entry.id())
|
||||
.map(row -> row.get("uid", Long.class)).one().block();
|
||||
if (uid != null) {
|
||||
uids.add(uid);
|
||||
}
|
||||
}
|
||||
return uids;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void expunge(List<Long> messageIds) {
|
||||
for (Long id : messageIds) {
|
||||
for (Attachment attachment : attachments.findByMessageId(id).collectList().block()) {
|
||||
try {
|
||||
Files.deleteIfExists(Paths.get(attachment.getFilePath()));
|
||||
} catch (IOException e) {
|
||||
log.warn("Attachment file {} not deleted: {}", attachment.getFilePath(), e.getMessage());
|
||||
}
|
||||
}
|
||||
messages.deleteById(id).block();
|
||||
}
|
||||
}
|
||||
|
||||
private long uid(long messageId) {
|
||||
return db.sql("SELECT uid FROM messages WHERE id = :id").bind("id", messageId)
|
||||
.map(row -> row.get("uid", Long.class)).one().block();
|
||||
}
|
||||
|
||||
private static Instant instant(Object value) {
|
||||
if (value instanceof Instant instant) {
|
||||
return instant;
|
||||
}
|
||||
if (value instanceof LocalDateTime local) {
|
||||
return local.toInstant(ZoneOffset.UTC);
|
||||
}
|
||||
if (value instanceof java.time.OffsetDateTime offset) {
|
||||
return offset.toInstant();
|
||||
}
|
||||
return Instant.EPOCH;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
package com.mailserver.imap;
|
||||
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Reads one IMAP command: the decoder has already collected it whole, with its literals inline
|
||||
* ("{n}\r\n" + n bytes, or "{n+}\r\n" + n bytes).
|
||||
*/
|
||||
final class ImapReader {
|
||||
|
||||
static final class SyntaxError extends RuntimeException {
|
||||
SyntaxError(String message) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
||||
private final byte[] b;
|
||||
private int pos;
|
||||
|
||||
ImapReader(byte[] command) {
|
||||
this(command, true);
|
||||
}
|
||||
|
||||
private ImapReader(byte[] command, boolean stripLineEnd) {
|
||||
int end = command.length;
|
||||
if (!stripLineEnd) {
|
||||
this.b = command;
|
||||
return;
|
||||
}
|
||||
if (end > 0 && command[end - 1] == '\n') {
|
||||
end--;
|
||||
}
|
||||
if (end > 0 && command[end - 1] == '\r') {
|
||||
end--;
|
||||
}
|
||||
this.b = java.util.Arrays.copyOf(command, end);
|
||||
}
|
||||
|
||||
boolean atEnd() {
|
||||
return pos >= b.length;
|
||||
}
|
||||
|
||||
int peek() {
|
||||
return pos < b.length ? b[pos] & 0xff : -1;
|
||||
}
|
||||
|
||||
void sp() {
|
||||
if (peek() != ' ') {
|
||||
throw new SyntaxError("Expected a space");
|
||||
}
|
||||
while (peek() == ' ') {
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
|
||||
boolean optionalSp() {
|
||||
if (peek() == ' ') {
|
||||
sp();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void expect(char c) {
|
||||
if (peek() != c) {
|
||||
throw new SyntaxError("Expected '" + c + "'");
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
|
||||
/** Characters up to a space, parenthesis, or the end (an atom; also tags, sequence sets, flags). */
|
||||
String atom() {
|
||||
int start = pos;
|
||||
while (pos < b.length) {
|
||||
int c = b[pos] & 0xff;
|
||||
if (c == ' ' || c == '(' || c == ')' || c == '{' || c == '"' || c < 0x20 || c == 0x7f) {
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
if (pos == start) {
|
||||
throw new SyntaxError("Expected an atom");
|
||||
}
|
||||
return new String(b, start, pos - start, StandardCharsets.UTF_8);
|
||||
}
|
||||
|
||||
/** Atom, quoted string or literal. */
|
||||
String astring() {
|
||||
int c = peek();
|
||||
if (c == '"' || c == '{') {
|
||||
return new String(stringBytes(), StandardCharsets.UTF_8);
|
||||
}
|
||||
return atom();
|
||||
}
|
||||
|
||||
/** Quoted string or literal, raw bytes. */
|
||||
byte[] stringBytes() {
|
||||
int c = peek();
|
||||
if (c == '"') {
|
||||
pos++;
|
||||
java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
|
||||
while (true) {
|
||||
if (pos >= b.length) {
|
||||
throw new SyntaxError("Unterminated quoted string");
|
||||
}
|
||||
byte x = b[pos++];
|
||||
if (x == '"') {
|
||||
return out.toByteArray();
|
||||
}
|
||||
if (x == '\\' && pos < b.length) {
|
||||
x = b[pos++];
|
||||
}
|
||||
out.write(x);
|
||||
}
|
||||
}
|
||||
if (c == '{') {
|
||||
int close = indexOf('}', pos);
|
||||
if (close < 0) {
|
||||
throw new SyntaxError("Bad literal");
|
||||
}
|
||||
String size = new String(b, pos + 1, close - pos - 1, StandardCharsets.US_ASCII);
|
||||
if (size.endsWith("+")) {
|
||||
size = size.substring(0, size.length() - 1);
|
||||
}
|
||||
int length;
|
||||
try {
|
||||
length = Integer.parseInt(size);
|
||||
} catch (NumberFormatException e) {
|
||||
throw new SyntaxError("Bad literal size");
|
||||
}
|
||||
pos = close + 1;
|
||||
if (peek() == '\r') {
|
||||
pos++;
|
||||
}
|
||||
expect('\n');
|
||||
if (pos + length > b.length) {
|
||||
throw new SyntaxError("Literal shorter than announced");
|
||||
}
|
||||
byte[] data = java.util.Arrays.copyOfRange(b, pos, pos + length);
|
||||
pos += length;
|
||||
return data;
|
||||
}
|
||||
throw new SyntaxError("Expected a string");
|
||||
}
|
||||
|
||||
/** "(a b c)" → [a, b, c] (atoms or strings); an atom without parentheses → [atom]. */
|
||||
List<String> list() {
|
||||
List<String> items = new ArrayList<>();
|
||||
if (peek() != '(') {
|
||||
items.add(astring());
|
||||
return items;
|
||||
}
|
||||
pos++;
|
||||
while (peek() == ' ') {
|
||||
pos++;
|
||||
}
|
||||
while (peek() != ')') {
|
||||
if (atEnd()) {
|
||||
throw new SyntaxError("Unterminated list");
|
||||
}
|
||||
items.add(astring());
|
||||
while (peek() == ' ') {
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
pos++;
|
||||
return items;
|
||||
}
|
||||
|
||||
/** Everything left, as text (used for FETCH attributes and SEARCH keys parsed by their own readers). */
|
||||
String rest() {
|
||||
String text = new String(b, pos, b.length - pos, StandardCharsets.UTF_8);
|
||||
pos = b.length;
|
||||
return text;
|
||||
}
|
||||
|
||||
/** A reader over the rest, as is (SEARCH may hold literals). */
|
||||
ImapReader restReader() {
|
||||
ImapReader reader = new ImapReader(java.util.Arrays.copyOfRange(b, pos, b.length), false);
|
||||
pos = b.length;
|
||||
return reader;
|
||||
}
|
||||
|
||||
private int indexOf(char c, int from) {
|
||||
for (int i = from; i < b.length; i++) {
|
||||
if (b[i] == c) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,260 @@
|
||||
package com.mailserver.imap;
|
||||
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import io.netty.buffer.Unpooled;
|
||||
import io.netty.channel.ChannelHandlerContext;
|
||||
import io.netty.channel.ChannelPipeline;
|
||||
import io.netty.handler.codec.ByteToMessageDecoder;
|
||||
import io.netty.handler.codec.TooLongFrameException;
|
||||
import io.netty.handler.ssl.SslContext;
|
||||
import io.netty.handler.ssl.SslHandler;
|
||||
import io.netty.handler.timeout.ReadTimeoutHandler;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import reactor.core.publisher.Flux;
|
||||
import reactor.core.publisher.Mono;
|
||||
import reactor.core.publisher.Sinks;
|
||||
import reactor.core.scheduler.Schedulers;
|
||||
import reactor.netty.Connection;
|
||||
import reactor.netty.DisposableServer;
|
||||
import reactor.netty.NettyOutbound;
|
||||
import reactor.netty.tcp.TcpServer;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.net.InetSocketAddress;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.time.Duration;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
/**
|
||||
* IMAP server (RFC 3501) on Reactor Netty.
|
||||
* <ul>
|
||||
* <li>{@link CommandDecoder} collects whole commands with their literals ({n} — after "+ Ready", {n+} — at once);</li>
|
||||
* <li>each command runs on a worker thread (database, MIME parsing), never on the event loop; responses are written
|
||||
* in order, one command at a time;</li>
|
||||
* <li>TLS: STARTTLS, or implicit TLS on a separate port (993); LOGIN/AUTHENTICATE only inside TLS unless
|
||||
* {@code authWithoutTls}; plain text sent together with STARTTLS is never executed;</li>
|
||||
* <li>IDLE: changes of the selected mailbox are pushed every {@code idlePoll} until DONE.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class ImapServer {
|
||||
|
||||
private static final Logger log = LoggerFactory.getLogger(ImapServer.class);
|
||||
|
||||
static final int MAX_LINE = 64 * 1024;
|
||||
private static final int MAX_QUEUED = 1000;
|
||||
private static final Pattern LITERAL = Pattern.compile("\\{(\\d+)(\\+?)}\r?\n$");
|
||||
private static final Pattern IDLE = Pattern.compile("^(\\S+) IDLE\\s*$", Pattern.CASE_INSENSITIVE);
|
||||
private static final Duration IDLE_MAX = Duration.ofMinutes(29);
|
||||
|
||||
/**
|
||||
* @param tls certificate; null — no TLS
|
||||
* @param implicitTls TLS from the first byte (port 993)
|
||||
* @param maxLiteral the largest literal accepted (APPEND of a big message)
|
||||
* @param idlePoll how often IDLE looks for changes
|
||||
*/
|
||||
public record Settings(String host, int port, String hostname, boolean authWithoutTls, SslContext tls,
|
||||
boolean implicitTls, int maxLiteral, Duration idleTimeout, Duration idlePoll) {
|
||||
}
|
||||
|
||||
/** A whole command and whether it arrived over TLS. */
|
||||
record Command(byte[] bytes, boolean tls) {
|
||||
}
|
||||
|
||||
private final Settings settings;
|
||||
private final ImapStore store;
|
||||
private DisposableServer server;
|
||||
|
||||
public ImapServer(Settings settings, ImapStore store) {
|
||||
this.settings = settings;
|
||||
this.store = store;
|
||||
}
|
||||
|
||||
public void start() {
|
||||
if (settings.implicitTls() && settings.tls() == null) {
|
||||
throw new IllegalStateException("Implicit TLS needs a certificate");
|
||||
}
|
||||
TcpServer tcp = TcpServer.create()
|
||||
.host(settings.host())
|
||||
.port(settings.port())
|
||||
.doOnConnection(connection -> connection
|
||||
.addHandlerFirst("imap-idle", new ReadTimeoutHandler(settings.idleTimeout().toSeconds(), TimeUnit.SECONDS))
|
||||
.addHandlerLast("imap-commands", new CommandDecoder(settings.maxLiteral())));
|
||||
if (settings.implicitTls()) {
|
||||
tcp = tcp.secure(spec -> spec.sslContext(settings.tls()));
|
||||
}
|
||||
server = tcp.handle((inbound, outbound) -> {
|
||||
Connection[] connection = {null};
|
||||
String[] remoteIp = {"unknown"};
|
||||
inbound.withConnection(c -> {
|
||||
connection[0] = c;
|
||||
if (c.address() instanceof InetSocketAddress address && address.getAddress() != null) {
|
||||
remoteIp[0] = address.getAddress().getHostAddress();
|
||||
}
|
||||
});
|
||||
ImapSession session = new ImapSession(
|
||||
new ImapSession.Settings(settings.hostname(), settings.tls() != null, settings.authWithoutTls()),
|
||||
store, remoteIp[0], settings.implicitTls());
|
||||
@SuppressWarnings("unchecked")
|
||||
Sinks.Empty<Void>[] idleDone = new Sinks.Empty[1];
|
||||
|
||||
Flux<byte[]> responses = inbound.receiveObject().cast(Command.class)
|
||||
// DONE ends IDLE while the IDLE command is still running — handled before the queue
|
||||
.filter(command -> {
|
||||
if (session.idling() && isDone(command.bytes())) {
|
||||
if (idleDone[0] != null) {
|
||||
idleDone[0].tryEmitEmpty();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
})
|
||||
// read commands as they come (so DONE is seen during IDLE), run them one by one
|
||||
.onBackpressureBuffer(MAX_QUEUED, dropped -> log.warn("IMAP {}: too many queued commands", session.remoteIp))
|
||||
.concatMap(command -> {
|
||||
if (session.tls && !command.tls()) {
|
||||
// plain text sent together with STARTTLS: never executed, the connection is closed
|
||||
log.warn("IMAP {}: plain-text command after STARTTLS, closing", session.remoteIp);
|
||||
session.closing = true;
|
||||
connection[0].dispose();
|
||||
return Flux.empty();
|
||||
}
|
||||
String text = new String(command.bytes(), StandardCharsets.UTF_8).trim();
|
||||
Matcher idle = IDLE.matcher(text);
|
||||
if (idle.matches()) {
|
||||
idleDone[0] = Sinks.empty();
|
||||
return idle(session, idle.group(1), idleDone[0]);
|
||||
}
|
||||
return blocking(() -> session.handle(command.bytes()));
|
||||
})
|
||||
.onErrorResume(e -> {
|
||||
log.debug("IMAP {}: connection closed: {}", session.remoteIp, e.toString());
|
||||
return Mono.just(ImapSession.line("* BYE " + e.getMessage()));
|
||||
})
|
||||
.takeUntil(response -> session.closing);
|
||||
|
||||
return Flux.concat(Mono.just(session.greeting()), responses)
|
||||
.concatMap(response -> response == ImapSession.STARTTLS_READY
|
||||
? startTls(connection[0], session)
|
||||
: send(outbound, response))
|
||||
.then();
|
||||
})
|
||||
.bindNow(Duration.ofSeconds(10));
|
||||
log.info("IMAP server listening on {}:{} ({}{})", settings.host(), port(), settings.hostname(),
|
||||
settings.implicitTls() ? ", implicit TLS" : settings.tls() != null ? ", STARTTLS" : ", no TLS");
|
||||
}
|
||||
|
||||
private Flux<byte[]> idle(ImapSession session, String tag, Sinks.Empty<Void> done) {
|
||||
Flux<byte[]> polls = Flux.interval(settings.idlePoll())
|
||||
.onBackpressureDrop()
|
||||
.concatMap(tick -> blocking(session::idlePoll))
|
||||
.takeUntilOther(done.asMono())
|
||||
.take(IDLE_MAX);
|
||||
return Flux.concat(
|
||||
blocking(() -> session.idleStart(tag)),
|
||||
Flux.defer(() -> session.idling() ? polls : Flux.empty()),
|
||||
blocking(session::idleEnd));
|
||||
}
|
||||
|
||||
private static boolean isDone(byte[] bytes) {
|
||||
return new String(bytes, StandardCharsets.US_ASCII).trim().toUpperCase(Locale.ROOT).equals("DONE");
|
||||
}
|
||||
|
||||
private static Flux<byte[]> blocking(java.util.concurrent.Callable<List<byte[]>> work) {
|
||||
return Mono.fromCallable(work).subscribeOn(Schedulers.boundedElastic()).flatMapIterable(list -> list);
|
||||
}
|
||||
|
||||
private static Mono<Void> send(NettyOutbound outbound, byte[] response) {
|
||||
return outbound.send(Mono.just(Unpooled.wrappedBuffer(response))).then();
|
||||
}
|
||||
|
||||
/** After the tagged OK of STARTTLS has left in plain text: TLS in front, a fresh decoder (no plain leftovers). */
|
||||
private Mono<Void> startTls(Connection connection, ImapSession session) {
|
||||
ChannelPipeline pipeline = connection.channel().pipeline();
|
||||
SslHandler ssl = settings.tls().newHandler(connection.channel().alloc());
|
||||
pipeline.replace("imap-commands", "imap-commands", new CommandDecoder(settings.maxLiteral()));
|
||||
pipeline.addFirst("imap-tls", ssl);
|
||||
return Mono.create(sink -> ssl.handshakeFuture().addListener(future -> {
|
||||
if (!future.isSuccess()) {
|
||||
log.info("IMAP {}: TLS handshake failed: {}", session.remoteIp, future.cause().toString());
|
||||
session.closing = true;
|
||||
connection.dispose();
|
||||
}
|
||||
sink.success();
|
||||
}));
|
||||
}
|
||||
|
||||
public int port() {
|
||||
return server.port();
|
||||
}
|
||||
|
||||
public void stop() {
|
||||
if (server != null) {
|
||||
server.disposeNow(Duration.ofSeconds(5));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Collects one command: lines plus the literals they announce. A synchronizing literal {n} gets "+ Ready" first;
|
||||
* {n+} (LITERAL+) is read at once. Marks whether the command was read behind TLS.
|
||||
*/
|
||||
static final class CommandDecoder extends ByteToMessageDecoder {
|
||||
private final int maxLiteral;
|
||||
private final ByteArrayOutputStream command = new ByteArrayOutputStream();
|
||||
private int literalLeft;
|
||||
private int lineBytes;
|
||||
|
||||
CommandDecoder(int maxLiteral) {
|
||||
this.maxLiteral = maxLiteral;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
|
||||
while (in.isReadable()) {
|
||||
if (literalLeft > 0) {
|
||||
int n = Math.min(literalLeft, in.readableBytes());
|
||||
byte[] chunk = new byte[n];
|
||||
in.readBytes(chunk);
|
||||
command.write(chunk, 0, n);
|
||||
literalLeft -= n;
|
||||
continue;
|
||||
}
|
||||
int newline = in.indexOf(in.readerIndex(), in.writerIndex(), (byte) '\n');
|
||||
if (newline < 0) {
|
||||
if (lineBytes + in.readableBytes() > MAX_LINE) {
|
||||
throw new TooLongFrameException("Command line too long");
|
||||
}
|
||||
return;
|
||||
}
|
||||
int length = newline - in.readerIndex() + 1;
|
||||
if (lineBytes + length > MAX_LINE) {
|
||||
throw new TooLongFrameException("Command line too long");
|
||||
}
|
||||
byte[] line = new byte[length];
|
||||
in.readBytes(line);
|
||||
command.write(line, 0, line.length);
|
||||
lineBytes += length;
|
||||
Matcher literal = LITERAL.matcher(new String(line, StandardCharsets.ISO_8859_1));
|
||||
if (literal.find()) {
|
||||
long size = Long.parseLong(literal.group(1));
|
||||
if (size > maxLiteral) {
|
||||
ctx.writeAndFlush(Unpooled.copiedBuffer("* BYE Literal too large\r\n", StandardCharsets.US_ASCII));
|
||||
throw new TooLongFrameException("Literal too large: " + size);
|
||||
}
|
||||
literalLeft = (int) size;
|
||||
if (literal.group(2).isEmpty()) {
|
||||
ctx.writeAndFlush(Unpooled.copiedBuffer("+ Ready for literal data\r\n", StandardCharsets.US_ASCII));
|
||||
}
|
||||
continue;
|
||||
}
|
||||
out.add(new Command(command.toByteArray(), ctx.pipeline().get(SslHandler.class) != null));
|
||||
command.reset();
|
||||
lineBytes = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,91 @@
|
||||
package com.mailserver.imap;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
|
||||
/**
|
||||
* Mailboxes and messages as IMAP sees them. Blocking: the IMAP server calls it from a worker thread,
|
||||
* never from the network event loop.
|
||||
*/
|
||||
public interface ImapStore {
|
||||
|
||||
/** A refusal the client sees as "NO reason". */
|
||||
final class Refused extends RuntimeException {
|
||||
public Refused(String reason) {
|
||||
super(reason);
|
||||
}
|
||||
}
|
||||
|
||||
record Account(long userId, String email) {
|
||||
}
|
||||
|
||||
record Mailbox(long id, String name, boolean system, long uidValidity, long uidNext) {
|
||||
|
||||
boolean isInbox() {
|
||||
return system && "INBOX".equalsIgnoreCase(name);
|
||||
}
|
||||
|
||||
boolean isDrafts() {
|
||||
return system && "Drafts".equals(name);
|
||||
}
|
||||
|
||||
/** RFC 6154 attribute, or null. */
|
||||
String specialUse() {
|
||||
if (!system) {
|
||||
return null;
|
||||
}
|
||||
return switch (name) {
|
||||
case "Drafts" -> "\\Drafts";
|
||||
case "Sent" -> "\\Sent";
|
||||
case "Spam" -> "\\Junk";
|
||||
case "Trash" -> "\\Trash";
|
||||
default -> null;
|
||||
};
|
||||
}
|
||||
|
||||
boolean named(String other) {
|
||||
return isInbox() ? "INBOX".equalsIgnoreCase(other) : name.toLowerCase(Locale.ROOT).equals(other.toLowerCase(Locale.ROOT));
|
||||
}
|
||||
}
|
||||
|
||||
record Entry(long id, long uid, boolean seen, boolean flagged, boolean answered, boolean deleted, Instant internalDate) {
|
||||
|
||||
Entry withFlags(boolean seen, boolean flagged, boolean answered, boolean deleted) {
|
||||
return new Entry(id, uid, seen, flagged, answered, deleted, internalDate);
|
||||
}
|
||||
}
|
||||
|
||||
/** null — wrong user or password. */
|
||||
Account authenticate(String username, String password);
|
||||
|
||||
List<Mailbox> mailboxes(long userId);
|
||||
|
||||
Mailbox create(long userId, String name);
|
||||
|
||||
void rename(long userId, Mailbox mailbox, String newName);
|
||||
|
||||
/** An own folder: its messages go to the Trash (as in the web client), then the folder is removed. */
|
||||
void delete(long userId, Mailbox mailbox);
|
||||
|
||||
/** Messages of the folder in UID order. */
|
||||
List<Entry> entries(long folderId);
|
||||
|
||||
/** The full MIME text of the message (the original one, or built once and kept). */
|
||||
byte[] source(long messageId);
|
||||
|
||||
void setFlags(long messageId, boolean seen, boolean flagged, boolean answered, boolean deleted);
|
||||
|
||||
/** Stores the message into the folder; returns its UID. */
|
||||
long append(long userId, Mailbox target, byte[] raw, boolean seen, boolean flagged, boolean answered,
|
||||
boolean deleted, Instant internalDate);
|
||||
|
||||
/** Copies; returns the new UIDs in the same order. */
|
||||
List<Long> copy(long userId, List<Entry> messages, Mailbox target);
|
||||
|
||||
/** Moves; returns the new UIDs in the same order. */
|
||||
List<Long> move(long userId, List<Entry> messages, Mailbox target);
|
||||
|
||||
/** Removes the messages for good (with attachment files). */
|
||||
void expunge(List<Long> messageIds);
|
||||
}
|
||||
@@ -0,0 +1,255 @@
|
||||
package com.mailserver.imap;
|
||||
|
||||
import jakarta.mail.internet.AddressException;
|
||||
import jakarta.mail.internet.ContentDisposition;
|
||||
import jakarta.mail.internet.InternetAddress;
|
||||
import jakarta.mail.internet.MimeUtility;
|
||||
import jakarta.mail.internet.ParameterList;
|
||||
import jakarta.mail.internet.ParseException;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.Enumeration;
|
||||
import java.util.Locale;
|
||||
|
||||
/** Builds IMAP response bytes: strings, literals, ENVELOPE, BODYSTRUCTURE (RFC 3501 7.4.2). */
|
||||
final class ImapWriter {
|
||||
|
||||
private final ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
|
||||
ImapWriter text(String text) {
|
||||
byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
|
||||
out.write(bytes, 0, bytes.length);
|
||||
return this;
|
||||
}
|
||||
|
||||
ImapWriter sp() {
|
||||
out.write(' ');
|
||||
return this;
|
||||
}
|
||||
|
||||
ImapWriter crlf() {
|
||||
return text("\r\n");
|
||||
}
|
||||
|
||||
ImapWriter literal(byte[] bytes) {
|
||||
text("{" + bytes.length + "}\r\n");
|
||||
out.write(bytes, 0, bytes.length);
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Quoted when it is plain ASCII without CR/LF, a literal otherwise; null → NIL. */
|
||||
ImapWriter nstring(String value) {
|
||||
if (value == null) {
|
||||
return text("NIL");
|
||||
}
|
||||
return string(value);
|
||||
}
|
||||
|
||||
ImapWriter string(String value) {
|
||||
boolean quotable = value.length() < 1024;
|
||||
for (int i = 0; i < value.length() && quotable; i++) {
|
||||
char c = value.charAt(i);
|
||||
if (c > 0x7e || c < 0x20) {
|
||||
quotable = false;
|
||||
}
|
||||
}
|
||||
if (!quotable) {
|
||||
return literal(value.getBytes(StandardCharsets.UTF_8));
|
||||
}
|
||||
return text("\"" + value.replace("\\", "\\\\").replace("\"", "\\\"") + "\"");
|
||||
}
|
||||
|
||||
byte[] bytes() {
|
||||
return out.toByteArray();
|
||||
}
|
||||
|
||||
// ---------- ENVELOPE ----------
|
||||
|
||||
ImapWriter envelope(MimeTree message) {
|
||||
text("(");
|
||||
nstring(message.header("Date")).sp();
|
||||
nstring(message.header("Subject")).sp();
|
||||
String from = message.header("From");
|
||||
addresses(from).sp();
|
||||
addresses(firstNonNull(message.header("Sender"), from)).sp();
|
||||
addresses(firstNonNull(message.header("Reply-To"), from)).sp();
|
||||
addresses(message.header("To")).sp();
|
||||
addresses(message.header("Cc")).sp();
|
||||
addresses(message.header("Bcc")).sp();
|
||||
nstring(message.header("In-Reply-To")).sp();
|
||||
nstring(message.header("Message-ID"));
|
||||
return text(")");
|
||||
}
|
||||
|
||||
private ImapWriter addresses(String header) {
|
||||
if (header == null || header.isBlank()) {
|
||||
return text("NIL");
|
||||
}
|
||||
InternetAddress[] list;
|
||||
try {
|
||||
list = InternetAddress.parseHeader(header, false);
|
||||
} catch (AddressException e) {
|
||||
return text("NIL");
|
||||
}
|
||||
if (list.length == 0) {
|
||||
return text("NIL");
|
||||
}
|
||||
text("(");
|
||||
for (InternetAddress address : list) {
|
||||
String email = address.getAddress() == null ? "" : address.getAddress();
|
||||
int at = email.lastIndexOf('@');
|
||||
text("(");
|
||||
nstring(encodedPersonal(address.getPersonal())).sp().text("NIL").sp();
|
||||
nstring(at > 0 ? email.substring(0, at) : email).sp();
|
||||
nstring(at > 0 ? email.substring(at + 1) : null);
|
||||
text(")");
|
||||
}
|
||||
return text(")");
|
||||
}
|
||||
|
||||
private static String encodedPersonal(String personal) {
|
||||
if (personal == null) {
|
||||
return null;
|
||||
}
|
||||
try {
|
||||
return MimeUtility.encodeWord(personal, "UTF-8", "B");
|
||||
} catch (UnsupportedEncodingException e) {
|
||||
return personal;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- BODYSTRUCTURE / BODY ----------
|
||||
|
||||
ImapWriter bodyStructure(MimeTree part, boolean extensible) {
|
||||
text("(");
|
||||
if (part.isMultipart() && !part.children.isEmpty()) {
|
||||
for (MimeTree child : part.children) {
|
||||
bodyStructure(child, extensible);
|
||||
}
|
||||
sp().string(part.type.getSubType().toUpperCase(Locale.ROOT));
|
||||
if (extensible) {
|
||||
sp().params(part.type.getParameterList()).sp();
|
||||
disposition(part).sp().text("NIL NIL");
|
||||
}
|
||||
return text(")");
|
||||
}
|
||||
String primary = part.isMultipart() ? "TEXT" : part.type.getPrimaryType().toUpperCase(Locale.ROOT);
|
||||
String sub = part.isMultipart() ? "PLAIN" : part.type.getSubType().toUpperCase(Locale.ROOT);
|
||||
string(primary).sp().string(sub).sp();
|
||||
params(part.type.getParameterList()).sp();
|
||||
nstring(part.header("Content-ID")).sp();
|
||||
nstring(part.header("Content-Description")).sp();
|
||||
String encoding = part.header("Content-Transfer-Encoding");
|
||||
string(encoding == null ? "7BIT" : encoding.toUpperCase(Locale.ROOT)).sp();
|
||||
text(String.valueOf(part.bodySize()));
|
||||
if ("TEXT".equals(primary)) {
|
||||
sp().text(String.valueOf(part.bodyLines()));
|
||||
} else if (part.message != null) {
|
||||
sp().envelope(part.message).sp().bodyStructure(part.message, extensible).sp().text(String.valueOf(part.bodyLines()));
|
||||
}
|
||||
if (extensible) {
|
||||
sp().nstring(part.header("Content-MD5")).sp();
|
||||
disposition(part).sp();
|
||||
nstring(part.header("Content-Language")).sp();
|
||||
nstring(part.header("Content-Location"));
|
||||
}
|
||||
return text(")");
|
||||
}
|
||||
|
||||
private ImapWriter params(ParameterList params) {
|
||||
if (params == null || params.size() == 0) {
|
||||
return text("NIL");
|
||||
}
|
||||
text("(");
|
||||
boolean first = true;
|
||||
Enumeration<String> names = params.getNames();
|
||||
while (names.hasMoreElements()) {
|
||||
String name = names.nextElement();
|
||||
if (!first) {
|
||||
sp();
|
||||
}
|
||||
first = false;
|
||||
string(name.toUpperCase(Locale.ROOT)).sp().string(String.valueOf(params.get(name)));
|
||||
}
|
||||
return text(")");
|
||||
}
|
||||
|
||||
private ImapWriter disposition(MimeTree part) {
|
||||
String header = part.header("Content-Disposition");
|
||||
if (header == null) {
|
||||
return text("NIL");
|
||||
}
|
||||
try {
|
||||
ContentDisposition disposition = new ContentDisposition(header);
|
||||
text("(").string(disposition.getDisposition().toUpperCase(Locale.ROOT)).sp();
|
||||
params(disposition.getParameterList());
|
||||
return text(")");
|
||||
} catch (ParseException e) {
|
||||
return text("NIL");
|
||||
}
|
||||
}
|
||||
|
||||
private static String firstNonNull(String a, String b) {
|
||||
return a != null ? a : b;
|
||||
}
|
||||
|
||||
// ---------- modified UTF-7 (RFC 3501 5.1.3) for mailbox names ----------
|
||||
|
||||
static String encodeMailbox(String name) {
|
||||
StringBuilder out = new StringBuilder();
|
||||
StringBuilder pending = new StringBuilder();
|
||||
for (int i = 0; i < name.length(); i++) {
|
||||
char c = name.charAt(i);
|
||||
if (c >= 0x20 && c <= 0x7e) {
|
||||
flushBase64(out, pending);
|
||||
out.append(c == '&' ? "&-" : String.valueOf(c));
|
||||
} else {
|
||||
pending.append(c);
|
||||
}
|
||||
}
|
||||
flushBase64(out, pending);
|
||||
return out.toString();
|
||||
}
|
||||
|
||||
private static void flushBase64(StringBuilder out, StringBuilder pending) {
|
||||
if (pending.length() == 0) {
|
||||
return;
|
||||
}
|
||||
byte[] utf16 = pending.toString().getBytes(StandardCharsets.UTF_16BE);
|
||||
String base64 = java.util.Base64.getEncoder().withoutPadding().encodeToString(utf16).replace('/', ',');
|
||||
out.append('&').append(base64).append('-');
|
||||
pending.setLength(0);
|
||||
}
|
||||
|
||||
static String decodeMailbox(String name) {
|
||||
StringBuilder out = new StringBuilder();
|
||||
int i = 0;
|
||||
while (i < name.length()) {
|
||||
char c = name.charAt(i);
|
||||
if (c != '&') {
|
||||
out.append(c);
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
int dash = name.indexOf('-', i);
|
||||
if (dash < 0) {
|
||||
out.append(name.substring(i));
|
||||
break;
|
||||
}
|
||||
if (dash == i + 1) {
|
||||
out.append('&');
|
||||
} else {
|
||||
try {
|
||||
byte[] utf16 = java.util.Base64.getDecoder().decode(name.substring(i + 1, dash).replace(',', '/'));
|
||||
out.append(new String(utf16, StandardCharsets.UTF_16BE));
|
||||
} catch (IllegalArgumentException e) {
|
||||
out.append(name, i, dash + 1);
|
||||
}
|
||||
}
|
||||
i = dash + 1;
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
package com.mailserver.imap;
|
||||
|
||||
import com.mailserver.domain.Attachment;
|
||||
import com.mailserver.domain.Message;
|
||||
import jakarta.activation.DataHandler;
|
||||
import jakarta.activation.FileDataSource;
|
||||
import jakarta.mail.MessagingException;
|
||||
import jakarta.mail.Session;
|
||||
import jakarta.mail.internet.InternetAddress;
|
||||
import jakarta.mail.internet.MimeBodyPart;
|
||||
import jakarta.mail.internet.MimeMessage;
|
||||
import jakarta.mail.internet.MimeMultipart;
|
||||
import jakarta.mail.internet.MimeUtility;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Date;
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
|
||||
/**
|
||||
* MIME text of a message that has no original (written in the web client): built from the stored fields and
|
||||
* attachment files. The boundary and Message-ID come from the message id, so the result is the same every time.
|
||||
*/
|
||||
public final class MimeSource {
|
||||
|
||||
private MimeSource() {
|
||||
}
|
||||
|
||||
public static byte[] build(Message message, List<Attachment> attachments, String hostname)
|
||||
throws MessagingException, IOException {
|
||||
Properties props = new Properties();
|
||||
props.put("mail.mime.splitlongparameters", "true");
|
||||
Session session = Session.getInstance(props);
|
||||
String messageId = message.getMessageId() == null || message.getMessageId().isBlank()
|
||||
? message.getId() + "@" + hostname
|
||||
: message.getMessageId().replaceAll("^<|>$", "");
|
||||
if (!messageId.contains("@")) {
|
||||
messageId = messageId + "@" + hostname;
|
||||
}
|
||||
String finalMessageId = "<" + messageId + ">";
|
||||
MimeMessage mime = new MimeMessage(session) {
|
||||
@Override
|
||||
protected void updateMessageID() throws MessagingException {
|
||||
setHeader("Message-ID", finalMessageId);
|
||||
}
|
||||
};
|
||||
|
||||
String from = message.getSenderEmail() == null ? "unknown@" + hostname : message.getSenderEmail();
|
||||
mime.setFrom(new InternetAddress(from, message.getSenderName(), "UTF-8"));
|
||||
List<InternetAddress> to = addresses(message.getRecipientEmail());
|
||||
if (!to.isEmpty()) {
|
||||
mime.setRecipients(jakarta.mail.Message.RecipientType.TO, to.toArray(new InternetAddress[0]));
|
||||
}
|
||||
List<InternetAddress> cc = addresses(message.getCcEmail());
|
||||
if (!cc.isEmpty()) {
|
||||
mime.setRecipients(jakarta.mail.Message.RecipientType.CC, cc.toArray(new InternetAddress[0]));
|
||||
}
|
||||
mime.setSubject(message.getSubject() == null ? "" : message.getSubject(), "UTF-8");
|
||||
if (message.getReceivedAt() != null) {
|
||||
mime.setSentDate(Date.from(message.getReceivedAt()));
|
||||
}
|
||||
|
||||
String body = message.getBody() == null ? "" : message.getBody();
|
||||
String subtype = message.isHtml() ? "html" : "plain";
|
||||
if (attachments.isEmpty()) {
|
||||
mime.setText(body, "UTF-8", subtype);
|
||||
} else {
|
||||
MimeMultipart mixed = new FixedBoundaryMultipart("mixed", "=_rms_" + message.getId());
|
||||
MimeBodyPart text = new MimeBodyPart();
|
||||
text.setText(body, "UTF-8", subtype);
|
||||
mixed.addBodyPart(text);
|
||||
for (Attachment attachment : attachments) {
|
||||
Path file = Path.of(attachment.getFilePath());
|
||||
if (!Files.isRegularFile(file)) {
|
||||
continue;
|
||||
}
|
||||
MimeBodyPart part = new MimeBodyPart();
|
||||
FileDataSource source = new FileDataSource(file.toFile()) {
|
||||
@Override
|
||||
public String getContentType() {
|
||||
return attachment.getContentType() == null ? "application/octet-stream" : attachment.getContentType();
|
||||
}
|
||||
};
|
||||
part.setDataHandler(new DataHandler(source));
|
||||
part.setFileName(MimeUtility.encodeText(attachment.getFilename(), "UTF-8", null));
|
||||
part.setDisposition(attachment.getContentId() != null ? MimeBodyPart.INLINE : MimeBodyPart.ATTACHMENT);
|
||||
if (attachment.getContentId() != null) {
|
||||
part.setContentID("<" + attachment.getContentId().replaceAll("^<|>$", "") + ">");
|
||||
}
|
||||
mixed.addBodyPart(part);
|
||||
}
|
||||
mime.setContent(mixed);
|
||||
}
|
||||
mime.saveChanges();
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
mime.writeTo(out);
|
||||
return out.toByteArray();
|
||||
}
|
||||
|
||||
private static List<InternetAddress> addresses(String list) {
|
||||
List<InternetAddress> result = new ArrayList<>();
|
||||
if (list == null || list.isBlank()) {
|
||||
return result;
|
||||
}
|
||||
for (String one : list.split("[,;]")) {
|
||||
String address = one.trim();
|
||||
if (!address.isEmpty()) {
|
||||
try {
|
||||
result.add(new InternetAddress(address));
|
||||
} catch (MessagingException ignored) {
|
||||
// a broken address is left out, the message is still served
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/** MimeMultipart with a given boundary instead of a random one. */
|
||||
private static final class FixedBoundaryMultipart extends MimeMultipart {
|
||||
FixedBoundaryMultipart(String subtype, String boundary) {
|
||||
super(subtype);
|
||||
this.contentType = "multipart/" + subtype + "; boundary=\"" + boundary + "\"";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,250 @@
|
||||
package com.mailserver.imap;
|
||||
|
||||
import jakarta.mail.MessagingException;
|
||||
import jakarta.mail.internet.ContentType;
|
||||
import jakarta.mail.internet.InternetHeaders;
|
||||
import jakarta.mail.internet.ParseException;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Enumeration;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* A message split into MIME parts by byte offsets — what IMAP needs for BODYSTRUCTURE and BODY[section]:
|
||||
* every part is a range of the original bytes, so sizes and contents match BODY[] exactly.
|
||||
*/
|
||||
final class MimeTree {
|
||||
|
||||
private static final int MAX_DEPTH = 20;
|
||||
|
||||
final byte[] raw;
|
||||
/** Part = [start, end); headers = [start, bodyStart), the blank line included. */
|
||||
final int start;
|
||||
final int bodyStart;
|
||||
final int end;
|
||||
final InternetHeaders headers;
|
||||
final ContentType type;
|
||||
final List<MimeTree> children;
|
||||
/** The encapsulated message of a message/rfc822 part. */
|
||||
final MimeTree message;
|
||||
|
||||
private MimeTree(byte[] raw, int start, int end, int depth) {
|
||||
this.raw = raw;
|
||||
this.start = start;
|
||||
this.end = end;
|
||||
this.bodyStart = headerEnd(raw, start, end);
|
||||
this.headers = parseHeaders(raw, start, bodyStart);
|
||||
this.type = contentType(headers);
|
||||
List<MimeTree> parts = new ArrayList<>();
|
||||
MimeTree nested = null;
|
||||
if (depth < MAX_DEPTH) {
|
||||
if (isMultipart()) {
|
||||
String boundary = type.getParameter("boundary");
|
||||
if (boundary != null && !boundary.isEmpty()) {
|
||||
split(boundary, depth, parts);
|
||||
}
|
||||
} else if (is("message", "rfc822") || is("message", "global")) {
|
||||
nested = new MimeTree(raw, bodyStart, end, depth + 1);
|
||||
}
|
||||
}
|
||||
this.children = Collections.unmodifiableList(parts);
|
||||
this.message = nested;
|
||||
}
|
||||
|
||||
static MimeTree parse(byte[] raw) {
|
||||
return new MimeTree(raw, 0, raw.length, 0);
|
||||
}
|
||||
|
||||
boolean isMultipart() {
|
||||
return "multipart".equalsIgnoreCase(type.getPrimaryType());
|
||||
}
|
||||
|
||||
boolean is(String primary, String sub) {
|
||||
return primary.equalsIgnoreCase(type.getPrimaryType()) && sub.equalsIgnoreCase(type.getSubType());
|
||||
}
|
||||
|
||||
byte[] all() {
|
||||
return slice(start, end);
|
||||
}
|
||||
|
||||
byte[] header() {
|
||||
return slice(start, bodyStart);
|
||||
}
|
||||
|
||||
byte[] body() {
|
||||
return slice(bodyStart, end);
|
||||
}
|
||||
|
||||
int bodySize() {
|
||||
return end - bodyStart;
|
||||
}
|
||||
|
||||
/** Lines of the body (for text parts in BODYSTRUCTURE). */
|
||||
int bodyLines() {
|
||||
int lines = 0;
|
||||
for (int i = bodyStart; i < end; i++) {
|
||||
if (raw[i] == '\n') {
|
||||
lines++;
|
||||
}
|
||||
}
|
||||
if (end > bodyStart && raw[end - 1] != '\n') {
|
||||
lines++;
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
/** Header value unfolded, or null. */
|
||||
String header(String name) {
|
||||
String[] values = headers.getHeader(name);
|
||||
if (values == null || values.length == 0 || values[0] == null) {
|
||||
return null;
|
||||
}
|
||||
return values[0].replaceAll("\r?\n(?=[ \t])", "").trim();
|
||||
}
|
||||
|
||||
/** Only these header fields (or all but these), each with its folded lines, plus the blank line. */
|
||||
byte[] headerFields(Set<String> names, boolean not) {
|
||||
StringBuilder out = new StringBuilder();
|
||||
String text = new String(raw, start, bodyStart - start, StandardCharsets.ISO_8859_1);
|
||||
String[] lines = text.split("\r?\n", -1);
|
||||
boolean keep = false;
|
||||
for (String line : lines) {
|
||||
if (line.isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
if (line.charAt(0) == ' ' || line.charAt(0) == '\t') {
|
||||
if (keep) {
|
||||
out.append(line).append("\r\n");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
int colon = line.indexOf(':');
|
||||
String name = colon > 0 ? line.substring(0, colon).trim().toUpperCase(Locale.ROOT) : "";
|
||||
keep = names.contains(name) != not;
|
||||
if (keep) {
|
||||
out.append(line).append("\r\n");
|
||||
}
|
||||
}
|
||||
out.append("\r\n");
|
||||
return out.toString().getBytes(StandardCharsets.ISO_8859_1);
|
||||
}
|
||||
|
||||
private byte[] slice(int from, int to) {
|
||||
byte[] copy = new byte[Math.max(0, to - from)];
|
||||
System.arraycopy(raw, from, copy, 0, copy.length);
|
||||
return copy;
|
||||
}
|
||||
|
||||
/** Body parts between "--boundary" lines; the CRLF before a delimiter belongs to the delimiter. */
|
||||
private void split(String boundary, int depth, List<MimeTree> parts) {
|
||||
byte[] delimiter = ("--" + boundary).getBytes(StandardCharsets.ISO_8859_1);
|
||||
int partStart = -1;
|
||||
int i = bodyStart;
|
||||
while (i < end) {
|
||||
int lineEnd = indexOf(raw, (byte) '\n', i, end);
|
||||
int next = lineEnd < 0 ? end : lineEnd + 1;
|
||||
if (startsWith(raw, i, end, delimiter)) {
|
||||
int after = i + delimiter.length;
|
||||
boolean close = after + 1 < end && raw[after] == '-' && raw[after + 1] == '-';
|
||||
if (partStart >= 0) {
|
||||
int partEnd = i;
|
||||
if (partEnd > partStart && raw[partEnd - 1] == '\n') {
|
||||
partEnd--;
|
||||
if (partEnd > partStart && raw[partEnd - 1] == '\r') {
|
||||
partEnd--;
|
||||
}
|
||||
}
|
||||
parts.add(new MimeTree(raw, partStart, Math.max(partStart, partEnd), depth + 1));
|
||||
}
|
||||
if (close) {
|
||||
return;
|
||||
}
|
||||
partStart = next;
|
||||
}
|
||||
i = next;
|
||||
}
|
||||
if (partStart >= 0 && partStart < end) { // no closing delimiter — take the rest
|
||||
parts.add(new MimeTree(raw, partStart, end, depth + 1));
|
||||
}
|
||||
}
|
||||
|
||||
private static int headerEnd(byte[] raw, int start, int end) {
|
||||
if (start < end && raw[start] == '\n') {
|
||||
return start + 1;
|
||||
}
|
||||
if (start + 1 < end && raw[start] == '\r' && raw[start + 1] == '\n') {
|
||||
return start + 2;
|
||||
}
|
||||
for (int i = start; i < end; i++) {
|
||||
if (raw[i] == '\n') {
|
||||
if (i + 1 < end && raw[i + 1] == '\n') {
|
||||
return i + 2;
|
||||
}
|
||||
if (i + 2 < end && raw[i + 1] == '\r' && raw[i + 2] == '\n') {
|
||||
return i + 3;
|
||||
}
|
||||
}
|
||||
}
|
||||
return end; // headers only
|
||||
}
|
||||
|
||||
private static InternetHeaders parseHeaders(byte[] raw, int start, int end) {
|
||||
try {
|
||||
return new InternetHeaders(new ByteArrayInputStream(raw, start, end - start));
|
||||
} catch (MessagingException e) {
|
||||
return new InternetHeaders();
|
||||
}
|
||||
}
|
||||
|
||||
private static ContentType contentType(InternetHeaders headers) {
|
||||
String[] values = headers.getHeader("Content-Type");
|
||||
if (values != null && values.length > 0 && values[0] != null) {
|
||||
try {
|
||||
return new ContentType(values[0].replaceAll("\r?\n(?=[ \t])", "").trim());
|
||||
} catch (ParseException ignored) {
|
||||
// broken header — the RFC 2045 default
|
||||
}
|
||||
}
|
||||
try {
|
||||
return new ContentType("text/plain; charset=us-ascii");
|
||||
} catch (ParseException e) {
|
||||
throw new IllegalStateException(e);
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean startsWith(byte[] raw, int at, int end, byte[] prefix) {
|
||||
if (at + prefix.length > end) {
|
||||
return false;
|
||||
}
|
||||
for (int i = 0; i < prefix.length; i++) {
|
||||
if (raw[at + i] != prefix[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private static int indexOf(byte[] raw, byte value, int from, int end) {
|
||||
for (int i = from; i < end; i++) {
|
||||
if (raw[i] == value) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/** Header names of the part, for tests and debugging. */
|
||||
List<String> headerNames() {
|
||||
List<String> names = new ArrayList<>();
|
||||
Enumeration<jakarta.mail.Header> all = headers.getAllHeaders();
|
||||
while (all.hasMoreElements()) {
|
||||
names.add(all.nextElement().getName());
|
||||
}
|
||||
return names;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user