server/common/porting.C


/*
 * static char *rcsid_porting_c =
 *   "$Id: porting.C,v 1.5 2006-09-10 16:00:23 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_uncompress() first searches for the original filename. If it exist,
 * then it opens it and returns the file-pointer.
 */
FILE *
open_and_uncompress (const char *name, int flag, int *compressed)
{
  size_t i;
  FILE *fp;

  *compressed = 0;
  return fopen (name, "r");
}

/*
 * See open_and_uncompress().
 */

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