summaryrefslogtreecommitdiffstats
path: root/common/w32-cmdline.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--common/w32-cmdline.c450
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;
+}