rfa.c

来自「ftam等标准协议服务器和客户端的源代码。」· C语言 代码 · 共 1,200 行 · 第 1/3 页

	/*--- check if we are master ---*/
	if (IS_MASTER(rfa->ri_status) || IS_UNREGISTERED(rfa->ri_status)) {
	    if (IS_LOCKED(rfa->ri_status)) {
		releaseRfaInfoList(dirname(fn), rfalist);
		fprintf(err,"*** file already locked by %s since %s ***\n",
			rfa->ri_lckname, shortTime(&(rfa->ri_lcksince)));
		CONT(NOTOK_LOCKED);
	    }
	    SET_LOCKINFO(rfa->ri_status, RI_LOCKED);
	    rfa->ri_lckname = strdup(getenv("USER"));
	    (void)time(&(rfa->ri_lcksince));
	    if ((rc = putRfaInfoList(dirname(fn), rfalist)) != OK) {
		releaseRfaInfoList(dirname(fn), rfalist);
		fprintf(err, "*** local file access error : %s ***\n",
			errMsg(rc));
		CONT(NOTOK_FILEACCESS);
	    }
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(out, "locked file %s\n",fn);
	    continue;
	}

	/*--- otherwise we are slave, get from master ---*/
	if (getConnection() != OK)
	    CONT(NOTOK_REMOTE_ERROR);

	if (rfa->ri_mode & S_IFMT & S_IFREG) 
	    if ((rc = getfile_aux(fn, rfa, &rmode)) != OK)  {
		releaseRfaInfoList(dirname(fn), rfalist);
		CONT(NOTOK_REMOTE_ERROR);
	    }

	if ((rma = (struct type_RFA_RequestMasterArg *)
		malloc(sizeof(struct type_RFA_RequestMasterArg))) == NULL) 
	{
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err,"*** local error : no memory ***\n");
	    CONT(NOTOK_LOCAL_ERROR);
	}
	
	rma->filename = str2qb(fn, strlen(fn), 1);
	rma->slaveVersion = rfa->ri_modTime;

	if (invoke(operation_RFA_requestMaster, (caddr_t)rma, (caddr_t *)&rmr, &res)
		== NOTOK) 
	{
	    releaseRfaInfoList(dirname(fn), rfalist);
	    free_RFA_RequestMasterArg(rma);
	    fprintf(err, "*** remote operation invocation failed ***\n");
	    CONT(NOTOK_REMOTE_ERROR);
	}
	if (res != RY_RESULT) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    free_RFA_RequestMasterArg(rma);
	    printError(res, (caddr_t)rmr, &rc);
	    CONT(rc);
	}

	free_RFA_RequestMasterRes(rmr);
	free_RFA_RequestMasterArg(rma);
	SET_LOCKINFO(rfa->ri_status, RI_LOCKED);
	SET_STATUS(rfa->ri_status, RI_MASTER);
	(void)time(&(rfa->ri_lastChange));
	rfa->ri_lckname = strdup(getenv("USER"));
	(void)time(&(rfa->ri_lcksince));
	if ((rc = putRfaInfoList(dirname(fn), rfalist)) != OK) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err, "*** local file access error : %s ***\n", errMsg(rc));
	    fprintf(err,"*** PANIC : can't set local Master status of %s ***\n",
			fn);
	    CONT(NOTOK_FILEACCESS);
	}

	/*--- set owner and group mode to writable ---*/
	if (rmode && (rfa->ri_mode & S_IFMT & S_IFREG)) 
	    if (changeFileMode(fn, rmode, "set write permissions") != OK)
		fprintf(err, "*** %s ***\n", rfaErrStr);

	releaseRfaInfoList(dirname(fn), rfalist);
	fprintf(out, "locked file %s\n",fn);
    }
    RETURN;
}

