[metrics-lib/master] Implement parsing relay server descriptors.

2 Jan 2012

commit aecdb0f72eefa2479002e47cce3d1dce9e55868d
Author: Karsten Loesing <karsten.loesing@gmx.net>
Date:   Mon Jan 2 14:37:30 2012 +0100

    Implement parsing relay server descriptors.
---
 .../torproject/descriptor/BandwidthHistory.java    |   26 +
 .../descriptor/RelayServerDescriptor.java          |  103 ++
 .../descriptor/impl/BandwidthHistoryImpl.java      |   73 ++
 .../torproject/descriptor/impl/DescriptorImpl.java |  164 +++
 .../descriptor/impl/NetworkStatusImpl.java         |  129 +---
 .../torproject/descriptor/impl/ParseHelper.java    |   45 +
 .../impl/RelayNetworkStatusConsensusImpl.java      |    2 +-
 .../impl/RelayNetworkStatusVoteImpl.java           |    2 +-
 .../descriptor/impl/RelayServerDescriptorImpl.java |  529 ++++++++++
 .../impl/RelayNetworkStatusConsensusImplTest.java  |    2 +
 .../impl/RelayNetworkStatusVoteImplTest.java       |    2 +
 .../impl/RelayServerDescriptorImplTest.java        | 1080 ++++++++++++++++++++
 12 files changed, 2028 insertions(+), 129 deletions(-)

diff --git a/src/org/torproject/descriptor/BandwidthHistory.java b/src/org/torproject/descriptor/BandwidthHistory.java
new file mode 100644
index 0000000..1794ab4
--- /dev/null
+++ b/src/org/torproject/descriptor/BandwidthHistory.java
@@ -0,0 +1,26 @@
+/* Copyright 2012 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor;
+
+import java.util.SortedMap;
+
+/* Contains the bandwidth history of a relay or bridge. */
+public interface BandwidthHistory {
+
+  /* Return the original bandwidth history line as contained in the
+   * descriptor, possibly prefixed with "opt ". */
+  public String getLine();
+
+  /* Return the end of the most recent interval in millis. */
+  public long getHistoryEndMillis();
+
+  /* Return the interval length in seconds, which is typically 900 seconds
+   * or 15 minutes. */
+  public long getIntervalLength();
+
+  /* Return the (possibly empty) bandwidth history with map keys being
+   * interval ends in millis and map values being number of bytes used in
+   * the interval, ordered from oldest to newest interval. */
+  public SortedMap<Long, Long> getBandwidthValues();
+}
+
diff --git a/src/org/torproject/descriptor/RelayServerDescriptor.java b/src/org/torproject/descriptor/RelayServerDescriptor.java
index 1542cba..fcd4382 100644
--- a/src/org/torproject/descriptor/RelayServerDescriptor.java
+++ b/src/org/torproject/descriptor/RelayServerDescriptor.java
@@ -2,6 +2,109 @@
  * See LICENSE for licensing information */
 package org.torproject.descriptor;
 
+import java.util.List;
+
+/* Contains a relay server descriptor. */
 public interface RelayServerDescriptor extends Descriptor {
+
+  /* Return the relay's nickname. */
+  public String getNickname();
+
+  /* Return the relay's IPv4 address in dotted-quad format. */
+  public String getAddress();
+
+  /* Return the relay's OR port. */
+  public int getOrPort();
+
+  /* Return the relay's SOCKS port which should always be 0. */
+  public int getSocksPort();
+
+  /* Return the relay's directory port. */
+  public int getDirPort();
+
+  /* Return the average bandwidth in bytes per second that the relay is
+   * willing to sustain over long periods. */
+  public int getBandwidthRate();
+
+  /* Return the burst bandwidth in bytes per second that the relay is
+   * willing to sustain in very short intervals. */
+  public int getBandwidthBurst();
+
+  /* Return the observed bandwidth in bytes per second as an estimate of
+   * the capacity that the relay can handle. */
+  public int getBandwidthObserved();
+
+  /* Return the platform string containing the Tor software version and
+   * the operating system. */
+  public String getPlatform();
+
+  /* Return the time when this descriptor and the corresponding extra-info
+   * document was generated. */
+  public long getPublishedMillis();
+
+  /* Return the relay fingerprint, or null if this descriptor does not
+   * contain a fingerprint line. */
+  public String getFingerprint();
+
+  /* Return whether the relay was hibernating when this descriptor was
+   * published. */
+  public boolean isHibernating();
+
+  /* Return the number of seconds that this relay has been running, or -1
+   * if the descriptor does not contain an uptime line. */
+  public int getUptime();
+
+  /* Return the relay's exit policy consisting of one or more accept or
+   * reject lines. */
+  public List<String> getExitPolicyLines();
+
+  /* Return the contact information for this relay, or null if no contact
+   * information is included in the descriptor. */
+  public String getContact();
+
+  /* Return the nicknames or ($-prefixed) fingerprints contained in the
+   * family line of this relay, or null if the descriptor does not contain
+   * a family line. */
+  public List<String> getFamilyEntries();
+
+  /* Return the relay's read history.  (Current Tor versions include their
+   * bandwidth histories in their extra-info descriptors, not in their
+   * server descriptors.) */
+  public BandwidthHistory getReadHistory();
+
+  /* Return the relay's write history.  (Current Tor versions include
+   * their bandwidth histories in their extra-info descriptors, not in
+   * their server descriptors.) */
+  public BandwidthHistory getWriteHistory();
+
+  /* Return true if the relay uses the enhanced DNS logic, or false if
+   * doesn't use it or doesn't include an eventdns line in its
+   * descriptor. */
+  public boolean getUsesEnhancedDnsLogic();
+
+  /* Return whether this relay is a directory cache that provides
+   * extra-info descriptors. */
+  public boolean getCachesExtraInfo();
+
+  /* Return the digest of the relay's extra-info descriptor, or null if
+   * the relay did not upload a corresponding extra-info descriptor. */
+  public String getExtraInfoDigest();
+
+  /* Return the hidden service descriptor version(s) that this relay
+   * stores and serves, or null if it doesn't store and serve any hidden
+   * service descriptors. */
+  public List<Integer> getHiddenServiceDirVersions();
+
+  /* Return the list of link protocol versions that this relay
+   * supports. */
+  public List<Integer> getLinkProtocolVersions();
+
+  /* Return the list of circuit protocol versions that this relay
+   * supports. */
+  public List<Integer> getCircuitProtocolVersions();
+
+  /* Return whether this relay allows single-hop circuits to make exit
+   * connections. */
+  public boolean getAllowSingleHopExits();
 }
 
