Exemple #1
1
  public static String submitPostData(String pos, String data) throws IOException {
    Log.v("req", data);

    URL url = new URL(urlPre + pos);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    configConnection(connection);
    if (sCookie != null && sCookie.length() > 0) {
      connection.setRequestProperty("Cookie", sCookie);
    }
    connection.connect();

    // Send data
    DataOutputStream output = new DataOutputStream(connection.getOutputStream());
    output.write(data.getBytes());
    output.flush();
    output.close();

    // check Cookie
    String cookie = connection.getHeaderField("set-cookie");
    if (cookie != null && !cookie.equals(sCookie)) {
      sCookie = cookie;
    }

    // Respond
    BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
    StringBuilder sb = new StringBuilder();
    String line = null;
    while ((line = reader.readLine()) != null) {
      sb.append(line + "\n");
    }
    connection.disconnect();
    String res = sb.toString();
    Log.v("res", res);
    return res;
  }
Exemple #2
0
  public void testLease() throws Exception {
    Configuration conf = new Configuration();
    MiniDFSCluster cluster = new MiniDFSCluster(conf, 2, true, null);
    try {
      FileSystem fs = cluster.getFileSystem();
      assertTrue(fs.mkdirs(dir));

      Path a = new Path(dir, "a");
      Path b = new Path(dir, "b");

      DataOutputStream a_out = fs.create(a);
      a_out.writeBytes("something");

      assertTrue(hasLease(cluster, a));
      assertTrue(!hasLease(cluster, b));

      DataOutputStream b_out = fs.create(b);
      b_out.writeBytes("something");

      assertTrue(hasLease(cluster, a));
      assertTrue(hasLease(cluster, b));

      a_out.close();
      b_out.close();

      assertTrue(!hasLease(cluster, a));
      assertTrue(!hasLease(cluster, b));

      fs.delete(dir, true);
    } finally {
      if (cluster != null) {
        cluster.shutdown();
      }
    }
  }
    @Override
    public void close() {
      System.err.println(
          "Target: " + vocE.size() + " types. Writing to " + job_.get("root", null) + "/vocab.E");
      System.err.println(
          "Source: " + vocF.size() + " types .Writing to " + job_.get("root", null) + "/vocab.F");

      // write out vocabulary to file
      try {
        FileSystem fs = FileSystem.get(job_);

        DataOutputStream dos =
            new DataOutputStream(
                new BufferedOutputStream(fs.create(new Path(job_.get("root", null) + "/vocab.E"))));
        ((VocabularyWritable) vocE).write(dos);
        dos.close();
        DataOutputStream dos2 =
            new DataOutputStream(
                new BufferedOutputStream(fs.create(new Path(job_.get("root", null) + "/vocab.F"))));
        ((VocabularyWritable) vocF).write(dos2);
        dos2.close();

      } catch (IOException e) {
        throw new RuntimeException("Vocab couldn't be written to disk.\n" + e.toString());
      }
    }
  /* Save generated parameters in a binary file */
  public void saveParam(String fileName, HTSPStream par, HMMData.FeatureType type) {
    int t, m, i;
    try {

      if (type == HMMData.FeatureType.LF0) {
        fileName += ".f0";
        DataOutputStream data_out = new DataOutputStream(new FileOutputStream(fileName));
        i = 0;
        for (t = 0; t < voiced.length; t++) {
            /* here par.getT are just the voiced!!! */
          if (voiced[t]) {
            data_out.writeFloat((float) Math.exp(par.getPar(i, 0)));
            i++;
          } else data_out.writeFloat((float) 0.0);
        }
        data_out.close();

      } else if (type == HMMData.FeatureType.MGC) {
        fileName += ".mgc";
        DataOutputStream data_out = new DataOutputStream(new FileOutputStream(fileName));
        for (t = 0; t < par.getT(); t++)
          for (m = 0; m < par.getOrder(); m++) data_out.writeFloat((float) par.getPar(t, m));
        data_out.close();
      }

      logger.info("saveParam in file: " + fileName);

    } catch (IOException e) {
      logger.info("IO exception = " + e);
    }
  }
 private String getString(PublicKey key) throws FailedLoginException {
   try {
     if (key instanceof DSAPublicKey) {
       DSAPublicKey dsa = (DSAPublicKey) key;
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       DataOutputStream dos = new DataOutputStream(baos);
       write(dos, "ssh-dss");
       write(dos, dsa.getParams().getP());
       write(dos, dsa.getParams().getQ());
       write(dos, dsa.getParams().getG());
       write(dos, dsa.getY());
       dos.close();
       return base64Encode(baos.toByteArray());
     } else if (key instanceof RSAKey) {
       RSAPublicKey rsa = (RSAPublicKey) key;
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       DataOutputStream dos = new DataOutputStream(baos);
       write(dos, "ssh-rsa");
       write(dos, rsa.getPublicExponent());
       write(dos, rsa.getModulus());
       dos.close();
       return base64Encode(baos.toByteArray());
     } else {
       throw new FailedLoginException("Unsupported key type " + key.getClass().toString());
     }
   } catch (IOException e) {
     throw new FailedLoginException("Unable to check public key");
   }
 }
 private void writeVersion() throws IOException {
   DataOutputStream out = this.writer.prepareAppendKey(-1);
   VERSION_KEY.write(out);
   out.close();
   out = this.writer.prepareAppendValue(-1);
   out.writeInt(VERSION);
   out.close();
 }
 public void writeApplicationOwner(String user) throws IOException {
   DataOutputStream out = this.writer.prepareAppendKey(-1);
   APPLICATION_OWNER_KEY.write(out);
   out.close();
   out = this.writer.prepareAppendValue(-1);
   out.writeUTF(user);
   out.close();
 }
 public void append(LogKey logKey, LogValue logValue) throws IOException {
   DataOutputStream out = this.writer.prepareAppendKey(-1);
   logKey.write(out);
   out.close();
   out = this.writer.prepareAppendValue(-1);
   logValue.write(out);
   out.close();
 }
