ReceivePack.java

  1. /*
  2.  * Copyright (C) 2008-2010, Google Inc. and others
  3.  *
  4.  * This program and the accompanying materials are made available under the
  5.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  6.  * https://www.eclipse.org/org/documents/edl-v10.php.
  7.  *
  8.  * SPDX-License-Identifier: BSD-3-Clause
  9.  */

  11. package org.eclipse.jgit.transport;

  13. import static java.nio.charset.StandardCharsets.UTF_8;
  14. import static org.eclipse.jgit.lib.Constants.HEAD;
  15. import static org.eclipse.jgit.transport.GitProtocolConstants.CAPABILITY_ATOMIC;
  16. import static org.eclipse.jgit.transport.GitProtocolConstants.CAPABILITY_DELETE_REFS;
  17. import static org.eclipse.jgit.transport.GitProtocolConstants.CAPABILITY_OFS_DELTA;
  18. import static org.eclipse.jgit.transport.GitProtocolConstants.CAPABILITY_PUSH_OPTIONS;
  19. import static org.eclipse.jgit.transport.GitProtocolConstants.CAPABILITY_QUIET;
  20. import static org.eclipse.jgit.transport.GitProtocolConstants.CAPABILITY_REPORT_STATUS;
  21. import static org.eclipse.jgit.transport.GitProtocolConstants.CAPABILITY_SIDE_BAND_64K;
  22. import static org.eclipse.jgit.transport.GitProtocolConstants.OPTION_AGENT;
  23. import static org.eclipse.jgit.transport.GitProtocolConstants.PACKET_ERR;
  24. import static org.eclipse.jgit.transport.GitProtocolConstants.PACKET_SHALLOW;
  25. import static org.eclipse.jgit.transport.GitProtocolConstants.OPTION_SESSION_ID;
  26. import static org.eclipse.jgit.transport.SideBandOutputStream.CH_DATA;
  27. import static org.eclipse.jgit.transport.SideBandOutputStream.CH_ERROR;
  28. import static org.eclipse.jgit.transport.SideBandOutputStream.CH_PROGRESS;
  29. import static org.eclipse.jgit.transport.SideBandOutputStream.MAX_BUF;

  31. import java.io.EOFException;
  32. import java.io.IOException;
  33. import java.io.InputStream;
  34. import java.io.OutputStream;
  35. import java.io.UncheckedIOException;
  36. import java.text.MessageFormat;
  37. import java.util.ArrayList;
  38. import java.util.Collections;
  39. import java.util.HashMap;
  40. import java.util.HashSet;
  41. import java.util.List;
  42. import java.util.Map;
  43. import java.util.Set;
  44. import java.util.concurrent.TimeUnit;
  45. import java.util.function.Function;
  46. import java.util.stream.Collectors;

  48. import org.eclipse.jgit.annotations.Nullable;
  49. import org.eclipse.jgit.errors.InvalidObjectIdException;
  50. import org.eclipse.jgit.errors.LargeObjectException;
  51. import org.eclipse.jgit.errors.PackProtocolException;
  52. import org.eclipse.jgit.errors.TooLargePackException;
  53. import org.eclipse.jgit.errors.UnpackException;
  54. import org.eclipse.jgit.internal.JGitText;
  55. import org.eclipse.jgit.internal.submodule.SubmoduleValidator;
  56. import org.eclipse.jgit.internal.submodule.SubmoduleValidator.SubmoduleValidationException;
  57. import org.eclipse.jgit.internal.transport.connectivity.FullConnectivityChecker;
  58. import org.eclipse.jgit.internal.transport.parser.FirstCommand;
  59. import org.eclipse.jgit.lib.AnyObjectId;
  60. import org.eclipse.jgit.lib.BatchRefUpdate;
  61. import org.eclipse.jgit.lib.Config;
  62. import org.eclipse.jgit.lib.ConfigConstants;
  63. import org.eclipse.jgit.lib.Constants;
  64. import org.eclipse.jgit.lib.GitmoduleEntry;
  65. import org.eclipse.jgit.lib.NullProgressMonitor;
  66. import org.eclipse.jgit.lib.ObjectChecker;
  67. import org.eclipse.jgit.lib.ObjectDatabase;
  68. import org.eclipse.jgit.lib.ObjectId;
  69. import org.eclipse.jgit.lib.ObjectInserter;
  70. import org.eclipse.jgit.lib.ObjectLoader;
  71. import org.eclipse.jgit.lib.PersonIdent;
  72. import org.eclipse.jgit.lib.ProgressMonitor;
  73. import org.eclipse.jgit.lib.Ref;
  74. import org.eclipse.jgit.lib.Repository;
  75. import org.eclipse.jgit.revwalk.RevCommit;
  76. import org.eclipse.jgit.revwalk.RevObject;
  77. import org.eclipse.jgit.revwalk.RevWalk;
  78. import org.eclipse.jgit.transport.ConnectivityChecker.ConnectivityCheckInfo;
  79. import org.eclipse.jgit.transport.PacketLineIn.InputOverLimitIOException;
  80. import org.eclipse.jgit.transport.ReceiveCommand.Result;
  81. import org.eclipse.jgit.transport.RefAdvertiser.PacketLineOutRefAdvertiser;
  82. import org.eclipse.jgit.util.io.InterruptTimer;
  83. import org.eclipse.jgit.util.io.LimitedInputStream;
  84. import org.eclipse.jgit.util.io.TimeoutInputStream;
  85. import org.eclipse.jgit.util.io.TimeoutOutputStream;

  87. /**
  88.  * Implements the server side of a push connection, receiving objects.
  89.  */
  90. public class ReceivePack {
  91.     /**
  92.      * Data in the first line of a request, the line itself plus capabilities.
  93.      *
  94.      * @deprecated Use {@link FirstCommand} instead.
  95.      * @since 5.6
  96.      */
  97.     @Deprecated
  98.     public static class FirstLine {
  99.         private final FirstCommand command;

  101.         /**
  102.          * Parse the first line of a receive-pack request.
  103.          *
  104.          * @param line
  105.          *            line from the client.
  106.          */
  107.         public FirstLine(String line) {
  108.             command = FirstCommand.fromLine(line);
  109.         }

  111.         /** @return non-capabilities part of the line. */
  112.         public String getLine() {
  113.             return command.getLine();
  114.         }

  116.         /** @return capabilities parsed from the line. */
  117.         public Set<String> getCapabilities() {
  118.             Set<String> reconstructedCapabilites = new HashSet<>();
  119.             for (Map.Entry<String, String> e : command.getCapabilities()
  120.                     .entrySet()) {
  121.                 String cap = e.getValue() == null ? e.getKey()
  122.                         : e.getKey() + "=" + e.getValue(); //$NON-NLS-1$
  123.                 reconstructedCapabilites.add(cap);
  124.             }

  126.             return reconstructedCapabilites;
  127.         }
  128.     }

  130.     /** Database we write the stored objects into. */
  131.     private final Repository db;

  133.     /** Revision traversal support over {@link #db}. */
  134.     private final RevWalk walk;

  136.     /**
  137.      * Is the client connection a bi-directional socket or pipe?
  138.      * <p>
  139.      * If true, this class assumes it can perform multiple read and write cycles
  140.      * with the client over the input and output streams. This matches the
  141.      * functionality available with a standard TCP/IP connection, or a local
  142.      * operating system or in-memory pipe.
  143.      * <p>
  144.      * If false, this class runs in a read everything then output results mode,
  145.      * making it suitable for single round-trip systems RPCs such as HTTP.
  146.      */
  147.     private boolean biDirectionalPipe = true;

  149.     /** Expecting data after the pack footer */
  150.     private boolean expectDataAfterPackFooter;

  152.     /** Should an incoming transfer validate objects? */
  153.     private ObjectChecker objectChecker;

  155.     /** Should an incoming transfer permit create requests? */
  156.     private boolean allowCreates;

  158.     /** Should an incoming transfer permit delete requests? */
  159.     private boolean allowAnyDeletes;

  161.     private boolean allowBranchDeletes;

  163.     /** Should an incoming transfer permit non-fast-forward requests? */
  164.     private boolean allowNonFastForwards;

  166.     /** Should an incoming transfer permit push options? **/
  167.     private boolean allowPushOptions;

  169.     /**
  170.      * Should the requested ref updates be performed as a single atomic
  171.      * transaction?
  172.      */
  173.     private boolean atomic;

  175.     private boolean allowOfsDelta;

  177.     private boolean allowQuiet = true;

  179.     /** Should the server advertise and accept the session-id capability. */
  180.     private boolean allowReceiveClientSID;

  182.     /** Identity to record action as within the reflog. */
  183.     private PersonIdent refLogIdent;

  185.     /** Hook used while advertising the refs to the client. */
  186.     private AdvertiseRefsHook advertiseRefsHook;

  188.     /** Filter used while advertising the refs to the client. */
  189.     private RefFilter refFilter;

  191.     /** Timeout in seconds to wait for client interaction. */
  192.     private int timeout;

  194.     /** Timer to manage {@link #timeout}. */
  195.     private InterruptTimer timer;

  197.     private TimeoutInputStream timeoutIn;

  199.     // Original stream passed to init(), since rawOut may be wrapped in a
  200.     // sideband.
  201.     private OutputStream origOut;

  203.     /** Raw input stream. */
  204.     private InputStream rawIn;

  206.     /** Raw output stream. */
  207.     private OutputStream rawOut;

  209.     /** Optional message output stream. */
  210.     private OutputStream msgOut;

  212.     private SideBandOutputStream errOut;

  214.     /** Packet line input stream around {@link #rawIn}. */
  215.     private PacketLineIn pckIn;

  217.     /** Packet line output stream around {@link #rawOut}. */
  218.     private PacketLineOut pckOut;

  220.     private final MessageOutputWrapper msgOutWrapper = new MessageOutputWrapper();

  222.     private PackParser parser;

  224.     /** The refs we advertised as existing at the start of the connection. */
  225.     private Map<String, Ref> refs;

  227.     /** All SHA-1s shown to the client, which can be possible edges. */
  228.     private Set<ObjectId> advertisedHaves;

  230.     /** Capabilities requested by the client. */
  231.     private Map<String, String> enabledCapabilities;

  233.     /** Session ID sent from the client. Null if none was received. */
  234.     private String clientSID;

  236.     String userAgent;

  238.     private Set<ObjectId> clientShallowCommits;

  240.     private List<ReceiveCommand> commands;

  242.     private long maxCommandBytes;

  244.     private long maxDiscardBytes;

  246.     private StringBuilder advertiseError;

  248.     /**
  249.      * If {@link BasePackPushConnection#CAPABILITY_SIDE_BAND_64K} is enabled.
  250.      */
  251.     private boolean sideBand;

  253.     private boolean quiet;

  255.     /** Lock around the received pack file, while updating refs. */
  256.     private PackLock packLock;

  258.     private boolean checkReferencedAreReachable;

  260.     /** Git object size limit */
  261.     private long maxObjectSizeLimit;

  263.     /** Total pack size limit */
  264.     private long maxPackSizeLimit = -1;

  266.     /** The size of the received pack, including index size */
  267.     private Long packSize;

  269.     private PushCertificateParser pushCertificateParser;

  271.     private SignedPushConfig signedPushConfig;

  273.     private PushCertificate pushCert;

  275.     private ReceivedPackStatistics stats;

  277.     /**
  278.      * Connectivity checker to use.
  279.      * @since 5.7
  280.      */
  281.     protected ConnectivityChecker connectivityChecker = new FullConnectivityChecker();

  283.     /** Hook to validate the update commands before execution. */
  284.     private PreReceiveHook preReceive;

  286.     private ReceiveCommandErrorHandler receiveCommandErrorHandler = new ReceiveCommandErrorHandler() {
  287.         // Use the default implementation.
  288.     };

  290.     private UnpackErrorHandler unpackErrorHandler = new DefaultUnpackErrorHandler();

  292.     /** Hook to report on the commands after execution. */
  293.     private PostReceiveHook postReceive;

  295.     /** If {@link BasePackPushConnection#CAPABILITY_REPORT_STATUS} is enabled. */
  296.     private boolean reportStatus;

  298.     /** Whether the client intends to use push options. */
  299.     private boolean usePushOptions;
  300.     private List<String> pushOptions;

  302.     /**
  303.      * Create a new pack receive for an open repository.
  304.      *
  305.      * @param into
  306.      *            the destination repository.
  307.      */
  308.     public ReceivePack(Repository into) {
  309.         db = into;
  310.         walk = new RevWalk(db);
  311.         walk.setRetainBody(false);

  313.         TransferConfig tc = db.getConfig().get(TransferConfig.KEY);
  314.         objectChecker = tc.newReceiveObjectChecker();
  315.         allowReceiveClientSID = tc.isAllowReceiveClientSID();

  317.         ReceiveConfig rc = db.getConfig().get(ReceiveConfig::new);
  318.         allowCreates = rc.allowCreates;
  319.         allowAnyDeletes = true;
  320.         allowBranchDeletes = rc.allowDeletes;
  321.         allowNonFastForwards = rc.allowNonFastForwards;
  322.         allowOfsDelta = rc.allowOfsDelta;
  323.         allowPushOptions = rc.allowPushOptions;
  324.         maxCommandBytes = rc.maxCommandBytes;
  325.         maxDiscardBytes = rc.maxDiscardBytes;
  326.         advertiseRefsHook = AdvertiseRefsHook.DEFAULT;
  327.         refFilter = RefFilter.DEFAULT;
  328.         advertisedHaves = new HashSet<>();
  329.         clientShallowCommits = new HashSet<>();
  330.         signedPushConfig = rc.signedPush;
  331.         preReceive = PreReceiveHook.NULL;
  332.         postReceive = PostReceiveHook.NULL;
  333.     }

  335.     /** Configuration for receive operations. */
  336.     private static class ReceiveConfig {
  337.         final boolean allowCreates;

  339.         final boolean allowDeletes;

  341.         final boolean allowNonFastForwards;

  343.         final boolean allowOfsDelta;

  345.         final boolean allowPushOptions;

  347.         final long maxCommandBytes;

  349.         final long maxDiscardBytes;

  351.         final SignedPushConfig signedPush;

  353.         ReceiveConfig(Config config) {
  354.             allowCreates = true;
  355.             allowDeletes = !config.getBoolean("receive", "denydeletes", false); //$NON-NLS-1$ //$NON-NLS-2$
  356.             allowNonFastForwards = !config.getBoolean("receive", //$NON-NLS-1$
  357.                     "denynonfastforwards", false); //$NON-NLS-1$
  358.             allowOfsDelta = config.getBoolean("repack", "usedeltabaseoffset", //$NON-NLS-1$ //$NON-NLS-2$
  359.                     true);
  360.             allowPushOptions = config.getBoolean("receive", "pushoptions", //$NON-NLS-1$ //$NON-NLS-2$
  361.                     false);
  362.             maxCommandBytes = config.getLong("receive", //$NON-NLS-1$
  363.                     "maxCommandBytes", //$NON-NLS-1$
  364.                     3 << 20);
  365.             maxDiscardBytes = config.getLong("receive", //$NON-NLS-1$
  366.                     "maxCommandDiscardBytes", //$NON-NLS-1$
  367.                     -1);
  368.             signedPush = SignedPushConfig.KEY.parse(config);
  369.         }
  370.     }

  372.     /**
  373.      * Output stream that wraps the current {@link #msgOut}.
  374.      * <p>
  375.      * We don't want to expose {@link #msgOut} directly because it can change
  376.      * several times over the course of a session.
  377.      */
  378.     class MessageOutputWrapper extends OutputStream {
  379.         @Override
  380.         public void write(int ch) {
  381.             if (msgOut != null) {
  382.                 try {
  383.                     msgOut.write(ch);
  384.                 } catch (IOException e) {
  385.                     // Ignore write failures.
  386.                 }
  387.             }
  388.         }

  390.         @Override
  391.         public void write(byte[] b, int off, int len) {
  392.             if (msgOut != null) {
  393.                 try {
  394.                     msgOut.write(b, off, len);
  395.                 } catch (IOException e) {
  396.                     // Ignore write failures.
  397.                 }
  398.             }
  399.         }

  401.         @Override
  402.         public void write(byte[] b) {
  403.             write(b, 0, b.length);
  404.         }

  406.         @Override
  407.         public void flush() {
  408.             if (msgOut != null) {
  409.                 try {
  410.                     msgOut.flush();
  411.                 } catch (IOException e) {
  412.                     // Ignore write failures.
  413.                 }
  414.             }
  415.         }
  416.     }

  418.     /**
  419.      * Get the repository this receive completes into.
  420.      *
  421.      * @return the repository this receive completes into.
  422.      */
  423.     public Repository getRepository() {
  424.         return db;
  425.     }

  427.     /**
  428.      * Get the RevWalk instance used by this connection.
  429.      *
  430.      * @return the RevWalk instance used by this connection.
  431.      */
  432.     public RevWalk getRevWalk() {
  433.         return walk;
  434.     }

  436.     /**
  437.      * Get refs which were advertised to the client.
  438.      *
  439.      * @return all refs which were advertised to the client, or null if
  440.      *         {@link #setAdvertisedRefs(Map, Set)} has not been called yet.
  441.      */
  442.     public Map<String, Ref> getAdvertisedRefs() {
  443.         return refs;
  444.     }

  446.     /**
  447.      * Set the refs advertised by this ReceivePack.
  448.      * <p>
  449.      * Intended to be called from a
  450.      * {@link org.eclipse.jgit.transport.PreReceiveHook}.
  451.      *
  452.      * @param allRefs
  453.      *            explicit set of references to claim as advertised by this
  454.      *            ReceivePack instance. This overrides any references that may
  455.      *            exist in the source repository. The map is passed to the
  456.      *            configured {@link #getRefFilter()}. If null, assumes all refs
  457.      *            were advertised.
  458.      * @param additionalHaves
  459.      *            explicit set of additional haves to claim as advertised. If
  460.      *            null, assumes the default set of additional haves from the
  461.      *            repository.
  462.      * @throws IOException
  463.      */
  464.     public void setAdvertisedRefs(Map<String, Ref> allRefs,
  465.             Set<ObjectId> additionalHaves) throws IOException {
  466.         refs = allRefs != null ? allRefs : getAllRefs();
  467.         refs = refFilter.filter(refs);
  468.         advertisedHaves.clear();

  470.         Ref head = refs.get(HEAD);
  471.         if (head != null && head.isSymbolic()) {
  472.             refs.remove(HEAD);
  473.         }

  475.         for (Ref ref : refs.values()) {
  476.             if (ref.getObjectId() != null) {
  477.                 advertisedHaves.add(ref.getObjectId());
  478.             }
  479.         }
  480.         if (additionalHaves != null) {
  481.             advertisedHaves.addAll(additionalHaves);
  482.         } else {
  483.             advertisedHaves.addAll(db.getAdditionalHaves());
  484.         }
  485.     }

  487.     /**
  488.      * Get objects advertised to the client.
  489.      *
  490.      * @return the set of objects advertised to the as present in this
  491.      *         repository, or null if {@link #setAdvertisedRefs(Map, Set)} has
  492.      *         not been called yet.
  493.      */
  494.     public final Set<ObjectId> getAdvertisedObjects() {
  495.         return advertisedHaves;
  496.     }

  498.     /**
  499.      * Whether this instance will validate all referenced, but not supplied by
  500.      * the client, objects are reachable from another reference.
  501.      *
  502.      * @return true if this instance will validate all referenced, but not
  503.      *         supplied by the client, objects are reachable from another
  504.      *         reference.
  505.      */
  506.     public boolean isCheckReferencedObjectsAreReachable() {
  507.         return checkReferencedAreReachable;
  508.     }

  510.     /**
  511.      * Validate all referenced but not supplied objects are reachable.
  512.      * <p>
  513.      * If enabled, this instance will verify that references to objects not
  514.      * contained within the received pack are already reachable through at least
  515.      * one other reference displayed as part of {@link #getAdvertisedRefs()}.
  516.      * <p>
  517.      * This feature is useful when the application doesn't trust the client to
  518.      * not provide a forged SHA-1 reference to an object, in an attempt to
  519.      * access parts of the DAG that they aren't allowed to see and which have
  520.      * been hidden from them via the configured
  521.      * {@link org.eclipse.jgit.transport.AdvertiseRefsHook} or
  522.      * {@link org.eclipse.jgit.transport.RefFilter}.
  523.      * <p>
  524.      * Enabling this feature may imply at least some, if not all, of the same
  525.      * functionality performed by {@link #setCheckReceivedObjects(boolean)}.
  526.      * Applications are encouraged to enable both features, if desired.
  527.      *
  528.      * @param b
  529.      *            {@code true} to enable the additional check.
  530.      */
  531.     public void setCheckReferencedObjectsAreReachable(boolean b) {
  532.         this.checkReferencedAreReachable = b;
  533.     }

  535.     /**
  536.      * Whether this class expects a bi-directional pipe opened between the
  537.      * client and itself.
  538.      *
  539.      * @return true if this class expects a bi-directional pipe opened between
  540.      *         the client and itself. The default is true.
  541.      */
  542.     public boolean isBiDirectionalPipe() {
  543.         return biDirectionalPipe;
  544.     }

  546.     /**
  547.      * Whether this class will assume the socket is a fully bidirectional pipe
  548.      * between the two peers and takes advantage of that by first transmitting
  549.      * the known refs, then waiting to read commands.
  550.      *
  551.      * @param twoWay
  552.      *            if true, this class will assume the socket is a fully
  553.      *            bidirectional pipe between the two peers and takes advantage
  554.      *            of that by first transmitting the known refs, then waiting to
  555.      *            read commands. If false, this class assumes it must read the
  556.      *            commands before writing output and does not perform the
  557.      *            initial advertising.
  558.      */
  559.     public void setBiDirectionalPipe(boolean twoWay) {
  560.         biDirectionalPipe = twoWay;
  561.     }

  563.     /**
  564.      * Whether there is data expected after the pack footer.
  565.      *
  566.      * @return {@code true} if there is data expected after the pack footer.
  567.      */
  568.     public boolean isExpectDataAfterPackFooter() {
  569.         return expectDataAfterPackFooter;
  570.     }

  572.     /**
  573.      * Whether there is additional data in InputStream after pack.
  574.      *
  575.      * @param e
  576.      *            {@code true} if there is additional data in InputStream after
  577.      *            pack.
  578.      */
  579.     public void setExpectDataAfterPackFooter(boolean e) {
  580.         expectDataAfterPackFooter = e;
  581.     }

  583.     /**
  584.      * Whether this instance will verify received objects are formatted
  585.      * correctly.
  586.      *
  587.      * @return {@code true} if this instance will verify received objects are
  588.      *         formatted correctly. Validating objects requires more CPU time on
  589.      *         this side of the connection.
  590.      */
  591.     public boolean isCheckReceivedObjects() {
  592.         return objectChecker != null;
  593.     }

  595.     /**
  596.      * Whether to enable checking received objects
  597.      *
  598.      * @param check
  599.      *            {@code true} to enable checking received objects; false to
  600.      *            assume all received objects are valid.
  601.      * @see #setObjectChecker(ObjectChecker)
  602.      */
  603.     public void setCheckReceivedObjects(boolean check) {
  604.         if (check && objectChecker == null)
  605.             setObjectChecker(new ObjectChecker());
  606.         else if (!check && objectChecker != null)
  607.             setObjectChecker(null);
  608.     }

  610.     /**
  611.      * Set the object checking instance to verify each received object with
  612.      *
  613.      * @param impl
  614.      *            if non-null the object checking instance to verify each
  615.      *            received object with; null to disable object checking.
  616.      * @since 3.4
  617.      */
  618.     public void setObjectChecker(ObjectChecker impl) {
  619.         objectChecker = impl;
  620.     }

  622.     /**
  623.      * Whether the client can request refs to be created.
  624.      *
  625.      * @return {@code true} if the client can request refs to be created.
  626.      */
  627.     public boolean isAllowCreates() {
  628.         return allowCreates;
  629.     }

  631.     /**
  632.      * Whether to permit create ref commands to be processed.
  633.      *
  634.      * @param canCreate
  635.      *            {@code true} to permit create ref commands to be processed.
  636.      */
  637.     public void setAllowCreates(boolean canCreate) {
  638.         allowCreates = canCreate;
  639.     }

  641.     /**
  642.      * Whether the client can request refs to be deleted.
  643.      *
  644.      * @return {@code true} if the client can request refs to be deleted.
  645.      */
  646.     public boolean isAllowDeletes() {
  647.         return allowAnyDeletes;
  648.     }

  650.     /**
  651.      * Whether to permit delete ref commands to be processed.
  652.      *
  653.      * @param canDelete
  654.      *            {@code true} to permit delete ref commands to be processed.
  655.      */
  656.     public void setAllowDeletes(boolean canDelete) {
  657.         allowAnyDeletes = canDelete;
  658.     }

  660.     /**
  661.      * Whether the client can delete from {@code refs/heads/}.
  662.      *
  663.      * @return {@code true} if the client can delete from {@code refs/heads/}.
  664.      * @since 3.6
  665.      */
  666.     public boolean isAllowBranchDeletes() {
  667.         return allowBranchDeletes;
  668.     }

  670.     /**
  671.      * Configure whether to permit deletion of branches from the
  672.      * {@code refs/heads/} namespace.
  673.      *
  674.      * @param canDelete
  675.      *            {@code true} to permit deletion of branches from the
  676.      *            {@code refs/heads/} namespace.
  677.      * @since 3.6
  678.      */
  679.     public void setAllowBranchDeletes(boolean canDelete) {
  680.         allowBranchDeletes = canDelete;
  681.     }

  683.     /**
  684.      * Whether the client can request non-fast-forward updates of a ref,
  685.      * possibly making objects unreachable.
  686.      *
  687.      * @return {@code true} if the client can request non-fast-forward updates
  688.      *         of a ref, possibly making objects unreachable.
  689.      */
  690.     public boolean isAllowNonFastForwards() {
  691.         return allowNonFastForwards;
  692.     }

  694.     /**
  695.      * Configure whether to permit the client to ask for non-fast-forward
  696.      * updates of an existing ref.
  697.      *
  698.      * @param canRewind
  699.      *            {@code true} to permit the client to ask for non-fast-forward
  700.      *            updates of an existing ref.
  701.      */
  702.     public void setAllowNonFastForwards(boolean canRewind) {
  703.         allowNonFastForwards = canRewind;
  704.     }

  706.     /**
  707.      * Whether the client's commands should be performed as a single atomic
  708.      * transaction.
  709.      *
  710.      * @return {@code true} if the client's commands should be performed as a
  711.      *         single atomic transaction.
  712.      * @since 4.4
  713.      */
  714.     public boolean isAtomic() {
  715.         return atomic;
  716.     }

  718.     /**
  719.      * Configure whether to perform the client's commands as a single atomic
  720.      * transaction.
  721.      *
  722.      * @param atomic
  723.      *            {@code true} to perform the client's commands as a single
  724.      *            atomic transaction.
  725.      * @since 4.4
  726.      */
  727.     public void setAtomic(boolean atomic) {
  728.         this.atomic = atomic;
  729.     }

  731.     /**
  732.      * Get identity of the user making the changes in the reflog.
  733.      *
  734.      * @return identity of the user making the changes in the reflog.
  735.      */
  736.     public PersonIdent getRefLogIdent() {
  737.         return refLogIdent;
  738.     }

  740.     /**
  741.      * Set the identity of the user appearing in the affected reflogs.
  742.      * <p>
  743.      * The timestamp portion of the identity is ignored. A new identity with the
  744.      * current timestamp will be created automatically when the updates occur
  745.      * and the log records are written.
  746.      *
  747.      * @param pi
  748.      *            identity of the user. If null the identity will be
  749.      *            automatically determined based on the repository
  750.      *            configuration.
  751.      */
  752.     public void setRefLogIdent(PersonIdent pi) {
  753.         refLogIdent = pi;
  754.     }

  756.     /**
  757.      * Get the hook used while advertising the refs to the client
  758.      *
  759.      * @return the hook used while advertising the refs to the client
  760.      */
  761.     public AdvertiseRefsHook getAdvertiseRefsHook() {
  762.         return advertiseRefsHook;
  763.     }

  765.     /**
  766.      * Get the filter used while advertising the refs to the client
  767.      *
  768.      * @return the filter used while advertising the refs to the client
  769.      */
  770.     public RefFilter getRefFilter() {
  771.         return refFilter;
  772.     }

  774.     /**
  775.      * Set the hook used while advertising the refs to the client.
  776.      * <p>
  777.      * If the {@link org.eclipse.jgit.transport.AdvertiseRefsHook} chooses to
  778.      * call {@link #setAdvertisedRefs(Map,Set)}, only refs set by this hook
  779.      * <em>and</em> selected by the {@link org.eclipse.jgit.transport.RefFilter}
  780.      * will be shown to the client. Clients may still attempt to create or
  781.      * update a reference not advertised by the configured
  782.      * {@link org.eclipse.jgit.transport.AdvertiseRefsHook}. These attempts
  783.      * should be rejected by a matching
  784.      * {@link org.eclipse.jgit.transport.PreReceiveHook}.
  785.      *
  786.      * @param advertiseRefsHook
  787.      *            the hook; may be null to show all refs.
  788.      */
  789.     public void setAdvertiseRefsHook(AdvertiseRefsHook advertiseRefsHook) {
  790.         if (advertiseRefsHook != null)
  791.             this.advertiseRefsHook = advertiseRefsHook;
  792.         else
  793.             this.advertiseRefsHook = AdvertiseRefsHook.DEFAULT;
  794.     }

  796.     /**
  797.      * Set the filter used while advertising the refs to the client.
  798.      * <p>
  799.      * Only refs allowed by this filter will be shown to the client. The filter
  800.      * is run against the refs specified by the
  801.      * {@link org.eclipse.jgit.transport.AdvertiseRefsHook} (if applicable).
  802.      *
  803.      * @param refFilter
  804.      *            the filter; may be null to show all refs.
  805.      */
  806.     public void setRefFilter(RefFilter refFilter) {
  807.         this.refFilter = refFilter != null ? refFilter : RefFilter.DEFAULT;
  808.     }

  810.     /**
  811.      * Get timeout (in seconds) before aborting an IO operation.
  812.      *
  813.      * @return timeout (in seconds) before aborting an IO operation.
  814.      */
  815.     public int getTimeout() {
  816.         return timeout;
  817.     }

  819.     /**
  820.      * Set the timeout before willing to abort an IO call.
  821.      *
  822.      * @param seconds
  823.      *            number of seconds to wait (with no data transfer occurring)
  824.      *            before aborting an IO read or write operation with the
  825.      *            connected client.
  826.      */
  827.     public void setTimeout(int seconds) {
  828.         timeout = seconds;
  829.     }

  831.     /**
  832.      * Set the maximum number of command bytes to read from the client.
  833.      *
  834.      * @param limit
  835.      *            command limit in bytes; if 0 there is no limit.
  836.      * @since 4.7
  837.      */
  838.     public void setMaxCommandBytes(long limit) {
  839.         maxCommandBytes = limit;
  840.     }

  842.     /**
  843.      * Set the maximum number of command bytes to discard from the client.
  844.      * <p>
  845.      * Discarding remaining bytes allows this instance to consume the rest of
  846.      * the command block and send a human readable over-limit error via the
  847.      * side-band channel. If the client sends an excessive number of bytes this
  848.      * limit kicks in and the instance disconnects, resulting in a non-specific
  849.      * 'pipe closed', 'end of stream', or similar generic error at the client.
  850.      * <p>
  851.      * When the limit is set to {@code -1} the implementation will default to
  852.      * the larger of {@code 3 * maxCommandBytes} or {@code 3 MiB}.
  853.      *
  854.      * @param limit
  855.      *            discard limit in bytes; if 0 there is no limit; if -1 the
  856.      *            implementation tries to set a reasonable default.
  857.      * @since 4.7
  858.      */
  859.     public void setMaxCommandDiscardBytes(long limit) {
  860.         maxDiscardBytes = limit;
  861.     }

  863.     /**
  864.      * Set the maximum allowed Git object size.
  865.      * <p>
  866.      * If an object is larger than the given size the pack-parsing will throw an
  867.      * exception aborting the receive-pack operation.
  868.      *
  869.      * @param limit
  870.      *            the Git object size limit. If zero then there is not limit.
  871.      */
  872.     public void setMaxObjectSizeLimit(long limit) {
  873.         maxObjectSizeLimit = limit;
  874.     }

  876.     /**
  877.      * Set the maximum allowed pack size.
  878.      * <p>
  879.      * A pack exceeding this size will be rejected.
  880.      *
  881.      * @param limit
  882.      *            the pack size limit, in bytes
  883.      * @since 3.3
  884.      */
  885.     public void setMaxPackSizeLimit(long limit) {
  886.         if (limit < 0)
  887.             throw new IllegalArgumentException(
  888.                     MessageFormat.format(JGitText.get().receivePackInvalidLimit,
  889.                             Long.valueOf(limit)));
  890.         maxPackSizeLimit = limit;
  891.     }

  893.     /**
  894.      * Check whether the client expects a side-band stream.
  895.      *
  896.      * @return true if the client has advertised a side-band capability, false
  897.      *         otherwise.
  898.      * @throws org.eclipse.jgit.transport.RequestNotYetReadException
  899.      *             if the client's request has not yet been read from the wire,
  900.      *             so we do not know if they expect side-band. Note that the
  901.      *             client may have already written the request, it just has not
  902.      *             been read.
  903.      */
  904.     public boolean isSideBand() throws RequestNotYetReadException {
  905.         checkRequestWasRead();
  906.         return enabledCapabilities.containsKey(CAPABILITY_SIDE_BAND_64K);
  907.     }

  909.     /**
  910.      * Whether clients may request avoiding noisy progress messages.
  911.      *
  912.      * @return true if clients may request avoiding noisy progress messages.
  913.      * @since 4.0
  914.      */
  915.     public boolean isAllowQuiet() {
  916.         return allowQuiet;
  917.     }

  919.     /**
  920.      * Configure if clients may request the server skip noisy messages.
  921.      *
  922.      * @param allow
  923.      *            true to allow clients to request quiet behavior; false to
  924.      *            refuse quiet behavior and send messages anyway. This may be
  925.      *            necessary if processing is slow and the client-server network
  926.      *            connection can timeout.
  927.      * @since 4.0
  928.      */
  929.     public void setAllowQuiet(boolean allow) {
  930.         allowQuiet = allow;
  931.     }

  933.     /**
  934.      * Whether the server supports receiving push options.
  935.      *
  936.      * @return true if the server supports receiving push options.
  937.      * @since 4.5
  938.      */
  939.     public boolean isAllowPushOptions() {
  940.         return allowPushOptions;
  941.     }

  943.     /**
  944.      * Configure if the server supports receiving push options.
  945.      *
  946.      * @param allow
  947.      *            true to optionally accept option strings from the client.
  948.      * @since 4.5
  949.      */
  950.     public void setAllowPushOptions(boolean allow) {
  951.         allowPushOptions = allow;
  952.     }

  954.     /**
  955.      * True if the client wants less verbose output.
  956.      *
  957.      * @return true if the client has requested the server to be less verbose.
  958.      * @throws org.eclipse.jgit.transport.RequestNotYetReadException
  959.      *             if the client's request has not yet been read from the wire,
  960.      *             so we do not know if they expect side-band. Note that the
  961.      *             client may have already written the request, it just has not
  962.      *             been read.
  963.      * @since 4.0
  964.      */
  965.     public boolean isQuiet() throws RequestNotYetReadException {
  966.         checkRequestWasRead();
  967.         return quiet;
  968.     }

  970.     /**
  971.      * Set the configuration for push certificate verification.
  972.      *
  973.      * @param cfg
  974.      *            new configuration; if this object is null or its
  975.      *            {@link SignedPushConfig#getCertNonceSeed()} is null, push
  976.      *            certificate verification will be disabled.
  977.      * @since 4.1
  978.      */
  979.     public void setSignedPushConfig(SignedPushConfig cfg) {
  980.         signedPushConfig = cfg;
  981.     }

  983.     private PushCertificateParser getPushCertificateParser() {
  984.         if (pushCertificateParser == null) {
  985.             pushCertificateParser = new PushCertificateParser(db,
  986.                     signedPushConfig);
  987.         }
  988.         return pushCertificateParser;
  989.     }

  991.     /**
  992.      * Get the user agent of the client.
  993.      * <p>
  994.      * If the client is new enough to use {@code agent=} capability that value
  995.      * will be returned. Older HTTP clients may also supply their version using
  996.      * the HTTP {@code User-Agent} header. The capability overrides the HTTP
  997.      * header if both are available.
  998.      * <p>
  999.      * When an HTTP request has been received this method returns the HTTP
  1000.      * {@code User-Agent} header value until capabilities have been parsed.
  1001.      *
  1002.      * @return user agent supplied by the client. Available only if the client
  1003.      *         is new enough to advertise its user agent.
  1004.      * @since 4.0
  1005.      */
  1006.     public String getPeerUserAgent() {
  1007.         if (enabledCapabilities == null || enabledCapabilities.isEmpty()) {
  1008.             return userAgent;
  1009.         }

  1011.         return enabledCapabilities.getOrDefault(OPTION_AGENT, userAgent);
  1012.     }

  1014.     /**
  1015.      * Get all of the command received by the current request.
  1016.      *
  1017.      * @return all of the command received by the current request.
  1018.      */
  1019.     public List<ReceiveCommand> getAllCommands() {
  1020.         return Collections.unmodifiableList(commands);
  1021.     }

  1023.     /**
  1024.      * Set an error handler for {@link ReceiveCommand}.
  1025.      *
  1026.      * @param receiveCommandErrorHandler
  1027.      * @since 5.7
  1028.      */
  1029.     public void setReceiveCommandErrorHandler(
  1030.             ReceiveCommandErrorHandler receiveCommandErrorHandler) {
  1031.         this.receiveCommandErrorHandler = receiveCommandErrorHandler;
  1032.     }

  1034.     /**
  1035.      * Send an error message to the client.
  1036.      * <p>
  1037.      * If any error messages are sent before the references are advertised to
  1038.      * the client, the errors will be sent instead of the advertisement and the
  1039.      * receive operation will be aborted. All clients should receive and display
  1040.      * such early stage errors.
  1041.      * <p>
  1042.      * If the reference advertisements have already been sent, messages are sent
  1043.      * in a side channel. If the client doesn't support receiving messages, the
  1044.      * message will be discarded, with no other indication to the caller or to
  1045.      * the client.
  1046.      * <p>
  1047.      * {@link org.eclipse.jgit.transport.PreReceiveHook}s should always try to
  1048.      * use
  1049.      * {@link org.eclipse.jgit.transport.ReceiveCommand#setResult(Result, String)}
  1050.      * with a result status of
  1051.      * {@link org.eclipse.jgit.transport.ReceiveCommand.Result#REJECTED_OTHER_REASON}
  1052.      * to indicate any reasons for rejecting an update. Messages attached to a
  1053.      * command are much more likely to be returned to the client.
  1054.      *
  1055.      * @param what
  1056.      *            string describing the problem identified by the hook. The
  1057.      *            string must not end with an LF, and must not contain an LF.
  1058.      */
  1059.     public void sendError(String what) {
  1060.         if (refs == null) {
  1061.             if (advertiseError == null)
  1062.                 advertiseError = new StringBuilder();
  1063.             advertiseError.append(what).append('\n');
  1064.         } else {
  1065.             msgOutWrapper.write(Constants.encode("error: " + what + "\n")); //$NON-NLS-1$ //$NON-NLS-2$
  1066.         }
  1067.     }

  1069.     private void fatalError(String msg) {
  1070.         if (errOut != null) {
  1071.             try {
  1072.                 errOut.write(Constants.encode(msg));
  1073.                 errOut.flush();
  1074.             } catch (IOException e) {
  1075.                 // Ignore write failures
  1076.             }
  1077.         } else {
  1078.             sendError(msg);
  1079.         }
  1080.     }

  1082.     /**
  1083.      * Send a message to the client, if it supports receiving them.
  1084.      * <p>
  1085.      * If the client doesn't support receiving messages, the message will be
  1086.      * discarded, with no other indication to the caller or to the client.
  1087.      *
  1088.      * @param what
  1089.      *            string describing the problem identified by the hook. The
  1090.      *            string must not end with an LF, and must not contain an LF.
  1091.      */
  1092.     public void sendMessage(String what) {
  1093.         msgOutWrapper.write(Constants.encode(what + "\n")); //$NON-NLS-1$
  1094.     }

  1096.     /**
  1097.      * Get an underlying stream for sending messages to the client.
  1098.      *
  1099.      * @return an underlying stream for sending messages to the client.
  1100.      */
  1101.     public OutputStream getMessageOutputStream() {
  1102.         return msgOutWrapper;
  1103.     }

  1105.     /**
  1106.      * Get whether or not a pack has been received.
  1107.      *
  1108.      * This can be called before calling {@link #getPackSize()} to avoid causing
  1109.      * {@code IllegalStateException} when the pack size was not set because no
  1110.      * pack was received.
  1111.      *
  1112.      * @return true if a pack has been received.
  1113.      * @since 5.6
  1114.      */
  1115.     public boolean hasReceivedPack() {
  1116.         return packSize != null;
  1117.     }

  1119.     /**
  1120.      * Get the size of the received pack file including the index size.
  1121.      *
  1122.      * This can only be called if the pack is already received.
  1123.      *
  1124.      * @return the size of the received pack including index size
  1125.      * @throws java.lang.IllegalStateException
  1126.      *             if called before the pack has been received
  1127.      * @since 3.3
  1128.      */
  1129.     public long getPackSize() {
  1130.         if (packSize != null)
  1131.             return packSize.longValue();
  1132.         throw new IllegalStateException(JGitText.get().packSizeNotSetYet);
  1133.     }

  1135.     /**
  1136.      * Get the commits from the client's shallow file.
  1137.      *
  1138.      * @return if the client is a shallow repository, the list of edge commits
  1139.      *         that define the client's shallow boundary. Empty set if the
  1140.      *         client is earlier than Git 1.9, or is a full clone.
  1141.      */
  1142.     private Set<ObjectId> getClientShallowCommits() {
  1143.         return clientShallowCommits;
  1144.     }

  1146.     /**
  1147.      * Whether any commands to be executed have been read.
  1148.      *
  1149.      * @return {@code true} if any commands to be executed have been read.
  1150.      */
  1151.     private boolean hasCommands() {
  1152.         return !commands.isEmpty();
  1153.     }

  1155.     /**
  1156.      * Whether an error occurred that should be advertised.
  1157.      *
  1158.      * @return true if an error occurred that should be advertised.
  1159.      */
  1160.     private boolean hasError() {
  1161.         return advertiseError != null;
  1162.     }

  1164.     /**
  1165.      * Initialize the instance with the given streams.
  1166.      *
  1167.      * Visible for out-of-tree subclasses (e.g. tests that need to set the
  1168.      * streams without going through the {@link #service()} method).
  1169.      *
  1170.      * @param input
  1171.      *            raw input to read client commands and pack data from. Caller
  1172.      *            must ensure the input is buffered, otherwise read performance
  1173.      *            may suffer.
  1174.      * @param output
  1175.      *            response back to the Git network client. Caller must ensure
  1176.      *            the output is buffered, otherwise write performance may
  1177.      *            suffer.
  1178.      * @param messages
  1179.      *            secondary "notice" channel to send additional messages out
  1180.      *            through. When run over SSH this should be tied back to the
  1181.      *            standard error channel of the command execution. For most
  1182.      *            other network connections this should be null.
  1183.      */
  1184.     protected void init(final InputStream input, final OutputStream output,
  1185.             final OutputStream messages) {
  1186.         origOut = output;
  1187.         rawIn = input;
  1188.         rawOut = output;
  1189.         msgOut = messages;

  1191.         if (timeout > 0) {
  1192.             final Thread caller = Thread.currentThread();
  1193.             timer = new InterruptTimer(caller.getName() + "-Timer"); //$NON-NLS-1$
  1194.             timeoutIn = new TimeoutInputStream(rawIn, timer);
  1195.             TimeoutOutputStream o = new TimeoutOutputStream(rawOut, timer);
  1196.             timeoutIn.setTimeout(timeout * 1000);
  1197.             o.setTimeout(timeout * 1000);
  1198.             rawIn = timeoutIn;
  1199.             rawOut = o;
  1200.         }

  1202.         pckIn = new PacketLineIn(rawIn);
  1203.         pckOut = new PacketLineOut(rawOut);
  1204.         pckOut.setFlushOnEnd(false);

  1206.         enabledCapabilities = new HashMap<>();
  1207.         commands = new ArrayList<>();
  1208.     }

  1210.     /**
  1211.      * Get advertised refs, or the default if not explicitly advertised.
  1212.      *
  1213.      * @return advertised refs, or the default if not explicitly advertised.
  1214.      * @throws IOException
  1215.      */
  1216.     private Map<String, Ref> getAdvertisedOrDefaultRefs() throws IOException {
  1217.         if (refs == null)
  1218.             setAdvertisedRefs(null, null);
  1219.         return refs;
  1220.     }

  1222.     /**
  1223.      * Receive a pack from the stream and check connectivity if necessary.
  1224.      *
  1225.      * Visible for out-of-tree subclasses. Subclasses overriding this method
  1226.      * should invoke this implementation, as it alters the instance state (e.g.
  1227.      * it reads the pack from the input and parses it before running the
  1228.      * connectivity checks).
  1229.      *
  1230.      * @throws java.io.IOException
  1231.      *             an error occurred during unpacking or connectivity checking.
  1232.      * @throws LargeObjectException
  1233.      *             an large object needs to be opened for the check.
  1234.      * @throws SubmoduleValidationException
  1235.      *             fails to validate the submodule.
  1236.      */
  1237.     protected void receivePackAndCheckConnectivity() throws IOException,
  1238.             LargeObjectException, SubmoduleValidationException {
  1239.         receivePack();
  1240.         if (needCheckConnectivity()) {
  1241.             checkSubmodules();
  1242.             checkConnectivity();
  1243.         }
  1244.         parser = null;
  1245.     }

  1247.     /**
  1248.      * Unlock the pack written by this object.
  1249.      *
  1250.      * @throws java.io.IOException
  1251.      *             the pack could not be unlocked.
  1252.      */
  1253.     private void unlockPack() throws IOException {
  1254.         if (packLock != null) {
  1255.             packLock.unlock();
  1256.             packLock = null;
  1257.         }
  1258.     }

  1260.     /**
  1261.      * Generate an advertisement of available refs and capabilities.
  1262.      *
  1263.      * @param adv
  1264.      *            the advertisement formatter.
  1265.      * @throws java.io.IOException
  1266.      *             the formatter failed to write an advertisement.
  1267.      * @throws org.eclipse.jgit.transport.ServiceMayNotContinueException
  1268.      *             the hook denied advertisement.
  1269.      */
  1270.     public void sendAdvertisedRefs(RefAdvertiser adv)
  1271.             throws IOException, ServiceMayNotContinueException {
  1272.         if (advertiseError != null) {
  1273.             adv.writeOne(PACKET_ERR + advertiseError);
  1274.             return;
  1275.         }

  1277.         try {
  1278.             advertiseRefsHook.advertiseRefs(this);
  1279.         } catch (ServiceMayNotContinueException fail) {
  1280.             if (fail.getMessage() != null) {
  1281.                 adv.writeOne(PACKET_ERR + fail.getMessage());
  1282.                 fail.setOutput();
  1283.             }
  1284.             throw fail;
  1285.         }

  1287.         adv.init(db);
  1288.         adv.advertiseCapability(CAPABILITY_SIDE_BAND_64K);
  1289.         adv.advertiseCapability(CAPABILITY_DELETE_REFS);
  1290.         adv.advertiseCapability(CAPABILITY_REPORT_STATUS);
  1291.         if (allowReceiveClientSID) {
  1292.             adv.advertiseCapability(OPTION_SESSION_ID);
  1293.         }
  1294.         if (allowQuiet) {
  1295.             adv.advertiseCapability(CAPABILITY_QUIET);
  1296.         }
  1297.         String nonce = getPushCertificateParser().getAdvertiseNonce();
  1298.         if (nonce != null) {
  1299.             adv.advertiseCapability(nonce);
  1300.         }
  1301.         if (db.getRefDatabase().performsAtomicTransactions()) {
  1302.             adv.advertiseCapability(CAPABILITY_ATOMIC);
  1303.         }
  1304.         if (allowOfsDelta) {
  1305.             adv.advertiseCapability(CAPABILITY_OFS_DELTA);
  1306.         }
  1307.         if (allowPushOptions) {
  1308.             adv.advertiseCapability(CAPABILITY_PUSH_OPTIONS);
  1309.         }
  1310.         adv.advertiseCapability(OPTION_AGENT, UserAgent.get());
  1311.         adv.send(getAdvertisedOrDefaultRefs().values());
  1312.         for (ObjectId obj : advertisedHaves) {
  1313.             adv.advertiseHave(obj);
  1314.         }
  1315.         if (adv.isEmpty()) {
  1316.             adv.advertiseId(ObjectId.zeroId(), "capabilities^{}"); //$NON-NLS-1$
  1317.         }
  1318.         adv.end();
  1319.     }

  1321.     /**
  1322.      * Returns the statistics on the received pack if available. This should be
  1323.      * called after {@link #receivePack} is called.
  1324.      *
  1325.      * @return ReceivedPackStatistics
  1326.      * @since 4.6
  1327.      */
  1328.     @Nullable
  1329.     public ReceivedPackStatistics getReceivedPackStatistics() {
  1330.         return stats;
  1331.     }

  1333.     /**
  1334.      * Extract the full list of refs from the ref-db.
  1335.      *
  1336.      * @return Map of all refname/ref
  1337.      */
  1338.     private Map<String, Ref> getAllRefs() {
  1339.         try {
  1340.             return db.getRefDatabase().getRefs().stream()
  1341.                     .collect(Collectors.toMap(Ref::getName,
  1342.                             Function.identity()));
  1343.         } catch (IOException e) {
  1344.             throw new UncheckedIOException(e);
  1345.         }
  1346.     }

  1348.     /**
  1349.      * Receive a list of commands from the input.
  1350.      *
  1351.      * @throws java.io.IOException
  1352.      */
  1353.     private void recvCommands() throws IOException {
  1354.         PacketLineIn pck = maxCommandBytes > 0
  1355.                 ? new PacketLineIn(rawIn, maxCommandBytes)
  1356.                 : pckIn;
  1357.         PushCertificateParser certParser = getPushCertificateParser();
  1358.         boolean firstPkt = true;
  1359.         try {
  1360.             for (;;) {
  1361.                 String line;
  1362.                 try {
  1363.                     line = pck.readString();
  1364.                 } catch (EOFException eof) {
  1365.                     if (commands.isEmpty())
  1366.                         return;
  1367.                     throw eof;
  1368.                 }
  1369.                 if (PacketLineIn.isEnd(line)) {
  1370.                     break;
  1371.                 }

  1373.                 int len = PACKET_SHALLOW.length() + 40;
  1374.                 if (line.length() >= len && line.startsWith(PACKET_SHALLOW)) {
  1375.                     parseShallow(line.substring(PACKET_SHALLOW.length(), len));
  1376.                     continue;
  1377.                 }

  1379.                 if (firstPkt) {
  1380.                     firstPkt = false;
  1381.                     FirstCommand firstLine = FirstCommand.fromLine(line);
  1382.                     enabledCapabilities = firstLine.getCapabilities();
  1383.                     line = firstLine.getLine();
  1384.                     enableCapabilities();

  1386.                     if (line.equals(GitProtocolConstants.OPTION_PUSH_CERT)) {
  1387.                         certParser.receiveHeader(pck, !isBiDirectionalPipe());
  1388.                         continue;
  1389.                     }
  1390.                 }

  1392.                 if (line.equals(PushCertificateParser.BEGIN_SIGNATURE)) {
  1393.                     certParser.receiveSignature(pck);
  1394.                     continue;
  1395.                 }

  1397.                 ReceiveCommand cmd = parseCommand(line);
  1398.                 if (cmd.getRefName().equals(Constants.HEAD)) {
  1399.                     cmd.setResult(Result.REJECTED_CURRENT_BRANCH);
  1400.                 } else {
  1401.                     cmd.setRef(refs.get(cmd.getRefName()));
  1402.                 }
  1403.                 commands.add(cmd);
  1404.                 if (certParser.enabled()) {
  1405.                     certParser.addCommand(cmd);
  1406.                 }
  1407.             }
  1408.             pushCert = certParser.build();
  1409.             if (hasCommands()) {
  1410.                 readPostCommands(pck);
  1411.             }
  1412.         } catch (Throwable t) {
  1413.             discardCommands();
  1414.             throw t;
  1415.         }
  1416.     }

  1418.     private void discardCommands() {
  1419.         if (sideBand) {
  1420.             long max = maxDiscardBytes;
  1421.             if (max < 0) {
  1422.                 max = Math.max(3 * maxCommandBytes, 3L << 20);
  1423.             }
  1424.             try {
  1425.                 new PacketLineIn(rawIn, max).discardUntilEnd();
  1426.             } catch (IOException e) {
  1427.                 // Ignore read failures attempting to discard.
  1428.             }
  1429.         }
  1430.     }

  1432.     private void parseShallow(String idStr) throws PackProtocolException {
  1433.         ObjectId id;
  1434.         try {
  1435.             id = ObjectId.fromString(idStr);
  1436.         } catch (InvalidObjectIdException e) {
  1437.             throw new PackProtocolException(e.getMessage(), e);
  1438.         }
  1439.         clientShallowCommits.add(id);
  1440.     }

  1442.     /**
  1443.      * @param in
  1444.      *            request stream.
  1445.      * @throws IOException
  1446.      *             request line cannot be read.
  1447.      */
  1448.     void readPostCommands(PacketLineIn in) throws IOException {
  1449.         if (usePushOptions) {
  1450.             pushOptions = new ArrayList<>(4);
  1451.             for (;;) {
  1452.                 String option = in.readString();
  1453.                 if (PacketLineIn.isEnd(option)) {
  1454.                     break;
  1455.                 }
  1456.                 pushOptions.add(option);
  1457.             }
  1458.         }
  1459.     }

  1461.     /**
  1462.      * Enable capabilities based on a previously read capabilities line.
  1463.      */
  1464.     private void enableCapabilities() {
  1465.         reportStatus = isCapabilityEnabled(CAPABILITY_REPORT_STATUS);
  1466.         usePushOptions = isCapabilityEnabled(CAPABILITY_PUSH_OPTIONS);
  1467.         sideBand = isCapabilityEnabled(CAPABILITY_SIDE_BAND_64K);
  1468.         quiet = allowQuiet && isCapabilityEnabled(CAPABILITY_QUIET);

  1470.         clientSID = enabledCapabilities.get(OPTION_SESSION_ID);

  1472.         if (sideBand) {
  1473.             OutputStream out = rawOut;

  1475.             rawOut = new SideBandOutputStream(CH_DATA, MAX_BUF, out);
  1476.             msgOut = new SideBandOutputStream(CH_PROGRESS, MAX_BUF, out);
  1477.             errOut = new SideBandOutputStream(CH_ERROR, MAX_BUF, out);

  1479.             pckOut = new PacketLineOut(rawOut);
  1480.             pckOut.setFlushOnEnd(false);
  1481.         }
  1482.     }

  1484.     /**
  1485.      * Check if the peer requested a capability.
  1486.      *
  1487.      * @param name
  1488.      *            protocol name identifying the capability.
  1489.      * @return true if the peer requested the capability to be enabled.
  1490.      */
  1491.     private boolean isCapabilityEnabled(String name) {
  1492.         return enabledCapabilities.containsKey(name);
  1493.     }

  1495.     private void checkRequestWasRead() {
  1496.         if (enabledCapabilities == null)
  1497.             throw new RequestNotYetReadException();
  1498.     }

  1500.     /**
  1501.      * Whether a pack is expected based on the list of commands.
  1502.      *
  1503.      * @return {@code true} if a pack is expected based on the list of commands.
  1504.      */
  1505.     private boolean needPack() {
  1506.         for (ReceiveCommand cmd : commands) {
  1507.             if (cmd.getType() != ReceiveCommand.Type.DELETE)
  1508.                 return true;
  1509.         }
  1510.         return false;
  1511.     }

  1513.     /**
  1514.      * Receive a pack from the input and store it in the repository.
  1515.      *
  1516.      * @throws IOException
  1517.      *             an error occurred reading or indexing the pack.
  1518.      */
  1519.     private void receivePack() throws IOException {
  1520.         // It might take the client a while to pack the objects it needs
  1521.         // to send to us. We should increase our timeout so we don't
  1522.         // abort while the client is computing.
  1523.         //
  1524.         if (timeoutIn != null)
  1525.             timeoutIn.setTimeout(10 * timeout * 1000);

  1527.         ProgressMonitor receiving = NullProgressMonitor.INSTANCE;
  1528.         ProgressMonitor resolving = NullProgressMonitor.INSTANCE;
  1529.         if (sideBand && !quiet)
  1530.             resolving = new SideBandProgressMonitor(msgOut);

  1532.         try (ObjectInserter ins = db.newObjectInserter()) {
  1533.             String lockMsg = "jgit receive-pack"; //$NON-NLS-1$
  1534.             if (getRefLogIdent() != null)
  1535.                 lockMsg += " from " + getRefLogIdent().toExternalString(); //$NON-NLS-1$

  1537.             parser = ins.newPackParser(packInputStream());
  1538.             parser.setAllowThin(true);
  1539.             parser.setNeedNewObjectIds(checkReferencedAreReachable);
  1540.             parser.setNeedBaseObjectIds(checkReferencedAreReachable);
  1541.             parser.setCheckEofAfterPackFooter(!biDirectionalPipe
  1542.                     && !isExpectDataAfterPackFooter());
  1543.             parser.setExpectDataAfterPackFooter(isExpectDataAfterPackFooter());
  1544.             parser.setObjectChecker(objectChecker);
  1545.             parser.setLockMessage(lockMsg);
  1546.             parser.setMaxObjectSizeLimit(maxObjectSizeLimit);
  1547.             packLock = parser.parse(receiving, resolving);
  1548.             packSize = Long.valueOf(parser.getPackSize());
  1549.             stats = parser.getReceivedPackStatistics();
  1550.             ins.flush();
  1551.         }

  1553.         if (timeoutIn != null)
  1554.             timeoutIn.setTimeout(timeout * 1000);
  1555.     }

  1557.     private InputStream packInputStream() {
  1558.         InputStream packIn = rawIn;
  1559.         if (maxPackSizeLimit >= 0) {
  1560.             packIn = new LimitedInputStream(packIn, maxPackSizeLimit) {
  1561.                 @Override
  1562.                 protected void limitExceeded() throws TooLargePackException {
  1563.                     throw new TooLargePackException(limit);
  1564.                 }
  1565.             };
  1566.         }
  1567.         return packIn;
  1568.     }

  1570.     private boolean needCheckConnectivity() {
  1571.         return isCheckReceivedObjects()
  1572.                 || isCheckReferencedObjectsAreReachable()
  1573.                 || !getClientShallowCommits().isEmpty();
  1574.     }

  1576.     private void checkSubmodules() throws IOException, LargeObjectException,
  1577.             SubmoduleValidationException {
  1578.         ObjectDatabase odb = db.getObjectDatabase();
  1579.         if (objectChecker == null) {
  1580.             return;
  1581.         }
  1582.         for (GitmoduleEntry entry : objectChecker.getGitsubmodules()) {
  1583.             AnyObjectId blobId = entry.getBlobId();
  1584.             ObjectLoader blob = odb.open(blobId, Constants.OBJ_BLOB);

  1586.             SubmoduleValidator.assertValidGitModulesFile(
  1587.                     new String(blob.getBytes(), UTF_8));
  1588.         }
  1589.     }

  1591.     private void checkConnectivity() throws IOException {
  1592.         ProgressMonitor checking = NullProgressMonitor.INSTANCE;
  1593.         if (sideBand && !quiet) {
  1594.             SideBandProgressMonitor m = new SideBandProgressMonitor(msgOut);
  1595.             m.setDelayStart(750, TimeUnit.MILLISECONDS);
  1596.             checking = m;
  1597.         }

  1599.         connectivityChecker.checkConnectivity(createConnectivityCheckInfo(),
  1600.                 advertisedHaves, checking);
  1601.     }

  1603.     private ConnectivityCheckInfo createConnectivityCheckInfo() {
  1604.         ConnectivityCheckInfo info = new ConnectivityCheckInfo();
  1605.         info.setCheckObjects(checkReferencedAreReachable);
  1606.         info.setCommands(getAllCommands());
  1607.         info.setRepository(db);
  1608.         info.setParser(parser);
  1609.         info.setWalk(walk);
  1610.         return info;
  1611.     }

  1613.     /**
  1614.      * Validate the command list.
  1615.      */
  1616.     private void validateCommands() {
  1617.         for (ReceiveCommand cmd : commands) {
  1618.             final Ref ref = cmd.getRef();
  1619.             if (cmd.getResult() != Result.NOT_ATTEMPTED)
  1620.                 continue;

  1622.             if (cmd.getType() == ReceiveCommand.Type.DELETE) {
  1623.                 if (!isAllowDeletes()) {
  1624.                     // Deletes are not supported on this repository.
  1625.                     cmd.setResult(Result.REJECTED_NODELETE);
  1626.                     continue;
  1627.                 }
  1628.                 if (!isAllowBranchDeletes()
  1629.                         && ref.getName().startsWith(Constants.R_HEADS)) {
  1630.                     // Branches cannot be deleted, but other refs can.
  1631.                     cmd.setResult(Result.REJECTED_NODELETE);
  1632.                     continue;
  1633.                 }
  1634.             }

  1636.             if (cmd.getType() == ReceiveCommand.Type.CREATE) {
  1637.                 if (!isAllowCreates()) {
  1638.                     cmd.setResult(Result.REJECTED_NOCREATE);
  1639.                     continue;
  1640.                 }

  1642.                 if (ref != null && !isAllowNonFastForwards()) {
  1643.                     // Creation over an existing ref is certainly not going
  1644.                     // to be a fast-forward update. We can reject it early.
  1645.                     //
  1646.                     cmd.setResult(Result.REJECTED_NONFASTFORWARD);
  1647.                     continue;
  1648.                 }

  1650.                 if (ref != null) {
  1651.                     // A well behaved client shouldn't have sent us a
  1652.                     // create command for a ref we advertised to it.
  1653.                     //
  1654.                     cmd.setResult(Result.REJECTED_OTHER_REASON,
  1655.                             JGitText.get().refAlreadyExists);
  1656.                     continue;
  1657.                 }
  1658.             }

  1660.             if (cmd.getType() == ReceiveCommand.Type.DELETE && ref != null) {
  1661.                 ObjectId id = ref.getObjectId();
  1662.                 if (id == null) {
  1663.                     id = ObjectId.zeroId();
  1664.                 }
  1665.                 if (!ObjectId.zeroId().equals(cmd.getOldId())
  1666.                         && !id.equals(cmd.getOldId())) {
  1667.                     // Delete commands can be sent with the old id matching our
  1668.                     // advertised value, *OR* with the old id being 0{40}. Any
  1669.                     // other requested old id is invalid.
  1670.                     //
  1671.                     cmd.setResult(Result.REJECTED_OTHER_REASON,
  1672.                             JGitText.get().invalidOldIdSent);
  1673.                     continue;
  1674.                 }
  1675.             }

  1677.             if (cmd.getType() == ReceiveCommand.Type.UPDATE) {
  1678.                 if (ref == null) {
  1679.                     // The ref must have been advertised in order to be updated.
  1680.                     //
  1681.                     cmd.setResult(Result.REJECTED_OTHER_REASON,
  1682.                             JGitText.get().noSuchRef);
  1683.                     continue;
  1684.                 }
  1685.                 ObjectId id = ref.getObjectId();
  1686.                 if (id == null) {
  1687.                     // We cannot update unborn branch
  1688.                     cmd.setResult(Result.REJECTED_OTHER_REASON,
  1689.                             JGitText.get().cannotUpdateUnbornBranch);
  1690.                     continue;
  1691.                 }

  1693.                 if (!id.equals(cmd.getOldId())) {
  1694.                     // A properly functioning client will send the same
  1695.                     // object id we advertised.
  1696.                     //
  1697.                     cmd.setResult(Result.REJECTED_OTHER_REASON,
  1698.                             JGitText.get().invalidOldIdSent);
  1699.                     continue;
  1700.                 }

  1702.                 // Is this possibly a non-fast-forward style update?
  1703.                 //
  1704.                 RevObject oldObj, newObj;
  1705.                 try {
  1706.                     oldObj = walk.parseAny(cmd.getOldId());
  1707.                 } catch (IOException e) {
  1708.                     receiveCommandErrorHandler
  1709.                             .handleOldIdValidationException(cmd, e);
  1710.                     continue;
  1711.                 }

  1713.                 try {
  1714.                     newObj = walk.parseAny(cmd.getNewId());
  1715.                 } catch (IOException e) {
  1716.                     receiveCommandErrorHandler
  1717.                             .handleNewIdValidationException(cmd, e);
  1718.                     continue;
  1719.                 }

  1721.                 if (oldObj instanceof RevCommit
  1722.                         && newObj instanceof RevCommit) {
  1723.                     try {
  1724.                         if (walk.isMergedInto((RevCommit) oldObj,
  1725.                                 (RevCommit) newObj)) {
  1726.                             cmd.setTypeFastForwardUpdate();
  1727.                         } else {
  1728.                             cmd.setType(ReceiveCommand.Type.UPDATE_NONFASTFORWARD);
  1729.                         }
  1730.                     } catch (IOException e) {
  1731.                         receiveCommandErrorHandler
  1732.                                 .handleFastForwardCheckException(cmd, e);
  1733.                     }
  1734.                 } else {
  1735.                     cmd.setType(ReceiveCommand.Type.UPDATE_NONFASTFORWARD);
  1736.                 }

  1738.                 if (cmd.getType() == ReceiveCommand.Type.UPDATE_NONFASTFORWARD
  1739.                         && !isAllowNonFastForwards()) {
  1740.                     cmd.setResult(Result.REJECTED_NONFASTFORWARD);
  1741.                     continue;
  1742.                 }
  1743.             }

  1745.             if (!cmd.getRefName().startsWith(Constants.R_REFS)
  1746.                     || !Repository.isValidRefName(cmd.getRefName())) {
  1747.                 cmd.setResult(Result.REJECTED_OTHER_REASON,
  1748.                         JGitText.get().funnyRefname);
  1749.             }
  1750.         }
  1751.     }

  1753.     /**
  1754.      * Whether any commands have been rejected so far.
  1755.      *
  1756.      * @return if any commands have been rejected so far.
  1757.      */
  1758.     private boolean anyRejects() {
  1759.         for (ReceiveCommand cmd : commands) {
  1760.             if (cmd.getResult() != Result.NOT_ATTEMPTED
  1761.                     && cmd.getResult() != Result.OK)
  1762.                 return true;
  1763.         }
  1764.         return false;
  1765.     }

  1767.     /**
  1768.      * Set the result to fail for any command that was not processed yet.
  1769.      *
  1770.      */
  1771.     private void failPendingCommands() {
  1772.         ReceiveCommand.abort(commands);
  1773.     }

  1775.     /**
  1776.      * Filter the list of commands according to result.
  1777.      *
  1778.      * @param want
  1779.      *            desired status to filter by.
  1780.      * @return a copy of the command list containing only those commands with
  1781.      *         the desired status.
  1782.      * @since 5.7
  1783.      */
  1784.     protected List<ReceiveCommand> filterCommands(Result want) {
  1785.         return ReceiveCommand.filter(commands, want);
  1786.     }

  1788.     /**
  1789.      * Execute commands to update references.
  1790.      * @since 5.7
  1791.      */
  1792.     protected void executeCommands() {
  1793.         List<ReceiveCommand> toApply = filterCommands(Result.NOT_ATTEMPTED);
  1794.         if (toApply.isEmpty())
  1795.             return;

  1797.         ProgressMonitor updating = NullProgressMonitor.INSTANCE;
  1798.         if (sideBand) {
  1799.             SideBandProgressMonitor pm = new SideBandProgressMonitor(msgOut);
  1800.             pm.setDelayStart(250, TimeUnit.MILLISECONDS);
  1801.             updating = pm;
  1802.         }

  1804.         BatchRefUpdate batch = db.getRefDatabase().newBatchUpdate();
  1805.         batch.setAllowNonFastForwards(isAllowNonFastForwards());
  1806.         batch.setAtomic(isAtomic());
  1807.         batch.setRefLogIdent(getRefLogIdent());
  1808.         batch.setRefLogMessage("push", true); //$NON-NLS-1$
  1809.         batch.addCommand(toApply);
  1810.         try {
  1811.             batch.setPushCertificate(getPushCertificate());
  1812.             batch.execute(walk, updating);
  1813.         } catch (IOException e) {
  1814.             receiveCommandErrorHandler.handleBatchRefUpdateException(toApply,
  1815.                     e);
  1816.         }
  1817.     }

  1819.     /**
  1820.      * Send a status report.
  1821.      *
  1822.      * @param unpackError
  1823.      *            an error that occurred during unpacking, or {@code null}
  1824.      * @throws java.io.IOException
  1825.      *             an error occurred writing the status report.
  1826.      * @since 5.6
  1827.      */
  1828.     private void sendStatusReport(Throwable unpackError) throws IOException {
  1829.         Reporter out = new Reporter() {
  1830.             @Override
  1831.             void sendString(String s) throws IOException {
  1832.                 if (reportStatus) {
  1833.                     pckOut.writeString(s + '\n');
  1834.                 } else if (msgOut != null) {
  1835.                     msgOut.write(Constants.encode(s + '\n'));
  1836.                 }
  1837.             }
  1838.         };

  1840.         try {
  1841.             if (unpackError != null) {
  1842.                 out.sendString("unpack error " + unpackError.getMessage()); //$NON-NLS-1$
  1843.                 if (reportStatus) {
  1844.                     for (ReceiveCommand cmd : commands) {
  1845.                         out.sendString("ng " + cmd.getRefName() //$NON-NLS-1$
  1846.                                 + " n/a (unpacker error)"); //$NON-NLS-1$
  1847.                     }
  1848.                 }
  1849.                 return;
  1850.             }

  1852.             if (reportStatus) {
  1853.                 out.sendString("unpack ok"); //$NON-NLS-1$
  1854.             }
  1855.             for (ReceiveCommand cmd : commands) {
  1856.                 if (cmd.getResult() == Result.OK) {
  1857.                     if (reportStatus) {
  1858.                         out.sendString("ok " + cmd.getRefName()); //$NON-NLS-1$
  1859.                     }
  1860.                     continue;
  1861.                 }

  1863.                 final StringBuilder r = new StringBuilder();
  1864.                 if (reportStatus) {
  1865.                     r.append("ng ").append(cmd.getRefName()).append(" "); //$NON-NLS-1$ //$NON-NLS-2$
  1866.                 } else {
  1867.                     r.append(" ! [rejected] ").append(cmd.getRefName()) //$NON-NLS-1$
  1868.                             .append(" ("); //$NON-NLS-1$
  1869.                 }

  1871.                 if (cmd.getResult() == Result.REJECTED_MISSING_OBJECT) {
  1872.                     if (cmd.getMessage() == null)
  1873.                         r.append("missing object(s)"); //$NON-NLS-1$
  1874.                     else if (cmd.getMessage()
  1875.                             .length() == Constants.OBJECT_ID_STRING_LENGTH) {
  1876.                         // TODO: Using get/setMessage to store an OID is a
  1877.                         // misuse. The caller should set a full error message.
  1878.                         r.append("object "); //$NON-NLS-1$
  1879.                         r.append(cmd.getMessage());
  1880.                         r.append(" missing"); //$NON-NLS-1$
  1881.                     } else {
  1882.                         r.append(cmd.getMessage());
  1883.                     }
  1884.                 } else if (cmd.getMessage() != null) {
  1885.                     r.append(cmd.getMessage());
  1886.                 } else {
  1887.                     switch (cmd.getResult()) {
  1888.                     case NOT_ATTEMPTED:
  1889.                         r.append("server bug; ref not processed"); //$NON-NLS-1$
  1890.                         break;

  1892.                     case REJECTED_NOCREATE:
  1893.                         r.append("creation prohibited"); //$NON-NLS-1$
  1894.                         break;

  1896.                     case REJECTED_NODELETE:
  1897.                         r.append("deletion prohibited"); //$NON-NLS-1$
  1898.                         break;

  1900.                     case REJECTED_NONFASTFORWARD:
  1901.                         r.append("non-fast forward"); //$NON-NLS-1$
  1902.                         break;

  1904.                     case REJECTED_CURRENT_BRANCH:
  1905.                         r.append("branch is currently checked out"); //$NON-NLS-1$
  1906.                         break;

  1908.                     case REJECTED_OTHER_REASON:
  1909.                         r.append("unspecified reason"); //$NON-NLS-1$
  1910.                         break;

  1912.                     case LOCK_FAILURE:
  1913.                         r.append("failed to lock"); //$NON-NLS-1$
  1914.                         break;

  1916.                     case REJECTED_MISSING_OBJECT:
  1917.                     case OK:
  1918.                         // We shouldn't have reached this case (see 'ok' case
  1919.                         // above and if-statement above).
  1920.                         throw new AssertionError();
  1921.                     }
  1922.                 }

  1924.                 if (!reportStatus) {
  1925.                     r.append(")"); //$NON-NLS-1$
  1926.                 }
  1927.                 out.sendString(r.toString());
  1928.             }
  1929.         } finally {
  1930.             if (reportStatus) {
  1931.                 pckOut.end();
  1932.             }
  1933.         }
  1934.     }

  1936.     /**
  1937.      * Close and flush (if necessary) the underlying streams.
  1938.      *
  1939.      * @throws java.io.IOException
  1940.      */
  1941.     private void close() throws IOException {
  1942.         if (sideBand) {
  1943.             // If we are using side band, we need to send a final
  1944.             // flush-pkt to tell the remote peer the side band is
  1945.             // complete and it should stop decoding. We need to
  1946.             // use the original output stream as rawOut is now the
  1947.             // side band data channel.
  1948.             //
  1949.             ((SideBandOutputStream) msgOut).flushBuffer();
  1950.             ((SideBandOutputStream) rawOut).flushBuffer();

  1952.             PacketLineOut plo = new PacketLineOut(origOut);
  1953.             plo.setFlushOnEnd(false);
  1954.             plo.end();
  1955.         }

  1957.         if (biDirectionalPipe) {
  1958.             // If this was a native git connection, flush the pipe for
  1959.             // the caller. For smart HTTP we don't do this flush and
  1960.             // instead let the higher level HTTP servlet code do it.
  1961.             //
  1962.             if (!sideBand && msgOut != null)
  1963.                 msgOut.flush();
  1964.             rawOut.flush();
  1965.         }
  1966.     }

  1968.     /**
  1969.      * Release any resources used by this object.
  1970.      *
  1971.      * @throws java.io.IOException
  1972.      *             the pack could not be unlocked.
  1973.      */
  1974.     private void release() throws IOException {
  1975.         walk.close();
  1976.         unlockPack();
  1977.         timeoutIn = null;
  1978.         rawIn = null;
  1979.         rawOut = null;
  1980.         msgOut = null;
  1981.         pckIn = null;
  1982.         pckOut = null;
  1983.         refs = null;
  1984.         // Keep the capabilities. If responses are sent after this release
  1985.         // we need to remember at least whether sideband communication has to be
  1986.         // used
  1987.         commands = null;
  1988.         if (timer != null) {
  1989.             try {
  1990.                 timer.terminate();
  1991.             } finally {
  1992.                 timer = null;
  1993.             }
  1994.         }
  1995.     }

  1997.     /** Interface for reporting status messages. */
  1998.     abstract static class Reporter {
  1999.         abstract void sendString(String s) throws IOException;
  2000.     }

  2002.     /**
  2003.      * Get the push certificate used to verify the pusher's identity.
  2004.      * <p>
  2005.      * Only valid after commands are read from the wire.
  2006.      *
  2007.      * @return the parsed certificate, or null if push certificates are disabled
  2008.      *         or no cert was presented by the client.
  2009.      * @since 4.1
  2010.      */
  2011.     public PushCertificate getPushCertificate() {
  2012.         return pushCert;
  2013.     }

  2015.     /**
  2016.      * Set the push certificate used to verify the pusher's identity.
  2017.      * <p>
  2018.      * Should only be called if reconstructing an instance without going through
  2019.      * the normal {@link #recvCommands()} flow.
  2020.      *
  2021.      * @param cert
  2022.      *            the push certificate to set.
  2023.      * @since 4.1
  2024.      */
  2025.     public void setPushCertificate(PushCertificate cert) {
  2026.         pushCert = cert;
  2027.     }

  2029.     /**
  2030.      * Gets an unmodifiable view of the option strings associated with the push.
  2031.      *
  2032.      * @return an unmodifiable view of pushOptions, or null (if pushOptions is).
  2033.      * @since 4.5
  2034.      */
  2035.     @Nullable
  2036.     public List<String> getPushOptions() {
  2037.         if (isAllowPushOptions() && usePushOptions) {
  2038.             return Collections.unmodifiableList(pushOptions);
  2039.         }

  2041.         // The client doesn't support push options. Return null to
  2042.         // distinguish this from the case where the client declared support
  2043.         // for push options and sent an empty list of them.
  2044.         return null;
  2045.     }

  2047.     /**
  2048.      * Set the push options supplied by the client.
  2049.      * <p>
  2050.      * Should only be called if reconstructing an instance without going through
  2051.      * the normal {@link #recvCommands()} flow.
  2052.      *
  2053.      * @param options
  2054.      *            the list of options supplied by the client. The
  2055.      *            {@code ReceivePack} instance takes ownership of this list.
  2056.      *            Callers are encouraged to first create a copy if the list may
  2057.      *            be modified later.
  2058.      * @since 4.5
  2059.      */
  2060.     public void setPushOptions(@Nullable List<String> options) {
  2061.         usePushOptions = options != null;
  2062.         pushOptions = options;
  2063.     }

  2065.     /**
  2066.      * Get the hook invoked before updates occur.
  2067.      *
  2068.      * @return the hook invoked before updates occur.
  2069.      */
  2070.     public PreReceiveHook getPreReceiveHook() {
  2071.         return preReceive;
  2072.     }

  2074.     /**
  2075.      * Set the hook which is invoked prior to commands being executed.
  2076.      * <p>
  2077.      * Only valid commands (those which have no obvious errors according to the
  2078.      * received input and this instance's configuration) are passed into the
  2079.      * hook. The hook may mark a command with a result of any value other than
  2080.      * {@link org.eclipse.jgit.transport.ReceiveCommand.Result#NOT_ATTEMPTED} to
  2081.      * block its execution.
  2082.      * <p>
  2083.      * The hook may be called with an empty command collection if the current
  2084.      * set is completely invalid.
  2085.      *
  2086.      * @param h
  2087.      *            the hook instance; may be null to disable the hook.
  2088.      */
  2089.     public void setPreReceiveHook(PreReceiveHook h) {
  2090.         preReceive = h != null ? h : PreReceiveHook.NULL;
  2091.     }

  2093.     /**
  2094.      * Get the hook invoked after updates occur.
  2095.      *
  2096.      * @return the hook invoked after updates occur.
  2097.      */
  2098.     public PostReceiveHook getPostReceiveHook() {
  2099.         return postReceive;
  2100.     }

  2102.     /**
  2103.      * Set the hook which is invoked after commands are executed.
  2104.      * <p>
  2105.      * Only successful commands (type is
  2106.      * {@link org.eclipse.jgit.transport.ReceiveCommand.Result#OK}) are passed
  2107.      * into the hook. The hook may be called with an empty command collection if
  2108.      * the current set all resulted in an error.
  2109.      *
  2110.      * @param h
  2111.      *            the hook instance; may be null to disable the hook.
  2112.      */
  2113.     public void setPostReceiveHook(PostReceiveHook h) {
  2114.         postReceive = h != null ? h : PostReceiveHook.NULL;
  2115.     }

  2117.     /**
  2118.      * Get the current unpack error handler.
  2119.      *
  2120.      * @return the current unpack error handler.
  2121.      * @since 5.8
  2122.      */
  2123.     public UnpackErrorHandler getUnpackErrorHandler() {
  2124.         return unpackErrorHandler;
  2125.     }

  2127.     /**
  2128.      * @param unpackErrorHandler
  2129.      *            the unpackErrorHandler to set
  2130.      * @since 5.7
  2131.      */
  2132.     public void setUnpackErrorHandler(UnpackErrorHandler unpackErrorHandler) {
  2133.         this.unpackErrorHandler = unpackErrorHandler;
  2134.     }

  2136.     /**
  2137.      * Set whether this class will report command failures as warning messages
  2138.      * before sending the command results.
  2139.      *
  2140.      * @param echo
  2141.      *            if true this class will report command failures as warning
  2142.      *            messages before sending the command results. This is usually
  2143.      *            not necessary, but may help buggy Git clients that discard the
  2144.      *            errors when all branches fail.
  2145.      * @deprecated no widely used Git versions need this any more
  2146.      */
  2147.     @Deprecated
  2148.     public void setEchoCommandFailures(boolean echo) {
  2149.         // No-op.
  2150.     }

  2152.     /**
  2153.      * @return The client session-id.
  2154.      * @since 6.4
  2155.      */
  2156.     public String getClientSID() {
  2157.         return clientSID;
  2158.     }

  2160.     /**
  2161.      * Execute the receive task on the socket.
  2162.      *
  2163.      * @param input
  2164.      *            raw input to read client commands and pack data from. Caller
  2165.      *            must ensure the input is buffered, otherwise read performance
  2166.      *            may suffer.
  2167.      * @param output
  2168.      *            response back to the Git network client. Caller must ensure
  2169.      *            the output is buffered, otherwise write performance may
  2170.      *            suffer.
  2171.      * @param messages
  2172.      *            secondary "notice" channel to send additional messages out
  2173.      *            through. When run over SSH this should be tied back to the
  2174.      *            standard error channel of the command execution. For most
  2175.      *            other network connections this should be null.
  2176.      * @throws java.io.IOException
  2177.      */
  2178.     public void receive(final InputStream input, final OutputStream output,
  2179.             final OutputStream messages) throws IOException {
  2180.         init(input, output, messages);
  2181.         try {
  2182.             service();
  2183.         } catch (PackProtocolException e) {
  2184.             fatalError(e.getMessage());
  2185.             throw e;
  2186.         } catch (InputOverLimitIOException e) {
  2187.             String msg = JGitText.get().tooManyCommands;
  2188.             fatalError(msg);
  2189.             throw new PackProtocolException(msg, e);
  2190.         } finally {
  2191.             try {
  2192.                 close();
  2193.             } finally {
  2194.                 release();
  2195.             }
  2196.         }
  2197.     }

  2199.     /**
  2200.      * Execute the receive task on the socket.
  2201.      *
  2202.      * <p>
  2203.      * Same as {@link #receive}, but the exceptions are not reported to the
  2204.      * client yet.
  2205.      *
  2206.      * @param input
  2207.      *            raw input to read client commands and pack data from. Caller
  2208.      *            must ensure the input is buffered, otherwise read performance
  2209.      *            may suffer.
  2210.      * @param output
  2211.      *            response back to the Git network client. Caller must ensure
  2212.      *            the output is buffered, otherwise write performance may
  2213.      *            suffer.
  2214.      * @param messages
  2215.      *            secondary "notice" channel to send additional messages out
  2216.      *            through. When run over SSH this should be tied back to the
  2217.      *            standard error channel of the command execution. For most
  2218.      *            other network connections this should be null.
  2219.      * @throws java.io.IOException
  2220.      * @since 5.7
  2221.      */
  2222.     public void receiveWithExceptionPropagation(InputStream input,
  2223.             OutputStream output, OutputStream messages) throws IOException {
  2224.         init(input, output, messages);
  2225.         try {
  2226.             service();
  2227.         } finally {
  2228.             try {
  2229.                 close();
  2230.             } finally {
  2231.                 release();
  2232.             }
  2233.         }
  2234.     }

  2236.     private void service() throws IOException {
  2237.         if (isBiDirectionalPipe()) {
  2238.             sendAdvertisedRefs(new PacketLineOutRefAdvertiser(pckOut));
  2239.             pckOut.flush();
  2240.         } else
  2241.             getAdvertisedOrDefaultRefs();
  2242.         if (hasError())
  2243.             return;

  2245.         recvCommands();

  2247.         if (hasCommands()) {
  2248.             try (PostReceiveExecutor e = new PostReceiveExecutor()) {
  2249.                 if (needPack()) {
  2250.                     try {
  2251.                         receivePackAndCheckConnectivity();
  2252.                     } catch (IOException | RuntimeException
  2253.                             | SubmoduleValidationException | Error err) {
  2254.                         unlockPack();
  2255.                         unpackErrorHandler.handleUnpackException(err);
  2256.                         throw new UnpackException(err);
  2257.                     }
  2258.                 }

  2260.                 try {
  2261.                     setAtomic(isCapabilityEnabled(CAPABILITY_ATOMIC));

  2263.                     validateCommands();
  2264.                     if (atomic && anyRejects()) {
  2265.                         failPendingCommands();
  2266.                     }

  2268.                     preReceive.onPreReceive(
  2269.                             this, filterCommands(Result.NOT_ATTEMPTED));
  2270.                     if (atomic && anyRejects()) {
  2271.                         failPendingCommands();
  2272.                     }
  2273.                     executeCommands();
  2274.                 } finally {
  2275.                     unlockPack();
  2276.                 }

  2278.                 sendStatusReport(null);
  2279.             }
  2280.             autoGc();
  2281.         }
  2282.     }

  2284.     private void autoGc() {
  2285.         Repository repo = getRepository();
  2286.         if (!repo.getConfig().getBoolean(ConfigConstants.CONFIG_RECEIVE_SECTION,
  2287.                 ConfigConstants.CONFIG_KEY_AUTOGC, true)) {
  2288.             return;
  2289.         }
  2290.         repo.autoGC(NullProgressMonitor.INSTANCE);
  2291.     }

  2293.     static ReceiveCommand parseCommand(String line)
  2294.             throws PackProtocolException {
  2295.         if (line == null || line.length() < 83) {
  2296.             throw new PackProtocolException(
  2297.                     JGitText.get().errorInvalidProtocolWantedOldNewRef);
  2298.         }
  2299.         String oldStr = line.substring(0, 40);
  2300.         String newStr = line.substring(41, 81);
  2301.         ObjectId oldId, newId;
  2302.         try {
  2303.             oldId = ObjectId.fromString(oldStr);
  2304.             newId = ObjectId.fromString(newStr);
  2305.         } catch (InvalidObjectIdException e) {
  2306.             throw new PackProtocolException(
  2307.                     JGitText.get().errorInvalidProtocolWantedOldNewRef, e);
  2308.         }
  2309.         String name = line.substring(82);
  2310.         if (!Repository.isValidRefName(name)) {
  2311.             throw new PackProtocolException(
  2312.                     JGitText.get().errorInvalidProtocolWantedOldNewRef);
  2313.         }
  2314.         return new ReceiveCommand(oldId, newId, name);
  2315.     }

  2317.     private class PostReceiveExecutor implements AutoCloseable {
  2318.         @Override
  2319.         public void close() {
  2320.             postReceive.onPostReceive(ReceivePack.this,
  2321.                     filterCommands(Result.OK));
  2322.         }
  2323.     }

  2325.     private class DefaultUnpackErrorHandler implements UnpackErrorHandler {
  2326.         @Override
  2327.         public void handleUnpackException(Throwable t) throws IOException {
  2328.             sendStatusReport(t);
  2329.         }
  2330.     }
  2331. }
Created with JaCoCo 0.8.7.202105040129