/usr/src/bin/csh/glob.c

Bug Summary

File:	src/bin/csh/glob.c
Warning:	line 457, column 9 Array access (from variable 'vl') results in a null pointer dereference

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name glob.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/bin/csh/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/bin/csh -I . -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/bin/csh/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/bin/csh/glob.c

1/*	$OpenBSD: glob.c,v 1.23 2018/09/08 01:28:39 miko Exp $	*/
2/*	$NetBSD: glob.c,v 1.10 1995/03/21 09:03:01 cgd Exp $	*/

4/*-
* Copyright (c) 1980, 1991, 1993
*	The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

33#include <sys/types.h>
34#include <glob.h>
35#include <errno(*__errno()).h>
36#include <stdlib.h>
37#include <string.h>
38#include <unistd.h>
39#include <limits.h>
40#include <stdarg.h>

42#include "csh.h"
43#include "extern.h"

45static int noglob;
46static int pargsiz, gargsiz;

48/*
* Values for gflag
*/
51#define	G_NONE0	0		/* No globbing needed			*/
52#define	G_GLOB1	1		/* string contains *?[] characters	*/
53#define	G_CSH2	2		/* string contains ~`{ characters	*/

55#define	GLOBSPACE100	100	/* Alloc increment			*/

57#define LBRC'{' '{'
58#define RBRC'}' '}'
59#define LBRK'[' '['
60#define RBRK']' ']'
61#define EOS'\0' '\0'

63Char  **gargv = NULL((void *)0);
64long    gargc = 0;
65Char  **pargv = NULL((void *)0);
66long    pargc = 0;

68/*
* globbing is now done in two stages. In the first pass we expand
* csh globbing idioms ~`{ and then we proceed doing the normal
* globbing if needed ?*[
*
* Csh type globbing is handled in globexpand() and the rest is
* handled in glob() which is part of the 4.4BSD libc.
*
*/
77static Char	*globtilde(Char **, Char *);
78static Char	**libglob(Char **);
79static Char	**globexpand(Char **);
80static int	globbrace(Char *, Char *, Char ***);
81static void	expbrace(Char ***, Char ***, int);
82static int	pmatch(Char *, Char *);
83static void	pword(void);
84static void	psave(int);
85static void	backeval(Char *, bool);


88static Char *
89globtilde(Char **nv, Char *s)
90{
  Char    gbuf[PATH_MAX1024], *gstart, *b, *u, *e;

  gstart = gbuf;
  *gstart++ = *s++;
  u = s;
  for (b = gstart, e = &gbuf[PATH_MAX1024 - 1];
*s && *s != '/' && *s != ':' && b < e;
*b++ = *s++)
continue;
  *b = EOS'\0';
  if (gethdir(gstart, &gbuf[sizeof(gbuf)/sizeof(Char)] - gstart)) {
blkfree(nv);
if (*gstart)
   stderror(ERR_UNKUSER76, vis_str(gstart));
else
   stderror(ERR_NOHOME77);
  }
  b = &gstart[Strlen(gstart)];
  while (*s)
*b++ = *s++;
  *b = EOS'\0';
  --u;
  free(u);
  return (Strsave(gstart));
115}

