net.i2p.data.i2cp.SessionId.writeBytes java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Dictionary d =new Hashtable()
Bundle bundle;bundle.getHeaders()
new Properties()
Smart code suggestions by Tabnine
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  if (_sessionId == null)
    throw new I2CPMessageException("Unable to write out the message as there is not enough data");
  ByteArrayOutputStream os = new ByteArrayOutputStream(64);
  try {
    _sessionId.writeBytes(os);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  if (_sessionId == null)
    throw new I2CPMessageException("No data");
  ByteArrayOutputStream os = new ByteArrayOutputStream(256);
  try {
    _sessionId.writeBytes(os);
    DataHelper.writeLong(os, 1, _endpoints.size());
    for (int i = 0; i < _endpoints.size(); i++) {
      _endpoints.get(i).writeBytes(os);
    }
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  if (_sessionId == null || _sessionConfig == null)
    throw new I2CPMessageException("Unable to write out the message as there is not enough data");
  ByteArrayOutputStream os = new ByteArrayOutputStream(64);
  try {
    _sessionId.writeBytes(os);
    _sessionConfig.writeBytes(os);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  if (_sessionId == null)
    throw new I2CPMessageException("Unable to write out the message as there is not enough data");
  ByteArrayOutputStream os = new ByteArrayOutputStream(64);
  try {
    _sessionId.writeBytes(os);
    DataHelper.writeLong(os, 1, _status);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  int len = 7;
  if (_code == RESULT_SUCCESS) {
    if (_dest == null)
      throw new I2CPMessageException("Unable to write out the message as there is not enough data");
    len += _dest.size();
  }
  ByteArrayOutputStream os = new ByteArrayOutputStream(len);
  try {
    _sessionId.writeBytes(os);
    DataHelper.writeLong(os, 4, _reqID);
    DataHelper.writeLong(os, 1, _code);
    if (_code == RESULT_SUCCESS)
      _dest.writeBytes(os);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("bad data", dfe);
  }
  return os.toByteArray();
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  if (_sessionId == null)
    throw new I2CPMessageException("Unable to write out the message as there is not enough data");
  ByteArrayOutputStream os = new ByteArrayOutputStream(256);
  try {
    _sessionId.writeBytes(os);
    DataHelper.writeLong(os, 1, _endpoints.size());
    for (int i = 0; i < _endpoints.size(); i++) {
      Hash router = getRouter(i);
      router.writeBytes(os);
      TunnelId tunnel = getTunnelId(i);
      tunnel.writeBytes(os);
    }
    DataHelper.writeDate(os, _end);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  if ((_sessionId == null) || (_severity == null) || (_reason == null))
    throw new I2CPMessageException("Not enough information to construct the message");
  ByteArrayOutputStream os = new ByteArrayOutputStream(32);
  try {
    _sessionId.writeBytes(os);
    _severity.writeBytes(os);
    _reason.writeBytes(os);
    if (_messageId == null) {
      _messageId = new MessageId();
      _messageId.setMessageId(0);
    }
    _messageId.writeBytes(os);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  if ((_sessionId == null) || (_signingPrivateKey == null) || (_privateKey == null) || (_leaseSet == null))
    throw new I2CPMessageException("Unable to write out the message as there is not enough data");
  int size = 4 // sessionId
       + _signingPrivateKey.length()
       + PrivateKey.KEYSIZE_BYTES
       + _leaseSet.size();
  ByteArrayOutputStream os = new ByteArrayOutputStream(size);
  try {
    _sessionId.writeBytes(os);
    _signingPrivateKey.writeBytes(os);
    _privateKey.writeBytes(os);
    _leaseSet.writeBytes(os);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  int len;
  if (_lookupType == LOOKUP_HASH) {
    if (_hash == null)
      throw new I2CPMessageException("Unable to write out the message as there is not enough data");
    len = 11 + Hash.HASH_LENGTH;
  } else if (_lookupType == LOOKUP_HOST) {
    if (_host == null)
      throw new I2CPMessageException("Unable to write out the message as there is not enough data");
    len = 12 + _host.length();
  } else {
    throw new I2CPMessageException("bad type");
  }
  ByteArrayOutputStream os = new ByteArrayOutputStream(len);
  try {
    _sessionId.writeBytes(os);
    DataHelper.writeLong(os, 4, _reqID);
    DataHelper.writeLong(os, 4, _timeout);
    DataHelper.writeLong(os, 1, _lookupType);
    if (_lookupType == LOOKUP_HASH) {
      _hash.writeBytes(os);
    } else {
      DataHelper.writeString(os, _host);
    }
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("bad data", dfe);
  }
  return os.toByteArray();
}

@Override
protected byte[] doWriteMessage() throws I2CPMessageException, IOException {
  int type = _leaseSet.getType();
  if (_sessionId == null || _leaseSet == null ||
    (type != DatabaseEntry.KEY_TYPE_META_LS2 && (_signingPrivateKey == null || _privateKey == null)))
    throw new I2CPMessageException("Unable to write out the message as there is not enough data");
  int size = 4 // sessionId
       + 1 // type
       + _leaseSet.size()
       + _signingPrivateKey.length()
       + _privateKey.length();
  ByteArrayOutputStream os = new ByteArrayOutputStream(size);
  try {
    _sessionId.writeBytes(os);
    os.write(_leaseSet.getType());
    _leaseSet.writeBytes(os);
    if (type != DatabaseEntry.KEY_TYPE_META_LS2) {
      _signingPrivateKey.writeBytes(os);
      for (PrivateKey pk : getPrivateKeys()) {
        pk.writeBytes(os);
      }
    }
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing out the message data", dfe);
  }
  return os.toByteArray();
}

/**
 * Write out the full message to the stream, including the 4 byte size and 1 
 * byte type header.  Override the parent so we can be more mem efficient
 *
 * @throws IOException 
 */
@Override
public void writeMessage(OutputStream out) throws I2CPMessageException, IOException {
  if (_sessionId == null)
    throw new I2CPMessageException("No session ID");
  if (_destination == null)
    throw new I2CPMessageException("No dest");
  if (_payload == null)
    throw new I2CPMessageException("No payload");
  if (_nonce < 0)
    throw new I2CPMessageException("No nonce");
  int len = 2 + _destination.size() + _payload.getSize() + 4 + 4;
  
  try {
    DataHelper.writeLong(out, 4, len);
    out.write((byte) getType());
    _sessionId.writeBytes(out);
    _destination.writeBytes(out);
    _payload.writeBytes(out);
    DataHelper.writeLong(out, 4, _nonce);
  } catch (DataFormatException dfe) {
    throw new I2CPMessageException("Error writing the msg", dfe);
  }
}

DataHelper.writeLong(out, 4, len);
out.write((byte) MESSAGE_TYPE);
_sessionId.writeBytes(out);
_destination.writeBytes(out);
_payload.writeBytes(out);

Popular methods of SessionId

Popular in Java

Updating database using SQL prepared statement
onRequestPermissionsResult (Fragment)
getExternalFilesDir (Context)
runOnUiThread (Activity)
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
HashMap (java.util)
HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
ConcurrentHashMap (java.util.concurrent)
A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This version is based on or
JarFile (java.util.jar)
JarFile is used to read jar entries and their associated data from jar files.
JButton (javax.swing)
IsNull (org.hamcrest.core)
Is the value null?
Top 15 Vim Plugins

How to use writeBytesmethodin net.i2p.data.i2cp.SessionId

Best Java code snippets using net.i2p.data.i2cp.SessionId.writeBytes (Showing top 12 results out of 315)

How to use
writeBytes
method
in
net.i2p.data.i2cp.SessionId