Examples with PEX dev.hawala.xns.level2.PEX used on opensource projects

Example 1 with PEX

use of dev.hawala.xns.level2.PEX in project dodo by devhawala.

the class GetXNSPackets method main.

/**
 * Main startup method
 *
 * @param args
 *          ignored
 * @throws IOException
 */
public static void main(String[] args) throws IOException {
    // Will be filled with NICs
    List<PcapIf> alldevs = new ArrayList<PcapIf>();
    // For any error msgs
    StringBuilder errbuf = new StringBuilder();
    /**
     *************************************************************************
     * First get a list of devices on this system
     *************************************************************************
     */
    int r = Pcap.findAllDevs(alldevs, errbuf);
    if (r == Pcap.NOT_OK || alldevs.isEmpty()) {
        System.err.printf("Can't read list of devices, error is %s", errbuf.toString());
        return;
    }
    System.err.printf("r -> %d\n", r);
    System.err.printf("alldevs.size() = %d\n", alldevs.size());
    System.out.println("Network devices found:");
    PcapIf matchedDev = null;
    int i = 0;
    for (PcapIf device : alldevs) {
        String description = (device.getDescription() != null) ? device.getDescription() : "No description available";
        if ("tap0".equals(description)) {
            System.err.println("** found tap0 by description");
            matchedDev = device;
        }
        if ("tap0".equals(device.getName())) {
            System.err.println("** found tap0 by name");
            matchedDev = device;
        }
        byte[] addr = device.getHardwareAddress();
        String addrLen = "X";
        String sep = "";
        String mac = "";
        if (addr != null) {
            addrLen = "" + addr.length;
            for (byte b : addr) {
                mac = String.format("%s%s%02X", mac, sep, b);
                sep = "-";
            }
        }
        System.out.printf("#%d: %s (%s)[%s] [%s]\n", i++, device.getName(), addrLen, mac, description);
    }
    // We know we have at least 1 device
    PcapIf device = (matchedDev != null) ? matchedDev : alldevs.get(alldevs.size() - 1);
    System.out.printf("\nChoosing '%s' on your behalf:\n", (device.getDescription() != null) ? device.getDescription() : device.getName());
    /**
     *************************************************************************
     * Second we open up the selected device
     *************************************************************************
     */
    // Capture all packets, no trucation
    int snaplen = 64 * 1024;
    // capture all packets
    int flags = Pcap.MODE_PROMISCUOUS;
    // 10 * 1000;           // 10 seconds in millis
    int timeout = 1;
    Pcap pcap = Pcap.openLive(device.getName(), snaplen, flags, timeout, errbuf);
    if (pcap == null) {
        System.err.printf("Error while opening device for capture: " + errbuf.toString());
        return;
    }
    /**
     *************************************************************************
     * Third we create a packet handler which will receive packets from the
     * libpcap loop.
     *************************************************************************
     */
    PcapPacketHandler<String> jpacketHandler = new PcapPacketHandler<String>() {

        public void nextPacket(PcapPacket packet, String user) {
            if (packet.getByte(12) != (byte) 0x06 || packet.getByte(13) != (byte) 0x00) {
                // System.out.println("packet skipped...");
                return;
            }
            System.out.printf("\n\nReceived packet at %s caplen=%-4d len=%-4d %s\n", new Date(packet.getCaptureHeader().timestampInMillis()), // Length actually captured
            packet.getCaptureHeader().caplen(), // Original length
            packet.getCaptureHeader().wirelen(), // User supplied object
            user);
            // System.out.println(packet);
            int payloadStart = 14;
            int payloadLength = packet.getCaptureHeader().caplen() - payloadStart;
            NetPacket np = new NetPacket(packet.getByteArray(payloadStart, payloadLength));
            IDP idp = new IDP(np);
            PacketType packetType = idp.getPacketType();
            if (packetType == PacketType.SPP) {
                SPP spp = new SPP(idp);
                System.out.printf("%s\n", spp.toString());
                System.out.printf("payload: %s\n", spp.payloadToString());
            } else if (packetType == PacketType.ERROR) {
                Error err = new Error(idp);
                System.out.printf("%s\n", err.toString());
                System.out.printf("payload: %s\n", err.payloadToString());
            } else if (packetType == PacketType.PEX) {
                PEX pex = new PEX(idp);
                System.out.printf("%s\n", pex.toString());
                System.out.printf("payload: %s\n", pex.payloadToString());
            } else {
                System.out.printf("%s\n", np.toString());
                System.out.printf("payload: %s\n", np.payloadToString());
            }
        }
    };
    // JBufferHandler<String> jbufferHandler = new JBufferHandler<String>() {
    // 
    // @Override
    // public void nextPacket(PcapHeader header, JBuffer buffer, String userDate) {
    // buffer.
    // }
    // 
    // }
    /**
     *************************************************************************
     * Fourth we enter the loop and tell it to capture 10 packets. The loop
     * method does a mapping of pcap.datalink() DLT value to JProtocol ID, which
     * is needed by JScanner. The scanner scans the packet buffer and decodes
     * the headers. The mapping is done automatically, although a variation on
     * the loop method exists that allows the programmer to sepecify exactly
     * which protocol ID to use as the data link type for this pcap interface.
     *************************************************************************
     */
    pcap.loop(100000, jpacketHandler, "jNetPcap rocks!");
    /**
     *************************************************************************
     * Last thing to do is close the pcap handle
     *************************************************************************
     */
    pcap.close();
    System.out.printf("GetXNSPackets done\n");
}