Exemple #9
0
  void removeEntry(String entry, boolean first) {
    String[] params = entry.split(",");
    entry = params[0] + " " + params[1];
    List<String> hosts = new ArrayList<String>();
    try {
      Process proc = Runtime.getRuntime().exec("cat /etc/hosts");
      BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
      String line = null;
      while ((line = reader.readLine()) != null) {
        if (!line.equals("") && line != null) {
          if (line.contains(entry) && first) {
            first = false;
          } else if (line.contains(entry) && !first) {
            hosts.add(line);
          } else if (!line.contains(entry)) {
            hosts.add(line);
          }
        }
      }
    } catch (Exception e) {

    }
    if (hosts.size() > 0) {
      try {
        Process proc = Runtime.getRuntime().exec("su");
        DataOutputStream os = new DataOutputStream(proc.getOutputStream());
        os.writeBytes("mount -o rw,remount -t " + fs + " " + block + " /system\n");
        os.writeBytes("echo '' > /etc/hosts\n");
        for (String s : hosts) {
          os.writeBytes("echo '" + s + "' >> /etc/hosts\n");
        }
        os.writeBytes("mount -o ro,remount -t " + fs + " " + block + " /system\n");
        os.writeBytes("exit\n");
        os.flush();
        os.close();
        proc.waitFor();
      } catch (Exception e) {

      }
    } else {
      try {
        Process proc = Runtime.getRuntime().exec("su");
        DataOutputStream os = new DataOutputStream(proc.getOutputStream());
        os.writeBytes("mount -o rw,remount -t " + fs + " " + block + " /system\n");
        os.writeBytes("echo '' > /etc/hosts\n");
        os.writeBytes("mount -o ro,remount -t " + fs + " " + block + " /system\n");
        os.writeBytes("exit\n");
        os.flush();
        os.close();
        proc.waitFor();
      } catch (Exception e) {

      }
    }
  }
 public void writeApplicationACLs(Map<ApplicationAccessType, String> appAcls)
     throws IOException {
   DataOutputStream out = this.writer.prepareAppendKey(-1);
   APPLICATION_ACL_KEY.write(out);
   out.close();
   out = this.writer.prepareAppendValue(-1);
   for (Entry<ApplicationAccessType, String> entry : appAcls.entrySet()) {
     out.writeUTF(entry.getKey().toString());
     out.writeUTF(entry.getValue());
   }
   out.close();
 }
  @Override
  protected void populateObject(Object object) throws Exception {
    super.populateObject(object);
    Message info = (Message) object;

    info.setProducerId(createProducerId("ProducerId:1"));
    info.setDestination(createActiveMQDestination("Destination:2"));
    info.setTransactionId(createTransactionId("TransactionId:3"));
    info.setOriginalDestination(createActiveMQDestination("OriginalDestination:4"));
    info.setMessageId(createMessageId("MessageId:5"));
    info.setOriginalTransactionId(createTransactionId("OriginalTransactionId:6"));
    info.setGroupID("GroupID:7");
    info.setGroupSequence(1);
    info.setCorrelationId("CorrelationId:8");
    info.setPersistent(true);
    info.setExpiration(1);
    info.setPriority((byte) 1);
    info.setReplyTo(createActiveMQDestination("ReplyTo:9"));
    info.setTimestamp(2);
    info.setType("Type:10");
    {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      DataOutputStream dataOut = new DataOutputStream(baos);
      MarshallingSupport.writeUTF8(dataOut, "Content:11");
      dataOut.close();
      info.setContent(baos.toByteSequence());
    }
    {
      Map map = new HashMap();
      map.put("MarshalledProperties", 12);
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      DataOutputStream os = new DataOutputStream(baos);
      MarshallingSupport.marshalPrimitiveMap(map, os);
      os.close();
      info.setMarshalledProperties(baos.toByteSequence());
    }
    info.setDataStructure(createDataStructure("DataStructure:13"));
    info.setTargetConsumerId(createConsumerId("TargetConsumerId:14"));
    info.setCompressed(false);
    info.setRedeliveryCounter(2);
    {
      BrokerId value[] = new BrokerId[2];
      for (int i = 0; i < 2; i++) {
        value[i] = createBrokerId("BrokerPath:15");
      }
      info.setBrokerPath(value);
    }
    info.setArrival(3);
    info.setUserID("UserID:16");
    info.setRecievedByDFBridge(true);
    info.setDroppable(false);
  }
 public ActiveMQMessage convertFrame(StompProtocolConverter converter, StompFrame command)
     throws JMSException, ProtocolException {
   final Map<?, ?> headers = command.getHeaders();
   final ActiveMQMessage msg;
   /*
    * To reduce the complexity of this method perhaps a Chain of Responsibility
    * would be a better implementation
    */
   if (headers.containsKey(Stomp.Headers.AMQ_MESSAGE_TYPE)) {
     String intendedType = (String) headers.get(Stomp.Headers.AMQ_MESSAGE_TYPE);
     if (intendedType.equalsIgnoreCase("text")) {
       ActiveMQTextMessage text = new ActiveMQTextMessage();
       try {
         ByteArrayOutputStream bytes = new ByteArrayOutputStream(command.getContent().length + 4);
         DataOutputStream data = new DataOutputStream(bytes);
         data.writeInt(command.getContent().length);
         data.write(command.getContent());
         text.setContent(bytes.toByteSequence());
         data.close();
       } catch (Throwable e) {
         throw new ProtocolException("Text could not bet set: " + e, false, e);
       }
       msg = text;
     } else if (intendedType.equalsIgnoreCase("bytes")) {
       ActiveMQBytesMessage byteMessage = new ActiveMQBytesMessage();
       byteMessage.writeBytes(command.getContent());
       msg = byteMessage;
     } else {
       throw new ProtocolException("Unsupported message type '" + intendedType + "'", false);
     }
   } else if (headers.containsKey(Stomp.Headers.CONTENT_LENGTH)) {
     headers.remove(Stomp.Headers.CONTENT_LENGTH);
     ActiveMQBytesMessage bm = new ActiveMQBytesMessage();
     bm.writeBytes(command.getContent());
     msg = bm;
   } else {
     ActiveMQTextMessage text = new ActiveMQTextMessage();
     try {
       ByteArrayOutputStream bytes = new ByteArrayOutputStream(command.getContent().length + 4);
       DataOutputStream data = new DataOutputStream(bytes);
       data.writeInt(command.getContent().length);
       data.write(command.getContent());
       text.setContent(bytes.toByteSequence());
       data.close();
     } catch (Throwable e) {
       throw new ProtocolException("Text could not bet set: " + e, false, e);
     }
     msg = text;
   }
   Helper.copyStandardHeadersFromFrameToMessage(converter, command, msg, this);
   return msg;
 }
 /**
  * Collect all column values for the same Row. RowKey may be different if indexes are involved, so
  * it writes a separate record for each unique RowKey
  *
  * @param context Current mapper context
  * @param tableName Table index in tableNames list
  * @param lkv List of KV values that will be combined in a single ImmutableBytesWritable
  * @throws IOException
  * @throws InterruptedException
  */
 private void writeAggregatedRow(Context context, String tableName, List<KeyValue> lkv)
     throws IOException, InterruptedException {
   ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
   DataOutputStream outputStream = new DataOutputStream(bos);
   ImmutableBytesWritable outputKey = null;
   if (!lkv.isEmpty()) {
     for (KeyValue cell : lkv) {
       if (outputKey == null
           || Bytes.compareTo(
                   outputKey.get(),
                   outputKey.getOffset(),
                   outputKey.getLength(),
                   cell.getRowArray(),
                   cell.getRowOffset(),
                   cell.getRowLength())
               != 0) {
         // This a the first RowKey or a different from previous
         if (outputKey != null) { // It's a different RowKey, so we need to write it
           ImmutableBytesWritable aggregatedArray = new ImmutableBytesWritable(bos.toByteArray());
           outputStream.close();
           context.write(new TableRowkeyPair(tableName, outputKey), aggregatedArray);
         }
         outputKey =
             new ImmutableBytesWritable(
                 cell.getRowArray(), cell.getRowOffset(), cell.getRowLength());
         bos = new ByteArrayOutputStream(1024);
         outputStream = new DataOutputStream(bos);
       }
       /*
       The order of aggregation: type, index of column, length of value, value itself
        */
       int i = findIndex(cell);
       if (i == -1) {
         // That may happen when we load only local indexes. Since KV pairs for both
         // table and local index are going to the same physical table at that point
         // we skip those KVs that are not belongs to loca index
         continue;
       }
       outputStream.writeByte(cell.getTypeByte());
       WritableUtils.writeVInt(outputStream, i);
       WritableUtils.writeVInt(outputStream, cell.getValueLength());
       outputStream.write(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
     }
     ImmutableBytesWritable aggregatedArray = new ImmutableBytesWritable(bos.toByteArray());
     outputStream.close();
     context.write(new TableRowkeyPair(tableName, outputKey), aggregatedArray);
   }
 }
  public int a(String var1) {
    Short var2 = (Short) d.get(var1);
    if (var2 == null) {
      var2 = Short.valueOf((short) 0);
    } else {
      var2 = Short.valueOf((short) (var2.shortValue() + 1));
    }

    d.put(var1, var2);
    if (b == null) {
      return var2.shortValue();
    } else {
      try {
        File var3 = b.a("idcounts");
        if (var3 != null) {
          class_dn var4 = new class_dn();
          Iterator var5 = d.keySet().iterator();

          while (var5.hasNext()) {
            String var6 = (String) var5.next();
            short var7 = ((Short) d.get(var6)).shortValue();
            var4.a(var6, var7);
          }

          DataOutputStream var9 = new DataOutputStream(new FileOutputStream(var3));
          class_dx.a(var4, (DataOutput) var9);
          var9.close();
        }
      } catch (Exception var8) {
        var8.printStackTrace();
      }

      return var2.shortValue();
    }
  }
  /**
   * DO NOT call symbolTable.addReference in writeObject as this (may) result in a
   * concurrentModificationException.
   *
   * <p>All references should be created in the constructor
   */
  public void writeObject(DataOutput out) throws IOException {
    boolean sgIO = node instanceof com.sun.j3d.utils.scenegraph.io.SceneGraphIO;
    out.writeBoolean(sgIO);
    out.writeInt(symbol.nodeID);

    int nodeClassID = control.getNodeClassID(node);

    out.writeShort(nodeClassID);

    if (nodeClassID == -1) out.writeUTF(nodeClassName);

    writeConstructorParams(out);

    if (sgIO) {
      ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
      DataOutputStream tmpOut = new DataOutputStream(byteStream);
      ((com.sun.j3d.utils.scenegraph.io.SceneGraphIO) node).writeSceneGraphObject(tmpOut);
      tmpOut.close();
      out.writeInt(byteStream.size());
      out.write(byteStream.toByteArray());
    }

    writeUserData(out);
    writeString(node.getName(), out);

    writeCapabilities(out);
  }
  public void update(Observable source, Object object) {
    if (source instanceof Users) {
      if (!this.isDisabled()) {
        try {
          Operations.sendUserNamesList(users.getUserNames(), out);
        } catch (IOException io) {
          logger.error("IO Exception", io);
        }
      }
    }

    if (source instanceof Messages) {
      try {
        Operations.sendMessage((MessageType) object, out);
      } catch (IOException io) {
        if (out != null) {
          try {
            out.close();
          } catch (Exception ioe) {
            logger.error("Failed to close the output stream", ioe);
          }
        }

        logger.error("Impossible to send messages", io);
      }
    }
  }
 @Test
 public void dataRoundTrip() throws IOException {
   dos.writeUTF("Hello, world!");
   dos.writeInt(0xCAFEBABE);
   dos.writeUTF("Over & out.");
   dos.close();
   //    aos.close(); // important?
   byte[] bs = bos.toByteArray();
   if (verbose) {
     for (int i = 0; i < bs.length; i++) {
       System.out.printf("%02x ", bs[i]);
       if (i % 16 == 15) System.out.println();
     }
     System.out.println();
   }
   PPMModel pi = new PPMModel(4);
   ByteArrayInputStream bis = new ByteArrayInputStream(bs);
   ArithCodeInputStream ais = new ArithCodeInputStream(bis, pi);
   DataInputStream dis = new DataInputStream(ais);
   String s1 = dis.readUTF();
   assert s1.equals("Hello, world!") : s1;
   int i1 = dis.readInt();
   assert 0xCAFEBABE == i1 : i1;
   String s2 = dis.readUTF();
   assert s2.equals("Over & out.") : s2;
   int i2 = dis.read();
   assert -1 == i2 : i2;
 }
  public PacketSelectionUpdate(PlayerInfo info) {
    packet = new Packet250CustomPayload();

    ByteArrayOutputStream streambyte = new ByteArrayOutputStream();
    DataOutputStream stream = new DataOutputStream(streambyte);

    try {
      stream.write(packetID);

      if (info != null && info.getPoint1() != null) {
        Point p1 = info.getPoint1();
        stream.writeBoolean(true);
        stream.writeInt(p1.x);
        stream.writeInt(p1.y);
        stream.writeInt(p1.z);
      } else stream.writeBoolean(false);

      if (info != null && info.getPoint2() != null) {
        Point p2 = info.getPoint2();
        stream.writeBoolean(true);
        stream.writeInt(p2.x);
        stream.writeInt(p2.y);
        stream.writeInt(p2.z);
      } else stream.writeBoolean(false);

      stream.close();
      streambyte.close();

      packet.channel = FECHANNEL;
      packet.data = streambyte.toByteArray();
      packet.length = packet.data.length;
    } catch (Exception e) {
      OutputHandler.SOP("Error creating packet >> " + this.getClass());
    }
  }
  private void configBody(String params) throws IOException {
    try {
      byte[] postData = params.getBytes(ENCODING_UTF);
      int postDataLength = postData.length;
      connection.setDoOutput(true);
      connection.setRequestProperty("charset", ENCODING_UTF);
      connection.setRequestProperty("Content-Length", Integer.toString(postDataLength));
      connection.setUseCaches(false);
      wr = new DataOutputStream(connection.getOutputStream());
      wr.write(postData);
    } catch (IOException e) {
      if (e instanceof ConnectException)
        throw new IOException("Problemas ao tentar conectar com o servidor.");

      throw new IOException("Problemas ao processar dados para envio.");
    } finally {
      if (wr != null) {
        try {
          wr.flush();
          wr.close();
        } catch (IOException e) {
          L.output(e.getMessage());
        }
      }
    }
  }
    protected JSONObject doInBackground(String... params) {
      try {
        URL url = new URL(params[0]);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        connection.setDoOutput(true);
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/json");

        JSONObject parameters = new JSONObject();
        parameters.put("hash", "274ffe280ad2956ea85f35986958095d");
        parameters.put("seed", "10");

        DataOutputStream wr = new DataOutputStream(connection.getOutputStream());

        wr.writeBytes(parameters.toString());
        wr.flush();
        wr.close();

        BufferedReader r = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        StringBuilder result = new StringBuilder();
        String line;
        while ((line = r.readLine()) != null) {
          result.append(line);
        }

        JSONObject obj = new JSONObject(result.toString());
        return obj;
      } catch (Exception e) {
        this.exception = e;
        return null;
      }
    }
Exemple #21
0
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    DataInputStream input = new DataInputStream(request.getInputStream());

    byte buff[];
    int leido = input.readByte();
    int tamano = leido;
    buff = new byte[tamano];
    leido = input.read(buff, 0, tamano);
    if (leido < tamano) {
      log.error("final inesperado");
      throw new IOException("Se leyo menos de los esperado");
    }
    input.close();
    String login = new String(buff);
    UsuarioDao dao = new UsuarioDao();
    BeanUsuario usuario = dao.getUsuarioByLogin(login);
    DataOutputStream output = new DataOutputStream(response.getOutputStream());
    if (usuario != null) {
      output.writeByte(1);
      usuario.write(output);
    } else {
      output.writeByte(0);
    }
    output.close();
  }
