ARP OVERVIEW:

In order for two hosts on an ethernet segment to communicate using the IP protocol, the logical IP address must be linked to the physical address of the network adapter card. ARP (Address Resolution Protocol) is the protocol that resolves IP addresses to physical addresses (i.e., it maps a MAC address to an IP address).

Note that ARP data packets do not have IP headers since the ARP protocol is at the same layer in the OSI model as the IP protocol.

Here is an example that shows how ARP works:

Suppose a packet is sent from 138.16.14.190/255.255.255.0 to 138.16.14.1/255.255.255.0. First, 138.16.14.190 verifies that 138.16.14.1 is in the same network. Since they are in the same network, the two systems are connected by ethernet. 138.16.14.190 then looks up 138.16.14.1 in its ARP cache (i.e., ARP table). If an entry exists for 138.16.14.1, an ethernet header is prepended to the packet and the ethernet packet is sent off.

However, if an entry for 138.16.14.1 is not in the ARP table, the corresponding ethernet address is not known and, therefore, there is no way for 138.16.14.190 to send the packet. So 138.16.14.190 sends out an ARP request packet in an attempt to determine this ethernet address. 138.16.14.1 will then see this ARP request packet and send an ARP reply packet indicating its ethernet address. After receiving the ARP reply packet, 138.16.14.190 will use this information and an ethernet header containing this ethernet address is prepended to the packet and the ethernet packet is sent off.

138.16.14.190 creates an entry for this ip address/ethernet address mapping in the ARP table so that it can send ethernet packets to 138.16.14.1 without sending out an ARP request packet first. (Other systems on the ethernet segment that receive this ARP reply will also add an entry to their ARP tables.) Note, however, that entries in the ARP table time out (in the Minix network service, the time out is 20 minutes) and 138.16.14.190 will eventually need to send another ARP request packet to determine 138.16.14.190 associated ethernet address.

arp46_t

The arp46_t struct is the structure of the arp-request and arp-reply packets. The information contained within the arp-reqests and arp-replies is used to build the arp table. The first three fields in the struct (a46_dstaddr, a46_srcaddr, and a46_ethtype) correspond to an ethernet header and the remaining fields are arp-specific.

"46" refers to the number of bytes in the packet - 16 for the ethernet header and 28 for the arp-specific fields.

typedef struct arp46

{

          ether_addr_t a46_dstaddr;

          ether_addr_t a46_srcaddr;

          ether_type_t a46_ethtype;

          union

          {

                   struct

                   {

                            u16_t a_hdr, a_pro;

                            u8_t a_hln, a_pln;

                            u16_t a_op;

                            ether_addr_t a_sha;

                            u8_t a_spa[4];

                            ether_addr_t a_tha;

                            u8_t a_tpa[4];

                   } a46_data;

                   char a46_dummy[ETH_MIN_PACK_SIZE-ETH_HDR_SIZE];

          } a46_data;

} arp46_t;

From RFC 2625:

                     +-------------------------+

                     | HW Type                 | 2 bytes

                     +-------------------------+

                     | Protocol                | 2 bytes

                     +-------------------------+

                     | HW Addr Length          | 1 byte

                     +-------------------------+

                     | Protocol Addr Length    | 1 byte

                     +-------------------------+

                     | Op Code                 | 2 bytes

                     +-------------------------+

                     | HW Addr of Sender       | 6 bytes

                     +-------------------------+

                     | Protocol Addr of Sender | 4 bytes

                     +-------------------------+

                     | HW Addr of Target       | 6 bytes

                     +-------------------------+

                     | Protocol Addr of Target | 4 bytes

                     +-------------------------+

                                          Total 28 bytes

                           ARP Packet Format







    +---------+-------------------------------------------------------+

    |Ethernet |For an ARP request, source MAC address is the MAC      |

    |Header   |address of the host sending the ARP request,           |

    |         |destination MAC address is the Ethernet broadcast      |

    |         |address (FF:FF:FF:FF:FF:FF), frame type field is 0x806.|

    |         |For ARP reply, source MAC address is the MAC address of|

    |         |the host replying to the ARP request, destination MAC  |

    |         |address is the MAC address of the host that sent the   |

    |         |ARP request, and the frame type field is 0x806.        |

    +---------+-------------------------------------------------------+

    |Hardware |Type of the hardware MAC address which is being mapped.|

    |Address  |For Ethernet the value of this field is 1.             |

    |Type     |                                                       |

    +---------+-------------------------------------------------------+

    |Protocol |Type of the protocol address to which the MAC address  |

    |Address  |is mapped.  For IP address the value of this field is  |

    |Type     |0x800.                                                 |

    +---------+-------------------------------------------------------+

    |Hardware |Size of the hardware MAC address.  For Ethernet, the   |

    |Address  |value of this field is 6.                              |

    |Size     |                                                       |

    +---------+-------------------------------------------------------+

    |Protocol |Size of the protocol address.  For IP, the value of    |

    |Address  |this field is 4.                                       |

    |Size     |                                                       |

    +---------+-------------------------------------------------------+

    |Operation|Type of operation being performed.  The value of this  |

    |         |field can be 1 (ARP request), 2 (ARP reply)            |

    +---------+-------------------------------------------------------+

    |Source   |The hardware MAC address of the host sending the ARP   |

    |MAC      |request or reply.  This is same as the source MAC      |

    |address  |address present in the Ethernet header.                |

    +---------+-------------------------------------------------------+

    |Source   |The IP address of the host sending the ARP request or  |

    |IP       |reply.                                                 |

    |address  |                                                       |

    +---------+-------------------------------------------------------+

    |Target   |The hardware MAC address of the host receiving the ARP |

    |MAC      |request or reply.  This is same as the destination MAC |

    |address  |address present in the Ethernet header.                |

    +---------+-------------------------------------------------------+

    |Target   |The IP address of the host receiving the ARP request   |

    |IP       |or reply.                                              |

    |address  |                                                       |

    +---------+-------------------------------------------------------+