diff --git a/src/org/torproject/descriptor/impl/BandwidthHistoryImpl.java b/src/org/torproject/descriptor/impl/BandwidthHistoryImpl.java
new file mode 100644
index 0000000..f16cc81
--- /dev/null
+++ b/src/org/torproject/descriptor/impl/BandwidthHistoryImpl.java
@@ -0,0 +1,73 @@
+/* Copyright 2012 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor.impl;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import org.torproject.descriptor.BandwidthHistory;
+
+public class BandwidthHistoryImpl implements BandwidthHistory {
+
+  protected BandwidthHistoryImpl(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    boolean isValid = false;
+    if (partsNoOpt.length >= 5) {
+      try {
+        this.line = line;
+        this.historyEndMillis = ParseHelper.parseTimestampAtIndex(line,
+            partsNoOpt, 1, 2);
+        if (partsNoOpt[3].startsWith("(") &&
+            partsNoOpt[4].equals("s)")) {
+          this.intervalLength = Long.parseLong(partsNoOpt[3].
+              substring(1));
+          if (partsNoOpt.length > 6) {
+            /* Invalid line, handle below. */
+          } else if (partsNoOpt.length == 5) {
+            /* No bandwidth values to parse. */
+            isValid = true;
+          } else {
+            long endMillis = this.historyEndMillis;
+            String[] values = partsNoOpt[5].split(",", -1);
+            for (int i = values.length - 1; i >= 0; i--) {
+              long bandwidthValue = Long.parseLong(values[i]);
+              this.bandwidthValues.put(endMillis, bandwidthValue);
+              endMillis -= this.intervalLength * 1000L;
+            }
+            isValid = true;
+          }
+        }
+      } catch (NumberFormatException e) {
+        /* Handle below. */
+      }
+    }
+    if (!isValid) {
+      throw new DescriptorParseException("Invalid bandwidth-history line "
+          + "'" + line + "'.");
+    }
+  }
+
+  private String line;
+  public String getLine() {
+    return this.line;
+  }
+
+  private long historyEndMillis;
+  public long getHistoryEndMillis() {
+    return this.historyEndMillis;
+  }
+
+  private long intervalLength;
+  public long getIntervalLength() {
+    return this.intervalLength;
+  }
+
+  private SortedMap<Long, Long> bandwidthValues =
+      new TreeMap<Long, Long>();
+  public SortedMap<Long, Long> getBandwidthValues() {
+    return new TreeMap<Long, Long>(this.bandwidthValues);
+  }
+}
+
diff --git a/src/org/torproject/descriptor/impl/DescriptorImpl.java b/src/org/torproject/descriptor/impl/DescriptorImpl.java
new file mode 100644
index 0000000..d337630
--- /dev/null
+++ b/src/org/torproject/descriptor/impl/DescriptorImpl.java
@@ -0,0 +1,164 @@
+/* Copyright 2012 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor.impl;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.torproject.descriptor.Descriptor;
+
+public abstract class DescriptorImpl implements Descriptor {
+
+  protected static List<byte[]> splitRawDescriptorBytes(
+      byte[] rawDescriptorBytes, String startToken) {
+    List<byte[]> rawDescriptors = new ArrayList<byte[]>();
+    String splitToken = "\n" + startToken;
+    String ascii = new String(rawDescriptorBytes);
+    int length = rawDescriptorBytes.length,
+        start = ascii.indexOf(startToken);
+    while (start < length) {
+      int end = ascii.indexOf(splitToken, start);
+      if (end < 0) {
+        end = length;
+      } else {
+        end += 1;
+      }
+      byte[] rawDescriptor = new byte[end - start];
+      System.arraycopy(rawDescriptorBytes, start, rawDescriptor, 0,
+          end - start);
+      start = end;
+      rawDescriptors.add(rawDescriptor);
+    }
+    return rawDescriptors;
+  }
+
+  protected byte[] rawDescriptorBytes;
+  public byte[] getRawDescriptorBytes() {
+    return this.rawDescriptorBytes;
+  }
+
+  protected DescriptorImpl(byte[] rawDescriptorBytes)
+      throws DescriptorParseException {
+    this.rawDescriptorBytes = rawDescriptorBytes;
+    this.countKeywords(rawDescriptorBytes);
+  }
+
+  /* Count parsed keywords for consistency checks by subclasses. */
+  private String firstKeyword, lastKeyword;
+  private Map<String, Integer> parsedKeywords =
+      new HashMap<String, Integer>();
+  private void countKeywords(byte[] rawDescriptorBytes)
+      throws DescriptorParseException {
+    if (rawDescriptorBytes.length == 0) {
+      throw new DescriptorParseException("Descriptor is empty.");
+    }
+    String descriptorString = new String(rawDescriptorBytes);
+    if (descriptorString.startsWith("\n") ||
+        descriptorString.contains("\n\n")) {
+      throw new DescriptorParseException("Empty lines are not allowed.");
+    }
+    try {
+      BufferedReader br = new BufferedReader(new StringReader(
+          descriptorString));
+      String line;
+      boolean skipCrypto = false;
+      while ((line = br.readLine()) != null) {
+        if (line.startsWith("-----BEGIN")) {
+          skipCrypto = true;
+        } else if (line.startsWith("-----END")) {
+          skipCrypto = false;
+        } else if (!skipCrypto) {
+          String lineNoOpt = line.startsWith("opt ") ?
+              line.substring("opt ".length()) : line;
+          String keyword = lineNoOpt.split(" ", -1)[0];
+          if (keyword.equals("")) {
+            throw new DescriptorParseException("Illegal keyword in line '"
+                + line + "'.");
+          }
+          if (this.firstKeyword == null) {
+            this.firstKeyword = keyword;
+          }
+          lastKeyword = keyword;
+          if (parsedKeywords.containsKey(keyword)) {
+            parsedKeywords.put(keyword, parsedKeywords.get(keyword) + 1);
+          } else {
+            parsedKeywords.put(keyword, 1);
+          }
+        }
+      }
+    } catch (IOException e) {
+      throw new RuntimeException("Internal error: Ran into an "
+          + "IOException while parsing a String in memory.  Something's "
+          + "really wrong.", e);
+    }
+  }
+
+  protected void checkFirstKeyword(String keyword)
+      throws DescriptorParseException {
+    if (this.firstKeyword == null ||
+        !this.firstKeyword.equals(keyword)) {
+      throw new DescriptorParseException("Keyword '" + keyword + "' must "
+          + "be contained in the first line.");
+    }
+  }
+
+  protected void checkLastKeyword(String keyword)
+      throws DescriptorParseException {
+    if (this.lastKeyword == null ||
+        !this.lastKeyword.equals(keyword)) {
+      throw new DescriptorParseException("Keyword '" + keyword + "' must "
+          + "be contained in the last line.");
+    }
+  }
+
+  protected void checkExactlyOnceKeywords(Set<String> keywords)
+      throws DescriptorParseException {
+    for (String keyword : keywords) {
+      int contained = 0;
+      if (this.parsedKeywords.containsKey(keyword)) {
+        contained = this.parsedKeywords.get(keyword);
+      }
+      if (contained != 1) {
+        throw new DescriptorParseException("Keyword '" + keyword + "' is "
+            + "contained " + contained + " times, but must be contained "
+            + "exactly once.");
+      }
+    }
+  }
+
+  protected void checkAtLeastOnceKeywords(Set<String> keywords)
+      throws DescriptorParseException {
+    for (String keyword : keywords) {
+      if (!this.parsedKeywords.containsKey(keyword)) {
+        throw new DescriptorParseException("Keyword '" + keyword + "' is "
+            + "contained 0 times, but must be contained at least once.");
+      }
+    }
+  }
+
+  protected void checkAtMostOnceKeywords(Set<String> keywords)
+      throws DescriptorParseException {
+    for (String keyword : keywords) {
+      if (this.parsedKeywords.containsKey(keyword) &&
+          this.parsedKeywords.get(keyword) > 1) {
+        throw new DescriptorParseException("Keyword '" + keyword + "' is "
+            + "contained " + this.parsedKeywords.get(keyword) + " times, "
+            + "but must be contained at most once.");
+      }
+    }
+  }
+
+  protected int getKeywordCount(String keyword) {
+    if (!this.parsedKeywords.containsKey(keyword)) {
+      return 0;
+    } else {
+      return this.parsedKeywords.get(keyword);
+    }
+  }
+}
+
diff --git a/src/org/torproject/descriptor/impl/NetworkStatusImpl.java b/src/org/torproject/descriptor/impl/NetworkStatusImpl.java
index f478913..2878ad9 100644
--- a/src/org/torproject/descriptor/impl/NetworkStatusImpl.java
+++ b/src/org/torproject/descriptor/impl/NetworkStatusImpl.java
@@ -18,40 +18,11 @@ import org.torproject.descriptor.NetworkStatusEntry;
 /* Parse the common parts of v3 consensuses, v3 votes, v3 microdesc
  * consensuses, v2 statuses, and sanitized bridge network statuses and
  * delegate the specific parts to the subclasses. */
