tools/mpack-1.6/unixos.c

/* (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 <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <time.h>
#include <netdb.h>
#include <fcntl.h>
#include <unistd.h>
#include "xmalloc.h"
#include "common.h"
#include "part.h"

extern void warn(char *s);

#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 64
#endif

#ifndef errno
extern int errno;
#endif

int overwrite_files = 0;
int didchat;

/* The name of the file we're writing */
static char *output_fname = 0;

/* Characters that shouldn't be in filenames */
#define BADCHARS "!$&*()|\'\";<>[]{}?/`\\ \t"

/* Generate a message-id */
char *os_genid(void)
{
    static int pid = 0;
    static time_t curtime;
    static char hostname[MAXHOSTNAMELEN+1];
    char *result;
    struct hostent *hp;
    

    if (pid == 0) {
        pid = getpid();
        time(&curtime);
        gethostname(hostname, sizeof(hostname));

        /* If we don't have a FQDN, try canonicalizing with gethostbyname */
        if (!strchr(hostname, '.')) {
            hp = gethostbyname(hostname);
            if (hp) {
                strcpy(hostname, hp->h_name);
            }
        }
    }

    result = malloc(25+strlen(hostname));
    sprintf(result, "%d.%lu@%s", pid, (unsigned long) curtime++, hostname);
    return result;
}

/* Create and return directory for a message-id */
char *os_idtodir(char *id)
{
    static char buf[4096];
    char *p;

    if (getenv("TMPDIR")) {
        strcpy(buf, getenv("TMPDIR"));
    }
    else {
        strcpy(buf, "/var/tmp");
    }
    strcat(buf, "/m-prts-");
    p = getenv("USER");
    if (!p) p = getenv("LOGNAME");
    if (!p) p = "x";
    strcat(buf, p);
    
    (void)mkdir(buf, 0700);

    p = buf + strlen(buf);
    *p++ = '/';
    while (*id && p < buf+sizeof(buf)-10 ) {
        if (isprint(*id) && !strchr(BADCHARS, *id)) *p++ = *id;
        id++;
    }
    *p = '\0';
    if (mkdir(buf, 0700) == -1 && errno != EEXIST) {
        perror(buf);
        return 0;
    }
    *p++ = '/';
    *p = '\0';
    return buf;
}

/*
 * We are done with the directory returned by os_idtodir()
 * Remove it
 */
void os_donewithdir(char *dir)
{
    char *p;

    /* Remove trailing slash */
    p = dir + strlen(dir) - 1;
    *p = '\0';

    rmdir(dir);
}

FILE *os_createnewfile(char *fname)
{
    int fd;
    FILE *ret;
     
#ifdef O_EXCL
    struct stat statbuf;

    if ((stat(fname, &statbuf) == 0) && (S_ISCHR(statbuf.st_mode))) {
        fd=open(fname, O_RDWR);
    }
    else {
        fd=open(fname, O_RDWR|O_CREAT|O_EXCL, 0644);
    }
#else
    fd=open(fname, O_RDWR|O_CREAT|O_TRUNC, 0644);
#endif

    if (fd == -1)
        return NULL;
     
    ret=fdopen(fd, "w");
    return ret;
}

     
/*
 * 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(char *fname, char *contentType, int flags, params contentParams)
{
    char *p;
    static int filesuffix=0;
    char buf[128], *descfname=0;
    FILE *outfile = 0;

    if (!fname) fname = "";

    /* If absolute path name, chop to tail */
    if (*fname == '/') {
        p = strrchr(fname, '/');
        fname = p+1;
    }

    /* Get rid of leading ~ or ~/ */
    while (*fname == '~' || *fname == '/') fname++;

    while (!strncmp(fname, "../", 3)) fname += 3;
    
    /* Clean out bad characters, create directories along path */
    for (p=fname; *p; p++) {
        if (*p == '/') {
            if (!strncmp(p, "/../", 4)) {
                p[1] = p[2] = 'X';
            }
            *p = '\0';
            (void) mkdir(fname, 0777);
            *p = '/';
        }
        else if (!isprint(*p) || strchr(BADCHARS, *p)) *p = 'X';
    }

    if (!fname[0]) {
        do {
            if (outfile) fclose(outfile);
            sprintf(buf, "part%d", ++filesuffix);
        } while ((outfile = fopen(buf, "r")));
        fname = buf;
    }
    else if (!overwrite_files && (outfile = fopen(fname, "r"))) {
        do {
            fclose(outfile);
            sprintf(buf, "%s.%d", fname, ++filesuffix);
         
        } while ((outfile = fopen(buf, "r")));
        fname = buf;
    }

    if (overwrite_files)
         outfile = fopen(fname, "w");
    else
         outfile = os_createnewfile(fname);
    
    if (!outfile) {
        perror(fname);
    }

    if (output_fname) free(output_fname);
    output_fname = strsave(fname);

    if (strlen(fname) > sizeof(buf)-6) {
        descfname = xmalloc(strlen(fname)+6);
    }
    else {
        descfname = buf;
    }
    strcpy(descfname, fname);

    p = strchr(descfname, '/');
    if (!p) p = descfname;
    if ((p = strrchr(p, '.'))) *p = '\0';

    strcat(descfname, ".desc");
    (void) rename(TEMPFILENAME, descfname);
    if (descfname != buf) free(descfname);
    
    fprintf(stdout, "%s (%s)\n", output_fname, contentType);
    didchat = 1;

    return outfile;
}