Example 2 with PEX

use of dev.hawala.xns.level2.PEX in project dodo by devhawala.

the class TestPayloads method testNominalSizes.

@Test
public void testNominalSizes() {
    final int maxNetPayloadSize = NetPacket.MAX_PACKET_SIZE;
    final int maxIdpPayloadSize = NetPacket.MAX_PACKET_SIZE - IDP.IDP_DATA_START;
    final int maxSppPayloadSize = NetPacket.MAX_PACKET_SIZE - IDP.IDP_DATA_START - SPP.SPP_DATA_START;
    final int maxPexPayloadSize = NetPacket.MAX_PACKET_SIZE - IDP.IDP_DATA_START - PEX.PEX_DATA_START;
    final int maxErrPayloadSize = NetPacket.MAX_PACKET_SIZE - IDP.IDP_DATA_START - Error.ERROR_DATA_START;
    NetPacket netPacket = new NetPacket();
    assertEquals("netPacket.getMaxPayloadLength()", maxNetPayloadSize, netPacket.getMaxPayloadLength());
    IDP idp1 = new IDP();
    assertEquals("idp1.getMaxPayloadLength()", maxIdpPayloadSize, idp1.getMaxPayloadLength());
    // IDP idp2 = new IDP(new NetPacket());
    // assertEquals("idp2.getMaxPayloadLength()", maxIdpPayloadSize, idp2.getMaxPayloadLength());
    SPP spp1 = new SPP();
    assertEquals("spp1.getMaxPayloadLength()", maxSppPayloadSize, spp1.getMaxPayloadLength());
    // SPP spp2 = new SPP(new IDP());
    // assertEquals("spp2.getMaxPayloadLength()", maxSppPayloadSize, spp2.getMaxPayloadLength());
    // SPP spp3 = new SPP(new IDP(new NetPacket()));
    // assertEquals("spp3.getMaxPayloadLength()", maxSppPayloadSize, spp3.getMaxPayloadLength());
    PEX pex1 = new PEX();
    assertEquals("pex1.getMaxPayloadLength()", maxPexPayloadSize, pex1.getMaxPayloadLength());
// PEX pex2 = new PEX(new IDP());
// assertEquals("pex2.getMaxPayloadLength()", maxPexPayloadSize, pex2.getMaxPayloadLength());
// PEX pex3 = new PEX(new IDP(new NetPacket()));
// assertEquals("pex3.getMaxPayloadLength()", maxPexPayloadSize, pex3.getMaxPayloadLength());
// Error err1 = new Error();
// assertEquals("err1.getMaxPayloadLength()", maxErrPayloadSize, err1.getMaxPayloadLength());
// Error err2 = new Error(new IDP());
// assertEquals("err2.getMaxPayloadLength()", maxErrPayloadSize, err2.getMaxPayloadLength());
// Error err3 = new Error(new IDP(new NetPacket()));
// assertEquals("err3.getMaxPayloadLength()", maxErrPayloadSize, err3.getMaxPayloadLength());
}

Example 3 with PEX

use of dev.hawala.xns.level2.PEX in project dodo by devhawala.

the class Tests method createWhereAmIReply.

private PEX createWhereAmIReply(PEX pexPacket) {
    PEX response = new PEX(NETWORK_NUMBER_BYTES);
    response.idp.asReplyTo(pexPacket.idp);
    response.idp.setDstNetwork(NETWORK_NUMBER);
    response.idp.setSrcNetwork(NETWORK_NUMBER);
    response.idp.setSrcHost(HOST_ADDRESS);
    response.setIdentification(pexPacket.getIdentification());
    response.setClientType(pexPacket.getClientType());
    response.copy(pexPacket);
    return response;
}

Example 4 with PEX

use of dev.hawala.xns.level2.PEX in project dodo by devhawala.

the class NetMachine method pexRequest.

@Override
public Payload pexRequest(EndpointAddress remoteEndpoint, int clientType, byte[] pBuffer, int pOffset, int pLength) throws XnsException {
    PEX pex = new PEX(pBuffer, pOffset, pLength);
    pex.setClientType(clientType);
    pex.setIdentification(this.getClientIdentification());
    pex.idp.withDestination(remoteEndpoint);
    return this.pexRequestHandler.sendAndwaitForResponse(pex);
}

Example 5 with PEX

use of dev.hawala.xns.level2.PEX in project dodo by devhawala.

the class NetSpy method dumpPacket.

