Segmentation fault with string operations - help needed

>>   static char buffer[1024];

You said that the string could be longer than 1kB ... You should probably provide more space for the buffer ...


>>   if(!(p = strstr(str, orig)))
>>     return str;

The function returns two semantically different pointers in different situations. In this case it returns a char*, as a copy of one of the arguments (this might point to anything, including a string literal). In the normal case, a pointer to a static buffer is returned. Be careful with this, as you're making assumptions about the function's usage that aren't necessarily true.


>> sizeof(replace_str(login, "$dlul", dlu))

Since replace_str returns a char*, this will be the same as sizeof(char*). On a 32bit platform for example, that would be 4. It does NOT give you the length of the string - for that you need strlen.


>>   tempstr = malloc(sizeof(replace_str(login, "$dlul", dlu)));
>>   strcpy(tempstr,replace_str(login, "$dlul", dlu));

Note that you're calling replace_str twice here with the same exact parameters ... That's a bit wasteful, especially since you're dealing with large strings.


>>   login = realloc(login,sizeof(tempstr)+sizeof(logindata));

Same comment about sizeof here ...


>>   strcpy(login,tempstr);
>>   strcat(login, logindata);

Does the login string have enough room to hold the concatenation of those two ?



>> But every single way i try i get segmentation fault or memory corruption later in program...

Could you show us the exact code you used, as well as the line where the segmentation fault occurs ?

char string[]; is exactly the same as char* string; the correct syntax is const char* string;

In the function. You create an local array buffer. Then use it as a return value. But the array will stop the exist in the exact moment the function will return. Therefore you will get a pointer pointing somewhere into non-valid memory, which will cause access violation when accessing it.

>> char string[]; is exactly the same as char* string

No. The first is an array, while the second is a pointer. They're quite different.


>> In the function. You create an local array buffer. Then use it as a return value.

That's why it's a static buffer ;)

>>   tempstr = malloc(sizeof(replace_str(login, "$dlul", dlu)));
>>   strcpy(tempstr,replace_str(login, "$dlul", dlu));

> Note that you're calling replace_str twice here with the same exact parameters ... That's a bit
> wasteful, especially since you're dealing with large strings.

Ok... so how do i do it then?

> In the function. You create an local array buffer. Then use it as a return value. But the array
> will stop the exist in the exact moment the function will return. Therefore you will get a pointer
> pointing somewhere into non-valid memory, which will cause access violation when accessing it.

Yes thats why im strcpy'ing it to my string..

>> Ok... so how do i do it then?

Call it once, and save the returned char* somewhere.

But that wasn't the most important part of my post ;) The other problems I pointed out are a lot more damaging.

void initLoginData(){
  char dlugosc[32]; //10.
  char *dlu = &dlugosc[0];
  char * tempstr;

  itoa (strlen(logindata), dlu);
  tempstr = malloc(strlen(replace_str(login, "$dlul", dlu)));
  strcpy(tempstr,replace_str(login, "$dlul", dlu));
  fprintf(stderr, "ok1");
  login = realloc(login,strlen(tempstr)+strlen(logindata));
  fprintf(stderr, "ok2");
  strcpy(login,tempstr);
  strcat(login, logindata);
}

Still the same ... segmentation fault after ok1, before ok2.

The login string still doesn't have enough room to hold the concatenation of tempstr and logindata. It needs at least one more byte for the trailing '\0'.

You didn't mention whether you fixed the problems in the replace_str function.

You haven't responded to evilrix's comment.


>> segmentation fault after ok1, before ok2.

By simply looking at the output, you can't know that ... The segmentation fault might have occurred after "ok2", even if you didn't see it on the output.
Use a proper debugger to find out the exact location of the segmentation fault (try generating a core dump to analyze eg.).
Alternatively, you could use fflush to make sure that the output buffer is flushed before continuing (ie. after each printf).

You should also check the return values of malloc and realloc, to make sure that allocation succeeded.

As for evilrix's comment: i said that i'm not performing any operations on result of replace_str function, im strcpy'ing it first to my string. Or maybe thats not what he was reffering to(?).

I changed buffor size to 2048 it's surly enough.

I added 32 to every malloc / realloc

...And it did not help.

void initLoginData(){
  char dlugosc[32]; //10.
  char *dlu = &dlugosc[0];
  char * tempstr;

  itoa (strlen(logindata), dlu);
  tempstr = malloc(strlen(replace_str(login, "$dlul", dlu))+32);
  if(tempstr){
   fprintf(stderr, "tempstr ok\n");
  }
  strcpy(tempstr,replace_str(login, "$dlul", dlu));
  fprintf(stderr, "ok1");
  login = realloc(login,strlen(tempstr)+strlen(logindata)+32);
  if(login){
   fprintf(stderr, "login ok\n");
  }
  fprintf(stderr, "ok2");
  strcpy(login,tempstr);
  strcat(login, logindata);
}

>

tempstr ok
ok1Segmentation fault

To make sure that this is the function that causes it i modified main to do nothing more, so it cant becaused by anything else:

int main (int argc, char *argv[]){
 
  initLoginData();
  return 0;

}

You haven't showed what 'login' is ... Did you properly initialize it to NULL ?
You haven't showed what 'logindata' is ... Does it point to a valid C string ?

char * login = "something something something something\r\n"
                      "something something something something\r\n"
                      "something something $dlul\r\n";

char * logindata = "something something something something\r\n"
                             "something something something something\r\n"
                             "something something something something\r\n"
                             "something something something something\r\n"
                             "something something something something\r\n"
                             "something something something something\r\n"
                             "something something something something\r\n";

You can't do a realloc on a string literal :)
You can only do a realloc on dynamically allocated memory (returned by either malloc, calloc or realloc) or a NULL pointer.

Ok then how do i do what i need to do?

>> Ok then how do i do what i need to do?

What do you need to do ?

Why do you need to realloc the login string ?

I only need to replace some things in those strings and merge them to one

Yes. But you made 'login' a string literal, which means you should not (cannot) modify it. But then you want to modify it ...

If that suits you, you could simply allocate enough memory using malloc, then copy the string literal in there, and let 'login' point to that allocated memory.

How exactly? As I said, i have no idea about C, it's my first application

Is it ok to make something like this?

strcpy(LOGIN,replace_str(LOGIN, "$pass", domain));

i mean using the same variable in first in second parametr?

>> Is it ok to make something like this?

No. The two arguments of strcpy should be non-overlapping strings. And your replace_str function is written in such a way that that is a possibility.