#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "config.h"

#include "environment.h"

#include "gettext.h"

#include "hex.h"

#include "refs.h"

#include "pkt-line.h"

#include "sideband.h"

#include "repository.h"

#include "object-store-ll.h"

#include "oid-array.h"

#include "object.h"

#include "commit.h"

#include "diff.h"

#include "revision.h"

#include "list-objects-filter-options.h"

#include "run-command.h"

#include "connect.h"

#include "sigchain.h"

#include "version.h"

#include "string-list.h"

#include "strvec.h"

#include "trace2.h"

#include "protocol.h"

#include "upload-pack.h"

#include "commit-graph.h"

#include "commit-reach.h"

#include "shallow.h"

#include "write-or-die.h"

#include "json-writer.h"

#include "strmap.h"

/* Remember to update object flag allocation in object.h */

#define THEY_HAVE (1u << 11)

#define OUR_REF   (1u << 12)

#define WANTED    (1u << 13)

#define COMMON_KNOWN  (1u << 14)

#define SHALLOW   (1u << 16)

#define NOT_SHALLOW (1u << 17)

#define CLIENT_SHALLOW  (1u << 18)

#define HIDDEN_REF  (1u << 19)

#define ALL_FLAGS (THEY_HAVE | OUR_REF | WANTED | COMMON_KNOWN | SHALLOW | \

    NOT_SHALLOW | CLIENT_SHALLOW | HIDDEN_REF)

/* Enum for allowed unadvertised object request (UOR) */

enum allow_uor {

  /* Allow specifying sha1 if it is a ref tip. */

  ALLOW_TIP_SHA1 = 0x01,

  /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */

  ALLOW_REACHABLE_SHA1 = 0x02,

  /* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */

  ALLOW_ANY_SHA1 = 0x07

};

/*

 * Please annotate, and if possible group together, fields used only

 * for protocol v0 or only for protocol v2.

 */

struct upload_pack_data {

  struct string_list symref;        /* v0 only */

  struct object_array want_obj;

  struct object_array have_obj;

  struct strmap wanted_refs;        /* v2 only */

  struct strvec hidden_refs;

  struct object_array shallows;

  struct oidset deepen_not;

  struct object_array extra_edge_obj;

  int depth;

  timestamp_t deepen_since;

  int deepen_rev_list;

  int deepen_relative;

  int keepalive;

  int shallow_nr;

  timestamp_t oldest_have;

  unsigned int timeout;         /* v0 only */

  enum {

    NO_MULTI_ACK = 0,

    MULTI_ACK = 1,

    MULTI_ACK_DETAILED = 2

  } multi_ack;            /* v0 only */

  /* 0 for no sideband, otherwise DEFAULT_PACKET_MAX or LARGE_PACKET_MAX */

  int use_sideband;

  struct string_list uri_protocols;

  enum allow_uor allow_uor;

  struct list_objects_filter_options filter_options;

  struct string_list allowed_filters;

  struct packet_writer writer;

  char *pack_objects_hook;

  unsigned stateless_rpc : 1;       /* v0 only */

  unsigned no_done : 1;         /* v0 only */

  unsigned daemon_mode : 1;       /* v0 only */

  unsigned filter_capability_requested : 1;   /* v0 only */

  unsigned use_thin_pack : 1;

  unsigned use_ofs_delta : 1;

  unsigned no_progress : 1;

  unsigned use_include_tag : 1;

  unsigned wait_for_done : 1;

  unsigned allow_filter : 1;

  unsigned allow_filter_fallback : 1;

  unsigned long tree_filter_max_depth;

  unsigned done : 1;          /* v2 only */

  unsigned allow_ref_in_want : 1;       /* v2 only */

  unsigned allow_sideband_all : 1;      /* v2 only */

  unsigned seen_haves : 1;        /* v2 only */

  unsigned allow_packfile_uris : 1;     /* v2 only */

  unsigned advertise_sid : 1;

  unsigned sent_capabilities : 1;

};

static void upload_pack_data_init(struct upload_pack_data *data)

