Third Party Keep-Alive

& 3rd_party_keep_alive begins here
&
& Version 1.00 12-09-13
& noah.davids@stratus.com
&
& This command macro uses a socket's PCB address (input PCB argument) to
& extract the local and foreign IP addresses, port numbers and sequence
& numbers. It then calls the 3rd_part_keep_alive.pm using those values.
& Next it sleeps for the requested number of minutes (input SLEEP
& argument) and then does it all again. A SLEEP value less than 1 indicates
& that the macro should exit without looping. If the VERBOSE value (input
& VERBOSE) is > 0 the macro will display the command line being executed
& and the command will display its arguments.
&
& On each iteration the socket state is extracted and if it is not TS_ESTAB
& the macro reports an error and exits. There is no point sending a keep
& alive segment if the socket is not in an ESTABLISHED state. Also on each
& iteration it compares the IP address and port numbers to those obtained on
& the first iteration, if they are not the same it assumes that the original
& socket has been closed, reports an error and exits. It needs to do this
& because it is possible for the socket address space to be reused after the
& original socket is closed.
&
& This software is provided on an "AS IS" basis, WITHOUT ANY WARRANTY OR ANY
& SUPPORT OF ANY KIND. The AUTHOR SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES
& OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE.  This disclaimer
& applies, despite any verbal representations of any kind provided by the
& author or anyone else.
&
&begin_parameters
PCB PCB:string,req
SLEEP SLEEP:number,=0
VERBOSE verbose:number,=0
&end_parameters
&
&set_string FIRST ''
&attach_input
&
& Run dump_onetcb to get the IP addresses and port and sequence numbers and
& the socket state.  If the PCB is not valid you can get some analyze_system
& errors - no big deal.
&label again
&echo no_input_lines no_command_lines no_macro_lines
analyze_system
..attach_default_output (process_dir)>lport
match lport; dump_onetcb &PCB&
..detach_default_output
..attach_default_output (process_dir)>fport
match fport; dump_onetcb &PCB&
..detach_default_output
..attach_default_output (process_dir)>laddr
match 'laddr  '; dump_onetcb &PCB&
..detach_default_output
..attach_default_output (process_dir)>faddr
match 'faddr  '; dump_onetcb &PCB&
..detach_default_output
..attach_default_output (process_dir)>rcvseq
match rcvseq; dump_onetcb &PCB&
..detach_default_output
..attach_default_output (process_dir)>sndseq
match sndseq; dump_onetcb &PCB&
..detach_default_output
..attach_default_output (process_dir)>state
match tcb_state; dump_onetcb &PCB&
..detach_default_output
quit
&
& check the state to make sure the PCB refers to an established socket. I
& am appending an X to the state just in case the captured state value is
& blank. That way the macro doesn't get a syntax error and fault. It reports
& the state is wrong and exists. I start at position 35 which is to the left
& of the actual value but the leading spaces will not not. This way the
& macro works if for some reason the analyze_system prompt is not quite what
& is expected.
&set_string STATE (rtrim (substr (contents (process_dir)>state 1) 35))
&if (string &STATE&X) ^= TS_ESTABX &then &do
display_line
display_line socket is not in the ESTABLISHED state it is in (quote &STATE&)
display_line exiting . . .
&return
&end
&
& Load up the IP address and port and sequence number variables.
&set_string LPORT (substr (contents (process_dir)>lport 1) 35)
&set_string FPORT (substr (contents (process_dir)>fport 1) 35)
&set_string LADDR (substr (contents (process_dir)>laddr 1) 35)
&set_string FADDR (substr (contents (process_dir)>faddr 1) 35)
&set_string RCVSEQ (substr (contents (process_dir)>rcvseq 1) 35)
&set_string SNDSEQ (substr (contents (process_dir)>sndseq 1) 35)
&
& The TEMP string holds all the values for easy comparison and to use in an
& error message.
&set_string TEMP &+
      (rtrim &LADDR&),(ltrim &LPORT&)->(rtrim &FADDR&),(ltrim &FPORT&)
