/** * Constructs a IndexEntry out of a InputStream. This will read the tag id, * the data type, the offset of the data and the number of elements of * data. Note that the number of elements varies in its meaning depending * on the data type. * * @param inputStream An InputStream containing a rpm file. * @throws IOException If an error occurs during reading from stream */ public IndexEntry(java.io.DataInputStream inputStream) {//throws IOException { tag = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("tag:" + tag); } type = RPMIndexType.getRPMIndexType(inputStream.readInt()); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("type: " + type); } offset = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("offset: " + offset); } count = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("count: " + count); } check(!type.equals(RPMIndexType.UNKNOWN)); }
/** * Constructs a type froma stream * * @param inputStream An input stream * @param indexEntry The index informations * @return The size of the read data * @throws IOException if an I/O error occurs. */ public static INT32 readFromStream(java.io.DataInputStream inputStream, IndexEntry indexEntry) {//throws IOException { if (indexEntry.getType() != RPMIndexType.INT32) { throw new java.lang.IllegalArgumentException("Type <" + indexEntry.getType() + "> does not match <" + RPMIndexType.INT32 + ">"); } int[] data = new int[(int)indexEntry.getCount()]; for (int pos = 0; pos < indexEntry.getCount(); pos++) { data[pos] = inputStream.readInt(); } INT32 int32Object = new INT32(data); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer(int32Object.toString()); } // int32Object.size = indexEntry.getType().getSize() // * indexEntry.getCount(); return(int32Object); }
/** * Create a header structure from an input stream. <p/> The header * structure of a signature or a header can be read and also the index * entries containing the tags for this rpm section (signature or * header). <p/> Unless we have a raw header from headerUnload or the * database, a header is read consisting of the following fields: * <code><pre> * byte magic[3]; (3 byte) (8e ad e8) * int version; (1 byte) * byte reserved[4]; (4 byte) * long num_index; (4 byte) * long num_data; (4 byte) * </pre></code> <p/> Afterwards the index entries are read and then the tags * and the correspondig data entries are read. * * @param inputStream * An inputstream containing rpm file informations * @param rawHeader * Are we a raw header (from headerUnload or rpmdb) * @throws IOException * if an error occurs on reading informations out of the * stream */ public Header(java.io.DataInputStream inputStream, bool rawHeader, Store store) {//throws IOException { this.store = store; if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Start Reading Header"); } if (!rawHeader) { // Read header size = HEADER_LENGTH; int magic = 0; do { magic = inputStream.readUnsignedByte(); if (magic == 0) { inputStream.skip(7); } } while (magic == 0); check(magic == 0x8E, "Header magic 0x" + java.lang.Integer.toHexString(magic) + " != 0x8E"); magic = inputStream.readUnsignedByte(); check(magic == 0xAD, "Header magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xAD"); magic = inputStream.readUnsignedByte(); check(magic == 0xE8, "Header magic 0x" + java.lang.Integer.toHexString(magic) + " != 0xE8"); version = inputStream.readUnsignedByte(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("version: " + version); } // skip reserved bytes inputStream.skipBytes(4); } indexNumber = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("indexes available: " + indexNumber); } indexDataSize = inputStream.readInt(); if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("index data size: " + indexDataSize); } // Read indexes // make sure to sort them in order of offset to // be able to read the store without jumping arround in // the file java.util.TreeSet <IndexEntry> _indexes = new java.util.TreeSet <IndexEntry>(new IAC_IndexesComparator()); for (int i = 0; i < this.indexNumber; i++) { IndexEntry index = new IndexEntry(inputStream); _indexes.add(index); size += index.getSize(); } indexes = new IndexEntry[0]; indexes = (IndexEntry[])_indexes.toArray(indexes); // Read store for (int i = 0; i < indexes.Length; i++) { IndexEntry index = indexes[i]; // if (index.getType().equals(RPMIndexType.STRING_ARRAY) || // index.getType().equals(RPMIndexType.STRING) || // index.getType().equals(RPMIndexType.I18NSTRING)) { // if (i < (indexes.length - 1)) { // IndexEntry next = indexes[i + 1]; // // length = next.getOffset() - index.getOffset(); // } else { // length = indexDataSize - index.getOffset(); // } // // // and initialize temporary space for data // stringData = new byte[(int) length]; // // // and read it from stream // inputStream.readFully(stringData); // } DataTypeIf dataObject = null; if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Reading for tag '" + store.getTagNameForId(index.getTag()) + "' '" + index.getCount() + "' entries of type '" + index.getType().getName() + "'"); } dataObject = TypeFactory .createFromStream(inputStream, index, (i < (indexes.Length - 1)) ? (indexes[i + 1] .getOffset() - index.getOffset()) : (indexDataSize - index.getOffset())); // adjust size size += dataObject.getSize(); store.setTag(index.getTag(), dataObject); } if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer(""); } if (logger.isLoggable(java.util.logging.Level.FINER)) { logger.finer("Finished Reading Header"); } }