Brtdku

I was using memory mapping to "edit" one file and print the results to another, when I encountered this phenomenon. My understanding is that sscanf (similar to printf) reads a string until a whitespace or newline is encountered. This was exactly my tactic, when I used it on my mmap'd source file to filter out the comments and print everything else to second file. For a given argument of how the comment line starts (a string e.g. "#", "@","//", "whatever"), I used sscanf to check if a line began with that word. Much to my surprise it seems that when mmap is used, the pointer to that virtual memory isn't treated the same. (note the test printf right before the while loop).

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <string.h>

#include <errno.h>

#include <sys/mman.h>

#include <unistd.h>



static void     fatalError(char *message);



int     main(int argc, char *argv)

{

    int     fd1, fd2;

    struct stat     stats;

    char    *source, *dest;





    assert(argc == 4);



    if ((fd1 = open(argv[1], O_RDONLY)) < 0) {

        if (errno == ENOENT)

            fatalError("First file nonexistent");

        else 

            fatalError("open error");

    }





    if ((fd2 = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH)) < 0) {

        if (errno == EACCES)

            printf("Creating second filen");

        else

            fatalError("open error");

    }





    if (fstat(fd1, &stats) < 0)

        fatalError("fstat error");



    if (lseek(fd2, stats.st_size-1, SEEK_SET) < 0)

        fatalError("lseek error");



    if (write(fd2, "", 1) != 1)

        fatalError("write error");





    if ((source = mmap(0, stats.st_size, PROT_READ, MAP_SHARED, fd1, 0)) == MAP_FAILED)

        fatalError("mmap failed");



    if ((dest = mmap(0, stats.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd2, 0)) == MAP_FAILED)

        fatalError("mmap failed");



    char    word[100];

    int     flag, count;

    char    *tmp;



    tmp = source;



    char    test[50] = "firstWord will only be read by sscanf";

    sscanf(test, "%s", word);

    printf("%sn", word);



    while ((count = sscanf(source, "%s", word)) > 0) {

        if (!flag) {

            // in comment

            if (!strcmp(word, argv[3])) {

                flag = 1;

                source += count;

                continue;

            }

            sprintf(dest, "%s", word);

            source += count;

        } else {

            // not in comment

            if (word[strlen(word) - 1] == 'n') {

                sprintf(dest, "n");

                source += count;

            }



            source += count;



        }



    }



    source = tmp;



    if (munmap(source, stats.st_size) < 0)

        fatalError("munmap error");



    if (munmap(dest, stats.st_size) < 0)

        fatalError("munmap error");



    if (close(fd1) < 0)

        fatalError("close return");



    if (close(fd2) < 0)

        fatalError("close error");









    return 0;

}





static void     fatalError(char *message) {

    perror(message);

    exit(EXIT_FAILURE);

}

The input file("#" as comment symbol):

npwhitespacea

asdasdasdasd

# asdasdasdasmdaosimda

asdasd

kmflsdkfms

#

oioiasjdoaisd

i

# asoidaosid

source += count; is questionable code as it is the same as source++; for count is 1 here.

Likely on a match, code should advance by the length of the string and not the conversion count.

  // in comment

  if (!strcmp(word, argv[3])) {

    flag = 1;

    // source += count;

    source += strlen(argv[3]);

    continue;

  }

Code is never true

word[strlen(word) - 1] == 'n' is never true because sscanf(source, "%s", word) will not put white-space into word.

sscanf (similar to printf) reads a string until a whitespace or newline is encountered.

OP's generalization is too broad. 1) the "until" depends on the format. 2) With format "%s", sscanf() reads white-spaces and skip other them, then its reads non-white-spaces and saves them. This continues until a whitespace (which include a 'n') is found. sscanf() differs from scanf/fscanf in this case as reading a null character by scanf/fscanf is read/saved just like any non-white-space. With sscanf(), a null character is akin to an end-of-file. It is not "read/saved", but does stop the scan.

OP's overall strategy have weaknesses. OP is looking for comment line. "%s" loses all awareness of 'n'.

Code could use the below to read a line, yet more work is needed for empty or very long lines.

char line[260];

int n = 0;

sscanf(source, "%259[^n]%n", line, &n);

if (line > 0) {

  // success, now read potential n or more line

  ...

} else {

  // read potential n (a short line)

  ...

}



// process line



// next line

source += n;

Other issues may exist.

sscanf reads until null '' character.