Ejemplo n.º 1
0
  /**
   * Deserializes an {@link MBeanFeatureInfo} from an {@link ObjectInputStream}.
   *
   * @serialData For compatibility reasons, an object of this class is deserialized as follows.
   *     <ul>
   *       The method {@link ObjectInputStream#defaultReadObject defaultReadObject()} is called
   *       first to deserialize the object except the field {@code descriptor}, which is not
   *       serialized in the default way. Then the method {@link ObjectInputStream#read read()} is
   *       called to read a byte, the field {@code descriptor} is deserialized according to the
   *       value of the byte value:
   *       <ul>
   *         <li>1. The method {@link ObjectInputStream#readObject readObject()} is called twice to
   *             obtain the field names (a {@code String[]}) and the field values (a {@code
   *             Object[]}) of the {@code descriptor}. The two obtained values then are used to
   *             construct an {@link ImmutableDescriptor} instance for the field {@code descriptor};
   *         <li>0. The value for the field {@code descriptor} is obtained directly by calling the
   *             method {@link ObjectInputStream#readObject readObject()}. If the obtained value is
   *             null, the field {@code descriptor} is set to {@link
   *             ImmutableDescriptor#EMPTY_DESCRIPTOR EMPTY_DESCRIPTOR};
   *         <li>-1. This means that there is no byte to read and that the object is from an earlier
   *             version of the JMX API. The field {@code descriptor} is set to {@link
   *             ImmutableDescriptor#EMPTY_DESCRIPTOR EMPTY_DESCRIPTOR}
   *         <li>Any other value. A {@link StreamCorruptedException} is thrown.
   *       </ul>
   *     </ul>
   *
   * @since 1.6
   */
  private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

    in.defaultReadObject();

    switch (in.read()) {
      case 1:
        final String[] names = (String[]) in.readObject();

        if (names.length == 0) {
          descriptor = ImmutableDescriptor.EMPTY_DESCRIPTOR;
        } else {
          final Object[] values = (Object[]) in.readObject();
          descriptor = new ImmutableDescriptor(names, values);
        }

        break;
      case 0:
        descriptor = (Descriptor) in.readObject();

        if (descriptor == null) {
          descriptor = ImmutableDescriptor.EMPTY_DESCRIPTOR;
        }

        break;
      case -1: // from an earlier version of the JMX API
        descriptor = ImmutableDescriptor.EMPTY_DESCRIPTOR;

        break;
      default:
        throw new StreamCorruptedException("Got unexpected byte.");
    }
  }
Ejemplo n.º 2
0
  public static Serializable safeDeserialize(ObjectInputStream in) throws IOException {
    if (!in.readBoolean()) {
      return null;
    }

    int length = in.readInt();

    if (length > buffer.length - 4) {
      buffer = new byte[length];
    }

    in.read(buffer, 0, length);
    buffer[length] = (byte) 0xFF;
    buffer[length + 1] = (byte) 0xFF;
    buffer[length + 2] = (byte) 0xFF;
    buffer[length + 3] = (byte) 0xFF;

    Serializable object;

    try {
      object = deserializeRaw(buffer);
    } catch (ClassNotFoundException cnfe) {
      SerializedData dummy = new SerializedData();
      dummy.serialData = Arrays.copyOf(buffer, length);
      object = dummy;
    }

    return object;
  }
 /** java.io.ObjectOutputStream#write(int) */
 public void test_writeI() throws Exception {
   // Test for method void java.io.ObjectOutputStream.write(int)
   oos.write('T');
   oos.close();
   ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
   assertEquals("Read incorrect byte", 'T', ois.read());
   ois.close();
 }
