rfa.c

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

	    fprintf(err,
		"*** local file access error : not within RFA subtree %s ***\n",
		fsBase);
	    CONT(NOTOK_OUTOFSUBTREE);
	}
	if ((fn = expandSymLinks(fn)) == NULL) {
	    fprintf(err, "*** local file access error : %s ***\n", rfaErrStr);
	    CONT(NOTOK_OUTOFSUBTREE);
	}
	if((rc = syncDir(fn, 1)) != OK)
	    CONT(rc);
    }
    RETURN;
}


/*--------------------------------------------------------------*/
/*  syncdir							*/
/*--------------------------------------------------------------*/
do_syncdir(av)
    char **av;
{
    int rc;
    char *fn;

    if (*av == NULL) {
	*av = "";
	*(av+1) = NULL;
    }

    START;
    for(; *av; av++) {
	if((fn = getRfaContext(cwd_remote, *av)) == NULL) {
	    fprintf(err,
		"*** local file access error : not within RFA subtree %s ***\n",
		fsBase);
	    CONT(NOTOK_OUTOFSUBTREE);
	}
	if ((fn = expandSymLinks(fn)) == NULL) {
	    fprintf(err, "*** local file access error : %s ***\n", rfaErrStr);
	    CONT(NOTOK_OUTOFSUBTREE);
	}

	if((rc = syncDir(fn, 0)) != OK)
	    CONT(rc);
    }
    RETURN;
}


/*--------------------------------------------------------------*/
/*  settransfer							*/
/*--------------------------------------------------------------*/
do_setreq(av)
    char **av;
{ do_settransfer(av, RI_TR_REQ); }

do_setauto(av)
    char **av;
{ do_settransfer(av, RI_TR_AUTO); }

do_settransfer(av, mode)
    char **av;
    int mode;
{
    int rc;
    struct RfaInfo *rfalist, *rfa;
    char *fn, *shortTime();

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

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

	SET_TRANSFER(rfa->ri_status, mode);

	if ((rc = putRfaInfoList(dirname(fn), rfalist)) != OK) {
	    releaseRfaInfoList(dirname(fn), rfalist);
	    fprintf(err, "*** local file access error : %s ***\n", errMsg(rc));
	    CONT(NOTOK_FILEACCESS);
	}
	(void)releaseRfaInfoList(dirname(fn), rfalist);
	fprintf(out, "set transfer mode to %s for file %s\n",
		mode == RI_TR_AUTO ? "AUTOMATIC" : "REQUEST", fn);
    }
    RETURN;
}


/*--------------------------------------------------------------*/
/*  Print WD							*/
/*--------------------------------------------------------------*/
do_pwd(av)
    char **av;
{
    fprintf(out,"working directory: %s\n",*cwd_remote? cwd_remote : "/");
}

/*--------------------------------------------------------------*/
/*  Change Dir							*/
/*--------------------------------------------------------------*/
do_changeDir(av)
    char **av;
{
    register char *s, *r, *fn = *av;

    if (fn == NULL) {
	*cwd_remote = '\0';
	return OK;
    }
    if (*fn == '@')  {
	*cwd_remote = '\0';
	fn++;
    }

    for (s = strtok(fn, "/"); s; s = strtok(NULL, "/")) {
	if (strcmp(s, ".") == 0)
	    continue;
	if (strcmp(s, "..") == 0) {
	    if (*cwd_remote) 
		if ( r = rindex(cwd_remote, '/'))
		    *r = '\0';
		else
		    *cwd_remote = '\0';
	    continue;
	}
	strcat(cwd_remote, "/");
	strcat(cwd_remote, s);
    }
    return OK;
}

