common/cfg_getcap.cc

Go to the documentation of this file.

//
//
//
// ***** BEGIN LICENSE BLOCK *****
// Version: MPL 1.1/GPL 2.0/LGPL 2.1
// 
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// http://www.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License.
// 
// The Original Code is the consmgr network/serial-line monitoring package.
// 
// The Initial Developer of the Original Code is Chris P. Ross.
// Portions created by the Initial Developer are Copyright (C) 2000-2008
// the Initial Developer.  All Rights Reserved.
// 
// Contributor(s):
// 
// Alternatively, the contents of this file may be used under the terms of
// either the GNU General Public License Version 2 or later (the "GPL"), or
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
// in which case the provisions of the GPL or the LGPL are applicable instead
// of those above. If you wish to allow use of your version of this file only
// under the terms of either the GPL or the LGPL, and not to allow others to
// use your version of this file under the terms of the MPL, indicate your
// decision by deleting the provisions above and replace them with the notice
// and other provisions required by the GPL or the LGPL. If you do not delete
// the provisions above, a recipient may use your version of this file under
// the terms of any one of the MPL, the GPL or the LGPL.
// 
// ***** END LICENSE BLOCK *****

#ifdef  HAVE_GETCAP

#include <sstream>

#include "cfg_getcap.h"
#include "guard.h"
#include "consmgr.h"

extern "C" {
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
};

//
// Constructors & Destructor
//

Getcap::Getcap(const string &filename) : Config(filename), capent(NULL)
{
    int     ret;
    
    // Instantiate the capent mutex.
    ret = pthread_mutex_init(&capent_mtx, NULL);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_init(capent_mtx)");

    this->filename = filename;

    return;
}

Getcap::~Getcap(void)
{
    int     ret;
    
    ret = pthread_mutex_lock(&capent_mtx);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_lock(capent_mtx)");
 
    if (capent)
        free(capent);           // Allocated with malloc(), so use free()
    capent = NULL;

    ret = pthread_mutex_unlock(&capent_mtx);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_unlock(capent_mtx)");
 
    ret = pthread_mutex_destroy(&capent_mtx);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_destroy(capent_mtx)");

    return;
}

//
// Member functions
//

void
Getcap::load_entry(const string &s)
{
    int         ret;

    try {
        // Lock the mutex.
        Guard   locker(&capent_mtx);

        // If there is an entry, check to see if it's the *right* entry.
        if (capent) {
            // XXX - I should deal with caching all name values in
            // ent_name, rather than just the last ref'd one...
            if (cgetmatch(capent, (char *)s.c_str())) {
                ent_name = s;
                throw true;
            }
            free(capent);       // Allocated with malloc(), so use free()
            capent = NULL;
        }

        char    *files[2] = { const_cast<char*>(filename.c_str()), NULL };
        ret = cgetent(&capent, files, (char *)s.c_str());       

        if (ret == 0) {
            ent_name = s;
            throw true;
        }

        // Describe the error
        int                     eno = errno;
        std::ostringstream      ostr;

        switch (ret) {
          case -1:      // Entry not found
            {
                ConfigUnfoundException e(s);
                e.set_file(filename);
                throw e;
            }
            break;
          case -2:      // system error (setting errno)
            ostr << "System error " << eno << " (" << strerror(eno)
                 << ") from cgetent(" << s << ")";
            // XXX - if implement a system-error exception, put that here.
            break;
          case -3:      // potential reference loop detected
          default:
            ostr << "Got unknown non-zero response from cgetent(,," << s
                 << "): " << ret;
            break;
        }

        throw ConfigException(ostr.str());
    } catch (bool) {
#ifdef  CONFIGURATION_DEBUGGING
        clog << "Successfully read the capent for '" << s << "'" << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    } catch (...) {
        throw;
    }

    // XXX - Oh, if only getcap(3) allowed us to iterate the entries
    // in the 'capent' entry loaded from the file(s)...  Would it be
    // worth parsing it ourselves, or just load it knowing what fields
    // we expect?
    try {
        this->insert(std::pair<string,string>("host", this->str("host")));
    } catch (ConfigUnfoundException) {
#ifdef  CONFIGURATION_DEBUGGING
        clog << "Failed to find 'host', but don't care." << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    } catch (...) {
        throw;
    }
    try {
        std::ostringstream str;
        str << this->num("port");
        this->insert(std::pair<string,string>("port", str.str()));
    } catch (ConfigUnfoundException) {
#ifdef  CONFIGURATION_DEBUGGING
        clog << "Failed to find 'port', but don't care." << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    } catch (...) {
        throw;
    }
    try {
        this->insert(std::pair<string,string>("local_socket", this->str("sf")));
    } catch (ConfigUnfoundException) {
#ifdef  CONFIGURATION_DEBUGGING
        clog << "Failed to find 'sf', but don't care." << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    } catch (...) {
        throw;
    }
    // There are two names under which the logfile parameter could be stored.
    try { 
        this->insert(std::pair<string,string>("logfile", this->str("logfile")));
    } catch (ConfigUnfoundException &e) {
        // Probably just failed to see the entry.  Try the older form...
        try {
            this->insert(std::pair<string,string>("logfile",
                         this->str("lf")));
        } catch (ConfigUnfoundException) {
#ifdef  CONFIGURATION_DEBUGGING
            clog << "Failed to find 'logfile' or 'lf', but don't care." << endl;
#endif  /* CONFIGURATION_DEBUGGING */
        } catch (...) {
            throw;
        }
    } catch (...) {
        throw;
    }
    
    return;
}

