Adding upstream version 2.2.40.upstream/2.2.40upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 450 insertions, 0 deletions

diff --git a/common/w32-cmdline.c b/common/w32-cmdline.c
new file mode 100644
index 0000000..85d5752
--- /dev/null
+++ b/common/w32-cmdline.c
@@ -0,0 +1,450 @@
+/* w32-cmdline.c - Command line helper functions needed in Windows
+ * Copyright (C) 2021 g10 Code GmbH
+ *
+ * This file is part of GnuPG.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either
+ *
+ *   - the GNU Lesser General Public License as published by the Free
+ *     Software Foundation; either version 3 of the License, or (at
+ *     your option) any later version.
+ *
+ * or
+ *
+ *   - the GNU General Public License as published by the Free
+ *     Software Foundation; either version 2 of the License, or (at
+ *     your option) any later version.
+ *
+ * or both in parallel, as here.
+ *
+ * This file 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 this program; if not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+
+#ifdef HAVE_W32_SYSTEM
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#endif /*!HAVE_W32_SYSTEM*/
+
+#include "util.h"
+#include "w32help.h"
+
+
+/* Helper object for add_arg.  */
+struct add_arg_s
+{
+  char **argv; /* Calloced array.  */
+  int argc;    /* Number of items in argc. */
+  int size;    /* Allocated size of argv.  */
+};
+
+
+/* Add STRING to the argv of PARM.  Returns 0 on success; on error
+ * sets ERRNO and returns -1.  */
+static int
+add_arg (struct add_arg_s *parm, const char *string)
+{
+  if (parm->argc == parm->size)
+    {
+      char **newargv;
+      int newsize;
+
+      if (parm->size < 256)
+        newsize = ((parm->size + 31) / 32 + 1) * 32;
+      else
+        newsize = ((parm->size + 255) / 256 + 1) * 256;
+      /* We allocate one more item for the trailing NULL.  */
+      newargv = xtryreallocarray (parm->argv, parm->size, newsize+1,
+                                  sizeof *newargv);
+      if (!newargv)
+        return -1;
+      parm->argv = newargv;
+      parm->size = newsize;
+    }
+  parm->argv[parm->argc] = xtrystrdup (string);
+  if (!parm->argv[parm->argc])
+    return -1;
+  parm->argc++;
+  return 0;
+}
+
+
+/* Glob PATTERN and add to the argv of PARM.  Returns 0 on success; on
+ * error sets ERRNO and returns -1.  */
+static int
+glob_arg (struct add_arg_s *parm, const char *pattern)
+{
+  int rc;
+  const char *s;
+
+#ifdef HAVE_W32_SYSTEM
+  HANDLE hd;
+  WIN32_FIND_DATAW dir;
+  uintptr_t pos;  /* Offset to the last slash in pattern/buffer or 0.  */
+  char *buffer, *p;
+  int any = 0;
+
+  s = strpbrk (pattern, "*?");
+  if (!s)
+    {
+      /* Called without wildcards.  */
+      return add_arg (parm, pattern);
+    }
+  for (; s != pattern && *s != '/' && *s != '\\'; s--)
+    ;
+  pos = s - pattern;
+  if (*s == '/' || *s == L'\\')
+    pos++;
+
+  {
+    wchar_t *wpattern;
+
+    wpattern = utf8_to_wchar (pattern);
+    if (!wpattern)
+      return -1;
+
+    hd = FindFirstFileW (wpattern, &dir);
+    xfree (wpattern);
+  }
+  if (hd == INVALID_HANDLE_VALUE)
+    return add_arg (parm, pattern);
+
+  /* We allocate enough space to hold all kind of UTF-8 strings.  */
+  buffer = xtrymalloc (strlen (pattern) + MAX_PATH*6 + 1);
+  if (!buffer)
+    {
+      FindClose (hd);
+      return -1;
+    }
+  mem2str (buffer, pattern, pos+1);
+  for (p=buffer; *p; p++)
+    if (*p == '\\')
+      *p = '/';
+
+  do
+    {
+      if (!(dir.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+        {
+          char *name;
+
+          name = wchar_to_utf8 (dir.cFileName);
+          if (!name)
+            rc = -1;
+          else
+            {
+              mem2str (buffer + pos, name, MAX_PATH*6);
+              xfree (name);
+              rc = add_arg (parm, buffer);
+            }
+          if (rc)
+            {
+              FindClose (hd);
+              xfree (buffer);
+              return rc;
+            }
+          any = 1;
+        }
+    }
+  while (FindNextFileW (hd, &dir));
+
+  FindClose (hd);
+  xfree (buffer);
+
+  rc = any? 0 : add_arg (parm, pattern);
+
+#else /* Unix */
+
+  /* We use some dummy code here because this is only used in the Unix
+   * test suite.  */
+  s = strpbrk (pattern, "*?");
+  if (!s)
+    {
+      /* Called without wildcards.  */
+      return add_arg (parm, pattern);
+    }
+
+  if (strchr (pattern, '?'))
+    rc = add_arg (parm, "[? follows]");
+  else if (strchr (pattern, '*'))
+    rc = add_arg (parm, "[* follows]");
+  else
+    rc = add_arg (parm, "[no glob!]");  /* Should not happen.  */
+  if (!rc)
+    rc = add_arg (parm, pattern);
+
+#endif /* Unix */
+
+  return rc;
+}
+
+
+/* Return the number of backslashes.  */
+static unsigned int
+count_backslashes (const char *s)
+{
+  unsigned int count = 0;
+
+  for ( ;*s == '\\'; s++)
+    count++;
+  return count;
+}
+
+
+static void
+strip_one_arg (char *string, int endquote)
+{
+  char *s, *d;
+  unsigned int n, i;
+
+  for (s=d=string; *s; s++)
+    if (*s == '\\')
+      {
+        n = count_backslashes (s);
+        if (s[n] == '"')
+          {
+            for (i=0; i < n/2; i++)
+              *d++ = '\\';
+            if ((n&1)) /* Odd number of backslashes.  */
+              *d++ = '"';  /* Print the quote.  */
+          }
+        else if (!s[n] && endquote)
+          {
+            for (i=0; i < n/2; i++)
+              *d++ = '\\';
+            s--;
+          }
+        else /* Print all backslashes.  */
+          {
+            for (i=0; i < n; i++)
+              *d++ = '\\';
+            n--; /* Adjust for the increment in the for.  */
+          }
+        s += n;
+      }
+    else if (*s == '"' && s[1])
+      *d++ = *++s;
+    else
+      *d++ = *s;
+  *d = 0;
+}
+
+
+/* Helper for parse_w32_commandline.  If ARGV and ARGVFLAGS are not
+ * NULL, ARGVFLAGS is expected to be allocated at the same size of
+ * ARGV and zeroed; on return 1 is stored for all arguments which are
+ * quoted (args like (foo"bar"baz") also count as quoted.  */
+static int
+parse_cmdstring (char *string, char **argv, unsigned char *argvflags)
+{
+  int argc = 0;
+  int inquote = 0;
+  char *p0, *p;
+  unsigned int n;
+
+  p0 = string;
+  for (p=string; *p; p++)
+    {
+      if (inquote)
+        {
+          if (*p == '\\' && p[1] == '"')
+            p++;
+          else if (*p == '\\' && p[1] == '\\')
+            p++;
+          else if (*p == '"')
+            {
+              if (p[1] == ' ' || p[1] == '\t' || !p[1])
+                {
+                  if (argv)
+                    {
+                      *p = 0;
+                      strip_one_arg (p0, 1);
+                      argv[argc] = p0;
+                      if (argvflags)
+                        argvflags[argc] = 1;
+                    }
+                  argc++;
+                  p0 = NULL;
+                }
+              inquote = 0;
+            }
+        }
+      else if (*p == '\\' && (n=count_backslashes (p)))
+        {
+          if (!p0) /* First non-WS; set start.  */
+            p0 = p;
+          if (p[n] == '"')
+            {
+              if (!(n&1)) /* Even number.  */
+                inquote = 1;
+              p++;
+            }
+          p += n;
+        }
+      else if (*p == '"')
+        {
+          inquote = 1;
+          if (!p0 || p == string) /* First non-WS or first char; set start.  */
+            p0 = p + 1;
+        }
+      else if (*p == ' ' || *p == '\t')
+        {
+          if (p0) /* We are in an argument and reached WS.  */
+            {
+              if (argv)
+                {
+                  *p = 0;
+                  strip_one_arg (p0, inquote);
+                  argv[argc] = p0;
+                  if (argvflags && inquote)
+                    argvflags[argc] = 1;
+                }
+              argc++;
+              p0 = NULL;
+            }
+        }
+      else if (!p0) /* First non-WS; set start.  */
+        p0 = p;
+    }
+
+  if (inquote || p0)
+    {
+      /* Closing quote missing (we accept this as argument anyway) or
+       * an open argument.  */
+      if (argv)
+        {
+          *p = 0;
+          strip_one_arg (p0, inquote);
+          argv[argc] = p0;
+          if (argvflags && inquote)
+            argvflags[argc] = 1;
+        }
+      argc++;
+    }
+
+  return argc;
+}
+
+/* This is a Windows command line parser, returning an array with
+ * strings and its count.  The argument CMDLINE is expected to be
+ * utf-8 encoded and may be modified after returning from this
+ * function.  The returned array points into CMDLINE, so this should
+ * not be freed.  If GLOBING is set to true globing is done for all
+ * items.  Returns NULL on error.  The number of items in the array is
+ * returned at R_ARGC.  If R_ITEMSALLOCED is NOT NULL, it's value is
+ * set to true if the items at R_ALLOC are allocated and not point
+ * into to CMDLINE.  */
+char **
+w32_parse_commandline (char *cmdline, int globing, int *r_argc,
+                       int *r_itemsalloced)
+{
+  int argc, i;
+  char **argv;
+  char *argvflags;
+
+  if (r_itemsalloced)
+    *r_itemsalloced = 0;
+
+  argc = parse_cmdstring (cmdline, NULL, NULL);
+  if (!argc)
+    {
+      log_error ("%s failed: %s\n", __func__, "internal error");
+      return NULL;  /* Ooops.  */
+    }
+  argv = xtrycalloc (argc+1, sizeof *argv);
+  if (!argv)
+    {
+      log_error ("%s failed: %s\n", __func__,
+                 gpg_strerror (gpg_error_from_syserror ()));
+      return NULL;  /* Ooops.  */
+    }
+  if (globing)
+    {
+      argvflags = xtrycalloc (argc+1, sizeof *argvflags);
+      if (!argvflags)
+        {
+          log_error ("%s failed: %s\n", __func__,
+                     gpg_strerror (gpg_error_from_syserror ()));
+          xfree (argv);
+          return NULL;  /* Ooops.  */
+        }
+    }
+  else
+    argvflags = NULL;
+
+  i = parse_cmdstring (cmdline, argv, argvflags);
+  if (argc != i)
+    {
+      log_error ("%s failed (argc=%d i=%d)\n", __func__, argc, i);
+      xfree (argv);
+      xfree (argvflags);
+      return NULL;  /* Ooops.  */
+    }
+
+  if (globing)
+    {
+      for (i=0; i < argc; i++)
+        if (argvflags[i] != 1 && strpbrk (argv[i], "*?"))
+          break;
+      if (i < argc)
+        {
+          /* Indeed some unquoted arguments contain wildcards.  We
+           * need to do the globing and thus a dynamically re-allocate
+           * the argv array and strdup all items.  */
+          struct add_arg_s parm;
+          int rc;
+
+          if (argc < 32)
+            parm.size = ((argc + 31) / 32 + 1) * 32;
+          else
+            parm.size = ((argc + 255) / 256 + 1) * 256;
+          parm.argc = 0;
+          /* We allocate one more item for the trailing NULL.  */
+          parm.argv = xtryreallocarray (NULL, 0, parm.size + 1,
+                                        sizeof *parm.argv);
+          if (!parm.argv)
+            {
+              log_error ("%s: error allocating array: %s\n", __func__,
+                         gpg_strerror (gpg_error_from_syserror ()));
+              xfree (argv);
+              xfree (argvflags);
+              return NULL;  /* Ooops.  */
+            }
+          rc = 0;
+          for (i=0; i < argc; i++)
+            {
+              if (argvflags[i] != 1)
+                rc = glob_arg (&parm, argv[i]);
+              else
+                rc = add_arg (&parm, argv[i]);
+              if (rc)
+                {
+                  log_error ("%s: error adding or blobing: %s\n", __func__,
+                             gpg_strerror (gpg_error_from_syserror ()));
+                  for (i=0; i < parm.argc; i++)
+                    xfree (parm.argv[i]);
+                  xfree (parm.argv);
+                  xfree (argv);
+                  xfree (argvflags);
+                  return NULL;  /* Ooops.  */
+                }
+            }
+          xfree (argv);
+          argv = parm.argv;
+          argc = parm.argc;
+          if (r_itemsalloced)
+            *r_itemsalloced = 1;
+        }
+    }
+
+  xfree (argvflags);
+  *r_argc = argc;
+  return argv;
+}