Ethernet Lab

Background:

Parts of HDLC have been used in many different protocols. The bit stuffing features of HDLC have been used by Ethernet to provide a unique preamble and postamble for the Ethernet frame. This allows an Ethernet receiver to synchronize on a frame boundary and to receive valid data. For this lab you will write the HDLC code that will format an Ethernet frame

Specifications:

You should study the material on pages 87-88 and 116-121 in order to complete this lab successfully. The format for an Ethernet packet will consist of the following fields. Note that this is slightly different than the Ethernet packet described in the text.

Preamble	Dest Address	Src Address	Type	Body	CRC (ignored)	Postamble
8 bits	48 bits	48 bits	16 bits	1-56 bytes	32 bits	8 bits
01111110	Bit stuffing					01111110

When you create a ethernet header, the "Src Address" should be the address passed to you in the init(...)routine. The "dst address" is the addr parameter from your push(...) routine. The "Type" and "CRC" should be zero.

The Ethernet layer object will be very similar to the physical layer object you wrote in a prior lab. The ethernet layer object must support the following methods:

init ( char *name, protocol *higher, protocol *lower, char *addr, int port, int client);

push ( char *buf, int len, char *addr);

Take the data pointed to by buf
Prepend the Ethernet Header using the destination address specified by addr and the source address stored from the init(...) method.
Fill the Type field with zeros.
Fill the CRC field with zeros. You will compute this in a later lab.
Run HDLC on the whole combined Ethernet header and payload from buf, and attach the Preamble and Postamble. You will probably end up with a byte that is not fully filled when you go to send the packet. Fill the remaining bits with zeros. Don’t worry about this, you will account for it on the other end when you un-HDLC the packet.
Call the physical layer push(..) routine with the result of the previous step. You can pass a NULL for the address parameter since the physical layer does not need a destination address

pop ( char *buf, int len);

Start searching through the data in buf for a sentinal. You will not have to worry about ethernet packets spanning multiple physical layer packets, but you can expect to have multiple ethernet packets inside of one physical layer (90 byte) packet.

Once you have received a valid frame (a Preamble followed by data and then a Postamble) you should un-bitstuff the data between the Preamble and Postamble.
Now check the CRC, it should be zero. Discard the packet if the CRC is not zero.
Look at the destination address in the packet. If this address does not match your Ethernet address (set up in init(...)), discard the packet.
Now rip off the Ethernet header and pass the payload to the IP layer pop(...) routine.
You can figure out the length to pass to IP::pop(...) by subtracting the size of the Ethernet header from the number of bytes between Preamble and Postamble once you unstuff it.
At this point you should start looking for another sentinal since there might be other ethernet packets in buf.

HDLC

One way to implement the bit stuffing code is to use a shift register. This is one of the easiest ways to detect long strings of ones, since they may cross byte boundaries. For example 0x07,0xf0 should be changed to 0x07,0xd8 even though neither of the bytes has more than 5 ones in a row. If you shift bits into a variable and look for strings of ones, then you can detect all problem bit patterns. We would like you to use some creativity in designing the bit-stuffing algorithm. You should be able to do it with the information provided in the text and by looking at the HDLC generated by the TA code. In this lab, you will be passing off against lab code and can look at what it returns in order to help you in the debug cycle. This is a common mode for networking code development. You have to reverse engineer a protocol by examining the output of a working protocol module.

Passoff: <EXAMPLE OUTPUT>

We will provide you with the Ethernet framework in ~cs460ta/labs/ether_template to help you code and test your ethernet layer. Replace the physical.h and physical.cc files in the template with your own files from the physical layer lab.

The passoff procedure will test the following specific items

· The lab code will send non-zero CRC, discard this data.

· The lab code will send garbage data between the Postamble and Preamble, discard this data.

· Good packets will be sent.

Run your code as a client against the compiled version of the ta's code (~cs460ta/labs/ether) running as the server in order to pass off your program for the TA during his office hours. This lab code will do the same thing as the framework code, but may run some different tests.

The T.A. server will first receive all of the packets you send from main. When you hit the ENTER key on the server window, it will send you frames with bad crc, bad destination address and framing errors as well as packets with more than one ethernet frame in each 90 byte packet. If you see bad bit stuffing, you should throw away everything you have seen so far and then start looking for a sentinal that will begin the next frame. Don't look for a closing sentinal on a frame with bad bitstuffing. You may want to run additional tests of your own to make sure that things are working.

The following passoff levels will apply to this lab:

Passoff Level	Behavior	Points
Minimal Passoff	At least one Ethernet packet is sent and received with correct bitstuffing	2 Points
Discards Bad CRC	Must check CRC	2 Points
Framing	Garbage frames are discarded, you should start looking for a beginning sentinal after you throw away the frame	2 Points
Perfect behavior	Passes all tests	4 Points