/*
 *  Copyright (C) 2002 - 2005 Tomasz Kojm <tkojm@clamav.net>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301, USA.
 */

#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif

#ifdef BUILD_CLAMD

#include <stdio.h>
#ifdef	HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <sys/types.h>
#ifndef	_WIN32
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif
#include <string.h>
#include <errno.h>

#include "shared/optparser.h"
#include "shared/output.h"
#include "shared/clamdcom.h"

#include "notify.h"

int
clamd_connect (const char *cfgfile, const char *option)
{
#ifndef	_WIN32
    struct sockaddr_un server;
#endif
#ifdef HAVE_GETADDRINFO
    struct addrinfo hints, *res;
    char port[6];
    const char *addr;
    int ret;
#else
    struct sockaddr_in server2;
    struct hostent *he;
#endif
    struct optstruct *opts;
    const struct optstruct *opt;
    int sockd;
    const char *socktype;


    if ((opts = optparse (cfgfile, 0, NULL, 1, OPT_CLAMD, 0, NULL)) == NULL)
    {
        logg ("!%s: Can't find or parse configuration file %s\n", option,
              cfgfile);
        return -11;
    }

#ifndef	_WIN32
    if ((opt = optget (opts, "LocalSocket"))->enabled)
    {
        socktype = "UNIX";
        memset(&server, 0x00, sizeof(server));
        server.sun_family = AF_UNIX;
        strncpy (server.sun_path, opt->strarg, sizeof (server.sun_path));
        server.sun_path[sizeof (server.sun_path) - 1] = '\0';

        if ((sockd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
        {
            logg ("^Clamd was NOT notified: Can't create socket endpoint for %s\n", opt->strarg);
            perror ("socket()");
            optfree (opts);
            return -1;
        }

        if (connect
            (sockd, (struct sockaddr *) &server,
             sizeof (struct sockaddr_un)) < 0)
        {
            closesocket (sockd);
            logg ("^Clamd was NOT notified: Can't connect to clamd through %s\n", opt->strarg);
            perror ("connect()");
            optfree (opts);
            return -11;
        }

    }
    else
#endif
    if ((opt = optget (opts, "TCPSocket"))->enabled)
    {
        socktype = "TCP";

#ifdef HAVE_GETADDRINFO
        memset (&hints, 0, sizeof (hints));
/*
#ifdef SUPPORT_IPv6
	hints.ai_family = AF_UNSPEC;
#else
*/
        hints.ai_family = AF_INET;
        hints.ai_socktype = SOCK_STREAM;
        snprintf (port, sizeof (port), "%u", (unsigned int) opt->numarg);
        port[5] = 0;

        if ((opt = optget (opts, "TCPAddr"))->enabled)
            addr = opt->strarg;
        else
            addr = NULL;

        ret = getaddrinfo (addr, port, &hints, &res);

        if (ret)
        {
            logg ("!%s: Can't resolve hostname %s (%s)\n", option,
                  addr ? addr : "",
                  (ret ==
                   EAI_SYSTEM) ? strerror (errno) : gai_strerror (ret));
            optfree (opts);
            return -1;
        }

        if ((sockd = socket (res->ai_family, SOCK_STREAM, 0)) < 0)
        {
            perror ("socket()");
            logg ("!%s: Can't create TCP socket\n", option);
            optfree (opts);
            freeaddrinfo (res);
            return -1;
        }

        if (connect (sockd, res->ai_addr, res->ai_addrlen) == -1)
        {
            perror ("connect()");
            closesocket (sockd);
            logg ("!%s: Can't connect to clamd on %s:%s\n", option,
                  addr ? addr : "localhost", port);
            optfree (opts);
            freeaddrinfo (res);
            return -1;
        }
        freeaddrinfo (res);

#else /* IPv4 */

        if ((sockd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
        {
            logg ("!%s: Can't create TCP socket\n", option);
            perror ("socket()");
            optfree (opts);
            return -1;
        }

        server2.sin_family = AF_INET;
        server2.sin_port = htons (opt->numarg);

        if ((opt = optget (opts, "TCPAddr"))->enabled)
        {
            if ((he = gethostbyname (opt->strarg)) == 0)
            {
                perror ("gethostbyname()");
                logg ("^Clamd was NOT notified: Can't resolve hostname '%s'\n", opt->strarg);
                optfree (opts);
                closesocket (sockd);
                return -1;
            }
            server2.sin_addr = *(struct in_addr *) he->h_addr_list[0];
        }
        else
            server2.sin_addr.s_addr = inet_addr ("127.0.0.1");


        if (connect
            (sockd, (struct sockaddr *) &server2,
             sizeof (struct sockaddr_in)) < 0)
        {
            closesocket (sockd);
            logg ("^Clamd was NOT notified: Can't connect to clamd on %s:%d\n", inet_ntoa (server2.sin_addr), ntohs (server2.sin_port));
            perror ("connect()");
            optfree (opts);
            return -1;
        }

#endif

    }
    else
    {
        logg ("!%s: No communication socket specified in %s\n", option,
              cfgfile);
        optfree (opts);
        return 1;
    }

    optfree (opts);
    return sockd;
}

int
notify (const char *cfgfile)
{
    char buff[20];
    int sockd, bread;

    if ((sockd = clamd_connect (cfgfile, "NotifyClamd")) < 0)
        return 1;

    if (sendln (sockd, "RELOAD", 7) < 0)
    {
        logg ("!NotifyClamd: Could not write to clamd socket\n");
        perror ("send()");
        closesocket (sockd);
        return 1;
    }

    memset (buff, 0, sizeof (buff));
    if ((bread = recv (sockd, buff, sizeof (buff), 0)) > 0)
    {
        if (!strstr (buff, "RELOADING"))
        {
            logg ("!NotifyClamd: Unknown answer from clamd: '%s'\n", buff);
            closesocket (sockd);
            return 1;
        }
    }

    closesocket (sockd);
    logg ("Clamd successfully notified about the update.\n");
    return 0;
}
#endif