UdpLogger.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI
//
// UdpLogger.cpp: implementation of a simple UDP Logger object.
//
// Author: FESA team
//
//  May 2007
//      - added to the FESA Framework for the DIAGNOSTIC protoyping
//
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/Diagnostic/UdpLogger.h>
#include <signal.h>
#include <string>
#include <cstring>

namespace fesa
{

    UdpLogger::UdpLogger(const char* hostname, unsigned short& port, const bool connectMode) : udpConn(connectMode)
    {

        // init of the UDP channel
        hostent* host = gethostbyname(const_cast<char *> (hostname));
        if (strlen(hostname) && (host != NULL))
        {

            if ((udpSock = socket(AF_INET, SOCK_DGRAM, 0)) != -1)
            {

                if (port == 0)
                {
                    //Dynamic allocation: need to find a port number

                    udpAttr.sin_addr.s_addr = htonl(INADDR_ANY);
                    udpAttr.sin_family = AF_INET;
                    udpAttr.sin_port = htons(port);

                    if (bind(udpSock, (struct sockaddr *) &udpAttr, sizeof(udpAttr)) != -1)
                    {

                        socklen_t slen = sizeof(udpAttr);
                        if (getsockname(udpSock, (struct sockaddr*) &udpAttr, &slen) != -1)
                        {
                            port = udpAttr.sin_port; // retrieve allocated port number
                        }
                        else
                        {
                            std::string errMsg("UdpLogger constructor/ getsockname failed: " + std::string(strerror(
                                            errno)));
                            throw FesaException(__FILE__, __LINE__, "FESA_FWK");
                        }
                    }
                    else
                    {
                        std::string errMsg("UdpLogger constructor/ bind failed: " + std::string(strerror(errno)));
                        throw FesaException(__FILE__, __LINE__, "FESA_FWK");
                    }
                }

                udpAttr.sin_addr.s_addr = (int32_t) *((int32_t *) host->h_addr);
                udpAttr.sin_family = AF_INET;
                udpAttr.sin_port = htons(port);

                // TODO change these exceptions
                // to receive ICMP "not reachable" if nobody is listening
                if (udpConn)
                {
                    if (connect(udpSock, (struct sockaddr *) &udpAttr, sizeof(udpAttr)) < 0)
                    {
                        std::string errMsg("UdpLogger constructor/ connect failed: " + std::string(strerror(errno)));
                        throw FesaException(__FILE__, __LINE__, "FESA_FWK");
                    }
                }
            }
            else
            {
                std::string errMsg("UdpLogger constructor/ socket failed: " + std::string(strerror(errno)));
                throw FesaException(__FILE__, __LINE__, "FESA_FWK");
            }
        }
        else
        { //host unknown
            throw FesaException(__FILE__, __LINE__, "FESA_FWK");
        }
    }
    ;

    UdpLogger::~UdpLogger()
    {

        if (close(udpSock) < 0)
        {
            std::string errMsg("UdpLogger destructor/ close failed: " + std::string(strerror(errno)));
            throw FesaException(__FILE__, __LINE__, "FESA_FWK");
        }
    }
    ;

    int32_t UdpLogger::sendStr(const char* msg)
    {

        //This method send a UDP frame which should not excedd 8Kb to garantee atomic send.
        //Iterative send (size > MAX_UDP_SEND_SIZE(~8Kb)) is not safe but can be tolerate
        //for rare case of large config/state files.

        //sendStr expects string format (null terminated buffer)
        /*send will fail (<0) if no listener or bad UDP channel*/
        if (udpConn)
        {
            //catch SIGPIPE to prevent process exit when client disconnect during sending!
            //be careful: this protection could interfer with middle-ware if connected mode is used!
            void (*sigpipeHandler)(int32_t);
            sigpipeHandler = signal(SIGPIPE, (void(*)(int32_t)) SIG_IGN);

            //connected mode
            if (send(udpSock, msg, strlen(msg) + 1, 0) < 0)
                return (errno);

            //restore old handler
            signal(SIGPIPE, (void(*)(int32_t)) sigpipeHandler);
        }
        else
        {
            //not-connected mode
            if (sendto(udpSock, msg, strlen(msg) + 1, 0, (struct sockaddr *) &udpAttr, sizeof(udpAttr)) < 0)
                return (errno);
        }

        return 0;
    }
    ;
}