arp_port

For each ip port that uses an ethernet port (as opposed to a psip port), there will be one arp port.

typedef struct arp_port

{

          int ap_flags;

          int ap_state;

          int ap_eth_port;

          int ap_ip_port;

          int ap_eth_fd;

          ether_addr_t ap_ethaddr;

          ipaddr_t ap_ipaddr;

          timer_t ap_timer;

 

          ether_addr_t ap_write_ethaddr;

          ipaddr_t ap_write_ipaddr;

          int ap_write_code;

 

          ipaddr_t ap_req_ipaddr;

          int ap_req_count;

 

          arp_func_t ap_arp_func;

} arp_port_t;

int ap_flags:

ap_flags can be one or more of the following:

#define APF_EMPTY 0
#define APF_ARP_RD_IP 0x4
#define APF_ARP_RD_SP 0x8
#define APF_ARP_WR_IP 0x10
#define APF_ARP_WR_SP 0x20
#define APF_INADDR_SET 0x100
#define APF_MORE2WRITE 0x200
#define APF_CLIENTREQ 0x400
#define APF_CLIENTWRITE 0x1000
#define APF_SUSPEND 0x2000

Most of the flags are used to either indicate the state of the arp port or the state of a current read or write and are therefore somewhat uninteresting. An exception is APF_CLIENTREQ; APF_CLIENTREQ is set if an arp-request packet has been sent out but a reply has not yet been received.

int ap_state:

#define APS_INITIAL 0x00
#define APS_GETADDR 0x01
#define APS_ARPSTART 0x10
#define APS_ARPPROTO 0x20
#define APS_ARPMAIN 0x40
#define APS_ERROR 0x80

APS_ARPMAIN is the arp port's normal operational state. All states except for APS_ERROR are initialization states.


int ap_eth_port, ap_ip_port:

ap_eth_port and ap_ip_port are the ip port and the ip port's associated ethernet port and are the ports that receive the arp broadcasts that detail the ip address to ethernet port mappings.


int ap_eth_fd:

The index of the arp port's associated ethernet file descriptor within eth_fd_table[].


ether_addr_t ap_ethaddr:

The ethernet address of the underlying ethernet port.


ipaddr_t ap_ipaddr:

The ip address of the associated ip port.


timer_t ap_timer:

When an arp-request is sent out, a timer is set (to which ap_timer points). If an arp-reply is not received for this arp-request within a half second, arp_timeout() is called. If fewer than four arp-requests have already been sent out, arp_timeout() simply calls setup_write() to send out another arp-request. If four arp-requests have already been sent out, the arp table entry is marked as unreachable and client_reply() is called to alert interested ip file descriptors.


ether_addr_t ap_write_ethaddr:
ipaddr_t ap_write_ipaddr:
int ap_write_code:

When an arp-reply or an arp-request packet is being created, the values of these 3 fields are used to get the target ethernet and ip addresses and the write code (either ARP_REQUEST or ARP_REPLY).


ipaddr_t ap_req_ipaddr:

If an entry for a destination ip address cannot be found in the arp table, this ip address is placed in the ap_req_ipaddr field. When the arp port is able to send out the arp request, the ap_req_ipaddr field is copied to the ap_write_ipaddr field.


int ap_req_count:

Four arp-requests are allowed to resolve the ip address held in the ap_req_ipaddr field.


arp_func_t ap_arp_func:

ap_arp_func is set to ipeth_arp_reply().

arp_cache_t

Each entry in an arp table is of type arp_cache_t:

typedef struct arp_cache

{

          int ac_flags;

          int ac_state;

          ether_addr_t ac_ethaddr;

          ipaddr_t ac_ipaddr;

          arp_port_t *ac_port;

          time_t ac_expire;

          time_t ac_lastuse;

} arp_cache_t;

int ac_flags:

ac_flags can be one of the following:

#define ACF_EMPTY 0
#define ACF_GOTREQ 1

