Merge lp:~ensoft-opensource/ensoft-sextant/trunk into lp:ensoft-sextant

[James]

setup.py no uploads config and web file to the correct location for the pypi installation.

setup.py no uploads config and web file to the correct location for the pypi installation.

[Phil Connell (pconnell)]

Merging in without a review, to get trunk in sync with latest code.

Full review to be done at some point.

review: Approve

=== added file 'LICENSE.txt'
--- LICENSE.txt	1970-01-01 00:00:00 +0000
+++ LICENSE.txt	2014-08-15 12:04:08 +0000
@@ -0,0 +1,27 @@
+Copyright (c) 2014, Ensoft Ltd.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer. 
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies, 
+either expressed or implied, of the FreeBSD Project.
+
 
=== added file 'MANIFEST.in'
--- MANIFEST.in	1970-01-01 00:00:00 +0000
+++ MANIFEST.in	2014-08-15 12:04:08 +0000
@@ -0,0 +1,3 @@
+include *.py
+recursive-include resources *.html *.js *.css *.gif
+
 
=== removed directory 'Parser'
=== removed file 'Parser/parser.py'
--- Parser/parser.py	2014-07-03 12:28:28 +0000
+++ Parser/parser.py	1970-01-01 00:00:00 +0000
@@ -1,161 +0,0 @@
-__author__ = 'patrickas'
-
-import re
-import argparse
-
-class parsed_object():
-    """This object has a name (which is the verbatim name like '<__libc_start_main@plt>'), a position (which
-    is the virtual memory location in hex, like '08048320', extracted from the dump), and a canonical_position
-    (which is the virtual memory location in hex but stripped of leading 0s, so it should be a unique id).
-    It also has a list what_do_i_call of parsed_objects it calls using the assembly keyword 'call'.
-    It has a list original_code of its assembler code, too, in case it's useful."""
-
-    @staticmethod
-    def get_canonical_position(position):
-        return position.lstrip('0')
-
-    def __eq__(self, other):
-        return self.canonical_position == other.canonical_position and self.name == other.name
-
-    def __init__(self, input_lines, assembler_section = ''):
-        """Creates a new parsed_object given the relevant definition-lines from objdump -S.
-        A sample first definition-line is '08048300 <__gmon_start__@plt>:\n' but this function
-         expects to see the entire definition eg
-
-080482f0 <puts@plt>:
- 80482f0:	ff 25 00 a0 04 08    	jmp    *0x804a000
- 80482f6:	68 00 00 00 00       	push   $0x0
- 80482fb:	e9 e0 ff ff ff       	jmp    80482e0 <_init+0x30>
-
-          We also might expect assembler_section, which is for instance '.init' in 'Disassembly of section .init:'
-        """
-        self.name = re.search(r'<.+>', input_lines[0]).group(0)
-        self.position = re.search(r'^[0-9a-f]+', input_lines[0]).group(0)
-        self.canonical_position = parsed_object.get_canonical_position(self.position)
-        self.assembler_section = assembler_section
-        self.original_code = input_lines[1:]
-
-        #todo: work out what this node calls, and store it in what_do_i_call
-        lines_where_i_call = [line for line in input_lines if re.search(r'\tcall   [0-9a-f]+ <.+>\n', line)]
-
-        self.what_do_i_call = []
-        for line in lines_where_i_call:
-            called = (re.search(r'\tcall   [0-9a-f]+ <.+>\n', line).group(0))[8:]
-            address, name = called.split(' ')
-            self.what_do_i_call.append((address, name.rstrip('\n')))
-
-
-
-    def __str__(self):
-        return 'Memory address ' + self.position + ' with name ' + self.name + ' in section ' + str(self.assembler_section)
-
-    def __repr__(self):
-        out_str = 'Disassembly of section ' + self.assembler_section + ':\n\n' + self.position + ' ' + self.name + ':\n'
-        return out_str + '\n'.join([' ' + line for line in self.original_code])
-
-class Parser:
-    # Class to manipulate the output of objdump
-
-    def __init__(self, input_file_location):
-        """Creates a new Parser, given an input file path. That path should be an output from objdump -S."""
-        file = open(input_file_location, 'r')
-        self.source_string_list = [line for line in file]
-        file.close()
-        self.parsed_objects = []
-
-    def create_objects(self):
-        """ Go through the source_string_list, getting object names (like <main>) along with the corresponding
-         definitions, and put them into parsed_objects """
-
-        parsed_objects = []
-        current_object = []
-        current_section = ''
-        for line in self.source_string_list[4:]: # we bodge, since the file starts with a little bit of guff
-            if re.match(r'[0-9a-f]+ <.+>:\n', line):
-                # we are a starting line
-                current_object = [line]
-            elif re.match(r'Disassembly of section', line):
-                current_section = re.search(r'section .+:\n', line).group(0).lstrip('section ').rstrip(':\n')
-                current_object = []
-            elif line == '\n':
-                #we now need to stop parsing the current block, and store it
-                if len(current_object) > 0:
-                    parsed_objects.append(parsed_object(current_object, current_section))
-            else:
-                current_object.append(line)
-
-        # now we should be done. We assumed that blocks begin with r'[0-9a-f]+ <.+>:\n' and end with a newline.
-                #clear duplicates:
-
-        self.parsed_objects = []
-        for obj in parsed_objects:
-            if obj not in self.parsed_objects:
-                self.parsed_objects.append(obj)
-
-        # by this point, each object contains a self.what_do_i_call which is a list of tuples ('address', 'name').
-
-    def object_lookup(self, object_name = '', object_address = ''):
-        """Returns the object with name object_name or address object_address (at least one must be given).
-        If objects with the given name or address
-        are not found, returns None."""
-
-        if object_name == '' and object_address == '':
-            return None
-
-        trial_obj = self.parsed_objects
-
-        if object_name != '':
-            trial_obj = [obj for obj in trial_obj if obj.name == object_name]
-
-        if object_address != '':
-            trial_obj = [obj for obj in trial_obj if obj.canonical_position == parsed_object.get_canonical_position(object_address)]
-
-        if len(trial_obj) == 0:
-            return None
-
-        return trial_obj
-
-    def link_objects(self):
-        """Goes through the objects which have already been imported, making their self.what_do_i_call into a list of
-        objects, rather than a list of (address, name)"""
-        #todo: implement this
-
-        for obj in self.parsed_objects:
-            output_list = []
-            for called_thing in obj.what_do_i_call:
-                ref = called_thing[0]
-                if self.object_lookup(object_address=ref) is None:
-                    #here, we have an object which is not found in our object_lookup
-                    pass
-                else:
-                #called_thing looks like ('address', 'name'); we need to pass this list one by one into object_lookup
-                    for looked_up in self.object_lookup(object_address=ref):
-                        output_list.append(looked_up)
-            obj.what_do_i_call = output_list
-
-def main():
-    
-
-    p = Parser(r"C:\Users\patrickas\Desktop\Objdump_parser\objdump_samples\objdump_libcopp.txt") #command line input of this, or accept a .o file (to run objdump against)
-    p.create_objects()
-
-    print('Functions found:')
-
-    for obj in p.parsed_objects:
-        print(str(obj))
-
-    p.link_objects()
-
-    func_to_investigate = '<copp_sampler_et_ht_lookup>' #do this for all functions
-
-    print('Investigation of {}:'.format(func_to_investigate))
-
-    #we can investigate a particular object:
-    main_func = [obj for obj in p.parsed_objects if obj.name == func_to_investigate][0]
-    print('{} calls '.format(func_to_investigate),end='')
-    print([str(f) for f in main_func.what_do_i_call])
-
-    print('Ended investigation')
-
-if __name__ == "__main__":
-    main()
 \ No newline at end of file
 
=== added directory 'bin'
=== added file 'bin/sextant'
--- bin/sextant	1970-01-01 00:00:00 +0000
+++ bin/sextant	2014-08-15 12:04:08 +0000
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+export PYTHONPATH=${PYTHONPATH}:${DIR}/../src
+
+python -m sextant $@
+
 
=== added file 'bin/sextant.bat'
--- bin/sextant.bat	1970-01-01 00:00:00 +0000
+++ bin/sextant.bat	2014-08-15 12:04:08 +0000
@@ -0,0 +1,3 @@
+set DIR=%~dp0..\src\
+
+cmd /C "set PYTHONPATH=%DIR% && c:\python27\python -m sextant %*"
 
=== added directory 'doc'
=== added file 'doc/Instructions For yED use.docx'
 Binary files doc/Instructions For yED use.docx	1970-01-01 00:00:00 +0000 and doc/Instructions For yED use.docx	2014-08-15 12:04:08 +0000 differ
=== added file 'doc/Program_upload_docs.mkd'
--- doc/Program_upload_docs.mkd	1970-01-01 00:00:00 +0000
+++ doc/Program_upload_docs.mkd	2014-08-15 12:04:08 +0000
@@ -0,0 +1,9 @@
+# Function pointers
+
+We treat function pointers as functions in their own right, but we rename them to `_._function_pointer_n` where `n` is a numerical identifier (unique to each function pointer call). When ProgramConverter is used to produce graphical output for graphs with function pointers in, they are displayed as yellow nodes with name `(function pointer)`.
+
+Optionally, the flag `--ignore-function-pointers` can be provided to `program_upload.py` to cause the parser to pretend function pointer calls simply do not exist.
+
+# Query parameters
+We take the mandatory `--input-file`, a filepath for a program file whose call graph we wish to upload to the Neo4J server. Optionally we can specify that it is an ``--object-file` to have `objdump` run against it; otherwise, we assume the input was a text file consisting of `objdump`'s output.
+Optional (if specified in config file) `--remote-neo4j`, the location of the Neo4J server (eg. `http://localhost:7474`).
 \ No newline at end of file
 
=== added file 'doc/Web_server.mkd'
--- doc/Web_server.mkd	1970-01-01 00:00:00 +0000
+++ doc/Web_server.mkd	2014-08-15 12:04:08 +0000
@@ -0,0 +1,20 @@
+The server is running on Twisted. It has a static directory (`/trunk/sextant/web/public_html` in the repository) hosted at `/hello_world` for the moment. It also has `/database_properties` and `/output_graph.svg`. This page documents (so far) the dynamically generated pages.
+
+# database_properties
+This page is designed to be roughly equivalent to the Python script `/graph_properties.py`. It takes arguments `query` of 'functions' or 'properties' and optionally `program_name` (which is ignored unless 'query=functions' was specified). Its return content-type is `text/plain`. The page returns a list of function names as:
+
+    ["func1", "func2", ... , "funcn"]
+    
+if `query=functions` was specified, where the `funci` are the function names in the database under program-name `program_name`. It returns `None` if there was no program with the given name, and `[]` if there were no functions in the existing program with the given name.
+
+If instead `query=programs` was specified, we return:
+
+    ["prog1", ... , "progn"]
+    
+where the `progi` are the program names stored in the database. If there are no programs in the database, we return `[]`.
+
+# output_graph.svg
+This page is roughly equivalent to `/query_graph.py`. It takes arguments `program_name`, `query`. If the `program_name` was not found in the database, raises a 404 Not Found error. The `query` must be `whole_program`, `functions_calling` or `functions_called_by`; if it is not found, we use `whole_program` as a default.
+If `query` is `functions_calling` or `functions_called_by`, we require a `func1` parameter, as the name of the function of interest.
+
+The page returns a GraphViz-generated file of the query run against the specified function. Its content-type is `image/svg+xml`.
 \ No newline at end of file
 
=== added directory 'doc/wiki'
=== added file 'doc/wiki/Reference'
--- doc/wiki/Reference	1970-01-01 00:00:00 +0000
+++ doc/wiki/Reference	2014-08-15 12:04:08 +0000
@@ -0,0 +1,45 @@
+
+= Sextant Notes =
+== Configuration ==
+In the config file you should specify:
+ * The url under which Neo4j is running, 
+ * The port on which the web interface will run,
+ * Your definition of what is a common function (number of functions calling that function).
+An example file is provided in the etc folder.
+If your instance of Neo4j is local, please start running the server before uploading a program or performing queries.
+== File Management ==
+No more than one program can have the same name in the database.
+=== Uploading a File ===
+set-file-name and not-object-file are optional.
+{{{
+sextant add_program --input-file <name of file being input> --set-file-name <name file to be stored under in database> --not-object-file <True or False (default is False; pass through Objdump)>
+}}}
+=== Deleting File ===
+It is good practice to delete files from the server since having many graphs in the database can lead to negative effects on performance.
+{{{
+sextant delete_program --program name <program name to be deleted as stored in database>
+}}}
+== Queries ==
+=== Command Line ===
+Command line queries produce a text output, either as a list or in GraphML which can be opened in yED.
+All queries take the form.
+{{{
+sextant query --program-name <program name> --query <query name>  --funcs <One or two functions as the arguments of the query> --suppress-common <True or False (default is False)>
+}}}
+Here common sense prevails. "return-all-program-names" doesn't have a "--program-name" argument or "--funcs" or "--suppress-common".  Similarly whole-graph doesn't take any "--funcs". "--suppress-common" is always optional and can only be used for a GraphML output.
+The options for queries are:
+ * functions-calling,
+ * functions-called-by,
+ * calls-between,
+ * whole-graph,
+ * shortest-path,
+ * return-all-program-names,
+ * return-all-function-names.
+For help with queries from the command line and the arguments type:
+{{{
+sextant query -h
+}}}
+=== Web ===
+To run the web server type
+{{{ sextant web }}}
+into the command line; then navigate a web browser to the port specified.
 \ No newline at end of file
 
=== added directory 'etc'
=== added file 'etc/sextant.conf'
--- etc/sextant.conf	1970-01-01 00:00:00 +0000
+++ etc/sextant.conf	2014-08-15 12:04:08 +0000
@@ -0,0 +1,7 @@
+[Neo4j]
+# URL of the Neo4J server
+remote_neo4j = http://localhost:7474
+# port on which to serve Sextant Web
+port = 2905
+# number of calls incoming before we consider a function to be 'common'
+common_function_calls = 10
 
