/************************************************************************/
/*  meta2seed -		convert meta request file to SEED file.		*/
/*	input - 	meta request file				*/
/*	output -	SEED volume (with data or dataless)		*/
/************************************************************************/

#include <stdio.h>
#include <strings.h>
#include <math.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <search.h>

#ifdef USE_SAMFS
#include "/opt/LSCsamfs/include/samrpc.h"
#endif

#define	CONNECT_STRING2	"netdc/dB2Usr@ncedc"
#define	CONNECT_STRING	"ciresp/dB2Usr@ncedc"
#define	WAVEDIR		"/scr/dc13/MSEED"
#define	NOMOREROWS	1403

/*  TWINDOW is defined to be longer (in seconds) than any waveform	*/
/*  segment in the database.  It must be longer than 1 day, since we	*/
/*  break broadband data into daily records.				*/
/*  TWINDOW has been changed to a month due to the UL Network           */
#define	TWINDOWDAILY		86401
#define TWINDOWMONTHLY		2678401

char *syntax[] = {
"%s [-h] [-I] [-o seed_file] [-w workdir] [-p pod_request] [-D datapath]",
"    [-b poddir] [-d debug_value] meta_req_file",
"    where:",
"	-h		Prints out a summary of the available options.",
"	-I		Generate Dataless SEED.",
"	-o seed_file	Output SEED file.",
"	-w workdir	Temp directory to work in.  If not specified, use /tmp.",
"	-p pod_req	Additional explicit pod request file.",
"	-D datapath	Additional explicit pod DATA_PATH entry.",
"	-d debug_val	Debug value for POD and program.",
"	-b dir		Specifies the path and name of the POD request",
"			directory structure (HAR000).",
"	meta_req_file	Meta-SQL request file.",
NULL};

#define	YEARLY_ARCHIVE	"/data/sam/bbdata/BK"

#define	CREATOR_VAR	"CREATOR=\"Northern California Earthquake Data Center, UC Berkeley\""
#define	TAPELABEL_VAR	"TAPELABEL=\"SEED V2.3 volume created by NCEDC\""

#define READPODREQUEST2	"/home/netdc/Local/Make_Blockettes -p req 1> /dev/null 2>&1"
#define READPODREQUEST	"/data/09/stephane/DBMS_Query_Engine/Instrument_Responses/IR/Make_Blockettes/Make_Blockettes -p req 1> /dev/null 2>&1"
#define	POD		"/home/netdc/Local/pod"


#define	DEBUG(val)  (debug_flag & val)
#define	DEBUG_POD   3
#define	DEBUG_CMD   4
#define	DEBUG_KEEP  8
#define	DEBUG_WAVE  16

/* qlib2 functions. */
extern int print_syntax
   (char	*cmd,		/* program name.			*/
    char	*syntax[],	/* syntax array.			*/
    FILE	*fp);		/* FILE ptr for output.			*/
extern char *tail
   (char	*path);		/* pathname.				*/

EXEC SQL INCLUDE sqlca.h;

EXEC SQL BEGIN DECLARE SECTION;
char    user_pwd[80];

char	net[9];
char	sta[7];
char	location[3];
char	seedchan[4];
int	fileid;
char	dfile[33];
int	subdirid;
char	subdirname[65];
char	pathname[256];
double	wondate;
double	woffdate;
double	uondate;
double	uoffdate;
char	dateon[20];
char	dateoff[20];
char	udateon[20];
char	udateoff[20];
char	sondate[20];
char	soffdate[20];
char	jsondate[20];
char	jsoffdate[20];
char	jon[20];
char	joff[20];
double	fwondate;
double	fwoffdate;
char	fdateon[20];
char	fdateoff[20];
char	fjon[20];
char	fjoff[20];
char    condate[20];
char    coffdate[20];


char   ir_sql[8192];
char   wav_sql[8192];

short	ind;
EXEC SQL END DECLARE SECTION;

