cbhey.cc

Go to the documentation of this file.

/*
 * cbhey.cc
 *
 * Copyright (c) 2003 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file cbhey.cc
 *
 * Main file for a command line utility used to communicate with active CPU
 * broker objects.
 */

#include "config.h"

#include <errno.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/stat.h>

#include <assert_pp.h>
#include <factory_library.h>

#include <corba.h>

#include <string>

#include "ltdl.h"

/* BEGIN HACK */
#define private public
#include "ior-handler.h" // XXX
#undef private
/* END HACK */

#include "HeyParser.hh"

using namespace std;

#if !defined(__XSTRING)
/**
 * Convert a macro argument to a string.
 *
 * @param x The macro to expand to a string.
 */
#define __XSTRING(x) __STRING(x)
#endif

enum {
    CDB_DEBUG,
    CDB_LIST,
};

/**
 * Flags for the cbhey_data.cd_Flags field.
 *
 * CDF_LIST - Just list the supported interface/implementation types.
 */
enum {
    CDF_DEBUG = (1L << CDB_DEBUG),
    CDF_LIST = (1L << CDB_LIST),
};

/**
 * Global data for the tool.
 *
 * cd_Flags - Holds the CDF_ flags.
 * cd_InterfaceType - The cast type given on the command line.
 */
static struct {
    unsigned long cd_Flags;
    const char *cd_InterfaceType;
} cbhey_data;

/**
 * Print the usage statement to standard error.
 *
 * @param prog_name The program name.
 */
static void cbhUsage(const char *prog_name)
{
    require(prog_name != NULL);

    cerr << "Generic CPU Broker control program.\n"
         << "Usage: "
         << prog_name
         << " [options] <ior> <verb> <specifiers> ...\n"
         << endl
         << "Options:\n"
         << "  -h\t\tThis help message.\n"
         << "  -V\t\tShow the version number.\n"

         << "  -d\t\tTurn on debugging messages.\n"
         << "  -l\t\tList the supported types.\n"
         << "  -c <type>\tCast the object to the given interface.\n"

         << endl
        
         << "Package: " << PACKAGE_STRING << endl
         << "Contact: " << PACKAGE_BUGREPORT << endl

        ;
}

/**
 * Process the command line options.
 *
 * @param argc_inout Reference to main's argc variable.  On return, the
 * variable will contain the number of arguments remaining after option
 * processing.
 * @param argv_inout Reference to main's argv variable.  On return, the
 * variable will contain the remaining argument values.
 * @return True if the options were processed correctly, false otherwise.
 */
static int cbhProcessOptions(int &argc_inout, char **&argv_inout)
{
    int ch, retval = 0;
    char *prog_name;
    char **argv;
    int argc;

    argc = argc_inout;
    argv = argv_inout;
    prog_name = argv[0];
    while( ((ch = getopt(argc, argv, "hVldc:")) != -1) &&
           (retval == 0) )
    {
        switch( ch )
        {
        case 'c':
            cbhey_data.cd_InterfaceType = optarg;
            break;
        case 'd':
            cbhey_data.cd_Flags |= CDF_DEBUG;
            break;
        case 'l':
            cbhey_data.cd_Flags |= CDF_LIST;
            break;
        case 'V':
            cerr << PACKAGE_VERSION << endl;
            retval = -1;
            break;
        case 'h':
        case '?':
        default:
            retval = 1;
            break;
        }
    }
    argc_inout -= optind;
    argv_inout += optind;

    argc_inout += 1;
    argv_inout -= 1;
    argv_inout[0] = prog_name;
    return( retval );
}

/* XXX BEGIN Transplanted from TAO */
static void interpret_ior(IorHandler *ioh,
                          char *thisIor,
                          struct IOR_Manager *thisIorInfo)
{
    int numCharsToSkip;
    int validTypeId = 0;
    int ulongValue;

    // Skip the prefix "IOR:"
    int numHexCharsRead = 4;

    // Type ID must be at least 4 bytes in length since type_id is prefixed
    // by the string "IDL:"
    int validTypeIdLen = 0;

    while (!validTypeIdLen)
    {
        ioh->skipNullOctets((char *)(thisIor + numHexCharsRead),
                            &numCharsToSkip, 1);
        numHexCharsRead += numCharsToSkip;

        // Read the length of the type_id field
        ulongValue = ioh->getOctet2Field((char *)(thisIor + numHexCharsRead),
                                         &numCharsToSkip);

        if (ulongValue == 0)
        {
            return;
        }

        numHexCharsRead += numCharsToSkip;

        if (ulongValue > 4)
        {
            validTypeIdLen = 1;
            thisIorInfo->typeIdLen = ulongValue;
        }

        ioh->skipNullOctets((char *)(thisIor + numHexCharsRead),
                            &numCharsToSkip, 1);
        numHexCharsRead += numCharsToSkip;

        // Read the Type ID
        ACE_OS::strncpy (thisIorInfo->typeId,
                         ioh->getString((char *)(thisIor + numHexCharsRead),
                                        2 * thisIorInfo->typeIdLen),
                         thisIorInfo->typeIdLen);

        // Confirm that this is a valid TypeId by looking for the IDL
        // interface. Additionally, the IDL interface could be extracted
        // and used for other purposes.
        ioh->getIdlInterface(thisIorInfo->typeId, &validTypeId);

        if (!validTypeId)
        {
            validTypeIdLen = 0;
            numHexCharsRead -= numCharsToSkip;
        }
    }
}
/* XXX END Transplanted from TAO */

