Checkpoint

svn path=/scripts/rpki/left_right.py; revision=752

3 files changed, 83 insertions, 258 deletions

diff --git a/scripts/rpki/left_right.py b/scripts/rpki/left_right.py
index 7435a1d5..edc74fd0 100644
--- a/scripts/rpki/left_right.py
+++ b/scripts/rpki/left_right.py
@@ -1,241 +1,64 @@
 # $Id$
 
-import base64, xml.sax, resource_set
-
-def snarf(obj, attrs, key, func=None):
-  """
-  Utility function to consolidate the steps needed to extract a field
-  from the SAX XML parse and insert it as an object attribute of the
-  same name.
-  """
-
-  try:
-    val = attrs.getValue(key).encode("ascii")
-    if func:
-      val = func(val)
-  except KeyError:
-    val = None
-  setattr(obj, key, val)
-
-class msg(object):
-  """
-  Base type for Up-Down protocol PDU.
-  """
+import base64, sax_utils, resource_set
+
+class msg(list):
+  """
+  Left-right PDU.
+  """
+
+  spec_uri = "http://www.hactrn.net/uris/rpki/left-right-spec/"
+  version = 1
+
+  dispatch = {
+    ("control-request",  "biz-signing-context")   : bsc_q,
+    ("control-request",  "child")                 : child_q,
+    ("control-request",  "parent")                : parent_q,
+    ("control-request",  "repository")            : repository_q,
+    ("control-request",  "route-origin")          : route_origin_q,
+    ("control-request",  "self")                  : self_q,
+    ("control-response", "biz-signing-context")   : bsc_r,
+    ("control-response", "child")                 : child_r,
+    ("control-response", "parent")                : parent_r,
+    ("control-response", "repository")            : repository_r,
+    ("control-response", "route-origin")          : route_origin_r,
+    ("control-response", "self")                  : self_r,
+    ("data-request",     "list-resources")        : list_resources_q,
+    ("data-response",    "list-resources")        : list_resources_r,
+    ("error",            "report-error")          : report_error_q
+ }
 
   def __str__(self):
     return ('\
-<?xml version="1.0" encoding="UTF-8"?>\n\
-<message xmlns="http://www.apnic.net/specs/rescerts/up-down/"\n\
-         version="1"\n\
-         sender="%s"\n\
-         recipient="%s"\n\
+<?xml version="1.0" encoding="US-ASCII" ?>\n\
+<msg xmlns="%s"\n\
+         version="%d"\n\
          type="%s">\n' \
-            % (self.sender, self.recipient, self.type)
-            ) + self.toXML() + "</message>\n"
-
-  def toXML(self):
-    return ""
-
-  def startElement(self, name, attrs):
-    pass
+            % (self.spec_uri, self.version, self.type)
+            ) + "".join(map(str,self)) + "</msg>\n"
 
   def endElement(self, name, text):
     pass
 
