Attachment #2139 for bug #2170

View | Details | Raw Unified | Return to bug 2170
Collapse All | Expand All




// Public methods

AnimationInterface::AnimationInterface (const std::string fn)
  :
#ifdef HAVE_LIBXML2
  m_xmlWriter(0),
  m_routingXmlWriter(0),
#else
  m_f (0),
  m_routingF (0),
#endif
  m_mobilityPollInterval (Seconds (0.25)),
  m_outputFileName (fn),
  gAnimUid (0),
  m_writeCallback (0),
  m_started (false),
  m_enablePacketMetadata (false),
  m_startTime (Seconds (0)),
  m_stopTime (Seconds (3600 * 1000)),
  m_maxPktsPerFile (MAX_PKTS_PER_TRACE_FILE),
  m_originalFileName (fn),
  m_routingStopTime (Seconds (0)),
  m_routingFileName (""),
  m_routingPollInterval (Seconds (5)),
  m_trackPackets (true)
{
  initialized = true;
  StartAnimation ();

  m_started = false;
  NS_LOG_INFO ("Stopping Animation");
  ResetAnimWriteCallback ();
#ifdef HAVE_LIBXML2
  if (m_xmlWriter)
    {
      int rc = xmlTextWriterEndDocument (m_xmlWriter);
      if (rc < 0)
        {
          NS_FATAL_ERROR ("Error at xmlTextWriterEndDocument\n");
        }
      xmlFreeTextWriter (m_xmlWriter);
      m_xmlWriter = 0;
  	}
  if (onlyAnimation)
	{
	  return;
	}
  if (m_routingXmlWriter)
    {
      int rc = xmlTextWriterEndDocument (m_routingXmlWriter);
      if (rc < 0)
        {
          NS_FATAL_ERROR ("Error at xmlTextWriterEndDocument when ending routing xml file\n");
        }
      xmlFreeTextWriter (m_routingXmlWriter);
      m_routingXmlWriter = 0;
    }
#else
  if (m_f) 
    {
      // Terminate the anim element

      std::fclose (m_routingF);
      m_routingF = 0;
    }
#endif
}

void 

void 
AnimationInterface::SetOutputFile (const std::string& fn, bool routing)
{
#ifdef HAVE_LIBXML2
  if (!routing && m_xmlWriter)
    {
      return;
    }
  if (routing && m_routingXmlWriter)
    {
      NS_FATAL_ERROR ("SetRoutingOutputFile already used once");
      return;
    }
  NS_LOG_INFO ("Creating new trace file:" << fn.c_str ());

  xmlTextWriterPtr *writer = (routing ? &m_routingXmlWriter : &m_xmlWriter);

  /* Create a new XmlWriter for this filename, with no compression. */
  *writer = xmlNewTextWriterFilename (fn.c_str (), 0);
  if (!*writer)
    {
      NS_FATAL_ERROR ("Error creating the xml writer");
      return;
    }
  /* Make the writer use automatic indentation */
  xmlTextWriterSetIndent (*writer, 1);

  /* Start the document with the xml default for the version,
   * UTF-8 encoding and the default for the standalone
   * declaration. */
  int rc = xmlTextWriterStartDocument (*writer, 0, "utf-8", 0);
  if (rc < 0)
    {
      NS_FATAL_ERROR ("Error at xmlTextWriterStartDocument\n");
      return;
    }
  if (routing)
    {
      m_routingFileName = fn;
    }
  else
    {
      m_outputFileName = fn;
    }
  return;

#else
  if (!routing && m_f)
    {
      return;

      m_outputFileName = fn;
    }
  return;
#endif
}

void 



// XML 
#ifdef HAVE_LIBXML2
AnimationInterface::AnimXmlElement::AnimXmlElement(xmlTextWriterPtr writer, std::string tagName):
  m_tagName (tagName),
  m_writer (writer),
	m_closed(false)
{
  if (!m_writer)
    {
      NS_FATAL_ERROR ("Null XML writer");
      return;
    }
  int rc = xmlTextWriterStartElement (m_writer, BAD_CAST m_tagName.c_str ());
  if (rc < 0)
    {
      NS_FATAL_ERROR ("Error at xmlTextWriterStartElement (rp)");
    }
}