=== added directory 'resources'
=== added directory 'resources/web'
=== added file 'resources/web/index.html'
--- resources/web/index.html	1970-01-01 00:00:00 +0000
+++ resources/web/index.html	2014-08-15 12:04:08 +0000
@@ -0,0 +1,45 @@
+<!--
+ Sextant
+ Copyright 2014, Ensoft Ltd.
+ Author: Patrick Stevens
+
+ Home screen for Sextant-->
+
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8"/>
+    <link rel="stylesheet" type="text/css" href="style_sheet.css"/>
+    <title>Sextant</title>
+</head>
+<body>
+<table>
+<tr>
+    <td>
+        <h1>You have reached the portal to Sextant.</h1>
+    </td>
+    <td>
+    </td>
+</tr>
+<tr>
+    <td>
+        <!--Sextant image-->
+        <img src="sextant.gif" alt = "sextant">
+    </td>
+    <td>
+        <!--link to the Query page-->
+        <form action='/interface.html' method="get">
+            <input type="submit" value="Query Page" class="button2"
+                 name="link_query" id="form1_submit" />
+        </form>
+        <!--link to Database Properties page-->
+        <form action='/database_properties' method="get">
+            <input type="submit" value="Database Properties" class="button2"
+                 name="link_properties" id="form2_submit" />
+        </form>
+    </td>
+</tr>
+</table>
+
+</body>
+</html>
 
=== added file 'resources/web/interface.html'
--- resources/web/interface.html	1970-01-01 00:00:00 +0000
+++ resources/web/interface.html	2014-08-15 12:04:08 +0000
@@ -0,0 +1,103 @@
+<!--
+ Sextant
+ Copyright 2014, Ensoft Ltd.
+ Author: James Harkin
+
+ Sextant web interface for Queries -->
+
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8"/>
+ 	<link rel="stylesheet" type="text/css" href="style_sheet.css"/>
+    <title> Webinterface test </title>
+</head>
+
+<body onload="get_names_for_autocomplete('programs')">
+<!-- Create a table with a border to hold the input file query name
+        and arguments. table remains fixed while page scrolls-->
+<table style="background-color:#FFFFFF; width: 100%;
+                border:1px solid black;  position: fixed;">
+<tr style="height:20px">
+    <td style="width:250">
+        <h2>Input file</h2>
+    </td>
+    <td style="width:350">
+        <h2>Query</h2>
+    </td>
+    <td style="width:250">
+        <h2>Arguments</h2>
+    </td>
+    <td>
+    <form>
+        <!--checkbox used to supress common nodes-->
+        <label>
+            <input type="checkbox" id="suppress_common" value="True" />
+            Suppress common functions?
+        </label>
+	</form>
+    </td>
+</tr>
+<tr style="height:100px">
+    <td>
+        <!-- Autocomplete textbox for program names; populated on upload-->
+        <input list="program_names"  id="program_name"
+               onblur="get_names_for_autocomplete('funcs')" style="size:20">
+        <datalist id="program_names">
+        </datalist>
+    </td>
+    <td>
+        <!-- Drop-down box to hold choice of queries-->
+        <form name="drop_list_1">
+        <SELECT  id="query_list" onchange="display_when();">
+            <option value="whole_program">Whole graph</option>
+            <option value="functions_calling">
+                All functions calling specific function</option>
+            <option value="functions_called_by">
+                All functions called by a specific function</option>
+            <option value="call_paths">
+                All function call paths between two functions</option>
+            <option value="shortest_path">
+                Shortest path between two functions</option>
+            <option value="function_names">
+                All function names</option>
+        </SELECT>
+        </form>
+        <p>
+            query selected : <input type="text" id="query"
+                                    value="Whole graph" size="20">
+        </p>
+    </td>
+    <td>
+        <!-- Autocomplete text box for argument
+        1 Is only visible for relevant queries-->
+        <div id="argument_1">No arguments required.</div>
+        <input list="function_names" id="function_1" style="size:20; visibility:hidden">
+      <!--list to populate arguments.  Updates when program name is specified-->
+        <datalist id="function_names">
+        </datalist>
+        <!-- Autocomplete text box for argument
+        2 Is only visible for relevant queries-->
+        <div id="argument_2"></div>
+        <input list="function_names" id="function_2"  style="size:20; visibility:hidden">
+
+    </td>
+    <td>
+
+        <!--execute button; submits query-->
+        <br><input type="submit" value="Execute&#x00A;Query" class="button"
+                   onclick="execute_query()"><br>
+    </td>
+</tr>
+</table>
+<!-- Paragraph for text output e.g. list of funtion names-->
+<p id="function_names_output" class="pos_functions" style="size:20; visibility:hidden"></p>
+
+<!-- Output for image file-->
+<img id=output_image src="sextant.jpg" alt="Execute query to display graph."
+    class="pos_img"
+    style="align: bottom; font-style: italic; color: #C0C0C0; font-size: 15px;">
+
+<script src="queryjavascript.js"></script>
+</body>
+</html>
 
=== added file 'resources/web/queryjavascript.js'
--- resources/web/queryjavascript.js	1970-01-01 00:00:00 +0000
+++ resources/web/queryjavascript.js	2014-08-15 12:04:08 +0000
@@ -0,0 +1,201 @@
+// Sextant
+// Copyright 2014, Ensoft Ltd.
+// Author: James Harkin, Patrick Stevens
+// 
+//Runs query and "GET"s either program names uploaded on the 
+//server or function names from a specific program.
+
+
+function get_names_for_autocomplete(info_needed){
+	//Function queries to database to create a list 
+	//which is used to populate the auto-complete text boxes.
+	var xmlhttp = new XMLHttpRequest();
+	xmlhttp.onreadystatechange = function(){
+		if (xmlhttp.status = 200){
+			var values_list = xmlhttp.responseText;
+			console.log(values_list)
+			values_list = JSON.parse(values_list);
+			if (info_needed =='programs'){
+				//We need to populate the program names list
+				add_options("program_names", values_list);
+			}
+			if (info_needed =='funcs'){
+				//We need to populate the functions list for the arguments
+				add_options("function_names", values_list);
+			}	
+		}
+	}
+	if (info_needed == 'programs'){
+		var string = "/database_properties?query=" + info_needed + "&program_name=";
+	}
+	else{
+		var string = "/database_properties?query=" + "functions" + 
+		"&program_name=" + document.getElementById("program_name").value;
+	if (info_needed == 'programs'){
+		var string = "/database_properties?query=" + 
+		info_needed + "&program_name=" + prog_name;
+	}
+	//"GET" information from the specified url (string)
+	xmlhttp.open("GET", string, true);
+	xmlhttp.send();
+	}
+	xmlhttp.open("GET", string, true);
+	xmlhttp.send();
+}
+
+
+function add_options(selectedlist, values_list){
+	//Adds all the options obtained from the list of program 
+	//names or function names to an auto complete drop-down box
+	var options = ''
+	if (values_list.length == 1 || values_list.length ==0){
+		options += '<option value="'+values_list+'"/>';
+	}
+	else{
+		for (var i=0; i < values_list.length;++i){
+			options += '<option value="'+values_list[i]+'"/>';
+		}
+	}
+	document.getElementById(selectedlist).innerHTML = options;
+}
+
+	
+function display_when(){
+	//For each query specifies when auto-complete text boxes should be made 
+	//visible or invisible and makes them read only
+	var query_list = document.getElementById("query_list");
+	document.getElementById("query").value = 
+		query_list.options[query_list.selectedIndex].text;
+	var no_functions = new Array();
+	var prog_name = document.getElementById("program_name").value;
+	if (query_list.options[query_list.selectedIndex].value == "functions_calling"){
+		document.getElementById("argument_1").innerHTML = "Function being called";
+		document.getElementById("argument_2").innerHTML = "";
+		document.getElementById("function_1").readOnly = false;
+		document.getElementById("function_2").readOnly = true;
+		document.getElementById("function_1").style.visibility = "visible";
+		document.getElementById("function_2").style.visibility = "hidden";
+		document.getElementById("function_2").value = null;
+	}
+	if (query_list.options[query_list.selectedIndex].value == "functions_called_by"){
+		document.getElementById("argument_1").innerHTML = "Function calling";
+		document.getElementById("argument_2").innerHTML = "";
+		document.getElementById("function_1").readOnly = false;
+		document.getElementById("function_2").readOnly = true;
+		document.getElementById("function_1").style.visibility = "visible";
+		document.getElementById("function_2").style.visibility = "hidden";
+		document.getElementById("function_2").value = null;
+	}
+	if (query_list.options[query_list.selectedIndex].value == "call_paths"){
+		document.getElementById("argument_1").innerHTML = "Function calling";
+		document.getElementById("argument_2").innerHTML = "Function being called";
+		document.getElementById("function_1").readOnly = false;
+		document.getElementById("function_2").readOnly = false;
+		document.getElementById("function_1").style.visibility = "visible";
+		document.getElementById("function_2").style.visibility = "visible";
+	}
+	if (query_list.options[query_list.selectedIndex].value == "shortest_path"){
+		document.getElementById("argument_1").innerHTML = "Function calling";
+		document.getElementById("argument_2").innerHTML = "Function being called";
+		document.getElementById("function_1").readOnly = false;
+		document.getElementById("function_2").readOnly = false;
+		document.getElementById("function_1").style.visibility = "visible";
+		document.getElementById("function_2").style.visibility = "visible";
+	}
+	if (query_list.options[query_list.selectedIndex].value == "whole_program") {
+		document.getElementById("argument_1").innerHTML	= "No arguments required.";
+		document.getElementById("argument_2").innerHTML = "";
+		document.getElementById("function_1").readOnly = true;
+		document.getElementById("function_2").readOnly = true;
+		document.getElementById("function_1").style.visibility = "hidden";
+		document.getElementById("function_2").style.visibility = "hidden";
+		document.getElementById("function_1").value = null;
+		document.getElementById("function_2").value = null;
+	}
+	if (query_list.options[query_list.selectedIndex].value == "function_names"){
+		document.getElementById("argument_1").innerHTML = "No arguments required.";
+		document.getElementById("argument_2").innerHTML = "";
+		document.getElementById("function_1").readOnly = true;
+		document.getElementById("function_2").readOnly = true;
+		document.getElementById("function_1").style.visibility = "hidden";
+		document.getElementById("function_2").style.visibility = "hidden";
+		document.getElementById("function_1").value = null;
+		document.getElementById("function_2").value = null;
+	}
+}
+
+
+
+function execute_query(){
+	//Returns error in alert window if query not executed properly, 
+	//otherwise performs the query and outputs it
+	document.getElementById("output_image").src = "";
+	document.getElementById("output_image").alt = "Please wait loading...";
+	var query_id = document.getElementById("query_list").value;
+	if (query_id == "function_names"){
+		//url for page containing all function names
+		var string = "/database_properties?program_name=" + 
+		document.getElementById("program_name").value + "&query=functions";
+	}
+	else{
+		//If not function names we will want a graph as an output; 
+		//url returns svg file of graph.
+		var string = "/output_graph.svg?program_name=" + 
+			document.getElementById("program_name").value + 
+			"&query=" + query_id + "&func1=";
+        string = string + document.getElementById("function_1").value + 
+			"&func2=" + document.getElementById("function_2").value;
+        string = string + "&suppress_common=" + 
+			document.getElementById('suppress_common').checked.toString();
+
+	}
+	var xmlhttp = new XMLHttpRequest();
+		xmlhttp.open("GET", string, true);
+		xmlhttp.send();
+	xmlhttp.onreadystatechange = function(){
+		if (xmlhttp.readyState == 4 && xmlhttp.status == 200){
+			//readyState == 4 means query has finished executing.
+			//status == 200 means "GET"ing has been successful.
+			if (query_id == "function_names"){
+				//Text output displayed in paragraph.
+				document.getElementById("function_names_output").innerHTML = 
+						xmlhttp.responseText;
+				document.getElementById("function_names_output").style.visibility = 
+						"visible"
+				//Clear current image if one exists.
+				document.getElementById("output_image").alt = "";
+				document.getElementById("output_image").src = "";
+			}
+			else{
+				document.getElementById("function_names_output").style.visibility = 
+						"hidden"
+				document.getElementById("output_image").src = string;
+			}
+		}
+		else if (xmlhttp.readyState == 4 && xmlhttp.status == 400){
+			//Error occurred during query; display response.
+			document.getElementById("output_image").alt = "";
+			window.alert(xmlhttp.responseText);
+		}
+		else if(xmlhttp.readyState == 4 && xmlhttp.status == 404){
+			//Error occurred during query; display response.
+			document.getElementById("output_image").alt = "";
+			window.alert(xmlhttp.responseText);
+		}
+		else if(xmlhttp.readyState ==4 && xmlhttp.status == 204){
+			//Query executed correctly but graph returned is empty
+			document.getElementById("output_image").alt = "";
+			window.alert("Graph returned was empty");
+		}
+		else if (xmlhttp.readyState == 4 && xmlhttp.status == 502) {
+		    //Error occurs if Neo4j isn't running
+			document.getElementById("output_image").alt = "";
+			window.alert("Bad Gateway received - are you sure the database server is running?");
+		}
+		else if(xmlhttp.readyState ==4){
+			//query executed correctly
+			document.getElementById("output_image").alt = "";
+			window.alert("Error not recognised");
+		}
+	}
+}
 
=== added file 'resources/web/sextant.gif'
 Binary files resources/web/sextant.gif	1970-01-01 00:00:00 +0000 and resources/web/sextant.gif	2014-08-15 12:04:08 +0000 differ
=== added file 'resources/web/style_sheet.css'
--- resources/web/style_sheet.css	1970-01-01 00:00:00 +0000
+++ resources/web/style_sheet.css	2014-08-15 12:04:08 +0000
@@ -0,0 +1,36 @@
+pre {
+    color: green;
+	background: white;
+	font-family: monospace;
+}
+
+body {
+	font-family: Helvetica, sans-serif;
+}
+.button{
+	display:block; width:100px; height:100px; border-radius:50px; font-size:15px; 
+	color:#fff; line-height:100px; text-align:center; background:#FF0000
+}
+
+.pos_img{
+	position:absolute;
+	left:0px;
+	top:270px;
+	z-index:-1
+	
+}
+.pos_functions{
+	position:absolute;
+	left:0px;
+	top:250px;
+	
+}
+
+.button2{
+	display:inline-block; width:200px; height:100px; border-radius:50px; 
+	font-size:15px; color:#fff; line-height:100px; 
+	text-align:center; background:#000000
+}
+
+
+
 