private static void dumpPacket() {
    logf("\n          => raw packet content:");
    for (int i = 0; i < (bufLen + 1) / 2; i++) {
        if ((i % 16) == 0) {
            logf("\n              0x%03X :", i);
        }
        logf(" %04X", readWord(i));
    }
    logf("\n");
    if (bufLen < 7) {
        return;
    }
    logf("\n          => ethernet packet header\n");
    dumpNetAddress("dst-addr", readWord(0), readWord(1), readWord(2));
    dumpNetAddress("src-addr", readWord(3), readWord(4), readWord(5));
    short etherType = readWord(6);
    logf("              ethType  : 0x%04X (%s)\n", etherType, (etherType == 0x0600) ? "xns" : "other");
    if (etherType != 0x0600) {
        return;
    }
    logf("\n          => xns packet header\n");
    int pByteLen = readWord(8) & 0xFFFF;
    int pWordLen = (pByteLen + 1) / 2;
    logf("              ckSum   : 0x%04X\n", readWord(7));
    logf("              length  : %d bytes => %d words\n", pByteLen, pWordLen);
    short ctlType = readWord(9);
    logf("              transCtl: %d\n", ctlType >>> 8);
    int ptype = ctlType & 0xFF;
    String typeName = "?";
    switch(ptype) {
        case 1:
            typeName = "Rip";
            break;
        case 2:
            typeName = "Echo";
            break;
        case 3:
            typeName = "Error";
            break;
        case 4:
            typeName = "PEX";
            break;
        case 5:
            typeName = "SPP";
            break;
        case 9:
            typeName = "BootServerPacket";
            break;
        case 12:
            typeName = "PUP";
            break;
        default:
            typeName = "unknown";
    }
    logf("              pktType : %d = %s\n", ptype, typeName);
    dumpXnsEndpoint("destination", readWord(10), readWord(11), readWord(12), readWord(13), readWord(14), readWord(15));
    dumpXnsEndpoint("source", readWord(16), readWord(17), readWord(18), readWord(19), readWord(20), readWord(21));
    if (ptype == 1) {
        // Rip
        int wordsRemaining = (pWordLen + 7) - 22;
        int currWord = 22;
        logf("\n          => RIP( remaining words = %d , curr word = %d )\n", wordsRemaining, currWord);
        int operation = readWord(currWord++) & 0xFFFF;
        wordsRemaining--;
        String opName;
        switch(operation) {
            case 1:
                opName = "request";
                break;
            case 2:
                opName = "response";
                break;
            default:
                opName = "??";
        }
        logf("              operation: %d = %s\n", operation, opName);
        while (wordsRemaining >= 3) {
            int nw1 = readWord(currWord++) & 0xFFFF;
            wordsRemaining--;
            int nw2 = readWord(currWord++) & 0xFFFF;
            wordsRemaining--;
            int hops = readWord(currWord++);
            wordsRemaining--;
            logf("              network 0x %04X %04X , hops = %d\n", nw1, nw2, hops);
        }
    }
    if (ptype == 4) {
        // PEX
        logf("\n          => PEX header\n");
        logf("              identif.  : %04X - %04X\n", readWord(22), readWord(23));
        int ctype = readWord(24);
        String clientType;
        switch(ctype) {
            case 0:
                clientType = "unspecified";
                break;
            case 1:
                clientType = "time";
                break;
            case 2:
                clientType = "clearinghouse";
                break;
            case 8:
                clientType = "teledebug";
                break;
            default:
                clientType = "??";
        }
        logf("              clientType: %d = %s\n", ctype, clientType);
        dumpXnsBody(typeName, pByteLen, 3);
    }
    if (ptype == 5) {
        // SPP
        int w22 = readWord(22);
        int tctl = (w22 >> 8) & 0x00FF;
        int sst = w22 & 0x00FF;
        String transCtl = "";
        if ((tctl & 0x80) != 0) {
            transCtl += " SystemPacket";
        }
        if ((tctl & 0x40) != 0) {
            transCtl += " SendAck";
        }
        if ((tctl & 0x20) != 0) {
            transCtl += " Attention";
        }
        if ((tctl & 0x10) != 0) {
            transCtl += " EndOfMessage";
        }
        int srcConnId = readWord(23) & 0xFFFF;
        int dstConnId = readWord(24) & 0xFFFF;
        int seqNo = readWord(25) & 0xFFFF;
        int ackNo = readWord(26) & 0xFFFF;
        int allocNo = readWord(27) & 0xFFFF;
        logf("\n          => SPP header\n");
        logf("              TransCtl  : %02X (%s )\n", tctl, transCtl);
        logf("              Data SST  : %02X\n", sst);
        logf("              Source Id : %04X\n", srcConnId);
        logf("              Dest Id   : %04X\n", dstConnId);
        logf("              SequenceNo: %04X\n", seqNo);
        logf("              Ack No    : %04X\n", ackNo);
        logf("              Alloc No  : %04X\n", allocNo);
        dumpXnsBody(typeName, pByteLen, 6);
    }
    if (ptype == 3) {
        // Error
        ErrorCode errorCode = ErrorCode.forNumber(readWord(22) & 0xFFFF);
        int errorParam = readWord(23) & 0xFFFF;
        logf("\n          => Error header\n");
        logf("              ErrorCode : %s\n", errorCode);
        logf("              ErrorParam: 0x%04X\n", errorParam);
        dumpXnsBody(typeName, pByteLen, 2);
    }
}