private final void socketrun() {
do {
if (link.socketport != 0) {
try {
Socket socket =
new Socket(InetAddress.getByName(getCodeBase().getHost()), link.socketport);
socket.setSoTimeout(30000);
socket.setTcpNoDelay(true);
link.s = socket;
} catch (Exception _ex) {
link.s = null;
}
link.socketport = 0;
}
if (link.runme != null) {
Thread thread = new Thread(link.runme);
thread.setDaemon(true);
thread.start();
link.runme = null;
}
if (link.iplookup != null) {
String s = "unknown";
try {
s = InetAddress.getByName(link.iplookup).getHostName();
} catch (Exception _ex) {
}
link.host = s;
link.iplookup = null;
}
try {
Thread.sleep(100L);
} catch (Exception _ex) {
}
} while (true);
}
private String detectAgentUrl(
HttpServer pServer, JolokiaServerConfig pConfig, String pContextPath) {
serverAddress = pServer.getAddress();
InetAddress realAddress;
int port;
if (serverAddress != null) {
realAddress = serverAddress.getAddress();
if (realAddress.isAnyLocalAddress()) {
try {
realAddress = NetworkUtil.getLocalAddress();
} catch (IOException e) {
try {
realAddress = InetAddress.getLocalHost();
} catch (UnknownHostException e1) {
// Ok, ok. We take the original one
realAddress = serverAddress.getAddress();
}
}
}
port = serverAddress.getPort();
} else {
realAddress = pConfig.getAddress();
port = pConfig.getPort();
}
return String.format(
"%s://%s:%d%s", pConfig.getProtocol(), realAddress.getHostAddress(), port, pContextPath);
}
/** 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();
}
/** 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);
}
}
}
// Check if the datagramsocket adaptor can send with a packet
// that has not been initialized with an address; the legacy
// datagram socket will send in this case
private static void test2() throws Exception {
DatagramChannel sndChannel = DatagramChannel.open();
sndChannel.socket().bind(null);
InetSocketAddress sender =
new InetSocketAddress(InetAddress.getLocalHost(), sndChannel.socket().getLocalPort());
DatagramChannel rcvChannel = DatagramChannel.open();
rcvChannel.socket().bind(null);
InetSocketAddress receiver =
new InetSocketAddress(InetAddress.getLocalHost(), rcvChannel.socket().getLocalPort());
rcvChannel.connect(sender);
sndChannel.connect(receiver);
byte b[] = "hello".getBytes("UTF-8");
DatagramPacket pkt = new DatagramPacket(b, b.length);
sndChannel.socket().send(pkt);
ByteBuffer bb = ByteBuffer.allocate(256);
rcvChannel.receive(bb);
bb.flip();
CharBuffer cb = Charset.forName("US-ASCII").newDecoder().decode(bb);
if (!cb.toString().startsWith("h")) throw new RuntimeException("Test failed");
// Check that the pkt got set with the target address;
// This is legacy behavior
if (!pkt.getSocketAddress().equals(receiver)) throw new RuntimeException("Test failed");
rcvChannel.close();
sndChannel.close();
}
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();
}
}
// Check if DatagramChannel.send while connected can include
// address without throwing
private static void test1() throws Exception {
DatagramChannel sndChannel = DatagramChannel.open();
sndChannel.socket().bind(null);
InetSocketAddress sender =
new InetSocketAddress(InetAddress.getLocalHost(), sndChannel.socket().getLocalPort());
DatagramChannel rcvChannel = DatagramChannel.open();
rcvChannel.socket().bind(null);
InetSocketAddress receiver =
new InetSocketAddress(InetAddress.getLocalHost(), rcvChannel.socket().getLocalPort());
rcvChannel.connect(sender);
sndChannel.connect(receiver);
ByteBuffer bb = ByteBuffer.allocate(256);
bb.put("hello".getBytes());
bb.flip();
int sent = sndChannel.send(bb, receiver);
bb.clear();
rcvChannel.receive(bb);
bb.flip();
CharBuffer cb = Charset.forName("US-ASCII").newDecoder().decode(bb);
if (!cb.toString().startsWith("h")) throw new RuntimeException("Test failed");
rcvChannel.close();
sndChannel.close();
}
// 获得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;
}
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());
}
/** 启动初始化，他确定网络中有多少个其它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());
}
}
/*========================================================================*/
public void init() {
/*========================================================================*/
final int port = 9901;
initComponents();
try {
/*-----------------------------------*/
/* Setup the socket's target address */
/*-----------------------------------*/
// InetAddress address = InetAddress.getByName("localhost");//local
InetAddress address = InetAddress.getLocalHost(); // local
System.out.println("Local host: " + address.toString());
Socket socket = new Socket(address, port);
/*--------------------------------*/
/* Setup the input/output streams */
/*--------------------------------*/
OutputStream os = socket.getOutputStream();
dos = new DataOutputStream(os);
InputStream is = socket.getInputStream();
dis = new DataInputStream(is);
System.out.println("Setup for all streams complete");
} catch (IOException ioe) {
System.out.println("Error connecting");
}
}
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();
}
}
/** Returns the address */
public InetAddress getAddress() {
try {
if (name == null) return InetAddress.getByAddress(address);
else return InetAddress.getByAddress(name.toString(), address);
} catch (UnknownHostException e) {
return null;
}
}
// 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;
}
}
// [JACKSON-484]
public void testInetAddress() throws IOException {
InetAddress address = MAPPER.readValue(quote("127.0.0.1"), InetAddress.class);
assertEquals("127.0.0.1", address.getHostAddress());
// should we try resolving host names? That requires connectivity...
final String HOST = "google.com";
address = MAPPER.readValue(quote(HOST), InetAddress.class);
assertEquals(HOST, address.getHostName());
}
/**
* 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);
}
/** Return the hostname of the local machine. */
public static String getLocalHost() {
String hostname = null;
try {
InetAddress ia = InetAddress.getLocalHost();
hostname = ia.getHostName();
} catch (UnknownHostException e) {
return "localhost";
}
return hostname;
}
/** Return the hostname of the local machine. */
public static String getLocalAddress() {
String address = null;
try {
InetAddress ia = InetAddress.getLocalHost();
address = ia.getHostAddress();
} catch (UnknownHostException e) {
return "127.0.0.1";
}
return address;
}
/**
* @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));
}
private void doConnect(InetSocketAddress addr) throws IOException {
dest = new Socket();
try {
dest.connect(addr, 10000);
} catch (SocketTimeoutException ex) {
sendError(HOST_UNREACHABLE);
return;
} catch (ConnectException cex) {
sendError(CONN_REFUSED);
return;
}
// Success
InetAddress iadd = addr.getAddress();
if (iadd instanceof Inet4Address) {
out.write(PROTO_VERS);
out.write(REQUEST_OK);
out.write(0);
out.write(IPV4);
out.write(iadd.getAddress());
} else if (iadd instanceof Inet6Address) {
out.write(PROTO_VERS);
out.write(REQUEST_OK);
out.write(0);
out.write(IPV6);
out.write(iadd.getAddress());
} else {
sendError(GENERAL_FAILURE);
return;
}
out.write((addr.getPort() >> 8) & 0xff);
out.write((addr.getPort() >> 0) & 0xff);
out.flush();
InputStream in2 = dest.getInputStream();
OutputStream out2 = dest.getOutputStream();
Tunnel tunnel = new Tunnel(in2, out);
tunnel.start();
int b = 0;
do {
// Note that the socket might be closed from another thread (the tunnel)
try {
b = in.read();
if (b == -1) {
in.close();
out2.close();
return;
}
out2.write(b);
} catch (IOException ioe) {
}
} while (!client.isClosed());
}
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;
}
/**
* 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;
}
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;
}
public AppFrame() {
super();
GlobalData.oFrame = this;
this.setSize(this.width, this.height);
this.toolkit = Toolkit.getDefaultToolkit();
Dimension w = toolkit.getScreenSize();
int fx = (int) w.getWidth();
int fy = (int) w.getHeight();
int wx = (fx - this.width) / 2;
int wy = (fy - this.getHeight()) / 2;
setLocation(wx, wy);
this.tracker = new MediaTracker(this);
String sHost = "";
try {
localAddr = InetAddress.getLocalHost();
if (localAddr.isLoopbackAddress()) {
localAddr = LinuxInetAddress.getLocalHost();
}
sHost = localAddr.getHostAddress();
} catch (UnknownHostException ex) {
sHost = "你的IP地址错误";
}
//
this.textLines[0] = "服务器正在运行.";
this.textLines[1] = "";
this.textLines[2] = "你的IP地址: " + sHost;
this.textLines[3] = "";
this.textLines[4] = "请打开你的手机客户端";
this.textLines[5] = "";
this.textLines[6] = "输入屏幕上显示的IP地址.";
//
try {
URL fileURL = this.getClass().getProtectionDomain().getCodeSource().getLocation();
String sBase = fileURL.toString();
if ("jar".equals(sBase.substring(sBase.length() - 3, sBase.length()))) {
jar = new JarFile(new File(fileURL.toURI()));
} else {
basePath = System.getProperty("user.dir") + "\\res\\";
}
} catch (Exception ex) {
this.textLines[1] = "exception: " + ex.toString();
}
}
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;
}
/** * @param args the command line arguments */
public static void main(String[] args) {
System.out.println("versió 0.1 del projecte prjava02");
try {
InetAddress adreça = InetAddress.getLocalHost();
String hostname = adreça.getHostName();
System.out.println("hostname=" + hostname);
System.out.println("Nom de l'usuari: " + System.getProperty("user.name"));
System.out.println("Carpeta Personal: " + System.getProperty("user.home"));
System.out.println("Sistema operatiu: " + System.getProperty("os.name"));
System.out.println("Versió OS: " + System.getProperty("os.version"));
System.out.println("Creació d'una branca del projecte prjava02 ");
System.out.println("Afegint més codi a la branca00 del projecte prjava02");
} catch (IOException e) {
}
}
public BroadcastClient(String ipAddress, int ipPort, String nicAddress, int nicPort)
throws IOException {
this.ipPort = ipPort; // Deprication
this.nicPort = nicPort;
this.type = Type.MULTICAST;
this.direction = Direction.RECEIVE;
try {
this.nicAddress = InetAddress.getByName(nicAddress);
this.ipAddress = InetAddress.getByName(ipAddress);
} catch (UnknownHostException e) {
}
socket = new MulticastSocket(this.nicPort);
socket.setInterface(this.nicAddress);
socket.joinGroup(this.ipAddress);
}
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());
}
}
