From 8d82476f77f4d4060d67938091d92d000a416b34 Mon Sep 17 00:00:00 2001 From: John Furr <John Furr@Johns_Asus> Date: Thu, 6 Sep 2018 11:05:40 -0700 Subject: [PATCH] Draft files added. --- .../FriscoFurrProject/FDCSendRecieve.java | 258 ++++++++++++++ .../FriscoFurrProject/FFTestEspduSender.java | 324 ++++++++++++++++++ .../FriscoFurrPduSender.java | 5 +- 3 files changed, 586 insertions(+), 1 deletion(-) create mode 100644 deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FDCSendRecieve.java create mode 100644 deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FFTestEspduSender.java diff --git a/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FDCSendRecieve.java b/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FDCSendRecieve.java new file mode 100644 index 0000000000..95ef35b042 --- /dev/null +++ b/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FDCSendRecieve.java @@ -0,0 +1,258 @@ +package MV3500Cohort2018JulySeptember.FinalProject.FriscoFurrProject; + +import java.net.*; +import java.io.*; +import java.util.*; +import edu.nps.moves.dis.*; +import java.io.IOException; +import edu.nps.moves.disenum.*; +import edu.nps.moves.disutil.PduFactory; + +public class FDCSendRecieve { + + /** + * Default multicast group address we send on. + */ + public static final String DEFAULT_MULTICAST_ADDRESS = "239.1.2.3"; + + /** + * Default multicast port used, matches Wireshark DIS capture default + */ + public static final int DEFAULT_MULTICAST_PORT = 3000; + + private int port; + InetAddress multicastAddress; + + public static final int MULTICAST_PORT = 3000; + public static final String MULTICAST_GROUP = "239.1.2.3"; + public static final boolean USE_FAST_ESPDU = false; + + public FDCSendRecieve(int port, String multicast) { + try { + this.port = port; + multicastAddress = InetAddress.getByName(multicast); + if (!multicastAddress.isMulticastAddress()) { + System.out.println("Not a multicast address: " + multicast); + } + } catch (UnknownHostException e) { + System.out.println("Unable to open socket: " + e); + } + } + + public void run(Pdu pdu) { + System.out.println("DisExamples.PduSender started..."); + short currentPduType = pdu.getPduType(); + String currentPduTypeName = pdu.getClass().getName(); + short currentProtocolFamilyID = pdu.getProtocolFamily(); + String currentPduFamilyName = pdu.getClass().getSuperclass().getSimpleName(); + + try { + List<Pdu> generatedPdus = new ArrayList<>(); + + // Loop through all the enumerated PDU types, create a PDU for each type, + // and add that PDU to a list. + for (PduType pdu2 : PduType.values()) { + Pdu aPdu = null; + System.out.println(pdu); + + //Change the switch statement to the currentPduType from the recieve portion, then when a packet we want comes in, send the CASE file. + + switch (pdu2) // using enumeration values from edu.nps.moves.disenum.* + { + + case ENTITY_STATE: + System.out.println("Case: Enitity_State " + pdu + "\n"); + aPdu = new EntityStatePdu(); + EntityStatePdu espdu = (EntityStatePdu) aPdu; + Marking marking = new Marking(); + marking.setCharactersString("PduSender"); + espdu.setMarking(marking); + Vector3Double espduLocation = new Vector3Double(); + espduLocation.setX(1.0); + espduLocation.setY(2.0); + espduLocation.setZ(3.0); + break; + + case COMMENT: + aPdu = new CommentPdu(); + break; + + case FIRE: + aPdu = new FirePdu(); + break; + + case DETONATION: + aPdu = new DetonationPdu(); + break; + + case COLLISION: + aPdu = new CollisionPdu(); + break; + + case SERVICE_REQUEST: + aPdu = new ServiceRequestPdu(); + break; + + case RESUPPLY_OFFER: + aPdu = new ResupplyOfferPdu(); + break; + + case RESUPPLY_RECEIVED: + aPdu = new ResupplyReceivedPdu(); + break; + + case RESUPPLY_CANCEL: + aPdu = new ResupplyCancelPdu(); + break; + + case REPAIR_COMPLETE: + aPdu = new RepairCompletePdu(); + break; + + case REPAIR_RESPONSE: + aPdu = new RepairResponsePdu(); + break; + + case CREATE_ENTITY: + aPdu = new CreateEntityPdu(); + break; + + case REMOVE_ENTITY: + aPdu = new RemoveEntityPdu(); + break; + + case START_RESUME: + aPdu = new StartResumePdu(); + break; + + case STOP_FREEZE: + aPdu = new StopFreezePdu(); + break; + + case ACKNOWLEDGE: + aPdu = new AcknowledgePdu(); + break; + + case ACTION_REQUEST: + aPdu = new ActionRequestPdu(); + break; + + default: + System.out.print("PDU of type " + pdu + " not supported, created or sent "); + System.out.println(); + } + if (aPdu != null) { + generatedPdus.add(aPdu); + System.out.println("APDU container count " + generatedPdus.size()); + } + } + + + + // Send the PDUs we created + InetAddress localMulticastAddress = InetAddress.getByName(DEFAULT_MULTICAST_ADDRESS); + MulticastSocket socket = new MulticastSocket(DEFAULT_MULTICAST_PORT); + socket.joinGroup(localMulticastAddress); + + for (int idx = 0; idx < generatedPdus.size(); idx++) { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(baos); + byte[] buffer; + + Pdu aPdu = generatedPdus.get(idx); + aPdu.marshal(dos); + + buffer = baos.toByteArray(); + DatagramPacket packet = new DatagramPacket(buffer, buffer.length, localMulticastAddress, DEFAULT_MULTICAST_PORT); + socket.send(packet); + System.out.println("Sent PDU of type " + aPdu.getClass().getName()); + } + } catch (IOException e) { + System.out.println(e); + } + } + + public static void main(String[] args) { + + //turns on the sender code - might need to move around down into the recieve with the if statements... + if (args.length == 2) { + FDCSendRecieve sender = new FDCSendRecieve(Integer.parseInt(args[0]), args[1]); + // sender.run(); //needs to be sender.run(pdu) + } else { + System.out.println("Usage: PduSender <port> <multicast group>"); + System.out.println("Default: PduSender " + DEFAULT_MULTICAST_PORT + " " + DEFAULT_MULTICAST_ADDRESS); + FDCSendRecieve sender = new FDCSendRecieve(DEFAULT_MULTICAST_PORT, DEFAULT_MULTICAST_ADDRESS); + // sender.run(); + } + + + + /* BELOW IS THE RECIEVE CODE // + // // + // // + */ // + PduFactory factory; + MulticastSocket socket = null; + InetAddress address = null; + DatagramPacket packet; + short currentPduType; //will use the curentPduType as the check for sending other packets. + + + try { + FDCSendRecieve sender = new FDCSendRecieve(DEFAULT_MULTICAST_PORT, DEFAULT_MULTICAST_ADDRESS); + System.out.println("DisExamples.PduReceiver started..."); + socket = new MulticastSocket(MULTICAST_PORT); + address = InetAddress.getByName(MULTICAST_GROUP); + socket.joinGroup(address); + + factory = new PduFactory(); + + while (true) // Loop infinitely, receiving datagrams + { + byte buffer[] = new byte[1500]; // typical MTU size + + packet = new DatagramPacket(buffer, buffer.length); // reset + + socket.receive(packet); + + Pdu pdu = factory.createPdu(packet.getData()); + if (pdu != null) { + currentPduType = pdu.getPduType(); + // if statement might need to go here fix thread shit... + +// if(currentPduType == 5 ||currentPduType == 4 ) +// {Thread thread; +// thread = new Thread(sender.run(pdu)); +// thread.start(); +// } + sender.run(pdu); + + String currentPduTypeName = pdu.getClass().getName(); + short currentProtocolFamilyID = pdu.getProtocolFamily(); + String currentPduFamilyName = pdu.getClass().getSuperclass().getSimpleName(); + + StringBuilder message = new StringBuilder(); + message.append("received DIS PDU: "); + message.append("pduType "); + if (currentPduType < 10) { + message.append(" "); + } + message.append(currentPduType).append(" ").append(currentPduTypeName); + message.append(", protocolFamily ").append(currentProtocolFamilyID); + message.append(" ").append(currentPduFamilyName); + System.out.println(message.toString()); + + } else { + System.out.println("received packet but pdu is null, packet.getData().length=" + packet.getData().length + ", error..."); + } + } + } catch (IOException e) { + System.out.println("Problem with DisExamples.PduReceiver, see exception trace:"); + System.out.println(e); + } finally { + System.out.println("DisExamples.PduReceiver complete."); + } + + } + +} diff --git a/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FFTestEspduSender.java b/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FFTestEspduSender.java new file mode 100644 index 0000000000..c3e1b7a981 --- /dev/null +++ b/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FFTestEspduSender.java @@ -0,0 +1,324 @@ +package MV3500Cohort2018JulySeptember.FinalProject.FriscoFurrProject; + +import java.io.*; +import java.net.*; +import java.util.*; + +import edu.nps.moves.dis.*; +import edu.nps.moves.disutil.CoordinateConversions; +import edu.nps.moves.disutil.DisTime; + +/** + * Creates and sends ESPDUs in IEEE binary format. Adapted from OpenDIS library + * example package edu.nps.moves.examples + * + * @author DMcG + */ +public class FFTestEspduSender { + + public static final int NUMBER_TO_SEND = 5000; + + public enum NetworkMode { + UNICAST, MULTICAST, BROADCAST + }; + + /** + * Default multicast group address we send on. + */ + public static final String DEFAULT_MULTICAST_ADDRESS = "239.1.2.3"; + + /** + * Default multicast port used, matches Wireshark DIS capture default + */ + public static final int DEFAULT_MULTICAST_PORT = 3000; + + /** + * Possible system properties, passed in via -Dattr=val networkMode: + * unicast, broadcast, multicast destinationIp: where to send the packet. If + * in multicast mode, this can be multicast. To determine broadcast + * destination IP, use an online broadcast address calculator, for example + * http://www.remotemonitoringsystems.ca/broadcast.php If in multicast mode, + * a join() will be done on the multicast address. port: port used for both + * source and destination. + * + * @param args + */ + public static void main(String args[]) + { + System.out.println("DisExamples.EspduSender started... send " + NUMBER_TO_SEND + " ESPDUs, initial index=0"); + /** + * an entity state pdu + */ + EntityStatePdu espdu = new EntityStatePdu(); + MulticastSocket socket = null; // must be initialized, even if null + DisTime disTime = DisTime.getInstance(); // TODO explain + int alternator = -1; + + // ICBM coordinates for my office + double lat = 36.595517; + double lon = -121.877000; + + // Default settings. These are used if no system properties are set. + // If system properties are passed in, these are over ridden. + int port = DEFAULT_MULTICAST_PORT; + NetworkMode mode = NetworkMode.BROADCAST; + InetAddress destinationIp = null; // must be initialized, even if null + + try { + destinationIp = InetAddress.getByName(DEFAULT_MULTICAST_ADDRESS); + } catch (UnknownHostException e) { + System.out.println(e + " Cannot create multicast address"); + System.exit(0); + } + + // All system properties, passed in on the command line via -Dattribute=value + Properties systemProperties = System.getProperties(); + + // IP address we send to + String destinationIpString = systemProperties.getProperty("destinationIp"); + + // Port we send to, and local port we open the socket on + String portString = systemProperties.getProperty("port"); + + // Network mode: unicast, multicast, broadcast + String networkModeString = systemProperties.getProperty("networkMode"); // unicast or multicast or broadcast + + // Set up a socket to send information + try { + // Port we send to + if (portString != null) + { + port = Integer.parseInt(portString); + } + + socket = new MulticastSocket(port); + + // Where we send packets to, the destination IP address + if (destinationIpString != null) + { + destinationIp = InetAddress.getByName(destinationIpString); + } + + // Type of transport: unicast, broadcast, or multicast + // TODO convert to String constants + if (networkModeString != null) { + if (networkModeString.equalsIgnoreCase("unicast")) + { + mode = NetworkMode.UNICAST; + } + else if (networkModeString.equalsIgnoreCase("broadcast")) { + mode = NetworkMode.BROADCAST; + } + else if (networkModeString.equalsIgnoreCase("multicast")) { + mode = NetworkMode.MULTICAST; + if (!destinationIp.isMulticastAddress()) + { + throw new RuntimeException("Sending to multicast address, but destination address " + destinationIp.toString() + "is not multicast"); + } + socket.joinGroup(destinationIp); + } + } // end networkModeString + } + catch (IOException | RuntimeException e) + { + System.out.println("Unable to initialize networking. Exiting."); + System.out.println(e); + System.exit(-1); + } + + // Initialize values in the Entity State PDU object. The exercise ID is + // a way to differentiate between different virtual worlds on one network. + // Note that some values (such as the PDU type and PDU family) are set + // automatically when you create the ESPDU. + espdu.setExerciseID((short) 1); + + // The EID is the unique identifier for objects in the world. This + // EID should match up with the ID for the object specified in the + // VMRL/x3d/virtual world. + EntityID entityID = espdu.getEntityID(); + entityID.setSite(1); // 0 is apparently not a valid site number, per the spec + entityID.setApplication(1); + entityID.setEntity(2); + + // Set the entity type. SISO has a big list of enumerations, so that by + // specifying various numbers we can say this is an M1A2 American tank, + // the USS Enterprise, and so on. We'll make this a tank. There is a + // separate project elsehwhere in this project that implements DIS + // enumerations in C++ and Java, but to keep things simple we just use + // numbers here. + EntityType entityType = espdu.getEntityType(); + entityType.setEntityKind((short) 1); // Platform (vs lifeform, munition, sensor, etc.) + entityType.setCountry(225); // USA + entityType.setDomain((short) 1); // Land (vs air, surface, subsurface, space) + entityType.setCategory((short) 1); // Tank + entityType.setSubcategory((short) 1); // M1 Abrams + entityType.setSpec((short) 3); // M1A2 Abrams + + Set<InetAddress> broadcastAddresses; + // Loop through sending N ESPDUs + try + { + System.out.println("Sending " + NUMBER_TO_SEND + " ESPDU packets to " + destinationIp.toString()); + + for (int index = 0; index < NUMBER_TO_SEND; index++) { + // DIS time is a pain in the uh, neck. DIS time units are 2^31-1 units per + // hour, and time is set to DIS time units from the top of the hour. + // This means that if you start sending just before the top of the hour + // the time units can roll over to zero as you are sending. The receivers + // (escpecially homegrown ones) are often not able to detect rollover + // and may start discarding packets as dupes or out of order. We use + // an NPS timestamp here, hundredths of a second since the start of the + // year. The DIS standard for time is often ignored in the wild; I've seen + // people use Unix time (seconds since 1970) and more. Or you can + // just stuff idx into the timestamp field to get something that is monotonically + // increasing. + + // Note that timestamp is used to detect duplicate and out of order packets. + // That means if you DON'T change the timestamp, many implementations will simply + // discard subsequent packets that have an identical timestamp. Also, if they + // receive a PDU with an timestamp lower than the last one they received, they + // may discard it as an earlier, out-of-order PDU. So it is a good idea to + // update the timestamp on ALL packets sent. + // An alterative approach: actually follow the standard. It's a crazy concept, + // but it might just work. + int timestamp = disTime.getDisAbsoluteTimestamp(); + espdu.setTimestamp(timestamp); + + // Set the position of the entity in the world. DIS uses a cartesian + // coordinate system with the origin at the center of the earth, the x + // axis out at the equator and prime meridian, y out at the equator and + // 90 deg east, and z up and out the north pole. To place an object on + // the earth's surface you also need a model for the shape of the earth + // (it's not a sphere.) All the fancy math necessary to do this is in + // the SEDRIS SRM package. There are also some one-off formulas for + // doing conversions from, for example, lat/lon/altitude to DIS coordinates. + // Here we use those one-off formulas. + // Modify the position of the object. This will send the object a little + // due east by adding some to the longitude every iteration. Since we + // are on the Pacific coast, this sends the object east. Assume we are + // at zero altitude. In other worlds you'd use DTED to determine the + // local ground altitude at that lat/lon, or you'd just use ground clamping. + // The x and y values will change, but the z value should not. + //lon = lon + (double)((double)idx / 100000.0); + //System.out.println("lla=" + lat + "," + lon + ", 0.0"); + double direction = Math.pow((double) (-1.0), (double) (index)); + lon = lon + (direction * 0.00006); + System.out.println(lon); + + double disCoordinates[] = CoordinateConversions.getXYZfromLatLonDegrees(lat, lon, 1.0); + Vector3Double location = espdu.getEntityLocation(); + location.setX(disCoordinates[0]); + location.setY(disCoordinates[1]); + location.setZ(disCoordinates[2]); + System.out.println("lat, lon:" + lat + ", " + lon); + System.out.println("DIS coord:" + disCoordinates[0] + ", " + disCoordinates[1] + ", " + disCoordinates[2]); + + // Optionally, we can do some rotation of the entity + /* + Orientation orientation = espdu.getEntityOrientation(); + float psi = orientation.getPsi(); + psi = psi + idx; + orientation.setPsi(psi); + orientation.setTheta((float)(orientation.getTheta() + idx /2.0)); + */ + // You can set other ESPDU values here, such as the velocity, acceleration, + // and so on. + // Marshal out the espdu object to a byte array, then send a datagram + // packet with that data in it. + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + DataOutputStream dos = new DataOutputStream(baos); + espdu.marshal(dos); + + FirePdu fire = new FirePdu(); + fire.set + byte[] fireArray = fire.marshal(); + + // The byte array here is the packet in DIS format. We put that into a + // datagram and send it. + byte[] data = baos.toByteArray(); + + broadcastAddresses = getBroadcastAddresses(); + Iterator iterator = broadcastAddresses.iterator(); + while (iterator.hasNext()) + { + InetAddress broadcast = (InetAddress) iterator.next(); + System.out.println("Sending broadcast datagram packet to " + broadcast); + DatagramPacket packet = new DatagramPacket(data, data.length, broadcast, port); + socket.send(packet); + // TODO experiment with these! 8) + packet = new DatagramPacket(fireArray, fireArray.length, broadcast, port); // alternate + socket.send(packet); + } + + // Send every 1 sec. Otherwise all this will be all over in a fraction of a second. + Thread.sleep(1000); // msec + + location = espdu.getEntityLocation(); + + System.out.println("Espdu #" + index + " EID=[" + entityID.getSite() + "," + entityID.getApplication() + "," + entityID.getEntity() + "]"); + System.out.println(" DIS coordinates location=[" + location.getX() + "," + location.getY() + "," + location.getZ() + "]"); + double c[] = {location.getX(), location.getY(), location.getZ()}; + double lla[] = CoordinateConversions.xyzToLatLonDegrees(c); +// debug: System.out.println(" Location (lat/lon/alt): [" + lla[0] + ", " + lla[1] + ", " + lla[2] + "]"); + } + } + catch (IOException | InterruptedException e) + { + System.out.println("Problem with DisExamples.EspduSender, see exception trace:"); + System.out.println(e); + } + } + + /** + * A number of sites get all snippy about using 255.255.255.255 for a + * broadcast address; it trips their security software and they kick you off + * their network. (Comcast, NPS.) This determines the broadcast address for + * all connected interfaces, based on the IP and subnet mask. If you have a + * dual-homed host it will return a broadcast address for both. If you have + * some VMs running on your host this will pick up the addresses for those + * as well--e.g. running VMWare on your laptop with a local IP this will also + * pick up a 192.168 address assigned to the VM by the host OS. + * + * @return set of all broadcast addresses + */ + public static Set<InetAddress> getBroadcastAddresses() + { + Set<InetAddress> broadcastAddresses = new HashSet<>(); + Enumeration interfaces; + + try { + interfaces = NetworkInterface.getNetworkInterfaces(); + + while (interfaces.hasMoreElements()) + { + NetworkInterface anInterface = (NetworkInterface) interfaces.nextElement(); + + if (anInterface.isUp()) + { + Iterator iterator = anInterface.getInterfaceAddresses().iterator(); + while (iterator.hasNext()) + { + InterfaceAddress anAddress = (InterfaceAddress) iterator.next(); + if ((anAddress == null || anAddress.getAddress().isLinkLocalAddress())) + { + continue; + } + + //System.out.println("Getting broadcast address for " + anAddress); + InetAddress broadcastAddress = anAddress.getBroadcast(); + if (broadcastAddress != null) + { + broadcastAddresses.add(broadcastAddress); + } + } + } + } + } + catch (SocketException e) + { + System.out.println("Problem with DisExamples.EspduSender.getBroadcastAddresses(), see exception trace:"); + System.out.println(e); + } + return broadcastAddresses; + } +} diff --git a/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FriscoFurrPduSender.java b/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FriscoFurrPduSender.java index e7804b68a0..b2adef0b68 100644 --- a/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FriscoFurrPduSender.java +++ b/deliverables/src/MV3500Cohort2018JulySeptember/FinalProject/FriscoFurrProject/FriscoFurrPduSender.java @@ -52,10 +52,12 @@ public class FriscoFurrPduSender // and add that PDU to a list. for (PduType pdu : PduType.values()) { Pdu aPdu = null; - + System.out.println(pdu); switch (pdu) // using enumeration values from edu.nps.moves.disenum.* { + case ENTITY_STATE: + System.out.println("Case: Enitity_State "+pdu+"\n"); aPdu = new EntityStatePdu(); EntityStatePdu espdu = (EntityStatePdu) aPdu; Marking marking = new Marking(); @@ -138,6 +140,7 @@ public class FriscoFurrPduSender if (aPdu != null) { generatedPdus.add(aPdu); + System.out.println("APDU container count "+generatedPdus.size()); } } -- GitLab