/*--------------------------------------------------------------*/
/*  timesync							*/
/*--------------------------------------------------------------*/
int do_timesync(av)
    char **av;
{
    struct type_RFA_SyncTimeArg sta;
    struct type_RFA_SyncTimeRes *str;
    int res, rc;
    time_t rt, lt, dt;
    char buf[BUFSIZ];

    if (getConnection() != OK)  {
	return NOTOK_REMOTE_ERROR;
    }

    if (timeSlave) {
	sta.role = int_RFA_role_slave;
	sta.time = 0;
    } else {
	sta.role = int_RFA_role_master;
	(void)time(&(sta.time));
	sta.time += SENDTIME_DELAY;
    }
    if (invoke(operation_RFA_syncTime, (caddr_t)&sta, (caddr_t *)&str, &res)
	    ==NOTOK) 
    {
	fprintf(err, "*** remote operation invocation failed ***\n");
	return (NOTOK_REMOTE_ERROR);
    }
    time(&lt);

    if (res != RY_RESULT) {
	printError(res, (caddr_t)str, &rc);
	return rc;
    }
    rt = str->parm;
    free_RFA_SyncTimeRes(str);
    if (timeSlave) {
	if (dt = rt - lt) {
	    if (changeTime(dt) != OK) {
		fprintf(err, "*** %s ***\n", rfaErrStr);
		sprintf(buf, "%s/rfatime %ld", isodesbinpath, dt);
		if (system(buf) != OK)  {
		    fprintf(err, "*** %s ***\n", rfaErrStr);
		    return NOTOK_LOCAL_ERROR;
		}
	    }
	    if(dt > 0)
		fprintf(out, "advanced local time by %ld sec\n", dt);
	    else
		fprintf(out, "retarding local time by %ld sec\n", dt);
	}
    } else {
	if(rt > 0)
	    fprintf(out, "remote site advanced local time by %ld sec\n", rt);
	else
	    if (rt < 0)
		fprintf(out,"remote site is retarding local time by %ld sec\n",rt);
    }
    return OK;
}

/*--------------------------------------------------------------*/
/*  quit							*/
/*--------------------------------------------------------------*/
int do_quit(av)
    char **av;
{
    quit_command++;
}


/*--------------------------------------------------------------*/
/*  Execute Command						*/
/*--------------------------------------------------------------*/
int executeCommand(cmd)
    char *cmd;
{
    char **ap, *aps[BUFSIZ];
    static struct cmd {
	char	*n;
	int	(*f)();
	char 	*h;
    } cmds[] = {
	{ "get",	do_getFile,
	  "update a local SLAVE file according to the remote MASTER"},
	{ "lock",	do_lockFile,
	  "request lock for a local file"},
	{ "unlock",	do_unlockFile,
	  "release lock for a local file"},
	{ "rlist",	do_listDir,
	  "list files in the remote directory"},
	{ "list",		do_localListDir,
	  "list files in a local directory"},
	{ "pwd",	do_pwd,
	  "print the current directory path"},
	{ "cd",		do_changeDir,
	  "change the current directory path"},
	{ "master",	do_master,
	  "make a local file a MASTER version"},
	{ "slave",	do_slave,	
	  "make a local file a SLAVE version"},
	{ "unregister",	do_unregister,	
	  "unregister a previously MASTER or SLAVE file"},
	{ "setreq",	do_setreq,	
	  "set file transfer mode to 'request'"},
	{ "setauto",	do_setauto,	
	  "set file transfer mode to 'automatic'"},
	{ "syncdir",	do_syncdir, 
	  "synchronize files in a directory with the remote site"},
	{ "rsyncdir",	do_rsyncdir,   
	  "recursively synchronize files in a directory with the remote site"},
	{ "timesync",	do_timesync,   
	  "syncronize local time with masters clock"},
	{ "quit",	do_quit,   
	  "terminate RFA session"},
	{ "exit",	do_quit,   
	  "terminate RFA session"},
	{ NULL,		NULL,		NULL			} 
    }, *cmdp, *fc;


    aps[0] = strtok (cmd, " ");
    for (ap = aps+1; *ap = strtok(NULL," "); ap++)
	    ;

    if (aps[0]) {
	if ((strncmp(*aps, "h", 1) == 0) || (strncmp(*aps, "?", 1) == 0)) {
	    for (cmdp = cmds; cmdp->n; cmdp++) 
	       fprintf(out,"%8.8s - %s\n", cmdp->n, cmdp->h);
	    return NOTOK;
	}
	    
	fc = NULL;
	for (cmdp = cmds; cmdp->n; cmdp++) 
	    if (strncmp(cmdp->n, *aps, strlen(*aps)) == 0)  {
		if (fc) {
		    fprintf(stderr,"command '%s' ambiguous, use one of\n",*aps);
		    for (cmdp = cmds; cmdp->n; cmdp++) 
			if (strncmp(cmdp->n, *aps, strlen(*aps)) == 0) 
			   fprintf(out,"    %8.8s - %s\n", cmdp->n, cmdp->h);
		    return NOTOK;
		}
		fc = cmdp;
	    }
	if (fc == NULL) {
	    fprintf(err, "unknown command: %s\n",*aps);
	    return NOTOK;
	}

	if (fc->f)
	    return (*(fc->f))(aps+1);
	else
	    return NOTOK;

    }
    return OK;
}

