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 /** Part of a "GIT binary patch" to describe the pre-image or post-image */
53 public class BinaryHunk {
54 private static final byte[] LITERAL = encodeASCII("literal "); //$NON-NLS-1$
55
56 private static final byte[] DELTA = encodeASCII("delta "); //$NON-NLS-1$
57
58 /** Type of information stored in a binary hunk. */
59 public static enum Type {
60 /** The full content is stored, deflated. */
61 LITERAL_DEFLATED,
62
63 /** A Git pack-style delta is stored, deflated. */
64 DELTA_DEFLATED;
65 }
66
67 private final FileHeader file;
68
69 /** Offset within {@link #file}.buf to the "literal" or "delta " line. */
70 final int startOffset;
71
72 /** Position 1 past the end of this hunk within {@link #file}'s buf. */
73 int endOffset;
74
75 /** Type of the data meaning. */
76 private Type type;
77
78 /** Inflated length of the data. */
79 private int length;
80
81 BinaryHunk(final FileHeader fh, final int offset) {
82 file = fh;
83 startOffset = offset;
84 }
85
86 /** @return header for the file this hunk applies to */
87 public FileHeader getFileHeader() {
88 return file;
89 }
90
91 /** @return the byte array holding this hunk's patch script. */
92 public byte[] getBuffer() {
93 return file.buf;
94 }
95
96 /** @return offset the start of this hunk in {@link #getBuffer()}. */
97 public int getStartOffset() {
98 return startOffset;
99 }
100
101 /** @return offset one past the end of the hunk in {@link #getBuffer()}. */
102 public int getEndOffset() {
103 return endOffset;
104 }
105
106 /** @return type of this binary hunk */
107 public Type getType() {
108 return type;
109 }
110
111 /** @return inflated size of this hunk's data */
112 public int getSize() {
113 return length;
114 }
115
116 int parseHunk(int ptr, final int end) {
117 final byte[] buf = file.buf;
118
119 if (match(buf, ptr, LITERAL) >= 0) {
120 type = Type.LITERAL_DEFLATED;
121 length = parseBase10(buf, ptr + LITERAL.length, null);
122
123 } else if (match(buf, ptr, DELTA) >= 0) {
124 type = Type.DELTA_DEFLATED;
125 length = parseBase10(buf, ptr + DELTA.length, null);
126
127 } else {
128 // Not a valid binary hunk. Signal to the caller that
129 // we cannot parse any further and that this line should
130 // be treated otherwise.
131 //
132 return -1;
133 }
134 ptr = nextLF(buf, ptr);
135
136 // Skip until the first blank line; that is the end of the binary
137 // encoded information in this hunk. To save time we don't do a
138 // validation of the binary data at this point.
139 //
140 while (ptr < end) {
141 final boolean empty = buf[ptr] == '\n';
142 ptr = nextLF(buf, ptr);
143 if (empty)
144 break;
145 }
146
147 return ptr;
148 }
149 }