2019-12-16 11:51:42 +00:00
|
|
|
package koushinbase
|
2019-12-04 19:55:08 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"io/ioutil"
|
|
|
|
"mime"
|
|
|
|
"net/http"
|
|
|
|
"net/url"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
|
|
|
|
2019-12-16 11:51:42 +00:00
|
|
|
"git.sr.ht/~emersion/koushin"
|
2019-12-04 19:55:08 +00:00
|
|
|
"github.com/emersion/go-imap"
|
|
|
|
imapclient "github.com/emersion/go-imap/client"
|
|
|
|
"github.com/emersion/go-message"
|
2019-12-16 12:07:35 +00:00
|
|
|
"github.com/emersion/go-smtp"
|
2019-12-04 19:55:08 +00:00
|
|
|
"github.com/labstack/echo/v4"
|
|
|
|
)
|
|
|
|
|
2019-12-09 15:17:36 +00:00
|
|
|
type MailboxRenderData struct {
|
2019-12-16 11:51:42 +00:00
|
|
|
koushin.RenderData
|
2019-12-09 15:17:36 +00:00
|
|
|
Mailbox *imap.MailboxStatus
|
|
|
|
Mailboxes []*imap.MailboxInfo
|
|
|
|
Messages []imapMessage
|
|
|
|
PrevPage, NextPage int
|
2019-12-16 13:36:43 +00:00
|
|
|
Query string
|
2019-12-09 15:17:36 +00:00
|
|
|
}
|
|
|
|
|
2019-12-04 19:55:08 +00:00
|
|
|
func handleGetMailbox(ectx echo.Context) error {
|
2019-12-16 11:51:42 +00:00
|
|
|
ctx := ectx.(*koushin.Context)
|
2019-12-04 19:55:08 +00:00
|
|
|
|
|
|
|
mboxName, err := url.PathUnescape(ctx.Param("mbox"))
|
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
page := 0
|
|
|
|
if pageStr := ctx.QueryParam("page"); pageStr != "" {
|
|
|
|
var err error
|
|
|
|
if page, err = strconv.Atoi(pageStr); err != nil || page < 0 {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, "invalid page index")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-16 13:36:43 +00:00
|
|
|
query := ctx.FormValue("query")
|
|
|
|
|
2019-12-04 19:55:08 +00:00
|
|
|
var mailboxes []*imap.MailboxInfo
|
|
|
|
var msgs []imapMessage
|
|
|
|
var mbox *imap.MailboxStatus
|
2019-12-16 12:01:33 +00:00
|
|
|
err = ctx.Session.DoIMAP(func(c *imapclient.Client) error {
|
2019-12-04 19:55:08 +00:00
|
|
|
var err error
|
|
|
|
if mailboxes, err = listMailboxes(c); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-12-16 13:36:43 +00:00
|
|
|
if query != "" {
|
|
|
|
msgs, err = searchMessages(c, mboxName, query)
|
|
|
|
} else {
|
|
|
|
msgs, err = listMessages(c, mboxName, page)
|
|
|
|
}
|
|
|
|
if err != nil {
|
2019-12-04 19:55:08 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
mbox = c.Mailbox()
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
prevPage, nextPage := -1, -1
|
2019-12-16 13:36:43 +00:00
|
|
|
if query == "" {
|
|
|
|
// TODO: paging for search
|
|
|
|
if page > 0 {
|
|
|
|
prevPage = page - 1
|
|
|
|
}
|
|
|
|
if (page+1)*messagesPerPage < int(mbox.Messages) {
|
|
|
|
nextPage = page + 1
|
|
|
|
}
|
2019-12-04 19:55:08 +00:00
|
|
|
}
|
|
|
|
|
2019-12-09 15:17:36 +00:00
|
|
|
return ctx.Render(http.StatusOK, "mailbox.html", &MailboxRenderData{
|
2019-12-16 11:51:42 +00:00
|
|
|
RenderData: *koushin.NewRenderData(ctx),
|
2019-12-10 16:39:42 +00:00
|
|
|
Mailbox: mbox,
|
|
|
|
Mailboxes: mailboxes,
|
|
|
|
Messages: msgs,
|
|
|
|
PrevPage: prevPage,
|
|
|
|
NextPage: nextPage,
|
2019-12-16 13:36:43 +00:00
|
|
|
Query: query,
|
2019-12-04 19:55:08 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func handleLogin(ectx echo.Context) error {
|
2019-12-16 11:51:42 +00:00
|
|
|
ctx := ectx.(*koushin.Context)
|
2019-12-10 16:36:21 +00:00
|
|
|
|
2019-12-04 19:55:08 +00:00
|
|
|
username := ctx.FormValue("username")
|
|
|
|
password := ctx.FormValue("password")
|
|
|
|
if username != "" && password != "" {
|
2019-12-11 12:03:31 +00:00
|
|
|
s, err := ctx.Server.Sessions.Put(username, password)
|
2019-12-04 19:55:08 +00:00
|
|
|
if err != nil {
|
2019-12-16 11:51:42 +00:00
|
|
|
if _, ok := err.(koushin.AuthError); ok {
|
2019-12-09 17:35:51 +00:00
|
|
|
return ctx.Render(http.StatusOK, "login.html", nil)
|
|
|
|
}
|
2019-12-04 19:55:08 +00:00
|
|
|
return fmt.Errorf("failed to put connection in pool: %v", err)
|
|
|
|
}
|
2019-12-11 11:54:00 +00:00
|
|
|
ctx.SetSession(s)
|
2019-12-04 19:55:08 +00:00
|
|
|
|
|
|
|
return ctx.Redirect(http.StatusFound, "/mailbox/INBOX")
|
|
|
|
}
|
|
|
|
|
2019-12-16 11:51:42 +00:00
|
|
|
return ctx.Render(http.StatusOK, "login.html", koushin.NewRenderData(ctx))
|
2019-12-04 19:55:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func handleLogout(ectx echo.Context) error {
|
2019-12-16 11:51:42 +00:00
|
|
|
ctx := ectx.(*koushin.Context)
|
2019-12-04 19:55:08 +00:00
|
|
|
|
2019-12-11 11:48:18 +00:00
|
|
|
ctx.Session.Close()
|
2019-12-11 11:54:00 +00:00
|
|
|
ctx.SetSession(nil)
|
2019-12-04 19:55:08 +00:00
|
|
|
return ctx.Redirect(http.StatusFound, "/login")
|
|
|
|
}
|
|
|
|
|
2019-12-09 15:17:36 +00:00
|
|
|
type MessageRenderData struct {
|
2019-12-16 11:51:42 +00:00
|
|
|
koushin.RenderData
|
2019-12-09 15:17:36 +00:00
|
|
|
Mailbox *imap.MailboxStatus
|
|
|
|
Message *imapMessage
|
|
|
|
Body string
|
|
|
|
PartPath string
|
|
|
|
MailboxPage int
|
|
|
|
}
|
|
|
|
|
2019-12-16 11:51:42 +00:00
|
|
|
func handleGetPart(ctx *koushin.Context, raw bool) error {
|
2019-12-04 19:55:08 +00:00
|
|
|
mboxName, uid, err := parseMboxAndUid(ctx.Param("mbox"), ctx.Param("uid"))
|
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, err)
|
|
|
|
}
|
|
|
|
partPathString := ctx.QueryParam("part")
|
|
|
|
partPath, err := parsePartPath(partPathString)
|
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
var msg *imapMessage
|
|
|
|
var part *message.Entity
|
|
|
|
var mbox *imap.MailboxStatus
|
2019-12-16 12:01:33 +00:00
|
|
|
err = ctx.Session.DoIMAP(func(c *imapclient.Client) error {
|
2019-12-04 19:55:08 +00:00
|
|
|
var err error
|
|
|
|
msg, part, err = getMessagePart(c, mboxName, uid, partPath)
|
|
|
|
mbox = c.Mailbox()
|
|
|
|
return err
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
mimeType, _, err := part.Header.ContentType()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to parse part Content-Type: %v", err)
|
|
|
|
}
|
|
|
|
if len(partPath) == 0 {
|
|
|
|
mimeType = "message/rfc822"
|
|
|
|
}
|
|
|
|
|
|
|
|
if raw {
|
|
|
|
disp, dispParams, _ := part.Header.ContentDisposition()
|
|
|
|
filename := dispParams["filename"]
|
|
|
|
|
|
|
|
// TODO: set Content-Length if possible
|
|
|
|
|
|
|
|
if !strings.EqualFold(mimeType, "text/plain") || strings.EqualFold(disp, "attachment") {
|
|
|
|
dispParams := make(map[string]string)
|
|
|
|
if filename != "" {
|
|
|
|
dispParams["filename"] = filename
|
|
|
|
}
|
|
|
|
disp := mime.FormatMediaType("attachment", dispParams)
|
|
|
|
ctx.Response().Header().Set("Content-Disposition", disp)
|
|
|
|
}
|
|
|
|
return ctx.Stream(http.StatusOK, mimeType, part.Body)
|
|
|
|
}
|
|
|
|
|
|
|
|
var body string
|
|
|
|
if strings.HasPrefix(strings.ToLower(mimeType), "text/") {
|
|
|
|
b, err := ioutil.ReadAll(part.Body)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to read part body: %v", err)
|
|
|
|
}
|
|
|
|
body = string(b)
|
|
|
|
}
|
|
|
|
|
2019-12-09 15:17:36 +00:00
|
|
|
return ctx.Render(http.StatusOK, "message.html", &MessageRenderData{
|
2019-12-16 11:51:42 +00:00
|
|
|
RenderData: *koushin.NewRenderData(ctx),
|
2019-12-09 15:17:36 +00:00
|
|
|
Mailbox: mbox,
|
|
|
|
Message: msg,
|
|
|
|
Body: body,
|
|
|
|
PartPath: partPathString,
|
|
|
|
MailboxPage: int(mbox.Messages-msg.SeqNum) / messagesPerPage,
|
2019-12-04 19:55:08 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-12-09 15:17:36 +00:00
|
|
|
type ComposeRenderData struct {
|
2019-12-16 11:51:42 +00:00
|
|
|
koushin.RenderData
|
2019-12-09 15:17:36 +00:00
|
|
|
Message *OutgoingMessage
|
|
|
|
}
|
|
|
|
|
2019-12-04 19:55:08 +00:00
|
|
|
func handleCompose(ectx echo.Context) error {
|
2019-12-16 11:51:42 +00:00
|
|
|
ctx := ectx.(*koushin.Context)
|
2019-12-04 19:55:08 +00:00
|
|
|
|
|
|
|
var msg OutgoingMessage
|
2019-12-16 11:51:42 +00:00
|
|
|
if strings.ContainsRune(ctx.Session.Username(), '@') {
|
|
|
|
msg.From = ctx.Session.Username()
|
2019-12-04 19:55:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.Request().Method == http.MethodGet && ctx.Param("uid") != "" {
|
|
|
|
// This is a reply
|
|
|
|
mboxName, uid, err := parseMboxAndUid(ctx.Param("mbox"), ctx.Param("uid"))
|
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, err)
|
|
|
|
}
|
|
|
|
partPath, err := parsePartPath(ctx.QueryParam("part"))
|
|
|
|
if err != nil {
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
var inReplyTo *imapMessage
|
|
|
|
var part *message.Entity
|
2019-12-16 12:01:33 +00:00
|
|
|
err = ctx.Session.DoIMAP(func(c *imapclient.Client) error {
|
2019-12-04 19:55:08 +00:00
|
|
|
var err error
|
|
|
|
inReplyTo, part, err = getMessagePart(c, mboxName, uid, partPath)
|
|
|
|
return err
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
mimeType, _, err := part.Header.ContentType()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("failed to parse part Content-Type: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !strings.HasPrefix(strings.ToLower(mimeType), "text/") {
|
|
|
|
err := fmt.Errorf("cannot reply to \"%v\" part", mimeType)
|
|
|
|
return echo.NewHTTPError(http.StatusBadRequest, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
msg.Text, err = quote(part.Body)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
msg.InReplyTo = inReplyTo.Envelope.MessageId
|
|
|
|
// TODO: populate From from known user addresses and inReplyTo.Envelope.To
|
|
|
|
replyTo := inReplyTo.Envelope.ReplyTo
|
|
|
|
if len(replyTo) == 0 {
|
|
|
|
replyTo = inReplyTo.Envelope.From
|
|
|
|
}
|
|
|
|
if len(replyTo) > 0 {
|
|
|
|
msg.To = make([]string, len(replyTo))
|
|
|
|
for i, to := range replyTo {
|
2019-12-09 12:45:15 +00:00
|
|
|
msg.To[i] = to.Address()
|
2019-12-04 19:55:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
msg.Subject = inReplyTo.Envelope.Subject
|
|
|
|
if !strings.HasPrefix(strings.ToLower(msg.Subject), "re:") {
|
|
|
|
msg.Subject = "Re: " + msg.Subject
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ctx.Request().Method == http.MethodPost {
|
|
|
|
msg.From = ctx.FormValue("from")
|
|
|
|
msg.To = parseAddressList(ctx.FormValue("to"))
|
|
|
|
msg.Subject = ctx.FormValue("subject")
|
|
|
|
msg.Text = ctx.FormValue("text")
|
|
|
|
msg.InReplyTo = ctx.FormValue("in_reply_to")
|
|
|
|
|
2019-12-16 12:07:35 +00:00
|
|
|
err := ctx.Session.DoSMTP(func(c *smtp.Client) error {
|
|
|
|
return sendMessage(c, &msg)
|
|
|
|
})
|
2019-12-04 19:55:08 +00:00
|
|
|
if err != nil {
|
2019-12-16 11:51:42 +00:00
|
|
|
if _, ok := err.(koushin.AuthError); ok {
|
|
|
|
return echo.NewHTTPError(http.StatusForbidden, err)
|
|
|
|
}
|
2019-12-04 19:55:08 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: append to IMAP Sent mailbox
|
|
|
|
|
|
|
|
return ctx.Redirect(http.StatusFound, "/mailbox/INBOX")
|
|
|
|
}
|
|
|
|
|
2019-12-09 15:17:36 +00:00
|
|
|
return ctx.Render(http.StatusOK, "compose.html", &ComposeRenderData{
|
2019-12-16 11:51:42 +00:00
|
|
|
RenderData: *koushin.NewRenderData(ctx),
|
2019-12-10 16:39:42 +00:00
|
|
|
Message: &msg,
|
2019-12-04 19:55:08 +00:00
|
|
|
})
|
|
|
|
}
|