/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Copyright 2009 Sun Microsystems, Inc.
|
*/
|
|
package org.opends.sdk.ldif;
|
|
|
|
import static com.sun.opends.sdk.messages.Messages.*;
|
import static com.sun.opends.sdk.util.StaticUtils.*;
|
|
import java.io.BufferedReader;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.net.URL;
|
import java.util.Iterator;
|
import java.util.LinkedList;
|
import java.util.List;
|
|
import org.opends.sdk.*;
|
|
import com.sun.opends.sdk.util.*;
|
|
|
|
/**
|
* Common LDIF reader functionality.
|
*/
|
abstract class AbstractLDIFReader extends AbstractLDIFStream
|
{
|
static final class KeyValuePair
|
{
|
String key;
|
|
String value;
|
}
|
|
|
|
/**
|
* LDIF reader implementation interface.
|
*/
|
interface LDIFReaderImpl
|
{
|
|
/**
|
* Closes any resources associated with this LDIF reader
|
* implementation.
|
*
|
* @throws IOException
|
* If an error occurs while closing.
|
*/
|
void close() throws IOException;
|
|
|
|
/**
|
* Reads the next line of LDIF from the underlying LDIF source.
|
* Implementations must remove trailing line delimiters.
|
*
|
* @return The next line of LDIF, or {@code null} if the end of the
|
* LDIF source has been reached.
|
* @throws IOException
|
* If an error occurs while reading from the LDIF source.
|
*/
|
String readLine() throws IOException;
|
}
|
|
|
|
final class LDIFRecord
|
{
|
final Iterator<String> iterator;
|
|
final LinkedList<String> ldifLines;
|
|
final long lineNumber;
|
|
|
|
private LDIFRecord(long lineNumber, LinkedList<String> ldifLines)
|
{
|
this.lineNumber = lineNumber;
|
this.ldifLines = ldifLines;
|
this.iterator = ldifLines.iterator();
|
}
|
}
|
|
|
|
/**
|
* LDIF output stream writer implementation.
|
*/
|
private final class LDIFReaderInputStreamImpl implements
|
LDIFReaderImpl
|
{
|
|
private BufferedReader reader;
|
|
|
|
/**
|
* Creates a new LDIF input stream reader implementation.
|
*
|
* @param in
|
* The input stream to use.
|
*/
|
LDIFReaderInputStreamImpl(InputStream in)
|
{
|
this.reader = new BufferedReader(new InputStreamReader(in));
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public void close() throws IOException
|
{
|
reader.close();
|
reader = null;
|
}
|
|
|
|
/**
|
*{@inheritDoc}
|
*/
|
public String readLine() throws IOException
|
{
|
String line = null;
|
if (reader != null)
|
{
|
line = reader.readLine();
|
if (line == null)
|
{
|
// Automatically close.
|
close();
|
}
|
}
|
return line;
|
}
|
}
|
|
|
|
/**
|
* LDIF output stream writer implementation.
|
*/
|
private final class LDIFReaderListImpl implements LDIFReaderImpl
|
{
|
|
private final Iterator<String> iterator;
|
|
|
|
/**
|
* Creates a new LDIF list reader.
|
*
|
* @param ldifLines
|
* The string list.
|
*/
|
LDIFReaderListImpl(List<String> ldifLines)
|
{
|
this.iterator = ldifLines.iterator();
|
}
|
|
|
|
/**
|
* {@inheritDoc}
|
*/
|
public void close() throws IOException
|
{
|
// Nothing to do.
|
}
|
|
|
|
/**
|
*{@inheritDoc}
|
*/
|
public String readLine() throws IOException
|
{
|
if (iterator.hasNext())
|
{
|
return iterator.next();
|
}
|
else
|
{
|
return null;
|
}
|
}
|
}
|
|
|
|
boolean validateSchema = true;
|
|
private final LDIFReaderImpl impl;
|
|
private long lineNumber = 0;
|
|
|
|
/**
|
* Creates a new LDIF entry reader whose source is the provided input
|
* stream.
|
*
|
* @param in
|
* The input stream to use.
|
*/
|
AbstractLDIFReader(InputStream in)
|
{
|
Validator.ensureNotNull(in);
|
this.impl = new LDIFReaderInputStreamImpl(in);
|
}
|
|
|
|
/**
|
* Creates a new LDIF entry reader which will read lines of LDIF from
|
* the provided list.
|
*
|
* @param ldifLines
|
* The list from which lines of LDIF should be read.
|
*/
|
AbstractLDIFReader(List<String> ldifLines)
|
{
|
Validator.ensureNotNull(ldifLines);
|
this.impl = new LDIFReaderListImpl(ldifLines);
|
}
|
|
|
|
final void close0() throws IOException
|
{
|
impl.close();
|
}
|
|
|
|
final int parseColonPosition(LDIFRecord record, String ldifLine)
|
throws DecodeException
|
{
|
final int colonPos = ldifLine.indexOf(":");
|
if (colonPos <= 0)
|
{
|
final LocalizableMessage message = ERR_LDIF_NO_ATTR_NAME.get(
|
record.lineNumber, ldifLine);
|
throw DecodeException.error(message);
|
}
|
return colonPos;
|
}
|
|
|
|
final ByteString parseSingleValue(LDIFRecord record, String ldifLine,
|
DN entryDN, int colonPos, String attrName) throws DecodeException
|
{
|
|
// Look at the character immediately after the colon. If there is
|
// none, then assume an attribute with an empty value. If it is
|
// another colon, then the value must be base64-encoded. If it is a
|
// less-than sign, then assume that it is a URL. Otherwise, it is a
|
// regular value.
|
final int length = ldifLine.length();
|
ByteString value;
|
if (colonPos == length - 1)
|
{
|
value = ByteString.empty();
|
}
|
else
|
{
|
final char c = ldifLine.charAt(colonPos + 1);
|
if (c == ':')
|
{
|
// The value is base64-encoded. Find the first non-blank
|
// character, take the rest of the line, and base64-decode it.
|
int pos = colonPos + 2;
|
while (pos < length && ldifLine.charAt(pos) == ' ')
|
{
|
pos++;
|
}
|
|
try
|
{
|
value = Base64.decode(ldifLine.substring(pos));
|
}
|
catch (final LocalizedIllegalArgumentException e)
|
{
|
// The value did not have a valid base64-encoding.
|
final LocalizableMessage message = ERR_LDIF_COULD_NOT_BASE64_DECODE_ATTR
|
.get(entryDN.toString(), record.lineNumber, ldifLine, e
|
.getMessageObject());
|
throw DecodeException.error(message);
|
}
|
}
|
else if (c == '<')
|
{
|
// Find the first non-blank character, decode the rest of the
|
// line as a URL, and read its contents.
|
int pos = colonPos + 2;
|
while (pos < length && ldifLine.charAt(pos) == ' ')
|
{
|
pos++;
|
}
|
|
URL contentURL;
|
try
|
{
|
contentURL = new URL(ldifLine.substring(pos));
|
}
|
catch (final Exception e)
|
{
|
// The URL was malformed or had an invalid protocol.
|
final LocalizableMessage message = ERR_LDIF_INVALID_URL.get(entryDN
|
.toString(), record.lineNumber, attrName, String
|
.valueOf(e));
|
throw DecodeException.error(message);
|
}
|
|
InputStream inputStream = null;
|
ByteStringBuilder builder = null;
|
try
|
{
|
builder = new ByteStringBuilder();
|
inputStream = contentURL.openConnection().getInputStream();
|
|
int bytesRead;
|
final byte[] buffer = new byte[4096];
|
while ((bytesRead = inputStream.read(buffer)) > 0)
|
{
|
builder.append(buffer, 0, bytesRead);
|
}
|
|
value = builder.toByteString();
|
}
|
catch (final Exception e)
|
{
|
// We were unable to read the contents of that URL for some
|
// reason.
|
final LocalizableMessage message = ERR_LDIF_URL_IO_ERROR.get(entryDN
|
.toString(), record.lineNumber, attrName, String
|
.valueOf(contentURL), String.valueOf(e));
|
throw DecodeException.error(message);
|
}
|
finally
|
{
|
if (inputStream != null)
|
{
|
try
|
{
|
inputStream.close();
|
}
|
catch (final Exception e)
|
{
|
// Ignore.
|
}
|
}
|
}
|
}
|
else
|
{
|
// The rest of the line should be the value. Skip over any
|
// spaces and take the rest of the line as the value.
|
int pos = colonPos + 1;
|
while (pos < length && ldifLine.charAt(pos) == ' ')
|
{
|
pos++;
|
}
|
|
value = ByteString.valueOf(ldifLine.substring(pos));
|
}
|
}
|
return value;
|
}
|
|
|
|
final LDIFRecord readLDIFRecord() throws IOException
|
{
|
// Read the entry lines into a buffer.
|
final StringBuilder lastLineBuilder = new StringBuilder();
|
final LinkedList<String> ldifLines = new LinkedList<String>();
|
long recordLineNumber = 0;
|
|
final int START = 0;
|
final int START_COMMENT_LINE = 1;
|
final int GOT_LDIF_LINE = 2;
|
final int GOT_COMMENT_LINE = 3;
|
final int APPENDING_LDIF_LINE = 4;
|
|
int state = START;
|
|
while (true)
|
{
|
final String line = readLine();
|
|
switch (state)
|
{
|
case START:
|
if (line == null)
|
{
|
// We have reached the end of the LDIF source.
|
return null;
|
}
|
else if (line.length() == 0)
|
{
|
// Skip leading blank lines.
|
}
|
else if (line.charAt(0) == '#')
|
{
|
// This is a comment at the start of the LDIF record.
|
state = START_COMMENT_LINE;
|
}
|
else if (isContinuationLine(line))
|
{
|
// Fatal: got a continuation line at the start of the record.
|
final LocalizableMessage message = ERR_LDIF_INVALID_LEADING_SPACE.get(
|
lineNumber, line);
|
throw DecodeException.fatalError(message);
|
}
|
else
|
{
|
// Got the first line of LDIF.
|
ldifLines.add(line);
|
recordLineNumber = lineNumber;
|
state = GOT_LDIF_LINE;
|
}
|
break;
|
case START_COMMENT_LINE:
|
if (line == null)
|
{
|
// We have reached the end of the LDIF source.
|
return null;
|
}
|
else if (line.length() == 0)
|
{
|
// Skip leading blank lines and comments.
|
state = START;
|
}
|
else if (line.charAt(0) == '#')
|
{
|
// This is another comment at the start of the LDIF record.
|
}
|
else if (isContinuationLine(line))
|
{
|
// Skip comment continuation lines.
|
}
|
else
|
{
|
// Got the first line of LDIF.
|
ldifLines.add(line);
|
recordLineNumber = lineNumber;
|
state = GOT_LDIF_LINE;
|
}
|
break;
|
case GOT_LDIF_LINE:
|
if (line == null)
|
{
|
// We have reached the end of the LDIF source.
|
return new LDIFRecord(recordLineNumber, ldifLines);
|
}
|
else if (line.length() == 0)
|
{
|
// We have reached the end of the LDIF record.
|
return new LDIFRecord(recordLineNumber, ldifLines);
|
}
|
else if (line.charAt(0) == '#')
|
{
|
// This is a comment.
|
state = GOT_COMMENT_LINE;
|
}
|
else if (isContinuationLine(line))
|
{
|
// Got a continuation line for the previous line.
|
lastLineBuilder.setLength(0);
|
lastLineBuilder.append(ldifLines.removeLast());
|
lastLineBuilder.append(line.substring(1));
|
state = APPENDING_LDIF_LINE;
|
}
|
else
|
{
|
// Got the next line of LDIF.
|
ldifLines.add(line);
|
state = GOT_LDIF_LINE;
|
}
|
break;
|
case GOT_COMMENT_LINE:
|
if (line == null)
|
{
|
// We have reached the end of the LDIF source.
|
return new LDIFRecord(recordLineNumber, ldifLines);
|
}
|
else if (line.length() == 0)
|
{
|
// We have reached the end of the LDIF record.
|
return new LDIFRecord(recordLineNumber, ldifLines);
|
}
|
else if (line.charAt(0) == '#')
|
{
|
// This is another comment.
|
state = GOT_COMMENT_LINE;
|
}
|
else if (isContinuationLine(line))
|
{
|
// Skip comment continuation lines.
|
}
|
else
|
{
|
// Got the next line of LDIF.
|
ldifLines.add(line);
|
state = GOT_LDIF_LINE;
|
}
|
break;
|
case APPENDING_LDIF_LINE:
|
if (line == null)
|
{
|
// We have reached the end of the LDIF source.
|
ldifLines.add(lastLineBuilder.toString());
|
return new LDIFRecord(recordLineNumber, ldifLines);
|
}
|
else if (line.length() == 0)
|
{
|
// We have reached the end of the LDIF record.
|
ldifLines.add(lastLineBuilder.toString());
|
return new LDIFRecord(recordLineNumber, ldifLines);
|
}
|
else if (line.charAt(0) == '#')
|
{
|
// This is a comment.
|
ldifLines.add(lastLineBuilder.toString());
|
state = GOT_COMMENT_LINE;
|
}
|
else if (isContinuationLine(line))
|
{
|
// Got another continuation line for the previous line.
|
lastLineBuilder.append(line.substring(1));
|
}
|
else
|
{
|
// Got the next line of LDIF.
|
ldifLines.add(lastLineBuilder.toString());
|
ldifLines.add(line);
|
state = GOT_LDIF_LINE;
|
}
|
break;
|
}
|
}
|
}
|
|
|
|
final void readLDIFRecordAttributeValue(LDIFRecord record,
|
String ldifLine, Entry entry) throws DecodeException
|
{
|
// Parse the attribute description.
|
final int colonPos = parseColonPosition(record, ldifLine);
|
final String attrDescr = ldifLine.substring(0, colonPos);
|
|
AttributeDescription attributeDescription;
|
try
|
{
|
attributeDescription = AttributeDescription.valueOf(attrDescr,
|
schema);
|
}
|
catch (final LocalizedIllegalArgumentException e)
|
{
|
throw DecodeException.error(e.getMessageObject());
|
}
|
|
// Now parse the attribute value.
|
final ByteString value = parseSingleValue(record, ldifLine, entry
|
.getName(), colonPos, attrDescr);
|
|
// Skip the attribute if requested before performing any schema
|
// checking: the attribute may have been excluded because it is
|
// known to violate the schema.
|
if (isAttributeExcluded(attributeDescription))
|
{
|
return;
|
}
|
|
// Ensure that the binary option is present if required.
|
if (!attributeDescription.getAttributeType().getSyntax()
|
.isBEREncodingRequired())
|
{
|
if (validateSchema
|
&& attributeDescription.containsOption("binary"))
|
{
|
final LocalizableMessage message = ERR_LDIF_INVALID_ATTR_OPTION.get(entry
|
.getName().toString(), record.lineNumber, attrDescr);
|
throw DecodeException.error(message);
|
}
|
}
|
else
|
{
|
attributeDescription = AttributeDescription.create(
|
attributeDescription, "binary");
|
}
|
|
Attribute attribute = entry.getAttribute(attributeDescription);
|
if (attribute == null)
|
{
|
if (validateSchema)
|
{
|
final LocalizableMessageBuilder invalidReason = new LocalizableMessageBuilder();
|
if (!attributeDescription.getAttributeType().getSyntax()
|
.valueIsAcceptable(value, invalidReason))
|
{
|
final LocalizableMessage message = WARN_LDIF_VALUE_VIOLATES_SYNTAX.get(
|
entry.getName().toString(), record.lineNumber, value
|
.toString(), attrDescr, invalidReason);
|
throw DecodeException.error(message);
|
}
|
}
|
|
attribute = new LinkedAttribute(attributeDescription, value);
|
entry.addAttribute(attribute);
|
}
|
else
|
{
|
if (validateSchema)
|
{
|
final LocalizableMessageBuilder invalidReason = new LocalizableMessageBuilder();
|
if (!attributeDescription.getAttributeType().getSyntax()
|
.valueIsAcceptable(value, invalidReason))
|
{
|
final LocalizableMessage message = WARN_LDIF_VALUE_VIOLATES_SYNTAX.get(
|
entry.getName().toString(), record.lineNumber, value
|
.toString(), attrDescr, invalidReason);
|
throw DecodeException.error(message);
|
}
|
|
if (!attribute.add(value))
|
{
|
final LocalizableMessage message = WARN_LDIF_DUPLICATE_ATTR.get(entry
|
.getName().toString(), record.lineNumber, attrDescr,
|
value.toString());
|
throw DecodeException.error(message);
|
}
|
|
if (attributeDescription.getAttributeType().isSingleValue())
|
{
|
final LocalizableMessage message = ERR_LDIF_MULTIPLE_VALUES_FOR_SINGLE_VALUED_ATTR
|
.get(entry.getName().toString(), record.lineNumber,
|
attrDescr);
|
throw DecodeException.error(message);
|
}
|
}
|
else
|
{
|
attribute.add(value);
|
}
|
}
|
}
|
|
|
|
final DN readLDIFRecordDN(LDIFRecord record) throws DecodeException
|
{
|
String ldifLine = record.iterator.next();
|
int colonPos = ldifLine.indexOf(":");
|
if (colonPos <= 0)
|
{
|
final LocalizableMessage message = ERR_LDIF_NO_ATTR_NAME.get(
|
record.lineNumber, ldifLine.toString());
|
throw DecodeException.error(message);
|
}
|
|
String attrName = toLowerCase(ldifLine.substring(0, colonPos));
|
if (attrName.equals("version"))
|
{
|
// This is the version line, try the next line if there is one.
|
if (!record.iterator.hasNext())
|
{
|
return null;
|
}
|
|
ldifLine = record.iterator.next();
|
colonPos = ldifLine.indexOf(":");
|
if (colonPos <= 0)
|
{
|
final LocalizableMessage message = ERR_LDIF_NO_ATTR_NAME.get(
|
record.lineNumber, ldifLine.toString());
|
throw DecodeException.error(message);
|
}
|
|
attrName = toLowerCase(ldifLine.substring(0, colonPos));
|
}
|
|
if (!attrName.equals("dn"))
|
{
|
final LocalizableMessage message = ERR_LDIF_NO_DN.get(record.lineNumber,
|
ldifLine.toString());
|
throw DecodeException.error(message);
|
}
|
|
// Look at the character immediately after the colon. If there is
|
// none, then assume the null DN. If it is another colon, then the
|
// DN must be base64-encoded. Otherwise, it may be one or more
|
// spaces.
|
final int length = ldifLine.length();
|
if (colonPos == length - 1)
|
{
|
return DN.rootDN();
|
}
|
|
String dnString = null;
|
|
if (ldifLine.charAt(colonPos + 1) == ':')
|
{
|
// The DN is base64-encoded. Find the first non-blank character
|
// and take the rest of the line and base64-decode it.
|
int pos = colonPos + 2;
|
while (pos < length && ldifLine.charAt(pos) == ' ')
|
{
|
pos++;
|
}
|
|
final String base64DN = ldifLine.substring(pos);
|
try
|
{
|
dnString = Base64.decode(base64DN).toString();
|
}
|
catch (final LocalizedIllegalArgumentException e)
|
{
|
// The value did not have a valid base64-encoding.
|
final LocalizableMessage message = ERR_LDIF_COULD_NOT_BASE64_DECODE_DN
|
.get(record.lineNumber, ldifLine, e.getMessageObject());
|
throw DecodeException.error(message);
|
}
|
}
|
else
|
{
|
// The rest of the value should be the DN. Skip over any spaces
|
// and attempt to decode the rest of the line as the DN.
|
int pos = colonPos + 1;
|
while (pos < length && ldifLine.charAt(pos) == ' ')
|
{
|
pos++;
|
}
|
|
dnString = ldifLine.substring(pos);
|
}
|
|
try
|
{
|
return DN.valueOf(dnString, schema);
|
}
|
catch (final LocalizedIllegalArgumentException e)
|
{
|
final LocalizableMessage message = ERR_LDIF_INVALID_DN.get(
|
record.lineNumber, ldifLine, e.getMessageObject());
|
throw DecodeException.error(message);
|
}
|
}
|
|
|
|
final String readLDIFRecordKeyValuePair(LDIFRecord record,
|
KeyValuePair pair, boolean allowBase64) throws DecodeException
|
{
|
final String ldifLine = record.iterator.next();
|
final int colonPos = ldifLine.indexOf(":");
|
if (colonPos <= 0)
|
{
|
final LocalizableMessage message = ERR_LDIF_NO_ATTR_NAME.get(
|
record.lineNumber, ldifLine);
|
throw DecodeException.error(message);
|
}
|
pair.key = ldifLine.substring(0, colonPos);
|
|
// Look at the character immediately after the colon. If there is
|
// none, then no value was specified. Throw an exception
|
final int length = ldifLine.length();
|
if (colonPos == length - 1)
|
{
|
// FIXME: improve error.
|
final LocalizableMessage message = LocalizableMessage
|
.raw("Malformed changetype attribute");
|
throw DecodeException.error(message);
|
}
|
|
if (allowBase64 && ldifLine.charAt(colonPos + 1) == ':')
|
{
|
// The value is base64-encoded. Find the first non-blank
|
// character, take the rest of the line, and base64-decode it.
|
int pos = colonPos + 2;
|
while (pos < length && ldifLine.charAt(pos) == ' ')
|
{
|
pos++;
|
}
|
|
try
|
{
|
pair.value = Base64.decode(ldifLine.substring(pos)).toString();
|
}
|
catch (final LocalizedIllegalArgumentException e)
|
{
|
// The value did not have a valid base64-encoding.
|
// FIXME: improve error.
|
final LocalizableMessage message = LocalizableMessage
|
.raw("Malformed base64 changetype attribute");
|
throw DecodeException.error(message);
|
}
|
}
|
else
|
{
|
// The rest of the value should be the changetype. Skip over any
|
// spaces and attempt to decode the rest of the line as the
|
// changetype string.
|
int pos = colonPos + 1;
|
while (pos < length && ldifLine.charAt(pos) == ' ')
|
{
|
pos++;
|
}
|
|
pair.value = ldifLine.substring(pos);
|
}
|
|
return ldifLine;
|
}
|
|
|
|
final void rejectLDIFRecord(LDIFRecord record, LocalizableMessage message)
|
throws DecodeException
|
{
|
// FIXME: not yet implemented.
|
throw DecodeException.error(message);
|
}
|
|
|
|
final void skipLDIFRecord(LDIFRecord record, LocalizableMessage message)
|
{
|
// FIXME: not yet implemented.
|
}
|
|
|
|
// Determine whether the provided line is a continuation line. Note
|
// that while RFC 2849 technically only allows a space in this
|
// position, both OpenLDAP and the Sun Java System Directory Server
|
// allow a tab as well, so we will too for compatibility reasons. See
|
// issue #852 for details.
|
private boolean isContinuationLine(String line)
|
{
|
return line.charAt(0) == ' ' || line.charAt(0) == '\t';
|
}
|
|
|
|
private String readLine() throws IOException
|
{
|
final String line = impl.readLine();
|
if (line != null)
|
{
|
lineNumber++;
|
}
|
return line;
|
}
|
|
}
|
