mirror of
https://github.com/subsurface/subsurface.git
synced 2024-11-28 05:00:20 +00:00
1aa3c0d514
It turns out that the serial number returned by libdivecomputer isn't really the serial number as interpreted by the vendor. Those tend to be strings, but libdivecomputer gives us a 32bit number. Some experimenting showed that for the Suunto devies tested the serial number is encoded in that 32bit number: It so happens that the Suunto serial number strings are strings that have all numbers, but they aren't *one* number. They are four bytes representing two numbers each, and the "23500027" string is actually the four bytes 23 50 00 27 (0x17 0x32 0x00 0x1b). And libdivecomputer has incorrectly parsed those four bytes as one number, not as the encoded serial number string it is. So the value 389152795 is actually hex 0x1732001b, which is 0x17 0x32 0x00 0x1b, which is - 23 50 00 27. This should be done by libdivecomputer, but hey, in the meantime this at least shows the concept. And helps test the XML save/restore code. It depends on the two patches that create the whole "device.c" infrastructure, of course. With this, my dive file ends up having the settings section look like this: <divecomputerid model='Suunto Vyper Air' deviceid='d4629110' serial='01201094' firmware='1.1.22'/> <divecomputerid model='Suunto HelO2' deviceid='995dd566' serial='23500027' firmware='1.0.4'/> where the format of the firmware version is something I guessed at, but it was the obvious choice (again, it's byte-based, I'm ignoring the high byte that is zero for both of my Suuntos). Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
582 lines
14 KiB
C
582 lines
14 KiB
C
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
|
|
#include "dive.h"
|
|
#include "device.h"
|
|
|
|
static void show_milli(FILE *f, const char *pre, int value, const char *unit, const char *post)
|
|
{
|
|
int i;
|
|
char buf[4];
|
|
unsigned v;
|
|
|
|
fputs(pre, f);
|
|
v = value;
|
|
if (value < 0) {
|
|
putc('-', f);
|
|
v = -value;
|
|
}
|
|
for (i = 2; i >= 0; i--) {
|
|
buf[i] = (v % 10) + '0';
|
|
v /= 10;
|
|
}
|
|
buf[3] = 0;
|
|
if (buf[2] == '0') {
|
|
buf[2] = 0;
|
|
if (buf[1] == '0')
|
|
buf[1] = 0;
|
|
}
|
|
|
|
fprintf(f, "%u.%s%s%s", v, buf, unit, post);
|
|
}
|
|
|
|
static void show_temperature(FILE *f, temperature_t temp, const char *pre, const char *post)
|
|
{
|
|
if (temp.mkelvin)
|
|
show_milli(f, pre, temp.mkelvin - 273150, " C", post);
|
|
}
|
|
|
|
static void show_depth(FILE *f, depth_t depth, const char *pre, const char *post)
|
|
{
|
|
if (depth.mm)
|
|
show_milli(f, pre, depth.mm, " m", post);
|
|
}
|
|
|
|
static void show_duration(FILE *f, duration_t duration, const char *pre, const char *post)
|
|
{
|
|
if (duration.seconds)
|
|
fprintf(f, "%s%u:%02u min%s", pre, FRACTION(duration.seconds, 60), post);
|
|
}
|
|
|
|
static void show_pressure(FILE *f, pressure_t pressure, const char *pre, const char *post)
|
|
{
|
|
if (pressure.mbar)
|
|
show_milli(f, pre, pressure.mbar, " bar", post);
|
|
}
|
|
|
|
static void show_salinity(FILE *f, int salinity, const char *pre, const char *post)
|
|
{
|
|
if (salinity)
|
|
fprintf(f, "%s%d g/l%s", pre, salinity / 10, post);
|
|
}
|
|
/*
|
|
* We're outputting utf8 in xml.
|
|
* We need to quote the characters <, >, &.
|
|
*
|
|
* Technically I don't think we'd necessarily need to quote the control
|
|
* characters, but at least libxml2 doesn't like them. It doesn't even
|
|
* allow them quoted. So we just skip them and replace them with '?'.
|
|
*
|
|
* If we do this for attributes, we need to quote the quotes we use too.
|
|
*/
|
|
static void quote(FILE *f, const char *text, int is_attribute)
|
|
{
|
|
const char *p = text;
|
|
|
|
for (;;) {
|
|
const char *escape;
|
|
|
|
switch (*p++) {
|
|
default:
|
|
continue;
|
|
case 0:
|
|
escape = NULL;
|
|
break;
|
|
case 1 ... 8:
|
|
case 11: case 12:
|
|
case 14 ... 31:
|
|
escape = "?";
|
|
break;
|
|
case '<':
|
|
escape = "<";
|
|
break;
|
|
case '>':
|
|
escape = ">";
|
|
break;
|
|
case '&':
|
|
escape = "&";
|
|
break;
|
|
case '\'':
|
|
if (!is_attribute)
|
|
continue;
|
|
escape = "'";
|
|
break;
|
|
case '\"':
|
|
if (!is_attribute)
|
|
continue;
|
|
escape = """;
|
|
break;
|
|
}
|
|
fwrite(text, (p - text - 1), 1, f);
|
|
if (!escape)
|
|
break;
|
|
fputs(escape, f);
|
|
text = p;
|
|
}
|
|
}
|
|
|
|
static void show_utf8(FILE *f, const char *text, const char *pre, const char *post, int is_attribute)
|
|
{
|
|
int len;
|
|
|
|
if (!text)
|
|
return;
|
|
while (isspace(*text))
|
|
text++;
|
|
len = strlen(text);
|
|
if (!len)
|
|
return;
|
|
while (len && isspace(text[len-1]))
|
|
len--;
|
|
/* FIXME! Quoting! */
|
|
fputs(pre, f);
|
|
quote(f, text, is_attribute);
|
|
fputs(post, f);
|
|
}
|
|
|
|
static void save_depths(FILE *f, struct dive *dive)
|
|
{
|
|
/* What's the point of this dive entry again? */
|
|
if (!dive->maxdepth.mm && !dive->meandepth.mm)
|
|
return;
|
|
|
|
fputs(" <depth", f);
|
|
show_depth(f, dive->maxdepth, " max='", "'");
|
|
show_depth(f, dive->meandepth, " mean='", "'");
|
|
fputs(" />\n", f);
|
|
}
|
|
|
|
static void save_temperatures(FILE *f, struct dive *dive)
|
|
{
|
|
if (!dive->airtemp.mkelvin && !dive->watertemp.mkelvin)
|
|
return;
|
|
fputs(" <temperature", f);
|
|
show_temperature(f, dive->airtemp, " air='", "'");
|
|
show_temperature(f, dive->watertemp, " water='", "'");
|
|
fputs(" />\n", f);
|
|
}
|
|
|
|
static void save_airpressure(FILE *f, struct dive *dive)
|
|
{
|
|
if (!dive->surface_pressure.mbar)
|
|
return;
|
|
fputs(" <surface", f);
|
|
show_pressure(f, dive->surface_pressure, " pressure='", "'");
|
|
fputs(" />\n", f);
|
|
}
|
|
|
|
static void save_salinity(FILE *f, struct dive *dive)
|
|
{
|
|
/* only save if we have a value that isn't the default of sea water */
|
|
if (!dive->salinity || dive->salinity == 10300)
|
|
return;
|
|
fputs(" <water", f);
|
|
show_salinity(f, dive->salinity, " salinity='", "'");
|
|
fputs(" />\n", f);
|
|
}
|
|
|
|
/*
|
|
* Format degrees to within 6 decimal places. That's about 0.1m
|
|
* on a great circle (ie longitude at equator). And micro-degrees
|
|
* is also enough to fit in a fixed-point 32-bit integer.
|
|
*/
|
|
static int format_degrees(char *buffer, degrees_t value)
|
|
{
|
|
int udeg = value.udeg;
|
|
const char *sign = "";
|
|
|
|
if (udeg < 0) {
|
|
sign = "-";
|
|
udeg = -udeg;
|
|
}
|
|
return sprintf(buffer, "%s%u.%06u",
|
|
sign, udeg / 1000000, udeg % 1000000);
|
|
}
|
|
|
|
static int format_location(char *buffer, degrees_t latitude, degrees_t longitude)
|
|
{
|
|
int len = sprintf(buffer, "gps='");
|
|
|
|
len += format_degrees(buffer+len, latitude);
|
|
buffer[len++] = ' ';
|
|
len += format_degrees(buffer+len, longitude);
|
|
buffer[len++] = '\'';
|
|
|
|
return len;
|
|
}
|
|
|
|
static void show_location(FILE *f, struct dive *dive)
|
|
{
|
|
char buffer[80];
|
|
const char *prefix = " <location>";
|
|
degrees_t latitude = dive->latitude;
|
|
degrees_t longitude = dive->longitude;
|
|
|
|
/*
|
|
* Ok, theoretically I guess you could dive at
|
|
* exactly 0,0. But we don't support that. So
|
|
* if you do, just fudge it a bit, and say that
|
|
* you dove a few meters away.
|
|
*/
|
|
if (latitude.udeg || longitude.udeg) {
|
|
int len = sprintf(buffer, " <location ");
|
|
|
|
len += format_location(buffer+len, latitude, longitude);
|
|
if (!dive->location) {
|
|
memcpy(buffer+len, "/>\n", 4);
|
|
fputs(buffer, f);
|
|
return;
|
|
}
|
|
buffer[len++] = '>';
|
|
buffer[len] = 0;
|
|
prefix = buffer;
|
|
}
|
|
show_utf8(f, dive->location, prefix,"</location>\n", 0);
|
|
}
|
|
|
|
static void save_overview(FILE *f, struct dive *dive)
|
|
{
|
|
save_depths(f, dive);
|
|
save_temperatures(f, dive);
|
|
save_airpressure(f, dive);
|
|
save_salinity(f, dive);
|
|
show_duration(f, dive->surfacetime, " <surfacetime>", "</surfacetime>\n");
|
|
show_location(f, dive);
|
|
show_utf8(f, dive->divemaster, " <divemaster>","</divemaster>\n", 0);
|
|
show_utf8(f, dive->buddy, " <buddy>","</buddy>\n", 0);
|
|
show_utf8(f, dive->notes, " <notes>","</notes>\n", 0);
|
|
show_utf8(f, dive->suit, " <suit>","</suit>\n", 0);
|
|
}
|
|
|
|
static int nr_cylinders(struct dive *dive)
|
|
{
|
|
int nr;
|
|
|
|
for (nr = MAX_CYLINDERS; nr; --nr) {
|
|
cylinder_t *cylinder = dive->cylinder+nr-1;
|
|
if (!cylinder_nodata(cylinder))
|
|
break;
|
|
}
|
|
return nr;
|
|
}
|
|
|
|
static void save_cylinder_info(FILE *f, struct dive *dive)
|
|
{
|
|
int i, nr;
|
|
|
|
nr = nr_cylinders(dive);
|
|
|
|
for (i = 0; i < nr; i++) {
|
|
cylinder_t *cylinder = dive->cylinder+i;
|
|
int volume = cylinder->type.size.mliter;
|
|
const char *description = cylinder->type.description;
|
|
int o2 = cylinder->gasmix.o2.permille;
|
|
int he = cylinder->gasmix.he.permille;
|
|
|
|
fprintf(f, " <cylinder");
|
|
if (volume)
|
|
show_milli(f, " size='", volume, " l", "'");
|
|
show_pressure(f, cylinder->type.workingpressure, " workpressure='", "'");
|
|
if (description && *description)
|
|
fprintf(f, " description='%s'", description);
|
|
if (o2) {
|
|
fprintf(f, " o2='%u.%u%%'", FRACTION(o2, 10));
|
|
if (he)
|
|
fprintf(f, " he='%u.%u%%'", FRACTION(he, 10));
|
|
}
|
|
show_pressure(f, cylinder->start, " start='", "'");
|
|
show_pressure(f, cylinder->end, " end='", "'");
|
|
fprintf(f, " />\n");
|
|
}
|
|
}
|
|
|
|
static void save_weightsystem_info(FILE *f, struct dive *dive)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_WEIGHTSYSTEMS; i++) {
|
|
weightsystem_t *ws = dive->weightsystem+i;
|
|
int grams = ws->weight.grams;
|
|
const char *description = ws->description;
|
|
|
|
/* No weight information at all? */
|
|
if (grams == 0)
|
|
return;
|
|
fprintf(f, " <weightsystem");
|
|
show_milli(f, " weight='", grams, " kg", "'");
|
|
if (description && *description)
|
|
fprintf(f, " description='%s'", description);
|
|
fprintf(f, " />\n");
|
|
}
|
|
}
|
|
|
|
static void show_index(FILE *f, int value, const char *pre, const char *post)
|
|
{
|
|
if (value)
|
|
fprintf(f, " %s%d%s", pre, value, post);
|
|
}
|
|
|
|
static void save_sample(FILE *f, struct sample *sample, struct sample *old)
|
|
{
|
|
fprintf(f, " <sample time='%u:%02u min'", FRACTION(sample->time.seconds,60));
|
|
show_milli(f, " depth='", sample->depth.mm, " m", "'");
|
|
show_temperature(f, sample->temperature, " temp='", "'");
|
|
show_pressure(f, sample->cylinderpressure, " pressure='", "'");
|
|
|
|
/*
|
|
* We only show sensor information for samples with pressure, and only if it
|
|
* changed from the previous sensor we showed.
|
|
*/
|
|
if (sample->cylinderpressure.mbar && sample->sensor != old->sensor) {
|
|
fprintf(f, " sensor='%d'", sample->sensor);
|
|
old->sensor = sample->sensor;
|
|
}
|
|
|
|
/* the deco/ndl values are stored whenever they change */
|
|
if (sample->ndl.seconds != old->ndl.seconds) {
|
|
fprintf(f, " ndl='%u:%02u min'", FRACTION(sample->ndl.seconds, 60));
|
|
old->ndl = sample->ndl;
|
|
}
|
|
if (sample->in_deco != old->in_deco) {
|
|
fprintf(f, " in_deco='%d'", sample->in_deco ? 1 : 0);
|
|
old->in_deco = sample->in_deco;
|
|
}
|
|
if (sample->stoptime.seconds != old->stoptime.seconds) {
|
|
fprintf(f, " stoptime='%u:%02u min'", FRACTION(sample->stoptime.seconds, 60));
|
|
old->stoptime = sample->stoptime;
|
|
}
|
|
|
|
if (sample->stopdepth.mm != old->stopdepth.mm) {
|
|
show_milli(f, " stopdepth='", sample->stopdepth.mm, " m", "'");
|
|
old->stopdepth = sample->stopdepth;
|
|
}
|
|
|
|
if (sample->cns != old->cns) {
|
|
fprintf(f, " cns='%u%%'", sample->cns);
|
|
old->cns = sample->cns;
|
|
}
|
|
|
|
if (sample->po2 != old->po2) {
|
|
fprintf(f, " po2='%u.%2u bar'", FRACTION(sample->po2, 1000));
|
|
old->po2 = sample->po2;
|
|
}
|
|
fprintf(f, " />\n");
|
|
}
|
|
|
|
static void save_one_event(FILE *f, struct event *ev)
|
|
{
|
|
fprintf(f, " <event time='%d:%02d min'", FRACTION(ev->time.seconds,60));
|
|
show_index(f, ev->type, "type='", "'");
|
|
show_index(f, ev->flags, "flags='", "'");
|
|
show_index(f, ev->value, "value='", "'");
|
|
show_utf8(f, ev->name, " name='", "'", 1);
|
|
fprintf(f, " />\n");
|
|
}
|
|
|
|
|
|
static void save_events(FILE *f, struct event *ev)
|
|
{
|
|
while (ev) {
|
|
save_one_event(f, ev);
|
|
ev = ev->next;
|
|
}
|
|
}
|
|
|
|
static void show_date(FILE *f, timestamp_t when)
|
|
{
|
|
struct tm tm;
|
|
|
|
utc_mkdate(when, &tm);
|
|
|
|
fprintf(f, " date='%04u-%02u-%02u'",
|
|
tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday);
|
|
fprintf(f, " time='%02u:%02u:%02u'",
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec);
|
|
}
|
|
|
|
static void save_samples(FILE *f, int nr, struct sample *s)
|
|
{
|
|
struct sample dummy = { };
|
|
|
|
while (--nr >= 0) {
|
|
save_sample(f, s, &dummy);
|
|
s++;
|
|
}
|
|
}
|
|
|
|
static void save_dc(FILE *f, struct dive *dive, struct divecomputer *dc)
|
|
{
|
|
fprintf(f, " <divecomputer");
|
|
if (dc->model)
|
|
show_utf8(f, dc->model, " model='", "'", 1);
|
|
if (dc->deviceid)
|
|
fprintf(f, " deviceid='%08x'", dc->deviceid);
|
|
if (dc->diveid)
|
|
fprintf(f, " diveid='%08x'", dc->diveid);
|
|
if (dc->when && dc->when != dive->when)
|
|
show_date(f, dc->when);
|
|
fprintf(f, ">\n");
|
|
save_events(f, dc->events);
|
|
save_samples(f, dc->samples, dc->sample);
|
|
|
|
fprintf(f, " </divecomputer>\n");
|
|
}
|
|
|
|
void save_dive(FILE *f, struct dive *dive)
|
|
{
|
|
struct divecomputer *dc;
|
|
|
|
fputs("<dive", f);
|
|
if (dive->number)
|
|
fprintf(f, " number='%d'", dive->number);
|
|
if (dive->tripflag == NO_TRIP)
|
|
fprintf(f, " tripflag='NOTRIP'");
|
|
if (dive->rating)
|
|
fprintf(f, " rating='%d'", dive->rating);
|
|
if (dive->visibility)
|
|
fprintf(f, " visibility='%d'", dive->visibility);
|
|
show_date(f, dive->when);
|
|
fprintf(f, " duration='%u:%02u min'>\n",
|
|
FRACTION(dive->duration.seconds, 60));
|
|
save_overview(f, dive);
|
|
save_cylinder_info(f, dive);
|
|
save_weightsystem_info(f, dive);
|
|
|
|
/* Save the dive computer data */
|
|
dc = &dive->dc;
|
|
do {
|
|
save_dc(f, dive, dc);
|
|
dc = dc->next;
|
|
} while (dc);
|
|
|
|
fprintf(f, "</dive>\n");
|
|
}
|
|
|
|
static void save_trip(FILE *f, dive_trip_t *trip)
|
|
{
|
|
int i;
|
|
struct dive *dive;
|
|
|
|
fprintf(f, "<trip");
|
|
show_date(f, trip->when);
|
|
if (trip->location)
|
|
show_utf8(f, trip->location, " location=\'","\'", 1);
|
|
fprintf(f, ">\n");
|
|
if (trip->notes)
|
|
show_utf8(f, trip->notes, "<notes>","</notes>\n", 0);
|
|
|
|
/*
|
|
* Incredibly cheesy: we want to save the dives sorted, and they
|
|
* are sorted in the dive array.. So instead of using the dive
|
|
* list in the trip, we just traverse the global dive array and
|
|
* check the divetrip pointer..
|
|
*/
|
|
for_each_dive(i, dive) {
|
|
if (dive->divetrip == trip)
|
|
save_dive(f, dive);
|
|
}
|
|
|
|
fprintf(f, "</trip>\n");
|
|
}
|
|
|
|
static void save_dc_if_needed(FILE *f, struct divecomputer *dc)
|
|
{
|
|
struct device_info *info = get_device_info(dc->model, dc->deviceid);
|
|
const char *nickname, *serial_nr, *firmware;
|
|
|
|
/* we have no dc or no model or no deviceid information... nothing to do here */
|
|
if (!info || info->saved)
|
|
return;
|
|
info->saved = 1;
|
|
|
|
/* Nicknames that are empty or the same as the device model are not interesting */
|
|
nickname = info->nickname;
|
|
if (nickname) {
|
|
if (!*nickname || !strcmp(dc->model, nickname))
|
|
nickname = NULL;
|
|
}
|
|
|
|
/* Serial numbers that are empty are not interesting */
|
|
serial_nr = info->serial_nr;
|
|
if (serial_nr && !*serial_nr)
|
|
serial_nr = NULL;
|
|
|
|
/* Firmware strings that are empty are not interesting */
|
|
firmware = info->firmware;
|
|
if (firmware && !*firmware)
|
|
firmware = NULL;
|
|
|
|
/* Do we have anything interesting about this dive computer to save? */
|
|
if (!serial_nr && !nickname && !firmware)
|
|
return;
|
|
|
|
fprintf(f, "<divecomputerid model='%s' deviceid='%08x'", dc->model, dc->deviceid);
|
|
if (serial_nr)
|
|
show_utf8(f, serial_nr, " serial='", "'", 1);
|
|
if (firmware)
|
|
show_utf8(f, firmware, " firmware='", "'", 1);
|
|
if (nickname)
|
|
show_utf8(f, nickname, " nickname='", "'", 1);
|
|
fprintf(f, "/>\n");
|
|
return;
|
|
}
|
|
|
|
#define VERSION 2
|
|
|
|
void save_dives(const char *filename)
|
|
{
|
|
int i;
|
|
struct dive *dive;
|
|
dive_trip_t *trip;
|
|
|
|
FILE *f = g_fopen(filename, "w");
|
|
|
|
if (!f)
|
|
return;
|
|
|
|
/* Flush any edits of current dives back to the dives! */
|
|
update_dive(current_dive);
|
|
|
|
fprintf(f, "<divelog program='subsurface' version='%d'>\n<settings>\n", VERSION);
|
|
|
|
/* save the dive computer nicknames, if any */
|
|
clear_device_saved_status();
|
|
for_each_dive(i, dive) {
|
|
struct divecomputer *dc = &dive->dc;
|
|
while (dc) {
|
|
save_dc_if_needed(f, dc);
|
|
dc = dc->next;
|
|
}
|
|
}
|
|
if (autogroup)
|
|
fprintf(f, "<autogroup state='1' />\n");
|
|
fprintf(f, "</settings>\n<dives>\n");
|
|
|
|
for (trip = dive_trip_list; trip != NULL; trip = trip->next)
|
|
trip->index = 0;
|
|
|
|
/* save the dives */
|
|
for_each_dive(i, dive) {
|
|
trip = dive->divetrip;
|
|
|
|
/* Bare dive without a trip? */
|
|
if (!trip) {
|
|
save_dive(f, dive);
|
|
continue;
|
|
}
|
|
|
|
/* Have we already seen this trip (and thus saved this dive?) */
|
|
if (trip->index)
|
|
continue;
|
|
|
|
/* We haven't seen this trip before - save it and all dives */
|
|
trip->index = 1;
|
|
save_trip(f, trip);
|
|
}
|
|
fprintf(f, "</dives>\n</divelog>\n");
|
|
fclose(f);
|
|
}
|