Attachment #281337 for bug #558633

View | Details | Raw Unified | Return to bug 558633
Collapse All | Expand All




import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InvalidClassException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

            File indexFile = new File(prefix + "index"); //$NON-NLS-1$
            fis = new FileInputStream(indexFile);
            listener.worked(1);
            /**
             * Classes deserialized:
             * org.eclipse.mat.parser.model.XSnapshotInfo
             * org.eclipse.mat.parser.model.AbstractObjectImpl
             * org.eclipse.mat.parser.model.XGCRootInfo
             * org.eclipse.mat.parser.model.ClassImpl
             * [Lorg.eclipse.mat.parser.model.XGCRootInfo
             * org.eclipse.mat.parser.model.XGCRootInfo
             * 
             * org.eclipse.mat.snapshot.SnapshotInfo
             * org.eclipse.mat.snapshot.UnreachableObjectsHistogram
             * 
             * org.eclipse.mat.snapshot.model.GCRootInfo
             * org.eclipse.mat.snapshot.model.FieldDescriptor
             * org.eclipse.mat.snapshot.model.Field
             * [Lorg.eclipse.mat.snapshot.model.FieldDescriptor
             * [Lorg.eclipse.mat.snapshot.model.Field
             * org.eclipse.mat.snapshot.model.ObjectReference
             * 
             * org.eclipse.mat.collect.HashMapIntObject
             * org.eclipse.mat.collect.BitField
             * 
             * java.util.ArrayList:
             * java.util.Date
             * java.util.HashMap
             * 
             * java.lang.Boolean
             * java.lang.Long
             * java.lang.Number
             * java.lang.Byte
             * java.lang.Short
             * java.lang.Character
             * java.lang.Double
             * java.lang.Float
             * [I
             * 
             */
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(fis)) {
                @Override
                protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
                    // similar to system property jdk.serialFilter
                    String match="java.lang.*;java.util.*;org.eclipse.mat.parser.model.*;org.eclipse.mat.snapshot.*;org.eclipse.mat.snapshot.model.*;org.eclipse.mat.collect.*;!*"; //$NON-NLS-1$
                    String nm = desc.getName();
                    if (!nm.startsWith("[")) //$NON-NLS-1$
                    {
                        for (String pt : match.split(";")) //$NON-NLS-1$
                        {
                            boolean not = pt.startsWith("!"); //$NON-NLS-1$
                            if (not)
                                pt = pt.substring(1);
                            boolean m;
                            if (pt.endsWith(".**")) //$NON-NLS-1$
                                m = nm.startsWith(pt.substring(0, pt.length() - 2));
                            else if (pt.endsWith(".*")) //$NON-NLS-1$
                                m = nm.startsWith(pt.substring(0, pt.length() - 1))
                                                && !nm.substring(pt.length() - 1).contains("."); //$NON-NLS-1$
                            else if (pt.endsWith("*")) //$NON-NLS-1$
                                m = nm.startsWith(pt.substring(0, pt.length() - 1));
                            else
                                m = nm.equals(pt);
                            if (not && m)
                                throw new InvalidClassException(nm, match);
                            if (m)
                                break;
                        }
                    }
                    return super.resolveClass(desc);
                }
            };

            String version = in.readUTF();
            if (!VERSION.equals(version))

            }

            IndexManager indexManager = new IndexManager();
            boolean done = false;
            try
            {
                indexManager.init(prefix);

                SnapshotImpl ret = new SnapshotImpl(snapshotInfo, heapObjectReader, classCache, roots, rootsPerThread, loaderLabels,
                                arrayObjects, indexManager);
                listener.worked(3);
                done = true;

                return ret;
            }
            finally
            {
                if (!done)
                {
                    // Close files on error to allow delete
                    indexManager.close();
                }
            }
        }
        catch (ClassNotFoundException e)
        {




import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InvalidClassException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;


                list = new LinkedList<Entry>();

                /*
                 * org.eclipse.mat.ui.SnapshotHistoryService$Entry
                 * java.lang.Long
                 * java.lang.Number
                 * org.eclipse.mat.snapshot.SnapshotInfo
                 * java.util.Date
                 * java.util.HashMap
                 * java.lang.Boolean
                 */
                ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file)) {
                    @Override
                    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
                        // similar to system property jdk.serialFilter
                        String match="java.lang.*;java.util.*;org.eclipse.mat.snapshot.SnapshotInfo;org.eclipse.mat.ui.SnapshotHistoryService$Entry;!*"; //$NON-NLS-1$
                        String nm = desc.getName();
                        if (!nm.startsWith("[")) //$NON-NLS-1$
                        {
                            for (String pt : match.split(";")) //$NON-NLS-1$
                            {
                                boolean not = pt.startsWith("!"); //$NON-NLS-1$
                                if (not)
                                    pt = pt.substring(1);
                                boolean m;
                                if (pt.endsWith(".**")) //$NON-NLS-1$
                                    m = nm.startsWith(pt.substring(0, pt.length() - 2));
                                else if (pt.endsWith(".*")) //$NON-NLS-1$
                                    m = nm.startsWith(pt.substring(0, pt.length() - 1))
                                    && !nm.substring(pt.length() - 1).contains("."); //$NON-NLS-1$
                                else if (pt.endsWith("*")) //$NON-NLS-1$
                                    m = nm.startsWith(pt.substring(0, pt.length() - 1));
                                else
                                    m = nm.equals(pt);
                                if (not && m)
                                    throw new InvalidClassException(nm, match);
                                if (m)
                                    break;
                            }
                        }
                        return super.resolveClass(desc);
                    }
                };
                try
                {
                    int size = oin.readInt();




import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InvalidClassException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

        {
            try
            {
                /**
                 * org.eclipse.mat.ui.SnapshotHistoryService$Entry
                 * java.lang.Long
                 * java.lang.Number
                 * org.eclipse.mat.snapshot.SnapshotInfo
                 * java.util.Date
                 * java.util.HashMap
                 * java.lang.Boolean
                 */
                ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file)) {
                    @Override
                    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
                        // similar to system property jdk.serialFilter
                        String match="java.lang.*;java.util.*;org.eclipse.mat.snapshot.*;org.eclipse.mat.ui.SnapshotHistoryService$Entry;!*"; //$NON-NLS-1$
                        String nm = desc.getName();
                        if (!nm.startsWith("[")) //$NON-NLS-1$
                        {
                            for (String pt : match.split(";")) //$NON-NLS-1$
                            {
                                boolean not = pt.startsWith("!"); //$NON-NLS-1$
                                if (not)
                                    pt = pt.substring(1);
                                boolean m;
                                if (pt.endsWith(".**")) //$NON-NLS-1$
                                    m = nm.startsWith(pt.substring(0, pt.length() - 2));
                                else if (pt.endsWith(".*")) //$NON-NLS-1$
                                    m = nm.startsWith(pt.substring(0, pt.length() - 1))
                                    && !nm.substring(pt.length() - 1).contains("."); //$NON-NLS-1$
                                else if (pt.endsWith("*")) //$NON-NLS-1$
                                    m = nm.startsWith(pt.substring(0, pt.length() - 1));
                                else
                                    m = nm.equals(pt);
                                if (not && m)
                                    throw new InvalidClassException(nm, match);
                                if (m)
                                    break;
                            }
                        }
                        return super.resolveClass(desc);
                    }
                };
                try
                {
                    history = (LinkedList<String>) oin.readObject();

Return to bug 558633

Lines 17-24 Link Here

(-)a/plugins/org.eclipse.mat.parser/src/org/eclipse/mat/parser/internal/SnapshotImpl.java (-6 / +90 lines)
17	import java.io.FileInputStream;	17	import java.io.FileInputStream;
18	import java.io.FileOutputStream;	18	import java.io.FileOutputStream;
19	import java.io.IOException;	19	import java.io.IOException;
		20	import java.io.InvalidClassException;
20	import java.io.ObjectInputStream;	21	import java.io.ObjectInputStream;
21	import java.io.ObjectOutputStream;	22	import java.io.ObjectOutputStream;
		23	import java.io.ObjectStreamClass;
22	import java.util.ArrayList;	24	import java.util.ArrayList;
23	import java.util.Arrays;	25	import java.util.Arrays;
24	import java.util.Collection;	26	import java.util.Collection;
Lines 102-108 Link Here
102	File indexFile = new File(prefix + "index"); //$NON-NLS-1$	104	File indexFile = new File(prefix + "index"); //$NON-NLS-1$
103	fis = new FileInputStream(indexFile);	105	fis = new FileInputStream(indexFile);
104	listener.worked(1);	106	listener.worked(1);
105	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(fis));	107	/**
		108	* Classes deserialized:
		109	* org.eclipse.mat.parser.model.XSnapshotInfo
		110	* org.eclipse.mat.parser.model.AbstractObjectImpl
		111	* org.eclipse.mat.parser.model.XGCRootInfo
		112	* org.eclipse.mat.parser.model.ClassImpl
		113	* [Lorg.eclipse.mat.parser.model.XGCRootInfo
		114	* org.eclipse.mat.parser.model.XGCRootInfo
		115	*
		116	* org.eclipse.mat.snapshot.SnapshotInfo
		117	* org.eclipse.mat.snapshot.UnreachableObjectsHistogram
		118	*
		119	* org.eclipse.mat.snapshot.model.GCRootInfo
		120	* org.eclipse.mat.snapshot.model.FieldDescriptor
		121	* org.eclipse.mat.snapshot.model.Field
		122	* [Lorg.eclipse.mat.snapshot.model.FieldDescriptor
		123	* [Lorg.eclipse.mat.snapshot.model.Field
		124	* org.eclipse.mat.snapshot.model.ObjectReference
		125	*
		126	* org.eclipse.mat.collect.HashMapIntObject
		127	* org.eclipse.mat.collect.BitField
		128	*
		129	* java.util.ArrayList:
		130	* java.util.Date
		131	* java.util.HashMap
		132	*
		133	* java.lang.Boolean
		134	* java.lang.Long
		135	* java.lang.Number
		136	* java.lang.Byte
		137	* java.lang.Short
		138	* java.lang.Character
		139	* java.lang.Double
		140	* java.lang.Float
		141	* [I
		142	*
		143	*/
		144	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(fis)) {
		145	@Override
		146	protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
		147	// similar to system property jdk.serialFilter
		148	String match="java.lang.;java.util.;org.eclipse.mat.parser.model.;org.eclipse.mat.snapshot.;org.eclipse.mat.snapshot.model.;org.eclipse.mat.collect.;!*"; //$NON-NLS-1$
		149	String nm = desc.getName();
		150	if (!nm.startsWith("[")) //$NON-NLS-1$
		151	{
		152	for (String pt : match.split(";")) //$NON-NLS-1$
		153	{
		154	boolean not = pt.startsWith("!"); //$NON-NLS-1$
		155	if (not)
		156	pt = pt.substring(1);
		157	boolean m;
		158	if (pt.endsWith(".**")) //$NON-NLS-1$
		159	m = nm.startsWith(pt.substring(0, pt.length() - 2));
		160	else if (pt.endsWith(".*")) //$NON-NLS-1$
		161	m = nm.startsWith(pt.substring(0, pt.length() - 1))
		162	&& !nm.substring(pt.length() - 1).contains("."); //$NON-NLS-1$
		163	else if (pt.endsWith("*")) //$NON-NLS-1$
		164	m = nm.startsWith(pt.substring(0, pt.length() - 1));
		165	else
		166	m = nm.equals(pt);
		167	if (not && m)
		168	throw new InvalidClassException(nm, match);
		169	if (m)
		170	break;
		171	}
172	}
173	return super.resolveClass(desc);
174	}
175	};
106		176
107	String version = in.readUTF();	177	String version = in.readUTF();
108	if (!VERSION.equals(version))	178	if (!VERSION.equals(version))
Lines 155-166 Link Here
155	}	225	}
156		226
157	IndexManager indexManager = new IndexManager();	227	IndexManager indexManager = new IndexManager();
158	indexManager.init(prefix);	228	boolean done = false;
		229	try
		230	{
		231	indexManager.init(prefix);
159		232
160	SnapshotImpl ret = new SnapshotImpl(snapshotInfo, heapObjectReader, classCache, roots, rootsPerThread, loaderLabels,	233	SnapshotImpl ret = new SnapshotImpl(snapshotInfo, heapObjectReader, classCache, roots, rootsPerThread, loaderLabels,
161	arrayObjects, indexManager);	234	arrayObjects, indexManager);
162	listener.worked(3);	235	listener.worked(3);
163	return ret;	236	done = true;
		237
		238	return ret;
		239	}
		240	finally
		241	{
		242	if (!done)
		243	{
		244	// Close files on error to allow delete
		245	indexManager.close();
		246	}
		247	}
