server/common/porting.C

/*
 * static char *rcsid_porting_c =
 *   "$Id: porting.C,v 1.2 2006-08-29 08:01:35 root Exp $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

/* This file contains various functions that are not really unique for
 * crossfire, but rather provides what should be standard functions 
 * for systems that do not have them.  In this way, most of the
 * nasty system dependent stuff is contained here, with the program
 * calling these functions.
 */


#ifdef WIN32 /* ---win32 exclude/include headers */
#include "process.h"
#define pid_t int  /* we include it non global, because there is a redefinition in python.h */
#else
#include <ctype.h>
#include <sys/stat.h>
#include <sys/wait.h>

#include <sys/param.h>
#include <stdio.h>

/* Need to pull in the HAVE_... values somehow */
/* win32 reminder: always put this in a ifndef win32 block */
#include <autoconf.h>
#endif


#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <stdarg.h>
/* Has to be after above includes so we don't redefine some values */
#include "global.h"

static unsigned int curtmp = 0;

/*****************************************************************************
 * File related functions
 ****************************************************************************/

/*
 * A replacement for the tempnam() function since it's not defined
 * at some unix variants.
 */

char *tempnam_local(const char *dir, const char *pfx)
{
    char *name;
    pid_t pid=getpid();

/* HURD does not have a hard limit, but we do */
#ifndef MAXPATHLEN
#define MAXPATHLEN 4096
#endif

    if (!(name = (char *) malloc(MAXPATHLEN)))
        return(NULL);

    if (!pfx)
        pfx = "cftmp.";

    /* This is a pretty simple method - put the pid as a hex digit and
     * just keep incrementing the last digit.  Check to see if the file
     * already exists - if so, we'll just keep looking - eventually we should
     * find one that is free.
     */
    if (dir!=NULL) {
        do {
#ifdef HAVE_SNPRINTF
            (void)snprintf(name, MAXPATHLEN, "%s/%s%hx.%d", dir, pfx, pid, curtmp);
#else
            (void)sprintf(name,"%s/%s%hx%d", dir, pfx, pid, curtmp);
#endif
            curtmp++;
        } while (access(name, F_OK)!=-1);
        return(name);
    }
  return(NULL);
}


/* This function removes everything in the directory. */
void remove_directory(const char *path)
{
    DIR *dirp;
    char buf[MAX_BUF];
    struct stat statbuf;
    int status;

    if ((dirp=opendir(path))!=NULL) {
        struct dirent *de;

        for (de=readdir(dirp); de; de = readdir(dirp)) {
            /* Don't remove '.' or '..'  In  theory we should do a better 
             * check for .., but the directories we are removing are fairly
             * limited and should not have dot files in them.
             */
            if (de->d_name[0] == '.') continue;

            /* Linux actually has a type field in the dirent structure,
             * but that is not portable - stat should be portable
             */
            status=stat(de->d_name, &statbuf);
            if ((status!=-1) && (S_ISDIR(statbuf.st_mode))) {
                sprintf(buf,"%s/%s", path, de->d_name);
                remove_directory(buf);
                continue;
            }
            sprintf(buf,"%s/%s", path, de->d_name);
            if (unlink(buf)) {
                LOG(llevError,"Unable to remove directory %s\n", path);
            }
        }
        closedir(dirp);
    }
    if (rmdir(path)) {
        LOG(llevError,"Unable to remove directory %s\n", path);
    }
}

#if defined(sgi)

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

#define popen fixed_popen

FILE *popen_local(const char *command, const char *type)
{
        int             fd[2];
        int             pd;
        FILE    *ret;
        if (!strcmp(type,"r"))
        {
                pd=STDOUT_FILENO;
        }
        else if (!strcmp(type,"w"))
        {
                pd=STDIN_FILENO;
        }
        else
        {
                return NULL;
        }
        if (pipe(fd)!=-1)
        {
                switch (fork())
                {
                case -1:
                        close(fd[0]);
                        close(fd[1]);
                        break;
                case 0:
                        close(fd[0]);
                        if ((fd[1]==pd)||(dup2(fd[1],pd)==pd))
                        {
                                if (fd[1]!=pd)
                                {
                                        close(fd[1]);
                                }
                                execl("/bin/sh","sh","-c",command,NULL);
                                close(pd);
                        }
                        exit(1);
                        break;
                default:
                        close(fd[1]);
                        if (ret=fdopen(fd[0],type))
                        {
                                return ret;
                        }
                        close(fd[0]);
                        break;
                }
        }
        return NULL;
}

