mpack_src/mpack-1.6-4/part.c

/*
 * Read MIME body-part, stopping on boundaries.
 */
/* (C) Copyright 1994 by Carnegie Mellon University
 * All Rights Reserved.
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without
 * fee, provided that the above copyright notice appear in all copies
 * and that both that copyright notice and this permission notice
 * appear in supporting documentation, and that the name of Carnegie
 * Mellon University not be used in advertising or publicity
 * pertaining to distribution of the software without specific,
 * written prior permission.  Carnegie Mellon University makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied
 * warranty.
 *
 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "part.h"
#include "xmalloc.h"

#define BUFSIZE 1024 /* must be > PART_MAX_BOUNDARY_LEN */
#define GROWBOUNDARY 20

static int pendingboundary(struct part *part);

/*
 * Create, initialize, and return a new struct part pointer
 * for the input file 'infile'.
 */
struct part *part_init(FILE *infile)
{
    static struct part zeropart;
    struct part *newpart;

    newpart = (struct part *)xmalloc(sizeof(struct part));
    *newpart = zeropart;
    newpart->infile = infile;
    newpart->buf = (unsigned char *)xmalloc(BUFSIZE);
    newpart->buf_alloc = BUFSIZE;

    return newpart;
}

/*
 * Close and free 'part'.
 */
void part_close(struct part *part)
{
    fclose(part->infile);
    if (part->buf) free(part->buf);
    if (part->boundary) free(part->boundary);
}

/*
 * Return the multipart depth of 'part'.  Top-level is '0'.
 */
int
part_depth(struct part *part)
{
    return part->boundary_num;
}

/*
 * Add to 'part' the multipart boundary 'boundary'.
 */
void part_addboundary(struct part *part, char *boundary)
{
    /* Grow boundary array if necessary */
    if (part->boundary_num == part->boundary_alloc) {
        part->boundary_alloc += GROWBOUNDARY;
        part->boundary = (char (*)[PART_MAX_BOUNDARY_LEN+1])
            xrealloc((char *)part->boundary,
                     part->boundary_alloc * (PART_MAX_BOUNDARY_LEN+1));
        part->boundary_length = (int *)
            xrealloc((char *)part->boundary_length,
                     part->boundary_alloc * sizeof(int));
    }

    strncpy(part->boundary[part->boundary_num], boundary,
            PART_MAX_BOUNDARY_LEN);
    part->boundary[part->boundary_num][PART_MAX_BOUNDARY_LEN] = '\0';
    part->boundary_length[part->boundary_num] =
        strlen(part->boundary[part->boundary_num]);
    part->boundary_num++;
    if (part->boundary_seen+1 == part->boundary_num) {
        part->boundary_seen++;
    }
}

/*
 * Private function that is only called from the part_getc() macro.
 *
 * Fills the input buffer for 'part' if necessary.  Returns the next
 * input character or EOF if at a boundary or end of file.
 */
int
part_fill(struct part *part)
{
    /* part_getc() decremented this before calling us, put it back */
    part->cnt++;

    /* Return EOF if we saw a boundary */
    if (part->boundary_seen < part->boundary_num) return EOF;

    /* Fill buffer if it is empty */
    if (part->cnt == 0) {
        part->ptr = part->buf;
        part->cnt = fread(part->buf, 1, part->buf_alloc, part->infile);
        if (part->cnt == 0) {
            part->boundary_seen = 0;
            return EOF;
        }
    }

    /* If there is a newline, see if it is followed by a boundary */
    if (part->ptr[0] == '\n' && pendingboundary(part)) {
        return EOF;
    }

    part->cnt--;
    return *part->ptr++;
}

/*
 * Read a line into the array 's', of size 'n', from 'part'.
 * Reads until 'n'-1 characters are read, a newline is read, or
 * an EOF is encountered.  The array is then nul-terminated and returned.
 * If the first character read is an EOF, then a null pointer is instead
 * returned.
 */
char *
part_gets(char *s, int n, struct part *part)
{
    int c;
    char *p = s;
    
    if (n == 0) return 0;
    n--;
    while (n-- && (c = part_getc(part)) != EOF) {
        *p++ = c;
        if (c == '\n') break;
    }
    if (p == s) return 0;
    *p++ = '\0';
    return s;
}

/*
 * Push back the string 's' into the input buffer of 'part'.
 * Leaves room in the input buffer to push back an additional single
 * character using the prot_ungetc() macro.
 */
