Changeset 6836


Ignore:
Timestamp:
10/13/16 15:36:06 (3 years ago)
Author:
kevin
Message:

Updated with version 2.18

Location:
trunk/src/libsrc/util/libmseed
Files:
95 added
1 deleted
30 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/libsrc/util/libmseed/ChangeLog

    r6803 r6836  
     12016.286: 2.18 
     2        - Remove limitation on sample rate before calling ms_genfactmult() 
     3        in the normal path of packing records.  Previously generating the 
     4        factor and multiplier was not attempted for rates higher than 
     5        32,767. 
     6 
     72016.281: 2.18rc4 
     8        - ms_genfactmult() now support a much larger range of integer 
     9        sample rates and periods. 
     10        - ms_genfactmult() now sets the factor and multiplier using the 
     11        SECONDS/SAMPLE notation for sample rates less than 1.0 to retain 
     12        precision for low rates. 
     13        - ms_genfactmult() now assumes the specified rate is a sample 
     14        period in seconds if the samprate value is negative. 
     15        - Add ms_rsqrt64() as a general use reciprocal sqrt for doubles. 
     16        - Use memcpy() instead of assignment when unpacking float32 and 
     17        float64 samples to avoid problems with NaN's.  Thanks Lion Krischer. 
     18        - Add test for reading records without Blockette 1000. 
     19        - Reformat all source code using included clang-format profile. 
     20 
     212016.277: 
     22        - A more elegant sanity check for output length in packing by mbyt. 
     23 
     242016:276: 2.18rc3 
     25        - Improvements for test suite, more consistency. 
     26        - Remove msr_decode_steim? from libmseed.def, they are internal. 
     27        - Add sanity to length check before memset calls in packing functions. 
     28 
     292016:274: 2.18rc2 
     30        - Check for environment variables ENCODE_DEBUG and DECODE_DEBUG 
     31        and set debugging output, at this point it is Steim frame details 
     32        and differences being encoded/decoded. 
     33        - Fix padding in steim[12] encoding routines. 
     34        - Remove unneeded output buffer checks in steim[12] decoding routines. 
     35 
     362016.272: 2.18rc1 
     37        - Replace data sample packing and unpacking routines from qlib2 with 
     38        new routines developed from scratch.  All code is now LGPL licensed. 
     39        - Add test suite with tests for encoding, decoding, parsing, etc. 
     40        - Update licensing to GNU-LGPL version 3 and include (L)GPL licenses 
     41        in LICENSE.txt. 
     42 
     432015.053: 
     44        - Define needed C99 int types for MSVC 2012 or earlier.  Previously 
     45        this was only done for versions earlier than MSVC 2010. 
     46 
    1472015.213: 2.17 
    248        - Round Fixed Section Data Header start time values to the nearest 
     
    3076        standard headers except for a few platform specific cases. 
    3177        - Convert all printf() and scanf() usage of %lld for 64-bit integers 
    32         to use the C99 PRId64 and SCNd64 macros for portability (MingGW). 
     78        to use the C99 PRId64 and SCNd64 macros for portability (MinGW). 
    3379        - Change detection of Linux/Cygwin to set global define LMP_LINUX 
    3480        instead of LMP_GLIB2 (now marked as deprecated). 
  • trunk/src/libsrc/util/libmseed/INSTALL

    r5445 r6836  
    99A simple 'make' on most Unix-like systems should build the library. 
    1010 
    11 The included Makefile should work for most Unix-like environments; a 
    12 special target of 'gcc' will explicitly use gcc with '-02' 
    13 optimization and more warnings.  By default a statically linked 
    14 version of the library is built: 'libmseed.a'. 
     11The included Makefile should work for most Unix-like environments and 
     12most make variants; it is know to work with GNU make. 
    1513 
    16 Using gcc it is possible to build a shared library with 'make shared'. 
    17 If 'make' has been run before 'make shared' the object files will 
    18 need to be cleaned up using 'make clean' before running 'make shared'. 
     14The CC and CFLAGS environment variables can be set to control the build. 
    1915 
    20 -- Mac OSX (Darwin) -- 
     16By default a statically linked version of the library is built: 'libmseed.a'. 
     17 
     18With GCC, clang or compatible build tools it is possible to build a shared 
     19library with 'make shared'. 
     20 
     21-- macOS -- 
    2122 
    2223A static library can be compiled using the above Unix instructions, 
    23 just run 'make'.  Using gcc it is possible to build a dynamic library 
    24 with 'make dynamic'.  If 'make' has been run before 'make dynamic' the 
    25 object files will need to be cleaned up using 'make clean' before 
    26 running 'make dynamic'. 
     24just run 'make'. 
     25 
     26Using GCC, clang or compatible build tools it is possible to build a dynamic 
     27library with 'make dynamic'. 
    2728 
    2829-- Windows (Win32) -- 
  • trunk/src/libsrc/util/libmseed/Makefile

    r6803 r6836  
    66 
    77MAJOR_VER = 2 
    8 MINOR_VER = 17 
     8MINOR_VER = 18 
    99CURRENT_VER = $(MAJOR_VER).$(MINOR_VER) 
    1010COMPAT_VER = $(MAJOR_VER).$(MINOR_VER) 
     
    5050        ln -sf $(LIB_DYN) $(LIB_DYN_ALIAS) 
    5151 
     52test: static FORCE 
     53        @$(MAKE) -C test test 
     54 
    5255clean: 
    53         rm -f $(LIB_OBJS) $(LIB_DOBJS) $(LIB_A) $(LIB_SO_FILENAME) $(LIB_SO) $(LIB_SO_ALIAS) $(LIB_DYN) $(LIB_DYN_ALIAS) 
     56        @rm -f $(LIB_OBJS) $(LIB_DOBJS) $(LIB_A) $(LIB_SO_FILENAME) $(LIB_SO) $(LIB_SO_ALIAS) $(LIB_DYN) $(LIB_DYN_ALIAS) 
     57        @$(MAKE) -C test clean 
     58        @echo "All clean." 
    5459 
    5560install: 
     
    6873.c.lo: 
    6974        $(CC) $(CFLAGS) -fPIC -c $< -o $@ 
     75 
     76FORCE: 
  • trunk/src/libsrc/util/libmseed/Makefile.wat

    r6242 r6836  
    5353lookup.obj:     lookup.c libmseed.h 
    5454msrutils.obj:   msrutils.c libmseed.h 
    55 pack.obj:       pack.c libmseed.h packdata.h steimdata.h 
    56 packdata.obj:   packdata.c libmseed.h packdata.h steimdata.h 
     55pack.obj:       pack.c libmseed.h packdata.h 
     56packdata.obj:   packdata.c libmseed.h packdata.h 
    5757traceutils.obj: traceutils.c libmseed.h 
    5858tracelist.obj:  tracelist.c libmseed.h 
    5959parseutils.obj: parseutils.c libmseed.h 
    60 unpack.obj:     unpack.c libmseed.h unpackdata.h steimdata.h 
    61 unpackdata.obj: unpackdata.c libmseed.h unpackdata.h steimdata.h 
     60unpack.obj:     unpack.c libmseed.h unpackdata.h 
     61unpackdata.obj: unpackdata.c libmseed.h unpackdata.h 
    6262logging.obj:    logging.c libmseed.h 
    6363 
  • trunk/src/libsrc/util/libmseed/README

    r6803 r6836  
    1111full data description. 
    1212 
    13 The library has been tested in Linux, Mac OSX (Darwin), Solaris and 
    14 Win32 environments. 
     13The library should work in Linux, BSD (and derivatives like macOS), 
     14Solaris and Win32 environments. 
    1515 
    1616For installation instructions see the INSTALL file.  For further 
     
    2121-- License -- 
    2222 
     23Copyright (C) 2016 Chad Trabant, IRIS Data Management Center 
     24 
    2325This library is free software; you can redistribute it and/or modify 
    24 it under the terms of the GNU Library General Public License as 
    25 published by the Free Software Foundation; either version 2 of the 
     26it under the terms of the GNU Lesser General Public License as 
     27published by the Free Software Foundation; either version 3 of the 
    2628License, or (at your option) any later version. 
    2729 
     
    2931WITHOUT ANY WARRANTY; without even the implied warranty of 
    3032MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
    31 Library General Public License (GNU-LGPL) for more details.  The 
    32 GNU-LGPL and further information can be found here: 
    33 http://www.gnu.org/licenses/ 
     33Lesser General Public License (GNU-LGPL) for more details. 
    3434 
     35You should have received a copy of the GNU Lesser General Public 
     36License along with this software. 
     37If not, see <https://www.gnu.org/licenses/>. 
    3538 
    36 Chad Trabant, IRIS Data Management Center 
     39-- Acknowlegements -- 
     40 
     41Numerous improvements have been incorporated based on feedback and 
     42patches submitted by others.  Individual acknowlegements are included 
     43in the ChangeLog. 
     44 
     45This library also uses code bits published in the public domain and 
     46acknowledgement is included in the code whenever possible. 
  • trunk/src/libsrc/util/libmseed/doc/ms_genfactmult.3

    r2598 r6836  
    1 .TH MS_GENFACTMULT 3 2004/11/22 "Libmseed API" 
     1.TH MS_GENFACTMULT 3 2016/10/07 "Libmseed API" 
    22.SH DESCRIPTION 
    33Generate SEED sample rate factor and multiplier 
     
    1717\fBms_genfactmult\fP generates an appropriate SEED sample rate 
    1818\fIfactor\fP and \fImultiplier\fP pair from a double precision sample 
    19 rate (\fIsamprate\fP).  The factor and multiplier are cast as int16_t 
    20 because that is the integer size needed for the fixed section of the 
    21 SEED data header. 
     19rate.  If \fIsamprate\fP is positive it is expected to represent a 
     20rate in samples/second, if negative is is expected to represent a 
     21period in seconds/sample. 
    2222 
    23 If the input sample rate is already integer (within 0.000001) it will 
    24 be placed into the factor and the multiplier will be set to 1. 
     23Non-integer sample rates and periods are supported between 32767.0 and 
     241/32767.0.  An error will be returned for non-integer rates and 
     25periods outside this range. 
    2526 
    26 An error will be produced if the sample rate is very high (> 32727) or 
    27 negative. 
     27Integer sample rates and periods are supported between 1 and the 
     28maximum possible value (32767 * 32767).  Values from 1 to 32767 are 
     29represented directly.  Values larger than 32767 are factored and 
     30represented exactly when possible and approximated otherwise, with the 
     31discrepency becoming larger as the values reach the maximum possible 
     32value. 
     33 
     34The factor and multiplier are int16_t because that is the integer size 
     35needed for the fixed section of the SEED data header. 
    2836 
    2937\fBms_ratapprox\fP finds an approximate rational number for a real 
     
    3543 
    3644.SH RETURN VALUES 
    37 \fBms_genfactmult\fP returns 0 on success and -1 on error. 
     45\fBms_genfactmult\fP returns 0 on success and -1 when value is outside 
     46of the supported range or error. 
    3847 
    3948\fBms_ratapprox\fP returns the number of iterations performed. 
  • trunk/src/libsrc/util/libmseed/doc/ms_ratapprox.3

    r2598 r6836  
    1 .TH MS_GENFACTMULT 3 2004/11/22 "Libmseed API" 
     1.TH MS_GENFACTMULT 3 2016/10/07 "Libmseed API" 
    22.SH DESCRIPTION 
    33Generate SEED sample rate factor and multiplier 
     
    1717\fBms_genfactmult\fP generates an appropriate SEED sample rate 
    1818\fIfactor\fP and \fImultiplier\fP pair from a double precision sample 
    19 rate (\fIsamprate\fP).  The factor and multiplier are cast as int16_t 
    20 because that is the integer size needed for the fixed section of the 
    21 SEED data header. 
     19rate.  If \fIsamprate\fP is positive it is expected to represent a 
     20rate in samples/second, if negative is is expected to represent a 
     21period in seconds/sample. 
    2222 
    23 If the input sample rate is already integer (within 0.000001) it will 
    24 be placed into the factor and the multiplier will be set to 1. 
     23Non-integer sample rates and periods are supported between 32767.0 and 
     241/32767.0.  An error will be returned for non-integer rates and 
     25periods outside this range. 
    2526 
    26 An error will be produced if the sample rate is very high (> 32727) or 
    27 negative. 
     27Integer sample rates and periods are supported between 1 and the 
     28maximum possible value (32767 * 32767).  Values from 1 to 32767 are 
     29represented directly.  Values larger than 32767 are factored and 
     30represented exactly when possible and approximated otherwise, with the 
     31discrepency becoming larger as the values reach the maximum possible 
     32value. 
     33 
     34The factor and multiplier are int16_t because that is the integer size 
     35needed for the fixed section of the SEED data header. 
    2836 
    2937\fBms_ratapprox\fP finds an approximate rational number for a real 
     
    3543 
    3644.SH RETURN VALUES 
    37 \fBms_genfactmult\fP returns 0 on success and -1 on error. 
     45\fBms_genfactmult\fP returns 0 on success and -1 when value is outside 
     46of the supported range or error. 
    3847 
    3948\fBms_ratapprox\fP returns the number of iterations performed. 
  • trunk/src/libsrc/util/libmseed/doc/ms_readleapsecondfile.3

    r6260 r6836  
    1 .TH MS_READLEAPSECONDS 3 2015/03/02 "Libmseed API" 
     1.TH MS_READLEAPSECONDS 3 2016/10/01 "Libmseed API" 
    22.SH DESCRIPTION 
    33Read a leap second file into a global buffer 
     
    3232 
    3333Usually the most recent version of this file is available here: 
    34 http://www.ietf.org/timezones/data/leap-seconds.list 
     34https://www.ietf.org/timezones/data/leap-seconds.list 
    3535 
    3636.SH RETURN VALUES 
  • trunk/src/libsrc/util/libmseed/doc/ms_readleapseconds.3

    r6260 r6836  
    1 .TH MS_READLEAPSECONDS 3 2015/03/02 "Libmseed API" 
     1.TH MS_READLEAPSECONDS 3 2016/10/01 "Libmseed API" 
    22.SH DESCRIPTION 
    33Read a leap second file into a global buffer 
     
    3232 
    3333Usually the most recent version of this file is available here: 
    34 http://www.ietf.org/timezones/data/leap-seconds.list 
     34https://www.ietf.org/timezones/data/leap-seconds.list 
    3535 
    3636.SH RETURN VALUES 
  • trunk/src/libsrc/util/libmseed/example/msview.c

    r6803 r6836  
    99 * Written by Chad Trabant, ORFEUS/EC-Project MEREDIAN 
    1010 * 
    11  * modified 2015.108 
    12  ***************************************************************************/ 
    13  
     11 * modified 2016.233 
     12 ***************************************************************************/ 
     13 
     14#include <errno.h> 
    1415#include <stdio.h> 
    1516#include <stdlib.h> 
    1617#include <string.h> 
    1718#include <time.h> 
    18 #include <errno.h> 
    1919 
    2020#ifndef WIN32 
    21   #include <signal.h> 
    22   static void term_handler (int sig); 
     21#include <signal.h> 
     22static void term_handler (int sig); 
    2323#endif 
    2424 
     
    2828#define PACKAGE "msview" 
    2929 
    30 static flag  verbose    = 0; 
    31 static flag  ppackets   = 0; 
    32 static flag  basicsum   = 0; 
    33 static int   reclen     = -1; 
    34 static char *inputfile  = 0; 
     30static flag verbose = 0; 
     31static flag ppackets = 0; 
     32static flag basicsum = 0; 
     33static int printdata = 0; 
     34static int reclen = -1; 
     35static char *inputfile = 0; 
    3536 
    3637static int parameter_proc (int argcount, char **argvec); 
     
    4344  MSRecord *msr = 0; 
    4445 
    45   int dataflag   = 0; 
    46   int64_t totalrecs  = 0; 
     46  int64_t totalrecs = 0; 
    4747  int64_t totalsamps = 0; 
    4848  int retcode; 
     
    5454  sa.sa_flags = SA_RESTART; 
    5555  sigemptyset (&sa.sa_mask); 
    56    
     56 
    5757  sa.sa_handler = term_handler; 
    5858  sigaction (SIGINT, &sa, NULL); 
    5959  sigaction (SIGQUIT, &sa, NULL); 
    6060  sigaction (SIGTERM, &sa, NULL); 
    61    
     61 
    6262  sa.sa_handler = SIG_IGN; 
    6363  sigaction (SIGHUP, &sa, NULL); 
    6464  sigaction (SIGPIPE, &sa, NULL); 
    6565#endif 
    66    
     66 
    6767  /* Process given parameters (command line and parameter file) */ 
    6868  if (parameter_proc (argc, argv) < 0) 
    6969    return -1; 
    70    
     70 
    7171  /* Loop over the input file */ 
    72   while ( (retcode = ms_readmsr (&msr, inputfile, reclen, NULL, NULL, 1, 
    73                                  dataflag, verbose)) == MS_NOERROR ) 
    74     { 
    75       totalrecs++; 
    76       totalsamps += msr->samplecnt; 
    77        
    78       msr_print (msr, ppackets); 
    79     } 
    80    
    81   if ( retcode != MS_ENDOFFILE ) 
    82     ms_log (2, "Cannot read %s: %s\n", inputfile, ms_errorstr(retcode)); 
    83    
     72  while ((retcode = ms_readmsr (&msr, inputfile, reclen, NULL, NULL, 1, 
     73                                printdata, verbose)) == MS_NOERROR) 
     74  { 
     75    totalrecs++; 
     76    totalsamps += msr->samplecnt; 
     77 
     78    msr_print (msr, ppackets); 
     79 
     80    if (printdata && msr->numsamples > 0) 
     81    { 
     82      int line, col, cnt, samplesize; 
     83      int lines = (msr->numsamples / 6) + 1; 
     84      void *sptr; 
     85 
     86      if ((samplesize = ms_samplesize (msr->sampletype)) == 0) 
     87      { 
     88        ms_log (2, "Unrecognized sample type: '%c'\n", msr->sampletype); 
     89      } 
     90 
     91      for (cnt = 0, line = 0; line < lines; line++) 
     92      { 
     93        for (col = 0; col < 6; col++) 
     94        { 
     95          if (cnt < msr->numsamples) 
     96          { 
     97            sptr = (char *)msr->datasamples + (cnt * samplesize); 
     98 
     99            if (msr->sampletype == 'i') 
     100              ms_log (0, "%10d  ", *(int32_t *)sptr); 
     101 
     102            else if (msr->sampletype == 'f') 
     103              ms_log (0, "%10.8g  ", *(float *)sptr); 
     104 
     105            else if (msr->sampletype == 'd') 
     106              ms_log (0, "%10.10g  ", *(double *)sptr); 
     107 
     108            cnt++; 
     109          } 
     110        } 
     111        ms_log (0, "\n"); 
     112 
     113        /* If only printing the first 6 samples break out here */ 
     114        if (printdata == 1) 
     115          break; 
     116      } 
     117    } 
     118  } 
     119 
     120  if (retcode != MS_ENDOFFILE) 
     121    ms_log (2, "Cannot read %s: %s\n", inputfile, ms_errorstr (retcode)); 
     122 
    84123  /* Make sure everything is cleaned up */ 
    85124  ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0); 
    86    
    87   if ( basicsum ) 
    88     ms_log (1, "Records: %"PRId64", Samples: %"PRId64"\n", 
    89             totalrecs, totalsamps); 
    90    
     125 
     126  if (basicsum) 
     127    ms_log (1, "Records: %" PRId64 ", Samples: %" PRId64 "\n", 
     128            totalrecs, totalsamps); 
     129 
    91130  return 0; 
    92 }  /* End of main() */ 
    93  
     131} /* End of main() */ 
    94132 
    95133/*************************************************************************** 
     
    106144  /* Process all command line arguments */ 
    107145  for (optind = 1; optind < argcount; optind++) 
    108     { 
    109       if (strcmp (argvec[optind], "-V") == 0) 
    110         { 
    111           ms_log (1, "%s version: %s\n", PACKAGE, VERSION); 
    112           exit (0); 
    113         } 
    114       else if (strcmp (argvec[optind], "-h") == 0) 
    115         { 
    116           usage(); 
    117           exit (0); 
    118         } 
    119       else if (strncmp (argvec[optind], "-v", 2) == 0) 
    120         { 
    121           verbose += strspn (&argvec[optind][1], "v"); 
    122         } 
    123       else if (strncmp (argvec[optind], "-p", 2) == 0) 
    124         { 
    125           ppackets += strspn (&argvec[optind][1], "p"); 
    126         } 
    127       else if (strcmp (argvec[optind], "-s") == 0) 
    128         { 
    129           basicsum = 1; 
    130         } 
    131       else if (strcmp (argvec[optind], "-r") == 0) 
    132         { 
    133           reclen = atoi (argvec[++optind]); 
    134         } 
    135       else if (strncmp (argvec[optind], "-", 1) == 0 && 
    136                strlen (argvec[optind]) > 1 ) 
    137         { 
    138           ms_log (2, "Unknown option: %s\n", argvec[optind]); 
    139           exit (1); 
    140         } 
    141       else if ( inputfile == 0 ) 
    142         { 
    143           inputfile = argvec[optind]; 
    144         } 
    145       else 
    146         { 
    147           ms_log (2, "Unknown option: %s\n", argvec[optind]); 
    148           exit (1); 
    149         } 
    150     } 
     146  { 
     147    if (strcmp (argvec[optind], "-V") == 0) 
     148    { 
     149      ms_log (1, "%s version: %s\n", PACKAGE, VERSION); 
     150      exit (0); 
     151    } 
     152    else if (strcmp (argvec[optind], "-h") == 0) 
     153    { 
     154      usage (); 
     155      exit (0); 
     156    } 
     157    else if (strncmp (argvec[optind], "-v", 2) == 0) 
     158    { 
     159      verbose += strspn (&argvec[optind][1], "v"); 
     160    } 
     161    else if (strncmp (argvec[optind], "-p", 2) == 0) 
     162    { 
     163      ppackets += strspn (&argvec[optind][1], "p"); 
     164    } 
     165    else if (strncmp (argvec[optind], "-d", 2) == 0) 
     166    { 
     167      printdata = 1; 
     168    } 
     169    else if (strncmp (argvec[optind], "-D", 2) == 0) 
     170    { 
     171      printdata = 2; 
     172    } 
     173    else if (strcmp (argvec[optind], "-s") == 0) 
     174    { 
     175      basicsum = 1; 
     176    } 
     177    else if (strcmp (argvec[optind], "-r") == 0) 
     178    { 
     179      reclen = atoi (argvec[++optind]); 
     180    } 
     181    else if (strncmp (argvec[optind], "-", 1) == 0 && 
     182             strlen (argvec[optind]) > 1) 
     183    { 
     184      ms_log (2, "Unknown option: %s\n", argvec[optind]); 
     185      exit (1); 
     186    } 
     187    else if (inputfile == 0) 
     188    { 
     189      inputfile = argvec[optind]; 
     190    } 
     191    else 
     192    { 
     193      ms_log (2, "Unknown option: %s\n", argvec[optind]); 
     194      exit (1); 
     195    } 
     196  } 
    151197 
    152198  /* Make sure an inputfile was specified */ 
    153   if ( ! inputfile ) 
    154     { 
    155       ms_log (2, "No input file was specified\n\n"); 
    156       ms_log (1, "%s version %s\n\n", PACKAGE, VERSION); 
    157       ms_log (1, "Try %s -h for usage\n", PACKAGE); 
    158       exit (1); 
    159     } 
     199  if (!inputfile) 
     200  { 
     201    ms_log (2, "No input file was specified\n\n"); 
     202    ms_log (1, "%s version %s\n\n", PACKAGE, VERSION); 
     203    ms_log (1, "Try %s -h for usage\n", PACKAGE); 
     204    exit (1); 
     205  } 
    160206 
    161207  /* Report the program version */ 
    162   if ( verbose ) 
     208  if (verbose) 
    163209    ms_log (1, "%s version: %s\n", PACKAGE, VERSION); 
    164    
     210 
    165211  return 0; 
    166 }  /* End of parameter_proc() */ 
    167  
     212} /* End of parameter_proc() */ 
    168213 
    169214/*************************************************************************** 
     
    177222  fprintf (stderr, "Usage: %s [options] file\n\n", PACKAGE); 
    178223  fprintf (stderr, 
    179            " ## Options ##\n" 
    180            " -V             Report program version\n" 
    181            " -h             Show this usage message\n" 
    182            " -v             Be more verbose, multiple flags can be used\n" 
    183            " -p             Print details of header, multiple flags can be used\n" 
    184            " -s             Print a basic summary after processing a file\n" 
    185            " -r bytes       Specify record length in bytes, required if no Blockette 1000\n" 
    186            "\n" 
    187            " file           File of Mini-SEED records\n" 
    188            "\n"); 
    189 }  /* End of usage() */ 
    190  
     224           " ## Options ##\n" 
     225           " -V             Report program version\n" 
     226           " -h             Show this usage message\n" 
     227           " -v             Be more verbose, multiple flags can be used\n" 
     228           " -p             Print details of header, multiple flags can be used\n" 
     229           " -d             Print first 6 sample values\n" 
     230           " -D             Print all sample values\n" 
     231           " -s             Print a basic summary after processing a file\n" 
     232           " -r bytes       Specify record length in bytes, required if no Blockette 1000\n" 
     233           "\n" 
     234           " file           File of Mini-SEED records\n" 
     235           "\n"); 
     236} /* End of usage() */ 
    191237 
    192238#ifndef WIN32 
  • trunk/src/libsrc/util/libmseed/fileutils.c

    r6803 r6836  
    99 ***************************************************************************/ 
    1010 
     11#include <errno.h> 
    1112#include <stdio.h> 
    1213#include <stdlib.h> 
    1314#include <string.h> 
     15#include <sys/stat.h> 
     16#include <sys/types.h> 
    1417#include <time.h> 
    15 #include <errno.h> 
    16 #include <sys/types.h> 
    17 #include <sys/stat.h> 
    1818 
    1919#include "libmseed.h" 
     
    2525 */ 
    2626int8_t packtypes[9][3] = { 
    27   { 0, 0, 0 }, 
    28   { 8, 8, 8 }, 
    29   { 11, 8, 8 }, 
    30   { 11, 8, 8 }, 
    31   { 11, 8, 8 }, 
    32   { 11, 8, 8 }, 
    33   { 13, 8, 8 }, 
    34   { 15, 8, 8 }, 
    35   { 22, 15, 10 }}; 
     27    {0, 0, 0}, 
     28    {8, 8, 8}, 
     29    {11, 8, 8}, 
     30    {11, 8, 8}, 
     31    {11, 8, 8}, 
     32    {11, 8, 8}, 
     33    {13, 8, 8}, 
     34    {15, 8, 8}, 
     35    {22, 15, 10}}; 
    3636 
    3737/********************************************************************* 
     
    6868 * |PQI-      |q |lc|chn|  size  | ...data... | chksum |q |lc|chn|  size  | ...data... | chksum  ... 
    6969 * parsing guide: 
    70  *      10    |     15 hdr       |     xx     |   8    |    15 hdr        |    xx    
     70 *      10    |     15 hdr       |     xx     |   8    |    15 hdr        |    xx 
    7171 *            |+0|+2|+4 |+7      | 
    72  *  
    73  *  
     72 * 
     73 * 
    7474 * Large-Size Pack - Type 8: (for large channel blocks) 
    7575 * _____10_____2__2___3_____15_______mod 256_______8____2__2__2___3_____15_______mod 256_______8____ ... 
     
    8787MSFileParam gMSFileParam = {NULL, "", NULL, 0, 0, 0, 0, 0, 0, 0}; 
    8888 
    89  
    9089/********************************************************************** 
    9190 * ms_readmsr: 
     
    10099int 
    101100ms_readmsr (MSRecord **ppmsr, const char *msfile, int reclen, off_t *fpos, 
    102             int *last, flag skipnotdata, flag dataflag, flag verbose) 
     101            int *last, flag skipnotdata, flag dataflag, flag verbose) 
    103102{ 
    104103  MSFileParam *msfp = &gMSFileParam; 
    105    
     104 
    106105  return ms_readmsr_main (&msfp, ppmsr, msfile, reclen, fpos, 
    107                           last, skipnotdata, dataflag, NULL, verbose); 
    108 }  /* End of ms_readmsr() */ 
    109  
     106                          last, skipnotdata, dataflag, NULL, verbose); 
     107} /* End of ms_readmsr() */ 
    110108 
    111109/********************************************************************** 
     
    122120int 
    123121ms_readmsr_r (MSFileParam **ppmsfp, MSRecord **ppmsr, const char *msfile, 
    124               int reclen, off_t *fpos, int *last, flag skipnotdata, 
    125               flag dataflag, flag verbose) 
     122              int reclen, off_t *fpos, int *last, flag skipnotdata, 
     123              flag dataflag, flag verbose) 
    126124{ 
    127125  return ms_readmsr_main (ppmsfp, ppmsr, msfile, reclen, fpos, 
    128                           last, skipnotdata, dataflag, NULL, verbose); 
    129 }  /* End of ms_readmsr_r() */ 
    130  
     126                          last, skipnotdata, dataflag, NULL, verbose); 
     127} /* End of ms_readmsr_r() */ 
    131128 
    132129/********************************************************************** 
     
    141138ms_shift_msfp (MSFileParam *msfp, int shift) 
    142139{ 
    143   if ( ! msfp ) 
     140  if (!msfp) 
    144141    return; 
    145    
    146   if ( shift <= 0 && shift > msfp->readlen ) 
    147     { 
    148       ms_log (2, "ms_shift_msfp(): Cannot shift buffer, shift: %d, readlen: %d, readoffset: %d\n", 
    149               shift, msfp->readlen, msfp->readoffset); 
    150       return; 
    151     } 
    152    
     142 
     143  if (shift <= 0 && shift > msfp->readlen) 
     144  { 
     145    ms_log (2, "ms_shift_msfp(): Cannot shift buffer, shift: %d, readlen: %d, readoffset: %d\n", 
     146            shift, msfp->readlen, msfp->readoffset); 
     147    return; 
     148  } 
     149 
    153150  memmove (msfp->rawrec, msfp->rawrec + shift, msfp->readlen - shift); 
    154151  msfp->readlen -= shift; 
    155    
    156   if ( shift < msfp->readoffset ) 
    157     { 
    158       msfp->readoffset -= shift; 
    159     } 
     152 
     153  if (shift < msfp->readoffset) 
     154  { 
     155    msfp->readoffset -= shift; 
     156  } 
    160157  else 
    161     { 
    162       msfp->filepos += (shift - msfp->readoffset); 
    163       msfp->readoffset = 0; 
    164     } 
    165    
     158  { 
     159    msfp->filepos += (shift - msfp->readoffset); 
     160    msfp->readoffset = 0; 
     161  } 
     162 
    166163  return; 
    167 }  /* End of ms_shift_msfp() */ 
    168  
     164} /* End of ms_shift_msfp() */ 
    169165 
    170166/* Macro to calculate length of unprocessed buffer */ 
     
    222218int 
    223219ms_readmsr_main (MSFileParam **ppmsfp, MSRecord **ppmsr, const char *msfile, 
    224                 int reclen, off_t *fpos, int *last, flag skipnotdata, 
    225                 flag dataflag, Selections *selections, flag verbose) 
     220                int reclen, off_t *fpos, int *last, flag skipnotdata, 
     221                flag dataflag, Selections *selections, flag verbose) 
    226222{ 
    227223  MSFileParam *msfp; 
    228224  off_t packdatasize = 0; 
    229225  int packskipsize; 
    230   int parseval = 0; 
    231   int readsize = 0; 
     226  int parseval  = 0; 
     227  int readsize  = 0; 
    232228  int readcount = 0; 
    233   int retcode = MS_NOERROR; 
    234    
    235   if ( ! ppmsr ) 
     229  int retcode   = MS_NOERROR; 
     230 
     231  if (!ppmsr) 
    236232    return MS_GENERROR; 
    237    
    238   if ( ! ppmsfp ) 
     233 
     234  if (!ppmsfp) 
    239235    return MS_GENERROR; 
    240    
     236 
    241237  msfp = *ppmsfp; 
    242    
     238 
    243239  /* Initialize the file read parameters if needed */ 
    244   if ( ! msfp ) 
    245     { 
    246       msfp = (MSFileParam *) malloc (sizeof (MSFileParam)); 
    247        
    248       if ( msfp == NULL ) 
    249         { 
    250           ms_log (2, "ms_readmsr_main(): Cannot allocate memory for MSFP\n"); 
    251           return MS_GENERROR; 
    252         } 
    253        
    254       /* Redirect the supplied pointer to the allocated params */ 
    255       *ppmsfp = msfp; 
    256        
    257       msfp->fp = NULL; 
    258       msfp->filename[0] = '\0'; 
    259       msfp->rawrec = NULL; 
    260       msfp->readlen = 0; 
     240  if (!msfp) 
     241  { 
     242    msfp = (MSFileParam *)malloc (sizeof (MSFileParam)); 
     243 
     244    if (msfp == NULL) 
     245    { 
     246      ms_log (2, "ms_readmsr_main(): Cannot allocate memory for MSFP\n"); 
     247      return MS_GENERROR; 
     248    } 
     249 
     250    /* Redirect the supplied pointer to the allocated params */ 
     251    *ppmsfp = msfp; 
     252 
     253    msfp->fp            = NULL; 
     254    msfp->filename[0]   = '\0'; 
     255    msfp->rawrec        = NULL; 
     256    msfp->readlen       = 0; 
     257    msfp->readoffset    = 0; 
     258    msfp->packtype      = 0; 
     259    msfp->packhdroffset = 0; 
     260    msfp->filepos       = 0; 
     261    msfp->filesize      = 0; 
     262    msfp->recordcount   = 0; 
     263  } 
     264 
     265  /* When cleanup is requested */ 
     266  if (msfile == NULL) 
     267  { 
     268    msr_free (ppmsr); 
     269 
     270    if (msfp->fp != NULL) 
     271      fclose (msfp->fp); 
     272 
     273    if (msfp->rawrec != NULL) 
     274      free (msfp->rawrec); 
     275 
     276    /* If the file parameters are the global parameters reset them */ 
     277    if (*ppmsfp == &gMSFileParam) 
     278    { 
     279      gMSFileParam.fp            = NULL; 
     280      gMSFileParam.filename[0]   = '\0'; 
     281      gMSFileParam.rawrec        = NULL; 
     282      gMSFileParam.readlen       = 0; 
     283      gMSFileParam.readoffset    = 0; 
     284      gMSFileParam.packtype      = 0; 
     285      gMSFileParam.packhdroffset = 0; 
     286      gMSFileParam.filepos       = 0; 
     287      gMSFileParam.filesize      = 0; 
     288      gMSFileParam.recordcount   = 0; 
     289    } 
     290    /* Otherwise free the MSFileParam */ 
     291    else 
     292    { 
     293      free (*ppmsfp); 
     294      *ppmsfp = NULL; 
     295    } 
     296 
     297    return MS_NOERROR; 
     298  } 
     299 
     300  /* Allocate reading buffer */ 
     301  if (msfp->rawrec == NULL) 
     302  { 
     303    if (!(msfp->rawrec = (char *)malloc (MAXRECLEN))) 
     304    { 
     305      ms_log (2, "ms_readmsr_main(): Cannot allocate memory for read buffer\n"); 
     306      return MS_GENERROR; 
     307    } 
     308  } 
     309 
     310  /* Sanity check: track if we are reading the same file */ 
     311  if (msfp->fp && strncmp (msfile, msfp->filename, sizeof (msfp->filename))) 
     312  { 
     313    ms_log (2, "ms_readmsr_main() called with a different file name without being reset\n"); 
     314 
     315    /* Close previous file and reset needed variables */ 
     316    if (msfp->fp != NULL) 
     317      fclose (msfp->fp); 
     318 
     319    msfp->fp            = NULL; 
     320    msfp->readlen       = 0; 
     321    msfp->readoffset    = 0; 
     322    msfp->packtype      = 0; 
     323    msfp->packhdroffset = 0; 
     324    msfp->filepos       = 0; 
     325    msfp->filesize      = 0; 
     326    msfp->recordcount   = 0; 
     327  } 
     328 
     329  /* Open the file if needed, redirect to stdin if file is "-" */ 
     330  if (msfp->fp == NULL) 
     331  { 
     332    /* Store the filename for tracking */ 
     333    strncpy (msfp->filename, msfile, sizeof (msfp->filename) - 1); 
     334    msfp->filename[sizeof (msfp->filename) - 1] = '\0'; 
     335 
     336    if (strcmp (msfile, "-") == 0) 
     337    { 
     338      msfp->fp = stdin; 
     339    } 
     340    else 
     341    { 
     342      if ((msfp->fp = fopen (msfile, "rb")) == NULL) 
     343      { 
     344        ms_log (2, "Cannot open file: %s (%s)\n", msfile, strerror (errno)); 
     345        msr_free (ppmsr); 
     346 
     347        return MS_GENERROR; 
     348      } 
     349      else 
     350      { 
     351        /* Determine file size */ 
     352        struct stat sbuf; 
     353 
     354        if (fstat (fileno (msfp->fp), &sbuf)) 
     355        { 
     356          ms_log (2, "Cannot open file: %s (%s)\n", msfile, strerror (errno)); 
     357          msr_free (ppmsr); 
     358 
     359          return MS_GENERROR; 
     360        } 
     361 
     362        msfp->filesize = sbuf.st_size; 
     363      } 
     364    } 
     365  } 
     366 
     367  /* Seek to a specified offset if requested */ 
     368  if (fpos != NULL && *fpos < 0) 
     369  { 
     370    /* Only try to seek in real files, not stdin */ 
     371    if (msfp->fp != stdin) 
     372    { 
     373      if (lmp_fseeko (msfp->fp, *fpos * -1, SEEK_SET)) 
     374      { 
     375        ms_log (2, "Cannot seek in file: %s (%s)\n", msfile, strerror (errno)); 
     376 
     377        return MS_GENERROR; 
     378      } 
     379 
     380      msfp->filepos    = *fpos * -1; 
     381      msfp->readlen    = 0; 
    261382      msfp->readoffset = 0; 
    262       msfp->packtype = 0; 
    263       msfp->packhdroffset = 0; 
    264       msfp->filepos = 0; 
    265       msfp->filesize = 0; 
    266       msfp->recordcount = 0; 
    267     } 
    268    
    269   /* When cleanup is requested */ 
    270   if ( msfile == NULL ) 
    271     { 
    272       msr_free (ppmsr); 
    273        
    274       if ( msfp->fp != NULL ) 
    275         fclose (msfp->fp); 
    276        
    277       if ( msfp->rawrec != NULL ) 
    278         free (msfp->rawrec); 
    279        
    280       /* If the file parameters are the global parameters reset them */ 
    281       if ( *ppmsfp == &gMSFileParam ) 
    282         { 
    283           gMSFileParam.fp = NULL; 
    284           gMSFileParam.filename[0] = '\0'; 
    285           gMSFileParam.rawrec = NULL; 
    286           gMSFileParam.readlen = 0; 
    287           gMSFileParam.readoffset = 0; 
    288           gMSFileParam.packtype = 0; 
    289           gMSFileParam.packhdroffset = 0; 
    290           gMSFileParam.filepos = 0; 
    291           gMSFileParam.filesize = 0; 
    292           gMSFileParam.recordcount = 0; 
    293         } 
    294       /* Otherwise free the MSFileParam */ 
    295       else 
    296         { 
    297           free (*ppmsfp); 
    298           *ppmsfp = NULL; 
    299         } 
    300        
    301       return MS_NOERROR; 
    302     } 
    303    
    304   /* Allocate reading buffer */ 
    305   if ( msfp->rawrec == NULL ) 
    306     { 
    307       if ( ! (msfp->rawrec = (char *) malloc (MAXRECLEN)) ) 
    308         { 
    309           ms_log (2, "ms_readmsr_main(): Cannot allocate memory for read buffer\n"); 
    310           return MS_GENERROR; 
    311         } 
    312     } 
    313    
    314   /* Sanity check: track if we are reading the same file */ 
    315   if ( msfp->fp && strncmp (msfile, msfp->filename, sizeof(msfp->filename)) ) 
    316     { 
    317       ms_log (2, "ms_readmsr_main() called with a different file name without being reset\n"); 
    318        
    319       /* Close previous file and reset needed variables */ 
    320       if ( msfp->fp != NULL ) 
    321         fclose (msfp->fp); 
    322        
    323       msfp->fp = NULL; 
    324       msfp->readlen = 0; 
    325       msfp->readoffset = 0; 
    326       msfp->packtype = 0; 
    327       msfp->packhdroffset = 0; 
    328       msfp->filepos = 0; 
    329       msfp->filesize = 0; 
    330       msfp->recordcount = 0; 
    331     } 
    332    
    333   /* Open the file if needed, redirect to stdin if file is "-" */ 
    334   if ( msfp->fp == NULL ) 
    335     { 
    336       /* Store the filename for tracking */ 
    337       strncpy (msfp->filename, msfile, sizeof(msfp->filename) - 1); 
    338       msfp->filename[sizeof(msfp->filename) - 1] = '\0'; 
    339        
    340       if ( strcmp (msfile, "-") == 0 ) 
    341         { 
    342           msfp->fp = stdin; 
    343         } 
    344       else 
    345         { 
    346           if ( (msfp->fp = fopen (msfile, "rb")) == NULL ) 
    347             { 
    348               ms_log (2, "Cannot open file: %s (%s)\n", msfile, strerror (errno)); 
    349               msr_free (ppmsr); 
    350                
    351               return MS_GENERROR; 
    352             } 
    353           else 
    354             { 
    355               /* Determine file size */ 
    356               struct stat sbuf; 
    357                
    358               if ( fstat (fileno(msfp->fp), &sbuf) ) 
    359                 { 
    360                   ms_log (2, "Cannot open file: %s (%s)\n", msfile, strerror (errno)); 
    361                   msr_free (ppmsr); 
    362                    
    363                   return MS_GENERROR; 
    364                 } 
    365                
    366               msfp->filesize = sbuf.st_size; 
    367             } 
    368         } 
    369     } 
    370    
    371   /* Seek to a specified offset if requested */ 
    372   if ( fpos != NULL && *fpos < 0 ) 
    373     { 
    374       /* Only try to seek in real files, not stdin */ 
    375       if ( msfp->fp != stdin ) 
    376         { 
    377           if ( lmp_fseeko (msfp->fp, *fpos * -1, SEEK_SET) ) 
    378             { 
    379               ms_log (2, "Cannot seek in file: %s (%s)\n", msfile, strerror (errno)); 
    380                
    381               return MS_GENERROR; 
    382             } 
    383            
    384           msfp->filepos = *fpos * -1; 
    385           msfp->readlen = 0; 
    386           msfp->readoffset = 0; 
    387         } 
    388     } 
    389    
     383    } 
     384  } 
     385 
    390386  /* Zero the last record indicator */ 
    391   if ( last ) 
     387  if (last) 
    392388    *last = 0; 
    393    
     389 
    394390  /* Read data and search for records */ 
    395391  for (;;) 
    396     { 
    397       /* Read more data into buffer if not at EOF and buffer has less than MINRECLEN 
     392  { 
     393    /* Read more data into buffer if not at EOF and buffer has less than MINRECLEN 
    398394       * or more data is needed for the current record detected in buffer. */ 
    399       if ( ! feof(msfp->fp) && (MSFPBUFLEN(msfp) < MINRECLEN || parseval > 0) ) 
    400         { 
    401           /* Reset offsets if no unprocessed data in buffer */ 
    402           if ( MSFPBUFLEN(msfp) <= 0 ) 
    403             { 
    404               msfp->readlen = 0; 
    405               msfp->readoffset = 0; 
    406             } 
    407           /* Otherwise shift existing data to beginning of buffer */ 
    408           else if ( msfp->readoffset > 0 ) 
    409             { 
    410               ms_shift_msfp (msfp, msfp->readoffset); 
    411             } 
    412            
    413           /* Determine read size */ 
    414           readsize = (MAXRECLEN - msfp->readlen); 
    415            
    416           /* Read data into record buffer */ 
    417           readcount = ms_fread (msfp->rawrec + msfp->readlen, 1, readsize, msfp->fp); 
    418            
    419           if ( readcount != readsize ) 
    420             { 
    421               if ( ! feof (msfp->fp) ) 
    422                 { 
    423                   ms_log (2, "Short read of %d bytes starting from %"PRId64"\n", 
    424                           readsize, msfp->filepos); 
    425                   retcode = MS_GENERROR; 
    426                   break; 
    427                 } 
    428             } 
    429            
    430           /* Update read buffer length */ 
    431           msfp->readlen += readcount; 
    432            
    433           /* File position corresponding to start of buffer; not strictly necessary */ 
    434           if ( msfp->fp != stdin ) 
    435             msfp->filepos = lmp_ftello (msfp->fp) - msfp->readlen; 
    436         } 
    437        
    438       /* Test for packed file signature at the beginning of the file */ 
    439       if ( msfp->filepos == 0 && *(MSFPREADPTR(msfp)) == 'P' && MSFPBUFLEN(msfp) >= 48 ) 
    440         { 
    441           msfp->packtype = 0; 
    442            
    443           /* Determine pack type, the negative pack type indicates initial header */ 
    444           if ( ! memcmp ("PED", MSFPREADPTR(msfp), 3) ) 
    445             msfp->packtype = -1; 
    446           else if ( ! memcmp ("PSD", MSFPREADPTR(msfp), 3) ) 
    447             msfp->packtype = -2; 
    448           else if ( ! memcmp ("PLC", MSFPREADPTR(msfp), 3) ) 
    449             msfp->packtype = -6; 
    450           else if ( ! memcmp ("PQI", MSFPREADPTR(msfp), 3) ) 
    451             msfp->packtype = -7; 
    452           else if ( ! memcmp ("PLS", MSFPREADPTR(msfp), 3) ) 
    453             msfp->packtype = -8; 
    454            
    455           if ( verbose > 0 ) 
    456             ms_log (1, "Detected packed file (%3.3s: type %d)\n", MSFPREADPTR(msfp), -msfp->packtype); 
    457         } 
    458        
    459       /* Read pack headers, initial and subsequent headers including (ignored) chksum values */ 
    460       if ( msfp->packtype && (msfp->packtype < 0 || msfp->filepos == msfp->packhdroffset) && MSFPBUFLEN(msfp) >= 48 ) 
    461         { 
    462           char hdrstr[30]; 
    463           int64_t datasize; 
    464            
    465           /* Determine bytes to skip before header: either initial ID block or type-specific chksum block */ 
    466           packskipsize = ( msfp->packtype < 0 ) ? 10 : packtypes[msfp->packtype][2]; 
    467            
    468           if ( msfp->packtype < 0 ) 
    469             msfp->packtype = -msfp->packtype; 
    470            
    471           /* Read pack length from pack header accounting for bytes that should be skipped */ 
    472           memset (hdrstr, 0, sizeof(hdrstr)); 
    473           memcpy (hdrstr, MSFPREADPTR(msfp) + (packtypes[msfp->packtype][0] + packskipsize - packtypes[msfp->packtype][1]), 
    474                   packtypes[msfp->packtype][1]); 
    475           sscanf (hdrstr, " %"SCNd64, &datasize); 
    476           packdatasize = (off_t) datasize; 
    477            
    478           /* Next pack header = File position + skipsize + header size + data size 
     395    if (!feof (msfp->fp) && (MSFPBUFLEN (msfp) < MINRECLEN || parseval > 0)) 
     396    { 
     397      /* Reset offsets if no unprocessed data in buffer */ 
     398      if (MSFPBUFLEN (msfp) <= 0) 
     399      { 
     400        msfp->readlen    = 0; 
     401        msfp->readoffset = 0; 
     402      } 
     403      /* Otherwise shift existing data to beginning of buffer */ 
     404      else if (msfp->readoffset > 0) 
     405      { 
     406        ms_shift_msfp (msfp, msfp->readoffset); 
     407      } 
     408 
     409      /* Determine read size */ 
     410      readsize = (MAXRECLEN - msfp->readlen); 
     411 
     412      /* Read data into record buffer */ 
     413      readcount = ms_fread (msfp->rawrec + msfp->readlen, 1, readsize, msfp->fp); 
     414 
     415      if (readcount != readsize) 
     416      { 
     417        if (!feof (msfp->fp)) 
     418        { 
     419          ms_log (2, "Short read of %d bytes starting from %" PRId64 "\n", 
     420                  readsize, msfp->filepos); 
     421          retcode = MS_GENERROR; 
     422          break; 
     423        } 
     424      } 
     425 
     426      /* Update read buffer length */ 
     427      msfp->readlen += readcount; 
     428 
     429      /* File position corresponding to start of buffer; not strictly necessary */ 
     430      if (msfp->fp != stdin) 
     431        msfp->filepos = lmp_ftello (msfp->fp) - msfp->readlen; 
     432    } 
     433 
     434    /* Test for packed file signature at the beginning of the file */ 
     435    if (msfp->filepos == 0 && *(MSFPREADPTR (msfp)) == 'P' && MSFPBUFLEN (msfp) >= 48) 
     436    { 
     437      msfp->packtype = 0; 
     438 
     439      /* Determine pack type, the negative pack type indicates initial header */ 
     440      if (!memcmp ("PED", MSFPREADPTR (msfp), 3)) 
     441        msfp->packtype = -1; 
     442      else if (!memcmp ("PSD", MSFPREADPTR (msfp), 3)) 
     443        msfp->packtype = -2; 
     444      else if (!memcmp ("PLC", MSFPREADPTR (msfp), 3)) 
     445        msfp->packtype = -6; 
     446      else if (!memcmp ("PQI", MSFPREADPTR (msfp), 3)) 
     447        msfp->packtype = -7; 
     448      else if (!memcmp ("PLS", MSFPREADPTR (msfp), 3)) 
     449        msfp->packtype = -8; 
     450 
     451      if (verbose > 0) 
     452        ms_log (1, "Detected packed file (%3.3s: type %d)\n", MSFPREADPTR (msfp), -msfp->packtype); 
     453    } 
     454 
     455    /* Read pack headers, initial and subsequent headers including (ignored) chksum values */ 
     456    if (msfp->packtype && (msfp->packtype < 0 || msfp->filepos == msfp->packhdroffset) && MSFPBUFLEN (msfp) >= 48) 
     457    { 
     458      char hdrstr[30]; 
     459      int64_t datasize; 
     460 
     461      /* Determine bytes to skip before header: either initial ID block or type-specific chksum block */ 
     462      packskipsize = (msfp->packtype < 0) ? 10 : packtypes[msfp->packtype][2]; 
     463 
     464      if (msfp->packtype < 0) 
     465        msfp->packtype = -msfp->packtype; 
     466 
     467      /* Read pack length from pack header accounting for bytes that should be skipped */ 
     468      memset (hdrstr, 0, sizeof (hdrstr)); 
     469      memcpy (hdrstr, MSFPREADPTR (msfp) + (packtypes[msfp->packtype][0] + packskipsize - packtypes[msfp->packtype][1]), 
     470              packtypes[msfp->packtype][1]); 
     471      sscanf (hdrstr, " %" SCNd64, &datasize); 
     472      packdatasize = (off_t)datasize; 
     473 
     474      /* Next pack header = File position + skipsize + header size + data size 
    479475           * This offset is actually to the data block chksum which is skipped by the logic above, 
    480476           * the next pack header should directly follow the chksum. */ 
    481           msfp->packhdroffset = msfp->filepos + packskipsize + packtypes[msfp->packtype][0] + packdatasize; 
    482            
    483           if ( verbose > 1 ) 
    484             ms_log (1, "Read packed file header at offset %"PRId64" (%d bytes follow), chksum offset: %"PRId64"\n", 
    485                     (msfp->filepos + packskipsize), packdatasize, 
    486                     msfp->packhdroffset); 
    487  
    488           /* Shift buffer to new reading offset (aligns records in buffer) */ 
    489           ms_shift_msfp (msfp, msfp->readoffset + (packskipsize + packtypes[msfp->packtype][0])); 
    490         } /* End of packed header processing */ 
    491        
    492       /* Check for match if selections are supplied and pack header was read, */ 
    493       /* only when enough data is in buffer and not reading from stdin pipe */ 
    494       if ( selections && msfp->packtype && packdatasize && MSFPBUFLEN(msfp) >= 48 && msfp->fp != stdin ) 
    495         { 
    496           char srcname[100]; 
    497            
    498           ms_recsrcname (MSFPREADPTR(msfp), srcname, 1); 
    499            
    500           if ( ! ms_matchselect (selections, srcname, HPTERROR, HPTERROR, NULL) ) 
    501             { 
    502               /* Update read position if next section is in buffer */ 
    503               if ( MSFPBUFLEN(msfp) >= (msfp->packhdroffset - msfp->filepos) ) 
    504                 { 
    505                   if ( verbose > 1 ) 
    506                     { 
    507                       ms_log (1, "Skipping (jump) packed section for %s (%d bytes) starting at offset %"PRId64"\n", 
    508                               srcname, (msfp->packhdroffset - msfp->filepos), msfp->filepos); 
    509                     } 
    510                    
    511                   msfp->readoffset += (msfp->packhdroffset - msfp->filepos); 
    512                   msfp->filepos = msfp->packhdroffset; 
    513                   packdatasize = 0; 
    514                 } 
    515                
    516               /* Otherwise seek to next pack header and reset reading position */ 
    517               else 
    518                 { 
    519                   if ( verbose > 1 ) 
    520                     { 
    521                       ms_log (1, "Skipping (seek) packed section for %s (%d bytes) starting at offset %"PRId64"\n", 
    522                               srcname, (msfp->packhdroffset - msfp->filepos), msfp->filepos); 
    523                     } 
    524  
    525                   if ( lmp_fseeko (msfp->fp, msfp->packhdroffset, SEEK_SET) ) 
    526                     { 
    527                       ms_log (2, "Cannot seek in file: %s (%s)\n", msfile, strerror (errno)); 
    528                        
    529                       return MS_GENERROR; 
    530                       break; 
    531                     } 
    532                    
    533                   msfp->filepos = msfp->packhdroffset; 
    534                   msfp->readlen = 0; 
    535                   msfp->readoffset = 0; 
    536                   packdatasize = 0; 
    537                 } 
    538                
    539               /* Return to top of loop for proper pack header handling */ 
    540               continue; 
    541             } 
    542         } /* End of selection processing */ 
    543        
    544       /* Attempt to parse record from buffer */ 
    545       if ( MSFPBUFLEN(msfp) >= MINRECLEN ) 
    546         { 
    547           int parselen = MSFPBUFLEN(msfp); 
    548            
    549           /* Limit the parse length to offset of pack header if present in the buffer */ 
    550           if ( msfp->packhdroffset && msfp->packhdroffset < (msfp->filepos + MSFPBUFLEN(msfp)) ) 
    551             parselen = msfp->packhdroffset - msfp->filepos; 
    552            
    553           parseval = msr_parse (MSFPREADPTR(msfp), parselen, ppmsr, reclen, dataflag, verbose); 
    554            
    555           /* Record detected and parsed */ 
    556           if ( parseval == 0 ) 
    557             { 
    558               if ( verbose > 1 ) 
    559                 ms_log (1, "Read record length of %d bytes\n", (*ppmsr)->reclen); 
    560                
    561               /* Test if this is the last record if file size is known (not pipe) */ 
    562               if ( last && msfp->filesize ) 
    563                 if ( (msfp->filesize - (msfp->filepos + (*ppmsr)->reclen)) < MINRECLEN ) 
    564                   *last = 1; 
    565                
    566               /* Return file position for this record */ 
    567               if ( fpos ) 
    568                 *fpos = msfp->filepos; 
    569                
    570               /* Update reading offset, file position and record count */ 
    571               msfp->readoffset += (*ppmsr)->reclen; 
    572               msfp->filepos += (*ppmsr)->reclen; 
    573               msfp->recordcount++; 
    574                
    575               retcode = MS_NOERROR; 
    576               break; 
    577             } 
    578           else if ( parseval < 0 ) 
    579             { 
    580               /* Skip non-data if requested */  
    581               if ( skipnotdata ) 
    582                 { 
    583                   if ( verbose > 1 ) 
    584                     { 
    585                       if ( MS_ISVALIDBLANK((char *)MSFPREADPTR(msfp)) ) 
    586                         ms_log (1, "Skipped %d bytes of blank/noise record at byte offset %"PRId64"\n", 
    587                                 MINRECLEN, msfp->filepos); 
    588                       else 
    589                         ms_log (1, "Skipped %d bytes of non-data record at byte offset %"PRId64"\n", 
    590                                 MINRECLEN, msfp->filepos); 
    591                     } 
    592                    
    593                   /* Skip MINRECLEN bytes, update reading offset and file position */ 
    594                   msfp->readoffset += MINRECLEN; 
    595                   msfp->filepos += MINRECLEN; 
    596                 } 
    597               /* Parsing errors */  
    598               else 
    599                 { 
    600                   ms_log (2, "Cannot detect record at byte offset %"PRId64": %s\n", 
    601                           msfp->filepos, msfile); 
    602                    
    603                   /* Print common errors and raw details if verbose */ 
    604                   ms_parse_raw (MSFPREADPTR(msfp), MSFPBUFLEN(msfp), verbose, -1); 
    605                    
    606                   retcode = parseval; 
    607                   break; 
    608                 } 
    609             } 
    610           else /* parseval > 0 (found record but need more data) */ 
    611             { 
    612               /* Determine implied record length if needed */ 
    613               int32_t impreclen = reclen; 
    614                
    615               /* Check for parse hints that are larger than MAXRECLEN */ 
    616               if ( (MSFPBUFLEN(msfp) + parseval) > MAXRECLEN ) 
    617                 { 
    618                   if ( skipnotdata ) 
    619                     { 
    620                       /* Skip MINRECLEN bytes, update reading offset and file position */ 
    621                       msfp->readoffset += MINRECLEN; 
    622                       msfp->filepos += MINRECLEN; 
    623                     } 
    624                   else 
    625                     { 
    626                       retcode = MS_OUTOFRANGE; 
    627                       break; 
    628                     } 
    629                 } 
    630                
    631               /* Pack header check, if pack header offset is within buffer */ 
    632               else if ( impreclen <= 0 && msfp->packhdroffset && 
    633                         msfp->packhdroffset < (msfp->filepos + MSFPBUFLEN(msfp)) ) 
    634                 { 
    635                   impreclen = msfp->packhdroffset - msfp->filepos; 
    636                    
    637                   /* Check that record length is within range and a power of 2. 
     477      msfp->packhdroffset = msfp->filepos + packskipsize + packtypes[msfp->packtype][0] + packdatasize; 
     478 
     479      if (verbose > 1) 
     480        ms_log (1, "Read packed file header at offset %" PRId64 " (%d bytes follow), chksum offset: %" PRId64 "\n", 
     481                (msfp->filepos + packskipsize), packdatasize, 
     482                msfp->packhdroffset); 
     483 
     484      /* Shift buffer to new reading offset (aligns records in buffer) */ 
     485      ms_shift_msfp (msfp, msfp->readoffset + (packskipsize + packtypes[msfp->packtype][0])); 
     486    } /* End of packed header processing */ 
     487 
     488    /* Check for match if selections are supplied and pack header was read, */ 
     489    /* only when enough data is in buffer and not reading from stdin pipe */ 
     490    if (selections && msfp->packtype && packdatasize && MSFPBUFLEN (msfp) >= 48 && msfp->fp != stdin) 
     491    { 
     492      char srcname[100]; 
     493 
     494      ms_recsrcname (MSFPREADPTR (msfp), srcname, 1); 
     495 
     496      if (!ms_matchselect (selections, srcname, HPTERROR, HPTERROR, NULL)) 
     497      { 
     498        /* Update read position if next section is in buffer */ 
     499        if (MSFPBUFLEN (msfp) >= (msfp->packhdroffset - msfp->filepos)) 
     500        { 
     501          if (verbose > 1) 
     502          { 
     503            ms_log (1, "Skipping (jump) packed section for %s (%d bytes) starting at offset %" PRId64 "\n", 
     504                    srcname, (msfp->packhdroffset - msfp->filepos), msfp->filepos); 
     505          } 
     506 
     507          msfp->readoffset += (msfp->packhdroffset - msfp->filepos); 
     508          msfp->filepos = msfp->packhdroffset; 
     509          packdatasize = 0; 
     510        } 
     511 
     512        /* Otherwise seek to next pack header and reset reading position */ 
     513        else 
     514        { 
     515          if (verbose > 1) 
     516          { 
     517            ms_log (1, "Skipping (seek) packed section for %s (%d bytes) starting at offset %" PRId64 "\n", 
     518                    srcname, (msfp->packhdroffset - msfp->filepos), msfp->filepos); 
     519          } 
     520 
     521          if (lmp_fseeko (msfp->fp, msfp->packhdroffset, SEEK_SET)) 
     522          { 
     523            ms_log (2, "Cannot seek in file: %s (%s)\n", msfile, strerror (errno)); 
     524 
     525            return MS_GENERROR; 
     526            break; 
     527          } 
     528 
     529          msfp->filepos    = msfp->packhdroffset; 
     530          msfp->readlen    = 0; 
     531          msfp->readoffset = 0; 
     532          packdatasize    = 0; 
     533        } 
     534 
     535        /* Return to top of loop for proper pack header handling */ 
     536        continue; 
     537      } 
     538    } /* End of selection processing */ 
     539 
     540    /* Attempt to parse record from buffer */ 
     541    if (MSFPBUFLEN (msfp) >= MINRECLEN) 
     542    { 
     543      int parselen = MSFPBUFLEN (msfp); 
     544 
     545      /* Limit the parse length to offset of pack header if present in the buffer */ 
     546      if (msfp->packhdroffset && msfp->packhdroffset < (msfp->filepos + MSFPBUFLEN (msfp))) 
     547        parselen = msfp->packhdroffset - msfp->filepos; 
     548 
     549      parseval = msr_parse (MSFPREADPTR (msfp), parselen, ppmsr, reclen, dataflag, verbose); 
     550 
     551      /* Record detected and parsed */ 
     552      if (parseval == 0) 
     553      { 
     554        if (verbose > 1) 
     555          ms_log (1, "Read record length of %d bytes\n", (*ppmsr)->reclen); 
     556 
     557        /* Test if this is the last record if file size is known (not pipe) */ 
     558        if (last && msfp->filesize) 
     559          if ((msfp->filesize - (msfp->filepos + (*ppmsr)->reclen)) < MINRECLEN) 
     560            *last = 1; 
     561 
     562        /* Return file position for this record */ 
     563        if (fpos) 
     564          *fpos = msfp->filepos; 
     565 
     566        /* Update reading offset, file position and record count */ 
     567        msfp->readoffset += (*ppmsr)->reclen; 
     568        msfp->filepos += (*ppmsr)->reclen; 
     569        msfp->recordcount++; 
     570 
     571        retcode = MS_NOERROR; 
     572        break; 
     573      } 
     574      else if (parseval < 0) 
     575      { 
     576        /* Skip non-data if requested */ 
     577        if (skipnotdata) 
     578        { 
     579          if (verbose > 1) 
     580          { 
     581            if (MS_ISVALIDBLANK ((char *)MSFPREADPTR (msfp))) 
     582              ms_log (1, "Skipped %d bytes of blank/noise record at byte offset %" PRId64 "\n", 
     583                      MINRECLEN, msfp->filepos); 
     584            else 
     585              ms_log (1, "Skipped %d bytes of non-data record at byte offset %" PRId64 "\n", 
     586                      MINRECLEN, msfp->filepos); 
     587          } 
     588 
     589          /* Skip MINRECLEN bytes, update reading offset and file position */ 
     590          msfp->readoffset += MINRECLEN; 
     591          msfp->filepos += MINRECLEN; 
     592        } 
     593        /* Parsing errors */ 
     594        else 
     595        { 
     596          ms_log (2, "Cannot detect record at byte offset %" PRId64 ": %s\n", 
     597                  msfp->filepos, msfile); 
     598 
     599          /* Print common errors and raw details if verbose */ 
     600          ms_parse_raw (MSFPREADPTR (msfp), MSFPBUFLEN (msfp), verbose, -1); 
     601 
     602          retcode = parseval; 
     603          break; 
     604        } 
     605      } 
     606      else /* parseval > 0 (found record but need more data) */ 
     607      { 
     608        /* Determine implied record length if needed */ 
     609        int32_t impreclen = reclen; 
     610 
     611        /* Check for parse hints that are larger than MAXRECLEN */ 
     612        if ((MSFPBUFLEN (msfp) + parseval) > MAXRECLEN) 
     613        { 
     614          if (skipnotdata) 
     615          { 
     616            /* Skip MINRECLEN bytes, update reading offset and file position */ 
     617            msfp->readoffset += MINRECLEN; 
     618            msfp->filepos += MINRECLEN; 
     619          } 
     620          else 
     621          { 
     622            retcode = MS_OUTOFRANGE; 
     623            break; 
     624          } 
     625        } 
     626 
     627        /* Pack header check, if pack header offset is within buffer */ 
     628        else if (impreclen <= 0 && msfp->packhdroffset && 
     629                 msfp->packhdroffset < (msfp->filepos + MSFPBUFLEN (msfp))) 
     630        { 
     631          impreclen = msfp->packhdroffset - msfp->filepos; 
     632 
     633          /* Check that record length is within range and a power of 2. 
    638634                   * Power of two if (X & (X - 1)) == 0 */ 
    639                   if ( impreclen >= MINRECLEN && impreclen <= MAXRECLEN && 
    640                        (impreclen & (impreclen - 1)) == 0 ) 
    641                     { 
    642                       /* Set the record length implied by the next pack header */ 
    643                       reclen = impreclen; 
    644                     } 
    645                   else 
    646                     { 
    647                       ms_log (1, "Implied record length (%d) is invalid\n", impreclen); 
    648                        
    649                       retcode = MS_NOTSEED; 
    650                       break; 
    651                     } 
    652                 } 
    653                
    654               /* End of file check */ 
    655               else if ( impreclen <= 0 && feof (msfp->fp) ) 
    656                 { 
    657                   impreclen = msfp->filesize - msfp->filepos; 
    658                    
    659                   /* Check that record length is within range and a power of 2. 
     635          if (impreclen >= MINRECLEN && impreclen <= MAXRECLEN && 
     636              (impreclen & (impreclen - 1)) == 0) 
     637          { 
     638            /* Set the record length implied by the next pack header */ 
     639            reclen = impreclen; 
     640          } 
     641          else 
     642          { 
     643            ms_log (1, "Implied record length (%d) is invalid\n", impreclen); 
     644 
     645            retcode = MS_NOTSEED; 
     646            break; 
     647          } 
     648        } 
     649 
     650        /* End of file check */ 
     651        else if (impreclen <= 0 && feof (msfp->fp)) 
     652        { 
     653          impreclen = msfp->filesize - msfp->filepos; 
     654 
     655          /* Check that record length is within range and a power of 2. 
    660656                   * Power of two if (X & (X - 1)) == 0 */ 
    661                   if ( impreclen >= MINRECLEN && impreclen <= MAXRECLEN && 
    662                        (impreclen & (impreclen - 1)) == 0 ) 
    663                     { 
    664                       /* Set the record length implied by the end of the file */ 
    665                       reclen = impreclen; 
    666                     } 
    667                   /* Otherwise a trucated record */ 
    668                   else 
    669                     { 
    670                       if ( verbose ) 
    671                         { 
    672                           if ( msfp->filesize ) 
    673                             ms_log (1, "Truncated record at byte offset %"PRId64", filesize %d: %s\n", 
    674                                     msfp->filepos, msfp->filesize, msfile); 
    675                           else 
    676                             ms_log (1, "Truncated record at byte offset %"PRId64"\n", 
    677                                     msfp->filepos); 
    678                         } 
    679                        
    680                       retcode = MS_ENDOFFILE; 
    681                       break; 
    682                     } 
    683                 } 
    684             } 
    685         } /* End of record detection */ 
    686        
    687       /* Finished when within MINRECLEN from EOF and buffer less than MINRECLEN */ 
    688       if ( (msfp->filesize - msfp->filepos) < MINRECLEN && MSFPBUFLEN(msfp) < MINRECLEN ) 
    689         { 
    690           if ( msfp->recordcount == 0 && msfp->packtype == 0 ) 
    691             { 
    692               if ( verbose > 0 ) 
    693                 ms_log (2, "%s: No data records read, not SEED?\n", msfile); 
    694               retcode = MS_NOTSEED; 
    695             } 
    696           else 
    697             { 
    698               retcode = MS_ENDOFFILE; 
    699             } 
    700            
    701           break; 
    702         } 
    703     } /* End of reading, record detection and parsing loop */ 
    704    
     657          if (impreclen >= MINRECLEN && impreclen <= MAXRECLEN && 
     658              (impreclen & (impreclen - 1)) == 0) 
     659          { 
     660            /* Set the record length implied by the end of the file */ 
     661            reclen = impreclen; 
     662          } 
     663          /* Otherwise a trucated record */ 
     664          else 
     665          { 
     666            if (verbose) 
     667            { 
     668              if (msfp->filesize) 
     669                ms_log (1, "Truncated record at byte offset %" PRId64 ", filesize %d: %s\n", 
     670                        msfp->filepos, msfp->filesize, msfile); 
     671              else 
     672                ms_log (1, "Truncated record at byte offset %" PRId64 "\n", 
     673                        msfp->filepos); 
     674            } 
     675 
     676            retcode = MS_ENDOFFILE; 
     677            break; 
     678          } 
     679        } 
     680      } 
     681    } /* End of record detection */ 
     682 
     683    /* Finished when within MINRECLEN from EOF and buffer less than MINRECLEN */ 
     684    if ((msfp->filesize - msfp->filepos) < MINRECLEN && MSFPBUFLEN (msfp) < MINRECLEN) 
     685    { 
     686      if (msfp->recordcount == 0 && msfp->packtype == 0) 
     687      { 
     688        if (verbose > 0) 
     689          ms_log (2, "%s: No data records read, not SEED?\n", msfile); 
     690        retcode = MS_NOTSEED; 
     691      } 
     692      else 
     693      { 
     694        retcode = MS_ENDOFFILE; 
     695      } 
     696 
     697      break; 
     698    } 
     699  } /* End of reading, record detection and parsing loop */ 
     700 
    705701  /* Cleanup target MSRecord if returning an error */ 
    706   if ( retcode != MS_NOERROR ) 
    707     { 
    708       msr_free (ppmsr); 
    709     } 
    710    
     702  if (retcode != MS_NOERROR) 
     703  { 
     704    msr_free (ppmsr); 
     705  } 
     706 
    711707  return retcode; 
    712 }  /* End of ms_readmsr_main() */ 
    713  
     708} /* End of ms_readmsr_main() */ 
    714709 
    715710/********************************************************************* 
     
    724719int 
    725720ms_readtraces (MSTraceGroup **ppmstg, const char *msfile, int reclen, 
    726                double timetol, double sampratetol, flag dataquality, 
    727                flag skipnotdata, flag dataflag, flag verbose) 
     721               double timetol, double sampratetol, flag dataquality, 
     722               flag skipnotdata, flag dataflag, flag verbose) 
    728723{ 
    729724  return ms_readtraces_selection (ppmstg, msfile, reclen, 
    730                                   timetol, sampratetol, NULL, 
    731                                   dataquality, skipnotdata, 
    732                                   dataflag, verbose); 
    733 }  /* End of ms_readtraces() */ 
    734  
     725                                  timetol, sampratetol, NULL, 
     726                                  dataquality, skipnotdata, 
     727                                  dataflag, verbose); 
     728} /* End of ms_readtraces() */ 
    735729 
    736730/********************************************************************* 
     
    745739int 
    746740ms_readtraces_timewin (MSTraceGroup **ppmstg, const char *msfile, int reclen, 
    747                        double timetol, double sampratetol, 
    748                        hptime_t starttime, hptime_t endtime, flag dataquality, 
    749                        flag skipnotdata, flag dataflag, flag verbose) 
     741                       double timetol, double sampratetol, 
     742                       hptime_t starttime, hptime_t endtime, flag dataquality, 
     743                       flag skipnotdata, flag dataflag, flag verbose) 
    750744{ 
    751745  Selections selection; 
    752746  SelectTime selecttime; 
    753    
    754   selection.srcname[0] = '*'; 
    755   selection.srcname[1] = '\0'; 
     747 
     748  selection.srcname[0]  = '*'; 
     749  selection.srcname[1]  = '\0'; 
    756750  selection.timewindows = &selecttime; 
    757   selection.next = NULL; 
    758    
     751  selection.next        = NULL; 
     752 
    759753  selecttime.starttime = starttime; 
    760   selecttime.endtime = endtime; 
    761   selecttime.next = NULL; 
    762    
     754  selecttime.endtime   = endtime; 
     755  selecttime.next      = NULL; 
     756 
    763757  return ms_readtraces_selection (ppmstg, msfile, reclen, 
    764                                   timetol, sampratetol, &selection, 
    765                                   dataquality, skipnotdata, 
    766                                   dataflag, verbose); 
    767 }  /* End of ms_readtraces_timewin() */ 
    768  
     758                                  timetol, sampratetol, &selection, 
     759                                  dataquality, skipnotdata, 
     760                                  dataflag, verbose); 
     761} /* End of ms_readtraces_timewin() */ 
    769762 
    770763/********************************************************************* 
     
    786779int 
    787780ms_readtraces_selection (MSTraceGroup **ppmstg, const char *msfile, 
    788                         int reclen, double timetol, double sampratetol, 
    789                         Selections *selections, flag dataquality, 
    790                         flag skipnotdata, flag dataflag, flag verbose) 
    791 { 
    792   MSRecord *msr = 0; 
     781                        int reclen, double timetol, double sampratetol, 
     782                        Selections *selections, flag dataquality, 
     783                        flag skipnotdata, flag dataflag, flag verbose) 
     784{ 
     785  MSRecord *msr     = 0; 
    793786  MSFileParam *msfp = 0; 
    794787  int retcode; 
    795    
    796   if ( ! ppmstg ) 
     788 
     789  if (!ppmstg) 
    797790    return MS_GENERROR; 
    798    
     791 
    799792  /* Initialize MSTraceGroup if needed */ 
    800   if ( ! *ppmstg ) 
    801     { 
    802       *ppmstg = mst_initgroup (*ppmstg); 
    803        
    804       if ( ! *ppmstg ) 
    805         return MS_GENERROR; 
    806     } 
    807    
     793  if (!*ppmstg) 
     794  { 
     795    *ppmstg = mst_initgroup (*ppmstg); 
     796 
     797    if (!*ppmstg) 
     798      return MS_GENERROR; 
     799  } 
     800 
    808801  /* Loop over the input file */ 
    809   while ( (retcode = ms_readmsr_main (&msfp, &msr, msfile, reclen, NULL, NULL, 
    810                                       skipnotdata, dataflag, NULL, verbose)) == MS_NOERROR) 
    811     { 
    812       /* Test against selections if supplied */ 
    813       if ( selections ) 
    814         { 
    815           char srcname[50]; 
    816           hptime_t endtime; 
    817            
    818           msr_srcname (msr, srcname, 1); 
    819           endtime = msr_endtime (msr); 
    820            
    821           if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) 
    822             { 
    823               continue; 
    824             } 
    825         } 
    826        
    827       /* Add to trace group */ 
    828       mst_addmsrtogroup (*ppmstg, msr, dataquality, timetol, sampratetol); 
    829     } 
    830    
     802  while ((retcode = ms_readmsr_main (&msfp, &msr, msfile, reclen, NULL, NULL, 
     803                                     skipnotdata, dataflag, NULL, verbose)) == MS_NOERROR) 
     804  { 
     805    /* Test against selections if supplied */ 
     806    if (selections) 
     807    { 
     808      char srcname[50]; 
     809      hptime_t endtime; 
     810 
     811      msr_srcname (msr, srcname, 1); 
     812      endtime = msr_endtime (msr); 
     813 
     814      if (ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL) 
     815      { 
     816        continue; 
     817      } 
     818    } 
     819 
     820    /* Add to trace group */ 
     821    mst_addmsrtogroup (*ppmstg, msr, dataquality, timetol, sampratetol); 
     822  } 
     823 
    831824  /* Reset return code to MS_NOERROR on successful read by ms_readmsr() */ 
    832   if ( retcode == MS_ENDOFFILE ) 
     825  if (retcode == MS_ENDOFFILE) 
    833826    retcode = MS_NOERROR; 
    834    
     827 
    835828  ms_readmsr_main (&msfp, &msr, NULL, 0, NULL, NULL, 0, 0, NULL, 0); 
    836    
     829 
    837830  return retcode; 
    838 }  /* End of ms_readtraces_selection() */ 
    839  
     831} /* End of ms_readtraces_selection() */ 
    840832 
    841833/********************************************************************* 
     
    850842int 
    851843ms_readtracelist (MSTraceList **ppmstl, const char *msfile, int reclen, 
    852                   double timetol, double sampratetol, flag dataquality, 
    853                   flag skipnotdata, flag dataflag, flag verbose) 
     844                  double timetol, double sampratetol, flag dataquality, 
     845                  flag skipnotdata, flag dataflag, flag verbose) 
    854846{ 
    855847  return ms_readtracelist_selection (ppmstl, msfile, reclen, 
    856                                      timetol, sampratetol, NULL, 
    857                                      dataquality, skipnotdata, 
    858                                      dataflag, verbose); 
    859 }  /* End of ms_readtracelist() */ 
    860  
     848                                     timetol, sampratetol, NULL, 
     849                                     dataquality, skipnotdata, 
     850                                     dataflag, verbose); 
     851} /* End of ms_readtracelist() */ 
    861852 
    862853/********************************************************************* 
     
    871862int 
    872863ms_readtracelist_timewin (MSTraceList **ppmstl, const char *msfile, 
    873                           int reclen, double timetol, double sampratetol, 
    874                           hptime_t starttime, hptime_t endtime, flag dataquality, 
    875                           flag skipnotdata, flag dataflag, flag verbose) 
     864                          int reclen, double timetol, double sampratetol, 
     865                          hptime_t starttime, hptime_t endtime, flag dataquality, 
     866                          flag skipnotdata, flag dataflag, flag verbose) 
    876867{ 
    877868  Selections selection; 
    878869  SelectTime selecttime; 
    879    
    880   selection.srcname[0] = '*'; 
    881   selection.srcname[1] = '\0'; 
     870 
     871  selection.srcname[0]  = '*'; 
     872  selection.srcname[1]  = '\0'; 
    882873  selection.timewindows = &selecttime; 
    883   selection.next = NULL; 
    884    
     874  selection.next        = NULL; 
     875 
    885876  selecttime.starttime = starttime; 
    886   selecttime.endtime = endtime; 
    887   selecttime.next = NULL; 
    888    
     877  selecttime.endtime   = endtime; 
     878  selecttime.next      = NULL; 
     879 
    889880  return ms_readtracelist_selection (ppmstl, msfile, reclen, 
    890                                      timetol, sampratetol, &selection, 
    891                                      dataquality, skipnotdata, 
    892                                      dataflag, verbose); 
    893 }  /* End of ms_readtracelist_timewin() */ 
    894  
     881                                     timetol, sampratetol, &selection, 
     882                                     dataquality, skipnotdata, 
     883                                     dataflag, verbose); 
     884} /* End of ms_readtracelist_timewin() */ 
    895885 
    896886/********************************************************************* 
     
    912902int 
    913903ms_readtracelist_selection (MSTraceList **ppmstl, const char *msfile, 
    914                             int reclen, double timetol, double sampratetol, 
    915                             Selections *selections, flag dataquality, 
    916                             flag skipnotdata, flag dataflag, flag verbose) 
    917 { 
    918   MSRecord *msr = 0; 
     904                            int reclen, double timetol, double sampratetol, 
     905                            Selections *selections, flag dataquality, 
     906                            flag skipnotdata, flag dataflag, flag verbose) 
     907{ 
     908  MSRecord *msr     = 0; 
    919909  MSFileParam *msfp = 0; 
    920910  int retcode; 
    921    
    922   if ( ! ppmstl ) 
     911 
     912  if (!ppmstl) 
    923913    return MS_GENERROR; 
    924    
     914 
    925915  /* Initialize MSTraceList if needed */ 
    926   if ( ! *ppmstl ) 
    927     { 
    928       *ppmstl = mstl_init (*ppmstl); 
    929        
    930       if ( ! *ppmstl ) 
    931         return MS_GENERROR; 
    932     } 
    933    
     916  if (!*ppmstl) 
     917  { 
     918    *ppmstl = mstl_init (*ppmstl); 
     919 
     920    if (!*ppmstl) 
     921      return MS_GENERROR; 
     922  } 
     923 
    934924  /* Loop over the input file */ 
    935   while ( (retcode = ms_readmsr_main (&msfp, &msr, msfile, reclen, NULL, NULL, 
    936                                       skipnotdata, dataflag, NULL, verbose)) == MS_NOERROR) 
    937     { 
    938       /* Test against selections if supplied */ 
    939       if ( selections ) 
    940         { 
    941           char srcname[50]; 
    942           hptime_t endtime; 
    943            
    944           msr_srcname (msr, srcname, 1); 
    945           endtime = msr_endtime (msr); 
    946            
    947           if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) 
    948             { 
    949               continue; 
    950             } 
    951         } 
    952        
    953       /* Add to trace list */ 
    954       mstl_addmsr (*ppmstl, msr, dataquality, 1, timetol, sampratetol); 
    955     } 
    956    
     925  while ((retcode = ms_readmsr_main (&msfp, &msr, msfile, reclen, NULL, NULL, 
     926                                     skipnotdata, dataflag, NULL, verbose)) == MS_NOERROR) 
     927  { 
     928    /* Test against selections if supplied */ 
     929    if (selections) 
     930    { 
     931      char srcname[50]; 
     932      hptime_t endtime; 
     933 
     934      msr_srcname (msr, srcname, 1); 
     935      endtime = msr_endtime (msr); 
     936 
     937      if (ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL) 
     938      { 
     939        continue; 
     940      } 
     941    } 
     942 
     943    /* Add to trace list */ 
     944    mstl_addmsr (*ppmstl, msr, dataquality, 1, timetol, sampratetol); 
     945  } 
     946 
    957947  /* Reset return code to MS_NOERROR on successful read by ms_readmsr() */ 
    958   if ( retcode == MS_ENDOFFILE ) 
     948  if (retcode == MS_ENDOFFILE) 
    959949    retcode = MS_NOERROR; 
    960    
     950 
    961951  ms_readmsr_main (&msfp, &msr, NULL, 0, NULL, NULL, 0, 0, NULL, 0); 
    962    
     952 
    963953  return retcode; 
    964 }  /* End of ms_readtracelist_selection() */ 
    965  
     954} /* End of ms_readtracelist_selection() */ 
    966955 
    967956/********************************************************************* 
     
    976965{ 
    977966  int read = 0; 
    978    
    979   read = (int) fread (buf, size, num, stream); 
    980    
    981   if ( read <= 0 && size && num ) 
    982     { 
    983       if ( ferror (stream) ) 
    984         ms_log (2, "ms_fread(): Cannot read input file\n"); 
    985        
    986       else if ( ! feof (stream) ) 
    987         ms_log (2, "ms_fread(): Unknown return from fread()\n"); 
    988     } 
    989    
     967 
     968  read = (int)fread (buf, size, num, stream); 
     969 
     970  if (read <= 0 && size && num) 
     971  { 
     972    if (ferror (stream)) 
     973      ms_log (2, "ms_fread(): Cannot read input file\n"); 
     974 
     975    else if (!feof (stream)) 
     976      ms_log (2, "ms_fread(): Unknown return from fread()\n"); 
     977  } 
     978 
    990979  return read; 
    991 }  /* End of ms_fread() */ 
    992  
     980} /* End of ms_fread() */ 
    993981 
    994982/*************************************************************************** 
     
    1002990ms_record_handler_int (char *record, int reclen, void *ofp) 
    1003991{ 
    1004   if ( fwrite(record, reclen, 1, (FILE *)ofp) != 1 ) 
    1005     { 
    1006       ms_log (2, "Error writing to output file\n"); 
    1007     } 
    1008 }  /* End of ms_record_handler_int() */ 
    1009  
     992  if (fwrite (record, reclen, 1, (FILE *)ofp) != 1) 
     993  { 
     994    ms_log (2, "Error writing to output file\n"); 
     995  } 
     996} /* End of ms_record_handler_int() */ 
    1010997 
    1011998/*************************************************************************** 
     
    10181005 ***************************************************************************/ 
    10191006int 
    1020 msr_writemseed ( MSRecord *msr, const char *msfile, flag overwrite, 
    1021                  int reclen, flag encoding, flag byteorder, flag verbose ) 
     1007msr_writemseed (MSRecord *msr, const char *msfile, flag overwrite, 
     1008                int reclen, flag encoding, flag byteorder, flag verbose) 
    10221009{ 
    10231010  FILE *ofp; 
    10241011  char srcname[50]; 
    1025   char *perms = (overwrite) ? "wb":"ab"; 
     1012  char *perms       = (overwrite) ? "wb" : "ab"; 
    10261013  int packedrecords = 0; 
    1027    
    1028   if ( ! msr || ! msfile ) 
     1014 
     1015  if (!msr || !msfile) 
    10291016    return -1; 
    1030    
     1017 
    10311018  /* Open output file or use stdout */ 
    1032   if ( strcmp (msfile, "-") == 0 ) 
    1033     { 
    1034       ofp = stdout; 
    1035     } 
    1036   else if ( (ofp = fopen (msfile, perms)) == NULL ) 
    1037     { 
    1038       ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror(errno)); 
    1039        
    1040       return -1; 
    1041     } 
    1042    
     1019  if (strcmp (msfile, "-") == 0) 
     1020  { 
     1021    ofp = stdout; 
     1022  } 
     1023  else if ((ofp = fopen (msfile, perms)) == NULL) 
     1024  { 
     1025    ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror (errno)); 
     1026 
     1027    return -1; 
     1028  } 
     1029 
    10431030  /* Pack the MSRecord */ 
    1044   if ( msr->numsamples > 0 ) 
    1045     { 
    1046       msr->encoding = encoding; 
    1047       msr->reclen = reclen; 
    1048       msr->byteorder = byteorder; 
    1049        
    1050       packedrecords = msr_pack (msr, &ms_record_handler_int, ofp, NULL, 1, verbose-1); 
    1051        
    1052       if ( packedrecords < 0 ) 
    1053         { 
    1054           msr_srcname (msr, srcname, 1); 
    1055           ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); 
    1056         } 
    1057     } 
    1058    
     1031  if (msr->numsamples > 0) 
     1032  { 
     1033    msr->encoding = encoding; 
     1034    msr->reclen    = reclen; 
     1035    msr->byteorder = byteorder; 
     1036 
     1037    packedrecords = msr_pack (msr, &ms_record_handler_int, ofp, NULL, 1, verbose - 1); 
     1038 
     1039    if (packedrecords < 0) 
     1040    { 
     1041      msr_srcname (msr, srcname, 1); 
     1042      ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); 
     1043    } 
     1044  } 
     1045 
    10591046  /* Close file and return record count */ 
    10601047  fclose (ofp); 
    1061    
     1048 
    10621049  return (packedrecords >= 0) ? packedrecords : -1; 
    1063 }  /* End of msr_writemseed() */ 
    1064  
     1050} /* End of msr_writemseed() */ 
    10651051 
    10661052/*************************************************************************** 
     
    10731059 ***************************************************************************/ 
    10741060int 
    1075 mst_writemseed ( MSTrace *mst, const char *msfile, flag overwrite, 
    1076                  int reclen, flag encoding, flag byteorder, flag verbose ) 
     1061mst_writemseed (MSTrace *mst, const char *msfile, flag overwrite, 
     1062                int reclen, flag encoding, flag byteorder, flag verbose) 
    10771063{ 
    10781064  FILE *ofp; 
    10791065  char srcname[50]; 
    1080   char *perms = (overwrite) ? "wb":"ab"; 
     1066  char *perms       = (overwrite) ? "wb" : "ab"; 
    10811067  int packedrecords = 0; 
    1082    
    1083   if ( ! mst || ! msfile ) 
     1068 
     1069  if (!mst || !msfile) 
    10841070    return -1; 
    1085    
     1071 
    10861072  /* Open output file or use stdout */ 
    1087   if ( strcmp (msfile, "-") == 0 ) 
    1088     { 
    1089       ofp = stdout; 
    1090     } 
    1091   else if ( (ofp = fopen (msfile, perms)) == NULL ) 
    1092     { 
    1093       ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror(errno)); 
    1094        
    1095       return -1; 
    1096     } 
    1097    
     1073  if (strcmp (msfile, "-") == 0) 
     1074  { 
     1075    ofp = stdout; 
     1076  } 
     1077  else if ((ofp = fopen (msfile, perms)) == NULL) 
     1078  { 
     1079    ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror (errno)); 
     1080 
     1081    return -1; 
     1082  } 
     1083 
    10981084  /* Pack the MSTrace */ 
    1099   if ( mst->numsamples > 0 ) 
    1100     { 
    1101       packedrecords = mst_pack (mst, &ms_record_handler_int, ofp, reclen, encoding, 
    1102                                 byteorder, NULL, 1, verbose-1, NULL); 
    1103        
    1104       if ( packedrecords < 0 ) 
    1105         { 
    1106           mst_srcname (mst, srcname, 1); 
    1107           ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); 
    1108         } 
    1109     } 
    1110    
     1085  if (mst->numsamples > 0) 
     1086  { 
     1087    packedrecords = mst_pack (mst, &ms_record_handler_int, ofp, reclen, encoding, 
     1088                              byteorder, NULL, 1, verbose - 1, NULL); 
     1089 
     1090    if (packedrecords < 0) 
     1091    { 
     1092      mst_srcname (mst, srcname, 1); 
     1093      ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); 
     1094    } 
     1095  } 
     1096 
    11111097  /* Close file and return record count */ 
    11121098  fclose (ofp); 
    1113    
     1099 
    11141100  return (packedrecords >= 0) ? packedrecords : -1; 
    1115 }  /* End of mst_writemseed() */ 
    1116  
     1101} /* End of mst_writemseed() */ 
    11171102 
    11181103/*************************************************************************** 
     
    11251110 ***************************************************************************/ 
    11261111int 
    1127 mst_writemseedgroup ( MSTraceGroup *mstg, const char *msfile, flag overwrite, 
    1128                       int reclen, flag encoding, flag byteorder, flag verbose ) 
     1112mst_writemseedgroup (MSTraceGroup *mstg, const char *msfile, flag overwrite, 
     1113                     int reclen, flag encoding, flag byteorder, flag verbose) 
    11291114{ 
    11301115  MSTrace *mst; 
    11311116  FILE *ofp; 
    11321117  char srcname[50]; 
    1133   char *perms = (overwrite) ? "wb":"ab"; 
     1118  char *perms = (overwrite) ? "wb" : "ab"; 
    11341119  int trpackedrecords; 
    11351120  int packedrecords = 0; 
    1136    
    1137   if ( ! mstg || ! msfile ) 
     1121 
     1122  if (!mstg || !msfile) 
    11381123    return -1; 
    1139    
     1124 
    11401125  /* Open output file or use stdout */ 
    1141   if ( strcmp (msfile, "-") == 0 ) 
    1142     { 
    1143       ofp = stdout; 
    1144     } 
    1145   else if ( (ofp = fopen (msfile, perms)) == NULL ) 
    1146     { 
    1147       ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror(errno)); 
    1148        
    1149       return -1; 
    1150     } 
    1151    
     1126  if (strcmp (msfile, "-") == 0) 
     1127  { 
     1128    ofp = stdout; 
     1129  } 
     1130  else if ((ofp = fopen (msfile, perms)) == NULL) 
     1131  { 
     1132    ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror (errno)); 
     1133 
     1134    return -1; 
     1135  } 
     1136 
    11521137  /* Pack each MSTrace in the group */ 
    11531138  mst = mstg->traces; 
    1154   while ( mst ) 
    1155     { 
    1156       if ( mst->numsamples <= 0 ) 
    1157         { 
    1158           mst = mst->next; 
    1159           continue; 
    1160         } 
    1161        
    1162       trpackedrecords = mst_pack (mst, &ms_record_handler_int, ofp, reclen, encoding, 
    1163                                   byteorder, NULL, 1, verbose-1, NULL); 
    1164        
    1165       if ( trpackedrecords < 0 ) 
    1166         { 
    1167           mst_srcname (mst, srcname, 1); 
    1168           ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); 
    1169         } 
    1170       else 
    1171         { 
    1172           packedrecords += trpackedrecords; 
    1173         } 
    1174        
     1139  while (mst) 
     1140  { 
     1141    if (mst->numsamples <= 0) 
     1142    { 
    11751143      mst = mst->next; 
    1176     } 
    1177    
     1144      continue; 
     1145    } 
     1146 
     1147    trpackedrecords = mst_pack (mst, &ms_record_handler_int, ofp, reclen, encoding, 
     1148                                byteorder, NULL, 1, verbose - 1, NULL); 
     1149 
     1150    if (trpackedrecords < 0) 
     1151    { 
     1152      mst_srcname (mst, srcname, 1); 
     1153      ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); 
     1154    } 
     1155    else 
     1156    { 
     1157      packedrecords += trpackedrecords; 
     1158    } 
     1159 
     1160    mst = mst->next; 
     1161  } 
     1162 
    11781163  /* Close file and return record count */ 
    11791164  fclose (ofp); 
    1180    
     1165 
    11811166  return packedrecords; 
    1182 }  /* End of mst_writemseedgroup() */ 
    1183  
     1167} /* End of mst_writemseedgroup() */ 
  • trunk/src/libsrc/util/libmseed/genutils.c

    r6803 r6836  
    88 * IRIS Data Management Center 
    99 * 
    10  * modified: 2015.213 
    11  ***************************************************************************/ 
    12  
     10 * modified: 2016.281 
     11 ***************************************************************************/ 
     12 
     13#include <errno.h> 
    1314#include <stdio.h> 
    1415#include <stdlib.h> 
    1516#include <string.h> 
    16 #include <errno.h> 
    1717#include <time.h> 
    1818 
     19#include "libmseed.h" 
    1920#include "lmplatform.h" 
    20 #include "libmseed.h" 
    2121 
    2222static hptime_t ms_time2hptime_int (int year, int day, int hour, 
    23                                     int min, int sec, int usec); 
     23                                    int min, int sec, int usec); 
    2424 
    2525static struct tm *ms_gmtime_r (int64_t *timep, struct tm *result); 
    26  
    2726 
    2827/* A constant number of seconds between the NTP and Posix/Unix time epoch */ 
     
    3130/* Global variable to hold a leap second list */ 
    3231LeapSecond *leapsecondlist = NULL; 
    33  
    3432 
    3533/*************************************************************************** 
     
    5149  char location[6]; 
    5250  char channel[6]; 
    53    
    54   if ( ! record ) 
    55     return NULL; 
    56    
    57   fsdh = (struct fsdh_s *) record; 
    58    
     51 
     52  if (!record) 
     53    return NULL; 
     54 
     55  fsdh = (struct fsdh_s *)record; 
     56 
    5957  ms_strncpclean (network, fsdh->network, 2); 
    6058  ms_strncpclean (station, fsdh->station, 5); 
    6159  ms_strncpclean (location, fsdh->location, 2); 
    6260  ms_strncpclean (channel, fsdh->channel, 3); 
    63    
     61 
    6462  /* Build the source name string including the quality indicator*/ 
    65   if ( quality ) 
     63  if (quality) 
    6664    sprintf (srcname, "%s_%s_%s_%s_%c", 
    6765             network, station, location, channel, fsdh->dataquality); 
    68    
     66 
    6967  /* Build the source name string without the quality indicator*/ 
    7068  else 
    7169    sprintf (srcname, "%s_%s_%s_%s", network, station, location, channel); 
    72    
     70 
    7371  return srcname; 
    7472} /* End of ms_recsrcname() */ 
    75  
    7673 
    7774/*************************************************************************** 
     
    8683int 
    8784ms_splitsrcname (char *srcname, char *net, char *sta, char *loc, char *chan, 
    88                 char *qual) 
     85                char *qual) 
    8986{ 
    9087  char *id; 
    9188  char *ptr, *top, *next; 
    9289  int sepcnt = 0; 
    93    
    94   if ( ! srcname ) 
     90 
     91  if (!srcname) 
    9592    return -1; 
    96    
     93 
    9794  /* Verify number of separating underscore characters */ 
    9895  id = srcname; 
    99   while ( (id = strchr (id, '_')) ) 
    100     { 
    101       id++; 
    102       sepcnt++; 
    103     } 
    104    
     96  while ((id = strchr (id, '_'))) 
     97  { 
     98    id++; 
     99    sepcnt++; 
     100  } 
     101 
    105102  /* Either 3 or 4 separating underscores are required */ 
    106   if ( sepcnt != 3 && sepcnt != 4 ) 
    107     { 
    108       return -1; 
    109     } 
    110    
     103  if (sepcnt != 3 && sepcnt != 4) 
     104  { 
     105    return -1; 
     106  } 
     107 
    111108  /* Duplicate srcname */ 
    112   if ( ! (id = strdup(srcname)) ) 
    113     { 
    114       ms_log (2, "ms_splitsrcname(): Error duplicating srcname string"); 
    115       return -1; 
    116     } 
    117    
     109  if (!(id = strdup (srcname))) 
     110  { 
     111    ms_log (2, "ms_splitsrcname(): Error duplicating srcname string"); 
     112    return -1; 
     113  } 
     114 
    118115  /* Network */ 
    119116  top = id; 
    120   if ( (ptr = strchr (top, '_')) ) 
    121     { 
    122       next = ptr + 1; 
    123       *ptr = '\0'; 
    124        
    125       if ( net ) 
    126         strcpy (net, top); 
    127        
    128       top = next; 
    129     } 
     117  if ((ptr = strchr (top, '_'))) 
     118  { 
     119    next = ptr + 1; 
     120    *ptr = '\0'; 
     121 
     122    if (net) 
     123      strcpy (net, top); 
     124 
     125    top = next; 
     126  } 
    130127  /* Station */ 
    131   if ( (ptr = strchr (top, '_')) ) 
    132     { 
    133       next = ptr + 1; 
    134       *ptr = '\0'; 
    135        
    136       if ( sta ) 
    137         strcpy (sta, top); 
    138        
    139       top = next; 
    140     } 
     128  if ((ptr = strchr (top, '_'))) 
     129  { 
     130    next = ptr + 1; 
     131    *ptr = '\0'; 
     132 
     133    if (sta) 
     134      strcpy (sta, top); 
     135 
     136    top = next; 
     137  } 
    141138  /* Location */ 
    142   if ( (ptr = strchr (top, '_')) ) 
    143     { 
    144       next = ptr + 1; 
    145       *ptr = '\0'; 
    146        
    147       if ( loc ) 
    148         strcpy (loc, top); 
    149        
    150       top = next; 
    151     } 
     139  if ((ptr = strchr (top, '_'))) 
     140  { 
     141    next = ptr + 1; 
     142    *ptr = '\0'; 
     143 
     144    if (loc) 
     145      strcpy (loc, top); 
     146 
     147    top = next; 
     148  } 
    152149  /* Channel & optional Quality */ 
    153   if ( (ptr = strchr (top, '_')) ) 
    154     { 
    155       next = ptr + 1; 
    156       *ptr = '\0'; 
    157        
    158       if ( chan ) 
    159         strcpy (chan, top); 
    160        
    161       top = next; 
    162        
    163       /* Quality */ 
    164       if ( *top && qual ) 
    165         { 
    166           /* Quality is a single character */ 
    167           *qual = *top; 
    168         } 
    169     } 
     150  if ((ptr = strchr (top, '_'))) 
     151  { 
     152    next = ptr + 1; 
     153    *ptr = '\0'; 
     154 
     155    if (chan) 
     156      strcpy (chan, top); 
     157 
     158    top = next; 
     159 
     160    /* Quality */ 
     161    if (*top && qual) 
     162    { 
     163      /* Quality is a single character */ 
     164      *qual = *top; 
     165    } 
     166  } 
    170167  /* Otherwise only Channel */ 
    171   else if ( *top && chan ) 
    172     { 
    173       strcpy (chan, top); 
    174     } 
    175    
     168  else if (*top && chan) 
     169  { 
     170    strcpy (chan, top); 
     171  } 
     172 
    176173  /* Free duplicated stream ID */ 
    177   if ( id ) 
     174  if (id) 
    178175    free (id); 
    179    
     176 
    180177  return 0; 
    181 }  /* End of ms_splitsrcname() */ 
    182  
     178} /* End of ms_splitsrcname() */ 
    183179 
    184180/*************************************************************************** 
     
    190186 * for the non-space characters within 'length' and the null 
    191187 * terminator, a maximum of 'length + 1'. 
    192  *  
     188 * 
    193189 * Returns the number of characters (not including the null terminator) in 
    194190 * the destination string. 
     
    198194{ 
    199195  int sidx, didx; 
    200    
    201   if ( ! dest ) 
     196 
     197  if (!dest) 
    202198    return 0; 
    203    
    204   if ( ! source ) 
    205     { 
    206       *dest = '\0'; 
    207       return 0; 
    208     } 
    209  
    210   for ( sidx=0, didx=0; sidx < length ; sidx++ ) 
    211     { 
    212       if ( *(source+sidx) == '\0' ) 
    213         { 
    214           break; 
    215         } 
    216  
    217       if ( *(source+sidx) != ' ' ) 
    218         { 
    219           *(dest+didx) = *(source+sidx); 
    220           didx++; 
    221         } 
    222     } 
    223  
    224   *(dest+didx) = '\0'; 
    225    
     199 
     200  if (!source) 
     201  { 
     202    *dest = '\0'; 
     203    return 0; 
     204  } 
     205 
     206  for (sidx = 0, didx = 0; sidx < length; sidx++) 
     207  { 
     208    if (*(source + sidx) == '\0') 
     209    { 
     210      break; 
     211    } 
     212 
     213    if (*(source + sidx) != ' ') 
     214    { 
     215      *(dest + didx) = *(source + sidx); 
     216      didx++; 
     217    } 
     218  } 
     219 
     220  *(dest + didx) = '\0'; 
     221 
    226222  return didx; 
    227 }  /* End of ms_strncpclean() */ 
    228  
     223} /* End of ms_strncpclean() */ 
    229224 
    230225/*************************************************************************** 
     
    244239{ 
    245240  int idx, pretail; 
    246    
    247   if ( ! dest ) 
     241 
     242  if (!dest) 
    248243    return 0; 
    249    
    250   if ( ! source ) 
    251     { 
    252       *dest = '\0'; 
    253       return 0; 
    254     } 
    255    
    256   *(dest+length) = '\0'; 
    257    
     244 
     245  if (!source) 
     246  { 
     247    *dest = '\0'; 
     248    return 0; 
     249  } 
     250 
     251  *(dest + length) = '\0'; 
     252 
    258253  pretail = 0; 
    259   for ( idx=length-1; idx >= 0 ; idx-- ) 
    260     { 
    261       if ( ! pretail && *(source+idx) == ' ' ) 
    262         { 
    263           *(dest+idx) = '\0'; 
    264         } 
    265       else 
    266         { 
    267           pretail++; 
    268           *(dest+idx) = *(source+idx); 
    269         } 
    270     } 
    271    
     254  for (idx = length - 1; idx >= 0; idx--) 
     255  { 
     256    if (!pretail && *(source + idx) == ' ') 
     257    { 
     258      *(dest + idx) = '\0'; 
     259    } 
     260    else 
     261    { 
     262      pretail++; 
     263      *(dest + idx) = *(source + idx); 
     264    } 
     265  } 
     266 
    272267  return pretail; 
    273 }  /* End of ms_strncpcleantail() */ 
    274  
     268} /* End of ms_strncpcleantail() */ 
    275269 
    276270/*************************************************************************** 
     
    281275 * justified and *never* null terminated (the open-ended part).  The 
    282276 * destination string must have enough room for 'length' characters. 
    283  *  
     277 * 
    284278 * Returns the number of characters copied from the source string. 
    285279 ***************************************************************************/ 
     
    290284  int dcnt = 0; 
    291285  int term = 0; 
    292    
    293   if ( ! dest ) 
     286 
     287  if (!dest) 
    294288    return 0; 
    295    
    296   if ( ! source ) 
    297     { 
    298       for ( didx=0; didx < length ; didx++ ) 
    299         { 
    300           *(dest+didx) = ' '; 
    301         } 
    302        
    303       return 0; 
    304     } 
    305    
    306   for ( didx=0; didx < length ; didx++ ) 
    307     { 
    308       if ( !term ) 
    309         if ( *(source+didx) == '\0' ) 
    310           term = 1; 
    311        
    312       if ( !term ) 
    313         { 
    314           *(dest+didx) = *(source+didx); 
    315           dcnt++; 
    316         } 
    317       else 
    318         { 
    319           *(dest+didx) = ' '; 
    320         } 
    321     } 
    322    
     289 
     290  if (!source) 
     291  { 
     292    for (didx = 0; didx < length; didx++) 
     293    { 
     294      *(dest + didx) = ' '; 
     295    } 
     296 
     297    return 0; 
     298  } 
     299 
     300  for (didx = 0; didx < length; didx++) 
     301  { 
     302    if (!term) 
     303      if (*(source + didx) == '\0') 
     304        term = 1; 
     305 
     306    if (!term) 
     307    { 
     308      *(dest + didx) = *(source + didx); 
     309      dcnt++; 
     310    } 
     311    else 
     312    { 
     313      *(dest + didx) = ' '; 
     314    } 
     315  } 
     316 
    323317  return dcnt; 
    324 }  /* End of ms_strncpopen() */ 
    325  
     318} /* End of ms_strncpopen() */ 
    326319 
    327320/*************************************************************************** 
     
    337330 ***************************************************************************/ 
    338331int 
    339 ms_doy2md(int year, int jday, int *month, int *mday) 
     332ms_doy2md (int year, int jday, int *month, int *mday) 
    340333{ 
    341334  int idx; 
    342335  int leap; 
    343336  int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 
    344    
     337 
    345338  /* Sanity check for the supplied year */ 
    346   if ( year < 1800 || year > 5000 ) 
    347     { 
    348       ms_log (2, "ms_doy2md(): year (%d) is out of range\n", year); 
    349       return -1; 
    350     } 
    351    
     339  if (year < 1800 || year > 5000) 
     340  { 
     341    ms_log (2, "ms_doy2md(): year (%d) is out of range\n", year); 
     342    return -1; 
     343  } 
     344 
    352345  /* Test for leap year */ 
    353   leap = ( ((year%4 == 0) && (year%100 != 0)) || (year%400 == 0) ) ? 1 : 0; 
     346  leap = (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) ? 1 : 0; 
    354347 
    355348  /* Add a day to February if leap year */ 
    356   if ( leap ) 
     349  if (leap) 
    357350    days[1]++; 
    358351 
    359   if (jday > 365+leap || jday <= 0) 
    360     { 
    361       ms_log (2, "ms_doy2md(): day-of-year (%d) is out of range\n", jday); 
    362       return -1; 
    363     } 
    364      
    365   for ( idx=0; idx < 12; idx++ ) 
    366     { 
    367       jday -= days[idx]; 
    368  
    369       if ( jday <= 0 ) 
    370         { 
    371           *month = idx + 1; 
    372           *mday = days[idx] + jday; 
    373           break; 
    374         } 
    375     } 
     352  if (jday > 365 + leap || jday <= 0) 
     353  { 
     354    ms_log (2, "ms_doy2md(): day-of-year (%d) is out of range\n", jday); 
     355    return -1; 
     356  } 
     357 
     358  for (idx = 0; idx < 12; idx++) 
     359  { 
     360    jday -= days[idx]; 
     361 
     362    if (jday <= 0) 
     363    { 
     364      *month = idx + 1; 
     365      *mday = days[idx] + jday; 
     366      break; 
     367    } 
     368  } 
    376369 
    377370  return 0; 
    378 }  /* End of ms_doy2md() */ 
    379  
     371} /* End of ms_doy2md() */ 
    380372 
    381373/*************************************************************************** 
     
    391383 ***************************************************************************/ 
    392384int 
    393 ms_md2doy(int year, int month, int mday, int *jday) 
     385ms_md2doy (int year, int month, int mday, int *jday) 
    394386{ 
    395387  int idx; 
    396388  int leap; 
    397389  int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 
    398    
     390 
    399391  /* Sanity check for the supplied parameters */ 
    400   if ( year < 1800 || year > 5000 ) 
    401     { 
    402       ms_log (2, "ms_md2doy(): year (%d) is out of range\n", year); 
    403       return -1; 
    404     } 
    405   if ( month < 1 || month > 12 ) 
    406     { 
    407       ms_log (2, "ms_md2doy(): month (%d) is out of range\n", month); 
    408       return -1; 
    409     } 
    410   if ( mday < 1 || mday > 31 ) 
    411     { 
    412       ms_log (2, "ms_md2doy(): day-of-month (%d) is out of range\n", mday); 
    413       return -1; 
    414     } 
    415    
     392  if (year < 1800 || year > 5000) 
     393  { 
     394    ms_log (2, "ms_md2doy(): year (%d) is out of range\n", year); 
     395    return -1; 
     396  } 
     397  if (month < 1 || month > 12) 
     398  { 
     399    ms_log (2, "ms_md2doy(): month (%d) is out of range\n", month); 
     400    return -1; 
     401  } 
     402  if (mday < 1 || mday > 31) 
     403  { 
     404    ms_log (2, "ms_md2doy(): day-of-month (%d) is out of range\n", mday); 
     405    return -1; 
     406  } 
     407 
    416408  /* Test for leap year */ 
    417   leap = ( ((year%4 == 0) && (year%100 != 0)) || (year%400 == 0) ) ? 1 : 0; 
    418    
     409  leap = (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) ? 1 : 0; 
     410 
    419411  /* Add a day to February if leap year */ 
    420   if ( leap ) 
     412  if (leap) 
    421413    days[1]++; 
    422    
     414 
    423415  /* Check that the day-of-month jives with specified month */ 
    424   if ( mday > days[month-1] ) 
    425     { 
    426       ms_log (2, "ms_md2doy(): day-of-month (%d) is out of range for month %d\n", 
    427                mday, month); 
    428       return -1; 
    429     } 
     416  if (mday > days[month - 1]) 
     417  { 
     418    ms_log (2, "ms_md2doy(): day-of-month (%d) is out of range for month %d\n", 
     419            mday, month); 
     420    return -1; 
     421  } 
    430422 
    431423  *jday = 0; 
    432424  month--; 
    433    
    434   for ( idx=0; idx < 12; idx++ ) 
    435     { 
    436       if ( idx == month ) 
    437         { 
    438           *jday += mday; 
    439           break; 
    440         } 
    441        
    442       *jday += days[idx]; 
    443     } 
    444    
     425 
     426  for (idx = 0; idx < 12; idx++) 
     427  { 
     428    if (idx == month) 
     429    { 
     430      *jday += mday; 
     431      break; 
     432    } 
     433 
     434    *jday += days[idx]; 
     435  } 
     436 
    445437  return 0; 
    446 }  /* End of ms_md2doy() */ 
    447  
     438} /* End of ms_md2doy() */ 
    448439 
    449440/*************************************************************************** 
     
    465456  int intervening_leap_days; 
    466457  int days; 
    467    
    468   if ( ! btime ) 
    469     return HPTERROR; 
    470    
     458 
     459  if (!btime) 
     460    return HPTERROR; 
     461 
    471462  shortyear = btime->year - 1900; 
    472463 
    473   a4 = (shortyear >> 2) + 475 - ! (shortyear & 3); 
    474   a100 = a4 / 25 - (a4 % 25 < 0); 
    475   a400 = a100 >> 2; 
     464  a4                    = (shortyear >> 2) + 475 - !(shortyear & 3); 
     465  a100                  = a4 / 25 - (a4 % 25 < 0); 
     466  a400                  = a100 >> 2; 
    476467  intervening_leap_days = (a4 - 492) - (a100 - 19) + (a400 - 4); 
    477    
     468 
    478469  days = (365 * (shortyear - 70) + intervening_leap_days + (btime->day - 1)); 
    479    
    480   hptime = (hptime_t ) (60 * (60 * ((hptime_t) 24 * days + btime->hour) + btime->min) + btime->sec) * HPTMODULUS 
    481     + (btime->fract * (HPTMODULUS / 10000)); 
    482      
     470 
     471  hptime = (hptime_t) (60 * (60 * ((hptime_t)24 * days + btime->hour) + btime->min) + btime->sec) * HPTMODULUS + (btime->fract * (HPTMODULUS / 10000)); 
     472 
    483473  return hptime; 
    484 }  /* End of ms_btime2hptime() */ 
    485  
     474} /* End of ms_btime2hptime() */ 
    486475 
    487476/*************************************************************************** 
     
    497486char * 
    498487ms_btime2isotimestr (BTime *btime, char *isotimestr) 
    499 {   
     488{ 
    500489  int month = 0; 
    501   int mday = 0; 
     490  int mday  = 0; 
    502491  int ret; 
    503492 
    504   if ( ! isotimestr ) 
    505     return NULL; 
    506  
    507   if ( ms_doy2md (btime->year, btime->day, &month, &mday) ) 
    508     { 
    509       ms_log (2, "ms_btime2isotimestr(): Error converting year %d day %d\n", 
    510               btime->year, btime->day); 
    511       return NULL; 
    512     } 
    513    
     493  if (!isotimestr) 
     494    return NULL; 
     495 
     496  if (ms_doy2md (btime->year, btime->day, &month, &mday)) 
     497  { 
     498    ms_log (2, "ms_btime2isotimestr(): Error converting year %d day %d\n", 
     499            btime->year, btime->day); 
     500    return NULL; 
     501  } 
     502 
    514503  ret = snprintf (isotimestr, 25, "%4d-%02d-%02dT%02d:%02d:%02d.%04d", 
    515                   btime->year, month, mday, 
    516                   btime->hour, btime->min, btime->sec, btime->fract); 
    517    
    518   if ( ret != 24 ) 
     504                  btime->year, month, mday, 
     505                  btime->hour, btime->min, btime->sec, btime->fract); 
     506 
     507  if (ret != 24) 
    519508    return NULL; 
    520509  else 
    521510    return isotimestr; 
    522 }  /* End of ms_btime2isotimestr() */ 
    523  
     511} /* End of ms_btime2isotimestr() */ 
    524512 
    525513/*************************************************************************** 
     
    527515 * 
    528516 * Build a time string in month-day format from a BTime struct. 
    529  *  
     517 * 
    530518 * The provided isostimestr must have enough room for the resulting time 
    531519 * string of 25 characters, i.e. '2001-07-29 12:38:00.0000' + NULL. 
     
    535523char * 
    536524ms_btime2mdtimestr (BTime *btime, char *mdtimestr) 
    537 {  
     525{ 
    538526  int month = 0; 
    539   int mday = 0; 
     527  int mday  = 0; 
    540528  int ret; 
    541    
    542   if ( ! mdtimestr ) 
    543     return NULL; 
    544    
    545   if ( ms_doy2md (btime->year, btime->day, &month, &mday) ) 
    546     { 
    547       ms_log (2, "ms_btime2mdtimestr(): Error converting year %d day %d\n", 
    548               btime->year, btime->day); 
    549       return NULL; 
    550     } 
    551    
     529 
     530  if (!mdtimestr) 
     531    return NULL; 
     532 
     533  if (ms_doy2md (btime->year, btime->day, &month, &mday)) 
     534  { 
     535    ms_log (2, "ms_btime2mdtimestr(): Error converting year %d day %d\n", 
     536            btime->year, btime->day); 
     537    return NULL; 
     538  } 
     539 
    552540  ret = snprintf (mdtimestr, 25, "%4d-%02d-%02d %02d:%02d:%02d.%04d", 
    553541                  btime->year, month, mday, 
    554542                  btime->hour, btime->min, btime->sec, btime->fract); 
    555543 
    556   if ( ret != 24 ) 
     544  if (ret != 24) 
    557545    return NULL; 
    558546  else 
    559547    return mdtimestr; 
    560 }  /* End of ms_btime2mdtimestr() */ 
    561  
     548} /* End of ms_btime2mdtimestr() */ 
    562549 
    563550/*************************************************************************** 
     
    575562{ 
    576563  int ret; 
    577    
    578   if ( ! seedtimestr ) 
    579     return NULL; 
    580    
     564 
     565  if (!seedtimestr) 
     566    return NULL; 
     567 
    581568  ret = snprintf (seedtimestr, 23, "%4d,%03d,%02d:%02d:%02d.%04d", 
    582                   btime->year, btime->day, 
    583                   btime->hour, btime->min, btime->sec, btime->fract); 
    584    
    585   if ( ret != 22 ) 
     569                  btime->year, btime->day, 
     570                  btime->hour, btime->min, btime->sec, btime->fract); 
     571 
     572  if (ret != 22) 
    586573    return NULL; 
    587574  else 
    588575    return seedtimestr; 
    589 }  /* End of ms_btime2seedtimestr() */ 
    590  
     576} /* End of ms_btime2seedtimestr() */ 
    591577 
    592578/*************************************************************************** 
     
    604590ms_hptime2tomsusecoffset (hptime_t hptime, hptime_t *toms, int8_t *usecoffset) 
    605591{ 
    606   if ( toms == NULL || usecoffset == NULL ) 
     592  if (toms == NULL || usecoffset == NULL) 
    607593    return -1; 
    608    
     594 
    609595  /* Split time into tenths of milliseconds and microseconds */ 
    610   *toms = hptime / (HPTMODULUS / 10000); 
    611   *usecoffset = hptime - (*toms * (HPTMODULUS / 10000)); 
    612    
     596  *toms       = hptime / (HPTMODULUS / 10000); 
     597  *usecoffset = (int8_t) (hptime - (*toms * (HPTMODULUS / 10000))); 
     598 
    613599  /* Round tenths and adjust microsecond offset to -50 to +49 range */ 
    614   if ( *usecoffset > 49 && *usecoffset < 100 ) 
    615     { 
    616       *toms += 1; 
    617       *usecoffset -= 100; 
    618     } 
    619   else if ( *usecoffset < -50 && *usecoffset > -100 ) 
    620     { 
    621       *toms -= 1; 
    622       *usecoffset += 100; 
    623     } 
    624    
     600  if (*usecoffset > 49 && *usecoffset < 100) 
     601  { 
     602    *toms += 1; 
     603    *usecoffset -= 100; 
     604  } 
     605  else if (*usecoffset < -50 && *usecoffset > -100) 
     606  { 
     607    *toms -= 1; 
     608    *usecoffset += 100; 
     609  } 
     610 
    625611  /* Convert tenths of milliseconds to be in hptime_t (HPTMODULUS) units */ 
    626612  *toms *= (HPTMODULUS / 10000); 
    627    
     613 
    628614  return 0; 
    629 }  /* End of ms_hptime2tomsusecoffset() */ 
    630  
     615} /* End of ms_hptime2tomsusecoffset() */ 
    631616 
    632617/*************************************************************************** 
     
    646631  int ifract; 
    647632  int bfract; 
    648    
    649   if ( btime == NULL ) 
     633 
     634  if (btime == NULL) 
    650635    return -1; 
    651    
     636 
    652637  /* Reduce to Unix/POSIX epoch time and fractional seconds */ 
    653   isec = MS_HPTIME2EPOCH(hptime); 
     638  isec   = MS_HPTIME2EPOCH (hptime); 
    654639  ifract = (int)(hptime - (isec * HPTMODULUS)); 
    655    
     640 
    656641  /* BTime only has 1/10000 second precision */ 
    657642  bfract = ifract / (HPTMODULUS / 10000); 
    658    
     643 
    659644  /* Adjust for negative epoch times, round back when needed */ 
    660   if ( hptime < 0 && ifract != 0 ) 
    661     { 
    662       /* Isolate microseconds between 1e-4 and 1e-6 precision and adjust bfract if not zero */ 
    663       if ( ifract - bfract * (HPTMODULUS / 10000) ) 
    664         bfract -= 1; 
    665        
    666       isec -= 1; 
    667       bfract = 10000 - (-bfract); 
    668     } 
    669  
    670   if ( ! (ms_gmtime_r (&isec, &tms)) ) 
     645  if (hptime < 0 && ifract != 0) 
     646  { 
     647    /* Isolate microseconds between 1e-4 and 1e-6 precision and adjust bfract if not zero */ 
     648    if (ifract - bfract * (HPTMODULUS / 10000)) 
     649      bfract -= 1; 
     650 
     651    isec -= 1; 
     652    bfract = 10000 - (-bfract); 
     653  } 
     654 
     655  if (!(ms_gmtime_r (&isec, &tms))) 
    671656    return -1; 
    672    
     657 
    673658  btime->year   = tms.tm_year + 1900; 
    674659  btime->day    = tms.tm_yday + 1; 
     
    677662  btime->sec    = tms.tm_sec; 
    678663  btime->unused = 0; 
    679   btime->fract  = (uint16_t) bfract; 
    680    
     664  btime->fract  = (uint16_t)bfract; 
     665 
    681666  return 0; 
    682 }  /* End of ms_hptime2btime() */ 
    683  
     667} /* End of ms_hptime2btime() */ 
    684668 
    685669/*************************************************************************** 
     
    705689  int ret; 
    706690 
    707   if ( isotimestr == NULL ) 
     691  if (isotimestr == NULL) 
    708692    return NULL; 
    709693 
    710694  /* Reduce to Unix/POSIX epoch time and fractional seconds */ 
    711   isec = MS_HPTIME2EPOCH(hptime); 
     695  isec   = MS_HPTIME2EPOCH (hptime); 
    712696  ifract = (int)(hptime - (isec * HPTMODULUS)); 
    713    
     697 
    714698  /* Adjust for negative epoch times */ 
    715   if ( hptime < 0 && ifract != 0 ) 
    716     { 
    717       isec -= 1; 
    718       ifract = HPTMODULUS - (-ifract); 
    719     } 
    720    
    721   if ( ! (ms_gmtime_r (&isec, &tms)) ) 
    722     return NULL; 
    723    
    724   if ( subseconds ) 
     699  if (hptime < 0 && ifract != 0) 
     700  { 
     701    isec -= 1; 
     702    ifract = HPTMODULUS - (-ifract); 
     703  } 
     704 
     705  if (!(ms_gmtime_r (&isec, &tms))) 
     706    return NULL; 
     707 
     708  if (subseconds) 
    725709    /* Assuming ifract has at least microsecond precision */ 
    726710    ret = snprintf (isotimestr, 27, "%4d-%02d-%02dT%02d:%02d:%02d.%06d", 
     
    732716                    tms.tm_hour, tms.tm_min, tms.tm_sec); 
    733717 
    734   if ( ret != 26 && ret != 19 ) 
     718  if (ret != 26 && ret != 19) 
    735719    return NULL; 
    736720  else 
    737721    return isotimestr; 
    738 }  /* End of ms_hptime2isotimestr() */ 
    739  
     722} /* End of ms_hptime2isotimestr() */ 
    740723 
    741724/*************************************************************************** 
     
    760743  int ifract; 
    761744  int ret; 
    762    
    763   if ( mdtimestr == NULL ) 
     745 
     746  if (mdtimestr == NULL) 
    764747    return NULL; 
    765748 
    766749  /* Reduce to Unix/POSIX epoch time and fractional seconds */ 
    767   isec = MS_HPTIME2EPOCH(hptime); 
     750  isec   = MS_HPTIME2EPOCH (hptime); 
    768751  ifract = (int)(hptime - (isec * HPTMODULUS)); 
    769752 
    770753  /* Adjust for negative epoch times */ 
    771   if ( hptime < 0 && ifract != 0 ) 
    772     { 
    773       isec -= 1; 
    774       ifract = HPTMODULUS - (-ifract); 
    775     } 
    776    
    777   if ( ! (ms_gmtime_r (&isec, &tms)) ) 
    778     return NULL; 
    779  
    780   if ( subseconds ) 
     754  if (hptime < 0 && ifract != 0) 
     755  { 
     756    isec -= 1; 
     757    ifract = HPTMODULUS - (-ifract); 
     758  } 
     759 
     760  if (!(ms_gmtime_r (&isec, &tms))) 
     761    return NULL; 
     762 
     763  if (subseconds) 
    781764    /* Assuming ifract has at least microsecond precision */ 
    782765    ret = snprintf (mdtimestr, 27, "%4d-%02d-%02d %02d:%02d:%02d.%06d", 
     
    788771                    tms.tm_hour, tms.tm_min, tms.tm_sec); 
    789772 
    790   if ( ret != 26 && ret != 19 ) 
     773  if (ret != 26 && ret != 19) 
    791774    return NULL; 
    792775  else 
    793776    return mdtimestr; 
    794 }  /* End of ms_hptime2mdtimestr() */ 
    795  
     777} /* End of ms_hptime2mdtimestr() */ 
    796778 
    797779/*************************************************************************** 
     
    815797  int ifract; 
    816798  int ret; 
    817    
    818   if ( seedtimestr == NULL ) 
    819     return NULL; 
    820    
     799 
     800  if (seedtimestr == NULL) 
     801    return NULL; 
     802 
    821803  /* Reduce to Unix/POSIX epoch time and fractional seconds */ 
    822   isec = MS_HPTIME2EPOCH(hptime); 
     804  isec   = MS_HPTIME2EPOCH (hptime); 
    823805  ifract = (int)(hptime - (isec * HPTMODULUS)); 
    824    
     806 
    825807  /* Adjust for negative epoch times */ 
    826   if ( hptime < 0 && ifract != 0 ) 
    827     { 
    828       isec -= 1; 
    829       ifract = HPTMODULUS - (-ifract); 
    830     } 
    831    
    832   if ( ! (ms_gmtime_r (&isec, &tms)) ) 
    833     return NULL; 
    834    
    835   if ( subseconds ) 
     808  if (hptime < 0 && ifract != 0) 
     809  { 
     810    isec -= 1; 
     811    ifract = HPTMODULUS - (-ifract); 
     812  } 
     813 
     814  if (!(ms_gmtime_r (&isec, &tms))) 
     815    return NULL; 
     816 
     817  if (subseconds) 
    836818    /* Assuming ifract has at least microsecond precision */ 
    837819    ret = snprintf (seedtimestr, 25, "%4d,%03d,%02d:%02d:%02d.%06d", 
    838                     tms.tm_year + 1900, tms.tm_yday + 1, 
    839                     tms.tm_hour, tms.tm_min, tms.tm_sec, ifract); 
     820                    tms.tm_year + 1900, tms.tm_yday + 1, 
     821                    tms.tm_hour, tms.tm_min, tms.tm_sec, ifract); 
    840822  else 
    841823    ret = snprintf (seedtimestr, 18, "%4d,%03d,%02d:%02d:%02d", 
    842824                    tms.tm_year + 1900, tms.tm_yday + 1, 
    843825                    tms.tm_hour, tms.tm_min, tms.tm_sec); 
    844    
    845   if ( ret != 24 && ret != 17 ) 
     826 
     827  if (ret != 24 && ret != 17) 
    846828    return NULL; 
    847829  else 
    848830    return seedtimestr; 
    849 }  /* End of ms_hptime2seedtimestr() */ 
    850  
     831} /* End of ms_hptime2seedtimestr() */ 
    851832 
    852833/*************************************************************************** 
     
    864845  BTime btime; 
    865846  hptime_t hptime; 
    866    
    867   memset (&btime, 0, sizeof(BTime)); 
     847 
     848  memset (&btime, 0, sizeof (BTime)); 
    868849  btime.day = 1; 
    869    
     850 
    870851  /* Convert integer seconds using ms_btime2hptime */ 
    871   btime.year = (int16_t) year; 
    872   btime.day = (int16_t) day; 
    873   btime.hour = (uint8_t) hour; 
    874   btime.min = (uint8_t) min; 
    875   btime.sec = (uint8_t) sec; 
     852  btime.year  = (int16_t)year; 
     853  btime.day   = (int16_t)day; 
     854  btime.hour  = (uint8_t)hour; 
     855  btime.min   = (uint8_t)min; 
     856  btime.sec   = (uint8_t)sec; 
    876857  btime.fract = 0; 
    877858 
    878859  hptime = ms_btime2hptime (&btime); 
    879    
    880   if ( hptime == HPTERROR ) 
    881     { 
    882       ms_log (2, "ms_time2hptime(): Error converting with ms_btime2hptime()\n"); 
    883       return HPTERROR; 
    884     } 
    885    
     860 
     861  if (hptime == HPTERROR) 
     862  { 
     863    ms_log (2, "ms_time2hptime(): Error converting with ms_btime2hptime()\n"); 
     864    return HPTERROR; 
     865  } 
     866 
    886867  /* Add the microseconds */ 
    887   hptime += (hptime_t) usec * (1000000 / HPTMODULUS); 
    888    
     868  hptime += (hptime_t)usec * (1000000 / HPTMODULUS); 
     869 
    889870  return hptime; 
    890 }  /* End of ms_time2hptime_int() */ 
    891  
     871} /* End of ms_time2hptime_int() */ 
    892872 
    893873/*************************************************************************** 
     
    911891ms_time2hptime (int year, int day, int hour, int min, int sec, int usec) 
    912892{ 
    913   if ( year < 1800 || year > 5000 ) 
    914     { 
    915       ms_log (2, "ms_time2hptime(): Error with year value: %d\n", year); 
    916       return HPTERROR; 
    917     } 
    918    
    919   if ( day < 1 || day > 366 ) 
    920     { 
    921       ms_log (2, "ms_time2hptime(): Error with day value: %d\n", day); 
    922       return HPTERROR; 
    923     } 
    924    
    925   if ( hour < 0 || hour > 23 ) 
    926     { 
    927       ms_log (2, "ms_time2hptime(): Error with hour value: %d\n", hour); 
    928       return HPTERROR; 
    929     } 
    930    
    931   if ( min < 0 || min > 59 ) 
    932     { 
    933       ms_log (2, "ms_time2hptime(): Error with minute value: %d\n", min); 
    934       return HPTERROR; 
    935     } 
    936    
    937   if ( sec < 0 || sec > 60 ) 
    938     { 
    939       ms_log (2, "ms_time2hptime(): Error with second value: %d\n", sec); 
    940       return HPTERROR; 
    941     } 
    942    
    943   if ( usec < 0 || usec > 999999 ) 
    944     { 
    945       ms_log (2, "ms_time2hptime(): Error with microsecond value: %d\n", usec); 
    946       return HPTERROR; 
    947     } 
    948    
     893  if (year < 1800 || year > 5000) 
     894  { 
     895    ms_log (2, "ms_time2hptime(): Error with year value: %d\n", year); 
     896    return HPTERROR; 
     897  } 
     898 
     899  if (day < 1 || day > 366) 
     900  { 
     901    ms_log (2, "ms_time2hptime(): Error with day value: %d\n", day); 
     902    return HPTERROR; 
     903  } 
     904 
     905  if (hour < 0 || hour > 23) 
     906  { 
     907    ms_log (2, "ms_time2hptime(): Error with hour value: %d\n", hour); 
     908    return HPTERROR; 
     909  } 
     910 
     911  if (min < 0 || min > 59) 
     912  { 
     913    ms_log (2, "ms_time2hptime(): Error with minute value: %d\n", min); 
     914    return HPTERROR; 
     915  } 
     916 
     917  if (sec < 0 || sec > 60) 
     918  { 
     919    ms_log (2, "ms_time2hptime(): Error with second value: %d\n", sec); 
     920    return HPTERROR; 
     921  } 
     922 
     923  if (usec < 0 || usec > 999999) 
     924  { 
     925    ms_log (2, "ms_time2hptime(): Error with microsecond value: %d\n", usec); 
     926    return HPTERROR; 
     927  } 
     928 
    949929  return ms_time2hptime_int (year, day, hour, min, sec, usec); 
    950 }  /* End of ms_time2hptime() */ 
    951  
     930} /* End of ms_time2hptime() */ 
    952931 
    953932/*************************************************************************** 
    954933 * ms_seedtimestr2hptime: 
    955  *  
     934 * 
    956935 * Convert a SEED time string (day-of-year style) to a high precision 
    957936 * epoch time.  The time format expected is 
     
    974953{ 
    975954  int fields; 
    976   int year = 0; 
    977   int day  = 1; 
    978   int hour = 0; 
    979   int min  = 0; 
    980   int sec  = 0; 
     955  int year    = 0; 
     956  int day     = 1; 
     957  int hour    = 0; 
     958  int min     = 0; 
     959  int sec     = 0; 
    981960  float fusec = 0.0; 
    982   int usec = 0; 
    983    
     961  int usec    = 0; 
     962 
    984963  fields = sscanf (seedtimestr, "%d%*[-,:.]%d%*[-,:.Tt ]%d%*[-,:.]%d%*[-,:.]%d%f", 
    985                    &year, &day, &hour, &min, &sec, &fusec); 
    986    
     964                   &year, &day, &hour, &min, &sec, &fusec); 
     965 
    987966  /* Convert fractional seconds to microseconds */ 
    988   if ( fusec != 0.0 ) 
    989     { 
    990       usec = (int) (fusec * 1000000.0 + 0.5); 
    991     } 
    992    
    993   if ( fields < 1 ) 
    994     { 
    995       ms_log (2, "ms_seedtimestr2hptime(): Error converting time string: %s\n", seedtimestr); 
    996       return HPTERROR; 
    997     } 
    998    
    999   if ( year < 1800 || year > 5000 ) 
    1000     { 
    1001       ms_log (2, "ms_seedtimestr2hptime(): Error with year value: %d\n", year); 
    1002       return HPTERROR; 
    1003     } 
    1004  
    1005   if ( day < 1 || day > 366 ) 
    1006     { 
    1007       ms_log (2, "ms_seedtimestr2hptime(): Error with day value: %d\n", day); 
    1008       return HPTERROR; 
    1009     } 
    1010    
    1011   if ( hour < 0 || hour > 23 ) 
    1012     { 
    1013       ms_log (2, "ms_seedtimestr2hptime(): Error with hour value: %d\n", hour); 
    1014       return HPTERROR; 
    1015     } 
    1016    
    1017   if ( min < 0 || min > 59 ) 
    1018     { 
    1019       ms_log (2, "ms_seedtimestr2hptime(): Error with minute value: %d\n", min); 
    1020       return HPTERROR; 
    1021     } 
    1022    
    1023   if ( sec < 0 || sec > 60 ) 
    1024     { 
    1025       ms_log (2, "ms_seedtimestr2hptime(): Error with second value: %d\n", sec); 
    1026       return HPTERROR; 
    1027     } 
    1028    
    1029   if ( usec < 0 || usec > 999999 ) 
    1030     { 
    1031       ms_log (2, "ms_seedtimestr2hptime(): Error with fractional second value: %d\n", usec); 
    1032       return HPTERROR; 
    1033     } 
    1034    
     967  if (fusec != 0.0) 
     968  { 
     969    usec = (int)(fusec * 1000000.0 + 0.5); 
     970  } 
     971 
     972  if (fields < 1) 
     973  { 
     974    ms_log (2, "ms_seedtimestr2hptime(): Error converting time string: %s\n", seedtimestr); 
     975    return HPTERROR; 
     976  } 
     977 
     978  if (year < 1800 || year > 5000) 
     979  { 
     980    ms_log (2, "ms_seedtimestr2hptime(): Error with year value: %d\n", year); 
     981    return HPTERROR; 
     982  } 
     983 
     984  if (day < 1 || day > 366) 
     985  { 
     986    ms_log (2, "ms_seedtimestr2hptime(): Error with day value: %d\n", day); 
     987    return HPTERROR; 
     988  } 
     989 
     990  if (hour < 0 || hour > 23) 
     991  { 
     992    ms_log (2, "ms_seedtimestr2hptime(): Error with hour value: %d\n", hour); 
     993    return HPTERROR; 
     994  } 
     995 
     996  if (min < 0 || min > 59) 
     997  { 
     998    ms_log (2, "ms_seedtimestr2hptime(): Error with minute value: %d\n", min); 
     999    return HPTERROR; 
     1000  } 
     1001 
     1002  if (sec < 0 || sec > 60) 
     1003  { 
     1004    ms_log (2, "ms_seedtimestr2hptime(): Error with second value: %d\n", sec); 
     1005    return HPTERROR; 
     1006  } 
     1007 
     1008  if (usec < 0 || usec > 999999) 
     1009  { 
     1010    ms_log (2, "ms_seedtimestr2hptime(): Error with fractional second value: %d\n", usec); 
     1011    return HPTERROR; 
     1012  } 
     1013 
    10351014  return ms_time2hptime_int (year, day, hour, min, sec, usec); 
    1036 }  /* End of ms_seedtimestr2hptime() */ 
    1037  
     1015} /* End of ms_seedtimestr2hptime() */ 
    10381016 
    10391017/*************************************************************************** 
    10401018 * ms_timestr2hptime: 
    1041  *  
     1019 * 
    10421020 * Convert a generic time string to a high precision epoch time.  The 
    10431021 * time format expected is "YYYY[/MM/DD HH:MM:SS.FFFF]", the delimiter 
     
    10601038{ 
    10611039  int fields; 
    1062   int year = 0; 
    1063   int mon  = 1; 
    1064   int mday = 1; 
    1065   int day  = 1; 
    1066   int hour = 0; 
    1067   int min  = 0; 
    1068   int sec  = 0; 
     1040  int year    = 0; 
     1041  int mon     = 1; 
     1042  int mday    = 1; 
     1043  int day     = 1; 
     1044  int hour    = 0; 
     1045  int min     = 0; 
     1046  int sec     = 0; 
    10691047  float fusec = 0.0; 
    1070   int usec = 0; 
    1071    
     1048  int usec    = 0; 
     1049 
    10721050  fields = sscanf (timestr, "%d%*[-,/:.]%d%*[-,/:.]%d%*[-,/:.Tt ]%d%*[-,/:.]%d%*[-,/:.]%d%f", 
    1073                    &year, &mon, &mday, &hour, &min, &sec, &fusec); 
    1074    
     1051                   &year, &mon, &mday, &hour, &min, &sec, &fusec); 
     1052 
    10751053  /* Convert fractional seconds to microseconds */ 
    1076   if ( fusec != 0.0 ) 
    1077     { 
    1078       usec = (int) (fusec * 1000000.0 + 0.5); 
    1079     } 
    1080  
    1081   if ( fields < 1 ) 
    1082     { 
    1083       ms_log (2, "ms_timestr2hptime(): Error converting time string: %s\n", timestr); 
    1084       return HPTERROR; 
    1085     } 
    1086    
    1087   if ( year < 1800 || year > 5000 ) 
    1088     { 
    1089       ms_log (2, "ms_timestr2hptime(): Error with year value: %d\n", year); 
    1090       return HPTERROR; 
    1091     } 
    1092    
    1093   if ( mon < 1 || mon > 12 ) 
    1094     { 
    1095       ms_log (2, "ms_timestr2hptime(): Error with month value: %d\n", mon); 
    1096       return HPTERROR; 
    1097     } 
    1098  
    1099   if ( mday < 1 || mday > 31 ) 
    1100     { 
    1101       ms_log (2, "ms_timestr2hptime(): Error with day value: %d\n", mday); 
    1102       return HPTERROR; 
    1103     } 
     1054  if (fusec != 0.0) 
     1055  { 
     1056    usec = (int)(fusec * 1000000.0 + 0.5); 
     1057  } 
     1058 
     1059  if (fields < 1) 
     1060  { 
     1061    ms_log (2, "ms_timestr2hptime(): Error converting time string: %s\n", timestr); 
     1062    return HPTERROR; 
     1063  } 
     1064 
     1065  if (year < 1800 || year > 5000) 
     1066  { 
     1067    ms_log (2, "ms_timestr2hptime(): Error with year value: %d\n", year); 
     1068    return HPTERROR; 
     1069  } 
     1070 
     1071  if (mon < 1 || mon > 12) 
     1072  { 
     1073    ms_log (2, "ms_timestr2hptime(): Error with month value: %d\n", mon); 
     1074    return HPTERROR; 
     1075  } 
     1076 
     1077  if (mday < 1 || mday > 31) 
     1078  { 
     1079    ms_log (2, "ms_timestr2hptime(): Error with day value: %d\n", mday); 
     1080    return HPTERROR; 
     1081  } 
    11041082 
    11051083  /* Convert month and day-of-month to day-of-year */ 
    1106   if ( ms_md2doy (year, mon, mday, &day) ) 
    1107     { 
    1108       return HPTERROR; 
    1109     } 
    1110    
    1111   if ( hour < 0 || hour > 23 ) 
    1112     { 
    1113       ms_log (2, "ms_timestr2hptime(): Error with hour value: %d\n", hour); 
    1114       return HPTERROR; 
    1115     } 
    1116    
    1117   if ( min < 0 || min > 59 ) 
    1118     { 
    1119       ms_log (2, "ms_timestr2hptime(): Error with minute value: %d\n", min); 
    1120       return HPTERROR; 
    1121     } 
    1122    
    1123   if ( sec < 0 || sec > 60 ) 
    1124     { 
    1125       ms_log (2, "ms_timestr2hptime(): Error with second value: %d\n", sec); 
    1126       return HPTERROR; 
    1127     } 
    1128    
    1129   if ( usec < 0 || usec > 999999 ) 
    1130     { 
    1131       ms_log (2, "ms_timestr2hptime(): Error with fractional second value: %d\n", usec); 
    1132       return HPTERROR; 
    1133     } 
    1134    
     1084  if (ms_md2doy (year, mon, mday, &day)) 
     1085  { 
     1086    return HPTERROR; 
     1087  } 
     1088 
     1089  if (hour < 0 || hour > 23) 
     1090  { 
     1091    ms_log (2, "ms_timestr2hptime(): Error with hour value: %d\n", hour); 
     1092    return HPTERROR; 
     1093  } 
     1094 
     1095  if (min < 0 || min > 59) 
     1096  { 
     1097    ms_log (2, "ms_timestr2hptime(): Error with minute value: %d\n", min); 
     1098    return HPTERROR; 
     1099  } 
     1100 
     1101  if (sec < 0 || sec > 60) 
     1102  { 
     1103    ms_log (2, "ms_timestr2hptime(): Error with second value: %d\n", sec); 
     1104    return HPTERROR; 
     1105  } 
     1106 
     1107  if (usec < 0 || usec > 999999) 
     1108  { 
     1109    ms_log (2, "ms_timestr2hptime(): Error with fractional second value: %d\n", usec); 
     1110    return HPTERROR; 
     1111  } 
     1112 
    11351113  return ms_time2hptime_int (year, day, hour, min, sec, usec); 
    1136 }  /* End of ms_timestr2hptime() */ 
    1137  
     1114} /* End of ms_timestr2hptime() */ 
    11381115 
    11391116/*************************************************************************** 
     
    11421119 * Calculate a sample rate from SEED sample rate factor and multiplier 
    11431120 * as stored in the fixed section header of data records. 
    1144  *  
     1121 * 
    11451122 * Returns the positive sample rate. 
    11461123 ***************************************************************************/ 
     
    11491126{ 
    11501127  double samprate = 0.0; 
    1151    
    1152   if ( factor > 0 ) 
    1153     samprate = (double) factor; 
    1154   else if ( factor < 0 ) 
    1155     samprate = -1.0 / (double) factor; 
    1156   if ( multiplier > 0 ) 
    1157     samprate = samprate * (double) multiplier; 
    1158   else if ( multiplier < 0 ) 
    1159     samprate = -1.0 * (samprate / (double) multiplier); 
    1160    
     1128 
     1129  if (factor > 0) 
     1130    samprate = (double)factor; 
     1131  else if (factor < 0) 
     1132    samprate = -1.0 / (double)factor; 
     1133  if (multiplier > 0) 
     1134    samprate = samprate * (double)multiplier; 
     1135  else if (multiplier < 0) 
     1136    samprate = -1.0 * (samprate / (double)multiplier); 
     1137 
    11611138  return samprate; 
    1162 }  /* End of ms_nomsamprate() */ 
    1163  
     1139} /* End of ms_nomsamprate() */ 
    11641140 
    11651141/*************************************************************************** 
     
    11681144 * Read leap seconds from a file indicated by the specified 
    11691145 * environment variable and populate the global leapsecondlist. 
    1170  *  
     1146 * 
    11711147 * Returns positive number of leap seconds read, -1 on file read 
    11721148 * error, and -2 when the environment variable is not set. 
     
    11761152{ 
    11771153  char *filename; 
    1178    
    1179   if ( (filename = getenv(envvarname)) ) 
    1180     { 
    1181       return ms_readleapsecondfile (filename); 
    1182     } 
    1183    
     1154 
     1155  if ((filename = getenv (envvarname))) 
     1156  { 
     1157    return ms_readleapsecondfile (filename); 
     1158  } 
     1159 
    11841160  return -2; 
    1185 }  /* End of ms_readleapseconds() */ 
    1186  
     1161} /* End of ms_readleapseconds() */ 
    11871162 
    11881163/*************************************************************************** 
     
    11921167 * leapsecondlist.  The file is expected to be standard IETF leap 
    11931168 * second list format.  The list is usually available from: 
    1194  * http://www.ietf.org/timezones/data/leap-seconds.list 
    1195  *  
     1169 * https://www.ietf.org/timezones/data/leap-seconds.list 
     1170 * 
    11961171 * Returns positive number of leap seconds read on success and -1 on error. 
    11971172 ***************************************************************************/ 
     
    11991174ms_readleapsecondfile (char *filename) 
    12001175{ 
    1201   FILE *fp = NULL; 
    1202   LeapSecond *ls = NULL; 
     1176  FILE *fp           = NULL; 
     1177  LeapSecond *ls     = NULL; 
    12031178  LeapSecond *lastls = NULL; 
    12041179  int64_t expires; 
     
    12091184  int fields; 
    12101185  int count = 0; 
    1211    
    1212   if ( ! filename ) 
     1186 
     1187  if (!filename) 
    12131188    return -1; 
    1214    
    1215   if ( ! (fp = fopen(filename, "rb")) ) 
    1216     { 
    1217       ms_log (2, "Cannot open file %s: %s\n", filename, strerror(errno)); 
    1218       return -1; 
    1219     } 
    1220    
    1221   while ( fgets (readline, sizeof(readline)-1, fp) ) 
    1222     { 
    1223       /* Guarantee termination */ 
    1224       readline[sizeof(readline)-1] = '\0'; 
    1225        
    1226       /* Terminate string at first newline character if any */ 
    1227       if ( (cp = strchr(readline, '\n')) ) 
    1228         *cp = '\0'; 
    1229        
    1230       /* Skip empty lines */ 
    1231       if ( ! strlen (readline) ) 
    1232         continue; 
    1233        
    1234       /* Check for and parse expiration date */ 
    1235       if ( ! strncmp (readline, "#@", 2) ) 
     1189 
     1190  if (!(fp = fopen (filename, "rb"))) 
     1191  { 
     1192    ms_log (2, "Cannot open leap second file %s: %s\n", filename, strerror (errno)); 
     1193    return -1; 
     1194  } 
     1195 
     1196  while (fgets (readline, sizeof (readline) - 1, fp)) 
     1197  { 
     1198    /* Guarantee termination */ 
     1199    readline[sizeof (readline) - 1] = '\0'; 
     1200 
     1201    /* Terminate string at first newline character if any */ 
     1202    if ((cp = strchr (readline, '\n'))) 
     1203      *cp = '\0'; 
     1204 
     1205    /* Skip empty lines */ 
     1206    if (!strlen (readline)) 
     1207      continue; 
     1208 
     1209    /* Check for and parse expiration date */ 
     1210    if (!strncmp (readline, "#@", 2)) 
     1211    { 
     1212      expires = 0; 
     1213      fields  = sscanf (readline, "#@ %" SCNd64, &expires); 
     1214 
     1215      if (fields == 1) 
     1216      { 
     1217        /* Convert expires to Unix epoch */ 
     1218        expires = expires - NTPPOSIXEPOCHDELTA; 
     1219 
     1220        /* Compare expire time to current time */ 
     1221        if (time (NULL) > expires) 
    12361222        { 
    1237           expires = 0; 
    1238           fields = sscanf (readline, "#@ %"SCNd64, &expires); 
    1239            
    1240           if ( fields == 1 ) 
    1241             { 
    1242               /* Convert expires to Unix epoch */ 
    1243               expires = expires - NTPPOSIXEPOCHDELTA; 
    1244  
    1245               /* Compare expire time to current time */ 
    1246               if ( time(NULL) > expires ) 
    1247                 { 
    1248                   char timestr[100]; 
    1249                   ms_hptime2mdtimestr (MS_EPOCH2HPTIME(expires), timestr, 0); 
    1250                   ms_log (1, "Warning: leap second file (%s) has expired as of %s\n", 
    1251                           filename, timestr); 
    1252                 } 
    1253             } 
    1254            
    1255           continue; 
     1223          char timestr[100]; 
     1224          ms_hptime2mdtimestr (MS_EPOCH2HPTIME (expires), timestr, 0); 
     1225          ms_log (1, "Warning: leap second file (%s) has expired as of %s\n", 
     1226                  filename, timestr); 
    12561227        } 
    1257        
    1258       /* Skip comment lines */ 
    1259       if ( *readline == '#' ) 
    1260         continue; 
    1261        
    1262       fields = sscanf (readline, "%"SCNd64" %d ", &leapsecond, &TAIdelta); 
    1263        
    1264       if ( fields == 2 ) 
     1228      } 
     1229 
     1230      continue; 
     1231    } 
     1232 
     1233    /* Skip comment lines */ 
     1234    if (*readline == '#') 
     1235      continue; 
     1236 
     1237    fields = sscanf (readline, "%" SCNd64 " %d ", &leapsecond, &TAIdelta); 
     1238 
     1239    if (fields == 2) 
     1240    { 
     1241      if ((ls = malloc (sizeof (LeapSecond))) == NULL) 
     1242      { 
     1243        ms_log (2, "Cannot allocate LeapSecond, out of memory?\n"); 
     1244        return -1; 
     1245      } 
     1246 
     1247      /* Convert NTP epoch time to Unix epoch time and then to HPT */ 
     1248      ls->leapsecond = MS_EPOCH2HPTIME ((leapsecond - NTPPOSIXEPOCHDELTA)); 
     1249      ls->TAIdelta   = TAIdelta; 
     1250      ls->next       = NULL; 
     1251 
     1252      /* Add leap second to global list */ 
     1253      if (!leapsecondlist) 
     1254      { 
     1255        leapsecondlist = ls; 
     1256        lastls         = ls; 
     1257      } 
     1258      else 
     1259      { 
     1260        lastls->next = ls; 
     1261        lastls       = ls; 
     1262      } 
     1263    } 
     1264    else 
     1265    { 
     1266      ms_log (1, "Unrecognized leap second file line: '%s'\n", readline); 
     1267    } 
     1268  } 
     1269 
     1270  if (ferror (fp)) 
     1271  { 
     1272    ms_log (2, "Error reading leap second file (%s): %s\n", filename, strerror (errno)); 
     1273  } 
     1274 
     1275  fclose (fp); 
     1276 
     1277  return count; 
     1278} /* End of ms_readleapsecondfile() */ 
     1279 
     1280/*************************************************************************** 
     1281 * ms_reduce_rate: 
     1282 * 
     1283 * Reduce the specified sample rate into two "factors" (in some cases 
     1284 * the second factor is actually a divisor). 
     1285 * 
     1286 * Integer rates between 1 and 32767 can be represented exactly. 
     1287 * 
     1288 * Integer rates higher than 32767 will be matched as closely as 
     1289 * possible with the deviation becoming larger as the integers reach 
     1290 * (32767 * 32767). 
     1291 * 
     1292 * Non-integer rates between 32767.0 and 1.0/32767.0 are represented 
     1293 * exactly when possible and approximated otherwise. 
     1294 * 
     1295 * Non-integer rates greater than 32767 or less than 1/32767 are not supported. 
     1296 * 
     1297 * Returns 0 on success and -1 on error. 
     1298 ***************************************************************************/ 
     1299int 
     1300ms_reduce_rate (double samprate, int16_t *factor1, int16_t *factor2) 
     1301{ 
     1302  int num; 
     1303  int den; 
     1304  int32_t intsamprate = (int32_t) (samprate + 0.5); 
     1305 
     1306  int32_t searchfactor1; 
     1307  int32_t searchfactor2; 
     1308  int32_t closestfactor; 
     1309  int32_t closestdiff; 
     1310  int32_t diff; 
     1311 
     1312  /* Handle case of integer sample values. */ 
     1313  if (ms_dabs (samprate - intsamprate) < 0.0000001) 
     1314  { 
     1315    /* If integer sample rate is less than range of 16-bit int set it directly */ 
     1316    if (intsamprate <= 32767) 
     1317    { 
     1318      *factor1 = intsamprate; 
     1319      *factor2 = 1; 
     1320      return 0; 
     1321    } 
     1322    /* If integer sample rate is within the maximum possible nominal rate */ 
     1323    else if (intsamprate <= (32767 * 32767)) 
     1324    { 
     1325      /* Determine the closest factors that represent the sample rate. 
     1326       * The approximation gets worse as the values increase. */ 
     1327      searchfactor1 = (int)(1.0 / ms_rsqrt64 (samprate)); 
     1328      closestdiff   = searchfactor1; 
     1329      closestfactor = searchfactor1; 
     1330 
     1331      while ((intsamprate % searchfactor1) != 0) 
     1332      { 
     1333        searchfactor1 -= 1; 
     1334 
     1335        /* Track the factor that generates the closest match */ 
     1336        searchfactor2 = intsamprate / searchfactor1; 
     1337        diff          = intsamprate - (searchfactor1 * searchfactor2); 
     1338        if (diff < closestdiff) 
    12651339        { 
    1266           if ( (ls = malloc (sizeof(LeapSecond))) == NULL ) 
    1267             { 
    1268               ms_log (2, "Cannot allocate LeapSecond, out of memory?\n"); 
    1269               return -1; 
    1270             } 
    1271            
    1272           /* Convert NTP epoch time to Unix epoch time and then to HPT */ 
    1273           ls->leapsecond = MS_EPOCH2HPTIME( (leapsecond - NTPPOSIXEPOCHDELTA) ); 
    1274           ls->TAIdelta = TAIdelta; 
    1275           ls->next = NULL; 
    1276            
    1277           /* Add leap second to global list */ 
    1278           if ( ! leapsecondlist ) 
    1279             { 
    1280               leapsecondlist = ls; 
    1281               lastls = ls; 
    1282             } 
    1283           else 
    1284             { 
    1285               lastls->next = ls; 
    1286               lastls = ls; 
    1287             } 
     1340          closestdiff   = diff; 
     1341          closestfactor = searchfactor1; 
    12881342        } 
    1289       else 
     1343 
     1344        /* If the next iteration would create a factor beyond the limit 
     1345         * we accept the closest factor */ 
     1346        if ((intsamprate / (searchfactor1 - 1)) > 32767) 
    12901347        { 
    1291           ms_log (1, "Unrecognized leap second file line: '%s'\n", readline); 
     1348          searchfactor1 = closestfactor; 
     1349          break; 
    12921350        } 
    1293     } 
    1294    
    1295   return count; 
    1296 }  /* End of ms_readleapsecondfile() */ 
    1297  
     1351      } 
     1352 
     1353      searchfactor2 = intsamprate / searchfactor1; 
     1354 
     1355      if (searchfactor1 <= 32767 && searchfactor2 <= 32767) 
     1356      { 
     1357        *factor1 = searchfactor1; 
     1358        *factor2 = searchfactor2; 
     1359        return 0; 
     1360      } 
     1361    } 
     1362  } 
     1363  /* Handle case of non-integer less than 16-bit int range */ 
     1364  else if (samprate <= 32767.0) 
     1365  { 
     1366    /* For samples/seconds, determine, potentially approximate, numerator and denomiator */ 
     1367    ms_ratapprox (samprate, &num, &den, 32767, 1e-8); 
     1368 
     1369    /* Negate the factor2 to denote a division operation */ 
     1370    *factor1 = (int16_t)num; 
     1371    *factor2 = (int16_t)-den; 
     1372    return 0; 
     1373  } 
     1374 
     1375  return -1; 
     1376} /* End of ms_reduce_rate() */ 
    12981377 
    12991378/*************************************************************************** 
    13001379 * ms_genfactmult: 
    13011380 * 
    1302  * Generate an approriate SEED sample rate factor and multiplier from 
     1381 * Generate an appropriate SEED sample rate factor and multiplier from 
    13031382 * a double precision sample rate. 
    1304  *  
    1305  * Returns 0 on success and -1 on error. 
     1383 * 
     1384 * If the samplerate > 0.0 it is expected to be a rate in SAMPLES/SECOND. 
     1385 * If the samplerate < 0.0 it is expected to be a period in SECONDS/SAMPLE. 
     1386 * 
     1387 * Results use SAMPLES/SECOND notation when sample rate >= 1.0 
     1388 * Results use SECONDS/SAMPLE notation when samles rates < 1.0 
     1389 * 
     1390 * Returns 0 on success and -1 on error or calculation not possible. 
    13061391 ***************************************************************************/ 
    13071392int 
    13081393ms_genfactmult (double samprate, int16_t *factor, int16_t *multiplier) 
    13091394{ 
    1310   int num, den; 
    1311    
    1312   /* This routine does not support very high or negative sample rates, 
    1313      even though high rates are possible in Mini-SEED */ 
    1314   if ( samprate > 32767.0 || samprate < 0.0 ) 
    1315     { 
    1316       ms_log (2, "ms_genfactmult(): samprate out of range: %g\n", samprate); 
    1317       return -1; 
    1318     } 
    1319    
    1320   /* If the sample rate is integer set the factor and multipler in the 
    1321      obvious way, otherwise derive a (potentially approximate) 
    1322      numerator and denominator for the given samprate */ 
    1323   if ( (samprate - (int16_t) samprate) < 0.000001 ) 
    1324     { 
    1325       *factor = (int16_t) samprate; 
    1326       if ( *factor ) 
    1327         *multiplier = 1; 
    1328     } 
     1395  int16_t factor1; 
     1396  int16_t factor2; 
     1397 
     1398  if (!factor || !multiplier) 
     1399    return -1; 
     1400 
     1401  /* Convert sample period to sample rate */ 
     1402  if (samprate < 0.0) 
     1403    samprate = -1.0 / samprate; 
     1404 
     1405  /* Handle special case of zero */ 
     1406  if (samprate == 0.0) 
     1407  { 
     1408    *factor     = 0; 
     1409    *multiplier = 0; 
     1410    return 0; 
     1411  } 
     1412  /* Handle sample rates >= 1.0 with the SAMPLES/SECOND representation */ 
     1413  else if (samprate >= 1.0) 
     1414  { 
     1415    if (ms_reduce_rate (samprate, &factor1, &factor2) == 0) 
     1416    { 
     1417      *factor     = factor1; 
     1418      *multiplier = factor2; 
     1419      return 0; 
     1420    } 
     1421  } 
     1422  /* Handle sample rates < 1 with the SECONDS/SAMPLE representation */ 
    13291423  else 
    1330     { 
    1331       ms_ratapprox (samprate, &num, &den, 32767, 1e-12); 
    1332        
    1333       /* Negate the multiplier to denote a division factor */ 
    1334       *factor = (int16_t ) num; 
    1335       *multiplier = (int16_t) -den; 
    1336     } 
    1337    
    1338   return 0; 
    1339 }  /* End of ms_genfactmult() */ 
    1340  
     1424  { 
     1425    /* Reduce rate as a sample period and invert factor/multiplier */ 
     1426    if (ms_reduce_rate (1.0 / samprate, &factor1, &factor2) == 0) 
     1427    { 
     1428      *factor     = -factor1; 
     1429      *multiplier = -factor2; 
     1430      return 0; 
     1431    } 
     1432  } 
     1433 
     1434  return -1; 
     1435} /* End of ms_genfactmult() */ 
    13411436 
    13421437/*************************************************************************** 
     
    13471442 * numerator (num) and denominator (den) whose absolute values are not 
    13481443 * larger than 'maxval' while trying to reach a specified 'precision'. 
    1349  *  
     1444 * 
    13501445 * Returns the number of iterations performed. 
    13511446 ***************************************************************************/ 
     
    13541449{ 
    13551450  double realj, preal; 
    1356   char pos;   
     1451  char pos; 
    13571452  int pnum, pden; 
    13581453  int iterations = 1; 
     
    13611456  int Aj = 0; 
    13621457  int Bj = 1; 
    1363    
    1364   if ( real >= 0.0 ) { pos = 1; realj = real; } 
    1365   else               { pos = 0; realj = -real; } 
    1366    
     1458 
     1459  if (real >= 0.0) 
     1460  { 
     1461    pos   = 1; 
     1462    realj = real; 
     1463  } 
     1464  else 
     1465  { 
     1466    pos   = 0; 
     1467    realj = -real; 
     1468  } 
     1469 
    13671470  preal = realj; 
    1368    
    1369   bj = (int) (realj + precision); 
     1471 
     1472  bj    = (int)(realj + precision); 
    13701473  realj = 1 / (realj - bj); 
    1371   Aj = bj; Aj1 = 1; 
    1372   Bj = 1;  Bj1 = 0; 
     1474  Aj    = bj; 
     1475  Aj1   = 1; 
     1476  Bj    = 1; 
     1477  Bj1   = 0; 
    13731478  *num = pnum = Aj; 
    13741479  *den = pden = Bj; 
    1375   if ( !pos ) *num = -*num; 
    1376    
    1377   while ( ms_dabs(preal - (double)Aj/(double)Bj) > precision && 
    1378           Aj < maxval && Bj < maxval ) 
    1379     { 
    1380       Aj2 = Aj1; Aj1 = Aj; 
    1381       Bj2 = Bj1; Bj1 = Bj; 
    1382       bj = (int) (realj + precision); 
    1383       realj = 1 / (realj - bj); 
    1384       Aj = bj * Aj1 + Aj2; 
    1385       Bj = bj * Bj1 + Bj2; 
    1386       *num = pnum; 
    1387       *den = pden; 
    1388       if ( !pos ) *num = -*num; 
    1389       pnum = Aj; 
    1390       pden = Bj; 
    1391        
    1392       iterations++; 
    1393     } 
    1394    
    1395   if ( pnum < maxval && pden < maxval ) 
    1396     { 
    1397       *num = pnum; 
    1398       *den = pden; 
    1399       if ( !pos ) *num = -*num; 
    1400     } 
    1401    
     1480  if (!pos) 
     1481    *num = -*num; 
     1482 
     1483  while (ms_dabs (preal - (double)Aj / (double)Bj) > precision && 
     1484         Aj < maxval && Bj < maxval) 
     1485  { 
     1486    Aj2   = Aj1; 
     1487    Aj1   = Aj; 
     1488    Bj2   = Bj1; 
     1489    Bj1   = Bj; 
     1490    bj    = (int)(realj + precision); 
     1491    realj = 1 / (realj - bj); 
     1492    Aj    = bj * Aj1 + Aj2; 
     1493    Bj    = bj * Bj1 + Bj2; 
     1494    *num  = pnum; 
     1495    *den  = pden; 
     1496    if (!pos) 
     1497      *num = -*num; 
     1498    pnum   = Aj; 
     1499    pden   = Bj; 
     1500 
     1501    iterations++; 
     1502  } 
     1503 
     1504  if (pnum < maxval && pden < maxval) 
     1505  { 
     1506    *num = pnum; 
     1507    *den = pden; 
     1508    if (!pos) 
     1509      *num = -*num; 
     1510  } 
     1511 
    14021512  return iterations; 
    14031513} 
    1404  
    14051514 
    14061515/*************************************************************************** 
     
    14111520 * provided.  The code below actually tests for little-endianess, the 
    14121521 * only other alternative is assumed to be big endian. 
    1413  *  
     1522 * 
    14141523 * Returns 0 if the host is little endian, otherwise 1. 
    14151524 ***************************************************************************/ 
     
    14191528  int16_t host = 1; 
    14201529  return !(*((int8_t *)(&host))); 
    1421 }  /* End of ms_bigendianhost() */ 
    1422  
     1530} /* End of ms_bigendianhost() */ 
    14231531 
    14241532/*************************************************************************** 
     
    14281536 * if the input double is positive multiplying by -1.0 if not and 
    14291537 * return it. 
    1430  *  
     1538 * 
    14311539 * Returns the positive value of input double. 
    14321540 ***************************************************************************/ 
     
    14341542ms_dabs (double val) 
    14351543{ 
    1436   if ( val < 0.0 ) 
     1544  if (val < 0.0) 
    14371545    val *= -1.0; 
    14381546  return val; 
    1439 }  /* End of ms_dabs() */ 
    1440  
     1547} /* End of ms_dabs() */ 
     1548 
     1549/*************************************************************************** 
     1550 * ms_rsqrt64: 
     1551 * 
     1552 * An optimized reciprocal square root calculation from: 
     1553 *   Matthew Robertson (2012). "A Brief History of InvSqrt" 
     1554 *   https://cs.uwaterloo.ca/~m32rober/rsqrt.pdf 
     1555 * 
     1556 * Further reference and description: 
     1557 *   https://en.wikipedia.org/wiki/Fast_inverse_square_root 
     1558 * 
     1559 * Modifications: 
     1560 * Add 2 more iterations of Newton's method to increase accuracy, 
     1561 * specifically for large values. 
     1562 * Use memcpy instead of assignment through differing pointer types. 
     1563 * 
     1564 * Returns 0 if the host is little endian, otherwise 1. 
     1565 ***************************************************************************/ 
     1566double 
     1567ms_rsqrt64 (double val) 
     1568{ 
     1569  uint64_t i; 
     1570  double x2; 
     1571  double y; 
     1572 
     1573  x2 = val * 0.5; 
     1574  y  = val; 
     1575  memcpy (&i, &y, sizeof(i)); 
     1576  i  = 0x5fe6eb50c7b537a9 - (i >> 1); 
     1577  memcpy (&y, &i, sizeof(y)); 
     1578  y  = y * (1.5 - (x2 * y * y)); 
     1579  y  = y * (1.5 - (x2 * y * y)); 
     1580  y  = y * (1.5 - (x2 * y * y)); 
     1581 
     1582  return y; 
     1583} /* End of ms_rsqrt64() */ 
    14411584 
    14421585/*************************************************************************** 
     
    14501593 * made to integrate the original to this code base, avoid name 
    14511594 * collisions and formatting so I could read it. 
    1452  *  
     1595 * 
    14531596 * Returns a pointer to the populated tm struct on success and NULL on error. 
    14541597 ***************************************************************************/ 
     
    14921635 
    14931636const char pivotal_gmtime_r_stamp_lm[] = 
    1494   "pivotal_gmtime_r. Copyright (C) 2009  Paul Sheer. Terms and " 
    1495   "conditions apply. Visit http://2038bug.com/ for more info."; 
     1637    "pivotal_gmtime_r. Copyright (C) 2009  Paul Sheer. Terms and " 
     1638    "conditions apply. Visit http://2038bug.com/ for more info."; 
    14961639 
    14971640static const int tm_days[4][13] = { 
    1498   {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, 
    1499   {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, 
    1500   {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, 
    1501   {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}, 
     1641    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, 
     1642    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, 
     1643    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, 
     1644    {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}, 
    15021645}; 
    15031646 
    15041647#define TM_LEAP_CHECK(n) ((!(((n) + 1900) % 400) || (!(((n) + 1900) % 4) && (((n) + 1900) % 100))) != 0) 
    1505 #define TM_WRAP(a,b,m)   ((a) = ((a) <  0  ) ? ((b)--, (a) + (m)) : (a)) 
     1648#define TM_WRAP(a, b, m) ((a) = ((a) < 0) ? ((b)--, (a) + (m)) : (a)) 
    15061649 
    15071650static struct tm * 
     
    15121655  long m; 
    15131656  int64_t tv; 
    1514    
    1515   if ( ! timep || ! result ) 
    1516     return NULL; 
    1517    
     1657 
     1658  if (!timep || !result) 
     1659    return NULL; 
     1660 
    15181661  tv = *timep; 
    1519    
    1520   v_tm_sec = ((int64_t) tv % (int64_t) 60); 
     1662 
     1663  v_tm_sec = ((int64_t)tv % (int64_t)60); 
    15211664  tv /= 60; 
    1522   v_tm_min = ((int64_t) tv % (int64_t) 60); 
     1665  v_tm_min = ((int64_t)tv % (int64_t)60); 
    15231666  tv /= 60; 
    1524   v_tm_hour = ((int64_t) tv % (int64_t) 24); 
     1667  v_tm_hour = ((int64_t)tv % (int64_t)24); 
    15251668  tv /= 24; 
    15261669  v_tm_tday = (int)tv; 
    1527    
     1670 
    15281671  TM_WRAP (v_tm_sec, v_tm_min, 60); 
    15291672  TM_WRAP (v_tm_min, v_tm_hour, 60); 
    15301673  TM_WRAP (v_tm_hour, v_tm_tday, 24); 
    1531    
    1532   if ( (v_tm_wday = (v_tm_tday + 4) % 7) < 0 ) 
     1674 
     1675  if ((v_tm_wday = (v_tm_tday + 4) % 7) < 0) 
    15331676    v_tm_wday += 7; 
    1534    
    1535   m = (long) v_tm_tday; 
    1536    
    1537   if ( m >= 0 ) 
    1538     { 
    1539       result->tm_year = 70; 
     1677 
     1678  m = (long)v_tm_tday; 
     1679 
     1680  if (m >= 0) 
     1681  { 
     1682    result->tm_year = 70; 
     1683    leap            = TM_LEAP_CHECK (result->tm_year); 
     1684 
     1685    while (m >= (long)tm_days[leap + 2][12]) 
     1686    { 
     1687      m -= (long)tm_days[leap + 2][12]; 
     1688      result->tm_year++; 
    15401689      leap = TM_LEAP_CHECK (result->tm_year); 
    1541        
    1542       while ( m >= (long) tm_days[leap + 2][12] ) 
    1543         { 
    1544           m -= (long) tm_days[leap + 2][12]; 
    1545           result->tm_year++; 
    1546           leap = TM_LEAP_CHECK (result->tm_year); 
    1547         } 
    1548        
    1549       v_tm_mon = 0; 
    1550        
    1551       while ( m >= (long) tm_days[leap][v_tm_mon] ) 
    1552         { 
    1553           m -= (long) tm_days[leap][v_tm_mon]; 
    1554           v_tm_mon++; 
    1555         } 
    1556     } 
     1690    } 
     1691 
     1692    v_tm_mon = 0; 
     1693 
     1694    while (m >= (long)tm_days[leap][v_tm_mon]) 
     1695    { 
     1696      m -= (long)tm_days[leap][v_tm_mon]; 
     1697      v_tm_mon++; 
     1698    } 
     1699  } 
    15571700  else 
    1558     { 
    1559       result->tm_year = 69; 
     1701  { 
     1702    result->tm_year = 69; 
     1703    leap            = TM_LEAP_CHECK (result->tm_year); 
     1704 
     1705    while (m < (long)-tm_days[leap + 2][12]) 
     1706    { 
     1707      m += (long)tm_days[leap + 2][12]; 
     1708      result->tm_year--; 
    15601709      leap = TM_LEAP_CHECK (result->tm_year); 
    1561        
    1562       while ( m < (long) -tm_days[leap + 2][12] ) 
    1563         { 
    1564           m += (long) tm_days[leap + 2][12]; 
    1565           result->tm_year--; 
    1566           leap = TM_LEAP_CHECK (result->tm_year); 
    1567         } 
    1568        
    1569       v_tm_mon = 11; 
    1570        
    1571       while ( m < (long) -tm_days[leap][v_tm_mon] ) 
    1572         { 
    1573           m += (long) tm_days[leap][v_tm_mon]; 
    1574           v_tm_mon--; 
    1575         } 
    1576        
    1577       m += (long) tm_days[leap][v_tm_mon]; 
    1578     } 
    1579    
    1580   result->tm_mday = (int) m + 1; 
     1710    } 
     1711 
     1712    v_tm_mon = 11; 
     1713 
     1714    while (m < (long)-tm_days[leap][v_tm_mon]) 
     1715    { 
     1716      m += (long)tm_days[leap][v_tm_mon]; 
     1717      v_tm_mon--; 
     1718    } 
     1719 
     1720    m += (long)tm_days[leap][v_tm_mon]; 
     1721  } 
     1722 
     1723  result->tm_mday = (int)m + 1; 
    15811724  result->tm_yday = tm_days[leap + 2][v_tm_mon] + m; 
    1582   result->tm_sec = v_tm_sec; 
    1583   result->tm_min = v_tm_min; 
     1725  result->tm_sec  = v_tm_sec; 
     1726  result->tm_min  = v_tm_min; 
    15841727  result->tm_hour = v_tm_hour; 
    1585   result->tm_mon = v_tm_mon; 
     1728  result->tm_mon  = v_tm_mon; 
    15861729  result->tm_wday = v_tm_wday; 
    1587    
     1730 
    15881731  return result; 
    1589 }  /* End of ms_gmtime_r() */ 
     1732} /* End of ms_gmtime_r() */ 
  • trunk/src/libsrc/util/libmseed/gswap.c

    r6260 r6836  
    2727 
    2828void 
    29 ms_gswap2 ( void *data2 ) 
     29ms_gswap2 (void *data2) 
    3030{ 
    3131  uint8_t temp; 
    32    
    33   union 
    34   { 
    35     uint8_t  c[2]; 
     32 
     33  union { 
     34    uint8_t c[2]; 
    3635  } dat; 
    37    
    38   memcpy( &dat, data2, 2 ); 
     36 
     37  memcpy (&dat, data2, 2); 
    3938  temp     = dat.c[0]; 
    4039  dat.c[0] = dat.c[1]; 
    4140  dat.c[1] = temp; 
    42   memcpy( data2, &dat, 2 ); 
     41  memcpy (data2, &dat, 2); 
    4342} 
    4443 
    45  
    4644void 
    47 ms_gswap3 ( void *data3 ) 
     45ms_gswap3 (void *data3) 
    4846{ 
    4947  uint8_t temp; 
    50    
    51   union 
    52   { 
    53     uint8_t  c[3]; 
     48 
     49  union { 
     50    uint8_t c[3]; 
    5451  } dat; 
    55    
    56   memcpy( &dat, data3, 3 ); 
     52 
     53  memcpy (&dat, data3, 3); 
    5754  temp     = dat.c[0]; 
    5855  dat.c[0] = dat.c[2]; 
    5956  dat.c[2] = temp; 
    60   memcpy( data3, &dat, 3 ); 
     57  memcpy (data3, &dat, 3); 
    6158} 
    6259 
    63  
    6460void 
    65 ms_gswap4 ( void *data4 ) 
     61ms_gswap4 (void *data4) 
    6662{ 
    6763  uint8_t temp; 
     
    7066    uint8_t c[4]; 
    7167  } dat; 
    72    
    73   memcpy( &dat, data4, 4 ); 
     68 
     69  memcpy (&dat, data4, 4); 
    7470  temp     = dat.c[0]; 
    7571  dat.c[0] = dat.c[3]; 
     
    7874  dat.c[1] = dat.c[2]; 
    7975  dat.c[2] = temp; 
    80   memcpy( data4, &dat, 4 ); 
     76  memcpy (data4, &dat, 4); 
    8177} 
    8278 
    83  
    8479void 
    85 ms_gswap8 ( void *data8 ) 
     80ms_gswap8 (void *data8) 
    8681{ 
    8782  uint8_t temp; 
    88    
    89   union 
    90   { 
    91     uint8_t   c[8]; 
     83 
     84  union { 
     85    uint8_t c[8]; 
    9286  } dat; 
    93    
    94   memcpy( &dat, data8, 8 ); 
     87 
     88  memcpy (&dat, data8, 8); 
    9589  temp     = dat.c[0]; 
    9690  dat.c[0] = dat.c[7]; 
    9791  dat.c[7] = temp; 
    98    
     92 
    9993  temp     = dat.c[1]; 
    10094  dat.c[1] = dat.c[6]; 
    10195  dat.c[6] = temp; 
    102    
     96 
    10397  temp     = dat.c[2]; 
    10498  dat.c[2] = dat.c[5]; 
    10599  dat.c[5] = temp; 
    106    
     100 
    107101  temp     = dat.c[3]; 
    108102  dat.c[3] = dat.c[4]; 
    109103  dat.c[4] = temp; 
    110   memcpy( data8, &dat, 8 ); 
     104  memcpy (data8, &dat, 8); 
    111105} 
    112106 
     
    114108 
    115109void 
    116 ms_gswap2a ( void *data2 ) 
     110ms_gswap2a (void *data2) 
    117111{ 
    118112  uint16_t *data = data2; 
    119    
    120   *data=(((*data>>8)&0xff) | ((*data&0xff)<<8)); 
     113 
     114  *data = (((*data >> 8) & 0xff) | ((*data & 0xff) << 8)); 
    121115} 
    122116 
     117void 
     118ms_gswap4a (void *data4) 
     119{ 
     120  uint32_t *data = data4; 
     121 
     122  *data = (((*data >> 24) & 0xff) | ((*data & 0xff) << 24) | 
     123           ((*data >> 8) & 0xff00) | ((*data & 0xff00) << 8)); 
     124} 
    123125 
    124126void 
    125 ms_gswap4a ( void *data4 ) 
    126 { 
    127   uint32_t *data = data4; 
    128    
    129   *data=(((*data>>24)&0xff) | ((*data&0xff)<<24) | 
    130          ((*data>>8)&0xff00) | ((*data&0xff00)<<8)); 
    131 } 
    132  
    133  
    134 void 
    135 ms_gswap8a ( void *data8 ) 
     127ms_gswap8a (void *data8) 
    136128{ 
    137129  uint32_t *data4 = data8; 
    138130  uint32_t h0, h1; 
    139    
     131 
    140132  h0 = data4[0]; 
    141   h0 = (((h0>>24)&0xff) | ((h0&0xff)<<24) | 
    142         ((h0>>8)&0xff00) | ((h0&0xff00)<<8)); 
    143    
     133  h0 = (((h0 >> 24) & 0xff) | ((h0 & 0xff) << 24) | 
     134        ((h0 >> 8) & 0xff00) | ((h0 & 0xff00) << 8)); 
     135 
    144136  h1 = data4[1]; 
    145   h1 = (((h1>>24)&0xff) | ((h1&0xff)<<24) | 
    146         ((h1>>8)&0xff00) | ((h1&0xff00)<<8)); 
    147    
     137  h1 = (((h1 >> 24) & 0xff) | ((h1 & 0xff) << 24) | 
     138        ((h1 >> 8) & 0xff00) | ((h1 & 0xff00) << 8)); 
     139 
    148140  data4[0] = h1; 
    149141  data4[1] = h0; 
  • trunk/src/libsrc/util/libmseed/libmseed.def

    r6242 r6836  
    103103   ms_gswap4a 
    104104   ms_gswap8a 
    105    msr_unpack_steim2 
    106    msr_unpack_steim1 
  • trunk/src/libsrc/util/libmseed/libmseed.h

    r6803 r6836  
    55 * Interface declarations for the Mini-SEED library (libmseed). 
    66 * 
    7  * This library is free software; you can redistribute it and/or 
    8  * modify it under the terms of the GNU Library General Public License 
    9  * as published by the Free Software Foundation; either version 2 of 
    10  * the License, or (at your option) any later version. 
     7 * This library is free software; you can redistribute it and/or modify 
     8 * it under the terms of the GNU Lesser General Public License as 
     9 * published by the Free Software Foundation; either version 3 of the 
     10 * License, or (at your option) any later version. 
    1111 * 
    1212 * This library is distributed in the hope that it will be useful, but 
    1313 * WITHOUT ANY WARRANTY; without even the implied warranty of 
    1414 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
    15  * Library General Public License (GNU-LGPL) for more details.  The 
    16  * GNU-LGPL and further information can be found here: 
    17  * http://www.gnu.org/ 
     15 * Lesser General Public License (GNU-LGPL) for more details. 
    1816 * 
    19  * Written by Chad Trabant 
     17 * You should have received a copy of the GNU Lesser General Public 
     18 * License along with this software. 
     19 * If not, see <https://www.gnu.org/licenses/>. 
     20 * 
     21 * Copyright (C) 2016 Chad Trabant 
    2022 * IRIS Data Management Center 
    2123 ***************************************************************************/ 
     
    3133#include "lmplatform.h" 
    3234 
    33 #define LIBMSEED_VERSION "2.17" 
    34 #define LIBMSEED_RELEASE "2015.213" 
     35#define LIBMSEED_VERSION "2.18" 
     36#define LIBMSEED_RELEASE "2016.286" 
    3537 
    3638#define MINRECLEN   128      /* Minimum Mini-SEED record length, 2^7 bytes */ 
     
    672674extern int      ms_bigendianhost (void); 
    673675extern double   ms_dabs (double val); 
     676extern double   ms_rsqrt64 (double val); 
    674677 
    675678 
  • trunk/src/libsrc/util/libmseed/lmplatform.c

    r6803 r6836  
    11/*************************************************************************** 
    22 * lmplatform.c: 
    3  *  
     3 * 
    44 * Platform portability routines. 
    5  * 
    6  * This library is free software; you can redistribute it and/or 
    7  * modify it under the terms of the GNU Library General Public License 
    8  * as published by the Free Software Foundation; either version 2 of 
    9  * the License, or (at your option) any later version. 
    10  * 
    11  * This library is distributed in the hope that it will be useful, but 
    12  * WITHOUT ANY WARRANTY; without even the implied warranty of 
    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
    14  * Library General Public License (GNU-LGPL) for more details.  The 
    15  * GNU-LGPL and further information can be found here: 
    16  * http://www.gnu.org/ 
    17  * 
    18  * Written by Chad Trabant, IRIS Data Management Center 
    195 * 
    206 * modified: 2010.304 
     
    2511 
    2612#include "lmplatform.h" 
    27  
    2813 
    2914/*************************************************************************** 
     
    3722{ 
    3823#if defined(LMP_WIN) 
    39   return (off_t) ftell (stream); 
     24  return (off_t)ftell (stream); 
    4025 
    4126#else 
    42   return (off_t) ftello (stream); 
     27  return (off_t)ftello (stream); 
    4328 
    4429#endif 
    45 }  /* End of lmp_ftello() */ 
    46  
     30} /* End of lmp_ftello() */ 
    4731 
    4832/*************************************************************************** 
     
    5640{ 
    5741#if defined(LMP_WIN) 
    58   return (int) fseek (stream, (long int) offset, whence); 
    59    
     42  return (int)fseek (stream, (long int)offset, whence); 
     43 
    6044#else 
    61   return (int) fseeko (stream, offset, whence); 
    62    
     45  return (int)fseeko (stream, offset, whence); 
     46 
    6347#endif 
    64 }  /* End of lmp_fseeko() */ 
    65  
     48} /* End of lmp_fseeko() */ 
  • trunk/src/libsrc/util/libmseed/lmplatform.h

    r6803 r6836  
    11/*************************************************************************** 
    22 * lmplatform.h: 
    3  *  
     3 * 
    44 * Platform specific headers.  This file provides a basic level of platform 
    55 * portability. 
    66 * 
    7  * This library is free software; you can redistribute it and/or 
    8  * modify it under the terms of the GNU Library General Public License 
    9  * as published by the Free Software Foundation; either version 2 of 
    10  * the License, or (at your option) any later version. 
    11  * 
    12  * This library is distributed in the hope that it will be useful, but 
    13  * WITHOUT ANY WARRANTY; without even the implied warranty of 
    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
    15  * Library General Public License (GNU-LGPL) for more details.  The 
    16  * GNU-LGPL and further information can be found here: 
    17  * http://www.gnu.org/ 
    18  * 
    19  * Written by Chad Trabant, IRIS Data Management Center 
    20  * 
    21  * modified: 2015.134 
     7 * modified: 2016.275 
    228 ***************************************************************************/ 
    239 
     
    8066  #include <sys/types.h> 
    8167 
    82   /* For pre-MSVC 2010 define standard int types, otherwise use inttypes.h */ 
    83   #if defined(_MSC_VER) && _MSC_VER < 1600 
     68  /* For MSVC 2012 and earlier define standard int types, otherwise use inttypes.h */ 
     69  #if defined(_MSC_VER) && _MSC_VER <= 1700 
    8470    typedef signed char int8_t; 
    8571    typedef unsigned char uint8_t; 
     
    11298 
    11399  #if defined(__MINGW32__) || defined(__MINGW64__) 
     100    #include <fcntl.h> 
     101 
    114102    #define fstat _fstat 
    115103    #define stat _stat 
     
    124112} 
    125113#endif 
    126   
     114 
    127115#endif /* LMPLATFORM_H */ 
  • trunk/src/libsrc/util/libmseed/logging.c

    r6242 r6836  
    1010 ***************************************************************************/ 
    1111 
     12#include <stdarg.h> 
    1213#include <stdio.h> 
    1314#include <stdlib.h> 
    14 #include <stdarg.h> 
    1515#include <string.h> 
    1616 
     
    1818 
    1919void ms_loginit_main (MSLogParam *logp, 
    20                       void (*log_print)(char*), const char *logprefix, 
    21                       void (*diag_print)(char*), const char *errprefix); 
     20                      void (*log_print) (char *), const char *logprefix, 
     21                      void (*diag_print) (char *), const char *errprefix); 
    2222 
    2323int ms_log_main (MSLogParam *logp, int level, va_list *varlist); 
     
    2626MSLogParam gMSLogParam = {NULL, NULL, NULL, NULL}; 
    2727 
    28  
    2928/*************************************************************************** 
    3029 * ms_loginit: 
     
    3534 ***************************************************************************/ 
    3635void 
    37 ms_loginit (void (*log_print)(char*), const char *logprefix, 
    38             void (*diag_print)(char*), const char *errprefix) 
    39 { 
    40   ms_loginit_main(&gMSLogParam, log_print, logprefix, diag_print, errprefix); 
    41 }  /* End of ms_loginit() */ 
    42  
     36ms_loginit (void (*log_print) (char *), const char *logprefix, 
     37            void (*diag_print) (char *), const char *errprefix) 
     38{ 
     39  ms_loginit_main (&gMSLogParam, log_print, logprefix, diag_print, errprefix); 
     40} /* End of ms_loginit() */ 
    4341 
    4442/*************************************************************************** 
     
    5654MSLogParam * 
    5755ms_loginit_l (MSLogParam *logp, 
    58               void (*log_print)(char*), const char *logprefix, 
    59               void (*diag_print)(char*), const char *errprefix) 
     56              void (*log_print) (char *), const char *logprefix, 
     57              void (*diag_print) (char *), const char *errprefix) 
    6058{ 
    6159  MSLogParam *llog; 
    62    
    63   if ( logp == NULL ) 
    64     { 
    65       llog = (MSLogParam *) malloc (sizeof(MSLogParam)); 
    66        
    67       if ( llog == NULL ) 
    68         { 
    69           ms_log (2, "ms_loginit_l(): Cannot allocate memory\n"); 
    70           return NULL; 
    71         } 
    72        
    73       llog->log_print = NULL; 
    74       llog->logprefix = NULL; 
    75       llog->diag_print = NULL; 
    76       llog->errprefix = NULL; 
    77     } 
     60 
     61  if (logp == NULL) 
     62  { 
     63    llog = (MSLogParam *)malloc (sizeof (MSLogParam)); 
     64 
     65    if (llog == NULL) 
     66    { 
     67      ms_log (2, "ms_loginit_l(): Cannot allocate memory\n"); 
     68      return NULL; 
     69    } 
     70 
     71    llog->log_print = NULL; 
     72    llog->logprefix = NULL; 
     73    llog->diag_print = NULL; 
     74    llog->errprefix = NULL; 
     75  } 
    7876  else 
    79     { 
    80       llog = logp; 
    81     } 
    82    
     77  { 
     78    llog = logp; 
     79  } 
     80 
    8381  ms_loginit_main (llog, log_print, logprefix, diag_print, errprefix); 
    8482 
    8583  return llog; 
    86 }  /* End of ms_loginit_l() */ 
    87  
     84} /* End of ms_loginit_l() */ 
    8885 
    8986/*************************************************************************** 
     
    111108void 
    112109ms_loginit_main (MSLogParam *logp, 
    113                  void (*log_print)(char*), const char *logprefix, 
    114                  void (*diag_print)(char*), const char *errprefix) 
    115 { 
    116   if ( ! logp ) 
     110                 void (*log_print) (char *), const char *logprefix, 
     111                 void (*diag_print) (char *), const char *errprefix) 
     112{ 
     113  if (!logp) 
    117114    return; 
    118115 
    119   if ( log_print ) 
     116  if (log_print) 
    120117    logp->log_print = log_print; 
    121    
    122   if ( logprefix ) 
    123     { 
    124       if ( strlen(logprefix) >= MAX_LOG_MSG_LENGTH ) 
    125         { 
    126           ms_log_l (logp, 2, 0, "log message prefix is too large\n"); 
    127         } 
    128       else 
    129         { 
    130           logp->logprefix = logprefix; 
    131         } 
    132     } 
    133    
    134   if ( diag_print ) 
     118 
     119  if (logprefix) 
     120  { 
     121    if (strlen (logprefix) >= MAX_LOG_MSG_LENGTH) 
     122    { 
     123      ms_log_l (logp, 2, 0, "log message prefix is too large\n"); 
     124    } 
     125    else 
     126    { 
     127      logp->logprefix = logprefix; 
     128    } 
     129  } 
     130 
     131  if (diag_print) 
    135132    logp->diag_print = diag_print; 
    136    
    137   if ( errprefix ) 
    138     { 
    139       if ( strlen(errprefix) >= MAX_LOG_MSG_LENGTH ) 
    140         { 
    141           ms_log_l (logp, 2, 0, "error message prefix is too large\n"); 
    142         } 
    143       else 
    144         { 
    145           logp->errprefix = errprefix; 
    146         } 
    147     } 
    148    
     133 
     134  if (errprefix) 
     135  { 
     136    if (strlen (errprefix) >= MAX_LOG_MSG_LENGTH) 
     137    { 
     138      ms_log_l (logp, 2, 0, "error message prefix is too large\n"); 
     139    } 
     140    else 
     141    { 
     142      logp->errprefix = errprefix; 
     143    } 
     144  } 
     145 
    149146  return; 
    150 }  /* End of ms_loginit_main() */ 
    151  
     147} /* End of ms_loginit_main() */ 
    152148 
    153149/*************************************************************************** 
     
    163159  int retval; 
    164160  va_list varlist; 
    165    
     161 
    166162  va_start (varlist, level); 
    167163 
     
    171167 
    172168  return retval; 
    173 }  /* End of ms_log() */ 
    174  
     169} /* End of ms_log() */ 
    175170 
    176171/*************************************************************************** 
     
    190185  MSLogParam *llog; 
    191186 
    192   if ( ! logp ) 
     187  if (!logp) 
    193188    llog = &gMSLogParam; 
    194189  else 
    195190    llog = logp; 
    196    
     191 
    197192  va_start (varlist, level); 
    198    
     193 
    199194  retval = ms_log_main (llog, level, &varlist); 
    200195 
     
    202197 
    203198  return retval; 
    204 }  /* End of ms_log_l() */ 
    205  
     199} /* End of ms_log_l() */ 
    206200 
    207201/*************************************************************************** 
     
    212206 * The function uses logging parameters specified in the supplied 
    213207 * MSLogParam. 
    214  *  
     208 * 
    215209 * This function expects 2+ arguments: message level, fprintf format, 
    216  * and fprintf arguments.  
     210 * and fprintf arguments. 
    217211 * 
    218212 * Three levels are recognized: 
     
    243237  int presize; 
    244238  const char *format; 
    245    
    246   if ( ! logp ) 
    247     { 
    248       fprintf(stderr, "ms_log_main() called without specifying log parameters"); 
    249       return -1; 
    250     } 
    251    
     239 
     240  if (!logp) 
     241  { 
     242    fprintf (stderr, "ms_log_main() called without specifying log parameters"); 
     243    return -1; 
     244  } 
     245 
    252246  message[0] = '\0'; 
    253247 
    254248  format = va_arg (*varlist, const char *); 
    255249 
    256   if ( level >= 2 )  /* Error message */ 
    257     { 
    258       if ( logp->errprefix != NULL ) 
    259         { 
    260           strncpy (message, logp->errprefix, MAX_LOG_MSG_LENGTH); 
    261           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    262         } 
    263       else 
    264         { 
    265           strncpy (message, "Error: ", MAX_LOG_MSG_LENGTH); 
    266         } 
    267        
    268       presize = strlen(message); 
    269       retvalue = vsnprintf (&message[presize], 
    270                             MAX_LOG_MSG_LENGTH - presize, 
    271                             format, *varlist); 
    272        
     250  if (level >= 2) /* Error message */ 
     251  { 
     252    if (logp->errprefix != NULL) 
     253    { 
     254      strncpy (message, logp->errprefix, MAX_LOG_MSG_LENGTH); 
    273255      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    274  
    275       if ( logp->diag_print != NULL ) 
    276         { 
    277           logp->diag_print (message); 
    278         } 
    279       else 
    280         { 
    281           fprintf(stderr, "%s", message); 
    282         } 
    283     } 
    284   else if ( level == 1 )  /* Diagnostic message */ 
    285     { 
    286       if ( logp->logprefix != NULL ) 
    287         { 
    288           strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    289           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    290         } 
    291        
    292       presize = strlen(message); 
    293       retvalue = vsnprintf (&message[presize], 
    294                             MAX_LOG_MSG_LENGTH - presize, 
    295                             format, *varlist); 
    296        
     256    } 
     257    else 
     258    { 
     259      strncpy (message, "Error: ", MAX_LOG_MSG_LENGTH); 
     260    } 
     261 
     262    presize  = strlen (message); 
     263    retvalue = vsnprintf (&message[presize], 
     264                          MAX_LOG_MSG_LENGTH - presize, 
     265                          format, *varlist); 
     266 
     267    message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     268 
     269    if (logp->diag_print != NULL) 
     270    { 
     271      logp->diag_print (message); 
     272    } 
     273    else 
     274    { 
     275      fprintf (stderr, "%s", message); 
     276    } 
     277  } 
     278  else if (level == 1) /* Diagnostic message */ 
     279  { 
     280    if (logp->logprefix != NULL) 
     281    { 
     282      strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    297283      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    298        
    299       if ( logp->diag_print != NULL ) 
    300         { 
    301           logp->diag_print (message); 
    302         } 
    303       else 
    304         { 
    305           fprintf(stderr, "%s", message); 
    306         } 
    307     } 
    308   else if ( level == 0 )  /* Normal log message */ 
    309     { 
    310       if ( logp->logprefix != NULL ) 
    311         { 
    312           strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    313           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    314         } 
    315        
    316       presize = strlen(message); 
    317       retvalue = vsnprintf (&message[presize], 
    318                             MAX_LOG_MSG_LENGTH - presize, 
    319                             format, *varlist); 
    320        
     284    } 
     285 
     286    presize  = strlen (message); 
     287    retvalue = vsnprintf (&message[presize], 
     288                          MAX_LOG_MSG_LENGTH - presize, 
     289                          format, *varlist); 
     290 
     291    message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     292 
     293    if (logp->diag_print != NULL) 
     294    { 
     295      logp->diag_print (message); 
     296    } 
     297    else 
     298    { 
     299      fprintf (stderr, "%s", message); 
     300    } 
     301  } 
     302  else if (level == 0) /* Normal log message */ 
     303  { 
     304    if (logp->logprefix != NULL) 
     305    { 
     306      strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    321307      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    322        
    323       if ( logp->log_print != NULL ) 
    324         { 
    325            logp->log_print (message); 
    326         } 
    327       else 
    328         { 
    329           fprintf(stdout, "%s", message); 
    330         } 
    331     } 
    332    
     308    } 
     309 
     310    presize  = strlen (message); 
     311    retvalue = vsnprintf (&message[presize], 
     312                          MAX_LOG_MSG_LENGTH - presize, 
     313                          format, *varlist); 
     314 
     315    message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     316 
     317    if (logp->log_print != NULL) 
     318    { 
     319      logp->log_print (message); 
     320    } 
     321    else 
     322    { 
     323      fprintf (stdout, "%s", message); 
     324    } 
     325  } 
     326 
    333327  return retvalue; 
    334 }  /* End of ms_log_main() */ 
     328} /* End of ms_log_main() */ 
  • trunk/src/libsrc/util/libmseed/lookup.c

    r3048 r6836  
    1515/*************************************************************************** 
    1616 * ms_samplesize(): 
    17  *  
     17 * 
    1818 * Returns the sample size based on type code or 0 for unknown. 
    1919 ***************************************************************************/ 
     
    2222{ 
    2323  switch (sampletype) 
    24     { 
    25     case 'a': 
    26       return 1; 
    27     case 'i': 
    28     case 'f': 
    29       return 4; 
    30     case 'd': 
    31       return 8; 
    32     default: 
    33       return 0; 
    34     }  /* end switch */ 
    35    
    36 }  /* End of ms_samplesize() */ 
    37  
     24  { 
     25  case 'a': 
     26    return 1; 
     27  case 'i': 
     28  case 'f': 
     29    return 4; 
     30  case 'd': 
     31    return 8; 
     32  default: 
     33    return 0; 
     34  } /* end switch */ 
     35 
     36} /* End of ms_samplesize() */ 
    3837 
    3938/*************************************************************************** 
    4039 * ms_encodingstr(): 
    41  *  
     40 * 
    4241 * Returns a string describing a data encoding format. 
    4342 ***************************************************************************/ 
     
    4645{ 
    4746  switch (encoding) 
    48     { 
    49     case 0: 
    50       return "ASCII text"; 
    51     case 1: 
    52       return "16 bit integers"; 
    53     case 2: 
    54       return "24 bit integers"; 
    55     case 3: 
    56       return "32 bit integers"; 
    57     case 4: 
    58       return "IEEE floating point"; 
    59     case 5: 
    60       return "IEEE double precision float"; 
    61     case 10: 
    62       return "STEIM 1 Compression"; 
    63     case 11: 
    64       return "STEIM 2 Compression"; 
    65     case 12: 
    66       return "GEOSCOPE Muxed 24 bit int"; 
    67     case 13: 
    68       return "GEOSCOPE Muxed 16/3 bit gain/exp"; 
    69     case 14: 
    70       return "GEOSCOPE Muxed 16/4 bit gain/exp"; 
    71     case 15: 
    72       return "US National Network compression"; 
    73     case 16: 
    74       return "CDSN 16 bit gain ranged"; 
    75     case 17: 
    76       return "Graefenberg 16 bit gain ranged"; 
    77     case 18: 
    78       return "IPG - Strasbourg 16 bit gain"; 
    79     case 19: 
    80       return "STEIM 3 Compression"; 
    81     case 30: 
    82       return "SRO Gain Ranged Format"; 
    83     case 31: 
    84       return "HGLP Format"; 
    85     case 32: 
    86       return "DWWSSN Format"; 
    87     case 33: 
    88       return "RSTN 16 bit gain ranged"; 
    89     default: 
    90       return "Unknown format code"; 
    91     }  /* end switch */ 
    92  
    93 }  /* End of ms_encodingstr() */ 
    94  
     47  { 
     48  case 0: 
     49    return "ASCII text"; 
     50  case 1: 
     51    return "16 bit integers"; 
     52  case 2: 
     53    return "24 bit integers"; 
     54  case 3: 
     55    return "32 bit integers"; 
     56  case 4: 
     57    return "IEEE floating point"; 
     58  case 5: 
     59    return "IEEE double precision float"; 
     60  case 10: 
     61    return "STEIM 1 Compression"; 
     62  case 11: 
     63    return "STEIM 2 Compression"; 
     64  case 12: 
     65    return "GEOSCOPE Muxed 24 bit int"; 
     66  case 13: 
     67    return "GEOSCOPE Muxed 16/3 bit gain/exp"; 
     68  case 14: 
     69    return "GEOSCOPE Muxed 16/4 bit gain/exp"; 
     70  case 15: 
     71    return "US National Network compression"; 
     72  case 16: 
     73    return "CDSN 16 bit gain ranged"; 
     74  case 17: 
     75    return "Graefenberg 16 bit gain ranged"; 
     76  case 18: 
     77    return "IPG - Strasbourg 16 bit gain"; 
     78  case 19: 
     79    return "STEIM 3 Compression"; 
     80  case 30: 
     81    return "SRO Gain Ranged Format"; 
     82  case 31: 
     83    return "HGLP Format"; 
     84  case 32: 
     85    return "DWWSSN Format"; 
     86  case 33: 
     87    return "RSTN 16 bit gain ranged"; 
     88  default: 
     89    return "Unknown format code"; 
     90  } /* end switch */ 
     91 
     92} /* End of ms_encodingstr() */ 
    9593 
    9694/*************************************************************************** 
     
    104102{ 
    105103  switch (blkttype) 
    106     { 
    107     case 100: 
    108       return "Sample Rate"; 
    109     case 200: 
    110       return "Generic Event Detection"; 
    111     case 201: 
    112       return "Murdock Event Detection"; 
    113     case 300: 
    114       return "Step Calibration"; 
    115     case 310: 
    116       return "Sine Calibration"; 
    117     case 320: 
    118       return "Pseudo-random Calibration"; 
    119     case 390: 
    120       return "Generic Calibration"; 
    121     case 395: 
    122       return "Calibration Abort"; 
    123     case 400: 
    124       return "Beam"; 
    125     case 500: 
    126       return "Timing"; 
    127     case 1000: 
    128       return "Data Only SEED"; 
    129     case 1001: 
    130       return "Data Extension"; 
    131     case 2000: 
    132       return "Opaque Data"; 
    133     } /* end switch */ 
     104  { 
     105  case 100: 
     106    return "Sample Rate"; 
     107  case 200: 
     108    return "Generic Event Detection"; 
     109  case 201: 
     110    return "Murdock Event Detection"; 
     111  case 300: 
     112    return "Step Calibration"; 
     113  case 310: 
     114    return "Sine Calibration"; 
     115  case 320: 
     116    return "Pseudo-random Calibration"; 
     117  case 390: 
     118    return "Generic Calibration"; 
     119  case 395: 
     120    return "Calibration Abort"; 
     121  case 400: 
     122    return "Beam"; 
     123  case 500: 
     124    return "Timing"; 
     125  case 1000: 
     126    return "Data Only SEED"; 
     127  case 1001: 
     128    return "Data Extension"; 
     129  case 2000: 
     130    return "Opaque Data"; 
     131  } /* end switch */ 
    134132 
    135133  return NULL; 
    136    
    137 }  /* End of ms_blktdesc() */ 
    138  
     134 
     135} /* End of ms_blktdesc() */ 
    139136 
    140137/*************************************************************************** 
     
    148145{ 
    149146  uint16_t blktlen = 0; 
    150    
     147 
    151148  switch (blkttype) 
     149  { 
     150  case 100: /* Sample Rate */ 
     151    blktlen = 12; 
     152    break; 
     153  case 200: /* Generic Event Detection */ 
     154    blktlen = 28; 
     155    break; 
     156  case 201: /* Murdock Event Detection */ 
     157    blktlen = 36; 
     158    break; 
     159  case 300: /* Step Calibration */ 
     160    blktlen = 32; 
     161    break; 
     162  case 310: /* Sine Calibration */ 
     163    blktlen = 32; 
     164    break; 
     165  case 320: /* Pseudo-random Calibration */ 
     166    blktlen = 28; 
     167    break; 
     168  case 390: /* Generic Calibration */ 
     169    blktlen = 28; 
     170    break; 
     171  case 395: /* Calibration Abort */ 
     172    blktlen = 16; 
     173    break; 
     174  case 400: /* Beam */ 
     175    blktlen = 16; 
     176    break; 
     177  case 500: /* Timing */ 
     178    blktlen = 8; 
     179    break; 
     180  case 1000: /* Data Only SEED */ 
     181    blktlen = 8; 
     182    break; 
     183  case 1001: /* Data Extension */ 
     184    blktlen = 8; 
     185    break; 
     186  case 2000: /* Opaque Data */ 
     187    /* First 2-byte field after the blockette header is the length */ 
     188    if (blkt) 
    152189    { 
    153     case 100:  /* Sample Rate */ 
    154       blktlen = 12;