int service_connect(struct service * svc, struct thread * connecting_thread,
                    struct socket ** client_socket, bool * blocking)
{
    *blocking = false;
    *client_socket = 0;

    if(svc->listening_thread != 0)
    {
        struct socket * server_socket  = socket_create(svc->listening_thread);
        *client_socket = socket_create(connecting_thread);

        socket_connect(*client_socket, server_socket);

        // Wake up the listening thread and return the new socket:
        mordax_resource_t server_retval = process_add_resource(svc->listening_thread->parent,
                                          PROCESS_RESOURCE_SOCKET, server_socket);
        context_set_syscall_retval(svc->listening_thread->context, (void *) server_retval);
        scheduler_move_thread_to_running(svc->listening_thread);
        svc->listening_thread = 0;

        return 0;
    } else {
        queue_add_back(svc->backlog, connecting_thread);
        *blocking = true;
        return 0;
    }
}

int service_listen(struct service * svc, struct thread * listener,
                   struct socket ** server_socket, bool * blocking)
{
    *blocking = false;
    *server_socket = 0;

    if(svc->listening_thread != 0)
        return -EBUSY;

    if(svc->backlog->elements > 0)
    {
        struct thread * client_thread = 0;
        if(!queue_remove_front(svc->backlog, (void **) &client_thread))
            return -EINTERNAL;
        struct socket * client_socket = socket_create(client_thread);

        *server_socket = socket_create(listener);
        socket_connect(client_socket, *server_socket);

        mordax_resource_t client_retval = process_add_resource(client_thread->parent,
                                          PROCESS_RESOURCE_SOCKET, client_socket);
        context_set_syscall_retval(client_thread->context, (void *) client_retval);
        scheduler_move_thread_to_running(client_thread);

        return 0;
    } else {
        svc->listening_thread = listener;
        *blocking = true;
        return 0;
    }
}

/*
 * Kernel Sockets
 *
 * Mostly a wrapper around the private socket_* functions.
 */
int
ksocket_socket(ksocket_t *ksp, int domain, int type, int protocol, int flags,
    struct cred *cr)
{
	static const int version = SOV_DEFAULT;
	int error = 0;
	struct sonode *so;
	*ksp = NULL;

	/* All Solaris components should pass a cred for this operation. */
	ASSERT(cr != NULL);

	if (domain == AF_NCA || domain == AF_UNIX)
		return (EAFNOSUPPORT);

	ASSERT(flags == KSOCKET_SLEEP || flags == KSOCKET_NOSLEEP);
	so = socket_create(domain, type, protocol, NULL, NULL, version, flags,
	    cr, &error);
	if (so == NULL) {
		if (error == EAFNOSUPPORT) {
			char *mod = NULL;

			/*
			 * Could be that root file sytem is not loaded or
			 * soconfig has not run yet.
			 */
			if (type == SOCK_STREAM && (domain == AF_INET ||
			    domain == AF_INET6) && (protocol == 0 ||
			    protocol == IPPROTO_TCP)) {
					mod = SOCKETMOD_TCP;
			} else if (type == SOCK_DGRAM && (domain == AF_INET ||
			    domain == AF_INET6) && (protocol == 0 ||
			    protocol == IPPROTO_UDP)) {
					mod = SOCKETMOD_UDP;
			} else {
				return (EAFNOSUPPORT);
			}

			so = socket_create(domain, type, protocol, NULL,
			    mod, version, flags, cr, &error);
			if (so == NULL)
				return (error);
		} else {
			return (error);
		}
	}

	so->so_mode |= SM_KERNEL;

