pktdrv.c

NXPl788上lwip的无操作系统移植,基于Embest开发板

    printf("Invalid adapter_num: %d\n", adapter_num);
    free(pa);
    return NULL;
  }
#ifndef PACKET_LIB_QUIET
  printf("Using adapter_num: %d\n", adapter_num);
#endif /* PACKET_LIB_QUIET */
  /* set up the selected adapter */
  pa->lpAdapter = PacketOpenAdapter(AdapterList[adapter_num]);
  if (!pa->lpAdapter || (pa->lpAdapter->hFile == INVALID_HANDLE_VALUE)) {
    free(pa);
    return NULL;
  }
  /* alloc the OID packet  */
  ppacket_oid_data = (PPACKET_OID_DATA)malloc(sizeof(PACKET_OID_DATA) + PACKET_OID_DATA_SIZE);
  if (!ppacket_oid_data) {
    PacketCloseAdapter(pa->lpAdapter);
    free(pa);
    return NULL;
  }
  /* get the description of the selected adapter */
  ppacket_oid_data->Oid = OID_GEN_VENDOR_DESCRIPTION;
  ppacket_oid_data->Length = PACKET_OID_DATA_SIZE;
  if (PacketRequest(pa->lpAdapter, FALSE, ppacket_oid_data)) {
    printf("Using adapter: \"%s\"", ppacket_oid_data->Data);
  }
  /* get the MAC address of the selected adapter */
  ppacket_oid_data->Oid = OID_802_3_PERMANENT_ADDRESS;
  ppacket_oid_data->Length = ETHARP_HWADDR_LEN;
  if (!PacketRequest(pa->lpAdapter, FALSE, ppacket_oid_data)) {
    printf("ERROR getting the adapter's HWADDR, maybe it's not an ethernet adapter?\n");
    PacketCloseAdapter(pa->lpAdapter);
    free(pa);
    return NULL;
  }
  /* copy the MAC address */
  memcpy(&ethaddr, ppacket_oid_data->Data, ETHARP_HWADDR_LEN);
  free(ppacket_oid_data);
  if (mac_addr != NULL) {
    /* copy the MAC address to the user supplied buffer, also */
    memcpy(mac_addr, &ethaddr, ETHARP_HWADDR_LEN);
  }
  printf(" [MAC: %02X:%02X:%02X:%02X:%02X:%02X]\n", ethaddr[0], ethaddr[1], ethaddr[2],
          ethaddr[3], ethaddr[4], ethaddr[5]);
  /* some more adapter settings */
  PacketSetBuff(pa->lpAdapter, PACKET_ADAPTER_BUFSIZE);
  PacketSetReadTimeout(pa->lpAdapter, 1);
  PacketSetHwFilter(pa->lpAdapter, NDIS_PACKET_TYPE_ALL_LOCAL | NDIS_PACKET_TYPE_PROMISCUOUS);
  /* set up packet descriptor (the application input buffer) */
  if ((pa->lpPacket = PacketAllocatePacket()) == NULL) {
    printf("ERROR setting up a packet descriptor\n");
    PacketCloseAdapter(pa->lpAdapter);
    free(pa);
    return NULL;
  }
  PacketInitPacket(pa->lpPacket,(char*)pa->buffer, sizeof(pa->buffer));

  if(get_link_state(pa, &mediastate)) {
    *linkstate = (mediastate == NdisMediaStateConnected ? LINKEVENT_UP : LINKEVENT_DOWN);
  }

  return pa;
}

/**
 * Close the adapter (no more packets can be sent or received)
 *
 * @param adapter adapter handle received by a call to init_adapter, invalid on return
 */
void
shutdown_adapter(void *adapter)
{
  struct packet_adapter *pa = (struct packet_adapter*)adapter;
  if (pa != NULL) {
    if (pa->lpPacket) {
      PacketFreePacket(pa->lpPacket);
    }
    if (pa->lpAdapter) {
      PacketCloseAdapter(pa->lpAdapter);
    }
    free(pa);
  }
}

/**
 * Send a packet
 *
 * @param adapter adapter handle received by a call to init_adapter
 * @param buffer complete packet to send (including ETH header; without CRC)
 * @param len length of the packet (including ETH header; without CRC)
 */