=== added file 'setup.cfg'
--- setup.cfg	1970-01-01 00:00:00 +0000
+++ setup.cfg	2014-08-15 12:04:08 +0000
@@ -0,0 +1,2 @@
+[metadata]
+description-file = README.md
 \ No newline at end of file
 
=== added file 'setup.py'
--- setup.py	1970-01-01 00:00:00 +0000
+++ setup.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,25 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: James Harkin, using work from Patrick Stevens and James Harkin
+# -----------------------------------------
+#
+
+import glob
+import os
+from setuptools import setup
+
+setup(
+    name='Sextant',
+    version='1.0',
+    description= 'Navigating the C',
+    url='http://open.ensoft.co.uk/Sextant',
+    license='Simplified BSD License',
+    packages=['sextant', 'sextant.web', 'resources', 'etc'],
+    package_dir={'sextant': 'src/sextant', 'resources': 'resources', 'etc': 'etc'},
+    scripts=['bin/sextant'],
+    install_requires=['neo4jrestclient', 'twisted'],
+    package_data={'resources': ['web/*'], 'etc': ['*.conf']},
+)
+
+
 
=== added directory 'src'
=== added directory 'src/sextant'
=== added file 'src/sextant/__init__.py'
--- src/sextant/__init__.py	1970-01-01 00:00:00 +0000
+++ src/sextant/__init__.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,21 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: Patrick Stevens, James Harkin
+# -----------------------------------------
+"""Program call graph recording and query framework."""
+
+from . import errors
+from . import pyinput
+
+__all__ = (
+    "SextantConnection",
+) + (
+    errors.__all__ +
+    pyinput.__all__
+)
+
+from .db_api import SextantConnection
+from .errors import *
+from .pyinput import *
+
 
=== added file 'src/sextant/__main__.py'
--- src/sextant/__main__.py	1970-01-01 00:00:00 +0000
+++ src/sextant/__main__.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,220 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: James Harkin, using work from Patrick Stevens and James Harkin
+# -----------------------------------------
+#invokes Sextant and argparse
+
+from __future__ import absolute_import, print_function
+
+import argparse
+try:
+    import ConfigParser
+except ImportError:
+    import configparser as ConfigParser
+import logging
+import logging.config
+import os
+import sys
+
+from . import update_db
+from . import query
+from . import db_api
+
+
+# @@@ Logging level should be configurable (with some structure to setting up
+# logging).
+logging.config.dictConfig({
+    "version": 1,
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "level": logging.INFO,
+            "stream": "ext://sys.stderr",
+        },
+    },
+    "root": {
+        "level": logging.DEBUG,
+        "handlers": ["console"],
+    },
+})
+log = logging.getLogger()
+
+
+def get_config_file():
+    # get the config file option for neo4j server location and web port number
+    _ROOT = os.path.abspath(os.path.dirname(__file__))
+    def get_data(path, file_name):
+        return os.path.join(_ROOT, path, file_name)
+
+    home_config = os.path.expanduser(os.path.join("~", ".sextant.conf"))
+    env_config = os.environ.get("SEXTANT_CONFIG", "")
+    example_config = get_data('../etc', 'sextant.conf')
+
+    try:
+        conffile = next(p
+                        for p in (home_config, env_config, example_config)
+                        if os.path.exists(p))
+    except StopIteration:
+        #No config files accessable
+        if "SEXTANT_CONFIG" in os.environ:
+            #SEXTANT_CONFIG environment variable is set
+            log.error("SEXTANT_CONFIG file %r doesn't exist.", env_config)
+        log.error("Sextant requires a configuration file.")
+        sys.exit(1)
+
+    log.info("Sextant is using config file %s", conffile)
+    return conffile
+
+conffile = get_config_file()
+
+conf = ConfigParser.ConfigParser()
+conf.read(conffile)
+
+#remote_neo4j = 'http://localhost:7474'
+#web_port = 2905
+#common_def = 10  # definition of a 'common' node
+try:
+    options = conf.options('Neo4j')
+except ConfigParser.NoSectionError:
+    pass
+else:
+    try:
+        remote_neo4j = conf.get('Neo4j', 'remote_neo4j')
+    except ConfigParser.NoOptionError:
+        pass
+
+    try:
+        web_port = conf.get('Neo4j', 'port')
+    except ConfigParser.NoOptionError:
+        pass
+
+    try:
+        common_def = conf.get('Neo4j', 'common_function_calls')
+    except ConfigParser.NoOptionError:
+        common_def = 10
+
+argumentparser = argparse.ArgumentParser(description="Invoke part of the SEXTANT program")
+subparsers = argumentparser.add_subparsers(title="subcommands")
+
+#set what will be defined as a "common function"
+db_api.set_common_cutoff(common_def)
+
+parsers = dict()
+
+# add each subparser in turn to the parsers dictionary
+
+parsers['add'] = subparsers.add_parser('add_program', help="add a program to the database")
+parsers['add'].add_argument('--input-file', required=True, metavar="FILE_NAME",
+                            help="name of file to be put into database",
+                            type=str, nargs=1)
+parsers['add'].add_argument('--set-file-name', metavar="FILE_NAME",
+                            help="string to store this program under", type=str,
+                            nargs=1)
+parsers['add'].add_argument('--not-object-file',
+                            help='default False, if the input file is an object to be disassembled',
+                            action='store_true')
+
+parsers['delete'] = subparsers.add_parser('delete_program',
+                                          help="delete a program from the database")
+parsers['delete'].add_argument('--program-name', required=True, metavar="PROG_NAME",
+                               help="name of program as stored in the database",
+                               type=str, nargs=1)
+
+parsers['query'] = subparsers.add_parser('query',
+                                         help="make a query of the database")
+parsers['query'].add_argument('--program-name', metavar="PROG_NAME",
+                              help="name of program as stored in the database",
+                              type=str, nargs=1)
+parsers['query'].add_argument('--query', required=True, metavar="QUERY",
+                              help="functions-calling, functions-called-by, "
+                                   "calls-between, whole-graph, shortest-path, "
+                                   "return-all-program-names or "
+                                   "return-all-function-names; if the latter, "
+                                   "supply argument --program-name",
+                              type=str, nargs=1)
+parsers['query'].add_argument('--funcs', metavar='FUNCS',
+                              help='functions to pass to the query',
+                              type=str, nargs='+')
+parsers['query'].add_argument('--suppress-common', metavar='BOOL',
+                              help='suppress commonly called functions (True or False)',
+                              type=str, nargs=1)
+
+parsers['web'] = subparsers.add_parser('web', help="start the web server")
+parsers['web'].add_argument('--port', metavar='PORT', type=int,
+                            help='port on which to serve Sextant Web',
+                            default=web_port)
+
+for parser_key in parsers:
+    parsers[parser_key].add_argument('--remote-neo4j', metavar="URL", nargs=1,
+                                     help="URL of neo4j server", type=str,
+                                     default=remote_neo4j)
+
+def _start_web(args):
+    # Don't import at top level -- this makes twisted dependency semi-optional,
+    # allowing non-web functionality to work with Python 3.
+    from .web import server
+    log.info("Serving site on port %s", args.port)
+    server.serve_site(input_database_url=args.remote_neo4j, port=args.port)
+
+parsers['web'].set_defaults(func=_start_web)
+
+def add_file(namespace):
+
+    try:
+        alternative_name = namespace.set_file_name[0]
+    except TypeError:
+        alternative_name = None
+
+    not_object_file = namespace.not_object_file
+    # the default is "yes, this is an object file" if not-object-file was
+    # unsupplied
+    
+    update_db.upload_program(namespace.input_file[0],
+                             namespace.remote_neo4j,
+                             alternative_name, not_object_file)
+
+
+def delete_file(namespace):
+    update_db.delete_program(namespace.program_name[0],
+                             namespace.remote_neo4j)
+
+parsers['add'].set_defaults(func=add_file)
+parsers['delete'].set_defaults(func=delete_file)
+
+
+def make_query(namespace):
+
+    arg1 = None
+    arg2 = None
+    try:
+        arg1 = namespace.funcs[0]
+        arg2 = namespace.funcs[1]
+    except TypeError:
+        pass
+
+    try:
+        program_name = namespace.program_name[0]
+    except TypeError:
+        program_name = None
+
+    try:
+        suppress_common = namespace.suppress_common[0]
+    except TypeError:
+        suppress_common = False
+
+    query.query(remote_neo4j=namespace.remote_neo4j,
+                input_query=namespace.query[0],
+                program_name=program_name, argument_1=arg1, argument_2=arg2,
+                suppress_common=suppress_common)
+
+parsers['query'].set_defaults(func=make_query)
+
+# parse the arguments
+
+parsed = argumentparser.parse_args()
+
+# call the appropriate function
+
+parsed.func(parsed)
+
 