EXEC SQL DECLARE ir_stmt    STATEMENT;
EXEC SQL DECLARE wav_stmt    STATEMENT;

char *cmdname;
char	wavedir[MAXPATHLEN];

void *FileList;

long      SQLCODE;

void    sql_error();    /* Handles unrecoverable errors */

#define	MAXYEARS	500
static int	years[MAXYEARS];
static int	nyears = 0;

static void mark_year (int year)
{
    int i;
    for (i=0;i<MAXYEARS;i++) {
	if (years[i] == year) break;
	if (years[i] == 0) {
	    years[i] = year;
	    nyears = ++i;
	    break;
	}
    }
}

static  int intcompare(const void *i, const void *j)
{
    if (*(int *)i > *(int *)j)
	return (1);
    if (*(int *)i < *(int *)j)
	return (-1);
    return (0);
}
		   
char*   Remove_Blank (s)
char    *s;
{
 char   *p = s + strlen (s);
 while (--p >= s)
        if (*p == ' ')
                *p = '\0';
        else    break;
 return (s);
}


void CopyTree (const void *pfilename, VISIT visit, int level)
{
    int status = 0;
    char *filename = *((char **)pfilename);
/*::
    printf ("Filename = 0x%x = %s, visit = %s, level = %d\n",
	   filename,
	   (filename == NULL) ? "<NULL>" : filename,
	   (visit == preorder) ? "preorder" : 
	   (visit == postorder) ? "postorder" :
	   (visit == endorder) ? "endorder" :
	   (visit == leaf) ? "leaf" : "unknown",
	   level);
::*/
    if (visit == postorder || visit == leaf) {
	if (CopyFile ((char *)filename, wavedir) != 0) {
		printf ("Warning: Error copying file %s to %s\n", filename, wavedir);
		fflush (stdout);
	}
	/*else printf ("Copied %s to %s\n", filename, wavedir);*/
    }
}

                                   /*****************************************************************/
                                  /*  Function to stage data from the jukebox to the magnetic disk */
                                 /*****************************************************************/
#ifdef USE_SAMFS
int	PrepareFile (char file[])
{
 sam_stage (file, "");
 return (0);
}
#endif

                                   /*******************************/
                                  /*  Function to copy waveforms */
                                 /*******************************/
 
int	CopyFile (char f[], char d[])
{
 char	sys[20+MAXPATHLEN*2];	/* System command */
 int status;
 sprintf (sys, "/bin/cp %s %s", f, d);
 status = system (sys);
 return (status);
}


                                   /*******************************************************/
                                  /*  Function to convert a Oracle date to a Julian date */
                                 /*******************************************************/
 
