no-opt=0             => {Build without optimization}
    json=0               => {Build with fossil JSON API enabled}
}

# Update the minimum required SQLite version number here, and also
# in src/main.c near the sqlite3_libversion_number() call.  Take care
# that both places agree!
define MINIMUM_SQLITE_VERSION "3.38.0"

# This is useful for people wanting Fossil to use an external SQLite library
# to compare the one they have against the minimum required
if {[opt-bool print-minimum-sqlite-version]} {
    puts [get-define MINIMUM_SQLITE_VERSION]
    exit 0
}

**    git CMD     Do the "git export" or "git status" command (which every
**                is specified by CMD) on all repositories for which
**                a Git mirror has been previously established.
**
**    info        Run the "info" command on all repositories.
**
**    pull        Run a "pull" operation on all repositories.  Only the
**                --verbose and --synclog options are supported.
**
**    push        Run a "push" on all repositories.  Only the --verbose
**                and --synclog options is supported.
**
**    rebuild     Rebuild on all repositories.  The command line options
**                supported by the rebuild command itself, if any are
**                present, are passed along verbatim.  The --force and
**                --randomize options are not supported.
**
**    sync        Run a "sync" on all repositories.  Only the --verbose,
**                --unversioned, and --synclog options are supported.
**
**    set         Run the "setting" or "set" commands on all
**                repositories.  These command are particularly useful in
**                conjunction with the "max-loadavg" setting which cannot
**                otherwise be set globally.
**
**    unset       Run the "unset" command on all repositories

      }else{
        usage("git (export|status)");
      }
    }
  }else if( strncmp(zCmd, "push", n)==0 ){
    zCmd = "push -autourl -R";
    collect_argument(&extra, "verbose","v");
    collect_argument(&extra, "synclog",0);
  }else if( strncmp(zCmd, "pull", n)==0 ){
    zCmd = "pull -autourl -R";
    collect_argument(&extra, "verbose","v");
    collect_argument(&extra, "synclog",0);
  }else if( strncmp(zCmd, "rebuild", n)==0 ){
    zCmd = "rebuild";
    collect_argument(&extra, "cluster",0);
    collect_argument(&extra, "compress",0);
    collect_argument(&extra, "compress-only",0);
    collect_argument(&extra, "noverify",0);
    collect_argument_value(&extra, "pagesize");

  }else if( strncmp(zCmd, "fts-config", n)==0 ){
    zCmd = "fts-config -R";
    collect_argv(&extra, 3);
  }else if( strncmp(zCmd, "sync", n)==0 ){
    zCmd = "sync -autourl -R";
    collect_argument(&extra, "verbose","v");
    collect_argument(&extra, "unversioned","u");
    collect_argument(&extra, "synclog",0);
  }else if( strncmp(zCmd, "test-integrity", n)==0 ){
    collect_argument(&extra, "db-only", "d");
    collect_argument(&extra, "parse", 0);
    collect_argument(&extra, "quick", "q");
    zCmd = "test-integrity";
  }else if( strncmp(zCmd, "test-orphans", n)==0 ){
    zCmd = "test-orphans -R";

** if "u" is present and "developer" if "v" is present.
*/
void capability_expand(CapabilityString *pIn){
  static char *zNobody = 0;
  static char *zAnon = 0;
  static char *zReader = 0;
  static char *zDev = 0;
  static char *zAdmin = "bcdefghijklmnopqrtwz234567ADEF";
  int doneV = 0;

  if( pIn==0 ){
    fossil_free(zNobody); zNobody = 0;
    fossil_free(zAnon);   zAnon = 0;
    fossil_free(zReader); zReader = 0;
    fossil_free(zDev);    zDev = 0;

    "Alerts", "Sign up for email alerts" },
  { 'A', CAPCLASS_ALERT|CAPCLASS_SUPER, 0,
    "Announce", "Send announcements to all subscribers" },
  { 'C', CAPCLASS_FORUM, 0,
    "Chat",  "Read and/or writes messages in the chatroom" },
  { 'D', CAPCLASS_OTHER, 0,
    "Debug", "Enable debugging features" },
  { 'E', CAPCLASS_SUPER, 0,
    "Read SyncLog", "Read the SyncLog" },
  { 'F', CAPCLASS_SUPER, 0,
    "Update SyncLog", "Add or modify entries in the SyncLog" },
};

/*
** Populate the aCap[].nUser values based on the current content
** of the USER table.
*/
void capabilities_count(void){

  int groupMask,           /* Mask of groups to be send */
  sqlite3_int64 iStart     /* Only write values changed since this time */
){
  Stmt q;
  Blob rec;
  int ii;
  int nCard = 0;
  int bPrepped;

  blob_zero(&rec);
  if( groupMask & CONFIGSET_SHUN ){
    db_prepare(&q, "SELECT mtime, quote(uuid), quote(scom) FROM shun"
                   " WHERE mtime>=%lld", iStart);
    while( db_step(&q)==SQLITE_ROW ){
      blob_appendf(&rec,"%s %s scom %s",

      blob_appendf(pOut, "config /subscriber %d\n%s\n",
                   blob_size(&rec), blob_str(&rec));
      nCard++;
      blob_reset(&rec);
    }
    db_finalize(&q);
  }
  bPrepped = 0;

  for(ii=0; ii<count(aConfig); ii++){
    if( (aConfig[ii].groupMask & groupMask)!=0 && aConfig[ii].zName[0]!='@' ){
      if( !bPrepped ){
        db_prepare(&q, "SELECT mtime, quote(name), quote(value) FROM config"
                       " WHERE name=:name AND mtime>=%lld", iStart);
        bPrepped = 1;
      }
      db_bind_text(&q, ":name", aConfig[ii].zName);
      while( db_step(&q)==SQLITE_ROW ){
        blob_appendf(&rec,"%s %s value %s",
          db_column_text(&q, 0),
          db_column_text(&q, 1),
          db_column_text(&q, 2)
        );
        blob_appendf(pOut, "config /config %d\n%s\n",
                     blob_size(&rec), blob_str(&rec));
        nCard++;
        blob_reset(&rec);
      }
      db_reset(&q);
    }
  }
  if( bPrepped ){
    db_finalize(&q);
  }
  return nCard;
}

/*
** Identify a configuration group by name.  Return its mask.
** Throw an error if no match.
*/

** Implementation of the "fossil git export" command.
*/
void gitmirror_export_command(void){
  const char *zLimit;             /* Text of the --limit flag */
  int nLimit = 0x7fffffff;        /* Numeric value of the --limit flag */
  int nTotal = 0;                 /* Total number of check-ins to export */
  char *zMirror;                  /* Name of the mirror */
  char *zMirrorAbs;               /* Canonicalized name of the mirror */
  char *z;                        /* Generic string */
  char *zCmd;                     /* git command to run as a subprocess */
  const char *zDebug = 0;         /* Value of the --debug flag */
  const char *zAutoPush = 0;      /* Value of the --autopush flag */
  char *zMainBr = 0;              /* Value of the --mainbranch flag */
  char *zPushUrl;                 /* URL to sync the mirror to */
  double rEnd;                    /* time of most recent export */

  /* Maybe run a git repack */
  if( bNeedRepack ){
    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;
    const char *zUrl;
    UrlData url;
    if( sqlite3_strglob("http*", zPushUrl)==0 ){
      url_parse_local(zPushUrl, 0, &url);
      zUrl = url.canonical;
    }else{
      zUrl = zPushUrl;
    }
    zPushCmd = mprintf("git push --mirror %s", url.canonical);
    gitmirror_message(VERB_NORMAL, "%s\n", zPushCmd);
    fossil_free(zPushCmd);
    zPushCmd = mprintf("git push --mirror %$", zPushUrl);
    rc = fossil_system(zPushCmd);
    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", zUrl, 0, "git-push");
    }
    fossil_free(zPushCmd);
  }
}

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

                             p->RdWiki = p->WrWiki = p->NewWiki =
                             p->ApndWiki = p->Hyperlink = p->Clone =
                             p->NewTkt = p->Password = p->RdAddr =
                             p->TktFmt = p->Attach = p->ApndTkt =
                             p->ModWiki = p->ModTkt =
                             p->RdForum = p->WrForum = p->ModForum =
                             p->WrTForum = p->AdminForum = p->Chat = 
                             p->EmailAlert = p->Announce = p->Debug =
                             p->RdSLog = p->WrSLog = 1;
                             /* Fall thru into Read/Write */
      case 'i':   p->Read = p->Write = 1;                      break;
      case 'o':   p->Read = 1;                                 break;
      case 'z':   p->Zip = 1;                                  break;

      case 'h':   p->Hyperlink = 1;                            break;
      case 'g':   p->Clone = 1;                                break;

      case '3':   p->WrForum = 1;
      case '2':   p->RdForum = 1;                              break;

      case '7':   p->EmailAlert = 1;                           break;
      case 'A':   p->Announce = 1;                             break;
      case 'C':   p->Chat = 1;                                 break;
      case 'D':   p->Debug = 1;                                break;
      case 'E':   p->RdSLog = 1;                               break;
      case 'F':   p->WrSLog = 1;                               break;

      /* The "u" privilege recursively
      ** inherits all privileges of the user named "reader" */
      case 'u': {
        if( p->XReader==0 ){
          const char *zUser;
          p->XReader = 1;

      case '4':  rc = p->WrTForum;  break;
      case '5':  rc = p->ModForum;  break;
      case '6':  rc = p->AdminForum;break;
      case '7':  rc = p->EmailAlert;break;
      case 'A':  rc = p->Announce;  break;
      case 'C':  rc = p->Chat;      break;
      case 'D':  rc = p->Debug;     break;
      case 'E':  rc = p->RdSLog;    break;
      case 'F':  rc = p->WrSLog;    break;
      case 'L':  rc = g.zLogin && *g.zLogin; break;
      /* Mainenance reminder: '@' should not be used because
         it would semantically collide with the @ in the
         capexpr TH1 command. */
      default:   rc = 0;            break;
    }
  }

  char WrTForum;         /* 4: Post to forums not subject to moderation */
  char ModForum;         /* 5: Moderate (approve or reject) forum posts */
  char AdminForum;       /* 6: Grant capability 4 to other users */
  char EmailAlert;       /* 7: Sign up for email notifications */
  char Announce;         /* A: Send announcements */
  char Chat;             /* C: read or write the chatroom */
  char Debug;            /* D: show extra Fossil debugging features */
  char RdSLog;           /* E: read the synclog */
  char WrSLog;           /* F: add to the synclog */
  /* These last two are included to block infinite recursion */
  char XReader;          /* u: Inherit all privileges of "reader" */
  char XDeveloper;       /* v: Inherit all privileges of "developer" */
};

