/*
|
* 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 legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* 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 legal-notices/CDDLv1_0.txt.
|
* 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-2010 Sun Microsystems, Inc.
|
* Portions copyright 2011-2013 ForgeRock AS
|
*/
|
|
package org.forgerock.opendj.ldif;
|
|
import static com.forgerock.opendj.util.StaticUtils.toLowerCase;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_COULD_NOT_BASE64_DECODE_ATTR;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_COULD_NOT_BASE64_DECODE_DN;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_INVALID_DN;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_INVALID_LEADING_SPACE;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_INVALID_URL;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_MALFORMED_ATTRIBUTE_NAME;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_MULTI_VALUED_SINGLE_VALUED_ATTRIBUTE;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_NO_ATTR_NAME;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_NO_DN;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_UNEXPECTED_BINARY_OPTION;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_UNKNOWN_ATTRIBUTE_TYPE;
|
import static org.forgerock.opendj.ldap.CoreMessages.ERR_LDIF_URL_IO_ERROR;
|
import static org.forgerock.opendj.ldap.CoreMessages.WARN_LDIF_DUPLICATE_ATTRIBUTE_VALUE;
|
|
import java.io.BufferedReader;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.InputStreamReader;
|
import java.io.Reader;
|
import java.net.URL;
|
import java.util.Iterator;
|
import java.util.LinkedList;
|
import java.util.List;
|
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.forgerock.i18n.LocalizableMessageBuilder;
|
import org.forgerock.i18n.LocalizedIllegalArgumentException;
|
import org.forgerock.opendj.ldap.Attribute;
|
import org.forgerock.opendj.ldap.AttributeDescription;
|
import org.forgerock.opendj.ldap.ByteString;
|
import org.forgerock.opendj.ldap.ByteStringBuilder;
|
import org.forgerock.opendj.ldap.DN;
|
import org.forgerock.opendj.ldap.DecodeException;
|
import org.forgerock.opendj.ldap.Entry;
|
import org.forgerock.opendj.ldap.LinkedAttribute;
|
import org.forgerock.opendj.ldap.schema.Schema;
|
import org.forgerock.opendj.ldap.schema.SchemaValidationPolicy;
|
import org.forgerock.opendj.ldap.schema.Syntax;
|
import org.forgerock.opendj.ldap.schema.UnknownSchemaElementException;
|
|
import com.forgerock.opendj.util.Validator;
|
|
/**
|
* 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;
|
}
|
|
static final class LDIFRecord {
|
final Iterator<String> iterator;
|
final LinkedList<String> ldifLines;
|
final long lineNumber;
|
|
private LDIFRecord(final long lineNumber, final LinkedList<String> ldifLines) {
|
this.lineNumber = lineNumber;
|
this.ldifLines = ldifLines;
|
this.iterator = ldifLines.iterator();
|
}
|
}
|
|
/**
|
* LDIF output stream writer implementation.
|
*/
|
private static final class LDIFReaderInputStreamImpl implements LDIFReaderImpl {
|
private BufferedReader reader;
|
|
LDIFReaderInputStreamImpl(final Reader reader) {
|
this.reader =
|
reader instanceof BufferedReader ? (BufferedReader) reader
|
: new BufferedReader(reader);
|
}
|
|
@Override
|
public void close() throws IOException {
|
if (reader != null) {
|
reader.close();
|
reader = null;
|
}
|
}
|
|
@Override
|
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 static final class LDIFReaderListImpl implements LDIFReaderImpl {
|
private final Iterator<String> iterator;
|
|
LDIFReaderListImpl(final List<String> ldifLines) {
|
this.iterator = ldifLines.iterator();
|
}
|
|
@Override
|
public void close() throws IOException {
|
// Nothing to do.
|
}
|
|
@Override
|
public String readLine() throws IOException {
|
if (iterator.hasNext()) {
|
return iterator.next();
|
} else {
|
return null;
|
}
|
}
|
}
|
|
RejectedLDIFListener rejectedRecordListener = RejectedLDIFListener.FAIL_FAST;
|
Schema schema = Schema.getDefaultSchema().asNonStrictSchema();
|
SchemaValidationPolicy schemaValidationPolicy = SchemaValidationPolicy.ignoreAll();
|
private final LDIFReaderImpl impl;
|
private long lineNumber = 0;
|
|
AbstractLDIFReader(final InputStream in) {
|
this(new InputStreamReader(in));
|
}
|
|
AbstractLDIFReader(final List<String> ldifLines) {
|
Validator.ensureNotNull(ldifLines);
|
this.impl = new LDIFReaderListImpl(ldifLines);
|
}
|
|
AbstractLDIFReader(final Reader reader) {
|
this.impl = new LDIFReaderInputStreamImpl(reader);
|
}
|
|
final void close0() throws IOException {
|
impl.close();
|
}
|
|
final void handleMalformedRecord(final LDIFRecord record, final LocalizableMessage message)
|
throws DecodeException {
|
rejectedRecordListener.handleMalformedRecord(record.lineNumber, record.ldifLines, message);
|
}
|
|
final void handleSchemaValidationFailure(final LDIFRecord record,
|
final List<LocalizableMessage> messages) throws DecodeException {
|
rejectedRecordListener.handleSchemaValidationFailure(record.lineNumber, record.ldifLines,
|
messages);
|
}
|
|
final void handleSchemaValidationWarning(final LDIFRecord record,
|
final List<LocalizableMessage> messages) throws DecodeException {
|
rejectedRecordListener.handleSchemaValidationWarning(record.lineNumber, record.ldifLines,
|
messages);
|
}
|
|
final void handleSkippedRecord(final LDIFRecord record, final LocalizableMessage message)
|
throws DecodeException {
|
rejectedRecordListener.handleSkippedRecord(record.lineNumber, record.ldifLines, message);
|
}
|
|
final int parseColonPosition(final LDIFRecord record, final 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(final LDIFRecord record, final String ldifLine,
|
final DN entryDN, final int colonPos, final 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 = ByteString.valueOfBase64(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 stateStart = 0;
|
final int stateStartCommentLine = 1;
|
final int stateGotLDIFLine = 2;
|
final int stateGotCommentLine = 3;
|
final int appendingLDIFLine = 4;
|
int state = stateStart;
|
|
while (true) {
|
final String line = readLine();
|
|
switch (state) {
|
case stateStart:
|
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 = stateStartCommentLine;
|
} 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 = stateGotLDIFLine;
|
}
|
break;
|
case stateStartCommentLine:
|
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 = stateStart;
|
} 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 = stateGotLDIFLine;
|
}
|
break;
|
case stateGotLDIFLine:
|
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 = stateGotCommentLine;
|
} 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 = appendingLDIFLine;
|
} else {
|
// Got the next line of LDIF.
|
ldifLines.add(line);
|
state = stateGotLDIFLine;
|
}
|
break;
|
case stateGotCommentLine:
|
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 = stateGotCommentLine;
|
} else if (isContinuationLine(line)) {
|
// Skip comment continuation lines.
|
} else {
|
// Got the next line of LDIF.
|
ldifLines.add(line);
|
state = stateGotLDIFLine;
|
}
|
break;
|
case appendingLDIFLine:
|
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 = stateGotCommentLine;
|
} 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 = stateGotLDIFLine;
|
}
|
break;
|
}
|
}
|
}
|
|
final boolean readLDIFRecordAttributeValue(final LDIFRecord record, final String ldifLine,
|
final Entry entry, final List<LocalizableMessage> schemaErrors) 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 UnknownSchemaElementException e) {
|
final LocalizableMessage message =
|
ERR_LDIF_UNKNOWN_ATTRIBUTE_TYPE.get(record.lineNumber, entry.getName()
|
.toString(), attrDescr);
|
switch (schemaValidationPolicy.checkAttributesAndObjectClasses()) {
|
case REJECT:
|
schemaErrors.add(message);
|
return false;
|
case WARN:
|
schemaErrors.add(message);
|
return true;
|
default: // Ignore
|
/*
|
* This should not happen: we should be using a non-strict
|
* schema for this policy.
|
*/
|
throw new IllegalStateException("Schema is not consistent with policy", e);
|
}
|
} catch (final LocalizedIllegalArgumentException e) {
|
final LocalizableMessage message =
|
ERR_LDIF_MALFORMED_ATTRIBUTE_NAME.get(record.lineNumber, entry.getName()
|
.toString(), attrDescr);
|
throw DecodeException.error(message);
|
}
|
|
// 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 true;
|
}
|
|
final Syntax syntax = attributeDescription.getAttributeType().getSyntax();
|
|
// Ensure that the binary option is present if required.
|
if (!syntax.isBEREncodingRequired()) {
|
if (schemaValidationPolicy.checkAttributeValues().needsChecking()
|
&& attributeDescription.hasOption("binary")) {
|
final LocalizableMessage message =
|
ERR_LDIF_UNEXPECTED_BINARY_OPTION.get(record.lineNumber, entry.getName()
|
.toString(), attrDescr);
|
schemaErrors.add(message);
|
return !schemaValidationPolicy.checkAttributeValues().isReject();
|
}
|
} else {
|
attributeDescription = attributeDescription.withOption("binary");
|
}
|
|
final boolean checkAttributeValues =
|
schemaValidationPolicy.checkAttributeValues().needsChecking();
|
if (checkAttributeValues) {
|
final LocalizableMessageBuilder builder = new LocalizableMessageBuilder();
|
if (!syntax.valueIsAcceptable(value, builder)) {
|
schemaErrors.add(builder.toMessage());
|
if (schemaValidationPolicy.checkAttributeValues().isReject()) {
|
return false;
|
}
|
}
|
}
|
|
Attribute attribute = entry.getAttribute(attributeDescription);
|
if (attribute == null) {
|
attribute = new LinkedAttribute(attributeDescription, value);
|
entry.addAttribute(attribute);
|
} else if (checkAttributeValues) {
|
if (!attribute.add(value)) {
|
final LocalizableMessage message =
|
WARN_LDIF_DUPLICATE_ATTRIBUTE_VALUE.get(record.lineNumber, entry.getName()
|
.toString(), attrDescr, value.toString());
|
schemaErrors.add(message);
|
if (schemaValidationPolicy.checkAttributeValues().isReject()) {
|
return false;
|
}
|
} else if (attributeDescription.getAttributeType().isSingleValue()) {
|
final LocalizableMessage message =
|
ERR_LDIF_MULTI_VALUED_SINGLE_VALUED_ATTRIBUTE.get(record.lineNumber, entry
|
.getName().toString(), attrDescr);
|
schemaErrors.add(message);
|
if (schemaValidationPolicy.checkAttributeValues().isReject()) {
|
return false;
|
}
|
}
|
} else {
|
attribute.add(value);
|
}
|
|
return true;
|
}
|
|
final DN readLDIFRecordDN(final 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 = ByteString.valueOfBase64(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(final LDIFRecord record, final KeyValuePair pair,
|
final boolean allowBase64) {
|
final String ldifLine = record.iterator.next();
|
final int colonPos = ldifLine.indexOf(":");
|
if (colonPos <= 0) {
|
pair.key = null;
|
return ldifLine;
|
}
|
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) {
|
pair.key = null;
|
return ldifLine;
|
}
|
|
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 = ByteString.valueOfBase64(ldifLine.substring(pos)).toString();
|
} catch (final LocalizedIllegalArgumentException e) {
|
pair.key = null;
|
return ldifLine;
|
}
|
} 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;
|
}
|
|
/*
|
* 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(final 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;
|
}
|
}
|