char*	Convert_Date (char d[20])
{
    EXEC SQL BEGIN DECLARE SECTION;
    static char   nd[20];
    char   d2[20];
    EXEC SQL END DECLARE SECTION;
 
    char dd[10];
 
 
    sprintf (dd, ",%s", d+11);
    strcpy (d2, d);
    d2[10] = '\0';
 
    EXEC SQL SELECT TO_CHAR (TO_DATE (:d2, 'YYYY/MM/DD'), 'YYYY,DDD') INTO :nd FROM DUAL;

    memcpy (nd+8, dd, 9);

    return (nd); 
}

   
/* Main function */
void main (int argc, char **argv)
{
    FILE	*fmeta, *freq, *freqtmp, *fpod;
    char	*meta, req[2048], reqtmp[2048];
    char	env_header[2048], env_lookup[64], env_poly[64], env_debug[20];
    char	line[255];
    char	Query[8][4096];
    int		i, z;
    int		level = 0;
    int		debug_flag = 0;
    char	Flag_Har = 0;
    char	har_name[255];
    char	hostname[11];

    char	decstart[12], decend[12];
    char	fdecstart[12], fdecend[12];

    char	datapath[4096];
    char	datatmp[255];

    char	min_sta[7];
    char	min_net[9];
    char	min_cha[4];
    char	min_sdate[23];

    char	tmp_sta[7];
    char	tmp_net[9];
    char	tmp_cha[4];
    char	tmp_sdate[23];
    char	reqfile[2048];
    char	cmd[2048];
    char	pod_log[2048] = "/dev/null";
    int		Flag_D = 0;
    int		Dataless = 0;
    char	*Add_Datapath = NULL;
    char	*Add_podreq = NULL;
    char	*workdir;
    char	*seedfile = "output.seed";
    pid_t	pid;

    /* Variables needed for getopt. */
    extern char	*optarg;
    extern int	optind, opterr;
    int		c;

    cmdname = tail(argv[0]);
    /*	Parse command line options.					*/
    while ( (c = getopt(argc,argv,"hIo:w:p:D:d:b:")) != -1)
	switch (c) {
	case '?':
	case 'h':   print_syntax(cmdname,syntax,stdout); exit(0); break;
	case 'I':   Dataless = 1; break;	
	case 'o':   seedfile = optarg; break;
	case 'w':   workdir = optarg; break;
	case 'p':   Add_podreq = optarg; break;
	case 'D':   Add_Datapath = optarg; break;
	case 'd':   debug_flag = atoi(optarg); break;
	case 'b':   Flag_Har = 1; strcpy (har_name, optarg); break;
	}

    /*	Skip over all options and their arguments.			*/
    argv = &(argv[optind]);
    argc -= optind;

    if (argc > 0) meta = argv[0];
    else {
	fprintf (stderr, "Error: no meta_file specified.\n");
	exit (129);
    }

    if (! workdir) workdir = ".";

    pid = getpid();
    sprintf (req, "%s/%s", workdir, "req");
    sprintf (reqtmp, "%s/%s.%d", workdir, "reqtmp", (int)pid);

    if (DEBUG(DEBUG_POD)) sprintf (pod_log, "%s/%s", workdir, "pod.log");

    /* Opening input file */
    if ((fmeta = fopen (meta, "r+t")) == NULL)
    {
	printf ("Error: Couldn't open meta file %s \n", meta);
	exit (129);
    }

    /* Opening request file */
    if ((freq = fopen (req, "w+t")) == NULL)
    {
	printf ("Error: Couldn't open file %s \n", req);
	exit (129);
    }

#ifdef USE_SAMFS
    /* Initialize SamFS */
    if ((sam_initrpc ("slip.geo.berkeley.edu")) == (-1))
	{
	 printf ("\n Error: SamFS couldn't be initialized.\n");
	 exit (-1);
	}
#endif

    /* Connect to ORACLE. */
    EXEC SQL WHENEVER SQLERROR DO sql_error();

    strcpy (user_pwd, CONNECT_STRING);

    EXEC SQL CONNECT :user_pwd;

 /* Convert meta-request into actual SQL request. */
 while (!feof (fmeta))
	{
	 /* Reading level */
	 fscanf (fmeta, "%d\n", &level);

	 /* Reading SQL queries */
	 if (level == 5)
		{
		 for (i=1;i<=6;i++)
			{
			 fgets (Query[i], 4095, fmeta);
			 Query[i][strlen (Query[i]) - 1] = '\0';
			}
		}
	 else
		{
		 printf ("\n Error: Meta file level = %d.\n\n", level);
		 EXEC SQL COMMIT WORK RELEASE;

		 #ifdef USE_SAMFS
		 sam_closerpc();
		 #endif

		 exit (-1);
		}

	 /* Copying dates */
	 strcpy (udateon,  Query[5]);
	 strcpy (udateoff, Query[6]);
	 udateon[19]  = '\0';
	 udateoff[19] = '\0';

	 /* Retrieving data */
	 if (Dataless)
		{ /* Dataless SEED request.  Do not itemize by each waveform. Itemize by IR time spans	*/

		 sprintf (ir_sql, "SELECT DISTINCT net, sta, seedchan, location, ondate, offdate FROM Channel_Data WHERE (%s) AND (%s) AND (%s) AND (%s)", Query[1], Query[2], Query[3], Query[4]);

		 /* Declaring IR cursor */
		 EXEC SQL PREPARE ir_stmt FROM :ir_sql;
		 EXEC SQL DECLARE ir_cursor CURSOR FOR ir_stmt;

		 /* Opening IR cursor */
		 EXEC SQL OPEN ir_cursor;

		 /* Fetch instances for the IR cursor */
		 EXEC SQL FETCH ir_cursor INTO :net, :sta, :seedchan, :location, :condate, :coffdate;
		 while (sqlca.sqlcode != NOMOREROWS)
			{
			 char	irondate[20];
			 char	iroffdate[20];

			 strcpy (irondate, Convert_Date (condate));
			 strcpy (iroffdate, Convert_Date (coffdate));
			 irondate[19] = '\0';
			 iroffdate[19] = '\0';

			 Remove_Blank (net);
			 Remove_Blank (sta);
			 Remove_Blank (seedchan);
			 Remove_Blank (location);

			 if (
					     (
					      (strcmp (udateon, irondate) >= 0) && (strcmp (udateon, iroffdate) <= 0)
					     ) ||
					     (
					      (strcmp (udateoff, irondate) >= 0) && (strcmp (udateoff, iroffdate) <= 0)
					     ) ||
					     (
					      (strcmp (udateon, irondate) <= 0) && (strcmp (udateoff, iroffdate) >= 0)
					     )
					    )
						fprintf(freq, "%s\t%s\t%s\t%s\t%.8s\t%.8s\tWaveformFilename\tHAR000\t%.17s\t%.17s\n", 
							sta, net, seedchan, location, irondate, iroffdate, irondate, iroffdate);

			  EXEC SQL FETCH ir_cursor INTO :net, :sta, :seedchan, :location, :condate, :coffdate;
			}
		}
	else
		{ /* Data SEED request.  Search over each waveform. */ 
		 EXEC SQL SELECT NCEDCDBA.TRUETIME.STRING2TRUE (:udateon)  INTO :uondate FROM DUAL;
		 EXEC SQL SELECT NCEDCDBA.TRUETIME.STRING2TRUE (:udateoff) INTO :uoffdate FROM DUAL;

		 if (!strcmp (Query[1], "net like 'UL'"))
			{
			 if ((uoffdate - uondate) < TWINDOWMONTHLY)
				sprintf (wav_sql, "SELECT "
					     "DISTINCT net, sta, seedchan, location, fileid, datetime_on, datetime_off FROM Waveform " 
 					     "WHERE (%s) AND (%s) AND (%s) AND (%s) "
					     "AND ((datetime_on BETWEEN %f AND %f) OR (datetime_off BETWEEN %f AND %f) "
					     "OR ((datetime_on BETWEEN %f AND %f) AND (datetime_off BETWEEN %f AND %f)))", 
					     Query[1], Query[2], Query[3], Query[4], uondate, uoffdate, uondate, uoffdate, 
					     uoffdate-TWINDOWMONTHLY, uondate, uoffdate, uondate+TWINDOWMONTHLY);
			 else	sprintf (wav_sql, "SELECT "
					     "DISTINCT net, sta, seedchan, location, fileid, datetime_on, datetime_off FROM Waveform " 
 					     "WHERE (%s) AND (%s) AND (%s) AND (%s) "
					     "AND ((datetime_on BETWEEN %f AND %f) OR (datetime_off BETWEEN %f AND %f)) ",
					     Query[1], Query[2], Query[3], Query[4], uondate, uoffdate, uondate, uoffdate); 
			}
		 else if ((!strcmp (Query[1], "net like 'BK'")) || (!strcmp (Query[1], "net like 'BP'")) || (!strcmp (Query[1], "net like 'NN'")))
			{
			 if ((uoffdate - uondate) < TWINDOWDAILY)
				sprintf (wav_sql, "SELECT "
					     "DISTINCT net, sta, seedchan, location, fileid, datetime_on, datetime_off FROM Waveform " 
 					     "WHERE (%s) AND (%s) AND (%s) AND (%s) "
					     "AND ((datetime_on BETWEEN %f AND %f) OR (datetime_off BETWEEN %f AND %f) "
					     "OR ((datetime_on BETWEEN %f AND %f) AND (datetime_off BETWEEN %f AND %f)))", 
					     Query[1], Query[2], Query[3], Query[4], uondate, uoffdate, uondate, uoffdate, 
					     uoffdate-TWINDOWDAILY, uondate, uoffdate, uondate+TWINDOWDAILY);
			 else	sprintf (wav_sql, "SELECT "
					     "DISTINCT net, sta, seedchan, location, fileid, datetime_on, datetime_off FROM Waveform " 
 					     "WHERE (%s) AND (%s) AND (%s) AND (%s) "
					     "AND ((datetime_on BETWEEN %f AND %f) OR (datetime_off BETWEEN %f AND %f)) ",
					     Query[1], Query[2], Query[3], Query[4], uondate, uoffdate, uondate, uoffdate); 
			}

		 else
			{
			 if ((uoffdate - uondate) < TWINDOWMONTHLY)
				sprintf (wav_sql, "SELECT "
					     "DISTINCT net, sta, seedchan, location, fileid, datetime_on, datetime_off FROM Waveform " 
 					     "WHERE (%s) AND (%s) AND (%s) AND (%s) "
					     "AND ((datetime_on BETWEEN %f AND %f) OR (datetime_off BETWEEN %f AND %f) "
					     "OR ((datetime_on BETWEEN %f AND %f) AND (datetime_off BETWEEN %f AND %f)))", 
					     Query[1], Query[2], Query[3], Query[4], uondate, uoffdate, uondate, uoffdate, 
					     uoffdate-TWINDOWMONTHLY, uondate, uoffdate, uondate+TWINDOWMONTHLY);
			 else	sprintf (wav_sql, "SELECT "
					     "DISTINCT net, sta, seedchan, location, fileid, datetime_on, datetime_off FROM Waveform " 
 					     "WHERE (%s) AND (%s) AND (%s) AND (%s) "
					     "AND ((datetime_on BETWEEN %f AND %f) OR (datetime_off BETWEEN %f AND %f)) ",
					     Query[1], Query[2], Query[3], Query[4], uondate, uoffdate, uondate, uoffdate); 
			}

		 if (DEBUG(DEBUG_CMD)) printf ("SQL Command: %s\n", wav_sql);

		 /* Declaring waveform cursor */
		 EXEC SQL PREPARE wav_stmt FROM :wav_sql;
		 EXEC SQL DECLARE wav_cursor CURSOR FOR wav_stmt;

		 /* Opening waveform cursor */
		 EXEC SQL OPEN wav_cursor;

		 /* Fetch instances for the waveform cursor  */
		 EXEC SQL FETCH wav_cursor INTO	:net, :sta, :seedchan, :location, :fileid, :wondate, :woffdate;

		 while (sqlca.sqlcode != NOMOREROWS)
			{
			 Remove_Blank (net);
			 Remove_Blank (sta);
			 Remove_Blank (seedchan);

			 /* Searching IR start and end dates */
			 strcpy (sondate, "4000/01/01 00:00:00");
			 EXEC SQL SELECT MIN (ondate) INTO :sondate:ind FROM channel_data 
				WHERE net = :net AND sta = :sta AND seedchan = :seedchan AND location = :location;

			 if ((ind == (-1)) || (strlen (sondate) == 0))
				strcpy (sondate, "4000/01/01 00:00:00");

			 strcpy (soffdate, "4000/01/01 00:00:00");
			 EXEC SQL SELECT MAX (offdate) INTO :soffdate:ind FROM channel_data 
				WHERE net = :net AND sta = :sta AND seedchan = :seedchan AND location = :location;

			 if ((ind == (-1)) || (strlen (soffdate) == 0))
				strcpy (soffdate, "4000/01/01 00:00:00");

			 strcpy (jsondate, Convert_Date (sondate));
			 strcpy (jsoffdate, Convert_Date (soffdate));


			 EXEC SQL SELECT subdirid, dfile, datetime_on, datetime_off INTO :subdirid, :dfile, :fwondate, :fwoffdate FROM Filename WHERE fileid = :fileid;

			 Remove_Blank (dfile);

			 sprintf (decstart, "%5.4f", wondate  - floor (wondate ));
			 sprintf (decend  , "%5.4f", woffdate - floor (woffdate));

			 sprintf (fdecstart, "%5.4f", fwondate  - floor (fwondate ));
			 sprintf (fdecend  , "%5.4f", fwoffdate - floor (fwoffdate));

			 wondate   = floor (wondate);
			 woffdate  = floor (woffdate);
			 fwondate  = floor (fwondate);
			 fwoffdate = floor (fwoffdate);

			 EXEC SQL SELECT NCEDCDBA.TRUETIME.TRUE2STRING (:wondate) INTO :dateon FROM DUAL;
			 EXEC SQL SELECT NCEDCDBA.TRUETIME.TRUE2STRING (:woffdate) INTO :dateoff FROM DUAL;
			 EXEC SQL SELECT NCEDCDBA.TRUETIME.TRUE2STRING (:fwondate) INTO :fdateon FROM DUAL;
			 EXEC SQL SELECT NCEDCDBA.TRUETIME.TRUE2STRING (:fwoffdate) INTO :fdateoff FROM DUAL;

			 /* Windowing waveforms to user time */
			 if (uondate > wondate)
					{
					    strcpy (jon, Convert_Date (udateon));
					    sprintf (decstart, "%5.4f", 0.);
					}
			 else	strcpy (jon, Convert_Date (dateon));

			 if (uoffdate < woffdate)
					{
					    strcpy (joff, Convert_Date (udateoff));
					    sprintf (decend, "%5.4f", 0.);
					}
			 else	strcpy (joff, Convert_Date (dateoff));

			 strcpy (fjon, Convert_Date (fdateon));
			 strcpy (fjoff, Convert_Date (fdateoff));

			 Remove_Blank (location);

			 if (
					     (
					      (strcmp (jon, jsondate) >= 0) && (strcmp (jon, jsoffdate) <= 0)
					     ) ||
					     (
					      (strcmp (joff, jsondate) >= 0) && (strcmp (joff, jsoffdate) <= 0)
					     ) ||
					     (
					      (strcmp (jon, jsondate) <= 0) && (strcmp (joff, jsoffdate) >= 0)
					     )
					    )
				{
				 /* Retrieving SubDir information */
				 EXEC SQL SELECT subdirname INTO :subdirname
					FROM SUBDIR
					WHERE subdirid = :subdirid;

				 Remove_Blank (subdirname);

				 /* Retrieving path names */
				 EXEC SQL DECLARE cpath CURSOR FOR
					SELECT pathname FROM PATHNAME
					WHERE  net = :net;

				 EXEC SQL OPEN cpath;

				 EXEC SQL FETCH cpath INTO :pathname;
				 while (sqlca.sqlcode != NOMOREROWS)
					{
					 FILE	*ftmp;
					 char	ntmp[MAXPATHLEN];

					 /* Does the file exist? */
					 Remove_Blank (pathname);
					 sprintf (ntmp, "%s/%s/%s", pathname, subdirname, dfile);
					 if (access (ntmp, F_OK) == 0)
						{
						 char *filepath = strdup(ntmp);
						 void *p;
						 if (filepath == NULL)
							{
							 printf ("Error duplicating filepath %s\n", ntmp);
							 exit(129);
							}
						 #ifdef USE_SAMFS
						 /* Staging file */
						 if ((PrepareFile (filepath)) == (-1))
							{
							 printf ("Error preparing file %s\n", filepath);
							 exit (129);		
							}
						 #endif
						 /* Storing file into file list */
						 if ((p = (char *)tsearch(filepath,&FileList,strcmp)) == NULL)
							{
							 printf ("Error adding %s to tree\n", filepath);
							 exit(129);
							}
						 /*:: printf ("filepath = 0x%x, p = 0x%x\n", filepath, p); */
						}

					 EXEC SQL FETCH cpath INTO :pathname;
					}

				 EXEC SQL CLOSE cpath;

			  	 fprintf(freq, "%s\t%s\t%s\t%s\t%.17s%s\t%.17s%s\t%s\tHAR000\t%.17s%s\t%.17s%s\n", 
					   	 sta, net, seedchan, location, fjon, fdecstart+1, fjoff, fdecend+1, dfile, 
						 jon, decstart+1, joff, decend+1);

				}
 
			 EXEC SQL FETCH wav_cursor INTO	:net, :sta, :seedchan, :location, :fileid, :wondate, :woffdate;
			}

		 /* Closing waveform cursor */
		 EXEC SQL CLOSE wav_cursor;
		}

	 /* Reading level */
	 fscanf (fmeta, "%d\n", &level);
	}

    /* Disconnect from the database. */
    EXEC SQL COMMIT WORK RELEASE;

    /* Closing files */
    fclose (fmeta);
    fclose (freq);

    /* Any Pod request file? */
    if (Add_podreq)
    {
	/* Opening files */
	if ((freq = fopen (req, "a+t")) == NULL)
	{
	    printf ("\n Error: Couldn't open file %s \n", req);
	    exit (129);
	}

	if ((fpod = fopen (Add_podreq, "rt")) == NULL)
	{
	    printf ("\n Error: Couldn't open file %s \n", Add_podreq);
	    exit (129);
	}

	/* Copying files */
	fgets (line, 255, fpod);
	while (!feof (fpod))
	{
	    fputs (line, freq);
	    fgets (line, 255, fpod);
	}

	/* Closing files */
	fclose (freq);
	fclose (fpod);
    }

    /* Sorting request file */
    sprintf (cmd, "sort %s > %s", req, reqtmp);
    if (DEBUG(DEBUG_CMD)) printf ("%s\n", cmd);
    system (cmd);

    /* Looking for the earliest time */
 
    /* Opening request file */
    if ((freqtmp = fopen (reqtmp, "rt")) == NULL)
    {
	printf ("\n Error: Couldn't open file %s \n", reqtmp);
	exit (129);
    }

    /* Reading request file */
    fgets (datatmp, 255, freqtmp);
    strcpy (min_sdate, "5000,365,23:59:59.9999");
    while (!feof (freqtmp))
    {
	int year;
	sscanf (datatmp, "%s %s %s %*s %*s %*s %*s %s", tmp_sta, tmp_net, tmp_cha, tmp_sdate);
	sscanf (tmp_sdate, "%04d", &year);
	mark_year (year);
	if (strcmp (tmp_sdate, min_sdate) < 0)
	{
	    strcpy (min_sta,   tmp_sta);
	    strcpy (min_net,   tmp_net);
	    strcpy (min_cha,   tmp_cha);
	    strcpy (min_sdate, tmp_sdate);
	}

	fgets (datatmp, 255, freqtmp);
    }

    /* Writing new request file */
    rewind (freqtmp);
    if ((freq = fopen (req, "w+t")) == NULL)
    {
	printf ("\n Error: Couldn't open file %s\n", req);
	exit (129);
    }

    fgets (datatmp, 255, freqtmp);
    while (!feof (freqtmp))
    {
	sscanf (datatmp, "%s %s %s", tmp_sta, tmp_net, tmp_cha);

	if ((!strcmp (tmp_sta, min_sta)) && (!strcmp (tmp_net, min_net)) && (!strcmp (tmp_cha, min_cha)))
	    fprintf (freq, "%s", datatmp);
	 
	fgets (datatmp, 255, freqtmp);
    }
 
    rewind (freqtmp);
    fgets (datatmp, 255, freqtmp);
    while (!feof (freqtmp))
    {
	sscanf (datatmp, "%s %s %s", tmp_sta, tmp_net, tmp_cha);

	if ((strcmp (tmp_sta, min_sta)) || (strcmp (tmp_net, min_net)) || (strcmp (tmp_cha, min_cha)))
	    fprintf (freq, "%s", datatmp);
	 
	fgets (datatmp, 255, freqtmp);
    }

    /* closing files */
    fclose (freq);
    fclose (freqtmp);


    /* Setting environment for Read_Pod_Request */
    sprintf (env_lookup, "USE_LOOKUP=YES");
    putenv (env_lookup);
/*::
    sprintf (env_poly, "USE_ABPOLY=YES");
    putenv (env_poly);
::*/

    /* Calling Read_Pod_Request */
    if (!Flag_Har)
	{
	 sprintf (cmd, "(cd %s && %s)", workdir, READPODREQUEST);
	 if (DEBUG(DEBUG_CMD)) printf ("%s\n", cmd);
	 system (cmd);
	}

    /* Setting environment for POD */
    if (Flag_Har)
	{
	 if (har_name[strlen (har_name) - 1] == '/')
		har_name[strlen (har_name) - 1] = '\0';

	 sprintf (env_header, "HEADER_PATH=%s",har_name);
	}
    else	sprintf (env_header, "HEADER_PATH=%s/HAR000",workdir);
    putenv (env_header);

    sprintf (env_debug, "DEBUG=%d", DEBUG(DEBUG_POD));
    putenv (env_debug);

    putenv ("SEED_VERSION=2.3");

    putenv (CREATOR_VAR);

    putenv (TAPELABEL_VAR);

    gethostname (hostname, 10);
    sprintf (wavedir, "%s/%s.%d", WAVEDIR, hostname, pid);

    if (! Dataless) {
        /* Building DATA_PATH */
	sprintf (datapath, "DATA_PATH=%s", wavedir);

        if (Add_Datapath)
        {
            strcat(datapath, ":");
            strcat (datapath, Add_Datapath);
        }
        putenv (datapath);
    }
    else	putenv ("SEEDOUTPUTNODATA=YES");

    /* Copying waveforms */
    mkdir (wavedir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
    twalk (FileList,CopyTree);

    /* Calling POD */
    sprintf (cmd, "%s %s %s %d %d %s %s >%s 2>&1", POD, seedfile, req, 4096, 32768, "99,999", "99,999", pod_log);
    if (DEBUG(DEBUG_CMD)) printf ("%s\n", cmd);
    system (cmd);

    /* Debug? */
    if (DEBUG(DEBUG_WAVE))
	printf ("Waveform files in %s\n", wavedir);
    else
	{
	 sprintf (cmd, "rm -rf %s", wavedir);
         if (DEBUG(DEBUG_CMD)) printf ("%s\n", cmd);
         system (cmd);
	}

#ifdef USE_SAMFS
    /* Close SamFS */
    if (sam_closerpc() == (-1))
	{
	 printf ("\n Error: SamFS couldn't be closed.\n");
	 exit (-1);
	}
#endif

    exit (0);
}

/* Handle errors. Exit on any error. */
void    sql_error()
{
    char msg[512];
    size_t buf_len, msg_len;


    EXEC SQL WHENEVER SQLERROR CONTINUE;

    buf_len = sizeof(msg);
    sqlglm(msg, &buf_len, &msg_len);

    printf("\nORACLE error detected:");
    printf("\n%.*s \n", msg_len, msg);

    EXEC SQL ROLLBACK WORK RELEASE;

    exit (129);
}