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