common/udslistener.cc

Go to the documentation of this file.

//
// The UDSListener class - establish/maintain a connection via a UNIX Domain Socket
//
// ***** 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 *****

extern "C" {
#include <unistd.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
}

#include <sstream>

#include "consmgr.h"
#include "udslistener.h"
#include "guard.h"

UDSListener::UDSListener(SocketAddressP &path)
        : SocketListener(path)
{
}

UDSListener::~UDSListener()
{
    // Call disconnect to do any cleanup/closedown.
    disconnect();
}


void
UDSListener::disconnect()
{
    SocketListener::disconnect();

    // Lock the mutex before accessing methods in sock_addr
    // XXX Is this really necessary? I doubt it; the address is const and
    // immutable. What could happen?
    Guard       locker(&mutex);

    // Delete the socket file; no one can connect to it anymore if we're
    // no longer listening!
    reinterpret_cast<const UDSSocketAddress&>(*sock_addr).unlink();
}

int
UDSListener::make_incoming_socket()
{
    clog << "In UDSListener::make_incoming_socket()" << endl;

    // Create a new scope for the Guard, so that we release the mutex before
    // we call SocketListener::make_incoming_socket, which will lock it again.
    // However, this seems problematic; shouldn't we keep the mutex locked for
    // this entire operation? But see the note in
    // SocketListener::make_incoming_socket; this needs work, anyway.
    {
        struct stat     statbuf;
        sockaddr_un     *addr_un;
        Guard           locker(&mutex);

        addr_un = (sockaddr_un *)sock_addr->get_addr();

        // Now I need to check to make sure the UDS wasn't created earlier.
        // Perhaps I should catch this error, but for now just nuking it seems
        // an acceptable action...
        if ((stat(addr_un->sun_path, &statbuf) >= 0) &&
            (S_ISSOCK(statbuf.st_mode))) {
            clog << "Auto-nuking \"" << addr_un->sun_path << "\"..." << endl;
            unlink(addr_un->sun_path);
        } else {
            // XXX - While I'm here, I should catch if it's *not* a socket
            // file, perhaps if it's a file, directory, etc...
            clog << "Hrm, the UDS path '" << addr_un->sun_path << "' exists, "
                 << "but is not a socket.  Its st_mode is " << statbuf.st_mode
                 << endl;
        }
    }

    // Okay, now do the rest of the work
    return SocketListener::make_incoming_socket();
}

//
// Generate a string to tell a human who we are...
//

std::string
UDSListener::get_id() const
{
    std::ostringstream  id_str;

    id_str << "UDSListener[" << sock_addr->get_id() << "]";

    return(id_str.str());
}

---