=== added file 'src/sextant/db_api.py'
--- src/sextant/db_api.py	1970-01-01 00:00:00 +0000
+++ src/sextant/db_api.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,610 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: Patrick Stevens, using work from Patrick Stevens and James Harkin
+# -----------------------------------------
+# API to interact with a Neo4J server: upload, query and delete programs in a DB
+
+__all__ = ("Validator", "AddToDatabase", "FunctionQueryResult", "Function",
+           "SextantConnection")
+
+import re  # for validation of function/program names
+import logging
+
+from neo4jrestclient.client import GraphDatabase
+import neo4jrestclient.client as client
+
+COMMON_CUTOFF = 10
+# a function is deemed 'common' if it has more than this
+# many connections
+
+
+class Validator():
+    """ Sanitises/checks strings, to prevent Cypher injection attacks"""
+
+    @staticmethod
+    def validate(input_):
+        """
+        Checks whether we can allow a string to be passed into a Cypher query.
+        :param input_: the string we wish to validate
+        :return: bool(the string is allowed)
+        """
+        regex = re.compile(r'^[A-Za-z0-9\-:\.\$_@\*\(\)%\+,]+$')
+        return bool(regex.match(input_))
+
+    @staticmethod
+    def sanitise(input_):
+        """
+        Strips harmful characters from the given string.
+        :param input_: string to sanitise
+        :return: the sanitised string
+        """
+        return re.sub(r'[^\.\-_a-zA-Z0-9]+', '', input_)
+
+
+class AddToDatabase():
+    """Updates the database, adding functions/calls to a given program"""
+
+    def __init__(self, program_name='', sextant_connection=None):
+        """
+        Object which can be used to add functions and calls to a new program
+        :param program_name: the name of the new program to be created
+          (must already be validated against Validator)
+        :param sextant_connection: the SextantConnection to use for connections
+        """
+        # program_name must be alphanumeric, to avoid injection attacks easily
+        if not Validator.validate(program_name):
+            return
+
+        self.program_name = program_name
+        self.parent_database_connection = sextant_connection
+        self._functions = {}
+        self._new_tx = None
+
+        if self.parent_database_connection:
+            # we'll locally use db for short
+            db = self.parent_database_connection._db
+
+            parent_function = db.nodes.create(name=program_name, type='program')
+            self._parent_id = parent_function.id
+
+            self._new_tx = db.transaction(using_globals=False, for_query=True)
+
+        self._connections = []
+
+    def add_function(self, function_name):
+        """
+        Adds a function to the program, ready to be sent to the remote database.
+        If the function name is already in use, this method effectively does
+          nothing and returns True.
+
+        :param function_name: a string which must be alphanumeric
+        :return: True if the request succeeded, False otherwise
+        """
+        if not Validator.validate(function_name):
+            return False
+        if self.class_contains_function(function_name):
+            return True
+
+        if function_name[-4:] == "@plt":
+            display_name = function_name[:-4]
+            function_group = "plt_stub"
+        elif function_name[:20] == "_._function_pointer_":
+            display_name = function_name
+            function_group = "function_pointer"
+        else:
+            display_name = function_name
+            function_group = "normal"
+
+        query = ('START n = node({}) '
+                 'CREATE (n)-[:subject]->(m:func {{type: "{}", name: "{}"}})')
+        query = query.format(self._parent_id, function_group, display_name)
+
+        self._new_tx.append(query)
+
+        self._functions[function_name] = function_name
+
+        return True
+
+    def class_contains_function(self, function_to_find):
+        """
+        Checks whether we contain a function with a given name.
+        :param function_to_find: string name of the function we wish to look up
+        :return: bool(the function exists in this AddToDatabase)
+        """
+        return function_to_find in self._functions
+
+    def class_contains_call(self, function_calling, function_called):
+        """
+        Checks whether we contain a call between the two named functions.
+        :param function_calling: string name of the calling-function
+        :param function_called: string name of the called function
+        :return: bool(function_calling calls function_called in us)
+        """
+        return (function_calling, function_called) in self._connections
+
+    def add_function_call(self, fn_calling, fn_called):
+        """
+        Adds a function call to the program, ready to be sent to the database.
+        Effectively does nothing if there is already a function call between
+          these two functions.
+        Function names must be alphanumeric for easy security purposes;
+          returns False if they fail validation.
+        :param fn_calling: the name of the calling-function as a string.
+          It should already exist in the AddToDatabase; if it does not,
+          this method will create a stub for it.
+        :param fn_called: name of the function called by fn_calling.
+          If it does not exist, we create a stub representation for it.
+        :return: True if successful, False otherwise
+        """
+        if not all((Validator.validate(fn_calling),
+                    Validator.validate(fn_called))):
+            return False
+
+        if not self.class_contains_function(fn_called):
+            self.add_function(fn_called)
+        if not self.class_contains_function(fn_calling):
+            self.add_function(fn_calling)
+
+        if not self.class_contains_call(fn_calling, fn_called):
+            query = ('START p = node({}) '
+                     'MATCH (p)-[:subject]->(n) WHERE n.name = "{}" '
+                     'MATCH (p)-[:subject]->(m) WHERE m.name = "{}" '
+                     'CREATE (n)-[:calls]->(m)')
+            query = query.format(self._parent_id, fn_calling, fn_called)
+            self._new_tx.append(query)
+
+            self._connections.append((fn_calling, fn_called))
+
+        return True
+
+    def commit(self):
+        """
+        Call this when you are finished with the object.
+        Changes are not synced to the remote database until this is called.
+        """
+        self._new_tx.commit()
+
+
+class FunctionQueryResult:
+    """A graph of function calls arising as the result of a Neo4J query."""
+
+    def __init__(self, parent_db, program_name='', rest_output=None):
+        self.program_name = program_name
+        self._parent_db_connection = parent_db
+        self.functions = self._rest_node_output_to_graph(rest_output)
+        self._update_common_functions()
+
+    def __eq__(self, other):
+        # we make a dictionary so that we can perform easy comparison
+        selfdict = {func.name: func for func in self.functions}
+        otherdict = {func.name: func for func in other.functions}
+
+        return self.program_name == other.program_name and selfdict == otherdict
+
+    def _update_common_functions(self):
+        """
+        Loop over all functions: increment the called-by count of their callees.
+        """
+        for func in self.functions:
+            for called in func.functions_i_call:
+                called.number_calling_me += 1
+
+    def _rest_node_output_to_graph(self, rest_output):
+        """
+        Convert the output of a REST API query into our internal representation.
+        :param rest_output: output of the REST call as a Neo4j QuerySequence
+        :return: iterable of <Function>s ready to initialise self.functions.
+        """
+
+        if rest_output is None or not rest_output.elements:
+            return []
+
+        # how we store this is: a dict
+        #   with keys  'functionname'
+        #   and values [the function object we will use,
+        #               and a set of (function names this function calls),
+        #               and numeric ID of this node in the Neo4J database]
+
+        result = {}
+
+        # initial pass for names of functions
+
+        # if the following assertion failed, we've probably called db.query
+        # to get it to not return client.Node objects, which is wrong.
+        # we attempt to handle this a bit later; this should never arise, but
+        # we can cope with it happening in some cases, like the test suite
+
+        if type(rest_output.elements) is not list:
+            logging.warning('Not a list: {}'.format(type(rest_output.elements)))
+
+        for node_list in rest_output.elements:
+            assert(isinstance(node_list, list))
+            for node in node_list:
+                if isinstance(node, client.Node):
+                    name = node.properties['name']
+                    node_id = node.id
+                    node_type = node.properties['type']
+                else:  # this is the handling we mentioned earlier;
+                    # we are a dictionary instead of a list, as for some
+                    # reason we've returned Raw rather than Node data.
+                    # We should never reach this code, but just in case.
+                    name = node['data']['name']
+                    # hacky workaround to get the id
+                    node_id = node['self'].split('/')[-1]
+                    node_type = node['data']['type']
+
+                result[name] = [Function(self.program_name,
+                                         function_name=name,
+                                         function_type=node_type),
+                                set(),
+                                node_id]
+
+        # end initialisation of names-dictionary
+
+        if self._parent_db_connection is not None:
+            # This is the normal case, of extracting results from a server.
+            # We leave the other case in because it is useful for unit testing.
+
+            # We collect the name-name pairs of caller-callee, batched for speed
+            new_tx = self._parent_db_connection.transaction(using_globals=False,
+                                                            for_query=True)
+            for index in result:
+                q = ("START n=node({})"
+                     "MATCH n-[calls:calls]->(m)"
+                     "RETURN n.name, m.name").format(result[index][2])
+                new_tx.append(q)
+
+            logging.debug('exec')
+            results = new_tx.execute()
+
+            # results is a list of query results, each of those being a list of
+            # calls.
+
+            for call_list in results:
+                if call_list:
+                    # call_list has element 0 being an arbitrary call this
+                    # function makes; element 0 of that call is the name of the
+                    # function itself. Think {{'orig', 'b'}, {'orig', 'c'}}.
+                    orig = call_list[0][0]
+                    # result['orig'] is [<Function>, ('callee1','callee2')]
+                    result[orig][1] |= set(list(zip(*call_list.elements))[1])
+                    # recall: set union is denoted by |
+
+        else:
+            # we don't have a parent database connection.
+            # This has probably arisen because we created this object from a
+            # test suite, or something like that.
+            for node in rest_output.elements:
+                node_name = node[0].properties['name']
+                result[node_name][1] |= {relationship.end.properties['name']
+                                         for relationship in node[0].relationships.outgoing()}
+
+        logging.debug('Relationships complete.')
+
+        # named_function takes a function name and returns the Function object
+        # with that name, or None if none exists.
+        named_function = lambda name: result[name][0] if name in result else None
+
+        for function, calls, node_id in result.values():
+            what_i_call = [named_function(name)
+                           for name in calls
+                           if named_function(name) is not None]
+            function.functions_i_call = what_i_call
+
+        return [list_element[0]
+                for list_element in result.values()
+                if list_element[0]]
+
+    def get_functions(self):
+        """
+        :return: a list of Function objects present in the query result
+        """
+        return self.functions
+
+    def get_function(self, name):
+        """
+        Given a function name, returns the Function object which has that name.
+        If no function with that name exists, returns None.
+        """
+        func_list = [func for func in self.functions if func.name == name]
+        return None if len(func_list) == 0 else func_list[0]
+
+
+def set_common_cutoff(common_def):
+    """
+    Sets the number of incoming connections at which we deem a function 'common'
+    Default is 10 (which is used if this method is never called).
+    :param common_def: number of incoming connections
+    """
+    global COMMON_CUTOFF
+    COMMON_CUTOFF = common_def
+
+
+class Function(object):
+    """Represents a function which might appear in a FunctionQueryResult."""
+
+    def __eq__(self, other):
+        funcs_i_call_list = {func.name for func in self.functions_i_call}
+        funcs_other_calls_list = {func.name for func in other.functions_i_call}
+
+        return (self.parent_program == other.parent_program
+                and self.name == other.name
+                and funcs_i_call_list == funcs_other_calls_list
+                and self.attributes == other.attributes)
+
+    @property
+    def number_calling_me(self):
+        return self._number_calling_me
+
+    @number_calling_me.setter
+    def number_calling_me(self, value):
+        self._number_calling_me = value
+        self.is_common = (self._number_calling_me > COMMON_CUTOFF)
+
+    def __init__(self, program_name='', function_name='', function_type=''):
+        self.parent_program = program_name
+        self.attributes = []
+        self.type = function_type
+        self.functions_i_call = []
+        self.name = function_name
+        self.is_common = False
+        self._number_calling_me = 0
+        # care: _number_calling_me is not automatically updated, except by
+        # any invocation of FunctionQueryResult._update_common_functions.
+
+
+class SextantConnection:
+    """
+    RESTful connection to a remote database.
+    It can be used to create/delete/query programs.
+    """
+
+    def __init__(self, url):
+        self.url = url
+        self._db = GraphDatabase(url)
+
+    def new_program(self, name_of_program):
+        """
+        Request that the remote database create a new program with the given name.
+        This procedure will create a new program remotely; you can manipulate
+          that program using the returned AddToDatabase object.
+        The name can appear in the database already, but this is not recommended
+          because then delete_program will not know which to delete. Check first
+          using self.check_program_exists.
+        The name specified must pass Validator.validate()ion; this is a measure
+          to prevent Cypher injection attacks.
+        :param name_of_program: string program name
+        :return: AddToDatabase instance if successful
+        """
+
+        if not Validator.validate(name_of_program):
+            raise ValueError(
+                "{} is not a valid program name".format(name_of_program))
+
+        return AddToDatabase(sextant_connection=self,
+                             program_name=name_of_program)
+
+    def delete_program(self, name_of_program):
+        """
+        Request that the remote database delete a specified program.
+        :param name_of_program: a string which must be alphanumeric only
+        :return: bool(request succeeded)
+        """
+        if not Validator.validate(name_of_program):
+            return False
+
+        q = """MATCH (n) WHERE n.name= "{}" AND n.type="program"
+        OPTIONAL MATCH (n)-[r]-(b) OPTIONAL MATCH (b)-[rel]-()
+        DELETE  b,rel DELETE n, r""".format(name_of_program)
+
+        self._db.query(q)
+
+        return True
+
+    def _execute_query(self, prog_name='', query=''):
+        """
+        Executes a Cypher query against the remote database.
+        Note that this returns a FunctionQueryResult, so is unsuitable for any
+          other expected outputs (such as lists of names). For those instances,
+          it is better to run self._parent_database_connection_object.query
+          explicitly.
+        Intended only to be used for non-updating queries
+          (such as "get functions" rather than "create").
+        :param prog_name: name of the program the result object will reflect
+        :param query: verbatim query we wish the server to execute
+        :return: a FunctionQueryResult corresponding to the server's output
+        """
+        rest_output = self._db.query(query, returns=client.Node)
+
+        return FunctionQueryResult(parent_db=self._db,
+                                   program_name=prog_name,
+                                   rest_output=rest_output)
+
+    def get_program_names(self):
+        """
+        Execute query to retrieve a list of all programs in the database.
+        Any name in this list can be used verbatim in any SextantConnection
+          method which requires a program-name input.
+        :return: a list of function-name strings.
+        """
+        q = """MATCH (n) WHERE n.type = "program" RETURN n.name"""
+        program_names = self._db.query(q, returns=str).elements
+
+        result = [el[0] for el in program_names]
+
+        return set(result)
+
+    def check_program_exists(self, program_name):
+        """
+        Execute query to check whether a program with the given name exists.
+        Returns False if the program_name fails validation against Validator.
+        :return: bool(the program exists in the database).
+        """
+
+        if not Validator.validate(program_name):
+            return False
+
+        q = ("MATCH (base) WHERE base.name = '{}' AND base.type = 'program' "
+             "RETURN count(base)").format(program_name)
+
+        result = self._db.query(q, returns=int)
+        return result.elements[0][0] > 0
+
+    def check_function_exists(self, program_name, function_name):
+        """
+        Execute query to check whether a function with the given name exists.
+        We only check for functions which are children of a program with the
+          given program_name.
+        :param program_name: string name of the program within which to check
+        :param function_name: string name of the function to check for existence
+        :return: bool(names validate correctly, and function exists in program)
+        """
+        if not self.check_program_exists(program_name):
+            return False
+
+        if not Validator.validate(program_name):
+            return False
+
+        q = ("MATCH (base) WHERE base.name = '{}' AND base.type = 'program'"
+             "MATCH (base)-[r:subject]->(m) WHERE m.name = '{}'"
+             "RETURN count(m)").format(program_name, function_name)
+
+        result = self._db.query(q, returns=int)
+        return result.elements[0][0] > 0
+
+    def get_function_names(self, program_name):
+        """
+        Execute query to retrieve a list of all functions in the program.
+        Any of the output names can be used verbatim in any SextantConnection
+          method which requires a function-name input.
+        :param program_name: name of the program whose functions to retrieve
+        :return: None if program_name doesn't exist in the remote database,
+          a set of function-name strings otherwise.
+        """
+
+        if not self.check_program_exists(program_name):
+            return None
+
+        q = ("MATCH (base) WHERE base.name = '{}' AND base.type = 'program' "
+             "MATCH (base)-[r:subject]->(m) "
+             "RETURN  m.name").format(program_name)
+        return {func[0] for func in self._db.query(q)}
+
+    def get_all_functions_called(self, program_name, function_calling):
+        """
+        Execute query to find all functions called by a function (indirectly).
+        If the given function is not present in the program, returns None;
+          likewise if the program_name does not exist.
+        :param program_name: a string name of the program we wish to query under
+        :param function_calling: string name of a function whose children to find
+        :return: FunctionQueryResult, maximal subgraph rooted at function_calling
+        """
+
+        if not self.check_program_exists(program_name):
+            return None
+
+        if not self.check_function_exists(program_name, function_calling):
+            return None
+
+        q = """MATCH (base) WHERE base.name = '{}' ANd base.type = 'program'
+            MATCH (base)-[:subject]->(m) WHERE m.name='{}'
+            MATCH (m)-[:calls*]->(n)
+            RETURN distinct n, m""".format(program_name, function_calling)
+
+        return self._execute_query(program_name, q)
+
+    def get_all_functions_calling(self, program_name, function_called):
+        """
+        Execute query to find all functions which call a function (indirectly).
+        If the given function is not present in the program, returns None;
+          likewise if the program_name does not exist.
+        :param program_name: a string name of the program we wish to query
+        :param function_called: string name of a function whose parents to find
+        :return: FunctionQueryResult, maximal connected subgraph with leaf function_called
+        """
+
+        if not self.check_program_exists(program_name):
+            return None
+
+        if not self.check_function_exists(program_name, function_called):
+            return None
+
+        q = """MATCH (base) WHERE base.name = '{}' AND base.type = 'program'
+            MATCH (base)-[r:subject]->(m) WHERE m.name='{}'
+            MATCH (n)-[:calls*]->(m) WHERE n.name <> '{}'
+            RETURN distinct n , m"""
+        q = q.format(program_name, function_called, program_name)
+
+        return self._execute_query(program_name, q)
+
+    def get_call_paths(self, program_name, function_calling, function_called):
+        """
+        Execute query to find all possible routes between two specific nodes.
+        If the given functions are not present in the program, returns None;
+          ditto if the program_name does not exist.
+        :param program_name: string program name
+        :param function_calling: string
+        :param function_called: string
+        :return: FunctionQueryResult, the union of all subgraphs reachable by
+          adding a source at function_calling and a sink at function_called.
+        """
+
+        if not self.check_program_exists(program_name):
+            return None
+
+        if not self.check_function_exists(program_name, function_called):
+            return None
+
+        if not self.check_function_exists(program_name, function_calling):
+            return None
+
+        q = r"""MATCH (pr) WHERE pr.name = '{}' AND pr.type = 'program'
+                MATCH p=(start {{name: "{}" }})-[:calls*]->(end {{name:"{}"}})
+                  WHERE (pr)-[:subject]->(start)
+                WITH DISTINCT nodes(p) AS result
+                UNWIND result AS answer
+                RETURN answer"""
+        q = q.format(program_name, function_calling, function_called)
+
+        return self._execute_query(program_name, q)
+
+    def get_whole_program(self, program_name):
+        """Execute query to find the entire program with a given name.
+        If the program is not present in the remote database, returns None.
+        :param: program_name: a string name of the program we wish to return.
+        :return: a FunctionQueryResult consisting of the program graph.
+        """
+
+        if not self.check_program_exists(program_name):
+            return None
+
+        query = """MATCH (base) WHERE base.name = '{}' AND base.type = 'program'
+                MATCH (base)-[subject:subject]->(m)
+                RETURN DISTINCT (m)""".format(program_name)
+
+        return self._execute_query(program_name, query)
+
+    def get_shortest_path_between_functions(self, program_name, func1, func2):
+        """
+        Execute query to get a single, shortest, path between two functions.
+        :param program_name: string name of the program we wish to search under
+        :param func1: the name of the originating function of our shortest path
+        :param func2: the name of the function at which to terminate the path
+        :return: FunctionQueryResult shortest path between func1 and func2.
+        """
+        if not self.check_program_exists(program_name):
+            return None
+
+        if not self.check_function_exists(program_name, func1):
+            return None
+
+        if not self.check_function_exists(program_name, func2):
+            return None
+
+        q = """MATCH (func1 {{ name:"{}" }}),(func2 {{ name:"{}" }}),
+            p = shortestPath((func1)-[:calls*]->(func2))
+            UNWIND nodes(p) AS ans
+            RETURN ans""".format(func1, func2)
+
+        return self._execute_query(program_name, q)
 
