Macintosh-SW
/
syncfiles
mirror of https://github.com/depp/syncfiles.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
syncfiles/sync.c

839 lines
20 KiB
C
Raw Blame History

#include "defs.h"
#include <Files.h>
#include <Folders.h>
#include <MacMemory.h>
#include <StringCompare.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
typedef enum {
kLogWarn,
kLogInfo,
kLogVerbose,
} log_level;
static log_level gLogLevel = kLogInfo;
enum {
// Maximum file size that we will copy.
kMaxFileSize = 64 * 1024,
};
typedef int (*convert_func)(unsigned char **outptr, unsigned char *outend,
const unsigned char **inptr,
const unsigned char *inend);
void print_err(const char *msg, ...) {
va_list ap;
fputs("## Error: ", stderr);
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
fputc('\n', stderr);
}
// Map from OSErr codes to messages. As a heuristic, this should include error
// codes caused by toolbox calls in this program which are readily understood by
// the user. It can exclude error codes that are likely to indicate a
// programming error.
struct error_message {
OSErr err;
const char *msg;
};
#define E(e, m) \
{ e, m "\0" #e }
const struct error_message kErrorMessages[] = {
E(dirFulErr, "directory full"), // -33
E(dskFulErr, "disk full"), // -34
E(ioErr, "I/O error"), // -36
E(bdNamErr, "bad name"), // -37
E(fnfErr, "file not found"), // -43
E(wPrErr, "disk is write-protected"), // -44
E(fLckdErr, "file is locked"), // -45
E(vLckdErr, "volume is locked"), // -46
E(fBsyErr, "file is busy"), // -47
E(dupFNErr, "destination already exists"), // -48
E(opWrErr, "file already open for writing"), // -49
E(paramErr, "parameter error"), // -50
E(permErr, "cannot write to locked file"), // -54
E(dirNFErr, "directory not found"), // -120
E(wrgVolTypErr, "not an HFS volume"), // -123
E(diffVolErr, "files on different volumes"), // -1303
E(afpAccessDenied, "user does not have access privileges (AFP)"), // -5000
E(afpObjectTypeErr,
"file/directory specified where directory/file expected"), // -5025
E(afpSameObjectErr, "objects are the same"), // -5038
};
static const char *mac_strerror(OSErr err) {
int i, n = sizeof(kErrorMessages) / sizeof(*kErrorMessages);
for (i = 0; i < n; i++) {
if (kErrorMessages[i].err == err) {
return kErrorMessages[i].msg;
}
}
return NULL;
}
void print_errcode(int err, const char *msg, ...) {
va_list ap;
const char *emsg;
fputs("## Error: ", stderr);
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
emsg = mac_strerror(err);
if (emsg != NULL) {
fprintf(stderr, ": %s (%d)\n", emsg, err);
} else {
fprintf(stderr, ": err=%d\n", err);
}
}
static void log_call(int err, const char *function) {
const char *emsg;
if (err == 0) {
fprintf(stderr, "## %s: noErr\n", function);
return;
}
emsg = mac_strerror(err);
if (emsg != NULL) {
emsg += strlen(emsg) + 1;
fprintf(stderr, "## %s: %s (%d)\n", function, emsg, err);
} else {
fprintf(stderr, "## %s: %d\n", function, err);
}
}
// Convert a C to Pascal string.
static int c2pstr(Str255 ostr, const char *istr) {
size_t n = strlen(istr);
if (n > 255) {
print_err("path too long: %s", istr);
return 1;
}
ostr[0] = n;
memcpy(ostr + 1, istr, n);
memset(ostr + 1 + n, 0, 255 - n);
return 0;
}
// Convert a Pascal to C string.
static void p2cstr(char *ostr, const unsigned char *istr) {
unsigned len = istr[0];
memcpy(ostr, istr + 1, len);
ostr[len] = '\0';
}
struct file_meta {
Boolean exists;
long modTime;
};
enum {
kSrcDir,
kDestDir,
};
enum {
kModeAuto,
kModePush,
kModePull,
};
struct file_info {
Str31 name;
struct file_meta meta[2];
int mode;
};
// Array of metadata entries for files.
static Handle gFiles;
static unsigned gFileCount;
static unsigned gFileAlloc;
// Get the metadata entry for a file with the given name.
static struct file_info *get_file(const unsigned char *name) {
unsigned i, n = gFileCount, len, newAlloc;
struct file_info *file, *array;
Handle newFiles;
OSErr err;
len = name[0];
if (len > 31) {
fputs("## Error: name too long\n", stderr);
return NULL;
}
if (gFiles == NULL) {
newAlloc = 8;
newFiles = NewHandle(newAlloc * sizeof(struct file_info));
err = MemError();
if (err != noErr) {
fputs("## Error: out of memory\n", stderr);
return NULL;
}
gFiles = newFiles;
gFileAlloc = newAlloc;
} else {
array = (struct file_info *)*gFiles;
for (i = 0; i < n; i++) {
file = &array[i];
if (memcmp(file->name, name, len + 1) == 0) {
return file;
}
}
if (n >= gFileAlloc) {
newAlloc = n * 2;
SetHandleSize(gFiles, newAlloc * sizeof(struct file_info));
err = MemError();
if (err != noErr) {
fputs("## Error: out of memory\n", stderr);
return NULL;
}
gFileAlloc = newAlloc;
}
}
array = (struct file_info *)*gFiles;
file = &array[n];
gFileCount = n + 1;
memset(file, 0, sizeof(*file));
memcpy(file->name, name, len + 1);
return file;
}
// Get the volume and directory ID for a directory from its path.
static int dir_from_path(short *vRefNum, long *dirID, const char *dirpath) {
Str255 ppath;
FSSpec spec;
CInfoPBRec ci;
OSErr err;
if (c2pstr(ppath, dirpath)) {
return 1;
}
err = FSMakeFSSpec(0, 0, ppath, &spec);
if (err != 0) {
if (err == fnfErr) {
print_err("does not exist: %s", dirpath);
} else {
print_errcode(err, "FSMakeFSSpec");
}
return 1;
}
memset(&ci, 0, sizeof(ci));
ci.dirInfo.ioNamePtr = spec.name;
ci.dirInfo.ioVRefNum = spec.vRefNum;
ci.dirInfo.ioDrDirID = spec.parID;
err = PBGetCatInfoSync(&ci);
if (err != 0) {
print_errcode(err, "PBGetCatInfoSync");
return 1;
}
if ((ci.dirInfo.ioFlAttrib & kioFlAttribDirMask) == 0) {
print_err("not a directory: %s", dirpath);
return 1;
}
*vRefNum = ci.dirInfo.ioVRefNum;
*dirID = ci.dirInfo.ioDrDirID;
return 0;
}
// Return true if a file with the given name should be included. The name is a
// Pascal string.
static int filter_name(const unsigned char *name) {
int len, i, stem;
const unsigned char *ext;
char temp[32];
if (EqualString(name, "\pmakefile", FALSE, TRUE)) {
return 1;
}
stem = 0;
len = name[0];
for (i = 1; i <= len; i++) {
if (name[i] == '.') {
stem = i;
}
}
if (stem != 0) {
ext = name + stem + 1;
switch (len - stem) {
case 1:
if (ext[0] == 'c' || ext[0] == 'h' || ext[0] == 'r') {
return 1;
}
break;
}
}
if (gLogLevel >= kLogVerbose) {
p2cstr(temp, name);
fprintf(stderr, "## Ignored: %s\n", temp);
}
return 0;
}
// List files in a directory, filter them, and add the files matching the filter
// to the file list. The value of 'which' should be kSrcDir or kDestDir.
static int list_dir(short vRefNum, long dirID, int which) {
Str255 ppath;
CInfoPBRec ci;
struct file_info *file;
OSErr err;
int i;
for (i = 1; i < 100; i++) {
memset(&ci, 0, sizeof(ci));
ci.dirInfo.ioNamePtr = ppath;
ci.dirInfo.ioVRefNum = vRefNum;
ci.dirInfo.ioDrDirID = dirID;
ci.dirInfo.ioFDirIndex = i;
err = PBGetCatInfoSync(&ci);
if (err != 0) {
if (err == fnfErr) {
break;
}
print_errcode(err, "could not list directory");
continue;
}
if ((ci.hFileInfo.ioFlAttrib & kioFlAttribDirMask) == 0 &&
filter_name(ppath)) {
ppath[ppath[0] + 1] = '\0';
file = get_file(ppath);
file->meta[which].exists = TRUE;
file->meta[which].modTime = ci.hFileInfo.ioFlMdDat;
}
}
return 0;
}
// Read the entire data fork of a file. The result must be freed with
// DisposePtr.
static int read_file(FSSpec *spec, Ptr *data, long *length) {
CInfoPBRec ci;
Ptr ptr;
long dataLength, pos, count;
OSErr err;
short fref;
// Get file size.
memset(&ci, 0, sizeof(ci));
ci.hFileInfo.ioNamePtr = spec->name;
ci.hFileInfo.ioVRefNum = spec->vRefNum;
ci.hFileInfo.ioDirID = spec->parID;
err = PBGetCatInfoSync(&ci);
if (err != 0) {
print_errcode(err, "could not get file metadata");
return 1;
}
if ((ci.hFileInfo.ioFlAttrib & kioFlAttribDirMask) != 0) {
print_err("is a directory");
return 1;
}
dataLength = ci.hFileInfo.ioFlLgLen;
if (dataLength > kMaxFileSize) {
print_err("file is too large: size=%ld, max=%ld", dataLength,
kMaxFileSize);
return 1;
}
// Allocate memory.
ptr = NewPtr(dataLength);
err = MemError();
if (err != 0) {
print_errcode(err, "out of memory");
return 1;
}
// Read file.
err = FSpOpenDF(spec, fsRdPerm, &fref);
if (err != 0) {
DisposePtr(ptr);
print_errcode(err, "could not open file");
return 1;
}
pos = 0;
while (pos < dataLength) {
count = dataLength - pos;
err = FSRead(fref, &count, ptr + pos);
if (err != 0) {
DisposePtr(ptr);
FSClose(fref);
print_errcode(err, "could not read file");
return 1;
}
pos += count;
}
FSClose(fref);
*data = ptr;
*length = dataLength;
return 0;
}
// Make an FSSpec for a temporary file.
static int make_temp(FSSpec *temp, short vRefNum, long dirID,
const unsigned char *name) {
Str31 tname;
unsigned pfxlen, maxpfx = 31 - 4;
OSErr err;
pfxlen = name[0];
if (pfxlen > maxpfx) {
pfxlen = maxpfx;
}
memcpy(tname + 1, name + 1, pfxlen);
memcpy(tname + 1 + pfxlen, ".tmp", 4);
tname[0] = pfxlen + 4;
err = FSMakeFSSpec(vRefNum, dirID, tname, temp);
if (err == 0) {
print_err("temporary file exists");
return 1;
} else if (err == fnfErr) {
return 0;
} else {
print_errcode(err, "could not create temp file spec");
return 1;
}
}
// Write the entire contents of a file.
static int write_file(FSSpec *dest, short tempVol, long tempDir, Ptr data,
long length, long modTime, Boolean destExists) {
FSSpec temp;
long pos, amt;
short ref;
HParamBlockRec pb;
CMovePBRec cm;
CInfoPBRec ci;
Str31 name;
OSErr err;
int r;
// Save the data to a temporary file.
r = make_temp(&temp, tempVol, tempDir, dest->name);
if (r != 0) {
return 1;
}
err = FSpCreate(&temp, 'MPS ', 'TEXT', smSystemScript);
if (err != 0) {
print_errcode(err, "could not create file");
return 1;
}
err = FSpOpenDF(&temp, fsRdWrPerm, &ref);
if (err != 0) {
print_errcode(err, "could not open temp file");
goto error;
}
pos = 0;
while (pos < length) {
amt = length - pos;
err = FSWrite(ref, &amt, data + pos);
if (err != 0) {
FSClose(ref);
print_errcode(err, "could not write temp file");
goto error;
}
pos += amt;
}
err = FSClose(ref);
if (err != 0) {
print_errcode(err, "could not close temp file");
goto error;
}
// Update the modification time.
memset(&ci, 0, sizeof(ci));
memcpy(name, temp.name, temp.name[0] + 1);
ci.hFileInfo.ioNamePtr = name;
ci.hFileInfo.ioVRefNum = temp.vRefNum;
ci.hFileInfo.ioDirID = temp.parID;
err = PBGetCatInfoSync(&ci);
if (err != 0) {
print_errcode(err, "could not get temp file info");
goto error;
}
memcpy(name, temp.name, temp.name[0] + 1);
ci.hFileInfo.ioNamePtr = name;
ci.hFileInfo.ioVRefNum = temp.vRefNum;
ci.hFileInfo.ioDirID = temp.parID;
ci.hFileInfo.ioFlMdDat = modTime;
err = PBSetCatInfoSync(&ci);
if (err != 0) {
print_errcode(err, "could not set temp file info");
goto error;
}
// First, try to exchange files if destination exists.
if (destExists) {
err = FSpExchangeFiles(&temp, dest);
if (gLogLevel >= kLogVerbose) {
log_call(err, "FSpExchangeFiles");
}
if (err == 0) {
err = FSpDelete(&temp);
if (err != 0) {
print_errcode(err, "could not remove temporary file");
return 1;
}
return 0;
}
// paramErr: function not supported by volume.
if (err != paramErr) {
print_errcode(err, "could not delete temp file");
return 1;
}
if (gLogLevel >= kLogVerbose) {
fputs("## FSpExchangeFiles not supported\n", stderr);
}
// Otherwise, delete destination and move temp file over.
err = FSpDelete(dest);
if (err != 0) {
print_errcode(err, "could not remove destination file");
goto error;
}
}
// Next, try MoveRename.
memset(&pb, 0, sizeof(pb));
pb.copyParam.ioNamePtr = temp.name;
pb.copyParam.ioVRefNum = temp.vRefNum;
pb.copyParam.ioNewName = dest->name;
pb.copyParam.ioNewDirID = dest->parID;
pb.copyParam.ioDirID = temp.parID;
err = PBHMoveRenameSync(&pb);
if (gLogLevel >= kLogVerbose) {
log_call(err, "PBHMoveRename");
}
if (err == 0) {
return 0;
}
// paramErr: function not supported by volume.
if (err != paramErr) {
print_errcode(err, "could not rename temporary file");
goto error;
}
// Finally, try move and then rename.
if (dest->parID != temp.parID) {
if (gLogLevel >= kLogVerbose) {
fputs("## PBCatMoveSync\n", stderr);
}
memset(&cm, 0, sizeof(cm));
cm.ioNamePtr = temp.name;
cm.ioVRefNum = temp.vRefNum;
cm.ioNewDirID = dest->parID;
cm.ioDirID = temp.parID;
err = PBCatMoveSync(&cm);
if (gLogLevel >= kLogVerbose) {
log_call(err, "PBCatMove");
}
if (err != 0) {
print_errcode(err, "could not move temporary file");
goto error;
}
temp.parID = dest->parID;
}
if (memcmp(dest->name, temp.name, dest->name[0] + 1) != 0) {
if (gLogLevel >= kLogVerbose) {
fputs("## FSpRename\n", stderr);
}
err = FSpRename(&temp, dest->name);
if (gLogLevel >= kLogVerbose) {
log_call(err, "FSpRename");
}
if (err != 0) {
print_errcode(err, "could not rename temporary file");
goto error;
}
}
return 0;
error:
err = FSpDelete(&temp);
if (err != 0) {
print_errcode(err, "could not delete temp file");
}
return 1;
}
// Copy the source file to the destination file. A temporary file is created in
// the specified temporary directory.
static int sync_file(struct file_info *file, convert_func func, long srcVol,
short srcDir, long destVol, short destDir, long tempVol,
short tempDir, long modTime) {
FSSpec src, dest;
Ptr srcData = NULL, destData = NULL;
long srcLength, destLength;
int r;
OSErr err;
unsigned char *outptr, *outend;
const unsigned char *inptr, *inend;
Boolean destExists;
// Create file specs.
err = FSMakeFSSpec(srcVol, srcDir, file->name, &src);
if (err != 0) {
print_errcode(err, "could not create source spec");
return 1;
}
err = FSMakeFSSpec(destVol, destDir, file->name, &dest);
if (err == 0) {
destExists = TRUE;
} else if (err == fnfErr) {
destExists = FALSE;
} else if (err != 0) {
print_errcode(err, "could not create destination spec");
return 1;
}
// Read the source file into memory.
r = read_file(&src, &srcData, &srcLength);
if (r != 0) {
return 1;
}
// Convert data.
destLength = srcLength + (srcLength >> 2) + 16;
destData = NewPtr(destLength);
err = MemError();
if (err != 0) {
print_errcode(err, "out of memory");
goto error;
}
outptr = (unsigned char *)destData;
outend = outptr + destLength;
inptr = (unsigned char *)srcData;
inend = inptr + srcLength;
func(&outptr, outend, &inptr, inend);
if (inptr != inend) {
print_err("conversion function failed");
goto error;
}
destLength = outptr - (unsigned char *)destData;
r = write_file(&dest, tempVol, tempDir, destData, destLength, destExists,
modTime);
if (r != 0) {
goto error;
}
// Clean up.
DisposePtr(srcData);
DisposePtr(destData);
return 0;
error:
if (srcData != NULL) {
DisposePtr(srcData);
}
if (destData != NULL) {
DisposePtr(destData);
}
return 1;
}
static int command_main(char *destpath, int mode) {
short srcVol, destVol, tempVol;
long srcDir, destDir, tempDir;
struct file_info *array, *file, *srcNewer, *destNewer;
OSErr err;
int r, i, j, n;
char name[32];
const char *modeStr;
// Get handles to src and dest directories.
err = HGetVol(NULL, &srcVol, &srcDir);
if (err != 0) {
print_errcode(err, "HGetVol");
return 1;
}
r = dir_from_path(&destVol, &destDir, destpath);
if (r != 0) {
return 1;
}
// List files in src and dest directories.
r = list_dir(srcVol, srcDir, kSrcDir);
if (r != 0) {
return 1;
}
r = list_dir(destVol, destDir, kDestDir);
if (r != 0) {
return 1;
}
if (gFileCount == 0) {
print_err("no files");
return 1;
}
HLock(gFiles);
array = (struct file_info *)*gFiles;
n = gFileCount;
// Figure out the direction for each file.
srcNewer = NULL;
destNewer = NULL;
for (i = 0; i < n; i++) {
file = &array[i];
if (!file->meta[kSrcDir].exists) {
file->mode = kModePull;
destNewer = file;
} else if (!file->meta[kDestDir].exists) {
file->mode = kModePush;
srcNewer = file;
} else if (file->meta[kSrcDir].modTime < file->meta[kDestDir].modTime) {
file->mode = kModePull;
destNewer = file;
} else if (file->meta[kSrcDir].modTime > file->meta[kDestDir].modTime) {
file->mode = kModePush;
srcNewer = file;
}
if (gLogLevel >= kLogVerbose) {
p2cstr(name, file->name);
switch (file->mode) {
default:
case kModeAuto:
modeStr = "equal";
break;
case kModePull:
modeStr = "destNewer";
break;
case kModePush:
modeStr = "srcNewer";
break;
}
fprintf(stderr, "## File: %s %s", name, modeStr);
for (j = 0; j < 2; j++) {
if (!file->meta[j].exists) {
fputs(" -", stderr);
} else {
fprintf(stderr, " %ld", file->meta[j].modTime);
}
}
fputc('\n', stderr);
}
}
// Figure out the mode: push or pull.
if (mode == kModeAuto) {
if (srcNewer != NULL) {
if (destNewer != NULL) {
fputs("## Error: both source and destination have new files\n",
stderr);
p2cstr(name, srcNewer->name);
fprintf(stderr, "## New file in source: %s\n", name);
p2cstr(name, destNewer->name);
fprintf(stderr, "## New file in destination: %s\n", name);
return 1;
}
mode = kModePush;
fputs("## Mode: push\n", stderr);
} else if (destNewer != NULL) {
mode = kModePull;
fputs("## Mode: pull\n", stderr);
} else {
fputs("## No changes.\n", stderr);
return 0;
}
}
// Synchronize the files.
if (mode == kModePull) {
r = mac_from_unix_init();
if (r != 0) {
return 1;
}
}
tempVol = 0;
tempDir = 0;
for (i = 0; i < n; i++) {
file = &array[i];
p2cstr(name, file->name);
if (file->mode == mode) {
if (gLogLevel >= kLogInfo) {
fprintf(stderr, "## Writing %s\n", name);
}
if (mode == kModePush) {
// When pushing, we use the destination directory as the
// temporary folder, to avoid crossing filesystem boundaries on
// the host.
r = sync_file(file, mac_to_unix, srcVol, srcDir, destVol,
destDir, destVol, destDir,
file->meta[kSrcDir].modTime);
} else {
if (tempDir == 0) {
err = FindFolder(srcVol, kTemporaryFolderType, TRUE,
&tempVol, &tempDir);
if (err != 0) {
print_errcode(err, "could not find temporary folder");
return 1;
}
}
r = sync_file(file, mac_to_unix, destVol, destDir, srcVol,
srcDir, tempVol, tempDir,
file->meta[kDestDir].modTime);
}
if (r) {
print_err("failed to copy file: %s", name);
return 1;
}
if (gLogLevel >= kLogVerbose) {
fprintf(stderr, "## Done writing %s\n", name);
}
} else if (file->mode != kModeAuto) {
fprintf(stderr,
"## Warning: Refusing to overwrite '%s', file is newer\n",
name);
}
}
return 0;
}
int main(int argc, char **argv) {
char *destDir = NULL, *arg, *opt;
int i, r, mode = kModeAuto;
for (i = 1; i < argc; i++) {
arg = argv[i];
if (*arg == '-') {
opt = arg + 1;
if (*opt == '-') {
opt++;
}
if (strcmp(opt, "push") == 0) {
mode = kModePush;
} else if (strcmp(opt, "pull") == 0) {
mode = kModePull;
} else if (strcmp(opt, "verbose") == 0 || strcmp(opt, "v") == 0) {
gLogLevel = kLogVerbose;
} else if (strcmp(opt, "quiet") == 0 || strcmp(opt, "q") == 0) {
gLogLevel = kLogWarn;
} else {
print_err("unknown flag: %s", arg);
return 1;
}
} else {
if (destDir != NULL) {
print_err("unexpected argument: %s", arg);
return 1;
}
destDir = arg;
}
}
r = command_main(argv[1], mode);
if (gFiles != NULL) {
DisposeHandle(gFiles);
}
mac_from_unix_term();
if (gLogLevel >= kLogVerbose) {
fputs("## Done\n", stderr);
}
return r;
}
Reference in New Issue View Git Blame Copy Permalink