Return to parse2.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / quipu

BSD 4.3reno

/* parse2.c - */

#ifndef	lint
static char *rcsid = "$Header: /var/lib/cvsd/repos/CSRG/43BSDReno/contrib/isode-beta/quipu/parse2.c,v 1.1.1.1 2018/04/24 16:12:56 root Exp $";
#endif

/* 
 * $Header: /var/lib/cvsd/repos/CSRG/43BSDReno/contrib/isode-beta/quipu/parse2.c,v 1.1.1.1 2018/04/24 16:12:56 root Exp $
 *
 *
 * $Log: parse2.c,v $
 * Revision 1.1.1.1  2018/04/24 16:12:56  root
 * BSD 4.3reno
 *
 * Revision 7.3  90/07/09  14:46:27  mrose
 * sync
 * 
 * Revision 7.2  90/01/11  18:37:23  mrose
 * real-sync
 * 
 * Revision 7.1  89/12/19  16:20:42  mrose
 * sync
 * 
 * Revision 7.0  89/11/23  22:17:57  mrose
 * Release 6.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/config.h"
#include "cmd_srch.h"
#include "quipu/malloc.h"
#ifdef TURBO_DISK
#include <gdbm.h>
#endif

Entry getentry_block_aux (), get_entry_aux();
extern LLog * log_dsap;
char * getline ();
int rdn_print ();
int master_edbs = 0;
int slave_edbs = 0;

#ifdef TURBO_DISK
extern datum	turbo_header_key;
#endif

Entry getentry_block (p_parent,fname)
Entry p_parent;
char * fname;
{
#ifdef TURBO_DISK
	GDBM_FILE	db;
	static char	gfname[1024];
	int		save_heap;

	strcpy(gfname, fname);
	strcat(gfname, ".gdbm");
	save_heap = mem_heap;
	GENERAL_HEAP;
	db = gdbm_open(gfname, 0, GDBM_READER, 0, 0);
	mem_heap = save_heap;
	return getentry_block_aux (p_parent, gfname, db);
#else
	return getentry_block_aux (p_parent,fname, fopen (fname, "r"));
#endif
}

Entry getentry_block_aux (p_parent,fname,file)
Entry p_parent;
char * fname;
#ifdef TURBO_DISK
GDBM_FILE	file;
#else
FILE *file;
#endif
{
extern char * parse_file;
extern int parse_status;
extern int parse_line;
Entry entryptr;
int   dtype;
char *version;
Entry get_entries_aux ();
extern int errno;

	if (file == NULL) {
		LLOG (log_dsap,LLOG_NOTICE,("WARNING - Can't open \"%s\" (%d)- should I be able to ?",fname,errno));
		return (NULLENTRY);
	}

	LLOG (log_dsap,LLOG_NOTICE,("Loading \"%s\"",fname));

	parse_status = 0;
	parse_line   = 0;
	parse_file = fname;

	if (get_header (file,&dtype,&version) != OK) {
		parse_line = 0;
		parse_error ("File %s not loaded",fname);
		parse_file = NULLCP;
#ifdef TURBO_DISK
		save_heap = mem_heap;
		GENERAL_HEAP;
		(void) gdbm_close (file);
		mem_heap = save_heap;
#else
		(void) fclose (file);
#endif
		return (NULLENTRY);
	}

	entryptr = get_entries_aux (file,p_parent,version,dtype);

	if ((parse_status != 0) || (entryptr == NULLENTRY)) {
		parse_line = 0;
		parse_error ("File %s not loaded",fname);
		parse_file = NULLCP;
#ifdef TURBO_DISK
		save_heap = mem_heap;
		GENERAL_HEAP;
		(void) gdbm_close (file);
		mem_heap = save_heap;
#else
		(void) fclose (file);
#endif
		return (NULLENTRY);
	}

        if ( p_parent != NULLENTRY ) {
       	        p_parent->e_edbversion = version;
               	if ((dtype == E_DATA_MASTER) || (dtype == E_TYPE_SLAVE)) 
                       	p_parent->e_allchildrenpresent = TRUE;
       	}

	parse_file = NULLCP;

	if (dtype == E_DATA_MASTER)
		master_edbs++;
	if (dtype == E_TYPE_SLAVE)
		slave_edbs++;

#ifdef TURBO_DISK
	save_heap = mem_heap;
	GENERAL_HEAP;
	(void) gdbm_close (file);
	mem_heap = save_heap;
#else
	(void) fclose (file);
#endif
	return (entryptr);
}

#ifdef TURBO_DISK

get_header (db, typeptr, versionptr)
GDBM_FILE	db;
int		*typeptr;
char		**versionptr;
{
	char		*v;
	datum		h;
	int		save_heap;
	static CMD_TABLE cmd_header[] =  {
		"MASTER",	E_DATA_MASTER,
		"SLAVE",	E_TYPE_SLAVE,
		"CACHE",	E_TYPE_CACHE_FROM_MASTER,
		0,		-1,
	};
	extern char	*parse_entry;

	save_heap = mem_heap;
	GENERAL_HEAP;

	parse_entry = turbo_header_key.dptr;
	if (db == NULL) {
		parse_error("NULL dbm file!!!", NULLCP);
		mem_heap = save_heap;
		return(NOTOK);
	}

	h = gdbm_fetch(db, turbo_header_key);
	if (h.dptr == NULL) {
		parse_error("File has no header!!!", NULLCP);
		mem_heap = save_heap;
		return(NOTOK);
	}

	v = index(h.dptr, '\n');
	if (v == NULLCP) {
		parse_error("Bad file header", NULLCP);
		mem_heap = save_heap;
		return(NOTOK);
	}
	*v++ = '\0';

	if ((*typeptr = cmd_srch(h.dptr, cmd_header)) == -1) {
		parse_error("File type %s not recognised", h.dptr);
		mem_heap = save_heap;
		return(NOTOK);
	}

	if (*v == '\0') {
		parse_error("No version specified", NULLCP);
		mem_heap = save_heap;
		return(NOTOK);
	}
	*versionptr = strdup(v);
	free(h.dptr);

	mem_heap = save_heap;
	return(OK);
}

#else

get_header (file,typeptr,versionptr)
FILE * file;
int * typeptr;
char ** versionptr;
{
char * ptr;
static CMD_TABLE cmd_header [] = {
	"MASTER",	E_DATA_MASTER,
	"SLAVE",	E_TYPE_SLAVE,
	"CACHE",	E_TYPE_CACHE_FROM_MASTER,
	0,		-1,
	};

	if ((ptr = getline (file)) == NULLCP) {
		parse_error ("NULL file !!!",NULLCP);
		return (NOTOK);
	}

	if ((*typeptr = cmd_srch (ptr,cmd_header)) == -1) {
		parse_error ("File type %s not recognised",ptr);
		return (NOTOK);
	}

	if ((ptr = getline (file)) == NULLCP) {
		parse_error ("No version specified",NULLCP);
		return (NOTOK);
	}
	*versionptr = strdup (ptr);
	
	return (OK);
}

#endif

/* ARGSUSED */
Entry get_entries_aux (file,parent,version,dtype)
#ifdef TURBO_DISK
GDBM_FILE	file;
#else
FILE * file;
#endif
Entry parent;
char * version;
int dtype;
{
Entry eptr = NULLENTRY;
Entry top = NULLENTRY;
Entry trail;
Entry find_sibling();

#ifdef TURBO_DISK
extern int dbmeof;
#endif
#ifdef TURBO_LOAD
	if ( ! turbo_start(file)) {
		parse_error ("Turbo load failed",NULLCP);
		return NULLENTRY;
	}
#endif

#ifdef TURBO_DISK
	dbmeof = 0;
	while (dbmeof == 0) {
#else
	while (feof(file) == 0) {
#endif
		if ((eptr = get_entry_aux (file,parent,dtype)) == NULLENTRY)
			continue;
		if ( top == NULLENTRY) {
			top = eptr;
			trail = eptr;
		} else {
#ifdef TURBO_LOAD
			if ( turbo_insert(eptr->e_name) != OK )
#else
                        if (find_sibling (eptr->e_name,top) != NULLENTRY)
#endif
			{
				pslog (log_dsap,LLOG_EXCEPTIONS,"Duplicate entry for",rdn_print,(caddr_t)eptr->e_name);
				parse_error ("Non Unique RDN",NULLCP);
			}
			trail->e_sibling = eptr;
			trail = eptr;
		}
	}

#ifdef TURBO_LOAD
	turbo_end();
#endif

	return (top);
}


Entry get_entries (file,parent,version,dtype)
FILE * file;
Entry parent;
char * version;
int dtype;
{
extern int parse_status;
extern int parse_line;

	parse_status = 0;
	parse_line   = 0;

	return (get_entries_aux (file,parent,version,dtype));
}

Entry find_sibling (object,start)
RDN object;
Entry start;
{
	if (start == NULLENTRY) 
		return (NULLENTRY);

	while (rdn_cmp (start->e_name, object) != OK) {
		start = start->e_sibling ;
		if ( start == NULLENTRY ) 
			return (NULLENTRY);
	}
	return (start);
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.