/**
 * Extract the object type from an IOR.  Currently, this function only handles
 * form "IOR:IORs of the ..." and "file://...".
 *
 * @param ior The IOR to interpret.
 * @return A string describing the object type (e.g. "IDL:Foo/Bar:1.0").
 */
static const char *type_from_ior(const char *ior)
{
    static IorHandler ior_handler; // XXX It crashes if its on the stack (?!)

    const char *retval = NULL;
    
    require(ior != NULL);

    if( cbhey_data.cd_InterfaceType != NULL )
    {
        retval = cbhey_data.cd_InterfaceType;
    }
    else if( strncmp("IOR:", ior, 4) == 0 )
    {
        interpret_ior(&ior_handler, (char *)ior, &ior_handler.parsedIOR);
        retval = ior_handler.parsedIOR.typeId;
    }
    else if( strncmp("file://", ior, 7) == 0 )
    {
        int fd;
        
        if( (fd = open((char  *)&ior[7], O_RDONLY)) >= 0 )
        {
            char ior_buf[MAX_IOR_LEN];
            int len;
            
            len = read(fd, ior_buf, MAX_IOR_LEN - 1);
            ior_buf[len] = '\0';
            interpret_ior(&ior_handler, ior_buf, &ior_handler.parsedIOR);
            retval = ior_handler.parsedIOR.typeId;
            close(fd);
        }
        else
        {
            perror("open");
        }
    }
    else
    {
        errno = EINVAL;
    }
    return( retval );
}

/**
 * The object type to pass through the directory walking functions.
 */
struct scan_payload;

/**
 * Hook used to scan a file found in a directory tree.
 *
 * @param path The path of the file.
 * @param sp The payload passed down from further up the call chain.
 * @return Zero if the scanner should stop, otherwise an errno value.
 */
static int scan_file(const char *path, struct scan_payload *sp);

/**
 * Scan a path, determine its type, and pass to the appropriate function
 * (scan_directory/scan_file).
 *
 * @param path The path to interrogate.
 * @param sp The payload passed down from further up the call chain.
 * @return Zero if the scanner should stop, otherwise an errno value.
 */
static int scan_path(const char *path, struct scan_payload *sp);

/**
 * Scan a directory and pass its contents to the scan_path.
 *
 * @param path The directory path to walk.
 * @param sp The payload passed down from further up the call chain.
 * @return Zero if the scanner should stop, otherwise an errno value.
 */
static int scan_directory(const char *path, struct scan_payload *sp);

/**
 * Scan through a colon separate list of paths.
 *
 * @param path_list A colon separate list of paths to search.
 * @param sp The payload passed down from further up the call chain.
 * @return Zero if the scanner succeeded, otherwise an errno value.
 */
static int scan_path_list(char *path_list, struct scan_payload *sp);

static int scan_directory(const char *path, struct scan_payload *sp)
{
    int retval = EINVAL;
    DIR *dir;

    require(path != NULL);
    require(sp != NULL);

    if( (dir = opendir(path)) != NULL )
    {
        struct dirent *de;

        while( (retval != 0) && ((de = readdir(dir)) != NULL) )
        {
            if( (strcmp(de->d_name, ".") == 0) ||
                (strcmp(de->d_name, "..") == 0) )
            {
            }
            else
            {
                string sub_path = path;
                
                sub_path += "/";
                sub_path += de->d_name;
                retval = scan_path(sub_path.c_str(), sp);
            }
        }
        closedir(dir);
    }
    else
    {
        retval = errno;
    }
    return( retval );
}

static int scan_path(const char *path, struct scan_payload *sp)
{
    int retval = EINVAL;
    struct stat st;

    require(path != NULL);
    require(sp != NULL);

    if( stat(path, &st) == 0 )
    {
        if( st.st_mode & S_IFDIR )
        {
            retval = scan_directory(path, sp);
        }
        else
        {
            retval = scan_file(path, sp);
        }
    }
    else
    {
        retval = errno;
    }
    return( retval );
}

static int scan_path_list(char *path_list, struct scan_payload *sp)
{
    int retval = EINVAL;
    char *path;

    require(path_list != NULL);
    require(sp != NULL);
    
    while( (retval != 0) && ((path = strsep(&path_list, ":")) != NULL) )
    {
        retval = scan_path(path, sp);
    }
    return( retval );
}

