cfdp_bp_process_primitive_file/main.c

// ////////////////////////////////////////////////////////////////////////////
//
// Sample program creates a 2MB  data file and a file of CFDP 
// "put", "get", filestore and message primitives. The data files are 
// transferred from/to their home/user directory. File
// transfer an filestore results are provided by the cfdp_bp_destination 
// application. The program uses the ProcessFileOfCFDPPrimitives,
// MonitorAllCFDPTransactions and RemoveAllRequests API functions.  The 
// destination files are renamed with a time tag extension.
//
// Main with optional input defining pathname for the CFDP configuration file.  
// The default CFDP configuration file pathname is 
// "./cfdp_bp_process_primitive_config.txt".
//
// The "cfdp_bp_destination" example must be running on the destination
// platform prior to starting this CFDP BP examples.  Assumes the source and
// and destination platforms are using the same operating system and user
// account.  Remote eid/node = 2.
//
// ////////////////////////////////////////////////////////////////////////////
 
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/timeb.h>
#include <string.h>
#include "ds_shared.h"
#include "trek_error.h"
#include "toolkit_ds_api_error_codes.h"
#include "toolkit_cfdp_api_error_codes.h"
#include "trek_toolkit_common_api_ansi_c.h"
#include "toolkit_cfdp_api_ansi_c.h"
#include "toolkit_ds_api_ansi_c.h"
#ifdef __linux__
#include <unistd.h>
#else
#include <windows.h>
#endif
 
unsigned int message_mask;
 
// ////////////////////////////////////////////////////////////////////////////
//
// PrintTheMessage controls how messages are processed and displayed to 
// the user
//
// ////////////////////////////////////////////////////////////////////////////
 
