wac_samples/wacsample/main.cpp

/* IBM Source Code */
/* (C) Copyright IBM Corp. 2009, 2012 */
/* Licensed Materials - Property of IBM */
/* US Government Users Restricted Rights - Use duplication or disclosure restricted by GSA Schedule Contract with IBM Corp. */
 
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <ctime>
 
#ifdef WIN32
#       include <winsock2.h>
#endif
 
#include "dca/dca_base.h"
#include "dca/dca_url_classification.h"
#include "dca/dca_wac_classification.h"
#include "dca/dca_callbacks.h"
 
using namespace dca;
using namespace dca_wac;
 
const std::string S_ToolName = "wacsample";
const std::string S_ToolVersion = "1.3";
 
const std::string S_UsageString =
        "<redist-folder> <ticket> <product> <input-file>\n"
        "  redist-folder - the folder where the DCA is installed to\n"
        "  ticket - a valid ticket\n"
        "  product - the product associated with your ticket\n\n"
        "  input-file - a file with sample input data in the following format:\n"
        "     1st line: requestdata\n"
        "     2nd line: URL\n"
        "     3rd line: response\n"
        "     4th line: requestdata...\n"
        "   Leave line blank if no request data URL or response data should be used\n"
        "   Note: At least one of the 3 lines must be non blank.\n"
        "       Note: A $(CR), $(LF) or $(CRLF) will be substituted with \\r, \\n and \\r\\n\n\n"
        ;
 
#ifdef WIN32
#       define DCA_BINDIR               "bin/Win32"
#else
#       define DCA_BINDIR               "bin/linux"
#endif
 
#define DCA_INITDIR             "init"
 
#define DCA_LOGDIR              "./logs"
 
static void SetupInitData( const std::string& redist_folder, InitData& initData )
{
        initData.binDir = redist_folder + DCA_BINDIR;
        initData.initDir = redist_folder + DCA_INITDIR;
        initData.logDir = DCA_LOGDIR;
}
 
static bool StartupLibraries()
{
#ifdef WIN32
        // Windows needs an extra socket-startup for this process to work 
        // correctly with e.g. IP(v6) input IP addresses
        WORD wVersionRequested = MAKEWORD( 2, 2 );
        WSADATA wsaData;
        int err = WSAStartup( wVersionRequested, &wsaData );
        if ( err != 0 ) {
                std::cout << "Error on WSAStartup (" << err << ") occured, aborting" << 
                        std::endl;
                        return false;
        }
#endif  
 
        // init the 3rd party libraries
        InitCUrl();
        SetOpenSslCallbacks();
        return true;
}
 
static void ShutdownLibraries()
{
        // deinit the 3rd party libraries
        UnsetOpenSslCallbacks();
        DeinitCUrl();
        
#ifdef WIN32    
        // Cleanup Windows sockets for this process
        WSACleanup();
#endif
}
 
static void SetupLicense( const std::string& ticket, const std::string& product,
        LicenseData& licenseData )
{
        licenseData.ticket      = ticket;
        licenseData.product     = product;
}
 
static void SetupWacConnectionData( DbConnectionData& cData )
{
        cData.useLocalDatabase = true;
        cData.dbType = DBT_Wac;
}
 
static void SetupUrlConnectionData( DbConnectionData& cData )
{
        cData.useLocalDatabase = true;
        cData.dbType = DBT_Url;
}
 
static void PrintDbConnectionInfo( const DbConnection& aDbConnection )
{
        DatabaseInformation databaseInformation = 
                aDbConnection.getDatabaseInformation();
 
        std::cout << "WAC Database Version: " << databaseInformation.versionString 
                << " as of " << databaseInformation.creationDateUTC << std::endl;
}
 
 
static void PrintLicenseInfo( const License& aLicense )
{
        const time_t expirationDate = aLicense.getExpirationDate();
        struct tm *expirationTime = localtime( &expirationDate );
 
        std::cout << "License Info:" << std::endl;
        std::cout << "  DCA is " << ( aLicense.isLicensed() ? "licensed." : 
                "not licensed." ) << std::endl;
        std::cout << "  MaxUsers:" << aLicense.getMaxUsers() << 
                std::endl;
        std::cout << "  MaxSessions:" << aLicense.getMaxSessions() << 
                std::endl;
        std::cout << "  Ticket:" << aLicense.getTicket() << 
                std::endl;
        std::cout << "  Session:" << aLicense.getSession() << 
                std::endl;
        std::cout << "  Last Message:" << aLicense.getLastMessage() << 
                std::endl;
        std::cout << "  Expiration Date:" << asctime( expirationTime ) << 
                std::endl;
}
 
static void PrintToolHeader()
{
        std::cout << "IBM DCA Sample: " << S_ToolName << " (" << S_ToolVersion << ")" << std::endl;
}
 
static void PrintUsage( const char *name )
{
        std::cout << name << " usage:" << std::endl;
        std::cout << S_UsageString << std::endl;
}
 
