ulfile.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

	return(NULL);
	}
    if (file_offset >= EL_MAXRECSIZE)
	{
	len          = EL_MAXRECSIZE;
	file_offset -= EL_MAXRECSIZE;
	}
    else
	{
	len         = file_offset;
	file_offset = 0;
	}
    lseek(in_file, file_offset, L_SET);
    if (read(in_file, rec_buff, len) != len)
	{
	*status = EI$RDR;
	return(NULL);
	}
    if (strncmp(rec_buff+(len - EL_TRAILERSIZE),trailer,EL_TRAILERSIZE) != 0)
	{
	*status = EI$RDR;
	return(NULL);
	}
    for(i = len - (EL_TRAILERSIZE + 1); i > 0; i--)
	{
        if (strncmp(rec_buff+i,trailer,EL_TRAILERSIZE) == 0)
	    break;
	}
    if (i == 0)
	{
	if (file_offset != 0)	/* cannot find start of rec */
	    {
	    *status = EI$FAIL;
	    return(NULL);
	    }
	}
    else
	{
	i += EL_TRAILERSIZE;
	len -= i;			/* calculated rec len	*/
	for (j = 0; j < len; j++)
	    {
	    rec_buff[j] = rec_buff[i+j];
	    }
	}
    file_offset += i;
    }
*status = EI$SUCC;
return ((struct el_rec *)rec_buff);
}

/*... END ROUTINE GET_NEXT_REC 				*/




/*
*	.SBTTL	WRITE_REC - Writes raw record to new log file
*++
* FUNCTIONAL DESCRIPTION:		
*
*	Writes raw record from given buffer to new output log file
*	
* FORMAL PARAMETERS:		elrp - A pointer to buffer
*                                      (raw sytem event record). 
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		A raw system event record
*
* COMPLETION STATUS:		EI$SUCC - Everything's cool
*
* SIDE EFFECTS:			NONE
*
*--
*/
/*...	ROUTINE WRITE_REC(elrp)				*/

long write_rec(elrp)
struct el_rec *elrp;
{
write(out_file,elrp,elrp->elrhdr.rhdr_reclen);
return (EI$SUCC);
}

/*...	END ROUTINE PUT_REC()				*/

/*
*	.SBTTL	VALIDATE_ENTRY - Validates the current raw record
*++
* FUNCTIONAL DESCRIPTION:		
*
*	This routine checks the expected trailer on the end of the
*	raw record to see if a valid entry exists.  It also checks the
*	validation location for the record to see if that is also valid.
*	
* FORMAL PARAMETERS:		
*
*	elrp		A pointer to current raw ULTRIX event.
*
* IMPLICIT INPUTS:		A raw event record
*
* IMPLICIT OUTPUTS:		NONE
*
* COMPLETION STATUS:		EI$TRUE (good record)
*				EI$CORRUPT (record has valid trailer
*					but invalid value in rhdr_valid)
*				EI$FAIL (invalid record, and unable
*					to resync)
*
* SIDE EFFECTS:			Return value used by calling
*				routine to decide what to do next
*
*--
*/
/*...	ROUTINE VALIDATE_ENTRY(elrp)				*/

long  validate_entry(elrp)

struct el_rec *elrp;

{
long  i;				/* loop ctr */

/**************** First check for a valid trailer *****************/

rec_len = elrp->elrhdr.rhdr_reclen;   /*save len for next read */

if (strncmp(((char *)elrp)+(rec_len-EL_TRAILERSIZE),trailer,EL_TRAILERSIZE) != 0)
    {					/* no trailer found */
    for (i = 0; i < EL_MAXRECSIZE; ++i)	/* search for next */
        {
        if (strncmp(rec_buff+i,trailer,EL_TRAILERSIZE) == 0)
            {
            rec_len = i+EL_TRAILERSIZE;
	    return (EI$CORRUPT);	/* found another trailer */
	    break;
            }
        }
    return (EI$FAIL);			/* cannot resync */
    }

to_new_ver();

/************************ now check for valid flag ***************/

if (elrp->elrhdr.rhdr_valid != EL_VALID)
    return (EI$CORRUPT);		/* no valid flag */

return(EI$SUCC);
}
/*...	ENDROUTINE VALIDATE_ENTRY				*/