#ifdef FOSSIL_ENABLE_TCL
/*

  fossil_printf_selfcheck();
  fossil_limit_memory(1);

  /* When updating the minimum SQLite version, change the number here,
  ** and also MINIMUM_SQLITE_VERSION value set in ../auto.def.  Take
  ** care that both places agree! */
  if( sqlite3_libversion_number()<3037000 ){
    fossil_panic("Unsuitable SQLite version %s, must be at least 3.38.0",
                 sqlite3_libversion());
  }

  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
  sqlite3_config(SQLITE_CONFIG_LOG, fossil_sqlite_log, 0);
  memset(&g, 0, sizeof(g));
  g.now = time(0);

  db_prepare(&q,
     "SELECT name FROM sqlite_schema /*scan*/"
     " WHERE type='table'"
     " AND name NOT IN ('admin_log', 'blob','delta','rcvfrom','user','alias',"
                       "'config','shun','private','reportfmt',"
                       "'concealed','accesslog','modreq',"
                       "'purgeevent','purgeitem','unversioned',"
                       "'subscriber','pending_alert','chat','synclog')"
     " AND name NOT GLOB 'sqlite_*'"
     " AND name NOT GLOB 'fx_*'"
     " AND name NOT GLOB 'ftsidx_*'"
  );
  while( db_step(&q)==SQLITE_ROW ){
    blob_appendf(&sql, "DROP TABLE IF EXISTS \"%w\";\n", db_column_text(&q,0));
  }
  db_finalize(&q);
  db_multi_exec("%s", blob_str(&sql)/*safe-for-%s*/);
  blob_reset(&sql);

        "DROP TABLE IF EXISTS accesslog;\n"
        "UPDATE user SET photo=NULL, info='';\n"
        "DROP TABLE IF EXISTS purgeevent;\n"
        "DROP TABLE IF EXISTS purgeitem;\n"
        "DROP TABLE IF EXISTS admin_log;\n"
        "DROP TABLE IF EXISTS vcache;\n"
        "DROP TABLE IF EXISTS chat;\n"
        "DROP TABLE IF EXISTS synclog;\n"
      );
    }
    db_protect_pop();
  }
  if( !bNeedRebuild ){
    db_end_transaction(0);
    db_unprotect(PROTECT_ALL);

/* Create the forum-post schema if it does not already exist */
void schema_forum(void){
  if( !db_table_exists("repository","forumpost") ){
    db_multi_exec("%s",zForumSchema/*safe-for-%s*/);
  }
}

/*
** The following table holds information about servers with which
** this repository has synced, as well as servers with which those 
** servers have synced, and so forth.
*/
static const char zSynclogSchema[] =
@ CREATE TABLE repository.synclog(
@   sfrom TEXT,          -- Sync client. "self" means this repo
@   sto TEXT,            -- Sync server
@   stime INT NOT NULL,  -- Time of transfer (unixepoch)
@   stype TEXT,          -- "push", "pull", "git", "backup", "import", etc...
@   PRIMARY KEY(sfrom,sto)
@ ) WITHOUT ROWID;
;

/* Create the forum-post schema if it does not already exist */
void schema_synclog(void){
  if( !db_table_exists("repository","synclog") ){
    db_multi_exec("%s",zSynclogSchema/*safe-for-%s*/);
  }
}

void secaudit0_page(void){
  const char *zAnonCap;      /* Capabilities of user "anonymous" and "nobody" */
  const char *zDevCap;       /* Capabilities of user group "developer" */
  const char *zReadCap;      /* Capabilities of user group "reader" */
  const char *zPubPages;     /* GLOB pattern for public pages */
  const char *zSelfCap;      /* Capabilities of self-registered users */
  int hasSelfReg = 0;        /* True if able to self-register */
  const char *zPublicUrl;    /* Canonical access URL */
  char *z;
  int n;
  CapabilityString *pCap;
  char **azCSP;              /* Parsed content security policy */

  login_check_credentials();
  if( !g.perm.Admin ){

    }
    @ </ul>
    if( zPubPages && zPubPages[0] ){
      @ <p>Change GLOB patterns exceptions using the "Public pages" setting
      @ on the <a href="setup_access">Access Settings</a> page.</p>
    }
  }

  zPublicUrl = public_url();
  if( zPublicUrl!=0 ){
    int nOther = db_int(0, "SELECT count(*) FROM config"
                           " WHERE name GLOB 'baseurl:*'"
                           " AND name<>'baseurl:%q'", zPublicUrl);
    @ <li><p>The canonical URL for this repository is
    @ <a href="%s(zPublicUrl)">%h(zPublicUrl)</a>.
    if( nOther==1 ){
      @ This is also <a href="urllist?urlonly">1 other URL</a> that has
      @ been used to access this repository.
    }else if( nOther>=2 ){
      @ There are also
      @ <a href="urllist?all&urlonly">%d(nOther) other URLs</a> that have
      @ been used to access this repository.
    }
  }else{
    int nUrl = db_int(0, "SELECT count(*) FROM config"
                         " WHERE name GLOB 'baseurl:*'");
    @ <li><p>This repository does not have a canonical access URL.
    if( nUrl==1 ){
      @ There 1
      @ <a href="urllist?urlonly">1 non-canonical URLs</a>
      @ that has been used to access this repository.
    }else if( nUrl>=2 ){
      @ There are
      @ <a href="urllist?all&urlonly">%d(nUrl) non-canonical URLs</a>
      @ that have been used to access this repository.
    }
  }

  /* Make sure the HTTPS is required for login, at least, so that the
  ** password does not go across the Internet in the clear.
  */
  if( db_get_int("redirect-to-https",0)==0 ){
    @ <li><p><b>WARNING:</b>
    @ Sensitive material such as login passwords can be sent over an

  @  Email Alerts%s(B('7'))</label>
  @  <li><label><input type="checkbox" name="aA"%s(oa['A']) />
  @  Send Announcements%s(B('A'))</label>
  @  <li><label><input type="checkbox" name="aC"%s(oa['C']) />
  @  Chatroom%s(B('C'))</label>
  @  <li><label><input type="checkbox" name="aD"%s(oa['D']) />
  @  Enable Debug%s(B('D'))</label>
  @  <li><label><input type="checkbox" name="aE"%s(oa['E']) />
  @  Read SyncLog%s(B('E'))</label>
  @  <li><label><input type="checkbox" name="aF"%s(oa['F']) />
  @  Update SyncLog%s(B('F'))</label>
  @ </ul></div>
  @   </td>
  @ </tr>
  @ <tr>
  @   <td class="usetupEditLabel">Selected Cap:</td>
  @   <td>
  @     <span id="usetupEditCapability">(missing JS?)</span>

      g.argv = newArgv;
      g.argc = 2;
      fossil_print("Full repository verification follows:\n");
      test_integrity();
    }
  }
}

