使用C中包含多个Null字符的字符串

Question

I have a char[] buffer that contains data read from the memory, which means there are multiple Nulls within this buffer and not only one single terminating Null at the end.

char *addr = (char *)memmem(buff, strlen(buff), needle, strlen(needle));

I need to process this string and search and replace certain content. For this, I would like to use memmem() , but unfortunately, it's not working because the multiple Nulls within the buffer.

I tried to replace the Nulls in the buffer with a character from which I thought it would not appear (the Bell ASCII code \\7) and then process it, but this does not work and corrupts my data.

Is there another way to process a string that has multiple Nulls?

Answer 1

memmem can be used to do it. However, since your data contains embedded nulls you cannot use strlen to calculate the length. You need to keep track of the lengths separately.

char *addr = (char *)memmem(buff, buffLen, needle, needleLen);

Answer 2

Using strlen on your char array that, by your own admission contains terminating isn't going to work. You should realize that strlen just counts the number of chars up to the point where it encounters a zero terminator.
Incidentally, this is how strncat works, too, so you can't use those functions either.

What you could do is keep an int at hand which you use to keep track of the actual length of the string.
An other way of tackling this problem would be to write your own d_strlen function, and always ensure that your buffer has two zero-terminating chars at the end:

size_t d_strlen(const char *in)
{
    size_t len = 0;
    while( !(in[len] == '\0' && in[len+1] == '\0' )) ++len;
    return len;
}

Again: your buffer Must then be terminated by two terminating zeroes, not just the one:

char buff[100] = "this \0 string contains \0 terminators \0";//adds second \0
printf("%d  != %d\n", strlen(buff), d_strlen(buff));//yields 5 != 37

---

As Frerich Raabe pointed out, to not loose the optimizations and security of a tried 'n tested function like strlen , this might be a better version of d_strlen

size_t d_strlen(const char *in)
{
    size_t len = 0;
    while(strlen(in+len)) len += strlen(in+len) + 1;
    return len ? --len : 0;//check for zero-length
}

However, this calls strlen twice, which is pointless overhead, so you're probably better off writing this:

size_t d_strlen(const char *in)
{
    size_t i, len = 0;
    do
    {
        i = strlen(in+len);//get substring length
        len += i + 1;//add to total length + 1 for \0 char
    }while(i > 0);
    return len > 1 ? len-2 : 0;//subtract 2, if possible, else return 0
}

Answer 3

AC string is a sequence of chars terminated by a NUL ... by definition it can't contain more than one NUL. What you have is something more generic, a block of chars. To deal with arbitrary blocks of chars, they must be accompanied by a length -- the count of the number of chars. Given that you can process the block without any concern for whether it contains NULs. Given a block consisting of a pointer to some chars and the count, you would use the count, rather than strlen, so

memmem(buff, buff_len, needle, needle_len);