	*ksp = SOTOKS(so);

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

// sets errno on error
int websocket_create(Websocket *websocket) {
	int rc = socket_create(&websocket->base);

	if (rc < 0) {
		return rc;
	}

	websocket->base.base.type = "WebSocket";
	websocket->base.destroy = websocket_destroy;
	websocket->base.receive = websocket_receive;
	websocket->base.send = websocket_send;

	websocket->frame_index = 0;
	websocket->line_index = 0;
	websocket->state = WEBSOCKET_STATE_WAIT_FOR_HANDSHAKE;

	memset(&websocket->frame, 0, sizeof(WebsocketFrame));
	memset(websocket->line, 0, WEBSOCKET_MAX_LINE_LENGTH);
	memset(websocket->client_key, 0, WEBSOCKET_CLIENT_KEY_LENGTH);

	if (queue_create(&websocket->send_queue, sizeof(WebsocketQueuedData)) < 0) {
		return -1;
	}

	return 0;
}

int main(int arg, char *args[])
{
    sql_connect(&mysql, &conn);

    //如果没有参数，main函数返回
    if(arg < 2)
    {
        printf("usage:myserver port\n");
        return EXIT_FAILURE;
    }
    //setdaemon();
    //将第一个参数转化为整数
    int iport = atoi(args[1]);
    if(iport == 0)
    {
        printf("port %d is invalid\n", iport);
        return EXIT_FAILURE;
    }
    int st = socket_create(iport);
    socket_accept(st);
    sql_disconnect(conn);
    close(st);
    printf("myhttp is end\n");
    return 0;
}

/*
  initialise a wrepl_socket. The event_ctx is optional, if provided then
  operations will use that event context
*/
struct wrepl_socket *wrepl_socket_init(TALLOC_CTX *mem_ctx,
                                       struct tevent_context *event_ctx,
                                       struct smb_iconv_convenience *iconv_convenience)
{
    struct wrepl_socket *wrepl_socket;
    NTSTATUS status;

    wrepl_socket = talloc_zero(mem_ctx, struct wrepl_socket);
    if (!wrepl_socket) return NULL;

    wrepl_socket->event.ctx = talloc_reference(wrepl_socket, event_ctx);
    if (!wrepl_socket->event.ctx) goto failed;

    wrepl_socket->iconv_convenience = iconv_convenience;

    status = socket_create("ip", SOCKET_TYPE_STREAM, &wrepl_socket->sock, 0);
    if (!NT_STATUS_IS_OK(status)) goto failed;

    talloc_steal(wrepl_socket, wrepl_socket->sock);

    wrepl_socket->request_timeout	= WREPL_SOCKET_REQUEST_TIMEOUT;

    talloc_set_destructor(wrepl_socket, wrepl_socket_destructor);

    return wrepl_socket;

failed:
    talloc_free(wrepl_socket);
    return NULL;
}

/*
 * Initialize CMWHOD
 */
void
create()
{
	int error;

	rm(LOG_DIR + "/cmwhod");
	log_info(CLIENT_VERSION + ": cmwhod log for '" + THIS_MUD + "'\n");
	socket = socket_create(DATAGRAM, "read", "close");
	if (socket < 0) {
		log_info("socket_create: " + socket_error(socket) + "\n");
		return;
	}
	error = socket_bind(socket, 0);
	if (error != EESUCCESS) {
		log_info("socket_bind: " + socket_error(error) + "\n");
		return;
    }
	set_comments();
	mwhod_addr = DAEMON_IP + " " + UDP_PORT;
	mudname = capitalize(THIS_MUD);
	set_keepalive_message();
	set_boot_message();
	call_out("keepalive", KEEPALIVE_INTERVAL);
	call_out("refresh", REFRESH_INTERVAL / PARTITIONS, 0);
}

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