&        
& If this is the first iteration, record the TEMP string as FIRST. If it is
& not the first iteration compare the TEMP string to FIRST and if they are
& not the same report an error. It is possible that the original socket was
& closed and a new one created using the same PCB address. If the client is
& binding to a fixed port number then all these values will be the same. But
& if that is the case you probably want to continue running the keep alives
& anyway.
&if &FIRST&XXX = 'XXX'  &then &set_string FIRST &TEMP&
&else &if &FIRST& ^= &TEMP& &then &do
display_line
display_line It appears that the original socket has been closed
display_line &FIRST& has changed to &TEMP&
display_line exiting . . .
&return
&end
&
& Build the command string to execute the 3rd_party_keep_alive PM
&set_string COMMAND 3rd_party_keep_alive.pm -source_address &LADDR& &+
   -destination_address &FADDR& -source_port &LPORT& &+
   -destination_port &FPORT& -sequence_number &SNDSEQ& &+
   -acknowledgment_number &RCVSEQ& -verbose &VERBOSE&
&if &VERBOSE& &then &do
display_line
display_line &COMMAND&
&end
&COMMAND&
&
&if &SLEEP& > 0 &then &do
sleep -minutes &SLEEP&
&goto again
&end
&
& 3rd_party_keep_alive ends here

/* 3rd_party_keep_alive.c begins here

Version 1.00 12-09-13

noah.davids@stratus.com

see
  http://noahdavids.org/self_published/3rd. . . .

   This software is provided on an "AS IS" basis, WITHOUT ANY WARRANTY OR ANY
   SUPPORT OF ANY KIND. The AUTHOR SPECIFICALLY DISCLAIMS ANY IMPLIED
   WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE.
   This disclaimer applies, despite any verbal representations of any kind
   provided by the author or anyone else.
*/

#define _POSIX_C_SOURCE 200112L

#define bzero(s, len)             memset((char *)(s), 0, len)

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

void exit (int);
void s$parse_command ();

/* take an ASCII character string representation of a number and convert it
   into a unsigned long int. If you hit a non-digit stop and return 0.
*/
unsigned long atoul (char * c)
{
unsigned long l;
int i;

l = 0;
for (i = 0; i < strlen (c); i++)
    {
    if (!isdigit (c[i]))
       return (0);
    l = l * 10 + ((c [i] - 48));
    }
return (l);
}

/* take an ASCII character string that is a representation of a hexadecimal
   number and convert it into a unsigned long int. If you hit a non-hexit
   stop and return 0. There are better ways to convert each hexit to a
   numerical value but a case statement was quick and easy.
*/
unsigned long htoul (char * c)
{
unsigned long l;
int i;

l = 0;
for (i = 0; i < strlen (c); i++)
    {
    if (!isxdigit (c[i]))
       return (0);
    switch (c [i])
    {    
     case '0': l = l * 16; break;
     case '1': l = l * 16 + 1; break;
     case '2': l = l * 16 + 2; break;
     case '3': l = l * 16 + 3; break;
     case '4': l = l * 16 + 4; break;
     case '5': l = l * 16 + 5; break;
     case '6': l = l * 16 + 6; break;
     case '7': l = l * 16 + 7; break;
     case '8': l = l * 16 + 8; break;
     case '9': l = l * 16 + 9; break;
     case 'a': l = l * 16 + 10; break;
     case 'A': l = l * 16 + 10; break;
     case 'b': l = l * 16 + 11; break;
     case 'B': l = l * 16 + 11; break;
     case 'c': l = l * 16 + 12; break;
     case 'C': l = l * 16 + 12; break;
     case 'd': l = l * 16 + 13; break;
     case 'D': l = l * 16 + 13; break;
     case 'e': l = l * 16 + 14; break;
     case 'E': l = l * 16 + 14; break;
     case 'f': l = l * 16 + 15; break;
     case 'F': l = l * 16 + 15; break;
    }    
    }
return (l);
}