164	}	248	}
165	catch (ClassNotFoundException e)	249	catch (ClassNotFoundException e)
166	{	250	{

Lines 14-21 Link Here

(-)a/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/SnapshotHistoryService.java (-1 / +43 lines)
14	import java.io.FileInputStream;	14	import java.io.FileInputStream;
15	import java.io.FileOutputStream;	15	import java.io.FileOutputStream;
16	import java.io.IOException;	16	import java.io.IOException;
		17	import java.io.InvalidClassException;
17	import java.io.ObjectInputStream;	18	import java.io.ObjectInputStream;
18	import java.io.ObjectOutputStream;	19	import java.io.ObjectOutputStream;
		20	import java.io.ObjectStreamClass;
19	import java.io.Serializable;	21	import java.io.Serializable;
20	import java.util.ArrayList;	22	import java.util.ArrayList;
21	import java.util.Iterator;	23	import java.util.Iterator;
Lines 197-203 Link Here
197		199
198	list = new LinkedList<Entry>();	200	list = new LinkedList<Entry>();
199		201
200	ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));	202	/*
		203	* org.eclipse.mat.ui.SnapshotHistoryService$Entry
		204	* java.lang.Long
		205	* java.lang.Number
		206	* org.eclipse.mat.snapshot.SnapshotInfo
		207	* java.util.Date
		208	* java.util.HashMap
		209	* java.lang.Boolean
		210	*/
		211	ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file)) {
		212	@Override
		213	protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
		214	// similar to system property jdk.serialFilter
		215	String match="java.lang.;java.util.;org.eclipse.mat.snapshot.SnapshotInfo;org.eclipse.mat.ui.SnapshotHistoryService$Entry;!*"; //$NON-NLS-1$
		216	String nm = desc.getName();
		217	if (!nm.startsWith("[")) //$NON-NLS-1$
		218	{
		219	for (String pt : match.split(";")) //$NON-NLS-1$
		220	{
		221	boolean not = pt.startsWith("!"); //$NON-NLS-1$
		222	if (not)
		223	pt = pt.substring(1);
		224	boolean m;
		225	if (pt.endsWith(".**")) //$NON-NLS-1$
		226	m = nm.startsWith(pt.substring(0, pt.length() - 2));
		227	else if (pt.endsWith(".*")) //$NON-NLS-1$
		228	m = nm.startsWith(pt.substring(0, pt.length() - 1))
		229	&& !nm.substring(pt.length() - 1).contains("."); //$NON-NLS-1$
		230	else if (pt.endsWith("*")) //$NON-NLS-1$
		231	m = nm.startsWith(pt.substring(0, pt.length() - 1));
		232	else
		233	m = nm.equals(pt);
		234	if (not && m)
		235	throw new InvalidClassException(nm, match);
		236	if (m)
		237	break;
		238	}
		239	}
		240	return super.resolveClass(desc);
		241	}
		242	};
