/*
* Connect a UDP socket, disconnect it, then send and recv on it.
* It will fail on Linux if we don't silently bind(2) again at the
* end of DatagramSocket.disconnect().
*/
private static void testConnectedUDP(InetAddress addr) throws Exception {
try {
DatagramSocket s = new DatagramSocket(0, addr);
DatagramSocket ss = new DatagramSocket(0, addr);
System.out.print("\tconnect...");
s.connect(ss.getLocalAddress(), ss.getLocalPort());
System.out.print("disconnect...");
s.disconnect();
byte[] data = {0, 1, 2};
DatagramPacket p =
new DatagramPacket(data, data.length, s.getLocalAddress(), s.getLocalPort());
s.setSoTimeout(10000);
System.out.print("send...");
s.send(p);
System.out.print("recv...");
s.receive(p);
System.out.println("OK");
ss.close();
s.close();
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
/** Generic constructor for the name service interface */
public LeetActive(String svc_host, int svc_port, int portNum) {
try {
nameServer = new DatagramSocket();
nameServer.setSoTimeout(3000);
nameServer.connect(InetAddress.getByName(svc_host), svc_port);
} catch (Exception e) {
System.err.println("LA " + e);
}
this.portNum = portNum;
hostList = new ArrayList();
}
/**
* Initialize a new Substrate object.
*
* @param myIp is the IP address to bind to the socket
* @param port is the port number to bind to the socket (may be 0)
* @param peerAdr is the IP address/port pair for the peer host (may be null, if this object is
* being used in a server)
* @param discProb is a discard probability used to randomly discard packets received from the Rdt
* object
* @param debug is a flag; if it is 1, each packet sent and received is printed out
*/
Substrate(InetAddress myIp, int port, InetSocketAddress peerAdr, double discProb, boolean debug) {
// initialize instance variables
this.peerAdr = peerAdr;
this.discProb = discProb;
this.debug = debug;
// open and configure socket with timeout
sock = null;
try {
sock = new DatagramSocket(port, myIp);
sock.setSoTimeout(100);
} catch (Exception e) {
System.out.println("unable to create socket");
System.exit(1);
}
sndr = new Sender(sock, peerAdr, discProb, debug);
rcvr = new Receiver(sock, peerAdr, sndr, debug);
}
protected Searcher(boolean _persistent, boolean _async) throws DeviceManagerException {
try {
int last_port = COConfigurationManager.getIntParameter("devices.tivo.net.tcp.port", 0);
if (last_port > 0) {
try {
ServerSocket ss = new ServerSocket(last_port);
ss.setReuseAddress(true);
ss.close();
} catch (Throwable e) {
last_port = 0;
}
}
twc = plugin_interface.getTracker().createWebContext(last_port, Tracker.PR_HTTP);
tcp_port = twc.getURLs()[0].getPort();
COConfigurationManager.setParameter("devices.tivo.net.tcp.port", tcp_port);
twc.addPageGenerator(
new TrackerWebPageGenerator() {
public boolean generate(
TrackerWebPageRequest request, TrackerWebPageResponse response)
throws IOException {
String id = (String) request.getHeaders().get("tsn");
if (id == null) {
id = (String) request.getHeaders().get("tivo_tcd_id");
}
if (id != null && is_enabled) {
persistent = true;
DeviceTivo tivo =
foundTiVo(request.getClientAddress2().getAddress(), id, null, null);
return (tivo.generate(request, response));
}
return (false);
}
});
control_socket = new DatagramSocket(null);
control_socket.setReuseAddress(true);
try {
control_socket.setSoTimeout(60 * 1000);
} catch (Throwable e) {
}
InetAddress bind = NetworkAdmin.getSingleton().getSingleHomedServiceBindAddress();
control_socket.bind(new InetSocketAddress(bind, CONTROL_PORT));
timer_event =
SimpleTimer.addPeriodicEvent(
"Tivo:Beacon",
60 * 1000,
new TimerEventPerformer() {
public void perform(TimerEvent event) {
if (!(manager_destroyed || search_destroyed)) {
sendBeacon();
}
// see if time to auto-shutdown searching
if (!persistent) {
synchronized (DeviceTivoManager.this) {
if (SystemTime.getMonotonousTime() - start >= LIFE_MILLIS) {
log("Terminating search, no devices found");
current_search = null;
destroy();
}
}
}
}
});
final AESemaphore start_sem = new AESemaphore("TiVo:CtrlListener");
new AEThread2("TiVo:CtrlListener", true) {
public void run() {
start_sem.release();
long successful_accepts = 0;
long failed_accepts = 0;
while (!(manager_destroyed || search_destroyed)) {
try {
byte[] buf = new byte[8192];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
control_socket.receive(packet);
successful_accepts++;
failed_accepts = 0;
if (receiveBeacon(packet.getAddress(), packet.getData(), packet.getLength())) {
persistent = true;
}
} catch (SocketTimeoutException e) {
} catch (Throwable e) {
if (control_socket != null && !search_destroyed && !manager_destroyed) {
failed_accepts++;
log("UDP receive on port " + CONTROL_PORT + " failed", e);
}
if ((failed_accepts > 100 && successful_accepts == 0) || failed_accepts > 1000) {
log(" too many failures, abandoning");
break;
}
}
}
}
}.start();
if (_async) {
new DelayedEvent(
"search:delay",
5000,
new AERunnable() {
public void runSupport() {
sendBeacon();
}
});
} else {
start_sem.reserve(5000);
sendBeacon();
}
log("Initiated device search");
} catch (Throwable e) {
log("Failed to initialise search", e);
destroy();
throw (new DeviceManagerException("Creation failed", e));
}
}
public static void main(String[] args) throws Exception {
//////////////////// STAGE A//////////////////////////////////////////
int portNum = 12235;
// InetAddress ip=InetAddress.getLocalHost();
InetAddress ip = InetAddress.getByName("attu2.cs.washington.edu");
DatagramSocket sock = new DatagramSocket();
byte[] response = new byte[HEADER_SIZE + 16];
String partA = "hello world\0";
byte[] buf = createBuffer(partA.getBytes(), 0, STEP1);
DatagramPacket packet = new DatagramPacket(buf, buf.length, ip, portNum);
sock.send(packet);
packet = new DatagramPacket(response, response.length);
sock.receive(packet);
int[] a2 = partA(response); // putting the 4 ints from server into int[]
// for (int i = 0; i < a2.length; i++) {
// System.out.println(a2[i]);
// }
////////////////////// STAGE B////////////////////////////////////////
int numSent = 0;
int send = a2[0];
int len = a2[1];
portNum = a2[2];
int secretA = a2[3];
System.out.println("The secrets:\nA: " + secretA);
sock.setSoTimeout(500); // .5s
while (numSent < send) {
// create packet
buf = createBuffer(partB(numSent, len), secretA, STEP1);
packet = new DatagramPacket(buf, buf.length, ip, portNum);
sock.send(packet);
// send packet
try {
sock.receive(new DatagramPacket(response, response.length));
numSent++;
ByteBuffer temp = ByteBuffer.wrap(response);
checkHeader(temp, 4, secretA, STEP1);
// System.out.println(temp.getInt()); // For debug. See if counts up by 1
} catch (SocketTimeoutException e) {
// if there's a timeout, try again
continue;
}
}
response = new byte[HEADER_SIZE + 8]; // 8 bytes -- 2 integers
sock.receive(new DatagramPacket(response, response.length));
ByteBuffer bb = ByteBuffer.wrap(response);
// Header
checkHeader(bb, 8, secretA, STEP2);
// reset the port number to the one given
portNum = bb.getInt();
int secretB = bb.getInt();
System.out.println("B: " + secretB);
// close the UDP socket
sock.close();
/////////////////////////// STAGE C///////////////////////////////////
Socket socket = new Socket(ip, portNum);
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
response = new byte[HEADER_SIZE + 16]; // 4 ints given to us this time
in.read(response);
bb = ByteBuffer.wrap(response);
// Header
checkHeader(bb, 13, secretB, STEP2);
// num2 len2 secretC and char c
numSent = bb.getInt();
len = bb.getInt();
int secretC = bb.getInt();
System.out.println("C: " + secretC);
// stage d
byte c = (byte) bb.getChar();
buf = new byte[len];
Arrays.fill(buf, c);
for (int i = 0; i < numSent; i++) {
byte[] b = createBuffer(buf, secretC, STEP1);
out.write(b);
}
response = new byte[12 + 4]; // one integer. secretD plus header
in.read(response);
bb = ByteBuffer.wrap(response);
checkHeader(bb, 4, secretC, STEP2);
int secretD = bb.getInt();
socket.close();
in.close();
out.close();
System.out.println("D: " + secretD);
}
public static void main(String args[]) throws Exception {
DatagramSocket r_clients = null, s_clients = null;
MulticastSocket servers = null, b_clients = null;
local = Integer.parseInt(args[1]);
rec = Integer.parseInt(args[0]);
System.out.println("Recieving arp on port " + rec + "...");
System.out.println("Recieving reply arp on port " + (rec + 1) + "...");
System.out.println("\nEmulating gateway on port " + local + "\nWaiting...");
try {
r_clients = new DatagramSocket(rec);
s_clients = new DatagramSocket(rec + 1);
b_clients = new MulticastSocket(local);
b_clients.joinGroup(InetAddress.getByName(group));
servers = new MulticastSocket(serv_port);
servers.joinGroup(InetAddress.getByName(group));
servers.setSoTimeout(10);
s_clients.setSoTimeout(10);
b_clients.setSoTimeout(10);
r_clients.setSoTimeout(10);
} catch (Exception e) {
System.out.println("error: " + e.toString());
System.exit(1);
}
byte arp_buf[] = new byte[28];
DatagramPacket arp_packet = new DatagramPacket(arp_buf, arp_buf.length);
while (true) {
try {
servers.receive(arp_packet);
System.out.println("\nGot arp from servers");
System.out.println("Sending arp to local computers");
arp_packet.setAddress(InetAddress.getByName(group));
arp_packet.setPort(local);
try {
b_clients.send(arp_packet, (byte) 255);
} catch (Exception e3) {
}
} catch (Exception e) {
try {
r_clients.receive(arp_packet);
System.out.println("\nGot arp from client");
System.out.println("Sending ARP");
arp_packet.setAddress(InetAddress.getByName(group));
arp_packet.setPort(serv_port);
try {
servers.send(arp_packet, (byte) 255);
} catch (Exception e3) {
}
} catch (Exception e2) {
try {
s_clients.receive(arp_packet);
System.out.println("\nGot reply arp from client");
arp_packet.setAddress(InetAddress.getByName(group));
arp_packet.setPort(2500);
try {
s_clients.send(arp_packet);
} catch (Exception e3) {
}
} catch (Exception e4) {
}
}
}
}
}