{

  struct string_list symref = STRING_LIST_INIT_DUP;

  struct strmap wanted_refs = STRMAP_INIT;

  struct strvec hidden_refs = STRVEC_INIT;

  struct object_array want_obj = OBJECT_ARRAY_INIT;

  struct object_array have_obj = OBJECT_ARRAY_INIT;

  struct object_array shallows = OBJECT_ARRAY_INIT;

  struct oidset deepen_not = OID_ARRAY_INIT;

  struct string_list uri_protocols = STRING_LIST_INIT_DUP;

  struct object_array extra_edge_obj = OBJECT_ARRAY_INIT;

  struct string_list allowed_filters = STRING_LIST_INIT_DUP;

  memset(data, 0, sizeof(*data));

  data->symref = symref;

  data->wanted_refs = wanted_refs;

  data->hidden_refs = hidden_refs;

  data->want_obj = want_obj;

  data->have_obj = have_obj;

  data->shallows = shallows;

  data->deepen_not = deepen_not;

  data->uri_protocols = uri_protocols;

  data->extra_edge_obj = extra_edge_obj;

  data->allowed_filters = allowed_filters;

  data->allow_filter_fallback = 1;

  data->tree_filter_max_depth = ULONG_MAX;

  packet_writer_init(&data->writer, 1);

  list_objects_filter_init(&data->filter_options);

  data->keepalive = 5;

  data->advertise_sid = 0;

}

static void upload_pack_data_clear(struct upload_pack_data *data)

{

  string_list_clear(&data->symref, 1);

  strmap_clear(&data->wanted_refs, 1);

  strvec_clear(&data->hidden_refs);

  object_array_clear(&data->want_obj);

  object_array_clear(&data->have_obj);

  object_array_clear(&data->shallows);

  oidset_clear(&data->deepen_not);

  object_array_clear(&data->extra_edge_obj);

  list_objects_filter_release(&data->filter_options);

  string_list_clear(&data->allowed_filters, 0);

  free((char *)data->pack_objects_hook);

}

static void reset_timeout(unsigned int timeout)

{

  alarm(timeout);

}

static void send_client_data(int fd, const char *data, ssize_t sz,

           int use_sideband)

{

  if (use_sideband) {

    send_sideband(1, fd, data, sz, use_sideband);

    return;

  }

  if (fd == 3)

    /* emergency quit */

    fd = 2;

  if (fd == 2) {

    /* XXX: are we happy to lose stuff here? */

    xwrite(fd, data, sz);

    return;

  }

  write_or_die(fd, data, sz);

}

static int write_one_shallow(const struct commit_graft *graft, void *cb_data)

{

  FILE *fp = cb_data;

  if (graft->nr_parent == -1)

    fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));

  return 0;

}

struct output_state {

  /*

   * We do writes no bigger than LARGE_PACKET_DATA_MAX - 1, because with

   * sideband-64k the band designator takes up 1 byte of space. Because

   * relay_pack_data keeps the last byte to itself, we make the buffer 1

   * byte bigger than the intended maximum write size.

   */

  char buffer[(LARGE_PACKET_DATA_MAX - 1) + 1];

  int used;

  unsigned packfile_uris_started : 1;

  unsigned packfile_started : 1;

};

static int relay_pack_data(int pack_objects_out, struct output_state *os,

         int use_sideband, int write_packfile_line)

