C++ socket_connect函数代码示例

void *events_clientize(void *param) {
	logprintf(LOG_STACK, "%s(...)", __FUNCTION__);

	unsigned int failures = 0;
	while(loop && failures <= 5) {
		struct ssdp_list_t *ssdp_list = NULL;
		int standalone = 0;
		settings_find_number("standalone", &standalone);
		if(ssdp_seek(&ssdp_list) == -1 || standalone == 1) {
			logprintf(LOG_DEBUG, "no pilight ssdp connections found");
			char server[16] = "127.0.0.1";
			if((sockfd = socket_connect(server, (unsigned short)socket_get_port())) == -1) {
				logprintf(LOG_DEBUG, "could not connect to pilight-daemon");
				failures++;
				continue;
			}
		} else {
			if((sockfd = socket_connect(ssdp_list->ip, ssdp_list->port)) == -1) {
				logprintf(LOG_DEBUG, "could not connect to pilight-daemon");
				failures++;
				continue;
			}
		}
		if(ssdp_list) {
			ssdp_free(ssdp_list);
		}

		struct JsonNode *jclient = json_mkobject();
		struct JsonNode *joptions = json_mkobject();
		json_append_member(jclient, "action", json_mkstring("identify"));
		json_append_member(joptions, "config", json_mknumber(1, 0));
		json_append_member(jclient, "options", joptions);
		json_append_member(jclient, "media", json_mkstring("all"));
		char *out = json_stringify(jclient, NULL);
		socket_write(sockfd, out);
		json_free(out);
		json_delete(jclient);

		if(socket_read(sockfd, &recvBuff, 0) != 0
			 || strcmp(recvBuff, "{\"status\":\"success\"}") != 0) {
				failures++;
			continue;
		}
		failures = 0;
		while(loop) {
			if(socket_read(sockfd, &recvBuff, 0) != 0) {
				break;
			} else {
				events_queue(recvBuff);
			}
		}
	}

	if(recvBuff) {
		FREE(recvBuff);
		recvBuff = NULL;
	}
	socket_close(sockfd);
	return 0;
}

int socket_setup(void)
{

    s8 rc = SOC_SUCCESS;

    if (setting.addr_type == ADDR_TYPE_IP)
    {
        return socket_connect(setting.ipaddr);
    }
    else
    {
        u8 ipaddr[4] = {0};
        u8 len = 0;

        eat_soc_gethost_notify_register(hostname_notify_cb);
        rc = eat_soc_gethostbyname(setting.domain, ipaddr, &len, request_id++);
        if (rc == SOC_WOULDBLOCK)
        {
            LOG_DEBUG("eat_soc_gethostbyname wait callback.");
            return ERR_WAITING_HOSTNAME2IP;
        }
        else if (rc == SOC_SUCCESS)
        {
            LOG_DEBUG("host:%s -> %d.%d.%d.%d:%d.", setting.domain, ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3], setting.port);
            return socket_connect(ipaddr);
        }
        else
        {
            LOG_ERROR("eat_soc_gethostbyname error!");
            return ERR_GET_HOSTBYNAME_FAILED;
        }
    }
}

int proxy_connect(struct proxy *self, const char *dst_ip, unsigned short dst_port)
{
	int err;

	err = socket_connect(self->s, self->ip, self->port);
	if (err < 0)
		return err;

	struct socket5_select_request	request;
	struct socket5_select_response	response;

	assert(self->ip);
	assert(self->usr);
	assert(self->pwd);

	err = socket_connect(self->s, self->ip, self->port);
	if (err < 0)
		return err;

	request.ver = 0x05;
	request.method_nr = 2;
	request.method_tbl[0] = 0x00;	/* no auth */
	request.method_tbl[2] = 0x02;	/* user pwd */

	err = socket_send_data(
				self->s,
				(char *)&request,
				2 + request.method_nr * sizeof(request.method_tbl[0])
				);

	if (err < 0)
		return err;

	err = socket_recv_data(
				self->s,
				(char *)&response,
				sizeof(response)
				);

	if (err < 0)
		return err;

	if (response.method == 0x02)
		err = auth(self->s, self->usr, self->pwd);

	if (err < 0)
		return err;

	err = conn(self->s, dst_ip, dst_port);
	
	return err;
}

