public void processBufferData(Buffer buffer) {

    CompositeDataPacket cdp = new CompositeDataPacket();
    cdp.setPrimaryStream(buffer.getData());

    if (buffer instanceof CompositeDataBuffer) {
      CompositeDataBuffer cb = (CompositeDataBuffer) buffer;
      cdp.setSecondaryStreams(cb.getBufferCompositeData());
    }
    buffer.reset();

    count++;

    if (count % 100 == 0) System.out.println(name + ": processed " + count + " buffers");
  }
 @Override
 protected void append(LoggingEvent event) {
   try {
     buf.reset();
     writeHeader(event);
     writeSP();
     writeStructuredData();
     writeSP();
     if (prefixMessageWithBOM) writeBOM();
     writeString(event.getRenderedMessage());
     protocol.send(this);
   } catch (IOException e) {
     errorHandler.error(
         "Failed to emit message by " + protocol + " connection to " + host + ":" + port,
         e,
         ErrorCode.WRITE_FAILURE,
         event);
   }
 }
Exemple #3
0
 /** Resets the data that the buffer reads. */
 public void reset(byte[] input, int start, int length) {
   buffer.reset(input, start, length);
 }
  public boolean next(Buffer _buf) throws Exception {
    int i, j;
    switch (state) {
      case SSH_MSG_KEX_DH_GEX_GROUP:
        // byte  SSH_MSG_KEX_DH_GEX_GROUP(31)
        // mpint p, safe prime
        // mpint g, generator for subgroup in GF (p)
        _buf.getInt();
        _buf.getByte();
        j = _buf.getByte();
        if (j != SSH_MSG_KEX_DH_GEX_GROUP) {
          System.err.println("type: must be SSH_MSG_KEX_DH_GEX_GROUP " + j);
          return false;
        }

        p = _buf.getMPInt();
        g = _buf.getMPInt();

        dh.setP(p);
        dh.setG(g);
        // The client responds with:
        // byte  SSH_MSG_KEX_DH_GEX_INIT(32)
        // mpint e <- g^x mod p
        //         x is a random number (1 < x < (p-1)/2)

        e = dh.getE();

        packet.reset();
        buf.putByte((byte) SSH_MSG_KEX_DH_GEX_INIT);
        buf.putMPInt(e);
        session.write(packet);

        if (JSch.getLogger().isEnabled(Logger.INFO)) {
          JSch.getLogger().log(Logger.INFO, "SSH_MSG_KEX_DH_GEX_INIT sent");
          JSch.getLogger().log(Logger.INFO, "expecting SSH_MSG_KEX_DH_GEX_REPLY");
        }

        state = SSH_MSG_KEX_DH_GEX_REPLY;
        return true;
        // break;

      case SSH_MSG_KEX_DH_GEX_REPLY:
        // The server responds with:
        // byte      SSH_MSG_KEX_DH_GEX_REPLY(33)
        // string    server public host key and certificates (K_S)
        // mpint     f
        // string    signature of H
        j = _buf.getInt();
        j = _buf.getByte();
        j = _buf.getByte();
        if (j != SSH_MSG_KEX_DH_GEX_REPLY) {
          System.err.println("type: must be SSH_MSG_KEX_DH_GEX_REPLY " + j);
          return false;
        }

        K_S = _buf.getString();

        byte[] f = _buf.getMPInt();
        byte[] sig_of_H = _buf.getString();

        dh.setF(f);

        dh.checkRange();

        K = normalize(dh.getK());

        // The hash H is computed as the HASH hash of the concatenation of the
        // following:
        // string    V_C, the client's version string (CR and NL excluded)
        // string    V_S, the server's version string (CR and NL excluded)
        // string    I_C, the payload of the client's SSH_MSG_KEXINIT
        // string    I_S, the payload of the server's SSH_MSG_KEXINIT
        // string    K_S, the host key
        // uint32    min, minimal size in bits of an acceptable group
        // uint32   n, preferred size in bits of the group the server should send
        // uint32    max, maximal size in bits of an acceptable group
        // mpint     p, safe prime
        // mpint     g, generator for subgroup
        // mpint     e, exchange value sent by the client
        // mpint     f, exchange value sent by the server
        // mpint     K, the shared secret
        // This value is called the exchange hash, and it is used to authenti-
        // cate the key exchange.

        buf.reset();
        buf.putString(V_C);
        buf.putString(V_S);
        buf.putString(I_C);
        buf.putString(I_S);
        buf.putString(K_S);
        buf.putInt(min);
        buf.putInt(preferred);
        buf.putInt(max);
        buf.putMPInt(p);
        buf.putMPInt(g);
        buf.putMPInt(e);
        buf.putMPInt(f);
        buf.putMPInt(K);

        byte[] foo = new byte[buf.getLength()];
        buf.getByte(foo);
        sha.update(foo, 0, foo.length);

        H = sha.digest();

        // System.err.print("H -> "); dump(H, 0, H.length);

        i = 0;
        j = 0;
        j =
            ((K_S[i++] << 24) & 0xff000000)
                | ((K_S[i++] << 16) & 0x00ff0000)
                | ((K_S[i++] << 8) & 0x0000ff00)
                | ((K_S[i++]) & 0x000000ff);
        String alg = Util.byte2str(K_S, i, j);
        i += j;

        boolean result = verify(alg, K_S, i, sig_of_H);

        state = STATE_END;
        return result;
    }
    return false;
  }
  /**
   * called when the current net_message is from remote_address modifies net_message so that it
   * points to the packet payload =================
   */
  public static boolean Process(NetworkChannel chan, Buffer msg) {
    int sequence, sequence_ack;
    int reliable_ack, reliable_message;
    int qport;

    // get sequence numbers
    msg.reset();
    sequence = msg.getInt();
    sequence_ack = msg.getInt();

    // read the qport if we are a server
    if (chan.sock == Constants.NS_SERVER) qport = msg.getShort();

    // achtung unsigned int
    reliable_message = sequence >>> 31;
    reliable_ack = sequence_ack >>> 31;

    sequence &= ~(1 << 31);
    sequence_ack &= ~(1 << 31);

    if (showpackets.value != 0) {
      if (reliable_message != 0)
        Com.Printf(
            // "recv %4i : s=%i reliable=%i ack=%i rack=%i\n"
            "recv "
                + msg.cursize
                + " : s="
                + sequence
                + " reliable="
                + (chan.incoming_reliable_sequence ^ 1)
                + " ack="
                + sequence_ack
                + " rack="
                + reliable_ack
                + "\n");
      else
        Com.Printf(
            // "recv %4i : s=%i ack=%i rack=%i\n"
            "recv "
                + msg.cursize
                + " : s="
                + sequence
                + " ack="
                + sequence_ack
                + " rack="
                + reliable_ack
                + "\n");
    }

    //
    // discard stale or duplicated packets
    //
    if (sequence <= chan.incoming_sequence) {
      if (showdrop.value != 0)
        Com.Printf(
            NET.AdrToString(chan.remote_address)
                + ":Out of order packet "
                + sequence
                + " at "
                + chan.incoming_sequence
                + "\n");
      return false;
    }

    //
    // dropped packets don't keep the message from being used
    //
    chan.dropped = sequence - (chan.incoming_sequence + 1);
    if (chan.dropped > 0) {
      if (showdrop.value != 0)
        Com.Printf(
            NET.AdrToString(chan.remote_address)
                + ":Dropped "
                + chan.dropped
                + " packets at "
                + sequence
                + "\n");
    }

    //
    // if the current outgoing reliable message has been acknowledged
    // clear the buffer to make way for the next
    //
    if (reliable_ack == chan.reliable_sequence) chan.reliable_length = 0; // it has been received

    //
    // if this message contains a reliable message, bump
    // incoming_reliable_sequence
    //
    chan.incoming_sequence = sequence;
    chan.incoming_acknowledged = sequence_ack;
    chan.incoming_reliable_acknowledged = reliable_ack;
    if (reliable_message != 0) {
      chan.incoming_reliable_sequence ^= 1;
    }

    //
    // the message can now be read from the current message pointer
    //
    chan.last_received = (int) Globals.curtime;

    return true;
  }
 public void reset(ByteBuffer... input) {
   buffers.reset(input);
 }