package org.eclipse.jgit.http.server;
+import static org.eclipse.jgit.http.server.ServletUtils.ATTRIBUTE_HANDLER;
+import static org.eclipse.jgit.transport.BasePackFetchConnection.OPTION_SIDE_BAND;
+import static org.eclipse.jgit.transport.BasePackFetchConnection.OPTION_SIDE_BAND_64K;
+import static org.eclipse.jgit.transport.BasePackPushConnection.CAPABILITY_SIDE_BAND_64K;
+import static org.eclipse.jgit.transport.SideBandOutputStream.CH_ERROR;
+import static org.eclipse.jgit.transport.SideBandOutputStream.SMALL_BUF;
import static javax.servlet.http.HttpServletResponse.SC_FORBIDDEN;
import static javax.servlet.http.HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.transport.PacketLineIn;
import org.eclipse.jgit.transport.PacketLineOut;
+import org.eclipse.jgit.transport.ReceivePack;
+import org.eclipse.jgit.transport.RequestNotYetReadException;
+import org.eclipse.jgit.transport.SideBandOutputStream;
+import org.eclipse.jgit.transport.UploadPack;
/**
* Utility functions for handling the Git-over-HTTP protocol.
* to a Git protocol client using an HTTP 200 OK response with the error
* embedded in the payload. If the request was not issued by a Git client,
* an HTTP response code is returned instead.
+ * <p>
+ * This method may only be called before handing off the request to
+ * {@link UploadPack#upload(java.io.InputStream, OutputStream, OutputStream)}
+ * or
+ * {@link ReceivePack#receive(java.io.InputStream, OutputStream, OutputStream)}.
*
* @param req
* current request.
}
}
- ByteArrayOutputStream buf = new ByteArrayOutputStream(128);
- PacketLineOut pck = new PacketLineOut(buf);
-
if (isInfoRefs(req)) {
- String svc = req.getParameter("service");
- pck.writeString("# service=" + svc + "\n");
- pck.end();
- pck.writeString("ERR " + textForGit);
- send(req, res, infoRefsResultType(svc), buf.toByteArray());
+ sendInfoRefsError(req, res, textForGit);
} else if (isUploadPack(req)) {
- pck.writeString("ERR " + textForGit);
- send(req, res, UPLOAD_PACK_RESULT_TYPE, buf.toByteArray());
+ sendUploadPackError(req, res, textForGit);
} else if (isReceivePack(req)) {
- pck.writeString("ERR " + textForGit);
- send(req, res, RECEIVE_PACK_RESULT_TYPE, buf.toByteArray());
+ sendReceivePackError(req, res, textForGit);
} else {
if (httpStatus < 400)
ServletUtils.consumeRequestBody(req);
}
}
+ private static void sendInfoRefsError(HttpServletRequest req,
+ HttpServletResponse res, String textForGit) throws IOException {
+ ByteArrayOutputStream buf = new ByteArrayOutputStream(128);
+ PacketLineOut pck = new PacketLineOut(buf);
+ String svc = req.getParameter("service");
+ pck.writeString("# service=" + svc + "\n");
+ pck.end();
+ pck.writeString("ERR " + textForGit);
+ send(req, res, infoRefsResultType(svc), buf.toByteArray());
+ }
+
+ private static void sendUploadPackError(HttpServletRequest req,
+ HttpServletResponse res, String textForGit) throws IOException {
+ ByteArrayOutputStream buf = new ByteArrayOutputStream(128);
+ PacketLineOut pckOut = new PacketLineOut(buf);
+
+ boolean sideband;
+ UploadPack up = (UploadPack) req.getAttribute(ATTRIBUTE_HANDLER);
+ if (up != null) {
+ try {
+ sideband = up.isSideBand();
+ } catch (RequestNotYetReadException e) {
+ sideband = isUploadPackSideBand(req);
+ }
+ } else
+ sideband = isUploadPackSideBand(req);
+
+ if (sideband)
+ writeSideBand(buf, textForGit);
+ else
+ writePacket(pckOut, textForGit);
+ send(req, res, UPLOAD_PACK_RESULT_TYPE, buf.toByteArray());
+ }
+
+ private static boolean isUploadPackSideBand(HttpServletRequest req) {
+ try {
+ // The client may be in a state where they have sent the sideband
+ // capability and are expecting a response in the sideband, but we might
+ // not have an UploadPack, or it might not have read any of the request.
+ // So, cheat and read the first line.
+ String line = new PacketLineIn(req.getInputStream()).readStringRaw();
+ UploadPack.FirstLine parsed = new UploadPack.FirstLine(line);
+ return (parsed.getOptions().contains(OPTION_SIDE_BAND)
+ || parsed.getOptions().contains(OPTION_SIDE_BAND_64K));
+ } catch (IOException e) {
+ // Probably the connection is closed and a subsequent write will fail, but
+ // try it just in case.
+ return false;
+ }
+ }
+
+ private static void sendReceivePackError(HttpServletRequest req,
+ HttpServletResponse res, String textForGit) throws IOException {
+ ByteArrayOutputStream buf = new ByteArrayOutputStream(128);
+ PacketLineOut pckOut = new PacketLineOut(buf);
+
+ boolean sideband;
+ ReceivePack rp = (ReceivePack) req.getAttribute(ATTRIBUTE_HANDLER);
+ if (rp != null) {
+ try {
+ sideband = rp.isSideBand();
+ } catch (RequestNotYetReadException e) {
+ sideband = isReceivePackSideBand(req);
+ }
+ } else
+ sideband = isReceivePackSideBand(req);
+
+ if (sideband)
+ writeSideBand(buf, textForGit);
+ else
+ writePacket(pckOut, textForGit);
+ send(req, res, RECEIVE_PACK_RESULT_TYPE, buf.toByteArray());
+ }
+
+ private static boolean isReceivePackSideBand(HttpServletRequest req) {
+ try {
+ // The client may be in a state where they have sent the sideband
+ // capability and are expecting a response in the sideband, but we might
+ // not have a ReceivePack, or it might not have read any of the request.
+ // So, cheat and read the first line.
+ String line = new PacketLineIn(req.getInputStream()).readStringRaw();
+ ReceivePack.FirstLine parsed = new ReceivePack.FirstLine(line);
+ return parsed.getCapabilities().contains(CAPABILITY_SIDE_BAND_64K);
+ } catch (IOException e) {
+ // Probably the connection is closed and a subsequent write will fail, but
+ // try it just in case.
+ return false;
+ }
+ }
+
+ private static void writeSideBand(OutputStream out, String textForGit)
+ throws IOException {
+ OutputStream msg = new SideBandOutputStream(CH_ERROR, SMALL_BUF, out);
+ msg.write(Constants.encode("error: " + textForGit));
+ msg.flush();
+ }
+
+ private static void writePacket(PacketLineOut pckOut, String textForGit)
+ throws IOException {
+ pckOut.writeString("error: " + textForGit);
+ }
+
private static void send(HttpServletRequest req, HttpServletResponse res,
String type, byte[] buf) throws IOException {
ServletUtils.consumeRequestBody(req);
--- /dev/null
+/*
+ * Copyright (C) 2012, Google Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.eclipse.jgit.transport;
+
+/** Indicates that a client request has not yet been read from the wire. */
+public class RequestNotYetReadException extends IllegalStateException {
+ private static final long serialVersionUID = 1L;
+
+ /** Initialize with no message. */
+ public RequestNotYetReadException() {
+ // Do not set a message.
+ }
+
+ /**
+ * @param msg
+ * a message explaining the state. This message should not
+ * be shown to an end-user.
+ */
+ public RequestNotYetReadException(String msg) {
+ super(msg);
+ }
+}
* This stream is buffered at packet sizes, so the caller doesn't need to wrap
* it in yet another buffered stream.
*/
-class SideBandOutputStream extends OutputStream {
- static final int CH_DATA = SideBandInputStream.CH_DATA;
+public class SideBandOutputStream extends OutputStream {
+ /** Channel used for pack data. */
+ public static final int CH_DATA = SideBandInputStream.CH_DATA;
- static final int CH_PROGRESS = SideBandInputStream.CH_PROGRESS;
+ /** Channel used for progress messages. */
+ public static final int CH_PROGRESS = SideBandInputStream.CH_PROGRESS;
- static final int CH_ERROR = SideBandInputStream.CH_ERROR;
+ /** Channel used for error messages. */
+ public static final int CH_ERROR = SideBandInputStream.CH_ERROR;
- static final int SMALL_BUF = 1000;
+ /** Default buffer size for a small amount of data. */
+ public static final int SMALL_BUF = 1000;
- static final int MAX_BUF = 65520;
+ /** Maximum buffer size for a single packet of sideband data. */
+ public static final int MAX_BUF = 65520;
static final int HDR_SIZE = 5;
* stream that the packets are written onto. This stream should
* be attached to a SideBandInputStream on the remote side.
*/
- SideBandOutputStream(final int chan, final int sz, final OutputStream os) {
+ public SideBandOutputStream(final int chan, final int sz, final OutputStream os) {
if (chan <= 0 || chan > 255)
throw new IllegalArgumentException(MessageFormat.format(JGitText.get().channelMustBeInRange0_255, chan));
if (sz <= HDR_SIZE)