201	try	243	try
202	{	244	{
203	int size = oin.readInt();	245	int size = oin.readInt();

Lines 14-21 Link Here

(-)a/plugins/org.eclipse.mat.ui/src/org/eclipse/mat/ui/internal/browser/QueryHistory.java (-1 / +43 lines)
14	import java.io.FileInputStream;	14	import java.io.FileInputStream;
15	import java.io.FileOutputStream;	15	import java.io.FileOutputStream;
16	import java.io.IOException;	16	import java.io.IOException;
		17	import java.io.InvalidClassException;
17	import java.io.ObjectInputStream;	18	import java.io.ObjectInputStream;
18	import java.io.ObjectOutputStream;	19	import java.io.ObjectOutputStream;
		20	import java.io.ObjectStreamClass;
19	import java.util.ArrayList;	21	import java.util.ArrayList;
20	import java.util.Iterator;	22	import java.util.Iterator;
21	import java.util.LinkedList;	23	import java.util.LinkedList;
Lines 72-78 Link Here
72	{	74	{
73	try	75	try
74	{	76	{
75	ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file));	77	/**
		78	* org.eclipse.mat.ui.SnapshotHistoryService$Entry
		79	* java.lang.Long
		80	* java.lang.Number
		81	* org.eclipse.mat.snapshot.SnapshotInfo
		82	* java.util.Date
		83	* java.util.HashMap
		84	* java.lang.Boolean
		85	*/
		86	ObjectInputStream oin = new ObjectInputStream(new FileInputStream(file)) {
		87	@Override
		88	protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
		89	// similar to system property jdk.serialFilter
		90	String match="java.lang.;java.util.;org.eclipse.mat.snapshot.;org.eclipse.mat.ui.SnapshotHistoryService$Entry;!"; //$NON-NLS-1$
		91	String nm = desc.getName();
		92	if (!nm.startsWith("[")) //$NON-NLS-1$
		93	{
		94	for (String pt : match.split(";")) //$NON-NLS-1$
		95	{
		96	boolean not = pt.startsWith("!"); //$NON-NLS-1$
		97	if (not)
		98	pt = pt.substring(1);
		99	boolean m;
		100	if (pt.endsWith(".**")) //$NON-NLS-1$
		101	m = nm.startsWith(pt.substring(0, pt.length() - 2));
		102	else if (pt.endsWith(".*")) //$NON-NLS-1$
		103	m = nm.startsWith(pt.substring(0, pt.length() - 1))
		104	&& !nm.substring(pt.length() - 1).contains("."); //$NON-NLS-1$
		105	else if (pt.endsWith("*")) //$NON-NLS-1$
		106	m = nm.startsWith(pt.substring(0, pt.length() - 1));
		107	else
		108	m = nm.equals(pt);
		109	if (not && m)
		110	throw new InvalidClassException(nm, match);
		111	if (m)
		112	break;
		113	}
		114	}
		115	return super.resolveClass(desc);
		116	}
		117	};
76	try	118	try
77	{	119	{
78	history = (LinkedList<String>) oin.readObject();	120	history = (LinkedList<String>) oin.readObject();