Thread: Extra characters in string

First of all, don't write code that relies on hard-coded magic numbers. All of those values should be calculated by the program. Otherwise you're just creating a maintainance nightmare for yourself and anyone else who has to use the code.

>> tiffLine + (strlen(tiffLine)-12)

Think about it. Let's say strlen(tiffLine) == 15. That would put you at the 3rd element to start copying at.

strncpy() doesn't automatically add a \0
So it you don't add one, it can seem like data overrun.

Store them in variables(the original ones) and then have your program calculate the rest.

I didn't compile this, but the general idea is something like:

Code:

// a 'safe' strncpy
char* sstrncpy(char* dst, const char* src, size_t len)
{
    if (!len--)
        return NULL;
    strncpy(dst, src, len);
    dst[len] = 0;    
    return dst;
}

int main(int argc, char *argv[])
{
    const size_t size = 64;
    char* end_of_path = NULL;
    char dest[size+1] = {0}; //destination path of files to be moved
    char tiff_file[size+1] = {0};  //TIFF files that will be moved
    char move_tiff[size+1] = "moveTIFF.dat";  //file with list of TIFF files to be moved
    char tiffLine[size+1];   //name and path of TIFF file
    FILE *inputFile, *errorFile, *indexFile, *tiffFile;
    if ( (access(move_tiff, F_OK)) != -1 ) {
        printf("%s found and can be opened\n", move_tiff);
        tiffFile = fopen(move_tiff, "r");  // open data file "moveTIFF.dat" for reading only
        if (tiffFile != NULL) { 
            while (fgets(tiffLine, size, tiffFile)!=NULL) { //loop for reading a line up of "moveTIFF.dat" to end of file
                printf("Line: %s\n", tiffLine);
                sstrncpy(dest, tiffLine, size);
                if (
                    (end_of_path = strrchr(dest, '\\')) != NULL 
                    || 
                    (end_of_path = strrchr(dest, '/')) != NULL
                ) {    
                    ++end_of_path;
                    sstrncpy(tiff_file, end_of_path, size);
                    *end_of_path = 0;
                    printf("Path:%s\nFile: %s\n", dest, tiff_file);
                }    
            }
            fclose(tiffFile);
        }    
    }    
    return 0;
}

if (!len--) return NULL;

So if len is 1 then len-- is zero, but results in 1... Postfix is not what you want here, but you could use a sequence point as a fix instead.

>> So if len is 1 then len-- is zero, but results in 1... Postfix is not what you want here, but you could use a sequence point as a fix instead.

The check was merely to ensure that len is not zero upon entering the function (which it does correctly).

>> Your code works fine. Thank you. I have to determine exactly how it works.
See the attachment for the output.

The one thing I noticed though is there's a trailing newline in the output. Just use strrchr(tiffLine, '\n') to get a pointer to the newline and set it to zero (check that it isn't NULL though, of course) before you copy the data to the other variables.

And just one more thing. So the whole point of automating things is so that your program can grow without having to account for any hard-coded settings. In your original post you stated that the filename will always be 13 characters long. So then if the program encounters a 14 character word, it won't work. And so then you have to go through all of the code and change all of that around including the 12's that are sprinkled around the function and whatnot. Quite a hassle! The way that the example I posted is set up, you'd only have to change the value 64 in a single place if the size of the filename for some reason requires more space. It's just more manageable that way.