/**
* Wait for the username/password message and verify or throw SOCKSException on failure
*
* @since 0.8.2
*/
private void verifyPassword(DataInputStream in, DataOutputStream out)
throws IOException, SOCKSException {
int c = in.readUnsignedByte();
if (c != AUTH_VERSION) throw new SOCKSException("Unsupported authentication version");
c = in.readUnsignedByte();
if (c <= 0) throw new SOCKSException("Bad authentication");
byte[] user = new byte[c];
in.readFully(user);
c = in.readUnsignedByte();
if (c <= 0) throw new SOCKSException("Bad authentication");
byte[] pw = new byte[c];
in.readFully(pw);
// Hopefully these are in UTF-8, since that's what our config file is in
// these throw UnsupportedEncodingException which is an IOE
String u = new String(user, "UTF-8");
String p = new String(pw, "UTF-8");
String configUser = props.getProperty(I2PTunnelHTTPClientBase.PROP_USER);
String configPW = props.getProperty(I2PTunnelHTTPClientBase.PROP_PW);
if ((!u.equals(configUser)) || (!p.equals(configPW))) {
_log.error("SOCKS authorization failure");
sendAuthReply(AUTH_FAILURE, out);
throw new SOCKSException("SOCKS authorization failure");
}
if (_log.shouldLog(Log.INFO)) _log.info("SOCKS authorization success, user: " + u);
sendAuthReply(AUTH_SUCCESS, out);
}
/**
* SOCKS5 connection initialization. This method assumes that SOCKS "VER" field has been stripped
* from the input stream.
*/
private void init(DataInputStream in, DataOutputStream out) throws IOException, SOCKSException {
int nMethods = in.readUnsignedByte();
int method = Method.NO_ACCEPTABLE_METHODS;
for (int i = 0; i < nMethods; ++i) {
int meth = in.readUnsignedByte();
if (((!authRequired) && meth == Method.NO_AUTH_REQUIRED)
|| (authRequired && meth == Method.USERNAME_PASSWORD)) {
// That's fine, we do support this method
method = meth;
}
}
switch (method) {
case Method.USERNAME_PASSWORD:
_log.debug("username/password authentication required");
sendInitReply(Method.USERNAME_PASSWORD, out);
verifyPassword(in, out);
return;
case Method.NO_AUTH_REQUIRED:
_log.debug("no authentication required");
sendInitReply(Method.NO_AUTH_REQUIRED, out);
return;
default:
_log.debug(
"no suitable authentication methods found (" + Integer.toHexString(method) + ")");
sendInitReply(Method.NO_ACCEPTABLE_METHODS, out);
throw new SOCKSException("Unsupported authentication method");
}
}
public void unmarshal(DataInputStream dis) {
super.unmarshal(dis);
try {
minefieldID.unmarshal(dis);
requestingEntityID.unmarshal(dis);
requestID = (short) dis.readUnsignedByte();
numberOfPerimeterPoints = (short) dis.readUnsignedByte();
pad2 = (short) dis.readUnsignedByte();
numberOfSensorTypes = (short) dis.readUnsignedByte();
dataFilter = dis.readInt();
requestedMineType.unmarshal(dis);
for (int idx = 0; idx < numberOfPerimeterPoints; idx++) {
Point anX = new Point();
anX.unmarshal(dis);
requestedPerimeterPoints.add(anX);
}
for (int idx = 0; idx < numberOfSensorTypes; idx++) {
TwoByteChunk anX = new TwoByteChunk();
anX.unmarshal(dis);
sensorTypes.add(anX);
}
} // end try
catch (Exception e) {
System.out.println(e);
}
} // end of unmarshal method
public void testFormat() {
InputConnection conn = null;
DataInputStream dis = null;
try {
conn = (InputConnection) Connector.open("scratchpad:///0");
dis = conn.openDataInputStream();
assertEquals("bytes per sector", 256, dis.readUnsignedShort());
assertEquals("sector per cluster", 1, dis.readUnsignedByte());
assertEquals("reserved sector", 1, dis.readUnsignedShort());
assertEquals("number of fats", 1, dis.readUnsignedByte());
assertEquals("root entries", 256, dis.readUnsignedShort());
assertEquals("total sectors", 200, dis.readUnsignedShort());
assertEquals("sector per fat", 100, dis.readUnsignedShort());
} catch (IOException e) {
fail(e.toString());
} finally {
if (dis != null)
try {
dis.close();
} catch (IOException e) {
}
;
if (conn != null)
try {
conn.close();
} catch (IOException e) {
}
;
}
}
public int read(DataInputStream istream) throws IOException {
preRead();
int retVal = 0;
// read header
retVal += header.read(istream);
// read length
{
length = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read programIndex
{
programIndex = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read txnId
{
txnId = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read ltsid
{
ltsid = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read programNumber
{
programNumber = istream.readUnsignedShort();
retVal += 2;
}
// read sourceId
{
sourceId = istream.readUnsignedShort();
retVal += 2;
}
// read caPmtCmdId
{
caPmtCmdId = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read bf2
retVal += bf2.read(istream);
// read StatusfieldCheckInstance
if (getProgramInfoLength() != 0) {
StatusfieldCheckInstance = new StatusfieldCheck(this);
retVal += StatusfieldCheckInstance.read(istream);
}
// read CaEntries
for (; istream.available() > 0; ) {
CaPmtModeMsg temp;
temp = new CaPmtModeMsg();
retVal += temp.read(istream);
CaEntries.add(temp);
}
postRead();
return retVal;
}
private static int readInt() throws IOException {
int a = dis.readUnsignedByte();
int b = dis.readUnsignedByte();
int c = dis.readUnsignedByte();
int d = dis.readUnsignedByte();
int i = (d << 24) | (c << 16) | (b << 8) | a;
return i;
}
/**
* Private API - A protocol version mismatch is detected by checking the three next bytes if a
* frame type of (int)'A' is read from an input stream. If the next three bytes are 'M', 'Q' and
* 'P', then it's likely the broker is trying to tell us we are speaking the wrong AMQP protocol
* version.
*
* @throws MalformedFrameException if an AMQP protocol version mismatch is detected
* @throws MalformedFrameException if a corrupt AMQP protocol identifier is read
*/
public static void protocolVersionMismatch(DataInputStream is) throws IOException {
MalformedFrameException x;
// We expect the letters M, Q, P in that order: generate an informative error if they're not
// found
byte[] expectedBytes = new byte[] {'M', 'Q', 'P'};
for (byte expectedByte : expectedBytes) {
int nextByte = is.readUnsignedByte();
if (nextByte != expectedByte) {
throw new MalformedFrameException(
"Invalid AMQP protocol header from server: expected character "
+ expectedByte
+ ", got "
+ nextByte);
}
}
try {
int[] signature = new int[4];
for (int i = 0; i < 4; i++) {
signature[i] = is.readUnsignedByte();
}
if (signature[0] == 1 && signature[1] == 1 && signature[2] == 8 && signature[3] == 0) {
x =
new MalformedFrameException(
"AMQP protocol version mismatch; we are version "
+ AMQP.PROTOCOL.MAJOR
+ "-"
+ AMQP.PROTOCOL.MINOR
+ "-"
+ AMQP.PROTOCOL.REVISION
+ ", server is 0-8");
} else {
String sig = "";
for (int i = 0; i < 4; i++) {
if (i != 0) sig += ",";
sig += signature[i];
}
x =
new MalformedFrameException(
"AMQP protocol version mismatch; we are version "
+ AMQP.PROTOCOL.MAJOR
+ "-"
+ AMQP.PROTOCOL.MINOR
+ "-"
+ AMQP.PROTOCOL.REVISION
+ ", server sent signature "
+ sig);
}
} catch (IOException ex) {
x = new MalformedFrameException("Invalid AMQP protocol header from server");
}
throw x;
}
public static Level load(String file) throws IOException {
com.mojang.minecraft.level.Level level = new com.mojang.minecraft.level.Level();
File f = new File(OpenClassic.getGame().getDirectory(), file);
FileInputStream in = new FileInputStream(f);
GZIPInputStream decompressor = new GZIPInputStream(in);
DataInputStream data = new DataInputStream(decompressor);
int magic = convert(data.readShort());
if (magic != 1874) {
OpenClassic.getLogger()
.severe(
String.format(
OpenClassic.getGame().getTranslator().translate("level.format-mismatch"),
"MCSharp v1"));
OpenClassic.getLogger()
.severe(OpenClassic.getGame().getTranslator().translate("level.try-mcforge"));
return MCForgeLevelFormat.load(file);
}
short width = convert(data.readShort());
short height = convert(data.readShort());
short depth = convert(data.readShort());
level.xSpawn = data.readShort();
level.ySpawn = data.readShort();
level.zSpawn = data.readShort();
level.rotSpawn = (byte) data.readUnsignedByte();
data.readUnsignedByte();
byte[] blocks = new byte[width * depth * height];
for (int z = 0; z < depth; z++) {
for (int y = 0; y < height; y++) {
byte[] row = new byte[height];
data.readFully(row);
for (int x = 0; x < width; x++) {
blocks[(y * height + z) * width + x] = translateBlock(row[x]);
}
}
}
level.setData(width, height, depth, blocks);
data.close();
try {
f.delete();
} catch (SecurityException e) {
e.printStackTrace();
}
return level.openclassic;
}
/**
* Read a constant from the constant pool.
*
* @param in The stream from which to read.
* @return The constant.
* @exception IOException If an error occurs while reading.
*/
Constant readConstant(DataInputStream in) throws IOException {
int tag = in.readUnsignedByte();
Object value;
switch (tag) {
case Constant.CLASS:
case Constant.STRING:
case Constant.METHOD_TYPE: // @since 1.8
value = Integer.valueOf(in.readUnsignedShort());
break;
case Constant.FIELD_REF:
case Constant.METHOD_REF:
case Constant.INTERFACE_METHOD_REF:
case Constant.NAME_AND_TYPE:
case Constant.INVOKE_DYNAMIC: // @since 1.8
value = new int[2];
((int[]) value)[0] = in.readUnsignedShort();
((int[]) value)[1] = in.readUnsignedShort();
break;
case Constant.INTEGER:
value = Integer.valueOf(in.readInt());
break;
case Constant.FLOAT:
value = Float.valueOf(in.readFloat());
break;
case Constant.LONG:
// Longs take up 2 constant pool entries.
value = Long.valueOf(in.readLong());
break;
case Constant.DOUBLE:
// Doubles take up 2 constant pool entries.
value = Double.valueOf(in.readDouble());
break;
case Constant.UTF8:
value = in.readUTF();
break;
case Constant.METHOD_HANDLE: // @since 1.8
value = new int[2];
((int[]) value)[0] = in.readUnsignedByte();
((int[]) value)[1] = in.readUnsignedShort();
break;
default:
throw new ClassFormatError("Invalid constant tag: " + tag);
}
return new Constant(tag, value);
}
public static Cp readCp(DataInputStream source) throws IOException {
byte tag;
tag = (byte) source.readUnsignedByte();
switch (tag) {
case TAG_Class:
return new CpClass(source);
case TAG_Fieldref:
return new CpFieldref(source);
case TAG_Methodref:
return new CpMethodref(source);
case TAG_InterfaceMethodref:
return new CpInterfaceMethodref(source);
case TAG_String:
return new CpString(source);
case TAG_Integer:
return new CpInteger(source);
case TAG_Float:
return new CpFloat(source);
case TAG_Long:
return new CpLong(source);
case TAG_Double:
return new CpDouble(source);
case TAG_NameAndType:
return new CpNameAndType(source);
case TAG_Utf8:
return new CpUtf8(source);
default:
throw new Error("Unknown tag type in constant pool: " + tag);
}
}
// Returns important image data to the main class
@Override
public ImageData getImages(int limit) {
try {
DataInputStream imgInputStream = new DataInputStream(new FileInputStream(imageFilePath));
imgInputStream.readInt(); // magic number
int numImgs = imgInputStream.readInt();
if (limit >= 0 && limit <= numImgs) numImgs = limit;
int numRows = imgInputStream.readInt();
int numCols = imgInputStream.readInt();
// Reduces each image pixel to its grayscale value for processing by the neural network
double[][] images = new double[numImgs][numRows * numCols];
for (int i = 0; i < images.length; i++) {
for (int j = 0; j < images[i].length; j++) {
images[i][j] = imgInputStream.readUnsignedByte() / 255.0;
}
}
imgInputStream.close();
return new ImageData(images, numRows, numCols);
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* Auxiliary method to extract the bootstrap methods associated with the resource. This is fetched
* from the 'SourceDebugExtension_attribute' structure, which has the following format:
*
* <p>[java 8] SourceDebugExtension_attribute { u2 attribute_name_index; u4 attribute_length; u1
* debug_extension[attribute_length]; }
*
* <p>- debug_extension[]: The 'debug_extension' array holds extended debugging information which
* has no semantic effect on the Java Virtual Machine. The information is represented using a
* modified UTF-8 string with no terminating zero byte. Note that the 'debug_extension' array may
* denote a string longer than that which can be represented with an instance of class String.
*
* @param dataInputStream The byte stream associated with the resource (aka .class file).
* @param attributeLength The length of the debug extension.
* @param resource The resource associated with the attribute.
* @throws IOException When reading bytes from the stream fails.
*/
public static void extractSourceDebugExtension(
DataInputStream dataInputStream, int attributeLength, Resource resource) throws IOException {
int debug;
for (int index = 0; index < attributeLength; index++) {
debug = dataInputStream.readUnsignedByte();
}
}
void loadConstants(LPrototype f) throws IOException {
int n = loadInt();
LValue[] values = new LValue[n];
for (int i = 0; i < n; i++) {
switch (is.readByte()) {
case Lua.LUA_TNIL:
values[i] = LNil.NIL;
break;
case Lua.LUA_TBOOLEAN:
values[i] = (0 != is.readUnsignedByte() ? LBoolean.TRUE : LBoolean.FALSE);
break;
case Lua.LUA_TINT:
values[i] = LInteger.valueOf(loadInt());
break;
case Lua.LUA_TNUMBER:
values[i] = loadNumber();
break;
case Lua.LUA_TSTRING:
values[i] = loadString();
break;
default:
throw new IllegalStateException("bad constant");
}
}
f.k = values;
n = loadInt();
LPrototype[] protos = new LPrototype[n];
for (int i = 0; i < n; i++) protos[i] = loadFunction(f.source);
f.p = protos;
}
public void writeStream(DataInputStream input) throws IOException, NoSuchAlgorithmException {
try {
int bytesRead = 0;
int bytesToSkip = 0;
while (true) {
final int value = input.readUnsignedByte();
bytesRead++;
check.nextByte(value);
writeRaw(value);
final int weakChecksum = check.weakChecksum();
String strongChecksum = null;
if (bytesToSkip > 0) {
bytesToSkip--;
} else {
Map<String, Integer> weakMatches = inputBlocks.get(weakChecksum);
if (weakMatches != null) {
strongChecksum = check.strongChecksum();
Integer previousOffset = weakMatches.get(strongChecksum);
if (previousOffset != null) {
snipRawBuffer();
System.err.println(
"Using previously remembered : "
+ previousOffset
+ " : "
+ (bytesRead - BLOCK_SIZE));
writeBlock(previousOffset);
bytesToSkip = BLOCK_SIZE - 1;
}
}
}
if ((bytesRead % BLOCK_SIZE) == 0) {
Map<String, Integer> weakMatches = inputBlocks.get(weakChecksum);
if (weakMatches == null) {
weakMatches = new HashMap<String, Integer>();
inputBlocks.put(weakChecksum, weakMatches);
}
if (strongChecksum == null) {
strongChecksum = check.strongChecksum();
}
if (!weakMatches.containsKey(strongChecksum)) {
weakMatches.put(strongChecksum, bytesRead - BLOCK_SIZE);
System.err.println(
"Remembering : "
+ weakChecksum
+ " : "
+ strongChecksum
+ " : "
+ (bytesRead - BLOCK_SIZE));
}
}
}
} catch (EOFException e) {
flushRaw();
}
System.err.println("Original data: " + rawChunks);
System.err.println("Reused data: " + blockChunks);
}
@SuppressWarnings("unchecked")
public SenseData decode(ByteBuffer buffer) throws IOException {
DataInputStream in = new DataInputStream(new ByteBufferInputStream(buffer));
int b1 = in.readUnsignedByte();
ResponseCode code = ResponseCode.valueOf((byte) (b1 & 0x7F)); // throws IOException
SenseData sense = null;
switch (code) {
case CURRENT_FIXED:
sense = new FixedSenseData();
break;
case CURRENT_DESCRIPTOR:
sense = new DescriptorSenseData();
break;
case DEFERRED_FIXED:
sense = new FixedSenseData();
break;
case DEFERRED_DESCRIPTOR:
sense = new DescriptorSenseData();
break;
}
sense.decode(new byte[] {(byte) b1}, buffer);
return sense;
}
private short readUnsignedByte() {
try {
return (short) inStream.readUnsignedByte();
} catch (IOException e) {
IOError();
}
return 0;
}
void readServerInit() throws IOException {
framebufferWidth = is.readUnsignedShort();
framebufferHeight = is.readUnsignedShort();
bitsPerPixel = is.readUnsignedByte();
depth = is.readUnsignedByte();
bigEndian = (is.readUnsignedByte() != 0);
trueColour = (is.readUnsignedByte() != 0);
redMax = is.readUnsignedShort();
greenMax = is.readUnsignedShort();
blueMax = is.readUnsignedShort();
redShift = is.readUnsignedByte();
greenShift = is.readUnsignedByte();
blueShift = is.readUnsignedByte();
byte[] pad = new byte[3];
readFully(pad);
int nameLength = is.readInt();
byte[] name = new byte[nameLength];
readFully(name);
desktopName = new String(name);
// Read interaction capabilities (TightVNC protocol extensions)
if (protocolTightVNC) {
int nServerMessageTypes = is.readUnsignedShort();
int nClientMessageTypes = is.readUnsignedShort();
int nEncodingTypes = is.readUnsignedShort();
is.readUnsignedShort();
readCapabilityList(serverMsgCaps, nServerMessageTypes);
readCapabilityList(clientMsgCaps, nClientMessageTypes);
readCapabilityList(encodingCaps, nEncodingTypes);
}
inNormalProtocol = true;
}
public void unmarshal(DataInputStream dis) {
super.unmarshal(dis);
try {
minefieldID.unmarshal(dis);
requestingEntityID.unmarshal(dis);
minefieldSequenceNumbeer = (int) dis.readUnsignedShort();
requestID = (short) dis.readUnsignedByte();
pduSequenceNumber = (short) dis.readUnsignedByte();
numberOfPdus = (short) dis.readUnsignedByte();
numberOfMinesInThisPdu = (short) dis.readUnsignedByte();
numberOfSensorTypes = (short) dis.readUnsignedByte();
pad2 = (short) dis.readUnsignedByte();
dataFilter = dis.readInt();
mineType.unmarshal(dis);
for (int idx = 0; idx < numberOfSensorTypes; idx++) {
TwoByteChunk anX = new TwoByteChunk();
anX.unmarshal(dis);
sensorTypes.add(anX);
}
pad3 = (short) dis.readUnsignedByte();
for (int idx = 0; idx < numberOfMinesInThisPdu; idx++) {
Vector3Float anX = new Vector3Float();
anX.unmarshal(dis);
mineLocation.add(anX);
}
} // end try
catch (Exception e) {
System.out.println(e);
}
} // end of unmarshal method
public int read(DataInputStream istream) throws IOException {
preRead();
int retVal = 0;
// read featureId
{
featureId = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read status
{
status = (short) (istream.readUnsignedByte());
retVal += 1;
}
postRead();
return retVal;
}
public static NSEC3PARAM parse(DataInputStream dis) throws IOException {
byte hashAlgorithm = dis.readByte();
byte flags = dis.readByte();
int iterations = dis.readUnsignedShort();
int saltLength = dis.readUnsignedByte();
byte[] salt = new byte[saltLength];
if (dis.read(salt) != salt.length && salt.length != 0) throw new IOException();
return new NSEC3PARAM(hashAlgorithm, flags, iterations, salt);
}
public static long convert8BytesToLong(byte[] buffer, int offset) throws IOException {
ByteArrayInputStream byte_in = new ByteArrayInputStream(buffer);
DataInputStream data_in = new DataInputStream(byte_in);
/* skip the offset */
data_in.skip(offset);
//
long value;
value = data_in.readUnsignedByte();
value += (long) data_in.readUnsignedByte() << 8;
value += (long) data_in.readUnsignedByte() << 16;
value += (long) data_in.readUnsignedByte() << 24;
value += (long) data_in.readUnsignedByte() << 32;
value += (long) data_in.readUnsignedByte() << 40;
value += (long) data_in.readUnsignedByte() << 48;
value += (long) data_in.readUnsignedByte() << 56;
return value;
// return convertNBytesToLong(buffer, offset, 8);
}
public static int readUnsignedByte(DataInputStream dataInputStream, long[] alRemainingBytes)
throws IOException {
int nByte = dataInputStream.readUnsignedByte();
// already done in DataInputStream.readUnsignedByte();
// if (nByte < 0)
// {
// throw new EOFException();
// }
alRemainingBytes[0]--;
return nByte;
}
private int getByte(DataInputStream ds) {
int y;
try { // read starting line #
y = ds.readUnsignedByte();
} catch (IOException e) {
System.out.println("Error reading byte : " + e);
return (-1);
}
return (y);
}
/**
* Parse a domain name starting at the current offset and moving the input stream pointer past
* this domain name (even if cross references occure).
*
* @param dis The input stream.
* @param data The raw data (for cross references).
* @return The domain name string.
* @throws IOException Should never happen.
*/
public static String parse(DataInputStream dis, byte data[]) throws IOException {
int c = dis.readUnsignedByte();
if ((c & 0xc0) == 0xc0) {
c = ((c & 0x3f) << 8) + dis.readUnsignedByte();
HashSet<Integer> jumps = new HashSet<Integer>();
jumps.add(c);
return parse(data, c, jumps);
}
if (c == 0) {
return "";
}
byte b[] = new byte[c];
dis.readFully(b);
String s = IDN.toUnicode(new String(b));
String t = parse(dis, data);
if (t.length() > 0) {
s = s + "." + t;
}
return s;
}
public int read(DataInputStream istream) throws IOException {
preRead();
int retVal = 0;
// read header
retVal += header.read(istream);
// read protocol_version
{
protocol_version = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read configuration_count_change
{
configuration_count_change = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read resources
retVal += resources.read(istream);
// read pvData
{
IntegerHolder iHolder = new IntegerHolder();
DataInputStream disTemp = istream;
pvData = PVDataFactory.createMsg(protocol_version, disTemp, iHolder);
retVal += iHolder.getValue();
}
// read certificateCount
{
certificateCount = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read cvCertificates
for (int iIdx = 0; iIdx < certificateCount + (0); iIdx++) {
CVCertificate temp;
temp = new CVCertificate();
retVal += temp.read(istream);
cvCertificates.add(temp);
}
postRead();
return retVal;
}
public LPrototype loadFunction(LString p) throws IOException {
LPrototype f = new LPrototype();
// this.L.push(f);
f.source = loadString();
if (f.source == null) f.source = p;
f.linedefined = loadInt();
f.lastlinedefined = loadInt();
f.nups = is.readUnsignedByte();
f.numparams = is.readUnsignedByte();
f.is_vararg = is.readUnsignedByte();
f.maxstacksize = is.readUnsignedByte();
f.code = loadIntArray();
loadConstants(f);
loadDebug(f);
// TODO: add check here, for debugging purposes, I believe
// see ldebug.c
// IF (!luaG_checkcode(f), "bad code");
// this.L.pop();
return f;
}
public int readNoHeader(DataInputStream istream) throws IOException {
preRead();
int retVal = 0;
// read length
{
length = (short) (istream.readUnsignedByte());
retVal += 1;
}
postRead();
return retVal;
}
public int readNoHeader(DataInputStream istream) throws IOException {
preRead();
int retVal = 0;
// read length
{
length = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read caPmtlisMngement
{
caPmtlisMngement = (short) (istream.readUnsignedByte());
retVal += 1;
}
// read programNumber
{
programNumber = istream.readUnsignedShort();
retVal += 2;
}
// read bf1
retVal += bf1.read(istream);
// read bf2
retVal += bf2.read(istream);
// read StatusfieldCheckInstance
if (getProgramInfoLength() != 0) {
StatusfieldCheckInstance = new StatusfieldCheck(this);
retVal += StatusfieldCheckInstance.read(istream);
}
// read CaEntries
for (; istream.available() > 0; ) {
CaPmtModeMsg temp;
temp = new CaPmtModeMsg();
retVal += temp.read(istream);
CaEntries.add(temp);
}
postRead();
return retVal;
}
@Override
public int read() throws IOException {
output.writeByte(ForkServer.RESOURCE);
output.writeByte(resource);
output.writeInt(1);
output.flush();
int n = input.readInt();
if (n == 1) {
return input.readUnsignedByte();
} else {
return n;
}
}
int readCompactLen() throws IOException {
int[] portion = new int[3];
portion[0] = is.readUnsignedByte();
// int byteCount = 1;
int len = portion[0] & 0x7F;
if ((portion[0] & 0x80) != 0) {
portion[1] = is.readUnsignedByte();
// byteCount++;
len |= (portion[1] & 0x7F) << 7;
if ((portion[1] & 0x80) != 0) {
portion[2] = is.readUnsignedByte();
// byteCount++;
len |= (portion[2] & 0xFF) << 14;
}
}
/*-
if (rec != null && recordFromBeginning)
for (int i = 0; i < byteCount; i++)
rec.writeByte(portion[i]);
*/
return len;
}
