socket.hhf

High Level assembly language(HLA)软件

#if( !@defined( socket_hhf ))
?socket_hhf := true;

#includeonce( "os/net.hhf" )
namespace linux; @fast;

type


	// Socket related types:
	
	msghdr: record
		msg_name		:dword;
		msg_namelen		:dword;
		msg_iov			:dword;	// pointer to iovec.
		msg_iovlen		:size_t;
		msg_control		:dword;
		msg_controllen	:dword;
		msg_flags		:dword;
	endrecord;
	
	socket_state:
  		enum
  		{
  			ss_free,
  			ss_unconnected,
  			ss_connecting,
  			ss_connected,
  			ss_disconnecting
  		};

	socklen_t:	dword;
	
	socket_lock_t: record
		slock	:spinlock_t;
		users	:dword;
		wq		:wait_queue_head_t;
	endrecord;
	
	sk_buff_head: record
		next	:dword;	//pointer to sk_buff_head.
		prev	:dword;	//pointer to sk_buff_head.
		qlen	:dword;
		_lock	:spinlock_t;
	endrecord;
	

	in6_addr: union
		in6_u:union
			u6_addr8	:byte [ 16 ];
			u6_addr16	:word [  8 ];
			u6_addr32	:dword[  4 ];
		endunion;
		s6_addr		:byte [ 16 ];
		s6_addr16	:word [  8 ];
		s6_addr32	:dword[  4 ];
	endunion;
	
	sockaddr_in6: record
		sin6_family		:word;
		sin6_port		:word;
		sin6_flowinfo	:dword;
		sin6_addr		:in6_addr;
		sin6_scope_id	:dword;
	endrecord;
	
	icmp6_filter: record
		data	:dword[8];
	endrecord;
	
	icmp_filter: record
		data	:dword;
	endrecord;
	
	tcp_sack_block: record
		start_seq	:dword;
		end_seq		:dword;
	endrecord;
		
		
	ipv6_pinfo: record;
		saddr		:in6_addr;
		rcv_saddr	:in6_addr;
		daddr		:in6_addr;
		daddr_cache	:dword;		//pointer to in6_addr
		flow_label	:dword;
		frag_size	:dword;
		hop_limit	:dword;
		mcast_hops	:dword;
		mcast_oif	:dword;
		
		rxopt: union
			
			// bits:
			//	0-1:	srcrt
			//	2:		rxinfo
			//	3:		rxhlim
			//	4:		hopopts
			//	5:		dstopts
			//	6:		authhdr
			//	7:		rxflow
			
			bits	:byte;
			all		:byte;
			
		endunion;
		
		//sockoptFlags:
		// 0:	mc_loop
		// 1:	recverr
		// 2:	sndflow
		// 3-4:	pmtudisc
		
		sockoptFlags	:byte;
		
		ipv6_mc_list	:dword;	//pointer to ipv6_mc_socklist
		ipv6_fl_list	:dword; //pointer to ipv6_fl_socklist
		
		dst_cookie		:dword;
		
		opt				:dword;	//pointer to ipv6_txoptions
		pktoptions		:dword;	//pointer to sk_buff
	endrecord;
	
	raw6_opt: record
		checksum	:dword;
		offset		:dword;
		filter		:icmp6_filter;
	endrecord;
	
	raw_opt: record
		filter	:icmp_filter;
	endrecord;
	
	inet_opt: record
		ttl			:dword;
		tos			:dword;
		cmsg_flags	:dword;
		opt			:dword; //pointer to ip_options
		hdrincl		:byte;
		mc_ttl		:byte;
		mc_loop		:byte;
		
		// rAndF:
		// 0:	recverr
		// 1:	freebind
		
		rAndF		:word;
	
		id			:word;
		pmtudisc	:byte;
		mc_index	:dword;
		mc_addr		:dword;
		mc_list		:dword;	//pointer to ip_mc_socklist
	endrecord;
	
	ppp_channel_ops: record
		start_xmit	:procedure( ppp_ch: dword; skbptr:dword ); @cdecl;
		ioctl		:procedure
					 ( 
					 	ppp_ch	:dword; 
					 	p1		:dword; 
					 	p2		:dword 
					 ); @cdecl;
	endrecord;
	
	ppp_channel: record
		private	:dword;
		ops		:dword;	//pointer to ppp_channel_ops
		mtu		:dword;
		hdrlen	:dword;
		ppp		:dword;
		speed	:dword;
		latency	:dword;
	endrecord;
	
	pppoe_addr: record
		sid		:sid_t;
		remote	:char[  eth_alen ];
		dev		:char[ ifnamsiz ];
	endrecord;
	
	sockaddr_pppox: record
		sa_family	:sa_family_t;
		sa_protocol	:dword;
		sa_addr: union
			pppoe	:pppoe_addr;
		endunion;
	endrecord;
	
	pppoe_opt: record
		dev		:dword; // pointer to net_device
		pa		:pppoe_addr;
		relay	:sockaddr_pppox;
	endrecord;
	
	poppox_opt: record
		chan	:ppp_channel;
		sk		:dword;		// pointer to sock.
		next	:dword;		// pointer to ppox_opt
		proto: union
			pppoe	:pppoe_opt;
		endunion;
	endrecord;
	
	tcp_opt: record
		tcp_header_len	:dword;
		pred_flags		:dword;
		rcv_nxt			:dword;
		snd_nxt			:dword;
		snd_una			:dword;
		snd_sml			:dword;
		rcv_tstamp		:dword;
		lsndtime		:dword;
		ack: record
			pending			:byte;
			quick			:byte;
			pingpong		:byte;
			blocked			:byte;
			ato				:dword;
			timeout			:dword;
			lrcvtime		:dword;
			last_seg_size	:word;
			rcv_mss			:word;
		endrecord;
		
		ucopy: record
			prequeue	:sk_buff_head;
			memory		:dword;
			task		:dword; // pointer to task_struct
			iov			:dword; // pointer to iovec
			len			:dword;
		endrecord;
		
		snd_wl1			:dword;
		snd_wnd			:dword;
		max_window		:dword;
		pmtu_cookie		:dword;
		mss_cache		:word;
		mss_clamp		:word;
		ext_header_len	:word;
		ca_state		:byte;
		retransmits		:byte;
		reordering		:byte;
		queue_shrunk	:byte;
		defer_accept	:byte;
		
		backoff			:byte;
		srtt			:dword;
		mdev			:dword;
		mdev_max		:dword;
		rttvar			:dword;
		rtt_seq			:dword;
		rto				:dword;
		packets_out		:dword;
		left_out		:dword;
		retrans_out		:dword;
		
		snd_ssthresh	:dword;
		snd_cwnd		:dword;
		snd_cwnd_cnt	:dword;
		snd_cwnd_used	:dword;
		snd_cwnd_stamp	:dword;
		
		timeout			:dword;
		retransmit_timer:timer_list;
		delack_timer	:timer_list;
		out_of_order_queue	:sk_buff_head;
		af_specific		:dword; // pointer to tcp_func.
		send_head		:dword;	// pointer to sk_buff.
		sndmsg_page		:dword; // pointer to page.
		sndmsg_off		:dword;
		
		rcv_wnd			:dword;
		rcv_wup			:dword;
		write_seq		:dword;
		pushed_seq		:dword;
		copied_seq		:dword;
		
		tstamp_ok		:byte;
		wscale_ok		:byte;
		sack_ok			:byte;
		saw_tstamp		:byte;
		snd_wscale		:byte;
		rcv_wscale		:byte;
		nonagle			:byte;
		keepalive_probes:byte;
		
		rcv_tsval		:dword;
		rcv_tsecr		:dword;
		ts_recent		:dword;
		ts_recent_stamp	:dword;
		
		user_mss		:dword;
		dsack			:byte;
		eff_sacks		:byte;
		
		duplicate_sack	:tcp_sack_block[1];
		selective_acks	:tcp_sack_block[4];
		
		window_clamp	:dword;
		rcv_ssthresh	:dword;
		probes_out		:byte;
		num_sacks		:byte;
		advmss			:word;
		
		syn_retries		:byte;
		ecn_flags		:byte;
		prior_ssthresh	:word;
		lost_out		:dword;
		sacked_out		:dword;
		fackets_out		:dword;
		high_seq		:dword;
		
		retrans_stamp	:dword;
		
		undo_marker		:dword;
		undo_retrans	:dword;
		urg_seq			:dword;
		urg_data		:word;
		pending			:byte;
		urg_mode		:byte;
		snd_up			:dword;
		
		syn_wait_lock	:rwlock_t;
		listen_opt		:dword;	// pointer to tcp_listen_opt
		accept_queue	:dword;	// pointer to open_request
		accept_queue_tail	:dword;	//pointer to open_request
		write_pending	:dword;
		keepalive_time	:dword;
		keepalive_intvl	:dword;
		linger2			:dword;
		
	endrecord;
		
	unix_opt: record
		addr		:dword;	// pointer to unix_address
		dentery		:dword;	// pointer to dentry
		mnt			:dword;	// pointer to vfsmount
		readsem		:semaphore;
		other		:dword;	// pointer to sock
		list		:dword; // pointer to pointer to sock.
		gc_tree		:dword;	// pointer to sock.
		inflight	:atomic_t;
		_lock		:rwlock_t;
		peer_wait	:wait_queue_head_t;
	endrecord;
	
	ipx_address: record
		net		:dword;
		node	:char[ ipx_node_len ];
		sock	:word;
	endrecord;
	ipx_opt: record
		dest_addr	:ipx_address;
		intrfc		:dword;		//pointer to ipx_interface
		port		:word;
		node		:byte[ ipx_node_len ];
		_type		:word;
		ipx_ncp_conn:word;
	endrecord;
	
	
	spx_opt: record
		state			:dword;
		sndbuf			:dword;
		retries			:dword;
		retransmits		:dword;
		max_retries		:dword;
		wd_interval		:dword;
		owner			:dword;
		dest_connid		:word;
		source_connid	:word;
		sequence		:word;
		alloc			:word;
		rmt_ack			:word;
		rmt_seq			:word;
		acknowledge		:word;
		rmt_alloc		:word;
		dest_addr		:ipx_address;
		source_addr		:ipx_address;
		watchdog		:timer_list;
		retransmit		:timer_list;
		rcv_queue		:sk_buff_head;
		transmit_queue	:sk_buff_head;
		retransmit_queue:sk_buff_head;
	endrecord;
		
	ucred: record
		pid	:dword;
		uid	:dword;
		gid	:dword;
	endrecord;
	
	at_addr: record
		s_net	:word;
		s_node	:byte;
	endrecord;
	
	sockaddr_at: record
		sat_family	:sa_family_t;
		sat_port	:byte;
		sat_addr	:at_addr;
		sat_zero	:byte[8];
	endrecord;
	
	atalk_sock: record
		dest_net	:word;
		src_net		:word;
		dest_node	:byte;
		src_node	:byte;
		dest_port	:byte;
		src_port	:byte;
	endrecord;
	
	dn_naddr: record
		a_len	:word;
		a_addr	:char[ dn_maxaddl ];
	endrecord;
	
	sockaddr_dn: record
		sdn_family	:word;
		sdn_flags	:byte;
		sdn_objnum	:byte;
		sdn_objnamel:word;
		sdn_objname	:char[ dn_maxobjl ];
		sdn_add		:dn_naddr;
	endrecord;
	
	accessdata_dn: record
		acc_accl	:byte;
		acc_acc		:char[ dn_maxaccl ];
		acc_passl	:byte;
		acc_pass	:char[ dn_maxaccl ];
		acc_userl	:byte;
		acc_user	:char[ dn_maxaccl ];
	endrecord;
	
	etheraddress: record
		dne_addr	:char[6];
		dne_remote	:record
			dne_hiord		:byte[4];
			dne_nodeaddr	:byte[2];
		endrecord;
	endrecord;
	
	dn_addr: record
		dna_family	:word;
		dna_netaddr	:etheraddress;
	endrecord;
	
	optdata_dn: record
		opt_status	:word;
		opt_optl	:word;
		opt_data	:byte[16];
	endrecord;
	
	dn_scp: record
		state			:byte;
		addrloc			:word;
		addrrem			:word;
		numdat			:word;
		numoth			:word;
		numoth_rcv		:word;
		numdat_rcv		:word;
		ackxmt_dat		:word;
		ackxmt_oth		:word;
		ackrcv_dat		:word;
		ackrcv_oth		:word;
		flowrem_sw		:byte;
		flowloc_sw		:byte;
		flowrem_dat		:word;
		flowrem_oth		:word;
		flowloc_dat		:word;
		flowloc_oth		:word;
		services_rem	:byte;
		services_loc	:byte;
		info_rem		:byte;
		info_loc		:byte;
		segsize_rem		:word;
		segsize_loc		:word;
		nonagle			:byte;
		multi_ireq		:byte;
		accept_mode		:byte;
		seg_total		:dword;
		conndata_in		:optdata_dn;
		conndata_out	:optdata_dn;
		discdata_in		:optdata_dn;
		discdata_out	:optdata_dn;
		accessdata		:accessdata_dn;
		addr			:sockaddr_dn;
		peer			:sockaddr_dn;
		max_window		:dword;
		snd_window		:dword;
		nsp_srtt		:dword;
		nsp_rttvar		:dword;
		nsp_rxtshift	:dword;
		data_xmit_queue	:sk_buff_head;
		other_xmit_queue:sk_buff_head;
		other_receive_queue	:sk_buff_head;
		other_report	:dword;
		stamp			:dword;
		
		persist			:dword;
		persist_fxn		:procedure( sk:dword ); @cdecl;
		
		keepalive		:dword;
		keepalive_fxn	:procedure( sk:dword ); @cdecl;
		
		delack_timer	:timer_list;
		delack_pending	:dword;
		delack_fxn		:procedure( sk:dword ); @cdecl;
		
	endrecord;
		
		
		
	sock: record
		daddr			:dword;
		rcv_saddr		:dword;
		dport			:word;
		num				:word;
		bound_dev_if	:dword;
		
		next			:dword;		// pointer to sock.
		pprev			:dword;		// pointer to pointer to sock.
		bind_next		:dword;		// pointer to sock.
		bind_pprev		:dword;		// pointer to pointer to sock.
		
		state			:byte;
		zapped			:byte;
		sport			:word;
		family			:word;
		reuse			:byte;
		shutdown		:byte;
		refcnt			:atomic_t;
		
		_lock			:socket_lock_t;
		rcvbuf			:dword;
		sleep			:dword;		// pointer to wait_queue_head_t
		dst_cache		:dword;		// pointer to dst_entry.
		dst_lock		:rwlock_t;
		rmem_alloc		:atomic_t;
		receive_queue	:sk_buff_head;
		wmem_alloc		:atomic_t;
		write_queue		:sk_buff_head;
		omem_alloc		:atomic_t;
		wmem_queued		:dword;
		forward_alloc	:dword;
		saddr			:dword;
		allocation		:dword;
		sndbuf			:dword;
		prev			:dword;		// pointer to sock.
		
		dead			:byte;
		done			:byte;
		urginline		:byte;
		keepopen		:byte;
		linger			:byte;
		destroy			:byte;
		no_check		:byte;
		broadcast		:byte;
		bsdism			:byte;
		debug			:byte;
		rcvtstamp		:byte;
		use_write_queue	:byte;
		userlocks		:byte;
		
		route_caps		:dword;
		proc			:dword;
		lingertime		:dword;
		hashent			:dword;
		pair			:dword;	// pointer to sock.
		
		backlock: record
			head	:dword;	// pointer to sk_buff.
			tail	:dword;	// pointer to sk_buff.
		endrecord;
		
		callback_lock	:rwlock_t;
		prot			:dword;	// pointer to proto.
		
		net_pinfo: union
			af_inet6	:ipv6_pinfo;
		endunion;
		
		tp_pinfo: union
			af_tcp	:tcp_opt;
			tp_raw4	:raw_opt;
			tp_raw	:raw6_opt;
			af_spx	:spx_opt;
		endunion;
		
		err				:dword;
		err_soft		:dword;
		ack_backlog		:word;
		max_ack_backlog	:word;
		priority		:dword;
		_type			:word;
		localroute		:byte;
		protocol		:byte;
		peercred		:ucred;
		rcvlowat		:dword;
		rcvtimeo		:dword;
		sndtimeo		:dword;
		
		filter			:dword;	// pointer to sk_filter.
		
		protinfo: union
			destruct_hook	:dword;
			af_unix			:unix_opt;
			af_inet			:inet_opt;
			af_at			:atalk_sock;
			af_ipx			:ipx_opt;
			dn				:dn_scp;
			af_packet		:dword; //pointer to packet_opt
			x25				:dword;	//pointer to x25_cb
			ax25			:dword; //pointer to x25_cb
			nr				:dword; //pointer to nr_cb
			rose			:dword; //pointer to rose_cb
			pppox			:dword; //pointer pppox_opt
			af_netlink		:dword; //pointer to netlink_opt
			af_econet		:dword; //pointer to econet_opt
			af_atm			:dword; //pointer to  atm_vcc
			irda			:dword; //pointer to irda_sock
			af_wanpipe		:dword; //pointer to wanpipe_opt
		endunion;
		
		timer				:timer_list;
		stamp				:timeval;
		
		socket				:dword;	//pointer to socket.
		user_data			:dword;
		
		state_change	:procedure( sk:dword ); @cdecl;
		data_ready		:procedure( sk:dword; bytes:dword ); @cdecl;
		write_space		:procedure( sk:dword ); @cdecl;
		error_report	:procedure( sk:dword ); @cdecl;
		backlog_rcv		:procedure( sk:dword; skb:dword ); @cdecl;
		destruct		:procedure( sk:dword ); @cdecl;
		
	endrecord;
		
		
		
		
		
		
  	socket_t: record
  		state		:socket_state;
  		flags		:dword;
  		ops			:dword;		// pointer to proto_ops.
  		inode		:dword;		// pointer to inode.
		fasync_list	:dword;		// pointer to fasync_struct.
		file		:dword;		// pointer to file structure.
		sk			:sock;
		_wait		:wait_queue_head_t;
		_type		:word;
		passcred	:byte;
	endrecord;
	
	sockaddr: record
		sa_family	:sa_family_t;
		sa_data		:char[14];
	endrecord;
	
	

		

	

end linux;
#endif //socket_hhf