117static int
118globbrace(Char *s, Char *p, Char ***bl)
119{
  int     i, len;
  Char   *pm, *pe, *lm, *pl;
  Char  **nv, **vl;
  Char    gbuf[PATH_MAX1024];
  int     size = GLOBSPACE100;

  nv = vl = xreallocarray(NULL((void *)0), size, sizeof(Char *));
  *vl = NULL((void *)0);

  len = 0;
  /* copy part up to the brace */
  for (lm = gbuf, p = s; *p != LBRC'{'; *lm++ = *p++)
continue;

  /* check for balanced braces */
  for (i = 0, pe = ++p; *pe; pe++)
if (*pe == LBRK'[') {
   /* Ignore everything between [] */
   for (++pe; *pe != RBRK']' && *pe != EOS'\0'; pe++)
continue;
   if (*pe == EOS'\0') {
blkfree(nv);
return (-RBRK']');
   }
}
else if (*pe == LBRC'{')
   i++;
else if (*pe == RBRC'}') {
   if (i == 0)
break;
   i--;
}

  if (i != 0 || *pe == '\0') {
blkfree(nv);
return (-RBRC'}');
  }

  for (i = 0, pl = pm = p; pm <= pe; pm++)
switch (*pm) {
case LBRK'[':
   for (++pm; *pm != RBRK']' && *pm != EOS'\0'; pm++)
continue;
   if (*pm == EOS'\0') {
*vl = NULL((void *)0);
blkfree(nv);
return (-RBRK']');
   }
   break;
case LBRC'{':
   i++;
   break;
case RBRC'}':
   if (i) {
i--;
break;
   }
   /* FALLTHROUGH */
case ',':
   if (i && *pm == ',')
break;
   else {
Char    savec = *pm;

*pm = EOS'\0';
(void) Strlcpy(lm, pl, &gbuf[sizeof(gbuf)/sizeof(Char)] - lm);
(void) Strlcat(gbuf, pe + 1, PATH_MAX1024);
*pm = savec;
*vl++ = Strsave(gbuf);
len++;
pl = pm + 1;
if (vl == &nv[size]) {
    size += GLOBSPACE100;
    nv = xreallocarray(nv, size, sizeof(Char *));
    vl = &nv[size - GLOBSPACE100];
}
   }
   break;
default:
   break;
}
  *vl = NULL((void *)0);
  *bl = nv;
  return (len);
204}


207static void
208expbrace(Char ***nvp, Char ***elp, int size)
209{
  Char **vl, **el, **nv, *s;

  vl = nv = *nvp;
  if (elp != NULL((void *)0))
el = *elp;
  else
for (el = vl; *el; el++)
   continue;

  for (s = *vl; s; s = *++vl) {
Char   *b;
Char  **vp, **bp;

/* leave {} untouched for find */
if (s[0] == '{' && (s[1] == '\0' || (s[1] == '}' && s[2] == '\0')))
   continue;
if ((b = Strchr(s, '{')) != NULL((void *)0)) {
   Char  **bl;
   int     len;

   if ((len = globbrace(s, b, &bl)) < 0) {
free(nv);
stderror(ERR_MISSING51, -len);
   }
   free(s);
   if (len == 1) {
*vl-- = *bl;
free(bl);
continue;
   }
   len = blklen(bl);
   if (&el[len] >= &nv[size]) {
int     l, e;

l = &el[len] - &nv[size];
size += GLOBSPACE100 > l ? GLOBSPACE100 : l;
l = vl - nv;
e = el - nv;
nv = xreallocarray(nv, size, sizeof(Char *));
vl = nv + l;
el = nv + e;
   }
   vp = vl--;
   *vp = *bl;
   len--;
   for (bp = el; bp != vp; bp--)
bp[len] = *bp;
   el += len;
   vp++;
   for (bp = bl + 1; *bp; *vp++ = *bp++)
continue;
   free(bl);
}

  }
  if (elp != NULL((void *)0))
*elp = el;
  *nvp = nv;
268}

270static Char **
271globexpand(Char **v)
272{
  Char   *s;
  Char  **nv, **vl, **el;
  int     size = GLOBSPACE100;


  nv = vl = xreallocarray(NULL((void *)0), size, sizeof(Char *));
  *vl = NULL((void *)0);

  /*
   * Step 1: expand backquotes.
   */
  while ((s = *v++) != NULL((void *)0)) {
if (Strchr(s, '`')) {
   int     i;

   (void) dobackp(s, 0);
   for (i = 0; i < pargc; i++) {
*vl++ = pargv[i];
if (vl == &nv[size]) {
    size += GLOBSPACE100;
    nv = xreallocarray(nv, size, sizeof(Char *));
    vl = &nv[size - GLOBSPACE100];
}
   }
   free(pargv);
   pargv = NULL((void *)0);
}
else {
   *vl++ = Strsave(s);
   if (vl == &nv[size]) {
size += GLOBSPACE100;
nv = xreallocarray(nv, size, sizeof(Char *));
vl = &nv[size - GLOBSPACE100];
   }
}
  }
  *vl = NULL((void *)0);

  if (noglob)
return (nv);

  /*
   * Step 2: expand braces
   */
  el = vl;
  expbrace(&nv, &el, size);

  /*
   * Step 3: expand ~
   */
  vl = nv;
  for (s = *vl; s; s = *++vl)
if (*s == '~')
   *vl = globtilde(nv, s);
  vl = nv;
  return (vl);
329}

