public static void main(String[] args) throws IOException, InterruptedException {
boolean running = true;
// udp protocol over a socket.
DatagramSocket socket = new DatagramSocket();
while (running) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
String[] inputs = line.split(" ");
if (inputs.length < 2) {
System.out.println("Usage: username command id");
socket.close();
return;
}
byte[] byteArr = (inputs[0] + " " + inputs[1] + " " + inputs[2]).getBytes();
// send request
byte[] buf = new byte[256];
InetAddress address = InetAddress.getByName("localhost");
DatagramPacket packet = new DatagramPacket(byteArr, byteArr.length, address, 4445);
socket.send(packet);
// get response
packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
// display response
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("From server: " + received);
}
// socket.close();
}
/** List file names */
public Enumeration nlst(String s) throws IOException {
InetAddress inetAddress = InetAddress.getLocalHost();
byte ab[] = inetAddress.getAddress();
serverSocket_ = new ServerSocket(0, 1);
StringBuffer sb = new StringBuffer(32);
sb.append("PORT ");
for (int i = 0; i < ab.length; i++) {
sb.append(String.valueOf(ab[i] & 255));
sb.append(",");
}
sb.append(String.valueOf(serverSocket_.getLocalPort() >>> 8 & 255));
sb.append(",");
sb.append(String.valueOf(serverSocket_.getLocalPort() & 255));
if (issueCommand(sb.toString()) != FTP_SUCCESS) {
serverSocket_.close();
throw new IOException(getResponseString());
} else if (issueCommand("NLST " + ((s == null) ? "" : s)) != FTP_SUCCESS) {
serverSocket_.close();
throw new IOException(getResponseString());
}
dataSocket_ = serverSocket_.accept();
serverSocket_.close();
serverSocket_ = null;
Vector v = readServerResponse_(dataSocket_.getInputStream());
dataSocket_.close();
dataSocket_ = null;
return (v == null) ? null : v.elements();
}
private void setupProxy(
ConnectivitySettings cs, int connectionType, InetSocketAddress inetSocketAddress) {
cs.setConnectionType(connectionType);
InetAddress address = inetSocketAddress.getAddress();
cs.setProxyHost((address != null) ? address.getHostAddress() : inetSocketAddress.getHostName());
cs.setProxyPort(inetSocketAddress.getPort());
}
/** Block datagrams from given source if a memory to receive all datagrams. */
void block(MembershipKeyImpl key, InetAddress source) throws IOException {
assert key.channel() == this;
assert key.sourceAddress() == null;
synchronized (stateLock) {
if (!key.isValid()) throw new IllegalStateException("key is no longer valid");
if (source.isAnyLocalAddress())
throw new IllegalArgumentException("Source address is a wildcard address");
if (source.isMulticastAddress())
throw new IllegalArgumentException("Source address is multicast address");
if (source.getClass() != key.group().getClass())
throw new IllegalArgumentException("Source address is different type to group");
int n;
if (key instanceof MembershipKeyImpl.Type6) {
MembershipKeyImpl.Type6 key6 = (MembershipKeyImpl.Type6) key;
n = Net.block6(fd, key6.groupAddress(), key6.index(), Net.inet6AsByteArray(source));
} else {
MembershipKeyImpl.Type4 key4 = (MembershipKeyImpl.Type4) key;
n = Net.block4(fd, key4.groupAddress(), key4.interfaceAddress(), Net.inet4AsInt(source));
}
if (n == IOStatus.UNAVAILABLE) {
// ancient kernel
throw new UnsupportedOperationException();
}
}
}
/** 启动初始化，他确定网络中有多少个其它UDPBase和相关的信息 */
public void initNet() throws UDPBaseException {
try {
mainThread = new SoleThread(this);
localIP = InetAddress.getLocalHost().getHostAddress();
int i = localIP.lastIndexOf('.');
BROADCAST_ADDR = localIP.substring(0, i) + ".255";
// System.out.println ("lip=="+localIP) ;
// sendSocket = new DatagramSocket () ;
// recvSocket = new MulticastSocket (RECV_PORT) ;
recvSocket = new DatagramSocket(RECV_PORT);
sendSocket = recvSocket;
// recvAckSocket = new MulticastSocket (RECV_ACK_PORT) ;
group = InetAddress.getByName(BROADCAST_ADDR);
// recvSocket.joinGroup (group) ;
// recvAckSocket.joinGroup (group) ;
procMsgThd = new ProcMsgThd();
procMsgThd.start();
//
mainThread.start();
} catch (Exception e) {
e.printStackTrace();
throw new UDPBaseException("UDPBase init() error=\n" + e.toString());
}
}
/** Creates the server. */
public static void main(String args[]) {
client = null;
ServerSocket server = null;
try {
System.out.print("\nCreating Server...\n");
// creates the server
server = new ServerSocket(8008);
System.out.print("Created\n");
// get the ip Address and the host name.
InetAddress localAddr = InetAddress.getLocalHost();
System.out.println("IP address: " + localAddr.getHostAddress());
System.out.println("Hostname: " + localAddr.getHostName());
} catch (IOException e) {
// sends a
System.out.println("IO" + e);
}
// constantly checks for a new aocket trying to attach itself to the trhead
while (true) {
try {
client = server.accept();
// create a new thread.
FinalMultiThread thr = new FinalMultiThread(client);
System.out.print(client.getInetAddress() + " : " + thr.getUserName() + "\n");
CliList.add(thr);
current++;
thr.start();
} catch (IOException e) {
System.out.println(e);
}
}
}
static void readConfig() {
tracker_ip = COConfigurationManager.getStringParameter("Tracker IP", "");
tracker_ip = UrlUtils.expandIPV6Host(tracker_ip);
String override_ips = COConfigurationManager.getStringParameter("Override Ip", "");
StringTokenizer tok = new StringTokenizer(override_ips, ";");
Map new_override_map = new HashMap();
while (tok.hasMoreTokens()) {
String ip = tok.nextToken().trim();
if (ip.length() > 0) {
new_override_map.put(AENetworkClassifier.categoriseAddress(ip), ip);
}
}
override_map = new_override_map;
InetAddress bad = NetworkAdmin.getSingleton().getSingleHomedServiceBindAddress();
if (bad == null || bad.isAnyLocalAddress()) {
bind_ip = "";
} else {
bind_ip = bad.getHostAddress();
}
}
private Core() {
boolean f = false;
try {
for (Enumeration en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
NetworkInterface intf = (NetworkInterface) en.nextElement();
for (Enumeration enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
InetAddress inetAddress = (InetAddress) enumIpAddr.nextElement();
if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
String ipAddress = inetAddress.getHostAddress().toString();
this.ip = inetAddress;
f = true;
break;
}
}
if (f) break;
}
} catch (SocketException ex) {
ex.printStackTrace();
System.exit(1);
}
this.teams = new HashMap<String, Team>();
this.judges = new HashMap<String, Judge>();
this.problems = new HashMap<String, ProblemInfo>();
this.scheduler = new Scheduler();
this.timer = new ContestTimer(300 * 60);
try {
readConfigure();
} catch (FileNotFoundException e) {
e.printStackTrace();
System.exit(1);
}
this.scoreBoardHttpServer = new ScoreBoardHttpServer(this.scoreBoardPort);
}
// function to do the join use case
public static void share() throws Exception {
HttpPost method = new HttpPost(url + "/share");
String ipAddress = null;
Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
while (en.hasMoreElements()) {
NetworkInterface ni = (NetworkInterface) en.nextElement();
if (ni.getName().equals("eth0")) {
Enumeration<InetAddress> en2 = ni.getInetAddresses();
while (en2.hasMoreElements()) {
InetAddress ip = (InetAddress) en2.nextElement();
if (ip instanceof Inet4Address) {
ipAddress = ip.getHostAddress();
break;
}
}
break;
}
}
method.setEntity(new StringEntity(username + ';' + ipAddress, "UTF-8"));
try {
ResponseHandler<String> responseHandler = new BasicResponseHandler();
connIp = client.execute(method, responseHandler);
} catch (IOException e) {
System.err.println("Fatal transport error: " + e.getMessage());
e.printStackTrace();
}
// get present time
date = new Date();
long start = date.getTime();
// Execute the vishwa share process
Process p = Runtime.getRuntime().exec("java -jar vishwa/JVishwa.jar " + connIp);
String ch = "alive";
System.out.println("Type kill to unjoin from the grid");
while (!ch.equals("kill")) {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
ch = in.readLine();
}
p.destroy();
date = new Date();
long end = date.getTime();
long durationInt = end - start;
String duration = String.valueOf(durationInt);
method = new HttpPost(url + "/shareAck");
method.setEntity(new StringEntity(username + ";" + duration, "UTF-8"));
try {
client.execute(method);
} catch (IOException e) {
System.err.println("Fatal transport error: " + e.getMessage());
e.printStackTrace();
}
}
// 获得IP地址
public static String getIpAddr(HttpServletRequest request) {
String ipAddress = null;
ipAddress = request.getHeader("x-forwarded-for");
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
ipAddress = request.getRemoteAddr();
if (ipAddress.equals("127.0.0.1")) {
// 根据网卡取本机配置的IP
InetAddress inet = null;
try {
inet = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
e.printStackTrace();
}
ipAddress = inet.getHostAddress();
}
}
// 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
// = 15
if (ipAddress.indexOf(",") > 0) {
ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
}
}
return ipAddress;
}
// Check for an IP, since this seems to be safer to return then a plain name
private String getIpIfPossible(String pHost) {
try {
InetAddress address = InetAddress.getByName(pHost);
return address.getHostAddress();
} catch (UnknownHostException e) {
return pHost;
}
}
public byte[] getRAddr() {
try {
InetAddress addr = InetAddress.getByName(host);
return addr.getAddress();
} catch (UnknownHostException e) {
System.err.println("NCCPConnection::getRAddr Don't know about host: ");
return null;
}
}
/**
* @throws RemoteException
* @throws UnknownHostException
*/
public void stabilize() throws RemoteException, UnknownHostException {
ChordMessageInterface succ = rmiChord(successor.getIp(), successor.getPort());
Finger x = succ.getPredecessor();
if (ino(x.getId(), i, successor.getId())) {
successor = x;
}
InetAddress ip = InetAddress.getLocalHost();
succ = rmiChord(successor.getIp(), successor.getPort());
succ.notify(new Finger(ip.getHostAddress(), port, i));
}
// ---------------------------------------------------------
// decide whether two host names (h1, h2) refer to same IP
// ---------------------------------------------------------
public static boolean sameHost(String h1, String h2) {
try {
String a1 = InetAddress.getByName(h1).getHostAddress();
String a2 = InetAddress.getByName(h2).getHostAddress();
if (a1.equals(a2)) return true;
} catch (Exception e) {
System.out.println(e);
}
return false;
}
/**
* Creates a SimpleResolver that will query the specified host
*
* @exception UnknownHostException Failure occurred while finding the host
*/
public SimpleResolver(String hostname) throws UnknownHostException {
if (hostname == null) {
hostname = ResolverConfig.getCurrentConfig().server();
if (hostname == null) hostname = defaultResolver;
}
InetAddress addr;
if (hostname.equals("0")) addr = InetAddress.getLocalHost();
else addr = InetAddress.getByName(hostname);
address = new InetSocketAddress(addr, DEFAULT_PORT);
}
private Descrittore contatta_server(String nome) {
// variabili per l'RMI
RMIServerInt serv = null; // server
Descrittore descr_rit = null; // descrittore ritornato
if (nome == null) {
System.out.println("## contatta_server di Download ha ricevuto parametro null ! ");
return null;
}
System.out.println("@ provo a contattare il server RMI ");
// ################ RMI ################
if (System.getSecurityManager() == null) {
System.setSecurityManager(new SecurityManager());
}
Object o = null;
try {
// o = Naming.lookup("rmi://192.168.0.10:1099/srmi");
Registry registry = LocateRegistry.getRegistry(server.getHostAddress());
o = registry.lookup("srmi");
} catch (RemoteException e) {
System.out.println("## Problemi nell'RMI di Download - contatta_server di " + nome);
e.printStackTrace();
} catch (NotBoundException e) {
System.out.println("## Problemi nell'RMI di Download - contatta_server di " + nome);
e.printStackTrace();
}
if (o == null) {
System.out.println(
"## l'RMI di Download - contatta_server di " + nome + " ha ritornato l'oggetto o null");
return null;
}
serv = (RMIServerInt) o;
try {
descr_rit = serv.lookup(nome, InetAddress.getLocalHost());
} catch (RemoteException e) {
e.printStackTrace();
System.out.println("## Problemi con Lookup di " + nome);
return null;
} catch (UnknownHostException e) {
e.printStackTrace();
System.out.println("## Problemi con Lookup di " + nome);
return null;
}
return descr_rit;
}
public String getLocalAddress() {
InetAddress mcastAddr = ssdpMultiGroup.getAddress();
Enumeration addrs = ssdpMultiIf.getInetAddresses();
while (addrs.hasMoreElements()) {
InetAddress addr = (InetAddress) addrs.nextElement();
if (mcastAddr instanceof Inet6Address && addr instanceof Inet6Address)
return addr.getHostAddress();
if (mcastAddr instanceof Inet4Address && addr instanceof Inet4Address)
return addr.getHostAddress();
}
return "";
}
protected String getHostName() {
String res = ConfigManager.getPlatformHostname();
if (res == null) {
try {
InetAddress inet = InetAddress.getLocalHost();
return inet.getHostName();
} catch (UnknownHostException e) {
log.warning("Can't get hostname", e);
return "unknown";
}
}
return res;
}
/**
* Returns the name of the localhost. If that cannot be found it will return <code>localhost
* </code>.
*
* @return my host
*/
public static String myHost() {
String str = null;
try {
InetAddress inetA = InetAddress.getLocalHost();
str = inetA.getHostName();
} catch (UnknownHostException exc) {
}
if (str == null) {
str = "localhost";
}
return str;
}
public String detectPPP() {
try {
List<String> linkPPP = new ArrayList<String>();
List<String> linkDSL = new ArrayList<String>();
Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
// System.out.println("NETS VALUES"+" "+nets);
// System.out.println("INITIALY VALUES"+" "+linkPPP);
for (NetworkInterface netInf : Collections.list(nets)) {
// System.out.println("netInf VALUES"+" "+netInf);
if (!netInf.isLoopback()) {
if (netInf.isPointToPoint()) {
// System.out.println("in point to point");
// System.out.println("netInf VALUES"+" "+netInf);
Enumeration<InetAddress> inetAdd = netInf.getInetAddresses();
// System.out.println("inetAdd VALUES"+" "+inetAdd);
for (InetAddress inet : Collections.list(inetAdd)) {
// System.out.println("inet vales in the ineer loop"+" "+inet);
// System.out.println("linkPPP vales before add in the ineer loop"+" "+linkPPP);
linkPPP.add(inet.getHostAddress()); //
// System.out.println("linkPPP vales after add in the ineer loop"+" "+linkPPP);
// System.out.println("IP:"+" "+inet.getHostAddress());
}
} else {
Enumeration<InetAddress> inetAdd = netInf.getInetAddresses();
for (InetAddress inet : Collections.list(inetAdd)) {
linkDSL.add(inet.getHostAddress());
}
}
}
}
// System.out.println("FINAL VALUE of linkPPP"+" "+linkPPP.get(0));
// System.out.println("FINAL VALUES DSL"+" "+linkDSL);
int i = linkPPP.size();
if (i != 0) {
// System.out.println("linkPPP"+" "+linkPPP.get(i-1));
return linkPPP.get(i - 1) + ",y";
// return linkPPP.get(0)+",y";
} else if (linkDSL.size() != 0) return linkDSL.get(i - 1) + ",n";
// return linkDSL.get(0)+",n";
else return "127.0.0.1,n";
} catch (SocketException e) {
// e.printStackTrace();
System.err.println("exception in ");
}
return "127.0.0.1,n";
}
public int send(ByteBuffer src, SocketAddress target) throws IOException {
if (src == null) throw new NullPointerException();
synchronized (writeLock) {
ensureOpen();
InetSocketAddress isa = Net.checkAddress(target);
InetAddress ia = isa.getAddress();
if (ia == null) throw new IOException("Target address not resolved");
synchronized (stateLock) {
if (!isConnected()) {
if (target == null) throw new NullPointerException();
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
if (ia.isMulticastAddress()) {
sm.checkMulticast(ia);
} else {
sm.checkConnect(ia.getHostAddress(), isa.getPort());
}
}
} else { // Connected case; Check address then write
if (!target.equals(remoteAddress)) {
throw new IllegalArgumentException("Connected address not equal to target address");
}
return write(src);
}
}
int n = 0;
try {
begin();
if (!isOpen()) return 0;
writerThread = NativeThread.current();
do {
n = send(fd, src, isa);
} while ((n == IOStatus.INTERRUPTED) && isOpen());
synchronized (stateLock) {
if (isOpen() && (localAddress == null)) {
localAddress = Net.localAddress(fd);
}
}
return IOStatus.normalize(n);
} finally {
writerThread = 0;
end((n > 0) || (n == IOStatus.UNAVAILABLE));
assert IOStatus.check(n);
}
}
}
private List<String> getServerInterfaces() {
List<String> bindInterfaces = new ArrayList<String>();
String interfaceName = JiveGlobals.getXMLProperty("network.interface");
String bindInterface = null;
if (interfaceName != null) {
if (interfaceName.trim().length() > 0) {
bindInterface = interfaceName;
}
}
int adminPort = JiveGlobals.getXMLProperty("adminConsole.port", 9090);
int adminSecurePort = JiveGlobals.getXMLProperty("adminConsole.securePort", 9091);
if (bindInterface == null) {
try {
Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
for (NetworkInterface netInterface : Collections.list(nets)) {
Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
for (InetAddress address : Collections.list(addresses)) {
if ("127.0.0.1".equals(address.getHostAddress())) {
continue;
}
if (address.getHostAddress().startsWith("0.")) {
continue;
}
Socket socket = new Socket();
InetSocketAddress remoteAddress =
new InetSocketAddress(address, adminPort > 0 ? adminPort : adminSecurePort);
try {
socket.connect(remoteAddress);
bindInterfaces.add(address.getHostAddress());
break;
} catch (IOException e) {
// Ignore this address. Let's hope there is more addresses to validate
}
}
}
} catch (SocketException e) {
// We failed to discover a valid IP address where the admin console is running
return null;
}
} else {
bindInterfaces.add(bindInterface);
}
return bindInterfaces;
}
public static boolean isServer() throws Exception {
boolean isServer = false;
InetAddress IP = InetAddress.getLocalHost();
try {
if (IP.getHostAddress().toString().equals("54.186.249.201")
|| IP.getHostAddress().toString().equals("172.31.40.246")
|| IP.getHostAddress().toString().equals("128.199.237.142")
|| IP.getHostAddress().toString().equals("saracourierservice.tk")) {
isServer = true;
}
} catch (Exception ex) {
throw ex;
}
return isServer;
}
private void setMailCredential(CIJob job) {
if (debugEnabled) {
S_LOGGER.debug("Entering Method CIManagerImpl.setMailCredential");
}
try {
String jenkinsTemplateDir = Utility.getJenkinsTemplateDir();
String mailFilePath = jenkinsTemplateDir + MAIL + HYPHEN + CREDENTIAL_XML;
if (debugEnabled) {
S_LOGGER.debug("configFilePath ... " + mailFilePath);
}
File mailFile = new File(mailFilePath);
SvnProcessor processor = new SvnProcessor(mailFile);
// DataInputStream in = new DataInputStream(new FileInputStream(mailFile));
// while (in.available() != 0) {
// System.out.println(in.readLine());
// }
// in.close();
// Mail have to go with jenkins running email address
InetAddress ownIP = InetAddress.getLocalHost();
processor.changeNodeValue(
CI_HUDSONURL,
HTTP_PROTOCOL
+ PROTOCOL_POSTFIX
+ ownIP.getHostAddress()
+ COLON
+ job.getJenkinsPort()
+ FORWARD_SLASH
+ CI
+ FORWARD_SLASH);
processor.changeNodeValue("smtpAuthUsername", job.getSenderEmailId());
processor.changeNodeValue("smtpAuthPassword", job.getSenderEmailPassword());
processor.changeNodeValue("adminAddress", job.getSenderEmailId());
// jenkins home location
String jenkinsJobHome = System.getenv(JENKINS_HOME);
StringBuilder builder = new StringBuilder(jenkinsJobHome);
builder.append(File.separator);
processor.writeStream(new File(builder.toString() + CI_MAILER_XML));
} catch (Exception e) {
S_LOGGER.error(
"Entered into the catch block of CIManagerImpl.setMailCredential "
+ e.getLocalizedMessage());
}
}
/**
* Konstruktor
*
* @param configFile Jmeno konfiguracniho souboru
*/
public Server(String configFile) {
setServerConfig(new ServerConfig(configFile));
setPort(getServerConfig().getPort());
try {
setBindAddress(InetAddress.getByName(getServerConfig().getBindAddress()));
} catch (UnknownHostException e) {
System.err.println("Bind adresa neni platna!");
System.exit(-1);
}
try {
setServerSocket(new ServerSocket(getPort(), 0, getBindAddress()));
} catch (IOException e) {
System.err.println("Chyba startu ServerSocketu");
System.exit(-1);
}
System.out.println("Server spusten");
clients = new Hashtable<String, ServerThread>();
boolean running = true;
while (running) {
try {
accept();
} catch (IOException e) {
System.err.println("Chyba acceptu");
running = false;
}
}
}
@Override
public DatagramChannel bind(SocketAddress local) throws IOException {
synchronized (readLock) {
synchronized (writeLock) {
synchronized (stateLock) {
ensureOpen();
if (localAddress != null) throw new AlreadyBoundException();
InetSocketAddress isa;
if (local == null) {
// only Inet4Address allowed with IPv4 socket
if (family == StandardProtocolFamily.INET) {
isa = new InetSocketAddress(InetAddress.getByName("0.0.0.0"), 0);
} else {
isa = new InetSocketAddress(0);
}
} else {
isa = Net.checkAddress(local);
// only Inet4Address allowed with IPv4 socket
if (family == StandardProtocolFamily.INET) {
InetAddress addr = isa.getAddress();
if (!(addr instanceof Inet4Address)) throw new UnsupportedAddressTypeException();
}
}
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkListen(isa.getPort());
}
Net.bind(family, fd, isa.getAddress(), isa.getPort());
localAddress = Net.localAddress(fd);
}
}
}
return this;
}
public static void main(String[] args) {
int port = 5555;
DatagramSocket socket;
socket = null;
try {
socket = new DatagramSocket(port);
socket.setBroadcast(true);
socket.connect(InetAddress.getByName("255.255.255.255"), 5555);
} catch (Exception e) {
System.err.println("Connection failed. " + e.getMessage());
}
while (true) {
String message = "hey";
byte[] buf = message.getBytes();
DatagramPacket packet = new DatagramPacket(buf, buf.length);
try {
socket.send(packet);
} catch (Exception e) {
System.err.println("Sending failed. " + e.getMessage());
}
}
}
/**
* Workaround for the problem encountered in certains JDKs that a thread listening on a socket
* cannot be interrupted. Therefore we just send a dummy datagram packet so that the thread 'wakes
* up' and realizes it has to terminate. Should be removed when all JDKs support
* Thread.interrupt() on reads. Uses sock t send dummy packet, so this socket has to be still
* alive.
*
* @param dest The destination host. Will be local host if null
* @param port The destination port
*/
void sendDummyPacket(InetAddress dest, int port) {
DatagramPacket packet;
byte[] buf = {0};
if (dest == null) {
try {
dest = InetAddress.getLocalHost();
} catch (Exception e) {
}
}
if (Trace.debug) {
Trace.info("UDP.sendDummyPacket()", "sending packet to " + dest + ":" + port);
}
if (sock == null || dest == null) {
Trace.warn(
"UDP.sendDummyPacket()", "sock was null or dest was null, cannot send dummy packet");
return;
}
packet = new DatagramPacket(buf, buf.length, dest, port);
try {
sock.send(packet);
} catch (Throwable e) {
Trace.error(
"UDP.sendDummyPacket()",
"exception sending dummy packet to " + dest + ":" + port + ": " + e);
}
}
public Process(String name, int pid, int n) {
this.name = name;
this.port = Utils.REGISTRAR_PORT + pid;
this.host = "UNKNOWN";
try {
this.host = (InetAddress.getLocalHost()).getHostName();
} catch (UnknownHostException e) {
String msg = String.format("Error: getHostName() failed at %s.", this.getInfo());
System.err.println(msg);
System.err.println(e.getMessage());
System.exit(1);
}
this.pid = pid;
this.n = n;
random = new Random();
/* Accepts connections from one of Registrar's worker threads */
new Thread(new Listener(this)).start();
/* Connect to registrar */
socket = connect();
init();
Utils.out(pid, "Connected.");
}
Target(String host) {
try {
address = new InetSocketAddress(InetAddress.getByName(host), 80);
} catch (IOException x) {
failure = x;
}
}
