ulfile.c

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

#ifndef lint
static char sccsid[]  =  "@(#)ulfile.c	4.2   (ULTRIX)   9/11/90";
#endif  lint

/*
*	.TITLE	ULFILE - Raw ULTRIX event file handler
*	.IDENT	/1-001/
*
* COPYRIGHT (C) 1986 DIGITAL EQUIPMENT CORP.,
* CSSE SOFTWARE ENGINEERING
* MARLBOROUGH, MASSACHUSETTS
*
* THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A 
* SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLUSION
* OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE,  OR ANY OTHER
* COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE
* TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO
* AGREES TO THESE LICENSE TERMS.  TITLE TO AND OWNERSHIP OF THE
* SOFTWARE SHALL AT ALL TIMES REMAIN IN DEC.
*
* THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT
* NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
* EQUIPMENT CORPORATION.
*
* DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF
* ITS SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.
*
*++
*
* FACILITY:		[ FMA Software Tools - Detail Design ]
*
* ABSTRACT:
*
*	This module contains the functions to 
open, close and read 
*	either the error log file or a socket on an ULTRIX system.
*	
*	
* ENVIRONMENT:	ULTRIX-32 C
*	
* AUTHOR:  Bob Winant,  CREATION DATE:  30-Jan-1986
*
* MODIFIED BY:
*
*--
*/
#include "eiliterals.h"		/* Erit specific literals */
#include "eims.h"
#include "erms.h"
#include "select.h"
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/errlog.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <elwindow.h>

/*
*++
*=
*=
*=MODULE FLOW - ulfile.c
*=
*=  a - get_buff_addr()                             Gets address of buffer
*=                                                  of raw rec
*=          return(rec_buff)
*=
*=  b - open_file(filename, mode)                   Opens file or socket
*=          if(EI$MAILBOX)
*=              {
*=              bld_socket()                                (* j)
*=              return(EI$OPN)
*=              }
*=          if(EI$APPEND)
*=              {
*=              open(out_file,WRONLY|CREAT|APPEND,0644)
*=              return(EI$OPN)
*=              }
*=          open(in_file,RDONLY,0)
*=          return(EI$OPN)
*=
*=  c - close_file(mode)                            Closes file or socket.
*=          if(socket_flag)
*=              close_wndw(in_file,params)
*=          else
*=              close(in_file)
*=          return(status)
*=
*=  d - read_file(status)                           Reads next raw record
*=                                                  into buffer.
*=          if(socket_flag)
*=              soc_read(status)                            (* k)
*=          else
*=              {
*=              if(new_file)
*=                  init_file()                             (* i)
*=              get_next_rec(status)                        (* e)
*=          validate_entry(elrp)                            (* g)
*=          return(elrp)
*=
*=  e - get_next_rec(status)                        Gets the next record.
*=          if(! reverse_flag)
*=              {
*=              lseek(in_file,offset,L_SET)
*=              read(in_file,rec_buff,EL_MAXRECSIZE)
*=              }
*=          if(reverse_flag)
*=              {
*=              lseek(in_file,offset-EL_MAXRECSIZE,L_SET)
*=              read(in_file,rec_buff,EL_MAXRECSIZE)
*=              "back up checking for trailer"
*=              }
*=          return(rec_buff)
*=
*=  f - write_rec(elrp)                             Writes log record.
*=          write(out_file,elrp,reclen)
*=          return(EI$SUCC)
*=
*=  g - validate_entry(elrp)                        Validates record trailer.
*=          "check for valid trailer"
*=          to_new_ver()                                    (* h)
*=          "check valid flag"
*=          return(EI$CORRUPT | EI$SUCC)
*=
*=  h - to_new_ver()                                Changes elrp format from
*=                                                  old versions to latest.
*=
*=  i - init_file()                                 Initializes input file
*=                                                  for 1st read.
*=          if(reverse_flag)
*=              "setup for reverse"
*=          while(between start time and end time)
*=              {
*=              lseek(in_file,offset,L_SET)
*=              read(in_file,rec_buff,EL_MAXRECSIZE)
*=              validate_entry(elrp)                        (* g)
*=              es$eval(end_date_tree)                      (select.c)
*=              es$eval(start_date_tree)                    (select.c)
*=              }
*=          return()
*=
*=  j - bld_socket()                                Opens errlog socket.
*=          open_wndw(opts,params)
*=          return(socket_id)
*=
*=  k - soc_read()                                  Reads socket and places
*=                                                  raw record in buffer
*=          read_wndw(in_file,rec_buff,EL_MAXRECSIZE)
*=          return(rec_buff)
*=
*
*--
*/