int
packet_send(void *adapter, void *buffer, int len)
{
  struct packet_adapter *pa = (struct packet_adapter*)adapter;
  LPPACKET lpPacket;

  if (pa == NULL) {
    return -1;
  }
  if ((lpPacket = PacketAllocatePacket()) == NULL) {
    return -1;
  }
  PacketInitPacket(lpPacket, buffer, len);
  if (!PacketSendPacket(pa->lpAdapter, lpPacket, TRUE)) {
    return -1;
  }
  PacketFreePacket(lpPacket);

  return 0;
}

/**
 * Process a packet buffer (which can hold multiple packets) and feed
 * every packet to process_input().
 *
 * @param adapter adapter handle received by a call to init_adapter
 * @param lpPacket the packet buffer to process
 */
static void
ProcessPackets(void *adapter, LPPACKET lpPacket)
{
  struct packet_adapter *pa = (struct packet_adapter*)adapter;
  ULONG  ulLines, ulBytesReceived;
  char  *base;
  char  *buf;
  u_int off = 0;
  u_int tlen, tlen1;
  struct bpf_hdr *hdr;
  void *cur_packet;
  int cur_length;

  if (pa == NULL) {
    return;
  }

  ulBytesReceived = lpPacket->ulBytesReceived;

  buf = (char*)lpPacket->Buffer;

  off=0;

  while (off < ulBytesReceived) {
    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);

    pa->input(pa->input_fn_arg, cur_packet, cur_length);
  }
}

/**
 * Check for newly received packets. Called in the main loop: 'interrupt' mode is not
 * really supported :(
 *
 * @param adapter adapter handle received by a call to init_adapter
 */
void
update_adapter(void *adapter)
{
  struct packet_adapter *pa = (struct packet_adapter*)adapter;
  struct bpf_stat stat;

  /* print the capture statistics */
  if(PacketGetStats(pa->lpAdapter, &stat) == FALSE) {
    printf("Warning: unable to get stats from the kernel!\n");
  } else {
    if (pa->bs_drop != stat.bs_drop) {
      printf("%d packets received.\n%d Packets dropped.\n", stat.bs_recv, stat.bs_drop);
      pa->bs_drop = stat.bs_drop;
    }
  }

  if ((pa != NULL) && (PacketReceivePacket(pa->lpAdapter, pa->lpPacket, TRUE))) {
    ProcessPackets(adapter, pa->lpPacket);
  }
}

/** Get the current linkg status
 * @param adapter adapter handle received by a call to init_adapter
 * @param linkstate the current link state
 * @return 1: succeeded, 0: failed
 */
static int
get_link_state(struct packet_adapter *pa, NDIS_MEDIA_STATE *linkstate)
{
  int ret = 0;
  if(pa != NULL) {
    PPACKET_OID_DATA ppacket_oid_data;

    /* get the media connect status of the selected adapter */
    ppacket_oid_data = (PPACKET_OID_DATA)malloc(sizeof(PACKET_OID_DATA) + sizeof(NDIS_MEDIA_STATE));
    if (ppacket_oid_data != NULL) {
      ppacket_oid_data->Oid    = OID_GEN_MEDIA_CONNECT_STATUS;
      ppacket_oid_data->Length = sizeof(NDIS_MEDIA_STATE);
      if (PacketRequest(pa->lpAdapter, FALSE, ppacket_oid_data)) {
        *linkstate = (*((PNDIS_MEDIA_STATE)(ppacket_oid_data->Data)));
        ret = 1;
      }
      free(ppacket_oid_data);
    }
  }

  return ret;
}

/**
 * Check for link state changes. Called in the main loop: 'interrupt' mode is not
 * really supported :(
 *
 * @param adapter adapter handle received by a call to init_adapter
 * @return one of the link_adapter_event values
 */
enum link_adapter_event
link_adapter(void *adapter)
{
  struct packet_adapter *pa = (struct packet_adapter*)adapter;

  if (pa != NULL) {
    NDIS_MEDIA_STATE fNdisMediaState;
    if (get_link_state(pa, &fNdisMediaState)) {
      if (pa->fNdisMediaState != fNdisMediaState) {
        pa->fNdisMediaState = fNdisMediaState;
        return ((fNdisMediaState == NdisMediaStateConnected) ? LINKEVENT_UP : LINKEVENT_DOWN);
      }
    }
  }

  return LINKEVENT_UNCHANGED;
}