Changeset 6842


Ignore:
Timestamp:
10/18/16 02:39:20 (3 years ago)
Author:
chad
Message:

libdali: update to version 1.7

Location:
trunk/src/libsrc/libdali
Files:
3 added
1 deleted
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/libsrc/libdali/ChangeLog

    r5981 r6842  
     12016.10.17: 1.7 
     2        - Change socket type to SOCKET and set appropriately for platform. 
     3        - Modernize portable.[ch], change DLP_WIN32 to DLP_WIN and DLP_GLIBC2 
     4        to DLP_WIN and re-oragnize includes. 
     5        - Change host name resolution to use getaddrinfo() on all platforms 
     6        except Windows.  Support is now nearly ubiquitous.  Still limited to 
     7        IPv4 addresses. 
     8        - Cleanup make files, remove unused targets and need for ntwin32.mak. 
     9        - Add target for Cygwin to portable.h. 
     10        - Clarify licensing to be LGPLv3, include LICENSE.txt and INSTALL. 
     11        - Reformat all source code using included clang-format profile. 
     12 
    1132013.210: 1.6 
    214        - dl_position(): return 0 when packet was not found.  Differentiates 
  • trunk/src/libsrc/libdali/Makefile

    r6819 r6842  
    33# environment variables: 
    44#   CC : Specify the C compiler to use 
    5 #   GLOBALFLAGS : Specify compiler options to use 
     5#   CFLAGS : Specify compiler options to use 
    66 
    7 CFLAGS = $(GLOBALFLAGS) 
    87 
    9 # GCC specific parameters 
    10 GCC = gcc 
    11 GCCFLAGS = -O2 -Wall 
     8MAJOR_VER = 1 
     9MINOR_VER = 7 
     10CURRENT_VER = $(MAJOR_VER).$(MINOR_VER) 
     11COMPAT_VER = $(MAJOR_VER).$(MINOR_VER) 
    1212 
    13 LIB_OBJS = timeutils.o genutils.o strutils.o \ 
    14            logging.o network.o statefile.o config.o \ 
    15            portable.o connection.o 
     13LIB_SRCS = timeutils.c genutils.c strutils.c \ 
     14           logging.c network.c statefile.c config.c \ 
     15           portable.c connection.c 
    1616 
    17 CURRENT_VER = 1.3 
    18 COMPAT_VER = 1.3 
     17LIB_OBJS = $(LIB_SRCS:.c=.o) 
     18LIB_DOBJS = $(LIB_SRCS:.c=.lo) 
    1919 
    2020LIB_A = libdali.a 
    21 LIB_SO = libdali.so.$(CURRENT_VER) 
    22 LIB_SO_ALIAS = libdali.so 
     21LIB_SO_FILENAME = libdali.so 
     22LIB_SO_ALIAS = $(LIB_SO_FILENAME).$(MAJOR_VER) 
     23LIB_SO = $(LIB_SO_FILENAME).$(CURRENT_VER) 
     24LIB_DYN_ALIAS = libdali.dylib 
    2325LIB_DYN = libdali.$(CURRENT_VER).dylib 
    24 LIB_DYN_ALIAS = libdali.dylib 
    2526 
    2627all: static 
     
    3334 
    3435$(LIB_A): $(LIB_OBJS) 
    35         ar -rcs $(LIB_A) $(LIB_OBJS) 
     36        rm -f $(LIB_A) 
     37        ar -crs $(LIB_A) $(LIB_OBJS) 
    3638 
    37 $(LIB_SO): $(LIB_OBJS) 
    38         $(CC) -shared -Wl,-soname -Wl,$(LIB_SO_ALIAS) -o $(LIB_SO) $(LIB_OBJS) 
     39$(LIB_SO): $(LIB_DOBJS) 
     40        rm -f $(LIB_SO) $(LIB_SO_ALIAS) $(LIB_SO_FILENAME) 
     41        $(CC) $(CFLAGS) -shared -Wl,-soname -Wl,$(LIB_SO_ALIAS) -o $(LIB_SO) $(LIB_DOBJS) 
    3942        ln -s $(LIB_SO) $(LIB_SO_ALIAS) 
     43        ln -s $(LIB_SO) $(LIB_SO_FILENAME) 
    4044 
    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)" 
     45$(LIB_DYN): $(LIB_DOBJS) 
     46        rm -f $(LIB_DYN) $(LIB_DYN_ALIAS) 
     47        $(CC) $(CFLAGS) -dynamiclib -compatibility_version $(COMPAT_VER) -current_version $(CURRENT_VER) -install_name $(LIB_DYN_ALIAS) -o $(LIB_DYN) $(LIB_DOBJS) 
     48        ln -sf $(LIB_DYN) $(LIB_DYN_ALIAS) 
    5649 
    5750clean: 
    58         rm -f $(LIB_OBJS) $(LIB_A) $(LIB_SO) $(LIB_SO_ALIAS) $(LIB_DYN) $(LIB_DYN_ALIAS) 
     51        rm -f $(LIB_OBJS) $(LIB_DOBJS) $(LIB_A) $(LIB_SO) $(LIB_SO_ALIAS) \ 
     52              $(LIB_SO_FILENAME) $(LIB_DYN) $(LIB_DYN_ALIAS) 
    5953 
    6054install: 
    6155        @echo 
    62         @echo "No install method, copy the library, header file, and" 
     56        @echo "No install method, copy the library, header files, and" 
    6357        @echo "documentation to the preferred install location" 
    6458        @echo 
     59 
     60.SUFFIXES: .c .o .lo 
     61 
     62# Standard object building 
     63.c.o: 
     64        $(CC) $(CFLAGS) -c $< -o $@ 
     65 
     66# Standard object building for dynamic library components using -fPIC 
     67.c.lo: 
     68        $(CC) $(CFLAGS) -fPIC -c $< -o $@ 
  • trunk/src/libsrc/libdali/Makefile.win

    r5978 r6842  
    11# 
    2 # 
    3 # Nmake File - MS Visual C++ version 
     2# Nmake File - MS Visual C/C++ 
    43# Use 'nmake -f Makefile.win' 
    54 
    65NODEBUG=1 
    76 
    8 !include <ntwin32.mak> 
    9  
    107INCS = /I. 
     8OPTS = -D_CRT_SECURE_NO_WARNINGS 
    119LIB = libdali.lib 
    1210DLL = libdali.dll 
     
    2018        config.obj      \ 
    2119        portable.obj    \ 
    22         connection.obj   
     20        connection.obj 
    2321 
    2422all: lib 
     
    3129 
    3230.c.obj: 
    33         $(cc) /nologo $(cflags) $(cdebug) $(cvarsmt) $(tflags) $(INCS) $< 
    34  
     31        $(CC) /nologo $(CFLAGS) $(INCS) $(OPTS) /c $< 
    3532 
    3633# Clean-up directives 
  • trunk/src/libsrc/libdali/README

    r5978 r6842  
    77'doc' directory, including a Users Guide and man pages. 
    88 
    9 Installation instructions for libdali: the DataLink 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 'libdali.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 'libdali.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 (libdali.a, libdali.so* and/or libdali.*.dylib) into a 
    39 system library directory and copy the associated header file 
    40 (libdali.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. 
    4213 
    4314-- Extras -- 
     
    5425condition that each connection parameter set (DLCP) is handled by a 
    5526single thread.  Thread independent logging schemes are possible. 
    56 Under WIN32 the library is not thread-safe. 
     27Under Windows the library is probably not thread-safe. 
     28 
     29-- Licensing -- 
     30 
     31Copyright (C) 2016 Chad Trabant, IRIS Data Management Center 
     32 
     33This library is free software; you can redistribute it and/or modify 
     34it under the terms of the GNU Lesser General Public License as 
     35published by the Free Software Foundation; either version 3 of the 
     36License, or (at your option) any later version. 
     37 
     38This library is distributed in the hope that it will be useful, but 
     39WITHOUT ANY WARRANTY; without even the implied warranty of 
     40MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
     41Lesser General Public License (GNU-LGPL) for more details. 
     42 
     43You should have received a copy of the GNU Lesser General Public 
     44License along with this software. 
     45If not, see <https://www.gnu.org/licenses/>. 
     46 
     47-- Acknowlegements -- 
     48 
     49Numerous improvements have been incorporated based on feedback and 
     50patches submitted by others.  Individual acknowlegements are included 
     51in the ChangeLog. 
    5752 
    5853-- Pronunciation -- 
     
    6055lib = 'l' + [eye] + 'b'  (as in library, long 'i') 
    6156dali = 'da' + [lee] (as in Salvador Dali) 
    62  
    63 -- Licensing -- 
    64  
    65 This library is free software; you can redistribute it and/or 
    66 modify it under the terms of the GNU Library General Public License 
    67 as published by the Free Software Foundation; either version 2 of 
    68 the License, or (at your option) any later version. 
    69  
    70 This library is distributed in the hope that it will be useful, but 
    71 WITHOUT ANY WARRANTY; without even the implied warranty of 
    72 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
    73 Library General Public License (GNU-LGPL) for more details.  The 
    74 GNU-LGPL and further information can be found here: 
    75 http://www.gnu.org/ 
    76  
    77 -- Author -- 
    78  
    79 Chad Trabant 
    80 IRIS Data Management Center 
  • trunk/src/libsrc/libdali/config.c

    r5978 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file config.c: 
    33 * 
     
    1010 ***************************************************************************/ 
    1111 
     12#include <ctype.h> 
     13#include <errno.h> 
    1214#include <stdio.h> 
    13 #include <errno.h> 
    1415#include <string.h> 
    15 #include <ctype.h> 
    1616 
    1717#include "libdali.h" 
    1818 
    19  
    20 /***********************************************************************//** 
     19/***********************************************************************/ /** 
    2120 * @brief Create a compound regular expression from a list in a file 
    2221 * 
     
    3635  int count = 0; 
    3736  int idx; 
    38    
     37 
    3938  /* Open the stream list file */ 
    40   if ( (streamfd = dlp_openfile (streamfile, 'r')) < 0 ) 
     39  if ((streamfd = dlp_openfile (streamfile, 'r')) < 0) 
     40  { 
     41    if (errno == ENOENT) 
    4142    { 
    42       if ( errno == ENOENT ) 
    43         { 
    44           dl_log_r (dlconn, 2, 0, "could not find stream list file: %s\n", streamfile); 
    45           return NULL; 
    46         } 
    47       else 
    48         { 
    49           dl_log_r (dlconn, 2, 0, "opening stream list file, %s\n", strerror (errno)); 
    50           return NULL; 
    51         } 
     43      dl_log_r (dlconn, 2, 0, "could not find stream list file: %s\n", streamfile); 
     44      return NULL; 
    5245    } 
    53    
     46    else 
     47    { 
     48      dl_log_r (dlconn, 2, 0, "opening stream list file, %s\n", strerror (errno)); 
     49      return NULL; 
     50    } 
     51  } 
     52 
    5453  dl_log_r (dlconn, 1, 1, "Reading list of streams from %s\n", streamfile); 
    55    
    56   while ( (dl_readline (streamfd, line, sizeof(line))) >= 0 ) 
    57     { 
    58       ptr = line; 
    59        
    60       /* Trim initial white space */ 
    61       while ( isspace ((int) *ptr) ) 
    62         ptr++; 
    63        
    64       /* Trim trailing white space */ 
    65       idx = strlen(ptr) - 1; 
    66       while ( idx >= 0 && isspace ((int) ptr[idx]) ) 
    67         ptr[idx--] = '\0'; 
    68        
    69       /* Ignore blank or comment lines */ 
    70       if ( strlen(ptr) == 0 || ptr[0] == '#' || ptr[0] == '*' ) 
    71         continue; 
    72        
    73       /* Add this stream to the stream chain */ 
    74       if ( dl_addtostring (&regex, ptr, "|", MAXREGEXSIZE) ) 
    75         { 
    76           dl_log_r (dlconn, 2, 0, "no streams defined in %s\n", streamfile); 
    77           return NULL; 
    78         } 
    79        
    80       count++; 
    81     } 
    82    
    83   if ( count == 0 ) 
     54 
     55  while ((dl_readline (streamfd, line, sizeof (line))) >= 0) 
     56  { 
     57    ptr = line; 
     58 
     59    /* Trim initial white space */ 
     60    while (isspace ((int)*ptr)) 
     61      ptr++; 
     62 
     63    /* Trim trailing white space */ 
     64    idx = strlen (ptr) - 1; 
     65    while (idx >= 0 && isspace ((int)ptr[idx])) 
     66      ptr[idx--] = '\0'; 
     67 
     68    /* Ignore blank or comment lines */ 
     69    if (strlen (ptr) == 0 || ptr[0] == '#' || ptr[0] == '*') 
     70      continue; 
     71 
     72    /* Add this stream to the stream chain */ 
     73    if (dl_addtostring (&regex, ptr, "|", MAXREGEXSIZE)) 
    8474    { 
    8575      dl_log_r (dlconn, 2, 0, "no streams defined in %s\n", streamfile); 
    86     } 
    87   else if ( count > 0 ) 
    88     { 
    89       dl_log_r (dlconn, 1, 2, "Read %d streams from %s\n", count, streamfile); 
    90     } 
    91    
    92   if ( close (streamfd) ) 
    93     { 
    94       dl_log_r (dlconn, 2, 0, "closing stream list file, %s\n", strerror (errno)); 
    9576      return NULL; 
    9677    } 
    97    
     78 
     79    count++; 
     80  } 
     81 
     82  if (count == 0) 
     83  { 
     84    dl_log_r (dlconn, 2, 0, "no streams defined in %s\n", streamfile); 
     85  } 
     86  else if (count > 0) 
     87  { 
     88    dl_log_r (dlconn, 1, 2, "Read %d streams from %s\n", count, streamfile); 
     89  } 
     90 
     91  if (close (streamfd)) 
     92  { 
     93    dl_log_r (dlconn, 2, 0, "closing stream list file, %s\n", strerror (errno)); 
     94    return NULL; 
     95  } 
     96 
    9897  return regex; 
    99 }  /* End of dl_read_streamlist() */ 
     98} /* End of dl_read_streamlist() */ 
  • trunk/src/libsrc/libdali/connection.c

    r5981 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file connection.c 
    33 * 
     
    66 * @author Chad Trabant, IRIS Data Management Center 
    77 * 
    8  * modified: 2013.210 
     8 * modified: 2016.291 
    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 
     
    1717#include "portable.h" 
    1818 
    19 /***********************************************************************//** 
     19/***********************************************************************/ /** 
    2020 * @brief Create a new DataLink Connection Parameter (DLCP) structure 
    2121 * 
     
    3131{ 
    3232  DLCP *dlconn; 
    33    
    34   dlconn = (DLCP *) malloc (sizeof(DLCP)); 
    35    
    36   if ( dlconn == NULL ) 
    37     { 
    38       dl_log_r (NULL, 2, 0, "dl_newdlcp(): error allocating memory\n"); 
    39       return NULL; 
    40     } 
    41    
     33 
     34  dlconn = (DLCP *)malloc (sizeof (DLCP)); 
     35 
     36  if (dlconn == NULL) 
     37  { 
     38    dl_log_r (NULL, 2, 0, "dl_newdlcp(): error allocating memory\n"); 
     39    return NULL; 
     40  } 
     41 
    4242  /* Set defaults */ 
    43   strncpy (dlconn->addr, address, sizeof(dlconn->addr)); 
    44   dlp_genclientid (progname, dlconn->clientid, sizeof(dlconn->clientid)); 
    45   dlconn->keepalive    = 600; 
    46   dlconn->iotimeout    = 60; 
    47   dlconn->link         = -1; 
    48   dlconn->serverproto  = 0.0; 
    49   dlconn->maxpktsize   = 0; 
    50   dlconn->writeperm    = 0; 
    51   dlconn->pktid        = 0; 
    52   dlconn->pkttime      = 0; 
     43  strncpy (dlconn->addr, address, sizeof (dlconn->addr)); 
     44  if (dlp_genclientid (progname, dlconn->clientid, sizeof (dlconn->clientid)) < 0) 
     45    dlconn->clientid[0]  = '\0'; 
     46  dlconn->keepalive      = 600; 
     47  dlconn->iotimeout      = 60; 
     48  dlconn->link           = -1; 
     49  dlconn->serverproto    = 0.0; 
     50  dlconn->maxpktsize     = 0; 
     51  dlconn->writeperm      = 0; 
     52  dlconn->pktid          = 0; 
     53  dlconn->pkttime        = 0; 
    5354  dlconn->keepalive_trig = -1; 
    54   dlconn->keepalive_time = 0.0; 
    55   dlconn->terminate    = 0; 
    56   dlconn->streaming    = 0; 
    57    
     55  dlconn->keepalive_time = 0; 
     56  dlconn->terminate      = 0; 
     57  dlconn->streaming      = 0; 
     58 
    5859  dlconn->log = NULL; 
    59    
     60 
    6061  return dlconn; 
    61 }  /* End of dl_newdlcp() */ 
    62  
    63  
    64 /***********************************************************************//** 
     62} /* End of dl_newdlcp() */ 
     63 
     64/***********************************************************************/ /** 
    6565 * @brief Free a DataLink Connection Parameter (DLCP) structure 
    6666 * 
     
    7272dl_freedlcp (DLCP *dlconn) 
    7373{ 
    74   if ( dlconn->log ) 
     74  if (dlconn->log) 
    7575    free (dlconn->log); 
    76    
     76 
    7777  free (dlconn); 
    78 }  /* End of dl_freedlcp() */ 
    79  
    80  
    81 /***********************************************************************//** 
     78} /* End of dl_freedlcp() */ 
     79 
     80/***********************************************************************/ /** 
    8281 * @brief Send the ID command to the DataLink server and parse response 
    8382 * 
     
    9594dl_exchangeIDs (DLCP *dlconn, int parseresp) 
    9695{ 
    97   char sendstr[255];            /* Buffer for command strings */ 
    98   char respstr[255];            /* Buffer for server response */   
    99   char *capptr;                 /* Pointer to capabilities flags */   
     96  char sendstr[255]; /* Buffer for command strings */ 
     97  char respstr[255]; /* Buffer for server response */ 
     98  char *capptr;      /* Pointer to capabilities flags */ 
    10099  int respsize; 
    101100  int ret = 0; 
    102101 
    103   if ( ! dlconn ) 
    104     return -1; 
    105    
     102  if (!dlconn) 
     103    return -1; 
     104 
    106105  /* Sanity check that connection is not in streaming mode */ 
    107   if ( dlconn->streaming ) 
    108     { 
    109       dl_log_r (dlconn, 1, 1, "[%s] dl_exchangeIDs(): Connection in streaming mode, cannot continue\n", 
    110                 dlconn->addr); 
    111       return -1; 
    112     } 
    113    
     106  if (dlconn->streaming) 
     107  { 
     108    dl_log_r (dlconn, 1, 1, "[%s] dl_exchangeIDs(): Connection in streaming mode, cannot continue\n", 
     109              dlconn->addr); 
     110    return -1; 
     111  } 
     112 
    114113  /* Send ID command including client ID */ 
    115   snprintf (sendstr, sizeof(sendstr), "ID %s", 
    116             (dlconn->clientid) ? dlconn->clientid : ""); 
     114  snprintf (sendstr, sizeof (sendstr), "ID %s", 
     115            (dlconn->clientid[0] == '\0') ? dlconn->clientid : ""); 
    117116  dl_log_r (dlconn, 1, 2, "[%s] sending: %s\n", dlconn->addr, sendstr); 
    118    
     117 
    119118  respsize = dl_sendpacket (dlconn, sendstr, strlen (sendstr), NULL, 0, 
    120                             respstr, sizeof(respstr)); 
    121    
     119                            respstr, sizeof (respstr)); 
     120 
    122121  /* Check for errors */ 
    123   if ( respsize < 0 ) 
    124     { 
    125       return -1; 
    126     } 
    127    
     122  if (respsize < 0) 
     123  { 
     124    return -1; 
     125  } 
     126 
    128127  /* Check minimum server ID response size */ 
    129   if ( respsize < 11 ) 
    130     { 
    131       dl_log_r (dlconn, 1, 2, "[%s] Server ID response too short: %d\n", 
    132                 dlconn->addr, respstr); 
    133       return -1; 
    134     } 
    135    
     128  if (respsize < 11) 
     129  { 
     130    dl_log_r (dlconn, 1, 2, "[%s] Server ID response too short: %d\n", 
     131              dlconn->addr, respstr); 
     132    return -1; 
     133  } 
     134 
    136135  /* Make sure the response string is terminated */ 
    137136  respstr[respsize] = '\0'; 
    138    
     137 
    139138  /* Verify DataLink signature in server response */ 
    140   if ( strncasecmp (respstr, "ID DATALINK", 11) ) 
    141     { 
    142       dl_log_r (dlconn, 1, 1, 
    143                 "[%s] dl_exchangeIDs(): Unrecognized server ID: %11.11s\n", 
    144                 dlconn->addr, respstr); 
    145       return -1; 
    146     } 
    147    
     139  if (strncasecmp (respstr, "ID DATALINK", 11)) 
     140  { 
     141    dl_log_r (dlconn, 1, 1, 
     142              "[%s] dl_exchangeIDs(): Unrecognized server ID: %11.11s\n", 
     143              dlconn->addr, respstr); 
     144    return -1; 
     145  } 
     146 
    148147  /* Parse the response from the server if requested */ 
    149   if ( parseresp ) 
    150     { 
    151       /* Search for capabilities flags in server ID by looking for "::" 
     148  if (parseresp) 
     149  { 
     150    /* Search for capabilities flags in server ID by looking for "::" 
    152151       * The expected format of the complete server ID is: 
    153152       * "ID DataLink <optional text> <:: optional capability flags>" 
    154153       */ 
    155       capptr = strstr (respstr, "::"); 
    156       if ( capptr ) 
    157         { 
    158           /* Truncate server ID portion of string */ 
    159           *capptr = '\0'; 
    160            
    161           /* Move pointer to beginning of flags */ 
    162           capptr += 2; 
    163            
    164           /* Move capptr up to first non-space character */ 
    165           while ( *capptr == ' ' ) 
    166             capptr++; 
    167         } 
    168        
    169       /* Report received server ID (without the initial "ID ") */ 
    170       dl_log_r (dlconn, 1, 1, "[%s] connected to: %s\n", dlconn->addr, respstr+3); 
    171       if ( capptr ) 
    172         dl_log_r (dlconn, 1, 1, "[%s] capabilities: %s\n", dlconn->addr, capptr); 
    173        
    174       /* Check capabilities flags */ 
    175       if ( capptr ) 
    176         { 
    177           char *tptr; 
    178            
    179           /* Parse protocol version flag: "DLPROTO:<#.#>" if present */ 
    180           if ( (tptr = strstr(capptr, "DLPROTO")) ) 
    181             { 
    182               /* Parse protocol version as a float */ 
    183               ret = sscanf (tptr, "DLPROTO:%f", &dlconn->serverproto); 
    184                
    185               if ( ret != 1 ) 
    186                 dl_log_r (dlconn, 1, 1, 
    187                           "[%s] dl_exchangeIDs(): could not parse protocol version from DLPROTO flag: %s\n", 
    188                           dlconn->addr, tptr); 
    189             } 
    190            
    191           /* Parse server packet size flag: "PACKETSIZE:<#>" if present */ 
    192           if ( (tptr = strstr(capptr, "PACKETSIZE")) ) 
    193             { 
    194               /* Parse protocol version as an integer */ 
    195               ret = sscanf (tptr, "PACKETSIZE:%d", &dlconn->maxpktsize); 
    196                
    197               if ( ret != 1 ) 
    198                 dl_log_r (dlconn, 1, 1, 
    199                           "[%s] dl_exchangeIDs(): could not parse packet size from PACKETSIZE flag: %s\n", 
    200                           dlconn->addr, tptr); 
    201             } 
    202            
    203           /* Search for write permission flag */ 
    204           if ( (tptr = strstr(capptr, "WRITE")) ) 
    205             { 
    206               dlconn->writeperm = 1; 
    207             } 
    208         } 
    209     } 
    210    
     154    capptr = strstr (respstr, "::"); 
     155    if (capptr) 
     156    { 
     157      /* Truncate server ID portion of string */ 
     158      *capptr = '\0'; 
     159 
     160      /* Move pointer to beginning of flags */ 
     161      capptr += 2; 
     162 
     163      /* Move capptr up to first non-space character */ 
     164      while (*capptr == ' ') 
     165        capptr++; 
     166    } 
     167 
     168    /* Report received server ID (without the initial "ID ") */ 
     169    dl_log_r (dlconn, 1, 1, "[%s] connected to: %s\n", dlconn->addr, respstr + 3); 
     170    if (capptr) 
     171      dl_log_r (dlconn, 1, 1, "[%s] capabilities: %s\n", dlconn->addr, capptr); 
     172 
     173    /* Check capabilities flags */ 
     174    if (capptr) 
     175    { 
     176      char *tptr; 
     177 
     178      /* Parse protocol version flag: "DLPROTO:<#.#>" if present */ 
     179      if ((tptr = strstr (capptr, "DLPROTO"))) 
     180      { 
     181        /* Parse protocol version as a float */ 
     182        ret = sscanf (tptr, "DLPROTO:%f", &dlconn->serverproto); 
     183 
     184        if (ret != 1) 
     185          dl_log_r (dlconn, 1, 1, 
     186                    "[%s] dl_exchangeIDs(): could not parse protocol version from DLPROTO flag: %s\n", 
     187                    dlconn->addr, tptr); 
     188      } 
     189 
     190      /* Parse server packet size flag: "PACKETSIZE:<#>" if present */ 
     191      if ((tptr = strstr (capptr, "PACKETSIZE"))) 
     192      { 
     193        /* Parse protocol version as an integer */ 
     194        ret = sscanf (tptr, "PACKETSIZE:%d", &dlconn->maxpktsize); 
     195 
     196        if (ret != 1) 
     197          dl_log_r (dlconn, 1, 1, 
     198                    "[%s] dl_exchangeIDs(): could not parse packet size from PACKETSIZE flag: %s\n", 
     199                    dlconn->addr, tptr); 
     200      } 
     201 
     202      /* Search for write permission flag */ 
     203      if ((tptr = strstr (capptr, "WRITE"))) 
     204      { 
     205        dlconn->writeperm = 1; 
     206      } 
     207    } 
     208  } 
     209 
    211210  return 0; 
    212 }  /* End of dl_exchangeIDs() */ 
    213  
    214  
    215 /***********************************************************************//** 
     211} /* End of dl_exchangeIDs() */ 
     212 
     213/***********************************************************************/ /** 
    216214 * @brief Position the client read position 
    217215 * 
     
    243241  int replylen; 
    244242  int rv; 
    245    
    246   if ( ! dlconn ) 
    247     return -1; 
    248    
    249   if ( dlconn->link < 0 ) 
    250     return -1; 
    251    
    252   if ( pktid < 0 && pktid != LIBDALI_POSITION_EARLIEST && pktid != LIBDALI_POSITION_LATEST ) 
    253     return -1; 
    254    
     243 
     244  if (!dlconn) 
     245    return -1; 
     246 
     247  if (dlconn->link < 0) 
     248    return -1; 
     249 
     250  if (pktid < 0 && pktid != LIBDALI_POSITION_EARLIEST && pktid != LIBDALI_POSITION_LATEST) 
     251    return -1; 
     252 
    255253  /* Sanity check that connection is not in streaming mode */ 
    256   if ( dlconn->streaming ) 
    257     { 
    258       dl_log_r (dlconn, 1, 1, "[%s] dl_position(): Connection in streaming mode, cannot continue\n", 
    259                 dlconn->addr); 
    260       return -1; 
    261     } 
    262    
     254  if (dlconn->streaming) 
     255  { 
     256    dl_log_r (dlconn, 1, 1, "[%s] dl_position(): Connection in streaming mode, cannot continue\n", 
     257              dlconn->addr); 
     258    return -1; 
     259  } 
     260 
    263261  /* When positioning to earliest or latest packet in the ring, ignore pkttime */ 
    264   if ( pktid == LIBDALI_POSITION_EARLIEST ) 
    265     { 
    266       /* Create packet header with command: "POSITION SET EARLIEST" */ 
    267       headerlen = snprintf (header, sizeof(header), "POSITION SET EARLIEST"); 
    268     } 
    269   else if ( pktid == LIBDALI_POSITION_LATEST ) 
    270     { 
    271       /* Create packet header with command: "POSITION SET LATEST" */ 
    272       headerlen = snprintf (header, sizeof(header), "POSITION SET LATEST"); 
    273     } 
    274   else  
    275     { 
    276       /* Create packet header with command: "POSITION SET pktid pkttime" */ 
    277       headerlen = snprintf (header, sizeof(header), "POSITION SET %lld %lld", 
    278                             (long long int)pktid, (long long int)pkttime); 
    279     } 
    280    
     262  if (pktid == LIBDALI_POSITION_EARLIEST) 
     263  { 
     264    /* Create packet header with command: "POSITION SET EARLIEST" */ 
     265    headerlen = snprintf (header, sizeof (header), "POSITION SET EARLIEST"); 
     266  } 
     267  else if (pktid == LIBDALI_POSITION_LATEST) 
     268  { 
     269    /* Create packet header with command: "POSITION SET LATEST" */ 
     270    headerlen = snprintf (header, sizeof (header), "POSITION SET LATEST"); 
     271  } 
     272  else 
     273  { 
     274    /* Create packet header with command: "POSITION SET pktid pkttime" */ 
     275    headerlen = snprintf (header, sizeof (header), "POSITION SET %lld %lld", 
     276                          (long long int)pktid, (long long int)pkttime); 
     277  } 
     278 
    281279  /* Send command to server */ 
    282280  replylen = dl_sendpacket (dlconn, header, headerlen, NULL, 0, 
    283                             reply, sizeof(reply)); 
    284    
    285   if ( replylen <= 0 ) 
    286     { 
    287       dl_log_r (dlconn, 2, 0, "[%s] dl_position(): problem sending POSITION command\n", 
    288                 dlconn->addr); 
    289       return -1; 
    290     } 
    291    
     281                            reply, sizeof (reply)); 
     282 
     283  if (replylen <= 0) 
     284  { 
     285    dl_log_r (dlconn, 2, 0, "[%s] dl_position(): problem sending POSITION command\n", 
     286              dlconn->addr); 
     287    return -1; 
     288  } 
     289 
    292290  /* Reply message, if sent, will be placed into the reply buffer */ 
    293   rv = dl_handlereply (dlconn, reply, sizeof(reply), &replyvalue); 
    294    
     291  rv = dl_handlereply (dlconn, reply, sizeof (reply), &replyvalue); 
     292 
    295293  /* Log server reply message */ 
    296   if ( rv >= 0 ) 
     294  if (rv >= 0) 
    297295    dl_log_r (dlconn, 1, 1, "[%s] %s\n", dlconn->addr, reply); 
    298296 
    299   return ( rv < 0 || replyvalue < 0 ) ? -1 : replyvalue; 
    300 }  /* End of dl_position() */ 
    301  
    302  
    303 /***********************************************************************//** 
     297  return (rv < 0 || replyvalue < 0) ? -1 : replyvalue; 
     298} /* End of dl_position() */ 
     299 
     300/***********************************************************************/ /** 
    304301 * @brief Position the client read position based on data time 
    305302 * 
     
    323320  int replylen; 
    324321  int rv; 
    325    
    326   if ( ! dlconn ) 
    327     return -1; 
    328    
    329   if ( dlconn->link < 0 ) 
    330     return -1; 
    331    
     322 
     323  if (!dlconn) 
     324    return -1; 
     325 
     326  if (dlconn->link < 0) 
     327    return -1; 
     328 
    332329  /* Sanity check that connection is not in streaming mode */ 
    333   if ( dlconn->streaming ) 
    334     { 
    335       dl_log_r (dlconn, 1, 1, "[%s] dl_position_after(): Connection in streaming mode, cannot continue\n", 
    336                 dlconn->addr); 
    337       return -1; 
    338     } 
    339    
     330  if (dlconn->streaming) 
     331  { 
     332    dl_log_r (dlconn, 1, 1, "[%s] dl_position_after(): Connection in streaming mode, cannot continue\n", 
     333              dlconn->addr); 
     334    return -1; 
     335  } 
     336 
    340337  /* Create packet header with command: "POSITION AFTER datatime" */ 
    341   headerlen = snprintf (header, sizeof(header), "POSITION AFTER %lld", 
    342                         (long long int)datatime); 
    343    
     338  headerlen = snprintf (header, sizeof (header), "POSITION AFTER %lld", 
     339                        (long long int)datatime); 
     340 
    344341  /* Send command to server */ 
    345342  replylen = dl_sendpacket (dlconn, header, headerlen, NULL, 0, 
    346                             reply, sizeof(reply)); 
    347    
    348   if ( replylen <= 0 ) 
    349     { 
    350       dl_log_r (dlconn, 2, 0, "[%s] dl_position_after(): problem sending POSITION command\n", 
    351                 dlconn->addr); 
    352       return -1; 
    353     } 
    354    
     343                            reply, sizeof (reply)); 
     344 
     345  if (replylen <= 0) 
     346  { 
     347    dl_log_r (dlconn, 2, 0, "[%s] dl_position_after(): problem sending POSITION command\n", 
     348              dlconn->addr); 
     349    return -1; 
     350  } 
     351 
    355352  /* Reply message, if sent, will be placed into the reply buffer */ 
    356   rv = dl_handlereply (dlconn, reply, sizeof(reply), &replyvalue); 
    357    
     353  rv = dl_handlereply (dlconn, reply, sizeof (reply), &replyvalue); 
     354 
    358355  /* Log server reply message */ 
    359   if ( rv >= 0 ) 
     356  if (rv >= 0) 
    360357    dl_log_r (dlconn, 1, 1, "[%s] %s\n", dlconn->addr, reply); 
    361    
    362   return ( rv < 0 ) ? -1 : replyvalue; 
    363 }  /* End of dl_position_after() */ 
    364  
    365  
    366 /***********************************************************************//** 
     358 
     359  return (rv < 0) ? -1 : replyvalue; 
     360} /* End of dl_position_after() */ 
     361 
     362/***********************************************************************/ /** 
    367363 * @brief Set the packet match parameters for a connection 
    368364 * 
     
    391387  int replylen; 
    392388  int rv; 
    393    
    394   if ( ! dlconn ) 
    395     return -1; 
    396    
    397   if ( dlconn->link < 0 ) 
    398     return -1; 
    399    
     389 
     390  if (!dlconn) 
     391    return -1; 
     392 
     393  if (dlconn->link < 0) 
     394    return -1; 
     395 
    400396  /* Sanity check that connection is not in streaming mode */ 
    401   if ( dlconn->streaming ) 
    402     { 
    403       dl_log_r (dlconn, 1, 1, "[%s] dl_match(): Connection in streaming mode, cannot continue\n", 
    404                 dlconn->addr); 
    405       return -1; 
    406     } 
    407    
    408   patternlen = ( matchpattern ) ? strlen(matchpattern) : 0; 
    409    
     397  if (dlconn->streaming) 
     398  { 
     399    dl_log_r (dlconn, 1, 1, "[%s] dl_match(): Connection in streaming mode, cannot continue\n", 
     400              dlconn->addr); 
     401    return -1; 
     402  } 
     403 
     404  patternlen = (matchpattern) ? strlen (matchpattern) : 0; 
     405 
    410406  /* Create packet header with command: "MATCH size" */ 
    411   headerlen = snprintf (header, sizeof(header), "MATCH %ld", 
    412                         patternlen); 
    413    
     407  headerlen = snprintf (header, sizeof (header), "MATCH %ld", 
     408                        patternlen); 
     409 
    414410  /* Send command and pattern to server */ 
    415411  replylen = dl_sendpacket (dlconn, header, headerlen, 
    416                             matchpattern, patternlen, 
    417                             reply, sizeof(reply)); 
    418    
    419   if ( replylen <= 0 ) 
    420     { 
    421       dl_log_r (dlconn, 2, 0, "[%s] dl_match(): problem sending MATCH command\n", 
    422                 dlconn->addr); 
    423       return -1; 
    424     } 
    425    
     412                            matchpattern, patternlen, 
     413                            reply, sizeof (reply)); 
     414 
     415  if (replylen <= 0) 
     416  { 
     417    dl_log_r (dlconn, 2, 0, "[%s] dl_match(): problem sending MATCH command\n", 
     418              dlconn->addr); 
     419    return -1; 
     420  } 
     421 
    426422  /* Reply message, if sent, will be placed into the reply buffer */ 
    427   rv = dl_handlereply (dlconn, reply, sizeof(reply), &replyvalue); 
    428   
     423  rv = dl_handlereply (dlconn, reply, sizeof (reply), &replyvalue); 
     424 
    429425  /* Log server reply message */ 
    430   if ( rv >= 0 ) 
     426  if (rv >= 0) 
    431427    dl_log_r (dlconn, 1, 1, "[%s] %s\n", dlconn->addr, reply); 
    432    
    433   return ( rv < 0 ) ? -1 : replyvalue; 
    434 }  /* End of dl_match() */ 
    435  
    436  
    437 /***********************************************************************//** 
     428 
     429  return (rv < 0) ? -1 : replyvalue; 
     430} /* End of dl_match() */ 
     431 
     432/***********************************************************************/ /** 
    438433 * @brief Set the packet reject parameters for a connection 
    439434 * 
     
    462457  int replylen; 
    463458  int rv; 
    464    
    465   if ( ! dlconn ) 
    466     return -1; 
    467    
    468   if ( dlconn->link < 0 ) 
    469     return -1; 
    470    
     459 
     460  if (!dlconn) 
     461    return -1; 
     462 
     463  if (dlconn->link < 0) 
     464    return -1; 
     465 
    471466  /* Sanity check that connection is not in streaming mode */ 
    472   if ( dlconn->streaming ) 
    473     { 
    474       dl_log_r (dlconn, 1, 1, "[%s] dl_reject(): Connection in streaming mode, cannot continue\n", 
    475                 dlconn->addr); 
    476       return -1; 
    477     } 
    478  
    479   patternlen = ( rejectpattern ) ? strlen(rejectpattern) : 0; 
    480    
     467  if (dlconn->streaming) 
     468  { 
     469    dl_log_r (dlconn, 1, 1, "[%s] dl_reject(): Connection in streaming mode, cannot continue\n", 
     470              dlconn->addr); 
     471    return -1; 
     472  } 
     473 
     474  patternlen = (rejectpattern) ? strlen (rejectpattern) : 0; 
     475 
    481476  /* Create packet header with command: "REJECT size" */ 
    482   headerlen = snprintf (header, sizeof(header), "REJECT %ld", 
    483                         patternlen); 
    484    
     477  headerlen = snprintf (header, sizeof (header), "REJECT %ld", 
     478                        patternlen); 
     479 
    485480  /* Send command and pattern to server */ 
    486481  replylen = dl_sendpacket (dlconn, header, headerlen, 
    487                             rejectpattern, patternlen, 
    488                             reply, sizeof(reply)); 
    489    
    490   if ( replylen <= 0 ) 
    491     { 
    492       dl_log_r (dlconn, 2, 0, "[%s] dl_reject(): problem sending REJECT command\n", 
    493                 dlconn->addr); 
    494       return -1; 
    495     } 
    496    
     482                            rejectpattern, patternlen, 
     483                            reply, sizeof (reply)); 
     484 
     485  if (replylen <= 0) 
     486  { 
     487    dl_log_r (dlconn, 2, 0, "[%s] dl_reject(): problem sending REJECT command\n", 
     488              dlconn->addr); 
     489    return -1; 
     490  } 
     491 
    497492  /* Reply message, if sent, will be placed into the reply buffer */ 
    498   rv = dl_handlereply (dlconn, reply, sizeof(reply), &replyvalue); 
    499    
     493  rv = dl_handlereply (dlconn, reply, sizeof (reply), &replyvalue); 
     494 
    500495  /* Log server reply message */ 
    501   if ( rv >= 0 ) 
     496  if (rv >= 0) 
    502497    dl_log_r (dlconn, 1, 1, "[%s] %s\n", dlconn->addr, reply); 
    503    
    504   return ( rv < 0 ) ? -1 : replyvalue; 
    505 }  /* End of dl_reject() */ 
    506  
    507  
    508 /***********************************************************************//** 
     498 
     499  return (rv < 0) ? -1 : replyvalue; 
     500} /* End of dl_reject() */ 
     501 
     502/***********************************************************************/ /** 
    509503 * @brief Send a packet to the DataLink server 
    510504 * 
     
    532526int64_t 
    533527dl_write (DLCP *dlconn, void *packet, int packetlen, char *streamid, 
    534           dltime_t datastart, dltime_t dataend, int ack) 
     528          dltime_t datastart, dltime_t dataend, int ack) 
    535529{ 
    536530  int64_t replyvalue = 0; 
    537531  char reply[255]; 
    538532  char header[255]; 
    539   char *flags = ( ack ) ? "A" : "N"; 
     533  char *flags = (ack) ? "A" : "N"; 
    540534  int headerlen; 
    541535  int replylen; 
    542536  int rv; 
    543    
    544   if ( ! dlconn || ! packet || ! streamid ) 
    545     { 
    546       dl_log_r (dlconn, 1, 1, "dl_write(): dlconn || packet || streamid is not anticipated value \n"); 
    547       return -1; 
    548     } 
    549    
    550   if ( dlconn->link < 0 ) 
    551     { 
    552       dl_log_r (dlconn, 1, 3, "[%s] dl_write(): dlconn->link = %d, expect >=0 \n", dlconn->addr, dlconn->link); 
    553       return -1; 
    554     } 
    555    
     537 
     538  if (!dlconn || !packet || !streamid) 
     539  { 
     540    dl_log_r (dlconn, 1, 1, "dl_write(): dlconn || packet || streamid is not anticipated value \n"); 
     541    return -1; 
     542  } 
     543 
     544  if (dlconn->link < 0) 
     545  { 
     546    dl_log_r (dlconn, 1, 3, "[%s] dl_write(): dlconn->link = %d, expect >=0 \n", dlconn->addr, dlconn->link); 
     547    return -1; 
     548  } 
     549 
    556550  /* Sanity check that connection is not in streaming mode */ 
    557   if ( dlconn->streaming ) 
    558     { 
    559       dl_log_r (dlconn, 1, 1, "[%s] dl_write(): Connection in streaming mode, cannot continue\n", 
    560                 dlconn->addr); 
    561       return -1; 
    562     } 
    563    
     551  if (dlconn->streaming) 
     552  { 
     553    dl_log_r (dlconn, 1, 1, "[%s] dl_write(): Connection in streaming mode, cannot continue\n", 
     554              dlconn->addr); 
     555    return -1; 
     556  } 
     557 
    564558  /* Sanity check that packet data is not larger than max packet size if known */ 
    565   if ( dlconn->maxpktsize > 0 && packetlen > dlconn->maxpktsize ) 
    566     { 
    567       dl_log_r (dlconn, 1, 1, "[%s] dl_write(): Packet length (%d) greater than max packet size (%d)\n", 
    568                 dlconn->addr, packetlen, dlconn->maxpktsize); 
    569       return -1; 
    570     } 
    571    
     559  if (dlconn->maxpktsize > 0 && packetlen > dlconn->maxpktsize) 
     560  { 
     561    dl_log_r (dlconn, 1, 1, "[%s] dl_write(): Packet length (%d) greater than max packet size (%d)\n", 
     562              dlconn->addr, packetlen, dlconn->maxpktsize); 
     563    return -1; 
     564  } 
     565 
    572566  /* Create packet header with command: "WRITE streamid hpdatastart hpdataend flags size" */ 
    573   headerlen = snprintf (header, sizeof(header), 
    574                         "WRITE %s %lld %lld %s %d", 
    575                         streamid, (long long int)datastart, (long long int)dataend, 
    576                         flags, packetlen); 
    577    
     567  headerlen = snprintf (header, sizeof (header), 
     568                        "WRITE %s %lld %lld %s %d", 
     569                        streamid, (long long int)datastart, (long long int)dataend, 
     570                        flags, packetlen); 
     571 
    578572  /* Send command and packet to server */ 
    579573  replylen = dl_sendpacket (dlconn, header, headerlen, 
    580                             packet, packetlen, 
    581                             (ack)?reply:NULL, (ack)?sizeof(reply):0); 
    582    
    583   if ( replylen < 0 ) 
    584     { 
    585       dl_log_r (dlconn, 2, 0, "[%s] dl_write(): problem sending WRITE command\n", 
    586                 dlconn->addr); 
    587       return -1; 
    588     } 
    589   else if ( replylen > 0 ) 
    590     { 
    591       /* Reply message, if sent, will be placed into the reply buffer */ 
    592       rv = dl_handlereply (dlconn, reply, sizeof(reply), &replyvalue); 
    593        
    594       /* Log server reply message */ 
    595       if ( rv == 0 ) 
    596         { 
    597           dl_log_r (dlconn, 1, 3, "[%s] %s\n", dlconn->addr, reply); 
    598         } 
    599       else if ( rv == 1 ) 
    600         { 
    601           dl_log_r (dlconn, 1, 0, "[%s] %s\n", dlconn->addr, reply); 
    602           replyvalue = -1; 
    603         } 
    604       else 
    605         { 
    606           replyvalue = -1; 
    607         } 
    608     } 
    609    
     574                            packet, packetlen, 
     575                            (ack) ? reply : NULL, (ack) ? sizeof (reply) : 0); 
     576 
     577  if (replylen < 0) 
     578  { 
     579    dl_log_r (dlconn, 2, 0, "[%s] dl_write(): problem sending WRITE command\n", 
     580              dlconn->addr); 
     581    return -1; 
     582  } 
     583  else if (replylen > 0) 
     584  { 
     585    /* Reply message, if sent, will be placed into the reply buffer */ 
     586    rv = dl_handlereply (dlconn, reply, sizeof (reply), &replyvalue); 
     587 
     588    /* Log server reply message */ 
     589    if (rv == 0) 
     590    { 
     591      dl_log_r (dlconn, 1, 3, "[%s] %s\n", dlconn->addr, reply); 
     592    } 
     593    else if (rv == 1) 
     594    { 
     595      dl_log_r (dlconn, 1, 0, "[%s] %s\n", dlconn->addr, reply); 
     596      replyvalue = -1; 
     597    } 
     598    else 
     599    { 
     600      replyvalue = -1; 
     601    } 
     602  } 
     603 
    610604  return replyvalue; 
    611 }  /* End of dl_write() */ 
    612  
    613  
    614 /***********************************************************************//** 
     605} /* End of dl_write() */ 
     606 
     607/***********************************************************************/ /** 
    615608 * @brief Request a packet from the DataLink server 
    616609 * 
     
    636629int 
    637630dl_read (DLCP *dlconn, int64_t pktid, DLPacket *packet, void *packetdata, 
    638         size_t maxdatasize) 
     631        size_t maxdatasize) 
    639632{ 
    640633  char header[255]; 
    641634  int headerlen; 
    642635  int rv = 0; 
    643    
     636 
    644637  long long int spktid; 
    645638  long long int spkttime; 
    646639  long long int sdatastart; 
    647640  long long int sdataend; 
    648   long long int sdatasize; 
    649    
    650   if ( ! dlconn || ! packet || ! packetdata ) 
    651     return -1; 
    652    
    653   if ( dlconn->link < 0 ) 
    654     return -1; 
    655    
     641  long int sdatasize; 
     642 
     643  if (!dlconn || !packet || !packetdata) 
     644    return -1; 
     645 
     646  if (dlconn->link < 0) 
     647    return -1; 
     648 
    656649  /* Sanity check that connection is not in streaming mode */ 
    657   if ( dlconn->streaming ) 
    658     { 
    659       dl_log_r (dlconn, 1, 1, "[%s] dl_read(): Connection in streaming mode, cannot continue\n", 
    660                 dlconn->addr); 
     650  if (dlconn->streaming) 
     651  { 
     652    dl_log_r (dlconn, 1, 1, "[%s] dl_read(): Connection in streaming mode, cannot continue\n", 
     653              dlconn->addr); 
     654    return -1; 
     655  } 
     656 
     657  /* Request a specific packet */ 
     658  if (pktid > 0) 
     659  { 
     660    /* Create packet header with command: "READ pktid" */ 
     661    headerlen = snprintf (header, sizeof (header), "READ %lld", (long long int)pktid); 
     662 
     663    /* Send command and packet to server */ 
     664    if (dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0) 
     665    { 
     666      dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem sending READ command\n", 
     667                dlconn->addr); 
    661668      return -1; 
    662669    } 
    663    
    664   /* Request a specific packet */ 
    665   if ( pktid > 0 ) 
    666     { 
    667       /* Create packet header with command: "READ pktid" */ 
    668       headerlen = snprintf (header, sizeof(header), "READ %lld", (long long int)pktid); 
    669        
    670       /* Send command and packet to server */ 
    671       if ( dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0 ) 
    672         { 
    673           dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem sending READ command\n", 
    674                     dlconn->addr); 
    675           return -1; 
    676         } 
    677     } 
    678    
     670  } 
     671 
    679672  /* Receive packet header, blocking until received */ 
    680   if ( (rv = dl_recvheader (dlconn, header, sizeof(header), 1)) < 0 ) 
     673  if ((rv = dl_recvheader (dlconn, header, sizeof (header), 1)) < 0) 
     674  { 
     675    /* Only log an error if the connection was not shut down */ 
     676    if (rv < -1) 
     677      dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem receving packet header\n", 
     678                dlconn->addr); 
     679    return -1; 
     680  } 
     681 
     682  if (!strncmp (header, "PACKET", 6)) 
     683  { 
     684    /* Parse PACKET header */ 
     685    rv = sscanf (header, "PACKET %s %lld %lld %lld %lld %ld", 
     686                 packet->streamid, &spktid, &spkttime, 
     687                 &sdatastart, &sdataend, &sdatasize); 
     688 
     689    if (rv != 6) 
     690    { 
     691      dl_log_r (dlconn, 2, 0, "[%s] dl_read(): cannot parse PACKET header\n", 
     692                dlconn->addr); 
     693      return -1; 
     694    } 
     695 
     696    packet->pktid     = spktid; 
     697    packet->pkttime   = spkttime; 
     698    packet->datastart = sdatastart; 
     699    packet->dataend   = sdataend; 
     700    packet->datasize  = sdatasize; 
     701 
     702    /* Check that the packet data size is not beyond the max receive buffer size */ 
     703    if (packet->datasize > (ssize_t)maxdatasize) 
     704    { 
     705      char *discard; 
     706 
     707      dl_log_r (dlconn, 2, 0, 
     708                "[%s] dl_read(): packet data larger (%ld) than receiving buffer (%ld)\n", 
     709                dlconn->addr, packet->datasize, maxdatasize); 
     710 
     711      /* Allocate temporary buffer */ 
     712      if (!(discard = (char *)malloc (packet->datasize))) 
     713      { 
     714        dl_log_r (dlconn, 2, 0, 
     715                  "[%s] dl_read(): cannot allocate %d bytes for temporary buffer\n", 
     716                  dlconn->addr, packet->datasize); 
     717        return -1; 
     718      } 
     719 
     720      /* Consume packet data */ 
     721      if ((rv = dl_recvdata (dlconn, discard, packet->datasize, 1)) != packet->datasize) 
     722      { 
     723        /* Only log an error if the connection was not shut down */ 
     724        if (rv < -1) 
     725          dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem receiving packet data\n", 
     726                    dlconn->addr); 
     727        return -1; 
     728      } 
     729 
     730      if (discard) 
     731        free (discard); 
     732 
     733      return 0; 
     734    } 
     735 
     736    /* Receive packet data, blocking until complete */ 
     737    if ((rv = dl_recvdata (dlconn, packetdata, packet->datasize, 1)) != packet->datasize) 
    681738    { 
    682739      /* Only log an error if the connection was not shut down */ 
    683       if ( rv < -1 ) 
    684         dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem receving packet header\n", 
    685                   dlconn->addr); 
     740      if (rv < -1) 
     741        dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem receiving packet data\n", 
     742                  dlconn->addr); 
    686743      return -1; 
    687744    } 
    688    
    689   if ( ! strncmp (header, "PACKET", 6) ) 
    690     { 
    691       /* Parse PACKET header */ 
    692       rv = sscanf (header, "PACKET %s %lld %lld %lld %lld %lldd", 
    693                    packet->streamid, &spktid, &spkttime, 
    694                    &sdatastart, &sdataend, &sdatasize); 
    695        
    696       if ( rv != 6 ) 
    697         { 
    698           dl_log_r (dlconn, 2, 0, "[%s] dl_read(): cannot parse PACKET header\n", 
    699                     dlconn->addr); 
    700           return -1; 
    701         } 
    702        
    703       packet->pktid = spktid; 
    704       packet->pkttime = spkttime; 
    705       packet->datastart = sdatastart; 
    706       packet->dataend = sdataend; 
    707       packet->datasize = sdatasize; 
    708        
    709       /* Check that the packet data size is not beyond the max receive buffer size */ 
    710       if ( packet->datasize > maxdatasize ) 
    711         { 
    712           char *discard; 
    713            
    714           dl_log_r (dlconn, 2, 0, 
    715                     "[%s] dl_read(): packet data larger (%ld) than receiving buffer (%ld)\n", 
    716                     dlconn->addr, packet->datasize, maxdatasize); 
    717            
    718           /* Allocate temporary buffer */ 
    719           if ( ! (discard = (char *) malloc (packet->datasize)) ) 
    720             { 
    721               dl_log_r (dlconn, 2, 0, 
    722                         "[%s] dl_read(): cannot allocate %d bytes for temporary buffer\n", 
    723                         dlconn->addr, packet->datasize); 
    724               return -1; 
    725             } 
    726            
    727           /* Consume packet data */ 
    728           if ( (rv = dl_recvdata (dlconn, discard, packet->datasize, 1)) != packet->datasize ) 
    729             { 
    730               /* Only log an error if the connection was not shut down */ 
    731               if ( rv < -1 ) 
    732                 dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem receiving packet data\n", 
    733                           dlconn->addr); 
    734               return -1; 
    735             } 
    736            
    737           if ( discard ) 
    738             free (discard); 
    739            
    740           return 0; 
    741         } 
    742        
    743       /* Receive packet data, blocking until complete */ 
    744       if ( (rv = dl_recvdata (dlconn, packetdata, packet->datasize, 1)) != packet->datasize ) 
    745         { 
    746           /* Only log an error if the connection was not shut down */ 
    747           if ( rv < -1 ) 
    748             dl_log_r (dlconn, 2, 0, "[%s] dl_read(): problem receiving packet data\n", 
    749                       dlconn->addr); 
    750           return -1; 
    751         } 
    752        
    753       /* Update most recently received packet ID and time */ 
    754       dlconn->pktid = packet->pktid; 
    755       dlconn->pkttime = packet->pkttime; 
    756     } 
    757   else if ( ! strncmp (header, "ERROR", 5) ) 
    758     { 
    759       /* Reply message, if sent, will be placed into the header buffer */ 
    760       rv = dl_handlereply (dlconn, header, sizeof(header), NULL); 
    761        
    762       /* Log server reply message */ 
    763       if ( rv >= 0 ) 
    764         dl_log_r (dlconn, 2, 0, "[%s] %s\n", dlconn->addr, header); 
    765        
    766       return -1; 
    767     } 
     745 
     746    /* Update most recently received packet ID and time */ 
     747    dlconn->pktid   = packet->pktid; 
     748    dlconn->pkttime = packet->pkttime; 
     749  } 
     750  else if (!strncmp (header, "ERROR", 5)) 
     751  { 
     752    /* Reply message, if sent, will be placed into the header buffer */ 
     753    rv = dl_handlereply (dlconn, header, sizeof (header), NULL); 
     754 
     755    /* Log server reply message */ 
     756    if (rv >= 0) 
     757      dl_log_r (dlconn, 2, 0, "[%s] %s\n", dlconn->addr, header); 
     758 
     759    return -1; 
     760  } 
    768761  else 
    769     { 
    770       dl_log_r (dlconn, 2, 0, "[%s] dl_read(): Unrecognized reply string %.6s\n", 
    771                 dlconn->addr, header); 
    772       return -1; 
    773     } 
    774    
     762  { 
     763    dl_log_r (dlconn, 2, 0, "[%s] dl_read(): Unrecognized reply string %.6s\n", 
     764              dlconn->addr, header); 
     765    return -1; 
     766  } 
     767 
    775768  return packet->datasize; 
    776 }  /* End of dl_read() */ 
    777  
    778  
    779 /***********************************************************************//** 
     769} /* End of dl_read() */ 
     770 
     771/***********************************************************************/ /** 
    780772 * @brief Request information from the DataLink server 
    781773 * 
     
    801793int 
    802794dl_getinfo (DLCP *dlconn, const char *infotype, char *infomatch, 
    803             char **infodata, size_t maxinfosize) 
     795            char **infodata, size_t maxinfosize) 
    804796{ 
    805797  char header[255]; 
     
    807799  int headerlen; 
    808800  int infosize = 0; 
    809   int rv = 0; 
    810    
    811   if ( ! dlconn || ! infotype || ! infodata ) 
    812     return -1; 
    813    
    814   if ( maxinfosize && ! *infodata ) 
    815     return -1; 
    816    
    817   if ( dlconn->link < 0 ) 
    818     return -1; 
    819    
     801  int rv       = 0; 
     802 
     803  if (!dlconn || !infotype || !infodata) 
     804    return -1; 
     805 
     806  if (maxinfosize && !*infodata) 
     807    return -1; 
     808 
     809  if (dlconn->link < 0) 
     810    return -1; 
     811 
    820812  /* Sanity check that connection is not in streaming mode */ 
    821   if ( dlconn->streaming ) 
    822     { 
    823       dl_log_r (dlconn, 1, 1, "[%s] dl_getinfo(): Connection in streaming mode, cannot continue\n", 
    824                 dlconn->addr); 
    825       return -1; 
    826     } 
    827    
     813  if (dlconn->streaming) 
     814  { 
     815    dl_log_r (dlconn, 1, 1, "[%s] dl_getinfo(): Connection in streaming mode, cannot continue\n", 
     816              dlconn->addr); 
     817    return -1; 
     818  } 
     819 
    828820  /* Request information */ 
    829821  /* Create packet header with command: "INFO type" */ 
    830   headerlen = snprintf (header, sizeof(header), "INFO %s %s", infotype, 
    831                         (infomatch)?infomatch:""); 
    832    
     822  headerlen = snprintf (header, sizeof (header), "INFO %s %s", infotype, 
     823                        (infomatch) ? infomatch : ""); 
     824 
    833825  /* Send command and packet to server */ 
    834   if ( dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0 ) 
    835     { 
    836       dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): problem sending INFO command\n", 
    837                 dlconn->addr); 
     826  if (dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0) 
     827  { 
     828    dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): problem sending INFO command\n", 
     829              dlconn->addr); 
     830    return -1; 
     831  } 
     832 
     833  /* Receive packet header, blocking until complete: INFO <size> */ 
     834  if ((rv = dl_recvheader (dlconn, header, sizeof (header), 1)) < 0) 
     835  { 
     836    /* Only log an error if the connection was not shut down */ 
     837    if (rv < -1) 
     838      dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): problem receving packet header\n", 
     839                dlconn->addr); 
     840    return -1; 
     841  } 
     842 
     843  if (!strncmp (header, "INFO", 4)) 
     844  { 
     845    /* Parse INFO header */ 
     846    rv = sscanf (header, "INFO %s %d", type, &infosize); 
     847 
     848    if (rv != 2) 
     849    { 
     850      dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): cannot parse INFO header\n", 
     851                dlconn->addr); 
    838852      return -1; 
    839853    } 
    840    
    841   /* Receive packet header, blocking until complete: INFO <size> */ 
    842   if ( (rv = dl_recvheader (dlconn, header, sizeof(header), 1)) < 0 ) 
     854 
     855    if (strncasecmp (infotype, type, strlen (infotype))) 
     856    { 
     857      dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): requested type %s but received type %s\n", 
     858                dlconn->addr, infotype, type); 
     859      return -1; 
     860    } 
     861 
     862    /* If a maximum buffer size was specified check that it's large enough */ 
     863    if (maxinfosize && infosize > (ssize_t)maxinfosize) 
     864    { 
     865      dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): INFO data larger (%d) than the maximum size (%d)\n", 
     866                dlconn->addr, infosize, maxinfosize); 
     867      return -1; 
     868    } 
     869 
     870    /* Allocate the infobuffer if needed */ 
     871    if (maxinfosize == 0) 
     872    { 
     873      if (!(*infodata = malloc (infosize))) 
     874      { 
     875        dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): error allocating receving buffer of %d bytes\n", 
     876                  dlconn->addr, infosize); 
     877        return -1; 
     878      } 
     879    } 
     880 
     881    /* Receive INFO data, blocking until complete */ 
     882    if ((rv = dl_recvdata (dlconn, *infodata, infosize, 1)) != infosize) 
    843883    { 
    844884      /* Only log an error if the connection was not shut down */ 
    845       if ( rv < -1 ) 
    846         dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): problem receving packet header\n", 
    847                   dlconn->addr); 
     885      if (rv < -1) 
     886        dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): problem receiving INFO data\n", 
     887                  dlconn->addr); 
    848888      return -1; 
    849889    } 
    850    
    851   if ( ! strncmp (header, "INFO", 4) ) 
    852     { 
    853       /* Parse INFO header */ 
    854       rv = sscanf (header, "INFO %s %d", type, &infosize); 
    855        
    856       if ( rv != 2 ) 
    857         { 
    858           dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): cannot parse INFO header\n", 
    859                     dlconn->addr); 
    860           return -1; 
    861         } 
    862        
    863       if ( strncasecmp (infotype, type, strlen(infotype)) ) 
    864         { 
    865           dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): requested type %s but received type %s\n", 
    866                     dlconn->addr, infotype, type); 
    867           return -1; 
    868         } 
    869        
    870       /* If a maximum buffer size was specified check that it's large enough */ 
    871       if ( maxinfosize && infosize > maxinfosize ) 
    872         { 
    873           dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): INFO data larger (%d) than the maximum size (%d)\n", 
    874                     dlconn->addr, infosize, maxinfosize); 
    875           return -1; 
    876         } 
    877        
    878       /* Allocate the infobuffer if needed */ 
    879       if ( maxinfosize == 0 ) 
    880         { 
    881           if ( ! (*infodata = malloc (infosize)) ) 
    882             { 
    883               dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): error allocating receving buffer of %d bytes\n", 
    884                         dlconn->addr, infosize); 
    885               return -1; 
    886             } 
    887         } 
    888        
    889       /* Receive INFO data, blocking until complete */ 
    890       if ( (rv = dl_recvdata (dlconn, *infodata, infosize, 1)) != infosize ) 
    891         { 
    892           /* Only log an error if the connection was not shut down */ 
    893           if ( rv < -1 ) 
    894             dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): problem receiving INFO data\n", 
    895                       dlconn->addr); 
    896           return -1; 
    897         } 
    898     } 
    899   else if ( ! strncmp (header, "ERROR", 5) ) 
    900     { 
    901       /* Reply message, if sent, will be placed into the header buffer */ 
    902       rv = dl_handlereply (dlconn, header, sizeof(header), NULL); 
    903        
    904       /* Log server reply message */ 
    905       if ( rv >= 0 ) 
    906         dl_log_r (dlconn, 2, 0, "[%s] %s\n", dlconn->addr, header); 
    907        
    908       return -1; 
    909     } 
     890  } 
     891  else if (!strncmp (header, "ERROR", 5)) 
     892  { 
     893    /* Reply message, if sent, will be placed into the header buffer */ 
     894    rv = dl_handlereply (dlconn, header, sizeof (header), NULL); 
     895 
     896    /* Log server reply message */ 
     897    if (rv >= 0) 
     898      dl_log_r (dlconn, 2, 0, "[%s] %s\n", dlconn->addr, header); 
     899 
     900    return -1; 
     901  } 
    910902  else 
    911     { 
    912       dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): Unrecognized reply string %.6s\n", 
    913                 dlconn->addr, header); 
    914       return -1; 
    915     } 
    916    
     903  { 
     904    dl_log_r (dlconn, 2, 0, "[%s] dl_getinfo(): Unrecognized reply string %.6s\n", 
     905              dlconn->addr, header); 
     906    return -1; 
     907  } 
     908 
    917909  return infosize; 
    918 }  /* End of dl_getinfo() */ 
    919  
    920  
    921 /***********************************************************************//** 
     910} /* End of dl_getinfo() */ 
     911 
     912/***********************************************************************/ /** 
    922913 * @brief Collect packets streaming from the DataLink server 
    923914 * 
     
    946937int 
    947938dl_collect (DLCP *dlconn, DLPacket *packet, void *packetdata, 
    948             size_t maxdatasize, int8_t endflag) 
     939            size_t maxdatasize, int8_t endflag) 
    949940{ 
    950941  dltime_t now; 
    951942  char header[255]; 
    952   int  headerlen; 
    953   int  rv; 
     943  int headerlen; 
     944  int rv; 
    954945 
    955946  long long int spktid; 
     
    957948  long long int sdatastart; 
    958949  long long int sdataend; 
    959   long long int sdatasize; 
    960    
     950  long int sdatasize; 
     951 
    961952  /* For select()ing during the read loop */ 
    962953  struct timeval select_tv; 
    963   fd_set         select_fd; 
    964   int            select_ret; 
    965    
    966   if ( ! dlconn || ! packet || ! packetdata ) 
     954  fd_set select_fd; 
     955  int select_ret; 
     956 
     957  if (!dlconn || !packet || !packetdata) 
    967958    return DLERROR; 
    968    
    969   if ( dlconn->link == -1 ) 
     959 
     960  if (dlconn->link == -1) 
    970961    return DLERROR; 
    971    
     962 
    972963  /* If not streaming send the STREAM command */ 
    973   if ( ! dlconn->streaming && ! endflag ) 
    974     { 
    975       /* Create packet header with command: "STREAM" */ 
    976       headerlen = snprintf (header, sizeof(header), "STREAM"); 
    977        
    978       /* Send command to server */ 
    979       if ( dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0 ) 
    980         { 
    981           dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem sending STREAM command\n", 
    982                     dlconn->addr); 
    983           return DLERROR; 
    984         } 
    985        
    986       dlconn->streaming = 1; 
     964  if (!dlconn->streaming && !endflag) 
     965  { 
     966    /* Create packet header with command: "STREAM" */ 
     967    headerlen = snprintf (header, sizeof (header), "STREAM"); 
     968 
     969    /* Send command to server */ 
     970    if (dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0) 
     971    { 
     972      dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem sending STREAM command\n", 
     973                dlconn->addr); 
     974      return DLERROR; 
     975    } 
     976 
     977    dlconn->streaming      = 1; 
     978    dlconn->keepalive_trig = -1; 
     979    dl_log_r (dlconn, 1, 2, "[%s] STREAM command sent to server\n", dlconn->addr); 
     980  } 
     981 
     982  /* If streaming and end is requested send the ENDSTREAM command */ 
     983  if (dlconn->streaming == 1 && endflag) 
     984  { 
     985    /* Create packet header with command: "ENDSTREAM" */ 
     986    headerlen = snprintf (header, sizeof (header), "ENDSTREAM"); 
     987 
     988    /* Send command to server */ 
     989    if (dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0) 
     990    { 
     991      dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem sending ENDSTREAM command\n", 
     992                dlconn->addr); 
     993      return DLERROR; 
     994    } 
     995 
     996    dlconn->streaming      = -1; 
     997    dlconn->keepalive_trig = -1; 
     998    dl_log_r (dlconn, 1, 2, "[%s] ENDSTREAM command sent to server\n", dlconn->addr); 
     999  } 
     1000 
     1001  /* Start the primary loop */ 
     1002  while (!dlconn->terminate) 
     1003  { 
     1004    /* Check if a keepalive packet needs to be sent */ 
     1005    if (dlconn->keepalive && dlconn->keepalive_trig > 0) 
     1006    { 
     1007      dl_log_r (dlconn, 1, 2, "[%s] Sending keepalive packet\n", dlconn->addr); 
     1008 
     1009      /* Send ID as a keepalive packet exchange */ 
     1010      headerlen = snprintf (header, sizeof (header), "ID %s", 
     1011                            (dlconn->clientid[0] == '\0') ? dlconn->clientid : ""); 
     1012 
     1013      if (dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0) 
     1014      { 
     1015        dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem sending keepalive packet\n", 
     1016                  dlconn->addr); 
     1017        return DLERROR; 
     1018      } 
     1019 
    9871020      dlconn->keepalive_trig = -1; 
    988       dl_log_r (dlconn, 1, 2, "[%s] STREAM command sent to server\n", dlconn->addr); 
    989     } 
    990    
    991   /* If streaming and end is requested send the ENDSTREAM command */ 
    992   if ( dlconn->streaming == 1 && endflag ) 
    993     { 
    994       /* Create packet header with command: "ENDSTREAM" */ 
    995       headerlen = snprintf (header, sizeof(header), "ENDSTREAM"); 
    996        
    997       /* Send command to server */ 
    998       if ( dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0 ) 
    999         { 
    1000           dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem sending ENDSTREAM command\n", 
    1001                     dlconn->addr); 
    1002           return DLERROR; 
    1003         } 
    1004        
    1005       dlconn->streaming = -1; 
    1006       dlconn->keepalive_trig = -1; 
    1007       dl_log_r (dlconn, 1, 2, "[%s] ENDSTREAM command sent to server\n", dlconn->addr); 
    1008     } 
    1009    
    1010   /* Start the primary loop */ 
    1011   while ( ! dlconn->terminate ) 
    1012     { 
    1013       /* Check if a keepalive packet needs to be sent */ 
    1014       if ( dlconn->keepalive && dlconn->keepalive_trig > 0 ) 
    1015         { 
    1016           dl_log_r (dlconn, 1, 2, "[%s] Sending keepalive packet\n", dlconn->addr); 
    1017            
    1018           /* Send ID as a keepalive packet exchange */ 
    1019           headerlen = snprintf (header, sizeof(header), "ID %s", 
    1020                                 (dlconn->clientid) ? dlconn->clientid : ""); 
    1021            
    1022           if ( dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0 ) 
    1023             { 
    1024               dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem sending keepalive packet\n", 
    1025                         dlconn->addr); 
    1026               return DLERROR; 
    1027             } 
    1028            
    1029           dlconn->keepalive_trig = -1; 
    1030         } 
    1031        
    1032       /* Poll the socket for available data */ 
    1033       FD_ZERO (&select_fd); 
    1034       FD_SET ((unsigned int)dlconn->link, &select_fd); 
    1035       select_tv.tv_sec = 0; 
    1036       select_tv.tv_usec = 500000;  /* Block up to 0.5 seconds */ 
    1037        
    1038       select_ret = select ((dlconn->link + 1), &select_fd, NULL, NULL, &select_tv); 
    1039        
    1040       /* Check the return from select(), an interrupted system call error 
     1021    } 
     1022 
     1023    /* Poll the socket for available data */ 
     1024    FD_ZERO (&select_fd); 
     1025    FD_SET ((unsigned int)dlconn->link, &select_fd); 
     1026    select_tv.tv_sec  = 0; 
     1027    select_tv.tv_usec = 500000; /* Block up to 0.5 seconds */ 
     1028 
     1029    select_ret = select ((dlconn->link + 1), &select_fd, NULL, NULL, &select_tv); 
     1030 
     1031    /* Check the return from select(), an interrupted system call error 
    10411032         will be reported if a signal handler was used.  If the terminate 
    10421033         flag is set this is not an error. */ 
    1043       if ( select_ret > 0 ) 
    1044         { 
    1045           if ( ! FD_ISSET (dlconn->link, &select_fd) ) 
    1046             { 
    1047               dl_log_r (dlconn, 2, 0, "[%s] select() reported data but socket not in set!\n", 
    1048                         dlconn->addr); 
    1049             } 
    1050           else 
    1051             { 
    1052               /* Receive packet header, blocking until complete */ 
    1053               if ( (rv = dl_recvheader (dlconn, header, sizeof(header), 1)) < 0 ) 
    1054                 { 
    1055                   if ( rv == -1 ) 
    1056                     return DLENDED; 
    1057                    
    1058                   dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem receving packet header\n", 
    1059                             dlconn->addr); 
    1060                   return DLERROR; 
    1061                 } 
    1062                
    1063               /* Reset keepalive trigger */ 
    1064               dlconn->keepalive_trig = -1; 
    1065                
    1066               if ( ! strncmp (header, "PACKET", 6) ) 
    1067                 { 
    1068                   /* Parse PACKET header */ 
    1069                   rv = sscanf (header, "PACKET %s %lld %lld %lld %lld %lld", 
    1070                                packet->streamid, &spktid, &spkttime, 
    1071                                &sdatastart, &sdataend, &sdatasize); 
    1072                    
    1073                   if ( rv != 6 ) 
    1074                     { 
    1075                       dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): cannot parse PACKET header\n", 
    1076                                 dlconn->addr); 
    1077                       return DLERROR; 
    1078                     } 
    1079                    
    1080                   packet->pktid = spktid; 
    1081                   packet->pkttime = spkttime; 
    1082                   packet->datastart = sdatastart; 
    1083                   packet->dataend = sdataend; 
    1084                   packet->datasize = sdatasize; 
    1085                    
    1086                   if ( packet->datasize > maxdatasize ) 
    1087                     { 
    1088                       dl_log_r (dlconn, 2, 0, 
    1089                                 "[%s] dl_collect(): packet data larger (%ld) than receiving buffer (%ld)\n", 
    1090                                 dlconn->addr, packet->datasize, maxdatasize); 
    1091                       return DLERROR; 
    1092                     } 
    1093                    
    1094                   /* Receive packet data, blocking until complete */ 
    1095                   if ( (rv = dl_recvdata (dlconn, packetdata, packet->datasize, 1)) != packet->datasize ) 
    1096                     { 
    1097                       if ( rv == -1 ) 
    1098                         return DLENDED; 
    1099                        
    1100                       dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem receiving packet data\n", 
    1101                                 dlconn->addr); 
    1102                       return DLERROR; 
    1103                     } 
    1104                    
    1105                   /* Update most recently received packet ID and time */ 
    1106                   dlconn->pktid = packet->pktid; 
    1107                   dlconn->pkttime = packet->pkttime; 
    1108                    
    1109                   return DLPACKET; 
    1110                 } 
    1111               else if ( ! strncmp (header, "ID", 2) ) 
    1112                 { 
    1113                   dl_log_r (dlconn, 1, 2, "[%s] Received keepalive from server\n", 
    1114                             dlconn->addr); 
    1115                 } 
    1116               else if ( ! strncmp (header, "ENDSTREAM", 9) ) 
    1117                 { 
    1118                   dl_log_r (dlconn, 1, 2, "[%s] Received end-of-stream from server\n", 
    1119                             dlconn->addr); 
    1120                   dlconn->streaming = 0; 
    1121                   return DLENDED; 
    1122                 } 
    1123               else 
    1124                 { 
    1125                   dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): Unrecognized packet header %.6s\n", 
    1126                             dlconn->addr, header); 
    1127                   return DLERROR; 
    1128                 } 
    1129             } 
    1130         } 
    1131       else if ( select_ret < 0 && ! dlconn->terminate ) 
    1132         { 
    1133           dl_log_r (dlconn, 2, 0, "[%s] select() error: %s\n", dlconn->addr, dlp_strerror ()); 
    1134           return DLERROR; 
    1135         } 
    1136        
    1137       /* Update timing variables */ 
    1138       now = dlp_time (); 
    1139        
    1140       /* Keepalive/heartbeat interval timing logic */ 
    1141       if ( dlconn->keepalive ) 
    1142         { 
    1143           if ( dlconn->keepalive_trig == -1 ) /* reset timer */ 
    1144             { 
    1145               dlconn->keepalive_time = now; 
    1146               dlconn->keepalive_trig = 0; 
    1147             } 
    1148           else if ( dlconn->keepalive_trig == 0 && 
    1149                     (now - dlconn->keepalive_time) > (dlconn->keepalive * DLTMODULUS) ) 
    1150             { 
    1151               dlconn->keepalive_trig = 1; 
    1152             } 
    1153         } 
    1154     } /* End of primary loop */ 
    1155    
     1034    if (select_ret > 0) 
     1035    { 
     1036      if (!FD_ISSET (dlconn->link, &select_fd)) 
     1037      { 
     1038        dl_log_r (dlconn, 2, 0, "[%s] select() reported data but socket not in set!\n", 
     1039                  dlconn->addr); 
     1040      } 
     1041      else 
     1042      { 
     1043        /* Receive packet header, blocking until complete */ 
     1044        if ((rv = dl_recvheader (dlconn, header, sizeof (header), 1)) < 0) 
     1045        { 
     1046          if (rv == -1) 
     1047            return DLENDED; 
     1048 
     1049          dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem receving packet header\n", 
     1050                    dlconn->addr); 
     1051          return DLERROR; 
     1052        } 
     1053 
     1054        /* Reset keepalive trigger */ 
     1055        dlconn->keepalive_trig = -1; 
     1056 
     1057        if (!strncmp (header, "PACKET", 6)) 
     1058        { 
     1059          /* Parse PACKET header */ 
     1060          rv = sscanf (header, "PACKET %s %lld %lld %lld %lld %ld", 
     1061                       packet->streamid, &spktid, &spkttime, 
     1062                       &sdatastart, &sdataend, &sdatasize); 
     1063 
     1064          if (rv != 6) 
     1065          { 
     1066            dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): cannot parse PACKET header\n", 
     1067                      dlconn->addr); 
     1068            return DLERROR; 
     1069          } 
     1070 
     1071          packet->pktid    = spktid; 
     1072          packet->pkttime  = spkttime; 
     1073          packet->datastart = sdatastart; 
     1074          packet->dataend  = sdataend; 
     1075          packet->datasize = sdatasize; 
     1076 
     1077          if (packet->datasize > (ssize_t)maxdatasize) 
     1078          { 
     1079            dl_log_r (dlconn, 2, 0, 
     1080                      "[%s] dl_collect(): packet data larger (%ld) than receiving buffer (%ld)\n", 
     1081                      dlconn->addr, packet->datasize, maxdatasize); 
     1082            return DLERROR; 
     1083          } 
     1084 
     1085          /* Receive packet data, blocking until complete */ 
     1086          if ((rv = dl_recvdata (dlconn, packetdata, packet->datasize, 1)) != packet->datasize) 
     1087          { 
     1088            if (rv == -1) 
     1089              return DLENDED; 
     1090 
     1091            dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): problem receiving packet data\n", 
     1092                      dlconn->addr); 
     1093            return DLERROR; 
     1094          } 
     1095 
     1096          /* Update most recently received packet ID and time */ 
     1097          dlconn->pktid  = packet->pktid; 
     1098          dlconn->pkttime = packet->pkttime; 
     1099 
     1100          return DLPACKET; 
     1101        } 
     1102        else if (!strncmp (header, "ID", 2)) 
     1103        { 
     1104          dl_log_r (dlconn, 1, 2, "[%s] Received keepalive from server\n", 
     1105                    dlconn->addr); 
     1106        } 
     1107        else if (!strncmp (header, "ENDSTREAM", 9)) 
     1108        { 
     1109          dl_log_r (dlconn, 1, 2, "[%s] Received end-of-stream from server\n", 
     1110                    dlconn->addr); 
     1111          dlconn->streaming = 0; 
     1112          return DLENDED; 
     1113        } 
     1114        else 
     1115        { 
     1116          dl_log_r (dlconn, 2, 0, "[%s] dl_collect(): Unrecognized packet header %.6s\n", 
     1117                    dlconn->addr, header); 
     1118          return DLERROR; 
     1119        } 
     1120      } 
     1121    } 
     1122    else if (select_ret < 0 && !dlconn->terminate) 
     1123    { 
     1124      dl_log_r (dlconn, 2, 0, "[%s] select() error: %s\n", dlconn->addr, dlp_strerror ()); 
     1125      return DLERROR; 
     1126    } 
     1127 
     1128    /* Update timing variables */ 
     1129    now = dlp_time (); 
     1130 
     1131    /* Keepalive/heartbeat interval timing logic */ 
     1132    if (dlconn->keepalive) 
     1133    { 
     1134      if (dlconn->keepalive_trig == -1) /* reset timer */ 
     1135      { 
     1136        dlconn->keepalive_time = now; 
     1137        dlconn->keepalive_trig = 0; 
     1138      } 
     1139      else if (dlconn->keepalive_trig == 0 && 
     1140               (now - dlconn->keepalive_time) > (dlconn->keepalive * DLTMODULUS)) 
     1141      { 
     1142        dlconn->keepalive_trig = 1; 
     1143      } 
     1144    } 
     1145  } /* End of primary loop */ 
     1146 
    11561147  return DLENDED; 
    1157 }  /* End of dl_collect() */ 
    1158  
    1159  
    1160 /***********************************************************************//** 
     1148} /* End of dl_collect() */ 
     1149 
     1150/***********************************************************************/ /** 
    11611151 * @brief Collect packets streaming from the DataLink server without blocking 
    11621152 * 
     
    11871177int 
    11881178dl_collect_nb (DLCP *dlconn, DLPacket *packet, void *packetdata, 
    1189                size_t maxdatasize, int8_t endflag) 
     1179               size_t maxdatasize, int8_t endflag) 
    11901180{ 
    11911181  dltime_t now; 
    11921182  char header[255]; 
    1193   int  headerlen; 
    1194   int  rv; 
    1195    
     1183  int headerlen; 
     1184  int rv; 
     1185 
    11961186  long long int spktid; 
    11971187  long long int spkttime; 
    11981188  long long int sdatastart; 
    11991189  long long int sdataend; 
    1200   long long int sdatasize; 
    1201  
    1202   if ( ! dlconn || ! packet || ! packetdata ) 
     1190  long int sdatasize; 
     1191 
     1192  if (!dlconn || !packet || !packetdata) 
    12031193    return DLERROR; 
    1204    
    1205   if ( dlconn->link == -1 ) 
     1194 
     1195  if (dlconn->link == -1) 
    12061196    return DLERROR; 
    1207    
     1197 
    12081198  /* If not streaming send the STREAM command */ 
    1209   if ( ! dlconn->streaming && ! endflag ) 
    1210     { 
    1211       /* Create packet header with command: "STREAM" */ 
    1212       headerlen = snprintf (header, sizeof(header), "STREAM"); 
    1213        
    1214       /* Send command to server */ 
    1215       if ( dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0 ) 
    1216         { 
    1217           dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem sending STREAM command\n", 
    1218                     dlconn->addr); 
    1219           return DLERROR; 
    1220         } 
    1221        
    1222       dlconn->streaming = 1; 
     1199  if (!dlconn->streaming && !endflag) 
     1200  { 
     1201    /* Create packet header with command: "STREAM" */ 
     1202    headerlen = snprintf (header, sizeof (header), "STREAM"); 
     1203 
     1204    /* Send command to server */ 
     1205    if (dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0) 
     1206    { 
     1207      dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem sending STREAM command\n", 
     1208                dlconn->addr); 
     1209      return DLERROR; 
     1210    } 
     1211 
     1212    dlconn->streaming      = 1; 
     1213    dlconn->keepalive_trig = -1; 
     1214    dl_log_r (dlconn, 1, 2, "[%s] STREAM command sent to server", dlconn->addr); 
     1215  } 
     1216 
     1217  /* If streaming and end is requested send the ENDSTREAM command */ 
     1218  if (dlconn->streaming == 1 && endflag) 
     1219  { 
     1220    /* Create packet header with command: "ENDSTREAM" */ 
     1221    headerlen = snprintf (header, sizeof (header), "ENDSTREAM"); 
     1222 
     1223    /* Send command to server */ 
     1224    if (dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0) 
     1225    { 
     1226      dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem sending ENDSTREAM command\n", 
     1227                dlconn->addr); 
     1228      return DLERROR; 
     1229    } 
     1230 
     1231    dlconn->streaming      = -1; 
     1232    dlconn->keepalive_trig = -1; 
     1233    dl_log_r (dlconn, 1, 2, "[%s] ENDSTREAM command sent to server", dlconn->addr); 
     1234  } 
     1235 
     1236  if (!dlconn->terminate) 
     1237  { 
     1238    /* Check if a keepalive packet needs to be sent */ 
     1239    if (dlconn->keepalive && dlconn->keepalive_trig > 0) 
     1240    { 
     1241      dl_log_r (dlconn, 1, 2, "[%s] Sending keepalive packet\n", dlconn->addr); 
     1242 
     1243      /* Send ID as a keepalive packet exchange */ 
     1244      headerlen = snprintf (header, sizeof (header), "ID %s", 
     1245                            (dlconn->clientid[0] == '\0') ? dlconn->clientid : ""); 
     1246 
     1247      if (dl_sendpacket (dlconn, header, headerlen, 
     1248                         NULL, 0, NULL, 0) < 0) 
     1249      { 
     1250        dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem sending keepalive packet\n", 
     1251                  dlconn->addr); 
     1252        return DLERROR; 
     1253      } 
     1254 
    12231255      dlconn->keepalive_trig = -1; 
    1224       dl_log_r (dlconn, 1, 2, "[%s] STREAM command sent to server", dlconn->addr); 
    1225     } 
    1226    
    1227   /* If streaming and end is requested send the ENDSTREAM command */ 
    1228   if ( dlconn->streaming == 1 && endflag ) 
    1229     { 
    1230       /* Create packet header with command: "ENDSTREAM" */ 
    1231       headerlen = snprintf (header, sizeof(header), "ENDSTREAM"); 
    1232        
    1233       /* Send command to server */ 
    1234       if ( dl_sendpacket (dlconn, header, headerlen, NULL, 0, NULL, 0) < 0 ) 
    1235         { 
    1236           dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem sending ENDSTREAM command\n", 
    1237                     dlconn->addr); 
    1238           return DLERROR; 
    1239         } 
    1240        
    1241       dlconn->streaming = -1; 
    1242       dlconn->keepalive_trig = -1; 
    1243       dl_log_r (dlconn, 1, 2, "[%s] ENDSTREAM command sent to server", dlconn->addr); 
    1244     } 
    1245    
    1246   if ( ! dlconn->terminate ) 
    1247     { 
    1248       /* Check if a keepalive packet needs to be sent */ 
    1249       if ( dlconn->keepalive && dlconn->keepalive_trig > 0 ) 
    1250         { 
    1251           dl_log_r (dlconn, 1, 2, "[%s] Sending keepalive packet\n", dlconn->addr); 
    1252            
    1253           /* Send ID as a keepalive packet exchange */ 
    1254           headerlen = snprintf (header, sizeof(header), "ID %s", 
    1255                                 (dlconn->clientid) ? dlconn->clientid : ""); 
    1256            
    1257           if ( dl_sendpacket (dlconn, header, headerlen, 
    1258                               NULL, 0, NULL, 0) < 0 ) 
    1259             { 
    1260               dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem sending keepalive packet\n", 
    1261                         dlconn->addr); 
    1262               return DLERROR; 
    1263             } 
    1264            
    1265           dlconn->keepalive_trig = -1; 
    1266         } 
    1267     } 
    1268    
     1256    } 
     1257  } 
     1258 
    12691259  /* Receive packet header if it's available */ 
    1270   if ( (rv = dl_recvheader (dlconn, header, sizeof(header), 0)) < 0 ) 
    1271     { 
    1272       if ( rv == -1 ) 
    1273         return DLENDED; 
    1274        
    1275       dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem receving packet header\n", 
    1276                 dlconn->addr); 
     1260  if ((rv = dl_recvheader (dlconn, header, sizeof (header), 0)) < 0) 
     1261  { 
     1262    if (rv == -1) 
     1263      return DLENDED; 
     1264 
     1265    dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem receving packet header\n", 
     1266              dlconn->addr); 
     1267    return DLERROR; 
     1268  } 
     1269 
     1270  /* Process data if header received */ 
     1271  if (rv > 0) 
     1272  { 
     1273    /* Reset keepalive trigger */ 
     1274    dlconn->keepalive_trig = -1; 
     1275 
     1276    if (!strncmp (header, "PACKET", 6)) 
     1277    { 
     1278      /* Parse PACKET header */ 
     1279      rv = sscanf (header, "PACKET %s %lld %lld %lld %lld %ld", 
     1280                   packet->streamid, &spktid, &spkttime, 
     1281                   &sdatastart, &sdataend, &sdatasize); 
     1282 
     1283      if (rv != 6) 
     1284      { 
     1285        dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): cannot parse PACKET header\n", 
     1286                  dlconn->addr); 
     1287        return DLERROR; 
     1288      } 
     1289 
     1290      packet->pktid     = spktid; 
     1291      packet->pkttime   = spkttime; 
     1292      packet->datastart = sdatastart; 
     1293      packet->dataend   = sdataend; 
     1294      packet->datasize  = sdatasize; 
     1295 
     1296      if (packet->datasize > (ssize_t)maxdatasize) 
     1297      { 
     1298        dl_log_r (dlconn, 2, 0, 
     1299                  "[%s] dl_collect_nb(): packet data larger (%ld) than receiving buffer (%ld)\n", 
     1300                  dlconn->addr, packet->datasize, maxdatasize); 
     1301        return DLERROR; 
     1302      } 
     1303 
     1304      /* Receive packet data, blocking until complete */ 
     1305      if ((rv = dl_recvdata (dlconn, packetdata, packet->datasize, 1)) != packet->datasize) 
     1306      { 
     1307        if (rv == -1) 
     1308          return DLENDED; 
     1309 
     1310        dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem receiving packet data\n", 
     1311                  dlconn->addr); 
     1312        return DLERROR; 
     1313      } 
     1314 
     1315      /* Update most recently received packet ID and time */ 
     1316      dlconn->pktid   = packet->pktid; 
     1317      dlconn->pkttime = packet->pkttime; 
     1318 
     1319      return DLPACKET; 
     1320    } 
     1321    else if (!strncmp (header, "ID", 2)) 
     1322    { 
     1323      dl_log_r (dlconn, 1, 2, "[%s] Received keepalive (ID) from server\n", dlconn->addr); 
     1324    } 
     1325    else if (!strncmp (header, "ENDSTREAM", 9)) 
     1326    { 
     1327      dl_log_r (dlconn, 1, 2, "[%s] Received end-of-stream from server\n", dlconn->addr); 
     1328      dlconn->streaming = 0; 
     1329      return DLENDED; 
     1330    } 
     1331    else 
     1332    { 
     1333      dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): Unrecognized packet header %.6s\n", 
     1334                dlconn->addr, header); 
    12771335      return DLERROR; 
    12781336    } 
    1279    
    1280   /* Process data if header received */ 
    1281   if ( rv > 0 ) 
    1282     { 
    1283       /* Reset keepalive trigger */ 
    1284       dlconn->keepalive_trig = -1; 
    1285        
    1286       if ( ! strncmp (header, "PACKET", 6) ) 
    1287         { 
    1288           /* Parse PACKET header */ 
    1289           rv = sscanf (header, "PACKET %s %lld %lld %lld %lld %lld", 
    1290                        packet->streamid, &spktid, &spkttime, 
    1291                        &sdatastart, &sdataend, &sdatasize); 
    1292            
    1293           if ( rv != 6 ) 
    1294             { 
    1295               dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): cannot parse PACKET header\n", 
    1296                         dlconn->addr); 
    1297               return DLERROR; 
    1298             } 
    1299            
    1300           packet->pktid = spktid; 
    1301           packet->pkttime = spkttime; 
    1302           packet->datastart = sdatastart; 
    1303           packet->dataend = sdataend; 
    1304           packet->datasize = sdatasize; 
    1305            
    1306           if ( packet->datasize > maxdatasize ) 
    1307             { 
    1308               dl_log_r (dlconn, 2, 0, 
    1309                         "[%s] dl_collect_nb(): packet data larger (%ld) than receiving buffer (%ld)\n", 
    1310                         dlconn->addr, packet->datasize, maxdatasize); 
    1311               return DLERROR; 
    1312             } 
    1313            
    1314           /* Receive packet data, blocking until complete */ 
    1315           if ( (rv = dl_recvdata (dlconn, packetdata, packet->datasize, 1)) != packet->datasize ) 
    1316             { 
    1317               if ( rv == -1 ) 
    1318                 return DLENDED; 
    1319                
    1320               dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): problem receiving packet data\n", 
    1321                         dlconn->addr); 
    1322               return DLERROR; 
    1323             } 
    1324            
    1325           /* Update most recently received packet ID and time */ 
    1326           dlconn->pktid = packet->pktid; 
    1327           dlconn->pkttime = packet->pkttime; 
    1328            
    1329           return DLPACKET; 
    1330         } 
    1331       else if ( ! strncmp (header, "ID", 2) ) 
    1332         { 
    1333           dl_log_r (dlconn, 1, 2, "[%s] Received keepalive (ID) from server\n", dlconn->addr); 
    1334         } 
    1335       else if ( ! strncmp (header, "ENDSTREAM", 9) ) 
    1336         { 
    1337           dl_log_r (dlconn, 1, 2, "[%s] Received end-of-stream from server\n", dlconn->addr); 
    1338           dlconn->streaming = 0; 
    1339           return DLENDED; 
    1340         } 
    1341       else 
    1342         { 
    1343           dl_log_r (dlconn, 2, 0, "[%s] dl_collect_nb(): Unrecognized packet header %.6s\n", 
    1344                     dlconn->addr, header); 
    1345           return DLERROR; 
    1346         } 
    1347     } 
    1348    
     1337  } 
     1338 
    13491339  /* Update timing variables */ 
    13501340  now = dlp_time (); 
    1351    
     1341 
    13521342  /* Keepalive/heartbeat interval timing logic */ 
    1353   if ( dlconn->keepalive ) 
    1354     { 
    1355       if ( dlconn->keepalive_trig == -1 )  /* reset timer */ 
    1356         { 
    1357           dlconn->keepalive_time = now; 
    1358           dlconn->keepalive_trig = 0; 
    1359         } 
    1360       else if ( dlconn->keepalive_trig == 0 && 
    1361                 (now - dlconn->keepalive_time) > (dlconn->keepalive * DLTMODULUS) ) 
    1362         { 
    1363           dlconn->keepalive_trig = 1; 
    1364         } 
    1365     } 
    1366    
    1367   return ( dlconn->terminate ) ? DLENDED: DLNOPACKET; 
    1368 }  /* End of dl_collect_nb() */ 
    1369  
    1370  
    1371 /***********************************************************************//** 
     1343  if (dlconn->keepalive) 
     1344  { 
     1345    if (dlconn->keepalive_trig == -1) /* reset timer */ 
     1346    { 
     1347      dlconn->keepalive_time = now; 
     1348      dlconn->keepalive_trig = 0; 
     1349    } 
     1350    else if (dlconn->keepalive_trig == 0 && 
     1351             (now - dlconn->keepalive_time) > (dlconn->keepalive * DLTMODULUS)) 
     1352    { 
     1353      dlconn->keepalive_trig = 1; 
     1354    } 
     1355  } 
     1356 
     1357  return (dlconn->terminate) ? DLENDED : DLNOPACKET; 
     1358} /* End of dl_collect_nb() */ 
     1359 
     1360/***********************************************************************/ /** 
    13721361 * @brief Handle the server reply to a command 
    13731362 * 
     
    13951384  long long int pvalue; 
    13961385  long long int size = 0; 
    1397   int rv = 0; 
    1398    
    1399   if ( ! dlconn || ! buffer ) 
    1400     return -1; 
    1401    
     1386  int rv             = 0; 
     1387 
     1388  if (!dlconn || !buffer) 
     1389    return -1; 
     1390 
    14021391  /* Make sure buffer if terminated */ 
    14031392  cbuffer[buflen] = '\0'; 
    1404    
     1393 
    14051394  /* Parse reply header */ 
    1406   if ( sscanf (buffer, "%10s %lld %lld", status, &pvalue, &size) != 3 ) 
    1407     { 
    1408       dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Unable to parse reply header: '%s'\n", 
    1409                 dlconn->addr, buffer); 
     1395  if (sscanf (buffer, "%10s %lld %lld", status, &pvalue, &size) != 3) 
     1396  { 
     1397    dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Unable to parse reply header: '%s'\n", 
     1398              dlconn->addr, buffer); 
     1399    return -1; 
     1400  } 
     1401 
     1402  /* Store reply value if requested */ 
     1403  if (value) 
     1404    *value = pvalue; 
     1405 
     1406  /* Check that reply message will fit into buffer */ 
     1407  if (size > buflen) 
     1408  { 
     1409    dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Reply message too large (%d) for buffer (%d)\n", 
     1410              dlconn->addr, size, buflen); 
     1411    return -1; 
     1412  } 
     1413 
     1414  /* Receive reply message if included */ 
     1415  if (size > 0) 
     1416  { 
     1417    /* Receive reply message, blocking until complete */ 
     1418    if ((rv = dl_recvdata (dlconn, buffer, (size_t)size, 1)) != size) 
     1419    { 
     1420      /* Only log an error if the connection was not shut down */ 
     1421      if (rv < -1) 
     1422        dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Problem receiving reply message\n", 
     1423                  dlconn->addr); 
    14101424      return -1; 
    14111425    } 
    1412    
    1413   /* Store reply value if requested */ 
    1414   if ( value ) 
    1415     *value = pvalue; 
    1416    
    1417   /* Check that reply message will fit into buffer */ 
    1418   if ( size > buflen ) 
    1419     { 
    1420       dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Reply message too large (%d) for buffer (%d)\n", 
    1421                 dlconn->addr, size, buflen); 
    1422       return -1;       
    1423     } 
    1424    
    1425   /* Receive reply message if included */ 
    1426   if ( size > 0 ) 
    1427     { 
    1428       /* Receive reply message, blocking until complete */ 
    1429       if ( (rv = dl_recvdata (dlconn, buffer, size, 1)) != size ) 
    1430         { 
    1431           /* Only log an error if the connection was not shut down */ 
    1432           if ( rv < -1 ) 
    1433             dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Problem receiving reply message\n", 
    1434                       dlconn->addr); 
    1435           return -1; 
    1436         } 
    1437        
    1438       if ( size < buflen ) 
    1439         cbuffer[size] = '\0'; 
    1440       else 
    1441         cbuffer[buflen-1] = '\0'; 
    1442     } 
     1426 
     1427    if (size < buflen) 
     1428      cbuffer[size] = '\0'; 
     1429    else 
     1430      cbuffer[buflen - 1] = '\0'; 
     1431  } 
    14431432  /* Make sure buffer is terminated */ 
    14441433  else 
    1445     { 
    1446       cbuffer[0] = '\0'; 
    1447     } 
    1448    
     1434  { 
     1435    cbuffer[0] = '\0'; 
     1436  } 
     1437 
    14491438  /* Check for "OK" status in reply header */ 
    1450   if ( ! strncmp (status, "OK", 2) ) 
    1451     { 
    1452       rv = 0; 
    1453     } 
    1454   else if ( ! strncmp (status, "ERROR", 5) ) 
    1455     { 
    1456       rv = 1; 
    1457     } 
     1439  if (!strncmp (status, "OK", 2)) 
     1440  { 
     1441    rv = 0; 
     1442  } 
     1443  else if (!strncmp (status, "ERROR", 5)) 
     1444  { 
     1445    rv = 1; 
     1446  } 
    14581447  else 
    1459     { 
    1460       dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Unrecognized reply string %.5s\n", 
    1461                 dlconn->addr, buffer); 
    1462       rv = -1; 
    1463     } 
    1464    
     1448  { 
     1449    dl_log_r (dlconn, 2, 0, "[%s] dl_handlereply(): Unrecognized reply string %.5s\n", 
     1450              dlconn->addr, buffer); 
     1451    rv = -1; 
     1452  } 
     1453 
    14651454  return rv; 
    1466 }  /* End of dl_handlereply() */ 
    1467  
    1468  
    1469 /***********************************************************************//** 
     1455} /* End of dl_handlereply() */ 
     1456 
     1457/***********************************************************************/ /** 
    14701458 * @brief Set the terminate parameter of a DataLink connection 
    14711459 * 
     
    14801468{ 
    14811469  dl_log_r (dlconn, 1, 1, "[%s] Terminating connection\n", dlconn->addr); 
    1482    
     1470 
    14831471  dlconn->terminate = 1; 
    1484 }  /* End of dl_terminate() */ 
     1472} /* End of dl_terminate() */ 
  • trunk/src/libsrc/libdali/example/Makefile.win

    r5978 r6842  
    11# 
    2 # 
    3 # Nmake file - Windows version 
     2# Nmake file - MS Visual C/C++ 
    43# Use 'nmake -f Makefile.win' 
    54 
    65NODEBUG=1 
    76 
    8 !include <ntwin32.mak> 
    9  
    107INCS = /I.. 
     8OPTS = -D_CRT_SECURE_NO_WARNINGS 
    119LIBS = ../libdali.lib ws2_32.lib advapi32.lib 
    1210BIN = daliclient.exe 
    1311 
    1412OBJS =  daliclient.obj 
    15  
    16 cflags = $(cflags) -DWIN32 
    1713 
    1814all: daliclient 
     
    2218 
    2319.c.obj: 
    24         $(cc) /nologo $(cflags) $(cdebug) $(cvarsmt) $(tflags) $(INCS) $< 
     20        $(CC) /nologo $(CFLAGS) $(INCS) $(OPTS) /c $< 
    2521 
    2622# Clean-up directives 
  • trunk/src/libsrc/libdali/genutils.c

    r5978 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file genutils.c 
    33 * 
     
    1515#include "libdali.h" 
    1616 
    17 /***********************************************************************//** 
     17/***********************************************************************/ /** 
    1818 * @brief Split a stream ID into separate components: "W_X_Y_Z/TYPE" 
    1919 * 
     
    3636  char *id; 
    3737  char *ptr, *top, *next; 
    38    
    39   if ( ! streamid ) 
     38 
     39  if (!streamid) 
    4040    return -1; 
    41    
     41 
    4242  /* Duplicate stream ID */ 
    43   if ( ! (id = strdup(streamid)) ) 
     43  if (!(id = strdup (streamid))) 
    4444    return -1; 
    45    
     45 
    4646  /* First truncate after the type if included */ 
    47   if ( (ptr = strrchr (id, '/')) ) 
    48     { 
    49       *ptr++ = '\0'; 
    50        
    51       /* Copy the type if requested */ 
    52       if ( type ) 
    53         strcpy (type, ptr); 
    54     } 
    55    
     47  if ((ptr = strrchr (id, '/'))) 
     48  { 
     49    *ptr++ = '\0'; 
     50 
     51    /* Copy the type if requested */ 
     52    if (type) 
     53      strcpy (type, ptr); 
     54  } 
     55 
    5656  /* W */ 
    5757  top = id; 
    58   if ( (ptr = strchr (top, '_')) ) 
    59     { 
    60       next = ptr + 1; 
    61       *ptr = '\0'; 
    62        
    63       if ( w ) 
    64         strcpy (w, top); 
    65        
    66       top = next; 
    67     } 
     58  if ((ptr = strchr (top, '_'))) 
     59  { 
     60    next = ptr + 1; 
     61    *ptr = '\0'; 
     62 
     63    if (w) 
     64      strcpy (w, top); 
     65 
     66    top = next; 
     67  } 
    6868  /* X */ 
    69   if ( (ptr = strchr (top, '_')) ) 
    70     { 
    71       next = ptr + 1; 
    72       *ptr = '\0'; 
     69  if ((ptr = strchr (top, '_'))) 
     70  { 
     71    next = ptr + 1; 
     72    *ptr = '\0'; 
    7373 
    74       if ( x ) 
    75         strcpy (x, top); 
    76        
    77       top = next; 
    78     } 
     74    if (x) 
     75      strcpy (x, top); 
     76 
     77    top = next; 
     78  } 
    7979  /* Y */ 
    80   if ( (ptr = strchr (top, '_')) ) 
    81     { 
    82       next = ptr + 1; 
    83       *ptr = '\0'; 
    84        
    85       if ( y ) 
    86         strcpy (y, top); 
    87        
    88       top = next; 
    89     } 
     80  if ((ptr = strchr (top, '_'))) 
     81  { 
     82    next = ptr + 1; 
     83    *ptr = '\0'; 
     84 
     85    if (y) 
     86      strcpy (y, top); 
     87 
     88    top = next; 
     89  } 
    9090  /* Z */ 
    91   if ( *top && z ) 
    92     { 
    93       strcpy (z, top); 
    94     } 
    95    
     91  if (*top && z) 
     92  { 
     93    strcpy (z, top); 
     94  } 
     95 
    9696  /* Free duplicated stream ID */ 
    97   if ( id ) 
     97  if (id) 
    9898    free (id); 
    99    
     99 
    100100  return 0; 
    101 }  /* End of dl_splitstreamid() */ 
     101} /* End of dl_splitstreamid() */ 
    102102 
    103  
    104 /***********************************************************************//** 
     103/***********************************************************************/ /** 
    105104 * @brief Determine byte order of host machine 
    106105 * 
     
    109108 * provided.  The code actually tests for little-endianess, the only 
    110109 * other alternative is assumed to be big endian. 
    111  *  
     110 * 
    112111 * @return 0 if the host is little endian, otherwise 1. 
    113112 ***************************************************************************/ 
     
    117116  int16_t host = 1; 
    118117  return !(*((int8_t *)(&host))); 
    119 }  /* End of dl_bigendianhost() */ 
     118} /* End of dl_bigendianhost() */ 
    120119 
    121  
    122 /***********************************************************************//** 
     120/***********************************************************************/ /** 
    123121 * @brief Return absolute value of double value 
    124122 * 
     
    126124 * if the input double is positive multiplying by -1.0 if not and 
    127125 * return it. 
    128  *  
     126 * 
    129127 * @return Positive value of input double. 
    130128 ***************************************************************************/ 
     
    132130dl_dabs (double value) 
    133131{ 
    134   if ( value < 0.0 ) 
     132  if (value < 0.0) 
    135133    value *= -1.0; 
    136134  return value; 
    137 }  /* End of dl_dabs() */ 
     135} /* End of dl_dabs() */ 
    138136 
    139  
    140 /***********************************************************************//** 
     137/***********************************************************************/ /** 
    141138 * @brief Read a line from a file stream 
    142139 * 
     
    153150{ 
    154151  int nread = 0; 
    155    
    156   if ( ! buffer ) 
     152 
     153  if (!buffer) 
    157154    return -1; 
    158    
     155 
    159156  /* Read data from stream until newline character or max characters */ 
    160   while ( nread < (buflen-1) ) 
     157  while (nread < (buflen - 1)) 
     158  { 
     159    /* Read a single character from the stream */ 
     160    if (read (fd, buffer + nread, 1) != 1) 
    161161    { 
    162       /* Read a single character from the stream */ 
    163       if ( read (fd, buffer+nread, 1) != 1 ) 
    164         { 
    165           return -1; 
    166         } 
    167        
    168       /* Trap door for newline character */ 
    169       if ( buffer[nread] == '\n' ) 
    170         { 
    171           break; 
    172         } 
    173        
    174       nread++; 
     162      return -1; 
    175163    } 
    176    
     164 
     165    /* Trap door for newline character */ 
     166    if (buffer[nread] == '\n') 
     167    { 
     168      break; 
     169    } 
     170 
     171    nread++; 
     172  } 
     173 
    177174  /* Terminate string in buffer */ 
    178175  buffer[nread] = '\0'; 
    179    
     176 
    180177  return nread; 
    181 }  /* End of dl_readline() */ 
     178} /* End of dl_readline() */ 
  • trunk/src/libsrc/libdali/libdali.h

    r5981 r6842  
    11/***********************************************************************//** 
    22 * @file libdali.h 
    3  *  
     3 * 
    44 * Interface declarations for the DataLink library (libdali). 
    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/ 
     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 
    1721 * 
    1822 * @author Chad Trabant, IRIS Data Management Center 
    1923 * 
    20  * modified: 2011.003 
     24 * modified: 2016.291 
    2125 ***************************************************************************/ 
    2226 
     
    3034#include "portable.h" 
    3135 
    32 #define LIBDALI_VERSION "1.6"        /**< libdali version */ 
    33 #define LIBDALI_RELEASE "2013.210"   /**< libdali release date */ 
     36#define LIBDALI_VERSION "1.7"        /**< libdali version */ 
     37#define LIBDALI_RELEASE "2016.291"   /**< libdali release date */ 
    3438 
    3539#define MAXPACKETSIZE       16384    /**< Maximum packet size for libdali */ 
     
    8690   
    8791  /* Connection parameters maintained internally */ 
    88   int         link;             /**< The network socket descriptor, maintained internally */ 
     92  SOCKET      link;             /**< The network socket descriptor, maintained internally */ 
    8993  float       serverproto;      /**< Server version of the DataLink protocol, maintained internally */ 
    9094  int32_t     maxpktsize;       /**< Maximum packet size for server, maintained internally */ 
     
    137141 
    138142/* network.c */ 
    139 extern int     dl_connect (DLCP *dlconn); 
     143extern SOCKET  dl_connect (DLCP *dlconn); 
    140144extern void    dl_disconnect (DLCP *dlconn); 
    141145extern int     dl_senddata (DLCP *dlconn, void *buffer, size_t sendlen); 
  • trunk/src/libsrc/libdali/logging.c

    r5978 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file logging.c 
    33 * 
     
    1616 ***************************************************************************/ 
    1717 
     18#include <stdarg.h> 
    1819#include <stdio.h> 
    1920#include <stdlib.h> 
    20 #include <stdarg.h> 
    2121#include <string.h> 
    2222 
     
    2424 
    2525void dl_loginit_main (DLLog *logp, int verbosity, 
    26                       void (*log_print)(char*), const char *logprefix, 
    27                       void (*diag_print)(char*), const char *errprefix); 
     26                      void (*log_print) (char *), const char *logprefix, 
     27                      void (*diag_print) (char *), const char *errprefix); 
    2828 
    2929int dl_log_main (DLLog *logp, int level, int verb, va_list *varlist); 
     
    3232DLLog gDLLog = {NULL, NULL, NULL, NULL, 0}; 
    3333 
    34  
    35 /***********************************************************************//** 
     34/***********************************************************************/ /** 
    3635 * @brief Initialize global logging system parameters 
    3736 * 
     
    4241void 
    4342dl_loginit (int verbosity, 
    44             void (*log_print)(char*), const char *logprefix, 
    45             void (*diag_print)(char*), const char *errprefix) 
     43            void (*log_print) (char *), const char *logprefix, 
     44            void (*diag_print) (char *), const char *errprefix) 
    4645{ 
    4746  dl_loginit_main (&gDLLog, verbosity, log_print, logprefix, diag_print, errprefix); 
    48 }  /* End of dl_loginit() */ 
    49  
    50  
    51 /***********************************************************************//** 
     47} /* End of dl_loginit() */ 
     48 
     49/***********************************************************************/ /** 
    5250 * @brief Initialize logging parameters specific to a DLCP 
    5351 * 
     
    6058void 
    6159dl_loginit_r (DLCP *dlconn, int verbosity, 
    62               void (*log_print)(char*), const char *logprefix, 
    63               void (*diag_print)(char*), const char *errprefix) 
    64 { 
    65   if ( ! dlconn ) 
     60              void (*log_print) (char *), const char *logprefix, 
     61              void (*diag_print) (char *), const char *errprefix) 
     62{ 
     63  if (!dlconn) 
    6664    return; 
    6765 
    68   if ( dlconn->log == NULL ) 
    69     { 
    70       dlconn->log = (DLLog *) malloc (sizeof(DLLog)); 
    71  
    72       dlconn->log->log_print = NULL; 
    73       dlconn->log->logprefix = NULL; 
    74       dlconn->log->diag_print = NULL; 
    75       dlconn->log->errprefix = NULL; 
    76       dlconn->log->verbosity = 0; 
    77     } 
    78  
    79   dl_loginit_main(dlconn->log, verbosity, log_print, logprefix, diag_print, errprefix); 
    80 }  /* End of dl_loginit_r() */ 
    81  
    82  
    83 /***********************************************************************//** 
     66  if (dlconn->log == NULL) 
     67  { 
     68    dlconn->log = (DLLog *)malloc (sizeof (DLLog)); 
     69 
     70    dlconn->log->log_print  = NULL; 
     71    dlconn->log->logprefix  = NULL; 
     72    dlconn->log->diag_print = NULL; 
     73    dlconn->log->errprefix  = NULL; 
     74    dlconn->log->verbosity  = 0; 
     75  } 
     76 
     77  dl_loginit_main (dlconn->log, verbosity, log_print, logprefix, diag_print, errprefix); 
     78} /* End of dl_loginit_r() */ 
     79 
     80/***********************************************************************/ /** 
    8481 * @brief Initialize logging parameters for a specific DLLog 
    8582 * 
     
    9491DLLog * 
    9592dl_loginit_rl (DLLog *log, int verbosity, 
    96                void (*log_print)(char*), const char *logprefix, 
    97                void (*diag_print)(char*), const char *errprefix) 
     93               void (*log_print) (char *), const char *logprefix, 
     94               void (*diag_print) (char *), const char *errprefix) 
    9895{ 
    9996  DLLog *logp; 
    10097 
    101   if ( log == NULL ) 
    102     { 
    103       logp = (DLLog *) malloc (sizeof(DLLog)); 
    104  
    105       logp->log_print = NULL; 
    106       logp->logprefix = NULL; 
    107       logp->diag_print = NULL; 
    108       logp->errprefix = NULL; 
    109       logp->verbosity = 0; 
    110     } 
     98  if (log == NULL) 
     99  { 
     100    logp = (DLLog *)malloc (sizeof (DLLog)); 
     101 
     102    logp->log_print = NULL; 
     103    logp->logprefix = NULL; 
     104    logp->diag_print = NULL; 
     105    logp->errprefix = NULL; 
     106    logp->verbosity = 0; 
     107  } 
    111108  else 
    112     { 
    113       logp = log; 
    114     } 
     109  { 
     110    logp = log; 
     111  } 
    115112 
    116113  dl_loginit_main (logp, verbosity, log_print, logprefix, diag_print, errprefix); 
    117114 
    118115  return logp; 
    119 }  /* End of dl_loginit_rl() */ 
    120  
    121  
    122 /***********************************************************************//** 
     116} /* End of dl_loginit_rl() */ 
     117 
     118/***********************************************************************/ /** 
    123119 * @brief Initialize the logging system 
    124120 * 
     
    151147void 
    152148dl_loginit_main (DLLog *logp, int verbosity, 
    153                  void (*log_print)(char*), const char *logprefix, 
    154                  void (*diag_print)(char*), const char *errprefix) 
    155 { 
    156   if ( ! logp ) 
     149                 void (*log_print) (char *), const char *logprefix, 
     150                 void (*diag_print) (char *), const char *errprefix) 
     151{ 
     152  if (!logp) 
    157153    return; 
    158154 
    159155  logp->verbosity = verbosity; 
    160156 
    161   if ( log_print ) 
     157  if (log_print) 
    162158    logp->log_print = log_print; 
    163159 
    164   if ( logprefix ) 
    165     { 
    166       if ( strlen(logprefix) >= MAX_LOG_MSG_LENGTH ) 
    167         { 
    168           dl_log_rl (logp, 2, 0, "log message prefix is too large\n"); 
    169         } 
    170       else 
    171         { 
    172           logp->logprefix = logprefix; 
    173         } 
    174     } 
    175  
    176   if ( diag_print ) 
     160  if (logprefix) 
     161  { 
     162    if (strlen (logprefix) >= MAX_LOG_MSG_LENGTH) 
     163    { 
     164      dl_log_rl (logp, 2, 0, "log message prefix is too large\n"); 
     165    } 
     166    else 
     167    { 
     168      logp->logprefix = logprefix; 
     169    } 
     170  } 
     171 
     172  if (diag_print) 
    177173    logp->diag_print = diag_print; 
    178174 
    179   if ( errprefix ) 
    180     { 
    181       if ( strlen(errprefix) >= MAX_LOG_MSG_LENGTH ) 
    182         { 
    183           dl_log_rl (logp, 2, 0, "error message prefix is too large\n"); 
    184         } 
    185       else 
    186         { 
    187           logp->errprefix = errprefix; 
    188         } 
    189     } 
     175  if (errprefix) 
     176  { 
     177    if (strlen (errprefix) >= MAX_LOG_MSG_LENGTH) 
     178    { 
     179      dl_log_rl (logp, 2, 0, "error message prefix is too large\n"); 
     180    } 
     181    else 
     182    { 
     183      logp->errprefix = errprefix; 
     184    } 
     185  } 
    190186 
    191187  return; 
    192 }  /* End of dl_loginit_main() */ 
    193  
    194  
    195 /***********************************************************************//** 
     188} /* End of dl_loginit_main() */ 
     189 
     190/***********************************************************************/ /** 
    196191 * @brief Log a message using the global logging parameters 
    197192 * 
     
    209204  int retval; 
    210205  va_list varlist; 
    211    
     206 
    212207  va_start (varlist, verb); 
    213208 
     
    217212 
    218213  return retval; 
    219 }  /* End of dl_log() */ 
    220  
    221  
    222 /***********************************************************************//** 
     214} /* End of dl_log() */ 
     215 
     216/***********************************************************************/ /** 
    223217 * @brief Log a message using the log parameters from a DLCP 
    224218 * 
     
    241235  DLLog *logp; 
    242236 
    243   if ( ! dlconn ) 
     237  if (!dlconn) 
    244238    logp = &gDLLog; 
    245   else if ( ! dlconn->log ) 
     239  else if (!dlconn->log) 
    246240    logp = &gDLLog; 
    247241  else 
    248242    logp = dlconn->log; 
    249    
     243 
    250244  va_start (varlist, verb); 
    251    
     245 
    252246  retval = dl_log_main (logp, level, verb, &varlist); 
    253247 
     
    255249 
    256250  return retval; 
    257 }  /* End of dl_log_r() */ 
    258  
    259  
    260 /***********************************************************************//** 
     251} /* End of dl_log_r() */ 
     252 
     253/***********************************************************************/ /** 
    261254 * @brief Log a message using the log parameters from a DLCP 
    262255 * 
     
    279272  DLLog *logp; 
    280273 
    281   if ( ! log ) 
     274  if (!log) 
    282275    logp = &gDLLog; 
    283276  else 
    284277    logp = log; 
    285    
     278 
    286279  va_start (varlist, verb); 
    287    
     280 
    288281  retval = dl_log_main (logp, level, verb, &varlist); 
    289282 
     
    291284 
    292285  return retval; 
    293 }  /* End of dl_log_rl() */ 
    294  
    295  
    296 /***********************************************************************//** 
     286} /* End of dl_log_rl() */ 
     287 
     288/***********************************************************************/ /** 
    297289 * @brief Primary log message processing routine 
    298290 * 
     
    304296 * The function uses logging parameters specified in the supplied 
    305297 * DLLog. 
    306  *  
     298 * 
    307299 * This function expects 3+ arguments, message level, verbosity level, 
    308300 * fprintf format, and fprintf arguments.  If the verbosity level is 
     
    341333  static char message[MAX_LOG_MSG_LENGTH]; 
    342334  int retvalue = 0; 
    343    
     335 
    344336  message[0] = '\0'; 
    345    
     337 
    346338  if (verb <= logp->verbosity) 
    347     { 
    348       int presize; 
    349       const char *format; 
    350  
    351       format = va_arg (*varlist, const char *); 
    352  
    353       if ( level >= 2 ) /* Error message */ 
    354         { 
    355           if ( logp->errprefix != NULL ) 
    356             { 
    357               strncpy (message, logp->errprefix, MAX_LOG_MSG_LENGTH); 
    358             } 
    359           else 
    360             { 
    361               strncpy (message, "error: ", MAX_LOG_MSG_LENGTH); 
    362             } 
    363  
    364           presize = strlen(message); 
    365           retvalue = vsnprintf (&message[presize], 
    366                                 MAX_LOG_MSG_LENGTH - presize, 
    367                                 format, *varlist); 
    368  
    369           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    370  
    371           if ( logp->diag_print != NULL ) 
    372             { 
    373               logp->diag_print (message); 
    374             } 
    375           else 
    376             { 
    377               fprintf(stderr, "%s", message); 
    378             } 
    379         } 
    380       else if ( level == 1 ) /* Diagnostic message */ 
    381         { 
    382           if ( logp->logprefix != NULL ) 
    383             { 
    384               strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    385             } 
    386  
    387           presize = strlen(message); 
    388           retvalue = vsnprintf (&message[presize], 
    389                                 MAX_LOG_MSG_LENGTH - presize, 
    390                                 format, *varlist); 
    391  
    392           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    393  
    394           if ( logp->diag_print != NULL ) 
    395             { 
    396               logp->diag_print (message); 
    397             } 
    398           else 
    399             { 
    400               fprintf(stderr, "%s", message); 
    401             } 
    402         } 
    403       else if ( level == 0 ) /* Normal log message */ 
    404         { 
    405           if ( logp->logprefix != NULL ) 
    406             { 
    407               strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
    408             } 
    409  
    410           presize = strlen(message); 
    411           retvalue = vsnprintf (&message[presize], 
    412                                 MAX_LOG_MSG_LENGTH - presize, 
    413                                 format, *varlist); 
    414  
    415           message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
    416  
    417           if ( logp->log_print != NULL ) 
    418             { 
    419               logp->log_print (message); 
    420             } 
    421           else 
    422             { 
    423               fprintf(stdout, "%s", message); 
    424             } 
    425         } 
    426     } 
     339  { 
     340    int presize; 
     341    const char *format; 
     342 
     343    format = va_arg (*varlist, const char *); 
     344 
     345    if (level >= 2) /* Error message */ 
     346    { 
     347      if (logp->errprefix != NULL) 
     348      { 
     349        strncpy (message, logp->errprefix, MAX_LOG_MSG_LENGTH); 
     350      } 
     351      else 
     352      { 
     353        strncpy (message, "error: ", MAX_LOG_MSG_LENGTH); 
     354      } 
     355 
     356      presize  = strlen (message); 
     357      retvalue = vsnprintf (&message[presize], 
     358                            MAX_LOG_MSG_LENGTH - presize, 
     359                            format, *varlist); 
     360 
     361      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     362 
     363      if (logp->diag_print != NULL) 
     364      { 
     365        logp->diag_print (message); 
     366      } 
     367      else 
     368      { 
     369        fprintf (stderr, "%s", message); 
     370      } 
     371    } 
     372    else if (level == 1) /* Diagnostic message */ 
     373    { 
     374      if (logp->logprefix != NULL) 
     375      { 
     376        strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
     377      } 
     378 
     379      presize  = strlen (message); 
     380      retvalue = vsnprintf (&message[presize], 
     381                            MAX_LOG_MSG_LENGTH - presize, 
     382                            format, *varlist); 
     383 
     384      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     385 
     386      if (logp->diag_print != NULL) 
     387      { 
     388        logp->diag_print (message); 
     389      } 
     390      else 
     391      { 
     392        fprintf (stderr, "%s", message); 
     393      } 
     394    } 
     395    else if (level == 0) /* Normal log message */ 
     396    { 
     397      if (logp->logprefix != NULL) 
     398      { 
     399        strncpy (message, logp->logprefix, MAX_LOG_MSG_LENGTH); 
     400      } 
     401 
     402      presize  = strlen (message); 
     403      retvalue = vsnprintf (&message[presize], 
     404                            MAX_LOG_MSG_LENGTH - presize, 
     405                            format, *varlist); 
     406 
     407      message[MAX_LOG_MSG_LENGTH - 1] = '\0'; 
     408 
     409      if (logp->log_print != NULL) 
     410      { 
     411        logp->log_print (message); 
     412      } 
     413      else 
     414      { 
     415        fprintf (stdout, "%s", message); 
     416      } 
     417    } 
     418  } 
    427419 
    428420  return retvalue; 
    429 }  /* End of dl_log_main() */ 
     421} /* End of dl_log_main() */ 
  • trunk/src/libsrc/libdali/network.c

    r5981 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file network.c 
    33 * 
     
    66 * @author Chad Trabant, IRIS Data Management Center 
    77 * 
    8  * Version: 2013.210 
     8 * Version: 2016.291 
    99 ***************************************************************************/ 
    1010 
     
    1515#include "libdali.h" 
    1616 
    17  
    18 /***********************************************************************//** 
     17/***********************************************************************/ /** 
    1918 * @brief Connect to a DataLink server 
    2019 * 
     
    3635 * @retval -1 on errors 
    3736 ***************************************************************************/ 
    38 int 
     37SOCKET 
    3938dl_connect (DLCP *dlconn) 
    4039{ 
    41   int sock; 
     40  SOCKET sock; 
    4241  long int nport; 
    4342  char nodename[300]; 
     
    4645  size_t addrlen; 
    4746  struct sockaddr addr; 
    48    
    49   if ( dlp_sockstartup() ) 
    50     { 
    51       dl_log_r (dlconn, 2, 0, "could not initialize network sockets\n"); 
    52       return -1; 
    53     } 
    54    
     47 
     48  if (dlp_sockstartup ()) 
     49  { 
     50    dl_log_r (dlconn, 2, 0, "could not initialize network sockets\n"); 
     51    return -1; 
     52  } 
     53 
    5554  /* Check server address string and use defaults if needed: 
    5655   * If only ':' is specified neither host nor port specified 
     
    5857   * If ':' is the first character no host was specified 
    5958   */ 
    60   if ( ! strcmp (dlconn->addr, ":") ) 
     59  if (!strcmp (dlconn->addr, ":")) 
     60  { 
     61    strcpy (nodename, "localhost"); 
     62    strcpy (nodeport, "16000"); 
     63  } 
     64  else if ((ptr = strchr (dlconn->addr, ':')) == NULL) 
     65  { 
     66    strncpy (nodename, dlconn->addr, sizeof (nodename)); 
     67    strcpy (nodeport, "16000"); 
     68  } 
     69  else 
     70  { 
     71    if (ptr == dlconn->addr) 
    6172    { 
    6273      strcpy (nodename, "localhost"); 
    63       strcpy (nodeport, "16000"); 
    64     } 
    65   else if ((ptr = strchr (dlconn->addr, ':')) == NULL) 
    66     { 
    67       strncpy (nodename, dlconn->addr, sizeof(nodename)); 
    68       strcpy (nodeport, "16000"); 
    69     } 
    70   else 
    71     { 
    72       if ( ptr == dlconn->addr ) 
    73         { 
    74           strcpy (nodename, "localhost"); 
    75         } 
    76       else 
    77         { 
    78           strncpy (nodename, dlconn->addr, (ptr - dlconn->addr)); 
    79           nodename[(ptr - dlconn->addr)] = '\0'; 
    80         } 
    81        
    82       strcpy (nodeport, ptr+1); 
    83  
    84       /* Sanity test the port number */ 
    85       nport = strtoul (nodeport, &tail, 10); 
    86       if ( *tail || (nport <= 0 || nport > 0xffff) ) 
    87         { 
    88           dl_log_r (dlconn, 2, 0, "server port specified incorrectly\n"); 
    89           dlconn->terminate = 1; 
    90           return -1; 
    91         } 
    92     } 
    93    
     74    } 
     75    else 
     76    { 
     77      strncpy (nodename, dlconn->addr, (ptr - dlconn->addr)); 
     78      nodename[(ptr - dlconn->addr)] = '\0'; 
     79    } 
     80 
     81    strcpy (nodeport, ptr + 1); 
     82 
     83    /* Sanity test the port number */ 
     84    nport = strtoul (nodeport, &tail, 10); 
     85    if (*tail || (nport <= 0 || nport > 0xffff)) 
     86    { 
     87      dl_log_r (dlconn, 2, 0, "server port specified incorrectly\n"); 
     88      dlconn->terminate = 1; 
     89      return -1; 
     90    } 
     91  } 
     92 
    9493  /* Resolve server address */ 
    95   if ( dlp_getaddrinfo (nodename, nodeport, &addr, &addrlen) ) 
    96     { 
    97       dl_log_r (dlconn, 2, 0, "cannot resolve hostname %s\n", nodename ); 
    98       return -1; 
    99     } 
    100    
     94  if (dlp_getaddrinfo (nodename, nodeport, &addr, &addrlen)) 
     95  { 
     96    dl_log_r (dlconn, 2, 0, "cannot resolve hostname %s\n", nodename); 
     97    return -1; 
     98  } 
     99 
    101100  /* Create socket */ 
    102   if ( (sock = socket (PF_INET, SOCK_STREAM, 0)) < 0 ) 
    103     { 
    104       dl_log_r (dlconn, 2, 0, "[%s] socket(): %s\n", dlconn->addr, dlp_strerror ()); 
    105       dlp_sockclose (sock); 
    106       return -1; 
    107     } 
    108    
     101  if ((sock = socket (PF_INET, SOCK_STREAM, 0)) < 0) 
     102  { 
     103    dl_log_r (dlconn, 2, 0, "[%s] socket(): %s\n", dlconn->addr, dlp_strerror ()); 
     104    dlp_sockclose (sock); 
     105    return -1; 
     106  } 
     107 
    109108  /* Set socket I/O timeouts if possible */ 
    110   if ( dlconn->iotimeout ) 
    111     { 
    112       int timeout = (dlconn->iotimeout > 0) ? dlconn->iotimeout : - dlconn->iotimeout; 
    113        
    114       if ( dlp_setsocktimeo (sock, timeout) == 1 ) 
    115         { 
    116           dl_log_r (dlconn, 1, 2, "[%s] using system socket timeouts\n", dlconn->addr); 
    117            
    118           /* Negate timeout to indicate socket timeouts are set */ 
    119           dlconn->iotimeout = - timeout; 
    120         } 
    121     } 
    122    
     109  if (dlconn->iotimeout) 
     110  { 
     111    int timeout = (dlconn->iotimeout > 0) ? dlconn->iotimeout : -dlconn->iotimeout; 
     112 
     113    if (dlp_setsocktimeo (sock, timeout) == 1) 
     114    { 
     115      dl_log_r (dlconn, 1, 2, "[%s] using system socket timeouts\n", dlconn->addr); 
     116 
     117      /* Negate timeout to indicate socket timeouts are set */ 
     118      dlconn->iotimeout = -timeout; 
     119    } 
     120  } 
     121 
    123122  /* Connect socket */ 
    124   if ( (dlp_sockconnect (sock, (struct sockaddr *) &addr, addrlen)) ) 
    125     { 
    126       dl_log_r (dlconn, 2, 0, "[%s] connect(): %s\n", dlconn->addr, dlp_strerror ()); 
    127       dlp_sockclose (sock); 
    128       return -1; 
    129     } 
    130    
     123  if ((dlp_sockconnect (sock, (struct sockaddr *)&addr, addrlen))) 
     124  { 
     125    dl_log_r (dlconn, 2, 0, "[%s] connect(): %s\n", dlconn->addr, dlp_strerror ()); 
     126    dlp_sockclose (sock); 
     127    return -1; 
     128  } 
     129 
    131130  /* Set socket to non-blocking */ 
    132   if ( dlp_socknoblock(sock) ) 
    133     { 
    134       dl_log_r (dlconn, 2, 0, "Error setting socket to non-blocking\n"); 
    135       dlp_sockclose (sock); 
    136       return -1; 
    137     } 
    138    
     131  if (dlp_socknoblock (sock)) 
     132  { 
     133    dl_log_r (dlconn, 2, 0, "Error setting socket to non-blocking\n"); 
     134    dlp_sockclose (sock); 
     135    return -1; 
     136  } 
     137 
    139138  /* socket connected */ 
    140139  dl_log_r (dlconn, 1, 1, "[%s] network socket opened\n", dlconn->addr); 
    141    
     140 
    142141  dlconn->link = sock; 
    143    
     142 
    144143  /* Everything should be connected, exchange IDs */ 
    145   if ( dl_exchangeIDs (dlconn, 1) == -1 ) 
    146     { 
    147       dlp_sockclose (sock); 
    148       return -1; 
    149     } 
    150    
     144  if (dl_exchangeIDs (dlconn, 1) == -1) 
     145  { 
     146    dlp_sockclose (sock); 
     147    return -1; 
     148  } 
     149 
    151150  return sock; 
    152 }  /* End of dl_connect() */ 
    153  
    154  
    155 /***********************************************************************//** 
     151} /* End of dl_connect() */ 
     152 
     153/***********************************************************************/ /** 
    156154 * @brief Disconnect a DataLink connection 
    157155 * 
     
    164162dl_disconnect (DLCP *dlconn) 
    165163{ 
    166   if ( dlconn->link >= 0 ) 
    167     { 
    168       dlp_sockclose (dlconn->link); 
    169       dlconn->link = -1; 
    170        
    171       dl_log_r (dlconn, 1, 1, "[%s] network socket closed\n", dlconn->addr); 
    172     } 
    173 }  /* End of dl_disconnect() */ 
    174  
    175  
    176 /***********************************************************************//** 
     164  if (dlconn->link >= 0) 
     165  { 
     166    dlp_sockclose (dlconn->link); 
     167    dlconn->link = -1; 
     168 
     169    dl_log_r (dlconn, 1, 1, "[%s] network socket closed\n", dlconn->addr); 
     170  } 
     171} /* End of dl_disconnect() */ 
     172 
     173/***********************************************************************/ /** 
    177174 * @brief Send arbitrary data to a DataLink server 
    178175 * 
     
    198195{ 
    199196  /* Set socket to blocking */ 
    200   if ( dlp_sockblock (dlconn->link) ) 
    201     { 
    202       dl_log_r (dlconn, 2, 0, "[%s] error setting socket to blocking\n", 
    203                 dlconn->addr); 
    204       return -1; 
    205     } 
    206    
     197  if (dlp_sockblock (dlconn->link)) 
     198  { 
     199    dl_log_r (dlconn, 2, 0, "[%s] error setting socket to blocking\n", 
     200              dlconn->addr); 
     201    return -1; 
     202  } 
     203 
    207204  /* Set timeout alarm if needed */ 
    208   if ( dlconn->iotimeout > 0 ) 
    209     { 
    210       if ( dlp_setioalarm (dlconn->iotimeout) ) 
    211         { 
    212           dl_log_r (dlconn, 2, 0, "[%s] error setting network I/O timeout\n", 
    213                     dlconn->addr); 
    214         } 
    215     } 
    216    
     205  if (dlconn->iotimeout > 0) 
     206  { 
     207    if (dlp_setioalarm (dlconn->iotimeout)) 
     208    { 
     209      dl_log_r (dlconn, 2, 0, "[%s] error setting network I/O timeout\n", 
     210                dlconn->addr); 
     211    } 
     212  } 
     213 
    217214  /* Send data */ 
    218   if ( send (dlconn->link, buffer, sendlen, 0) != sendlen ) 
    219     { 
    220       dl_log_r (dlconn, 2, 0, "[%s] error sending data\n", dlconn->addr); 
    221       return -1; 
    222     } 
    223    
     215  if (send (dlconn->link, buffer, sendlen, 0) != (ssize_t)sendlen) 
     216  { 
     217    dl_log_r (dlconn, 2, 0, "[%s] error sending data\n", dlconn->addr); 
     218    return -1; 
     219  } 
     220 
    224221  /* Cancel timeout alarm if set */ 
    225   if ( dlconn->iotimeout > 0 ) 
    226     { 
    227       if ( dlp_setioalarm (0) ) 
    228         { 
    229           dl_log_r (dlconn, 2, 0, "[%s] error cancelling network I/O timeout\n", 
    230                     dlconn->addr); 
    231         } 
    232     } 
    233    
     222  if (dlconn->iotimeout > 0) 
     223  { 
     224    if (dlp_setioalarm (0)) 
     225    { 
     226      dl_log_r (dlconn, 2, 0, "[%s] error cancelling network I/O timeout\n", 
     227                dlconn->addr); 
     228    } 
     229  } 
     230 
    234231  /* Set socket to non-blocking */ 
    235   if ( dlp_socknoblock (dlconn->link) ) 
    236     { 
    237       dl_log_r (dlconn, 2, 0, "[%s] error setting socket to non-blocking\n", 
    238                 dlconn->addr); 
    239       return -1; 
    240     } 
    241    
     232  if (dlp_socknoblock (dlconn->link)) 
     233  { 
     234    dl_log_r (dlconn, 2, 0, "[%s] error setting socket to non-blocking\n", 
     235              dlconn->addr); 
     236    return -1; 
     237  } 
     238 
    242239  return 0; 
    243 }  /* End of dl_senddata() */ 
    244  
    245  
    246 /***********************************************************************//** 
     240} /* End of dl_senddata() */ 
     241 
     242/***********************************************************************/ /** 
    247243 * @brief Create and send a DataLink packet 
    248244 * 
     
    274270int 
    275271dl_sendpacket (DLCP *dlconn, void *headerbuf, size_t headerlen, 
    276                void *databuf, size_t datalen, 
    277                void *respbuf, int resplen) 
     272               void *databuf, size_t datalen, 
     273               void *respbuf, int resplen) 
    278274{ 
    279   int bytesread = 0;            /* bytes read into resp buffer */ 
     275  int bytesread = 0; /* bytes read into resp buffer */ 
    280276  char wirepacket[MAXPACKETSIZE]; 
    281    
    282   if ( ! dlconn || ! headerbuf ) 
    283     return -1; 
    284    
     277 
     278  if (!dlconn || !headerbuf) 
     279    return -1; 
     280 
    285281  /* Sanity check that the header is not too large or zero */ 
    286   if ( headerlen > 255 || headerlen == 0 ) 
    287     { 
    288       dl_log_r (dlconn, 2, 0, "[%s] packet header size is invalid: %d\n", 
    289                 dlconn->addr, headerlen); 
    290       return -1; 
    291     } 
    292    
     282  if (headerlen > 255 || headerlen == 0) 
     283  { 
     284    dl_log_r (dlconn, 2, 0, "[%s] packet header size is invalid: %d\n", 
     285              dlconn->addr, headerlen); 
     286    return -1; 
     287  } 
     288 
    293289  /* Sanity check that the header + packet data is not too large */ 
    294   if ( (3 + headerlen + datalen) > MAXPACKETSIZE ) 
    295     { 
    296       dl_log_r (dlconn, 2, 0, "[%s] packet is too large (%d), max is %d\n", 
    297                 dlconn->addr, (headerlen + datalen), MAXPACKETSIZE); 
    298       return -1; 
    299     } 
    300    
     290  if ((3 + headerlen + datalen) > MAXPACKETSIZE) 
     291  { 
     292    dl_log_r (dlconn, 2, 0, "[%s] packet is too large (%d), max is %d\n", 
     293              dlconn->addr, (headerlen + datalen), MAXPACKETSIZE); 
     294    return -1; 
     295  } 
     296 
    301297  /* Set the synchronization and header size bytes */ 
    302298  wirepacket[0] = 'D'; 
    303299  wirepacket[1] = 'L'; 
    304   wirepacket[2] = (uint8_t) headerlen; 
    305    
     300  wirepacket[2] = (uint8_t)headerlen; 
     301 
    306302  /* Copy header into the wire packet */ 
    307   memcpy (wirepacket+3, headerbuf, headerlen); 
    308    
     303  memcpy (wirepacket + 3, headerbuf, headerlen); 
     304 
    309305  /* Copy packet data into the wire packet if supplied */ 
    310   if ( databuf && datalen > 0 ) 
    311     memcpy (wirepacket+3+headerlen, databuf, datalen); 
    312    
     306  if (databuf && datalen > 0) 
     307    memcpy (wirepacket + 3 + headerlen, databuf, datalen); 
     308 
    313309  /* Send data */ 
    314   if ( dl_senddata (dlconn, wirepacket, (3+headerlen+datalen)) < 0 ) 
    315     { 
    316       /* Check for a message from the server */ 
    317       if ( (bytesread = dl_recvheader (dlconn, respbuf, resplen, 0)) > 0 ) 
    318         { 
    319           dl_log_r (dlconn, 2, 0, "[%s] %s", dlconn->addr, respbuf); 
    320         } 
    321        
     310  if (dl_senddata (dlconn, wirepacket, (3 + headerlen + datalen)) < 0) 
     311  { 
     312    /* Check for a message from the server */ 
     313    if ((bytesread = dl_recvheader (dlconn, respbuf, resplen, 0)) > 0) 
     314    { 
     315      dl_log_r (dlconn, 2, 0, "[%s] %s", dlconn->addr, respbuf); 
     316    } 
     317 
     318    return -1; 
     319  } 
     320 
     321  /* If requested collect the response (packet header only) */ 
     322  if (respbuf != NULL) 
     323  { 
     324    if ((bytesread = dl_recvheader (dlconn, respbuf, resplen, 1)) < 0) 
     325    { 
     326      if (bytesread < -1) 
     327        dl_log_r (dlconn, 2, 0, "[%s] error receiving data\n", dlconn->addr); 
     328 
    322329      return -1; 
    323330    } 
    324    
    325   /* If requested collect the response (packet header only) */ 
    326   if ( respbuf != NULL ) 
    327     { 
    328       if ( (bytesread = dl_recvheader (dlconn, respbuf, resplen, 1)) < 0 ) 
    329         { 
    330           if ( bytesread < -1 ) 
    331             dl_log_r (dlconn, 2, 0, "[%s] error receiving data\n", dlconn->addr); 
    332            
    333           return -1; 
    334         } 
    335     } 
    336    
     331  } 
     332 
    337333  return bytesread; 
    338 }  /* End of dl_sendpacket() */ 
    339  
    340  
    341 /***********************************************************************//** 
     334} /* End of dl_sendpacket() */ 
     335 
     336/***********************************************************************/ /** 
    342337 * @brief Receive arbitrary data from a DataLink server 
    343338 * 
     
    363358 * @return number of bytes read on success 
    364359 * @retval 0 when no data available on non-blocking socket 
    365  * @retval -1 on connection shutdown  
     360 * @retval -1 on connection shutdown 
    366361 * @retval -2 on error. 
    367362 ***************************************************************************/ 
     
    370365{ 
    371366  int nrecv; 
    372   int nread = 0; 
     367  int nread  = 0; 
    373368  char *bptr = buffer; 
    374    
    375   if ( ! buffer ) 
    376     { 
     369 
     370  if (!buffer) 
     371  { 
     372    return -2; 
     373  } 
     374 
     375  /* Set socket to blocking if requested */ 
     376  if (blockflag) 
     377  { 
     378    if (dlp_sockblock (dlconn->link)) 
     379    { 
     380      dl_log_r (dlconn, 2, 0, "[%s] Error setting socket to blocking: %s\n", 
     381                dlconn->addr, dlp_strerror ()); 
    377382      return -2; 
    378383    } 
    379    
    380   /* Set socket to blocking if requested */ 
    381   if ( blockflag ) 
    382     { 
    383       if ( dlp_sockblock (dlconn->link) ) 
    384         { 
    385           dl_log_r (dlconn, 2, 0, "[%s] Error setting socket to blocking: %s\n", 
    386                     dlconn->addr, dlp_strerror ()); 
    387           return -2; 
    388         } 
    389     } 
    390    
     384  } 
     385 
    391386  /* Set timeout alarm if needed */ 
    392   if ( dlconn->iotimeout > 0 ) 
    393     { 
    394       if ( dlp_setioalarm (dlconn->iotimeout) ) 
    395         { 
    396           dl_log_r (dlconn, 2, 0, "[%s] error setting network I/O timeout\n", 
    397                     dlconn->addr); 
    398         } 
    399     } 
    400    
     387  if (dlconn->iotimeout > 0) 
     388  { 
     389    if (dlp_setioalarm (dlconn->iotimeout)) 
     390    { 
     391      dl_log_r (dlconn, 2, 0, "[%s] error setting network I/O timeout\n", 
     392                dlconn->addr); 
     393    } 
     394  } 
     395 
    401396  /* Recv until readlen bytes have been read */ 
    402   while ( nread < readlen ) 
    403     { 
    404       if ( (nrecv = recv(dlconn->link, bptr, readlen-nread, 0)) < 0 ) 
    405         { 
    406           /* The only acceptable error is no data on non-blocking */ 
    407           if ( ! blockflag && ! dlp_noblockcheck() ) 
    408             { 
    409               /* Only break out if no data has yet been received */ 
    410               if ( nread == 0 ) 
    411                 break; 
    412                
    413               /* Corner case: if some data has been received in non-blocking 
     397  while (nread < (ssize_t)readlen) 
     398  { 
     399    if ((nrecv = recv (dlconn->link, bptr, readlen - nread, 0)) < 0) 
     400    { 
     401      /* The only acceptable error is no data on non-blocking */ 
     402      if (!blockflag && !dlp_noblockcheck ()) 
     403      { 
     404        /* Only break out if no data has yet been received */ 
     405        if (nread == 0) 
     406          break; 
     407 
     408        /* Corner case: if some data has been received in non-blocking 
    414409                 mode we will loop forever until readlen bytes are read */ 
    415             } 
    416           else 
    417             { 
    418               dl_log_r (dlconn, 2, 0, "[%s] recv(%d): %d %s\n", 
    419                         dlconn->addr, dlconn->link, nrecv, dlp_strerror ()); 
    420               nread = -2; 
    421               break; 
    422             } 
    423         } 
    424        
    425       /* Peer completed an orderly shutdown */ 
    426       if ( nrecv == 0 ) 
    427         { 
    428           nread = -1; 
    429           break; 
    430         } 
    431        
    432       /* Update recv pointer and byte count */ 
    433       if ( nrecv > 0 ) 
    434         { 
    435           bptr += nrecv; 
    436           nread += nrecv; 
    437         } 
    438     } 
    439    
     410      } 
     411      else 
     412      { 
     413        dl_log_r (dlconn, 2, 0, "[%s] recv(%d): %d %s\n", 
     414                  dlconn->addr, dlconn->link, nrecv, dlp_strerror ()); 
     415        nread = -2; 
     416        break; 
     417      } 
     418    } 
     419 
     420    /* Peer completed an orderly shutdown */ 
     421    if (nrecv == 0) 
     422    { 
     423      nread = -1; 
     424      break; 
     425    } 
     426 
     427    /* Update recv pointer and byte count */ 
     428    if (nrecv > 0) 
     429    { 
     430      bptr += nrecv; 
     431      nread += nrecv; 
     432    } 
     433  } 
     434 
    440435  /* Cancel timeout alarm if set */ 
    441   if ( dlconn->iotimeout > 0 ) 
    442     { 
    443       if ( dlp_setioalarm (0) ) 
    444         { 
    445           dl_log_r (dlconn, 2, 0, "[%s] error cancelling network I/O timeout\n", 
    446                     dlconn->addr); 
    447         } 
    448     } 
    449    
     436  if (dlconn->iotimeout > 0) 
     437  { 
     438    if (dlp_setioalarm (0)) 
     439    { 
     440      dl_log_r (dlconn, 2, 0, "[%s] error cancelling network I/O timeout\n", 
     441                dlconn->addr); 
     442    } 
     443  } 
     444 
    450445  /* Set socket to non-blocking if set to blocking */ 
    451   if ( blockflag ) 
    452     { 
    453       if ( dlp_socknoblock (dlconn->link) ) 
    454         { 
    455           dl_log_r (dlconn, 2, 0, "[%s] Error setting socket to non-blocking: %s\n", 
    456                     dlconn->addr, dlp_strerror ()); 
    457           return -2; 
    458         } 
    459     } 
    460    
     446  if (blockflag) 
     447  { 
     448    if (dlp_socknoblock (dlconn->link)) 
     449    { 
     450      dl_log_r (dlconn, 2, 0, "[%s] Error setting socket to non-blocking: %s\n", 
     451                dlconn->addr, dlp_strerror ()); 
     452      return -2; 
     453    } 
     454  } 
     455 
    461456  return nread; 
    462 }  /* End of dl_recvdata() */ 
    463  
    464  
    465 /***********************************************************************//** 
     457} /* End of dl_recvdata() */ 
     458 
     459/***********************************************************************/ /** 
    466460 * @brief Receive DataLink packet header 
    467461 * 
     
    475469 * @return number of bytes read on success 
    476470 * @retval 0 when no data available on non-blocking socket 
    477  * @retval -1 on connection shutdown  
     471 * @retval -1 on connection shutdown 
    478472 * @retval -2 on error. 
    479473 ***************************************************************************/ 
     
    484478  int headerlen; 
    485479  char *cbuffer = buffer; 
    486    
    487   if ( ! dlconn || ! buffer ) 
    488     { 
     480 
     481  if (!dlconn || !buffer) 
     482  { 
     483    return -2; 
     484  } 
     485 
     486  if (buflen < 255) 
     487  { 
     488    dl_log_r (dlconn, 2, 0, "[%s] dl_recvheader(): buffer length to small (%zd)\n", 
     489              dlconn->addr, buflen); 
     490    return -2; 
     491  } 
     492 
     493  /* Receive synchronization bytes and header length */ 
     494  if ((bytesread = dl_recvdata (dlconn, buffer, 3, blockflag)) != 3) 
     495  { 
     496    /* Bytes read but not 3 is an error */ 
     497    if (bytesread > 0) 
    489498      return -2; 
    490     } 
    491    
    492   if ( buflen < 255 ) 
    493     { 
    494       dl_log_r (dlconn, 2, 0, "[%s] dl_recvheader(): buffer length to small (%zd)\n", 
    495                 dlconn->addr, buflen); 
     499    else 
     500      return bytesread; 
     501  } 
     502 
     503  /* Test synchronization bytes */ 
     504  if (cbuffer[0] != 'D' || cbuffer[1] != 'L') 
     505  { 
     506    dl_log_r (dlconn, 2, 0, "[%s] No DataLink packet detected\n", 
     507              dlconn->addr); 
     508    return -2; 
     509  } 
     510 
     511  /* 3rd byte is the header length */ 
     512  headerlen = (uint8_t)cbuffer[2]; 
     513 
     514  /* Receive header payload blocking until completely received */ 
     515  if ((bytesread = dl_recvdata (dlconn, buffer, headerlen, 1)) != headerlen) 
     516  { 
     517    /* Bytes read but not headerlen is an error */ 
     518    if (bytesread > 0) 
    496519      return -2; 
    497     } 
    498    
    499   /* Receive synchronization bytes and header length */ 
    500   if ( (bytesread = dl_recvdata (dlconn, buffer, 3, blockflag)) != 3 ) 
    501     { 
    502       /* Bytes read but not 3 is an error */ 
    503       if ( bytesread > 0 ) 
    504         return -2; 
    505       else 
    506         return bytesread; 
    507     } 
    508    
    509   /* Test synchronization bytes */ 
    510   if ( cbuffer[0] != 'D' || cbuffer[1] != 'L' ) 
    511     { 
    512       dl_log_r (dlconn, 2, 0, "[%s] No DataLink packet detected\n", 
    513                 dlconn->addr); 
    514       return -2; 
    515     } 
    516    
    517   /* 3rd byte is the header length */ 
    518   headerlen = (uint8_t) cbuffer[2]; 
    519    
    520   /* Receive header payload blocking until completely received */ 
    521   if ( (bytesread = dl_recvdata (dlconn, buffer, headerlen, 1)) != headerlen ) 
    522     { 
    523       /* Bytes read but not headerlen is an error */ 
    524       if ( bytesread > 0 ) 
    525         return -2; 
    526       else 
    527         return bytesread; 
    528     } 
    529    
     520    else 
     521      return bytesread; 
     522  } 
     523 
    530524  /* Make sure reply is NULL terminated */ 
    531   if ( bytesread == buflen ) 
    532     cbuffer[bytesread-1] = '\0'; 
     525  if (bytesread == (ssize_t)buflen) 
     526    cbuffer[bytesread - 1] = '\0'; 
    533527  else 
    534528    cbuffer[bytesread] = '\0'; 
    535    
     529 
    536530  return bytesread; 
    537 }  /* End of dl_recvheader() */ 
     531} /* End of dl_recvheader() */ 
  • trunk/src/libsrc/libdali/portable.c

    r5978 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file portable.c: 
    3  *  
     3 * 
    44 * Platform portability routines. 
    55 * 
     
    1818 * @author Chad Trabant, IRIS Data Management Center 
    1919 * 
    20  * modified: 2008.193 
    21  ***************************************************************************/ 
    22  
     20 * modified: 2016.291 
     21 ***************************************************************************/ 
     22 
     23#include <errno.h> 
    2324#include <fcntl.h> 
    24 #include <errno.h> 
    2525#include <stdio.h> 
     26#include <string.h> 
     27#include <sys/stat.h> 
     28#include <sys/types.h> 
    2629#include <time.h> 
    27 #include <string.h> 
    28 #include <sys/types.h> 
    29 #include <sys/stat.h> 
    30  
     30 
     31#include "libdali.h" 
    3132#include "portable.h" 
    32 #include "libdali.h" 
    33  
    34  
    35 /************************************************************************//** 
    36  * @brief Start up socket subsystem (only does something for Win32) 
     33 
     34/************************************************************************/ /** 
     35 * @brief Start up socket subsystem (only does something for WIN) 
    3736 * 
    3837 * Startup the network socket layer.  At the moment this is only meaningful 
    39  * for the WIN32 platform and requests Windows sockets version 2.2. 
     38 * for the WIN platform and requests Windows sockets version 2.2. 
    4039 * 
    4140 * @return -1 on errors and 0 on success. 
     
    4443dlp_sockstartup (void) 
    4544{ 
    46 #if defined(DLP_WIN32) 
     45#if defined(DLP_WIN) 
    4746  WORD wVersionRequested; 
    4847  WSADATA wsaData; 
    4948 
    5049  /* Check for Windows sockets version 2.2 */ 
    51   wVersionRequested = MAKEWORD( 2, 2 ); 
    52  
    53   if ( WSAStartup( wVersionRequested, &wsaData ) ) 
    54     return -1; 
    55  
    56 #endif 
    57  
    58   return 0; 
    59 }  /* End of dlp_sockstartup() */ 
    60  
    61  
    62 /***********************************************************************//** 
     50  wVersionRequested = MAKEWORD (2, 2); 
     51 
     52  if (WSAStartup (wVersionRequested, &wsaData)) 
     53    return -1; 
     54 
     55#endif 
     56 
     57  return 0; 
     58} /* End of dlp_sockstartup() */ 
     59 
     60/***********************************************************************/ /** 
    6361 * @brief Connect a network socket 
    6462 * 
     
    7270 ***************************************************************************/ 
    7371int 
    74 dlp_sockconnect (int socket, struct sockaddr * inetaddr, int addrlen) 
    75 { 
    76 #if defined(DLP_WIN32) 
     72dlp_sockconnect (SOCKET socket, struct sockaddr *inetaddr, int addrlen) 
     73{ 
     74#if defined(DLP_WIN) 
    7775  if ((connect (socket, inetaddr, addrlen)) == SOCKET_ERROR) 
    78     { 
    79       if (WSAGetLastError() != WSAEWOULDBLOCK) 
    80         return -1; 
    81     } 
     76  { 
     77    if (WSAGetLastError () != WSAEWOULDBLOCK) 
     78      return -1; 
     79  } 
    8280#else 
    8381  if ((connect (socket, inetaddr, addrlen)) == -1) 
    84     { 
    85       if (errno != EINPROGRESS) 
    86         return -1; 
    87     } 
    88 #endif 
    89  
    90   return 0; 
    91 }  /* End of dlp_sockconnect() */ 
    92  
    93  
    94 /***********************************************************************//** 
     82  { 
     83    if (errno != EINPROGRESS) 
     84      return -1; 
     85  } 
     86#endif 
     87 
     88  return 0; 
     89} /* End of dlp_sockconnect() */ 
     90 
     91/***********************************************************************/ /** 
    9592 * @brief Close a network socket 
    9693 * 
     
    10299 ***************************************************************************/ 
    103100int 
    104 dlp_sockclose (int socket) 
    105 { 
    106 #if defined(DLP_WIN32) 
     101dlp_sockclose (SOCKET socket) 
     102{ 
     103#if defined(DLP_WIN) 
    107104  return closesocket (socket); 
    108105#else 
    109106  return close (socket); 
    110107#endif 
    111 }  /* End of dlp_sockclose() */ 
    112  
    113  
    114 /***********************************************************************//** 
     108} /* End of dlp_sockclose() */ 
     109 
     110/***********************************************************************/ /** 
    115111 * @brief Set a network socket to blocking mode 
    116112 * 
     
    122118 ***************************************************************************/ 
    123119int 
    124 dlp_sockblock (int socket) 
    125 { 
    126 #if defined(DLP_WIN32) 
     120dlp_sockblock (SOCKET socket) 
     121{ 
     122#if defined(DLP_WIN) 
    127123  u_long flag = 0; 
    128    
    129   if (ioctlsocket(socket, FIONBIO, &flag) == -1) 
    130     return -1; 
    131    
    132 #else 
    133   int flags = fcntl(socket, F_GETFL, 0); 
    134    
     124 
     125  if (ioctlsocket (socket, FIONBIO, &flag) == -1) 
     126    return -1; 
     127 
     128#else 
     129  int flags = fcntl (socket, F_GETFL, 0); 
     130 
    135131  flags &= (~O_NONBLOCK); 
    136    
    137   if (fcntl(socket, F_SETFL, flags) == -1) 
    138     return -1; 
    139  
    140 #endif 
    141  
    142   return 0; 
    143 }  /* End of dlp_sockblock() */ 
    144  
    145  
    146 /***********************************************************************//** 
     132 
     133  if (fcntl (socket, F_SETFL, flags) == -1) 
     134    return -1; 
     135 
     136#endif 
     137 
     138  return 0; 
     139} /* End of dlp_sockblock() */ 
     140 
     141/***********************************************************************/ /** 
    147142 * @brief Set a network socket to non-blocking mode 
    148143 * 
     
    154149 ***************************************************************************/ 
    155150int 
    156 dlp_socknoblock (int socket) 
    157 { 
    158 #if defined(DLP_WIN32) 
     151dlp_socknoblock (SOCKET socket) 
     152{ 
     153#if defined(DLP_WIN) 
    159154  u_long flag = 1; 
    160155 
    161   if (ioctlsocket(socket, FIONBIO, &flag) == -1) 
    162     return -1; 
    163  
    164 #else 
    165   int flags = fcntl(socket, F_GETFL, 0); 
     156  if (ioctlsocket (socket, FIONBIO, &flag) == -1) 
     157    return -1; 
     158 
     159#else 
     160  int flags = fcntl (socket, F_GETFL, 0); 
    166161 
    167162  flags |= O_NONBLOCK; 
    168   if (fcntl(socket, F_SETFL, flags) == -1) 
    169     return -1; 
    170  
    171 #endif 
    172  
    173   return 0; 
    174 }  /* End of dlp_socknoblock() */ 
    175  
    176  
    177 /***********************************************************************//** 
     163  if (fcntl (socket, F_SETFL, flags) == -1) 
     164    return -1; 
     165 
     166#endif 
     167 
     168  return 0; 
     169} /* End of dlp_socknoblock() */ 
     170 
     171/***********************************************************************/ /** 
    178172 * @brief Check if socket action would have blocked 
    179173 * 
     
    187181dlp_noblockcheck (void) 
    188182{ 
    189 #if defined(DLP_WIN32) 
    190   if (WSAGetLastError() != WSAEWOULDBLOCK) 
     183#if defined(DLP_WIN) 
     184  if (WSAGetLastError () != WSAEWOULDBLOCK) 
    191185    return -1; 
    192186 
     
    199193  /* no data available for NONBLOCKing IO */ 
    200194  return 0; 
    201 }  /* End of dlp_noblockcheck() */ 
    202  
    203  
    204 /***********************************************************************//** 
     195} /* End of dlp_noblockcheck() */ 
     196 
     197/***********************************************************************/ /** 
    205198 * @brief Set socket I/O timeout 
    206199 * 
    207  * Set socket I/O timeout if such an option exists.  On Win32 and 
     200 * Set socket I/O timeout if such an option exists.  On WIN and 
    208201 * other platforms where SO_RCVTIMEO and SO_SNDTIMEO are defined this 
    209202 * sets the SO_RCVTIMEO and SO_SNDTIMEO socket options using 
     
    218211 ***************************************************************************/ 
    219212int 
    220 dlp_setsocktimeo (int socket, int timeout) 
    221 { 
    222 #if defined(DLP_WIN32) 
     213dlp_setsocktimeo (SOCKET socket, int timeout) 
     214{ 
     215#if defined(DLP_WIN) 
    223216  int tval = timeout * 1000; 
    224    
    225   if ( setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char*)&tval, sizeof(tval)) ) 
    226     { 
    227       return -1; 
    228     } 
     217 
     218  if (setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tval, sizeof (tval))) 
     219  { 
     220    return -1; 
     221  } 
    229222  tval = timeout * 1000; 
    230   if ( setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char*)&tval, sizeof(tval)) ) 
    231     { 
    232       return -1; 
    233     } 
    234    
    235 #else 
    236   /* Set socket I/O timeouts if socket options are defined */ 
    237 #if defined (SO_RCVTIMEO) && defined (SO_SNDTIMEO) 
     223  if (setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&tval, sizeof (tval))) 
     224  { 
     225    return -1; 
     226  } 
     227 
     228#else 
     229/* Set socket I/O timeouts if socket options are defined */ 
     230#if defined(SO_RCVTIMEO) && defined(SO_SNDTIMEO) 
    238231  struct timeval tval; 
    239    
    240   tval.tv_sec = timeout; 
     232 
     233  tval.tv_sec  = timeout; 
    241234  tval.tv_usec = 0; 
    242    
    243   if ( setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, &tval, sizeof (tval)) ) 
    244     { 
    245       return -1; 
    246     } 
    247   if ( setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, &tval, sizeof (tval)) ) 
    248     { 
    249       return -1; 
    250     } 
    251 #else 
    252   return 0; 
    253 #endif 
    254    
    255 #endif 
    256    
     235 
     236  if (setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, &tval, sizeof (tval))) 
     237  { 
     238    return -1; 
     239  } 
     240  if (setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, &tval, sizeof (tval))) 
     241  { 
     242    return -1; 
     243  } 
     244#else 
     245  return 0; 
     246#endif 
     247 
     248#endif 
     249 
    257250  return 1; 
    258 }  /* End of dlp_setsocktimeo() */ 
    259  
    260  
    261 /***********************************************************************//** 
     251} /* End of dlp_setsocktimeo() */ 
     252 
     253/***********************************************************************/ /** 
    262254 * @brief Set a network I/O real time alarm 
    263255 * 
     
    266258 * most platforms this will cause a SIGALARM signal to be sent to the 
    267259 * calling process after @a timeout seconds have elapsed.  This 
    268  * function does nothing under Win32. 
     260 * function does nothing under WIN. 
    269261 * 
    270262 * @param timeout Alarm timeout in seconds 
     
    275267dlp_setioalarm (int timeout) 
    276268{ 
    277 #if defined(DLP_WIN32) 
    278   /* Non-operation for Win32 */   
    279    
     269#if defined(DLP_WIN) 
     270/* Non-operation for WIN */ 
     271 
    280272#else 
    281273  struct itimerval itval; 
    282    
    283   itval.it_interval.tv_sec = 0; 
     274 
     275  itval.it_interval.tv_sec  = 0; 
    284276  itval.it_interval.tv_usec = 0; 
    285   itval.it_value.tv_sec = timeout; 
    286   itval.it_value.tv_usec = 0; 
    287    
    288   if ( setitimer (ITIMER_REAL, &itval, NULL) ) 
    289     { 
    290       return -1; 
    291     } 
    292    
    293 #endif 
    294    
    295   return 0; 
    296 }  /* End of dlp_setioalarm() */ 
    297  
    298  
    299 /***********************************************************************//** 
    300  * @brief Resolve IP address and prepare paramters for connect() 
    301  * 
    302  * Resolve IP addresses and provide parameters needed for connect(). 
    303  * On Win32 this will use gethostbyname() for portability (only newer 
    304  * Windows platforms support getaddrinfo).  On Linux (glibc2) and 
    305  * Solaris the reentrant gethostbyname_r() is used. 
    306  * 
    307  * The real solution to name resolution is to use POSIX 1003.1g 
    308  * getaddrinfo() because it is standardized, thread-safe and protocol 
    309  * independent (i.e. IPv4, IPv6, etc.).  Unfortunately it is not 
    310  * supported on many older platforms. 
     277  itval.it_value.tv_sec     = timeout; 
     278  itval.it_value.tv_usec    = 0; 
     279 
     280  if (setitimer (ITIMER_REAL, &itval, NULL)) 
     281  { 
     282    return -1; 
     283  } 
     284 
     285#endif 
     286 
     287  return 0; 
     288} /* End of dlp_setioalarm() */ 
     289 
     290/***********************************************************************/ /** 
     291 * @brief Resolve IP address and prepare parameters for connect() 
     292 * 
     293 * On WIN this will use the older gethostbyname() for consistent 
     294 * compatibility with older OS versions.  In the future we should be 
     295 * able to use getaddrinfo() even on Windows. 
     296 * 
     297 * On all other platforms use POSIX 1003.1g getaddrinfo() because it 
     298 * is standardized, thread-safe and protocol independent (i.e. IPv4, 
     299 * IPv6, etc.) and has broad support. 
     300 * 
     301 * Currently, this routine is limited to IPv4 addresses. 
    311302 * 
    312303 * @param nodename Hostname to resolve 
     
    315306 * @param addrlen Returned length of @a addr 
    316307 * 
    317  * @return 0 on success and non-zero on error. 
     308 * @return 0 on success and non-zero on error.  On everything but WIN 
     309 * an error value is the return value of getaddrinfo(). 
    318310 ***************************************************************************/ 
    319311int 
    320312dlp_getaddrinfo (char *nodename, char *nodeport, 
    321                 struct sockaddr *addr, size_t *addrlen) 
    322 { 
    323 #if defined(DLP_WIN32) 
     313                struct sockaddr *addr, size_t *addrlen) 
     314{ 
     315#if defined(DLP_WIN) 
    324316  struct hostent *result; 
    325317  struct sockaddr_in inet_addr; 
     
    327319  char *tail; 
    328320 
    329   if ( (result = gethostbyname (nodename)) == NULL ) 
    330     { 
    331       return -1; 
    332     } 
     321  if ((result = gethostbyname (nodename)) == NULL) 
     322  { 
     323    return -1; 
     324  } 
    333325 
    334326  nport = strtoul (nodeport, &tail, 0); 
     
    336328  memset (&inet_addr, 0, sizeof (inet_addr)); 
    337329  inet_addr.sin_family = AF_INET; 
    338   inet_addr.sin_port = htons ((unsigned short int)nport); 
    339   inet_addr.sin_addr = *(struct in_addr *) result->h_addr_list[0]; 
    340    
    341   *addr = *((struct sockaddr *) &inet_addr); 
    342   *addrlen = sizeof(inet_addr); 
    343  
    344 #elif defined(DLP_GLIBC2) || defined(DLP_SOLARIS) 
    345   /* 512 bytes should be enough for the vast majority of cases.  If 
    346      not (e.g. the node has a lot of aliases) this call will fail. */ 
    347  
    348   char buffer[512]; 
    349   struct hostent *result; 
    350   struct hostent result_buffer; 
    351   struct sockaddr_in inet_addr; 
    352   int my_error; 
    353   long int nport; 
    354   char *tail; 
    355  
    356   #if defined(DLP_GLIBC2) 
    357   gethostbyname_r (nodename, &result_buffer, 
    358                    buffer, sizeof(buffer) - 1, 
    359                    &result, &my_error); 
    360   #endif 
    361  
    362   #if defined(DLP_SOLARIS) 
    363   result = gethostbyname_r (nodename, &result_buffer, 
    364                             buffer, sizeof(buffer) - 1, 
    365                             &my_error); 
    366   #endif 
    367  
    368   if ( !result ) 
    369     return my_error; 
    370  
    371   nport = strtoul (nodeport, &tail, 0); 
    372  
    373   memset (&inet_addr, 0, sizeof (inet_addr)); 
    374   inet_addr.sin_family = AF_INET; 
    375   inet_addr.sin_port = htons ((unsigned short int)nport); 
    376   inet_addr.sin_addr = *(struct in_addr *) result->h_addr_list[0]; 
    377    
    378   *addr = *((struct sockaddr *) &inet_addr); 
    379   *addrlen = sizeof(inet_addr); 
    380  
    381 #else 
    382   /* This will be used by all others, it is not properly supported 
    383      by some but this is the future of name resolution. */ 
    384  
    385   struct addrinfo *result; 
     330  inet_addr.sin_port   = htons ((unsigned short int)nport); 
     331  inet_addr.sin_addr   = *(struct in_addr *)result->h_addr_list[0]; 
     332 
     333  memcpy (addr, &inet_addr, sizeof (struct sockaddr)); 
     334  *addrlen = sizeof (inet_addr); 
     335 
     336#else 
     337  /* getaddrinfo() will be used by all others */ 
     338  struct addrinfo *ptr    = NULL; 
     339  struct addrinfo *result = NULL; 
    386340  struct addrinfo hints; 
    387  
    388   memset (&hints, 0, sizeof(hints)); 
    389   hints.ai_family = PF_INET; 
     341  int rv; 
     342 
     343  memset (&hints, 0, sizeof (hints)); 
     344  hints.ai_family   = AF_INET; 
    390345  hints.ai_socktype = SOCK_STREAM; 
    391    
    392   if ( getaddrinfo (nodename, nodeport, &hints, &result) ) 
     346 
     347  if ((rv = getaddrinfo (nodename, nodeport, &hints, &result))) 
     348  { 
     349    return rv; 
     350  } 
     351 
     352  for (ptr = result; ptr != NULL; ptr = ptr->ai_next) 
     353  { 
     354    if (ptr->ai_family == AF_INET) 
    393355    { 
    394       return -1; 
     356      memcpy (addr, ptr->ai_addr, sizeof (struct sockaddr)); 
     357      *addrlen = (size_t)ptr->ai_addrlen; 
     358      break; 
    395359    } 
    396  
    397   *addr = *(result->ai_addr); 
    398   *addrlen = result->ai_addrlen; 
     360  } 
    399361 
    400362  freeaddrinfo (result); 
     
    403365 
    404366  return 0; 
    405 }  /* End of dlp_getaddrinfo() */ 
    406  
    407  
    408 /***********************************************************************//** 
     367} /* End of dlp_getaddrinfo() */ 
     368 
     369/***********************************************************************/ /** 
    409370 * @brief Open a file stream 
    410371 * 
     
    425386dlp_openfile (const char *filename, char perm) 
    426387{ 
    427 #if defined(DLP_WIN32) 
     388#if defined(DLP_WIN) 
    428389  int flags = (perm == 'w') ? (_O_RDWR | _O_CREAT | _O_BINARY) : (_O_RDONLY | _O_BINARY); 
    429   int mode = (_S_IREAD | _S_IWRITE); 
    430 #else 
    431   int flags = (perm == 'w') ? (O_RDWR | O_CREAT) : O_RDONLY; 
     390  int mode  = (_S_IREAD | _S_IWRITE); 
     391#else 
     392  int flags   = (perm == 'w') ? (O_RDWR | O_CREAT) : O_RDONLY; 
    432393  mode_t mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); 
    433394#endif 
    434    
     395 
    435396  return open (filename, flags, mode); 
    436 }  /* End of dlp_openfile() */ 
    437  
    438  
    439 /***********************************************************************//** 
     397} /* End of dlp_openfile() */ 
     398 
     399/***********************************************************************/ /** 
    440400 * @brief Return a description of the last system error. 
    441401 * 
    442  * @return A description of the last system error, in the case of Win32 
     402 * @return A description of the last system error, in the case of WIN 
    443403 * this will be the last Windows Sockets error. 
    444404 ***************************************************************************/ 
     
    446406dlp_strerror (void) 
    447407{ 
    448 #if defined(DLP_WIN32) 
     408#if defined(DLP_WIN) 
    449409  static char errorstr[100]; 
    450410 
    451   snprintf (errorstr, sizeof(errorstr), "%d", WSAGetLastError()); 
    452   return (const char *) errorstr; 
    453  
    454 #else 
    455   return (const char *) strerror (errno); 
    456  
    457 #endif 
    458 }  /* End of dlp_strerror() */ 
    459  
    460  
    461 /***********************************************************************//** 
     411  snprintf (errorstr, sizeof (errorstr), "%d", WSAGetLastError ()); 
     412  return (const char *)errorstr; 
     413 
     414#else 
     415  return (const char *)strerror (errno); 
     416 
     417#endif 
     418} /* End of dlp_strerror() */ 
     419 
     420/***********************************************************************/ /** 
    462421 * @brief Determine the current system time 
    463422 * 
    464423 * Determine the current time from the system as a dltime_t value.  On 
    465  * the WIN32 platform this function has millisecond resulution, on 
     424 * the WIN platform this function has millisecond resulution, on 
    466425 * Unix platforms this function has microsecond resolution. 
    467426 * 
     
    471430dlp_time (void) 
    472431{ 
    473 #if defined(DLP_WIN32) 
    474    
     432#if defined(DLP_WIN) 
     433 
    475434  static const __int64 SECS_BETWEEN_EPOCHS = 11644473600; 
    476   static const __int64 SECS_TO_100NS = 10000000; /* 10^7 */ 
    477    
     435  static const __int64 SECS_TO_100NS       = 10000000; /* 10^7 */ 
     436 
    478437  __int64 dltime; 
    479438  __int64 UnixTime; 
    480439  SYSTEMTIME SystemTime; 
    481440  FILETIME FileTime; 
    482    
    483   GetSystemTime(&SystemTime); 
    484   SystemTimeToFileTime(&SystemTime, &FileTime); 
    485    
    486   /* Get the full win32 epoch value, in 100ns */ 
    487   UnixTime = ((__int64)FileTime.dwHighDateTime << 32) +  
    488     FileTime.dwLowDateTime; 
    489    
     441 
     442  GetSystemTime (&SystemTime); 
     443  SystemTimeToFileTime (&SystemTime, &FileTime); 
     444 
     445  /* Get the full Windows epoch value, in 100ns */ 
     446  UnixTime = ((__int64)FileTime.dwHighDateTime << 32) + 
     447             FileTime.dwLowDateTime; 
     448 
    490449  /* Convert to the Unix epoch */ 
    491450  UnixTime -= (SECS_BETWEEN_EPOCHS * SECS_TO_100NS); 
    492    
     451 
    493452  UnixTime /= SECS_TO_100NS; /* now convert to seconds */ 
    494    
     453 
    495454  dltime = ((__int64)UnixTime * DLTMODULUS) + 
    496     ((__int64)SystemTime.wMilliseconds * (DLTMODULUS/1000)); 
    497    
     455           ((__int64)SystemTime.wMilliseconds * (DLTMODULUS / 1000)); 
     456 
    498457  return dltime; 
    499    
    500 #else 
    501    
     458 
     459#else 
     460 
    502461  int64_t dltime; 
    503462  struct timeval tv; 
    504    
    505   if ( gettimeofday (&tv, (struct timezone *) 0) ) 
    506     { 
    507       return DLTERROR; 
    508     } 
    509    
     463 
     464  if (gettimeofday (&tv, (struct timezone *)0)) 
     465  { 
     466    return DLTERROR; 
     467  } 
     468 
    510469  dltime = ((int64_t)tv.tv_sec * DLTMODULUS) + 
    511     ((int64_t)tv.tv_usec * (DLTMODULUS/1000000)); 
    512    
     470           ((int64_t)tv.tv_usec * (DLTMODULUS / 1000000)); 
     471 
    513472  return dltime; 
    514    
    515 #endif 
    516 }  /* End of dlp_time() */ 
    517  
    518  
    519 /***********************************************************************//** 
     473 
     474#endif 
     475} /* End of dlp_time() */ 
     476 
     477/***********************************************************************/ /** 
    520478 * @brief Sleep for a specified number of microseconds 
    521  *  
    522  * Sleep for a given number of microseconds.  Under Win32 use SleepEx() 
     479 * 
     480 * Sleep for a given number of microseconds.  Under WIN use SleepEx() 
    523481 * and for all others use the POSIX.4 nanosleep(), which can be 
    524482 * interrupted by signals. 
     
    529487dlp_usleep (unsigned long int useconds) 
    530488{ 
    531 #if defined(DLP_WIN32) 
     489#if defined(DLP_WIN) 
    532490 
    533491  SleepEx ((useconds / 1000), 1); 
    534492 
    535493#else 
    536    
     494 
    537495  struct timespec treq, trem; 
    538    
    539   treq.tv_sec = (time_t) (useconds / 1e6); 
    540   treq.tv_nsec = (long) ((useconds * 1e3) - (treq.tv_sec * 1e9)); 
    541    
     496 
     497  treq.tv_sec  = (time_t) (useconds / 1e6); 
     498  treq.tv_nsec = (long)((useconds * 1e3) - (treq.tv_sec * 1e9)); 
     499 
    542500  nanosleep (&treq, &trem); 
    543501 
    544502#endif 
    545 }  /* End of dlp_usleep() */ 
    546  
    547  
    548 /***********************************************************************//** 
     503} /* End of dlp_usleep() */ 
     504 
     505/***********************************************************************/ /** 
    549506 * @brief Generate a DataLink client ID from system & process information 
    550  *  
     507 * 
    551508 * Generate a client ID composed of the program name, the current user 
    552509 * name and the current process ID as a string where the fields are 
     
    568525dlp_genclientid (char *progname, char *clientid, size_t maxsize) 
    569526{ 
    570 #if defined(DLP_WIN32) 
    571   char osver[100]; 
     527#if defined(DLP_WIN) 
    572528  char *prog = 0; 
    573529  char user[256]; 
    574   DWORD max_user = 256; 
    575   DWORD dwVersion = 0; 
     530  DWORD max_user       = 256; 
     531  DWORD dwVersion      = 0; 
    576532  DWORD dwMajorVersion = 0; 
    577533  DWORD dwMinorVersion = 0; 
    578   DWORD dwBuild = 0; 
    579   int pid = getpid(); 
    580  
    581    /* Do a simple basename() for any supplied progname */ 
    582   if ( progname && (prog = strrchr (progname, '\\')) ) 
    583     { 
    584       prog++; 
    585     } 
    586   else if ( progname ) 
    587     { 
    588       prog = progname; 
    589     } 
    590    
    591    
     534  DWORD dwBuild        = 0; 
     535  int pid              = _getpid (); 
     536 
     537  /* Do a simple basename() for any supplied progname */ 
     538  if (progname && (prog = strrchr (progname, '\\'))) 
     539  { 
     540    prog++; 
     541  } 
     542  else if (progname) 
     543  { 
     544    prog = progname; 
     545  } 
     546 
    592547  /* Look up current user name */ 
    593   if ( ! GetUserName (user, &max_user) ) 
    594     { 
    595       user[0] = '\0'; 
    596     } 
    597    
     548  if (!GetUserName (user, &max_user)) 
     549  { 
     550    user[0] = '\0'; 
     551  } 
     552 
    598553  /* Get Windows version */ 
    599   dwVersion = GetVersion(); 
    600   dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion))); 
    601   dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion))); 
     554  dwVersion      = GetVersion (); 
     555  dwMajorVersion = (DWORD) (LOBYTE (LOWORD (dwVersion))); 
     556  dwMinorVersion = (DWORD) (HIBYTE (LOWORD (dwVersion))); 
    602557  if (dwVersion < 0x80000000) 
    603     dwBuild = (DWORD)(HIWORD(dwVersion)); 
    604    
    605   snprintf (clientid, maxsize, "%s:%s:%ld:Win32-%d.%d (%d)", 
    606             (prog)?prog:"", 
    607             (user)?user:"", 
    608             (long) pid, 
    609             dwMajorVersion, dwMinorVersion, dwBuild); 
    610    
     558    dwBuild = (DWORD) (HIWORD (dwVersion)); 
     559 
     560  snprintf (clientid, maxsize, "%s:%s:%ld:WIN-%d.%d (%d)", 
     561            (prog) ? prog : "", 
     562            (user) ? user : "", 
     563            (long)pid, 
     564            dwMajorVersion, dwMinorVersion, dwBuild); 
     565 
    611566  return 0; 
    612567#else 
     
    614569  char *prog = 0; 
    615570  char *user = 0; 
    616   pid_t pid = getpid (); 
     571  pid_t pid  = getpid (); 
    617572  struct passwd *pw; 
    618573  struct utsname myname; 
    619    
     574 
    620575  /* Do a simple basename() for any supplied progname */ 
    621   if ( progname && (prog = strrchr (progname, '/')) ) 
    622     { 
    623       prog++; 
    624     } 
    625   else if ( progname ) 
    626     { 
    627       prog = progname; 
    628     } 
    629   
     576  if (progname && (prog = strrchr (progname, '/'))) 
     577  { 
     578    prog++; 
     579  } 
     580  else if (progname) 
     581  { 
     582    prog = progname; 
     583  } 
     584 
    630585  /* Look up real user name */ 
    631   if ( (pw = getpwuid(getuid())) ) 
    632     { 
    633       user = pw->pw_name; 
    634     } 
    635    
     586  if ((pw = getpwuid (getuid ()))) 
     587  { 
     588    user = pw->pw_name; 
     589  } 
     590 
    636591  /* Lookup system name and release */ 
    637   if ( uname (&myname) >= 0 ) 
    638     { 
    639       snprintf (osver, sizeof(osver), "%s-%s", 
    640                 myname.sysname, myname.release); 
    641     } 
     592  if (uname (&myname) >= 0) 
     593  { 
     594    snprintf (osver, sizeof (osver), "%s-%s", 
     595              myname.sysname, myname.release); 
     596  } 
    642597  else 
    643     { 
    644       osver[0] = '\0'; 
    645     } 
    646    
     598  { 
     599    osver[0] = '\0'; 
     600  } 
     601 
    647602  snprintf (clientid, maxsize, "%s:%s:%ld:%s", 
    648             (prog)?prog:"", 
    649             (user)?user:"", 
    650             (long) pid, 
    651             osver); 
    652    
    653   return 0; 
    654 #endif 
    655 }  /* End of dlp_genclientid() */ 
     603            (prog) ? prog : "", 
     604            (user) ? user : "", 
     605            (long)pid, 
     606            osver); 
     607 
     608  return 0; 
     609#endif 
     610} /* End of dlp_genclientid() */ 
  • trunk/src/libsrc/libdali/portable.h

    r5978 r6842  
    11/***********************************************************************//** 
    22 * @file portable.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, IRIS Data Management Center 
     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.193 
     21 * Copyright (C) 2016 Chad Trabant, IRIS Data Management Center 
     22 * 
     23 * modified: 2016.291 
    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, possible others, 
     34 * requires a packed attribute in certain places but this only works 
     35 * with GCC and compatible for now. */ 
    3736#if defined (__GNUC__) 
    3837  #define DLP_PACKED __attribute__ ((packed)) 
     
    4140#endif 
    4241 
    43   /* Make some guesses about the system libraries based 
    44    * on the architecture.  Currently the assumptions are: 
    45    * Linux => glibc2 (DLP_GLIBC2) 
    46    * Sun => Solaris (DLP_SOLARIS) 
    47    * BSD => BSD libraries, including Apple Mac OS X (DLP_BSD) 
    48    * WIN32 => WIN32 and Windows Sockets 2 (DLP_WIN32) 
    49    */ 
     42/* C99 standard headers */ 
     43#include <stdlib.h> 
     44#include <stdio.h> 
     45#include <stdarg.h> 
     46#include <time.h> 
     47#include <string.h> 
     48#include <ctype.h> 
    5049 
    51 #if defined(__linux__) || defined(__linux) 
    52   #define DLP_GLIBC2 1 
     50#if defined(__linux__) || defined(__linux) || defined(__CYGWIN__) 
     51  #define DLP_LINUX 1 
     52  #define DLP_GLIBC2 1 /* Deprecated */ 
    5353 
    54   #include <stdlib.h> 
    5554  #include <unistd.h> 
    56   #include <stdarg.h> 
    5755  #include <inttypes.h> 
     56  #include <errno.h> 
    5857  #include <sys/socket.h> 
    5958  #include <netinet/in.h> 
     
    6160  #include <sys/time.h> 
    6261  #include <sys/utsname.h> 
    63   #include <sys/types.h> 
    6462  #include <pwd.h> 
    65     
    66 #elif defined(__sun__) || defined(__sun) 
    67   #define DLP_SOLARIS 1 
    6863 
    69   #include <stdlib.h> 
     64#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) 
     65  #define DLP_BSD 
     66 
    7067  #include <unistd.h> 
    71   #include <stdarg.h> 
    7268  #include <inttypes.h> 
    7369  #include <errno.h> 
    74   #include <sys/types.h> 
    7570  #include <sys/socket.h> 
    7671  #include <netinet/in.h> 
     
    7873  #include <sys/time.h> 
    7974  #include <sys/utsname.h> 
    80   #include <sys/types.h> 
    8175  #include <pwd.h> 
    8276 
    83 #elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) 
    84   #define DLP_BSD 1 
     77#elif defined(__sun__) || defined(__sun) 
     78  #define DLP_SOLARIS 1 
    8579 
    86   #include <stdlib.h> 
    87   #include <stdio.h> 
    8880  #include <unistd.h> 
    89   #include <stdarg.h> 
    9081  #include <inttypes.h> 
     82  #include <errno.h> 
     83  #include <sys/types.h> 
     84  #include <sys/stat.h> 
    9185  #include <sys/socket.h> 
    9286  #include <netinet/in.h> 
     
    9488  #include <sys/time.h> 
    9589  #include <sys/utsname.h> 
    96   #include <sys/types.h> 
    97   #include <string.h> 
    98   #include <ctype.h> 
    9990  #include <pwd.h> 
    10091 
    101 #elif defined(WIN32) 
    102   #define DLP_WIN32 1 
     92#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64) 
     93  #define DLP_WIN 1 
     94  #define DLP_WIN32 1 /* Deprecated */ 
    10395 
     96  #include <winsock2.h> 
     97  #include <ws2tcpip.h> 
    10498  #include <windows.h> 
    105   #include <stdarg.h> 
    106   #include <winsock.h> 
    107   #include <stdio.h> 
     99  #include <process.h> 
    108100  #include <io.h> 
    109   #include <process.h> 
    110101 
     102  /* For MSVC 2012 and earlier define standard int types, otherwise use inttypes.h */ 
     103  #if defined(_MSC_VER) && _MSC_VER <= 1700 
     104    typedef signed char int8_t; 
     105    typedef unsigned char uint8_t; 
     106    typedef signed short int int16_t; 
     107    typedef unsigned short int uint16_t; 
     108    typedef signed int int32_t; 
     109    typedef unsigned int uint32_t; 
     110    typedef signed __int64 int64_t; 
     111    typedef unsigned __int64 uint64_t; 
     112  #else 
     113    #include <inttypes.h> 
     114  #endif 
     115 
     116  #if defined(_MSC_VER) 
     117    #if !defined(PRId64) 
     118      #define PRId64 "I64d" 
     119    #endif 
     120    #if !defined(SCNd64) 
     121      #define SCNd64 "I64d" 
     122    #endif 
     123    #if !defined(ssize_t) 
     124      #define ssize_t SSIZE_T 
     125    #endif 
     126  #endif 
     127 
     128  #define strdup _strdup 
     129  #define read _read 
     130  #define write _write 
     131  #define open _open 
     132  #define close _close 
    111133  #define snprintf _snprintf 
    112134  #define vsnprintf _vsnprintf 
    113135  #define strncasecmp _strnicmp 
    114  
    115   typedef signed char int8_t; 
    116   typedef unsigned char uint8_t; 
    117   typedef signed short int int16_t; 
    118   typedef unsigned short int uint16_t; 
    119   typedef signed int int32_t; 
    120   typedef unsigned int uint32_t; 
    121   typedef signed __int64 int64_t; 
    122   typedef unsigned __int64 uint64_t; 
    123136 
    124137#else 
     
    134147#endif 
    135148 
     149/* Use int for SOCKET if platform includes have not defined it */ 
     150#ifndef SOCKET 
     151  #define SOCKET int 
     152#endif 
     153 
    136154extern int dlp_sockstartup (void); 
    137 extern int dlp_sockconnect (int socket, struct sockaddr * inetaddr, int addrlen); 
    138 extern int dlp_sockclose (int socket); 
    139 extern int dlp_sockblock (int socket); 
    140 extern int dlp_socknoblock (int socket); 
     155extern int dlp_sockconnect (SOCKET socket, struct sockaddr * inetaddr, int addrlen); 
     156extern int dlp_sockclose (SOCKET socket); 
     157extern int dlp_sockblock (SOCKET socket); 
     158extern int dlp_socknoblock (SOCKET socket); 
    141159extern int dlp_noblockcheck (void); 
    142 extern int dlp_setsocktimeo (int socket, int timeout); 
     160extern int dlp_setsocktimeo (SOCKET socket, int timeout); 
    143161extern int dlp_setioalarm (int timeout); 
    144162extern int dlp_getaddrinfo (char * nodename, char * nodeport, 
     
    153171} 
    154172#endif 
    155   
     173 
    156174#endif /* PORTABLE_H */ 
  • trunk/src/libsrc/libdali/statefile.c

    r5978 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file statefile.c: 
    33 * 
     
    99 ***************************************************************************/ 
    1010 
     11#include <errno.h> 
    1112#include <stdio.h> 
    12 #include <errno.h> 
    1313#include <string.h> 
    1414 
    1515#include "libdali.h" 
    1616 
    17  
    18 /***********************************************************************//** 
     17/***********************************************************************/ /** 
    1918 * @brief Save a DataLink connection state to a file 
    2019 * 
     
    3433  int linelen; 
    3534  int statefd; 
    36    
    37   if ( ! dlconn || ! statefile ) 
     35 
     36  if (!dlconn || !statefile) 
    3837    return -1; 
    3938 
    4039  /* Open the state file */ 
    41   if ( (statefd = dlp_openfile (statefile, 'w')) < 0 ) 
    42     { 
    43       dl_log_r (dlconn, 2, 0, "cannot open state file for writing\n"); 
    44       return -1; 
    45     } 
    46    
     40  if ((statefd = dlp_openfile (statefile, 'w')) < 0) 
     41  { 
     42    dl_log_r (dlconn, 2, 0, "cannot open state file for writing\n"); 
     43    return -1; 
     44  } 
     45 
    4746  dl_log_r (dlconn, 1, 2, "saving connection state to state file\n"); 
    48    
     47 
    4948  /* Write state information: <server address> <packet ID> <packet time> */ 
    50   linelen = snprintf (line, sizeof(line), "%s %lld %lld\n", 
    51                       dlconn->addr, (long long int)dlconn->pktid, 
    52                       (long long int)dlconn->pkttime); 
    53    
    54   if ( write (statefd, line, linelen) != linelen ) 
    55     { 
    56       dl_log_r (dlconn, 2, 0, "cannot write to state file, %s\n", strerror (errno)); 
    57       return -1; 
    58     } 
    59    
    60   if ( close (statefd) ) 
    61     { 
    62       dl_log_r (dlconn, 2, 0, "cannot close state file, %s\n", strerror (errno)); 
    63       return -1; 
    64     } 
    65    
     49  linelen = snprintf (line, sizeof (line), "%s %lld %lld\n", 
     50                      dlconn->addr, (long long int)dlconn->pktid, 
     51                      (long long int)dlconn->pkttime); 
     52 
     53  if (write (statefd, line, linelen) != linelen) 
     54  { 
     55    dl_log_r (dlconn, 2, 0, "cannot write to state file, %s\n", strerror (errno)); 
     56    return -1; 
     57  } 
     58 
     59  if (close (statefd)) 
     60  { 
     61    dl_log_r (dlconn, 2, 0, "cannot close state file, %s\n", strerror (errno)); 
     62    return -1; 
     63  } 
     64 
    6665  return 0; 
    6766} /* End of dl_savestate() */ 
    6867 
    69  
    70 /***********************************************************************//** 
     68/***********************************************************************/ /** 
    7169 * @brief Recover DataLink connection state from a file 
    7270 * 
     
    9088  int found = 0; 
    9189  int count = 1; 
    92    
    93   if ( ! dlconn || ! statefile ) 
     90 
     91  if (!dlconn || !statefile) 
    9492    return -1; 
    95    
     93 
    9694  /* Open the state file */ 
    97   if ( (statefd = dlp_openfile (statefile, 'r')) < 0 ) 
     95  if ((statefd = dlp_openfile (statefile, 'r')) < 0) 
     96  { 
     97    if (errno == ENOENT) 
    9898    { 
    99       if ( errno == ENOENT ) 
    100         { 
    101           dl_log_r (dlconn, 1, 0, "could not find state file: %s\n", statefile); 
    102           return 1; 
    103         } 
    104       else 
    105         { 
    106           dl_log_r (dlconn, 2, 0, "could not open state file, %s\n", strerror (errno)); 
    107           return -1; 
    108         } 
     99      dl_log_r (dlconn, 1, 0, "could not find state file: %s\n", statefile); 
     100      return 1; 
    109101    } 
    110    
    111   dl_log_r (dlconn, 1, 1, "recovering connection state from state file\n"); 
    112    
    113   /* Loop through lines in the file and find the matching server address */ 
    114   while ( (dl_readline (statefd, line, sizeof(line))) >= 0 ) 
     102    else 
    115103    { 
    116       long long int spktid; 
    117       long long int spkttime; 
    118        
    119       addrstr[0] = '\0'; 
    120        
    121       fields = sscanf (line, "%s %lld %lld\n", addrstr, &spktid, &spkttime); 
    122        
    123       if ( fields < 0 ) 
    124         continue; 
    125        
    126       if ( fields < 3 ) 
    127         { 
    128           dl_log_r (dlconn, 2, 0, "could not parse line %d of state file\n", count); 
    129         } 
    130        
    131       /* Check for a matching server address and set connection values if found */ 
    132       if ( ! strncmp (dlconn->addr, addrstr, sizeof(addrstr)) ) 
    133         { 
    134           dlconn->pktid = spktid; 
    135           dlconn->pkttime = spkttime; 
    136            
    137           found = 1; 
    138           break; 
    139         } 
    140        
    141       count++; 
    142     } 
    143    
    144   if ( ! found ) 
    145     { 
    146       dl_log_r (dlconn, 1, 0, "Server address not found in state file: %s\n", dlconn->addr); 
    147     }   
    148    
    149   if ( close (statefd) ) 
    150     { 
    151       dl_log_r (dlconn, 2, 0, "could not close state file, %s\n", strerror (errno)); 
     104      dl_log_r (dlconn, 2, 0, "could not open state file, %s\n", strerror (errno)); 
    152105      return -1; 
    153106    } 
     107  } 
     108 
     109  dl_log_r (dlconn, 1, 1, "recovering connection state from state file\n"); 
     110 
     111  /* Loop through lines in the file and find the matching server address */ 
     112  while ((dl_readline (statefd, line, sizeof (line))) >= 0) 
     113  { 
     114    long long int spktid; 
     115    long long int spkttime; 
     116 
     117    addrstr[0] = '\0'; 
     118 
     119    fields = sscanf (line, "%s %lld %lld\n", addrstr, &spktid, &spkttime); 
     120 
     121    if (fields < 0) 
     122      continue; 
     123 
     124    if (fields < 3) 
     125    { 
     126      dl_log_r (dlconn, 2, 0, "could not parse line %d of state file\n", count); 
     127    } 
     128 
     129    /* Check for a matching server address and set connection values if found */ 
     130    if (!strncmp (dlconn->addr, addrstr, sizeof (addrstr))) 
     131    { 
     132      dlconn->pktid   = spktid; 
     133      dlconn->pkttime = spkttime; 
     134 
     135      found = 1; 
     136      break; 
     137    } 
     138 
     139    count++; 
     140  } 
     141 
     142  if (!found) 
     143  { 
     144    dl_log_r (dlconn, 1, 0, "Server address not found in state file: %s\n", dlconn->addr); 
     145  } 
     146 
     147  if (close (statefd)) 
     148  { 
     149    dl_log_r (dlconn, 2, 0, "could not close state file, %s\n", strerror (errno)); 
     150    return -1; 
     151  } 
    154152 
    155153  return 0; 
  • trunk/src/libsrc/libdali/strutils.c

    r5978 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file strutils.c 
    33 * 
     
    99 ***************************************************************************/ 
    1010 
     11#include <errno.h> 
    1112#include <stdio.h> 
    1213#include <stdlib.h> 
    1314#include <string.h> 
    14 #include <errno.h> 
    1515#include <sys/stat.h> 
    1616#include <sys/types.h> 
     
    1818#include "libdali.h" 
    1919 
    20  
    21 /***********************************************************************//** 
     20/***********************************************************************/ /** 
    2221 * @brief Parse/split a string on a specified delimiter 
    2322 * 
     
    4241dl_strparse (const char *string, const char *delim, DLstrlist **list) 
    4342{ 
    44   const char *beg;                      /* beginning of element */ 
    45   const char *del;                      /* delimiter */ 
    46   int stop = 0; 
     43  const char *beg; /* beginning of element */ 
     44  const char *del; /* delimiter */ 
     45  int stop  = 0; 
    4746  int count = 0; 
    4847  int total; 
     
    5251 
    5352  if (string != NULL && delim != NULL) 
     53  { 
     54    total = strlen (string); 
     55    beg   = string; 
     56 
     57    while (!stop) 
    5458    { 
    55       total = strlen (string); 
    56       beg = string; 
    57  
    58       while (!stop) 
    59         { 
    60  
    61           /* Find delimiter */ 
    62           del = strstr (beg, delim); 
    63  
    64           /* Delimiter not found or empty */ 
    65           if (del == NULL || strlen (delim) == 0) 
    66             { 
    67               del = string + strlen (string); 
    68               stop = 1; 
    69             } 
    70  
    71           tmplist = (DLstrlist *) malloc (sizeof (DLstrlist)); 
    72           tmplist->next = 0; 
    73  
    74           tmplist->element = (char *) malloc (del - beg + 1); 
    75           strncpy (tmplist->element, beg, (del - beg)); 
    76           tmplist->element[(del - beg)] = '\0'; 
    77  
    78           /* Add this to the list */ 
    79           if (count++ == 0) 
    80             { 
    81               curlist = tmplist; 
    82               *list = curlist; 
    83             } 
    84           else 
    85             { 
    86               curlist->next = tmplist; 
    87               curlist = curlist->next; 
    88             } 
    89  
    90           /* Update 'beg' */ 
    91           beg = (del + strlen (delim)); 
    92           if ((beg - string) > total) 
    93             break; 
    94         } 
    95  
    96       return count; 
     59 
     60      /* Find delimiter */ 
     61      del = strstr (beg, delim); 
     62 
     63      /* Delimiter not found or empty */ 
     64      if (del == NULL || strlen (delim) == 0) 
     65      { 
     66        del  = string + strlen (string); 
     67        stop = 1; 
     68      } 
     69 
     70      tmplist       = (DLstrlist *)malloc (sizeof (DLstrlist)); 
     71      tmplist->next = 0; 
     72 
     73      tmplist->element = (char *)malloc (del - beg + 1); 
     74      strncpy (tmplist->element, beg, (del - beg)); 
     75      tmplist->element[(del - beg)] = '\0'; 
     76 
     77      /* Add this to the list */ 
     78      if (count++ == 0) 
     79      { 
     80        curlist = tmplist; 
     81        *list   = curlist; 
     82      } 
     83      else 
     84      { 
     85        curlist->next = tmplist; 
     86        curlist       = curlist->next; 
     87      } 
     88 
     89      /* Update 'beg' */ 
     90      beg = (del + strlen (delim)); 
     91      if ((beg - string) > total) 
     92        break; 
    9793    } 
     94 
     95    return count; 
     96  } 
    9897  else 
     98  { 
     99    curlist = *list; 
     100    while (curlist != NULL) 
    99101    { 
    100       curlist = *list; 
    101       while (curlist != NULL) 
    102         { 
    103           tmplist = curlist->next; 
    104           free (curlist->element); 
    105           free (curlist); 
    106           curlist = tmplist; 
    107         } 
    108       *list = NULL; 
    109  
    110       return 0; 
     102      tmplist = curlist->next; 
     103      free (curlist->element); 
     104      free (curlist); 
     105      curlist = tmplist; 
    111106    } 
    112 }  /* End of dl_strparse() */ 
    113  
    114  
    115 /***********************************************************************//** 
     107    *list = NULL; 
     108 
     109    return 0; 
     110  } 
     111} /* End of dl_strparse() */ 
     112 
     113/***********************************************************************/ /** 
    116114 * @brief Copy a string while removing space charaters 
    117115 * 
     
    122120 * for the non-space characters within @a length and the null 
    123121 * terminator. 
    124  *  
     122 * 
    125123 * @param dest Destination string 
    126124 * @param source String to copy 
     
    135133  int sidx, didx; 
    136134 
    137   for ( sidx=0, didx=0; sidx < length ; sidx++ ) 
     135  for (sidx = 0, didx = 0; sidx < length; sidx++) 
     136  { 
     137    if (*(source + sidx) != ' ') 
    138138    { 
    139       if ( *(source+sidx) != ' ' ) 
    140         { 
    141           *(dest+didx) = *(source+sidx); 
    142           didx++; 
    143         } 
     139      *(dest + didx) = *(source + sidx); 
     140      didx++; 
    144141    } 
    145  
    146   *(dest+didx) = '\0'; 
     142  } 
     143 
     144  *(dest + didx) = '\0'; 
    147145 
    148146  return didx; 
    149 }  /* End of dl_strncpclean() */ 
    150  
    151  
    152 /***********************************************************************//** 
     147} /* End of dl_strncpclean() */ 
     148 
     149/***********************************************************************/ /** 
    153150 * @brief Concatinate one string to another growing the destination as needed 
    154151 * 
    155152 * Concatinate one string to another with a delimiter in-between 
    156153 * growing the destination string as needed up to a maximum length. 
    157  *  
     154 * 
    158155 * @param string Destination string to be added to 
    159156 * @param add String to add to @a string 
     
    169166  int length; 
    170167  char *ptr; 
    171    
    172   if ( ! string || ! add ) 
     168 
     169  if (!string || !add) 
    173170    return -1; 
    174    
     171 
    175172  /* If string is empty, allocate space and copy the addition */ 
    176   if ( ! *string ) 
    177     { 
    178       length = strlen (add) + 1; 
    179        
    180       if ( length > maxlen ) 
    181         return -2; 
    182        
    183       if ( (*string = (char *) malloc (length)) == NULL ) 
    184         return -1; 
    185        
    186       strcpy (*string, add); 
    187     } 
     173  if (!*string) 
     174  { 
     175    length = strlen (add) + 1; 
     176 
     177    if (length > maxlen) 
     178      return -2; 
     179 
     180    if ((*string = (char *)malloc (length)) == NULL) 
     181      return -1; 
     182 
     183    strcpy (*string, add); 
     184  } 
    188185  /* Otherwise tack on the addition with a delimiter */ 
    189186  else 
    190     { 
    191       length = strlen (*string) + strlen (delim) + strlen(add) + 1; 
    192        
    193       if ( length > maxlen ) 
    194         return -2; 
    195        
    196       if ( (ptr = (char *) realloc (*string, length)) == NULL ) 
    197         return -1; 
    198        
    199       *string = ptr; 
    200        
    201       strcat (*string, delim); 
    202       strcat (*string, add); 
    203     } 
    204    
     187  { 
     188    length = strlen (*string) + strlen (delim) + strlen (add) + 1; 
     189 
     190    if (length > maxlen) 
     191      return -2; 
     192 
     193    if ((ptr = (char *)realloc (*string, length)) == NULL) 
     194      return -1; 
     195 
     196    *string = ptr; 
     197 
     198    strcat (*string, delim); 
     199    strcat (*string, add); 
     200  } 
     201 
    205202  return 0; 
    206 }  /* End of dl_addtostring() */ 
     203} /* End of dl_addtostring() */ 
  • trunk/src/libsrc/libdali/timeutils.c

    r5978 r6842  
    1 /***********************************************************************//** 
     1/***********************************************************************/ /** 
    22 * @file timeutils.c 
    33 * 
     
    1818 
    1919static dltime_t dl_time2dltime_int (int year, int day, int hour, 
    20                                     int min, int sec, int usec); 
     20                                    int min, int sec, int usec); 
    2121 
    2222static struct tm *dl_gmtime_r (int64_t *timep, struct tm *result); 
    2323 
    24  
    25 /***********************************************************************//** 
     24/***********************************************************************/ /** 
    2625 * @brief Compute the month and day-of-month from day-of-year 
    2726 * 
     
    4544  int leap; 
    4645  int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 
    47    
     46 
    4847  /* Sanity check for the supplied year */ 
    49   if ( year < 1900 || year > 2100 ) 
     48  if (year < 1900 || year > 2100) 
     49  { 
     50    dl_log (2, 0, "dl_doy2md(): year (%d) is out of range\n", year); 
     51    return -1; 
     52  } 
     53 
     54  /* Test for leap year */ 
     55  leap = (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) ? 1 : 0; 
     56 
     57  /* Add a day to February if leap year */ 
     58  if (leap) 
     59    days[1]++; 
     60 
     61  if (jday > 365 + leap || jday <= 0) 
     62  { 
     63    dl_log (2, 0, "dl_doy2md(): day-of-year (%d) is out of range\n", jday); 
     64    return -1; 
     65  } 
     66 
     67  for (idx = 0; idx < 12; idx++) 
     68  { 
     69    jday -= days[idx]; 
     70 
     71    if (jday <= 0) 
    5072    { 
    51       dl_log (2, 0, "dl_doy2md(): year (%d) is out of range\n", year); 
    52       return -1; 
     73      *month = idx + 1; 
     74      *mday  = days[idx] + jday; 
     75      break; 
    5376    } 
    54 <