Exemple #22
0
  public void run() {
    try {
      DataInputStream in = new DataInputStream(sockd.getInputStream());
      DataOutputStream out = new DataOutputStream(sockd.getOutputStream());

      BufferedReader br = new BufferedReader(new InputStreamReader(in));
      BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
      vdb.setBw(bw);

      String name;

      while ((name = br.readLine()) != null) {
        System.out.println("graph for " + name);
        vdb.buildGraph(name, max_depth, peers_only);
        vdb.convertGraph();
        System.out.println("graph for " + name + " is ready");
        break;
      }

      br.close();
      in.close();
      bw.close();
      out.close();

      sockd.close();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
  public ActionForward createClassifications(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response)
      throws FenixFilterException, FenixServiceException, IOException {

    IUserView userView = UserView.getUser();

    DynaActionForm dynaActionForm = (DynaActionForm) form;
    Integer degreeCurricularPlanID = (Integer) dynaActionForm.get("degreeCurricularPlanID");
    Integer[] entryGradeLimits = (Integer[]) dynaActionForm.get("entryGradeLimits");
    Integer[] approvationRatioLimits = (Integer[]) dynaActionForm.get("approvationRatioLimits");
    Integer[] arithmeticMeanLimits = (Integer[]) dynaActionForm.get("arithmeticMeanLimits");

    Object[] args = {
      entryGradeLimits, approvationRatioLimits, arithmeticMeanLimits, degreeCurricularPlanID
    };
    ByteArrayOutputStream resultStream =
        (ByteArrayOutputStream)
            ServiceUtils.executeService("CreateClassificationsForStudents", args);

    String currentDate = new SimpleDateFormat("dd-MMM-yy.HH-mm").format(new Date());
    response.setHeader(
        "Content-disposition",
        "attachment;filename=" + degreeCurricularPlanID + "_" + currentDate + ".zip");
    response.setContentType("application/zip");
    DataOutputStream dos = new DataOutputStream(response.getOutputStream());
    dos.write(resultStream.toByteArray());
    dos.close();

    return null;
  }
  public String execSu(String cmd) {
    Log.d(TAG, "^ Executing as SU '" + cmd + "'");
    try {
      Process process = Runtime.getRuntime().exec("su");
      DataInputStream is = new DataInputStream(process.getInputStream());
      DataOutputStream os = new DataOutputStream(process.getOutputStream());
      os.writeBytes(cmd + "\n");
      os.writeBytes("exit\n");
      os.flush();
      os.close();

      BufferedReader reader = new BufferedReader(new InputStreamReader(is));

      try {
        String fullOutput = "";
        String line;
        while ((line = reader.readLine()) != null) {
          fullOutput = fullOutput + line + "\n";
        }
        return fullOutput;
      } catch (IOException e) { // It seems IOException is thrown when it reaches EOF.
        e.printStackTrace();
        Log.e(TAG, "^ execSU, IOException 1");
      }
      process.waitFor();

    } catch (IOException e) {
      e.printStackTrace();
      Log.e(TAG, "^ execSU, IOException 2");
    } catch (InterruptedException e) {
      e.printStackTrace();
      Log.e(TAG, "^ execSU, InterruptedException");
    }
    return "";
  }
Exemple #25
0
  @Override
  public void close() {
    if (debug)
      OLogManager.instance()
          .info(
              this,
              "%s - Closing socket...",
              socket != null ? " null possible previous close" : socket.getRemoteSocketAddress());

    try {
      if (in != null) {
        in.close();
        // in = null;
      }
    } catch (IOException e) {
      OLogManager.instance().debug(this, "Error during closing of input stream", e);
    }

    try {
      if (out != null) {
        out.close();
        // out = null;
      }
    } catch (IOException e) {
      OLogManager.instance().debug(this, "Error during closing of output stream", e);
    }

    super.close();
  }
Exemple #26
0
  public static void main(String[] args) {
    try {
      Socket s1 = new Socket("127.0.0.1", 57643);

      InputStream is = s1.getInputStream();
      DataInputStream dis = new DataInputStream(is);
      System.out.println(dis.readUTF());

      OutputStream os = s1.getOutputStream();
      DataOutputStream dos = new DataOutputStream(os);
      dos.writeUTF("Oh my gosh...");

      dis.close();
      is.close();
      dos.close();
      os.close();

      s1.close();
    } catch (ConnectException connExc) {
      connExc.printStackTrace();
      System.out.println("Server connection failed");
    } catch (IOException ioExc) {
      ioExc.printStackTrace();
    }
  }
 /** Closes open files. */
 private void close() throws IOException {
   sync();
   oos.close();
   fos.close();
   oos = null;
   fos = null;
 }
    public void run() {
      try {
        // 读取客户端数据
        DataInputStream input = new DataInputStream(socket.getInputStream());
        String clientInputStr = input.readUTF(); // 这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
        // 处理客户端数据
        System.out.println("客户端发过来的内容:" + clientInputStr);

        // 向客户端回复信息
        DataOutputStream out = new DataOutputStream(socket.getOutputStream());
        System.out.print("请输入:\t");
        // 发送键盘输入的一行
        String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
        out.writeUTF(s);

        out.close();
        input.close();
      } catch (Exception e) {
        System.out.println("服务器 run 异常: " + e.getMessage());
      } finally {
        if (socket != null) {
          try {
            socket.close();
          } catch (Exception e) {
            socket = null;
            System.out.println("服务端 finally 异常:" + e.getMessage());
          }
        }
      }
    }
 public synchronized List<Sample> getSamples() {
   if (samples == null) {
     samples = new ArrayList<Sample>();
     long lastEnd = 0;
     for (Line sub : subs) {
       long silentTime = sub.from - lastEnd;
       if (silentTime > 0) {
         samples.add(new SampleImpl(ByteBuffer.wrap(new byte[] {0, 0})));
       } else if (silentTime < 0) {
         throw new Error("Subtitle display times may not intersect");
       }
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       DataOutputStream dos = new DataOutputStream(baos);
       try {
         dos.writeShort(sub.text.getBytes("UTF-8").length);
         dos.write(sub.text.getBytes("UTF-8"));
         dos.close();
       } catch (IOException e) {
         throw new Error("VM is broken. Does not support UTF-8");
       }
       samples.add(new SampleImpl(ByteBuffer.wrap(baos.toByteArray())));
       lastEnd = sub.to;
     }
   }
   return samples;
 }
  private static TwitterAuthenticated getTwitterAuthentication(String base64Encoded)
      throws Exception {
    // Create a HTTP Post to twitter platform
    final HttpURLConnection conn = getHTTPUrlConnection(Constants.Twitter.URL_TOKEN);
    conn.setRequestMethod("POST");
    conn.setRequestProperty("User-Agent", "Mozilla/5.0");
    conn.setRequestProperty("Authorization", "Basic " + base64Encoded);
    conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");

    // Send post request
    conn.setDoOutput(true);
    final DataOutputStream wr = new DataOutputStream(conn.getOutputStream());
    wr.writeBytes("grant_type=client_credentials");
    wr.flush();
    wr.close();

    final int responseCode = conn.getResponseCode();
    // If success
    if (responseCode == 200) {
      // Read the response, and build the TwitterAuthenticated object
      final TwitterAuthenticated authenticated =
          new Gson()
              .fromJson(
                  new JsonReader(new InputStreamReader(conn.getInputStream(), "UTF-8")),
                  TwitterAuthenticated.class);
      return authenticated;
    }

    return null;
  }