Ejemplo n.º 4
0
  public Game(boolean host) {
    try {
      if (host) {
        System.out.println("Hosting...");
        server = new ServerSocket(port, 4, InetAddress.getByName(serverIP));
        System.out.println("Ready!\nAwaiting client...");
        client = server.accept();
        System.out.println("Client connected!\nBuffering...");
        out = new ObjectOutputStream(client.getOutputStream());
        in = new ObjectInputStream(client.getInputStream());
        System.out.println("Buffered!\nPinging for 256 bytes...");
        long start = System.currentTimeMillis();
        byte[] ping = new byte[256];
        in.read(ping);
        System.out.println("Latency: " + (System.currentTimeMillis() - start));
        out.writeLong(start);
        out.flush();
        System.out.println("Starting threads...");
        new ThreadSend(world, out);
        new ThreadReceive(world, in);
        System.out.println("Started!\nCreating game world...");
      } else {
        System.out.println("Connecting...");
        socket = new Socket(connectIP, port);
        System.out.println("Connected!\nBuffering...");
        in = new ObjectInputStream(socket.getInputStream());
        out = new ObjectOutputStream(socket.getOutputStream());
        byte[] ping = new byte[256];
        new Random().nextBytes(ping);
        System.out.println("Buffered\nPinging for 256 bytes...");
        out.write(ping);
        out.flush();
        long latency = in.readLong();
        System.out.println("Latency: " + (System.currentTimeMillis() - latency));
        System.out.println("Starting threads...");
        new ThreadReceive(world, in);
        new ThreadSend(world, out);
        System.out.println("Started!\nCreating game world...");
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    try {
      Display.setDisplayMode(new DisplayMode(width, height));
      Display.create();
    } catch (Exception e) {
      e.printStackTrace();
    }

    world.init();

    while (!Display.isCloseRequested()) {
      if (ended) break;
      world.update();
    }

    Display.destroy();
  }
Ejemplo n.º 5
0
 public void objectInputStreamNotClosedAfterRead() {
   ObjectInputStream oin;
   try {
     oin = new ObjectInputStream(new FileInputStream("file.txt"));
     oin.read();
     oin.close();
   } catch (IOException e) {
   }
 }
 /** java.io.ObjectOutputStream#write(byte[]) */
 public void test_write$B() throws Exception {
   // Test for method void java.io.ObjectOutputStream.write(byte [])
   byte[] buf = new byte[10];
   oos.write("HelloWorld".getBytes());
   oos.close();
   ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
   ois.read(buf, 0, 10);
   ois.close();
   assertEquals("Read incorrect bytes", "HelloWorld", new String(buf, 0, 10));
 }
Ejemplo n.º 7
0
  private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
    in.defaultReadObject();

    int length = in.readInt();
    if (length != 0) {
      byte[] json = new byte[length];
      in.read(json);

      Schema schema = new Schema.Parser().parse(new String(json));
      setSchema(schema);
    }
  }
Ejemplo n.º 8
0
 @SuppressWarnings("unchecked")
 private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
   try {
     in.read(new byte["factory".length()], 0, "factory".length());
     in.read(); // ':'
     int length = in.readInt();
     in.read(); // ':'
     byte[] factoryName = new byte[length];
     in.read(factoryName, 0, length);
     in.read(); // ':'
     Class<?> clazz = getClass().getClassLoader().loadClass(new String(factoryName, "UTF8"));
     this.vf = (IValueFactory) clazz.getMethod("getInstance").invoke(null, new Object[0]);
     this.value = (T) new BinaryValueReader().read(vf, in);
   } catch (InvocationTargetException
       | IllegalAccessException
       | IllegalArgumentException
       | NoSuchMethodException
       | SecurityException
       | ClassCastException e) {
     throw new IOException("Could not load IValueFactory", e);
   }
 }
Ejemplo n.º 9
0
    /**
     * Constructor that takes existing the signature data
     *
     * @param sigData Existing signature data
     * @throws OpenStegoException
     */
    public Signature(byte[] sigData) throws OpenStegoException {
      ObjectInputStream ois = null;
      byte[] inputSig = new byte[this.sig.length];

      try {
        ois = new ObjectInputStream(new ByteArrayInputStream(sigData));
        ois.read(inputSig, 0, this.sig.length);
        if (!(new String(this.sig)).equals(new String(inputSig))) {
          throw new OpenStegoException(null, NAMESPACE, DWTXieErrors.ERR_SIG_NOT_VALID);
        }

        this.watermarkLength = ois.readInt();
        this.embeddingStrength = ois.readDouble();
        this.waveletFilterMethod = ois.readInt();
        this.filterID = ois.readInt();
        this.embeddingLevel = ois.readInt();

        this.watermark = new byte[this.watermarkLength];
        ois.read(this.watermark);
      } catch (IOException ioEx) {
        throw new OpenStegoException(ioEx);
      }
    }
