https://github.com/dougkpowers/atmega-network/

  http://www.atmel.com/products/microcontrollers/avr/megaavr.aspx

You can control when you send data out on the network, but you have
no control over when data will arrive.  Therefore, in every 'loop()' 
of your program, you must check for incomming data and process it.
At the Ethernet level, a single transmission of data is called a 'frame.'
This is the smallest chunk of data that is sent or received.  On each
loop() of our program, we therefore must check for an incoming Ethernet 
Frame and process it.

There are different protocols that run over Ethernet and how we handle
the frame depends on the protocol.  For example, the ARP protocol is used
to find MAC addresses for a given IP address, and the ARP protocol
has its own frame type.  Likewise, the IP protocol is used to send data 
to a specific IP address (MAC address on Ethernet) and it also has its
own frame type.  We tell the Ethernet controller about our ability to
process certain types of frames by giving it the handler for each frame 
type.  For example:

    arp = new ARPHandler(myip,2,control);
    /\                    /\  /\   /\
    |                     |   |    |
    |                     |   |    The ethernet controller to register
    |                     |   |    ourself with
    |                     |   |
    |                     |   The size of the ARP routing table
    |                     |
    |                     |
    |                     Our IP so it can respond to requests for 
    |                     those looking for our MAC address
    |
    ----a pointer to our ARP Handler

Now, when a frame comes in, the controller will pass it to the ARPHandler
for processing.

Similary, we can create an IPHandler for handling of frames with IP packet
data: 

    ip = new IPHandler(myip,gwip,subnetmask,arp,control);
    /\                  /\  /\   /\         /\      /\
    |                   |   |    |          |       |  
    |                   |   |    |          |       |
    |                   |   |    |          |       The ethernet controller
    |                   |   |    |          |       to register ourself with
    |                   |   |    |          |
    |                   |   |    |          The arp handler to use when
    |                   |   |    |          we need to find the MAC address
    |                   |   |    |          for an IP
    |                   |   |    |
    |                   |   |    Subnet mask
    |                   |   |
    |                   |   Gateway IP
    |                   |   
    |                   Our IP Address
    |
    ----a pointer to our ARP Handler

The protocol stack is built up in this way, so that an incoming Ethernet
frame is handed to the appropriate 'Handler.'  In turn the IP Handler
will unwrap the IP frame into an IP packet and pass the packet to
a packet handler, which knows how to process packets for that protocol
(TCP vs UDP).

   udp = new UDPHandler(ip, 1);
    /\                  /\  /\  
    |                   |   |___the number of receivers waiting for 
    |                   |       Datagrams   
    |                   |   
    |                   |--- the IP handler to register ouself with
    |                   
    ---a pointer to our UDP handler

In the example above, we reference a 'receiver.'  A receiver, in this
case, is just another handler.  When a UDP Datagram arives, what will
the UDPHandler do with it?  It will pass it to a Receiver, such as
a DNS, which operates over UDP:

    dns = new DNSHandler(udp,dnsip,1);
    /\                    /\  /\   /\
    |                     |   |    |___cache capacity, how many hostnames
    |                     |   |        to IPs should we keep in memory?
    |                     |   |    
    |                     |   |---IP address of DNS server
    |                     |
    |                     UDPHandler to register ourself with
    |   
    --- a pointer to our DNS handler

We can now lookup IPs for hostnames and get a response:

    loop(){
        ...
        //see if we can resolve
        uint8_t error;
        uint8_t* remoteIP = dns->resolve(remoteDomain,&error);

        if (error == PENDING){ 
            //still waiting for a response
            //on each loop, keep calling dns->resolve(..) until we
            //get a resonse
        }
        else if (error == NO_ERROR && remoteIP != NULL){
            //we have the IP of the remote hostname
        }
    }   

 You may wonder, why are we calling resolve(..) in the loop?  On an
 Arduino, we do not have the benefit of threads and blocking calls.  
 The first time we call resolve(..) the DNSHandler simply sends out a 
 request.  On subsequent calls, it knows whether the response is pending
 and will not send out another request unless the original request times
 out.  Eventually, after a few iterations of the loop(), the resolve(..)
 function will return the IP of the remote host.

#include <ENC28J60Driver.h>     -- The driver for the ENC28J60 chipset
#include <EtherControl.h>       -- Manages the interface to the driver
#include <ARPHandler.h>         -- Manages ARP protocol
#include <IPHandler.h>          -- Manages the IP protocol
#include <UDPHandler.h>         -- Manages the UDP protocol

static byte myip[] = { 192,168,1,2 };
static byte gwip[] = { 192,168,1,1 };
static byte dnsip[] = {8,8,8,8};        //Google DNS
static byte dnsipbackup[] = {8,8,8,8};  //Google DNS

static byte subnet[] =     {192,168,1,0};
static byte subnetmask[] = {255,255,255,0};

//must be unique on your local network
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x01,0x01 };

ENC28J60Driver* driver;
EtherControl* control;
ARPHandler* arp;
IPHandler* ip;
UDPHandler* udp;

void setup() {

   //instiate your driver with your mac address
   driver = new ENC28J60Driver(mymac); 

   //tell the controller which driver you are using
   control = new EtherControl(driver);

   //create a handler for the ARP ethernet frames
   arp = new ARPHandler(myip,2,control);

   //create a handler for IP packets
   ip = new IPHandler(myip,gwip,subnetmask,arp,control);

   //create a handler for UDP based IP packets
   udp = new UDPHandler(ip,1);

   //request the mac address of your gateway
   arp->requestMACAddress(gwip);
}

void loop(){
  control->processFrame();
}

void loop(){
  control->processFrame();

  //if we have no route to the gateway, exit the loop
  if (arp->getMACAddress(gwip) == NULL){
    return;
  }
}

void loop(){
  control->processFrame();

  //if we have no route to the gateway, exit the loop
  if (arp->getMACAddress(gwip) == NULL){
    return;
  }

  //since we have the MAC address fo the gwip, let's send
  //some UDP packets out
  udp->sendDatagram(destinationIP, destinationPort, 
	        sourcePort, "I am here!");

}