network_tcp/main.c

// ////////////////////////////////////////////////////////////////////////////
//
// Sample program sends and receives four packets via two TCP sockets and logs 
// info and error messages. Program uses RegisterPrintMessage, 
// StartLoggingMessages, CreateTCPClientSocketDevice, SetTCPKeepalive, 
// CreateTCPListenerSocketDevice, CreateDeviceKeyAlias, ConnectSocketDevice, 
// RegisterReceivePacketFromSocket, DefinePhpSyncHexPattern, 
// DefinePhpPacketSizeField, RegisterAcceptConnection, 
// RegisterDropConnectionFromClient, AddPacketHeaderProcessor and 
// SendPacket API functions.
//
// ////////////////////////////////////////////////////////////////////////////
 
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include "ds_shared.h"
#include "trek_error.h"
#include "toolkit_ds_api_error_codes.h"
#include "trek_toolkit_common_api_ansi_c.h"
#include "toolkit_ds_api_ansi_c.h"
#ifdef __linux__
#include <unistd.h>
#else
#include <windows.h>
#endif
 
// ////////////////////////////////////////////////////////////////////////////
//
// PrintTheMessage controls how messages are processed and displayed to 
// the user.
//
// ////////////////////////////////////////////////////////////////////////////
 
void PrintTheMessage(message_struct_type *mess_struct_ptr)
{
    if (mess_struct_ptr->category == MSG_CAT_INFO       || 
        mess_struct_ptr->category == MSG_CAT_INFO_ALERT || 
        mess_struct_ptr->category == MSG_CAT_ERROR      || 
        mess_struct_ptr->category == MSG_CAT_WARNING        ||
        mess_struct_ptr->category == MSG_CAT_ERROR_ALERT)
    {
        printf("%s\t%s\n",GetMessageCategoryAsString(mess_struct_ptr->category),
               mess_struct_ptr->message);
    }
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// ReceivePacket's packet_buffer_ptr points to the newly received packet.
//
// ////////////////////////////////////////////////////////////////////////////
 
void ReceivePacket (const char     *device_key,
                    int            packet_length,
                    unsigned char  *packet_buffer_ptr,
                    const char     *received_from_ip_address,
                    unsigned short recieved_from_port)
{
    // Print the data zone packets.
    printf("Data\t%s\n", (char *)packet_buffer_ptr + 5);
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// AcceptConnection provides ip_address and port information about the client 
// socket that is requesting a connection.  Returning SUCCESS to accept the 
// connection request, return FAIL to reject the connection request.
//
// ////////////////////////////////////////////////////////////////////////////
 
int AcceptConnection  (const char     *listener_device_key,
                       const char     *server_device_key, 
                       const char     *connected_ip_address, 
                       unsigned short connected_port)
{
    printf("Info\tConnection request from IP address: %s and port: %d\n",
            connected_ip_address,connected_port);
    return(SUCCESS);
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// DropConnection provides ip_address and port information about the client 
// socket that is dropping a connection.
//
// ////////////////////////////////////////////////////////////////////////////
 
void DropConnection (const char     *disconnected_client_device_key, 
                     const char     *disconnected_remote_ip_address, 
                     unsigned short disconnected_remote_port)
{
    printf("Info\tConnection dropped from IP address: %s and port: %d\n",
            disconnected_remote_ip_address,disconnected_remote_port);
    return;
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// CreateDataPackets creates the data packets with a three byte header.
// The first three header bytes contains a sync hex pattern = fafbfc.
// The fourth and fifth header bytes contain the overall packet length in 
// big endian byte order. 
//
// ////////////////////////////////////////////////////////////////////////////
 
void CreateDataPackets(unsigned char *packet1_ptr,
                       unsigned char *packet2_ptr,
                       unsigned char *packet3_ptr,
                       unsigned char *packet4_ptr,
                       unsigned short *length1_ptr,
                       unsigned short *length2_ptr,
                       unsigned short *length3_ptr,
                       unsigned short *length4_ptr)
{
    // Determine if this is a little endian or big endian platform. 
    unsigned short tester= 1;
    unsigned char tester_byte[1];
    unsigned char sync_pattern[3];
    unsigned short big_endian_order = 1;
    memcpy(tester_byte,&tester,1);
    if (tester_byte[0] == 0x01)
    {
        big_endian_order = 0;
    }
 
    // Zero fill the packets prior to populating.
    memset(packet1_ptr,0x00,50);
    memset(packet2_ptr,0x00,50);
    memset(packet3_ptr,0x00,50);
    memset(packet4_ptr,0x00,50);
 
    // Create a five byte header for all the packets. The header is populated
    // with the sync bytes and a big endian two byte overall packet length. 
    
    // Populate packet data zone 
    strcpy((char *)packet1_ptr+5,"Mary had a little lamb");
    strcpy((char *)packet2_ptr+5,"Its feet were black as soot");
    strcpy((char *)packet3_ptr+5,"And into Mary's bread and jam ");
    strcpy((char *)packet4_ptr+5,"Its sooty foot it put");
 
    // Get packet length including 5 byte header and null terminator.
    *length1_ptr = strlen((char *)packet1_ptr+5) + 6;
    *length2_ptr = strlen((char *)packet2_ptr+5) + 6;
    *length3_ptr = strlen((char *)packet3_ptr+5) + 6;
    *length4_ptr = strlen((char *)packet4_ptr+5) + 6;
 
    // Populate headers. 
 
    // Populate packet length field. 
    if (big_endian_order == 1)
    {
        memmove(packet1_ptr+3,length1_ptr,2);
        memmove(packet2_ptr+3,length2_ptr,2);
        memmove(packet3_ptr+3,length3_ptr,2);
        memmove(packet4_ptr+3,length4_ptr,2);
    }
    else
    {
        memmove(packet1_ptr+4,length1_ptr,1);
        memmove(packet2_ptr+4,length2_ptr,1);
        memmove(packet3_ptr+4,length3_ptr,1);
        memmove(packet4_ptr+4,length4_ptr,1);
    }
 
    // Populate sync field. 
    sync_pattern[0] = 0xfa;
    sync_pattern[1] = 0xfb;
    sync_pattern[2] = 0xfc;
    memcpy(packet1_ptr,sync_pattern,3);
    memcpy(packet2_ptr,sync_pattern,3);
    memcpy(packet3_ptr,sync_pattern,3);
    memcpy(packet4_ptr,sync_pattern,3);
 
    return;
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// PrintAvailableIPAddesses uses the PopulateIPAddressStructArray function to 
// identify and print the host's available IPv4 and IPv6 addresses. 
//
// ////////////////////////////////////////////////////////////////////////////
 
void PrintAvailableIPAddesses()
{
    unsigned int number_of_ip_address_structs;
    ip_address_struct_type *ip_address_struct_array_ptr = NULL;
    ip_address_struct_type ip_address_struct;
    unsigned int i;
    PopulateIPAddressStructArray(&number_of_ip_address_structs,
                                 &ip_address_struct_array_ptr);
 
    printf("\nIP Addresses:\n\n");
 
    for (i=0; i<number_of_ip_address_structs; i++)
    {
        ip_address_struct = ip_address_struct_array_ptr[i];
 
        if (ip_address_struct_array_ptr[i].ip_address_version == IPV4)
        {
            printf("IPv4 address: %s\n",  
                    ip_address_struct_array_ptr[i].ip_address);
        }
        else
        {
            switch (ip_address_struct_array_ptr[i].ip_address_v6_category)
            {
                case GLOBAL_FIXED:
                    printf("IPv6 address: %s\tIPv6 category: GLOBAL_FIXED\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
                case GLOBAL_TEMPORARY:
                    printf("IPv6 address: %s\tIPv6 category: GLOBAL_TEMPORARY\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
                case LINK_LOCAL:
                    printf("IPv6 address: %s\tIPv6 category: LINK_LOCAL\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
                case TAREDO_TUNNELING:
                    printf("IPv6 address: %s\tIPv6 category: TAREDO_TUNNELING\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
                case IPV6_TO_IPV4_TUNNELING:
                    printf("IPv6 address: %s\tIPv6 category: IPV6_TO_IPV4_TUNNELING\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
                case MULTICAST:
                    printf("IPv6 address: %s\tIPv6 category: MULTICAST\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
                case OTHER:
                    printf("IPv6 address: %s\tIPv6 category: OTHER\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
                default:
                    printf("IPv6 address: %s\tIPv6 category: UNDEFINED_IP_ADDRESS_V6_CATEGORY\n", 
                            ip_address_struct_array_ptr[i].ip_address);
                    break;
            }
        }
    }
 
    // NOTE: Problems may develop when freeing the memory associated 
    // with the ip_address_struct_array_ptr if the DS  library's compiler  
    // or run time environment does not match the application code's 
    // compiler or run time environment.  This method is provided to 
    // avoid those problems. The code, "free(ip_address_struct_array_ptr)" 
    // will work if the library and application code's compilers 
    // are the same.
    FreeIPAddressStructArrayMemoryAlloc(ip_address_struct_array_ptr);
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// Sample program sends and receives four packets via two TCP sockets and logs 
// info and error messages. Program uses RegisterPrintMessage, 
// StartLoggingMessages, CreateTCPClientSocketDevice, SetTCPKeepalive, 
// CreateTCPListenerSocketDevice, CreateDeviceKeyAlias, ConnectSocketDevice, 
// RegisterReceivePacketFromSocket, DefinePhpSyncHexPattern, 
// DefinePhpPacketSizeField, RegisterAcceptConnection, 
// RegisterDropConnectionFromClient, AddPacketHeaderProcessor and 
// SendPacket API functions.
//
// ////////////////////////////////////////////////////////////////////////////
 
int main(int argc, char *argv[])
{ 
    char ip_address[50];
    unsigned short source_port;
    unsigned short receive_port;
    unsigned int receive_queue_size;
    unsigned int receive_buffer_size;
    char source_device_key[50];
    char source_device_name[50];
    char receive_device_key[50];
    char receive_device_name[50];
    unsigned char packet1[50];
    unsigned char packet2[50];
    unsigned char packet3[50];
    unsigned char packet4[50];
    unsigned char packets1_thru_4[200];
    unsigned short length1;
    unsigned short length2;
    unsigned short length3;
    unsigned short length4;
    unsigned int key_buffer_size;
    unsigned int byte_offset;
    unsigned int bit_offset;
    unsigned int length_in_bits;
    long size_offset_value;
    endian_byte_order byte_order;
    char log_path[256];
    char log_filename[256];
    boolean_type start_of_packet_sync_flag;
    char sync_hex_pattern[10];
    char php_name[10];
    unsigned long keepalive_time;
    unsigned long keepalive_interval;
    unsigned long keepalive_probes;
    unsigned int connection_timeout_msec = 2100;
 
    // Example code using the PopulateIPAddressStructArray function to print 
    // the host's available ip addresses.
    PrintAvailableIPAddesses();
 
    // Create data packets.
    CreateDataPackets(packet1,
                      packet2,
                      packet3,
                      packet4,
                      &length1,
                      &length2,
                      &length3,
                      &length4);
 
    // Register the PrintMessage callback function prior to InitToolkitCfdp 
    // to process error messages that may be generated during initialization.
    RegisterMessage(&PrintTheMessage);
 
    printf("\nNetwork TCP\n\n");
 
    // Create a log file in the home/<username> or Users/<username> directory 
    // by passing a empty string for directory path. Only log error and 
    // information messages. 
    strcpy(log_path,"");
    strcpy(log_filename,"network_tcp_log_file");
    StartLoggingMessages(log_path,
                         log_filename,
                         FALSE_OR_NO);
 
    // Create a statistics file in the home/<username> or Users/<username> directory 
    // by passing a empty string for directory path. Only record device statistics
    // and not packet statisitics. 
    strcpy(log_path,"");
    strcpy(log_filename,"network_tcp_statistics_file");
    StartRecordingStatSnapshot(log_path,
                               log_filename,
                               FALSE_OR_NO);
 
    // Create a TCP client source socket device 
    strcpy(ip_address,"127.0.0.1");  // Use loopback address
    source_port = 20170; //20130;
    // A receive queue is not required since this socket is only 
    // sending packets 
    receive_queue_size = 0;
    receive_buffer_size = 0;
    key_buffer_size = sizeof(source_device_key);
 
    if (CreateTCPClientSocketDevice(ip_address,
                                    source_port,
                                    receive_queue_size,
                                    receive_buffer_size,
                                    &key_buffer_size,
                                    source_device_key) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Define a user friendly device name and associate the name with a device 
    // key.  The device name is an alias for the device key and may 
    // be used in functions requiring a device key.  The name must be unique 
    // for all devices.  A device may not have multiple names.            
    strcpy(source_device_name,"TCP_client");
    if (CreateDeviceKeyAlias(source_device_key,
                             source_device_name) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Sets the TCP keepalive parameters to determine whether the TCP 
    // connection is still up and running or if it has broken.
    //
    // keepalive_time The timeout, in seconds, with no activity until the first
    //                keepalive packet is sent.
    // keepalive_interval The interval, in seconds, when successive keep-alive 
    //                    packets are sent if no acknowledgement is received. 
    // keepalive_probes The number of consecutive probes/packets that are sent 
    //                  without an acknowledgement prior to declaring the 
    //                  connection broken.  
 
    keepalive_time= 3600;
    keepalive_interval = 300;
    keepalive_probes = 10;
 
    if (SetTCPKeepalive(source_device_key,
                        keepalive_time,
                        keepalive_interval,
                        keepalive_probes) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Create a TCP listener receive socket device.
    receive_port = 20180; //20140;
    // If the receive socket is receiving hundreds of packets a second and 
    // receive buffer minimizes the chances of packets being dropped. 
    receive_queue_size = 100;
    receive_buffer_size = 100;
    key_buffer_size = sizeof(receive_device_key);
 
    if (CreateTCPListenerSocketDevice(ip_address,
                                      receive_port,
                                      receive_queue_size,
                                      receive_buffer_size,
                                      &key_buffer_size,
                                      receive_device_key) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Define a user friendly device name and associate the name with a 
    // device key.  The device name is an alias for the device key and may 
    // be used in functions requiring a device key.  The name must be unique
    // for all devices.  A device may not have multiple names.            
    strcpy(receive_device_name,"TCP_listener");
    if (CreateDeviceKeyAlias(receive_device_key,
                             receive_device_name) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    if (SetTCPKeepalive(receive_device_key,
                        keepalive_time,
                        keepalive_interval,
                        keepalive_probes) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Define a packet header processor by identifying the sync pattern 
    // (if any) and the location of the packet size field (if available) in 
    // the packet header associated with the packets that will be received by
    // the receive device.  The data packets for this example contain a five
    // byte packet header that contains a three byte sync and two byte  
    // packet size field.  The packet size field is populated with a 16 bit 
    // packet length value using big endian or network byte ordering.
    // The given name of the packet header processor or php is "EXAMPLE".
 
    byte_offset = 3;       // Byte offset to first byte of the packet size 
                           // field. 
    bit_offset = 0;        // Bit offset to the beginning of the packet size 
                           // field.  
                           // NOTE: Byte and bit offsets are combined to  
                           // determine the overall offset to the packet size. 
    length_in_bits = 16;   // Length of the packet size field. 
    size_offset_value = 0; // Additional bytes that need to be added to the 
                           // packet length contained in the header to get an 
                           // overall packet length. 
    byte_order = BIG_ENDIAN_ORDER;
    strcpy(sync_hex_pattern,"fafbfc");
    strcpy(php_name,"EXAMPLE");
    start_of_packet_sync_flag = TRUE_OR_YES;
 
    // Create an instance of the "EXAMPE" packet header processor and define  
    // its sync pattern and packet size field. 
    if (DefinePHPSyncHexPattern(php_name,
                                sync_hex_pattern,
                                start_of_packet_sync_flag) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    if (DefinePHPPacketSizeField(php_name,
                                 byte_offset,
                                 bit_offset,
                                 length_in_bits,
                                 size_offset_value,
                                 byte_order) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Add the "EXAMPLE" php to the recieve socket device so the device can 
    // extract the packets from the TCP packet segments. 
    if  (AddPacketHeaderProcessor(php_name,
                                  receive_device_name) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Associate the AcceptConnection callback function with the receive 
    // socket device so all connections are identified. 
    if (RegisterAcceptConnection (receive_device_name,
                                  &AcceptConnection) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
    
    // Associate the RegisterDropConnectionFromClient callback function with 
    // the receive socket device so all drop connections are identified. 
    if (RegisterDropConnectionFromClient (source_device_name,
                                          &DropConnection) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
    
    // Associate the RecieveDeviceData callback function with the receive 
    // socket device so all packets received by the device will 
    // be processed by RecieveDeviceData. 
    if (RegisterReceivePacketFromSocket (receive_device_name,
                                         &ReceivePacket) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
    // Connect the source or client socket to the recieve or listener socket.  
    // The listener socket will accept the client socket connection and create 
    // a server socket that is connected 
    // to the client socket. 
    if (ConnectSocketDevice(source_device_name,
                            ip_address,
                            receive_port,
                            connection_timeout_msec) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
 
 
    // Sleep to allow connection to complete 
    #ifdef __linux__
    sleep(1);
    #else
    Sleep(1000);
    #endif
 
    // Simulate TCP packet segmentation by combining packet 1 thru 4 in a
    // single buffer which is sent in two packet segments. The receiving socket
    // will assemble the four individual packets using the sync and packet size
    // field in the header of each packet.  Each assembled packet will be
    // processed by the ReceiveDeviceData callback function.  The source socket
    // is connected to the receive socket so the SendPacket function does
    // not requires a destination IP address and port for each transmission.
    memcpy(packets1_thru_4,packet1,length1);
    memcpy(packets1_thru_4+length1,packet2,length2);
    memcpy(packets1_thru_4+length1+length2,packet3,length3);
    memcpy(packets1_thru_4+length1+length2+length3,packet4,length4);
 
    if (SendPacket (source_device_name,
                    length1+
                    length2+
                    length3/2,
                    packets1_thru_4) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Allow time to process seperate segments.
    #ifdef __linux__
    sleep(1);
    #else
    Sleep(1000);
    #endif
 
    if (SendPacket (source_device_name,
                    length3/2+length4,
                    packets1_thru_4+
                    length1+
                    length2+
                    length3/2) != SUCCESS)
    {
        DSCleanUp();
        return 0;
    }
 
    // Allow time to print messages. 
    #ifdef __linux__
    sleep(1);
    #else
    Sleep(1000);
    #endif
 
    // Close the statistics file. A timetag is appended to the filename.
    StopRecordingStatSnapshot();
 
    // Drop the connection by deleting the listener/receive socket instead
    // of the client/sender socket so the Windows OS may immediately reuse
    // the port to create another client socket.  If a client socket is 
    // deleted or its connection is closed, the Windows OS will not release
    // the port for reuse for 30 to 240 seconds. 
    DeleteDevice(receive_device_name);
 
    // Allow time to print and log messages.
    #ifdef __linux__
    sleep(1);
    #else
    Sleep(1000);
    #endif
 
    // Close the log file. A timetag is appended to the log filename. 
    StopLoggingMessages(); 
    DSCleanUp();
    return 0;
}