331static Char *
332handleone(Char *str, Char **vl, int action)
333{

  Char   *cp, **vlp = vl;

  switch (action) {
  case G_ERROR0:
setname(vis_str(str))(bname = (vis_str(str)));
blkfree(vl);
stderror(ERR_NAME0x10000000 | ERR_AMBIG40);
break;
  case G_APPEND2:
trim(vlp);
str = Strsave(*vlp++);
do {
   cp = Strspl(str, STRspace);
   free(str);
   str = Strspl(cp, *vlp);
   free(cp);
}
while (*++vlp)
   ;
blkfree(vl);
break;
  case G_IGNORE1:
str = Strsave(strip(*vlp));
blkfree(vl);
break;
  default:
break;
  }
  return (str);
364}

366static Char **
367libglob(Char **vl)
368{
  int     gflgs = GLOB_QUOTE0x0400 | GLOB_NOMAGIC0x0200;
  glob_t  globv;
  char   *ptr;
  int     nonomatch = adrof(STRnonomatch)adrof1(STRnonomatch, &shvhed) != 0, magic = 0, match = 0;

  if (!vl || !vl[0])
return (vl);

  globv.gl_offs = 0;
  globv.gl_pathv = 0;
  globv.gl_pathc = 0;

  if (nonomatch)
gflgs |= GLOB_NOCHECK0x0010;

  do {
ptr = short2qstr(*vl);
switch (glob(ptr, gflgs, 0, &globv)) {
case GLOB_ABORTED(-2):
   setname(vis_str(*vl))(bname = (vis_str(*vl)));
   stderror(ERR_NAME0x10000000 | ERR_GLOB13);
   /* NOTREACHED */
case GLOB_NOSPACE(-1):
   stderror(ERR_NOMEM53);
   /* NOTREACHED */
default:
   break;
}
if (globv.gl_flags & GLOB_MAGCHAR0x0100) {
   match |= (globv.gl_matchc != 0);
   magic = 1;
}
gflgs |= GLOB_APPEND0x0001;
  }
  while (*++vl)
;
  vl = (globv.gl_pathc == 0 || (magic && !match && !nonomatch)) ?
NULL((void *)0) : blk2short(globv.gl_pathv);
  globfree(&globv);
  return (vl);
409}

411Char   *
412globone(Char *str, int action)
413{
  Char   *v[2], **vl, **vo;
  int    gflg;

  noglob = adrof(STRnoglob)adrof1(STRnoglob, &shvhed) != 0;
1
Assuming the condition is false→
  gflag = 0;
  v[0] = str;
  v[1] = 0;
  tglob(v);
  gflg = gflag;
  if (gflg == G_NONE0)
2
←
Assuming 'gflg' is not equal to G_NONE→
3
←
Taking false branch→
return (strip(Strsave(str)));

  if (gflg & G_CSH2) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
/*
* Expand back-quote, tilde and brace
*/
vo = globexpand(v);
if (noglob || (gflg & G_GLOB1) == 0) {
   if (vo[0] == NULL((void *)0)) {
free(vo);
return (Strsave(STRNULL));
   }
   if (vo[1] != NULL((void *)0))
return (handleone(str, vo, action));
   else {
str = strip(vo[0]);
free(vo);
return (str);
   }
}
  }
  else if (noglob || (gflg & G_GLOB1) == 0)
6
←
Assuming 'noglob' is 0→
7
←
Assuming the condition is false→
8
←
Taking false branch→
return (strip(Strsave(str)));
  else
vo = v;

  vl = libglob(vo);
