- Added xml output switch (-x, check scyther --help). It's not complete

yet, to be finished tomorrow.

src/arachne.c

@@ -437,7 +437,7 @@ determine_unification_run (Termlist tl)
 
 //! Determine trace length
 int
-get_trace_length ()
+get_semitrace_length ()
 {
   int run;
   int length;
@@ -1571,7 +1571,7 @@ printSemiState ()
   indentPrint ();
   eprintf ("!!\n");
   indentPrint ();
-  eprintf ("!! Trace length: %i\n", get_trace_length ());
+  eprintf ("!! Trace length: %i\n", get_semitrace_length ());
   open = 0;
   for (run = 0; run < sys->maxruns; run++)
     {
@@ -1718,7 +1718,8 @@ isOpenNonceVar (Term t)
 //! Count unique open variables in term
 /**
  */
-int count_open_variables (const Term t)
+int
+count_open_variables (const Term t)
 {
   Termlist tl;
   int n;
@@ -2725,7 +2726,7 @@ prune_bounds ()
     }
 
   // Limit on exceeding any attack length
-  if (sys->prune == 2 && get_trace_length () >= attack_length)
+  if (sys->prune == 2 && get_semitrace_length () >= attack_length)
     {
       if (sys->output == PROOF)
 	{
@@ -2834,6 +2835,12 @@ property_check ()
    */
   count_false ();
   if (sys->output == ATTACK)
+    {
+      if (sys->switchXMLoutput)
+	{
+	  xmlOutSemitrace (sys);
+	}
+      else
 	{
 	  if (sys->latex == 1)
 	    {
@@ -2844,8 +2851,9 @@ property_check ()
 	      dotSemiState ();
 	    }
 	}
+    }
   // Store attack length if shorter
-  attack_this = get_trace_length ();
+  attack_this = get_semitrace_length ();
   if (attack_this < attack_length)
     {
       // Shortest attack

src/arachne.h

@@ -6,5 +6,6 @@
 void arachneInit (const System sys);
 void arachneDone ();
 int arachne ();
+int get_semitrace_length ();
 
 #endif

src/switches.c

@@ -210,6 +210,19 @@ switcher (const int process, const System sys, int index)
 	}
     }
 
+  if (detect ('x', "xml-output", 0))
+    {
+      if (!process)
+	{
+	  helptext ("-x,--xml-output", "show attack output in XML format");
+	}
+      else
+	{
+	  sys->switchXMLoutput = 1;
+	  return index;
+	}
+    }
+
   if (detect ('m', "match", 1))
     {
       if (!process)
@@ -519,7 +532,8 @@ switcher (const int process, const System sys, int index)
 		}
 	      else
 		{
-		  fprintf (stderr, "Could not open input file '%s'.\n", this_arg);
+		  fprintf (stderr, "Could not open input file '%s'.\n",
+			   this_arg);
 		}
 	      exit (1);
 	    }

src/system.c

@@ -75,6 +75,7 @@ systemInit ()
   sys->switchReduceClaims = 1;	// default remove claims from duplicate instance choosers
   sys->switchClaims = 0;	// default don't report on claims
   sys->switchClaimToCheck = NULL;	// default check all claims
+  sys->switchXMLoutput = 0;	// default no xml output
   sys->switchGoalSelectMethod = 3;	// default goal selection method
   sys->traverse = 12;		// default traversal method
 
@@ -262,7 +263,8 @@ ensureValidRun (const System sys, int run)
   /* update size parameter */
   oldsize = sys->maxruns;
   sys->maxruns = run + 1;
-  sys->runs = (Run) memRealloc (sys->runs, sizeof (struct run) * (sys->maxruns));
+  sys->runs =
+    (Run) memRealloc (sys->runs, sizeof (struct run) * (sys->maxruns));
 
   /* create runs, set the new pointer(s) to NULL */
   for (i = oldsize; i < sys->maxruns; i++)
@@ -1069,7 +1071,8 @@ roleInstanceDestroy (const System sys)
       // Destroy run struct allocation in array using realloc
       // Reduce run count
       sys->maxruns = sys->maxruns - 1;
-      sys->runs = (Run) memRealloc (sys->runs, sizeof (struct run) * (sys->maxruns));
+      sys->runs =
+	(Run) memRealloc (sys->runs, sizeof (struct run) * (sys->maxruns));
     }
 }
 

src/system.h