cleanup()
{
}


int getConnection()
{
    if (connected)
	return OK;
    if (makeconn(host, passwd, user) == NOTOK)  {
	fprintf(err,"*** provider error: can't establish connection to %s ***\n"
		, host);
	return NOTOK;
    }
    connected = 1;
    return OK;
}


main (ac, av) 
int ac;
char **av;
{
    char c, buf[BUFSIZ];
    extern char *optarg;
    extern int optind;
    char *cmd=NULL;
    int rc;

    host = "localhost";
    myname = av[0];

    out = stdout;
    err = stderr;

    isodetailor (myname, 1);

    /*-- create log file --*/
    initLog(myname);

    /*--- rfa tailoring ---*/
    sprintf(buf, "%s/rfatailor", isodetcpath);
    if (tailor(buf) != OK) {
	fprintf(stderr,"*** tailoring of file '%s' failed:%s\n",buf, rfaErrStr);
	exit(NOTOK_LOCAL_ERROR);
    }
    sprintf(buf,"%s/.rfarc", getenv("HOME"));
    if (tailor(buf) != OK) {
	fprintf(stderr,"*** tailoring of file '%s' failed:%s\n",buf, rfaErrStr);
	exit(NOTOK_LOCAL_ERROR);
    }

    while ((c = getopt(ac, av, "qu:p:c:h:")) != -1)
	switch (c) {
	    case 'u': 
		user = optarg;
		break;
	    case 'p':
		passwd = optarg;
		break;
	    case 'c':
		cmd = optarg;
		break;
	    case 'h':
		host = optarg;
		break;
	    case 'q':
		out = fopen("/dev/null", "w");
		interactive = 0;
		break;
	    case '?':
		fprintf(stderr, "USAGE: %s [-h  hostname] [-u user] [-p password] [-c command] [ -q ]\n", basename(myname));
		exit(NOTOK_LOCAL_ERROR);
	}
    
    /*-- set uid, gid --*/
    if (initUserId(getuid(), getgid(), "") != OK)
	fprintf(err, "*** %s ***\n", rfaErrStr);

    /*--- init cwd ---*/
    getwd(buf);
    if (strncmp(buf, fsBase, strlen(fsBase)) == 0) 
	strcpy(cwd_remote, buf + strlen(fsBase));

    if (cmd) {
	commandMode = 1;
	rc = executeCommand(cmd);
	if (connected)
	    closeconn();
	exit(rc);
    } 

    while (! quit_command) {
	printf("rfa-%s@%s> ", user, host);
	gets(buf);
	executeCommand(buf);
    }
    if (connected)
	closeconn();
    exit (0);
}