template <typename T>
void
AnimationInterface::AnimXmlElement::AddAttribute (std::string attribute, T value)
{
  if (!m_writer)
    {
      NS_FATAL_ERROR ("Null XML writer");
      return;
    }
  if (m_closed)
    {
      NS_FATAL_ERROR ("XML element already closed");
      return;
    }
  std::ostringstream oss;
  oss << std::setprecision (10);
  oss << value;
  int rc = xmlTextWriterWriteAttribute(m_writer,
                                       BAD_CAST attribute.c_str(),
                                   	 	 BAD_CAST oss.str().c_str());
  if (rc < 0)
    {
      NS_FATAL_ERROR ("Error at xmlTextWriterWriteAttribute");
      return;
    }
}

template <typename T>
void AnimationInterface::AnimXmlElement::AddAttribute (xmlTextWriterPtr writer, std::string attribute, T value)
{
	if (!writer)
    {
      NS_FATAL_ERROR ("Null XML writer");
      return;
    }
	std::ostringstream oss;
	oss << std::setprecision (10);
	oss << value;
	int rc = xmlTextWriterWriteAttribute(writer,
	                                     BAD_CAST attribute.c_str(),
																			 BAD_CAST oss.str().c_str());
	if (rc < 0)
	  {
      NS_FATAL_ERROR ("Error at xmlTextWriterWriteAttribute");
      return;
	  }
}

void
AnimationInterface::AnimXmlElement::CloseElement ()
{
  if (!m_writer)
    {
      NS_FATAL_ERROR ("Null XML writer");
      return;
    }
  if (m_closed)
    {
      NS_FATAL_ERROR ("XML element already closed");
      return;
    }
  m_closed = true;
  int rc = xmlTextWriterEndElement(m_writer);
	if (rc < 0)
	  {
      NS_FATAL_ERROR ("Error at xmlTextWriterEndElement");
      return;
	  }
}
#else
AnimationInterface::AnimXmlElement::AnimXmlElement (std::string tagName, bool emptyElement):
                                m_tagName (tagName),
                                m_emptyElement (emptyElement)

  std::ostringstream oss;
  oss << std::setprecision (10);
  oss << value;
  const char *attribute_char = oss.str ().c_str ();
  m_elementString += attribute.c_str ();
  m_elementString += "=\"";
  while (*attribute_char)
  {
   switch(*attribute_char)
   {
     case '&':
       m_elementString += "&amp;";
       break;
     case '\"':
       m_elementString += "&quot;";
       break;
     case '\'':
       m_elementString += "&apos;";
       break;
     case '<':
       m_elementString += "&lt;";
       break;
     case '>':
       m_elementString += "&gt;";
       break;
     default:
       m_elementString += *attribute_char;
       break;
   }
   attribute_char++;
  }
  m_elementString += "\" ";
}

void

{
  return m_elementString;
}
#endif

void 
AnimationInterface::WriteXmlAnim (bool routing)
{
#ifdef HAVE_LIBXML2
  int rc;
  rc = xmlTextWriterStartElement (m_xmlWriter, BAD_CAST "anim");
  if (rc < 0)
    {
      NS_FATAL_ERROR ("Error at xmlTextWriterStartElement (anim)");
		  return;
    }
  AnimXmlElement::AddAttribute (m_xmlWriter, "ver", GetNetAnimVersion ());
  if (!routing)
    {
      AnimXmlElement::AddAttribute (m_xmlWriter, "filetype", "animation");
    }
	else
    {
      AnimXmlElement::AddAttribute (m_xmlWriter, "filetype", "routing");
    }
#else
  AnimXmlElement element ("anim");
  element.AddAttribute ("ver", GetNetAnimVersion ());
  FILE * f = m_f;

    }
  element.Close ();
  WriteN (element.GetElementString (), f);
#endif
}

#ifndef HAVE_LIBXML2
void 
AnimationInterface::WriteXmlClose (std::string name, bool routing) 
{

      WriteN (closeString, m_routingF);
    }
}
#endif

