C++ connect_socket函数代码示例

void *thread_main(void *arg)
{
    int fd;
    char * spath = (char *) arg;
    char *tile;

    fd = connect_socket(spath);

    while((tile = fetch(spath, &fd))) {
        int ret = process(fd, tile);
        if (ret == 0) {
            printf("Reconnecting closed socket\n");
            close(fd);
            fd = connect_socket(spath);
        }
        num_render++;
        if (!(num_render % 10)) {
            gettimeofday(&end, NULL);
            printf("\n");
            printf("Meta tiles rendered: ");
            display_rate(start, end, num_render);
            printf("Total tiles rendered: ");
            display_rate(start, end, num_render * METATILE * METATILE);
            printf("Number of Metatiles tested for expiry: ");
            display_rate(start, end, num_all);
            printf("\n");
        }
        free(tile);
    }

    close(fd);

    return NULL;
}

static void test_connect_two_sockets(const void *test_data)
{
	struct test_data *data = tester_get_data();
	const struct l2cap_data *l2data = data->test_data;
	const uint8_t *client_bdaddr;

	test_two_sockets_connect_cb_cnt = 0;
	test_scan_enable_counter = 0;

	hciemu_add_master_post_command_hook(data->hciemu,
				test_connect_two_sockets_router, data);

	if (l2data->server_psm) {
		struct bthost *bthost = hciemu_client_get_host(data->hciemu);

		if (!l2data->data_len)
			bthost_add_l2cap_server(bthost, l2data->server_psm,
						NULL, NULL);
	}

	client_bdaddr = hciemu_get_client_bdaddr(data->hciemu);
	if (l2data->close_one_socket)
		connect_socket(client_bdaddr, &data->sk, NULL);
	else
		connect_socket(client_bdaddr, &data->sk,
						test_two_sockets_connect_cb);
}

static IPC_SOCKET_TYPE connect_and_serve(const char *socket_path, const char* event_path, const char *exec_path)
{
  IPC_SOCKET_TYPE sock = connect_socket(socket_path, 0);

  if (sock == INVALID_HANDLE_VALUE)
  {
    start_server(socket_path, event_path, exec_path);
    sock = connect_socket(socket_path, 1);
  }

  if (sock == INVALID_HANDLE_VALUE)
    abort();

  return sock;
}

int main(int argc, char **argv) 
{
		SOCKET sock = connect_socket(IP_ADDR, PORT);
		BOOL must_continue = sock != INVALID_SOCKET;
		
		char buf[MAXLINE];
		char* prompt = "sldb> ";
		while( must_continue ){
			//snprintf(buf, MAXLINE, "?1 ? ?\r\n");
			
			write(STDOUT_FILENO, prompt, strlen(prompt));
      int n_readed = read(STDIN_FILENO, buf, MAXLINE);
			must_continue &= !send_socket(sock, buf, n_readed);
			
			while( must_continue ){
				int len = read_line(sock, buf, MAXLINE);
				BOOL is_empty_line = len == 0;
				if( is_empty_line ){
					break;
				}
				write(STDOUT_FILENO, buf, len);
				printf("\r\n");
				BOOL must_close = !strcmp(buf, "!close");
				must_continue &= !must_close;
			}
		}
		
		int iResult = close_socket(sock);
    return iResult;
}

int websocket_connect(websocket_t *client, char *host, const char *port)
{
	int r;
	int tls_hs_retry = WEBSOCKET_MAX_TLS_HANDSHAKE;

TLS_HS_RETRY:
	if ((r = connect_socket(client, host, port)) != WEBSOCKET_SUCCESS) {
		return r;
	}

	if (websocket_config_socket(client->fd) != WEBSOCKET_SUCCESS) {
		WEBSOCKET_CLOSE(client->fd);
		return WEBSOCKET_SOCKET_ERROR;
	}

	if (client->tls_enabled) {
		if ((r = websocket_tls_handshake(client, host, client->auth_mode)) != WEBSOCKET_SUCCESS) {
			if (r == MBEDTLS_ERR_NET_SEND_FAILED || r == MBEDTLS_ERR_NET_RECV_FAILED || r == MBEDTLS_ERR_SSL_CONN_EOF) {
				if (tls_hs_retry-- > 0) {
					WEBSOCKET_DEBUG("Handshake again.... \n");
					mbedtls_net_free(&(client->tls_net));
					mbedtls_ssl_free(client->tls_ssl);
					mbedtls_ssl_init(client->tls_ssl);
					goto TLS_HS_RETRY;
				}
			}
			return WEBSOCKET_TLS_HANDSHAKE_ERROR;
		}
	}
	return r;
}

