C++ create_socket函数代码示例

int main()
{
    int server_socket;
    int port;
    int epollfd;
    int ret;
    char buf[1024];

    port = 8765;
    server_socket = create_socket(port);

    /* 监听 */
    listen(server_socket, 10);

    struct epoll_event events[100];

    epollfd = epoll_create(1024);

    add_event(epollfd,server_socket,EPOLLIN);

    while(1) {
        //该函数返回已经准备好的描述符事件数目
        ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1);
        //处理接收到的连接
        handle_events(epollfd,events,ret,server_socket,buf);
    }
    return 0;
}

int bg_listen_socket_create_unix(const char * name,
                                 int queue_size)
  {
  int ret;

  struct sockaddr_un addr;
  int addr_len;
  ret = create_socket(PF_LOCAL, SOCK_STREAM, 0);
  if(ret < 0)
    {
    bg_log(BG_LOG_ERROR, LOG_DOMAIN, "Cannot create unix server socket");
    return -1;
    }

  addr.sun_family = AF_LOCAL;
  strncpy (addr.sun_path, name, sizeof(addr.sun_path));
  addr.sun_path[sizeof (addr.sun_path) - 1] = '\0';
  addr_len = SUN_LEN(&addr);
  if(bind(ret,(struct sockaddr*)(&addr),addr_len)<0)
    {
    bg_log(BG_LOG_ERROR, LOG_DOMAIN, "Cannot bind UNIX domain socket: %s",
           strerror(errno));
    return -1;
    }
  if(listen(ret, queue_size))
    {
    bg_log(BG_LOG_ERROR, LOG_DOMAIN, "Cannot put socket into listening mode");
    return -1;
    }
  return ret;
  }

int main(int argc, char **argv)
{
    int choice;
    int servfd;
    char user[MAXNAMELEN];
    char pass[MAXNAMELEN];
    char content[CONTENTLEN];
    unsigned char buf[CONTENTLEN];
    size_t packetsize, pks;
    int code;
  
    if(argc!=2)
	{
	    fprintf(stderr, "Usage: client.exe servername\n");
	    exit(-1);
	}
    servfd = create_socket(argv[1], DEFAULT_PORT);
    
    if(servfd)
	{
	    Run(servfd);	
	    close(servfd);
	} //End code = 0 register user
    return 0;
}

int msg_init(char *sock_path)
{
	int listen_sock;
	int efd;
	int ret;

	listen_sock = create_socket(sock_path); 
	if (-1 == listen_sock) {
		return -1;
	}

	efd = epoll_create1(0);
	if (efd == -1)
	{
		DEBUG_ERROR("epoll_create");
		close(listen_sock);

		return -1;
	}

	ret = add2epoll(efd, EPOLLIN, listen_sock);
	if (0 == ret)
	{
		g_efd = efd;
		g_listen_fd = listen_sock;
	}
	else
	{
		close(listen_sock);
		close(efd); 
	}


	return ret;
}

int bg_socket_connect_unix(const char * name)
  {
  struct sockaddr_un addr;
  int addr_len;
  int ret;
  ret = create_socket(PF_LOCAL, SOCK_STREAM, 0);
  if(ret < 0)
    {
    bg_log(BG_LOG_ERROR, LOG_DOMAIN, "Cannot create unix socket");
    return -1;
    }

  addr.sun_family = AF_LOCAL;
  strncpy (addr.sun_path, name, sizeof(addr.sun_path));
  addr.sun_path[sizeof (addr.sun_path) - 1] = '\0';
  addr_len = SUN_LEN(&addr);
  
  if(connect(ret,(struct sockaddr*)(&addr),addr_len)<0)
    {
    bg_log(BG_LOG_ERROR, LOG_DOMAIN, "Connecting unix socket failed: %s",
           strerror(errno));
    return -1;
    }
  return ret;
  }

