int rfind_client_start(const char* username, const char* server) {
  int fd = connect_to(server, default_register_port);
  if (fd < 0) {
    fprintf(stderr, "socket open error\n");
    return -1;
  }
  char buf[protocol_buf_size];
  int reg;
  sprintf(buf, "1%s", username);
  if (write(fd, buf, strlen(buf)) < 0) {
    fprintf(stderr, "find register error\n");
    close(fd);
    return -1;
  }
  if (read(fd, &reg, sizeof(int)) < 0) {
    fprintf(stderr, "find register error\n");
    close(fd);
    return -1;
  }
  close(fd);
  if (reg == -1) {
    fprintf(stderr, "server no start\n");
    return -1;
  }
  return connect_to(server, reg);
}

ret_t
cherokee_downloader_connect (cherokee_downloader_t *downloader)
{
	ret_t               ret;
	cherokee_boolean_t  uses_proxy;
	cherokee_url_t     *url  = &downloader->request.url;

	/* Does it use a proxy?
	 */
	uses_proxy = ! cherokee_buffer_is_empty (&downloader->proxy);
	ret = cherokee_request_header_uses_proxy (&downloader->request, uses_proxy);
	if (ret != ret_ok) return ret;

	/* Connect
	 */
	if (uses_proxy) {
		ret = connect_to (downloader, &downloader->proxy, downloader->proxy_port, http);
		if (ret != ret_ok) return ret;
	} else {
		ret = connect_to (downloader, &url->host, url->port, url->protocol);
		if (ret != ret_ok) return ret;
	}

	return ret_ok;
}

void write_register(char * username, char * password){
	
   if (client_connection_id > 0){
    printf(RED "Tenés que desconectarte de tu usuario actual para poder crear otro.\n" RESET_COLOR);
    return;
   }

   client_connection_id = connect_to((void*)&server_info);

   if (client_connection_id < 0){
       print_error();
          return;
    }

    maxfd = client_connection_id;
    FD_SET(client_connection_id, &fds);
    logged =1;


    write_byte(client_send_buffer, REGISTER_USER);
    write_string(client_send_buffer, username);
    write_string(client_send_buffer, password);

    flush_buffer(client_connection_id, client_send_buffer);

}

void write_login(char * username, char * password, char color){
	
    if (client_connection_id > 0){
      printf(RED "Ya estás logeado.\n" RESET_COLOR);
      return;
    }

    client_connection_id = connect_to((void*)&server_info);

    if (client_connection_id <= 0){
        print_error();
        return;
    }

    maxfd = client_connection_id;
    FD_SET(client_connection_id, &fds);
    logged =1;

    write_byte(client_send_buffer, LOGIN);
    write_string(client_send_buffer, username);
    write_string(client_send_buffer, password);
    write_byte(client_send_buffer, color);

    flush_buffer(client_connection_id, client_send_buffer);

}

void t04_server_timeout_threaded(){
  INIT_LOCAL();
  CURL *curl=prepare_curl("http://localhost:8082");

  o=onion_new(O_THREADED | O_DETACH_LISTEN);
  onion_set_root_handler(o,onion_handler_new((void*)process_request,NULL,NULL));
  onion_set_port(o,"8082");
  onion_set_timeout(o,2000);
  onion_listen(o);
  sleep(1);

  int fd=connect_to("localhost","8082");
  sleep(3);
  // Should have closed the connection
  int w=write(fd,"GET /\n\n",7);
  FAIL_IF_NOT_EQUAL_INT(w,7);
  char data[256];
  FAIL_IF(read(fd, data,sizeof(data))>0);
  close(fd);

  FAIL_IF_NOT(curl_get(curl, "http://localhost:8082"));

  onion_free(o);
	curl_easy_cleanup(curl);
  END_LOCAL();
}

 void node::attempt_new_connection()
 {
    for( auto p : _potential_peers )
    {
      // try a connection...
      if( !p.second.is_connected )
      {
         try {
            connect_to( p.second.peer_endpoint );
            p.second.last_connect_attempt = fc::time_point::now();
         } 
         catch ( const fc::exception& e )
         {
            wlog( "${ep} : ${e}", ("ep", p.second.peer_endpoint )("e",e.to_detail_string() ) );
            p.second.last_connect_attempt = fc::time_point::now();
            p.second.failed_attempts++;
         }
      }
    }
    if( _peers.size() < _desired_peer_count )
    {
       ilog( "attempting new connections to peers: ${d} of ${desired}", ("d",_peers.size())("desired",_desired_peer_count) );
       _attempt_new_connections_task = fc::schedule( [=](){ attempt_new_connection(); }, fc::time_point::now() + fc::seconds(60) );
    }
    else {
       ilog( "we have the desired number of peers: ${d} of ${desired}", ("d",_peers.size())("desired",_desired_peer_count) );
    }
 }