/* calculate a checksum based on the standard algorithm
*/
int ipsum(const char* addr, int count)
{
  /* Compute Internet Checksum for "count" bytes
   *         beginning at location "addr".
   */
  long sum = 0;

  while( count > 1 )
    {
      /*  This is the inner loop */
      sum += * (unsigned short*) addr;  addr += 2;
      count -= 2;
    }

  /*  Add left-over byte, if any */
  if (count > 0)
    {    
      sum += * (unsigned char *) addr;
    }

  /*  Fold 32-bit sum to 16 bits */
  while (sum>>16)
    {
      sum = (sum & 0xffff) + (sum >> 16);
    }
  return (~sum);
}


main ()
{
int i;
int r;

int sd;
int error_code;

struct sockaddr      addr;
struct sockaddr_in   *sin;

unsigned int sport_no, dport_no;
unsigned long seq_no, ack_no;

char_varying(15) v_saddress, v_daddress, v_seq_no, v_ack_no;
char saddress [16], daddress [16], c_seq_no [16], c_ack_no [16];
int verbose;

struct myIPHdr
   {
   char ip_vl;                     /* version length */
   char ip_tos;                    /* type of service */
   unsigned short ip_total_len;    /* total length */
   unsigned short ip_id;           /* ID */
   unsigned short ip_flags_off;    /* flags and fragment offset */
   char ip_ttl;                    /* TTL */
   char ip_protocol;               /* protocol */
   unsigned short ip_sum;          /* header checksum */
   long ip_src;                    /* source address */
   long ip_dst;                    /* destination address */
   };

#define TH_ACK  0x10

struct myTCPHdr
   {
   unsigned short  th_sport;      /* source port */
   unsigned short  th_dport;      /* destination port */
   long   th_seq;                 /* sequence number */
   long   th_ack;                 /* acknowledgement number */
   char   th_off_res;             /* 4 bits for data offset,
                                     2 bits for reserved */
   char   th_res_flags;           /* 2 bits for resevered,
                                     6 bits for flags */
   unsigned short   th_win;       /* window */
   unsigned short   th_sum;       /* checksum */
   unsigned short   th_urp;       /* urgent pointer */
   };

struct
   {
   struct myIPHdr ip;
   struct myTCPHdr tcp;
   char myByte [2];
   } packet;

struct   
   {
   long ip_src;
   long ip_dst;
   char unused;
   char ip_protocol;
   int  length;
   struct myTCPHdr tcp;
   char myByte [2];
   } pseudo;

int packet_len, hdr;

v_saddress = "";
v_daddress = "";
v_seq_no = "";
v_ack_no = "";

s$parse_command(&(char_varying(32))"keep_alive", &error_code,
        &(char_varying)"option(-source_address), string, value", &v_saddress,
        &(char_varying)"option(-destination_address), string, value",
            &v_daddress,
        &(char_varying)"option(-source_port), number,longword, value, =0",
            &sport_no,
        &(char_varying)"option(-destination_port), number,longword, \
           value, =0",&dport_no,
        &(char_varying)"option(-sequence_number), string, value, =0",&v_seq_no,
        &(char_varying)"option(-acknowledgment_number), string, \
           value, =0",&v_ack_no,
        &(char_varying)"option(-verbose), number, value, =0",&verbose,
        &(char_varying(32))"end");

if (error_code != 0)
   return (error_code);

/* convert all the varying character strings to standard null terminated
   strings
*/
    strcpy_nstr_vstr(saddress, &v_saddress);
    strcpy_nstr_vstr(daddress, &v_daddress);
    strcpy_nstr_vstr(c_seq_no, &v_seq_no);
    strcpy_nstr_vstr(c_ack_no, &v_ack_no);

/* convert the sequence number strings to unsigned longs
*/
    seq_no = atoul (c_seq_no);
    ack_no = atoul (c_ack_no);

/* convert the hexadecimal address strings to unsigned longs and start filling
   in the IP packet structure
*/
    packet.ip.ip_src = htoul (saddress);
    packet.ip.ip_dst = htoul (daddress);

/* If the verbose flag is positive output a message showing all the arguments
   so we know what we are doing
*/
if (verbose > 0)
   {
   printf ("Sending keep_alive to %x,%d from %x,%d\n", packet.ip.ip_dst,
        dport_no, packet.ip.ip_src, sport_no);
   printf ("with sequence number %u (%x)", seq_no - 1, seq_no - 1);
   printf (" and acknowledgment number %u (%x)\n\n", ack_no, ack_no);
   }

/* We start with a RAW socket
*/
sd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
if (sd < 0)
   {     
   printf ("Error %d during socket call\n", errno);
   exit (errno);
   }

/* Indicate that we will be creating our own IP and upper layer headers
*/
hdr = 1;
if (setsockopt (sd, IPPROTO_IP, IP_HDRINCL, (char *) &hdr, sizeof (hdr)) < 0)
   {
   printf ("Error %d setting IP_HDRINCL\n", errno);
   exit (errno);
   }

/* Build a blank socket address structure
*/
(void) bzero((char *)&addr, sizeof(struct sockaddr));
sin = (struct sockaddr_in *)&addr;
sin->sin_family = AF_INET;
sin->sin_port = 0;
r = inet_aton ("0.0.0.0", &sin->sin_addr);

/* build the IP header and fill in the pseudo header
*/       
packet.ip.ip_vl = 0x45;
packet.ip.ip_tos = 0;
packet.ip.ip_total_len = 41;
packet.ip.ip_id = 0;
packet.ip.ip_flags_off = 0;
packet.ip.ip_ttl = 0x55;
pseudo.ip_protocol = packet.ip.ip_protocol = 0x06;
packet.ip.ip_sum = 0x00;
pseudo.ip_src = packet.ip.ip_src;
pseudo.ip_dst = packet.ip.ip_dst;
pseudo.unused = 0x00;
pseudo.length = 21;

pseudo.tcp.th_sport = packet.tcp.th_sport = htons (sport_no);
pseudo.tcp.th_dport = packet.tcp.th_dport = htons (dport_no);
pseudo.tcp.th_seq = packet.tcp.th_seq = htonl (seq_no - 1);
pseudo.tcp.th_ack = packet.tcp.th_ack = htonl (ack_no);
pseudo.tcp.th_off_res = packet.tcp.th_off_res = 0x50;
pseudo.tcp.th_res_flags = packet.tcp.th_res_flags = TH_ACK;
pseudo.tcp.th_win = packet.tcp.th_win = 0x80;
pseudo.tcp.th_sum = packet.tcp.th_sum = 0x00;
pseudo.tcp.th_urp = packet.tcp.th_urp = 0x00;
pseudo.myByte [0] = packet.myByte [0] = 'A';
pseudo.myByte [1] = packet.myByte [1] = 0x00;

/* Note that I am not calculating the IP header checksum. Even though this is
   a raw socket the system is still calculating the IP header checksum. It is
   also setting the IP ID value to 1. It is however necessary to calculate the
   TCP checksum.
*/
packet.tcp.th_sum = ipsum ((char *) &pseudo, sizeof (pseudo));

/* Length is 41 because I am only sending 1 byte of data - the capital A. I set
   two bytes in the structure 'A' and 0x00 because the checksum requires an
   even number of bytes.
*/
packet_len = 41;

/* send the packet
*/
sendto (sd, (char *) &packet, packet_len, 0, &addr, sizeof(struct sockaddr));

}

/* 3rd_party_keep_alive.c ends here */