diff options
| -rw-r--r-- | dive.c | 24 | ||||
| -rw-r--r-- | dive.h | 3 | ||||
| -rw-r--r-- | save-git.c | 689 | ||||
| -rw-r--r-- | save-xml.c | 54 | ||||
| -rw-r--r-- | subsurface-configure.pri | 2 | ||||
| -rw-r--r-- | subsurface.pro | 1 |
6 files changed, 744 insertions, 29 deletions
@@ -224,6 +224,30 @@ void copy_events(struct dive *s, struct dive *d) } } +int nr_cylinders(struct dive *dive) +{ + int nr; + + for (nr = MAX_CYLINDERS; nr; --nr) { + cylinder_t *cylinder = dive->cylinder + nr - 1; + if (!cylinder_nodata(cylinder)) + break; + } + return nr; +} + +int nr_weightsystems(struct dive *dive) +{ + int nr; + + for (nr = MAX_WEIGHTSYSTEMS; nr; --nr) { + weightsystem_t *ws = dive->weightsystem + nr - 1; + if (!weightsystem_none(ws)) + break; + } + return nr; +} + void copy_cylinders(struct dive *s, struct dive *d) { int i; @@ -685,6 +685,7 @@ extern void save_dives(const char *filename); extern void save_dives_logic(const char *filename, bool select_only); extern void save_dive(FILE *f, struct dive *dive); extern void export_dives_uddf(const char *filename, const bool selected); +extern int git_save_dives(int fd, bool select_only); extern int subsurface_rename(const char *path, const char *newpath); extern int subsurface_open(const char *path, int oflags, mode_t mode); @@ -723,6 +724,8 @@ extern void add_gas_switch_event(struct dive *dive, struct divecomputer *dc, int extern void add_event(struct divecomputer *dc, int time, int type, int flags, int value, const char *name); extern void per_cylinder_mean_depth(struct dive *dive, struct divecomputer *dc, int *mean, int *duration); extern int get_cylinder_index(struct dive *dive, struct event *ev); +extern int nr_cylinders(struct dive *dive); +extern int nr_weightsystems(struct dive *dive); /* UI related protopypes */ diff --git a/save-git.c b/save-git.c new file mode 100644 index 000000000..6e0d989c0 --- /dev/null +++ b/save-git.c @@ -0,0 +1,689 @@ +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <time.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> +#include <fcntl.h> +#include <git2.h> + +#include "dive.h" +#include "device.h" +#include "membuffer.h" + +#define VA_BUF(b, fmt) do { va_list args; va_start(args, fmt); put_vformat(b, fmt, args); va_end(args); } while (0) + +static void cond_put_format(int cond, struct membuffer *b, const char *fmt, ...) +{ + if (cond) { + VA_BUF(b, fmt); + } +} + +#define SAVE(str, x) cond_put_format(dive->x, b, str " %d\n", dive->x) + +static void put_degrees(struct membuffer *b, degrees_t value, const char sep) +{ + int udeg = value.udeg; + const char *sign = ""; + + if (udeg < 0) { + udeg = -udeg; + sign = "-"; + } + put_format(b,"%s%u.%06u%c", sign, FRACTION(udeg, 1000000), sep); +} + +static void show_gps(struct membuffer *b, degrees_t latitude, degrees_t longitude) +{ + if (latitude.udeg || longitude.udeg) { + put_string(b, "gps "); + put_degrees(b, latitude, ' '); + put_degrees(b, longitude, '\n'); + } +} + +static void quote(struct membuffer *b, const char *text) +{ + const char *p = text; + + for (;;) { + const char *escape; + + switch (*p++) { + default: + continue; + case 0: + escape = NULL; + break; + case 1 ... 8: + case 11: + case 12: + case 14 ... 31: + escape = "?"; + break; + case '"': + escape = "\\\""; + break; + case '\n': + escape = "\n\t"; + if (*p == '\n') + escape = "\n"; + break; + } + put_bytes(b, text, (p - text - 1)); + if (!escape) + break; + put_string(b, escape); + text = p; + } +} + +static void show_utf8(struct membuffer *b, const char *prefix, const char *value, const char *postfix) +{ + if (value) { + put_format(b, "%s\"", prefix); + quote(b, value); + put_format(b, "\"%s", postfix); + } +} + +static void save_overview(struct membuffer *b, struct dive *dive) +{ + show_gps(b, dive->latitude, dive->longitude); + show_utf8(b, "location ", dive->location, "\n"); + show_utf8(b, "divemaster ", dive->divemaster, "\n"); + show_utf8(b, "buddy ", dive->buddy, "\n"); + show_utf8(b, "suit ", dive->suit, "\n"); + show_utf8(b, "notes ", dive->notes, "\n"); +} + +static void save_tags(struct membuffer *b, struct tag_entry *tags) +{ + const char *sep = " "; + + if (!tags) + return; + /* The first entry is a dummy, because people don't understand pointers to pointers */ + tags = tags->next; + if (!tags) + return; + put_string(b, "tags"); + while (tags) { + show_utf8(b, sep, tags->tag->source ? : tags->tag->name, ""); + sep = ", "; + tags = tags->next; + } + put_string(b, "\n"); +} + +static void save_cylinder_info(struct membuffer *b, struct dive *dive) +{ + int i, nr; + + nr = nr_cylinders(dive); + for (i = 0; i < nr; i++) { + cylinder_t *cylinder = dive->cylinder + i; + int volume = cylinder->type.size.mliter; + const char *description = cylinder->type.description; + int o2 = cylinder->gasmix.o2.permille; + int he = cylinder->gasmix.he.permille; + + put_string(b, "cylinder"); + if (volume) + put_milli(b, " vol=", volume, "l"); + put_pressure(b, cylinder->type.workingpressure, " workpressure=", "bar"); + show_utf8(b, " description=", description, ""); + strip_mb(b); + if (o2) { + put_format(b, " o2=%u.%u%%", FRACTION(o2, 10)); + if (he) + put_format(b, " he=%u.%u%%", FRACTION(he, 10)); + } + put_pressure(b, cylinder->start, " start=", "bar"); + put_pressure(b, cylinder->end, " end=", "bar"); + put_string(b, "\n"); + } +} + +static void save_weightsystem_info(struct membuffer *b, struct dive *dive) +{ + int i, nr; + + nr = nr_weightsystems(dive); + for (i = 0; i < nr; i++) { + weightsystem_t *ws = dive->weightsystem + i; + int grams = ws->weight.grams; + const char *description = ws->description; + + put_string(b, "weightsystem"); + put_milli(b, " weight=", grams, "kg"); + show_utf8(b, " description=", description, ""); + put_string(b, "\n"); + } +} + +static void save_dive_temperature(struct membuffer *b, struct dive *dive) +{ + if (!dive->airtemp.mkelvin && !dive->watertemp.mkelvin) + return; + if (dive->airtemp.mkelvin == dc_airtemp(&dive->dc) && dive->watertemp.mkelvin == dc_watertemp(&dive->dc)) + return; + + put_string(b, "divetemperature"); + if (dive->airtemp.mkelvin != dc_airtemp(&dive->dc)) + put_temperature(b, dive->airtemp, " air=", "°C"); + if (dive->watertemp.mkelvin != dc_watertemp(&dive->dc)) + put_temperature(b, dive->watertemp, " water=", "°C'"); + put_string(b, "\n"); +} + +static void save_depths(struct membuffer *b, struct divecomputer *dc) +{ + /* What's the point of this dive entry again? */ + if (!dc->maxdepth.mm && !dc->meandepth.mm) + return; + + put_string(b, " depth"); + put_depth(b, dc->maxdepth, " max=", "m"); + put_depth(b, dc->meandepth, " mean=", "m"); + put_string(b, "\n"); +} + +static void save_temperatures(struct membuffer *b, struct divecomputer *dc) +{ + if (!dc->airtemp.mkelvin && !dc->watertemp.mkelvin) + return; + put_string(b, " temperature"); + put_temperature(b, dc->airtemp, " air=", "°C"); + put_temperature(b, dc->watertemp, " water=", "°C"); + put_string(b, "\n"); +} + +static void save_airpressure(struct membuffer *b, struct divecomputer *dc) +{ + if (!dc->surface_pressure.mbar) + return; + put_string(b, " surface"); + put_pressure(b, dc->surface_pressure, " pressure=", "bar"); + put_string(b, "\n"); +} + +static void save_salinity(struct membuffer *b, struct divecomputer *dc) +{ + /* only save if we have a value that isn't the default of sea water */ + if (!dc->salinity || dc->salinity == SEAWATER_SALINITY) + return; + put_string(b, " water"); + put_salinity(b, dc->salinity, " salinity=", "g/l"); + put_string(b, "\n"); +} + +static void show_date(struct membuffer *b, timestamp_t when) +{ + struct tm tm; + + utc_mkdate(when, &tm); + + put_format(b, " date=%04u-%02u-%02u", + tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); + put_format(b, " time=%02u:%02u:%02u", + tm.tm_hour, tm.tm_min, tm.tm_sec); +} + +static void show_index(struct membuffer *b, int value, const char *pre, const char *post) +{ + if (value) + put_format(b, " %s%d%s", pre, value, post); +} + +/* + * Samples are saved as densely as possible while still being readable, + * since they are the bulk of the data. + * + * For parsing, look at the units to figure out what the numbers are. + */ +static void save_sample(struct membuffer *b, struct sample *sample, struct sample *old) +{ + put_format(b, " %3u:%02umin", FRACTION(sample->time.seconds, 60)); + put_milli(b, " ", sample->depth.mm, "m"); + put_temperature(b, sample->temperature, " ", "°C"); + put_pressure(b, sample->cylinderpressure, " ", "bar"); + + /* + * We only show sensor information for samples with pressure, and only if it + * changed from the previous sensor we showed. + */ + if (sample->cylinderpressure.mbar && sample->sensor != old->sensor) { + put_format(b, " sensor=%d", sample->sensor); + old->sensor = sample->sensor; + } + + /* the deco/ndl values are stored whenever they change */ + if (sample->ndl.seconds != old->ndl.seconds) { + put_format(b, " ndl=%u:%02umin", FRACTION(sample->ndl.seconds, 60)); + old->ndl = sample->ndl; + } + if (sample->in_deco != old->in_deco) { + put_format(b, " in_deco=%d", sample->in_deco ? 1 : 0); + old->in_deco = sample->in_deco; + } + if (sample->stoptime.seconds != old->stoptime.seconds) { + put_format(b, " stoptime=%u:%02umin", FRACTION(sample->stoptime.seconds, 60)); + old->stoptime = sample->stoptime; + } + + if (sample->stopdepth.mm != old->stopdepth.mm) { + put_milli(b, " stopdepth=", sample->stopdepth.mm, "m"); + old->stopdepth = sample->stopdepth; + } + + if (sample->cns != old->cns) { + put_format(b, " cns=%u%%", sample->cns); + old->cns = sample->cns; + } + + if (sample->po2 != old->po2) { + put_milli(b, " po2=", sample->po2, "bar"); + old->po2 = sample->po2; + } + show_index(b, sample->heartbeat, "heartbeat=", ""); + show_index(b, sample->bearing, "bearing=", "°"); + put_format(b, "\n"); +} + +static void save_samples(struct membuffer *b, int nr, struct sample *s) +{ + struct sample dummy = {}; + + while (--nr >= 0) { + save_sample(b, s, &dummy); + s++; + } +} + +static void save_one_event(struct membuffer *b, struct event *ev) +{ + put_format(b, " event %d:%02dmin", FRACTION(ev->time.seconds, 60)); + show_index(b, ev->type, "type=", ""); + show_index(b, ev->flags, "flags=", ""); + show_index(b, ev->value, "value=", ""); + show_utf8(b, ev->name, " name=", ""); + put_string(b, "\n"); +} + +static void save_events(struct membuffer *b, struct event *ev) +{ + while (ev) { + save_one_event(b, ev); + ev = ev->next; + } +} + +static void save_dc(struct membuffer *b, struct dive *dive, struct divecomputer *dc) +{ + put_format(b, "divecomputer"); + show_utf8(b, " model=", dc->model, ""); + if (dc->deviceid) + put_format(b, " deviceid=%08x", dc->deviceid); + if (dc->diveid) + put_format(b, " diveid=%08x", dc->diveid); + if (dc->when && dc->when != dive->when) + show_date(b, dc->when); + if (dc->duration.seconds && dc->duration.seconds != dive->dc.duration.seconds) + put_duration(b, dc->duration, " duration=", "min"); + put_string(b, "\n"); + + save_depths(b, dc); + save_temperatures(b, dc); + save_airpressure(b, dc); + save_salinity(b, dc); + put_duration(b, dc->surfacetime, " surfacetime", "min\n"); + + save_events(b, dc->events); + save_samples(b, dc->samples, dc->sample); +} + +/* + * Note that we don't save the date and time or dive + * number: they are encoded in the filename. + */ +static void create_dive_buffer(struct dive *dive, struct membuffer *b) +{ + struct divecomputer *dc; + + put_format(b, "duration %u:%02u min\n", FRACTION(dive->dc.duration.seconds, 60)); + SAVE("rating", rating); + SAVE("visibility", visibility); + cond_put_format(dive->tripflag == NO_TRIP, b, "notrip\n"); + save_tags(b, dive->tag_list); + + save_overview(b, dive); + save_cylinder_info(b, dive); + save_weightsystem_info(b, dive); + save_dive_temperature(b, dive); + + /* Save the dive computer data */ + dc = &dive->dc; + do { + save_dc(b, dive, dc); + dc = dc->next; + } while (dc); +} + +static int git_save_error(const char *fmt, ...) +{ + struct membuffer b = { 0 }; + VA_BUF(&b, fmt); + + /* We should do some UI element thing describing the failure */ + put_bytes(&b, "\n", 1); + flush_buffer(&b, stderr); + free_buffer(&b); + + return -1; +} + +/* + * libgit2 has a "git_treebuilder" concept, but it's broken, and can not + * be used to do a flat tree (like the git "index") nor a recursive tree. + * Stupid. + * + * So we have to do that "keep track of recursive treebuilder entries" + * ourselves. We use 'git_treebuilder' for any regular files, and our own + * data structures for recursive trees. + * + * When finally writing it out, we traverse the subdirectories depth- + * first, writing them out, and then adding the written-out trees to + * the git_treebuilder they existed in. + */ +struct dir { + git_treebuilder *files; + struct dir *subdirs, *sibling; + char name[1]; +}; + +/* + * The name of a dive is the date plus a hash of the contents. + */ +static void generate_name(struct dive *dive, git_oid *id, struct membuffer *name) +{ + struct tm tm; + + utc_mkdate(dive->when, &tm); + put_format(name, "%04u-%02u-%02u-%02u:%02u:%02u", + tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, + tm.tm_hour, tm.tm_min, tm.tm_sec); + cond_put_format(dive->number, name, "-%d", dive->number); + put_format(name, "-%02x%02x%02x%02x%c", + id->id[0], id->id[1], id->id[2], id->id[3], 0); +} + +static int save_one_dive(git_repository *repo, struct dir *tree, struct dive *dive) +{ + struct membuffer buf = { 0 }, name = { 0 }; + git_oid blob_id; + int ret; + + create_dive_buffer(dive, &buf); + ret = git_blob_create_frombuffer(&blob_id, repo, buf.buffer, buf.len); + free_buffer(&buf); + if (ret) + return git_save_error("git blob creation failed"); + + generate_name(dive, &blob_id, &name); + ret = git_treebuilder_insert(NULL, tree->files, name.buffer, &blob_id, 0100644); + free_buffer(&name); + if (ret) + return git_save_error("git tree insert failed"); + + return 0; +} + +/* + * This does *not* make sure the new subdirectory doesn't + * alias some existing name. Currently we always create + * unique subdirectory names ("tripXYZ"), but .. + */ +static struct dir *new_directory(struct dir *parent, const char *fmt, ...) +{ + struct membuffer name = { 0 }; + struct dir *subdir; + + VA_BUF(&name, fmt); + subdir = malloc(sizeof(*subdir)+name.len); + + /* + * It starts out empty: no subdirectories of its own, + * and an empty treebuilder list of files. + */ + subdir->subdirs = NULL; + git_treebuilder_create(&subdir->files, NULL); + memcpy(subdir->name, name.buffer, name.len); + subdir->name[name.len] = 0; + + /* Add it to the list of subdirs of the parent */ + subdir->sibling = parent->subdirs; + parent->subdirs = subdir; + + return subdir; +} + +static int save_one_trip(git_repository *repo, struct dir *tree, dive_trip_t *trip, int idx) +{ + int i; + struct dive *dive; + struct dir *subdir; + + subdir = new_directory(tree, "trip%03d", idx); + for_each_dive(i, dive) { + if (dive->divetrip == trip) + save_one_dive(repo, subdir, dive); + } + + return 0; +} + +#define TRIPNAME_SIZE (10) + +static int create_git_tree(git_repository *repo, struct dir *tree, bool select_only) +{ + int i, tripidx; + struct dive *dive; + dive_trip_t *trip; + + tripidx = 0; + for (trip = dive_trip_list; trip != NULL; trip = trip->next) + trip->index = 0; + + /* save the dives */ + for_each_dive(i, dive) { + trip = dive->divetrip; + + if (select_only) { + if (!dive->selected) + continue; + /* We don't save trips when doing selected dive saves */ + trip = NULL; + } + + if (trip) { + /* Did we already save this trip? */ + if (trip->index) + continue; + trip->index = ++tripidx; + + /* Pass that new subdirectory in for save-trip */ + save_one_trip(repo, tree, trip, tripidx); + continue; + } + + save_one_dive(repo, tree, dive); + } + return 0; +} + +/* + * libgit2 revision 0.19 and earlier do not have the signature and + * message log arguments. + */ +#if !LIBGIT2_VER_MAJOR && LIBGIT2_VER_MINOR <= 19 + #define git_branch_create(out,repo,branch_name,target,force,sig,msg) \ + git_branch_create(out,repo,branch_name,target,force) + #define git_reference_set_target(out,ref,target,signature,log_message) \ + git_reference_set_target(out,ref,target) +#endif + +static int create_new_commit(git_repository *repo, const char *branch, git_oid *tree_id) +{ + int ret; + git_reference *ref; + git_object *parent; + git_oid commit_id; + git_signature *author; + git_commit *commit; + git_tree *tree; + + ret = git_branch_lookup(&ref, repo, branch, GIT_BRANCH_LOCAL); + switch (ret) { + default: + return git_save_error("Bad branch '%s' (%s)", branch, strerror(errno)); + case GIT_EINVALIDSPEC: + return git_save_error("Invalid branch name '%s'", branch); + case GIT_ENOTFOUND: /* We'll happily create it */ + ref = NULL; parent = NULL; + break; + case 0: + if (git_reference_peel(&parent, ref, GIT_OBJ_COMMIT)) + return git_save_error("Unable to look up parent in branch '%s'", branch); + /* all good */ + break; + } + + if (git_tree_lookup(&tree, repo, tree_id)) + return git_save_error("Could not look up newly created tree"); + + /* git_signature_default() is too recent */ + if (git_signature_now(&author, "Subsurface", "subsurface@hohndel.org")) + return git_save_error("No user name configuration in git repo"); + + if (git_commit_create_v(&commit_id, repo, NULL, author, author, NULL, "subsurface commit", tree, parent != NULL, parent)) + return git_save_error("Git commit create failed (%s)", strerror(errno)); + + if (git_commit_lookup(&commit, repo, &commit_id)) + return git_save_error("Could not look up newly created commit"); + + if (!ref) { + if (git_branch_create(&ref, repo, branch, commit, 0, author, "Create branch")) + return git_save_error("Failed to create branch '%s'", branch); + } + if (git_reference_set_target(&ref, ref, &commit_id, author, "Subsurface save event")) + return git_save_error("Failed to update branch '%s'", branch); + + return 0; +} + +static int write_git_tree(git_repository *repo, struct dir *tree, git_oid *result) +{ + int ret; + struct dir *subdir; + + /* Write out our subdirectories, add them to the treebuilder, and free them */ + while ((subdir = tree->subdirs) != NULL) { + git_oid id; + + if (!write_git_tree(repo, subdir, &id)) + git_treebuilder_insert(NULL, tree->files, subdir->name, &id, 0040000); + tree->subdirs = subdir->sibling; + free(subdir); + }; + + /* .. write out the resulting treebuilder */ + ret = git_treebuilder_write(result, repo, tree->files); + + /* .. and free the now useless treebuilder */ + git_treebuilder_free(tree->files); + + return ret; +} + +static int do_git_save(git_repository *repo, const char *branch, bool select_only) +{ + struct dir tree; + git_oid id; + + /* Start with an empty tree: no subdirectories, no files */ + tree.name[0] = 0; + tree.subdirs = NULL; + if (git_treebuilder_create(&tree.files, NULL)) + return git_save_error("git treebuilder failed"); + + /* Populate our tree data structure */ + if (create_git_tree(repo, &tree, select_only)) + return -1; + + if (write_git_tree(repo, &tree, &id)) + return git_save_error("git tree write failed"); + + /* And save the tree! */ + create_new_commit(repo, branch, &id); + return 0; +} + +int git_save_dives(int fd, bool select_only) +{ + int len, ret; + struct stat st; + static char buffer[2048]; + git_repository *repo; + char *loc, *branch; + + if (fstat(fd, &st) < 0) + return 0; + if (st.st_size >= sizeof(buffer)) + return 0; + len = st.st_size; + if (read(fd, buffer, len) != len) + return 0; + buffer[len] = 0; + if (len < 4) + return 0; + if (memcmp(buffer, "git ", 4)) + return 0; + + /* Ok, it's a git pointer, we're going to follow it */ + close(fd); + + /* Trim any whitespace at the end */ + while (isspace(buffer[len-1])) + buffer[--len] = 0; + + /* skip the "git" part and any whitespace from the beginning */ + loc = buffer+3; + len -= 3; + while (isspace(*loc)) { + loc++; + len--; + } + + if (!len) + return git_save_error("Invalid git pointer"); + + /* + * The result should be a git directory and branch name, like + * "/home/torvalds/scuba:linus" + */ + branch = strrchr(loc, ':'); + if (branch) + *branch++ = 0; + + if (git_repository_open(&repo, loc)) + return git_save_error("Unable to open git repository at '%s' (branch '%s')", loc, branch); + + ret = do_git_save(repo, branch, select_only); + git_repository_free(repo); + return ret < 0 ? ret : 1; +} diff --git a/save-xml.c b/save-xml.c index 56de154fe..7801080e9 100644 --- a/save-xml.c +++ b/save-xml.c @@ -5,6 +5,7 @@ #include <errno.h> #include <time.h> #include <unistd.h> +#include <fcntl.h> #include "dive.h" #include "device.h" @@ -210,18 +211,6 @@ static void save_overview(struct membuffer *b, struct dive *dive) show_utf8(b, dive->suit, " <suit>", "</suit>\n", 0); } -static int nr_cylinders(struct dive *dive) -{ - int nr; - - for (nr = MAX_CYLINDERS; nr; --nr) { - cylinder_t *cylinder = dive->cylinder + nr - 1; - if (!cylinder_nodata(cylinder)) - break; - } - return nr; -} - static void save_cylinder_info(struct membuffer *b, struct dive *dive) { int i, nr; @@ -251,18 +240,6 @@ static void save_cylinder_info(struct membuffer *b, struct dive *dive) } } -static int nr_weightsystems(struct dive *dive) -{ - int nr; - - for (nr = MAX_WEIGHTSYSTEMS; nr; --nr) { - weightsystem_t *ws = dive->weightsystem + nr - 1; - if (!weightsystem_none(ws)) - break; - } - return nr; -} - static void save_weightsystem_info(struct membuffer *b, struct dive *dive) { int i, nr; @@ -609,15 +586,12 @@ static void save_backup(const char *name, const char *ext, const char *new_ext) free(newname); } -void save_dives_logic(const char *filename, const bool select_only) +static void try_to_backup(const char *filename) { - struct membuffer buf = { 0 }; - FILE *f; char extension[][5] = { "xml", "ssrf", "" }; int i = 0; int flen = strlen(filename); - save_dives_buffer(&buf, select_only); /* Maybe we might want to make this configurable? */ while (extension[i][0] != '\0') { int elen = strlen(extension[i]); @@ -627,6 +601,30 @@ void save_dives_logic(const char *filename, const bool select_only) } i++; } +} + +void save_dives_logic(const char *filename, const bool select_only) +{ + struct membuffer buf = { 0 }; + FILE *f; + int fd; + + /* + * See if the file already exists, and if so, + * perhaps it's a git save-file pointer? + * + * Otherwise, try to back it up. + */ + fd = subsurface_open(filename, O_RDONLY, 0); + if (fd >= 0) { + if (git_save_dives(fd, select_only)) + return; + close(fd); + try_to_backup(filename); + } + + save_dives_buffer(&buf, select_only); + f = subsurface_fopen(filename, "w"); if (f) { flush_buffer(&buf, f); diff --git a/subsurface-configure.pri b/subsurface-configure.pri index 8e6aeadb8..a211113b2 100644 --- a/subsurface-configure.pri +++ b/subsurface-configure.pri @@ -126,7 +126,7 @@ LIBS *= $$XSLT_LIBS $$XML2_LIBS # We're searching for: # libzip # sqlite3 -link_pkgconfig: PKGCONFIG += libzip sqlite3 +link_pkgconfig: PKGCONFIG += libzip sqlite3 libgit2 # Add libiconv if needed link_pkgconfig: packagesExist(libiconv): PKGCONFIG += libiconv diff --git a/subsurface.pro b/subsurface.pro index 81cb9061e..e664f6a75 100644 --- a/subsurface.pro +++ b/subsurface.pro @@ -115,6 +115,7 @@ SOURCES = \ qt-ui/subsurfacewebservices.cpp \ qt-ui/tableview.cpp \ qt-ui/exif.cpp \ + save-git.c \ save-xml.c \ sha1.c \ statistics.c \ |