Ticket #17824: 0001-task-17824-addendum.patch

File 0001-task-17824-addendum.patch, 38.2 KB (added by iwakeh, 4 years ago)

more

  • src/org/torproject/descriptor/impl/DirSourceEntryImpl.java

    From ff67b09d07deec782b1ae2515a25f943b661268f Tue Dec 22 22:00:00 2015
    From: iwakeh <iwakeh@users.ourproject.org>
    Date: Tue, 22 Dec 2015 22:00:00 +0000
    Subject: [PATCH] task-17824 addendum.
    
    ---
     .../descriptor/impl/DirSourceEntryImpl.java        |  35 ++++--
     .../impl/DirectoryKeyCertificateImpl.java          |  53 ++++----
     .../descriptor/impl/DirectorySignatureImpl.java    |  41 +++---
     .../descriptor/impl/DownloadCoordinatorImpl.java   |  74 +++++------
     .../descriptor/impl/ExtraInfoDescriptorImpl.java   |  62 +++++-----
     .../descriptor/impl/MicrodescriptorImpl.java       |  72 ++++++-----
     .../descriptor/impl/NetworkStatusEntryImpl.java    |  25 ++--
     .../descriptor/impl/NetworkStatusImpl.java         |  27 ++--
     .../torproject/descriptor/impl/ParseHelper.java    |  12 ++
     .../descriptor/impl/RelayDirectoryImpl.java        |  64 +++++-----
     .../descriptor/impl/RelayNetworkStatusImpl.java    |  61 +++++----
     .../impl/RelayNetworkStatusVoteImpl.java           |  14 ++-
     .../descriptor/impl/ServerDescriptorImpl.java      | 137 ++++++++++-----------
     13 files changed, 376 insertions(+), 301 deletions(-)
    
    diff --git a/src/org/torproject/descriptor/impl/DirSourceEntryImpl.java b/src/org/torproject/descriptor/impl/DirSourceEntryImpl.java
    index 3a59d5b..306bb07 100644
    a b public class DirSourceEntryImpl implements DirSourceEntry { 
    8080    boolean skipCrypto = false;
    8181    while (s.hasNext()) {
    8282      String line = s.next();
    83       if (line.startsWith("dir-source")) {
     83      String[] parts = line.split(" ");
     84      switch(parts[0]){
     85      case "dir-source":
    8486        this.parseDirSourceLine(line);
    85       } else if (line.startsWith("contact")) {
     87        break;
     88      case "contact":
    8689        this.parseContactLine(line);
    87       } else if (line.startsWith("vote-digest")) {
     90        break;
     91      case "vote-digest":
    8892        this.parseVoteDigestLine(line);
    89       } else if (line.startsWith("-----BEGIN")) {
     93        break;
     94      case "-----BEGIN":
    9095        skipCrypto = true;
    91       } else if (line.startsWith("-----END")) {
     96        break;
     97      case "-----END":
    9298        skipCrypto = false;
    93       } else if (!skipCrypto) {
    94         if (this.failUnrecognizedDescriptorLines) {
    95           throw new DescriptorParseException("Unrecognized line '"
    96               + line + "' in dir-source entry.");
    97         } else {
    98           if (this.unrecognizedLines == null) {
    99             this.unrecognizedLines = new ArrayList<>();
     99        break;
     100      default:
     101        if (!skipCrypto) {
     102          if (this.failUnrecognizedDescriptorLines) {
     103            throw new DescriptorParseException("Unrecognized line '"
     104                + line + "' in dir-source entry.");
     105          } else {
     106            if (this.unrecognizedLines == null) {
     107              this.unrecognizedLines = new ArrayList<>();
     108            }
     109            this.unrecognizedLines.add(line);
    100110          }
    101           this.unrecognizedLines.add(line);
    102111        }
    103112      }
    104113    }
  • src/org/torproject/descriptor/impl/DirectoryKeyCertificateImpl.java

    diff --git a/src/org/torproject/descriptor/impl/DirectoryKeyCertificateImpl.java b/src/org/torproject/descriptor/impl/DirectoryKeyCertificateImpl.java
    index 2b7d3ea..1039bbd 100644
    a b public class DirectoryKeyCertificateImpl extends DescriptorImpl 
    9898        this.parseDirKeyCertificationLine(line, parts);
    9999        nextCrypto = "dir-key-certification";
    100100        break;
     101      case "-----BEGIN":
     102        crypto = new StringBuilder();
     103        crypto.append(line).append("\n");
     104        break;
     105      case "-----END":
     106        crypto.append(line).append("\n");
     107        String cryptoString = crypto.toString();
     108        crypto = null;
     109        switch (nextCrypto) {
     110        case "dir-identity-key":
     111          this.dirIdentityKey = cryptoString;
     112          break;
     113        case "dir-signing-key":
     114          this.dirSigningKey = cryptoString;
     115          break;
     116        case "dir-key-crosscert":
     117          this.dirKeyCrosscert = cryptoString;
     118          break;
     119        case "dir-key-certification":
     120          this.dirKeyCertification = cryptoString;
     121          break;
     122        default:
     123          throw new DescriptorParseException("Unrecognized crypto "
     124              + "block in directory key certificate.");
     125        }
     126        nextCrypto = "";
    101127      default:
    102         if (line.startsWith("-----BEGIN")) {
    103           crypto = new StringBuilder();
    104           crypto.append(line).append("\n");
    105         } else if (line.startsWith("-----END")) {
    106           crypto.append(line).append("\n");
    107           String cryptoString = crypto.toString();
    108           crypto = null;
    109           switch (nextCrypto) {
    110           case "dir-identity-key":
    111             this.dirIdentityKey = cryptoString;
    112             break;
    113           case "dir-signing-key":
    114             this.dirSigningKey = cryptoString;
    115             break;
    116           case "dir-key-crosscert":
    117             this.dirKeyCrosscert = cryptoString;
    118             break;
    119           case "dir-key-certification":
    120             this.dirKeyCertification = cryptoString;
    121             break;
    122           default:
    123             throw new DescriptorParseException("Unrecognized crypto "
    124                 + "block in directory key certificate.");
    125           }
    126           nextCrypto = "";
    127         } else if (crypto != null) {
     128        if (crypto != null) {
    128129          crypto.append(line).append("\n");
    129130        } else {
    130131          if (this.failUnrecognizedDescriptorLines) {
  • src/org/torproject/descriptor/impl/DirectorySignatureImpl.java

    diff --git a/src/org/torproject/descriptor/impl/DirectorySignatureImpl.java b/src/org/torproject/descriptor/impl/DirectorySignatureImpl.java
    index 8cf6589..21136d8 100644
    a b public class DirectorySignatureImpl implements DirectorySignature { 
    4040    StringBuilder crypto = null;
    4141    while (s.hasNext()) {
    4242      String line = s.next();
    43       if (line.startsWith("directory-signature ")) {
    44         String[] parts = line.split(" ", -1);
     43      String[] parts = line.split(" ", -1);
     44      String keyword = parts[0];
     45      switch(keyword){
     46      case "directory-signature":
    4547        int algorithmOffset = 0;
    46         if (parts.length == 4) {
     48        switch(parts.length){
     49        case 4:
    4750          this.algorithm = parts[1];
    4851          algorithmOffset = 1;
    49         } else if (parts.length != 3) {
     52          break;
     53        case 3:
     54          break;
     55        default:
    5056          throw new DescriptorParseException("Illegal line '" + line
    5157              + "'.");
    5258        }
    public class DirectorySignatureImpl implements DirectorySignature { 
    5460            parts[1 + algorithmOffset]);
    5561        this.signingKeyDigest = ParseHelper.parseTwentyByteHexString(
    5662            line, parts[2 + algorithmOffset]);
    57       } else if (line.startsWith("-----BEGIN")) {
     63        break;
     64      case "-----BEGIN":
    5865        crypto = new StringBuilder();
    5966        crypto.append(line).append("\n");
    60       } else if (line.startsWith("-----END")) {
     67        break;
     68      case "-----END":
    6169        crypto.append(line).append("\n");
    6270        String cryptoString = crypto.toString();
    6371        crypto = null;
    6472        this.signature = cryptoString;
    65       } else if (crypto != null) {
    66         crypto.append(line).append("\n");
    67       } else {
    68         if (this.failUnrecognizedDescriptorLines) {
    69           throw new DescriptorParseException("Unrecognized line '"
    70               + line + "' in dir-source entry.");
     73        break;
     74      default:
     75        if (crypto != null) {
     76          crypto.append(line).append("\n");
    7177        } else {
    72           if (this.unrecognizedLines == null) {
    73             this.unrecognizedLines = new ArrayList<>();
     78          if (this.failUnrecognizedDescriptorLines) {
     79            throw new DescriptorParseException("Unrecognized line '"
     80                + line + "' in dir-source entry.");
     81          } else {
     82            if (this.unrecognizedLines == null) {
     83              this.unrecognizedLines = new ArrayList<>();
     84            }
     85            this.unrecognizedLines.add(line);
    7486          }
    75           this.unrecognizedLines.add(line);
    7687        }
    7788      }
    7889    }
  • src/org/torproject/descriptor/impl/DownloadCoordinatorImpl.java

    diff --git a/src/org/torproject/descriptor/impl/DownloadCoordinatorImpl.java b/src/org/torproject/descriptor/impl/DownloadCoordinatorImpl.java
    index e95f9da..1a33827 100644
    a b public class DownloadCoordinatorImpl implements DownloadCoordinator { 
    203203    if (response.getException() != null) {
    204204      this.runningDirectories.remove(nickname);
    205205    }
    206     if (response.getDescriptorType().equals("consensus")) {
    207       this.requestingConsensuses.remove(nickname);
    208       if (response.getResponseCode() == 200 &&
    209           response.getDescriptors() != null) {
    210         if (this.includeCurrentReferencedVotes) {
    211           /* TODO Only add votes if the consensus is not older than one
    212            * hour.  Or does that make no sense? */
    213           for (Descriptor parsedDescriptor : response.getDescriptors()) {
    214             if (!(parsedDescriptor instanceof
    215                 RelayNetworkStatusConsensus)) {
    216               continue;
    217             }
    218             RelayNetworkStatusConsensus parsedConsensus =
    219                 (RelayNetworkStatusConsensus) parsedDescriptor;
    220             for (DirSourceEntry dirSource :
    221                 parsedConsensus.getDirSourceEntries().values()) {
    222               String identity = dirSource.getIdentity();
    223               if (!this.missingVotes.contains(identity)) {
    224                 boolean alreadyRequested = false;
    225                 for (Set<String> requestedBefore :
    226                     this.requestedVotes.values()) {
    227                   if (requestedBefore.contains(identity)) {
    228                     alreadyRequested = true;
    229                     break;
     206    switch(response.getDescriptorType()) {
     207      case "consensus":
     208        this.requestingConsensuses.remove(nickname);
     209        if (response.getResponseCode() == 200 &&
     210            response.getDescriptors() != null) {
     211          if (this.includeCurrentReferencedVotes) {
     212            /* TODO Only add votes if the consensus is not older than one
     213             * hour.  Or does that make no sense? */
     214            for (Descriptor parsedDescriptor : response.getDescriptors()) {
     215              if (!(parsedDescriptor instanceof
     216                  RelayNetworkStatusConsensus)) {
     217                continue;
     218              }
     219              RelayNetworkStatusConsensus parsedConsensus =
     220                  (RelayNetworkStatusConsensus) parsedDescriptor;
     221              for (DirSourceEntry dirSource :
     222                  parsedConsensus.getDirSourceEntries().values()) {
     223                String identity = dirSource.getIdentity();
     224                if (!this.missingVotes.contains(identity)) {
     225                  boolean alreadyRequested = false;
     226                  for (Set<String> requestedBefore :
     227                      this.requestedVotes.values()) {
     228                    if (requestedBefore.contains(identity)) {
     229                      alreadyRequested = true;
     230                      break;
     231                    }
     232                  }
     233                  if (!alreadyRequested) {
     234                    this.missingVotes.add(identity);
    230235                  }
    231                 }
    232                 if (!alreadyRequested) {
    233                   this.missingVotes.add(identity);
    234236                }
    235237              }
    236238            }
     239            /* TODO Later, add referenced server descriptors. */
    237240          }
    238           /* TODO Later, add referenced server descriptors. */
     241        } else {
     242          this.missingConsensus = true;
     243        }
     244        break;
     245      case "vote":
     246        String requestedVote = requestingVotes.remove(nickname);
     247        if (response.getResponseCode() != 200) {
     248          this.missingVotes.add(requestedVote);
    239249        }
    240       } else {
    241         this.missingConsensus = true;
    242       }
    243     } else if (response.getDescriptorType().equals("vote")) {
    244       String requestedVote = requestingVotes.remove(nickname);
    245       if (response.getResponseCode() != 200) {
    246         this.missingVotes.add(requestedVote);
    247       }
    248250    }
    249251    if (response.getRequestEnd() != 0L) {
    250252      this.descriptorQueue.add(response);
  • src/org/torproject/descriptor/impl/ExtraInfoDescriptorImpl.java

    diff --git a/src/org/torproject/descriptor/impl/ExtraInfoDescriptorImpl.java b/src/org/torproject/descriptor/impl/ExtraInfoDescriptorImpl.java
    index 4fcf4c9..3255bd9 100644
    a b public abstract class ExtraInfoDescriptorImpl extends DescriptorImpl 
    238238      case "router-digest-sha256":
    239239        this.parseRouterDigestSha256Line(line, lineNoOpt, partsNoOpt);
    240240        break;
    241       default:
    242         if (line.startsWith("-----BEGIN")) {
    243           cryptoLines = new ArrayList<>();
    244           cryptoLines.add(line);
    245         } else if (line.startsWith("-----END")) {
    246           cryptoLines.add(line);
    247           StringBuilder sb = new StringBuilder();
    248           for (String cryptoLine : cryptoLines) {
    249             sb.append("\n").append(cryptoLine);
    250           }
    251           String cryptoString = sb.toString().substring(1);
    252           switch (nextCrypto) {
    253           case "router-signature":
    254             this.routerSignature = cryptoString;
    255             break;
    256           case "identity-ed25519":
    257             this.identityEd25519 = cryptoString;
    258             this.parseIdentityEd25519CryptoBlock(cryptoString);
    259             break;
    260           default:
    261             if (this.failUnrecognizedDescriptorLines) {
    262               throw new DescriptorParseException("Unrecognized crypto "
    263                   + "block '" + cryptoString + "' in extra-info "
    264                   + "descriptor.");
    265             } else {
    266               if (this.unrecognizedLines == null) {
    267                 this.unrecognizedLines = new ArrayList<>();
    268               }
    269               this.unrecognizedLines.addAll(cryptoLines);
     241      case "-----BEGIN":
     242        cryptoLines = new ArrayList<>();
     243        cryptoLines.add(line);
     244        break;
     245      case "-----END":
     246        cryptoLines.add(line);
     247        StringBuilder sb = new StringBuilder();
     248        for (String cryptoLine : cryptoLines) {
     249          sb.append("\n").append(cryptoLine);
     250        }
     251        String cryptoString = sb.toString().substring(1);
     252        switch (nextCrypto) {
     253        case "router-signature":
     254          this.routerSignature = cryptoString;
     255          break;
     256        case "identity-ed25519":
     257          this.identityEd25519 = cryptoString;
     258          this.parseIdentityEd25519CryptoBlock(cryptoString);
     259          break;
     260        default:
     261          if (this.failUnrecognizedDescriptorLines) {
     262            throw new DescriptorParseException("Unrecognized crypto "
     263                + "block '" + cryptoString + "' in extra-info "
     264                + "descriptor.");
     265          } else {
     266            if (this.unrecognizedLines == null) {
     267              this.unrecognizedLines = new ArrayList<>();
    270268            }
     269            this.unrecognizedLines.addAll(cryptoLines);
    271270          }
    272271          cryptoLines = null;
    273272          nextCrypto = "";
    274         } else if (cryptoLines != null) {
     273        }
     274        break;
     275      default:
     276        if (cryptoLines != null) {
    275277          cryptoLines.add(line);
    276278        } else {
    277279          ParseHelper.parseKeyword(line, partsNoOpt[0]);
  • src/org/torproject/descriptor/impl/MicrodescriptorImpl.java

    diff --git a/src/org/torproject/descriptor/impl/MicrodescriptorImpl.java b/src/org/torproject/descriptor/impl/MicrodescriptorImpl.java
    index d303fa0..4fe5f25 100644
    a b public class MicrodescriptorImpl extends DescriptorImpl 
    8989      case "id":
    9090        this.parseIdLine(line, parts);
    9191        break;
     92      case "-----BEGIN":
     93        crypto = new StringBuilder();
     94        crypto.append(line).append("\n");
     95        break;
     96      case "-----END":
     97        crypto.append(line).append("\n");
     98        String cryptoString = crypto.toString();
     99        crypto = null;
     100        if (nextCrypto.equals("onion-key")) {
     101          this.onionKey = cryptoString;
     102        } else {
     103          throw new DescriptorParseException("Unrecognized crypto "
     104              + "block in microdescriptor.");
     105        }
     106        nextCrypto = "";
     107        break;
    92108      default:
    93         if (line.startsWith("-----BEGIN")) {
    94           crypto = new StringBuilder();
    95           crypto.append(line).append("\n");
    96         } else if (line.startsWith("-----END")) {
    97           crypto.append(line).append("\n");
    98           String cryptoString = crypto.toString();
    99           crypto = null;
    100           if (nextCrypto.equals("onion-key")) {
    101             this.onionKey = cryptoString;
    102           } else {
    103             throw new DescriptorParseException("Unrecognized crypto "
    104                 + "block in microdescriptor.");
    105           }
    106           nextCrypto = "";
    107         } else if (crypto != null) {
     109        if (crypto != null) {
    108110          crypto.append(line).append("\n");
    109111        } else {
    110112          ParseHelper.parseKeyword(line, parts[0]);
    public class MicrodescriptorImpl extends DescriptorImpl 
    191193    boolean isValid = true;
    192194    if (parts.length != 3) {
    193195      isValid = false;
    194     } else if (!parts[1].equals("accept") && !parts[1].equals("reject")) {
    195       isValid = false;
    196     } else {
    197       String[] ports = parts[2].split(",", -1);
    198       for (int i = 0; i < ports.length; i++) {
    199         if (ports[i].length() < 1) {
    200           isValid = false;
    201           break;
     196    } else  {
     197      switch(parts[1]){
     198      case "accept":
     199      case "reject":
     200        String[] ports = parts[2].split(",", -1);
     201        for (int i = 0; i < ports.length; i++) {
     202          if (ports[i].length() < 1) {
     203            isValid = false;
     204            break;
     205          }
    202206        }
     207        break;
     208      default:
     209        isValid = false;
    203210      }
    204211    }
    205212    if (!isValid) {
    public class MicrodescriptorImpl extends DescriptorImpl 
    211218      throws DescriptorParseException {
    212219    if (parts.length != 3) {
    213220      throw new DescriptorParseException("Illegal line '" + line + "'.");
    214     } else if ("ed25519".equals(parts[1])) {
    215       ParseHelper.parseThirtyTwoByteBase64String(line, parts[2]);
    216       this.ed25519Identity = parts[2];
    217     } else if ("rsa1024".equals(parts[1])) {
    218       ParseHelper.parseTwentyByteBase64String(line, parts[2]);
    219       this.rsa1024Identity = parts[2];
    220221    } else {
    221       throw new DescriptorParseException("Illegal line '" + line + "'.");
     222        switch(parts[1]){
     223        case "ed25519":
     224          ParseHelper.parseThirtyTwoByteBase64String(line, parts[2]);
     225          this.ed25519Identity = parts[2];
     226          break;
     227        case "rsa1024":
     228          ParseHelper.parseTwentyByteBase64String(line, parts[2]);
     229          this.rsa1024Identity = parts[2];
     230          break;
     231        default:
     232          throw new DescriptorParseException("Illegal line '" + line + "'.");
     233        }
    222234    }
    223235  }
    224236
  • src/org/torproject/descriptor/impl/NetworkStatusEntryImpl.java

    diff --git a/src/org/torproject/descriptor/impl/NetworkStatusEntryImpl.java b/src/org/torproject/descriptor/impl/NetworkStatusEntryImpl.java
    index c5f0704..1d67cbf 100644
    a b public class NetworkStatusEntryImpl implements NetworkStatusEntry { 
    213213    boolean isValid = true;
    214214    if (parts.length != 3) {
    215215      isValid = false;
    216     } else if (!parts[1].equals("accept") && !parts[1].equals("reject")) {
    217       isValid = false;
    218216    } else {
    219       this.defaultPolicy = parts[1];
    220       this.portList = parts[2];
    221       String[] ports = parts[2].split(",", -1);
    222       for (int i = 0; i < ports.length; i++) {
    223         if (ports[i].length() < 1) {
    224           isValid = false;
    225           break;
     217        switch(parts[1]){
     218          case "accept":
     219          case "reject":
     220            this.defaultPolicy = parts[1];
     221            this.portList = parts[2];
     222            String[] ports = parts[2].split(",", -1);
     223            for (int i = 0; i < ports.length; i++) {
     224              if (ports[i].length() < 1) {
     225                isValid = false;
     226                break;
     227              }
     228            }
     229            break;
     230          default:
     231            isValid = false;
    226232        }
    227       }
    228233    }
    229234    if (!isValid) {
    230235      throw new DescriptorParseException("Illegal line '" + line + "'.");
  • src/org/torproject/descriptor/impl/NetworkStatusImpl.java

    diff --git a/src/org/torproject/descriptor/impl/NetworkStatusImpl.java b/src/org/torproject/descriptor/impl/NetworkStatusImpl.java
    index a9c2483..423f214 100644
    a b public abstract class NetworkStatusImpl extends DescriptorImpl { 
    177177  protected String[] parseClientOrServerVersions(String line,
    178178      String[] parts) throws DescriptorParseException {
    179179    String[] result = null;
    180     if (parts.length > 2) {
    181       throw new DescriptorParseException("Illegal versions line '" + line
    182           + "'.");
    183     } else if (parts.length == 2) {
    184       result = parts[1].split(",", -1);
    185       for (String version : result) {
    186         if (version.length() < 1) {
    187           throw new DescriptorParseException("Illegal versions line '"
    188               + line + "'.");
     180    switch(parts.length){
     181      case 1:
     182        result = new String[0];
     183        break;
     184      case 2:
     185        result = parts[1].split(",", -1);
     186        for (String version : result) {
     187          if (version.length() < 1) {
     188            throw new DescriptorParseException("Illegal versions line '"
     189                + line + "'.");
     190          }
    189191        }
    190       }
    191     } else if (parts.length == 1) {
    192       result = new String[0];
     192        break;
     193      default:
     194        throw new DescriptorParseException("Illegal versions line '" + line
     195            + "'.");
    193196    }
    194197    return result;
    195198  }
  • src/org/torproject/descriptor/impl/ParseHelper.java

    diff --git a/src/org/torproject/descriptor/impl/ParseHelper.java b/src/org/torproject/descriptor/impl/ParseHelper.java
    index 43a44d1..f0231f4 100644
    a b public class ParseHelper { 
    263263    return nickname;
    264264  }
    265265
     266  public static boolean parseBoolean(String b, String line)
     267      throws DescriptorParseException {
     268    switch(b){
     269    case "1":
     270      return true;
     271    case "0":
     272      return false;
     273    default:
     274      throw new DescriptorParseException("Illegal line '" + line + "'.");
     275    }
     276  }
     277
    266278  private static Pattern twentyByteBase64Pattern =
    267279      Pattern.compile("^[0-9a-zA-Z+/]{27}$");
    268280  public static String parseTwentyByteBase64String(String line,
  • src/org/torproject/descriptor/impl/RelayDirectoryImpl.java

    diff --git a/src/org/torproject/descriptor/impl/RelayDirectoryImpl.java b/src/org/torproject/descriptor/impl/RelayDirectoryImpl.java
    index ac17f54..ccfcb1c 100644
    a b public class RelayDirectoryImpl extends DescriptorImpl 
    227227      case "router-status":
    228228        routerStatusLine = line;
    229229        break;
     230      case "-----BEGIN":
     231        crypto = new StringBuilder();
     232        crypto.append(line).append("\n");
     233        break;
     234      case "-----END":
     235        crypto.append(line).append("\n");
     236        String cryptoString = crypto.toString();
     237        crypto = null;
     238        if (nextCrypto.equals("dir-signing-key") &&
     239            this.dirSigningKey == null) {
     240          this.dirSigningKey = cryptoString;
     241        } else {
     242          throw new DescriptorParseException("Unrecognized crypto "
     243              + "block in v1 directory.");
     244        }
     245        nextCrypto = "";
     246        break;
    230247      default:
    231         if (line.startsWith("-----BEGIN")) {
    232           crypto = new StringBuilder();
    233           crypto.append(line).append("\n");
    234         } else if (line.startsWith("-----END")) {
    235           crypto.append(line).append("\n");
    236           String cryptoString = crypto.toString();
    237           crypto = null;
    238           if (nextCrypto.equals("dir-signing-key") &&
    239               this.dirSigningKey == null) {
    240             this.dirSigningKey = cryptoString;
    241           } else {
    242             throw new DescriptorParseException("Unrecognized crypto "
    243                 + "block in v1 directory.");
    244           }
    245           nextCrypto = "";
    246         } else if (crypto != null) {
     248        if (crypto != null) {
    247249          crypto.append(line).append("\n");
    248250        } else {
    249251          if (this.failUnrecognizedDescriptorLines) {
    public class RelayDirectoryImpl extends DescriptorImpl 
    313315          line.substring("opt ".length()) : line;
    314316      String[] partsNoOpt = lineNoOpt.split("[ \t]+");
    315317      String keyword = partsNoOpt[0];
    316       if (keyword.equals("directory-signature")) {
     318      switch(keyword){
     319      case "directory-signature":
    317320        this.parseDirectorySignatureLine(line, lineNoOpt, partsNoOpt);
    318321        nextCrypto = "directory-signature";
    319       } else if (line.startsWith("-----BEGIN")) {
     322        break;
     323      case "-----BEGIN":
    320324        crypto = new StringBuilder();
    321325        crypto.append(line).append("\n");
    322       } else if (line.startsWith("-----END")) {
     326        break;
     327      case "-----END":
    323328        crypto.append(line).append("\n");
    324329        String cryptoString = crypto.toString();
    325330        crypto = null;
    public class RelayDirectoryImpl extends DescriptorImpl 
    330335              + "block in v2 network status.");
    331336        }
    332337        nextCrypto = "";
    333       } else if (crypto != null) {
    334         crypto.append(line).append("\n");
    335       } else if (this.failUnrecognizedDescriptorLines) {
    336         throw new DescriptorParseException("Unrecognized line '" + line
    337             + "' in v2 network status.");
    338       } else {
    339         if (this.unrecognizedLines == null) {
    340           this.unrecognizedLines = new ArrayList<>();
     338        break;
     339      default:
     340        if (crypto != null) {
     341          crypto.append(line).append("\n");
     342        } else if (this.failUnrecognizedDescriptorLines) {
     343          throw new DescriptorParseException("Unrecognized line '" + line
     344              + "' in v2 network status.");
     345        } else {
     346          if (this.unrecognizedLines == null) {
     347            this.unrecognizedLines = new ArrayList<>();
     348          }
     349          this.unrecognizedLines.add(line);
    341350        }
    342         this.unrecognizedLines.add(line);
    343351      }
    344352    }
    345353  }
  • src/org/torproject/descriptor/impl/RelayNetworkStatusImpl.java

    diff --git a/src/org/torproject/descriptor/impl/RelayNetworkStatusImpl.java b/src/org/torproject/descriptor/impl/RelayNetworkStatusImpl.java
    index 7788040..01f77bc 100644
    a b public class RelayNetworkStatusImpl extends NetworkStatusImpl 
    126126      case "dir-options":
    127127        this.parseDirOptionsLine(line, parts);
    128128        break;
     129      case "-----BEGIN":
     130        crypto = new StringBuilder();
     131        crypto.append(line).append("\n");
     132        break;
     133      case "-----END":
     134        crypto.append(line).append("\n");
     135        String cryptoString = crypto.toString();
     136        crypto = null;
     137        if (nextCrypto.equals("dir-signing-key")) {
     138          this.dirSigningKey = cryptoString;
     139        } else {
     140          throw new DescriptorParseException("Unrecognized crypto "
     141              + "block in v2 network status.");
     142        }
     143        nextCrypto = "";
    129144      default:
    130         if (line.startsWith("-----BEGIN")) {
    131           crypto = new StringBuilder();
    132           crypto.append(line).append("\n");
    133         } else if (line.startsWith("-----END")) {
    134           crypto.append(line).append("\n");
    135           String cryptoString = crypto.toString();
    136           crypto = null;
    137           if (nextCrypto.equals("dir-signing-key")) {
    138             this.dirSigningKey = cryptoString;
    139           } else {
    140             throw new DescriptorParseException("Unrecognized crypto "
    141                 + "block in v2 network status.");
    142           }
    143           nextCrypto = "";
    144         } else if (crypto != null) {
     145        if (crypto != null) {
    145146          crypto.append(line).append("\n");
    146147        } else if (this.failUnrecognizedDescriptorLines) {
    147148          throw new DescriptorParseException("Unrecognized line '" + line
    public class RelayNetworkStatusImpl extends NetworkStatusImpl 
    172173      String line = s.next();
    173174      String[] parts = line.split("[ \t]+");
    174175      String keyword = parts[0];
    175       if (keyword.equals("directory-signature")) {
     176      switch(keyword){
     177      case "directory-signature":
    176178        this.parseDirectorySignatureLine(line, parts);
    177179        nextCrypto = "directory-signature";
    178       } else if (line.startsWith("-----BEGIN")) {
     180        break;
     181      case "-----BEGIN":
    179182        crypto = new StringBuilder();
    180183        crypto.append(line).append("\n");
    181       } else if (line.startsWith("-----END")) {
     184        break;
     185      case "-----END":
    182186        crypto.append(line).append("\n");
    183187        String cryptoString = crypto.toString();
    184188        crypto = null;
    public class RelayNetworkStatusImpl extends NetworkStatusImpl 
    189193              + "block in v2 network status.");
    190194        }
    191195        nextCrypto = "";
    192       } else if (crypto != null) {
    193         crypto.append(line).append("\n");
    194       } else if (this.failUnrecognizedDescriptorLines) {
    195         throw new DescriptorParseException("Unrecognized line '" + line
    196             + "' in v2 network status.");
    197       } else {
    198         if (this.unrecognizedLines == null) {
    199           this.unrecognizedLines = new ArrayList<>();
     196        break;
     197      default:
     198        if (crypto != null) {
     199          crypto.append(line).append("\n");
     200        } else if (this.failUnrecognizedDescriptorLines) {
     201          throw new DescriptorParseException("Unrecognized line '" + line
     202              + "' in v2 network status.");
     203        } else {
     204          if (this.unrecognizedLines == null) {
     205            this.unrecognizedLines = new ArrayList<>();
     206          }
     207          this.unrecognizedLines.add(line);
    200208        }
    201         this.unrecognizedLines.add(line);
    202209      }
    203210    }
    204211  }
  • src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java

    diff --git a/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java b/src/org/torproject/descriptor/impl/RelayNetworkStatusVoteImpl.java
    index d74ef65..c16a9f9 100644
    a b public class RelayNetworkStatusVoteImpl extends NetworkStatusImpl 
    148148      case "dir-key-crosscert":
    149149      case "dir-key-certification":
    150150        break;
     151      case "-----BEGIN":
     152        skipCrypto = true;
     153        break;
     154      case "-----END":
     155        skipCrypto = false;
     156        break;
    151157      default:
    152         if (line.startsWith("-----BEGIN")) {
    153           skipCrypto = true;
    154         } else if (line.startsWith("-----END")) {
    155           skipCrypto = false;
    156         } else if (!skipCrypto) {
     158        if (!skipCrypto) {
    157159          if (this.failUnrecognizedDescriptorLines) {
    158160            throw new DescriptorParseException("Unrecognized line '"
    159161                + line + "' in vote.");
    public class RelayNetworkStatusVoteImpl extends NetworkStatusImpl 
    313315        case "ignoring-advertised-bws":
    314316          this.ignoringAdvertisedBws = Integer.parseInt(e.getValue());
    315317          break;
     318        default:
     319          // empty
    316320        }
    317321      }
    318322    } catch (NumberFormatException ex) {
  • src/org/torproject/descriptor/impl/ServerDescriptorImpl.java

    diff --git a/src/org/torproject/descriptor/impl/ServerDescriptorImpl.java b/src/org/torproject/descriptor/impl/ServerDescriptorImpl.java
    index 84ad2a1..73bd34e 100644
    a b public abstract class ServerDescriptorImpl extends DescriptorImpl 
    171171        this.parseNtorOnionKeyCrosscert(line, lineNoOpt, partsNoOpt);
    172172        nextCrypto = "ntor-onion-key-crosscert";
    173173        break;
    174       default:
    175         if (line.startsWith("-----BEGIN")) {
    176           cryptoLines = new ArrayList<>();
    177           cryptoLines.add(line);
    178         } else if (line.startsWith("-----END")) {
    179           cryptoLines.add(line);
    180           StringBuilder sb = new StringBuilder();
    181           for (String cryptoLine : cryptoLines) {
    182             sb.append("\n").append(cryptoLine);
    183           }
    184           String cryptoString = sb.toString().substring(1);
    185           switch (nextCrypto) {
    186           case "onion-key":
    187             this.onionKey = cryptoString;
    188             break;
    189           case "signing-key":
    190             this.signingKey = cryptoString;
    191             break;
    192           case "router-signature":
    193             this.routerSignature = cryptoString;
    194             break;
    195           case "identity-ed25519":
    196             this.identityEd25519 = cryptoString;
    197             this.parseIdentityEd25519CryptoBlock(cryptoString);
    198             break;
    199           case "onion-key-crosscert":
    200             this.onionKeyCrosscert = cryptoString;
    201             break;
    202           case "ntor-onion-key-crosscert":
    203             this.ntorOnionKeyCrosscert = cryptoString;
    204             break;
    205           default:
    206             if (this.failUnrecognizedDescriptorLines) {
    207               throw new DescriptorParseException("Unrecognized crypto "
    208                   + "block '" + cryptoString + "' in server descriptor.");
    209             } else {
    210               if (this.unrecognizedLines == null) {
    211                 this.unrecognizedLines = new ArrayList<>();
    212               }
    213               this.unrecognizedLines.addAll(cryptoLines);
     174      case "-----BEGIN":
     175        cryptoLines = new ArrayList<>();
     176        cryptoLines.add(line);
     177        break;
     178      case "-----END":
     179        cryptoLines.add(line);
     180        StringBuilder sb = new StringBuilder();
     181        for (String cryptoLine : cryptoLines) {
     182          sb.append("\n").append(cryptoLine);
     183        }
     184        String cryptoString = sb.toString().substring(1);
     185        switch (nextCrypto) {
     186        case "onion-key":
     187          this.onionKey = cryptoString;
     188          break;
     189        case "signing-key":
     190          this.signingKey = cryptoString;
     191          break;
     192        case "router-signature":
     193          this.routerSignature = cryptoString;
     194          break;
     195        case "identity-ed25519":
     196          this.identityEd25519 = cryptoString;
     197          this.parseIdentityEd25519CryptoBlock(cryptoString);
     198          break;
     199        case "onion-key-crosscert":
     200          this.onionKeyCrosscert = cryptoString;
     201          break;
     202        case "ntor-onion-key-crosscert":
     203          this.ntorOnionKeyCrosscert = cryptoString;
     204          break;
     205        default:
     206          if (this.failUnrecognizedDescriptorLines) {
     207            throw new DescriptorParseException("Unrecognized crypto "
     208                + "block '" + cryptoString + "' in server descriptor.");
     209          } else {
     210            if (this.unrecognizedLines == null) {
     211              this.unrecognizedLines = new ArrayList<>();
    214212            }
     213            this.unrecognizedLines.addAll(cryptoLines);
    215214          }
    216           cryptoLines = null;
    217           nextCrypto = "";
    218         } else if (cryptoLines != null) {
     215        }
     216        cryptoLines = null;
     217        nextCrypto = "";
     218        break;
     219      default:
     220        if (cryptoLines != null) {
    219221          cryptoLines.add(line);
    220222        } else {
    221223          ParseHelper.parseKeyword(line, partsNoOpt[0]);
    public abstract class ServerDescriptorImpl extends DescriptorImpl 
    317319    if (partsNoOpt.length != 2) {
    318320      throw new DescriptorParseException("Illegal line '" + line + "'.");
    319321    }
    320     if (partsNoOpt[1].equals("1")) {
    321       this.hibernating = true;
    322     } else if (partsNoOpt[1].equals("0")) {
    323       this.hibernating = false;
    324     } else {
    325       throw new DescriptorParseException("Illegal line '" + line + "'.");
    326     }
     322    this.hibernating = ParseHelper.parseBoolean(partsNoOpt[1], line);
    327323  }
    328324
    329325  private void parseUptimeLine(String line, String lineNoOpt,
    public abstract class ServerDescriptorImpl extends DescriptorImpl 
    438434    if (partsNoOpt.length != 2) {
    439435      throw new DescriptorParseException("Illegal line '" + line + "'.");
    440436    }
    441     if (partsNoOpt[1].equals("1")) {
    442       this.usesEnhancedDnsLogic = true;
    443     } else if (partsNoOpt[1].equals("0")) {
    444       this.usesEnhancedDnsLogic = false;
    445     } else {
    446       throw new DescriptorParseException("Illegal line '" + line + "'.");
    447     }
     437    this.usesEnhancedDnsLogic = ParseHelper.parseBoolean(partsNoOpt[1], line);
    448438  }
    449439
    450440  private void parseCachesExtraInfoLine(String line, String lineNoOpt,
    public abstract class ServerDescriptorImpl extends DescriptorImpl 
    490480      String[] partsNoOpt) throws DescriptorParseException {
    491481    int linkIndex = -1, circuitIndex = -1;
    492482    for (int i = 1; i < partsNoOpt.length; i++) {
    493       if (partsNoOpt[i].equals("Link")) {
     483      switch(partsNoOpt[i]){
     484      case "Link":
    494485        linkIndex = i;
    495       } else if (partsNoOpt[i].equals("Circuit")) {
     486        break;
     487      case "Circuit":
    496488        circuitIndex = i;
     489        break;
     490      default:
     491        // empty
    497492      }
    498493    }
    499494    if (linkIndex < 0 || circuitIndex < 0 || circuitIndex < linkIndex) {
    public abstract class ServerDescriptorImpl extends DescriptorImpl 
    555550    boolean isValid = true;
    556551    if (partsNoOpt.length != 3) {
    557552      isValid = false;
    558     } else if (!partsNoOpt[1].equals("accept") &&
    559         !partsNoOpt[1].equals("reject")) {
    560       isValid = false;
    561553    } else {
    562       this.ipv6DefaultPolicy = partsNoOpt[1];
    563       this.ipv6PortList = partsNoOpt[2];
    564       String[] ports = partsNoOpt[2].split(",", -1);
    565       for (int i = 0; i < ports.length; i++) {
    566         if (ports[i].length() < 1) {
    567           isValid = false;
     554        switch(partsNoOpt[1]){
     555        case "accept":
     556        case "reject":
     557          this.ipv6DefaultPolicy = partsNoOpt[1];
     558          this.ipv6PortList = partsNoOpt[2];
     559          String[] ports = partsNoOpt[2].split(",", -1);
     560          for (int i = 0; i < ports.length; i++) {
     561            if (ports[i].length() < 1) {
     562              isValid = false;
     563              break;
     564            }
     565          }
    568566          break;
     567        default:
     568          isValid = false;
    569569        }
    570       }
    571570    }
    572571    if (!isValid) {
    573572      throw new DescriptorParseException("Illegal line '" + line + "'.");