1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 package org.apache.commons.httpclient;
33
34 import java.io.UnsupportedEncodingException;
35
36 import org.apache.commons.logging.Log;
37 import org.apache.commons.logging.LogFactory;
38
39
40 /***
41 * HTTP content conversion routines.
42 *
43 * @author Oleg Kalnichevski
44 * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
45 */
46 public class HttpConstants {
47
48 /*** Character set used to encode HTTP protocol elements */
49 public static final String HTTP_ELEMENT_CHARSET = "US-ASCII";
50
51 /*** Default content encoding chatset */
52 public static final String DEFAULT_CONTENT_CHARSET = "ISO-8859-1";
53
54 /*** Log object for this class. */
55 private static final Log LOG = LogFactory.getLog(HttpConstants.class);
56
57 /***
58 * Converts the specified string to a byte array of HTTP element characters.
59 * This method is to be used when encoding content of HTTP elements (such as
60 * request headers)
61 *
62 * @param data the string to be encoded
63 * @return The resulting byte array.
64 */
65 public static byte[] getBytes(final String data) {
66 if (data == null) {
67 throw new IllegalArgumentException("Parameter may not be null");
68 }
69
70 try {
71 return data.getBytes(HTTP_ELEMENT_CHARSET);
72 } catch (UnsupportedEncodingException e) {
73
74 if (LOG.isWarnEnabled()) {
75 LOG.warn("Unsupported encoding: "
76 + HTTP_ELEMENT_CHARSET
77 + ". System default encoding used");
78 }
79
80 return data.getBytes();
81 }
82 }
83
84 /***
85 * Converts the byte array of HTTP element characters to a string This
86 * method is to be used when decoding content of HTTP elements (such as
87 * response headers)
88 *
89 * @param data the byte array to be encoded
90 * @param offset the index of the first byte to encode
91 * @param length the number of bytes to encode
92 * @return The resulting string.
93 */
94 public static String getString(final byte[] data, int offset, int length) {
95
96 if (data == null) {
97 throw new IllegalArgumentException("Parameter may not be null");
98 }
99
100 try {
101 return new String(data, offset, length, HTTP_ELEMENT_CHARSET);
102 } catch (UnsupportedEncodingException e) {
103
104 if (LOG.isWarnEnabled()) {
105 LOG.warn("Unsupported encoding: "
106 + HTTP_ELEMENT_CHARSET
107 + ". System default encoding used");
108 }
109
110 return new String(data, offset, length);
111 }
112 }
113
114 /***
115 * Converts the byte array of HTTP element characters to a string This
116 * method is to be used when decoding content of HTTP elements (such as
117 * response headers)
118 *
119 * @param data the byte array to be encoded
120 * @return The resulting string.
121 */
122 public static String getString(final byte[] data) {
123 return getString(data, 0, data.length);
124 }
125
126 /***
127 * Converts the specified string to a byte array of HTTP content charachetrs
128 * This method is to be used when encoding content of HTTP request/response
129 * If the specified charset is not supported, default HTTP content encoding
130 * (ISO-8859-1) is applied
131 *
132 * @param data the string to be encoded
133 * @param charset the desired character encoding
134 * @return The resulting byte array.
135 */
136 public static byte[] getContentBytes(final String data, String charset) {
137
138 if (data == null) {
139 throw new IllegalArgumentException("Parameter may not be null");
140 }
141
142 if ((charset == null) || (charset.equals(""))) {
143 charset = DEFAULT_CONTENT_CHARSET;
144 }
145
146 try {
147 return data.getBytes(charset);
148 } catch (UnsupportedEncodingException e) {
149
150 if (LOG.isWarnEnabled()) {
151 LOG.warn("Unsupported encoding: "
152 + charset
153 + ". HTTP default encoding used");
154 }
155
156 try {
157 return data.getBytes(DEFAULT_CONTENT_CHARSET);
158 } catch (UnsupportedEncodingException e2) {
159
160 if (LOG.isWarnEnabled()) {
161 LOG.warn("Unsupported encoding: "
162 + DEFAULT_CONTENT_CHARSET
163 + ". System encoding used");
164 }
165
166 return data.getBytes();
167 }
168 }
169 }
170
171 /***
172 * Converts the byte array of HTTP content characters to a string This
173 * method is to be used when decoding content of HTTP request/response If
174 * the specified charset is not supported, default HTTP content encoding
175 * (ISO-8859-1) is applied
176 *
177 * @param data the byte array to be encoded
178 * @param offset the index of the first byte to encode
179 * @param length the number of bytes to encode
180 * @param charset the desired character encoding
181 * @return The result of the conversion.
182 */
183 public static String getContentString(
184 final byte[] data,
185 int offset,
186 int length,
187 String charset
188 ) {
189
190 if (data == null) {
191 throw new IllegalArgumentException("Parameter may not be null");
192 }
193
194 if ((charset == null) || (charset.equals(""))) {
195 charset = DEFAULT_CONTENT_CHARSET;
196 }
197
198 try {
199 return new String(data, offset, length, charset);
200 } catch (UnsupportedEncodingException e) {
201
202 if (LOG.isWarnEnabled()) {
203 LOG.warn("Unsupported encoding: " + charset + ". Default HTTP encoding used");
204 }
205
206 try {
207 return new String(data, offset, length, DEFAULT_CONTENT_CHARSET);
208 } catch (UnsupportedEncodingException e2) {
209
210 if (LOG.isWarnEnabled()) {
211 LOG.warn("Unsupported encoding: "
212 + DEFAULT_CONTENT_CHARSET
213 + ". System encoding used");
214 }
215
216 return new String(data, offset, length);
217 }
218 }
219 }
220
221
222 /***
223 * Converts the byte array of HTTP content characters to a string This
224 * method is to be used when decoding content of HTTP request/response If
225 * the specified charset is not supported, default HTTP content encoding
226 * (ISO-8859-1) is applied
227 *
228 * @param data the byte array to be encoded
229 * @param charset the desired character encoding
230 * @return The result of the conversion.
231 */
232 public static String getContentString(final byte[] data, String charset) {
233 return getContentString(data, 0, data.length, charset);
234 }
235
236 /***
237 * Converts the specified string to a byte array of HTTP content characters
238 * using default HTTP content encoding (ISO-8859-1) This method is to be
239 * used when encoding content of HTTP request/response
240 *
241 * @param data the string to be encoded
242 * @return The byte array as above.
243 */
244 public static byte[] getContentBytes(final String data) {
245 return getContentBytes(data, null);
246 }
247
248 /***
249 * Converts the byte array of HTTP content characters to a string using
250 * default HTTP content encoding (ISO-8859-1) This method is to be used when
251 * decoding content of HTTP request/response
252 *
253 * @param data the byte array to be encoded
254 * @param offset the index of the first byte to encode
255 * @param length the number of bytes to encode
256 * @return The string representation of the byte array.
257 */
258 public static String getContentString(final byte[] data, int offset, int length) {
259 return getContentString(data, offset, length, null);
260 }
261
262 /***
263 * Converts the byte array of HTTP content characters to a string using
264 * default HTTP content encoding (ISO-8859-1) This method is to be used when
265 * decoding content of HTTP request/response
266 *
267 * @param data the byte array to be encoded
268 * @return The string representation of the byte array.
269 */
270 public static String getContentString(final byte[] data) {
271 return getContentString(data, null);
272 }
273
274 /***
275 * Converts the specified string to byte array of ASCII characters.
276 *
277 * @param data the string to be encoded
278 * @return The string as a byte array.
279 */
280 public static byte[] getAsciiBytes(final String data) {
281
282 if (data == null) {
283 throw new IllegalArgumentException("Parameter may not be null");
284 }
285
286 try {
287 return data.getBytes("US-ASCII");
288 } catch (UnsupportedEncodingException e) {
289 throw new RuntimeException("HttpClient requires ASCII support");
290 }
291 }
292
293 /***
294 * Converts the byte array of ASCII characters to a string. This method is
295 * to be used when decoding content of HTTP elements (such as response
296 * headers)
297 *
298 * @param data the byte array to be encoded
299 * @param offset the index of the first byte to encode
300 * @param length the number of bytes to encode
301 * @return The string representation of the byte array
302 */
303 public static String getAsciiString(final byte[] data, int offset, int length) {
304
305 if (data == null) {
306 throw new IllegalArgumentException("Parameter may not be null");
307 }
308
309 try {
310 return new String(data, offset, length, "US-ASCII");
311 } catch (UnsupportedEncodingException e) {
312 throw new RuntimeException("HttpClient requires ASCII support");
313 }
314 }
315
316 /***
317 * Converts the byte array of ASCII characters to a string. This method is
318 * to be used when decoding content of HTTP elements (such as response
319 * headers)
320 *
321 * @param data the byte array to be encoded
322 * @return The string representation of the byte array
323 */
324 public static String getAsciiString(final byte[] data) {
325 return getAsciiString(data, 0, data.length);
326 }
327 }