Ejemplo n.º 10
0
  @Override
  public Object decode(byte[] data) {

    try {
      ObjectInputStream oin = new ObjectInputStream(new ByteArrayInputStream(data));
      int classNameLength = oin.readInt();
      byte[] buff = new byte[classNameLength];
      oin.read(buff);
      String className = new String(buff, Encoding.DEFAULT);
      Class<?> klass = Class.forName(className);
      return mapper.readValue(oin, klass);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
Ejemplo n.º 11
0
 public static Download createFrom(ObjectInputStream in, DownloadManager m) throws IOException {
   try {
     Hash h = new Hash();
     int r = in.read(h.array());
     String fn = in.readUTF();
     ArrayList<Integer> guids = (ArrayList<Integer>) in.readObject();
     if (T.t) {
       T.ass(r == h.array().length, "Incorrect length when deserializing download");
     }
     BlockStorage bs = BlockStorage.getById(m.getCore(), in.readInt());
     Download d = new Download(m, h, bs, fn, guids);
     d.fd = d.manager.getCore().getFileManager().getFd(h);
     return d;
   } catch (ClassNotFoundException e) {
     throw new IOException("Could not find class while deserializing: " + e);
   }
 }
Ejemplo n.º 12
0
  private synchronized void startListener() {
    byte[] buffer = new byte[1024];
    int tamanhoBuffer;

    while (true) {
      try {
        ObjectInputStream ois = new ObjectInputStream(streamDeEntrada);
        tamanhoBuffer = ois.read(buffer);
        // tamanhoBuffer = streamDeEntrada.read(buffer);
        this.handle
            .obtainMessage(ManipuladorProtocolo.RECEBER_MENSAGEM, tamanhoBuffer, -1, buffer)
            .sendToTarget();
        buffer = new byte[1024];
      } catch (IOException e) {
        Log.e(TAG, "Um erro ocorreu enquanto recebia dados.", e);
        break;
      }
    }
  }
Ejemplo n.º 13
0
 /**
  * Retrieves the hashTable from the file specified by <i>source</i>.
  *
  * @param source the name of the file from which the hashTable is to be retrieved.
  * @pre <i>None</i>
  * @post If there is any error &rArr; LocalObjectId.nextId = LocalObjectId.INITIAL_ID and
  *     |hashTable| = 0 Else the hashTable in the specified file is retrieved and stored in
  *     hashTable AND LocalObjectId.nextId = |hashTable|
  */
 public void restore(String source) {
   String fileLocation = DEFAULT_FILE_LOCATION;
   if (FILE_LOCATION != null) {
     fileLocation = FILE_LOCATION;
   }
   if (source != null) {
     fileLocation = source;
   }
   try {
     ObjectInputStream ois =
         new ObjectInputStream(new BufferedInputStream(new FileInputStream(fileLocation)));
     int nextId = ois.read();
     LocalObjectId.setNextId(nextId);
     hashTable = (Hashtable<LocalObjectId, Object>) ois.readObject();
     ois.close();
   } catch (Exception e) {
     LocalObjectId.setNextId(LocalObjectId.INITIAL_ID);
     hashTable = new Hashtable<LocalObjectId, Object>();
   }
 }
 @Override
 public SecretKey loadKey() throws KeyLoadingException {
   // try to load key from file
   File keyFile = new File(FileSystemService.getUserRapidMinerDir(), DEFAULTKEY_FILE_NAME);
   try (FileInputStream fis = new FileInputStream(keyFile);
       ObjectInputStream in = new ObjectInputStream(fis)) {
     int length = in.readInt();
     byte[] rawKey = new byte[length];
     int actualLength = in.read(rawKey);
     if (length != actualLength) {
       throw new IOException("Cannot read key file (unexpected length)");
     }
     return KeyGeneratorTool.makeKey(rawKey);
   } catch (IOException e) {
     // catch to log the problem, then throw again to indicate error
     LogService.getRoot()
         .log(
             Level.WARNING,
             "com.rapidminer.tools.cipher.KeyGeneratorTool.read_key_error",
             e.getMessage());
     throw new KeyLoadingException("Cannot retrieve key: " + e.getMessage());
   }
 }
Ejemplo n.º 15
0
 /**
  * Reads a serialized simple time zone from stream.
  *
  * @see #writeObject
  */
 private void readObject(java.io.ObjectInputStream input)
     throws java.io.IOException, ClassNotFoundException {
   input.defaultReadObject();
   if (serialVersionOnStream == 0) {
     // initialize the new fields to default values.
     dstSavings = 60 * 60 * 1000;
     endMode = DOW_IN_MONTH_MODE;
     startMode = DOW_IN_MONTH_MODE;
     serialVersionOnStream = 1;
   } else {
     int length = input.readInt();
     byte[] byteArray = new byte[length];
     input.read(byteArray, 0, length);
     if (length >= 4) {
       // Lets hope that Sun does extensions to the serialized
       // form in a sane manner.
       startDay = byteArray[0];
       startDayOfWeek = byteArray[1];
       endDay = byteArray[2];
       endDayOfWeek = byteArray[3];
     }
   }
 }
Ejemplo n.º 16
0
  private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
    String remote = in.readUTF();
    String ext = ".data";
    int dot = remote.lastIndexOf('.');
    if (dot > 0) {
      ext = remote.substring(dot);
      remote = remote.substring(0, dot);
    }
    localPath = File.createTempFile(remote, ext);

    FileOutputStream fos = new FileOutputStream(localPath);
    try {
      long length = in.readLong();
      byte[] xfer = new byte[4096];
      while (length > 0) {
        int read = in.read(xfer, 0, (int) Math.min(xfer.length, length));
        if (read < 0) throw new EOFException("Unexpected EOF (" + length + " bytes remaining)");
        fos.write(xfer, 0, read);
        length -= read;
      }
    } finally {
      fos.close();
    }
  }
Ejemplo n.º 17
0
  private void doDownloadFile() throws IOException {
    try {
      final String base = (String) in.readObject(); // 第一次接收信息
      if (base == null) {
        out.write(FileBaseInfo.ANSWER_NO); // 第一次发送信息(取消)
        out.flush();
        return;
      }
      out.write(FileBaseInfo.ANSWER_YES); // 第一次发送信息(继续)
      out.flush();

      final long totalLength = in.readLong(); // 第二次接收信息(总长度)
      log.debug("totalLength : " + totalLength);
      getDisplay()
          .syncExec(
              new Runnable() {
                public void run() {
                  setMaximum(totalLength);
                  lblMsg.setText("Downloading file...");
                }
              });

      while (in.read() == FileBaseInfo.GOON) { // 连续接收信息
        byte fileOrFolder = (byte) in.read();
        String name = (String) in.readObject();
        final File f = new File(base + File.separatorChar + name);
        log.debug("download file: " + f);

        if (fileOrFolder == FileBaseInfo.FOLDER) {
          f.mkdir();
        } else {
          final long length = in.readLong();
          getDisplay()
              .syncExec(
                  new Runnable() {
                    public void run() {
                      lblFile.setText(
                          "File:\""
                              + f.getPath()
                              + "\" Size:"
                              + Util.byteCountToDisplaySize(length));
                    }
                  });
          RandomAccessFile raout = null;
          try {
            raout = new RandomAccessFile(f, "rw");
            StreamUtil2.copy(in, raout, length, FileDownloadShell.this);
          } catch (Exception e) {
            if (running) log.error("establish file error", e);
            f.delete();
            throw e;
          } finally {
            Util.closeQuietly(raout, log);
          }
        }
      }
      getDisplay()
          .syncExec(
              new Runnable() {
                public void run() {
                  lblMsg.setText("Download finished");
                  lblFile.setText("");
                  openFile(base);
                  FileDownloadShell.this.dispose();
                }
              });
    } catch (final Exception e) {
      if (running) {
        log.error("download file error", e);
        getDisplay()
            .syncExec(
                new Runnable() {
                  public void run() {
                    MessageDialog.openError(FileDownloadShell.this, "Error", e.getMessage());
                    FileDownloadShell.this.dispose();
                  }
                });
      }
    }
  }
  /** The run method. */
  public void run() {
    instances.add(this);
    try {
      listener.startUnpack();
      String currentOs = System.getProperty("os.name").toLowerCase();
      //
      // Initialisations
      FileOutputStream out = null;
      ArrayList parsables = new ArrayList();
      ArrayList executables = new ArrayList();
      List packs = idata.selectedPacks;
      int npacks = packs.size();
      udata = UninstallData.getInstance();

      // Specific to the web installers
      if (idata.kind.equalsIgnoreCase("web") || idata.kind.equalsIgnoreCase("web-kunststoff")) {
        InputStream kin = getClass().getResourceAsStream("/res/WebInstallers.url");
        BufferedReader kreader = new BufferedReader(new InputStreamReader(kin));
        jarLocation = kreader.readLine();
      }

      // We unpack the selected packs
      for (int i = 0; i < npacks; i++) {
        // We get the pack stream
        int n = idata.allPacks.indexOf(packs.get(i));
        ObjectInputStream objIn = new ObjectInputStream(getPackAsStream(n));

        // We unpack the files
        int nfiles = objIn.readInt();
        listener.changeUnpack(0, nfiles, ((Pack) packs.get(i)).name);
        for (int j = 0; j < nfiles; j++) {
          // We read the header
          PackFile pf = (PackFile) objIn.readObject();
          if (null == pf.os || matchOS(currentOs, pf.os.toLowerCase())) {
            // We translate & build the path
            String path = translatePath(pf.targetPath);
            File pathFile = new File(path);
            String fname = pathFile.getName();
            int z = fname.length();
            File dest = pathFile.getParentFile();
            if (!dest.exists()) dest.mkdirs();

            // We add the path to the log,
            udata.addFile(path);

            listener.progressUnpack(j, path);

            // if this file exists and shouldnot override skip this file
            if (((pf.override == false) && (pathFile.exists()))) {
              objIn.skip(pf.length);
              continue;
            }

            // We copy the file
            out = new FileOutputStream(path);
            byte[] buffer = new byte[5120];
            long bytesCopied = 0;
            while (bytesCopied < pf.length) {
              int maxBytes =
                  (pf.length - bytesCopied < buffer.length
                      ? (int) (pf.length - bytesCopied)
                      : buffer.length);
              int bytesInBuffer = objIn.read(buffer, 0, maxBytes);
              if (bytesInBuffer == -1) throw new IOException("Unexpected end of stream");

              out.write(buffer, 0, bytesInBuffer);

              bytesCopied += bytesInBuffer;
            }
            // Cleanings
            out.close();

            // Empty dirs restoring
            String _n = pathFile.getName();
            if (_n.startsWith("izpack-keepme") && _n.endsWith(".tmp")) pathFile.delete();

          } else objIn.skip(pf.length);
        }

        // Load information about parsable files
        int numParsables = objIn.readInt();
        int k;
        for (k = 0; k < numParsables; k++) {
          ParsableFile pf = (ParsableFile) objIn.readObject();
          pf.path = translatePath(pf.path);
          parsables.add(pf);
        }

        // Load information about executable files
        int numExecutables = objIn.readInt();
        for (k = 0; k < numExecutables; k++) {
          ExecutableFile ef = (ExecutableFile) objIn.readObject();
          ef.path = translatePath(ef.path);
          if (null != ef.argList && !ef.argList.isEmpty()) {
            String arg = null;
            for (int j = 0; j < ef.argList.size(); j++) {
              arg = (String) ef.argList.get(j);
              arg = translatePath(arg);
              ef.argList.set(j, arg);
            }
          }
          executables.add(ef);
          if (ef.executionStage == ExecutableFile.UNINSTALL) {
            udata.addExecutable(ef);
          }
        }
        objIn.close();
      }

      // We use the scripts parser
      ScriptParser parser = new ScriptParser(parsables, vs);
      parser.parseFiles();

      // We use the file executor
      FileExecutor executor = new FileExecutor(executables);
      if (executor.executeFiles(ExecutableFile.POSTINSTALL) != 0)
        javax.swing.JOptionPane.showMessageDialog(
            null,
            "The installation was not completed.",
            "Installation warning",
            javax.swing.JOptionPane.WARNING_MESSAGE);

      // We put the uninstaller
      putUninstaller();

      // The end :-)
      listener.stopUnpack();
    } catch (Exception err) {
      listener.stopUnpack();
      listener.errorUnpack(err.toString());
    }
    instances.remove(instances.indexOf(this));
  }