aboutsummaryrefslogtreecommitdiffstats
path: root/common/w32-misc.c
diff options
context:
space:
mode:
Diffstat (limited to 'common/w32-misc.c')
-rw-r--r--common/w32-misc.c257
1 files changed, 249 insertions, 8 deletions
diff --git a/common/w32-misc.c b/common/w32-misc.c
index ae194facb..2a0ba86e5 100644
--- a/common/w32-misc.c
+++ b/common/w32-misc.c
@@ -29,10 +29,163 @@
#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)
@@ -84,9 +237,12 @@ strip_one_arg (char *string, int endquote)
}
-/* Helper for parse_w32_commandline. */
+/* 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)
+parse_cmdstring (char *string, char **argv, unsigned char *argvflags)
{
int argc = 0;
int inquote = 0;
@@ -111,6 +267,8 @@ parse_cmdstring (char *string, char **argv)
*p = 0;
strip_one_arg (p0, 1);
argv[argc] = p0;
+ if (argvflags)
+ argvflags[argc] = 1;
}
argc++;
p0 = NULL;
@@ -145,6 +303,8 @@ parse_cmdstring (char *string, char **argv)
*p = 0;
strip_one_arg (p0, inquote);
argv[argc] = p0;
+ if (argvflags && inquote)
+ argvflags[argc] = 1;
}
argc++;
p0 = NULL;
@@ -163,6 +323,8 @@ parse_cmdstring (char *string, char **argv)
*p = 0;
strip_one_arg (p0, inquote);
argv[argc] = p0;
+ if (argvflags && inquote)
+ argvflags[argc] = 1;
}
argc++;
}
@@ -176,16 +338,21 @@ parse_cmdstring (char *string, char **argv)
* 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. */
+ * 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)
+w32_parse_commandline (char *cmdline, int globing, int *r_argc,
+ int *r_itemsalloced)
{
int argc, i;
char **argv;
+ char *argvflags;
- (void)globing;
+ if (r_itemsalloced)
+ *r_itemsalloced = 0;
- argc = parse_cmdstring (cmdline, NULL);
+ argc = parse_cmdstring (cmdline, NULL, NULL);
if (!argc)
{
log_error ("%s failed: %s\n", __func__, "internal error");
@@ -194,16 +361,90 @@ w32_parse_commandline (char *cmdline, int globing, int *r_argc)
argv = xtrycalloc (argc+1, sizeof *argv);
if (!argv)
{
- log_error ("%s failed: %s\n", __func__, strerror (errno));
+ log_error ("%s failed: %s\n", __func__,
+ gpg_strerror (gpg_error_from_syserror ()));
return NULL; /* Ooops. */
}
- i = parse_cmdstring (cmdline, argv);
+ 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;
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-16 03:51:06 +0000