int
connection_client_connect(struct connection *c,
                          const struct sockaddr *server_address,
                          size_t server_address_length,
                          uint32_t seed)
{
    int ret;
    struct timeval tv;

    assert(c->client.client == NULL);

    int fd;

    const struct addrinfo *socks4_address =
        c->instance->config->socks4_address;
    if (socks4_address != NULL) {
        fd = socket_connect(socks4_address->ai_family, SOCK_STREAM, 0,
                            socks4_address->ai_addr, socks4_address->ai_addrlen);
        if (fd < 0)
            return -fd;

        if (!socks_connect(fd, server_address))
            return -1;
    } else {
        fd = socket_connect(server_address->sa_family, SOCK_STREAM, 0,
                            server_address, server_address_length);
        if (fd < 0)
            return -fd;
    }

    ret = uo_client_create(fd, seed,
                           c->client_version.seed,
                           &client_handler, c,
                           &c->client.client);
    if (ret != 0) {
        close(fd);
        return ret;
    }

    if (client_version_defined(&c->client_version))
        uo_client_set_protocol(c->client.client,
                               c->client_version.protocol);

    tv.tv_sec = 30;
    tv.tv_usec = 0;
    evtimer_set(&c->client.ping_event, connection_ping_event_callback,
                &c->client);
    evtimer_add(&c->client.ping_event, &tv);

    return 0;
}

bool
bot_init_connection(struct bot *bot)
{
	DEBUG(LOG_VERBOSE, "bot init connection\n");
	
	return socket_connect(bot->socket);
}

static void run_networking_test(bool server)
{
    if (!server) {
        connection_t *conn = connection_create(&on_connect);
        if (!conn)
            return;

        printf("connecting to localhost on port 1337\n");
        socket_connect(conn, "127.0.0.1", "1337");

        char buffer[1024];
        while (fgets(buffer, sizeof buffer, stdin))
            socket_write(conn, buffer);
    } else {
        socket_t *sock = socket_create(on_accept);
        if (!sock)
            return;

        printf("Server will bind to port 1337.\n");
        socket_listen(sock, NULL, 1337, 10);
        while (1) {
            sleep(5);
            printf("%d connections ATM\n", sock->num_connections);
        }
    }
}

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

        initiate(argc, argv); /* initialize executor */
        #ifndef BASIC
        socket_setup();
        network_socket = socket_connect();
        #endif
        runsys(); /* initialize running system */
        if (has_network_socket()) {
            request_id();
            GraphRes = get_graph_res();
            graph_setstatus();
            if (GraphRes < 0) exit(12);
            if (remote) send_ready();
        }

        setjmp (contenv); /* set label for continue long jump */
        while (TRUE) { /* repeat until exit() is called */
            get_internal();
            schedule(); /* reschedule current process */
            if (ready != 0) {
                decode(); /* fetch instruction */
                execute(); /* and execute it */
            }
        }
        return 0;
    } /* end main */

void *__server(void *ptr)
{
	t_context *C=ctx_get();
	char msg[30];

	if(!server_init)
	{
		socket_connect(C->server->socket,9901);
		server_init=1;
		sprintf(msg,"listening on port %d",C->server->socket->portno);
		term_print(C->term,msg);

		if(C->app->off_screen)
		{
			printf("listening on port %d\n",C->server->socket->portno);
		}
	}
	else
	{
		socket_listen(C->server->socket);
		if(C->app->off_screen)
		{
			printf("waiting for connection");
		}

	}
	return NULL;
}

int nettest2(void)
{
	int err;
	sockaddr addr;

	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 = 9;
	NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(63,203,215,73);

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

	for(;;) {
		char buf[4096];
		socket_write(fd, buf, sizeof(buf));
	}
	return 0;
}

int nettest1(void)
{
	int err;
	sockaddr addr;

	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 = 19;
//	NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(63,203,215,73);
//	addr.port = 23;
//	NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(192,168,0,3);
	addr.port = 6667;
	NETADDR_TO_IPV4(addr.addr) = IPV4_DOTADDR_TO_ADDR(209,131,227,242);

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

	exit_sem = _kern_sem_create(0, "exit");

	_kern_thread_resume_thread(_kern_thread_create_thread("read_thread", &read_thread, NULL));
	_kern_thread_resume_thread(_kern_thread_create_thread("write_thread", &write_thread, NULL));

	for(;;)
		_kern_sem_acquire(exit_sem, 1);

	return 0;
}

