1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44 package org.eclipse.jgit.transport;
45
46 import static org.junit.Assert.assertEquals;
47 import static org.junit.Assert.assertFalse;
48 import static org.junit.Assert.assertNotNull;
49 import static org.junit.Assert.assertNull;
50 import static org.junit.Assert.assertSame;
51 import static org.junit.Assert.assertTrue;
52 import static org.junit.Assert.fail;
53
54 import java.io.ByteArrayInputStream;
55 import java.io.IOException;
56 import java.net.URISyntaxException;
57 import java.security.MessageDigest;
58 import java.util.Collections;
59 import java.util.HashMap;
60 import java.util.Map;
61 import java.util.zip.Deflater;
62
63 import org.eclipse.jgit.errors.MissingObjectException;
64 import org.eclipse.jgit.errors.UnpackException;
65 import org.eclipse.jgit.internal.storage.file.ObjectDirectory;
66 import org.eclipse.jgit.internal.storage.pack.BinaryDelta;
67 import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
68 import org.eclipse.jgit.junit.TestRepository;
69 import org.eclipse.jgit.lib.Constants;
70 import org.eclipse.jgit.lib.NullProgressMonitor;
71 import org.eclipse.jgit.lib.ObjectId;
72 import org.eclipse.jgit.lib.ObjectInserter;
73 import org.eclipse.jgit.lib.ObjectLoader;
74 import org.eclipse.jgit.lib.Ref;
75 import org.eclipse.jgit.lib.Repository;
76 import org.eclipse.jgit.revwalk.RevBlob;
77 import org.eclipse.jgit.revwalk.RevCommit;
78 import org.eclipse.jgit.revwalk.RevTree;
79 import org.eclipse.jgit.revwalk.RevWalk;
80 import org.eclipse.jgit.util.NB;
81 import org.eclipse.jgit.util.TemporaryBuffer;
82 import org.junit.After;
83 import org.junit.Before;
84 import org.junit.Test;
85
86 public class ReceivePackAdvertiseRefsHookTest extends LocalDiskRepositoryTestCase {
87 private static final NullProgressMonitor PM = NullProgressMonitor.INSTANCE;
88
89 private static final String R_MASTER = Constants.R_HEADS + Constants.MASTER;
90
91 private static final String R_PRIVATE = Constants.R_HEADS + "private";
92
93 private Repository src;
94
95 private Repository dst;
96
97 private RevCommit A, B, P;
98
99 private RevBlob a, b;
100
101 @Override
102 @Before
103 public void setUp() throws Exception {
104 super.setUp();
105
106 src = createBareRepository();
107 dst = createBareRepository();
108
109
110
111 TestRepository<Repository> d = new TestRepository<>(dst);
112 a = d.blob("a");
113 A = d.commit(d.tree(d.file("a", a)));
114 B = d.commit().parent(A).create();
115 d.update(R_MASTER, B);
116
117
118
119 try (Transport t = Transport.open(src, uriOf(dst))) {
120 t.fetch(PM, Collections.singleton(new RefSpec("+refs/*:refs/*")));
121 assertEquals(B, src.resolve(R_MASTER));
122 }
123
124
125
126 b = d.blob("b");
127 P = d.commit(d.tree(d.file("b", b)), A);
128 d.update(R_PRIVATE, P);
129 }
130
131 @Test
132 public void testFilterHidesPrivate() throws Exception {
133 Map<String, Ref> refs;
134 try (TransportLocal t = new TransportLocal(src, uriOf(dst),
135 dst.getDirectory()) {
136 @Override
137 ReceivePack createReceivePack(final Repository db) {
138 db.close();
139 dst.incrementOpen();
140
141 final ReceivePack rp = super.createReceivePack(dst);
142 rp.setAdvertiseRefsHook(new HidePrivateHook());
143 return rp;
144 }
145 }) {
146 try (PushConnection c = t.openPush()) {
147 refs = c.getRefsMap();
148 }
149 }
150
151 assertNotNull(refs);
152 assertNull("no private", refs.get(R_PRIVATE));
153 assertNull("no HEAD", refs.get(Constants.HEAD));
154 assertEquals(1, refs.size());
155
156 Ref master = refs.get(R_MASTER);
157 assertNotNull("has master", master);
158 assertEquals(B, master.getObjectId());
159 }
160
161 @Test
162 public void testSuccess() throws Exception {
163
164
165 TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(1024);
166
167 packHeader(pack, 2);
168 pack.write((Constants.OBJ_BLOB) << 4 | 1);
169 deflate(pack, new byte[] { 'a' });
170
171 pack.write((Constants.OBJ_REF_DELTA) << 4 | 4);
172 a.copyRawTo(pack);
173 deflate(pack, new byte[] { 0x1, 0x1, 0x1, 'b' });
174
175 digest(pack);
176 openPack(pack);
177
178
179
180 ObjectDirectory od = (ObjectDirectory) src.getObjectDatabase();
181 assertTrue("has b", src.hasObject(b));
182 assertFalse("b not loose", od.fileFor(b).exists());
183
184
185
186 TestRepository<Repository> s = new TestRepository<>(src);
187 RevCommit N = s.commit().parent(B).add("q", b).create();
188 s.update(R_MASTER, N);
189
190
191
192 TransportLocal t = new TransportLocal(src, uriOf(dst), dst.getDirectory()) {
193 @Override
194 ReceivePack createReceivePack(final Repository db) {
195 db.close();
196 dst.incrementOpen();
197
198 final ReceivePack rp = super.createReceivePack(dst);
199 rp.setCheckReceivedObjects(true);
200 rp.setCheckReferencedObjectsAreReachable(true);
201 rp.setAdvertiseRefsHook(new HidePrivateHook());
202 return rp;
203 }
204 };
205 RemoteRefUpdate u = new RemoteRefUpdate(
206 src,
207 R_MASTER,
208 R_MASTER,
209 false,
210 null,
211 null
212 );
213 PushResult r;
214 try {
215 t.setPushThin(true);
216 r = t.push(PM, Collections.singleton(u));
217 } finally {
218 t.close();
219 }
220
221 assertNotNull("have result", r);
222 assertNull("private not advertised", r.getAdvertisedRef(R_PRIVATE));
223 assertSame("master updated", RemoteRefUpdate.Status.OK, u.getStatus());
224 assertEquals(N, dst.resolve(R_MASTER));
225 }
226
227 @Test
228 public void testCreateBranchAtHiddenCommitFails() throws Exception {
229 final TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(64);
230 packHeader(pack, 0);
231 digest(pack);
232
233 final TemporaryBuffer.Heap inBuf = new TemporaryBuffer.Heap(256);
234 final PacketLineOut inPckLine = new PacketLineOut(inBuf);
235 inPckLine.writeString(ObjectId.zeroId().name() + ' ' + P.name() + ' '
236 + "refs/heads/s" + '\0'
237 + BasePackPushConnection.CAPABILITY_REPORT_STATUS);
238 inPckLine.end();
239 pack.writeTo(inBuf, PM);
240
241 final TemporaryBuffer.Heap outBuf = new TemporaryBuffer.Heap(1024);
242 final ReceivePack rp = new ReceivePack(dst);
243 rp.setCheckReceivedObjects(true);
244 rp.setCheckReferencedObjectsAreReachable(true);
245 rp.setAdvertiseRefsHook(new HidePrivateHook());
246 try {
247 receive(rp, inBuf, outBuf);
248 fail("Expected UnpackException");
249 } catch (UnpackException failed) {
250 Throwable err = failed.getCause();
251 assertTrue(err instanceof MissingObjectException);
252 MissingObjectException moe = (MissingObjectException) err;
253 assertEquals(P, moe.getObjectId());
254 }
255
256 final PacketLineIn r = asPacketLineIn(outBuf);
257 String master = r.readString();
258 int nul = master.indexOf('\0');
259 assertTrue("has capability list", nul > 0);
260 assertEquals(B.name() + ' ' + R_MASTER, master.substring(0, nul));
261 assertSame(PacketLineIn.END, r.readString());
262
263 assertEquals("unpack error Missing commit " + P.name(), r.readString());
264 assertEquals("ng refs/heads/s n/a (unpacker error)", r.readString());
265 assertSame(PacketLineIn.END, r.readString());
266 }
267
268 private static void receive(final ReceivePack rp,
269 final TemporaryBuffer.Heap inBuf, final TemporaryBuffer.Heap outBuf)
270 throws IOException {
271 rp.receive(new ByteArrayInputStream(inBuf.toByteArray()), outBuf, null);
272 }
273
274 @Test
275 public void testUsingHiddenDeltaBaseFails() throws Exception {
276 byte[] delta = { 0x1, 0x1, 0x1, 'c' };
277 TestRepository<Repository> s = new TestRepository<>(src);
278 RevCommit N = s.commit().parent(B).add("q",
279 s.blob(BinaryDelta.apply(dst.open(b).getCachedBytes(), delta)))
280 .create();
281
282 final TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(1024);
283 packHeader(pack, 3);
284 copy(pack, src.open(N));
285 copy(pack, src.open(s.parseBody(N).getTree()));
286 pack.write((Constants.OBJ_REF_DELTA) << 4 | 4);
287 b.copyRawTo(pack);
288 deflate(pack, delta);
289 digest(pack);
290
291 final TemporaryBuffer.Heap inBuf = new TemporaryBuffer.Heap(1024);
292 final PacketLineOut inPckLine = new PacketLineOut(inBuf);
293 inPckLine.writeString(ObjectId.zeroId().name() + ' ' + N.name() + ' '
294 + "refs/heads/s" + '\0'
295 + BasePackPushConnection.CAPABILITY_REPORT_STATUS);
296 inPckLine.end();
297 pack.writeTo(inBuf, PM);
298
299 final TemporaryBuffer.Heap outBuf = new TemporaryBuffer.Heap(1024);
300 final ReceivePack rp = new ReceivePack(dst);
301 rp.setCheckReceivedObjects(true);
302 rp.setCheckReferencedObjectsAreReachable(true);
303 rp.setAdvertiseRefsHook(new HidePrivateHook());
304 try {
305 receive(rp, inBuf, outBuf);
306 fail("Expected UnpackException");
307 } catch (UnpackException failed) {
308 Throwable err = failed.getCause();
309 assertTrue(err instanceof MissingObjectException);
310 MissingObjectException moe = (MissingObjectException) err;
311 assertEquals(b, moe.getObjectId());
312 }
313
314 final PacketLineIn r = asPacketLineIn(outBuf);
315 String master = r.readString();
316 int nul = master.indexOf('\0');
317 assertTrue("has capability list", nul > 0);
318 assertEquals(B.name() + ' ' + R_MASTER, master.substring(0, nul));
319 assertSame(PacketLineIn.END, r.readString());
320
321 assertEquals("unpack error Missing blob " + b.name(), r.readString());
322 assertEquals("ng refs/heads/s n/a (unpacker error)", r.readString());
323 assertSame(PacketLineIn.END, r.readString());
324 }
325
326 @Test
327 public void testUsingHiddenCommonBlobFails() throws Exception {
328
329
330 TestRepository<Repository> s = new TestRepository<>(src);
331 RevCommit N = s.commit().parent(B).add("q", s.blob("b")).create();
332
333
334
335 final TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(1024);
336 packHeader(pack, 2);
337 copy(pack, src.open(N));
338 copy(pack,src.open(s.parseBody(N).getTree()));
339 digest(pack);
340
341 final TemporaryBuffer.Heap inBuf = new TemporaryBuffer.Heap(1024);
342 final PacketLineOut inPckLine = new PacketLineOut(inBuf);
343 inPckLine.writeString(ObjectId.zeroId().name() + ' ' + N.name() + ' '
344 + "refs/heads/s" + '\0'
345 + BasePackPushConnection.CAPABILITY_REPORT_STATUS);
346 inPckLine.end();
347 pack.writeTo(inBuf, PM);
348
349 final TemporaryBuffer.Heap outBuf = new TemporaryBuffer.Heap(1024);
350 final ReceivePack rp = new ReceivePack(dst);
351 rp.setCheckReceivedObjects(true);
352 rp.setCheckReferencedObjectsAreReachable(true);
353 rp.setAdvertiseRefsHook(new HidePrivateHook());
354 try {
355 receive(rp, inBuf, outBuf);
356 fail("Expected UnpackException");
357 } catch (UnpackException failed) {
358 Throwable err = failed.getCause();
359 assertTrue(err instanceof MissingObjectException);
360 MissingObjectException moe = (MissingObjectException) err;
361 assertEquals(b, moe.getObjectId());
362 }
363
364 final PacketLineIn r = asPacketLineIn(outBuf);
365 String master = r.readString();
366 int nul = master.indexOf('\0');
367 assertTrue("has capability list", nul > 0);
368 assertEquals(B.name() + ' ' + R_MASTER, master.substring(0, nul));
369 assertSame(PacketLineIn.END, r.readString());
370
371 assertEquals("unpack error Missing blob " + b.name(), r.readString());
372 assertEquals("ng refs/heads/s n/a (unpacker error)", r.readString());
373 assertSame(PacketLineIn.END, r.readString());
374 }
375
376 @Test
377 public void testUsingUnknownBlobFails() throws Exception {
378
379
380 TestRepository<Repository> s = new TestRepository<>(src);
381 RevBlob n = s.blob("n");
382 RevCommit N = s.commit().parent(B).add("q", n).create();
383
384
385
386 final TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(1024);
387 packHeader(pack, 2);
388 copy(pack, src.open(N));
389 copy(pack,src.open(s.parseBody(N).getTree()));
390 digest(pack);
391
392 final TemporaryBuffer.Heap inBuf = new TemporaryBuffer.Heap(1024);
393 final PacketLineOut inPckLine = new PacketLineOut(inBuf);
394 inPckLine.writeString(ObjectId.zeroId().name() + ' ' + N.name() + ' '
395 + "refs/heads/s" + '\0'
396 + BasePackPushConnection.CAPABILITY_REPORT_STATUS);
397 inPckLine.end();
398 pack.writeTo(inBuf, PM);
399
400 final TemporaryBuffer.Heap outBuf = new TemporaryBuffer.Heap(1024);
401 final ReceivePack rp = new ReceivePack(dst);
402 rp.setCheckReceivedObjects(true);
403 rp.setCheckReferencedObjectsAreReachable(true);
404 rp.setAdvertiseRefsHook(new HidePrivateHook());
405 try {
406 receive(rp, inBuf, outBuf);
407 fail("Expected UnpackException");
408 } catch (UnpackException failed) {
409 Throwable err = failed.getCause();
410 assertTrue(err instanceof MissingObjectException);
411 MissingObjectException moe = (MissingObjectException) err;
412 assertEquals(n, moe.getObjectId());
413 }
414
415 final PacketLineIn r = asPacketLineIn(outBuf);
416 String master = r.readString();
417 int nul = master.indexOf('\0');
418 assertTrue("has capability list", nul > 0);
419 assertEquals(B.name() + ' ' + R_MASTER, master.substring(0, nul));
420 assertSame(PacketLineIn.END, r.readString());
421
422 assertEquals("unpack error Missing blob " + n.name(), r.readString());
423 assertEquals("ng refs/heads/s n/a (unpacker error)", r.readString());
424 assertSame(PacketLineIn.END, r.readString());
425 }
426
427 @Test
428 public void testUsingUnknownTreeFails() throws Exception {
429 TestRepository<Repository> s = new TestRepository<>(src);
430 RevCommit N = s.commit().parent(B).add("q", s.blob("a")).create();
431 RevTree t = s.parseBody(N).getTree();
432
433
434
435 final TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(1024);
436 packHeader(pack, 1);
437 copy(pack, src.open(N));
438 digest(pack);
439
440 final TemporaryBuffer.Heap inBuf = new TemporaryBuffer.Heap(1024);
441 final PacketLineOut inPckLine = new PacketLineOut(inBuf);
442 inPckLine.writeString(ObjectId.zeroId().name() + ' ' + N.name() + ' '
443 + "refs/heads/s" + '\0'
444 + BasePackPushConnection.CAPABILITY_REPORT_STATUS);
445 inPckLine.end();
446 pack.writeTo(inBuf, PM);
447
448 final TemporaryBuffer.Heap outBuf = new TemporaryBuffer.Heap(1024);
449 final ReceivePack rp = new ReceivePack(dst);
450 rp.setCheckReceivedObjects(true);
451 rp.setCheckReferencedObjectsAreReachable(true);
452 rp.setAdvertiseRefsHook(new HidePrivateHook());
453 try {
454 receive(rp, inBuf, outBuf);
455 fail("Expected UnpackException");
456 } catch (UnpackException failed) {
457 Throwable err = failed.getCause();
458 assertTrue(err instanceof MissingObjectException);
459 MissingObjectException moe = (MissingObjectException) err;
460 assertEquals(t, moe.getObjectId());
461 }
462
463 final PacketLineIn r = asPacketLineIn(outBuf);
464 String master = r.readString();
465 int nul = master.indexOf('\0');
466 assertTrue("has capability list", nul > 0);
467 assertEquals(B.name() + ' ' + R_MASTER, master.substring(0, nul));
468 assertSame(PacketLineIn.END, r.readString());
469
470 assertEquals("unpack error Missing tree " + t.name(), r.readString());
471 assertEquals("ng refs/heads/s n/a (unpacker error)", r.readString());
472 assertSame(PacketLineIn.END, r.readString());
473 }
474
475 private static void packHeader(TemporaryBuffer.Heap tinyPack, int cnt)
476 throws IOException {
477 final byte[] hdr = new byte[8];
478 NB.encodeInt32(hdr, 0, 2);
479 NB.encodeInt32(hdr, 4, cnt);
480
481 tinyPack.write(Constants.PACK_SIGNATURE);
482 tinyPack.write(hdr, 0, 8);
483 }
484
485 private static void copy(TemporaryBuffer.Heap tinyPack, ObjectLoader ldr)
486 throws IOException {
487 final byte[] buf = new byte[64];
488 final byte[] content = ldr.getCachedBytes();
489 int dataLength = content.length;
490 int nextLength = dataLength >>> 4;
491 int size = 0;
492 buf[size++] = (byte) ((nextLength > 0 ? 0x80 : 0x00)
493 | (ldr.getType() << 4) | (dataLength & 0x0F));
494 dataLength = nextLength;
495 while (dataLength > 0) {
496 nextLength >>>= 7;
497 buf[size++] = (byte) ((nextLength > 0 ? 0x80 : 0x00) | (dataLength & 0x7F));
498 dataLength = nextLength;
499 }
500 tinyPack.write(buf, 0, size);
501 deflate(tinyPack, content);
502 }
503
504 private static void deflate(TemporaryBuffer.Heap tinyPack,
505 final byte[] content)
506 throws IOException {
507 final Deflater deflater = new Deflater();
508 final byte[] buf = new byte[128];
509 deflater.setInput(content, 0, content.length);
510 deflater.finish();
511 do {
512 final int n = deflater.deflate(buf, 0, buf.length);
513 if (n > 0)
514 tinyPack.write(buf, 0, n);
515 } while (!deflater.finished());
516 }
517
518 private static void digest(TemporaryBuffer.Heap buf) throws IOException {
519 MessageDigest md = Constants.newMessageDigest();
520 md.update(buf.toByteArray());
521 buf.write(md.digest());
522 }
523
524 private ObjectInserter inserter;
525
526 @After
527 public void release() {
528 if (inserter != null) {
529 inserter.close();
530 }
531 }
532
533 private void openPack(TemporaryBuffer.Heap buf) throws IOException {
534 if (inserter == null)
535 inserter = src.newObjectInserter();
536
537 final byte[] raw = buf.toByteArray();
538 PackParser p = inserter.newPackParser(new ByteArrayInputStream(raw));
539 p.setAllowThin(true);
540 p.parse(PM);
541 }
542
543 private static PacketLineIn asPacketLineIn(TemporaryBuffer.Heap buf)
544 throws IOException {
545 return new PacketLineIn(new ByteArrayInputStream(buf.toByteArray()));
546 }
547
548 private static final class HidePrivateHook extends AbstractAdvertiseRefsHook {
549 @Override
550 public Map<String, Ref> getAdvertisedRefs(Repository r, RevWalk revWalk) {
551 Map<String, Ref> refs = new HashMap<>(r.getAllRefs());
552 assertNotNull(refs.remove(R_PRIVATE));
553 return refs;
554 }
555 }
556
557 private static URIish uriOf(Repository r) throws URISyntaxException {
558 return new URIish(r.getDirectory().getAbsolutePath());
559 }
560 }