9
←
Value assigned to 'vl'→
  if ((gflg & G_CSH2) && vl != vo)
blkfree(vo);
  if (vl == NULL((void *)0)) {
10
←
Assuming 'vl' is equal to NULL→
11
←
Taking true branch→
setname(vis_str(str))(bname = (vis_str(str)));
stderror(ERR_NAME0x10000000 | ERR_NOMATCH50);
  }
  if (vl[0] == NULL((void *)0)) {
12
←
Array access (from variable 'vl') results in a null pointer dereference
free(vl);
return (Strsave(STRNULL));
  }
  if (vl[1] != NULL((void *)0))
return (handleone(str, vl, action));
  else {
str = strip(*vl);
free(vl);
return (str);
  }
468}

470Char  **
471globall(Char **v)
472{
  Char  **vl, **vo;
  int   gflg = gflag;

  if (!v || !v[0]) {
gargv = saveblk(v);
gargc = blklen(gargv);
return (gargv);
  }

  noglob = adrof(STRnoglob)adrof1(STRnoglob, &shvhed) != 0;

  if (gflg & G_CSH2)
/*
* Expand back-quote, tilde and brace
*/
vl = vo = globexpand(v);
  else
vl = vo = saveblk(v);

  if (!noglob && (gflg & G_GLOB1)) {
vl = libglob(vo);
if ((gflg & G_CSH2) && vl != vo)
   blkfree(vo);
  }
  else
trim(vl);

  gargc = vl ? blklen(vl) : 0;
  return (gargv = vl);
502}

504void
505ginit(void)
506{
  gargsiz = GLOBSPACE100;
  gargv = xreallocarray(NULL((void *)0), gargsiz, sizeof(Char *));
  gargv[0] = 0;
  gargc = 0;
511}

513void
514rscan(Char **t, void (*f)(int))
515{
  Char *p;

  while ((p = *t++) != NULL((void *)0))
while (*p)
   (*f) (*p++);
521}

523void
524trim(Char **t)
525{
  Char *p;

  while ((p = *t++) != NULL((void *)0))
while (*p)
   *p++ &= TRIM0077777;
531}

533void
534tglob(Char **t)
535{
  Char *p, c;

  while ((p = *t++) != NULL((void *)0)) {
if (*p == '~' || *p == '=')
   gflag |= G_CSH2;
else if (*p == '{' &&
 (p[1] == '\0' || (p[1] == '}' && p[2] == '\0')))
   continue;
while ((c = *p++) != '\0') {
   /*
    * eat everything inside the matching backquotes
    */
   if (c == '`') {
gflag |= G_CSH2;
while (*p && *p != '`')
    if (*p++ == '\\') {
	if (*p)		/* Quoted chars */
	    p++;
	else
	    break;
    }
if (*p)			/* The matching ` */
    p++;
else
    break;
   }
   else if (c == '{')
gflag |= G_CSH2;
   else if (isglob(c)(((c) & 0100000U) ? 0 : (_cmap[(unsigned char)(c)] & (
0x0020))))
gflag |= G_GLOB1;
}
  }
568}

570/*
* Command substitute cp.  If literal, then this is a substitution from a
* << redirection, and so we should not crunch blanks and tabs, separating
* words only at newlines.
*/
575Char  **
576dobackp(Char *cp, bool literal)
577{
  Char *lp, *rp;
  Char   *ep, word[PATH_MAX1024];

  blkfree(pargv);
  pargsiz = GLOBSPACE100;
  pargv = xreallocarray(NULL((void *)0), pargsiz, sizeof(Char *));
  pargv[0] = NULL((void *)0);
  pargcp = pargs = word;
  pargc = 0;
  pnleft = PATH_MAX1024 - 4;
  for (;;) {
for (lp = cp; *lp != '`'; lp++) {
   if (*lp == 0) {
if (pargcp != pargs)
    pword();
return (pargv);
   }
   psave(*lp);
}
lp++;
for (rp = lp; *rp && *rp != '`'; rp++)
   if (*rp == '\\') {
rp++;
if (!*rp)
    goto oops;
   }
if (!*rp)
  oops:  stderror(ERR_UNMATCHED52, '`');
ep = Strsave(lp);
ep[rp - lp] = 0;
backeval(ep, literal);
cp = rp + 1;
  }
611}