int rfind_server_start() {
  int fd = connect_to("localhost", default_register_port);
  if (fd < 0) {
    fprintf(stderr, "socket open error\n");
    return -1;
  }
  int reg;
  char* name = getenv("USER");
  char buf[protocol_buf_size];
  sprintf(buf, "0%s", name);
  if (write(fd, buf, strlen(buf)) < 0) {
    fprintf(stderr, "register error\n");
    close(fd);
    return -1;
  }
  if (read(fd, &reg, sizeof(int)) < 0) {
    fprintf(stderr, "register error\n");
    close(fd);
    return -1;
  }
  close(fd);
  if (reg == -1) {
    fprintf(stderr, "register fail\n");
    return -1;
  }
  fprintf(stderr, "assigned port: %d\n", reg);
  return init_server(reg);
}

void handle_request(int s, const char **argv)
{
    Connection conn;
    pthread_t threads[2];
    
    // assign fds
    conn.client_to_server = s;
    conn.server_to_client = connect_to(argv[2], argv[3]);
    
    // print client info
    print_peer_information(s);
    
    // create threads to handle each connections
    pthread_create(&threads[0], NULL, handle_client_to_server, &conn);
    pthread_create(&threads[1], NULL, handle_server_to_client, &conn);
    
    // wait for all threads terminates
    pthread_join(threads[0], NULL);
    pthread_join(threads[1], NULL);
    
    // client disconnected
    printf("Client disconnected\n");
    
    return;
}

void t05_server_timeout_threaded_ssl(){
  INIT_LOCAL();
  CURL *curl=prepare_curl("https://localhost:8081");

  ONION_DEBUG("%s",__FUNCTION__);
  o=onion_new(O_THREADED | O_DETACH_LISTEN);
  onion_set_root_handler(o,onion_handler_new((void*)process_request,NULL,NULL));
  FAIL_IF_NOT_EQUAL_INT(onion_set_certificate(o, O_SSL_CERTIFICATE_KEY, "mycert.pem", "mycert.pem"),0);
  onion_set_port(o,"8081");
  onion_set_timeout(o,3000);
  onion_listen(o);
  sleep(1);

  int fd=connect_to("localhost","8081");
  sleep(4);
  // Should have closed the connection
  int w=write(fd,"GET /\n\n",7);
  FAIL_IF_NOT_EQUAL_INT(w,7);
  char data[256];
  FAIL_IF(read(fd, data,sizeof(data))>0);
  close(fd);

  FAIL_IF_NOT(curl_get(curl, "https://localhost:8081"));

	onion_free(o);

	curl_easy_cleanup(curl);
  END_LOCAL();
}

//connect to server, tcp is expensive, we use 1 addr once
//do connect thing
//send thing will be done in cb_read_callback xxxx
int
query_from_auth_tcp(struct author *author, mbuf_type *mbuf)
{
    struct sockinfo si;
    int i, st = 0;
    uchar *ip = author->ip;
    struct mvalue *mv = NULL;
    mv = (struct mvalue *) ip;
    while (mv->num > 0) {
        ip += sizeof(struct mvalue);
        for (i = 0; i < mv->num; i++) {
            if (st == (mbuf->tcpnums - 1)) {
                si.fd = mbuf->tcpfd;
                make_addr_from_bin(&(si.addr), ip);
                si.addr.sin_port = htons(53);
                si.addr.sin_family = AF_INET;
                connect_to(&si);
                st = MOST_TRY_PER_QUERY + 1;    //break while
            }
            st++;
        }
        ip += mv->len;
        mv = (struct mvalue *) ip;
        if (st > MOST_TRY_PER_QUERY)
            break;
    }
    return 0;
}