/*
*	.SBTTL	TO_NEW_VER - Changes the errlog file to a new version
*++
* FUNCTIONAL DESCRIPTION:		
*
*	This routine is used to change an errlog file from an old version
*	to that of the latest version.
*	
* FORMAL PARAMETERS:		
*
*
* IMPLICIT INPUTS:		A raw event record
*
* IMPLICIT OUTPUTS:		NONE
*
* COMPLETION STATUS:		NONE
*
* SIDE EFFECTS:			The errlog entry will now look like
*				the latest errlog.h
*
*--
*/
/*...	ROUTINE TO_NEW_VER()					*/

void to_new_ver()
{

long  i;				/* loop ctr */
long  new_rhdr_len;
long  new_body_len;
long  old_rhdr_len;
long  old_body_len;
char  temp_buff[EL_MAXRECSIZE];

/********************** DEFINE OLD HEADERS ************************/

struct v1_el_rhdr {			/* errlog header for v1 */
	u_short rhdr_reclen;		/* errlog record length */
	u_short rhdr_seqnum; 		/* seq. number */
	u_long rhdr_time;		/* time in sec */
	u_long rhdr_sid;		/* system id, filled in by elcs */
	u_char rhdr_valid;		/* valid error record */
	u_char rhdr_pri;		/* priority hi - low */
	u_char rhdr_elver[2];		/* errlog version,filled in by elcs */
	char rhdr_hname[EL_SIZE12];	/* host name, filled in by elcs */
};

if (elrp->elrhdr.rhdr_elver == 1)		/* ver 1 entry */

/************************ change ver 1 to ver 2 *************************/
    {
    old_rhdr_len  = sizeof(struct v1_el_rhdr);
    old_body_len  = rec_len - old_rhdr_len;

    new_rhdr_len  = sizeof(struct el_rhdr);
    new_body_len  = old_body_len;

    for (i = 0; i < rec_len; i++) 	/* copy rec to temp */
	temp_buff[i] = rec_buff[i];

    for (i = 0; i < (new_rhdr_len - old_rhdr_len); i++)
        rec_buff[old_rhdr_len + i] = '\0';	/* zero out new area */

					/* move body */
    for (i = 0; i < old_body_len; i++)
        rec_buff[new_rhdr_len + i] = temp_buff[old_rhdr_len + i];

    elrp->elrhdr.rhdr_reclen = new_rhdr_len + new_body_len;
    elrp->elrhdr.rhdr_elver  = 2;

    }
/******************** end change ver 1 to ver 2 *************************/


}
/*...	TO_NEW_VER				*/



/*
*	.SBTTL	INIT_FILE       Initialize pointers for read by date.
*++
* FUNCTIONAL DESCRIPTION:		
*
*	Returns the file_offset to the first record (forward or rev)
*	
* FORMAL PARAMETERS:		NONE
*
* IMPLICIT INPUTS:		Module wide declarations for rec_buff,
*				flags, and other integers necessary
*				for keeping track of the possition in
*				the file and direction.
*
* IMPLICIT OUTPUTS:		file-offset
*
* COMPLETION STATUS:		NONE
*
* SIDE EFFECTS:			NONE
*
*--
*/

/*...  ROUTINE  INIT_FILE()				*/

long  init_file()

