749 lines
17 KiB
Plaintext
749 lines
17 KiB
Plaintext
%{
|
|
/*
|
|
* Copyright (c) 2004 Jann Fischer. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/**
|
|
* These are the grammatic definitions in yacc syntax to parse MIME conform
|
|
* messages.
|
|
*
|
|
* TODO:
|
|
* - honour parse flags passed to us (partly done)
|
|
* - parse Content-Disposition header (partly done)
|
|
* - parse Content-Encoding header
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
|
|
#include "mimeparser.h"
|
|
#include "mm.h"
|
|
#include "mm_internal.h"
|
|
|
|
int set_boundary(char *,struct parser_state *);
|
|
int mimeparser_yywrap(void);
|
|
void reset_environ(struct parser_state *pstate);
|
|
int PARSER_initialize(struct parser_state *pstate, void *yyscanner);
|
|
|
|
static char *PARSE_readmessagepart(size_t, size_t, size_t, size_t *,yyscan_t, struct parser_state *);
|
|
FILE *mimeparser_yyget_in (yyscan_t yyscanner );
|
|
|
|
%}
|
|
|
|
%pure-parser
|
|
%parse-param {struct parser_state *pstate}
|
|
%parse-param {void *yyscanner}
|
|
%lex-param {void *yyscanner}
|
|
|
|
%union
|
|
{
|
|
int number;
|
|
char *string;
|
|
struct s_position position;
|
|
}
|
|
|
|
%token ANY
|
|
%token COLON
|
|
%token DASH
|
|
%token DQUOTE
|
|
%token ENDOFHEADERS
|
|
%token EOL
|
|
%token EOM
|
|
%token EQUAL
|
|
%token MIMEVERSION_HEADER
|
|
%token SEMICOLON
|
|
|
|
%token <string> CONTENTDISPOSITION_HEADER
|
|
%token <string> CONTENTENCODING_HEADER
|
|
%token <string> CONTENTTYPE_HEADER
|
|
%token <string> MAIL_HEADER
|
|
%token <string> HEADERVALUE
|
|
%token <string> BOUNDARY
|
|
%token <string> ENDBOUNDARY
|
|
%token <string> CONTENTTYPE_VALUE
|
|
%token <string> TSPECIAL
|
|
%token <string> WORD
|
|
|
|
%token <position> BODY
|
|
%token <position> PREAMBLE
|
|
%token <position> POSTAMBLE
|
|
|
|
%type <string> content_disposition
|
|
%type <string> contenttype_parameter_value
|
|
%type <string> mimetype
|
|
%type <string> body
|
|
|
|
%start message
|
|
|
|
%%
|
|
|
|
/* This is a parser for a MIME-conform message, which is in either single
|
|
* part or multi part format.
|
|
*/
|
|
message :
|
|
multipart_message
|
|
|
|
|
singlepart_message
|
|
;
|
|
|
|
multipart_message:
|
|
headers preamble
|
|
{
|
|
mm_context_attachpart(pstate->ctx, pstate->current_mimepart);
|
|
pstate->current_mimepart = mm_mimepart_new();
|
|
pstate->have_contenttype = 0;
|
|
}
|
|
mimeparts endboundary postamble
|
|
{
|
|
dprintf2(pstate,"This was a multipart message\n");
|
|
}
|
|
;
|
|
|
|
singlepart_message:
|
|
headers body
|
|
{
|
|
dprintf2(pstate,"This was a single part message\n");
|
|
mm_context_attachpart(pstate->ctx, pstate->current_mimepart);
|
|
}
|
|
;
|
|
|
|
headers :
|
|
header headers
|
|
|
|
|
end_headers
|
|
{
|
|
/* If we did not find a Content-Type header for the current
|
|
* MIME part (or envelope), we create one and attach it.
|
|
* According to the RFC, a type of "text/plain" and a
|
|
* charset of "us-ascii" can be assumed.
|
|
*/
|
|
struct mm_content *ct;
|
|
struct mm_param *param;
|
|
|
|
if (!pstate->have_contenttype) {
|
|
ct = mm_content_new();
|
|
mm_content_settype(ct, "text/plain");
|
|
|
|
param = mm_param_new();
|
|
param->name = xstrdup("charset");
|
|
param->value = xstrdup("us-ascii");
|
|
|
|
mm_content_attachtypeparam(ct, param);
|
|
mm_mimepart_attachcontenttype(pstate->current_mimepart, ct);
|
|
}
|
|
pstate->have_contenttype = 0;
|
|
}
|
|
|
|
|
header
|
|
;
|
|
|
|
preamble:
|
|
PREAMBLE
|
|
{
|
|
char *preamble;
|
|
size_t offset;
|
|
|
|
if ($1.start != $1.end) {
|
|
preamble = PARSE_readmessagepart(0, $1.start, $1.end,
|
|
&offset,yyscanner,pstate);
|
|
if (preamble == NULL) {
|
|
return(-1);
|
|
}
|
|
pstate->ctx->preamble = preamble;
|
|
dprintf2(pstate,"PREAMBLE:\n%s\n", preamble);
|
|
}
|
|
}
|
|
|
|
|
;
|
|
|
|
postamble:
|
|
POSTAMBLE
|
|
{
|
|
}
|
|
|
|
|
;
|
|
|
|
mimeparts:
|
|
mimeparts mimepart
|
|
|
|
|
mimepart
|
|
;
|
|
|
|
mimepart:
|
|
boundary headers body
|
|
{
|
|
|
|
if (mm_context_attachpart(pstate->ctx, pstate->current_mimepart) == -1) {
|
|
mm_errno = MM_ERROR_ERRNO;
|
|
return(-1);
|
|
}
|
|
|
|
pstate->temppart = mm_mimepart_new();
|
|
pstate->current_mimepart = pstate->temppart;
|
|
pstate->mime_parts++;
|
|
}
|
|
;
|
|
|
|
header :
|
|
mail_header
|
|
|
|
|
contenttype_header
|
|
{
|
|
pstate->have_contenttype = 1;
|
|
if (mm_content_iscomposite(pstate->envelope->type)) {
|
|
pstate->ctx->messagetype = MM_MSGTYPE_MULTIPART;
|
|
} else {
|
|
pstate->ctx->messagetype = MM_MSGTYPE_FLAT;
|
|
}
|
|
}
|
|
|
|
|
contentdisposition_header
|
|
|
|
|
contentencoding_header
|
|
|
|
|
mimeversion_header
|
|
|
|
|
invalid_header
|
|
{
|
|
if (pstate->parsemode != MM_PARSE_LOOSE) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("invalid header encountered");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
} else {
|
|
/* TODO: attach MM_WARNING_INVHDR */
|
|
}
|
|
}
|
|
;
|
|
|
|
mail_header:
|
|
MAIL_HEADER COLON WORD EOL
|
|
{
|
|
struct mm_mimeheader *hdr;
|
|
hdr = mm_mimeheader_generate($1, $3);
|
|
mm_mimepart_attachheader(pstate->current_mimepart, hdr);
|
|
}
|
|
|
|
|
MAIL_HEADER COLON EOL
|
|
{
|
|
struct mm_mimeheader *hdr;
|
|
|
|
if (pstate->parsemode != MM_PARSE_LOOSE) {
|
|
mm_errno = MM_ERROR_MIME;
|
|
mm_error_setmsg("invalid header encountered");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
} else {
|
|
/* TODO: attach MM_WARNING_INVHDR */
|
|
}
|
|
|
|
hdr = mm_mimeheader_generate($1, xstrdup(""));
|
|
mm_mimepart_attachheader(pstate->current_mimepart, hdr);
|
|
}
|
|
;
|
|
|
|
contenttype_header:
|
|
CONTENTTYPE_HEADER COLON mimetype EOL
|
|
{
|
|
mm_content_settype(pstate->ctype, "%s", $3);
|
|
mm_mimepart_attachcontenttype(pstate->current_mimepart, pstate->ctype);
|
|
dprintf2(pstate,"Content-Type -> %s\n", $3);
|
|
pstate->ctype = mm_content_new();
|
|
}
|
|
|
|
|
CONTENTTYPE_HEADER COLON mimetype contenttype_parameters EOL
|
|
{
|
|
mm_content_settype(pstate->ctype, "%s", $3);
|
|
mm_mimepart_attachcontenttype(pstate->current_mimepart, pstate->ctype);
|
|
dprintf2(pstate,"Content-Type (P) -> %s\n", $3);
|
|
pstate->ctype = mm_content_new();
|
|
}
|
|
;
|
|
|
|
contentdisposition_header:
|
|
CONTENTDISPOSITION_HEADER COLON content_disposition EOL
|
|
{
|
|
dprintf2(pstate,"Content-Disposition -> %s\n", $3);
|
|
pstate->ctype->disposition_type = xstrdup($3);
|
|
}
|
|
|
|
|
CONTENTDISPOSITION_HEADER COLON content_disposition content_disposition_parameters EOL
|
|
{
|
|
dprintf2(pstate,"Content-Disposition (P) -> %s; params\n", $3);
|
|
pstate->ctype->disposition_type = xstrdup($3);
|
|
}
|
|
;
|
|
|
|
content_disposition:
|
|
WORD
|
|
{
|
|
/*
|
|
* According to RFC 2183, the content disposition value may
|
|
* only be "inline", "attachment" or an extension token. We
|
|
* catch invalid values here if we are not in loose parsing
|
|
* mode.
|
|
*/
|
|
if (strcasecmp($1, "inline") && strcasecmp($1, "attachment")
|
|
&& strncasecmp($1, "X-", 2)) {
|
|
if (pstate->parsemode != MM_PARSE_LOOSE) {
|
|
mm_errno = MM_ERROR_MIME;
|
|
mm_error_setmsg("invalid content-disposition");
|
|
return(-1);
|
|
}
|
|
} else {
|
|
/* TODO: attach MM_WARNING_INVHDR */
|
|
}
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
contentencoding_header:
|
|
CONTENTENCODING_HEADER COLON WORD EOL
|
|
{
|
|
dprintf2(pstate,"Content-Transfer-Encoding -> %s\n", $3);
|
|
}
|
|
;
|
|
|
|
mimeversion_header:
|
|
MIMEVERSION_HEADER COLON WORD EOL
|
|
{
|
|
dprintf2(pstate,"MIME-Version -> '%s'\n", $3);
|
|
}
|
|
;
|
|
|
|
invalid_header:
|
|
any EOL
|
|
;
|
|
|
|
any:
|
|
any ANY
|
|
|
|
|
ANY
|
|
;
|
|
|
|
mimetype:
|
|
WORD '/' WORD
|
|
{
|
|
char type[255];
|
|
snprintf(type, sizeof(type), "%s/%s", $1, $3);
|
|
$$ = type;
|
|
}
|
|
;
|
|
|
|
contenttype_parameters:
|
|
SEMICOLON contenttype_parameter contenttype_parameters
|
|
|
|
|
SEMICOLON contenttype_parameter
|
|
|
|
|
SEMICOLON
|
|
{
|
|
if (pstate->parsemode != MM_PARSE_LOOSE) {
|
|
mm_errno = MM_ERROR_MIME;
|
|
mm_error_setmsg("invalid Content-Type header");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
} else {
|
|
/* TODO: attach MM_WARNING_INVHDR */
|
|
}
|
|
}
|
|
;
|
|
|
|
content_disposition_parameters:
|
|
SEMICOLON content_disposition_parameter content_disposition_parameters
|
|
|
|
|
SEMICOLON content_disposition_parameter
|
|
|
|
|
SEMICOLON
|
|
{
|
|
if (pstate->parsemode != MM_PARSE_LOOSE) {
|
|
mm_errno = MM_ERROR_MIME;
|
|
mm_error_setmsg("invalid Content-Disposition header");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
} else {
|
|
/* TODO: attach MM_WARNING_INVHDR */
|
|
}
|
|
}
|
|
;
|
|
|
|
contenttype_parameter:
|
|
WORD EQUAL contenttype_parameter_value
|
|
{
|
|
struct mm_param *param;
|
|
param = mm_param_new();
|
|
|
|
dprintf2(pstate,"Param: '%s', Value: '%s'\n", $1, $3);
|
|
|
|
/* Catch an eventual boundary identifier */
|
|
if (!strcasecmp($1, "boundary")) {
|
|
if (pstate->lstate.boundary_string == NULL) {
|
|
set_boundary($3,pstate);
|
|
} else {
|
|
if (pstate->parsemode != MM_PARSE_LOOSE) {
|
|
mm_errno = MM_ERROR_MIME;
|
|
mm_error_setmsg("duplicate boundary "
|
|
"found");
|
|
return -1;
|
|
} else {
|
|
/* TODO: attach MM_WARNING_DUPPARAM */
|
|
}
|
|
}
|
|
}
|
|
|
|
param->name = xstrdup($1);
|
|
param->value = xstrdup($3);
|
|
|
|
mm_content_attachtypeparam(pstate->ctype, param);
|
|
}
|
|
;
|
|
|
|
content_disposition_parameter:
|
|
WORD EQUAL contenttype_parameter_value
|
|
{
|
|
struct mm_param *param;
|
|
param = mm_param_new();
|
|
|
|
param->name = xstrdup($1);
|
|
param->value = xstrdup($3);
|
|
|
|
mm_content_attachdispositionparam(pstate->ctype, param);
|
|
|
|
}
|
|
;
|
|
|
|
contenttype_parameter_value:
|
|
WORD
|
|
{
|
|
dprintf2(pstate,"contenttype_param_val: WORD=%s\n", $1);
|
|
$$ = $1;
|
|
}
|
|
|
|
|
TSPECIAL
|
|
{
|
|
dprintf2(pstate,"contenttype_param_val: TSPECIAL\n");
|
|
/* For broken MIME implementation */
|
|
if (pstate->parsemode != MM_PARSE_LOOSE) {
|
|
mm_errno = MM_ERROR_MIME;
|
|
mm_error_setmsg("tspecial without quotes");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
} else {
|
|
/* TODO: attach MM_WARNING_INVAL */
|
|
}
|
|
$$ = $1;
|
|
}
|
|
|
|
|
'"' TSPECIAL '"'
|
|
{
|
|
dprintf2(pstate,"contenttype_param_val: \"TSPECIAL\"\n" );
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
end_headers :
|
|
ENDOFHEADERS
|
|
{
|
|
dprintf2(pstate,"End of headers at line %d\n", pstate->lstate.lineno);
|
|
}
|
|
;
|
|
|
|
boundary :
|
|
BOUNDARY EOL
|
|
{
|
|
if (pstate->lstate.boundary_string == NULL) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("internal incosistency");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
}
|
|
if (strcmp(pstate->lstate.boundary_string, $1)) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("invalid boundary: '%s' (%d)", $1, strlen($1));
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
}
|
|
dprintf2(pstate,"New MIME part... (%s)\n", $1);
|
|
}
|
|
;
|
|
|
|
endboundary :
|
|
ENDBOUNDARY
|
|
{
|
|
if (pstate->lstate.endboundary_string == NULL) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("internal incosistency");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
}
|
|
if (strcmp(pstate->lstate.endboundary_string, $1)) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("invalid end boundary: %s", $1);
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(-1);
|
|
}
|
|
dprintf2(pstate,"End of MIME message\n");
|
|
}
|
|
;
|
|
|
|
body:
|
|
BODY
|
|
{
|
|
char *body;
|
|
size_t offset;
|
|
|
|
dprintf2(pstate,"BODY (%d/%d), SIZE %d\n", $1.start, $1.end, $1.end - $1.start);
|
|
|
|
body = PARSE_readmessagepart($1.opaque_start, $1.start, $1.end,
|
|
&offset,yyscanner,pstate);
|
|
|
|
if (body == NULL) {
|
|
return(-1);
|
|
}
|
|
pstate->current_mimepart->opaque_body = body;
|
|
pstate->current_mimepart->body = body + offset;
|
|
pstate->current_mimepart->opaque_length = $1.end - $1.start - 2 + offset;
|
|
pstate->current_mimepart->length = pstate->current_mimepart->opaque_length - offset;
|
|
}
|
|
;
|
|
|
|
%%
|
|
|
|
/*
|
|
* This function gets the specified part from the currently parsed message.
|
|
*/
|
|
static char *
|
|
PARSE_readmessagepart(size_t opaque_start, size_t real_start, size_t end,
|
|
size_t *offset, yyscan_t yyscanner, struct parser_state *pstate)
|
|
{
|
|
size_t body_size;
|
|
size_t current;
|
|
size_t start;
|
|
char *body;
|
|
|
|
/* calculate start and offset markers for the opaque and
|
|
* header stripped body message.
|
|
*/
|
|
if (opaque_start > 0) {
|
|
/* Multipart message */
|
|
if (real_start) {
|
|
if (real_start < opaque_start) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("internal incosistency (S:%d/O:%d)",
|
|
real_start,
|
|
opaque_start);
|
|
return(NULL);
|
|
}
|
|
start = opaque_start;
|
|
*offset = real_start - start;
|
|
/* Flat message */
|
|
} else {
|
|
start = opaque_start;
|
|
*offset = 0;
|
|
}
|
|
} else {
|
|
start = real_start;
|
|
*offset = 0;
|
|
}
|
|
|
|
/* The next three cases should NOT happen anytime */
|
|
if (end <= start) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("internal incosistency,2");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(NULL);
|
|
}
|
|
if (start < *offset) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("internal incosistency, S:%d,O:%d,L:%d", start, offset, pstate->lstate.lineno);
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(NULL);
|
|
}
|
|
if (start < 0 || end < 0) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("internal incosistency,4");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(NULL);
|
|
}
|
|
|
|
/* XXX: do we want to enforce a maximum body size? make it a
|
|
* parser option? */
|
|
|
|
/* Read in the body message */
|
|
body_size = end - start;
|
|
|
|
if (body_size < 1) {
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("size of body cannot be < 1");
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return(NULL);
|
|
}
|
|
|
|
body = (char *)malloc(body_size + 1);
|
|
if (body == NULL) {
|
|
mm_errno = MM_ERROR_ERRNO;
|
|
return(NULL);
|
|
}
|
|
|
|
/* Get the message body either from a stream or a memory
|
|
* buffer.
|
|
*/
|
|
if (mimeparser_yyget_in(yyscanner) != NULL) {
|
|
FILE *x = mimeparser_yyget_in(yyscanner);
|
|
current = ftell(x);
|
|
fseek(x, start - 1, SEEK_SET);
|
|
fread(body, body_size - 1, 1, x);
|
|
fseek(x, current, SEEK_SET);
|
|
} else if (pstate->lstate.message_buffer != NULL) {
|
|
strlcpy(body, pstate->lstate.message_buffer + start - 1, body_size);
|
|
}
|
|
|
|
return(body);
|
|
|
|
}
|
|
|
|
int
|
|
yyerror(struct parser_state *pstate, void *yyscanner, const char *str)
|
|
{
|
|
mm_errno = MM_ERROR_PARSE;
|
|
mm_error_setmsg("%s", str);
|
|
mm_error_setlineno(pstate->lstate.lineno);
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
mimeparser_yywrap(void)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Sets the boundary value for the current message
|
|
*/
|
|
int
|
|
set_boundary(char *str, struct parser_state *pstate)
|
|
{
|
|
size_t blen;
|
|
|
|
blen = strlen(str);
|
|
|
|
pstate->lstate.boundary_string = (char *)malloc(blen + 3);
|
|
pstate->lstate.endboundary_string = (char *)malloc(blen + 5);
|
|
|
|
if (pstate->lstate.boundary_string == NULL || pstate->lstate.endboundary_string == NULL) {
|
|
if (pstate->lstate.boundary_string != NULL) {
|
|
free(pstate->lstate.boundary_string);
|
|
}
|
|
if (pstate->lstate.endboundary_string != NULL) {
|
|
free(pstate->lstate.endboundary_string);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
pstate->ctx->boundary = xstrdup(str);
|
|
|
|
snprintf(pstate->lstate.boundary_string, blen + 3, "--%s", str);
|
|
snprintf(pstate->lstate.endboundary_string, blen + 5, "--%s--", str);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Debug printf()
|
|
*/
|
|
int
|
|
dprintf2(struct parser_state *pstate, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
char *msg;
|
|
if (pstate->debug == 0) return 1;
|
|
|
|
va_start(ap, fmt);
|
|
vasprintf(&msg, fmt, ap);
|
|
va_end(ap);
|
|
|
|
fprintf(stderr, "%s", msg);
|
|
free(msg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
void reset_environ(struct parser_state *pstate)
|
|
{
|
|
pstate->lstate.lineno = 0;
|
|
pstate->lstate.boundary_string = NULL;
|
|
pstate->lstate.endboundary_string = NULL;
|
|
pstate->lstate.message_buffer = NULL;
|
|
pstate->mime_parts = 0;
|
|
pstate->debug = 0;
|
|
pstate->envelope = NULL;
|
|
pstate->temppart = NULL;
|
|
pstate->ctype = NULL;
|
|
pstate->current_mimepart = NULL;
|
|
|
|
pstate->have_contenttype = 0;
|
|
}
|
|
/**
|
|
* Initializes the parser engine.
|
|
*/
|
|
int
|
|
PARSER_initialize(struct parser_state *pstate, void *yyscanner)
|
|
{
|
|
void reset_lexer_state(void *yyscanner, struct parser_state *);
|
|
#if 0
|
|
if (pstate->ctx != NULL) {
|
|
xfree(pstate->ctx);
|
|
pstate->ctx = NULL;
|
|
}
|
|
if (pstate->envelope != NULL) {
|
|
xfree(pstate->envelope);
|
|
pstate->envelope = NULL;
|
|
}
|
|
if (pstate->ctype != NULL) {
|
|
xfree(pstate->ctype);
|
|
pstate->ctype = NULL;
|
|
}
|
|
#endif
|
|
/* yydebug = 1; */
|
|
reset_environ(pstate);
|
|
reset_lexer_state(yyscanner,pstate);
|
|
|
|
pstate->envelope = mm_mimepart_new();
|
|
pstate->current_mimepart = pstate->envelope;
|
|
pstate->ctype = mm_content_new();
|
|
|
|
pstate->have_contenttype = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|