const char *zRepack = "git repack -adf";
    gitmirror_message(VERB_NORMAL, "%s\n", zRepack);
    fossil_system(zRepack);
  }

  /* Record this export into the sync log */
  zMirrorAbs = file_canonical_name_dup(zMirror);
  sync_log_entry("this", zMirrorAbs, 0, "git");
  fossil_free(zMirrorAbs);

  /* Optionally do a "git push" */
  zPushUrl = db_text(0, "SELECT value FROM mconfig WHERE key='autopush'");
  if( zPushUrl ){
    char *zPushCmd;
    UrlData url;

    if( rc ){
      fossil_fatal("cannot push content using: %s", zPushCmd);
    }else if( db_is_writeable("repository") ){
      db_unprotect(PROTECT_CONFIG);
      db_multi_exec("REPLACE INTO config(name,value,mtime)"
                    "VALUES('gitpush:%q',1,now())", zPushUrl);
      db_protect_pop();
      sync_log_entry("this", zPushUrl, 0, "git-push");
    }
    fossil_free(zPushCmd);
  }
}

/*
** Implementation of the "fossil git status" command.

    azOther[i] = 0;
  }
  fossil_free(azOther);
  return nErr;
}

/*
** Make a new entry, or update an existing entry, in the SYNCLOG table.

**
** For an ordinary push/pull, zType is NULL.  But it may also be a string
** describing non-standard operations.  For example zType might be "git"
** when doing a "fossil git export", or zType might be "import" when doing
** a "fossil pull --from-parent-project".





*/
void sync_log_entry(
  const char *zFrom,        /* Content comes from this machine */
  const char *zTo,          /* Content goes to this machine */
  i64 iTime,                /* Transfer time, or 0 for "now" */  
  const char *zType         /* Type of sync.  NULL for normal */

){

  schema_synclog();
  if( iTime<=0 ){
    db_multi_exec(
      "INSERT INTO repository.synclog(sfrom,sto,stime,stype)"
      " VALUES(%Q,%Q,unixepoch(),%Q)"
      " ON CONFLICT DO UPDATE SET stime=unixepoch()",
      zFrom, zTo, zType
    );
  }else{
    db_multi_exec(
      "INSERT INTO repository.synclog(sfrom,sto,stime,stype)"
      " VALUES(%Q,%Q,%lld,%Q)"
      " ON CONFLICT DO UPDATE SET stime=%lld WHERE stime<%lld",
      zFrom, zTo, iTime, zType, iTime, iTime
    );
  }












}


/*
** If the repository is configured for autosyncing, then do an
** autosync.  Bits of the "flags" parameter determine details of behavior:
**

    }else{
      fossil_fatal("backup \"%s\" already exists", zDest);
    }
  }
  db_unprotect(PROTECT_ALL);
  db_multi_exec("VACUUM repository INTO %Q", zDest);
  zFullName = file_canonical_name_dup(zDest);
  sync_log_entry("this", zFullName, 0, "backup");
  fossil_free(zFullName);
}

**   # ... code here
**   set common_done 1
** }
*/
int xfer_run_common_script(void){
  return xfer_run_script(xfer_common_code(), 0, 0);
}

/*
** The current line is a "pragma synclog".  Accept this line into
** the SYNCLOG table, if appropriate.
**
**    pragma synclog FROM TO MTIME ?TYPE?
**
** The name of the remote size is zRemote.  The value of "this" for
** either the FROM or TO fields is converted into zRemote.
**
** If either FROM or TO is an alias for the current repository, then
** silently reject the entry.
*/
static void xfer_accept_synclog_pragma(
  Xfer *pXfer,             /* Current line of xfer script */
  const char *zRemote      /* The name of the remote repository */
){
  const char *zFrom = blob_str(&pXfer->aToken[2]);
  const char *zTo = blob_str(&pXfer->aToken[3]);
  i64 iTime = strtoll(blob_str(&pXfer->aToken[4]), 0, 0);
  const char *zType = pXfer->nToken>=5 ? blob_str(&pXfer->aToken[5]) : 0;
  if( strcmp(zFrom, "this")==0 ){
    zFrom = zRemote;
  }else if( db_exists("SELECT 1 FROM config WHERE name='baseurl:%q'",zFrom) ){
    iTime = 0;
  }
  if( strcmp(zTo, "this")==0 ){
    zTo = zRemote;
  }else if( db_exists("SELECT 1 FROM config WHERE name='baseurl:%q'",zTo) ){
    iTime = 0;
  }
  if( iTime>0 ) sync_log_entry(zFrom, zTo, iTime, zType);
}

