summaryrefslogtreecommitdiffstats
path: root/uemis-downloader.c
diff options
context:
space:
mode:
Diffstat (limited to 'uemis-downloader.c')
-rw-r--r--uemis-downloader.c500
1 files changed, 224 insertions, 276 deletions
diff --git a/uemis-downloader.c b/uemis-downloader.c
index 9577c48cc..c80b1e929 100644
--- a/uemis-downloader.c
+++ b/uemis-downloader.c
@@ -44,11 +44,12 @@ static int mbuf_size = 0;
struct argument_block {
const char *mountpath;
- char **xml_buffer;
progressbar_t *progress;
gboolean force_download;
};
+static int nr_divespots = 0;
+
static int import_thread_done = 0, import_thread_cancelled;
static const char *progress_bar_text = "";
static double progress_bar_fraction = 0.0;
@@ -66,6 +67,72 @@ static GError *error(const char *fmt, ...)
return error;
}
+/* helper function to parse the Uemis data structures */
+static void uemis_ts(char *buffer, void *_when)
+{
+ struct tm tm;
+ timestamp_t *when = _when;
+
+ memset(&tm, 0, sizeof(tm));
+ sscanf(buffer,"%d-%d-%dT%d:%d:%d",
+ &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
+ &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
+ tm.tm_mon -= 1;
+ tm.tm_year -= 1900;
+ *when = utc_mktime(&tm);
+}
+
+/* float minutes */
+static void uemis_duration(char *buffer, duration_t *duration)
+{
+ duration->seconds = atof(buffer) * 60 + 0.5;
+}
+
+/* int cm */
+static void uemis_depth(char *buffer, depth_t *depth)
+{
+ depth->mm = atoi(buffer) * 10;
+}
+
+static void uemis_get_index(char *buffer, int *idx)
+{
+ *idx = atoi(buffer);
+}
+
+/* space separated */
+static void uemis_add_string(char *buffer, char **text)
+{
+ if (!buffer || !*buffer)
+ return;
+ if (!*text) {
+ *text = strdup(buffer);
+ } else {
+ char *buf = malloc(strlen(buffer) + strlen(*text) + 2);
+ strcpy(buf, *text);
+ strcat(buf, " ");
+ strcat(buf, buffer);
+ free(*text);
+ *text = buf;
+ }
+}
+
+/* still unclear if it ever reports lbs */
+static void uemis_get_weight(char *buffer, weightsystem_t *weight, int diveid)
+{
+ weight->weight.grams = uemis_get_weight_unit(diveid) ?
+ lbs_to_grams(atof(buffer)) : atof(buffer) * 1000;
+ weight->description = strdup("unknown");
+}
+
+static struct dive *uemis_start_dive(int deviceid)
+{
+ struct dive *dive = alloc_dive();
+ dive->downloaded = TRUE;
+ dive->dc.model = strdup("Uemis Zurich");
+ dive->dc.deviceid = deviceid;
+ return dive;
+}
+
/* send text to the importer progress bar */
static void uemis_info(const char *fmt, ...)
{
@@ -136,16 +203,7 @@ static gboolean uemis_init(const char *path)
close (reqtxt_file);
/* It would be nice if we could simply go back to the first set of
- * ANS files. Something like the below - unfortunately this is known
- * to fail - more information from Uemis is needed here.
- * Without code like this it is very easy when downloading large amounts
- * of dives to run out of space on the dive computer - which can only
- * be fixed by unmounting and rebooting the DC
- * reqtxt_file = g_open(reqtxt_path, O_RDWR | O_CREAT | O_TRUNC, 0666);
- * write(reqtxt_file, "n0001", 5);
- * close(reqtxt_file);
- * filenr = 1;
- */
+ * ANS files. But with a FAT filesystem that isn't possible */
ans_path = g_build_filename(path, "ANS", NULL);
number_of_files = number_of_file(ans_path);
g_free(ans_path);
@@ -246,184 +304,6 @@ static void buffer_add(char **buffer, int *buffer_size, char *buf)
#endif
}
-#define PATTERN1 "<val key=\"%s\">%s"
-#define PATTERN2 "\n<int>%d</int>"
-static gboolean get_tag_int_value(char *buffer, char *tag, int *value, char **next_ptr)
-{
- char *ptr = buffer;
- int len;
- char *format;
-
- if (!ptr || !value)
- return FALSE;
- len = strlen(PATTERN1) + strlen(PATTERN2) + strlen(tag);
- format = malloc(len);
- snprintf(format, len, PATTERN1, tag, "");
- ptr = strstr(ptr, format);
- if (!ptr)
- return FALSE;
- snprintf(format, len, PATTERN1, tag, PATTERN2);
- if (sscanf(ptr, format, value) != 1)
- return FALSE;
- if (next_ptr)
- *next_ptr = ptr + 1;
- return TRUE;
-}
-
-static gboolean get_tag_string_value(char *buffer, char *tag, char **value)
-{
- char *eptr, *ptr = buffer;
- int len;
- char *format;
-
- if (!ptr || !value)
- return FALSE;
- len = strlen(PATTERN1) + strlen(tag);
- format = malloc(len);
- snprintf(format, len, PATTERN1, tag, "");
- ptr = strstr(ptr, format);
- if (!ptr)
- return FALSE;
- eptr = strstr(ptr, "</string>");
- if (!eptr)
- return FALSE;
- *eptr = '\0';
- *value = strdup(ptr + strlen(format) + 9);
- *eptr = '<';
- return TRUE;
-}
-
-#define PATTERN4 "\n<float>%lf</float>"
-static gboolean get_tag_double_value(char *buffer, char *tag, double *value, char **next_ptr)
-{
- char *ptr = buffer;
- int len;
- char *format;
-
- if (!ptr || !value)
- return FALSE;
- len = strlen(PATTERN1) + strlen(PATTERN4) + strlen(tag);
- format = malloc(len);
- snprintf(format, len, PATTERN1, tag, "");
- ptr = strstr(ptr, format);
- if (!ptr)
- return FALSE;
- snprintf(format, len, PATTERN1, tag, PATTERN4);
- if (sscanf(ptr, format, value) != 1)
- return FALSE;
- if (next_ptr)
- *next_ptr = ptr + 1;
- return TRUE;
-}
-
-static char *get_xml_for_int(char *buf, char *tag)
-{
- int value;
- char *xml;
- if (get_tag_int_value(buf, tag, &value, NULL)) {
- int len = 20 + 2 * strlen(tag);
- xml = malloc(len);
- snprintf(xml, len, "<%s>%d</%s>\n", tag, value, tag);
- }
- return xml;
-}
-
-static const char *suit[] = { "", "wetsuit", "semidry", "drysuit" };
-static const char *suit_type[] = { "", "shorty", "vest", "long john", "jacket", "full suit", "2 pcs full suit" };
-static const char *suit_thickness[] = { "", "0.5-2mm", "2-3mm", "3-5mm", "5-7mm", "8mm+", "membrane" };
-static char *convert_dive_details(char *buf, uint8_t *hdr)
-{
- char *conv_buffer = NULL;
- int conv_size = 0;
- char *ptr, *eptr;
- double doublevalue;
- double weight;
- char *stringvalue;
- char textbuf[200];
- int suit_idx, suit_type_idx, suit_thickness_idx;
-
- /* we want to throw away what is duplicate and clean up and
- * parse the userful entries */
- ptr = strstr(buf, "<val key=\"logfilenr\">");
- if (!ptr)
- return NULL;
- eptr = strstr(ptr + 1, "<val");
- *eptr = '\0';
- buffer_add(&conv_buffer, &conv_size, ptr);
- *eptr = '<';
- buffer_add(&conv_buffer, &conv_size, get_xml_for_int(eptr, "altitude"));
- buffer_add(&conv_buffer, &conv_size, get_xml_for_int(eptr, "decoindex"));
- buffer_add(&conv_buffer, &conv_size, get_xml_for_int(eptr, "consumption"));
- if (get_tag_double_value(eptr, "f32Weight", &doublevalue, NULL)) {
- weight = hdr[24] ? lbs_to_grams(doublevalue) / 1000.0 : doublevalue;
- snprintf(textbuf, sizeof(textbuf),
- "<weightsystem weight='%.3lf' description='unknown' />\n", weight);
- buffer_add(&conv_buffer, &conv_size, textbuf);
- }
- if (get_tag_string_value(eptr, "notes", &stringvalue)) {
- buffer_add(&conv_buffer, &conv_size, "<notes>");
- buffer_add(&conv_buffer, &conv_size, stringvalue);
- buffer_add(&conv_buffer, &conv_size, "</notes>\n");
- }
- if (get_tag_int_value(eptr, "u8DiveSuit", &suit_idx, NULL) &&
- get_tag_int_value(eptr, "u8DiveSuitType", &suit_type_idx, NULL) &&
- get_tag_int_value(eptr, "u8SuitThickness", &suit_thickness_idx, NULL) &&
- suit_idx >= 0 && suit_idx < sizeof(suit) &&
- suit_type_idx >= 0 && suit_type_idx < sizeof(suit_type) &&
- suit_thickness_idx >= 0 && suit_thickness_idx < sizeof(suit_thickness)) {
- snprintf(textbuf, sizeof(textbuf), "<suit>%s %s %s</suit>\n",
- suit[suit_idx], suit_type[suit_type_idx], suit_thickness[suit_thickness_idx]);
- buffer_add(&conv_buffer, &conv_size, textbuf);
- }
- return conv_buffer;
-}
-
-/* this is more interesting - insert the additional data in the dive
- * it belongs to - no idea why Uemis splits out the dive data in this
- * odd way, but we have to re-assemble it here */
-static void buffer_insert(char **buffer, int *buffer_size, char *buf)
-{
- char *ptr, *endptr, *b64, *cbuf;
- int obj_dive;
- int obj_log;
- int offset, len;
- uint8_t hdr[27];
-
- /* since we want to insert into the buffer... if there's
- * nothing there, this makes absolutely no sense so just
- * bail */
- if (!buf || !*buffer)
- return;
- endptr = *buffer + strlen(*buffer);
- /* now figure out the object_id of buf and find the matching
- * spot in buffer */
- if (!get_tag_int_value(buf, "logfilenr", &obj_dive, NULL))
- return;
- ptr = *buffer;
- while (ptr < endptr) {
- if (!get_tag_int_value(ptr, "object_id", &obj_log, &ptr))
- return;
- if (obj_dive == obj_log)
- break;
- }
- ptr = strstr(ptr, "<val key=\"file_content\">");
- if (!ptr)
- return;
- /* this is where the base64 data starts; we need to extract
- * some info from that in order to make sense of the data in
- * the dive info */
- b64 = strstr(ptr, "<bin>") + 5;
- decode(b64, hdr, 36);
- cbuf = convert_dive_details(buf, hdr);
- offset = ptr - *buffer;
- len = strlen(cbuf);
- *buffer_size += len;
- *buffer = realloc(*buffer, *buffer_size);
- ptr = *buffer + offset;
- memmove(ptr + len, ptr, strlen(*buffer) - offset + 1);
- memmove(ptr, cbuf, len);
-}
-
/* are there more ANS files we can check? */
static gboolean next_file(int max)
{
@@ -436,12 +316,12 @@ static gboolean next_file(int max)
/* ultra-simplistic; it doesn't deal with the case when the object_id is
* split across two chunks. It also doesn't deal with the discrepancy between
* object_id and dive number as understood by the dive computer */
-static void show_progress(char *buf)
+static void show_progress(char *buf, char *what)
{
char *object;
object = strstr(buf, "object_id");
if (object) {
- /* let the user know which dive we are working on */
+ /* let the user know what we are working on */
char tmp[10];
char *p = object + 14;
char *t = tmp;
@@ -450,7 +330,7 @@ static void show_progress(char *buf)
while (*p != '{' && t < tmp + 9)
*t++ = *p++;
*t = '\0';
- uemis_info(_("Reading dive %s"), tmp);
+ uemis_info(_("Reading %s %s"), what, tmp);
}
}
}
@@ -470,6 +350,7 @@ static gboolean uemis_get_answer(const char *path, char *request, int n_param_in
char sb[BUFLEN];
char fl[13];
char tmp[101];
+ char *what = _("data");
gboolean searching = TRUE;
gboolean assembling_mbuf = FALSE;
gboolean ismulti = FALSE;
@@ -485,9 +366,16 @@ static gboolean uemis_get_answer(const char *path, char *request, int n_param_in
str_append_with_delim(sb, request);
for (i = 0; i < n_param_in; i++)
str_append_with_delim(sb, param_buff[i]);
- if (! strcmp(request, "getDivelogs") || ! strcmp(request, "getDeviceData") || ! strcmp(request, "getDirectory")) {
+ if (! strcmp(request, "getDivelogs") || ! strcmp(request, "getDeviceData") || ! strcmp(request, "getDirectory") ||
+ ! strcmp(request, "getDivespot") || strcmp(request, "getDive")) {
answer_in_mbuf = TRUE;
str_append_with_delim(sb, "");
+ if (! strcmp(request, "getDivelogs"))
+ what = _("divelog entry id");
+ else if (!strcmp(request, "getDivespot"))
+ what = _("divespot data id");
+ else if (!strcmp(request, "getDive"))
+ what = _("additional data dive id");
}
str_append_with_delim(sb, "");
file_length = strlen(sb);
@@ -567,9 +455,9 @@ static gboolean uemis_get_answer(const char *path, char *request, int n_param_in
char *buf = malloc(size - 2);
lseek(ans_file, 3, SEEK_CUR);
read(ans_file, buf, size - 3);
- buf[size -3 ] = '\0';
+ buf[size - 3] = '\0';
buffer_add(&mbuf, &mbuf_size, buf);
- show_progress(buf);
+ show_progress(buf, what);
free(buf);
param_buff[3]++;
}
@@ -592,6 +480,8 @@ static gboolean uemis_get_answer(const char *path, char *request, int n_param_in
lseek(ans_file, 3, SEEK_CUR);
read(ans_file, buf, size - 3);
buf[size - 3] = '\0';
+ buffer_add(&mbuf, &mbuf_size, buf);
+ show_progress(buf, what);
#if UEMIS_DEBUG > 3
fprintf(debugfile, "::r %s \"%s\"\n", ans_path, buf);
#endif
@@ -618,22 +508,105 @@ static gboolean uemis_get_answer(const char *path, char *request, int n_param_in
return found_answer;
}
-/* Turn what we get from the dive computer into something that we can
- * pass to the parse_xml function. If this is a divelog, then the
- * last 'object_id' that we see is returned as our current
- * approximation of a last dive number */
-static char *process_raw_buffer(char *inbuf, char **max_divenr)
+static void parse_divespot(char *buf)
+{
+ char *bp = buf + 1;
+ char *tp = next_token(&bp);
+ char *tag, *type, *val;
+ char locationstring[255] = "";
+ int divespot, len;
+ double latitude, longitude;
+
+
+ if (strcmp(tp, "divespot"))
+ return;
+ do
+ tag = next_token(&bp);
+ while (*tag && strcmp(tag, "object_id"));
+ if (! *tag)
+ return;
+ type = next_token(&bp);
+ val = next_token(&bp);
+ divespot = atoi(val);
+ do {
+ tag = next_token(&bp);
+ type = next_token(&bp);
+ val = next_token(&bp);
+ if (!strcmp(type, "string") && *val && strcmp(val, " ")) {
+ len = strlen(locationstring);
+ snprintf(locationstring + len, sizeof(locationstring) - len,
+ "%s%s", len ? ", " : "", val);
+ } else if (!strcmp(type, "float")) {
+ if (!strcmp(tag, "longitude"))
+ longitude = atof(val);
+ else if (!strcmp(tag, "latitude"))
+ latitude = atof(val);
+ }
+ } while (tag && *tag);
+ uemis_set_divelocation(divespot, strdup(locationstring), latitude, longitude);
+}
+
+static void track_divespot(char *val, int diveid, char **location, double *latitude, double *longitude)
+{
+ int id = atoi(val);
+ if (id >= 0 && id > nr_divespots)
+ nr_divespots = id;
+ uemis_mark_divelocation(diveid, id, location, latitude, longitude);
+ return;
+}
+
+static char *suit[] = { "", "wetsuit", "semidry", "drysuit" };
+static char *suit_type[] = { "", "shorty", "vest", "long john", "jacket", "full suit", "2 pcs full suit" };
+static char *suit_thickness[] = { "", "0.5-2mm", "2-3mm", "3-5mm", "5-7mm", "8mm+", "membrane" };
+
+static void parse_tag(struct dive *dive, char *tag, char *val)
+{
+ /* we can ignore computer_id, water and gas as those are redundant
+ * with the binary data and would just get overwritten */
+ if (! strcmp(tag, "date"))
+ uemis_ts(val, &dive->when);
+ else if (!strcmp(tag, "duration"))
+ uemis_duration(val, &dive->duration);
+ else if (!strcmp(tag, "depth"))
+ uemis_depth(val, &dive->maxdepth);
+ else if (!strcmp(tag, "file_content"))
+ uemis_parse_divelog_binary(val, dive);
+ else if (!strcmp(tag, "altitude"))
+ uemis_get_index(val, &dive->surface_pressure.mbar);
+ else if (!strcmp(tag, "f32Weight"))
+ uemis_get_weight(val, &dive->weightsystem[0], dive->dc.diveid);
+ else if (!strcmp(tag, "notes"))
+ uemis_add_string(val, &dive->notes);
+ else if (!strcmp(tag, "u8DiveSuit"))
+ uemis_add_string(suit[atoi(val)], &dive->suit);
+ else if (!strcmp(tag, "u8DiveSuitType"))
+ uemis_add_string(suit_type[atoi(val)], &dive->suit);
+ else if (!strcmp(tag, "u8SuitThickness"))
+ uemis_add_string(suit_thickness[atoi(val)], &dive->suit);
+}
+
+/* This function is called for both divelog and dive information that we get
+ * from the SDA (what an insane design, btw). The object_id in the divelog
+ * matches the logfilenr in the dive information (which has its own, often
+ * different object_id) - we use this as the diveid.
+ * We create the dive when parsing the divelog and then later, when we parse
+ * the dive information we locate the already created dive via its diveid.
+ * Most things just get parsed and converted into our internal data structures,
+ * but the dive location API is even more crazy. We just get an id that is an
+ * index into yet another data store that we read out later. In order to
+ * correctly populate the location and gps data from that we need to remember
+ * the adresses of those fields for every dive that references the divespot. */
+static void process_raw_buffer(int deviceid, char *inbuf, char **max_divenr)
{
char *buf = strdup(inbuf);
char *tp, *bp, *tag, *type, *val;
gboolean done = FALSE;
int inbuflen = strlen(inbuf);
char *endptr = buf + inbuflen;
- char *conv_buffer = NULL;
- int conv_buffer_size = 0;
gboolean log = FALSE;
char *sections[10];
int s, nr_sections = 0;
+ struct dive *dive = NULL;
bp = buf + 1;
tp = next_token(&bp);
@@ -642,23 +615,19 @@ static char *process_raw_buffer(char *inbuf, char **max_divenr)
log = TRUE;
tp = next_token(&bp);
if (strcmp(tp,"1.0") != 0)
- return NULL;
+ return;
} else if (strcmp(tp, "dive") == 0) {
/* this is dive detail */
tp = next_token(&bp);
if (strcmp(tp,"1.0") != 0)
- return NULL;
+ return;
} else {
/* don't understand the buffer */
- return NULL;
+ return;
}
if (log)
- buffer_add(&conv_buffer, &conv_buffer_size,
- "<dive type=\"uemis\" ref=\"divelog\" version=\"1.0\">\n");
+ dive = uemis_start_dive(deviceid);
while (!done) {
- char *tmp;
- int tmp_size;
-
/* the valid buffer ends with a series of delimiters */
if (bp >= endptr - 2 || !strcmp(bp, "{{"))
break;
@@ -687,36 +656,38 @@ static char *process_raw_buffer(char *inbuf, char **max_divenr)
if (log && ! strcmp(tag, "object_id")) {
free(*max_divenr);
*max_divenr = strdup(val);
+ dive->dc.diveid = atoi(val);
+ } else if (!log && ! strcmp(tag, "logfilenr")) {
+ /* this one tells us which dive we are adding data to */
+ dive = get_dive_by_diveid(atoi(val), deviceid);
+ } else if (!log && dive && ! strcmp(tag, "divespot_id")) {
+ track_divespot(val, dive->dc.diveid, &dive->location, &dive->latitude, &dive->longitude);
+ } else if (dive) {
+ parse_tag(dive, tag, val);
}
- if (! strcmp(tag, "file_content")) {
- tmp_size = 45 + strlen(tag) + strlen(val);
+ if (log && ! strcmp(tag, "file_content"))
done = TRUE;
- } else {
- tmp_size = 28 + strlen(tag) + 2 * strlen(type) + strlen(val);
- }
- tmp = malloc(tmp_size);
- snprintf(tmp, tmp_size, "<val key=\"%s\">\n<%s>%s</%s>\n</val>\n",
- tag, type, val, type);
- buffer_add(&conv_buffer, &conv_buffer_size, tmp);
- free(tmp);
/* done with one dive (got the file_content tag), but there could be more:
* a '{' indicates the end of the record - but we need to see another "{{"
* later in the buffer to know that the next record is complete (it could
* be a short read because of some error */
if (done && ++bp < endptr && *bp != '{' && strstr(bp, "{{")) {
done = FALSE;
- buffer_add(&conv_buffer, &conv_buffer_size,
- "</dive>\n<dive type=\"uemis\" ref=\"divelog\" version=\"1.0\">\n");
+ record_dive(dive);
+ mark_divelist_changed(TRUE);
+ dive = uemis_start_dive(deviceid);
}
}
if (log) {
- buffer_add(&conv_buffer, &conv_buffer_size, "</dive>\n");
+ if (dive->dc.diveid) {
+ record_dive(dive);
+ mark_divelist_changed(TRUE);
+ } else { /* partial dive */
+ free(dive);
+ }
}
free(buf);
-#if UEMIS_DEBUG > 3
- fprintf(debugfile,"converted to \"%s\"\n", conv_buffer);
-#endif
- return strdup(conv_buffer);
+ return;
}
static char *get_divenr(char *deviceidstr)
@@ -724,38 +695,34 @@ static char *get_divenr(char *deviceidstr)
int deviceid, i, maxdiveid = 0;
char divenr[10];
- if (sscanf(deviceidstr, "%d", &deviceid) != 1)
- return "0";
+ deviceid = atoi(deviceidstr);
for (i = 0; i < dive_table.nr; i++) {
struct divecomputer *dc = &dive_table.dives[i]->dc;
if (dc->deviceid == deviceid && dc->diveid > maxdiveid)
maxdiveid = dc->diveid;
}
snprintf(divenr, 10, "%d", maxdiveid);
-
return strdup(divenr);
}
static char *do_uemis_download(struct argument_block *args)
{
const char *mountpath = args->mountpath;
- char **xml_buffer = args->xml_buffer;
- int xml_buffer_size;
char *newmax = NULL;
- int start, end, i;
+ int start, end, i, deviceidnr;
char objectid[10];
char *deviceid = NULL;
char *result = NULL;
char *endptr;
gboolean success;
- buffer_add(xml_buffer, &xml_buffer_size, "<dives type='uemis'><string></string>\n<list>\n");
uemis_info("Init Communication");
if (! uemis_init(mountpath))
return _("Uemis init failed");
if (! uemis_get_answer(mountpath, "getDeviceId", 0, 1, &result))
goto bail;
deviceid = strdup(param_buff[0]);
+ deviceidnr = atoi(deviceid);
/* the answer from the DeviceId call becomes the input parameter for getDeviceData */
if (! uemis_get_answer(mountpath, "getDeviceData", 1, 0, &result))
goto bail;
@@ -769,35 +736,25 @@ static char *do_uemis_download(struct argument_block *args)
if (import_thread_cancelled)
goto bail;
param_buff[1] = "notempty";
- /* if we have an empty divelist then the user will almost
- * certainly want to start downloading from the first dive on
- * the Uemis; otherwise check which was the last dive
- * downloaded */
+ /* if we have an empty divelist or force it, then we start downloading from the
+ * first dive on the Uemis; otherwise check which was the last dive downloaded */
if (!args->force_download && dive_table.nr > 0)
newmax = get_divenr(deviceid);
else
newmax = strdup("0");
-
- if (sscanf(newmax, "%d", &start) != 1)
- start = 0;
+ start = atoi(newmax);
for (;;) {
param_buff[2] = newmax;
param_buff[3] = 0;
success = uemis_get_answer(mountpath, "getDivelogs", 3, 0, &result);
/* process the buffer we have assembled */
- if (mbuf) {
- char *next_seg = process_raw_buffer(mbuf, &newmax);
- buffer_add(xml_buffer, &xml_buffer_size, next_seg);
- free(next_seg);
- }
- /* if we got an error, deal with it */
- if (!success)
- break;
- /* if the user clicked cancel, exit gracefully but ignore everything read */
+ if (mbuf)
+ process_raw_buffer(deviceidnr, mbuf, &newmax);
+ /* if the user clicked cancel, exit gracefully */
if (import_thread_cancelled)
goto bail;
- /* also, if we got nothing back, we should stop trying */
- if (!param_buff[3])
+ /* if we got an error or got nothing back, stop trying */
+ if (!success || !param_buff[3])
break;
/* finally, if the memory is getting too full, maybe we better stop, too */
if (progress_bar_fraction > 0.85) {
@@ -818,16 +775,21 @@ static char *do_uemis_download(struct argument_block *args)
for (i = start; i < end; i++) {
snprintf(objectid, sizeof(objectid), "%d", i);
param_buff[2] = objectid;
- param_buff[3] = 0;
success = uemis_get_answer(mountpath, "getDive", 3, 0, &result);
- if (mbuf) {
- char *next_detail = process_raw_buffer(mbuf, &newmax);
- buffer_insert(xml_buffer, &xml_buffer_size, next_detail);
- free(next_detail);
- }
+ if (mbuf)
+ process_raw_buffer(deviceidnr, mbuf, &newmax);
if (!success || import_thread_cancelled)
break;
}
+ success = TRUE;
+ for (i = 0; i <= nr_divespots; i++) {
+ char divespotnr[10];
+ snprintf(divespotnr, sizeof(divespotnr), "%d", i);
+ param_buff[2] = divespotnr;
+ success = uemis_get_answer(mountpath, "getDivespot", 3, 0, &result);
+ if (mbuf)
+ parse_divespot(mbuf);
+ }
bail:
(void) uemis_get_answer(mountpath, "terminateSync", 0, 3, &result);
if (! strcmp(param_buff[0], "error")) {
@@ -836,13 +798,6 @@ bail:
else
result = param_buff[2];
}
- if (import_thread_cancelled)
- xml_buffer[0] = 0;
- else
- buffer_add(xml_buffer, &xml_buffer_size, "</list></dives>");
-#if UEMIS_DEBUG > 5
- fprintf(debugfile, "XML buffer \"%s\"", *xml_buffer);
-#endif
free(deviceid);
return result;
}
@@ -866,12 +821,12 @@ static gboolean timeout_func(gpointer _data)
return FALSE;
}
-GError *uemis_download(const char *mountpath, char **xml_buffer, progressbar_t *progress,
+GError *uemis_download(const char *mountpath, progressbar_t *progress,
GtkDialog *dialog, gboolean force_download)
{
pthread_t pthread;
void *retval;
- struct argument_block args = {mountpath, xml_buffer, progress, force_download};
+ struct argument_block args = {mountpath, progress, force_download};
/* I'm sure there is some better interface for waiting on a thread in a UI main loop */
import_thread_done = 0;
@@ -891,18 +846,11 @@ GError *uemis_download(const char *mountpath, char **xml_buffer, progressbar_t *
update_progressbar(args.progress, progress_bar_fraction);
update_progressbar_text(args.progress, progress_bar_text);
result = gtk_dialog_run(dialog);
- switch (result) {
- case GTK_RESPONSE_CANCEL:
+ if (result == GTK_RESPONSE_CANCEL)
import_thread_cancelled = TRUE;
- progress_bar_text = "Cancelled...";
- break;
- default:
- /* nothing */
- break;
- }
} else {
update_progressbar(args.progress, progress_bar_fraction);
- update_progressbar_text(args.progress, progress_bar_text);
+ update_progressbar_text(args.progress, "Cancelled, exiting cleanly...");
usleep(100000);
}
}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-12-29 04:07:50 +0000