#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#ifndef WIN32
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>
#endif

#ifndef __USE_GNU
#define __USE_GNU
#endif

#ifdef WIN32
#define gethostbyname2(a, b) gethostbyname(a)
#else
#include <unistd.h>
#endif

#define BUFLEN 65535

void diep(char *s)
{
  perror(s);
  exit(1);
}

int split_host_port(char *input, int default_port, char **host, int *port)
{
  char *p;
    
  *host = strdup(input);
    
  if ((p = strchr(*host, ':')))
    {
      *port = strtol(p+1, NULL, 0);
      *p = 0;
    }
  else
    {
      *port = default_port;
    }
    
  return 1;
}

int open_udp_socket(int port)
{
  struct sockaddr_in si_me;
  int s;
  int reuse = 1;
    
  if ((s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
    return(-1); // diep("socket");

  if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof(reuse)) != 0)
    return(-1); //diep("setsockaopt");

  memset((char *) &si_me, 0, sizeof(si_me));
  si_me.sin_family = AF_INET;
  si_me.sin_port = htons(port);
  si_me.sin_addr.s_addr = htonl(INADDR_ANY);
  if (::bind(s, (struct sockaddr *) &si_me, sizeof(si_me)) != 0)
    return(-1); //diep("bind");
    
  return s;
}

void send_udp_datagram(void *buf, int len, int socket, char *target_host, int target_port)
{
  struct sockaddr_in target_si;

  struct addrinfo hints, *res = NULL, *p;
  int errcode;

  memset(&target_si, 0, sizeof(target_si));
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_INET; /* IPv4 */
  //  hints.ai_socktype = SOCK_STREAM;
  //  hints.ai_flags |= AI_CANONNAME;

  if((errcode = getaddrinfo(target_host, NULL, &hints, &res))
     || !res)
    return;

  for (p = res; p != NULL; p = p->ai_next) {
    memcpy(&target_si, res->ai_addr, res->ai_addrlen);
    break;
  }

  freeaddrinfo(res);

  target_si.sin_port = htons(target_port);
    
  if (sendto(socket, (const char*)buf, len, 0, (struct sockaddr *) &target_si, sizeof(target_si)) == -1)
    return; //diep("sendto");
}    

int receive_udp_datagram(void *buf, int max, int socket, char **sender_host, int *sender_port)
{
  struct sockaddr_in sender_si;
  int slen = sizeof(sender_si);
  int nr;
    
  nr = recvfrom(socket, (char*)buf, BUFLEN, 
#ifdef WIN32
	  0,
#else
	  MSG_DONTWAIT, // TODO: add select() to avoid waiting forever
#endif
	  (struct sockaddr *) &sender_si, (socklen_t*)&slen);
  if (nr == -1)
    {
      if (errno == EAGAIN || errno == EWOULDBLOCK)
	return 0;
        
      return(-1); //diep("recvfrom");
    }
    
  if (sender_host)
    *sender_host = inet_ntoa(sender_si.sin_addr);
    
  if (sender_port)
    *sender_port = ntohs(sender_si.sin_port);
    
  return nr;
}

/* Borrowed from the GNU libc manual. */
int input_timeout(int filedes, unsigned int seconds)
{
  fd_set set;
  struct timeval timeout;

  /* Initialize the file descriptor set. */
  FD_ZERO(&set);
  FD_SET(filedes, &set);

  /* Initialize the timeout data structure. */
  timeout.tv_sec = seconds;
  timeout.tv_usec = 0;

  /* `select' returns 0 if timeout, 1 if input available, -1 if error. */
  return /* TEMP_FAILURE_RETRY*/(select(FD_SETSIZE,
					&set, NULL, NULL,
					&timeout));
}