void PrintResults( const WacClassificationResult& aWacClassificationResult, const WacCategoriesInfo& aCategoriesInfo )
{
        if( aWacClassificationResult == NullWacClassificationResult ) {
                std::cout << "No results returned for the given request data" << std::endl;
        }
        else {
 
                std::cout << "Result from WAC Classification:" << std::endl;
                DCA_APPLICATION_ID_TYPE appId = aWacClassificationResult.applicationId();
                if( appId >= 0 ) {
                        std::cout << "Returned Application name=" <<
                                aCategoriesInfo.getApplications().byId( appId ).name() << std::endl;
                }
 
                DCA_ACTION_ID_TYPE actionId = aWacClassificationResult.actionId();
                if( actionId >= 0 ) {
                        std::cout << "Returned Action name=" <<
                                aCategoriesInfo.getActions().byId( actionId ).name() << std::endl;
                }
        }
}
 
void DoCallWacClassification( const WacClassifier& aWacClassifier, const WacInputData& aWacInputData,
                                                         WacClassificationResult& aWacClassificationResult )
{
        FunctionResult myFR = aWacClassifier.classify( aWacInputData, aWacClassificationResult );
        if( !myFR ) {
                std::cout << "Error returned from WAC Classification call. RC=" << myFR.getReturnCode() <<
                        ", Details:" << myFR.getDescription() << std::endl;
        }
}
 
void SubstituteCRLF( std::string& s )
{
        if( s.empty() )
                return;
 
        {
                const std::string subst = "$(CR)";
                const std::string newst = "\r";
                size_t substlen = subst.length();
                size_t newstlen = newst.length();
                std::string::size_type i = 0, pos = 0;
                while( ( i = s.find( subst, pos ) ) != std::string::npos ) {
                        s.replace( i, substlen, newst );
                        pos = i + newstlen;
                }
        }
        {
                const std::string subst = "$(LF)";
                const std::string newst = "\n";
                size_t substlen = subst.length();
                size_t newstlen = newst.length();
                std::string::size_type i = 0, pos = 0;
                while( ( i = s.find( subst, pos ) ) != std::string::npos ) {
                        s.replace( i, substlen, newst );
                        pos = i + newstlen;
                }
        }
        {
                const std::string subst = "$(CRLF)";
                const std::string newst = "\r\n";
                size_t substlen = subst.length();
                size_t newstlen = newst.length();
                std::string::size_type i = 0, pos = 0;
                while( ( i = s.find( subst, pos ) ) != std::string::npos ) {
                        s.replace( i, substlen, newst );
                        pos = i + newstlen;
                }
        }
}
 
void TestWacClassification( const dca::DcaInstance& aDcaInstance,
                                                   const dca::UrlDbClassifier& aUrlClassifier,
                                                   const WacClassification& aWacClassification,
                                                   const WacClassifier& aWacClassifier,
                                                   const WacCategoriesInfo& aCategoriesInfo,
                                                   const std::string& aFile )
{
        std::ifstream fstream( aFile.c_str(), std::ios::in );
        if ( !fstream.is_open() ) return;
 
        std::string line;
 
        int i = 0;
 
        while ( std::getline(fstream, line) )
        {
                ++i;
                if( line.empty() )
                        continue;
 
                while( line[line.length()-1] == '\r' || line[line.length()-1] == '\n' )
                        line.erase( line.length() - 1 );
 
                std::string requestLine = line;
 
                if( !std::getline(fstream, line) ) {
                        break;
                }
                std::string urlLine = line;
 
                if( !std::getline(fstream, line) ) {
                        break;
                }
                std::string responseLine = line;
 
                if( requestLine.empty() &&
                        urlLine.empty() &&
                        responseLine.empty() )
                        continue; // nothing specified?
 
                WacInputData myInputData;
 
                dca::UrlClassificationResults myUrlResults;
 
                if( !urlLine.empty() ) {
                        // invoke URL classification and check whether WAC Details are available
                        // of not suppress WAC classification calls
 
                        dca::Url myUrl = dca::Url::create( aDcaInstance, urlLine );
                        FunctionResult myFR = aUrlClassifier.classify( myUrl, myUrlResults );
                        if( ! myFR ) {
                                std::cout << "Retrieved error on UrlClassification call rc=" <<
                                        myFR.getReturnCode() << ", details=" << myFR.getDescription() <<
                                        std::endl;
                                continue; // process next entry
                        }
                        if( !aWacClassification.wacDetailsAvailable( myUrlResults ) ) {
                                std::cout << "Given URL '" << urlLine << "' has no WAC related results available so continue with next entry"
                                        << std::endl;
                                continue;
                        }
 
                        myInputData.setUrlObject( myUrl );
                }
 
                if( !requestLine.empty() ) {
                        SubstituteCRLF( requestLine );
                        myInputData.setRequestData( requestLine.c_str(), requestLine.length() );
                }
 
                if ( !responseLine.empty() ) {
                        SubstituteCRLF( responseLine );
                        myInputData.setResponse( responseLine.c_str(), responseLine.length() );
                }
 
                std::cout << "Starting WAC Classification #" << i <<
                        " (URL='" << urlLine << "', request length=" << requestLine.length() <<
                        ", response length=" << responseLine.length() <<
                        ")" << std::endl;
 
                WacClassificationResult myWacClassificationResult;
 
                DoCallWacClassification( aWacClassifier, myInputData, myWacClassificationResult );
 
                PrintResults( myWacClassificationResult, aCategoriesInfo );
                std::cout << std::endl;
        }
}
 