-class cert(object):
-  """
-  Up-Down protocol representation of an issued certificate.
-  """
-
-  def __init__(self, attrs):
-    snarf(self, attrs, "cert_url")
-    snarf(self, attrs, "req_resource_set_as",   resource_set.resource_set_as)
-    snarf(self, attrs, "req_resource_set_ipv4", resource_set.resource_set_ipv4)
-    snarf(self, attrs, "req_resource_set_ipv6", resource_set.resource_set_ipv6)
-
-  def __str__(self):
-    xml = ('    <certificate cert_url="%s"' % (self.cert_url))
-    if self.req_resource_set_as:
-      xml += ('\n                 req_resource_set_as="%s"' % self.req_resource_set_as)
-    if self.req_resource_set_ipv4:
-      xml += ('\n                 req_resource_set_ipv4="%s"' % self.req_resource_set_ipv4)
-    if self.req_resource_set_ipv6:
-      xml += ('\n                 req_resource_set_ipv6="%s"' % self.req_resource_set_ipv6)
-    xml += ">" + base64.b64encode(self.cert) + "</certificate>\n"
-    return xml
-
-class klass(object):
-  """
-  Up-Down protocol representation of a resource class.
-  """
-
-  def __init__(self, attrs):
-    snarf(self, attrs, "class_name")
-    snarf(self, attrs, "cert_url")
-    snarf(self, attrs, "resource_set_as",   resource_set.resource_set_as)
-    snarf(self, attrs, "resource_set_ipv4", resource_set.resource_set_ipv4)
-    snarf(self, attrs, "resource_set_ipv6", resource_set.resource_set_ipv6)
-    snarf(self, attrs, "suggested_sia_head")
-    self.certs = []
-
-  def __str__(self):
-    xml = ('\
-  <class class_name="%s"\n\
-         cert_url="%s"\n\
-         resource_set_as="%s"\n\
-         resource_set_ipv4="%s"\n\
-         resource_set_ipv6="%s"' \
-           % (self.class_name, self.cert_url,
-              self.resource_set_as, self.resource_set_ipv4, self.resource_set_ipv6))
-    if self.suggested_sia_head:
-      xml += ('\n         suggested_sia_head="%s"' % (self.suggested_sia_head))
-    xml += ">\n"
-    for cert in self.certs:
-      xml += str(cert)
-    xml += "    <issuer>" + base64.b64encode(self.issuer) + "</issuer>\n  </class>\n"
-    return xml
-
-class list(msg):
-  """
-  Up-Down protocol "list" PDU.
-  """
-  pass
-
-class list_response(msg):
-  """
-  Up-Down protocol "list_response" PDU.
-  """
-
-  def __init__(self):
-    self.klasses = []
-
   def startElement(self, name, attrs):
-    if name == "class":
-      self.klasses.append(klass(attrs))
-    elif name == "certificate":
-      self.klasses[-1].certs.append(cert(attrs))
-
-  def endElement(self, name, text):
-    if name == "certificate":
-      self.klasses[-1].certs[-1].cert = base64.b64decode(text)
-    elif name == "issuer":
-      self.klasses[-1].issuer = base64.b64decode(text)
-
-  def toXML(self):
-    return "".join(map(str, self.klasses))
-
-class issue(msg):
-  """
-  Up-Down protocol "issue" PDU.
-  """
-
-  def startElement(self, name, attrs):
-    assert name == "request"
-    snarf(self, attrs, "class_name")
-    snarf(self, attrs, "req_resource_set_as",   resource_set.resource_set_as)
-    snarf(self, attrs, "req_resource_set_ipv4", resource_set.resource_set_ipv4)
-    snarf(self, attrs, "req_resource_set_ipv6", resource_set.resource_set_ipv6)
-
-  def endElement(self, name, text):
-    assert name == "request"
-    self.pkcs10 = base64.b64decode(text)
-
-  def toXML(self):
-    xml = ('  <request class_name="%s"' % self.class_name)
-    if self.req_resource_set_as:
-      xml += ('\n           req_resource_set_as="%s"' % self.req_resource_set_as)
-    if self.req_resource_set_ipv4:
-      xml += ('\n           req_resource_set_ipv4="%s"' % self.req_resource_set_ipv4)
-    if self.req_resource_set_ipv6:
-      xml += ('\n           req_resource_set_ipv6="%s"' % self.req_resource_set_ipv6)
-    return xml + ">" + base64.b64encode(self.pkcs10) + "</request>\n"
-
-class issue_response(list_response):
-  """
-  Up-Down protocol "issue_response" PDU.
-  """
-
-  def toXML(self):
-    assert len(self.klasses) == 1
-    return list_response.toXML(self)
-
-class revoke(msg):
-  """
-  Up-Down protocol "revoke" PDU.
-  """
-
-  def startElement(self, name, attrs):
-    snarf(self, attrs, "class_name")
-    snarf(self, attrs, "ski")
-
-  def toXML(self):
-    return ('  <key class_name="%s" ski="%s" />\n' % (self.class_name, self.ski))
-
-class revoke_response(revoke):
-  """
-  Up-Down protocol "revoke_response" PDU.
-  """
-  pass
-
-class error_response(msg):
-  """
-  Up-Down protocol "error_response" PDU.
-  """
-
-  def toXML(self):
-    return '  <status>%d</status>\n' % self.status
-
-  def endElement(self, name, text):
-    if name == "status":
-      self.status = int(text)
-    elif name == "last_message_processed":
-      self.last_message_processed = text
-    elif name == "description":
-      self.description = text
+    if name == "msg":
+      sax_utils.snarf(self, attrs, "version", int)
+      sax_utils.snarf(self, attrs, "type")
+      assert self.version == 1
+    else:
+      func = self.dispatch(self.type, name)
+      # hmm, proabbly want to look at action attribute but that's a
+      # layering violation, so maybe do it in the next handler down?
 
