ThreadX docsThreadX docs
ThreadX
ThreadX Modules
NetX Duo
FileX
GUIX
USBX
TraceX
LevelX
ThreadX
ThreadX Modules
NetX Duo
FileX
GUIX
USBX
TraceX
LevelX
  • NetX Duo Documentation

    • Understand NetX Duo
    • NetX Duo documentation
    • Chapter 1 - Introduction to NetX Duo
    • Chapter 2 - Installation and Use of NetX Duo
    • Chapter 3 - Functional Components of NetX Duo
    • Chapter 4 - Description of NetX Duo Services
    • Chapter 5 - NetX Duo Network Drivers
    • Appendix A - NetX Duo Services
    • Appendix B - NetX Duo Constants
    • Appendix C - NetX Duo Data Types
    • Appendix D - NetX Duo BSD-Compatible Socket API
    • Appendix E - NetX Duo ASCII Character Codes
    • Auto-IP

      • Chapter 1 - Introduction to NetX Duo AutoIP
      • Chapter 2 - Installation and use of NetX Duo AutoIP
      • Chapter 3 - Description of NetX Duo AutoIP services
    • BSD

      • Chapter 1 - Introduction to NetX Duo BSD
      • Chapter 2 - Installation and use of NetX Duo BSD
      • Chapter 3 - NetX Duo BSD Services
    • Crypto

      • Chapter 1 - Introduction to NetX Duo Crypto
      • Chapter 2 - Installation and use of NetX Duo Crypto
      • Chapter 3 - Functional description of NetX Duo Crypto
      • Chapter 4 - NetX Duo Crypto API description
      • Appendix - NetX Duo Crypto CAVS test
    • DHCP Client

      • Chapter 1 - Introduction to the NetX Duo DHCP Client
      • Chapter 2 - Installation and use of NetX Duo DHCP Client
      • Chapter 3 - Description of NetX Duo DHCP Client services
      • Appendix A - Description of the Restore state feature for NetX Duo DHCP Client services
    • DHCP Server

      • Chapter 1 - Introduction to NetX Duo DHCP Server
      • Chapter 2 - Installation and Use of the NetX Duo DHCP Server
      • Chapter 3 - Description of NetX Duo DHCP server services
    • DHCPv6 Client

      • Chapter 1 - Introduction to NetX Duo DHCPv6 Client
      • Chapter 2 - Installation and use of NetX Duo DHCPv6 Client
      • Chapter 3 - NetX Duo DHCPv6 configuration options
      • Chapter 4 - NetX Duo DHCPv6 Client services
      • Appendix A - Description of the Restore State Feature for NetX Duo DHCPv6 Client
    • DHCPv6 Server

      • Chapter 1 - Introduction to NetX Duo DHCPv6 server
      • Chapter 2 - Installation and use of NetX Duo DHCPv6 server
      • Chapter 3 - NetX Duo DHCPv6 server configuration options
      • Chapter 4 - NetX Duo DHCPv6 server services
      • Appendix A – NetX Duo DHCPv6 option codes
      • Appendix B - NetX Duo DHCPv6 server status codes
      • Appendix C - NetX Duo DHCPv6 unique identifiers (DUIDs)
      • Appendix D - NetX Duo Advanced DHCPv6 server example
    • DNS

      • Chapter 1 - Introduction to the NetX Duo DNS Client
      • Chapter 2 - Installation and Use of NetX Duo DNS Client
      • Chapter 3 - Description of NetX Duo DNS Client Services
    • FTP

      • Chapter 1 - Introduction to NetX Duo FTP
      • Chapter 2 - Installation and use of FTP
      • Chapter 3 - Description of FTP services
    • HTTP

      • Chapter 1 - Introduction to NetX Duo HTTP
      • Chapter 2 - Installation and Use of NetX Duo HTTP
      • Chapter 3 - Description of NetX Duo HTTP Services
    • iperf

      • Chapter 1 - Introduction to NetX Duo Iperf
      • Chapter 2 - Installing and using NetX Duo Iperf
      • Chapter 3 - Running the UDP Transmit Test
    • mDNS

      • Chapter 1 - Introduction to NetX Duo mDNS/DNS-SD
      • Chapter 2 - Installation and use of mDNS
      • Chapter 3 - Description of internal service cache
      • Chapter 4 - Description of mDNS services
    • mqtt

      • Chapter 1 - Introduction to NetX Duo MQTT
      • Chapter 2 - Installation and use of NetX Duo MQTT client
      • Chapter 3 - Description of NetX Duo MQTT Client Services
    • NAT

      • Chapter 1 - An introduction to Network Address Translation
      • Chapter 2 - Installation and use of NAT
      • Chapter 3 - NAT configuration options
      • Chapter 4 - Description of NAT services
    • POP3 Client

      • Chapter 1 - Introduction to NetX Duo POP3
      • Chapter 2 - Installation and use of NetX Duo POP3 Client
      • Chapter 3 - Description of POP3 Client services
    • PPP

      • Chapter 1 - Introduction to the NetX Duo Point-to-Point Protocol (PPP)
      • Chapter 2 - Installation and use of NetX Duo Point-to-Point Protocol (PPP)
      • Chapter 3 - Description of NetX Duo Point-to-Point Protocol (PPP) services
    • PTP Client

      • Chapter 1 - Introduction to NetX Duo PTP Client
      • Chapter 2 - Installation and Use of NetX Duo PTP Client
      • Chapter 3 - Description of NetX Duo PTP Client Services
    • rtp

      • Chapter 1 - Introduction to the NetX Duo RTP Sender
      • Chapter 2 - Installation and use of NetX Duo RTP Sender
      • Chapter 3 - Description of NetX Duo RTP Sender Services
    • rtsp

      • Chapter 1 - Introduction to the NetX Duo RTSP Server
      • Chapter 2 - Installation and use of NetX Duo RTSP Server
      • Chapter 3 - Description of NetX Duo RTSP Server Services
    • Secure DTLS

      • Chapter 1 - Introduction to NetX Duo Secure DTLS
      • Chapter 2 - Installation and use of NetX Duo Secure DTLS
      • Chapter 3 - Functional description of NetX Duo Secure DTLS
      • Chapter 4 - Description of NetX Duo Secure DTLS services
      • Appendix A - NetX Duo Secure DTLS return/error codes
    • Secure TLS

      • Chapter 1 - Introduction to NetX Duo Secure
      • Chapter 2 - Installation and use of NetX Duo Secure
      • Chapter 3 - Functional description of NetX Duo Secure
      • Chapter 4 - Description of NetX Duo Secure services
      • Appendix A - NetX Duo Secure return/error codes
    • SMTP Client

      • Chapter 1 - Introduction to NetX Duo SMTP client
      • Chapter 2 - Installation and use of NetX Duo SMTP client
      • Chapter 3 - Client description of SMTP Client services
    • snmp

      • Chapter 1 - Introduction to NetX Duo SNMP
      • Chapter 2 - Installation and use of the NetX Duo SNMP agent
      • Chapter 3 - Description of NetX Duo SNMP agent services
    • sntp client

      • Chapter 1 - Introduction to NetX Duo SNTP
      • Chapter 2 - Installation and Use of NetX Duo SNTP Client
      • Chapter 3 - Description of NetX Duo SNTP Client Services
      • Appendix A - NetX Duo SNTP Fatal Error Codes
    • telnet

      • Chapter 1 - Introduction to NetX Duo Telnet
      • Chapter 2 - Installation and use of NetX Duo Telnet
      • Chapter 3 - Description of NetX Duo Telnet services
    • TFTP

      • Chapter 1 - Introduction to NetX Duo TFTP
      • Chapter 2 - Installation and use of NetX Duo TFTP
      • Chapter 3 - Description of NetX Duo TFTP services
    • Web HTTP

      • Chapter 1 - Introduction to HTTP and HTTPS
      • Chapter 2 - Installation and use of HTTP and HTTPS
      • Chapter 3 - Description of HTTP services
    • About the NetX Duo User Guide