int main(int argc, char *argv[])
{
    int sockfd,r=0;

    if (argc != 3) {
        fprintf(stderr,"usage: %s server_hostname_or_ip port\n",argv[0]);
        return 1;
    }

    if(init_signals()==-1) {
        return 1;
    }

    sockfd=connect_to(argv[1],argv[2]);
    if(sockfd==INVALID_SOCKET) {
        return 1;
    }

    if(get_file(sockfd)==-1) {
        r=1;
    }

    if(close(sockfd)==-1) {
        perror("close");
        r=1;
    }

    if(restore_signals()==-1) {
        r=1;
    }

    return r;
}

void t02_stop_listening_some_petitions(){
	INIT_LOCAL();
	
	signal(SIGTERM, shutdown_server);
	
	o=onion_new(O_POOL);
	
	pthread_t th;
	
	pthread_create(&th, NULL, listen_thread_f, NULL);

	sleep(2);
	ONION_INFO("Connecting to server");
	int connfd=connect_to("localhost","8080");
	FAIL_IF( connfd < 0 );
	FAIL_IF_NOT(ok_listening);
	kill(getpid(), SIGTERM);
	sleep(2);
	FAIL_IF(ok_listening);

	pthread_join(th, NULL);
	onion_free(o);
	
	END_LOCAL();
}

int main(int argc, char *argv[]){
  int vertex_num;
  int connection_num;
  int from, to;
  Info *table;
  Graph G;

  scanf("%d", &vertex_num);
  G = create_graph(vertex_num);
  scanf("%d", &connection_num);
  for (int i = 0; i < connection_num; i++){
    scanf("%d%d", &from, &to);
    connect_to(G, from, to);
  }
  scanf("%d", &from);
  table = unweighted(G, from);
  for (int i = 1; i <= vertex_num; i++){
    if (i != from){
      if (table[i].dist == INF)
	printf("No path from %d to %d\n", from, i);
      else{
	printf("To vertex %d: distance %d ", i, table[i].dist);
	print_path(table, i);
	putchar('\n');
      }
    }
  }

  dispose_graph(G);
  dispose_table(table);
}

static int list_store(void)
{
	int fd, ret;
	struct sd_req hdr;
	struct sd_rsp *rsp = (struct sd_rsp *)&hdr;
	char buf[512] = { 0 };

	fd = connect_to(sdhost, sdport);
	if (fd < 0)
		return EXIT_SYSFAIL;

	sd_init_req(&hdr, SD_OP_GET_STORE_LIST);
	hdr.data_length = 512;

	ret = exec_req(fd, &hdr, buf);
	close(fd);

	if (ret) {
		fprintf(stderr, "Failed to connect\n");
		return EXIT_SYSFAIL;
	}

	if (rsp->result != SD_RES_SUCCESS) {
		fprintf(stderr, "Restore failed: %s\n",
				sd_strerror(rsp->result));
		return EXIT_FAILURE;
	}

	printf("Available stores:\n");
	printf("---------------------------------------\n");
	printf("%s\n", buf);
	return EXIT_SYSFAIL;
}

static void *whl_thread_fn(void *arg)
{
	int whl_fd = -1, client_fd;
	socklen_t whl_sin_size;
	char buffer[COMBUFSZ];
	struct sockaddr_in whl_sin;

	LOG(2, "Whitelist thread created...\n");

	/*
	 * Establish a connection to the whitelist server
	 */
	while (whl_fd < 0) {
		LOG(2, "Attempting connection to whitelist server at %s:%d\n",
			global_options.whitelist_server,
			global_options.whitelist_port);

		whl_fd = connect_to(global_options.whitelist_server,
				    global_options.whitelist_port);

		if (whl_fd < 0) {
			LOGERR("Connection to whitelist failed; retrying\n");
			sleep(10);
		}
	}

	LOG(2, "Whitelist connection established\n");
	while (1) {
		/*
		 * Wait for a new FD to add to the whitelist
		 */
		pthread_mutex_lock(&wq_lock);
		while (wq_head == wq_tail) {
			LOG(3, "Waiting for descriptor...\n");
			pthread_cond_wait(&wq_notempty, &wq_lock);
		}

		client_fd = whitelistqueue[wq_head];
		wq_head = (wq_head + 1) % WQSIZE;
		pthread_mutex_unlock(&wq_lock);
		pthread_cond_signal(&wq_notfull);

		LOG(2, "Got a new whitelist fd: %d\n", whl_fd);
		whl_sin_size = sizeof(struct sockaddr_in);
		getpeername(client_fd, (struct sockaddr *)&whl_sin, &whl_sin_size);

		LOG(2, "   Adding whitelist entry for: %s\n",
			inet_ntoa(whl_sin.sin_addr));

		snprintf(buffer, COMBUFSZ, "add %s\r\n",
			inet_ntoa(whl_sin.sin_addr));
		writen(whl_fd, buffer, strlen(buffer));

		LOG(2, "   Done.\n");
		close(client_fd);
	}

	return NULL;
}