int qnet_tcp_listen(int port, const char *bindaddr) {
  UNUSED(bindaddr);

  int                 fd;
  struct sockaddr_in  sa;

  if ((fd = create_socket()) < 0) {
    return -1;
  }

  if (set_nonblocking(fd) < 0) {
    return -1;
  }

  memset(&sa,0,sizeof(sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons(port);
  sa.sin_addr.s_addr = htonl(INADDR_ANY);
  if (bindaddr && inet_aton(bindaddr, &sa.sin_addr) == 0) {
    qerror("invalid bind address");
    close(fd);
    return -1;
  }
  if (net_listen(fd,(struct sockaddr*)&sa, sizeof(sa)) < 0) {
    close(fd);
    return -1;
  }

  return fd;
}

/*
 * pjsip_fake_udp_transport_start()
 *
 * Create a FAKE_UDP socket in the specified address and start a transport.
 */
PJ_DEF(pj_status_t) pjsip_fake_udp_transport_start( pjsip_endpoint *endpt,
					       const pj_sockaddr_in *local_a,
					       const pjsip_host_port *a_name,
					       unsigned async_cnt,
					       pjsip_transport **p_transport)
{
    pj_sock_t sock;
    pj_status_t status;
    char addr_buf[PJ_INET6_ADDRSTRLEN];
    pjsip_host_port bound_name;

    PJ_ASSERT_RETURN(endpt && async_cnt, PJ_EINVAL);

    status = create_socket(pj_AF_INET(), local_a, sizeof(pj_sockaddr_in),
			   &sock);
    if (status != PJ_SUCCESS)
	return status;

    if (a_name == NULL) {
	/* Address name is not specified.
	 * Build a name based on bound address.
	 */
	status = get_published_name(sock, addr_buf, sizeof(addr_buf),
				    &bound_name);
	if (status != PJ_SUCCESS) {
	    pj_sock_close(sock);
	    return status;
	}

	a_name = &bound_name;
    }

    return pjsip_fake_udp_transport_attach( endpt, sock, a_name, async_cnt,
				       p_transport );
}

int nonblock_connect_to(const char * ip,int port, struct sockaddr_in* addr)
{
	int res;

	int fd = create_socket();
	if (fd < 0) 
    {
		return -1;
	}

	int flags = fcntl(fd,F_GETFL,0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
	   
	make_address(addr, ip, port);

	res = connect(fd, (const struct sockaddr*)addr, (socklen_t)sizeof(struct sockaddr));
	if ( res < 0) 
    {
        if(errno == EINPROGRESS)
        {
            return fd;
        }

        close_socket(fd);
        return -1;
    }
	return fd;
}

int main(int  argc,
	 char **argv)
{
   SOCKET              listen_sock;
   struct sockaddr_un  addr;
   union conv_sockaddr u_sock_addr;
   int                 len, nb_str;
   char                **print_me;
   listen_sock = create_socket();
   strcpy(addr.sun_path, get_path());
   addr.sun_family = AF_LOCAL;
   u_sock_addr.un = &addr;
   if (connect(listen_sock, u_sock_addr.ad, sizeof(addr)) == -1)
   {
      printf("Client not connected.\n");
      return (-1);
   }
   if ((nb_str =parse_arg(argc, argv, &print_me)) == 0)
      return (close_server(listen_sock));
   for (; nb_str > 0; nb_str--)
   {
      len = strlen(print_me[nb_str - 1]);
      write(listen_sock, &len, sizeof(len));
      write(listen_sock, print_me[nb_str - 1], len);
   }
   close(listen_sock);
   free(print_me);
   return (0);
}

int main() {
        init_epoll();
        create_socket();
        setup_signals();

        while (running) {
                struct epoll_event event;
                int ret = epoll_wait(epoll_fd, &event, 1, -1);
                if (ret == 0)
                        continue;

                if (ret < 0) {
                        if (errno == EINTR)
                                continue;

		        syslog(LOG_ERR, "epoll_wait: %s\n", strerror(errno));
                        exit(1);
                }

                if (event.data.ptr == &listen_event)
                        handle_accept(event.events);
                else
                        handle_data(event.data.ptr);
        }

        cleanup();
}

void
ipc_init(recieve_callback callback_func)
{
	assert(!initialized);
	callback = callback_func;

#ifdef _WIN32
	int result;
	WSADATA wsaData;

	result = WSAStartup(MAKEWORD(2, 2), &wsaData);
	if(result != 0)
	{
		LOG_ERROR_MSG("Can't initialize Windows sockets");
		return;
	}
#endif

	if(create_socket() != 0)
	{
#ifdef _WIN32
		WSACleanup();
#endif
		initialized = -1;
		return;
	}

	/* FIXME: used to call try_become_a_server() here, but it always succeeds (see
	 *        FIXME comment there), which breaks our logic. */

	atexit(&clean_at_exit);
	initialized = 1;
}

int netsocket_setup(int argc, char **argv)
{
	cJSON *json;
	struct netsocket_config cfg;
	int error;

	error = read_json(argc, argv, &json);
	if (error)
		return error;

	error = json_to_config(json, &cfg);
	if (error)
		goto end;

	error = create_socket(&cfg);
	if (error)
		goto end;

	error = adjust_mcast_opts(&cfg);
	if (error) {
		close(sk);
		freeaddrinfo(addr_candidates);
		goto end;
	}
	/* Fall through. */

end:
	cJSON_Delete(json);
	return error;
}

int
tcp_server_start(struct tundev_context *ctx, uv_loop_t *loop) {
    int rc;

    uv_tcp_init(loop, &ctx->inet_tcp.tcp);

    ctx->inet_tcp_fd = create_socket(SOCK_STREAM, 1);
    if ((rc = uv_tcp_open(&ctx->inet_tcp.tcp, ctx->inet_tcp_fd))) {
        logger_stderr("tcp open error: %s", uv_strerror(rc));
        exit(1);
    }

    uv_tcp_bind(&ctx->inet_tcp.tcp, &ctx->tun->addr, 0);
    if (rc) {
        logger_stderr("tcp bind error: %s", uv_strerror(rc));
        exit(1);
    }

    ctx->inet_tcp.tcp.data = ctx;
    rc = uv_listen(&ctx->inet_tcp.stream, 128, accept_cb);
    if (rc) {
        logger_stderr("tcp listen error: %s", uv_strerror(rc));
        exit(1);
    }
    return rc;
}

struct bt_hci *bt_hci_new_raw_device(uint16_t index)
{
	struct bt_hci *hci;
	struct hci_filter flt;
	int fd;

	fd = create_socket(index, HCI_CHANNEL_RAW);
	if (fd < 0)
		return NULL;

	memset(&flt, 0, sizeof(flt));
	flt.type_mask = 1 << BT_H4_EVT_PKT;
	flt.event_mask[0] = 0xffffffff;
	flt.event_mask[1] = 0xffffffff;

	if (setsockopt(fd, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {
		close(fd);
		return NULL;
	}

	hci = create_hci(fd);
	if (!hci) {
		close(fd);
		return NULL;
	}

	hci->is_stream = false;

	bt_hci_set_close_on_unref(hci, true);

	return hci;
}

int main(int argc, const char *argv[])
{
    const char* host = argv[1];                  // 目标主机
    char send_buff[SEND_BUF_SIZE];               // 发送缓冲区
    char recv_buf[RECV_BUFF_SIZE];               // 接收缓冲区
    size_t to_send_size = 0;                     // 要发送数据大小 
    int client_fd;                               // 客户端socket
    struct addrinfo *addr;                       // 存放getaddrinfo返回数据

    if (argc != 2) {
        printf("Usage:%s [host]\n", argv[0]);
        return 1;
    }


    addr = get_addr(host, "80");
    client_fd = create_socket(addr);
    connect_host(client_fd, addr);
    freeaddrinfo(addr);

    to_send_size = get_send_data(send_buff, SEND_BUF_SIZE, host);
    send_data(client_fd, send_buff, to_send_size);

    recv_data(client_fd, recv_buf, RECV_BUFF_SIZE);

    close(client_fd);
    return 0;
}