Пример #1
0
  // 获得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;
  }
Пример #2
0
  /**
   * Creates a new, empty SessionDescription. The session is set as follows:
   *
   * <p>v=0
   *
   * <p>o=this.createOrigin ("user", InetAddress.getLocalHost().toString());
   *
   * <p>s=-
   *
   * <p>t=0 0
   *
   * @throws SdpException SdpException, - if there is a problem constructing the SessionDescription.
   * @return a new, empty SessionDescription.
   */
  public SessionDescription createSessionDescription() throws SdpException {
    SessionDescriptionImpl sessionDescriptionImpl = new SessionDescriptionImpl();

    ProtoVersionField ProtoVersionField = new ProtoVersionField();
    ProtoVersionField.setVersion(0);
    sessionDescriptionImpl.setVersion(ProtoVersionField);

    OriginField originImpl = null;
    try {
      originImpl =
          (OriginField) this.createOrigin("user", InetAddress.getLocalHost().getHostAddress());
    } catch (UnknownHostException e) {
      e.printStackTrace();
    }
    sessionDescriptionImpl.setOrigin(originImpl);

    SessionNameField sessionNameImpl = new SessionNameField();
    sessionNameImpl.setValue("-");
    sessionDescriptionImpl.setSessionName(sessionNameImpl);

    TimeDescriptionImpl timeDescriptionImpl = new TimeDescriptionImpl();
    TimeField timeImpl = new TimeField();
    timeImpl.setZero();
    timeDescriptionImpl.setTime(timeImpl);
    Vector times = new Vector();
    times.addElement(timeDescriptionImpl);
    sessionDescriptionImpl.setTimeDescriptions(times);

    sessionDescriptionsList.addElement(sessionDescriptionImpl);
    return sessionDescriptionImpl;
  }
Пример #3
0
  private boolean connectSPPMon() {
    if (state == ConnectionEvent.CONNECTION_PENDING) {
      ExpCoordinator.print(
          new String("NCCPConnection(" + host + ", " + port + ").connect connection pending"), 0);
      while (state == ConnectionEvent.CONNECTION_PENDING) {
        try {
          Thread.sleep(500);
        } catch (java.lang.InterruptedException e) {
        }
      }
      return (isConnected());
    }

    state = ConnectionEvent.CONNECTION_PENDING;
    if (nonProxy != null) {
      try {
        nonProxy.connect();
      } catch (UnknownHostException e) {
        boolean rtn = informUserError("Don't know about host: " + host + ":" + e.getMessage());
        return rtn;
      } catch (SocketTimeoutException e) {
        boolean rtn = informUserError("Socket time out for " + host + ":" + e.getMessage());
        return rtn;
      } catch (IOException e) {
        boolean rtn = informUserError("Couldnt get I/O for " + host + ":" + e.getMessage());
        return rtn;
      }
    }
    return (isConnected());
  }
Пример #4
0
 /**
  * 获取本机ip
  *
  * @return
  */
 public static String GetIpAdd() {
   try {
     return InetAddress.getLocalHost().getHostAddress();
   } catch (UnknownHostException e) { // TODO 自动生成 catch 块
     return e.getMessage(); // e.printStackTrace();
   }
 }
  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.");
  }
Пример #6
0
  public Server() {
    try {
      ServerSocket ss = new ServerSocket(SERVER_PORT);

      Socket s = ss.accept();

      InputStream is = s.getInputStream();
      OutputStream out = s.getOutputStream();
      InputStreamReader isr = new InputStreamReader(is);
      BufferedReader br = new BufferedReader(isr);

      String sss = br.readLine();
      System.out.println(sss);

      PrintWriter pw = new PrintWriter(out);
      pw.print("hello,我是服务器。");

      pw.close();
      br.close();
      isr.close();
      out.close();
      is.close();
      s.close();
      ss.close();
    } catch (UnknownHostException ue) {
      ue.printStackTrace();
    } catch (IOException oe) {
      oe.printStackTrace();
    }
  }
  public boolean connectToServer(String ip, String userName) {
    try {
      socket = new Socket(ip, 45322);
      lnOut("Connected to server!");
      ;
      streamFromServer = new DataInputStream(socket.getInputStream());
      streamToServer = new DataOutputStream(socket.getOutputStream());

      // With the connection established, create the server connection module.
      serverCon = new ServerConnection(this, streamToServer);
      // next start a thread that listens to incoming
      // messages from the game server via TCP.
      listener = new TCPListenerThread(this, client, streamFromServer);

      // finally send the requested user name to the server.
      streamToServer.write(userName.getBytes());
      return true;
    } catch (UnknownHostException e) {
      System.out.println("Don't know about host: " + ip);
      System.out.println(e.getMessage());
      return false;
    } catch (IOException e) {
      System.out.println("Couldn't get I/O for the connection to: " + ip);
      System.out.println(e.getMessage());
      return false;
    } catch (Exception e) {
      System.out.println(e.getMessage());
      return false;
    }
  }
Пример #8
0
  /** @param args the command line arguments */
  public static void main(String[] args) {

    try {
      int randomNum = (int) ((Math.random() * 100) + 1);
      Socket server = new Socket("127.0.0.1", 8888);
      BufferedReader input = new BufferedReader(new InputStreamReader(server.getInputStream()));
      PrintWriter output = new PrintWriter(server.getOutputStream(), true);
      String leggi;
      int total = 0;
      output.println(randomNum);
      while ((leggi = input.readLine()) != null) {
        System.out.println("Valore letto: " + leggi);
        total += Integer.parseInt(leggi);
      }
      System.out.println("Somma dei valori ricevuti dal Server: " + total);
      if (total % 2 == 0) {
        System.out.println("PARI");
      } else {
        System.out.println("DISPARI");
      }

    } catch (UnknownHostException ex) {
      System.out.println("Errore indirizzo sconosciuto:" + ex.getMessage());
    } catch (IOException ex) {
      System.out.println(ex);
    }
  }