613static void
614backeval(Char *cp, bool literal)
615{
  int icnt, c;
  Char *ip;
  struct command faket;
  bool    hadnl;
  int     pvec[2], quoted;
  Char   *fakecom[2], ibuf[BUFSIZ1024];
  char    tibuf[BUFSIZ1024];

  hadnl = 0;
  icnt = 0;
  quoted = (literal || (cp[0] & QUOTE0100000U)) ? QUOTE0100000U : 0;
  faket.t_dtyp = NODE_COMMAND1;
  faket.t_dflg = 0;
  faket.t_dlefL.T_dlef = 0;
  faket.t_dritR.T_drit = 0;
  faket.t_dspr = 0;
  faket.t_dcom = fakecom;
  fakecom[0] = STRfakecom1;
  fakecom[1] = 0;

  /*
   * We do the psave job to temporarily change the current job so that the
   * following fork is considered a separate job.  This is so that when
   * backquotes are used in a builtin function that calls glob the "current
   * job" is not corrupted.  We only need one level of pushed jobs as long as
   * we are sure to fork here.
   */
  psavejob();

  /*
   * It would be nicer if we could integrate this redirection more with the
   * routines in sh.sem.c by doing a fake execute on a builtin function that
   * was piped out.
   */
  mypipe(pvec);
  if (pfork(&faket, -1) == 0) {
struct wordent paraml;
struct command *t;

(void) close(pvec[0]);
(void) dmove(pvec[1], 1);
(void) dmove(SHERR, 2);
initdesc();
/*
* Bugfix for nested backquotes by Michael Greim <greim@sbsvax.UUCP>,
* posted to comp.bugs.4bsd 12 Sep. 1989.
*/
if (pargv)		/* mg, 21.dec.88 */
   blkfree(pargv), pargv = 0, pargsiz = 0;
/* mg, 21.dec.88 */
arginp = cp;
while (*cp)
   *cp++ &= TRIM0077777;

/*
* In the child ``forget'' everything about current aliases or
* eval vectors.
*/
alvec = NULL((void *)0);
evalvec = NULL((void *)0);
alvecp = NULL((void *)0);
evalp = NULL((void *)0);
(void) lex(&paraml);
if (seterr)
   stderror(ERR_OLD0x40000000);
alias(&paraml);
t = syntax(paraml.next, &paraml, 0);
if (seterr)
   stderror(ERR_OLD0x40000000);
if (t)
   t->t_dflg |= F_NOFORK(1<<4);
(void) signal(SIGTSTP18, SIG_IGN(void (*)(int))1);
(void) signal(SIGTTIN21, SIG_IGN(void (*)(int))1);
(void) signal(SIGTTOU22, SIG_IGN(void (*)(int))1);
execute(t, -1, NULL((void *)0), NULL((void *)0));
exitstat();
  }
  free(cp);
  (void) close(pvec[1]);
  c = 0;
  ip = NULL((void *)0);
  do {
int     cnt = 0;

for (;;) {
   if (icnt == 0) {
int     i;

ip = ibuf;
do
    icnt = read(pvec[0], tibuf, BUFSIZ1024);
while (icnt == -1 && errno(*__errno()) == EINTR4);
if (icnt <= 0) {
    c = -1;
    break;
}
for (i = 0; i < icnt; i++)
    ip[i] = (unsigned char) tibuf[i];
   }
   if (hadnl)
break;
   --icnt;
   c = (*ip++ & TRIM0077777);
   if (c == 0)
break;
   if (c == '\n') {
/*
 * Continue around the loop one more time, so that we can eat
 * the last newline without terminating this word.
 */
hadnl = 1;
continue;
   }
   if (!quoted && (c == ' ' || c == '\t'))
break;
   cnt++;
   psave(c | quoted);
}
/*
* Unless at end-of-file, we will form a new word here if there were
* characters in the word, or in any case when we take text literally.
* If we didn't make empty words here when literal was set then we
* would lose blank lines.
*/
if (c != -1 && (cnt || literal))
   pword();
hadnl = 0;
  } while (c >= 0);
  (void) close(pvec[0]);
  pwait();
  prestjob();
747}