{

  /*

   * We keep the last byte to ourselves

   * in case we detect broken rev-list, so that we

   * can leave the stream corrupted.  This is

   * unfortunate -- unpack-objects would happily

   * accept a valid packdata with trailing garbage,

   * so appending garbage after we pass all the

   * pack data is not good enough to signal

   * breakage to downstream.

   */

  ssize_t readsz;

  readsz = xread(pack_objects_out, os->buffer + os->used,

           sizeof(os->buffer) - os->used);

  if (readsz < 0) {

    return readsz;

  }

  os->used += readsz;

  while (!os->packfile_started) {

    char *p;

    if (os->used >= 4 && !memcmp(os->buffer, "PACK", 4)) {

      os->packfile_started = 1;

      if (write_packfile_line) {

        if (os->packfile_uris_started)

          packet_delim(1);

        packet_write_fmt(1, "\1packfile\n");

      }

      break;

    }

    if ((p = memchr(os->buffer, '\n', os->used))) {

      if (!os->packfile_uris_started) {

        os->packfile_uris_started = 1;

        if (!write_packfile_line)

          BUG("packfile_uris requires sideband-all");

        packet_write_fmt(1, "\1packfile-uris\n");

      }

      *p = '\0';

      packet_write_fmt(1, "\1%s\n", os->buffer);

      os->used -= p - os->buffer + 1;

      memmove(os->buffer, p + 1, os->used);

    } else {

      /*

       * Incomplete line.

       */

      return readsz;

    }

  }

  if (os->used > 1) {

    send_client_data(1, os->buffer, os->used - 1, use_sideband);

    os->buffer[0] = os->buffer[os->used - 1];

    os->used = 1;

  } else {

    send_client_data(1, os->buffer, os->used, use_sideband);

    os->used = 0;

  }

  return readsz;

}

static void create_pack_file(struct upload_pack_data *pack_data,

           const struct string_list *uri_protocols)

