lwip代码分析

int main(void)
{
 struct netif *netif;

 /* the mac address of the board. this should be unique per board */
 unsigned char mac_ethernet_address[] = {
  0x00, 0x0a, 0x35, 0x00, 0x01, 0x02 };

 netif = &server_netif;
#if defined (__arm__) && !defined (ARMR5)
#if XPAR_GIGE_PCS_PMA_SGMII_CORE_PRESENT == 1 || \
  XPAR_GIGE_PCS_PMA_1000BASEX_CORE_PRESENT == 1
 ProgramSi5324();
 ProgramSfpPhy();
#endif
#endif

 /* Define this board specific macro in order perform PHY reset
  * on ZCU102
  */
#ifdef XPS_BOARD_ZCU102
 IicPhyReset();
#endif

 init_platform();

 xil_printf("\r\n\r\n");
 xil_printf("-----lwIP RAW Mode TCP Client Application-----\r\n");

 /* initialize lwIP */
 lwip_init();
 
 /* Add network interface to the netif_list, and set it as default */
 if (!xemac_add(netif, NULL, NULL, NULL, mac_ethernet_address,
    PLATFORM_EMAC_BASEADDR)) {
  xil_printf("Error adding N/W interface\r\n");
  return -1;
 }
 
 netif_set_default(netif);

 /* now enable interrupts */
 platform_enable_interrupts();

 /* specify that the network if is up */
 netif_set_up(netif);
 assign_default_ip(&(netif->ip_addr), &(netif->netmask), &(netif->gw));
 print_ip_settings(&(netif->ip_addr), &(netif->netmask), &(netif->gw));
 
 xil_printf("\r\n");

 /* print app header */
 print_app_header();

 /* start the application*/
 start_application();
 xil_printf("\r\n");

 while (1) {
  if (TcpFastTmrFlag) {
   tcp_fasttmr();
   TcpFastTmrFlag = 0;
  }
  if (TcpSlowTmrFlag) {
   tcp_slowtmr();
   TcpSlowTmrFlag = 0;
  }
  xemacif_input(netif);
  transfer_data();
 }

 /* never reached */
 cleanup_platform();

 return 0;
}

struct netif *
xemac_add(struct netif *netif,
 ip_addr_t *ipaddr, ip_addr_t *netmask, ip_addr_t *gw,
 unsigned char *mac_ethernet_address,
 UINTPTR mac_baseaddr)

/**
 * @ingroup netif
 * Set a network interface as the default network interface
 * (used to output all packets for which no specific route is found)
 *
 * @param netif the default network interface
 */
void
netif_set_default(struct netif *netif)
{
  LWIP_ASSERT_CORE_LOCKED();

  if (netif == NULL) {
    /* remove default route */
    mib2_remove_route_ip4(1, netif);
  } else {
    /* install default route */
    mib2_add_route_ip4(1, netif);
  }
  netif_default = netif;
  LWIP_DEBUGF(NETIF_DEBUG, ("netif: setting default interface %c%c\n",
                            netif ? netif->name[0] : '\'', netif ? netif->name[1] : '\''));
}

void platform_enable_interrupts()
{
 /*
  * Enable non-critical exceptions.
  */
 Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
 XScuTimer_EnableInterrupt(&TimerInstance);
 XScuTimer_Start(&TimerInstance);
 return;
}

void
netif_set_up(struct netif *netif)
{
  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_up: invalid netif", netif != NULL, return);

  if (!(netif->flags & NETIF_FLAG_UP)) {
    netif_set_flags(netif, NETIF_FLAG_UP);

    MIB2_COPY_SYSUPTIME_TO(&netif->ts);

    NETIF_STATUS_CALLBACK(netif);

#if LWIP_NETIF_EXT_STATUS_CALLBACK
    {
      netif_ext_callback_args_t args;
      args.status_changed.state = 1;
      netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args);
    }
#endif

    netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6);
#if LWIP_IPV6
    nd6_restart_netif(netif);
#endif /* LWIP_IPV6 */
  }
}

static void assign_default_ip(ip_addr_t *ip, ip_addr_t *mask, ip_addr_t *gw)
{
 int err;

 xil_printf("Configuring default IP %s \r\n", DEFAULT_IP_ADDRESS);

 err = inet_aton(DEFAULT_IP_ADDRESS, ip);
 if (!err)
  xil_printf("Invalid default IP address: %d\r\n", err);

 err = inet_aton(DEFAULT_IP_MASK, mask);
 if (!err)
  xil_printf("Invalid default IP MASK: %d\r\n", err);

 err = inet_aton(DEFAULT_GW_ADDRESS, gw);
 if (!err)
  xil_printf("Invalid default gateway address: %d\r\n", err);
}

void start_application(void)
{
 err_t err;
 struct tcp_pcb* pcb;
 ip_addr_t remote_addr;
 u32_t i;

#if LWIP_IPV6==1
 remote_addr.type= IPADDR_TYPE_V6;
 err = inet6_aton(TCP_SERVER_IPV6_ADDRESS, &remote_addr);
#else
 err = inet_aton(TCP_SERVER_IP_ADDRESS, &remote_addr);
#endif /* LWIP_IPV6 */

 if (!err) {
  xil_printf("Invalid Server IP address: %d\r\n", err);
  return;
 }

 /* Create Client PCB */
 pcb = tcp_new_ip_type(IPADDR_TYPE_ANY);
 if (!pcb) {
  xil_printf("Error in PCB creation. out of memory\r\n");
  return;
 }

 err = tcp_connect(pcb, &remote_addr, TCP_CONN_PORT,
   tcp_client_connected);
 if (err) {
  xil_printf("Error on tcp_connect: %d\r\n", err);
  tcp_client_close(pcb);
  return;
 }
 client.client_id = 0;

 /* initialize data buffer being sent with same as used in iperf */
 for (i = 0; i < TCP_SEND_BUFSIZE; i++)
  send_buf[i] = (i % 10) + '0';

 return;
}