Base opentitantool application. 1. Establish the basic `opentitantool` framework. 2. Create a procedural macro for deriving `CommandDispatch` for interior nodes in the command hierarchy. 3. Create some sample `hello` commands in `hello.rs`. Signed-off-by: Chris Frantz <cfrantz@google.com>

diff --git a/sw/host/opentitanlib/Cargo.toml b/sw/host/opentitanlib/Cargo.toml
index 3309988..85b7870 100644
--- a/sw/host/opentitanlib/Cargo.toml
+++ b/sw/host/opentitanlib/Cargo.toml

@@ -15,3 +15,6 @@
 nix = "0.17.0"
 bitflags = "1.0"
 log = "0.4"
+
+erased-serde = "0.3.12"
+opentitantool_derive = {path = "opentitantool_derive"}

diff --git a/sw/host/opentitanlib/opentitantool_derive/Cargo.toml b/sw/host/opentitanlib/opentitantool_derive/Cargo.toml
new file mode 100644
index 0000000..39f5f9d
--- /dev/null
+++ b/sw/host/opentitanlib/opentitantool_derive/Cargo.toml

@@ -0,0 +1,18 @@
+# Copyright lowRISC contributors.
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "opentitantool_derive"
+version = "0.1.0"
+authors = ["lowRISC contributors"]
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+proc-macro-error = "1.0"
+quote = "1.0"
+syn = "1.0"

diff --git a/sw/host/opentitanlib/opentitantool_derive/src/lib.rs b/sw/host/opentitanlib/opentitantool_derive/src/lib.rs
new file mode 100644
index 0000000..3c000c6
--- /dev/null
+++ b/sw/host/opentitanlib/opentitantool_derive/src/lib.rs

@@ -0,0 +1,105 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use proc_macro2::TokenStream;
+use proc_macro_error::{abort, proc_macro_error};
+use quote::quote;
+use syn::{parse_macro_input, Data, DataEnum, DeriveInput, Fields, Ident, Variant};
+
+/// Derives the `CommandDispatch` trait for a NewType enum.
+///
+/// Derive this on purely interior nodes in the opentitantool command hierarchy
+/// (that is: nodes whose only purpose is to dispatch down to the next layer
+/// in the command heirarchy).  The automatic derivation simply calls the
+/// `run` method on the next layer in the command hierarchy.
+///
+/// Imagine that you have structs `World` and `People` which implement
+/// "Hello World" and "Hello People" commands.  You would create Newtype
+/// variants inside of a `Hello` enum and derive `CommandDispatch` to
+/// generate the dispatch layer for this interior node in the command hierarchy:
+///
+/// ```
+/// #[derive(StructOpt, CommandDispatch)]
+/// pub enum Hello {
+///     World(World),
+///     People(People),
+/// }
+///
+/// // The derived code is as follows:
+/// impl opentitanlib::app::command::CommandDispatch for Hello {
+///     fn run(
+///         &self,
+///         backend: &mut dyn opentitanlib::transport::Transport
+///     ) -> anyhow::Result<Option<Box<dyn erased_serde::Serialize>>> {
+///         match self {
+///             Hello::World(ref __field) => __field.run(backend),
+///             Hello::People(ref __field) => __field.run(backend),
+///         }
+///     }
+/// }
+/// ```
+#[proc_macro_derive(CommandDispatch)]
+#[proc_macro_error]
+pub fn derive_command_dispatch(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    match &input.data {
+        Data::Enum(e) => dispatch_enum(&input.ident, e).into(),
+        _ => abort!(
+            input.ident.span(),
+            "CommandDispatch is only implemented for enums"
+        ),
+    }
+}
+
+fn dispatch_enum(name: &Ident, e: &DataEnum) -> TokenStream {
+    let arms = e
+        .variants
+        .iter()
+        .map(|variant| dispatch_variant(name, variant))
+        .collect::<Vec<_>>();
+
+    // We wrap the derived code inside an anonymous const block to give the
+    // `extern crate` references a local namespace that wont pollute the
+    // global namespace.
+    quote! {
+        const _: () = {
+            extern crate opentitanlib;
+            extern crate anyhow;
+            extern crate erased_serde;
+
+            impl opentitanlib::app::command::CommandDispatch for #name {
+                fn run(
+                    &self,
+                    backend: &mut dyn opentitanlib::transport::Transport
+                ) -> anyhow::Result<Option<Box<dyn erased_serde::Serialize>>> {
+                    match self {
+                        #(#arms),*
+                    }
+                }
+            }
+        };
+    }
+}
+
+fn dispatch_variant(name: &Ident, variant: &Variant) -> TokenStream {
+    let ident = &variant.ident;
+    let unnamed_len = match &variant.fields {
+        Fields::Unnamed(u) => u.unnamed.len(),
+        _ => abort!(
+            variant.ident.span(),
+            "CommandDispatch is only implemented for Newtype variants"
+        ),
+    };
+    if unnamed_len != 1 {
+        abort!(
+            variant.ident.span(),
+            "CommandDispatch is only implemented for Newtype variants"
+        );
+    }
+    quote! {
+        #name::#ident(ref __field) =>
+            opentitanlib::app::command::CommandDispatch::run(__field, backend)
+    }
+}

