@Override
public void write(final byte[] b, final int off, final int len) throws IOException {
if (anyAreSet(state, FLAG_CLOSED)) {
throw UndertowServletMessages.MESSAGES.streamIsClosed();
}
if (listener == null) {
Channels.writeBlocking(channel, ByteBuffer.wrap(b, off, len));
} else {
if (anyAreClear(state, FLAG_READY)) {
throw UndertowServletMessages.MESSAGES.streamNotReady();
}
int res;
ByteBuffer buffer = ByteBuffer.wrap(b);
do {
res = channel.write(buffer);
if (res == 0) {
ByteBuffer copy = ByteBuffer.allocate(buffer.remaining());
copy.put(buffer);
copy.flip();
this.buffer = copy;
state = state & ~FLAG_READY;
channel.resumeWrites();
return;
}
} while (buffer.hasRemaining());
}
}
public void writeToChannel(WritableByteChannel channel) throws IOException {
channel.write(ByteBuffer.wrap(new byte[] {version}));
channel.write(ByteBuffer.wrap(Ints.toByteArray(totalSize)));
channel.write(ByteBuffer.wrap(Ints.toByteArray(sizePer)));
channel.write(ByteBuffer.wrap(new byte[] {compression.getId()}));
baseLongBuffers.writeToChannel(channel);
}
/** Tests the method to fill the Reserved Expansion Field with a velocity value. */
@Test
public void testPrepareREForCat062() throws Exception {
TrackVelocity trackVelocity = new TrackVelocity((short) 1, (short) 5, 5.5);
REForCat062 re = new REForCat062((short) 62, 5, "description", new ArrayList<DataItem>());
ByteBuffer buffer =
REForCat062Container.getDefaultBuffer(re.getSubTypeDescriptor(), trackVelocity);
byte[] bytes =
new byte[] {
0x6, // length
0x20, // item indicator 00100000 (only the 3rd item is present)
0x0, 0x1, 0x0, 0x5
}; // values of the velocity
Assert.assertEquals(ByteBuffer.wrap(bytes), buffer);
// another test
trackVelocity = new TrackVelocity((short) 2, (short) 7, 5.5);
buffer = REForCat062Container.getDefaultBuffer(re.getSubTypeDescriptor(), trackVelocity);
bytes[3] = 0x2;
bytes[5] = 0x7;
Assert.assertEquals(ByteBuffer.wrap(bytes), buffer);
}
public synchronized int writenonblock(ByteList buf) throws IOException, BadDescriptorException {
checkWritable();
ensureWrite();
// Ruby ignores empty syswrites
if (buf == null || buf.length() == 0) return 0;
if (buffer.position() != 0 && !flushWrite(false)) return 0;
if (descriptor.getChannel() instanceof SelectableChannel) {
SelectableChannel selectableChannel = (SelectableChannel) descriptor.getChannel();
synchronized (selectableChannel.blockingLock()) {
boolean oldBlocking = selectableChannel.isBlocking();
try {
if (oldBlocking) {
selectableChannel.configureBlocking(false);
}
return descriptor.write(ByteBuffer.wrap(buf.getUnsafeBytes(), buf.begin(), buf.length()));
} finally {
if (oldBlocking) {
selectableChannel.configureBlocking(oldBlocking);
}
}
}
} else {
// can't set nonblocking, so go ahead with it...not much else we can do
return descriptor.write(ByteBuffer.wrap(buf.getUnsafeBytes(), buf.begin(), buf.length()));
}
}
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;
}
void send(byte[] data) throws IOException {
SocketChannel channel = (SocketChannel) key.channel();
verboseLog("TCP write", data);
byte[] lengthArray = new byte[2];
lengthArray[0] = (byte) (data.length >>> 8);
lengthArray[1] = (byte) (data.length & 0xFF);
ByteBuffer[] buffers = new ByteBuffer[2];
buffers[0] = ByteBuffer.wrap(lengthArray);
buffers[1] = ByteBuffer.wrap(data);
int nsent = 0;
key.interestOps(SelectionKey.OP_WRITE);
try {
while (nsent < data.length + 2) {
if (key.isWritable()) {
long n = channel.write(buffers);
if (n < 0) throw new EOFException();
nsent += (int) n;
if (nsent < data.length + 2 && System.currentTimeMillis() > endTime)
throw new SocketTimeoutException();
} else blockUntil(key, endTime);
}
} finally {
if (key.isValid()) key.interestOps(0);
}
}
public ByteBuffer encode(final String name) throws IOException {
if (this.charset == null) { // i.e. use default charset, see no-args constructor
return ByteBuffer.wrap(name.getBytes(de.getEncode()));
} else {
return ByteBuffer.wrap(name.getBytes(this.charset));
}
}
/**
* This utility method creates a list of Thrift TRowResult "struct" based on an Hbase RowResult
* object. The empty list is returned if the input is null.
*
* @param in Hbase RowResult object
* @param sortColumns This boolean dictates if row data is returned in a sorted order sortColumns
* = True will set TRowResult's sortedColumns member which is an ArrayList of TColumn struct
* sortColumns = False will set TRowResult's columns member which is a map of columnName and
* TCell struct
* @return Thrift TRowResult array
*/
public static List<TRowResult> rowResultFromHBase(Result[] in, boolean sortColumns) {
List<TRowResult> results = new ArrayList<TRowResult>();
for (Result result_ : in) {
if (result_ == null || result_.isEmpty()) {
continue;
}
TRowResult result = new TRowResult();
result.row = ByteBuffer.wrap(result_.getRow());
if (sortColumns) {
result.sortedColumns = new ArrayList<TColumn>();
for (Cell kv : result_.rawCells()) {
result.sortedColumns.add(
new TColumn(
ByteBuffer.wrap(
KeyValue.makeColumn(CellUtil.cloneFamily(kv), CellUtil.cloneQualifier(kv))),
new TCell(ByteBuffer.wrap(CellUtil.cloneValue(kv)), kv.getTimestamp())));
}
} else {
result.columns = new TreeMap<ByteBuffer, TCell>();
for (Cell kv : result_.rawCells()) {
result.columns.put(
ByteBuffer.wrap(
KeyValue.makeColumn(CellUtil.cloneFamily(kv), CellUtil.cloneQualifier(kv))),
new TCell(ByteBuffer.wrap(CellUtil.cloneValue(kv)), kv.getTimestamp()));
}
}
results.add(result);
}
return results;
}
@Override
protected void eol(byte[] b, int len) throws IOException {
String line = charset.decode(ByteBuffer.wrap(b, 0, len)).toString();
// line = StandardCharsets.UTF_8.decode(ByteBuffer.wrap(b, 0, len)).toString();
// trim off CR/LF from the end
line = trimEOL(line);
Pattern patternWarnings = Pattern.compile(".*\\d+\\sWarning\\(s\\).*");
Pattern patternErrors = Pattern.compile(".*\\d+\\sError\\(s\\).*");
Matcher mWarnings = patternWarnings.matcher(line);
Matcher mErrors = patternErrors.matcher(line);
if (mWarnings.matches()) { // Match the number of warnings
String[] part = line.split(" ");
try {
numberOfWarnings = Integer.parseInt(part[4]);
} catch (NumberFormatException e) {
}
} else if (mErrors.matches()) { // Match the number of errors
String[] part = line.split(" ");
try {
numberOfErrors = Integer.parseInt(part[4]);
} catch (NumberFormatException e) {
}
}
// Write to output
// out.write(b, 0, len);
out.write(sjis.decode(ByteBuffer.wrap(b, 0, len)).toString().getBytes(StandardCharsets.UTF_8));
}
@Test
public void testToString() {
String test1 = "你好äöüS§مندرين";
String test2 = "";
byte[] data3 = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1};
String test3 = new String(data3, Helper.CHARSET_UTF8);
byte[] data1 = test1.getBytes(Helper.CHARSET_UTF8);
byte[] data2 = test2.getBytes(Helper.CHARSET_UTF8);
ByteBuffer bb1 = ByteBuffer.wrap(data1);
ByteBuffer bb2 = ByteBuffer.wrap(data2);
ByteBuffer bb3 = ByteBuffer.wrap(data3);
assertEquals(test1, ArrayHelper.toString(data1));
assertEquals(test2, ArrayHelper.toString(data2));
assertEquals(test3, ArrayHelper.toString(data3));
assertEquals(test1, ArrayHelper.toString(bb1));
assertEquals(test2, ArrayHelper.toString(bb2));
assertEquals(test3, ArrayHelper.toString(bb3));
bb1.position(3);
bb3.position(3);
assertEquals(test1, ArrayHelper.toString(bb1));
assertEquals(test3, ArrayHelper.toString(bb3));
assertFalse(test1.equals(ArrayHelper.toStringP(bb1)));
assertFalse(test3.equals(ArrayHelper.toStringP(bb3)));
String test =
new String(new byte[] {4, 5, 6, 1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1}, Helper.CHARSET_UTF8);
assertTrue(test.equals(ArrayHelper.toStringP(bb3)));
test = test1.substring(1);
assertTrue(test.equals(ArrayHelper.toStringP(bb1)));
}
@Test
public void testMd5() {
System.out.println(
ArrayHelper.toHexString(
ArrayHelper.md5P(ByteBuffer.wrap("Wang_Bo.jpg".getBytes(Helper.CHARSET_UTF8)))));
assertArrayEquals(
new byte[] {
(byte) 0x8e,
(byte) 0xf9,
(byte) 0x3b,
(byte) 0x78,
(byte) 0xdc,
(byte) 0x67,
(byte) 0x01,
(byte) 0x9c,
(byte) 0xd2,
(byte) 0x63,
(byte) 0xd1,
(byte) 0x01,
(byte) 0x16,
(byte) 0xaa,
(byte) 0x50,
(byte) 0x05
},
ArrayHelper.md5P(ByteBuffer.wrap("Wang_Bo.jpg".getBytes(Helper.CHARSET_UTF8))));
}
@Test
public void testReadAndWriteCaptureChannels() throws IOException {
String blobName = "test-read-and-write-capture-channels-blob";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
byte[] stringBytes;
BlobWriteChannel writer = storage.writer(blob);
stringBytes = BLOB_STRING_CONTENT.getBytes(UTF_8);
writer.write(ByteBuffer.wrap(BLOB_BYTE_CONTENT));
RestorableState<BlobWriteChannel> writerState = writer.capture();
BlobWriteChannel secondWriter = writerState.restore();
secondWriter.write(ByteBuffer.wrap(stringBytes));
secondWriter.close();
ByteBuffer readBytes;
ByteBuffer readStringBytes;
BlobReadChannel reader = storage.reader(blob.blobId());
reader.chunkSize(BLOB_BYTE_CONTENT.length);
readBytes = ByteBuffer.allocate(BLOB_BYTE_CONTENT.length);
reader.read(readBytes);
RestorableState<BlobReadChannel> readerState = reader.capture();
BlobReadChannel secondReader = readerState.restore();
readStringBytes = ByteBuffer.allocate(stringBytes.length);
secondReader.read(readStringBytes);
reader.close();
secondReader.close();
assertArrayEquals(BLOB_BYTE_CONTENT, readBytes.array());
assertEquals(BLOB_STRING_CONTENT, new String(readStringBytes.array(), UTF_8));
assertTrue(storage.delete(BUCKET, blobName));
}
/**
* Reads the header and returns the length of the data part.
*
* @param inputStream
* @return The length of the data part
* @throws IOException, {@link SoftEndOfStreamException} if socket closes before any length data
* read.
*/
protected int readHeader(InputStream inputStream) throws IOException {
byte[] lengthPart = new byte[this.headerSize];
int status = read(inputStream, lengthPart, true);
if (status < 0) {
throw new SoftEndOfStreamException("Stream closed between payloads");
}
int messageLength;
switch (this.headerSize) {
case HEADER_SIZE_INT:
messageLength = ByteBuffer.wrap(lengthPart).getInt();
if (messageLength < 0) {
throw new IllegalArgumentException("Length header:" + messageLength + " is negative");
}
break;
case HEADER_SIZE_UNSIGNED_BYTE:
messageLength = ByteBuffer.wrap(lengthPart).get() & 0xff;
break;
case HEADER_SIZE_UNSIGNED_SHORT:
messageLength = ByteBuffer.wrap(lengthPart).getShort() & 0xffff;
break;
default:
throw new IllegalArgumentException("Bad header size:" + headerSize);
}
return messageLength;
}
@Override
protected int readHeader(InputStream inputStream) throws IOException {
byte[] lengthPart = new byte[this.headerSize];
try {
int status = read(inputStream, lengthPart, true);
if (status < 0) {
throw new SoftEndOfStreamException("Stream closed between payloads");
}
int messageLength;
switch (this.headerSize) {
case HEADER_SIZE_INT:
messageLength = ByteBuffer.wrap(lengthPart).order(LITTLE_ENDIAN).getInt();
if (messageLength < 0) {
throw new IllegalArgumentException("Length header:" + messageLength + " is negative");
}
break;
case HEADER_SIZE_UNSIGNED_BYTE:
messageLength = ByteBuffer.wrap(lengthPart).order(LITTLE_ENDIAN).get() & 0xff;
break;
case HEADER_SIZE_UNSIGNED_SHORT:
messageLength = ByteBuffer.wrap(lengthPart).order(LITTLE_ENDIAN).getShort() & 0xffff;
break;
default:
throw new IllegalArgumentException("Bad header size:" + headerSize);
}
messageLength -= headerSize; // substract header size from data
return messageLength;
} catch (SoftEndOfStreamException e) {
throw e;
} catch (IOException | RuntimeException e) {
publishEvent(e, lengthPart, -1);
throw e;
}
}
public int write(byte[] buf, int off, int len) throws IOException {
if (!ready) {
throw ISEnotusable;
}
int pos = 7;
int current = len;
// Force a blocking read.
if (isComplete) {
while (current > 0) {
int digit = current % 16;
current = current / 16;
chunkLength[pos--] = HexUtils.HEX[digit];
}
OutputWriter.flushChannel(socketChannel, ByteBuffer.wrap(chunkLength, pos + 1, 9 - pos));
}
int nWrite = socketChannel.write(ByteBuffer.wrap(buf, off, len));
if (nWrite == len) {
isComplete = true;
OutputWriter.flushChannel(socketChannel, ByteBuffer.wrap(chunkLength, 8, 2));
OutputWriter.flushChannel(socketChannel, end.slice());
} else {
isComplete = false;
}
return nWrite;
}
private static byte[] createTCPMsg(int opcode) {
ByteBuffer buffer = ByteBuffer.wrap(new byte[1]);
switch (opcode) {
case 0:
buffer = ByteBuffer.wrap(new byte[1]);
buffer.put((byte) 0x00);
break;
case 1:
String userName = "******";
buffer = ByteBuffer.wrap(new byte[userName.length() + 1]);
buffer.put((byte) 0x01);
buffer.put(userName.getBytes(StandardCharsets.UTF_8));
break;
case 2:
case 3:
case 4:
buffer = ByteBuffer.wrap(new byte[17]);
buffer.put((byte) opcode);
buffer.putLong(userId.getMostSignificantBits());
buffer.putLong(userId.getLeastSignificantBits());
break;
}
return buffer.array();
}
public static String computeHash(InputStream stream, long length) throws IOException {
int chunkSizeForFile = (int) Math.min(HASH_CHUNK_SIZE, length);
// buffer that will contain the head and the tail chunk, chunks will overlap if length is
// smaller than two chunks
byte[] chunkBytes = new byte[(int) Math.min(2 * HASH_CHUNK_SIZE, length)];
DataInputStream in = new DataInputStream(stream);
// first chunk
in.readFully(chunkBytes, 0, chunkSizeForFile);
long position = chunkSizeForFile;
long tailChunkPosition = length - chunkSizeForFile;
// seek to position of the tail chunk, or not at all if length is smaller than two chunks
while (position < tailChunkPosition && (position += in.skip(tailChunkPosition - position)) >= 0)
;
// second chunk, or the rest of the data if length is smaller than two chunks
in.readFully(chunkBytes, chunkSizeForFile, chunkBytes.length - chunkSizeForFile);
long head = computeHashForChunk(ByteBuffer.wrap(chunkBytes, 0, chunkSizeForFile));
long tail =
computeHashForChunk(
ByteBuffer.wrap(chunkBytes, chunkBytes.length - chunkSizeForFile, chunkSizeForFile));
return String.format("%016x", length + head + tail);
}
@Test
public void testLimits() throws DeploymentException {
Server server = startServer(PingPongEndpoint.class);
try {
ClientManager client = createClient();
final Session session =
client.connectToServer(
new Endpoint() {
@Override
public void onOpen(Session session, EndpointConfig config) {
// do nothing.
}
},
ClientEndpointConfig.Builder.create().build(),
getURI(PingPongEndpoint.class));
session
.getBasicRemote()
.sendPing(
ByteBuffer.wrap(
"12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"
.getBytes()));
try {
session
.getBasicRemote()
.sendPing(
ByteBuffer.wrap(
"123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456"
.getBytes()));
fail();
} catch (IllegalArgumentException e) {
// ignore
}
session
.getBasicRemote()
.sendPong(
ByteBuffer.wrap(
"12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345"
.getBytes()));
try {
session
.getBasicRemote()
.sendPong(
ByteBuffer.wrap(
"123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456"
.getBytes()));
fail();
} catch (IllegalArgumentException e) {
// ignore
}
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage(), e);
} finally {
stopServer(server);
}
}
@Override
public ByteBuffer downloadChunk(String id) throws TException {
TimeCacheMap<Object, Object> downloaders = data.getDownloaders();
Object obj = downloaders.get(id);
if (obj == null) {
throw new TException("Could not find input stream for that id");
}
try {
if (obj instanceof BufferFileInputStream) {
BufferFileInputStream is = (BufferFileInputStream) obj;
byte[] ret = is.read();
if (ret != null) {
downloaders.put(id, (BufferFileInputStream) is);
return ByteBuffer.wrap(ret);
}
} else {
throw new TException("Object isn't BufferFileInputStream for " + id);
}
} catch (IOException e) {
LOG.error("BufferFileInputStream read failed when downloadChunk ", e);
throw new TException(e);
}
byte[] empty = {};
return ByteBuffer.wrap(empty);
}
public boolean get(OIDType type, Attribute<?> p) {
Attribute<?> a = map.get(type);
if (a == null) {
return false;
} else if (a instanceof AttributeValueAssertion) {
if (p == null) {
return false;
} else {
int idx = list.indexOf(a);
ByteBuffer bb = ByteBuffer.wrap(((AttributeValueAssertion) a).getValue().getArray());
bb.order(ByteOrder.BIG_ENDIAN);
p.parse(bb);
list.set(idx, p);
map.put(type, p);
recycle.add((AttributeValueAssertion) a);
return true;
}
} else if (a.getValue() instanceof ByteArray) {
int idx = list.indexOf(a);
ByteArray ba = (ByteArray) a.getValue();
p.parse(ByteBuffer.wrap(ba.getArray()).order(ByteOrder.BIG_ENDIAN));
list.set(idx, p);
map.put(type, p);
return true;
} else {
return false;
}
}
/*
* Create and size the buffers appropriately.
*/
private void createBuffers() {
/*
* We'll assume the buffer sizes are the same
* between client and server.
*/
SSLSession session = clientEngine.getSession();
int appBufferMax = session.getApplicationBufferSize();
int netBufferMax = session.getPacketBufferSize();
/*
* We'll make the input buffers a bit bigger than the max needed
* size, so that unwrap()s following a successful data transfer
* won't generate BUFFER_OVERFLOWS.
*
* We'll use a mix of direct and indirect ByteBuffers for
* tutorial purposes only. In reality, only use direct
* ByteBuffers when they give a clear performance enhancement.
*/
clientIn = ByteBuffer.allocate(appBufferMax + 50);
serverIn = ByteBuffer.allocate(appBufferMax + 50);
cTOs = ByteBuffer.allocateDirect(netBufferMax);
sTOc = ByteBuffer.allocateDirect(netBufferMax);
clientOut = ByteBuffer.wrap("Hi Server, I'm Client".getBytes());
serverOut = ByteBuffer.wrap("Hello Client, I'm Server".getBytes());
}
/* (non-Javadoc)
* @see chu.engine.Game#init(int, int, java.lang.String)
*/
public void init(int width, int height, String name) {
super.init(width, height, name);
Player p1 = new Player("Player", (byte) 0);
localPlayer = p1;
ByteBuffer icon16, icon32;
icon16 = icon32 = null;
try {
icon16 =
ByteBuffer.wrap(
TextureLoader.getTexture(
"PNG", ResourceLoader.getResourceAsStream("res/gui/icon16.png"))
.getTextureData());
icon32 =
ByteBuffer.wrap(
TextureLoader.getTexture(
"PNG", ResourceLoader.getResourceAsStream("res/gui/icon32.png"))
.getTextureData());
} catch (IOException e) {
e.printStackTrace();
}
Display.setIcon(new ByteBuffer[] {icon16, icon32});
FEResources.loadResources();
FEResources.loadBitmapFonts();
WeaponFactory.loadWeapons();
UnitFactory.loadUnits();
p1.getParty().setColor(Party.TEAM_BLUE);
/* OpenGL final setup */
glEnable(GL_LINE_SMOOTH);
UnitFactory.getUnit("Lyn");
connect = new ConnectStage();
setCurrentStage(new TitleStage());
SoundTrack.loop("main");
}
private void sendPacketOut(ConnectPoint outport, Ethernet payload, int sid) {
IPv4 ipPacket = (IPv4) payload.getPayload();
Ip4Address destIpAddress = Ip4Address.valueOf(ipPacket.getDestinationAddress());
if (sid == -1
|| config.getSegmentId(payload.getDestinationMAC()) == sid
|| config.inSameSubnet(outport.deviceId(), destIpAddress)) {
TrafficTreatment treatment =
DefaultTrafficTreatment.builder().setOutput(outport.port()).build();
OutboundPacket packet =
new DefaultOutboundPacket(
outport.deviceId(), treatment, ByteBuffer.wrap(payload.serialize()));
srManager.packetService.emit(packet);
} else {
log.info("Send a MPLS packet as a ICMP response");
TrafficTreatment treatment =
DefaultTrafficTreatment.builder().setOutput(outport.port()).build();
payload.setEtherType(Ethernet.MPLS_UNICAST);
MPLS mplsPkt = new MPLS();
mplsPkt.setLabel(sid);
mplsPkt.setTtl(((IPv4) payload.getPayload()).getTtl());
mplsPkt.setPayload(payload.getPayload());
payload.setPayload(mplsPkt);
OutboundPacket packet =
new DefaultOutboundPacket(
outport.deviceId(), treatment, ByteBuffer.wrap(payload.serialize()));
srManager.packetService.emit(packet);
}
}
private void init() throws IOException {
if (xts != null) {
return;
}
this.size = base.size() - HEADER_LENGTH;
boolean newFile = size < 0;
byte[] salt;
if (newFile) {
byte[] header = Arrays.copyOf(HEADER, BLOCK_SIZE);
salt = MathUtils.secureRandomBytes(SALT_LENGTH);
System.arraycopy(salt, 0, header, SALT_POS, salt.length);
DataUtils.writeFully(base, 0, ByteBuffer.wrap(header));
size = 0;
} else {
salt = new byte[SALT_LENGTH];
DataUtils.readFully(base, SALT_POS, ByteBuffer.wrap(salt));
if ((size & BLOCK_SIZE_MASK) != 0) {
size -= BLOCK_SIZE;
}
}
AES cipher = new AES();
cipher.setKey(SHA256.getPBKDF2(encryptionKey, salt, HASH_ITERATIONS, 16));
encryptionKey = null;
xts = new XTS(cipher);
}
private Cell toOffheapCell(
ByteBuffer valAndTagsBuffer, int vOffset, int tagsLenSerializationSize) {
ByteBuffer tagsBuf = HConstants.EMPTY_BYTE_BUFFER;
int tOffset = 0;
if (this.includeTags) {
if (this.tagCompressionContext == null) {
tagsBuf = valAndTagsBuffer;
tOffset = vOffset + this.valueLength + tagsLenSerializationSize;
} else {
tagsBuf = ByteBuffer.wrap(Bytes.copy(tagsBuffer, 0, this.tagsLength));
tOffset = 0;
}
}
return new OffheapDecodedCell(
ByteBuffer.wrap(Bytes.copy(keyBuffer, 0, this.keyLength)),
currentKey.getRowLength(),
currentKey.getFamilyOffset(),
currentKey.getFamilyLength(),
currentKey.getQualifierOffset(),
currentKey.getQualifierLength(),
currentKey.getTimestamp(),
currentKey.getTypeByte(),
valAndTagsBuffer,
vOffset,
this.valueLength,
memstoreTS,
tagsBuf,
tOffset,
this.tagsLength);
}
@Test
public void testGenerateParseOneByteAtATime() {
DataGenerator generator = new DataGenerator(new HeaderGenerator());
final List<DataFrame> frames = new ArrayList<>();
Parser parser =
new Parser(
new Parser.Listener.Adapter() {
@Override
public void onData(DataFrame frame) {
frames.add(frame);
}
},
4096,
8192);
ByteBuffer data = ByteBuffer.wrap(largeContent);
List<ByteBuffer> list = generator.generateData(13, data.slice(), true, data.remaining());
for (ByteBuffer buffer : list) {
while (buffer.hasRemaining()) {
parser.parse(ByteBuffer.wrap(new byte[] {buffer.get()}));
}
}
Assert.assertEquals(largeContent.length, frames.size());
}
/*
* Reads BYTE image data organized as separate image planes.
*
*/
public byte[][] readPlanar8(
int width,
int height,
int samplesPerPixel,
long[] stripOffsets,
long[] stripCounts,
long rowsPerStrip)
throws IOException {
byte[][] data = new byte[samplesPerPixel][width * height];
int band = 0;
int offset = 0;
int numRows = 0;
ByteBuffer buff = ByteBuffer.wrap(data[band]);
for (int i = 0; i < stripOffsets.length; i++) {
this.theChannel.position(stripOffsets[i]);
int len = (int) stripCounts[i];
if ((offset + len) >= data[band].length) len = data[band].length - offset;
buff.limit(offset + len);
this.theChannel.read(buff);
offset += stripCounts[i];
numRows += rowsPerStrip;
if (numRows >= height && band < (data.length - 1)) {
buff = ByteBuffer.wrap(data[++band]);
numRows = 0;
offset = 0;
}
}
return data;
}
@Override
protected boolean parseAvcc(BoxHeader header) {
byte[] data = new byte[(int) header.boxDataSize];
try {
if (mDataSource.readAt(mCurrentOffset, data, data.length) != data.length) {
return false;
}
} catch (IOException e) {
if (LOGS_ENABLED) Log.e(TAG, "Error while parsing 'avcc' box", e);
return false;
}
if (mIsMarlinProtected) {
ByteBuffer buffer = parseAvccForMarlin(data);
if (buffer == null) {
return false;
}
mCurrentMediaFormat.setByteBuffer("csd-0", buffer);
parseSPS(buffer.array());
} else {
AvccData avccData = parseAvccData(data);
if (avccData == null) {
return false;
}
ByteBuffer csd0 = ByteBuffer.wrap(avccData.spsBuffer.array());
ByteBuffer csd1 = ByteBuffer.wrap(avccData.ppsBuffer.array());
mCurrentMediaFormat.setByteBuffer("csd-0", csd0);
mCurrentMediaFormat.setByteBuffer("csd-1", csd1);
parseSPS(avccData.spsBuffer.array());
}
return true;
}
/**
* Decodes a dictionary from the bencoded byte array.
*
* @param bencoded_bytes the bencoded form of the dictionary.
* @param offset the offset into {@code bencoded_bytes} where the dictionary begins.
* @return an <code>Object[]</code> containing an <code>Integer</code> offset and the decoded
* dictionary (as a {@code Map}, in positions 0 and 1, respectively
* @throws BencodingException if the bencoded object is incorrectly encoded.
*/
@SuppressWarnings("unchecked")
private static final Object[] decodeDictionary(byte[] bencoded_bytes, int offset)
throws BencodingException {
HashMap map = new HashMap();
++offset;
ByteBuffer info_hash_bytes = null;
while (bencoded_bytes[offset] != (byte) 'e') {
// Decode the key, which must be a byte string
Object[] vals = decodeString(bencoded_bytes, offset);
ByteBuffer key = (ByteBuffer) vals[1];
offset = ((Integer) vals[0]).intValue();
boolean match = true;
for (int i = 0; i < key.array().length && i < 4; i++) {
if (!key.equals(ByteBuffer.wrap(new byte[] {'i', 'n', 'f', 'o'}))) {
match = false;
break;
}
}
int info_offset = -1;
if (match) info_offset = offset;
vals = decode(bencoded_bytes, offset);
offset = ((Integer) vals[0]).intValue();
if (match) {
info_hash_bytes = ByteBuffer.wrap(new byte[offset - info_offset]);
info_hash_bytes.put(bencoded_bytes, info_offset, info_hash_bytes.array().length);
} else if (vals[1] instanceof HashMap) {
info_hash_bytes = (ByteBuffer) vals[2];
}
if (vals[1] != null) map.put(key, vals[1]);
}
return new Object[] {new Integer(++offset), map, info_hash_bytes};
}
public static void main(String[] args) throws IOException {
Path pIn = FileSystems.getDefault().getPath(args[0]);
Path pOut = FileSystems.getDefault().getPath(args[1]);
ByteChannel in = Files.newByteChannel(pIn, StandardOpenOption.READ);
ByteChannel out =
Files.newByteChannel(pOut, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
ByteBuffer bb = ByteBuffer.allocate(BUFFER_SIZE);
int nb = 0;
while ((nb = in.read(bb)) != -1) {
bb.flip();
while (bb.hasRemaining()) {
byte b = bb.get();
ByteBuffer w;
if (b == CONST) {
byte[] arr = {b, b};
w = ByteBuffer.wrap(arr);
} else {
byte[] arr = {b};
w = ByteBuffer.wrap(arr);
}
out.write(w);
}
bb.clear();
}
in.close();
out.close();
}