int nettest4(void)
{
	int err;
	sockaddr addr;

	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(63,203,215,73);

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

	usleep(5000000);

	err = socket_close(fd);
	printf("socket_close returns %d\n", err);

	return 0;
}

Display *OpenDisplay(char *hostname, int port)
{
    Display *display = NULL;
    Socket *socket = NULL;
    char *port_buf = NULL;

    port_buf = int_to_string(port);
    if (port_buf == NULL)
        return NULL;

    socket = socket_new(Socket_Blocking);
    if (socket_connect(socket, hostname, port_buf) != 0) {
        socket_free(socket);
        free(port_buf);
        return NULL;
    }

    free(port_buf);

    display = (Display *) malloc(sizeof(Display));
    
    display->socket = socket;
    display->hostname = strdup(hostname);
    display->port = port;
    display->callbacks = callbacks_new();
    
    return display;
}

// main
//-----------------------------------------------------------------------------------
int
main (int argc, char *argv[])
{
  int s, size;
  pthread_t thread;
  char buf[256];

  if (argc == 1)
    {
      printf ("usage: client <server IP address>\n");
      exit (1);
    }

  s = socket_connect (argv[1], 1024);

  pthread_mutex_init (&g_mutex, NULL);
  pthread_create (&thread, NULL, thread_recv, (void *) &s);

  // メインループ
  //---------------------------------------------------
  while (g_main_loop)
    {
      fgets (buf, 256, stdin);
      size = strlen (buf);
      fprintf (stderr, "sending[%d] %s", size, buf);
      socket_write (s, &size, sizeof (int));
      socket_write (s, buf, size);
    }

  pthread_join (thread, NULL);

  exit (0);
}

/**
* 作用: 连接到一个FTP服务器，返回socket
* 参数: IP或域名, 端口
* 返回值: Socket套接字
* */
SOCKET connect_server(char *host, int port)
{
	SOCKET ctrl_sock;
	char buf[BUFSIZ];
	int result;
	ssize_t len;
	memset(buf, 0, sizeof(buf));

	ctrl_sock = socket_connect(host, port);
	if (-1 == ctrl_sock)
	{
		return -1;
	}
	while ((len = recv(ctrl_sock, buf, BUFSIZ, 0)) > 0)
	{
		buf[len] = 0;
		printf("buf\n");
	}
	sscanf(buf, "%d", &result);

	if (FTP_SERVICE_READY != result)
	{
		logger.error("FTP not ready, close the socket!");
		closesocket(ctrl_sock); // 关闭socket
		return -1;
	}
	return ctrl_sock;
}

/**
* 作用: 连接到PASV接口
*       PASV（被动）方式的连接过程是：
*       客户端向服务器的FTP端口（默认是21）发送连接请求，
*       服务器接受连接，建立一条命令链路。
* 参数: 命令链路SOCKET cmd-socket
* 返回值: 数据链路SOCKET raw-socket  -1 表示创建失败
* */
SOCKET ftp_pasv_connect(SOCKET c_sock)
{
	SOCKET r_sock;
	int send_result;
	ssize_t len;
	int addr[6]; //IP*4+PORT*2
	char buf[BUFSIZ];
	char result_buf[BUFSIZ];
	memset(result_buf, 0, sizeof(result_buf));

	// 设置PASV被动模式
	memset(buf, sizeof(buf), 0);
	sprintf(buf, "PASV\r\n");
	send_result = ftp_sendcmd_re(c_sock, buf, result_buf, &len);
	if (send_result == 0)
	{
		sscanf(result_buf, "%*[^(](%d,%d,%d,%d,%d,%d)", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]);
	}

	// 连接PASV端口
	memset(buf, sizeof(buf), 0);
	sprintf(buf, "%d.%d.%d.%d", addr[0], addr[1], addr[2], addr[3]);
	r_sock = socket_connect(buf, addr[4] * 256 + addr[5]);
	if (r_sock == -1)
	{
		return -1;
	}
	return r_sock;
}