=== added file 'src/sextant/errors.py'
--- src/sextant/errors.py	1970-01-01 00:00:00 +0000
+++ src/sextant/errors.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,20 @@
+# -----------------------------------------------------------------------------
+# errors.py -- Sextant error definitions
+#
+# August 2014, Phil Connell
+#
+# Copyright 2014, Ensoft Ltd.
+# -----------------------------------------------------------------------------
+
+from __future__ import absolute_import, print_function
+
+__all__ = (
+    "MissingDependencyError",
+)
+
+
+class MissingDependencyError(Exception):
+    """
+    Raised if trying an operation for which an optional dependency is missing.
+    """
+
 
=== added file 'src/sextant/export.py'
--- src/sextant/export.py	1970-01-01 00:00:00 +0000
+++ src/sextant/export.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,152 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: Patrick Stevens,  James Harkin
+# -----------------------------------------
+# Convert a program from internal Python representation to various output formats
+
+__all__ = "ProgramConverter"
+
+
+class ProgramConverter:
+    # Given our internal program representation, converts it to output formats.
+    # Currently supported: GraphML
+
+    @staticmethod
+    def get_supported_outputs():
+        return ['graphml', 'yed_graphml', 'dot']
+
+    @staticmethod
+    def get_display_name(function, suppress_common_nodes=False):
+        """
+        Given a Function object, retrieve the label we attach to it.
+        For instance, function-pointers are labelled "(function pointer)",
+        while the `main` function is usually labelled "main".
+        """
+        if function.type == "function_pointer":
+            name = "(function pointer)"
+        else:
+            name = function.name
+        
+        if suppress_common_nodes and function.is_common:
+            name += ' (common)'
+        return name
+
+    @staticmethod
+    def to_dot(program, suppress_common_nodes=False):
+        """
+        Convert the program to DOT output format.
+        """
+        output_str = 'digraph "{}" {{\n '.format(program.program_name)
+        output_str += 'overlap=false; \n'
+
+        font_name = "helvetica"
+
+        for func in program.get_functions():
+            if func.type == "plt_stub":
+                output_str += ' "{}" [fillcolor=pink, style=filled]\n'.format(func.name)
+            elif func.type == "function_pointer":
+                output_str += ' "{}" [fillcolor=yellow, style=filled]\n'.format(func.name)
+
+            # in all cases, even if we've specified that we want a filled-in
+            # node already, DOT lets us add more information about that node
+            # so we can insist on turning that same node into a box-shape
+            # and changing its font.
+            output_str += ' "{}" [label="{}", fontname="{}", shape=box]\n'.format(func.name,
+                                                                                  ProgramConverter.get_display_name(func, suppress_common_nodes),
+                                                                                  font_name)
+            if func.is_common:
+                output_str += ' "{}" [fillcolor=lightgreen, style=filled]\n'.format(func.name)
+
+            for func_called in func.functions_i_call:
+                if not (suppress_common_nodes and func_called.is_common):
+                    output_str += ' "{}" -> "{}"\n'.format(func.name, func_called.name)
+
+        output_str += '}'
+        return output_str
+
+
+
+    @staticmethod
+    def to_yed_graphml(program, suppress_common_nodes=False):
+        commonly_called = []
+        output_str = """<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \
+xmlns:y="http://www.yworks.com/xml/graphml" xmlns:yed="http://www.yworks.com/xml/yed/3" \
+xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://www.yworks.com/xml/schema/graphml/1.1/ygraphml.xsd">
+"""
+        output_str += """<key for="graphml" id="d0" yfiles.type="resources"/>
+                        <key for="port" id="d1" yfiles.type="portgraphics"/>
+                        <key for="port" id="d2" yfiles.type="portgeometry"/>
+                        <key for="port" id="d3" yfiles.type="portuserdata"/>
+                        <key attr.name="url" attr.type="string" for="node" id="d4"/>
+                        <key attr.name="description" attr.type="string" for="node" id="d5"/>
+                        <key for="node" id="d6" yfiles.type="nodegraphics"/>
+                        <key attr.name="url" attr.type="string" for="edge" id="d7"/>
+                        <key attr.name="description" attr.type="string" for="edge" id="d8"/>
+                        <key for="edge" id="d9" yfiles.type="edgegraphics"/>\n"""
+
+        output_str += """<graph id="{}" edgedefault="directed">\n""".format(program.program_name)
+
+        for func in program.get_functions():
+            display_func = ProgramConverter.get_display_name(func)
+            if func.type == "plt_stub":
+                colour = "#ff00ff"
+            elif func.type == "function_pointer":
+                colour = "#99ffff"
+            elif func.is_common:
+                colour = "#00FF00"
+            else:
+                colour = "#ffcc00"
+            output_str += """<node id="{}">
+                                <data key="d6">
+                                    <y:ShapeNode>
+                                        <y:Geometry height="{}" width="{}" x="60.0" y="0.0"/>
+                                      <y:Fill color="{}" transparent="false"/>
+                                      <y:BorderStyle color="#000000" type="line" width="1.0"/>
+                                      <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog"
+                                      fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false"
+                                      height="18.701171875" modelName="custom" textColor="#000000" visible="true"
+                                      width="36.6953125" x="-3.34765625" y="5.6494140625">{}<y:LabelModel>
+                                          <y:SmartNodeLabelModel distance="4.0"/>
+                                        </y:LabelModel>
+                                        <y:ModelParameter>
+                                          <y:SmartNodeLabelModelParameter labelRatioX="0.0" labelRatioY="0.0"
+                                          nodeRatioX="0.0" nodeRatioY="0.0" offsetX="0.0" offsetY="0.0" upX="0.0"
+                                          upY="-1.0"/>
+                                        </y:ModelParameter>
+                                      </y:NodeLabel>
+                                      <y:Shape type="rectangle"/>
+                                    </y:ShapeNode>
+                                </data> 
+                                </node>\n""".format(func.name, 20, len(display_func)*8, colour, display_func)
+            for callee in func.functions_i_call:
+                if callee not in commonly_called:
+                    if not(suppress_common_nodes and callee.is_common):
+                            output_str += """<edge source="{}" target="{}"> <data key="d9">
+                                        <y:PolyLineEdge>
+                                        <y:LineStyle color="#000000" type="line" width="1.0"/>
+                                        <y:Arrows source="none" target="standard"/>
+                                        <y:BendStyle smoothed="false"/>
+                                        </y:PolyLineEdge>
+                                        </data>
+                                     </edge>\n""".format(func.name, callee.name)
+
+        output_str += '</graph>\n<data key="d0">    <y:Resources/>  </data>\n</graphml>'
+        return output_str
+
+    @staticmethod
+    def to_graphml(program):
+        output_str = """<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \
+xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+"""
+        output_str += '<graph id="{}" edgedefault="directed">\n'.format(program.program_name)
+
+        for func in program.get_functions():
+            output_str += '<node id="{}"> <data key="name">{}</data> </node>\n'.format(func.name, ProgramConverter.get_display_name(func))
+            for callee in func.functions_i_call:
+                output_str += '<edge source="{}" target="{}"> <data key="calls">1</data> </edge>\n'.format(func.name, callee.name)
+
+        output_str += '</graph>\n</graphml>'
+        return output_str
 \ No newline at end of file
 
=== added file 'src/sextant/objdump_parser.py'
--- src/sextant/objdump_parser.py	1970-01-01 00:00:00 +0000
+++ src/sextant/objdump_parser.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,272 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: Patrick Stevens
+# -----------------------------------------
+
+#!/usr/bin/python3
+
+import re
+import argparse
+import os.path
+import subprocess
+import logging
+
+
+class ParsedObject():
+    """
+    Represents a function as parsed from an objdump disassembly.
+    Has a name (which is the verbatim name like '__libc_start_main@plt'),
+        a position (which is the virtual memory location in hex, like '08048320'
+                    extracted from the dump),
+        and a canonical_position (which is the virtual memory location in hex
+                                  but stripped of leading 0s, so it should be a
+                                  unique id).
+    It also has a list what_do_i_call of ParsedObjects it calls using the
+      assembly keyword 'call'.
+    It has a list original_code of its assembler code, too, in case it's useful.
+    """
+
+    @staticmethod
+    def get_canonical_position(position):
+        return position.lstrip('0')
+
+    def __eq__(self, other):
+        return self.name == other.name
+
+    def __init__(self, input_lines=None, assembler_section='', function_name='',
+                 ignore_function_pointers=True, function_pointer_id=None):
+        """
+        Create a new ParsedObject given the definition-lines from objdump -S.
+        A sample first definition-line is '08048300 <__gmon_start__@plt>:\n'
+         but this method
+         expects to see the entire definition eg
+
+080482f0 <puts@plt>:
+ 80482f0:	ff 25 00 a0 04 08    	jmp    *0x804a000
+ 80482f6:	68 00 00 00 00       	push   $0x0
+ 80482fb:	e9 e0 ff ff ff       	jmp    80482e0 <_init+0x30>
+
+          We also might expect assembler_section, which is for instance '.init'
+            in 'Disassembly of section .init:'
+          function_name is used if we want to give this function a custom name.
+          ignore_function_pointers=True will pretend that calls to (eg) *eax do
+            not exist; setting to False makes us create stubs for those calls.
+          function_pointer_id is only used internally; it refers to labelling
+            of function pointers if ignore_function_pointers is False. Each
+            stub is given a unique numeric ID: this parameter tells init where
+            to start counting these IDs from.
+
+        """
+        if input_lines is None:
+            # get around Python's inability to pass in empty lists by value
+            input_lines = []
+
+        self.name = function_name or re.search(r'<.+>', input_lines[0]).group(0).strip('<>')
+        self.what_do_i_call = []
+        self.position = ''
+
+        if input_lines:
+            self.position = re.search(r'^[0-9a-f]+', input_lines[0]).group(0)
+            self.canonical_position = ParsedObject.get_canonical_position(self.position)
+            self.assembler_section = assembler_section
+            self.original_code = input_lines[1:]
+            
+            call_regex_compiled = (ignore_function_pointers and re.compile(r'\tcall. +[^\*]+\n')) or re.compile(r'\tcall. +.+\n')
+
+            lines_where_i_call = [line for line in input_lines if call_regex_compiled.search(line)]
+
+            if not ignore_function_pointers and not function_pointer_id:
+                function_pointer_id = [1]
+
+            for line in lines_where_i_call:
+                # we'll catch call and callq for the moment
+                called = (call_regex_compiled.search(line).group(0))[8:].lstrip(' ').rstrip('\n')
+                if called[0] == '*' and ignore_function_pointers == False:
+                    # we have a function pointer, which we'll want to give a distinct name
+                    address = '0'
+                    name = '_._function_pointer_' + str(function_pointer_id[0])
+                    function_pointer_id[0] += 1
+
+                    self.what_do_i_call.append((address, name))
+
+                else: # we're not on a function pointer
+                    called_split = called.split(' ')
+                    if len(called_split) == 2:
+                        address, name = called_split
+                        name = name.strip('<>')
+                        # we still want to remove address offsets like +0x09 from the end of name
+                        match = re.match(r'^.+(?=\+0x[a-f0-9]+$)', name)
+                        if match is not None:
+                            name = match.group(0)
+                        self.what_do_i_call.append((address, name.strip('<>')))
+                    else:  # the format of the "what do i call" is not recognised as a name/address pair
+                        self.what_do_i_call.append(tuple(called_split))
+
+    def __str__(self):
+        if self.position:
+            return 'Memory address ' + self.position + ' with name ' + self.name + ' in section ' + str(
+                self.assembler_section)
+        else:
+            return 'Name ' + self.name
+
+    def __repr__(self):
+        out_str = 'Disassembly of section ' + self.assembler_section + ':\n\n' + self.position + ' ' + self.name + ':\n'
+        return out_str + '\n'.join([' ' + line for line in self.original_code])
+
+
+class Parser:
+    # Class to manipulate the output of objdump
+
+    def __init__(self, input_file_location='', file_contents=None, sections_to_view=None, ignore_function_pointers=False):
+        """Creates a new Parser, given an input file path. That path should be an output from objdump -D.
+        Alternatively, supply file_contents, as a list of each line of the objdump output. We expect newlines
+         to have been stripped from the end of each of these lines.
+         sections_to_view makes sure we only use the specified sections (use [] for 'all sections' and None for none).
+        """
+        if file_contents is None:
+            file_contents = []
+
+        if sections_to_view is None:
+            sections_to_view = []
+
+        if input_file_location:
+            file_to_read = open(input_file_location, 'r')
+            self.source_string_list = [line for line in file_to_read]
+            file_to_read.close()
+        elif file_contents:
+            self.source_string_list = [string + '\n' for string in file_contents]
+        self.parsed_objects = []
+        self.sections_to_view = sections_to_view
+        self.ignore_function_pointers = ignore_function_pointers
+        self.pointer_identifier = [1]
+
+    def create_objects(self):
+        """ Go through the source_string_list, getting object names (like 'main') along with the corresponding
+         definitions, and put them into parsed_objects """
+        if self.sections_to_view is None:
+            return
+
+        is_in_section = lambda name: self.sections_to_view == [] or name in self.sections_to_view
+
+        parsed_objects = []
+        current_object = []
+        current_section = ''
+        regex_compiled_addr_and_name = re.compile(r'[0-9a-f]+ <.+>:\n')
+        regex_compiled_section = re.compile(r'section .+:\n')
+
+        for line in self.source_string_list[4:]:  # we bodge, since the file starts with a little bit of guff
+            if regex_compiled_addr_and_name.match(line):
+                # we are a starting line
+                current_object = [line]
+            elif re.match(r'Disassembly of section', line):
+                current_section = regex_compiled_section.search(line).group(0).lstrip('section ').rstrip(':\n')
+                current_object = []
+            elif line == '\n':
+                # we now need to stop parsing the current block, and store it
+                if len(current_object) > 0 and is_in_section(current_section):
+                    parsed_objects.append(ParsedObject(input_lines=current_object, assembler_section=current_section,
+                                                       ignore_function_pointers=self.ignore_function_pointers,
+                                                       function_pointer_id=self.pointer_identifier))
+            else:
+                current_object.append(line)
+
+        # now we should be done. We assumed that blocks begin with r'[0-9a-f]+ <.+>:\n' and end with a newline.
+        # clear duplicates:
+
+        self.parsed_objects = []
+        for obj in parsed_objects:
+            if obj not in self.parsed_objects: # this is so that if we jump into the function at an offset,
+                # we still register it as being the old function, not some new function at a different address
+                # with the same name
+                self.parsed_objects.append(obj)
+
+                # by this point, each object contains a self.what_do_i_call which is a list of tuples
+                #  ('address', 'name') if the address and name were recognised, or else (thing1, thing2, ...)
+                # where the instruction was call thing1 thing2 thing3... .
+
+    def object_lookup(self, object_name='', object_address=''):
+        """Returns the object with name object_name or address object_address (at least one must be given).
+        If objects with the given name or address
+        are not found, returns None."""
+
+        if object_name == '' and object_address == '':
+            return None
+
+        trial_obj = self.parsed_objects
+
+        if object_name != '':
+            trial_obj = [obj for obj in trial_obj if obj.name == object_name]
+
+        if object_address != '':
+            trial_obj = [obj for obj in trial_obj if
+                         obj.canonical_position == ParsedObject.get_canonical_position(object_address)]
+
+        if len(trial_obj) == 0:
+            return None
+
+        return trial_obj
+
+def get_parsed_objects(filepath, sections_to_view, not_object_file, readable=False, ignore_function_pointers=False):
+    if sections_to_view is None:
+        sections_to_view = []  # because we use None for "no sections"; the intent of not providing any sections
+        # on the command line was to look at all sections, not none
+
+    # first, check whether the given file exists
+    if not os.path.isfile(filepath):
+        logging.error('Input file does not exist')
+        return False
+
+    #now the file should exist
+    if not not_object_file:  #if it is something we need to run through objdump first
+        #we need first to run the object file through objdump
+
+        objdump_file_contents = subprocess.check_output(['objdump', '-D', filepath])
+        objdump_str = objdump_file_contents.decode('utf-8')
+
+        p = Parser(file_contents=objdump_str.split('\n'), sections_to_view=sections_to_view, ignore_function_pointers=ignore_function_pointers)
+    else:
+        try:
+            p = Parser(input_file_location=filepath, sections_to_view=sections_to_view, ignore_function_pointers=ignore_function_pointers)
+        except UnicodeDecodeError:
+            logging.error('File could not be parsed as a string. Did you mean to supply --object-file?')
+            return False
+
+    if readable: # if we're being called from the command line
+        print('File read; beginning parse.')
+    #file is now read, and we start parsing
+
+    p.create_objects()
+    return p.parsed_objects
+
+def main():
+    argumentparser = argparse.ArgumentParser(description="Parse the output of objdump.")
+    argumentparser.add_argument('--filepath', metavar="FILEPATH", help="path to input file", type=str, nargs=1)
+    argumentparser.add_argument('--not-object-file', help="import text objdump output instead of the compiled file", default=False,
+                                action='store_true')
+    argumentparser.add_argument('--sections-to-view', metavar="SECTIONS",
+                                help="sections of disassembly to view, like '.text'; leave blank for 'all'",
+                                type=str, nargs='*')
+    argumentparser.add_argument('--ignore-function-pointers', help='whether to skip parsing calls to function pointers', action='store_true', default=False)
+
+    parsed = argumentparser.parse_args()
+    
+    filepath = parsed.filepath[0]
+    sections_to_view = parsed.sections_to_view
+    not_object_file = parsed.not_object_file
+    readable = True
+    function_pointers = parsed.ignore_function_pointers
+
+    parsed_objs = get_parsed_objects(filepath, sections_to_view, not_object_file, readable, function_pointers)
+    if parsed_objs is False:
+        return 1
+
+    if readable:
+        for named_function in parsed_objs:
+            print(named_function.name)
+            print([f[-1] for f in named_function.what_do_i_call])  # use [-1] to get the last element, since:
+        #either we are in ('address', 'name'), when we want the last element, or else we are in (thing1, thing2, ...)
+        #so for the sake of argument we'll take the last thing
+
+if __name__ == "__main__":
+    main()
 