//
// Utility functions to return things from the capent we've cached
//

int32_t
Getcap::num(const string &key)
{
    int         ret;
    long        val;

    if (capent == NULL)
        throw "No capent cached; cannot search for capabilities!!";

    // Lock the capent_mtx mutex with a Guard, so if we throw an exception
    // it will take care of unlocking it for us.
    Guard       locker(&capent_mtx);

    // Generate the description string, so we can note that it was supposed
    // to be a numeric element.
    if ((ret = cgetnum(this->capent, (char *)key.c_str(), &val)) != 0)
        throw ConfigUnfoundException(key, "Can't find requested numeric capability '" + key + "'...");

    return(val);
}

string
Getcap::str(const string &key)
{
    int         ret;
    char        *val;

    if (capent == NULL)
        throw ConfigException("No capent cached; cannot search for capabilities!!");

    // Limit the scope of the Guard object
    do {
        // Lock the capent_mtx mutex...
        Guard   locker(&capent_mtx);

        // Request the parameter from capent
        ret = cgetstr(this->capent, (char *)key.c_str(), &val);
        if (ret > 0)
            break;

        if (ret == -1)
            throw ConfigUnfoundException(key, "Can't find requested string "
                                         "capability '" + key + "'...");
        if (ret == -2)
            throw ConfigUnfoundException(key, "System error encountered while "
                                         "searching for capability '" + key +
                                         "'; storage allocation failure?");
        // What else could be the problem?
        throw ConfigException("Unknown error searching for string capability '"+
                              key + "'.");
    } while (0);

    string      val_s(val);

    free(val);

    // Now, do substitution if there are any '&'s in the string
#ifdef  CONFIGURATION_DEBUGGING
    clog << "String of '" << key << "' is '" << val_s << "'" << endl;
#endif  /* CONFIGURATION_DEBUGGING */
    string::size_type   p = 0;
    while ((p = val_s.find("&", p)) != string::npos) {
#ifdef  CONFIGURATION_DEBUGGING
        clog << "Did replacement..." << endl;
#endif  /* CONFIGURATION_DEBUGGING */
        val_s.replace(p, 1, this->ent_name);
    }
#ifdef  CONFIGURATION_DEBUGGING
    clog << "String of '" << key << "' is now '" << val_s << "'" << endl;
#endif  /* CONFIGURATION_DEBUGGING */

    return(val_s);
}
#endif  /* HAVE_GETCAP */

---