/*
 * The payload to be filled out by scan_file.
 *
 * sp_hey_server_hint - The FMA_HeyServerHint value to be passed to the factory
 *   method.  Set by the caller of scan_path_list.
 * sp_handle - The handle on the library that can deal with servers that match
 *   the given hint.
 * sp_method - Cached reference to the libraries factory method.
 */
struct scan_payload {
    const char *sp_hey_server_hint;
    lt_dlhandle sp_handle;
    factory_method_t sp_method;
};

static int scan_file(const char *path, struct scan_payload *sp)
{
    int retval = EINVAL;
    lt_dlhandle dlh;

    require(path != NULL);
    require(sp != NULL);

    if( (dlh = lt_dlopenext(path)) != NULL )
    {
        factory_method_t fm;
        int rc = EINVAL;

        if( cbhey_data.cd_Flags & CDF_LIST )
        {
            cerr << "    Library: " << path << endl;
        }
        if( ((fm = (factory_method_t)
              lt_dlsym(dlh, __XSTRING(FACTORY_METHOD_SYMBOL))) != NULL) &&
            ((rc = flFactoryMethod(fm, FLO_QUERY,
                                   FMA_HeyServerHint, sp->sp_hey_server_hint,
                                   FMA_TAG_DONE)) == 0) )
        {
            sp->sp_handle = dlh;
            sp->sp_method = fm;
            retval = 0;
        }
        else
        {
            if( cbhey_data.cd_Flags & CDF_DEBUG )
            {
                cerr << path
                     << ": does not support type: "
                     << (sp->sp_hey_server_hint == NULL ?
                         "" :
                         sp->sp_hey_server_hint)
                     << endl;
            }
            lt_dlclose(dlh);
            retval = rc;
        }
    }
    else
    {
        if( cbhey_data.cd_Flags & CDF_DEBUG )
        {
            cerr << path << ": " << lt_dlerror() << endl;
        }
        retval = errno;
    }
    return( retval );
}

/**
 * Scan the directory paths specific to cbhey.
 *
 * @param sp The payload to pass to the directory scanner.
 * @return Zero on success, otherwise an errno value.
 */
static int scan_cbhey_paths(struct scan_payload *sp)
{
    int retval = ENOENT;
    char *path_list;

    require(sp != NULL);

    if( (path_list = getenv("CBHEY_PATH")) != NULL )
    {
        retval = scan_path_list(path_list, sp);
    }
    if( retval != 0 )
    {
        retval = scan_path(__XSTRING(PACKAGE_DIRECTORY) "/lib", sp);
    }
    return( retval );
}

int main(int argc, char *argv[])
{
    const char *prog_name = argv[0];
    int retval = EXIT_FAILURE;

#if defined(HAVE_ACE)
    /* Put a sock in ACE */
    // ACE_Log_Msg::instance()->priority_mask(0, ACE_Log_Msg::PROCESS);
#endif
    
    try
    {
        CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
        int rc;

        rc = cbhProcessOptions(argc, argv);
        if( lt_dlinit() != 0 )
        {
            cerr << "Unable to initialize dynamic libraries\n";
        }
        else if( rc == 0 )
        {
            struct scan_payload sp;

            memset(&sp, 0, sizeof(sp));
            if( cbhey_data.cd_Flags & CDF_LIST )
            {
                cout << "Supported interface/implementation types:" << endl;
                scan_cbhey_paths(&sp);
                retval = EXIT_SUCCESS;
            }
            else if( argc >= 3 )
            {
                HeyParser hp(argc, (const char **)argv);
                CORBA::Object_var obj;
                const char *obj_ior;
                
                obj_ior = hp.who();
                obj = orb->string_to_object(obj_ior);
                if( CORBA::is_nil(obj.in()) )
                {
                    cerr << "Null object" << endl;
                    retval = 10;
                }
                else if( (sp.sp_hey_server_hint = type_from_ior(obj_ior)) ==
                         NULL )
                {
                    cerr << "Error: Invalid IOR: " << obj_ior << endl;
                }
                else if( scan_cbhey_paths(&sp) == 0 )
                {
                    retval = flFactoryMethod(
                        sp.sp_method, FLO_HEY,
                        FMA_ORB, orb.in(),
                        FMA_HeyServerHint, sp.sp_hey_server_hint,
                        FMA_HeyParser, &hp,
                        FMA_TAG_DONE);
                    lt_dlclose(sp.sp_handle);
                }
                else
                {
                    cerr << "Error: Unable to find handler library for "
                         << sp.sp_hey_server_hint
                         << endl;
                }
            }
            else
            {
                cbhUsage(prog_name);
            }
        }
        else
        {
            if( rc >= 0 )
            {
                cbhUsage(prog_name);
            }
        }
    }
    catch(const HeyParserException &he)
    {
        cerr << "Parse error: " << he << endl;
    }
    catch(const CORBA::SystemException &e)
    {
        cerr << "Caught Exception: " << e << endl;
    }
    catch(...)
    {
        cerr << "Caught an unhandled exception" << endl;
    }

    return( retval );
}

---