-public abstract class NetworkStatusImpl {
-
-  protected static List<byte[]> splitRawDescriptorBytes(
-      byte[] rawDescriptorBytes, String startToken) {
-    List<byte[]> rawDescriptors = new ArrayList<byte[]>();
-    String splitToken = "\n" + startToken;
-    String ascii = new String(rawDescriptorBytes);
-    int length = rawDescriptorBytes.length,
-        start = ascii.indexOf(startToken);
-    while (start < length) {
-      int end = ascii.indexOf(splitToken, start);
-      if (end < 0) {
-        end = length;
-      } else {
-        end += 1;
-      }
-      byte[] rawDescriptor = new byte[end - start];
-      System.arraycopy(rawDescriptorBytes, start, rawDescriptor, 0,
-          end - start);
-      start = end;
-      rawDescriptors.add(rawDescriptor);
-    }
-    return rawDescriptors;
-  }
-
-  private byte[] rawDescriptorBytes;
-  public byte[] getRawDescriptorBytes() {
-    return this.rawDescriptorBytes;
-  }
+public abstract class NetworkStatusImpl extends DescriptorImpl {
 
   protected NetworkStatusImpl(byte[] rawDescriptorBytes)
       throws DescriptorParseException {
-    this.rawDescriptorBytes = rawDescriptorBytes;
-    this.countKeywords(rawDescriptorBytes);
+    super(rawDescriptorBytes);
     this.splitAndParseParts(rawDescriptorBytes);
   }
 
@@ -126,7 +97,6 @@ public abstract class NetworkStatusImpl {
     byte[] headerBytes = new byte[end - start];
     System.arraycopy(this.rawDescriptorBytes, start,
         headerBytes, 0, end - start);
-    this.rememberFirstKeyword(headerBytes);
     this.parseHeader(headerBytes);
   }
 
@@ -240,101 +210,6 @@ public abstract class NetworkStatusImpl {
     }
   }
 
-  private String firstKeyword;
-  protected void rememberFirstKeyword(byte[] headerBytes) {
-    try {
-      BufferedReader br = new BufferedReader(new StringReader(
-          new String(headerBytes)));
-      this.firstKeyword = br.readLine().split(" ", -1)[0];
-    } catch (IOException e) {
-      throw new RuntimeException("Internal error: Ran into an "
-          + "IOException while parsing a String in memory.  Something's "
-          + "really wrong.", e);
-    }
-  }
-
-  protected void checkFirstKeyword(String keyword)
-      throws DescriptorParseException {
-    if (this.firstKeyword == null ||
-        !this.firstKeyword.equals(keyword)) {
-      throw new DescriptorParseException("Keyword '" + keyword + "' must "
-          + "be contained in the first line.");
-    }
-  }
-
-  /* Count parsed keywords in header and footer for consistency checks by
-   * subclasses. */
-  private Map<String, Integer> parsedKeywords =
-      new HashMap<String, Integer>();
-  protected void countKeywords(byte[] rawDescriptorBytes)
-      throws DescriptorParseException {
-    try {
-      BufferedReader br = new BufferedReader(new StringReader(
-          new String(rawDescriptorBytes)));
-      String line;
-      boolean skipCrypto = false;
-      while ((line = br.readLine()) != null) {
-        if (line.startsWith("-----BEGIN")) {
-          skipCrypto = true;
-        } else if (line.startsWith("-----END")) {
-          skipCrypto = false;
-        } else if (!skipCrypto) {
-          String keyword = line.split(" ", -1)[0];
-          if (keyword.equals("")) {
-            throw new DescriptorParseException("Illegal keyword in line '"
-                + line + "'.");
-          }
-          if (parsedKeywords.containsKey(keyword)) {
-            parsedKeywords.put(keyword, parsedKeywords.get(keyword) + 1);
-          } else {
-            parsedKeywords.put(keyword, 1);
-          }
-        }
-      }
-    } catch (IOException e) {
-      throw new RuntimeException("Internal error: Ran into an "
-          + "IOException while parsing a String in memory.  Something's "
-          + "really wrong.", e);
-    }
-  }
-
-  protected void checkExactlyOnceKeywords(Set<String> keywords)
-      throws DescriptorParseException {
-    for (String keyword : keywords) {
-      int contained = 0;
-      if (this.parsedKeywords.containsKey(keyword)) {
-        contained = this.parsedKeywords.get(keyword);
-      }
-      if (contained != 1) {
-        throw new DescriptorParseException("Keyword '" + keyword + "' is "
-            + "contained " + contained + " times, but must be contained "
-            + "exactly once.");
-      }
-    }
-  }
-
-  protected void checkAtLeastOnceKeywords(Set<String> keywords)
-      throws DescriptorParseException {
-    for (String keyword : keywords) {
-      if (!this.parsedKeywords.containsKey(keyword)) {
-        throw new DescriptorParseException("Keyword '" + keyword + "' is "
-            + "contained 0 times, but must be contained at least once.");
-      }
-    }
-  }
-
-  protected void checkAtMostOnceKeywords(Set<String> keywords)
-      throws DescriptorParseException {
-    for (String keyword : keywords) {
-      if (this.parsedKeywords.containsKey(keyword) &&
-          this.parsedKeywords.get(keyword) > 1) {
-        throw new DescriptorParseException("Keyword '" + keyword + "' is "
-            + "contained " + this.parsedKeywords.get(keyword) + " times, "
-            + "but must be contained at most once.");
-      }
-    }
-  }
-
   private SortedMap<String, DirSourceEntry> dirSourceEntries =
       new TreeMap<String, DirSourceEntry>();
   public SortedMap<String, DirSourceEntry> getDirSourceEntries() {
diff --git a/src/org/torproject/descriptor/impl/ParseHelper.java b/src/org/torproject/descriptor/impl/ParseHelper.java
index 5f4a1bd..296955e 100644
--- a/src/org/torproject/descriptor/impl/ParseHelper.java
+++ b/src/org/torproject/descriptor/impl/ParseHelper.java
@@ -61,6 +61,51 @@ public class ParseHelper {
     return port;
   }
 
+  public static String parseExitPattern(String line, String exitPattern)
+      throws DescriptorParseException {
+    if (!exitPattern.contains(":")) {
+      throw new DescriptorParseException("'" + exitPattern + "' in line '"
+          + line + "' must contain address and port.");
+    }
+    String[] parts = exitPattern.split(":");
+    String addressPart = parts[0];
+    /* TODO Extend to IPv6. */
+    if (addressPart.equals("*")) {
+      /* Nothing to check. */
+    } else if (addressPart.contains("/")) {
+      String[] addressParts = addressPart.split("/");
+      String address = addressParts[0];
+      ParseHelper.parseIpv4Address(line, address);
+      String mask = addressParts[1];
+      int maskValue = -1;
+      try {
+        maskValue = Integer.parseInt(addressPart.substring(
+            addressPart.indexOf("/") + 1));
+      } catch (NumberFormatException e) {
+        /* Handle below. */
+      }
+      if (addressParts.length != 2 || maskValue < 0 || maskValue > 32) {
+        throw new DescriptorParseException("'" + addressPart + "' in "
+            + "line '" + line + "' is not a valid address part.");
+      }
+    } else {
+      ParseHelper.parseIpv4Address(line, addressPart);
+    }
+    String portPart = parts[1];
+    if (portPart.equals("*")) {
+      /* Nothing to check. */
+    } else if (portPart.contains("-")) {
+      String[] portParts = portPart.split("-");
+      String fromPort = portParts[0];
+      ParseHelper.parsePort(line, fromPort);
+      String toPort = portParts[1];
+      ParseHelper.parsePort(line, toPort);
+    } else {
+      ParseHelper.parsePort(line, portPart);
+    }
+    return exitPattern;
+  }
+
   private static SimpleDateFormat dateTimeFormat = new SimpleDateFormat(
       "yyyy-MM-dd HH:mm:ss");
   static {
diff --git a/src/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImpl.java b/src/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImpl.java
index c4dc88b..a5ab87c 100644
--- a/src/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImpl.java
+++ b/src/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImpl.java
@@ -29,7 +29,7 @@ public class RelayNetworkStatusConsensusImpl extends NetworkStatusImpl
     List<RelayNetworkStatusConsensus> parsedConsensuses =
         new ArrayList<RelayNetworkStatusConsensus>();
     List<byte[]> splitConsensusBytes =
-        NetworkStatusImpl.splitRawDescriptorBytes(consensusesBytes,
+        DescriptorImpl.splitRawDescriptorBytes(consensusesBytes,
         "network-status-version 3");
     try {
       for (byte[] consensusBytes : splitConsensusBytes) {
diff --git a/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java b/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java
index ab4da77..438b1df 100644
--- a/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java
+++ b/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java
@@ -25,7 +25,7 @@ public class RelayNetworkStatusVoteImpl extends NetworkStatusImpl
     List<RelayNetworkStatusVote> parsedVotes =
         new ArrayList<RelayNetworkStatusVote>();
     List<byte[]> splitVotesBytes =
-        NetworkStatusImpl.splitRawDescriptorBytes(votesBytes,
+        DescriptorImpl.splitRawDescriptorBytes(votesBytes,
         "network-status-version 3");
     try {
       for (byte[] voteBytes : splitVotesBytes) {
diff --git a/src/org/torproject/descriptor/impl/RelayServerDescriptorImpl.java b/src/org/torproject/descriptor/impl/RelayServerDescriptorImpl.java
new file mode 100644
index 0000000..a5374b6
--- /dev/null
+++ b/src/org/torproject/descriptor/impl/RelayServerDescriptorImpl.java
@@ -0,0 +1,529 @@
+/* Copyright 2012 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor.impl;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.torproject.descriptor.RelayServerDescriptor;
+import org.torproject.descriptor.BandwidthHistory;
+
+/* Contains a relay server descriptor. */
+public class RelayServerDescriptorImpl extends DescriptorImpl
+    implements RelayServerDescriptor {
+
+  protected static List<RelayServerDescriptor> parseDescriptors(
+      byte[] descriptorsBytes) {
+    List<RelayServerDescriptor> parsedDescriptors =
+        new ArrayList<RelayServerDescriptor>();
+    List<byte[]> splitDescriptorsBytes =
+        DescriptorImpl.splitRawDescriptorBytes(descriptorsBytes,
+        "router ");
+    try {
+      for (byte[] descriptorBytes : splitDescriptorsBytes) {
+        RelayServerDescriptor parsedDescriptor =
+            new RelayServerDescriptorImpl(descriptorBytes);
+        parsedDescriptors.add(parsedDescriptor);
+      }
+    } catch (DescriptorParseException e) {
+      /* TODO Handle this error somehow. */
+      System.err.println("Failed to parse descriptor.  Skipping.");
+      e.printStackTrace();
+    }
+    return parsedDescriptors;
+  }
+
+  protected RelayServerDescriptorImpl(byte[] descriptorBytes)
+      throws DescriptorParseException {
+    super(descriptorBytes);
+    this.parseDescriptorBytes();
+    Set<String> exactlyOnceKeywords = new HashSet<String>(Arrays.asList((
+        "router,bandwidth,published,onion-key,signing-key,"
+        + "router-signature").split(",")));
+    this.checkExactlyOnceKeywords(exactlyOnceKeywords);
+    Set<String> atMostOnceKeywords = new HashSet<String>(Arrays.asList((
+        "platform,fingerprint,hibernating,uptime,contact,family,"
+        + "read-history,write-history,eventdns,caches-extra-info,"
+        + "extra-info-digest,hidden-service-dir,protocols,"
+        + "allow-single-hop-exits").split(",")));
+    this.checkAtMostOnceKeywords(atMostOnceKeywords);
+    this.checkFirstKeyword("router");
+    this.checkLastKeyword("router-signature");
+    if (this.getKeywordCount("accept") == 0 &&
+        this.getKeywordCount("reject") == 0) {
+      throw new DescriptorParseException("Either keyword 'accept' or "
+          + "'reject' must be contained at least once.");
+    }
+    return;
+  }
+
+  private void parseDescriptorBytes() throws DescriptorParseException {
+    try {
+      BufferedReader br = new BufferedReader(new StringReader(
+          new String(this.rawDescriptorBytes)));
+      String line;
+      boolean skipCrypto = false;
+      while ((line = br.readLine()) != null) {
+        String lineNoOpt = line.startsWith("opt ") ?
+            line.substring("opt ".length()) : line;
+        String[] partsNoOpt = lineNoOpt.split(" ");
+        String keyword = partsNoOpt[0];
+        if (keyword.equals("router")) {
+          this.parseRouterLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("bandwidth")) {
+          this.parseBandwidthLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("platform")) {
+          this.parsePlatformLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("published")) {
+          this.parsePublishedLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("fingerprint")) {
+          this.parseFingerprintLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("hibernating")) {
+          this.parseHibernatingLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("uptime")) {
+          this.parseUptimeLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("onion-key")) {
+          this.parseOnionKeyLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("signing-key")) {
+          this.parseSigningKeyLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("accept")) {
+          this.parseAcceptLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("reject")) {
+          this.parseRejectLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("router-signature")) {
+          this.parseRouterSignatureLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("contact")) {
+          this.parseContactLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("family")) {
+          this.parseFamilyLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("read-history")) {
+          this.parseReadHistoryLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("write-history")) {
+          this.parseWriteHistoryLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("eventdns")) {
+          this.parseEventdnsLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("caches-extra-info")) {
+          this.parseCachesExtraInfoLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("extra-info-digest")) {
+          this.parseExtraInfoDigestLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("hidden-service-dir")) {
+          this.parseHiddenServiceDirLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("protocols")) {
+          this.parseProtocolsLine(line, lineNoOpt, partsNoOpt);
+        } else if (keyword.equals("allow-single-hop-exits")) {
+          this.parseAllowSingleHopExitsLine(line, lineNoOpt, partsNoOpt);
+        } else if (line.startsWith("-----BEGIN")) {
+          skipCrypto = true;
+        } else if (line.startsWith("-----END")) {
+          skipCrypto = false;
+        } else if (!skipCrypto) {
+          /* TODO Is throwing an exception the right thing to do here?
+           * This is probably fine for development, but once the library
+           * is in production use, this seems annoying.  In theory,
+           * dir-spec.txt says that unknown lines should be ignored.  This
+           * also applies to the other descriptors. */
+          throw new DescriptorParseException("Unrecognized line '" + line
+              + "'.");
+        }
+      }
+    } catch (IOException e) {
+      throw new RuntimeException("Internal error: Ran into an "
+          + "IOException while parsing a String in memory.  Something's "
+          + "really wrong.", e);
+    }
+  }
+
+  private void parseRouterLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (partsNoOpt.length != 6) {
+      throw new DescriptorParseException("Illegal line '" + line
+          + "' in server descriptor.");
+    }
+    this.nickname = ParseHelper.parseNickname(line, partsNoOpt[1]);
+    this.address = ParseHelper.parseIpv4Address(line, partsNoOpt[2]);
+    this.orPort = ParseHelper.parsePort(line, partsNoOpt[3]);
+    this.socksPort = ParseHelper.parsePort(line, partsNoOpt[4]);
+    this.dirPort = ParseHelper.parsePort(line, partsNoOpt[5]);
+  }
+
+  private void parseBandwidthLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (partsNoOpt.length != 4) {
+      throw new DescriptorParseException("Wrong number of values in line "
+          + "'" + line + "'.");
+    }
+    boolean isValid = false;
+    try {
+      this.bandwidthRate = Integer.parseInt(partsNoOpt[1]);
+      this.bandwidthBurst = Integer.parseInt(partsNoOpt[2]);
+      this.bandwidthObserved = Integer.parseInt(partsNoOpt[3]);
+      if (this.bandwidthRate >= 0 && this.bandwidthBurst >= 0 &&
+          this.bandwidthObserved >= 0) {
+        isValid = true;
+      }
+    } catch (NumberFormatException e) {
+      /* Handle below. */
+    }
+    if (!isValid) {
+      throw new DescriptorParseException("Illegal values in line '" + line
+          + "'.");
+    }
+  }
+
+  private void parsePlatformLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (lineNoOpt.length() > "platform ".length()) {
+      this.platform = lineNoOpt.substring("platform ".length());
+    } else {
+      this.platform = "";
+    }
+  }
+
+  private void parsePublishedLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    this.publishedMillis = ParseHelper.parseTimestampAtIndex(line,
+        partsNoOpt, 1, 2);
+  }
+
+  private void parseFingerprintLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (lineNoOpt.length() != "fingerprint".length() + 5 * 10) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    this.fingerprint = ParseHelper.parseTwentyByteHexString(line,
+        lineNoOpt.substring("fingerprint ".length()).replaceAll(" ", ""));
+  }
+
+  private void parseHibernatingLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (partsNoOpt.length != 2) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    if (partsNoOpt[1].equals("true")) {
+      this.hibernating = true;
+    } else if (partsNoOpt[1].equals("false")) {
+      this.hibernating = false;
+    } else {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+  }
+
+  private void parseUptimeLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (partsNoOpt.length != 2) {
+      throw new DescriptorParseException("Wrong number of values in line "
+          + "'" + line + "'.");
+    }
+    boolean isValid = false;
+    try {
+      this.uptime = Integer.parseInt(partsNoOpt[1]);
+      if (this.uptime >= 0) {
+        isValid = true;
+      }
+    } catch (NumberFormatException e) {
+      /* Handle below. */
+    }
+    if (!isValid) {
+      throw new DescriptorParseException("Illegal value in line '" + line
+          + "'.");
+    }
+  }
+
+  private void parseOnionKeyLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    /* Not parsing crypto parts (yet). */
+  }
+
+  private void parseSigningKeyLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    /* Not parsing crypto parts (yet). */
+  }
+
+  private void parseAcceptLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    this.parseExitPolicyLine(line, lineNoOpt, partsNoOpt);
+  }
+
+  private void parseRejectLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    this.parseExitPolicyLine(line, lineNoOpt, partsNoOpt);
+  }
+
+  private void parseExitPolicyLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (partsNoOpt.length != 2) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    ParseHelper.parseExitPattern(line, partsNoOpt[1]);
+    this.exitPolicyLines.add(lineNoOpt);
+  }
+
+  private void parseRouterSignatureLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (!lineNoOpt.equals("router-signature")) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    /* Not parsing crypto parts (yet). */
+  }
+
+  private void parseContactLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (lineNoOpt.length() > "contact ".length()) {
+      this.contact = lineNoOpt.substring("contact ".length());
+    } else {
+      this.contact = "";
+    }
+  }
+
+  private void parseFamilyLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    this.familyEntries = new ArrayList<String>();
+    for (int i = 1; i < partsNoOpt.length; i++) {
+      if (partsNoOpt[i].startsWith("$")) {
+        this.familyEntries.add("$"
+            + ParseHelper.parseTwentyByteHexString(line,
+            partsNoOpt[i].substring(1)));
+      } else {
+        this.familyEntries.add(ParseHelper.parseNickname(line,
+            partsNoOpt[i]));
+      }
+    }
+  }
+
+  private void parseReadHistoryLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    this.readHistory = new BandwidthHistoryImpl(line, lineNoOpt,
+        partsNoOpt);
+  }
+
+  private void parseWriteHistoryLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    this.writeHistory = new BandwidthHistoryImpl(line, lineNoOpt,
+        partsNoOpt);
+  }
+
+  private void parseEventdnsLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (partsNoOpt.length != 2) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    if (partsNoOpt[1].equals("true")) {
+      this.usesEnhancedDnsLogic = true;
+    } else if (partsNoOpt[1].equals("false")) {
+      this.usesEnhancedDnsLogic = false;
+    } else {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+  }
+
+  private void parseCachesExtraInfoLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (!lineNoOpt.equals("caches-extra-info")) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    this.cachesExtraInfo = true;
+  }
+
+  private void parseExtraInfoDigestLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (partsNoOpt.length != 2) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    this.extraInfoDigest = ParseHelper.parseTwentyByteHexString(line,
+        partsNoOpt[1]);
+  }
+
+  private void parseHiddenServiceDirLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    this.hiddenServiceDirVersions = new ArrayList<Integer>();
+    if (partsNoOpt.length == 1) {
+      this.hiddenServiceDirVersions.add(2);
+    } else {
+      try {
+        for (int i = 1; i < partsNoOpt.length; i++) {
+          this.hiddenServiceDirVersions.add(Integer.parseInt(
+              partsNoOpt[i]));
+        }
+      } catch (NumberFormatException e) {
+        throw new DescriptorParseException("Illegal value in line '"
+            + line + "'.");
+      }
+    }
+  }
+
+  private void parseProtocolsLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    List<String> partsList = Arrays.asList(partsNoOpt);
+    boolean isValid = true;
+    this.linkProtocolVersions = new ArrayList<Integer>();
+    this.circuitProtocolVersions = new ArrayList<Integer>();
+    List<Integer> protocolVersions = null;
+    for (int i = 1; i < partsNoOpt.length; i++) {
+      String part = partsNoOpt[i];
+      if (part.equals("Link")) {
+        protocolVersions = this.linkProtocolVersions;
+      } else if (part.equals("Circuit")) {
+        protocolVersions = this.circuitProtocolVersions;
+      } else if (protocolVersions == null) {
+        isValid = false;
+        break;
+      } else {
+        try {
+          protocolVersions.add(Integer.parseInt(part));
+        } catch (NumberFormatException e) {
+          isValid = false;
+          break;
+        }
+      }
+    }
+    if (protocolVersions != this.circuitProtocolVersions) {
+      isValid = false;
+    }
+    if (!isValid) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+  }
+
+  private void parseAllowSingleHopExitsLine(String line, String lineNoOpt,
+      String[] partsNoOpt) throws DescriptorParseException {
+    if (!lineNoOpt.equals("allow-single-hop-exits")) {
+      throw new DescriptorParseException("Illegal line '" + line + "'.");
+    }
+    this.allowSingleHopExits = true;
+  }
+
+  private String nickname;
+  public String getNickname() {
+    return this.nickname;
+  }
+
+  private String address;
+  public String getAddress() {
+    return this.address;
+  }
+
+  private int orPort;
+  public int getOrPort() {
+    return this.orPort;
+  }
+
+  private int socksPort;
+  public int getSocksPort() {
+    return this.socksPort;
+  }
+
+  private int dirPort;
+  public int getDirPort() {
+    return this.dirPort;
+  }
+
+  private int bandwidthRate;
+  public int getBandwidthRate() {
+    return this.bandwidthRate;
+  }
+
+  private int bandwidthBurst;
+  public int getBandwidthBurst() {
+    return this.bandwidthBurst;
+  }
+
+  private int bandwidthObserved;
+  public int getBandwidthObserved() {
+    return this.bandwidthObserved;
+  }
+
+  private String platform;
+  public String getPlatform() {
+    return this.platform;
+  }
+
+  private long publishedMillis;
+  public long getPublishedMillis() {
+    return this.publishedMillis;
+  }
+
+  private String fingerprint;
+  public String getFingerprint() {
+    return this.fingerprint;
+  }
+
+  private boolean hibernating;
+  public boolean isHibernating() {
+    return this.hibernating;
+  }
+
+  private int uptime = -1;
+  public int getUptime() {
+    return this.uptime;
+  }
+
+  private List<String> exitPolicyLines = new ArrayList<String>();
+  public List<String> getExitPolicyLines() {
+    return new ArrayList<String>(this.exitPolicyLines);
+  }
+
+  private String contact;
+  public String getContact() {
+    return this.contact;
+  }
+
+  private List<String> familyEntries;
+  public List<String> getFamilyEntries() {
+    return this.familyEntries == null ? null :
+        new ArrayList<String>(this.familyEntries);
+  }
+
+  private BandwidthHistory readHistory;
+  public BandwidthHistory getReadHistory() {
+    return this.readHistory;
+  }
+
+  private BandwidthHistory writeHistory;
+  public BandwidthHistory getWriteHistory() {
+    return this.writeHistory;
+  }
+
+  private boolean usesEnhancedDnsLogic;
+  public boolean getUsesEnhancedDnsLogic() {
+    return this.usesEnhancedDnsLogic;
+  }
+
+  private boolean cachesExtraInfo;
+  public boolean getCachesExtraInfo() {
+    return this.cachesExtraInfo;
+  }
+
+  private String extraInfoDigest;
+  public String getExtraInfoDigest() {
+    return this.extraInfoDigest;
+  }
+
+  private List<Integer> hiddenServiceDirVersions;
+  public List<Integer> getHiddenServiceDirVersions() {
+    return this.hiddenServiceDirVersions == null ? null :
+        new ArrayList<Integer>(this.hiddenServiceDirVersions);
+  }
+
+  private List<Integer> linkProtocolVersions;
+  public List<Integer> getLinkProtocolVersions() {
+    return this.linkProtocolVersions == null ? null :
+        new ArrayList<Integer>(this.linkProtocolVersions);
+  }
+
+  private List<Integer> circuitProtocolVersions;
+  public List<Integer> getCircuitProtocolVersions() {
+    return this.circuitProtocolVersions == null ? null :
+        new ArrayList<Integer>(this.circuitProtocolVersions);
+  }
+
+  private boolean allowSingleHopExits;
+  public boolean getAllowSingleHopExits() {
+    return this.allowSingleHopExits;
+  }
+}
+
diff --git a/test/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImplTest.java b/test/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImplTest.java
index deadf80..d5bfd3a 100644
--- a/test/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImplTest.java
+++ b/test/org/torproject/descriptor/impl/RelayNetworkStatusConsensusImplTest.java
@@ -11,6 +11,8 @@ import org.junit.*;
 import org.junit.rules.*;
 import static org.junit.Assert.*;
 