{

  struct child_process pack_objects = CHILD_PROCESS_INIT;

  struct output_state *output_state = xcalloc(1, sizeof(struct output_state));

  char progress[128];

  char abort_msg[] = "aborting due to possible repository "

    "corruption on the remote side.";

  ssize_t sz;

  int i;

  FILE *pipe_fd;

  if (!pack_data->pack_objects_hook)

    pack_objects.git_cmd = 1;

  else {

    strvec_push(&pack_objects.args, pack_data->pack_objects_hook);

    strvec_push(&pack_objects.args, "git");

    pack_objects.use_shell = 1;

  }

  if (pack_data->shallow_nr) {

    strvec_push(&pack_objects.args, "--shallow-file");

    strvec_push(&pack_objects.args, "");

  }

  strvec_push(&pack_objects.args, "pack-objects");

  strvec_push(&pack_objects.args, "--revs");

  if (pack_data->use_thin_pack)

    strvec_push(&pack_objects.args, "--thin");

  strvec_push(&pack_objects.args, "--stdout");

  if (pack_data->shallow_nr)

    strvec_push(&pack_objects.args, "--shallow");

  if (!pack_data->no_progress)

    strvec_push(&pack_objects.args, "--progress");

  if (pack_data->use_ofs_delta)

    strvec_push(&pack_objects.args, "--delta-base-offset");

  if (pack_data->use_include_tag)

    strvec_push(&pack_objects.args, "--include-tag");

  if (pack_data->filter_options.choice) {

    const char *spec =

      expand_list_objects_filter_spec(&pack_data->filter_options);

    strvec_pushf(&pack_objects.args, "--filter=%s", spec);

  }

  if (uri_protocols) {

    for (i = 0; i < uri_protocols->nr; i++)

      strvec_pushf(&pack_objects.args, "--uri-protocol=%s",

           uri_protocols->items[i].string);

  }

  pack_objects.in = -1;

  pack_objects.out = -1;

  pack_objects.err = -1;

  pack_objects.clean_on_exit = 1;

  if (start_command(&pack_objects))

    die("git upload-pack: unable to fork git-pack-objects");

  pipe_fd = xfdopen(pack_objects.in, "w");

  if (pack_data->shallow_nr)

    for_each_commit_graft(write_one_shallow, pipe_fd);

  for (i = 0; i < pack_data->want_obj.nr; i++)

    fprintf(pipe_fd, "%s\n",

      oid_to_hex(&pack_data->want_obj.objects[i].item->oid));

  fprintf(pipe_fd, "--not\n");

  for (i = 0; i < pack_data->have_obj.nr; i++)

    fprintf(pipe_fd, "%s\n",

      oid_to_hex(&pack_data->have_obj.objects[i].item->oid));

  for (i = 0; i < pack_data->extra_edge_obj.nr; i++)

    fprintf(pipe_fd, "%s\n",

      oid_to_hex(&pack_data->extra_edge_obj.objects[i].item->oid));

  fprintf(pipe_fd, "\n");

  fflush(pipe_fd);

  fclose(pipe_fd);

  /* We read from pack_objects.err to capture stderr output for

   * progress bar, and pack_objects.out to capture the pack data.

   */

  while (1) {

    struct pollfd pfd[2];

    int pe, pu, pollsize, polltimeout;

    int ret;

    reset_timeout(pack_data->timeout);

    pollsize = 0;

    pe = pu = -1;

    if (0 <= pack_objects.out) {

      pfd[pollsize].fd = pack_objects.out;

      pfd[pollsize].events = POLLIN;

      pu = pollsize;

      pollsize++;

    }

    if (0 <= pack_objects.err) {

      pfd[pollsize].fd = pack_objects.err;

      pfd[pollsize].events = POLLIN;

      pe = pollsize;

      pollsize++;

    }

    if (!pollsize)

      break;

    polltimeout = pack_data->keepalive < 0

      ? -1

      : 1000 * pack_data->keepalive;

    ret = poll(pfd, pollsize, polltimeout);

    if (ret < 0) {

      if (errno != EINTR) {

        error_errno("poll failed, resuming");

        sleep(1);

      }

      continue;

    }

    if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {

      /* Status ready; we ship that in the side-band

       * or dump to the standard error.

       */

      sz = xread(pack_objects.err, progress,

          sizeof(progress));

      if (0 < sz)

        send_client_data(2, progress, sz,

             pack_data->use_sideband);

      else if (sz == 0) {

        close(pack_objects.err);

        pack_objects.err = -1;

      }

      else

        goto fail;

      /* give priority to status messages */

      continue;

    }

    if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {

      int result = relay_pack_data(pack_objects.out,

                 output_state,

                 pack_data->use_sideband,

                 !!uri_protocols);

      if (result == 0) {

        close(pack_objects.out);

        pack_objects.out = -1;

      } else if (result < 0) {

        goto fail;

      }

    }

    /*

     * We hit the keepalive timeout without saying anything; send

     * an empty message on the data sideband just to let the other

     * side know we're still working on it, but don't have any data

     * yet.

     *

     * If we don't have a sideband channel, there's no room in the

     * protocol to say anything, so those clients are just out of

     * luck.

     */

    if (!ret && pack_data->use_sideband) {

      static const char buf[] = "0005\1";

      write_or_die(1, buf, 5);

    }

  }

  if (finish_command(&pack_objects)) {

    error("git upload-pack: git-pack-objects died with error.");

    goto fail;

  }

  /* flush the data */

  if (output_state->used > 0) {

    send_client_data(1, output_state->buffer, output_state->used,

         pack_data->use_sideband);

    fprintf(stderr, "flushed.\n");

  }

  free(output_state);

  if (pack_data->use_sideband)

    packet_flush(1);

  return;

 fail:

  free(output_state);

  send_client_data(3, abort_msg, strlen(abort_msg),

       pack_data->use_sideband);

  die("git upload-pack: %s", abort_msg);

}

static int do_got_oid(struct upload_pack_data *data, const struct object_id *oid)

{

  int we_knew_they_have = 0;

  struct object *o = parse_object_with_flags(the_repository, oid,

               PARSE_OBJECT_SKIP_HASH_CHECK |

               PARSE_OBJECT_DISCARD_TREE);

  if (!o)

    die("oops (%s)", oid_to_hex(oid));

  if (o->type == OBJ_COMMIT) {

    struct commit_list *parents;

    struct commit *commit = (struct commit *)o;

    if (o->flags & THEY_HAVE)

      we_knew_they_have = 1;

    else

      o->flags |= THEY_HAVE;

    if (!data->oldest_have || (commit->date < data->oldest_have))

      data->oldest_have = commit->date;

    for (parents = commit->parents;

         parents;

         parents = parents->next)

      parents->item->object.flags |= THEY_HAVE;

  }

  if (!we_knew_they_have) {

    add_object_array(o, NULL, &data->have_obj);

    return 1;

  }

  return 0;

}

