pktif.c

来自「Keil下移植好的lwip基于c166」· C语言 代码 · 共 525 行 · 第 1/2 页

  unsigned char buffer[1600];
	unsigned char *ptr;
	LPPACKET lpPacket;

  /* initiate transfer(); */
  if (p->tot_len>=1600)
 		return ERR_BUF;
	if((lpPacket = PacketAllocatePacket())==NULL)
 		return ERR_BUF;
	PacketInitPacket(lpPacket,buffer,p->tot_len);
	ptr=buffer;
  for(q = p; q != NULL; q = q->next) {
    /* Send the data from the pbuf to the interface, one pbuf at a
       time. The size of the data in each pbuf is kept in the ->len
       variable. */
    /* send data from(q->payload, q->len); */
#ifdef NETIF_DEBUG
		DEBUGF(NETIF_DEBUG, ("netif: send ptr %p q->payload %p q->len %i q->next %p\n", ptr, q->payload, (int)q->len, q->next));
#endif
		memcpy(ptr,q->payload,q->len);
		ptr+=q->len;
  }

  /* signal that packet should be sent(); */
	
	if (!PacketSendPacket(lpAdapter,lpPacket,TRUE))
		return ERR_BUF;
	PacketFreePacket(lpPacket);

#ifdef LINK_STATS
  lwip_stats.link.xmit++;
#endif /* LINK_STATS */      
  return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
/*
 * low_level_input():
 *
 * Should allocate a pbuf and transfer the bytes of the incoming
 * packet from the interface into the pbuf.
 *
 */
/*-----------------------------------------------------------------------------------*/
static struct pbuf *
low_level_input(struct netif *ethernetif)
{
  struct pbuf *p, *q;
  int start, length;

  /* Obtain the size of the packet and put it into the "len"
     variable. */
  length = cur_length;
	if (length<=0)
		return NULL;

  /* We allocate a pbuf chain of pbufs from the pool. */
  p = pbuf_alloc(PBUF_LINK, (u16_t)length, PBUF_POOL);
#ifdef NETIF_DEBUG
	DEBUGF(NETIF_DEBUG, ("netif: recv length %i p->tot_len %i\n", length, (int)p->tot_len));
#endif
	
  if(p != NULL) {
    /* We iterate over the pbuf chain until we have read the entire
       packet into the pbuf. */
		start=0;
    for(q = p; q != NULL; q = q->next) {
      /* Read enough bytes to fill this pbuf in the chain. The
         avaliable data in the pbuf is given by the q->len
         variable. */
      /* read data into(q->payload, q->len); */
#ifdef NETIF_DEBUG
			DEBUGF(NETIF_DEBUG, ("netif: recv start %i length %i q->payload %p q->len %i q->next %p\n", start, length, q->payload, (int)q->len, q->next));
#endif
      memcpy(q->payload,&cur_packet[start],q->len);
			start+=q->len;
			length-=q->len;
			if (length<=0)
				break;
    }
    /* acknowledge that packet has been read(); */
    cur_length=0;
#ifdef LINK_STATS
    lwip_stats.link.recv++;
#endif /* LINK_STATS */      
  } else {
    /* drop packet(); */
    cur_length=0;
#ifdef LINK_STATS
    lwip_stats.link.memerr++;
    lwip_stats.link.drop++;
#endif /* LINK_STATS */      
  }

  return p;  
}
/*-----------------------------------------------------------------------------------*/
/*
 * ethernetif_output():
 *
 * This function is called by the TCP/IP stack when an IP packet
 * should be sent. It calls the function called low_level_output() to
 * do the actuall transmission of the packet.
 *
 */
/*-----------------------------------------------------------------------------------*/
static err_t
ethernetif_output(struct netif *netif, struct pbuf *p,
		  struct ip_addr *ipaddr)
{
  p = etharp_output(netif, ipaddr, p);
  if(p != NULL) {
    return low_level_output(netif, p);
  }
  return ERR_OK;
}
/*-----------------------------------------------------------------------------------*/
/*
 * ethernetif_input():
 *
 * This function should be called when a packet is ready to be read
 * from the interface. It uses the function low_level_input() that
 * should handle the actual reception of bytes from the network
 * interface.
 *
 */