#endif /* defined(sgi) */


/*****************************************************************************
 * String related function
 ****************************************************************************/


/*
 * A replacement of strdup(), since it's not defined at some
 * unix variants.
 */
char *strdup_local(const char *str) {
  char *c=(char *)malloc(sizeof(char)*(strlen(str)+1));
  strcpy(c,str);
  return c;
}


#define DIGIT(x)        (isdigit(x) ? (x) - '0' : \
islower (x) ? (x) + 10 - 'a' : (x) + 10 - 'A')
#define MBASE ('z' - 'a' + 1 + 10)

/* This seems to be lacking on some system */
#if !defined(HAVE_STRNCASECMP)
int strncasecmp(const char *s1, const char *s2, int n)
{
  register int c1, c2;

  while (*s1 && *s2 && n) {
    c1 = tolower(*s1);
    c2 = tolower(*s2);
    if (c1 != c2)
      return (c1 - c2);
    s1++;
    s2++;
    n--;
  }
  if (!n)
    return(0);
  return (int) (*s1 - *s2);
}
#endif

#if !defined(HAVE_STRCASECMP)
int strcasecmp(const char *s1, const char*s2)
{
  register int c1, c2;

  while (*s1 && *s2) {
    c1 = tolower(*s1);
    c2 = tolower(*s2);
    if (c1 != c2)
      return (c1 - c2);
    s1++;
    s2++;
  }
  if (*s1=='\0' && *s2=='\0')
        return 0;
  return (int) (*s1 - *s2);
}
#endif

char *strcasestr_local(const char *s, const char *find)
{
    char c, sc;
    size_t len;

    if ((c = *find++) != 0) {
                c = tolower(c);
        len = strlen(find);
        do {
            do {
                 if ((sc = *s++) == 0)
                     return NULL;
            } while (tolower(sc) != c);
        } while (strncasecmp(s, find, len) != 0);
        s--;
     }
     return (char *)s;
}

#if !defined(HAVE_SNPRINTF)

int snprintf(char *dest, int max, const char *format, ...)
{
    va_list var;
    int ret;

    va_start(var, format);
    ret = vsprintf(dest, format, var);
    va_end(var);
    if (ret > max) abort();

    return ret;
}
#endif


/*
 * Based on (n+1)^2 = n^2 + 2n + 1
 * given that   1^2 = 1, then
 *              2^2 = 1 + (2 + 1) = 1 + 3 = 4
 *              3^2 = 4 + (4 + 1) = 4 + 5 = 1 + 3 + 5 = 9
 *              4^2 = 9 + (6 + 1) = 9 + 7 = 1 + 3 + 5 + 7 = 16
 *              ...
 * In other words, a square number can be express as the sum of the
 * series n^2 = 1 + 3 + ... + (2n-1)
 */
int
isqrt(int n)
{
        int result, sum, prev;
        result = 0;
        prev = sum = 1;
        while (sum <= n) {
                prev += 2;
                sum += prev;
                ++result;
        }
        return result;
}


/*
 * returns a char-pointer to a static array, in which a representation
 * of the decimal number given will be stored.
 */

char *ltostr10(signed long n) {
  static char buf[12]; /* maximum size is n=-2 billion, i.e. 11 characters+1
                          character for the trailing nul character */
  snprintf(buf, sizeof(buf), "%ld", n);
  return buf;
}
char *doubletostr10(double v){
  static char tbuf[200];
  sprintf(tbuf,"%f",v);
  return tbuf;
}

