Commit 1a9cc74ce for imagemagick.org

commit 1a9cc74ce16285e256d5e027a599bdc17fb5b369
Author: Cristy <urban-warrior@imagemagick.org>
Date:   Wed Nov 18 18:42:50 2026 -0500

    https://github.com/ImageMagick/ImageMagick/issues/9122

diff --git a/MagickCore/token.c b/MagickCore/token.c
index db7d105e4..d8c804c07 100644
--- a/MagickCore/token.c
+++ b/MagickCore/token.c
@@ -91,7 +91,7 @@ struct _TokenInfo
 %
 %  The format of the AcquireTokenInfo method is:
 %
-%      TokenInfo *AcquireTokenInfo()
+%      TokenInfo *AcquireTokenInfo(void)
 %
 */
 MagickExport TokenInfo *AcquireTokenInfo(void)
@@ -100,6 +100,7 @@ MagickExport TokenInfo *AcquireTokenInfo(void)
     *token_info;

   token_info=(TokenInfo *) AcquireCriticalMemory(sizeof(*token_info));
+  (void) memset(token_info,0,sizeof(*token_info));
   token_info->signature=MagickCoreSignature;
   return(token_info);
 }
@@ -115,7 +116,7 @@ MagickExport TokenInfo *AcquireTokenInfo(void)
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  DestroyTokenInfo() deallocates memory associated with an TokenInfo
+%  DestroyTokenInfo() deallocates memory associated with a TokenInfo
 %  structure.
 %
 %  The format of the DestroyTokenInfo method is:
@@ -124,7 +125,7 @@ MagickExport TokenInfo *AcquireTokenInfo(void)
 %
 %  A description of each parameter follows:
 %
-%    o token_info: Specifies a pointer to an TokenInfo structure.
+%    o token_info: Specifies a pointer to a TokenInfo structure.
 %
 */
 MagickExport TokenInfo *DestroyTokenInfo(TokenInfo *token_info)
@@ -151,7 +152,7 @@ MagickExport TokenInfo *DestroyTokenInfo(TokenInfo *token_info)
 %
 %  GetNextToken() gets a token from the token stream.  A token is defined as
 %  a sequence of characters delimited by whitespace (e.g. clip-path), a
-%  sequence delimited with quotes (.e.g "Quote me"), or a sequence enclosed in
+%  sequence delimited with quotes (e.g. "Quote me"), or a sequence enclosed in
 %  parenthesis (e.g. rgb(0,0,0)).  GetNextToken() also recognizes these
 %  separator characters: ':', '=', ',', and ';'.  GetNextToken() returns the
 %  length of the consumed token.