@@ -143,6 +143,7 @@ struct system
   int switchClaims;		//!< Enable clails report
   int switchGoalSelectMethod;	//!< Goal selection method for Arachne engine
   Term switchClaimToCheck;	//!< Which claim should be checked?
+  int switchXMLoutput;		//!< xml output
 
   //! Latex output switch.
   /**

src/xmlout.c

@@ -0,0 +1,336 @@
+/*
+ * xmlout.c
+ *
+ * XML output for Scyther
+ *
+ * Module to output detailed Scyther information in XML format, for easier
+ * interaction with external programs. Originally developed for attack output
+ * details.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "term.h"
+#include "termlist.h"
+#include "system.h"
+#include "binding.h"
+#include "arachne.h"		// for get_semitrace_length
+
+#include "xmlout.h"
+
+/*
+ * Global/static stuff.
+ */
+static int xmlindent;		// indent level for xml elements in output
+
+/*
+ * Default external interface: init/done
+ */
+
+//! Init this module
+void
+xmlOutInit (void)
+{
+  xmlindent = 0;
+}
+
+//! Close up
+void
+xmlOutDone (void)
+{
+}
+
+/*
+ * Local code, needed for any further real code.
+ */
+
+//! Indent code
+void
+xmlIndentPrint ()
+{
+  int i;
+
+  i = xmlindent;
+  while (i > 0)
+    {
+      printf ("   ");
+      i--;
+    }
+}
+
+//! XML print
+/**
+ * Input is comparable to printf, but indents (according to xmlindent) and adds
+ * a newline.
+ */
+void
+xmlPrint (char *fmt, ...)
+{
+  va_list args;
+
+  xmlIndentPrint ();
+  va_start (args, fmt);
+  vfprintf (stdout, fmt, args);
+  va_end (args);
+  printf ("\n");
+}
+
+//! Print a simple integer value element
+void
+xmlOutInteger (const char *tag, const int value)
+{
+  xmlPrint ("<%s>%i</%s>", tag, value, tag);
+}
+
+//! Print a term for an element
+void
+xmlOutTerm (const char *tag, const Term term)
+{
+  if (term != NULL)
+    {
+      xmlIndentPrint ();
+      printf ("<%s>", tag);
+      termPrint (term);
+      printf ("</%s>\n", tag);
+    }
+}
+
+//! Attribute term
+void
+xmlAttrTerm (const char *tag, const Term term)
+{
+  if (term != NULL)
+    {
+      printf (" %s=\"", tag);
+      termPrint (term);
+      printf ("\"");
+    }
+}
+
+//! Global system info
+/**
+ * To be used by concrete trace as well as semitrace output
+ */
+void
+xmlOutSysInfo (const System sys)
+{
+  xmlPrint ("<system>");
+  xmlindent++;
+
+  {
+    Protocol p;
+
+    p = sys->protocols;
+    while (p != NULL)
+      {
+	xmlOutTerm ("protocol", p->nameterm);
+	p = p->next;
+      }
+  }
+
+  xmlOutInteger ("match", sys->match);
+
+  xmlindent--;
+  xmlPrint ("</system>");
+}
+
+//! Static information about a run
+/**
+ * TODO: Does not output any sigma info yet (role->agent mappings), which is very important.
+ */
+void
+xmlRunInfo (const System sys, const int run)
+{
+  Role r;
+  Term oldagent;
+
+  xmlOutInteger ("runid", run);
+  xmlOutTerm ("protocol", sys->runs[run].protocol->nameterm);
+  r = sys->runs[run].role;
+
+  /* undo substitution temporarily to retrieve role name */
+  /* Note that this is fairly tailored towards the Arachne method, TODO: make
+   * more generic. */
+  oldagent = r->nameterm->subst;
+  r->nameterm->subst = NULL;
+  xmlOutTerm ("role", r->nameterm);
+  /* reinstate substitution */
+  r->nameterm->subst = oldagent;
+  if (oldagent != NULL)
+    {
+      xmlOutTerm ("agent", r->nameterm);
+    }
+}
+
+//! Show a single event from a run
+/**
+ * run and index will only be output if they are nonnegative.
+ */
+void
+xmlOutEvent (const System sys, Roledef rd, const int run, const int index)
+{
+  xmlIndentPrint ();
+
+  printf ("<");
+  switch (rd->type)
+    {
+      /* Read or send types are fairly similar.
+       * Currently, choose events are not distinguished yet. TODO
+       */
+    case READ:
+      printf ("read");
+      break;
+    case SEND:
+      printf ("send");
+      break;
+    case CLAIM:
+      printf ("claim");
+      break;
+    default:
+      printf ("unknown code=\"%i\"", rd->type);
+      break;
+    }
+
+  xmlAttrTerm ("label", rd->label);
+  if (rd->type != CLAIM)
+    {
+      /* read or send */
+      xmlAttrTerm ("from", rd->from);
+      xmlAttrTerm ("to", rd->to);
+      xmlAttrTerm ("message", rd->message);
+    }
+  else
+    {
+      /* claim */
+      xmlAttrTerm ("role", rd->from);
+      xmlAttrTerm ("type", rd->to);
+      xmlAttrTerm ("argument", rd->message);
+    }
+
+  if (run >= 0)
+    {
+      printf (" run=\"%i\"", run);
+    }
+  if (index >= 0)
+    {
+      printf (" index=\"%i\"", index);
+    }
+  printf (" />\n");
+}
+
+//! Display runs
+void
+xmlOutRuns (const System sys)
+{
+  int run;
+
+  for (run = 0; run < sys->maxruns; run++)
+    {
+      xmlPrint ("<run>");
+      xmlindent++;
+
+      xmlRunInfo (sys, run);
+
+      xmlPrint ("<eventlist>");
+      xmlindent++;
+      {
+	Roledef rd;
+	int index;
+
+	index = 0;
+	rd = sys->runs[run].start;
+	while (rd != NULL)
+	  {
+	    xmlOutEvent (sys, rd, -1, index);
+	    index++;
+	    rd = rd->next;
+	  }
+      }
+      xmlindent--;
+      xmlPrint ("</eventlist>");
+      xmlindent--;
+      xmlPrint ("</run>");
+    }
+}
+
+
+//! Output list of bindings
+void
+xmlOutBindings (const System sys)
+{
+  int xmlBindingState (void *dt)
+  {
+    Binding b;
+    void xmlRunIndex (char *desc, const int run, const int index)
+    {
+      xmlPrint ("<%s run=\"%i\" index=\"%i\" />", desc, run, index);
+    }
+
+    b = (Binding) dt;
+    xmlIndentPrint ();
+    printf ("<binding term=\"");
+    termPrint (b->term);
+    printf ("\" />\n");
+    xmlindent++;
+    if (b->done)
+      xmlRunIndex ("from", b->run_from, b->ev_from);
+    else
+      xmlPrint ("<unbound />");
+    xmlRunIndex ("to", b->run_to, b->ev_to);
+    if (b->blocked)
+      printf ("<blocked />");
+    xmlindent--;
+    xmlPrint ("</binding>");
+    return 1;
+  }
+
+  xmlPrint ("<bindinglist>");
+  xmlindent++;
+  if (sys->bindings != NULL)
+    {
+      list_iterate (sys->bindings, xmlBindingState);
+    }
+  xmlindent--;
+  xmlPrint ("</bindinglist>");
+}
+
+/*
+ * -----------------------------------------------------------------------------------
+ * Publicly available functions
+ */
+
+//! Output for a concrete trace (from modelchecker)
+void
+xmlOutTrace (const System sys)
+{
+}
+
+//! Output for a semitrace (from arachne method)
+/**
+ * Note: Uses get_trace_length(), which is defined for the arachne method only.
+ *
+ * TODO does not show violated claim yet, this must now be guessed by the
+ * reader.
+ */
+void
+xmlOutSemitrace (const System sys)
+{
+  xmlIndentPrint ();
+  printf ("<attack");
+  /* add trace length attribute */
+  printf (" tracelength=\"%i\"", get_semitrace_length ());
+  printf (">\n");
+  xmlindent++;
+  /* any global information about the system */
+  xmlOutSysInfo (sys);
+  xmlPrint ("<semitrace>");
+  xmlindent++;
+  xmlOutRuns (sys);
+  xmlOutBindings (sys);
+  xmlindent--;
+  xmlPrint ("</semitrace>");
+  xmlindent--;
+  xmlPrint ("</attack>");
+}

src/xmlout.h

@@ -0,0 +1,12 @@
+#ifndef XMLOUT
+#define XMLOUT
+
+#include "system.h"
+
+void xmlOutInit (void);
+void xmlOutDone (void);
+
+void xmlOutSemitrace (const System sys);
+void xmlOutTrace (const System sys);
+
+#endif