mpack_src/mpack-1.6-4/macbhex.c

/* macbhex.c -- simple binhex decoding routine */
/* (C) Copyright 1993,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 <ctype.h>
#include <memory.h>
#include "part.h"
#include "macnapp.h"
#include "macmpack.h"

/* from macos.c: */
extern void renameDescFile(char *, short, long);

char binhex_decode[256] = {
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
        13, 14, 15, 16, 17, 18, 19, -1, 20, 21, -1, -1, -1, -1, -1, -1,
        22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, -1,
        37, 38, 39, 40, 41, 42, 43, -1, 44, 45, 46, 47, -1, -1, -1, -1,
        48, 49, 50, 51, 52, 53, 54, -1, 55, 56, 57, 58, 59, 60, -1, -1,
        61, 62, 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
#define BHEXVAL(c) (binhex_decode[(unsigned char) c])

typedef union {
        unsigned char c[4];
        unsigned long val;
} longbuf;

typedef struct {
        OSType type, creator;
        unsigned short flags;
        long dlen, rlen;
} binhex_header;

#define STATE_START  0
#define STATE_FNAME  1
#define STATE_HEADER 2
#define STATE_HCRC   3
#define STATE_DFORK  4
#define STATE_DCRC   5
#define STATE_RFORK  6
#define STATE_RCRC   7
#define STATE_DONE   8
#define STATE_ERROR  9

typedef struct binhex_state {
        short state;                    /* current state */
        short part;                             /* current part number */
        unsigned short CRC;             /* cumulative CRC */
        unsigned short fileCRC; /* CRC value from file */
        longbuf octetbuf;               /* buffer for decoded 6-bit values */
        short octetin;                  /* current input position in octetbuf */
        short donepos;                  /* ending position in octetbuf */
        short inCRC;                    /* flag set when reading a CRC */
        long count;                             /* generic counter */
        FILE *outfile;                  /* output file */
        short marker;                   /* flag indicating maker */
        unsigned char rlebuf;   /* buffer for last run length encoding value */
        PCstr namebuf[65];              /* buffer for binhex filename */
        binhex_header head;             /* buffer for header */
        FSSpec fspec;                   /* output file */
} binhex_state;

/* global state */
static binhex_state bh;

/* process a binhex character
 */
static void binhex_process(struct part *inpart)
{
        unsigned short tmpcrc, cval;
        unsigned char ctmp, c = bh.rlebuf;
        StandardFileReply reply;
        FInfo finfo;
        char buf[256];
        
        /* do CRC */
        ctmp = bh.inCRC ? c : 0;
        cval = bh.CRC & 0xf000;
        tmpcrc = ((unsigned short) (bh.CRC << 4) | (ctmp >> 4))
                        ^ (cval | (cval >> 7) | (cval >> 12));
        cval = tmpcrc & 0xf000;
        bh.CRC = ((unsigned short) (tmpcrc << 4) | (ctmp & 0x0f))
                        ^ (cval | (cval >> 7) | (cval >> 12));

        /* handle state */
        switch (bh.state) {
                case STATE_START:
                        bh.state = STATE_FNAME;
                        bh.count = 1;
                        *bh.namebuf = (c & 63);
                        break;
                case STATE_FNAME:
                        bh.namebuf[bh.count] = c;
                        if (bh.count++ > *bh.namebuf) {
                                bh.state = STATE_HEADER;
                                bh.count = 0;
                        }
                        break;
                case STATE_HEADER:
                        ((char *)&bh.head)[bh.count] = c;
                        if (++bh.count == 18) {
                                bh.state = STATE_HCRC;
                                bh.inCRC = 1;
                                bh.count = 0;
                        }
                        break;
                case STATE_DFORK:
                case STATE_RFORK:
                        putc(c, bh.outfile);
                        if (--bh.count == 0) {
                                fclose(bh.outfile);
                                bh.outfile = NULL;
                                ++bh.state;
                                bh.inCRC = 1;
                        }
                        break;
                case STATE_HCRC:
                case STATE_DCRC:
                case STATE_RCRC:
                        if (!bh.count++) {
                                bh.fileCRC = (unsigned short) c << 8;
                        } else {
                                if ((bh.fileCRC | c) != bh.CRC) {
                                        if (bh.state > STATE_HCRC) {
                                                HDelete(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name);
                                                SetCursor(&arrow);
                                                yell("BinHex file corrupted in transit");
                                                SetCursor(&watch);
                                        }
                                        bh.state = STATE_ERROR;
                                        break;
                                }
                                bh.CRC = 0;
                                if (++bh.state == STATE_DONE) {
                                        finfo.fdType = bh.head.type;
                                        finfo.fdCreator = bh.head.creator;
                                        finfo.fdFlags = bh.head.flags & 0xf800;
                                        HSetFInfo(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name, &finfo);
                                        PtoCstr(bh.fspec.name);
                                        renameDescFile((char *)bh.fspec.name, bh.fspec.vRefNum, bh.fspec.parID);
                                        break;
                                }
                                bh.count = bh.head.rlen;
                                if (bh.state == STATE_DFORK) {
                                        /* prompt user */
                                        sprintf(buf, "Saving BinHex file %s", C(bh.namebuf));
                                        chat(buf);
                                        SetCursor(&arrow);
                                        NAputFile("\pSave decoded BinHex file as:", P(bh.namebuf), &reply);
                                        SetCursor(&watch);
                                        statrefresh();
                                        if (!reply.sfGood) {
                                                didchat = -1;
                                                bh.state = STATE_ERROR;
                                        } else {
                                                bh.fspec = reply.sfFile;
                                                HCreate(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name,
                                                        bh.head.creator, bh.head.type);
                                                bh.count = bh.head.dlen;
                                        }
                                }
                                if (bh.count) {
                                        bh.inCRC = 0;
                                        bh.outfile = Macopen(inpart->infile, bh.fspec.name, bh.fspec.vRefNum,
                                                bh.fspec.parID, 1, bh.state == STATE_DFORK ? 0 : 1, fsWrPerm);
                                        if (!bh.outfile) {
                                                bh.state = STATE_ERROR;
                                                HDelete(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name);
                                                SetCursor(&arrow);
                                                yell("Failed to open file for writing");
                                                SetCursor(&watch);
                                        }
                                } else {
                                        ++bh.state;
                                }
                        }
                        break;
        }
}

/*
 * decode a binhex file
 *  returns -1 on fatal error, 0 for continue, 1 for done
 */
int os_binhex(struct part *inpart, int part, int nparts)
{
        long val;
        int c;
        char *bptr;
        short octetpos;
        static char buf[1024];
        
        /* reset state */
        if (part == 1) {
                bh.state = STATE_START;
                bh.part = 0;
                bh.CRC = 0;
                bh.octetbuf.val = 0;
                bh.octetin = 26;
                bh.donepos = 3;
                bh.inCRC = 0;
                bh.outfile = NULL;
                bh.marker = 0;
        }
        if (++bh.part != part) bh.state = STATE_ERROR;
        
        /* do nothing on error/completion */
        if (!inpart) {
                if (bh.state < STATE_DONE) bh.state = STATE_ERROR;
        } else {
                /* skip blank lines */
                do {
                        if (part_gets(buf, sizeof (buf), inpart) == NULL) return (0);
                } while (*buf == '\n');
                bptr = buf;
                if (part == 1 && *bptr++ != ':') bh.state = STATE_ERROR;
                
                /* line reading loop */
                do {
                        /* check line for separator */
                        if (!strncmp(buf, "--- ", 4)) break;
                        buf[strlen(buf) - 1] = '\0';
                        
                        /* loop through line of binhex charaters */
                        while (bh.state < STATE_DONE) {
                                /* fill in octetbuf */
                                do {
                                        if ((val = BHEXVAL(*bptr++)) == -1) {
                                                if (bptr[-1]) {
                                                        --bh.donepos;
                                                        if (bh.octetin >= 14) --bh.donepos;
                                                        if (bh.octetin >= 20) --bh.donepos;
                                                }
                                                break;
                                        }
                                        bh.octetbuf.val |= val << bh.octetin;
                                } while ((bh.octetin -= 6) > 2);
                                if (!bptr[-1]) break;
                                
                                /* handle decoded characters -- run length encoding (rle) detection */
                                for (octetpos = 0; octetpos < bh.donepos; ++octetpos) {
                                        /* get character & handle rle */
                                        c = bh.octetbuf.c[octetpos];
                                        if (c == 0x90 && !bh.marker++) continue;
                                        if (bh.marker) {
                                                if (c == 0) {
                                                        bh.rlebuf = 0x90;
                                                        binhex_process(inpart);
                                                } else {
                                                        while (--c > 0) {
                                                                binhex_process(inpart);
                                                        }
                                                }
                                                bh.marker = 0;
                                        } else {
                                                bh.rlebuf = (unsigned char) c;
                                                binhex_process(inpart);
                                        }
                                        if (bh.state >= STATE_DONE) break;
                                }
                                if (bh.donepos < 3 && bh.state < STATE_DONE) bh.state = STATE_ERROR;
                                bh.octetin = 26;
                                bh.octetbuf.val = 0;
                        }
                } while (bh.state < STATE_DONE && part_gets(bptr = buf, sizeof (buf), inpart) != NULL);
        }
        
        /* error clean up */
        if (bh.state == STATE_ERROR && bh.outfile) {
                fclose(bh.outfile);
                bh.outfile = NULL;
                HDelete(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name);
        }
        
        return (bh.state == STATE_ERROR ? 1 : 0);
}
1	jmc	1.1	/* macbhex.c -- simple binhex decoding routine */
2			/* (C) Copyright 1993,1994 by Carnegie Mellon University
3			* All Rights Reserved.
4			*
5			* Permission to use, copy, modify, distribute, and sell this software
6			* and its documentation for any purpose is hereby granted without
7			* fee, provided that the above copyright notice appear in all copies
8			* and that both that copyright notice and this permission notice
9			* appear in supporting documentation, and that the name of Carnegie
10			* Mellon University not be used in advertising or publicity
11			* pertaining to distribution of the software without specific,
12			* written prior permission. Carnegie Mellon University makes no
13			* representations about the suitability of this software for any
14			* purpose. It is provided "as is" without express or implied
15			* warranty.
16			*
17			* CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
18			* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
19			* AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
20			* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
21			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
22			* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
23			* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
24			* SOFTWARE.
25			*/
26
27			#include <stdio.h>
28			#include <ctype.h>
29			#include <memory.h>
30			#include "part.h"
31			#include "macnapp.h"
32			#include "macmpack.h"
33
34			/* from macos.c: */
35			extern void renameDescFile(char *, short, long);
36
37			char binhex_decode[256] = {
38			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
39			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
40			-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1,
41			13, 14, 15, 16, 17, 18, 19, -1, 20, 21, -1, -1, -1, -1, -1, -1,
42			22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, -1,
43			37, 38, 39, 40, 41, 42, 43, -1, 44, 45, 46, 47, -1, -1, -1, -1,
44			48, 49, 50, 51, 52, 53, 54, -1, 55, 56, 57, 58, 59, 60, -1, -1,
45			61, 62, 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
46			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
47			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
48			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
49			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
50			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
51			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
52			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
53			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
54			};
55			#define BHEXVAL(c) (binhex_decode[(unsigned char) c])
56
57			typedef union {
58			unsigned char c[4];
59			unsigned long val;
60			} longbuf;
61
62			typedef struct {
63			OSType type, creator;
64			unsigned short flags;
65			long dlen, rlen;
66			} binhex_header;
67
68			#define STATE_START 0
69			#define STATE_FNAME 1
70			#define STATE_HEADER 2
71			#define STATE_HCRC 3
72			#define STATE_DFORK 4
73			#define STATE_DCRC 5
74			#define STATE_RFORK 6
75			#define STATE_RCRC 7
76			#define STATE_DONE 8
77			#define STATE_ERROR 9
78
79			typedef struct binhex_state {
80			short state; /* current state */
81			short part; /* current part number */
82			unsigned short CRC; /* cumulative CRC */
83			unsigned short fileCRC; /* CRC value from file */
84			longbuf octetbuf; /* buffer for decoded 6-bit values */
85			short octetin; /* current input position in octetbuf */
86			short donepos; /* ending position in octetbuf */
87			short inCRC; /* flag set when reading a CRC */
88			long count; /* generic counter */
89			FILE outfile; / output file */
90			short marker; /* flag indicating maker */
91			unsigned char rlebuf; /* buffer for last run length encoding value */
92			PCstr namebuf[65]; /* buffer for binhex filename */
93			binhex_header head; /* buffer for header */
94			FSSpec fspec; /* output file */
95			} binhex_state;
96
97			/* global state */
98			static binhex_state bh;
99
100			/* process a binhex character
101			*/
102			static void binhex_process(struct part *inpart)
103			{
104			unsigned short tmpcrc, cval;
105			unsigned char ctmp, c = bh.rlebuf;
106			StandardFileReply reply;
107			FInfo finfo;
108			char buf[256];
109
110			/* do CRC */
111			ctmp = bh.inCRC ? c : 0;
112			cval = bh.CRC & 0xf000;
113			tmpcrc = ((unsigned short) (bh.CRC << 4) \| (ctmp >> 4))
114			^ (cval \| (cval >> 7) \| (cval >> 12));
115			cval = tmpcrc & 0xf000;
116			bh.CRC = ((unsigned short) (tmpcrc << 4) \| (ctmp & 0x0f))
117			^ (cval \| (cval >> 7) \| (cval >> 12));
118
119			/* handle state */
120			switch (bh.state) {
121			case STATE_START:
122			bh.state = STATE_FNAME;
123			bh.count = 1;
124			*bh.namebuf = (c & 63);
125			break;
126			case STATE_FNAME:
127			bh.namebuf[bh.count] = c;
128			if (bh.count++ > *bh.namebuf) {
129			bh.state = STATE_HEADER;
130			bh.count = 0;
131			}
132			break;
133			case STATE_HEADER:
134			((char *)&bh.head)[bh.count] = c;
135			if (++bh.count == 18) {
136			bh.state = STATE_HCRC;
137			bh.inCRC = 1;
138			bh.count = 0;
139			}
140			break;
141			case STATE_DFORK:
142			case STATE_RFORK:
143			putc(c, bh.outfile);
144			if (--bh.count == 0) {
145			fclose(bh.outfile);
146			bh.outfile = NULL;
147			++bh.state;
148			bh.inCRC = 1;
149			}
150			break;
151			case STATE_HCRC:
152			case STATE_DCRC:
153			case STATE_RCRC:
154			if (!bh.count++) {
155			bh.fileCRC = (unsigned short) c << 8;
156			} else {
157			if ((bh.fileCRC \| c) != bh.CRC) {
158			if (bh.state > STATE_HCRC) {
159			HDelete(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name);
160			SetCursor(&arrow);
161			yell("BinHex file corrupted in transit");
162			SetCursor(&watch);
163			}
164			bh.state = STATE_ERROR;
165			break;
166			}
167			bh.CRC = 0;
168			if (++bh.state == STATE_DONE) {
169			finfo.fdType = bh.head.type;
170			finfo.fdCreator = bh.head.creator;
171			finfo.fdFlags = bh.head.flags & 0xf800;
172			HSetFInfo(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name, &finfo);
173			PtoCstr(bh.fspec.name);
174			renameDescFile((char *)bh.fspec.name, bh.fspec.vRefNum, bh.fspec.parID);
175			break;
176			}
177			bh.count = bh.head.rlen;
178			if (bh.state == STATE_DFORK) {
179			/* prompt user */
180			sprintf(buf, "Saving BinHex file %s", C(bh.namebuf));
181			chat(buf);
182			SetCursor(&arrow);
183			NAputFile("\pSave decoded BinHex file as:", P(bh.namebuf), &reply);
184			SetCursor(&watch);
185			statrefresh();
186			if (!reply.sfGood) {
187			didchat = -1;
188			bh.state = STATE_ERROR;
189			} else {
190			bh.fspec = reply.sfFile;
191			HCreate(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name,
192			bh.head.creator, bh.head.type);
193			bh.count = bh.head.dlen;
194			}
195			}
196			if (bh.count) {
197			bh.inCRC = 0;
198			bh.outfile = Macopen(inpart->infile, bh.fspec.name, bh.fspec.vRefNum,
199			bh.fspec.parID, 1, bh.state == STATE_DFORK ? 0 : 1, fsWrPerm);
200			if (!bh.outfile) {
201			bh.state = STATE_ERROR;
202			HDelete(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name);
203			SetCursor(&arrow);
204			yell("Failed to open file for writing");
205			SetCursor(&watch);
206			}
207			} else {
208			++bh.state;
209			}
210			}
211			break;
212			}
213			}
214
215			/*
216			* decode a binhex file
217			* returns -1 on fatal error, 0 for continue, 1 for done
218			*/
219			int os_binhex(struct part *inpart, int part, int nparts)
220			{
221			long val;
222			int c;
223			char *bptr;
224			short octetpos;
225			static char buf[1024];
226
227			/* reset state */
228			if (part == 1) {
229			bh.state = STATE_START;
230			bh.part = 0;
231			bh.CRC = 0;
232			bh.octetbuf.val = 0;
233			bh.octetin = 26;
234			bh.donepos = 3;
235			bh.inCRC = 0;
236			bh.outfile = NULL;
237			bh.marker = 0;
238			}
239			if (++bh.part != part) bh.state = STATE_ERROR;
240
241			/* do nothing on error/completion */
242			if (!inpart) {
243			if (bh.state < STATE_DONE) bh.state = STATE_ERROR;
244			} else {
245			/* skip blank lines */
246			do {
247			if (part_gets(buf, sizeof (buf), inpart) == NULL) return (0);
248			} while (*buf == '\n');
249			bptr = buf;
250			if (part == 1 && *bptr++ != ':') bh.state = STATE_ERROR;
251
252			/* line reading loop */
253			do {
254			/* check line for separator */
255			if (!strncmp(buf, "--- ", 4)) break;
256			buf[strlen(buf) - 1] = '\0';
257
258			/* loop through line of binhex charaters */
259			while (bh.state < STATE_DONE) {
260			/* fill in octetbuf */
261			do {
262			if ((val = BHEXVAL(*bptr++)) == -1) {
263			if (bptr[-1]) {
264			--bh.donepos;
265			if (bh.octetin >= 14) --bh.donepos;
266			if (bh.octetin >= 20) --bh.donepos;
267			}
268			break;
269			}
270			bh.octetbuf.val \|= val << bh.octetin;
271			} while ((bh.octetin -= 6) > 2);
272			if (!bptr[-1]) break;
273
274			/* handle decoded characters -- run length encoding (rle) detection */
275			for (octetpos = 0; octetpos < bh.donepos; ++octetpos) {
276			/* get character & handle rle */
277			c = bh.octetbuf.c[octetpos];
278			if (c == 0x90 && !bh.marker++) continue;
279			if (bh.marker) {
280			if (c == 0) {
281			bh.rlebuf = 0x90;
282			binhex_process(inpart);
283			} else {
284			while (--c > 0) {
285			binhex_process(inpart);
286			}
287			}
288			bh.marker = 0;
289			} else {
290			bh.rlebuf = (unsigned char) c;
291			binhex_process(inpart);
292			}
293			if (bh.state >= STATE_DONE) break;
294			}
295			if (bh.donepos < 3 && bh.state < STATE_DONE) bh.state = STATE_ERROR;
296			bh.octetin = 26;
297			bh.octetbuf.val = 0;
298			}
299			} while (bh.state < STATE_DONE && part_gets(bptr = buf, sizeof (buf), inpart) != NULL);
300			}
301
302			/* error clean up */
303			if (bh.state == STATE_ERROR && bh.outfile) {
304			fclose(bh.outfile);
305			bh.outfile = NULL;
306			HDelete(bh.fspec.vRefNum, bh.fspec.parID, bh.fspec.name);
307			}
308
309			return (bh.state == STATE_ERROR ? 1 : 0);
310			}