/*
 *  This program 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 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301, USA.
 *
 *  Copyright © 2006 Pierre Habouzit
 */
/*
 * Copyright notice from original mutt:
 * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
 * Copyright (C) 1999-2000 Thomas Roessler <roessler@does-not-exist.org>
 */

#include <lib-lib/lib-lib.h>
#include <lib-lua/lib-lua.h>
#include "mime.h"
@import "../lib-lua/base.cpkg"

#define BOUNDARYLEN 16
const char MimeSpecials[] = "@.,;:<>[]\\\"()?/= \t";

const char *BodyTypes[] = {
    "x-unknown",
    "audio",
    "application",
    "image",
    "message",
    "model",
    "multipart",
    "text",
    "video",
};

const char *BodyEncodings[] = {
    "x-unknown",
    "7bit",
    "8bit",
    "quoted-printable",
    "base64",
    "binary",
    "x-uuencoded",
};

rx_t *SpamList = NULL, *NoSpamList = NULL;
string_list_t *AutoViewList, *AlternativeOrderList, *MimeLookupList;
string_list_t *Ignore, *UnIgnore, *HeaderOrderList;

static char *mailcap_init(void)
{
    /* Default search path from RFC1524 */
    const char *path = "~/.mailcap:" PKGDATADIR "/mailcap:"
        SYSCONFDIR "/mailcap:/etc/mailcap:"
        "/usr/etc/mailcap:/usr/local/etc/mailcap";
    return m_strdup(getenv("MAILCAPS") ?: path);
}

@package Mime {
    /*
     ** .pp
     ** ``$spam_separator'' controls what happens when multiple spam headers
     ** are matched: if \fIunset\fP, each successive header will overwrite any
     ** previous matches value for the spam label. If \fIset\fP, each successive
     ** match will append to the previous, using ``$spam_separator'' as a
     ** separator.
     */
    string_t spam_separator = m_strdup(",");

    /*
     ** .pp
     ** This variable specifies which files to consult when attempting to
     ** display MIME bodies not directly supported by Madmutt.
     */
    string_t mailcap_path   = mailcap_init();

    /*
     ** .pp
     ** If \fIset\fP, Madmutt will restrict possible characters in mailcap \fT%\fP expandos
     ** to a well-defined set of safe characters.  This is the safe setting,
     ** but we are not sure it doesn't break some more advanced MIME stuff.
     ** .pp
     ** \fBDON'T CHANGE THIS SETTING UNLESS YOU ARE REALLY SURE WHAT YOU ARE
     ** DOING!\fP
     */
    bool mailcap_sanitize   = 1;

    void spam(rx_t rx, const string_t tpl) {
        rx_set_template(rx, tpl);
        rx_list_remove(&NoSpamList, rx);
        rx_list_add2(&SpamList, &rx);
        RETURN();
    };

    void nospam(rx_t rx) {
        if (!m_strcmp(rx->pattern, "*")) {
            rx_list_wipe(&SpamList);
            rx_list_wipe(&NoSpamList);
            rx_delete(&rx);
        } else {
            rx_list_remove(&SpamList, rx);
            rx_list_add2(&NoSpamList, &rx);
        }
        RETURN();
    };

    void auto_view(string_t s) {
        string_list_add(&AutoViewList, s);
        RETURN();
    };
    void unauto_view(string_t s) {
        if (m_strcmp(s, "*")) {
            string_list_remove(&AutoViewList, s);
        } else {
            string_list_wipe(&AutoViewList);
        }
        RETURN();
    };

    void alternative_order(string_t s) {
        string_list_add(&AlternativeOrderList, s);
        RETURN();
    };
    void unalternative_order(string_t s) {
        if (m_strcmp(s, "*")) {
            string_list_remove(&AlternativeOrderList, s);
        } else {
            string_list_wipe(&AlternativeOrderList);
        }
        RETURN();
    };

    void lookup(string_t s) {
        string_list_add(&MimeLookupList, s);
        RETURN();
    };
    void unlookup(string_t s) {
        if (m_strcmp(s, "*")) {
            string_list_remove(&MimeLookupList, s);
        } else {
            string_list_wipe(&MimeLookupList);
        }
        RETURN();
    };

    void hdr_order(string_t s) {
        string_list_add(&HeaderOrderList, s);
        RETURN();
    };
    void unhdr_order(string_t s) {
        if (m_strcmp(s, "*")) {
            string_list_remove(&HeaderOrderList, s);
        } else {
            string_list_wipe(&HeaderOrderList);
        }
        RETURN();
    };

    void ignore(string_t s) {
        if (m_strcmp(s, "*")) {
            string_list_remove(&UnIgnore, s);
        } else {
            string_list_wipe(&UnIgnore);
        }
        string_list_add(&Ignore, s);
        RETURN();
    };
    void unignore(string_t s) {
        if (m_strcmp(s, "*")) {
            string_list_add(&UnIgnore, s);
            string_list_remove(&Ignore, s);
        } else {
            string_list_wipe(&Ignore);
        }
        RETURN();
    };
};

