自学教程：C++ socket_create函数代码示例

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. */intksocket_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 errorint 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 */voidcreate(){	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_tsocket_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;}

/*  initialise a nbt_dgram_socket. The event_ctx is optional, if provided  then operations will use that event context*/struct nbt_dgram_socket *nbt_dgram_socket_init(TALLOC_CTX *mem_ctx, 					      struct tevent_context *event_ctx){	struct nbt_dgram_socket *dgmsock;	NTSTATUS status;	dgmsock = talloc(mem_ctx, struct nbt_dgram_socket);	if (dgmsock == NULL) goto failed;	dgmsock->event_ctx = event_ctx;	if (dgmsock->event_ctx == NULL) goto failed;	status = socket_create("ip", SOCKET_TYPE_DGRAM, &dgmsock->sock, 0);	if (!NT_STATUS_IS_OK(status)) goto failed;	socket_set_option(dgmsock->sock, "SO_BROADCAST", "1");	talloc_steal(dgmsock, dgmsock->sock);	dgmsock->fde = tevent_add_fd(dgmsock->event_ctx, dgmsock,				    socket_get_fd(dgmsock->sock), 0,				    dgm_socket_handler, dgmsock);	dgmsock->send_queue = NULL;	dgmsock->incoming.handler = NULL;	dgmsock->mailslot_handlers = NULL;		return dgmsock;failed:	talloc_free(dgmsock);	return NULL;}

bool socketer::listen(unsigned short port, int backlog, bool islocal){	struct sockaddr_in soaddr;	if(m_sockfd != NET_INVALID_SOCKET)		close();	m_sockfd = socket_create();	if(m_sockfd == NET_INVALID_SOCKET)		return false;	memset(&soaddr, 0, sizeof(soaddr));	soaddr.sin_family = AF_INET;	if(islocal)		soaddr.sin_addr.s_addr = inet_addr("127.0.0.1");	else		soaddr.sin_addr.s_addr - INADDR_ANY;	soaddr.sin_port = htons(port);	if(bind(m_sockfd, (struct sockaddr *)&soaddr, sizeof(soaddr)) !=0)	{		close();		return false;	}	if(listen(m_sockfd, backlog) != 0)	{		close();		return false;	}	return true;}

static int tcp_sock_finish_setup(tcp_sockdata_t *sock, int *sock_id){	socket_core_t *sock_core;	int rc;	log_msg(LVL_DEBUG, "tcp_sock_finish_setup()");	sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);	if (sock->recv_fibril == 0)		return ENOMEM;	rc = socket_create(&sock->client->sockets, sock->client->sess,	    sock, sock_id);	if (rc != EOK) {		fibril_destroy(sock->recv_fibril);		sock->recv_fibril = 0;		return rc;	}	sock_core = socket_cores_find(&sock->client->sockets, *sock_id);	assert(sock_core != NULL);	sock->sock_core = sock_core;	return EOK;}

int main(void){    WSADATA Data;    SOCKADDR_IN recvSockAddr;    SOCKET recvSocket;    struct hostent * remoteHost;    char * ip;    const char * host_name = "pb-homework.appspot.com";    char maxBuff[MAXBUFLEN] = "/0";    int status = initDLL(Data);    if(status == 1)    {        fprintf(stderr, "Cannot initialize dll - WSAStartup failed.");        exit(1);    }    remoteHost = gethostbyname(host_name);    ip = inet_ntoa(*(struct in_addr *)*remoteHost->h_addr_list);    memset(&recvSockAddr, 0, sizeof(recvSockAddr));    recvSockAddr.sin_port=htons(PORT);    recvSockAddr.sin_family=AF_INET;    recvSockAddr.sin_addr.s_addr= inet_addr(ip);    recvSocket = socket_create();    socket_connect(recvSocket, recvSockAddr);    socket_sendRequest(host_name, recvSocket);    socket_receiveInfo(recvSocket, maxBuff);    getSecret(maxBuff, host_name, recvSocket);    socket_receiveInfo(recvSocket, maxBuff);    printf("******************************************/n"           "Answer to request from R.A. server/n"           "%s/n"           "******************************************/n",           maxBuff);    // Find the longest word here!    char longest[80] = "/0";    longestWord(maxBuff, longest);    printf("/n/n******************************************/n"           "Longest word was: [%s]/n"           "******************************************/n",           longest);    socket_sendPost(recvSocket, host_name, longest);    socket_receiveInfo(recvSocket, maxBuff);    printf("/n/n******************************************/n"           "Answer from R.A. server to my POST:/n"           "%s/n"           "******************************************/n",           maxBuff);    // Close all sockets.    closesocket(recvSocket);    // Free memory associated with sockets.    WSACleanup();    return 0;}

void consume_all_sockets(uint8_t protocol){    static int port = 9000;    int socket_handle;    do {        socket_handle = socket_create(AF_INET, SOCK_STREAM, protocol==IPPROTO_UDP ? IPPROTO_UDP : IPPROTO_TCP, port++, NIF_DEFAULT);    } while(socket_handle_valid(socket_handle));}

t_socket* socket_listen_in(char* ip, int port) {    t_socket* sock = socket_create();    addr_info* addr = addr_create(ip, port);    bind(sock->socket, (struct sockaddr*) addr, sizeof(addr_info));    listen(sock->socket, 100);    free(addr);    return sock;}

t_socket* socket_connect_to(char* ip, int port) {    t_socket* sock = socket_create();    addr_info* addr = addr_create(ip, port);     connect(sock->socket, (struct sockaddr*) addr, sizeof(addr_info));    free(addr);        return sock;}

/************************************************************************** FUNCTION*  custom_socket_create** DESCRIPTION*  Customize SOCKET create function.*  Return KAL_FALSE directly if SOCKET should not be created.** PARAMETERS** RETURNS** GLOBALS AFFECTED**************************************************************************/kal_bool custom_socket_create(comptask_handler_struct **handle){#ifdef SOC_NOT_PRESENT   return KAL_FALSE;#else   return socket_create(handle);#endif /* SOC_NOT_PRESENT */}

/*-------------------------------------------------------------------------*/* Tries to create a new inet socket/*-------------------------------------------------------------------------*/const char *inet_trycreate(p_socket ps, int family, int type, int protocol) {    const char *err = socket_strerror(socket_create(ps, family, type, protocol));    if (err == NULL && family == AF_INET6) {        int yes = 1;        setsockopt(*ps, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&yes, sizeof(yes));    }    return err;}