/*-----------------------------------------------------------------------------------*/
static void
ethernetif_input(struct netif *netif)
{
  struct ethernetif *ethernetif;
  struct eth_hdr *ethhdr;
  struct pbuf *p;


  ethernetif = netif->state;
  
  p = low_level_input(netif);

  if(p != NULL) {

#ifdef LINK_STATS
    lwip_stats.link.recv++;
#endif /* LINK_STATS */

    ethhdr = p->payload;
    
    switch(htons(ethhdr->type)) {
    case ETHTYPE_IP:
      etharp_ip_input(netif, p);
      pbuf_header(p, -14);
			//if(ip_lookup(p->payload, netif)) {
	      netif->input(p, netif);
			//}
      break;
    case ETHTYPE_ARP:
      p = etharp_arp_input(netif, ethernetif->ethaddr, p);
      if(p != NULL) {
				low_level_output(netif, p);
				pbuf_free(p);
      }
      break;
    default:
      pbuf_free(p);
      break;
    }
  }
}
/*-----------------------------------------------------------------------------------*/
static void
arp_timer(void *arg)
{
  etharp_tmr();
  sys_timeout(ARP_TMR_INTERVAL, (sys_timeout_handler)arp_timer, NULL);
}
/*-----------------------------------------------------------------------------------*/
/*
 * ethernetif_init():
 *
 * Should be called at the beginning of the program to set up the
 * network interface. It calls the function low_level_init() to do the
 * actual setup of the hardware.
 *
 */
/*-----------------------------------------------------------------------------------*/
void
ethernetif_init(struct netif *netif)
{
  struct ethernetif *ethernetif;
    
  ethernetif = mem_malloc(sizeof(struct ethernetif));
  netif->state = ethernetif;
  netif->name[0] = IFNAME0;
  netif->name[1] = IFNAME1;
  netif->output = ethernetif_output;
  
  ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]);
  
  low_level_init(netif);
  etharp_init();  
  
  sys_timeout(ARP_TMR_INTERVAL, (sys_timeout_handler)arp_timer, NULL);
}
/*-----------------------------------------------------------------------------------*/
/*
 * pktif_update():
 *
 * Needs to be called periodically to get new packets. This could
 * be done inside a thread.
 */
/*-----------------------------------------------------------------------------------*/
static void ProcessPackets(LPPACKET lpPacket)
{

	ULONG	ulLines, ulBytesReceived;
	char	*base;
	char	*buf;
	u_int off=0;
	u_int tlen,tlen1;
	struct bpf_hdr *hdr;
  struct ethernetif *ethernetif;

  ethernetif = pktif_netif->state;
  
	ulBytesReceived = lpPacket->ulBytesReceived;

	buf = lpPacket->Buffer;

	off=0;

	while(off<ulBytesReceived)
  {	
		//if(kbhit())return;
		hdr=(struct bpf_hdr *)(buf+off);
		tlen1=hdr->bh_datalen;
		cur_length=tlen1;
		tlen=hdr->bh_caplen;
		off+=hdr->bh_hdrlen;

		ulLines = (tlen + 15) / 16;
		if (ulLines > 5) ulLines=5;

		base =(char*)(buf+off);
		cur_packet=base;
		off=Packet_WORDALIGN(off+tlen);

		ethernetif_input(pktif_netif);
	}
} 

void update_adapter(void)
{
  struct ethernetif *ethernetif;

  ethernetif = pktif_netif->state;
  
  if(PacketReceivePacket(lpAdapter,lpPacket,TRUE)==TRUE)
    ProcessPackets(lpPacket);
  cur_length=0;
  cur_packet=NULL;
}