Initial import of the CDE 2.1.30 sources from the Open Group.
This commit is contained in:
Peter Howkins
966
cde/programs/dtfile/dtcopy/dosync.c
Normal file
966
cde/programs/dtfile/dtcopy/dosync.c
Normal file
@@ -0,0 +1,966 @@
|
||||
/* $TOG: dosync.c /main/6 1998/10/26 12:40:53 mgreess $ */
|
||||
/************************************<+>*************************************
|
||||
****************************************************************************
|
||||
*
|
||||
* FILE: dosync.c
|
||||
*
|
||||
*
|
||||
* DESCRIPTION: Routines synchronizing directories
|
||||
*
|
||||
* FUNCTIONS: CONFIRM
|
||||
* CmpPred
|
||||
* DTYPE
|
||||
* DirCmp
|
||||
* DirCmp2
|
||||
* DumpDir
|
||||
* ERROR_CHECK
|
||||
* FreeDir
|
||||
* GetDir
|
||||
* GetDirEntry
|
||||
* SortDir
|
||||
* SyncDirRecur
|
||||
* SyncDirectory
|
||||
* SyncItem
|
||||
* cmpSymlink
|
||||
* dirEraseCallback
|
||||
* dirErrorCallback
|
||||
* doCopy
|
||||
* doCopyLink
|
||||
* doMkdir
|
||||
* doSymlink
|
||||
* doUnlink
|
||||
* targetLink
|
||||
*
|
||||
* (c) Copyright 1993, 1994, 1995 Hewlett-Packard Company
|
||||
* (c) Copyright 1993, 1994, 1995 International Business Machines Corp.
|
||||
* (c) Copyright 1993, 1994, 1995 Sun Microsystems, Inc.
|
||||
* (c) Copyright 1993, 1994, 1995 Novell, Inc.
|
||||
*
|
||||
****************************************************************************
|
||||
************************************<+>*************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <assert.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/time.h>
|
||||
#include <dirent.h>
|
||||
#include <sys/file.h>
|
||||
#include "fsrtns.h"
|
||||
#ifdef PATRTNS
|
||||
#include "patrtns.h"
|
||||
#endif
|
||||
#include "dosync.h"
|
||||
|
||||
/*--------------------------------------------------------------------
|
||||
* global variables
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
char *FileOpNames[] = {
|
||||
"synchronize",
|
||||
"opendir",
|
||||
"lstat",
|
||||
"stat",
|
||||
"readlink",
|
||||
"delete",
|
||||
"copy",
|
||||
"mkdir",
|
||||
"copy link",
|
||||
"make link",
|
||||
"working",
|
||||
"is a copy",
|
||||
"is a link"
|
||||
};
|
||||
|
||||
|
||||
int (*syncConfirmCallback)(FileOp op,
|
||||
char *sname, int stype,
|
||||
char *tname, int ttype,
|
||||
char *link) = NULL;
|
||||
int (*syncErrorCallback)(FileOp op, char *fname, int errnum) = NULL;
|
||||
|
||||
|
||||
static SyncParams *SP;
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------
|
||||
* macros for invoking callback functions
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
#define DTYPE(delP) ((delP)? (delP)->ftype: ft_noent)
|
||||
|
||||
#define CONFIRM(op, sn, st, tn, tt, l, rc) \
|
||||
if (periodicCallback && (*periodicCallback)() != 0) return -1; \
|
||||
else if (syncConfirmCallback && \
|
||||
(rc = syncConfirmCallback(op, sn, st, tn, tt, l)) != 0) return rc; else
|
||||
|
||||
#define ERROR_CHECK(op, f, rc) \
|
||||
if (rc < 0 || rc && syncErrorCallback && syncErrorCallback(op, f, rc) < 0) \
|
||||
return -1; else
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------
|
||||
* reading directories
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
/* structure containing information anout a directory entry */
|
||||
typedef struct de {
|
||||
char name[256]; /* file name */
|
||||
int rc, lrc; /* return codes from stat, lstat */
|
||||
struct stat stat; /* stat */
|
||||
int ftype; /* file type flags (see #defines in dosync.h) */
|
||||
char exclude, skip; /* exclude, skip flags */
|
||||
char *link; /* value of symbolic link */
|
||||
struct de *teP; /* source dir: points to correspond. target dir entry */
|
||||
struct de *next; /* next directory entry */
|
||||
} DirEntry;
|
||||
|
||||
|
||||
/*
|
||||
* DumpDir: dump linked list of directory entries to stdout (debugging only)
|
||||
*/
|
||||
static void
|
||||
DumpDir(DirEntry *dP)
|
||||
{
|
||||
DirEntry *eP;
|
||||
|
||||
for (eP = dP; eP; eP = eP->next)
|
||||
printf(" %-15s %2d %c %c %c %c %c %s\n",
|
||||
eP->name,
|
||||
eP->rc,
|
||||
(eP->ftype & ft_isdir)? 'D': ' ',
|
||||
(eP->ftype & ft_islnk)? 'L': ' ',
|
||||
eP->exclude? 'X': ' ',
|
||||
eP->skip? 'S': ' ',
|
||||
eP->teP? 'F': ' ',
|
||||
eP->link? eP->link: "");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* DirCmp: compare function for sorting directory entries
|
||||
*/
|
||||
static int
|
||||
DirCmp(const void *p1, const void *p2)
|
||||
{
|
||||
return strcmp((*(DirEntry **)p1)->name, (*(DirEntry **)p2)->name);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* SortDir: sort linked list of directory entries by name
|
||||
*/
|
||||
static DirEntry *
|
||||
SortDir(DirEntry *dP, int (*cmp)(const void*, const void*))
|
||||
{
|
||||
int i, n;
|
||||
DirEntry *eP, **linkPP;
|
||||
DirEntry *da[1024], **daP;
|
||||
|
||||
/* count number of directory entries */
|
||||
n = 0;
|
||||
for (eP = dP; eP; eP = eP->next)
|
||||
n++;
|
||||
if (n < 2)
|
||||
return dP;
|
||||
|
||||
/* allocate pointer array */
|
||||
if (n <= 1024)
|
||||
daP = da;
|
||||
else
|
||||
daP = (DirEntry **)malloc(n * sizeof(DirEntry *));
|
||||
|
||||
/* sort pointer array */
|
||||
for (eP = dP, i = 0; eP; eP = eP->next, i++)
|
||||
daP[i] = eP;
|
||||
qsort(daP, n, sizeof(DirEntry *), cmp);
|
||||
|
||||
/* re-link the linked list */
|
||||
linkPP = &dP;
|
||||
for (i = 0; i < n; i++) {
|
||||
*linkPP = daP[i];
|
||||
linkPP = &(*linkPP)->next;
|
||||
}
|
||||
*linkPP = NULL;
|
||||
|
||||
/* free pointer array */
|
||||
if (daP != da)
|
||||
free(daP);
|
||||
|
||||
return dP;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* FreeDir: de-allocate linked list of directory entries
|
||||
*/
|
||||
static void
|
||||
FreeDir(DirEntry *deP)
|
||||
{
|
||||
DirEntry *nextP;
|
||||
|
||||
while (deP) {
|
||||
nextP = deP->next;
|
||||
free(deP);
|
||||
deP = nextP;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* GetDirEntry: Get information about one directory entry.
|
||||
* If an error occurs, returns the errno in *rc and the operation
|
||||
* that failed (op_lstat, op_stat, or op_readlink) in *op.
|
||||
*/
|
||||
static DirEntry *
|
||||
GetDirEntry(char *fname, FileOp *op, int *rc)
|
||||
{
|
||||
DirEntry *deP;
|
||||
char *p;
|
||||
char link[1024];
|
||||
int l;
|
||||
|
||||
/* allocate new DirEntry */
|
||||
deP = (DirEntry *)malloc(sizeof(DirEntry));
|
||||
memset(deP, 0, sizeof(DirEntry));
|
||||
|
||||
/* get file name */
|
||||
p = strrchr(fname, '/');
|
||||
if (p && p > fname)
|
||||
strcpy(deP->name, p + 1);
|
||||
else
|
||||
strcpy(deP->name, fname);
|
||||
|
||||
/* assume everything is fine */
|
||||
*op = 0;
|
||||
*rc = 0;
|
||||
|
||||
/* get information */
|
||||
deP->rc = lstat(fname, &deP->stat);
|
||||
if (deP->rc) {
|
||||
*op = op_lstat;
|
||||
*rc = errno;
|
||||
} else if ((deP->stat.st_mode & S_IFMT) == S_IFDIR)
|
||||
deP->ftype |= ft_isdir;
|
||||
else if ((deP->stat.st_mode & S_IFMT) == S_IFLNK) {
|
||||
deP->ftype |= ft_islnk;
|
||||
deP->lrc = stat(fname, &deP->stat);
|
||||
if (deP->lrc) {
|
||||
if (errno != ENOENT) {
|
||||
*op = op_stat;
|
||||
*rc = errno;
|
||||
}
|
||||
} else if ((deP->stat.st_mode & S_IFMT) == S_IFDIR)
|
||||
deP->ftype |= ft_isdir;
|
||||
l = readlink(fname, link, sizeof(link) - 1);
|
||||
if (l < 0) {
|
||||
*op = op_readlink;
|
||||
*rc = errno;
|
||||
} else {
|
||||
link[l] = 0;
|
||||
deP->link = strdup(link);
|
||||
}
|
||||
}
|
||||
|
||||
return deP;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* GetDir: read a directory and return linked list of directory entries
|
||||
*/
|
||||
static int
|
||||
GetDir(char *dirname, PatternList *xl, PatternList *sl, DirEntry **listPP)
|
||||
{
|
||||
DIR *dirP; /* open directory */
|
||||
struct dirent *entryP; /* directory entry */
|
||||
DirEntry *deP, *firstP, **linkPP;
|
||||
char fname[1024], *fnP;
|
||||
PatternList *pl;
|
||||
FileOp op;
|
||||
int rc;
|
||||
|
||||
|
||||
/* open directory */
|
||||
dirP = opendir(dirname);
|
||||
if (dirP == NULL) {
|
||||
rc = errno;
|
||||
if (syncErrorCallback &&
|
||||
syncErrorCallback(op_opendir, dirname, rc) < 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* copy dirname to file name buffer */
|
||||
strcpy(fname, dirname);
|
||||
fnP = fname + strlen(fname);
|
||||
*fnP++ = '/';
|
||||
|
||||
/* initialize linked list */
|
||||
firstP = NULL;
|
||||
linkPP = &firstP;
|
||||
|
||||
/* read the directory */
|
||||
while ((entryP = readdir(dirP)) != NULL) {
|
||||
/* skip . and .. */
|
||||
if (strcmp(entryP->d_name, ".") == 0 || strcmp(entryP->d_name, "..") == 0)
|
||||
continue;
|
||||
|
||||
/* get new DirEntry */
|
||||
strcpy(fnP, entryP->d_name);
|
||||
deP = GetDirEntry(fname, &op, &rc);
|
||||
|
||||
/* add to linked list */
|
||||
*linkPP = deP;
|
||||
linkPP = &deP->next;
|
||||
|
||||
/* if error occurred, call error callback function */
|
||||
if (rc != 0 && syncErrorCallback && syncErrorCallback(op, fname, rc) < 0) {
|
||||
FreeDir(firstP);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* check exclude and skip list */
|
||||
#ifdef PATRTNS
|
||||
for (pl = xl ; pl; pl = pl->next)
|
||||
if (MatchPattern(pl->pattern, fname))
|
||||
deP->exclude++;
|
||||
|
||||
for (pl = sl; pl; pl = pl->next)
|
||||
if (MatchPattern(pl->pattern, fname))
|
||||
deP->skip++;
|
||||
#endif
|
||||
}
|
||||
|
||||
closedir(dirP);
|
||||
*listPP = SortDir(firstP, DirCmp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------
|
||||
* file operations
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
static int erase_rc;
|
||||
|
||||
/*
|
||||
* dirEraseCallback: used in doUnlink (below) for confirmation
|
||||
* during recursive directory deletes
|
||||
*/
|
||||
static int
|
||||
dirEraseCallback(char *fname)
|
||||
{
|
||||
erase_rc = syncConfirmCallback(op_delete, "", ft_noent, fname, 0, "");
|
||||
return erase_rc;
|
||||
}
|
||||
|
||||
static int
|
||||
dirErrorCallback(char *fname, int errnum)
|
||||
{
|
||||
erase_rc = syncErrorCallback(op_delete, fname, errnum);
|
||||
return erase_rc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* doUnlink: delete a file from the target directory
|
||||
*/
|
||||
static int
|
||||
doUnlink(char *fname, DirEntry *fP, int confirm)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (confirm)
|
||||
CONFIRM(op_delete, "", ft_noent, fname, fP->ftype, "", rc);
|
||||
|
||||
if (SP->dontdoit)
|
||||
rc = 0;
|
||||
|
||||
else if (SP->keepold) {
|
||||
char newname[1024];
|
||||
|
||||
strcpy(newname, fname);
|
||||
strcat(newname, SP->keepold);
|
||||
fsMove(fname, newname, 1, &rc);
|
||||
|
||||
} else if ((fP->ftype & ft_isdir) && !(fP->ftype & ft_islnk)) {
|
||||
/* arrange for syncConfirmCallback's during recursive directory deletes */
|
||||
erase_rc = 0;
|
||||
if (syncErrorCallback)
|
||||
errorCallback = dirErrorCallback;
|
||||
if (syncConfirmCallback)
|
||||
progressCallback = dirEraseCallback;
|
||||
|
||||
fsErase(fname, &rc, 1);
|
||||
if (rc < 0 && erase_rc)
|
||||
rc = ENOTEMPTY;
|
||||
|
||||
errorCallback = NULL;
|
||||
progressCallback = NULL;
|
||||
|
||||
} else
|
||||
rc = (unlink(fname) != 0)? errno: 0;
|
||||
|
||||
/* check for errors */
|
||||
ERROR_CHECK(op_delete, fname, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* doCopy: copy a file from the source to target directory
|
||||
*/
|
||||
static int
|
||||
doCopy(char *sname, DirEntry *sP, char *tname, DirEntry *delP)
|
||||
{
|
||||
int rc;
|
||||
|
||||
/* display message */
|
||||
CONFIRM(op_copy, sname, sP->ftype, tname, DTYPE(delP), "", rc);
|
||||
|
||||
/* if necessary, delete target */
|
||||
if (delP && !SP->dontdoit)
|
||||
if ((rc = doUnlink(tname, delP, 0)) != 0)
|
||||
return rc;
|
||||
|
||||
/* copy the file */
|
||||
if (SP->dontdoit)
|
||||
rc = 0;
|
||||
else
|
||||
fsCopy(sname, tname, 0, &rc);
|
||||
|
||||
/* check for errors */
|
||||
ERROR_CHECK(op_copy, sname, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* doMkdir: create a new sub directory in the target directory
|
||||
*/
|
||||
static int
|
||||
doMkdir(char *sname, DirEntry *sP, char *tname, DirEntry *delP)
|
||||
{
|
||||
int rc;
|
||||
|
||||
/* display message */
|
||||
CONFIRM(op_mkdir, sname, sP->ftype, tname, DTYPE(delP), "", rc);
|
||||
|
||||
/* if necessary, delete target */
|
||||
if (delP && !SP->dontdoit)
|
||||
if ((rc = doUnlink(tname, delP, 0)) != 0)
|
||||
return rc;
|
||||
|
||||
/* make a new directory */
|
||||
rc = SP->dontdoit? 0: (mkdir(tname, sP->stat.st_mode & 07777) < 0)? errno: 0;
|
||||
|
||||
/* check for errors */
|
||||
ERROR_CHECK(op_mkdir, tname, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* targetLink: lookup symbloc link in the maplink list
|
||||
*/
|
||||
static void
|
||||
targetLink(char *source, char *target, char **tlPP, char **msgPP)
|
||||
/*
|
||||
*
|
||||
*/
|
||||
{
|
||||
static char buf[1024] = " -> ";
|
||||
MapList *ml;
|
||||
int l;
|
||||
|
||||
for (ml = SP->maplink; ml; ml = ml->next) {
|
||||
l = strlen(ml->from);
|
||||
if (strncmp(ml->from, source, l) == 0
|
||||
&& (source[l] == '/' || source[l] == 0))
|
||||
{
|
||||
strcpy(buf + 4, ml->to);
|
||||
if (source[l])
|
||||
strcat(buf, source +l);
|
||||
if (strcmp(buf + 4, target) != 0) {
|
||||
*tlPP = buf + 4;
|
||||
*msgPP = buf;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*tlPP = source;
|
||||
*msgPP = "";
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* doCopyLink: copy a symbolic link from the source to target directory
|
||||
*/
|
||||
static int
|
||||
doCopyLink(char *sname, DirEntry *sP, char *tname, DirEntry *delP)
|
||||
{
|
||||
char *tl, *msg;
|
||||
int rc;
|
||||
|
||||
/* determine where the link should point */
|
||||
targetLink(sP->link, tname, &tl, &msg);
|
||||
|
||||
/* display message */
|
||||
CONFIRM(op_cplink, sname, sP->ftype, tname, DTYPE(delP), msg, rc);
|
||||
|
||||
/* if necessary, delete target */
|
||||
if (delP && !SP->dontdoit)
|
||||
if ((rc = doUnlink(tname, delP, 0)) != 0)
|
||||
return rc;
|
||||
|
||||
/* create link */
|
||||
rc = SP->dontdoit? 0: (symlink(tl, tname) != 0)? errno: 0;
|
||||
|
||||
/* check for errors */
|
||||
ERROR_CHECK(op_cplink, tname, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* doSymlink: create a symbolic link in the target directory to a file
|
||||
* in the source directory
|
||||
*/
|
||||
static int
|
||||
doSymlink(char *sname, DirEntry *sP, char *tname, DirEntry *delP)
|
||||
{
|
||||
char *tl, *msg;
|
||||
int rc;
|
||||
|
||||
/* determine where the link should point */
|
||||
targetLink(sname, tname, &tl, &msg);
|
||||
|
||||
/* display message */
|
||||
CONFIRM(op_mklink, sname, sP->ftype, tname, DTYPE(delP), msg, rc);
|
||||
|
||||
/* if necessary, delete target */
|
||||
if (delP && !SP->dontdoit)
|
||||
if ((rc = doUnlink(tname, delP, 0)) != 0)
|
||||
return rc;
|
||||
|
||||
/* create link */
|
||||
targetLink(sname, tname, &tl, &msg);
|
||||
rc = SP->dontdoit? 0: (symlink(tl, tname) != 0)? errno: 0;
|
||||
|
||||
/* check for errors */
|
||||
ERROR_CHECK(op_mklink, sname, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* cmpSymlink: compare two symbolic links
|
||||
* return values:
|
||||
* -1 error reading one of the links
|
||||
* 0 links point to the same file
|
||||
* 1 tname link points to sname
|
||||
* 2 links point to different files
|
||||
*/
|
||||
static int
|
||||
cmpSymlink(char *sname, DirEntry *seP, char *tname, DirEntry *teP)
|
||||
{
|
||||
char *tl, *msg;
|
||||
|
||||
/* return error if target link could not be read */
|
||||
if (!teP->link)
|
||||
return -1;
|
||||
|
||||
/* check if target link points to source link */
|
||||
if (SP->keeplinks) {
|
||||
targetLink(sname, tname, &tl, &msg);
|
||||
if (strcmp(teP->link, tl) == 0)
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* if source not a symbolic link, target must be pointing to wrong file */
|
||||
if (!(seP->ftype & ft_islnk))
|
||||
return 2;
|
||||
|
||||
/* compare the links */
|
||||
targetLink(seP->link, tname, &tl, &msg);
|
||||
if (strcmp(teP->link, tl) == 0)
|
||||
return 0;
|
||||
else
|
||||
return 2;
|
||||
}
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------
|
||||
* sync directories
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
static int SyncDirRecur(char *sdir, char *tdir);
|
||||
|
||||
|
||||
/*
|
||||
* SyncItem: copy or replace one item from the source to the target directory
|
||||
*/
|
||||
static int
|
||||
SyncItem(char *sname, DirEntry *sP, char *tname, DirEntry *tP)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (periodicCallback && (*periodicCallback)() != 0)
|
||||
return -1;
|
||||
|
||||
if (!tP) {
|
||||
/* target does not exist */
|
||||
|
||||
rpl_target:
|
||||
/*--------------------------------------------------------------------
|
||||
* target does not exist or should be replaced
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
/* check if -dontreplace or -dontadd options apply */
|
||||
if (tP && SP->dontreplace || !tP && SP->dontadd)
|
||||
return 0;
|
||||
|
||||
if (sP->ftype & ft_islnk) {
|
||||
/* source is a link */
|
||||
|
||||
if ((sP->ftype & ft_isdir) && !SP->copydirs ||
|
||||
!(sP->ftype & ft_isdir) && !SP->copyfiles)
|
||||
{
|
||||
/* just copy the link */
|
||||
return doCopyLink(sname, sP, tname, tP);
|
||||
}
|
||||
|
||||
} else {
|
||||
/* source is not a link */
|
||||
|
||||
if ((sP->ftype & ft_isdir) && SP->linkdirs ||
|
||||
!(sP->ftype & ft_isdir) && SP->linkfiles)
|
||||
{
|
||||
/* don't copy; just create a link to the target */
|
||||
return doSymlink(sname, sP, tname, tP);
|
||||
}
|
||||
}
|
||||
|
||||
if (sP->ftype & ft_isdir) {
|
||||
/* source is a dir: create target directory and do recursive sync */
|
||||
rc = doMkdir(sname, sP, tname, tP);
|
||||
if (rc || SP->dontdoit)
|
||||
return rc;
|
||||
else
|
||||
return SyncDirRecur(sname, tname);
|
||||
|
||||
} else
|
||||
/* source is a regular file: copy the file */
|
||||
return doCopy(sname, sP, tname, tP);
|
||||
|
||||
|
||||
} else if (tP->ftype & ft_islnk) {
|
||||
/*--------------------------------------------------------------------
|
||||
* target is a symbolic link
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
if ((tP->ftype & ft_isdir) == (sP->ftype & ft_isdir)) {
|
||||
/*
|
||||
* target points to the right type of object (dir vs regular file):
|
||||
* check if target points to the right place
|
||||
*/
|
||||
rc = cmpSymlink(sname, sP, tname, tP);
|
||||
if (rc < 0)
|
||||
return 1; /* something is wrong */
|
||||
|
||||
if (SP->listlinks && rc == 1)
|
||||
CONFIRM(op_info_link, sname, sP->ftype, tname, tP->ftype, "", rc);
|
||||
|
||||
if (rc < 2)
|
||||
/* target is pointing to the right place */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* target points to the wrong type of object:
|
||||
* delete target link and try again
|
||||
*/
|
||||
goto rpl_target;
|
||||
|
||||
|
||||
} else if (!(tP->ftype & ft_isdir)) {
|
||||
/*--------------------------------------------------------------------
|
||||
* target is regular file
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
if (sP->ftype & ft_isdir)
|
||||
/* source is a dir: delete target file and try again */
|
||||
goto rpl_target;
|
||||
|
||||
else {
|
||||
/* source is regular file or link to regular file */
|
||||
|
||||
if (sP->ftype & ft_islnk) {
|
||||
/* source is just a link */
|
||||
|
||||
if (!SP->keepcopies && !SP->copyfiles)
|
||||
/* replace target by a link */
|
||||
goto rpl_target;
|
||||
|
||||
else if (SP->listcopies)
|
||||
CONFIRM(op_info_copy, sname, sP->ftype, tname, tP->ftype, "", rc);
|
||||
}
|
||||
|
||||
if (!SP->forcecopies &&
|
||||
tP->stat.st_mtime == sP->stat.st_mtime &&
|
||||
tP->stat.st_size == sP->stat.st_size)
|
||||
{
|
||||
/* we assume the file hasn't changed: don't do anything */
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (SP->keepnew && tP->stat.st_mtime > sP->stat.st_mtime)
|
||||
/* we should keep the target because it is newer than the source */
|
||||
return 0;
|
||||
|
||||
/* replace the target file */
|
||||
goto rpl_target;
|
||||
}
|
||||
|
||||
|
||||
} else if (!(tP->ftype & ft_islnk)) {
|
||||
/*--------------------------------------------------------------------
|
||||
* target is a directory
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
if (sP->ftype & ft_isdir) {
|
||||
if (sP->ftype & ft_islnk) {
|
||||
/* source is just a link */
|
||||
|
||||
if (!SP->keepcopies && !SP->copydirs)
|
||||
/* replace target by a link */
|
||||
goto rpl_target;
|
||||
|
||||
else if (SP->listcopies)
|
||||
CONFIRM(op_info_copy, sname, sP->ftype, tname, tP->ftype, "", rc);
|
||||
}
|
||||
|
||||
/* source is dir: recursively sync source and target dirs */
|
||||
return SyncDirRecur(sname, tname);
|
||||
|
||||
} else
|
||||
/* source is no dir: delete target dir and try again */
|
||||
goto rpl_target;
|
||||
}
|
||||
|
||||
/* should never be reached */
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* CmpPred: returns a precedence number that is used to determine in which
|
||||
* order source directory entries are processed:
|
||||
* 1 source is regular file
|
||||
* 2 source is symbolic link
|
||||
* 3 target is not a real directory
|
||||
* 4 target exists and is a real directory (not a sym link)
|
||||
*/
|
||||
static int
|
||||
CmpPred(DirEntry *dP)
|
||||
{
|
||||
if (!(dP->ftype & ft_isdir))
|
||||
return 1;
|
||||
|
||||
else if (dP->ftype & ft_islnk)
|
||||
return 2;
|
||||
|
||||
else if (!dP->teP ||
|
||||
!(dP->teP->ftype & ft_isdir) ||
|
||||
(dP->teP->ftype & ft_islnk))
|
||||
{
|
||||
return 3;
|
||||
|
||||
} else
|
||||
return 4;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* DirCmp2: compare function for sorting directory entries
|
||||
*/
|
||||
static int
|
||||
DirCmp2(const void *p1, const void *p2)
|
||||
{
|
||||
int d = CmpPred(*(DirEntry **)p1) - CmpPred(*(DirEntry **)p2);
|
||||
if (d)
|
||||
return d;
|
||||
else
|
||||
return strcmp((*(DirEntry **)p1)->name, (*(DirEntry **)p2)->name);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* SyncDirRecur: recursively synchronize source and target directories
|
||||
*/
|
||||
static int
|
||||
SyncDirRecur(char *sdir, char *tdir)
|
||||
{
|
||||
DirEntry *sP, *tP, *seP, *teP;
|
||||
char *fsP, *ftP;
|
||||
int rc;
|
||||
|
||||
/* informational callback */
|
||||
if (SP->verbose)
|
||||
CONFIRM(op_sync, sdir, ft_isdir, tdir, ft_isdir, "", rc);
|
||||
|
||||
/* read source and target directories */
|
||||
if ((rc = GetDir(sdir, SP->exclude, SP->skip, &sP)) != 0)
|
||||
return rc;
|
||||
if ((rc = GetDir(tdir, NULL, SP->skip, &tP)) != 0) {
|
||||
FreeDir(sP);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* append "/" to source and target directory names */
|
||||
fsP = sdir + strlen(sdir);
|
||||
ftP = tdir + strlen(tdir);
|
||||
*fsP++ = '/';
|
||||
*ftP++ = '/';
|
||||
|
||||
/* first delete files in target dir that don't exist in source dir */
|
||||
seP = sP;
|
||||
teP = tP;
|
||||
while (teP) {
|
||||
/* compare directory entries */
|
||||
rc = (seP != NULL)? strcmp(seP->name, teP->name): 1;
|
||||
|
||||
if ((seP != NULL) && seP->exclude) {
|
||||
/* skip excluded files */
|
||||
seP = seP->next;
|
||||
|
||||
} else if (rc == 0) {
|
||||
/* file exists in both directories */
|
||||
seP->teP = teP;
|
||||
seP = seP->next;
|
||||
teP = teP->next;
|
||||
|
||||
} else if (rc < 0) {
|
||||
/* source file not in target directory */
|
||||
seP = seP->next;
|
||||
|
||||
} else { /* rc > 0 */
|
||||
/* target file not in source directory */
|
||||
if (!SP->dontdelete && !teP->skip) {
|
||||
strcpy(ftP, teP->name);
|
||||
if (doUnlink(tdir, teP, 1) < 0) {
|
||||
FreeDir(sP);
|
||||
FreeDir(tP);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
teP = teP->next;
|
||||
}
|
||||
}
|
||||
|
||||
/* re-sort source dir so that regular files are processed before sub dirs */
|
||||
sP = SortDir(sP, DirCmp2);
|
||||
|
||||
/* process all entires found in the source directory */
|
||||
for (seP = sP, rc = 0; seP && rc >= 0; seP = seP->next) {
|
||||
/* skip error entries */
|
||||
if (seP->rc)
|
||||
continue;
|
||||
|
||||
/* skip excluded and to-be-skipped files */
|
||||
if (seP->exclude || seP->skip)
|
||||
continue;
|
||||
|
||||
/* also skip sub directories if "don't recur" option is set */
|
||||
if (SP->dontrecur && (seP->ftype & ft_isdir))
|
||||
continue;
|
||||
|
||||
/* construct source and target file names */
|
||||
strcpy(fsP, seP->name);
|
||||
strcpy(ftP, seP->name);
|
||||
|
||||
/* sync directory item */
|
||||
rc = SyncItem(sdir, seP, tdir, seP->teP);
|
||||
}
|
||||
|
||||
/* free directory lists */
|
||||
FreeDir(sP);
|
||||
FreeDir(tP);
|
||||
|
||||
return (rc < 0)? -1: 0;
|
||||
}
|
||||
|
||||
|
||||
/*--------------------------------------------------------------------
|
||||
* external entry point
|
||||
*------------------------------------------------------------------*/
|
||||
|
||||
void
|
||||
SyncDirectory(SyncParams *p)
|
||||
{
|
||||
char sbuf[1024], tbuf[1024];
|
||||
DirEntry *sP, *tP;
|
||||
FileOp op;
|
||||
int rc;
|
||||
|
||||
/* the lower-level error and progress callbacks are not used */
|
||||
errorCallback = NULL;
|
||||
progressCallback = NULL;
|
||||
|
||||
/* save pointer to params; copy source & target names */
|
||||
SP = p;
|
||||
strcpy(sbuf, SP->source);
|
||||
strcpy(tbuf, SP->target);
|
||||
|
||||
/* get info about the source */
|
||||
sP = GetDirEntry(sbuf, &op, &rc);
|
||||
if (rc) {
|
||||
if (syncErrorCallback)
|
||||
syncErrorCallback(op, sbuf, rc);
|
||||
FreeDir(sP);
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* The "copytop" option means: if the top-level source is a symbolic
|
||||
* make a copy of the real thing. To get this behavior we just switch
|
||||
* off the ft_islnk flag on the source.
|
||||
*/
|
||||
if (SP->copytop)
|
||||
sP->ftype &= ~ft_islnk;
|
||||
|
||||
/* get info about the target */
|
||||
tP = GetDirEntry(tbuf, &op, &rc);
|
||||
if (rc) {
|
||||
if (op == op_lstat && rc == ENOENT) {
|
||||
/* target does not yet exist; that's ok */
|
||||
FreeDir(tP);
|
||||
tP = NULL;
|
||||
|
||||
} else {
|
||||
/* we'll try to procede anyway ... unless the error callback says no */
|
||||
if (syncErrorCallback && syncErrorCallback(op, tbuf, rc) < 0) {
|
||||
FreeDir(sP);
|
||||
FreeDir(tP);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* now do the real work */
|
||||
SyncItem(sbuf, sP, tbuf, tP);
|
||||
|
||||
/* free storage and return */
|
||||
FreeDir(sP);
|
||||
FreeDir(tP);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user