/*
 * Close a file opened by os_newTypedFile()
 */
void os_closetypedfile(FILE *outfile)
{
    fclose(outfile);
}

/*
 * (Don't) Handle a BinHex'ed file
 */
int
os_binhex(struct part *inpart, int part, int nparts)
{
    return 1;
}

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

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

/*
 * Report an error (in errno) concerning a filename
 */
void os_perror(char *file)
{
    perror(file);
}
1	edhill	1.1	/* (C) Copyright 1993,1994 by Carnegie Mellon University
2			* All Rights Reserved.
3			*
4			* Permission to use, copy, modify, distribute, and sell this software
5			* and its documentation for any purpose is hereby granted without
6			* fee, provided that the above copyright notice appear in all copies
7			* and that both that copyright notice and this permission notice
8			* appear in supporting documentation, and that the name of Carnegie
9			* Mellon University not be used in advertising or publicity
10			* pertaining to distribution of the software without specific,
11			* written prior permission. Carnegie Mellon University makes no
12			* representations about the suitability of this software for any
13			* purpose. It is provided "as is" without express or implied
14			* warranty.
15			*
16			* CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
17			* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18			* AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
19			* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
20			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
21			* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
22			* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
23			* SOFTWARE.
24			*/
25			#include <stdio.h>
26	jmc	1.5	#include <stdlib.h>
27	edhill	1.1	#include <ctype.h>
28			#include <string.h>
29			#include <errno.h>
30			#include <sys/types.h>
31	jmc	1.5	#include <sys/stat.h>
32	edhill	1.1	#include <sys/param.h>
33	jmc	1.5	#include <time.h>
34	edhill	1.1	#include <netdb.h>
35			#include <fcntl.h>
36	jmc	1.5	#include <unistd.h>
37	edhill	1.1	#include "xmalloc.h"
38			#include "common.h"
39			#include "part.h"
40
41	jmc	1.5	extern void warn(char *s);
42
43	edhill	1.1	#ifndef MAXHOSTNAMELEN
44			#define MAXHOSTNAMELEN 64
45			#endif
46
47	jmc	1.5	#ifndef errno
48	edhill	1.1	extern int errno;
49	jmc	1.5	#endif
50	edhill	1.1
51			int overwrite_files = 0;
52			int didchat;
53
54			/* The name of the file we're writing */
55			static char *output_fname = 0;
56
57			/* Characters that shouldn't be in filenames */
58			#define BADCHARS "!$&*()\|\'\";<>[]{}?/`\\ \t"
59
60			/* Generate a message-id */
61			char *os_genid(void)
62			{
63			static int pid = 0;
64			static time_t curtime;
65			static char hostname[MAXHOSTNAMELEN+1];
66			char *result;
67			struct hostent *hp;
68
69
70			if (pid == 0) {
71			pid = getpid();
72			time(&curtime);
73			gethostname(hostname, sizeof(hostname));
74
75			/* If we don't have a FQDN, try canonicalizing with gethostbyname */
76			if (!strchr(hostname, '.')) {
77			hp = gethostbyname(hostname);
78			if (hp) {
79			strcpy(hostname, hp->h_name);
80			}
81			}
82			}
83
84	jmc	1.5	result = malloc(25+strlen(hostname));
85			sprintf(result, "%d.%lu@%s", pid, (unsigned long) curtime++, hostname);
86	edhill	1.1	return result;
87			}
88
89			/* Create and return directory for a message-id */
90			char os_idtodir(char id)
91			{
92			static char buf[4096];
93			char *p;
94
95			if (getenv("TMPDIR")) {
96			strcpy(buf, getenv("TMPDIR"));
97			}
98			else {
99	jmc	1.5	strcpy(buf, "/var/tmp");
100	edhill	1.1	}
101			strcat(buf, "/m-prts-");
102			p = getenv("USER");
103			if (!p) p = getenv("LOGNAME");
104			if (!p) p = "x";
105			strcat(buf, p);
106
107			(void)mkdir(buf, 0700);
108
109			p = buf + strlen(buf);
110			*p++ = '/';
111			while (*id && p < buf+sizeof(buf)-10 ) {
112			if (isprint(id) && !strchr(BADCHARS, id)) p++ = id;
113			id++;
114			}
115			*p = '\0';
116			if (mkdir(buf, 0700) == -1 && errno != EEXIST) {
117			perror(buf);
118			return 0;
119			}
120			*p++ = '/';
121			*p = '\0';
122			return buf;
123			}
124
125			/*
126			* We are done with the directory returned by os_idtodir()
127			* Remove it
128			*/
129			void os_donewithdir(char *dir)
130			{
131			char *p;
132
133			/* Remove trailing slash */
134			p = dir + strlen(dir) - 1;
135			*p = '\0';
136
137			rmdir(dir);
138			}
139
140			FILE os_createnewfile(char fname)
141			{
142			int fd;
143			FILE *ret;
144
145			#ifdef O_EXCL
146	jmc	1.5	struct stat statbuf;
147
148			if ((stat(fname, &statbuf) == 0) && (S_ISCHR(statbuf.st_mode))) {
149			fd=open(fname, O_RDWR);
150			}
151			else {
152			fd=open(fname, O_RDWR\|O_CREAT\|O_EXCL, 0644);
153			}
154	edhill	1.1	#else
155			fd=open(fname, O_RDWR\|O_CREAT\|O_TRUNC, 0644);
156			#endif
157
158			if (fd == -1)
159			return NULL;
160
161			ret=fdopen(fd, "w");
162			return ret;
163			}
164
165
166			/*
167			* Create a new file, with suggested filename "fname".
168			* "fname" may have come from an insecure source, so clean it up first.
169			* It may also be null.
170			* "contentType" is passed in for use by systems that have typed filesystems.
171			* "flags" contains a bit pattern describing attributes of the new file.
172			*/
173			FILE os_newtypedfile(char fname, char *contentType, int flags, params contentParams)
174			{
175			char *p;
176			static int filesuffix=0;
177			char buf[128], *descfname=0;
178			FILE *outfile = 0;
179
180			if (!fname) fname = "";
181
182			/* If absolute path name, chop to tail */
183			if (*fname == '/') {
184			p = strrchr(fname, '/');
185			fname = p+1;
186			}
187
188			/* Get rid of leading ~ or ~/ */
189			while (fname == '~' \|\| fname == '/') fname++;
190
191			while (!strncmp(fname, "../", 3)) fname += 3;
192
193			/* Clean out bad characters, create directories along path */
194			for (p=fname; *p; p++) {
195			if (*p == '/') {
196			if (!strncmp(p, "/../", 4)) {
197			p[1] = p[2] = 'X';
198			}
199			*p = '\0';
200			(void) mkdir(fname, 0777);
201			*p = '/';
202			}
203			else if (!isprint(p) \|\| strchr(BADCHARS, p)) *p = 'X';
204			}
205
206			if (!fname[0]) {
207			do {
208			if (outfile) fclose(outfile);
209			sprintf(buf, "part%d", ++filesuffix);
210	jmc	1.5	} while ((outfile = fopen(buf, "r")));
211	edhill	1.1	fname = buf;
212			}
213			else if (!overwrite_files && (outfile = fopen(fname, "r"))) {
214			do {
215			fclose(outfile);
216			sprintf(buf, "%s.%d", fname, ++filesuffix);
217
218	jmc	1.5	} while ((outfile = fopen(buf, "r")));
219	edhill	1.1	fname = buf;
220			}
221
222			if (overwrite_files)
223			outfile = fopen(fname, "w");
224			else
225			outfile = os_createnewfile(fname);
226
227			if (!outfile) {
228			perror(fname);
229			}
230
231			if (output_fname) free(output_fname);
232			output_fname = strsave(fname);
233
234			if (strlen(fname) > sizeof(buf)-6) {
235			descfname = xmalloc(strlen(fname)+6);
236			}
237			else {
238			descfname = buf;
239			}
240			strcpy(descfname, fname);
241
242			p = strchr(descfname, '/');
243			if (!p) p = descfname;
244	jmc	1.5	if ((p = strrchr(p, '.'))) *p = '\0';
245	edhill	1.1
246			strcat(descfname, ".desc");
247			(void) rename(TEMPFILENAME, descfname);
248			if (descfname != buf) free(descfname);
249
250			fprintf(stdout, "%s (%s)\n", output_fname, contentType);
251			didchat = 1;
252
253			return outfile;
254			}
255
256			/*
257			* Close a file opened by os_newTypedFile()
258			*/
259			void os_closetypedfile(FILE *outfile)
260			{
261			fclose(outfile);
262			}
263
264			/*
265			* (Don't) Handle a BinHex'ed file
266			*/
267			int
268			os_binhex(struct part *inpart, int part, int nparts)
269			{
270			return 1;
271			}
272
273			/*
274			* Warn user that the MD5 digest of the last file created by os_newtypedfile()
275			* did not match that supplied in the Content-MD5: header.
276			*/
277			void os_warnMD5mismatch(void)
278			{
279			char *warning;
280
281			warning = xmalloc(strlen(output_fname) + 100);
282			sprintf(warning, "%s was corrupted in transit",
283			output_fname);
284			warn(warning);
285			free(warning);
286			}
287
288			/*
289			* Report an error (in errno) concerning a filename
290			*/
291			void os_perror(char *file)
292			{
293			perror(file);
294			}