zla_samples/zlasample/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 <cstdlib>
#include <ctime>
#include <cstdio>
 
#include "dca/dca_base.h"
#include "dca/dca_zla_classification.h"
#include "dca/dca_callbacks.h"
 
using namespace dca;
 
const std::string S_ToolName = "zlasample";
const std::string S_ToolVersion = "1.2";
 
LogLevel G_LogLevel = LOG_Notice;       // Default log level
 
const std::string S_UsageString =
"<redist-folder> <ticket> <product> <encryption-data> <encryption-key> <email-list-file> [<log-level>]\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"
        "  hex-encryption-data - the encryption data (as hex string) included in your license\n"
        "  encryption-key - the encryption key included in your license\n"
        "  email-list-file - file that includes the emails to classify\n"
        "  log-level - optional log-level, default = 3 (LOG_Notice)\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 void SetupLicense( const std::string& ticket, const std::string& product,
        LicenseData& licenseData )
{
        licenseData.ticket      = ticket;
        licenseData.product     = product;
}
 
static bool SetupConnectionData( const std::string& encData, const std::string& encKey,
                                                                 DbConnectionData& cData )
{
        const int iEncKey = atoi( encKey.c_str() );
 
        if( iEncKey <= 0 )
                return false;
 
        cData.useLocalDatabase = false;
        cData.dbType = DBT_Url;
        cData.remoteServerData.encryptionData = encData;
        cData.remoteServerData.encryptionKey = iEncKey;
 
        return true;
}
 
static void PrintResult( const ZlaClassificationResult& result )
{
        if( result.result() == ZLA_SPAM ) {
                std::cout << "    ZLA_SPAM";
        }
        else if( result.result() == ZLA_HAM ) {
                std::cout << "    ZLA_HAM";
        }
        else if( result.result() == ZLA_NDR ) {
                std::cout << "    ZLA_NDR";
        }
        else if( result.result() == ZLA_UNKNOWN ) {
                std::cout << "    ZLA_UNKNOWN";
        }
        else {
                // should never happen
                std::cout << "    [UNKNOWN return from ZLA call]";
        }
        std::cout << "(" << (int)result.result() << ")";
 
        if( result.module() == DCA_NONE ) {
                std::cout << ", No ZLA module";
        }
        else if( result.module() == DCA_ZLA_FLOW ) {
                std::cout << ", DCA_ZLA_FLOW";
        }
        else if( result.module() == DCA_ZLA_SHINGLE_HEADERPRINT ) {
                std::cout << ", DCA_ZLA_SHINGLE_HEADERPRINT";
        }
        else if( result.module() == DCA_ZLA_SHINGLE_BAYES ) {
                std::cout << ", DCA_ZLA_SHINGLE_BAYES";
        }
        else if( result.module() == DCA_ZLA_SHINGLE_PRINT ) {
                std::cout << ", DCA_ZLA_SHINGLE_PRINT";
        }
        else if( result.module() == DCA_ZLA_URL ) {
                std::cout << ", DCA_ZLA_URL";
        }
        else if( result.module() == DCA_ZLA_BLOCKALLOW ) {
                std::cout << ", DCA_ZLA_BLOCKALLOW";
        }
        else if( result.module() == DCA_ZLA_DBBLOCKALLOW ) {
                std::cout << ", DCA_ZLA_DBBLOCKALLOW";
        }
        else if( result.module() == DCA_ZLA_NDR ) {
                std::cout << ", DCA_ZLA_NDR";
        }
        else {
                // should never happen
                std::cout << ", [UNKNOWN module from ZLA call]";
        }
        std::cout << "(" << (int)result.module() << ")" << std::endl;
}
 
static void PrintToolHeader()
{
        std::cout << "IBM DCA Sample: " << S_ToolName << " (" << S_ToolVersion << ")" << std::endl;
}
 
static void PrintUsage()
{
        std::cout << " usage:" << std::endl;
        std::cout << S_UsageString << std::endl;
}
 
