int handle_response(char *ip, char *filename) {
int i;
char buffer[RESPONSE_BUFFER_SIZE];
int buffer_size = 0;
int pointer = 0;
char status_line[HEADER_LINE_LENGTH];
char header[HEADER_LINE_LENGTH];
char value[HEADER_LINE_LENGTH];
int status_ok;
char header_content_length[HEADER_LINE_LENGTH];
char header_content_type[HEADER_LINE_LENGTH];
char header_last_modified[HEADER_LINE_LENGTH];
time_t curtime;
char current_time[HEADER_LINE_LENGTH];
FILE *fp;
/* fill buffer with first part of response */
buffer_size = get_response_header(buffer, RESPONSE_BUFFER_SIZE);
if (buffer_size < 0) {
printf("Request failed: could not retrieve response from server\n");
return 0;
}
/* read status line */
pointer = parse_status_line(buffer, buffer_size, status_line,
HEADER_LINE_LENGTH, &status_ok);
if (pointer < 0) {
printf("Request failed: invalid response status code sent by server\n");
return 0;
}
/* default value for headers */
snprintf(header_content_length, HEADER_LINE_LENGTH, "Unknown");
snprintf(header_content_type, HEADER_LINE_LENGTH, "Unknown");
snprintf(header_last_modified, HEADER_LINE_LENGTH, "Unknown");
/* read headers */
while ((i = parse_header(buffer + pointer, buffer_size - pointer,
header, HEADER_LINE_LENGTH,
value, HEADER_LINE_LENGTH)) > 0) {
pointer += i;
if (strcmp(header, "Content-Length") == 0) {
memcpy(header_content_length, value, HEADER_LINE_LENGTH);
} else if (strcmp(header, "Content-Type") == 0) {
memcpy(header_content_type, value, HEADER_LINE_LENGTH);
} else if (strcmp(header, "Last-Modified") == 0) {
memcpy(header_last_modified, value, HEADER_LINE_LENGTH);
}
}
i = read_separator(buffer + pointer, buffer_size - pointer);
if (i < 0) {
printf("Request failed: invalid response sent by server\n");
return 0;
}
pointer += i;
/* get current time */
time(&curtime);
strftime(current_time, HEADER_LINE_LENGTH, DATE_TIME_FORMAT,
gmtime(&curtime));
/* print some output */
printf("Request sent to http server at %s. Received response:\n", ip);
printf(" The return code was: %s\n", status_line);
printf(" Date of retrieval: %s\n", current_time);
printf(" Document last modified at: %s\n", header_last_modified);
printf(" Document size: %s bytes\n", header_content_length);
printf(" Document's mime type: %s\n", header_content_type);
if (!status_ok) {
printf("Since the status code was not '200 OK', no data has been written\nto %s\n",
filename);
return 1;
}
/* open file for writing */
if ((fp = fopen(filename, "w")) == (FILE *)0) {
switch (errno) {
case EACCES:
printf("No permissions to open file for writing: %s\n", filename);
return 0;
break;
default:
printf("Could not open file for writing: %s\n", filename);
return 0;
}
}
/* read until end of stream */
do {
/* write buffer contents to file */
while (pointer < buffer_size) {
putc(buffer[pointer], fp);
pointer++;
}
signal(SIGALRM, alarm_handler);
alarm(TIME_OUT);
buffer_size = tcp_read(buffer, RESPONSE_BUFFER_SIZE);
alarm(0);
/* failed reading */
if (buffer_size < 0
|| alarm_went_off) {
/*
Actually, we should write to a temp file
and delete it here. Only if all data is
received, copy temp file to real file.
But this is a problem if we have write
rights on filename, but not to create
temp file. So we leave this for the time
being.
*/
fclose(fp);
printf("Request failed: could not retrieve message body\n");
printf("Wrote partial message body to file: %s\n", filename);
return 0;
}
pointer = 0;
} while (buffer_size);
fclose(fp);
printf("Wrote message body to file: %s\n", filename);
return 1;
}
/**
* Function for modifying an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_modify(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* search;
gchar* uid;
gboolean result = FALSE;
gboolean LOCKSUPPORT = FALSE;
gchar* lock_token = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* file = g_strdup(settings->file);
if ((uid = get_response_header("uid", file, FALSE)) == NULL) {
g_free(file);
error->code = 1;
error->str = g_strdup("Error: Missing required UID for object");
return TRUE;
}
g_free(file);
/*
* collation is not supported by ICalendar.
* <C:text-match collation=\"i;ascii-casemap\">%s</C:text-match>
*/
search = g_strdup_printf(
"%s\r\n<C:text-match>%s</C:text-match>\r\n%s",
search_head, uid, search_tail);
g_free(uid);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, search);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(search));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
http_header = NULL;
g_free(search);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
else {
/* enable uploading */
gchar* url = NULL;
gchar* etag = NULL;
url = get_url(chunk.memory);
if (url) {
etag = get_etag(chunk.memory);
if (etag) {
gchar* host = get_host(settings->url);
if (host) {
file = g_strdup(url);
g_free(url);
url = g_strdup_printf("%s%s", host, file);
g_free(file);
g_free(host);
}
else {
g_free(etag);
g_free(url);
url = NULL;
}
}
else {
g_free(url);
url = NULL;
}
if (url) {
int lock = 0;
caldav_error lock_error;
file = g_strdup(etag);
g_free(etag);
etag = g_strdup_printf("If-Match: %s", file);
g_free(file);
http_header = curl_slist_append(http_header, etag);
g_free(etag);
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(
http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
if (settings->use_locking)
LOCKSUPPORT = caldav_lock_support(settings, &lock_error);
else
LOCKSUPPORT = FALSE;
if (LOCKSUPPORT) {
lock_token = caldav_lock_object(url, settings, &lock_error);
if (lock_token) {
http_header = curl_slist_append(
http_header, g_strdup_printf(
"If: (%s)", lock_token));
}
/*
* If error code is 423 (Resource is LOCKED) bail out
*/
else if (lock_error.code == 423) {
lock = -1;
}
/*
* If error code is 501 (Not implemented) we continue
* hoping for the best.
*/
else if (lock_error.code == 501) {
lock_token = g_strdup("");
}
else {
lock = -1;
}
}
if (! LOCKSUPPORT || (LOCKSUPPORT && lock_token && lock_error.code != 423)) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_URL, rebuild_url(settings, url));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, settings->file);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE,
strlen(settings->file));
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
res = curl_easy_perform(curl);
if (LOCKSUPPORT && lock_token) {
caldav_unlock_object(
lock_token, url, settings, &lock_error);
}
}
g_free(url);
g_free(lock_token);
if (res != 0 || lock < 0) {
/* Is this a lock_error don't change error*/
if (lock == 0 || lock_error.code == 423) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
error->code = lock_error.code;
error->str = g_strdup(lock_error.str);
}
result = TRUE;
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(
curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
}
curl_slist_free_all(http_header);
}
else {
error->code = code;
if (chunk.memory)
error->str = g_strdup(chunk.memory);
else
error->str = g_strdup("No object found");
result = TRUE;
}
}
else {
/*
* No object found on server. Posible synchronization
* problem or a server side race condition
*/
error->code = 409;
error->str = g_strdup("No object found");
result = TRUE;
}
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}
