Thread: Help with a file-backup function

Hi.
I'm writing a small function that gets as parameter a file's path and a folder's path, and copies the given file to that folder.

Code:

int copy_file(const char* source, const char* folder) {

    char copy[PATH_MAX];
    strcpy(copy, folder);
    strcat(copy, "/");
    strcat(copy, source);

    int source_fd;
    int copy_fd;

    struct stat source_stat;
    if (stat(source, &source_stat)) {
        perror("stat");
        return 1;
    }

    if ((source_fd=open(source, O_RDONLY))==-1) {
        perror("open");
        return 1;
    }

    if ((copy_fd=open(copy, O_WRONLY|O_CREAT|O_TRUNC, source_stat.st_mode))==-1) {
        perror("open");
        close(source_fd);
        return 1;
    }

    char buffer[READ_BLOCK];
    int bytes_read;
    while ((bytes_read=read(source_fd, buffer, READ_BLOCK))!=0) {
        if (bytes_read==-1) {
            perror("read");
            break;
        }
        if (write(copy_fd, buffer, bytes_read)==-1) {
            perror("write");
            break;
        }
    }

    close(source_fd);
    close(copy_fd);
    return 0;
}

Basically, this function purpose is to make a backup of source in folder every X minutes (depending on user's input).
The problem is the second call to open():
This call attempts to open the file for writing, and creates it if it is not already exist.
It also truncates it before writing to it - and that's my concern:
Let's say this is the second time this function runs, so copy is already exist. open() will then truncate it, and then one of the system calls in the while loop fails.
In this situation, I might be left with no backup file.

The problem also arises for when source is a read-only file:
If source is a read-only file, and copy is not already exist (meaning - it's the first backup attempt), then everything's fine, but, if source is a read-only file and copy is already exist, then I have to first remove copy altogather, and make a fresh copy of source.

Making a backup with new name for copy every time copy_file() runs, will solve this problem, and this is where I need some help:
Any ideas on how can this be accomplished?

EDIT

I should say that I'd really prefer that copy and source will have the same names when copy_file() returns...

You've already got source_stat.st_mode, why don't you use it to figure out what your next step should be?

Originally Posted by rstanley

Why not append the date [and time] to the backup file name when creating the file.

That's a good idea.
But then how will I delete the older backup?
If I'll add some date-time format to the file's name, then it'll be unique.
How will I locate it?

EDIT

To be more specific:

Code:

    if (!access(/* what should go here? */, F_OK)) {
        if (unlink(/*...*/)) {
            perror("unlink");
            return 1;
        }
    }

If you are only going to have at most two backups at any point of time, then specially designating the newer and older backup file names as in your post #3 makes sense. You would not need to involve date/timestamps since you will not be keeping additional backups long after the newest backup.

Incidentally, this:

Code:

strcpy(copy, folder);
strcat(copy, "/");
strcat(copy, source);

might be better written as:

Code:

snprintf(copy, PATH_MAX, "%s/%s", folder, source);