/*--------------------------------------------------------------*/
/*  master							*/
/*--------------------------------------------------------------*/
do_master(av)
    char **av;
{
    int rc, res;
    struct RfaInfo *rfalist, *rfa, *remoteRfaList, *rrfa;
    char *fn, *shortTime();
    char  buf[512];
    struct type_RFA_RequestMasterRes *rmr;
    struct type_RFA_RequestMasterArg *rma;
    int rmode = 0;

    START;
    for(; *av; av++) {

	/*--- get file Info ---*/
	fn = *av;
	if ((rc = getLocalRfaInfo(&fn, &rfa, &rfalist, 0)) != OK) 
	    CONT(rc);

	/*--- check if not a .rfaexec file ---*/
	if (strcmp(rfa->ri_filename, ".rfaexec") == 0) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err," *** not allowed on file '%s' ***\n",rfa->ri_filename);
	    CONT(NOTOK_NOT_ALLOWED);
	}

	/*--- check if unregistered ---*/
	if (IS_MASTER(rfa->ri_status)) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err," *** file %s is already master version ***\n", fn);
	    CONT(NOTOK_ALREADY_MASTER);
	}

	/*--- check if remote is already master ---*/
	if ((rc = getRemoteRfaInfoList(dirname(fn), &remoteRfaList)) != OK) {
	    if (interactive) {
		fprintf(err, "can't determine remote status, become master");
		fprintf(err, " anyway ? (y/n): ");
		gets(buf);
		if ((*buf != 'y') && (*buf != 'Y')) {
		    releaseRfaInfoList(dirname(fn), rfalist);
		    fprintf(err,"...aborted\n");
		    CONT(NOTOK_REMOTE_ERROR);
		}
	    } else {
		releaseRfaInfoList(dirname(fn), rfalist);
		fprintf(err,"*** can't determine remote status of %s ***\n",fn);
		CONT(NOTOK_REMOTE_ERROR);
	    }
	} else {

	    /*--- consistency checks ---*/
	    if (rrfa = findRfaInfo(basename(fn), remoteRfaList)) {
		if (IS_MASTER(rrfa->ri_status)) {
			
		    /*--- try to become master ---*/
		    if (rfa->ri_mode & S_IFMT & S_IFREG) 
			if ((rc = getfile_aux(fn, rfa, &rmode)) != OK)  {
			    releaseRfaInfoList(dirname(fn), rfalist);
			    freeRfaInfoList(remoteRfaList);
			    CONT(NOTOK_REMOTE_ERROR);
			}

		    if ((rma = (struct type_RFA_RequestMasterArg *)
		      malloc(sizeof(struct type_RFA_RequestMasterArg))) == NULL)
		    {
			releaseRfaInfoList(dirname(fn), rfalist);
			freeRfaInfoList(remoteRfaList);
			fprintf(err,"*** local error : no memory ***\n");
			CONT(NOTOK_LOCAL_ERROR);
		    }
			    
		    rma->filename = str2qb(fn, strlen(fn), 1);
		    rma->slaveVersion = rfa->ri_modTime;

		    if (invoke(operation_RFA_requestMaster, (caddr_t) rma, 
			(caddr_t *)&rmr, &res) ==NOTOK)
		    {
			releaseRfaInfoList(dirname(fn), rfalist);
			free_RFA_RequestMasterArg(rma);
			freeRfaInfoList(remoteRfaList);
			fprintf(err,
				"*** remote operation invocation failed ***\n");
			CONT(NOTOK_REMOTE_ERROR);
		    }
		    if (res != RY_RESULT) {
			releaseRfaInfoList(dirname(fn), rfalist);
			free_RFA_RequestMasterArg(rma);
			printError(res, (caddr_t)rmr, &rc);
			CONT(rc);
		    }
		    free_RFA_RequestMasterArg(rma);
		    free_RFA_RequestMasterRes(rmr);
		}
		if (IS_SLAVE(rrfa->ri_status)) {
		    if (interactive) {
			fprintf(err, "remote version is already slave, become");
			fprintf(err, " master anyway ? (y/n): ");
			gets(buf);
			if ((*buf != 'y') && (*buf != 'Y')) {
			    releaseRfaInfoList(dirname(fn), rfalist);
			    freeRfaInfoList(remoteRfaList);
			    fprintf(err,"...aborted\n");
			    CONT(NOTOK_REMOTE_ERROR);
			}
		    } else {
			releaseRfaInfoList(dirname(fn), rfalist);
			freeRfaInfoList(remoteRfaList);
			fprintf(err,
			  "*** remote version of %s is already slave ***\n",fn);
			CONT(NOTOK_REMOTE_ERROR);
		    }
		}
	    }
	    freeRfaInfoList(remoteRfaList);
	}

	if (IS_UNREGISTERED(rfa->ri_status))
	    SET_TRANSFER(rfa->ri_status, default_transfer);
	SET_STATUS(rfa->ri_status, RI_MASTER);
	time(&(rfa->ri_lastChange));
	if ((rc = putRfaInfoList(dirname(fn), rfalist)) != OK) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err, "*** local file access error : %s ***\n", errMsg(rc));
	    CONT(NOTOK_FILEACCESS);
	}

	/*--- set owner and group mode to writable ---*/
	if (rmode && (rrfa->ri_mode & S_IFMT & S_IFREG)) 
	    if (changeFileMode(fn, rmode, "set write permissions") != OK)
		fprintf(err, "*** %s ***\n", rfaErrStr);

	releaseRfaInfoList(dirname(fn), rfalist);
	fprintf(out, "changed local version of %s to MASTER\n",fn);
    }
    RETURN;
}