/*
** Return a string which is the public URL used to access this repository.
** Or return a NULL pointer if this repository does not have a public
** access URL.
**
** Algorithm:
**
** The public URL is given by the email-url property.  But it is only
** returned if there have been one more more accesses (as recorded by
** "baseurl:URL" entries in the CONFIG table).
*/
const char *public_url(void){
  const char *zUrl = db_get("email-url", 0);
  if( zUrl==0 ) return 0;
  if( !db_exists("SELECT 1 FROM config WHERE name='baseurl:%q'", zUrl) ){
    return 0;
  }
  return zUrl;
}


/*
** WEBPAGE: urllist
**
** Show ways in which this repository has been accessed
*/
void urllist_page(void){

  db_finalize(&q);
  if( cnt==0 ){
    @ <tr><td>(none)</td>
  }else if( nOmitted ){
    @ <tr><td><a href="urllist?all"><i>Show %d(nOmitted) more...</i></a>
  }
  @ </table>
  if( P("urlonly") ){
    style_finish_page();
    return;
  }

  if( db_table_exists("repository","synclog") ){
    /* This code derived from the "synclog" command in "sync.c" */
    const int nIndent = 2;
    db_prepare(&q,
      "WITH allpull(xfrom,xto,xtime) AS MATERIALIZED (\n"
      "  SELECT sfrom, sto, max(stime) FROM synclog GROUP BY 1\n"
      "),\n"
      "pull(level, url, mtime, ex) AS (\n"
      "  SELECT 0, xfrom, xtime, '|this|' || xfrom || '|'\n"
      "    FROM allpull WHERE xto='this'\n"
      "  UNION\n"
      "  SELECT level+1, xfrom, xtime, ex || xfrom || '|'\n"
      "    FROM pull, allpull\n"
      "   WHERE xto=url\n"
      "     AND ex NOT GLOB ('*|' || xfrom || '|*')\n"
      "   ORDER BY 1 DESC, 3 DESC\n"
      ")\n"
      "SELECT level, url, datetime(mtime,'auto') FROM pull"
    );
    cnt = 0;
    while( db_step(&q)==SQLITE_ROW ){
      int iLevel = db_column_int(&q,0)*nIndent;
      const char *zUrl = db_column_text(&q,1);
      const char *zDate = db_column_text(&q,2);
      if( cnt==0 ){
        @ <div class="section">Pulls</div>
        @ <table border="0" width='100%%'>
      }
      if( strncmp(zUrl,"http",4)==0 ){
        @ <tr><td width='100%%'><span style='margin-left:%d(iLevel)em'>\
        @ <a href='%s(zUrl)'>%h(zUrl)</a></td>\
        @ <td><nobr>%h(zDate)</nobr></td></tr>
      }else{
        @ <tr><td width='100%%'><span style='margin-left:%d(iLevel)em'>\
        @ %h(zUrl)</td><td><nobr>%h(zDate)</nobr></td></tr>
      }
      cnt++;
    }
    db_finalize(&q);
    if( cnt ){
      @ </table>
    }

    db_prepare(&q,
      "WITH allpush(xfrom,xto,xtime) AS MATERIALIZED (\n"
      "  SELECT sfrom, sto, max(stime) FROM synclog GROUP BY 2\n"
      "),\n"
      "push(level, url, mtime, ex) AS (\n"
      "  SELECT 0, xto, xtime, '|this|' || xto || '|'\n"
      "    FROM allpush WHERE xfrom='this'\n"
      "  UNION\n"
      "  SELECT level+1, xto, xtime, ex || xto || '|'\n"
      "    FROM push, allpush\n"
      "   WHERE xfrom=url\n"
      "     AND ex NOT GLOB ('*|' || xto || '|*')\n"
      "   ORDER BY 1 DESC, 3 DESC\n"
      ")\n"
      "SELECT level, url, datetime(mtime,'auto') FROM push"
    );
    cnt = 0;
    while( db_step(&q)==SQLITE_ROW ){
      int iLevel = db_column_int(&q,0)*nIndent;
      const char *zUrl = db_column_text(&q,1);
      const char *zDate = db_column_text(&q,2);
      if( cnt==0 ){
        @ <div class="section">Pushes</div>
        @ <table border="0" width='100%%'>
      }
      if( strncmp(zUrl,"http",4)==0 ){
        @ <tr><td width='100%%'><span style='margin-left:%d(iLevel)em'>\
        @ <a href='%s(zUrl)'>%h(zUrl)</a></td>\
        @ <td><nobr>%h(zDate)</nobr></td></tr>
      }else{
        @ <tr><td width='100%%'><span style='margin-left:%d(iLevel)em'>\
        @ %h(zUrl)</td><td><nobr>%h(zDate)</nobr></td></tr>
      }
      cnt++;
    }
    db_finalize(&q);
    if( cnt ){
      @ </table>
    }
  }


  db_prepare(&q, "SELECT substr(name,7), datetime(mtime,'unixepoch')"
                 "  FROM config WHERE name GLOB 'ckout:*' ORDER BY 2 DESC");
  cnt = 0;
  while( db_step(&q)==SQLITE_ROW ){
    const char *zPath = db_column_text(&q,0);
    if( vfile_top_of_checkout(zPath) ){
      if( cnt==0 ){
        @ <div class="section">Checkouts</div>
        @ <table border="0" width='100%%'>
      }
      @ <tr><td width='100%%'>%h(zPath)</td>
      @ <td><nobr>%h(db_column_text(&q,1))</nobr></td></tr>
      cnt++;
    }
  }
  db_finalize(&q);
  if( cnt ){
    @ </table>
  }


  cnt = 0;
  db_prepare(&q,
    "SELECT substr(name,10), datetime(mtime,'unixepoch')"
    "  FROM config WHERE name GLOB 'syncwith:*'"
    "UNION ALL "
    "SELECT substr(name,10), datetime(mtime,'unixepoch')"
    "  FROM config WHERE name GLOB 'syncfrom:*'"

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

/*
** Modify the URL to remove the username/password.
*/
static void remove_url_username(char *z){
  int i, j;
  for(i=0; z[i] && z[i]!='/'; i++){}
  if( z[i+1]!='/' ) return;
  i += 2;
  for(j=i; z[j] && z[j]!='@'; j++){}
  if( z[j]==0 ) return;
  j++;
  do{
    z[i++] = z[j];
  }while( z[j++]!=0 );
}

/*
** 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".
**
** Usernames are stripped from the zFrom and zTo URLs
*/
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 */
){
  char *zFree1 = 0;
  char *zFree2 = 0;
  schema_synclog();
  if( sqlite3_strglob("http*://*@*", zFrom)==0 ){
    zFree1 = fossil_strdup(zFrom);
    remove_url_username(zFree1);
    zFrom = zFree1;
  }
  if( sqlite3_strglob("http*://*@*", zTo)==0 ){
    zFree2 = fossil_strdup(zTo);
    remove_url_username(zFree2);
    zTo = zFree2;
  }
  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
    );
  }
  fossil_free(zFree1);
  fossil_free(zFree2);
}


