1 /*
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * @(#)HeaderTokenizer.java 1.9 02/03/27
28 */
29
30
31
32 package com.sun.xml.internal.messaging.saaj.packaging.mime.internet;
33
34
35 /**
36 * This class tokenizes RFC822 and MIME headers into the basic
37 * symbols specified by RFC822 and MIME. <p>
38 *
39 * This class handles folded headers (ie headers with embedded
40 * CRLF SPACE sequences). The folds are removed in the returned
41 * tokens.
42 *
43 * @version 1.9, 02/03/27
44 * @author John Mani
45 */
46
47 public class HeaderTokenizer {
48
49 /**
50 * The Token class represents tokens returned by the
51 * HeaderTokenizer.
52 */
53 public static class Token {
54
55 private int type;
56 private String value;
57
58 /**
59 * Token type indicating an ATOM.
60 */
61 public static final int ATOM = -1;
62
63 /**
64 * Token type indicating a quoted string. The value
65 * field contains the string without the quotes.
66 */
67 public static final int QUOTEDSTRING = -2;
68
69 /**
70 * Token type indicating a comment. The value field
71 * contains the comment string without the comment
72 * start and end symbols.
73 */
74 public static final int COMMENT = -3;
75
76 /**
77 * Token type indicating end of input.
78 */
79 public static final int EOF = -4;
80
81 /**
82 * Constructor.
83 * @param type Token type
84 * @param value Token value
85 */
86 public Token(int type, String value) {
87 this.type = type;
88 this.value = value;
89 }
90
91 /**
92 * Return the type of the token. If the token represents a
93 * delimiter or a control character, the type is that character
94 * itself, converted to an integer. Otherwise, it's value is
95 * one of the following:
96 * <ul>
97 * <li><code>ATOM</code> A sequence of ASCII characters
98 * delimited by either SPACE, CTL, "(", <"> or the
99 * specified SPECIALS
100 * <li><code>QUOTEDSTRING</code> A sequence of ASCII characters
101 * within quotes
102 * <li><code>COMMENT</code> A sequence of ASCII characters
103 * within "(" and ")".
104 * <li><code>EOF</code> End of header
105 * </ul>
106 */
107 public int getType() {
108 return type;
109 }
110
111 /**
112 * Returns the value of the token just read. When the current
113 * token is a quoted string, this field contains the body of the
114 * string, without the quotes. When the current token is a comment,
115 * this field contains the body of the comment.
116 *
117 * @return token value
118 */
119 public String getValue() {
120 return value;
121 }
122 }
123
124 private String string; // the string to be tokenized
125 private boolean skipComments; // should comments be skipped ?
126 private String delimiters; // delimiter string
127 private int currentPos; // current parse position
128 private int maxPos; // string length
129 private int nextPos; // track start of next Token for next()
130 private int peekPos; // track start of next Token for peek()
131
132 /**
133 * RFC822 specials
134 */
135 public final static String RFC822 = "()<>@,;:\\\"\t .[]";
136
137 /**
138 * MIME specials
139 */
140 public final static String MIME = "()<>@,;:\\\"\t []/?=";
141
142 // The EOF Token
143 private final static Token EOFToken = new Token(Token.EOF, null);
144
145 /**
146 * Constructor that takes a rfc822 style header.
147 *
148 * @param header The rfc822 header to be tokenized
149 * @param delimiters Set of delimiter characters
150 * to be used to delimit ATOMS. These
151 * are usually <code>RFC822</code> or
152 * <code>MIME</code>
153 * @param skipComments If true, comments are skipped and
154 * not returned as tokens
155 */
156 public HeaderTokenizer(String header, String delimiters,
157 boolean skipComments) {
158 string = (header == null) ? "" : header; // paranoia ?!
159 this.skipComments = skipComments;
160 this.delimiters = delimiters;
161 currentPos = nextPos = peekPos = 0;
162 maxPos = string.length();
163 }
164
165 /**
166 * Constructor. Comments are ignored and not returned as tokens
167 *
168 * @param header The header that is tokenized
169 * @param delimiters The delimiters to be used
170 */
171 public HeaderTokenizer(String header, String delimiters) {
172 this(header, delimiters, true);
173 }
174
175 /**
176 * Constructor. The RFC822 defined delimiters - RFC822 - are
177 * used to delimit ATOMS. Also comments are skipped and not
178 * returned as tokens
179 */
180 public HeaderTokenizer(String header) {
181 this(header, RFC822);
182 }
183
184 /**
185 * Parses the next token from this String. <p>
186 *
187 * Clients sit in a loop calling next() to parse successive
188 * tokens until an EOF Token is returned.
189 *
190 * @return the next Token
191 * @exception ParseException if the parse fails
192 */
193 public Token next() throws ParseException {
194 Token tk;
195
196 currentPos = nextPos; // setup currentPos
197 tk = getNext();
198 nextPos = peekPos = currentPos; // update currentPos and peekPos
199 return tk;
200 }
201
202 /**
203 * Peek at the next token, without actually removing the token
204 * from the parse stream. Invoking this method multiple times
205 * will return successive tokens, until <code>next()</code> is
206 * called. <p>
207 *
208 * @return the next Token
209 * @exception ParseException if the parse fails
210 */
211 public Token peek() throws ParseException {
212 Token tk;
213
214 currentPos = peekPos; // setup currentPos
215 tk = getNext();
216 peekPos = currentPos; // update peekPos
217 return tk;
218 }
219
220 /**
221 * Return the rest of the Header.
222 *
223 * @return String rest of header. null is returned if we are
224 * already at end of header
225 */
226 public String getRemainder() {
227 return string.substring(nextPos);
228 }
229
230 /*
231 * Return the next token starting from 'currentPos'. After the
232 * parse, 'currentPos' is updated to point to the start of the
233 * next token.
234 */
235 private Token getNext() throws ParseException {
236 // If we're already at end of string, return EOF
237 if (currentPos >= maxPos)
238 return EOFToken;
239
240 // Skip white-space, position currentPos beyond the space
241 if (skipWhiteSpace() == Token.EOF)
242 return EOFToken;
243
244 char c;
245 int start;
246 boolean filter = false;
247
248 c = string.charAt(currentPos);
249
250 // Check or Skip comments and position currentPos
251 // beyond the comment
252 while (c == '(') {
253 // Parsing comment ..
254 int nesting;
255 for (start = ++currentPos, nesting = 1;
256 nesting > 0 && currentPos < maxPos;
257 currentPos++) {
258 c = string.charAt(currentPos);
259 if (c == '\\') { // Escape sequence
260 currentPos++; // skip the escaped character
261 filter = true;
262 } else if (c == '\r')
263 filter = true;
264 else if (c == '(')
265 nesting++;
266 else if (c == ')')
267 nesting--;
268 }
269 if (nesting != 0)
270 throw new ParseException("Unbalanced comments");
271
272 if (!skipComments) {
273 // Return the comment, if we are asked to.
274 // Note that the comment start & end markers are ignored.
275 String s;
276 if (filter) // need to go thru the token again.
277 s = filterToken(string, start, currentPos-1);
278 else
279 s = string.substring(start,currentPos-1);
280
281 return new Token(Token.COMMENT, s);
282 }
283
284 // Skip any whitespace after the comment.
285 if (skipWhiteSpace() == Token.EOF)
286 return EOFToken;
287 c = string.charAt(currentPos);
288 }
289
290 // Check for quoted-string and position currentPos
291 // beyond the terminating quote
292 if (c == '"') {
293 for (start = ++currentPos; currentPos < maxPos; currentPos++) {
294 c = string.charAt(currentPos);
295 if (c == '\\') { // Escape sequence
296 currentPos++;
297 filter = true;
298 } else if (c == '\r')
299 filter = true;
300 else if (c == '"') {
301 currentPos++;
302 String s;
303
304 if (filter)
305 s = filterToken(string, start, currentPos-1);
306 else
307 s = string.substring(start,currentPos-1);
308
309 return new Token(Token.QUOTEDSTRING, s);
310 }
311 }
312 throw new ParseException("Unbalanced quoted string");
313 }
314
315 // Check for SPECIAL or CTL
316 if (c < 040 || c >= 0177 || delimiters.indexOf(c) >= 0) {
317 currentPos++; // re-position currentPos
318 char ch[] = new char[1];
319 ch[0] = c;
320 return new Token((int)c, new String(ch));
321 }
322
323 // Check for ATOM
324 for (start = currentPos; currentPos < maxPos; currentPos++) {
325 c = string.charAt(currentPos);
326 // ATOM is delimited by either SPACE, CTL, "(", <">
327 // or the specified SPECIALS
328 if (c < 040 || c >= 0177 || c == '(' || c == ' ' ||
329 c == '"' || delimiters.indexOf(c) >= 0)
330 break;
331 }
332 return new Token(Token.ATOM, string.substring(start, currentPos));
333 }
334
335 // Skip SPACE, HT, CR and NL
336 private int skipWhiteSpace() {
337 char c;
338 for (; currentPos < maxPos; currentPos++)
339 if (((c = string.charAt(currentPos)) != ' ') &&
340 (c != '\t') && (c != '\r') && (c != '\n'))
341 return currentPos;
342 return Token.EOF;
343 }
344
345 /* Process escape sequences and embedded LWSPs from a comment or
346 * quoted string.
347 */
348 private static String filterToken(String s, int start, int end) {
349 StringBuffer sb = new StringBuffer();
350 char c;
351 boolean gotEscape = false;
352 boolean gotCR = false;
353
354 for (int i = start; i < end; i++) {
355 c = s.charAt(i);
356 if (c == '\n' && gotCR) {
357 // This LF is part of an unescaped
358 // CRLF sequence (i.e, LWSP). Skip it.
359 gotCR = false;
360 continue;
361 }
362
363 gotCR = false;
364 if (!gotEscape) {
365 // Previous character was NOT '\'
366 if (c == '\\') // skip this character
367 gotEscape = true;
368 else if (c == '\r') // skip this character
369 gotCR = true;
370 else // append this character
371 sb.append(c);
372 } else {
373 // Previous character was '\'. So no need to
374 // bother with any special processing, just
375 // append this character
376 sb.append(c);
377 gotEscape = false;
378 }
379 }
380 return sb.toString();
381 }
382 }