static const char *do_device_import(device_data_t *data) { dc_status_t rc; dc_device_t *device = data->device; // Register the event handler. int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK; rc = dc_device_set_events(device, events, event_cb, data); if (rc != DC_STATUS_SUCCESS) return _("Error registering the event handler."); // Register the cancellation handler. rc = dc_device_set_cancel(device, cancel_cb, data); if (rc != DC_STATUS_SUCCESS) return _("Error registering the cancellation handler."); rc = import_device_data(device, data); if (rc != DC_STATUS_SUCCESS) return _("Dive data import error"); /* All good */ return NULL; }
static dc_status_t download (dc_context_t *context, dc_descriptor_t *descriptor, const char *devname, const char *cachedir, dc_buffer_t *fingerprint, dctool_output_t *output) { dc_status_t rc = DC_STATUS_SUCCESS; dc_device_t *device = NULL; dc_buffer_t *ofingerprint = NULL; // Open the device. message ("Opening the device (%s %s, %s).\n", dc_descriptor_get_vendor (descriptor), dc_descriptor_get_product (descriptor), devname ? devname : "null"); rc = dc_device_open (&device, context, descriptor, devname); if (rc != DC_STATUS_SUCCESS) { ERROR ("Error opening the device."); goto cleanup; } // Initialize the event data. event_data_t eventdata = {0}; if (fingerprint) { eventdata.cachedir = NULL; } else { eventdata.cachedir = cachedir; } // Register the event handler. message ("Registering the event handler.\n"); int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK | DC_EVENT_VENDOR; rc = dc_device_set_events (device, events, event_cb, &eventdata); if (rc != DC_STATUS_SUCCESS) { ERROR ("Error registering the event handler."); goto cleanup; } // Register the cancellation handler. message ("Registering the cancellation handler.\n"); rc = dc_device_set_cancel (device, dctool_cancel_cb, NULL); if (rc != DC_STATUS_SUCCESS) { ERROR ("Error registering the cancellation handler."); goto cleanup; } // Register the fingerprint data. if (fingerprint) { message ("Registering the fingerprint data.\n"); rc = dc_device_set_fingerprint (device, dc_buffer_get_data (fingerprint), dc_buffer_get_size (fingerprint)); if (rc != DC_STATUS_SUCCESS) { ERROR ("Error registering the fingerprint data."); goto cleanup; } } // Initialize the dive data. dive_data_t divedata = {0}; divedata.device = device; divedata.fingerprint = &ofingerprint; divedata.number = 0; divedata.output = output; // Download the dives. message ("Downloading the dives.\n"); rc = dc_device_foreach (device, dive_cb, &divedata); if (rc != DC_STATUS_SUCCESS) { ERROR ("Error downloading the dives."); goto cleanup; } // Store the fingerprint data. if (cachedir && ofingerprint) { char filename[1024] = {0}; dc_family_t family = DC_FAMILY_NULL; // Generate the fingerprint filename. family = dc_device_get_type (device); snprintf (filename, sizeof (filename), "%s/%s-%08X.bin", cachedir, dctool_family_name (family), eventdata.devinfo.serial); // Write the fingerprint file. dctool_file_write (filename, ofingerprint); } cleanup: dc_buffer_free (ofingerprint); dc_device_close (device); return rc; }
int libdc_driver_open(dev_handle_t abstract, const char * devpath, const char * args) { libdc_device_t dev = (libdc_device_t)(abstract); if (dev == NULL) { errno = EINVAL; return -1; } // Parse the Argument List arglist_t arglist; int rc = arglist_parse(& arglist, args); if (rc != 0) { dev->errcode = DRIVER_ERR_INVALID; dev->errmsg = "Invalid Argument String"; return -1; } // Load a Device Descriptor based on the Model argument rc = arglist_read_uint(arglist, "model", & dev->modelid); if (rc != 0) { dev->errcode = DRIVER_ERR_INVALID; dev->errmsg = "Missing 'model' Argument"; return -1; } int i, found = 0; for (i = 0; g_libdc_plugin_devtable[i].id != -1; ++i) { if (g_libdc_plugin_devtable[i].id == dev->modelid) { found = 1; dev->family = g_libdc_plugin_devtable[i].family; dev->model = g_libdc_plugin_devtable[i].model; } } if (! found) { dev->errcode = DRIVER_ERR_UNSUPPORTED; dev->errmsg = "Unsupported 'model' Argument"; return -1; } dc_iterator_t * iterator = NULL; dc_descriptor_t * descriptor = NULL; dc_descriptor_iterator(& iterator); while (dc_iterator_next(iterator, &descriptor) == DC_STATUS_SUCCESS) { if ((dc_descriptor_get_type(descriptor) == dev->family) && (dc_descriptor_get_model(descriptor) == dev->model)) { dev->descriptor = descriptor; } } dc_iterator_free(iterator); if (dev->descriptor == NULL) { dev->errcode = DRIVER_ERR_UNSUPPORTED; dev->errmsg = "Could not load descriptor for model"; return -1; } // Open the Device dc_status_t ret = dc_device_open(& dev->device, dev->context, dev->descriptor, devpath); if (ret != DC_STATUS_SUCCESS) { dev->errcode = DRIVER_ERR_NO_DEVICE; dev->errmsg = "Failed to connect to device"; return -1; } // Register the Event and Cancel Handlers int events = DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK; dc_device_set_events (dev->device, events, libdc_event_cb, dev); dc_device_set_cancel (dev->device, libdc_cancel_cb, dev); return DRIVER_ERR_SUCCESS; }
static dc_status_t dowork(dc_context_t *context, dc_descriptor_t *descriptor, program_options_t *options, dc_buffer_t *fingerprint) { dc_status_t rc = DC_STATUS_SUCCESS; /* initialize the device data */ device_data_t devdata = {{0}}; /* open the device */ message("Opening the device (%s, %s, %s.\n", dc_descriptor_get_vendor(descriptor), dc_descriptor_get_product(descriptor), options->devname ? options->devname : "null"); dc_device_t *device = NULL; rc = dc_device_open(&device, context, descriptor, options->devname); if (rc != DC_STATUS_SUCCESS) { WARNING("Error opening device."); return rc; } /* register the event handler */ message("Registering the event handler.\n"); int events = DC_EVENT_WAITING | DC_EVENT_PROGRESS | DC_EVENT_DEVINFO | DC_EVENT_CLOCK; rc = dc_device_set_events(device, events, event_cb, &devdata); if (rc != DC_STATUS_SUCCESS) { WARNING("Error registering the event handler."); dc_device_close(device); return rc; } /* register the cancellation handler */ message("Registering the cancellation handler.\n"); rc = dc_device_set_cancel(device, cancel_cb, NULL); if (rc != DC_STATUS_SUCCESS) { WARNING("Error registering the cancellation handler."); dc_device_close(device); return rc; } /* register the fingerprint data */ if (fingerprint) { message("Registering the fingerprint data.\n"); rc = dc_device_set_fingerprint(device, dc_buffer_get_data(fingerprint), dc_buffer_get_size(fingerprint)); if (rc != DC_STATUS_SUCCESS) { WARNING("Error registerting the fingerprint data"); dc_device_close(device); return rc; } } /* dump the memory if requested */ if (options->dumpMemory) { WARNING("Memory dump not enabled."); } /* dump the dives if requested */ if (options->dumpDives) { /* initialize the dive data */ dive_data_t divedata = {0}; dif_dive_collection_t *dc = dif_dive_collection_alloc(); divedata.device = device; divedata.fingerprint = NULL; divedata.number = 0; divedata.dc = dc; /* download the dives */ message("Downloading the dives.\n"); rc = dc_device_foreach(device, dive_cb, &divedata); if (rc != DC_STATUS_SUCCESS) { WARNING("Error downloading the dives."); dc_buffer_free(divedata.fingerprint); dc_device_close (device); return rc; } xml_options_t *xmlOptions = dif_xml_options_alloc(); xmlOptions->filename = options->xmlfile; xmlOptions->useInvalidElements = options->useInvalidElements; if (options->truncateDives) { divedata.dc = dif_alg_dc_truncate_dives(divedata.dc); } if (options->initialPressureFix) { divedata.dc = dif_alg_dc_initial_pressure_fix(divedata.dc); } dif_save_dive_collection_uddf_options(divedata.dc, xmlOptions); /* free the fingerprint buffer */ dc_buffer_free(divedata.fingerprint); dif_dive_collection_free(divedata.dc); dif_xml_options_free(xmlOptions); } /* close the device */ message("Closing the device.\n"); rc = dc_device_close(device); if (rc != DC_STATUS_SUCCESS) { WARNING("Error closing the device."); return rc; } return DC_STATUS_SUCCESS; }