Java tutorial
/* * Copyright 2011 David Brazdil * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package uk.ac.cam.db538.cryptosms.storage; import java.nio.ByteBuffer; import java.util.ArrayList; import org.joda.time.DateTime; import org.joda.time.format.ISODateTimeFormat; import uk.ac.cam.db538.cryptosms.crypto.Encryption; import uk.ac.cam.db538.cryptosms.crypto.EncryptionInterface.EncryptionException; import uk.ac.cam.db538.cryptosms.utils.Charset; import uk.ac.cam.db538.cryptosms.utils.LowLevel; /** * * Class representing a message entry in the secure storage file. * * @author David Brazdil * */ public class MessageData { // FILE FORMAT public static final int LENGTH_MESSAGE = 133; private static final int LENGTH_FLAGS = 1; private static final int LENGTH_TIMESTAMP = 29; private static final int LENGTH_MESSAGEBODYLEN = 2; private static final int LENGTH_MESSAGEBODY = LENGTH_MESSAGE; private static final int OFFSET_FLAGS = 0; private static final int OFFSET_TIMESTAMP = OFFSET_FLAGS + LENGTH_FLAGS; private static final int OFFSET_MESSAGEBODYLEN = OFFSET_TIMESTAMP + LENGTH_TIMESTAMP; private static final int OFFSET_MESSAGEBODY = OFFSET_MESSAGEBODYLEN + LENGTH_MESSAGEBODYLEN; private static final int OFFSET_RANDOMDATA = OFFSET_MESSAGEBODY + LENGTH_MESSAGEBODY; private static final int OFFSET_NEXTINDEX = Storage.ENCRYPTED_ENTRY_SIZE - 4; private static final int OFFSET_PREVINDEX = OFFSET_NEXTINDEX - 4; private static final int OFFSET_MSGSINDEX = OFFSET_PREVINDEX - 4; private static final int OFFSET_PARENTINDEX = OFFSET_MSGSINDEX - 4; private static final int LENGTH_RANDOMDATA = OFFSET_PARENTINDEX - OFFSET_RANDOMDATA; public enum MessageType { INCOMING, OUTGOING } // STATIC private static ArrayList<MessageData> cacheMessageData = new ArrayList<MessageData>(); /** * Removes all instances from the list of cached objects. * Be sure you don't use the instances afterwards. */ public static void forceClearCache() { synchronized (cacheMessageData) { cacheMessageData = new ArrayList<MessageData>(); } } /** * Returns an instance of a new MessageData entry in the storage file. * * @param parent the parent * @return the message data * @throws StorageFileException the storage file exception */ public static MessageData createMessageData(Conversation parent) throws StorageFileException { // create a new one MessageData msg = new MessageData(Empty.getEmptyIndex(), false); parent.attachMessageData(msg); return msg; } /** * Returns an instance of Empty class with given index in file. * * @param index Index in file * @return the message data * @throws StorageFileException the storage file exception */ static MessageData getMessageData(long index) throws StorageFileException { if (index <= 0L) return null; // try looking it up synchronized (cacheMessageData) { for (MessageData empty : cacheMessageData) if (empty.getEntryIndex() == index) return empty; } // create a new one return new MessageData(index, true); } // INTERNAL FIELDS private long mEntryIndex; // READ ONLY private boolean mDeliveredPart; private boolean mDeliveredAll; private MessageType mMessageType; private boolean mUnread; private boolean mCompressed; private boolean mAscii; private DateTime mTimeStamp; private byte[] mMessageBody; private long mIndexParent; private long mIndexMessageParts; private long mIndexPrev; private long mIndexNext; // CONSTRUCTORS /** * Constructor * @param index Which chunk of data should occupy in file * @param readFromFile Does this entry already exist in the file? * @throws StorageFileException */ private MessageData(long index, boolean readFromFile) throws StorageFileException { mEntryIndex = index; if (readFromFile) { byte[] dataEncrypted = Storage.getStorage().getEntry(index); byte[] dataPlain; try { dataPlain = Encryption.getEncryption().decryptSymmetricWithMasterKey(dataEncrypted); } catch (EncryptionException e) { throw new StorageFileException(e); } byte flags = dataPlain[OFFSET_FLAGS]; boolean deliveredPart = ((flags & (1 << 7)) == 0) ? false : true; boolean deliveredAll = ((flags & (1 << 6)) == 0) ? false : true; boolean messageOutgoing = ((flags & (1 << 5)) == 0) ? false : true; boolean unread = ((flags & (1 << 4)) == 0) ? false : true; boolean compressed = ((flags & (1 << 3)) == 0) ? false : true; boolean ascii = ((flags & (1 << 2)) == 0) ? false : true; String timeStamp = Charset.fromAscii8(dataPlain, OFFSET_TIMESTAMP, LENGTH_TIMESTAMP); setDeliveredPart(deliveredPart); setDeliveredAll(deliveredAll); setMessageType((messageOutgoing) ? MessageType.OUTGOING : MessageType.INCOMING); setUnread(unread); setCompressed(compressed); setAscii(ascii); setTimeStamp(ISODateTimeFormat.dateTimeParser().parseDateTime(timeStamp)); int messageBodyLength = Math.min(LENGTH_MESSAGEBODY, LowLevel.getUnsignedShort(dataPlain, OFFSET_MESSAGEBODYLEN)); setMessageBody(LowLevel.cutData(dataPlain, OFFSET_MESSAGEBODY, messageBodyLength)); setIndexParent(LowLevel.getUnsignedInt(dataPlain, OFFSET_PARENTINDEX)); setIndexMessageParts(LowLevel.getUnsignedInt(dataPlain, OFFSET_MSGSINDEX)); setIndexPrev(LowLevel.getUnsignedInt(dataPlain, OFFSET_PREVINDEX)); setIndexNext(LowLevel.getUnsignedInt(dataPlain, OFFSET_NEXTINDEX)); } else { // default values setDeliveredPart(false); setDeliveredAll(false); setMessageType(MessageType.OUTGOING); setUnread(false); setCompressed(false); setAscii(true); setTimeStamp(new DateTime()); setMessageBody(new byte[0]); setIndexParent(0L); setIndexMessageParts(0L); setIndexPrev(0L); setIndexNext(0L); saveToFile(); } synchronized (cacheMessageData) { cacheMessageData.add(this); } } // FUNCTIONS /** * Save the contents of this class to its place in the storage file. * * @throws StorageFileException the storage file exception */ public void saveToFile() throws StorageFileException { ByteBuffer msgBuffer = ByteBuffer.allocate(Storage.ENCRYPTED_ENTRY_SIZE); // flags byte flags = 0; if (this.mDeliveredPart) flags |= (byte) ((1 << 7) & 0xFF); if (this.mDeliveredAll) flags |= (byte) ((1 << 6) & 0xFF); if (this.mMessageType == MessageType.OUTGOING) flags |= (byte) ((1 << 5) & 0xFF); if (this.mUnread) flags |= (byte) ((1 << 4) & 0xFF); if (this.mCompressed) flags |= (byte) ((1 << 3) & 0xFF); if (this.mAscii) flags |= (byte) ((1 << 2) & 0xFF); msgBuffer.put(flags); // time stamp String timeStamp = ISODateTimeFormat.dateTime().print(this.mTimeStamp); msgBuffer.put(Charset.toAscii8(timeStamp, LENGTH_TIMESTAMP)); // message body msgBuffer.put(LowLevel.getBytesUnsignedShort(this.mMessageBody.length)); msgBuffer.put(LowLevel.wrapData(mMessageBody, LENGTH_MESSAGEBODY)); // random data msgBuffer.put(Encryption.getEncryption().generateRandomData(LENGTH_RANDOMDATA)); // indices msgBuffer.put(LowLevel.getBytesUnsignedInt(this.mIndexParent)); msgBuffer.put(LowLevel.getBytesUnsignedInt(this.mIndexMessageParts)); msgBuffer.put(LowLevel.getBytesUnsignedInt(this.mIndexPrev)); msgBuffer.put(LowLevel.getBytesUnsignedInt(this.mIndexNext)); byte[] dataEncrypted = null; try { dataEncrypted = Encryption.getEncryption().encryptSymmetricWithMasterKey(msgBuffer.array()); } catch (EncryptionException e) { throw new StorageFileException(e); } Storage.getStorage().setEntry(mEntryIndex, dataEncrypted); } /** * Returns an instance of the Conversation class that is the parent of this Message in the data structure * @return * @throws StorageFileException */ public Conversation getParent() throws StorageFileException { if (mIndexParent == 0) return null; return Conversation.getConversation(mIndexParent); } /** * Returns an instance of the Message that's predecessor of this one in the linked list of Messages of this Conversation * @return * @throws StorageFileException */ public MessageData getPreviousMessageData() throws StorageFileException { if (mIndexPrev == 0) return null; return MessageData.getMessageData(mIndexPrev); } /** * Returns an instance of the Message that's successor of this one in the linked list of Messages of this Conversation * @return * @throws StorageFileException */ public MessageData getNextMessageData() throws StorageFileException { if (mIndexNext == 0) return null; return MessageData.getMessageData(mIndexNext); } /** * Returns first message part in the linked list of MessageParts. * Should not be public - Message has API for making this seamlessly * @return * @throws StorageFileException */ MessageDataPart getFirstMessageDataPart() throws StorageFileException { if (mIndexMessageParts == 0) return null; return MessageDataPart.getMessageDataPart(mIndexMessageParts); } /** * Replaces assigned message parts with given list. * * @param list the list * @throws StorageFileException the storage file exception */ void assignMessageDataParts(ArrayList<MessageDataPart> list) throws StorageFileException { // delete all previous message parts long indexFirstInStack = getIndexMessageParts(); while (indexFirstInStack != 0) { MessageDataPart msgPart = MessageDataPart.getMessageDataPart(indexFirstInStack); indexFirstInStack = msgPart.getIndexNext(); msgPart.delete(); } // add new ones for (int i = 0; i < list.size(); ++i) { MessageDataPart msgPart = list.get(i); // parent msgPart.setIndexParent(this.mEntryIndex); // previous pointer if (i > 0) msgPart.setIndexPrev(list.get(i - 1).getEntryIndex()); else msgPart.setIndexPrev(0L); // next pointer if (i < list.size() - 1) msgPart.setIndexNext(list.get(i + 1).getEntryIndex()); else msgPart.setIndexNext(0L); msgPart.saveToFile(); } // update pointer in the conversation if (list.size() > 0) this.setIndexMessageParts(list.get(0).getEntryIndex()); else this.setIndexMessageParts(0L); this.saveToFile(); } /** * Delete Message and all the MessageParts it controls. * * @throws StorageFileException the storage file exception */ public void delete() throws StorageFileException { MessageData prev = this.getPreviousMessageData(); MessageData next = this.getNextMessageData(); if (prev != null) { // this is not the first message in the list // update the previous one prev.setIndexNext(this.getIndexNext()); prev.saveToFile(); } else { // this IS the first message in the list // update parent Conversation parent = this.getParent(); parent.setIndexMessages(this.getIndexNext()); parent.saveToFile(); } // update next one if (next != null) { next.setIndexPrev(this.getIndexPrev()); next.saveToFile(); } // delete all of the MessageParts MessageDataPart part = getFirstMessageDataPart(); while (part != null) { part.delete(); part = getFirstMessageDataPart(); } // delete this message Empty.replaceWithEmpty(mEntryIndex); // remove from cache synchronized (cacheMessageData) { cacheMessageData.remove(this); } // make this instance invalid this.mEntryIndex = -1L; } // MESSAGE HIGH LEVEL /** * Returns the data assigned to message part at given index. * * @param index the index * @return the part data * @throws StorageFileException the storage file exception */ public byte[] getPartData(int index) throws StorageFileException { if (index == 0) return this.getMessageBody(); else { --index; MessageDataPart part = getFirstMessageDataPart(); while (part != null) { if (index-- == 0) return part.getMessageBody(); part = part.getNextMessageDataPart(); } } throw new IndexOutOfBoundsException(); } /** * Adds/removes message parts so that there is exactly given number of them * (There is always at least one) * @param count * @throws StorageFileException */ public void setNumberOfParts(int count) throws StorageFileException { --count; // count the first part MessageDataPart temp = null, part = getFirstMessageDataPart(); while (count > 0 && part != null) { part.setMessageBody(new byte[0]); part.setDeliveredPart(false); part.saveToFile(); --count; temp = part; part = part.getNextMessageDataPart(); } if (count > 0 && part == null) { // we need to add more while (count-- > 0) { part = MessageDataPart.createMessageDataPart(); // parent part.setIndexParent(this.mEntryIndex); // pointers if (temp == null) { // this is the first one in list part.setIndexPrev(0L); this.setIndexMessageParts(part.getEntryIndex()); this.saveToFile(); } else { part.setIndexPrev(temp.getEntryIndex()); temp.setIndexNext(part.getEntryIndex()); temp.saveToFile(); } part.setIndexNext(0); // save and move to next if (count <= 0) // otherwise will be saved in the next run part.saveToFile(); temp = part; } } else if (count <= 0 && part != null) { // we need to remove some while (part != null) { temp = part.getNextMessageDataPart(); part.delete(); part = temp; } } } /** * Returns message part of given index (only for indices > 0) * @param index * @return * @throws StorageFileException */ private MessageDataPart getMessageDataPart(int index) throws StorageFileException { if (index <= 0) throw new IndexOutOfBoundsException(); else { --index; // for the first part MessageDataPart part = this.getFirstMessageDataPart(); while (part != null && index > 0) { part = part.getNextMessageDataPart(); index--; } if (part != null) return part; else throw new IndexOutOfBoundsException(); } } /** * Sets data to given message part. * * @param index the index * @param data the data * @throws StorageFileException the storage file exception */ public void setPartData(int index, byte[] data) throws StorageFileException { // if it's too long, just cut it if (data.length > LENGTH_MESSAGEBODY) data = LowLevel.cutData(data, 0, LENGTH_MESSAGEBODY); if (index == 0) { this.setMessageBody(data); this.saveToFile(); } else { MessageDataPart part = getMessageDataPart(index); part.setMessageBody(data); part.saveToFile(); } } /** * Returns whether given message part was delivered. * * @param index the index * @return the part delivered * @throws StorageFileException the storage file exception */ public boolean getPartDelivered(int index) throws StorageFileException { if (index == 0) return this.getDeliveredPart(); else return getMessageDataPart(index).getDeliveredPart(); } /** * Sets whether given message part was delivered. * * @param index the index * @param delivered the delivered * @throws StorageFileException the storage file exception */ public void setPartDelivered(int index, boolean delivered) throws StorageFileException { if (index == 0) { this.setDeliveredPart(delivered); this.saveToFile(); } else { MessageDataPart part = getMessageDataPart(index); part.setDeliveredPart(delivered); part.saveToFile(); } } // GETTERS / SETTERS long getEntryIndex() { return mEntryIndex; } void setDeliveredPart(boolean deliveredPart) { this.mDeliveredPart = deliveredPart; } boolean getDeliveredPart() { return mDeliveredPart; } public void setDeliveredAll(boolean deliveredAll) { this.mDeliveredAll = deliveredAll; } public boolean getDeliveredAll() { return mDeliveredAll; } public void setMessageType(MessageType messageType) { this.mMessageType = messageType; } public MessageType getMessageType() { return mMessageType; } public void setUnread(boolean unread) { this.mUnread = unread; } public boolean getUnread() { return mUnread; } public void setCompressed(boolean compressed) { this.mCompressed = compressed; } public boolean getCompressed() { return mCompressed; } public void setAscii(boolean ascii) { this.mAscii = ascii; } public boolean getAscii() { return mAscii; } void setMessageBody(byte[] messageBody) { this.mMessageBody = messageBody; } byte[] getMessageBody() { return mMessageBody; } public void setTimeStamp(DateTime timeStamp) { this.mTimeStamp = timeStamp; } public DateTime getTimeStamp() { return mTimeStamp; } long getIndexMessageParts() { return mIndexMessageParts; } void setIndexMessageParts(long indexMessageParts) { if (indexMessageParts > 0xFFFFFFFFL || indexMessageParts < 0L) throw new IndexOutOfBoundsException(); this.mIndexMessageParts = indexMessageParts; } long getIndexPrev() { return mIndexPrev; } void setIndexPrev(long indexPrev) { if (indexPrev > 0xFFFFFFFFL || indexPrev < 0L) throw new IndexOutOfBoundsException(); this.mIndexPrev = indexPrev; } long getIndexNext() { return mIndexNext; } void setIndexNext(long indexNext) { if (indexNext > 0xFFFFFFFFL || indexNext < 0L) throw new IndexOutOfBoundsException(); this.mIndexNext = indexNext; } void setIndexParent(long indexParent) { this.mIndexParent = indexParent; } long getIndexParent() { return mIndexParent; } }