{

short  i;
long   lo;
long   hi;
long   offset;

newfile_flag = EI$FALSE;

lo = 0;
hi = lseek(in_file, 0, L_XTND);		/* get file size	*/

if (reverse_flag == EI$TRUE)
    {
    file_offset = hi;
    if (endtree == NULL)
	return;
    }
else
    {
    file_offset = lo;
    if (startree == NULL)
	return;
    }

/*****************  DO BINARY SEARCH TO START  ******************/

while ( ((hi - lo)/2) > EL_MAXRECSIZE)
    {
    offset = lo + ((hi - lo)/2);
    lseek(in_file, offset, L_SET);	/* move ptr to mid range	*/
    if (read(in_file, rec_buff, EL_MAXRECSIZE) != EL_MAXRECSIZE)
        return;			/* cannot split any smaller     */

    for (i = 0; i < EL_MAXRECSIZE; i++, offset++)
        {
        if (strncmp(rec_buff+i,trailer,EL_TRAILERSIZE) == 0)
	    break;
        }

    if (i == EL_MAXRECSIZE)
        return;			/* cannot split any smaller     */
    i      += EL_TRAILERSIZE;
    offset += EL_TRAILERSIZE;

    lseek(in_file, offset, L_SET);	/* move ptr to rec start */
    if (read(in_file, rec_buff, EL_MAXRECSIZE) != EL_MAXRECSIZE)
        return;			/* cannot split any smaller     */

    elrp = (struct el_rec *)rec_buff;

    if (validate_entry(elrp) != EI$SUCC)
        return;			/* cannot split any smaller     */

    if (reverse_flag == EI$TRUE)
        {
        if (es$eval(endtree) == ES$SUCC)
            {
	    lo = offset;
	    }
        else
	    {
	    hi = offset;
	    file_offset = offset;
	    }
        }
    else
        {
        if (es$eval(startree) == ES$SUCC)
            {
	    hi = offset;
	    }
        else
	    {
	    lo = offset;
	    file_offset = offset;
	    }
        }
    }

/*****************  FINISHED BINARY SEARCH  *********************/

return;
}

/*...  END ROUTINE  INIT_FILE()			*/



/*
*	.SBTTL	BLD_SOCKET - Creates socket path to OS
*++
* FUNCTIONAL DESCRIPTION:		
*
*	Opens a path to the OS buffer for a constant read and
*	translation on wakeup
*	
* FORMAL PARAMETERS:		NONE
*
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		NONE
*
* COMPLETION STATUS:		sock_id - socket descriptor
*				EI$NSKT - failed to open socket
*
* SIDE EFFECTS:			Path to OS opened, opens processing
*				directly from os, continues until user
*				stops it.
*
*--
*/
/*...	ROUTINE BLD_SOCKET ()				*/
long bld_socket()

{
long sock_id;		/* Receives return value from socket open */

/******** Set up options to ALL * (defined in window.h by UEG) ****/
 
opts.class	= ALL;
opts.type	= ALL;
opts.ctldevtyp	= ALL;
opts.num	= ALL;
opts.unitnum	= ALL;

sock_id = open_wndw(&opts, &params);		/* Open socket connection */
if (sock_id != EI$RDR)
    return (sock_id);
else
    return (EI$NSKT);
}
/*...	ENDROUTINE BLD_SOCKET				*/


/*
*	.SBTTL	SOC_READ - reads an entry from a socket
*++
* FUNCTIONAL DESCRIPTION:		
*
*	Reads the specified socket one record at a time
*	
* FORMAL PARAMETERS:		NONE
*
*
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		A raw system event record
*
* COMPLETION STATUS:		EI$TRUE - Everything's cool
*				EI$RDR - error encountered
*					during read.
*				EI$CORRUPT - corrupt record found
*				
*
* SIDE EFFECTS:			Process goes into a wait state
*				until a response is received from
*				the called socket.
*
*--
*/
/*...	ROUTINE SOC_READ ()					*/
struct el_rec  *soc_read(status)
long *status;

{
long   bytes_read;
int    done = 0;

/********** Get a record from the socket connector ***************/

while (!done)
    {
    bytes_read = read_wndw(in_file, rec_buff, EL_MAXRECSIZE);

    if (bytes_read == 0)		/* 0 => exit; */
	{
	*status = EI$FAIL;
        return(NULL);
	}
    if (bytes_read == EI$RDR)
        {
        if (errno != EINTR)
	    {
	    *status = EI$FAIL;
            return (NULL);		/* return if not */
	    }
        else 				/* otherwise, try again */
            {
	    errno = 0;
	    continue;
	    }
        }
    done = 1;
    }
*status = EI$SUCC;
return((struct el_rec *)rec_buff);
}  
/*...	ENDROUTINE SOC_READ					*/