static int got_oid(struct upload_pack_data *data,

       const char *hex, struct object_id *oid)

{

  if (get_oid_hex(hex, oid))

    die("git upload-pack: expected SHA1 object, got '%s'", hex);

  if (!repo_has_object_file_with_flags(the_repository, oid,

               OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT))

    return -1;

  return do_got_oid(data, oid);

}

static int ok_to_give_up(struct upload_pack_data *data)

{

  timestamp_t min_generation = GENERATION_NUMBER_ZERO;

  if (!data->have_obj.nr)

    return 0;

  return can_all_from_reach_with_flag(&data->want_obj, THEY_HAVE,

              COMMON_KNOWN, data->oldest_have,

              min_generation);

}

static int get_common_commits(struct upload_pack_data *data,

            struct packet_reader *reader)

{

  struct object_id oid;

  char last_hex[GIT_MAX_HEXSZ + 1];

  int got_common = 0;

  int got_other = 0;

  int sent_ready = 0;

  for (;;) {

    const char *arg;

    reset_timeout(data->timeout);

    if (packet_reader_read(reader) != PACKET_READ_NORMAL) {

      if (data->multi_ack == MULTI_ACK_DETAILED

          && got_common

          && !got_other

          && ok_to_give_up(data)) {

        sent_ready = 1;

        packet_write_fmt(1, "ACK %s ready\n", last_hex);

      }

      if (data->have_obj.nr == 0 || data->multi_ack)

        packet_write_fmt(1, "NAK\n");

      if (data->no_done && sent_ready) {

        packet_write_fmt(1, "ACK %s\n", last_hex);

        return 0;

      }

      if (data->stateless_rpc)

        exit(0);

      got_common = 0;

      got_other = 0;

      continue;

    }

    if (skip_prefix(reader->line, "have ", &arg)) {

      switch (got_oid(data, arg, &oid)) {

      case -1: /* they have what we do not */

        got_other = 1;

        if (data->multi_ack

            && ok_to_give_up(data)) {

          const char *hex = oid_to_hex(&oid);

          if (data->multi_ack == MULTI_ACK_DETAILED) {

            sent_ready = 1;

            packet_write_fmt(1, "ACK %s ready\n", hex);

          } else

            packet_write_fmt(1, "ACK %s continue\n", hex);

        }

        break;

      default:

        got_common = 1;

        oid_to_hex_r(last_hex, &oid);

        if (data->multi_ack == MULTI_ACK_DETAILED)

          packet_write_fmt(1, "ACK %s common\n", last_hex);

        else if (data->multi_ack)

          packet_write_fmt(1, "ACK %s continue\n", last_hex);

        else if (data->have_obj.nr == 1)

          packet_write_fmt(1, "ACK %s\n", last_hex);

        break;

      }

      continue;

    }

    if (!strcmp(reader->line, "done")) {

      if (data->have_obj.nr > 0) {

        if (data->multi_ack)

          packet_write_fmt(1, "ACK %s\n", last_hex);

        return 0;

      }

      packet_write_fmt(1, "NAK\n");

      return -1;

    }

    die("git upload-pack: expected SHA1 list, got '%s'", reader->line);

  }

}

static int allow_hidden_refs(enum allow_uor allow_uor)