void 
AnimationInterface::WriteXmlNode (uint32_t id, uint32_t sysId, double locX, double locY)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "node");
#else
  AnimXmlElement element ("node");
#endif
  element.AddAttribute ("id", id);
  element.AddAttribute ("sysId", sysId);
  element.AddAttribute ("locX", locX);
  element.AddAttribute ("locY", locY);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlUpdateLink (uint32_t fromId, uint32_t toId, std::string linkDescription)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "linkupdate");
#else
  AnimXmlElement element ("linkupdate");
#endif
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("fromId", fromId);
  element.AddAttribute ("toId", toId);
  element.AddAttribute ("ld", linkDescription);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlLink (uint32_t fromId, uint32_t toLp, uint32_t toId)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "link");
#else
	AnimXmlElement element ("link");
#endif
	element.AddAttribute ("fromId", fromId);
	element.AddAttribute ("toId", toId);

	LinkProperties lprop ;
	lprop.fromNodeDescription = "";
	lprop.toNodeDescription = "";
	lprop.linkDescription = "";

	P2pLinkNodeIdPair p1 = { fromId, toId };
	P2pLinkNodeIdPair p2 = { toId, fromId };
	if (m_linkProperties.find (p1) != m_linkProperties.end ())
		{
			lprop = m_linkProperties[p1];
		}
	else if (m_linkProperties.find (p2) != m_linkProperties.end ())
		{
			lprop = m_linkProperties[p2];
		}

	element.AddAttribute ("fd", lprop.fromNodeDescription);
	element.AddAttribute ("td", lprop.toNodeDescription);
	element.AddAttribute ("ld", lprop.linkDescription);
	element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlRouting (uint32_t nodeId, std::string routingInfo)
{
#ifdef HAVE_LIBXML2
  AnimXmlElement element (m_routingXmlWriter, "rt");
#else
  AnimXmlElement element ("rt");
#endif
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("id", nodeId);
  element.AddAttribute ("info", routingInfo.c_str ());
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_routingF);
#endif
}

void 
AnimationInterface::WriteXmlRp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements)
{
#ifdef HAVE_LIBXML2
  AnimXmlElement element (m_routingXmlWriter, "rp");
#else
  std::string tagName = "rp";
  AnimXmlElement element (tagName, false);
#endif
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
	element.AddAttribute ("id", nodeId);
	element.AddAttribute ("d", destination.c_str ());
	element.AddAttribute ("c", rpElements.size ());
#ifndef HAVE_LIBXML2
	element.CloseTag ();
	element.AddLineBreak ();
#endif
	for (Ipv4RoutePathElements::const_iterator i = rpElements.begin ();
			 i != rpElements.end ();
			 ++i)
		{
			Ipv4RoutePathElement rpElement = *i;
#ifdef HAVE_LIBXML2
			AnimXmlElement rpeElement (m_routingXmlWriter, "rpe");
#else
			AnimXmlElement rpeElement ("rpe");
#endif
			rpeElement.AddAttribute ("n", rpElement.nodeId);
			rpeElement.AddAttribute ("nH", rpElement.nextHop.c_str ());
			rpeElement.CloseElement ();
#ifndef HAVE_LIBXML2
			element.Add (rpeElement);
#endif
		}
	element.CloseElement ();
#ifndef HAVE_LIBXML2
	WriteN (element.GetElementString (),  m_routingF);
#endif
}


void 
AnimationInterface::WriteXmlPRef (uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "pr");
#else
  AnimXmlElement element ("pr");
#endif
  element.AddAttribute ("uId", animUid);
  element.AddAttribute ("fId", fId);
  element.AddAttribute ("fbTx", fbTx);

      element.AddAttribute ("meta-info", metaInfo.c_str ());
    }
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (),  m_f);
#endif
}

void 
AnimationInterface::WriteXmlP (uint64_t animUid, std::string pktType, uint32_t tId, double fbRx, double lbRx)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, pktType);
#else
  AnimXmlElement element (pktType);
