tools/mpack-1.6/macos.c

/* macos.c -- operating system dependant mpack code for the Macintosh
 */
/* (C) Copyright 1993-1995 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 <string.h>
#include <errno.h>
#include "common.h"
#include "macnapp.h"
#include "macmpack.h"

extern char *malloc(), *realloc();

char copy_buf[COPY_BUFSIZE];

char *xmalloc(unsigned size)
{
    char *ret;

    if (ret = malloc((unsigned) size))
      return ret;

    yell("Not enough memory available.");
    maccleanup();
    exit(1);
}

char *xrealloc (char *ptr, unsigned size)
{
    char *ret;

    /* xrealloc (NULL, size) behaves like xmalloc (size), as in ANSI C */
    if (ret = !ptr ? malloc ((unsigned) size) : realloc (ptr, (unsigned) size))
      return ret;

    yell("Not enough memory available");
    maccleanup();
    exit(1);
}

char *strsave(char *str)
{
    char *p = xmalloc(strlen(str)+1);
    strcpy(p, str);
    return p;
}

/* save output filename buffer */
static char *output_fname = NULL;
static short applefile_flag = 0;
static FSSpec fspec;

/* rename or copy a file to a new location
 */
static void rename_or_copy(srcfname, dstfname, dstvol, dirid)
        char *srcfname;
        PCstr *dstfname;
        short dstvol;
        long dirid;
{
        PCstr tstr[257];
        short srefnum, drefnum;
        long count;
        WDPBRec wdpb;
        HParamBlockRec hpb;
        CMovePBRec cpb;
        
        wdpb.ioNamePtr = P(tstr);
        if (PBHGetVol(&wdpb, FALSE) != noErr) return;
        CtoPCstrcpy(tstr, srcfname);
        if (HOpen(0, 0, P(tstr), fsRdPerm, &srefnum) != noErr) return;
        if (GetEOF(srefnum, &count) == noErr && !count) {
                FSClose(srefnum);
                return;
        }
        if (wdpb.ioWDVRefNum == dstvol) {
                /* files on same drive -- do a rename/move */
                FSClose(srefnum);
                hpb.fileParam.ioNamePtr = P(tstr);
                hpb.fileParam.ioVRefNum = 0;
                hpb.ioParam.ioMisc = (Ptr) P(dstfname);
                hpb.fileParam.ioDirID = 0;
                if (PBHRenameSync(&hpb) == noErr && wdpb.ioWDDirID != dirid) {
                        cpb.ioNamePtr = P(dstfname);
                        cpb.ioVRefNum = 0;
                        cpb.ioNewName = NULL;
                        cpb.ioNewDirID = dirid;
                        cpb.ioDirID = 0;
                        PBCatMoveSync(&cpb);
                }
        } else {
                /* files on different drive -- do a copy */
                if (HCreate(dstvol, dirid, P(dstfname), _fcreator, _ftype) != noErr) {
                        FSClose(srefnum);
                        return;
                }
                if (HOpen(dstvol, dirid, P(dstfname), fsWrPerm, &drefnum) != noErr) {
                        FSClose(srefnum);
                        HDelete(dstvol, dirid, P(dstfname));
                        return;
                }
                count = sizeof (copy_buf);
                while (FSRead(srefnum, &count, (Ptr) copy_buf) != noErr && count > 0) {
                        FSWrite(drefnum, &count, (Ptr) copy_buf);
                        count = sizeof (copy_buf);
                }
                FSClose(srefnum);
                FSClose(drefnum);
        }
}

/* Generate a message-id */
char *os_genid()
{
    char *result;
    long tick;
    unsigned long time;

        tick = TickCount();
    result = malloc(64);
    GetDateTime(&time);
    HLock((Handle) mpack_prefs);
    sprintf(result, "%lu.%lu@%s", tick, time, (*mpack_prefs)->internet_host);
    HUnlock((Handle) mpack_prefs);
    
    /* make sure tick count is bumped before we return... */
    while (tick == TickCount());
    
    return (result);
}

/* Create and return directory for a message-id
 */
char *os_idtodir(id)
char *id;
{
        static PCstr buf[257];
        PCstr idbuf[257];
        char *fname;
    short uqid;
    OSErr err;
    long dirID;
    Handle h;
    ResType type = 'IDna';

        /* prepare filename */
        PtoPCstrcpy(buf, (char *) P(pfolder->prefs));
        fname = C(buf) + PCstrlen(buf);
        
        /* is there a mapping for the id? */
        CtoPCstrcpy(idbuf, id);
        h = GetNamedResource(type, P(idbuf));
        
        /* no mapping -- create one */
        if (!h) {
                while ((uqid = UniqueID(type)) < 128);
                h = NewHandle(sizeof (short));
                if (h) (**(short **)h) = uqid;
                AddResource(h, type, uqid, P(idbuf));
                if ((err = ResError()) != noErr) {
                        return (NULL);
                }
        } else {
                uqid = ** (short **) h;
        }
        
        /* set directory name & create it */
        sprintf(fname, "%d:", uqid);
        SetPlen(buf);
        err = DirCreate(pfolder->fspec.vRefNum, 0, P(buf), &dirID);
        if (err != noErr && err != dupFNErr) {
                RmveResource(h);
                DisposHandle(h);
                h = NULL;
        }
        
        return (h ? C(buf) : NULL);
}

/*
 * We are done with the directory returned by os_idtodir()
 * Remove it
 */
os_donewithdir(dir)
char *dir;
{
        PCstr buf[257];
        short uqid;
        char *fname;
        Handle h;
        
        CtoPCstrcpy(buf, dir);
        HDelete(0, 0, P(buf));
        fname = strrchr(C(buf), ':');
        while (fname > C(buf) && *--fname != ':');
        if (fname > C(buf)) {
                uqid = atoi(fname + 1);
                h = GetResource('IDna', uqid);
                if (h) {
                        RmveResource(h);
                        DisposHandle(h);
                }
        }
}

/* rename the description file
 */
void renameDescFile(char *fname, short vRefNum, long dirid)
{
        PCstr tstr[65];
        char *p;

    MapTypeCreator("text/plain", 0);

        /* save description file */
        CtoPCstrcpy(tstr, fname);
    if (p = strrchr(C(tstr), '.')) *p = '\0';
    strcat(C(tstr), ".desc");
    SetPlen(tstr);
    rename_or_copy(TEMPFILENAME, tstr, vRefNum, dirid);
    (void) remove(TEMPFILENAME);
}

FILE *os_createnewfile(fname) 
char *fname;
{
    return fopen(fname, "w");
}

/*
 * Create a new file, with suggested filename "fname".
 * "fname" may have come from an insecure source, so clean it up first.
 * It may also be null.
 * "contentType" is passed in for use by systems that have typed filesystems.
 * "flags" contains a bit pattern describing attributes of the new file.
 */
FILE *os_newtypedfile(fname, contentType, flags, contentParams)
char *fname;
char *contentType;
int flags;
params *contentParams;
{
    char *p;
    int applefile;
    FILE *outfile = 0, *tmpf;
    StandardFileReply reply;
    PCstr tstr[257];

    if (!fname) fname = "";
    
    /* Translate ':' to underscore */
    for (p=fname; *p; p++) {
        if (*p == ':' || !isprint(*p)) *p = '_';
    }
    
    /* chop filename to length */
    if (strlen(fname) > 31) {
                fname += strlen(fname) - 31;
    }
    
    /* remove leading periods, to protect from ".SONY" attacks */
    while (*fname == '.') ++fname;

        /* get filename from user */
        applefile = !strcmp(contentType, "application/applefile");
        if (!applefile || !(flags & FILE_INAPPLEDOUBLE)) {
                sprintf(C(tstr), "Found file: %s (%s)",
                        fname[0] ? fname : "Untitled", contentType);
                SetPlen(tstr);
                stattext(P(tstr), 1);
        }
        if (!applefile && (!applefile_flag || !(flags & FILE_INAPPLEDOUBLE))) {
            SetCursor(&arrow);
            CtoPstr(fname);
            NAputFile("\pSave decoded file as:",
                fname[0] ? (unsigned char *) fname : "\pUntitled", &reply);
            PtoCstr((unsigned char *) fname);
            SetCursor(&watch);
            statrefresh();
            if (!reply.sfGood) {
                didchat = -1;
                return (NULL);
            }
        }

        /* set the type */
        MapTypeCreator(contentType, 0);

        /* save file */
        tmpf = tmpfile();
        if (applefile) {
                outfile = tmpf;
                tmpf = NULL;
        } else if ((flags & FILE_INAPPLEDOUBLE) && applefile_flag) {
                outfile = Macopen(tmpf, fspec.name, fspec.vRefNum, fspec.parID,
                        flags & FILE_BINARY, 0, fsWrPerm);
        } else {
                HCreate(reply.sfFile.vRefNum, reply.sfFile.parID, reply.sfFile.name, _fcreator, _ftype);
            outfile = Macopen(tmpf, reply.sfFile.name, reply.sfFile.vRefNum, reply.sfFile.parID,
                flags & FILE_BINARY, 0, fsWrPerm);
        }
        applefile_flag = applefile;
        if (tmpf) fclose(tmpf);
        PtoCstr(reply.sfFile.name);
        fname = (char *) reply.sfFile.name;
    if (!outfile) {
        sprintf(C(tstr), "Couldn't open file %s", fname);
        warn(C(tstr));
        return (0);
    }
        
    if (output_fname) free(output_fname);
    output_fname = strsave(fname);
    
    renameDescFile(fname, reply.sfFile.vRefNum, reply.sfFile.parID);

    return outfile;
}

/*
 * Close a file opened by os_newTypedFile()
 */
os_closetypedfile(outfile)
FILE *outfile;
{
        char buf[128];
        
        if (applefile_flag) {
                rewind(outfile);
                if (decode_applefile(outfile, &fspec) < 0) {
                        sprintf(buf, "Failed to decode file %s", output_fname);
                        if (didchat >= 0) warn(buf);
                        applefile_flag = 0;
                }
        }

        /* close file */
    fclose(outfile);
}

/*
 * Warn user that the MD5 digest of the last file created by os_newtypedfile()
 * did not match that supplied in the Content-MD5: header.
 */
os_warnMD5mismatch()
{
    char *warning;

    warning = xmalloc(strlen(output_fname) + 100);
    sprintf(warning, "%s was corrupted in transit",
            output_fname);
    warn(warning);
    free(warning);
}

/* bring up an error dialog for a file error
 */