void part_ungets(char *s, struct part *part)
{
    int len = strlen(s);
    int i;

    /* Grow buffer if necessary */
    if (part->cnt + len + 1 > part->buf_alloc) {
        i = part->ptr - part->buf;
        part->buf_alloc = part->cnt + len + 1;
        part->buf = (unsigned char *)
            xrealloc((char *)part->buf, part->buf_alloc);
        part->ptr = part->buf + i;
    }

    /* Move current data down to make room for new data if necessary */
    if (len + 1 > part->ptr - part->buf) {
        for (i = part->cnt-1; i >= 0; i--) {
            part->buf[len+1+i] = part->ptr[i];
        }
        part->ptr = part->buf + len + 1;
    }

    /* Copy in the new data */
    part->ptr -= len;
    part->cnt += len;
    for (i = 0; i < len; i++) {
        part->ptr[i] = s[i];
    }
}

/*
 * Reset the saw-boundary state of 'part' and set up to read next
 * body-part Returns nonzero iff the pending boundary was a final
 * boundary of the current multipart.
 */
int
part_readboundary(struct part *part)
{
    int c;
    int sawfinal = 0;

    if (part->boundary_seen < part->boundary_num-1) {
        /* We saw an enclosing boundary.  Signal end of multipart, but
         * don't skip over the boundary.
         */
        part->boundary_num--;
        return 1;
    }

    /* Deal with EOF on input stream */
    if (part->cnt == 0) return 1;

    /* Skip over delimiter, reset the "saw boundary" state */
    part->ptr += part->boundary_length[part->boundary_seen] + 3;
    part->cnt -= part->boundary_length[part->boundary_seen] + 3;
    part->boundary_seen = part->boundary_num;
    
    /* Check for two dashes, which indicate a final delimiter */
    c = part_getc(part);
    if (c == '-') {
        c = part_getc(part);
        if (c == '-') {
            sawfinal = 1;
            part->boundary_num--;
        }
    }

    /* Eat rest of the boundary line */
    while (c != '\n' && c != EOF) {
        c = part_getc(part);
    }
        
    return sawfinal;
}    

            
/*
 * Return nonzero and set the saw-boundary state iff 'part'
 * is positioned at a boundary.
 */