/* Select handler which is set for the socket descriptor when connect() has
 * indicated (via errno) that it is in progress. On completion this handler gets
 * called. */
static void
connected(struct socket *socket)
{
	int err = 0;
	struct connection_state state = connection_state(0);
	socklen_t len = sizeof(err);

	assertm(socket->connect_info != NULL, "Lost connect_info!");
	if_assert_failed return;

	if (getsockopt(socket->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len) == 0) {
		/* Why does EMX return so large values? */
		if (err >= 10000) err -= 10000;
		if (err != 0)
			state = connection_state_for_errno(err);
		else
			state = connection_state(0);
	} else {
		/* getsockopt() failed */
		if (errno != 0)
			state = connection_state_for_errno(errno);
		else
			state = connection_state(S_STATE);
	}

	if (!is_in_state(state, 0)) {
		/* There are maybe still some more candidates. */
		connect_socket(socket, state);
		return;
	}

	complete_connect_socket(socket, NULL, NULL);
}

/* DNS callback. */
static void
dns_found(struct socket *socket, struct sockaddr_storage *addr, int addrlen)
{
	struct connect_info *connect_info = socket->connect_info;
	int size;

	if (!addr) {
		socket->ops->done(socket, connection_state(S_NO_DNS));
		return;
	}

	assert(connect_info);

	size = sizeof(*addr) * addrlen;

	connect_info->addr = mem_alloc(size);
	if (!connect_info->addr) {
		socket->ops->done(socket, connection_state(S_OUT_OF_MEM));
		return;
	}

	memcpy(connect_info->addr, addr, size);
	connect_info->addrno = addrlen;

	/* XXX: Passing non-result state here is bad but a lack of alternatives
	 * makes it so. Well adding get_state() socket operation could maybe fix
	 * it but the returned state would most likely be a non-result one at
	 * this point in the connection lifecycle. This will, however, only be a
	 * problem if connect_socket() fails without doing any system calls
	 * which is only the case when forcing the IP family. So it is better to
	 * handle it in connect_socket(). */
	connect_socket(socket, connection_state(S_CONN));
}

int main(int argc, char** argv) {
    if (argc < 3) {
        printf("Usage: jattach <pid> <cmd> <args> ...\n");
        return 1;
    }
    
    int pid = atoi(argv[1]);
    if (!check_socket(pid) && !start_attach_mechanism(pid)) {
        printf("Could not start attach mechanism\n");
        return 1;
    }

    int fd = connect_socket(pid);
    if (fd == -1) {
        printf("Could not connect to socket\n");
        return 1;
    }
    
    printf("Connected to remote JVM\n");
    write_command(fd, argc - 2, argv + 2);

    printf("Response code = ");
    read_response(fd);

    printf("\n");
    close(fd);
    
    return 0;
}

int main(int argc, char ** argv)
{
    int   sockfd=0;
    char  sendMsg[30]="abc.org/r/n/r";
    char* res;
    int   port = 4242;
    char  ip[128] = {0};
    strncpy(ip, "127.0.0.1", 128);
    if(argc > 2)
    {
        strncpy(ip, argv[1], 128);
        port = atoi(argv[2]);
        printf("Input IP: %s, port : %d/n", ip, port);
    }
    else if(argc > 1)
    {
        port = atoi(argv[1]);
        printf("Input port : %d/n", port);
    }
    sockfd=connect_socket(ip, port);

    send_msg(sockfd,sendMsg);
    /* res=recv_msg(sockfd); */

    printf("return from recv function/n");
    printf(res);
    free(res);
    close_socket(sockfd);
    return 0;
}

// Initialize resources for the node
void IPC_initialize_node(int _node_id)
{
  node_id = _node_id;

  if (node_id == 0)
  {
    sock = (typeof(sock)) malloc(sizeof(*sock) * nb_nodes);
    if (!sock)
    {
      perror("sock allocation error");
      exit(-1);
    }

    sock[0] = create_socket(PORT_CORE_0, nb_nodes);

    for (int i = 1; i < nb_nodes; i++)
    {
      sock[i] = get_connection(sock[0]);
    }
  }
  else
  {
    sock = (typeof(sock)) malloc(sizeof(*sock));
    if (!sock)
    {
      perror("sock allocation error");
      exit(-1);
    }

    sock[0] = create_socket(0, 0);
    connect_socket(sock[0], PORT_CORE_0);
  }
}

