import org.pcap4j.core.PacketListener; //导入依赖的package包/类
public void gotPacket(Packet packet) {
  for (PacketListener user: users) {
    user.gotPacket(packet);
  }

  if (EthernetHelper.matchesDestination(packet, macAddress)) {
    host.gotPacket(packet);
  }
  else {
    if (logger.isDebugEnabled()) {
      StringBuilder sb = new StringBuilder();
      sb.append("Dropped a packet not to me(")
        .append(macAddress)
        .append("): ")
        .append(packet);
      logger.debug(sb.toString());
    }
  }
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
private void readTOPSsample() throws PcapNativeException, InterruptedException, NotOpenException {
    final PcapHandle handle = Pcaps.openOffline("C:\\Users\\wojci\\Desktop\\IEX\\20171104_IEXTP1_TOPS1.6.pcap", PcapHandle.TimestampPrecision.NANO);

    handle.loop(-1, new PacketListener() {
        @Override
        public void gotPacket(final Packet packet) {
            final byte[] data = packet.getPayload().getPayload().getPayload().getRawData();
            final IEXSegment block = IEXTOPSMessageBlock.createIEXSegment(data);
            System.out.println(block);
        }
    });

    handle.close();
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
private void readDEEPsample() throws PcapNativeException, InterruptedException, NotOpenException {
    final PcapHandle handle = Pcaps.openOffline("path_to_pcap", PcapHandle.TimestampPrecision.MICRO);

    handle.loop(-1, new PacketListener() {
        @Override
        public void gotPacket(final Packet packet) {
            final byte[] data = packet.getPayload().getPayload().getPayload().getRawData();
            final IEXSegment block = IEXDEEPMessageBlock.createIEXSegment(data);
            System.out.println(block);
        }
    });

    handle.close();
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
private void readDEEPSample() throws PcapNativeException, NotOpenException, InterruptedException {
    final PcapHandle handle = Pcaps.openOffline("path_to_pcap", PcapHandle.TimestampPrecision.NANO);

    handle.loop(-1, new PacketListener() {
        @Override
        public void gotPacket(Packet packet) {
            final byte[] data = packet.getPayload().getPayload().getPayload().getRawData();
            final IEXSegment block = IEXDEEPMessageBlock.createIEXSegment(data);

            for (final IEXMessage iexMessage : block.getMessages()) {
                if (iexMessage instanceof IEXPriceLevelUpdateMessage) {
                    final IEXPriceLevelUpdateMessage iexPriceLevelUpdateMessage = (IEXPriceLevelUpdateMessage) iexMessage;
                    final IEXOrderBook iexOrderBook = orderBookStore.getOrderBook(iexPriceLevelUpdateMessage.getSymbol())
                            .orElseGet(() -> new IEXOrderBook(iexPriceLevelUpdateMessage.getSymbol()));
                    iexOrderBook.priceLevelUpdate(iexPriceLevelUpdateMessage);
                    orderBookStore.updateOrderBook(iexOrderBook);

                    if (iexOrderBook.getSymbol().equals("AAPL")) {
                        System.out.println(iexOrderBook);
                    }
                }
            }
        }
    });


    handle.close();
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
public VlanInterface(
  String name,
  MacAddress macAddress,
  int vid,
  PacketListener host
) {
  this.name = name;
  this.macAddress = macAddress;
  this.vid = vid;
  this.host = host;
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
public PhysicalNetworkInterface(
  String name,
  MacAddress macAddress,
  boolean trunk,
  PacketListener host
) {
  super(name);
  this.macAddress = macAddress;
  this.trunk = trunk;
  this.host = host;
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
public LagInterface(
  String name,
  MacAddress macAddress,
  int channelGroupNumber,
  PacketListener host
) {
  this.name = name;
  this.macAddress = macAddress;
  this.channelGroupNumber = channelGroupNumber;
  this.host = host;
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
public ReceiveTask(PcapHandle receiveHandle, PacketListener listener, CyclicBarrier cyclicBarrier) {
    this.receiveHandle = receiveHandle;
    this.listener = listener;
    this.cyclicBarrier = cyclicBarrier;
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
/**
 * Starts the capturing in a dedicated thread, so this method returns immediately. Every time a packet is captured,
 * the {@link PacketCapturingHandler#packetCaptured(MacAddress)} of the given
 * {@link PacketCapturingHandler} is called.
 *
 * It's possible to capture packets sent by a specific MAC address by providing the given parameter. If the
 * macAddress is null, all MAC addresses are considered.
 *
 * @param packetCapturingHandler The handler to be called every time a packet is captured
 * @param macAddress The source MAC address of the captured packet, might be null in order to deactivate this filter
 *            criteria
 * @return Returns true, if the capturing has been started successfully, otherwise returns false
 * @throws IllegalStateException Thrown if {@link PcapHandle#isOpen()} of {@link #pcapHandle} returns true
 */

public boolean startCapturing(final PacketCapturingHandler packetCapturingHandler, final String macAddress) {
    if (pcapHandle != null) {
        if (pcapHandle.isOpen()) {
            throw new IllegalStateException("There is an open pcap handle.");
        } else {
            pcapHandle.close();
        }
    }
    try {
        pcapHandle = pcapNetworkInterface.openLive(SNAPLEN, PromiscuousMode.PROMISCUOUS, READ_TIMEOUT);
        StringBuilder filterBuilder = new StringBuilder("(arp or port bootps)");
        if (macAddress != null) {
            filterBuilder.append(" and ether src " + macAddress);
        }
        pcapHandle.setFilter(filterBuilder.toString(), BpfCompileMode.OPTIMIZE);
    } catch (Exception e) {
        logger.error("Capturing packets on device {} failed.", pcapNetworkInterface.getName(), e);
        return false;
    }
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    executorService.submit(new Callable<Void>() {

        @Override
        public Void call() throws Exception {
            try {
                pcapHandle.loop(-1, new PacketListener() {

                    @Override
                    public void gotPacket(Packet packet) {
                        if (!packet.contains(EthernetPacket.class)) {
                            return;
                        }
                        final EthernetPacket ethernetPacket = packet.get(EthernetPacket.class);
                        final MacAddress sourceMacAddress = ethernetPacket.getHeader().getSrcAddr();
                        if (shouldCapture(packet)) {
                            packetCapturingHandler.packetCaptured(sourceMacAddress);
                        }
                    }
                });
            } finally {
                if (pcapHandle != null && pcapHandle.isOpen()) {
                    pcapHandle.close();
                    pcapHandle = null;
                }
            }
            return null;
        }
    });
    if (macAddress == null) {
        logger.debug("Started capturing ARP and BOOTP requests for network device {}.",
                pcapNetworkInterface.getName());
    } else {
        logger.debug("Started capturing ARP  and BOOTP requests for network device {} and MAC address {}.",
                pcapNetworkInterface.getName(), macAddress);
    }
    return true;
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
public void addUser(PacketListener user) {
  users.add(user);
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
@Deprecated
public void addUser(PacketListener user) {
  throw new UnsupportedOperationException();
}
 

import org.pcap4j.core.PacketListener; //导入依赖的package包/类
public void addUser(PacketListener user);