void sigint_handler(int signum)
{
    // do cleanups here and free all existing variables and stuff
    log_out("Closing client on: %d...\n", socket_get_fd(s));
    socket_close(s);
    exit(signum);
}

/**
 * netplay_new:
 * @server               : IP address of server.
 * @port                 : Port of server.
 * @frames               : Amount of lag frames.
 * @cb                   : Libretro callbacks.
 * @spectate             : If true, enable spectator mode.
 * @nick                 : Nickname of user.
 *
 * Creates a new netplay handle. A NULL host means we're
 * hosting (user 1).
 *
 * Returns: new netplay handle.
 **/
netplay_t *netplay_new(const char *server, uint16_t port,
                       unsigned frames, const struct retro_callbacks *cb,
                       bool spectate,
                       const char *nick)
{
    netplay_t *netplay = NULL;

    if (frames > UDP_FRAME_PACKETS)
        frames = UDP_FRAME_PACKETS;

    netplay = (netplay_t*)calloc(1, sizeof(*netplay));
    if (!netplay)
        return NULL;

    netplay->fd                = -1;
    netplay->udp_fd            = -1;
    netplay->cbs               = *cb;
    netplay->port              = server ? 0 : 1;
    netplay->spectate.enabled  = spectate;
    netplay->is_server         = server == NULL;
    strlcpy(netplay->nick, nick, sizeof(netplay->nick));

    if(spectate)
        netplay->net_cbs = netplay_get_cbs_spectate();
    else
        netplay->net_cbs = netplay_get_cbs_net();

    if (!init_socket(netplay, server, port))
    {
        free(netplay);
        return NULL;
    }

    if(!netplay_info_cb(netplay, frames))
        goto error;

    return netplay;

error:
    if (netplay->fd >= 0)
        socket_close(netplay->fd);
    if (netplay->udp_fd >= 0)
        socket_close(netplay->udp_fd);

    free(netplay);
    return NULL;
}

void
udp_detach(struct socket *so)
{
	socket_close(so->s);
	/* if (so->so_m) m_free(so->so_m);    done by sofree */

	sofree(so);
}

void ThreadedSocketConnection::disconnect()
{ QF_STACK_PUSH(ThreadedSocketConnection::disconnect)
  
  m_disconnect = true;
  socket_close( m_socket );

  QF_STACK_POP
}

/*
 * Used to kill the server properly when receiving SIGINT (^C).
 * TODO : this function should also kill all living sons of the main process,
 * and close the associated sockets.
 * (Should we store their pids in a global array ?)
 */
static void 
kill_server (int signum)
{
    /* Dummy assignment to shut the compiler up */
    signum = signum;
    socket_close (server_socket);
    exit (EXIT_SUCCESS);
}

/** Deinitialize and free Netplay discovery */
void deinit_netplay_discovery(void)
{
   if (lan_ad_client_fd >= 0)
   {
      socket_close(lan_ad_client_fd);
      lan_ad_client_fd = -1;
   }
}

void irc_disconnect (irc_session_t * session)
{
	if ( session->sock >= 0 )
		socket_close (&session->sock);

	session->sock = -1;
	session->state = LIBIRC_STATE_INIT;
}

static int net_http_new_socket(const char *domain, int port)
{
   int fd;
#ifndef _WIN32
   struct timeval timeout;
#endif
   struct addrinfo hints, *addr = NULL;
   char portstr[16] = {0};

   snprintf(portstr, sizeof(portstr), "%i", port);

   memset(&hints, 0, sizeof(hints));
   hints.ai_family   = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags    = 0;

   if (getaddrinfo_rarch(domain, portstr, &hints, &addr) < 0)
      return -1;
   if (!addr)
      return -1;

   fd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);

#ifndef _WIN32
   timeout.tv_sec=4;
   timeout.tv_usec=0;
   setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof timeout);
#endif

   if (connect(fd, addr->ai_addr, addr->ai_addrlen) != 0)
   {
      freeaddrinfo_rarch(addr);
      socket_close(fd);
      return -1;
   }

   freeaddrinfo_rarch(addr);

   if (!socket_nonblock(fd))
   {
      socket_close(fd);
      return -1;
   }

   return fd;
}

void ssl_socket_close(void *state_data)
{
   struct ssl_state *state = (struct ssl_state*)state_data;

   mbedtls_ssl_close_notify(&state->ctx);

   socket_close(state->net_ctx.fd);
}