int main( int argc, char *argv[] )
{
        PrintToolHeader();
 
        int rc = 5;
 
        try {
                if( argc < 5 ) {
                        PrintUsage( argv[0] );
                        return 5;
                }
 
                std::string myRedistFolder = argv[ 1 ];
                const std::string myTicket = argv[ 2 ];
                const std::string myProduct = argv[ 3 ];
                const std::string myFile = argv[ 4 ];
 
                if( myRedistFolder.empty() || myTicket.empty() ||
                        myProduct.empty() || myFile.empty() ) {
                        PrintUsage( argv[0] );
                        return 5;
                }
 
                // check for trailing fileslash - and add if necessary
                const char c = myRedistFolder[ myRedistFolder.length() - 1 ];
                if( c != '/' && c != '\\' )
                        myRedistFolder += "/";
 
                // Initialize socket on Windows and 3rd party libraries
                if( !StartupLibraries() ) 
                        return 5;
 
                {
                        // setup DCA directories
                        InitData myInitData;
                        SetupInitData( myRedistFolder, myInitData );
 
                        // instantiate DCA API
                        DcaInstance myDca;
                        myDca = DcaInstance::create( myInitData );
 
                        // setup license data
                        LicenseData myLicenseData;
                        SetupLicense( myTicket, myProduct, myLicenseData );
                        const License myLicense = myDca.createLicense( myLicenseData );
 
                        PrintLicenseInfo( myLicense );
                        
                        if( myLicense.isLicensed( WacClassification::ID ) ) {
                                // variables necessary for the call to TestWacClassification()
                                WacClassification myWacClassification;
                                WacClassifier myWacClassifier;
                                WacCategoriesInfo myWacCategoriesInfo;
 
                                { // create a WacClassifier & WacCategoriesInfo
                                        DbConnectionData myWacConnectionData;
                                        SetupWacConnectionData( myWacConnectionData );
 
                                        // A DbConnection data to a local database must exist to use WacClassification
                                        const DbConnection myDbConnection = myDca.createDbConnection( myLicense, myWacConnectionData );
 
                                        std::cout << "WAC ";
                                        PrintDbConnectionInfo( myDbConnection );
 
                                        // initialize the WAC Classification module
                                        myWacClassification = WacClassification::create( myDca, myLicense );
 
                                        // create a WacClassifier to use in the TestWacClassification() function
                            // (statistics upload disabled)
                            WacClassifierOptions myWacClassifierOptions;
                                    myWacClassifierOptions.enable_Feedback = false;
 
                                        myWacClassifier = myWacClassification.createClassifier( myDbConnection, myWacClassifierOptions );
 
                                        // create a categories info for printing out the result application and action as string per input data
                                        myWacCategoriesInfo = myWacClassification.getCategoriesInfo();
                                }
 
                                UrlDbClassifier myUrlClassifier;
                                { // create a UrlDbClassifier
                                        DbConnectionData myUrlConnectionData;
                                        SetupUrlConnectionData( myUrlConnectionData );
 
                                        const DbConnection myUrlConnection = myDca.createDbConnection( myLicense, myUrlConnectionData );
                                        std::cout << "URL ";
                                        PrintDbConnectionInfo( myUrlConnection );
 
                                        // initialize the URL Classification module
                                        const UrlClassification myUrlClassification = UrlClassification::create( myDca, myLicense );
 
                            // (embedded URL detection enabled, statistics and unknown url upload disabled)
                            UrlDbClassifierOptions myUrlDbClassifierOptions;
                                    myUrlDbClassifierOptions.enable_EmbeddedUrlDetection = true;
                            myUrlDbClassifierOptions.detect_EmbeddedUrlsInUrlPath = true;
                                    myUrlDbClassifierOptions.enable_Feedback = false;
 
                                        myUrlClassifier = myUrlClassification.createDbClassifier( myUrlConnection, myUrlDbClassifierOptions );
                                }
 
                                // call classification routine
                                TestWacClassification( myDca, myUrlClassifier, myWacClassification,
                                        myWacClassifier, myWacCategoriesInfo, myFile );
                                        
                                rc = 0;
                        }
                }
        }
        catch( const ExDca& ex ) {
                std::cerr << "DCA Exception occured. Details: " <<  ex.getDescription() <<
                        " (" << ex.getReturnCode() << ")." << std::endl;
                rc = 10;
        }
        catch( const std::exception& s ) {
                std::cerr << "std::exception occured. Details: " << s.what() << "." << std::endl;
                rc = 10;
        }
        catch(...) {
                std::cerr << "Unknown exception caught." << std::endl;
                rc = 10;
        }
 
        // deinit the 3rd party libraries
        ShutdownLibraries();
 
        return rc;
}