Пример #9
0
 public static String ip() {
   try {
     return InetAddress.getLocalHost().getHostAddress();
   } catch (UnknownHostException e) {
     e.printStackTrace();
     return null;
   }
 }
 /**
  * Gets the next token from a tokenizer and converts it to an IP Address.
  *
  * @param family The address family.
  * @return The next token in the stream, as an InetAddress
  * @throws TextParseException The input was invalid or not a valid address.
  * @throws IOException An I/O error occurred.
  * @see Address
  */
 public InetAddress getAddress(int family) throws IOException {
   String next = _getIdentifier("an address");
   try {
     return Address.getByAddress(next, family);
   } catch (UnknownHostException e) {
     throw exception(e.getMessage());
   }
 }
Пример #11
0
  ProcessB() {
    this.setPort(5000);
    this.setHost("localhost");
    try {
      this.setAddress(InetAddress.getByName(getHost()));

    } catch (UnknownHostException e) {
      e.printStackTrace();
    }
  }
    @Override
    public void run() {
      try {
        Thread.sleep(3000);

        String uberdustServerDnsName = config.getString("uberdustcoapserver.dnsName");
        if (uberdustServerDnsName == null) {
          throw new Exception("Property uberdustcoapserver.dnsName not set.");
        }

        int uberdustServerPort = config.getInt("uberdustcoapserver.port", 0);
        if (uberdustServerPort == 0) {
          throw new Exception("Property uberdustcoapserver.port not set.");
        }

        InetSocketAddress uberdustServerSocketAddress =
            new InetSocketAddress(InetAddress.getByName(uberdustServerDnsName), uberdustServerPort);

        String baseURI = config.getString("baseURIHost", "localhost");
        CoapRequest fakeRequest =
            new CoapRequest(
                MsgType.NON, Code.POST, new URI("coap://" + baseURI + ":5683/here_i_am"));

        CoapNodeRegistrationServer registrationServer = CoapNodeRegistrationServer.getInstance();
        if (registrationServer == null) {
          log.error("NULL!");
        }
        registrationServer.receiveCoapRequest(fakeRequest, uberdustServerSocketAddress);
      } catch (InterruptedException e) {
        e.printStackTrace();
      } catch (UnknownHostException e) {
        e.printStackTrace();
      } catch (URISyntaxException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      } catch (InvalidMessageException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      } catch (InvalidOptionException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      } catch (ToManyOptionsException e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      } catch (Exception e) {
        e
            .printStackTrace(); // To change body of catch statement use File | Settings | File
                                // Templates.
      }
    }
Пример #13
0
  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;
  }