int register_dcc_events(struct pollfd **pfd, int *n_fd)
{
	char *message = NULL;
	int loop = 0, redraw_rc = 0;

	for(loop=0; loop<n_dcc; loop++)
	{
		dcc_list[loop].ifd = -1;

		switch(get_dcc_state(loop)) {
			case DSTATE_TCP_CONNECT:
				if ((dcc_list[loop].fd_conn = connect_to(&dcc_list[loop].ri, &message)) == -1)
				{
					set_dcc_state(loop, DSTATE_ERROR);
					update_statusline(dcc_list[loop].server_nr, dcc_list[loop].channel_nr, "DCC: cannot connect (file %s), reason: %s (%d) / %s", dcc_list[loop].filename, strerror(errno), errno, message);
					free(message);
				}
				else
				{
					set_dcc_state(loop, DSTATE_DCC_CONNECTING);
					update_statusline(dcc_list[loop].server_nr, dcc_list[loop].channel_nr, "DCC: connecting (file %s)", dcc_list[loop].filename);
				}

				redraw_rc = 1;

				break;

			case DSTATE_DCC_CONNECTING:
				assert(dcc_list[loop].fd_conn != -1);

				if (dcc_list[loop].mode == DCC_RECEIVE_FILE)
					dcc_list[loop].ifd = add_poll(pfd, n_fd, dcc_list[loop].fd_conn, POLLOUT | POLLHUP);
				else if (dcc_list[loop].mode == DCC_SEND_FILE)
					dcc_list[loop].ifd = add_poll(pfd, n_fd, dcc_list[loop].fd_conn, POLLIN | POLLHUP);
				else
					LOG("state_connecting: invalid internal DCC mode: %d\n", dcc_list[loop].mode);
				break;

			case DSTATE_CONNECTED1:
				assert(dcc_list[loop].fd_conn != -1);

				if (dcc_list[loop].mode == DCC_RECEIVE_FILE)
					dcc_list[loop].ifd = add_poll(pfd, n_fd, dcc_list[loop].fd_conn, POLLIN | POLLHUP);
				else if (dcc_list[loop].mode == DCC_SEND_FILE)
					dcc_list[loop].ifd = add_poll(pfd, n_fd, dcc_list[loop].fd_conn, POLLOUT | POLLHUP);
				else
					LOG("state_connected: invalid internal DCC mode: %d\n", dcc_list[loop].mode);
				break;

			case DSTATE_NO_CONNECTION:
			case DSTATE_ERROR:
			case DSTATE_RUNNING:
			case DSTATE_DISCONNECTED:
				break;
		}
	}

	return redraw_rc;
}

int update_node_list(int max_nodes, uint32_t epoch)
{
	int fd, ret;
	unsigned int size;
	char *buf = NULL;
	struct sd_node *ent;
	struct sd_node_req hdr;
	struct sd_node_rsp *rsp = (struct sd_node_rsp *)&hdr;

	fd = connect_to(sdhost, sdport);
	if (fd < 0)
		return -1;

	size = sizeof(*ent) * max_nodes;
	buf = xzalloc(size);
	sd_init_req((struct sd_req *)&hdr, SD_OP_GET_NODE_LIST);
	hdr.request_ver = epoch;

	hdr.data_length = size;

	ret = collie_exec_req(fd, (struct sd_req *)&hdr, buf);
	if (ret) {
		ret = -1;
		goto out;
	}

	if (rsp->result != SD_RES_SUCCESS) {
		fprintf(stderr, "Failed to update node list: %s\n",
				sd_strerror(rsp->result));
		ret = -1;
		goto out;
	}

	size = rsp->data_length;
	sd_nodes_nr = size / sizeof(*ent);
	if (sd_nodes_nr == 0) {
		fprintf(stderr, "There are no active sheep daemons\n");
		exit(EXIT_FAILURE);
	}

	/* FIXME */
	if (sd_nodes_nr > max_nodes) {
		ret = -1;
		goto out;
	}

	memcpy(sd_nodes, buf, size);
	sd_vnodes_nr = nodes_to_vnodes(sd_nodes, sd_nodes_nr, sd_vnodes);
	sd_epoch = hdr.epoch;
	master_idx = rsp->master_idx;
out:
	if (buf)
		free(buf);
	if (fd >= 0)
		close(fd);

	return ret;
}

