libcurl program crashes on curl_easy_init?

I wrote a simple libcurl program with several calls to the following function:

Code:

---

char* import(char* in) {

CURL *curl;
puts("*curl");
curl = curl_easy_init();
puts("init");

if(curl == NULL)
{
puts("EASY_INIT WENT WRONG.");
exit(0);
}

char *data;

/* Create the write buffer */
data = malloc(1024 * 256);

if (data == NULL)
{
puts("Not enough memory for import buffer.");
exit(0);
}

struct write_result write_result = {
.data = data,
.pos = 0
};

/* Set curl's parameters */
curl_easy_setopt(curl, CURLOPT_URL,in);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &write_result);

curl_easy_perform(curl);

/* null terminate the string */
data[write_result.pos] = '\0';

curl_easy_cleanup(curl);
curl_global_cleanup();

return(data);

}

---

The weird thing is, I use the function often in the main program, and sometimes it works, sometimes it doesn't. When it doesn't work, it gets as far as printing "*curl", and then just crashes. Generally what happens is, it crashes several times in a row, on the exact same call (the previous work perfectly), and then inexplicably works fine again later on...

Does anyone have any idea what may be causing this and how to stop it???
Any help would be greatly appreciated

And what is the state of your network while all this is going on?

My connection seems okay; as the previous calls to the function work, just one particular call fails for some reason

> curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write);
What does this function do (curl_write) ?

In particular, how does it know how much data is available in the struct write_result structure?

Sorry, i forgot about the other definitions:

Code:

---

struct write_result {
char *data;
int pos;
};

---

and

Code:

---

static size_t curl_write( void *ptr, size_t size, size_t nmemb, void *stream) {

struct write_result *result = (struct write_result *)stream;

/* Will we overflow on this write? */
if(result->pos + size * nmemb >= (1024 * 256) - 1) {
return 0;
}

/* Copy curl's stream buffer into our own buffer */
memcpy(result->data + result->pos, ptr, size * nmemb);

/* Advance the position */
result->pos += size * nmemb;

return (size * nmemb);
}

---

I don't think the problem is related to free()ing memory properly either; every time i call inport(), I make sure to free the malloc'd pointer "data" as soon as I've used the returned string... I wonder is there any other error condition that can cause easy_init to crash apart from returning a NULL value? Oddly the program is now into a phase where it's working again (this will no doubt be short-lived), though I haven't changed the code at all, and my connection seems to be just as good as it was before

Use a debugger to help pinpoint the problem. Gdb will tell you where the crash is happening, Valgrind might be able to tell you what you're doing that's causing the crash.

> /* Advance the position */
> result->pos += size * nmemb;
How does this affect the validity of this calculation the next time around?

> if(result->pos + size * nmemb >= (1024 * 256) - 1)



Add a .size member to your structure, and update it with the real amount of space still available, as you add data.