When an arp-request is received, an entry in the arp table is created for the system that sent the arp-request (if an entry doesn't already exist) and, if the system was requesting the ethernet address that corresponds to the local system's ip address, the ACF_GOTREQ flag for the entry is set.


int ac_state:

The possible states for an arp table entry are:

#define ACS_UNUSED 0
#define ACS_INCOMPLETE 1
#define ACS_VALID 2
#define ACS_UNREACHABLE 3

ACS_INCOMPLETE indicates that the arp code has sent out an arp broadcast to determine the ethernet address that matches an ip address but a valid response has not yet been received. The other states are self-explanatory.


ether_addr_t ac_ethaddr: The ethernet address.


ipaddr_t ac_ipaddr: The ip address.


arp_port_t *ac_port: The arp port associated with the entry. If you have more than one ethernet port, there will be more than one arp port.


time_t ac_expire: The expiration time for the entry. If the system is found to be unreachable, the expiration time for the entry's unreachable status is 5 seconds.


time_t ac_lastuse: The time of the entry's last access. If the arp table is full and an entry is needed for a new ip address to ethernet mapping, the entry with the earliest ac_lastuse is claimed.

arp_prep()

arp_prep() simply allocates memory for the arp port table. The arp ports are later initialized by arp_init().

eth_conf_nr was set in read_conf().

For the following inet.conf file:

eth0 DP8390 0 { default; };
psip1;

eth_conf_nr will be 1 since there is only one ethernet interface. eth_port_table[] will therefore consist of a single element which corresponds to the single ethernet interface.

arp_init()

arp_init() sets the ap_state field of all the arp ports to APS_ERROR. Later, when the ip code acquires an arp port, the ap_state field of the acquired arp port is set to APS_INITIAL.

During the initialization of the ip code, ipeth_main() calls arp_set_cb() to acquire an arp port. arp_set_cb() sets the ap_state field of this acquired arp port to APS_INITIAL.

arp_main()

arp_main(arp_port) is called in two places during the initialization of the network service. The first time arp_main() is called is by arp_set_cb(), which is in the ip code. During this call, arp_main() opens an ethernet file descriptor for the arp port arp_port, arp_main()'s only parameter and retrieves the ethernet address of the ethernet file descriptor's underlying ethernet port, with which it sets the arp port's ap_ethaddr field.

arp_set_ipaddr() calls arp_main() the second time. During this call, the arp table (which is also referred to as the arp cache) is initialized and the ethernet file descriptor previously opened is configured with values appropriate for an ethernet file descriptor supporting an arp port. After configuring the file descriptor, setup_read() is called.

eth_open()

eth_open(port, srfd, get_userdata, put_userdata, put_pkt) finds an ethernet file descriptor that is free and associates the file descriptor with an ethernet port whose index within eth_port_table[] is port, eth_open()'s first parameter.

eth_open() is called by the ip code, the arp code and is called if an ethernet device file (e.g., /dev/eth) is opened directly.

Here are the relationships between various file descriptors and ports:

In this case, eth_ioctl() sets the ap_ethaddr field of the arp port to the ethernet address of the ethernet file descriptor's underlying ethernet port.


eth_ioctl()

The actions of eth_ioctl(fd, req) depend on req, eth_ioctl()'s second parameter:

NWIOSETHOPT (NetWork IO Set ETHernet OPTions):

If req is NWIOSETHOPT, eth_ioctl() configures the ethernet file descriptor fd (eth_ioctl()'s first parameter), which can then be used by a higher layer (e.g., ip, arp).

NWIOGETHSTAT (NetWork IO Get ETHernet STATs):

Only the arp code calls eth_ioctl() with the second parameter set to NWIOGETHSTAT. In this case, the ap_ethaddr field of the arp port is set to the ethernet address of the ethernet file descriptor's underlying ethernet port.

The first time that arp_main() is called, this conditional will be true and the function will return. When arp_main() is called the second time (by arp_set_ipaddr(), arp_set_ipaddr has just set the ap_ipaddr field of the arp port to the ip address of the associated ip port (i.e., APF_INADDR_SET is set). Therefore, the second time that arp_main() is called, this conditional will be false and the code will fall through.

Initialize the arp table.

The ethernet file descriptor's flags and types are set to the following:

nweo_flags= NWEO_COPY|NWEO_EN_BROAD|NWEO_TYPESPEC;
nweo_type= HTONS(ETH_ARP_PROTO);


eth_ioctl()

The actions of eth_ioctl(fd, req) depend on req, eth_ioctl()'s second parameter:

NWIOSETHOPT (NetWork IO Set ETHernet OPTions):

If req is NWIOSETHOPT, eth_ioctl() configures the ethernet file descriptor fd (eth_ioctl()'s first parameter), which can then be used by a higher layer (e.g., ip, arp).

NWIOGETHSTAT (NetWork IO Get ETHernet STATs):

Only the arp code calls eth_ioctl() with the second parameter set to NWIOGETHSTAT. In this case, the ap_ethaddr field of the arp port is set to the ethernet address of the ethernet file descriptor's underlying ethernet port.

setup_read() / arp

setup_read() is called in two places, by arp_main() during the initialization of the network service and by arp_putdata(). setup_read() calls eth_read() to deliver any ethernet packets that are waiting to be delivered to the arp port.

arp_getdata()

arp_getdata(fd, offset, count, for_ioctl) accomplishes several different tasks, depending on the state of the arp port:

APS_ARPPROTO (configuration state):

If count, arp_getdata()'s third parameter, is non-zero, arp_getdata() creates a nwio_eth_opt struct and sets the appropriate flags and type for an ethernet file descriptor that services an arp port:

nweo_flags= NWEO_COPY|NWEO_EN_BROAD|NWEO_TYPESPEC;
nweo_type= HTONS(ETH_ARP_PROTO);

and then returns an accessor that contains the struct.

ARS_ARPMAIN (operational state):

If count, arp_getdata()'s third parameter, is non-zero, arp_getdata() creates an arp packet (an arp46_t struct) and returns the struct. eth_write() calls arp_getdata() to create an arp-request or arp_reply packet (the packets that build the arp table. The ip and ethernet address of the arp-reply or request is gotten from the ap_write_ipaddr and ap_write_ethaddr fields, respectively, of the arp port.

Allocate an accessor big enough for a nwio_eth_opt struct, set the appropriate flags and type for an ethernet file descriptor that services an arp port:

nweo_flags= NWEO_COPY|NWEO_EN_BROAD|NWEO_TYPESPEC;
nweo_type= HTONS(ETH_ARP_PROTO);

and then return the accessor that contains the struct.

bf_memreq()

After the buffers have been initialized, accessors[] looks like the following:



bf_memreq() allocates accessors to the caller. For example, if 1514 bytes of buffer space are requested immediately after the network process starts and each buffer is 512 bytes (the default), then accessors[] will look like the following:



Note that three elements of accessors[] have been removed from buf512_freelist and that the head of the chain of the 3 accessors is returned by bf_memreq(). Also note that the acc_linkC and buf_linkC fields have been set to one and acc_length and acc_offset have been set to their appropriate values.

So what happens if there are not enough buffers on the buf512_freelist to satisfy a request? On lines 2280-2290 of buf.c, functions that free buffers for the specific clients (e.g., eth_buffree()) are called until there are enough buffers on buf512_freelist.

For a complete description of the network service's buffer management, click here.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

If arp_getdata() is called from eth_write(), an arp-request or arp-reply packet (an arp46_t struct) is created to be sent out by eth_send().

In order to follow the code below, it is important to understand the arp46_t struct.



REMOVE LATER (I think this diagram is a little confusing since eth_write() calls both arp_getdata() and eth_send():

(  prepare data   )   +--------------+

(  for eth_send() )   | setup_write()|

      |               +--------------+

      |           OR  |  

      +---------------+

      | arp_getdata() |   

      +---------------+

              ||

       +-------------+

       | eth_write() |

       +-------------+

arp46_t

The arp46_t struct is the structure of the arp-request and arp-reply packets. The information contained within the arp-reqests and arp-replies is used to build the arp table. The first three fields in the struct (a46_dstaddr, a46_srcaddr, and a46_ethtype) correspond to an ethernet header and the remaining fields are arp-specific.

"46" refers to the number of bytes in the packet - 16 for the ethernet header and 28 for the arp-specific fields.

typedef struct arp46

{

          ether_addr_t a46_dstaddr;

          ether_addr_t a46_srcaddr;

          ether_type_t a46_ethtype;

          union

          {

                   struct

                   {

                            u16_t a_hdr, a_pro;

                            u8_t a_hln, a_pln;

                            u16_t a_op;

                            ether_addr_t a_sha;

                            u8_t a_spa[4];

                            ether_addr_t a_tha;

                            u8_t a_tpa[4];

                   } a46_data;

                   char a46_dummy[ETH_MIN_PACK_SIZE-ETH_HDR_SIZE];

          } a46_data;

} arp46_t;

From RFC 2625:

                     +-------------------------+

                     | HW Type                 | 2 bytes

                     +-------------------------+

                     | Protocol                | 2 bytes

                     +-------------------------+

                     | HW Addr Length          | 1 byte

                     +-------------------------+

                     | Protocol Addr Length    | 1 byte

                     +-------------------------+

                     | Op Code                 | 2 bytes

                     +-------------------------+

                     | HW Addr of Sender       | 6 bytes

                     +-------------------------+

                     | Protocol Addr of Sender | 4 bytes

                     +-------------------------+

                     | HW Addr of Target       | 6 bytes

                     +-------------------------+

                     | Protocol Addr of Target | 4 bytes

                     +-------------------------+

                                          Total 28 bytes

                           ARP Packet Format







    +---------+-------------------------------------------------------+

    |Ethernet |For an ARP request, source MAC address is the MAC      |

    |Header   |address of the host sending the ARP request,           |

    |         |destination MAC address is the Ethernet broadcast      |

    |         |address (FF:FF:FF:FF:FF:FF), frame type field is 0x806.|

    |         |For ARP reply, source MAC address is the MAC address of|

    |         |the host replying to the ARP request, destination MAC  |

    |         |address is the MAC address of the host that sent the   |

    |         |ARP request, and the frame type field is 0x806.        |

    +---------+-------------------------------------------------------+

    |Hardware |Type of the hardware MAC address which is being mapped.|

    |Address  |For Ethernet the value of this field is 1.             |

    |Type     |                                                       |

    +---------+-------------------------------------------------------+

    |Protocol |Type of the protocol address to which the MAC address  |

    |Address  |is mapped.  For IP address the value of this field is  |

    |Type     |0x800.                                                 |

    +---------+-------------------------------------------------------+

    |Hardware |Size of the hardware MAC address.  For Ethernet, the   |

    |Address  |value of this field is 6.                              |

    |Size     |                                                       |

    +---------+-------------------------------------------------------+

    |Protocol |Size of the protocol address.  For IP, the value of    |

    |Address  |this field is 4.                                       |

    |Size     |                                                       |

    +---------+-------------------------------------------------------+

    |Operation|Type of operation being performed.  The value of this  |

    |         |field can be 1 (ARP request), 2 (ARP reply)            |

    +---------+-------------------------------------------------------+

    |Source   |The hardware MAC address of the host sending the ARP   |

    |MAC      |request or reply.  This is same as the source MAC      |

    |address  |address present in the Ethernet header.                |

    +---------+-------------------------------------------------------+

    |Source   |The IP address of the host sending the ARP request or  |

    |IP       |reply.                                                 |

    |address  |                                                       |

    +---------+-------------------------------------------------------+

    |Target   |The hardware MAC address of the host receiving the ARP |

    |MAC      |request or reply.  This is same as the destination MAC |

    |address  |address present in the Ethernet header.                |

    +---------+-------------------------------------------------------+

    |Target   |The IP address of the host receiving the ARP request   |

    |IP       |or reply.                                              |

    |address  |                                                       |

    +---------+-------------------------------------------------------+

bf_memreq()

After the buffers have been initialized, accessors[] looks like the following:



bf_memreq() allocates accessors to the caller. For example, if 1514 bytes of buffer space are requested immediately after the network process starts and each buffer is 512 bytes (the default), then accessors[] will look like the following:



Note that three elements of accessors[] have been removed from buf512_freelist and that the head of the chain of the 3 accessors is returned by bf_memreq(). Also note that the acc_linkC and buf_linkC fields have been set to one and acc_length and acc_offset have been set to their appropriate values.

So what happens if there are not enough buffers on the buf512_freelist to satisfy a request? On lines 2280-2290 of buf.c, functions that free buffers for the specific clients (e.g., eth_buffree()) are called until there are enough buffers on buf512_freelist.

For a complete description of the network service's buffer management, click here.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

Both offset and count are parameters of arp_getdata().

arp_getdata() sends out both arp-reply and arp-request packets. If the packet is an arp-reply, a system has already sent out an arp-request and arp_getdata() sends out a response packet to that specific machine. If the packet is an arp-request, arp_getdata() sends out a broadcast packet.

0xffffffffffff is the ethernet broadcast address.

The four fields below for both arp-request and arp-reply packets always have the same values. (The size of an ethernet address is 6 bytes and the size of an ip address is 4 bytes.)

The operation will either be ARP_REQUEST or ARP_REPLY.

a46_sha (Source Hardware Address) and a46_spa (Source Protocol Address) take the values of the arp port. setup_write() sets ap_write_ethaddr and ap_write_ethaddr before calling eth_write(). (Note that "tha" and "tpa" stand for "Target Hardware Address" and "Target Protocol Address", respectively.)

arp_putdata()

During the initialization of the network service, arp_main() calls eth_ioctl(). eth_ioctl(), in turn, (indirectly) calls arp_putdata() to get the underlying ethernet port's ethernet address.

After the initialization of the network service is complete, arp_putdata() is (indirectly) called by the ethernet code's packet2user() to deliver an arp-request or arp-reply packet to its destination arp port. arp_putdata() is also called by the ethernet code's reply_thr_put(), in which case arp_putdata() will call setup_read() to deliver any arp packets waiting to be delivered to the arp port.

After the initialization of the network service is complete, arp_putdata() is (indirectly) called by the ethernet code's packet2user() (with a non-null value for data) to deliver an arp-request or arp-reply packet to its destination arp port. This packet will then be processed by process_arp_req(). arp_putdata() is also called by the ethernet code's reply_thr_put() (with a null value for data), in which case arp_putdata() will call setup_read() to deliver any arp packets waiting to be delivered to the arp port.

If the code arrives here after an arp packet has been processed by an earlier call to arp_putdata(), the APF_ARP_RD_SP flag will not be set. However, if the ethernet code's reply_thr_put() is called in response to an error, it is possible that the APF_ARP_RD_SP flag has been set. In that case, call setup_read() to deliver any arp packets waiting to be delivered to the arp port.

setup_read() / arp

setup_read() is called in two places, by arp_main() during the initialization of the network service and by arp_putdata(). setup_read() calls eth_read() to deliver any ethernet packets that are waiting to be delivered to the arp port.

The read operation is complete so clear the read and suspend flags.

bf_packIffLess()

If the data in a linked list of accessors is less than min_len (the second parameter), bf_packIffLess(pack, min_len) packs the data by calling bf_pack().

bf_packIffLess() is often called to ensure that a packet's header is in a single contiguous buffer so that the individual fields of the header can be easily accessed.

For a detailed description of the network service's buffer management, click here.

process_arp_req()

The name process_arp_req() is a misnomer since the function not only processes arp-requests but also processes arp-replies. process_arp_req() is called by arp_putdata(), which is (indirectly) called by packet2user() upon receipt of either an arp-request or an arp-reply. If an entry in the arp table for the source ip address of the arp-request or arp-reply doesn't exist, the arp-request or arp-reply is discarded. Otherwise, the entry is updated with the ethernet address contained in the arp-request/arp-reply. If the updated entry was previously incomplete (in other words, the system was waiting for an arp-reply from an earlier arp-request), client_reply() is called to send out ethernet packets that were waiting for arp resolution. If an arp-request was received for the system's ip address, setup_write() is called to send out an arp-reply answering the arp-request.

During the initialization of the network service (when the state of an arp port is APS_GETADDR), arp_main() calls eth_ioctl(). eth_ioctl(), in turn, (indirectly) calls arp_putdata() to get the underlying ethernet port's ethernet address.

If the initialization of the network service and the arp port was not successfully finished, the code will arrive here.

arp_main()

arp_main(arp_port) is called in two places during the initialization of the network service. The first time arp_main() is called is by arp_set_cb(), which is in the ip code. During this call, arp_main() opens an ethernet file descriptor for the arp port arp_port, arp_main()'s only parameter and retrieves the ethernet address of the ethernet file descriptor's underlying ethernet port, with which it sets the arp port's ap_ethaddr field.

arp_set_ipaddr() calls arp_main() the second time. During this call, the arp table (which is also referred to as the arp cache) is initialized and the ethernet file descriptor previously opened is configured with values appropriate for an ethernet file descriptor supporting an arp port. After configuring the file descriptor, setup_read() is called.

compare()

compare is #define'd in inet/generic/assert.h:

#define compare(a,t,b) (!((a) t (b)) ? bad_compare(this_file, __LINE__, \
(a), #a " " #t " " #b, (b)) : (void) 0)

and bad_compare() is defined in inet/inet.c.

If the relationship between the 3 arguments in compare() does not hold, some debugging output is emitted and then Minix is terminated.

For example, if compare(result, >=, 0) is called and result (the first argument) is -1, Minix will be terminated.

bf_packIffLess()

If the data in a linked list of accessors is less than min_len (the second parameter), bf_packIffLess(pack, min_len) packs the data by calling bf_pack().

bf_packIffLess() is often called to ensure that a packet's header is in a single contiguous buffer so that the individual fields of the header can be easily accessed.

For a detailed description of the network service's buffer management, click here.

compare()

compare is #define'd in inet/generic/assert.h:

#define compare(a,t,b) (!((a) t (b)) ? bad_compare(this_file, __LINE__, \
(a), #a " " #t " " #b, (b)) : (void) 0)

and bad_compare() is defined in inet/inet.c.

If the relationship between the 3 arguments in compare() does not hold, some debugging output is emitted and then Minix is terminated.

For example, if compare(result, >=, 0) is called and result (the first argument) is -1, Minix will be terminated.

The nwio_ethstat struct is described here.


ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

setup_read() / arp

setup_read() is called in two places, by arp_main() during the initialization of the network service and by arp_putdata(). setup_read() calls eth_read() to deliver any ethernet packets that are waiting to be delivered to the arp port.

eth_read() calls packet2user(), which (indirectly) calls arp_putdata() twice. The first time that arp_putdata() is called, it attempts to deliver the packet to the arp port; if arp_putdata() can deliver the packet, arp_putdata() clears the APF_ARP_RD_IP flag the second time it is called.

eth_read()

eth_read() attempts to deliver all of the ethernet packets in an ethernet file descriptor's read queue to its associated ip port or arp port or sr file descriptor and returns NW_SUSPEND when there are no more ethernet packets to deliver.

eth_read() returns NW_SUSPEND after delivering all of the ethernet file descriptor's ethernet packets.

setup_write()

setup_write() initiates the sending of an arp-request or an arp-reply. Specifically, several fields of the arp port (e.g., ap_write_ipaddr - the ip address whose ethernet address is being sought) are set before calling eth_write() to send out the arp-request or arp-reply.

An arp-request will be sent out in an attempt to determine the ethernet address for a given ip address. APF_CLIENTWRITE is set by arp_ip_eth() before setup_write() is called.

Set a timer for the arp-request for a half second. If the arp-request times out, arp_timeout() is called.

ARP_TIMEOUT is #define'd on line 20023:

#define ARP_TIMEOUT (HZ/2+1) /* .5 seconds */


arp_timeout()

When an arp-request is sent out, a timer is set. If an arp-reply is not received for this arp-request within a half second, arp_timeout() is called. If fewer than four arp-requests have already been sent out, arp_timeout() simply calls setup_write() to send out another arp-request. If four arp-requests have already been sent out, the arp table entry is marked as unreachable and client_reply() is called to alert interested ip file descriptors.


clck_timer()

clck_timer(timer, timeout, func, fd) configures timer, clck_timer()'s first parameter, based on timeout, func, and fd (clck_timer()'s second, third, and fourth parameters) and places the timer in its appropriate position in timer_chain. In other words, if the new timer is scheduled to expire before any other timer, it is inserted at the head of the linked list and if the new timer is scheduled to expire after all the other timers, it is inserted at the tail of the linked list. If the new timer is scheduled to expire before any other timers, clck_timer() calls set_timer(), which sends a message to the clock task with a revised expiration time for the synchronous alarm.

An example of a client calling clck_timer() to insert a timer in timer_chain is the arp client.


get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

An arp-reply will be sent out in response to an arp-request that was previously received.

When an arp-request is received, an entry in the arp table is created for the system that sent the arp-request (if an entry doesn't already exist) and the ACF_GOTREQ flag for the entry is set. The code below searches through the arp table for the entry and sets the ap_write_ethaddr and ap_write_ipaddr to the system that sent the arp-request and sets ap_write_code to ARP_REPLY. These fields are later used by eth_write() to construct the arp-reply.

A matching entry wasn't found.

eth_write()

If a few tests (e.g., a test to determine if the ethernet packet is either too large or too small) have positive results and the ethernet task is not attempting to send an ethernet packet (i.e., etp_wr_pack is null) and the packet is coming from the ip code, eth_write(fd, count) passes the ethernet packet stored in the dl_eth.de_frame field of the ip port associated with the ethernet file descriptor fd, eth_write()'s first parameter, to eth_send().

If the packet is coming from the arp code (i.e., an arp-request or an arp-reply is being sent out), eth_write() calls arp_getdata() to create the ethernet packet before passing the newly created packet off to eth_send().

If the ethernet task is attempting to send an ethernet packet, eth_write() sets the ethernet port's EPF_MORE2WRITE flag and returns NW_SUSPEND.

process_arp_req()

The name process_arp_req() is a misnomer since the function not only processes arp-requests but also processes arp-replies. process_arp_req() is called by arp_putdata(), which is (indirectly) called by packet2user() upon receipt of either an arp-request or an arp-reply. If an entry in the arp table for the source ip address of the arp-request or arp-reply doesn't exist, the arp-request or arp-reply is discarded. Otherwise, the entry is updated with the ethernet address contained in the arp-request/arp-reply. If the updated entry was previously incomplete (in other words, the system was waiting for an arp-reply from an earlier arp-request), client_reply() is called to send out ethernet packets that were waiting for arp resolution. If an arp-request was received for the system's ip address, setup_write() is called to send out an arp-reply answering the arp-request.

get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

Copy the source and target protocol (i.e., ip) addresses found in the incoming arp-request to the spa and tpa variables.

The following four fields are the same for every arp-request and arp-reply packet. 6 bytes is the length of an ethernet address and 4 bytes is the length of an ip address.

find_cache_ent()

find_cache_ent(arp_port, ipaddr) looks in the arp table for an ip address, returning a reference to the corresponding arp table entry (of type arp_cache_t) if it finds the ip address and NULL if it does not find the ip address.

Note that find_cache_ent() will return the entry even if the entry has expired or is incomplete.

If find_cache_ent() returned an expired entry, nullify the entry (i.e., set the entry's state to ACS_UNUSED).

curr_time was set on line 20505.

If an entry for the source wasn't found or the entry had expired, initialize a new entry that corresponds to the source of the arp-request packet.

Ignore all arp-request packets except those packets that are looking for the ethernet address that corresponds to the ip address of the local machine.

It does seem curious that the system wouldn't go ahead and fill out a cache entry anyway since the information in the arp-request packet is valid nonetheless.

alloc_cache_ent()

alloc_cache_ent() finds an unused entry within the arp table and returns the entry's index within the table. If there are no unused entries within the arp table, the entry that was last used is returned instead.

The entry expires after 20 minutes.

On line 20024:

#define ARP_EXP_TIME (20L*60L*HZ) /* 20 minutes */

Regardless what the author's comment above indicates, ac_lastuse is used (see lines 20627-20628). If there are no unused arp table entries in the arp table and a new entry must be made, the entry whose ac_lastuse field is the oldest is selected by alloc_cache_ent().

Since the cache entry is not really being used here (it is simply being set), a 1 minute handicap is placed on the entry. Therefore, if an entry was accessed and then an entry was added in this code location shortly thereafter and a new entry is later needed, the latter will be chosen for removal before the former.

ARP_INUSE_OFFSET is #define'd on line 20028 as 1 minute:

#define ARP_INUSE_OFFSET (60*HZ)

The state of an entry in the arp table is ACS_INCOMPLETE if an arp-request for the system's ip address has been sent out but a response from the system has not been received. In this case, we've gotten lucky - we have received an unrelated arp-request from the system itself.

If the state of an entry is ACS_UNREACHABLE, the system was unreachable. By receiving an arp-request from this system, it appears that this is no longer the case.

Since we know the entry is now valid, mark it as such (i.e., set the state of the entry to ACS_VALID). If the entry was incomplete, call client_reply().

client_reply()

client_reply() is called either upon arp resolution (generally through an arp-reply) or upon the timeout of an arp-request. client_reply() simply unsets the timer associated with the arp-request and calls ipeth_arp_reply() so that ethernet packets that were waiting in the queue waiting for arp resolution can either be sent (if the arp-request got an answer) or discarded (if the arp-request timed out).

Place the ethernet address of the sender in the appropriate entry in the arp table and log some arp infomation (writeIpAddr() and writeEtherAddr() log information).

The entry in the arp table expires after 20 minutes (ARP_EXP_TIME = 20 minutes).

If the arp-request was for the ip address of the arp port's associated ip port, prepare to send an arp-reply in response.


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

The ACF_GOTREQ flag indicates that the system that corresponds to the entry in the arp table is waiting for an arp-reply from the local system.

setup_write()

setup_write() initiates the sending of an arp-request or an arp-reply. Specifically, several fields of the arp port (e.g., ap_write_ipaddr - the ip address whose ethernet address is being sought) are set before calling eth_write() to send out the arp-request or arp-reply.

client_reply()

client_reply() is called either upon arp resolution (generally through an arp-reply) or upon the timeout of an arp-request. client_reply() simply unsets the timer associated with the arp-request and calls ipeth_arp_reply() so that ethernet packets that were waiting in the queue waiting for arp resolution can either be sent (if the arp-request got an answer) or discarded (if the arp-request timed out).

Determine if an arp-request has been sent out for this ip address. If so, since either the arp-request has timed out or another arp-request has been received that contains the information requested, the timer for the arp-request can be turned off and the appropriate flags can be cleared.

clck_untimer()

clck_untimer(timer) releases timer, clck_untimer()'s only parameter. If necessary, clck_untimer() sends a message to the clock task requesting a synchronous alarm with a revised expiration time (actually, clck_untimer() calls set_timer(), which would send the message). Remember that the synchronous alarm task is aware of only a single alarm at any given time.

ipeth_arp_reply()

ipeth_arp_reply() is called (indirectly) by client_reply() under one of the following circumstances:

1) An arp-reply packet has been received in response to a previous arp-request packet that this system sent out.

2) An arp-request packet has timed out. In this case, eth_addr, ipeth_arp_reply()'s third parameter, will be NULL.

3) An arp-request packet has been received that contains the information requested by a previous arp-request packet that this system sent out.

ipeth_arp_reply() searches the queue of ethernet packets waiting for arp resolution for the ip address of the arp-request/arp-reply. If the arp resolution timed out, the packet is discarded. If the arp resolution was successful, the ethernet packet is moved to the queue of packets waiting to be sent out and ipeth_restart_send() is called to send out the packets.

find_cache_ent()

find_cache_ent(arp_port, ipaddr) looks in the arp table for an ip address, returning a reference to the corresponding arp table entry (of type arp_cache_t) if it finds the ip address and NULL if it does not find the ip address.

Note that find_cache_ent() will return the entry even if the entry has expired or is incomplete.

Look through the arp table for an entry that is in use (i.e., ac_state is not ACS_UNUSED) and whose ip address is ipaddr, the second parameter to find_cache_ent().

alloc_cache_ent()

alloc_cache_ent() finds an unused entry within the arp table and returns the entry's index within the table. If there are no unused entries within the arp table, the entry that was last used is returned instead.

ACS_INCOMPLETE indicates that the arp code has sent out an arp broadcast to determine the ethernet address that matches an ip address but a valid response has not yet been received.

If there are no unused entries within the arp table, the entry that was last used is returned instead.

arp_set_ipaddr()

arp_set_ipaddr(eth_port, ipaddr) is called only from ipeth_set_ipaddr(), which is (indirectly) called by ip_ioctl().

arp_set_ipaddr() simply sets the ap_ipaddr field of an arp port whose index within the arp_port_table[] is eth_port, arp_set_ipaddr()'s first parameter, to the ip address ipaddr, arp_set_ipaddr()'s second parameter.

Verify that the ethernet port number (and therefore the corresponding arp port number) exists.

Find the arp port whose index within arp_port_table[] is eth_port, the corresponding ethernet port.

arp_main()

arp_main(arp_port) is called in two places during the initialization of the network service. The first time arp_main() is called is by arp_set_cb(), which is in the ip code. During this call, arp_main() opens an ethernet file descriptor for the arp port arp_port, arp_main()'s only parameter and retrieves the ethernet address of the ethernet file descriptor's underlying ethernet port, with which it sets the arp port's ap_ethaddr field.

arp_set_ipaddr() calls arp_main() the second time. During this call, the arp table (which is also referred to as the arp cache) is initialized and the ethernet file descriptor previously opened is configured with values appropriate for an ethernet file descriptor supporting an arp port. After configuring the file descriptor, setup_read() is called.

arp_set_cb()

During the initialization of the network service (and, more specifically, the initialization of the ip layer), arp_set_cb(eth_port, ip_port, arp_func) is called to initialize the arp port associated with the ethernet port eth_port, arp_set_cb()'s first parameter. After initializing the arp port, arp_set_cb() calls arp_main().

It is unclear what the "cb" in the function name stands for.

arp_func is set to ipeth_arp_reply() by ipeth_main().

arp_ip_eth()

arp_ip_eth(eth_port, ipaddr, ethaddr) looks for an entry in the arp table that matches ipaddr, the second parameter, and if it finds it, returns the corresponding ethernet address in ethaddr, the third parameter. If arp_ip_eth() does not find a valid entry in the arp table for the ip address, it sends out an arp broadcast in an attempt to find the ethernet address for the ip address and returns NW_SUSPEND.

get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

find_cache_ent()

find_cache_ent(arp_port, ipaddr) looks in the arp table for an ip address, returning a reference to the corresponding arp table entry (of type arp_cache_t) if it finds the ip address and NULL if it does not find the ip address.

Note that find_cache_ent() will return the entry even if the entry has expired or is incomplete.

Mark the entry as unused (i.e., ac_state = ACS_UNUSED) if the entry has expired.

The arp table entry is valid. Return a reference to this ethernet address to the user.

A valid arp table entry was not found.

Send out an arp broadcast to determine the ethernet address of the system with ip address ipaddr (the second parameter to arp_ip_eth()).

ARP_EXP_TIME is #define'd on line 20025 as 20 minutes, the default expiration time of the arp table entry.

arp_timeout()

When an arp-request is sent out, a timer is set. If an arp-reply is not received for this arp-request within a half second, arp_timeout() is called. If fewer than four arp-requests have already been sent out, arp_timeout() simply calls setup_write() to send out another arp-request. If four arp-requests have already been sent out, the arp table entry is marked as unreachable and client_reply() is called to alert interested ip file descriptors.

Find the arp port whose index within arp_port_table is fd, arp_timeout()'s first parameter.

Four attempts can be made to determine the ethernet address that corresponds to an ip address.

MAX_ARP_RETRIES is #define'd on line 20022:

#define MAX_ARP_RETRIES 5

setup_write()

setup_write() initiates the sending of an arp-request or an arp-reply. Specifically, several fields of the arp port (e.g., ap_write_ipaddr - the ip address whose ethernet address is being sought) are set before calling eth_write() to send out the arp-request or arp-reply.

find_cache_ent()

find_cache_ent(arp_port, ipaddr) looks in the arp table for an ip address, returning a reference to the corresponding arp table entry (of type arp_cache_t) if it finds the ip address and NULL if it does not find the ip address.

Note that find_cache_ent() will return the entry even if the entry has expired or is incomplete.

Mark the cache entry as unreachable.

get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

Set the expiration time for this cache entry to 5 sec in the future.

ARP_NOTRCH_EXP_TIME is #define'd on line 20027:

#define ARP_NOTRCH_EXP_TIME (5*HZ) /* 5 seconds */

client_reply()

client_reply() is called either upon arp resolution (generally through an arp-reply) or upon the timeout of an arp-request. client_reply() simply unsets the timer associated with the arp-request and calls ipeth_arp_reply() so that ethernet packets that were waiting in the queue waiting for arp resolution can either be sent (if the arp-request got an answer) or discarded (if the arp-request timed out).