void PrintTheMessage(message_struct_type *mess_struct_ptr)
{
    if (mess_struct_ptr->category & message_mask)
    {
        printf("%s%s\n",GetMessageCategoryAsPaddedString(mess_struct_ptr->category),
                mess_struct_ptr->message);
    }
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// DeviceData's packet_buffer_ptr processes a cfdp_struct ptr defined as 
// follows:
//
// char           source_pathname[200];
// char           destination_pathname[200];
// long long      eid;                      (destination)
// char           transaction_id[50];
// unsigned short percent_transferred;
// unsigned long  bytes_transferred;
// unsigned long  file_size;
// unsigned long  cfdp_configuration; (e.g., DS_DEVICE_SENDING, 
//                                           DS_DEVICE_RECEIVING)
// unsigned long  cfdp_status;        (e.g., DS_PACKET_SENDING, 
//                                           DS_PACKET_RECEIVING,
//                                           DS_SUSPEND, DS_RESUME, 
//                                           DS_REPORT, 
//                                           DS_CANCEL, 
//                                           DS_SUCCESS, 
//                                           DS_FAIL, 
//                                           DS_ABANDON, 
//                                           DS_UNKNOWN)
//
// The cfdp_struct can be used to determine each file's transactions ID as  
// well as monitor a file's transfer status.
//
// ////////////////////////////////////////////////////////////////////////////
 
void DeviceData(const char      *device_key, 
                int             packet_length, 
                unsigned char   *packet_buffer_ptr)
{
    unsigned int count;
    cfdp_struct_type *cfdp_struct_ptr;
    // Retrieve the individual cfdp structs from the packet_buffer;
    for (count = 0; count*sizeof(cfdp_struct_type) < (unsigned int)packet_length; count++)
    {
        cfdp_struct_ptr = (cfdp_struct_type *)(packet_buffer_ptr + count*sizeof(cfdp_struct_type));
        if (cfdp_struct_ptr->cfdp_status == DS_MESSAGE)  // print proxy put (get) response message
        {
            // Print message
            printf("Message  %s\n",cfdp_struct_ptr->message);
        }
        else if (message_mask & MSG_CAT_PROGRESS)
        {
            printf("Progress Transaction_id %s -> %s\t file size=%lld\t bytes trans=%lld\t percent trans=%u%%\n",
                    cfdp_struct_ptr->transaction_id,
                    cfdp_struct_ptr->destination_pathname,
                    cfdp_struct_ptr->file_size,
                    cfdp_struct_ptr->bytes_transferred,
                    cfdp_struct_ptr->percent_transferred);
        }
    }
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// CreateDataFile creates a binary file with the specified pathname and size.
//
// ////////////////////////////////////////////////////////////////////////////
 
int CreateDataFile(char         *pathname,
                   unsigned int file_size)
{
    FILE *file_ptr = NULL;
    char fill_data[250];
    unsigned int i;
    if ((file_ptr = fopen(pathname,"wb")) == NULL)
    {
        printf("Error    Failed to open example data file.\n");
        return(FAIL);
    }
    // Write to data file.
    memset(fill_data,0xfe,sizeof(fill_data));
    for (i = 0; i < file_size; i+=sizeof(fill_data))
        fwrite(fill_data,1,sizeof(fill_data),file_ptr);
    fflush(file_ptr);
    fclose(file_ptr);
    return(SUCCESS);
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// InitExampleDataFiles creates a 2MB example data file and 
// returns the appropriate source and destination pathnames
//
// ////////////////////////////////////////////////////////////////////////////
 
int InitExampleDataFiles(char *pathname1MB,
                         char *destination_pathname1MB,
                         char *pathname2MB,
                         char *destination_pathname2MB,
                         char *pathname3MB,
                         char *destination_pathname3MB)
{
    struct timeb timebuffer;
    char home_path[256];
 
    if (TCAACGetHomeDirectory(home_path,sizeof(home_path)) != SUCCESS)
    {
        return(FAIL);
    }
 
    // Create the 1MB path names
    sprintf(pathname1MB, "%s/cfdp_bp_destination_data_file_1MB",home_path);
 
    // Create a destination time tag appended file name 
    ftime(&timebuffer);
    sprintf(destination_pathname1MB,"%s_%u",
           pathname1MB,
           (unsigned int)timebuffer.time);
 
    // Create a 2MB example data files 
    sprintf(pathname2MB, "%s/cfdp_bp_primitive_data_file_2MB",home_path);
    if (CreateDataFile(pathname2MB,2000000) == FAIL)
    {
        return(FAIL);
    }
    // Create a destination time tag appended file name 
    sprintf(destination_pathname2MB,"%s_%u",
            pathname2MB,
            (unsigned int)timebuffer.time);
 
    // Create the 3MB path names
    sprintf(pathname3MB, "%s/cfdp_rename_bp_primitive_data_file",home_path);
    
    // Create a destination time tag appended file name 
    sprintf(destination_pathname3MB,"%s_%u",
            pathname3MB,
            (unsigned int)timebuffer.time);
    return(SUCCESS);
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// InitPrimitiveFile creates a file of CFDP  "put", "get", filestore and 
// message primitives
//
// ////////////////////////////////////////////////////////////////////////////
 
int InitPrimitiveFile(char *pathname1MB,
                      char *destination_pathname1MB,
                      char *pathname2MB,
                      char *destination_pathname2MB,
                      char *pathname3MB,
                      char *destination_pathname3MB,
                      char *primitive_pathname)
{
    char home_path[256];
    char primitive[256];
    FILE *file_ptr = NULL;
 
    if (TCAACGetHomeDirectory(home_path,sizeof(home_path)) != SUCCESS)
    {
        return(FAIL);
    }
 
    // Create a file of CFDP primitives.
    sprintf(primitive_pathname,"%s/cfdp_bp_primitives.txt",home_path);
    if ((file_ptr = fopen(primitive_pathname,"wb")) == NULL)
    {
        printf("Error    Failed to open cfdp primitives file.\n");
        return(FAIL);
    }
 
    // Create and write primitives to the file 
 
    // Create the header that identifies file as a primitive file
    sprintf(primitive,"primitive_version 2 ION_CFDP\r\n\r\n");
    fwrite(primitive,1,strlen(primitive),file_ptr);
 
    sprintf(primitive, "get //// \"%s\" 2 \"%s\"\r\n",
            pathname1MB,
            destination_pathname1MB);
    fwrite(primitive,1,strlen(primitive),file_ptr);
 
    sprintf(primitive, "put //// \"%s\" 2 \"%s\"\r\n",
            pathname2MB,
            destination_pathname2MB);
    fwrite(primitive,1,strlen(primitive),file_ptr);
 
    sprintf(primitive, "rename_file //// \"%s\" 2 \"%s\"\r\n",
            destination_pathname2MB,
            destination_pathname3MB);
    fwrite(primitive,1,strlen(primitive),file_ptr);
 
    sprintf(primitive, "create_file //// \"%s\" 2 \r\n",
            destination_pathname1MB);
    fwrite(primitive,1,strlen(primitive),file_ptr);
 
    sprintf(primitive, "message //// \"Info    Finished processing primitive file.\" 2 \r\n");
    fwrite(primitive,1,strlen(primitive),file_ptr);
    
    fflush(file_ptr);
    fclose(file_ptr);
    return(SUCCESS);
}
 
// ////////////////////////////////////////////////////////////////////////////
//
// Sample program creates a 2MB  data file and a file of CFDP 
// "put", "get", filestore and message primitives. The data files are 
// transferred from/to their home/user directory. File
// transfer an filestore results are provided by the cfdp_bp_destination 
// application. The program uses the ProcessFileOfCFDPPrimitives,
// MonitorAllCFDPTransactions and RemoveAllRequests API functions.  The 
// destination files are renamed with a time tag extension.
//
// Main with optional input defining pathname for the CFDP configuration file.  
// The default CFDP configuration file pathname is 
// "./cfdp_bp_process_primitive_config.txt".
//
// The "cfdp_bp_destination" example must be running on the destination
// platform with a similar operating system prior to starting this 
// example.  Remote eid/node = 2.
//
// ////////////////////////////////////////////////////////////////////////////
 
int main(int argc, char *argv[])
{
    int return_value;
    char pathname[256];
    char pathname1MB[256];
    char destination_pathname1MB[256];
    char pathname2MB[256];
    char destination_pathname2MB[256];
    char pathname3MB[256];
    char destination_pathname3MB[256];
    char primitive_pathname[256];
    unsigned int transaction_count;
    cfdp_struct_type *cfdp_struct_array_ptr = NULL;
    unsigned int timeout_in_sec;
    unsigned int i;
    unsigned int primitive_count;
 
 
    char log_path[256];
    char log_filename[256];
 
    // Intialize message mask to print error messages.
    message_mask = MSG_CAT_ERROR;
 
    // Set default CFDP config_pathname.
    strcpy (pathname, "./cfdp_bp_process_primitive_config.txt");
    if (argc == 2)
    {
        strcpy(pathname,argv[1]);
    }
    else if (argc > 2)
    {
        printf("Error   Command line contains too many arguments.\n");
        return 0;
    }
 
    strcpy(log_path,"");
    strcpy(log_filename,"cfdp_bp_process_primitive_log_file");
    StartLoggingCFDPMessages(log_path,
                             log_filename,
                             FALSE_OR_NO);
 
    // Register the PrintMessage callback function prior to InitToolkitCfdp
    // to process error messages that may be generated during CFDP 
    // initialization. 
    RegisterMessage(&PrintTheMessage);
 
    // Initialize CFDP. This funcition creates, connects and configures the
    // socket and CFDP library. 
    if (InitToolkitCfdp(pathname) == SUCCESS)
    {
        if (GetDisplayMessageMask(&message_mask) != SUCCESS)
        {
            printf("Error    Failed to GetDisplayMessageMask.\n");
        }
 
        // Register the CFDPDeviceData callback function after initialization
        // since the CFDPDevice does not exist prior to initialization and 
        // this function would fail. 
        if (RegisterCFDPDeviceData(&DeviceData) != SUCCESS)
        {
            printf("Error    Failed to RegisterCFDPDeviceData.\n");
        }
 
        // Create a 2MB example data file and pathnames.  
        if (InitExampleDataFiles(pathname1MB,
                                 destination_pathname1MB,
                                 pathname2MB,
                                 destination_pathname2MB,
                                 pathname3MB,
                                 destination_pathname3MB) != SUCCESS)
        {
            printf("Error    Failed to InitExampleDataFiles.\n");
            DSCleanUp();
            return 0;
        }
 
        if (InitPrimitiveFile(pathname1MB,
                             destination_pathname1MB,
                             pathname2MB,
                             destination_pathname2MB,
                             pathname3MB,
                             destination_pathname3MB,
                             primitive_pathname) != SUCCESS)
        {
            printf("Error    Failed to InitPrimitiveFile.\n");
            DSCleanUp();
            return 0;
        }
 
        // Example code using the ProcessFileOfCFDPPrimitives, 
        // MonitorAllCFDPTransactions and RemoveAllRequests functions. 
        printf("\nProcess BP Primitive File\n\n");
 
        if (ProcessFileOfCFDPPrimitives(primitive_pathname,
                                        &primitive_count) == SUCCESS)
        {
            // Send/execute all primitives that were read from primitive file.
            if (SendAllRequests() == SUCCESS)
            {
                // Set the monitor timeout so MonitorAllCFDPTransactions will not
                // hang indefinitely waiting for a transaction to complete 
                // execution. 
                timeout_in_sec = 300;
                // Subtract one from the primitive count because a CFDP 
                // message primitive was included in the primitive file.
                // NOTE: CFDP messages have no transaction status and
                // do not send a transaction status response to the source. 
                transaction_count = primitive_count - 1;
                // Get the final transaction status for the CFDP transactions. 
                // NOTE: The cfdp config file "support_cfdp_status_requests"
                // parameter must be "true" to support transaction status 
                // monitoring.
                return_value = MonitorAllCFDPTransactions(timeout_in_sec,
                                                          &transaction_count,
                                                          &cfdp_struct_array_ptr);
                if (return_value == SUCCESS || return_value == DS_TIMEOUT)
                {
                    // Loop through the array of cfdp structs to determine the 
                    // final status of each CFDP transaction.
                    for (i=0; i<transaction_count;i++)
                    {
                        // Check for unsuccessful file transfer status 
                        // (e.g.,DS_CANCEL, DS_FAIL, DS_ABANDON, DS_UNKNOWN).
                        if (cfdp_struct_array_ptr[i].cfdp_status!= DS_SUCCESS)
                        {
                            // Take appropriate action 
                            printf("Info     Failed to execute filestore with transaction ID: %s.\n", 
                                cfdp_struct_array_ptr[i].transaction_id);
                        }
                    }
 
                    // NOTE: Problems may develop when freeing the memory associated 
                    // with the cfdp_struct_array if the CFDP 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(cfdp_struct_array_ptr)" 
                    // will work if the library and application code's compilers 
                    // are the same.
                     FreeCFDPStructArrayMemoryAlloc(cfdp_struct_array_ptr);
                }
                else
                {
                    printf("Error    Failed to MonitorAllCFDPTransactions.\n");
                }
                // Remove all "Put" and "Get" request so subsequent calls 
                // to "Put" and "Get" will not attempt to send the same files. 
                RemoveAllRequests();
            }
        }
        else
        {
            printf("Error    Failed to ProcessFileOfCFDPPrimitives.\n");
        }
    }  // end if (InitToolkitCfdp(pathname) == SUCCESS) 
    // Remove orginal data file (if it still exist).
    remove(pathname2MB);
    // Sleep 1 second prior to exiting.
    #ifdef __linux__
    sleep(1);
    #else
    Sleep(1000);
    #endif
    DSCleanUp();
    return 0;
}