mirror of git://git.gnupg.org/gnupg.git
451 lines
12 KiB
C
451 lines
12 KiB
C
/* 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;
|
|
}
|