server/common/porting.C


/*
 * static char *rcsid_porting_c =
 *   "$Id: porting.C,v 1.4 2006-09-07 09:28:44 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.5
Committed:	Sun Sep 10 16:00:23 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.4:	+100 -93 lines
Log Message:	indent
#	Content
1
2	/*
3	* static char *rcsid_porting_c =
4	* "$Id: porting.C,v 1.4 2006-09-07 09:28:44 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	{
184	pd = STDOUT_FILENO;
185	}
186	else if (!strcmp (type, "w"))
187	{
188	pd = STDIN_FILENO;
189	}
190	else
191	{
192	return NULL;
193	}
194	if (pipe (fd) != -1)
195	{
196	switch (fork ())
197	{
198	case -1:
199	close (fd[0]);
200	close (fd[1]);
201	break;
202	case 0:
203	close (fd[0]);
204	if ((fd[1] == pd) \|\| (dup2 (fd[1], pd) == pd))
205	{
206	if (fd[1] != pd)
207	{
208	close (fd[1]);
209	}
210	execl ("/bin/sh", "sh", "-c", command, NULL);
211	close (pd);
212	}
213	exit (1);
214	break;
215	default:
216	close (fd[1]);
217	if (ret = fdopen (fd[0], type))
218	{
219	return ret;
220	}
221	close (fd[0]);
222	break;
223	}
224	}
225	return NULL;
226	}
227
228	#endif /* defined(sgi) */
229
230
231	/*****************************************************************************
232	* String related function
233	****************************************************************************/
234
235
236
237	/*
238	* A replacement of strdup(), since it's not defined at some
239	* unix variants.
240	*/
241	char *
242	strdup_local (const char *str)
243	{
244	char c = (char ) malloc (sizeof (char) * (strlen (str) + 1));
245
246	strcpy (c, str);
247	return c;
248	}
249
250
251	#define DIGIT(x) (isdigit(x) ? (x) - '0' : \
252	islower (x) ? (x) + 10 - 'a' : (x) + 10 - 'A')
253	#define MBASE ('z' - 'a' + 1 + 10)
254
255	/* This seems to be lacking on some system */
256	#if !defined(HAVE_STRNCASECMP)
257	int
258	strncasecmp (const char s1, const char s2, int n)
259	{
260	register int c1, c2;
261
262	while (s1 && s2 && n)
263	{
264	c1 = tolower (*s1);
265	c2 = tolower (*s2);
266	if (c1 != c2)
267	return (c1 - c2);
268	s1++;
269	s2++;
270	n--;
271	}
272	if (!n)
273	return (0);
274	return (int) (s1 - s2);
275	}
276	#endif
277
278	#if !defined(HAVE_STRCASECMP)
279	int
280	strcasecmp (const char s1, const char s2)
281	{
282	register int c1, c2;
283
284	while (s1 && s2)
285	{
286	c1 = tolower (*s1);
287	c2 = tolower (*s2);
288	if (c1 != c2)
289	return (c1 - c2);
290	s1++;
291	s2++;
292	}
293	if (s1 == '\0' && s2 == '\0')
294	return 0;
295	return (int) (s1 - s2);
296	}
297	#endif
298
299	char *
300	strcasestr_local (const char s, const char find)
301	{
302	char c, sc;
303	size_t len;
304
305	if ((c = *find++) != 0)
306	{
307	c = tolower (c);
308	len = strlen (find);
309	do
310	{
311	do
312	{
313	if ((sc = *s++) == 0)
314	return NULL;
315	}
316	while (tolower (sc) != c);
317	}
318	while (strncasecmp (s, find, len) != 0);
319	s--;
320	}
321	return (char *) s;
322	}
323
324	#if !defined(HAVE_SNPRINTF)
325
326	int
327	snprintf (char dest, int max, const char format, ...)
328	{
329	va_list var;
330	int ret;
331
332	va_start (var, format);
333	ret = vsprintf (dest, format, var);
334	va_end (var);
335	if (ret > max)
336	abort ();
337
338	return ret;
339	}
340	#endif
341
342
343	/*
344	* Based on (n+1)^2 = n^2 + 2n + 1
345	* given that 1^2 = 1, then
346	* 2^2 = 1 + (2 + 1) = 1 + 3 = 4
347	* 3^2 = 4 + (4 + 1) = 4 + 5 = 1 + 3 + 5 = 9
348	* 4^2 = 9 + (6 + 1) = 9 + 7 = 1 + 3 + 5 + 7 = 16
349	* ...
350	* In other words, a square number can be express as the sum of the
351	* series n^2 = 1 + 3 + ... + (2n-1)
352	*/
353	int
354	isqrt (int n)
355	{
356	int result, sum, prev;
357
358	result = 0;
359	prev = sum = 1;
360	while (sum <= n)
361	{
362	prev += 2;
363	sum += prev;
364	++result;
365	}
366	return result;
367	}
368
369
370	/*
371	* returns a char-pointer to a static array, in which a representation
372	* of the decimal number given will be stored.
373	*/
374
375	char *
376	ltostr10 (signed long n)
377	{
378	static char buf[12]; /* maximum size is n=-2 billion, i.e. 11 characters+1
379	character for the trailing nul character */
380	snprintf (buf, sizeof (buf), "%ld", n);
381	return buf;
382	}
383
384	char *
385	doubletostr10 (double v)
386	{
387	static char tbuf[200];
388
389	sprintf (tbuf, "%f", v);
390	return tbuf;
391	}
392
393	/**
394	* open_and_uncompress() first searches for the original filename. If it exist,
395	* then it opens it and returns the file-pointer.
396	*/
397	FILE *
398	open_and_uncompress (const char name, int flag, int compressed)
399	{
400	size_t i;
401	FILE *fp;
402
403	*compressed = 0;
404	return fopen (name, "r");
405	}
406
407	/*
408	* See open_and_uncompress().
409	*/
410
411	void
412	close_and_delete (FILE * fp, int compressed)
413	{
414	fclose (fp);
415	}
416
417	/*
418	* If any directories in the given path doesn't exist, they are created.
419	*/
420
421	void
422	make_path_to_file (char *filename)
423	{
424	char buf[MAX_BUF], *cp = buf;
425	struct stat statbuf;
426
427	if (!filename \|\| !*filename)
428	return;
429	strcpy (buf, filename);
430
431	while ((cp = strchr (cp + 1, (int) '/')))
432	{
433	*cp = '\0';
434	if (stat (buf, &statbuf) \|\| !S_ISDIR (statbuf.st_mode))
435	{
436	if (mkdir (buf, SAVE_DIR_MODE))
437	{
438	LOG (llevError, "Cannot mkdir %s: %s\n", buf, strerror (errno));
439	return;
440	}
441	}
442	*cp = '/';
443	}
444	}