void server_pensionerHtmlID(socket_t * client, resource_t * lt, http_request_t * req)
{
    char buf[10000] = "";
    char * p = strstr(req->uri, "/pensioners/");
    p = p + 12;
    int index = atoi(p);

    if(index >= 0)
    {
        for(int i = 0; i < resource_getCnt(lt); i++)
        {
            if(index == resource_getID(lt, i))
            {
                if(strcmp(req->method, "GET") == 0)
                {
                    char pText[1000] = "";
                    char * text = pensioner_toHTML(resource_getbyId(lt, index), index);
                    strcat(pText, text);

                    char * pageText = "<a href=\"http://127.0.0.1:5000/pensioners\"><br>Back to the list.</a>";
                    strcat(pText, pageText);

                    char * textHtml = textToBuf_HTML(pText);
                    strcat(buf, textHtml);
                    free(textHtml);
                }
                else if(strcmp(req->method, "DELETE") == 0)
                {
                    char pText[1000] = "";
                    char * text = pensioner_toHTML(resource_deletePens(lt, index), index);
                    strcat(pText, text);
                    free(text);

                    sprintf(buf,
                            "HTTP/1.1 200 OK\n"
                            "Access-Control-Allow-Origin: *\n"
                            "Access-Control-Allow-Methods: DELETE\n"
                            "\n");
                }
            }
        }
        char * message = "<h3 style=\"color:orange\">ID not found!</h3>";
        char * textHtml = textToBuf_HTML(message);
        strcat(buf, textHtml);
        free(textHtml);

    }
    else
    {
        char * message = "<h3 style=\"color:orange\">ID not found!</h3>";
        char * textHtml = textToBuf_HTML(message);
        strcat(buf, textHtml);
        free(textHtml);

    }
    socket_write_string(client, buf);
    socket_close(client);
}

static void server_post(http_request_t request, socket_t* client, leading_t** leadings){
    int id = 0;
    int count = leading_leadingsCount(leadings);
    char buffer[2000] ="";
    char* str;
    char* name = http_request_getArg(&request, "name");
    char* surname = http_request_getArg(&request, "surname");
    char* birthdate = http_request_getArg(&request, "birthdate");
    char* experience = http_request_getArg(&request, "experience");
    char* rating = http_request_getArg(&request, "rating");

    if(strlen(name) <= 1 || strlen(surname) <= 1 || strlen(birthdate) <= 1){
        server_send(client, "Name/Surname/Birthday wasn't filled in"
                            "<p><a href=\"/leadings/new/\">Back to POST</a></p>");
        return;
    }

    str = birthdate;

   if(strlen(birthdate) > 10 || str[4] != '-' || str[7] != '-' || isdigit(birthdate[0])==0 || isdigit(experience[0]) == 0 || isdigit(rating[0])==0){
        server_send(client, "Wrong data!"
                    "<p><a href=\"/leadings/new/\">Back to POST</a></p>");
        return;
    }

    if(experience == " ")
        experience = "0";

    if(rating == " ")
        rating = "0.0";

    if(count >= MAX_LEADINGS){
        char fail[] = "Limit of leadings!";
        sprintf(buffer,
            "HTTP/1.1 404 \n"
            "Content-Type: text\n"
            "Content-Length: %i\r\n\r\n"
            "\n%s", strlen(fail), fail);

        socket_write_string(client, buffer);
        socket_close(client);
        return;
    }

    for(int i = 0; i<MAX_LEADINGS; i++, id++)
    {
        if(leading_getId(leadings[i]) == -1)
            break;
    }

    int exp = atoi(experience);
    double rate = atof(rating);

    leading_fill(leadings[id], id, name, surname, birthdate, exp, rate);
    server_send(client, "Success"
                "<p><a href=\"/leadings/\">All leadings</a></p>");

}

int socket_tcp_listen(const char *hostname, const char *port) {
	// NULL port / service name is not accepted.
	// NULL hostname is OK. (== bind to any interface)
	if (!port) {
		return -1;
	}

	struct addrinfo *address, hints;
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_INET6;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE | AI_ALL | AI_V4MAPPED;

	int r = -1;	
	if (0 != (r = getaddrinfo(hostname, port, &hints, &address))) {
		return -1;
	}
	int fd = -1;
	for (struct addrinfo *iter = address; iter; iter = iter->ai_next) {
		if (-1 == (fd = socket(iter->ai_family, iter->ai_socktype, address->ai_protocol))) {
			perror("socket");
			continue;
		}
		int yes = 1;
		if (-1 == setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))) {
			perror("setsockopt");
			socket_close(&fd);
			continue;
		}
		if (-1 == bind(fd, iter->ai_addr, iter->ai_addrlen)) {
			perror("bind");
			socket_close(&fd);
			continue;
		}
		if (-1 == listen(fd, 128)) {
			perror("listen");
			socket_close(&fd);
		}
		// Success
		break;
	}
	freeaddrinfo(address);

	return fd;
}

