00001 00002 /* 00003 * THIS FILE IS UNDER RCS - DO NOT MODIFY UNLESS YOU HAVE 00004 * CHECKED IT OUT USING THE COMMAND CHECKOUT. 00005 * 00006 * $Id: putaway_8c-source.html 2161 2006-05-19 16:55:03Z paulf $ 00007 * 00008 * Revision history: 00009 * $Log$ 00009 * Revision 1.1 2006/05/19 16:55:02 paulf 00009 * first inclusion 00009 * 00010 * Revision 1.10 2002/03/20 21:07:01 cjbryan 00011 * added EventSubnet to SEISPA_next_ev call 00012 * 00013 * 00014 * 3-feb-2001, S. Flower (British Geological Survey) 00015 * Added code for new 'gse_int' and 'seisan' output data types 00016 * All new code is prefixed with the initials 'SMF' 00017 00018 * Revision 1.8 2001/04/12 03:47:36 lombard 00019 * Added include file putaway.h for function prototypes 00020 * Removed MaxTraceMsg argument from PA_init(), no longer used. 00021 * 00022 * Revision 1.7 2001/03/22 20:56:29 cjbryan 00023 * deleted EventInst from PA_next_ev function call as it is no 00024 * longer needed by any of the putaway routines 00025 * cleaned up all other relic uses of EventInst and EventMod 00026 * 00027 * Revision 1.6 2001/03/21 16:40:40 alex 00028 * deleted now extraneous EventMod variable 00029 * 00030 * Revision 1.5 2001/03/21 02:15:28 alex 00031 * added EventSubnet to SUDSPA_next_ev call 00032 * 00033 * Revision 1.4 2000/07/08 19:26:05 lombard 00034 * replace `=' in if statements with `=='; two of these were in PA_close(). 00035 * 00036 * Revision 1.3 2000/03/14 18:35:11 lucky 00037 * *** empty log message *** 00038 * 00039 * Revision 1.2 2000/03/10 23:21:05 davidk 00040 * changed the putaway routines so that OutputFormat is specified at 00041 * initialization instead of per SCN. Consolidated all of the EventID's 00042 * so that now there is a single EventID string that is passed into 00043 * PA_next_ev. 00044 * / 00045 * 00046 * Revision 1.1 2000/02/14 18:51:48 lucky 00047 * Initial revision 00048 * 00049 * 00050 */ 00051 00052 /* 00053 putaway.c 00054 00055 Thu Jul 22 13:21:09 MDT 1999 lucky 00056 00057 Separated the putaway routines for the following output 00058 formats currently supported: 00059 ah 00060 sac 00061 suds 00062 seisan 00063 gse_int 00064 tank 00065 00066 This file will now become a library object, so that it can be 00067 used by both trig2disk and wave2disk. Therefore, adding a new 00068 output format will only require changing this file. 00069 00070 00071 Wed Oct 20 09:53:50 MDT 1999 lucky 00072 00073 Fixed a bug which limited the size of the OutBuffer. 00074 00075 00076 */ 00077 00078 #include <string.h> 00079 #include <earthworm.h> 00080 #include <ws_clientII.h> 00081 #include <ahhead.h> /* for AHHEADSIZE */ 00082 #include <putaway.h> 00083 #include <pa_subs.h> 00084 #include <sachead.h> /* for SACHEADERSIZE */ 00085 00086 /* SMF: definitions for GSE and SEIsan putaway routines */ 00087 #include "gsehead.h" 00088 #include "seihead.h" 00089 00090 #define AH_FORMAT 0 00091 #define SAC_FORMAT 1 00092 #define SUDS_FORMAT 2 00093 #define TANK_FORMAT 3 00094 /* SMF: new GSE format code - we use GSE_INT to allow future expansion 00095 * to the other GSE sub-format types (CM6 and CM8) */ 00096 #define GSE_INT_FORMAT 4 00097 /* SMF: new SEIsan format code */ 00098 #define SEI_FORMAT 5 00099 00100 00101 /* Initialization function, 00102 * This is the Put Away startup intializer. This is called when * 00103 * the system first comes up. Here is a chance to look around * 00104 * and see if it's possible to do business, and to complain * 00105 * if not ,BEFORE an event has to be processed. * 00106 */ 00107 int PA_init (char *DataFormat, long TraceBufferLen, long *OutBufferLen, 00108 int *FormatInd, char *OutDir, char * OutputFormat, int debug) 00109 { 00110 00111 00112 if ((DataFormat == NULL) || (TraceBufferLen <= 0) || 00113 (OutBufferLen == NULL) || (FormatInd == NULL)) 00114 { 00115 logit ("", "waveputaway: invalid parameters passed in.\n"); 00116 return EW_FAILURE; 00117 } 00118 00119 00120 /* size OutBuffer to include header info */ 00121 if (strcmp (DataFormat,"ah") == 0) 00122 { 00123 *FormatInd = AH_FORMAT; 00124 *OutBufferLen = TraceBufferLen + AHHEADSIZE; 00125 if (AHPA_init (OutBufferLen, OutDir, debug) != EW_SUCCESS) 00126 { 00127 logit("", "waveputaway: Call to AHPA_init failed!\n" ); 00128 return EW_FAILURE; 00129 } 00130 00131 } 00132 else if (strcmp (DataFormat,"sac") == 0) 00133 { 00134 *FormatInd = SAC_FORMAT; 00135 *OutBufferLen = TraceBufferLen + SACHEADERSIZE; 00136 if (SACPA_init (*OutBufferLen, OutDir, OutputFormat, debug) != EW_SUCCESS) 00137 { 00138 logit("", "waveputaway: Call to SACPA_init failed!\n" ); 00139 return EW_FAILURE; 00140 } 00141 } 00142 else if (strcmp (DataFormat,"suds") == 0) 00143 { 00144 *FormatInd = SUDS_FORMAT; 00145 *OutBufferLen = TraceBufferLen; 00146 if (SUDSPA_init (*OutBufferLen, OutDir, OutputFormat, debug) != EW_SUCCESS) 00147 { 00148 logit("", "waveputaway: Call to SUDSPA_init failed!\n" ); 00149 return EW_FAILURE; 00150 } 00151 } 00152 else if (strcmp (DataFormat,"tank") == 0) 00153 { 00154 *FormatInd = TANK_FORMAT; 00155 if (TANKPA_init (OutDir, debug) != EW_SUCCESS) 00156 { 00157 logit("", "waveputaway: Call to TANKPA_init failed!\n" ); 00158 return EW_FAILURE; 00159 } 00160 } 00161 /* SMF: new code for GSE */ 00162 else if (strcmp (DataFormat,"gse_int") == 0) 00163 { 00164 *FormatInd = GSE_INT_FORMAT; 00165 *OutBufferLen = TraceBufferLen; 00166 if (GSEPA_init (OutDir, OutputFormat, debug) != EW_SUCCESS) 00167 { 00168 logit("", "waveputaway: Call to GSEPA_init failed!\n" ); 00169 return EW_FAILURE; 00170 } 00171 } 00172 /* SMF: new code for SEIsan */ 00173 else if (strcmp (DataFormat,"seisan") == 0) 00174 { 00175 *FormatInd = SEI_FORMAT; 00176 *OutBufferLen = TraceBufferLen; 00177 if (SEIPA_init (OutDir, OutputFormat, debug) != EW_SUCCESS) 00178 { 00179 logit("", "waveputaway: Call to SEIPA_init failed!\n" ); 00180 return EW_FAILURE; 00181 } 00182 } 00183 else 00184 { 00185 logit("","waveputaway: undefined DataFormat: %s\n", DataFormat); 00186 return EW_FAILURE; 00187 } 00188 00189 00190 00191 00192 return EW_SUCCESS; 00193 00194 } 00195 00196 00197 /**************************************************************************** 00198 * This is the Put Away event initializer. It's called when a snippet 00199 * has been received, and is about to be processed. 00200 * It gets to see the pointer to the TraceRequest array, 00201 * and the number of loaded trace structures. 00202 *****************************************************************************/ 00203 int PA_next_ev (char *EventID, TRACE_REQ *trace_req, int num_req, 00204 int FormatInd, char *OutDir, char *EventDate, 00205 char *EventTime, char *EventSubnet, int debug) 00206 { 00207 00208 00209 if ((trace_req == NULL) || (OutDir == NULL) || (EventDate == NULL) || 00210 (EventTime == NULL) || (EventID == NULL)) 00211 { 00212 logit ("", "waveputaway: Invalid parameters passed in!\n"); 00213 return EW_FAILURE; 00214 } 00215 00216 00217 if (FormatInd == AH_FORMAT) 00218 { 00219 if (AHPA_next_ev (trace_req, num_req, OutDir, 00220 EventDate, EventTime, debug) != EW_SUCCESS) 00221 { 00222 logit ("", "waveputaway: Call to AHPA_next_ev failed!\n"); 00223 return EW_FAILURE; 00224 } 00225 } 00226 else if (FormatInd == SAC_FORMAT) 00227 { 00228 if (SACPA_next_ev (EventID, trace_req, num_req, OutDir, 00229 EventDate, EventTime, debug) != EW_SUCCESS) 00230 { 00231 logit ("", "waveputaway: Call to SACPA_next_ev failed!\n"); 00232 return EW_FAILURE; 00233 } 00234 } 00235 else if (FormatInd == SUDS_FORMAT) 00236 { 00237 if (SUDSPA_next_ev(EventID, trace_req, num_req, OutDir, EventDate, 00238 EventTime, EventSubnet, debug) != EW_SUCCESS) 00239 { 00240 logit ("", "waveputaway: Call to SUDSPA_next_ev failed!\n"); 00241 return EW_FAILURE; 00242 } 00243 00244 } 00245 else if (FormatInd == TANK_FORMAT) 00246 { 00247 if (TANKPA_next_ev (EventID, OutDir, EventDate, 00248 EventTime, debug) != EW_SUCCESS) 00249 { 00250 logit ("", "waveputaway: Call to TANKPA_next_ev failed!\n"); 00251 return EW_FAILURE; 00252 } 00253 } 00254 /* SMF: new code for GSE */ 00255 else if (FormatInd == GSE_INT_FORMAT) 00256 { 00257 if (GSEPA_next_ev (trace_req, num_req, OutDir, 00258 EventDate, EventTime, debug) != EW_SUCCESS) 00259 { 00260 logit ("", "waveputaway: Call to GSEPA_next_ev failed!\n"); 00261 return EW_FAILURE; 00262 } 00263 } 00264 /* SMF: new code for SEIsan */ 00265 else if (FormatInd == SEI_FORMAT) 00266 { 00267 if (SEIPA_next_ev (trace_req, num_req, OutDir, 00268 EventDate, EventTime, EventSubnet, debug) != EW_SUCCESS) 00269 { 00270 logit ("", "waveputaway: Call to SEIPA_next_ev failed!\n"); 00271 return EW_FAILURE; 00272 } 00273 } 00274 else 00275 { 00276 logit ("", "waveputaway: undefined DataFormat: %d!\n", FormatInd); 00277 return EW_FAILURE; 00278 } 00279 00280 00281 return EW_SUCCESS; 00282 } 00283 00284 00285 00286 /***************************************************************************** 00287 * This is the working entry point into the disposal system. This routine 00288 * gets called for each trace snippet which has been recovered. It gets 00289 * to see the corresponding SNIPPET structure, and the event id 00290 *****************************************************************************/ 00291 int PA_next (TRACE_REQ *getThis, int FormatInd, 00292 double GapThresh, long OutBufferLen, int debug) 00293 { 00294 00295 if (getThis == NULL) 00296 { 00297 logit ("e", "Invalid arguments passed in.\n"); 00298 return EW_FAILURE; 00299 } 00300 00301 if (FormatInd == AH_FORMAT) 00302 { 00303 if (AHPA_next (getThis, GapThresh, OutBufferLen, debug) != EW_SUCCESS) 00304 { 00305 logit("", "waveputaway: Call to AHPA_next failed!\n"); 00306 return EW_FAILURE; 00307 } 00308 } 00309 else if (FormatInd == SAC_FORMAT) 00310 { 00311 if (SACPA_next (getThis, GapThresh, OutBufferLen, debug) != EW_SUCCESS) 00312 { 00313 logit("", "waveputaway: Call to SACPA_next failed!\n"); 00314 return EW_FAILURE; 00315 } 00316 } 00317 else if (FormatInd == SUDS_FORMAT) 00318 { 00319 if (SUDSPA_next (getThis, GapThresh, OutBufferLen, debug) != EW_SUCCESS) 00320 { 00321 logit("", "waveputaway: Call to SUDSPA_next failed!\n"); 00322 return EW_FAILURE; 00323 } 00324 } 00325 else if (FormatInd == TANK_FORMAT) 00326 { 00327 if (TANKPA_next (getThis, debug) != EW_SUCCESS) 00328 { 00329 logit("", "waveputaway: Call to TANKPA_next failed!\n"); 00330 return EW_FAILURE; 00331 } 00332 } 00333 /* SMF: new code for GSE */ 00334 else if (FormatInd == GSE_INT_FORMAT) 00335 { 00336 if (GSEPA_next (getThis, GapThresh, debug) != EW_SUCCESS) 00337 { 00338 logit("", "waveputaway: Call to GSEPA_next failed!\n"); 00339 return EW_FAILURE; 00340 } 00341 } 00342 /* SMF: new code for SEIsan */ 00343 else if (FormatInd == SEI_FORMAT) 00344 { 00345 if (SEIPA_next (getThis, GapThresh, debug) != EW_SUCCESS) 00346 { 00347 logit("", "waveputaway: Call to SEIPA_next failed!\n"); 00348 return EW_FAILURE; 00349 } 00350 } 00351 else 00352 { 00353 logit("", "waveputaway: undefined DataFormat: %d\n", FormatInd); 00354 return EW_FAILURE; 00355 } 00356 00357 return EW_SUCCESS; 00358 00359 } 00360 00361 00362 /************************************************************************ 00363 * This is the Put Away end event routine. It's called after we've * 00364 * * 00365 * finished processing one event. * 00366 *************************************************************************/ 00367 int PA_end_ev (int FormatInd, int debug) 00368 { 00369 00370 if (FormatInd == AH_FORMAT) 00371 { 00372 if (AHPA_end_ev (debug) != EW_SUCCESS) 00373 { 00374 logit ("", "waveputaway: Call to AHPA_end_ev failed!\n"); 00375 return EW_FAILURE; 00376 } 00377 } 00378 else if (FormatInd == SAC_FORMAT) 00379 { 00380 if (SACPA_end_ev (debug) != EW_SUCCESS) 00381 { 00382 logit ("", "waveputaway: Call to SACPA_end_ev failed!\n"); 00383 return EW_FAILURE; 00384 } 00385 } 00386 else if (FormatInd == SUDS_FORMAT) 00387 { 00388 if (SUDSPA_end_ev (debug) != EW_SUCCESS) 00389 { 00390 logit ("", "waveputaway: Call to SUDSPA_end_ev failed!\n"); 00391 return EW_FAILURE; 00392 } 00393 } 00394 else if (FormatInd == TANK_FORMAT) 00395 { 00396 if (TANKPA_end_ev (debug) != EW_SUCCESS) 00397 { 00398 logit ("", "waveputaway: Call to TANKPA_end_ev failed!\n"); 00399 return EW_FAILURE; 00400 } 00401 } 00402 /* SMF: new code for GSE */ 00403 else if (FormatInd == GSE_INT_FORMAT) 00404 { 00405 if (GSEPA_end_ev (debug) != EW_SUCCESS) 00406 { 00407 logit ("", "waveputaway: Call to GSEPA_end_ev failed!\n"); 00408 return EW_FAILURE; 00409 } 00410 } 00411 /* SMF: new code for SEIsan */ 00412 else if (FormatInd == SEI_FORMAT) 00413 { 00414 if (SEIPA_end_ev (debug) != EW_SUCCESS) 00415 { 00416 logit ("", "waveputaway: Call to SEIPA_end_ev failed!\n"); 00417 return EW_FAILURE; 00418 } 00419 } 00420 else 00421 { 00422 logit ("", "waveputaway: undefined DataFormat: %d\n", FormatInd); 00423 return EW_FAILURE; 00424 } 00425 00426 return EW_SUCCESS; 00427 } 00428 00429 /************************************************************************ 00430 * This is the Put Away close routine. It's called after when * 00431 * we're being shut down. * 00432 *************************************************************************/ 00433 int PA_close (int FormatInd, int debug) 00434 { 00435 00436 if (FormatInd == AH_FORMAT) 00437 { 00438 if (AHPA_close (debug) != EW_SUCCESS) 00439 { 00440 logit ("", "waveputaway: Call to AHPA_close failed!\n"); 00441 return EW_FAILURE; 00442 } 00443 } 00444 else if (FormatInd == SAC_FORMAT) 00445 { 00446 if (SACPA_close (debug) != EW_SUCCESS) 00447 { 00448 logit ("", "waveputaway: Call to SACPA_close failed!\n"); 00449 return EW_FAILURE; 00450 } 00451 } 00452 else if (FormatInd == SUDS_FORMAT) 00453 { 00454 if (SUDSPA_close (debug) != EW_SUCCESS) 00455 { 00456 logit ("", "waveputaway: Call to SUDSPA_close failed!\n"); 00457 return EW_FAILURE; 00458 } 00459 } 00460 else if (FormatInd == TANK_FORMAT) 00461 { 00462 if (TANKPA_close (debug) != EW_SUCCESS) 00463 { 00464 logit ("", "waveputaway: Call to TANKPA_close failed!\n"); 00465 return EW_FAILURE; 00466 } 00467 } 00468 /* SMF: new code for GSE */ 00469 else if (FormatInd == GSE_INT_FORMAT) 00470 { 00471 if (GSEPA_close (debug) != EW_SUCCESS) 00472 { 00473 logit ("", "waveputaway: Call to GSEPA_close failed!\n"); 00474 return EW_FAILURE; 00475 } 00476 } 00477 /* SMF: new code for SEIsan */ 00478 else if (FormatInd == SEI_FORMAT) 00479 { 00480 if (SEIPA_close (debug) != EW_SUCCESS) 00481 { 00482 logit ("", "waveputaway: Call to SEIPA_close failed!\n"); 00483 return EW_FAILURE; 00484 } 00485 } 00486 else 00487 { 00488 logit ("", "waveputaway: undefined DataFormat: %d\n", FormatInd); 00489 return EW_FAILURE; 00490 } 00491 00492 return EW_SUCCESS; 00493 00494 }