001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019 package org.apache.commons.compress.archivers.ar; 020 021 import java.io.IOException; 022 import java.io.InputStream; 023 024 import org.apache.commons.compress.archivers.ArchiveEntry; 025 import org.apache.commons.compress.archivers.ArchiveInputStream; 026 import org.apache.commons.compress.utils.ArchiveUtils; 027 028 /** 029 * Implements the "ar" archive format as an input stream. 030 * 031 * @NotThreadSafe 032 * 033 */ 034 public class ArArchiveInputStream extends ArchiveInputStream { 035 036 private final InputStream input; 037 private long offset = 0; 038 private boolean closed; 039 040 /* 041 * If getNextEnxtry has been called, the entry metadata is stored in 042 * currentEntry. 043 */ 044 private ArArchiveEntry currentEntry = null; 045 046 // Storage area for extra long names (GNU ar) 047 private byte[] namebuffer = null; 048 049 /* 050 * The offset where the current entry started. -1 if no entry has been 051 * called 052 */ 053 private long entryOffset = -1; 054 055 /** 056 * Constructs an Ar input stream with the referenced stream 057 * 058 * @param pInput 059 * the ar input stream 060 */ 061 public ArArchiveInputStream(final InputStream pInput) { 062 input = pInput; 063 closed = false; 064 } 065 066 /** 067 * Returns the next AR entry in this stream. 068 * 069 * @return the next AR entry. 070 * @throws IOException 071 * if the entry could not be read 072 */ 073 public ArArchiveEntry getNextArEntry() throws IOException { 074 if (currentEntry != null) { 075 final long entryEnd = entryOffset + currentEntry.getLength(); 076 while (offset < entryEnd) { 077 int x = read(); 078 if (x == -1) { 079 // hit EOF before previous entry was complete 080 // TODO: throw an exception instead? 081 return null; 082 } 083 } 084 currentEntry = null; 085 } 086 087 if (offset == 0) { 088 final byte[] expected = ArchiveUtils.toAsciiBytes(ArArchiveEntry.HEADER); 089 final byte[] realized = new byte[expected.length]; 090 final int read = read(realized); 091 if (read != expected.length) { 092 throw new IOException("failed to read header. Occured at byte: " + getBytesRead()); 093 } 094 for (int i = 0; i < expected.length; i++) { 095 if (expected[i] != realized[i]) { 096 throw new IOException("invalid header " + ArchiveUtils.toAsciiString(realized)); 097 } 098 } 099 } 100 101 if (offset % 2 != 0 && read() < 0) { 102 // hit eof 103 return null; 104 } 105 106 if (input.available() == 0) { 107 return null; 108 } 109 110 final byte[] name = new byte[16]; 111 final byte[] lastmodified = new byte[12]; 112 final byte[] userid = new byte[6]; 113 final byte[] groupid = new byte[6]; 114 final byte[] filemode = new byte[8]; 115 final byte[] length = new byte[10]; 116 117 read(name); 118 read(lastmodified); 119 read(userid); 120 read(groupid); 121 read(filemode); 122 read(length); 123 124 { 125 final byte[] expected = ArchiveUtils.toAsciiBytes(ArArchiveEntry.TRAILER); 126 final byte[] realized = new byte[expected.length]; 127 final int read = read(realized); 128 if (read != expected.length) { 129 throw new IOException("failed to read entry trailer. Occured at byte: " + getBytesRead()); 130 } 131 for (int i = 0; i < expected.length; i++) { 132 if (expected[i] != realized[i]) { 133 throw new IOException("invalid entry trailer. not read the content? Occured at byte: " + getBytesRead()); 134 } 135 } 136 } 137 138 entryOffset = offset; 139 140 // GNU ar stores multiple extended filenames in the data section of a file with the name "//", this record is referred to by future headers. A header references an extended filename by storing a "/" followed by a decimal offset to the start of the filename in the extended filename data section. The format of this "//" file itself is simply a list of the long filenames, each separated by one or more LF characters. Note that the decimal offsets are number of characters, not line or string number within the "//" file. 141 // 142 // GNU ar uses a '/' to mark the end of the filename; this allows for the use of spaces without the use of an extended filename. 143 144 // entry name is stored as ASCII string 145 String temp = ArchiveUtils.toAsciiString(name).trim(); 146 147 if (temp.equals("//")){ // GNU extended filenames entry 148 int bufflen = asInt(length); // Assume length will fit in an int 149 namebuffer = new byte[bufflen]; 150 int read = read(namebuffer, 0, bufflen); 151 if (read != bufflen){ 152 throw new IOException("Failed to read complete // record: expected="+bufflen+" read="+read); 153 } 154 currentEntry = new ArArchiveEntry(temp, bufflen); 155 return getNextArEntry(); 156 } else if (temp.endsWith("/")) { // GNU terminator 157 temp = temp.substring(0, temp.length() - 1); 158 } else if (temp.matches("^/\\d+")) {// GNU long filename ref. 159 int offset = Integer.parseInt(temp.substring(1));// get the offset 160 temp = getExtendedName(offset); // convert to the long name 161 } 162 currentEntry = new ArArchiveEntry(temp, asLong(length), asInt(userid, true), 163 asInt(groupid, true), asInt(filemode, 8), 164 asLong(lastmodified)); 165 return currentEntry; 166 } 167 168 /** 169 * Get an extended name from the GNU extended name buffer. 170 * 171 * @param offset pointer to entry within the buffer 172 * @return the extended file name; without trailing "/" if present. 173 * @throws IOException if name not found or buffer not set up 174 */ 175 private String getExtendedName(int offset) throws IOException{ 176 if (namebuffer == null) { 177 throw new IOException("Cannot process GNU long filename as no // record was found"); 178 } 179 for(int i=offset; i < namebuffer.length; i++){ 180 if (namebuffer[i]=='\012'){ 181 if (namebuffer[i-1]=='/') { 182 i--; // drop trailing / 183 } 184 return ArchiveUtils.toAsciiString(namebuffer, offset, i-offset); 185 } 186 } 187 throw new IOException("Failed to read entry: "+offset); 188 } 189 private long asLong(byte[] input) { 190 return Long.parseLong(new String(input).trim()); 191 } 192 193 private int asInt(byte[] input) { 194 return asInt(input, 10, false); 195 } 196 197 private int asInt(byte[] input, boolean treatBlankAsZero) { 198 return asInt(input, 10, treatBlankAsZero); 199 } 200 201 private int asInt(byte[] input, int base) { 202 return asInt(input, base, false); 203 } 204 205 private int asInt(byte[] input, int base, boolean treatBlankAsZero) { 206 String string = new String(input).trim(); 207 if (string.length() == 0 && treatBlankAsZero) { 208 return 0; 209 } 210 return Integer.parseInt(string, base); 211 } 212 213 /* 214 * (non-Javadoc) 215 * 216 * @see 217 * org.apache.commons.compress.archivers.ArchiveInputStream#getNextEntry() 218 */ 219 public ArchiveEntry getNextEntry() throws IOException { 220 return getNextArEntry(); 221 } 222 223 /* 224 * (non-Javadoc) 225 * 226 * @see java.io.InputStream#close() 227 */ 228 public void close() throws IOException { 229 if (!closed) { 230 closed = true; 231 input.close(); 232 } 233 currentEntry = null; 234 } 235 236 /* 237 * (non-Javadoc) 238 * 239 * @see java.io.InputStream#read(byte[], int, int) 240 */ 241 public int read(byte[] b, final int off, final int len) throws IOException { 242 int toRead = len; 243 if (currentEntry != null) { 244 final long entryEnd = entryOffset + currentEntry.getLength(); 245 if (len > 0 && entryEnd > offset) { 246 toRead = (int) Math.min(len, entryEnd - offset); 247 } else { 248 return -1; 249 } 250 } 251 final int ret = this.input.read(b, off, toRead); 252 count(ret); 253 offset += (ret > 0 ? ret : 0); 254 return ret; 255 } 256 257 /** 258 * Checks if the signature matches ASCII "!<arch>" followed by a single LF 259 * control character 260 * 261 * @param signature 262 * the bytes to check 263 * @param length 264 * the number of bytes to check 265 * @return true, if this stream is an Ar archive stream, false otherwise 266 */ 267 public static boolean matches(byte[] signature, int length) { 268 // 3c21 7261 6863 0a3e 269 270 if (length < 8) { 271 return false; 272 } 273 if (signature[0] != 0x21) { 274 return false; 275 } 276 if (signature[1] != 0x3c) { 277 return false; 278 } 279 if (signature[2] != 0x61) { 280 return false; 281 } 282 if (signature[3] != 0x72) { 283 return false; 284 } 285 if (signature[4] != 0x63) { 286 return false; 287 } 288 if (signature[5] != 0x68) { 289 return false; 290 } 291 if (signature[6] != 0x3e) { 292 return false; 293 } 294 if (signature[7] != 0x0a) { 295 return false; 296 } 297 298 return true; 299 } 300 301 }