diff --git a/sw/host/opentitanlib/src/app/command.rs b/sw/host/opentitanlib/src/app/command.rs
new file mode 100644
index 0000000..b275cce
--- /dev/null
+++ b/sw/host/opentitanlib/src/app/command.rs

@@ -0,0 +1,16 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::transport::Transport;
+use anyhow::Result;
+use erased_serde::Serialize;
+pub use opentitantool_derive::*;
+
+/// The `CommandDispatch` trait should be implemented for all leaf structures
+/// in the application's command hierarchy.  It can be automatically derived
+/// on internal nodes in the heirarchy.  See the documentation for
+/// [`opentitantool_derive`].
+pub trait CommandDispatch {
+    fn run(&self, transport: &mut dyn Transport) -> Result<Option<Box<dyn Serialize>>>;
+}

diff --git a/sw/host/opentitanlib/src/app/mod.rs b/sw/host/opentitanlib/src/app/mod.rs
new file mode 100644
index 0000000..a371aaa
--- /dev/null
+++ b/sw/host/opentitanlib/src/app/mod.rs

@@ -0,0 +1,6 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Useful modules for OpenTitanTool application development.
+pub mod command;

diff --git a/sw/host/opentitanlib/src/lib.rs b/sw/host/opentitanlib/src/lib.rs
index 3825007..ab50890 100644
--- a/sw/host/opentitanlib/src/lib.rs
+++ b/sw/host/opentitanlib/src/lib.rs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
 // SPDX-License-Identifier: Apache-2.0
 
+pub mod app;
 pub mod io;
 pub mod transport;
 pub mod util;

diff --git a/sw/host/opentitantool/Cargo.toml b/sw/host/opentitantool/Cargo.toml
new file mode 100644
index 0000000..7345c24
--- /dev/null
+++ b/sw/host/opentitantool/Cargo.toml

@@ -0,0 +1,24 @@
+# Copyright lowRISC contributors.
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "opentitantool"
+version = "0.1.0"
+authors = ["lowRISC contributors"]
+edition = "2018"
+
+[dependencies]
+anyhow = "1.0"
+thiserror = "1.0"
+opentitanlib = {path="../opentitanlib"}
+structopt = "0.3"
+log = "0.4"
+env_logger = "0.8.3"
+raw_tty = "0.1.0"
+regex = "1"
+nix = "0.17.0"
+
+serde = {version="1", features=["serde_derive"]}
+serde_json = "1"
+erased-serde = "0.3.12"

diff --git a/sw/host/opentitantool/src/backend/mod.rs b/sw/host/opentitantool/src/backend/mod.rs
new file mode 100644
index 0000000..544be3c
--- /dev/null
+++ b/sw/host/opentitantool/src/backend/mod.rs

@@ -0,0 +1,29 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::Result;
+use structopt::StructOpt;
+use thiserror::Error;
+
+use opentitanlib::transport::{EmptyTransport, Transport};
+
+#[derive(Debug, StructOpt)]
+pub struct BackendOpts {
+    #[structopt(long, default_value)]
+    interface: String,
+}
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("unknown interface {0}")]
+    UnknownInterface(String),
+}
+
+/// Creates the requested backend interface according to [`BackendOpts`].
+pub fn create(args: &BackendOpts) -> Result<Box<dyn Transport>> {
+    match args.interface.as_str() {
+        "" => Ok(Box::new(EmptyTransport)),
+        _ => Err(Error::UnknownInterface(args.interface.clone()).into()),
+    }
+}

diff --git a/sw/host/opentitantool/src/command/hello.rs b/sw/host/opentitantool/src/command/hello.rs
new file mode 100644
index 0000000..4df9860
--- /dev/null
+++ b/sw/host/opentitantool/src/command/hello.rs

