Beispiel #1
0
bool NDInstanceBase::CheckReliableConn(nd_handle hsession)
{
	ndip_t peerip = nd_net_peer_getip(hsession) ;
	return CheckReliableHost(peerip);
}
Beispiel #2
0
int nd_net_ioctl(nd_netui_handle  socket_node, int cmd, void *val, int *size) 
{
	int ret = -1 ;
	NDUINT32 inputVal ;
	switch(cmd)
	{
	case NDIOCTL_SET_SENDVBUF:
		if (*size <4){
			return -1 ;
		}
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (!socket_node->is_session){
				inputVal = *(NDUINT32*)val ;
				ret = ndlbuf_realloc (&socket_node->send_buffer,inputVal) ;
			}
		}
		break ;
	case NDIOCTL_GET_SENDBUF:
		if (*size <4){
			return -1 ;
		}
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (!socket_node->is_session){
				*(NDUINT32*)val = (NDUINT32)ndlbuf_capacity(&socket_node->send_buffer) ;
				*size = sizeof(NDUINT32) ;
				ret = 0;
			}
		}
		break ;
	case NDIOCTL_SET_RECVVBUF:
		if (*size <4){
			return -1 ;
		}
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (!socket_node->is_session){
				inputVal = *(NDUINT32*)val ;
				ret = ndlbuf_realloc (&socket_node->recv_buffer,inputVal) ;
			}
		}
		break ;

	case NDIOCTL_GET_RECVBUF:
		if (*size <4){
			return -1 ;
		}
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (!socket_node->is_session){
				*(NDUINT32*)val = (NDUINT32)ndlbuf_capacity(&socket_node->recv_buffer) ;
				*size = sizeof(NDUINT32) ;
				ret = 0;
			}
		}
		break ;
	case NDIOCTL_SET_TCP_RECV_WNDSIZE:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (socket_node->fd){
				ret = setsockopt(socket_node->fd, SOL_SOCKET, SO_RCVBUF, (sock_opval_t)val, *size) ;
			}		
		}
		break ;
	case NDIOCTL_GET_TCP_RECV_WNDSIZE:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (socket_node->fd){
				inputVal = *(NDUINT32*)val ;
				ret = getsockopt(socket_node->fd, SOL_SOCKET, SO_RCVBUF, (sock_opval_t)val, size) ;
			}		
		}
		break ;
	case NDIOCTL_SET_TCP_SEND_WNDSIZE:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (socket_node->fd){
				inputVal = *(NDUINT32*)val ;
				ret = setsockopt(socket_node->fd, SOL_SOCKET, SO_SNDBUF,(sock_opval_t)val, *size) ;
			}		
		}
		break ;
	case NDIOCTL_GET_TCP_SEND_WNDSIZE:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			if (socket_node->fd){
				inputVal = *(NDUINT32*)val ;
				ret = getsockopt(socket_node->fd, SOL_SOCKET, SO_SNDBUF, (sock_opval_t)val, size) ;
			}		
		}
		break ;
	case NDIOCTL_SET_TIMEOUT:
		socket_node->disconn_timeout = (*(ndtime_t*)val) *1000 ;
		ret = 0;
		break;
	case NDIOCTL_GET_TIMEOUT:
		*(ndtime_t*)val  = socket_node->disconn_timeout /1000 ;
		*size = sizeof(ndtime_t) ;
		ret = 0;
		break ;
    case NDIOCTL_GET_LAST_RECV_TIME:
		*(ndtime_t*)val  = socket_node->last_recv ;
		*size = sizeof(ndtime_t) ;
		ret = 0;
        break ;
        
    case NDIOCTL_GET_LAST_SEND_TIME:
		*(ndtime_t*)val  = socket_node->last_push ;
		*size = sizeof(ndtime_t) ;
		ret = 0;
        break ;
        
    case NDIOCTL_GET_USERDATA:
		*(nd_userdata_t*)val  = socket_node->user_data ;
		ret = 0;
        break ;
    case NDIOCTL_SET_USERDATA:
		socket_node->user_data = val;
		ret = 0;
        break ;
        
        ///
        
    case NDIOCTL_GET_PEER_IP:
		*(ndip_t*) val = nd_net_peer_getip(socket_node);
		ret = 0;
        break;
        
    case NDIOCTL_GET_PEER_PORT:
		*(ndport_t*) val = nd_net_peer_getport(socket_node);
		ret = 0;
        break;

        
    case NDIOCTL_HOOK_DATA:
		nd_hook_data(socket_node,(data_in_entry) val ) ;
		ret = 0;
        break ;
        
    case NDIOCTL_HOOK_PACKET:
		nd_hook_packet(socket_node,(net_msg_entry) val ) ;
		ret = 0;
        break ;
        
    case NDIOCTL_SET_UNREG_MSG_CLOSED: //close peers when received unregister message
		nd_net_set_unregmsg_handler(socket_node, *(int*)val);
		ret = 0;

        break ;
    case NDIOCTL_SET_UNAUTHORIZE_CLOSE:
		nd_net_set_unauthorize_handler(socket_node, *(int*)val);
		ret = 0;
        break ;
        

    case NDIOCTL_SET_CRYPT_KEY:
		nd_connector_set_crypt(socket_node,val, *size);
		ret = 0;
        break ;
    case NDIOCTL_GET_CRYPT_KEY:
		{
		int keysize = 0 ;
		void *addr = nd_connector_get_crypt(socket_node, &keysize) ;
		ret = -1 ;
		if (keysize <= *size) {
			memcpy(val, addr, keysize) ;
			*size = keysize ;
			ret = 0 ;
		}
		}
        break;
            
    case NDIOCTL_SET_LEVEL:
		socket_node->level = (NDUINT8) (*(int*)val ) ;
		ret = 0;
        break;
            
    case NDIOCTL_GET_LEVEL:
		*(int*)val = socket_node->level ;
		ret = 0;
        break;

	case NDIOCTL_LOG_SEND_MSG:
		if (*(int*)val){
			socket_node->is_log_send = 1;
		}
		else {
			socket_node->is_log_send = 0;
		}
		ret = 0;
		break;

	case NDIOCTL_LOG_RECV_MSG:
		if (*(int*)val){
			socket_node->is_log_recv = 1;
		}
		else {
			socket_node->is_log_recv = 0;
		}
		ret = 0;
		break;

	case NDIOCTL_SYS_SET_LOG_FUNC:
		nd_setlog_func((logfunc)val);
		break;

	case NDIOCTL_SYS_GET_LOG_FUNC:
	{
		logfunc oldval = nd_setlog_func((logfunc)0);
		logfunc *retval = (logfunc *) val;
		*retval = oldval;
		nd_setlog_func(oldval);
	}
		break;

	case NDIOCTL_GET_SESSIONID:
		*(int*)val = socket_node->session_id ;
		ret = 0;
		break;
	case NDIOCTL_SET_SESSIONID:
		socket_node->session_id = (NDUINT16) (*(int*)val);
		ret = 0;
		break;
		
	case NDIOCTL_GET_WRITABLE_CALLBACK:
		*(net_writable_callback*)val = socket_node->writable_callback ;
		ret = 0 ;
		break ;
	case NDIOCTL_SET_WRITABLE_CALLBACK:
		socket_node->writable_callback =(net_writable_callback) *(nd_userdata_t*)val ;
		ret = 0 ;
		break ;
		
	case NDIOCTL_GET_WRITABLE_CALLBACK_PARAM:
		*(nd_userdata_t*)val = socket_node->writable_param ;
		ret = 0 ;
		break ;
	case NDIOCTL_SET_WRITABLE_CALLBACK_PARAM:
		socket_node->writable_param = *(nd_userdata_t*)val ;
		ret = 0 ;
		break ;
		

	case NDIOCTL_SET_BLOCK:
		ret = nd_socket_nonblock(socket_node->fd, 0) ;
		break ;
	case NDIOCTL_GET_BLOCK:
		ret = nd_socket_nonblock(socket_node->fd, 1) ;
		break ;

	case NDIOCTL_GET_RECV_PACK_NUM:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			*(NDUINT32*)val = (NDUINT32) nd_atomic_read(&socket_node->recv_pack_times) ;
			*size = sizeof(NDUINT32) ;
			ret = 0;
		}
		break ;
	case NDIOCTL_SET_RECV_PACK_NUM:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			inputVal = *(NDUINT32*)val ;
			nd_atomic_set(&socket_node->recv_pack_times, inputVal );
			ret = 0;
		}
		break ;
	case NDIOCTL_GET_SEND_PACK_NUM:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			*(NDUINT32*)val = (NDUINT32) nd_atomic_read(&socket_node->send_pack_times );
			*size = sizeof(NDUINT32) ;
			ret = 0;
		}
		break ;
	case NDIOCTL_SET_SEND_PACK_NUM:
		if (socket_node->type ==NDHANDLE_TCPNODE|| socket_node->type ==NDHANDLE_UDPNODE ){
			inputVal = *(NDUINT32*)val ;
			nd_atomic_set(&socket_node->send_pack_times, inputVal );
			ret = 0;
		}
		break ;
			
			
			
	case NDIOCTL_LOG_SEND_STRAM_FILE:
			ret = -1 ;
			if (val) {
				socket_node->save_send_stream = 1 ;
				if (_s_send_stream) {
					free(_s_send_stream) ;
				}
				_s_send_stream = (char*) malloc(*size + 1) ;
				if (_s_send_stream) {
					strncpy(_s_send_stream, (const char*)val, *size +1) ;
					ret =  0 ;
				}
			}
			else {
				socket_node->save_send_stream = 0;
				if (_s_send_stream) {
					free(_s_send_stream) ;
				}
				ret = 0 ;
			}
		break ;
	case NDIOCTL_LOG_RECV_STRAM_FILE:
			ret = -1 ;
			if (val) {
				socket_node->save_recv_stream = 1 ;
				if (_s_recv_stream) {
					free(_s_recv_stream) ;
				}
				_s_recv_stream = (char*) malloc(*size + 1) ;
				if (_s_recv_stream) {
					strncpy(_s_recv_stream, (const char*)val, *size +1) ;
					ret =  0 ;
				}
			}
			else {
				socket_node->save_recv_stream = 0;
				if (_s_recv_stream) {
					free(_s_recv_stream) ;
				}
				ret = 0 ;
			}
		break ;
	default :
		ret =-1 ;
		break ;
	}
	return ret ;
}