DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - metrics - download
Index: T e

⟦32b42e1bb⟧ TextFile

    Length: 7248 (0x1c50)
    Types: TextFile
    Names: »entry_load.c«

Derivation

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

TextFile

/* entry_load.c - load bits of the database */

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

/*
 * $Header: /f/osi/quipu/RCS/entry_load.c,v 6.0 89/03/18 23:41:35 mrose Rel $
 *
 *
 * $Log:	entry_load.c,v $
 * Revision 6.0  89/03/18  23:41:35  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 "quipu/ds_error.h"
#include "tailor.h"
#include <sys/types.h>
#include "usr.dirent.h"

extern char * treedir;
Entry database_root;
char filename [LINESIZE];
PS ps;
extern LLog * log_dsap;

Entry directory_load (root,level,check)
char * root;
char level;
char check;      /* if TRUE check attributes against mandatory/may list */
{
FILE * fptr;
Entry treetop;

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

	if (root != NULLCP) {
		if ((*root != '/') && (treedir != 0)) {
			ps_print (ps,isodefile(treedir));
			ps_print (ps,"/");
		}
		ps_print (ps,root);
		*ps->ps_ptr = 0;
		LLOG (log_dsap,LLOG_NOTICE,("root is %s",filename));
	} else {
		if (treedir != 0) {
			ps_print (ps,isodefile(treedir));
			ps_print (ps,"/EDB");
		} else 
			ps_print (ps,"EDB");
		*ps->ps_ptr = 0;
		LLOG (log_dsap,LLOG_NOTICE,("root is %s",filename));
	}

	if ((fptr = fopen (filename,"r")) == (FILE *) NULL) {
		LLOG (log_dsap,LLOG_NOTICE,("WARNING: can't open DIT root EDB - \"%s\" - should I be able to ?",filename));
		return (NULLENTRY);
	}

	treetop = get_default_entry (NULLENTRY);
	treetop->e_leaf = FALSE;
	treetop->e_acl->ac_child = acl_default ();
	treetop->e_acl->ac_entry = acl_default ();
	treetop->e_acl->ac_default = acl_default ();
	if ((treetop->e_child = getentry_block (fptr,treetop,filename,check)) == NULLENTRY) 
		return (NULLENTRY);
	(void) fclose (fptr);

	if (level == 'w')
	     if (entry_load_kids (treetop->e_child,strlen(isodefile(treedir))+1,check) == NOTOK)
	     	return (NULLENTRY);

	ps_free (ps);

	return (treetop);
}


entry_load_kids (entryptr,offset,check)
register Entry entryptr;
register int offset;
char check;
{
register Entry ptr;
FILE * fileptr;
DIR * dirp;

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

	dirp = opendir (filename);

	for ( ptr = entryptr; ptr != NULLENTRY; ptr = ptr->e_sibling) {
		if (check) /* don't load children unless there are KNOWN to exist */
			if ((ptr->e_master == NULLAV) && (ptr->e_slave == NULLAV)) {
				ptr->e_leaf = TRUE;
				continue;
			}
		DLOG (log_dsap,LLOG_DEBUG,("scan --- %s", filename));
		if (file_check (offset,ptr,dirp) == OK) {
		   DLOG (log_dsap,LLOG_DEBUG,("Opening file %s",filename));

		   if ((fileptr = fopen (filename,"r")) != (FILE *) NULL) {
			if ((ptr->e_child = getentry_block (fileptr,ptr,filename,check)) == NULLENTRY) {
				(void) closedir (dirp);
				(void) fclose (fileptr);
				return (NOTOK);
			}
			(void) fclose (fileptr);

			if (ptr->e_child != NULLENTRY) {
				ptr->e_leaf = FALSE;
				if (entry_load_kids (ptr->e_child,strlen(filename)-3,check) == NOTOK) {
					(void) closedir (dirp);
					return (NOTOK);
				}
			} else
				ptr->e_leaf = TRUE;
		   }
		}
	}

	(void) closedir (dirp);
	return (OK);

}


file_check (offset,entryptr,dirp)
register int offset;
register Entry entryptr;
DIR * dirp;
{
struct dirent * dp, * readdir();

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

	rdn_print (ps,entryptr->e_name,DIROUT);
	*ps->ps_ptr = 0;

	rewinddir (dirp);

	while ((dp = readdir (dirp)) != NULL)
		if (strcmp(dp->d_name,filename+offset) == 0) {
			ps_print (ps,"/EDB");
			*ps->ps_ptr = 0;
			return (OK);
		}

	return (NOTOK);

}