/*
** If the repository is configured for autosyncing, then do an
** autosync.  Bits of the "flags" parameter determine details of behavior:
**
**   SYNC_PULL           Pull content from the server to the local repo
**   SYNC_PUSH           Push content from local up to the server

  }
  if( find_option("no-http-compression",0,0)!=0 ){
    *pSyncFlags |= SYNC_NOHTTPCOMPRESS;
  }
  if( find_option("all",0,0)!=0 ){
    *pSyncFlags |= SYNC_ALLURL;
  }
  if( find_option("synclog",0,0)!=0 ){
    *pSyncFlags |= SYNC_PUSH_SYNCLOG;
  }
  url_proxy_options();
  clone_ssh_find_options();
  if( !uvOnly ) db_find_and_open_repository(0, 0);
  db_open_config(0, 1);
  if( g.argc==2 ){
    if( db_get_boolean("auto-shun",0) ) configSync = CONFIGSET_SHUN;
  }else if( g.argc==3 ){

**   --once                     Do not remember URL for subsequent syncs
**   --private                  Pull private branches too
**   --project-code CODE        Use CODE as the project code
**   --proxy PROXY              Use the specified HTTP proxy
**   -R|--repository REPO       Local repository to pull into
**   --ssl-identity FILE        Local SSL credentials, if requested by remote
**   --ssh-command SSH          Use SSH as the "ssh" command
**   --synclog                  Push local synclog information to the server
**   -v|--verbose               Additional (debugging) output
**   --verily                   Exchange extra information with the remote
**                              to ensure no content is overlooked
**
** See also: [[clone]], [[config]], [[push]], [[remote]], [[sync]]
*/
void pull_cmd(void){

**   --no-http-compression      Do not compress HTTP traffic
**   --once                     Do not remember URL for subsequent syncs
**   --proxy PROXY              Use the specified HTTP proxy
**   --private                  Push private branches too
**   -R|--repository REPO       Local repository to push from
**   --ssl-identity FILE        Local SSL credentials, if requested by remote
**   --ssh-command SSH          Use SSH as the "ssh" command
**   --synclog                  Push local synclog information to the server
**   -v|--verbose               Additional (debugging) output
**   --verily                   Exchange extra information with the remote
**                              to ensure no content is overlooked
**
** See also: [[clone]], [[config]], [[pull]], [[remote]], [[sync]]
*/
void push_cmd(void){

**   --no-http-compression      Do not compress HTTP traffic
**   --once                     Do not remember URL for subsequent syncs
**   --proxy PROXY              Use the specified HTTP proxy
**   --private                  Sync private branches too
**   -R|--repository REPO       Local repository to sync with
**   --ssl-identity FILE        Local SSL credentials, if requested by remote
**   --ssh-command SSH          Use SSH as the "ssh" command
**   --synclog                  Push local synclog information to the server
**   -u|--unversioned           Also sync unversioned content
**   -v|--verbose               Additional (debugging) output
**   --verily                   Exchange extra information with the remote
**                              to ensure no content is overlooked
**
** See also: [[clone]], [[pull]], [[push]], [[remote]]
*/

**
**    --overwrite              OK to overwrite an existing file
**    -R NAME                  Filename of the repository to backup
*/
void backup_cmd(void){
  char *zDest;
  int bOverwrite = 0;
  char *zFullName;
  db_find_and_open_repository(OPEN_ANY_SCHEMA, 0);
  bOverwrite = find_option("overwrite",0,0)!=0;
  verify_all_options();
  if( g.argc!=3 ){
    usage("FILE|DIRECTORY");
  }
  zDest = g.argv[2];

      }
    }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);
}

