DataMuseum.dk

top - metrics - download

    Length: 7078 (0x1ba6)
    Types: TextFile
    Names: »entry_dump.c«

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/quipu/entry_dump.c« 

TextFile

/* entry_dump.c - routines to dump the database */

#ifndef lint
static char *rcsid = "$Header: /f/osi/quipu/RCS/entry_dump.c,v 6.0 89/03/18 23:41:33 mrose Rel $";
#endif

/*
 * $Header: /f/osi/quipu/RCS/entry_dump.c,v 6.0 89/03/18 23:41:33 mrose Rel $
 *
 *
 * $Log:	entry_dump.c,v $
 * Revision 6.0  89/03/18  23:41:33  mrose
 * Release 5.0
 * 
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


#include "quipu/util.h"
#include "quipu/entry.h"
#include <errno.h>
#include "tailor.h"

FILE * file_open ();
static void child_dump ();
extern int errno;
extern char filename [LINESIZE];
extern PS ps;
extern LLog * log_dsap;
extern char * parse_file;
extern RDN parse_rdn;

entry_print (psa,entryptr,format)
PS psa;
Entry entryptr;
int format;
{
	if (entryptr == NULLENTRY)
		return;

	switch (format) {
		case READOUT:
			ps_print (psa,"Entry data block for ");
			rdn_print (psa,entryptr->e_name,format);
			ps_print (psa,"\n");
			ps_print (psa,entryptr->e_edbversion);
			ps_print (psa,"\n");
			as_print (psa,entryptr->e_attributes,format);
			break;
		case EDBOUT:
			rdn_print (psa,entryptr->e_name,format);
			parse_rdn = entryptr->e_name;
			ps_print (psa,"\n");
			as_print (psa,entryptr->e_attributes,format);
			parse_rdn = NULLRDN;
			break;
	}

}


entry_block_print (psa,block,format)
PS psa;
Entry block;
int format;
{
Entry ptr;

	if (block != NULLENTRY) {

		for ( ptr = block; ptr != NULLENTRY; ptr = ptr->e_sibling) {
			entry_print (psa,ptr,format);
		ps_print (psa,"\n");
		}

	}
}
directory_print (psa,directory)
PS psa;
Entry directory;
{
Entry ptr;

	if (directory != NULLENTRY) {

		for ( ptr = directory; ptr != NULLENTRY; ptr = ptr->e_sibling) {
			entry_print (psa,ptr,READOUT);
			ps_print (psa,"*******************\n");
			directory_print (psa,ptr->e_child);

			ps_print (psa,"End of ");
			rdn_print (psa,ptr->e_name,READOUT);
			ps_print (psa,"\n\n");
		}

	}
}


mk_directory (offset,entryptr)
register int offset;
register Entry entryptr;
{
	ps->ps_ptr = filename + offset;
	ps->ps_cnt = LINESIZE - offset;

	rdn_print (ps,entryptr->e_name,DIROUT);
	*ps->ps_ptr = 0;        /* bit of a hack - but solves problems !!! */

	DLOG (log_dsap,LLOG_DEBUG,("creating diretory %s",filename));

	if ( mkdir (filename,0700) != 0 ) {
		if ( errno == EEXIST )
			LLOG (log_dsap,LLOG_EXCEPTIONS,("directory %s already exists",filename));
		else
			LLOG (log_dsap,LLOG_EXCEPTIONS,("can't make directory %s",filename));
		return (-1);
	}

	return (0);
}

header_print (psa,edb,format)
PS psa;
Entry edb;
int format;
{
char * new_version ();

	switch (format) {
	case READOUT:   return;
	case EDBOUT:
		switch (edb->e_data) {
		case E_DATA_MASTER:
			ps_print (psa,"MASTER\n");
			break;
		case E_TYPE_SLAVE :
			ps_print (psa,"SLAVE\n");
			break;
		default:
			ps_print (psa,"CACHE\n");
			break;
		}
		if (edb->e_parent != NULLENTRY)
			ps_printf (psa,"%s\n",edb->e_parent->e_edbversion);
		else
			ps_printf (psa,"%s\n",new_version());
	}
}