/**
 * Open and possibly uncompress a file.
 *
 * @param ext the extension if the file is compressed.
 *
 * @param uncompressor the command to uncompress the file if the file is
 * compressed.
 *
 * @param name the base file name without compression extension
 *
 * @param flag only used for compressed files: if set, uncompress and open the
 * file; if unset, uncompress the file via pipe
 *
 * @param *compressed set to zero if the file was uncompressed
 */
static FILE *open_and_uncompress_file(const char *ext, const char *uncompressor, const char *name, int flag, int *compressed) {
    struct stat st;
    char buf[MAX_BUF];
    char buf2[MAX_BUF];
    int ret;

    if (ext == NULL) {
        ext = "";
    }

    if (strlen(name)+strlen(ext) >= sizeof(buf)) {
        errno = ENAMETOOLONG; /* File name too long */
        return NULL;
    }
    sprintf(buf, "%s%s", name, ext);

    if (stat(buf, &st) != 0) {
        return NULL;
    }

    if (!S_ISREG(st.st_mode)) {
        errno = EISDIR;         /* Not a regular file */
        return NULL;
    }

    if (uncompressor == NULL) {
        /* open without uncompression */

        return fopen(buf, "r");
    }

    /* The file name buf (and its substring name) is passed as an argument to a
     * shell command, therefore check for characters that could confuse the
     * shell.
     */
    if (strpbrk(buf, "'\\\r\n") != NULL) {
        errno = ENOENT;         /* Pretend the file does not exist */
        return NULL;
    }

    if (!flag) {
        /* uncompress via pipe */

        if (strlen(uncompressor)+4+strlen(buf)+1 >= sizeof(buf2)) {
            errno = ENAMETOOLONG;       /* File name too long */
            return NULL;
        }
        sprintf(buf2, "%s < '%s'", uncompressor, buf);

        return popen(buf2, "r");
    }

    /* remove compression from file, then open file */

    if (stat(name, &st) == 0 && !S_ISREG(st.st_mode)) {
        errno = EISDIR;
        return NULL;
    }

    if (strlen(uncompressor)+4+strlen(buf)+5+strlen(name)+1 >= sizeof(buf2)) {
        errno = ENAMETOOLONG;   /* File name too long */
        return NULL;
    }
    sprintf(buf2, "%s < '%s' > '%s'", uncompressor, buf, name);

    ret = system(buf2);
    if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) {
        LOG(llevError, "system(%s) returned %d\n", buf2, ret);
        errno = ENOENT;
        return NULL;
    }

    unlink(buf);                /* Delete the original */
    *compressed = 0;            /* Change to "uncompressed file" */
    chmod(name, st.st_mode);    /* Copy access mode from compressed file */

    return fopen(name, "r");
}

/**
 * open_and_uncompress() first searches for the original filename. If it exist,
 * then it opens it and returns the file-pointer.
 *
 * If not, it does two things depending on the flag. If the flag is set, it
 * tries to create the original file by appending a compression suffix to name
 * and uncompressing it. If the flag is not set, it creates a pipe that is used
 * for reading the file (NOTE - you can not use fseek on pipes).
 *
 * The compressed pointer is set to nonzero if the file is compressed (and
 * thus, fp is actually a pipe.) It returns 0 if it is a normal file.
 */
FILE *open_and_uncompress(const char *name, int flag, int *compressed) {
    size_t i;
    FILE *fp;

   fp = open_and_uncompress_file(0,0, name, flag, compressed);
        if (fp != NULL) {
            return fp;
        }

    errno = ENOENT;
    return NULL;
}

/*
 * See open_and_uncompress().
 */

void close_and_delete(FILE *fp, int compressed) {
  if (compressed)
    pclose(fp);
  else
    fclose(fp);
}

/*
 * If any directories in the given path doesn't exist, they are created.
 */