#endif
  element.AddAttribute ("uId", animUid);
  element.AddAttribute ("tId", tId);
  element.AddAttribute ("fbRx", fbRx);
  element.AddAttribute ("lbRx", lbRx);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (),  m_f);
#endif
}

void 
AnimationInterface::WriteXmlP (std::string pktType, uint32_t fId, double fbTx, double lbTx, 
                                                   uint32_t tId, double fbRx, double lbRx, std::string metaInfo)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, pktType);
#else
  AnimXmlElement element (pktType);
#endif
  element.AddAttribute ("fId", fId);
  element.AddAttribute ("fbTx", fbTx);
  element.AddAttribute ("lbTx", lbTx);

  element.AddAttribute ("fbRx", fbRx);
  element.AddAttribute ("lbRx", lbRx);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (),  m_f);
#endif
}

void 
AnimationInterface::WriteXmlAddNodeCounter (uint32_t nodeCounterId, std::string counterName, CounterType counterType)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "ncs");
#else
	AnimXmlElement element ("ncs");
#endif
  element.AddAttribute ("ncId", nodeCounterId);
  element.AddAttribute ("n", counterName);
  element.AddAttribute ("t", CounterTypeToString (counterType));
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlAddResource (uint32_t resourceId, std::string resourcePath)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "res");
#else
  AnimXmlElement element ("res");
#endif
  element.AddAttribute ("rid", resourceId);
  element.AddAttribute ("p", resourcePath);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlUpdateNodeImage (uint32_t nodeId, uint32_t resourceId)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "nu");
#else
  AnimXmlElement element ("nu");
#endif
  element.AddAttribute ("p", "i");
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("id", nodeId);
  element.AddAttribute ("rid", resourceId);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlUpdateNodeSize (uint32_t nodeId, double width, double height)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "nu");
#else
  AnimXmlElement element ("nu");
#endif
  element.AddAttribute ("p", "s");
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("id", nodeId);
  element.AddAttribute ("w", width);
  element.AddAttribute ("h", height);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (),  m_f);
#endif
}

void 
AnimationInterface::WriteXmlUpdateNodePosition (uint32_t nodeId, double x, double y)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "nu");
#else
  AnimXmlElement element ("nu");
#endif
  element.AddAttribute ("p", "p");
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("id", nodeId);
  element.AddAttribute ("x", x);
  element.AddAttribute ("y", y);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlUpdateNodeColor (uint32_t nodeId, uint8_t r, uint8_t g, uint8_t b)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "nu");
#else
  AnimXmlElement element ("nu");
#endif
  element.AddAttribute ("p", "c");
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("id", nodeId);

  element.AddAttribute ("g", (uint32_t) g);
  element.AddAttribute ("b", (uint32_t) b);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlUpdateNodeDescription (uint32_t nodeId)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "nu");
#else
  AnimXmlElement element ("nu");
#endif
  element.AddAttribute ("p", "d");
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("id", nodeId);

      element.AddAttribute ("descr", m_nodeDescriptions[nodeId]); 
    }
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}


void 
AnimationInterface::WriteXmlUpdateNodeCounter (uint32_t nodeCounterId, uint32_t nodeId, double counterValue)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "nc");
#else
  AnimXmlElement element ("nc");
#endif
  element.AddAttribute ("c", nodeCounterId);
  element.AddAttribute ("i", nodeId);
  element.AddAttribute ("t", Simulator::Now ().GetSeconds ());
  element.AddAttribute ("v", counterValue);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlUpdateBackground (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "bg");
#else
  AnimXmlElement element ("bg");
#endif
  element.AddAttribute ("f", fileName);
  element.AddAttribute ("x", x);
  element.AddAttribute ("y", y);

  element.AddAttribute ("sy", scaleY);
  element.AddAttribute ("o", opacity);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

void 
AnimationInterface::WriteXmlNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType)
{
#ifdef HAVE_LIBXML2
	AnimXmlElement element (m_xmlWriter, "nonp2plinkproperties");
#else
  AnimXmlElement element ("nonp2plinkproperties");
#endif
  element.AddAttribute ("id", id);
  element.AddAttribute ("ipv4Address", ipv4Address);
  element.AddAttribute ("channelType", channelType);
  element.CloseElement ();
#ifndef HAVE_LIBXML2
  WriteN (element.GetElementString (), m_f);
#endif
}