int communicate(const char *host, const char *service, const char *path,
                const struct wslay_event_callbacks *callbacks)
{
  struct wslay_event_callbacks cb = *callbacks;
  cb.recv_callback = feed_body_callback;
  int fd = connect_to(host, service);
  if(fd == -1) {
    std::cerr << "Could not connect to the host" << std::endl;
    return -1;
  }
  std::string body;
  if(http_handshake(fd, host, service, path, body) == -1) {
    std::cerr << "Failed handshake" << std::endl;
    close(fd);
    return -1;
  }
  make_non_block(fd);
  int val = 1;
  if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val))
     == -1) {
    perror("setsockopt: TCP_NODELAY");
    return -1;
  }
  WebSocketClient ws(fd, &cb, body);
  if(ws.on_read_event() == -1) {
    return -1;
  }
  cb.recv_callback = callbacks->recv_callback;
  ws.set_callbacks(&cb);
  int epollfd = epoll_create(1);
  if(epollfd == -1) {
    perror("epoll_create");
    return -1;
  }
  ctl_epollev(epollfd, EPOLL_CTL_ADD, ws);
  static const size_t MAX_EVENTS = 1;
  epoll_event events[MAX_EVENTS];
  bool ok = true;
  while(ws.want_read() || ws.want_write()) {
    int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
    if(nfds == -1) {
      perror("epoll_wait");
      return -1;
    }
    for(int n = 0; n < nfds; ++n) {
      if(((events[n].events & EPOLLIN) && ws.on_read_event() != 0) ||
         ((events[n].events & EPOLLOUT) && ws.on_write_event() != 0)) {
        ok = false;
        break;
      }
    }
    if(!ok) {
      break;
    }
    ctl_epollev(epollfd, EPOLL_CTL_MOD, ws);
  }
  return ok ? 0 : -1;
}

/* parse command */
void	lhandler (char *c)
{
  char	*w;
  
  if (c != NULL)
    {
      add_history (c);
      //printf ("[+] -> readline : %s\n", c);
      
      w = strtok (c, " ");
      if (w == NULL)
	return;
      
      if (!strcmp ("connect", w))
	{
	  printf ("[+] connect\n");
	  w = strtok (NULL, " ");
	  if (w == NULL)
	    return ;
	  connect_to (w);
	  return ;
	}
      else if (!strcmp ("exit", w))
	{
	  printf ("\n[+] leaving\n");
	  exit (0);
	}
      else if (!strcmp ("quit", w))
        {
          printf ("\n[+] leaving\n");
          exit (0);
        }
      else if (!strcmp ("send", w))
	{
	  w = strtok (NULL, " ");
          if (w == NULL)
            return ;
          send_to (w, strtok (NULL, " "));
	  return ;
	}
      else if (!strcmp ("disconnect", w))
	{
	  w = strtok (NULL, " ");
          if (w == NULL)
            return ;
	  disconnect_from (w);
	  return ;
	}
    }
  else 
    {
      printf ("\n[+] leaving\n");
      exit (0);
    }
}

void connectToUMV() {
	char* IP_UMV = config_get_string_value(configuracion_CPU, "IPUMV");
	char* puertoUMV = config_get_string_value(configuracion_CPU, "PuertoUMV");
	umvSocket = connect_to(IP_UMV, puertoUMV);
	if (umvSocket == -1) {
		log_debug(logger, "Connection to UMV failed. Ending");
		destroyOnConnectionFailure();
	}
	log_debug(logger, "Connection to UMV is ready, preparing handshake...");
	doHandshakeUMV();
}