void os_perror(char *str)
{
        extern int errno;
        char *err = strerror(errno), *scan;
        char msg[256];
        short maxflen;
        
        maxflen = 255 - (strlen(err) + 2);
        if (strlen(str) > maxflen) {
                str += strlen(str) - maxflen;
                for (scan = str; *scan && *scan++ != ':';);
                if (*scan) str = scan;
        }
        sprintf(msg, "%s: %s", str, err);
        yell(msg);
}
1	edhill	1.1	/* macos.c -- operating system dependant mpack code for the Macintosh
2			*/
3			/* (C) Copyright 1993-1995 by Carnegie Mellon University
4			* All Rights Reserved.
5			*
6			* Permission to use, copy, modify, distribute, and sell this software
7			* and its documentation for any purpose is hereby granted without fee,
8			* provided that the above copyright notice appear in all copies and
9			* that both that copyright notice and this permission notice appear in
10			* supporting documentation, and that the name of Carnegie Mellon University
11			* not be used in advertising or publicity pertaining to distribution of the
12			* software without specific, written prior permission. Carnegie
13			* Mellon University makes no representations about the suitability of
14			* this software for any purpose. It is provided "as is" without
15			* express or implied 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 <string.h>
30			#include <errno.h>
31			#include "common.h"
32			#include "macnapp.h"
33			#include "macmpack.h"
34
35			extern char malloc(), realloc();
36
37			char copy_buf[COPY_BUFSIZE];
38
39			char *xmalloc(unsigned size)
40			{
41			char *ret;
42
43			if (ret = malloc((unsigned) size))
44			return ret;
45
46			yell("Not enough memory available.");
47			maccleanup();
48			exit(1);
49			}
50
51			char xrealloc (char ptr, unsigned size)
52			{
53			char *ret;
54
55			/* xrealloc (NULL, size) behaves like xmalloc (size), as in ANSI C */
56			if (ret = !ptr ? malloc ((unsigned) size) : realloc (ptr, (unsigned) size))
57			return ret;
58
59			yell("Not enough memory available");
60			maccleanup();
61			exit(1);
62			}
63
64			char strsave(char str)
65			{
66			char *p = xmalloc(strlen(str)+1);
67			strcpy(p, str);
68			return p;
69			}
70
71			/* save output filename buffer */
72			static char *output_fname = NULL;
73			static short applefile_flag = 0;
74			static FSSpec fspec;
75
76			/* rename or copy a file to a new location
77			*/
78			static void rename_or_copy(srcfname, dstfname, dstvol, dirid)
79			char *srcfname;
80			PCstr *dstfname;
81			short dstvol;
82			long dirid;
83			{
84			PCstr tstr[257];
85			short srefnum, drefnum;
86			long count;
87			WDPBRec wdpb;
88			HParamBlockRec hpb;
89			CMovePBRec cpb;
90
91			wdpb.ioNamePtr = P(tstr);
92			if (PBHGetVol(&wdpb, FALSE) != noErr) return;
93			CtoPCstrcpy(tstr, srcfname);
94			if (HOpen(0, 0, P(tstr), fsRdPerm, &srefnum) != noErr) return;
95			if (GetEOF(srefnum, &count) == noErr && !count) {
96			FSClose(srefnum);
97			return;
98			}
99			if (wdpb.ioWDVRefNum == dstvol) {
100			/* files on same drive -- do a rename/move */
101			FSClose(srefnum);
102			hpb.fileParam.ioNamePtr = P(tstr);
103			hpb.fileParam.ioVRefNum = 0;
104			hpb.ioParam.ioMisc = (Ptr) P(dstfname);
105			hpb.fileParam.ioDirID = 0;
106			if (PBHRenameSync(&hpb) == noErr && wdpb.ioWDDirID != dirid) {
107			cpb.ioNamePtr = P(dstfname);
108			cpb.ioVRefNum = 0;
109			cpb.ioNewName = NULL;
110			cpb.ioNewDirID = dirid;
111			cpb.ioDirID = 0;
112			PBCatMoveSync(&cpb);
113			}
114			} else {
115			/* files on different drive -- do a copy */
116			if (HCreate(dstvol, dirid, P(dstfname), _fcreator, _ftype) != noErr) {
117			FSClose(srefnum);
118			return;
119			}
120			if (HOpen(dstvol, dirid, P(dstfname), fsWrPerm, &drefnum) != noErr) {
121			FSClose(srefnum);
122			HDelete(dstvol, dirid, P(dstfname));
123			return;
124			}
125			count = sizeof (copy_buf);
126			while (FSRead(srefnum, &count, (Ptr) copy_buf) != noErr && count > 0) {
127			FSWrite(drefnum, &count, (Ptr) copy_buf);
128			count = sizeof (copy_buf);
129			}
130			FSClose(srefnum);
131			FSClose(drefnum);
132			}
133			}
134
135			/* Generate a message-id */
136			char *os_genid()
137			{
138			char *result;
139			long tick;
140			unsigned long time;
141
142			tick = TickCount();
143			result = malloc(64);
144			GetDateTime(&time);
145			HLock((Handle) mpack_prefs);
146			sprintf(result, "%lu.%lu@%s", tick, time, (*mpack_prefs)->internet_host);
147			HUnlock((Handle) mpack_prefs);
148
149			/* make sure tick count is bumped before we return... */
150			while (tick == TickCount());
151
152			return (result);
153			}
154
155			/* Create and return directory for a message-id
156			*/
157			char *os_idtodir(id)
158			char *id;
159			{
160			static PCstr buf[257];
161			PCstr idbuf[257];
162			char *fname;
163			short uqid;
164			OSErr err;
165			long dirID;
166			Handle h;
167			ResType type = 'IDna';
168
169			/* prepare filename */
170			PtoPCstrcpy(buf, (char *) P(pfolder->prefs));
171			fname = C(buf) + PCstrlen(buf);
172
173			/* is there a mapping for the id? */
174			CtoPCstrcpy(idbuf, id);
175			h = GetNamedResource(type, P(idbuf));
176
177			/* no mapping -- create one */
178			if (!h) {
179			while ((uqid = UniqueID(type)) < 128);
180			h = NewHandle(sizeof (short));
181			if (h) ((short )h) = uqid;
182			AddResource(h, type, uqid, P(idbuf));
183			if ((err = ResError()) != noErr) {
184			return (NULL);
185			}
186			} else {
187			uqid = (short ) h;
188			}
189
190			/* set directory name & create it */
191			sprintf(fname, "%d:", uqid);
192			SetPlen(buf);
193			err = DirCreate(pfolder->fspec.vRefNum, 0, P(buf), &dirID);
194			if (err != noErr && err != dupFNErr) {
195			RmveResource(h);
196			DisposHandle(h);
197			h = NULL;
198			}
199
200			return (h ? C(buf) : NULL);
201			}
202
203			/*
204			* We are done with the directory returned by os_idtodir()
205			* Remove it
206			*/
207			os_donewithdir(dir)
208			char *dir;
209			{
210			PCstr buf[257];
211			short uqid;
212			char *fname;
213			Handle h;
214
215			CtoPCstrcpy(buf, dir);
216			HDelete(0, 0, P(buf));
217			fname = strrchr(C(buf), ':');
218			while (fname > C(buf) && *--fname != ':');
219			if (fname > C(buf)) {
220			uqid = atoi(fname + 1);
221			h = GetResource('IDna', uqid);
222			if (h) {
223			RmveResource(h);
224			DisposHandle(h);
225			}
226			}
227			}
228
229			/* rename the description file
230			*/
231			void renameDescFile(char *fname, short vRefNum, long dirid)
232			{
233			PCstr tstr[65];
234			char *p;
235
236			MapTypeCreator("text/plain", 0);
237
238			/* save description file */
239			CtoPCstrcpy(tstr, fname);
240			if (p = strrchr(C(tstr), '.')) *p = '\0';
241			strcat(C(tstr), ".desc");
242			SetPlen(tstr);
243			rename_or_copy(TEMPFILENAME, tstr, vRefNum, dirid);
244			(void) remove(TEMPFILENAME);
245			}
246
247			FILE *os_createnewfile(fname)
248			char *fname;
249			{
250			return fopen(fname, "w");
251			}
252
253			/*
254			* Create a new file, with suggested filename "fname".
255			* "fname" may have come from an insecure source, so clean it up first.
256			* It may also be null.
257			* "contentType" is passed in for use by systems that have typed filesystems.
258			* "flags" contains a bit pattern describing attributes of the new file.
259			*/
260			FILE *os_newtypedfile(fname, contentType, flags, contentParams)
261			char *fname;
262			char *contentType;
263			int flags;
264			params *contentParams;
265			{
266			char *p;
267			int applefile;
268			FILE outfile = 0, tmpf;
269			StandardFileReply reply;
270			PCstr tstr[257];
271
272			if (!fname) fname = "";
273
274			/* Translate ':' to underscore */
275			for (p=fname; *p; p++) {
276			if (p == ':' \|\| !isprint(p)) *p = '_';
277			}
278
279			/* chop filename to length */
280			if (strlen(fname) > 31) {
281			fname += strlen(fname) - 31;
282			}
283
284			/* remove leading periods, to protect from ".SONY" attacks */
285			while (*fname == '.') ++fname;
286
287			/* get filename from user */
288			applefile = !strcmp(contentType, "application/applefile");
289			if (!applefile \|\| !(flags & FILE_INAPPLEDOUBLE)) {
290			sprintf(C(tstr), "Found file: %s (%s)",
291			fname[0] ? fname : "Untitled", contentType);
292			SetPlen(tstr);
293			stattext(P(tstr), 1);
294			}
295			if (!applefile && (!applefile_flag \|\| !(flags & FILE_INAPPLEDOUBLE))) {
296			SetCursor(&arrow);
297			CtoPstr(fname);
298			NAputFile("\pSave decoded file as:",
299			fname[0] ? (unsigned char *) fname : "\pUntitled", &reply);
300			PtoCstr((unsigned char *) fname);
301			SetCursor(&watch);
302			statrefresh();
303			if (!reply.sfGood) {
304			didchat = -1;
305			return (NULL);
306			}
307			}
308
309			/* set the type */
310			MapTypeCreator(contentType, 0);
311
312			/* save file */
313			tmpf = tmpfile();
314			if (applefile) {
315			outfile = tmpf;
316			tmpf = NULL;
317			} else if ((flags & FILE_INAPPLEDOUBLE) && applefile_flag) {
318			outfile = Macopen(tmpf, fspec.name, fspec.vRefNum, fspec.parID,
319			flags & FILE_BINARY, 0, fsWrPerm);
320			} else {
321			HCreate(reply.sfFile.vRefNum, reply.sfFile.parID, reply.sfFile.name, _fcreator, _ftype);
322			outfile = Macopen(tmpf, reply.sfFile.name, reply.sfFile.vRefNum, reply.sfFile.parID,
323			flags & FILE_BINARY, 0, fsWrPerm);
324			}
325			applefile_flag = applefile;
326			if (tmpf) fclose(tmpf);
327			PtoCstr(reply.sfFile.name);
328			fname = (char *) reply.sfFile.name;
329			if (!outfile) {
330			sprintf(C(tstr), "Couldn't open file %s", fname);
331			warn(C(tstr));
332			return (0);
333			}
334
335			if (output_fname) free(output_fname);
336			output_fname = strsave(fname);
337
338			renameDescFile(fname, reply.sfFile.vRefNum, reply.sfFile.parID);
339
340			return outfile;
341			}
342
343			/*
344			* Close a file opened by os_newTypedFile()
345			*/
346			os_closetypedfile(outfile)
347			FILE *outfile;
348			{
349			char buf[128];
350
351			if (applefile_flag) {
352			rewind(outfile);
353			if (decode_applefile(outfile, &fspec) < 0) {
354			sprintf(buf, "Failed to decode file %s", output_fname);
355			if (didchat >= 0) warn(buf);
356			applefile_flag = 0;
357			}
358			}
359
360			/* close file */
361			fclose(outfile);
362			}
363
364			/*
365			* Warn user that the MD5 digest of the last file created by os_newtypedfile()
366			* did not match that supplied in the Content-MD5: header.
367			*/
368			os_warnMD5mismatch()
369			{
370			char *warning;
371
372			warning = xmalloc(strlen(output_fname) + 100);
373			sprintf(warning, "%s was corrupted in transit",
374			output_fname);
375			warn(warning);
376			free(warning);
377			}
378
379			/* bring up an error dialog for a file error
380			*/
381			void os_perror(char *str)
382			{
383			extern int errno;
384			char err = strerror(errno), scan;
385			char msg[256];
386			short maxflen;
387
388			maxflen = 255 - (strlen(err) + 2);
389			if (strlen(str) > maxflen) {
390			str += strlen(str) - maxflen;
391			for (scan = str; scan && scan++ != ':';);
392			if (*scan) str = scan;
393			}
394			sprintf(msg, "%s: %s", str, err);
395			yell(msg);
396			}