    virtual bool initSocket() {
        if (socket==SOCKET_INVALID) {
            socket = socket_create(AF_INET, SOCK_STREAM, IPPROTO_TCP, 54, 0);

            sockaddr_t socketAddr;
            int testResult = 0;

            // the family is always AF_INET
            socketAddr.sa_family = AF_INET;

            socketAddr.sa_data[0] = 0;
            socketAddr.sa_data[1] = 54;

            // the destination IP address: 8.8.8.8
            socketAddr.sa_data[2] = 127;
            socketAddr.sa_data[3] = 0;
            socketAddr.sa_data[4] = 0;
            socketAddr.sa_data[5] = 1;

            testResult = socket_connect(socket, &socketAddr, sizeof(socketAddr));
            if (testResult) {
                socket_close(socket);
                socket = SOCKET_INVALID;
            }
        }
        return socket!=SOCKET_INVALID;
    }

/* To establish a SOCKS5 connection, we create 2 idx's: one for the caller, and
	one that we use to connect to the server. */
int socks5_connect(int idx, char *proxy_host, int proxy_port, char *username, char *password, char *dest_host, int dest_port)
{
	int sock;
	proxy_info_t *info;

	sock = socket_create(proxy_host, proxy_port, NULL, 0, SOCKET_CLIENT|SOCKET_TCP|SOCKET_NONBLOCK);
	if (sock < 0) return(-1);

	info = (proxy_info_t *)malloc(sizeof(*info));
	info->host = strdup(dest_host);
	info->port = dest_port;
	if (!username) username = "";
	if (!password) password = "";
	info->username = strdup(username);
	info->password = strdup(password);
	info->status = 0;

	info->our_idx = sockbuf_new();
	sockbuf_set_sock(info->our_idx, sock, SOCKBUF_CLIENT);
	if (idx >= 0) info->their_idx = idx;
	else info->their_idx = sockbuf_new();

	info->sock = sock;

	sockbuf_set_handler(info->our_idx, &socks5_events, info);

	return(info->their_idx);
}

work::work(int port) //
{
	memset(socket_client, 0, sizeof(socket_client));
	listen_st = socket_create(port);//创建server端socket
	if (listen_st == 0)
		exit(-1);//创建socket失败，程序退出
}

int netlink_init() {
	struct socket *socket;
	
	// Регистрируем протокол
	if(register_routing_protocol(&system_proto) < 0) {
		error("Unable to register System routing protocol");
		return -1;
	}
	
	if((socket = socket_create(&system_proto)) == NULL) {
		error("Unable to create Netlink socket");
		return -1;
	}
	
	if(socket_bind_to_netlink(socket) < 0) {
		error("Unable to bind socket to Netlink");
		return -1;
	}
	
	if(socketlist_add(socket) < 0) {
		error("Unable to register Netlink socket");
		return -1;
	}	
	
	return 0;
}

/**
 * Test the connection and protocol
 */
static void check_connection(Service_T s, Port_T p) {
  Socket_T socket;
  volatile int rv = TRUE;
  char buf[STRLEN];
  char report[STRLEN] = {0};
  struct timeval t1;
  struct timeval t2;

  ASSERT(s && p);

  /* Get time of connection attempt beginning */
  gettimeofday(&t1, NULL);

  /* Open a socket to the destination INET[hostname:port] or UNIX[pathname] */
  socket = socket_create(p);
  if (!socket) {
    snprintf(report, STRLEN, "failed, cannot open a connection to %s", Util_portDescription(p, buf, sizeof(buf)));
    rv = FALSE;
    goto error;
  } else
    DEBUG("'%s' succeeded connecting to %s\n", s->name, Util_portDescription(p, buf, sizeof(buf)));

  /* Verify that the socket is ready for i|o. TCP sockets are checked anytime, UDP
   * sockets just when there is no specific protocol test used since the socket_is_ready()
   * adds 2s delay when used with UDP socket. When there is specific protocol used, we
   * don't need it for UDP, since the protocol test is sufficient */
  if ((socket_get_type(socket) != SOCK_DGRAM || p->protocol->check == check_default) && !socket_is_ready(socket)) {
    snprintf(report, STRLEN, "connection failed, %s is not ready for i|o -- %s", Util_portDescription(p, buf, sizeof(buf)), STRERROR);
    rv = FALSE;
    goto error;
  }

  /* Run the protocol verification routine through the socket */
  if (! p->protocol->check(socket)) {
    snprintf(report, STRLEN, "failed protocol test [%s] at %s", p->protocol->name, Util_portDescription(p, buf, sizeof(buf)));
    rv = FALSE;
    goto error;
  } else
    DEBUG("'%s' succeeded testing protocol [%s] at %s\n", s->name, p->protocol->name, Util_portDescription(p, buf, sizeof(buf)));

  /* Get time of connection attempt finish */
  gettimeofday(&t2, NULL);

  /* Get the response time */
  p->response = (double)(t2.tv_sec - t1.tv_sec) + (double)(t2.tv_usec - t1.tv_usec)/1000000;

  error:
  if (socket)
    socket_free(&socket);

  if (!rv) {
    p->response = -1;
    p->is_available = FALSE;
    Event_post(s, Event_Connection, STATE_FAILED, p->action, report);
  } else {
    p->is_available = TRUE;
    Event_post(s, Event_Connection, STATE_SUCCEEDED, p->action, "connection succeeded to %s", Util_portDescription(p, buf, sizeof(buf)));
  }
      
}

int main(int argc, char **argv)
{
	int mysock = -1;

	if (argc != 3) {
		printf("usage: %s LOCAL_TCP_PORT DEVICE_TCP_PORT\n", argv[0]);
		return 0;
	}

	listen_port = atoi(argv[1]);
	device_port = atoi(argv[2]);

	if (!listen_port) {
		fprintf(stderr, "Invalid listen_port specified!\n");
		return -EINVAL;
	}

	if (!device_port) {
		fprintf(stderr, "Invalid device_port specified!\n");
		return -EINVAL;
	}

	// first create the listening socket endpoint waiting for connections.
	mysock = socket_create(listen_port);
	if (mysock < 0) {
		fprintf(stderr, "Error creating socket: %s\n", strerror(errno));
		return -errno;
	} else {
#ifdef WIN32
		HANDLE acceptor = NULL;
#else
		pthread_t acceptor;
#endif
		struct sockaddr_in c_addr;
		socklen_t len = sizeof(struct sockaddr_in);
		struct client_data cdata;
		int c_sock;
		while (1) {
			printf("waiting for connection\n");
			c_sock = accept(mysock, (struct sockaddr*)&c_addr, &len);
			if (c_sock) {
				printf("accepted connection, fd = %d\n", c_sock);
				cdata.fd = c_sock;
#ifdef WIN32
				acceptor = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)acceptor_thread, &cdata, 0, NULL);
				WaitForSingleObject(acceptor, INFINITE);
#else
				pthread_create(&acceptor, NULL, acceptor_thread, &cdata);
				pthread_join(acceptor, NULL);
#endif
			} else {
				break;
			}
		}
		close(c_sock);
		close(mysock);
	}

	return 0;
}

