xref: /dports/dns/gen6dns/gen6dns-1.3/filep.c

/*****************************************************************
**	@(#) filep.c
*****************************************************************/
# include <sys/resource.h>
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <assert.h>
// # include <ctype.h>

# include "debug.h"
#define extern
# include "filep.h"
#undef extern

static	filep_t		filep[HASHSIZE];	/* the hash table */
static	int		filep_nofiles;		/* no of current open files in filep */
static	int		filep_maxfp;		/* no of max open files in filep */
static	const char	*filep_filemode;	/* filemode e.g. "w" or "a" */
static	const char	*filep_fnametmpl;	/* file name template e.g. "db%04x" or NULL*/
static	unsigned long	hashfunc (const char *val);

int	filep_init (const char *fnametmpl, const char *filemode)
{
	int	i;
	struct  rlimit  rl;

	if ( getrlimit (RLIMIT_NOFILE, &rl) < 0 )
	{
		fprintf (stderr, "Can't get max file limit\n");
		return 0;
	}
	// fprintf (stderr, "soft=%d hard=%d\n", rl.rlim_cur, rl.rlim_max);
	filep_nofiles = 0;		/* no of used slots in hash array */
	filep_maxfp = rl.rlim_cur;	/* curr limit of fd */
	filep_maxfp -= 3;		/* stdin, stdout, stderr */
	filep_maxfp -= 1;		/* reserve another one */
	filep_fnametmpl = fnametmpl;
	filep_filemode = filemode;

	for ( i = 0; i < HASHSIZE; i++ )
	{
		filep[i].fp = NULL;
		filep[i].name = NULL;
		filep[i].zone = NULL;
	}

	return filep_maxfp;
}

int	filep_close (void)
{
	int	i;

	/* close all open filepointer */
	for ( i = 0; i < HASHSIZE; i++ )
	{
		if ( filep[i].fp )
		{
			fclose (filep[i].fp);
			filep_nofiles--;
		}
		if ( filep[i].name )
			free (filep[i].name);
	}
	//fprintf (stderr, "nofiles = %d\n", filep_nofiles);
	assert ( filep_nofiles == 0 );

	return 1;
}

FILE	*filep_open (const char *name)
{
	int	ind;
	int	loopcnt;
	unsigned long	hash;
	const	char	*fname;
	char	fnamebuf[MAXFNAME+1];

	/* build hash from name (name is just the variable part of the filename) */
	hash = hashfunc (name);

	/* looking for hash in filep array */
	ind = hash % (HASHSIZE);
	assert ( ind >= 0 && ind < HASHSIZE );

	loopcnt = 0;		/* counter to detect if we are going another time through the hash list */
				/* This should never happen, it is just an "emergency break"  */
	while ( loopcnt < HASHSIZE && filep[ind].name != NULL && strcmp (filep[ind].name, name) != 0 )
	{
		if ( ++ind >= HASHSIZE )
			ind = 0;
		loopcnt++;
	}
	dbg_val2 ("loopcnt %d HASHSIZE %d\n", loopcnt, HASHSIZE);
	assert ( loopcnt < HASHSIZE );	/* this should never happen ! */

	/* the slot for this file and the file is indeed open ? */
	if ( filep[ind].fp && filep[ind].name )
		return filep[ind].fp;

	if ( filep_nofiles >= filep_maxfp )	/* no more filepointers available */
	{
		int	i;

		/* free one entry */
		i = ind;
		do {
			if ( i > 0 )
				i--;
			else
				i = HASHSIZE - 1;
		} while ( filep[i].fp == NULL );

		fclose (filep[i].fp);
		filep[i].fp = NULL;
		filep_nofiles--;

		dbg_val3 ("%3d close (%d) (interim) file %s \n", filep_nofiles, i, filep[i].name);
	}

	/* open or reopen the file */
	if ( filep_fnametmpl )		/* do we have a file name template ? */
	{
		snprintf (fnamebuf, sizeof (fnamebuf), filep_fnametmpl, name);	/* create the real name */
		fname = fnamebuf;
	}
	else
		fname = name;

	if ( filep[ind].name == NULL )	/* this is the slot for the new file */
	{
		if ( filep_nofiles >= MAXFILEP )	/* no space left in hasharray ? */
		{
			fprintf (stderr, "Maximum no of files (%d) reached !\n", filep_nofiles);
			exit (3);
		}

		if ( (filep[ind].fp = fopen (fname, filep_filemode)) == NULL )
		{
			dbg_val2 ("error in opening %s: # of open files = %d\n", fname, filep_nofiles);
			return NULL;
		}
		filep[ind].name = strdup (name);
		filep_nofiles++;

		dbg_val3 ("%3d open (%d) file %s \n", filep_nofiles, ind, fname);
	}
	else				/* the slot for a already known file */
	{
		/* reopen the file */
		if ( (filep[ind].fp = fopen (fname, "a")) == NULL )
		{
			dbg_val2 ("error in re-opening %s: # of open files = %d\n", fname, filep_nofiles);
			return NULL;
		}
		filep_nofiles++;

		dbg_val3 ("%3d re-open (%d) file %s \n", filep_nofiles, ind, fname);
	}

	return filep[ind].fp;
}

int	filep_first (int *ind)
{
	int	i = 0;

	while ( i < HASHSIZE && filep[i].fp == NULL )
		i++;
	*ind = i;

	return i >= HASHSIZE;
}

int	filep_next (int *ind)
{
	int	i = *ind + 1;

	while ( i < HASHSIZE && filep[i].fp == NULL )
		i++;
	*ind = i;

	return i >= HASHSIZE;
}

char	*filep_getname (int *ind)
{
	assert ( *ind >= 0 && *ind < HASHSIZE );

	return filep[*ind].name;
}

const	char	*filep_getzone (int *ind)
{
	assert ( *ind >= 0 && *ind < HASHSIZE );

	return filep[*ind].zone;
}


static	unsigned long	hashfunc (const char *val)
{
	unsigned long	hash = 0L;
	unsigned long	pot = 1L;

	while ( *val )
	{
		hash += *val++ * pot;
		pot *= 10;
	}

	return hash;
}


#ifdef TEST
#define	NFILES	MAXFILEP
int	main ()
{
	int	i;
	FILE	*fp;
	char	name[10+1];

	i = filep_init ("test/t%s.db", "w");
	fprintf (stdout, "No of concurrent open files is %d \n", i);

	/* open more files than the actual limit allows */
	srandom (27);
	fprintf (stdout, "First loop\n");
	for ( i = 0; i < NFILES; i++ )
	{
		snprintf (name, sizeof name, "%ld", random ());
		if ( (fp = filep_open (name)) == NULL )
			fprintf (stderr, "Error in access to file %s\n", name);
		fprintf (fp, "First line of file %d\n", i);
	}

	/* Now write again into each file */
	srandom (27);
	fprintf (stdout, "Second loop\n");
	for ( i = 0; i < NFILES; i++ )
	{
		snprintf (name, sizeof name, "%ld", random ());
		if ( (fp = filep_open (name)) == NULL )
			fprintf (stderr, "Error in access to file %s\n", name);
		fprintf (fp, "Second line of file %d\n", i);
	}

	/* Now close all files */
	filep_close ();
}
#endif