C copy file contents from EOF to SOF

Question

My program is working almost as it should. The intended purpose is to read the file from the end and copy the contents to destination file. However what confuses me is the lseek() method more so how I should be setting the offset.

My src contents at the moment are:
Line 1
Line 2
Line 3

At the moment what I get in my destination file is:
Line 3
e 2
e 2...

From what I understand calling int loc = lseek(src, -10, SEEK_END); will move the "cursor" in source file to then end then offset it from EOF to SOF for 10 bytes and the value of loc will be the size of file after I have deducted the offset. However after 7h of C I'm almost brain dead here.

int main(int argc, char* argv[])
{
    // Open source & source file
    int src = open(argv[1], O_RDONLY, 0777);
    int dst = open(argv[2], O_CREAT|O_WRONLY, 0777);

    // Check if either reported an erro
    if(src == -1 || dst == -1)
    {
        perror("There was a problem with one of the files.");
    }

    // Set buffer & block size
    char buffer[1];
    int block;

    // Set offset from EOF
    int offset = -1;

    // Set file pointer location to the end of file
    int loc = lseek(src, offset, SEEK_END);

    // Read from source from EOF to SOF
    while( loc > 0 )
    {
        // Read bytes
        block = read(src, buffer, 1);

        // Write to output file
        write(dst, buffer, block);

        // Move the pointer again
        loc = lseek(src, loc-1, SEEK_SET);
    }

}

Of course, this whole approach only works with fixed-size records, whereas your example data looks like a text file, wherein each line could be a different size. (Not to mention, even if the lines are fixed-length, your offset of -5 is wrong due to newlines and the space.) — Kevin, Oct 22 '13 at 16:31
@Kevin I'm aware of that, my solution was to simply read byte by byte but that resulted in correct outupt however each word was reversed so i would get 3eniL ... etc — Sterling Duchess, Oct 22 '13 at 16:57
You in the same class as http://stackoverflow.com/questions/19504935/how-to-reverse-order-of-lines-in-a-file? — Jongware, Oct 22 '13 at 17:36
you can do this with http://linux.die.net/man/3/strrchr using while (NULL != tmp=strrchr(buffer, '\n')) write(dst,tmp, strlen(tmp)); — technosaurus, Oct 23 '13 at 05:55

score 3 · Accepted Answer · edited Oct 23 '13 at 09:04

3

lseek() doesn't change or return the file size. What it returns is the position where the 'cursor' is set to. So when you call

loc = lseek(src, offset, SEEK_END);

twice it will always set the cursor to the same position again. I guess you want to do something like this:

while( loc > 0 )
{
    // Read bytes
    block = read(src, buffer, 5);

    // Write to output file
    write(dst, buffer, block);

    // Move the pointer again five bytes before the last offset
    loc = lseek(src, loc+offset, SEEK_SET);
}

If the line length is variable, you could do something like the following instead:

// define an offset that exceeds the maximum line length
int offset = 256;
char buffer[256];
// determine the file size
off_t size = lseek( src, 0, SEEK_END );
off_t pos = size;
// read block of offset bytes from the end
while( pos > 0 ) {
    pos -= offset;
    if( pos < 0 ) {
        //pos must not be negative ...
        offset += pos;   // in fact decrements offset!!
        pos = 0;
    }
    lseek( src, pos, SEEK_SET );
    // add error checking here!!
    read(src, buffer, offset );
    // we expect the last byte read to be a newline but we are interested in the one BEFORE that
    char *p = memchr( buffer, '\n', offset-1 );
    p++;  // the beginning of the last line
    int len = offset - (p-buffer);  // and its length
    write( dst, p, len );
    pos -= len;            // repeat with offset bytes before the last line
}

edited Oct 23 '13 at 09:04

ralight

11,033
3
49
59

answered Oct 22 '13 at 16:19

Ingo Leonhardt

9,435
2
24
33

I'm still having the same problem only now I get eLine3 – Sterling Duchess Oct 22 '13 at 16:23
Sorry, second `lseek()` has to be with `loc+offset` because `offset` is negative (edited) – Ingo Leonhardt Oct 22 '13 at 16:24
Btw. is there a blank between "Line" and "3"? if so offset has to be -6 because of the newline – Ingo Leonhardt Oct 22 '13 at 16:26
Problem is that each line in my file is of different length so only viable option is for offset and buffer to be 1 at a time. – Sterling Duchess Oct 22 '13 at 16:59
If you take a look at how I changed my method this works. However the output is: 3eniL2eniL1eniL all in same line with no spacing between words. – Sterling Duchess Oct 22 '13 at 17:05
Where's the updated method? I've added a piece of code to show what could be done for lines of variable length. It my be buggy but should give you an idea ... – Ingo Leonhardt Oct 22 '13 at 17:17
Results in an empty file. If you look at how I have it now this works only it joins all words in one line it ignores line breaks. – Sterling Duchess Oct 22 '13 at 20:17

ralight · Answer 2 · 2013-10-23T09:02:23.513

1

I think you should be using SEEK_CUR instead of SEEK_END in your final call to lseek():

// Set file pointer location to the end of file
int loc = lseek(src, offset, SEEK_END);

// Read from source from EOF to SOF
while( loc > 0 )
{
    // Read bytes
    block = read(src, buffer, 5);

    // Write to output file
    write(dst, buffer, block);

    // Move the pointer again
    lseek(src, -10, SEEK_CUR);
}

You could also do:

// Set file pointer location to the end of file
int loc = lseek(src, offset, SEEK_END);

// Read from source from EOF to SOF
while( loc > 0 )
{
    // Read bytes
    block = read(src, buffer, 5);

    // Write to output file
    write(dst, buffer, block);

    // Move the pointer again
    loc -= 5;
    lseek(src, loc, SEEK_SET);
}

edited Oct 23 '13 at 09:02

answered Oct 22 '13 at 16:16

ralight

11,033
3
49
59

1

Using SEEK_CUR doesn't help because of `read( ..., 5 )`. It will also just set the position to where it was before – Ingo Leonhardt Oct 22 '13 at 16:21
Well that depends on what else you pass. Just skip back 10 bytes instead of 5. – ralight Oct 22 '13 at 17:57

Kevin · Answer 3 · 2013-10-23T05:43:27.877

From some of your comments it looks like you want to reverse the order of the lines in a text file. Unfortunately you're not going to get that with such a simple program. There are several approaches you can take, depending on how complicated you want to get, how big the files are, how much memory is on hand, how fast you want it to be, etc.

Here are some different ideas off the top of my head:

Read your whole source file at once into a single memory block. Scan through the memory block forwards looking for line breaks and recording the pointer and length for each line. Save these records onto a stack (you could use a dynamic array, or an STL vector in C++,) and then to write your output file, you just pop a line's record off the stack (moving backwards through the array) and write it until the stack is empty (you've reached the beginning of the array.)
Start at the end of your input file, but for each line, seek backwards character-by-character until you find the newline that starts the previous line. Seek forwards again past that newline and then read in the line. (You should now know its length.) Or, you could just build up the reversed characters in a buffer and then write them out backwards.
Pull in whole blocks (sectors perhaps) of the file at once, from end to beginning. Within each block, locate the newlines in a similar fashion to the method above except now you already have the characters in memory and so don't need to do any reversing or pulling them in redundantly. However, this solution will be much more complicated because lines can span across block boundaries.

There may be more elaborate/clever tricks, but those are the more obvious, straightforward approaches.

C copy file contents from EOF to SOF

3 Answers3