int main (int argc, char *argv[]) {

  // Exit nicely
  struct sigaction sigIntHandler;

  sigIntHandler.sa_handler = my_handler;
  sigemptyset(&sigIntHandler.sa_mask);
  sigIntHandler.sa_flags = 0;

  sigaction(SIGINT, &sigIntHandler, NULL);
  // / Exit nicely

  if( argc < 2 ){
    printf("Usage: %s ServerAdresse\n", *argv);
    exit(EXIT_FAILURE);
  }

  sock = create_socket(AF_INET6, SOCK_STREAM, 0);
  atexit(cleanup);
  connect_socket(&sock, argv[1], 15000);

  pthread_t tw;
  pthread_create(&tw,NULL,sender,NULL);

  pthread_t tr;
  pthread_create(&tr,NULL,listener,NULL);

  pthread_join(tw,NULL);
  pthread_join(tr,NULL);

  return EXIT_SUCCESS;
}

apisock *api_connect_ssl(){
  apisock *ret;
  SSL *ssl;
  int sock;
  sock=connect_socket(API_HOST, API_PORT_SSL);
  if (sock==-1)
    return NULL;
  if (!globalctx){
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    OpenSSL_add_all_ciphers();
    SSL_load_error_strings();
    globalctx=SSL_CTX_new(SSLv23_method());
    if (!globalctx)
      return NULL;
  }
  ssl=SSL_new(globalctx);
  if (!ssl){
    close(sock);
    return NULL;
  }
  SSL_set_fd(ssl, sock);
  if (SSL_connect(ssl)!=1){
    SSL_free(ssl);
    close(sock);
    return NULL;
  }
  ret=(apisock *)malloc(sizeof(apisock));
  ret->sock=sock;
  ret->ssl=ssl;
  return ret;
}

void Socket::create_and_connect()
{
    addrinfo* serverinfo;
    int res;

    if ((res = get_addr_info(&serverinfo)) != 0)
    {
        throw std::system_error(errno, std::system_category(),
                                REPORT_ERROR("getaddrinfo failure: " +
                                std::string(gai_strerror(res))));
    }

    try
    {
        create_socket(serverinfo);
        connect_socket(serverinfo);
    }
    catch (std::system_error const& err)
    {
        freeaddrinfo(serverinfo);
        close(sock);
        throw err;
    }

    freeaddrinfo(serverinfo);

    if (!server_info.password.empty())
        send_to_socket("PASS " + server_info.password + "\r\n");

    send_to_socket("NICK " + server_info.nick + "\r\n");
    send_to_socket("USER " + server_info.user + "\r\n");
}

void *FUNC_THREAD(void *threadid)
{
    FILE *dosya_yaz;
    dosya_yaz = fopen("userlist.txt","a");
    long tid;
    tid = (long)threadid;
    
    char str[20];
    sprintf(str,"192.168.2.%ld",(tid+1));
    
    int conn;
    conn = connect_socket(10001,str);
    char inbuffer[512];
    if (conn != -1)
	{
		recv(conn,inbuffer,512,0);
		fprintf(dosya_yaz,"%s %s\n",str,inbuffer);
		
	}
	   
    close(conn);
    
    fclose(dosya_yaz);
    pthread_exit(NULL);
}

int sanlock_request(uint32_t flags, uint32_t force_mode,
		    struct sanlk_resource *res)
{
	int fd, rv, datalen;

	datalen = sizeof(struct sanlk_resource) +
		  sizeof(struct sanlk_disk) * res->num_disks;

	rv = connect_socket(&fd);
	if (rv < 0)
		return rv;

	rv = send_header(fd, SM_CMD_REQUEST, flags, datalen, force_mode, 0);
	if (rv < 0)
		goto out;

	rv = send(fd, res, sizeof(struct sanlk_resource), 0);
	if (rv < 0) {
		rv = -errno;
		goto out;
	}

	rv = send(fd, res->disks, sizeof(struct sanlk_disk) * res->num_disks, 0);
	if (rv < 0) {
		rv = -errno;
		goto out;
	}

	rv = recv_result(fd);
 out:
	close(fd);
	return rv;
}