/*
** If this variable is set, disable login checks.  Used for debugging
** only.
*/
static int disableLogin = 0;

  int rc;
  const char *zScript = 0;
  char *zUuidList = 0;
  int nUuidList = 0;
  char **pzUuidList = 0;
  int *pnUuidList = 0;
  int uvCatalogSent = 0;
  const char *zClientUrl = 0;

  if( fossil_strcmp(PD("REQUEST_METHOD","POST"),"POST") ){
     fossil_redirect_home();
  }
  g.zLogin = "anonymous";
  login_set_anon_nobody_capabilities();
  login_check_credentials();

            blob_str(&xfer.aToken[3])
          );
          db_protect_pop();
        }
        if( db_get_boolean("forbid-delta-manifests",0) ){
          @ pragma avoid-delta-manifests
        }
      }else

      /*   pragma ci-unlock CLIENT-ID
      **
      ** Remove any locks previously held by CLIENT-ID.  Clients send this
      ** pragma with their own ID whenever they know that they no longer
      ** have any commits pending.
      */
      if( blob_eq(&xfer.aToken[1], "ci-unlock")
       && xfer.nToken==3
       && blob_is_hname(&xfer.aToken[2])
      ){
        db_unprotect(PROTECT_CONFIG);
        db_multi_exec(
          "DELETE FROM config"
          " WHERE name GLOB 'ci-lock-*'"
          "   AND json_extract(value,'$.clientid')=%Q",
          blob_str(&xfer.aToken[2])
        );
        db_protect_pop();
      }else

      /*   pragma req-synclog ?CLIENT-URL?
      **
      ** Request synclog data.  If the CLIENT-URL  argument is provided,
      ** it will be the canonical URL for the client.
      */
      if( blob_eq(&xfer.aToken[1], "req-synclog") && g.perm.RdSLog ){
        Stmt qSynclog;
        if( xfer.nToken>=2 ){
          zClientUrl = blob_str(&xfer.aToken[2]);
          if( sqlite3_strlike("http%//localhost%", zClientUrl, 0)==0 ){
            zClientUrl = 0;
          }
        }
        db_prepare(&qSynclog,
          "SELECT sfrom, sto, unixepoch(stime), stype FROM synclog"
        );
        while( db_step(&qSynclog)==SQLITE_ROW ){
          const char *zFrom = db_column_text(&qSynclog,0);
          const char *zTo = db_column_text(&qSynclog,1);
          const char *zTime = db_column_text(&qSynclog,2);
          const char *zType = db_column_text(&qSynclog,3);
          if( zClientUrl ){
            if( strcmp(zFrom, zClientUrl)==0 ) continue;
            if( strcmp(zTo, zClientUrl)==0 ) continue;
          }
          if( zType!=0 && zType[0]!=0 ){
            @ pragma synclog %s(zFrom) %s(zTo) %s(zTime) %s(zType)
          }else{
            @ pragma synclog %s(zFrom) %s(zTo) %s(zTime)
          }
        }
      }else

      /*   pragma synclog FROM TO MTIME ?TYPE?
      **
      ** The client is uploading an entry from its SYNCLOG table.  This
      ** will only be accepted if both:
      **
      **    (1) The client as WrSLog permission
      **    (2) A prior req-synclog pragma has identified the URL of the client
      **
      ** Insert the entry into the SYNC log if appropriate.
      */
      if( xfer.nToken>=4
       && blob_eq(&xfer.aToken[1], "synclog")
       && g.perm.WrSLog
       && zClientUrl!=0
      ){
        xfer_accept_synclog_pragma(&xfer, zClientUrl);
      }

    }else

    /* Unknown message
    */
    {

        db_lset("client-id", zClientId);
      }
      blob_appendf(&send, "pragma ci-lock %s %s\n", zCkinLock, zClientId);
      zCkinLock = 0;
    }else if( zClientId ){
      blob_appendf(&send, "pragma ci-unlock %s\n", zClientId);
    }

    /* Transfer SYNCLOG data on the first roundtrip, if appropriate */
    if( nCycle==0 ){
      const char *zSelfUrl = public_url();
      if( sqlite3_strlike("http%//localhost%", zSelfUrl, 0)==0 ){
        zSelfUrl = 0;
      }
      if( zSelfUrl==0 ){
        blob_appendf(&send,"pragma req-synclog\n");
      }else{
        blob_appendf(&send,"pragma req-synclog %s\n", zSelfUrl);
        if( syncFlags & SYNC_PUSH_SYNCLOG ){
          Stmt qSynclog;
          db_prepare(&qSynclog,
            "SELECT sfrom, sto, unixepoch(stime), stype FROM synclog"
            " WHERE sfrom!=%Q AND sto!=%Q",
            g.url.canonical, g.url.canonical
          );
          while( db_step(&qSynclog)==SQLITE_ROW ){
            const char *zFrom = db_column_text(&qSynclog,0);
            const char *zTo = db_column_text(&qSynclog,1);
            const char *zTime = db_column_text(&qSynclog,2);
            const char *zType = db_column_text(&qSynclog,3);
            if( zType!=0 && zType[0]!=0 ){
              blob_appendf(&send,"pragma synclog %s %s %s %s\n",
                   zFrom, zTo, zTime, zType);
            }else{
              blob_appendf(&send,"pragma synclog %s %s %s\n",
                   zFrom, zTo, zTime);
            }
          }
        }
      }
    }

    /* Append randomness to the end of the uplink message.  This makes all
    ** messages unique so that that the login-card nonce will always
    ** be unique.
    */
    zRandomness = db_text(0, "SELECT hex(randomblob(20))");
    blob_appendf(&send, "# %s\n", zRandomness);

          xfer.remoteVersion = atoi(blob_str(&xfer.aToken[2]));
          if( xfer.nToken>=5 ){
            xfer.remoteDate = atoi(blob_str(&xfer.aToken[3]));
            xfer.remoteTime = atoi(blob_str(&xfer.aToken[4]));
          }
        }

        /*   pragma synclog FROM TO MTIME ?TYPE?
        **
        ** The server is downloading an entry from its SYNCLOG table.  Merge
        ** this into the local SYNCLOG table if appropriate.
        ** is running.  The DATE and TIME are a pure numeric ISO8601 time
        ** for the specific check-in of the client.
        */
        if( xfer.nToken>=4 && blob_eq(&xfer.aToken[1], "synclog") ){
          xfer_accept_synclog_pragma(&xfer, g.url.canonical);
        }

        /*   pragma uv-pull-only
        **   pragma uv-push-ok
        **
        ** If the server is unwill to accept new unversioned content (because
        ** this client lacks the necessary permissions) then it sends a

  }else if( rSkew*24.0*3600.0 < -10.0 ){
     fossil_warning("*** time skew *** server is slow by %s",
                    db_timespan_name(-rSkew));
     g.clockSkewSeen = 1;
  }

  if( nErr==0 ){
    if( zAltPCode!=0 ){
      sync_log_entry(g.url.canonical, "this", 0, "import");
    }else{
      if( syncFlags & SYNC_PUSH ){
        sync_log_entry("this", g.url.canonical, 0, 0);
      }
      if( syncFlags & SYNC_PULL ){
        sync_log_entry(g.url.canonical, "this", 0, 0);
      }
    }
  }

  fossil_force_newline();
  fossil_print(
     "%s done, wire bytes sent: %lld  received: %lld  ip: %s\n",
     zOpType, nSent, nRcvd, g.zIpAddr);
  if( syncFlags & SYNC_VERBOSE ){