TypeId

(-)a/src/netanim/model/animation-interface.h (-3 / +29 lines)

Lines 43-48	Link Here

#include "ns3/rectangle.h"

#include "ns3/rectangle.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4-l3-protocol.h"

#include "ns3/ipv4-l3-protocol.h"

#ifdef HAVE_LIBXML2

#include <libxml/encoding.h>

#include <libxml/xmlwriter.h>

#include <libxml/xmlstring.h>

#endif

namespace ns3 {

namespace ns3 {

Lines 514-520	Link Here

514

  // Node Counters

519

  // Node Counters

515

  typedef std::map <uint32_t, uint64_t> NodeCounterMap64;

520

  typedef std::map <uint32_t, uint64_t> NodeCounterMap64;

516

521

522

#ifdef HAVE_LIBXML2

523

  class AnimXmlElement

524

525

    public:

526

    AnimXmlElement (xmlTextWriterPtr writer, std::string tagName);

527

    template <typename T>

528

    void AddAttribute (std::string attribute, T value);

529

    template <typename T>

530

    static void AddAttribute (xmlTextWriterPtr writer, std::string attribute, T value);

531

    void CloseElement ();

532

  private:

533

    std::string m_tagName;

534

    xmlTextWriterPtr m_writer;

535

    bool m_closed;

517

536

537

};

538

#else

518

  class AnimXmlElement

539

  class AnimXmlElement

519

540

520

    public:

541

    public:

Lines 533-544	Link Here

533

    bool m_emptyElement;

554

    bool m_emptyElement;

534

555

535

};

556

};

536

557

#endif

537

558

538

  // ##### State #####

559

  // ##### State #####

539

560

#ifdef HAVE_LIBXML2

561

  xmlTextWriterPtr m_xmlWriter;

562

  xmlTextWriterPtr m_routingXmlWriter;

563

#else

540

  FILE * m_f; // File handle for output (0 if none)

564

  FILE * m_f; // File handle for output (0 if none)

541

  FILE * m_routingF; // File handle for routing table output (0 if None);

565

  FILE * m_routingF; // File handle for routing table output (0 if None);

566

#endif

542

  Time m_mobilityPollInterval;

567

  Time m_mobilityPollInterval;

543

  std::string m_outputFileName;

568

  std::string m_outputFileName;

544

  uint64_t gAnimUid ;    // Packet unique identifier used by AnimationInterface

569

  uint64_t gAnimUid ;    // Packet unique identifier used by AnimationInterface

Lines 774-785	Link Here

774

                                 std::string metaInfo = "");

799

                                 std::string metaInfo = "");

775

  void WriteXmlP (uint64_t animUid, std::string pktType, uint32_t fId, double fbTx, double lbTx);

800

  void WriteXmlP (uint64_t animUid, std::string pktType, uint32_t fId, double fbTx, double lbTx);

776

  void WriteXmlPRef (uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo = "");

801

  void WriteXmlPRef (uint64_t animUid, uint32_t fId, double fbTx, std::string metaInfo = "");

802

#ifndef HAVE_LIBXML2

777

  void WriteXmlClose (std::string name, bool routing = false);

803

  void WriteXmlClose (std::string name, bool routing = false);

804

#endif

778

  void WriteXmlNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType);

805

  void WriteXmlNonP2pLinkProperties (uint32_t id, std::string ipv4Address, std::string channelType);

779

  void WriteXmlRouting (uint32_t id, std::string routingInfo);

806

  void WriteXmlRouting (uint32_t id, std::string routingInfo);

780

  void WriteXmlRp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements);

807

  void WriteXmlRp (uint32_t nodeId, std::string destination, Ipv4RoutePathElements rpElements);

781

  void WriteXmlUpdateBackground (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity);

808

  void WriteXmlUpdateBackground (std::string fileName, double x, double y, double scaleX, double scaleY, double opacity);

782

783

};

809

};

784

810

785

811

Return to bug 2170