src/util/gnunet-qr.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2013-2019 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19 */
  20 /**
  21  * @file util/gnunet-qr.c
  22  * @author Hartmut Goebel (original implementation)
  23  * @author Martin Schanzenbach (integrate gnunet-uri)
  24  * @author Christian Grothoff (error handling)
  25  */
  26 #include <stdio.h>
  27 #include <zbar.h>
  28 #include <stdbool.h>
  29 #include "platform.h"
  30 #include "gnunet_util_lib.h"
  31
  32 #define LOG(fmt, ...)  \
  33   if (verbose == true) \
  34   printf (fmt, ##__VA_ARGS__)
  35
  36 /**
  37  * Video device to capture from. Sane default for GNU/Linux systems.
  38  */
  39 static char *device = "/dev/video0";
  40
  41 /**
  42  * --verbose option
  43  */
  44 static int verbose = false;
  45
  46 /**
  47  * --silent option
  48  */
  49 static int silent = false;
  50
  51 /**
  52  * Handler exit code
  53  */
  54 static long unsigned int exit_code = 1;
  55
  56 /**
  57  * Helper process we started.
  58  */
  59 static struct GNUNET_OS_Process *p;
  60
  61
  62 /**
  63  * Pipe used to communicate child death via signal.
  64  */
  65 static struct GNUNET_DISK_PipeHandle *sigpipe;
  66
  67
  68 /**
  69  * Task triggered whenever we receive a SIGCHLD (child
  70  * process died) or when user presses CTRL-C.
  71  *
  72  * @param cls closure, NULL
  73  */
  74 static void
  75 maint_child_death (void *cls)
  76 {
  77   enum GNUNET_OS_ProcessStatusType type;
  78
  79   if ((GNUNET_OK != GNUNET_OS_process_status (p, &type, &exit_code)) ||
  80       (type != GNUNET_OS_PROCESS_EXITED))
  81     GNUNET_break (0 == GNUNET_OS_process_kill (p, GNUNET_TERM_SIG));
  82   GNUNET_OS_process_destroy (p);
  83 }
  84
  85
  86 /**
  87  * Dispatch URIs to the appropriate GNUnet helper process
  88  *
  89  * @param cls closure
  90  * @param uri uri to dispatch
  91  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  92  * @param cfg configuration
  93  */
  94 static void
  95 gnunet_uri (void *cls,
  96             const char *uri,
  97             const char *cfgfile,
  98             const struct GNUNET_CONFIGURATION_Handle *cfg)
  99 {
 100   const char *orig_uri;
 101   const char *slash;
 102   char *subsystem;
 103   char *program;
 104   struct GNUNET_SCHEDULER_Task *rt;
 105
 106   orig_uri = uri;
 107   if (0 != strncasecmp ("gnunet://", uri, strlen ("gnunet://")))
 108   {
 109     fprintf (stderr,
 110              _ ("Invalid URI: does not start with `%s'\n"),
 111              "gnunet://");
 112     return;
 113   }
 114   uri += strlen ("gnunet://");
 115   if (NULL == (slash = strchr (uri, '/')))
 116   {
 117     fprintf (stderr, _ ("Invalid URI: fails to specify subsystem\n"));
 118     return;
 119   }
 120   subsystem = GNUNET_strndup (uri, slash - uri);
 121   if (GNUNET_OK !=
 122       GNUNET_CONFIGURATION_get_value_string (cfg, "uri", subsystem, &program))
 123   {
 124     fprintf (stderr, _ ("No handler known for subsystem `%s'\n"), subsystem);
 125     GNUNET_free (subsystem);
 126     return;
 127   }
 128   GNUNET_free (subsystem);
 129   rt = GNUNET_SCHEDULER_add_read_file (
 130     GNUNET_TIME_UNIT_FOREVER_REL,
 131     GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ),
 132     &maint_child_death,
 133     NULL);
 134   p = GNUNET_OS_start_process (GNUNET_NO,
 135                                0,
 136                                NULL,
 137                                NULL,
 138                                NULL,
 139                                program,
 140                                program,
 141                                orig_uri,
 142                                NULL);
 143   GNUNET_free (program);
 144   if (NULL == p)
 145     GNUNET_SCHEDULER_cancel (rt);
 146 }
 147
 148
 149 /**
 150  * Obtain QR code 'symbol' from @a proc.
 151  *
 152  * @param proc zbar processor to use
 153  * @return NULL on error
 154  */
 155 static const zbar_symbol_t *
 156 get_symbol (zbar_processor_t *proc)
 157 {
 158   const zbar_symbol_set_t *symbols;
 159   int rc;
 160   int n;
 161
 162   if (0 != zbar_processor_parse_config (proc, "enable"))
 163   {
 164     GNUNET_break (0);
 165     return NULL;
 166   }
 167
 168   /* initialize the Processor */
 169   if (0 != (rc = zbar_processor_init (proc, device, 1)))
 170   {
 171     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 172                 "Failed to open device `%s': %d\n",
 173                 device,
 174                 rc);
 175     return NULL;
 176   }
 177
 178   /* enable the preview window */
 179   if ((0 != (rc = zbar_processor_set_visible (proc, 1))) ||
 180       (0 != (rc = zbar_processor_set_active (proc, 1))))
 181   {
 182     GNUNET_break (0);
 183     return NULL;
 184   }
 185
 186   /* read at least one barcode (or until window closed) */
 187   LOG ("Capturing\n");
 188   n = zbar_process_one (proc, -1);
 189
 190   /* hide the preview window */
 191   (void) zbar_processor_set_active (proc, 0);
 192   (void) zbar_processor_set_visible (proc, 0);
 193   if (-1 == n)
 194     return NULL; /* likely user closed the window */
 195   LOG ("Got %i images\n", n);
 196   /* extract results */
 197   symbols = zbar_processor_get_results (proc);
 198   if (NULL == symbols)
 199   {
 200     GNUNET_break (0);
 201     return NULL;
 202   }
 203   return zbar_symbol_set_first_symbol (symbols);
 204 }
 205
 206
 207 /**
 208  * Run zbar QR code parser.
 209  *
 210  * @return NULL on error, otherwise the URI that we found
 211  */
 212 static char *
 213 run_zbar ()
 214 {
 215   zbar_processor_t *proc;
 216   const char *data;
 217   char *ret;
 218   const zbar_symbol_t *symbol;
 219
 220   /* configure the Processor */
 221   proc = zbar_processor_create (1);
 222   if (NULL == proc)
 223   {
 224     GNUNET_break (0);
 225     return NULL;
 226   }
 227
 228   symbol = get_symbol (proc);
 229   if (NULL == symbol)
 230   {
 231     zbar_processor_destroy (proc);
 232     return NULL;
 233   }
 234   data = zbar_symbol_get_data (symbol);
 235   if (NULL == data)
 236   {
 237     GNUNET_break (0);
 238     zbar_processor_destroy (proc);
 239     return NULL;
 240   }
 241   LOG ("Found %s \"%s\"\n",
 242        zbar_get_symbol_name (zbar_symbol_get_type (symbol)),
 243        data);
 244   ret = GNUNET_strdup (data);
 245   /* clean up */
 246   zbar_processor_destroy (proc);
 247   return ret;
 248 }
 249
 250
 251 /**
 252  * Main function that will be run by the scheduler.
 253  *
 254  * @param cls closure
 255  * @param args remaining command-line arguments
 256  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 257  * @param cfg configuration
 258  */
 259 static void
 260 run (void *cls,
 261      char *const *args,
 262      const char *cfgfile,
 263      const struct GNUNET_CONFIGURATION_Handle *cfg)
 264 {
 265   char *data;
 266
 267   data = run_zbar ();
 268   if (NULL == data)
 269     return;
 270   gnunet_uri (cls, data, cfgfile, cfg);
 271   if (exit_code != 0)
 272   {
 273     printf ("Failed to add URI %s\n", data);
 274   }
 275   else
 276   {
 277     printf ("Added URI %s\n", data);
 278   }
 279   GNUNET_free (data);
 280 };
 281
 282
 283 int
 284 main (int argc, char *const *argv)
 285 {
 286   int ret;
 287   struct GNUNET_GETOPT_CommandLineOption options[] =
 288     {GNUNET_GETOPT_option_string (
 289        'd',
 290        "device",
 291        "DEVICE",
 292        gettext_noop ("use video-device DEVICE (default: /dev/video0"),
 293        &device),
 294      GNUNET_GETOPT_option_flag ('\0',
 295                                 "verbose",
 296                                 gettext_noop ("be verbose"),
 297                                 &verbose),
 298      GNUNET_GETOPT_option_flag ('s',
 299                                 "silent",
 300                                 gettext_noop ("do not show preview windows"),
 301                                 &silent),
 302      GNUNET_GETOPT_OPTION_END};
 303
 304   ret = GNUNET_PROGRAM_run (
 305     argc,
 306     argv,
 307     "gnunet-qr",
 308     gettext_noop (
 309       "Scan a QR code using a video device and import the uri read"),
 310     options,
 311     &run,
 312     NULL);
 313   return ((GNUNET_OK == ret) && (0 == exit_code)) ? 0 : 1;
 314 }