1 /*
2 * Copyright (C) 2008, Google Inc.
3 * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
4 * and other copyright owners as documented in the project's IP log.
5 *
6 * This program and the accompanying materials are made available
7 * under the terms of the Eclipse Distribution License v1.0 which
8 * accompanies this distribution, is reproduced below, and is
9 * available at http://www.eclipse.org/org/documents/edl-v10.php
10 *
11 * All rights reserved.
12 *
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
15 * conditions are met:
16 *
17 * - Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 *
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials provided
23 * with the distribution.
24 *
25 * - Neither the name of the Eclipse Foundation, Inc. nor the
26 * names of its contributors may be used to endorse or promote
27 * products derived from this software without specific prior
28 * written permission.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
31 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
32 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
33 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
34 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
35 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
36 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
37 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
38 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
39 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
41 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
42 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 */
44
45 package org.eclipse.jgit.patch;
46
47 import static org.eclipse.jgit.lib.Constants.encodeASCII;
48 import static org.eclipse.jgit.util.RawParseUtils.match;
49 import static org.eclipse.jgit.util.RawParseUtils.nextLF;
50 import static org.eclipse.jgit.util.RawParseUtils.parseBase10;
51
52 /**
53 * Part of a "GIT binary patch" to describe the pre-image or post-image
54 */
55 public class BinaryHunk {
56 private static final byte[] LITERAL = encodeASCII("literal "); //$NON-NLS-1$
57
58 private static final byte[] DELTA = encodeASCII("delta "); //$NON-NLS-1$
59
60 /** Type of information stored in a binary hunk. */
61 public static enum Type {
62 /** The full content is stored, deflated. */
63 LITERAL_DEFLATED,
64
65 /** A Git pack-style delta is stored, deflated. */
66 DELTA_DEFLATED;
67 }
68
69 private final FileHeader file;
70
71 /** Offset within {@link #file}.buf to the "literal" or "delta " line. */
72 final int startOffset;
73
74 /** Position 1 past the end of this hunk within {@link #file}'s buf. */
75 int endOffset;
76
77 /** Type of the data meaning. */
78 private Type type;
79
80 /** Inflated length of the data. */
81 private int length;
82
83 BinaryHunk(FileHeader fh, int offset) {
84 file = fh;
85 startOffset = offset;
86 }
87
88 /**
89 * Get header for the file this hunk applies to.
90 *
91 * @return header for the file this hunk applies to.
92 */
93 public FileHeader getFileHeader() {
94 return file;
95 }
96
97 /**
98 * Get the byte array holding this hunk's patch script.
99 *
100 * @return the byte array holding this hunk's patch script.
101 */
102 public byte[] getBuffer() {
103 return file.buf;
104 }
105
106 /**
107 * Get offset the start of this hunk in {@link #getBuffer()}.
108 *
109 * @return offset the start of this hunk in {@link #getBuffer()}.
110 */
111 public int getStartOffset() {
112 return startOffset;
113 }
114
115 /**
116 * Get offset one past the end of the hunk in {@link #getBuffer()}.
117 *
118 * @return offset one past the end of the hunk in {@link #getBuffer()}.
119 */
120 public int getEndOffset() {
121 return endOffset;
122 }
123
124 /**
125 * Get type of this binary hunk.
126 *
127 * @return type of this binary hunk.
128 */
129 public Type getType() {
130 return type;
131 }
132
133 /**
134 * Get inflated size of this hunk's data.
135 *
136 * @return inflated size of this hunk's data.
137 */
138 public int getSize() {
139 return length;
140 }
141
142 int parseHunk(int ptr, int end) {
143 final byte[] buf = file.buf;
144
145 if (match(buf, ptr, LITERAL) >= 0) {
146 type = Type.LITERAL_DEFLATED;
147 length = parseBase10(buf, ptr + LITERAL.length, null);
148
149 } else if (match(buf, ptr, DELTA) >= 0) {
150 type = Type.DELTA_DEFLATED;
151 length = parseBase10(buf, ptr + DELTA.length, null);
152
153 } else {
154 // Not a valid binary hunk. Signal to the caller that
155 // we cannot parse any further and that this line should
156 // be treated otherwise.
157 //
158 return -1;
159 }
160 ptr = nextLF(buf, ptr);
161
162 // Skip until the first blank line; that is the end of the binary
163 // encoded information in this hunk. To save time we don't do a
164 // validation of the binary data at this point.
165 //
166 while (ptr < end) {
167 final boolean empty = buf[ptr] == '\n';
168 ptr = nextLF(buf, ptr);
169 if (empty)
170 break;
171 }
172
173 return ptr;
174 }
175 }