Appendix A - NetX Duo Services

Address Resolution Protocol (ARP)

UINT     nx_arp_dynamic_entries_invalidate(NX_IP *ip_ptr);
UINT     nx_arp_dynamic_entry_set(NX_IP *ip_ptr, ULONG
            ip_address, ULONG physical_msw, ULONG physical_lsw);
UINT     nx_arp_enable(NX_IP *ip_ptr, VOID *arp_cache_memory,
            ULONG arp_cache_size);
UINT     nx_arp_gratuitous_send(NX_IP *ip_ptr,
            VOID (*response_handler)(NX_IP *ip_ptr,
            NX_PACKET *packet_ptr));
UINT     nx_arp_hardware_address_find(NX_IP *ip_ptr,
         ULONG ip_address, ULONG*physical_msw,
         ULONG *physical_lsw); 
UINT     nx_arp_info_get(NX_IP *ip_ptr, ULONG
            *arp_requests_sent, ULONG*arp_requests_received,
            ULONG *arp_responses_sent,
            ULONG*arp_responses_received,
            ULONG *arp_dynamic_entries,
            ULONG *arp_static_entries,
            ULONG *arp_aged_entries,
            ULONG *arp_invalid_messages);                    
UINT     nx_arp_ip_address_find(NX_IP *ip_ptr,
            ULONG *ip_address, ULONG physical_msw,
            ULONG physical_lsw);