extern SELNODE *startree;
extern SELNODE *endtree;

extern char *ei$errtxt();    		/* error messages rtn */

/****************** Declare module wide globals ******************/

long in_file         = 0;		/* Input file descriptor */
long out_file        = 0;		/* Output file descriptor */
char rec_buff[EL_MAXRECSIZE];  		/* location to put record */
char   *trailer_id;			/* Pointer to check for valid trailer */

long   file_offset       =  0;
long   total_bytes       =  0;
long   rec_len           =  0;
struct el_rec *elrp;			/* to directly access info in event */


short socket_flag   = EI$FALSE;
short reverse_flag  = EI$FALSE;
short corrupt_flag  = EI$FALSE;
short newfile_flag  = EI$TRUE;

struct options opts;		/* Options to be read for socket conn */
struct s_params params;		/* Parameters for socket connection */
struct sockaddr_un soc_from;  	/* Socket structure that info comes from */
long   socfrmlen;		/* Length of info returned from a socket read */

/***************************  FUNCTIONS  ***************************/

long  init_file();
long  validate_entry();
void  to_new_ver();
long  bld_socket();
struct el_rec  *soc_read();
struct el_rec  *get_next_rec();

/**********************  GET_BUFF_ADDR  ****************************/

struct el_rec *get_buff_addr()

{
return ((struct el_rec *)rec_buff);
}

/******************************************************************/




/*
*	.SBTTL	OPEN_FILE - Obtains access to raw error information
*++
* FUNCTIONAL DESCRIPTION:		
*
*	-  Selects user's input location (file or mailbox).
*	-  Opens file or mailbox.
*	
* FORMAL PARAMETERS:		
*
*	filename		Name of the file to be opened
*	mode			Mode to open the file (used as a flag to
*				open mailbox).
*		  
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		A raw system event file
*
* COMPLETION STATUS:		EI$OPN (file or socket open - success)
*				EI$NOP (file or socket not opened - failure)
*				EI$FNX (file doesn't exist - failure)
*
* SIDE EFFECTS:			Raw data will be accessible
*
*--
*/
/*...	ROUTINE OPEN_FILE (filename, mode)				*/
long open_file (filename, mode)

char *filename;
short mode;

{

if (mode == EI$MAILBOX)
    {
    socket_flag = EI$TRUE;
    if ((in_file = bld_socket()) != EI$NSKT)
        return (EI$OPN);
    else
        {
	printf("\n%s\n", ei$errtxt(EI$, EI$NSKT));
	return (EI$FNX);
        }
    }
else
    {
    if (mode == EI$REVERSE)
        reverse_flag = EI$TRUE;
    if (strcmp(filename, "") != EI$FALSE)
        {
        if (mode == EI$APPEND)
            {
            if ((out_file = open(filename, O_WRONLY | O_CREAT | O_APPEND,
                                         0644)) >= 0)
                return (EI$OPN);
            else
                {
                printf("\n%s: %s\n", ei$errtxt(EI$,EI$NOP), filename);
                return (EI$NOP);
                }
            }
        if ((in_file = open(filename, O_RDONLY, 0)) >= 0)
            return (EI$OPN);
        else
            {
	    printf("\n%s: %s\n", ei$errtxt(EI$,EI$NOP), filename);
            return (EI$NOP);
            }
        }
    else
        {
	printf ("\n%s: %s\n", ei$errtxt(EI$,EI$FNX), filename);
	return (EI$FNX);
        }
    }
}
/*...	ENDROUTINE OPEN_FILE					*/

