void XMLHttpRequest::send(ArrayBuffer* ab)
{
if(curl && ab)
{
if(ab->byteLength>0)
{
requestDataBuffer.clear();
requestDataBuffer.resize(ab->byteLength+1);
memcpy(requestDataBuffer.data(), ab->data, ab->byteLength);
*(requestDataBuffer.data()+ab->byteLength) = 0;
}
curl_send();
readyState=LOADING;
tick();
}
}
void XMLHttpRequest::send(String data)
{
if(curl)
{
UINT cb = data.size();
if(cb>0)
{
// TODO: convert string to UTF8
requestDataBuffer.clear();
requestDataBuffer.resize(cb + 1);
memcpy(requestDataBuffer.data(), data.c_str(), cb);
*(requestDataBuffer.data() + cb) = 0;
}
curl_send();
readyState=LOADING;
tick();
}
}
void XMLHttpRequest::send(String data)
{
if(curl)
{
/*
UINT cb = data.size();
if(cb>0)
{
BSTR s = STR_to_BSTR(data);
cb = SysStringByteLen(s);
requestDataBuffer.clear();
requestDataBuffer.resize(cb+1);
memcpy(requestDataBuffer.data(), s, cb);
*(requestDataBuffer.data()+cb) = 0;
SysFreeString(s);
}
*/
curl_send();
readyState=LOADING;
tick();
}
}
int main(int argc, char** argv) {
if (argc != 2) {
strncpy(uploads_url, DEFAULT_UPLOADS_URL, MAX_URL_LENGTH);
} else {
strncpy(uploads_url, argv[1], MAX_URL_LENGTH);
}
openlog("bismark-data-transmit", LOG_PERROR, LOG_USER);
if (read_bismark_id()) {
return 1;
}
if (initialize_upload_subdirectories() || initialize_upload_directories()) {
return 1;
}
failure_counters = calloc(num_upload_subdirectories,
sizeof(failure_counters[0]));
if (failure_counters == NULL) {
syslog(LOG_ERR, "main:calloc: %s", strerror(errno));
return 1;
}
if (write_upload_failures_log()) {
return 1;
}
if (initialize_curl()) {
return 1;
}
/* Initialize inotify */
int inotify_handle = inotify_init();
if (inotify_handle < 0) {
syslog(LOG_ERR, "main:inotify_init: %s", strerror(errno));
return 1;
}
int idx;
watch_descriptors = calloc(num_upload_subdirectories,
sizeof(watch_descriptors[0]));
if (watch_descriptors == NULL) {
syslog(LOG_ERR, "main:calloc: %s", strerror(errno));
return 1;
}
for (idx = 0; idx < num_upload_subdirectories; ++idx) {
watch_descriptors[idx] = inotify_add_watch(inotify_handle,
upload_directories[idx],
IN_MOVED_TO);
if (watch_descriptors[idx] < 0) {
syslog(LOG_ERR,
"main:inotify_add_watch(\"%s\"): %s",
upload_directories[idx],
strerror(errno));
return 1;
}
syslog(LOG_INFO, "Watching %s", upload_directories[idx]);
}
time_t current_time = time(NULL);
if (current_time < 0) {
syslog(LOG_ERR, "main:time: %s", strerror(errno));
return 1;
}
time_t last_retry_time = current_time - RETRY_INTERVAL_SECONDS;
while (1) {
current_time = time(NULL);
if (current_time < 0) {
syslog(LOG_ERR, "main:time: %s", strerror(errno));
return 1;
}
fd_set select_set;
FD_ZERO(&select_set);
FD_SET(inotify_handle, &select_set);
struct timeval select_timeout;
select_timeout.tv_sec =
RETRY_INTERVAL_SECONDS - (current_time - last_retry_time);
if (select_timeout.tv_sec < 0) {
select_timeout.tv_sec = 0;
}
select_timeout.tv_usec = 0;
int select_result = select(
inotify_handle + 1, &select_set, NULL, NULL, &select_timeout);
if (select_result < 0) {
syslog(LOG_ERR, "main:select: %s", strerror(errno));
curl_easy_cleanup(curl_handle);
return 1;
} else if (select_result > 0) {
if (FD_ISSET(inotify_handle, &select_set)) {
char events_buffer[BUF_LEN];
int length = read(inotify_handle, events_buffer, BUF_LEN);
if (length < 0) {
syslog(LOG_ERR, "main:read: %s", strerror(errno));
curl_easy_cleanup(curl_handle);
return 1;
}
int offset = 0;
while (offset < length) {
struct inotify_event* event \
= (struct inotify_event*)(events_buffer + offset);
if (event->len && (event->mask & IN_MOVED_TO)) {
int idx;
for (idx = 0; idx < num_upload_subdirectories; ++idx) {
if (event->wd == watch_descriptors[idx]) {
char absolute_path[PATH_MAX + 1];
if (join_paths(
upload_directories[idx], event->name, absolute_path)) {
break;
}
syslog(LOG_INFO, "File move detected: %s", absolute_path);
if (!curl_send(absolute_path, upload_subdirectories[idx])) {
if (unlink(absolute_path)) {
syslog(LOG_ERR,
"main:unlink(\"%s\"): %s",
absolute_path,
strerror(errno));
}
}
break;
}
}
}
offset += sizeof(*event) + event->len;
}
}
} else if (select_result == 0) {
current_time = time(NULL);
if (current_time < 0) {
syslog(LOG_ERR, "main:time: %s", strerror(errno));
return 1;
}
retry_uploads(current_time);
last_retry_time = time(NULL);
if (last_retry_time < 0) {
syslog(LOG_ERR, "main:time: %s", strerror(errno));
return 1;
}
}
}
return 0;
}
static void retry_uploads(time_t current_time) {
upload_list_t files_to_sort;
upload_list_init(&files_to_sort);
int new_upload_failure = 0;
syslog(LOG_INFO, "Checking for uploads to retry");
int idx;
for (idx = 0; idx < num_upload_subdirectories; ++idx) {
DIR* handle = opendir(upload_directories[idx]);
if (handle == NULL) {
syslog(LOG_ERR,
"retry_uploads:opendir(\"%s\"): %s",
upload_directories[idx],
strerror(errno));
continue;
}
struct dirent* entry;
while ((entry = readdir(handle))) {
char absolute_path[PATH_MAX + 1];
if (join_paths(upload_directories[idx], entry->d_name, absolute_path)) {
continue;
}
struct stat file_info;
if (stat(absolute_path, &file_info)) {
syslog(LOG_ERR,
"retry_uploads:stat(\"%s\"): %s",
absolute_path,
strerror(errno));
continue;
}
if (S_ISREG(file_info.st_mode) || S_ISLNK(file_info.st_mode)) {
if (current_time - file_info.st_ctime > RETRY_INTERVAL_SECONDS) {
syslog(LOG_INFO, "Retrying file: %s", absolute_path);
if (curl_send(absolute_path, upload_subdirectories[idx]) == 0) {
if (unlink(absolute_path)) {
syslog(LOG_ERR,
"retry_uploads:unlink(\"%s\"): %s",
absolute_path,
strerror(errno));
} else {
continue;
}
}
}
upload_list_append(&files_to_sort,
absolute_path,
file_info.st_ctime,
file_info.st_blocks,
idx);
}
}
if (closedir(handle)) {
syslog(LOG_ERR, "retry_uploads:closedir: %s", strerror(errno));
}
}
if (files_to_sort.entries != NULL) {
upload_list_sort(&files_to_sort);
int total_blocks = 0;
for (idx = 0; idx < files_to_sort.length; ++idx) {
upload_entry_t* entry = &files_to_sort.entries[idx];
if (total_blocks + entry->size > MAX_UPLOADS_BLOCKS) {
syslog(LOG_INFO,
"Removing old upload: %s",
files_to_sort.entries[idx].filename);
if (unlink(files_to_sort.entries[idx].filename)) {
syslog(LOG_ERR,
"retry_uploads:unlink(\"%s\"): %s",
files_to_sort.entries[idx].filename,
strerror(errno));
} else {
log_upload_failure(files_to_sort.entries[idx].index);
new_upload_failure = 1;
}
} else {
total_blocks += entry->size;
}
}
}
upload_list_destroy(&files_to_sort);
if (new_upload_failure) {
(void)write_upload_failures_log();
}
}
