/*
 * Copyright (C) 2000-2012 Free Software Foundation, Inc.
 * Author: Nikos Mavrogiannopoulos
 *
 * This file is part of GnuTLS.
 *
 * GnuTLS is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GnuTLS 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, see <https://www.gnu.org/licenses/>.
 */

#ifndef GNUTLS_SRC_COMMON_H
#define GNUTLS_SRC_COMMON_H

#define SERVER "127.0.0.1"

#include "config.h"
#include <gnutls/gnutls.h>
#include <gnutls/pkcs11.h>
#include "certtool-common.h"
#include <c-ctype.h>
#include <string.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#ifndef _WIN32
#include <netinet/in.h>
#endif

#include <signal.h>
#ifdef _WIN32
#include <io.h>
#include <winbase.h>
#include <sys/select.h>
#include "socket.h"
#undef OCSP_RESPONSE
#endif
#include "timespec.h"

#ifndef __attribute__
#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5)
#define __attribute__(Spec) /* empty */
#endif
#endif

/* the number of elements in the priority structures.
 */
#define PRI_MAX 16

extern const char str_unknown[];

#define P_PRINT_CERT 1
#define P_WAIT_FOR_CERT (1 << 1)
int print_info(gnutls_session_t state, int verbose, int flags);
void print_cert_info(gnutls_session_t, int flag, int print_cert);
void print_key_material(gnutls_session_t, const char *label, size_t size);

int log_msg(FILE *file, const char *message, ...)
	__attribute__((format(printf, 2, 3)));
void log_set(FILE *file);

void print_cert_info2(gnutls_session_t, int flag, FILE *fp, int print_cert);

void print_list(const char *priorities, int verbose);
int cert_verify(gnutls_session_t session, const char *hostname,
		const char *purpose);

int compress_cert_set_methods(gnutls_session_t session, const char **strings,
			      size_t n_strings);

const char *raw_to_string(const unsigned char *raw, size_t raw_size);
const char *raw_to_hex(const unsigned char *raw, size_t raw_size);
const char *raw_to_base64(const unsigned char *raw, size_t raw_size);
int check_command(gnutls_session_t session, const char *str,
		  unsigned no_cli_cert);

#define MAX_PIN_LEN GNUTLS_PKCS11_MAX_PIN_LEN
void getenv_copy(char *str, size_t max_str_size, const char *envvar);
void getpass_copy(char *pass, size_t max_pass_size, const char *prompt);

int pin_callback(void *user, int attempt, const char *token_url,
		 const char *token_label, unsigned int flags, char *pin,
		 size_t pin_max);

void pkcs11_common(common_info_st *c);

inline static int is_ip(const char *hostname)
{
	int len = strlen(hostname);

	if (strchr(hostname, ':') != 0)
		return 1;
	else if (len > 2 && c_isdigit(hostname[0]) &&
		 c_isdigit(hostname[len - 1]))
		return 1;
	return 0;
}

void sockets_init(void);

#ifdef _WIN32
static int system_recv_timeout(gnutls_transport_ptr_t ptr, unsigned int ms)
{
	fd_set rfds;
	struct timeval tv;
	socket_st *hd = ptr;
	int fd = hd->fd;

	FD_ZERO(&rfds);
	FD_SET(fd, &rfds);

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

	return select(fd + 1, &rfds, NULL, NULL, &tv);
}

static ssize_t system_write(gnutls_transport_ptr ptr, const void *data,
			    size_t data_size)
{
	socket_st *hd = ptr;

	return send(hd->fd, data, data_size, 0);
}

static ssize_t system_read(gnutls_transport_ptr_t ptr, void *data,
			   size_t data_size)
{
	socket_st *hd = ptr;

	return recv(hd->fd, data, data_size, 0);
}

static void set_read_funcs(gnutls_session_t session)
{
	gnutls_transport_set_push_function(session, system_write);
	gnutls_transport_set_pull_function(session, system_read);
	gnutls_transport_set_pull_timeout_function(session,
						   system_recv_timeout);
}
#else
#define set_read_funcs(x)
#endif

#define SIMPLE_CTIME_BUF_SIZE 64
char *simple_ctime(const time_t *t, char buf[SIMPLE_CTIME_BUF_SIZE]);

void get_system_time(struct timespec *ts);
void set_system_time(struct timespec *ts);

#endif /* GNUTLS_SRC_COMMON_H */