@@ -191,6 +192,7 @@ MagickExport magick_hot_spot size_t GetNextToken(

   assert(start != (const char *) NULL);
   assert(token != (char *) NULL);
+  assert(extent != 0);
   i=0;
   p=start;
   while ((isspace((int) ((unsigned char) *p)) != 0) && (*p != '\0'))
@@ -352,28 +354,62 @@ MagickExport magick_hot_spot size_t GetNextToken(
 %
 */

-static MagickBooleanType GlobExpression_(const char *magick_restrict expression,
+static inline int GlobFoldCase(const int code)
+{
+  if ((code >= 'A') && (code <= 'Z'))
+    return(code-'A'+'a');
+  return(code);
+}
+
+static inline MagickBooleanType GlobInRange(const int code,const int low,
+  const int high,const MagickBooleanType case_insensitive)
+{
+  if ((code >= low) && (code <= high))
+    return(MagickTrue);
+  if (case_insensitive != MagickFalse)
+    {
+      int
+        other;
+
+      other=code;
+      if ((code >= 'a') && (code <= 'z'))
+        other=code-'a'+'A';
+      else
+        if ((code >= 'A') && (code <= 'Z'))
+          other=code-'A'+'a';
+      if ((other != code) && (other >= low) && (other <= high))
+        return(MagickTrue);
+    }
+  return(MagickFalse);
+}
+
+static int GlobExpression_(const char *magick_restrict expression,
   const char *magick_restrict pattern,const MagickBooleanType case_insensitive,
   const size_t depth)
 {
+#define GlobNoMatch  0
+#define GlobMatched  1
+#define GlobAbort  (-1)
+
+#if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
+#define MagickGlobEscapes
+#endif
+
   if (depth >= MagickMaxRecursionDepth)
     {
       errno=EOVERFLOW;
-      return(MagickFalse);
+      return(GlobAbort);
     }
   /*
-    Empty pattern or single '*' always matches.
+    A lone '*' always matches.
   */
-  if (pattern == (const char *) NULL)
-    return(MagickTrue);
-  if (GetUTFCode(pattern) == 0)
-    return(MagickTrue);
   if ((GetUTFCode(pattern) == '*') &&
       (GetUTFCode(pattern+GetUTFOctets(pattern)) == 0))
-    return(MagickTrue);
+    return(GlobMatched);
   if ((strchr(pattern,'{') == NULL) &&
       (strchr(pattern,'*') == NULL) &&
-      (strchr(pattern,'?') == NULL))
+      (strchr(pattern,'?') == NULL) &&
+      (strchr(pattern,'[') != NULL))
     {
       char
         path[MagickPathExtent]= { 0 };
@@ -383,7 +419,7 @@ static MagickBooleanType GlobExpression_(const char *magick_restrict expression,
       */
       GetPathComponent(pattern,SubimagePath,path);
       if (*path != '\0')
-        return(MagickFalse);
+        return(GlobNoMatch);
     }
   while (GetUTFCode(pattern) != 0)
   {
@@ -405,32 +441,33 @@ static MagickBooleanType GlobExpression_(const char *magick_restrict expression,
           pattern+=GetUTFOctets(pattern);
         }
         while (GetUTFCode(pattern) == '*');
+        if (GetUTFCode(pattern) == 0)
+          return(GlobMatched);
         while (1)
         {
+          int
+            status;
+
           /*
             Try to match at each position.
           */
-          if (GlobExpression_(expression,pattern,case_insensitive,depth+1) != MagickFalse)
-            {
-              /*
-                Consume rest of expression and pattern.
-              */
-              while (GetUTFCode(expression) != 0)
-                expression+=GetUTFOctets(expression);
-              while (GetUTFCode(pattern) != 0)
-                pattern+=GetUTFOctets(pattern);
-              return(MagickTrue);
-            }
-            if (GetUTFCode(expression) == 0)
-              break;
-            expression+=GetUTFOctets(expression);
-          }
-        return(MagickFalse);
+          status=GlobExpression_(expression,pattern,case_insensitive,depth+1);
+          if (status != GlobNoMatch)
+            return(status);
+          if (GetUTFCode(expression) == 0)
+            break;
+          expression+=GetUTFOctets(expression);
+        }
+        /*
+          Every suffix of the expression has been tried: no earlier '*' can do
+          better by consuming more.
+        */
+        return(GlobAbort);
       }
       case '?':
       {
         if (ecode == 0)
-          return(MagickFalse);
+          return(GlobNoMatch);
         pattern+=GetUTFOctets(pattern);
         expression+=GetUTFOctets(expression);
         break;
@@ -445,18 +482,30 @@ static MagickBooleanType GlobExpression_(const char *magick_restrict expression,
           matched = MagickFalse;

         if (ecode == 0)
-          return(MagickFalse);
+          return(GlobNoMatch);
+        /*
+          Find the closing ']'; a backslash escapes the next character.
+        */
         while ((GetUTFCode(q) != 0) && (GetUTFCode(q) != ']'))
+        {
+          if (GetUTFCode(q) == '\\')
+            {
+              q+=GetUTFOctets(q);
+              if (GetUTFCode(q) == 0)
+                break;
+            }
           q+=GetUTFOctets(q);
+        }
         if (GetUTFCode(q) == 0)
-          return(MagickFalse);  /* malformed */
+          return(GlobNoMatch);  /* malformed */
         while (p < q)
         {
           const char
             *next;

           int
-            code = GetUTFCode(p);
+            code = GetUTFCode(p),
+            high;

           size_t
             octets = GetUTFOctets(p);
@@ -468,150 +517,125 @@ static MagickBooleanType GlobExpression_(const char *magick_restrict expression,
               octets=GetUTFOctets(p);
             }
           next=p+octets;
+          high=code;
           if ((next < q) && (GetUTFCode(next) == '-'))
             {
-              int
-                ncode;
+              const char
+                *range;

-              next+=GetUTFOctets(next);
-              ncode=GetUTFCode(next);
-              if (ncode == '\\')
+              /*
+                A '-' immediately before the closing ']' is a literal.
+              */
+              range=next+GetUTFOctets(next);
+              if (range < q)
                 {
-                  next+=GetUTFOctets(next);
-                  ncode=GetUTFCode(next);
+                  high=GetUTFCode(range);
+                  if (high == '\\')
+                    {
+                      range+=GetUTFOctets(range);
+                      high=GetUTFCode(range);
+                    }
+                  next=range+GetUTFOctets(range);
                 }
-              if ((ecode >= code) && (ecode <= ncode))
-                matched=MagickTrue;
-              p=next+GetUTFOctets(next);
-            }
-          else
-            {
-              if (ecode == code)
-                matched=MagickTrue;
-              p+=octets;
             }
+          if (GlobInRange(ecode,code,high,case_insensitive) != MagickFalse)
+            matched=MagickTrue;
+          p=next;
         }
-        /*
-          Skip consecutive '*'.
-        */
         if (matched == MagickFalse)
-          return(MagickFalse);
+          return(GlobNoMatch);
         pattern=q+GetUTFOctets(q);  /* skip ']' */
         expression+=GetUTFOctets(expression);
         break;
       }
       case '{':
       {
-        char
-          *a,
-          *alternative;
-
         const char
-          *p,
-          *q;
+          *alternative,
+          *end,
+          *rest;

         size_t
-          remaining = MagickPathExtent;
+          rest_length;

-        pattern+=GetUTFOctets(pattern);  /* Skip '{' */
-        if (GetUTFCode(pattern) == 0)
-          return(MagickFalse);
         /*
-          End of brace expression: append remaining pattern.
+          Locate the closing brace.  Each alternative is matched together with
+          the remainder of the pattern.
         */
-        p=pattern;
-        while ((GetUTFCode(p) != 0) && (GetUTFCode(p) != '}'))
+        alternative=pattern+GetUTFOctets(pattern);  /* skip '{' */
+        end=alternative;
+        while ((GetUTFCode(end) != 0) && (GetUTFCode(end) != '}'))
         {
-#if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
-          if (GetUTFCode(p) == '\\')
+#if defined(MagickGlobEscapes)
+          if (GetUTFCode(end) == '\\')
             {
-              p+=GetUTFOctets(p);
-              if (GetUTFCode(p) == 0)
+              end+=GetUTFOctets(end);
+              if (GetUTFCode(end) == 0)
                 break;
             }
 #endif
-          p+=GetUTFOctets(p);
+          end+=GetUTFOctets(end);
         }
-        if (GetUTFCode(p) != '}')
-          return(MagickFalse);  /* malformed */
-        q=p+GetUTFOctets(p);
-        alternative=AcquireString(pattern);
-        a=alternative;
+        if (GetUTFCode(end) != '}')
+          return(GlobNoMatch);  /* malformed */
+        rest=end+GetUTFOctets(end);
+        rest_length=strlen(rest);
         while (1)
         {
-          int
-            code = GetUTFCode(pattern);
+          char
+            *subpattern;

-          size_t
-            octets;
+          const char
+            *next;

-          if ((code == 0) || (code == ',') || (code == '}'))
-            {
-              char
-                *subpattern;
+          int
+            status;

-              MagickBooleanType
-                match;
+          size_t
+            length;

-              /*
-                Try alternative as a full sub-pattern.
-              */
-              *a='\0';
-              subpattern=AcquireString(alternative);
-              if (ConcatenateString(&subpattern,q) == MagickFalse)
-                {
-                  subpattern=DestroyString(subpattern);
-                  alternative=DestroyString(alternative);
-                  return(MagickFalse);
-                }
-              match=GlobExpression_(expression,subpattern,case_insensitive,
-                depth+1);
-              subpattern=DestroyString(subpattern);
-              if (match != MagickFalse)
-                {
-                  /*
-                    Consume rest of expression and pattern.
-                  */
-                  while (GetUTFCode(expression) != 0)
-                    expression+=GetUTFOctets(expression);
-                  pattern=q;
-                  while (GetUTFCode(pattern) != 0)
-                    pattern+=GetUTFOctets(pattern);
-                  alternative=DestroyString(alternative);
-                  return(MagickTrue);
-                }
-              /*
-                Reset buffer for next alternative.
-              */
-              a=alternative;
-              remaining=MagickPathExtent;
-              if (code == ',')
-                {
-                  pattern+=GetUTFOctets(pattern);  /* skip ',' */
-                  continue;
-                }
-              break;  /* '}' or end */
-            }
           /*
-            Copy UTF-8 sequence into alternative.
+            Find the end of this alternative (an escaped ',' does not split).
           */
-          octets=GetUTFOctets(pattern);
-          if ((octets == 0) || (octets >= remaining))
+          next=alternative;
+          while ((next < end) && (GetUTFCode(next) != ','))
+          {
+#if defined(MagickGlobEscapes)
+            if (GetUTFCode(next) == '\\')
+              next+=GetUTFOctets(next);
+#endif
+            next+=GetUTFOctets(next);
+          }
+          if (next > end)
+            next=end;
+          length=(size_t) (next-alternative);
+          subpattern=(char *) AcquireQuantumMemory(length+rest_length+1,
+            sizeof(*subpattern));
+          if (subpattern == (char *) NULL)
+            {
+              errno=ENOMEM;
+              return(GlobAbort);
+            }
+          (void) memcpy(subpattern,alternative,length);
+          (void) memcpy(subpattern+length,rest,rest_length+1);
+          status=GlobExpression_(expression,subpattern,case_insensitive,
+            depth+1);
+          subpattern=(char *) RelinquishMagickMemory(subpattern);
+          if (status == GlobMatched)
+            return(GlobMatched);
+          if (next >= end)
             break;
-          (void) memcpy(a,pattern,octets);
-          a+=octets;
-          remaining-=octets;
-          pattern+=octets;
+          alternative=next+GetUTFOctets(next);  /* skip ',' */
         }
-        alternative=DestroyString(alternative);
-        return(MagickFalse);
+        return(GlobNoMatch);
       }
-#if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
+#if defined(MagickGlobEscapes)
       case '\\':
       {
         pattern+=GetUTFOctets(pattern);
-        if (GetUTFCode(pattern) == 0)
-          return(MagickFalse);
+        pcode=GetUTFCode(pattern);
+        if (pcode == 0)
+          return(GlobNoMatch);
         magick_fallthrough;
       }
 #endif
@@ -622,14 +646,14 @@ static MagickBooleanType GlobExpression_(const char *magick_restrict expression,
           pc = pcode;

         if (ecode == 0)
-          return(MagickFalse);
+          return(GlobNoMatch);
         if (case_insensitive != MagickFalse)
           {
-            pc=LocaleToLowercase(pc);
-            ec=LocaleToLowercase(ec);
+            pc=GlobFoldCase(pc);
+            ec=GlobFoldCase(ec);
           }
         if (pc != ec)
-          return(MagickFalse);
+          return(GlobNoMatch);
         pattern+=GetUTFOctets(pattern);
         expression+=GetUTFOctets(expression);
         break;
@@ -639,14 +663,21 @@ static MagickBooleanType GlobExpression_(const char *magick_restrict expression,
   while (GetUTFCode(pattern) == '*')
     pattern+=GetUTFOctets(pattern);
   return(((GetUTFCode(expression) == 0) &&
-          (GetUTFCode(pattern) == 0)) ? MagickTrue : MagickFalse);
+          (GetUTFCode(pattern) == 0)) ? GlobMatched : GlobNoMatch);
 }

 MagickExport MagickBooleanType GlobExpression(
   const char *magick_restrict expression,const char *magick_restrict pattern,
   const MagickBooleanType case_insensitive)
 {
-  return(GlobExpression_(expression,pattern,case_insensitive,0));
+  if (pattern == (const char *) NULL)
+    return(MagickTrue);
+  if (GetUTFCode(pattern) == 0)
+    return(MagickTrue);
+  if (expression == (const char *) NULL)
+    return(MagickFalse);
+  return(GlobExpression_(expression,pattern,case_insensitive,0) == GlobMatched ?
+    MagickTrue : MagickFalse);
 }

 /*
@@ -665,7 +696,7 @@ MagickExport MagickBooleanType GlobExpression(
 %
 %  The format of the IsGlob method is:
 %
-%      MagickBooleanType IsGlob(const char *geometry)
+%      MagickBooleanType IsGlob(const char *path)
 %
 %  A description of each parameter follows:
 %
@@ -674,12 +705,10 @@ MagickExport MagickBooleanType GlobExpression(
 */
 MagickPrivate MagickBooleanType IsGlob(const char *path)
 {
-  MagickBooleanType
-    status = MagickFalse;
-
   const char
     *p;

+  assert(path != (const char *) NULL);
   if (IsPathAccessible(path) != MagickFalse)
     return(MagickFalse);
   for (p=path; *p != '\0'; p++)
@@ -692,15 +721,12 @@ MagickPrivate MagickBooleanType IsGlob(const char *path)
       case '}':
       case '[':
       case ']':
-      {
-        status=MagickTrue;
-        break;
-      }
+        return(MagickTrue);
       default:
         break;
     }
   }
-  return(status);
+  return(MagickFalse);
 }

 /*
@@ -725,7 +751,7 @@ MagickPrivate MagickBooleanType IsGlob(const char *path)
 %    o token: A single unit of information in the form of a group of
 %      characters.
 %
-%    o white space: Apace that gets ignored (except within quotes or when
+%    o white space: Space that gets ignored (except within quotes or when
 %      escaped), like blanks and tabs. in addition, white space terminates a
 %      non-quoted token.
 %
@@ -797,7 +823,7 @@ MagickPrivate MagickBooleanType IsGlob(const char *path)
 %
 %  A description of each parameter follows:
 %
-%    o flag: right now, only the low order 3 bits are used.
+%    o flag: right now, only the low order 2 bits are used.
 %
 %        1 => convert non-quoted tokens to upper case
 %        2 => convert non-quoted tokens to lower case
@@ -824,7 +850,7 @@ MagickPrivate MagickBooleanType IsGlob(const char *path)
 %
 %    o quote: a string of the valid quote characters. An example would be
 %
-%        char whitesp[]={"'\"");
+%        char quotes[]={"'\""};
 %
 %      (this causes single and double quotes to be valid) Note that a
 %      token starting with one of these characters needs the same quote
@@ -898,12 +924,12 @@ static void StoreToken(TokenInfo *token_info,char *string,
   {
     case 1:
     {
-      string[i]=(char) LocaleToUppercase(c);
+      string[i]=(char) LocaleToUppercase((int) ((unsigned char) c));
       break;
     }
     case 2:
     {
-      string[i]=(char) LocaleToLowercase(c);
+      string[i]=(char) LocaleToLowercase((int) ((unsigned char) c));
       break;
     }
     default:
@@ -922,6 +948,17 @@ MagickExport int Tokenizer(TokenInfo *token_info,const unsigned flag,
   ssize_t
     i;

+  assert(token_info != (TokenInfo *) NULL);
+  assert(token_info->signature == MagickCoreSignature);
+  assert(token != (char *) NULL);
+  assert(max_token_length != 0);
+  assert(line != (const char *) NULL);
+  assert(white != (const char *) NULL);
+  assert(break_set != (const char *) NULL);
+  assert(quote != (const char *) NULL);
+  assert(breaker != (char *) NULL);
+  assert(next != (int *) NULL);
+  assert(quoted != (char *) NULL);
   *breaker='\0';
   *quoted='\0';
   if (line[*next] == '\0')