void make_path_to_file (char *filename)
{
    char buf[MAX_BUF], *cp = buf;
    struct stat statbuf;

    if (!filename || !*filename)
        return;
    strcpy (buf, filename);

    while ((cp = strchr (cp + 1, (int) '/'))) {
        *cp = '\0';
        if (stat(buf, &statbuf) || !S_ISDIR (statbuf.st_mode)) {
            if (mkdir (buf, SAVE_DIR_MODE)) {
                LOG(llevError, "Cannot mkdir %s: %s\n", buf, strerror(errno));
                return;
            }
        }
        *cp = '/';
    }
}

Revision:	1.3
Committed:	Wed Aug 30 16:30:37 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+3 -66 lines
Log Message:	remove compression support, intiialise perl earlier etc. etc.
#	User	Rev	Content
1	elmex	1.1	/*
2			* static char *rcsid_porting_c =
3	root	1.3	* "$Id: porting.C,v 1.2 2006-08-29 08:01:35 root Exp $";
4	elmex	1.1	*/
5
6			/*
7			CrossFire, A Multiplayer game for X-windows
8
9			Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10			Copyright (C) 1992 Frank Tore Johansen
11
12			This program is free software; you can redistribute it and/or modify
13			it under the terms of the GNU General Public License as published by
14			the Free Software Foundation; either version 2 of the License, or
15			(at your option) any later version.
16
17			This program is distributed in the hope that it will be useful,
18			but WITHOUT ANY WARRANTY; without even the implied warranty of
19			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20			GNU General Public License for more details.
21
22			You should have received a copy of the GNU General Public License
23			along with this program; if not, write to the Free Software
24			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
26			The authors can be reached via e-mail at crossfire-devel@real-time.com
27			*/
28
29			/* This file contains various functions that are not really unique for
30			* crossfire, but rather provides what should be standard functions
31			* for systems that do not have them. In this way, most of the
32			* nasty system dependent stuff is contained here, with the program
33			* calling these functions.
34			*/
35
36
37			#ifdef WIN32 /* ---win32 exclude/include headers */
38			#include "process.h"
39			#define pid_t int /* we include it non global, because there is a redefinition in python.h */
40			#else
41			#include <ctype.h>
42			#include <sys/stat.h>
43			#include <sys/wait.h>
44
45			#include <sys/param.h>
46			#include <stdio.h>
47
48			/* Need to pull in the HAVE_... values somehow */
49			/* win32 reminder: always put this in a ifndef win32 block */
50			#include <autoconf.h>
51			#endif
52
53
54			#ifdef HAVE_STDLIB_H
55			#include <stdlib.h>
56			#endif
57
58			#ifdef HAVE_UNISTD_H
59			#include <unistd.h>
60			#endif
61
62			#include <stdarg.h>
63			/* Has to be after above includes so we don't redefine some values */
64			#include "global.h"
65
66			static unsigned int curtmp = 0;
67
68			/*****************************************************************************
69			* File related functions
70			****************************************************************************/
71
72			/*
73			* A replacement for the tempnam() function since it's not defined
74			* at some unix variants.
75			*/
76
77			char tempnam_local(const char dir, const char *pfx)
78			{
79			char *name;
80			pid_t pid=getpid();
81
82			/* HURD does not have a hard limit, but we do */
83			#ifndef MAXPATHLEN
84			#define MAXPATHLEN 4096
85			#endif
86
87			if (!(name = (char *) malloc(MAXPATHLEN)))
88	root	1.2	return(NULL);
89	elmex	1.1
90			if (!pfx)
91	root	1.2	pfx = "cftmp.";
92	elmex	1.1
93			/* This is a pretty simple method - put the pid as a hex digit and
94			* just keep incrementing the last digit. Check to see if the file
95			* already exists - if so, we'll just keep looking - eventually we should
96			* find one that is free.
97			*/
98			if (dir!=NULL) {
99	root	1.2	do {
100	elmex	1.1	#ifdef HAVE_SNPRINTF
101	root	1.2	(void)snprintf(name, MAXPATHLEN, "%s/%s%hx.%d", dir, pfx, pid, curtmp);
102	elmex	1.1	#else
103	root	1.2	(void)sprintf(name,"%s/%s%hx%d", dir, pfx, pid, curtmp);
104	elmex	1.1	#endif
105	root	1.2	curtmp++;
106			} while (access(name, F_OK)!=-1);
107			return(name);
108	elmex	1.1	}
109			return(NULL);
110			}
111
112
113
114			/* This function removes everything in the directory. */
115			void remove_directory(const char *path)
116			{
117			DIR *dirp;
118			char buf[MAX_BUF];
119			struct stat statbuf;
120			int status;
121
122			if ((dirp=opendir(path))!=NULL) {
123	root	1.2	struct dirent *de;
124	elmex	1.1
125	root	1.2	for (de=readdir(dirp); de; de = readdir(dirp)) {
126			/* Don't remove '.' or '..' In theory we should do a better
127			* check for .., but the directories we are removing are fairly
128			* limited and should not have dot files in them.
129			*/
130			if (de->d_name[0] == '.') continue;
131
132			/* Linux actually has a type field in the dirent structure,
133			* but that is not portable - stat should be portable
134			*/
135			status=stat(de->d_name, &statbuf);
136			if ((status!=-1) && (S_ISDIR(statbuf.st_mode))) {
137			sprintf(buf,"%s/%s", path, de->d_name);
138			remove_directory(buf);
139			continue;
140			}
141			sprintf(buf,"%s/%s", path, de->d_name);
142			if (unlink(buf)) {
143			LOG(llevError,"Unable to remove directory %s\n", path);
144			}
145			}
146			closedir(dirp);
147	elmex	1.1	}
148			if (rmdir(path)) {
149	root	1.2	LOG(llevError,"Unable to remove directory %s\n", path);
150	elmex	1.1	}
151			}
152
153			#if defined(sgi)
154
155			#include <stdio.h>
156			#include <stdlib.h>
157			#include <string.h>
158
159			#define popen fixed_popen
160
161			FILE popen_local(const char command, const char *type)
162			{
163	root	1.2	int fd[2];
164			int pd;
165			FILE *ret;
166			if (!strcmp(type,"r"))
167			{
168			pd=STDOUT_FILENO;
169			}
170			else if (!strcmp(type,"w"))
171			{
172			pd=STDIN_FILENO;
173			}
174			else
175			{
176			return NULL;
177			}
178			if (pipe(fd)!=-1)
179			{
180			switch (fork())
181			{
182			case -1:
183			close(fd[0]);
184			close(fd[1]);
185			break;
186			case 0:
187			close(fd[0]);
188			if ((fd[1]==pd)\|\|(dup2(fd[1],pd)==pd))
189			{
190			if (fd[1]!=pd)
191			{
192			close(fd[1]);
193			}
194			execl("/bin/sh","sh","-c",command,NULL);
195			close(pd);
196			}
197			exit(1);
198			break;
199			default:
200			close(fd[1]);
201			if (ret=fdopen(fd[0],type))
202			{
203			return ret;
204			}
205			close(fd[0]);
206			break;
207			}
208			}
209			return NULL;
210	elmex	1.1	}
211
212			#endif /* defined(sgi) */
213
214
215			/*****************************************************************************
216			* String related function
217			****************************************************************************/
218
219
220
221			/*
222			* A replacement of strdup(), since it's not defined at some
223			* unix variants.
224			*/
225			char strdup_local(const char str) {
226			char c=(char )malloc(sizeof(char)*(strlen(str)+1));
227			strcpy(c,str);
228			return c;
229			}
230
231
232			#define DIGIT(x) (isdigit(x) ? (x) - '0' : \
233			islower (x) ? (x) + 10 - 'a' : (x) + 10 - 'A')
234			#define MBASE ('z' - 'a' + 1 + 10)
235
236			/* This seems to be lacking on some system */
237			#if !defined(HAVE_STRNCASECMP)
238			int strncasecmp(const char s1, const char s2, int n)
239			{
240			register int c1, c2;
241
242			while (s1 && s2 && n) {
243			c1 = tolower(*s1);
244			c2 = tolower(*s2);
245			if (c1 != c2)
246			return (c1 - c2);
247			s1++;
248			s2++;
249			n--;
250			}
251			if (!n)
252			return(0);
253			return (int) (s1 - s2);
254			}
255			#endif
256
257			#if !defined(HAVE_STRCASECMP)
258			int strcasecmp(const char s1, const chars2)
259			{
260			register int c1, c2;
261
262			while (s1 && s2) {
263			c1 = tolower(*s1);
264			c2 = tolower(*s2);
265			if (c1 != c2)
266			return (c1 - c2);
267			s1++;
268			s2++;
269			}
270			if (s1=='\0' && s2=='\0')
271	root	1.2	return 0;
272	elmex	1.1	return (int) (s1 - s2);
273			}
274			#endif
275
276			char strcasestr_local(const char s, const char *find)
277			{
278			char c, sc;
279			size_t len;
280
281			if ((c = *find++) != 0) {
282	root	1.2	c = tolower(c);
283	elmex	1.1	len = strlen(find);
284			do {
285			do {
286			if ((sc = *s++) == 0)
287			return NULL;
288			} while (tolower(sc) != c);
289			} while (strncasecmp(s, find, len) != 0);
290			s--;
291			}
292			return (char *)s;
293			}
294
295			#if !defined(HAVE_SNPRINTF)
296
297			int snprintf(char dest, int max, const char format, ...)
298			{
299			va_list var;
300			int ret;
301
302			va_start(var, format);
303			ret = vsprintf(dest, format, var);
304			va_end(var);
305			if (ret > max) abort();
306
307			return ret;
308			}
309			#endif
310
311
312			/*
313			* Based on (n+1)^2 = n^2 + 2n + 1
314			* given that 1^2 = 1, then
315			* 2^2 = 1 + (2 + 1) = 1 + 3 = 4
316			* 3^2 = 4 + (4 + 1) = 4 + 5 = 1 + 3 + 5 = 9
317			* 4^2 = 9 + (6 + 1) = 9 + 7 = 1 + 3 + 5 + 7 = 16
318			* ...
319			* In other words, a square number can be express as the sum of the
320			* series n^2 = 1 + 3 + ... + (2n-1)
321			*/
322			int
323			isqrt(int n)
324			{
325	root	1.2	int result, sum, prev;
326			result = 0;
327			prev = sum = 1;
328			while (sum <= n) {
329			prev += 2;
330			sum += prev;
331			++result;
332			}
333			return result;
334	elmex	1.1	}
335
336
337			/*
338			* returns a char-pointer to a static array, in which a representation
339			* of the decimal number given will be stored.
340			*/
341
342			char *ltostr10(signed long n) {
343			static char buf[12]; /* maximum size is n=-2 billion, i.e. 11 characters+1
344	root	1.2	character for the trailing nul character */
345	elmex	1.1	snprintf(buf, sizeof(buf), "%ld", n);
346			return buf;
347			}
348			char *doubletostr10(double v){
349			static char tbuf[200];
350			sprintf(tbuf,"%f",v);
351			return tbuf;
352			}
353
354			/**
355			* Open and possibly uncompress a file.
356			*
357			* @param ext the extension if the file is compressed.
358			*
359			* @param uncompressor the command to uncompress the file if the file is
360			* compressed.
361			*
362			* @param name the base file name without compression extension
363			*
364			* @param flag only used for compressed files: if set, uncompress and open the
365			* file; if unset, uncompress the file via pipe
366			*
367			* @param *compressed set to zero if the file was uncompressed
368			*/
369			static FILE open_and_uncompress_file(const char ext, const char uncompressor, const char name, int flag, int *compressed) {
370			struct stat st;
371			char buf[MAX_BUF];
372			char buf2[MAX_BUF];
373			int ret;
374
375			if (ext == NULL) {
376			ext = "";
377			}
378
379			if (strlen(name)+strlen(ext) >= sizeof(buf)) {
380			errno = ENAMETOOLONG; /* File name too long */
381			return NULL;
382			}
383			sprintf(buf, "%s%s", name, ext);
384
385			if (stat(buf, &st) != 0) {
386			return NULL;
387			}
388
389			if (!S_ISREG(st.st_mode)) {
390			errno = EISDIR; /* Not a regular file */
391			return NULL;
392			}
393
394			if (uncompressor == NULL) {
395			/* open without uncompression */
396
397			return fopen(buf, "r");
398			}
399
400			/* The file name buf (and its substring name) is passed as an argument to a
401			* shell command, therefore check for characters that could confuse the
402			* shell.
403			*/
404			if (strpbrk(buf, "'\\\r\n") != NULL) {
405			errno = ENOENT; /* Pretend the file does not exist */
406			return NULL;
407			}
408
409			if (!flag) {
410			/* uncompress via pipe */
411
412			if (strlen(uncompressor)+4+strlen(buf)+1 >= sizeof(buf2)) {
413			errno = ENAMETOOLONG; /* File name too long */
414			return NULL;
415			}
416			sprintf(buf2, "%s < '%s'", uncompressor, buf);
417
418			return popen(buf2, "r");
419			}
420
421			/* remove compression from file, then open file */
422
423			if (stat(name, &st) == 0 && !S_ISREG(st.st_mode)) {
424			errno = EISDIR;
425			return NULL;
426			}
427
428			if (strlen(uncompressor)+4+strlen(buf)+5+strlen(name)+1 >= sizeof(buf2)) {
429			errno = ENAMETOOLONG; /* File name too long */
430			return NULL;
431			}
432			sprintf(buf2, "%s < '%s' > '%s'", uncompressor, buf, name);
433
434			ret = system(buf2);
435			if (!WIFEXITED(ret) \|\| WEXITSTATUS(ret) != 0) {
436			LOG(llevError, "system(%s) returned %d\n", buf2, ret);
437			errno = ENOENT;
438			return NULL;
439			}
440
441			unlink(buf); /* Delete the original */
442			compressed = 0; / Change to "uncompressed file" */
443			chmod(name, st.st_mode); /* Copy access mode from compressed file */
444
445			return fopen(name, "r");
446			}
447
448			/**
449			* open_and_uncompress() first searches for the original filename. If it exist,
450			* then it opens it and returns the file-pointer.
451			*
452			* If not, it does two things depending on the flag. If the flag is set, it
453			* tries to create the original file by appending a compression suffix to name
454			* and uncompressing it. If the flag is not set, it creates a pipe that is used
455			* for reading the file (NOTE - you can not use fseek on pipes).
456			*
457			* The compressed pointer is set to nonzero if the file is compressed (and
458			* thus, fp is actually a pipe.) It returns 0 if it is a normal file.
459			*/
460			FILE open_and_uncompress(const char name, int flag, int *compressed) {
461			size_t i;
462			FILE *fp;
463
464	root	1.3	fp = open_and_uncompress_file(0,0, name, flag, compressed);
465	elmex	1.1	if (fp != NULL) {
466			return fp;
467			}
468
469			errno = ENOENT;
470			return NULL;
471			}
472
473			/*
474			* See open_and_uncompress().
475			*/
476
477			void close_and_delete(FILE *fp, int compressed) {
478			if (compressed)
479			pclose(fp);
480			else
481			fclose(fp);
482			}
483
484			/*
485			* If any directories in the given path doesn't exist, they are created.
486			*/
487
488			void make_path_to_file (char *filename)
489			{
490			char buf[MAX_BUF], *cp = buf;
491			struct stat statbuf;
492
493			if (!filename \|\| !*filename)
494	root	1.2	return;
495	elmex	1.1	strcpy (buf, filename);
496
497			while ((cp = strchr (cp + 1, (int) '/'))) {
498	root	1.2	*cp = '\0';
499			if (stat(buf, &statbuf) \|\| !S_ISDIR (statbuf.st_mode)) {
500			if (mkdir (buf, SAVE_DIR_MODE)) {
501	root	1.3	LOG(llevError, "Cannot mkdir %s: %s\n", buf, strerror(errno));
502	root	1.2	return;
503			}
504			}
505			*cp = '/';
506	elmex	1.1	}
507			}
508