PLAN: Packet Language

for Active Networks

Michael Hicksjoint work with

Jon Moore, Pankaj Kakkar, Carl Gunter, and Scott Nettles

Switchware Project Computer and Information Science

University of Pennsylvania

Distributed Programming

for Active Networks What is an Active Network? Why would I want one? How do I program one?

PLAN

Where can I get it?

Traditional Networks

R

R

R

H

H

H

H

H

Traditional Networks

R

R

R

H

H

H

H

H

Active Networks

A

A

A

A

A

A

A

A

Why Program the Network?

Multicast Network Searching Congestion Avoidance Web Caching Switch Diagnostics and Configuration ...

Can’t I do this stuff now?

In some cases, yes, but Evolution is slow Programming is tedious and error-prone

In other cases, no Many solutions require participation of all

network nodes

Design Goals

Flexibility IP and beyond

Security and Safety Non-interferenceResource boundingAuthentication

Performance Fast common case(data delivery)

Usability Simple InterfaceStatic guarantees

Design Space

Programmable Packets

DynamicallyExtensibleRouters

Endpoints only(Internet) Every hop

Where to add programmability?

Where to evaluate packets?

Two Level Architecture PacketLevel

ServiceLevel

Language PLAN Flexible

Code location In packet On node

Expressibility Limited General

Authentication? No When needed

Design Space

Programmable Packets

DynamicallyExtensibleRouters

Endpoints only(Internet) Every hop

Where to add programmability?

Where to evaluate packets?

Ping

A

B

Ping in PLAN

fun ping(source:host, dest:host):unit = if not thisHostIs(dest) then OnRemote(|ping|(source,dest), dest, … ) else OnRemote(|ack|(), source, … )

fun ack() : unit = print(“Success”)

PLAN: the Language Based on simply-typed calculus Remote evaluation with OnRemote and

chunks Access to services via function calls Explicit, global resource bound Exceptions and error handling Static guarantees

Type safety Termination

OnRemote

Primitive For Remote Evaluation

OnRemote(f,dest,rb,routFun) f: function to invoke remotely + args (a

chunk) dest: remote location rb: resource bound routFun: routing function name

Chunksalmost first-class functions

Three components: code (optional) function name actual parameters

Semantics at evaluation time: process code in fresh top-level environment resolve function name evaluate function with given parameters

Name Resolution

Three components: code (optional) function name actual parameters

Semantics at evaluation time: process code in fresh top-level environment resolve function name evaluate function with given parameters

Chunksmeans for encapsulation

fun v(c:chunk, cs:blob): unit = if verifyCS(c,cs) then eval(c)

let val c: chunk = |foo|() val d: chunk = checksum(c) in OnRemote(d,dest,getRB(),defaultRoute)end

What’s Missing? Direct recursion

can fake it with OnRemote General recursive types

built-in homogeneous lists + fold Higher-order functions

can use chunks Synchronization Mutation

both may occur at the service level

Why not use language X?

Special domain Simple languages for simple tasks Lightweight interpretation Possible a priori guarantees

type safety memory/CPU usage termination

PLANet

An Active Internetwork Based on IP but all packets are PLAN

programs RIP, ARP, etc. are service-level protocols -

communicate using PLAN programs

RIP, ARP, DNS, etc. Hard parts are implemented as services

Require state Timing oriented Security

Communication occurs via PLAN Routing update broadcasts, ARP requests,

etc.

Service Level Protocols

Summary

Active Networks provide a richer network model faster evolution improved flexibility

PLAN embodies AN design space packet programs (PLAN) service programs (Caml)

Programming model is simple and effective

Where to get PLAN

PLAN 3.1 (and PLANet)www.cis.upenn.edu/~switchware/PLAN/ includes new security features!

SwitchWare homepage (papers and code)www.cis.upenn.edu/~switchware