-class sax_handler(xml.sax.handler.ContentHandler):
+class sax_handler(sax_utils.handler):
   """
-  SAX handler for Up-Down protocol.  Builds message PDU then
-  dispatches to that class's handler for nested data.
+  SAX handler for Left-Right protocol.
   """
 
-  def __init__(self):
-    self.text = ""
-    self.obj = None
-
-  def startElementNS(self, name, qname, attrs):
-    return self.startElement(name[1], attrs)
-
-  def endElementNS(self, name, qname):
-    return self.endElement(name[1])
-
   def startElement(self, name, attrs):
-    if name == "message":
-      assert int(attrs.getValue("version")) == 1
-      if self.obj == None:
-        self.obj = {
-          "list"                  : list(),
-          "list_response"         : list_response(),
-          "issue"                 : issue(),
-          "issue_response"        : issue_response(),
-          "revoke"                : revoke(),
-          "revoke_response"       : revoke_response(),
-          "error_response"        : error_response()
-        }[attrs.getValue("type").encode("ascii")]
-      assert self.obj
-      snarf(self.obj, attrs, "sender")
-      snarf(self.obj, attrs, "recipient")
-      snarf(self.obj, attrs, "type")
-
-    else:
-      assert self.obj
-      self.obj.startElement(name, attrs)
-
-  def characters(self, content):
-    self.text += content
+    if name == "msg":
+      self.set_obj(msg())
+    self.obj.startElement(name, attrs)
 
   def endElement(self, name):
-    assert self.obj
-    if name != "message":
-      self.obj.endElement(name, self.text)
-    self.text = ""
+    self.obj.endElement(name, self.get_text())
diff --git a/scripts/rpki/sax_utils.py b/scripts/rpki/sax_utils.py
index b4259d2a..6497699a 100644
--- a/scripts/rpki/sax_utils.py
+++ b/scripts/rpki/sax_utils.py
@@ -36,3 +36,12 @@ class handler(xml.sax.handler.ContentHandler):
 
   def characters(self, content):
     self.text += content
+
+  def get_text(self):
+    val = self.text
+    self.text = ""
+    return val
+
+  def set_obj(self, obj):
+    assert self.obj is None
+    self.obj = obj
diff --git a/scripts/rpki/up_down.py b/scripts/rpki/up_down.py
index 8ce61e34..8d900c42 100644
--- a/scripts/rpki/up_down.py
+++ b/scripts/rpki/up_down.py
@@ -2,9 +2,9 @@
 
 import base64, sax_utils, resource_set
 
-class msg(object):
+class msg_pdu(object):
   """
-  Base type for Up-Down protocol PDU.
+  Base type for all Up-Down PDUs.
   """
 
   def __str__(self):
@@ -27,7 +27,7 @@ class msg(object):
   def endElement(self, name, text):
     pass
 
-class cert(object):
+class cert_elt(object):
   """
   Up-Down protocol representation of an issued certificate.
   """
@@ -49,7 +49,7 @@ class cert(object):
     xml += ">" + base64.b64encode(self.cert) + "</certificate>\n"
     return xml
 
-class klass(object):
+class class_elt(object):
   """
   Up-Down protocol representation of a resource class.
   """
@@ -80,36 +80,36 @@ class klass(object):
     xml += "    <issuer>" + base64.b64encode(self.issuer) + "</issuer>\n  </class>\n"
     return xml
 