UINT     nx_arp_static_entries_delete(NX_IP *ip_ptr);
UINT     nx_arp_static_entry_create(NX_IP *ip_ptr,
            ULONG ip_address,
            ULONG physical_msw, ULONG physical_lsw);
UINT     nx_arp_static_entry_delete(NX_IP *ip_ptr,
            ULONG ip_address, ULONG physical_msw,
            ULONG physical_lsw);

Internet Control Message Protocol (ICMP)

UINT     nx_icmp_enable(NX_IP *ip_ptr);
UINT     nx_icmp_info_get(NX_IP *ip_ptr, ULONG *pings_sent,
            ULONG *ping_timeouts, ULONG *ping_threads_suspended,
            ULONG *ping_responses_received,
            ULONG *icmp_checksum_errors,
            ULONG *icmp_unhandled_messages);
UINT     nx_icmp_ping(NX_IP *ip_ptr,
            ULONG ip_address, CHAR *data,
            ULONG data_size, NX_PACKET **response_ptr,
            ULONG wait_option);
UINT     nxd_icmp_enable(NX_IP *ip_ptr)
UINT     nxd_icmp_ping(NX_IP *ip_ptr, NXD_ADDRESS *ip_address,
            CHAR *data_ptr, ULONG data_size, NX_PACKET
            **response_ptr, ULONG wait_option)
UINT     nxd_icmp_interface_ping(NX_IP *ip_ptr, NXD_ADDRESS
            *ip_address, UINT source_index, CHAR *data_ptr,
            ULONG data_size, NX_PACKET **response_ptr, ULONG
            wait_option);

Internet Group Management Protocol (IGMP)

UINT     nx_igmp_enable(NX_IP *ip_ptr);
UINT     nx_igmp_info_get(NX_IP *ip_ptr, ULONG
            *igmp_reports_sent, ULONG *igmp_queries_received,
            ULONG *igmp_checksum_errors,
            ULONG *current_groups_joined);
UINT     nx_igmp_loopback_disable(NX_IP *ip_ptr);
UINT     nx_igmp_loopback_enable(NX_IP *ip_ptr);
UINT     nx_igmp_multicast_interface_join(NX_IP *ip_ptr,
            ULONG group_address, UINT interface_index);
UINT     nx_igmp_multicast_join(NX_IP *ip_ptr,
            ULONG group_address);
UINT     nx_igmp_multicast_leave(NX_IP *ip_ptr,
            ULONG group_address);

Internet Protocol (IP)

UINT     nx_ip_address_change_notify(NX_IP *ip_ptr,
            VOID (*change_notify)(NX_IP *, VOID *),
            VOID *additional_info);
UINT     nx_ip_address_get(NX_IP *ip_ptr, ULONG *ip_address,
            ULONG *network_mask);
UINT     nx_ip_address_set(NX_IP *ip_ptr, ULONG ip_address,
ULONG network_mask);
UINT     nx_ip_create(NX_IP *ip_ptr, CHAR *name,
            ULONG ip_address,
            ULONG network_mask, NX_PACKET_POOL *default_pool,
            VOID (*ip_network_driver)(NX_IP_DRIVER *),
            VOID *memory_ptr, ULONG memory_size, UINT priority);
UINT     nx_ip_delete(NX_IP *ip_ptr);
UINT     nx_ip_driver_direct_command(NX_IP *ip_ptr, UINT
            command, ULONG *return_value_ptr);
UINT     nx_ip_driver_interface_direct_command(NX_IP *ip_ptr,
            UINT command, UINT interface_index, ULONG
            *return_value_ptr);