/*
** COMMAND: synclog
**
** Usage: %fossil synclog
**
** Show other repositories with which this repository has pushed or pulled,
** together with the time since the most recent push or pull.
*/
void synclog_cmd(void){
  Stmt q;
  int cnt;
  const int nIndent = 2;
  db_find_and_open_repository(0,0);
  schema_synclog();
  db_prepare(&q,
    "WITH allpull(xfrom,xto,xtime) AS MATERIALIZED (\n"
    "  SELECT sfrom, sto, max(stime) FROM synclog GROUP BY 1\n"
    "),\n"
    "pull(level, url, mtime, ex) AS (\n"
    "  SELECT 0, xfrom, xtime, '|this|' || xfrom || '|'\n"
    "    FROM allpull WHERE xto='this'\n"
    "  UNION\n"
    "  SELECT level+1, xfrom, xtime, ex || xfrom || '|'\n"
    "    FROM pull, allpull\n"
    "   WHERE xto=url\n"
    "     AND ex NOT GLOB ('*|' || xfrom || '|*')\n"
    "   ORDER BY 1 DESC, 3 DESC\n"
    ")\n"
    "SELECT level, url, julianday() - julianday(mtime,'auto') FROM pull"
  );
  cnt = 0;
  fossil_print("PULL:\n");
  while( db_step(&q)==SQLITE_ROW ){
    int iLevel = (db_column_int(&q,0)+1)*nIndent;
    const char *zUrl = db_column_text(&q,1);
    double rTimeAgo = db_column_double(&q,2);
    if( rTimeAgo*86400.0<=2.0 ){
      fossil_print("%.*c%s (current)\n", iLevel, ' ', zUrl);
    }else{
      char *zAgo = human_readable_age(rTimeAgo);
      fossil_print("%.*c%s (%z ago)\n", iLevel, ' ', zUrl, zAgo);
    }
    cnt++;
  }
  db_finalize(&q);
  if( cnt==0 ){
    fossil_print("  (none)\n");
  }
  db_prepare(&q,
    "WITH allpush(xfrom,xto,xtime) AS MATERIALIZED (\n"
    "  SELECT sfrom, sto, max(stime) FROM synclog GROUP BY 2\n"
    "),\n"
    "push(level, url, mtime, ex) AS (\n"
    "  SELECT 0, xto, xtime, '|this|' || xto || '|'\n"
    "    FROM allpush WHERE xfrom='this'\n"
    "  UNION\n"
    "  SELECT level+1, xto, xtime, ex || xto || '|'\n"
    "    FROM push, allpush\n"
    "   WHERE xfrom=url\n"
    "     AND ex NOT GLOB ('*|' || xto || '|*')\n"
    "   ORDER BY 1 DESC, 3 DESC\n"
    ")\n"
    "SELECT level, url, julianday() - julianday(mtime,'auto') FROM push"
  );
  cnt = 0;
  fossil_print("PUSH:\n");
  while( db_step(&q)==SQLITE_ROW ){
    int iLevel = (db_column_int(&q,0)+1)*nIndent;
    const char *zUrl = db_column_text(&q,1);
    double rTimeAgo = db_column_double(&q,2);
    if( rTimeAgo*86400.0<=2.0 ){
      fossil_print("%.*c%s (current)\n", iLevel, ' ', zUrl);
    }else{
      char *zAgo = human_readable_age(rTimeAgo);
      fossil_print("%.*c%s (%z ago)\n", iLevel, ' ', zUrl, zAgo);
    }
    cnt++;
  }
  db_finalize(&q);
  if( cnt==0 ){
    fossil_print("  (none)\n");
  }
}

