1 /*************************************************
2 *      Perl-Compatible Regular Expressions       *
3 *************************************************/
4 
5 /* PCRE is a library of functions to support regular expressions whose syntax
6 and semantics are as close as possible to those of the Perl 5 language.
7 
8                        Written by Philip Hazel
9      Original API code Copyright (c) 1997-2012 University of Cambridge
10           New API code Copyright (c) 2016-2018 University of Cambridge
11 
12 -----------------------------------------------------------------------------
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions are met:
15 
16     * Redistributions of source code must retain the above copyright notice,
17       this list of conditions and the following disclaimer.
18 
19     * Redistributions in binary form must reproduce the above copyright
20       notice, this list of conditions and the following disclaimer in the
21       documentation and/or other materials provided with the distribution.
22 
23     * Neither the name of the University of Cambridge nor the names of its
24       contributors may be used to endorse or promote products derived from
25       this software without specific prior written permission.
26 
27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 POSSIBILITY OF SUCH DAMAGE.
38 -----------------------------------------------------------------------------
39 */
40 
41 
42 #ifdef HAVE_CONFIG_H
43 #include "config.h"
44 #endif
45 
46 #include "pcre2_internal.h"
47 
48 #define TYPE_OPTIONS (PCRE2_CONVERT_GLOB| \
49   PCRE2_CONVERT_POSIX_BASIC|PCRE2_CONVERT_POSIX_EXTENDED)
50 
51 #define ALL_OPTIONS (PCRE2_CONVERT_UTF|PCRE2_CONVERT_NO_UTF_CHECK| \
52   PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR| \
53   PCRE2_CONVERT_GLOB_NO_STARSTAR| \
54   TYPE_OPTIONS)
55 
56 #define DUMMY_BUFFER_SIZE 100
57 
58 /* Generated pattern fragments */
59 
60 #define STR_BACKSLASH_A STR_BACKSLASH STR_A
61 #define STR_BACKSLASH_z STR_BACKSLASH STR_z
62 #define STR_COLON_RIGHT_SQUARE_BRACKET STR_COLON STR_RIGHT_SQUARE_BRACKET
63 #define STR_DOT_STAR_LOOKBEHIND STR_DOT STR_ASTERISK STR_LEFT_PARENTHESIS STR_QUESTION_MARK STR_LESS_THAN_SIGN STR_EQUALS_SIGN
64 #define STR_LOOKAHEAD_NOT_DOT STR_LEFT_PARENTHESIS STR_QUESTION_MARK STR_EXCLAMATION_MARK STR_BACKSLASH STR_DOT STR_RIGHT_PARENTHESIS
65 #define STR_QUERY_s STR_LEFT_PARENTHESIS STR_QUESTION_MARK STR_s STR_RIGHT_PARENTHESIS
66 #define STR_STAR_NUL STR_LEFT_PARENTHESIS STR_ASTERISK STR_N STR_U STR_L STR_RIGHT_PARENTHESIS
67 
68 /* States for range and POSIX processing */
69 
70 enum { RANGE_NOT_STARTED, RANGE_STARTING, RANGE_STARTED };
71 enum { POSIX_START_REGEX, POSIX_ANCHORED, POSIX_NOT_BRACKET,
72        POSIX_CLASS_NOT_STARTED, POSIX_CLASS_STARTING, POSIX_CLASS_STARTED };
73 
74 /* Macro to add a character string to the output buffer, checking for overflow. */
75 
76 #define PUTCHARS(string) \
77   { \
78   for (s = (char *)(string); *s != 0; s++) \
79     { \
80     if (p >= endp) return PCRE2_ERROR_NOMEMORY; \
81     *p++ = *s; \
82     } \
83   }
84 
85 /* Literals that must be escaped: \ ? * + | . ^ $ { } [ ] ( ) */
86 
87 static const char *pcre2_escaped_literals =
88   STR_BACKSLASH STR_QUESTION_MARK STR_ASTERISK STR_PLUS
89   STR_VERTICAL_LINE STR_DOT STR_CIRCUMFLEX_ACCENT STR_DOLLAR_SIGN
90   STR_LEFT_CURLY_BRACKET STR_RIGHT_CURLY_BRACKET
91   STR_LEFT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET
92   STR_LEFT_PARENTHESIS STR_RIGHT_PARENTHESIS;
93 
94 /* Recognized escaped metacharacters in POSIX basic patterns. */
95 
96 static const char *posix_meta_escapes =
97   STR_LEFT_PARENTHESIS STR_RIGHT_PARENTHESIS
98   STR_LEFT_CURLY_BRACKET STR_RIGHT_CURLY_BRACKET
99   STR_1 STR_2 STR_3 STR_4 STR_5 STR_6 STR_7 STR_8 STR_9;
100 
101 
102 
103 /*************************************************
104 *           Convert a POSIX pattern              *
105 *************************************************/
106 
107 /* This function handles both basic and extended POSIX patterns.
108 
109 Arguments:
110   pattype        the pattern type
111   pattern        the pattern
112   plength        length in code units
113   utf            TRUE if UTF
114   use_buffer     where to put the output
115   use_length     length of use_buffer
116   bufflenptr     where to put the used length
117   dummyrun       TRUE if a dummy run
118   ccontext       the convert context
119 
120 Returns:         0 => success
121                 !0 => error code
122 */
123 
124 static int
convert_posix(uint32_t pattype,PCRE2_SPTR pattern,PCRE2_SIZE plength,BOOL utf,PCRE2_UCHAR * use_buffer,PCRE2_SIZE use_length,PCRE2_SIZE * bufflenptr,BOOL dummyrun,pcre2_convert_context * ccontext)125 convert_posix(uint32_t pattype, PCRE2_SPTR pattern, PCRE2_SIZE plength,
126   BOOL utf, PCRE2_UCHAR *use_buffer, PCRE2_SIZE use_length,
127   PCRE2_SIZE *bufflenptr, BOOL dummyrun, pcre2_convert_context *ccontext)
128 {
129 char *s;
130 PCRE2_SPTR posix = pattern;
131 PCRE2_UCHAR *p = use_buffer;
132 PCRE2_UCHAR *pp = p;
133 PCRE2_UCHAR *endp = p + use_length - 1;  /* Allow for trailing zero */
134 PCRE2_SIZE convlength = 0;
135 
136 uint32_t bracount = 0;
137 uint32_t posix_state = POSIX_START_REGEX;
138 uint32_t lastspecial = 0;
139 BOOL extended = (pattype & PCRE2_CONVERT_POSIX_EXTENDED) != 0;
140 BOOL nextisliteral = FALSE;
141 
142 (void)utf;       /* Not used when Unicode not supported */
143 (void)ccontext;  /* Not currently used */
144 
145 /* Initialize default for error offset as end of input. */
146 
147 *bufflenptr = plength;
148 PUTCHARS(STR_STAR_NUL);
149 
150 /* Now scan the input. */
151 
152 while (plength > 0)
153   {
154   uint32_t c, sc;
155   int clength = 1;
156 
157   /* Add in the length of the last item, then, if in the dummy run, pull the
158   pointer back to the start of the (temporary) buffer and then remember the
159   start of the next item. */
160 
161   convlength += p - pp;
162   if (dummyrun) p = use_buffer;
163   pp = p;
164 
165   /* Pick up the next character */
166 
167 #ifndef SUPPORT_UNICODE
168   c = *posix;
169 #else
170   GETCHARLENTEST(c, posix, clength);
171 #endif
172   posix += clength;
173   plength -= clength;
174 
175   sc = nextisliteral? 0 : c;
176   nextisliteral = FALSE;
177 
178   /* Handle a character within a class. */
179 
180   if (posix_state >= POSIX_CLASS_NOT_STARTED)
181     {
182     if (c == CHAR_RIGHT_SQUARE_BRACKET)
183       {
184       PUTCHARS(STR_RIGHT_SQUARE_BRACKET);
185       posix_state = POSIX_NOT_BRACKET;
186       }
187 
188     /* Not the end of the class */
189 
190     else
191       {
192       switch (posix_state)
193         {
194         case POSIX_CLASS_STARTED:
195         if (c <= 127 && islower(c)) break;  /* Remain in started state */
196         posix_state = POSIX_CLASS_NOT_STARTED;
197         if (c == CHAR_COLON  && plength > 0 &&
198             *posix == CHAR_RIGHT_SQUARE_BRACKET)
199           {
200           PUTCHARS(STR_COLON_RIGHT_SQUARE_BRACKET);
201           plength--;
202           posix++;
203           continue;    /* With next character after :] */
204           }
205         /* Fall through */
206 
207         case POSIX_CLASS_NOT_STARTED:
208         if (c == CHAR_LEFT_SQUARE_BRACKET)
209           posix_state = POSIX_CLASS_STARTING;
210         break;
211 
212         case POSIX_CLASS_STARTING:
213         if (c == CHAR_COLON) posix_state = POSIX_CLASS_STARTED;
214         break;
215         }
216 
217       if (c == CHAR_BACKSLASH) PUTCHARS(STR_BACKSLASH);
218       if (p + clength > endp) return PCRE2_ERROR_NOMEMORY;
219       memcpy(p, posix - clength, CU2BYTES(clength));
220       p += clength;
221       }
222     }
223 
224   /* Handle a character not within a class. */
225 
226   else switch(sc)
227     {
228     case CHAR_LEFT_SQUARE_BRACKET:
229     PUTCHARS(STR_LEFT_SQUARE_BRACKET);
230 
231 #ifdef NEVER
232     /* We could handle special cases [[:<:]] and [[:>:]] (which PCRE does
233     support) but they are not part of POSIX 1003.1. */
234 
235     if (plength >= 6)
236       {
237       if (posix[0] == CHAR_LEFT_SQUARE_BRACKET &&
238           posix[1] == CHAR_COLON &&
239           (posix[2] == CHAR_LESS_THAN_SIGN ||
240            posix[2] == CHAR_GREATER_THAN_SIGN) &&
241           posix[3] == CHAR_COLON &&
242           posix[4] == CHAR_RIGHT_SQUARE_BRACKET &&
243           posix[5] == CHAR_RIGHT_SQUARE_BRACKET)
244         {
245         if (p + 6 > endp) return PCRE2_ERROR_NOMEMORY;
246         memcpy(p, posix, CU2BYTES(6));
247         p += 6;
248         posix += 6;
249         plength -= 6;
250         continue;  /* With next character */
251         }
252       }
253 #endif
254 
255     /* Handle start of "normal" character classes */
256 
257     posix_state = POSIX_CLASS_NOT_STARTED;
258 
259     /* Handle ^ and ] as first characters */
260 
261     if (plength > 0)
262       {
263       if (*posix == CHAR_CIRCUMFLEX_ACCENT)
264         {
265         posix++;
266         plength--;
267         PUTCHARS(STR_CIRCUMFLEX_ACCENT);
268         }
269       if (plength > 0 && *posix == CHAR_RIGHT_SQUARE_BRACKET)
270         {
271         posix++;
272         plength--;
273         PUTCHARS(STR_RIGHT_SQUARE_BRACKET);
274         }
275       }
276     break;
277 
278     case CHAR_BACKSLASH:
279     if (plength == 0) return PCRE2_ERROR_END_BACKSLASH;
280     if (extended) nextisliteral = TRUE; else
281       {
282       if (*posix < 127 && strchr(posix_meta_escapes, *posix) != NULL)
283         {
284         if (isdigit(*posix)) PUTCHARS(STR_BACKSLASH);
285         if (p + 1 > endp) return PCRE2_ERROR_NOMEMORY;
286         lastspecial = *p++ = *posix++;
287         plength--;
288         }
289       else nextisliteral = TRUE;
290       }
291     break;
292 
293     case CHAR_RIGHT_PARENTHESIS:
294     if (!extended || bracount == 0) goto ESCAPE_LITERAL;
295     bracount--;
296     goto COPY_SPECIAL;
297 
298     case CHAR_LEFT_PARENTHESIS:
299     bracount++;
300     /* Fall through */
301 
302     case CHAR_QUESTION_MARK:
303     case CHAR_PLUS:
304     case CHAR_LEFT_CURLY_BRACKET:
305     case CHAR_RIGHT_CURLY_BRACKET:
306     case CHAR_VERTICAL_LINE:
307     if (!extended) goto ESCAPE_LITERAL;
308     /* Fall through */
309 
310     case CHAR_DOT:
311     case CHAR_DOLLAR_SIGN:
312     posix_state = POSIX_NOT_BRACKET;
313     COPY_SPECIAL:
314     lastspecial = c;
315     if (p + 1 > endp) return PCRE2_ERROR_NOMEMORY;
316     *p++ = c;
317     break;
318 
319     case CHAR_ASTERISK:
320     if (lastspecial != CHAR_ASTERISK)
321       {
322       if (!extended && (posix_state < POSIX_NOT_BRACKET ||
323           lastspecial == CHAR_LEFT_PARENTHESIS))
324         goto ESCAPE_LITERAL;
325       goto COPY_SPECIAL;
326       }
327     break;   /* Ignore second and subsequent asterisks */
328 
329     case CHAR_CIRCUMFLEX_ACCENT:
330     if (extended) goto COPY_SPECIAL;
331     if (posix_state == POSIX_START_REGEX ||
332         lastspecial == CHAR_LEFT_PARENTHESIS)
333       {
334       posix_state = POSIX_ANCHORED;
335       goto COPY_SPECIAL;
336       }
337     /* Fall through */
338 
339     default:
340     if (c < 128 && strchr(pcre2_escaped_literals, c) != NULL)
341       {
342       ESCAPE_LITERAL:
343       PUTCHARS(STR_BACKSLASH);
344       }
345     lastspecial = 0xff;  /* Indicates nothing special */
346     if (p + clength > endp) return PCRE2_ERROR_NOMEMORY;
347     memcpy(p, posix - clength, CU2BYTES(clength));
348     p += clength;
349     posix_state = POSIX_NOT_BRACKET;
350     break;
351     }
352   }
353 
354 if (posix_state >= POSIX_CLASS_NOT_STARTED)
355   return PCRE2_ERROR_MISSING_SQUARE_BRACKET;
356 convlength += p - pp;        /* Final segment */
357 *bufflenptr = convlength;
358 *p++ = 0;
359 return 0;
360 }
361 
362 
363 /*************************************************
364 *           Convert a glob pattern               *
365 *************************************************/
366 
367 /* Context for writing the output into a buffer. */
368 
369 typedef struct pcre2_output_context {
370   PCRE2_UCHAR *output;                  /* current output position */
371   PCRE2_SPTR output_end;                /* output end */
372   PCRE2_SIZE output_size;               /* size of the output */
373   uint8_t out_str[8];                   /* string copied to the output */
374 } pcre2_output_context;
375 
376 
377 /* Write a character into the output.
378 
379 Arguments:
380   out            output context
381   chr            the next character
382 */
383 
384 static void
convert_glob_write(pcre2_output_context * out,PCRE2_UCHAR chr)385 convert_glob_write(pcre2_output_context *out, PCRE2_UCHAR chr)
386 {
387 out->output_size++;
388 
389 if (out->output < out->output_end)
390   *out->output++ = chr;
391 }
392 
393 
394 /* Write a string into the output.
395 
396 Arguments:
397   out            output context
398   length         length of out->out_str
399 */
400 
401 static void
convert_glob_write_str(pcre2_output_context * out,PCRE2_SIZE length)402 convert_glob_write_str(pcre2_output_context *out, PCRE2_SIZE length)
403 {
404 uint8_t *out_str = out->out_str;
405 PCRE2_UCHAR *output = out->output;
406 PCRE2_SPTR output_end = out->output_end;
407 PCRE2_SIZE output_size = out->output_size;
408 
409 do
410   {
411   output_size++;
412 
413   if (output < output_end)
414     *output++ = *out_str++;
415   }
416 while (--length != 0);
417 
418 out->output = output;
419 out->output_size = output_size;
420 }
421 
422 
423 /* Prints the separator into the output.
424 
425 Arguments:
426   out            output context
427   separator      glob separator
428   with_escape    backslash is needed before separator
429 */
430 
431 static void
convert_glob_print_separator(pcre2_output_context * out,PCRE2_UCHAR separator,BOOL with_escape)432 convert_glob_print_separator(pcre2_output_context *out,
433   PCRE2_UCHAR separator, BOOL with_escape)
434 {
435 if (with_escape)
436   convert_glob_write(out, CHAR_BACKSLASH);
437 
438 convert_glob_write(out, separator);
439 }
440 
441 
442 /* Prints a wildcard into the output.
443 
444 Arguments:
445   out            output context
446   separator      glob separator
447   with_escape    backslash is needed before separator
448 */
449 
450 static void
convert_glob_print_wildcard(pcre2_output_context * out,PCRE2_UCHAR separator,BOOL with_escape)451 convert_glob_print_wildcard(pcre2_output_context *out,
452   PCRE2_UCHAR separator, BOOL with_escape)
453 {
454 out->out_str[0] = CHAR_LEFT_SQUARE_BRACKET;
455 out->out_str[1] = CHAR_CIRCUMFLEX_ACCENT;
456 convert_glob_write_str(out, 2);
457 
458 convert_glob_print_separator(out, separator, with_escape);
459 
460 convert_glob_write(out, CHAR_RIGHT_SQUARE_BRACKET);
461 }
462 
463 
464 /* Parse a posix class.
465 
466 Arguments:
467   from           starting point of scanning the range
468   pattern_end    end of pattern
469   out            output context
470 
471 Returns:  >0 => class index
472           0  => malformed class
473 */
474 
475 static int
convert_glob_parse_class(PCRE2_SPTR * from,PCRE2_SPTR pattern_end,pcre2_output_context * out)476 convert_glob_parse_class(PCRE2_SPTR *from, PCRE2_SPTR pattern_end,
477   pcre2_output_context *out)
478 {
479 static const char *posix_classes = "alnum:alpha:ascii:blank:cntrl:digit:"
480   "graph:lower:print:punct:space:upper:word:xdigit:";
481 PCRE2_SPTR start = *from + 1;
482 PCRE2_SPTR pattern = start;
483 const char *class_ptr;
484 PCRE2_UCHAR c;
485 int class_index;
486 
487 while (TRUE)
488   {
489   if (pattern >= pattern_end) return 0;
490 
491   c = *pattern++;
492 
493   if (c < CHAR_a || c > CHAR_z) break;
494   }
495 
496 if (c != CHAR_COLON || pattern >= pattern_end ||
497     *pattern != CHAR_RIGHT_SQUARE_BRACKET)
498   return 0;
499 
500 class_ptr = posix_classes;
501 class_index = 1;
502 
503 while (TRUE)
504   {
505   if (*class_ptr == CHAR_NUL) return 0;
506 
507   pattern = start;
508 
509   while (*pattern == (PCRE2_UCHAR) *class_ptr)
510     {
511     if (*pattern == CHAR_COLON)
512       {
513       pattern += 2;
514       start -= 2;
515 
516       do convert_glob_write(out, *start++); while (start < pattern);
517 
518       *from = pattern;
519       return class_index;
520       }
521     pattern++;
522     class_ptr++;
523     }
524 
525   while (*class_ptr != CHAR_COLON) class_ptr++;
526   class_ptr++;
527   class_index++;
528   }
529 }
530 
531 /* Checks whether the character is in the class.
532 
533 Arguments:
534   class_index    class index
535   c              character
536 
537 Returns:   !0 => character is found in the class
538             0 => otherwise
539 */
540 
541 static BOOL
convert_glob_char_in_class(int class_index,PCRE2_UCHAR c)542 convert_glob_char_in_class(int class_index, PCRE2_UCHAR c)
543 {
544 switch (class_index)
545   {
546   case 1: return isalnum(c);
547   case 2: return isalpha(c);
548   case 3: return 1;
549   case 4: return c == CHAR_HT || c == CHAR_SPACE;
550   case 5: return iscntrl(c);
551   case 6: return isdigit(c);
552   case 7: return isgraph(c);
553   case 8: return islower(c);
554   case 9: return isprint(c);
555   case 10: return ispunct(c);
556   case 11: return isspace(c);
557   case 12: return isupper(c);
558   case 13: return isalnum(c) || c == CHAR_UNDERSCORE;
559   default: return isxdigit(c);
560   }
561 }
562 
563 /* Parse a range of characters.
564 
565 Arguments:
566   from           starting point of scanning the range
567   pattern_end    end of pattern
568   out            output context
569   separator      glob separator
570   with_escape    backslash is needed before separator
571 
572 Returns:         0 => success
573                 !0 => error code
574 */
575 
576 static int
convert_glob_parse_range(PCRE2_SPTR * from,PCRE2_SPTR pattern_end,pcre2_output_context * out,BOOL utf,PCRE2_UCHAR separator,BOOL with_escape,PCRE2_UCHAR escape,BOOL no_wildsep)577 convert_glob_parse_range(PCRE2_SPTR *from, PCRE2_SPTR pattern_end,
578   pcre2_output_context *out, BOOL utf, PCRE2_UCHAR separator,
579   BOOL with_escape, PCRE2_UCHAR escape, BOOL no_wildsep)
580 {
581 BOOL is_negative = FALSE;
582 BOOL separator_seen = FALSE;
583 BOOL has_prev_c;
584 PCRE2_SPTR pattern = *from;
585 PCRE2_SPTR char_start = NULL;
586 uint32_t c, prev_c;
587 int len, class_index;
588 
589 (void)utf; /* Avoid compiler warning. */
590 
591 if (pattern >= pattern_end)
592   {
593   *from = pattern;
594   return PCRE2_ERROR_MISSING_SQUARE_BRACKET;
595   }
596 
597 if (*pattern == CHAR_EXCLAMATION_MARK
598     || *pattern == CHAR_CIRCUMFLEX_ACCENT)
599   {
600   pattern++;
601 
602   if (pattern >= pattern_end)
603     {
604     *from = pattern;
605     return PCRE2_ERROR_MISSING_SQUARE_BRACKET;
606     }
607 
608   is_negative = TRUE;
609 
610   out->out_str[0] = CHAR_LEFT_SQUARE_BRACKET;
611   out->out_str[1] = CHAR_CIRCUMFLEX_ACCENT;
612   len = 2;
613 
614   if (!no_wildsep)
615     {
616     if (with_escape)
617       {
618       out->out_str[len] = CHAR_BACKSLASH;
619       len++;
620       }
621     out->out_str[len] = (uint8_t) separator;
622     }
623 
624   convert_glob_write_str(out, len + 1);
625   }
626 else
627   convert_glob_write(out, CHAR_LEFT_SQUARE_BRACKET);
628 
629 has_prev_c = FALSE;
630 prev_c = 0;
631 
632 if (*pattern == CHAR_RIGHT_SQUARE_BRACKET)
633   {
634   out->out_str[0] = CHAR_BACKSLASH;
635   out->out_str[1] = CHAR_RIGHT_SQUARE_BRACKET;
636   convert_glob_write_str(out, 2);
637   has_prev_c = TRUE;
638   prev_c = CHAR_RIGHT_SQUARE_BRACKET;
639   pattern++;
640   }
641 
642 while (pattern < pattern_end)
643   {
644   char_start = pattern;
645   GETCHARINCTEST(c, pattern);
646 
647   if (c == CHAR_RIGHT_SQUARE_BRACKET)
648     {
649     convert_glob_write(out, c);
650 
651     if (!is_negative && !no_wildsep && separator_seen)
652       {
653       out->out_str[0] = CHAR_LEFT_PARENTHESIS;
654       out->out_str[1] = CHAR_QUESTION_MARK;
655       out->out_str[2] = CHAR_LESS_THAN_SIGN;
656       out->out_str[3] = CHAR_EXCLAMATION_MARK;
657       convert_glob_write_str(out, 4);
658 
659       convert_glob_print_separator(out, separator, with_escape);
660       convert_glob_write(out, CHAR_RIGHT_PARENTHESIS);
661       }
662 
663     *from = pattern;
664     return 0;
665     }
666 
667   if (pattern >= pattern_end) break;
668 
669   if (c == CHAR_LEFT_SQUARE_BRACKET && *pattern == CHAR_COLON)
670     {
671     *from = pattern;
672     class_index = convert_glob_parse_class(from, pattern_end, out);
673 
674     if (class_index != 0)
675       {
676       pattern = *from;
677 
678       has_prev_c = FALSE;
679       prev_c = 0;
680 
681       if (!is_negative &&
682           convert_glob_char_in_class (class_index, separator))
683         separator_seen = TRUE;
684       continue;
685       }
686     }
687   else if (c == CHAR_MINUS && has_prev_c &&
688            *pattern != CHAR_RIGHT_SQUARE_BRACKET)
689     {
690     convert_glob_write(out, CHAR_MINUS);
691 
692     char_start = pattern;
693     GETCHARINCTEST(c, pattern);
694 
695     if (pattern >= pattern_end) break;
696 
697     if (escape != 0 && c == escape)
698       {
699       char_start = pattern;
700       GETCHARINCTEST(c, pattern);
701       }
702     else if (c == CHAR_LEFT_SQUARE_BRACKET && *pattern == CHAR_COLON)
703       {
704       *from = pattern;
705       return PCRE2_ERROR_CONVERT_SYNTAX;
706       }
707 
708     if (prev_c > c)
709       {
710       *from = pattern;
711       return PCRE2_ERROR_CONVERT_SYNTAX;
712       }
713 
714     if (prev_c < separator && separator < c) separator_seen = TRUE;
715 
716     has_prev_c = FALSE;
717     prev_c = 0;
718     }
719   else
720     {
721     if (escape != 0 && c == escape)
722       {
723       char_start = pattern;
724       GETCHARINCTEST(c, pattern);
725 
726       if (pattern >= pattern_end) break;
727       }
728 
729     has_prev_c = TRUE;
730     prev_c = c;
731     }
732 
733   if (c == CHAR_LEFT_SQUARE_BRACKET || c == CHAR_RIGHT_SQUARE_BRACKET ||
734       c == CHAR_BACKSLASH || c == CHAR_MINUS)
735     convert_glob_write(out, CHAR_BACKSLASH);
736 
737   if (c == separator) separator_seen = TRUE;
738 
739   do convert_glob_write(out, *char_start++); while (char_start < pattern);
740   }
741 
742 *from = pattern;
743 return PCRE2_ERROR_MISSING_SQUARE_BRACKET;
744 }
745 
746 
747 /* Prints a (*COMMIT) into the output.
748 
749 Arguments:
750   out            output context
751 */
752 
753 static void
convert_glob_print_commit(pcre2_output_context * out)754 convert_glob_print_commit(pcre2_output_context *out)
755 {
756 out->out_str[0] = CHAR_LEFT_PARENTHESIS;
757 out->out_str[1] = CHAR_ASTERISK;
758 out->out_str[2] = CHAR_C;
759 out->out_str[3] = CHAR_O;
760 out->out_str[4] = CHAR_M;
761 out->out_str[5] = CHAR_M;
762 out->out_str[6] = CHAR_I;
763 out->out_str[7] = CHAR_T;
764 convert_glob_write_str(out, 8);
765 convert_glob_write(out, CHAR_RIGHT_PARENTHESIS);
766 }
767 
768 
769 /* Bash glob converter.
770 
771 Arguments:
772   pattype        the pattern type
773   pattern        the pattern
774   plength        length in code units
775   utf            TRUE if UTF
776   use_buffer     where to put the output
777   use_length     length of use_buffer
778   bufflenptr     where to put the used length
779   dummyrun       TRUE if a dummy run
780   ccontext       the convert context
781 
782 Returns:         0 => success
783                 !0 => error code
784 */
785 
786 static int
convert_glob(uint32_t options,PCRE2_SPTR pattern,PCRE2_SIZE plength,BOOL utf,PCRE2_UCHAR * use_buffer,PCRE2_SIZE use_length,PCRE2_SIZE * bufflenptr,BOOL dummyrun,pcre2_convert_context * ccontext)787 convert_glob(uint32_t options, PCRE2_SPTR pattern, PCRE2_SIZE plength,
788   BOOL utf, PCRE2_UCHAR *use_buffer, PCRE2_SIZE use_length,
789   PCRE2_SIZE *bufflenptr, BOOL dummyrun, pcre2_convert_context *ccontext)
790 {
791 pcre2_output_context out;
792 PCRE2_SPTR pattern_start = pattern;
793 PCRE2_SPTR pattern_end = pattern + plength;
794 PCRE2_UCHAR separator = ccontext->glob_separator;
795 PCRE2_UCHAR escape = ccontext->glob_escape;
796 PCRE2_UCHAR c;
797 BOOL no_wildsep = (options & PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR) != 0;
798 BOOL no_starstar = (options & PCRE2_CONVERT_GLOB_NO_STARSTAR) != 0;
799 BOOL in_atomic = FALSE;
800 BOOL after_starstar = FALSE;
801 BOOL no_slash_z = FALSE;
802 BOOL with_escape, is_start, after_separator;
803 int result = 0;
804 
805 (void)utf; /* Avoid compiler warning. */
806 
807 #ifdef SUPPORT_UNICODE
808 if (utf && (separator >= 128 || escape >= 128))
809   {
810   /* Currently only ASCII characters are supported. */
811   *bufflenptr = 0;
812   return PCRE2_ERROR_CONVERT_SYNTAX;
813   }
814 #endif
815 
816 with_escape = strchr(pcre2_escaped_literals, separator) != NULL;
817 
818 /* Initialize default for error offset as end of input. */
819 out.output = use_buffer;
820 out.output_end = use_buffer + use_length;
821 out.output_size = 0;
822 
823 out.out_str[0] = CHAR_LEFT_PARENTHESIS;
824 out.out_str[1] = CHAR_QUESTION_MARK;
825 out.out_str[2] = CHAR_s;
826 out.out_str[3] = CHAR_RIGHT_PARENTHESIS;
827 convert_glob_write_str(&out, 4);
828 
829 is_start = TRUE;
830 
831 if (pattern < pattern_end && pattern[0] == CHAR_ASTERISK)
832   {
833   if (no_wildsep)
834     is_start = FALSE;
835   else if (!no_starstar && pattern + 1 < pattern_end &&
836            pattern[1] == CHAR_ASTERISK)
837     is_start = FALSE;
838   }
839 
840 if (is_start)
841   {
842   out.out_str[0] = CHAR_BACKSLASH;
843   out.out_str[1] = CHAR_A;
844   convert_glob_write_str(&out, 2);
845   }
846 
847 while (pattern < pattern_end)
848   {
849   c = *pattern++;
850 
851   if (c == CHAR_ASTERISK)
852     {
853     is_start = pattern == pattern_start + 1;
854 
855     if (in_atomic)
856       {
857       convert_glob_write(&out, CHAR_RIGHT_PARENTHESIS);
858       in_atomic = FALSE;
859       }
860 
861     if (!no_starstar && pattern < pattern_end && *pattern == CHAR_ASTERISK)
862       {
863       after_separator = is_start || (pattern[-2] == separator);
864 
865       do pattern++; while (pattern < pattern_end &&
866                            *pattern == CHAR_ASTERISK);
867 
868       if (pattern >= pattern_end)
869         {
870         no_slash_z = TRUE;
871         break;
872         }
873 
874       after_starstar = TRUE;
875 
876       if (after_separator && escape != 0 && *pattern == escape &&
877           pattern + 1 < pattern_end && pattern[1] == separator)
878         pattern++;
879 
880       if (is_start)
881         {
882         if (*pattern != separator) continue;
883 
884         out.out_str[0] = CHAR_LEFT_PARENTHESIS;
885         out.out_str[1] = CHAR_QUESTION_MARK;
886         out.out_str[2] = CHAR_COLON;
887         out.out_str[3] = CHAR_BACKSLASH;
888         out.out_str[4] = CHAR_A;
889         out.out_str[5] = CHAR_VERTICAL_LINE;
890         convert_glob_write_str(&out, 6);
891 
892         convert_glob_print_separator(&out, separator, with_escape);
893         convert_glob_write(&out, CHAR_RIGHT_PARENTHESIS);
894 
895         pattern++;
896         continue;
897         }
898 
899       convert_glob_print_commit(&out);
900 
901       if (!after_separator || *pattern != separator)
902         {
903         out.out_str[0] = CHAR_DOT;
904         out.out_str[1] = CHAR_ASTERISK;
905         out.out_str[2] = CHAR_QUESTION_MARK;
906         convert_glob_write_str(&out, 3);
907         continue;
908         }
909 
910       out.out_str[0] = CHAR_LEFT_PARENTHESIS;
911       out.out_str[1] = CHAR_QUESTION_MARK;
912       out.out_str[2] = CHAR_COLON;
913       out.out_str[3] = CHAR_DOT;
914       out.out_str[4] = CHAR_ASTERISK;
915       out.out_str[5] = CHAR_QUESTION_MARK;
916 
917       convert_glob_write_str(&out, 6);
918 
919       convert_glob_print_separator(&out, separator, with_escape);
920 
921       out.out_str[0] = CHAR_RIGHT_PARENTHESIS;
922       out.out_str[1] = CHAR_QUESTION_MARK;
923       out.out_str[2] = CHAR_QUESTION_MARK;
924       convert_glob_write_str(&out, 3);
925 
926       pattern++;
927       continue;
928       }
929 
930     if (pattern < pattern_end && *pattern == CHAR_ASTERISK)
931       {
932       do pattern++; while (pattern < pattern_end &&
933                            *pattern == CHAR_ASTERISK);
934       }
935 
936     if (no_wildsep)
937       {
938       if (pattern >= pattern_end)
939         {
940         no_slash_z = TRUE;
941         break;
942         }
943 
944       /* Start check must be after the end check. */
945       if (is_start) continue;
946       }
947 
948     if (!is_start)
949       {
950       if (after_starstar)
951         {
952         out.out_str[0] = CHAR_LEFT_PARENTHESIS;
953         out.out_str[1] = CHAR_QUESTION_MARK;
954         out.out_str[2] = CHAR_GREATER_THAN_SIGN;
955         convert_glob_write_str(&out, 3);
956         in_atomic = TRUE;
957         }
958       else
959         convert_glob_print_commit(&out);
960       }
961 
962     if (no_wildsep)
963       convert_glob_write(&out, CHAR_DOT);
964     else
965       convert_glob_print_wildcard(&out, separator, with_escape);
966 
967     out.out_str[0] = CHAR_ASTERISK;
968     out.out_str[1] = CHAR_QUESTION_MARK;
969     if (pattern >= pattern_end)
970       out.out_str[1] = CHAR_PLUS;
971     convert_glob_write_str(&out, 2);
972     continue;
973     }
974 
975   if (c == CHAR_QUESTION_MARK)
976     {
977     if (no_wildsep)
978       convert_glob_write(&out, CHAR_DOT);
979     else
980       convert_glob_print_wildcard(&out, separator, with_escape);
981     continue;
982     }
983 
984   if (c == CHAR_LEFT_SQUARE_BRACKET)
985     {
986     result = convert_glob_parse_range(&pattern, pattern_end,
987       &out, utf, separator, with_escape, escape, no_wildsep);
988     if (result != 0) break;
989     continue;
990     }
991 
992   if (escape != 0 && c == escape)
993     {
994     if (pattern >= pattern_end)
995       {
996       result = PCRE2_ERROR_CONVERT_SYNTAX;
997       break;
998       }
999     c = *pattern++;
1000     }
1001 
1002   if (c < 128 && strchr(pcre2_escaped_literals, c) != NULL)
1003     convert_glob_write(&out, CHAR_BACKSLASH);
1004 
1005   convert_glob_write(&out, c);
1006   }
1007 
1008 if (result == 0)
1009   {
1010   if (!no_slash_z)
1011     {
1012     out.out_str[0] = CHAR_BACKSLASH;
1013     out.out_str[1] = CHAR_z;
1014     convert_glob_write_str(&out, 2);
1015     }
1016 
1017   if (in_atomic)
1018     convert_glob_write(&out, CHAR_RIGHT_PARENTHESIS);
1019 
1020   convert_glob_write(&out, CHAR_NUL);
1021 
1022   if (!dummyrun && out.output_size != (PCRE2_SIZE) (out.output - use_buffer))
1023     result = PCRE2_ERROR_NOMEMORY;
1024   }
1025 
1026 if (result != 0)
1027   {
1028   *bufflenptr = pattern - pattern_start;
1029   return result;
1030   }
1031 
1032 *bufflenptr = out.output_size - 1;
1033 return 0;
1034 }
1035 
1036 
1037 /*************************************************
1038 *                Convert pattern                 *
1039 *************************************************/
1040 
1041 /* This is the external-facing function for converting other forms of pattern
1042 into PCRE2 regular expression patterns. On error, the bufflenptr argument is
1043 used to return an offset in the original pattern.
1044 
1045 Arguments:
1046   pattern     the input pattern
1047   plength     length of input, or PCRE2_ZERO_TERMINATED
1048   options     options bits
1049   buffptr     pointer to pointer to output buffer
1050   bufflenptr  pointer to length of output buffer
1051   ccontext    convert context or NULL
1052 
1053 Returns:      0 for success, else an error code (+ve or -ve)
1054 */
1055 
1056 PCRE2_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_pattern_convert(PCRE2_SPTR pattern,PCRE2_SIZE plength,uint32_t options,PCRE2_UCHAR ** buffptr,PCRE2_SIZE * bufflenptr,pcre2_convert_context * ccontext)1057 pcre2_pattern_convert(PCRE2_SPTR pattern, PCRE2_SIZE plength, uint32_t options,
1058   PCRE2_UCHAR **buffptr, PCRE2_SIZE *bufflenptr,
1059   pcre2_convert_context *ccontext)
1060 {
1061 int i, rc;
1062 PCRE2_UCHAR dummy_buffer[DUMMY_BUFFER_SIZE];
1063 PCRE2_UCHAR *use_buffer = dummy_buffer;
1064 PCRE2_SIZE use_length = DUMMY_BUFFER_SIZE;
1065 BOOL utf = (options & PCRE2_CONVERT_UTF) != 0;
1066 uint32_t pattype = options & TYPE_OPTIONS;
1067 
1068 if (pattern == NULL || bufflenptr == NULL) return PCRE2_ERROR_NULL;
1069 
1070 if ((options & ~ALL_OPTIONS) != 0 ||        /* Undefined bit set */
1071     (pattype & (~pattype+1)) != pattype ||  /* More than one type set */
1072     pattype == 0)                           /* No type set */
1073   {
1074   *bufflenptr = 0;                          /* Error offset */
1075   return PCRE2_ERROR_BADOPTION;
1076   }
1077 
1078 if (plength == PCRE2_ZERO_TERMINATED) plength = PRIV(strlen)(pattern);
1079 if (ccontext == NULL) ccontext =
1080   (pcre2_convert_context *)(&PRIV(default_convert_context));
1081 
1082 /* Check UTF if required. */
1083 
1084 #ifndef SUPPORT_UNICODE
1085 if (utf)
1086   {
1087   *bufflenptr = 0;  /* Error offset */
1088   return PCRE2_ERROR_UNICODE_NOT_SUPPORTED;
1089   }
1090 #else
1091 if (utf && (options & PCRE2_CONVERT_NO_UTF_CHECK) == 0)
1092   {
1093   PCRE2_SIZE erroroffset;
1094   rc = PRIV(valid_utf)(pattern, plength, &erroroffset);
1095   if (rc != 0)
1096     {
1097     *bufflenptr = erroroffset;
1098     return rc;
1099     }
1100   }
1101 #endif
1102 
1103 /* If buffptr is not NULL, and what it points to is not NULL, we are being
1104 provided with a buffer and a length, so set them as the buffer to use. */
1105 
1106 if (buffptr != NULL && *buffptr != NULL)
1107   {
1108   use_buffer = *buffptr;
1109   use_length = *bufflenptr;
1110   }
1111 
1112 /* Call an individual converter, either just once (if a buffer was provided or
1113 just the length is needed), or twice (if a memory allocation is required). */
1114 
1115 for (i = 0; i < 2; i++)
1116   {
1117   PCRE2_UCHAR *allocated;
1118   BOOL dummyrun = buffptr == NULL || *buffptr == NULL;
1119 
1120   switch(pattype)
1121     {
1122     case PCRE2_CONVERT_GLOB:
1123     rc = convert_glob(options & ~PCRE2_CONVERT_GLOB, pattern, plength, utf,
1124       use_buffer, use_length, bufflenptr, dummyrun, ccontext);
1125     break;
1126 
1127     case PCRE2_CONVERT_POSIX_BASIC:
1128     case PCRE2_CONVERT_POSIX_EXTENDED:
1129     rc = convert_posix(pattype, pattern, plength, utf, use_buffer, use_length,
1130       bufflenptr, dummyrun, ccontext);
1131     break;
1132 
1133     default:
1134     *bufflenptr = 0;  /* Error offset */
1135     return PCRE2_ERROR_INTERNAL;
1136     }
1137 
1138   if (rc != 0 ||           /* Error */
1139       buffptr == NULL ||   /* Just the length is required */
1140       *buffptr != NULL)    /* Buffer was provided or allocated */
1141     return rc;
1142 
1143   /* Allocate memory for the buffer, with hidden space for an allocator at
1144   the start. The next time round the loop runs the conversion for real. */
1145 
1146   allocated = PRIV(memctl_malloc)(sizeof(pcre2_memctl) +
1147     (*bufflenptr + 1)*PCRE2_CODE_UNIT_WIDTH, (pcre2_memctl *)ccontext);
1148   if (allocated == NULL) return PCRE2_ERROR_NOMEMORY;
1149   *buffptr = (PCRE2_UCHAR *)(((char *)allocated) + sizeof(pcre2_memctl));
1150 
1151   use_buffer = *buffptr;
1152   use_length = *bufflenptr + 1;
1153   }
1154 
1155 /* Control should never get here. */
1156 
1157 return PCRE2_ERROR_INTERNAL;
1158 }
1159 
1160 
1161 /*************************************************
1162 *            Free converted pattern              *
1163 *************************************************/
1164 
1165 /* This frees a converted pattern that was put in newly-allocated memory.
1166 
1167 Argument:   the converted pattern
1168 Returns:    nothing
1169 */
1170 
1171 PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_converted_pattern_free(PCRE2_UCHAR * converted)1172 pcre2_converted_pattern_free(PCRE2_UCHAR *converted)
1173 {
1174 if (converted != NULL)
1175   {
1176   pcre2_memctl *memctl =
1177     (pcre2_memctl *)((char *)converted - sizeof(pcre2_memctl));
1178   memctl->free(memctl, memctl->memory_data);
1179   }
1180 }
1181 
1182 /* End of pcre2_convert.c */
1183