/*
*	.SBTTL	CLOSE_FILE - Closes the error log file or socket
*++
* FUNCTIONAL DESCRIPTION:		
*
*	-  Closes the input file or socket
*	-  Does necessary clean-up
*	
* FORMAL PARAMETERS:		
*
*	socket_flag		flag to specify socket
*
* IMPLICIT INPUTS:		Input file or socket in fcb_struc
*
* IMPLICIT OUTPUTS:		NONE
*
* COMPLETION STATUS:		EI$FCL (file or socket closed - success)
*				EI$FNC (file or socket not closed)
*
* SIDE EFFECTS:			File or socket will be closed and
*				become unavailable for processing.
*
*--
*/
/*...	ROUTINE CLOSE_FILE (mode)					*/
long close_file(mode)

long mode;

{
long status;

if (socket_flag)
    {
    status = close_wndw(in_file, &params);
    if (status != -1)
	status = 0;
    }
else
    status = close(in_file);

if (!status)
    return (EI$FCL);
else
    {
    printf("\n%s\n", ei$errtxt(EI$,EI$FNC));
    return (EI$FNC);
    }
}
/*...	ENDROUTINE CLOSE_FILE					*/


/*
*	.SBTTL	READ_FILE - reads an entry from the raw event file
*++
* FUNCTIONAL DESCRIPTION:		
*
*	Reads the specified input file or socket one record at a time
*	
* FORMAL PARAMETERS:		elrp - A pointer to be assigned to the
*					    read-in buffer.
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		A raw system event record
*
* COMPLETION STATUS:		EI$SUCC - Everything's cool
*				EI$RDR - error encountered
*					during read.
*				EI$EOF - End of file encountered
*				EI$FAIL - File somehow inaccessible
*				EI$CORRUPT - corrupt record found in
*					     raw event file.
*				
*
* SIDE EFFECTS:			NONE
*
*--
*/
/*...	ROUTINE READ_FILE ()				*/

struct el_rec *read_file(status)
long *status;

{
short i;

corrupt_flag = EI$FALSE;
		
if (socket_flag == EI$TRUE)		/* check for socket read  */
    elrp = soc_read(status);
else
    {
    if (newfile_flag == EI$TRUE)
	{
	init_file();
        rec_len = 0;			/* initialize rec len	*/
	}
    elrp = get_next_rec(status);
    }
    
if (*status != EI$SUCC)
    return (NULL);

if ((*status = validate_entry(elrp)) == EI$FAIL)
    return (NULL);

for (i = elrp->elrhdr.rhdr_reclen; i < EL_MAXRECSIZE; i++)
    rec_buff[i] = '\0';		/* zero out remainder of buffer */

if (*status == EI$CORRUPT)
    corrupt_flag = EI$TRUE;

return (elrp);
}

/*...	END ROUTINE READ_FILE()				*/



/*
*	.SBTTL	GET_NEXT_REC   reads entry from the raw event file
*++
* FUNCTIONAL DESCRIPTION:		
*
*	Reads the specified input file for next record.
*	
* FORMAL PARAMETERS:
*
* IMPLICIT INPUTS:		NONE
*
* IMPLICIT OUTPUTS:		A raw system event record
*
* COMPLETION STATUS:		EI$SUCC - Everything's cool
*				EI$RDR - error encountered
*					during read.
*				EI$EOF - End of file encountered
*				EI$FAIL - File somehow inaccessible
*				EI$CORRUPT - corrupt record found in
*					     raw event file.
*				
*
* SIDE EFFECTS:			NONE
*
*--
*/
/*...	ROUTINE GET_NEXT_REC()				*/

struct el_rec *get_next_rec(status)
long *status;

{
short i, j;
long len;

if (reverse_flag != EI$TRUE)

/*******************  FORWARD READ OF FILE ******************/

    {
    file_offset += rec_len;
    lseek(in_file,file_offset,L_SET);
    if (read(in_file,rec_buff,EL_MAXRECSIZE) == 0)
	{
	*status = EI$EOF;
	return(NULL);
	}
    }
else
    
/***********************  REVERSE READ OF FILE ******************/
    
    {
    if (file_offset <= 0)
	{
	*status = EI$EOF;