directory_dump (dir,directory,format,level)
char * dir;
Entry directory;
int format;
char level;
{
extern Entry database_root;
FILE * fptr;
register Entry ptr;
PS entryps;
int um;

	if ((ps = ps_alloc (str_open)) == NULLPS)
		fatal (-35,"file open ps_alloc failed");
	if (str_setup (ps,filename,LINESIZE,1) == NOTOK)
		fatal (-36,"file open std_setup failed");

	ps->ps_ptr = filename;
	ps->ps_cnt = LINESIZE;

	if (level == 'w') {

		if ( mkdir (isodefile(dir),0700) != 0 ) {
			if ( errno == EEXIST )
				LLOG (log_dsap,LLOG_EXCEPTIONS,("directory %s already exists",filename));
			else
				LLOG (log_dsap,LLOG_EXCEPTIONS,("can't make directory %s",filename));
			return;
		}

		if ((ps = ps_alloc (str_open)) == NULLPS)
			fatal (-37,"file open ps_alloc failed");
		if (str_setup (ps,filename,LINESIZE,1) == NOTOK)
			fatal (-38,"file open std_setup failed");

		ps_print (ps,isodefile(dir));
		DLOG (log_dsap,LLOG_DEBUG,("root is %s",filename));
		ps_print (ps,"/");
		ps_print (ps,"EDB");
		*ps->ps_ptr = 0;
	} else
		(void) strcpy (filename,dir);

	if (directory == NULLENTRY)
		directory = database_root->e_child;

	if (directory->e_data != E_TYPE_CONSTRUCTOR) {

		um = umask (0177);
		if ((fptr = fopen (filename,"w")) == (FILE *) NULL) {
			LLOG (log_dsap,LLOG_EXCEPTIONS,("can't create root %s",filename));
			return;
		}
		(void) umask (um);

		if ((entryps = ps_alloc (std_open)) == NULLPS) {
			LLOG (log_dsap,LLOG_EXCEPTIONS,("entryps_alloc failed"));
			return;
		}
		if (std_setup (entryps,fptr) == NOTOK) {
			LLOG (log_dsap,LLOG_EXCEPTIONS,("std_setup failed"));
			return;
		}

		parse_file = filename;
		header_print (entryps,directory,format);

		for ( ptr = directory; ptr != NULLENTRY; ptr = ptr->e_sibling ) {
			entry_print (entryps,ptr,format);
			ps_print (entryps,"\n");
			child_dump (ptr->e_child,format,strlen(isodefile(dir))+1);
		}

		ps_free (entryps);
		ps_free (ps);
		(void) fclose (fptr);
	} else
		for ( ptr = directory; ptr != NULLENTRY; ptr = ptr->e_sibling )
			child_dump (ptr->e_child,format,strlen(isodefile(dir))+1);
}


static void child_dump (child,format,offset)
Entry child;
register int format;
int offset;
{
FILE * fptr;
register Entry ptr;
PS entryps;
register int keepoffset;

	if (child != NULLENTRY) {
		if (mk_directory (offset,child->e_parent) != 0) {
			LLOG (log_dsap,LLOG_EXCEPTIONS,("can't make child directory"));
			return;
		}
		if (child->e_data != E_TYPE_CONSTRUCTOR) {

		   if ((fptr = file_open (offset, child->e_parent,"w")) == (FILE *) NULL) {
			LLOG (log_dsap,LLOG_EXCEPTIONS,("file_open failed"));
			return;
		   }
		   if ((entryps = ps_alloc (std_open)) == NULLPS) {
			LLOG (log_dsap,LLOG_EXCEPTIONS,("ps_alloc failed"));
			return;
		   }
		   if (std_setup (entryps,fptr) == NOTOK) {
			LLOG (log_dsap,LLOG_EXCEPTIONS,("std_setup failed"));
			return;
		   }

		   header_print (entryps,child,format);

		   entry_block_print (entryps,child,format);
		   ps_free (entryps);
		   (void) fclose (fptr);
		   keepoffset = strlen (filename) -3;

		} else {
		   ps_print (ps,"/");
		   *ps->ps_ptr = 0;
		   keepoffset = strlen (filename);
		}

		for ( ptr = child; ptr != NULLENTRY; ptr = ptr->e_sibling)
			child_dump (ptr->e_child,format,keepoffset);
	}
}

FILE * file_open (offset,entryptr,mode)
register int offset;
register Entry entryptr;
register char * mode;
{
int um;
FILE * t_fptr;

	ps->ps_ptr = filename + offset;
	ps->ps_cnt = LINESIZE - offset;

	rdn_print (ps,entryptr->e_name,DIROUT);
	ps_print (ps,"/EDB");
	*ps->ps_ptr = 0;

	DLOG (log_dsap,LLOG_DEBUG,("Opening file %s",filename));
        parse_file = filename;

	um = umask (0177);
	t_fptr = fopen (filename,mode);
	(void) umask (um);
	return (t_fptr);
}

char * new_version ()
{
long clock;
struct UTCtime ut;
extern time_t time();

	(void) time (&clock);
	tm2ut (gmtime (&clock),&ut);
	return (strdup(gent2str(&ut)));
}