C++ connect_to函数代码示例

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;
}