1/************************************************* 2* Perl-Compatible Regular Expressions * 3*************************************************/ 4 5/* PCRE is a library of functions to support regular expressions whose syntax 6and semantics are as close as possible to those of the Perl 5 language. 7 8 Written by Philip Hazel 9 Copyright (c) 1997-2012 University of Cambridge 10 11----------------------------------------------------------------------------- 12Redistribution and use in source and binary forms, with or without 13modification, are permitted provided that the following conditions are met: 14 15 * Redistributions of source code must retain the above copyright notice, 16 this list of conditions and the following disclaimer. 17 18 * Redistributions in binary form must reproduce the above copyright 19 notice, this list of conditions and the following disclaimer in the 20 documentation and/or other materials provided with the distribution. 21 22 * Neither the name of the University of Cambridge nor the names of its 23 contributors may be used to endorse or promote products derived from 24 this software without specific prior written permission. 25 26THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 27AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 30LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36POSSIBILITY OF SUCH DAMAGE. 37----------------------------------------------------------------------------- 38*/ 39 40 41/* This module contains an internal function that tests a compiled pattern to 42see if it was compiled with the opposite endianness. If so, it uses an 43auxiliary local function to flip the appropriate bytes. */ 44 45 46#ifdef HAVE_CONFIG_H 47#include "config.h" 48#endif 49 50#include "pcre_internal.h" 51 52 53/************************************************* 54* Swap byte functions * 55*************************************************/ 56 57/* The following functions swap the bytes of a pcre_uint16 58and pcre_uint32 value. 59 60Arguments: 61 value any number 62 63Returns: the byte swapped value 64*/ 65 66static pcre_uint32 67swap_uint32(pcre_uint32 value) 68{ 69return ((value & 0x000000ff) << 24) | 70 ((value & 0x0000ff00) << 8) | 71 ((value & 0x00ff0000) >> 8) | 72 (value >> 24); 73} 74 75static pcre_uint16 76swap_uint16(pcre_uint16 value) 77{ 78return (value >> 8) | (value << 8); 79} 80 81 82/************************************************* 83* Test for a byte-flipped compiled regex * 84*************************************************/ 85 86/* This function swaps the bytes of a compiled pattern usually 87loaded form the disk. It also sets the tables pointer, which 88is likely an invalid pointer after reload. 89 90Arguments: 91 argument_re points to the compiled expression 92 extra_data points to extra data or is NULL 93 tables points to the character tables or NULL 94 95Returns: 0 if the swap is successful, negative on error 96*/ 97 98#ifdef COMPILE_PCRE8 99PCRE_EXP_DECL int pcre_pattern_to_host_byte_order(pcre *argument_re, 100 pcre_extra *extra_data, const unsigned char *tables) 101#else 102PCRE_EXP_DECL int pcre16_pattern_to_host_byte_order(pcre16 *argument_re, 103 pcre16_extra *extra_data, const unsigned char *tables) 104#endif 105{ 106REAL_PCRE *re = (REAL_PCRE *)argument_re; 107pcre_study_data *study; 108#ifndef COMPILE_PCRE8 109pcre_uchar *ptr; 110int length; 111#ifdef SUPPORT_UTF 112BOOL utf; 113BOOL utf16_char; 114#endif /* SUPPORT_UTF */ 115#endif /* !COMPILE_PCRE8 */ 116 117if (re == NULL) return PCRE_ERROR_NULL; 118if (re->magic_number == MAGIC_NUMBER) 119 { 120 if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE; 121 re->tables = tables; 122 return 0; 123 } 124 125if (re->magic_number != REVERSED_MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC; 126if ((swap_uint16(re->flags) & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE; 127 128re->magic_number = MAGIC_NUMBER; 129re->size = swap_uint32(re->size); 130re->options = swap_uint32(re->options); 131re->flags = swap_uint16(re->flags); 132re->top_bracket = swap_uint16(re->top_bracket); 133re->top_backref = swap_uint16(re->top_backref); 134re->first_char = swap_uint16(re->first_char); 135re->req_char = swap_uint16(re->req_char); 136re->name_table_offset = swap_uint16(re->name_table_offset); 137re->name_entry_size = swap_uint16(re->name_entry_size); 138re->name_count = swap_uint16(re->name_count); 139re->ref_count = swap_uint16(re->ref_count); 140re->tables = tables; 141 142if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0) 143 { 144 study = (pcre_study_data *)extra_data->study_data; 145 study->size = swap_uint32(study->size); 146 study->flags = swap_uint32(study->flags); 147 study->minlength = swap_uint32(study->minlength); 148 } 149 150#ifndef COMPILE_PCRE8 151ptr = (pcre_uchar *)re + re->name_table_offset; 152length = re->name_count * re->name_entry_size; 153#ifdef SUPPORT_UTF 154utf = (re->options & PCRE_UTF16) != 0; 155utf16_char = FALSE; 156#endif 157 158while(TRUE) 159 { 160 /* Swap previous characters. */ 161 while (length-- > 0) 162 { 163 *ptr = swap_uint16(*ptr); 164 ptr++; 165 } 166#ifdef SUPPORT_UTF 167 if (utf16_char) 168 { 169 if (HAS_EXTRALEN(ptr[-1])) 170 { 171 /* We know that there is only one extra character in UTF-16. */ 172 *ptr = swap_uint16(*ptr); 173 ptr++; 174 } 175 } 176 utf16_char = FALSE; 177#endif /* SUPPORT_UTF */ 178 179 /* Get next opcode. */ 180 length = 0; 181 *ptr = swap_uint16(*ptr); 182 switch (*ptr) 183 { 184 case OP_END: 185 return 0; 186 187#ifdef SUPPORT_UTF 188 case OP_CHAR: 189 case OP_CHARI: 190 case OP_NOT: 191 case OP_NOTI: 192 case OP_STAR: 193 case OP_MINSTAR: 194 case OP_PLUS: 195 case OP_MINPLUS: 196 case OP_QUERY: 197 case OP_MINQUERY: 198 case OP_UPTO: 199 case OP_MINUPTO: 200 case OP_EXACT: 201 case OP_POSSTAR: 202 case OP_POSPLUS: 203 case OP_POSQUERY: 204 case OP_POSUPTO: 205 case OP_STARI: 206 case OP_MINSTARI: 207 case OP_PLUSI: 208 case OP_MINPLUSI: 209 case OP_QUERYI: 210 case OP_MINQUERYI: 211 case OP_UPTOI: 212 case OP_MINUPTOI: 213 case OP_EXACTI: 214 case OP_POSSTARI: 215 case OP_POSPLUSI: 216 case OP_POSQUERYI: 217 case OP_POSUPTOI: 218 case OP_NOTSTAR: 219 case OP_NOTMINSTAR: 220 case OP_NOTPLUS: 221 case OP_NOTMINPLUS: 222 case OP_NOTQUERY: 223 case OP_NOTMINQUERY: 224 case OP_NOTUPTO: 225 case OP_NOTMINUPTO: 226 case OP_NOTEXACT: 227 case OP_NOTPOSSTAR: 228 case OP_NOTPOSPLUS: 229 case OP_NOTPOSQUERY: 230 case OP_NOTPOSUPTO: 231 case OP_NOTSTARI: 232 case OP_NOTMINSTARI: 233 case OP_NOTPLUSI: 234 case OP_NOTMINPLUSI: 235 case OP_NOTQUERYI: 236 case OP_NOTMINQUERYI: 237 case OP_NOTUPTOI: 238 case OP_NOTMINUPTOI: 239 case OP_NOTEXACTI: 240 case OP_NOTPOSSTARI: 241 case OP_NOTPOSPLUSI: 242 case OP_NOTPOSQUERYI: 243 case OP_NOTPOSUPTOI: 244 if (utf) utf16_char = TRUE; 245#endif 246 /* Fall through. */ 247 248 default: 249 length = PRIV(OP_lengths)[*ptr] - 1; 250 break; 251 252 case OP_CLASS: 253 case OP_NCLASS: 254 /* Skip the character bit map. */ 255 ptr += 32/sizeof(pcre_uchar); 256 length = 0; 257 break; 258 259 case OP_XCLASS: 260 /* Reverse the size of the XCLASS instance. */ 261 ptr++; 262 *ptr = swap_uint16(*ptr); 263 if (LINK_SIZE > 1) 264 { 265 /* LINK_SIZE can be 1 or 2 in 16 bit mode. */ 266 ptr++; 267 *ptr = swap_uint16(*ptr); 268 } 269 ptr++; 270 length = (GET(ptr, -LINK_SIZE)) - (1 + LINK_SIZE + 1); 271 *ptr = swap_uint16(*ptr); 272 if ((*ptr & XCL_MAP) != 0) 273 { 274 /* Skip the character bit map. */ 275 ptr += 32/sizeof(pcre_uchar); 276 length -= 32/sizeof(pcre_uchar); 277 } 278 break; 279 } 280 ptr++; 281 } 282/* Control should never reach here in 16 bit mode. */ 283#endif /* !COMPILE_PCRE8 */ 284 285return 0; 286} 287 288/* End of pcre_byte_order.c */ 289