1dd5c337dc3c37511a7050d0c188a00bf046a1fe
[ossec-hids.git] / pcre2_convert.c
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
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
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
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
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
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
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
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
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
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
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
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
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 */