static void PrintDbConnectionInfo( const DbConnection& aDbConnection )
{
        std::cout << "Remote Database version is: " << aDbConnection.getDatabaseVersion() << 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 LoadEmailFile( const std::string& fileName, std::vector<std::string>& emailList )
{
        std::ifstream fstream( fileName.c_str(), std::ios::in );
        if (!fstream.is_open()) return;
 
        std::string line;
 
        while ( std::getline(fstream, line) )
        {
                if( !line.empty() && line[line.length()-1] == '\r')
                        line.erase( line.length() - 1 );
 
                if( !line.empty() )
                        emailList.push_back( line );
        }
}
 
static bool LoadEmail( const std::string& fileName, std::string& emailContents )
{
        emailContents.clear();
 
        FILE * file = fopen( fileName.c_str(), "rb" );
        if(!file )
                return false;
 
        fseek( file, 0, SEEK_END );
        const int iFileLength = ftell( file );
        fseek( file, 0, SEEK_SET );
        if( !iFileLength ) {
                fclose( file );
                return false;
        }
 
        char* pszBuffer = new char[ iFileLength ];
        if (!pszBuffer) { // no mem available!
                fclose( file );
                return false;
        }
 
        const size_t iBytesRead = fread( pszBuffer, 1, iFileLength, file );
        emailContents.append( pszBuffer, iBytesRead );
 
        delete[] pszBuffer;
        fclose( file );
 
        return !emailContents.empty();
}
 
void TestZlaClassification( const std::string& aEmailListFile, const DcaInstance& myDca,
        const ZlaClassifier& myZlaClassifier )
{
        size_t emailsRequested = 0;
 
        std::cout << "Entering ZLA classification routine..." <<  std::endl;
 
        ZlaClassificationResult myZlaClassificationResult;
 
        std::vector<std::string> myEmailList;
        LoadEmailFile( aEmailListFile, myEmailList );
 
        for( std::vector<std::string>::const_iterator E = myEmailList.begin(),
                EEnd = myEmailList.end(); E != EEnd; ++E ) {
 
                const std::string& myEmailString = *E;
 
                std::cout << "  Starting ZLA classification for email '" <<
                        myEmailString << "'" << std::endl;
 
                // Load email contents into given string
                std::string emailContent;
                if( !LoadEmail( myEmailString, emailContent ) ) {
                        std::cout << "Error loading given email file: " << myEmailString << ", continuing with next file." << std::endl;
                        continue;
                }
 
                // setup a Email object for given string
                const Email myEmail = Email::create( myDca, emailContent );
 
                ++emailsRequested;
 
                // start the classification
                FunctionResult myFR = myZlaClassifier.classify( myEmail, myZlaClassificationResult );
                if( !myFR ) {
                        // error occured.
                        std::cerr << "    Error from ZLA classification. Details: " << myFR.getDescription() <<
                                " (" << myFR.getReturnCode() << "). Continuing with next email." << std::endl;
                        continue;
                }
 
                std::cout << "    Classification Result for email '" << myEmailString << "'" << std::endl;
                PrintResult( myZlaClassificationResult );
        }
 
        std::cout << "  Total Results: " << std::endl;
        std::cout << "    Emails requested:\t\t" << emailsRequested << std::endl;
 
        std::cout << "Leaving ZLA classification routine." << std::endl;
}
 
std::string HexToString( const std::string& arg )
{
        if( (arg.length()%2) != 0 || arg.find( "0x" ) != 0 ) // not a hex string
                return arg;
 
        const std::string cmd( arg.substr( 2 ) );
        std::string result;
 
        for( std::string::size_type i = 0; i < cmd.length(); i += 2 ) {
                unsigned char hex[3] = { 0x00, 0x00, 0x00 };
                hex[0] = cmd[i];
                hex[1] = cmd[i+1];
                unsigned int x = 0;
                sscanf( (const char *)hex, "%02X", &x );
                result += (unsigned char)x;
        }
        return result;
}
 
int main( int argc, char *argv[] )
{
        PrintToolHeader();
 
        int rc = 5;
 
        try {
                if( argc < 7 ) {
                        PrintUsage();
                        return 5;
                }
 
                std::string myRedistFolder = argv[ 1 ];
                const std::string myTicket = argv[ 2 ];
                const std::string myProduct = argv[ 3 ];
 
                // encryption data may be entered in hex format 0xAB02FF....
                // or as a common string if only ASCII characters are used
                const std::string myEncData = HexToString( argv[ 4 ] );
 
                const std::string myEncKey = argv[ 5 ];
                const std::string myEmailList = argv[ 6 ];
 
                if (argc > 7)
                {
                        G_LogLevel = static_cast<LogLevel>( atoi( argv[7] ) );
                }
 
                if( myRedistFolder.empty() || myTicket.empty() ||
                         myProduct.empty() || myEmailList.empty() ||
                         myEncData.empty() || myEncKey.empty() ) {
                        PrintUsage();
                        return 5;
                }
 
                // check for trailing fileslash - and add if necessary
                char c = myRedistFolder[ myRedistFolder.length() - 1 ];
                if( c != '/' && c != '\\' )
                        myRedistFolder += "/";
 
                // init the 3rd party libraries
                InitCUrl();
                SetOpenSslCallbacks();
 
                {
                        // 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, ProxySettings(), G_LogLevel );
                        
                        PrintLicenseInfo( myLicense );
 
                        if( myLicense.isLicensed( ZlaClassification::ID ) ) {
                                // setup a signature database connection
                                DbConnectionData myDbConnectionData;
                                SetupConnectionData( myEncData, myEncKey, myDbConnectionData );
                                const DbConnection myDbConnection = myDca.createDbConnection( myLicense, myDbConnectionData, ProxySettings(), G_LogLevel );
                                PrintDbConnectionInfo( myDbConnection );
 
                                // initialize the ZLA classification module and create a ZLA classifier
                                ZlaClassification myZlaClassification = ZlaClassification::create( myDca, myLicense );
                                const ZlaClassifier myZlaClassifier = myZlaClassification.createClassifier( myDbConnection );
 
                                // call ZLA Classification routine
                                TestZlaClassification( myEmailList, myDca, myZlaClassifier );
                                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
        UnsetOpenSslCallbacks();
        DeinitCUrl();
 
        return rc;
}