UINT     nx_ip_forwarding_disable(NX_IP *ip_ptr);
UINT     nx_ip_forwarding_enable(NX_IP *ip_ptr);
UINT     nx_ip_fragment_disable(NX_IP *ip_ptr);
UINT     nx_ip_fragment_enable(NX_IP *ip_ptr);
UINT     nx_ip_gateway_address_set(NX_IP *ip_ptr,
            ULONG ip_address);
UINT     nx_ip_info_get(NX_IP *ip_ptr,
            ULONG *ip_total_packets_sent,
            ULONG *ip_total_bytes_sent,
            ULONG *ip_total_packets_received,
            ULONG *ip_total_bytes_received,
            ULONG *ip_invalid_packets,
            ULONG *ip_receive_packets_dropped,
            ULONG *ip_receive_checksum_errors,
            ULONG *ip_send_packets_dropped,
            ULONG *ip_total_fragments_sent,
            ULONG *ip_total_fragments_received);
UINT     nx_ip_interface_address_get(NX_IP *ip_ptr,
            ULONG interface_index,
            ULONG *ip_address,
            ULONG *network_mask);
UINT     nx_ip_interface_address_set(NX_IP *ip_ptr,
            ULONG interface_index, ULONG ip_address, ULONG
            network_mask);
UINT     nx_ip_interface_attach(NX_IP *ip_ptr, CHAR*
            interface_name, ULONG ip_address, ULONG
            network_mask,
            VOID (*ip_link_driver)(struct NX_IP_DRIVER_STRUCT
            *));
UINT     nx_ip_interface_info_get(NX_IP *ip_ptr, UINT
            interface_index, CHAR **interface_name, ULONG
            *ip_address,
            ULONG *network_mask, ULONG *mtu_size,
            ULONG *physical_address_msw, ULONG
            *physical_address_lsw);
UINT     nx_ip_interface_status_check(NX_IP *ip_ptr,
            UINT interface_index, ULONG needed_status,
            ULONG *actual_status, ULONG wait_option);
UINT     nx_ip_max_payload_size_find(NX_IP *ip_ptr,
            NXD_ADDRESS *dest_address, UINT if_index,
            UINT src_port,
            UINT dest_port, ULONG protocol,
            ULONG *start_offset_ptr,
            ULONG *payload_length_ptr)
UINT     nx_ip_raw_packet_disable(NX_IP *ip_ptr);
UINT     nx_ip_raw_packet_enable(NX_IP *ip_ptr);
UINT     nx_ip_raw_packet_interface_send(NX_IP *ip_ptr,
            NX_PACKET *packet_ptr, ULONG destination_ip,
            UINT interface_index, ULONG type_of_service);
UINT     nx_ip_raw_packet_receive(NX_IP *ip_ptr,
            NX_PACKET **packet_ptr,
            ULONG wait_option);
UINT     nx_ip_raw_packet_send(NX_IP *ip_ptr,
            NX_PACKET *packet_ptr,
            ULONG destination_ip, ULONG type_of_service);
UINT     nx_ip_static_route_add(NX_IP *ip_ptr, ULONG
            network_address, ULONG net_mask, ULONG next_hop);
UINT     nx_ip_static_route_delete(NX_IP *ip_ptr, ULONG
            network_address, ULONG net_mask);
UINT     nx_ip_status_check(NX_IP *ip_ptr, ULONG needed_status,
            ULONG *actual_status, ULONG wait_option);
UINT     nxd_ipv6_default_router_add(NX_IP *ip_ptr, NXD_ADDRESS
            *router_address, ULONG router_lifetime, UINT
            if_index)
UINT     nxd_ipv6_default_router_delete(NX_IP *ip_ptr,
            NXD_ADDRESS *router_address)
UINT     nxd_ipv6_default_router_get(NX_IP *ip_ptr, UINT
            if_index, NXD_ADDRESS *router_address, ULONG
            *router_lifetime, ULONG *prefix_length)
UINT     nxd_ipv6_enable(NX_IP *ip_ptr)
UINT     nxd_ip_raw_packet_send(NX_IP *ip_ptr, NX_PACKET
            *packet_ptr, NXD_ADDRESS *destination_ip, ULONG
            protocol)
