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

/**	socket_set_timeout : 'socket -> timout:number? -> void	<doc>Set the socket send and recv timeout in seconds to the given value (or null for blocking)</doc>**/static value socket_set_timeout( value o, value t ) {#ifdef NEKO_WINDOWS	int time;	val_check_kind(o,k_socket);	if( val_is_null(t) )		time = 0;	else {		val_check(t,number);		time = (int)(val_number(t) * 1000);	}#else	struct timeval time;	val_check_kind(o,k_socket);	if( val_is_null(t) ) {		time.tv_usec = 0;		time.tv_sec = 0;	} else {		val_check(t,number);		init_timeval(val_number(t),&time);	}#endif	if( setsockopt(val_sock(o),SOL_SOCKET,SO_SNDTIMEO,(char*)&time,sizeof(time)) != 0 )		neko_error();	if( setsockopt(val_sock(o),SOL_SOCKET,SO_RCVTIMEO,(char*)&time,sizeof(time)) != 0 )		neko_error();	return val_true;}

/**	socket_recv : 'socket -> buf:string -> pos:int -> len:int -> int	<doc>Read up to [len] bytes from [buf] starting at [pos] from a connected socket.	Return the number of bytes readed.</doc>**/static value socket_recv( value o, value data, value pos, value len ) {	int p,l,dlen,ret;	int retry = 0;	val_check_kind(o,k_socket);	val_check(data,string);	val_check(pos,int);	val_check(len,int);	p = val_int(pos);	l = val_int(len);	dlen = val_strlen(data);	if( p < 0 || l < 0 || p > dlen || p + l > dlen )		neko_error();	POSIX_LABEL(recv_again);	if( retry++ > NRETRYS ) {		sock_tmp t;		t.sock = val_sock(o);		t.buf = val_string(data) + p;		t.size = l;		neko_thread_blocking(tmp_recv,&t);		ret = t.ret;	} else		ret = recv(val_sock(o), val_string(data) + p , l, MSG_NOSIGNAL);	if( ret == SOCKET_ERROR ) {		HANDLE_EINTR(recv_again);		return block_error();	}	return alloc_int(ret);}

/**	socket_poll_prepare : 'poll -> read:'socket array -> write:'socket array -> int array array	<doc>	Prepare a poll for scanning events on sets of sockets.	</doc>**/static value socket_poll_prepare( value pdata, value rsocks, value wsocks ) {	polldata *p;	int i,len;	val_check(rsocks,array);	val_check(wsocks,array);	val_check_kind(pdata,k_poll);	p = val_poll(pdata);	len = val_array_size(rsocks);	if( len + val_array_size(wsocks) > p->max )		val_throw(alloc_string("Too many sockets in poll"));#	ifdef NEKO_WINDOWS	for(i=0;i<len;i++) {		value s = val_array_ptr(rsocks)[i];		val_check_kind(s,k_socket);		p->fdr->fd_array[i] = val_sock(s);	}	p->fdr->fd_count = len;	len = val_array_size(wsocks);	for(i=0;i<len;i++) {		value s = val_array_ptr(wsocks)[i];		val_check_kind(s,k_socket);		p->fdw->fd_array[i] = val_sock(s);	}	p->fdw->fd_count = len;#	else	for(i=0;i<len;i++) {		value s = val_array_ptr(rsocks)[i];		val_check_kind(s,k_socket);		p->fds[i].fd = val_sock(s);		p->fds[i].events = POLLIN;		p->fds[i].revents = 0;	}	p->rcount = len;	len = val_array_size(wsocks);	for(i=0;i<len;i++) {		int k = i + p->rcount;		value s = val_array_ptr(wsocks)[i];		val_check_kind(s,k_socket);		p->fds[k].fd = val_sock(s);		p->fds[k].events = POLLOUT;		p->fds[k].revents = 0;	}	p->wcount = len;#	endif	{		value a = alloc_array(2);		val_array_ptr(a)[0] = p->ridx;		val_array_ptr(a)[1] = p->widx;		return a;	}}

static value socket_recv_from( value o, value dataBuf, value pos, value len, value addr ) {	int p,l,ret;	int retry = 0;	struct sockaddr_in saddr;	SockLen slen = sizeof(saddr);	val_check_kind(o,k_socket);	val_check(dataBuf,buffer);	buffer buf = val_to_buffer(dataBuf);   char *data = buffer_data(buf);   int dlen = buffer_size(buf);	val_check(pos,int);	val_check(len,int);	val_check(addr,object);	p = val_int(pos);	l = val_int(len);	if( p < 0 || l < 0 || p > dlen || p + l > dlen )		neko_error();   SOCKET sock = val_sock(o);   gc_enter_blocking();	POSIX_LABEL(recv_from_again);	if( retry++ > NRETRYS ) {      ret = recv(sock,data+p,l,MSG_NOSIGNAL);	} else		ret = recvfrom(sock, data + p , l, MSG_NOSIGNAL, (struct sockaddr*)&saddr, &slen);	if( ret == SOCKET_ERROR ) {		HANDLE_EINTR(recv_from_again);		return block_error();	}   gc_exit_blocking();	alloc_field(addr,f_host,alloc_int32(*(int*)&saddr.sin_addr));	alloc_field(addr,f_port,alloc_int(ntohs(saddr.sin_port)));	return alloc_int(ret);}

/**	socket_close : 'socket -> void	<doc>Close a socket. Any subsequent operation on this socket will fail</doc>**/static value socket_close( value o ) {	POSIX_LABEL(close_again);	if( closesocket(val_sock(o)) ) {		HANDLE_EINTR(close_again);	}	return alloc_bool(true);}

/**	socket_set_timeout : 'socket -> timout:number? -> void	<doc>Set the socket send and recv timeout in seconds to the given value (or null for blocking)</doc>**/static value socket_set_timeout( value o, value t ) {	SOCKET sock = val_sock(o);#ifdef NEKO_WINDOWS	int time;	if( val_is_null(t) )		time = 0;	else {		val_check(t,number);		time = (int)(val_number(t) * 1000);	}#else	struct timeval time;	if( val_is_null(t) ) {		time.tv_usec = 0;		time.tv_sec = 0;	} else {		val_check(t,number);		init_timeval(val_number(t),&time);	}#endif   gc_enter_blocking();	if( setsockopt(sock,SOL_SOCKET,SO_SNDTIMEO,(char*)&time,sizeof(time)) != 0 )   {      gc_exit_blocking();		return alloc_null();   }	if( setsockopt(sock,SOL_SOCKET,SO_RCVTIMEO,(char*)&time,sizeof(time)) != 0 )   {      gc_exit_blocking();		return alloc_null();   }   gc_exit_blocking();	return alloc_bool(true);}

/**	socket_epoll_register : 'epoll -> 'socket -> int	<doc>Register a socket with an epoll instance to be notified of events. Returns the socket's fd.</doc>**/static value socket_epoll_register(value e, value s, value events) {	SOCKET sock;	int event_types;	epolldata *ep;	val_check_kind(e,k_epoll);	val_check_kind(s,k_socket);	val_check(events,int);	sock = val_sock(s);	event_types = val_int(events);	ep = val_epoll(e);#ifndef HAS_EPOLL	if (sock >= FD_SETSIZE)		val_throw(alloc_string("Can't register file descriptor >= FD_SETSIZE"));	if (event_types & EPOLLIN) {		if (ep->rcount >= FD_SETSIZE)			val_throw(alloc_string("Too many sockets (on non-Linux platforms, 'epoll' uses select)"));		val_array_ptr(ep->read)[ep->rcount++] = s;	}	if (event_types & EPOLLOUT) {		if (ep->wcount >= FD_SETSIZE)			val_throw(alloc_string("Too many sockets (on non-Linux platforms, 'epoll' uses select)"));		val_array_ptr(ep->write)[ep->wcount++] = s;	}#else	struct epoll_event ev;	ev.events = event_types;	ev.data.fd = sock;	int ret = epoll_ctl(ep->epollfd, EPOLL_CTL_ADD, sock, &ev);	if (ret == -1)		val_throw(alloc_int(errno));#endif	return alloc_int(sock);}

/**	socket_send_to : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int	<doc>	Send data from an unconnected UDP socket to the given address.	</doc>**/static value socket_send_to( value o, value data, value pos, value len, value vaddr ) {	int p,l,dlen;	value host, port;	struct sockaddr_in addr;	val_check_kind(o,k_socket);	val_check(data,string);	val_check(pos,int);	val_check(len,int);	val_check(vaddr,object);	host = val_field(vaddr, f_host);	port = val_field(vaddr, f_port);	val_check(host,int32);	val_check(port,int);	p = val_int(pos);	l = val_int(len);	dlen = val_strlen(data);	memset(&addr,0,sizeof(addr));	addr.sin_family = AF_INET;	addr.sin_port = htons(val_int(port));	*(int*)&addr.sin_addr.s_addr = val_int32(host);	if( p < 0 || l < 0 || p > dlen || p + l > dlen )		neko_error();	POSIX_LABEL(send_again);	dlen = sendto(val_sock(o), val_string(data) + p , l, MSG_NOSIGNAL, (struct sockaddr*)&addr, sizeof(addr));	if( dlen == SOCKET_ERROR ) {		HANDLE_EINTR(send_again);		return block_error();	}	return alloc_int(dlen);}

/**	socket_listen : 'socket -> int -> void	<doc>Listen for a number of connections</doc>**/static value socket_listen( value o, value n ) {	val_check_kind(o,k_socket);	val_check(n,int);	if( listen(val_sock(o),val_int(n)) == SOCKET_ERROR )		neko_error();	return val_true;}

static value socket_set_blocking( value o, value b ) {	SOCKET sock = val_sock(o);	val_check(b,bool);   gc_enter_blocking();#ifdef NEKO_WINDOWS	{		unsigned long arg = val_bool(b)?0:1;		if( ioctlsocket(sock,FIONBIO,&arg) != 0 )      {         gc_exit_blocking();			return alloc_null();      }	}#else	{		int rights = fcntl(sock,F_GETFL);		if( rights == -1 )      {         gc_exit_blocking();			return alloc_null();      }		if( val_bool(b) )			rights &= ~O_NONBLOCK;		else			rights |= O_NONBLOCK;		if( fcntl(sock,F_SETFL,rights) == -1 )      {         gc_exit_blocking();			return alloc_null();      }	}#endif   gc_exit_blocking();	return alloc_bool(true);}

/**	socket_send_to : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int	<doc>	Send data from an unconnected UDP socket to the given address.	</doc>**/static value socket_send_to( value o, value dataBuf, value pos, value len, value vaddr ) {	int p,l;	value host, port;	struct sockaddr_in addr;	val_check_kind(o,k_socket);   buffer buf = val_to_buffer(dataBuf);	const char *cdata = buffer_data(buf);	int dlen = buffer_size(buf);	val_check(pos,int);	val_check(len,int);	val_check(vaddr,object);	host = val_field(vaddr, f_host);	port = val_field(vaddr, f_port);	val_check(host,int);	val_check(port,int);	p = val_int(pos);	l = val_int(len);	memset(&addr,0,sizeof(addr));	addr.sin_family = AF_INET;	addr.sin_port = htons(val_int(port));	*(int*)&addr.sin_addr.s_addr = val_int(host);	if( p < 0 || l < 0 || p > dlen || p + l > dlen )		neko_error();   SOCKET sock = val_sock(o);	gc_enter_blocking();	POSIX_LABEL(send_again);	dlen = sendto(sock, cdata + p , l, MSG_NOSIGNAL, (struct sockaddr*)&addr, sizeof(addr));	if( dlen == SOCKET_ERROR ) {		HANDLE_EINTR(send_again);		return block_error();	}	gc_exit_blocking();	return alloc_int(dlen);}

value socket_set_fast_send( value o, value b ){	SOCKET sock = val_sock(o);	val_check(b,bool);   int fast = val_bool(b);   setsockopt(sock,IPPROTO_TCP,TCP_NODELAY,(char*)&fast,sizeof(fast));   return alloc_null();}

/**	socket_bind : 'socket -> host : 'int32 -> port:int -> void	<doc>Bind the socket for server usage on the given host and port</doc>**/static value socket_bind( value o, value host, value port ) {	int opt = 1;	struct sockaddr_in addr;	val_check_kind(o,k_socket);	val_check(host,int32);	val_check(port,int);	memset(&addr,0,sizeof(addr));	addr.sin_family = AF_INET;	addr.sin_port = htons(val_int(port));	*(int*)&addr.sin_addr.s_addr = val_int32(host);	#ifndef NEKO_WINDOWS	setsockopt(val_sock(o),SOL_SOCKET,SO_REUSEADDR,(char*)&opt,sizeof(opt));	#endif	if( bind(val_sock(o),(struct sockaddr*)&addr,sizeof(addr)) == SOCKET_ERROR )		neko_error();	return val_true;}

/**	socket_set_fast_send : 'socket -> bool -> void	<doc>	Disable or enable to TCP_NODELAY flag for the socket	</doc>**/static value socket_set_fast_send( value s, value f ) {	int fast;	val_check_kind(s,k_socket);	val_check(f,bool);	fast = val_bool(f);	if( setsockopt(val_sock(s),IPPROTO_TCP,TCP_NODELAY,(char*)&fast,sizeof(fast)) )		neko_error();	return val_null;}

/**	socket_close : 'socket -> void	<doc>Close a socket. Any subsequent operation on this socket will fail</doc>**/static value socket_close( value o ) {	val_check_kind(o,k_socket);	POSIX_LABEL(close_again);	if( closesocket(val_sock(o)) ) {		HANDLE_EINTR(close_again);	}	val_kind(o) = NULL;	return val_true;}

/**	socket_shutdown : 'socket -> read:bool -> write:bool -> void	<doc>Prevent the socket from further reading or writing or both.</doc>**/static value socket_shutdown( value o, value r, value w ) {	val_check_kind(o,k_socket);	val_check(r,bool);	val_check(w,bool);	if( !val_bool(r) && !val_bool(w) )		return val_true;	if( shutdown(val_sock(o),val_bool(r)?(val_bool(w)?SHUT_RDWR:SHUT_RD):SHUT_WR) )		neko_error();	return val_true;}

/**	socket_host : 'socket -> #address	<doc>Return the socket local address composed of an (host,port) array</doc>**/static value socket_host( value o ) {	SOCKET sock = val_sock(o);	struct sockaddr_in addr;	SockLen addrlen = sizeof(addr);	value ret;	if( getsockname(sock,(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )		return alloc_null();	ret = alloc_array(2);	val_array_set_i(ret,0,alloc_int32(*(int*)&addr.sin_addr));	val_array_set_i(ret,1,alloc_int(ntohs(addr.sin_port)));	return ret;}

/**	socket_listen : 'socket -> int -> void	<doc>Listen for a number of connections</doc>**/static value socket_listen( value o, value n ) {	SOCKET sock = val_sock(o);	val_check(n,int);	gc_enter_blocking();	if( listen(sock,val_int(n)) == SOCKET_ERROR )	{		gc_exit_blocking();		return alloc_null();	}	gc_exit_blocking();	return alloc_bool(true);}

static value socket_accept( value o ) {	SOCKET sock = val_sock(o);	struct sockaddr_in addr;	SockLen addrlen = sizeof(addr);	SOCKET s;	gc_enter_blocking();	s = accept(sock,(struct sockaddr*)&addr,&addrlen);	if( s == INVALID_SOCKET )		return block_error();	gc_exit_blocking();	return alloc_abstract(k_socket,(void *)(socket_int)s);}

/**	socket_host : 'socket -> #address	<doc>Return the socket local address composed of an (host,port) array</doc>**/static value socket_host( value o ) {	struct sockaddr_in addr;	unsigned int addrlen = sizeof(addr);	value ret;	val_check_kind(o,k_socket);	if( getsockname(val_sock(o),(struct sockaddr*)&addr,&addrlen) == SOCKET_ERROR )		neko_error();	ret = alloc_array(2);	val_array_ptr(ret)[0] = alloc_int32(*(int*)&addr.sin_addr);	val_array_ptr(ret)[1] = alloc_int(ntohs(addr.sin_port));	return ret;}

/**	socket_accept : 'socket -> 'socket	<doc>Accept an incoming connection request</doc>**/static value socket_accept( value o ) {	struct sockaddr_in addr;	unsigned int addrlen = sizeof(addr);	SOCKET s;	val_check_kind(o,k_socket);	POSIX_LABEL(accept_again);	s = accept(val_sock(o),(struct sockaddr*)&addr,&addrlen);	if( s == INVALID_SOCKET ) {		HANDLE_EINTR(accept_again);		return block_error();	}	return alloc_abstract(k_socket,(value)(int_val)s);}

/**	socket_connect : 'socket -> host:'int32 -> port:int -> void	<doc>Connect the socket the given [host] and [port]</doc>**/static value socket_connect( value o, value host, value port ) {	struct sockaddr_in addr;	val_check_kind(o,k_socket);	val_check(host,int32);	val_check(port,int);	memset(&addr,0,sizeof(addr));	addr.sin_family = AF_INET;	addr.sin_port = htons(val_int(port));	*(int*)&addr.sin_addr.s_addr = val_int32(host);	if( connect(val_sock(o),(struct sockaddr*)&addr,sizeof(addr)) != 0 )		return block_error();	return val_true;}

/**	socket_recv_from : 'socket -> buf:string -> pos:int -> length:int -> addr:{host:'int32,port:int} -> int	<doc>	Read data from an unconnected UDP socket, store the address from which we received data in addr.	</doc>**/static value socket_recv_from( value o, value data, value pos, value len, value addr ) {	int p,l,dlen,ret;	int retry = 0;	struct sockaddr_in saddr;	int slen = sizeof(saddr);	val_check_kind(o,k_socket);	val_check(data,string);	val_check(pos,int);	val_check(len,int);	val_check(addr,object);	p = val_int(pos);	l = val_int(len);	dlen = val_strlen(data);	if( p < 0 || l < 0 || p > dlen || p + l > dlen )		neko_error();	POSIX_LABEL(recv_from_again);	if( retry++ > NRETRYS ) {		sock_tmp t;		t.sock = val_sock(o);		t.buf = val_string(data) + p;		t.size = l;		neko_thread_blocking(tmp_recv,&t);		ret = t.ret;	} else		ret = recvfrom(val_sock(o), val_string(data) + p , l, MSG_NOSIGNAL, (struct sockaddr*)&saddr, &slen);	if( ret == SOCKET_ERROR ) {		HANDLE_EINTR(recv_from_again);#ifdef	NEKO_WINDOWS		if( WSAGetLastError() == WSAECONNRESET )			ret = 0;		else#endif		return block_error();	}	alloc_field(addr,f_host,alloc_int32(*(int*)&saddr.sin_addr));	alloc_field(addr,f_port,alloc_int(ntohs(saddr.sin_port)));	return alloc_int(ret);}

/**	socket_recv_char : 'socket -> int	<doc>Read a single char from a connected socket.</doc>**/static value socket_recv_char( value o ) {	int ret;	int retry = 0;	unsigned char cc;	val_check_kind(o,k_socket);	POSIX_LABEL(recv_char_again);	if( retry++ > NRETRYS ) {		sock_tmp t;		t.sock = val_sock(o);		t.buf = (char*)&cc;		t.size = 1;		neko_thread_blocking(tmp_recv,&t);		ret = t.ret;	} else		ret = recv(val_sock(o),&cc,1,MSG_NOSIGNAL);	if( ret == SOCKET_ERROR ) {		HANDLE_EINTR(recv_char_again);		return block_error();	}	if( ret == 0 )		neko_error();	return alloc_int(cc);}

/**	socket_set_blocking : 'socket -> bool -> void	<doc>Turn on/off the socket blocking mode.</doc>**/static value socket_set_blocking( value o, value b ) {	val_check_kind(o,k_socket);	val_check(b,bool);#ifdef NEKO_WINDOWS	{		unsigned long arg = val_bool(b)?0:1;		if( ioctlsocket(val_sock(o),FIONBIO,&arg) != 0 )			neko_error();	}#else	{		int rights = fcntl(val_sock(o),F_GETFL);		if( rights == -1 )			neko_error();		if( val_bool(b) )			rights &= ~O_NONBLOCK;		else			rights |= O_NONBLOCK;		if( fcntl(val_sock(o),F_SETFL,rights) == -1 )			neko_error();	}#endif	return val_true;}

/**	socket_shutdown : 'socket -> read:bool -> write:bool -> void	<doc>Prevent the socket from further reading or writing or both.</doc>**/static value socket_shutdown( value o, value r, value w ) {	SOCKET sock = val_sock(o);	val_check(r,bool);	val_check(w,bool);	if( !val_bool(r) && !val_bool(w) )		return alloc_bool(true);	gc_enter_blocking();	if( shutdown(sock,val_bool(r)?(val_bool(w)?SHUT_RDWR:SHUT_RD):SHUT_WR) )	{		gc_exit_blocking();		return alloc_null();	}	gc_exit_blocking();	return alloc_bool(true);}

/**	socket_recv_char : 'socket -> int	<doc>Read a single char from a connected socket.</doc>**/static value socket_recv_char( value o ) {	int ret;	unsigned char cc;	SOCKET sock = val_sock(o);	gc_enter_blocking();	POSIX_LABEL(recv_char_again);	ret = recv(sock,(char *)&cc,1,MSG_NOSIGNAL);	if( ret == SOCKET_ERROR ) {		HANDLE_EINTR(recv_char_again);		return block_error();	}	gc_exit_blocking();	if( ret == 0 )		val_throw(alloc_string("Connection closed"));	return alloc_int(cc);}

/**	socket_send_char : 'socket -> int -> void	<doc>Send a character over a connected socket. Must be in the range 0..255</doc>**/static value socket_send_char( value o, value v ) {	int c;	unsigned char cc;	val_check_kind(o,k_socket);	val_check(v,int);	c = val_int(v);	if( c < 0 || c > 255 )		neko_error();	cc = (unsigned char)c;	POSIX_LABEL(send_char_again);	if( send(val_sock(o),&cc,1,MSG_NOSIGNAL) == SOCKET_ERROR ) {		HANDLE_EINTR(send_char_again);		return block_error();	}	return val_true;}

static value make_array_result( value a, fd_set *tmp ) {	value r;	int i, len;	int pos = 0;	if( tmp == NULL )		return val_null;	len = val_array_size(a);	r = alloc_array(len);	for(i=0;i<len;i++) {		value s = val_array_i(a,i);		if( FD_ISSET(val_sock(s),tmp) )			val_array_set_i(r,pos++,s);	}	val_array_set_size(r,pos);	return r;}

/**	socket_connect : 'socket -> host:'int32 -> port:int -> void	<doc>Connect the socket the given [host] and [port]</doc>**/static value socket_connect( value o, value host, value port ) {	struct sockaddr_in addr;	val_check(host,int);	val_check(port,int);	memset(&addr,0,sizeof(addr));	addr.sin_family = AF_INET;	addr.sin_port = htons(val_int(port));	*(int*)&addr.sin_addr.s_addr = val_int(host);	gc_enter_blocking();	if( connect(val_sock(o),(struct sockaddr*)&addr,sizeof(addr)) != 0 )	{		gc_exit_blocking();		val_throw(alloc_string("[email
C++ val_strlen函数代码示例
C++ val_print函数代码示例