status_t
socket_spawn_pending(net_socket *_parent, net_socket **_socket)
{
	net_socket_private *parent = (net_socket_private *)_parent;

	MutexLocker locker(parent->lock);

	// We actually accept more pending connections to compensate for those
	// that never complete, and also make sure at least a single connection
	// can always be accepted
	if (parent->child_count > 3 * parent->max_backlog / 2)
		return ENOBUFS;

	net_socket_private *socket;
	status_t status = socket_create(parent->family, parent->type, parent->protocol,
		(net_socket **)&socket);
	if (status < B_OK)
		return status;

	// inherit parent's properties
	socket->send = parent->send;
	socket->receive = parent->receive;
	socket->options = parent->options & ~SO_ACCEPTCONN;
	socket->linger = parent->linger;
	memcpy(&socket->address, &parent->address, parent->address.ss_len);
	memcpy(&socket->peer, &parent->peer, parent->peer.ss_len);

	// add to the parent's list of pending connections
	list_add_item(&parent->pending_children, socket);
	socket->parent = parent;
	parent->child_count++;

	*_socket = socket;
	return B_OK;
}

/**
 * @brief udp broadcast recv data
 *
 * @param cast_ip     [in]  ip address of broadcast
 * @param port        [in]  port of broadcast
 * @param cast_times  [in]  broadcast times
 * @param cast_info   [out] broadcast data
 * @param size        [in]  size of broadcast data
 *
 * @return 0, if succ; -1, if failed.
 */
int udp_broadcast_recv(const char *cast_ip, int port, int cast_times,\
        char *cast_info, int size)
{
    int fd = -1;
    struct sockaddr_in addr = {0};

    if (cast_times < 1) return -1;

    /**
     * 1. socket create and init
     * 2. set socket broadcast
     * 3. bind socket 
     */
    fd = socket_create(AF_INET, SOCK_DGRAM);
    inet_addr_init(&addr, cast_ip, port);
    make_socket_broadcast(fd, 1);
    socket_bind(fd, (struct sockaddr *)&addr);

    /**
     * recv broadcast data cycly
     */
    while (cast_times-- > 0)
    {
        if (socket_addr_recvfrom(fd, cast_info, \
                size, &addr) > 0)
            printf("broadcast recv from %s: %s\n", \
                inet_ntoa(addr.sin_addr), cast_info);
    }

    socket_close(fd);

    return 0;
}

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

/**
 * @brief udp broadcast send data
 *
 * @param cast_ip     [in]  ip address of broadcast
 * @param port        [in]  port of broadcast
 * @param cast_times  [in]  broadcast times
 * @param cast_info   [in] broadcast data
 *
 * @return 0, if succ; -1, if failed.
 */
int udp_broadcast_send(const char *cast_ip, int port, int cast_times,\
        const char *cast_info)
{
    int fd = -1;
    struct sockaddr_in addr = {0};

    if (cast_times < 1) return -1;

    /**
     * 1. socket create and init
     * 2. set socket broadcast
     */
    fd = socket_create(AF_INET, SOCK_DGRAM);
    inet_addr_init(&addr, cast_ip, port);
    make_socket_broadcast(fd, 1);

    /**
     * send broadcast data cycly
     */
    while (cast_times-- > 0)
    {
        socket_addr_sendto(fd, (void *)cast_info, strlen(cast_info), &addr);
        sleep(1);
    }

    socket_close(fd);

    return 0;
}