Thread: I found a replace string by string...how secure it is?

Code:

int SearchAndReplace(char *outString,char *inString,char *searchString,char *replaceString)
{
	char *p;
	int lenReplace, lenSearch, len, count = 0;

     while ((p = strstr(inString, searchString)) != NULL)
	 {
		 if (count == 0)
		 {
			 lenReplace = strlen (replaceString);
			 lenSearch  = strlen (searchString);
		 }
		 count++;
		 len = p-inString;
		 CopyMemory(outString, inString, len);
		 outString += len;
		 inString = p+lenSearch;
		 CopyMemory(outString, replaceString, lenReplace);
		 outString += lenReplace;
	 }
	 lstrcpy (outString, inString);
     return count;
}

How effective is? Any leaks?

There seems to be no capacity to prevent overwrites of the destination character array (outString)... you can potentially write more to this array than its capacity can hold. Since this is the C++ forum, how about using a std::string version of the function where you wouldn't have to worry about that kind of thing, something like:

Code:

int SearchAndReplace(string& out_str, const string& in_str,
                     const string& find_str, const string& replace_str)
{
    string::size_type indx = 0;
    int count = 0;

    out_str = in_str;
    while( (indx = out.find(find_str,indx)) != string::npos )
    {
        out.replace(indx,find_str.length(),replace_str);
        indx += replace_str.length();
        ++count;
    }
    return count;
}

Well it's pretty poor to use char* for strings in C++

All except outstring should be declared as const.

There is no indication of the length of the buffer outstring points to (buffer overflows abound)

Thanks to everyone:

Does anyone know a C style one?

> Does anyone know a C style one?
That is a C style one.

Or do you mean how to make it safer?

Well pass an out length for starters, and code it in yourself. Post your attempt here for further comment.