*******************************************************************************
**
** This file contains code used to clone a repository
*/
#include "config.h"
#include "clone.h"
#include <assert.h>
#if !defined(_WIN32)
#  include <signal.h>
#endif

/*
** If there are public BLOBs that deltas from private BLOBs, then
** undeltify the public BLOBs so that the private BLOBs may be safely
** deleted.
*/
void fix_private_blob_dependencies(int showWarning){

** See also: [[init]], [[open]]
*/
void clone_cmd(void){
  char *zPassword;
  const char *zDefaultUser;   /* Optional name of the default user */
  const char *zHttpAuth;      /* HTTP Authorization user:pass information */
  int nErr = 0;
  int nResumes = 0;
  int urlFlags = URL_PROMPT_PW | URL_REMEMBER;
  int syncFlags = SYNC_CLONE;
  int noCompress = find_option("nocompress",0,0)!=0;
  int noOpen = find_option("no-open",0,0)!=0;
  int allowNested = find_option("nested",0,0)!=0; /* Used by open */
  int nResumeSeqno = 0;       /* Last seqno from which to resume clone */
  const char *zNewProjCode;   /* New Project code obtained during clone */
  const char *zOldProjCode;   /* Old project code stored in resuming clone */
  const char *zCloneCode;     /* server-code for the source of the clone */
  const char *zRepo = 0;      /* Name of the new local repository file */
  const char *zWorkDir = 0;   /* Open in this directory, if not zero */


  /* Also clone private branches */
  if( find_option("private",0,0)!=0 ) syncFlags |= SYNC_PRIVATE;
  if( find_option("once",0,0)!=0) urlFlags &= ~URL_REMEMBER;

    zRepo = mprintf("./%s.fossil", zBase);
    if( zWorkDir==0 ){
      zWorkDir = mprintf("./%s", zBase);
    }
    fossil_free(zBase);
  }
  if( -1 != file_size(zRepo, ExtFILE) ){
    db_open_repository(zRepo);
    nResumeSeqno = db_get_int("aux-clone-seqno",0);
    db_close(0);
    if( !nResumeSeqno ){
      fossil_fatal("file already exists: %s", zRepo);
    }
  }
  /* Fail before clone if open will fail because inside an open check-out */
  if( zWorkDir!=0 && zWorkDir[0]!=0 && !noOpen ){
    if( db_open_local_v2(0, allowNested) ){
      fossil_fatal("there is already an open tree at %s", g.zLocalRoot);
    }
  }

      g.zLogin = zDefaultUser;
    }else{
      g.zLogin = db_text(0, "SELECT login FROM user WHERE cap LIKE '%%s%%'");
    }
    fossil_print("Repository cloned into %s\n", zRepo);
  }else{
    db_close_config();
    if( nResumeSeqno>1 ){
      db_open_repository(zRepo);
      db_open_config(0,0);
      db_begin_transaction();
      zOldProjCode = db_get("project-code",0);
      zCloneCode = db_get("aux-clone-code",0);
      if( zOldProjCode==0 ) fossil_fatal("project-id missing from repository");
      if( zCloneCode==0 ) fossil_fatal("clone-code missing from repository");
      fossil_print("Resuming clone of project-id %s\n",zOldProjCode);
      db_unprotect(PROTECT_USER);
      db_multi_exec("DELETE FROM user WHERE cap LIKE '%%s%%'");
      db_protect_pop();
      db_create_default_users(1, zDefaultUser);
      if( zDefaultUser ){
        g.zLogin = zDefaultUser;
      }else{
        g.zLogin = db_text(0, "SELECT login FROM user WHERE cap LIKE '%%s%%'");
      }
      user_select();
    }else{
      db_create_repository(zRepo);
      db_open_repository(zRepo);
      db_open_config(0,0);
      db_begin_transaction();
      db_record_repository_filename(zRepo);
      db_initial_setup(0, 0, zDefaultUser);
      user_select();
      db_set("content-schema", CONTENT_SCHEMA, 0);
      db_set("aux-schema", AUX_SCHEMA_MAX, 0);
      db_set_int("aux-clone-seqno", 1, 0);
    }
    db_set("rebuilt", get_version(), 0);
    db_unset("hash-policy", 0);
    remember_or_get_http_auth(zHttpAuth, urlFlags & URL_REMEMBER, g.argv[2]);
    url_remember();
    if( g.zSSLIdentity!=0 ){
      /* If the --ssl-identity option was specified, store it as a setting */
      Blob fn;

      "DELETE FROM config WHERE name='project-code';"
    );
    db_protect_pop();
    url_enable_proxy(0);
    clone_ssh_db_set_options();
    url_get_password_if_needed();
    g.xlinkClusterOnly = 1;
    while( nResumes++<3 && (nErr = client_sync(syncFlags,CONFIGSET_ALL,0,0,0))
    ){
      if( db_get_int("aux-clone-seqno",1)==1 ){
        fossil_fatal("server returned an error - clone aborted");
      }
      if( sync_interrupted() ){
        fossil_warning("clone was interrupted");
        break;
      }
      if( nResumes<3 ){
        fossil_warning("cloning encountered errors, trying again.");
        sqlite3_sleep(500);
      }
    }
    g.xlinkClusterOnly = 0;
    verify_cancel();
    if( nResumeSeqno>1 ){
      if( nResumeSeqno==db_get_int("aux-clone-seqno",0) ){
        fossil_fatal("No progress was made - aborting");
      }
      zNewProjCode = db_get("project-code",0);
      if( zOldProjCode!=0 && zOldProjCode[0]!=0
          && fossil_strcmp(zOldProjCode, zNewProjCode)!=0 ){
        fossil_fatal("project-id changed\nwas %s\nis  %s"
               "\nrolling back changes",
               zOldProjCode, zNewProjCode);
      }
      if( zCloneCode!=0 && zCloneCode[0]!=0
          && fossil_strcmp(zCloneCode, db_get("aux-clone-code",0))!=0 ){
        fossil_fatal("clone resume from different server not allowed");
      }
    }
    if( nErr ){
      fossil_warning("server returned an error - clone incomplete");
    }else{
      db_unprotect(PROTECT_CONFIG);
      db_multi_exec(
        "DELETE FROM config WHERE name = 'aux-clone-seqno';"
        "DELETE FROM config WHERE name = 'aux-clone-code';"
      );
      db_protect_pop();
    }
    db_end_transaction(0);
    db_close(1);




    db_open_repository(zRepo);
#if !defined(_WIN32)
    signal(SIGINT, SIG_DFL);
#endif
  }

  if( db_exists("SELECT 1 FROM delta WHERE srcId IN phantom") ){
    fossil_warning("there are unresolved deltas -");
    if( db_get_int("aux-clone-seqno",0)==0 ){
      fossil_fatal("the clone is probabaly incomplete and unusable.");
    }
  }
  if( db_get_int("aux-clone-seqno",0)>1 ){
    fossil_warning("It may be possible to resume the"
           " clone by running the same command again.");
  }else{
    db_begin_transaction();
    fossil_print("Rebuilding repository meta-data...\n");
    rebuild_db(1, 0);
    if( !noCompress ){
      int nDelta = 0;
      i64 nByte;
      fossil_print("Extra delta compression... "); fflush(stdout);
      nByte = extra_deltification(&nDelta);
      if( nDelta==1 ){
        fossil_print("1 delta saves %,lld bytes\n", nByte);
      }else if( nDelta>1 ){
        fossil_print("%d deltas save %,lld bytes\n", nDelta, nByte);
      }else{
        fossil_print("none found\n");
      }
    }
    db_end_transaction(0);
    fossil_print("Vacuuming the database... "); fflush(stdout);
    if( db_int(0, "PRAGMA page_count")>1000
     && db_int(0, "PRAGMA page_size")<8192 ){
       db_multi_exec("PRAGMA page_size=8192;");
    }
    db_unprotect(PROTECT_ALL);
    db_multi_exec("VACUUM");
    db_protect_pop();
    fossil_print("\nproject-id: %s\n", db_get("project-code", 0));
    fossil_print("server-id:  %s\n", db_get("server-code", 0));
    zPassword = db_text(0, "SELECT pw FROM user WHERE login=%Q", g.zLogin);
    fossil_print("admin-user: %s (password is \"%s\")\n", g.zLogin, zPassword);
    hash_user_password(g.zLogin);
    if( zWorkDir!=0 && zWorkDir[0]!=0 && !noOpen ){
      Blob cmd;
      fossil_print("opening the new %s repository in directory %s...\n",
         zRepo, zWorkDir);
      blob_init(&cmd, 0, 0);
      blob_append_escaped_arg(&cmd, g.nameOfExe, 1);
      blob_append(&cmd, " open ", -1);
      blob_append_escaped_arg(&cmd, zRepo, 1);
      blob_append(&cmd, " --nosync --workdir ", -1);
      blob_append_escaped_arg(&cmd, zWorkDir, 1);
      if( allowNested ){
        blob_append(&cmd, " --nested", -1);
      }
      fossil_system(blob_str(&cmd));
      blob_reset(&cmd);
    }
  }
}