/****************************************************************************/
/* rfc822 header parameters                                                 */
/****************************************************************************/

char *parameter_getval(parameter_t *parm, const char *s)
{
    while (parm) {
        if (!ascii_strcasecmp(parm->attribute, s))
            return parm->value;
        parm = parm->next;
    }
    return NULL;
}

void parameter_setval(parameter_t **p, const char *attribute, const char *value)
{
    while (*p) {
        if (!ascii_strcasecmp(attribute, (*p)->attribute)) {
            if (value) {
                m_strreplace(&(*p)->value, value);
            } else {
                parameter_t *q = parameter_list_pop(p);
                parameter_delete(&q);
            }
            return;
        }
        p = &(*p)->next;
    }

    if (value) {
        (*p) = parameter_new();
        (*p)->attribute = m_strdup(attribute);
        (*p)->value = m_strdup(value);
    }
}

void parameter_delval(parameter_t **p, const char *attribute)
{
    while (*p) {
        if (!ascii_strcasecmp(attribute, (*p)->attribute)) {
            parameter_t *q = parameter_list_pop(p);
            parameter_delete(&q);
            return;
        }

        p = &(*p)->next;
    }
}

int parameter_equal(const parameter_t *p1, const parameter_t *p2)
{
    while (p1 && p2) {
        if (m_strcmp(p1->attribute, p2->attribute)
        ||  m_strcmp(p1->value, p2->value))
            return 0;

        p1 = p1->next;
        p2 = p2->next;
    }

    if (p1 || p2)
        return 0;

    return 1;
}

void parameter_set_boundary(parameter_t **parm)
{
    char rs[BOUNDARYLEN + 1];
    int i;

    for (i = 0; i < BOUNDARYLEN; i++) {
        rs[i] = __m_b64chars[lrand48() % sizeof(__m_b64chars)];
    }
    rs[BOUNDARYLEN] = '\0';

    parameter_setval(parm, "boundary", rs);
}


/****************************************************************************/
/* XXX                                                                      */
/****************************************************************************/

void envelope_wipe(ENVELOPE *p)
{
    address_list_wipe(&p->return_path);
    address_list_wipe(&p->from);
    address_list_wipe(&p->to);
    address_list_wipe(&p->cc);
    address_list_wipe(&p->bcc);
    address_list_wipe(&p->sender);
    address_list_wipe(&p->reply_to);
    address_list_wipe(&p->mail_followup_to);

    p_delete(&p->list_post);
    p_delete(&p->subject);
    /* real_subj is just an offset to subject and shouldn't be freed */
    p_delete(&p->message_id);
    p_delete(&p->supersedes);
    p_delete(&p->date);
    p_delete(&p->x_label);
    p_delete(&p->organization);
#ifdef USE_NNTP
    p_delete(&p->newsgroups);
    p_delete(&p->xref);
    p_delete(&p->followup_to);
    p_delete(&p->x_comment_to);
#endif

    mutt_buffer_free (&p->spam);
    string_list_wipe(&p->references);
    string_list_wipe(&p->in_reply_to);
    string_list_wipe(&p->userhdrs);
}

void body_wipe(BODY *b)
{
    if (b->parameter)
        parameter_list_wipe(&b->parameter);

    if (b->unlink && b->filename) {
        unlink (b->filename);
    }

    p_delete(&b->filename);
    p_delete(&b->content);
    p_delete(&b->xtype);
    p_delete(&b->subtype);
    p_delete(&b->description);
    p_delete(&b->form_name);

    if (b->hdr) {
        /* Don't free twice (b->hdr->content = b->parts) */
        b->hdr->content = NULL;
        header_delete(&b->hdr);
    }

    if (b->parts)
        body_list_wipe(&b->parts);
}

void header_wipe(HEADER *h)
{
    envelope_delete(&h->env);
    body_list_wipe(&h->content);
    p_delete(&h->maildir_flags);
    p_delete(&h->tree);
    p_delete(&h->path);
    string_list_wipe(&h->chain);
    p_delete(&h->data);
}


/****************************************************************************/
/* misc functions                                                           */
/****************************************************************************/

int mutt_is_message_type(BODY *b)
{
    int tok;

    if (b->type != TYPEMESSAGE)
        return 0;

    tok = mime_which_token(b->subtype, -1);
    return tok == MIME_RFC822 || tok == MIME_NEWS;
}

int mutt_is_text_part(BODY * b)
{
    char *s = b->subtype;

    if (mutt_is_application_pgp(b))
        return 0;

    switch (b->type) {
      case TYPETEXT:
        return 1;

      case TYPEMESSAGE:
        return mime_which_token(s, -1) == MIME_DELIVERY_STATUS;

      case TYPEAPPLICATION:
        return mime_which_token(s, -1) == MIME_PGP_KEYS;

      default:
        return 0;
    }
}

/* vim:set ft=c: */