001/**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.activemq.util;
018
019import java.io.DataInput;
020import java.io.DataInputStream;
021import java.io.DataOutput;
022import java.io.DataOutputStream;
023import java.io.IOException;
024import java.io.UTFDataFormatException;
025import java.util.ArrayList;
026import java.util.HashMap;
027import java.util.List;
028import java.util.Map;
029import java.util.Properties;
030
031import org.fusesource.hawtbuf.UTF8Buffer;
032
033/**
034 * The fixed version of the UTF8 encoding function. Some older JVM's UTF8
035 * encoding function breaks when handling large strings.
036 */
037public final class MarshallingSupport {
038
039    public static final byte NULL = 0;
040    public static final byte BOOLEAN_TYPE = 1;
041    public static final byte BYTE_TYPE = 2;
042    public static final byte CHAR_TYPE = 3;
043    public static final byte SHORT_TYPE = 4;
044    public static final byte INTEGER_TYPE = 5;
045    public static final byte LONG_TYPE = 6;
046    public static final byte DOUBLE_TYPE = 7;
047    public static final byte FLOAT_TYPE = 8;
048    public static final byte STRING_TYPE = 9;
049    public static final byte BYTE_ARRAY_TYPE = 10;
050    public static final byte MAP_TYPE = 11;
051    public static final byte LIST_TYPE = 12;
052    public static final byte BIG_STRING_TYPE = 13;
053
054    private MarshallingSupport() {}
055
056    public static void marshalPrimitiveMap(Map<String, Object> map, DataOutputStream out) throws IOException {
057        if (map == null) {
058            out.writeInt(-1);
059        } else {
060            out.writeInt(map.size());
061            for (String name : map.keySet()) {
062                out.writeUTF(name);
063                Object value = map.get(name);
064                marshalPrimitive(out, value);
065            }
066        }
067    }
068
069    public static Map<String, Object> unmarshalPrimitiveMap(DataInputStream in) throws IOException {
070        return unmarshalPrimitiveMap(in, Integer.MAX_VALUE);
071    }
072
073    public static Map<String, Object> unmarshalPrimitiveMap(DataInputStream in, boolean force) throws IOException {
074        return unmarshalPrimitiveMap(in, Integer.MAX_VALUE, force);
075    }
076
077    public static Map<String, Object> unmarshalPrimitiveMap(DataInputStream in, int maxPropertySize) throws IOException {
078        return unmarshalPrimitiveMap(in, maxPropertySize, false);
079    }
080
081    /**
082     * @param in
083     * @return
084     * @throws IOException
085     * @throws IOException
086     */
087    public static Map<String, Object> unmarshalPrimitiveMap(DataInputStream in, int maxPropertySize, boolean force) throws IOException {
088        int size = in.readInt();
089        if (size > maxPropertySize) {
090            throw new IOException("Primitive map is larger than the allowed size: " + size);
091        }
092        if (size < 0) {
093            return null;
094        } else {
095            Map<String, Object> rc = new HashMap<String, Object>(size);
096            for (int i = 0; i < size; i++) {
097                String name = in.readUTF();
098                rc.put(name, unmarshalPrimitive(in, force));
099            }
100            return rc;
101        }
102    }
103
104    public static void marshalPrimitiveList(List<Object> list, DataOutputStream out) throws IOException {
105        out.writeInt(list.size());
106        for (Object element : list) {
107            marshalPrimitive(out, element);
108        }
109    }
110
111    public static List<Object> unmarshalPrimitiveList(DataInputStream in) throws IOException {
112        return unmarshalPrimitiveList(in, false);
113    }
114
115    public static List<Object> unmarshalPrimitiveList(DataInputStream in, boolean force) throws IOException {
116        int size = in.readInt();
117        List<Object> answer = new ArrayList<Object>(size);
118        while (size-- > 0) {
119            answer.add(unmarshalPrimitive(in, force));
120        }
121        return answer;
122    }
123
124    public static void marshalPrimitive(DataOutputStream out, Object value) throws IOException {
125        if (value == null) {
126            marshalNull(out);
127        } else if (value.getClass() == Boolean.class) {
128            marshalBoolean(out, ((Boolean)value).booleanValue());
129        } else if (value.getClass() == Byte.class) {
130            marshalByte(out, ((Byte)value).byteValue());
131        } else if (value.getClass() == Character.class) {
132            marshalChar(out, ((Character)value).charValue());
133        } else if (value.getClass() == Short.class) {
134            marshalShort(out, ((Short)value).shortValue());
135        } else if (value.getClass() == Integer.class) {
136            marshalInt(out, ((Integer)value).intValue());
137        } else if (value.getClass() == Long.class) {
138            marshalLong(out, ((Long)value).longValue());
139        } else if (value.getClass() == Float.class) {
140            marshalFloat(out, ((Float)value).floatValue());
141        } else if (value.getClass() == Double.class) {
142            marshalDouble(out, ((Double)value).doubleValue());
143        } else if (value.getClass() == byte[].class) {
144            marshalByteArray(out, (byte[])value);
145        } else if (value.getClass() == String.class) {
146            marshalString(out, (String)value);
147        } else  if (value.getClass() == UTF8Buffer.class) {
148            marshalString(out, value.toString());
149        } else if (value instanceof Map) {
150            out.writeByte(MAP_TYPE);
151            marshalPrimitiveMap((Map<String, Object>)value, out);
152        } else if (value instanceof List) {
153            out.writeByte(LIST_TYPE);
154            marshalPrimitiveList((List<Object>)value, out);
155        } else {
156            throw new IOException("Object is not a primitive: " + value);
157        }
158    }
159
160    public static Object unmarshalPrimitive(DataInputStream in) throws IOException {
161        return unmarshalPrimitive(in, false);
162    }
163
164    public static Object unmarshalPrimitive(DataInputStream in, boolean force) throws IOException {
165        Object value = null;
166        byte type = in.readByte();
167        switch (type) {
168        case BYTE_TYPE:
169            value = Byte.valueOf(in.readByte());
170            break;
171        case BOOLEAN_TYPE:
172            value = in.readBoolean() ? Boolean.TRUE : Boolean.FALSE;
173            break;
174        case CHAR_TYPE:
175            value = Character.valueOf(in.readChar());
176            break;
177        case SHORT_TYPE:
178            value = Short.valueOf(in.readShort());
179            break;
180        case INTEGER_TYPE:
181            value = Integer.valueOf(in.readInt());
182            break;
183        case LONG_TYPE:
184            value = Long.valueOf(in.readLong());
185            break;
186        case FLOAT_TYPE:
187            value = new Float(in.readFloat());
188            break;
189        case DOUBLE_TYPE:
190            value = new Double(in.readDouble());
191            break;
192        case BYTE_ARRAY_TYPE:
193            value = new byte[in.readInt()];
194            in.readFully((byte[])value);
195            break;
196        case STRING_TYPE:
197            if (force) {
198                value = in.readUTF();
199            } else {
200                value = readUTF(in, in.readUnsignedShort());
201            }
202            break;
203        case BIG_STRING_TYPE: {
204            if (force) {
205                value = readUTF8(in);
206            } else {
207                value = readUTF(in, in.readInt());
208            }
209            break;
210        }
211        case MAP_TYPE:
212            value = unmarshalPrimitiveMap(in, true);
213            break;
214        case LIST_TYPE:
215            value = unmarshalPrimitiveList(in, true);
216            break;
217        case NULL:
218            value = null;
219            break;
220        default:
221            throw new IOException("Unknown primitive type: " + type);
222        }
223        return value;
224    }
225
226    public static UTF8Buffer readUTF(DataInputStream in, int length) throws IOException {
227        byte data[] = new byte[length];
228        in.readFully(data);
229        return new UTF8Buffer(data);
230    }
231
232    public static void marshalNull(DataOutputStream out) throws IOException {
233        out.writeByte(NULL);
234    }
235
236    public static void marshalBoolean(DataOutputStream out, boolean value) throws IOException {
237        out.writeByte(BOOLEAN_TYPE);
238        out.writeBoolean(value);
239    }
240
241    public static void marshalByte(DataOutputStream out, byte value) throws IOException {
242        out.writeByte(BYTE_TYPE);
243        out.writeByte(value);
244    }
245
246    public static void marshalChar(DataOutputStream out, char value) throws IOException {
247        out.writeByte(CHAR_TYPE);
248        out.writeChar(value);
249    }
250
251    public static void marshalShort(DataOutputStream out, short value) throws IOException {
252        out.writeByte(SHORT_TYPE);
253        out.writeShort(value);
254    }
255
256    public static void marshalInt(DataOutputStream out, int value) throws IOException {
257        out.writeByte(INTEGER_TYPE);
258        out.writeInt(value);
259    }
260
261    public static void marshalLong(DataOutputStream out, long value) throws IOException {
262        out.writeByte(LONG_TYPE);
263        out.writeLong(value);
264    }
265
266    public static void marshalFloat(DataOutputStream out, float value) throws IOException {
267        out.writeByte(FLOAT_TYPE);
268        out.writeFloat(value);
269    }
270
271    public static void marshalDouble(DataOutputStream out, double value) throws IOException {
272        out.writeByte(DOUBLE_TYPE);
273        out.writeDouble(value);
274    }
275
276    public static void marshalByteArray(DataOutputStream out, byte[] value) throws IOException {
277        marshalByteArray(out, value, 0, value.length);
278    }
279
280    public static void marshalByteArray(DataOutputStream out, byte[] value, int offset, int length) throws IOException {
281        out.writeByte(BYTE_ARRAY_TYPE);
282        out.writeInt(length);
283        out.write(value, offset, length);
284    }
285
286    public static void marshalString(DataOutputStream out, String s) throws IOException {
287        // If it's too big, out.writeUTF may not able able to write it out.
288        if (s.length() < Short.MAX_VALUE / 4) {
289            out.writeByte(STRING_TYPE);
290            out.writeUTF(s);
291        } else {
292            out.writeByte(BIG_STRING_TYPE);
293            writeUTF8(out, s);
294        }
295    }
296
297    public static void writeUTF8(DataOutput dataOut, String text) throws IOException {
298        if (text != null) {
299            int strlen = text.length();
300            int utflen = 0;
301            char[] charr = new char[strlen];
302            int c = 0;
303            int count = 0;
304
305            text.getChars(0, strlen, charr, 0);
306
307            for (int i = 0; i < strlen; i++) {
308                c = charr[i];
309                if ((c >= 0x0001) && (c <= 0x007F)) {
310                    utflen++;
311                } else if (c > 0x07FF) {
312                    utflen += 3;
313                } else {
314                    utflen += 2;
315                }
316            }
317            // TODO diff: Sun code - removed
318            byte[] bytearr = new byte[utflen + 4]; // TODO diff: Sun code
319            bytearr[count++] = (byte)((utflen >>> 24) & 0xFF); // TODO diff:
320            // Sun code
321            bytearr[count++] = (byte)((utflen >>> 16) & 0xFF); // TODO diff:
322            // Sun code
323            bytearr[count++] = (byte)((utflen >>> 8) & 0xFF);
324            bytearr[count++] = (byte)((utflen >>> 0) & 0xFF);
325            for (int i = 0; i < strlen; i++) {
326                c = charr[i];
327                if ((c >= 0x0001) && (c <= 0x007F)) {
328                    bytearr[count++] = (byte)c;
329                } else if (c > 0x07FF) {
330                    bytearr[count++] = (byte)(0xE0 | ((c >> 12) & 0x0F));
331                    bytearr[count++] = (byte)(0x80 | ((c >> 6) & 0x3F));
332                    bytearr[count++] = (byte)(0x80 | ((c >> 0) & 0x3F));
333                } else {
334                    bytearr[count++] = (byte)(0xC0 | ((c >> 6) & 0x1F));
335                    bytearr[count++] = (byte)(0x80 | ((c >> 0) & 0x3F));
336                }
337            }
338            dataOut.write(bytearr);
339
340        } else {
341            dataOut.writeInt(-1);
342        }
343    }
344
345    public static String readUTF8(DataInput dataIn) throws IOException {
346        int utflen = dataIn.readInt(); // TODO diff: Sun code
347        if (utflen > -1) {
348            StringBuffer str = new StringBuffer(utflen);
349            byte bytearr[] = new byte[utflen];
350            int c;
351            int char2;
352            int char3;
353            int count = 0;
354
355            dataIn.readFully(bytearr, 0, utflen);
356
357            while (count < utflen) {
358                c = bytearr[count] & 0xff;
359                switch (c >> 4) {
360                case 0:
361                case 1:
362                case 2:
363                case 3:
364                case 4:
365                case 5:
366                case 6:
367                case 7:
368                    /* 0xxxxxxx */
369                    count++;
370                    str.append((char)c);
371                    break;
372                case 12:
373                case 13:
374                    /* 110x xxxx 10xx xxxx */
375                    count += 2;
376                    if (count > utflen) {
377                        throw new UTFDataFormatException();
378                    }
379                    char2 = bytearr[count - 1];
380                    if ((char2 & 0xC0) != 0x80) {
381                        throw new UTFDataFormatException();
382                    }
383                    str.append((char)(((c & 0x1F) << 6) | (char2 & 0x3F)));
384                    break;
385                case 14:
386                    /* 1110 xxxx 10xx xxxx 10xx xxxx */
387                    count += 3;
388                    if (count > utflen) {
389                        throw new UTFDataFormatException();
390                    }
391                    char2 = bytearr[count - 2]; // TODO diff: Sun code
392                    char3 = bytearr[count - 1]; // TODO diff: Sun code
393                    if (((char2 & 0xC0) != 0x80) || ((char3 & 0xC0) != 0x80)) {
394                        throw new UTFDataFormatException();
395                    }
396                    str.append((char)(((c & 0x0F) << 12) | ((char2 & 0x3F) << 6) | ((char3 & 0x3F) << 0)));
397                    break;
398                default:
399                    /* 10xx xxxx, 1111 xxxx */
400                    throw new UTFDataFormatException();
401                }
402            }
403            // The number of chars produced may be less than utflen
404            return new String(str);
405        } else {
406            return null;
407        }
408    }
409
410    public static String propertiesToString(Properties props) throws IOException {
411        String result = "";
412        if (props != null) {
413            DataByteArrayOutputStream dataOut = new DataByteArrayOutputStream();
414            props.store(dataOut, "");
415            result = new String(dataOut.getData(), 0, dataOut.size());
416            dataOut.close();
417        }
418        return result;
419    }
420
421    public static Properties stringToProperties(String str) throws IOException {
422        Properties result = new Properties();
423        if (str != null && str.length() > 0) {
424            DataByteArrayInputStream dataIn = new DataByteArrayInputStream(str.getBytes());
425            result.load(dataIn);
426            dataIn.close();
427        }
428        return result;
429    }
430
431    public static String truncate64(String text) {
432        if (text.length() > 63) {
433            text = text.substring(0, 45) + "..." + text.substring(text.length() - 12);
434        }
435        return text;
436    }
437}