749static void
750psave(int c)
751{
  if (--pnleft <= 0)
stderror(ERR_WTOOLONG2);
  *pargcp++ = c;
755}

757static void
758pword(void)
759{
  psave(0);
  if (pargc == pargsiz - 1) {
pargsiz += GLOBSPACE100;
pargv = xreallocarray(pargv, pargsiz, sizeof(Char *));
  }
  pargv[pargc++] = Strsave(pargs);
  pargv[pargc] = NULL((void *)0);
  pargcp = pargs;
  pnleft = PATH_MAX1024 - 4;
769}

771int
772Gmatch(Char *string, Char *pattern)
773{
  Char **blk, **p;
  int	   gpol = 1, gres = 0;

  if (*pattern == '^') {
gpol = 0;
pattern++;
  }

  blk = xreallocarray(NULL((void *)0), GLOBSPACE100, sizeof(Char *));
  blk[0] = Strsave(pattern);
  blk[1] = NULL((void *)0);

  expbrace(&blk, NULL((void *)0), GLOBSPACE100);

  for (p = blk; *p; p++)
gres |= pmatch(string, *p);

  blkfree(blk);
  return(gres == gpol);
793}

795static int
796pmatch(Char *string, Char *pattern)
797{
  Char stringc, patternc;
  int     match, negate_range;
  Char    rangec;

  for (;; ++string) {
stringc = *string & TRIM0077777;
patternc = *pattern++;
switch (patternc) {
case 0:
   return (stringc == 0);
case '?':
   if (stringc == 0)
return (0);
   break;
case '*':
   if (!*pattern)
return (1);
   while (*string)
if (Gmatch(string++, pattern))
    return (1);
   return (0);
case '[':
   match = 0;
   if ((negate_range = (*pattern == '^')) != 0)
pattern++;
   while ((rangec = *pattern++) != '\0') {
if (rangec == ']')
    break;
if (match)
    continue;
if (rangec == '-' && *(pattern-2) != '[' && *pattern  != ']') {
    match = (stringc <= (*pattern & TRIM0077777) &&
	      (*(pattern-2) & TRIM0077777) <= stringc);
    pattern++;
}
else
    match = (stringc == (rangec & TRIM0077777));
   }
   if (rangec == 0)
stderror(ERR_NAME0x10000000 | ERR_MISSING51, ']');
   if (match == negate_range)
return (0);
   break;
default:
   if ((patternc & TRIM0077777) != stringc)
return (0);
   break;

}
  }
848}

850void
851Gcat(Char *s1, Char *s2)
852{
  Char *p, *q;
  int     n;

  for (p = s1; *p++;)
continue;
  for (q = s2; *q++;)
continue;
  n = (p - s1) + (q - s2) - 1;
  if (++gargc >= gargsiz) {
gargsiz += GLOBSPACE100;
gargv = xreallocarray(gargv, gargsiz, sizeof(Char *));
  }
  gargv[gargc] = 0;
  p = gargv[gargc - 1] = xreallocarray(NULL((void *)0), n, sizeof(Char));
  for (q = s1; (*p++ = *q++) != '\0';)
continue;
  for (p--, q = s2; (*p++ = *q++) != '\0';)
continue;
871}

873int
874sortscmp(const void *a, const void *b)
875{
  char    buf[2048];

  if (!a)			/* check for NULL */
return (b ? 1 : 0);
  if (!b)
return (-1);

  if (!*(Char **)a)			/* check for NULL */
return (*(Char **)b ? 1 : 0);
  if (!*(Char **)b)
return (-1);

  (void) strlcpy(buf, short2str(*(Char **)a), sizeof buf);
  return ((int) strcoll(buf, short2str(*(Char **)b)));
890}