=== added file 'src/sextant/pyinput.py'
--- src/sextant/pyinput.py	1970-01-01 00:00:00 +0000
+++ src/sextant/pyinput.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,180 @@
+# -----------------------------------------------------------------------------
+# pyinput.py -- Input information from Python programs.
+#
+# August 2014, Phil Connell
+#
+# Copyright 2014, Ensoft Ltd.
+# -----------------------------------------------------------------------------
+
+from __future__ import absolute_import, print_function
+
+__all__ = (
+    "trace",
+)
+
+
+import contextlib
+import sys
+
+from . import errors
+from . import db_api
+
+
+# Optional, should be checked at API entrypoints requiring entrails (and
+# yes, the handling is a bit fugly).
+try:
+    import entrails
+except ImportError:
+    _entrails_available = False
+    class entrails:
+        EntrailsOutput = object
+else:
+    _entrails_available = True
+
+
+class _SextantOutput(entrails.EntrailsOutput):
+    """Record calls traced by entrails in a sextant database."""
+
+    # Internal attributes:
+    #
+    # _conn:
+    #   Sextant connection.
+    # _fns:
+    #   Stack of function names (implemented as a list), reflecting the current
+    #   call stack, based on enter, exception and exit events.
+    # _prog:
+    #   Sextant program representation.
+    _conn = None
+    _fns = None
+    _prog = None
+
+    def __init__(self, conn, program_name):
+        """
+        Initialise this output.
+
+        conn:
+            Connection to the Sextant database.
+        program_name:
+            String used to refer to the traced program in sextant.
+
+        """
+        self._conn = conn
+        self._fns = []
+        self._prog = self._conn.new_program(program_name)
+        self._tracer = self._trace()
+        next(self._tracer)
+
+    def _add_frame(self, event):
+        """Add a function call to the internal stack."""
+        name = event.qualname()
+        self._fns.append(name)
+        self._prog.add_function(name)
+
+        try:
+            prev_name = self._fns[-2]
+        except IndexError:
+            pass
+        else:
+            self._prog.add_function_call(prev_name, name)
+
+    def _remove_frame(self, event):
+        """Remove a function call from the internal stack."""
+        assert event.qualname() == self._fns[-1], \
+                "Unexpected event for {}".format(event.qualname())
+        self._fns.pop()
+
+    def _handle_simple_event(self, what, event):
+        """Handle a single trace event, not needing recursive processing."""
+        handled = True
+
+        if what == "enter":
+            self._add_frame(event)
+        elif what == "exit":
+            self._remove_frame(event)
+        else:
+            handled = False
+
+        return handled
+
+    def _trace(self):
+        """Coroutine that processes trace events it's sent."""
+        while True:
+            what, event = yield
+
+            handled = self._handle_simple_event(what, event)
+            if not handled:
+                if what == "exception":
+                    # An exception doesn't necessarily mean the current stack
+                    # frame is exiting. Need to check whether the next event is
+                    # an exception in a different stack frame, implying that
+                    # the exception is propagating up the stack.
+                    while True:
+                        prev_event = event
+                        prev_name = event.qualname()
+                        what, event = yield
+                        if event == "exception":
+                            if event.qualname() != prev_name:
+                                self._remove_frame(prev_event)
+                        else:
+                            handled = self._handle_simple_event(what, event)
+                            assert handled
+                            break
+
+                else:
+                    raise NotImplementedError
+
+    def close(self):
+        self._prog.commit()
+
+    def enter(self, event):
+        self._tracer.send(("enter", event))
+
+    def exception(self, event):
+        self._tracer.send(("exception", event))
+
+    def exit(self, event):
+        self._tracer.send(("exit", event))
+
+
+# @@@ config parsing shouldn't be done in __main__ (we want to get the neo4j
+# url from there...)
[e-mail]
+def trace(conn, program_name=None, filters=None):
+    """
+    Context manager that records function calls in its context block.
+
+    e.g. given this code:
+
+        with sextant.trace("http://localhost:7474"):
+            foo()
+            bar()
+
+    The calls to foo() and bar() (and their callees, at any depth) will be
+    recorded in the sextant database.
+
+    conn:
+        Instance of SextantConnection that will be used to record calls.
+    program_name:
+        String used to refer to the traced program in sextant. Defaults to
+        sys.argv[0].
+    filters:
+        Optional iterable of entrails filters to apply.
+
+    """
+    if not _entrails_available:
+        raise errors.MissingDependencyError(
+            "Entrails is required to trace execution")
+
+    if program_name is None:
+        program_name = sys.argv[0]
+
+    tracer = entrails.Entrails(filters=filters)
+    tracer.add_output(_SextantOutput(conn, program_name))
+
+    tracer.start_trace()
+    try:
+        yield
+    finally:
+        # Flush traced data.
+        tracer.end_trace()
+
 
=== added file 'src/sextant/query.py'
--- src/sextant/query.py	1970-01-01 00:00:00 +0000
+++ src/sextant/query.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,113 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: James Harkin, Patrick Stevens
+# -----------------------------------------
+#API for performing queries on the database
+
+#!/usr/bin/python3
+import argparse
+import requests, urllib  # for different kinds of exception
+import logging
+
+from . import db_api
+from .export import ProgramConverter
+
+def query(remote_neo4j, input_query, program_name=None, argument_1=None, argument_2=None, suppress_common=False):
+
+    try:
+        db = db_api.SextantConnection(remote_neo4j)
+    except requests.exceptions.ConnectionError as err:
+        logging.exception("Could not connect to Neo4J server {}. Are you sure it is running?".format(remote_neo4j))
+        logging.exception(str(err))
+        return 2
+    #Not supported in python 2
+    #except (urllib.exceptions.MaxRetryError):
+     #   logging.error("Connection was refused to {}. Are you sure the server is running?".format(remote_neo4j))
+      #  return 2
+    except Exception as err:
+        logging.exception(str(err))
+        return 2
+
+    prog = None
+    names_list = None
+
+    if input_query == 'functions-calling':
+        if argument_1 == None:
+            print('Supply one function name to functions-calling.')
+            return 1
+        prog = db.get_all_functions_calling(program_name, argument_1)
+    elif input_query == 'functions-called-by':
+        if argument_1 == None:
+            print('Supply one function name to functions-called-by.')
+            return 1
+        prog = db.get_all_functions_called(program_name, argument_1)
+    elif input_query == 'calls-between':
+        if (argument_1 == None and argument_2 == None):
+            print('Supply two function names to calls-between.')
+            return 1
+        prog = db.get_call_paths(program_name, argument_1, argument_2)
+    elif input_query == 'whole-graph':
+        prog = db.get_whole_program(program_name)
+    elif input_query == 'shortest-path':
+        if argument_1 == None and argument_2 == None:
+            print('Supply two function names to shortest-path.')
+            return 1
+        prog = db.get_shortest_path_between_functions(program_name, argument_1, argument_2)
+    elif input_query == 'return-all-function-names':
+        if program_name != None:
+            func_names = db.get_function_names(program_name)
+            if func_names:
+                names_list = list(func_names)
+            else:
+                print('No functions were found in program %s on server %s.' % (program_name, remote_neo4j))
+        else:
+            list_of_programs = db.get_program_names()
+            if not list_of_programs:
+                print('Server %s database empty.' % (remote_neo4j))
+                return 0
+            func_list = []
+            for prog_name in list_of_programs:
+                func_list += db.get_function_names(prog_name)
+            if not func_list:
+                print('Server %s contains no functions.' % (remote_neo4j))
+            else:
+                names_list = func_list
+    elif input_query == 'return-all-program-names':
+        list_found = list(db.get_program_names())
+        if not list_found:
+            print('No programs were found on server {}.'.format(remote_neo4j))
+        else:
+            names_list = list_found
+    else:
+        print('Query unrecognised.')
+        return 2
+
+    if prog:
+        print(ProgramConverter.to_yed_graphml(prog, suppress_common))
+    elif names_list is not None:
+        print(names_list)
+    else:
+        print('Nothing was returned from the query.')
+
+
+def main():
+    argumentparser = argparse.ArgumentParser(description="Return GraphML representation or list from graph queries.")
+    argumentparser.add_argument('--remote-neo4j', required=True, metavar="URL", help="URL of neo4j server", type=str, nargs=1)
+    argumentparser.add_argument('--program-name', metavar="PROG_NAME", help="name of program as stored in the database",
+                                type=str, nargs=1)
+    argumentparser.add_argument('--query', required=True, metavar="QUERY",
+                                help="""functions-calling, functions-called-by, calls-between, whole-graph, shortest-path,
+                                return-all-program-names or return-all-function-names; if return-all-function-names,
+                                supply argument -program-name""", type=str, nargs=1)
+    argumentparser.add_argument('--funcs', metavar='FUNCS', help='functions to pass to the query', type=str, nargs='+')
+
+    parsed = argumentparser.parse_args()
+    names_list = None
+
+    query(remote_neo4j=parsed.remote_neo4j[0], input_query=parsed.query[0], arguments=parsed.funcs,
+          program_name=parsed.program_name[0])
+
+
+if __name__ == '__main__':
+    main()
 