static int
pendingboundary(struct part *part)
{
    int bufleft;
    int i;

    /* Fill buffer if we don't have enough to do our look ahead */
    if (part->cnt < 3 ||
        (part->cnt < PART_MAX_BOUNDARY_LEN+3 && part->ptr[1] == '-' &&
         part->ptr[2] == '-')) {
        
        bufleft = part->buf_alloc - part->cnt - (part->ptr - part->buf);

        /* If not enough room, move everything to beginning of buffer */
        if (part->ptr!=part->buf && bufleft + part->cnt < PART_MAX_BOUNDARY_LEN+3) {
            for (i = 0; i < part->cnt; i++) {
                part->buf[i] = part->ptr[i];
            }
            part->ptr = part->buf;
            bufleft = part->buf_alloc - part->cnt;
        }

        /* Read in more data */
        part->cnt += fread(part->ptr+part->cnt, 1, bufleft, part->infile);
    }

    /* If no "--", it's not a boundary */
    if (part->cnt < 3 || part->ptr[1] != '-' || part->ptr[2] != '-') {
        return 0;
    }

    for (i = 0; i < part->boundary_num; i++) {
        if (part->cnt - 3 >= part->boundary_length[i] &&
            !strncmp((char *)part->ptr+3, part->boundary[i],
                     part->boundary_length[i])) {
            break;
        }
    }

    if (i == part->boundary_num) return 0;

    /* Saw boundary, index 'i' */ 
    part->boundary_seen = i;
    return 1;
}
1	jmc	1.1	/*
2			* Read MIME body-part, stopping on boundaries.
3			*/
4			/* (C) Copyright 1994 by Carnegie Mellon University
5			* All Rights Reserved.
6			*
7			* Permission to use, copy, modify, distribute, and sell this software
8			* and its documentation for any purpose is hereby granted without
9			* fee, provided that the above copyright notice appear in all copies
10			* and that both that copyright notice and this permission notice
11			* appear in supporting documentation, and that the name of Carnegie
12			* Mellon University not be used in advertising or publicity
13			* pertaining to distribution of the software without specific,
14			* written prior permission. Carnegie Mellon University makes no
15			* representations about the suitability of this software for any
16			* purpose. It is provided "as is" without express or implied
17			* warranty.
18			*
19			* CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
20			* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
21			* AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
22			* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
23			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
24			* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
25			* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
26			* SOFTWARE.
27			*/
28
29			#include <stdio.h>
30			#include <stdlib.h>
31			#include <string.h>
32
33			#include "part.h"
34			#include "xmalloc.h"
35
36			#define BUFSIZE 1024 /* must be > PART_MAX_BOUNDARY_LEN */
37			#define GROWBOUNDARY 20
38
39			static int pendingboundary(struct part *part);
40
41			/*
42			* Create, initialize, and return a new struct part pointer
43			* for the input file 'infile'.
44			*/
45			struct part part_init(FILE infile)
46			{
47			static struct part zeropart;
48			struct part *newpart;
49
50			newpart = (struct part *)xmalloc(sizeof(struct part));
51			*newpart = zeropart;
52			newpart->infile = infile;
53			newpart->buf = (unsigned char *)xmalloc(BUFSIZE);
54			newpart->buf_alloc = BUFSIZE;
55
56			return newpart;
57			}
58
59			/*
60			* Close and free 'part'.
61			*/
62			void part_close(struct part *part)
63			{
64			fclose(part->infile);
65			if (part->buf) free(part->buf);
66			if (part->boundary) free(part->boundary);
67			}
68
69			/*
70			* Return the multipart depth of 'part'. Top-level is '0'.
71			*/
72			int
73			part_depth(struct part *part)
74			{
75			return part->boundary_num;
76			}
77
78			/*
79			* Add to 'part' the multipart boundary 'boundary'.
80			*/
81			void part_addboundary(struct part part, char boundary)
82			{
83			/* Grow boundary array if necessary */
84			if (part->boundary_num == part->boundary_alloc) {
85			part->boundary_alloc += GROWBOUNDARY;
86			part->boundary = (char (*)[PART_MAX_BOUNDARY_LEN+1])
87			xrealloc((char *)part->boundary,
88			part->boundary_alloc * (PART_MAX_BOUNDARY_LEN+1));
89			part->boundary_length = (int *)
90			xrealloc((char *)part->boundary_length,
91			part->boundary_alloc * sizeof(int));
92			}
93
94			strncpy(part->boundary[part->boundary_num], boundary,
95			PART_MAX_BOUNDARY_LEN);
96			part->boundary[part->boundary_num][PART_MAX_BOUNDARY_LEN] = '\0';
97			part->boundary_length[part->boundary_num] =
98			strlen(part->boundary[part->boundary_num]);
99			part->boundary_num++;
100			if (part->boundary_seen+1 == part->boundary_num) {
101			part->boundary_seen++;
102			}
103			}
104
105			/*
106			* Private function that is only called from the part_getc() macro.
107			*
108			* Fills the input buffer for 'part' if necessary. Returns the next
109			* input character or EOF if at a boundary or end of file.
110			*/
111			int
112			part_fill(struct part *part)
113			{
114			/* part_getc() decremented this before calling us, put it back */
115			part->cnt++;
116
117			/* Return EOF if we saw a boundary */
118			if (part->boundary_seen < part->boundary_num) return EOF;
119
120			/* Fill buffer if it is empty */
121			if (part->cnt == 0) {
122			part->ptr = part->buf;
123			part->cnt = fread(part->buf, 1, part->buf_alloc, part->infile);
124			if (part->cnt == 0) {
125			part->boundary_seen = 0;
126			return EOF;
127			}
128			}
129
130			/* If there is a newline, see if it is followed by a boundary */
131			if (part->ptr[0] == '\n' && pendingboundary(part)) {
132			return EOF;
133			}
134
135			part->cnt--;
136			return *part->ptr++;
137			}
138
139			/*
140			* Read a line into the array 's', of size 'n', from 'part'.
141			* Reads until 'n'-1 characters are read, a newline is read, or
142			* an EOF is encountered. The array is then nul-terminated and returned.
143			* If the first character read is an EOF, then a null pointer is instead
144			* returned.
145			*/
146			char *
147			part_gets(char s, int n, struct part part)
148			{
149			int c;
150			char *p = s;
151
152			if (n == 0) return 0;
153			n--;
154			while (n-- && (c = part_getc(part)) != EOF) {
155			*p++ = c;
156			if (c == '\n') break;
157			}
158			if (p == s) return 0;
159			*p++ = '\0';
160			return s;
161			}
162
163			/*
164			* Push back the string 's' into the input buffer of 'part'.
165			* Leaves room in the input buffer to push back an additional single
166			* character using the prot_ungetc() macro.
167			*/
168			void part_ungets(char s, struct part part)
169			{
170			int len = strlen(s);
171			int i;
172
173			/* Grow buffer if necessary */
174			if (part->cnt + len + 1 > part->buf_alloc) {
175			i = part->ptr - part->buf;
176			part->buf_alloc = part->cnt + len + 1;
177			part->buf = (unsigned char *)
178			xrealloc((char *)part->buf, part->buf_alloc);
179			part->ptr = part->buf + i;
180			}
181
182			/* Move current data down to make room for new data if necessary */
183			if (len + 1 > part->ptr - part->buf) {
184			for (i = part->cnt-1; i >= 0; i--) {
185			part->buf[len+1+i] = part->ptr[i];
186			}
187			part->ptr = part->buf + len + 1;
188			}
189
190			/* Copy in the new data */
191			part->ptr -= len;
192			part->cnt += len;
193			for (i = 0; i < len; i++) {
194			part->ptr[i] = s[i];
195			}
196			}
197
198			/*
199			* Reset the saw-boundary state of 'part' and set up to read next
200			* body-part Returns nonzero iff the pending boundary was a final
201			* boundary of the current multipart.
202			*/
203			int
204			part_readboundary(struct part *part)
205			{
206			int c;
207			int sawfinal = 0;
208
209			if (part->boundary_seen < part->boundary_num-1) {
210			/* We saw an enclosing boundary. Signal end of multipart, but
211			* don't skip over the boundary.
212			*/
213			part->boundary_num--;
214			return 1;
215			}
216
217			/* Deal with EOF on input stream */
218			if (part->cnt == 0) return 1;
219
220			/* Skip over delimiter, reset the "saw boundary" state */
221			part->ptr += part->boundary_length[part->boundary_seen] + 3;
222			part->cnt -= part->boundary_length[part->boundary_seen] + 3;
223			part->boundary_seen = part->boundary_num;
224
225			/* Check for two dashes, which indicate a final delimiter */
226			c = part_getc(part);
227			if (c == '-') {
228			c = part_getc(part);
229			if (c == '-') {
230			sawfinal = 1;
231			part->boundary_num--;
232			}
233			}
234
235			/* Eat rest of the boundary line */
236			while (c != '\n' && c != EOF) {
237			c = part_getc(part);
238			}
239
240			return sawfinal;
241			}
242
243
244			/*
245			* Return nonzero and set the saw-boundary state iff 'part'
246			* is positioned at a boundary.
247			*/
248			static int
249			pendingboundary(struct part *part)
250			{
251			int bufleft;
252			int i;
253
254			/* Fill buffer if we don't have enough to do our look ahead */
255			if (part->cnt < 3 \|\|
256			(part->cnt < PART_MAX_BOUNDARY_LEN+3 && part->ptr[1] == '-' &&
257			part->ptr[2] == '-')) {
258
259			bufleft = part->buf_alloc - part->cnt - (part->ptr - part->buf);
260
261			/* If not enough room, move everything to beginning of buffer */
262			if (part->ptr!=part->buf && bufleft + part->cnt < PART_MAX_BOUNDARY_LEN+3) {
263			for (i = 0; i < part->cnt; i++) {
264			part->buf[i] = part->ptr[i];
265			}
266			part->ptr = part->buf;
267			bufleft = part->buf_alloc - part->cnt;
268			}
269
270			/* Read in more data */
271			part->cnt += fread(part->ptr+part->cnt, 1, bufleft, part->infile);
272			}
273
274			/* If no "--", it's not a boundary */
275			if (part->cnt < 3 \|\| part->ptr[1] != '-' \|\| part->ptr[2] != '-') {
276			return 0;
277			}
278
279			for (i = 0; i < part->boundary_num; i++) {
280			if (part->cnt - 3 >= part->boundary_length[i] &&
281			!strncmp((char *)part->ptr+3, part->boundary[i],
282			part->boundary_length[i])) {
283			break;
284			}
285			}
286
287			if (i == part->boundary_num) return 0;
288
289			/* Saw boundary, index 'i' */
290			part->boundary_seen = i;
291			return 1;
292			}