summaryrefslogtreecommitdiff
path: root/backend/escl/escl_capabilities.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2020-03-30 21:30:45 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2020-03-30 21:30:45 +0200
commitee770c2346eb37e0dcb8b6cf3eaacf3d8efd6bbc (patch)
tree58f05092be1a17a939e861f8cadcda1b6ca2ecef /backend/escl/escl_capabilities.c
parent0da9e21872802cfc6e975b1ebaf9efb9e5934d84 (diff)
parentfef76e17ed4c607ea73b81279f9ef1d7121be900 (diff)
Merge branch 'release/experimental/1.0.29-1_experimental1'experimental/1.0.29-1_experimental1
Diffstat (limited to 'backend/escl/escl_capabilities.c')
-rw-r--r--backend/escl/escl_capabilities.c377
1 files changed, 377 insertions, 0 deletions
diff --git a/backend/escl/escl_capabilities.c b/backend/escl/escl_capabilities.c
new file mode 100644
index 0000000..690ff1e
--- /dev/null
+++ b/backend/escl/escl_capabilities.c
@@ -0,0 +1,377 @@
+/* sane - Scanner Access Now Easy.
+
+ Copyright (C) 2019 Touboul Nathane
+ Copyright (C) 2019 Thierry HUCHARD <thierry@ordissimo.com>
+
+ This file is part of the SANE package.
+
+ SANE is free software; you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at your
+ option) any later version.
+
+ SANE is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with sane; see the file COPYING. If not, write to the Free
+ Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ This file implements a SANE backend for eSCL scanners. */
+
+#define DEBUG_DECLARE_ONLY
+#include "../include/sane/config.h"
+
+#include "escl.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <curl/curl.h>
+#include <libxml/parser.h>
+
+#include "../include/sane/saneopts.h"
+
+struct cap
+{
+ char *memory;
+ size_t size;
+};
+
+/**
+ * \fn static SANE_String_Const convert_elements(SANE_String_Const str)
+ * \brief Function that converts the 'color modes' of the scanner (color/gray) to be understood by SANE.
+ *
+ * \return SANE_VALUE_SCAN_MODE_GRAY / SANE_VALUE_SCAN_MODE_COLOR ; NULL otherwise
+ */
+static SANE_String_Const
+convert_elements(SANE_String_Const str)
+{
+ if (strcmp(str, "Grayscale8") == 0)
+ return (SANE_VALUE_SCAN_MODE_GRAY);
+ else if (strcmp(str, "RGB24") == 0)
+ return (SANE_VALUE_SCAN_MODE_COLOR);
+ return (NULL);
+}
+
+/**
+ * \fn static SANE_String_Const *char_to_array(SANE_String_Const *tab, int *tabsize, SANE_String_Const mode, int good_array)
+ * \brief Function that creates the character arrays to put inside :
+ * the 'color modes', the 'content types', the 'document formats' and the 'supported intents'.
+ *
+ * \return board (the allocated array)
+ */
+static SANE_String_Const *
+char_to_array(SANE_String_Const *tab, int *tabsize, SANE_String_Const mode, int good_array)
+{
+ SANE_String_Const *board = NULL;
+ int i = 0;
+ SANE_String_Const convert = NULL;
+
+ if (mode == NULL)
+ return (tab);
+ if (good_array != 0) {
+ convert = convert_elements(mode);
+ if (convert == NULL)
+ return (tab);
+ }
+ else
+ convert = mode;
+ for (i = 0; i < (*tabsize); i++) {
+ if (strcmp(tab[i], convert) == 0)
+ return (tab);
+ }
+ (*tabsize)++;
+ if (*tabsize == 1)
+ board = (SANE_String_Const *)malloc(sizeof(SANE_String_Const) * (*tabsize) + 1);
+ else
+ board = (SANE_String_Const *)realloc(tab, sizeof(SANE_String_Const) * (*tabsize) + 1);
+ board[*tabsize - 1] = (SANE_String_Const)strdup(convert);
+ board[*tabsize] = NULL;
+ return (board);
+}
+
+/**
+ * \fn static SANE_Int *int_to_array(SANE_Int *tab, int *tabsize, int cont)
+ * \brief Function that creates the integer array to put inside the 'supported resolutions'.
+ *
+ * \return board (the allocated array)
+ */
+static SANE_Int *
+int_to_array(SANE_Int *tab, int *tabsize, int cont)
+{
+ SANE_Int *board = NULL;
+ int i = 0;
+
+ for (i = 0; i < (*tabsize); i++) {
+ if (tab[i] == cont)
+ return (tab);
+ }
+ (*tabsize)++;
+ if (*tabsize == 1) {
+ (*tabsize)++;
+ board = malloc(sizeof(SANE_Int *) * (*tabsize) + 1);
+ }
+ else
+ board = realloc(tab, sizeof(SANE_Int *) * (*tabsize) + 1);
+ board[0] = *tabsize - 1;
+ board[*tabsize - 1] = cont;
+ board[*tabsize] = -1;
+ return (board);
+}
+
+/**
+ * \fn static size_t memory_callback_c(void *contents, size_t size, size_t nmemb, void *userp)
+ * \brief Callback function that stocks in memory the content of the scanner capabilities.
+ *
+ * \return realsize (size of the content needed -> the scanner capabilities)
+ */
+static size_t
+memory_callback_c(void *contents, size_t size, size_t nmemb, void *userp)
+{
+ size_t realsize = size * nmemb;
+ struct cap *mem = (struct cap *)userp;
+
+ char *str = realloc(mem->memory, mem->size + realsize + 1);
+ if (str == NULL) {
+ fprintf(stderr, "not enough memory (realloc returned NULL)\n");
+ return (0);
+ }
+ mem->memory = str;
+ memcpy(&(mem->memory[mem->size]), contents, realsize);
+ mem->size = mem->size + realsize;
+ mem->memory[mem->size] = 0;
+ return (realsize);
+}
+
+/**
+ * \fn static int find_nodes_c(xmlNode *node)
+ * \brief Function that browses the xml file and parses it, to find the xml children node.
+ * --> to recover the scanner capabilities.
+ *
+ * \return 0 if a xml child node is found, 1 otherwise
+ */
+static int
+find_nodes_c(xmlNode *node)
+{
+ xmlNode *child = node->children;
+
+ while (child) {
+ if (child->type == XML_ELEMENT_NODE)
+ return (0);
+ child = child->next;
+ }
+ return (1);
+}
+
+/**
+ * \fn static int find_valor_of_array_variables(xmlNode *node, capabilities_t *scanner)
+ * \brief Function that searchs in the xml file if a scanner capabilitie stocked
+ * in one of the created array (character/integer array) is found.
+ *
+ * \return 0
+ */
+static int
+find_valor_of_array_variables(xmlNode *node, capabilities_t *scanner)
+{
+ const char *name = (const char *)node->name;
+ if (strcmp(name, "ColorMode") == 0)
+ scanner->ColorModes = char_to_array(scanner->ColorModes, &scanner->ColorModesSize, (SANE_String_Const)xmlNodeGetContent(node), 1);
+ else if (strcmp(name, "ContentType") == 0)
+ scanner->ContentTypes = char_to_array(scanner->ContentTypes, &scanner->ContentTypesSize, (SANE_String_Const)xmlNodeGetContent(node), 0);
+ else if (strcmp(name, "DocumentFormat") == 0)
+ {
+ int i = 0;
+ scanner->DocumentFormats = char_to_array(scanner->DocumentFormats, &scanner->DocumentFormatsSize, (SANE_String_Const)xmlNodeGetContent(node), 0);
+ for(; i < scanner->DocumentFormatsSize; i++)
+ {
+ if (scanner->default_format == NULL && !strcmp(scanner->DocumentFormats[i], "image/jpeg"))
+ {
+ scanner->default_format = strdup("image/jpeg");
+ }
+#if(defined HAVE_LIBPNG)
+ else if(!strcmp(scanner->DocumentFormats[i], "image/png") && (scanner->default_format == NULL || strcmp(scanner->default_format, "image/tiff")))
+ {
+ if (scanner->default_format)
+ free(scanner->default_format);
+ scanner->default_format = strdup("image/png");
+ }
+#endif
+#if(defined HAVE_TIFFIO_H)
+ else if(!strcmp(scanner->DocumentFormats[i], "image/tiff"))
+ {
+ if (scanner->default_format)
+ free(scanner->default_format);
+ scanner->default_format = strdup("image/tiff");
+ }
+#endif
+ }
+ fprintf(stderr, "Capability : [%s]\n", scanner->default_format);
+ }
+ else if (strcmp(name, "DocumentFormatExt") == 0)
+ scanner->format_ext = 1;
+ else if (strcmp(name, "Intent") == 0)
+ scanner->SupportedIntents = char_to_array(scanner->SupportedIntents, &scanner->SupportedIntentsSize, (SANE_String_Const)xmlNodeGetContent(node), 0);
+ else if (strcmp(name, "XResolution") == 0)
+ scanner->SupportedResolutions = int_to_array(scanner->SupportedResolutions, &scanner->SupportedResolutionsSize, atoi((const char *)xmlNodeGetContent(node)));
+ return (0);
+}
+
+/**
+ * \fn static int find_value_of_int_variables(xmlNode *node, capabilities_t *scanner)
+ * \brief Function that searchs in the xml file if a integer scanner capabilitie is found.
+ * The integer scanner capabilities that are interesting are :
+ * MinWidth, MaxWidth, MaxHeight, MinHeight, MaxScanRegions, MaxOpticalXResolution,
+ * RiskyLeftMargin, RiskyRightMargin, RiskyTopMargin, RiskyBottomMargin.
+ *
+ * \return 0
+ */
+static int
+find_value_of_int_variables(xmlNode *node, capabilities_t *scanner)
+{
+ int MaxWidth = 0;
+ int MaxHeight = 0;
+ const char *name = (const char *)node->name;
+
+ if (strcmp(name, "MinWidth") == 0)
+ scanner->MinWidth = atoi((const char*)xmlNodeGetContent(node));
+ else if (strcmp(name, "MaxWidth") == 0) {
+ MaxWidth = atoi((const char*)xmlNodeGetContent(node));
+ if (scanner->MaxWidth == 0 || MaxWidth < scanner->MaxWidth)
+ scanner->MaxWidth = atoi((const char *)xmlNodeGetContent(node));
+ }
+ else if (strcmp(name, "MinHeight") == 0)
+ scanner->MinHeight = atoi((const char*)xmlNodeGetContent(node));
+ else if (strcmp(name, "MaxHeight") == 0) {
+ MaxHeight = atoi((const char*)xmlNodeGetContent(node));
+ if (scanner->MaxHeight == 0 || MaxHeight < scanner->MaxHeight)
+ scanner->MaxHeight = atoi((const char *)xmlNodeGetContent(node));
+ }
+ else if (strcmp(name, "MaxScanRegions") == 0)
+ scanner->MaxScanRegions = atoi((const char *)xmlNodeGetContent(node));
+ else if (strcmp(name, "MaxOpticalXResolution") == 0)
+ scanner->MaxOpticalXResolution = atoi((const char *)xmlNodeGetContent(node));
+ else if (strcmp(name, "RiskyLeftMargin") == 0)
+ scanner->RiskyLeftMargin = atoi((const char *)xmlNodeGetContent(node));
+ else if (strcmp(name, "RiskyRightMargin") == 0)
+ scanner->RiskyRightMargin = atoi((const char *)xmlNodeGetContent(node));
+ else if (strcmp(name, "RiskyTopMargin") == 0)
+ scanner->RiskyTopMargin = atoi((const char *)xmlNodeGetContent(node));
+ else if (strcmp(name, "RiskyBottomMargin") == 0)
+ scanner->RiskyBottomMargin = atoi((const char *)xmlNodeGetContent(node));
+ find_valor_of_array_variables(node, scanner);
+ return (0);
+}
+
+/**
+ * \fn static int find_true_variables(xmlNode *node, capabilities_t *scanner)
+ * \brief Function that searchs in the xml file if we find a scanner capabilitie stocked
+ * in one of the created array (character/integer array),
+ * or, if we find a integer scanner capabilitie.
+ *
+ * \return 0
+ */
+static int
+find_true_variables(xmlNode *node, capabilities_t *scanner)
+{
+ const char *name = (const char *)node->name;
+ if (strcmp(name, "MinWidth") == 0 ||
+ strcmp(name, "MaxWidth") == 0 ||
+ strcmp(name, "MinHeight") == 0 ||
+ strcmp(name, "MaxHeight") == 0 ||
+ strcmp(name, "MaxScanRegions") == 0 ||
+ strcmp(name, "ColorMode") == 0 ||
+ strcmp(name, "ContentType") == 0 ||
+ strcmp(name, "DocumentFormat") == 0 ||
+ strcmp(name, "XResolution") == 0 ||
+ strcmp(name, "Intent") == 0 ||
+ strcmp(name, "MaxOpticalXResolution") == 0 ||
+ strcmp(name, "RiskyLeftMargin") == 0 ||
+ strcmp(name, "RiskyRightMargin") == 0 ||
+ strcmp(name, "RiskyTopMargin") == 0 ||
+ strcmp(name, "RiskyBottomMargin") == 0 ||
+ strcmp(name, "DocumentFormatExt") == 0)
+ find_value_of_int_variables(node, scanner);
+ return (0);
+}
+
+/**
+ * \fn static int print_xml_c(xmlNode *node, capabilities_t *scanner)
+ * \brief Function that browses the xml file, node by node.
+ *
+ * \return 0
+ */
+static int
+print_xml_c(xmlNode *node, capabilities_t *scanner)
+{
+ while (node) {
+ if (node->type == XML_ELEMENT_NODE) {
+ if (find_nodes_c(node))
+ find_true_variables(node, scanner);
+ }
+ print_xml_c(node->children, scanner);
+ node = node->next;
+ }
+ return (0);
+}
+
+/**
+ * \fn capabilities_t *escl_capabilities(SANE_String_Const name, SANE_Status *status)
+ * \brief Function that finally recovers all the capabilities of the scanner, using curl.
+ * This function is called in the 'sane_open' function and it's the equivalent of
+ * the following curl command : "curl http(s)://'ip':'port'/eSCL/ScannerCapabilities".
+ *
+ * \return scanner (the structure that stocks all the capabilities elements)
+ */
+capabilities_t *
+escl_capabilities(SANE_String_Const name, SANE_Status *status)
+{
+ capabilities_t *scanner = (capabilities_t*)calloc(1, sizeof(capabilities_t));
+ CURL *curl_handle = NULL;
+ struct cap *var = NULL;
+ xmlDoc *data = NULL;
+ xmlNode *node = NULL;
+ const char *scanner_capabilities = "/eSCL/ScannerCapabilities";
+ char tmp[PATH_MAX] = { 0 };
+
+ *status = SANE_STATUS_GOOD;
+ if (name == NULL)
+ *status = SANE_STATUS_NO_MEM;
+ var = (struct cap *)calloc(1, sizeof(struct cap));
+ if (var == NULL)
+ *status = SANE_STATUS_NO_MEM;
+ var->memory = malloc(1);
+ var->size = 0;
+ curl_handle = curl_easy_init();
+ strcpy(tmp, name);
+ strcat(tmp, scanner_capabilities);
+ DBG( 1, "Get Capabilities : %s\n", tmp);
+ curl_easy_setopt(curl_handle, CURLOPT_URL, tmp);
+ if (strncmp(name, "https", 5) == 0) {
+ DBG( 1, "Ignoring safety certificates, use https\n");
+ curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, 0L);
+ curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYHOST, 0L);
+ }
+ curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, memory_callback_c);
+ curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)var);
+ if (curl_easy_perform(curl_handle) != CURLE_OK) {
+ DBG( 1, "The scanner didn't respond.\n");
+ *status = SANE_STATUS_INVAL;
+ }
+ data = xmlReadMemory(var->memory, var->size, "file.xml", NULL, 0);
+ if (data == NULL)
+ *status = SANE_STATUS_NO_MEM;
+ node = xmlDocGetRootElement(data);
+ if (node == NULL)
+ *status = SANE_STATUS_NO_MEM;
+ print_xml_c(node, scanner);
+ xmlFreeDoc(data);
+ xmlCleanupParser();
+ xmlMemoryDump();
+ curl_easy_cleanup(curl_handle);
+ free(var->memory);
+ return (scanner);
+}