=== added file 'src/sextant/tests.py'
--- src/sextant/tests.py	1970-01-01 00:00:00 +0000
+++ src/sextant/tests.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,261 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: Patrick Stevens, James Harkin
+# -----------------------------------------
+#Testing module
+
+import unittest
+
+from db_api import Function
+from db_api import FunctionQueryResult
+from db_api import SextantConnection
+from db_api import Validator
+
+
+class TestFunctionQueryResults(unittest.TestCase):
+    def setUp(self):
+        # we need to set up the remote database by using the neo4j_input_api
+        self.remote_url = 'http://ensoft-sandbox:7474'
+
+        self.setter_connection = SextantConnection(self.remote_url)
+        self.program_1_name = 'testprogram'
+        self.upload_program = self.setter_connection.new_program(self.program_1_name)
+        self.upload_program.add_function('func1')
+        self.upload_program.add_function('func2')
+        self.upload_program.add_function('func3')
+        self.upload_program.add_function('func4')
+        self.upload_program.add_function('func5')
+        self.upload_program.add_function('func6')
+        self.upload_program.add_function('func7')
+        self.upload_program.add_function_call('func1', 'func2')
+        self.upload_program.add_function_call('func1', 'func4')
+        self.upload_program.add_function_call('func2', 'func1')
+        self.upload_program.add_function_call('func2', 'func4')
+        self.upload_program.add_function_call('func3', 'func5')
+        self.upload_program.add_function_call('func4', 'func4')
+        self.upload_program.add_function_call('func4', 'func5')
+        self.upload_program.add_function_call('func5', 'func1')
+        self.upload_program.add_function_call('func5', 'func2')
+        self.upload_program.add_function_call('func5', 'func3')
+        self.upload_program.add_function_call('func6', 'func7')
+
+        self.upload_program.commit()
+
+        self.one_node_program_name = 'testprogram1'
+        self.upload_one_node_program = self.setter_connection.new_program(self.one_node_program_name)
+        self.upload_one_node_program.add_function('lonefunc')
+
+        self.upload_one_node_program.commit()
+        
+        self.empty_program_name = 'testprogramblank'
+        self.upload_empty_program = self.setter_connection.new_program(self.empty_program_name)
+
+        self.upload_empty_program.commit()
+
+        self.getter_connection = SextantConnection(self.remote_url)
+
+    def tearDown(self):
+        self.setter_connection.delete_program(self.upload_program.program_name)
+        self.setter_connection.delete_program(self.upload_one_node_program.program_name)
+        self.setter_connection.delete_program(self.upload_empty_program.program_name)
+        del(self.setter_connection)
+
+    def test_17_get_call_paths(self):
+        reference1 = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)
+        reference1.functions = [Function(self.program_1_name, 'func1'), Function(self.program_1_name, 'func2'),
+                                Function(self.program_1_name, 'func3'),
+                                Function(self.program_1_name, 'func4'), Function(self.program_1_name, 'func5')]
+        reference1.functions[0].functions_i_call = reference1.functions[1:4:2]  # func1 calls func2, func4
+        reference1.functions[1].functions_i_call = reference1.functions[0:4:3]  # func2 calls func1, func4
+        reference1.functions[2].functions_i_call = [reference1.functions[4]]  # func3 calls func5
+        reference1.functions[3].functions_i_call = reference1.functions[3:5]  # func4 calls func4, func5
+        reference1.functions[4].functions_i_call = reference1.functions[0:3]  # func5 calls func1, func2, func3
+        self.assertEquals(reference1, self.getter_connection.get_call_paths(self.program_1_name, 'func1', 'func2'))
+        self.assertIsNone(self.getter_connection.get_call_paths('not a prog', 'func1', 'func2')) # shouldn't validation
+        self.assertIsNone(self.getter_connection.get_call_paths('notaprogram', 'func1', 'func2'))
+        self.assertIsNone(self.getter_connection.get_call_paths(self.program_1_name, 'notafunc', 'func2'))
+        self.assertIsNone(self.getter_connection.get_call_paths(self.program_1_name, 'func1', 'notafunc'))
+
+    def test_02_get_whole_program(self):
+        reference = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)
+        reference.functions = [Function(self.program_1_name, 'func1'), Function(self.program_1_name, 'func2'),
+                               Function(self.program_1_name, 'func3'),
+                               Function(self.program_1_name, 'func4'), Function(self.program_1_name, 'func5'),
+                               Function(self.program_1_name, 'func6'), Function(self.program_1_name, 'func7')]
+        reference.functions[0].functions_i_call = reference.functions[1:4:2]  # func1 calls func2, func4
+        reference.functions[1].functions_i_call = reference.functions[0:4:3]  # func2 calls func1, func4
+        reference.functions[2].functions_i_call = [reference.functions[4]]  # func3 calls func5
+        reference.functions[3].functions_i_call = reference.functions[3:5]  # func4 calls func4, func5
+        reference.functions[4].functions_i_call = reference.functions[0:3]  # func5 calls func1, func2, func3
+        reference.functions[5].functions_i_call = [reference.functions[6]]  # func6 calls func7
+
+
+        self.assertEqual(reference, self.getter_connection.get_whole_program(self.program_1_name))
+        self.assertIsNone(self.getter_connection.get_whole_program('nottherightprogramname'))
+        
+    def test_03_get_whole_one_node_program(self):
+        reference = FunctionQueryResult(parent_db=None, program_name=self.one_node_program_name)
+        reference.functions = [Function(self.one_node_program_name, 'lonefunc')]
+        
+        self.assertEqual(reference, self.getter_connection.get_whole_program(self.one_node_program_name))
+
+    def test_04_get_whole_empty_program(self):
+        reference = FunctionQueryResult(parent_db=None, program_name=self.empty_program_name)
+        reference.functions = []
+        
+        self.assertEqual(reference, self.getter_connection.get_whole_program(self.empty_program_name))
+
+    def test_05_get_function_names(self):
+        reference = {'func1', 'func2', 'func3', 'func4', 'func5', 'func6', 'func7'}
+        self.assertEqual(reference, self.getter_connection.get_function_names(self.program_1_name))
+
+    def test_06_get_function_names_one_node_program(self):
+        reference = {'lonefunc'}
+        self.assertEqual(reference, self.getter_connection.get_function_names(self.one_node_program_name))
+
+    def test_07_get_function_names_empty_program(self):
+        reference = set()
+        self.assertEqual(reference, self.getter_connection.get_function_names(self.empty_program_name))
+
+    def test_09_validation_is_used(self):
+        self.assertFalse(self.getter_connection.get_function_names('not alphanumeric'))
+        self.assertFalse(self.getter_connection.get_whole_program('not alphanumeric'))
+        self.assertFalse(self.getter_connection.check_program_exists('not alphanumeric'))
+        self.assertFalse(self.getter_connection.check_function_exists('not alphanumeric', 'alpha'))
+        self.assertFalse(self.getter_connection.check_function_exists('alpha', 'not alpha'))
+        self.assertFalse(self.getter_connection.get_all_functions_called('alphaprogram', 'not alpha function'))
+        self.assertFalse(self.getter_connection.get_all_functions_called('not alpha program', 'alphafunction'))
+        self.assertFalse(self.getter_connection.get_all_functions_calling('not alpha program', 'alphafunction'))
+        self.assertFalse(self.getter_connection.get_all_functions_calling('alphaprogram', 'not alpha function'))
+        self.assertFalse(self.getter_connection.get_call_paths('not alpha program','alphafunc1', 'alphafunc2'))
+        self.assertFalse(self.getter_connection.get_call_paths('alphaprogram','not alpha func 1', 'alphafunc2'))
+        self.assertFalse(self.getter_connection.get_call_paths('alphaprogram','alphafunc1', 'not alpha func 2'))
+
+    def test_08_get_program_names(self):
+        reference = {self.program_1_name, self.one_node_program_name, self.empty_program_name}
+        self.assertEqual(reference, self.getter_connection.get_program_names())
+
+
+    def test_11_get_all_functions_called(self):
+        reference1 = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)  # this will be the 1,2,3,4,5 component
+        reference2 = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)  # this will be the 6,7 component
+        reference3 = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)  # this will be the 7 component
+        reference1.functions = [Function(self.program_1_name, 'func1'), Function(self.program_1_name, 'func2'),
+                                Function(self.program_1_name, 'func3'),
+                                Function(self.program_1_name, 'func4'), Function(self.program_1_name, 'func5')]
+        reference2.functions = [Function(self.program_1_name, 'func6'), Function(self.program_1_name, 'func7')]
+        reference3.functions = []
+
+        reference1.functions[0].functions_i_call = reference1.functions[1:4:2]  # func1 calls func2, func4
+        reference1.functions[1].functions_i_call = reference1.functions[0:4:3]  # func2 calls func1, func4
+        reference1.functions[2].functions_i_call = [reference1.functions[4]]  # func3 calls func5
+        reference1.functions[3].functions_i_call = reference1.functions[3:5]  # func4 calls func4, func5
+        reference1.functions[4].functions_i_call = reference1.functions[0:3]  # func5 calls func1, func2, func3
+
+        reference2.functions[0].functions_i_call = [reference2.functions[1]]
+
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_called(self.program_1_name, 'func1'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_called(self.program_1_name, 'func2'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_called(self.program_1_name, 'func3'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_called(self.program_1_name, 'func4'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_called(self.program_1_name, 'func5'))
+
+        self.assertEquals(reference2, self.getter_connection.get_all_functions_called(self.program_1_name, 'func6'))
+
+        self.assertEquals(reference3, self.getter_connection.get_all_functions_called(self.program_1_name, 'func7'))
+
+        self.assertIsNone(self.getter_connection.get_all_functions_called(self.program_1_name, 'nottherightfunction'))
+        self.assertIsNone(self.getter_connection.get_all_functions_called('nottherightprogram', 'func2'))
+
+    def test_12_get_all_functions_called_1(self):
+        reference1 = FunctionQueryResult(parent_db=None, program_name=self.one_node_program_name)
+        reference1.functions = []
+
+        d=self.getter_connection.get_all_functions_called(self.one_node_program_name, 'lonefunc')
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_called(self.one_node_program_name,
+                                                                                      'lonefunc'))
+        self.assertIsNone(self.getter_connection.get_all_functions_called(self.one_node_program_name,
+                                                                          'not the right function'))
+        self.assertIsNone(self.getter_connection.get_all_functions_called('not the right program', 'lonefunc'))
+
+    def test_13_get_all_functions_called_blank(self):
+        reference1 = FunctionQueryResult(parent_db=None, program_name=self.empty_program_name)
+        reference1.functions = []
+
+        self.assertIsNone(self.getter_connection.get_all_functions_called(self.empty_program_name,
+                                                                          'not the right function'))
+
+    def test_14_get_all_functions_calling(self):
+        reference1 = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)  # this will be the 1,2,3,4,5 component
+        reference2 = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)  # this will be the 6,7 component
+        reference3 = FunctionQueryResult(parent_db=None, program_name=self.program_1_name)  # this will be the 7 component
+        reference1.functions = [Function(self.program_1_name, 'func1'), Function(self.program_1_name, 'func2'),
+                                Function(self.program_1_name, 'func3'),
+                                Function(self.program_1_name, 'func4'), Function(self.program_1_name, 'func5')]
+
+        reference1.functions[0].functions_i_call = reference1.functions[1:4:2]  # func1 calls func2, func4
+        reference1.functions[1].functions_i_call = reference1.functions[0:4:3]  # func2 calls func1, func4
+        reference1.functions[2].functions_i_call = [reference1.functions[4]]  # func3 calls func5
+        reference1.functions[3].functions_i_call = reference1.functions[3:5]  # func4 calls func4, func5
+        reference1.functions[4].functions_i_call = reference1.functions[0:3]  # func5 calls func1, func2, func3
+
+        reference2.functions = [Function(self.program_1_name, 'func6'), Function(self.program_1_name, 'func7')]
+
+        reference2.functions[0].functions_i_call = [reference2.functions[1]]
+
+        reference3.functions = [Function(self.program_1_name, 'func6')]
+
+        reference3.functions = []
+
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_calling(self.program_1_name, 'func1'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_calling(self.program_1_name, 'func2'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_calling(self.program_1_name, 'func3'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_calling(self.program_1_name, 'func4'))
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_calling(self.program_1_name, 'func5'))
+
+        self.assertEquals(reference2, self.getter_connection.get_all_functions_calling(self.program_1_name,'func7'))
+
+        self.assertEquals(reference3, self.getter_connection.get_all_functions_calling(self.program_1_name, 'func6'))
+
+        self.assertIsNone(self.getter_connection.get_all_functions_calling(self.program_1_name, 'nottherightfunction'))
+        self.assertIsNone(self.getter_connection.get_all_functions_calling('nottherightprogram', 'func2'))
+
+    def test_15_get_all_functions_calling_one_node_prog(self):
+        reference1 = FunctionQueryResult(parent_db=None, program_name=self.one_node_program_name)
+        reference1.functions = []
+        self.assertEquals(reference1, self.getter_connection.get_all_functions_calling(self.one_node_program_name,
+                                                                                       'lonefunc'))
+        self.assertIsNone(self.getter_connection.get_all_functions_calling(self.one_node_program_name,
+                                                                           'not the right function'))
+        self.assertIsNone(self.getter_connection.get_all_functions_calling('not the right program', 'lonefunc'))
+
+    def test_16_get_all_functions_calling_blank_prog(self):
+        reference1 = FunctionQueryResult(parent_db=None, program_name=self.empty_program_name)
+        reference1.functions=[]
+
+        self.assertIsNone(self.getter_connection.get_all_functions_called(self.empty_program_name,
+                                                                          'not the right function'))
+
+
+
+    def test_18_get_call_paths_between_two_functions_one_node_prog(self):
+        reference = FunctionQueryResult(parent_db=None, program_name=self.one_node_program_name)
+        reference.functions = [] # that is, reference is the empty program with name self.one_node_program_name
+
+        self.assertEquals(self.getter_connection.get_call_paths(self.one_node_program_name, 'lonefunc', 'lonefunc'),
+                          reference)
+        self.assertIsNone(self.getter_connection.get_call_paths(self.one_node_program_name, 'lonefunc', 'notafunc'))
+        self.assertIsNone(self.getter_connection.get_call_paths(self.one_node_program_name, 'notafunc', 'notafunc'))
+
+    def test_10_validator(self):
+        self.assertFalse(Validator.validate(''))
+        self.assertTrue(Validator.validate('thisworks'))
+        self.assertTrue(Validator.validate('th1sw0rks'))
+        self.assertTrue(Validator.validate('12345'))
+        self.assertFalse(Validator.validate('this does not work'))
+        self.assertTrue(Validator.validate('this_does_work'))
+        self.assertFalse(Validator.validate("'")) # string consisting of a single quote mark
+
+if __name__ == '__main__':
+    unittest.main()
 \ No newline at end of file
 
=== added file 'src/sextant/update_db.py'
--- src/sextant/update_db.py	1970-01-01 00:00:00 +0000
+++ src/sextant/update_db.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,78 @@
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: Patrick Stevens, using work from Patrick Stevens and James Harkin
+# -----------------------------------------
+# Given a program file to upload, or a program name to delete from the server, does the right thing.
+
+__all__ = ("upload_program", "delete_program")
+
+from .db_api import SextantConnection, Validator
+from .objdump_parser import get_parsed_objects
+
+import logging
+import requests
+
+
+def upload_program(file_path, db_url, alternative_name=None, not_object_file=False):
+    """
+    Uploads a program to the remote database.
+    :param file_path: the path to the local file we wish to upload
+    :param db_url: the URL of the database (eg. http://localhost:7474)
+    :param alternative_name: a name to give the program to override the default
+    :param object_file: bool(the file is an objdump text output file, rather than a compiled binary)
+    :return: 1 if the program already exists in database, 2 if there was a connection error
+    """
+    try:
+        connection = SextantConnection(db_url)
+    except requests.exceptions.ConnectionError as err:
+        logging.exception("Could not connect to Neo4J server {}. Are you sure it is running?".format(db_url))
+        return 2
+    #except urllib.exceptions.MaxRetryError:
+     #   logging.error("Connection was refused to {}. Are you sure the server is running?".format(db_url))
+      #  return 2
+
+    program_names = connection.get_program_names()
+    if alternative_name is None:
+        if Validator.sanitise(file_path) in program_names:
+            logging.error("There is already a program under this name; please delete the previous one with the same name "
+                          "and retry, or rename the input file.")
+            return 1
+    else:
+        if Validator.sanitise(alternative_name) in program_names:
+            logging.error("There is already a program under this name; please delete the previous one with the same name "
+                          "and retry, or rename the input file.")
+            return 1
+
+    parsed_objects = get_parsed_objects(filepath=file_path, sections_to_view=['.text'],
+                                        not_object_file=not_object_file, ignore_function_pointers=False)
+
+    logging.warning('Objdump has parsed!')
+
+    if alternative_name is None:
+        program_representation = connection.new_program(Validator.sanitise(file_path))
+    else:
+        program_representation = connection.new_program(Validator.sanitise(alternative_name))
+
+
+
+    for obj in parsed_objects:
+        for called in obj.what_do_i_call:
+            if not program_representation.add_function_call(obj.name, called[-1]): # called is a tuple (address, name)
+                logging.error('Validation error: {} calling {}'.format(obj.name, called[-1]))
+
+    logging.warning('Sending {} named objects to server {}...'.format(len(parsed_objects), db_url))
+    program_representation.commit()
+    logging.info('Sending complete! Exiting.')
+
+
+def delete_program(program_name, db_url):
+    """
+    Deletes a program with the specified name from the database.
+    :param program_name: the name of the program to delete
+    :param db_url: the URL of the database (eg. http://localhost:7474)
+    :return: bool(success)
+    """
+    connection = SextantConnection(db_url)
+    connection.delete_program(program_name)
+    print('Deleted {} successfully.'.format(program_name))
 
=== added directory 'src/sextant/web'
=== added file 'src/sextant/web/__init__.py'
--- src/sextant/web/__init__.py	1970-01-01 00:00:00 +0000
+++ src/sextant/web/__init__.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,8 @@
+#----------------------------------------------------------------------------
+# __init__.py -- Web package root
+#
+# July 2014, Phil Connell
+#
+# (c) Ensoft Ltd, 2014
+#----------------------------------------------------------------------------
+
 
=== added file 'src/sextant/web/server.py'
--- src/sextant/web/server.py	1970-01-01 00:00:00 +0000
+++ src/sextant/web/server.py	2014-08-15 12:04:08 +0000
@@ -0,0 +1,323 @@
+#!/usr/bin/python2
+# -----------------------------------------
+# Sextant
+# Copyright 2014, Ensoft Ltd.
+# Author: Patrick Stevens, James Harkin
+# -----------------------------------------
+# Note: this must be run in Python 2.
+
+from twisted.web.server import Site, NOT_DONE_YET
+from twisted.web.resource import Resource
+from twisted.web.static import File
+from twisted.internet import reactor
+from twisted.internet.threads import deferToThread
+from twisted.internet import defer
+
+import logging
+
+import os
+import sys  # hack to get the Sextant module imported
+sys.path.append(os.path.realpath('../..'))
+
+import json
+import requests
+
+import sextant.db_api as db_api
+import sextant.export as export
+import tempfile
+import subprocess
+
+from cgi import escape  # deprecated in Python 3 in favour of html.escape, but we're stuck on Python 2
+
+database_url = None  # the URL to access the database instance
+
+class Echoer(Resource):
+    # designed to take one name argument
+
+    def render_GET(self, request):
+        if "name" not in request.args:
+            return '<html><body>Greetings, unnamed stranger.</body></html>'
+
+        arg = escape(request.args["name"][0])
+        return '<html><body>Hello %s!</body></html>' % arg
+
+
+class SVGRenderer(Resource):
+
+    def error_creating_neo4j_connection(self, failure):
+        self.write("Error creating Neo4J connection: %s\n") % failure.getErrorMessage()
+
+    @staticmethod
+    def create_neo4j_connection():
+        return db_api.SextantConnection(database_url)
+
+    @staticmethod
+    def check_program_exists(connection, name):
+        return connection.check_program_exists(name)
+
+    @staticmethod
+    def get_whole_program(connection, name):
+        return connection.get_whole_program(name)
+
+    @staticmethod
+    def get_functions_calling(connection, progname, funcname):
+        return connection.get_all_functions_calling(progname, funcname)
+
+    @staticmethod
+    def get_plot(program, suppress_common_functions=False):
+        graph_dot = export.ProgramConverter.to_dot(program, suppress_common_functions)
+
+        file_written_to = tempfile.NamedTemporaryFile(delete=False)
+        file_out = tempfile.NamedTemporaryFile(delete=False)
+        file_written_to.write(graph_dot)
+        file_written_to.close()
+        subprocess.call(['dot', '-Tsvg', '-Kdot', '-o', file_out.name, file_written_to.name])
+
+        output = file_out.read().encode()
+        file_out.close()
+        return output
+
+    @defer.inlineCallbacks
+    def _render_plot(self, request):
+        if "program_name" not in request.args:
+            request.setResponseCode(400)
+            request.write("Supply 'program_name' parameter.")
+            request.finish()
+            defer.returnValue(None)
+
+        logging.info('enter')
+        name = request.args["program_name"][0]
+
+        try:
+            suppress_common = request.args["suppress_common"][0]
+        except KeyError:
+            suppress_common = False
+
+        if suppress_common == 'null' or suppress_common == 'true':
+            suppress_common = True
+        else:
+            suppress_common = False
+
+        try:
+            neo4jconnection = yield deferToThread(self.create_neo4j_connection)
+        except requests.exceptions.ConnectionError:
+            request.setResponseCode(502)  # Bad Gateway
+            request.write("Could not reach Neo4j server at {}".format(database_url))
+            request.finish()
+            defer.returnValue(None)
+            neo4jconnection = None  # to silence the "referenced before assignment" warnings later
+
+        logging.info('created')
+        exists = yield deferToThread(self.check_program_exists, neo4jconnection, name)
+        if not exists:
+            request.setResponseCode(404)
+            logging.info('returning nonexistent')
+            request.write("Name %s not found." % (escape(name)))
+            request.finish()
+            defer.returnValue(None)
+
+        logging.info('done created')
+        allowed_queries = ("whole_program", "functions_calling", "functions_called_by", "call_paths", "shortest_path")
+
+        if "query" not in request.args:
+            query = "whole_program"
+        else:
+            query = request.args["query"][0]
+
+        if query not in allowed_queries:
+            # raise 400 Bad Request error
+            request.setResponseCode(400)
+            request.write("Supply 'query' parameter, default is whole_program, allowed %s." % str(allowed_queries))
+            request.finish()
+            defer.returnValue(None)
+
+        if query == 'whole_program':
+            program = yield deferToThread(self.get_whole_program, neo4jconnection, name)
+        elif query == 'functions_calling':
+            if 'func1' not in request.args:
+                # raise 400 Bad Request error
+                request.setResponseCode(400)
+                request.write("Supply 'func1' parameter to functions_calling.")
+                request.finish()
+                defer.returnValue(None)
+            func1 = request.args['func1'][0]
+            program = yield deferToThread(self.get_functions_calling, neo4jconnection, name, func1)
+        elif query == 'functions_called_by':
+            if 'func1' not in request.args:
+                # raise 400 Bad Request error
+                request.setResponseCode(400)
+                request.write("Supply 'func1' parameter to functions_called_by.")
+                request.finish()
+                defer.returnValue(None)
+            func1 = request.args['func1'][0]
+            program = yield deferToThread(neo4jconnection.get_all_functions_called, name, func1)
+        elif query == 'call_paths':
+            if 'func1' not in request.args:
+                # raise 400 Bad Request error
+                request.setResponseCode(400)
+                request.write("Supply 'func1' parameter to call_paths.")
+                request.finish()
+                defer.returnValue(None)
+            if 'func2' not in request.args:
+                # raise 400 Bad Request error
+                request.setResponseCode(400)
+                request.write("Supply 'func2' parameter to call_paths.")
+                request.finish()
+                defer.returnValue(None)
+
+            func1 = request.args['func1'][0]
+            func2 = request.args['func2'][0]
+            program = yield deferToThread(neo4jconnection.get_call_paths, name, func1, func2)
+        elif query == 'shortest_path':
+            if 'func1' not in request.args:
+                # raise 400 Bad Request error
+                request.setResponseCode(400)
+                request.write("Supply 'func1' parameter to shortest_path.")
+                request.finish()
+                defer.returnValue(None)
+            if 'func2' not in request.args:
+                # raise 400 Bad Request error
+                request.setResponseCode(400)
+                request.write("Supply 'func2' parameter to shortest_path.")
+                request.finish()
+                defer.returnValue(None)
+
+            func1 = request.args['func1'][0]
+            func2 = request.args['func2'][0]
+            program = yield deferToThread(neo4jconnection.get_shortest_path_between_functions, name, func1, func2)
+
+        else:  # unrecognised query, so we need to raise a Bad Request response
+            request.setResponseCode(400)
+            request.write("Query %s not recognised." % escape(query))
+            request.finish()
+            defer.returnValue(None)
+            program = None  # silences the "referenced before assignment" warnings
+
+        if program is None:
+            request.setResponseCode(404)
+            request.write("At least one of the input functions was not found in program %s." % (escape(name)))
+            request.finish()
+            defer.returnValue(None)
+
+        logging.info('getting plot')
+        logging.info(program)
+        if not program.functions:  # we got an empty program back:  the program is in the Sextant but has no functions
+            request.setResponseCode(204)
+            request.finish()
+            defer.returnValue(None)
+
+        output = yield deferToThread(self.get_plot, program, suppress_common)
+        request.setHeader("content-type", "image/svg+xml")
+
+        logging.info('SVG: return')
+        request.write(output)
+        request.finish()
+
+    def render_GET(self, request):
+        self._render_plot(request)
+        return NOT_DONE_YET
+
+
+class GraphProperties(Resource):
+
+    @staticmethod
+    def _get_connection():
+        return db_api.SextantConnection(database_url)
+
+    @staticmethod
+    def _get_program_names(connection):
+        return connection.get_program_names()
+
+    @staticmethod
+    def _get_function_names(connection, program_name):
+        return connection.get_function_names(program_name)
+
+    @defer.inlineCallbacks
+    def _render_GET(self, request):
+        if "query" not in request.args:
+            request.setResponseCode(400)
+            request.setHeader("content-type", "text/plain")
+            request.write("Supply 'query' parameter of 'programs' or 'functions'.")
+            request.finish()
+            defer.returnValue(None)
+
+        query = request.args['query'][0]
+
+        logging.info('Properties: about to get_connection')
+
+        try:
+            neo4j_connection = yield deferToThread(self._get_connection)
+        except Exception:
+            request.setResponseCode(502)  # Bad Gateway
+            request.write("Could not reach Neo4j server at {}.".format(database_url))
+            request.finish()
+            defer.returnValue(None)
+            neo4j_connection = None  # just to silence the "referenced before assignment" warnings
+
+        logging.info('got connection')
+
+        if query == 'programs':
+            request.setHeader("content-type", "application/json")
+            prognames = yield deferToThread(self._get_program_names, neo4j_connection)
+            request.write(json.dumps(list(prognames)))
+            request.finish()
+            defer.returnValue(None)
+
+        elif query == 'functions':
+            if "program_name" not in request.args:
+                request.setResponseCode(400)
+                request.setHeader("content-type", "text/plain")
+                request.write("Supply 'program_name' parameter to ?query=functions.")
+                request.finish()
+                defer.returnValue(None)
+            program_name = request.args['program_name'][0]
+
+            funcnames = yield deferToThread(self._get_function_names, neo4j_connection, program_name)
+            if funcnames is None:
+                request.setResponseCode(404)
+                request.setHeader("content-type", "text/plain")
+                request.write("No program with name %s was found in the Sextant." % escape(program_name))
+                request.finish()
+                defer.returnValue(None)
+
+            request.setHeader("content-type", "application/json")
+            request.write(json.dumps(list(funcnames)))
+            request.finish()
+            defer.returnValue(None)
+
+        else:
+            request.setResponseCode(400)
+            request.setHeader("content-type", "text/plain")
+            request.write("'Query' parameter should be 'programs' or 'functions'.")
+            request.finish()
+            defer.returnValue(None)
+
+    def render_GET(self, request):
+        self._render_GET(request)
+        return NOT_DONE_YET
+
+
+def serve_site(input_database_url='http://localhost:7474', port=2905):
+
+    global database_url
+    database_url = input_database_url
+    # serve static directory at root
+    root = File(os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        "..", "..", "..", "resources", "web"))
+
+    # serve a dynamic Echoer webpage at /echoer.html
+    root.putChild("echoer.html", Echoer())
+
+    # serve a dynamic webpage at /Sextant_properties to return graph properties
+    root.putChild("database_properties", GraphProperties())
+
+    # serve a generated SVG at /output_graph.svg
+    root.putChild('output_graph.svg', SVGRenderer())
+
+    factory = Site(root)
+    reactor.listenTCP(port, factory)
+    reactor.run()
+
+if __name__ == '__main__':
+    serve_site()