/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.felix.framework.security.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import java.util.Map.Entry;
import org.apache.felix.framework.util.SecureAction;
public final class PropertiesCache
{
private final File m_file;
private final File m_tmp;
private final SecureAction m_action;
public PropertiesCache(File store, File tmp, SecureAction action)
{
m_action = action;
m_file = store;
m_tmp = tmp;
}
public void write(Map data) throws IOException
{
OutputStream out = null;
File tmp = null;
File tmp2 = null;
try
{
tmp = m_action.createTempFile("tmp", null, m_tmp);
tmp2 = m_action.createTempFile("tmp", null, m_tmp);
m_action.deleteFile(tmp2);
Exception org = null;
try
{
out = m_action.getFileOutputStream(tmp);
Properties store = new Properties();
int count = 0;
for (Iterator iter = data.entrySet().iterator(); iter.hasNext();)
{
Entry entry = (Entry) iter.next();
store.setProperty(count++ + "-" + (String) entry.getKey(),
getEncoded(entry.getValue()));
}
store.store(out, null);
}
catch (IOException ex)
{
org = ex;
throw ex;
}
finally
{
if (out != null)
{
try
{
out.close();
}
catch (IOException ex)
{
if (org == null)
{
throw ex;
}
}
}
}
if ((m_action.fileExists(m_file) && !m_action.renameFile(m_file,
tmp2))
|| !m_action.renameFile(tmp, m_file))
{
throw new IOException("Unable to write permissions");
}
}
catch (IOException ex)
{
if (!m_action.fileExists(m_file) && (tmp2 != null)
&& m_action.fileExists(tmp2))
{
m_action.renameFile(tmp2, m_file);
}
throw ex;
}
finally
{
if (tmp != null)
{
m_action.deleteFile(tmp);
}
if (tmp2 != null)
{
m_action.deleteFile(tmp2);
}
}
}
public void read(Class target, Map map) throws IOException
{
if (!m_file.isFile())
{
return;
}
InputStream in = null;
Exception other = null;
Map result = new TreeMap();
try
{
in = m_action.getFileInputStream(m_file);
Properties store = new Properties();
store.load(in);
for (Iterator iter = store.entrySet().iterator(); iter.hasNext();)
{
Entry entry = (Entry) iter.next();
result.put(entry.getKey(), getUnencoded((String) entry
.getValue(), target));
}
}
catch (IOException ex)
{
other = ex;
throw ex;
}
finally
{
if (in != null)
{
try
{
in.close();
}
catch (IOException ex)
{
if (other == null)
{
throw ex;
}
}
}
}
for (Iterator iter = result.entrySet().iterator(); iter.hasNext();)
{
Entry entry = (Entry) iter.next();
String key = (String) entry.getKey();
map.put(key.substring(key.indexOf("-")), entry.getValue());
}
}
private String getEncoded(Object target) throws IOException
{
Properties props = new Properties();
if (target.getClass().isArray())
{
Object[] array = (Object[]) target;
for (int i = 0; i < array.length; i++)
{
props.setProperty(Integer.toString(i), array[i].toString());
}
ByteArrayOutputStream tmp = new ByteArrayOutputStream();
props.store(tmp, null);
return new String(tmp.toByteArray());
}
return target.toString();
}
private Object getUnencoded(String encoded, Class target)
throws IOException
{
try
{
if (target.isArray())
{
Properties props = new Properties();
props.load(new ByteArrayInputStream(encoded.getBytes()));
Class componentType = target.getComponentType();
Constructor constructor = m_action.getConstructor(
componentType, new Class[] { String.class });
Object[] params = new Object[1];
Object[] result = (Object[]) Array.newInstance(componentType,
props.size());
for (Iterator iter = props.entrySet().iterator(); iter
.hasNext();)
{
Entry entry = (Entry) iter.next();
params[0] = entry.getValue();
result[Integer.parseInt((String) entry.getKey())] = constructor
.newInstance(params);
}
return result;
}
return m_action.invoke(m_action.getConstructor(target,
new Class[] { String.class }), new Object[] { encoded });
}
catch (Exception ex)
{
ex.printStackTrace();
throw new IOException(ex.getMessage());
}
}
}