Entry subtree_load (parent,dn)
Entry parent;
DN dn;
{
FILE * fptr;
Entry treetop;
int len;

	if ((parent != NULLENTRY) && (parent->e_child != NULLENTRY)) {
		DLOG (log_dsap,LLOG_NOTICE,("WARNING: Subtree load of non NULL child - This can USUALLY be ignored if it occurs during startup!!!"));
		return (parent->e_child);
	}

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

	if (treedir != 0) {
		ps_print (ps,isodefile(treedir));
		ps_print (ps,"/");
	}
	dn_print (ps,dn,DIROUT);
	ps_print (ps,"/EDB");
		
	*ps->ps_ptr = 0;
	len = strlen (filename) -3;
	DLOG (log_dsap,LLOG_NOTICE,("root is %s",filename));

	if ((fptr = fopen (filename,"r")) == (FILE *) NULL) {
		LLOG (log_dsap,LLOG_EXCEPTIONS,("WARNING - can't open subtree EDB file - \"%s\" - should I be able to ?",filename));
		return (NULLENTRY);
	}

	treetop = getentry_block (fptr,parent,filename,TRUE);
	parent->e_child = treetop;
	(void) fclose (fptr);

	if (entry_load_kids (treetop,len,TRUE) == NOTOK)
		return (NULLENTRY);

	ps_free (ps);

	return (treetop);
}

refresh_from_disk(str)
char * str;
{
DN dn, str2dn();
Entry parent;
Entry child;

	if (( dn= str2dn (str)) == NULLDN)
		return (NOTOK);

	if ((parent = local_find_entry (dn,FALSE)) == NULLENTRY)
		return (NOTOK);

	child = parent->e_child;
	parent->e_child = NULLENTRY;

	if ((subtree_load (parent,dn)) == NULLENTRY)
		return (NOTOK);

	directory_free (child);

	return (OK);
}

Entry new_constructor (parent)
Entry parent;
{
Entry constructor;

	constructor = get_default_entry (parent);
	constructor->e_leaf = FALSE;
	constructor->e_complete = FALSE;
	constructor->e_data = E_TYPE_CONSTRUCTOR;
	constructor->e_acl->ac_child = acl_default ();
	constructor->e_acl->ac_entry = acl_default ();
	constructor->e_acl->ac_default = acl_default ();
	return (constructor);
}

Entry make_path (dn)
DN dn;
{
Entry ptr;
register RDN    a_rdn, b_rdn;

	if ((database_root == NULLENTRY) || (database_root->e_child == NULLENTRY)) {
		database_root = new_constructor(NULLENTRY);
		ptr = database_root;
		for (; dn!= NULLDN; dn=dn->dn_parent) {
			ptr->e_child = new_constructor(ptr);
			ptr = ptr->e_child;
			ptr->e_name = rdn_cpy (dn->dn_rdn);
		}
		return (ptr);
	} else {
		/* follow links as far as poss, then add new bits */

		ptr = database_root->e_child;
		b_rdn = dn->dn_rdn;
		a_rdn = ptr->e_name ;

		for(;;) { /* return out */
			while (rdn_cmp (a_rdn, b_rdn) != OK) {
				if (ptr->e_sibling == NULLENTRY) {
				   for (; dn!= NULLDN; dn=dn->dn_parent) {
					ptr->e_sibling = new_constructor(ptr->e_parent);
					ptr = ptr->e_sibling;
					ptr->e_name = rdn_cpy (dn->dn_rdn);
				   }
				   return (ptr);
				}
				ptr = ptr->e_sibling;
				a_rdn = ptr->e_name ;
			}

			if ( dn->dn_parent == NULLDN)
				return (ptr);

			dn = dn->dn_parent;
			b_rdn = dn->dn_rdn;

			if ( ptr->e_child == NULLENTRY) {
				for (; dn!= NULLDN; dn=dn->dn_parent) {
					ptr->e_child = new_constructor(ptr);
					ptr = ptr->e_child;
					ptr->e_name = rdn_cpy (dn->dn_rdn);
				}
				return (ptr);
			}
			ptr = ptr->e_child;
			a_rdn = ptr->e_name;
		}

	}
	/* NOTREACHED */

}