/*--------------------------------------------------------------*/
/* slave							*/
/*--------------------------------------------------------------*/
do_slave(av)
    char **av;
{
    int rc;
    struct RfaInfo *rfalist, *rfa, *remoteRfaList, *rrfa;
    char *fn, *shortTime();
    char  buf[512];

    START;
    for(; *av; av++) {

	/*--- get file Info ---*/
	fn = *av;
	if ((rc = getLocalRfaInfo(&fn, &rfa, &rfalist, 0)) != OK) 
	    CONT(rc);

	/*--- check if not a .rfaexec file ---*/
	if (strcmp(rfa->ri_filename, ".rfaexec") == 0) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err," *** not allowed on file '%s' ***\n",rfa->ri_filename);
	    CONT(NOTOK_NOT_ALLOWED);
	}

	/*--- check if unregistered ---*/
	if (IS_SLAVE(rfa->ri_status)) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err," *** file %s already is slave version ***\n", fn);
	    CONT(NOTOK_ALREADY_SLAVE);
	}

	/*--- check if unregistered ---*/
	if (IS_LOCKED(rfa->ri_status)) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err," *** file %s is currently locked ***\n", fn);
	    CONT(NOTOK_LOCKED);
	}

	/*--- check if remote is already master ---*/
	if ((rc = getRemoteRfaInfoList(dirname(fn), &remoteRfaList)) != OK) {
	    if (interactive) {
		fprintf(err, "can't determine remote status, become slave");
		fprintf(err, " anyway ? (y/n): ");
		gets(buf);
		if ((*buf != 'y') && (*buf != 'Y')) {
		    releaseRfaInfoList(dirname(fn), rfalist);
		    fprintf(err,"...aborted\n");
		    CONT(NOTOK_REMOTE_ERROR);
		}
	    } else {
		releaseRfaInfoList(dirname(fn), rfalist);
		fprintf(err,"*** can't determine remote status of %s ***\n",fn);
		CONT(NOTOK_REMOTE_ERROR);
	    }
	} else {

	    /*--- consistency checks ---*/
	    if (rrfa = findRfaInfo(basename(fn), remoteRfaList)) {
		if (!IS_MASTER(rrfa->ri_status)) {
		    releaseRfaInfoList(dirname(fn), rfalist);
		    freeRfaInfoList(remoteRfaList);
		    fprintf(err, 
			"*** remote site is not master for file %s ***\n", fn);
		    CONT(NOTOK_REMOTE_NOT_MASTER);
		}
		if (((rfa->ri_mode & S_IFMT & S_IFDIR) == 0) 
	    	   && (rrfa->ri_modTime < rfa->ri_modTime)) {
		    releaseRfaInfoList(dirname(fn), rfalist);
		    freeRfaInfoList(remoteRfaList);
		    fprintf(err,"*** remote master version of %s would be", fn);
		    fprintf(err, " older than local slave version ***\n");
		    CONT(NOTOK_REMOTE_MASTER_OLDER);
		}
	    } else {
		releaseRfaInfoList(dirname(fn), rfalist);
		freeRfaInfoList(remoteRfaList);
		fprintf(err, 
			"*** remote site is not master for file %s ***\n", fn);
		CONT(NOTOK_REMOTE_NOT_MASTER);
	    }
	    (void)freeRfaInfoList(remoteRfaList);
	}

	if ((rfa->ri_mode & S_IFMT & S_IFDIR) == 0)
	    if (makeFileReadOnly(fn, rfa) != OK)
		fprintf(err, "*** %s ***\n", rfaErrStr);

	SET_LOCKINFO(rfa->ri_status, RI_UNLOCKED);
	if (IS_UNREGISTERED(rfa->ri_status))
	    SET_TRANSFER(rfa->ri_status, default_transfer);
	SET_STATUS(rfa->ri_status, RI_SLAVE);
	(void)time(&(rfa->ri_lastChange));

	if ((rc = putRfaInfoList(dirname(fn), rfalist)) != OK) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err, "*** local file access error : %s ***\n", errMsg(rc));
	    CONT(NOTOK_FILEACCESS);
	}
	releaseRfaInfoList(dirname(fn), rfalist);
	fprintf(out, "changed local version of %s to SLAVE\n",fn);
    }
    RETURN;
}