UINT     nxd_ip_raw_packet_interface_send(NX_IP *ip_ptr,
            NX_PACKET *packet_ptr, NXD_ADDRESS *destination_ip,
            UINT if_index, ULONG protocol);
UINT     nxd_ipv6_address_delete(NX_IP *ip_ptr, UINT
            address_index);
UINT     nxd_ipv6_address_get(NX_IP *ip_ptr, UINT address_index,
            NXD_ADDRESS *ip_address, ULONG *prefix_length, UINT
            *if_index);
UINT     nxd_ipv6_address_set(UINT nxd_ipv6_address_set(NX_IP
            *ip_ptr, UINT address_index);

Neighbor Discovery

UINT     nxd_nd_cache_entry_delete(NX_IP ip_ptr, ULONG
            *ip_address)
UINT     nxd_nd_cache_entry_set(NX_IP *ip_ptr, ULONG
            *ip_address, char *mac)
UINT     nxd_nd_cache_hardware_address_find(NX_IP *ip_ptr,
            NXD_ADDRESS *ip_address, ULONG *physical_msw,
            ULONG *physical_lsw)
UINT     nxd_nd_cache_invalidate(NX_IP *ip_ptr)
UINT     nxd_nd_cache_ip_address_find(NX_IP *ip_ptr, NXD_ADDRESS
            *ip_address,ULONG physical_msw, ULONG physical_lsw,
            UINT *if_index)

Packet Management

UINT     nx_packet_allocate(NX_PACKET_POOL *pool_ptr,
			   NX_PACKET **packet_ptr, ULONG packet_type,
			   ULONG wait_option);
UINT     nx_packet_copy(NX_PACKET *packet_ptr,
			   NX_PACKET **new_packet_ptr, NX_PACKET_POOL
			   *pool_ptr,
			   ULONG wait_option);
UINT     nx_packet_data_append(NX_PACKET *packet_ptr,
			   VOID *data_start, ULONG data_size,
			   NX_PACKET_POOL *pool_ptr, ULONG wait_option);
UINT     nx_packet_data_extract_offset(NX_PACKET *packet_ptr,
			   ULONG offset, VOID *buffer_start, ULONG
			   buffer_length, ULONG *bytes_copied);
UINT     nx_packet_data_retrieve(NX_PACKET *packet_ptr,
			   VOID *buffer_start, ULONG *bytes_copied);
UINT     nx_packet_length_get(NX_PACKET *packet_ptr, ULONG
			   *length);
UINT     nx_packet_pool_create(NX_PACKET_POOL *pool_ptr,
			   CHAR *name, ULONG block_size, VOID *memory_ptr,
			   ULONG memory_size);
UINT     nx_packet_pool_delete(NX_PACKET_POOL *pool_ptr);
UINT     nx_packet_pool_info_get(NX_PACKET_POOL *pool_ptr, ULONG
    			*total_packets, ULONG *free_packets,
    			ULONG *empty_pool_requests,
    			ULONG *empty_pool_suspensions,
    			ULONG *invalid_packet_releases);
UINT     nx_packet_release(NX_PACKET *packet_ptr);
UINT     nx_packet_transmit_release(NX_PACKET *packet_ptr);

Reverse Address Resolution Protocol (RARP)

UINT     nx_rarp_disable(NX_IP *ip_ptr);
UINT     nx_rarp_enable(NX_IP *ip_ptr);
UINT     nx_rarp_info_get(NX_IP *ip_ptr,
				ULONG *rarp_requests_sent,
				ULONG *rarp_responses_received,
				ULONG *rarp_invalid_messages);

System Management

VOID     nx_system_initialize(VOID);

Transmission Control Protocol (TCP)

UINT     nx_tcp_client_socket_bind(NX_TCP_SOCKET *socket_ptr,
				UINT port, ULONG wait_option);
UINT     nx_tcp_client_socket_connect(NX_TCP_SOCKET
				*socket_ptr, ULONG server_ip, UINT server_port,
				ULONG wait_option);
UINT     nx_tcp_client_socket_port_get(NX_TCP_SOCKET
				*socket_ptr, UINT *port_ptr);
UINT     nx_tcp_client_socket_unbind(NX_TCP_SOCKET
				*socket_ptr);
UINT     nx_tcp_enable(NX_IP *ip_ptr);
UINT     nx_tcp_free_port_find(NX_IP *ip_ptr, UINT port,
				UINT *free_port_ptr);
UINT     nx_tcp_info_get(NX_IP *ip_ptr, ULONG *tcp_packets_sent,
				ULONG *tcp_bytes_sent, ULONG *tcp_packets_received,
				ULONG *tcp_bytes_received, ULONG
				*tcp_invalid_packets, ULONG
				*tcp_receive_packets_dropped,
				ULONG *tcp_checksum_errors,ULONG *tcp_connections,
				ULONG *tcp_disconnections,
				ULONG *tcp_connections_dropped,
				ULONG*tcp_retransmit_packets);
UINT     nx_tcp_server_socket_accept(NX_TCP_SOCKET *socket_ptr,
				ULONG wait_option);
UINT     nx_tcp_server_socket_listen(NX_IP *ip_ptr,
				UINT port, NX_TCP_SOCKET *socket_ptr,
				UINT listen_queue_size,
				VOID (*tcp_listen_callback)(NX_TCP_SOCKET
				*socket_ptr, UINT port));
UINT     nx_tcp_server_socket_relisten(NX_IP *ip_ptr,
				UINT port, NX_TCP_SOCKET *socket_ptr);
UINT     nx_tcp_server_socket_unaccept(NX_TCP_SOCKET
				*socket_ptr);
UINT     nx_tcp_server_socket_unlisten(NX_IP *ip_ptr, UINT
				port);
UINT     nx_tcp_socket_bytes_available(NX_TCP_SOCKET
				*socket_ptr, ULONG *bytes_available);
UINT     nx_tcp_socket_create(NX_IP *ip_ptr,
				NX_TCP_SOCKET *socket_ptr, CHAR *name,
				ULONG type_of_service, ULONG fragment,
				UINT time_to_live, ULONG window_size,
				VOID (*tcp_urgent_data_callback)(NX_TCP_SOCKET
				*socket_ptr),
				VOID (*tcp_disconnect_callback)(NX_TCP_SOCKET
				*socket_ptr));
UINT     nx_tcp_socket_delete(NX_TCP_SOCKET *socket_ptr);
UINT     nx_tcp_socket_disconnect(NX_TCP_SOCKET *socket_ptr,
				ULONG wait_option);
UINT     nx_tcp_socket_info_get(NX_TCP_SOCKET *socket_ptr,
				ULONG *tcp_packets_sent, ULONG *tcp_bytes_sent,
				ULONG *tcp_packets_received, ULONG
				*tcp_bytes_received,
				ULONG *tcp_retransmit_packets, ULONG
				*tcp_packets_queued,
				ULONG *tcp_checksum_errors, ULONG *tcp_socket_state,
				ULONG *tcp_transmit_queue_depth, ULONG
				*tcp_transmit_window,
				ULONG *tcp_receive_window);
UINT     nx_tcp_socket_mss_get(NX_TCP_SOCKET *socket_ptr,
				ULONG *mss);
UINT     nx_tcp_socket_mss_peer_get(NX_TCP_SOCKET *socket_ptr,
				ULONG *peer_mss);
UINT     nx_tcp_socket_mss_set(NX_TCP_SOCKET *socket_ptr,
				ULONG mss);
UINT     nx_tcp_socket_peer_info_get(NX_TCP_SOCKET *socket_ptr,
				ULONG *peer_ip_address, ULONG *peer_port);
UINT     nx_tcp_socket_receive(NX_TCP_SOCKET *socket_ptr,
				NX_PACKET **packet_ptr, ULONG wait_option);
UINT     nx_tcp_socket_receive_notify(NX_TCP_SOCKET
				*socket_ptr, VOID
				(*tcp_receive_notify)(NX_TCP_SOCKET *socket_ptr));
UINT     nx_tcp_socket_send(NX_TCP_SOCKET *socket_ptr,
				NX_PACKET *packet_ptr, ULONG wait_option);
UINT     nx_tcp_socket_state_wait(NX_TCP_SOCKET *socket_ptr,
				UINT desired_state, ULONG wait_option);
UINT     nx_tcp_socket_transmit_configure(NX_TCP_SOCKET
				*socket_ptr, ULONG max_queue_depth, ULONG timeout,
				ULONG max_retries, ULONG timeout_shift);
UINT     nx_tcp_socket_window_update_notify_set
				(NX_TCP_SOCKET *socket_ptr,
				VOID (*tcp_window_update_notify)
				(NX_TCP_SOCKET *socket_ptr));
UINT     nxd_tcp_client_socket_connect(NX_TCP_SOCKET
				*socket_ptr, NXD_ADDRESS *server_ip, UINT
				server_port, ULONG wait_option)
UINT     nxd_tcp_socket_peer_info_get(NX_TCP_SOCKET
				*socket_ptr, NXD_ADDRESS *peer_ip_address,
				ULONG *peer_port)

User Datagram Protocol (UDP)

UINT     nx_udp_enable(NX_IP *ip_ptr);
UINT     nx_udp_free_port_find(NX_IP *ip_ptr, UINT port,
				UINT *free_port_ptr);
UINT     nx_udp_info_get(NX_IP *ip_ptr, ULONG *udp_packets_sent,
				ULONG *udp_bytes_sent, ULONG *udp_packets_received,
				ULONG *udp_bytes_received,
				ULONG *udp_invalid_packets,
				ULONG *udp_receive_packets_dropped,
				ULONG *udp_checksum_errors);
UINT     nx_udp_packet_info_extract(NX_PACKET *packet_ptr,
				ULONG *ip_address, UINT *protocol, UINT *port,
				UINT *interface_index);
UINT     nx_udp_socket_bind(NX_UDP_SOCKET *socket_ptr,
				UINT port, ULONG wait_option);
UINT     nx_udp_socket_bytes_available(NX_UDP_SOCKET
				*socket_ptr, ULONG *bytes_available);
UINT     nx_udp_socket_checksum_disable(NX_UDP_SOCKET
				*socket_ptr);
UINT     nx_udp_socket_checksum_enable(NX_UDP_SOCKET
				*socket_ptr);
UINT     nx_udp_socket_create(NX_IP *ip_ptr, NX_UDP_SOCKET
				*socket_ptr, CHAR *name, ULONG type_of_service,
				ULONG fragment,
				UINT time_to_live, ULONG queue_maximum);
UINT     nx_udp_socket_delete(NX_UDP_SOCKET *socket_ptr);
UINT     nx_udp_socket_info_get(NX_UDP_SOCKET *socket_ptr,
				ULONG *udp_packets_sent, ULONG *udp_bytes_sent,
				ULONG *udp_packets_received, ULONG
				*udp_bytes_received,
				ULONG *udp_packets_queued,
				ULONG *udp_receive_packets_dropped,
				ULONG *udp_checksum_errors);
UINT     nx_udp_socket_interface_send(NX_UDP_SOCKET
				*socket_ptr, NX_PACKET *packet_ptr, ULONG
				ip_address, UINT port, UINT address_index);
UINT     nx_udp_socket_port_get(NX_UDP_SOCKET *socket_ptr,
				UINT *port_ptr);
UINT     nx_udp_socket_receive(NX_UDP_SOCKET *socket_ptr,
				NX_PACKET **packet_ptr, ULONG wait_option);
UINT     nx_udp_socket_receive_notify(NX_UDP_SOCKET
				*socket_ptr, VOID
				(*udp_receive_notify)(NX_UDP_SOCKET *socket_ptr));
UINT     nx_udp_socket_send(NX_UDP_SOCKET *socket_ptr,
				NX_PACKET *packet_ptr, ULONG ip_address, UINT port);
UINT     nx_udp_socket_unbind(NX_UDP_SOCKET *socket_ptr);
UINT     nx_udp_source_extract(NX_PACKET *packet_ptr,
				ULONG *ip_address, UINT *port);
UINT     nxd_udp_packet_info_extract(NX_PACKET *packet_ptr,
				NXD_ADDRESS *ip_address, UINT *protocol, UINT *port,
				UINT *interface_index);
UINT     nxd_udp_source_extract (NX_PACKET *packet_ptr,
				NXD_ADDRESS *ip_address, UINT *port)
UINT     nxd_udp_socket_interface_send(NX_UDP_SOCKET
				*socket_ptr, NX_PACKET *packet_ptr, NXD_ADDRESS
				*ip_address, UINT port, UINT address_index)
UINT     nxd_udp_socket_send(NX_UDP_SOCKET *socket_ptr,
				NX_PACKET *packet_ptr, NXD_ADDRESS *ip_address,
				UINT port)
Prev
Chapter 5 - NetX Duo Network Drivers
Next
Appendix B - NetX Duo Constants