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-2022 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 /* This module is a wrapper that provides a POSIX API to the underlying PCRE2
43 functions. The operative functions are called pcre2_regcomp(), etc., with
44 wrappers that use the plain POSIX names. In addition, pcre2posix.h defines the
45 POSIX names as macros for the pcre2_xxx functions, so any program that includes
46 it and uses the POSIX names will call the base functions directly. This makes
47 it easier for an application to be sure it gets the PCRE2 versions in the
48 presence of other POSIX regex libraries. */
49
50
51 #ifdef HAVE_CONFIG_H
52 #include "config.h"
53 #endif
54
55
56 /* Ensure that the PCRE2POSIX_EXP_xxx macros are set appropriately for
57 compiling these functions. This must come before including pcre2posix.h, where
58 they are set for an application (using these functions) if they have not
59 previously been set. */
60
61 #if defined(_WIN32) && !defined(PCRE2_STATIC)
62 # define PCRE2POSIX_EXP_DECL extern __declspec(dllexport)
63 # define PCRE2POSIX_EXP_DEFN __declspec(dllexport)
64 #endif
65
66 /* Older versions of MSVC lack snprintf(). This define allows for
67 warning/error-free compilation and testing with MSVC compilers back to at least
68 MSVC 10/2010. Except for VC6 (which is missing some fundamentals and fails). */
69
70 #if defined(_MSC_VER) && (_MSC_VER < 1900)
71 #define snprintf _snprintf
72 #endif
73
74
75 /* Compile-time error numbers start at this value. It should probably never be
76 changed. This #define is a copy of the one in pcre2_internal.h. */
77
78 #define COMPILE_ERROR_BASE 100
79
80
81 /* Standard C headers */
82
83 #include <ctype.h>
84 #include <limits.h>
85 #include <stddef.h>
86 #include <stdio.h>
87 #include <stdlib.h>
88 #include <string.h>
89
90 /* PCRE2 headers */
91
92 #include "pcre2.h"
93 #include "pcre2posix.h"
94
95 /* Table to translate PCRE2 compile time error codes into POSIX error codes.
96 Only a few PCRE2 errors with a value greater than 23 turn into special POSIX
97 codes: most go to REG_BADPAT. The second table lists, in pairs, those that
98 don't. */
99
100 static const int eint1[] = {
101 0, /* No error */
102 REG_EESCAPE, /* \ at end of pattern */
103 REG_EESCAPE, /* \c at end of pattern */
104 REG_EESCAPE, /* unrecognized character follows \ */
105 REG_BADBR, /* numbers out of order in {} quantifier */
106 /* 5 */
107 REG_BADBR, /* number too big in {} quantifier */
108 REG_EBRACK, /* missing terminating ] for character class */
109 REG_ECTYPE, /* invalid escape sequence in character class */
110 REG_ERANGE, /* range out of order in character class */
111 REG_BADRPT, /* nothing to repeat */
112 /* 10 */
113 REG_ASSERT, /* internal error: unexpected repeat */
114 REG_BADPAT, /* unrecognized character after (? or (?- */
115 REG_BADPAT, /* POSIX named classes are supported only within a class */
116 REG_BADPAT, /* POSIX collating elements are not supported */
117 REG_EPAREN, /* missing ) */
118 /* 15 */
119 REG_ESUBREG, /* reference to non-existent subpattern */
120 REG_INVARG, /* pattern passed as NULL */
121 REG_INVARG, /* unknown compile-time option bit(s) */
122 REG_EPAREN, /* missing ) after (?# comment */
123 REG_ESIZE, /* parentheses nested too deeply */
124 /* 20 */
125 REG_ESIZE, /* regular expression too large */
126 REG_ESPACE, /* failed to get memory */
127 REG_EPAREN, /* unmatched closing parenthesis */
128 REG_ASSERT /* internal error: code overflow */
129 };
130
131 static const int eint2[] = {
132 30, REG_ECTYPE, /* unknown POSIX class name */
133 32, REG_INVARG, /* this version of PCRE2 does not have Unicode support */
134 37, REG_EESCAPE, /* PCRE2 does not support \L, \l, \N{name}, \U, or \u */
135 56, REG_INVARG, /* internal error: unknown newline setting */
136 92, REG_INVARG, /* invalid option bits with PCRE2_LITERAL */
137 99, REG_EESCAPE /* \K in lookaround */
138 };
139
140 /* Table of texts corresponding to POSIX error codes */
141
142 static const char *const pstring[] = {
143 "", /* Dummy for value 0 */
144 "internal error", /* REG_ASSERT */
145 "invalid repeat counts in {}", /* BADBR */
146 "pattern error", /* BADPAT */
147 "? * + invalid", /* BADRPT */
148 "unbalanced {}", /* EBRACE */
149 "unbalanced []", /* EBRACK */
150 "collation error - not relevant", /* ECOLLATE */
151 "bad class", /* ECTYPE */
152 "bad escape sequence", /* EESCAPE */
153 "empty expression", /* EMPTY */
154 "unbalanced ()", /* EPAREN */
155 "bad range inside []", /* ERANGE */
156 "expression too big", /* ESIZE */
157 "failed to get memory", /* ESPACE */
158 "bad back reference", /* ESUBREG */
159 "bad argument", /* INVARG */
160 "match failed" /* NOMATCH */
161 };
162
163
164
165 #if 0 /* REMOVE THIS CODE */
166
167 The code below was created for 10.33 (see ChangeLog 10.33 #4) when the
168 POSIX functions were given pcre2_... names instead of the traditional POSIX
169 names. However, it has proved to be more troublesome than useful. There have
170 been at least two cases where a program links with two others, one of which
171 uses the POSIX library and the other uses the PCRE2 POSIX functions, thus
172 causing two instances of the POSIX runctions to exist, leading to trouble. For
173 10.37 this code is commented out. In due course it can be removed if there are
174 no issues. The only small worry is the comment below about languages that do
175 not include pcre2posix.h. If there are any such cases, they will have to use
176 the PCRE2 names.
177
178
179 /*************************************************
180 * Wrappers with traditional POSIX names *
181 *************************************************/
182
183 /* Keep defining them to preseve the ABI for applications linked to the pcre2
184 POSIX library before these names were changed into macros in pcre2posix.h.
185 This also ensures that the POSIX names are callable from languages that do not
186 include pcre2posix.h. It is vital to #undef the macro definitions from
187 pcre2posix.h! */
188
189 #undef regerror
190 PCRE2POSIX_EXP_DECL size_t regerror(int, const regex_t *, char *, size_t);
191 PCRE2POSIX_EXP_DEFN size_t PCRE2_CALL_CONVENTION
192 regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
193 {
194 return pcre2_regerror(errcode, preg, errbuf, errbuf_size);
195 }
196
197 #undef regfree
198 PCRE2POSIX_EXP_DECL void regfree(regex_t *);
199 PCRE2POSIX_EXP_DEFN void PCRE2_CALL_CONVENTION
200 regfree(regex_t *preg)
201 {
202 pcre2_regfree(preg);
203 }
204
205 #undef regcomp
206 PCRE2POSIX_EXP_DECL int regcomp(regex_t *, const char *, int);
207 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
208 regcomp(regex_t *preg, const char *pattern, int cflags)
209 {
210 return pcre2_regcomp(preg, pattern, cflags);
211 }
212
213 #undef regexec
214 PCRE2POSIX_EXP_DECL int regexec(const regex_t *, const char *, size_t,
215 regmatch_t *, int);
216 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
217 regexec(const regex_t *preg, const char *string, size_t nmatch,
218 regmatch_t pmatch[], int eflags)
219 {
220 return pcre2_regexec(preg, string, nmatch, pmatch, eflags);
221 }
222 #endif
223
224
225 /*************************************************
226 * Translate error code to string *
227 *************************************************/
228
229 PCRE2POSIX_EXP_DEFN size_t PCRE2_CALL_CONVENTION
pcre2_regerror(int errcode,const regex_t * preg,char * errbuf,size_t errbuf_size)230 pcre2_regerror(int errcode, const regex_t *preg, char *errbuf,
231 size_t errbuf_size)
232 {
233 int used;
234 const char *message;
235
236 message = (errcode <= 0 || errcode >= (int)(sizeof(pstring)/sizeof(char *)))?
237 "unknown error code" : pstring[errcode];
238
239 if (preg != NULL && (int)preg->re_erroffset != -1)
240 {
241 used = snprintf(errbuf, errbuf_size, "%s at offset %-6d", message,
242 (int)preg->re_erroffset);
243 }
244 else
245 {
246 used = snprintf(errbuf, errbuf_size, "%s", message);
247 }
248
249 return used + 1;
250 }
251
252
253
254 /*************************************************
255 * Free store held by a regex *
256 *************************************************/
257
258 PCRE2POSIX_EXP_DEFN void PCRE2_CALL_CONVENTION
pcre2_regfree(regex_t * preg)259 pcre2_regfree(regex_t *preg)
260 {
261 pcre2_match_data_free(preg->re_match_data);
262 pcre2_code_free(preg->re_pcre2_code);
263 }
264
265
266
267 /*************************************************
268 * Compile a regular expression *
269 *************************************************/
270
271 /*
272 Arguments:
273 preg points to a structure for recording the compiled expression
274 pattern the pattern to compile
275 cflags compilation flags
276
277 Returns: 0 on success
278 various non-zero codes on failure
279 */
280
281 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_regcomp(regex_t * preg,const char * pattern,int cflags)282 pcre2_regcomp(regex_t *preg, const char *pattern, int cflags)
283 {
284 PCRE2_SIZE erroffset;
285 PCRE2_SIZE patlen;
286 int errorcode;
287 int options = 0;
288 int re_nsub = 0;
289
290 patlen = ((cflags & REG_PEND) != 0)? (PCRE2_SIZE)(preg->re_endp - pattern) :
291 PCRE2_ZERO_TERMINATED;
292
293 if ((cflags & REG_ICASE) != 0) options |= PCRE2_CASELESS;
294 if ((cflags & REG_NEWLINE) != 0) options |= PCRE2_MULTILINE;
295 if ((cflags & REG_DOTALL) != 0) options |= PCRE2_DOTALL;
296 if ((cflags & REG_NOSPEC) != 0) options |= PCRE2_LITERAL;
297 if ((cflags & REG_UTF) != 0) options |= PCRE2_UTF;
298 if ((cflags & REG_UCP) != 0) options |= PCRE2_UCP;
299 if ((cflags & REG_UNGREEDY) != 0) options |= PCRE2_UNGREEDY;
300
301 preg->re_cflags = cflags;
302 preg->re_pcre2_code = pcre2_compile((PCRE2_SPTR)pattern, patlen, options,
303 &errorcode, &erroffset, NULL);
304 preg->re_erroffset = erroffset;
305
306 if (preg->re_pcre2_code == NULL)
307 {
308 unsigned int i;
309
310 /* A negative value is a UTF error; otherwise all error codes are greater
311 than COMPILE_ERROR_BASE, but check, just in case. */
312
313 if (errorcode < COMPILE_ERROR_BASE) return REG_BADPAT;
314 errorcode -= COMPILE_ERROR_BASE;
315
316 if (errorcode < (int)(sizeof(eint1)/sizeof(const int)))
317 return eint1[errorcode];
318 for (i = 0; i < sizeof(eint2)/sizeof(const int); i += 2)
319 if (errorcode == eint2[i]) return eint2[i+1];
320 return REG_BADPAT;
321 }
322
323 (void)pcre2_pattern_info((const pcre2_code *)preg->re_pcre2_code,
324 PCRE2_INFO_CAPTURECOUNT, &re_nsub);
325 preg->re_nsub = (size_t)re_nsub;
326 preg->re_match_data = pcre2_match_data_create(re_nsub + 1, NULL);
327 preg->re_erroffset = (size_t)(-1); /* No meaning after successful compile */
328
329 if (preg->re_match_data == NULL)
330 {
331 /* LCOV_EXCL_START */
332 pcre2_code_free(preg->re_pcre2_code);
333 return REG_ESPACE;
334 /* LCOV_EXCL_STOP */
335 }
336
337 return 0;
338 }
339
340
341
342 /*************************************************
343 * Match a regular expression *
344 *************************************************/
345
346 /* A suitable match_data block, large enough to hold all possible captures, was
347 obtained when the pattern was compiled, to save having to allocate and free it
348 for each match. If REG_NOSUB was specified at compile time, the nmatch and
349 pmatch arguments are ignored, and the only result is yes/no/error. */
350
351 PCRE2POSIX_EXP_DEFN int PCRE2_CALL_CONVENTION
pcre2_regexec(const regex_t * preg,const char * string,size_t nmatch,regmatch_t pmatch[],int eflags)352 pcre2_regexec(const regex_t *preg, const char *string, size_t nmatch,
353 regmatch_t pmatch[], int eflags)
354 {
355 int rc, so, eo;
356 int options = 0;
357 pcre2_match_data *md = (pcre2_match_data *)preg->re_match_data;
358
359 if (string == NULL) return REG_INVARG;
360
361 if ((eflags & REG_NOTBOL) != 0) options |= PCRE2_NOTBOL;
362 if ((eflags & REG_NOTEOL) != 0) options |= PCRE2_NOTEOL;
363 if ((eflags & REG_NOTEMPTY) != 0) options |= PCRE2_NOTEMPTY;
364
365 /* When REG_NOSUB was specified, or if no vector has been passed in which to
366 put captured strings, ensure that nmatch is zero. This will stop any attempt to
367 write to pmatch. */
368
369 if ((preg->re_cflags & REG_NOSUB) != 0 || pmatch == NULL) nmatch = 0;
370
371 /* REG_STARTEND is a BSD extension, to allow for non-NUL-terminated strings.
372 The man page from OS X says "REG_STARTEND affects only the location of the
373 string, not how it is matched". That is why the "so" value is used to bump the
374 start location rather than being passed as a PCRE2 "starting offset". */
375
376 if ((eflags & REG_STARTEND) != 0)
377 {
378 if (pmatch == NULL) return REG_INVARG;
379 so = pmatch[0].rm_so;
380 eo = pmatch[0].rm_eo;
381 }
382 else
383 {
384 so = 0;
385 eo = (int)strlen(string);
386 }
387
388 rc = pcre2_match((const pcre2_code *)preg->re_pcre2_code,
389 (PCRE2_SPTR)string + so, (eo - so), 0, options, md, NULL);
390
391 /* Successful match */
392
393 if (rc >= 0)
394 {
395 size_t i;
396 PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(md);
397 if ((size_t)rc > nmatch) rc = (int)nmatch;
398 for (i = 0; i < (size_t)rc; i++)
399 {
400 pmatch[i].rm_so = (ovector[i*2] == PCRE2_UNSET)? -1 :
401 (int)(ovector[i*2] + so);
402 pmatch[i].rm_eo = (ovector[i*2+1] == PCRE2_UNSET)? -1 :
403 (int)(ovector[i*2+1] + so);
404 }
405 for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;
406 return 0;
407 }
408
409 /* Unsuccessful match */
410
411 if (rc <= PCRE2_ERROR_UTF8_ERR1 && rc >= PCRE2_ERROR_UTF8_ERR21)
412 return REG_INVARG;
413
414 /* Most of these are events that won't occur during testing, so exclude them
415 from coverage. */
416
417 switch(rc)
418 {
419 case PCRE2_ERROR_HEAPLIMIT: return REG_ESPACE;
420 case PCRE2_ERROR_NOMATCH: return REG_NOMATCH;
421
422 /* LCOV_EXCL_START */
423 case PCRE2_ERROR_BADMODE: return REG_INVARG;
424 case PCRE2_ERROR_BADMAGIC: return REG_INVARG;
425 case PCRE2_ERROR_BADOPTION: return REG_INVARG;
426 case PCRE2_ERROR_BADUTFOFFSET: return REG_INVARG;
427 case PCRE2_ERROR_MATCHLIMIT: return REG_ESPACE;
428 case PCRE2_ERROR_NOMEMORY: return REG_ESPACE;
429 case PCRE2_ERROR_NULL: return REG_INVARG;
430 default: return REG_ASSERT;
431 /* LCOV_EXCL_STOP */
432 }
433 }
434
435 /* End of pcre2posix.c */
436