**   # ... 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
       && db_table_exists("repository","synclog")
      ){
        Stmt qSynclog;
        if( xfer.nToken>=2 ){
          zClientUrl = blob_str(&xfer.aToken[2]);
          if( zClientUrl!=0
           && sqlite3_strlike("http%//localhost%", zClientUrl, 0)==0
          ){
            zClientUrl = 0;
          }
        }
        db_prepare(&qSynclog,
          "SELECT sfrom, sto, unixepoch(stime,'auto'), 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
    */
    {

static const char zBriefFormat[] =
   "Round-trips: %d   Artifacts sent: %d  received: %d\r";

#if INTERFACE
/*
** Flag options for controlling client_sync()
*/
#define SYNC_PUSH           0x00001    /* push content client to server */
#define SYNC_PULL           0x00002    /* pull content server to client */
#define SYNC_CLONE          0x00004    /* clone the repository */
#define SYNC_PRIVATE        0x00008    /* Also transfer private content */
#define SYNC_VERBOSE        0x00010    /* Extra diagnostics */
#define SYNC_RESYNC         0x00020    /* --verily */
#define SYNC_FROMPARENT     0x00040    /* Pull from the parent project */
#define SYNC_UNVERSIONED    0x00100    /* Sync unversioned content */
#define SYNC_UV_REVERT      0x00200    /* Copy server unversioned to client */
#define SYNC_UV_TRACE       0x00400    /* Describe UV activities */
#define SYNC_UV_DRYRUN      0x00800    /* Do not actually exchange files */
#define SYNC_IFABLE         0x01000    /* Inability to sync is not fatal */
#define SYNC_CKIN_LOCK      0x02000    /* Lock the current check-in */
#define SYNC_NOHTTPCOMPRESS 0x04000    /* Do not compression HTTP messages */
#define SYNC_ALLURL         0x08000    /* The --all flag - sync to all URLs */
#define SYNC_PUSH_SYNCLOG   0x10000    /* Uplink SYNCLOG info */
#endif

/*
** Floating-point absolute value
*/
static double fossil_fabs(double x){
  return x>0.0 ? x : -x;

  int autopushFailed = 0; /* Autopush following commit failed if true */
  const char *zCkinLock;  /* Name of check-in to lock.  NULL for none */
  const char *zClientId;  /* A unique identifier for this check-out */
  unsigned int mHttpFlags;/* Flags for the http_exchange() subsystem */

  if( db_get_boolean("dont-push", 0) ) syncFlags &= ~SYNC_PUSH;
  if( (syncFlags & (SYNC_PUSH|SYNC_PULL|SYNC_CLONE|SYNC_UNVERSIONED))==0
     && configRcvMask==0 && configSendMask==0 ){
    return 0;
  }
  if( zPCode==0 && (syncFlags & SYNC_CLONE)==0 ){
    /* Every established repository must have a project-code */
    fossil_fatal("no project-code defined for this repository");
  }
  if( syncFlags & SYNC_FROMPARENT ){
    configRcvMask = 0;
    configSendMask = 0;
    syncFlags &= ~(SYNC_PUSH);
    zAltPCode = db_get("parent-project-code", 0);
    if( zAltPCode==0 || db_get("parent-project-name",0)==0 ){
      fossil_fatal("there is no parent project: set the 'parent-project-code'"
                   " and 'parent-project-name' config parameters in order"
                   " to pull from a parent project");
    }
  }
  if( zAltPCode!=0 && zPCode!=0 && sqlite3_stricmp(zPCode,zAltPCode)==0 ){
    zAltPCode = 0;
  }

  transport_stats(0, 0, 1);
  socket_global_init();
  memset(&xfer, 0, sizeof(xfer));
  xfer.pIn = &recv;
  xfer.pOut = &send;

        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( zSelfUrl!=0
       && 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)!=0
         && db_table_exists("repository","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);

        if( xfer.nToken>=3 && blob_eq(&xfer.aToken[1], "server-version") ){
          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
        ** "uv-pull-only" pragma so that the client will know not to waste

      ** Also ignore "not authorized to write" errors if this is an
      ** autopush following a commit.
      */
      if( blob_eq(&xfer.aToken[0],"error") && xfer.nToken==2 ){
        char *zMsg = blob_terminate(&xfer.aToken[1]);
        defossilize(zMsg);
        if( (syncFlags & SYNC_IFABLE)!=0
         && sqlite3_strlike("%not authorized to write%",zMsg,0)==0
        ){
          autopushFailed = 1;
          nErr++;
        }else if( (syncFlags & SYNC_CLONE)==0 || nCycle>0 ){
          fossil_force_newline();
          fossil_print("Error: %s\n", zMsg);
          blob_appendf(&xfer.err, "server says: %s\n", zMsg);
          nErr++;

                    db_timespan_name(rSkew));
     g.clockSkewSeen = 1;
  }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 ){
    fossil_print(