Пример #14
0
 public void connect() {
   try {
     s = new Socket("127.0.0.1", 8888);
     dos = new DataOutputStream(s.getOutputStream());
     System.out.println("connected!");
   } catch (UnknownHostException e) {
     e.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
Пример #15
0
  public static void main(String[] args) {
    Socket socket = null;
    PrintWriter out = null;
    BufferedReader in = null;
    BufferedReader userInputStream = null;
    String IP = "127.0.0.1";
    final int PORT_NUM = 4444;
    try {
      socket = new Socket(IP, PORT_NUM);
      out = new PrintWriter(socket.getOutputStream(), true);
      in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    } catch (UnknownHostException e) {
      System.out.println("Unknown host:" + IP + " at port: " + PORT_NUM);
      e.printStackTrace();
      System.exit(0);
    } catch (IOException e) {
      System.out.println("Cannot connect to server...");
      e.printStackTrace();
      System.exit(0);
    }
    String userInput, fromServer;
    try {
      userInputStream = new BufferedReader(new InputStreamReader(System.in));
      while ((fromServer = in.readLine()) != null) {
        System.out.println("Server: " + fromServer);
        if (fromServer.equals(":q")) break;

        userInput = userInputStream.readLine();
        Calendar cal = Calendar.getInstance();
        cal.getTime();
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        if (userInput != null) {
          out.println(userInput + " (sent at " + (sdf.format(cal.getTime())) + ")");
        }
      }
    } catch (IOException e) {
      System.out.println("Could not access data from client printstream...");
      e.printStackTrace();
      System.exit(0);
    }
    try {
      out.close();
      in.close();
      userInputStream.close();
      socket.close();
      System.out.println("I love you, bye.");
      System.out.println("Terminating client...");
    } catch (IOException e) {
      System.out.println("Socket and stream closing error...");
      e.printStackTrace();
      System.exit(0);
    }
  }
Пример #16
0
 String getLocalIPAddr() {
   if (localAddr == null) {
     try {
       IPAddr localHost = IPAddr.getLocalHost();
       localAddr = localHost.getHostAddress();
     } catch (UnknownHostException e) {
       // shouldn't happen
       log.error("LockssServlet: getLocalHost: " + e.toString());
       return "???";
     }
   }
   return localAddr;
 }
Пример #17
0
 public void Connect() {
   try {
     System.out.println("ok");
     socket99 = new Socket(serverIP, 9999);
     socket66 = new Socket(serverIP, 6666);
     socket88 = new Socket(serverIP, 8888);
     isConnected = true;
   } catch (UnknownHostException e) {
     e.printStackTrace();
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
Пример #18
0
  public ChatClient(InetAddress iAddress, int serverPort) {
    System.out.println("Establishing connection. Please wait ...");
    try {
      socket = new Socket(iAddress, serverPort);
      cryptor = new EDCrypt();
      System.out.println("Connected: " + socket);

      start();
    } catch (UnknownHostException uhe) {
      System.out.println("Host unknown: " + uhe.getMessage());
    } catch (IOException ioe) {
      System.out.println("Unexpected exception: " + ioe.getMessage());
    }
  }
Пример #19
0
  private boolean establecer() {
    try {
      Mensaje msg = new MensajeSistema();
      this.conexion = new Socket(msg.HOST_SERVER, msg.PUERTO);
      // FIXME correcto tratamiento del error
      /*if (!this.conexion)
      return false;*/

    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return true;
  }
Пример #20
0
  /**
   * Returns the address of the local host. This is achieved by retrieving the name of the host from
   * the system, then resolving that name into an <code>InetAddress</code>.
   *
   * <p>Note: The resolved address may be cached for a short period of time.
   *
   * <p>If there is a security manager, its <code>checkConnect</code> method is called with the
   * local host name and <code>-1</code> as its arguments to see if the operation is allowed. If the
   * operation is not allowed, an InetAddress representing the loopback address is returned.
   *
   * @return the address of the local host.
   * @exception UnknownHostException if the local host name could not be resolved into an address.
   * @see SecurityManager#checkConnect
   * @see java.net.InetAddress#getByName(java.lang.String)
   */
  public static InetAddress getLocalHost() throws UnknownHostException {

    SecurityManager security = System.getSecurityManager();
    try {
      String local = impl.getLocalHostName();

      if (security != null) {
        security.checkConnect(local, -1);
      }

      if (local.equals("localhost")) {
        return impl.loopbackAddress();
      }

      InetAddress ret = null;
      synchronized (cacheLock) {
        long now = System.currentTimeMillis();
        if (cachedLocalHost != null) {
          if ((now - cacheTime) < maxCacheTime) // Less than 5s old?
          ret = cachedLocalHost;
          else cachedLocalHost = null;
        }

        // we are calling getAddressFromNameService directly
        // to avoid getting localHost from cache
        if (ret == null) {
          InetAddress[] localAddrs;
          try {
            localAddrs = (InetAddress[]) InetAddress.getAddressFromNameService(local, null);
          } catch (UnknownHostException uhe) {
            throw new UnknownHostException(local + ": " + uhe.getMessage());
          }
          cachedLocalHost = localAddrs[0];
          cacheTime = now;
          ret = localAddrs[0];
        }
      }
      return ret;
    } catch (java.lang.SecurityException e) {
      return impl.loopbackAddress();
    }
  }
  public void activateOptions() {
    InetAddress addr = null;

    try {
      Class c = Class.forName(decoder);
      Object o = c.newInstance();

      if (o instanceof Decoder) {
        this.decoderImpl = (Decoder) o;
      }
    } catch (ClassNotFoundException cnfe) {
      getLogger().warn("Unable to find decoder", cnfe);
    } catch (IllegalAccessException iae) {
      getLogger().warn("Could not construct decoder", iae);
    } catch (InstantiationException ie) {
      getLogger().warn("Could not construct decoder", ie);
    }

    try {
      addr = InetAddress.getByName(address);
    } catch (UnknownHostException uhe) {
      uhe.printStackTrace();
    }

    try {
      active = true;
      socket = new MulticastSocket(port);
      socket.joinGroup(addr);
      receiverThread = new MulticastReceiverThread();
      receiverThread.start();
      handlerThread = new MulticastHandlerThread();
      handlerThread.start();
      if (advertiseViaMulticastDNS) {
        zeroConf = new ZeroConfSupport(ZONE, port, getName());
        zeroConf.advertise();
      }

    } catch (IOException ioe) {
      ioe.printStackTrace();
    }
  }
Пример #22
0
 /** @return true if the request was served. */
 private boolean proxyRemotePath(
     HttpServletRequest req, HttpServletResponse resp, URI remoteURI, boolean failEarlyOn404)
     throws IOException, ServletException, UnknownHostException {
   try {
     return proxyRemoteUrl(req, resp, new URL(remoteURI.toString()), failEarlyOn404);
   } catch (MalformedURLException e) {
     String message = NLS.bind("Malformed remote URL: {0}", remoteURI.toString());
     handleException(
         resp, new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_NOT_FOUND, message, e));
   } catch (UnknownHostException e) {
     String message = NLS.bind("Unknown host {0}", e.getMessage());
     handleException(
         resp, new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_NOT_FOUND, message, e));
   } catch (Exception e) {
     String message = NLS.bind("An error occurred while retrieving {0}", remoteURI.toString());
     handleException(
         resp,
         new ServerStatus(
             IStatus.ERROR, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message, e));
   }
   return true;
 }
  public void update(EventBean[] newData, EventBean[] oldData) {

    System.out.println(
        "Transaction Id="
            + newData[0].get("tid")
            + ": Latency Between Order Creation and Purchase Order="
            + newData[0].get("LatencyAB")
            + " And Latency between Purchase Order and Shipping="
            + newData[0].get("LatencyBC"));

    String ip = "172.17.76.74";

    try {
      System.out.println("1--->Sending data...");
      System.out.println(InetAddress.getByName(ip));
      // UdpListener.sendDataOverUdp("TXNCEP.Order.LatencyAB",
      // newData[0].get("LatencyAB").toString(),InetAddress.getByName(ip),2003);
      UdpListener.sendDataOverUdp(
          /*"carbon.txncep.order.latencyab"*/
          "carbon.installation.TXNCEP",
          newData[0].get("LatencyAB").toString(),
          InetAddress.getByName(ip),
          2003);
      System.out.println("Sending data...");
    } catch (SocketException e) {
      System.out.println("socket error - Socket Exception" + e.getMessage());
      System.out.println();
    } catch (UnknownHostException e) {
      System.out.println("socket error - UnknownHost" + e.getMessage());
    } catch (PropertyAccessException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Пример #24
0
  /** Creates new form Login */
  public Login() {
    initComponents();
    setTitle("Zlatna ribica");
    /*
    napravit konekciju sa serverom
    */
    String servername = "0.0.0.0"; /* pretpostavljen localhost */
    int port = 1000; /* pretpostavljeno da server slusa na portu 23456 */
    try {
      socket = new Socket(servername, port);
      streamOut = new DataOutputStream(socket.getOutputStream());
      streamIn = new DataInputStream(socket.getInputStream());

    } catch (UnknownHostException uhe) {
      System.err.println("Host unknown " + uhe.getMessage());
      System.exit(0);
    } catch (IOException ioe) {
      System.err.println("Unexpected exception; " + ioe.getMessage());
      System.exit(0);
    }

    loginThread = new LoginThread(this, socket);
    loginThread.start();
  }
Пример #25
0
    public static LoaderOptions parseArgs(String cmdArgs[]) {
      CommandLineParser parser = new GnuParser();
      CmdLineOptions options = getCmdLineOptions();
      try {
        CommandLine cmd = parser.parse(options, cmdArgs, false);

        if (cmd.hasOption(HELP_OPTION)) {
          printUsage(options);
          System.exit(0);
        }

        String[] args = cmd.getArgs();
        if (args.length == 0) {
          System.err.println("Missing sstable directory argument");
          printUsage(options);
          System.exit(1);
        }

        if (args.length > 1) {
          System.err.println("Too many arguments");
          printUsage(options);
          System.exit(1);
        }

        String dirname = args[0];
        File dir = new File(dirname);

        if (!dir.exists()) errorMsg("Unknown directory: " + dirname, options);

        if (!dir.isDirectory()) errorMsg(dirname + " is not a directory", options);

        LoaderOptions opts = new LoaderOptions(dir);

        opts.debug = cmd.hasOption(DEBUG_OPTION);
        opts.verbose = cmd.hasOption(VERBOSE_OPTION);
        opts.noProgress = cmd.hasOption(NOPROGRESS_OPTION);

        if (cmd.hasOption(RPC_PORT_OPTION))
          opts.rpcPort = Integer.parseInt(cmd.getOptionValue(RPC_PORT_OPTION));

        if (cmd.hasOption(USER_OPTION)) opts.user = cmd.getOptionValue(USER_OPTION);

        if (cmd.hasOption(PASSWD_OPTION)) opts.passwd = cmd.getOptionValue(PASSWD_OPTION);

        if (cmd.hasOption(INITIAL_HOST_ADDRESS_OPTION)) {
          String[] nodes = cmd.getOptionValue(INITIAL_HOST_ADDRESS_OPTION).split(",");
          try {
            for (String node : nodes) {
              opts.hosts.add(InetAddress.getByName(node.trim()));
            }
          } catch (UnknownHostException e) {
            errorMsg("Unknown host: " + e.getMessage(), options);
          }

        } else {
          System.err.println("Initial hosts must be specified (-d)");
          printUsage(options);
          System.exit(1);
        }

        if (cmd.hasOption(IGNORE_NODES_OPTION)) {
          String[] nodes = cmd.getOptionValue(IGNORE_NODES_OPTION).split(",");
          try {
            for (String node : nodes) {
              opts.ignores.add(InetAddress.getByName(node.trim()));
            }
          } catch (UnknownHostException e) {
            errorMsg("Unknown host: " + e.getMessage(), options);
          }
        }

        // try to load config file first, so that values can be rewritten with other option values.
        // otherwise use default config.
        Config config;
        if (cmd.hasOption(CONFIG_PATH)) {
          File configFile = new File(cmd.getOptionValue(CONFIG_PATH));
          if (!configFile.exists()) {
            errorMsg("Config file not found", options);
          }
          config = new YamlConfigurationLoader().loadConfig(configFile.toURI().toURL());
        } else {
          config = new Config();
        }
        opts.storagePort = config.storage_port;
        opts.sslStoragePort = config.ssl_storage_port;
        opts.throttle = config.stream_throughput_outbound_megabits_per_sec;
        opts.encOptions = config.client_encryption_options;
        opts.serverEncOptions = config.server_encryption_options;

        if (cmd.hasOption(THROTTLE_MBITS)) {
          opts.throttle = Integer.parseInt(cmd.getOptionValue(THROTTLE_MBITS));
        }

        if (cmd.hasOption(SSL_TRUSTSTORE)) {
          opts.encOptions.truststore = cmd.getOptionValue(SSL_TRUSTSTORE);
        }

        if (cmd.hasOption(SSL_TRUSTSTORE_PW)) {
          opts.encOptions.truststore_password = cmd.getOptionValue(SSL_TRUSTSTORE_PW);
        }

        if (cmd.hasOption(SSL_KEYSTORE)) {
          opts.encOptions.keystore = cmd.getOptionValue(SSL_KEYSTORE);
          // if a keystore was provided, lets assume we'll need to use it
          opts.encOptions.require_client_auth = true;
        }

        if (cmd.hasOption(SSL_KEYSTORE_PW)) {
          opts.encOptions.keystore_password = cmd.getOptionValue(SSL_KEYSTORE_PW);
        }

        if (cmd.hasOption(SSL_PROTOCOL)) {
          opts.encOptions.protocol = cmd.getOptionValue(SSL_PROTOCOL);
        }

        if (cmd.hasOption(SSL_ALGORITHM)) {
          opts.encOptions.algorithm = cmd.getOptionValue(SSL_ALGORITHM);
        }

        if (cmd.hasOption(SSL_STORE_TYPE)) {
          opts.encOptions.store_type = cmd.getOptionValue(SSL_STORE_TYPE);
        }

        if (cmd.hasOption(SSL_CIPHER_SUITES)) {
          opts.encOptions.cipher_suites = cmd.getOptionValue(SSL_CIPHER_SUITES).split(",");
        }

        if (cmd.hasOption(TRANSPORT_FACTORY)) {
          ITransportFactory transportFactory =
              getTransportFactory(cmd.getOptionValue(TRANSPORT_FACTORY));
          configureTransportFactory(transportFactory, opts);
          opts.transportFactory = transportFactory;
        }

        return opts;
      } catch (ParseException | ConfigurationException | MalformedURLException e) {
        errorMsg(e.getMessage(), options);
        return null;
      }
    }
Пример #26
0
  public static void main(String[] args) {
    // Checks if no command line args were given by usej
    if (args.length <= 0) {
      System.out.println("No user specified!");
      return;
    }
    // Sets the filename equal to the command line argument
    String filename = "";
    String message = args[0];

    try {
      // Creates an InetAddress using localhost
      InetAddress address = InetAddress.getByName("localhost");

      // The byte buffer used for data the client is sending
      byte[] sdata = new byte[PACKET_SIZE];
      // The byte buffer used for data the client is receiving
      byte[] rData = new byte[PACKET_SIZE];

      // Puts "Sync" into the send Data
      sdata = ("SYNC" + message).getBytes();

      DatagramSocket socket = new DatagramSocket();
      // Socket timesout after 5 seconds to prevent infinite wait
      socket.setSoTimeout(5000);

      // Creates the packet and puts in the message
      DatagramPacket packet = new DatagramPacket(sdata, sdata.length, address, 3031);

      // Sends packet with the message to the server
      socket.send(packet);

      // Creates the recieve packet
      DatagramPacket rpacket = new DatagramPacket(rData, rData.length);

      socket.receive(rpacket);
      // Pulls the string out of the recieved packet
      String cmd1 = new String(rpacket.getData(), 0, rpacket.getLength());

      // Checks if the server sent SYNACK
      if (cmd1.substring(0, 6).equals("SYNACK")) {
        String dirList = cmd1.substring(6);
        System.out.println(dirList);
        System.out.flush();
        System.out.println(
            "Please type the file you wish to receive, or type " + "EXIT to close the server");
        Scanner scan = new Scanner(System.in);
        filename = scan.next();
        // Puts the file named into the Send Data
        sdata = filename.getBytes();
        // Creates a Packet with the Filename
        packet = new DatagramPacket(sdata, sdata.length, address, 3031);
        socket.send(packet);
      } else return;
      // Checks if the filename is Exit. If so the client exits as well
      if (filename.equals("EXIT")) {
        System.out.println("Exit request sent.");
        return;
      }
      // Creates a local file to put the data recieved from the server in.
      socket.receive(rpacket);
      // Pulls the filename out of the recieved packet
      filename = new String(rpacket.getData(), 0, rpacket.getLength());

      // Check if the first 7 characters are 'FILEACK', if so set file name
      // to the rest of the message
      if (filename.substring(0, 7).equals("FILEACK")) {
        filename = filename.substring(9 + message.length(), filename.length());
        System.out.println("File name requested: " + filename);
      } else {
        // If no FILEACK, then the file specified was not valid
        System.out.println("Not a valid file!");
        return;
      }
      File file = new File("local_" + filename);
      // Opens a FileOutputStream to use to write the data in the above file.
      FileOutputStream fos = new FileOutputStream(file);
      // Creates the receiving packet for data comming form the server

      System.out.println("Transfer started.");
      // The loop to received the packets of requested data.

      windowPackets = new DatagramPacket[MAX_SEQ];
      CRC32 crc = new CRC32();
      while (!done) {
        // Receives a packet sent from server
        socket.receive(rpacket);

        // Initialize arrays
        byte[] info = new byte[INT_SIZE];
        byte[] code = new byte[CHECKSUM_SIZE];
        byte[] data = new byte[rpacket.getLength() - SAC_SIZE];
        byte[] data2 = new byte[rpacket.getLength() - CHECKSUM_SIZE];

        // Split packet data into appropriate arrays
        System.arraycopy(rpacket.getData(), 0, info, 0, INT_SIZE);
        System.arraycopy(rpacket.getData(), INT_SIZE, data, 0, rpacket.getLength() - SAC_SIZE);
        System.arraycopy(rpacket.getData(), 0, data2, 0, rpacket.getLength() - CHECKSUM_SIZE);
        System.arraycopy(
            rpacket.getData(), rpacket.getLength() - CHECKSUM_SIZE, code, 0, CHECKSUM_SIZE);

        // Convert seq num and other numbers from bytes to ints
        int packNum2 = ByteConverter.toInt(info, 0);
        int sCode = ByteConverter.toInt(code, 0);
        int packNum = ByteConverter.toInt(info, 0);

        // Reset and update crc for next packet
        crc.reset();
        crc.update(data2, 0, data2.length);
        int cCode = (int) crc.getValue();

        byte[] ackNum = ByteConverter.toBytes(packNum);
        ArrayList<Integer> expecting = new ArrayList<Integer>();

        // Check for errors
        if (cCode == sCode) {
          // Create expected sequence numbers
          for (int i = 0; i < WINDOW_SIZE; i++) {
            if (base + i >= MAX_SEQ) expecting.add((base + i) - MAX_SEQ);
            else expecting.add(base + i);
          }

          // If packet number is base packet number
          if (packNum == base) {
            ackNum = ByteConverter.toBytes(packNum);
            packet = new DatagramPacket(ackNum, ackNum.length, address, 3031);
            socket.send(packet);

            // If last packet
            if (rpacket.getLength() == 0) {
              done = true;
              break;
            }
            // Write and move base forward
            fos.write(data, 0, data.length);
            base++;

            if (base == MAX_SEQ) base = 0;

            // update expected packets
            for (int i = 0; i < WINDOW_SIZE; i++) {
              if (base + i >= MAX_SEQ) expecting.add((base + i) - MAX_SEQ);
              else expecting.add(base + i);
            }

            // If the packet has data it writes it into the local file.
            // If this packet is smaller than the agree upon size then it knows
            // that the transfer is complete and client ends.
            if (rpacket.getLength() < PACKET_SIZE) {
              System.out.println("File transferred");
              done = true;
              break;
            }

            // While there are packets in buffer, move packet to file
            while (windowPackets[base] != null) {
              DatagramPacket nextPacket = windowPackets[base];
              windowPackets[base] = null;

              data = new byte[nextPacket.getLength() - SAC_SIZE];
              System.arraycopy(
                  nextPacket.getData(), INT_SIZE, data, 0, nextPacket.getLength() - SAC_SIZE);
              System.arraycopy(nextPacket.getData(), 0, info, 0, INT_SIZE);

              packNum = ByteConverter.toInt(info, 0);

              // If packet size is 0, then it is the last packet
              if (nextPacket.getLength() == 0) {
                System.out.println("File transferred");
                done = true;
                break;
              }

              // Write and move base forward
              fos.write(data, 0, data.length);
              base++;

              if (base == MAX_SEQ) base = 0;
              expecting.clear();

              // Update expected
              for (int i = 0; i < WINDOW_SIZE; i++) {
                if (base + i >= MAX_SEQ) expecting.add((base + i) - MAX_SEQ);
                else expecting.add(base + i);
              }

              // If the packet has data it writes it into the local file.
              // If this packet is smaller than the agree upon size then it knows
              // that the transfer is complete and client ends.
              if (nextPacket.getLength() < PACKET_SIZE) {
                System.out.println("File transferred");
                done = true;
                break;
              }
            }
          } else if (expecting.contains(packNum)) {
            // If its expected, put it into buffer
            windowPackets[packNum] = rpacket;
            System.arraycopy(rpacket.getData(), 0, info, 0, INT_SIZE);
            packNum = ByteConverter.toInt(info, 0);
            ackNum = ByteConverter.toBytes(packNum);
            packet = new DatagramPacket(ackNum, ackNum.length, address, 3031);
            socket.send(packet);
          } else {
            // If not expected, just ACK packet
            System.arraycopy(rpacket.getData(), 0, info, 0, INT_SIZE);
            packNum = ByteConverter.toInt(info, 0);
            ackNum = ByteConverter.toBytes(packNum);
            packet = new DatagramPacket(ackNum, ackNum.length, address, 3031);
            socket.send(packet);
          }

        } else {
          // CRC found error with packet
          System.out.println("ERROR");
        }
      }

      // transfer is done
      System.out.println("File length - " + file.length());
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (UnknownHostException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Пример #27
0
  public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws IOException, ServletException {

    InetAddress serverIp = null;
    Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
    String hostname = "", clientIp = "", userAgent = "";
    try {
      serverIp = InetAddress.getLocalHost();
      hostname = serverIp.getHostName();
      clientIp = request.getHeader("X-FORWARDED-FOR");
      if (clientIp == null) {
        clientIp = request.getRemoteAddr();
      }
      userAgent = request.getHeader("user-agent");

    } catch (UnknownHostException e) {

      e.printStackTrace();
    }

    response.setContentType("text/html");
    PrintWriter writer = response.getWriter();
    writer.println("<html>");
    writer.println("<head>");
    writer.println("<title>Sample Application Page</title>");
    writer.println("</head>");
    writer.println("<body bgcolor=white>");
    writer.println("<table border=\"0\">");
    writer.println("<tr>");
    writer.println("<td>");
    writer.println("<h1>Sample Application</h1>");
    writer.println("</td>");
    writer.println("</tr>");
    writer.println("<tr>");
    writer.println("<td>");
    //        writer.println("Server IP address: <strong>" + serverIp.getHostAddress() +
    // "</strong>");
    writer.println("Server IP addresses: <strong>");
    while (interfaces.hasMoreElements()) {
      NetworkInterface n = (NetworkInterface) interfaces.nextElement();
      Enumeration inetAddresses = n.getInetAddresses();
      while (inetAddresses.hasMoreElements()) {
        InetAddress address = (InetAddress) inetAddresses.nextElement();
        if (address.getHostAddress().substring(0, 6).compareTo("10.42.") == 0)
          writer.println(address.getHostAddress() + " ");
      }
    }
    writer.println("</strong>");
    writer.println("</td>");
    writer.println("</tr>");
    writer.println("<tr>");
    writer.println("<td>");
    writer.println("Server Hostname: <strong>" + hostname + "</strong>");
    writer.println("</td>");
    writer.println("</tr>");
    writer.println("<tr>");
    writer.println("<td>");
    writer.println("Your current IP address: <strong>" + clientIp + "</strong>");
    writer.println("</td>");
    writer.println("</tr>");
    writer.println("<tr>");
    writer.println("<td>");
    writer.println("Your current User-Agent: <strong>" + userAgent + "</strong>");
    writer.println("</td>");
    writer.println("</tr>");
    writer.println("</table>");
    writer.println("</body>");
    writer.println("</html>");
  }
Пример #28
0
  public static void main(String[] args) throws EOFException {

    queue = new ArrayList<Traffic>();

    ObjectInputStream OISforTG = null;
    ObjectOutputStream OOSforLot = null;

    System.out.print("login?");
    sc = new Scanner(System.in);
    String input = sc.nextLine();
    if (input.equalsIgnoreCase("y") || input.equalsIgnoreCase("yes")) {
      // System.out.println(ConnectionData.ipTG+" "+ConnectionData.portForTG);
      try {
        // socketForManager = new Socket(ConnectionData.ipMani, ConnectionData.portForManager);
        socketForTG = new Socket(ConnectionData.ipTG, ConnectionData.portForTG);
        socketForTime = new Socket(ConnectionData.ipTG, ConnectionData.portForTime);
        socketForParkingLot = new Socket(ConnectionData.ipLot, ConnectionData.portForLot);
        System.out.println("Connected");
      } catch (UnknownHostException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      }

      receiverForManager RFM = new receiverForManager();
      Thread ThreadRFM = new Thread(RFM);
      ThreadRFM.start();

      trafficReceiver trafficRec = new trafficReceiver();
      Thread ThreadTraffic = new Thread(trafficRec);
      ThreadTraffic.start();

      try {
        OOSforLot = new ObjectOutputStream(socketForParkingLot.getOutputStream());
      } catch (IOException e) {
        e.printStackTrace();
      } catch (NullPointerException npe) {
        npe.printStackTrace();
      }

      timeReader TR = new timeReader();
      Thread thread = new Thread(TR);
      thread.start();

      carReturned CR = new carReturned();
      Thread thread1 = new Thread(CR);
      thread1.start();
      // System.out.println("reach1");
      while (true) {
        try {
          if (Token > 0 && queue.size() > 0) {
            Token--;
            System.out.println(Token);
            OOSforLot.writeObject(queue.get(0));
          } else if (Token == 0 && queue.size() > 0) {
            String carOrig = queue.get(0).getGeneratedTime();
            Integer carOrigInt[] = utils.timeConverter(carOrig);
            int Orig = (carOrigInt[0] * 3600) + (carOrigInt[1] * 60);
            int Curren = (currentTime[0] * 3600) + (currentTime[1] * 60);

            if ((Curren - Orig) > 600) {
              // need to something...
              //
              //
              //
              //
            } else {
              System.out.println("Token: " + Token + " queue Size: " + queue.size());
              continue;
            }
          }

        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
Пример #29
0
  public JavaGame(String[] args) {
    this.args = args;
    updater = new Updater(this);
    highscore = new Highscore(this);
    eventHandler = new EventHandler(this);
    eventHandler.registerTestEvents();

    setTitle("Survive-JavaGame"); // Fenstertitel setzen
    setSize(1200, 900); // Fenstergröße einstellen
    addWindowListener(new WindowListener());
    setLocationRelativeTo(null);

    try {
      arg = args[0];
    } catch (ArrayIndexOutOfBoundsException e) {
      arg = "nothing";
    }
    if (arg.equals("fullscreen")) {
      setUndecorated(true); // "Vollbild"
      setSize(
          (int) Toolkit.getDefaultToolkit().getScreenSize().getWidth() - 200,
          (int) Toolkit.getDefaultToolkit().getScreenSize().getWidth());
      setLocation(0, 0);
    }
    setVisible(true);
    setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));

    try {
      /*URI Path = URLDecoder.decode(getClass().getClassLoader().getResource("texture").toURI();//, "UTF-8"); //Pfad zu den Resourcen
      File F = new File(Path);
      basePath = F;
      System.out.println(basePath);
      */
      File File = new File((System.getenv("APPDATA")));
      basePath = new File(File, "/texture");
      backgroundTexture = new File(basePath, "/hintergrund.jpg");
    } catch (Exception ex) {
      ex.printStackTrace();
    }

    try {
      backgroundImage = ImageIO.read(backgroundTexture);
    } catch (IOException exeption) {

    }

    if (soundan) {
      currentVolume = 80;
    } // end of if

    dbImage = createImage(1920, 1080);
    // dbGraphics = dbImage.getGraphics();

    // Texturen Liste

    // Ebenen Liste

    ebenen[0][0] = 91;
    ebenen[0][1] = 991; // Main Ebene: Kann nicht durchschrittenwerden indem down gedrückt wird
    ebenen[0][2] = 563;

    ebenen[1][0] = 387; // x1
    ebenen[1][1] = 524; // x2
    ebenen[1][2] = 454; // y

    ebenen[2][0] = 525;
    ebenen[2][1] = 645;
    ebenen[2][2] = 350;

    ebenen[3][0] = 246;
    ebenen[3][1] = 365;
    ebenen[3][2] = 351;

    ebenen[4][0] = 760;
    ebenen[4][1] = 870;
    ebenen[4][2] = 294;

    ebenen[5][0] = 835;
    ebenen[5][1] = 969;
    ebenen[5][2] = 441;

    // Spieler

    // I'm in Space! SPACE!
    player[1] =
        new Player(
            (int) (Math.random() * (ebenen[0][1] - ebenen[0][0]) + ebenen[0][0]),
            0,
            false,
            67,
            100,
            texture[0],
            shottexture[0],
            KeyEvent.VK_A,
            KeyEvent.VK_D,
            KeyEvent.VK_W,
            KeyEvent.VK_S,
            KeyEvent.VK_Q,
            1,
            35,
            highscore.getName(1));
    player[2] =
        new Bot(
            (int) (Math.random() * (ebenen[0][1] - ebenen[0][0]) + ebenen[0][0]),
            0,
            false,
            67,
            100,
            texture[1],
            shottexture[1],
            KeyEvent.VK_J,
            KeyEvent.VK_L,
            KeyEvent.VK_I,
            KeyEvent.VK_K,
            KeyEvent.VK_U,
            2,
            35,
            highscore.getName(1));
    player[3] =
        new Bot(
            (int) (Math.random() * (ebenen[0][1] - ebenen[0][0]) + ebenen[0][0]),
            0,
            false,
            67,
            100,
            texture[2],
            shottexture[2],
            KeyEvent.VK_LEFT,
            KeyEvent.VK_RIGHT,
            KeyEvent.VK_UP,
            KeyEvent.VK_DOWN,
            KeyEvent.VK_ENTER,
            3,
            35,
            highscore.getName(1));

    player[1].laden(this);
    player[2].laden(this);
    player[3].laden(this);

    this.addKeyListener(player[1]);
    this.addKeyListener(player[2]);
    this.addKeyListener(player[3]);

    this.addKeyListener(this);

    int result;
    Object[] options = {"SinglePlayer", "MultiPlayer"};
    if (arg.equals("dedicated")) {
      Server server = new Server();
      this.server = true;
      setVisible(false);

    } else {
      if ((result =
              JOptionPane.showOptionDialog(
                  null,
                  "Treffen Sie eine Auswahl",
                  "Alternativen",
                  JOptionPane.DEFAULT_OPTION,
                  JOptionPane.INFORMATION_MESSAGE,
                  null,
                  options,
                  options[0]))
          == 1) {
        client = new Client(this);
        online = true;
        while ((onlinename =
                    JOptionPane.showInputDialog(
                        null,
                        "Geben Sie Ihren Namen ein",
                        "Eine Eingabeaufforderung",
                        JOptionPane.PLAIN_MESSAGE))
                .isEmpty()
            && onlinename != null) {}

        Object[] optionsmp = {"Host", "Client"};
        if ((result =
                JOptionPane.showOptionDialog(
                    null,
                    "Treffen Sie eine Auswahl",
                    "Alternativen",
                    JOptionPane.DEFAULT_OPTION,
                    JOptionPane.INFORMATION_MESSAGE,
                    null,
                    optionsmp,
                    optionsmp[0]))
            == 0) {
          Server server = new Server();
          this.server = true;
        } else if (online) {
          while ((serveradresse =
                      JOptionPane.showInputDialog(
                          null,
                          "Geben Sie die Serveradresse ein",
                          "Eine Eingabeaufforderung",
                          JOptionPane.PLAIN_MESSAGE))
                  .isEmpty()
              && serveradresse != null) {}
        }
      }
    }
    if (!arg.equals("dedicated")) {
      gamerunner = new GameRunner(player, this);
      DamageLogig = new damageLogig(gamerunner);
    }

    if (online) {
      try {
        client.initialise(serveradresse, 9876);
        client.start();
      } catch (SocketException e) {
        e.printStackTrace();
      } catch (UnknownHostException e) {
        e.printStackTrace();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  } // end of init
  /**
   * connect: connect to the master
   *
   * @return: true for success and false for failure
   */
  protected boolean connect() {

    boolean connected = true;
    try {
      _sock = new Socket(_serverIP, _serverPort);
      _out = new PrintWriter(_sock.getOutputStream(), true);
      _in = new BufferedReader(new InputStreamReader(_sock.getInputStream()));
      String reply = sendAll();
      if (!reply.equals(ProtocolConstants.PACK_STR_CONFIRM_HEAD)) {
        /* Tokenize */
        StringTokenizer st = new StringTokenizer(reply);
        if (st.nextToken().equals(ProtocolConstants.PACK_STR_ERRMES_HEAD)) {
          _elog(st.nextToken());
          return false;
        }
      }

      _userSock = new Socket(_serverIP, _serverPort);
      _userOut = new PrintWriter(_userSock.getOutputStream(), true);
      _userIn = new BufferedReader(new InputStreamReader(_userSock.getInputStream()));
      String replyUser = sendUserID();
      if (!replyUser.equals(ProtocolConstants.PACK_STR_CONFIRM_HEAD)) {
        throw new Exception("Not confirmed");
      }
    } catch (UnknownHostException e) {
      if (!_server.noException()) {
        _elog(e.toString());
      }
      if (_server.debugMode()) {
        e.printStackTrace();
      }
      connected = false;
    } catch (IOException e) {
      if (!_server.noException()) {
        _elog(e.toString());
      }
      if (_server.debugMode()) {
        e.printStackTrace();
      }
      connected = false;
    } catch (Exception e) {
      if (!_server.noException()) {
        _elog(e.toString());
      }
      if (_server.debugMode()) {
        e.printStackTrace();
      }
      connected = false;
    }
    if (!connected) {
      return connected;
    }

    if (!connected) {
      /* Remove the pair of socket */
      _sock = null;
      _in = null;
      _out = null;

      _userSock = null;
      _userOut = null;
      _userIn = null;
    }
    return connected;
  }