[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[tor-commits] [metrics-lib/master] Add support for parsing exit lists.



commit 5c1494966f2af90f4bdb024c3c561cccad23b24e
Author: Karsten Loesing <karsten.loesing@xxxxxxx>
Date:   Thu Feb 2 08:11:15 2012 +0100

    Add support for parsing exit lists.
---
 src/org/torproject/descriptor/ExitList.java        |   16 ++
 src/org/torproject/descriptor/ExitListEntry.java   |   25 +++
 .../torproject/descriptor/impl/DescriptorImpl.java |    3 +
 .../descriptor/impl/ExitListEntryImpl.java         |  170 ++++++++++++++++++++
 .../torproject/descriptor/impl/ExitListImpl.java   |  121 ++++++++++++++
 5 files changed, 335 insertions(+), 0 deletions(-)

diff --git a/src/org/torproject/descriptor/ExitList.java b/src/org/torproject/descriptor/ExitList.java
new file mode 100644
index 0000000..5372b8b
--- /dev/null
+++ b/src/org/torproject/descriptor/ExitList.java
@@ -0,0 +1,16 @@
+/* Copyright 2012 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor;
+
+import java.util.Set;
+
+/* Exit list containing all known exit scan results at a given time. */
+public interface ExitList extends Descriptor {
+
+  /* Return the publication time of the exit list. */
+  public long getPublishedMillis();
+
+  /* Return the unordered set of exit scan results. */
+  public Set<ExitListEntry> getExitListEntries();
+}
+
diff --git a/src/org/torproject/descriptor/ExitListEntry.java b/src/org/torproject/descriptor/ExitListEntry.java
new file mode 100644
index 0000000..74438de
--- /dev/null
+++ b/src/org/torproject/descriptor/ExitListEntry.java
@@ -0,0 +1,25 @@
+/* Copyright 2012 The Tor Project
+ * See LICENSE for licensing information */
+package org.torproject.descriptor;
+
+/* Exit list entry containing results from a single exit scan. */
+public interface ExitListEntry {
+
+  /* Return the scanned relay's fingerprint. */
+  public String getFingerprint();
+
+  /* Return the publication time of the scanned relay's last known
+   * descriptor. */
+  public long getPublishedMillis();
+
+  /* Return the publication time of the network status that this scan was
+   * based on. */
+  public long getLastStatusMillis();
+
+  /* Return the IP address that was determined in the scan. */
+  public String getExitAddress();
+
+  /* Return the scan time. */
+  public long getScanMillis();
+}
+
diff --git a/src/org/torproject/descriptor/impl/DescriptorImpl.java b/src/org/torproject/descriptor/impl/DescriptorImpl.java
index 7db8aaf..e173612 100644
--- a/src/org/torproject/descriptor/impl/DescriptorImpl.java
+++ b/src/org/torproject/descriptor/impl/DescriptorImpl.java
@@ -63,6 +63,9 @@ public abstract class DescriptorImpl implements Descriptor {
           failUnrecognizedDescriptorLines));
     } else if (firstLines.startsWith("dir-key-certificate-version ")) {
       /* TODO Implement parsing of directory certificates. */
+    } else if (firstLines.startsWith("ExitNode ")) {
+      parsedDescriptors.add(new ExitListImpl(rawDescriptorBytes, fileName,
+          failUnrecognizedDescriptorLines));
     } else {
       throw new DescriptorParseException("Could not detect descriptor "
           + "type in descriptor starting with '" + firstLines + "'.");
diff --git a/src/org/torproject/descriptor/impl/ExitListEntryImpl.java b/src/org/torproject/descriptor/impl/ExitListEntryImpl.java
new file mode 100644
index 0000000..b3ed8f1
--- /dev/null
+++ b/src/org/torproject/descriptor/impl/ExitListEntryImpl.java
@@ -0,0 +1,170 @@
+/* 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.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import org.torproject.descriptor.ExitListEntry;
+
+public class ExitListEntryImpl implements ExitListEntry {
+
+  private byte[] exitListEntryBytes;
+  public byte[] getExitListEntryBytes() {
+    return this.exitListEntryBytes;
+  }
+
+  private boolean failUnrecognizedDescriptorLines;
+  private List<String> unrecognizedLines;
+  protected List<String> getAndClearUnrecognizedLines() {
+    List<String> lines = this.unrecognizedLines;
+    this.unrecognizedLines = null;
+    return lines;
+  }
+
+  protected ExitListEntryImpl(byte[] exitListEntryBytes,
+      boolean failUnrecognizedDescriptorLines)
+      throws DescriptorParseException {
+    this.exitListEntryBytes = exitListEntryBytes;
+    this.failUnrecognizedDescriptorLines =
+        failUnrecognizedDescriptorLines;
+    this.initializeKeywords();
+    this.parseExitListEntryBytes();
+    this.checkKeywords();
+  }
+
+  private SortedSet<String> exactlyOnceKeywords;
+  private void initializeKeywords() {
+    this.exactlyOnceKeywords = new TreeSet<String>();
+    this.exactlyOnceKeywords.add("ExitNode");
+    this.exactlyOnceKeywords.add("Published");
+    this.exactlyOnceKeywords.add("LastStatus");
+    this.exactlyOnceKeywords.add("ExitAddress");
+  }
+
+  private void parsedExactlyOnceKeyword(String keyword)
+      throws DescriptorParseException {
+    if (!this.exactlyOnceKeywords.contains(keyword)) {
+      throw new DescriptorParseException("Duplicate '" + keyword
+          + "' line in exit list entry.");
+    }
+    this.exactlyOnceKeywords.remove(keyword);
+  }
+
+  private void checkKeywords() throws DescriptorParseException {
+    for (String missingKeyword : this.exactlyOnceKeywords) {
+      throw new DescriptorParseException("Missing '" + missingKeyword
+          + "' line in exit list entry.");
+    }
+  }
+
+  private void parseExitListEntryBytes()
+      throws DescriptorParseException {
+    try {
+      BufferedReader br = new BufferedReader(new StringReader(
+          new String(this.exitListEntryBytes)));
+      String line;
+      while ((line = br.readLine()) != null) {
+        String[] parts = line.split(" ");
+        String keyword = parts[0];
+        if (keyword.equals("ExitNode")) {
+          this.parseExitNodeLine(line, parts);
+        } else if (keyword.equals("Published")) {
+          this.parsePublishedLine(line, parts);
+        } else if (keyword.equals("LastStatus")) {
+          this.parseLastStatusLine(line, parts);
+        } else if (keyword.equals("ExitAddress")) {
+          this.parseExitAddressLine(line, parts);
+        } else if (this.failUnrecognizedDescriptorLines) {
+          throw new DescriptorParseException("Unrecognized line '" + line
+              + "' in exit list entry.");
+        } else {
+          if (this.unrecognizedLines == null) {
+            this.unrecognizedLines = new ArrayList<String>();
+          }
+          this.unrecognizedLines.add(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 parseExitNodeLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length != 2) {
+      throw new DescriptorParseException("Invalid line '" + line + "' in "
+          + "exit list entry.");
+    }
+    this.parsedExactlyOnceKeyword(parts[0]);
+    this.fingerprint = ParseHelper.parseTwentyByteHexString(line,
+        parts[1]);
+  }
+
+  private void parsePublishedLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length != 3) {
+      throw new DescriptorParseException("Invalid line '" + line + "' in "
+          + "exit list entry.");
+    }
+    this.parsedExactlyOnceKeyword(parts[0]);
+    this.publishedMillis = ParseHelper.parseTimestampAtIndex(line, parts,
+        1, 2);
+  }
+
+  private void parseLastStatusLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length != 3) {
+      throw new DescriptorParseException("Invalid line '" + line + "' in "
+          + "exit list entry.");
+    }
+    this.parsedExactlyOnceKeyword(parts[0]);
+    this.lastStatusMillis = ParseHelper.parseTimestampAtIndex(line, parts,
+        1, 2);
+  }
+
+  private void parseExitAddressLine(String line, String[] parts)
+      throws DescriptorParseException {
+    if (parts.length != 4) {
+      throw new DescriptorParseException("Invalid line '" + line + "' in "
+          + "exit list entry.");
+    }
+    this.parsedExactlyOnceKeyword(parts[0]);
+    this.exitAddress = ParseHelper.parseIpv4Address(line, parts[1]);
+    this.scanMillis = ParseHelper.parseTimestampAtIndex(line, parts,
+        2, 3);
+  }
+
+  private String fingerprint;
+  public String getFingerprint() {
+    return this.fingerprint;
+  }
+
+  private long publishedMillis;
+  public long getPublishedMillis() {
+    return this.publishedMillis;
+  }
+
+  private long lastStatusMillis;
+  public long getLastStatusMillis() {
+    return this.lastStatusMillis;
+  }
+
+  private String exitAddress;
+  public String getExitAddress() {
+    return this.exitAddress;
+  }
+
+  private long scanMillis;
+  public long getScanMillis() {
+    return this.scanMillis;
+  }
+}
+
diff --git a/src/org/torproject/descriptor/impl/ExitListImpl.java b/src/org/torproject/descriptor/impl/ExitListImpl.java
new file mode 100644
index 0000000..4861fa0
--- /dev/null
+++ b/src/org/torproject/descriptor/impl/ExitListImpl.java
@@ -0,0 +1,121 @@
+/* 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.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.TimeZone;
+
+import org.torproject.descriptor.ExitList;
+import org.torproject.descriptor.ExitListEntry;
+
+/* TODO Add test class. */
+public class ExitListImpl extends DescriptorImpl implements ExitList {
+
+  protected ExitListImpl(byte[] rawDescriptorBytes, String fileName,
+      boolean failUnrecognizedDescriptorLines)
+      throws DescriptorParseException {
+    super(rawDescriptorBytes, failUnrecognizedDescriptorLines);
+    this.setPublishedMillisFromFileName(fileName);
+    this.splitAndParseExitListEntries(rawDescriptorBytes);
+  }
+
+  private void setPublishedMillisFromFileName(String fileName)
+      throws DescriptorParseException {
+    if (fileName.length() == "2012-02-01-04-06-24".length()) {
+      try {
+        SimpleDateFormat fileNameFormat = new SimpleDateFormat(
+            "yyyy-MM-dd-HH-mm-ss");
+        fileNameFormat.setLenient(false);
+        fileNameFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+        this.publishedMillis = fileNameFormat.parse(fileName).getTime();
+      } catch (ParseException e) {
+        /* Handle below. */
+      }
+    }
+    if (this.publishedMillis == 0L) {
+      throw new DescriptorParseException("Unrecognized exit list file "
+          + "name '" + fileName + "'.");
+    }
+  }
+
+  private void splitAndParseExitListEntries(byte[] rawDescriptorBytes)
+      throws DescriptorParseException {
+    if (this.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;
+      StringBuilder sb = new StringBuilder();
+      while ((line = br.readLine()) != null) {
+        String[] parts = line.split(" ");
+        String keyword = parts[0];
+        if (keyword.equals("ExitNode")) {
+          sb = new StringBuilder();
+          sb.append(line + "\n");
+        } else if (keyword.equals("Published")) {
+          sb.append(line + "\n");
+        } else if (keyword.equals("LastStatus")) {
+          sb.append(line + "\n");
+        } else if (keyword.equals("ExitAddress")) {
+          String exitListEntryString = sb.toString() + line + "\n";
+          byte[] exitListEntryBytes = exitListEntryString.getBytes();
+          this.parseExitListEntry(exitListEntryBytes);
+        } else if (this.failUnrecognizedDescriptorLines) {
+          throw new DescriptorParseException("Unrecognized line '" + line
+              + "' in exit list.");
+        } else {
+          if (this.unrecognizedLines == null) {
+            this.unrecognizedLines = new ArrayList<String>();
+          }
+          this.unrecognizedLines.add(line);
+        }
+      }
+    } 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 parseExitListEntry(byte[] exitListEntryBytes)
+      throws DescriptorParseException {
+    ExitListEntryImpl exitListEntry = new ExitListEntryImpl(
+        exitListEntryBytes, this.failUnrecognizedDescriptorLines);
+    this.exitListEntries.add(exitListEntry);
+    List<String> unrecognizedExitListEntryLines = exitListEntry.
+        getAndClearUnrecognizedLines();
+    if (unrecognizedExitListEntryLines != null) {
+      if (this.unrecognizedLines == null) {
+        this.unrecognizedLines = new ArrayList<String>();
+      }
+      this.unrecognizedLines.addAll(unrecognizedExitListEntryLines);
+    }
+  }
+
+  private long publishedMillis;
+  public long getPublishedMillis() {
+    return this.publishedMillis;
+  }
+
+  private Set<ExitListEntry> exitListEntries =
+      new HashSet<ExitListEntry>();
+  public Set<ExitListEntry> getExitListEntries() {
+    return new HashSet<ExitListEntry>(this.exitListEntries);
+  }
+}
+

_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits