static STATUS
gcn_nq_fopen( char *name, char *mode, FILE **file )
{
LOCATION loc;
STATUS status;
#ifndef hp9_mpe
if ( ( status = NMloc( ADMIN, PATH, (char *)NULL, &loc ) ) != OK )
goto error;
LOfaddpath( &loc, "name", &loc );
LOfstfile( name, &loc );
#else
if ( (status = NMloc( FILES, FILENAME, name, &loc )) != OK )
goto error;
#endif
if ( ! STcompare( mode, "r" ) && (status = LOexist( &loc )) != OK )
goto error;
#ifdef VMS
status = SIfopen( &loc, mode, SI_RACC, sizeof(GCN_DB_RECORD), file );
if (status == E_CL1904_SI_CANT_OPEN && ( LOexist( &loc ) == OK ) )
status = SIfopen( &loc, mode, GCN_RACC_FILE, sizeof (GCN_DB_RECORD),
file );
#else
status = SIfopen( &loc, mode, SI_RACC, sizeof (GCN_DB_RECORD), file );
#endif
error:
if ( status != OK ) *file = NULL;
return( status );
}
/*{
** Name: open_outfile - creates or appends to an output file
**
** Description:
** Creates or opens (for append) a file in a directory and sets a
** LOCATION structure.
**
** Inputs:
** out_filename - output file name
** out_dir - output directory
** create_or_append - create a new file or append to existing file
** uniq - make a unique filename
**
** Outputs:
** loc_name - output file path
**
** Returns:
** NULL - open failed
** FILE * - file pointer
*/
FILE *
open_outfile(
char *out_filename,
char *out_dir,
char *create_or_append,
char *loc_name,
bool uniq)
{
FILE *out_file;
char *p;
char filename[MAX_LOC+1];
LOCATION loc;
if (loc_name == NULL)
return (NULL);
if (CMcmpcase(create_or_append, ERx("c")) == 0)
{
STcopy(out_dir, filename);
LOfroms(PATH, filename, &loc);
/* if uniq is 1, create a unique filename */
if (uniq == 1)
LOuniq(out_filename, ERx(""), &loc);
else
LOfstfile(out_filename, &loc);
if (SIfopen(&loc, ERx("w"), SI_TXT, SI_MAX_TXT_REC, &out_file)
!= OK)
{
IIUGerr(E_RM00F2_Err_open_outfile, UG_ERR_ERROR, 1,
out_filename);
return (NULL);
}
LOtos(&loc, &p);
STcopy(p, loc_name);
}
else
{
LOfroms(PATH & FILENAME, loc_name, &loc);
if (SIfopen(&loc, ERx("a"), SI_TXT, SI_MAX_TXT_REC, &out_file)
!= OK)
{
IIUGerr(E_RM00F2_Err_open_outfile, UG_ERR_ERROR, 1,
out_filename);
return (NULL);
}
}
return (out_file);
}
/*
** create_comment ()
*/
STATUS
create_comment ()
{
STATUS ret_val ;
FILE *tmpf = NULL ;
if ((ret_val = bld_cmtName(msg)) != OK)
{
disp_line(msg, 0, 0);
}
else
{
if (SIfopen(cmtLoc, ERx("a"), SI_TXT, TERM_LINE, &tmpf) == OK)
{
SIclose(tmpf);
}
edit_file(cmtName);
fix_cursor();
TDclear(curscr);
TDtouchwin(mainW);
TDrefresh(mainW);
}
return (ret_val);
} /* end of create_comment */
/*
** Name: CFCreateConf
**
** Description:
** Create a configuration file.
**
** Inputs:
** path path to configuration file.
** filename filename of configuration file.
** begin Starting line of the confiuration
**
** Outputs:
** loc location structure updated.
**
** Returns:
** OK success
** FAIL failure
**
** History:
** 11-Feb-2000 (fanra01)
** Created.
*/
STATUS
CFCreateConf( char* path, char* filename, LOCATION* loc, PRL begin )
{
STATUS status;
char* locpath;
FILE* fptr;
PRL entry = begin;
i4 count;
/*
** Get the location path
*/
LOtos( loc, &locpath );
STRCOPY(path, locpath );
if ((status = LOfroms( PATH, locpath, loc )) == OK)
{
LOfstfile( filename, loc );
if ((status = SIfopen( loc, "w", SI_TXT, 0, &fptr )) == OK)
{
while ((status == OK) && (entry != NULL))
{
status = SIwrite( STRLENGTH(entry->text), entry->text, &count,
fptr );
entry = entry->next;
}
SIclose( fptr );
}
else
{
PRINTF( "Error: %d - Unable to open file %s in %s.\n", status,
filename, path );
}
}
return (status);
}
/*
** Name: CFWriteConf
**
** Description:
** Write out the configuration file.
**
** Inputs:
** loc location to write configuration
** begin starting line of configuration
**
** Outputs:
** none
**
** Returns:
** OK success
** FAIL failure
**
** History:
** 11-Feb-2000 (fanra01)
** Created.
*/
STATUS
CFWriteConf( LOCATION* loc, PRL begin )
{
STATUS status = OK;
PRL entry = begin;
FILE* fptr;
i4 count;
if ((status=SIfopen( loc, "w", SI_TXT, 0, &fptr )) == OK)
{
while (entry != NULL)
{
status = SIwrite( STRLENGTH( entry->text ), entry->text, &count,
fptr );
entry = entry->next;
}
SIclose( fptr );
}
else
{
char* tmp = NULL;
LOtos( loc, &tmp );
PRINTF( "Error: %d - Unable to open file %s.\n", status, tmp );
}
return (status);
}
/*{
** Name: open_infile - open a template file
**
** Description:
** Opens a template file from a directory.
**
** Inputs:
** directory - template directory
** template_filename - input template file name
**
** Outputs:
** none
**
** Returns:
** NULL - open failed
** FILE * - file pointer
*/
FILE *
open_infile(
char *directory,
char *template_filename)
{
FILE *in_file;
char *p;
char filename[MAX_LOC+1];
LOCATION loc;
if (template_filename == NULL || *template_filename == EOS)
{
IIUGerr(E_RM00EE_Null_empty_arg, UG_ERR_ERROR, 1,
ERx("open_infile"));
return (NULL);
}
STcopy(directory, filename);
LOfroms(PATH, filename, &loc);
LOfstfile(template_filename, &loc);
if (SIfopen(&loc, ERx("r"), SI_TXT, SI_MAX_TXT_REC, &in_file) != OK)
{
LOtos(&loc, &p);
IIUGerr(E_RM00F1_Err_open_template, UG_ERR_ERROR, 1, p);
return (NULL);
}
return (in_file);
}
/*{
** Name: RSblob_gcCallback - IIapi_getColumns callback for blobs
**
** Description:
** If the blob is smaller than DB_MAXTUP-2 bytes, set the blob size and
** return. Otherwise, open a temporary file in II_TEMPORARY and write the
** blob segments to it.
**
** Inputs:
** closure - closure (unused)
** parmBlock - IIAPI_GETCOLPARM parameter block
**
** Outputs:
** RS_BLOB buffer is updated.
**
** Returns:
** none
*/
II_VOID II_FAR II_CALLBACK
RSblob_gcCallback(
II_PTR closure,
II_PTR parmBlock)
{
IIAPI_GETCOLPARM *gcolParm = (IIAPI_GETCOLPARM *)parmBlock;
RS_BLOB *blob =
(RS_BLOB *)gcolParm->gc_columnData[0].dv_value;
LOCATION loc;
char *p;
i4 cnt;
if (!blob->fp && !blob->size)
{
/*
** If this is the only segment, just set the size from the
** length.
*/
if (!gcolParm->gc_moreSegments)
{
blob->size = blob->len;
return;
}
/*
** If there are more segments and the file hasn't been opened,
** create a new temporary file.
*/
NMloc(TEMP, PATH, NULL, &loc);
LOuniq(ERx("bl"), ERx("tmp"), &loc);
LOtos(&loc, &p);
STcopy(p, blob->filename);
if (SIfopen(&loc, ERx("w"), SI_VAR, sizeof blob->buf, &blob->fp)
!= OK)
{
gcolParm->gc_genParm.gp_status = IIAPI_ST_OUT_OF_MEMORY;
return;
}
}
/* write the current segment to a file and add to the size */
if (SIwrite((i4)blob->len, blob->buf, &cnt, blob->fp) != OK)
{
gcolParm->gc_genParm.gp_status = IIAPI_ST_OUT_OF_MEMORY;
return;
}
blob->size += blob->len;
/* if this is the last segment, close the temporary file */
if (!gcolParm->gc_moreSegments)
{
if (SIclose(blob->fp) != OK)
{
gcolParm->gc_genParm.gp_status = IIAPI_ST_OUT_OF_MEMORY;
return;
}
blob->fp = NULL;
}
}
/*
** Name: CFReadConf
**
** Description:
** Read the configuration file a line at a time and build a list.
**
** Inputs:
** path path of file to read
** filename filename of file to read
**
** Outputs:
** loc Location to update with path and filename
** begin Starting line of the confiuration
** end Last line of the configuration
**
** Returns:
** OK success
** FAIL failure
**
** History:
** 11-Feb-2000 (fanra01)
** Created.
*/
STATUS
CFReadConf( char* path, char* filename, LOCATION* loc, PRL* begin )
{
STATUS status;
char* locpath;
FILE* fptr;
PRL newline;
PRL end;
/*
** Get the location path
*/
LOtos( loc, &locpath );
STRCOPY( path, locpath );
if ((status = LOfroms( PATH, locpath, loc )) == OK)
{
LOfstfile( filename, loc );
if ((status = SIfopen( loc, "r", SI_TXT, 0, &fptr )) == OK)
{
do
{
status = SIgetrec( readbuf, SI_MAX_TXT_REC, fptr );
if (status != ENDFILE)
{
HALLOC( newline, RL, 1, &status );
if (newline != NULL)
{
newline->text = STRALLOC( readbuf );
if (*begin == NULL)
{
*begin = newline;
newline->prev = newline;
}
else
{
end = (*begin)->prev;
end->next = newline;
newline->prev = end;
(*begin)->prev = newline;
}
}
}
}while (status == OK);
status = ((status == ENDFILE) || (status == OK)) ? OK : status;
SIclose( fptr );
}
else
{
PRINTF( "Error: %d - Unable to open file %s in %s.\n", status,
filename, path );
}
}
return (status);
}
/*{
** Name: RSblob_ppCallback - IIsw_putParms callback for blobs
**
** Description:
** If the blob is smaller than DB_MAXTUP-2 bytes, set the blob size and
** return. Otherwise, open a temporary file in II_TEMPORARY and write the
** blob segments to it.
**
** Inputs:
** closure - closure (unused)
** parmBlock - IIAPI_PUTPARMPARM parameter block
**
** Outputs:
** RS_BLOB buffer is updated.
**
** Returns:
** none
*/
II_VOID II_FAR II_CALLBACK
RSblob_ppCallback(
II_PTR closure,
II_PTR parmBlock)
{
IIAPI_PUTPARMPARM *putParm = (IIAPI_PUTPARMPARM *)parmBlock;
RS_BLOB *blob =
(RS_BLOB *)putParm->pp_parmData[0].dv_value;
LOCATION loc;
i4 cnt;
STATUS status;
if (!blob->fp)
{
/* If there is only one segment, indicate this and return */
if (blob->size <= sizeof blob->buf)
{
putParm->pp_moreSegments = FALSE;
return;
}
/* Open the temporary file */
LOfroms(PATH & FILENAME, blob->filename, &loc);
if (SIfopen(&loc, ERx("r"), SI_VAR, sizeof blob->buf, &blob->fp)
!= OK)
{
putParm->pp_genParm.gp_status = IIAPI_ST_OUT_OF_MEMORY;
return;
}
}
/*
** Read the next segment from the file. If it's the last segment, close
** the temporary file.
*/
status = SIread(blob->fp, sizeof blob->buf, &cnt, blob->buf);
putParm->pp_moreSegments = TRUE;
blob->len = (short)cnt;
if (status == ENDFILE)
{
SIclose(blob->fp);
blob->fp = NULL;
putParm->pp_moreSegments = FALSE;
LOfroms(PATH & FILENAME, blob->filename, &loc);
LOdelete(&loc);
}
else if (status != OK)
{
putParm->pp_genParm.gp_status = IIAPI_ST_OUT_OF_MEMORY;
}
}
void
yyinit( void )
{
char *name, *value, *map_path;
/* zero the line counter */
yylineno = 0;
if( rulemap_path == NULL )
{
NMloc( FILES, FILENAME, ERx( "default.rfm" ), &loc );
LOcopy( &loc, file_name, &loc );
LOtos( &loc, &map_path );
}
else
{
STcopy( rulemap_path, file_name );
LOfroms( FILENAME, file_name, &loc );
map_path = rulemap_path;
}
(void) PMmInit( &rulemap );
if( PMmLoad( rulemap, &loc, PMerror ) != OK )
PCexit( FAIL );
/* initiate scan of rule map */
if( PMmScan( rulemap, ERx( ".*" ), &rfm_scan, NULL, &name, &value )
!= OK )
{
F_ERROR( "Rule file map %s is empty.", map_path );
}
/* set up LOCATION of first rule file */
STcopy( value, file_name );
NMloc( FILES, FILENAME, file_name, &loc );
LOcopy( &loc, file_name, &loc );
/* initialize input pointer */
yyp = &dummy;
/* open rule file */
if( SIfopen( &loc, ERx( "r" ), SI_TXT, SI_MAX_TXT_REC, &yyin )
!= OK && yywrap() )
{
ERROR( "No configuration rule files were found." );
}
}
static bool
yywrap( void )
{
char *name, *value;
/* initialize the line counter */
yylineno = -1;
while( TRUE )
{
/* get the name of next rule specification to be loaded */
if( PMmScan( rulemap, NULL, &rfm_scan, NULL, &name,
&value ) != OK )
{
if( yyin != (FILE *) NULL )
(void) SIclose( yyin );
return( TRUE ); /* no more files */
}
/* set up LOCATION of rule file */
STcopy( value, file_name );
NMloc( FILES, FILENAME, file_name, &loc );
LOcopy( &loc, file_name, &loc );
if( yyin != (FILE *) NULL )
{
(void) SIclose( yyin );
yyin = (FILE *) NULL;
}
/* try to open rule file */
if( SIfopen( &loc, ERx( "r" ), SI_TXT, SI_MAX_TXT_REC, &yyin )
== OK && SIgetrec( yybuf, sizeof( yybuf ), yyin )
== OK )
{
break;
}
}
/* initialize input pointer */
yyp = &dummy;
/* another file was opened - so we're not done yet */
return( FALSE );
}
STATUS
MO_oidmap_set(i4 offset,
i4 luserbuf,
char *userbuf,
i4 objsize,
PTR object )
{
FILE *fp;
STATUS cl_stat;
STATUS set_stat;
LOCATION loc;
char loc_buf[ MAX_LOC ];
char line[ SI_MAX_TXT_REC ];
char *words[ 2 ];
i4 wordcount;
SYSTIME new_time;
NMloc( FILES, FILENAME, userbuf, &loc );
LOcopy( &loc, loc_buf, &loc );
cl_stat = LOlast( &loc, &new_time );
/* If it's a new file, or old one has changed, read it */
if( OK == cl_stat && (STcompare( userbuf, MO_oid_map ) ||
new_time.TM_secs > MO_map_time.TM_secs ))
{
STcopy( userbuf, MO_oid_map );
MO_map_time = new_time;
cl_stat = SIfopen( &loc , ERx( "r" ), SI_TXT, (i4) SI_MAX_TXT_REC, &fp );
if( cl_stat == OK )
{
while( SIgetrec( line, (i4) SI_MAX_TXT_REC, fp ) == OK )
{
wordcount = 2;
STgetwords( line, &wordcount, words );
if( words[0][0] != '#' && wordcount >= 2 )
cl_stat = MOset( ~0, MO_META_OID_CLASS, words[0], words[1] );
}
SIclose( fp );
}
}
return( cl_stat );
}
static bool
writeMgrFile( char *altPath )
{
char *dirPath;
char fullPath[OCFG_MAX_STRLEN];
FILE *pfile;
LOCATION loc;
STATUS status;
# ifdef VMS
NMgtAt(SYSTEM_LOCATION_VARIABLE,&dirPath); /* usually II_SYSTEM */
if (dirPath != NULL && *dirPath)
STlcopy(dirPath,fullPath,sizeof(fullPath)-20-1);
else
return (FALSE);
STcat(fullPath,"[");
STcat(fullPath,SYSTEM_LOCATION_SUBDIRECTORY); /* usually "ingres" */
STcat(fullPath,".files]");
STcat(fullPath,MGR_STR_FILE_NAME);
# else
NMgtAt(SYSTEM_LOCATION_VARIABLE,&dirPath); /* usually II_SYSTEM */
if (dirPath != NULL && *dirPath)
STlcopy(dirPath,fullPath,sizeof(fullPath)-20-1);
else
return (FALSE);
STcat(fullPath,"/");
STcat(fullPath,SYSTEM_LOCATION_SUBDIRECTORY); /* usually "ingres" */
STcat(fullPath,"/files/");
STcat(fullPath,MGR_STR_FILE_NAME);
# endif /* ifdef VMS */
if ( LOfroms(PATH & FILENAME, fullPath, &loc) != OK )
return FALSE;
if (SIfopen(&loc, "w", (i4)SI_TXT, OCFG_MAX_STRLEN, &pfile) != OK)
return FALSE;
if (altPath && *altPath)
SIfprintf(pfile,"%s=%s\n",MGR_STR_PATH,altPath);
SIfprintf(pfile,"%s=%s\n",MGR_STR_MANAGER,
driverManager == MGR_VALUE_UNIX_ODBC ?
MGR_STR_UNIX_ODBC : MGR_STR_CAI_PT);
return TRUE;
}
/*{
** Name: DIAGObjectRead - Read details from an object file
**
** Description:
** This routine locates the symbol table and list of loadable areas from
** an object file and remembers them for future use. (most of the work
** is done by the symbol and map routines this routine simply provides
** the required driving code). Uses the a.out format.
**
** Inputs:
** LOC *loc - Object file location
** i4 offset - ignored on HP
**
** Side effects:
** Keeps a file descriptor to the object file to allow areas of store
** to be read in as required
**
** Exceptions:
** Calls DIAGerror() function with errors
**
** History:
** 06-Nov-1998 (muhpa01)
** Created.
}*/
i4
DIAGObjectRead( LOCATION *loc, i4 offset )
{
FILHDR header;
FILE *fp;
i4 count;
/* Open the object file random access */
if ( SIfopen( loc, "r", SI_RACC, FILHSZ, &fp ) != OK )
DIAGerror( "DIAGObjectRead: Failed to open file \"%s\"\n",
loc->fname );
/* Read the object file header */
if ( SIread( fp, FILHSZ, &count, (PTR)&header ) != OK )
DIAGerror( "DIAGObjectRead: Failed to read object header\n" );
/* read the symbols from the object file */
DIAGSymbolRead( fp, &header, 0 );
SIclose( fp );
}
int
main(int argc, char* argv[])
{
time_t ltime;
time_t tm_0, tm_1;
char szIIdate[64];
char szCommandLineString[1024];
int i;
double dtime;
time( &tm_0 );
g_pLoadData = (LOADDATA*)malloc (sizeof(LOADDATA));
memset (g_pLoadData, 0, sizeof(LOADDATA));
memset (&g_ReadSizeEvent, 0, sizeof(g_ReadSizeEvent));
memset (&g_dataLoaderStruct, 0, sizeof (g_dataLoaderStruct));
g_dataLoaderStruct.nArraySize = 5;
g_dataLoaderStruct.arrayFiles = (INFILES*)malloc (g_dataLoaderStruct.nArraySize * sizeof(INFILES));
memset (&g_mutexWrite2Log, 0, sizeof (g_mutexWrite2Log));
szIIdate[0] = '\0';
if (!IsInputDateCompatible(szIIdate))
{
if (szIIdate[0])
DTSTRUCT_SetDateFormat(&g_dataLoaderStruct, szIIdate);
}
CreateDTLMutex(&g_mutexWrite2Log);
/*
** Construct the command line string from the argv[]
*/
szCommandLineString[0] = '\0';
for (i=1; i<argc; i++)
{
if (i>1)
STcat (szCommandLineString, " ");
STcat (szCommandLineString, argv[i]);
}
/*
** Parse the command line string and update the
** Data Loader structure:
*/
memset (&g_cmd, 0, sizeof (g_cmd));
if (szCommandLineString[0])
{
STATUS st;
LOCATION lf;
char* strFle = NULL;
int nOk = ParseCommandLine (szCommandLineString, &g_cmd);
if (nOk == 0)
{
free (g_pLoadData);
/*
** Command line syntax error:
*/
SIprintf("Command line syntax error !!!\n");
return 1;
}
else
{
/*
** Check the MANDATORY command line:
*/
char* strItem = CMD_GetVnode(&g_cmd);
if (strItem && !strItem[0])
{
free (g_pLoadData);
SIprintf("Command line option missing: the connection string <vnode> is mandatory.\n");
return 1;
}
strItem = CMD_GetControlFile(&g_cmd);
if (strItem && !strItem[0])
{
free (g_pLoadData);
SIprintf("Command line option missing: the control file is mandatory.\n");
return 1;
}
}
if (CMD_GetReadSize(&g_cmd) > 0)
g_lReadSize = CMD_GetReadSize(&g_cmd);
/*
** Create the log file if needed:
*/
strFle = CMD_GetLogFile(&g_cmd);
if (!strFle || !strFle[0])
{
char szBuff[1024];
char* pFound;
STcopy (CMD_GetControlFile(&g_cmd), szBuff);
pFound = STrindex (szBuff, ".ctl", -1);
if (pFound && (STlength (pFound) == 4) && STcompare(pFound, ".ctl") == 0)
{
pFound[0] = '\0';
STcat (szBuff, ".log");
CMD_SetLogFile(&g_cmd, szBuff);
}
}
else
{
char szBuff[1024];
char* pFound;
STcopy (CMD_GetLogFile(&g_cmd), szBuff);
pFound = STrindex (szBuff, ".", -1);
if (!pFound) /* if logfile has no extension then add a .log extension */
{
STcopy (strFle, szBuff);
STcat (szBuff, ".log");
CMD_SetLogFile(&g_cmd, szBuff);
}
}
LOfroms (PATH&FILENAME, strFle, &lf);
st = SIfopen (&lf, "w", SI_TXT, DT_SI_MAX_TXT_REC, &g_fLogFile);
if (st != OK)
{
g_fLogFile = NULL;
SIprintf ("Failed to create log file\n");
}
time( <ime );
WRITE2LOG3("%s: Release %s - Production on %s\n\n", INGRES_DATA_LOADER, g_sVersion, ctime(<ime));
WRITE2LOG0("Copyright (C) 2005-2006 Ingres Corporation. All Rights Reserved.\n\n");
WRITE2LOG1("Control File:\t%s\n", CMD_GetControlFile(&g_cmd));
if (!g_mutexWrite2Log.nCreated)
{
E_WRITE2LOG1("%s: Failed to create the Mutex 'g_mutexWrite2Log' for writing log file\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
nOk = ParseControlFile(&g_dataLoaderStruct, &g_cmd);
if (nOk == 0)
{
E_WRITE2LOG1("%s: Syntax error in the control file.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
else
if (nOk == -1)
{
E_WRITE2LOG1("%s: Cannot open control file.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
else
{
int i;
int nErrorAccesInfile=0;
int nAllwithPosition=1;
int nWithPosition = 0;
int nPosError = 0;
int nMax=0;
int nWrongSep = 0;
FIELDSTRUCT* pField = &(g_dataLoaderStruct.fields);
FIELD* listField = pField->listField;
int* aSet = GetControlFileMandatoryOptionSet();
if (aSet[0] == 0)
{
E_WRITE2LOG1("%s: LOAD DATA is mandatory at the begining of the control file.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
if (aSet[1] == 0 || !DTSTRUCT_GetInfile(&g_dataLoaderStruct, 0))
{
E_WRITE2LOG1("%s: INFILE is mandatory in the control file.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
for (i=0; i<g_dataLoaderStruct.nFileCount; i++)
{
strFle = DTSTRUCT_GetInfile(&g_dataLoaderStruct, i);
if (access(strFle, 0) == -1)
{
nErrorAccesInfile = 1;
E_WRITE2LOG2("%s: INFILE '%s' cannot be accessed.\n", INGRES_DATA_LOADER, strFle);
}
}
if (nErrorAccesInfile == 1)
{
CleanVariables();
return 1;
}
if (aSet[5] == 0 || STlength (DTSTRUCT_GetTable(&g_dataLoaderStruct)) == 0)
{
E_WRITE2LOG1("%s: INTO TABLE <table>, a table name is mandatory in the control file.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
if (aSet[6] == 0)
{
E_WRITE2LOG1("%s: APPEND key word is mandatory in the control file.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
if (aSet[8] == 0)
{
E_WRITE2LOG1("%s: The table columns must be specified in the control file.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
if (g_dataLoaderStruct.fields.szTerminator[0] && g_dataLoaderStruct.fields.szTerminator[0] == '\n')
nWrongSep = 1;
if (listField)
{
int p1 = 0, p2 = 0;
while (listField)
{
if (listField->szTerminator[0] && strcmp (listField->szTerminator, "\\n") == 0)
nWrongSep = 1;
if (listField->pos1 <= p2)
nPosError = 1;
p1 = listField->pos1;
p2 = listField->pos2;
if (listField->pos1 <= 0 || listField->pos2 <= 0)
nPosError = 1;
if (listField->pos1 > listField->pos2 )
nPosError = 1;
if (listField->pos2 > nMax)
nMax = listField->pos2;
if (listField->pos1 == 0 && listField->pos2 == 0)
{
listField = listField->next;
nAllwithPosition = 0;
continue;
}
nWithPosition = 1;
listField = listField->next;
}
}
if (nWrongSep == 1)
{
E_WRITE2LOG1("%s: You should not use the '\\n' as field separator.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
for (i=0; i<g_dataLoaderStruct.nFileCount; i++)
{
int j;
if ((i>0) && (DTSTRUCT_GetFixLength(&g_dataLoaderStruct, 0) != DTSTRUCT_GetFixLength(&g_dataLoaderStruct, i)))
{
E_WRITE2LOG1("%s: FIX n, fixed record length must be the same for all INFILE clauses.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
/*
** Check if there are multiple bad files with the same name:
*/
for (j=i+1; j<g_dataLoaderStruct.nFileCount;j++)
{
if (stricmp (g_dataLoaderStruct.arrayFiles[i].badfile, g_dataLoaderStruct.arrayFiles[j].badfile)==0)
{
E_WRITE2LOG1("%s: Multiple bad files with the same name. You should specify different BADFILE for each INFILE.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
}
}
if (DTSTRUCT_GetFixLength(&g_dataLoaderStruct, 0) > 0)
{
if (nWithPosition && !nAllwithPosition)
{
E_WRITE2LOG1("%s: FIX n, fixed record length is specified, if you use POSITION (n, p) then all columns must use the POSITION.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
if (nPosError == 1)
{
E_WRITE2LOG1("%s: If you use POSITION (n, p) then n, p should be > 0.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
if (nMax > DTSTRUCT_GetFixLength(&g_dataLoaderStruct, 0))
{
E_WRITE2LOG1("%s: In the last POSITION (n, p), p should be <= FIX value.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
}
else
{
if (nWithPosition == 1)
{
E_WRITE2LOG1("%s: If you use POSITION (n, p) then you should also specify FIX value.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
}
if (FIELDSTRUCT_GetColumnCount (pField) <= 0)
{
E_WRITE2LOG1("%s: The list of columns should be specified.\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
}
for (i=0; i<g_dataLoaderStruct.nFileCount; i++)
{
WRITE2LOG1("Data File:\t%s\n", DTSTRUCT_GetInfile(&g_dataLoaderStruct, i));
if (DTSTRUCT_GetFixLength(&g_dataLoaderStruct, i) > 0)
WRITE2LOG1(" File processing option string: \"fix %d\"\n", DTSTRUCT_GetFixLength(&g_dataLoaderStruct, i));
WRITE2LOG1(" Bad File:\t%s\n", DTSTRUCT_GetBadfile(&g_dataLoaderStruct, i));
if (DTSTRUCT_GetDiscardFile(&g_dataLoaderStruct, i))
WRITE2LOG1(" Discard File:\t%s\n", DTSTRUCT_GetDiscardFile(&g_dataLoaderStruct, i));
}
WRITE2LOG1(" (Allow %d discards)\n", DTSTRUCT_GetDiscardMax(&g_dataLoaderStruct));
WRITE2LOG0("\n\n");
WRITE2LOG1("Table %s\n", DTSTRUCT_GetTable(&g_dataLoaderStruct));
WRITE2LOG0("Insert option in effect for this table: APPEND\n");
/*
WRITE2LOG1("Load to Table:\t%s\n", DTSTRUCT_GetTable(&g_dataLoaderStruct));
WRITE2LOG1("Read Size:\t%d\n", g_lReadSize);
WRITE2LOG1("Parallel:\t%c\n", (CMD_GetParallel(&g_cmd) == 1)? 'Y': 'N');
*/
if (!CheckForKnownDateFormat())
E_WRITE2LOG1("%s: The setting value of II_DATE_FORMAT is unknown.\n", INGRES_DATA_LOADER);
memset (&g_mutexLoadData, 0, sizeof (DTLMUTEX));
if (!CreateDTLMutex(&g_mutexLoadData))
{
E_WRITE2LOG1("%s: Failed to create the Mutex 'g_mutexLoadData'\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
if (!CreateReadsizeEvent(&g_ReadSizeEvent))
{
E_WRITE2LOG1 ("%s: Failed to create the Readsize Condition 'g_ReadSizeEvent'\n", INGRES_DATA_LOADER);
CleanVariables();
return 1;
}
/*
** Create the session:
*/
nOk = INGRESII_llConnectSession(CMD_GetVnode(&g_cmd));
if (nOk == 0) /* SQL Error */
{
char* strError = INGRESII_llGetLastSQLError();
if (strError && strError[0])
/* Error while connecting to the DBMS:*/
WRITE2LOG0(strError);
CleanVariables();
return 1;
}
for (i=0; i<g_dataLoaderStruct.nFileCount; i++)
{
/*
** Start the thread that reads the input data file and
** puts the data in the FIFO queue:
*/
StartInputReaderThread(&g_dataLoaderStruct);
/*
** The main thread begins a loop reading the data
** from the FIFO queue, transfer the data to the DBMS by
** using the COPY INTO callback program:
*/
nOk = StartTransferDataThread(&g_dataLoaderStruct);
if (nOk == 0) /* SQL Error */
{
char* strError = INGRESII_llGetLastSQLError();
if (strError && strError[0])
WRITE2LOG0 (strError);
}
g_dataLoaderStruct.nCurrent++;
memset (g_pLoadData, 0, sizeof(LOADDATA));
}
nOk = INGRESII_llDisconnectSession(1, 1);
if (nOk == 0) /* SQL Error */
{
char* strError = INGRESII_llGetLastSQLError();
if (strError && strError[0])
WRITE2LOG0 (strError);
}
}
else
{
SIprintf("Usage: \tdataldr [vnode::]dbname[/serverclass] control=controlfile\n");
SIprintf("\t[log=logfile][parallel=y] [direct=y] [readsize=value]");
}
time( &tm_1 );
dtime = difftime (tm_1, tm_0);
WRITE2LOG0("\n\n");
WRITE2LOG1("Run began on %s", ctime(&tm_0));
WRITE2LOG1("Run ended on %s\n", ctime(&tm_1));
WRITE2LOG0("\n\n");
Time2Chars(dtime, szIIdate);
WRITE2LOG1("Elapsed time was: %s\n", szIIdate);
STcopy ("00:00:00", szIIdate);
if ((g_lCpuEnded - g_lCpuStarted) >= 0)
{
double ds = 0.0, d1;
int lms = g_lCpuEnded - g_lCpuStarted;
while (lms >=1000)
{
lms -= 1000;
ds += 1.0;
}
d1 = (double)lms / 10.0; /* 1/100 s == 10 ms */
d1 = d1 / 100.0; /* into the seconds */
ds += d1;
Time2Chars(ds, szIIdate);
}
WRITE2LOG1("CPU time was: %s\n", szIIdate);
/*
** Free the structure before exiting:
*/
CleanVariables();
return 0;
}
VOID
gca_save( GCA_SVC_PARMS *svc_parms )
{
GCA_ACB *acb = svc_parms->acb;
GCA_SV_PARMS *sv_parms = (GCA_SV_PARMS *)svc_parms->parameter_list;
GCA_SAVE_DATA save_data;
PTR user_buf = sv_parms->gca_ptr_user_data;
i4 user_size = sv_parms->gca_length_user_data;
char cl_buf[ GCA_MAX_CL_SAVE_SIZE ];
i4 cl_size;
LOCATION file_loc;
LOCATION tmp_loc;
char loc_buf[ MAX_LOC ];
FILE *save_file;
char *save_ptr;
char file_id[ MAX_LOC ];
i4 j;
/* Initialize status in service invoker's parameter list */
sv_parms->gca_status = E_GCFFFF_IN_PROCESS;
/* Get CL save info */
svc_parms->gc_parms.svc_buffer = (PTR)cl_buf;
svc_parms->gc_parms.reqd_amount = sizeof( cl_buf );
GCsave( &svc_parms->gc_parms );
if ( svc_parms->gc_parms.status != OK )
goto complete;
cl_size = svc_parms->gc_parms.rcv_data_length;
/* Format GCA_SAVE_DATA structure */
save_data.save_level_major = GCA_SAVE_LEVEL_MAJOR;
save_data.save_level_minor = GCA_SAVE_LEVEL_MINOR;
save_data.cl_save_size = cl_size;
save_data.user_save_size = user_size;
save_data.assoc_id = acb->assoc_id;
save_data.size_advise = acb->size_advise;
save_data.heterogeneous = acb->flags.heterogeneous;
/* Create the save file name. */
file_id[0] = '\0';
(VOID) LOfroms(PATH & FILENAME, file_id, &tmp_loc);
(VOID) LOuniq("IIGC", "TMP", &tmp_loc);
(VOID) NMloc(TEMP, FILENAME, file_id, &tmp_loc);
(VOID) LOcopy( &tmp_loc, loc_buf, &file_loc );
(VOID) LOtos( &file_loc, &save_ptr );
(VOID) STcopy( save_ptr, sv_parms->gca_save_name );
/* Open save file. */
if( SIfopen( &file_loc, "w", SI_VAR, 0, &save_file ) != OK )
{
GCA_DEBUG_MACRO(1)( "gca_send bad file open\n" );
svc_parms->gc_parms.status = E_GC0014_SAVE_FAIL;
goto complete;
}
/* Write GCA, CL, and user data to save file. */
if( SIwrite( sizeof( save_data ), (PTR)&save_data, &j, save_file ) != OK
|| cl_size && SIwrite( cl_size, (PTR)cl_buf, &j, save_file ) != OK
|| user_size && SIwrite( user_size, user_buf, &j, save_file ) != OK
|| SIclose( save_file ) != OK )
{
GCA_DEBUG_MACRO(1)( "gca_send bad file write/close\n" );
(VOID) SIclose( save_file );
(VOID) LOdelete( &file_loc );
svc_parms->gc_parms.status = E_GC0014_SAVE_FAIL;
}
complete:
return;
}
i4
main(
i4 argc,
char * argv[])
{
char c='\0';
char *tz_file=NULL;
char *tz_name=NULL;
char *tz_def;
char tzname[TM_MAX_TZNAME+1];
char tzfile[MAX_LOC+1];
char ioptarg[MAX_LOC + 1];
char tz_pmvalue[MAX_LOC + 1];
char tz_pmname[MAX_LOC + 1];
char *p, *ip, *pm_value;
char *tm_tztype;
char chr='/';
char *out_file;
i4 ioptind=1, i;
char *tm_tztime;
i4 timecnt, tempi, temptype, temptz;
char buf[sizeof(TM_TZ_CB)+TM_MAX_TIMECNT*(sizeof(i4)+1)];
FILE *fid;
LOCATION loc_root, tmp_loc;
STATUS status=OK;
TM_TZ_CB *tm_tz_cb;
struct timevect time_v;
appname = argv[0];
if( TMtz_getopt(argc, argv, "n:name:f:file", &ioptind, ioptarg, &c) == OK)
{
switch (c)
{
case 'f':
tz_file = ioptarg;
break;
case 'n':
tz_name = ioptarg;
break;
default:
break;
}
}
else
{
TMtz_usage();
PCexit(FAIL);
}
if( tz_file == NULL)
{
if( tz_name == NULL)
{
/* Get II_TIMEZONE_NAME value */
NMgtAt(ERx("II_TIMEZONE_NAME"), &tz_def);
if (!tz_def || !(*tz_def))
{
SIprintf("%s: %s_TIMEZONE_NAME is not set\n",
appname, SystemVarPrefix);
PCexit(FAIL);
}
STncpy(tzname, tz_def, TM_MAX_TZNAME);
tzname[ TM_MAX_TZNAME ] = EOS;
}
else
{
STncpy(tzname, tz_name, TM_MAX_TZNAME);
tzname[ TM_MAX_TZNAME ] = EOS;
}
PMinit();
if( PMload( NULL, (PM_ERR_FUNC *)NULL) != OK)
{
SIprintf("%s: Error loading PM %s_CONFIG/config.dat file\n",
appname, SystemVarPrefix);
PCexit(FAIL);
}
/* Get timezone file name */
STprintf( tz_pmname, ERx("%s.*.tz.%s"), SystemCfgPrefix, tzname);
if( PMget( tz_pmname, &pm_value) != OK)
{
SIprintf("%s: Error locating %s in PM config.dat file\n",
appname, tz_pmname);
PCexit(FAIL);
}
do
{
if((status = NMloc(FILES, PATH, ERx("zoneinfo"), &loc_root)) != OK)
break;
#if defined(conf_BUILD_ARCH_32_64) && defined(BUILD_ARCH64)
if((status = LOfaddpath(&loc_root, ERx("lp64"), &loc_root)) != OK)
break;
#endif
#if defined(conf_BUILD_ARCH_64_32) && defined(BUILD_ARCH32)
{
/*
** Reverse hybrid support must be available in ALL
** 32bit binaries
*/
char *rhbsup;
NMgtAt("II_LP32_ENABLED", &rhbsup);
if ( (rhbsup && *rhbsup) &&
( !(STbcompare(rhbsup, 0, "ON", 0, TRUE)) ||
!(STbcompare(rhbsup, 0, "TRUE", 0, TRUE))))
status = LOfaddpath(&loc_root, "lp32", &loc_root);
}
#endif /* reverse hybrid */
STcopy( pm_value, tz_pmvalue);
/*
** Compose the directory path
*/
for( p = tz_pmvalue, ip = tz_pmvalue;
(p = STchr(ip, chr)) != NULL;)
{
*p = EOS;
if((status = LOfaddpath(&loc_root, ip, &loc_root)) != OK)
break;
ip = CMnext(p);
}
/*
** Add file name to the directory path
*/
if((status = LOfroms(FILENAME, ip, &tmp_loc)) != OK)
break;
status = LOstfile( &tmp_loc, &loc_root);
} while( FALSE);
if( status != OK)
{
SIprintf("%s: Error composing timezone file name for %s\n",
appname, tz_pmvalue);
PCexit(FAIL);
}
}
else
{
STcopy("<unknown>", tzname);
STncpy( tzfile, tz_file, MAX_LOC);
tzfile[ MAX_LOC ] = EOS;
if( LOfroms(FILENAME&PATH, tzfile, &loc_root) != OK)
{
SIprintf("%s: Error composing timezone file name for %s\n",
appname, tz_pmvalue);
PCexit(FAIL);
}
}
/*
** Now open the timezone information file
*/
do
{
if((status = SIfopen( &loc_root, ERx("r"), SI_VAR, sizeof buf, &fid))
!= OK)
break;
status = SIread(fid, sizeof buf, &i, buf);
status = SIclose(fid);
} while(FALSE);
if( status != OK)
{
LOtos( &loc_root, &out_file);
SIprintf("%s: Error opening %s for timezone %s\n",
appname, out_file, tzname);
PCexit(FAIL);
}
tm_tz_cb = (TM_TZ_CB *)&buf;
I4ASSIGN_MACRO( tm_tz_cb->timecnt, timecnt);
/* Make sure the input file has correct file size */
if( timecnt > TM_MAX_TIMECNT || timecnt < 0
|| i != sizeof(TM_TZ_CB) + timecnt*(sizeof(i4)+1))
{
LOtos( &loc_root, &out_file);
SIprintf(
"%s: Invalid file format for timezone file %s for timezone %s\n",
appname, out_file, tzname);
SIprintf(
" File size: %d, Expected file size: %d, time periods: %d\n",
i, sizeof(TM_TZ_CB) + timecnt*(sizeof(i4)+1),
timecnt);
PCexit(FAIL);
}
/* Now we are all set to display the content of timezone information file */
LOtos( &loc_root, &out_file);
SIprintf("\n\n");
SIprintf("timezone name: %s\n", tzname);
SIprintf("timezone file: %s\n", out_file);
SIprintf("-------------------------------------");
SIprintf("-------------------------------------\n");
if(timecnt == 0)
{
I4ASSIGN_MACRO( tm_tz_cb->tzinfo[0].gmtoff, tempi);
SIprintf(" Fixed GMT offset (secs): %d\n", tempi);
}
else
{
SIprintf("\tPeriod Begin");
SIprintf("\t\tGMT offset\n");
SIprintf("\t(YYYY_MM_DD HH:MM)");
SIprintf("\t(Minute)\n\n");
tm_tztype = buf + sizeof(TM_TZ_CB);
tm_tztime = tm_tztype + timecnt;
i=0;
while( i < timecnt)
{
I4ASSIGN_MACRO( *tm_tztime, tempi);
/* Adjust for timezone */
if( i == 0)
temptype = (i4)tm_tztype[i+1];
else
temptype = (i4)tm_tztype[i-1];
I4ASSIGN_MACRO( tm_tz_cb->tzinfo[temptype].gmtoff, temptz);
/* Get real timezone */
tempi += temptz;
temptype = (i4)tm_tztype[i];
I4ASSIGN_MACRO( tm_tz_cb->tzinfo[temptype].gmtoff, temptz);
TMtz_cvtime( tempi, &time_v);
SIprintf("\t%04d_%02d_%02d %02d:%02d\t%d\t%s\n",
time_v.tm_year+1900,
time_v.tm_mon+1,
time_v.tm_mday,
time_v.tm_hour,
time_v.tm_min,
temptz/60,
tm_tz_cb->tzlabel + tm_tz_cb->tzinfo[temptype].abbrind);
tm_tztime += sizeof(i4);
i++;
}
}
PCexit(OK);
}
main(int argc, char **argv)
{
STATUS status = OK;
VMS_STATUS vStatus;
char srcbuf[NAME_FILE_SIZE];
char dstbuf[NAME_FILE_SIZE];
char delFile[NAME_FILE_SIZE];
struct dsc$descriptor_s filename_d =
{ sizeof (delFile) - 1,
DSC$K_DTYPE_T,
DSC$K_CLASS_S,
delFile
};
FILE *srcFile = NULL;
FILE *dstFile = NULL;
FILE *nameFile = NULL;
LOCATION loc;
bool clusterArg = FALSE;
bool unclusterArg = FALSE;
bool writeOutput = FALSE;
bool validSyntax;
bool clustered = FALSE;
bool v1DecryptErr = FALSE;
bool rewrite = FALSE;
bool isLogin = FALSE;
i4 total_recs = 0;
char local_host[MAX_LOC+CM_MAXATTRNAME];
char config_host[MAX_LOC+CM_MAXATTRNAME];
i2 i,j;
i4 active_rec;
i4 offset;
char *onOff = NULL;
bool srcOpened=FALSE;
bool dstOpened=FALSE;
bool printable = TRUE;
GCN_QUEUE *gcn_q;
GCN_QUEUE *merge_q;
i4 rec_len = 0;
QUEUE *q;
u_i1 local_mask[ 8 ]; /* Must be 8 bytes */
char name[MAX_LOC+CM_MAXATTRNAME];
i4 count;
char *p = NULL;
i4 dcryptFail = 0;
i2 pc;
char *pv[ 3 ];
GCN_DB_REC0 tmp_rec;
SYSTIME timestamp;
MEadvise(ME_INGRES_ALLOC);
SIeqinit();
GChostname( local_host, sizeof(local_host));
STcopy (PMhost(), config_host);
if (argc == 1)
validSyntax = TRUE;
/*
** Parse input arguments.
*/
for (i = 1; i < argc; i++)
{
validSyntax = FALSE;
for (j = 0; j < argLen; j++)
{
if (!STncasecmp(arg[j],argv[i], STlength(argv[i])))
{
switch(j)
{
case HELP1:
case HELP2:
case HELP3:
case HELP4:
usage();
break;
case VERBOSE:
validSyntax = TRUE;
verboseArg = TRUE;
break;
case CLUSTER:
validSyntax = TRUE;
clusterArg = TRUE;
writeOutput = TRUE;
break;
case UNCLUSTER:
validSyntax = TRUE;
unclusterArg = TRUE;
writeOutput = TRUE;
break;
}
} /* if (!STncasecmp(arg[j],argv[i], STlength(argv[i]))) */
if (validSyntax)
break;
} /* for (j = 0; j < argLen; j++) */
if (!validSyntax)
break;
} /* for (i = 1; i < argc; i++) */
if (!validSyntax)
{
usage();
PCexit(1);
}
if (clusterArg && unclusterArg)
{
SIprintf("Cannot specify both -c and -u\n\n");
usage();
PCexit(1);
}
if (verboseArg)
SIprintf("Local host is %s\n", local_host);
/*
** Generate key seeds for encoding and decoding.
*/
STpolycat( 2, GCN_LOGIN_PREFIX, local_host, name );
gcn_init_mask( name, sizeof( local_mask ), local_mask );
QUinit(&gcn_qhead);
QUinit(&merge_qhead);
PMinit();
/*
** See if this is a clustered installation. If it is,
** the node, login, and attribute files have no file extension.
*/
if ( PMload( (LOCATION *)NULL, (PM_ERR_FUNC *)NULL ) != OK )
{
SIprintf("Error reading config.dat, exiting\n");
goto cvt_exit;
}
PMsetDefault( 0, SystemCfgPrefix );
PMsetDefault( 1, config_host );
PMsetDefault( 2, ERx("gcn") );
status = PMget( ERx("!.cluster_mode"), &onOff);
if (onOff && *onOff)
;
else
onOff = "OFF";
if (verboseArg)
SIprintf("Cluster mode is %s\n", onOff);
if (!clusterArg && !unclusterArg)
clustered = !STncasecmp(onOff, "ON", STlength(onOff));
/*
** Rewrite the named GCN files. For clustered installations, the
** node, login and attribute files have no hostname extension.
*/
for ( i = 0; i < NBR_NAMED_FILES; i++ )
{
/*
** Ticket files are simply deleted.
*/
if (i == IILTICKET || i == IIRTICKET)
{
STprintf(delFile, "II_SYSTEM:[INGRES.FILES.NAME]II%s*;*",
named_file[i].file);
if (verboseArg)
SIprintf("Deleting %s\n", delFile);
filename_d.dsc$w_length = STlength(delFile);
vStatus = lib$delete_file(&filename_d,0,0,0,0,0,0,0,0,0);
if (!vStatus & STS$M_SUCCESS)
SIprintf("delete of %s failed, status is 0x%d\n", delFile,
vStatus);
continue;
}
rewrite = FALSE;
if (!clusterArg && !unclusterArg)
writeOutput = FALSE;
if ( ( status = NMloc( FILES, PATH & FILENAME,
(char *)NULL, &loc ) ) != OK )
{
SIprintf("iicvtgcn: Could not find II_SYSTEM:[ingres.files]\n");
goto cvt_exit;
}
LOfaddpath( &loc, "name", &loc );
if (clustered || unclusterArg)
{
if (named_file[i].add_cluster_node)
STprintf( srcbuf, "II%s_%s", named_file[i].file,config_host);
else
STprintf(srcbuf, "II%s", named_file[i].file);
}
else
STprintf( srcbuf, "II%s_%s", named_file[i].file,config_host);
if (verboseArg)
SIprintf("Opening %s for input\n", srcbuf);
LOfstfile( srcbuf, &loc );
/*
** Ignore non-existent files.
*/
if ( LOexist( &loc ) != OK )
{
if (verboseArg)
SIprintf("%s does not exist\n", srcbuf);
continue;
}
/*
** Open the existing file as "regular" RACC.
*/
status = SIfopen( &loc, "r", (i4)SI_RACC, sizeof( GCN_DB_REC0 ),
&srcFile );
/*
** If the file exists but can't be opened, it's already optimized.
*/
if (status == E_CL1904_SI_CANT_OPEN && ( LOexist( &loc ) == OK ) )
{
/*
** Open the existing file as "optimized" RACC.
*/
status = SIfopen( &loc, "r", (i4)GCN_RACC_FILE,
sizeof( GCN_DB_REC0 ), &srcFile );
if (status != OK)
{
SIprintf( "iicvtgcn: Error opening %s, status is %x\n",
srcbuf, status );
continue;
}
if (verboseArg)
SIprintf("%s is already optimized\n", srcbuf);
}
else if (status != OK)
{
SIprintf( "iicvtgcn: Error opening %s, status is %x\n",
srcbuf, status );
continue;
}
/*
** A successful open as SI_RACC means the file is not optimized.
** This file needs a rewrite.
*/
else
{
if (verboseArg)
SIprintf("Rewriting %s as optimized\n", srcbuf);
writeOutput = TRUE;
}
srcOpened = TRUE;
while ( status == OK )
{
/*
** Read the source data and store in a queue for analysis.
*/
status = SIread( srcFile, sizeof( GCN_DB_REC0 ),
&count, (PTR)&tmp_rec );
if ( status == ENDFILE )
break;
if ( status != OK )
{
SIprintf("iicvtgcn: Error reading %s, status is %x\n",
srcbuf, status);
goto cvt_exit;
}
else if (tmp_rec.gcn_invalid && tmp_rec.gcn_tup_id != -1)
continue;
else
{
gcn_q = (GCN_QUEUE *)MEreqmem(0, sizeof(GCN_QUEUE),0,NULL);
if (!gcn_q)
{
SIprintf("iicvtgcn: Cannot allocate memory, exiting\n");
goto cvt_exit;
}
MEcopy((PTR)&tmp_rec, sizeof(GCN_DB_REC0), (PTR)&gcn_q->buf);
QUinsert(&gcn_q->q, &gcn_qhead);
/*
** EOF record found.
*/
if (gcn_q->buf.gcn_tup_id == -1)
{
gcn_q->buf.gcn_l_uid = 0;
gcn_q->buf.gcn_uid[0] = '\0';
gcn_q->buf.gcn_l_obj = 0;
gcn_q->buf.gcn_obj[0] = '\0';
gcn_q->buf.gcn_l_val = 0;
gcn_q->buf.gcn_val[0] = '\0';
gcn_q->buf.gcn_invalid = TRUE;
break;
}
}
} /* while ( status == OK ) */
/*
** Decrypt passwords for IILOGIN files. If any V1 records are found,
** the IILOGIN file will need to be rewritten.
*/
isLogin = FALSE;
for (q = gcn_qhead.q_prev; q != &gcn_qhead; q = q->q_prev)
{
gcn_q = (GCN_QUEUE *)q;
/*
** EOF record found.
*/
if (gcn_q->buf.gcn_tup_id == -1)
{
gcn_q->buf.gcn_invalid = TRUE;
break;
}
if (i == IILOGIN)
{
isLogin = TRUE;
MEcopy((PTR)&gcn_q->buf, sizeof(GCN_DB_REC0), (PTR)&tmp_rec);
if (verboseArg)
SIprintf("\tEncoding vnode %s\n", gcn_q->buf.gcn_obj);
if (unclusterArg)
status = gcn_recrypt( FALSE, local_mask,
gcn_q->buf.gcn_val, &v1DecryptErr, &writeOutput);
else if (clusterArg)
status = gcn_recrypt( TRUE, local_mask,
gcn_q->buf.gcn_val, &v1DecryptErr, &writeOutput);
else
status = gcn_recrypt( clustered, local_mask,
gcn_q->buf.gcn_val, &v1DecryptErr, &writeOutput);
if (status != OK)
{
if (verboseArg)
SIprintf("Cannot decrypt password from " \
"vnode %s status %x\n", gcn_q->buf.gcn_obj,
status);
dcryptFail++;
MEcopy((PTR)&tmp_rec, sizeof(GCN_DB_REC0),
(PTR)&gcn_q->buf);
continue;
}
if (v1DecryptErr)
{
if (verboseArg)
SIprintf("Cannot decrypt password from " \
"vnode %s\n", gcn_q->buf.gcn_obj);
dcryptFail++;
MEcopy((PTR)&tmp_rec, sizeof(GCN_DB_REC0),
(PTR)&gcn_q->buf);
continue;
}
} /* if (LOGIN) */
} /* for (q = gcn_qhead.q_prev; q != &gcn_qhead; q = q->q_prev) */
if (dcryptFail && verboseArg && isLogin)
{
if (clustered || unclusterArg )
SIprintf("\n%d vnode(s) could not be decrypted.\n" \
"Probably some login entries were created on " \
"another node.\nTry executing iicvtgcn on another " \
"node to merge the other node's entries.\n\n", dcryptFail);
else
SIprintf("\n%d vnode(s) could not be decrypted.\n" \
"Probably the login file was created on " \
"another host.\nTry executing iicvtgcn on " \
"a different host.\n\n", dcryptFail);
}
if (!writeOutput)
{
if (srcOpened)
SIclose(srcFile);
srcOpened = FALSE;
cleanup_queues();
continue;
}
/*
** Open the destination file with special GCN_RACC_FILE flag, for
** optimized writes.
*/
if (clustered || clusterArg)
{
if (named_file[i].add_cluster_node)
STprintf( dstbuf, "II%s_%s", named_file[i].file, local_host);
else
STprintf(dstbuf, "II%s", named_file[i].file);
}
else
STprintf( dstbuf, "II%s_%s", named_file[i].file, local_host);
if (clusterArg && !named_file[i].add_cluster_node)
rewrite = TRUE;
LOfstfile( dstbuf, &loc );
if (rewrite)
{
status = SIfopen( &loc, "rw", (i4)GCN_RACC_FILE,
sizeof( GCN_DB_REC0 ), &dstFile );
if ( status != OK )
{
status = SIfopen( &loc, "w", (i4)GCN_RACC_FILE,
sizeof( GCN_DB_REC0 ), &dstFile );
if (status == OK)
{
SIclose( dstFile);
status = SIfopen( &loc, "rw", (i4)GCN_RACC_FILE,
sizeof( GCN_DB_REC0 ), &dstFile );
}
}
}
else
status = SIfopen( &loc, "w", (i4)GCN_RACC_FILE,
sizeof( GCN_DB_REC0 ), &dstFile );
if ( status != OK )
{
SIprintf( "iicvtgcn: Error opening %s, status is %x\n",dstbuf,
status );
goto cvt_exit;
}
dstOpened = TRUE;
if (verboseArg)
SIprintf("%s %s\n", rewrite ? "Rewriting " : "Writing ", dstbuf);
/*
** If this is a merge operation (-c), login, attribute or
** node files may change the location of EOF, since the
** file to be merged may have different records than
** the destination file.
** Before merging, the output file is read and fed into a queue.
** Then each merge record is compared to each output record.
** If the entire records match, nothing is done.
** If a global login record matches only the vnode name
** global or private records will be added if not present;
** otherwise, nothing is done.
** Node or attribute records may be added if only one field
** fails to match.
*/
status = SIfseek(dstFile, (i4)0, SI_P_START);
if (rewrite)
{
while ( status == OK )
{
/*
** Read the source data and store in a queue for analysis.
*/
status = SIread( dstFile, sizeof( GCN_DB_REC0 ),
&count, (PTR)&tmp_rec );
if ( status == ENDFILE )
break;
if ( status != OK )
{
SIprintf("iicvtgcn: Error reading %s, status is %x\n",
dstbuf, status);
goto cvt_exit;
}
else if (tmp_rec.gcn_invalid && tmp_rec.gcn_tup_id != -1)
continue;
else
{
merge_q = (GCN_QUEUE *)MEreqmem(0, sizeof(GCN_QUEUE),0,NULL);
if (!merge_q)
{
SIprintf("iicvtgcn: Cannot allocate memory, exiting\n");
goto cvt_exit;
}
MEcopy((PTR)&tmp_rec, sizeof(GCN_DB_REC0),
(PTR)&merge_q->buf);
QUinsert(&merge_q->q, &merge_qhead);
/*
** EOF record found.
*/
if (merge_q->buf.gcn_tup_id == -1)
break;
}
if ( status == ENDFILE )
break;
} /* while ( status == OK ) */
/*
** Go through the input queue. Compare each record with
** the output (merge) queue. If the record is invalid
** or doesn't match, it's ignored.
*/
dcryptFail = 0;
total_recs = 0;
for (q = gcn_qhead.q_prev; q != &gcn_qhead; q = q->q_prev)
{
SYSTIME timestamp;
gcn_q = (GCN_QUEUE *)q;
if (gcn_q->buf.gcn_tup_id == -1)
break;
if ( !gcn_merge_rec( gcn_q, isLogin ) )
continue;
if (isLogin)
{
/*
** Login passwords get encrypted as V0 in a cluster
** environment.
*/
MEcopy((PTR)&gcn_q->buf, sizeof(GCN_DB_REC0),
(PTR)&tmp_rec);
status = gcn_recrypt( TRUE, local_mask,
gcn_q->buf.gcn_val, &v1DecryptErr, &writeOutput);
if (status != OK)
{
if (verboseArg)
SIprintf("Cannot decrypt password from " \
"vnode %s status %x\n", gcn_q->buf.gcn_obj,
status);
dcryptFail++;
MEcopy((PTR)&tmp_rec, sizeof(GCN_DB_REC0),
(PTR)&gcn_q->buf);
continue;
}
if (v1DecryptErr)
{
if (verboseArg)
SIprintf("Cannot decrypt password from " \
"vnode %s\n", gcn_q->buf.gcn_obj);
dcryptFail++;
MEcopy((PTR)&tmp_rec, sizeof(GCN_DB_REC0),
(PTR)&gcn_q->buf);
continue;
}
}
merge_q = (GCN_QUEUE *)MEreqmem(0, sizeof(GCN_QUEUE),0,NULL);
if (!merge_q)
{
SIprintf("iicvtgcn: Cannot allocate memory, exiting\n");
goto cvt_exit;
}
MEcopy((PTR)&gcn_q->buf, sizeof(GCN_DB_REC0),
(PTR)&merge_q->buf);
total_recs++;
QUinsert(&merge_q->q, &merge_qhead);
}
if (dcryptFail && verboseArg && isLogin)
{
if (clustered || unclusterArg )
SIprintf("\n%d vnode(s) could not be decrypted.\n" \
"Probably some login entries were created on " \
"another node.\nTry executing iicvtgcn on another " \
"node to merge the other node's entries.\n\n",
dcryptFail);
else
SIprintf("\n%d vnode(s) could not be decrypted.\n" \
"Probably the login file was created on " \
"another host.\nTry executing iicvtgcn on " \
"a different host.\n\n", dcryptFail);
}
if (verboseArg)
SIprintf("Total records merged: %d\n", total_recs);
/*
** If no records to merge, clean up and continue.
*/
if (!total_recs)
{
cleanup_queues();
continue;
}
status = SIfseek(dstFile, (i4)0, SI_P_START);
active_rec = 0;
for (q = merge_qhead.q_prev; q != &merge_qhead; q = q->q_prev)
{
merge_q = (GCN_QUEUE *)q;
if (verboseArg)
SIprintf("Rewriting %s record vnode %s val %s\n",
!STcasecmp("*", merge_q->buf.gcn_uid) ? "global" :
"private", merge_q->buf.gcn_obj, merge_q->buf.gcn_val);
if (merge_q->buf.gcn_tup_id == -1)
continue;
status = SIwrite(sizeof( GCN_DB_REC0 ),
(char *)&merge_q->buf, &count, dstFile );
if ( status != OK)
{
SIprintf( "iicvtgcn: Failed to write file %s, " \
"status is %x\n", srcbuf, status );
goto cvt_exit;
}
active_rec++;
}
/*
** Write new EOF record.
*/
tmp_rec.gcn_tup_id = -1;
tmp_rec.gcn_l_uid = 0;
tmp_rec.gcn_uid[0] = '\0';
tmp_rec.gcn_l_obj = 0;
tmp_rec.gcn_obj[0] = '\0';
tmp_rec.gcn_l_val = 0;
tmp_rec.gcn_val[0] = '\0';
tmp_rec.gcn_invalid = TRUE;
offset = active_rec * sizeof(GCN_DB_REC0);
status = SIfseek(dstFile, (i4)offset, SI_P_START);
status = SIwrite(sizeof( GCN_DB_REC0 ), (PTR)&tmp_rec,
&count, dstFile );
}
else
{
for (q = gcn_qhead.q_prev; q != &gcn_qhead; q = q->q_prev)
{
gcn_q = (GCN_QUEUE *)q;
gcn_q->buf.gcn_l_val = STlength(gcn_q->buf.gcn_val);
if (verboseArg)
SIprintf("Writing %s record vnode %s val %s\n",
!STcasecmp("*", gcn_q->buf.gcn_uid) ? "global" :
"private", gcn_q->buf.gcn_obj, gcn_q->buf.gcn_val);
status = SIwrite(sizeof( GCN_DB_REC0 ), (char *)&gcn_q->buf,
&count, dstFile );
if ( status != OK)
{
SIprintf( "iicvtgcn: Failed to write file %s, " \
"status is %x\n", srcbuf, status );
goto cvt_exit;
}
}
} /* if (rewrite) */
cleanup_queues();
SIclose( srcFile );
srcOpened = FALSE;
SIclose( dstFile );
dstOpened = FALSE;
} /* for (i = 0; i < NBR_NAMED_FILES; i++ ) */
cvt_exit:
cleanup_queues();
if (srcOpened)
SIclose(srcFile);
if (dstOpened)
SIclose(dstFile);
PCexit( OK );
}
/*
** pp_open() -- open a file for reading. The use of the include path list
** is used to resolve files that may not be in the current default
** location.
*/
static STATUS
pp_open( FILE **input, char *filepath, bool def_dir )
{
LOCATION loc;
LOCATION loctest;
char buf[ MAX_LOC + 1 ];
char bufdev[ MAX_LOC + 1 ];
char bufpath[ MAX_LOC + 1 ];
char bufsave[ MAX_LOC + 1 ];
char buftest[ MAX_LOC + 1 ];
STATUS sts;
IPATH *ipath;
bool found = FALSE;
bool file_has_path, dir_has_path;
/*
** Check to see if we should first look in the default directory,
** this directory will be the first entry in the Include list.
*/
if (def_dir == TRUE)
ipath = &ihead;
else
ipath = ihead.next;
/* Convert the filename to open to a LOCATION */
STcopy(filepath, bufsave);
if (OK != (sts = LOfroms( PATH & FILENAME, bufsave, &loc )) )
return (sts);
/*
** Search for the file in each directory in the include list.
** No expansion possible if there are no include directories.
*/
while (ipath != NULL && found == FALSE)
{
/* Initialize loctest so LOaddpath will work */
LOcopy(&loc, buftest, &loctest);
/* Is there a device (VMS) and/or a path for the directory? */
STcopy(ERx(""), bufdev);
STcopy(ERx(""), bufpath);
sts = LOdetail(ipath->pathloc, bufdev, bufpath, buf, buf, buf);
if (sts != OK)
break;
if (STlength(bufdev) + STlength(bufpath) > 0 )
dir_has_path = TRUE;
else
dir_has_path = FALSE;
/* Don't mess with the filename if it was an absolute path */
/* or if this include directory path is empty */
if (LOisfull(&loctest) == FALSE && dir_has_path == TRUE )
{
/* Is there a path for the file? */
sts = LOdetail(&loctest,
buf, bufpath, buf, buf, buf);
if (sts != OK)
break;
file_has_path = (STlength(bufpath) > 0 ? TRUE : FALSE);
/*
** If there's no path component then copy in the
** next prefix, else append it.
** If LOaddpath succeeds, the result will also have
** the original filename. If it fails then drop out.
** LOaddpath can fail if loctest is an absolute path,
** but we already checked for that.
*/
if ( file_has_path )
{
sts =LOaddpath(ipath->pathloc, &loc, &loctest);
}
else
{
LOcopy(ipath->pathloc, buftest, &loctest);
/*
** If we can't set the filename from loc,
** then something is wrong, and will continue
** to be wrong. Get out of the loop.
*/
sts = LOstfile(&loc, &loctest);
}
}
/*
** If all of the filename manipulations have succeeded
** then check for the file's existance.
*/
if (sts == OK && LOexist(&loctest) == OK) {
found = TRUE;
LOcopy(&loctest, buf, &loc);
}
/* Prepare for the next path in the include list */
ipath = ipath->next;
}
/*
** If the file existed then return back the result from the open,
** otherwise all of our efforts were a bust, return back a failure.
*/
if (found)
return ( SIfopen(&loc, ERx("r"), SI_TXT, MAX_LINE, input) );
else
return (FAIL);
}
edit()
{
register char *p;
LOCATION t_loc,
loc;
FILE *fp;
char errbuf[ER_MAX_LEN + 1];
char input[MAX_LOC + 1];
char *editfile;
char *ingedit;
i4 rflag;
STATUS status;
i4 c;
#ifdef CMS
i4 Notempty = 1;
#endif /* CMS */
GLOBALREF char *IIMOildInitLnDraw;
FUNC_EXTERN char *getfilenm();
FUNC_EXTERN char *macro();
if (!Newline)
{
q_putc(Qryiop, '\n');
Newline = TRUE;
}
Autoclear = 0;
editfile = getfilenm();
rflag = 0;
if (*editfile == '\0')
{
rflag = 1;
input[0] = EOS;
if ((status = NMloc( TEMP, PATH, (char *)NULL, &t_loc)) ||
(status = LOuniq( ERx( "query" ), ERx( "edt" ), &t_loc)))
{
STcopy( ERx( "queryXXX" ), input );
}
else
{
LOcopy( &t_loc, input, &loc );
}
status = SIfopen( &loc, ERx( "w" ), (i4)SI_TXT,
(i4)SI_MAX_TXT_REC, &fp );
}
else
{
/* use the path and file name the user gave you */
STcopy(editfile, input);
if (!(status = LOfroms(PATH & FILENAME, input, &loc)))
status = SIfopen( &loc, ERx("w"), (i4)SI_TXT,
(i4)SI_MAX_TXT_REC, &fp );
}
if (status)
{
if (status == FAIL)
errbuf[0] = '\0';
else
ERreport(status, errbuf);
putprintf(ERget(F_MO000C_Cant_create_qry_file),
input, errbuf);
cgprompt();
return(0);
}
if (q_ropen(Qryiop, 'r') == (struct qbuf *)NULL)
/* edit: q_ropen 1 */
ipanic(E_MO0044_1500400);
while ((c = (i4)q_getc(Qryiop)) > 0)
SIputc((char)c, fp);
SIclose(fp);
if (Nodayfile >= 0)
{
putprintf(ERget(F_MO000D_editor_prompt));
SIflush(stdout);
}
/*
** macro returns NULL if undefined, UTedit uses
** default editor if passed NULL.
*/
/* Bug 4875 - Use editor defined by environment variable
ING_EDIT. If that is not set then use the macro(editor).
*/
NMgtAt((ERx("ING_EDIT")), &ingedit);
if ( ingedit != NULL && *ingedit != EOS )
p = ingedit;
else
p = macro(ERx("{editor}"));
if (status = UTedit(p, &loc))
{
ERreport(status, errbuf);
putprintf(ERget(F_MO000E_Can_t_start_up_editor), errbuf);
cgprompt();
return(0);
}
if (!rflag)
{
if (q_ropen(Qryiop, 'a') == (struct qbuf *)NULL)
/* edit: q_ropen 2 */
ipanic(E_MO0045_1500401);
}
else
{
if (q_ropen(Qryiop, 'w') == (struct qbuf *)NULL)
/* edit: q_ropen 3 */
ipanic(E_MO0046_1500402);
if (status = SIfopen( &loc, ERx("r"), (i4)SI_TXT,
(i4)SI_MAX_TXT_REC, &fp ))
#ifdef CMS
{
Notempty = 0;
}
#else
{
ERreport(status, errbuf);
/* can't reopen editfile %s: %s\n */
ipanic(E_MO0047_1500403,
editfile, errbuf);
}
#endif /* CMS */
#ifdef CMS
if (Notempty)
{
#endif /* CMS */
Notnull = 0;
while ((c = SIgetc(fp)) != EOF)
{
if (status)
{
ERreport(status, errbuf);
/* Error reading edit file: %s\n */
ipanic(E_MO0048_1500404, errbuf);
}
Notnull = 1;
q_putc(Qryiop, (char)c);
}
SIclose(fp);
if (status = LOpurge(&loc, 0))
{
ERreport(status, errbuf);
putprintf(ERget(F_MO000F_Cant_delete_file), editfile, errbuf);
}
#ifdef CMS
} /* endif Notempty */
#endif /* CMS */
}
#ifndef FT3270
/* Re-Initialize IT line drawing */
{
if (Outisterm && IIMOildInitLnDraw != NULL)
SIprintf(ERx("%s"), IIMOildInitLnDraw);
}
#endif
cgprompt();
return(0);
}
STATUS
Run_SED_on_file(SEPFILE **Sep_file,LOCATION *Sep_Loc)
{
STATUS ret_val ;
CL_ERR_DESC cl_err;
LOCATION *sedtmploc = NULL ;
LOCATION *filtmploc = NULL ;
char *SEDbuffer = NULL ;
char *sedtmp = NULL ;
char *filtmp = NULL ;
char *cmd_line = NULL ;
char *sed_dev = NULL ;
char *sed_path = NULL ;
char *sed_name = NULL ;
char *sed_type = NULL ;
char *sed_vers = NULL ;
char *fptr1 = NULL ;
char *fptr2 = NULL ;
FILE *SEDfptr = NULL ;
FILE *fptr = NULL ;
bool Sep_file_empty ;
sed_dev = SEP_MEalloc(SEP_ME_TAG_SED, LO_DEVNAME_MAX+1, TRUE, NULL);
sed_path = SEP_MEalloc(SEP_ME_TAG_SED, LO_PATH_MAX+1, TRUE, NULL);
sed_name = SEP_MEalloc(SEP_ME_TAG_SED, LO_FPREFIX_MAX+1, TRUE, NULL);
sed_type = SEP_MEalloc(SEP_ME_TAG_SED, LO_FSUFFIX_MAX+1, TRUE, NULL);
sed_vers = SEP_MEalloc(SEP_ME_TAG_SED, LO_FVERSION_MAX+1, TRUE, NULL);
SEDbuffer = SEP_MEalloc(SEP_ME_TAG_SED, SCR_LINE+1, TRUE, NULL);
/*
** Create Sed output file names.
*/
sedtmploc = (LOCATION *)SEP_MEalloc(SEP_ME_TAG_SED, sizeof(LOCATION),
TRUE, NULL);
filtmploc = (LOCATION *)SEP_MEalloc(SEP_ME_TAG_SED, sizeof(LOCATION),
TRUE, NULL);
sedtmp = SEP_MEalloc(SEP_ME_TAG_TOKEN, MAX_LOC+1, TRUE, NULL);
filtmp = SEP_MEalloc(SEP_ME_TAG_TOKEN, MAX_LOC+1, TRUE, NULL);
LOtos(Sep_Loc, &fptr2);
STcopy(fptr2, sedtmp);
STcopy(fptr2, filtmp);
LOfroms(FILENAME & PATH, sedtmp, sedtmploc);
LOfroms(FILENAME & PATH, filtmp, filtmploc);
LOdetail(sedtmploc, sed_dev, sed_path, sed_name, sed_type, sed_vers);
STcopy(ERx("sed"),sed_type);
SEP_LOcompose(sed_dev, sed_path, sed_name, sed_type, sed_vers, sedtmploc);
STcopy(ERx("sdr"),sed_type);
SEP_LOcompose(sed_dev, sed_path, sed_name, sed_type, sed_vers, filtmploc);
/*
** Copy Sep SI_RACC file to a SI_TXT file.
*/
SEPrewind(*Sep_file, FALSE);
if ((ret_val = SIfopen(filtmploc,ERx("w"), SI_TXT, SCR_LINE, &fptr))
!= OK)
return(ret_val);
for (Sep_file_empty = TRUE;
(ret_val = SEPgetrec(SEDbuffer, *Sep_file)) == OK;
SIputrec(SEDbuffer, fptr))
if (Sep_file_empty)
Sep_file_empty = FALSE;
SIclose(fptr);
if (Sep_file_empty == FALSE)
{ /*
** Create command line for sed command.
*/
LOtos(SED_loc, &fptr1);
LOtos(filtmploc, &fptr2);
cmd_line = SEP_MEalloc(SEP_ME_TAG_TOKEN, MAX_LOC+1, TRUE, NULL);
IISTprintf(cmd_line, "sed -f %s %s", fptr1, fptr2);
/*
** Close Sep file and run the SED.
*/
SEPclose(*Sep_file);
ret_val = PCcmdline(NULL, cmd_line, PC_WAIT, sedtmploc, &cl_err);
if(ret_val != OK)
{
SEPopen(Sep_Loc, SCR_LINE, Sep_file);
del_floc(sedtmploc);
del_floc(filtmploc);
MEtfree(SEP_ME_TAG_SED);
return(1);
}
/*
** Recreate Sep file.
*/
#ifdef NT_GENERIC
LOdelete(Sep_Loc);
#else
del_floc(Sep_Loc);
#endif
if ((ret_val = SIfopen(Sep_Loc, ERx("w"), SI_RACC, SCR_LINE, &fptr))
!= OK)
return(ret_val);
SIclose(fptr);
SEPopen(Sep_Loc, SCR_LINE, Sep_file);
/*
** Open Sed output file.
*/
if ((ret_val = SIfopen(sedtmploc, ERx("r"), SI_TXT, SCR_LINE, &SEDfptr))
!= OK)
return(ret_val);
/*
** Copy the Sed output file to the Sep file.
*/
while((ret_val = SIgetrec(SEDbuffer, SCR_LINE, SEDfptr)) == OK)
SEPputrec(SEDbuffer, *Sep_file);
SEPclose(*Sep_file);
SIclose(SEDfptr);
/*
** Reopen the sep file.
*/
SEPopen(Sep_Loc, SCR_LINE, Sep_file);
/*
** Clean up.
*/
del_floc(sedtmploc);
}
del_floc(filtmploc);
MEtfree(SEP_ME_TAG_SED);
return(OK);
}
static VOID
IILQgtfGcaTraceFile( II_LBQ_CB *IIlbqcb, i4 action )
{
IILQ_TRACE *msgtrc = &IIglbcb->iigl_msgtrc;
FILE *trace_file = (FILE *)msgtrc->ii_tr_file;
char *title = ERx("off");
SYSTIME now;
char nowbuf[100];
i4 nowend;
/*
** Check to see that we actually need to open
** or close the trace file.
*/
if ( (action == IITRC_ON && trace_file) ||
(action == IITRC_OFF && ! trace_file) ||
(action == IITRC_SWITCH && ! trace_file) )
return;
if ( action == IITRC_SWITCH ) title = ERx("switched");
if ( action == IITRC_ON )
{
LOCATION trace_loc;
STATUS stat;
/*
** If trace file name not provided, use default.
*/
if ( ! msgtrc->ii_tr_fname )
msgtrc->ii_tr_fname = STalloc( GCTRACEFILE );
LOfroms(FILENAME, msgtrc->ii_tr_fname, &trace_loc );
# ifdef hp9_mpe
if ( msgtrc->ii_tr_flags & II_TR_APPEND )
stat = SIfopen(&trace_loc, ERx("a"), SI_TXT, 252, &trace_file);
else
stat = SIfopen(&trace_loc, ERx("w"), SI_TXT, 252, &trace_file);
# else
if ( msgtrc->ii_tr_flags & II_TR_APPEND )
stat = SIopen(&trace_loc, ERx("a"), &trace_file);
else
stat = SIopen(&trace_loc, ERx("w"), &trace_file);
# endif
if (stat != OK)
{
/* Simplest error path; don't want IIlocerr functionality */
IIUGerr(E_LQ0007_PRINTQRY, 0, 1, msgtrc->ii_tr_fname);
/*
** We can't call IILQgstGcaSetTrace() because
** of possible conflicts with the tracing
** semaphore, so just turn off tracing here.
*/
msgtrc->ii_tr_flags &= ~II_TR_FILE;
if ( ! (msgtrc->ii_tr_flags & II_TR_HDLR) )
IIcgct1_set_trace( IIlbqcb->ii_lq_gca, 0, NULL, NULL );
return;
}
msgtrc->ii_tr_file = (PTR)trace_file;
title = ERx("on ");
}
/* Get time stamp */
TMnow(&now);
TMstr(&now, nowbuf);
nowend = STlength( nowbuf );
if ( nowbuf[ nowend - 1 ] == '\n' ) nowbuf[ nowend - 1 ] = EOS;
SIfprintf( trace_file, ERx("---- printgca = %s session %d (%s) ---\n\n"),
title, IIlbqcb->ii_lq_sid, nowbuf );
SIflush( trace_file );
if ( action != IITRC_OFF )
msgtrc->ii_tr_sid = IIlbqcb->ii_lq_sid;
else
{
SIclose( trace_file );
msgtrc->ii_tr_file = NULL;
msgtrc->ii_tr_sid = 0;
msgtrc->ii_tr_flags |= II_TR_APPEND; /* Don't overwrite if reopened */
}
return;
} /* IILQgtfGcaTraceFile */
/*
** form_comment
*/
STATUS
form_comment(FILE *aFile)
{
STATUS ret_status ;
FILE *comPtr = NULL ;
/*
** Find beginning of commment.
*/
do
{
ret_status = read_fm_command(aFile);
} while ((ret_status == OK)&&
((sep_state & BLANK_LINE_STATE)||(sep_state & IN_ENDING_STATE)));
if (ret_status == OK)
{
if ((sep_state & IN_COMMENT_STATE) == 0)
{
fromLastRec = 1;
STcopy(buffer_1, holdBuf);
ret_status = FAIL;
}
}
/*
** create comments file
*/
if (ret_status == OK)
{
if ((ret_status = bld_cmtName(msg)) != OK)
{
disp_line(msg,0,0);
}
else if ((ret_status = SIfopen(cmtLoc, ERx("w"), SI_TXT, TERM_LINE,
&comPtr)) != OK)
{
disp_line(STpolycat(2,ErrOpn,cfile,msg),0,0);
}
}
/*
** read in comments
*/
if (ret_status == OK)
{
if ((ret_status = read_in_comments(aFile, comPtr)) == OK)
{
/*
** close comments file
*/
if (SIclose(comPtr)!= OK)
{
STpolycat(3,ErrC,ERx("close"),cfile,msg);
disp_line(msg,0,0);
ret_status = FAIL;
}
}
}
return(ret_status);
} /* end of form_comment */