{

  if ((allow_uor & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1)

    return 1;

  return !(allow_uor & (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));

}

static void for_each_namespaced_ref_1(each_ref_fn fn,

              struct upload_pack_data *data)

{

  const char **excludes = NULL;

  /*

   * If `data->allow_uor` allows fetching hidden refs, we need to

   * mark all references (including hidden ones), to check in

   * `is_our_ref()` below.

   *

   * Otherwise, we only care about whether each reference's object

   * has the OUR_REF bit set or not, so do not need to visit

   * hidden references.

   */

  if (allow_hidden_refs(data->allow_uor))

    excludes = hidden_refs_to_excludes(&data->hidden_refs);

  refs_for_each_namespaced_ref(get_main_ref_store(the_repository),

             excludes, fn, data);

}

static int is_our_ref(struct object *o, enum allow_uor allow_uor)

{

  return o->flags & ((allow_hidden_refs(allow_uor) ? 0 : HIDDEN_REF) | OUR_REF);

}

/*

 * on successful case, it's up to the caller to close cmd->out

 */

static int do_reachable_revlist(struct child_process *cmd,

        struct object_array *src,

        struct object_array *reachable,

        enum allow_uor allow_uor)

{

  struct object *o;

  FILE *cmd_in = NULL;

  int i;

  strvec_pushl(&cmd->args, "rev-list", "--stdin", NULL);

  cmd->git_cmd = 1;

  cmd->no_stderr = 1;

  cmd->in = -1;

  cmd->out = -1;

  /*

   * If the next rev-list --stdin encounters an unknown commit,

   * it terminates, which will cause SIGPIPE in the write loop

   * below.

   */

  sigchain_push(SIGPIPE, SIG_IGN);

  if (start_command(cmd))

    goto error;

  cmd_in = xfdopen(cmd->in, "w");

  for (i = get_max_object_index(); 0 < i; ) {

    o = get_indexed_object(--i);

    if (!o)

      continue;

    if (reachable && o->type == OBJ_COMMIT)

      o->flags &= ~TMP_MARK;

    if (!is_our_ref(o, allow_uor))

      continue;

    if (fprintf(cmd_in, "^%s\n", oid_to_hex(&o->oid)) < 0)

      goto error;

  }

  for (i = 0; i < src->nr; i++) {

    o = src->objects[i].item;

    if (is_our_ref(o, allow_uor)) {

      if (reachable)

        add_object_array(o, NULL, reachable);

      continue;

    }

    if (reachable && o->type == OBJ_COMMIT)

      o->flags |= TMP_MARK;

    if (fprintf(cmd_in, "%s\n", oid_to_hex(&o->oid)) < 0)

      goto error;

  }

  if (ferror(cmd_in) || fflush(cmd_in))

    goto error;

  fclose(cmd_in);

  cmd->in = -1;

  sigchain_pop(SIGPIPE);

  return 0;

error:

  sigchain_pop(SIGPIPE);

  if (cmd_in)

    fclose(cmd_in);

  if (cmd->out >= 0)

    close(cmd->out);

  return -1;

}

static int get_reachable_list(struct upload_pack_data *data,

            struct object_array *reachable)

{

  struct child_process cmd = CHILD_PROCESS_INIT;

  int i;

  struct object *o;

  char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */

  const unsigned hexsz = the_hash_algo->hexsz;

  if (do_reachable_revlist(&cmd, &data->shallows, reachable,

         data->allow_uor) < 0)

    return -1;

  while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {

    struct object_id oid;

    const char *p;

    if (parse_oid_hex(namebuf, &oid, &p) || *p != '\n')

      break;

    o = lookup_object(the_repository, &oid);

    if (o && o->type == OBJ_COMMIT) {

      o->flags &= ~TMP_MARK;

    }

  }

  for (i = get_max_object_index(); 0 < i; i--) {

    o = get_indexed_object(i - 1);

    if (o && o->type == OBJ_COMMIT &&

        (o->flags & TMP_MARK)) {

      add_object_array(o, NULL, reachable);

        o->flags &= ~TMP_MARK;

    }

  }

  close(cmd.out);

  if (finish_command(&cmd))

    return -1;

  return 0;

}

static int has_unreachable(struct object_array *src, enum allow_uor allow_uor)

{

  struct child_process cmd = CHILD_PROCESS_INIT;

  char buf[1];

  int i;

  if (do_reachable_revlist(&cmd, src, NULL, allow_uor) < 0)

    return 1;

  /*

   * The commits out of the rev-list are not ancestors of

   * our ref.

   */

  i = read_in_full(cmd.out, buf, 1);

  if (i)

    goto error;

  close(cmd.out);

  cmd.out = -1;

  /*

   * rev-list may have died by encountering a bad commit

   * in the history, in which case we do want to bail out

   * even when it showed no commit.

   */

  if (finish_command(&cmd))

    goto error;

  /* All the non-tip ones are ancestors of what we advertised */

  return 0;

error:

  if (cmd.out >= 0)

    close(cmd.out);

  return 1;

}

static void check_non_tip(struct upload_pack_data *data)

{

  int i;

  /*

   * In the normal in-process case without

   * uploadpack.allowReachableSHA1InWant,

   * non-tip requests can never happen.

   */

  if (!data->stateless_rpc && !(data->allow_uor & ALLOW_REACHABLE_SHA1))

    goto error;

  if (!has_unreachable(&data->want_obj, data->allow_uor))

    /* All the non-tip ones are ancestors of what we advertised */

    return;

error:

  /* Pick one of them (we know there at least is one) */

  for (i = 0; i < data->want_obj.nr; i++) {

    struct object *o = data->want_obj.objects[i].item;

    if (!is_our_ref(o, data->allow_uor)) {

      error("git upload-pack: not our ref %s",

            oid_to_hex(&o->oid));

      packet_writer_error(&data->writer,

              "upload-pack: not our ref %s",

              oid_to_hex(&o->oid));

      exit(128);

    }

  }

}

static void send_shallow(struct upload_pack_data *data,

       struct commit_list *result)

{

  while (result) {

    struct object *object = &result->item->object;

    if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {

      packet_writer_write(&data->writer, "shallow %s",

              oid_to_hex(&object->oid));

      register_shallow(the_repository, &object->oid);

      data->shallow_nr++;

    }

    result = result->next;

  }

}

static void send_unshallow(struct upload_pack_data *data)

{

  int i;

  for (i = 0; i < data->shallows.nr; i++) {

    struct object *object = data->shallows.objects[i].item;

    if (object->flags & NOT_SHALLOW) {

      struct commit_list *parents;

      packet_writer_write(&data->writer, "unshallow %s",

              oid_to_hex(&object->oid));

      object->flags &= ~CLIENT_SHALLOW;

      /*

       * We want to _register_ "object" as shallow, but we

       * also need to traverse object's parents to deepen a

       * shallow clone. Unregister it for now so we can

       * parse and add the parents to the want list, then

       * re-register it.

       */

      unregister_shallow(&object->oid);

      object->parsed = 0;

      parse_commit_or_die((struct commit *)object);

      parents = ((struct commit *)object)->parents;

      while (parents) {

        add_object_array(&parents->item->object,

             NULL, &data->want_obj);

        parents = parents->next;

      }

      add_object_array(object, NULL, &data->extra_edge_obj);

    }

    /* make sure commit traversal conforms to client */

    register_shallow(the_repository, &object->oid);

  }

}

static int check_ref(const char *refname_full, const char *referent UNUSED, const struct object_id *oid,

         int flag, void *cb_data);

static void deepen(struct upload_pack_data *data, int depth)

{

  if (depth == INFINITE_DEPTH && !is_repository_shallow(the_repository)) {

    int i;

    for (i = 0; i < data->shallows.nr; i++) {

      struct object *object = data->shallows.objects[i].item;

      object->flags |= NOT_SHALLOW;

    }

  } else if (data->deepen_relative) {

    struct object_array reachable_shallows = OBJECT_ARRAY_INIT;

    struct commit_list *result;

    /*

     * Checking for reachable shallows requires that our refs be

     * marked with OUR_REF.

     */

    refs_head_ref_namespaced(get_main_ref_store(the_repository),

           check_ref, data);

    for_each_namespaced_ref_1(check_ref, data);

    get_reachable_list(data, &reachable_shallows);

    result = get_shallow_commits(&reachable_shallows,

               depth + 1,

               SHALLOW, NOT_SHALLOW);