int nettest5(void)
{
	int err;
	sockaddr addr;
	int new_fd;

	fd = socket_create(SOCK_PROTO_TCP, 0);
	printf("created socket, fd %d\n", fd);
	if(fd < 0)
		return 0;

	memset(&addr, 0, sizeof(addr));
	addr.addr.len = 4;
	addr.addr.type = ADDR_TYPE_IP;
	addr.port = 1900;
	NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(0,0,0,0);

	err = socket_bind(fd, &addr);
	printf("socket_bind returns %d\n", err);
	if(err < 0)
		return 0;

	err = socket_listen(fd);
	printf("socket_listen returns %d\n", err);
	if(err < 0)
		return 0;

	new_fd = socket_accept(fd, &addr);
	printf("socket_accept returns %d\n", new_fd);
	if(new_fd < 0)
		return 0;

	err = socket_write(new_fd, "hello world!\n", strlen("hello world!\n"));
	printf("socket_write returns %d\n", err);

	printf("sleeping for 5 seconds\n");
	usleep(5000000);

	printf("closing fd %d\n", new_fd);
	socket_close(new_fd);
	printf("closing fd %d\n", fd);
	socket_close(fd);

	return 0;
}

int main(int argc, char* argv[]) {
  gint error = 0;
  options_init(argc - 1, argv + 1);

  INFO("Starting up.");
  descriptor_init();

  DEBUG("Disabling SIGPIPE.");
  signal(SIGPIPE, SIG_IGN);

  DEBUG("Creating ZeroMQ context.");
  gpointer zmq_context = zmq_init(options_zmq_io_threads());
  if (zmq_context == NULL) {
    PERROR("main(zmq_init)");
    error = 1;
    goto err0;
  }

  DEBUG("Creating server on port %s.", options_port());
  gint socket = socket_server(options_port());
  if (socket == -1) {
    error = 1;
    goto err1;
  }

  INFO("Initialising Lua API.");
  lua_api_init(zmq_context, argc - 1, argv + 1);
  lua_State* lua = lua_api_get();
  DEBUG("Running " LUA_START_FILE);
  if (luaL_dofile(lua, LUA_START_FILE) == 1) {
    ERROR("%s", lua_tostring(lua, -1));
    error = 1;
    goto err2;
  }

  io_mainloop(socket);

 err2:
  DEBUG("Closing server socket.");
  socket_close(socket);
 err1:
  DEBUG("Terminating ZeroMQ context.");
  /* This is separate from lua_api_deinit() to prevent zmq_term() from
     blocking forever. */
  lua_zmq_deinit();
  zmq_term(zmq_context);
 err0:
  DEBUG("Enabling SIGPIPE.");
  signal(SIGPIPE, SIG_DFL);
  options_deinit();
  descriptor_deinit();
  if (lua_api_get() != NULL) {
    DEBUG("Closing Lua state.");
    lua_api_deinit();
  }
  return error;
}

void listener_release(struct listener *self) {
	assert(self != NULL);
	assert(!self->isfree);
	if (!self)
		return;
	socket_close(&self->sockfd);
	self->isfree = true;
	netpool_releaselisten(self);
}

static int
st_local_socket_close(int sd)
{
	if (!use_obp) {
		return (socket_close(sd));
	} else {
		return (0);
	}
}

void player_close(player_info_t *player) {
	socket_close(player->socket);
	if ( player == players ) {
		players = player->next;
	} else {
		player->prev->next = player->next;
	}
	free(player);
}

void net_http_delete(struct http_t *state)
{
   if (!state)
      return;

   if (state->fd >= 0)
      socket_close(state->fd);
   free(state);
}

static void ClientNetworkLayerClose(UA_Connection *connection) {
    if(connection->state == UA_CONNECTION_CLOSED)
        return;
    connection->state = UA_CONNECTION_CLOSED;
    socket_close(connection);
#ifndef UA_MULTITHREADING
    UA_ByteString_delete(connection->handle);
#endif
}

int ipc_server_close(int fd, int last_error)
{
    int ret = 0;
    
    if (!last_error)
	ret = ipc_server_sync(fd);
    socket_close(fd);
    return ret;
}