+/* TODO Add test cases for all lines starting with "opt ". */
+
 /* Test parsing of network status consensuses.  The main focus is on
  * making sure that the parser is as robust as possible and doesn't break,
  * no matter what gets fed into it.  A secondary focus is to ensure that
diff --git a/test/org/torproject/descriptor/impl/RelayNetworkStatusVoteImplTest.java b/test/org/torproject/descriptor/impl/RelayNetworkStatusVoteImplTest.java
index cdf2a01..7618fff 100644
--- a/test/org/torproject/descriptor/impl/RelayNetworkStatusVoteImplTest.java
+++ b/test/org/torproject/descriptor/impl/RelayNetworkStatusVoteImplTest.java
@@ -11,6 +11,8 @@ import org.junit.*;
 import org.junit.rules.*;
 import static org.junit.Assert.*;
 
+/* TODO Add test cases for all lines starting with "opt ". */
+
 /* Test parsing of network status votes.  Some of the vote-parsing code is
  * already tested in the consensus-parsing tests.  The tests in this class
  * focus on the differences between votes and consensuses that are mostly
diff --git a/test/org/torproject/descriptor/impl/RelayServerDescriptorImplTest.java b/test/org/torproject/descriptor/impl/RelayServerDescriptorImplTest.java
new file mode 100644
index 0000000..acc2dbe
--- /dev/null
+++ b/test/org/torproject/descriptor/impl/RelayServerDescriptorImplTest.java
@@ -0,0 +1,1080 @@
+/* Copyright 2012 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor.impl;
+
+import org.torproject.descriptor.BandwidthHistory;
+import org.torproject.descriptor.RelayServerDescriptor;
+
+import java.util.*;
+
+import org.junit.*;
+import org.junit.rules.*;
+import static org.junit.Assert.*;
+
+/* Test parsing of relay server descriptors. */
+public class RelayServerDescriptorImplTest {
+
+  /* Helper class to build a descriptor based on default data and
+   * modifications requested by test methods. */
+  private static class DescriptorBuilder {
+    private String routerLine = "router saberrider2008 94.134.192.243 "
+        + "9001 0 0";
+    private static RelayServerDescriptor createWithRouterLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.routerLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String bandwidthLine = "bandwidth 51200 51200 53470";
+    private static RelayServerDescriptor createWithBandwidthLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.bandwidthLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String platformLine = "platform Tor 0.2.2.35 "
+        + "(git-b04388f9e7546a9f) on Linux i686";
+    private static RelayServerDescriptor createWithPlatformLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.platformLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String publishedLine = "published 2012-01-01 04:03:19";
+    private static RelayServerDescriptor createWithPublishedLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.publishedLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String fingerprintLine = "opt fingerprint D873 3048 FC8E "
+        + "C910 2466 AD8F 3098 622B F1BF 71FD";
+    private static RelayServerDescriptor createWithFingerprintLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.fingerprintLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String hibernatingLine = null;
+    private static RelayServerDescriptor createWithHibernatingLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.hibernatingLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String uptimeLine = "uptime 48";
+    private static RelayServerDescriptor createWithUptimeLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.uptimeLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String onionKeyLines = "onion-key\n"
+        + "-----BEGIN RSA PUBLIC KEY-----\n"
+        + "MIGJAoGBAKM+iiHhO6eHsvd6Xjws9z9EQB1V/Bpuy5ciGJ1U4V9SeiKooSo5Bp"
+        + "PL\no3XT+6PIgzl3R6uycjS3Ejk47vLEJdcVTm/VG6E0ppu3olIynCI4QryfCE"
+        + "uC3cTF\n9wE4WXY4nX7w0RTN18UVLxrt1A9PP0cobFNiPs9rzJCbKFfacOkpAg"
+        + "MBAAE=\n"
+        + "-----END RSA PUBLIC KEY-----";
+    private static RelayServerDescriptor createWithOnionKeyLines(
+        String lines) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.onionKeyLines = lines;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String signingKeyLines = "signing-key\n"
+        + "-----BEGIN RSA PUBLIC KEY-----\n"
+        + "MIGJAoGBALMm3r3QDh482Ewe6Ub9wvRIfmEkoNX6q5cEAtQRNHSDcNx41gjELb"
+        + "cl\nEniVMParBYACKfOxkS+mTTnIRDKVNEJTsDOwryNrc4X9JnPc/nn6ymYPiN"
+        + "DhUROG\n8URDIhQoixcUeyyrVB8sxliSstKimulGnB7xpjYOlO8JKaHLNL4TAg"
+        + "MBAAE=\n"
+        + "-----END RSA PUBLIC KEY-----";
+    private static RelayServerDescriptor createWithSigningKeyLines(
+        String lines) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.signingKeyLines = lines;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String exitPolicyLines = "reject *:*";
+    private static RelayServerDescriptor createWithExitPolicyLines(
+        String lines) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.exitPolicyLines = lines;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String contactLine = "contact Random Person <nobody AT "
+        + "example dot com>";
+    private static RelayServerDescriptor createWithContactLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.contactLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String familyLine = null;
+    private static RelayServerDescriptor createWithFamilyLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.familyLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String readHistoryLine = null;
+    private static RelayServerDescriptor createWithReadHistoryLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.readHistoryLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String writeHistoryLine = null;
+    private static RelayServerDescriptor createWithWriteHistoryLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.writeHistoryLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String eventdnsLine = null;
+    private static RelayServerDescriptor createWithEventdnsLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.eventdnsLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String cachesExtraInfoLine = null;
+    private static RelayServerDescriptor createWithCachesExtraInfoLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.cachesExtraInfoLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String extraInfoDigestLine = "opt extra-info-digest "
+        + "1469D1550738A25B1E7B47CDDBCD7B2899F51B74";
+    private static RelayServerDescriptor createWithExtraInfoDigestLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.extraInfoDigestLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String hiddenServiceDirLine = "opt hidden-service-dir";
+    private static RelayServerDescriptor createWithHiddenServiceDirLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.hiddenServiceDirLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String protocolsLine = "opt protocols Link 1 2 Circuit 1";
+    private static RelayServerDescriptor createWithProtocolsLine(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.protocolsLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String allowSingleHopExitsLine = null;
+    private static RelayServerDescriptor
+        createWithAllowSingleHopExitsLine(String line)
+        throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.allowSingleHopExitsLine = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private String routerSignatureLines = "router-signature\n"
+        + "-----BEGIN SIGNATURE-----\n"
+        + "o4j+kH8UQfjBwepUnr99v0ebN8RpzHJ/lqYsTojXHy9kMr1RNI9IDeSzA7PSqT"
+        + "uV\n4PL8QsGtlfwthtIoZpB2srZeyN/mcpA9fa1JXUrt/UN9K/+32Cyaad7h0n"
+        + "HE6Xfb\njqpXDpnBpvk4zjmzjjKYnIsUWTnADmu0fo3xTRqXi7g=\n"
+        + "-----END SIGNATURE-----";
+    private static RelayServerDescriptor createWithRouterSignatureLines(
+        String line) throws DescriptorParseException {
+      DescriptorBuilder db = new DescriptorBuilder();
+      db.routerSignatureLines = line;
+      return new RelayServerDescriptorImpl(db.buildDescriptor());
+    }
+    private byte[] buildDescriptor() {
+      StringBuilder sb = new StringBuilder();
+      if (this.routerLine != null) {
+        sb.append(this.routerLine + "\n");
+      }
+      if (this.bandwidthLine != null) {
+        sb.append(this.bandwidthLine + "\n");
+      }
+      if (this.platformLine != null) {
+        sb.append(this.platformLine + "\n");
+      }
+      if (this.publishedLine != null) {
+        sb.append(this.publishedLine + "\n");
+      }
+      if (this.fingerprintLine != null) {
+        sb.append(this.fingerprintLine + "\n");
+      }
+      if (this.hibernatingLine != null) {
+        sb.append(this.hibernatingLine + "\n");
+      }
+      if (this.uptimeLine != null) {
+        sb.append(this.uptimeLine + "\n");
+      }
+      if (this.onionKeyLines != null) {
+        sb.append(this.onionKeyLines + "\n");
+      }
+      if (this.signingKeyLines != null) {
+        sb.append(this.signingKeyLines + "\n");
+      }
+      if (this.exitPolicyLines != null) {
+        sb.append(this.exitPolicyLines + "\n");
+      }
+      if (this.contactLine != null) {
+        sb.append(this.contactLine + "\n");
+      }
+      if (this.familyLine != null) {
+        sb.append(this.familyLine + "\n");
+      }
+      if (this.readHistoryLine != null) {
+        sb.append(this.readHistoryLine + "\n");
+      }
+      if (this.writeHistoryLine != null) {
+        sb.append(this.writeHistoryLine + "\n");
+      }
+      if (this.eventdnsLine != null) {
+        sb.append(this.eventdnsLine + "\n");
+      }
+      if (this.cachesExtraInfoLine != null) {
+        sb.append(this.cachesExtraInfoLine + "\n");
+      }
+      if (this.extraInfoDigestLine != null) {
+        sb.append(this.extraInfoDigestLine + "\n");
+      }
+      if (this.hiddenServiceDirLine != null) {
+        sb.append(this.hiddenServiceDirLine + "\n");
+      }
+      if (this.protocolsLine != null) {
+        sb.append(this.protocolsLine + "\n");
+      }
+      if (this.allowSingleHopExitsLine != null) {
+        sb.append(this.allowSingleHopExitsLine + "\n");
+      }
+      if (this.routerSignatureLines != null) {
+        sb.append(this.routerSignatureLines + "\n");
+      }
+      return sb.toString().getBytes();
+    }
+  }
+
+  @Test()
+  public void testSampleDescriptor() throws DescriptorParseException {
+    DescriptorBuilder db = new DescriptorBuilder();
+    RelayServerDescriptor descriptor =
+        new RelayServerDescriptorImpl(db.buildDescriptor());
+    assertEquals("saberrider2008", descriptor.getNickname());
+    assertEquals("94.134.192.243", descriptor.getAddress());
+    assertEquals(9001, (int) descriptor.getOrPort());
+    assertEquals(0, (int) descriptor.getSocksPort());
+    assertEquals(0, (int) descriptor.getDirPort());
+    assertEquals("Tor 0.2.2.35 (git-b04388f9e7546a9f) on Linux i686",
+        descriptor.getPlatform());
+    assertEquals(Arrays.asList(new Integer[] {1, 2}),
+        descriptor.getLinkProtocolVersions());
+    assertEquals(Arrays.asList(new Integer[] {1}),
+        descriptor.getCircuitProtocolVersions());
+    assertEquals(1325390599000L, descriptor.getPublishedMillis());
+    assertEquals("D8733048FC8EC9102466AD8F3098622BF1BF71FD",
+        descriptor.getFingerprint());
+    assertEquals(48, (int) descriptor.getUptime());
+    assertEquals(51200, (int) descriptor.getBandwidthRate());
+    assertEquals(51200, (int) descriptor.getBandwidthBurst());
+    assertEquals(53470, (int) descriptor.getBandwidthObserved());
+    assertEquals("1469D1550738A25B1E7B47CDDBCD7B2899F51B74",
+        descriptor.getExtraInfoDigest());
+    assertEquals(Arrays.asList(new Integer[] {2}),
+        descriptor.getHiddenServiceDirVersions());
+    assertEquals("Random Person <nobody AT example dot com>",
+        descriptor.getContact());
+    assertEquals(Arrays.asList(new String[] {"reject *:*"}),
+        descriptor.getExitPolicyLines());
+    assertFalse(descriptor.isHibernating());
+    assertNull(descriptor.getFamilyEntries());
+    assertNull(descriptor.getReadHistory());
+    assertNull(descriptor.getWriteHistory());
+    assertFalse(descriptor.getUsesEnhancedDnsLogic());
+    assertFalse(descriptor.getCachesExtraInfo());
+    assertFalse(descriptor.getAllowSingleHopExits());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testRouterLineMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine(null);
+  }
+
+  @Test()
+  public void testRouterOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithRouterLine("opt router saberrider2008 "
+        + "94.134.192.243 9001 0 0");
+    assertEquals("saberrider2008", descriptor.getNickname());
+    assertEquals("94.134.192.243", descriptor.getAddress());
+    assertEquals(9001, (int) descriptor.getOrPort());
+    assertEquals(0, (int) descriptor.getSocksPort());
+    assertEquals(0, (int) descriptor.getDirPort());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testRouterLinePrecedingHibernatingLine()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("hibernating true\nrouter "
+        + "saberrider2008 94.134.192.243 9001 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNicknameMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router  94.134.192.243 9001 "
+        + "0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNicknameInvalidChar() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router $aberrider2008 "
+        + "94.134.192.243 9001 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testNicknameTooLong() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router "
+        + "saberrider2008ReallyLongNickname 94.134.192.243 9001 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testAddress24() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008 "
+        + "94.134.192/24 9001 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testAddress294() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008 "
+        + "294.134.192.243 9001 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testAddressMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008  9001 "
+        + "0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testOrPort99001() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008 "
+        + "94.134.192.243 99001 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testOrPortMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008 "
+        + "94.134.192.243  0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testOrPortOne() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008 "
+        + "94.134.192.243 one 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testOrPortNewline() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008 "
+        + "94.134.192.243 0\n 0 0");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testDirPortMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterLine("router saberrider2008 "
+        + "94.134.192.243 9001 0 ");
+  }
+
+  @Test()
+  public void testPlatformMissing() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithPlatformLine(null);
+    assertNull(descriptor.getPlatform());
+  }
+
+  @Test()
+  public void testPlatformOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithPlatformLine("opt platform Tor 0.2.2.35 "
+        + "(git-b04388f9e7546a9f) on Linux i686");
+    assertEquals("Tor 0.2.2.35 (git-b04388f9e7546a9f) on Linux i686",
+        descriptor.getPlatform());
+  }
+
+  @Test()
+  public void testPlatformNoSpace() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithPlatformLine("platform");
+    assertEquals("", descriptor.getPlatform());
+  }
+
+  @Test()
+  public void testPlatformSpace() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithPlatformLine("platform ");
+    assertEquals("", descriptor.getPlatform());
+  }
+
+  @Test()
+  public void testProtocolsNoOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithProtocolsLine("protocols Link 1 2 Circuit 1");
+    assertEquals(Arrays.asList(new Integer[] {1, 2}),
+        descriptor.getLinkProtocolVersions());
+    assertEquals(Arrays.asList(new Integer[] {1}),
+        descriptor.getCircuitProtocolVersions());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testProtocolsAB() throws DescriptorParseException {
+    DescriptorBuilder.createWithProtocolsLine("opt protocols Link A B "
+        + "Circuit 1");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testProtocolsNoCircuitVersions()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithProtocolsLine("opt protocols Link 1 2");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testPublishedMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithPublishedLine(null);
+  }
+
+  @Test()
+  public void testPublishedOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithPublishedLine("opt published 2012-01-01 04:03:19");
+    assertEquals(1325390599000L, descriptor.getPublishedMillis());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testPublished3012() throws DescriptorParseException {
+    DescriptorBuilder.createWithPublishedLine("published 3012-01-01 "
+        + "04:03:19");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testPublished1912() throws DescriptorParseException {
+    DescriptorBuilder.createWithPublishedLine("published 1912-01-01 "
+        + "04:03:19");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testPublishedFeb31() throws DescriptorParseException {
+    DescriptorBuilder.createWithPublishedLine("published 2012-02-31 "
+        + "04:03:19");
+  }
+
+  @Test()
+  public void testFingerprintNoOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithFingerprintLine("fingerprint D873 3048 FC8E C910 2466 "
+            + "AD8F 3098 622B F1BF 71FD");
+    assertEquals("D8733048FC8EC9102466AD8F3098622BF1BF71FD",
+        descriptor.getFingerprint());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFingerprintG() throws DescriptorParseException {
+    DescriptorBuilder.createWithFingerprintLine("opt fingerprint G873 "
+        + "3048 FC8E C910 2466 AD8F 3098 622B F1BF 71FD");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFingerprintTooShort() throws DescriptorParseException {
+    DescriptorBuilder.createWithFingerprintLine("opt fingerprint D873 "
+        + "3048 FC8E C910 2466 AD8F 3098 622B F1BF");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFingerprintTooLong() throws DescriptorParseException {
+    DescriptorBuilder.createWithFingerprintLine("opt fingerprint D873 "
+        + "3048 FC8E C910 2466 AD8F 3098 622B F1BF 71FD D873");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFingerprintNoSpaces() throws DescriptorParseException {
+    DescriptorBuilder.createWithFingerprintLine("opt fingerprint "
+        + "D8733048FC8EC9102466AD8F3098622BF1BF71FD");
+  }
+
+  @Test()
+  public void testUptimeMissing() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithUptimeLine(null);
+    assertEquals(-1, (int) descriptor.getUptime());
+  }
+
+  @Test()
+  public void testUptimeOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithUptimeLine("opt uptime 48");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testUptimeFourtyEight() throws DescriptorParseException {
+    DescriptorBuilder.createWithUptimeLine("uptime fourty-eight");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testUptimeMinusOne() throws DescriptorParseException {
+    DescriptorBuilder.createWithUptimeLine("uptime -1");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testUptimeSpace() throws DescriptorParseException {
+    DescriptorBuilder.createWithUptimeLine("uptime ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testUptimeNoSpace() throws DescriptorParseException {
+    DescriptorBuilder.createWithUptimeLine("uptime");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testUptimeFourEight() throws DescriptorParseException {
+    DescriptorBuilder.createWithUptimeLine("uptime 4 8");
+  }
+
+  @Test()
+  public void testBandwidthOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithBandwidthLine("opt bandwidth 51200 51200 53470");
+    assertEquals(51200, (int) descriptor.getBandwidthRate());
+    assertEquals(51200, (int) descriptor.getBandwidthBurst());
+    assertEquals(53470, (int) descriptor.getBandwidthObserved());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testBandwidthMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithBandwidthLine(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testBandwidthTwoValues() throws DescriptorParseException {
+    DescriptorBuilder.createWithBandwidthLine("bandwidth 51200 51200");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testBandwidthFourValues() throws DescriptorParseException {
+    DescriptorBuilder.createWithBandwidthLine("bandwidth 51200 51200 "
+        + "53470 53470");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testBandwidthMinusOneTwoThree()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithBandwidthLine("bandwidth -1 -2 -3");
+  }
+
+  @Test()
+  public void testExtraInfoDigestNoOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithExtraInfoDigestLine("extra-info-digest "
+        + "1469D1550738A25B1E7B47CDDBCD7B2899F51B74");
+    assertEquals("1469D1550738A25B1E7B47CDDBCD7B2899F51B74",
+        descriptor.getExtraInfoDigest());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExtraInfoDigestNoSpace()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithExtraInfoDigestLine("opt "
+        + "extra-info-digest");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExtraInfoDigestTooShort()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithExtraInfoDigestLine("opt "
+        + "extra-info-digest 1469D1550738A25B1E7B47CDDBCD7B2899F5");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExtraInfoDigestTooLong()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithExtraInfoDigestLine("opt "
+        + "extra-info-digest "
+        + "1469D1550738A25B1E7B47CDDBCD7B2899F51B741469");
+  }
+
+  @Test()
+  public void testExtraInfoDigestMissing()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithExtraInfoDigestLine(null);
+    assertNull(descriptor.getExtraInfoDigest());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testOnionKeyMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithOnionKeyLines(null);
+  }
+
+  @Test()
+  public void testOnionKeyOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithOnionKeyLines("opt onion-key\n"
+        + "-----BEGIN RSA PUBLIC KEY-----\n"
+        + "MIGJAoGBAKM+iiHhO6eHsvd6Xjws9z9EQB1V/Bpuy5ciGJ1U4V9SeiKooSo5Bp"
+        + "PL\no3XT+6PIgzl3R6uycjS3Ejk47vLEJdcVTm/VG6E0ppu3olIynCI4QryfCE"
+        + "uC3cTF\n9wE4WXY4nX7w0RTN18UVLxrt1A9PP0cobFNiPs9rzJCbKFfacOkpAg"
+        + "MBAAE=\n"
+        + "-----END RSA PUBLIC KEY-----");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testSigningKeyMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithSigningKeyLines(null);
+  }
+
+  @Test()
+  public void testSigningKeyOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithSigningKeyLines("opt signing-key\n"
+        + "-----BEGIN RSA PUBLIC KEY-----\n"
+        + "MIGJAoGBALMm3r3QDh482Ewe6Ub9wvRIfmEkoNX6q5cEAtQRNHSDcNx41gjELb"
+        + "cl\nEniVMParBYACKfOxkS+mTTnIRDKVNEJTsDOwryNrc4X9JnPc/nn6ymYPiN"
+        + "DhUROG\n8URDIhQoixcUeyyrVB8sxliSstKimulGnB7xpjYOlO8JKaHLNL4TAg"
+        + "MBAAE=\n"
+        + "-----END RSA PUBLIC KEY-----");
+  }
+
+  @Test()
+  public void testHiddenServiceDirMissing()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithHiddenServiceDirLine(null);
+    assertNull(descriptor.getHiddenServiceDirVersions());
+  }
+
+  @Test()
+  public void testHiddenServiceDirNoOpt()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithHiddenServiceDirLine("hidden-service-dir");
+    assertEquals(Arrays.asList(new Integer[] {2}),
+        descriptor.getHiddenServiceDirVersions());
+  }
+
+  @Test()
+  public void testHiddenServiceDirVersions2And3()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithHiddenServiceDirLine("hidden-service-dir 2 3");
+    assertEquals(Arrays.asList(new Integer[] {2, 3}),
+        descriptor.getHiddenServiceDirVersions());
+  }
+
+  @Test()
+  public void testContactMissing() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithContactLine(null);
+    assertNull(descriptor.getContact());
+  }
+
+  @Test()
+  public void testContactOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithContactLine("opt contact Random Person");
+    assertEquals("Random Person", descriptor.getContact());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testContactDuplicate() throws DescriptorParseException {
+    DescriptorBuilder.createWithContactLine("contact Random "
+        + "Person\ncontact Random Person");
+  }
+
+  @Test()
+  public void testContactNoSpace() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithContactLine("contact");
+    assertEquals("", descriptor.getContact());
+  }
+
+  @Test()
+  public void testExitPolicyRejectAllAcceptAll()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithExitPolicyLines("reject *:*\naccept *:*");
+    assertEquals(Arrays.asList(new String[] {"reject *:*", "accept *:*"}),
+        descriptor.getExitPolicyLines());
+  }
+
+  @Test()
+  public void testExitPolicyOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithExitPolicyLines("opt reject *:*");
+    assertEquals(Arrays.asList(new String[] {"reject *:*"}),
+        descriptor.getExitPolicyLines());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExitPolicyNoPort() throws DescriptorParseException {
+    DescriptorBuilder.createWithExitPolicyLines("reject *");
+  }
+
+  @Test()
+  public void testExitPolicyAccept80RejectAll()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithExitPolicyLines("accept *:80\nreject *:*");
+    assertEquals(Arrays.asList(new String[] {"accept *:80",
+        "reject *:*"}), descriptor.getExitPolicyLines());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExitPolicyReject321() throws DescriptorParseException {
+    DescriptorBuilder.createWithExitPolicyLines("reject "
+        + "123.123.123.321:80");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExitPolicyRejectPort66666()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithExitPolicyLines("reject *:66666");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExitPolicyProjectAll() throws DescriptorParseException {
+    DescriptorBuilder.createWithExitPolicyLines("project *:*");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testExitPolicyMissing() throws DescriptorParseException {
+    DescriptorBuilder.createWithExitPolicyLines(null);
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testRouterSignatureMissing()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterSignatureLines(null);
+  }
+
+  @Test()
+  public void testRouterSignatureOpt()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterSignatureLines("opt "
+        + "router-signature\n"
+        + "-----BEGIN SIGNATURE-----\n"
+        + "crypto lines are ignored anyway\n"
+        + "-----END SIGNATURE-----");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testRouterSignatureNotLastLine()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithRouterSignatureLines("router-signature\n"
+        + "-----BEGIN SIGNATURE-----\n"
+        + "o4j+kH8UQfjBwepUnr99v0ebN8RpzHJ/lqYsTojXHy9kMr1RNI9IDeSzA7PSqT"
+        + "uV\n4PL8QsGtlfwthtIoZpB2srZeyN/mcpA9fa1JXUrt/UN9K/+32Cyaad7h0n"
+        + "HE6Xfb\njqpXDpnBpvk4zjmzjjKYnIsUWTnADmu0fo3xTRqXi7g=\n"
+        + "-----END SIGNATURE-----\ncontact me");
+  }
+
+  @Test()
+  public void testHibernatingOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithHibernatingLine("opt hibernating true");
+    assertTrue(descriptor.isHibernating());
+  }
+
+  @Test()
+  public void testHibernatingFalse() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithHibernatingLine("hibernating false");
+    assertFalse(descriptor.isHibernating());
+  }
+
+  @Test()
+  public void testHibernatingTrue() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithHibernatingLine("hibernating true");
+    assertTrue(descriptor.isHibernating());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testHibernatingYep() throws DescriptorParseException {
+    DescriptorBuilder.createWithHibernatingLine("hibernating yep");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testHibernatingNoSpace() throws DescriptorParseException {
+    DescriptorBuilder.createWithHibernatingLine("hibernating");
+  }
+
+  @Test()
+  public void testFamilyOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithFamilyLine("opt family saberrider2008");
+    assertEquals(Arrays.asList(new String[] {"saberrider2008"}),
+        descriptor.getFamilyEntries());
+  }
+
+  @Test()
+  public void testFamilyFingerprint() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithFamilyLine("family "
+        + "$D8733048FC8EC9102466AD8F3098622BF1BF71FD");
+    assertEquals(Arrays.asList(new String[] {
+        "$D8733048FC8EC9102466AD8F3098622BF1BF71FD"}),
+        descriptor.getFamilyEntries());
+  }
+
+  @Test()
+  public void testFamilyNickname() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithFamilyLine("family saberrider2008");
+    assertEquals(Arrays.asList(new String[] {"saberrider2008"}),
+        descriptor.getFamilyEntries());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFamilyDuplicate() throws DescriptorParseException {
+    DescriptorBuilder.createWithFamilyLine("family "
+        + "saberrider2008\nfamily saberrider2008");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFamilyNicknamePrefix() throws DescriptorParseException {
+    DescriptorBuilder.createWithFamilyLine("family $saberrider2008");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testFamilyFingerprintNoPrefix()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithFamilyLine("family "
+        + "D8733048FC8EC9102466AD8F3098622BF1BF71FD");
+  }
+
+  @Test()
+  public void testWriteHistory() throws DescriptorParseException {
+    String writeHistoryLine = "write-history 2012-01-01 03:51:44 (900 s) "
+        + "4345856,261120,7591936,1748992";
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithWriteHistoryLine(writeHistoryLine);
+    assertNotNull(descriptor.getWriteHistory());
+    BandwidthHistory parsedWriteHistory = descriptor.getWriteHistory();
+    assertEquals(writeHistoryLine, parsedWriteHistory.getLine());
+    assertEquals(1325389904000L, (long) parsedWriteHistory.
+        getHistoryEndMillis());
+    assertEquals(900L, (long) parsedWriteHistory.getIntervalLength());
+    SortedMap<Long, Long> bandwidthValues = parsedWriteHistory.
+        getBandwidthValues();
+    assertEquals(4345856L, (long) bandwidthValues.remove(1325387204000L));
+    assertEquals(261120L, (long) bandwidthValues.remove(1325388104000L));
+    assertEquals(7591936L, (long) bandwidthValues.remove(1325389004000L));
+    assertEquals(1748992L, (long) bandwidthValues.remove(1325389904000L));
+    assertTrue(bandwidthValues.isEmpty());
+  }
+
+  @Test()
+  public void testWriteHistoryOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithWriteHistoryLine("opt write-history 2012-01-01 "
+        + "03:51:44 (900 s) 4345856,261120,7591936,1748992");
+    assertNotNull(descriptor.getWriteHistory());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistory3012() throws DescriptorParseException {
+    DescriptorBuilder.createWithWriteHistoryLine("write-history "
+        + "3012-01-01 03:51:44 (900 s) 4345856,261120,7591936,1748992");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistoryNoSeconds()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithWriteHistoryLine("write-history "
+        + "2012-01-01 03:51 (900 s) 4345856,261120,7591936,1748992");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistoryNoParathenses()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithWriteHistoryLine("write-history "
+        + "2012-01-01 03:51:44 900 s 4345856,261120,7591936,1748992");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistoryNoSpaceSeconds()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithWriteHistoryLine("write-history "
+        + "2012-01-01 03:51:44 (900s) 4345856,261120,7591936,1748992");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistoryTrailingComma()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithWriteHistoryLine("write-history "
+        + "2012-01-01 03:51:44 (900 s) 4345856,261120,7591936,");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistoryOneTwoThree()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithWriteHistoryLine("write-history "
+        + "2012-01-01 03:51:44 (900 s) one,two,three");
+  }
+
+  @Test()
+  public void testWriteHistoryNoValuesSpace()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithWriteHistoryLine("write-history 2012-01-01 03:51:44 "
+        + "(900 s) ");
+    assertEquals(900, (long) descriptor.getWriteHistory().
+        getIntervalLength());
+    assertTrue(descriptor.getWriteHistory().getBandwidthValues().
+        isEmpty());
+  }
+
+  @Test()
+  public void testWriteHistoryNoValuesNoSpace()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithWriteHistoryLine("write-history 2012-01-01 03:51:44 "
+        + "(900 s)");
+    assertEquals(900, (long) descriptor.getWriteHistory().
+        getIntervalLength());
+    assertTrue(descriptor.getWriteHistory().getBandwidthValues().
+        isEmpty());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistoryNoS() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithWriteHistoryLine("write-history 2012-01-01 03:51:44 "
+        + "(900 ");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testWriteHistoryTrailingNumber()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithWriteHistoryLine("write-history "
+        + "2012-01-01 03:51:44 (900 s) 4345856 1");
+  }
+
+  @Test()
+  public void testWriteHistory1800Seconds()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithWriteHistoryLine("write-history 2012-01-01 03:51:44 "
+        + "(1800 s) 4345856");
+    assertEquals(1800L, (long) descriptor.getWriteHistory().
+        getIntervalLength());
+  }
+
+  @Test()
+  public void testReadHistory() throws DescriptorParseException {
+    String readHistoryLine = "read-history 2012-01-01 03:51:44 (900 s) "
+        + "4268032,139264,7797760,1415168";
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithReadHistoryLine(readHistoryLine);
+    assertNotNull(descriptor.getReadHistory());
+    BandwidthHistory parsedReadHistory = descriptor.getReadHistory();
+    assertEquals(readHistoryLine, parsedReadHistory.getLine());
+    assertEquals(1325389904000L, (long) parsedReadHistory.
+        getHistoryEndMillis());
+    assertEquals(900L, (long) parsedReadHistory.getIntervalLength());
+    SortedMap<Long, Long> bandwidthValues = parsedReadHistory.
+        getBandwidthValues();
+    assertEquals(4268032L, (long) bandwidthValues.remove(1325387204000L));
+    assertEquals(139264L, (long) bandwidthValues.remove(1325388104000L));
+    assertEquals(7797760L, (long) bandwidthValues.remove(1325389004000L));
+    assertEquals(1415168L, (long) bandwidthValues.remove(1325389904000L));
+    assertTrue(bandwidthValues.isEmpty());
+  }
+
+  /* TODO There are some old server descriptors with " read-history"
+   * lines.  Find out if these were spec-compliant and if other lines may
+   * start with leading spaces, too. */
+  @Test(expected = DescriptorParseException.class)
+  public void testReadHistoryLeadingSpace()
+      throws DescriptorParseException {
+    String readHistoryLine = " read-history 2012-01-01 03:51:44 (900 s) "
+        + "4268032,139264,7797760,1415168";
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithReadHistoryLine(readHistoryLine);
+  }
+
+  @Test()
+  public void testEventdnsOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithEventdnsLine("opt eventdns true");
+    assertTrue(descriptor.getUsesEnhancedDnsLogic());
+  }
+
+  @Test()
+  public void testEventdnsTrue() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithEventdnsLine("eventdns true");
+    assertTrue(descriptor.getUsesEnhancedDnsLogic());
+  }
+
+  @Test()
+  public void testEventdnsFalse() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithEventdnsLine("eventdns false");
+    assertFalse(descriptor.getUsesEnhancedDnsLogic());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testEventdns1() throws DescriptorParseException {
+    DescriptorBuilder.createWithEventdnsLine("eventdns 1");
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testEventdnsNo() throws DescriptorParseException {
+    DescriptorBuilder.createWithEventdnsLine("eventdns no");
+  }
+
+  @Test()
+  public void testCachesExtraInfoOpt() throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithCachesExtraInfoLine("opt caches-extra-info");
+    assertTrue(descriptor.getCachesExtraInfo());
+  }
+
+  @Test()
+  public void testCachesExtraInfoNoSpace()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithCachesExtraInfoLine("caches-extra-info");
+    assertTrue(descriptor.getCachesExtraInfo());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testCachesExtraInfoTrue() throws DescriptorParseException {
+    DescriptorBuilder.createWithCachesExtraInfoLine("caches-extra-info "
+        + "true");
+  }
+
+  @Test()
+  public void testAllowSingleHopExitsOpt()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithCachesExtraInfoLine("opt allow-single-hop-exits");
+    assertTrue(descriptor.getAllowSingleHopExits());
+  }
+
+  @Test()
+  public void testAllowSingleHopExitsNoSpace()
+      throws DescriptorParseException {
+    RelayServerDescriptor descriptor = DescriptorBuilder.
+        createWithCachesExtraInfoLine("allow-single-hop-exits");
+    assertTrue(descriptor.getAllowSingleHopExits());
+  }
+
+  @Test(expected = DescriptorParseException.class)
+  public void testAllowSingleHopExitsTrue()
+      throws DescriptorParseException {
+    DescriptorBuilder.createWithCachesExtraInfoLine(
+        "allow-single-hop-exits true");
+  }
+}
+

    

karsten＠torproject.org

tags

participants (1)