@@ -0,0 +1,92 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+//! Sample command heirarchy.
+//!
+//! This module implements a sample command heirarchy to demonstrate
+//! the command framework for opentitantool.
+
+use anyhow::Result;
+use erased_serde::Serialize;
+use structopt::StructOpt;
+
+use opentitanlib::app::command::CommandDispatch;
+use opentitanlib::transport::Transport;
+
+#[derive(Debug, StructOpt)]
+/// The `hello world` command accepts an command option of `--cruel`.
+pub struct HelloWorld {
+    #[structopt(short, long)]
+    cruel: bool,
+}
+
+#[derive(serde::Serialize)]
+/// The [`HelloMessage`] is the result of the `hello world` command.
+pub struct HelloMessage {
+    pub greeting: String,
+}
+
+impl CommandDispatch for HelloWorld {
+    fn run(&self, _transport: &mut dyn Transport) -> Result<Option<Box<dyn Serialize>>> {
+        // Is the world cruel or not?
+        let msg = if self.cruel {
+            "Hello cruel World!"
+        } else {
+            "Hello World!"
+        };
+        Ok(Some(Box::new(HelloMessage {
+            greeting: msg.to_owned(),
+        })))
+    }
+}
+
+#[derive(Debug, StructOpt)]
+/// The `hello people` command takes no additional switches or arguments.
+pub struct HelloPeople {
+    // Unit structs not allowed by StructOpt
+}
+
+impl CommandDispatch for HelloPeople {
+    fn run(&self, _transport: &mut dyn Transport) -> Result<Option<Box<dyn Serialize>>> {
+        // The `hello people` command produces no result.
+        Ok(None)
+    }
+}
+
+#[derive(Debug, StructOpt, CommandDispatch)]
+/// There are two types of `hello` subcommand; this enum binds them together
+/// so they can both be under the `hello` command.  This enum also derives
+/// `CommandDispatch` which automatically builds a `run` method for this
+/// type which dispatches to the subcommands.
+pub enum HelloTypes {
+    World(HelloWorld),
+    People(HelloPeople),
+}
+
+#[derive(Debug, StructOpt)]
+/// The `goodbye` command takes no options or arguments.
+pub struct GoodbyeCommand {}
+
+#[derive(serde::Serialize)]
+/// The [`GoodbyeMessage`] is the result of the `goodbye` command.
+pub struct GoodbyeMessage {
+    pub message: String,
+}
+
+impl CommandDispatch for GoodbyeCommand {
+    fn run(&self, _transport: &mut dyn Transport) -> Result<Option<Box<dyn Serialize>>> {
+        Ok(Some(Box::new(GoodbyeMessage {
+            message: "Goodbye!".to_owned(),
+        })))
+    }
+}
+
+#[derive(Debug, StructOpt, CommandDispatch)]
+/// The [`Greetings`] enum binds the `hello` and `goodbye` command hirarchies
+/// in this module together into a single type which can be included into
+/// the root of the command heirarchy in `main.rs`.
+pub enum Greetings {
+    Hello(HelloTypes),
+    Goodbye(GoodbyeCommand),
+}

diff --git a/sw/host/opentitantool/src/command/mod.rs b/sw/host/opentitantool/src/command/mod.rs
new file mode 100644
index 0000000..950ba35
--- /dev/null
+++ b/sw/host/opentitantool/src/command/mod.rs

@@ -0,0 +1,5 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod hello;

diff --git a/sw/host/opentitantool/src/main.rs b/sw/host/opentitantool/src/main.rs
new file mode 100644
index 0000000..3dbbb2b
--- /dev/null
+++ b/sw/host/opentitantool/src/main.rs

@@ -0,0 +1,44 @@
+// Copyright lowRISC contributors.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::Result;
+use log::LevelFilter;
+use structopt::StructOpt;
+
+mod backend;
+mod command;
+use opentitanlib::app::command::CommandDispatch;
+
+#[derive(Debug, StructOpt, CommandDispatch)]
+enum RootCommandHierarchy {
+    // Flattened because `Greetings` is a subcommand hierarchy.
+    #[structopt(flatten)]
+    Greetings(command::hello::Greetings),
+}
+
+#[derive(Debug, StructOpt)]
+struct Opts {
+    #[structopt(long, default_value = "off")]
+    logging: LevelFilter,
+
+    #[structopt(flatten)]
+    backend_opts: backend::BackendOpts,
+
+    #[structopt(subcommand)]
+    command: RootCommandHierarchy,
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::from_args();
+    env_logger::Builder::from_default_env()
+        .filter(None, opts.logging)
+        .init();
+
+    let mut interface = backend::create(&opts.backend_opts)?;
+
+    if let Some(value) = opts.command.run(&mut *interface)? {
+        println!("{}", serde_json::to_string_pretty(&value)?);
+    }
+    Ok(())
+}