Changeset 6839


Ignore:
Timestamp:
10/17/16 11:42:43 (3 years ago)
Author:
kevin
Message:

Updated with version 2.6

Location:
trunk/src/data_exchange/slink2ew/libslink
Files:
3 deleted
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/data_exchange/slink2ew/libslink/ChangeLog

    r6017 r6839  
     12016.288: 
     2        - Replace data sample unpacking routines from qlib2 with new routines 
     3        developed from scratch in libmseed.  All code is now LGPL licensed. 
     4        - Add sl_msr_srcname() function to generate "Net_Sta_Loc_Chan[_Qual]". 
     5        - Switch to simpler SOCKET type defined as needed by platform includes 
     6        or as int when not set. 
     7        - Clarify licensing to be LGPLv3. 
     8        - Cleanup Makefile (remove unused targets) and README, add INSTALL. 
     9 
     102016.287: version 2.5 
     11        - Support data sample unpacking with byte order specified in Blockette 1000, 
     12        specifically allows little endian decoding.  Thanks to patch by Yen Soon. 
     13        - Port socket usage to portable SLP_SOCKET type, either int or SOCKET. 
     14        - Change default use of lastpkttime to true (1) in sl_newslcd(). 
     15        - Quiet some MSVC warnings with a define suggested by Kevin Frechette. 
     16 
    1172013.305: version 2.4b 
    218        - sl_read_streamlist(): Allow '!' character in selectors field, this 
  • trunk/src/data_exchange/slink2ew/libslink/INSTALL

    r1793 r6839  
    11 
    2 Installation instructions for libslink: the SeedLink client library. 
     2The library requires that C99 integer types are available on the 
     3target computer.  Specifically the int8_t, int16_t, int32_t, int64_t 
     4and their unsigned counterpart types.  If these data types are not 
     5available guesses are made in lmplatform.h. 
    36 
    4 -- Building -- 
     7-- Unix -- 
    58 
    6 Unix/Linux: The easiest way to compile the library is to simply run 
    7 'make'.  The included Makefile should work for most Unix-like 
    8 environments with GNU's gcc.  The Makefile will need to be edited to 
    9 use a different compiler (e.g. the Sun compiler), instructions are 
    10 included in the Makefile.  By default a statically linked version of 
    11 the library is built 'libslink.a'.  Using gcc it is possible to build 
    12 a shared library with 'make shared'. 
     9A simple 'make' on most Unix-like systems should build the library. 
    1310 
    14 Windows: On a WIN32 platform the library can be compiled by using the 
     11The included Makefile should work for most Unix-like environments and 
     12most make variants; it is know to work with GNU make. 
     13 
     14The CC and CFLAGS environment variables can be set to control the build. 
     15 
     16By default a statically linked version of the library is built: 'libslink.a'. 
     17 
     18With GCC, clang or compatible build tools it is possible to build a shared 
     19library with 'make shared'. 
     20 
     21-- macOS -- 
     22 
     23A static library can be compiled using the above Unix instructions, 
     24just run 'make'. 
     25 
     26Using GCC, clang or compatible build tools it is possible to build a dynamic 
     27library with 'make dynamic'. 
     28 
     29-- Windows (Win32) -- 
     30 
     31On a WIN32 platform the library can be compiled by using the 
    1532Nmake compatible Makefile.win (e.g. 'nmake -f Makefile.win') or Open 
    1633Watcom's Wmake with Makefile.wat (e.g. 'wmake -f Makefile.wat'). The 
    1734default target is a static library 'libslink.lib'.  The library has 
    18 been tested with Microsoft Visual Studio 6 and Open Watcom 1.1. 
    19  
    20 For non-WIN32 platforms the POSIX nanosleep() function is used.  This 
    21 function may not be implemented on older Solaris or Linux platforms. 
    22 It is known to be available under Solaris 8 or later and recent 
    23 versions of Glibc2. 
    24  
    25 -- Installing -- 
    26  
    27 For installation into the system development environment simply copy 
    28 the library (libslink.a and/or libslink.so) into a system library 
    29 directory and copy the associated libslink.h into a system include 
    30 directory.  Otherwise the library and include file can be used 
    31 directly from the build directory. 
    32  
    33 The 'example' directory includes an example SeedLink client that uses 
    34 libslink. 
    35  
    36 The 'doc' directory includes all associated documentation including 
    37 a Users Guide and man pages for library functions. 
    38  
    39 -- Threading -- 
    40  
    41 The library is thread-safe under Unix-like environments with the 
    42 condition that each connection descriptor (SLCD) is handled by a 
    43 single thread.  Thread independent logging schemes are possible. 
    44 Under WIN32 the library is not thread-safe. 
    45  
    46 -- Pronounciation -- 
    47  
    48 lib = 'l' + [eye] + 'b'  (as in library, long 'i') 
    49 s = [es]   (like the beginning of 'esta' in como esta?) 
    50 link = link   (rhymes with the color pink) 
    51  
    52 all together: 'l' [eye] 'b' [es] link 
     35been tested with Open Watcom 1.8. 
  • trunk/src/data_exchange/slink2ew/libslink/Makefile

    r6819 r6839  
    77CFLAGS = $(GLOBALFLAGS) 
    88 
    9 # GCC specific parameters 
    10 GCC = gcc 
    11 GCCFLAGS = -O2 -Wall 
     9MAJOR_VER = 2 
     10MINOR_VER = 6 
     11CURRENT_VER = $(MAJOR_VER).$(MINOR_VER) 
     12COMPAT_VER = $(MAJOR_VER).$(MINOR_VER) 
    1213 
    13 LIB_OBJS = gswap.o unpack.o msrecord.o genutils.o strutils.o \ 
    14            logging.o network.o statefile.o config.o \ 
    15            globmatch.o slplatform.o slutils.o 
     14LIB_SRCS = gswap.c unpack.c msrecord.c genutils.c strutils.c \ 
     15           logging.c network.c statefile.c config.c \ 
     16           globmatch.c slplatform.c slutils.c 
    1617 
    17 CURRENT_VER = 2.4 
    18 COMPAT_VER = 2.0 
     18LIB_OBJS = $(LIB_SRCS:.c=.o) 
     19LIB_DOBJS = $(LIB_SRCS:.c=.lo) 
    1920 
    2021LIB_A = libslink.a 
    21 LIB_SO = libslink.so.$(CURRENT_VER) 
    22 LIB_SO_ALIAS = libslink.so 
     22LIB_SO_FILENAME = libslink.so 
     23LIB_SO_ALIAS = $(LIB_SO_FILENAME).$(MAJOR_VER) 
     24LIB_SO = $(LIB_SO_FILENAME).$(CURRENT_VER) 
     25LIB_DYN_ALIAS = libslink.dylib 
    2326LIB_DYN = libslink.$(CURRENT_VER).dylib 
    24 LIB_DYN_ALIAS = libslink.dylib 
    2527 
    2628all: static 
     
    3234dynamic: $(LIB_DYN) 
    3335 
     36# Build static library 
    3437$(LIB_A): $(LIB_OBJS) 
    35         ar -rcs $(LIB_A) $(LIB_OBJS) 
     38        rm -f $(LIB_A) 
     39        ar -crs $(LIB_A) $(LIB_OBJS) 
    3640 
    37 $(LIB_SO): $(LIB_OBJS) 
    38         $(CC) -shared -Wl,-soname -Wl,$(LIB_SO_ALIAS) -o $(LIB_SO) $(LIB_OBJS) 
     41# Build shared library using GCC-style options 
     42$(LIB_SO): $(LIB_DOBJS) 
     43        rm -f $(LIB_SO) $(LIB_SO_ALIAS) $(LIB_SO_FILENAME) 
     44        $(CC) $(CFLAGS) -shared -Wl,-soname -Wl,$(LIB_SO_ALIAS) -o $(LIB_SO) $(LIB_DOBJS) 
    3945        ln -s $(LIB_SO) $(LIB_SO_ALIAS) 
     46        ln -s $(LIB_SO) $(LIB_SO_FILENAME) 
    4047 
    41 $(LIB_DYN): $(LIB_OBJS) 
    42         $(CC) -dynamiclib -compatibility_version $(COMPAT_VER) -current_version $(CURRENT_VER) -install_name $(LIB_DYN_ALIAS) -o $(LIB_DYN) $(LIB_OBJS) 
    43         ln -s $(LIB_DYN) $(LIB_DYN_ALIAS) 
    44  
    45 cc: 
    46         @$(MAKE) "CC=$(CC)" "CFLAGS=$(CFLAGS)" 
    47  
    48 gcc: 
    49         @$(MAKE) "CC=$(GCC)" "CFLAGS=$(GCCFLAGS)" 
    50  
    51 debug: 
    52         $(MAKE) "CC=$(CC)" "CFLAGS=-g $(CFLAGS)" 
    53  
    54 gccdebug: 
    55         $(MAKE) "CC=$(GCC)" "CFLAGS=-g $(GCCFLAGS)" 
     48# Build dynamic library (usually for Mac OSX) 
     49$(LIB_DYN): $(LIB_DOBJS) 
     50        rm -f $(LIB_DYN) $(LIB_DYN_ALIAS) 
     51        $(CC) $(CFLAGS) -dynamiclib -compatibility_version $(COMPAT_VER) -current_version $(CURRENT_VER) -install_name $(LIB_DYN_ALIAS) -o $(LIB_DYN) $(LIB_DOBJS) 
     52        ln -sf $(LIB_DYN) $(LIB_DYN_ALIAS) 
    5653 
    5754clean: 
    58         rm -f $(LIB_OBJS) $(LIB_A) $(LIB_SO) $(LIB_SO_ALIAS) $(LIB_DYN) $(LIB_DYN_ALIAS) 
     55        rm -f $(LIB_OBJS) $(LIB_DOBJS) $(LIB_A) $(LIB_SO) $(LIB_SO_ALIAS) \ 
     56              $(LIB_SO_FILENAME) $(LIB_DYN) $(LIB_DYN_ALIAS) 
    5957 
    6058install: 
    6159        @echo 
    62         @echo "No install method, copy the library, header file, and" 
     60        @echo "No install method, copy the library, header files, and" 
    6361        @echo "documentation to the preferred install location" 
    6462        @echo 
     63 
     64.SUFFIXES: .c .o .lo 
     65 
     66# Standard object building 
     67.c.o: 
     68        $(CC) $(CFLAGS) -c $< -o $@ 
     69 
     70# Standard object building for dynamic library components using -fPIC 
     71.c.lo: 
     72        $(CC) $(CFLAGS) -fPIC -c $< -o $@ 
     73 
  • trunk/src/data_exchange/slink2ew/libslink/Makefile.win

    r6329 r6839  
    66NODEBUG=1 
    77 
    8 !include <ntwin32.mak> 
    9  
    108INCS = /I. 
     9OPTS = -D_CRT_SECURE_NO_WARNINGS 
    1110LIB = libslink.lib 
    1211DLL = libslink.dll 
     
    3433 
    3534.c.obj: 
    36    $(cc) /nologo $(cflags) $(cdebug) $(cvarsmt) $(tflags) $(INCS) -D_CRT_SECURE_NO_DEPRECATE $< 
    37  
     35   $(CC) /nologo $(CFLAGS) $(INCS) $(OPTS) /c $<  
    3836 
    3937# Clean-up directives 
  • trunk/src/data_exchange/slink2ew/libslink/README

    r1795 r6839  
    77'doc' directory, including a Users Guide and man pages. 
    88 
    9 Installation instructions for libslink: the SeedLink client library. 
     9The library should work in Linux, BSD (and derivatives like macOS), 
     10Solaris and MS-Windows environments. 
    1011 
    11 -- Building -- 
    12  
    13 Linux/Unix: The easiest way to compile the library is to simply run 
    14 'make'.  The included Makefile should work for most Unix-like 
    15 environments; a special target of 'gcc' will explicitly use gcc with 
    16 '-02' optimization and more warnings.  By default a statically linked 
    17 version of the library is built 'libslink.a'.  Using gcc it is 
    18 possible to build a shared library with 'make shared'. 
    19  
    20 Mac OSX (Darwin): A static library can be compiled using the above 
    21 Linux/Unix instructions, just run 'make'.  A dynamic library can be 
    22 built with 'make dynamic'. 
    23  
    24 Windows: On a WIN32 platform the library can be compiled by using the 
    25 Nmake compatible Makefile.win (e.g. 'nmake -f Makefile.win') or Open 
    26 Watcom's Wmake with Makefile.wat (e.g. 'wmake -f Makefile.wat'). The 
    27 default target is a static library 'libslink.lib'.  The library has 
    28 been tested with Microsoft Visual Studio 6 and Open Watcom 1.1. 
    29  
    30 For non-WIN32 platforms the POSIX nanosleep() function is used.  This 
    31 function may not be implemented on older Solaris or Linux platforms. 
    32 It is known to be available under Solaris 8 or later and recent 
    33 versions of Glibc2. 
    34  
    35 -- Installing -- 
    36  
    37 For installation into the system development environment simply copy 
    38 the library (libslink.a, libslink.so* and/or libslink.*.dylib) into a 
    39 system library directory and copy the associated header file 
    40 (libslink.h) into a system include directory.  Otherwise the library 
    41 and include file can be used directly from the build directory. 
     12For installation instructions see the INSTALL file.  For further 
     13information regarding the library interface see the documentation in 
     14the 'doc' directory.  For example uses of libslink see the source code 
     15in the 'examples' directory. 
    4216 
    4317-- Extras -- 
     
    5630Under WIN32 the library is not thread-safe. 
    5731 
     32-- Licensing -- 
     33 
     34Copyright (C) 2016 Chad Trabant, IRIS Data Management Center 
     35 
     36This library is free software; you can redistribute it and/or modify 
     37it under the terms of the GNU Lesser General Public License as 
     38published by the Free Software Foundation; either version 3 of the 
     39License, or (at your option) any later version. 
     40 
     41This library is distributed in the hope that it will be useful, but 
     42WITHOUT ANY WARRANTY; without even the implied warranty of 
     43MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
     44Lesser General Public License (GNU-LGPL) for more details. 
     45 
     46You should have received a copy of the GNU Lesser General Public 
     47License along with this software. 
     48If not, see <https://www.gnu.org/licenses/>. 
     49 
     50-- Acknowlegements -- 
     51 
     52Numerous improvements have been incorporated based on feedback and 
     53patches submitted by others.  Individual acknowlegements are included 
     54in the ChangeLog. 
     55 
     56Initial development at the ORFEUS Data Center/EC MEREDIAN Project 
     57Continuing maintenance at the IRIS Data Management Center 
     58 
    5859-- Pronunciation -- 
    5960 
     
    6364 
    6465all together: 'l' [eye] 'b' [es] link 
    65  
    66 -- Licensing -- 
    67  
    68 This library is free software; you can redistribute it and/or 
    69 modify it under the terms of the GNU Library General Public License 
    70 as published by the Free Software Foundation; either version 2 of 
    71 the License, or (at your option) any later version. 
    72  
    73 This library is distributed in the hope that it will be useful, but 
    74 WITHOUT ANY WARRANTY; without even the implied warranty of 
    75 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
    76 Library General Public License (GNU-LGPL) for more details.  The 
    77 GNU-LGPL and further information can be found here: 
    78 http://www.gnu.org/ 
    79  
    80 -- Author -- 
    81  
    82 Chad Trabant 
    83 Initial development at the ORFEUS Data Center/EC MEREDIAN Project 
    84 Continuing maintenance at the IRIS Data Management Center 
    85  
  • trunk/src/data_exchange/slink2ew/libslink/config.c

    r6017 r6839  
    1010 ***************************************************************************/ 
    1111 
     12#include <errno.h> 
    1213#include <stdio.h> 
    13 #include <errno.h> 
    1414#include <string.h> 
    1515 
    1616#include "libslink.h" 
    17  
    1817 
    1918/*************************************************************************** 
    2019 * sl_read_streamlist: 
    2120 * 
    22  * Read a list of streams and selectors from a file and add them to the  
     21 * Read a list of streams and selectors from a file and add them to the 
    2322 * stream chain for configuring a multi-station connection. 
    2423 * 
     
    3433 * NL HGN 
    3534 * MN AQU  BH?  HH? 
    36  * --------  
     35 * -------- 
    3736 * 
    3837 * Returns the number of streams configured or -1 on error. 
    3938 ***************************************************************************/ 
    4039int 
    41 sl_read_streamlist (SLCD * slconn, const char * streamfile, 
    42                     const char * defselect) 
     40sl_read_streamlist (SLCD *slconn, const char *streamfile, 
     41                    const char *defselect) 
    4342{ 
    4443  char net[3]; 
     
    5150  int stacount; 
    5251  int addret; 
    53    
    54   net[0] = '\0'; 
    55   sta[0] = '\0'; 
     52 
     53  net[0]       = '\0'; 
     54  sta[0]       = '\0'; 
    5655  selectors[0] = '\0'; 
    57    
     56 
    5857  /* Open the stream list file */ 
    59   if ( (streamfd = slp_openfile (streamfile, 'r')) < 0 ) 
    60     { 
    61       if (errno == ENOENT) 
    62         { 
    63           sl_log_r (slconn, 2, 0, "could not find stream list file: %s\n", streamfile); 
    64           return -1; 
    65         } 
    66       else 
    67         { 
    68           sl_log_r (slconn, 2, 0, "opening stream list file, %s\n", strerror (errno)); 
    69           return -1; 
    70         } 
    71     } 
    72    
     58  if ((streamfd = slp_openfile (streamfile, 'r')) < 0) 
     59  { 
     60    if (errno == ENOENT) 
     61    { 
     62      sl_log_r (slconn, 2, 0, "could not find stream list file: %s\n", streamfile); 
     63      return -1; 
     64    } 
     65    else 
     66    { 
     67      sl_log_r (slconn, 2, 0, "opening stream list file, %s\n", strerror (errno)); 
     68      return -1; 
     69    } 
     70  } 
     71 
    7372  sl_log_r (slconn, 1, 1, "Reading stream list from %s\n", streamfile); 
    74    
    75   count = 1; 
     73 
     74  count    = 1; 
    7675  stacount = 0; 
    77    
    78   while ( (sl_readline (streamfd, line, sizeof(line))) >= 0 ) 
    79     { 
    80       fields = sscanf (line, "%2s %5s %99[a-zA-Z0-9!?. ]\n", 
    81                        net, sta, selectors); 
    82        
    83       /* Ignore blank or comment lines */ 
    84       if ( fields < 0 || net[0] == '#' || net[0] == '*' ) 
    85         continue; 
    86  
    87       if ( fields < 2 ) 
    88         { 
    89           sl_log_r (slconn, 2, 0, "cannot parse line %d of stream list\n", count); 
    90         } 
    91        
    92       /* Add this stream to the stream chain */ 
    93       if ( fields == 3 ) 
    94         { 
    95           sl_addstream (slconn, net, sta, selectors, -1, NULL); 
    96           stacount++; 
    97         } 
    98       else 
    99         { 
    100           addret = sl_addstream (slconn, net, sta, defselect, -1, NULL); 
    101           stacount++; 
    102         } 
    103        
    104         count++; 
    105     } 
    106    
    107   if ( stacount == 0 ) 
    108     { 
    109       sl_log_r (slconn, 2, 0, "no streams defined in %s\n", streamfile); 
    110     } 
    111   else if ( stacount > 0 ) 
    112     { 
    113       sl_log_r (slconn, 1, 2, "Read %d streams from %s\n", stacount, streamfile); 
    114     } 
    115  
    116   if ( close (streamfd) ) 
    117     { 
    118       sl_log_r (slconn, 2, 0, "closing stream list file, %s\n", strerror (errno)); 
    119       return -1; 
    120     } 
    121    
     76 
     77  while ((sl_readline (streamfd, line, sizeof (line))) >= 0) 
     78  { 
     79    fields = sscanf (line, "%2s %5s %99[a-zA-Z0-9!?. ]\n", 
     80                     net, sta, selectors); 
     81 
     82    /* Ignore blank or comment lines */ 
     83    if (fields < 0 || net[0] == '#' || net[0] == '*') 
     84      continue; 
     85 
     86    if (fields < 2) 
     87    { 
     88      sl_log_r (slconn, 2, 0, "cannot parse line %d of stream list\n", count); 
     89    } 
     90 
     91    /* Add this stream to the stream chain */ 
     92    if (fields == 3) 
     93    { 
     94      sl_addstream (slconn, net, sta, selectors, -1, NULL); 
     95      stacount++; 
     96    } 
     97    else 
     98    { 
     99      addret = sl_addstream (slconn, net, sta, defselect, -1, NULL); 
     100      stacount++; 
     101    } 
     102 
     103    count++; 
     104  } 
     105 
     106  if (stacount == 0) 
     107  { 
     108    sl_log_r (slconn, 2, 0, "no streams defined in %s\n", streamfile); 
     109  } 
     110  else if (stacount > 0) 
     111  { 
     112    sl_log_r (slconn, 1, 2, "Read %d streams from %s\n", stacount, streamfile); 
     113  } 
     114 
     115  if (close (streamfd)) 
     116  { 
     117    sl_log_r (slconn, 2, 0, "closing stream list file, %s\n", strerror (errno)); 
     118    return -1; 
     119  } 
     120 
    122121  return count; 
    123 }  /* End of sl_read_streamlist() */ 
    124  
     122} /* End of sl_read_streamlist() */ 
    125123 
    126124/*************************************************************************** 
     
    135133 * For example: 
    136134 * "IU_KONO:BHE BHN,GE_WLF,MN_AQU:HH?.D" 
    137  *  
     135 * 
    138136 * Returns the number of streams configured or -1 on error. 
    139137 ***************************************************************************/ 
    140138int 
    141 sl_parse_streamlist (SLCD * slconn, const char * streamlist, 
    142                      const char * defselect) 
     139sl_parse_streamlist (SLCD *slconn, const char *streamlist, 
     140                     const char *defselect) 
    143141{ 
    144142  int count = 0; 
     
    149147  char *sta; 
    150148 
    151   SLstrlist *ringlist   = NULL;       /* split streamlist on ',' */ 
    152   SLstrlist *reqlist    = NULL;       /* split ringlist on ':' */ 
    153   SLstrlist *netstalist = NULL;       /* split reqlist[0] on "_" */ 
    154  
    155   SLstrlist *ringptr    = NULL; 
    156   SLstrlist *reqptr     = NULL; 
    157   SLstrlist *netstaptr  = NULL; 
     149  SLstrlist *ringlist   = NULL; /* split streamlist on ',' */ 
     150  SLstrlist *reqlist    = NULL; /* split ringlist on ':' */ 
     151  SLstrlist *netstalist = NULL; /* split reqlist[0] on "_" */ 
     152 
     153  SLstrlist *ringptr   = NULL; 
     154  SLstrlist *reqptr    = NULL; 
     155  SLstrlist *netstaptr = NULL; 
    158156 
    159157  /* Parse the streams and selectors */ 
     
    162160 
    163161  while (ringptr != 0) 
    164     { 
    165       net = NULL; 
    166       sta = NULL; 
    167       staselect = NULL; 
    168        
    169       fields = sl_strparse (ringptr->element, ":", &reqlist); 
    170       reqptr = reqlist; 
    171  
    172       /* Fill in the NET and STA fields */ 
    173       if (sl_strparse (reqptr->element, "_", &netstalist) != 2) 
    174         { 
    175           sl_log_r (slconn, 2, 0, "not in NET_STA format: %s\n", reqptr->element); 
    176           count = -1; 
    177         } 
    178       else 
    179         { 
    180           /* Point to the first element, should be a network code */ 
    181           netstaptr = netstalist; 
    182           if (strlen (netstaptr->element) == 0) 
    183             { 
    184               sl_log_r (slconn, 2, 0, "not in NET_STA format: %s\n", 
    185                       reqptr->element); 
    186               count = -1; 
    187             } 
    188           net = netstaptr->element; 
    189            
    190           /* Point to the second element, should be a station code */ 
    191           netstaptr = netstaptr->next; 
    192           if (strlen (netstaptr->element) == 0) 
    193             { 
    194               sl_log_r (slconn, 2, 0, "not in NET_STA format: %s\n", 
    195                       reqptr->element); 
    196               count = -1; 
    197             } 
    198           sta = netstaptr->element; 
    199         } 
    200  
    201       if (fields > 1) 
    202         {                  /* Selectors were included */ 
    203           /* Point to the second element of reqptr, should be selectors */ 
    204           reqptr = reqptr->next; 
    205           if (strlen (reqptr->element) == 0) 
    206             { 
    207               sl_log_r (slconn, 2, 0, "empty selector: %s\n", reqptr->element); 
    208               count = -1; 
    209             } 
    210           staselect = reqptr->element; 
    211         } 
    212       else /* If no specific selectors, use the default */ 
    213         { 
    214           staselect = defselect; 
    215         } 
    216        
    217       /* Add this to the stream chain */ 
    218       if ( count != -1 ) 
    219         { 
    220           sl_addstream(slconn, net, sta, staselect, -1, 0); 
    221           count++; 
    222         } 
    223  
    224       /* Free the netstalist (the 'NET_STA' part) */ 
    225       sl_strparse (NULL, NULL, &netstalist); 
    226        
    227       /* Free the reqlist (the 'NET_STA:selector' part) */ 
    228       sl_strparse (NULL, NULL, &reqlist); 
    229        
    230       ringptr = ringptr->next; 
    231     } 
    232  
    233   if ( netstalist != NULL ) 
    234     { 
    235       sl_strparse (NULL, NULL, &netstalist); 
    236     } 
    237   if ( reqlist != NULL ) 
    238     { 
    239       sl_strparse (NULL, NULL, &reqlist); 
    240     } 
    241    
    242   if ( count == 0 ) 
    243     { 
    244       sl_log_r (slconn, 2, 0, "no streams defined in stream list\n"); 
    245     } 
    246   else if ( count > 0 ) 
    247     { 
    248       sl_log_r (slconn, 1, 2, "Parsed %d streams from stream list\n", count); 
    249     } 
     162  { 
     163    net      = NULL; 
     164    sta      = NULL; 
     165    staselect = NULL; 
     166 
     167    fields = sl_strparse (ringptr->element, ":", &reqlist); 
     168    reqptr = reqlist; 
     169 
     170    /* Fill in the NET and STA fields */ 
     171    if (sl_strparse (reqptr->element, "_", &netstalist) != 2) 
     172    { 
     173      sl_log_r (slconn, 2, 0, "not in NET_STA format: %s\n", reqptr->element); 
     174      count = -1; 
     175    } 
     176    else 
     177    { 
     178      /* Point to the first element, should be a network code */ 
     179      netstaptr = netstalist; 
     180      if (strlen (netstaptr->element) == 0) 
     181      { 
     182        sl_log_r (slconn, 2, 0, "not in NET_STA format: %s\n", 
     183                  reqptr->element); 
     184        count = -1; 
     185      } 
     186      net = netstaptr->element; 
     187 
     188      /* Point to the second element, should be a station code */ 
     189      netstaptr = netstaptr->next; 
     190      if (strlen (netstaptr->element) == 0) 
     191      { 
     192        sl_log_r (slconn, 2, 0, "not in NET_STA format: %s\n", 
     193                  reqptr->element); 
     194        count = -1; 
     195      } 
     196      sta = netstaptr->element; 
     197    } 
     198 
     199    if (fields > 1) 
     200    { /* Selectors were included */ 
     201      /* Point to the second element of reqptr, should be selectors */ 
     202      reqptr = reqptr->next; 
     203      if (strlen (reqptr->element) == 0) 
     204      { 
     205        sl_log_r (slconn, 2, 0, "empty selector: %s\n", reqptr->element); 
     206        count = -1; 
     207      } 
     208      staselect = reqptr->element; 
     209    } 
     210    else /* If no specific selectors, use the default */ 
     211    { 
     212      staselect = defselect; 
     213    } 
     214 
     215    /* Add this to the stream chain */ 
     216    if (count != -1) 
     217    { 
     218      sl_addstream (slconn, net, sta, staselect, -1, 0); 
     219      count++; 
     220    } 
     221 
     222    /* Free the netstalist (the 'NET_STA' part) */ 
     223    sl_strparse (NULL, NULL, &netstalist); 
     224 
     225    /* Free the reqlist (the 'NET_STA:selector' part) */ 
     226    sl_strparse (NULL, NULL, &reqlist); 
     227 
     228    ringptr = ringptr->next; 
     229  } 
     230 
     231  if (netstalist != NULL) 
     232  { 
     233    sl_strparse (NULL, NULL, &netstalist); 
     234  } 
     235  if (reqlist != NULL) 
     236  { 
     237    sl_strparse (NULL, NULL, &reqlist); 
     238  } 
     239 
     240  if (count == 0) 
     241  { 
     242    sl_log_r (slconn, 2, 0, "no streams defined in stream list\n"); 
     243  } 
     244  else if (count > 0) 
     245  { 
     246    sl_log_r (slconn, 1, 2, "Parsed %d streams from stream list\n", count); 
     247  } 
    250248 
    251249  /* Free the ring list */ 
    252250  sl_strparse (NULL, NULL, &ringlist); 
    253    
     251 
    254252  return count; 
    255 }  /* End of sl_parse_streamlist() */ 
     253} /* End of sl_parse_streamlist() */ 
  • trunk/src/data_exchange/slink2ew/libslink/doc/sl_msr_new.3

    r4843 r6839  
    1 .TH MSR_NEW 3 2006/12/10 
     1.TH MSR_NEW 3 2016/10/14 
    22.SH NAME 
    33Utility routines for parsing, printing, etc. of Mini-SEED records 
     
    1212.BI "SLMSrecord * \fBsl_msr_parse\fP (SLlog *" log ", char *" msrecord ", SLMSrecord **" msr ", 
    1313.BI "                           int " blktflag " , int " unpackflag ); 
    14 .BI "int        \fBsl_msr_print\fP (SLlog *" log ", SLMSrecord *" msr ", int " details "); 
     14.sp 
     15.BI "int        \fBsl_msr_print\fP (SLlog *" log ", SLMSrecord *" msr ", int " details ");" 
     16.sp 
     17.BI "int        \fBsl_msr_srcname\fP (SLMSrecord *" msr ", char *" srcname ", 
     18.BI "                           int8_t " quality ); 
    1519.sp 
    1620.BI "int        \fBsl_msr_dsamprate\fP (SLMSrecord *" msr ", double *" samprate ); 
     
    8286printed.  Otherwise only a single line for each packet is printed. 
    8387 
     88\fBsl_msr_srcname\fP will generate a source name string of the format 
     89"Net_Sta_Loc_Chan[_Qual]" for the given SLMSrecord.  The data quality 
     90indicator will be added to the source name if the \fIquality\fP flag 
     91is true.  The supplied \fIsrcname\fP buffer must have enough room to 
     92hold the result. 
     93 
    8494\fBsl_msr_dsamprate\fP, \fBsl_msr_dnomsamprate\fP and 
    8595\fBsl_msr_depochstime\fP are helper functions for common, mundane 
  • trunk/src/data_exchange/slink2ew/libslink/example/Makefile.win

    r6017 r6839  
    44# Use 'nmake -f Makefile.win' 
    55 
    6 NODEBUG=1 
    7  
    8 !include <ntwin32.mak> 
    9  
    106INCS = /I.. 
     7OPTS = -D_CRT_SECURE_NO_WARNINGS 
    118LIBS = ../libslink.lib ws2_32.lib 
    129BIN = slclient.exe 
     
    2219 
    2320.c.obj: 
    24    $(cc) /nologo $(cflags) $(cdebug) $(cvarsmt) $(tflags) $(INCS) $< 
     21        $(CC) /nologo $(CFLAGS) $(INCS) $(OPTS) /c $< 
    2522 
    2623# Clean-up directives 
  • trunk/src/data_exchange/slink2ew/libslink/genutils.c

    r3293 r6839  
    1717#include "libslink.h" 
    1818 
    19  
    2019/*************************************************************************** 
    2120 * sl_dtime: 
     
    2827{ 
    2928  /* Now just a shell for the portable version */ 
    30   return slp_dtime(); 
    31 }  /* End of sl_dtime() */ 
    32  
     29  return slp_dtime (); 
     30} /* End of sl_dtime() */ 
    3331 
    3432/*************************************************************************** 
     
    4038 ***************************************************************************/ 
    4139int 
    42 sl_doy2md(int year, int jday, int *month, int *mday) 
     40sl_doy2md (int year, int jday, int *month, int *mday) 
    4341{ 
    4442  int idx; 
    4543  int leap; 
    4644  int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 
    47    
     45 
    4846  /* Sanity check for the supplied year */ 
    49   if ( year < 1900 || year > 2100 ) 
    50     { 
    51       sl_log_r (NULL, 2, 0, "sl_doy2md(): year (%d) is out of range\n", year); 
    52       return -1; 
    53     } 
    54      
     47  if (year < 1900 || year > 2100) 
     48  { 
     49    sl_log_r (NULL, 2, 0, "sl_doy2md(): year (%d) is out of range\n", year); 
     50    return -1; 
     51  } 
     52 
    5553  /* Test for leap year */ 
    56   leap = ( ((year%4 == 0) && (year%100 != 0)) || (year%400 == 0) ) ? 1 : 0; 
     54  leap = (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) ? 1 : 0; 
    5755 
    5856  /* Add a day to February if leap year */ 
    59   if ( leap ) 
     57  if (leap) 
    6058    days[1]++; 
    6159 
    62   if (jday > 365+leap || jday <= 0) 
     60  if (jday > 365 + leap || jday <= 0) 
     61  { 
     62    sl_log_r (NULL, 2, 0, "sl_doy2md(): day-of-year (%d) is out of range\n", jday); 
     63    return -1; 
     64  } 
     65 
     66  for (idx = 0; idx < 12; idx++) 
     67  { 
     68    jday -= days[idx]; 
     69 
     70    if (jday <= 0) 
    6371    { 
    64       sl_log_r (NULL, 2, 0, "sl_doy2md(): day-of-year (%d) is out of range\n", jday); 
    65       return -1; 
     72      *month = idx + 1; 
     73      *mday  = days[idx] + jday; 
     74      break; 
    6675    } 
    67      
    68   for ( idx=0; idx < 12; idx++ ) 
    69     { 
    70       jday -= days[idx]; 
    71  
    72       if ( jday <= 0 ) 
    73         { 
    74           *month = idx + 1; 
    75           *mday = days[idx] + jday; 
    76           break; 
    77         } 
    78     } 
     76  } 
    7977 
    8078  return 0; 
    81 }  /* End of sl_doy2md() */ 
    82  
     79} /* End of sl_doy2md() */ 
    8380 
    8481/*************************************************************************** 
     
    9390 ***************************************************************************/ 
    9491int 
    95 sl_checkversion (const SLCD * slconn, float version) 
     92sl_checkversion (const SLCD *slconn, float version) 
    9693{ 
    9794  if (slconn->protocol_ver == 0.0) 
    98     { 
    99       return 0; 
    100     } 
     95  { 
     96    return 0; 
     97  } 
    10198  else if (slconn->protocol_ver >= version) 
    102     { 
    103       return 1; 
    104     } 
     99  { 
     100    return 1; 
     101  } 
    105102  else 
    106     { 
    107       return -1; 
    108     } 
    109 }  /* End of sl_checkversion() */ 
    110  
     103  { 
     104    return -1; 
     105  } 
     106} /* End of sl_checkversion() */ 
    111107 
    112108/*************************************************************************** 
     
    118114 ***************************************************************************/ 
    119115int 
    120 sl_checkslcd (const SLCD * slconn) 
     116sl_checkslcd (const SLCD *slconn) 
    121117{ 
    122118  int retval = 0; 
    123119 
    124120  if (slconn->streams == NULL && slconn->info == NULL) 
    125     { 
    126       sl_log_r (slconn, 2, 0, "sl_checkslconn(): stream chain AND info type are empty\n"); 
    127       retval = -1; 
    128     } 
     121  { 
     122    sl_log_r (slconn, 2, 0, "sl_checkslconn(): stream chain AND info type are empty\n"); 
     123    retval = -1; 
     124  } 
    129125 
    130126  return retval; 
    131 }  /* End of sl_checkslconn() */ 
    132  
     127} /* End of sl_checkslconn() */ 
    133128 
    134129/*************************************************************************** 
     
    147142{ 
    148143  int nread = 0; 
    149    
    150   if ( ! buffer ) 
     144 
     145  if (!buffer) 
    151146    return -1; 
    152    
     147 
    153148  /* Read data from stream until newline character or max characters */ 
    154   while ( nread < (buflen-1) ) 
     149  while (nread < (buflen - 1)) 
     150  { 
     151    /* Read a single character from the stream */ 
     152    if (read (fd, buffer + nread, 1) != 1) 
    155153    { 
    156       /* Read a single character from the stream */ 
    157       if ( read (fd, buffer+nread, 1) != 1 ) 
    158         { 
    159           return -1; 
    160         } 
    161        
    162       /* Trap door for newline character */ 
    163       if ( buffer[nread] == '\n' ) 
    164         { 
    165           break; 
    166         } 
    167        
    168       nread++; 
     154      return -1; 
    169155    } 
    170    
     156 
     157    /* Trap door for newline character */ 
     158    if (buffer[nread] == '\n') 
     159    { 
     160      break; 
     161    } 
     162 
     163    nread++; 
     164  } 
     165 
    171166  /* Terminate string in buffer */ 
    172167  buffer[nread] = '\0'; 
    173    
     168 
    174169  return nread; 
    175 }  /* End of sl_readline() */ 
     170} /* End of sl_readline() */ 
  • trunk/src/data_exchange/slink2ew/libslink/globmatch.c

    r4843 r6839  
    3838 * charset code fixed. it is now robust and interprets all 
    3939 * variations of charset [i think] correctly, including [z-a] etc. 
    40  *  
     40 * 
    4141 * Revision 1.1  94/12/08  12:45:23  oz 
    4242 * Initial revision 
    4343 */ 
    4444 
    45  
    4645#include "globmatch.h" 
    4746 
    48 #define SL_GLOBMATCH_TRUE    1 
    49 #define SL_GLOBMATCH_FALSE   0 
    50  
     47#define SL_GLOBMATCH_TRUE 1 
     48#define SL_GLOBMATCH_FALSE 0 
    5149 
    5250/*********************************************************************** 
     
    6361  int match; 
    6462  int c; 
    65    
    66   while ( *pattern ) 
     63 
     64  while (*pattern) 
     65  { 
     66    if (!*string && *pattern != '*') 
     67      return SL_GLOBMATCH_FALSE; 
     68 
     69    switch (c = *pattern++) 
    6770    { 
    68       if ( !*string && *pattern != '*' ) 
    69         return SL_GLOBMATCH_FALSE; 
    70        
    71       switch ( c = *pattern++ ) 
    72         { 
    73            
    74         case '*': 
    75           while ( *pattern == '*' ) 
    76             pattern++; 
    77            
    78           if ( !*pattern ) 
    79             return SL_GLOBMATCH_TRUE; 
    80            
    81           if ( *pattern != '?' && *pattern != '[' && *pattern != '\\' ) 
    82             while ( *string && *pattern != *string ) 
    83               string++; 
    84            
    85           while ( *string ) 
    86             { 
    87               if ( sl_globmatch(string, pattern) ) 
    88                 return SL_GLOBMATCH_TRUE; 
    89               string++; 
    90             } 
    91           return SL_GLOBMATCH_FALSE; 
    92            
    93         case '?': 
    94           if ( *string ) 
    95             break; 
    96           return SL_GLOBMATCH_FALSE; 
    97            
    98           /* set specification is inclusive, that is [a-z] is a, z and 
     71 
     72    case '*': 
     73      while (*pattern == '*') 
     74        pattern++; 
     75 
     76      if (!*pattern) 
     77        return SL_GLOBMATCH_TRUE; 
     78 
     79      if (*pattern != '?' && *pattern != '[' && *pattern != '\\') 
     80        while (*string && *pattern != *string) 
     81          string++; 
     82 
     83      while (*string) 
     84      { 
     85        if (sl_globmatch (string, pattern)) 
     86          return SL_GLOBMATCH_TRUE; 
     87        string++; 
     88      } 
     89      return SL_GLOBMATCH_FALSE; 
     90 
     91    case '?': 
     92      if (*string) 
     93        break; 
     94      return SL_GLOBMATCH_FALSE; 
     95 
     96    /* set specification is inclusive, that is [a-z] is a, z and 
    9997           * everything in between. this means [z-a] may be interpreted 
    10098           * as a set that contains z, a and nothing in between. 
    10199           */ 
    102         case '[': 
    103           if ( *pattern != SL_GLOBMATCH_NEGATE ) 
    104             negate = SL_GLOBMATCH_FALSE; 
    105           else 
    106             { 
    107               negate = SL_GLOBMATCH_TRUE; 
    108               pattern++; 
    109             } 
    110            
    111           match = SL_GLOBMATCH_FALSE; 
    112            
    113           while ( !match && (c = *pattern++) ) 
    114             { 
    115               if ( !*pattern ) 
    116                 return SL_GLOBMATCH_FALSE; 
    117                
    118               if ( *pattern == '-' )    /* c-c */ 
    119                 { 
    120                   if ( !*++pattern ) 
    121                     return SL_GLOBMATCH_FALSE; 
    122                   if ( *pattern != ']' ) 
    123                     { 
    124                       if ( *string == c || *string == *pattern || 
    125                            ( *string > c && *string < *pattern ) ) 
    126                         match = SL_GLOBMATCH_TRUE; 
    127                     } 
    128                   else 
    129                     {           /* c-] */ 
    130                       if ( *string >= c ) 
    131                         match = SL_GLOBMATCH_TRUE; 
    132                       break; 
    133                     } 
    134                 } 
    135               else                      /* cc or c] */ 
    136                 { 
    137                   if ( c == *string ) 
    138                     match = SL_GLOBMATCH_TRUE; 
    139                   if ( *pattern != ']' ) 
    140                     { 
    141                       if ( *pattern == *string ) 
    142                         match = SL_GLOBMATCH_TRUE; 
    143                     } 
    144                   else 
    145                     break; 
    146                 } 
    147             }  
    148            
    149           if ( negate == match ) 
    150             return SL_GLOBMATCH_FALSE; 
    151            
    152           /* 
     100    case '[': 
     101      if (*pattern != SL_GLOBMATCH_NEGATE) 
     102        negate = SL_GLOBMATCH_FALSE; 
     103      else 
     104      { 
     105        negate = SL_GLOBMATCH_TRUE; 
     106        pattern++; 
     107      } 
     108 
     109      match = SL_GLOBMATCH_FALSE; 
     110 
     111      while (!match && (c = *pattern++)) 
     112      { 
     113        if (!*pattern) 
     114          return SL_GLOBMATCH_FALSE; 
     115 
     116        if (*pattern == '-') /* c-c */ 
     117        { 
     118          if (!*++pattern) 
     119            return SL_GLOBMATCH_FALSE; 
     120          if (*pattern != ']') 
     121          { 
     122            if (*string == c || *string == *pattern || 
     123                (*string > c && *string < *pattern)) 
     124              match = SL_GLOBMATCH_TRUE; 
     125          } 
     126          else 
     127          { /* c-] */ 
     128            if (*string >= c) 
     129              match = SL_GLOBMATCH_TRUE; 
     130            break; 
     131          } 
     132        } 
     133        else /* cc or c] */ 
     134        { 
     135          if (c == *string) 
     136            match = SL_GLOBMATCH_TRUE; 
     137          if (*pattern != ']') 
     138          { 
     139            if (*pattern == *string) 
     140              match = SL_GLOBMATCH_TRUE; 
     141          } 
     142          else 
     143            break; 
     144        } 
     145      } 
     146 
     147      if (negate == match) 
     148        return SL_GLOBMATCH_FALSE; 
     149 
     150      /* 
    153151           * if there is a match, skip past the charset and continue on 
    154152           */ 
    155           while ( *pattern && *pattern != ']' ) 
    156             pattern++; 
    157           if ( !*pattern++ )    /* oops! */ 
    158             return SL_GLOBMATCH_FALSE; 
    159           break; 
    160            
    161         case '\\': 
    162           if ( *pattern ) 
    163             c = *pattern++; 
    164         default: 
    165           if ( c != *string ) 
    166             return SL_GLOBMATCH_FALSE; 
    167           break; 
    168         } 
    169        
    170       string++; 
     153      while (*pattern && *pattern != ']') 
     154        pattern++; 
     155      if (!*pattern++) /* oops! */ 
     156        return SL_GLOBMATCH_FALSE; 
     157      break; 
     158 
     159    case '\\': 
     160      if (*pattern) 
     161        c = *pattern++; 
     162    default: 
     163      if (c != *string) 
     164        return SL_GLOBMATCH_FALSE; 
     165      break; 
    171166    } 
    172    
     167 
     168    string++; 
     169  } 
     170 
    173171  return !*string; 
    174172} 
  • trunk/src/data_exchange/slink2ew/libslink/gswap.c

    r3286 r6839  
    2929 
    3030void 
    31 sl_gswap2 ( void *data2 ) 
     31sl_gswap2 (void *data2) 
    3232{ 
    3333  uint8_t temp; 
    34    
    35   union 
    36   { 
    37     uint8_t  c[2]; 
     34 
     35  union { 
     36    uint8_t c[2]; 
    3837  } dat; 
    39    
    40   memcpy( &dat, data2, sizeof(dat) ); 
     38 
     39  memcpy (&dat, data2, sizeof (dat)); 
    4140  temp     = dat.c[0]; 
    4241  dat.c[0] = dat.c[1]; 
    4342  dat.c[1] = temp; 
    44   memcpy( data2, &dat, sizeof(dat) ); 
     43  memcpy (data2, &dat, sizeof (dat)); 
    4544} 
    4645 
    47  
    4846void 
    49 sl_gswap3 ( void *data3 ) 
     47sl_gswap3 (void *data3) 
    5048{ 
    5149  uint8_t temp; 
    52    
    53   union 
    54   { 
    55     uint8_t  c[3]; 
     50 
     51  union { 
     52    uint8_t c[3]; 
    5653  } dat; 
    57    
    58   memcpy( &dat, data3, sizeof(dat) ); 
     54 
     55  memcpy (&dat, data3, sizeof (dat)); 
    5956  temp     = dat.c[0]; 
    6057  dat.c[0] = dat.c[2]; 
    6158  dat.c[2] = temp; 
    62   memcpy( data3, &dat, sizeof(dat) ); 
     59  memcpy (data3, &dat, sizeof (dat)); 
    6360} 
    6461 
    65  
    6662void 
    67 sl_gswap4 ( void *data4 ) 
     63sl_gswap4 (void *data4) 
    6864{ 
    6965  uint8_t temp; 
     
    7268    uint8_t c[4]; 
    7369  } dat; 
    74    
    75   memcpy( &dat, data4, sizeof(dat) ); 
     70 
     71  memcpy (&dat, data4, sizeof (dat)); 
    7672  temp     = dat.c[0]; 
    7773  dat.c[0] = dat.c[3]; 
     
    8076  dat.c[1] = dat.c[2]; 
    8177  dat.c[2] = temp; 
    82   memcpy( data4, &dat, sizeof(dat) ); 
     78  memcpy (data4, &dat, sizeof (dat)); 
    8379} 
    8480 
    85  
    8681void 
    87 sl_gswap8 ( void *data8 ) 
     82sl_gswap8 (void *data8) 
    8883{ 
    8984  uint8_t temp; 
    90    
    91   union 
    92   { 
    93     uint8_t   c[8]; 
     85 
     86  union { 
     87    uint8_t c[8]; 
    9488  } dat; 
    95    
    96   memcpy( &dat, data8, sizeof(dat) ); 
     89 
     90  memcpy (&dat, data8, sizeof (dat)); 
    9791  temp     = dat.c[0]; 
    9892  dat.c[0] = dat.c[7]; 
    9993  dat.c[7] = temp; 
    100    
     94 
    10195  temp     = dat.c[1]; 
    10296  dat.c[1] = dat.c[6]; 
    10397  dat.c[6] = temp; 
    104    
     98 
    10599  temp     = dat.c[2]; 
    106100  dat.c[2] = dat.c[5]; 
    107101  dat.c[5] = temp; 
    108    
     102 
    109103  temp     = dat.c[3]; 
    110104  dat.c[3] = dat.c[4]; 
    111105  dat.c[4] = temp; 
    112   memcpy( data8, &dat, sizeof(dat) ); 
     106  memcpy (data8, &dat, sizeof (dat)); 
    113107} 
    114108 
     
    116110 
    117111void 
    118 sl_gswap2a ( void *data2 ) 
     112sl_gswap2a (void *data2) 
    119113{ 
    120114  uint16_t *data = data2; 
    121    
    122   *data=(((*data>>8)&0xff) | ((*data&0xff)<<8)); 
     115 
     116  *data = (((*data >> 8) & 0xff) | ((*data & 0xff) << 8)); 
    123117} 
    124118 
     119void 
     120sl_gswap4a (void *data4) 
     121{ 
     122  uint32_t *data = data4; 
     123 
     124  *data = (((*data >> 24) & 0xff) | ((*data & 0xff) << 24) | 
     125           ((*data >> 8) & 0xff00) | ((*data & 0xff00) << 8)); 
     126} 
    125127 
    126128void 
    127 sl_gswap4a ( void *data4 ) 
    128 { 
    129   uint32_t *data = data4; 
    130    
    131   *data=(((*data>>24)&0xff) | ((*data&0xff)<<24) | 
    132          ((*data>>8)&0xff00) | ((*data&0xff00)<<8)); 
    133 } 
    134  
    135  
    136 void 
    137 sl_gswap8a ( void *data8 ) 
     129sl_gswap8a (void *data8) 
    138130{ 
    139131  uint32_t *data4 = data8; 
    140132  uint32_t h0, h1; 
    141    
     133 
    142134  h0 = data4[0]; 
    143   h0 = (((h0>>24)&0xff) | ((h0&0xff)<<24) | 
    144         ((h0>>8)&0xff00) | ((h0&0xff00)<<8)); 
    145    
     135  h0 = (((h0 >> 24) & 0xff) | ((h0 & 0xff) << 24) | 
     136        ((h0 >> 8) & 0xff00) | ((h0 & 0xff00) << 8)); 
     137 
    146138  h1 = data4[1]; 
    147   h1 = (((h1>>24)&0xff) | ((h1&0xff)<<24) | 
    148         ((h1>>8)&0xff00) | ((h1&0xff00)<<8)); 
    149    
     139  h1 = (((h1 >> 24) & 0xff) | ((h1 & 0xff) << 24) | 
     140        ((h1 >> 8) & 0xff00) | ((h1 & 0xff00) << 8)); 
     141 
    150142  data4[0] = h1; 
    151143  data4[1] = h0; 
  • trunk/src/data_exchange/slink2ew/libslink/libslink.h

    r6017 r6839  
    11/*************************************************************************** 
    22 * libslink.h: 
    3  *  
     3 * 
    44 * Interface declarations for the SeedLink library (libslink). 
    55 * 
    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. 
     6 * This library is free software; you can redistribute it and/or modify 
     7 * it under the terms of the GNU Lesser General Public License as 
     8 * published by the Free Software Foundation; either version 3 of the 
     9 * License, or (at your option) any later version. 
    1010 * 
    1111 * This library is distributed in the hope that it will be useful, but 
    1212 * WITHOUT ANY WARRANTY; without even the implied warranty of 
    1313 * 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 
    19  *   ORFEUS/EC-Project MEREDIAN 
    20  *   IRIS Data Management Center 
    21  * 
    22  * modified: 2012.152 
     14 * Lesser General Public License (GNU-LGPL) for more details. 
     15 * 
     16 * You should have received a copy of the GNU Lesser General Public 
     17 * License along with this software. 
     18 * If not, see <https://www.gnu.org/licenses/>. 
     19 * 
     20 * Copyright (C) 2016 Chad Trabant, IRIS Data Management Center 
     21 * 
     22 * modified: 2016.288 
    2323 ***************************************************************************/ 
    24  
    2524 
    2625#ifndef LIBSLINK_H 
     
    3332#include "slplatform.h" 
    3433 
    35 #define LIBSLINK_VERSION "2.4b" 
    36 #define LIBSLINK_RELEASE "2013.305" 
     34#define LIBSLINK_VERSION "2.6dev" 
     35#define LIBSLINK_RELEASE "2016.288" 
    3736 
    3837#define SLRECSIZE           512      /* Default Mini-SEED record size */ 
     
    225224  float       protocol_ver;     /* Version of the SeedLink protocol in use */ 
    226225  const char *info;             /* INFO level to request */ 
    227   int         link;             /* The network socket descriptor */ 
     226  SOCKET      link;             /* The network socket descriptor */ 
    228227  SLstat     *stat;             /* Persistent state information */ 
    229228  SLlog      *log;              /* Logging parameters */ 
     
    256255extern int    sl_send_info (SLCD * slconn, const char * info_level, 
    257256                            int verbose); 
    258 extern int    sl_connect (SLCD * slconn, int sayhello); 
     257extern SOCKET sl_connect (SLCD * slconn, int sayhello); 
    259258extern int    sl_disconnect (SLCD * slconn); 
    260259extern int    sl_ping (SLCD * slconn, char *serverid, char *site); 
    261 extern int    sl_checksock (int sock, int tosec, int tousec); 
     260extern int    sl_checksock (SOCKET sock, int tosec, int tousec); 
    262261extern int    sl_senddata (SLCD * slconn, void *buffer, size_t buflen, 
    263262                           const char *ident, void *resp, int resplen); 
     
    305304typedef struct SLMSrecord_s { 
    306305  const char            *msrecord;    /* Pointer to original record */ 
    307   struct sl_fsdh_s       fsdh;        /* Fixed Section of Data Header */  
     306  struct sl_fsdh_s       fsdh;        /* Fixed Section of Data Header */ 
    308307  struct sl_blkt_100_s  *Blkt100;     /* Blockette 100, if present */ 
    309308  struct sl_blkt_1000_s *Blkt1000;    /* Blockette 1000, if present */ 
     
    322321                                      int8_t blktflag, int8_t unpackflag, int slrecsize); 
    323322extern int         sl_msr_print (SLlog * log, SLMSrecord * msr, int details); 
     323extern char*       sl_msr_srcname (SLMSrecord * msr, char * srcname, int8_t quality); 
    324324extern int         sl_msr_dsamprate (SLMSrecord * msr, double * samprate); 
    325325extern double      sl_msr_dnomsamprate (SLMSrecord * msr); 
  • trunk/src/data_exchange/slink2ew/libslink/logging.c

    r2069 r6839  
    99 ***************************************************************************/ 
    1010 
     11#include <stdarg.h> 
    1112#include <stdio.h> 
    1213#include <stdlib.h> 
    13 #include <stdarg.h> 
    1414#include <string.h> 
    1515 
    1616#include "libslink.h" 
    1717 
    18 void sl_loginit_main (SLlog * logp, int verbosity, 
    19                       void (*log_print)(const char*), const char * logprefix, 
    20                       void (*diag_print)(const char*), const char * errprefix); 
    21  
    22 int sl_log_main (SLlog * logp, int level, int verb, va_list * varlist); 
     18void sl_loginit_main (SLlog *logp, int verbosity, 
     19                      void (*log_print) (const char *), const char *logprefix, 
     20                      void (*diag_print) (const char *), const char *errprefix); 
     21 
     22int sl_log_main (SLlog *logp, int level, int verb, va_list *varlist); 
    2323 
    2424/* Initialize the global logging parameters */ 
    2525SLlog gSLlog = {NULL, NULL, NULL, NULL, 0}; 
    2626 
    27  
    2827/*************************************************************************** 
    2928 * sl_loginit: 
     
    3534void 
    3635sl_loginit (int verbosity, 
    37             void (*log_print)(const char*), const char * logprefix, 
    38             void (*diag_print)(const char*), const char * errprefix) 
    39 { 
    40   sl_loginit_main(&gSLlog, verbosity, log_print, logprefix, diag_print, errprefix); 
    41 }  /* End of sl_loginit() */ 
    42  
     36            void (*log_print) (const char *), const char *logprefix, 
     37            void (*diag_print) (const char *), const char *errprefix) 
     38{ 
     39  sl_loginit_main (&gSLlog, verbosity, log_print, logprefix, diag_print, errprefix); 
     40} /* End of sl_loginit() */ 
    4341 
    4442/*************************************************************************** 
     
    5250 ***************************************************************************/ 
    5351void 
    54 sl_loginit_r (SLCD * slconn, int verbosity, 
    55               void (*log_print)(const char*), const char * logprefix, 
    56               void (*diag_print)(const char*), const char * errprefix) 
    57 { 
    58   if ( ! slconn ) 
     52sl_loginit_r (SLCD *slconn, int verbosity, 
     53              void (*log_print) (const char *), const char *logprefix, 
     54              void (*diag_print) (const char *), const char *errprefix) 
     55{ 
     56  if (!slconn) 
    5957    return; 
    6058 
    61   if ( slconn->log == NULL ) 
    62     { 
    63       slconn->log = (SLlog *) malloc (sizeof(SLlog)); 
    64  
    65       slconn->log->log_print = NULL; 
    66       slconn->log->logprefix = NULL; 
    67       slconn->log->diag_print = NULL; 
    68       slconn->log->errprefix = NULL; 
    69       slconn->log->verbosity = 0; 
    70     } 
    71  
    72   sl_loginit_main(slconn->log, verbosity, log_print, logprefix, diag_print, errprefix); 
    73 }  /* End of sl_loginit_r() */ 
    74  
     59  if (slconn->log == NULL) 
     60  { 
     61    slconn->log = (SLlog *)malloc (sizeof (SLlog)); 
     62 
     63    slconn->log->log_print  = NULL; 
     64    slconn->log->logprefix  = NULL; 
     65    slconn->log->diag_print = NULL; 
     66    slconn->log->errprefix  = NULL; 
     67    slconn->log->verbosity  = 0; 
     68  } 
     69 
     70  sl_loginit_main (slconn->log, verbosity, log_print, logprefix, diag_print, errprefix); 
     71} /* End of sl_loginit_r() */ 
    7572 
    7673/*************************************************************************** 
     
    8683 ***************************************************************************/ 
    8784SLlog * 
    88 sl_loginit_rl (SLlog * log, int verbosity, 
    89                void (*log_print)(const char*), const char * logprefix, 
    90                void (*diag_print)(const char*), const char * errprefix) 
     85sl_loginit_rl (SLlog *log, int verbosity, 
     86               void (*log_print) (const char *), const char *logprefix, 
     87               void (*diag_print) (const char *), const char *errprefix) 
    9188{ 
    9289  SLlog *logp; 
    9390 
    94   if ( log == NULL ) 
    95     { 
    96       logp = (SLlog *) malloc (sizeof(SLlog)); 
    97  
    98       logp->log_print = NULL; 
    99       logp->logprefix = NULL; 
    100       logp->diag_print = NULL; 
    101       logp->errprefix = NULL; 
    102       logp->verbosity = 0; 
    103     } 
     91  if (log == NULL) 
     92  { 
     93    logp = (SLlog *)malloc (sizeof (SLlog)); 
     94 
     95    logp->log_print = NULL; 
     96    logp->logprefix = NULL; 
     97    logp->diag_print = NULL; 
     98    logp->errprefix = NULL; 
     99    logp->verbosity = 0; 
     100  } 
    104101  else 
    105     { 
    106       logp = log; 
    107     } 
     102  { 
     103    logp = log; 
     104  } 
    108105 
    109106  sl_loginit_main (logp, verbosity, log_print, logprefix, diag_print, errprefix); 
    110107 
    111108  return logp; 
    112 }  /* End of sl_loginit_rl() */ 
    113  
     109} /* End of sl_loginit_rl() */ 
    114110 
    115111/*************************************************************************** 
     
    136132 ***************************************************************************/ 
    137133void 
    138 sl_loginit_main (SLlog * logp, int verbosity, 
    139                  void (*log_print)(const char*), const char * logprefix, 
    140                  void (*diag_print)(const char*), const char * errprefix) 
    141 { 
    142   if ( ! logp ) 
     134sl_loginit_main (SLlog *logp, int verbosity, 
     135                 void (*log_print) (const char *), const char *logprefix, 
     136                 void (*diag_print) (const char *), const char *errprefix) 
     137{ 
     138  if (!logp) 
    143139    return; 
    144140 
    145141  logp->verbosity = verbosity; 
    146142 
    147   if ( log_print ) 
     143  if (log_print) 
    148144    logp->log_print = log_print; 
    149145 
    150   if ( logprefix ) 
    151     { 
    152       if ( strlen(logprefix) >= MAX_LOG_MSG_LENGTH ) 
    153         { 
    154           sl_log_rl (logp, 2, 0, "log message prefix is too large\n"); 
    155         } 
    156       else 
    157         { 
    158           logp->logprefix = logprefix; 
    159         } 
    160     } 
    161  
    162   if ( diag_print ) 
     146  if (logprefix) 
     147  { 
     148    if (strlen (logprefix) >= MAX_LOG_MSG_LENGTH) 
     149    { 
     150      sl_log_rl (logp, 2, 0, "log message prefix is too large\n"); 
     151    } 
     152    else 
     153    { 
     154      logp->logprefix = logprefix; 
     155    } 
     156  } 
     157 
     158  if (diag_print) 
    163159    logp->diag_print = diag_print; 
    164160 
    165   if ( errprefix ) 
    166     { 
    167       if ( strlen(errprefix) >= MAX_LOG_MSG_LENGTH ) 
    168         { 
    169           sl_log_rl (logp, 2, 0, "error message prefix is too large\n"); 
    170         } 
    171       else 
    172         { 
    173           logp->errprefix = errprefix; 
    174         } 
    175     } 
     161  if (errprefix) 
     162  { 
     163    if (strlen (errprefix) >= MAX_LOG_MSG_LENGTH) 
     164    { 
     165      sl_log_rl (logp, 2, 0, "error message prefix is too large\n"); 
     166    } 
     167    else 
     168    { 
     169      logp->errprefix = errprefix; 
     170    } 
     171  } 
    176172 
    177173  return; 
    178 }  /* End of sl_loginit_main() */ 
    179  
     174} /* End of sl_loginit_main() */ 
    180175 
    181176/*************************************************************************** 
     
    191186  int retval; 
    192187  va_list varlist; 
    193    
     188 
    194189  va_start (varlist, verb); 
    195190 
     
    199194 
    200195  return retval; 
    201 }  /* End of sl_log() */ 
    202  
     196} /* End of sl_log() */ 
    203197 
    204198/*************************************************************************** 
     
    212206 ***************************************************************************/ 
    213207int 
    214 sl_log_r (const SLCD * slconn, int level, int verb, ...) 
     208sl_log_r (const SLCD *slconn, int level, int verb, ...) 
    215209{ 
    216210  int retval; 
     
    218212  SLlog *logp; 
    219213 
    220   if ( ! slconn ) 
     214  if (!slconn) 
    221215    logp = &gSLlog; 
    222   else if ( ! slconn->log ) 
     216  else if (!slconn->log) 
    223217    logp = &gSLlog; 
    224218  else 
    225219    logp = slconn->log; 
    226    
     220 
    227221  va_start (varlist, verb); 
    228    
     222 
    229223  retval = sl_log_main (logp, level, verb, &varlist); 
    230224 
     
    232226 
    233227  return retval; 
    234 }  /* End of sl_log_r() */ 
    235  
     228} /* End of sl_log_r() */ 
    236229 
    237230/*************************************************************************** 
     
    245238 ***************************************************************************/ 
    246239int 
    247 sl_log_rl (SLlog * log, int level, int verb, ...) 
     240sl_log_rl (SLlog *log, int level, int verb, ...) 
    248241{ 
    249242  int retval; 
     
    251244  SLlog *logp; 
    252245 
    253   if ( ! log ) 
     246  if (!log) 
    254247    logp = &gSLlog; 
    255248  else 
    256249    logp = log; 
    257    
     250 
    258251  va_start (varlist, verb); 
    259    
     252 
    260253  retval = sl_log_main (logp, level, verb, &varlist); 
    261254 
     
    263256 
    264257  return retval; 
    265 }  /* End of sl_log_rl() */ 
    266  
     258} /* End of sl_log_rl() */ 
    267259 
    268260/*************************************************************************** 
     
    276268 * The function uses logging parameters specified in the supplied 
    277269 * SLlog. 
    278  *  
     270 * 
    279271 * This function expects 3+ arguments, message level, verbosity level, 
    280272 * fprintf format, and fprintf arguments.  If the verbosity level is 
     
    304296 ***************************************************************************/ 
    305297int 
    306 sl_log_main (SLlog * logp, int level, int verb, va_list * varlist) 
     298sl_log_main (SLlog *logp, int level, int verb, va_list *varlist) 
    307299{ 
    308300  static char message[MAX_LOG_MSG_LENGTH]; 
    309301  int retvalue = 0; 
    310    
     302 
    311303  message[0] = '\0'; 
    312304 
    313305  if (verb <= logp->verbosity) 
    314     { 
    315       int presize; 
    316       const char *format; 
    317  
    318       format = va_arg (*varlist, const char *); 
    319  
    320       if ( level >= 2 ) /* Error message */ 
    321         { 
    322           if ( logp->errprefix != NULL ) 
    323             { 
    324               strncpy (message, logp->errprefix, MAX_LOG_MSG_LENGTH); 
    325             } 
    326           else 
    327             { 
    328               strncpy (message, "error: ", MAX_LOG_MSG_LENGTH); 
    329             } 
    330  
    331           presize = strlen(message); 
    332           retvalue = vsnprintf (&message[presize], 
    333                                 MAX_LOG_MSG_LENGTH - presize, 
    334                                 format, *varlist); 
    335  
    336           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    337  
    338           if ( logp->diag_print != NULL ) 
    339             { 
    340               logp->diag_print ((const char *) message); 
    341             } 
    342           else 
    343             { 
    344               fprintf(stderr, "%s", message); 
    345             } 
    346         } 
    347       else if ( level == 1 ) /* Diagnostic message */ 
    348         { 
    349           if ( logp->logprefix != NULL ) 
    350             { 
    351               strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    352             } 
    353  
    354           presize = strlen(message); 
    355           retvalue = vsnprintf (&message[presize], 
    356                                 MAX_LOG_MSG_LENGTH - presize, 
    357                                 format, *varlist); 
    358  
    359           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    360  
    361           if ( logp->diag_print != NULL ) 
    362             { 
    363               logp->diag_print ((const char *) message); 
    364             } 
    365           else 
    366             { 
    367               fprintf(stderr, "%s", message); 
    368             } 
    369         } 
    370       else if ( level == 0 ) /* Normal log message */ 
    371         { 
    372           if ( logp->logprefix != NULL ) 
    373             { 
    374               strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    375             } 
    376  
    377           presize = strlen(message); 
    378           retvalue = vsnprintf (&message[presize], 
    379                                 MAX_LOG_MSG_LENGTH - presize, 
    380                                 format, *varlist); 
    381  
    382           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    383  
    384           if ( logp->log_print != NULL ) 
    385             { 
    386               logp->log_print ((const char *) message); 
    387             } 
    388           else 
    389             { 
    390               fprintf(stdout, "%s", message); 
    391             } 
    392         } 
    393     } 
     306  { 
     307    int presize; 
     308    const char *format; 
     309 
     310    format = va_arg (*varlist, const char *); 
     311 
     312    if (level >= 2) /* Error message */ 
     313    { 
     314      if (logp->errprefix != NULL) 
     315      { 
     316        strncpy (message, logp->errprefix, MAX_LOG_MSG_LENGTH); 
     317      } 
     318      else 
     319      { 
     320        strncpy (message, "error: ", MAX_LOG_MSG_LENGTH); 
     321      } 
     322 
     323      presize  = strlen (message); 
     324      retvalue = vsnprintf (&message[presize], 
     325                            MAX_LOG_MSG_LENGTH - presize, 
     326                            format, *varlist); 
     327 
     328      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     329 
     330      if (logp->diag_print != NULL) 
     331      { 
     332        logp->diag_print ((const char *)message); 
     333      } 
     334      else 
     335      { 
     336        fprintf (stderr, "%s", message); 
     337      } 
     338    } 
     339    else if (level == 1) /* Diagnostic message */ 
     340    { 
     341      if (logp->logprefix != NULL) 
     342      { 
     343        strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
     344      } 
     345 
     346      presize  = strlen (message); 
     347      retvalue = vsnprintf (&message[presize], 
     348                            MAX_LOG_MSG_LENGTH - presize, 
     349                            format, *varlist); 
     350 
     351      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     352 
     353      if (logp->diag_print != NULL) 
     354      { 
     355        logp->diag_print ((const char *)message); 
     356      } 
     357      else 
     358      { 
     359        fprintf (stderr, "%s", message); 
     360      } 
     361    } 
     362    else if (level == 0) /* Normal log message */ 
     363    { 
     364      if (logp->logprefix != NULL) 
     365      { 
     366        strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
     367      } 
     368 
     369      presize  = strlen (message); 
     370      retvalue = vsnprintf (&message[presize], 
     371                            MAX_LOG_MSG_LENGTH - presize, 
     372                            format, *varlist); 
     373 
     374      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     375 
     376      if (logp->log_print != NULL) 
     377      { 
     378        logp->log_print ((const char *)message); 
     379      } 
     380      else 
     381      { 
     382        fprintf (stdout, "%s", message); 
     383      } 
     384    } 
     385  } 
    394386 
    395387  return retvalue; 
    396 }  /* End of sl_log_main() */ 
     388} /* End of sl_log_main() */ 
  • trunk/src/data_exchange/slink2ew/libslink/msrecord.c

    r4843 r6839  
    1313 * Some ideas and structures were used from seedsniff 2.0 
    1414 * 
    15  * Written by Chad Trabant, ORFEUS/EC-Project MEREDIAN 
    16  * 
    17  * modified: 2012.152 
     15 * Written by Chad Trabant, IRIS Data Managment Center 
     16 * 
     17 * modified: 2016.288 
    1818 ***************************************************************************/ 
    1919 
     
    2626#include "unpack.h" 
    2727 
    28 /* Delcare routines only used in this source file */ 
     28#define SL_ISVALIDYEARDAY(Y, D) (Y >= 1900 && Y <= 2100 && D >= 1 && D <= 366) 
     29 
     30/* Declare routines only used in this source file */ 
    2931void encoding_hash (char enc, char *encstr); 
    30 double host_latency (SLMSrecord * msr); 
    31  
     32double host_latency (SLMSrecord *msr); 
    3233 
    3334/*************************************************************************** 
     
    4041 ***************************************************************************/ 
    4142SLMSrecord * 
    42 sl_msr_new ( void ) 
    43 { 
    44   SLMSrecord * msr; 
    45    
    46   msr = (SLMSrecord *) malloc (sizeof(SLMSrecord)); 
    47    
    48   if ( msr == NULL ) 
    49     { 
    50       sl_log_rl (NULL, 2, 0, "sl_msr_new(): error allocating memory\n"); 
    51       return NULL; 
    52     } 
     43sl_msr_new (void) 
     44{ 
     45  SLMSrecord *msr; 
     46 
     47  msr = (SLMSrecord *)malloc (sizeof (SLMSrecord)); 
     48 
     49  if (msr == NULL) 
     50  { 
     51    sl_log_rl (NULL, 2, 0, "sl_msr_new(): error allocating memory\n"); 
     52    return NULL; 
     53  } 
    5354 
    5455  msr->fsdh.sequence_number[0] = '\0'; 
     
    7677  msr->fsdh.begin_data         = 0; 
    7778  msr->fsdh.begin_blockette    = 0; 
    78    
    79   msr->Blkt100     = NULL; 
    80   msr->Blkt1000    = NULL; 
    81   msr->Blkt1001    = NULL; 
    82    
     79 
     80  msr->Blkt100  = NULL; 
     81  msr->Blkt1000 = NULL; 
     82  msr->Blkt1001 = NULL; 
     83 
    8384  msr->msrecord    = NULL; 
    8485  msr->datasamples = NULL; 
    8586  msr->numsamples  = -1; 
    8687  msr->unpackerr   = MSD_NOERROR; 
    87    
     88 
    8889  return msr; 
    89 }  /* End of sl_msr_new() */ 
    90  
     90} /* End of sl_msr_new() */ 
    9191 
    9292/*************************************************************************** 
     
    9797 ***************************************************************************/ 
    9898void 
    99 sl_msr_free ( SLMSrecord ** msr ) 
    100 { 
    101   if ( msr != NULL && *msr != NULL ) 
    102     { 
    103       free((*msr)->Blkt100); 
    104       free((*msr)->Blkt1000); 
    105       free((*msr)->Blkt1001); 
    106  
    107       if ( (*msr)->datasamples != NULL ) 
    108         free((*msr)->datasamples); 
    109  
    110       free(*msr); 
    111        
    112       *msr = NULL; 
    113     } 
    114 }  /* End of sl_msr_free() */ 
    115  
     99sl_msr_free (SLMSrecord **msr) 
     100{ 
     101  if (msr != NULL && *msr != NULL) 
     102  { 
     103    free ((*msr)->Blkt100); 
     104    free ((*msr)->Blkt1000); 
     105    free ((*msr)->Blkt1001); 
     106 
     107    if ((*msr)->datasamples != NULL) 
     108      free ((*msr)->datasamples); 
     109 
     110    free (*msr); 
     111 
     112    *msr = NULL; 
     113  } 
     114} /* End of sl_msr_free() */ 
     115 
     116/*************************************************************************** 
     117 * sl_littleendianhost: 
     118 * 
     119 * Determine the byte order of the host machine.  Due to the lack of 
     120 * portable defines to determine host byte order this run-time test is 
     121 * provided.  This function originated from a similar function in libmseed. 
     122 * 
     123 * Returns 1 if the host is little endian, otherwise 0. 
     124 ***************************************************************************/ 
     125static uint8_t 
     126sl_littleendianhost (void) 
     127{ 
     128  uint16_t host = 1; 
     129  return *((uint8_t *)(&host)); 
     130} /* End of sl_littleendianhost() */ 
    116131 
    117132/*************************************************************************** 
    118133 * sl_msr_parse: 
    119134 * 
    120  * A wrapper for sl_msr_parse_size()  
     135 * A wrapper for sl_msr_parse_size() 
    121136 ***************************************************************************/ 
    122137SLMSrecord * 
    123 sl_msr_parse (SLlog * log, const char * msrecord, SLMSrecord ** ppmsr, 
    124               int8_t blktflag, int8_t unpackflag) 
     138sl_msr_parse (SLlog *log, const char *msrecord, SLMSrecord **ppmsr, 
     139              int8_t blktflag, int8_t unpackflag) 
    125140{ 
    126141  return sl_msr_parse_size (log, msrecord, ppmsr, blktflag, unpackflag, SLRECSIZE); 
    127142} 
    128  
    129143 
    130144/*************************************************************************** 
     
    162176 ***************************************************************************/ 
    163177SLMSrecord * 
    164 sl_msr_parse_size (SLlog * log, const char * msrecord, SLMSrecord ** ppmsr, 
    165                    int8_t blktflag, int8_t unpackflag, int slrecsize) 
    166 { 
    167   int swapflag = 0;                    /* is swapping needed? */ 
    168   uint16_t begin_blockette;             /* byte offset for next blockette */ 
    169   SLMSrecord * msr = NULL; 
    170  
    171   if ( ppmsr == NULL ) 
    172     { 
    173       sl_log_rl (log, 2, 1, "msr_parse(): pointer to SLMSrecord cannot be NULL\n"); 
    174       *ppmsr = NULL; 
    175       return NULL; 
    176     } 
     178sl_msr_parse_size (SLlog *log, const char *msrecord, SLMSrecord **ppmsr, 
     179                   int8_t blktflag, int8_t unpackflag, int slrecsize) 
     180{ 
     181  uint8_t headerswapflag = 0; /* is swapping needed? */ 
     182  uint8_t dataswapflag   = 0; 
     183  SLMSrecord *msr        = NULL; 
     184 
     185  if (ppmsr == NULL) 
     186  { 
     187    sl_log_rl (log, 2, 1, "msr_parse(): pointer to SLMSrecord cannot be NULL\n"); 
     188    *ppmsr = NULL; 
     189    return NULL; 
     190  } 
    177191  else 
    178     { 
    179       msr = * ppmsr; 
    180     } 
     192  { 
     193    msr = *ppmsr; 
     194  } 
    181195 
    182196  /* If this record is new init a new one otherwise clean it up */ 
    183   if ( msr == NULL ) 
    184     { 
    185       msr = sl_msr_new(); 
    186     } 
     197  if (msr == NULL) 
     198  { 
     199    msr = sl_msr_new (); 
     200  } 
    187201  else 
    188     { 
    189       if ( msr->Blkt100 != NULL ) 
    190         { 
    191           free (msr->Blkt100); 
    192           msr->Blkt100 = NULL; 
    193         } 
    194       if ( msr->Blkt1000 != NULL ) 
    195         { 
    196           free (msr->Blkt1000); 
    197           msr->Blkt1000 = NULL; 
    198         } 
    199  
    200       if ( msr->Blkt1001 != NULL ) 
    201         { 
    202           free (msr->Blkt1001); 
    203           msr->Blkt1001 = NULL; 
    204         } 
    205  
    206       if ( msr->datasamples != NULL ) 
    207         { 
    208           free (msr->datasamples); 
    209           msr->datasamples = NULL; 
    210         } 
    211     } 
     202  { 
     203    if (msr->Blkt100 != NULL) 
     204    { 
     205      free (msr->Blkt100); 
     206      msr->Blkt100 = NULL; 
     207    } 
     208    if (msr->Blkt1000 != NULL) 
     209    { 
     210      free (msr->Blkt1000); 
     211      msr->Blkt1000 = NULL; 
     212    } 
     213 
     214    if (msr->Blkt1001 != NULL) 
     215    { 
     216      free (msr->Blkt1001); 
     217      msr->Blkt1001 = NULL; 
     218    } 
     219 
     220    if (msr->datasamples != NULL) 
     221    { 
     222      free (msr->datasamples); 
     223      msr->datasamples = NULL; 
     224    } 
     225  } 
    212226 
    213227  msr->msrecord = msrecord; 
    214228 
    215229  /* Copy the fixed section into msr */ 
    216   memcpy ((void *) &msr->fsdh, msrecord, 48); 
     230  memcpy ((void *)&msr->fsdh, msrecord, 48); 
    217231 
    218232  /* Sanity check for msr/quality indicator */ 
     
    220234      msr->fsdh.dhq_indicator != 'R' && 
    221235      msr->fsdh.dhq_indicator != 'Q') 
    222     { 
    223       sl_log_rl (log, 2, 0, "record header/quality indicator unrecognized: %c\n", 
    224                  msr->fsdh.dhq_indicator); 
    225       sl_msr_free(&msr); 
    226       *ppmsr = NULL; 
    227       return NULL; 
    228     } 
    229  
    230   /* Check to see if byte swapping is needed (bogus year makes good test) */ 
    231   if ((msr->fsdh.start_time.year < 1900) || 
    232       (msr->fsdh.start_time.year > 2050)) 
    233     swapflag = 1; 
    234    
     236  { 
     237    sl_log_rl (log, 2, 0, "record header/quality indicator unrecognized: %c\n", 
     238               msr->fsdh.dhq_indicator); 
     239    sl_msr_free (&msr); 
     240    *ppmsr = NULL; 
     241    return NULL; 
     242  } 
     243 
     244  /* Check to see if byte swapping is needed by testing the year and day */ 
     245  if (!SL_ISVALIDYEARDAY (msr->fsdh.start_time.year, msr->fsdh.start_time.day)) 
     246    headerswapflag = dataswapflag = 1; 
     247 
    235248  /* Change byte order? */ 
    236   if ( swapflag ) 
    237     { 
    238       SL_SWAPBTIME (&msr->fsdh.start_time); 
    239       sl_gswap2 (&msr->fsdh.num_samples); 
    240       sl_gswap2 (&msr->fsdh.samprate_fact); 
    241       sl_gswap2 (&msr->fsdh.samprate_mult); 
    242       sl_gswap4 (&msr->fsdh.time_correct); 
    243       sl_gswap2 (&msr->fsdh.begin_data); 
    244       sl_gswap2 (&msr->fsdh.begin_blockette); 
    245     } 
     249  if (headerswapflag) 
     250  { 
     251    SL_SWAPBTIME (&msr->fsdh.start_time); 
     252    sl_gswap2 (&msr->fsdh.num_samples); 
     253    sl_gswap2 (&msr->fsdh.samprate_fact); 
     254    sl_gswap2 (&msr->fsdh.samprate_mult); 
     255    sl_gswap4 (&msr->fsdh.time_correct); 
     256    sl_gswap2 (&msr->fsdh.begin_data); 
     257    sl_gswap2 (&msr->fsdh.begin_blockette); 
     258  } 
    246259 
    247260  /* Parse the blockettes if requested */ 
    248   if ( blktflag ) 
    249     { 
    250       /* Define some structures */ 
    251       struct sl_blkt_head_s  *blkt_head; 
    252       struct sl_blkt_100_s   *blkt_100; 
    253       struct sl_blkt_1000_s  *blkt_1000; 
    254       struct sl_blkt_1001_s  *blkt_1001; 
    255        
    256       /* Initialize the blockette structures */ 
    257       blkt_head = (struct sl_blkt_head_s *) malloc (sizeof (struct sl_blkt_head_s)); 
    258       blkt_100  = NULL; 
    259       blkt_1000 = NULL; 
    260       blkt_1001 = NULL; 
    261  
    262       /* loop through blockettes as long as number is non-zero and viable */ 
    263       begin_blockette = msr->fsdh.begin_blockette; 
    264        
    265       while ((begin_blockette != 0) && 
    266              (begin_blockette <= slrecsize)) 
    267         { 
    268            
    269           memcpy ((void *) blkt_head, msrecord + begin_blockette, 
    270                   sizeof (struct sl_blkt_head_s)); 
    271           if ( swapflag ) 
    272             { 
    273               sl_gswap2 (&blkt_head->blkt_type); 
    274               sl_gswap2 (&blkt_head->next_blkt); 
    275             } 
    276  
    277           if (blkt_head->blkt_type == 100) 
    278             {                   /* found a 100 blockette */ 
    279               blkt_100 = (struct sl_blkt_100_s *) malloc (sizeof (struct sl_blkt_100_s)); 
    280               memcpy ((void *) blkt_100, msrecord + begin_blockette, 
    281                       sizeof (struct sl_blkt_100_s)); 
    282                
    283               if ( swapflag ) 
    284                 { 
    285                   sl_gswap4 (&blkt_100->sample_rate); 
    286                 } 
    287                
    288               blkt_100->blkt_type = blkt_head->blkt_type; 
    289               blkt_100->next_blkt = blkt_head->next_blkt; 
    290                
    291               msr->Blkt100 = blkt_100; 
    292             } 
    293            
    294           if (blkt_head->blkt_type == 1000) 
    295              
    296             {                   /* found the 1000 blockette */ 
    297               blkt_1000 = 
    298                 (struct sl_blkt_1000_s *) malloc (sizeof (struct sl_blkt_1000_s)); 
    299               memcpy ((void *) blkt_1000, msrecord + begin_blockette, 
    300                       sizeof (struct sl_blkt_1000_s)); 
    301                
    302               blkt_1000->blkt_type = blkt_head->blkt_type; 
    303               blkt_1000->next_blkt = blkt_head->next_blkt; 
    304                
    305               msr->Blkt1000 = blkt_1000; 
    306             } 
    307            
    308           if (blkt_head->blkt_type == 1001) 
    309             {                   /* found a 1001 blockette */ 
    310               blkt_1001 = 
    311                 (struct sl_blkt_1001_s *) malloc (sizeof (struct sl_blkt_1001_s)); 
    312               memcpy ((void *) blkt_1001, msrecord + begin_blockette, 
    313                       sizeof (struct sl_blkt_1001_s)); 
    314                
    315               blkt_1001->blkt_type = blkt_head->blkt_type; 
    316               blkt_1001->next_blkt = blkt_head->next_blkt; 
    317                
    318               msr->Blkt1001 = blkt_1001; 
    319             } 
    320            
    321           /* Point to the next blockette */ 
    322           begin_blockette = blkt_head->next_blkt; 
    323         }                               /* End of while looping through blockettes */ 
    324        
    325       if (blkt_1000 == NULL) 
    326         { 
    327           sl_log_rl (log, 1, 0, "1000 blockette was NOT found for %s.%s.%s.%s!", 
    328                      msr->fsdh.network, msr->fsdh.station, 
    329                      msr->fsdh.location, msr->fsdh.channel); 
    330         } 
    331        
    332       free (blkt_head); 
    333     } 
     261  if (blktflag) 
     262  { 
     263    /* Define some structures */ 
     264    struct sl_blkt_head_s *blkt_head; 
     265    struct sl_blkt_100_s *blkt_100; 
     266    struct sl_blkt_1000_s *blkt_1000; 
     267    struct sl_blkt_1001_s *blkt_1001; 
     268    uint16_t begin_blockette; /* byte offset for next blockette */ 
     269 
     270    /* Initialize the blockette structures */ 
     271    blkt_head = (struct sl_blkt_head_s *)malloc (sizeof (struct sl_blkt_head_s)); 
     272    blkt_100  = NULL; 
     273    blkt_1000 = NULL; 
     274    blkt_1001 = NULL; 
     275 
     276    /* loop through blockettes as long as number is non-zero and viable */ 
     277    begin_blockette = msr->fsdh.begin_blockette; 
     278 
     279    while ((begin_blockette != 0) && 
     280           (begin_blockette <= slrecsize)) 
     281    { 
     282 
     283      memcpy ((void *)blkt_head, msrecord + begin_blockette, 
     284              sizeof (struct sl_blkt_head_s)); 
     285      if (headerswapflag) 
     286      { 
     287        sl_gswap2 (&blkt_head->blkt_type); 
     288        sl_gswap2 (&blkt_head->next_blkt); 
     289      } 
     290 
     291      if (blkt_head->blkt_type == 100) 
     292      { /* found a 100 blockette */ 
     293        blkt_100 = (struct sl_blkt_100_s *)malloc (sizeof (struct sl_blkt_100_s)); 
     294        memcpy ((void *)blkt_100, msrecord + begin_blockette, 
     295                sizeof (struct sl_blkt_100_s)); 
     296 
     297        if (headerswapflag) 
     298        { 
     299          sl_gswap4 (&blkt_100->sample_rate); 
     300        } 
     301 
     302        blkt_100->blkt_type = blkt_head->blkt_type; 
     303        blkt_100->next_blkt = blkt_head->next_blkt; 
     304 
     305        msr->Blkt100 = blkt_100; 
     306      } 
     307 
     308      if (blkt_head->blkt_type == 1000) 
     309 
     310      { /* found the 1000 blockette */ 
     311        blkt_1000 = 
     312            (struct sl_blkt_1000_s *)malloc (sizeof (struct sl_blkt_1000_s)); 
     313        memcpy ((void *)blkt_1000, msrecord + begin_blockette, 
     314                sizeof (struct sl_blkt_1000_s)); 
     315 
     316        blkt_1000->blkt_type = blkt_head->blkt_type; 
     317        blkt_1000->next_blkt = blkt_head->next_blkt; 
     318 
     319        msr->Blkt1000 = blkt_1000; 
     320      } 
     321 
     322      if (blkt_head->blkt_type == 1001) 
     323      { /* found a 1001 blockette */ 
     324        blkt_1001 = 
     325            (struct sl_blkt_1001_s *)malloc (sizeof (struct sl_blkt_1001_s)); 
     326        memcpy ((void *)blkt_1001, msrecord + begin_blockette, 
     327                sizeof (struct sl_blkt_1001_s)); 
     328 
     329        blkt_1001->blkt_type = blkt_head->blkt_type; 
     330        blkt_1001->next_blkt = blkt_head->next_blkt; 
     331 
     332        msr->Blkt1001 = blkt_1001; 
     333      } 
     334 
     335      /* Point to the next blockette */ 
     336      begin_blockette = blkt_head->next_blkt; 
     337    } /* End of while looping through blockettes */ 
     338 
     339    if (blkt_1000 == NULL) 
     340    { 
     341      sl_log_rl (log, 1, 0, "1000 blockette was NOT found for %s.%s.%s.%s!", 
     342                 msr->fsdh.network, msr->fsdh.station, 
     343                 msr->fsdh.location, msr->fsdh.channel); 
     344    } 
     345    else 
     346    { 
     347      /* no byte swapping of data if little-endian host and little-endian data */ 
     348      if (sl_littleendianhost () && blkt_1000->word_swap == 0) 
     349        dataswapflag = 0; 
     350      /* no byte swapping of data if big-endian host and big-endian data */ 
     351      else if (!sl_littleendianhost () && blkt_1000->word_swap == 1) 
     352        dataswapflag = 0; 
     353    } 
     354 
     355    free (blkt_head); 
     356  } 
    334357 
    335358  /* Unpack the data samples if requested */ 
    336   if ( unpackflag ) 
    337     { 
    338       msr->numsamples = sl_msr_unpack (log, msr, swapflag); 
    339     } 
    340   else { 
     359  if (unpackflag) 
     360  { 
     361    msr->numsamples = sl_msr_unpack (log, msr, dataswapflag); 
     362  } 
     363  else 
     364  { 
    341365    msr->numsamples = -1; 
    342366  } 
     
    345369  *ppmsr = msr; 
    346370  return msr; 
    347 }  /* End of sl_msr_parse() */ 
    348  
     371} /* End of sl_msr_parse_size() */ 
    349372 
    350373/*************************************************************************** 
     
    358381 ***************************************************************************/ 
    359382int 
    360 sl_msr_print (SLlog * log, SLMSrecord * msr, int details) 
     383sl_msr_print (SLlog *log, SLMSrecord *msr, int details) 
    361384{ 
    362385  char sourcename[50]; 
    363   char prtnet[4], prtsta[7]; 
    364   char prtloc[4], prtchan[5]; 
    365386  char stime[25]; 
    366387  double latency; 
     
    368389  int usec; 
    369390 
    370   /* Generate clean identifier strings */ 
    371   sl_strncpclean (prtnet, msr->fsdh.network, 2); 
    372   sl_strncpclean (prtsta, msr->fsdh.station, 5); 
    373   sl_strncpclean (prtloc, msr->fsdh.location, 2); 
    374   sl_strncpclean (prtchan, msr->fsdh.channel, 3); 
    375  
    376   if (prtnet[0] != '\0') 
    377     strcat (prtnet, "_"); 
    378   if (prtsta[0] != '\0') 
    379     strcat (prtsta, "_"); 
    380   if (prtloc[0] != '\0') 
    381     strcat (prtloc, "_"); 
    382  
    383391  /* Build the source name string */ 
    384   sprintf (sourcename, "%.3s%.6s%.3s%.3s", prtnet, prtsta, prtloc, prtchan); 
     392  sl_msr_srcname (msr, sourcename, 0); 
    385393 
    386394  usec = msr->fsdh.start_time.fract * 100; 
    387    
    388   if ( msr->Blkt1001 ) 
    389     { 
    390       usec += msr->Blkt1001->usec; 
    391        
    392       if ( usec > 1000000 || usec < 0 ) 
    393         { 
    394           sl_log_rl (log, 1, 0, "Cannot apply microsecond offset\n"); 
    395           usec -= msr->Blkt1001->usec; 
    396         } 
    397     } 
     395 
     396  if (msr->Blkt1001) 
     397  { 
     398    usec += msr->Blkt1001->usec; 
     399 
     400    if (usec > 1000000 || usec < 0) 
     401    { 
     402      sl_log_rl (log, 1, 0, "Cannot apply microsecond offset\n"); 
     403      usec -= msr->Blkt1001->usec; 
     404    } 
     405  } 
    398406 
    399407  /* Build a start time string */ 
    400   snprintf (stime, sizeof(stime), "%04d,%03d,%02d:%02d:%02d.%06d", 
    401             msr->fsdh.start_time.year, msr->fsdh.start_time.day, 
    402             msr->fsdh.start_time.hour, msr->fsdh.start_time.min, 
    403             msr->fsdh.start_time.sec, usec); 
    404    
     408  snprintf (stime, sizeof (stime), "%04d,%03d,%02d:%02d:%02d.%06d", 
     409            msr->fsdh.start_time.year, msr->fsdh.start_time.day, 
     410            msr->fsdh.start_time.hour, msr->fsdh.start_time.min, 
     411            msr->fsdh.start_time.sec, usec); 
     412 
    405413  /* Calculate the latency */ 
    406414  latency = host_latency (msr); 
    407    
     415 
    408416  /* Report information in the fixed header */ 
    409417  if (details > 0) 
    410     { 
    411       dsamprate = sl_msr_dnomsamprate(msr); 
    412       sl_log_rl (log, 0, 0, "                 source: %s\n", sourcename); 
    413       sl_log_rl (log, 0, 0, "             start time: %s  (latency ~%1.1f sec)\n", 
    414                 stime, latency); 
    415       sl_log_rl (log, 0, 0, "      number of samples: %d\n", msr->fsdh.num_samples); 
    416       sl_log_rl (log, 0, 0, "     sample rate factor: %d\n", msr->fsdh.samprate_fact); 
    417       sl_log_rl (log, 0, 0, " sample rate multiplier: %d  (%.10g samples per second)\n", 
    418                 msr->fsdh.samprate_mult, dsamprate); 
    419       sl_log_rl (log, 0, 0, "     num. of blockettes: %d\n", 
    420                 msr->fsdh.num_blockettes); 
    421       sl_log_rl (log, 0, 0, "        time correction: %ld\n", 
    422                 msr->fsdh.time_correct); 
    423       sl_log_rl (log, 0, 0, "      begin data offset: %d\n", msr->fsdh.begin_data); 
    424       sl_log_rl (log, 0, 0, "  fist blockette offset: %d\n", 
    425                 msr->fsdh.begin_blockette); 
    426     } 
     418  { 
     419    dsamprate = sl_msr_dnomsamprate (msr); 
     420    sl_log_rl (log, 0, 0, "                 source: %s\n", sourcename); 
     421    sl_log_rl (log, 0, 0, "             start time: %s  (latency ~%1.1f sec)\n", 
     422              stime, latency); 
     423    sl_log_rl (log, 0, 0, "      number of samples: %d\n", msr->fsdh.num_samples); 
     424    sl_log_rl (log, 0, 0, "     sample rate factor: %d\n", msr->fsdh.samprate_fact); 
     425    sl_log_rl (log, 0, 0, " sample rate multiplier: %d  (%.10g samples per second)\n", 
     426              msr->fsdh.samprate_mult, dsamprate); 
     427    sl_log_rl (log, 0, 0, "     num. of blockettes: %d\n", 
     428              msr->fsdh.num_blockettes); 
     429    sl_log_rl (log, 0, 0, "        time correction: %ld\n", 
     430              msr->fsdh.time_correct); 
     431    sl_log_rl (log, 0, 0, "      begin data offset: %d\n", msr->fsdh.begin_data); 
     432    sl_log_rl (log, 0, 0, "  fist blockette offset: %d\n", 
     433              msr->fsdh.begin_blockette); 
     434  } 
    427435  else 
    428     { 
    429       sl_msr_dsamprate (msr, &dsamprate); 
    430       sl_log_rl (log, 0, 0, "%s, %d samples, %.10g Hz, %s (latency ~%1.1f sec)\n", 
    431                 sourcename, msr->fsdh.num_samples, dsamprate, stime, latency); 
    432     } 
     436  { 
     437    sl_msr_dsamprate (msr, &dsamprate); 
     438    sl_log_rl (log, 0, 0, "%s, %d samples, %.10g Hz, %s (latency ~%1.1f sec)\n", 
     439              sourcename, msr->fsdh.num_samples, dsamprate, stime, latency); 
     440  } 
    433441 
    434442  if (details > 0) 
    435     { 
    436       if ( msr->Blkt100 != NULL ) 
    437         { 
    438           sl_log_rl (log, 0, 0, "          BLOCKETTE 100:\n"); 
    439           sl_log_rl (log, 0, 0, "              next blockette: %d\n", 
    440                      msr->Blkt100->next_blkt); 
    441           sl_log_rl (log, 0, 0, "          actual sample rate: %.4f\n", 
    442                      msr->Blkt100->sample_rate); 
    443           sl_log_rl (log, 0, 0, "                       flags: %d\n", 
    444                      msr->Blkt100->flags); 
    445         } 
    446        
    447       if ( msr->Blkt1000 != NULL ) 
    448         { 
    449           int reclen; 
    450           char order[40]; 
    451           char encstr[100]; 
    452  
    453           encoding_hash (msr->Blkt1000->encoding, &encstr[0]); 
    454            
    455           /* Calculate record size in bytes as 2^(Blkt1000->rec_len) */ 
    456           reclen = (unsigned int) 1 << msr->Blkt1000->rec_len; 
    457            
    458           /* Big or little endian reported by the 1000 blockette? */ 
    459           if (msr->Blkt1000->word_swap == 0) 
    460             strncpy (order, "Little endian (Intel/VAX)", sizeof(order)-1); 
    461           else if (msr->Blkt1000->word_swap == 1) 
    462             strncpy (order, "Big endian (SPARC/Motorola)", sizeof(order)-1); 
    463           else 
    464             strncpy (order, "Unknown value", sizeof(order)-1); 
    465            
    466           sl_log_rl (log, 0, 0, "         BLOCKETTE 1000:\n"); 
    467           sl_log_rl (log, 0, 0, "              next blockette: %d\n", 
    468                      msr->Blkt1000->next_blkt); 
    469           sl_log_rl (log, 0, 0, "                    encoding: %s\n", encstr); 
    470           sl_log_rl (log, 0, 0, "                  byte order: %s\n", order); 
    471           sl_log_rl (log, 0, 0, "               record length: %d (val:%d)\n", 
    472                      reclen, msr->Blkt1000->rec_len); 
    473           sl_log_rl (log, 0, 0, "                    reserved: %d\n", 
    474                      msr->Blkt1000->reserved); 
    475         } 
    476        
    477       if ( msr->Blkt1001 != NULL ) 
    478         { 
    479           sl_log_rl (log, 0, 0, "         BLOCKETTE 1001:\n"); 
    480           sl_log_rl (log, 0, 0, "              next blockette: %d\n", 
    481                      msr->Blkt1001->next_blkt); 
    482           sl_log_rl (log, 0, 0, "              timing quality: %d%%\n", 
    483                      msr->Blkt1001->timing_qual); 
    484           sl_log_rl (log, 0, 0, "                micro second: %d\n", 
    485                      msr->Blkt1001->usec); 
    486           sl_log_rl (log, 0, 0, "                    reserved: %d\n", 
    487                      msr->Blkt1001->reserved); 
    488           sl_log_rl (log, 0, 0, "                 frame count: %d\n", 
    489                      msr->Blkt1001->frame_cnt); 
    490         } 
    491     } 
    492    
     443  { 
     444    if (msr->Blkt100 != NULL) 
     445    { 
     446      sl_log_rl (log, 0, 0, "          BLOCKETTE 100:\n"); 
     447      sl_log_rl (log, 0, 0, "              next blockette: %d\n", 
     448                 msr->Blkt100->next_blkt); 
     449      sl_log_rl (log, 0, 0, "          actual sample rate: %.4f\n", 
     450                 msr->Blkt100->sample_rate); 
     451      sl_log_rl (log, 0, 0, "                       flags: %d\n", 
     452                 msr->Blkt100->flags); 
     453    } 
     454 
     455    if (msr->Blkt1000 != NULL) 
     456    { 
     457      int reclen; 
     458      char order[40]; 
     459      char encstr[100]; 
     460 
     461      encoding_hash (msr->Blkt1000->encoding, &encstr[0]); 
     462 
     463      /* Calculate record size in bytes as 2^(Blkt1000->rec_len) */ 
     464      reclen = (unsigned int)1 << msr->Blkt1000->rec_len; 
     465 
     466      /* Big or little endian reported by the 1000 blockette? */ 
     467      if (msr->Blkt1000->word_swap == 0) 
     468        strncpy (order, "Little endian (Intel/VAX)", sizeof (order) - 1); 
     469      else if (msr->Blkt1000->word_swap == 1) 
     470        strncpy (order, "Big endian (SPARC/Motorola)", sizeof (order) - 1); 
     471      else 
     472        strncpy (order, "Unknown value", sizeof (order) - 1); 
     473 
     474      sl_log_rl (log, 0, 0, "         BLOCKETTE 1000:\n"); 
     475      sl_log_rl (log, 0, 0, "              next blockette: %d\n", 
     476                 msr->Blkt1000->next_blkt); 
     477      sl_log_rl (log, 0, 0, "                    encoding: %s\n", encstr); 
     478      sl_log_rl (log, 0, 0, "                  byte order: %s\n", order); 
     479      sl_log_rl (log, 0, 0, "               record length: %d (val:%d)\n", 
     480                 reclen, msr->Blkt1000->rec_len); 
     481      sl_log_rl (log, 0, 0, "                    reserved: %d\n", 
     482                 msr->Blkt1000->reserved); 
     483    } 
     484 
     485    if (msr->Blkt1001 != NULL) 
     486    { 
     487      sl_log_rl (log, 0, 0, "         BLOCKETTE 1001:\n"); 
     488      sl_log_rl (log, 0, 0, "              next blockette: %d\n", 
     489                 msr->Blkt1001->next_blkt); 
     490      sl_log_rl (log, 0, 0, "              timing quality: %d%%\n", 
     491                 msr->Blkt1001->timing_qual); 
     492      sl_log_rl (log, 0, 0, "                micro second: %d\n", 
     493                 msr->Blkt1001->usec); 
     494      sl_log_rl (log, 0, 0, "                    reserved: %d\n", 
     495                 msr->Blkt1001->reserved); 
     496      sl_log_rl (log, 0, 0, "                 frame count: %d\n", 
     497                 msr->Blkt1001->frame_cnt); 
     498    } 
     499  } 
     500 
    493501  return 1; 
    494 }  /* End of sl_msr_print() */ 
    495  
     502} /* End of sl_msr_print() */ 
     503 
     504/*************************************************************************** 
     505 * sl_ms_srcname: 
     506 * 
     507 * Generate a source name string for a specified raw data record in 
     508 * the format: 'NET_STA_LOC_CHAN' or, if the quality flag is true: 
     509 * 'NET_STA_LOC_CHAN_QUAL'.  The passed srcname must have enough room 
     510 * for the resulting string. 
     511 * 
     512 * Returns a pointer to the resulting string or NULL on error. 
     513 ***************************************************************************/ 
     514char * 
     515sl_msr_srcname (SLMSrecord *msr, char *srcname, int8_t quality) 
     516{ 
     517  char network[8]; 
     518  char station[8]; 
     519  char location[8]; 
     520  char channel[8]; 
     521 
     522  if (!msr) 
     523    return NULL; 
     524 
     525  sl_strncpclean (network, msr->fsdh.network, 2); 
     526  sl_strncpclean (station, msr->fsdh.station, 5); 
     527  sl_strncpclean (location, msr->fsdh.location, 2); 
     528  sl_strncpclean (channel, msr->fsdh.channel, 3); 
     529 
     530  /* Build the source name string including the quality indicator*/ 
     531  if (quality) 
     532    sprintf (srcname, "%s_%s_%s_%s_%c", 
     533             network, station, location, channel, msr->fsdh.dhq_indicator); 
     534 
     535  /* Build the source name string without the quality indicator*/ 
     536  else 
     537    sprintf (srcname, "%s_%s_%s_%s", network, station, location, channel); 
     538 
     539  return srcname; 
     540} /* End of sl_msr_srcname() */ 
    496541 
    497542/*************************************************************************** 
     
    509554 ***************************************************************************/ 
    510555int 
    511 sl_msr_dsamprate (SLMSrecord * msr, double * samprate) 
    512 { 
    513   if ( ! msr ) 
     556sl_msr_dsamprate (SLMSrecord *msr, double *samprate) 
     557{ 
     558  if (!msr) 
    514559    return 0; 
    515560 
    516   if ( msr->Blkt100 ) 
    517     { 
    518       *samprate = (double) msr->Blkt100->sample_rate; 
    519       return 1; 
    520     } 
     561  if (msr->Blkt100) 
     562  { 
     563    *samprate = (double)msr->Blkt100->sample_rate; 
     564    return 1; 
     565  } 
    521566  else 
    522     { 
    523       *samprate = sl_msr_dnomsamprate(msr); 
    524        
    525       if ( *samprate == -1.0 ) 
    526         return 0; 
    527        
    528       return 2; 
    529     } 
    530 }  /* End of sl_msr_dsamprate() */ 
    531  
     567  { 
     568    *samprate = sl_msr_dnomsamprate (msr); 
     569 
     570    if (*samprate == -1.0) 
     571      return 0; 
     572 
     573    return 2; 
     574  } 
     575} /* End of sl_msr_dsamprate() */ 
    532576 
    533577/*************************************************************************** 
     
    541585 ***************************************************************************/ 
    542586double 
    543 sl_msr_dnomsamprate (SLMSrecord * msr) 
     587sl_msr_dnomsamprate (SLMSrecord *msr) 
    544588{ 
    545589  double srcalc = 0.0; 
    546590  int factor; 
    547591  int multiplier; 
    548    
    549   if ( ! msr ) 
     592 
     593  if (!msr) 
    550594    return -1.0; 
    551    
    552   /* Calculate the nominal sample rate */   
    553   factor = msr->fsdh.samprate_fact; 
     595 
     596  /* Calculate the nominal sample rate */ 
     597  factor     = msr->fsdh.samprate_fact; 
    554598  multiplier = msr->fsdh.samprate_mult; 
    555    
    556   if ( factor > 0 ) 
    557     srcalc = (double) factor; 
    558   else if ( factor < 0 ) 
    559     srcalc = -1.0 / (double) factor; 
    560    
    561   if ( multiplier > 0 ) 
    562     srcalc = srcalc * (double) multiplier; 
    563   else if ( multiplier < 0 ) 
    564     srcalc = -1.0 * (srcalc / (double) multiplier); 
    565    
     599 
     600  if (factor > 0) 
     601    srcalc = (double)factor; 
     602  else if (factor < 0) 
     603    srcalc = -1.0 / (double)factor; 
     604 
     605  if (multiplier > 0) 
     606    srcalc = srcalc * (double)multiplier; 
     607  else if (multiplier < 0) 
     608    srcalc = -1.0 * (srcalc / (double)multiplier); 
     609 
    566610  return srcalc; 
    567 }  /* End of sl_msr_dnomsamprate() */ 
    568  
     611} /* End of sl_msr_dnomsamprate() */ 
    569612 
    570613/*************************************************************************** 
     
    578621 ***************************************************************************/ 
    579622double 
    580 sl_msr_depochstime (SLMSrecord * msr) 
     623sl_msr_depochstime (SLMSrecord *msr) 
    581624{ 
    582625  struct sl_btime_s *btime; 
    583626  double dtime; 
    584    
    585   if ( ! msr ) 
     627 
     628  if (!msr) 
    586629    return 0; 
    587    
     630 
    588631  btime = &msr->fsdh.start_time; 
    589    
    590   dtime = (double) (btime->year - 1970) * 31536000 + 
    591                    ((btime->year - 1969) / 4) * 86400 + 
    592                    (btime->day - 1) * 86400 + 
    593                    btime->hour * 3600 + 
    594                    btime->min * 60 + 
    595                    btime->sec + 
    596                    (double) btime->fract / 10000.0; 
    597  
    598   if ( msr->Blkt1001 ) 
    599     { 
    600       dtime += msr->Blkt1001->usec / 1000000; 
    601     } 
    602    
     632 
     633  dtime = (double)(btime->year - 1970) * 31536000 + 
     634          ((btime->year - 1969) / 4) * 86400 + 
     635          (btime->day - 1) * 86400 + 
     636          btime->hour * 3600 + 
     637          btime->min * 60 + 
     638          btime->sec + 
     639          (double)btime->fract / 10000.0; 
     640 
     641  if (msr->Blkt1001) 
     642  { 
     643    dtime += msr->Blkt1001->usec / 1000000; 
     644  } 
     645 
    603646  return dtime; 
    604 }  /* End of sl_msr_depochstime() */ 
    605  
     647} /* End of sl_msr_depochstime() */ 
    606648 
    607649/*************************************************************************** 
     
    614656{ 
    615657  switch (enc) 
    616     { 
    617     case 0: 
    618       strcpy (encstr, "ASCII text (val:0)"); 
    619       break; 
    620     case 1: 
    621       strcpy (encstr, "16 bit integers (val:1)"); 
    622       break; 
    623     case 2: 
    624       strcpy (encstr, "24 bit integers (val:2)"); 
    625       break; 
    626     case 3: 
    627       strcpy (encstr, "32 bit integers (val:3)"); 
    628       break; 
    629     case 4: 
    630       strcpy (encstr, "IEEE floating point (val:4)"); 
    631       break; 
    632     case 5: 
    633       strcpy (encstr, "IEEE double precision float (val:5)"); 
    634       break; 
    635     case 10: 
    636       strcpy (encstr, "STEIM 1 Compression (val:10)"); 
    637       break; 
    638     case 11: 
    639       strcpy (encstr, "STEIM 2 Compression (val:11)"); 
    640       break; 
    641     case 12: 
    642       strcpy (encstr, "GEOSCOPE Muxed 24 bit int (val:12)"); 
    643       break; 
    644     case 13: 
    645       strcpy (encstr, "GEOSCOPE Muxed 16/3 bit gain/exp (val:13)"); 
    646       break; 
    647     case 14: 
    648       strcpy (encstr, "GEOSCOPE Muxed 16/4 bit gain/exp (val:14)"); 
    649       break; 
    650     case 15: 
    651       strcpy (encstr, "US National Network compression (val:15)"); 
    652       break; 
    653     case 16: 
    654       strcpy (encstr, "CDSN 16 bit gain ranged (val:16)"); 
    655       break; 
    656     case 17: 
    657       strcpy (encstr, "Graefenberg 16 bit gain ranged (val:17)"); 
    658       break; 
    659     case 18: 
    660       strcpy (encstr, "IPG - Strasbourg 16 bit gain (val:18)"); 
    661       break; 
    662     case 19: 
    663       strcpy (encstr, "STEIM 3 Compression (val:19)"); 
    664       break; 
    665     case 30: 
    666       strcpy (encstr, "SRO Format (val:30)"); 
    667       break; 
    668     case 31: 
    669       strcpy (encstr, "HGLP Format (val:31)"); 
    670       break; 
    671     case 32: 
    672       strcpy (encstr, "DWWSSN Gain Ranged Format (val:32)"); 
    673       break; 
    674     case 33: 
    675       strcpy (encstr, "RSTN 16 bit gain ranged (val:33)"); 
    676       break; 
    677     default: 
    678       sprintf (encstr, "Unknown format code: (%d)", enc); 
    679     }                           /* end switch */ 
    680  
    681 }  /* End of encoding_hash() */ 
    682  
     658  { 
     659  case 0: 
     660    strcpy (encstr, "ASCII text (val:0)"); 
     661    break; 
     662  case 1: 
     663    strcpy (encstr, "16 bit integers (val:1)"); 
     664    break; 
     665  case 2: 
     666    strcpy (encstr, "24 bit integers (val:2)"); 
     667    break; 
     668  case 3: 
     669    strcpy (encstr, "32 bit integers (val:3)"); 
     670    break; 
     671  case 4: 
     672    strcpy (encstr, "IEEE floating point (val:4)"); 
     673    break; 
     674  case 5: 
     675    strcpy (encstr, "IEEE double precision float (val:5)"); 
     676    break; 
     677  case 10: 
     678    strcpy (encstr, "STEIM 1 Compression (val:10)"); 
     679    break; 
     680  case 11: 
     681    strcpy (encstr, "STEIM 2 Compression (val:11)"); 
     682    break; 
     683  case 12: 
     684    strcpy (encstr, "GEOSCOPE Muxed 24 bit int (val:12)"); 
     685    break; 
     686  case 13: 
     687    strcpy (encstr, "GEOSCOPE Muxed 16/3 bit gain/exp (val:13)"); 
     688    break; 
     689  case 14: 
     690    strcpy (encstr, "GEOSCOPE Muxed 16/4 bit gain/exp (val:14)"); 
     691    break; 
     692  case 15: 
     693    strcpy (encstr, "US National Network compression (val:15)"); 
     694    break; 
     695  case 16: 
     696    strcpy (encstr, "CDSN 16 bit gain ranged (val:16)"); 
     697    break; 
     698  case 17: 
     699    strcpy (encstr, "Graefenberg 16 bit gain ranged (val:17)"); 
     700    break; 
     701  case 18: 
     702    strcpy (encstr, "IPG - Strasbourg 16 bit gain (val:18)"); 
     703    break; 
     704  case 19: 
     705    strcpy (encstr, "STEIM 3 Compression (val:19)"); 
     706    break; 
     707  case 30: 
     708    strcpy (encstr, "SRO Format (val:30)"); 
     709    break; 
     710  case 31: 
     711    strcpy (encstr, "HGLP Format (val:31)"); 
     712    break; 
     713  case 32: 
     714    strcpy (encstr, "DWWSSN Gain Ranged Format (val:32)"); 
     715    break; 
     716  case 33: 
     717    strcpy (encstr, "RSTN 16 bit gain ranged (val:33)"); 
     718    break; 
     719  default: 
     720    sprintf (encstr, "Unknown format code: (%d)", enc); 
     721  } /* end switch */ 
     722 
     723} /* End of encoding_hash() */ 
    683724 
    684725/*************************************************************************** 
     
    695736host_latency (SLMSrecord *msr) 
    696737{ 
    697   double dsamprate = 0.0;       /* Nominal sampling rate */ 
    698   double span = 0.0;            /* Time covered by the samples */ 
    699   double epoch;                 /* Current epoch time */ 
    700   double sepoch;                /* Epoch time of the record start time */ 
     738  double dsamprate = 0.0; /* Nominal sampling rate */ 
     739  double span      = 0.0; /* Time covered by the samples */ 
     740  double epoch;           /* Current epoch time */ 
     741  double sepoch;          /* Epoch time of the record start time */ 
    701742  double latency = 0.0; 
    702743 
    703744  sl_msr_dsamprate (msr, &dsamprate); 
    704      
     745 
    705746  /* Calculate the time covered by the samples */ 
    706   if ( dsamprate ) 
    707     span = (double) msr->fsdh.num_samples * (1.0 / dsamprate); 
    708    
     747  if (dsamprate) 
     748    span = (double)msr->fsdh.num_samples * (1.0 / dsamprate); 
     749 
    709750  /* Grab UTC time according to the system clock */ 
    710   epoch = sl_dtime(); 
    711    
     751  epoch = sl_dtime (); 
     752 
    712753  /* Now calculate the latency */ 
    713   sepoch = sl_msr_depochstime(msr); 
     754  sepoch  = sl_msr_depochstime (msr); 
    714755  latency = epoch - sepoch - span; 
    715    
     756 
    716757  return latency; 
    717 }  /* End of host_latency() */ 
     758} /* End of host_latency() */ 
  • trunk/src/data_exchange/slink2ew/libslink/network.c

    r4078 r6839  
    55 * Network communication routines for SeedLink 
    66 * 
    7  * Written by Chad Trabant,  
     7 * Written by Chad Trabant, 
    88 *   ORFEUS/EC-Project MEREDIAN (previously) 
    99 *   IRIS Data Management Center 
     
    1212 * SeisComP written by Andres Heinloo 
    1313 * 
    14  * Version: 2010.075 
     14 * Version: 2016.288 
    1515 ***************************************************************************/ 
    1616 
     
    2222 
    2323/* Functions only used in this source file */ 
    24 int sl_sayhello (SLCD * slconn); 
    25 int sl_batchmode (SLCD * slconn); 
    26 int sl_negotiate_uni (SLCD * slconn); 
    27 int sl_negotiate_multi (SLCD * slconn); 
    28  
     24int sl_sayhello (SLCD *slconn); 
     25int sl_batchmode (SLCD *slconn); 
     26int sl_negotiate_uni (SLCD *slconn); 
     27int sl_negotiate_multi (SLCD *slconn); 
    2928 
    3029/*************************************************************************** 
     
    3938 ***************************************************************************/ 
    4039int 
    41 sl_configlink (SLCD * slconn) 
     40sl_configlink (SLCD *slconn) 
    4241{ 
    4342  int ret = -1; 
    4443 
    4544  if (slconn->multistation) 
    46     { 
    47       if (sl_checkversion (slconn, 2.5) >= 0) 
    48         { 
    49           ret = sl_negotiate_multi (slconn); 
    50         } 
    51       else 
    52         { 
    53           sl_log_r (slconn, 2, 0, 
    54                     "[%s] detected  SeedLink version (%.3f) does not support multi-station protocol\n", 
    55                     slconn->sladdr, slconn->protocol_ver); 
    56           ret = -1; 
    57         } 
    58     } 
     45  { 
     46    if (sl_checkversion (slconn, 2.5) >= 0) 
     47    { 
     48      ret = sl_negotiate_multi (slconn); 
     49    } 
     50    else 
     51    { 
     52      sl_log_r (slconn, 2, 0, 
     53                "[%s] detected  SeedLink version (%.3f) does not support multi-station protocol\n", 
     54                slconn->sladdr, slconn->protocol_ver); 
     55      ret = -1; 
     56    } 
     57  } 
    5958  else 
    6059    ret = sl_negotiate_uni (slconn); 
    6160 
    6261  return ret; 
    63 }  /* End of sl_configlink() */ 
    64  
     62} /* End of sl_configlink() */ 
    6563 
    6664/*************************************************************************** 
     
    8078 ***************************************************************************/ 
    8179int 
    82 sl_negotiate_uni (SLCD * slconn) 
     80sl_negotiate_uni (SLCD *slconn) 
    8381{ 
    84   int sellen = 0; 
     82  int sellen    = 0; 
    8583  int bytesread = 0; 
    86   int acceptsel = 0;            /* Count of accepted selectors */ 
     84  int acceptsel = 0; /* Count of accepted selectors */ 
    8785  char *selptr; 
    8886  char *extreply = 0; 
    8987  char *term1, *term2; 
    90   char sendstr[100];            /* A buffer for command strings */ 
    91   char readbuf[100];            /* A buffer for responses */ 
     88  char sendstr[100]; /* A buffer for command strings */ 
     89  char readbuf[100]; /* A buffer for responses */ 
    9290  SLstream *curstream; 
    93    
     91 
    9492  /* Point to the stream chain */ 
    9593  curstream = slconn->streams; 
    9694 
    9795  selptr = curstream->selectors; 
    98    
     96 
    9997  /* Send the selector(s) and check the response(s) */ 
    10098  if (curstream->selectors != 0) 
    101     { 
    102       while (1) 
    103         { 
    104           selptr += sellen; 
    105           selptr += strspn (selptr, " "); 
    106           sellen = strcspn (selptr, " "); 
    107  
    108           if (sellen == 0) 
    109             break;              /* end of while loop */ 
    110  
    111           else if (sellen > SELSIZE) 
    112             { 
    113               sl_log_r (slconn, 2, 0, "[%s] invalid selector: %.*s\n", slconn->sladdr, 
    114                         sellen, selptr); 
    115               selptr += sellen; 
    116             } 
    117           else 
    118             { 
    119                
    120               /* Build SELECT command, send it and receive response */ 
    121               sprintf (sendstr, "SELECT %.*s\r", sellen, selptr); 
    122               sl_log_r (slconn, 1, 2, "[%s] sending: SELECT %.*s\n", slconn->sladdr, 
    123                         sellen, selptr); 
    124               bytesread = sl_senddata (slconn, (void *) sendstr, 
    125                                        strlen (sendstr), slconn->sladdr, 
    126                                        readbuf, sizeof (readbuf)); 
    127               if (bytesread < 0) 
    128                 {               /* Error from sl_senddata() */ 
    129                   return -1; 
    130                 } 
    131                
    132               /* Search for 2nd "\r" indicating extended reply message present */ 
    133               extreply = 0; 
    134               if ( (term1 = memchr (readbuf, '\r', bytesread)) ) 
    135                 { 
    136                   if ( (term2 = memchr (term1+1, '\r', bytesread-(readbuf-term1)-1)) ) 
    137                     { 
    138                       *term2 = '\0'; 
    139                       extreply = term1+1; 
    140                     } 
    141                 } 
    142                
    143               /* Check response to SELECT */ 
    144               if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
    145                 { 
    146                   sl_log_r (slconn, 1, 2, "[%s] selector %.*s is OK %s%s%s\n", slconn->sladdr, 
    147                             sellen, selptr, (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    148                   acceptsel++; 
    149                 } 
    150               else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
    151                 { 
    152                   sl_log_r (slconn, 1, 2, "[%s] selector %.*s not accepted %s%s%s\n", slconn->sladdr, 
    153                             sellen, selptr, (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    154                 } 
    155               else 
    156                 { 
    157                   sl_log_r (slconn, 2, 0, 
    158                             "[%s] invalid response to SELECT command: %.*s\n", 
    159                             slconn->sladdr, bytesread, readbuf); 
    160                   return -1; 
    161                 } 
    162             } 
    163         } 
    164        
    165       /* Fail if none of the given selectors were accepted */ 
    166       if (!acceptsel) 
    167         { 
    168           sl_log_r (slconn, 2, 0, "[%s] no data stream selector(s) accepted\n", 
    169                     slconn->sladdr); 
    170           return -1; 
    171         } 
     99  { 
     100    while (1) 
     101    { 
     102      selptr += sellen; 
     103      selptr += strspn (selptr, " "); 
     104      sellen = strcspn (selptr, " "); 
     105 
     106      if (sellen == 0) 
     107        break; /* end of while loop */ 
     108 
     109      else if (sellen > SELSIZE) 
     110      { 
     111        sl_log_r (slconn, 2, 0, "[%s] invalid selector: %.*s\n", slconn->sladdr, 
     112                  sellen, selptr); 
     113        selptr += sellen; 
     114      } 
    172115      else 
    173         { 
    174           sl_log_r (slconn, 1, 2, "[%s] %d selector(s) accepted\n", 
    175                     slconn->sladdr, acceptsel); 
    176         } 
    177     }                           /* End of selector processing */ 
     116      { 
     117 
     118        /* Build SELECT command, send it and receive response */ 
     119        sprintf (sendstr, "SELECT %.*s\r", sellen, selptr); 
     120        sl_log_r (slconn, 1, 2, "[%s] sending: SELECT %.*s\n", slconn->sladdr, 
     121                  sellen, selptr); 
     122        bytesread = sl_senddata (slconn, (void *)sendstr, 
     123                                 strlen (sendstr), slconn->sladdr, 
     124                                 readbuf, sizeof (readbuf)); 
     125        if (bytesread < 0) 
     126        { /* Error from sl_senddata() */ 
     127          return -1; 
     128        } 
     129 
     130        /* Search for 2nd "\r" indicating extended reply message present */ 
     131        extreply = 0; 
     132        if ((term1 = memchr (readbuf, '\r', bytesread))) 
     133        { 
     134          if ((term2 = memchr (term1 + 1, '\r', bytesread - (readbuf - term1) - 1))) 
     135          { 
     136            *term2   = '\0'; 
     137            extreply = term1 + 1; 
     138          } 
     139        } 
     140 
     141        /* Check response to SELECT */ 
     142        if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
     143        { 
     144          sl_log_r (slconn, 1, 2, "[%s] selector %.*s is OK %s%s%s\n", slconn->sladdr, 
     145                    sellen, selptr, (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     146          acceptsel++; 
     147        } 
     148        else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
     149        { 
     150          sl_log_r (slconn, 1, 2, "[%s] selector %.*s not accepted %s%s%s\n", slconn->sladdr, 
     151                    sellen, selptr, (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     152        } 
     153        else 
     154        { 
     155          sl_log_r (slconn, 2, 0, 
     156                    "[%s] invalid response to SELECT command: %.*s\n", 
     157                    slconn->sladdr, bytesread, readbuf); 
     158          return -1; 
     159        } 
     160      } 
     161    } 
     162 
     163    /* Fail if none of the given selectors were accepted */ 
     164    if (!acceptsel) 
     165    { 
     166      sl_log_r (slconn, 2, 0, "[%s] no data stream selector(s) accepted\n", 
     167                slconn->sladdr); 
     168      return -1; 
     169    } 
     170    else 
     171    { 
     172      sl_log_r (slconn, 1, 2, "[%s] %d selector(s) accepted\n", 
     173                slconn->sladdr, acceptsel); 
     174    } 
     175  } /* End of selector processing */ 
    178176 
    179177  /* Issue the DATA, FETCH or TIME action commands.  A specified start (and 
     
    181179     previous sequence number. */ 
    182180  if (slconn->begin_time != NULL) 
    183     { 
    184       if (sl_checkversion (slconn, (float)2.92) >= 0) 
    185         { 
    186           if (slconn->end_time == NULL) 
    187             { 
    188               sprintf (sendstr, "TIME %.25s\r", slconn->begin_time); 
    189             } 
    190           else 
    191             { 
    192               sprintf (sendstr, "TIME %.25s %.25s\r", slconn->begin_time, 
    193                        slconn->end_time); 
    194             } 
    195           sl_log_r (slconn, 1, 1, "[%s] requesting specified time window\n", 
    196                     slconn->sladdr); 
    197         } 
     181  { 
     182    if (sl_checkversion (slconn, (float)2.92) >= 0) 
     183    { 
     184      if (slconn->end_time == NULL) 
     185      { 
     186        sprintf (sendstr, "TIME %.25s\r", slconn->begin_time); 
     187      } 
    198188      else 
    199         { 
    200           sl_log_r (slconn, 2, 0, 
    201                     "[%s] detected SeedLink version (%.3f) does not support TIME windows\n", 
    202                     slconn->sladdr, slconn->protocol_ver); 
    203         } 
    204     } 
    205   else if (curstream->seqnum != -1 && slconn->resume ) 
    206     { 
    207       char cmd[10]; 
    208  
    209       if ( slconn->dialup ) 
    210         { 
    211           sprintf (cmd, "FETCH"); 
    212         } 
    213       else 
    214         { 
    215           sprintf (cmd, "DATA"); 
    216         } 
    217  
    218       /* Append the last packet time if the feature is enabled and server is >= 2.93 */ 
    219       if (slconn->lastpkttime && 
    220           sl_checkversion (slconn, (float)2.93) >= 0 && 
    221           strlen (curstream->timestamp)) 
    222         { 
    223           /* Increment sequence number by 1 */ 
    224           sprintf (sendstr, "%s %06X %.25s\r", cmd, 
    225                    (curstream->seqnum + 1) & 0xffffff, curstream->timestamp); 
    226  
    227           sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d) at %.25s\n", 
    228                     slconn->sladdr, (curstream->seqnum + 1) & 0xffffff, 
    229                     (curstream->seqnum + 1), curstream->timestamp); 
    230         } 
    231       else 
    232         { 
    233           /* Increment sequence number by 1 */ 
    234           sprintf (sendstr, "%s %06X\r", cmd, (curstream->seqnum + 1) & 0xffffff); 
    235  
    236           sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d)\n", 
    237                     slconn->sladdr, (curstream->seqnum + 1) & 0xffffff, 
    238                     (curstream->seqnum + 1)); 
    239         } 
    240     } 
     189      { 
     190        sprintf (sendstr, "TIME %.25s %.25s\r", slconn->begin_time, 
     191                 slconn->end_time); 
     192      } 
     193      sl_log_r (slconn, 1, 1, "[%s] requesting specified time window\n", 
     194                slconn->sladdr); 
     195    } 
     196    else 
     197    { 
     198      sl_log_r (slconn, 2, 0, 
     199                "[%s] detected SeedLink version (%.3f) does not support TIME windows\n", 
     200                slconn->sladdr, slconn->protocol_ver); 
     201    } 
     202  } 
     203  else if (curstream->seqnum != -1 && slconn->resume) 
     204  { 
     205    char cmd[10]; 
     206 
     207    if (slconn->dialup) 
     208    { 
     209      sprintf (cmd, "FETCH"); 
     210    } 
     211    else 
     212    { 
     213      sprintf (cmd, "DATA"); 
     214    } 
     215 
     216    /* Append the last packet time if the feature is enabled and server is >= 2.93 */ 
     217    if (slconn->lastpkttime && 
     218        sl_checkversion (slconn, (float)2.93) >= 0 && 
     219        strlen (curstream->timestamp)) 
     220    { 
     221      /* Increment sequence number by 1 */ 
     222      sprintf (sendstr, "%s %06X %.25s\r", cmd, 
     223               (curstream->seqnum + 1) & 0xffffff, curstream->timestamp); 
     224 
     225      sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d) at %.25s\n", 
     226                slconn->sladdr, (curstream->seqnum + 1) & 0xffffff, 
     227                (curstream->seqnum + 1), curstream->timestamp); 
     228    } 
     229    else 
     230    { 
     231      /* Increment sequence number by 1 */ 
     232      sprintf (sendstr, "%s %06X\r", cmd, (curstream->seqnum + 1) & 0xffffff); 
     233 
     234      sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d)\n", 
     235                slconn->sladdr, (curstream->seqnum + 1) & 0xffffff, 
     236                (curstream->seqnum + 1)); 
     237    } 
     238  } 
    241239  else 
    242     { 
    243       if ( slconn->dialup ) 
    244         { 
    245           sprintf (sendstr, "FETCH\r"); 
    246         } 
    247       else 
    248         { 
    249           sprintf (sendstr, "DATA\r"); 
    250         } 
    251  
    252       sl_log_r (slconn, 1, 1, "[%s] requesting next available data\n", slconn->sladdr); 
    253     } 
    254  
    255   if (sl_senddata (slconn, (void *) sendstr, strlen (sendstr), 
    256                    slconn->sladdr, (void *) NULL, 0) < 0) 
    257     { 
    258       sl_log_r (slconn, 2, 0, "[%s] error sending DATA/FETCH/TIME request\n", slconn->sladdr); 
    259       return -1; 
    260     } 
     240  { 
     241    if (slconn->dialup) 
     242    { 
     243      sprintf (sendstr, "FETCH\r"); 
     244    } 
     245    else 
     246    { 
     247      sprintf (sendstr, "DATA\r"); 
     248    } 
     249 
     250    sl_log_r (slconn, 1, 1, "[%s] requesting next available data\n", slconn->sladdr); 
     251  } 
     252 
     253  if (sl_senddata (slconn, (void *)sendstr, strlen (sendstr), 
     254                   slconn->sladdr, (void *)NULL, 0) < 0) 
     255  { 
     256    sl_log_r (slconn, 2, 0, "[%s] error sending DATA/FETCH/TIME request\n", slconn->sladdr); 
     257    return -1; 
     258  } 
    261259 
    262260  return slconn->link; 
    263 }  /* End of sl_negotiate_uni() */ 
    264  
     261} /* End of sl_negotiate_uni() */ 
    265262 
    266263/*************************************************************************** 
    267264 * sl_negotiate_multi: 
    268265 * 
    269  * Negotiate a SeedLink connection using multi-station mode and  
     266 * Negotiate a SeedLink connection using multi-station mode and 
    270267 * issue the END action command.  This is compatible with SeedLink 
    271268 * Protocol version 3, multi-station mode. 
     
    280277 ***************************************************************************/ 
    281278int 
    282 sl_negotiate_multi (SLCD * slconn) 
     279sl_negotiate_multi (SLCD *slconn) 
    283280{ 
    284   int sellen = 0; 
     281  int sellen    = 0; 
    285282  int bytesread = 0; 
    286   int acceptsta = 0;            /* Count of accepted stations */ 
    287   int acceptsel = 0;            /* Count of accepted selectors */ 
     283  int acceptsta = 0; /* Count of accepted stations */ 
     284  int acceptsel = 0; /* Count of accepted selectors */ 
    288285  char *selptr; 
    289286  char *term1, *term2; 
    290287  char *extreply = 0; 
    291   char sendstr[100];            /* A buffer for command strings */ 
    292   char readbuf[100];            /* A buffer for responses */ 
    293   char slring[12];              /* Keep track of the ring name */ 
     288  char sendstr[100]; /* A buffer for command strings */ 
     289  char readbuf[100]; /* A buffer for responses */ 
     290  char slring[12];   /* Keep track of the ring name */ 
    294291  SLstream *curstream; 
    295292 
     
    299296  /* Loop through the stream chain */ 
    300297  while (curstream != NULL) 
    301     { 
    302  
    303       /* A ring identifier */ 
    304       snprintf (slring, sizeof (slring), "%s_%s", 
    305                 curstream->net, curstream->sta); 
    306  
    307       /* Send the STATION command */ 
    308       sprintf (sendstr, "STATION %s %s\r", curstream->sta, curstream->net); 
    309       sl_log_r (slconn, 1, 2, "[%s] sending: STATION %s %s\n", 
    310                 slring, curstream->sta, curstream->net); 
    311       bytesread = sl_senddata (slconn, (void *) sendstr, 
    312                                strlen (sendstr), slring, readbuf, 
    313                                sizeof (readbuf)); 
    314       if (bytesread < 0) 
    315         { 
    316           return -1; 
    317         } 
    318        
    319       /* Search for 2nd "\r" indicating extended reply message present */ 
    320       extreply = 0; 
    321       if ( (term1 = memchr (readbuf, '\r', bytesread)) ) 
    322         { 
    323           if ( (term2 = memchr (term1+1, '\r', bytesread-(readbuf-term1)-1)) ) 
    324             { 
    325               *term2 = '\0'; 
    326               extreply = term1+1; 
    327             } 
    328         } 
    329        
    330       /* Check the response */ 
    331       if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
    332         { 
    333           sl_log_r (slconn, 1, 2, "[%s] station is OK %s%s%s\n", slring, 
    334                     (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    335           acceptsta++; 
    336         } 
    337       else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
    338         { 
    339           sl_log_r (slconn, 2, 0, "[%s] station not accepted %s%s%s\n", slring, 
    340                     (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    341           /* Increment the loop control and skip to the next stream */ 
    342           curstream = curstream->next; 
    343           continue; 
    344         } 
     298  { 
     299 
     300    /* A ring identifier */ 
     301    snprintf (slring, sizeof (slring), "%s_%s", 
     302              curstream->net, curstream->sta); 
     303 
     304    /* Send the STATION command */ 
     305    sprintf (sendstr, "STATION %s %s\r", curstream->sta, curstream->net); 
     306    sl_log_r (slconn, 1, 2, "[%s] sending: STATION %s %s\n", 
     307              slring, curstream->sta, curstream->net); 
     308    bytesread = sl_senddata (slconn, (void *)sendstr, 
     309                             strlen (sendstr), slring, readbuf, 
     310                             sizeof (readbuf)); 
     311    if (bytesread < 0) 
     312    { 
     313      return -1; 
     314    } 
     315 
     316    /* Search for 2nd "\r" indicating extended reply message present */ 
     317    extreply = 0; 
     318    if ((term1 = memchr (readbuf, '\r', bytesread))) 
     319    { 
     320      if ((term2 = memchr (term1 + 1, '\r', bytesread - (readbuf - term1) - 1))) 
     321      { 
     322        *term2   = '\0'; 
     323        extreply = term1 + 1; 
     324      } 
     325    } 
     326 
     327    /* Check the response */ 
     328    if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
     329    { 
     330      sl_log_r (slconn, 1, 2, "[%s] station is OK %s%s%s\n", slring, 
     331                (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     332      acceptsta++; 
     333    } 
     334    else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
     335    { 
     336      sl_log_r (slconn, 2, 0, "[%s] station not accepted %s%s%s\n", slring, 
     337                (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     338      /* Increment the loop control and skip to the next stream */ 
     339      curstream = curstream->next; 
     340      continue; 
     341    } 
     342    else 
     343    { 
     344      sl_log_r (slconn, 2, 0, "[%s] invalid response to STATION command: %.*s\n", 
     345                slring, bytesread, readbuf); 
     346      return -1; 
     347    } 
     348 
     349    selptr = curstream->selectors; 
     350    sellen = 0; 
     351 
     352    /* Send the selector(s) and check the response(s) */ 
     353    if (curstream->selectors != 0) 
     354    { 
     355      while (1) 
     356      { 
     357        selptr += sellen; 
     358        selptr += strspn (selptr, " "); 
     359        sellen = strcspn (selptr, " "); 
     360 
     361        if (sellen == 0) 
     362          break; /* end of while loop */ 
     363 
     364        else if (sellen > SELSIZE) 
     365        { 
     366          sl_log_r (slconn, 2, 0, "[%s] invalid selector: %.*s\n", 
     367                    slring, sellen, selptr); 
     368          selptr += sellen; 
     369        } 
     370        else 
     371        { 
     372 
     373          /* Build SELECT command, send it and receive response */ 
     374          sprintf (sendstr, "SELECT %.*s\r", sellen, selptr); 
     375          sl_log_r (slconn, 1, 2, "[%s] sending: SELECT %.*s\n", slring, sellen, 
     376                    selptr); 
     377          bytesread = sl_senddata (slconn, (void *)sendstr, 
     378                                   strlen (sendstr), slring, 
     379                                   readbuf, sizeof (readbuf)); 
     380          if (bytesread < 0) 
     381          { /* Error from sl_senddata() */ 
     382            return -1; 
     383          } 
     384 
     385          /* Search for 2nd "\r" indicating extended reply message present */ 
     386          extreply = 0; 
     387          if ((term1 = memchr (readbuf, '\r', bytesread))) 
     388          { 
     389            if ((term2 = memchr (term1 + 1, '\r', bytesread - (readbuf - term1) - 1))) 
     390            { 
     391              *term2   = '\0'; 
     392              extreply = term1 + 1; 
     393            } 
     394          } 
     395 
     396          /* Check response to SELECT */ 
     397          if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
     398          { 
     399            sl_log_r (slconn, 1, 2, "[%s] selector %.*s is OK %s%s%s\n", slring, 
     400                      sellen, selptr, (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     401            acceptsel++; 
     402          } 
     403          else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
     404          { 
     405            sl_log_r (slconn, 2, 0, "[%s] selector %.*s not accepted %s%s%s\n", slring, 
     406                      sellen, selptr, (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     407          } 
     408          else 
     409          { 
     410            sl_log_r (slconn, 2, 0, 
     411                      "[%s] invalid response to SELECT command: %.*s\n", 
     412                      slring, bytesread, readbuf); 
     413            return -1; 
     414          } 
     415        } 
     416      } 
     417 
     418      /* Fail if none of the given selectors were accepted */ 
     419      if (!acceptsel) 
     420      { 
     421        sl_log_r (slconn, 2, 0, "[%s] no data stream selector(s) accepted", 
     422                  slring); 
     423        return -1; 
     424      } 
    345425      else 
    346         { 
    347           sl_log_r (slconn, 2, 0, "[%s] invalid response to STATION command: %.*s\n", 
    348                     slring, bytesread, readbuf); 
    349           return -1; 
    350         } 
    351  
    352       selptr = curstream->selectors; 
    353       sellen = 0; 
    354  
    355       /* Send the selector(s) and check the response(s) */ 
    356       if (curstream->selectors != 0) 
    357         { 
    358           while (1) 
    359             { 
    360               selptr += sellen; 
    361               selptr += strspn (selptr, " "); 
    362               sellen = strcspn (selptr, " "); 
    363  
    364               if (sellen == 0) 
    365                 break;          /* end of while loop */ 
    366  
    367               else if (sellen > SELSIZE) 
    368                 { 
    369                   sl_log_r (slconn, 2, 0, "[%s] invalid selector: %.*s\n", 
    370                             slring, sellen, selptr); 
    371                   selptr += sellen; 
    372                 } 
    373               else 
    374                 { 
    375  
    376                   /* Build SELECT command, send it and receive response */ 
    377                   sprintf (sendstr, "SELECT %.*s\r", sellen, selptr); 
    378                   sl_log_r (slconn, 1, 2, "[%s] sending: SELECT %.*s\n", slring, sellen, 
    379                             selptr); 
    380                   bytesread = sl_senddata (slconn, (void *) sendstr, 
    381                                            strlen (sendstr), slring, 
    382                                            readbuf, sizeof (readbuf)); 
    383                   if (bytesread < 0) 
    384                     {           /* Error from sl_senddata() */ 
    385                       return -1; 
    386                     } 
    387                    
    388                   /* Search for 2nd "\r" indicating extended reply message present */ 
    389                   extreply = 0; 
    390                   if ( (term1 = memchr (readbuf, '\r', bytesread)) ) 
    391                     { 
    392                       if ( (term2 = memchr (term1+1, '\r', bytesread-(readbuf-term1)-1)) ) 
    393                         { 
    394                           *term2 = '\0'; 
    395                           extreply = term1+1; 
    396                         } 
    397                     } 
    398                    
    399                   /* Check response to SELECT */ 
    400                   if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
    401                     { 
    402                       sl_log_r (slconn, 1, 2, "[%s] selector %.*s is OK %s%s%s\n", slring, 
    403                                 sellen, selptr, (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    404                       acceptsel++; 
    405                     } 
    406                   else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
    407                     { 
    408                       sl_log_r (slconn, 2, 0, "[%s] selector %.*s not accepted %s%s%s\n", slring, 
    409                                 sellen, selptr, (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    410                     } 
    411                   else 
    412                     { 
    413                       sl_log_r (slconn, 2, 0, 
    414                                 "[%s] invalid response to SELECT command: %.*s\n", 
    415                                 slring, bytesread, readbuf); 
    416                       return -1; 
    417                     } 
    418                 } 
    419             } 
    420  
    421           /* Fail if none of the given selectors were accepted */ 
    422           if (!acceptsel) 
    423             { 
    424               sl_log_r (slconn, 2, 0, "[%s] no data stream selector(s) accepted", 
    425                         slring); 
    426               return -1; 
    427             } 
    428           else 
    429             { 
    430               sl_log_r (slconn, 1, 2, "[%s] %d selector(s) accepted\n", slring, 
    431                         acceptsel); 
    432             } 
    433  
    434           acceptsel = 0;        /* Reset the accepted selector count */ 
    435  
    436         }                       /* End of selector processing */ 
    437  
    438       /* Issue the DATA, FETCH or TIME action commands.  A specified start (and 
     426      { 
     427        sl_log_r (slconn, 1, 2, "[%s] %d selector(s) accepted\n", slring, 
     428                  acceptsel); 
     429      } 
     430 
     431      acceptsel = 0; /* Reset the accepted selector count */ 
     432 
     433    } /* End of selector processing */ 
     434 
     435    /* Issue the DATA, FETCH or TIME action commands.  A specified start (and 
    439436         optionally, stop time) takes precedence over the resumption from any 
    440437         previous sequence number. */ 
    441       if (slconn->begin_time != NULL) 
    442         { 
    443           if (sl_checkversion (slconn, (float)2.92) >= 0) 
    444             { 
    445               if (slconn->end_time == NULL) 
    446                 { 
    447                   sprintf (sendstr, "TIME %.25s\r", slconn->begin_time); 
    448                 } 
    449               else 
    450                 { 
    451                   sprintf (sendstr, "TIME %.25s %.25s\r", slconn->begin_time, 
    452                            slconn->end_time); 
    453                 } 
    454               sl_log_r (slconn, 1, 1, "[%s] requesting specified time window\n", 
    455                         slring); 
    456             } 
    457           else 
    458             { 
    459               sl_log_r (slconn, 2, 0, 
    460                         "[%s] detected SeedLink version (%.3f) does not support TIME windows\n", 
    461                         slring, slconn->protocol_ver); 
    462             } 
    463         } 
    464       else if (curstream->seqnum != -1 && slconn->resume ) 
    465         { 
    466           char cmd[10]; 
    467            
    468           if ( slconn->dialup ) 
    469             { 
    470               sprintf (cmd, "FETCH"); 
    471             } 
    472           else 
    473             { 
    474               sprintf (cmd, "DATA"); 
    475             } 
    476            
    477           /* Append the last packet time if the feature is enabled and server is >= 2.93 */ 
    478           if (slconn->lastpkttime && 
    479               sl_checkversion (slconn, (float)2.93) >= 0 && 
    480               strlen (curstream->timestamp)) 
    481             { 
    482               /* Increment sequence number by 1 */ 
    483               sprintf (sendstr, "%s %06X %.25s\r", cmd, 
    484                        (curstream->seqnum + 1) & 0xffffff, curstream->timestamp); 
    485  
    486               sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d) at %.25s\n", 
    487                         slconn->sladdr, (curstream->seqnum + 1) & 0xffffff, 
    488                         (curstream->seqnum + 1), curstream->timestamp); 
    489             }      
    490           else 
    491             { /* Increment sequence number by 1 */ 
    492               sprintf (sendstr, "%s %06X\r", cmd, 
    493                        (curstream->seqnum + 1) & 0xffffff); 
    494  
    495               sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d)\n", slring, 
    496                         (curstream->seqnum + 1) & 0xffffff, 
    497                         (curstream->seqnum + 1)); 
    498             } 
    499         } 
     438    if (slconn->begin_time != NULL) 
     439    { 
     440      if (sl_checkversion (slconn, (float)2.92) >= 0) 
     441      { 
     442        if (slconn->end_time == NULL) 
     443        { 
     444          sprintf (sendstr, "TIME %.25s\r", slconn->begin_time); 
     445        } 
     446        else 
     447        { 
     448          sprintf (sendstr, "TIME %.25s %.25s\r", slconn->begin_time, 
     449                   slconn->end_time); 
     450        } 
     451        sl_log_r (slconn, 1, 1, "[%s] requesting specified time window\n", 
     452                  slring); 
     453      } 
    500454      else 
    501         { 
    502           if ( slconn->dialup ) 
    503             { 
    504               sprintf (sendstr, "FETCH\r"); 
    505             } 
    506           else 
    507             { 
    508               sprintf (sendstr, "DATA\r"); 
    509             } 
    510            
    511           sl_log_r (slconn, 1, 1, "[%s] requesting next available data\n", slring); 
    512         } 
    513  
    514       /* Send the TIME/DATA/FETCH command and receive response */ 
    515       bytesread = sl_senddata (slconn, (void *) sendstr, 
    516                                strlen (sendstr), slring, 
    517                                readbuf, sizeof (readbuf)); 
    518       if (bytesread < 0) 
    519         { 
    520           sl_log_r (slconn, 2, 0, "[%s] error with DATA/FETCH/TIME request\n", slring); 
    521           return -1; 
    522         } 
    523        
    524       /* Search for 2nd "\r" indicating extended reply message present */ 
    525       extreply = 0; 
    526       if ( (term1 = memchr (readbuf, '\r', bytesread)) ) 
    527         { 
    528           if ( (term2 = memchr (term1+1, '\r', bytesread-(readbuf-term1)-1)) ) 
    529             { 
    530               fprintf (stderr, "term2: '%s'\n", term2); 
    531  
    532               *term2 = '\0'; 
    533               extreply = term1+1; 
    534             } 
    535         } 
    536        
    537       /* Check response to DATA/FETCH/TIME request */ 
    538       if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
    539         { 
    540           sl_log_r (slconn, 1, 2, "[%s] DATA/FETCH/TIME command is OK %s%s%s\n", slring, 
    541                     (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    542         } 
    543       else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
    544         { 
    545           sl_log_r (slconn, 2, 0, "[%s] DATA/FETCH/TIME command is not accepted %s%s%s\n", slring, 
    546                     (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    547         } 
     455      { 
     456        sl_log_r (slconn, 2, 0, 
     457                  "[%s] detected SeedLink version (%.3f) does not support TIME windows\n", 
     458                  slring, slconn->protocol_ver); 
     459      } 
     460    } 
     461    else if (curstream->seqnum != -1 && slconn->resume) 
     462    { 
     463      char cmd[10]; 
     464 
     465      if (slconn->dialup) 
     466      { 
     467        sprintf (cmd, "FETCH"); 
     468      } 
    548469      else 
    549         { 
    550           sl_log_r (slconn, 2, 0, "[%s] invalid response to DATA/FETCH/TIME command: %.*s\n", 
    551                     slring, bytesread, readbuf); 
    552           return -1; 
    553         } 
    554        
    555       /* Point to the next stream */ 
    556       curstream = curstream->next; 
    557  
    558     }  /* End of stream and selector config (end of stream chain). */ 
    559    
     470      { 
     471        sprintf (cmd, "DATA"); 
     472      } 
     473 
     474      /* Append the last packet time if the feature is enabled and server is >= 2.93 */ 
     475      if (slconn->lastpkttime && 
     476          sl_checkversion (slconn, (float)2.93) >= 0 && 
     477          strlen (curstream->timestamp)) 
     478      { 
     479        /* Increment sequence number by 1 */ 
     480        sprintf (sendstr, "%s %06X %.25s\r", cmd, 
     481                 (curstream->seqnum + 1) & 0xffffff, curstream->timestamp); 
     482 
     483        sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d) at %.25s\n", 
     484                  slconn->sladdr, (curstream->seqnum + 1) & 0xffffff, 
     485                  (curstream->seqnum + 1), curstream->timestamp); 
     486      } 
     487      else 
     488      { /* Increment sequence number by 1 */ 
     489        sprintf (sendstr, "%s %06X\r", cmd, 
     490                 (curstream->seqnum + 1) & 0xffffff); 
     491 
     492        sl_log_r (slconn, 1, 1, "[%s] resuming data from %06X (Dec %d)\n", slring, 
     493                  (curstream->seqnum + 1) & 0xffffff, 
     494                  (curstream->seqnum + 1)); 
     495      } 
     496    } 
     497    else 
     498    { 
     499      if (slconn->dialup) 
     500      { 
     501        sprintf (sendstr, "FETCH\r"); 
     502      } 
     503      else 
     504      { 
     505        sprintf (sendstr, "DATA\r"); 
     506      } 
     507 
     508      sl_log_r (slconn, 1, 1, "[%s] requesting next available data\n", slring); 
     509    } 
     510 
     511    /* Send the TIME/DATA/FETCH command and receive response */ 
     512    bytesread = sl_senddata (slconn, (void *)sendstr, 
     513                             strlen (sendstr), slring, 
     514                             readbuf, sizeof (readbuf)); 
     515    if (bytesread < 0) 
     516    { 
     517      sl_log_r (slconn, 2, 0, "[%s] error with DATA/FETCH/TIME request\n", slring); 
     518      return -1; 
     519    } 
     520 
     521    /* Search for 2nd "\r" indicating extended reply message present */ 
     522    extreply = 0; 
     523    if ((term1 = memchr (readbuf, '\r', bytesread))) 
     524    { 
     525      if ((term2 = memchr (term1 + 1, '\r', bytesread - (readbuf - term1) - 1))) 
     526      { 
     527        fprintf (stderr, "term2: '%s'\n", term2); 
     528 
     529        *term2   = '\0'; 
     530        extreply = term1 + 1; 
     531      } 
     532    } 
     533 
     534    /* Check response to DATA/FETCH/TIME request */ 
     535    if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
     536    { 
     537      sl_log_r (slconn, 1, 2, "[%s] DATA/FETCH/TIME command is OK %s%s%s\n", slring, 
     538                (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     539    } 
     540    else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
     541    { 
     542      sl_log_r (slconn, 2, 0, "[%s] DATA/FETCH/TIME command is not accepted %s%s%s\n", slring, 
     543                (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     544    } 
     545    else 
     546    { 
     547      sl_log_r (slconn, 2, 0, "[%s] invalid response to DATA/FETCH/TIME command: %.*s\n", 
     548                slring, bytesread, readbuf); 
     549      return -1; 
     550    } 
     551 
     552    /* Point to the next stream */ 
     553    curstream = curstream->next; 
     554 
     555  } /* End of stream and selector config (end of stream chain). */ 
     556 
    560557  /* Fail if no stations were accepted */ 
    561558  if (!acceptsta) 
    562     { 
    563       sl_log_r (slconn, 2, 0, "[%s] no station(s) accepted\n", slconn->sladdr); 
    564       return -1; 
    565     } 
     559  { 
     560    sl_log_r (slconn, 2, 0, "[%s] no station(s) accepted\n", slconn->sladdr); 
     561    return -1; 
     562  } 
    566563  else 
    567     { 
    568       sl_log_r (slconn, 1, 1, "[%s] %d station(s) accepted\n", 
    569               slconn->sladdr, acceptsta); 
    570     } 
     564  { 
     565    sl_log_r (slconn, 1, 1, "[%s] %d station(s) accepted\n", 
     566              slconn->sladdr, acceptsta); 
     567  } 
    571568 
    572569  /* Issue END action command */ 
    573570  sprintf (sendstr, "END\r"); 
    574571  sl_log_r (slconn, 1, 2, "[%s] sending: END\n", slconn->sladdr); 
    575   if (sl_senddata (slconn, (void *) sendstr, strlen (sendstr), 
    576                    slconn->sladdr, (void *) NULL, 0) < 0) 
    577     { 
    578       sl_log_r (slconn, 2, 0, "[%s] error sending END command\n", slconn->sladdr); 
    579       return -1; 
    580     } 
     572  if (sl_senddata (slconn, (void *)sendstr, strlen (sendstr), 
     573                   slconn->sladdr, (void *)NULL, 0) < 0) 
     574  { 
     575    sl_log_r (slconn, 2, 0, "[%s] error sending END command\n", slconn->sladdr); 
     576    return -1; 
     577  } 
    581578 
    582579  return slconn->link; 
    583 }  /* End of sl_negotiate_multi() */ 
    584  
     580} /* End of sl_negotiate_multi() */ 
    585581 
    586582/*************************************************************************** 
     
    594590 ***************************************************************************/ 
    595591int 
    596 sl_send_info (SLCD * slconn, const char * info_level, int verbose) 
     592sl_send_info (SLCD *slconn, const char *info_level, int verbose) 
    597593{ 
    598   char sendstr[40];             /* A buffer for command strings */ 
     594  char sendstr[40]; /* A buffer for command strings */ 
    599595 
    600596  if (sl_checkversion (slconn, (float)2.92) >= 0) 
    601     { 
    602       sprintf (sendstr, "INFO %.15s\r", info_level); 
    603  
    604       sl_log_r (slconn, 1, verbose, "[%s] requesting INFO level %s\n", 
    605                 slconn->sladdr, info_level); 
    606  
    607       if (sl_senddata (slconn, (void *) sendstr, strlen (sendstr), 
    608                        slconn->sladdr, (void *) NULL, 0) < 0) 
    609         { 
    610           sl_log_r (slconn, 2, 0, "[%s] error sending INFO request\n", slconn->sladdr); 
    611           return -1; 
    612         } 
    613     } 
     597  { 
     598    sprintf (sendstr, "INFO %.15s\r", info_level); 
     599 
     600    sl_log_r (slconn, 1, verbose, "[%s] requesting INFO level %s\n", 
     601              slconn->sladdr, info_level); 
     602 
     603    if (sl_senddata (slconn, (void *)sendstr, strlen (sendstr), 
     604                     slconn->sladdr, (void *)NULL, 0) < 0) 
     605    { 
     606      sl_log_r (slconn, 2, 0, "[%s] error sending INFO request\n", slconn->sladdr); 
     607      return -1; 
     608    } 
     609  } 
    614610  else 
    615     { 
    616       sl_log_r (slconn, 2, 0, 
    617                 "[%s] detected SeedLink version (%.3f) does not support INFO requests\n", 
    618                 slconn->sladdr, slconn->protocol_ver);    
    619       return -1; 
    620     } 
     611  { 
     612    sl_log_r (slconn, 2, 0, 
     613              "[%s] detected SeedLink version (%.3f) does not support INFO requests\n", 
     614              slconn->sladdr, slconn->protocol_ver); 
     615    return -1; 
     616  } 
    621617 
    622618  return slconn->link; 
    623 }  /* End of sl_send_info() */ 
    624  
     619} /* End of sl_send_info() */ 
    625620 
    626621/*************************************************************************** 
     
    646641 * Returns -1 on errors otherwise the socket descriptor created. 
    647642 ***************************************************************************/ 
    648 int 
    649 sl_connect (SLCD * slconn, int sayhello) 
     643SOCKET 
     644sl_connect (SLCD *slconn, int sayhello) 
    650645{ 
    651   int sock; 
     646  SOCKET sock; 
    652647  int on = 1; 
    653648  int sockstat; 
     
    659654  struct sockaddr addr; 
    660655 
    661   if ( slp_sockstartup() ) { 
     656  if (slp_sockstartup ()) 
     657  { 
    662658    sl_log_r (slconn, 2, 0, "could not initialize network sockets\n"); 
    663659    return -1; 
    664660  } 
    665    
     661 
    666662  /* Check server address string and use defaults if needed: 
    667663   * If only ':' is specified neither host nor port specified 
     
    669665   * If ':' is the first character no host was specified 
    670666   */ 
    671   if ( ! strcmp (slconn->sladdr, ":") ) 
     667  if (!strcmp (slconn->sladdr, ":")) 
     668  { 
     669    strcpy (nodename, "localhost"); 
     670    strcpy (nodeport, "18000"); 
     671  } 
     672  else if ((ptr = strchr (slconn->sladdr, ':')) == NULL) 
     673  { 
     674    strncpy (nodename, slconn->sladdr, sizeof (nodename)); 
     675    strcpy (nodeport, "18000"); 
     676  } 
     677  else 
     678  { 
     679    if (ptr == slconn->sladdr) 
    672680    { 
    673681      strcpy (nodename, "localhost"); 
    674       strcpy (nodeport, "18000"); 
    675     } 
    676   else if ((ptr = strchr (slconn->sladdr, ':')) == NULL) 
    677     { 
    678       strncpy (nodename, slconn->sladdr, sizeof(nodename)); 
    679       strcpy (nodeport, "18000"); 
    680     } 
    681   else 
    682     { 
    683       if ( ptr == slconn->sladdr ) 
    684         { 
    685           strcpy (nodename, "localhost"); 
    686         } 
    687       else 
    688         { 
    689           strncpy (nodename, slconn->sladdr, (ptr - slconn->sladdr)); 
    690           nodename[(ptr - slconn->sladdr)] = '\0'; 
    691         } 
    692        
    693       strcpy (nodeport, ptr+1); 
    694  
    695       /* Sanity test the port number */ 
    696       nport = strtoul (nodeport, &tail, 10); 
    697       if ( *tail || (nport <= 0 || nport > 0xffff) ) 
    698         { 
    699           sl_log_r (slconn, 2, 0, "server port specified incorrectly\n"); 
    700           slconn->terminate = 1; 
    701           return -1; 
    702         } 
    703     } 
    704    
    705   if ( slp_getaddrinfo (nodename, nodeport, &addr, &addrlen) ) 
    706     { 
    707       sl_log_r (slconn, 2, 0, "cannot resolve hostname %s\n", nodename ); 
     682    } 
     683    else 
     684    { 
     685      strncpy (nodename, slconn->sladdr, (ptr - slconn->sladdr)); 
     686      nodename[(ptr - slconn->sladdr)] = '\0'; 
     687    } 
     688 
     689    strcpy (nodeport, ptr + 1); 
     690 
     691    /* Sanity test the port number */ 
     692    nport = strtoul (nodeport, &tail, 10); 
     693    if (*tail || (nport <= 0 || nport > 0xffff)) 
     694    { 
     695      sl_log_r (slconn, 2, 0, "server port specified incorrectly\n"); 
     696      slconn->terminate = 1; 
    708697      return -1; 
    709698    } 
     699  } 
     700 
     701  if (slp_getaddrinfo (nodename, nodeport, &addr, &addrlen)) 
     702  { 
     703    sl_log_r (slconn, 2, 0, "cannot resolve hostname %s\n", nodename); 
     704    return -1; 
     705  } 
    710706 
    711707  if ((sock = socket (PF_INET, SOCK_STREAM, 0)) < 0) 
    712     { 
    713       sl_log_r (slconn, 2, 0, "[%s] socket(): %s\n", slconn->sladdr, slp_strerror ()); 
    714       slp_sockclose (sock); 
    715       return -1; 
    716     } 
     708  { 
     709    sl_log_r (slconn, 2, 0, "[%s] socket(): %s\n", slconn->sladdr, slp_strerror ()); 
     710    slp_sockclose (sock); 
     711    return -1; 
     712  } 
    717713 
    718714  /* Set non-blocking IO */ 
    719   if ( slp_socknoblock(sock) ) 
    720     { 
    721       sl_log_r (slconn, 2, 0, "Error setting socket to non-blocking\n"); 
    722     } 
    723  
    724   if ( (slp_sockconnect (sock, (struct sockaddr *) &addr, addrlen)) ) 
    725     { 
    726       sl_log_r (slconn, 2, 0, "[%s] connect(): %s\n", slconn->sladdr, slp_strerror ()); 
    727       slp_sockclose (sock); 
    728       return -1; 
    729     } 
    730    
     715  if (slp_socknoblock (sock)) 
     716  { 
     717    sl_log_r (slconn, 2, 0, "Error setting socket to non-blocking\n"); 
     718  } 
     719 
     720  if ((slp_sockconnect (sock, (struct sockaddr *)&addr, addrlen))) 
     721  { 
     722    sl_log_r (slconn, 2, 0, "[%s] connect(): %s\n", slconn->sladdr, slp_strerror ()); 
     723    slp_sockclose (sock); 
     724    return -1; 
     725  } 
     726 
    731727  /* Wait up to 10 seconds for the socket to be connected */ 
    732728  if ((sockstat = sl_checksock (sock, 10, 0)) <= 0) 
    733     { 
    734       if (sockstat < 0) 
    735         {                       /* select() returned error */ 
    736           sl_log_r (slconn, 2, 1, "[%s] socket connect error\n", slconn->sladdr); 
    737         } 
    738       else 
    739         {                       /* socket time-out */ 
    740           sl_log_r (slconn, 2, 1, "[%s] socket connect time-out (10s)\n", 
    741                     slconn->sladdr); 
    742         } 
    743  
    744       slp_sockclose (sock); 
    745       return -1; 
    746     } 
    747   else if ( ! slconn->terminate ) 
    748     {                           /* socket connected */ 
    749       sl_log_r (slconn, 1, 1, "[%s] network socket opened\n", slconn->sladdr); 
    750        
    751       /* Set the SO_KEEPALIVE socket option, although not really useful */ 
    752       if (setsockopt 
    753           (sock, SOL_SOCKET, SO_KEEPALIVE, (char *) &on, sizeof (on)) < 0) 
    754         sl_log_r (slconn, 1, 1, "[%s] cannot set SO_KEEPALIVE socket option\n", 
    755                   slconn->sladdr); 
    756        
    757       slconn->link = sock; 
    758  
    759       if ( slconn->batchmode ) 
    760           slconn->batchmode = 1; 
    761        
    762       /* Everything should be connected, say hello if requested */ 
    763       if ( sayhello ) 
    764         { 
    765           if (sl_sayhello (slconn) == -1) 
    766             { 
    767               slp_sockclose (sock); 
    768               return -1; 
    769             } 
    770         } 
    771        
    772       /* Try to enter batch mode if requested */ 
    773       if ( slconn->batchmode ) 
    774         { 
    775           if (sl_batchmode (slconn) == -1) 
    776             { 
    777               slp_sockclose (sock); 
    778               return -1; 
    779             } 
    780         } 
    781        
    782       return sock; 
    783     } 
    784    
     729  { 
     730    if (sockstat < 0) 
     731    { /* select() returned error */ 
     732      sl_log_r (slconn, 2, 1, "[%s] socket connect error\n", slconn->sladdr); 
     733    } 
     734    else 
     735    { /* socket time-out */ 
     736      sl_log_r (slconn, 2, 1, "[%s] socket connect time-out (10s)\n", 
     737                slconn->sladdr); 
     738    } 
     739 
     740    slp_sockclose (sock); 
     741    return -1; 
     742  } 
     743  else if (!slconn->terminate) 
     744  { /* socket connected */ 
     745    sl_log_r (slconn, 1, 1, "[%s] network socket opened\n", slconn->sladdr); 
     746 
     747    /* Set the SO_KEEPALIVE socket option, although not really useful */ 
     748    if (setsockopt (sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&on, sizeof (on)) < 0) 
     749      sl_log_r (slconn, 1, 1, "[%s] cannot set SO_KEEPALIVE socket option\n", 
     750                slconn->sladdr); 
     751 
     752    slconn->link = sock; 
     753 
     754    if (slconn->batchmode) 
     755      slconn->batchmode = 1; 
     756 
     757    /* Everything should be connected, say hello if requested */ 
     758    if (sayhello) 
     759    { 
     760      if (sl_sayhello (slconn) == -1) 
     761      { 
     762        slp_sockclose (sock); 
     763        return -1; 
     764      } 
     765    } 
     766 
     767    /* Try to enter batch mode if requested */ 
     768    if (slconn->batchmode) 
     769    { 
     770      if (sl_batchmode (slconn) == -1) 
     771      { 
     772        slp_sockclose (sock); 
     773        return -1; 
     774      } 
     775    } 
     776 
     777    return sock; 
     778  } 
     779 
    785780  return -1; 
    786 }  /* End of sl_connect() */ 
    787  
     781} /* End of sl_connect() */ 
    788782 
    789783/*************************************************************************** 
     
    795789 ***************************************************************************/ 
    796790int 
    797 sl_disconnect (SLCD * slconn) 
     791sl_disconnect (SLCD *slconn) 
    798792{ 
    799793  if (slconn->link != -1) 
    800     { 
    801       slp_sockclose (slconn->link); 
    802       slconn->link = -1; 
    803        
    804       sl_log_r (slconn, 1, 1, "[%s] network socket closed\n", slconn->sladdr); 
    805     } 
    806    
     794  { 
     795    slp_sockclose (slconn->link); 
     796    slconn->link = -1; 
     797 
     798    sl_log_r (slconn, 1, 1, "[%s] network socket closed\n", slconn->sladdr); 
     799  } 
     800 
    807801  return -1; 
    808 }  /* End of sl_disconnect() */ 
    809  
     802} /* End of sl_disconnect() */ 
    810803 
    811804/*************************************************************************** 
     
    820813 ***************************************************************************/ 
    821814int 
    822 sl_sayhello (SLCD * slconn) 
     815sl_sayhello (SLCD *slconn) 
    823816{ 
    824   int ret = 0; 
     817  int ret     = 0; 
    825818  int servcnt = 0; 
    826819  int sitecnt = 0; 
    827   char sendstr[100];            /* A buffer for command strings */ 
    828   char servstr[200];            /* The remote server ident */ 
    829   char sitestr[100];            /* The site/data center ident */ 
    830   char servid[100];             /* Server ID string, i.e. 'SeedLink' */ 
    831   char *capptr;                 /* Pointer to capabilities flags */   
    832   char capflag = 0;             /* Capabilities are supported by server */ 
     820  char sendstr[100]; /* A buffer for command strings */ 
     821  char servstr[200]; /* The remote server ident */ 
     822  char sitestr[100]; /* The site/data center ident */ 
     823  char servid[100];  /* Server ID string, i.e. 'SeedLink' */ 
     824  char *capptr;      /* Pointer to capabilities flags */ 
     825  char capflag = 0;  /* Capabilities are supported by server */ 
    833826 
    834827  /* Send HELLO */ 
    835828  sprintf (sendstr, "HELLO\r"); 
    836829  sl_log_r (slconn, 1, 2, "[%s] sending: %s\n", slconn->sladdr, sendstr); 
    837   sl_senddata (slconn, (void *) sendstr, strlen (sendstr), slconn->sladdr, 
    838                NULL, 0); 
    839    
     830  sl_senddata (slconn, (void *)sendstr, strlen (sendstr), slconn->sladdr, 
     831               NULL, 0); 
     832 
    840833  /* Recv the two lines of response: server ID and site installation ID */ 
    841   if ( sl_recvresp (slconn, (void *) servstr, (size_t) sizeof (servstr), 
    842                     sendstr, slconn->sladdr) < 0 ) 
    843     { 
    844       return -1; 
    845     } 
    846    
    847   if ( sl_recvresp (slconn, (void *) sitestr, (size_t) sizeof (sitestr), 
    848                     sendstr, slconn->sladdr) < 0 ) 
    849     { 
    850       return -1; 
    851     } 
    852    
     834  if (sl_recvresp (slconn, (void *)servstr, (size_t)sizeof (servstr), 
     835                   sendstr, slconn->sladdr) < 0) 
     836  { 
     837    return -1; 
     838  } 
     839 
     840  if (sl_recvresp (slconn, (void *)sitestr, (size_t)sizeof (sitestr), 
     841                   sendstr, slconn->sladdr) < 0) 
     842  { 
     843    return -1; 
     844  } 
     845 
    853846  /* Terminate on first "\r" character or at one character before end of buffer */ 
    854847  servcnt = strcspn (servstr, "\r"); 
    855   if ( servcnt > (sizeof(servstr)-2) ) 
    856     { 
    857       servcnt = (sizeof(servstr)-2); 
    858     } 
     848  if (servcnt > (sizeof (servstr) - 2)) 
     849  { 
     850    servcnt = (sizeof (servstr) - 2); 
     851  } 
    859852  servstr[servcnt] = '\0'; 
    860    
     853 
    861854  sitecnt = strcspn (sitestr, "\r"); 
    862   if ( sitecnt > (sizeof(sitestr)-2) ) 
    863     { 
    864       sitecnt = (sizeof(sitestr)-2); 
    865     } 
     855  if (sitecnt > (sizeof (sitestr) - 2)) 
     856  { 
     857    sitecnt = (sizeof (sitestr) - 2); 
     858  } 
    866859  sitestr[sitecnt] = '\0'; 
    867    
     860 
    868861  /* Search for capabilities flags in server ID by looking for "::" 
    869862   * The expected format of the complete server ID is: 
     
    871864   */ 
    872865  capptr = strstr (servstr, "::"); 
    873   if ( capptr ) 
    874     { 
    875       /* Truncate server ID portion of string */ 
    876       *capptr = '\0'; 
    877  
    878       /* Move pointer to beginning of flags */ 
    879       capptr += 2; 
    880        
    881       /* Move capptr up to first non-space character */ 
    882       while ( *capptr == ' ' ) 
    883         capptr++; 
    884     } 
    885    
     866  if (capptr) 
     867  { 
     868    /* Truncate server ID portion of string */ 
     869    *capptr = '\0'; 
     870 
     871    /* Move pointer to beginning of flags */ 
     872    capptr += 2; 
     873 
     874    /* Move capptr up to first non-space character */ 
     875    while (*capptr == ' ') 
     876      capptr++; 
     877  } 
     878 
    886879  /* Report received IDs */ 
    887880  sl_log_r (slconn, 1, 1, "[%s] connected to: %s\n", slconn->sladdr, servstr); 
    888   if ( capptr ) 
     881  if (capptr) 
    889882    sl_log_r (slconn, 1, 1, "[%s] capabilities: %s\n", slconn->sladdr, capptr); 
    890883  sl_log_r (slconn, 1, 1, "[%s] organization: %s\n", slconn->sladdr, sitestr); 
    891    
     884 
    892885  /* Parse old-school server ID and version from the returned string. 
    893886   * The expected format at this point is: 
     
    896889   */ 
    897890  /* Add a space to the end to allowing parsing when the optionals are not present */ 
    898   servstr[servcnt] = ' '; servstr[servcnt+1] = '\0'; 
    899   ret = sscanf (servstr, "%s v%f ", &servid[0], &slconn->protocol_ver); 
    900    
    901   if ( ret != 2 || strncasecmp (servid, "SEEDLINK", 8) ) 
    902     { 
    903       sl_log_r (slconn, 1, 1, 
    904                 "[%s] unrecognized server version, assuming minimum functionality\n", 
    905                 slconn->sladdr); 
    906       slconn->protocol_ver = 0.0; 
    907     } 
    908    
     891  servstr[servcnt]     = ' '; 
     892  servstr[servcnt + 1] = '\0'; 
     893  ret                  = sscanf (servstr, "%s v%f ", &servid[0], &slconn->protocol_ver); 
     894 
     895  if (ret != 2 || strncasecmp (servid, "SEEDLINK", 8)) 
     896  { 
     897    sl_log_r (slconn, 1, 1, 
     898              "[%s] unrecognized server version, assuming minimum functionality\n", 
     899              slconn->sladdr); 
     900    slconn->protocol_ver = 0.0; 
     901  } 
     902 
    909903  /* Check capabilities flags */ 
    910   if ( capptr ) 
    911     { 
    912       char *tptr; 
    913        
    914       /* Parse protocol version flag: "SLPROTO:<#.#>" if present */ 
    915       if ( (tptr = strstr(capptr, "SLPROTO")) ) 
    916         { 
    917           /* This protocol specification overrides that from earlier in the server ID */ 
    918           ret = sscanf (tptr, "SLPROTO:%f", &slconn->protocol_ver); 
    919            
    920           if ( ret != 1 ) 
    921             sl_log_r (slconn, 1, 1, 
    922                       "[%s] could not parse protocol version from SLPROTO flag: %s\n", 
    923                       slconn->sladdr, tptr); 
    924         } 
    925        
    926       /* Check for CAPABILITIES command support */ 
    927       if ( strstr(capptr, "CAP") ) 
    928         capflag = 1; 
    929     } 
    930    
     904  if (capptr) 
     905  { 
     906    char *tptr; 
     907 
     908    /* Parse protocol version flag: "SLPROTO:<#.#>" if present */ 
     909    if ((tptr = strstr (capptr, "SLPROTO"))) 
     910    { 
     911      /* This protocol specification overrides that from earlier in the server ID */ 
     912      ret = sscanf (tptr, "SLPROTO:%f", &slconn->protocol_ver); 
     913 
     914      if (ret != 1) 
     915        sl_log_r (slconn, 1, 1, 
     916                  "[%s] could not parse protocol version from SLPROTO flag: %s\n", 
     917                  slconn->sladdr, tptr); 
     918    } 
     919 
     920    /* Check for CAPABILITIES command support */ 
     921    if (strstr (capptr, "CAP")) 
     922      capflag = 1; 
     923  } 
     924 
    931925  /* Send CAPABILITIES flags if supported by server */ 
    932   if ( capflag ) 
    933     { 
    934       int bytesread = 0; 
    935       char readbuf[100]; 
    936        
    937       char *term1, *term2; 
    938       char *extreply = 0; 
    939        
    940       /* Current capabilities: 
     926  if (capflag) 
     927  { 
     928    int bytesread = 0; 
     929    char readbuf[100]; 
     930 
     931    char *term1, *term2; 
     932    char *extreply = 0; 
     933 
     934    /* Current capabilities: 
    941935       *   SLPROTO:3.1 = SeedLink protocol version 
    942936       *   CAP         = CAPABILITIES command support 
     
    945939       *   BATCH       = BATCH command mode support 
    946940       */ 
    947       sprintf (sendstr, "CAPABILITIES SLPROTO:3.1 CAP EXTREPLY NSWILDCARD BATCH\r"); 
    948        
    949       /* Send CAPABILITIES and recv response */ 
    950       sl_log_r (slconn, 1, 2, "[%s] sending: %s\n", slconn->sladdr, sendstr); 
    951       bytesread = sl_senddata (slconn, (void *) sendstr, strlen (sendstr), slconn->sladdr, 
    952                                readbuf, sizeof (readbuf)); 
    953        
    954       if ( bytesread < 0 ) 
    955         {               /* Error from sl_senddata() */ 
    956           return -1; 
    957         } 
    958        
    959       /* Search for 2nd "\r" indicating extended reply message present */ 
    960       extreply = 0; 
    961       if ( (term1 = memchr (readbuf, '\r', bytesread)) ) 
    962         { 
    963           if ( (term2 = memchr (term1+1, '\r', bytesread-(readbuf-term1)-1)) ) 
    964             { 
    965               *term2 = '\0'; 
    966               extreply = term1+1; 
    967             } 
    968         } 
    969        
    970       /* Check response to CAPABILITIES */ 
    971       if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
    972         { 
    973           sl_log_r (slconn, 1, 2, "[%s] capabilities OK %s%s%s\n", slconn->sladdr, 
    974                     (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":""); 
    975         } 
    976       else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
    977         { 
    978           sl_log_r (slconn, 1, 2, "[%s] CAPABILITIES not accepted %s%s%s\n", slconn->sladdr, 
    979                     (extreply)?"{":"", (extreply)?extreply:"", (extreply)?"}":"");         
    980           return -1; 
    981         } 
    982       else 
    983         { 
    984           sl_log_r (slconn, 2, 0, 
    985                     "[%s] invalid response to CAPABILITIES command: %.*s\n", 
    986                     slconn->sladdr, bytesread, readbuf); 
    987           return -1; 
    988         } 
    989     } 
    990    
     941    sprintf (sendstr, "CAPABILITIES SLPROTO:3.1 CAP EXTREPLY NSWILDCARD BATCH\r"); 
     942 
     943    /* Send CAPABILITIES and recv response */ 
     944    sl_log_r (slconn, 1, 2, "[%s] sending: %s\n", slconn->sladdr, sendstr); 
     945    bytesread = sl_senddata (slconn, (void *)sendstr, strlen (sendstr), slconn->sladdr, 
     946                             readbuf, sizeof (readbuf)); 
     947 
     948    if (bytesread < 0) 
     949    { /* Error from sl_senddata() */ 
     950      return -1; 
     951    } 
     952 
     953    /* Search for 2nd "\r" indicating extended reply message present */ 
     954    extreply = 0; 
     955    if ((term1 = memchr (readbuf, '\r', bytesread))) 
     956    { 
     957      if ((term2 = memchr (term1 + 1, '\r', bytesread - (readbuf - term1) - 1))) 
     958      { 
     959        *term2  = '\0'; 
     960        extreply = term1 + 1; 
     961      } 
     962    } 
     963 
     964    /* Check response to CAPABILITIES */ 
     965    if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
     966    { 
     967      sl_log_r (slconn, 1, 2, "[%s] capabilities OK %s%s%s\n", slconn->sladdr, 
     968                (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     969    } 
     970    else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
     971    { 
     972      sl_log_r (slconn, 1, 2, "[%s] CAPABILITIES not accepted %s%s%s\n", slconn->sladdr, 
     973                (extreply) ? "{" : "", (extreply) ? extreply : "", (extreply) ? "}" : ""); 
     974      return -1; 
     975    } 
     976    else 
     977    { 
     978      sl_log_r (slconn, 2, 0, 
     979                "[%s] invalid response to CAPABILITIES command: %.*s\n", 
     980                slconn->sladdr, bytesread, readbuf); 
     981      return -1; 
     982    } 
     983  } 
     984 
    991985  return 0; 
    992 }  /* End of sl_sayhello() */ 
    993  
     986} /* End of sl_sayhello() */ 
    994987 
    995988/*************************************************************************** 
     
    1004997 ***************************************************************************/ 
    1005998int 
    1006 sl_batchmode (SLCD * slconn) 
     999sl_batchmode (SLCD *slconn) 
    10071000{ 
    1008   char sendstr[100];    /* A buffer for command strings */ 
    1009   char readbuf[100];    /* A buffer for server reply */ 
     1001  char sendstr[100]; /* A buffer for command strings */ 
     1002  char readbuf[100]; /* A buffer for server reply */ 
    10101003  int bytesread = 0; 
    1011    
    1012   if ( ! slconn ) 
    1013     return -1; 
    1014    
     1004 
     1005  if (!slconn) 
     1006    return -1; 
     1007 
    10151008  if (sl_checkversion (slconn, 3.1) < 0) 
    1016     { 
    1017       sl_log_r (slconn, 2, 0, 
    1018                 "[%s] detected SeedLink version (%.3f) does not support the BATCH command\n", 
    1019                 slconn->sladdr, slconn->protocol_ver); 
    1020       return -1; 
    1021     } 
    1022    
     1009  { 
     1010    sl_log_r (slconn, 2, 0, 
     1011              "[%s] detected SeedLink version (%.3f) does not support the BATCH command\n", 
     1012              slconn->sladdr, slconn->protocol_ver); 
     1013    return -1; 
     1014  } 
     1015 
    10231016  /* Send BATCH and recv response */ 
    10241017  sprintf (sendstr, "BATCH\r"); 
    10251018  sl_log_r (slconn, 1, 2, "[%s] sending: %s\n", slconn->sladdr, sendstr); 
    1026   bytesread = sl_senddata (slconn, (void *) sendstr, strlen (sendstr), slconn->sladdr, 
    1027                            readbuf, sizeof (readbuf)); 
    1028    
    1029   if ( bytesread < 0 ) 
    1030     {           /* Error from sl_senddata() */ 
    1031       return -1; 
    1032     } 
    1033    
     1019  bytesread = sl_senddata (slconn, (void *)sendstr, strlen (sendstr), slconn->sladdr, 
     1020                           readbuf, sizeof (readbuf)); 
     1021 
     1022  if (bytesread < 0) 
     1023  { /* Error from sl_senddata() */ 
     1024    return -1; 
     1025  } 
     1026 
    10341027  /* Check response to BATCH */ 
    10351028  if (!strncmp (readbuf, "OK\r", 3) && bytesread >= 4) 
    1036     { 
    1037       sl_log_r (slconn, 1, 2, "[%s] BATCH accepted\n", slconn->sladdr); 
    1038       slconn->batchmode = 2; 
    1039     } 
     1029  { 
     1030    sl_log_r (slconn, 1, 2, "[%s] BATCH accepted\n", slconn->sladdr); 
     1031    slconn->batchmode = 2; 
     1032  } 
    10401033  else if (!strncmp (readbuf, "ERROR\r", 6) && bytesread >= 7) 
    1041     { 
    1042       sl_log_r (slconn, 1, 2, "[%s] BATCH not accepted\n", slconn->sladdr); 
    1043     } 
     1034  { 
     1035    sl_log_r (slconn, 1, 2, "[%s] BATCH not accepted\n", slconn->sladdr); 
     1036  } 
    10441037  else 
    1045     { 
    1046       sl_log_r (slconn, 2, 0, 
    1047                 "[%s] invalid response to BATCH command: %.*s\n", 
    1048                 slconn->sladdr, bytesread, readbuf); 
    1049       return -1; 
    1050     } 
    1051    
     1038  { 
     1039    sl_log_r (slconn, 2, 0, 
     1040              "[%s] invalid response to BATCH command: %.*s\n", 
     1041              slconn->sladdr, bytesread, readbuf); 
     1042    return -1; 
     1043  } 
     1044 
    10521045  return 0; 
    1053 }  /* End of sl_batchmode() */ 
    1054  
     1046} /* End of sl_batchmode() */ 
    10551047 
    10561048/*************************************************************************** 
     
    10681060 ***************************************************************************/ 
    10691061int 
    1070 sl_ping (SLCD * slconn, char *serverid, char *site) 
     1062sl_ping (SLCD *slconn, char *serverid, char *site) 
    10711063{ 
    10721064  int servcnt = 0; 
    10731065  int sitecnt = 0; 
    1074   char sendstr[100];            /* A buffer for command strings */ 
    1075   char servstr[100];            /* The remote server ident */ 
    1076   char sitestr[100];            /* The site/data center ident */ 
    1077    
     1066  char sendstr[100]; /* A buffer for command strings */ 
     1067  char servstr[100]; /* The remote server ident */ 
     1068  char sitestr[100]; /* The site/data center ident */ 
     1069 
    10781070  /* Open network connection to server */ 
    1079   if ( sl_connect (slconn, 0) == -1 ) 
    1080     { 
    1081       sl_log_r (slconn, 2, 1, "Could not connect to server\n"); 
    1082       return -2; 
    1083     } 
    1084    
     1071  if (sl_connect (slconn, 0) == -1) 
     1072  { 
     1073    sl_log_r (slconn, 2, 1, "Could not connect to server\n"); 
     1074    return -2; 
     1075  } 
     1076 
    10851077  /* Send HELLO */ 
    10861078  sprintf (sendstr, "HELLO\r"); 
    10871079  sl_log_r (slconn, 1, 2, "[%s] sending: HELLO\n", slconn->sladdr); 
    1088   sl_senddata (slconn, (void *) sendstr, strlen (sendstr), slconn->sladdr, 
    1089                NULL, 0); 
    1090    
     1080  sl_senddata (slconn, (void *)sendstr, strlen (sendstr), slconn->sladdr, 
     1081               NULL, 0); 
     1082 
    10911083  /* Recv the two lines of response */ 
    1092   if ( sl_recvresp (slconn, (void *) servstr, (size_t) sizeof (servstr),  
    1093                     sendstr, slconn->sladdr) < 0 ) 
    1094     { 
    1095       return -1; 
    1096     } 
    1097    
    1098   if ( sl_recvresp (slconn, (void *) sitestr, (size_t) sizeof (sitestr), 
    1099                     sendstr, slconn->sladdr) < 0 ) 
    1100     { 
    1101       return -1; 
    1102     } 
    1103    
     1084  if (sl_recvresp (slconn, (void *)servstr, (size_t)sizeof (servstr), 
     1085                   sendstr, slconn->sladdr) < 0) 
     1086  { 
     1087    return -1; 
     1088  } 
     1089 
     1090  if (sl_recvresp (slconn, (void *)sitestr, (size_t)sizeof (sitestr), 
     1091                   sendstr, slconn->sladdr) < 0) 
     1092  { 
     1093    return -1; 
     1094  } 
     1095 
    11041096  servcnt = strcspn (servstr, "\r"); 
    1105   if ( servcnt > 90 ) 
    1106     { 
    1107       servcnt = 90; 
    1108     } 
     1097  if (servcnt > 90) 
     1098  { 
     1099    servcnt = 90; 
     1100  } 
    11091101  servstr[servcnt] = '\0'; 
    1110    
     1102 
    11111103  sitecnt = strcspn (sitestr, "\r"); 
    1112   if ( sitecnt > 90 ) 
    1113     { 
    1114       sitecnt = 90; 
    1115     } 
     1104  if (sitecnt > 90) 
     1105  { 
     1106    sitecnt = 90; 
     1107  } 
    11161108  sitestr[sitecnt] = '\0'; 
    1117    
     1109 
    11181110  /* Copy the response strings into the supplied strings */ 
    1119   strncpy (serverid, servstr, sizeof(servstr)); 
    1120   strncpy (site, sitestr, sizeof(sitestr)); 
    1121    
     1111  strncpy (serverid, servstr, sizeof (servstr)); 
     1112  strncpy (site, sitestr, sizeof (sitestr)); 
     1113 
    11221114  slconn->link = sl_disconnect (slconn); 
    1123    
     1115 
    11241116  return 0; 
    1125 }  /* End of sl_ping() */ 
    1126  
     1117} /* End of sl_ping() */ 
    11271118 
    11281119/*************************************************************************** 
     
    11391130 ***************************************************************************/ 
    11401131int 
    1141 sl_checksock (int sock, int tosec, int tousec) 
     1132sl_checksock (SOCKET sock, int tosec, int tousec) 
    11421133{ 
    11431134  int sret; 
    1144   int ret = -1;                 /* default is failure */ 
     1135  int ret = -1; /* default is failure */ 
    11451136  char testbuf[1]; 
    11461137  fd_set checkset; 
     
    11481139 
    11491140  FD_ZERO (&checkset); 
    1150   FD_SET ((unsigned int)sock, &checkset); 
    1151  
    1152   to.tv_sec = tosec; 
     1141  FD_SET (sock, &checkset); 
     1142 
     1143  to.tv_sec  = tosec; 
    11531144  to.tv_usec = tousec; 
    11541145 
     
    11571148    ret = 1; 
    11581149  else if (sret == 0) 
    1159     ret = 0;                    /* time-out expired */ 
     1150    ret = 0; /* time-out expired */ 
    11601151 
    11611152  /* Check read ability with recv() */ 
    11621153  if (ret && (recv (sock, testbuf, sizeof (char), MSG_PEEK)) <= 0) 
    1163     { 
    1164       if (! slp_noblockcheck()) 
    1165         ret = 1;                /* no data for non-blocking IO */ 
    1166       else 
    1167         ret = -1; 
    1168     } 
     1154  { 
     1155    if (!slp_noblockcheck ()) 
     1156      ret = 1; /* no data for non-blocking IO */ 
     1157    else 
     1158      ret = -1; 
     1159  } 
    11691160 
    11701161  return ret; 
    1171 }  /* End of sl_checksock() */ 
    1172  
     1162} /* End of sl_checksock() */ 
    11731163 
    11741164/*************************************************************************** 
     
    11861176 ***************************************************************************/ 
    11871177int 
    1188 sl_senddata (SLCD * slconn, void *buffer, size_t buflen, 
    1189              const char *ident, void *resp, int resplen) 
     1178sl_senddata (SLCD *slconn, void *buffer, size_t buflen, 
     1179             const char *ident, void *resp, int resplen) 
    11901180{ 
    1191    
    1192   int bytesread = 0;            /* bytes read into resp */ 
    1193    
    1194   if ( send (slconn->link, buffer, buflen, 0) < 0 ) 
    1195     { 
    1196       sl_log_r (slconn, 2, 0, "[%s] error sending '%.*s'\n", ident, 
    1197                 strcspn ((char *) buffer, "\r\n"), (char *) buffer); 
    1198       return -1; 
    1199     } 
    1200    
     1181 
     1182  int bytesread = 0; /* bytes read into resp */ 
     1183 
     1184  if (send (slconn->link, buffer, buflen, 0) < 0) 
     1185  { 
     1186    sl_log_r (slconn, 2, 0, "[%s] error sending '%.*s'\n", ident, 
     1187              strcspn ((char *)buffer, "\r\n"), (char *)buffer); 
     1188    return -1; 
     1189  } 
     1190 
    12011191  /* If requested collect the response */ 
    1202   if ( resp != NULL ) 
    1203     { 
    1204       /* Clear response buffer */ 
    1205       memset (resp, 0, resplen); 
    1206        
    1207       if ( slconn->batchmode == 2 ) 
    1208         { 
    1209           /* Fake OK response */ 
    1210           strcpy(resp, "OK\r\n"); 
    1211           bytesread = 4; 
    1212         } 
    1213       else 
    1214         { 
    1215           bytesread = sl_recvresp (slconn, resp, resplen, buffer, ident); 
    1216         } 
    1217     } 
    1218    
     1192  if (resp != NULL) 
     1193  { 
     1194    /* Clear response buffer */ 
     1195    memset (resp, 0, resplen); 
     1196 
     1197    if (slconn->batchmode == 2) 
     1198    { 
     1199      /* Fake OK response */ 
     1200      strcpy (resp, "OK\r\n"); 
     1201      bytesread = 4; 
     1202    } 
     1203    else 
     1204    { 
     1205      bytesread = sl_recvresp (slconn, resp, resplen, buffer, ident); 
     1206    } 
     1207  } 
     1208 
    12191209  return bytesread; 
    1220 }  /* End of sl_senddata() */ 
    1221  
     1210} /* End of sl_senddata() */ 
    12221211 
    12231212/*************************************************************************** 
     
    12321221 ***************************************************************************/ 
    12331222int 
    1234 sl_recvdata (SLCD * slconn, void *buffer, size_t maxbytes, 
    1235              const char *ident) 
     1223sl_recvdata (SLCD *slconn, void *buffer, size_t maxbytes, 
     1224             const char *ident) 
    12361225{ 
    12371226  int bytesread = 0; 
    1238    
    1239   if ( buffer == NULL ) 
    1240     { 
     1227 
     1228  if (buffer == NULL) 
     1229  { 
     1230    return -1; 
     1231  } 
     1232 
     1233  bytesread = recv (slconn->link, buffer, maxbytes, 0); 
     1234 
     1235  if (bytesread == 0) /* should indicate TCP FIN or EOF */ 
     1236  { 
     1237    sl_log_r (slconn, 1, 1, "[%s] recv():%d TCP FIN or EOF received\n", 
     1238              ident, bytesread); 
     1239    return -1; 
     1240  } 
     1241  else if (bytesread < 0) 
     1242  { 
     1243    if (slp_noblockcheck ()) 
     1244    { 
     1245      sl_log_r (slconn, 2, 0, "[%s] recv():%d %s\n", ident, bytesread, 
     1246                slp_strerror ()); 
    12411247      return -1; 
    12421248    } 
    1243    
    1244   bytesread = recv (slconn->link, buffer, maxbytes, 0); 
    1245    
    1246   if ( bytesread == 0 )         /* should indicate TCP FIN or EOF */ 
    1247     { 
    1248       sl_log_r (slconn, 1, 1, "[%s] recv():%d TCP FIN or EOF received\n", 
    1249                 ident, bytesread); 
    1250       return -1; 
    1251     } 
    1252   else if ( bytesread < 0 ) 
    1253     { 
    1254       if ( slp_noblockcheck() ) 
    1255         { 
    1256           sl_log_r (slconn, 2, 0, "[%s] recv():%d %s\n", ident, bytesread, 
    1257                     slp_strerror ()); 
    1258           return -1; 
    1259         } 
    1260  
    1261       /* no data available for NONBLOCKing IO */ 
    1262       return 0; 
    1263     } 
     1249 
     1250    /* no data available for NONBLOCKing IO */ 
     1251    return 0; 
     1252  } 
    12641253 
    12651254  return bytesread; 
    1266 }  /* End of sl_recvdata() */ 
    1267  
     1255} /* End of sl_recvdata() */ 
    12681256 
    12691257/*************************************************************************** 
     
    12841272 ***************************************************************************/ 
    12851273int 
    1286 sl_recvresp (SLCD * slconn, void *buffer, size_t maxbytes, 
    1287              const char *command, const char *ident) 
     1274sl_recvresp (SLCD *slconn, void *buffer, size_t maxbytes, 
     1275             const char *command, const char *ident) 
    12881276{ 
    1289    
    1290   int bytesread = 0;            /* total bytes read */ 
    1291   int recvret   = 0;            /* return from sl_recvdata */ 
    1292   int ackcnt    = 0;            /* counter for the read loop */ 
    1293   int ackpoll   = 50000;        /* poll at 0.05 seconds for reading */ 
    1294    
    1295   if ( buffer == NULL ) 
    1296     { 
    1297       return -1; 
    1298     } 
    1299    
     1277 
     1278  int bytesread = 0;     /* total bytes read */ 
     1279  int recvret   = 0;     /* return from sl_recvdata */ 
     1280  int ackcnt    = 0;     /* counter for the read loop */ 
     1281  int ackpoll   = 50000; /* poll at 0.05 seconds for reading */ 
     1282 
     1283  if (buffer == NULL) 
     1284  { 
     1285    return -1; 
     1286  } 
     1287 
    13001288  /* Clear the receiving buffer */ 
    13011289  memset (buffer, 0, maxbytes); 
    1302    
     1290 
    13031291  /* Recv a byte at a time and wait up to 30 seconds for a response */ 
    1304   while ( bytesread < maxbytes ) 
    1305     { 
    1306       recvret = sl_recvdata (slconn, (char *)buffer + bytesread, 1, ident); 
    1307        
    1308       /* Trap door for termination */ 
    1309       if ( slconn->terminate ) 
    1310         { 
    1311           return -1; 
    1312         } 
    1313        
    1314       if ( recvret > 0 ) 
    1315         { 
    1316           bytesread += recvret; 
    1317         } 
    1318       else if ( recvret < 0 ) 
    1319         { 
    1320           sl_log_r (slconn, 2, 0, "[%s] bad response to '%.*s'\n", 
    1321                     ident, strcspn ((char *) command, "\r\n"), 
    1322                     (char *) command); 
    1323           return -1; 
    1324         } 
    1325        
    1326       /* Trap door if '\r\n' is recv'd */ 
    1327       if ( bytesread >= 2 && 
    1328            *(char *)((char *)buffer + bytesread - 2) == '\r' && 
    1329            *(char *)((char *)buffer + bytesread - 1) == '\n' ) 
    1330         { 
    1331           return bytesread; 
    1332         } 
    1333        
    1334       /* Trap door if 30 seconds has elapsed, (ackpoll x 600) */ 
    1335       if ( ackcnt > 600 ) 
    1336         { 
    1337           sl_log_r (slconn, 2, 0, "[%s] timeout waiting for response to '%.*s'\n", 
    1338                     ident, strcspn ((char *) command, "\r\n"), 
    1339                     (char *) command); 
    1340           return -1; 
    1341         } 
    1342        
    1343       /* Delay if no data received */ 
    1344       if ( recvret == 0 ) 
    1345         { 
    1346           slp_usleep (ackpoll); 
    1347           ackcnt++; 
    1348         } 
    1349     } 
    1350    
     1292  while (bytesread < maxbytes) 
     1293  { 
     1294    recvret = sl_recvdata (slconn, (char *)buffer + bytesread, 1, ident); 
     1295 
     1296    /* Trap door for termination */ 
     1297    if (slconn->terminate) 
     1298    { 
     1299      return -1; 
     1300    } 
     1301 
     1302    if (recvret > 0) 
     1303    { 
     1304      bytesread += recvret; 
     1305    } 
     1306    else if (recvret < 0) 
     1307    { 
     1308      sl_log_r (slconn, 2, 0, "[%s] bad response to '%.*s'\n", 
     1309                ident, strcspn ((char *)command, "\r\n"), 
     1310                (char *)command); 
     1311      return -1; 
     1312    } 
     1313 
     1314    /* Trap door if '\r\n' is recv'd */ 
     1315    if (bytesread >= 2 && 
     1316        *(char *)((char *)buffer + bytesread - 2) == '\r' && 
     1317        *(char *)((char *)buffer + bytesread - 1) == '\n') 
     1318    { 
     1319      return bytesread; 
     1320    } 
     1321 
     1322    /* Trap door if 30 seconds has elapsed, (ackpoll x 600) */ 
     1323    if (ackcnt > 600) 
     1324    { 
     1325      sl_log_r (slconn, 2, 0, "[%s] timeout waiting for response to '%.*s'\n", 
     1326                ident, strcspn ((char *)command, "\r\n"), 
     1327                (char *)command); 
     1328      return -1; 
     1329    } 
     1330 
     1331    /* Delay if no data received */ 
     1332    if (recvret == 0) 
     1333    { 
     1334      slp_usleep (ackpoll); 
     1335      ackcnt++; 
     1336    } 
     1337  } 
     1338 
    13511339  return bytesread; 
    1352 }  /* End of sl_recvresp() */ 
     1340} /* End of sl_recvresp() */ 
  • trunk/src/data_exchange/slink2ew/libslink/slplatform.c

    r4078 r6839  
    11/*************************************************************************** 
    22 * slplatform.c: 
    3  *  
     3 * 
    44 * Platform portability routines. 
    55 * 
    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, ORFEUS/EC-Project MEREDIAN 
    19  * 
    20  * modified: 2008.029 
    21  ***************************************************************************/ 
    22  
     6 * modified: 2016.288 
     7 ***************************************************************************/ 
     8 
     9#include <errno.h> 
    2310#include <fcntl.h> 
    24 #include <errno.h> 
    2511#include <stdio.h> 
     12#include <string.h> 
     13#include <sys/stat.h> 
     14#include <sys/types.h> 
    2615#include <time.h> 
    27 #include <string.h> 
    28 #include <sys/types.h> 
    29 #include <sys/stat.h> 
    3016 
    3117#include "libslink.h" 
    32  
    3318 
    3419/*************************************************************************** 
     
    4833 
    4934  /* Check for Windows sockets version 2.2 */ 
    50   wVersionRequested = MAKEWORD( 2, 2 ); 
    51  
    52   if ( WSAStartup( wVersionRequested, &wsaData ) ) 
    53     return -1; 
    54  
    55 #endif 
    56  
    57   return 0; 
    58 }  /* End of slp_sockstartup() */ 
    59  
     35  wVersionRequested = MAKEWORD (2, 2); 
     36 
     37  if (WSAStartup (wVersionRequested, &wsaData)) 
     38    return -1; 
     39 
     40#endif 
     41 
     42  return 0; 
     43} /* End of slp_sockstartup() */ 
    6044 
    6145/*************************************************************************** 
     
    6751 ***************************************************************************/ 
    6852int 
    69 slp_sockconnect (int sock, struct sockaddr * inetaddr, int addrlen) 
     53slp_sockconnect (SOCKET sock, struct sockaddr *inetaddr, int addrlen) 
    7054{ 
    7155#if defined(SLP_WIN32) 
    7256  if ((connect (sock, inetaddr, addrlen)) == SOCKET_ERROR) 
    73     { 
    74       if (WSAGetLastError() != WSAEWOULDBLOCK) 
    75         return -1; 
    76     } 
     57  { 
     58    if (WSAGetLastError () != WSAEWOULDBLOCK) 
     59      return -1; 
     60  } 
    7761#else 
    7862  if ((connect (sock, inetaddr, addrlen)) == -1) 
    79     { 
    80       if (errno != EINPROGRESS) 
    81         return -1; 
    82     } 
    83 #endif 
    84  
    85   return 0; 
    86 }  /* End of slp_sockconnect() */ 
    87  
     63  { 
     64    if (errno != EINPROGRESS) 
     65      return -1; 
     66  } 
     67#endif 
     68 
     69  return 0; 
     70} /* End of slp_sockconnect() */ 
    8871 
    8972/*************************************************************************** 
     
    9578 ***************************************************************************/ 
    9679int 
    97 slp_sockclose (int sock) 
     80slp_sockclose (SOCKET sock) 
    9881{ 
    9982#if defined(SLP_WIN32) 
     
    10285  return close (sock); 
    10386#endif 
    104 }  /* End of slp_sockclose() */ 
    105  
     87} /* End of slp_sockclose() */ 
    10688 
    10789/*************************************************************************** 
     
    11395 ***************************************************************************/ 
    11496int 
    115 slp_socknoblock (int sock) 
     97slp_socknoblock (SOCKET sock) 
    11698{ 
    11799#if defined(SLP_WIN32) 
    118100  u_long flag = 1; 
    119101 
    120   if (ioctlsocket(sock, FIONBIO, &flag) == -1) 
    121     return -1; 
    122  
    123 #else 
    124   int flags = fcntl(sock, F_GETFL, 0); 
     102  if (ioctlsocket (sock, FIONBIO, &flag) == -1) 
     103    return -1; 
     104 
     105#else 
     106  int flags = fcntl (sock, F_GETFL, 0); 
    125107 
    126108  flags |= O_NONBLOCK; 
    127   if (fcntl(sock, F_SETFL, flags) == -1) 
    128     return -1; 
    129  
    130 #endif 
    131  
    132   return 0; 
    133 }  /* End of slp_socknoblock() */ 
    134  
     109  if (fcntl (sock, F_SETFL, flags) == -1) 
     110    return -1; 
     111 
     112#endif 
     113 
     114  return 0; 
     115} /* End of slp_socknoblock() */ 
    135116 
    136117/*************************************************************************** 
     
    144125{ 
    145126#if defined(SLP_WIN32) 
    146   if (WSAGetLastError() != WSAEWOULDBLOCK) 
     127  if (WSAGetLastError () != WSAEWOULDBLOCK) 
    147128    return -1; 
    148129 
     
    155136  /* no data available for NONBLOCKing IO */ 
    156137  return 0; 
    157 }  /* End of slp_noblockcheck() */ 
    158  
     138} /* End of slp_noblockcheck() */ 
    159139 
    160140/*************************************************************************** 
     
    174154 ***************************************************************************/ 
    175155int 
    176 slp_getaddrinfo (char * nodename, char * nodeport, 
    177                  struct sockaddr * addr, size_t * addrlen) 
     156slp_getaddrinfo (char *nodename, char *nodeport, 
     157                 struct sockaddr *addr, size_t *addrlen) 
    178158{ 
    179159#if defined(SLP_WIN32) 
     
    183163  char *tail; 
    184164 
    185   if ( (result = gethostbyname (nodename)) == NULL ) 
    186     { 
    187       return -1; 
    188     } 
     165  if ((result = gethostbyname (nodename)) == NULL) 
     166  { 
     167    return -1; 
     168  } 
    189169 
    190170  nport = strtoul (nodeport, &tail, 0); 
     
    192172  memset (&inet_addr, 0, sizeof (inet_addr)); 
    193173  inet_addr.sin_family = AF_INET; 
    194   inet_addr.sin_port = htons ((unsigned short int)nport); 
    195   inet_addr.sin_addr = *(struct in_addr *) result->h_addr_list[0]; 
    196    
    197   *addr = *((struct sockaddr *) &inet_addr); 
    198   *addrlen = sizeof(inet_addr); 
     174  inet_addr.sin_port   = htons ((unsigned short int)nport); 
     175  inet_addr.sin_addr   = *(struct in_addr *)result->h_addr_list[0]; 
     176 
     177  *addr    = *((struct sockaddr *)&inet_addr); 
     178  *addrlen = sizeof (inet_addr); 
    199179 
    200180#elif defined(SLP_GLIBC2) || defined(SLP_SOLARIS) 
     
    210190  char *tail; 
    211191 
    212   #if defined(SLP_GLIBC2) 
     192#if defined(SLP_GLIBC2) 
    213193  gethostbyname_r (nodename, &result_buffer, 
    214                    buffer, sizeof(buffer) - 1, 
    215                    &result, &my_error); 
    216   #endif 
    217  
    218   #if defined(SLP_SOLARIS) 
     194                   buffer, sizeof (buffer) - 1, 
     195                   &result, &my_error); 
     196#endif 
     197 
     198#if defined(SLP_SOLARIS) 
    219199  result = gethostbyname_r (nodename, &result_buffer, 
    220                             buffer, sizeof(buffer) - 1, 
    221                             &my_error); 
    222   #endif 
    223  
    224   if ( !result ) 
     200                            buffer, sizeof (buffer) - 1, 
     201                            &my_error); 
     202#endif 
     203 
     204  if (!result) 
    225205    return my_error; 
    226206 
     
    229209  memset (&inet_addr, 0, sizeof (inet_addr)); 
    230210  inet_addr.sin_family = AF_INET; 
    231   inet_addr.sin_port = htons ((unsigned short int)nport); 
    232   inet_addr.sin_addr = *(struct in_addr *) result->h_addr_list[0]; 
    233    
    234   *addr = *((struct sockaddr *) &inet_addr); 
    235   *addrlen = sizeof(inet_addr); 
     211  inet_addr.sin_port   = htons ((unsigned short int)nport); 
     212  inet_addr.sin_addr   = *(struct in_addr *)result->h_addr_list[0]; 
     213 
     214  *addr       = *((struct sockaddr *)&inet_addr); 
     215  *addrlen    = sizeof (inet_addr); 
    236216 
    237217#else 
     
    242222  struct addrinfo hints; 
    243223 
    244   memset (&hints, 0, sizeof(hints)); 
    245   hints.ai_family = PF_INET; 
     224  memset (&hints, 0, sizeof (hints)); 
     225  hints.ai_family   = PF_INET; 
    246226  hints.ai_socktype = SOCK_STREAM; 
    247    
    248   if ( getaddrinfo (nodename, nodeport, &hints, &result) ) 
    249     { 
    250       return -1; 
    251     } 
    252  
    253   *addr = *(result->ai_addr); 
     227 
     228  if (getaddrinfo (nodename, nodeport, &hints, &result)) 
     229  { 
     230    return -1; 
     231  } 
     232 
     233  *addr    = *(result->ai_addr); 
    254234  *addrlen = result->ai_addrlen; 
    255235 
     
    259239 
    260240  return 0; 
    261 }  /* End of slp_getaddrinfo() */ 
    262  
     241} /* End of slp_getaddrinfo() */ 
    263242 
    264243/*************************************************************************** 
     
    280259#if defined(SLP_WIN32) 
    281260  int flags = (perm == 'w') ? (_O_RDWR | _O_CREAT | _O_BINARY) : (_O_RDONLY | _O_BINARY); 
    282   int mode = (_S_IREAD | _S_IWRITE); 
    283 #else 
    284   int flags = (perm == 'w') ? (O_RDWR | O_CREAT) : O_RDONLY; 
     261  int mode  = (_S_IREAD | _S_IWRITE); 
     262#else 
     263  int flags   = (perm == 'w') ? (O_RDWR | O_CREAT) : O_RDONLY; 
    285264  mode_t mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); 
    286265#endif 
    287    
     266 
    288267  return open (filename, flags, mode); 
    289 }  /* End of slp_openfile() */ 
    290  
     268} /* End of slp_openfile() */ 
    291269 
    292270/*************************************************************************** 
     
    302280  static char errorstr[100]; 
    303281 
    304   snprintf (errorstr, sizeof(errorstr), "%d", WSAGetLastError()); 
    305   return (const char *) errorstr; 
    306  
    307 #else 
    308   return (const char *) strerror (errno); 
    309  
    310 #endif 
    311 }  /* End of slp_strerror() */ 
    312  
     282  snprintf (errorstr, sizeof (errorstr), "%d", WSAGetLastError ()); 
     283  return (const char *)errorstr; 
     284 
     285#else 
     286  return (const char *)strerror (errno); 
     287 
     288#endif 
     289} /* End of slp_strerror() */ 
    313290 
    314291/*************************************************************************** 
     
    327304 
    328305  static const __int64 SECS_BETWEEN_EPOCHS = 11644473600; 
    329   static const __int64 SECS_TO_100NS = 10000000; /* 10^7 */ 
     306  static const __int64 SECS_TO_100NS       = 10000000; /* 10^7 */ 
    330307 
    331308  __int64 UnixTime; 
     
    334311  double depoch; 
    335312 
    336   GetSystemTime(&SystemTime); 
    337   SystemTimeToFileTime(&SystemTime, &FileTime); 
     313  GetSystemTime (&SystemTime); 
     314  SystemTimeToFileTime (&SystemTime, &FileTime); 
    338315 
    339316  /* Get the full win32 epoch value, in 100ns */ 
    340   UnixTime = ((__int64)FileTime.dwHighDateTime << 32) +  
    341     FileTime.dwLowDateTime; 
     317  UnixTime = ((__int64)FileTime.dwHighDateTime << 32) + 
     318             FileTime.dwLowDateTime; 
    342319 
    343320  /* Convert to the Unix epoch */ 
    344321  UnixTime -= (SECS_BETWEEN_EPOCHS * SECS_TO_100NS); 
    345    
     322 
    346323  UnixTime /= SECS_TO_100NS; /* now convert to seconds */ 
    347    
    348   if ( (double)UnixTime != UnixTime ) 
    349     { 
    350       sl_log_r (NULL, 2, 0, "slp_dtime(): resulting value is too big for a double value\n"); 
    351     } 
    352    
    353   depoch = (double) UnixTime + ((double) SystemTime.wMilliseconds / 1000.0); 
     324 
     325  if ((double)UnixTime != UnixTime) 
     326  { 
     327    sl_log_r (NULL, 2, 0, "slp_dtime(): resulting value is too big for a double value\n"); 
     328  } 
     329 
     330  depoch = (double)UnixTime + ((double)SystemTime.wMilliseconds / 1000.0); 
    354331 
    355332  return depoch; 
     
    358335 
    359336  struct timeval tv; 
    360    
    361   gettimeofday (&tv, (struct timezone *) 0); 
    362   return ((double) tv.tv_sec + ((double) tv.tv_usec / 1000000.0)); 
    363  
    364 #endif 
    365 }  /* End of slp_dtime() */ 
    366  
     337 
     338  gettimeofday (&tv, (struct timezone *)0); 
     339  return ((double)tv.tv_sec + ((double)tv.tv_usec / 1000000.0)); 
     340 
     341#endif 
     342} /* End of slp_dtime() */ 
    367343 
    368344/*************************************************************************** 
    369345 * slp_usleep: 
    370  *  
     346 * 
    371347 * Sleep for a given number of microseconds.  Under Win32 use SleepEx() 
    372348 * and for all others use the POSIX.4 nanosleep(). 
     
    380356 
    381357#else 
    382    
     358 
    383359  struct timespec treq, trem; 
    384    
    385   treq.tv_sec = (time_t) (useconds / 1e6); 
    386   treq.tv_nsec = (long) ((useconds * 1e3) - (treq.tv_sec * 1e9)); 
    387    
     360 
     361  treq.tv_sec  = (time_t) (useconds / 1e6); 
     362  treq.tv_nsec = (long)((useconds * 1e3) - (treq.tv_sec * 1e9)); 
     363 
    388364  nanosleep (&treq, &trem); 
    389365 
    390366#endif 
    391 }  /* End of slp_usleep() */ 
     367} /* End of slp_usleep() */ 
  • trunk/src/data_exchange/slink2ew/libslink/slplatform.h

    r4078 r6839  
    11/*************************************************************************** 
    22 * slplatform.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. 
     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, ORFEUS/EC-Project MEREDIAN 
     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/>. 
    2020 * 
    21  * modified: 2008.078 
     21 * Copyright (C) 2016 Chad Trabant, IRIS Data Management Center 
     22 * 
     23 * modified: 2016.288 
    2224 ***************************************************************************/ 
    2325 
     
    2931#endif 
    3032 
    31  
    32   /* Portability to the XScale (ARM) architecture 
    33    * requires a packed attribute in certain places 
    34    * but this only works with GCC for now. 
    35    */ 
    36  
     33/* Portability to the XScale (ARM) architecture requires a packed 
     34 * attribute in certain places but this only works with GCC for now. */ 
    3735#if defined (__GNUC__) 
    3836  #define SLP_PACKED __attribute__ ((packed)) 
    3937#else 
    4038  #define SLP_PACKED 
    41 #endif   
    42  
    43   /* Make some guesses about the system libraries based 
    44    * on the architecture.  Currently the assumptions are: 
    45    * Linux => glibc2 (SLP_GLIBC2) 
    46    * Sun => Solaris (SLP_SOLARIS) 
    47    * WIN32 => WIN32 and Windows Sockets 2 (SLP_WIN32) 
    48    * Apple => Mac OS X (SLP_DARWIN) 
    49    */ 
     39#endif 
    5040 
    5141#if defined(__linux__) || defined(__linux) 
    52   #define SLP_GLIBC2 1 
     42  #define SLP_LINUX 1 
    5343 
    5444  #include <stdlib.h> 
     
    6050  #include <netdb.h> 
    6151  #include <sys/time.h> 
    62     
     52 
    6353#elif defined(__sun__) || defined(__sun) 
    6454  #define SLP_SOLARIS 1 
     
    7666  #include <sys/time.h> 
    7767 
    78 #elif defined(WIN32) 
     68#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) 
    7969  #define SLP_WIN32 1 
    8070 
     71  #include <winsock2.h> 
    8172  #include <windows.h> 
    8273  #include <stdarg.h> 
    83   #include <winsock.h> 
    8474  #include <io.h> 
    8575 
     
    123113#endif 
    124114 
     115/* Use int for SOCKET if platform includes have not defined it */ 
     116#ifndef SOCKET 
     117  #define SOCKET int 
     118#endif 
     119 
    125120extern int slp_sockstartup (void); 
    126 extern int slp_sockconnect (int sock, struct sockaddr * inetaddr, int addrlen); 
    127 extern int slp_sockclose (int sock); 
    128 extern int slp_socknoblock (int sock); 
     121extern int slp_sockconnect (SOCKET sock, struct sockaddr * inetaddr, int addrlen); 
     122extern int slp_sockclose (SOCKET sock); 
     123extern int slp_socknoblock (SOCKET sock); 
    129124extern int slp_noblockcheck (void); 
    130 extern int slp_getaddrinfo (char * nodename, char * nodeport,  
     125extern int slp_getaddrinfo (char * nodename, char * nodeport, 
    131126                            struct sockaddr * addr, size_t * addrlen); 
    132127extern int slp_openfile (const char *filename, char perm); 
     
    138133} 
    139134#endif 
    140   
     135 
    141136#endif /* SLPLATFORM_H */ 
  • trunk/src/data_exchange/slink2ew/libslink/slutils.c

    r4843 r6839  
    66 * Written by Chad Trabant, ORFEUS/EC-Project MEREDIAN 
    77 * 
    8  * modified: 2012.152 
     8 * modified: 2016.287 
    99 ***************************************************************************/ 
    1010 
     11#include <errno.h> 
     12#include <stdio.h> 
    1113#include <stdlib.h> 
    12 #include <stdio.h> 
    13 #include <errno.h> 
    1414#include <string.h> 
    1515 
     
    1919 
    2020/* Function(s) only used in this source file */ 
    21 int update_stream (SLCD * slconn, SLpacket * slpack); 
    22  
     21int update_stream (SLCD *slconn, SLpacket *slpack); 
    2322 
    2423/*************************************************************************** 
     
    3736 ***************************************************************************/ 
    3837int 
    39 sl_collect (SLCD * slconn, SLpacket ** slpack) 
     38sl_collect (SLCD *slconn, SLpacket **slpack) 
    4039{