Changeset 7606


Ignore:
Timestamp:
11/26/18 12:47:34 (2 years ago)
Author:
alexander
Message:

Committing changes to trunk

Location:
trunk
Files:
97 edited
49 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/include/socket_ew.h

    r7477 r7606  
    5252 
    5353#ifdef _WINNT 
    54 # include <windows.h> 
    55 # include <ws2tcpip.h>                  /* typedef fd_set */ 
     54#include <winsock2.h> 
     55#ifdef WIN32_LEAN_AND_MEAN 
     56#undef WIN32_LEAN_AND_MEAN 
     57#endif 
     58#define _WINSOCKAPI_ 
     59#include <windows.h> 
     60#include <ws2tcpip.h>                   /* typedef fd_set */ 
    5661# define WOULDBLOCK_EW WSAEWOULDBLOCK 
    5762# define CONNECT_WOULDBLOCK_EW WSAEWOULDBLOCK 
     
    120125/* Socket based function prototypes                           */ 
    121126/**************************************************************/ 
     127SOCKET setuptcpclient_ew(const char *host, const char *service, int timeout_msec); 
     128  /* setuptcpclient_ew() checks the supplied parameters and  
     129     determines whether it is appropriate to resolve host and 
     130     service as IPv4 or IPv6 
     131     The function takes care of the initial socket() call, and proceeds to call 
     132     connect_ew() with the appropriate timeout parameter for nonblocking sockets 
     133     calls, returning a valid SOCKET if succesful, and -1 if not 
     134  */ 
     135 
     136SOCKET setuptcpserver_ew(const char *host, const char *service, int backlog); 
     137  /* setuptcpserver_ew() checks the supplied parameters and determines 
     138     whether it is appropriate to resolve host and service as IPv4 or IPv6. 
     139     The function takes care of the initial socket() call, and proceeds to call 
     140     bind__ew() and listen_ew() (passing the 'backlog' parameter to listen_ew()) 
     141     The function returns a valid SOCKET if successful, and  
     142     -3 if address resolution fails 
     143     -2 setsockopt() fails 
     144     and -1 if otherwise unable to establish a server socket 
     145   */ 
     146 
     147int numeric_address_to_string_ew(int isIPv6, uint8_t inAddr[16], uint8_t inPort[2], 
     148                                 char hostString[64], char portString[10]); 
     149  /* numeric_address_to_string_ew() converts numeric arrays inAddr and inPort 
     150     to human-readable strings 
     151   */ 
     152 
     153int formatsocketaddress_ew(const struct sockaddr *address, int addrLen,  
     154                             char hostString[64], char portString[10]); 
     155  /* formatsocketaddress_ew() accepts a (typically client) connection specified as  
     156     'address' 
     157    
     158      and returns hostString, portString, providing a human-readable representation 
     159      of the connection 'address' 
     160   */ 
    122161 
    123162SOCKET accept_ew (SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen, 
     
    303342 
    304343Time_ew GetTime_ew(); 
    305  
    306 #endif /* SOCKET_EW_H : don't include file if already included*/ 
     344/*************************************************************/ 
     345/* Network utility prototypes                                */ 
     346/*************************************************************/ 
     347int numeric_address_to_string_ew(int isIPv6, uint8_t inAddr[16],  
     348                uint8_t inPort[2], char hostStr[64], char portStr[10]); 
     349/* numeric_address_to_string_ew() converts numeric arrays inAddr, inPort  
     350   into strings hostStr, portStr 
     351 */ 
     352 
     353char ip_in_same_subnet(const char *ip1, const char *ip2, char *netmask); 
     354/* Determines if ip1 and ip2 belong to the same subnet 
     355   If IPs are IPv4, uses netmask to determine which subnet 
     356   If IPs are IPv6, compares first 64 bits of each address 
     357    
     358   returns 1 if ips are in same subnet, or 0 if not OR 
     359   if processing failed (eg, due to mixed use of address families) 
     360 */ 
     361 
     362#endif  
     363/* SOCKET_EW_H : don't include file if already included*/ 
  • trunk/include/ws_clientII.h

    r6803 r7606  
    4444#include <platform.h> 
    4545#include <trace_buf.h> 
     46#include <socket_ew.h> 
    4647 
    4748/* Return codes used by routines in ws_client.c 
     
    104105TRACE_REQ; 
    105106 
    106 #define wsADRLEN    16    /* length for ip and port adrress strings */ 
     107#define wsADRLEN    64    /* length for ip and port adrress strings */ 
    107108#define wsREQLEN   1024    /* length for MENU request */ 
    108109#define wsREPLEN  2000000   /* increased to 2Megs to allow HUGE menu requests */ 
  • trunk/include/ws_clientII_no_location.h

    r6803 r7606  
    8888TRACE_REQ; 
    8989 
    90 #define wsADRLEN    16    /* length for ip and port adrress strings */ 
     90#define wsADRLEN    64    /* length for ip and port adrress strings */ 
    9191#define wsREQLEN   256    /* length for MENU request */ 
    9292#define wsREPLEN  20480   /* length for reply to MENU request(up to 256 SCNs) */ 
  • trunk/include/ws_clientIIx.h

    r6803 r7606  
    116116 
    117117/* string buffer lengths */ 
    118 #define wsADRLEN    16    /* length for ip and port adrress strings */ 
     118#define wsADRLEN    64    /* length for ip and port adrress strings */ 
    119119#define wsREQLEN   256    /* length for MENU request */ 
    120120#define wsREPLEN  20480   /* length for reply to MENU request(up to 256 SCNLs) */ 
  • trunk/src

  • trunk/src/archiving/ew2mseed/ew2mseed_log.c

    r7220 r7606  
    126126          logit("", "           SocketReconnect   = %d s\n", rn->TimeoutSeconds); /* IGD 03/15/01 updated */ 
    127127          logit("", "           Travel Tm-out     = %d s\n", rn->TravelTimeout);   
    128           logit("", "           Start Time (s)    = %f\n", rn->julStartTime); 
     128          logit("", "           Start Time (s)    = %lf\n", rn->julStartTime); 
    129129          logit("", "           LockFile          = %s\n", ((rn->LockFile == NULL) ? "NULL" : rn->LockFile)); 
    130130          logit("", "           UsePriority       = %s\n",  ((rn->usePriority == 0) ? "NO" : "YES")); 
  • trunk/src/archiving/ew2mseed/ws_requests.c

    r7220 r7606  
    870870        { 
    871871                logit("pt",  
    872                  "wsGetTraceBin() returned %d, sample rate = %f; setting retVal to WS_ERR_BROKEN_CONNECTION\n", 
     872                 "wsGetTraceBin() returned %d, sample rate = %lf; setting retVal to WS_ERR_BROKEN_CONNECTION\n", 
    873873                        retVal, currentSampleRate); 
    874874                p_trace->reqStarttime += 30;    /* IGD 04/04/02 Skip 30 secs from danger */ 
  • trunk/src/archiving/nq2wws/nq2wws.c

    r7475 r7606  
    127127static int     LogSwitch;              /* 0 if no logfile should be written */ 
    128128static int     HeartBeatInt;           /* seconds between heartbeats        */ 
    129 static char    ServerIPAdr[16];        /* server's IP address               */ 
    130 static int     ServerPort;             /* Server's well-known port number   */ 
     129static char    ServerIPAdr[64];        /* server's IP address               */ 
     130static char    ServerPort[16];             /* Server's well-known port number   */ 
    131131static long    MaxMsgSize;             /* max size for input/output msgs    */ 
    132132static int     RingSize;               /* max messages in output circular buffer */ 
     
    183183{ 
    184184        /* Socket variables: */ 
    185         int    on = 1; 
    186185        int    clientLen; 
    187         char   client_ip[16];        /* IP address of client from inet_ntoa   */ 
    188         struct sockaddr_in  skt; 
    189         struct sockaddr_in client; 
     186        char   client_ip[64];        /* IP address of client from inet_ntoa   */ 
     187   char   client_port[10]; 
     188        struct sockaddr_storage client; 
    190189 
    191190        /* Other variables: */ 
     
    344343        SocketSysInit(); 
    345344 
    346         if ( ( PassiveSocket = socket_ew( PF_INET, SOCK_STREAM, 0) ) == -1 ) { 
    347                 logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
     345   PassiveSocket = setuptcpserver_ew(ServerIPAdr, ServerPort, 0); 
     346 
     347        if ( PassiveSocket < 0 ) { 
     348                logit( "et", "%s(%s): Error setting up TCP server socket; exiting!\n", Argv0, MyModName ); 
    348349                tport_detach( &Region ); 
    349350                return( -1 ); 
    350351        } 
    351352        SockStatus = SOCK_NEW; 
    352  
    353         /* Fill in server's socket address structure 
    354         ********************************************/ 
    355         memset( (char *) &skt, '\0', sizeof(skt) ); 
    356         skt.sin_family = AF_INET; 
    357         skt.sin_port   = htons( (short)ServerPort ); 
    358 #if defined(_LINUX) || defined(_MACOSX) 
    359         if ((int)(skt.sin_addr.s_addr = inet_addr(ServerIPAdr)) == -1) 
    360 #else 
    361         if ((int)(skt.sin_addr.S_un.S_addr = inet_addr(ServerIPAdr)) == -1) 
    362 #endif 
    363         { 
    364                 logit( "e", "%s(%s): inet_addr failed for ServerIPAdr <%s>;" 
    365                         " exiting!\n", Argv0, MyModName, ServerIPAdr ); 
    366                 return( -1 ); 
    367         } 
    368  
    369         /* Allows the server to be stopped and restarted 
    370         ************************************************/ 
    371         on=1; 
    372         if( setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, 
    373                 (char *)&on, sizeof(char *) ) != 0 ) 
    374         { 
    375                 logit( "et", "%s(%s): Error on setsockopt; exiting!\n", 
    376                         Argv0, MyModName ); 
    377                 perror("Export setsockopt"); 
    378                 tport_detach( &Region ); 
    379                 return( -1 ); 
    380         } 
    381  
    382         /* Bind socket to a name 
    383         ************************/ 
    384         if ( bind_ew( PassiveSocket, (struct sockaddr *) &skt, sizeof(skt)) ) 
    385         { 
    386                 logit("et", "%s(%s): error binding socket; exiting.\n", 
    387             Argv0, MyModName); 
    388                 perror("Export bind error"); 
    389                 closesocket_ew(PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW); 
    390                 tport_detach( &Region ); 
    391                 return( -1 ); 
    392         } 
    393  
    394         /* Prepare for connect requests 
    395         *******************************/ 
    396         if ( listen_ew( PassiveSocket, 0)) 
    397         { 
    398                 logit("et", "%s(%s): socket listen error; exiting!\n", 
    399                         Argv0, MyModName ); 
    400                 closesocket_ew( PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW ); 
    401                 tport_detach( &Region ); 
    402                 return( 1 ); 
    403         } 
    404353 
    405354        /* One heartbeat to announce ourselves to statmgr 
     
    445394        } 
    446395 
    447         strcpy( client_ip, inet_ntoa(client.sin_addr) ); 
     396   formatsocketaddress_ew((struct sockaddr *) &client, clientLen, client_ip, client_port); 
    448397        LiveConnection = 1; /*970623:ldd*/ 
    449398        if (SockStatus == SOCK_NOT_CONN) 
     
    15231472                                                exit( -1 ); 
    15241473                                        } 
    1525                                         strcpy( ServerIPAdr, str ); 
     1474                                        strncpy( ServerIPAdr, str, sizeof( ServerIPAdr ) ); 
    15261475                                } 
    15271476                                init[5] = 1; 
     
    15321481/*6*/      
    15331482                        else if( k_its("ServerPort") ) { 
    1534                                 ServerPort = k_int(); 
    1535                                 init[6] = 1; 
     1483            if((str = k_str()) != NULL) { 
     1484                                      strncpy( ServerPort, str, sizeof( ServerPort )); 
     1485                  init[6] = 1; 
     1486               } 
    15361487            } 
    15371488 
  • trunk/src/archiving/nq2wws/nq2wws_ack.c

    r7475 r7606  
    180180{ 
    181181        /* Socket variables: */ 
    182         int    on = 1; 
    183182        int    clientLen; 
    184         char   client_ip[16];        /* IP address of client from inet_ntoa   */ 
    185         struct sockaddr_in  skt; 
    186         struct sockaddr_in client; 
     183        char   client_ip[64];        /* IP address of client from inet_ntoa   */ 
     184   char   client_port[10]; 
     185        struct sockaddr_storage client; 
    187186 
    188187        /* Other variables: */ 
     
    347346        SocketSysInit(); 
    348347 
    349         if ( ( PassiveSocket = socket_ew( PF_INET, SOCK_STREAM, 0) ) == -1 ) { 
    350                 logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
     348   PassiveSocket = setuptcpserver_ew(ServerIPAdr, ServerPort, 0); 
     349 
     350        if ( PassiveSocket < 0 ) { 
     351                logit( "et", "%s(%s): Error setting up TCP server socket; exiting!\n", Argv0, MyModName ); 
    351352                tport_detach( &Region ); 
    352353                return( -1 ); 
    353354        } 
    354355        SockStatus = SOCK_NEW; 
    355  
    356         /* Fill in server's socket address structure 
    357         ********************************************/ 
    358         memset( (char *) &skt, '\0', sizeof(skt) ); 
    359         skt.sin_family = AF_INET; 
    360         skt.sin_port   = htons( (short)ServerPort ); 
    361 #if defined(_LINUX) || defined(_MACOSX) 
    362         if ((int)(skt.sin_addr.s_addr = inet_addr(ServerIPAdr)) == -1) 
    363 #else 
    364         if ((int)(skt.sin_addr.S_un.S_addr = inet_addr(ServerIPAdr)) == -1) 
    365 #endif 
    366         { 
    367                 logit( "e", "%s(%s): inet_addr failed for ServerIPAdr <%s>;" 
    368                         " exiting!\n", Argv0, MyModName, ServerIPAdr ); 
    369                 return( -1 ); 
    370         } 
    371  
    372         /* Allows the server to be stopped and restarted 
    373         ************************************************/ 
    374         on=1; 
    375         if( setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, 
    376                 (char *)&on, sizeof(char *) ) != 0 ) 
    377         { 
    378                 logit( "et", "%s(%s): Error on setsockopt; exiting!\n", 
    379                         Argv0, MyModName ); 
    380                 perror("Export setsockopt"); 
    381                 tport_detach( &Region ); 
    382                 return( -1 ); 
    383         } 
    384  
    385         /* Bind socket to a name 
    386         ************************/ 
    387         if ( bind_ew( PassiveSocket, (struct sockaddr *) &skt, sizeof(skt)) ) 
    388         { 
    389                 logit("et", "%s(%s): error binding socket; exiting.\n", 
    390             Argv0, MyModName); 
    391                 perror("Export bind error"); 
    392                 closesocket_ew(PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW); 
    393                 tport_detach( &Region ); 
    394                 return( -1 ); 
    395         } 
    396  
    397         /* Prepare for connect requests 
    398         *******************************/ 
    399         if ( listen_ew( PassiveSocket, 0)) 
    400         { 
    401                 logit("et", "%s(%s): socket listen error; exiting!\n", 
    402                         Argv0, MyModName ); 
    403                 closesocket_ew( PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW ); 
    404                 tport_detach( &Region ); 
    405                 return( 1 ); 
    406         } 
    407356 
    408357        /* One heartbeat to announce ourselves to statmgr 
     
    448397        } 
    449398 
    450         strcpy( client_ip, inet_ntoa(client.sin_addr) ); 
     399   formatsocketaddress_ew((struct sockaddr *) &client, clientLen, client_ip, client_port); 
    451400        LiveConnection = 1; /*970623:ldd*/ 
    452401        if (SockStatus == SOCK_NOT_CONN) 
  • trunk/src/archiving/nq2wws_ack/nq2wws_ack.c

    r7475 r7606  
    227227        int    on = 1; 
    228228        int    clientLen; 
    229         char   client_ip[16];    /* IP address of client from inet_ntoa   */ 
    230         struct sockaddr_in  skt; 
    231         struct sockaddr_in  client; 
     229        char   client_ip[64];    /* IP address of client from inet_ntoa   */ 
     230   char   client_port[10]; 
     231        struct sockaddr_storage  client; 
    232232 
    233233/* Other variables: */ 
     
    412412   SocketSysInit(); 
    413413 
    414    if( ( PassiveSocket = socket_ew( PF_INET, SOCK_STREAM, 0) ) == -1 ) 
    415    { 
    416       logit( "et", "%s Error opening socket; exiting!\n", whoami ); 
     414   if( ( PassiveSocket = setuptcpserver_ew(ServerIPAdr, ServerPort, 0) ) < 0) 
     415   { 
     416      logit( "et", "%s Error setting up TCP server socket; exiting!\n", whoami ); 
    417417      tport_detach( &Region ); 
    418418      return( -1 ); 
    419419   } 
    420420   SocketStatus = SOCK_NEW; 
    421  
    422 /* Fill in server's socket address structure 
    423  ********************************************/ 
    424    memset( (char *) &skt, '\0', sizeof(skt) ); 
    425    skt.sin_family = AF_INET; 
    426    skt.sin_port   = htons( (short)ServerPort ); 
    427 #if defined(_LINUX) || defined(_MACOSX) 
    428    if ((int)(skt.sin_addr.s_addr = inet_addr(ServerIPAdr)) == -1) 
    429 #else 
    430    if ((int)(skt.sin_addr.S_un.S_addr = inet_addr(ServerIPAdr)) == -1) 
    431 #endif 
    432    { 
    433       logit( "e", "%s inet_addr failed for ServerIPAdr <%s>;" 
    434             " exiting!\n", whoami, ServerIPAdr ); 
    435       return( -1 ); 
    436    } 
    437  
    438 /* Allows the server to be stopped and restarted 
    439  ************************************************/ 
    440    on=1; 
    441    if( setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, 
    442                   (char *)&on, sizeof(char *) ) != 0 ) 
    443    { 
    444       logit( "et", "%s Error on setsockopt; exiting!\n", whoami ); 
    445       perror("Export setsockopt"); 
    446       export_shutdown( -1 ); 
    447    } 
    448  
    449 /* Bind socket to a name 
    450  ************************/ 
    451    if ( bind_ew( PassiveSocket, (struct sockaddr *) &skt, sizeof(skt)) ) 
    452    { 
    453       logit("et", "%s error binding socket; exiting.\n", whoami ); 
    454       perror("Export bind error"); 
    455       export_shutdown( -1 ); 
    456    } 
    457  
    458 /* Prepare for connect requests 
    459  *******************************/ 
    460    if( listen_ew( PassiveSocket, 0 ) ) 
    461    { 
    462       logit("et", "%s socket listen error; exiting!\n", whoami ); 
    463       export_shutdown( 1 ); 
    464    } 
    465421 
    466422/* Accept a connection (blocking) 
     
    499455   } 
    500456 
    501    strcpy( client_ip, inet_ntoa(client.sin_addr) ); 
     457   formatsocketaddress_ew((struct sockaddr *) &client, clientLen, client_ip, client_port); 
    502458        LiveConnection = 1; /*970623:ldd*/ 
    503459   if( SocketStatus == SOCK_NOT_CONN ) 
  • trunk/src/archiving/wave_serverV/serve_trace.c

    r7476 r7606  
    654654        { 
    655655             logit("t","Found gap, or too young at curr=%d, setting offset %ld\n", 
    656                         curr,pCurr->offset); 
     656                                                                                                                                curr,pCurr->offset); 
    657657             logit("t","Curr-Start %f,Curr->End %f,reqTime %f!\n", 
    658658                        pCurr->tStart,pCurr->tEnd,reqTime); 
  • trunk/src/archiving/wave_serverV/wave_serverV.c

    r7501 r7606  
    497497static int     TraceBufIsValid( TANK *, TRACE2_HEADER * ); 
    498498 
    499 #define IPADDRLEN 20 
     499#define IPADDRLEN 64 
    500500#define MAX_PATH_LEN 255 
    501501 
     
    504504SOCKET         PassiveSocket;     /* Socket descriptor; passive socket     */ 
    505505static char    ServerIPAdr[IPADDRLEN];  /* IP address of wave_server machine */ 
    506 static int     ServerPort;        /* Server port for requests & replies    */ 
     506static char    ServerPort[16];        /* Server port for requests & replies    */ 
    507507 
    508508/* Pointers to things and actual allocations 
     
    670670#define PACKET_CHECK_FLOOR 100                  /* allow adjustment to Heartbeat check down to this number of packets */ 
    671671 
    672 #define WSV_VERSION "5.1.45 - 2014-03-31" 
     672//5.2.0 - IPv6 functionality added 
     673#define WSV_VERSION "5.2.0 - 2018-03-15" 
    673674 
    674675int main( int argc, char **argv ) 
     
    15641565thr_ret ServerMgr( void *dummy ) 
    15651566{ 
    1566   int                  on = 1; 
    15671567  int                  clientLen; 
    15681568#ifdef TO_BE_USED_IN_FUTURE 
    15691569  char                 sysname[40];                    /* system name; filled by getsysname_ew  */ 
    15701570#endif 
    1571   struct sockaddr_in   skt; 
    1572   struct sockaddr_in * client; 
     1571  struct sockaddr_storage * client; 
    15731572  int                  freeThrd; 
    15741573  int                  i; 
    1575  
    1576  
     1574  char                 clientPort[10];             /* need this for formatsocketaddress_ew()  */ 
    15771575 
    15781576#define ACCEPTABLE_TIME_TO_WAIT_FOR_SERVER_THREAD_TO_START 15 
     
    15981596 
    15991597  /*ActiveSocket=(SOCKET *) malloc(MaxServerThreads * sizeof(int));*/ 
    1600   client_ip=malloc(MaxServerThreads * sizeof(char)* 16); 
    1601   client=(struct sockaddr_in *)malloc(MaxServerThreads * sizeof(struct sockaddr_in)); 
     1598  client_ip=malloc(MaxServerThreads * sizeof(char)* INET6_ADDRSTRLEN); 
     1599  client=(struct sockaddr_storage *)malloc(MaxServerThreads * sizeof(struct sockaddr_storage)); 
    16021600 
    16031601  /* End of malloc and initialization. 
     
    16381636 
    16391637#endif 
    1640  
    1641   if ( ( PassiveSocket = socket_ew( PF_INET, SOCK_STREAM, 0) ) == -1 ) 
    1642   { 
    1643     logit( "et", "wave_serverV: Error opening socket. Exiting.\n" ); 
     1638   PassiveSocket = setuptcpserver_ew(ServerIPAdr, ServerPort, MaxServerThreads); 
     1639    
     1640  if ( PassiveSocket == -1 ) 
     1641  { 
     1642    logit( "et", "wave_serverV: Error during TCP server setup. Exiting.\n" ); 
    16441643    exit(-1); 
    16451644  } 
    16461645 
    1647   /* Fill in server's socket address structure 
    1648    *******************************************/ 
    1649   memset( (char *) &skt, '\0', sizeof(skt) ); 
    1650   /* 2003.04.14 dbh -- formerly used memcpy to set skt.sin_addr from gethostbyaddr() result */ 
    1651  
    1652 #if defined(_LINUX) || defined(_MACOSX) 
    1653   /* the S_un substruct is not something linux knows about */ 
    1654   if ((int)(skt.sin_addr.s_addr = inet_addr(ServerIPAdr)) == INADDR_NONE) 
    1655 #else 
    1656   if ((int)(skt.sin_addr.S_un.S_addr = inet_addr(ServerIPAdr)) == INADDR_NONE) 
    1657 #endif 
    1658   { 
    1659       logit( "e", "wave_serverV: inet_addr failed for ServerIPAdr <%s>; exiting!\n",ServerIPAdr ); 
    1660       exit( -1 ); 
    1661   } 
    1662  
    1663   skt.sin_family = AF_INET; 
    1664   skt.sin_port   = htons( (short)ServerPort ); 
    1665  
    1666   /* Allows the server to be stopped and restarted 
    1667    *********************************************/ 
    1668   on=1; 
    1669   if(setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(char *) )!=0) 
    1670   { 
     1646  if( PassiveSocket == -2) 
     1647  { 
     1648    //setuptcpserver_ew() has already closed the socket 
    16711649    logit( "et", "wave_serverV: Error on setsockopt. Exiting.\n" ); 
    16721650    perror("Export_generic setsockopt"); 
    1673     closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW); 
    16741651    goto HeavyRestart; 
    1675   } 
    1676  
    1677   /* Bind socket to a name 
    1678    ************************/ 
    1679   if ( bind_ew( PassiveSocket, (struct sockaddr *) &skt, sizeof(skt)) ) 
    1680   { 
    1681     sprintf(Text,"wave_serverV: error binding socket; Exiting.\n"); 
    1682     perror("wave_serverV bind error"); 
    1683     logit("et","%s",Text ); 
    1684     closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW); 
    1685     exit (-1); 
    1686   } 
    1687   /* and start listening */ 
    1688   if ( listen_ew( PassiveSocket, MaxServerThreads) ) 
    1689   { 
    1690     logit("et","wave_serverV: socket listen error; exiting!\n" ); 
    1691     closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW); 
    1692     exit(-1); 
    16931652  } 
    16941653 
     
    17691728      goto HeavyRestart; 
    17701729    } 
    1771     strcpy( client_ip[freeThrd], inet_ntoa(client[freeThrd].sin_addr) ); 
     1730    formatsocketaddress_ew((struct sockaddr*) &client[freeThrd], clientLen, client_ip[freeThrd], clientPort); 
    17721731 
    17731732    logit( "t", "wave_serverV: Connection accepted from IP address %s\n", 
     
    21362095      /*3*/    else if( k_its( "ServerPort" ) ) 
    21372096      { 
    2138         ServerPort = k_int(); 
    2139         init[3] = 1; 
     2097         if( (str = k_str())) { 
     2098            strncpy( ServerPort, str, 16);  
     2099            init[3] = 1; 
     2100         } 
    21402101      } 
    21412102      /* Read the Internet address of wave_server machine 
     
    21482109          if (strlen(str) < IPADDRLEN) 
    21492110          { 
    2150             strcpy( ServerIPAdr, str ); 
     2111            strncpy( ServerIPAdr, str, IPADDRLEN ); 
    21512112            init[4] = 1; 
    21522113          } 
  • trunk/src/data_exchange/Makefile

    r7409 r7606  
    8282        import_generic \ 
    8383        import_pasv \ 
    84         liss \ 
    8584        makehbfile \ 
    8685        pdl2ew \ 
     
    9392        ewexport2ringserver \ 
    9493        slink2ew 
     94#       liss  
    9595 
    9696LINUX_MODULES=$(UNIX_MODULES) 
     
    112112        import_generic \ 
    113113        import_pasv \ 
    114         liss \ 
    115         liss2ew_scnl \ 
    116114        makehbfile \ 
    117115        pickwasher \ 
  • trunk/src/data_exchange/coaxtoring/receiver_nt.c

    r7080 r7606  
    3131#include <stdio.h> 
    3232#include <windows.h> 
     33#include <socket_ew.h> 
    3334 
    3435#include "earthworm.h" 
  • trunk/src/data_exchange/ew2ringserver/ew2ringserver.c

    r7475 r7606  
    3939 
    4040#define PACKAGE "ew2ringserver" 
    41 #define PROGRAM_VERSION "1.2 2013-10-12" 
     41#define PROGRAM_VERSION "2.0 2018-04-18" 
    4242 
    4343static thr_ret MessageStacker (void *); /* Read messages and add to queue */ 
  • trunk/src/data_exchange/export/export.c

    r7475 r7606  
    77*    Revision history: 
    88*     $Log$ 
     9*     Revision 2.0   2018/05/03 16:05:21  alexander 
     10*     Upgraded to IPv6 
     11* 
    912*     Revision 1.20  2007/03/28 15:26:44  paulf 
    1013*     minor MACOSX changes, mostly removing malloc.h since that should be defined in platform.h already 
     
    134137 
    135138/* Functions in this source file 
    136 *******************************/ 
     139 *******************************/ 
    137140void  export_config  ( char * ); 
    138141void  export_lookup  ( void ); 
     
    144147 
    145148/* Thread things 
    146 ***************/ 
     149 ***************/ 
    147150#if defined(_LINUX) 
    148151/* too small a stack size caused seg faulting on Linux OS, untested on Solaris+windows+MacOSX */ 
     
    154157static unsigned TidListener;         /* Thread listening for client heartbeats */ 
    155158static unsigned TidStacker;          /* Thread moving messages from transport */ 
    156                                                                          /*   to queue */ 
     159/*   to queue */ 
    157160 
    158161#define THREAD_OFF    0              /* thread has not been started      */ 
     
    161164 
    162165/* Thread flags 
    163 ***************/ 
     166 ***************/ 
    164167/* The xxStatus variables are for filing complaints */ 
    165168volatile int MessageStackerStatus =     THREAD_OFF; 
     
    174177 
    175178QUEUE OutQueue;                      /* from queue.h, queue.c; sets up linked    */ 
    176                                      /*    list via malloc and free              */ 
     179/*    list via malloc and free              */ 
    177180thr_ret SocketSender( void * ); 
    178181thr_ret SocketListener( void * ); 
    179182thr_ret MessageStacker( void * );    /* used to pass messages between main thread */ 
    180                                      /*   and SocketSender thread */ 
     183/*   and SocketSender thread */ 
    181184 
    182185/* Message Buffers to be allocated 
    183 *********************************/ 
     186 *********************************/ 
    184187static char *Rawmsg = NULL;          /* "raw" retrieved msg for main thread      */ 
    185188static char *SSmsg = NULL;           /* SocketSender's incoming message buffer   */ 
     
    190193static char *MSrawmsg = NULL;        /* MessageStacker's "raw" retrieved message */ 
    191194static char *MSfilteredmsg = NULL;   /* MessageStacker's "filtered" message to   */ 
    192                                      /*    be sent to client                     */ 
     195/*    be sent to client                     */ 
    193196 
    194197/* Heart beat stuff 
    195 *******************/ 
     198 *******************/ 
    196199time_t LastRcvAlive=0;     /* Last time we heard from our client */ 
    197200time_t LastSendAlive=0;    /* Last time we sent a heartbeat to our client */ 
     
    210213 
    211214/* Global socket things 
    212 **********************/ 
     215 **********************/ 
    213216SOCKET    PassiveSocket = 0;    /* Socket descriptor; passive socket     */ 
    214217SOCKET    ActiveSocket;         /* Socket descriptor; active socket      */ 
    215218 
    216219/* Things to read or derive from configuration file 
    217 **************************************************/ 
     220 **************************************************/ 
    218221static char    RingName[MAX_RING_STR]; /* name of transport ring for i/o    */ 
    219222static char    MyModName[MAX_MOD_STR]; /* speak as this module name/id      */ 
    220223static int     LogSwitch;              /* 0 if no logfile should be written */ 
    221224static int     HeartBeatInt;           /* seconds between heartbeats        */ 
    222 static char    ServerIPAdr[16];        /* server's IP address               */ 
    223 static int     ServerPort;             /* Server's well-known port number   */ 
     225static char    ServerIPAdr[64];        /* server's IP address               */ 
     226static char    ServerPort[16];             /* Server's well-known port number   */ 
    224227static long    MaxMsgSize;             /* max size for input/output msgs    */ 
    225228static int     RingSize;               /* max messages in output circular buffer */ 
     
    232235static int     SocketTimeoutLength=0;  /* Length of timeouts on SOCKET_ew calls */ 
    233236/*  Socket timeouts are not handled(well) in export, so there is not a whole lot 
    234 of point to setting SocketTimeoutLength to any useful value.  Currently 
    235 it is set to atleast the RcvAliveInt + a few seconds, so the main thread 
    236 always squashes the socket code after a timeout.  DavidK 2001/04/16 */ 
     237    of point to setting SocketTimeoutLength to any useful value.  Currently 
     238    it is set to atleast the RcvAliveInt + a few seconds, so the main thread 
     239    always squashes the socket code after a timeout.  DavidK 2001/04/16 */ 
    237240 
    238241static int     SOCKET_ewDebug=0;       /* Set to 1 for SOCKET_ew debug statements*/ 
    239242 
    240243/* Things to look up in the earthworm.h tables with getutil.c functions 
    241 **********************************************************************/ 
     244 **********************************************************************/ 
    242245static long          RingKey;       /* key of transport ring for i/o      */ 
    243246static unsigned char InstId;        /* local installation id              */ 
     
    247250 
    248251/* Error messages used by export 
    249 ********************************/ 
     252 ********************************/ 
    250253#define  ERR_MISSMSG       0   /* message missed in transport ring        */ 
    251254#define  ERR_TOOBIG        1   /* retreived msg too large for buffer      */ 
     
    259262 
    260263/* Socket status values 
    261 ***********************/ 
     264 ***********************/ 
    262265#define SOCK_NEW 0             /* New socket net yet connected           */ 
    263266#define SOCK_NOT_CONN 1        /* No connection after timeout            */ 
     
    266269 
    267270 
    268 #define EXP_VERSION "1.0.2 March 27, 2015" 
     271#define EXP_VERSION "2.0 2018.05.03" 
    269272int main( int argc, char **argv ) 
    270273{ 
    271         /* Socket variables: */ 
    272         int    on = 1; 
    273         int    clientLen; 
    274         char   client_ip[16];        /* IP address of client from inet_ntoa   */ 
    275         struct sockaddr_in  skt; 
    276         struct sockaddr_in  client; 
     274   /* Socket variables: */ 
     275   int    clientLen; 
     276   char   client_ip[64];        /* IP address of client from inet_ntoa   */ 
     277   char   client_port[10]; 
     278        struct sockaddr_storage  client; 
    277279 
    278280        /* Other variables: */ 
     
    463465        *******************************/ 
    464466        SocketSysInit(); 
    465  
    466         if ( ( PassiveSocket = socket_ew( PF_INET, SOCK_STREAM, 0) ) == -1 ) 
    467         { 
    468                 logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
     467    
     468   PassiveSocket = setuptcpserver_ew(ServerIPAdr, ServerPort, 0); 
     469 
     470        if ( PassiveSocket < 0 ) 
     471        { 
     472                logit( "et", "%s(%s): Error setting up TCP server connection; exiting!\n", Argv0, MyModName ); 
    469473                tport_detach( &Region ); 
    470474                return( -1 ); 
    471         } 
    472         SockStatus = SOCK_NEW; 
    473  
    474         /* Fill in server's socket address structure 
    475         ********************************************/ 
    476         memset( (char *) &skt, '\0', sizeof(skt) ); 
    477         skt.sin_family = AF_INET; 
    478         skt.sin_port   = htons( (short)ServerPort ); 
    479 #if defined(_LINUX) || defined(_MACOSX) 
    480         if ((int)(skt.sin_addr.s_addr = inet_addr(ServerIPAdr)) == -1) 
    481 #else 
    482         if ((int)(skt.sin_addr.S_un.S_addr = inet_addr(ServerIPAdr)) == -1) 
    483 #endif 
    484         { 
    485                 logit( "e", "%s(%s): inet_addr failed for ServerIPAdr <%s>;" 
    486                         " exiting!\n", Argv0, MyModName, ServerIPAdr ); 
    487                 return( -1 ); 
    488         } 
    489  
    490         /* Allows the server to be stopped and restarted 
    491         ************************************************/ 
    492         on=1; 
    493         if( setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, 
    494                 (char *)&on, sizeof(char *) ) != 0 ) 
    495         { 
    496                 logit( "et", "%s(%s): Error on setsockopt; exiting!\n", 
    497                         Argv0, MyModName ); 
    498                 perror("Export setsockopt"); 
    499                 tport_detach( &Region ); 
    500                 return( -1 ); 
    501         } 
    502  
    503         /* Bind socket to a name 
    504         ************************/ 
    505         if ( bind_ew( PassiveSocket, (struct sockaddr *) &skt, sizeof(skt)) ) 
    506         { 
    507                 logit("et", "%s(%s): error binding socket; exiting.\n", 
    508             Argv0, MyModName); 
    509                 perror("Export bind error"); 
    510                 closesocket_ew(PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW); 
    511                 tport_detach( &Region ); 
    512                 return( -1 ); 
    513         } 
    514  
    515         /* Prepare for connect requests 
    516         *******************************/ 
    517         if ( listen_ew( PassiveSocket, 0)) 
    518         { 
    519                 logit("et", "%s(%s): socket listen error; exiting!\n", 
    520                         Argv0, MyModName ); 
    521                 closesocket_ew( PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW ); 
    522                 tport_detach( &Region ); 
    523                 return( 1 ); 
    524475        } 
    525476 
     
    569520        closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW); 
    570521 
    571         strcpy( client_ip, inet_ntoa(client.sin_addr) ); 
     522   formatsocketaddress_ew((struct sockaddr *) &client, clientLen, client_ip, client_port); 
    572523        LiveConnection = 1; /*970623:ldd*/ 
    573524        if (SockStatus == SOCK_NOT_CONN) 
     
    14151366                                        exit( -1 ); 
    14161367                                } 
    1417                                 strcpy( ServerIPAdr, str ); 
     1368                                strncpy( ServerIPAdr, str, sizeof( ServerIPAdr) ); 
    14181369                        } 
    14191370                        init[5] = 1; 
     
    14231374                        *******************************/ 
    14241375                        /*6*/     else if( k_its("ServerPort") ) { 
    1425                         ServerPort = k_int(); 
    1426                         init[6] = 1; 
     1376               if((str = k_str()) != NULL) { 
     1377                                 strncpy(ServerPort, str, sizeof(ServerPort)); 
     1378                                init[6] = 1; 
     1379               } 
    14271380            } 
    14281381 
  • trunk/src/data_exchange/export/export_ack.c

    r7475 r7606  
    77 *    Revision history: 
    88 *     $Log$ 
     9 *     Revision 2.0   2018/05/03 16:10:30  alexander 
     10 *     Upgraded to IPv6 
     11 * 
    912 *     Revision 1.12  2007/03/28 15:26:44  paulf 
    1013 *     minor MACOSX changes, mostly removing malloc.h since that should be defined in platform.h already 
     
    154157#include "exportfilter.h" 
    155158 
    156 #define EXPACK_VERSION  "1.15 2015.03.27" 
     159#define EXPACK_VERSION  "2.0 2018.05.03" 
    157160 
    158161/* CONSTANTS */ 
     
    261264static int     LogSwitch;              /* 0 if no logfile should be written */ 
    262265static int     HeartBeatInt;           /* seconds between heartbeats        */ 
    263 static char    ServerIPAdr[16];        /* server's IP address               */ 
    264 static int     ServerPort;             /* Server's well-known port number   */ 
     266static char    ServerIPAdr[64];        /* server's IP address               */ 
     267static char    ServerPort[16];         /* Server's well-known port number   */ 
    265268static long    MaxMsgSize;             /* max size for input/output msgs    */ 
    266269static int     RingSize;           /* max messages in output circular buffer */ 
     
    316319   int    on = 1; 
    317320   int    clientLen; 
    318    char   client_ip[16];        /* IP address of client from inet_ntoa   */ 
    319    struct sockaddr_in  skt; 
    320    struct sockaddr_in  client; 
     321   char   client_ip[64];        /* IP address of client from inet_ntoa   */ 
     322   char   client_port[10]; 
     323   struct sockaddr_storage  client; 
    321324 
    322325/* Other variables: */ 
     
    526529   SocketSysInit(); 
    527530 
    528    if( ( PassiveSocket = socket_ew( PF_INET, SOCK_STREAM, 0) ) == -1 ) 
    529    { 
    530       logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
     531   PassiveSocket = setuptcpserver_ew(ServerIPAdr, ServerPort, 0); 
     532 
     533   if( PassiveSocket < 0) 
     534   { 
     535      logit( "et", "%s(%s): Error setting up TCP server socket; exiting!\n", Argv0, MyModName ); 
    531536      tport_detach( &Region ); 
     537      export_free(); 
    532538      return( -1 ); 
    533539   } 
    534540   SocketStatus = SOCK_NEW; 
    535  
    536 /* Fill in server's socket address structure 
    537  ********************************************/ 
    538    memset( (char *) &skt, '\0', sizeof(skt) ); 
    539    skt.sin_family = AF_INET; 
    540    skt.sin_port   = htons( (short)ServerPort ); 
    541 #if defined(_LINUX) || defined(_MACOSX) 
    542    if ((int)(skt.sin_addr.s_addr = inet_addr(ServerIPAdr)) == -1) 
    543 #else 
    544    if ((int)(skt.sin_addr.S_un.S_addr = inet_addr(ServerIPAdr)) == -1) 
    545 #endif 
    546    { 
    547       logit( "e", "%s(%s): inet_addr failed for ServerIPAdr <%s>;" 
    548             " exiting!\n", Argv0, MyModName, ServerIPAdr ); 
    549       return( -1 ); 
    550    } 
    551  
    552 /* Allows the server to be stopped and restarted 
    553  ************************************************/ 
    554    on=1; 
    555    if( setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, 
    556                   (char *)&on, sizeof(char *) ) != 0 ) 
    557    { 
    558       logit( "et", "%s(%s): Error on setsockopt; exiting!\n", 
    559             Argv0, MyModName ); 
    560       perror("Export setsockopt"); 
    561       export_shutdown( -1 ); 
    562       return( -1 ); 
    563    } 
    564  
    565 /* Bind socket to a name 
    566  ************************/ 
    567    if ( bind_ew( PassiveSocket, (struct sockaddr *) &skt, sizeof(skt)) ) 
    568    { 
    569       logit("et", "%s(%s): error binding socket; exiting.\n", 
    570             Argv0, MyModName); 
    571       perror("Export bind error"); 
    572       export_shutdown( -1 ); 
    573       return( -1 ); 
    574    } 
    575  
    576 /* Prepare for connect requests 
    577  *******************************/ 
    578    if( listen_ew( PassiveSocket, 0 ) ) 
    579    { 
    580       logit("et", "%s(%s): socket listen error; exiting!\n", 
    581             Argv0, MyModName ); 
    582       export_shutdown( 1 ); 
    583       return( -1 ); 
    584    } 
    585541 
    586542/* Accept a connection (blocking) 
     
    623579   closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW ); 
    624580 
    625    strcpy( client_ip, inet_ntoa(client.sin_addr) ); 
     581   formatsocketaddress_ew((struct sockaddr *)&client, clientLen, client_ip, client_port); 
    626582   if( SocketStatus == SOCK_NOT_CONN ) 
    627583   { /* we cried before, so now we have to let them know we're OK */ 
     
    15431499                  exit( -1 ); 
    15441500               } 
    1545                strcpy( ServerIPAdr, str ); 
     1501               strncpy( ServerIPAdr, str, sizeof(ServerIPAdr) ); 
    15461502            } 
    15471503            init[5] = 1; 
     
    15511507       *******************************/ 
    15521508/*6*/    else if( k_its("ServerPort") ) { 
    1553             ServerPort = k_int(); 
    1554             init[6] = 1; 
     1509            if((str = k_str()) != NULL) { 
     1510               strncpy(ServerPort, str, sizeof(ServerPort)); 
     1511               init[6] = 1; 
     1512            } 
    15551513         } 
    15561514 
  • trunk/src/data_exchange/export/export_actv.c

    r7475 r7606  
    11/**************************************************************************** 
    22 *   export_actv.c 
     3 * 
     4 *   Revision history: 
     5 *    $Log$ 
     6 *    Revision 2.0  2018/05/03 16:03:26 
     7 *    Upgraded to IPv6. Adding revision log 
    38 * 
    49 *   Program to read messages (of user-given logos) from 
     
    3439#include "exportfilter.h" 
    3540 
    36 #define EXPACTV_VERSION  "1.2 2015.03.27" 
     41#define EXPACTV_VERSION  "2.0 2018.05.03" 
    3742 
    3843/* Functions in this source file 
     
    9398static int     LogSwitch;            /* 0 if no logfile should be written */ 
    9499static int     HeartBeatInt;         /* seconds between heartbeats        */ 
    95 static char    ReceiverIpAdr[16];    /* receiver's IP address               */ 
    96 static int     ReceiverPort;         /* receiver's well-known port number   */ 
     100static char    ReceiverIpAdr[64];    /* receiver's IP address               */ 
     101static char    ReceiverPort[16];     /* receiver's well-known port number   */ 
    97102static long    MaxMsgSize;           /* max size for input/output msgs    */ 
    98103static int     RingSize;             /* max messages in output circular buffer       */ 
     
    130135int main( int argc, char **argv ) 
    131136{ 
    132     /* Socket variables 
    133     ******************/ 
    134     struct sockaddr_in  skt_snd; 
    135  
    136137    /* Other variables 
    137138    *****************/ 
     
    237238    SocketSysInit(); 
    238239 
    239     /* Stuff address and port into socket structure 
    240     **********************************************/ 
    241     memset( (char *)&skt_snd, 0, sizeof(skt_snd) ); 
    242     skt_snd.sin_family = AF_INET; 
    243     skt_snd.sin_port = htons ( (short)ReceiverPort ); 
    244 #if defined(_LINUX) || defined(_MACOSX) 
    245     if ( (int)(skt_snd.sin_addr.s_addr = inet_addr(ReceiverIpAdr)) == -1 ) 
    246 #else 
    247     if ( (int)(skt_snd.sin_addr.S_un.S_addr = inet_addr(ReceiverIpAdr)) == -1 ) 
    248 #endif 
    249     { 
    250         logit ( "e", "%s(%s): inet_addr failed for ReceiverIpAdr <%s>; exiting.\n", 
    251                         Argv0, MyModName, ReceiverIpAdr ); 
    252         return -1; 
    253     } 
    254  
    255240    /* Prevent flooding the log file during long reconnect attempts 
    256241    **************************************************************/ 
     
    277262        } 
    278263 
    279         /* Create a socket 
    280         *****************/ 
    281         if ( ( ActiveSocket = socket_ew( AF_INET, SOCK_STREAM, 0) ) == -1 ) 
    282         { 
    283             sprintf(errtxt, "%s(%s): socket_ew", Argv0, MyModName); 
    284             SocketPerror(errtxt); 
    285             logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
    286             free(msg); 
    287             tport_detach( &Region ); 
    288             return( -1 ); 
    289         } 
    290  
    291         if ( retry_cnt < LOG_LIMIT ) 
    292         { 
    293             logit( "et", "%s(%s): Trying to connect to %s on port %d\n", 
    294                         Argv0, MyModName, ReceiverIpAdr, ReceiverPort ); 
    295         } 
    296  
    297         if ( retry_cnt == LOG_LIMIT ) 
    298         { 
    299             logit( "et", "%s(%s): Repetitions of connect attempts not logged\n", 
    300                     Argv0, MyModName ); 
    301         } 
    302  
    303         /* Attempt to connect 
    304         ********************/ 
    305         if ( connect_ew( ActiveSocket, (struct sockaddr *) &skt_snd, sizeof(skt_snd), 
    306                         SocketTimeoutLength ) == -1 ) 
    307         { 
    308  
     264         if ( retry_cnt < LOG_LIMIT ) 
     265         { 
     266            logit( "et", "%s(%s): Trying to establish TCP connection to %s on port %s\n", Argv0, MyModName, ReceiverIpAdr, ReceiverPort ); 
     267         } else if (retry_cnt == LOG_LIMIT)  
     268         { 
     269            logit("et", "%s(%s): Repetitions of connect attempts not logged\n", Argv0, MyModName); 
     270         } 
     271 
     272         /* Create a socket 
     273         *****************/ 
     274         if ( ( ActiveSocket = setuptcpclient_ew(ReceiverIpAdr, ReceiverPort, SocketTimeoutLength)) < 0) 
     275         { 
     276                 
     277            //Check if ActiveSocket == -2, indicating socket_ew() failed: 
     278            if(ActiveSocket == -2) { 
     279               sprintf(errtxt, "%s(%s): socket_ew", Argv0, MyModName); 
     280               SocketPerror(errtxt); 
     281               logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
     282               free(msg); 
     283               tport_detach( &Region ); 
     284               return( -1 ); 
     285            } 
     286 
     287            //Here, we know that the connection failed, not the call to socket_ew(): 
    309288            if ( retry_cnt < LOG_LIMIT ) 
    310289            { 
     
    329308        /* Successful connection 
    330309        ***********************/ 
    331         logit( "et", "%s(%s): Connected to %s on port %d\n", 
     310        logit( "et", "%s(%s): Connected to %s on port %s\n", 
    332311                    Argv0, MyModName, ReceiverIpAdr, ReceiverPort ); 
    333312        connected=1; 
     
    11821161              exit( -1 ); 
    11831162            } 
    1184             strcpy( ReceiverIpAdr, str ); 
     1163            strncpy( ReceiverIpAdr, str, sizeof(ReceiverIpAdr) ); 
    11851164            init[5] = 1; 
    11861165          } 
     
    11911170        *******************************/ 
    11921171  /*6*/ else if( k_its("ReceiverPort") ) 
    1193                 { 
    1194           ReceiverPort = k_int(); 
    1195           init[6] = 1; 
     1172        { 
     1173            if((str = k_str()) != NULL) { 
     1174               strncpy(ReceiverPort, str, sizeof(ReceiverPort)); 
     1175               init[6] = 1; 
     1176            } 
    11961177        } 
    11971178 
     
    13221303       if ( !init[3] )  logit("e", "<HeartBeatInt> " ); 
    13231304       if ( !init[4] )  logit("e", "<GetMsgLogo> "   ); 
    1324        if ( !init[5] )  logit("e", "<ServerIPAdr> "  ); 
    1325        if ( !init[6] )  logit("e", "<ServerPort> "   ); 
     1305       if ( !init[5] )  logit("e", "<ReceiverIpAdr> "  ); 
     1306       if ( !init[6] )  logit("e", "<ReceiverPort> "   ); 
    13261307       if ( !init[7] )  logit("e", "<MaxMsgSize> "   ); 
    13271308       if ( !init[8] )  logit("e", "<RingSize> "     ); 
  • trunk/src/data_exchange/export/export_scn_pri.c

    r7475 r7606  
    77 *    Revision history: 
    88 *     $Log$ 
     9 *     Revision 2.0  2018/05/03 16:06:48  alexander 
     10 *     upgraded to IPv6, added versioning string 
     11 * 
    912 *     Revision 1.7  2007/09/20 20:58:49  paulf 
    1013 *      made processor array bigger as per Alex N. suggestion 
     
    6770#define ALEXs_MAGIC_NUMBER 3 /* seconds */ 
    6871 
     72#define VERSION_STR "2.0 2018.05.03" 
     73 
    6974/* Functions in this source file 
    7075 *******************************/ 
     
    139144static int     LogSwitch;           /* 0 if no logfile should be written */ 
    140145static int     HeartBeatInt;        /* seconds between heartbeats        */ 
    141 static char    ServerIPAdr[16];     /* server's IP address               */ 
    142 static int     ServerPort;          /* Server's well-known port number   */ 
     146static char    ServerIPAdr[64];     /* server's IP address               */ 
     147static char    ServerPort[16];          /* Server's well-known port number   */ 
    143148static long    MaxMsgSize;          /* max size for input/output msgs    */ 
    144149static int     RingSize;        /* max messages in output circular buffer       */ 
     
    187192{ 
    188193/* Socket variables: */ 
    189    int    on = 1; 
    190194   int    clientLen; 
    191    char   client_ip[16];        /* IP address of client from inet_ntoa   */ 
    192    struct sockaddr_in  skt; 
    193    struct sockaddr_in  client; 
     195   char   client_ip[64];        /* IP address of client from inet_ntoa   */ 
     196   char   client_port[10]; 
     197   struct sockaddr_storage  client; 
    194198 
    195199/* Other variables: */ 
     
    224228   export_config( argv[1] ); 
    225229   export_lookup(); 
    226    logit( "et" , "%s(%s): Read command file <%s>\n", 
    227            Argv0, MyModName, argv[1] ); 
     230   logit( "et" , "%s(%s): Read command file <%s>. Version: %s\n", 
     231           Argv0, MyModName, argv[1], VERSION_STR ); 
    228232 
    229233   /* Reinitialize the logging level 
     
    237241   /* Heartbeat parameters sanity checks 
    238242   ************************************/ 
    239    logit("","3 Apr 00 version: I do re-sends.\n"); 
     243   logit("","(version: %s): I do re-sends.\n", VERSION_STR); 
    240244 
    241245   /* Do a sanity chcek on the SocketTimeoutLength. 
     
    363367   SocketSysInit(); 
    364368 
    365    if ( ( PassiveSocket = socket_ew( PF_INET, SOCK_STREAM, 0) ) == -1 ) 
    366    { 
    367       logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
     369   PassiveSocket = setuptcpserver_ew(ServerIPAdr, ServerPort, 0); 
     370 
     371   if ( PassiveSocket < 0 ) 
     372   { 
     373      logit( "et", "%s(%s): Error setting up TCP server socket; exiting!\n", Argv0, MyModName ); 
    368374      tport_detach( &Region ); 
    369375      return( -1 ); 
    370376   } 
    371377   SockStatus = SOCK_NEW; 
    372  
    373    /* Fill in server's socket address structure 
    374    ********************************************/ 
    375    memset( (char *) &skt, '\0', sizeof(skt) ); 
    376    skt.sin_family = AF_INET; 
    377    skt.sin_port   = htons( (short)ServerPort ); 
    378 #if defined(_LINUX) || defined(_MACOSX) 
    379    if ((int)(skt.sin_addr.s_addr = inet_addr(ServerIPAdr)) == -1) 
    380 #else 
    381    if ((int)(skt.sin_addr.S_un.S_addr = inet_addr(ServerIPAdr)) == -1) 
    382 #endif 
    383    { 
    384       logit( "e", "%s(%s): inet_addr failed for ServerIPAdr <%s>;" 
    385                   " exiting!\n", Argv0, MyModName, ServerIPAdr ); 
    386       return( -1 ); 
    387    } 
    388  
    389    /* Allows the server to be stopped and restarted 
    390    ************************************************/ 
    391    on=1; 
    392    if( setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, 
    393                  (char *)&on, sizeof(char *) ) != 0 ) 
    394    { 
    395       logit( "et", "%s(%s): Error on setsockopt; exiting!\n", 
    396               Argv0, MyModName ); 
    397       perror("Export setsockopt"); 
    398       tport_detach( &Region ); 
    399       return( -1 ); 
    400    } 
    401  
    402    /* Bind socket to a name 
    403    ************************/ 
    404    if ( bind_ew( PassiveSocket, (struct sockaddr *) &skt, sizeof(skt)) ) 
    405    { 
    406       logit("et", "%s(%s): error binding socket; exiting.\n", 
    407             Argv0, MyModName); 
    408       perror("Export bind error"); 
    409       closesocket_ew(PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW); 
    410       tport_detach( &Region ); 
    411       return( -1 ); 
    412    } 
    413  
    414    /* Prepare for connect requests 
    415    *******************************/ 
    416    if ( listen_ew( PassiveSocket, 0)) 
    417    { 
    418       logit("et", "%s(%s): socket listen error; exiting!\n", 
    419              Argv0, MyModName ); 
    420       closesocket_ew( PassiveSocket,SOCKET_CLOSE_IMMEDIATELY_EW ); 
    421       tport_detach( &Region ); 
    422       return( 1 ); 
    423    } 
    424378 
    425379   /* One heartbeat to announce ourselves to statmgr 
     
    465419   } 
    466420 
    467    strcpy( client_ip, inet_ntoa(client.sin_addr) ); 
     421   formatsocketaddress_ew((struct sockaddr *)&client, clientLen, client_ip, client_port); 
    468422   LiveConnection = 1; /*970623:ldd*/ 
    469423   if (SockStatus == SOCK_NOT_CONN) 
     
    12891243                      exit( -1 ); 
    12901244                   } 
    1291                    strcpy( ServerIPAdr, str ); 
     1245                   strncpy( ServerIPAdr, str, sizeof(ServerIPAdr) ); 
    12921246                } 
    12931247                init[5] = 1; 
     
    12981252          *******************************/ 
    12991253  /*6*/     else if( k_its("ServerPort") ) { 
    1300                 ServerPort = k_int(); 
    1301                 init[6] = 1; 
     1254               if((str = k_str())) { 
     1255                  strncpy(ServerPort, str, sizeof(ServerPort)); 
     1256                  init[6] = 1; 
     1257               } 
    13021258            } 
    13031259 
  • trunk/src/data_exchange/getfile_ew/getfile_ew.c

    r7238 r7606  
    77 *    Revision history: 
    88 *     $Log$ 
     9 *     Revision 2.0  2018/05/03 16:15:15  alexander 
     10 *     Upgraded to IPv6, added versioning string 
     11 * 
    912 *     Revision 1.6  2007/02/26 18:56:06  paulf 
    1013 *     yet more warnings fixed related to time_t 
     
    4245#include "kom.h" 
    4346#include "transport.h" 
     47#include <socket_ew.h> 
    4448#include "getfile_ew.h" 
     49 
     50#define VERSION_STR "2.0 2018.05.03" 
    4551 
    4652/* Functions declarations 
     
    7985static unsigned char TypeError; 
    8086 
    81 char   ServerIP[20];           /* IP address of system to receive msg's */ 
    82 int    ServerPort;             /* The well-known port number */ 
     87char   ServerIP[64];           /* IP address of system to receive msg's */ 
     88char   ServerPort[16];             /* The well-known port number */ 
    8389int    nClient = 0;            /* Number of trusted clients */ 
    8490CLIENT Client[MAX_CLIENTS];     /* List if trusted clients */ 
     
    110116      int    total_bytes_received = 0; 
    111117      time_t tstart; 
    112       int    rc, clientIndex; 
     118      int    rc, clientIndex, isIPv6, err; 
    113119 
    114120        if (argc != 2) 
    115121    { 
    116         fprintf( stderr, "Usage: getfile_ew <configfile>\n" ); 
     122        fprintf( stderr, "Usage (version %s): getfile_ew <configfile>\n", VERSION_STR ); 
    117123        exit( 0 ); 
    118124    } 
     
    141147                if ((MyPid = getpid ()) == -1) 
    142148                { 
    143                         logit ("e", "getfile: Call to getpid failed. Exiting.\n"); 
     149                        logit ("e", "getfile_ew (v %s): Call to getpid failed. Exiting.\n", VERSION_STR); 
    144150                        exit (-1); 
    145151                } 
     
    147153                /* Attach to the output ring */ 
    148154                tport_attach (&OutRegion, OutRingKey); 
    149                 logit ("", "getfile_ew: Attached to public memory region %s: %ld\n", 
    150                                 OutRingName, OutRingKey); 
     155                logit ("", "getfile_ew (version %s): Attached to public memory region %ld: %s\n", 
     156                                OutRingName, OutRingKey, VERSION_STR); 
    151157 
    152158                /* Force a heartbeat to be issued in first pass thru main loop 
     
    187193            return -1; 
    188194         } 
    189  
    190          Client[i].ipint = inet_addr( Client[i].ip ); 
    191          if ( Client[i].ipint == 0xffffffff ) 
     195         //XXX XXX XXX 
     196         // inet_addr() only works for IPv4 
     197         // Need to use inet_pton() but that requires knowing 
     198         // whether the address is IPv4 or IPv6 beforehand, 
     199         // so we'll use isIPv6 first 
     200         // then, make sure ipint is the size of in6_addr so that it 
     201         // can hold either 
     202         #if 0 
     203         if((isIPv6 = isIPv6(Client[i].ip)) < 0) { 
     204            //this is an error: 
     205            logit("e", "ERROR. Unable to determine address family for %s. Exiting.\n", Client[i].ip); 
     206            return -1; 
     207         } 
     208         if(isIPv6) { 
     209            err = inet_pton(AF_INET6, Client[i].ip, &(Client[i].ipint));                 
     210         } else { 
     211            err = inet_pton(AF_INET, Client[i].ip, &(Client[i].ipint)); 
     212         } 
     213         if ( err <= 0 ) 
    192214         { 
    193             logit ( "e", "Error. Bad client ip: %s Exiting.\n", Client[i].ip ); 
     215            logit ( "e", "Error.  Failed to convert address %s. Check formatting. Exiting.\n", Client[i].ip ); 
    194216            exit( -1 ); 
    195217         } 
     218         #endif 
    196219      } 
    197220 
     
    396419                        { 
    397420                str = k_str(); 
    398                 if(str) strcpy( ServerIP, str ); 
     421                if(str) strncpy( ServerIP, str, sizeof(ServerIP) ); 
    399422                init[0] = 1; 
    400423            } 
    401424  /*1*/     else if( k_its("ServerPort") )  
    402425                        { 
    403                 ServerPort = k_int(); 
     426                str = k_str(); 
     427                if(str) strncpy( ServerPort, str, sizeof(ServerPort) ); 
    404428                init[1] = 1; 
    405429            } 
     
    412436                        { 
    413437                str = k_str(); 
    414                 if(str) strcpy( TempDir, str ); 
     438                if(str) strncpy( TempDir, str, sizeof(TempDir) ); 
    415439                init[3] = 1; 
    416440            } 
     
    424448                } 
    425449                if( ( str=k_str() ) ) { 
    426                    strcpy (Client[nClient].ip, str);  
     450                   strncpy (Client[nClient].ip, str, sizeof(Client[nClient].ip));  
    427451                } 
    428452                if( ( str=k_str() ) ) { 
    429                    strcpy (Client[nClient].indir, str); 
     453                   strncpy (Client[nClient].indir, str, sizeof(Client[nClient].indir)); 
    430454                } 
    431455 
     
    441465  /*6*/     else if( k_its("LogFileDir") ) { 
    442466                str = k_str(); 
    443                 if(str) strcpy( LogFileDir, str ); 
     467                if(str) strncpy( LogFileDir, str, sizeof(LogFileDir) ); 
    444468                init[6] = 1; 
    445469                                Standalone = TRUE; 
     
    456480  /*7*/     else if( k_its("MyModuleId") ) { 
    457481                str = k_str(); 
    458                 if(str) strcpy( MyModName, str ); 
     482                if(str) strncpy( MyModName, str, MAX_MOD_STR ); 
    459483                init[7] = 1; 
    460484                                Earthworm = TRUE; 
     
    462486  /*8*/     else if( k_its("OutRingName") ) { 
    463487                str = k_str(); 
    464                 if(str) strcpy( OutRingName, str ); 
     488                if(str) strncpy( OutRingName, str, MAX_RING_STR ); 
    465489                init[8] = 1; 
    466490                                Earthworm = TRUE; 
     
    659683   logit ("e", "COMMON CONFIGURATION:\n"); 
    660684   logit ("e", "ServerIP:    %s\n", ServerIP ); 
    661    logit ("e", "ServerPort:  %d\n", ServerPort ); 
     685   logit ("e", "ServerPort:  %s\n", ServerPort ); 
    662686   logit ("e", "TimeOut:     %d\n", TimeOut ); 
    663687   for (i = 0; i < nClient; i++ ) 
  • trunk/src/data_exchange/getfile_ew/getfile_ew.h

    r1121 r7606  
    2727typedef struct 
    2828{ 
    29    char ip[20];            /* IP address of trusted client */ 
     29   char ip[64];            /* IP address of trusted client */ 
    3030   char indir[80];         /* Where to store files from the client */ 
    31    unsigned long ipint;    /* IP address stored as an unsigned long */ 
     31   struct in6_addr ipint;  /* IP address stored as an unsigned long */ 
    3232} CLIENT; 
    3333 
  • trunk/src/data_exchange/getfile_ew/getfile_socket.c

    r7108 r7606  
    77 *    Revision history: 
    88 *     $Log$ 
     9 *     Revision 2.0  2018/05/03 16:12:46  alexander 
     10 *     Upgraded to IPv6 
     11 * 
    912 *     Revision 1.7  2010/04/27 18:43:41  paulf 
    1013 *     removed any stropts include lines 
     
    6366static SOCKET readSock;          /* Read from this socket  (ns) */ 
    6467 
    65  
    66  
    6768       /********************************************************* 
    6869        *                    CloseReadSock()                    * 
     
    8990   unsigned long address; 
    9091 
    91 /* Get a new socket descriptor 
    92    ***************************/ 
    93    acceptSock = socket_ew ( AF_INET, SOCK_STREAM, 0 ); 
    94    if ( acceptSock == -1 ) 
    95    { 
    96       logit ( "e", "socket() error\n" ); 
    97       exit( -1 ); 
    98    } 
    99  
    100 /* Allow reuse of socket addresses 
    101    *******************************/ 
    102    if ( setsockopt( acceptSock, SOL_SOCKET, SO_REUSEADDR, (char *)&optVal, 
    103                     sizeof(int) ) == -1 ) 
    104    { 
    105       logit ( "e", "setsockopt() error\n" ); 
    106       SocketClose( acceptSock ); 
    107       exit( -1 ); 
    108    } 
    109  
    110 /* Fill in socket address structure 
    111    ********************************/ 
    112    address = inet_addr( ServerIP ); 
    113    if ( address == -1 ) 
    114    { 
    115       logit ( "e", "Bad server IP address: %s  Exiting.\n", ServerIP ); 
    116       SocketClose( acceptSock ); 
    117       exit( -1 ); 
    118    } 
    119    memset( (char *)&server, '\0', sizeof(server) ); 
    120    server.sin_family = AF_INET; 
    121    server.sin_port   = htons( (unsigned short)ServerPort ); 
    122 #if defined(_LINUX) || defined(_MACOSX) 
    123    server.sin_addr.s_addr = address; 
    124 #else 
    125    server.sin_addr.S_un.S_addr = address; 
    126 #endif 
    127  
    128 /* Bind a local address to the socket descriptor 
    129    *********************************************/ 
    130    if ( bind_ew ( acceptSock, (struct sockaddr *)&server,  
    131                                                                                 sizeof(server) ) == SOCKET_ERROR ) 
    132    { 
    133       logit ( "e", "bind() error: %s\n", strerror(errno) ); 
    134       SocketClose ( acceptSock ); 
    135       exit( -1 ); 
    136    } 
    137  
    138 /* Set the maximum number of pending connections 
    139    *********************************************/ 
    140    if ( listen_ew ( acceptSock, 5 ) == SOCKET_ERROR ) 
    141    { 
    142       logit ( "e", "listen() error: %s\n", strerror(errno) ); 
    143       SocketClose ( acceptSock ); 
    144       exit( -1 ); 
    145    } 
     92   if((acceptSock = setuptcpserver_ew(ServerIP, ServerPort, 5)) < 0) 
     93   { 
     94      logit("e", "setuptcpserver_ew() error\n"); 
     95      exit(-1); 
     96   } 
     97 
    14698   return; 
    14799} 
     
    160112   extern CLIENT Client[];             /* Addresses of trusted clients */ 
    161113   extern int TimeOut;             /* Send/receive timeout, in seconds */ 
    162    struct sockaddr_in client;         /* Client socket address structure */ 
     114   struct sockaddr_storage client;         /* Client socket address structure */ 
    163115   int clientlen = sizeof(client);    /* Client socket structure length */ 
    164116   unsigned long lOnOff=1; 
    165117   int i; 
     118   struct sockaddr_in *ipv4Addr; 
     119   struct sockaddr_in6 *ipv6Addr; 
    166120   int trusted = 0;                   /* 1 if client is trusted */ 
    167121 
     
    179133   for ( i = 0; i < nClient; i++ ) 
    180134   { 
     135#if 0 
     136      if(((struct sockaddr *)&client)->sa_family == AF_INET) { 
     137         ipv4Addr = (struct sockaddr_in *)&client; 
    181138#if defined(_LINUX) || defined(_MACOSX) 
    182       if ( client.sin_addr.s_addr == Client[i].ipint ) 
     139         if ( ipv4Addr->sin_addr.s_addr == Client[i].ipint ) 
    183140#else 
    184       if ( client.sin_addr.S_un.S_addr == Client[i].ipint ) 
     141         if ( ipv4Addr->sin_addr.S_un.S_addr == Client[i].ipint ) 
    185142#endif 
    186       { 
    187          trusted = 1; 
    188          break; 
     143         { 
     144            trusted = 1; 
     145            break; 
     146         } 
     147      } else if (((struct sockaddr *)&client)->sa_family == AF_INET6) { 
     148         ipv6Addr = (struct sockaddr_in6)&client; 
     149         //fortunately it does not appear that Windows differ from Posix for IPv6 structs: 
     150         if (memcmp(&(ipv6Addr->sin6_addr), &(Client[i].ipint), sizeof(struct in6_addr)) == 0) 
     151         { 
     152            trusted = 1; 
     153            break; 
     154         } 
    189155      } 
    190    } 
    191  
     156#endif 
     157   } 
    192158  
    193159   if ( !trusted ) 
    194160   { 
    195       logit ( "e", "Rejected connection attempt by %s\n", 
    196            inet_ntoa(client.sin_addr) ); 
     161      //logit ( "e", "Rejected connection attempt by %s\n", inet_ntoa(client.sin_addr) ); 
    197162      SocketClose ( readSock ); 
    198163      return GETFILE_FAILURE; 
     
    200165 
    201166   *clientIndex = i; 
    202    logit ( "et", "Accepted connection from %s\n", inet_ntoa(client.sin_addr) ); 
     167   //logit ( "et", "Accepted connection from %s\n", inet_ntoa(client.sin_addr) ); 
    203168 
    204169/* Set socket to non-blocking mode 
  • trunk/src/data_exchange/import_generic/import_ack.c

    r7475 r7606  
    77 *    Revision history: 
    88 *     $Log$ 
     9 *     Revision 2.0  2018/05/03 15:53:07  alexander 
     10 *     Upgraded module to IPv6 
     11 * 
    912 *     Revision 1.5  2007/03/28 15:42:27  paulf 
    1013 *     minor MACOSX directives 
     
    133136/* versioning added starting with number 2.0.0 on July 10, 2013 */ 
    134137 
    135 #define VERSION_STR "2.0.1 2013.07.15" 
     138#define VERSION_STR "2.1.0 2018.05.03" 
    136139 
    137140#define MAX_LOGO  20 
     
    163166static char    MyAliveString[MAX_ALIVE_STR];  /* Text of above alive message */ 
    164167 
    165 static char    SenderIpAdr[20];     /* Foreign sender's address, in dot notation */ 
    166 static int     SenderPort;          /* Server's well-known port number */ 
     168static char    SenderIpAdr[64];     /* Foreign sender's address, in dot notation */ 
     169static char    SenderPort[16];          /* Server's well-known port number */ 
    167170static int     SenderHeartRate;     /* Expect alive messages this often from foreign sender */ 
    168171static char    SenderHeartText[MAX_ALIVE_STR];/* Text making up the sender's heartbeat msg */ 
     
    214217int main( int argc, char **argv ) 
    215218{ 
    216    struct sockaddr_in insocket; 
    217219   time_t now; 
    218220   time_t tfirsttry;            /* time of first connection attempt */ 
     
    256258/* Heartbeat parameters sanity checks 
    257259 ************************************/ 
    258    logit("","29 Apr 2005 version: I discover if I should send ACKs.\n"); 
     260   logit("","(v%s): I discover if I should send ACKs.\n", VERSION_STR); 
    259261   if( 1000 * SenderHeartRate >= (int)SocketTimeoutLength ) 
    260262   { 
     
    298300   SocketSysInit(); 
    299301 
    300 /* Stuff address and port into socket structure 
    301  **********************************************/ 
    302    memset( (char *)&insocket, '\0', sizeof(insocket) ); 
    303    insocket.sin_family = AF_INET; 
    304    insocket.sin_port   = htons( (short)SenderPort ); 
    305  
    306 #if defined(_LINUX) || defined(_MACOSX) 
    307    if( (int)(insocket.sin_addr.s_addr = inet_addr(SenderIpAdr)) == -1 ) 
    308 #else 
    309    if( (int)(insocket.sin_addr.S_un.S_addr = inet_addr(SenderIpAdr)) == -1 ) 
    310 #endif 
    311    { 
    312       logit( "e", "import_ack(%s): inet_addr failed for SenderIpAdr <%s>; exiting!\n", 
    313               MyModName, SenderIpAdr ); 
    314       return -1; 
    315    } 
    316   
    317302/* to prevent flooding the log file during long reconnect attempts 
    318303 *****************************************************************/ 
     
    355340      } 
    356341 
    357    /* Create a socket 
    358     ******************/ 
    359       if( ( Sd = socket_ew( AF_INET, SOCK_STREAM, 0)) == -1 ) 
    360       { 
    361          sprintf (errtxt, "import_ack(%s): socket_ew", MyModName); 
    362          SocketPerror(errtxt); 
    363          logit( "et", "import_ack(%s): Error opening socket, exiting!\n", MyModName ); 
    364          closesocket_ew((int)Sd,SOCKET_CLOSE_IMMEDIATELY_EW); 
    365          free(MsgBuf); 
    366          return -1; 
    367       } 
    368       if( retryCount <= 4 ) { 
    369          logit("t", "import_ack(%s): Trying to connect to %s on port %d\n", 
    370                 MyModName, SenderIpAdr, SenderPort); 
    371       } 
    372  
    373    /* Attempt the connection, if it fails close socket and sleep  
    374     ************************************************************/ 
    375       if( connect_ew( (int)Sd, (struct sockaddr *)&insocket, sizeof(insocket), 
    376                      SocketTimeoutLength ) == -1 ) 
    377       { 
    378          closesocket_ew((int)Sd, SOCKET_CLOSE_IMMEDIATELY_EW); 
    379  
     342 
     343      /* Create a client TCP connection 
     344       *********************************/ 
     345      if ( ( Sd = setuptcpclient_ew(SenderIpAdr, SenderPort, SocketTimeoutLength)) < 0) 
     346      { 
     347         if(Sd == -2) //indicating socket() failed 
     348         { 
     349            sprintf(errtxt, "import_ack(%s): socket_ew", MyModName); 
     350            SocketPerror(errtxt); 
     351            logit( "et", "import_ack(%s): Error opening socket, exiting!\n", MyModName); 
     352            free(MsgBuf); 
     353            return -1; 
     354         } 
     355         //XXX XXX XXX XXX 
     356         //XXX XXX 
    380357         if( retryCount < 4 ) { 
    381             logit("t", "import_ack(%s): Failed to connect. Waiting...\n",  
    382                    MyModName ); 
     358            logit("t", "import_ack(%s): Failed to set up TCP client connection with %s:%s. Waiting...\n", MyModName, SenderIpAdr, SenderPort); 
    383359         } 
    384360         if( retryCount == 4 ) { 
    385             logit("t", "import_ack(%s): Failed to connect. Will try to " 
    386                    "connect every %d seconds, but will not log repetitions.\n",  
    387                    MyModName, CONNECT_WAIT_DT ); 
     361            logit("t", "import_ack(%s): Failed to set up TCP client connection. Will try to connect every %d seconds, but will not log further attempts.\n", MyModName, CONNECT_WAIT_DT ); 
    388362         } 
    389363         sleep_ew(CONNECT_WAIT_DT*1000); 
     
    394368      else 
    395369      { 
    396          logit( "t", "import_ack(%s): Connected after %d seconds (on try %d)\n", 
    397                  MyModName, (int)(time(&now)-tfirsttry), retryCount ); 
     370         logit( "t", "import_ack(%s): Connected after %d seconds (on try %d)\n", MyModName, (int)(time(&now)-tfirsttry), retryCount ); 
    398371         connected  = 1; 
    399372         retryCount = 0; 
     
    976949                     k_its("ServerIPAdr")    ) { 
    977950                str=k_str(); 
    978                 if(str) strcpy(SenderIpAdr,str); 
     951                if(str) strncpy(SenderIpAdr, str, sizeof(SenderIpAdr)); 
    979952                init[7]=1; 
    980953            } 
     
    984957            else if( k_its("SenderPort") || 
    985958                     k_its("ServerPort")    ) { 
    986                 SenderPort = k_int(); 
     959                str=k_str(); 
     960                if(str) strncpy(SenderPort, str, sizeof(SenderPort)); 
    987961                init[8]=1; 
    988962            } 
  • trunk/src/data_exchange/import_generic/import_generic.c

    r7475 r7606  
    88 *    Revision history: 
    99 *     $Log$ 
     10 *     Revision 2.0   2018/05/03 15:58:16  alexander 
     11 *     Upgraded to IPv6, added version info 
     12 * 
    1013 *     Revision 1.13  2007/03/28 15:42:27  paulf 
    1114 *     minor MACOSX directives 
     
    114117#define MAX_LOGO  20 
    115118 
     119#define VERSION_STR "2.0.0 2018.05.03" 
     120 
    116121/* Functions in this source file 
    117122   *****************************/ 
     
    139144static char    MyAliveString[MAX_ALIVE_STR];  /* Text of above alive message */ 
    140145 
    141 static char    SenderIpAdr[20];     /* Foreign sender's address, in dot notation */ 
    142 static int     SenderPort;          /* Server's well-known port number */ 
     146static char    SenderIpAdr[64];     /* Foreign sender's address, in IP[v6] format or host name */ 
     147static char    SenderPort[16];          /* Server's port number or known service */ 
    143148static int     SenderHeartRate;     /* Expect alive messages this often from foreign sender */ 
    144149static char    SenderHeartText[MAX_ALIVE_STR];/* Text making up the sender's heartbeat msg */ 
     
    186191int main( int argc, char **argv ) 
    187192{ 
    188    struct sockaddr_in insocket; 
    189193   time_t now; 
    190194   time_t tfirsttry;            /* time of first connection attempt */ 
     
    209213 ********************************/ 
    210214   config( argv[1] ); 
    211    logit( "" , "import_generic(%s): Read command file <%s>\n",  
    212                 MyModName, argv[1] ); 
     215   logit( "" , "import_generic(%s): Read command file <%s>. Version: %s\n",  
     216                MyModName, argv[1], VERSION_STR ); 
    213217 
    214218/* Reinitialize the logging level 
     
    226230/* Heartbeat parameters sanity checks 
    227231 ************************************/ 
    228    logit("","17 Mar 2005 version.\n"); 
     232   logit("","%s\n", VERSION_STR); 
    229233   if(1000 * (unsigned int)SenderHeartRate >= SocketTimeoutLength) 
    230234   { 
     
    268272   SocketSysInit(); 
    269273 
    270 /* Stuff address and port into socket structure 
    271    ********************************************/ 
    272    memset( (char *)&insocket, '\0', sizeof(insocket) ); 
    273    insocket.sin_family = AF_INET; 
    274    insocket.sin_port   = htons( (short)SenderPort ); 
    275  
    276 #if defined(_LINUX) || defined(_MACOSX) 
    277    if ((int)(insocket.sin_addr.s_addr = inet_addr(SenderIpAdr)) == -1) 
    278 #else 
    279    if ((int)(insocket.sin_addr.S_un.S_addr = inet_addr(SenderIpAdr)) == -1) 
    280 #endif 
    281    { 
    282       logit( "e", "import_generic(%s): inet_addr failed for SenderIpAdr <%s>; exiting!\n", 
    283               MyModName, SenderIpAdr ); 
    284       return -1; 
    285    } 
    286   
    287274   /* to prevent flooding the log file during long reconnect attempts */ 
    288275   /********************************************************************/ 
     
    312299         MyLastInternalBeat = now; 
    313300      } 
     301 
    314302 
    315303   /* Are we being told to quit?  
     
    325313         return 0; 
    326314      } 
    327  
    328    /* Create a socket 
    329     ******************/ 
    330       if ( ( Sd = socket_ew( AF_INET, SOCK_STREAM, 0)) == -1 ) 
    331       { 
    332          sprintf (errtxt, "import_generic(%s): socket_ew", MyModName); 
    333          SocketPerror(errtxt); 
    334          logit( "et", "import_generic(%s): Error opening socket, exiting!\n", MyModName ); 
    335          closesocket_ew((int)Sd,SOCKET_CLOSE_IMMEDIATELY_EW); 
    336          free(MsgBuf); 
    337          return -1; 
    338       } 
    339       if (retryCount <= 4) { 
    340          logit("t", "import_generic(%s): Trying to connect to %s on port %d\n", 
    341                 MyModName, SenderIpAdr, SenderPort); 
    342       } 
    343  
    344    /* Attempt the connection, if it fails close socket and sleep  
    345     ************************************************************/ 
    346       if ( connect_ew( (int)Sd, (struct sockaddr *)&insocket, sizeof(insocket), 
    347                      SocketTimeoutLength ) == -1 ) 
    348       { 
    349          closesocket_ew((int)Sd, SOCKET_CLOSE_IMMEDIATELY_EW); 
    350  
    351          if (retryCount < 4) { 
    352             logit("t", "import_generic(%s): Failed to connect. Waiting...\n",  
    353                    MyModName ); 
    354          } 
    355          if (retryCount == 4) { 
    356             logit("t", "import_generic(%s): Failed to connect. Will try to " 
    357                    "connect every %d seconds, but will not log repetitions.\n",  
    358                    MyModName, CONNECT_WAIT_DT ); 
     315       
     316      //XXX: for testing new functionality: 
     317      setSocket_ewDebug(1); 
     318 
     319      /* Create a client TCP connection 
     320       *********************************/ 
     321      if ( ( Sd = setuptcpclient_ew(SenderIpAdr, SenderPort, SocketTimeoutLength)) < 0 ) 
     322      { 
     323         //no need to close the socket, setuptcpclient_ew() handles this 
     324         //XXX XXX XXX  
     325         //The original code quit when socket() failed 
     326         if(Sd == -2) //indicating socket() failed, not just connect failure 
     327         { 
     328            sprintf (errtxt, "import_generic(%s): socket failure", MyModName); 
     329            SocketPerror(errtxt); 
     330            logit( "et", "import_generic(%s): Error opening socket, exiting!\n", MyModName ); 
     331            free(MsgBuf); 
     332            return -1; 
     333         }  
     334 
     335         if(retryCount < 4) { 
     336            logit("t", "import_generic(%s): Failed to set up TCP client connection with %s:%s. Waiting...\n", MyModName, SenderIpAdr, SenderPort); 
     337         } else if (retryCount == 4) 
     338         { 
     339            logit("t", "import_generic(%s): Failed to set up TCP client connection with %s:%s. Will try to connect every %d seconds, but will not log further attempts.\n", MyModName, SenderIpAdr, SenderPort, CONNECT_WAIT_DT); 
    359340         } 
    360341         sleep_ew(CONNECT_WAIT_DT*1000); 
    361       } 
    362  
    363    /* else the connection succeeded...let's get out of this loop!  
    364     *************************************************************/ 
    365       else 
    366       { 
    367          logit("t", "import_generic(%s): Connected after %d seconds (on try %d)\n", 
    368                 MyModName, (int)(time(&now)-tfirsttry), retryCount ); 
    369          connected  = 1; 
     342      } else  
     343      { 
     344         /* connection established... let's get out of this loop! 
     345          ********************************************************/ 
     346         logit("t", "import_generic(%s): Connected after %d seconds (on try %d)\n", MyModName, (int)(time(&now)-tfirsttry), retryCount ); 
     347         connected = 1; 
    370348         retryCount = 0; 
    371349      } 
     
    860838            } 
    861839 
    862         /* 8 Sender's Port Number 
     840        /* 8 Sender's Port Number/Known service 
    863841        *************************/ 
    864842            else if( k_its("SenderPort") ) { 
    865                 SenderPort = k_int(); 
     843                str=k_str(); 
     844                if(str) strcpy(SenderPort,str); 
    866845                init[8]=1; 
    867846            } 
  • trunk/src/data_exchange/import_pasv/import_gen_pasv.c

    r7563 r7606  
    5959#include <string.h> 
    6060#include <time.h> 
    61  
    62 #include "earthworm.h" 
    63 #include "kom.h" 
    64 #include "transport.h" 
    65 #include "socket_ew.h" 
    66 #include "imp_exp_gen.h" 
    67 #include "mask_check.h" 
    68 #include "trace_buf.h" 
     61#include <errno.h> 
     62#include <signal.h> 
     63#include <earthworm.h> 
     64#include <kom.h> 
     65#include <transport.h> 
     66#include <socket_ew.h> 
     67#include <imp_exp_gen.h> 
     68#include <trace_buf.h> 
     69 
     70#ifdef _WINNT 
     71#include <winsock2.h> 
     72#include <ws2tcpip.h> 
     73#pragma comment(lib, "Ws2_32.lib") 
     74#endif 
    6975 
    7076#define MAX_LOGO  20 
     
    7682   0.1.1 - 2018-10-01 - paulf added more debugging to heartbeat  
    7783*/ 
    78 #define VERSION "0.1.1 2018-10-01" 
    79 #define MAX_IP_STR 17 
     84#define VERSION "0.2.0 2018-03-09" 
     85#define MAX_IP_STR 47 
    8086 
    8187/* Functions in this source file 
     
    106112 
    107113static char ReceiverIpAdr[MAX_IP_STR];       /* Receiver's IP address             */ 
    108 static int  ReceiverPort;            /* Receiver's well-known port number */ 
     114static char ReceiverPort[16];            /* Receiver's well-known port number */ 
    109115 
    110116static char SenderIpAdr[MAX_IP_STR];         /* Sender's IP address for checking  */ 
     
    177183int main( int argc, char **argv ) 
    178184{ 
    179    struct sockaddr_in skt_snd; 
    180    struct sockaddr_in skt_rcv; 
     185   struct sockaddr_storage skt_snd; 
    181186   time_t now, acceptstart; 
    182    char   sender_ip[MAX_IP_STR];       /* Sender IP Address from inet_ntoa() */ 
     187   char   sender_ip[64];       /* Sender IP Address from inet_ntoa() */ 
     188   char   sender_port[10]; 
    183189   int    senderLen; 
    184190   int    on   = 1; 
     
    259265   SocketSysInit(); 
    260266 
    261 /* Create a socket 
    262  *****************/ 
    263    if( ( PassiveSocket = socket_ew( AF_INET, SOCK_STREAM, 0) ) == -1 ) 
    264    { 
    265       logit( "et", "%s(%s): Error opening socket; exiting!\n", Argv0, MyModName ); 
    266       closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW ); 
    267       tport_detach( &Region ); 
    268       free( MsgBuf ); 
    269       return( -1 ); 
    270    } 
    271  
    272 /* Fill in receiver (import_pasv) socket address structure 
    273  **********************************************************/ 
    274    memset( (char *) &skt_rcv, '\0', sizeof(skt_rcv) ); 
    275    skt_rcv.sin_family = AF_INET; 
    276    skt_rcv.sin_port   = htons( (short)ReceiverPort ); 
    277 #if defined(_LINUX) || defined(_MACOSX) 
    278    if ((int)(skt_rcv.sin_addr.s_addr = inet_addr(ReceiverIpAdr)) == -1) 
    279 #else 
    280    if ((int)(skt_rcv.sin_addr.S_un.S_addr = inet_addr(ReceiverIpAdr)) == -1) 
    281 #endif 
    282    { 
    283       logit( "e", "%s(%s): inet_addr failed for ReceiverIpAdr <%s>;" 
    284              " exiting!\n", Argv0, MyModName, ReceiverIpAdr ); 
    285       closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW ); 
    286       tport_detach( &Region ); 
    287       free( MsgBuf ); 
    288       return( -1 ); 
    289    } 
    290   
    291 /* Allow the receiver (import_pasv) to be stopped and restarted 
    292  **************************************************************/ 
    293    on = 1; 
    294    if( setsockopt( PassiveSocket, SOL_SOCKET, SO_REUSEADDR, 
    295                   (char *)&on, sizeof(char *) ) != 0 ) 
    296    { 
    297       logit( "et", "%s(%s): Error on setsockopt; exiting!\n", 
    298              Argv0, MyModName ); 
    299       perror("Export setsockopt"); 
    300       closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW ); 
    301       tport_detach( &Region ); 
    302       free( MsgBuf ); 
    303       return( -1 ); 
    304    } 
    305  
    306 /* Bind socket to a name 
    307  ***********************/ 
    308    if( bind_ew( PassiveSocket, (struct sockaddr *) &skt_rcv, sizeof(skt_rcv)) ) 
    309    { 
    310       logit( "et", "%s(%s): error binding socket; exiting.\n", 
    311              Argv0, MyModName); 
    312       perror( "Export bind error" ); 
    313       closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW ); 
    314       tport_detach( &Region ); 
    315       free( MsgBuf ); 
    316       return( -1 ); 
    317    } 
    318  
    319 /* Prepare for connect requests 
    320  ******************************/ 
    321    if( listen_ew( PassiveSocket, 0 ) ) 
    322    {   
    323       logit( "et", "%s(%s): socket listen error; exiting!\n", 
    324              Argv0, MyModName ); 
    325       closesocket_ew( PassiveSocket, SOCKET_CLOSE_IMMEDIATELY_EW ); 
    326       tport_detach( &Region ); 
    327       free( MsgBuf ); 
    328       return( 1 ); 
     267/* Create and initialize a TCP server socket 
     268 *********************************************/ 
     269   PassiveSocket = setuptcpserver_ew(ReceiverIpAdr, ReceiverPort, 0); 
     270 
     271   if(PassiveSocket < 0) 
     272   { 
     273      logit("et" ,"%s(%s): Error initializing TCP server socket; exiting\n", Argv0, MyModName); 
     274      tport_detach(&Region); 
     275      free(MsgBuf); 
     276      return(-1); 
    329277   } 
    330278 
     
    394342   /* Got a connection! Is the sender who we expect? 
    395343    ************************************************/  
    396       strcpy( sender_ip, inet_ntoa(skt_snd.sin_addr) ); 
    397  
    398       if( !ip_in_same_netmask(sender_ip, SenderIpAdr, SenderNetMask))  
     344      formatsocketaddress_ew((struct sockaddr *)&skt_snd, senderLen, sender_ip, sender_port); 
     345 
     346      //XXX XXX XXX 
     347      // 
     348      //check if sender_ip or SenderIpAdr are both AF_INET[X] 
     349      //if not, raise an error 
     350      //if so, check SenderNetMask 
     351      if( !ip_in_same_subnet(sender_ip, SenderIpAdr, SenderNetMask))  
    399352      { 
    400353         logit( "et", "%s(%s): Connection after %ld sec refused from IP address %s\n", 
     
    658611               if ( Debug ) 
    659612               { 
    660                   logit( "et", "%s(%s): Received Mag, size=%d bytes, MsgHdr: %64s \n", Argv0, MyModName, nchar, &MsgBuf[0] );  
     613                  logit( "et", "%s(%s): Received Mag, size=%ld bytes, MsgHdr: %64s \n", Argv0, MyModName, nchar, &MsgBuf[0] );  
    661614               } 
    662615               import_filter( MsgBuf, nchar ); /* process the message via user-routine */ 
     
    928881                  exit( -1 ); 
    929882                } 
    930                 if( str ) strcpy( ReceiverIpAdr, str ); 
    931                 init[7]=1; 
     883                if( str ) { 
     884                  strncpy( ReceiverIpAdr, str, sizeof(ReceiverIpAdr) ); 
     885                  init[7]=1; 
     886                } 
    932887            } 
    933888 
     
    936891            else if( k_its("ReceiverPort") )  
    937892            { 
    938                 ReceiverPort = k_int(); 
    939                 init[8]=1; 
     893               if((str = k_str()) != NULL) { 
     894                  strncpy(ReceiverPort, str, sizeof(ReceiverPort)); 
     895                  init[8]=1; 
     896               } 
    940897            } 
    941898 
     
    957914            { 
    958915                str=k_str(); 
    959                 if (strlen(str) > MAX_IP_STR) { 
    960                   logit( "e", 
    961                          "%s: Error SenderNetMask string too long for legal netmask <%s>; exiting! Maximum %d chars\n", 
    962                          Argv0, str , MAX_IP_STR-1); 
    963                   exit( -1 ); 
     916                if(str != NULL) { 
     917                    if (strlen(str) > MAX_IP_STR) { 
     918                      logit( "e", 
     919                             "%s: Error SenderNetMask string too long for legal netmask <%s>; exiting! Maximum %d chars\n", 
     920                             Argv0, str , MAX_IP_STR-1); 
     921                      exit( -1 ); 
     922                    } 
    964923                } 
    965924                if( str ) strcpy( SenderNetMask, str ); 
  • trunk/src/data_exchange/import_pasv/makefile.nt

    r6213 r7606  
    3737 
    3838$B\$(APP).exe: $O 
    39    $(link) $(conlflags) $(ldebug) $(conlibsmt) $O $L\socket_ew.obj \ 
    40     $L\mask_check.obj $L\socket_ew_common.obj \ 
     39   $(link) $(conlflags) ws2_32.lib $(ldebug) $(conlibsmt) $O $L\socket_ew.obj \ 
     40    $L\socket_ew_common.obj $L\parse_ip_address.obj \ 
    4141    $L\libew_mt.lib -out:$B\$(APP).exe 
    4242 
  • trunk/src/data_exchange/import_pasv/makefile.unix

    r6209 r7606  
    1212 
    1313BINARIES = import_gen_pasv.o $L/libew_mt.a \ 
    14            $L/socket_ew.o $L/socket_ew_common.o $L/mask_check.o 
     14           $L/socket_ew.o $L/socket_ew_common.o $L/parse_ip_address.o 
    1515           
    1616 
  • trunk/src/data_exchange/liss/e2l_server.c

    r7477 r7606  
    6868   while( pE2L->terminate != 1) 
    6969   { 
    70      if ( ( listenSocket = socket_ew( PF_INET, SOCK_STREAM, 0) )  
    71           == INVALID_SOCKET ) 
    72      { 
    73        logit( "et", "ew2liss: Error listening socket; <%d> exiting!\n", 
    74               socketGetError_ew()); 
    75        pE2L->terminate = 1; 
    76        KillSelfThread(); 
    77      } 
     70      if( (listenSocket = setuptcpserver_ew(pE2L->LISSaddr, pE2L->LISSport, 0)) < 0) 
     71      { 
     72         logit( "et", "ew2liss: Error setting up TCP server %s:%s exiting!\n", pE2L->LISSaddr, pE2L->LISSport); 
     73         pE2L->terminate = 1; 
     74         KillSelfThread(); 
     75      } 
    7876    
    79      /* Allows the server to be stopped and restarted */ 
    80      on=1; 
    81      if( setsockopt( listenSocket, SOL_SOCKET, SO_REUSEADDR,  
    82                      (char *)&on, sizeof(char *) ) != 0 ) 
    83      { 
    84        logit( "et", "ew2liss: Error on setsockopt; <%d>; exiting!\n",  
    85               socketGetError_ew()); 
    86        pE2L->terminate = 1; 
    87        KillSelfThread(); 
    88      } 
    89  
    90      /* Bind socket to a name */ 
    91      if ( bind_ew( listenSocket, (struct sockaddr *) &sin, sizeof(sin)) ) 
    92      { 
    93        logit("et", "ew2liss: error binding socket <%d>; exiting.\n",  
    94              socketGetError_ew()); 
    95        perror("Export bind error"); 
    96        closesocket_ew(listenSocket,SOCKET_CLOSE_IMMEDIATELY_EW); 
    97        pE2L->terminate = 1; 
    98        KillSelfThread(); 
    99      } 
    100       
    101      /* Prepare for connect requests */ 
    102      if ( listen_ew( listenSocket, 0)) 
    103      { 
    104        logit("et", "ew2liss: socket listen error <%d>; exiting!\n",  
    105              socketGetError_ew() ); 
    106        closesocket_ew( listenSocket,SOCKET_CLOSE_IMMEDIATELY_EW ); 
    107        pE2L->terminate = 1; 
    108        KillSelfThread(); 
    109      } 
    110       
    11177     /* Accept a connection */ 
    11278     clientLen = sizeof( client ); 
     
    184150  return( 0 ); 
    185151} 
    186  
    187  
    188  
    189 /* SetAddress: given a LISS domain name or IP address and port number, 
    190    set up the socket address structure. Returns 0 on success, -1 on failure */ 
    191 int SetAddress( struct sockaddr_in *sinP, WORLD E2L) 
    192 { 
    193   unsigned long addr; 
    194   struct hostent* hp; 
    195    
    196   memset((void*)sinP, 0, sizeof(struct sockaddr_in)); 
    197   sinP->sin_family = AF_INET; 
    198   sinP->sin_port = htons((unsigned short)E2L.LISSport); 
    199  
    200   /* Assume we have an IP address and try to convert to network format. 
    201    * If that fails, assume a domain name and look up its IP address. 
    202    * Can't trust reverse name lookup, since some place may not have their 
    203    * name server properly configured.  
    204    */ 
    205   if ( (addr = inet_addr(E2L.LISSaddr)) != INADDR_NONE ) 
    206   { 
    207     sinP->sin_addr.s_addr = addr; 
    208   } 
    209   else 
    210   {       /* it's not a dotted quad IP address */ 
    211     if ( (hp = gethostbyname(E2L.LISSaddr)) == NULL)  
    212     { 
    213       logit("e", "bad server address <%s>\n", E2L.LISSaddr ); 
    214       return( -1 ); 
    215     } 
    216     memcpy((void *) &(sinP->sin_addr), (void*)hp->h_addr, hp->h_length); 
    217   } 
    218   return( 0 ); 
    219    
    220 } 
  • trunk/src/data_exchange/liss/ew2liss.c

    r7523 r7606  
    582582      /* 5 */ else if ( k_its ( "LISSport")) 
    583583      { 
    584         pE2L->LISSport = k_int(); 
    585         if (pE2L->LISSport < 1) 
    586         { 
    587           fprintf(stderr, "LISSport is 0; this won't work.\n"); 
    588           return EW_FAILURE; 
    589         } 
    590         init[5] = 1; 
     584        str = k_str(); 
     585        if ( str != NULL ) { 
     586          strncpy(pE2L->LISSport, str, sizeof(pE2L->LISSport)); 
     587          init[5] = 1; 
     588        } 
    591589      } 
    592590       
  • trunk/src/data_exchange/liss/ew2liss.h

    r205 r7606  
    133133  MSG_LOGO    errLogo; 
    134134  pid_t       MyPid; 
    135   int         LISSport; 
     135  char        LISSport[10]; 
    136136  char        LISSaddr[MAXADDRLEN]; /* IP address or hostname           */ 
    137137  char        seqFile[MAXFILENAMELEN]; /* sequence number memory file   */ 
  • trunk/src/data_exchange/liss/liss2ew.c

    r7028 r7606  
    7777  int   nread, err; 
    7878  /*char  msgText[MAXMESSAGELEN];     string for log/error messages   */ 
    79   struct sockaddr_in sin; 
    8079  time_t  timeNow;                   /* current time                  */  
    8180  time_t  timeLastBeat;              /* time last heartbeat was sent  */ 
     
    9897  /* Initialize the socket system */ 
    9998  SocketSysInit(); 
    100   if ( SetAddress( &sin, L2e ) ) 
    101   { 
    102     logit("e", "%s: error setting LISS address. Exiting\n", argv[0]); 
    103     tport_detach(&(L2e.regionOut)); 
    104     exit( EW_FAILURE ); 
    105   } 
    10699     
    107100  /*    Force a heartbeat to be issued in first pass thru main loop     */ 
     
    122115    { 
    123116    case closed:   /* Open a nonblocking socket for the LISS connection */ 
    124       if ( ( sock = socket_ew( AF_INET, SOCK_STREAM, 0)) == -1 ) 
    125       { 
    126         logit("et", "%s: error opening socket. Exiting\n", argv[0]); 
    127         tport_detach(&(L2e.regionOut)); 
    128         exit( EW_FAILURE ); 
    129       } 
    130       if ( connect_ew( sock, (struct sockaddr*) &sin, sizeof(sin),  
    131                        L2e.sockTimeout ) == -1 ) 
    132       { 
    133         if ( (err = socketGetError_ew() ) != CONNECT_WOULDBLOCK_EW) 
    134         { 
    135           logit("et", "%s: Error connecting to LISS: %s; exiting\n", argv[0], 
    136                 strerror(err)); 
    137           tport_detach(&(L2e.regionOut)); 
    138           exit( EW_FAILURE ); 
    139         } 
    140          
    141         if (L2e.Param.debug) 
    142           logit("et", "no connection\n"); 
    143          
    144         conn_retry++; 
    145         state = closed;   /* connect_ew closed the socket */ 
    146         if (conn_retry > RETRIES_EXIT) 
    147         { 
    148           logit("et", "%s: Still no connection after %d tries, exiting\n", 
    149                 argv[0], conn_retry); 
    150           tport_detach(&(L2e.regionOut)); 
    151           exit( EW_FAILURE ); 
    152         } 
    153  
    154         if (conn_retry > RETRIES_LOG) 
    155         { 
    156           if (reported == conn_fail1) 
    157           { 
    158             logit("et", "%s: no connection after %d tries; still trying.\n", 
    159                   argv[0], conn_retry); 
    160             reported = conn_fail2; 
    161           } 
    162         } 
    163         else 
    164         { 
     117      //XXX: FAIL 
     118      if ( ( sock = setuptcpclient_ew(L2e.LISSaddr, L2e.LISSport, L2e.sockTimeout)) == -2 ) 
     119      { 
     120         logit("et", "%s: error opening socket. Exiting\n", argv[0]); 
     121         tport_detach(&(L2e.regionOut)); 
     122         exit(EW_FAILURE); 
     123      } else if (sock < 0) { 
     124         //assume a problem with connect_ew 
     125 
     126         //check socketGetError_ew(): 
     127         if ( (err = socketGetError_ew() ) != CONNECT_WOULDBLOCK_EW) 
     128         { 
     129            logit("et", "%s: Error connecting to LISS: %s; exiting\n", argv[0], strerror(err)); 
     130            tport_detach(&(L2e.regionOut)); 
     131            exit( EW_FAILURE ); 
     132         } 
     133 
     134         if (L2e.Param.debug) { 
     135            logit("et", "no connection\n"); 
     136         } 
     137 
     138         conn_retry++; 
     139         state = closed;   /* connect_ew closed the socket */ 
     140         if (conn_retry > RETRIES_EXIT) 
     141         { 
     142            logit("et", "%s: Still no connection after %d tries, exiting\n", argv[0], conn_retry); 
     143            tport_detach(&(L2e.regionOut)); 
     144            exit( EW_FAILURE ); 
     145         } 
     146 
     147         if (conn_retry > RETRIES_LOG) 
     148         { 
     149            if (reported == conn_fail1) 
     150            { 
     151               logit("et", "%s: no connection after %d tries; still trying.\n", argv[0], conn_retry); 
     152               reported = conn_fail2; 
     153            } 
     154         } else { 
    165155          reported = conn_fail1; 
    166         } 
     156         } 
    167157      }  
    168158      else 
     
    237227} 
    238228 
    239 /* SetAddress: given a LISS domain name or IP address and port number, 
    240    set up the socket address structure. Returns 0 on success, -1 on failure */ 
    241 int SetAddress( struct sockaddr_in *sinP, WORLD L2e) 
    242 { 
    243   unsigned long addr; 
    244   struct hostent* hp; 
    245   /*int port;*/ 
    246    
    247   memset((void*)sinP, 0, sizeof(struct sockaddr_in)); 
    248   sinP->sin_family = AF_INET; 
    249   sinP->sin_port = (u_short)htons((u_short)L2e.LISSport); 
    250  
    251   /* Assume we have an IP address and try to convert to network format. 
    252    * If that fails, assume a domain name and look up its IP address. 
    253    * Can't trust reverse name lookup, since some place may not have their 
    254    * name server properly configured.  
    255    */ 
    256   if ( (addr = inet_addr(L2e.LISSaddr)) != INADDR_NONE ) 
    257   { 
    258     sinP->sin_addr.s_addr = addr; 
    259   } 
    260   else 
    261   {       /* it's not a dotted quad IP address */ 
    262     if ( (hp = gethostbyname(L2e.LISSaddr)) == NULL)  
    263     { 
    264       logit("e", "bad server address <%s>\n", L2e.LISSaddr ); 
    265       return( -1 ); 
    266     } 
    267     memcpy((void *) &(sinP->sin_addr), (void*)hp->h_addr, hp->h_length); 
    268   } 
    269   return( 0 ); 
    270    
    271 } 
    272  
    273    
    274229/* StatusReport: Send error and hearbeat messages to transport ring     */ 
    275230void StatusReport( WORLD* pL2e, unsigned char type, short code,  
     
    331286  /* Some important initial values or defaults */ 
    332287  pL2e->lenSEED = DEF_LEN_SEED; 
    333   pL2e->LISSport = DEF_LISS_PORT; 
     288  strncpy(pL2e->LISSport, DEF_LISS_PORT, 10); //10 being the size of (LISSport) 
    334289  pL2e->sockTimeout = 0; 
    335290  pL2e->Nscn = 0; 
     
    569524            return EW_FAILURE; 
    570525          } 
    571           strcpy (pL2e->LISSaddr, str); 
     526          strncpy (pL2e->LISSaddr, str, MAXADDRLEN); 
    572527          init[4] = 1; 
    573528        } 
     
    576531      /* 5 */ else if ( k_its ( "LISSport")) 
    577532      { 
    578         pL2e->LISSport = k_int(); 
    579         if (pL2e->LISSport < 1) 
    580         { 
    581           fprintf(stderr, "LISSport is 0; this won't work.\n"); 
    582           return EW_FAILURE; 
    583         } 
    584         init[5] = 1; 
     533         if( (str = k_str()) != NULL ) 
     534         { 
     535            if (strlen(str) >= 10) 
     536            { 
     537               fprintf(stderr, "LISSport too long; max is 10\n"); 
     538               return EW_FAILURE; 
     539            } 
     540            strncpy(pL2e->LISSport, str, 10); 
     541            init[5] = 1; 
     542         } 
    585543      } 
    586544       
  • trunk/src/data_exchange/liss/liss2ew.h

    r1248 r7606  
    3737 
    3838#define DEF_LEN_SEED    512     /* Default packet size from LISS        */ 
    39 #define DEF_LISS_PORT  4000     /* Default TCP port for LISS            */ 
     39#define DEF_LISS_PORT   "4000"  /* Default TCP port for LISS            */ 
    4040 
    4141#define MAXMESSAGELEN   160     /* Maximum length of a status or error  */ 
     
    4545#define MAXMODNAMELEN   30      /* Maximum length of a module name      */ 
    4646                                /* Should be defined by kom.h           */ 
    47 #define MAXADDRLEN      80      /* Length of LISS hostname or address   */ 
     47#define MAXADDRLEN      64      /* Length of LISS hostname or address   */ 
    4848#define MAXFILENAMELEN  100     /* Length of a file name                */ 
    4949#define LC_LEN          4       /* Bytes for the location code          */ 
     
    127127  MSG_LOGO    errLogo; 
    128128  pid_t       MyPid; 
    129   int         LISSport; 
     129  char        LISSport[10]; 
    130130  char        LISSaddr[MAXADDRLEN];   /* IP address or hostname */ 
    131131  int         lenSEED;                /* How many bytes of miniSEED     */ 
  • trunk/src/data_exchange/liss2ew_scnl/TCPSocket.cpp

    r2194 r7606  
    239239 
    240240    return nResult; 
    241 } 
    242  
    243 /** 
    244   * Initializes a socket for receiving connections.  This must be called before calling AcceptConnections. 
    245   * 
    246   * @return 0 if all is well, or SOCKET_ERROR for an error. 
    247   */ 
    248  
    249 int CTCPSocket::InitForListen() 
    250 { 
    251         int retval; 
    252         int errorval; 
    253  
    254         if (!m_bInitialized) 
    255         { 
    256                 reportError(WD_FATAL_ERROR, GENFATERR, "Error: Cannot create socket until address is set via SetAddress\n"); 
    257                 return SOCKET_ERROR; 
    258         } 
    259  
    260         m_bReceiving = true; 
    261  
    262         retval = InitSocket(); 
    263         if (retval != 0) 
    264                 return retval; 
    265  
    266         if (listen_ew(m_socket, 1) == SOCKET_ERROR) 
    267         { 
    268                 errorval = socketGetError_ew(); 
    269                 reportError(WD_FATAL_ERROR, GENFATERR, "Call to listen_ew failed for %s:  Error %d.\n", 
    270                                                 m_ipAddress, errorval); 
    271                 return SOCKET_ERROR; 
    272         } 
    273  
    274         return 0; 
    275 } 
    276  
    277 /** 
    278   * Accepts a connection from a remote socket.  Call this function after calling InitForReceive. 
    279   * If the socket is blocking (timeout == -1), then this function will block until a connection 
    280   * is made.  Otherwise, if no connections were requested it will return WOULDBLOCK_EW. 
    281   * 
    282   * @return error code if no connection was made, or 0 if a connection was made. 
    283   *             error codes:    WOULDBLOCK_EW -  all is well, but no connections were requested 
    284   *                                                             (only happens if m_Timeout != -1) 
    285   *                                             anything else - more serious problem 
    286   */ 
    287 int CTCPSocket::AcceptConnections() 
    288 { 
    289         int socklen = sizeof(sockaddr_in); 
    290         int err; 
    291  
    292         if (!m_bInitialized) 
    293         { 
    294                 reportError(WD_FATAL_ERROR, GENFATERR, "Error: Cannot accept connections until address is set via SetAddress\n"); 
    295                 return SOCKET_ERROR; 
    296         } 
    297  
    298         m_ReadSocket = accept_ew(m_socket, (sockaddr *)&m_ConnectedAddr, &socklen, m_Timeout); 
    299         if (m_ReadSocket == INVALID_SOCKET) 
    300         { 
    301                 err = socketGetError_ew(); 
    302                 if (err != WOULDBLOCK_EW) 
    303                 { 
    304                         reportError( WD_FATAL_ERROR, GENFATERR, "Call to accept_ew failed:  Error %d.\n", 
    305                                                         err ); 
    306                 } 
    307                 return err; 
    308         } 
    309  
    310         m_WriteSocket = m_ReadSocket; 
    311  
    312         strcpy(m_ipAddress, inet_ntoa(m_ConnectedAddr.sin_addr)); 
    313         reportError(WD_DEBUG, 0, "Connection accepted from %s\n", m_ipAddress); 
    314  
    315         return 0; 
    316241} 
    317242 
  • trunk/src/data_exchange/liss2ew_scnl/TCPSocket.h

    r6803 r7606  
    7272        virtual ~CTCPSocket(); 
    7373 
    74         virtual int InitForListen(); 
    7574        virtual int InitForConnect(); 
    76         virtual int AcceptConnections(); 
    7775        virtual int Connect(); 
    7876        virtual int Send(const unsigned char * buffer, unsigned long len); 
  • trunk/src/data_exchange/liss2ew_scnl/liss2ew_scnl.cpp

    r6803 r7606  
    236236        if (pConnInfo->pSocket) 
    237237                delete pConnInfo->pSocket; 
     238 
     239   //XXX XXX XXX 
     240   //XXX 
     241   //put setup() functions in InitForConnect() OR CTCPSocket() 
    238242 
    239243        pConnInfo->pSocket = new CTCPSocket(pConnInfo->IPaddr, pConnInfo->IPport); 
  • trunk/src/data_exchange/seisan_report/seisan_report.c

    r7244 r7606  
    319319                return; 
    320320        } 
    321         logit( "t", "parsed event %ld\n", event[event_index].arc.sum.qid ); 
     321        logit( "t", "parsed event %s\n", event[event_index].qid ); 
    322322         
    323323        /* Put QID in structure separately */ 
  • trunk/src/data_exchange/slink2ew/ChangeLog

    r6896 r7606  
     12018.04.18: version 3.0 
     2         - Upgraded libslink to handle IPv6 
     3 
    142017.01.26: version 2.9 
    25    - Added MseedRing command to redirect/echo output in miniSEED format in 
  • trunk/src/data_exchange/slink2ew/libslink/ChangeLog

    r6840 r7606  
     12018.106: version 3.0 
     2        - Upgraded libslink to handle IPv6 connections. All platforms now using 
     3        getaddrinfo() for name resolution 
     4 
    152016.290: version 2.6 
    26        - Change host name resolution to use getaddrinfo() on all platforms 
  • trunk/src/data_exchange/slink2ew/libslink/libslink.h

    r7464 r7606  
    3232#include "slplatform.h" 
    3333 
    34 #define LIBSLINK_VERSION "2.6" 
    35 #define LIBSLINK_RELEASE "2016.290" 
     34#define LIBSLINK_VERSION "3.0" 
     35#define LIBSLINK_RELEASE "2018.106" 
    3636 
    3737#define SLRECSIZE           512      /* Default Mini-SEED record size */ 
  • trunk/src/data_exchange/slink2ew/libslink/network.c

    r6839 r7606  
    1818#include <stdlib.h> 
    1919#include <string.h> 
     20 
     21#include <parse_ip_address.h> 
    2022 
    2123#include "libslink.h" 
     
    650652  char nodename[300]; 
    651653  char nodeport[100]; 
     654  char hostStr[64] = {0}; 
     655  char portStr[10] = {0}; 
     656  int isIPv6 = 0; 
    652657  char *ptr, *tail; 
    653   size_t addrlen; 
    654   struct sockaddr addr; 
     658  int err = 0; 
    655659 
    656660  if (slp_sockstartup ()) 
     
    677681  else 
    678682  { 
    679     if (ptr == slconn->sladdr) 
    680     { 
    681       strcpy (nodename, "localhost"); 
    682     } 
    683     else 
    684     { 
    685       strncpy (nodename, slconn->sladdr, (ptr - slconn->sladdr)); 
    686       nodename[(ptr - slconn->sladdr)] = '\0'; 
    687     } 
    688  
    689     strcpy (nodeport, ptr + 1); 
     683    //just get the {host, port} from parse_ip_address_string(): 
     684    if(parse_ip_address_string(slconn->sladdr, hostStr, portStr, &isIPv6) <= 0) { 
     685      sl_log_r (slconn, 2, 0, "Error parsing address and port\n"); 
     686      slconn->terminate = 1; 
     687      return -1; 
     688    } else { 
     689      strncpy(nodename, hostStr, sizeof(hostStr)); 
     690      strncpy(nodeport, portStr, sizeof(portStr)); 
     691    } 
    690692 
    691693    /* Sanity test the port number */ 
    692694    nport = strtoul (nodeport, &tail, 10); 
    693     if (*tail || (nport <= 0 || nport > 0xffff)) 
    694     { 
    695       sl_log_r (slconn, 2, 0, "server port specified incorrectly\n"); 
     695    if(nport == 0) { 
     696      strncpy(nodeport, "18000", strlen("18000")+1); 
     697    } 
     698    if (*tail || (nport < 0 || nport > 0xffff)) 
     699    { 
     700      sl_log_r (slconn, 2, 0, "server port (%lu) specified incorrectly\n", nport); 
    696701      slconn->terminate = 1; 
    697702      return -1; 
     
    699704  } 
    700705 
    701   if (slp_getaddrinfo (nodename, nodeport, &addr, &addrlen)) 
    702   { 
    703     sl_log_r (slconn, 2, 0, "cannot resolve hostname %s\n", nodename); 
    704     return -1; 
    705   } 
    706  
    707   if ((sock = socket (PF_INET, SOCK_STREAM, 0)) < 0) 
     706   //setup TCP socket connection!! 
     707   sock = slp_setuptcpclient(nodename, nodeport); 
     708 
     709  if(sock == -4) { 
     710   sl_log_r (slconn, 2, 0, "cannot resolve hostname %s\n", nodename); 
     711   return -1; 
     712  } 
     713 
     714  if (sock == -3) 
    708715  { 
    709716    sl_log_r (slconn, 2, 0, "[%s] socket(): %s\n", slconn->sladdr, slp_strerror ()); 
     
    713720 
    714721  /* Set non-blocking IO */ 
    715   if (slp_socknoblock (sock)) 
     722  if (sock == -2) 
    716723  { 
    717724    sl_log_r (slconn, 2, 0, "Error setting socket to non-blocking\n"); 
    718725  } 
    719726 
    720   if ((slp_sockconnect (sock, (struct sockaddr *)&addr, addrlen))) 
     727  if (sock == -1) 
    721728  { 
    722729    sl_log_r (slconn, 2, 0, "[%s] connect(): %s\n", slconn->sladdr, slp_strerror ()); 
  • trunk/src/data_exchange/slink2ew/libslink/slplatform.c

    r6840 r7606  
    1717#include "libslink.h" 
    1818 
     19/************************************************************************** 
     20 * slp_setuptcpclient: 
     21 *  
     22 *  setup a TCP client connection. 
     23 * 
     24 *  if successful, returns valid socket descriptor 
     25 *  if getaddrinfo() fails, return -4 
     26 *  if socket() fails, return -3 
     27 *  if slp_socknoblock() fails, return -2 
     28 *  if socket() succeeds but connect() fails, return -1 
     29 * 
     30 **************************************************************************/ 
     31SOCKET slp_setuptcpclient(const char *host, const char *service) 
     32{ 
     33  struct addrinfo addrCriteria;                 //Criteria for address match 
     34  memset(&addrCriteria, 0, sizeof(addrCriteria)); 
     35  addrCriteria.ai_family = AF_UNSPEC;           //v4 or v6 OK 
     36  addrCriteria.ai_socktype = SOCK_STREAM;       //only streaming sockets 
     37  addrCriteria.ai_protocol = IPPROTO_TCP;       //TCP protocol 
     38  int socketEstablished = 0;  
     39  struct addrinfo *addr = NULL; 
     40  char dupAddress[300]; 
     41 
     42  // Get address(es) 
     43  struct addrinfo *servAddr;              //holder for list of servers addresses 
     44  int rtnVal = getaddrinfo(host, service, &addrCriteria, &servAddr); 
     45  if (rtnVal != 0) { 
     46    sl_log_r(NULL, 1, 1, "getaddrinfo() failed!\n"); 
     47    return -3; 
     48  } 
     49 
     50  int sock = -1; 
     51  for (addr = servAddr; addr != NULL; addr = addr->ai_next) { 
     52    // check for 'link-local' addresses (IPv6) 
     53    if(addr->ai_family == AF_INET6) { 
     54      if(getnameinfo(addr->ai_addr, addr->ai_addrlen, dupAddress, sizeof(dupAddress), NULL, 0, NI_NUMERICHOST) == 0) { 
     55        if(strncmp(dupAddress, "fe80", strlen("fe80")) == 0) { 
     56          //set the scope to '2' for link local: 
     57          ((struct sockaddr_in6 *)(addr->ai_addr))->sin6_scope_id = 2; 
     58        } 
     59      } 
     60    } 
     61    //Create TCP stream socket: 
     62    sock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 
     63    if (sock < 0) 
     64      continue;   //socket creation failed; try next address 
     65 
     66    socketEstablished = 1; //save this state for later 
     67 
     68    if (slp_socknoblock(sock)) { 
     69      //this is an error! 
     70      return -2; 
     71    } 
     72 
     73    if ( slp_sockconnect(sock, addr->ai_addr, addr->ai_addrlen) == 0) 
     74      break;         //connection established, break and return 
     75 
     76    sock = -1; 
     77  } 
     78 
     79  if(!socketEstablished) { 
     80    sl_log_r(NULL, 1, 1, "socket not established\n"); 
     81    sock = -3; 
     82  } 
     83 
     84   freeaddrinfo(servAddr); 
     85 
     86  return sock; 
     87} 
    1988/*************************************************************************** 
    2089 * slp_sockstartup: 
  • trunk/src/data_exchange/slink2ew/libslink/slplatform.h

    r6840 r7606  
    138138#endif 
    139139 
     140extern SOCKET slp_setuptcpclient(const char *host, const char *service); 
    140141extern int slp_sockstartup (void); 
    141142extern int slp_sockconnect (SOCKET sock, struct sockaddr * inetaddr, int addrlen); 
     
    150151extern void slp_usleep(unsigned long int useconds); 
    151152 
     153 
    152154#ifdef __cplusplus 
    153155} 
  • trunk/src/data_exchange/slink2ew/makefile.nt

    r6329 r7606  
    1414 
    1515EW_LIBS = $L\getutil.obj $L\socket_ew.obj $L\socket_ew_common.obj \ 
    16     $L\libew_mt.lib $L\swap.obj \ 
     16    $L\libew_mt.lib $L\swap.obj $L\parse_ip_address.obj \ 
    1717    $L\mem_circ_queue.obj $L\libmseed.lib 
    1818 
  • trunk/src/data_exchange/slink2ew/makefile.unix

    r6131 r7606  
    1616 
    1717EWLIBS = $L/libew_mt.a $L/socket_ew_common.o \ 
    18          $L/socket_ew.o $L/swap.o \ 
     18         $L/socket_ew.o $L/swap.o $L/parse_ip_address.o \ 
    1919         $L/mem_circ_queue.o $L/libmseed.a 
    2020 
  • trunk/src/data_exchange/slink2ew/slink2ew.c

    r7464 r7606  
    567567  int     success; 
    568568 
    569   int    slport = 0; 
     569  char  *slport = 0; 
    570570  char  *slhost = 0; 
    571571  char   sladdr[100]; 
     
    694694          else if ( k_its ("SLport")) 
    695695            { 
    696               slport = k_int(); 
    697               if (slport < 1) 
    698                 { 
    699                   fprintf(stderr, "SLport is 0 or junk, quiting.\n"); 
    700                   return EW_FAILURE; 
    701                 } 
     696          if ( (str = k_str()) ) 
     697 
     698                  { 
     699          if (strlen(str) >= MAXADDRLEN) { 
     700                      fprintf(stderr, "SLport too long; quiting.\n"); 
     701                      return EW_FAILURE;  
     702          } 
     703          slport = strdup(str); 
     704                   } 
    702705            } 
    703706 
     
    944947 
    945948  /* Configure the SeedLink connection description thing */ 
    946   snprintf (sladdr, sizeof(sladdr), "%s:%d", slhost, slport); 
     949  snprintf (sladdr, sizeof(sladdr), "%s:%s", slhost, slport); 
    947950  slconn->sladdr = strdup(sladdr); 
    948951 
  • trunk/src/data_exchange/slink2ew/slink2ew.h

    r7102 r7606  
    55#define __SLINK2EW__ 
    66 
    7 #define VERSION "2.9" 
     7#define VERSION "3.0" 
    88 
    99#define MAXMESSAGELEN   160     /* Maximum length of a status or error  */ 
     
    1313#define MAXMODNAMELEN   30      /* Maximum length of a module name      */ 
    1414                                /* Should be defined by kom.h           */ 
    15 #define MAXADDRLEN      80      /* Length of SeedLink hostname/address  */ 
     15#define MAXADDRLEN      100     /* Length of SeedLink hostname/address  */ 
    1616 
    1717 
  • trunk/src/data_sources/k2ew/getconfig.c

    r7371 r7606  
    274274             return -1; 
    275275           } 
     276           if ( (str = k_str()) != 0 ) 
     277           { 
     278             if (strlen(str) >= sizeof(gen_io.tcp_io.k2_port) - 1) 
     279             { 
     280               fprintf(stderr, "%s: TcpPort name too long; max is %zd\n", 
     281                       g_progname_str, sizeof(gen_io.tcp_io.k2_port)); 
     282               return -1; 
     283             } 
     284             strcpy(gen_io.tcp_io.k2_port, str); 
     285             init[1] = 1; 
     286           }            
     287           #if 0 
    276288           if((gen_io.tcp_io.k2_port=k_long()) < 1024L || 
    277289              gen_io.tcp_io.k2_port > 100000L) 
     
    282294           } 
    283295           init[1] = 1; 
     296           #endif 
    284297         } 
    285298 
  • trunk/src/data_sources/k2ew/k2c_tcp.c

    r6803 r7606  
    8080 
    8181static SOCKET sfd;                  /* Our socket */ 
    82 struct sockaddr_in saddr;           /* socket address structure  */ 
     82static char K2Addr[64];             /* initialized during socket setup */ 
     83static char K2Port[16]; 
    8384static int sockInit = 0;            /* Socket System init flag */ 
    8485 
     
    119120    SocketSysInit();   /* This exits on failure */ 
    120121 
    121     /* Set the socket address structure */ 
    122     memset(&saddr, 0, sizeof(struct sockaddr_in)); 
    123     saddr.sin_family = AF_INET; 
    124     saddr.sin_port = htons((unsigned short)pgen_io->tcp_io.k2_port); 
    125  
    126     /* Assume we have an IP address and try to convert to network format. 
    127      * If that fails, assume a domain name and look up its IP address. 
    128      * Can't trust reverse name lookup, since some place may not have their 
    129      * name server properly configured. 
    130      */ 
    131     if ( (addr = inet_addr(pgen_io->tcp_io.k2_address)) != INADDR_NONE ) 
    132     { 
    133       saddr.sin_addr.s_addr = addr; 
    134     } 
    135     else 
    136     {       /* it's not a dotted quad IP address */ 
    137       if ( (hp = gethostbyname(pgen_io->tcp_io.k2_address)) == NULL) 
    138       { 
    139         logit("et", "k2c_init_io: invalid K2 address <%s>\n", 
    140               pgen_io->tcp_io.k2_address); 
    141         return K2R_ERROR; 
    142       } 
    143       memcpy((void *) &saddr.sin_addr, (void*)hp->h_addr, hp->h_length); 
    144     } 
     122    /* 
     123     * Save variables in case we need to redo the connection 
     124     *********************************************************/ 
     125    strncpy(K2Addr, pgen_io->tcp_io.k2_address, sizeof(K2Addr)); 
     126    strncpy(K2Port, pgen_io->tcp_io.k2_port, sizeof(K2Port)); 
    145127    sockInit = 1; 
    146128  } 
     
    148130/* Loop until connect() succeeds 
    149131   *****************************/ 
    150   while ( 1 ) 
    151   { 
    152      g_mt_working = 1;     /* Keep sending heartbeats */ 
    153  
    154      if ( (sfd = socket_ew(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR) 
    155      { 
    156        ew_fmt_err_msg(socketGetError_ew(), errormsg, MAX_ERR_MSG); 
    157        logit("et", "k2c_init_io: error opening socket: %s\n", 
    158              errormsg); 
    159        return K2R_ERROR; 
    160      } 
    161  
    162      if (connect_ew(sfd, (struct sockaddr *)&saddr, sizeof(struct sockaddr), 
    163                     toutms) != -1) 
    164         break;                        /* connect() succeeded */ 
    165  
    166      sfd = INVALID_SOCKET;            /* connect_ew closes socket on error */ 
    167      if ( (error = GetLastError_ew()) == CONNECT_WOULDBLOCK_EW) 
    168      { 
    169        logit("et", "k2c_init_io: Timed out making connection to K2\n"); 
    170        if ( !gcfg_dont_quit ) return K2R_TIMEOUT; 
    171      } 
    172      else 
    173      { 
    174        ew_fmt_err_msg(socketGetError_ew(), errormsg, MAX_ERR_MSG); 
    175        logit("et", "k2c_init_io: Error making TCP connection to K2: %s\n", 
    176              errormsg); 
    177        if ( !gcfg_dont_quit ) return K2R_ERROR; 
    178      } 
     132   while ( 1 ) 
     133   { 
     134      g_mt_working = 1;     /* Keep sending heartbeats */ 
     135       
     136      if ( (sfd = setuptcpclient_ew(K2Addr, K2Port, toutms)) > 0) 
     137      { 
     138         break; 
     139      } else { 
     140         logit("et", "k2c_init_io: error setting up TCP client socket\n"); 
     141         return K2R_ERROR; 
     142      } 
     143 
    179144     sleep_ew( toutms ); 
    180145  } 
     
    536501      logit("et", "Opening socket\n"); 
    537502 
    538     if ( (sfd = socket_ew(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR) 
     503    if ( (sfd = setuptcpclient_ew(K2Addr, K2Port, K2C_RD_SOCK_MS)) < 0) 
    539504    { 
    540505      ew_fmt_err_msg(socketGetError_ew(), errormsg, MAX_ERR_MSG); 
    541       logit("et", "redo_socket: Error opening socket: %s\n", 
    542             errormsg); 
     506      logit("et", "redo_socket: Error reestablishing TCP client connection: %s\n", errormsg); 
    543507      return K2R_ERROR; 
    544     } 
    545  
    546     if (connect_ew(sfd, (struct sockaddr *)&saddr, sizeof(struct sockaddr), 
    547                    K2C_RD_SOCK_MS) == -1) 
    548     { 
    549       sfd = INVALID_SOCKET;          /* connect_ew closes socket on error */ 
    550       if ( (error = socketGetError_ew()) != CONNECT_WOULDBLOCK_EW) 
    551       { 
    552         ew_fmt_err_msg(error, errormsg, MAX_ERR_MSG); 
    553         logit("et", "redo_socket: Error reconnecting to K2: %d %s\n", 
    554               error, errormsg); 
    555         if ( !gcfg_dont_quit ) return K2R_ERROR; 
    556         if ( g_terminate_flg ) return K2R_ERROR; 
    557       } /* connection timed out; try again */ 
    558508    } 
    559509    else   /* connection made, return OK */ 
  • trunk/src/data_sources/k2ew/k2comif.h

    r6094 r7606  
    3737{ 
    3838  char k2_address[KC_MAX_ADDR_LEN];  /* domain name or IP address */ 
    39   int k2_port;                       /* tcp port number           */ 
     39  char k2_port[10];                       /* tcp port number           */ 
    4040} s_tcp_io; 
    4141 
  • trunk/src/data_sources/k2ew/k2ewmain.c

    r7541 r7606  
    17471747      break; 
    17481748    case IO_TCP: 
    1749       logit("e", "Using TCP address <%s> and port %d\n", 
     1749      logit("e", "Using TCP address <%s> and port %s\n", 
    17501750            gen_io.tcp_io.k2_address, gen_io.tcp_io.k2_port ); 
    17511751      break; 
  • trunk/src/data_sources/samtac2ew/getconfig.c

    r7083 r7606  
    239239                                        return -1; 
    240240                                } 
     241                if ( (str = k_str()) != 0 ) 
     242                                { 
     243                                        if (strlen(str) >= sizeof(gen_io.tcp_io.samtac_port) - 1) 
     244                                        { 
     245                                                fprintf(stderr, "%s: TcpPort name too long; max is %d\n", 
     246                                                        g_progname_str, sizeof(gen_io.tcp_io.samtac_port) - 1); 
     247                                                return -1; 
     248                                        } 
     249                                        strcpy(gen_io.tcp_io.samtac_port, str); 
     250                                        init[1] = 1; 
     251                                } 
     252                #if 0 
    241253                                if((gen_io.tcp_io.samtac_port=k_long()) < 1024L || 
    242254                                        gen_io.tcp_io.samtac_port > 100000L) 
     
    247259                                } 
    248260                                init[1] = 1; 
     261                #endif 
    249262                        } 
    250263                        else if ( k_its( "DeviceID" ) ) 
  • trunk/src/data_sources/samtac2ew/samtac2c_tcp.c

    r7083 r7606  
    9292 
    9393static SOCKET sfd;                  /* Our socket */ 
    94 struct sockaddr_in saddr;           /* socket address structure  */ 
     94static char SamtacAddr[64];         // Initialized during setup, 
     95static char SamtacPort[16];         // allows us to redo the connection later    
    9596static int sockInit = 0;            /* Socket System init flag */ 
    9697 
     
    130131    SocketSysInit();   /* This exits on failure */ 
    131132 
    132     /* Set the socket address structure */ 
    133     memset(&saddr, 0, sizeof(struct sockaddr_in)); 
    134     saddr.sin_family = AF_INET; 
    135     saddr.sin_port = htons((unsigned short)gen_io->tcp_io.samtac_port); 
    136  
    137     /* Assume we have an IP address and try to convert to network format. 
    138      * If that fails, assume a domain name and look up its IP address. 
    139      * Can't trust reverse name lookup, since some place may not have their 
    140      * name server properly configured. 
    141      */ 
    142     if ( (addr = inet_addr(gen_io->tcp_io.samtac_address)) != INADDR_NONE ) 
    143     { 
    144       saddr.sin_addr.s_addr = addr; 
    145     } 
     133    /* Variables saved in case we need to redo the connection later */ 
     134    strncpy(SamtacAddr, gen_io->tcp_io.samtac_address, sizeof(SamtacAddr)); 
     135    strncpy(SamtacPort, gen_io->tcp_io.samtac_port, sizeof(SamtacPort)); 
    146136    sockInit = 1; 
    147137  } 
     
    153143    // g_mt_working = 1;     /* Keep sending heartbeats */ 
    154144 
    155      if ( (sfd = socket_ew(AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR) 
     145     if ( (sfd = setuptcpclient_ew(SamtacAddr, SamtacPort, toutms)) < 0) 
    156146     { 
    157147       ew_fmt_err_msg(socketGetError_ew(), errormsg, MAX_ERR_MSG); 
    158        logit("et", "samtac2ew_init_io: error opening socket: %s\n", 
     148       logit("et", "samtac2ew_init_io: error setting up TCP client connection: %s\n", 
    159149             errormsg); 
    160150       return SAMTAC2R_ERROR; 
     151     } else { 
     152         break; 
    161153     } 
    162  
    163      if (connect_ew(sfd, (struct sockaddr *)&saddr, sizeof(struct sockaddr), 
    164                     toutms) != -1) 
    165         break;                        /* connect() succeeded */ 
    166154 
    167155     sfd = INVALID_SOCKET;            /* connect_ew closes socket on error */ 
  • trunk/src/data_sources/samtac2ew/samtac_comif.h

    r3536 r7606  
    4949{ 
    5050  char samtac_address[KC_MAX_ADDR_LEN];  /* domain name or IP address */ 
    51   int samtac_port;                       /* tcp port number           */ 
     51  char samtac_port[10];                  /* tcp port number           */ 
    5252} s_tcp_io; 
    5353 
  • trunk/src/data_sources/srpar2ew/srpar2ew.c

    r7308 r7606  
    20602060          { 
    20612061             if ( Debug >= 2 ) 
    2062                 logit( "", "First time data, deleay mark 0x%lX found at point %ld\n", 
     2062                logit( "", "First time data, delay mark 0x%lX found at point %ld\n", 
    20632063                       *dataGpsPtr, j+1 ); 
    20642064 
     
    28162816    if ( Debug >= 5 )  logit( "", "Now Writing = %p\n", AtodBufferWrite ); 
    28172817 
    2818  
    28192818    istartpt = 0; 
    28202819    ichan    = 0; 
  • trunk/src/data_sources/winsdr2ew/Ws2Ew.c

    r5670 r7606  
    120120                if( tm > lastUpdateTime ) 
    121121                        lastUpdateTime = tm; 
    122          
    123                 curTimeRef = pHdr->timeRefStatus; 
    124122                 
    125123                /* Fill the trace buffer header */ 
     
    298296        pUI->updateTime = time( 0 ); 
    299297         
    300         LogWriteThread("Connected to WinSDR at %s:%d", pUI->who, Port ); 
     298        LogWriteThread("Connected to WinSDR at %s:%s", pUI->who, Port ); 
    301299        LogWriteThread("Settings: %s", pUI->inData ); 
    302300        strncpy( pUI->settings, pUI->inData, 255 ); 
     
    385383                pUI->sock = SOCKET_ERROR; 
    386384                pUI->pCI = 0; 
    387                 strcpy( pUI->who, Host ); 
     385                strncpy( pUI->who, Host, sizeof(pUI->who) ); 
    388386                return pUI; 
    389387        } 
     
    449447thr_ret ListenThread( void *parm ) 
    450448{ 
    451         int err, retval, timeout, addrSize = sizeof(struct sockaddr_in); 
     449        int err, retval, timeout, addrSize = sizeof(struct sockaddr_storage); 
    452450        struct timeval wait; 
    453         struct sockaddr_in localAddr, peer; 
     451        struct sockaddr_storage peer; 
    454452        fd_set rfds, wfds; 
    455453        UserInfo *pUI; 
     
    458456         
    459457        listenRestartTime = time( 0 ); 
    460                  
    461         if( ( listenSock = socket_ew( AF_INET, SOCK_STREAM, 0)) == -1 )  { 
    462                 LogWriteThread( "Error Opening Socket. Exiting" ); 
    463                 ReportError( 7, "Socket Error"); 
    464                 KillListenThread(); 
    465                 return; 
    466         } 
    467          
    468         memset( &localAddr, 0, sizeof(localAddr) ); 
    469          
    470         localAddr.sin_port = htons( Port ); 
    471         localAddr.sin_family = AF_INET; 
    472         localAddr.sin_addr.s_addr = htonl(INADDR_ANY); 
    473                  
    474         if( ( err = bind_ew(listenSock, (struct sockaddr *)&localAddr, sizeof(localAddr))) == SOCKET_ERROR )  { 
    475                 LogWriteThread( "TCP/IP Socket Bind Failed" ); 
    476                 ReportError( 7, "Socket Error"); 
    477                 KillListenThread(); 
    478                 goto end; 
    479         } 
    480                  
    481         if( listen_ew( listenSock, 1 ) == SOCKET_ERROR)  { 
    482                 ReportError( 7, "Socket Error"); 
    483                 LogWriteThread( "TCP/IP Couldn't Get Listen Socket" ); 
    484                 KillListenThread(); 
    485                 goto end; 
    486         } 
    487          
     458         
     459   //attempt to bind to all IPv6 addresses: 
     460   if( ( listenSock = setuptcpserver_ew("::", Port, 1) ) < 0) { 
     461      //check if we can bind to all IPv4 addresses: 
     462      if( ( listenSock = setuptcpserver_ew("0.0.0.0", Port, 1) ) < 0) { 
     463         LogWriteThread( "Error setting up TCP server connection. Exiting" ); 
     464         ReportError( 7, "Socket Error"); 
     465         KillListenThread(); 
     466         return; 
     467      } 
     468   } 
     469 
    488470        sampleCount = 0; 
    489471         
     
    561543        pUI->connecting = TRUE; 
    562544 
    563         if( ( pUI->sock = socket_ew( AF_INET, SOCK_STREAM, 0)) == SOCKET_ERROR )  { 
    564                 LogWriteThread("Error Opening Socket. Exiting" ); 
    565                 ReportError( 7, "Socket Error"); 
    566                 pUI->updateTime = pUI->connectTime = 0; 
    567                 KillReceiveThread( pUI ); 
    568                 goto end; 
    569         } 
    570         if( connect_ew( pUI->sock, (struct sockaddr*) &saddr, sizeof(saddr), SocketTimeout ) == SOCKET_ERROR )  { 
    571                 LogWriteThread("Error Connecting to %s; Exiting", pUI->who ); 
    572                 ReportError( 7, "Socket Error"); 
    573                 pUI->updateTime = pUI->connectTime = 0; 
    574                 KillReceiveThread( pUI ); 
    575                 goto end; 
    576         } 
     545   if( ( pUI->sock = setuptcpclient_ew( Host, Port, SocketTimeout)) < 0) { 
     546      LogWriteThread("Error setting up TCP client. Exiting" ); 
     547      ReportError( 7, "Socket Error"); 
     548      pUI->updateTime = pUI->connectTime = 0; 
     549      KillReceiveThread( pUI ); 
     550      goto end;  
     551   } 
     552 
    577553        pUI->updateTime = pUI->connectTime = time( 0 ); 
    578554        if( !ListenMode ) 
     
    868844        Heartbeat( start_time ); 
    869845 
    870         /* Init tcp stuff */ 
    871         if( !InitSocket() )  { 
    872                 tport_detach( &OutRegion ); 
    873                 LogWrite( "", "InitSocket Error\n" ); 
    874                 return 0; 
    875         } 
    876  
    877846        /* Init queue stuff. One for the EW ring receive data thread and the other for messages */ 
    878847        initqueue( &tbQ, 10, 4096 ); 
     
    905874        for( i = 0; i != MAX_CONNECT_USERS; i++ )  { 
    906875                pCI = &connectInfo[ i ]; 
    907                 if( !strcmp( pUI->who, pCI->who ) )  { 
     876                if( !strncmp( pUI->who, pCI->who, sizeof(pUI->who) ) )  { 
    908877                        return pCI; 
    909878                } 
     
    916885                pCI = &connectInfo[ i ]; 
    917886                if( !pCI->who[0] )  { 
    918                         strcpy( pCI->who, pUI->who ); 
     887                        strncpy( pCI->who, pUI->who, sizeof(pCI->who) ); 
    919888                        pCI->connectCount = 0; 
    920889                        return pCI; 
  • trunk/src/data_sources/winsdr2ew/Ws2Ew.h

    r5094 r7606  
    103103extern SCNL ChanList[ MAX_CHAN_LIST]; // Array to fill with SCNL values 
    104104extern int  HeartbeatInt;       // Heartbeat interval in seconds 
    105 extern int Port;                                // Port number 
     105extern char Port[16];                           // Port number 
    106106extern int SocketTimeout;               // Time in milliseconds 
    107107extern int NoDataWaitTime;              // Time to wait for no data. If no data reset recv thread. In seconds. 
     
    112112extern pid_t MyPid;                             // process id, sent with heartbeat 
    113113extern HANDLE outHandle;                // The console file handle 
    114 extern struct sockaddr_in saddr; // Socket address structure 
    115114extern int ListenMode;                  // if TRUE listen for connections 
    116115extern int SendAck;                             // if TRUE send ack packet after receiving n packets 
     
    134133void ReportError( int errNum, char *errmsg, ... ); 
    135134double CalcPacketTime( SYSTEMTIME *, int filterDelay ); 
    136 int InitSocket(); 
    137135int StartReceiveThread(); 
    138136int GetInQueue( BYTE * ); 
  • trunk/src/data_sources/winsdr2ew/Ws2EwUtils.c

    r5405 r7606  
    1313#include <stdarg.h> 
    1414#include "Ws2Ew.h" 
    15  
    16 struct sockaddr_in saddr;   // Socket address structure 
    1715 
    1816#ifdef WIN32 
     
    177175} 
    178176 
    179 int InitSocket() 
    180 { 
    181         struct hostent *hp; 
    182         int addr; 
    183  
    184         SocketSysInit();   /* This exits on failure */ 
    185  
    186         /* Set the socket address structure */ 
    187         memset(&saddr, 0, sizeof(struct sockaddr_in)); 
    188         saddr.sin_family = AF_INET; 
    189         saddr.sin_port = htons( (unsigned short)Port ); 
    190  
    191         if( ( addr = inet_addr( Host ) ) != INADDR_NONE ) 
    192                 saddr.sin_addr.s_addr = addr; 
    193         else  { 
    194                 if( ( hp = gethostbyname( Host ) ) == NULL)  { 
    195                         LogWrite( "e", "Invalid Host Address <%s>\n", Host ); 
    196                         return FALSE; 
    197                 } 
    198                 memcpy((void *) &saddr.sin_addr, (void*)hp->h_addr, hp->h_length); 
    199         } 
    200         return TRUE; 
    201 } 
    202  
    203177void LogWrite( char *type, char *pszFormat, ...) 
    204178{ 
  • trunk/src/data_sources/winsdr2ew/getconfig.c

    r5094 r7606  
    1212unsigned char ModuleId;         // Module id of this program 
    1313char Host[256];                         // Host name or IP Address of WinSDR system 
    14 int Port;                                       // Port to use when connection to WinSDR 
     14char Port[16];                                  // Port to use when connection to WinSDR 
    1515int     ChanRate;                               // Rate in samples per second per channel 
    1616long OutKey;                            // Key to ring where traces will live 
     
    167167                        else if ( k_its( "Host" ) )  { 
    168168                                str = k_str(); 
    169                                 strcpy( Host, str ); 
     169                                if(str) strncpy( Host, str, sizeof(Host) ); 
    170170                                init[1] = 1; 
    171171                        } 
    172172                        else if ( k_its( "Port" ) )  { 
    173                                 Port = k_int(); 
     173            str = k_str(); 
     174            if(str) strncpy(Port, str, sizeof(Port)); 
    174175                                init[2] = 1; 
    175176                        } 
     
    275276        logit( "", "ListenMode:      %d\n", ListenMode ); 
    276277        logit( "", "Host:            %s\n", Host ); 
    277         logit( "", "Port:            %d\n", Port ); 
     278        logit( "", "Port:            %s\n", Port ); 
    278279        logit( "", "OutKey:          %d\n", OutKey ); 
    279280        logit( "", "HeartbeatInt:    %d\n", HeartbeatInt ); 
  • trunk/src/diagnostic_tools/findwave/findwave.c

    r7386 r7606  
    490490        if (totalMB > 1073) /* 1 GB = 1073741824, max ws tank size = 1073741823 */ 
    491491        { 
    492           logit("","# size for (%s:%s:%s:%s) is %dMB.  Truncating to 1GB.",  
     492          logit("","# size for (%s:%s:%s:%s) is %dMB.  Truncating to 1GB.\n",  
    493493            SCNLtable[i].TrHdr.sta, SCNLtable[i].TrHdr.chan,  
    494494            SCNLtable[i].TrHdr.net, loc, 
  • trunk/src/diagnostic_tools/getmenu/getmenu.c

    r5298 r7606  
    5050#include <earthworm.h> 
    5151#include <ws_clientII.h> 
     52#include <socket_ew.h> 
     53#include <parse_ip_address.h> 
    5254#include <stdlib.h> 
    5355#include <ctype.h> 
     
    5860 
    5961#define MAX_WAVESERVERS   10 
    60 #define MAX_ADRLEN        20 
     62#define MAX_ADRLEN        64 
    6163#define MAX_ADRCMDLEN     255 
    6264#define MAXTXT           150 
     
    275277void Add2ServerList( char * addr_port ) 
    276278{ 
    277   char c; 
    278   char addr[MAXTXT], port[MAX_ADRLEN]; 
    279   char *addr_p; 
    280   int is_port = 0;   /* flag to say we are looking at the port number */ 
    281   int i = 0; 
    282   int a = 0, p = 0; 
    283   struct hostent  *host; 
    284   struct in_addr addr_s; 
    285  
    286   /* scan the input string for format address:port */ 
    287   while ((c = addr_port[i++]) != (char) 0 ) { 
    288     if (a == MAXTXT) { 
    289       fprintf(stderr, "getmenu: hostname <%s> too long; max is %d\n", addr, 
    290             MAXTXT - 1); 
     279  int isIPv6 = 0; 
     280  enum ip_format parseResult = 0; 
     281  //call parse_ip_address_string() 
     282  if((parseResult = parse_ip_address_string(addr_port, wsIp[numserv], wsPort[numserv], &isIPv6)) <= 0) { 
     283      logit("e", "getmenu: failed to parse IP address %s. Parse result: %s\n",  
     284                      addr_port, get_ip_format_string(parseResult)); 
    291285      return; 
    292     } 
    293     if ( is_port == 0 ) { 
    294       if ( c == ':') {   /* end of address, start of port# */ 
    295         addr[a++] = '\0'; 
    296         is_port = 1; 
    297         continue; 
    298       } else {    /* a hostname or IP address */ 
    299         addr[a++] = c; 
    300         continue; 
    301       } 
    302     } else {     /* looking at port number */ 
    303       if ( isdigit(c) ) {   /* looks ok for port number */ 
    304         port[p++] = c; 
    305         continue; 
    306       } else {              /* oops! Something's wrong! */ 
    307         fprintf(stderr, "getmenu: bad server address:port <%s>.\n", addr_port ); 
    308           return; 
    309       } 
    310     }   /* if is_port  */ 
    311   }     /* while(1)  */ 
    312   port[p++] = '\0'; 
    313  
    314   /* Assume we have an IP address and try to convert to network format. 
    315    * If that fails, assume a domain name and look up its IP address. 
    316    * Can't trust reverse name lookup, since some place may not have their 
    317    * name server properly configured. 
    318    */ 
    319   addr_p = addr; 
    320   if ( inet_addr(addr) == INADDR_NONE ) 
    321     {        /* it's not a dotted quad address */ 
    322       if ( (host = gethostbyname(addr)) == NULL) 
    323         { 
    324           logit("e", "getmenu: bad server address <%s>\n", addr ); 
    325           return; 
    326         } 
    327       memcpy((char *) &addr_s, host->h_addr,  host->h_length); 
    328       addr_p = inet_ntoa(addr_s); 
    329     } 
    330  
    331  
    332   if (strlen(addr_p) > 15 || strlen(port) > 5) { 
    333     fprintf(stderr, "getmenu: ignoring dubious server <%s:%s>\n", addr_p, 
    334           port); 
    335     return; 
    336286  } 
    337   strcpy( wsAddrCmdLine[numserv], addr ); 
    338   strcpy( wsIp[numserv], addr_p ); 
    339   strcpy( wsPort[numserv], port ); 
     287  strncpy(wsAddrCmdLine[numserv], wsIp[numserv], sizeof(wsAddrCmdLine[numserv])); 
    340288  numserv++; 
    341289 
  • trunk/src/diagnostic_tools/getmenu/makefile.nt

    r5320 r7606  
    3636$B\getmenu.exe: getmenu.obj 
    3737   $(link) $(conlflags) $(ldebug) $(conlibsmt) getmenu.obj $L\ws_clientII.obj \ 
    38     $L\socket_ew.obj \ 
     38    $L\socket_ew.obj $L\parse_ip_address.obj $L\get_ip_format_string.obj \ 
    3939    $L\libew.lib $L\socket_ew_common.obj -out:$B\getmenu.exe 
    4040 
  • trunk/src/diagnostic_tools/getmenu/makefile.unix

    r5310 r7606  
    99 
    1010 
    11 O = getmenu.o $L/socket_ew.o $L/libew.a $L/ws_clientII.o $L/socket_ew_common.o 
     11O = getmenu.o $L/socket_ew.o $L/libew.a $L/ws_clientII.o $L/socket_ew_common.o $L/parse_ip_address.o $L/get_ip_format_string.o 
    1212 
    1313getmenu: $O 
  • trunk/src/diagnostic_tools/wave_probe/ws_clientII.h

    r6803 r7606  
    8686TRACE_REQ; 
    8787 
    88 #define wsADRLEN    16    /* length for ip and port adrress strings */ 
     88#define wsADRLEN    64    /* length for ip and port adrress strings */ 
    8989#define wsREQLEN   256    /* length for MENU request */ 
    9090#define wsREPLEN  20480   /* length for reply to MENU request(up to 256 SCNs) */ 
  • trunk/src/display/heli_ewII/heli_ewII.c

    r7250 r7606  
    251251  if(ImAModule) {  /* this is set in config_me() by the presence of module paramters in the config file*/ 
    252252    if(HeartBeatInterval<=SLEEP_SEC){ 
    253       logit("et","%s Heartbeat Interval=%f. Shorter than minimum %d. Exiting\n", whoami, difftime( HeartBeatInterval, (time_t) 0 ), SLEEP_SEC); 
     253      logit("et","%s Heartbeat Interval=%ld. Shorter than minimum %d. Exiting\n", whoami, HeartBeatInterval, SLEEP_SEC); 
    254254      return(-1); 
    255255    } 
     
    10491049  xinc = decimation * in_sec / But->plt[i].samp_sec;       /* decimation */ 
    10501050  if(But->Debug) { 
    1051     logit( "e", "%s %s. sf: %f in_sec: %f samp_pix: %f samp_sec: %f decimation: %d xinc: %f\n",  
     1051    logit( "e", "%s %s. sf: %f in_sec: %f samp_pix: %f samp_sec: %lf decimation: %d xinc: %f\n",  
    10521052            whoami, But->plt[i].SCNLtxt, sf, in_sec, samp_pix, But->plt[i].samp_sec, decimation, xinc); 
    10531053  } 
  • trunk/src/display/sgram/sgram.c

    r7251 r7606  
    25212521 
    25222522    memcpy( pTH4, pTH, sizeof(TRACE_HEADER) ); 
    2523     if(WSDebug) logit( "e","%s server: %s Make Local\n", whoami, server ); 
     2523    if(WSDebug) logit( "e","%s server: %s io: %d Make Local\n", whoami, server, io ); 
    25242524    if (WaveMsgMakeLocal(pTH4) == -1) { 
    25252525        logit("et", "%s server: %s %s.%s.%s unknown datatype <%s>; skipping\n", 
     
    28132813 
    28142814    memcpy( pTH4, pTH, sizeof(TRACE2_HEADER) ); 
    2815     if(WSDebug) logit( "e","%s server: %s Make Local\n", whoami, server ); 
     2815    if(WSDebug) logit( "e","%s server: %s io: %d Make Local\n", whoami, server, io ); 
    28162816    if (WaveMsg2MakeLocal(pTH4) == -1) { 
    28172817        logit("et", "%s server: %s %s.%s.%s.%s unknown datatype <%s>; skipping\n", 
  • trunk/src/grab_bag/trig2arc/hyp_trig_utils.c

    r7254 r7606  
    6868        if ( ( nxttok=strtok(line, terminators) ) == NULL ) { /* first token should be station name */ 
    6969                logit("et","read_statrig_line: Bad syntax in trigger message:" 
    70                         " Strange station line - no tokens in:\n.%s.\n", line); 
     70                        "Strange station line - no tokens in: \n.%s.\n",line); 
    7171                return(0); 
    7272        } 
  • trunk/src/libsrc/libdali/ChangeLog

    r6842 r7606  
     12018.106: 2.0 
     2   - Upgraded package to handle IPv6 addresses 
     3        - Added parsing routines to determine whether address should be handled 
     4        as IPv4 or IPv6 
     5 
    162016.10.17: 1.7 
    27        - Change socket type to SOCKET and set appropriately for platform. 
  • trunk/src/libsrc/libdali/Makefile

    r6842 r7606  
    1313LIB_SRCS = timeutils.c genutils.c strutils.c \ 
    1414           logging.c network.c statefile.c config.c \ 
    15            portable.c connection.c 
     15           portable.c connection.c parse_ip_address.c 
    1616 
    1717LIB_OBJS = $(LIB_SRCS:.c=.o) 
  • trunk/src/libsrc/libdali/libdali.h

    r7464 r7606  
    3434#include "portable.h" 
    3535 
    36 #define LIBDALI_VERSION "1.7"        /**< libdali version */ 
    37 #define LIBDALI_RELEASE "2016.291"   /**< libdali release date */ 
     36#define LIBDALI_VERSION "2.0"        /**< libdali version */ 
     37#define LIBDALI_RELEASE "2018.106"   /**< libdali release date */ 
    3838 
    3939#define MAXPACKETSIZE       16384    /**< Maximum packet size for libdali */ 
  • trunk/src/libsrc/libdali/makefile.nt

    r6493 r7606  
    2121        statefile.obj   \ 
    2222        config.obj      \ 
     23        parse_ip_address.obj \ 
    2324        portable.obj    \ 
    2425        connection.obj   
  • trunk/src/libsrc/libdali/network.c

    r6842 r7606  
    1212#include <stdlib.h> 
    1313#include <string.h> 
     14 
     15#include "parse_ip_address.h" 
    1416 
    1517#include "libdali.h" 
     
    4244  char nodename[300]; 
    4345  char nodeport[100]; 
     46  char hostStr[64] = {0}; 
     47  char portStr[10] = {0}; 
     48  int timeout = 0; 
     49  int isIPv6 = 0; 
    4450  char *ptr, *tail; 
    45   size_t addrlen; 
    46   struct sockaddr addr; 
     51  int err = 0; 
    4752 
    4853  if (dlp_sockstartup ()) 
     
    6974  else 
    7075  { 
    71     if (ptr == dlconn->addr) 
    72     { 
    73       strcpy (nodename, "localhost"); 
    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); 
     76    //just get the {host, port} from parse_ip_address_string(): 
     77    if(parse_ip_address_string(dlconn->addr, hostStr, portStr, &isIPv6) <= 0) { 
     78      dl_log_r (dlconn, 2, 0, "Error parsing address and port\n"); 
     79      dlconn->terminate = 1; 
     80      return -1; 
     81    } else { 
     82      strncpy(nodename, hostStr, sizeof(hostStr)); 
     83      strncpy(nodeport, portStr, sizeof(portStr)); 
     84    } 
     85 
     86    if(nport == 0) { 
     87      strncpy(nodeport, "16000", strlen("18000") + 1); 
     88    } 
    8289 
    8390    /* Sanity test the port number */ 
    8491    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"); 
     92    if (*tail || (nport < 0 || nport > 0xffff)) 
     93    { 
     94      dl_log_r (dlconn, 2, 0, "server port (%lu) specified incorrectly\n", nport); 
    8895      dlconn->terminate = 1; 
    8996      return -1; 
     
    9198  } 
    9299 
    93   /* Resolve server address */ 
    94   if (dlp_getaddrinfo (nodename, nodeport, &addr, &addrlen)) 
    95   { 
     100  timeout = dlconn->iotimeout; 
     101  //setup TCP socket connection!! 
     102  sock = dlp_setuptcpclient(nodename, nodeport, &timeout); 
     103 
     104  if(sock == -4) { 
    96105    dl_log_r (dlconn, 2, 0, "cannot resolve hostname %s\n", nodename); 
    97106    return -1; 
    98107  } 
    99108 
    100   /* Create socket */ 
    101   if ((sock = socket (PF_INET, SOCK_STREAM, 0)) < 0) 
    102   { 
     109  if (sock == -3) { 
    103110    dl_log_r (dlconn, 2, 0, "[%s] socket(): %s\n", dlconn->addr, dlp_strerror ()); 
    104111    dlp_sockclose (sock); 
     
    106113  } 
    107114 
    108   /* Set socket I/O timeouts if possible */ 
    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  
    122   /* Connect socket */ 
    123   if ((dlp_sockconnect (sock, (struct sockaddr *)&addr, addrlen))) 
    124   { 
     115  if (sock == -2) { 
     116    dl_log_r (dlconn, 2, 0, "error setting socket to non-blocking\n"); 
     117  } 
     118 
     119  if (dlconn->iotimeout == -(timeout)) { 
     120    dl_log_r (dlconn, 1, 2, "[%s] using system socket timouts\n", dlconn->addr); 
     121 
     122    /* Update timeout to indicate socket timeouts are set  */ 
     123    dlconn->iotimeout = timeout; 
     124  } 
     125 
     126  if (sock == -1) { 
    125127    dl_log_r (dlconn, 2, 0, "[%s] connect(): %s\n", dlconn->addr, dlp_strerror ()); 
    126     dlp_sockclose (sock); 
    127     return -1; 
    128   } 
    129  
    130   /* Set socket to non-blocking */ 
    131   if (dlp_socknoblock (sock)) 
    132   { 
    133     dl_log_r (dlconn, 2, 0, "Error setting socket to non-blocking\n"); 
    134128    dlp_sockclose (sock); 
    135129    return -1; 
  • trunk/src/libsrc/libdali/portable.c

    r6842 r7606  
    3131#include "libdali.h" 
    3232#include "portable.h" 
     33/************************************************************************** 
     34 * dlp_setuptcpclient: 
     35 *  
     36 *  setup a TCP client connection. 
     37 * 
     38 *  if successful, returns valid socket descriptor 
     39 *  if getaddrinfo() fails, return -4 
     40 *  if socket() fails, return -3 
     41 *  if dlp_socknoblock() fails, return -2 
     42 *  if socket() succeeds but connect() fails, return -1 
     43 * 
     44 **************************************************************************/ 
     45SOCKET dlp_setuptcpclient(const char *host, const char *service, int *timeout) 
     46{ 
     47  struct addrinfo addrCriteria;                 //Criteria for address match 
     48  memset(&addrCriteria, 0, sizeof(addrCriteria)); 
     49  addrCriteria.ai_family = AF_UNSPEC;           //v4 or v6 OK 
     50  addrCriteria.ai_socktype = SOCK_STREAM;       //only streaming sockets 
     51  addrCriteria.ai_protocol = IPPROTO_TCP;       //TCP protocol 
     52  int socketEstablished = 0;  
     53  struct addrinfo *addr = NULL; 
     54  char dupAddress[300]; 
     55 
     56  // Get address(es) 
     57  struct addrinfo *servAddr;              //holder for list of servers addresses 
     58  int rtnVal = getaddrinfo(host, service, &addrCriteria, &servAddr); 
     59  if (rtnVal != 0) { 
     60    return -3; 
     61  } 
     62 
     63  int sock = -1; 
     64  for (addr = servAddr; addr != NULL; addr = addr->ai_next) { 
     65    // check for 'link-local' addresses (IPv6) 
     66    if(addr->ai_family == AF_INET6) { 
     67      if(getnameinfo(addr->ai_addr, addr->ai_addrlen, dupAddress, sizeof(dupAddress), NULL, 0, NI_NUMERICHOST) == 0) { 
     68        if(strncmp(dupAddress, "fe80", strlen("fe80")) == 0) { 
     69          //set the scope to '2' for link local: 
     70          ((struct sockaddr_in6 *)(addr->ai_addr))->sin6_scope_id = 2; 
     71        } 
     72      } 
     73    } 
     74    //Create TCP stream socket: 
     75    sock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 
     76    if (sock < 0) 
     77      continue;   //socket creation failed; try next address 
     78 
     79    socketEstablished = 1; //save this state for later 
     80 
     81    if (dlp_setsocktimeo (sock, *timeout) == 1) { 
     82      /* Negate timeout to indicate socket timeouts are set */ 
     83      *timeout = -(*timeout); 
     84    } 
     85 
     86    if (dlp_socknoblock(sock)) { 
     87      //this is an error! 
     88      return -2; 
     89    } 
     90 
     91    if ( dlp_sockconnect(sock, addr->ai_addr, addr->ai_addrlen) == 0) 
     92      break;         //connection established, break and return 
     93 
     94    sock = -1; 
     95  } 
     96 
     97  if(!socketEstablished) { 
     98    sock = -3; 
     99  } 
     100 
     101   freeaddrinfo(servAddr); 
     102 
     103  return sock; 
     104} 
     105 
    33106 
    34107/************************************************************************/ /** 
  • trunk/src/libsrc/libdali/portable.h

    r6842 r7606  
    152152#endif 
    153153 
     154extern SOCKET dlp_setuptcpclient(const char *host, const char *service, int *timeout); 
    154155extern int dlp_sockstartup (void); 
    155156extern int dlp_sockconnect (SOCKET socket, struct sockaddr * inetaddr, int addrlen); 
  • trunk/src/libsrc/util/makefile.nt

    r7585 r7606  
    3131        geo_to_km.obj \ 
    3232        geom.obj \ 
     33        get_ip_format_string.obj \ 
    3334        getutil.obj \ 
    3435        glevt_2_ewevent.obj \ 
     
    4142        lockfile.obj \ 
    4243        make_triglist.obj \ 
    43         mask_check.obj \ 
    4444        mem_circ_queue.obj \ 
    4545        mnbrak.obj \ 
    4646        mseedputaway.obj \ 
    4747        neic2scn.obj \ 
     48        parse_ip_address.obj \ 
    4849        parse_trig.obj \ 
    4950        parse_usnsn.obj \ 
  • trunk/src/libsrc/util/makefile.unix

    r7570 r7606  
    2121        geo_to_km.c \ 
    2222        geom.c \ 
     23        get_ip_format_string.c \ 
    2324        getutil.c \ 
    2425        glevt_2_ewevent.c \ 
     
    3536        logit.c \ 
    3637        make_triglist.c\ 
    37         mask_check.c\ 
    3838        mem_circ_queue.c\ 
    3939        mnbrak.c \ 
    4040        mseedputaway.c\ 
    4141        neic2scn.c \ 
     42        parse_ip_address.c \ 
    4243        parse_trig.c \ 
    4344        parse_usnsn.c \ 
  • trunk/src/libsrc/util/rayloc_message_rw.c

    r7223 r7606  
    683683 
    684684                logit("",    " axis1 az1 dp1  axis2 az2 dp2  axis3 az3 dp3\n"); 
    685                 logit("",    "%6.1f %3ld %+2ld %6.1f %3ld %+2ld %6.1f %3ld %+2ld\n", 
    686                     p_struct->axis[0] , lround(p_struct->az[0]) , lround(p_struct->dp[0]) , 
    687                     p_struct->axis[1] , lround(p_struct->az[1]) , lround(p_struct->dp[1]) , 
    688                     p_struct->axis[2] , lround(p_struct->az[2]) , lround(p_struct->dp[2])); 
     685                logit("",    "%6.1f %3lf %+2lf %6.1lf %3lf %+2lf %6.1lf %3lf %+2lf \n", 
     686                    p_struct->axis[0] , p_struct->az[0] , p_struct->dp[0] , 
     687                    p_struct->axis[1] , p_struct->az[1] , p_struct->dp[1] , 
     688                    p_struct->axis[2] , p_struct->az[2] , p_struct->dp[2]); 
    689689 
    690690                logit("",    "  PickID    sta  cmp nt lc  phase    res   dist azm w\n"); 
  • trunk/src/libsrc/util/socket_ew_common.c

    r7052 r7606  
    4141 *     see a difference, is when you try connecting to a non-existent socket. 
    4242 *     Previously the function would return TIMEOUT, now it will return 
    43  *     connection REFUSED. 
    44  * 
    4543 *     Revision 1.4  2000/12/01 23:48:54  lombard 
    4644 *     Fixed a few more logit format errors. 
     
    7472#include <socket_ew.h> 
    7573 
     74#pragma comment(lib, "Ws2_32.lib") 
     75 
    7676/********************** GLOBAL *******************************/ 
    7777/********************* VARIABLES *****************************/ 
     
    9898/********************* Functions *****************************/ 
    9999/*************************************************************/ 
     100SOCKET setuptcpclient_ew(const char *host, const char *service, int timeout_msec) { 
     101/* 
     102 * if successfully establishes a TCP connection, returns valid socket descriptor 
     103 *    if socket() fails, returns -2 
     104 *    if socket() succeeds but connection fails, return -1 (so we can try again later) 
     105 * */ 
     106   char * funcName = "setuptcpclient_ew()"; 
     107   // Tell the system what kind(s) of address info we want 
     108   struct addrinfo addrCriteria;                   // Criteria for address match 
     109   memset(&addrCriteria, 0, sizeof(addrCriteria)); // Zero out structure 
     110   addrCriteria.ai_family = AF_UNSPEC;             // v4 or v6 is OK 
     111   addrCriteria.ai_socktype = SOCK_STREAM;         // Only streaming sockets 
     112   addrCriteria.ai_protocol = IPPROTO_TCP;         // Only TCP protocol 
     113   int socketEstablished = 0;                      //Flag to deal with case where socket() fails completely 
     114   struct addrinfo *addr = NULL; 
     115   char dupAddress[64];                            //for testing/checking IPv6 addresses 
     116 
     117   // Get address(es) 
     118   struct addrinfo *servAddr; // Holder for returned list of server addrs 
     119   int rtnVal = getaddrinfo(host, service, &addrCriteria, &servAddr); 
     120   //XXX XXX XXX 
     121   if (rtnVal != 0) { 
     122      logit("et", "%s- getaddrinfo error: %s\n", funcName, gai_strerror(rtnVal)); 
     123      return -3; 
     124   } 
     125 
     126   int sock = -1; 
     127   for (addr = servAddr; addr != NULL; addr = addr->ai_next) { 
     128      // check for 'link-local' addresses (IPv6).  
     129      if(addr->ai_family == AF_INET6) { 
     130         if(getnameinfo(addr->ai_addr, addr->ai_addrlen, dupAddress, sizeof(dupAddress), NULL, 0, NI_NUMERICHOST) == 0) { 
     131            logit("et", "%s- formatted address: %s\n", funcName, dupAddress); 
     132            if(strncmp(dupAddress, "fe80", strlen("fe80")) == 0) { 
     133               //here we can be sure that the address is a link-local address 
     134               //set the scope to '2' 
     135               ((struct sockaddr_in6 *)(addr->ai_addr))->sin6_scope_id = 2; 
     136            } 
     137         } 
     138      } 
     139      // Create a reliable, stream socket using TCP 
     140      sock = socket_ew(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 
     141      if (sock < 0) 
     142         continue;  // Socket creation failed; try next address 
     143 
     144      //here, we have established a socket, save this info: 
     145      socketEstablished = 1; 
     146 
     147      // Establish the connection to the echo server 
     148      if ( connect_ew(sock, addr->ai_addr, addr->ai_addrlen, timeout_msec) == 0) 
     149         break;     // Socket connection succeeded; break and return socket 
     150 
     151 
     152      sock = -1; 
     153   } 
     154 
     155   if(!socketEstablished) 
     156   { 
     157      sock = -2;  //this way we can differentiate between socket() failure and connect() failure 
     158   } 
     159 
     160   freeaddrinfo(servAddr); // Free addrinfo allocated in getaddrinfo() 
     161   return sock; 
     162} 
     163 
     164SOCKET setuptcpserver_ew(const char *host, const char *service, int backlog) 
     165{ 
     166  /* setuptcpserver_ew() checks the supplied parameters and determines 
     167     whether it is appropriate to resolve host and service as IPv4 or IPv6. 
     168     The function takes care of the initial socket() call, and proceeds to call 
     169     bind__ew() and listen_ew() (passing the 'backlog' parameter to listen_ew()) 
     170     The function returns a valid SOCKET if successful, and  
     171     -3 if address resolution fails 
     172     -2 setsockopt() fails 
     173     and -1 if otherwise unable to establish a server socket 
     174   */ 
     175   // Construct the server address structure 
     176   struct addrinfo addrCriteria;                   // Criteria for address match 
     177   memset(&addrCriteria, 0, sizeof(addrCriteria)); // Zero out structure 
     178   addrCriteria.ai_family = AF_UNSPEC;             // Any address family 
     179   addrCriteria.ai_flags = AI_PASSIVE;             // Accept on any address/port 
     180   addrCriteria.ai_socktype = SOCK_STREAM;         // Only stream sockets 
     181   addrCriteria.ai_protocol = IPPROTO_TCP;         // Only TCP protocol 
     182   int on = 1;                                     // boolean flag to pass for setsockopt() setting 'REUSEADDR' to 'on' 
     183   struct addrinfo *addr = NULL; 
     184 
     185   struct addrinfo *servAddr; // List of server addresses 
     186   int rtnVal = getaddrinfo(host, service, &addrCriteria, &servAddr); 
     187   if (rtnVal != 0) { 
     188      //failure, use specific return code 
     189      return -3; 
     190   } 
     191 
     192   SOCKET servSock = -1; 
     193   for (addr = servAddr; addr != NULL; addr = addr->ai_next) { 
     194      // Create a TCP socket 
     195      servSock = socket_ew(addr->ai_family, addr->ai_socktype, addr->ai_protocol); 
     196      if (servSock < 0) 
     197         continue;       // Socket creation failed; try next address 
     198 
     199      //call setsockopt(): 
     200      if(setsockopt(servSock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(char *)) != 0) { 
     201         //log messages will be printed by client 
     202         //close socket 
     203         closesocket_ew(servSock, SOCKET_CLOSE_IMMEDIATELY_EW); 
     204         //go to "Heavy Restart"... probably make a specific return code 
     205         return -2; 
     206      } 
     207       
     208      // XXX should bind() and listen() be broken up? 
     209      // Bind to the local address and set socket to listen 
     210      if ((bind_ew(servSock, addr->ai_addr, addr->ai_addrlen) == 0) && 
     211         (listen_ew(servSock, backlog) == 0)) { 
     212         break;       // Bind and listen successful 
     213      } 
     214 
     215      closesocket_ew(servSock, SOCKET_CLOSE_IMMEDIATELY_EW);  // Close and try again 
     216      servSock = -1; 
     217   } 
     218 
     219   // Free address list allocated by getaddrinfo() 
     220   freeaddrinfo(servAddr); 
     221 
     222   return servSock; 
     223} 
     224 
     225int numeric_address_to_string_ew(int isIPv6, uint8_t inAddr[16], uint8_t inPort[2], 
     226                              char hostString[64], char portString[10]) 
     227{ 
     228   /* numeric_address_to_string_ew() turns {inAddr, inPort} into strings  
     229      hostString, portString.  
     230 
     231      returns 0 if successful, a value < 0 if not successful 
     232    */ 
     233   struct sockaddr *address; 
     234   int addrLen; 
     235   struct sockaddr_in ipv4Addr; 
     236   struct sockaddr_in6 ipv6Addr; 
     237   if(isIPv6) { 
     238      memset(&ipv6Addr, 0, sizeof(struct sockaddr_in6)); 
     239      ipv6Addr.sin6_family = AF_INET6; 
     240      memcpy(&(ipv6Addr.sin6_addr), inAddr, sizeof(ipv6Addr.sin6_addr)); 
     241      memcpy(&(ipv6Addr.sin6_port), inPort, sizeof(ipv6Addr.sin6_port)); 
     242      addrLen = sizeof(struct sockaddr_in6); 
     243      address = &ipv6Addr; 
     244   } else { 
     245      memset(&ipv4Addr, 0, sizeof(struct sockaddr_in)); 
     246      ipv4Addr.sin_family = AF_INET; 
     247      memcpy(&(ipv4Addr.sin_addr), inAddr, sizeof(ipv4Addr.sin_addr)); 
     248      memcpy(&(ipv4Addr.sin_port), inPort, sizeof(ipv4Addr.sin_port)); 
     249      addrLen = sizeof(struct sockaddr_in); 
     250      address = &ipv4Addr; 
     251   } 
     252     
     253   return formatsocketaddress_ew(address, addrLen, hostString, portString); 
     254} 
     255 
     256int formatsocketaddress_ew(const struct sockaddr *address, int addrLen, 
     257                char hostString[64], char portString[10]) { 
     258  /* formatsocketaddress_ew() accepts a (typically client) connection specified as  
     259     'address' 
     260    
     261      and returns a format string in addrString, provided a human-readable representation 
     262      of the connection 'address' 
     263   */ 
     264 
     265   int err = 0; 
     266   int hostSize = 64; 
     267   int portSize = 10; 
     268 
     269   // Test for address 
     270   if (address == NULL) 
     271      return -1; 
     272 
     273   memset(hostString, 0, hostSize); 
     274   memset(portString, 0, portSize); 
     275 
     276   //look up info: 
     277   if((err = getnameinfo(address, addrLen, hostString, hostSize, 
     278                         portString, portSize, NI_NUMERICHOST | NI_NUMERICSERV)) != 0) { 
     279      strncpy(hostString, (char *)("[invalid address]"), strlen((char *)"[invalid address]") + 1); // Unable to convert 
     280      //for now: 
     281      logit("et", "gai_strerror(): %s\n", gai_strerror(err)); 
     282      return -2; 
     283   } 
     284   return 0; 
     285} 
     286 
    100287 
    101288SOCKET socket_ew (int af, int type, int protocol) 
     
    172359   struct  timeval SelectTimeout; 
    173360    
    174   if ( EW_SOCKET_DEBUG ) 
    175     logit( "et" , "SOCKET_DEBUG: Entering %s\n", MyFuncName ); 
     361   if ( EW_SOCKET_DEBUG ) 
     362    logit( "et" , "SOCKET_DEBUG: Entering %s. Socket: %d namelen: %d timeout: %d\n", MyFuncName, s, namelen, timeout_msec ); 
    176363 
    177364/* If there is no timeout, make the socket blocking 
     
    196383     else                                        /* Didn't get a connection */ 
    197384       retVal = -1; 
    198       
     385     
    199386/* Change the socket back to non-blocking so 
    200387   we don't screw up any further operations 
  • trunk/src/libsrc/util/sudsputaway.c

    r7513 r7606  
    1919#include <string.h> 
    2020#include <time.h> 
     21#include <stdint.h> 
    2122 
    2223#include "earthworm.h" 
  • trunk/src/libsrc/util/test/mask_test.c

    r6207 r7606  
    11 
    22#include <stdio.h> 
    3  
    4 char ip_in_same_netmask(char * ip1, char * ip2, char *netmask); 
    5  
     3#include <socket_ew.h> 
    64 
    75int main() { 
     
    1412char netmask_match_perfect[] = "255.255.255.255"; 
    1513 
    16 if (ip_in_same_netmask(ip1, ip_to_test, netmask_to_succeed)) fprintf(stdout, "algo works for match\n"); 
    17 if (!ip_in_same_netmask(ip1, ip_to_test, netmask_to_fail)) fprintf(stdout, "algo works for fail\n"); 
    18 if (ip_in_same_netmask(ip1, ip_to_test, netmask_match_any)) fprintf(stdout, "algo works for any-match %s\n", netmask_match_any); 
    19 if (!ip_in_same_netmask(ip1, ip_to_test, netmask_match_perfect)) fprintf(stdout, "algo works for perfect-match %s fail case\n", netmask_match_perfect); 
    20 if (ip_in_same_netmask(ip1, ip1, netmask_match_perfect)) fprintf(stdout, "algo works for perfect-match %s succeed case\n", netmask_match_perfect); 
     14if (ip_in_same_subnet(ip1, ip_to_test, netmask_to_succeed)) fprintf(stdout, "algo works for match\n"); 
     15if (!ip_in_same_subnet(ip1, ip_to_test, netmask_to_fail)) fprintf(stdout, "algo works for fail\n"); 
     16if (ip_in_same_subnet(ip1, ip_to_test, netmask_match_any)) fprintf(stdout, "algo works for any-match %s\n", netmask_match_any); 
     17if (!ip_in_same_subnet(ip1, ip_to_test, netmask_match_perfect)) fprintf(stdout, "algo works for perfect-match %s fail case\n", netmask_match_perfect); 
     18if (ip_in_same_subnet(ip1, ip1, netmask_match_perfect)) fprintf(stdout, "algo works for perfect-match %s succeed case\n", netmask_match_perfect); 
    2119} 
  • trunk/src/libsrc/util/ws_clientII.c

    r7217 r7606  
    195195    } 
    196196 
    197     strcpy( menu->addr, ipAdr ); 
    198     strcpy( menu->port, port ); 
     197    strncpy( menu->addr, ipAdr, wsADRLEN ); 
     198    strncpy( menu->port, port, wsADRLEN ); 
    199199    if ( wsAttachServer( menu, timeout ) != WS_ERR_NONE ) { 
    200200        ret = WS_ERR_NO_CONNECTION; 
     
    794794    *pscnlp = NULL; 
    795795    while ( menu ) { 
    796         if ( strcmp( addr, menu->addr ) == 0 && 
    797              strcmp( port, menu->port ) == 0 ) { 
     796        if ( strncmp( addr, menu->addr, wsADRLEN ) == 0 && 
     797             strncmp( port, menu->port, wsADRLEN ) == 0 ) { 
    798798            ret = WS_ERR_NONE; 
    799799            *pscnlp = menu->pscnl; 
     
    848848        WS_PSCNL pscnl = menu->pscnl; 
    849849        while ( pscnl ) { 
    850             if ( strcmp( getThis->sta, pscnl->sta ) == 0 && 
    851                  strcmp( getThis->chan, pscnl->chan ) == 0 && 
    852                  strcmp( getThis->net, pscnl->net ) == 0 && 
    853                  strcmp( getThis->loc, pscnl->loc) == 0 ) { 
     850            if ( strncmp( getThis->sta, pscnl->sta, TRACE2_STA_LEN ) == 0 && 
     851                 strncmp( getThis->chan, pscnl->chan, TRACE2_CHAN_LEN ) == 0 && 
     852                 strncmp( getThis->net, pscnl->net, TRACE2_NET_LEN ) == 0 && 
     853                 strncmp( getThis->loc, pscnl->loc, TRACE2_LOC_LEN ) == 0 ) { 
    854854                ret = WS_ERR_NONE; 
    855855                *menup = menu; 
     
    907907        WS_PSCNL pscnl = menu->pscnl; 
    908908        while ( pscnl ) { 
    909             if ( strcmp( getThis->sta, pscnl->sta ) == 0 && 
    910                  strcmp( getThis->chan, pscnl->chan ) == 0 && 
    911                  strcmp( getThis->net, pscnl->net ) == 0 ) { 
     909            if ( strncmp( getThis->sta, pscnl->sta, TRACE2_STA_LEN ) == 0 && 
     910                 strncmp( getThis->chan, pscnl->chan, TRACE2_CHAN_LEN ) == 0 && 
     911                 strncmp( getThis->net, pscnl->net, TRACE2_NET_LEN ) == 0 ) { 
    912912                ret = WS_ERR_NONE; 
    913913                *menup = menu; 
     
    931931} 
    932932 
    933 /*********************************************************************** 
    934  *  wsAttachServer: Open a connection to a server. The timeout starts  * 
    935  *    when connect() is called by connect_ew() in socket_ew_common.c  * 
    936  *  This function is not concerned with location codes.                * 
     933/************************************************************************ 
     934 *  wsAttachServer: Open a connection to a server. The timeout starts   * 
     935 *    when connect() is called by connect_ew() via setuptcpclient_ew() * 
     936 *  This function is not concerned with location codes.                 * 
    937937 ***********************************************************************/ 
    938938int wsAttachServer( WS_MENU menu, int timeout ) 
     
    949949    int                ret = WS_ERR_NONE; 
    950950    SOCKET             sock = 0;   /* Socket descriptor                  */ 
    951     struct sockaddr_in s_in ;      /* Server's socket address stucture   */ 
    952951 
    953952    if ( !menu ) { 
     
    959958        wsDetachServer( menu ); 
    960959    } 
    961      
    962     /* open a non_blocking socket 
    963      *****************************/ 
    964     if ( ( sock = socket_ew( AF_INET, SOCK_STREAM, 0 ) ) == -1 ) { 
    965         ret = WS_ERR_SOCKET; 
    966         if (WS_CL_DEBUG)  
    967             logit( "e", "wsAttachServer(): socket_ew() call failed\n" ); 
    968         goto Abort; 
    969     } 
    970  
    971     /* Stuff address and port into socket structure 
    972      ********************************************/ 
    973     memset( (char *)&s_in, '\0', sizeof(s_in) ); 
    974     s_in.sin_family = AF_INET; 
    975     s_in.sin_port   = htons( (short)atoi(menu->port) ); 
    976  
    977 #if defined(_LINUX) || defined(_MACOSX) 
    978     if ((int)(s_in.sin_addr.s_addr = inet_addr(menu->addr)) == -1) { 
    979 #else 
    980     if ((int)(s_in.sin_addr.S_un.S_addr = inet_addr(menu->addr)) == -1) { 
    981 #endif 
    982         ret = WS_ERR_NO_CONNECTION; 
    983         if (WS_CL_DEBUG)  
    984             logit( "e", "wsAttachServer(): inet_addr failed on <%s>\n", 
    985                    menu->addr ); 
    986         goto Abort; 
    987     } 
    988      
    989     if ( connect_ew( sock, (struct sockaddr *)&s_in, sizeof(s_in), timeout)  
    990          == -1 ) { 
    991         ret = WS_ERR_NO_CONNECTION; 
    992         if (WS_CL_DEBUG)  
    993             logit( "e", "wsAttachServer(): connect() call failed\n" ); 
    994         goto Abort; 
    995     } 
     960 
     961    if( ( sock = setuptcpclient_ew(menu->addr, menu->port, timeout)) < 0) { 
     962      if(sock == -2) { 
     963         ret = WS_ERR_SOCKET; 
     964         if (WS_CL_DEBUG) logit("e", "wsAttachServer(): socket call failed\n"); 
     965      }  else { 
     966         ret = WS_ERR_NO_CONNECTION; 
     967         if (WS_CL_DEBUG) logit("e", "wsAttachServer(): connection failed\n"); 
     968      } 
     969      goto Abort; 
     970    } 
     971 
    996972    menu->sock = sock; 
    997973 
     
    13521328        loc[TRACE2_LOC_LEN-1]=0x00; 
    13531329   
    1354         strcpy( pscnl->sta, sta ); 
    1355         strcpy( pscnl->chan, chan ); 
    1356         strcpy( pscnl->net, net ); 
    1357         strcpy( pscnl->loc, loc ); 
     1330        strncpy( pscnl->sta, sta, TRACE2_STA_LEN ); 
     1331        strncpy( pscnl->chan, chan, TRACE2_CHAN_LEN ); 
     1332        strncpy( pscnl->net, net, TRACE2_NET_LEN ); 
     1333        strncpy( pscnl->loc, loc, TRACE2_LOC_LEN ); 
    13581334        pscnl->tankStarttime = tankStarttime; 
    13591335        pscnl->tankEndtime = tankEndtime; 
  • trunk/src/libsrc/util/ws_clientII_no_location.c

    r7217 r7606  
    608608/*********************************************************************** 
    609609 *  wsAttachServer: Open a connection to a server. The timeout starts  * 
    610  *    when connect() is called by connect_ew() in socket_ew_common.c  * 
     610 *    when connect() is called by connect_ew() via setuptcpclient_ew() * 
    611611 ***********************************************************************/ 
    612612int wsAttachServer( WS_MENU menu, int timeout ) 
     
    623623  int                ret = WS_ERR_NONE; 
    624624  SOCKET             sock = 0;   /* Socket descriptor                  */ 
    625   struct sockaddr_in s_in ;      /* Server's socket address stucture   */ 
    626625 
    627626  if ( !menu ) 
     
    636635    } 
    637636 
    638   /* open a non_blocking socket 
    639   *****************************/ 
    640   if ( ( sock = socket_ew( AF_INET, SOCK_STREAM, 0 ) ) == -1 ) 
    641     { 
    642       ret = WS_ERR_SOCKET; 
    643       if (WS_CL_DEBUG)  
    644         logit( "e", "wsAttachServer(): socket_ew() call failed\n" ); 
     637   /* Establish a TCP client connection */ 
     638  if ( ( sock = setuptcpclient_ew( menu->addr, menu->port, timeout ) ) < 0 ) 
     639    { 
     640      if (sock == -2) { 
     641         ret = WS_ERR_SOCKET; 
     642         if (WS_CL_DEBUG) logit( "e", "wsAttachServer(): socket call failed\n" ); 
     643      } else { 
     644         ret = WS_ERR_NO_CONNECTION; 
     645         if (WS_CL_DEBUG) logit( "e", "wsAttachServer(): connect call failed\n" ); 
     646      } 
    645647      goto Abort; 
    646648    } 
    647649 
    648   /* Stuff address and port into socket structure 
    649   ********************************************/ 
    650   memset( (char *)&s_in, '\0', sizeof(s_in) ); 
    651   s_in.sin_family = AF_INET; 
    652   s_in.sin_port   = htons( (short)atoi(menu->port) ); 
    653  
    654 #if defined(_LINUX) || defined(_MACOSX) 
    655   if ((int)(s_in.sin_addr.s_addr = inet_addr(menu->addr)) == -1) 
    656 #else 
    657   if ((int)(s_in.sin_addr.S_un.S_addr = inet_addr(menu->addr)) == -1) 
    658 #endif 
    659     { 
    660       ret = WS_ERR_NO_CONNECTION; 
    661       if (WS_CL_DEBUG)  
    662         logit( "e", "wsAttachServer(): inet_addr failed on <%s>\n", 
    663                menu->addr ); 
    664       goto Abort; 
    665     } 
    666  
    667   if ( connect_ew( sock, (struct sockaddr *)&s_in, sizeof(s_in), timeout) == -1 ) 
    668     { 
    669       ret = WS_ERR_NO_CONNECTION; 
    670       if (WS_CL_DEBUG)  
    671         logit( "e", "wsAttachServer(): connect() call failed\n" ); 
    672       goto Abort; 
    673     } 
    674650  menu->sock = sock; 
    675651 
  • trunk/src/libsrc/util/ws_clientIIx.c

    r7218 r7606  
    930930  int                ret = WS_ERR_NONE; 
    931931  SOCKET             sock = 0;   /* Socket descriptor                  */ 
    932   struct sockaddr_in s_in ;      /* Server's socket address stucture   */ 
    933932   
    934933  if ( !menu ) 
     
    947946  /* open a non_blocking socket 
    948947  *****************************/ 
    949   if ( ( sock = socket_ew( AF_INET, SOCK_STREAM, 0 ) ) == -1 ) 
    950   { 
    951     ret = WS_ERR_SOCKET; 
    952     if(WS_CL_DEBUG & WS_DEBUG_SERVER_ERRORS)  
    953       logit( "", "wsAttachServer(): socket_ew() call failed\n" ); 
     948  if ( ( sock = setuptcpclient_ew( menu->addr, menu->port, timeout ) ) < 0 ) 
     949  { 
     950    if(sock == -2) { 
     951      ret = WS_ERR_SOCKET; 
     952      if(WS_CL_DEBUG & WS_DEBUG_SERVER_ERRORS) logit( "", "wsAttachServer(): socket call failed\n" ); 
     953    } else { 
     954      ret = WS_ERR_NO_CONNECTION; 
     955      if(WS_CL_DEBUG & WS_DEBUG_SERVER_ERRORS) logit( "", "wsAttachServer(): connect call failed\n"); 
     956    } 
    954957    goto Abort; 
    955958  } 
    956959   
    957   /* Stuff address and port into socket structure 
    958   ********************************************/ 
    959   memset( (char *)&s_in, '\0', sizeof(s_in) ); 
    960   s_in.sin_family = AF_INET; 
    961   s_in.sin_port   = htons( (short)atoi(menu->port) ); 
    962    
    963 #if defined(_LINUX) || defined(_MACOSX) 
    964   if ((int)(s_in.sin_addr.s_addr = inet_addr(menu->addr)) == -1) 
    965 #else 
    966     if ((int)(s_in.sin_addr.S_un.S_addr = inet_addr(menu->addr)) == -1) 
    967 #endif 
    968     { 
    969       ret = WS_ERR_NO_CONNECTION; 
    970       if(WS_CL_DEBUG & WS_DEBUG_SERVER_ERRORS)  
    971         logit( "", "wsAttachServer(): inet_addr failed on <%s>\n", 
    972         menu->addr ); 
    973       goto Abort; 
    974     } 
    975  
    976     if(WS_CL_DEBUG & WS_DEBUG_SERVER_INFO)  
    977       logit("t","\n  Connecting Server (%s:%s) - ", menu->addr,menu->port); 
    978  
    979     if(menu->stats.bConnected) 
    980     { 
    981       logit("t","wsAttachServer(): Warning: error in stats package, " 
    982             "connecting to an already active connection(%s:%s).\n", 
    983             menu->addr,menu->port); 
    984     } 
    985     hrtime_ew(&dAttempting); 
    986     menu->stats.iNumTotalConnectionsAttempted++; 
    987  
    988     if ( connect_ew( sock, (struct sockaddr *)&s_in, sizeof(s_in), timeout) == -1 ) 
    989     { 
    990       if(WS_CL_DEBUG & WS_DEBUG_SERVER_INFO)  
    991         logit("t","FAILED\n"); 
    992       else if(WS_CL_DEBUG & WS_DEBUG_SERVER_ERRORS)  
    993         logit("t","\n  Connecting Server (%s:%s) - FAILED!\n", 
    994               menu->addr,menu->port); 
    995  
    996       ret = WS_ERR_NO_CONNECTION; 
    997       if(WS_CL_DEBUG & WS_DEBUG_SERVER_ERRORS)  
    998       { 
    999         int iSocketError = socketGetError_ew(); 
    1000         logit( "t", "wsAttachServer(): connect() call failed:"); 
    1001         if(iSocketError == CONNECT_WOULDBLOCK_EW) 
    1002          logit("","  connection TIMED OUT after %d seconds\n", timeout/1000); 
    1003         else if(iSocketError == CONNREFUSED_EW) 
    1004          logit("","  connection REFUSED.\n"); 
    1005         else 
    1006          logit("","  unrecognized error(%d).\n",iSocketError); 
    1007       } 
    1008  
    1009          
    1010       goto Abort; 
    1011     } 
    1012960    menu->sock = sock; 
    1013961    if(WS_CL_DEBUG & WS_DEBUG_SERVER_INFO)  
  • trunk/src/seismic_processing/Makefile

    r7434 r7606  
    8383        ewshear \ 
    8484        ewnotify \ 
    85         ewthresh 
    86 #       geqproc \ 
    87 #       globalproc \ 
     85        ewthresh \ 
     86        hyp71_mgr \ 
     87        hypAssoc  
     88 
     89# 
     90# List all modules to be compiled into the NT distribution 
     91# 
     92NT_MODULES = \ 
     93        binder_ew \ 
     94        carlstatrig \ 
     95        carlsubtrig \ 
     96        coda_aav \ 
     97        coda_dur \ 
     98        compress_UA \ 
     99        debias \ 
     100        decimate \ 
     101        decompress_UA \ 
     102        eqbuf \ 
     103        eqcoda \ 
     104        eqassemble \ 
     105        eqfilter \ 
     106        eqprelim \ 
     107        eqproc \ 
     108        eqverify \ 
     109        evansassoc \ 
     110        evanstrig \ 
     111        ewdrift \ 
     112        ewintegrate \ 
     113        ew2rsam \ 
     114        ew2ssam \ 
     115        ewspectra \ 
     116        fir \ 
     117        glass \ 
     118        globalproc \ 
     119        localmag \ 
     120        loc_wcatwc \ 
     121        gmew \ 
     122        pick_ew \ 
     123        pick_FP \ 
     124        pick_wcatwc \ 
     125        pkfilter \ 
     126        raypicker \ 
     127        statrigfilter \ 
     128        wftimefilter \ 
     129        wftimeshifter \ 
     130        ewthresh \ 
     131        ewaccel \ 
     132        geqproc \ 
     133        globalproc \ 
     134        ewnotify 
    88135 
    89136FORTRAN_MODULES = \ 
  • trunk/src/seismic_processing/Mm/makefile.nt

    r6803 r7606  
    1111ALL: $B\$(APP).exe 
    1212 
    13 EBLIBS= $L\diskrw.obj $L\complex.obj $L\filters.obj \ 
    14         $L\get_pick.obj $L\report.obj $L\ReadStationData.obj \ 
    15         $L\geotools.obj $L\mags.obj $L\taulib.obj $L\mjstime.obj \ 
    16         $L\dummy.obj $L\get_hypo.obj $L\locquake.obj 
     13#EBLIBS= $L\diskrw.obj $L\complex.obj $L\filters.obj \ 
     14#       $L\get_pick.obj $L\report.obj $L\ReadStationData.obj \ 
     15#       $L\geotools.obj $L\mags.obj $L\taulib.obj $L\mjstime.obj \ 
     16#        $L\dummy.obj $L\get_hypo.obj $L\locquake.obj 
     17EBLIBS=-lebpick -lebloc 
    1718 
    1819OBJS= $(APP).obj $(APP)_config.obj $(APP)_processing.obj $(APP)_threads.obj 
  • trunk/src/seismic_processing/Ms/makefile.nt

    r6803 r7606  
    1111ALL: $B\$(APP).exe 
    1212 
    13 EBLIBS= $L\diskrw.obj $L\complex.obj $L\filters.obj \ 
    14         $L\get_pick.obj $L\report.obj $L\ReadStationData.obj \ 
    15         $L\geotools.obj $L\mags.obj $L\taulib.obj $L\mjstime.obj \ 
    16         $L\dummy.obj $L\get_hypo.obj $L\locquake.obj 
     13#EBLIBS= $L\diskrw.obj $L\complex.obj $L\filters.obj \ 
     14#       $L\get_pick.obj $L\report.obj $L\ReadStationData.obj \ 
     15#       $L\geotools.obj $L\mags.obj $L\taulib.obj $L\mjstime.obj \ 
     16#        $L\dummy.obj $L\get_hypo.obj $L\locquake.obj 
     17EBLIBS=-lebpick -lebloc 
    1718 
    1819OBJS= $(APP).obj $(APP)_config.obj $(APP)_processing.obj $(APP)_threads.obj 
  • trunk/src/seismic_processing/Theta/makefile.nt

    r6803 r7606  
    1111ALL: $B\$(APP).exe 
    1212 
    13 EBLIBS= $L\diskrw.obj $L\complex.obj $L\filters.obj \ 
    14         $L\get_pick.obj $L\report.obj $L\ReadStationData.obj \ 
    15         $L\geotools.obj $L\mags.obj $L\taulib.obj $L\mjstime.obj \ 
    16         $L\dummy.obj $L\get_hypo.obj $L\locquake.obj 
     13#EBLIBS= $L\diskrw.obj $L\complex.obj $L\filters.obj \ 
     14#       $L\get_pick.obj $L\report.obj $L\ReadStationData.obj \ 
     15#       $L\geotools.obj $L\mags.obj $L\taulib.obj $L\mjstime.obj \ 
     16#        $L\dummy.obj $L\get_hypo.obj $L\locquake.obj 
     17EBLIBS=-lebpick -lebloc 
    1718 
    1819OBJS= $(APP).obj $(APP)_config.obj $(APP)_processing.obj $(APP)_threads.obj 
  • trunk/src/seismic_processing/carlsubtrig/prostatrg.c

    r7260 r7606  
    164164        {  /* there is room, so insert this trigger in the stack        */ 
    165165          if ( csuNet->csuParam.debug > 3 ) 
    166             logit( "", "New message in slot %d next\n", nextNextIn ); 
     166            logit( "", "New message in slot %d next %d\n", station->nextIn, 
     167                   nextNextIn ); 
    167168          trigger->onTime = onTime; 
    168169          trigger->offTime = offTime; 
  • trunk/src/seismic_processing/eqprelim/eqprelim.c

    r7393 r7606  
    1 /* 
     1        /* 
    22 *   THIS FILE IS UNDER RCS - DO NOT MODIFY UNLESS YOU HAVE 
    33 *   CHECKED IT OUT USING THE COMMAND CHECKOUT. 
  • trunk/src/seismic_processing/localmag/lm_config.h

    r6892 r7606  
    9292typedef struct _SERVER *PSERVER; 
    9393typedef struct _SERVER { 
    94   char IPAddr[16]; 
    95   char port[6]; 
     94  char IPAddr[64]; 
     95  char port[10]; 
    9696  PSERVER next; 
    9797} SERVER; 
  • trunk/src/seismic_processing/localmag/lm_main.c

    r7275 r7606  
    523523    if (pEvt->origin_time + plmParams->waitTime > (double) now && plmParams->waitNow == 0) { 
    524524      sleep_time = (time_t)(pEvt->origin_time + plmParams->waitTime) - now; 
    525       logit("t", "event %s: waiting %f seconds before processing\n", 
    526             pEvt->eventId, difftime( sleep_time, (time_t) 0 )); 
     525      logit("t", "event %s: waiting %ld seconds before processing\n", 
     526            pEvt->eventId, sleep_time); 
    527527      sleep_ew( 1000 * (unsigned int) sleep_time); 
    528528    } else if (plmParams->waitTime>0.0 && plmParams->waitNow == 1) { 
  • trunk/src/seismic_processing/localmag/lm_ws.c

    r5741 r7606  
    100100#include <trace_buf.h> 
    101101#include <ws_clientII.h> 
     102#include <socket_ew.h> 
     103#include <parse_ip_address.h> 
    102104#include "lm.h" 
    103105#include "lm_config.h" 
     
    551553  char sep[] = " \t:";    /* space, tab and colon */ 
    552554  int len; 
    553   struct hostent  *host; 
    554   struct in_addr addr_s; 
    555555  SERVER *new; 
     556  enum ip_format parseResult = 0; 
     557  int isIPv6 = 0; 
    556558  extern int SOCKET_SYS_INIT; 
    557559   
     
    566568  } 
    567569   
    568   if ( (c = strpbrk(addr_port, sep)) == NULL) 
    569   { 
    570     logit("", "Add2ServerList: address and port must be separated by `:' or space\n"); 
    571     return -1; 
    572   } 
    573   *c = '\0';            /* terminate the address */ 
    574   c++;                  /* advance one */ 
    575   len = strspn(c, sep); /* check for more separators */ 
    576   c += len;             /* advance past them */ 
    577    
    578   /* Assume we have an IP address and try to convert to network format. 
    579    * If that fails, assume a domain name and look up its IP address. 
    580    * Can't trust reverse name lookup, since some place may not have their 
    581    * name server properly configured.  
    582    */ 
    583   memset((void *) &addr_s, 0, sizeof(addr_s)); 
    584  
    585   addr = addr_port; 
    586   if ( inet_addr(addr_port) == INADDR_NONE ) 
    587   {        /* it's not a dotted quad address */ 
    588     if ( (host = gethostbyname(addr_port)) == NULL) 
    589     { 
    590       logit("", "Add2ServerList: bad server address <%s>\n", addr_port ); 
    591       return -1; 
    592     } 
    593     memcpy((void *) &addr_s, host->h_addr, host->h_length); 
    594     addr = inet_ntoa(addr_s); 
    595   } 
    596    
    597   if (strlen(addr) > 15 || strlen(c) > 5)  
    598   { 
    599     logit("", "Add2ServerList: ignoring dubious server <%s:%s>\n", addr, c); 
    600     return 0; 
    601   } 
    602570  if (plmParams->pWSV == (WS_ACCESS *)NULL) 
    603571  { 
     
    614582    return -1; 
    615583  } 
    616    
    617   strcpy( new->IPAddr, addr); 
    618   strcpy( new->port, c); 
     584 
     585  if((parseResult = parse_ip_address_string(addr_port, new->IPAddr, new->port, &isIPv6)) <= 0) 
     586  { 
     587    logit("", "Add2ServerList: IP parsing failed. %s\n", get_ip_format_string(parseResult)); 
     588    return -1; 
     589  } 
    619590  new->next = plmParams->pWSV->pList; 
    620591  plmParams->pWSV->pList = new; 
  • trunk/src/seismic_processing/localmag/makefile.nt

    r6283 r7606  
    7575   $L\ws_clientII.obj $L\socket_ew_common.obj $L\socket_ew.obj \ 
    7676   $L\tlay.obj $L\mnbrak.obj $L\brent.obj $L\dirops_ew.obj \ 
    77    $L\mem_circ_queue.obj \ 
     77   $L\mem_circ_queue.obj $L\parse_ip_address.obj $L\get_ip_format_string.obj \ 
    7878   $L\libew_mt.lib $L\fft99.obj $L\fft_prep.obj $L\transfer.obj \ 
    7979   $L\rw_mag.obj 
  • trunk/src/seismic_processing/localmag/makefile.unix

    r7551 r7606  
    2626   $L/ws_clientII.o $L/socket_ew_common.o $L/socket_ew.o $L/libew_mt.a \ 
    2727   $L/tlay.o $L/mnbrak.o $L/brent.o $L/dirops_ew.o \ 
    28    $L/mem_circ_queue.o \ 
     28   $L/mem_circ_queue.o $L/parse_ip_address.o $L/get_ip_format_string.o \ 
    2929   $L/fft99.o $L/fft_prep.o $L/transfer.o \ 
    3030   $L/rw_mag.o  
  • trunk/src/seismic_processing/nll_mgr/nll_mgr.c

    r7591 r7606  
    237237        //printf("DEBUG argc %d\n", argc); 
    238238 
    239         _Xlogit( "e" , "nll_mgr: Read configuration file\n" ); 
     239        _Xlogit( "e" , "nll_mgr: Read configuration file <%s>\n", configFile ); 
    240240        //_Xlogit( "e" , "nll_mgr: Read configuration file <%s>\n", configFile ); 
    241241//printf("DEBUG TP 4\n"); 
  • trunk/src/seismic_processing/pkfilter/pkfilter.c

    r7395 r7606  
    459459 
    460460  /*1*/     else if( k_its("MyModuleId") ) { 
    461                 str = k_str(); 
    462                 if ( str != NULL ) { 
     461                if( str=k_str() != NULL ) { 
    463462                   if( GetModId( str, &MyModId ) != 0 ) { 
    464463                      logit( "e", 
     
    472471 
    473472  /*2*/     else if( k_its("InRing") ) { 
    474                 str = k_str(); 
    475                 if ( str != NULL ) { 
     473                if( str=k_str() != NULL ) { 
    476474                   if( ( InRingKey = GetKey(str) ) == -1 ) { 
    477475                      logit( "e", 
     
    485483 
    486484  /*3*/     else if( k_its("OutRing") ) { 
    487                 str = k_str(); 
    488                 if ( str != NULL ) { 
     485                if( str=k_str() != NULL ) { 
    489486                   if( ( OutRingKey = GetKey(str) ) == -1 ) { 
    490487                      logit( "e", 
     
    517514                GetLogo = tlogo; 
    518515 
    519                 str = k_str(); 
    520                 if ( str != NULL ) { 
     516                if( str=k_str() != NULL ) { 
    521517                   if( GetInst( str, &GetLogo[nLogo].instid ) != 0 ) { 
    522518                       logit( "e", 
     
    528524                   GetLogo[nLogo+2].instid = GetLogo[nLogo].instid; 
    529525                   GetLogo[nLogo+3].instid = GetLogo[nLogo].instid; 
    530                    str = k_str(); 
    531                    if ( str != NULL ) { 
     526                   if( str=k_str() != NULL) { 
    532527                      if( GetModId( str, &GetLogo[nLogo].mod ) != 0 ) { 
    533528                          logit( "e", 
     
    659654                AllowComp = tmp; 
    660655 
    661                 str = k_str(); 
    662                 if ( str != NULL ) { 
     656                if( str=k_str() != NULL ) { 
    663657                   int length = (int) strlen(str); 
    664658                   if( length<=0 || length>=TRACE2_CHAN_LEN ) { 
  • trunk/src/seismic_processing/wftimefilter/wftimefilter.c

    r7397 r7606  
    770770                GetLogo = tlogo; 
    771771 
    772                 str = k_str(); 
    773                 if ( str != NULL ) { 
     772                if( str=k_str() != NULL ) { 
    774773                   if( GetInst( str, &GetLogo[nLogo].instid ) != 0 ) { 
    775774                       logit( "e", 
     
    778777                       exit( -1 ); 
    779778                   } 
    780                    str = k_str(); 
    781                    if ( str != NULL ) { 
     779                   if( str=k_str() != NULL ) { 
    782780                      if( GetModId( str, &GetLogo[nLogo].mod ) != 0 ) { 
    783781                          logit( "e", 
     
    787785                      } 
    788786 
    789                       str = k_str(); 
    790                       if ( str != NULL ) { 
     787                      if( str=k_str() != NULL ) { 
    791788                         if( GetType( str, &GetLogo[nLogo].type ) != 0 ) { 
    792789                             logit( "e", 
Note: See TracChangeset for help on using the changeset viewer.