2017-04-27 18:18:03 +00:00
// SPDX-License-Identifier: GPL-2.0
2017-03-11 20:08:31 +00:00
# ifdef __clang__
2016-03-09 18:18:05 +00:00
// Clang has a bug on zero-initialization of C structs.
# pragma clang diagnostic ignored "-Wmissing-field-initializers"
2017-03-11 20:08:31 +00:00
# endif
2016-03-09 18:18:05 +00:00
2024-05-01 21:35:21 +00:00
# include <fcntl.h>
2011-09-12 16:19:21 +00:00
# include <stdio.h>
2023-12-03 21:59:21 +00:00
# include <stdlib.h>
2011-11-27 17:10:37 +00:00
# include <unistd.h>
# include <inttypes.h>
2013-10-05 07:29:09 +00:00
# include <string.h>
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
# include <sys/types.h>
# include <sys/stat.h>
2024-05-01 21:35:21 +00:00
# include <chrono>
2013-10-06 15:55:58 +00:00
# include "gettext.h"
core: introduce divelog structure
The parser API was very annoying, as a number of tables
to-be-filled were passed in as pointers. The goal of this
commit is to collect all these tables in a single struct.
This should make it (more or less) clear what is actually
written into the divelog files.
Moreover, it should now be rather easy to search for
instances, where the global logfile is accessed (and it
turns out that there are many!).
The divelog struct does not contain the tables as substructs,
but only collects pointers. The idea is that the "divelog.h"
file can be included without all the other files describing
the numerous tables.
To make it easier to use from C++ parts of the code, the
struct implements a constructor and a destructor. Sadly,
we can't use smart pointers, since the pointers are accessed
from C code. Therfore the constructor and destructor are
quite complex.
The whole commit is large, but was mostly an automatic
conversion.
One oddity of note: the divelog structure also contains
the "autogroup" flag, since that is saved in the divelog.
This actually fixes a bug: Before, when importing dives
from a different log, the autogroup flag was overwritten.
This was probably not intended and does not happen anymore.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
# include "divelog.h"
2019-03-04 22:20:29 +00:00
# include "divesite.h"
2020-10-25 12:28:55 +00:00
# include "sample.h"
2022-08-30 16:13:13 +00:00
# include "subsurface-float.h"
2018-05-11 15:25:41 +00:00
# include "subsurface-string.h"
2024-03-13 08:41:11 +00:00
# include "format.h"
Assemble the actual Suunto serial number
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>
2013-01-10 00:14:21 +00:00
# include "device.h"
2020-05-01 11:43:52 +00:00
# include "dive.h"
2019-08-05 17:41:15 +00:00
# include "errorhelper.h"
2020-10-25 08:14:16 +00:00
# include "event.h"
2019-03-03 21:04:34 +00:00
# include "sha1.h"
2020-05-01 12:07:59 +00:00
# include "subsurface-time.h"
2011-09-12 16:19:21 +00:00
2016-03-06 14:52:55 +00:00
# include <libdivecomputer/version.h>
2018-04-17 22:57:04 +00:00
# include <libdivecomputer/usbhid.h>
2020-08-20 20:05:53 +00:00
# include <libdivecomputer/usb.h>
2018-04-17 22:57:04 +00:00
# include <libdivecomputer/serial.h>
# include <libdivecomputer/irda.h>
2020-09-19 21:16:08 +00:00
# include <libdivecomputer/bluetooth.h>
2018-04-17 22:57:04 +00:00
2016-03-08 01:18:10 +00:00
# include "libdivecomputer.h"
2017-09-28 03:00:58 +00:00
# include "core/version.h"
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
# include "core/qthelper.h"
# include "core/file.h"
2024-03-01 12:09:20 +00:00
# include <array>
2024-05-02 19:26:22 +00:00
# include <charconv>
2011-09-15 04:00:49 +00:00
2024-03-16 09:29:05 +00:00
std : : string dumpfile_name ;
std : : string logfile_name ;
2013-05-20 19:43:33 +00:00
const char * progress_bar_text = " " ;
2017-07-09 19:43:06 +00:00
void ( * progress_callback ) ( const char * text ) = NULL ;
2013-05-20 19:43:33 +00:00
double progress_bar_fraction = 0.0 ;
2017-11-14 11:36:40 +00:00
static int stoptime , stopdepth , ndl , po2 , cns , heartbeat , bearing ;
2013-10-05 07:29:09 +00:00
static bool in_deco , first_temp_is_air ;
2016-08-29 21:07:17 +00:00
static int current_gas_index ;
2012-09-20 19:56:42 +00:00
2024-05-14 23:38:00 +00:00
# define INFO(fmt, ...) report_info("INFO: " fmt, ##__VA_ARGS__)
# define ERROR(fmt, ...) report_info("ERROR: " fmt, ##__VA_ARGS__)
2017-05-30 03:56:42 +00:00
2024-05-02 19:59:14 +00:00
device_data_t : : device_data_t ( )
{
}
device_data_t : : ~ device_data_t ( )
{
if ( descriptor )
dc_descriptor_free ( descriptor ) ;
}
2015-04-03 19:33:10 +00:00
/*
* Directly taken from libdivecomputer ' s examples / common . c to improve
* the error messages resulting from libdc ' s return codes
*/
const char * errmsg ( dc_status_t rc )
{
switch ( rc ) {
case DC_STATUS_SUCCESS :
return " Success " ;
case DC_STATUS_UNSUPPORTED :
return " Unsupported operation " ;
case DC_STATUS_INVALIDARGS :
return " Invalid arguments " ;
case DC_STATUS_NOMEMORY :
return " Out of memory " ;
case DC_STATUS_NODEVICE :
return " No device found " ;
case DC_STATUS_NOACCESS :
return " Access denied " ;
case DC_STATUS_IO :
return " Input/output error " ;
case DC_STATUS_TIMEOUT :
return " Timeout " ;
case DC_STATUS_PROTOCOL :
return " Protocol error " ;
case DC_STATUS_DATAFORMAT :
return " Data format error " ;
case DC_STATUS_CANCELLED :
return " Cancelled " ;
default :
return " Unknown error " ;
}
}
2023-11-20 02:56:53 +00:00
/**
* @ brief get_deeper_gasmix Returns the gas mix with the deeper MOD .
* NOTE : Parameters are passed by value in order to use them as local working
* storage .
* Invalid gas mixes are converted to air for the purpose of this operation .
* The gas mix with the lower MOD is taken as the one with the lower O2 content ,
* or , if equal , the one with the higher HE content . No actual MOD calculations
* are performed .
* @ param a The first gas mix to compare .
* @ param b The second gas mix to compare .
* @ return The gas mix with the deeper MOD .
*/
static struct gasmix get_deeper_gasmix ( struct gasmix a , struct gasmix b )
{
if ( same_gasmix ( a , gasmix_invalid ) ) {
a = gasmix_air ;
}
if ( same_gasmix ( b , gasmix_invalid ) ) {
b = gasmix_air ;
}
if ( get_o2 ( a ) < get_o2 ( b ) ) {
return a ;
}
2023-11-20 03:22:58 +00:00
if ( get_o2 ( a ) > get_o2 ( b ) ) {
2023-11-20 02:56:53 +00:00
return b ;
}
return get_he ( a ) < get_he ( b ) ? b : a ;
}
/**
* @ brief parse_gasmixes matches gas mixes with cylinders
* This function retrieves all tanks and gas mixes reported by libdivecomputer
* and attepmts to match them . The matching logic assigns the mixes to the
* tanks in a 1 : 1 ordering .
* If there are more gas mixes than tanks , additional tanks are created .
* If there are fewer gas mixes than tanks , the remaining tanks are assigned to
* the gas mix with the lowest ( deepest ) MOD .
* @ param devdata The dive computer data .
* @ param dive The dive to which these tanks and gas mixes will be assigned .
* @ param parser The libdivecomputer parser data .
* @ param ngases The number of gas mixes to process .
* @ return DC_STATUS_SUCCESS on success , otherwise an error code .
*/
2024-03-01 12:09:20 +00:00
static dc_status_t parse_gasmixes ( device_data_t * devdata , struct dive * dive , dc_parser_t * parser , unsigned int ngases )
2011-09-12 18:05:32 +00:00
{
2014-08-06 13:19:31 +00:00
static bool shown_warning = false ;
2016-03-10 02:25:30 +00:00
unsigned int i ;
2024-04-28 11:39:39 +00:00
dc_status_t rc ;
2014-11-09 06:20:59 +00:00
2016-03-10 02:25:30 +00:00
unsigned int ntanks = 0 ;
2014-11-09 06:20:59 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_TANK_COUNT , 0 , & ntanks ) ;
if ( rc = = DC_STATUS_SUCCESS ) {
2017-02-02 09:56:22 +00:00
if ( ntanks & & ntanks < ngases ) {
2014-11-09 06:20:59 +00:00
shown_warning = true ;
2017-02-03 15:32:27 +00:00
report_error ( " Warning: different number of gases (%d) and cylinders (%d) " , ngases , ntanks ) ;
2017-02-02 09:56:22 +00:00
} else if ( ntanks > ngases ) {
shown_warning = true ;
2023-11-14 04:12:08 +00:00
report_error ( " Warning: smaller number of gases (%d) than cylinders (%d). " , ngases , ntanks ) ;
2014-11-09 06:20:59 +00:00
}
}
2017-02-02 09:56:22 +00:00
bool no_volume = true ;
2023-11-20 03:22:58 +00:00
struct gasmix bottom_gas = { { 1000 } , { 0 } } ; /* Default to pure O2, or air if there are no mixes defined */
if ( ngases = = 0 ) {
bottom_gas = gasmix_air ;
}
2017-02-02 09:56:22 +00:00
2019-08-04 16:44:57 +00:00
clear_cylinder_table ( & dive - > cylinders ) ;
2024-03-23 08:16:59 +00:00
for ( i = 0 ; i < std : : max ( ngases , ntanks ) ; i + + ) {
2024-05-04 17:15:47 +00:00
cylinder_t cyl ;
2024-02-01 03:06:33 +00:00
cyl . cylinder_use = NOT_USED ;
2017-02-02 09:56:22 +00:00
if ( i < ngases ) {
dc_gasmix_t gasmix = { 0 } ;
int o2 , he ;
rc = dc_parser_get_field ( parser , DC_FIELD_GASMIX , i , & gasmix ) ;
2024-02-01 03:06:33 +00:00
if ( rc = = DC_STATUS_SUCCESS ) {
o2 = lrint ( gasmix . oxygen * 1000 ) ;
he = lrint ( gasmix . helium * 1000 ) ;
/* Ignore bogus data - libdivecomputer does some crazy stuff */
if ( o2 + he < = O2_IN_AIR | | o2 > 1000 ) {
if ( ! shown_warning ) {
shown_warning = true ;
report_error ( " unlikely dive gas data from libdivecomputer: o2 = %.3f he = %.3f " , gasmix . oxygen , gasmix . helium ) ;
}
o2 = 0 ;
}
if ( he < 0 | | o2 + he > 1000 ) {
if ( ! shown_warning ) {
shown_warning = true ;
report_error ( " unlikely dive gas data from libdivecomputer: o2 = %.3f he = %.3f " , gasmix . oxygen , gasmix . helium ) ;
}
he = 0 ;
}
cyl . gasmix . o2 . permille = o2 ;
cyl . gasmix . he . permille = he ;
bottom_gas = get_deeper_gasmix ( bottom_gas , cyl . gasmix ) ;
2017-02-02 09:56:22 +00:00
2024-02-01 03:06:33 +00:00
switch ( gasmix . usage ) {
case DC_USAGE_DILUENT :
cyl . cylinder_use = DILUENT ;
2017-02-02 09:56:22 +00:00
2024-02-01 03:06:33 +00:00
break ;
case DC_USAGE_OXYGEN :
cyl . cylinder_use = OXYGEN ;
break ;
case DC_USAGE_OPEN_CIRCUIT :
cyl . cylinder_use = OC_GAS ;
break ;
default :
if ( dive - > dc . divemode = = CCR )
cyl . cylinder_use = DILUENT ;
else
cyl . cylinder_use = OC_GAS ;
break ;
2017-02-02 09:56:22 +00:00
}
2014-08-06 13:19:31 +00:00
}
2014-06-11 14:15:40 +00:00
}
2012-12-28 16:53:16 +00:00
2014-11-09 06:20:59 +00:00
if ( i < ntanks ) {
2023-11-20 02:56:53 +00:00
// If we've run out of gas mixes, assign this cylinder to bottom
// gas. Note that this can be overridden below if the dive computer
// explicitly reports a gas mix for this tank.
if ( i > = ngases ) {
cyl . gasmix = bottom_gas ;
}
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
dc_tank_t tank = { 0 } ;
2014-11-11 09:41:08 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_TANK , i , & tank ) ;
2014-11-09 06:20:59 +00:00
if ( rc = = DC_STATUS_SUCCESS ) {
2019-08-04 16:44:57 +00:00
cyl . type . size . mliter = lrint ( tank . volume * 1000 ) ;
cyl . type . workingpressure . mbar = lrint ( tank . workpressure * 1000 ) ;
2016-07-18 07:18:17 +00:00
2024-02-01 03:06:33 +00:00
if ( tank . type & DC_TANKVOLUME_IMPERIAL ) {
2024-05-02 19:26:22 +00:00
if ( devdata - > model = = " Suunto EON Steel " ) {
2015-10-22 11:15:33 +00:00
/* Suunto EON Steele gets this wrong. Badly.
* but on the plus side it only supports a few imperial sizes ,
* so let ' s try and guess at least the most common ones .
* First , the pressures are off by a constant factor . WTF ?
* Then we can round the wet sizes so we get to multiples of 10
* for cuft sizes ( as that ' s all that you can enter ) */
2019-08-04 16:44:57 +00:00
cyl . type . workingpressure . mbar = lrint (
cyl . type . workingpressure . mbar * 206.843 / 206.7 ) ;
Increase size of name_buffer to fit any integer
In libdivecomputer.c, name_buffer is formatted with calls like
snprintf(name_buffer, 9, "%d cuft", rounded_size);
This works fine in the regular case, but it generates compiler
warnings, since theoretically the integer might produce up to
11 digits, leading to a truncation of the string.
Increasing the size of name_buffer to 17 chars silences these
warnings. This may seem like pointless warning-silencing.
Nevertheless, in the case of invalid data, it might make debugging
easier since, in the above case, the "cuft" is never truncated.
In total, it seems that this is a benign change with potential,
though in a very unlikely case, positive effects.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-01-04 08:18:46 +00:00
char name_buffer [ 17 ] ;
2019-08-04 16:44:57 +00:00
int rounded_size = lrint ( ml_to_cuft ( gas_volume ( & cyl ,
cyl . type . workingpressure ) ) ) ;
2015-10-22 11:15:33 +00:00
rounded_size = ( int ) ( ( rounded_size + 5 ) / 10 ) * 10 ;
2019-08-04 16:44:57 +00:00
switch ( cyl . type . workingpressure . mbar ) {
2015-10-22 11:15:33 +00:00
case 206843 :
Increase size of name_buffer to fit any integer
In libdivecomputer.c, name_buffer is formatted with calls like
snprintf(name_buffer, 9, "%d cuft", rounded_size);
This works fine in the regular case, but it generates compiler
warnings, since theoretically the integer might produce up to
11 digits, leading to a truncation of the string.
Increasing the size of name_buffer to 17 chars silences these
warnings. This may seem like pointless warning-silencing.
Nevertheless, in the case of invalid data, it might make debugging
easier since, in the above case, the "cuft" is never truncated.
In total, it seems that this is a benign change with potential,
though in a very unlikely case, positive effects.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-01-04 08:18:46 +00:00
snprintf ( name_buffer , sizeof ( name_buffer ) , " AL%d " , rounded_size ) ;
2015-10-22 11:15:33 +00:00
break ;
case 234422 : /* this is wrong - HP tanks tend to be 3440, but Suunto only allows 3400 */
Increase size of name_buffer to fit any integer
In libdivecomputer.c, name_buffer is formatted with calls like
snprintf(name_buffer, 9, "%d cuft", rounded_size);
This works fine in the regular case, but it generates compiler
warnings, since theoretically the integer might produce up to
11 digits, leading to a truncation of the string.
Increasing the size of name_buffer to 17 chars silences these
warnings. This may seem like pointless warning-silencing.
Nevertheless, in the case of invalid data, it might make debugging
easier since, in the above case, the "cuft" is never truncated.
In total, it seems that this is a benign change with potential,
though in a very unlikely case, positive effects.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-01-04 08:18:46 +00:00
snprintf ( name_buffer , sizeof ( name_buffer ) , " HP%d " , rounded_size ) ;
2015-10-22 11:15:33 +00:00
break ;
case 179263 :
Increase size of name_buffer to fit any integer
In libdivecomputer.c, name_buffer is formatted with calls like
snprintf(name_buffer, 9, "%d cuft", rounded_size);
This works fine in the regular case, but it generates compiler
warnings, since theoretically the integer might produce up to
11 digits, leading to a truncation of the string.
Increasing the size of name_buffer to 17 chars silences these
warnings. This may seem like pointless warning-silencing.
Nevertheless, in the case of invalid data, it might make debugging
easier since, in the above case, the "cuft" is never truncated.
In total, it seems that this is a benign change with potential,
though in a very unlikely case, positive effects.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-01-04 08:18:46 +00:00
snprintf ( name_buffer , sizeof ( name_buffer ) , " LP+%d " , rounded_size ) ;
2015-10-22 11:15:33 +00:00
break ;
case 165474 :
Increase size of name_buffer to fit any integer
In libdivecomputer.c, name_buffer is formatted with calls like
snprintf(name_buffer, 9, "%d cuft", rounded_size);
This works fine in the regular case, but it generates compiler
warnings, since theoretically the integer might produce up to
11 digits, leading to a truncation of the string.
Increasing the size of name_buffer to 17 chars silences these
warnings. This may seem like pointless warning-silencing.
Nevertheless, in the case of invalid data, it might make debugging
easier since, in the above case, the "cuft" is never truncated.
In total, it seems that this is a benign change with potential,
though in a very unlikely case, positive effects.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-01-04 08:18:46 +00:00
snprintf ( name_buffer , sizeof ( name_buffer ) , " LP%d " , rounded_size ) ;
2015-10-22 11:15:33 +00:00
break ;
default :
Increase size of name_buffer to fit any integer
In libdivecomputer.c, name_buffer is formatted with calls like
snprintf(name_buffer, 9, "%d cuft", rounded_size);
This works fine in the regular case, but it generates compiler
warnings, since theoretically the integer might produce up to
11 digits, leading to a truncation of the string.
Increasing the size of name_buffer to 17 chars silences these
warnings. This may seem like pointless warning-silencing.
Nevertheless, in the case of invalid data, it might make debugging
easier since, in the above case, the "cuft" is never truncated.
In total, it seems that this is a benign change with potential,
though in a very unlikely case, positive effects.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2018-01-04 08:18:46 +00:00
snprintf ( name_buffer , sizeof ( name_buffer ) , " %d cuft " , rounded_size ) ;
2015-10-22 11:15:33 +00:00
break ;
}
2019-08-04 16:44:57 +00:00
cyl . type . description = copy_string ( name_buffer ) ;
cyl . type . size . mliter = lrint ( cuft_to_l ( rounded_size ) * 1000 /
mbar_to_atm ( cyl . type . workingpressure . mbar ) ) ;
2015-10-22 11:15:33 +00:00
}
2014-11-09 06:20:59 +00:00
}
2020-06-13 08:36:38 +00:00
if ( tank . gasmix ! = DC_GASMIX_UNKNOWN & & tank . gasmix ! = i ) { // we don't handle this, yet
2014-11-09 06:20:59 +00:00
shown_warning = true ;
report_error ( " gasmix %d for tank %d doesn't match " , tank . gasmix , i ) ;
}
}
2022-08-30 15:47:31 +00:00
if ( ! nearly_0 ( tank . volume ) )
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
no_volume = false ;
2015-07-02 13:12:56 +00:00
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
// this new API also gives us the beginning and end pressure for the tank
2017-03-29 11:59:31 +00:00
// normally 0 is not a valid pressure, but for some Uwatec dive computers we
// don't get the actual start and end pressure, but instead a start pressure
// that matches the consumption and an end pressure of always 0
2017-03-30 09:30:23 +00:00
// In order to make this work, we arbitrary shift this up by 30bar so the
// rest of the code treats this as if they were valid values
2022-08-30 15:47:31 +00:00
if ( ! nearly_0 ( tank . beginpressure ) ) {
if ( ! nearly_0 ( tank . endpressure ) ) {
2019-08-04 16:44:57 +00:00
cyl . start . mbar = lrint ( tank . beginpressure * 1000 ) ;
cyl . end . mbar = lrint ( tank . endpressure * 1000 ) ;
2024-05-02 19:26:22 +00:00
} else if ( devdata - > vendor = = " Uwatec " ) {
2019-08-04 16:44:57 +00:00
cyl . start . mbar = lrint ( tank . beginpressure * 1000 + 30000 ) ;
cyl . end . mbar = 30000 ;
2017-03-30 09:30:23 +00:00
}
Make sure DC_FIELD_TANK starts from a clean slate for each cylinder
We used to clear the 'dc_tank_t' for each dive, but then only clear the
volume field in between each cylinder. That means that if the
libdivecomputer back-end does not touch a field, it might contain the
stale value from the previous tank information.
I'm not sure this is actually much of an issue, since I'd expect
back-ends do seem to initialize the fields fully (at least the EON Steel
back-end does). But it's inconsistent.
Also, the code was actually buggy because of the odd indentation: it
would only ask for new tank information up to 'ntanks' tanks, but
because of the final fixup that was done outside of the conditional, it
would actually update the cylinder begin/end pressure data *beyond*
'ntanks', and just re-use the last libdivecomputer data for the rest of
the cylinders.
Again, in practice, that probably never really happened, but it is a
real bug.
The fixed-up code actually looks better too, imho, and is one line
shorter because of the initialization now being done in one place rather
than two.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-08-30 02:05:30 +00:00
}
2015-07-02 13:12:56 +00:00
}
2014-11-09 07:03:10 +00:00
if ( no_volume ) {
2014-11-09 06:20:59 +00:00
/* for the first tank, if there is no tanksize available from the
* dive computer , fill in the default tank information ( if set ) */
2019-08-04 16:44:57 +00:00
fill_default_cylinder ( dive , & cyl ) ;
2014-11-09 06:20:59 +00:00
}
2015-03-19 12:32:43 +00:00
/* whatever happens, make sure there is a name for the cylinder */
2019-08-04 16:44:57 +00:00
if ( empty_string ( cyl . type . description ) )
cyl . type . description = strdup ( translate ( " gettextFromC " , " unknown " ) ) ;
2020-04-28 12:50:40 +00:00
add_cylinder ( & dive - > cylinders , dive - > cylinders . nr , cyl ) ;
2011-09-12 18:05:32 +00:00
}
2012-06-22 20:37:39 +00:00
return DC_STATUS_SUCCESS ;
2011-09-12 18:05:32 +00:00
}
2012-11-24 02:51:27 +00:00
static void handle_event ( struct divecomputer * dc , struct sample * sample , dc_sample_value_t value )
2011-09-12 18:05:32 +00:00
{
2011-09-22 23:55:55 +00:00
int type , time ;
2016-08-29 21:07:17 +00:00
struct event * ev ;
2012-10-21 18:34:11 +00:00
/* we mark these for translation here, but we store the untranslated strings
* and only translate them when they are displayed on screen */
2011-09-12 18:05:32 +00:00
static const char * events [ ] = {
2016-09-21 04:30:18 +00:00
[ SAMPLE_EVENT_NONE ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " none " ) ,
[ SAMPLE_EVENT_DECOSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " deco stop " ) ,
[ SAMPLE_EVENT_RBT ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " rbt " ) ,
[ SAMPLE_EVENT_ASCENT ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " ascent " ) ,
[ SAMPLE_EVENT_CEILING ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " ceiling " ) ,
[ SAMPLE_EVENT_WORKLOAD ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " workload " ) ,
[ SAMPLE_EVENT_TRANSMITTER ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " transmitter " ) ,
[ SAMPLE_EVENT_VIOLATION ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " violation " ) ,
[ SAMPLE_EVENT_BOOKMARK ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " bookmark " ) ,
[ SAMPLE_EVENT_SURFACE ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " surface " ) ,
[ SAMPLE_EVENT_SAFETYSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " safety stop " ) ,
[ SAMPLE_EVENT_GASCHANGE ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " gaschange " ) ,
[ SAMPLE_EVENT_SAFETYSTOP_VOLUNTARY ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " safety stop (voluntary) " ) ,
[ SAMPLE_EVENT_SAFETYSTOP_MANDATORY ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " safety stop (mandatory) " ) ,
[ SAMPLE_EVENT_DEEPSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " deepstop " ) ,
[ SAMPLE_EVENT_CEILING_SAFETYSTOP ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " ceiling (safety stop) " ) ,
2024-03-01 12:09:20 +00:00
[ SAMPLE_EVENT_FLOOR ] = std : : array < const char * , 2 > { QT_TRANSLATE_NOOP3 ( " gettextFromC " , " below floor " , " event showing dive is below deco floor and adding deco time " ) } [ 1 ] ,
2016-09-21 04:30:18 +00:00
[ SAMPLE_EVENT_DIVETIME ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " divetime " ) ,
[ SAMPLE_EVENT_MAXDEPTH ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " maxdepth " ) ,
[ SAMPLE_EVENT_OLF ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " OLF " ) ,
[ SAMPLE_EVENT_PO2 ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " pO₂ " ) ,
[ SAMPLE_EVENT_AIRTIME ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " airtime " ) ,
[ SAMPLE_EVENT_RGBM ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " rgbm " ) ,
[ SAMPLE_EVENT_HEADING ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " heading " ) ,
[ SAMPLE_EVENT_TISSUELEVEL ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " tissue level warning " ) ,
[ SAMPLE_EVENT_GASCHANGE2 ] = QT_TRANSLATE_NOOP ( " gettextFromC " , " gaschange " ) ,
2011-09-22 23:55:55 +00:00
} ;
const int nr_events = sizeof ( events ) / sizeof ( const char * ) ;
const char * name ;
/*
* Other evens might be more interesting , but for now we just print them out .
*/
type = value . event . type ;
2014-02-28 04:09:57 +00:00
name = QT_TRANSLATE_NOOP ( " gettextFromC " , " invalid event number " ) ;
2016-09-21 04:30:18 +00:00
if ( type < nr_events & & events [ type ] )
2012-10-21 18:34:11 +00:00
name = events [ type ] ;
2016-07-20 06:27:59 +00:00
# ifdef SAMPLE_EVENT_STRING
if ( type = = SAMPLE_EVENT_STRING )
name = value . event . name ;
# endif
2011-09-22 23:55:55 +00:00
time = value . event . time ;
if ( sample )
time + = sample - > time . seconds ;
2016-08-29 21:07:17 +00:00
ev = add_event ( dc , time , type , value . event . flags , value . event . value , name ) ;
if ( event_is_gaschange ( ev ) & & ev - > gas . index > = 0 )
current_gas_index = ev - > gas . index ;
2011-09-22 23:45:28 +00:00
}
Add support for libdivecomputer using DC_SAMPLE_GASMIX
New libdivecomputer versions use DC_SAMPLE_GASMIX to indicate a gas
change (which contains the cylinder index we're changing to) rather than
SAMPLE_EVENT_GASCHANGE*.
Unlike the old GASCHANGE model, and despite the name, DC_SAMPLE_GASMIX
does not actually say what the mix is, it only specifies a cylinder
index. We had already extended SAMPLE_EVENT_GASCHANGE2 to have the
cylinder index in the otherwise unused "flags" field, so this is not all
that different from what we used to do.
And subsurface internally already had the logic that "if we know what
the cylinder index is, take the gas mix from the cylinder data", so
we've already been able to transparently use _either_ the actual gas mix
or the cylinder index to show the event.
But we do want to make it an event rather than some sample data, because
we want to show it as such in the profile. But because we are happy
with just the cylinder index, we'll just translate the DC_SAMPLE_GASMIX
thing to the SAMPLE_EVENT_GASCHANGE2 event, and nothing really changes
for subsurface.
libdivecomputer has made other changes, like indicating the initial
cylinder index with an early DC_SAMPLE_GASMIX report, but we've seen
that before too (in the form of early SAMPLE_EVENT_GASCHANGE events), so
that doesn't really end up changing anything for us either.
HOWEVER, one thing that is worth noticing: do *not* apply this patch and
then use an old libdivecomputer library that sends both the
DC_SAMPLE_GASMIX samples _and_ the deprecated SAMPLE_EVENT_GASCHANGE
events. It will all *work*, but since subsurface will take either,
you'll then get duplicate gas mix events.
It's not like that is in any way fatal, but it might be a bit confusing.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-01-03 23:18:03 +00:00
static void handle_gasmix ( struct divecomputer * dc , struct sample * sample , int idx )
{
2019-08-04 16:44:57 +00:00
/* TODO: Verify that index is not higher than the number of cylinders */
if ( idx < 0 )
Add support for libdivecomputer using DC_SAMPLE_GASMIX
New libdivecomputer versions use DC_SAMPLE_GASMIX to indicate a gas
change (which contains the cylinder index we're changing to) rather than
SAMPLE_EVENT_GASCHANGE*.
Unlike the old GASCHANGE model, and despite the name, DC_SAMPLE_GASMIX
does not actually say what the mix is, it only specifies a cylinder
index. We had already extended SAMPLE_EVENT_GASCHANGE2 to have the
cylinder index in the otherwise unused "flags" field, so this is not all
that different from what we used to do.
And subsurface internally already had the logic that "if we know what
the cylinder index is, take the gas mix from the cylinder data", so
we've already been able to transparently use _either_ the actual gas mix
or the cylinder index to show the event.
But we do want to make it an event rather than some sample data, because
we want to show it as such in the profile. But because we are happy
with just the cylinder index, we'll just translate the DC_SAMPLE_GASMIX
thing to the SAMPLE_EVENT_GASCHANGE2 event, and nothing really changes
for subsurface.
libdivecomputer has made other changes, like indicating the initial
cylinder index with an early DC_SAMPLE_GASMIX report, but we've seen
that before too (in the form of early SAMPLE_EVENT_GASCHANGE events), so
that doesn't really end up changing anything for us either.
HOWEVER, one thing that is worth noticing: do *not* apply this patch and
then use an old libdivecomputer library that sends both the
DC_SAMPLE_GASMIX samples _and_ the deprecated SAMPLE_EVENT_GASCHANGE
events. It will all *work*, but since subsurface will take either,
you'll then get duplicate gas mix events.
It's not like that is in any way fatal, but it might be a bit confusing.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-01-03 23:18:03 +00:00
return ;
add_event ( dc , sample - > time . seconds , SAMPLE_EVENT_GASCHANGE2 , idx + 1 , 0 , " gaschange " ) ;
current_gas_index = idx ;
}
2011-09-22 23:45:28 +00:00
void
2024-02-01 03:06:33 +00:00
sample_cb ( dc_sample_type_t type , const dc_sample_value_t * pvalue , void * userdata )
2011-09-22 23:45:28 +00:00
{
2015-08-31 21:23:43 +00:00
static unsigned int nsensor = 0 ;
2024-02-01 03:06:33 +00:00
dc_sample_value_t value = * pvalue ;
2024-03-01 12:09:20 +00:00
struct divecomputer * dc = ( divecomputer * ) userdata ;
2011-09-12 20:25:05 +00:00
struct sample * sample ;
/*
2012-06-22 20:37:39 +00:00
* We fill in the " previous " sample - except for DC_SAMPLE_TIME ,
2011-09-12 20:25:05 +00:00
* which creates a new one .
*/
2014-02-28 04:09:57 +00:00
sample = dc - > samples ? dc - > sample + dc - > samples - 1 : NULL ;
2011-09-12 18:05:32 +00:00
2013-12-10 23:53:36 +00:00
/*
2014-03-05 20:19:45 +00:00
* Ok , sanity check .
* If first sample is not a DC_SAMPLE_TIME , Allocate a sample for us
*/
2013-12-10 23:53:36 +00:00
if ( sample = = NULL & & type ! = DC_SAMPLE_TIME )
sample = prepare_sample ( dc ) ;
2011-09-12 18:05:32 +00:00
switch ( type ) {
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_TIME :
2015-08-31 21:23:43 +00:00
nsensor = 0 ;
2015-10-25 03:02:08 +00:00
// Create a new sample.
// Mark depth as negative
2012-11-24 02:51:27 +00:00
sample = prepare_sample ( dc ) ;
2024-02-01 03:06:33 +00:00
sample - > time . seconds = value . time / 1000 ;
2015-10-25 03:02:08 +00:00
sample - > depth . mm = - 1 ;
2017-11-14 11:36:40 +00:00
// The current sample gets some sticky values
// that may have been around from before, these
// values will be overwritten by new data if available
sample - > in_deco = in_deco ;
sample - > ndl . seconds = ndl ;
sample - > stoptime . seconds = stoptime ;
sample - > stopdepth . mm = stopdepth ;
sample - > setpoint . mbar = po2 ;
sample - > cns = cns ;
sample - > heartbeat = heartbeat ;
sample - > bearing . degrees = bearing ;
2012-11-24 02:51:27 +00:00
finish_sample ( dc ) ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_DEPTH :
2017-03-08 06:41:41 +00:00
sample - > depth . mm = lrint ( value . depth * 1000 ) ;
2011-09-12 18:05:32 +00:00
break ;
Try to sanely download multiple concurrent cylinder pressures
This tries to sanely handle the case of a dive computer reporting
multiple cylinder pressures concurrently.
NOTE! There are various "interesting" situations that this whole issue
brings up:
- some dive computers may report more cylinder pressures than we have
slots for.
Currently we will drop such pressures on the floor if they come for
the same sample, but if they end up being spread across multiple
samples we will end up re-using the slots with different sensor
indexes.
That kind of slot re-use may or may not end up confusing other
subsurface logic - for example, make things believe there was a
cylidner change event.
- some dive computers might send only one sample at a time, but switch
*which* sample they send on a gas switch event. If they also report
the correct sensor number, we'll now start reporting that pressure in
the second slot.
This should all be fine, and is the RightThing(tm) to do, but is
different from what we used to do when we only ever used a single
slot.
- When people actually use multiple sensors, our old save format will
start to need fixing. Right now our save format comes from the CCR
model where the second sensor was always the Oxygen sensor.
We save that pressure fine (except we save it as "o2pressure" - just
an odd historical naming artifact), but we do *not* save the actual
sensor index, because in our traditional format that was always
implicit in the data ("it's the oxygen cylinder").
so while this code hopefully makes our libdivecomputer download do the
right thing, there *will* be further fallout from having multiple
cylinder pressure sensors. We're not done yet.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-07-24 18:55:47 +00:00
case DC_SAMPLE_PRESSURE :
add_sample_pressure ( sample , value . pressure . tank , lrint ( value . pressure . value * 1000 ) ) ;
2011-09-12 18:05:32 +00:00
break ;
Add support for libdivecomputer using DC_SAMPLE_GASMIX
New libdivecomputer versions use DC_SAMPLE_GASMIX to indicate a gas
change (which contains the cylinder index we're changing to) rather than
SAMPLE_EVENT_GASCHANGE*.
Unlike the old GASCHANGE model, and despite the name, DC_SAMPLE_GASMIX
does not actually say what the mix is, it only specifies a cylinder
index. We had already extended SAMPLE_EVENT_GASCHANGE2 to have the
cylinder index in the otherwise unused "flags" field, so this is not all
that different from what we used to do.
And subsurface internally already had the logic that "if we know what
the cylinder index is, take the gas mix from the cylinder data", so
we've already been able to transparently use _either_ the actual gas mix
or the cylinder index to show the event.
But we do want to make it an event rather than some sample data, because
we want to show it as such in the profile. But because we are happy
with just the cylinder index, we'll just translate the DC_SAMPLE_GASMIX
thing to the SAMPLE_EVENT_GASCHANGE2 event, and nothing really changes
for subsurface.
libdivecomputer has made other changes, like indicating the initial
cylinder index with an early DC_SAMPLE_GASMIX report, but we've seen
that before too (in the form of early SAMPLE_EVENT_GASCHANGE events), so
that doesn't really end up changing anything for us either.
HOWEVER, one thing that is worth noticing: do *not* apply this patch and
then use an old libdivecomputer library that sends both the
DC_SAMPLE_GASMIX samples _and_ the deprecated SAMPLE_EVENT_GASCHANGE
events. It will all *work*, but since subsurface will take either,
you'll then get duplicate gas mix events.
It's not like that is in any way fatal, but it might be a bit confusing.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-01-03 23:18:03 +00:00
case DC_SAMPLE_GASMIX :
handle_gasmix ( dc , sample , value . gasmix ) ;
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_TEMPERATURE :
2013-11-26 22:11:30 +00:00
sample - > temperature . mkelvin = C_to_mkelvin ( value . temperature ) ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_EVENT :
2012-11-24 02:51:27 +00:00
handle_event ( dc , sample , value ) ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_RBT :
Add support for RBT reported sample value
RBT (Remaining Bottom Time) is a value calculated on the fly by some air
integrated divecomputers, for example Uwatec devices. This value is an
estimation based in some heuristic around time function pressure
gradients. This way, RBT would be the time a diver can spend at actual
depth without running out of gas (taking account of ascent, deco, if
required, and rock bottom gas reserve, if set).
Older Uwatec devices just made the calculus and only stored alarm events
if this time value reached zero, but modern devices store the value each
sample, in minutes.
It seems that Suunto Eon Steel is storing RBT values too, in seconds.
Libdivecomputer has supported RBT for a while, but Subsurface just
printed it to stdout and dropped it.
This adds support for RBT value on subsurface sample structure and shows
it in the profile's info box, right under TTS(calc), if selected, where
these two values can be easily compared by humans.
Signed-off-by: Salvador Cuñat <salvador.cunat@gmail.com>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-22 15:02:33 +00:00
sample - > rbt . seconds = ( ! strncasecmp ( dc - > model , " suunto " , 6 ) ) ? value . rbt : value . rbt * 60 ;
2011-09-12 18:05:32 +00:00
break ;
2018-09-02 20:14:41 +00:00
# ifdef DC_SAMPLE_TTS
case DC_SAMPLE_TTS :
sample - > tts . seconds = value . time ;
break ;
# endif
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_HEARTBEAT :
2017-11-14 11:36:40 +00:00
sample - > heartbeat = heartbeat = value . heartbeat ;
2011-09-12 18:05:32 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_BEARING :
2017-11-14 11:36:40 +00:00
sample - > bearing . degrees = bearing = value . bearing ;
2011-09-12 18:05:32 +00:00
break ;
2014-11-20 23:04:01 +00:00
# ifdef DEBUG_DC_VENDOR
2012-06-22 20:37:39 +00:00
case DC_SAMPLE_VENDOR :
2024-05-01 09:01:06 +00:00
printf ( " <vendor time='%u:%02u' type= \" %u \" size= \" %u \" > " , FRACTION_TUPLE ( sample - > time . seconds , 60 ) ,
2014-02-28 04:09:57 +00:00
value . vendor . type , value . vendor . size ) ;
2014-11-27 19:55:24 +00:00
for ( int i = 0 ; i < value . vendor . size ; + + i )
2014-02-28 04:09:57 +00:00
printf ( " %02X " , ( ( unsigned char * ) value . vendor . data ) [ i ] ) ;
2011-09-12 18:05:32 +00:00
printf ( " </vendor> \n " ) ;
break ;
2014-11-20 23:04:01 +00:00
# endif
2012-12-08 04:08:29 +00:00
case DC_SAMPLE_SETPOINT :
/* for us a setpoint means constant pO2 from here */
2017-03-08 06:41:41 +00:00
sample - > setpoint . mbar = po2 = lrint ( value . setpoint * 1000 ) ;
2012-12-08 04:08:29 +00:00
break ;
case DC_SAMPLE_PPO2 :
2024-01-20 23:35:44 +00:00
if ( nsensor < MAX_O2_SENSORS )
2024-02-01 03:06:33 +00:00
sample - > o2sensor [ nsensor ] . mbar = lrint ( value . ppo2 . value * 1000 ) ;
2015-08-31 21:23:43 +00:00
else
report_error ( " %d is more o2 sensors than we can handle " , nsensor ) ;
nsensor + + ;
2015-09-13 17:58:55 +00:00
// Set the amount of detected o2 sensors
if ( nsensor > dc - > no_o2sensors )
dc - > no_o2sensors = nsensor ;
2012-12-08 04:08:29 +00:00
break ;
case DC_SAMPLE_CNS :
2017-03-08 06:41:41 +00:00
sample - > cns = cns = lrint ( value . cns * 100 ) ;
2012-12-08 04:08:29 +00:00
break ;
2012-12-11 15:43:11 +00:00
case DC_SAMPLE_DECO :
if ( value . deco . type = = DC_DECO_NDL ) {
2012-12-31 02:11:01 +00:00
sample - > ndl . seconds = ndl = value . deco . time ;
2017-03-08 06:41:41 +00:00
sample - > stopdepth . mm = stopdepth = lrint ( value . deco . depth * 1000.0 ) ;
2014-01-15 18:54:41 +00:00
sample - > in_deco = in_deco = false ;
2012-12-11 15:43:11 +00:00
} else if ( value . deco . type = = DC_DECO_DECOSTOP | |
value . deco . type = = DC_DECO_DEEPSTOP ) {
2017-03-08 06:41:41 +00:00
sample - > stopdepth . mm = stopdepth = lrint ( value . deco . depth * 1000.0 ) ;
2012-12-31 02:11:01 +00:00
sample - > stoptime . seconds = stoptime = value . deco . time ;
2018-09-02 20:52:48 +00:00
sample - > in_deco = in_deco = stopdepth > 0 ;
2012-12-29 02:39:01 +00:00
ndl = 0 ;
2012-12-31 02:11:01 +00:00
} else if ( value . deco . type = = DC_DECO_SAFETYSTOP ) {
2014-01-15 18:54:41 +00:00
sample - > in_deco = in_deco = false ;
2017-03-08 06:41:41 +00:00
sample - > stopdepth . mm = stopdepth = lrint ( value . deco . depth * 1000.0 ) ;
2012-12-31 02:11:01 +00:00
sample - > stoptime . seconds = stoptime = value . deco . time ;
2012-12-11 15:43:11 +00:00
}
2024-02-01 03:06:33 +00:00
sample - > tts . seconds = value . deco . tts ;
2011-09-12 18:05:32 +00:00
default :
break ;
}
}
2024-03-01 12:09:20 +00:00
static void dev_info ( device_data_t * , const char * fmt , . . . )
2012-05-03 00:40:39 +00:00
{
2013-03-04 01:53:43 +00:00
static char buffer [ 1024 ] ;
2012-05-03 00:40:39 +00:00
va_list ap ;
va_start ( ap , fmt ) ;
vsnprintf ( buffer , sizeof ( buffer ) , fmt , ap ) ;
va_end ( ap ) ;
2012-09-20 19:56:42 +00:00
progress_bar_text = buffer ;
2020-10-03 19:57:42 +00:00
if ( verbose )
2024-05-14 23:38:00 +00:00
INFO ( " dev_info: %s " , buffer ) ;
2020-10-03 19:57:42 +00:00
2017-07-09 19:43:06 +00:00
if ( progress_callback )
( * progress_callback ) ( buffer ) ;
2012-05-03 00:40:39 +00:00
}
2011-09-12 18:05:32 +00:00
2012-05-03 00:40:39 +00:00
static int import_dive_number = 0 ;
2019-09-11 15:23:29 +00:00
static void download_error ( const char * fmt , . . . )
{
static char buffer [ 1024 ] ;
va_list ap ;
va_start ( ap , fmt ) ;
vsnprintf ( buffer , sizeof ( buffer ) , fmt , ap ) ;
va_end ( ap ) ;
report_error ( " Dive %d: %s " , import_dive_number , buffer ) ;
}
2024-04-28 11:39:39 +00:00
static dc_status_t parse_samples ( device_data_t * , struct divecomputer * dc , dc_parser_t * parser )
2011-09-12 18:05:32 +00:00
{
// Parse the sample data.
2012-11-24 02:51:27 +00:00
return dc_parser_samples_foreach ( parser , sample_cb , dc ) ;
2011-09-12 18:05:32 +00:00
}
2012-12-28 22:12:10 +00:00
static int might_be_same_dc ( struct divecomputer * a , struct divecomputer * b )
{
if ( ! a - > model | | ! b - > model )
return 1 ;
if ( strcasecmp ( a - > model , b - > model ) )
return 0 ;
if ( ! a - > deviceid | | ! b - > deviceid )
return 1 ;
return a - > deviceid = = b - > deviceid ;
}
2012-12-16 18:40:17 +00:00
static int match_one_dive ( struct divecomputer * a , struct dive * dive )
2012-11-25 03:06:06 +00:00
{
2012-12-16 18:40:17 +00:00
struct divecomputer * b = & dive - > dc ;
/*
* Walk the existing dive computer data ,
* see if we have a match ( or an anti - match :
* the same dive computer but a different
* dive ID ) .
*/
do {
int match = match_one_dc ( a , b ) ;
if ( match )
return match > 0 ;
b = b - > next ;
} while ( b ) ;
/* Ok, no exact dive computer match. Does the date match? */
b = & dive - > dc ;
do {
2012-12-28 22:12:10 +00:00
if ( a - > when = = b - > when & & might_be_same_dc ( a , b ) )
2012-12-16 18:40:17 +00:00
return 1 ;
b = b - > next ;
} while ( b ) ;
return 0 ;
2012-11-25 03:06:06 +00:00
}
2011-09-26 20:04:14 +00:00
/*
* Check if this dive already existed before the import
*/
2012-11-25 03:06:06 +00:00
static int find_dive ( struct divecomputer * match )
2011-09-26 20:04:14 +00:00
{
int i ;
core: introduce divelog structure
The parser API was very annoying, as a number of tables
to-be-filled were passed in as pointers. The goal of this
commit is to collect all these tables in a single struct.
This should make it (more or less) clear what is actually
written into the divelog files.
Moreover, it should now be rather easy to search for
instances, where the global logfile is accessed (and it
turns out that there are many!).
The divelog struct does not contain the tables as substructs,
but only collects pointers. The idea is that the "divelog.h"
file can be included without all the other files describing
the numerous tables.
To make it easier to use from C++ parts of the code, the
struct implements a constructor and a destructor. Sadly,
we can't use smart pointers, since the pointers are accessed
from C code. Therfore the constructor and destructor are
quite complex.
The whole commit is large, but was mostly an automatic
conversion.
One oddity of note: the divelog structure also contains
the "autogroup" flag, since that is saved in the divelog.
This actually fixes a bug: Before, when importing dives
from a different log, the autogroup flag was overwritten.
This was probably not intended and does not happen anymore.
Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
for ( i = divelog . dives - > nr - 1 ; i > = 0 ; i - - ) {
struct dive * old = divelog . dives - > dives [ i ] ;
2011-09-26 20:04:14 +00:00
2012-12-16 18:40:17 +00:00
if ( match_one_dive ( match , old ) )
2012-11-25 03:06:06 +00:00
return 1 ;
2011-09-26 20:04:14 +00:00
}
return 0 ;
}
2012-11-25 19:44:27 +00:00
/*
* The dive ID for libdivecomputer dives is the first word of the
* SHA1 of the fingerprint , if it exists .
*
* NOTE ! This is byte - order dependent , and I don ' t care .
*/
static uint32_t calculate_diveid ( const unsigned char * fingerprint , unsigned int fsize )
{
if ( ! fingerprint | | ! fsize )
return 0 ;
2024-04-23 07:28:11 +00:00
return SHA1_uint32 ( fingerprint , fsize ) ;
2012-11-25 19:44:27 +00:00
}
Clean up divecomputer 'device' handling
We have this odd legacy notion of a divecomputer 'device', that was
originally just basically the libdivecomputer 'EVENT_DEVINFO' report
that was associated with each dive. So it had firmware version,
deviceid, and serial number.
It had also gotten extended to do 'nickname' handling, and it was all
confusing, ugly and bad. It was particularly bad because it wasn't
actually a 'per device' thing at all: due to the firmware field, a dive
computer that got a firmware update forced a new 'device'.
To make matters worse, the 'deviceid' was also almost random, because
we've calculated it a couple of different ways, and libdivecomputer
itself has changed how the legacy 32-bit 'serial number' is expressed.
Finally, because of all these issues, we didn't even try to make the
thing unique, so it really ended up being a random snapshot of the state
of the dive computer at the time of a dive, and sometimes we'd pick one,
and sometimes another, since they weren't really well-defined.
So get rid of all this confusion.
The new rules:
- the actual random dive computer state at the time of a dive is kept
in the dive data. So if you want to know the firmware version, it
should be in the 'extra data'
- the only serial number that matters is the string one in the extra
data, because that's the one that actually matches what the dive
computer reports, and isn't some random 32-bit integer with ambiguous
formatting.
- the 'device id' - the thing we match with (together with the model
name, eg "Suunto EON Steel") is purely a hash of the real serial
number.
The device ID that libdivecomputer reports in EVENT_DEVINFO is
ignored, as is the device ID we've saved in the XML or git files. If
we have a serial number, the device ID will be uniquely associated
with that serial number, and if we don't have one, the device ID will
be zero (for 'match anything').
So now 'deviceid' is literally just a shorthand for the serial number
string, and the two are joined at the hip.
- the 'device' managament is _only_ used to track devices that have
serial numbers _and_ nicknames. So no more different device
structures just because one had a nickname and the other didn't etc.
Without a serial number, the device is 'anonymous' and fundamentally
cannot be distinguished from other devices of the same model, so a
nickname is meaningless. And without a nickname, there is no point in
creating a device data structure, since all the data is in the dive
itself and the device structure wouldn't add any value..
These rules mean that we no longer have ambiguous 'device' structures,
and we can never have duplicates that can confuse us.
This does mean that you can't give a nickname to a device that cannot be
uniquely identified with a serial number, but those are happily fairly
rare (and mostly older ones). Dirk said he'd look at what it takes to
give more dive computers proper serial numbers, and I already did it for
the Garmin Descent family yesterday.
(Honesty in advertizing: right now you can't add a nickname to a dive
computer that doesn't already have one, because such a dive computer
will not have a device structure. But that's a UI issue, and I'll sort
that out separately)
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-08-16 22:50:11 +00:00
uint32_t calculate_string_hash ( const char * str )
2014-10-22 19:11:12 +00:00
{
2015-05-28 12:59:08 +00:00
return calculate_diveid ( ( const unsigned char * ) str , strlen ( str ) ) ;
2014-10-22 19:11:12 +00:00
}
2019-02-28 21:45:17 +00:00
static void parse_string_field ( device_data_t * devdata , struct dive * dive , dc_field_string_t * str )
2014-10-22 19:11:12 +00:00
{
// Our dive ID is the string hash of the "Dive ID" string
if ( ! strcmp ( str - > desc , " Dive ID " ) ) {
if ( ! dive - > dc . diveid )
dive - > dc . diveid = calculate_string_hash ( str - > value ) ;
return ;
}
Update the serial number and deviceid in sync when loading
When we save the divecomputer data, we never actually save the serial
value as a field. We used to rely on saving the very dodgy 'deviceid',
and then look up the serial number from there. And that never really
worked reliably, but we didn't really notice, because we never really
_used_ the serial number anywhere.
The only place the serial number is actually reliably displayed is in
the "Extra data" tab, which contains the key value pairs, and that's
where the original dive download code got the serial number from.
So just parse that at load time too, the same way we parsed it at dive
download time.
In fact, do the firmware version the same way, and remove the code from
the downloader, since it too can rely on 'add_extra_data()' just picking
up the information directly.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-08-17 06:52:00 +00:00
// This will pick up serial number and firmware data
2014-11-22 05:42:00 +00:00
add_extra_data ( & dive - > dc , str - > desc , str - > value ) ;
Update the serial number and deviceid in sync when loading
When we save the divecomputer data, we never actually save the serial
value as a field. We used to rely on saving the very dodgy 'deviceid',
and then look up the serial number from there. And that never really
worked reliably, but we didn't really notice, because we never really
_used_ the serial number anywhere.
The only place the serial number is actually reliably displayed is in
the "Extra data" tab, which contains the key value pairs, and that's
where the original dive download code got the serial number from.
So just parse that at load time too, the same way we parsed it at dive
download time.
In fact, do the firmware version the same way, and remove the code from
the downloader, since it too can rely on 'add_extra_data()' just picking
up the information directly.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-08-17 06:52:00 +00:00
2018-08-30 01:51:51 +00:00
/* GPS data? */
if ( ! strncmp ( str - > desc , " GPS " , 3 ) ) {
char * line = ( char * ) str - > value ;
2018-10-20 18:12:15 +00:00
location_t location ;
2018-08-30 01:51:51 +00:00
2020-09-29 18:36:26 +00:00
/* Do we already have a divesite? */
if ( dive - > dive_site ) {
/*
* " GPS1 " always takes precedence , anything else
* we ' ll just pick the first " GPS* " that matches .
*/
if ( strcmp ( str - > desc , " GPS1 " ) ! = 0 )
return ;
}
2018-10-20 18:12:15 +00:00
parse_location ( line , & location ) ;
2018-08-30 01:51:51 +00:00
2019-03-05 21:58:47 +00:00
if ( location . lat . udeg & & location . lon . udeg ) {
unregister_dive_from_dive_site ( dive ) ;
2024-05-04 15:18:08 +00:00
add_dive_to_dive_site ( dive , create_dive_site_with_gps ( std : : string ( str - > value ) , & location , devdata - > log - > sites ) ) ;
2019-03-05 21:58:47 +00:00
}
2018-08-30 01:51:51 +00:00
}
2014-10-22 19:11:12 +00:00
}
2017-07-17 23:50:03 +00:00
static dc_status_t libdc_header_parser ( dc_parser_t * parser , device_data_t * devdata , struct dive * dive )
2011-09-12 17:27:35 +00:00
{
2024-03-01 12:09:20 +00:00
dc_status_t rc = static_cast < dc_status_t > ( 0 ) ;
2014-02-28 04:09:57 +00:00
dc_datetime_t dt = { 0 } ;
2011-09-12 20:25:05 +00:00
struct tm tm ;
2011-09-12 17:27:35 +00:00
2012-06-22 20:37:39 +00:00
rc = dc_parser_get_datetime ( parser , & dt ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error parsing the datetime " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 17:27:35 +00:00
}
2015-04-03 22:44:01 +00:00
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
// Our deviceid is the hash of the serial number
dive - > dc . deviceid = 0 ;
2011-09-12 17:27:35 +00:00
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS ) {
tm . tm_year = dt . year ;
tm . tm_mon = dt . month - 1 ;
tm . tm_mday = dt . day ;
tm . tm_hour = dt . hour ;
tm . tm_min = dt . minute ;
tm . tm_sec = dt . second ;
dive - > when = dive - > dc . when = utc_mktime ( & tm ) ;
}
2015-04-03 22:44:01 +00:00
2011-09-12 18:05:32 +00:00
// Parse the divetime.
2024-03-02 08:12:21 +00:00
std : : string date_string = get_dive_date_c_string ( dive - > when ) ;
dev_info ( devdata , translate ( " gettextFromC " , " Dive %d: %s " ) , import_dive_number , date_string . c_str ( ) ) ;
2015-06-22 03:24:07 +00:00
2011-09-12 18:05:32 +00:00
unsigned int divetime = 0 ;
2014-02-28 04:09:57 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_DIVETIME , 0 , & divetime ) ;
2012-06-22 20:37:39 +00:00
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error parsing the divetime " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 18:05:32 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
dive - > dc . duration . seconds = divetime ;
2011-09-12 18:05:32 +00:00
// Parse the maxdepth.
double maxdepth = 0.0 ;
2012-06-22 20:37:39 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_MAXDEPTH , 0 , & maxdepth ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error parsing the maxdepth " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 18:05:32 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
2017-03-08 06:41:41 +00:00
dive - > dc . maxdepth . mm = lrint ( maxdepth * 1000 ) ;
2011-09-12 18:05:32 +00:00
2014-11-08 06:45:59 +00:00
// Parse temperatures
double temperature ;
dc_field_type_t temp_fields [ ] = { DC_FIELD_TEMPERATURE_SURFACE ,
DC_FIELD_TEMPERATURE_MAXIMUM ,
DC_FIELD_TEMPERATURE_MINIMUM } ;
for ( int i = 0 ; i < 3 ; i + + ) {
rc = dc_parser_get_field ( parser , temp_fields [ i ] , 0 , & temperature ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error parsing temperature " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2014-11-08 06:45:59 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
switch ( i ) {
case 0 :
dive - > dc . airtemp . mkelvin = C_to_mkelvin ( temperature ) ;
break ;
case 1 : // we don't distinguish min and max water temp here, so take min if given, max otherwise
case 2 :
dive - > dc . watertemp . mkelvin = C_to_mkelvin ( temperature ) ;
break ;
}
2014-11-08 06:45:59 +00:00
}
2011-09-12 18:05:32 +00:00
// Parse the gas mixes.
unsigned int ngases = 0 ;
2012-06-22 20:37:39 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_GASMIX_COUNT , 0 , & ngases ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error parsing the gas mix count " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2011-09-12 18:05:32 +00:00
}
2013-10-03 12:06:12 +00:00
// Check if the libdivecomputer version already supports salinity & atmospheric
dc_salinity_t salinity = {
. type = DC_WATER_SALT ,
2014-02-28 04:09:57 +00:00
. density = SEAWATER_SALINITY / 10.0
2013-10-03 12:06:12 +00:00
} ;
2012-11-10 18:18:10 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_SALINITY , 0 , & salinity ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error obtaining water salinity " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2012-11-10 18:18:10 +00:00
}
2022-04-13 01:28:13 +00:00
if ( rc = = DC_STATUS_SUCCESS ) {
2017-03-08 06:41:41 +00:00
dive - > dc . salinity = lrint ( salinity . density * 10.0 ) ;
2022-04-13 01:28:13 +00:00
if ( dive - > dc . salinity = = 0 ) {
// sometimes libdivecomputer gives us density values, sometimes just
// a water type and a density of zero; let's make this work as best as we can
switch ( salinity . type ) {
case DC_WATER_FRESH :
dive - > dc . salinity = FRESHWATER_SALINITY ;
break ;
default :
dive - > dc . salinity = SEAWATER_SALINITY ;
break ;
}
}
}
2013-10-03 12:06:12 +00:00
2014-02-12 22:11:21 +00:00
double surface_pressure = 0 ;
2013-10-03 12:06:12 +00:00
rc = dc_parser_get_field ( parser , DC_FIELD_ATMOSPHERIC , 0 , & surface_pressure ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error obtaining surface pressure " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2013-10-03 12:06:12 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
2017-03-08 06:41:41 +00:00
dive - > dc . surface_pressure . mbar = lrint ( surface_pressure * 1000.0 ) ;
2012-11-10 18:18:10 +00:00
2014-10-22 19:11:12 +00:00
// The dive parsing may give us more device information
int idx ;
for ( idx = 0 ; idx < 100 ; idx + + ) {
dc_field_string_t str = { NULL } ;
rc = dc_parser_get_field ( parser , DC_FIELD_STRING , idx , & str ) ;
if ( rc ! = DC_STATUS_SUCCESS )
break ;
if ( ! str . desc | | ! str . value )
break ;
2019-02-28 21:45:17 +00:00
parse_string_field ( devdata , dive , & str ) ;
2020-10-19 11:32:10 +00:00
free ( ( void * ) str . value ) ; // libdc gives us copies of the value-string.
2014-10-22 19:11:12 +00:00
}
2014-11-08 13:11:09 +00:00
dc_divemode_t divemode ;
rc = dc_parser_get_field ( parser , DC_FIELD_DIVEMODE , 0 , & divemode ) ;
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error obtaining dive mode " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
2014-11-08 13:11:09 +00:00
}
2015-01-09 19:01:06 +00:00
if ( rc = = DC_STATUS_SUCCESS )
switch ( divemode ) {
case DC_DIVEMODE_FREEDIVE :
2015-01-21 07:52:28 +00:00
dive - > dc . divemode = FREEDIVE ;
break ;
2015-01-09 19:01:06 +00:00
case DC_DIVEMODE_GAUGE :
case DC_DIVEMODE_OC : /* Open circuit */
2015-01-10 23:01:15 +00:00
dive - > dc . divemode = OC ;
2015-01-09 19:01:06 +00:00
break ;
2017-12-13 08:47:57 +00:00
case DC_DIVEMODE_CCR : /* Closed circuit rebreather*/
2015-01-10 23:01:15 +00:00
dive - > dc . divemode = CCR ;
2015-01-09 19:01:06 +00:00
break ;
2017-12-13 08:47:57 +00:00
case DC_DIVEMODE_SCR : /* Semi-closed circuit rebreather */
dive - > dc . divemode = PSCR ;
break ;
2015-01-09 19:01:06 +00:00
}
2014-11-08 13:11:09 +00:00
2015-04-03 23:11:35 +00:00
rc = parse_gasmixes ( devdata , dive , parser , ngases ) ;
2015-04-03 22:44:01 +00:00
if ( rc ! = DC_STATUS_SUCCESS & & rc ! = DC_STATUS_UNSUPPORTED ) {
2019-09-11 15:23:29 +00:00
download_error ( translate ( " gettextFromC " , " Error parsing the gas mix " ) ) ;
2015-04-03 22:44:01 +00:00
return rc ;
}
return DC_STATUS_SUCCESS ;
}
/* returns true if we want libdivecomputer's dc_device_foreach() to continue,
* false otherwise */
static int dive_cb ( const unsigned char * data , unsigned int size ,
const unsigned char * fingerprint , unsigned int fsize ,
void * userdata )
{
2024-04-28 11:39:39 +00:00
dc_status_t rc ;
2015-04-03 22:44:01 +00:00
dc_parser_t * parser = NULL ;
2024-03-01 12:09:20 +00:00
device_data_t * devdata = ( device_data_t * ) userdata ;
2015-04-03 22:44:01 +00:00
struct dive * dive = NULL ;
2017-04-24 14:28:06 +00:00
/* reset static data, that is only valid per dive */
2017-11-14 12:59:13 +00:00
stoptime = stopdepth = po2 = cns = heartbeat = 0 ;
ndl = bearing = - 1 ;
2015-04-03 22:44:01 +00:00
in_deco = false ;
2016-08-29 21:07:17 +00:00
current_gas_index = - 1 ;
2015-04-03 22:44:01 +00:00
2019-09-11 15:23:29 +00:00
import_dive_number + + ;
2024-02-01 03:06:33 +00:00
rc = dc_parser_new ( & parser , devdata - > device , data , size ) ;
2015-04-03 22:44:01 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-05-02 19:26:22 +00:00
download_error ( translate ( " gettextFromC " , " Unable to create parser for %s %s: %d " ) , devdata - > vendor . c_str ( ) , devdata - > product . c_str ( ) , errmsg ( rc ) ) ;
Keep parsing dives even if one dive parse failed
Eric Charbonnier reported a problem downloading the dives from his
OSTC2, and Jef debugged the libdivecomputer log and says:
"Your ostc has 75 dives, but subsurface downloaded only one, and then
stopped the download. That's because that first dive appears to be
corrupt and fails to parse:
ERROR: Buffer overflow detected! [in /win/subsurface/libdivecomputer/src/hw_ostc_parser.c:981 (hw_ostc_parser_samples_foreach)]
Subsurface (incorrectly) considers that a fatal error and stops the
entire download. From a user point of view, it would be much better to
ignore the problematic dive, and continue downloading the remaining"
Subsurface used to just stop downloading if there were parsing errors,
but Jef further says:
"How parser errors are handled is up to the application. Aborting the
download is probably the worst option here. If a dive fails to parse
(because the dive data is corrupt, the parser contains a bug, etc),
that does not necessary mean the remaining dives can't be downloaded"
so let's change the logic to just continue downloading, and hope other
dives work better.
We might want to do better error reporting, right now the errors tend to
just cause "dev_info()" reports, which just set the progress bar text.
So you'll see it in the progress bar as it happens, but it won't get
really ever noted as an error, and it's easy to miss.
But that error reporting is a separate issue, and this just does the
"continue to the next dive" part.
Reported-by: Eric Charbonnier <eric.charbonnier69@gmail.com>
Suggested-by: Jef Driesen <jef@libdivecomputer.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-09-11 14:27:29 +00:00
return true ;
2015-04-03 22:44:01 +00:00
}
dive = alloc_dive ( ) ;
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
// Fill in basic fields
2024-05-02 19:26:22 +00:00
dive - > dc . model = strdup ( devdata - > model . c_str ( ) ) ;
Preferentially use existing device ID when setting serial number
We have two different models for setting the deviceid associated with a
dive computer: either take the value from the libdivecomputer 'devinfo'
field (from the DC_EVENT_DEVINFO event), or generate the device ID by
just hashing the serial number string.
The one thing we do *not* want to have, is to use both methods, so that
the same device generates different device IDs. Because then we'll
think we have two different dive computers even though they are one and
the same.
Usually, this is not an issue, because libdivecomputer either sends the
DEVINFO event or gives us the serial number string, and we'll always
just pick one or the other.
However, in the case of at least the Suunto EON Steel, I intentionally
did *not* send the DC_EVENT_DEVINFO event, because it gives no useful
information. We used the serial number string to generate a device ID,
and everything was fine.
However, in commit d40cdb4755ee ("Add the devinfo event") in the
libdivecomputer tree, Jeff started generating those DC_EVENT_DEVINFO
events for the EON Steel too, and suddenly subsurface would start using
a device ID based on that instead.
The situation is inherently ambiguous - for the EON Steel, we want to
use the hash of the serial number (because that is what we've
historically done), but other dive computers might want to use the
DEVINFO data (because that is what _those_ backends have historically
done, even if they might also implement the new serial string model).
This commit makes subsurface resolve this ambiguity by simply preferring
whatever previous device ID it has associated with that particular
serial number string. If you have no previous device IDs, it doesn't
matter which one you pick.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-06-21 00:59:26 +00:00
dive - > dc . diveid = calculate_diveid ( fingerprint , fsize ) ;
2015-04-03 22:44:01 +00:00
// Parse the dive's header data
rc = libdc_header_parser ( parser , devdata , dive ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-04-28 11:39:39 +00:00
download_error ( translate ( " getextFromC " , " Error parsing the header: %s " ) , errmsg ( rc ) ) ;
2015-04-03 22:44:01 +00:00
goto error_exit ;
}
2011-09-12 18:05:32 +00:00
// Initialize the sample data.
2012-11-24 02:51:27 +00:00
rc = parse_samples ( devdata , & dive - > dc , parser ) ;
2012-06-22 20:37:39 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-04-28 11:39:39 +00:00
download_error ( translate ( " gettextFromC " , " Error parsing the samples: %s " ) , errmsg ( rc ) ) ;
2014-03-06 23:36:46 +00:00
goto error_exit ;
2011-09-12 18:05:32 +00:00
}
Keep parsing dives even if one dive parse failed
Eric Charbonnier reported a problem downloading the dives from his
OSTC2, and Jef debugged the libdivecomputer log and says:
"Your ostc has 75 dives, but subsurface downloaded only one, and then
stopped the download. That's because that first dive appears to be
corrupt and fails to parse:
ERROR: Buffer overflow detected! [in /win/subsurface/libdivecomputer/src/hw_ostc_parser.c:981 (hw_ostc_parser_samples_foreach)]
Subsurface (incorrectly) considers that a fatal error and stops the
entire download. From a user point of view, it would be much better to
ignore the problematic dive, and continue downloading the remaining"
Subsurface used to just stop downloading if there were parsing errors,
but Jef further says:
"How parser errors are handled is up to the application. Aborting the
download is probably the worst option here. If a dive fails to parse
(because the dive data is corrupt, the parser contains a bug, etc),
that does not necessary mean the remaining dives can't be downloaded"
so let's change the logic to just continue downloading, and hope other
dives work better.
We might want to do better error reporting, right now the errors tend to
just cause "dev_info()" reports, which just set the progress bar text.
So you'll see it in the progress bar as it happens, but it won't get
really ever noted as an error, and it's easy to miss.
But that error reporting is a separate issue, and this just does the
"continue to the next dive" part.
Reported-by: Eric Charbonnier <eric.charbonnier69@gmail.com>
Suggested-by: Jef Driesen <jef@libdivecomputer.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-09-11 14:27:29 +00:00
dc_parser_destroy ( parser ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
/*
* Save off fingerprint data .
*
* NOTE ! We do this after parsing the dive fully , so that
* we have the final deviceid here .
*/
if ( fingerprint & & fsize & & ! devdata - > fingerprint ) {
2024-03-01 12:09:20 +00:00
devdata - > fingerprint = ( unsigned char * ) calloc ( fsize , 1 ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
if ( devdata - > fingerprint ) {
devdata - > fsize = fsize ;
devdata - > fdeviceid = dive - > dc . deviceid ;
devdata - > fdiveid = dive - > dc . diveid ;
memcpy ( devdata - > fingerprint , fingerprint , fsize ) ;
}
}
2011-09-26 20:04:14 +00:00
/* If we already saw this dive, abort. */
2017-07-09 23:29:16 +00:00
if ( ! devdata - > force_download & & find_dive ( & dive - > dc ) ) {
2024-03-02 08:12:21 +00:00
std : : string date_string = get_dive_date_c_string ( dive - > when ) ;
dev_info ( devdata , translate ( " gettextFromC " , " Already downloaded dive at %s " ) , date_string . c_str ( ) ) ;
2022-08-20 15:24:45 +00:00
free_dive ( dive ) ;
Keep parsing dives even if one dive parse failed
Eric Charbonnier reported a problem downloading the dives from his
OSTC2, and Jef debugged the libdivecomputer log and says:
"Your ostc has 75 dives, but subsurface downloaded only one, and then
stopped the download. That's because that first dive appears to be
corrupt and fails to parse:
ERROR: Buffer overflow detected! [in /win/subsurface/libdivecomputer/src/hw_ostc_parser.c:981 (hw_ostc_parser_samples_foreach)]
Subsurface (incorrectly) considers that a fatal error and stops the
entire download. From a user point of view, it would be much better to
ignore the problematic dive, and continue downloading the remaining"
Subsurface used to just stop downloading if there were parsing errors,
but Jef further says:
"How parser errors are handled is up to the application. Aborting the
download is probably the worst option here. If a dive fails to parse
(because the dive data is corrupt, the parser contains a bug, etc),
that does not necessary mean the remaining dives can't be downloaded"
so let's change the logic to just continue downloading, and hope other
dives work better.
We might want to do better error reporting, right now the errors tend to
just cause "dev_info()" reports, which just set the progress bar text.
So you'll see it in the progress bar as it happens, but it won't get
really ever noted as an error, and it's easy to miss.
But that error reporting is a separate issue, and this just does the
"continue to the next dive" part.
Reported-by: Eric Charbonnier <eric.charbonnier69@gmail.com>
Suggested-by: Jef Driesen <jef@libdivecomputer.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-09-11 14:27:29 +00:00
return false ;
2017-07-09 23:29:16 +00:00
}
2014-03-06 23:36:46 +00:00
2013-01-23 02:15:07 +00:00
/* Various libdivecomputer interface fixups */
2015-11-25 20:08:28 +00:00
if ( dive - > dc . airtemp . mkelvin = = 0 & & first_temp_is_air & & dive - > dc . samples ) {
2013-01-23 18:25:31 +00:00
dive - > dc . airtemp = dive - > dc . sample [ 0 ] . temperature ;
2013-01-23 02:15:07 +00:00
dive - > dc . sample [ 0 ] . temperature . mkelvin = 0 ;
}
2022-04-13 18:51:48 +00:00
/* special case for bug in Tecdiving DiveComputer.eu
* often the first sample has a water temperature of 0 C , followed by the correct
* temperature in the next sample */
if ( same_string ( dive - > dc . model , " Tecdiving DiveComputer.eu " ) & &
dive - > dc . sample [ 0 ] . temperature . mkelvin = = ZERO_C_IN_MKELVIN & &
dive - > dc . sample [ 1 ] . temperature . mkelvin > dive - > dc . sample [ 0 ] . temperature . mkelvin )
dive - > dc . sample [ 0 ] . temperature . mkelvin = dive - > dc . sample [ 1 ] . temperature . mkelvin ;
2022-11-12 11:44:29 +00:00
record_dive_to_table ( dive , devdata - > log - > dives ) ;
2014-01-27 19:42:19 +00:00
return true ;
2014-03-06 23:36:46 +00:00
error_exit :
dc_parser_destroy ( parser ) ;
2022-08-20 15:24:45 +00:00
free_dive ( dive ) ;
Keep parsing dives even if one dive parse failed
Eric Charbonnier reported a problem downloading the dives from his
OSTC2, and Jef debugged the libdivecomputer log and says:
"Your ostc has 75 dives, but subsurface downloaded only one, and then
stopped the download. That's because that first dive appears to be
corrupt and fails to parse:
ERROR: Buffer overflow detected! [in /win/subsurface/libdivecomputer/src/hw_ostc_parser.c:981 (hw_ostc_parser_samples_foreach)]
Subsurface (incorrectly) considers that a fatal error and stops the
entire download. From a user point of view, it would be much better to
ignore the problematic dive, and continue downloading the remaining"
Subsurface used to just stop downloading if there were parsing errors,
but Jef further says:
"How parser errors are handled is up to the application. Aborting the
download is probably the worst option here. If a dive fails to parse
(because the dive data is corrupt, the parser contains a bug, etc),
that does not necessary mean the remaining dives can't be downloaded"
so let's change the logic to just continue downloading, and hope other
dives work better.
We might want to do better error reporting, right now the errors tend to
just cause "dev_info()" reports, which just set the progress bar text.
So you'll see it in the progress bar as it happens, but it won't get
really ever noted as an error, and it's easy to miss.
But that error reporting is a separate issue, and this just does the
"continue to the next dive" part.
Reported-by: Eric Charbonnier <eric.charbonnier69@gmail.com>
Suggested-by: Jef Driesen <jef@libdivecomputer.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2019-09-11 14:27:29 +00:00
return true ;
2014-03-06 23:36:46 +00:00
2011-09-12 17:27:35 +00:00
}
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
# ifndef O_BINARY
# define O_BINARY 0
# endif
static void do_save_fingerprint ( device_data_t * devdata , const char * tmp , const char * final )
{
int fd , written = - 1 ;
fd = subsurface_open ( tmp , O_WRONLY | O_BINARY | O_CREAT | O_TRUNC , 0666 ) ;
if ( fd < 0 )
return ;
2021-10-28 00:31:48 +00:00
if ( verbose )
dev_info ( devdata , " Saving fingerprint for %08x:%08x to '%s' " ,
devdata - > fdeviceid , devdata - > fdiveid , final ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
/* The fingerprint itself.. */
written = write ( fd , devdata - > fingerprint , devdata - > fsize ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
/* ..followed by the device ID and dive ID of the fingerprinted dive */
if ( write ( fd , & devdata - > fdeviceid , 4 ) ! = 4 | | write ( fd , & devdata - > fdiveid , 4 ) ! = 4 )
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
written = - 1 ;
/* I'd like to do fsync() here too, but does Windows support it? */
if ( close ( fd ) < 0 )
written = - 1 ;
2024-03-01 12:09:20 +00:00
if ( written = = ( int ) devdata - > fsize ) {
2021-10-28 00:31:48 +00:00
if ( ! subsurface_rename ( tmp , final ) )
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
return ;
}
unlink ( tmp ) ;
}
2024-03-02 06:27:52 +00:00
static std : : string fingerprint_file ( device_data_t * devdata )
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
{
uint32_t model , serial ;
// Model hash and libdivecomputer 32-bit 'serial number' for the file name
2024-05-02 19:26:22 +00:00
model = calculate_string_hash ( devdata - > model . c_str ( ) ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
serial = devdata - > devinfo . serial ;
2024-03-02 06:27:52 +00:00
return format_string_std ( " %s/fingerprints/%04x.%u " ,
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
system_default_directory ( ) ,
model , serial ) ;
}
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
/*
* Save the fingerprint after a successful download
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
*
* NOTE ! At this point , we have the final device ID for the divecomputer
* we downloaded from . But that ' deviceid ' is actually not useful , because
* at the point where we want to _load_ this , we only have the libdivecomputer
* DC_EVENT_DEVINFO state ( devdata - > devinfo ) .
*
* Now , we do have the devdata - > devinfo at save time , but at load time we
* need to verify not only that it ' s the proper fingerprint file : we also
* need to check that we actually have the particular dive that was
* associated with that fingerprint state .
*
* That means that the fingerprint save file needs to include not only the
* fingerprint data itself , but also enough data to look up a dive unambiguously
* when loading the fingerprint . And the fingerprint data needs to be looked
* up using the DC_EVENT_DEVINFO data .
*
* End result :
*
* - fingerprint filename depends on the model name and ' devinfo . serial '
* so that we can look it up at DC_EVENT_DEVINFO time before the full
* info has been parsed .
*
* - the fingerprint file contains the ' diveid ' of the fingerprinted dive ,
* which is just a hash of the fingerprint itself .
*
* - we also save the final ' deviceid ' in the fingerprint file , so that
* looking up the dive associated with the fingerprint is possible .
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
*/
static void save_fingerprint ( device_data_t * devdata )
{
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
// Don't try to save nonexistent fingerprint data
if ( ! devdata - > fingerprint | | ! devdata - > fdiveid )
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
return ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
// Make sure the fingerprints directory exists
2024-03-02 06:27:52 +00:00
std : : string dir = format_string_std ( " %s/fingerprints " , system_default_directory ( ) ) ;
subsurface_mkdir ( dir . c_str ( ) ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
2024-03-02 06:27:52 +00:00
std : : string final = fingerprint_file ( devdata ) ;
std : : string tmp = final + " .tmp " ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
2024-03-02 06:27:52 +00:00
do_save_fingerprint ( devdata , tmp . c_str ( ) , final . c_str ( ) ) ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
}
/*
* The fingerprint cache files contain the actual libdivecomputer
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
* fingerprint , followed by 8 bytes of ( deviceid , diveid ) data .
*
* Before we use the fingerprint data , verify that we actually
* do have that fingerprinted dive .
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
*/
static void verify_fingerprint ( dc_device_t * device , device_data_t * devdata , const unsigned char * buffer , size_t size )
{
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
uint32_t diveid , deviceid ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
if ( size < = 8 )
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
return ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
size - = 8 ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
/* Get the dive ID from the end of the fingerprint cache file.. */
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
memcpy ( & deviceid , buffer + size , 4 ) ;
memcpy ( & diveid , buffer + size + 4 , 4 ) ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
2021-10-28 00:31:48 +00:00
if ( verbose )
dev_info ( devdata , " ... fingerprinted dive %08x:%08x " , deviceid , diveid ) ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
/* Only use it if we *have* that dive! */
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
if ( ! has_dive ( deviceid , diveid ) ) {
2021-10-28 00:31:48 +00:00
if ( verbose )
dev_info ( devdata , " ... dive not found " ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
return ;
}
dc_device_set_fingerprint ( device , buffer , size ) ;
2021-10-28 00:31:48 +00:00
if ( verbose )
dev_info ( devdata , " ... fingerprint of size %zu " , size ) ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
}
/*
* Look up the fingerprint from the fingerprint caches , and
* give it to libdivecomputer to avoid downloading already
* downloaded dives .
*/
static void lookup_fingerprint ( dc_device_t * device , device_data_t * devdata )
{
2021-10-30 18:02:24 +00:00
const unsigned char * raw_data ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
if ( devdata - > force_download )
return ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
2021-10-30 18:02:24 +00:00
/* first try our in memory data - raw_data is owned by the table, the dc_device_set_fingerprint function copies the data */
2024-05-02 19:26:22 +00:00
int fsize = get_fingerprint_data ( & fingerprint_table , calculate_string_hash ( devdata - > model . c_str ( ) ) , devdata - > devinfo . serial , & raw_data ) ;
2021-10-30 18:02:24 +00:00
if ( fsize ) {
if ( verbose )
dev_info ( devdata , " ... found fingerprint in dive table " ) ;
dc_device_set_fingerprint ( device , raw_data , fsize ) ;
return ;
}
/* now check if we have a fingerprint on disk */
2024-03-02 06:27:52 +00:00
std : : string cachename = fingerprint_file ( devdata ) ;
2021-10-28 00:31:48 +00:00
if ( verbose )
2024-03-02 06:27:52 +00:00
dev_info ( devdata , " Looking for fingerprint in '%s' " , cachename . c_str ( ) ) ;
auto [ mem , err ] = readfile ( cachename . c_str ( ) ) ;
2024-03-01 12:09:20 +00:00
if ( err > 0 ) {
2021-10-28 00:31:48 +00:00
if ( verbose )
2024-03-01 12:09:20 +00:00
dev_info ( devdata , " ... got %zu bytes " , mem . size ( ) ) ;
verify_fingerprint ( device , devdata , ( unsigned char * ) mem . data ( ) , mem . size ( ) ) ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
}
}
Assemble the actual Suunto serial number
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>
2013-01-10 00:14:21 +00:00
2012-06-22 20:37:39 +00:00
static void event_cb ( dc_device_t * device , dc_event_type_t event , const void * data , void * userdata )
2011-09-12 16:50:40 +00:00
{
2021-10-27 23:02:21 +00:00
static unsigned int last = 0 ;
2024-03-01 12:09:20 +00:00
const dc_event_progress_t * progress = ( dc_event_progress_t * ) data ;
const dc_event_devinfo_t * devinfo = ( dc_event_devinfo_t * ) data ;
const dc_event_clock_t * clock = ( dc_event_clock_t * ) data ;
const dc_event_vendor_t * vendor = ( dc_event_vendor_t * ) data ;
device_data_t * devdata = ( device_data_t * ) userdata ;
2011-09-12 17:37:54 +00:00
switch ( event ) {
2012-06-22 20:37:39 +00:00
case DC_EVENT_WAITING :
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Event: waiting for user action " ) ) ;
2011-09-12 17:37:54 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_EVENT_PROGRESS :
2021-10-27 23:02:21 +00:00
/* this seems really dumb... but having no idea what is happening on long
* downloads makes people think that the app is hung ;
* since the progress is in bytes downloaded ( usually ) , simply give updates in 10 k increments
*/
if ( progress - > current < last )
/* this is a new communication with the divecomputer */
last = progress - > current ;
if ( progress - > current > last + 10240 ) {
last = progress - > current ;
dev_info ( NULL , translate ( " gettextFromC " , " read %dkb " ) , progress - > current / 1024 ) ;
}
if ( progress - > maximum )
progress_bar_fraction = ( double ) progress - > current / ( double ) progress - > maximum ;
2011-09-12 17:37:54 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_EVENT_DEVINFO :
2017-07-08 05:19:23 +00:00
if ( dc_descriptor_get_model ( devdata - > descriptor ) ! = devinfo - > model ) {
dc_descriptor_t * better_descriptor = get_descriptor ( dc_descriptor_get_type ( devdata - > descriptor ) , devinfo - > model ) ;
if ( better_descriptor ! = NULL ) {
2024-03-24 20:03:08 +00:00
report_info ( " EVENT_DEVINFO gave us a different detected product (model %d instead of %d), which we are using now. " ,
2019-01-21 21:31:06 +00:00
devinfo - > model , dc_descriptor_get_model ( devdata - > descriptor ) ) ;
2017-07-08 05:19:23 +00:00
devdata - > descriptor = better_descriptor ;
devdata - > product = dc_descriptor_get_product ( better_descriptor ) ;
devdata - > vendor = dc_descriptor_get_vendor ( better_descriptor ) ;
2024-05-02 19:26:22 +00:00
devdata - > model = devdata - > vendor + " " + devdata - > product ;
2019-01-21 21:31:06 +00:00
} else {
2024-03-24 20:03:08 +00:00
report_info ( " EVENT_DEVINFO gave us a different detected product (model %d instead of %d), but that one is unknown. " ,
2019-01-21 21:31:06 +00:00
devinfo - > model , dc_descriptor_get_model ( devdata - > descriptor ) ) ;
2017-07-08 05:19:23 +00:00
}
}
2017-07-09 22:52:10 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " model=%s firmware=%u serial=%u " ) ,
2024-05-02 19:26:22 +00:00
devdata - > product . c_str ( ) , devinfo - > firmware , devinfo - > serial ) ;
2017-07-09 22:52:10 +00:00
if ( devdata - > libdc_logfile ) {
fprintf ( devdata - > libdc_logfile , " Event: model=%u (0x%08x), firmware=%u (0x%08x), serial=%u (0x%08x) \n " ,
devinfo - > model , devinfo - > model ,
devinfo - > firmware , devinfo - > firmware ,
devinfo - > serial , devinfo - > serial ) ;
}
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
devdata - > devinfo = * devinfo ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
lookup_fingerprint ( device , devdata ) ;
2011-09-12 17:37:54 +00:00
break ;
2012-06-22 20:37:39 +00:00
case DC_EVENT_CLOCK :
2014-02-28 04:09:57 +00:00
dev_info ( devdata , translate ( " gettextFromC " , " Event: systime=% " PRId64 " , devtime=%u \n " ) ,
( uint64_t ) clock - > systime , clock - > devtime ) ;
2014-01-07 19:38:36 +00:00
if ( devdata - > libdc_logfile ) {
2014-02-28 04:09:57 +00:00
fprintf ( devdata - > libdc_logfile , " Event: systime=% " PRId64 " , devtime=%u \n " ,
2014-01-07 19:38:36 +00:00
( uint64_t ) clock - > systime , clock - > devtime ) ;
}
break ;
case DC_EVENT_VENDOR :
if ( devdata - > libdc_logfile ) {
fprintf ( devdata - > libdc_logfile , " Event: vendor= " ) ;
for ( unsigned int i = 0 ; i < vendor - > size ; + + i )
fprintf ( devdata - > libdc_logfile , " %02X " , vendor - > data [ i ] ) ;
2014-02-28 04:09:57 +00:00
fprintf ( devdata - > libdc_logfile , " \n " ) ;
2014-01-07 19:38:36 +00:00
}
2011-09-12 17:37:54 +00:00
break ;
default :
break ;
}
2011-09-12 16:50:40 +00:00
}
2014-02-28 04:09:57 +00:00
int import_thread_cancelled ;
2011-09-16 05:58:02 +00:00
2024-03-01 12:09:20 +00:00
static int cancel_cb ( void * )
2011-09-12 16:50:40 +00:00
{
2011-09-16 05:58:02 +00:00
return import_thread_cancelled ;
2011-09-12 16:50:40 +00:00
}
2024-04-29 05:02:54 +00:00
static std : : string do_device_import ( device_data_t * data )
2011-09-12 16:19:21 +00:00
{
2012-06-22 20:37:39 +00:00
dc_status_t rc ;
2012-08-27 22:06:58 +00:00
dc_device_t * device = data - > device ;
2011-09-12 16:50:40 +00:00
2024-05-02 19:26:22 +00:00
data - > model = data - > vendor + " " + data - > product ;
Assemble the actual Suunto serial number
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>
2013-01-10 00:14:21 +00:00
2011-09-12 16:50:40 +00:00
// Register the event handler.
2014-01-07 19:38:36 +00:00
int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK | DC_EVENT_VENDOR ;
2012-06-22 20:37:39 +00:00
rc = dc_device_set_events ( device , events , event_cb , data ) ;
2024-04-28 11:39:39 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
dev_info ( data , " Import error: %s " , errmsg ( rc ) ) ;
2014-02-28 04:09:57 +00:00
return translate ( " gettextFromC " , " Error registering the event handler. " ) ;
2024-04-28 11:39:39 +00:00
}
2011-09-12 16:50:40 +00:00
// Register the cancellation handler.
2012-06-22 20:37:39 +00:00
rc = dc_device_set_cancel ( device , cancel_cb , data ) ;
2024-04-28 11:39:39 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
dev_info ( data , " Import error: %s " , errmsg ( rc ) ) ;
2014-02-28 04:09:57 +00:00
return translate ( " gettextFromC " , " Error registering the cancellation handler. " ) ;
2024-04-28 11:39:39 +00:00
}
2011-09-12 16:50:40 +00:00
2013-12-25 00:26:00 +00:00
if ( data - > libdc_dump ) {
2014-02-28 04:09:57 +00:00
dc_buffer_t * buffer = dc_buffer_new ( 0 ) ;
2013-12-23 20:09:33 +00:00
2014-02-28 04:09:57 +00:00
rc = dc_device_dump ( device , buffer ) ;
2024-03-16 09:29:05 +00:00
if ( rc = = DC_STATUS_SUCCESS & & ! dumpfile_name . empty ( ) ) {
FILE * fp = subsurface_fopen ( dumpfile_name . c_str ( ) , " wb " ) ;
2013-12-23 20:09:33 +00:00
if ( fp ! = NULL ) {
2014-02-28 04:09:57 +00:00
fwrite ( dc_buffer_get_data ( buffer ) , 1 , dc_buffer_get_size ( buffer ) , fp ) ;
fclose ( fp ) ;
2013-12-23 20:09:33 +00:00
}
}
2014-02-28 04:09:57 +00:00
dc_buffer_free ( buffer ) ;
2023-06-14 00:48:56 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
progress_bar_fraction = 0.0 ;
if ( rc = = DC_STATUS_UNSUPPORTED )
return translate ( " gettextFromC " , " Dumping not supported on this device " ) ;
2024-04-28 11:39:39 +00:00
dev_info ( data , " Import error: %s " , errmsg ( rc ) ) ;
2023-06-14 00:48:56 +00:00
return translate ( " gettextFromC " , " Dive data dumping error " ) ;
}
2013-12-23 20:09:33 +00:00
} else {
rc = dc_device_foreach ( device , dive_cb , data ) ;
2023-06-14 00:48:56 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
progress_bar_fraction = 0.0 ;
2024-04-28 11:39:39 +00:00
dev_info ( data , " Import error: %s " , errmsg ( rc ) ) ;
2023-06-14 00:48:56 +00:00
return translate ( " gettextFromC " , " Dive data import error " ) ;
}
2014-02-26 13:34:16 +00:00
}
2011-09-12 17:27:35 +00:00
2012-08-27 22:06:58 +00:00
/* All good */
2024-04-29 05:02:54 +00:00
return std : : string ( ) ;
2011-09-16 05:58:02 +00:00
}
2024-03-01 12:09:20 +00:00
void logfunc ( dc_context_t * , dc_loglevel_t loglevel , const char * file , unsigned int line , const char * function , const char * msg , void * userdata )
2013-12-23 20:07:13 +00:00
{
2014-02-28 04:09:57 +00:00
const char * loglevels [ ] = { " NONE " , " ERROR " , " WARNING " , " INFO " , " DEBUG " , " ALL " } ;
2013-12-23 20:07:13 +00:00
2024-05-01 21:35:21 +00:00
static const auto start ( std : : chrono : : steady_clock : : now ( ) ) ;
auto now ( std : : chrono : : steady_clock : : now ( ) ) ;
double elapsed_seconds = std : : chrono : : duration < double > ( now - start ) . count ( ) ;
2020-03-10 21:58:24 +00:00
2014-02-28 04:09:57 +00:00
FILE * fp = ( FILE * ) userdata ;
2013-12-23 20:07:13 +00:00
if ( loglevel = = DC_LOGLEVEL_ERROR | | loglevel = = DC_LOGLEVEL_WARNING ) {
2024-05-01 21:35:21 +00:00
fprintf ( fp , " [%.6f] %s: %s [in %s:%d (%s)] \n " ,
elapsed_seconds ,
2020-03-10 21:58:24 +00:00
loglevels [ loglevel ] , msg , file , line , function ) ;
2013-12-23 20:07:13 +00:00
} else {
2024-05-01 21:35:21 +00:00
fprintf ( fp , " [%6f] %s: %s \n " , elapsed_seconds , loglevels [ loglevel ] , msg ) ;
2013-12-23 20:07:13 +00:00
}
}
2018-04-25 19:34:46 +00:00
/*
* Get the transports supported by us ( as opposed to
* the list of transports supported by a particular
* dive computer ) .
*
* This could have various platform rules too . .
*/
2018-04-25 22:51:35 +00:00
unsigned int get_supported_transports ( device_data_t * data )
2018-04-25 19:34:46 +00:00
{
2018-05-12 04:32:04 +00:00
# if defined(Q_OS_IOS)
// BLE only - don't bother with being clever.
return DC_TRANSPORT_BLE ;
# endif
2018-04-25 22:51:35 +00:00
// start out with the list of transports that libdivecomputer claims to support
// dc_context_get_transports ignores its context argument...
unsigned int supported = dc_context_get_transports ( NULL ) ;
2018-04-25 19:34:46 +00:00
2018-04-25 22:51:35 +00:00
// then add the ones that we have our own implementations for
# if defined(BT_SUPPORT)
supported | = DC_TRANSPORT_BLUETOOTH ;
# endif
# if defined(BLE_SUPPORT)
supported | = DC_TRANSPORT_BLE ;
# endif
2020-03-09 17:38:23 +00:00
# if defined(Q_OS_ANDROID)
// we cannot support transports that need libusb, hid, filesystem access, or IRDA on Android
supported & = ~ ( DC_TRANSPORT_USB | DC_TRANSPORT_USBHID | DC_TRANSPORT_IRDA | DC_TRANSPORT_USBSTORAGE ) ;
# endif
2018-04-25 22:51:35 +00:00
if ( data ) {
/*
* If we have device data available , we can refine this :
* We don ' t support BT or BLE unless bluetooth_mode was set ,
* and if it was we won ' t try any of the other transports .
*/
if ( data - > bluetooth_mode ) {
supported & = ( DC_TRANSPORT_BLUETOOTH | DC_TRANSPORT_BLE ) ;
2024-05-02 19:26:22 +00:00
if ( starts_with ( data - > devname , " LE: " ) )
2018-04-25 22:51:35 +00:00
supported & = DC_TRANSPORT_BLE ;
} else {
supported & = ~ ( DC_TRANSPORT_BLUETOOTH | DC_TRANSPORT_BLE ) ;
}
2018-04-25 19:34:46 +00:00
}
return supported ;
}
2020-08-20 20:05:53 +00:00
static dc_status_t usbhid_device_open ( dc_iostream_t * * iostream , dc_context_t * context , device_data_t * data )
{
dc_status_t rc ;
dc_iterator_t * iterator = NULL ;
dc_usbhid_device_t * device = NULL ;
// Discover the usbhid device.
dc_usbhid_iterator_new ( & iterator , context , data - > descriptor ) ;
while ( dc_iterator_next ( iterator , & device ) = = DC_STATUS_SUCCESS )
break ;
dc_iterator_free ( iterator ) ;
2020-10-03 19:57:42 +00:00
if ( ! device ) {
2024-05-14 23:38:00 +00:00
ERROR ( " didn't find HID device " ) ;
2020-08-20 20:05:53 +00:00
return DC_STATUS_NODEVICE ;
2020-10-03 19:57:42 +00:00
}
2020-08-20 20:05:53 +00:00
dev_info ( data , " Opening USB HID device for %04x:%04x " ,
dc_usbhid_device_get_vid ( device ) ,
dc_usbhid_device_get_pid ( device ) ) ;
rc = dc_usbhid_open ( iostream , context , device ) ;
dc_usbhid_device_free ( device ) ;
return rc ;
}
static dc_status_t usb_device_open ( dc_iostream_t * * iostream , dc_context_t * context , device_data_t * data )
{
dc_status_t rc ;
dc_iterator_t * iterator = NULL ;
dc_usb_device_t * device = NULL ;
// Discover the usb device.
dc_usb_iterator_new ( & iterator , context , data - > descriptor ) ;
while ( dc_iterator_next ( iterator , & device ) = = DC_STATUS_SUCCESS )
break ;
dc_iterator_free ( iterator ) ;
if ( ! device )
return DC_STATUS_NODEVICE ;
dev_info ( data , " Opening USB device for %04x:%04x " ,
dc_usb_device_get_vid ( device ) ,
dc_usb_device_get_pid ( device ) ) ;
rc = dc_usb_open ( iostream , context , device ) ;
dc_usb_device_free ( device ) ;
return rc ;
}
static dc_status_t irda_device_open ( dc_iostream_t * * iostream , dc_context_t * context , device_data_t * data )
{
unsigned int address = 0 ;
dc_iterator_t * iterator = NULL ;
dc_irda_device_t * device = NULL ;
// Try to find the IRDA address
dc_irda_iterator_new ( & iterator , context , data - > descriptor ) ;
while ( dc_iterator_next ( iterator , & device ) = = DC_STATUS_SUCCESS ) {
address = dc_irda_device_get_address ( device ) ;
dc_irda_device_free ( device ) ;
break ;
}
dc_iterator_free ( iterator ) ;
// If that fails, use the device name. This will
// use address 0 if it's not a number.
if ( ! address )
2024-05-02 19:26:22 +00:00
std : : from_chars ( data - > devname . c_str ( ) , data - > devname . c_str ( ) + data - > devname . size ( ) , address ) ;
2020-08-20 20:05:53 +00:00
dev_info ( data , " Opening IRDA address %u " , address ) ;
return dc_irda_open ( & data - > iostream , context , address , 1 ) ;
}
2020-10-26 14:54:57 +00:00
# if defined(BT_SUPPORT) && !defined(__ANDROID__) && !defined(__APPLE__)
static dc_status_t bluetooth_device_open ( dc_context_t * context , device_data_t * data )
2020-09-19 21:16:08 +00:00
{
dc_bluetooth_address_t address = 0 ;
dc_iterator_t * iterator = NULL ;
dc_bluetooth_device_t * device = NULL ;
// Try to find the rfcomm device address
dc_bluetooth_iterator_new ( & iterator , context , data - > descriptor ) ;
while ( dc_iterator_next ( iterator , & device ) = = DC_STATUS_SUCCESS ) {
address = dc_bluetooth_device_get_address ( device ) ;
dc_bluetooth_device_free ( device ) ;
break ;
}
dc_iterator_free ( iterator ) ;
if ( ! address ) {
2024-04-28 11:39:39 +00:00
dev_info ( data , " No rfcomm device found " ) ;
2020-09-19 21:16:08 +00:00
return DC_STATUS_NODEVICE ;
}
2020-10-17 00:01:02 +00:00
dev_info ( data , " Opening rfcomm address %llu " , address ) ;
2020-09-19 21:16:08 +00:00
return dc_bluetooth_open ( & data - > iostream , context , address , 0 ) ;
}
2020-10-26 14:54:57 +00:00
# endif
2020-09-19 21:16:08 +00:00
2018-04-17 22:57:04 +00:00
dc_status_t divecomputer_device_open ( device_data_t * data )
{
2023-11-03 16:15:58 +00:00
dc_status_t rc = DC_STATUS_UNSUPPORTED ;
2018-04-17 22:57:04 +00:00
dc_context_t * context = data - > context ;
2018-04-25 19:34:46 +00:00
unsigned int transports , supported ;
2020-08-20 20:05:53 +00:00
transports = dc_descriptor_get_transports ( data - > descriptor ) ;
2018-04-25 19:34:46 +00:00
supported = get_supported_transports ( data ) ;
2018-04-17 22:57:04 +00:00
2018-04-25 19:34:46 +00:00
transports & = supported ;
if ( ! transports ) {
2024-04-28 11:39:39 +00:00
dev_info ( data , " Dive computer transport not supported " ) ;
2018-04-25 19:34:46 +00:00
return DC_STATUS_UNSUPPORTED ;
}
# ifdef BT_SUPPORT
if ( transports & DC_TRANSPORT_BLUETOOTH ) {
2024-05-02 19:26:22 +00:00
dev_info ( data , " Opening rfcomm stream %s " , data - > devname . c_str ( ) ) ;
2020-09-19 21:58:26 +00:00
# if defined(__ANDROID__) || defined(__APPLE__)
// we don't have BT on iOS in the first place, so this is for Android and macOS
2024-05-02 19:26:22 +00:00
rc = rfcomm_stream_open ( & data - > iostream , context , data - > devname . c_str ( ) ) ;
2020-09-19 21:58:26 +00:00
# else
2020-10-26 14:54:57 +00:00
rc = bluetooth_device_open ( context , data ) ;
2020-09-19 21:58:26 +00:00
# endif
2018-04-17 22:57:04 +00:00
if ( rc = = DC_STATUS_SUCCESS )
return rc ;
}
# endif
2018-04-25 19:34:46 +00:00
# ifdef BLE_SUPPORT
if ( transports & DC_TRANSPORT_BLE ) {
2024-05-02 19:26:22 +00:00
dev_info ( data , " Connecting to BLE device %s " , data - > devname . c_str ( ) ) ;
rc = ble_packet_open ( & data - > iostream , context , data - > devname . c_str ( ) , data ) ;
2018-04-17 22:57:04 +00:00
if ( rc = = DC_STATUS_SUCCESS )
return rc ;
}
# endif
if ( transports & DC_TRANSPORT_USBHID ) {
2020-08-20 20:05:53 +00:00
dev_info ( data , " Connecting to USB HID device " ) ;
rc = usbhid_device_open ( & data - > iostream , context , data ) ;
if ( rc = = DC_STATUS_SUCCESS )
return rc ;
2018-04-17 22:57:04 +00:00
}
2019-09-11 15:23:29 +00:00
if ( transports & DC_TRANSPORT_USB ) {
2020-08-20 20:05:53 +00:00
dev_info ( data , " Connecting to native USB device " ) ;
rc = usb_device_open ( & data - > iostream , context , data ) ;
if ( rc = = DC_STATUS_SUCCESS )
return rc ;
2019-09-11 15:23:29 +00:00
}
2018-04-17 22:57:04 +00:00
if ( transports & DC_TRANSPORT_SERIAL ) {
2024-05-02 19:26:22 +00:00
dev_info ( data , " Opening serial device %s " , data - > devname . c_str ( ) ) ;
2018-04-17 22:57:04 +00:00
# ifdef SERIAL_FTDI
2024-05-02 19:26:22 +00:00
if ( ! strcasecmp ( data - > devname . c_str ( ) , " ftdi " ) )
2018-09-16 11:55:37 +00:00
return ftdi_open ( & data - > iostream , context ) ;
2020-03-05 21:38:33 +00:00
# endif
# ifdef __ANDROID__
2020-03-15 01:11:46 +00:00
if ( data - > androidUsbDeviceDescriptor )
return serial_usb_android_open ( & data - > iostream , context , data - > androidUsbDeviceDescriptor ) ;
2018-04-17 22:57:04 +00:00
# endif
2024-05-02 19:26:22 +00:00
rc = dc_serial_open ( & data - > iostream , context , data - > devname . c_str ( ) ) ;
2018-06-21 07:01:10 +00:00
if ( rc = = DC_STATUS_SUCCESS )
return rc ;
2018-04-17 22:57:04 +00:00
}
if ( transports & DC_TRANSPORT_IRDA ) {
2020-08-20 20:05:53 +00:00
dev_info ( data , " Connecting to IRDA device " ) ;
rc = irda_device_open ( & data - > iostream , context , data ) ;
2018-04-17 22:57:04 +00:00
if ( rc = = DC_STATUS_SUCCESS )
return rc ;
}
2018-08-27 18:19:30 +00:00
if ( transports & DC_TRANSPORT_USBSTORAGE ) {
2024-05-02 19:26:22 +00:00
dev_info ( data , " Opening USB storage at %s " , data - > devname . c_str ( ) ) ;
rc = dc_usb_storage_open ( & data - > iostream , context , data - > devname . c_str ( ) ) ;
2018-08-27 18:19:30 +00:00
if ( rc = = DC_STATUS_SUCCESS )
return rc ;
}
2023-11-03 16:15:58 +00:00
return rc ;
2018-04-17 22:57:04 +00:00
}
2023-04-02 06:28:33 +00:00
static dc_status_t sync_divecomputer_time ( dc_device_t * device )
{
dc_datetime_t now ;
dc_datetime_localtime ( & now , dc_datetime_now ( ) ) ;
return dc_device_timesync ( device , & now ) ;
}
2024-04-29 05:02:54 +00:00
std : : string do_libdivecomputer_import ( device_data_t * data )
2012-08-27 22:06:58 +00:00
{
dc_status_t rc ;
2013-12-23 20:07:13 +00:00
FILE * fp = NULL ;
2012-08-27 22:06:58 +00:00
import_dive_number = 0 ;
2013-01-23 02:15:07 +00:00
first_temp_is_air = 0 ;
2012-08-27 22:06:58 +00:00
data - > device = NULL ;
data - > context = NULL ;
2018-04-17 01:14:59 +00:00
data - > iostream = NULL ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
data - > fingerprint = NULL ;
data - > fsize = 0 ;
2012-08-27 22:06:58 +00:00
2024-03-16 09:29:05 +00:00
if ( data - > libdc_log & & ! logfile_name . empty ( ) )
fp = subsurface_fopen ( logfile_name . c_str ( ) , " w " ) ;
2013-12-23 20:07:13 +00:00
2014-01-07 19:38:36 +00:00
data - > libdc_logfile = fp ;
2012-08-27 22:06:58 +00:00
rc = dc_context_new ( & data - > context ) ;
if ( rc ! = DC_STATUS_SUCCESS )
2014-02-28 04:09:57 +00:00
return translate ( " gettextFromC " , " Unable to create libdivecomputer context " ) ;
2012-08-27 22:06:58 +00:00
2013-12-23 20:07:13 +00:00
if ( fp ) {
dc_context_set_loglevel ( data - > context , DC_LOGLEVEL_ALL ) ;
dc_context_set_logfunc ( data - > context , logfunc , fp ) ;
2017-09-28 03:00:58 +00:00
fprintf ( data - > libdc_logfile , " Subsurface: v%s, " , subsurface_git_version ( ) ) ;
fprintf ( data - > libdc_logfile , " built with libdivecomputer v%s \n " , dc_version ( NULL ) ) ;
2013-12-23 20:07:13 +00:00
}
2024-04-29 05:02:54 +00:00
std : : string err = translate ( " gettextFromC " , " Unable to open %s %s (%s) " ) ;
2015-07-06 14:07:34 +00:00
2018-04-17 22:57:04 +00:00
rc = divecomputer_device_open ( data ) ;
2015-08-20 22:19:45 +00:00
2015-09-09 16:39:12 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-04-28 11:39:39 +00:00
dev_info ( data , " Import error: %s " , errmsg ( rc ) ) ;
2015-07-06 14:07:34 +00:00
} else {
2019-09-11 15:23:29 +00:00
dev_info ( data , " Connecting ... " ) ;
2018-04-17 01:14:59 +00:00
rc = dc_device_open ( & data - > device , data - > context , data - > descriptor , data - > iostream ) ;
2024-04-19 03:31:34 +00:00
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-05-14 23:38:00 +00:00
INFO ( " dc_device_open error value of %d " , rc ) ;
2024-05-02 19:26:22 +00:00
if ( subsurface_access ( data - > devname . c_str ( ) , R_OK | W_OK ) ! = 0 )
2018-06-21 06:49:20 +00:00
# if defined(SUBSURFACE_MOBILE)
2024-04-19 03:31:34 +00:00
err = translate ( " gettextFromC " , " Error opening the device %s %s (%s). \n In most cases, in order to debug this issue, it is useful to send the developers the log files. You can copy them to the clipboard in the About dialog. " ) ;
2018-06-21 06:49:20 +00:00
# else
2024-04-19 03:31:34 +00:00
err = translate ( " gettextFromC " , " Error opening the device %s %s (%s). \n In most cases, in order to debug this issue, a libdivecomputer logfile will be useful. \n You can create this logfile by selecting the corresponding checkbox in the download dialog. " ) ;
2018-06-21 06:49:20 +00:00
# endif
2024-04-19 03:31:34 +00:00
} else {
2019-09-11 15:23:29 +00:00
dev_info ( data , " Starting import ... " ) ;
Fix error handling for libdivecomputer import
The error handling was incorrect for the case where we successfully
opened the libdivecomputer iostream in divecomputer_device_open(), but
the dc_device_open() call failed.
When the dc_device_open() failed, we would (correctly) not do the
dc_device_close() but we would _also_ not do the dc_iostream_close() to
close the underlying file descriptor, which is wrong.
Normally this isn't all that noticeable, partly because the common case
is that dc_device_open() succeeds if you actually do have a dive
computer connected, but also because most of the time it just leaked a
file descriptor or something like that.
However, particularly for the POSIX serial device case, libdivecomputer
does a
ioctl(device->fd, TIOCEXCL, NULL)
call to make serial opens exclusive. This is what we want - but if we
then fail at closing the serial file descriptor, we won't be able to
retry the import at all because now the next open will fail with EBUSY.
So the error handling was incorrect, and while it doesn't usually matter
all that much, it can be quite noticeable particularly when you have
transient errors.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-10-06 17:17:06 +00:00
err = do_device_import ( data ) ;
/* TODO: Show the logfile to the user on error. */
2023-04-02 06:28:33 +00:00
dev_info ( data , " Import complete " ) ;
2024-04-29 05:02:54 +00:00
if ( err . empty ( ) & & data - > sync_time ) {
2023-04-02 06:28:33 +00:00
dev_info ( data , " Syncing dive computer time ... " ) ;
rc = sync_divecomputer_time ( data - > device ) ;
switch ( rc ) {
case DC_STATUS_SUCCESS :
dev_info ( data , " Time sync complete " ) ;
break ;
case DC_STATUS_UNSUPPORTED :
dev_info ( data , " Time sync not supported by dive computer " ) ;
break ;
default :
dev_info ( data , " Time sync failed " ) ;
break ;
}
}
Fix error handling for libdivecomputer import
The error handling was incorrect for the case where we successfully
opened the libdivecomputer iostream in divecomputer_device_open(), but
the dc_device_open() call failed.
When the dc_device_open() failed, we would (correctly) not do the
dc_device_close() but we would _also_ not do the dc_iostream_close() to
close the underlying file descriptor, which is wrong.
Normally this isn't all that noticeable, partly because the common case
is that dc_device_open() succeeds if you actually do have a dive
computer connected, but also because most of the time it just leaked a
file descriptor or something like that.
However, particularly for the POSIX serial device case, libdivecomputer
does a
ioctl(device->fd, TIOCEXCL, NULL)
call to make serial opens exclusive. This is what we want - but if we
then fail at closing the serial file descriptor, we won't be able to
retry the import at all because now the next open will fail with EBUSY.
So the error handling was incorrect, and while it doesn't usually matter
all that much, it can be quite noticeable particularly when you have
transient errors.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-10-06 17:17:06 +00:00
dc_device_close ( data - > device ) ;
data - > device = NULL ;
2022-11-12 11:44:29 +00:00
if ( ! data - > log - > dives - > nr )
Fix error handling for libdivecomputer import
The error handling was incorrect for the case where we successfully
opened the libdivecomputer iostream in divecomputer_device_open(), but
the dc_device_open() call failed.
When the dc_device_open() failed, we would (correctly) not do the
dc_device_close() but we would _also_ not do the dc_iostream_close() to
close the underlying file descriptor, which is wrong.
Normally this isn't all that noticeable, partly because the common case
is that dc_device_open() succeeds if you actually do have a dive
computer connected, but also because most of the time it just leaked a
file descriptor or something like that.
However, particularly for the POSIX serial device case, libdivecomputer
does a
ioctl(device->fd, TIOCEXCL, NULL)
call to make serial opens exclusive. This is what we want - but if we
then fail at closing the serial file descriptor, we won't be able to
retry the import at all because now the next open will fail with EBUSY.
So the error handling was incorrect, and while it doesn't usually matter
all that much, it can be quite noticeable particularly when you have
transient errors.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-10-06 17:17:06 +00:00
dev_info ( data , translate ( " gettextFromC " , " No new dives downloaded from dive computer " ) ) ;
}
2018-04-17 01:14:59 +00:00
dc_iostream_close ( data - > iostream ) ;
data - > iostream = NULL ;
2015-07-06 14:07:34 +00:00
}
2014-11-12 20:09:57 +00:00
2012-08-27 22:06:58 +00:00
dc_context_free ( data - > context ) ;
2014-12-29 23:25:57 +00:00
data - > context = NULL ;
2013-12-23 20:07:13 +00:00
if ( fp ) {
fclose ( fp ) ;
}
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
/*
* Note that we save the fingerprint unconditionally .
* This is ok because we only have fingerprint data if
* we got a dive header , and because we will use the
* dive id to verify that we actually have the dive
* it refers to before we use the fingerprint data .
2021-10-30 18:02:24 +00:00
*
* For now we save the fingerprint both to the local file system
* and to the global fingerprint table ( to be then saved out with
* the dive log data ) .
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
*/
save_fingerprint ( data ) ;
2021-10-30 18:02:24 +00:00
if ( data - > fingerprint & & data - > fdiveid )
2024-05-02 19:26:22 +00:00
create_fingerprint_node ( & fingerprint_table , calculate_string_hash ( data - > model . c_str ( ) ) , data - > devinfo . serial ,
2021-10-30 18:02:24 +00:00
data - > fingerprint , data - > fsize , data - > fdeviceid , data - > fdiveid ) ;
Re-do the libdivecomputer fingerprint save/load code
This tries to make our fingerprinting code work better, by avoiding
using the "deviceid" field that has always been unreliable because we've
calculated it multiple different ways, and even for the same version of
subsurface, it ends up changing in the middle (ie we calculate one value
initially, then re-calculate it when we have a proper serial number
string).
So instead, the fingerprinting code will look up and save the
fingerprint file using purely "stable" information that is available
early during the download:
- the device model name (which is a string with vendor and product name
separated by a space)
- the DC_EVENT_DEVINFO 32-bit 'serial' number (which is not necessarily
a real serial number at all, but hopefully at least a unique number
for the particular product)
but because the model name is not necessarily a good filename (think
slashes and other possibly invalid characters), we hash that model name
and use the resulting hex number in the fingerprint file name.
This way the fingerprint file is unambiguous at load and save time, and
depends purely on libdivecomputer data.
But because we also need to verify that we have the actual _dive_
associated with that fingerprint, we also need to save the final
deviceid and diveid when saving the fingerprint file, so that when we
load it again we can look up the dive and verify that we have it before
we use the fingerprint data.
To do that, the fingerprint file itself contains not just the
fingerprint data from libdivecomputer, but the last 8 bytes of the file
are the (subsurface) deviceid and the diveid of the dive that is
associated with the fingerprint.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2021-09-19 01:52:50 +00:00
free ( data - > fingerprint ) ;
data - > fingerprint = NULL ;
use libdivecomputer 'fingerprint' to avoid downloading extra data
This opportunistically uses a cache of 'fingerprints' for already
downloaded dives.
As we download data from a dive computer, we save the fingerprint and
dive ID of the most recent dive in a per-divecopmputer fingerprint cache
file.
The next time we download from that dive computer, we will load the
cache file for that dive computer if it exists, verify that we still
have the dive that is referenced in that cachefile, and if so use the
fingerprint to let libdivecomputer potentially stop downloading dives
early.
This doesn't much matter for most dive computers, but some (like the
Scubapro G2) are not able to download one dive at a time, and need the
fingerprint to avoid doing a full dump. That is particularly noticeable
over bluetooth, where a full dump can be very slow.
NOTE! The fingerprint cache is a separate entity from the dive log
itself. Unlike the dive log, it doesn't synchronize over the cloud, so
if you download using different clients (say, your phone and your
laptop), the fingerprint cache entries are per device.
So you may still end up downloading dives you already have, because the
fingerprint code basically only works to avoid duplicate downloads on
the same installation.
Also, note that we only have a cache of one single entry per dive
computer and downloader, so if you download dives and then don't save
the end result, the fingerprint will now point to a dive that you don't
actually have in your dive list. As a result, next time you download,
the fingerprint won't match any existing dive, and we'll resort to the
old non-optimized behavior.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-04-24 17:37:31 +00:00
2012-08-27 22:06:58 +00:00
return err ;
}
2015-04-03 22:51:38 +00:00
/*
* Parse data buffers instead of dc devices downloaded data .
* Intended to be used to parse profile data from binary files during import tasks .
* Actually included Uwatec families because of works on datatrak and smartrak logs
* and OSTC families for OSTCTools logs import .
* For others , simply include them in the switch ( check parameters ) .
* Note that dc_descriptor_t in data * must * have been filled using dc_descriptor_iterator ( )
* calls .
*/
dc_status_t libdc_buffer_parser ( struct dive * dive , device_data_t * data , unsigned char * buffer , int size )
{
dc_status_t rc ;
dc_parser_t * parser = NULL ;
2016-12-29 14:41:44 +00:00
switch ( dc_descriptor_get_type ( data - > descriptor ) ) {
2015-04-03 22:51:38 +00:00
case DC_FAMILY_UWATEC_ALADIN :
case DC_FAMILY_UWATEC_MEMOMOUSE :
case DC_FAMILY_UWATEC_SMART :
case DC_FAMILY_UWATEC_MERIDIAN :
case DC_FAMILY_HW_OSTC :
case DC_FAMILY_HW_FROG :
case DC_FAMILY_HW_OSTC3 :
2024-02-01 03:06:33 +00:00
rc = dc_parser_new2 ( & parser , data - > context , data - > descriptor , buffer , size ) ;
2015-04-03 22:51:38 +00:00
break ;
2015-04-29 21:47:56 +00:00
default :
report_error ( " Device type not handled! " ) ;
return DC_STATUS_UNSUPPORTED ;
2015-04-03 22:51:38 +00:00
}
if ( rc ! = DC_STATUS_SUCCESS ) {
report_error ( " Error creating parser. " ) ;
dc_parser_destroy ( parser ) ;
return rc ;
}
// Do not parse Aladin/Memomouse headers as they are fakes
// Do not return on error, we can still parse the samples
2016-12-29 14:41:44 +00:00
if ( dc_descriptor_get_type ( data - > descriptor ) ! = DC_FAMILY_UWATEC_ALADIN & & dc_descriptor_get_type ( data - > descriptor ) ! = DC_FAMILY_UWATEC_MEMOMOUSE ) {
2015-04-03 22:51:38 +00:00
rc = libdc_header_parser ( parser , data , dive ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-04-28 11:39:39 +00:00
report_error ( " Error parsing the dive header data. Dive # %d: %s " , dive - > number , errmsg ( rc ) ) ;
2015-04-03 22:51:38 +00:00
}
}
rc = dc_parser_samples_foreach ( parser , sample_cb , & dive - > dc ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-04-28 11:39:39 +00:00
report_error ( " Error parsing the sample data. Dive # %d: %s " , dive - > number , errmsg ( rc ) ) ;
2015-04-03 22:51:38 +00:00
dc_parser_destroy ( parser ) ;
return rc ;
}
dc_parser_destroy ( parser ) ;
2018-02-17 20:21:16 +00:00
return DC_STATUS_SUCCESS ;
2015-04-03 22:51:38 +00:00
}
2016-12-28 19:55:52 +00:00
/*
2016-12-28 19:55:53 +00:00
* Returns a dc_descriptor_t structure based on dc model ' s number and family .
*
* That dc_descriptor_t needs to be freed with dc_descriptor_free by the reciver .
2016-12-28 19:55:52 +00:00
*/
2016-12-28 19:55:53 +00:00
dc_descriptor_t * get_descriptor ( dc_family_t type , unsigned int model )
2016-12-28 19:55:52 +00:00
{
2016-12-28 19:55:53 +00:00
dc_descriptor_t * descriptor = NULL , * needle = NULL ;
2016-12-28 19:55:52 +00:00
dc_iterator_t * iterator = NULL ;
dc_status_t rc ;
rc = dc_descriptor_iterator ( & iterator ) ;
if ( rc ! = DC_STATUS_SUCCESS ) {
2024-04-28 11:39:39 +00:00
report_info ( " Error creating the device descriptor iterator: %s " , errmsg ( rc ) ) ;
2016-12-28 19:55:53 +00:00
return NULL ;
2016-12-28 19:55:52 +00:00
}
while ( ( dc_iterator_next ( iterator , & descriptor ) ) = = DC_STATUS_SUCCESS ) {
2016-12-28 19:55:53 +00:00
unsigned int desc_model = dc_descriptor_get_model ( descriptor ) ;
dc_family_t desc_type = dc_descriptor_get_type ( descriptor ) ;
if ( model = = desc_model & & type = = desc_type ) {
needle = descriptor ;
2016-12-28 19:55:52 +00:00
break ;
}
dc_descriptor_free ( descriptor ) ;
}
dc_iterator_free ( iterator ) ;
2016-12-28 19:55:53 +00:00
return needle ;
2016-12-28 19:55:52 +00:00
}