public static void createTestFiles() {
try {
System.out.println("Creating test files ... ");
Random rand = new Random();
String rootname = "f-";
long[] sizes = {0, 1, 50000000};
File testdir = new File(dirname);
FileUtil.mkdirs(testdir);
for (int i = 0; i < sizes.length; i++) {
long size = sizes[i];
File file = new File(testdir, rootname + String.valueOf(size));
System.out.println(file.getName() + "...");
FileChannel fc = new RandomAccessFile(file, "rw").getChannel();
long position = 0;
while (position < size) {
long remaining = size - position;
if (remaining > 1024000) remaining = 1024000;
byte[] buffer = new byte[new Long(remaining).intValue()];
rand.nextBytes(buffer);
ByteBuffer bb = ByteBuffer.wrap(buffer);
position += fc.write(bb);
}
fc.close();
}
System.out.println("DONE\n");
} catch (Exception e) {
Debug.printStackTrace(e);
}
}
public static void runTests() {
try {
// SHA1 sha1Jmule = new SHA1();
MessageDigest sha1Sun = MessageDigest.getInstance("SHA-1");
SHA1 sha1Gudy = new SHA1();
// SHA1Az shaGudyResume = new SHA1Az();
ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
File dir = new File(dirname);
File[] files = dir.listFiles();
for (int i = 0; i < files.length; i++) {
FileChannel fc = new RandomAccessFile(files[i], "r").getChannel();
System.out.println("Testing " + files[i].getName() + " ...");
while (fc.position() < fc.size()) {
fc.read(buffer);
buffer.flip();
byte[] raw = new byte[buffer.limit()];
System.arraycopy(buffer.array(), 0, raw, 0, raw.length);
sha1Gudy.update(buffer);
sha1Gudy.saveState();
ByteBuffer bb = ByteBuffer.wrap(new byte[56081]);
sha1Gudy.digest(bb);
sha1Gudy.restoreState();
sha1Sun.update(raw);
buffer.clear();
}
byte[] sun = sha1Sun.digest();
sha1Sun.reset();
byte[] gudy = sha1Gudy.digest();
sha1Gudy.reset();
if (Arrays.equals(sun, gudy)) {
System.out.println(" SHA1-Gudy: OK");
} else {
System.out.println(" SHA1-Gudy: FAILED");
}
buffer.clear();
fc.close();
System.out.println();
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
// Takes the byte array received from the server and parses.
// The server responds with a UDP packet containing 4 integers. The
// integer array returned contains has those 4 integers.
public static int[] partA(byte[] response) {
ByteBuffer bb = ByteBuffer.wrap(response);
checkHeader(bb, 16, 0, STEP2);
int[] res = new int[4];
for (int i = 0; i < res.length; i++) {
res[i] = bb.getInt();
}
return res;
}
/**
* Get text content of a source file.
*
* @param path The canonical path of source file.
* @param charset Source file encoding.
* @return Source file content.
*/
public String read(String path, String charset) {
String str = null;
byte[] bin = read(path);
try {
str = Charset.forName(charset).newDecoder().decode(ByteBuffer.wrap(bin)).toString();
} catch (CharacterCodingException e) {
App.exit("Cannot read " + path + " as " + charset + " encoded file");
}
return str;
}
private void dispatchMessage(
TcpAddress incomingAddress, ByteBuffer byteBuffer, long bytesRead) {
byteBuffer.flip();
if (logger.isDebugEnabled()) {
logger.debug(
"Received message from "
+ incomingAddress
+ " with length "
+ bytesRead
+ ": "
+ new OctetString(byteBuffer.array(), 0, (int) bytesRead).toHexString());
}
ByteBuffer bis;
if (isAsyncMsgProcessingSupported()) {
byte[] bytes = new byte[(int) bytesRead];
System.arraycopy(byteBuffer.array(), 0, bytes, 0, (int) bytesRead);
bis = ByteBuffer.wrap(bytes);
} else {
bis = ByteBuffer.wrap(byteBuffer.array(), 0, (int) bytesRead);
}
fireProcessMessage(incomingAddress, bis);
}
/**
* Check if the first X characters of a byte stream match a String.
*
* @param data The byte array to process
* @param pattern The String to match
* @return True if the pattern was found, false otherwise
*/
private static boolean bytesEqualsString(byte[] data, String pattern) {
byte[] bytes = new byte[pattern.length()];
Charset csets = Charset.forName("US-ASCII");
boolean fin = false;
int currChar = 0;
// remove any CR and/or LF characters at the beginning of the article
// data
while (!fin) {
if (currChar >= data.length) break;
byte in = data[currChar];
ByteBuffer bb = ByteBuffer.wrap(new byte[] {(byte) in});
CharBuffer cb = csets.decode(bb);
char c = cb.charAt(0);
if (data.length > 0 && (c == '\n' || c == '\r')) currChar++;
else fin = true;
if (data.length == 0) fin = true;
}
// extract bytes (chars) to check from article data
for (int i = 0; i < bytes.length && i < data.length; i++, currChar++) {
byte in = data[currChar];
bytes[i] = (byte) in;
}
// decode byte data to characters
ByteBuffer bb = ByteBuffer.wrap(bytes);
CharBuffer cb = csets.decode(bb);
// compare these characters to the pattern String
for (int i = 0; i < pattern.length(); i++) if (cb.charAt(i) != pattern.charAt(i)) return false;
return true;
}
static void test() throws Exception {
ServerSocketChannel ssc = null;
SocketChannel sc = null;
SocketChannel peer = null;
try {
ssc = ServerSocketChannel.open().bind(new InetSocketAddress(0));
// loopback connection
InetAddress lh = InetAddress.getLocalHost();
sc = SocketChannel.open(new InetSocketAddress(lh, ssc.socket().getLocalPort()));
peer = ssc.accept();
// peer sends message so that "sc" will be readable
int n = peer.write(ByteBuffer.wrap("Hello".getBytes()));
assert n > 0;
sc.configureBlocking(false);
Selector selector = Selector.open();
SelectionKey key = sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
boolean done = false;
int failCount = 0;
while (!done) {
int nSelected = selector.select();
if (nSelected > 0) {
if (nSelected > 1) throw new RuntimeException("More than one channel selected");
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iterator = keys.iterator();
while (iterator.hasNext()) {
key = iterator.next();
iterator.remove();
if (key.isWritable()) {
failCount++;
if (failCount > 10) throw new RuntimeException("Test failed");
Thread.sleep(250);
}
if (key.isReadable()) {
done = true;
}
}
}
}
} finally {
if (peer != null) peer.close();
if (sc != null) sc.close();
if (ssc != null) ssc.close();
}
}
static void testMixed(Charset cs) throws Throwable {
CharsetDecoder dec =
cs.newDecoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
CharsetEncoder enc =
cs.newEncoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
List<Integer> cps = new ArrayList<>(0x10000);
int off = 0;
int cp = 0;
while (cp < 0x10000) {
if (enc.canEncode((char) cp)) {
cps.add(cp);
}
cp++;
}
Collections.shuffle(cps);
char[] bmpCA = new char[cps.size()];
for (int i = 0; i < cps.size(); i++) bmpCA[i] = (char) (int) cps.get(i);
String bmpStr = new String(bmpCA);
// getBytes(csn);
byte[] bmpBA = bmpStr.getBytes(cs.name());
ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(bmpCA));
byte[] baNIO = new byte[bf.limit()];
bf.get(baNIO, 0, baNIO.length);
if (!Arrays.equals(bmpBA, baNIO)) {
throw new RuntimeException("getBytes(csn) failed -> " + cs.name());
}
// getBytes(cs);
bmpBA = bmpStr.getBytes(cs);
if (!Arrays.equals(bmpBA, baNIO))
throw new RuntimeException("getBytes(cs) failed -> " + cs.name());
// new String(csn);
String strSC = new String(bmpBA, cs.name());
String strNIO = dec.reset().decode(ByteBuffer.wrap(bmpBA)).toString();
if (!strNIO.equals(strSC)) {
throw new RuntimeException("new String(csn) failed -> " + cs.name());
}
// new String(cs);
strSC = new String(bmpBA, cs);
if (!strNIO.equals(strSC)) throw new RuntimeException("new String(cs) failed -> " + cs.name());
}
private void writeMessage(SocketEntry entry, SocketChannel sc) throws IOException {
byte[] message = entry.nextMessage();
if (message != null) {
ByteBuffer buffer = ByteBuffer.wrap(message);
sc.write(buffer);
if (logger.isDebugEnabled()) {
logger.debug(
"Send message with length "
+ message.length
+ " to "
+ entry.getPeerAddress()
+ ": "
+ new OctetString(message).toHexString());
}
sc.register(selector, SelectionKey.OP_READ);
}
}
public final void unserialise(final byte[] data) {
final ByteBuffer bb = ByteBuffer.wrap(data);
this.m_id = bb.getInt();
this.m_isChallengeGoal = (bb.get() == 1);
try {
final byte[] targetPosition = new byte[bb.getInt()];
bb.get(targetPosition);
this.m_targetPosition = new String(targetPosition, "UTF-8").intern();
this.m_isCountDownJauge = (bb.get() == 1);
this.m_jaugeMaxValue = bb.getInt();
final byte[] jaugeVarName = new byte[bb.getInt()];
bb.get(jaugeVarName);
this.m_jaugeVarName = new String(jaugeVarName, "UTF-8").intern();
} catch (UnsupportedEncodingException e) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e);
}
}
public final void unserialise(final byte[] data) {
final ByteBuffer bb = ByteBuffer.wrap(data);
this.m_id = bb.getInt();
this.m_order = bb.get();
this.m_gfx = bb.getInt();
final byte[] cdata = new byte[bb.getInt()];
bb.get(cdata);
try {
this.m_criterion = new String(cdata, "UTF-8").intern();
} catch (UnsupportedEncodingException e) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e);
}
this.m_success = (bb.get() == 1);
this.m_itemId = bb.getInt();
this.m_itemQty = bb.getShort();
this.m_xp = bb.getInt();
this.m_kama = bb.getInt();
this.m_guildPoints = bb.getInt();
}
protected void fill(GOut g) {
BGL gl = g.gl;
Coord dim = new Coord(tdim, tdim);
for (int i = 0; i < order.length; i++) {
ByteBuffer data =
ByteBuffer.wrap(
TexI.convert(back, dim, new Coord(order[i][0] * tdim, order[i][1] * tdim), dim));
gl.glTexImage2D(
GL.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
0,
GL.GL_RGBA,
tdim,
tdim,
0,
GL.GL_RGBA,
GL.GL_UNSIGNED_BYTE,
data);
}
}
static char[] decode(byte[] bb, Charset cs, boolean testDirect, Time t) throws Exception {
String csn = cs.name();
CharsetDecoder dec = cs.newDecoder();
ByteBuffer bbf;
CharBuffer cbf;
if (testDirect) {
bbf = ByteBuffer.allocateDirect(bb.length);
cbf = ByteBuffer.allocateDirect(bb.length * 2).asCharBuffer();
bbf.put(bb);
} else {
bbf = ByteBuffer.wrap(bb);
cbf = CharBuffer.allocate(bb.length);
}
CoderResult cr = null;
long t1 = System.nanoTime() / 1000;
for (int i = 0; i < iteration; i++) {
bbf.rewind();
cbf.clear();
dec.reset();
cr = dec.decode(bbf, cbf, true);
}
long t2 = System.nanoTime() / 1000;
t.t = (t2 - t1) / iteration;
if (cr != CoderResult.UNDERFLOW) {
System.out.println("DEC-----------------");
int pos = bbf.position();
System.out.printf(
" cr=%s, bbf.pos=%d, bb[pos]=%x,%x,%x,%x%n",
cr.toString(),
pos,
bb[pos++] & 0xff,
bb[pos++] & 0xff,
bb[pos++] & 0xff,
bb[pos++] & 0xff);
throw new RuntimeException("Decoding err: " + csn);
}
char[] cc = new char[cbf.position()];
cbf.flip();
cbf.get(cc);
return cc;
}
static CoderResult decodeCR(byte[] bb, Charset cs, boolean testDirect) throws Exception {
CharsetDecoder dec = cs.newDecoder();
ByteBuffer bbf;
CharBuffer cbf;
if (testDirect) {
bbf = ByteBuffer.allocateDirect(bb.length);
cbf = ByteBuffer.allocateDirect(bb.length * 2).asCharBuffer();
bbf.put(bb).flip();
} else {
bbf = ByteBuffer.wrap(bb);
cbf = CharBuffer.allocate(bb.length);
}
CoderResult cr = null;
for (int i = 0; i < iteration; i++) {
bbf.rewind();
cbf.clear();
dec.reset();
cr = dec.decode(bbf, cbf, true);
}
return cr;
}
/** {@inheritDoc} */
@Override
public ByteBuffer encode(GridNioSession ses, GridClientMessage msg)
throws IOException, GridException {
assert msg != null;
if (msg instanceof GridTcpRestPacket) return encodeMemcache((GridTcpRestPacket) msg);
else if (msg == PING_MESSAGE) return ByteBuffer.wrap(PING_PACKET);
else {
byte[] data = marshaller.marshal(msg);
assert data.length > 0;
ByteBuffer res = ByteBuffer.allocate(data.length + 5);
res.put(GRIDGAIN_REQ_FLAG);
res.put(U.intToBytes(data.length));
res.put(data);
res.flip();
return res;
}
}
/**
* Handles control packet.
*
* @param data raw packet data that arrived on control PPID.
* @param sid SCTP stream id on which the data has arrived.
*/
private synchronized void onCtrlPacket(byte[] data, int sid) throws IOException {
ByteBuffer buffer = ByteBuffer.wrap(data);
int messageType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
if (messageType == MSG_CHANNEL_ACK) {
if (logger.isDebugEnabled()) {
logger.debug(getEndpoint().getID() + " ACK received SID: " + sid);
}
// Open channel ACK
WebRtcDataStream channel = channels.get(sid);
if (channel != null) {
// Ack check prevents from firing multiple notifications
// if we get more than one ACKs (by mistake/bug).
if (!channel.isAcknowledged()) {
channel.ackReceived();
notifyChannelOpened(channel);
} else {
logger.warn("Redundant ACK received for SID: " + sid);
}
} else {
logger.error("No channel exists on sid: " + sid);
}
} else if (messageType == MSG_OPEN_CHANNEL) {
int channelType = /* 1 byte unsigned integer */ 0xFF & buffer.get();
int priority = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
long reliability = /* 4 bytes unsigned integer */ 0xFFFFFFFFL & buffer.getInt();
int labelLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
int protocolLength = /* 2 bytes unsigned integer */ 0xFFFF & buffer.getShort();
String label;
String protocol;
if (labelLength == 0) {
label = "";
} else {
byte[] labelBytes = new byte[labelLength];
buffer.get(labelBytes);
label = new String(labelBytes, "UTF-8");
}
if (protocolLength == 0) {
protocol = "";
} else {
byte[] protocolBytes = new byte[protocolLength];
buffer.get(protocolBytes);
protocol = new String(protocolBytes, "UTF-8");
}
if (logger.isDebugEnabled()) {
logger.debug(
"!!! "
+ getEndpoint().getID()
+ " data channel open request on SID: "
+ sid
+ " type: "
+ channelType
+ " prio: "
+ priority
+ " reliab: "
+ reliability
+ " label: "
+ label
+ " proto: "
+ protocol);
}
if (channels.containsKey(sid)) {
logger.error("Channel on sid: " + sid + " already exists");
}
WebRtcDataStream newChannel = new WebRtcDataStream(sctpSocket, sid, label, true);
channels.put(sid, newChannel);
sendOpenChannelAck(sid);
notifyChannelOpened(newChannel);
} else {
logger.error("Unexpected ctrl msg type: " + messageType);
}
}
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
int index;
DatastoreService ds;
MemcacheService ms;
BlobstoreService bs;
URLFetchService us;
FileService fs;
Map<String, List<BlobKey>> blobMap;
BlobKey blobKey;
BlobInfoFactory blobInfoFactory;
BlobInfo blobInfo;
int postCount;
int postIndex;
String postType;
String postText;
String postDelpw;
String postShowgallery;
DataObj dataObj;
String filelink;
String picUrl;
HTTPResponse picRes;
List<HTTPHeader> headerList;
String picMime;
String[] fileNamePart;
AppEngineFile picFile;
FileWriteChannel writeChannel;
PostObj postObj;
List<PostObj> postObjList;
String linkID;
resp.setCharacterEncoding("UTF-8");
resp.setContentType("text/plain");
try {
ds = DatastoreServiceFactory.getDatastoreService();
ms = MemcacheServiceFactory.getMemcacheService();
bs = BlobstoreServiceFactory.getBlobstoreService();
us = URLFetchServiceFactory.getURLFetchService();
fs = FileServiceFactory.getFileService();
blobInfoFactory = new BlobInfoFactory(ds);
blobMap = bs.getUploads(req);
postCount = Integer.valueOf(req.getParameter("input_post_count"));
postObjList = new ArrayList<PostObj>();
for (postIndex = 0; postIndex < postCount; postIndex++) {
try {
postType = req.getParameter("input_post_type_" + postIndex);
if (postType == null) {
continue;
}
postText = req.getParameter("input_post_text_" + postIndex);
postDelpw = req.getParameter("input_post_delpw_" + postIndex);
postShowgallery = req.getParameter("input_post_showgallery_" + postIndex);
if (postShowgallery == null) {
postShowgallery = "";
}
if (postType.equals("file") == true) {
blobKey = blobMap.get("input_post_file_" + postIndex).get(0);
if (blobKey == null) {
throw new Exception();
}
dataObj = new DataObj();
dataObj.fileid = createUID();
dataObj.posttime = new Date().getTime();
dataObj.delpw = postDelpw;
dataObj.blobkey = blobKey;
dataObj.putDB(ds);
blobInfo = blobInfoFactory.loadBlobInfo(dataObj.blobkey);
filelink =
"http://"
+ req.getServerName()
+ "/down/"
+ dataObj.fileid
+ "/"
+ blobInfo.getFilename();
postObj =
new PostObj(
dataObj.fileid,
filelink,
blobInfo.getSize(),
dataObj.posttime,
dataObj.delpw,
postShowgallery);
postObjList.add(postObj);
} else if (postType.equals("url") == true) {
picUrl = postText;
picRes = us.fetch(new URL(picUrl));
headerList = picRes.getHeaders();
picMime = "application/octet-stream";
for (index = 0; index < headerList.size(); index++) {
if (headerList.get(index).getName().compareToIgnoreCase("Content-Type") == 0) {
picMime = headerList.get(index).getValue();
break;
}
}
fileNamePart = picUrl.split("/");
picFile = fs.createNewBlobFile(picMime, fileNamePart[fileNamePart.length - 1]);
writeChannel = fs.openWriteChannel(picFile, true);
writeChannel.write(ByteBuffer.wrap(picRes.getContent()));
writeChannel.closeFinally();
dataObj = new DataObj();
dataObj.fileid = createUID();
dataObj.posttime = new Date().getTime();
dataObj.delpw = postDelpw;
dataObj.blobkey = fs.getBlobKey(picFile);
dataObj.putDB(ds);
blobInfo = blobInfoFactory.loadBlobInfo(dataObj.blobkey);
filelink =
"http://"
+ req.getServerName()
+ "/down/"
+ dataObj.fileid
+ "/"
+ blobInfo.getFilename();
postObj =
new PostObj(
dataObj.fileid,
filelink,
blobInfo.getSize(),
dataObj.posttime,
dataObj.delpw,
postShowgallery);
postObjList.add(postObj);
}
} catch (Exception e) {
}
}
linkID = postFile(us, postObjList);
if (req.getParameter("specflag") != null) {
resp.getWriter().print("http://tnfshmoe.appspot.com/link.jsp?linkid=" + linkID);
} else {
resp.sendRedirect("http://tnfshmoe.appspot.com/link.jsp?linkid=" + linkID);
}
} catch (Exception e) {
}
}
public static void main(String[] args) throws Exception {
//////////////////// STAGE A//////////////////////////////////////////
int portNum = 12235;
// InetAddress ip=InetAddress.getLocalHost();
InetAddress ip = InetAddress.getByName("attu2.cs.washington.edu");
DatagramSocket sock = new DatagramSocket();
byte[] response = new byte[HEADER_SIZE + 16];
String partA = "hello world\0";
byte[] buf = createBuffer(partA.getBytes(), 0, STEP1);
DatagramPacket packet = new DatagramPacket(buf, buf.length, ip, portNum);
sock.send(packet);
packet = new DatagramPacket(response, response.length);
sock.receive(packet);
int[] a2 = partA(response); // putting the 4 ints from server into int[]
// for (int i = 0; i < a2.length; i++) {
// System.out.println(a2[i]);
// }
////////////////////// STAGE B////////////////////////////////////////
int numSent = 0;
int send = a2[0];
int len = a2[1];
portNum = a2[2];
int secretA = a2[3];
System.out.println("The secrets:\nA: " + secretA);
sock.setSoTimeout(500); // .5s
while (numSent < send) {
// create packet
buf = createBuffer(partB(numSent, len), secretA, STEP1);
packet = new DatagramPacket(buf, buf.length, ip, portNum);
sock.send(packet);
// send packet
try {
sock.receive(new DatagramPacket(response, response.length));
numSent++;
ByteBuffer temp = ByteBuffer.wrap(response);
checkHeader(temp, 4, secretA, STEP1);
// System.out.println(temp.getInt()); // For debug. See if counts up by 1
} catch (SocketTimeoutException e) {
// if there's a timeout, try again
continue;
}
}
response = new byte[HEADER_SIZE + 8]; // 8 bytes -- 2 integers
sock.receive(new DatagramPacket(response, response.length));
ByteBuffer bb = ByteBuffer.wrap(response);
// Header
checkHeader(bb, 8, secretA, STEP2);
// reset the port number to the one given
portNum = bb.getInt();
int secretB = bb.getInt();
System.out.println("B: " + secretB);
// close the UDP socket
sock.close();
/////////////////////////// STAGE C///////////////////////////////////
Socket socket = new Socket(ip, portNum);
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
response = new byte[HEADER_SIZE + 16]; // 4 ints given to us this time
in.read(response);
bb = ByteBuffer.wrap(response);
// Header
checkHeader(bb, 13, secretB, STEP2);
// num2 len2 secretC and char c
numSent = bb.getInt();
len = bb.getInt();
int secretC = bb.getInt();
System.out.println("C: " + secretC);
// stage d
byte c = (byte) bb.getChar();
buf = new byte[len];
Arrays.fill(buf, c);
for (int i = 0; i < numSent; i++) {
byte[] b = createBuffer(buf, secretC, STEP1);
out.write(b);
}
response = new byte[12 + 4]; // one integer. secretD plus header
in.read(response);
bb = ByteBuffer.wrap(response);
checkHeader(bb, 4, secretC, STEP2);
int secretD = bb.getInt();
socket.close();
in.close();
out.close();
System.out.println("D: " + secretD);
}
/**
* Parses the binary data that describes the recurrent pattern.
*
* @param data the binary data.
* @param sourceTask the calendar item.
*/
public RecurringPattern(byte[] data, CalendarItemTimerTask sourceTask) {
this.sourceTask = sourceTask;
dataBuffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
int offset = 4;
recurFrequency = dataBuffer.getShort(offset);
offset += 2;
patternType = PatternType.getFromShort(dataBuffer.getShort(offset));
offset += 2;
calendarType = dataBuffer.getShort(offset);
offset += 2;
firstDateTime = dataBuffer.getInt(offset);
offset += 4;
period = dataBuffer.getInt(offset);
offset += 4;
slidingFlag = dataBuffer.getInt(offset);
offset += 4;
switch (patternType) {
case Week:
case Month:
case MonthEnd:
case HjMonth:
case HjMonthEnd:
patternSpecific1 = dataBuffer.getInt(offset);
patternSpecific2 = 0;
offset += 4;
if (patternType == PatternType.Week) {
for (int day = firstDow; day < firstDow + 7; day++) {
if ((patternSpecific1 & (weekOfDayMask[day % 7])) != 0) {
allowedDaysOfWeek.add((day % 7) + 1);
}
}
}
break;
case MonthNth:
case HjMonthNth:
patternSpecific1 = dataBuffer.getInt(offset);
patternSpecific2 = dataBuffer.getInt(offset + 4);
if (patternSpecific1 == 0x7f && patternSpecific2 != 0x5) {
patternType = PatternType.Month;
}
for (int day = 0; day < 7; day++) {
if ((patternSpecific1 & (weekOfDayMask[day])) != 0) {
allowedDaysOfWeek.add((day) + 1);
}
}
offset += 8;
break;
default:
break;
}
// endType
endType = dataBuffer.getInt(offset);
offset += 4;
occurenceCount = dataBuffer.getInt(offset);
offset += 4;
firstDow = dataBuffer.getInt(offset);
offset += 4;
deletedInstanceCount = dataBuffer.getInt(offset);
offset += 4;
// deleted instances
for (int i = 0; i < deletedInstanceCount; i++) {
deletedInstances.add(windowsTimeToDateObject(dataBuffer.getInt(offset)));
offset += 4;
}
modifiedInstanceCount = dataBuffer.getInt(offset);
offset += 4;
// modified instances
modifiedInstances = new int[modifiedInstanceCount];
for (int i = 0; i < modifiedInstanceCount; i++) {
modifiedInstances[i] = dataBuffer.getInt(offset);
offset += 4;
}
startDate = dataBuffer.getInt(offset);
offset += 4;
endDate = dataBuffer.getInt(offset);
offset += 4;
offset += 16;
short exceptionCount = dataBuffer.getShort(offset);
offset += 2;
exceptionInfo = new ArrayList<ExceptionInfo>(exceptionCount);
for (int i = 0; i < exceptionCount; i++) {
ExceptionInfo tmpExceptionInfo = new ExceptionInfo(offset);
exceptionInfo.add(tmpExceptionInfo);
offset += tmpExceptionInfo.sizeInBytes();
CalendarService.BusyStatusEnum status = tmpExceptionInfo.getBusyStatus();
Date startTime = tmpExceptionInfo.getStartDate();
Date endTime = tmpExceptionInfo.getEndDate();
if (status == CalendarService.BusyStatusEnum.FREE || startTime == null || endTime == null)
continue;
Date currentTime = new Date();
if (endTime.before(currentTime) || endTime.equals(currentTime)) return;
boolean executeNow = false;
if (startTime.before(currentTime) || startTime.equals(currentTime)) executeNow = true;
CalendarItemTimerTask task =
new CalendarItemTimerTask(
status, startTime, endTime, sourceTask.getId(), executeNow, this);
task.scheduleTasks();
}
}
public void sendData(long sig, byte[] data) throws IOException {
sendData(sig, ByteBuffer.wrap(data));
}
public void sendDatagram(long sig, byte[] data, int length, String recipAddress, int recipPort) {
sendDatagram(sig, ByteBuffer.wrap(data), recipAddress, recipPort);
}
static void test(Charset cs, char[] bmpCA, byte[] sbBA) throws Throwable {
String bmpStr = new String(bmpCA);
CharsetDecoder dec =
cs.newDecoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
CharsetEncoder enc =
cs.newEncoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
// getBytes(csn);
byte[] baSC = bmpStr.getBytes(cs.name());
ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(bmpCA));
byte[] baNIO = new byte[bf.limit()];
bf.get(baNIO, 0, baNIO.length);
if (!Arrays.equals(baSC, baNIO))
throw new RuntimeException("getBytes(csn) failed -> " + cs.name());
// getBytes(cs);
baSC = bmpStr.getBytes(cs);
if (!Arrays.equals(baSC, baNIO))
throw new RuntimeException("getBytes(cs) failed -> " + cs.name());
// new String(csn);
String strSC = new String(sbBA, cs.name());
String strNIO = dec.reset().decode(ByteBuffer.wrap(sbBA)).toString();
if (!strNIO.equals(strSC))
throw new RuntimeException("new String(csn) failed -> " + cs.name());
// new String(cs);
strSC = new String(sbBA, cs);
if (!strNIO.equals(strSC)) throw new RuntimeException("new String(cs) failed -> " + cs.name());
// encode unmappable surrogates
if (enc instanceof sun.nio.cs.ArrayEncoder && cs.contains(Charset.forName("ASCII"))) {
if (cs.name().equals("UTF-8")
|| // utf8 handles surrogates
cs.name().equals("CESU-8")) // utf8 handles surrogates
return;
enc.replaceWith(new byte[] {(byte) 'A'});
sun.nio.cs.ArrayEncoder cae = (sun.nio.cs.ArrayEncoder) enc;
String str = "ab\uD800\uDC00\uD800\uDC00cd";
byte[] ba = new byte[str.length() - 2];
int n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 6 || !"abAAcd".equals(new String(ba, cs.name())))
throw new RuntimeException("encode1(surrogates) failed -> " + cs.name());
ba = new byte[str.length()];
n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 6 || !"abAAcd".equals(new String(ba, 0, n, cs.name())))
throw new RuntimeException("encode2(surrogates) failed -> " + cs.name());
str = "ab\uD800B\uDC00Bcd";
ba = new byte[str.length()];
n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 8 || !"abABABcd".equals(new String(ba, 0, n, cs.name())))
throw new RuntimeException("encode3(surrogates) failed -> " + cs.name());
/* sun.nio.cs.ArrayDeEncoder works on the assumption that the
invoker (StringCoder) allocates enough output buf, utf8
and double-byte coder does not check the output buffer limit.
ba = new byte[str.length() - 1];
n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 7 || !"abABABc".equals(new String(ba, 0, n, cs.name()))) {
throw new RuntimeException("encode4(surrogates) failed -> "
+ cs.name());
}
*/
}
}
public static void main(String[] argv) {
if (argv.length != 3) {
usage();
}
String tempFile = argv[0];
String testFile = argv[1];
int fileSize = Integer.valueOf(argv[2]).intValue();
int exitcode = 0;
int numRead;
int numThisBuf;
int numWritten;
if ((fileSize <= 0) || (fileSize % 4096 != 0)) {
System.out.println("Error: size is not a multiple of 4096!!!!!!");
System.out.println();
usage();
}
try {
int bufSize = 4096;
byte[] inBytes = new byte[bufSize];
byte[] outBytes = new byte[bufSize];
Random ioRandom = new Random(2006);
ioRandom.nextBytes(outBytes);
ByteBuffer inBuf = ByteBuffer.allocate(bufSize);
ByteBuffer outBuf = ByteBuffer.wrap(outBytes);
//
// Loop forever
//
while (true) {
//
// Write the temporary file
//
FileOutputStream fos = new FileOutputStream(tempFile);
FileChannel foc = fos.getChannel();
numWritten = 0;
while (numWritten < fileSize) {
outBuf.clear(); // sets limit to capacity & position to zero
while (outBuf.hasRemaining()) {
numWritten += foc.write(outBuf);
}
}
//
// Move to permanent location
//
FileChannel srcChannel = new FileInputStream(tempFile).getChannel();
FileChannel dstChannel = new FileOutputStream(testFile).getChannel();
dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
srcChannel.close();
dstChannel.close();
boolean success = (new File(tempFile)).delete();
if (!success) {
System.out.println("Warning: unable to delete temporary file");
}
//
// Read and compare
//
FileInputStream fis = new FileInputStream(testFile);
FileChannel fic = fis.getChannel();
for (numRead = 0, numThisBuf = 0; numRead < fileSize; numThisBuf = 0) {
inBuf.rewind(); // Set the buffer position to 0
numThisBuf = fic.read(inBuf);
while (numThisBuf < bufSize) {
numThisBuf += fic.read(inBuf);
}
numRead += bufSize;
inBuf.rewind(); // Set the buffer position to 0
inBuf.get(inBytes);
boolean same = Arrays.equals(inBytes, outBytes);
if (same = false) {
System.out.println("Data read does not equal data written at " + numRead + " bytes");
}
}
}
} catch (FileNotFoundException fnfe) {
fnfe.printStackTrace(System.err);
exitcode = 1;
// break;
} catch (SecurityException se) {
se.printStackTrace(System.err);
exitcode = 1;
// break;
} catch (Throwable t) {
t.printStackTrace(System.err);
exitcode = 1;
}
System.exit(exitcode);
}
private void readMessage(SelectionKey sk, SocketChannel readChannel, TcpAddress incomingAddress)
throws IOException {
// note that socket has been used
SocketEntry entry = (SocketEntry) sockets.get(incomingAddress);
if (entry != null) {
entry.used();
ByteBuffer readBuffer = entry.getReadBuffer();
if (readBuffer != null) {
readChannel.read(readBuffer);
if (readBuffer.hasRemaining()) {
readChannel.register(selector, SelectionKey.OP_READ, entry);
} else {
dispatchMessage(incomingAddress, readBuffer, readBuffer.capacity());
}
return;
}
}
ByteBuffer byteBuffer = ByteBuffer.wrap(buf);
byteBuffer.limit(messageLengthDecoder.getMinHeaderLength());
long bytesRead = readChannel.read(byteBuffer);
if (logger.isDebugEnabled()) {
logger.debug("Reading header " + bytesRead + " bytes from " + incomingAddress);
}
MessageLength messageLength = new MessageLength(0, Integer.MIN_VALUE);
if (bytesRead == messageLengthDecoder.getMinHeaderLength()) {
messageLength = messageLengthDecoder.getMessageLength(ByteBuffer.wrap(buf));
if (logger.isDebugEnabled()) {
logger.debug("Message length is " + messageLength);
}
if ((messageLength.getMessageLength() > getMaxInboundMessageSize())
|| (messageLength.getMessageLength() <= 0)) {
logger.error(
"Received message length "
+ messageLength
+ " is greater than inboundBufferSize "
+ getMaxInboundMessageSize());
synchronized (entry) {
entry.getSocket().close();
logger.info("Socket to " + entry.getPeerAddress() + " closed due to an error");
}
} else {
byteBuffer.limit(messageLength.getMessageLength());
bytesRead += readChannel.read(byteBuffer);
if (bytesRead == messageLength.getMessageLength()) {
dispatchMessage(incomingAddress, byteBuffer, bytesRead);
} else {
byte[] message = new byte[byteBuffer.limit()];
byteBuffer.flip();
byteBuffer.get(message, 0, byteBuffer.limit() - byteBuffer.remaining());
entry.setReadBuffer(ByteBuffer.wrap(message));
}
readChannel.register(selector, SelectionKey.OP_READ, entry);
}
} else if (bytesRead < 0) {
logger.debug("Socket closed remotely");
sk.cancel();
readChannel.close();
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_DISCONNECTED_REMOTELY,
null);
fireConnectionStateChanged(e);
}
}
@Override
public boolean onMessage(final ExternalFightCreationMessage msg) {
final FightModel fightModel = FightModel.getFromTypeId(msg.getFightType());
if (fightModel == null) {
ExternalFightCreationMessageHandler.m_logger.error(
(Object)
String.format(
"FightModel (typeId=%d) inconnu dans la cr\u00e9ation de l'external fight id=%d",
msg.getFightType(), msg.getFightId()));
return false;
}
final ExternalFightInfo externalFightInfo = new ExternalFightInfo(fightModel);
final FightMap fightMap = new WakfuClientFightMap();
new FightMapSerializer(fightMap).unserialize(ByteBuffer.wrap(msg.getSerializedFightMap()));
externalFightInfo.setId(msg.getFightId());
externalFightInfo.setStatus(msg.getFightStatus());
externalFightInfo.setPartition(msg.getPartition());
externalFightInfo.setFightMap(fightMap);
fightMap.blockFightingGroundInTopology(true, false);
final boolean displayEffect =
WakfuGameEntity.getInstance().getLocalPlayer().getCurrentFight() == null;
for (int i = 0; i < msg.getFightersCount(); ++i) {
final byte teamId = msg.getTeamId(i);
final long fighterId = msg.getFighterId(i);
externalFightInfo.addFighterToTeamById(teamId, fighterId);
}
ExternalFightCreationActions.INSTANCE.m_fightIsInFightCreation.add(msg.getFightId());
externalFightInfo.setAttackerCreatorId(msg.getCreators().get(0));
externalFightInfo.setDefenderCreatorId(msg.getCreators().get(1));
final CharacterInfo attackerCreator =
externalFightInfo.getFighterFromId((long) msg.getCreators().get(0));
final CharacterInfo defenderCreator =
externalFightInfo.getFighterFromId((long) msg.getCreators().get(1));
if (attackerCreator != null && defenderCreator != null) {
ExternalFightCreationActions.INSTANCE.m_lookAtTheFoeActions1.put(
msg.getFightId(),
LookAtTheFoeAction.checkout(
1, FightActionType.LOOK_AT_THE_FOE.getId(), 0, attackerCreator, defenderCreator));
ExternalFightCreationActions.INSTANCE.m_lookAtTheFoeActions2.put(
msg.getFightId(),
LookAtTheFoeAction.checkout(
2, FightActionType.LOOK_AT_THE_FOE.getId(), 0, defenderCreator, attackerCreator));
ExternalFightCreationActions.INSTANCE.m_lookAtTheFoeActions3.put(
msg.getFightId(),
LookAtTheFoeAction.checkout(
3,
FightActionType.LOOK_AT_THE_FOE.getId(),
0,
externalFightInfo.getFightersInTeam(attackerCreator.getTeamId()),
defenderCreator));
ExternalFightCreationActions.INSTANCE.m_lookAtTheFoeActions4.put(
msg.getFightId(),
LookAtTheFoeAction.checkout(
4,
FightActionType.LOOK_AT_THE_FOE.getId(),
0,
externalFightInfo.getFightersInTeam(defenderCreator.getTeamId()),
attackerCreator));
ExternalFightCreationActions.INSTANCE.m_playAnimationAction2.put(
msg.getFightId(),
PlayAnimationAction.checkout(
6, FightActionType.PLAY_ANIMATION.getId(), 0, defenderCreator, "AnimHit", 250));
if (displayEffect) {
ExternalFightCreationActions.INSTANCE.m_tauntAction1.put(
msg.getFightId(),
TauntAction.checkout(10, FightActionType.TAUNT.getId(), 0, defenderCreator));
final Collection<CharacterInfo> fightersWhoTaunt =
new HashSet<CharacterInfo>(
externalFightInfo.getFightersInTeam(defenderCreator.getTeamId()));
fightersWhoTaunt.remove(defenderCreator);
ExternalFightCreationActions.INSTANCE.m_tauntAction2.put(
msg.getFightId(),
TauntAction.checkout(10, FightActionType.TAUNT.getId(), 0, fightersWhoTaunt));
}
externalFightInfo.setAttackerCreator(attackerCreator);
externalFightInfo.setDefenderCreator(defenderCreator);
}
if (displayEffect) {
final AbstractBattlegroundBorderEffectArea baseArea =
StaticEffectAreaManager.getInstance()
.getBorderCellArea(msg.getBattlegroundBorderEffectAreaBaseId());
if (baseArea != null) {
final AbstractBattlegroundBorderEffectArea area =
(AbstractBattlegroundBorderEffectArea)
baseArea.instanceAnother(
new EffectAreaParameters(
msg.getBattlegroundBorderEffectAreaUID(),
fightMap.getMinX(),
fightMap.getMinY(),
fightMap.getMinZ(),
externalFightInfo.getContext(),
null,
(short) 0,
Direction8.NONE));
area.initialize(fightMap);
externalFightInfo.getEffectAreaManager().addEffectArea(area);
} else {
ExternalFightCreationMessageHandler.m_logger.error(
(Object)
("Impossible de cr\u00e9er la bulle de combat : la zone d'effet d'index "
+ msg.getBattlegroundBorderEffectAreaBaseId()
+ " n'existe pas"));
}
((ExternalFightCellLightModifier) externalFightInfo.getCellLightModifier())
.setFightMap(fightMap);
}
FightManager.getInstance().addFight(externalFightInfo);
LocalPartitionManager.getInstance().addExternalFight(externalFightInfo);
if (attackerCreator != null && defenderCreator != null) {
FightVisibilityManager.getInstance().onExternalFightCreation(externalFightInfo);
}
return false;
}
/**
* Encodes memcache message to a raw byte array.
*
* @param msg Message being serialized.
* @return Serialized message.
* @throws GridException If serialization failed.
*/
private ByteBuffer encodeMemcache(GridTcpRestPacket msg) throws GridException {
GridByteArrayList res = new GridByteArrayList(HDR_LEN);
int keyLength = 0;
int keyFlags = 0;
if (msg.key() != null) {
ByteArrayOutputStream rawKey = new ByteArrayOutputStream();
keyFlags = encodeObj(msg.key(), rawKey);
msg.key(rawKey.toByteArray());
keyLength = rawKey.size();
}
int dataLength = 0;
int valFlags = 0;
if (msg.value() != null) {
ByteArrayOutputStream rawVal = new ByteArrayOutputStream();
valFlags = encodeObj(msg.value(), rawVal);
msg.value(rawVal.toByteArray());
dataLength = rawVal.size();
}
int flagsLength = 0;
if (msg.addFlags()) // || keyFlags > 0 || valFlags > 0)
flagsLength = FLAGS_LENGTH;
res.add(MEMCACHE_RES_FLAG);
res.add(msg.operationCode());
// Cast is required due to packet layout.
res.add((short) keyLength);
// Cast is required due to packet layout.
res.add((byte) flagsLength);
// Data type is always 0x00.
res.add((byte) 0x00);
res.add((short) msg.status());
res.add(keyLength + flagsLength + dataLength);
res.add(msg.opaque(), 0, msg.opaque().length);
// CAS, unused.
res.add(0L);
assert res.size() == HDR_LEN;
if (flagsLength > 0) {
res.add((short) keyFlags);
res.add((short) valFlags);
}
assert msg.key() == null || msg.key() instanceof byte[];
assert msg.value() == null || msg.value() instanceof byte[];
if (keyLength > 0) res.add((byte[]) msg.key(), 0, ((byte[]) msg.key()).length);
if (dataLength > 0) res.add((byte[]) msg.value(), 0, ((byte[]) msg.value()).length);
return ByteBuffer.wrap(res.entireArray());
}