-class list(msg):
+class list_pdu(msg_pdu):
   """
   Up-Down protocol "list" PDU.
   """
   pass
 
-class list_response(msg):
+class list_response_pdu(msg_pdu):
   """
   Up-Down protocol "list_response" PDU.
   """
 
   def __init__(self):
-    self.klasses = []
+    self.classes = []
 
   def startElement(self, name, attrs):
     if name == "class":
-      self.klasses.append(klass(attrs))
+      self.classes.append(class_elt(attrs))
     elif name == "certificate":
-      self.klasses[-1].certs.append(cert(attrs))
+      self.classes[-1].certs.append(cert_elt(attrs))
 
   def endElement(self, name, text):
     if name == "certificate":
-      self.klasses[-1].certs[-1].cert = base64.b64decode(text)
+      self.classes[-1].certs[-1].cert = base64.b64decode(text)
     elif name == "issuer":
-      self.klasses[-1].issuer = base64.b64decode(text)
+      self.classes[-1].issuer = base64.b64decode(text)
 
   def toXML(self):
-    return "".join(map(str, self.klasses))
+    return "".join(map(str, self.classes))
 
-class issue(msg):
+class issue_pdu(msg_pdu):
   """
   Up-Down protocol "issue" PDU.
   """
@@ -135,16 +135,16 @@ class issue(msg):
       xml += ('\n           req_resource_set_ipv6="%s"' % self.req_resource_set_ipv6)
     return xml + ">" + base64.b64encode(self.pkcs10) + "</request>\n"
 
-class issue_response(list_response):
+class issue_response_pdu(list_response_pdu):
   """
   Up-Down protocol "issue_response" PDU.
   """
 
   def toXML(self):
-    assert len(self.klasses) == 1
-    return list_response.toXML(self)
+    assert len(self.classes) == 1
+    return list_response_pdu.toXML(self)
 
-class revoke(msg):
+class revoke_pdu(msg_pdu):
   """
   Up-Down protocol "revoke" PDU.
   """
@@ -156,13 +156,13 @@ class revoke(msg):
   def toXML(self):
     return ('  <key class_name="%s" ski="%s" />\n' % (self.class_name, self.ski))
 
-class revoke_response(revoke):
+class revoke_response_pdu(revoke_pdu):
   """
   Up-Down protocol "revoke_response" PDU.
   """
   pass
 
-class error_response(msg):
+class error_response_pdu(msg_pdu):
   """
   Up-Down protocol "error_response" PDU.
   """
@@ -187,27 +187,20 @@ class sax_handler(sax_utils.handler):
   def startElement(self, name, attrs):
     if name == "message":
       assert int(attrs.getValue("version")) == 1
-      if self.obj == None:
-        self.obj = {
-          "list"                  : list(),
-          "list_response"         : list_response(),
-          "issue"                 : issue(),
-          "issue_response"        : issue_response(),
-          "revoke"                : revoke(),
-          "revoke_response"       : revoke_response(),
-          "error_response"        : error_response()
-        }[attrs.getValue("type").encode("ascii")]
-      assert self.obj
+      self.set_obj({ "list"            : list_pdu(),
+                     "list_response"   : list_response_pdu(),
+                     "issue"           : issue_pdu(),
+                     "issue_response"  : issue_response_pdu(),
+                     "revoke"          : revoke_pdu(),
+                     "revoke_response" : revoke_response_pdu(),
+                     "error_response"  : error_response_pdu()
+                   }[attrs.getValue("type").encode("ascii")])
       sax_utils.snarf(self.obj, attrs, "sender")
       sax_utils.snarf(self.obj, attrs, "recipient")
       sax_utils.snarf(self.obj, attrs, "type")
-
     else:
-      assert self.obj
       self.obj.startElement(name, attrs)
 
   def endElement(self, name):
-    assert self.obj
     if name != "message":
-      self.obj.endElement(name, self.text)
-    self.text = ""
+      self.obj.endElement(name, self.get_text())