/*--------------------------------------------------------------*/
/* unregister							*/
/*--------------------------------------------------------------*/
do_unregister(av)
    char **av;
{
    int rc;
    struct RfaInfo *rfalist, *rfa;
    char *fn;

    START;
    for(; *av; av++) {

	/*--- get file Info ---*/
	fn = *av;
	if ((rc = getLocalRfaInfo(&fn, &rfa, &rfalist, 0)) != OK) 
	    CONT(rc);

	/*--- check if unregistered ---*/
	if (IS_UNREGISTERED(rfa->ri_status)) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err," *** file %s already is unregistered ***\n", fn);
	    CONT(NOTOK_ALREADY_UNREG);
	}

	/*--- check if locked ---*/
	if (IS_LOCKED(rfa->ri_status)) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err," *** file %s is currently locked ***\n", fn);
	    CONT(NOTOK_LOCKED);
	}

	if ((rfa->ri_mode & S_IFMT & S_IFDIR) == 0)
	    if (makeFileReadWrite(fn, rfa) != OK)
		fprintf(err, "*** %s ***\n", rfaErrStr);

	SET_LOCKINFO(rfa->ri_status, RI_UNLOCKED);
	SET_TRANSFER(rfa->ri_status, RI_TR_REQ);
	SET_STATUS(rfa->ri_status, RI_UNREGISTERED);
	(void)time(&(rfa->ri_lastChange));

	if ((rc = putRfaInfoList(dirname(fn), rfalist)) != OK) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err, "*** local file access error : %s ***\n", errMsg(rc));
	    CONT(NOTOK_FILEACCESS);
	}
	releaseRfaInfoList(dirname(fn), rfalist);
	fprintf(out, "changed local version of %s to UNREGISTERED\n",fn);
    }
    RETURN;
}


/*--------------------------------------------------------------*/
/*  rsyncdir							*/
/*--------------------------------------------------------------*/
do_rsyncdir(av)
    char **av;
{
    char *fn;
    int rc;

    if (*av == NULL) {
	*av = "";
	*(av+1) = NULL;
    }
    START;
    for(; *av; av++) {
	if((fn = getRfaContext(cwd_remote, *av)) == NULL) {