/*
 *  Copyright (C) 2015 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
 *  Copyright (C) 2009-2010 Sourcefire, Inc.
 *
 *  Author: aCaB, Mickey Sola
 *
 *  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

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <curl/curl.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <fcntl.h>
#include <errno.h>

#if !defined(_WIN32)
#include <sys/socket.h>
#endif

#include "shared/output.h"

#include "communication.h"


static int onas_socket_wait(curl_socket_t sockfd, int32_t b_recv, uint64_t timeout_ms);

/**
 * Function from curl example code, Copyright (C) 1998 - 2018, Daniel Stenberg, see COPYING.curl for license details
 */
static int onas_socket_wait(curl_socket_t sockfd, int32_t b_recv, uint64_t timeout_ms)
{
  struct timeval tv;
  fd_set infd, outfd, errfd;
  int ret;

  tv.tv_sec = timeout_ms / 1000;
  tv.tv_usec = (timeout_ms % 1000) * 1000;

  FD_ZERO(&infd);
  FD_ZERO(&outfd);
  FD_ZERO(&errfd);

  FD_SET(sockfd, &errfd); /* always check for error */

  if(b_recv) {
    FD_SET(sockfd, &infd);
  }
  else {
    FD_SET(sockfd, &outfd);
  }

  /* select() returns the number of signalled sockets or -1 */
  ret = select((int)sockfd + 1, &infd, &outfd, &errfd, &tv);
  return ret;
}

/* Sends bytes over a socket
 * Returns 0 on success */
int onas_sendln(CURL *curl, const void *line, size_t len, int64_t timeout) {
	size_t sent = 0;
	CURLcode curlcode;
	curl_socket_t sockfd;

	curlcode = curl_easy_getinfo(curl, CURLINFO_ACTIVESOCKET, &sockfd);

	if(CURLE_OK != curlcode) {
		logg("!ClamCom: could not get curl active socket info %s\n", curl_easy_strerror(curlcode));
		return 1;
	}

	while(len) {

		do {
			curlcode = curl_easy_send(curl, line, len, &sent);
			if (CURLE_AGAIN == curlcode && !onas_socket_wait(sockfd, 0, timeout)) {
				logg("!ClamCom: TIMEOUT while waiting on socket (send)\n");
				return 1;
			}
		} while (CURLE_AGAIN == curlcode);


		if(sent <= 0) {
			if(sent && errno == EINTR) {
				continue;
			} else {
				logg("!Can't send to clamd: %s\n", strerror(errno));
			}

			return 1;
		}

		line += sent;
		len -= sent;
	}

	return 0;
}

/* Inits a RECVLN struct before it can be used in recvln() - see below */
void onas_recvlninit(struct RCVLN *rcv_data, CURL *curl) {
	rcv_data->curl = curl;
	rcv_data->curlcode = CURLE_OK;
	rcv_data->lnstart = rcv_data->curr = rcv_data->buf;
	rcv_data->retlen = 0;
}

/* Receives a full (terminated with \0) line from a socket
 * Sets ret_bol to the begin of the received line, and optionally
 * ret_eol to the end of line.
 * Should be called repeatedly until all input is consumed
 * Returns:
 * - the length of the line (a positive number) on success
 * - 0 if the connection is closed
 * - -1 on error
 */
int onas_recvln(struct RCVLN *rcv_data, char **ret_bol, char **ret_eol, int64_t timeout) {
	char *eol;
	int ret = 0;
	curl_socket_t sockfd;

	rcv_data->curlcode = curl_easy_getinfo(rcv_data->curl, CURLINFO_ACTIVESOCKET, &sockfd);

	if(CURLE_OK != rcv_data->curlcode) {
		logg("!ClamCom: could not get curl active socket info %s\n", curl_easy_strerror(rcv_data->curlcode));
		return -1;
	}

	while(1) {
		if (!rcv_data->retlen) {
                    do {
			rcv_data->curlcode = curl_easy_recv(rcv_data->curl, rcv_data->curr,
					sizeof(rcv_data->buf) - (rcv_data->curr - rcv_data->buf), &(rcv_data->retlen));

			if (CURLE_AGAIN == rcv_data->curlcode && !onas_socket_wait(sockfd, 1, timeout)) {
				logg("!ClamCom: TIMEOUT while waiting on socket (recv)\n");
				return -1;
			}

                    } while (CURLE_AGAIN == rcv_data->curlcode);

			if (rcv_data->retlen<=0) {
				if (rcv_data->retlen && errno == EINTR) {
					rcv_data->retlen = 0;
					continue;
				}

				if (rcv_data->retlen || rcv_data->curr!=rcv_data->buf) {
					*rcv_data->curr = '\0';

					if (strcmp(rcv_data->buf, "UNKNOWN COMMAND\n")) {
						logg("!Communication error\n");
					} else {
						logg("!Command rejected by clamd (wrong clamd version?)\n");
					}

					return -1;
				}

				return 0;
			}
		}

		if ((eol = memchr(rcv_data->curr, 0, rcv_data->retlen))) {
			eol++;
			rcv_data->retlen -= eol - rcv_data->curr;

			*ret_bol = rcv_data->lnstart;
			if (ret_eol) {
				*ret_eol = eol;
			}

			ret = eol - rcv_data->lnstart;
			if (rcv_data->retlen) {
				rcv_data->lnstart = rcv_data->curr = eol;
			} else {
				rcv_data->lnstart = rcv_data->curr = rcv_data->buf;
			}

			return ret;
		}

		rcv_data->retlen += rcv_data->curr - rcv_data->lnstart;

		if (!eol && rcv_data->retlen==sizeof(rcv_data->buf)) {
			logg("!Overlong reply from clamd\n");
			return -1;
		}

		if (!eol) {
			if(rcv_data->buf != rcv_data->lnstart) {
				memmove(rcv_data->buf, rcv_data->lnstart, rcv_data->retlen);
				rcv_data->lnstart = rcv_data->buf;
			}

			rcv_data->curr = &rcv_data->lnstart[rcv_data->retlen];
			rcv_data->retlen = 0;
		}
	}
}