/*
** If user chooses to use HTTP Authentication over unencrypted HTTP,
** remember decision.  Otherwise, if the URL is being changed and no
** preference has been indicated, err on the safe side and revert the

    fossil_fatal("the --repodir option only makes sense if the REPOSITORY "
                 "argument is a URI that begins with http:, https:, ssh:, "
                 "or file:");
  }

  db_open_config(0,0);
  db_open_repository(zRepo);
  if( db_get_int("aux-clone-seqno",0)!=0 ){
    fossil_fatal("This repository appears to be an incomplete clone.");
  }

  /* Figure out which revision to open. */
  if( !emptyFlag ){
    if( g.argc==4 ){
      g.zOpenRevision = g.argv[3];
    }else if( db_exists("SELECT 1 FROM event WHERE type='ci'") ){
      g.zOpenRevision = db_get("main-branch", 0);

**
** This file contains code to implement the file transfer protocol.
*/
#include "config.h"
#include "xfer.h"

#include <time.h>
#if !defined(_WIN32)
#  include <signal.h>
#endif

/*
** Maximum number of HTTP redirects that any http_exchange() call will
** follow before throwing a fatal error. Most browsers use a limit of 20.
*/
#define MAX_REDIRECTS 20

          cgi_set_content_type("application/x-fossil-uncompressed");
        }
        blob_is_int(&xfer.aToken[2], &seqno);
        max = db_int(0, "SELECT max(rid) FROM blob");
        while( xfer.mxSend>(int)blob_size(xfer.pOut) && seqno<=max){
          if( time(NULL) >= xfer.maxTime ) break;
          if( iVers>=3 ){
            if( seqno==1 ){
              send_all(&xfer);
              if( xfer.syncPrivate ) send_private(&xfer);
            }
            send_compressed_file(&xfer, seqno);
          }else{
            send_file(&xfer, seqno, 0, 1);
          }
          seqno++;
        }
        if( seqno>max ) seqno = 0;

      /*    pragma req-links
      **
      ** The client sends this message to the server to ask the server
      ** to tell it about alternative repositories  in the reply.
      */
      if( blob_eq(&xfer.aToken[1], "req-links") ){
        bSendLinks = 1;
      }else

      /*    pragma send-rebuilt
      **
      ** The client sends this message to the server to ask the server
      ** for the last time its database was rebuilt
      */
      if( blob_eq(&xfer.aToken[1], "send-rebuilt") ){
        Blob rcode;
        blob_zero(&rcode);
        blob_appendf(&rcode, "%s-%s", db_get("server-code",0),
                     db_get_mtime("rebuilt",0,0));
        @ pragma rebuilt %F(blob_str(&rcode))
        blob_reset(&rcode);
      }

    }else

    /* Unknown message
    */
    {

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

/*
** Used during cloning to exit the sync loop prematurely
*/
static int bSyncGotIntr = 0;
static void sync_sigint_handler(int x){
  bSyncGotIntr = 1;
}
/*
** Interface to check whether sync was interrupted by SIGINT
*/
int sync_interrupted() {
  return bSyncGotIntr;
}

/*
** Sync to the host identified in g.url.name and g.url.path.  This
** routine is called by the client.
**
** Records are pushed to the server if pushFlag is true.  Records
** are pulled if pullFlag is true.  A full sync occurs if both are

  Blob recv;              /* Reply we got back from the server */
  Xfer xfer;              /* Transfer data */
  int pctDone;            /* Percentage done with a message */
  int lastPctDone = -1;   /* Last displayed pctDone */
  double rArrivalTime;    /* Time at which a message arrived */
  const char *zSCode = db_get("server-code", "x");
  const char *zPCode = db_get("project-code", 0);
  const char *zCCode = 0;
  int nErr = 0;           /* Number of errors */
  int nRoundtrip= 0;      /* Number of HTTP requests */
  int nArtifactSent = 0;  /* Total artifacts sent */
  int nArtifactRcvd = 0;  /* Total artifacts received */
  int nPriorArtifact = 0; /* Artifacts received on prior round-trips */
  const char *zOpType = 0;/* Push, Pull, Sync, Clone */
  double rSkew = 0.0;     /* Maximum time skew */

  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;  /* Nothing to do */
  }

  if( (syncFlags & SYNC_CLONE)==0 && db_get_int("aux-clone-seqno",0)>0 ){
    fossil_fatal("Unable to synchronize due to incomplete clone.");
  }else if( (syncFlags & SYNC_CLONE)!=0 ){
    cloneSeqno = db_get_int("aux-clone-seqno",1);
  }

  /* Compute an appropriate project code.  zPCode is the project code
  ** for the local repository.  zAltPCode will usually be NULL, but might
  ** also be an alternative project code to expect on the server.  When
  ** zAltPCode is not NULL, that means we are doing a cross-project import -
  ** in other words, reading content from one project into a different
  ** project.

  /*
  ** The request from the client always begin with a clone, pull,
  ** or push message.
  */
  blob_appendf(&send, "pragma client-version %d %d %d\n",
               RELEASE_VERSION_NUMBER, MANIFEST_NUMERIC_DATE,
               MANIFEST_NUMERIC_TIME);
  if( (syncFlags & SYNC_CLONE)!=0 ){
#if !defined(_WIN32)
    signal(SIGINT, sync_sigint_handler);
#endif
    if( nCycle<2 ){
      /* Only request this at the beginning of the clone */
      blob_appendf(&send, "pragma send-rebuilt\n");
    }
    blob_appendf(&send, "clone 3 %d\n", cloneSeqno);
    syncFlags &= ~(SYNC_PUSH|SYNC_PULL);
    nCardSent++;
    /* TBD: Request all transferable configuration values */
    content_enable_dephantomize(0);
    zOpType = "Clone";
  }else if( syncFlags & SYNC_PULL ){

       && xfer.nToken==3
       && (syncFlags & SYNC_CLONE)!=0
       && blob_is_hname(&xfer.aToken[2])
      ){
        if( zPCode==0 ){
          zPCode = mprintf("%b", &xfer.aToken[2]);
          db_set("project-code", zPCode, 0);
        }
        if( zCCode==0 ){
          if( blob_is_hname(&xfer.aToken[1]) ){
            zCCode = mprintf("%b", &xfer.aToken[1]);
            db_set("aux-clone-code", zCCode, 0);
          }
        }
        if( cloneSeqno>0 ) blob_appendf(&send, "clone 3 %d\n", cloneSeqno);
        nCardSent++;
      }else

      /*   config NAME SIZE \n CONTENT
      **

              "   WHERE mtime<excluded.mtime;",
              zUrl, zArg, iTime
            );
            db_protect_pop();
          }
          url_unparse(&x);
        }

        /*    pragma rebuilt FOSSILISZESTRING
        **
        ** The server generates this message in response to a client request
        ** that is trying to resume.
        */
        else if( blob_eq(&xfer.aToken[1], "rebuilt")
              && xfer.nToken==3
              && (syncFlags & SYNC_CLONE)!=0
        ){
          zCCode = mprintf("%b", &xfer.aToken[2]);
          db_set("aux-clone-code", zCCode, 0);
        }

      }else

      /*   error MESSAGE
      **
      ** The server is reporting an error.  The client will abandon
      ** the sync session.

      fossil_print(zBriefFormat /*works-like:"%d%d%d"*/,
                   nRoundtrip, nArtifactSent, nArtifactRcvd);
    }
    nUncRcvd += blob_size(&recv);
    blob_reset(&recv);
    nCycle++;

    /* Record the current cloneSeqno in the event that clone fails. This
    ** enables the ability to resume from this same point in clone. */
    if( (syncFlags & SYNC_CLONE)!=0 ){
      db_set_int("aux-clone-seqno", cloneSeqno, 0);
    }
    /* Set go to 1 if we need to continue the sync/push/pull/clone for
    ** another round.  Set go to 0 if it is time to quit. */
    nFileRecv = xfer.nFileRcvd + xfer.nDeltaRcvd + xfer.nDanglingFile;
    if( (nFileRecv>0 || newPhantom) && db_exists("SELECT 1 FROM phantom") ){
      go = 1;
      mxPhantomReq = nFileRecv*2;
      if( mxPhantomReq<200 ) mxPhantomReq = 200;

      }else if( nFileRecv>0 ){
        go = 1;
      }else if( cloneSeqno>0 && nArtifactRcvd>nPriorArtifact ){
        /* Continue the clone until we see the clone_seqno 0" card or
        ** until we stop receiving artifacts */
        go = 1;
      }
    }
    if( (syncFlags & SYNC_CLONE)!=0 && bSyncGotIntr && cloneSeqno>0 ){
      go = 0;
      nErr++;
    }

    nCardRcvd = 0;
    xfer.nFileRcvd = 0;
    xfer.nDeltaRcvd = 0;
    xfer.nDanglingFile = 0;
    db_multi_exec("DROP TABLE onremote; DROP TABLE unk;");