mirrors/tres
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Formatted

Browse source
This commit is contained in:
Eishun Kondoh 2018-01-30 22:47:31 +09:00
parent 5fc01a9bec
commit 7635272fbd
150 changed files with 5055 additions and 4032 deletions
Download patch file Download diff file Expand all files Collapse all files

18
.formatter.exs Normal file
View file

@ -0,0 +1,18 @@
[
inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"],
locals_without_parens: [
# Formatter tests
assert_format: 2,
assert_format: 3,
assert_same: 1,
assert_same: 2,
# Errors tests
assert_eval_raise: 3,
# Mix tests
in_fixture: 2,
in_tmp: 2
]
]

14
lib/openflow.ex
View file

@ -8,20 +8,23 @@ defmodule Openflow do
when byte_size(binary) < @ofp_header_size do
{:error, :binary_too_small}
end
def read(<<_v::8, _t::8, len::16, _x::32, _r::bytes>> = binary)
when byte_size(binary) < len do
{:error, :binary_too_small}
end
def read(<<ver::8, type::8, len::16, xid::32, binary2::bytes>>) do
body_len = len - @ofp_header_size
<<body_bin::bytes-size(body_len), rest::bytes>> = binary2
result = type
result =
type
|> Openflow.Enums.to_atom(:openflow_codec)
|> do_read(body_bin)
case result do
{:ok, struct} -> {:ok, %{struct|version: ver, xid: xid}, rest}
{:ok, struct} -> {:ok, %{struct | version: ver, xid: xid}, rest}
{:error, reason} -> {:error, reason}
end
end
@ -30,19 +33,23 @@ defmodule Openflow do
binaries = for message <- messages, do: to_binary(message)
Enum.join(binaries, "")
end
def to_binary(%{__struct__: encoder, version: version, xid: xid} = msg) do
case encoder.to_binary(msg) do
body_bin when is_binary(body_bin) ->
length = @ofp_header_size + byte_size(body_bin)
<<version::8, (encoder.ofp_type)::8, length::16, xid::32, body_bin::bytes>>
<<version::8, encoder.ofp_type::8, length::16, xid::32, body_bin::bytes>>
{:error, reason} ->
{:error, reason}
end
end
def append_body(nil, message), do: message
def append_body(message, continue) do
mod = message.__struct__
if function_exported?(mod, :append_body, 2) do
mod.append_body(message, continue)
else
@ -55,6 +62,7 @@ defmodule Openflow do
defp do_read({:error, reason}, _) do
{:error, reason}
end
defp do_read(decoder, body_bin) do
case decoder.read(body_bin) do
{:error, reason} -> {:error, reason}

10
lib/openflow/action.ex
View file

@ -1,5 +1,4 @@
defmodule Openflow.Action do
def read(action_bin) do
do_read([], action_bin)
end
@ -7,6 +6,7 @@ defmodule Openflow.Action do
def to_binary(actions) when is_list(actions) do
to_binary(<<>>, actions)
end
def to_binary(action) do
to_binary([action])
end
@ -15,15 +15,17 @@ defmodule Openflow.Action do
defp do_read(acc, <<>>), do: Enum.reverse(acc)
defp do_read(acc, <<0::32, _::bytes>>), do: Enum.reverse(acc)
defp do_read(acc, <<type::16, length::16, _::bytes>> = binary) do
<<action_bin::size(length)-bytes, rest::bytes>> = binary
codec = Openflow.Enums.to_atom(type, :action_type)
do_read([codec.read(action_bin)|acc], rest)
do_read([codec.read(action_bin) | acc], rest)
end
defp to_binary(acc, []), do: acc
defp to_binary(acc, [action|rest]) do
defp to_binary(acc, [action | rest]) do
codec = action.__struct__
to_binary(<<acc::bytes, (codec.to_binary(action))::bytes>>, rest)
to_binary(<<acc::bytes, codec.to_binary(action)::bytes>>, rest)
end
end

8
lib/openflow/actions/experimenter.ex
View file

@ -5,7 +5,7 @@ defmodule Openflow.Action.Experimenter do
@experimter_size 8
def ofpat, do: 0xffff
def ofpat, do: 0xFFFF
def new(exp_id, data \\ "") do
%Experimenter{exp_id: exp_id, data: data}
@ -13,17 +13,19 @@ defmodule Openflow.Action.Experimenter do
def to_binary(%Experimenter{exp_id: exp_id, data: data}) do
length = @experimter_size + byte_size(data)
<<0xffff::16, length::16, exp_id::32, data::bytes>>
<<0xFFFF::16, length::16, exp_id::32, data::bytes>>
end
def read(<<0xffff::16, _length::16, exp_id::32, exp_type::16, data::bytes>>) do
def read(<<0xFFFF::16, _length::16, exp_id::32, exp_type::16, data::bytes>>) do
case Openflow.Utils.get_enum(exp_id, :action_vendor) do
vendor_id when is_integer(vendor_id) ->
%Experimenter{exp_id: exp_id, data: <<exp_type::16, data::bytes>>}
vendor when is_atom(vendor) ->
case Openflow.Utils.get_enum(exp_type, vendor) do
codec when is_atom(codec) ->
codec.read(<<exp_id::32, exp_type::16, data::bytes>>)
exp_type when is_integer(exp_type) ->
%Experimenter{exp_id: exp_id, data: <<exp_type::16, data::bytes>>}
end

40
lib/openflow/actions/nx_bundle.ex
View file

@ -15,36 +15,44 @@ defmodule Openflow.Action.NxBundle do
def new(options) do
slaves = options[:slaves] || []
%NxBundle{algorithm: options[:algorithm] || :active_backup,
%NxBundle{
algorithm: options[:algorithm] || :active_backup,
hash_field: options[:hash_field] || :eth_src,
basis: options[:basis] || 0,
n_slaves: length(slaves),
slaves: slaves}
slaves: slaves
}
end
def to_binary(%NxBundle{algorithm: alg,
def to_binary(%NxBundle{
algorithm: alg,
hash_field: hash_field,
basis: basis,
slave_type: slave_type,
n_slaves: n_slaves,
slaves: slaves}) do
slaves: slaves
}) do
hash_field_int = Openflow.Enums.to_int(hash_field, :nx_hash_fields)
alg_int = Openflow.Enums.to_int(alg, :nx_bd_algorithm)
slave_type_bin = Openflow.Match.codec_header(slave_type)
slaves_bin = codec_slaves(slaves)
body = <<alg_int::16, hash_field_int::16, basis::16,
slave_type_bin::4-bytes, n_slaves::16, 0::16, 0::size(4)-unit(8), 0::32,
slaves_bin::bytes>>
body =
<<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16, 0::16,
0::size(4)-unit(8), 0::32, slaves_bin::bytes>>
exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<alg_int::16, hash_field_int::16, basis::16,
slave_type_bin::4-bytes, n_slaves::16, _::16, _::32, _::32, rest::bytes>> = body
<<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16, _::16,
_::32, _::32, rest::bytes>> = body
slave_len = n_slaves * 2
<<slaves_bin::size(slave_len)-bytes, _::bytes>> = rest
alg = Openflow.Enums.to_atom(alg_int, :nx_bd_algorithm)
@ -52,23 +60,29 @@ defmodule Openflow.Action.NxBundle do
slave_type = Openflow.Match.codec_header(slave_type_bin)
slaves = codec_slaves(slaves_bin)
n_slaves = length(slaves)
%NxBundle{algorithm: alg,
%NxBundle{
algorithm: alg,
hash_field: hash_field,
basis: basis,
slave_type: slave_type,
n_slaves: n_slaves,
slaves: slaves}
slaves: slaves
}
end
# private functions
defp codec_slaves(slaves) when is_list(slaves) do
slaves1 = for slave <- slaves do
slaves1 =
for slave <- slaves do
slave_int = Openflow.Utils.get_enum(slave, :openflow10_port_no)
<<slave_int::16>>
end
Enum.join(slaves1, "")
end
defp codec_slaves(slaves) when is_binary(slaves) do
for <<slave_int::16 <- slaves>> do
Openflow.Utils.get_enum(slave_int, :openflow10_port_no)

43
lib/openflow/actions/nx_bundle_load.ex
View file

@ -22,17 +22,21 @@ defmodule Openflow.Action.NxBundleLoad do
dst_field = options[:dst_field]
default_n_bits = Openflow.Match.Field.n_bits_of(dst_field)
slaves = options[:slaves] || []
%NxBundleLoad{algorithm: options[:algorithm] || :active_backup,
%NxBundleLoad{
algorithm: options[:algorithm] || :active_backup,
hash_field: options[:hash_field] || :eth_src,
basis: options[:basis] || 0,
n_slaves: length(slaves),
slaves: slaves,
offset: options[:offset] || 0,
n_bits: options[:n_bits] || default_n_bits,
dst_field: options[:dst_field]}
dst_field: options[:dst_field]
}
end
def to_binary(%NxBundleLoad{algorithm: alg,
def to_binary(%NxBundleLoad{
algorithm: alg,
hash_field: hash_field,
basis: basis,
slave_type: slave_type,
@ -40,27 +44,30 @@ defmodule Openflow.Action.NxBundleLoad do
slaves: slaves,
offset: ofs,
n_bits: n_bits,
dst_field: dst_field}) do
dst_field: dst_field
}) do
hash_field_int = Openflow.Enums.to_int(hash_field, :nx_hash_fields)
alg_int = Openflow.Enums.to_int(alg, :nx_bd_algorithm)
slave_type_bin = Openflow.Match.codec_header(slave_type)
slaves_bin = codec_slaves(slaves)
ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
ofs_nbits = ofs <<< 6 ||| n_bits - 1
dst_field_bin = Openflow.Match.codec_header(dst_field)
body = <<alg_int::16, hash_field_int::16, basis::16,
slave_type_bin::4-bytes, n_slaves::16, ofs_nbits::16,
dst_field_bin::4-bytes, 0::32, slaves_bin::bytes>>
body =
<<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16,
ofs_nbits::16, dst_field_bin::4-bytes, 0::32, slaves_bin::bytes>>
exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<alg_int::16, hash_field_int::16, basis::16,
slave_type_bin::4-bytes, n_slaves::16, ofs::10, n_bits::6,
dst_field_bin::4-bytes, _reserved::32, rest::bytes>> = body
<<alg_int::16, hash_field_int::16, basis::16, slave_type_bin::4-bytes, n_slaves::16, ofs::10,
n_bits::6, dst_field_bin::4-bytes, _reserved::32, rest::bytes>> = body
slave_len = n_slaves * 2
<<slaves_bin::size(slave_len)-bytes, _::bytes>> = rest
alg = Openflow.Enums.to_atom(alg_int, :nx_bd_algorithm)
@ -69,7 +76,9 @@ defmodule Openflow.Action.NxBundleLoad do
slaves = codec_slaves(slaves_bin)
n_slaves = length(slaves)
dst_field = Openflow.Match.codec_header(dst_field_bin)
%NxBundleLoad{algorithm: alg,
%NxBundleLoad{
algorithm: alg,
hash_field: hash_field,
basis: basis,
slave_type: slave_type,
@ -77,18 +86,22 @@ defmodule Openflow.Action.NxBundleLoad do
slaves: slaves,
offset: ofs,
n_bits: n_bits + 1,
dst_field: dst_field}
dst_field: dst_field
}
end
# private functions
defp codec_slaves(slaves) when is_list(slaves) do
slaves1 = for slave <- slaves do
slaves1 =
for slave <- slaves do
slave_int = Openflow.Utils.get_enum(slave, :openflow10_port_no)
<<slave_int::16>>
end
Enum.join(slaves1, "")
end
defp codec_slaves(slaves) when is_binary(slaves) do
for <<slave_int::16 <- slaves>> do
Openflow.Utils.get_enum(slave_int, :openflow10_port_no)

6
lib/openflow/actions/nx_clone.ex
View file

@ -1,7 +1,5 @@
defmodule Openflow.Action.NxClone do
defstruct(
actions: []
)
defstruct(actions: [])
@experimenter 0x00002320
@nxast 42
@ -18,7 +16,7 @@ defmodule Openflow.Action.NxClone do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8), actions_bin::bytes>>) do

8
lib/openflow/actions/nx_conjunction.ex
View file

@ -11,14 +11,16 @@ defmodule Openflow.Action.NxConjunction do
alias __MODULE__
def new(options) do
%NxConjunction{clause: options[:clause] || 0,
%NxConjunction{
clause: options[:clause] || 0,
n_clauses: options[:n_clauses] || 0,
id: options[:id] || 0}
id: options[:id] || 0
}
end
def to_binary(%NxConjunction{clause: clause, n_clauses: n_clauses, id: id}) do
exp_body = <<@experimenter::32, @nxast::16, clause::8, n_clauses::8, id::32>>
<<0xffff::16, 16::16, exp_body::bytes>>
<<0xFFFF::16, 16::16, exp_body::bytes>>
end
def read(<<@experimenter::32, @nxast::16, clause::8, n_clauses::8, id::32>>) do

40
lib/openflow/actions/nx_conntrack.ex
View file

@ -18,14 +18,16 @@ defmodule Openflow.Action.NxConntrack do
alias __MODULE__
def new(options \\ []) do
%NxConntrack{flags: options[:flags] || [],
%NxConntrack{
flags: options[:flags] || [],
zone_src: options[:zone_src],
zone_imm: options[:zone_imm] || 0,
zone_offset: options[:zone_offset],
zone_n_bits: options[:zone_n_bits],
recirc_table: options[:recirc_table] || 255,
alg: options[:alg] || 0,
exec: options[:exec] || []}
exec: options[:exec] || []
}
end
def to_binary(%NxConntrack{
@ -36,43 +38,53 @@ defmodule Openflow.Action.NxConntrack do
zone_imm: zone_imm,
recirc_table: recirc_table,
alg: alg,
exec: exec}) do
exec: exec
}) do
flags_int = Openflow.Enums.flags_to_int(flags, :nx_conntrack_flags)
{src_bin, ofs_nbits} = if not (is_nil(zone_src)) do
{src_bin, ofs_nbits} =
if not is_nil(zone_src) do
zone_src_bin = Openflow.Match.codec_header(zone_src)
{zone_src_bin, (zone_ofs <<< 6) ||| (zone_n_bits - 1)}
{zone_src_bin, zone_ofs <<< 6 ||| zone_n_bits - 1}
else
{<<0::32>>, zone_imm}
end
exec_bin = Openflow.Action.to_binary(exec)
exp_body = <<@experimenter::32, @nxast::16, flags_int::16,
src_bin::bytes, ofs_nbits::16, recirc_table::8,
0::size(3)-unit(8), alg::16, exec_bin::bytes>>
exp_body =
<<@experimenter::32, @nxast::16, flags_int::16, src_bin::bytes, ofs_nbits::16,
recirc_table::8, 0::size(3)-unit(8), alg::16, exec_bin::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, flags_int::16,
src_bin::4-bytes, ofs_nbits::16-bits, recirc_table::8,
_::size(3)-unit(8), alg::16, exec_bin::bytes>>) do
def read(
<<@experimenter::32, @nxast::16, flags_int::16, src_bin::4-bytes, ofs_nbits::16-bits,
recirc_table::8, _::size(3)-unit(8), alg::16, exec_bin::bytes>>
) do
flags = Openflow.Enums.int_to_flags(flags_int, :nx_conntrack_flags)
exec = Openflow.Action.read(exec_bin)
ct = %NxConntrack{
flags: flags,
recirc_table: recirc_table,
alg: alg,
exec: exec
}
case src_bin do
<<0::32>> ->
<<zone_imm::16>> = ofs_nbits
%{ct|zone_imm: zone_imm}
%{ct | zone_imm: zone_imm}
binary when is_binary(binary) ->
zone_src = Openflow.Match.codec_header(binary)
<<ofs::10, n_bits::6>> = ofs_nbits
%{ct|zone_src: zone_src, zone_offset: ofs, zone_n_bits: n_bits + 1}
%{ct | zone_src: zone_src, zone_offset: ofs, zone_n_bits: n_bits + 1}
end
end
end

18
lib/openflow/actions/nx_controller.ex
View file

@ -11,19 +11,27 @@ defmodule Openflow.Action.NxController do
alias __MODULE__
def new(options) do
%NxController{max_len: options[:max_len] || :no_buffer,
%NxController{
max_len: options[:max_len] || :no_buffer,
id: options[:id] || 0,
reason: options[:reason] || :action}
reason: options[:reason] || :action
}
end
def to_binary(%NxController{max_len: max_len, id: controller_id, reason: reason}) do
max_len_int = Openflow.Utils.get_enum(max_len, :controller_max_len)
reason_int = Openflow.Enums.to_int(reason, :packet_in_reason)
exp_body = <<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8, 0::8>>
<<0xffff::16, 16::16, exp_body::bytes>>
exp_body =
<<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8, 0::8>>
<<0xFFFF::16, 16::16, exp_body::bytes>>
end
def read(<<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8, _::bytes>>) do
def read(
<<@experimenter::32, @nxast::16, max_len_int::16, controller_id::16, reason_int::8,
_::bytes>>
) do
max_len = Openflow.Utils.get_enum(max_len_int, :controller_max_len)
reason = Openflow.Enums.to_atom(reason_int, :packet_in_reason)
%NxController{max_len: max_len, id: controller_id, reason: reason}

52
lib/openflow/actions/nx_controller2.ex
View file

@ -21,11 +21,13 @@ defmodule Openflow.Action.NxController2 do
alias __MODULE__
def new(options) do
%NxController2{max_len: options[:max_len] || :no_buffer,
%NxController2{
max_len: options[:max_len] || :no_buffer,
id: options[:id] || 0,
reason: options[:reason] || :action,
userdata: options[:userdata],
pause: options[:pause] || false}
pause: options[:pause] || false
}
end
def to_binary(%NxController2{} = ctl) do
@ -36,7 +38,7 @@ defmodule Openflow.Action.NxController2 do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes>>
<<0xFFFF::16, length::16, exp_body::bytes>>
end
def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8), body::bytes>>) do
@ -48,64 +50,88 @@ defmodule Openflow.Action.NxController2 do
defp get_prop_key(ctl) do
ctl
|> Map.from_struct
|> Enum.map(fn({k, v}) -> if(not is_nil(v), do: k, else: nil) end)
|> Enum.filter(fn(v) -> not is_nil(v) end)
|> Map.from_struct()
|> Enum.map(fn {k, v} -> if(not is_nil(v), do: k, else: nil) end)
|> Enum.filter(fn v -> not is_nil(v) end)
end
defp encode_prop(acc, [], _ctl), do: acc
defp encode_prop(acc, [prop|rest], ctl) do
defp encode_prop(acc, [prop | rest], ctl) do
value = Map.get(ctl, prop)
prop_bin = cond do
prop == :max_len and (value != :no_buffer or value < 0xffff) ->
prop_bin =
cond do
prop == :max_len and (value != :no_buffer or value < 0xFFFF) ->
padding_length = 2
prop_length = @prop_header_size + 2 + padding_length
max_len_int = Openflow.Utils.get_enum(value, :controller_max_len)
<<@prop_max_len::16, prop_length::16, max_len_int::16, 0::size(padding_length)-unit(8)>>
prop == :id ->
padding_length = 2
prop_length = @prop_header_size + 2 + padding_length
<<@prop_ctl_id::16, prop_length::16, value::16, 0::size(padding_length)-unit(8)>>
prop == :reason and value != :action ->
padding_length = 3
prop_length = @prop_header_size + 1 + padding_length
reason_int = Openflow.Utils.get_enum(value, :packet_in_reason)
<<@prop_reason::16, prop_length::16, reason_int::8, 0::size(padding_length)-unit(8)>>
prop == :userdata and byte_size(value) > 0 ->
prop_length = @prop_header_size + byte_size(value)
padding_length = Openflow.Utils.padding(prop_length, 8)
<<@prop_userdata::16, prop_length::16, value::bytes, 0::size(padding_length)-unit(8)>>
prop == :pause and value == true ->
padding_length = 4
prop_length = @prop_header_size + padding_length
<<@prop_pause::16, prop_length::16, 0::size(padding_length)-unit(8)>>
true ->
""
end
encode_prop(<<acc::bytes, prop_bin::bytes>>, rest, ctl)
end
defp decode_prop(ctl, ""), do: ctl
defp decode_prop(ctl, <<prop_type_int::16, _::bytes>> = bin) do
prop_type = Openflow.Enums.to_atom(prop_type_int, :nx_action_controller2_prop_type)
case prop_type do
:max_len ->
<<@prop_max_len::16, _prop_length::16, max_len_int::16, _::size(2)-unit(8), rest::bytes>> = bin
<<@prop_max_len::16, _prop_length::16, max_len_int::16, _::size(2)-unit(8), rest::bytes>> =
bin
max_len = Openflow.Utils.get_enum(max_len_int, :controller_max_len)
decode_prop(struct(ctl, %{max_len: max_len}), rest)
:controller_id ->
<<@prop_ctl_id::16, _prop_length::16, controller_id::16, _::size(2)-unit(8), rest::bytes>> = bin
<<@prop_ctl_id::16, _prop_length::16, controller_id::16, _::size(2)-unit(8), rest::bytes>> =
bin
decode_prop(struct(ctl, %{controller_id: controller_id}), rest)
:reason ->
<<@prop_reason::16, _prop_length::16, reason_int::8, _::size(3)-unit(8), rest::bytes>> = bin
<<@prop_reason::16, _prop_length::16, reason_int::8, _::size(3)-unit(8), rest::bytes>> =
bin
reason = Openflow.Utils.get_enum(reason_int, :packet_in_reason)
decode_prop(struct(ctl, %{reason: reason}), rest)
:userdata ->
<<@prop_userdata::16, prop_length::16, remains::bytes>> = bin
userdata_len = prop_length - 4
padding_length = Openflow.Utils.padding(prop_length, 8)
<<userdata::size(userdata_len)-bytes, _::size(padding_length)-unit(8), rest::bytes>> = remains
<<userdata::size(userdata_len)-bytes, _::size(padding_length)-unit(8), rest::bytes>> =
remains
decode_prop(struct(ctl, %{userdata: userdata}), rest)
:pause ->
<<@prop_pause::16, _::16, 0::size(4)-unit(8), rest::bytes>> = bin
decode_prop(struct(ctl, %{pause: true}), rest)

2
lib/openflow/actions/nx_ct_clear.ex
View file

@ -12,7 +12,7 @@ defmodule Openflow.Action.NxCtClear do
def to_binary(%NxCtClear{}) do
exp_body = <<@experimenter::32, @nxast::16, 0::16, 0::size(4)-unit(8)>>
<<0xffff::16, 16::16, exp_body::bytes>>
<<0xFFFF::16, 16::16, exp_body::bytes>>
end
def read(<<@experimenter::32, @nxast::16, _::16, _::size(4)-unit(8)>>) do

2
lib/openflow/actions/nx_dec_mpls_ttl.ex
View file

@ -12,7 +12,7 @@ defmodule Openflow.Action.NxDecMplsTtl do
def to_binary(%NxDecMplsTtl{}) do
exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8)>>
<<0xffff::16, 16::16, exp_body::bytes>>
<<0xFFFF::16, 16::16, exp_body::bytes>>
end
def read(<<@experimenter::32, @nxast::16, _::size(6)-unit(8)>>) do

2
lib/openflow/actions/nx_dec_ttl.ex
View file

@ -12,7 +12,7 @@ defmodule Openflow.Action.NxDecTtl do
def to_binary(%NxDecTtl{}) do
exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8)>>
<<0xffff::16, 16::16, exp_body::bytes>>
<<0xFFFF::16, 16::16, exp_body::bytes>>
end
def read(<<@experimenter::32, @nxast::16, _::16, _::size(4)-unit(8)>>) do

11
lib/openflow/actions/nx_dec_ttl_cnt_ids.ex
View file

@ -12,14 +12,17 @@ defmodule Openflow.Action.NxDecTtlCntIds do
def to_binary(%NxDecTtlCntIds{ids: ids}) do
n_controllers = length(ids)
ids_bin = Enum.join((for id <- ids, do: <<id::16>>), "")
ids_bin = Enum.join(for(id <- ids, do: <<id::16>>), "")
padding = Openflow.Utils.padding(n_controllers, 8)
exp_body = <<@experimenter::32, @nxast::16, n_controllers::16,
0::size(4)-unit(8), ids_bin::bytes, 0::size(padding)-unit(8)>>
exp_body =
<<@experimenter::32, @nxast::16, n_controllers::16, 0::size(4)-unit(8), ids_bin::bytes,
0::size(padding)-unit(8)>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, n_controllers::16, body::bitstring>>) do

2
lib/openflow/actions/nx_exit.ex
View file

@ -12,7 +12,7 @@ defmodule Openflow.Action.NxExit do
def to_binary(%NxExit{}) do
exp_body = <<@experimenter::32, @nxast::16, 0::48>>
<<0xffff::16, 16::16, exp_body::bytes>>
<<0xFFFF::16, 16::16, exp_body::bytes>>
end
def read(<<@experimenter::32, @nxast::16, 0::48>>) do

8
lib/openflow/actions/nx_fin_timeout.ex
View file

@ -10,13 +10,15 @@ defmodule Openflow.Action.NxFinTimeout do
alias __MODULE__
def new(options) do
%NxFinTimeout{idle_timeout: options[:idle_timeout] || 0,
hard_timeout: options[:hard_timeout] || 0}
%NxFinTimeout{
idle_timeout: options[:idle_timeout] || 0,
hard_timeout: options[:hard_timeout] || 0
}
end
def to_binary(%NxFinTimeout{idle_timeout: fin_idle, hard_timeout: fin_hard}) do
exp_body = <<@experimenter::32, @nxast::16, fin_idle::16, fin_hard::16>>
<<0xffff::16, 16::16, exp_body::bytes, 0::size(2)-unit(8)>>
<<0xFFFF::16, 16::16, exp_body::bytes, 0::size(2)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, fin_idle::16, fin_hard::16, _::size(2)-unit(8)>>) do

10
lib/openflow/actions/nx_flow_spec.ex
View file

@ -1,5 +1,4 @@
defmodule Openflow.Action.NxFlowSpec do
def read(flow_spec_bin) do
do_read([], flow_spec_bin)
end
@ -7,6 +6,7 @@ defmodule Openflow.Action.NxFlowSpec do
def to_binary(flow_specs) when is_list(flow_specs) do
to_binary(<<>>, flow_specs)
end
def to_binary(flow_spec) do
to_binary([flow_spec])
end
@ -15,15 +15,17 @@ defmodule Openflow.Action.NxFlowSpec do
defp do_read(acc, <<>>), do: Enum.reverse(acc)
defp do_read(acc, <<0::16, _::bitstring>>), do: Enum.reverse(acc)
defp do_read(acc, <<_::2, _::1, type::2, _::bitstring>> = binary) do
codec = Openflow.Enums.to_atom(type, :nx_flow_spec_type)
{flow_spec, rest} = codec.read(binary)
do_read([flow_spec|acc], rest)
do_read([flow_spec | acc], rest)
end
defp to_binary(acc, []), do: acc
defp to_binary(acc, [flow_spec|rest]) do
defp to_binary(acc, [flow_spec | rest]) do
codec = flow_spec.__struct__
to_binary(<<acc::bytes, (codec.to_binary(flow_spec))::bytes>>, rest)
to_binary(<<acc::bytes, codec.to_binary(flow_spec)::bytes>>, rest)
end
end

44
lib/openflow/actions/nx_flow_spec_load.ex
View file

@ -16,11 +16,14 @@ defmodule Openflow.Action.NxFlowSpecLoad do
def new(options) do
dst = options[:dst]
n_bits = options[:n_bits] || Openflow.Match.Field.n_bits_of(dst)
%NxFlowSpecLoad{src: options[:src],
%NxFlowSpecLoad{
src: options[:src],
dst: dst,
n_bits: n_bits,
src_offset: options[:src_offset] || 0,
dst_offset: options[:dst_offset] || 0}
dst_offset: options[:dst_offset] || 0
}
end
def to_binary(%NxFlowSpecLoad{} = fsm) do
@ -30,39 +33,49 @@ defmodule Openflow.Action.NxFlowSpecLoad do
src_offset: src_ofs,
dst_offset: dst_ofs
} = fsm
{src_code, src_bin} = codec_src(fsm)
dst_bin = Openflow.Match.codec_header(dst_field)
case src_code do
@learn_src_immediate ->
<<0::2, src_code::1, @learn_dst::2, n_bits::11,
src_bin::bytes, dst_bin::4-bytes, dst_ofs::16>>
<<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::bytes, dst_bin::4-bytes,
dst_ofs::16>>
@learn_src_field ->
<<0::2, src_code::1, @learn_dst::2, n_bits::11,
src_bin::4-bytes, src_ofs::16, dst_bin::4-bytes, dst_ofs::16>>
<<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
dst_bin::4-bytes, dst_ofs::16>>
end
end
def read(<<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes,
src_ofs::16, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>) do
def read(
<<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>
) do
src = Openflow.Match.codec_header(src_bin)
dst = Openflow.Match.codec_header(dst_bin)
flow_spec = %NxFlowSpecLoad{src: src,
flow_spec = %NxFlowSpecLoad{
src: src,
dst: dst,
n_bits: n_bits,
src_offset: src_ofs,
dst_offset: dst_ofs}
dst_offset: dst_ofs
}
{flow_spec, rest}
end
def read(<<_::2, @learn_src_immediate::1, @learn_dst::2, n_bits::11, binary::bitstring>>) do
rounded_up_len = Openflow.Utils.pad_length(n_bits, 8)
rounded_up_nbits = n_bits + rounded_up_len
<<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> = binary
<<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> =
binary
dst = Openflow.Match.codec_header(dst_bin)
src = Openflow.Match.Field.codec(src_bin, dst)
flow_spec = %NxFlowSpecLoad{src: src,
dst: dst,
n_bits: n_bits,
dst_offset: dst_ofs}
flow_spec = %NxFlowSpecLoad{src: src, dst: dst, n_bits: n_bits, dst_offset: dst_ofs}
{flow_spec, rest}
end
@ -72,6 +85,7 @@ defmodule Openflow.Action.NxFlowSpecLoad do
src_bin = Openflow.Match.codec_header(src_field)
{@learn_src_field, src_bin}
end
defp codec_src(%NxFlowSpecLoad{src: src, dst: dst_field}) do
src_bin = Openflow.Match.Field.codec(src, dst_field)
{@learn_src_immediate, src_bin}

44
lib/openflow/actions/nx_flow_spec_match.ex
View file

@ -16,11 +16,14 @@ defmodule Openflow.Action.NxFlowSpecMatch do
def new(options) do
dst = options[:dst]
n_bits = options[:n_bits] || Openflow.Match.Field.n_bits_of(dst)
%NxFlowSpecMatch{src: options[:src],
%NxFlowSpecMatch{
src: options[:src],
dst: dst,
n_bits: n_bits,
src_offset: options[:src_offset] || 0,
dst_offset: options[:dst_offset] || 0}
dst_offset: options[:dst_offset] || 0
}
end
def to_binary(%NxFlowSpecMatch{} = fsm) do
@ -30,39 +33,49 @@ defmodule Openflow.Action.NxFlowSpecMatch do
src_offset: src_ofs,
dst_offset: dst_ofs
} = fsm
{src_code, src_bin} = codec_src(fsm)
dst_bin = Openflow.Match.codec_header(dst_field)
case src_code do
@learn_src_immediate ->
<<0::2, src_code::1, @learn_dst::2, n_bits::11,
src_bin::bytes, dst_bin::4-bytes, dst_ofs::16>>
<<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::bytes, dst_bin::4-bytes,
dst_ofs::16>>
@learn_src_field ->
<<0::2, src_code::1, @learn_dst::2, n_bits::11,
src_bin::bytes, src_ofs::16, dst_bin::4-bytes, dst_ofs::16>>
<<0::2, src_code::1, @learn_dst::2, n_bits::11, src_bin::bytes, src_ofs::16,
dst_bin::4-bytes, dst_ofs::16>>
end
end
def read(<<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes,
src_ofs::16, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>) do
def read(
<<_::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
dst_bin::4-bytes, dst_ofs::16, rest::bitstring>>
) do
src = Openflow.Match.codec_header(src_bin)
dst = Openflow.Match.codec_header(dst_bin)
flow_spec = %NxFlowSpecMatch{src: src,
flow_spec = %NxFlowSpecMatch{
src: src,
dst: dst,
n_bits: n_bits,
src_offset: src_ofs,
dst_offset: dst_ofs}
dst_offset: dst_ofs
}
{flow_spec, rest}
end
def read(<<_::2, @learn_src_immediate::1, @learn_dst::2, n_bits::11, binary::bitstring>>) do
rounded_up_len = Openflow.Utils.pad_length(n_bits, 8)
rounded_up_nbits = n_bits + rounded_up_len
<<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> = binary
<<src_bin::size(rounded_up_nbits)-bits, dst_bin::4-bytes, dst_ofs::16, rest::bitstring>> =
binary
dst = Openflow.Match.codec_header(dst_bin)
src = Openflow.Match.Field.codec(src_bin, dst)
flow_spec = %NxFlowSpecMatch{src: src,
dst: dst,
n_bits: n_bits,
dst_offset: dst_ofs}
flow_spec = %NxFlowSpecMatch{src: src, dst: dst, n_bits: n_bits, dst_offset: dst_ofs}
{flow_spec, rest}
end
@ -72,6 +85,7 @@ defmodule Openflow.Action.NxFlowSpecMatch do
src_bin = Openflow.Match.codec_header(src_field)
{@learn_src_field, src_bin}
end
defp codec_src(%NxFlowSpecMatch{src: src, dst: dst_field}) do
src_bin = Openflow.Match.Field.codec(src, dst_field)
{@learn_src_immediate, src_bin}

18
lib/openflow/actions/nx_flow_spec_output.ex
View file

@ -13,24 +13,20 @@ defmodule Openflow.Action.NxFlowSpecOutput do
def new(options) do
src = options[:src]
n_bits = options[:n_bits] || Openflow.Match.Field.n_bits_of(src)
%NxFlowSpecOutput{n_bits: n_bits,
src: src,
src_offset: options[:src_offset] || 0}
%NxFlowSpecOutput{n_bits: n_bits, src: src, src_offset: options[:src_offset] || 0}
end
def to_binary(%NxFlowSpecOutput{n_bits: n_bits,
src: src,
src_offset: src_ofs}) do
def to_binary(%NxFlowSpecOutput{n_bits: n_bits, src: src, src_offset: src_ofs}) do
src_bin = Openflow.Match.codec_header(src)
<<0::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16>>
end
def read(<<0::2, @learn_src_field::1, @learn_dst::2,
n_bits::11, src_bin::4-bytes, src_ofs::16, rest::bitstring>>) do
def read(
<<0::2, @learn_src_field::1, @learn_dst::2, n_bits::11, src_bin::4-bytes, src_ofs::16,
rest::bitstring>>
) do
src = Openflow.Match.codec_header(src_bin)
flow_spec = %NxFlowSpecOutput{n_bits: n_bits,
src: src,
src_offset: src_ofs}
flow_spec = %NxFlowSpecOutput{n_bits: n_bits, src: src, src_offset: src_ofs}
{flow_spec, rest}
end
end

39
lib/openflow/actions/nx_learn.ex
View file

@ -17,18 +17,21 @@ defmodule Openflow.Action.NxLearn do
alias __MODULE__
def new(options) do
%NxLearn{idle_timeout: options[:idle_timeout] || 0,
%NxLearn{
idle_timeout: options[:idle_timeout] || 0,
hard_timeout: options[:hard_timeout] || 0,
priority: options[:priority] || 0,
cookie: options[:cookie] || 0,
flags: options[:flags] || [],
table_id: options[:table_id] || 0xff,
table_id: options[:table_id] || 0xFF,
fin_idle_timeout: options[:fin_idle_timeout] || 0,
fin_hard_timeout: options[:fin_hard_timeout] || 0,
flow_specs: options[:flow_specs] || []}
flow_specs: options[:flow_specs] || []
}
end
def to_binary(%NxLearn{idle_timeout: idle,
def to_binary(%NxLearn{
idle_timeout: idle,
hard_timeout: hard,
priority: prio,
cookie: cookie,
@ -36,27 +39,30 @@ defmodule Openflow.Action.NxLearn do
table_id: table_id,
fin_idle_timeout: fin_idle,
fin_hard_timeout: fin_hard,
flow_specs: flow_specs}) do
flow_specs: flow_specs
}) do
flags_int = Openflow.Enums.flags_to_int(flags, :nx_learn_flag)
flow_specs_bin = Openflow.Action.NxFlowSpec.to_binary(flow_specs)
exp_body = <<@experimenter::32, @nxast::16, idle::16, hard::16,
prio::16, cookie::64, flags_int::16, table_id::8,
0::size(1)-unit(8), fin_idle::16, fin_hard::16,
flow_specs_bin::bitstring>>
exp_body =
<<@experimenter::32, @nxast::16, idle::16, hard::16, prio::16, cookie::64, flags_int::16,
table_id::8, 0::size(1)-unit(8), fin_idle::16, fin_hard::16, flow_specs_bin::bitstring>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bitstring>>) do
<<idle::16, hard::16,
prio::16, cookie::64, flags_int::16, table_id::8,
_pad::size(1)-unit(8), fin_idle::16, fin_hard::16,
flow_specs_bin::bitstring>> = body
<<idle::16, hard::16, prio::16, cookie::64, flags_int::16, table_id::8, _pad::size(1)-unit(8),
fin_idle::16, fin_hard::16, flow_specs_bin::bitstring>> = body
flags = Openflow.Enums.int_to_flags(flags_int, :nx_learn_flag)
flow_specs = Openflow.Action.NxFlowSpec.read(flow_specs_bin)
%NxLearn{idle_timeout: idle,
%NxLearn{
idle_timeout: idle,
hard_timeout: hard,
priority: prio,
cookie: cookie,
@ -64,6 +70,7 @@ defmodule Openflow.Action.NxLearn do
table_id: table_id,
fin_idle_timeout: fin_idle,
fin_hard_timeout: fin_hard,
flow_specs: flow_specs}
flow_specs: flow_specs
}
end
end

46
lib/openflow/actions/nx_learn2.ex
View file

@ -20,21 +20,24 @@ defmodule Openflow.Action.NxLearn2 do
alias __MODULE__
def new(options) do
%NxLearn2{idle_timeout: options[:idle_timeout] || 0,
%NxLearn2{
idle_timeout: options[:idle_timeout] || 0,
hard_timeout: options[:hard_timeout] || 0,
priority: options[:priority] || 0,
cookie: options[:cookie] || 0,
flags: options[:flags] || [],
table_id: options[:table_id] || 0xff,
table_id: options[:table_id] || 0xFF,
fin_idle_timeout: options[:fin_idle_timeout] || 0,
fin_hard_timeout: options[:fin_hard_timeout] || 0,
limit: options[:limit] || 0,
result_dst_offset: options[:result_dst_offset] || 0,
result_dst: options[:result_dst],
flow_specs: options[:flow_specs] || []}
flow_specs: options[:flow_specs] || []
}
end
def to_binary(%NxLearn2{idle_timeout: idle,
def to_binary(%NxLearn2{
idle_timeout: idle,
hard_timeout: hard,
priority: prio,
cookie: cookie,
@ -45,31 +48,38 @@ defmodule Openflow.Action.NxLearn2 do
limit: limit,
result_dst_offset: result_dst_ofs,
result_dst: result_dst,
flow_specs: flow_specs}) do
flow_specs: flow_specs
}) do
flags_int = Openflow.Enums.flags_to_int(flags, :nx_learn_flag)
result_dst_bin = if :write_result in flags do
result_dst_bin =
if :write_result in flags do
Openflow.Match.codec_header(result_dst)
else
""
end
flow_specs_bin = Openflow.Action.NxFlowSpec.to_binary(flow_specs)
exp_body = <<@experimenter::32, @nxast::16, idle::16, hard::16,
prio::16, cookie::64, flags_int::16, table_id::8,
0::size(1)-unit(8), fin_idle::16, fin_hard::16,
limit::32, result_dst_ofs::16, 0::size(2)-unit(8),
result_dst_bin::bytes, flow_specs_bin::bitstring>>
exp_body =
<<@experimenter::32, @nxast::16, idle::16, hard::16, prio::16, cookie::64, flags_int::16,
table_id::8, 0::size(1)-unit(8), fin_idle::16, fin_hard::16, limit::32,
result_dst_ofs::16, 0::size(2)-unit(8), result_dst_bin::bytes, flow_specs_bin::bitstring>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<idle::16, hard::16, prio::16, cookie::64, flags_int::16, table_id::8,
0::8, fin_idle::16, fin_hard::16, limit::32,
result_dst_ofs::16, 0::size(2)-unit(8), rest::bytes>> = body
<<idle::16, hard::16, prio::16, cookie::64, flags_int::16, table_id::8, 0::8, fin_idle::16,
fin_hard::16, limit::32, result_dst_ofs::16, 0::size(2)-unit(8), rest::bytes>> = body
flags = Openflow.Enums.int_to_flags(flags_int, :nx_learn_flag)
learn = %NxLearn2{idle_timeout: idle,
learn = %NxLearn2{
idle_timeout: idle,
hard_timeout: hard,
priority: prio,
cookie: cookie,
@ -78,7 +88,9 @@ defmodule Openflow.Action.NxLearn2 do
fin_idle_timeout: fin_idle,
fin_hard_timeout: fin_hard,
limit: limit,
result_dst_offset: result_dst_ofs}
result_dst_offset: result_dst_ofs
}
if :write_result in flags do
header_size = Openflow.Match.header_size(rest)
<<result_dst_bin::size(header_size)-bytes, flow_specs_bin::bytes>> = rest

38
lib/openflow/actions/nx_multipath.ex
View file

@ -27,52 +27,62 @@ defmodule Openflow.Action.NxMultipath do
default_n_bits = Openflow.Match.Field.n_bits_of(dst_field)
n_bits = Keyword.get(options, :n_bits, default_n_bits)
ofs = Keyword.get(options, :offset, 0)
%NxMultipath{hash_field: hash_field,
%NxMultipath{
hash_field: hash_field,
basis: basis,
algorithm: alg,
max_link: max_link,
offset: ofs,
n_bits: n_bits,
argument: arg,
dst_field: dst_field}
dst_field: dst_field
}
end
def to_binary(%NxMultipath{hash_field: hash_field,
def to_binary(%NxMultipath{
hash_field: hash_field,
basis: basis,
algorithm: alg,
max_link: max_link,
argument: arg,
offset: ofs,
n_bits: n_bits,
dst_field: dst_field}) do
dst_field: dst_field
}) do
hash_field_int = Openflow.Enums.to_int(hash_field, :nx_hash_fields)
alg_int = Openflow.Enums.to_int(alg, :nx_mp_algorithm)
dst_field_bin = Openflow.Match.codec_header(dst_field)
ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
body = <<hash_field_int::16, basis::16, 0::size(2)-unit(8),
alg_int::16, max_link::16, arg::32, 0::size(2)-unit(8),
ofs_nbits::16, dst_field_bin::4-bytes>>
ofs_nbits = ofs <<< 6 ||| n_bits - 1
body =
<<hash_field_int::16, basis::16, 0::size(2)-unit(8), alg_int::16, max_link::16, arg::32,
0::size(2)-unit(8), ofs_nbits::16, dst_field_bin::4-bytes>>
exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<hash_field_int::16, basis::16, _::size(2)-unit(8),
alg_int::16, max_link::16, arg::32, _::size(2)-unit(8),
ofs::10, n_bits::6, dst_field_bin::4-bytes>> = body
<<hash_field_int::16, basis::16, _::size(2)-unit(8), alg_int::16, max_link::16, arg::32,
_::size(2)-unit(8), ofs::10, n_bits::6, dst_field_bin::4-bytes>> = body
hash_field = Openflow.Enums.to_atom(hash_field_int, :nx_hash_fields)
alg = Openflow.Enums.to_atom(alg_int, :nx_mp_algorithm)
dst_field = Openflow.Match.codec_header(dst_field_bin)
%NxMultipath{hash_field: hash_field,
%NxMultipath{
hash_field: hash_field,
basis: basis,
algorithm: alg,
max_link: max_link,
argument: arg,
offset: ofs,
n_bits: n_bits + 1,
dst_field: dst_field}
dst_field: dst_field
}
end
end

50
lib/openflow/actions/nx_nat.ex
View file

@ -22,30 +22,38 @@ defmodule Openflow.Action.NxNat do
ipv6_max = Keyword.get(options, :ipv6_max)
proto_min = Keyword.get(options, :proto_min)
proto_max = Keyword.get(options, :proto_max)
%NxNat{flags: flags,
%NxNat{
flags: flags,
ipv4_min: ipv4_min,
ipv4_max: ipv4_max,
ipv6_min: ipv6_min,
ipv6_max: ipv6_max,
proto_min: proto_min,
proto_max: proto_max}
proto_max: proto_max
}
end
def to_binary(%NxNat{flags: flags} = nat) do
flags_int = Openflow.Enums.flags_to_int(flags, :nx_nat_flags)
range_flags =
nat
|> get_ranges
|> Openflow.Enums.flags_to_int(:nx_nat_range)
|> Openflow.Enums.int_to_flags(:nx_nat_range)
ranges_bin = encode_ranges("", range_flags, nat)
range_flags_int = Openflow.Enums.flags_to_int(range_flags, :nx_nat_range)
exp_body = <<@experimenter::32, @nxast::16, 0::size(2)-unit(8),
flags_int::16, range_flags_int::16, ranges_bin::bytes>>
exp_body =
<<@experimenter::32, @nxast::16, 0::size(2)-unit(8), flags_int::16, range_flags_int::16,
ranges_bin::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
@ -59,33 +67,43 @@ defmodule Openflow.Action.NxNat do
defp get_ranges(nat) do
nat
|> Map.from_struct
|> Map.from_struct()
|> Map.delete(:flags)
|> Enum.map(fn({k, v}) -> if(not is_nil(v), do: k, else: nil) end)
|> Enum.filter(fn(v) -> not is_nil(v) end)
|> Enum.map(fn {k, v} -> if(not is_nil(v), do: k, else: nil) end)
|> Enum.filter(fn v -> not is_nil(v) end)
end
defp encode_ranges(acc, [], _nat), do: acc
defp encode_ranges(acc, [range|rest], nat) do
defp encode_ranges(acc, [range | rest], nat) do
cond do
range == :ipv4_min or range == :ipv4_max ->
case Map.get(nat, range) do
{a1, a2, a3, a4} ->
encode_ranges(<<acc::bytes, a1, a2, a3, a4>>, rest, nat)
"" ->
encode_ranges(<<acc::bytes>>, rest, nat)
end
range == :ipv6_min or range == :ipv6_max ->
case Map.get(nat, range) do
{a1, a2, a3, a4, a5, a6, a7, a8} ->
encode_ranges(<<acc::bytes, a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16>>, rest, nat)
encode_ranges(
<<acc::bytes, a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16>>,
rest,
nat
)
"" ->
encode_ranges(<<acc::bytes>>, rest, nat)
end
range == :proto_min or range == :proto_max ->
case Map.get(nat, range) do
proto when is_integer(proto) and proto in (1..0xffff) ->
proto when is_integer(proto) and proto in 1..0xFFFF ->
encode_ranges(<<acc::bytes, proto::16>>, rest, nat)
_ ->
encode_ranges(<<acc::bytes>>, rest, nat)
end
@ -93,26 +111,32 @@ defmodule Openflow.Action.NxNat do
end
defp decode_ranges(nat, [], _), do: nat
defp decode_ranges(nat, [range|ranges], bin) do
defp decode_ranges(nat, [range | ranges], bin) do
cond do
range == :ipv4_min or range == :ipv4_max ->
case bin do
<<a1, a2, a3, a4, rest::bytes>> ->
decode_ranges(struct(nat, %{range => {a1, a2, a3, a4}}), ranges, rest)
rest ->
decode_ranges(struct(nat, %{range => ""}), ranges, rest)
end
range == :ipv6_min or range == :ipv6_max ->
case bin do
<<a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16, rest::bytes>> ->
decode_ranges(struct(nat, %{range => {a1, a2, a3, a4, a5, a6, a7, a8}}), ranges, rest)
rest ->
decode_ranges(struct(nat, %{range => ""}), ranges, rest)
end
range == :proto_min or range == :proto_max ->
case bin do
<<proto::16, rest::bytes>> when proto in (1..0xffff) ->
<<proto::16, rest::bytes>> when proto in 1..0xFFFF ->
decode_ranges(struct(nat, %{range => proto}), ranges, rest)
rest ->
decode_ranges(struct(nat, %{range => ""}), ranges, rest)
end

2
lib/openflow/actions/nx_note.ex
View file

@ -16,7 +16,7 @@ defmodule Openflow.Action.NxNote do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, note_bin::bytes>>) do

19
lib/openflow/actions/nx_output_reg.ex
View file

@ -19,34 +19,25 @@ defmodule Openflow.Action.NxOutputReg do
n_bits = Keyword.get(options, :n_bits, default_n_bits)
ofs = Keyword.get(options, :offset, 0)
max_len = Keyword.get(options, :max_len, :no_buffer)
%NxOutputReg{n_bits: n_bits,
offset: ofs,
src_field: src_field,
max_len: max_len}
%NxOutputReg{n_bits: n_bits, offset: ofs, src_field: src_field, max_len: max_len}
end
def to_binary(%NxOutputReg{n_bits: n_bits,
offset: ofs,
src_field: src_field,
max_len: max_len}) do
def to_binary(%NxOutputReg{n_bits: n_bits, offset: ofs, src_field: src_field, max_len: max_len}) do
src_field_bin = Openflow.Match.codec_header(src_field)
ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
ofs_nbits = ofs <<< 6 ||| n_bits - 1
max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
body = <<ofs_nbits::16, src_field_bin::4-bytes, max_len::16, 0::size(6)-unit(8)>>
exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<ofs::10, n_bits::6, src_field_bin::4-bytes, max_len::16, _::size(6)-unit(8)>> = body
src_field = Openflow.Match.codec_header(src_field_bin)
max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
%NxOutputReg{n_bits: n_bits + 1,
offset: ofs,
src_field: src_field,
max_len: max_len}
%NxOutputReg{n_bits: n_bits + 1, offset: ofs, src_field: src_field, max_len: max_len}
end
end

11
lib/openflow/actions/nx_output_reg2.ex
View file

@ -24,7 +24,7 @@ defmodule Openflow.Action.NxOutputReg2 do
def to_binary(%NxOutputReg2{n_bits: n_bits, offset: ofs, src_field: src_field, max_len: max_len}) do
src_field_bin = Openflow.Match.codec_header(src_field)
ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
ofs_nbits = ofs <<< 6 ||| n_bits - 1
max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
padding = Openflow.Utils.padding(byte_size(src_field_bin), 10)
body = <<ofs_nbits::16, max_len::16, src_field_bin::bytes, 0::size(padding)-unit(8)>>
@ -32,20 +32,23 @@ defmodule Openflow.Action.NxOutputReg2 do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<ofs::10, n_bits::6, max_len::16, oxm_header::4-bytes, rest::bitstring>> = body
exp_size = match_header_size(oxm_header) - 4
<<experimenter_int::size(exp_size)-unit(8), _padding::bytes>> = rest
src_field = Openflow.Match.codec_header(<<oxm_header::bytes, experimenter_int::size(exp_size)-unit(8)>>)
src_field =
Openflow.Match.codec_header(<<oxm_header::bytes, experimenter_int::size(exp_size)-unit(8)>>)
max_len = Openflow.Utils.get_enum(max_len, :controller_max_len)
%NxOutputReg2{n_bits: n_bits + 1, offset: ofs, src_field: src_field, max_len: max_len}
end
# private functions
defp match_header_size(<<0xffff::16, _::bytes>>), do: 8
defp match_header_size(<<0xFFFF::16, _::bytes>>), do: 8
defp match_header_size(<<_::16, _::bytes>>), do: 4
end

2
lib/openflow/actions/nx_output_trunc.ex
View file

@ -21,7 +21,7 @@ defmodule Openflow.Action.NxOutputTrunc do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, port_no_int::16, max_len::32>>) do

2
lib/openflow/actions/nx_pop_mpls.ex
View file

@ -15,7 +15,7 @@ defmodule Openflow.Action.NxPopMpls do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, ethertype::16, _::size(4)-unit(8)>>) do

2
lib/openflow/actions/nx_pop_queue.ex
View file

@ -15,7 +15,7 @@ defmodule Openflow.Action.NxPopQueue do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8)>>) do

2
lib/openflow/actions/nx_push_mpls.ex
View file

@ -15,7 +15,7 @@ defmodule Openflow.Action.NxPushMpls do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, ethertype::16, _::size(4)-unit(8)>>) do

19
lib/openflow/actions/nx_reg_load.ex
View file

@ -19,36 +19,27 @@ defmodule Openflow.Action.NxRegLoad do
n_bits = Keyword.get(options, :n_bits, default_n_bits)
ofs = Keyword.get(options, :offset, 0)
value = Keyword.get(options, :value)
%NxRegLoad{n_bits: n_bits,
offset: ofs,
dst_field: dst_field,
value: value}
%NxRegLoad{n_bits: n_bits, offset: ofs, dst_field: dst_field, value: value}
end
def to_binary(%NxRegLoad{n_bits: n_bits,
offset: ofs,
dst_field: dst_field,
value: value}) do
def to_binary(%NxRegLoad{n_bits: n_bits, offset: ofs, dst_field: dst_field, value: value}) do
dst_field_bin = Openflow.Match.codec_header(dst_field)
value_bin0 = Openflow.Match.Field.codec(value, dst_field)
tmp_value = :binary.decode_unsigned(value_bin0, :big)
value_bin = <<tmp_value::64>>
ofs_nbits = (ofs <<< 6) ||| (n_bits - 1)
ofs_nbits = ofs <<< 6 ||| n_bits - 1
body = <<ofs_nbits::16, dst_field_bin::4-bytes, value_bin::bytes>>
exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<ofs::10, n_bits::6, dst_field_bin::4-bytes, value_bin::bytes>> = body
dst_field = Openflow.Match.codec_header(dst_field_bin)
value = Openflow.Match.Field.codec(value_bin, dst_field)
%NxRegLoad{n_bits: n_bits + 1,
offset: ofs,
dst_field: dst_field,
value: value}
%NxRegLoad{n_bits: n_bits + 1, offset: ofs, dst_field: dst_field, value: value}
end
end

14
lib/openflow/actions/nx_reg_load2.ex
View file

@ -18,23 +18,27 @@ defmodule Openflow.Action.NxRegLoad2 do
def to_binary(%NxRegLoad2{dst_field: dst_field, value: value}) do
match_bin =
[{dst_field, value}]
|> Openflow.Match.new
|> Openflow.Match.to_binary
|> Openflow.Match.new()
|> Openflow.Match.to_binary()
<<1::16, _length::16, padded_field::bytes>> = match_bin
patial_len = 4 + 4 + 2 + 6 + byte_size(padded_field)
padding = Openflow.Utils.padding(patial_len, 8)
exp_body = <<@experimenter::32, @nxast::16, 0::48, padded_field::bytes, 0::size(padding)-unit(8)>>
exp_body =
<<@experimenter::32, @nxast::16, 0::48, padded_field::bytes, 0::size(padding)-unit(8)>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, _::48, match_field_bin::bytes>>) do
<<_class::16, _field::7, _hm::1, flen::8, _rest::bytes>> = match_field_bin
match_len = 4 + 4 + flen
match_bin = <<1::16, match_len::16, match_field_bin::bytes, 0::size(4)-unit(8)>>
{[{dst_field, value}|_], _rest} = Openflow.Match.read(match_bin)
{[{dst_field, value} | _], _rest} = Openflow.Match.read(match_bin)
%NxRegLoad2{dst_field: dst_field, value: value}
end
end

33
lib/openflow/actions/nx_reg_move.ex
View file

@ -19,38 +19,49 @@ defmodule Openflow.Action.NxRegMove do
n_bits = Keyword.get(options, :n_bits, default_n_bits)
src_ofs = Keyword.get(options, :src_offset, 0)
dst_ofs = Keyword.get(options, :dst_offset, 0)
%NxRegMove{n_bits: n_bits,
%NxRegMove{
n_bits: n_bits,
src_offset: src_ofs,
dst_offset: dst_ofs,
src_field: src_field,
dst_field: dst_field}
dst_field: dst_field
}
end
def to_binary(%NxRegMove{n_bits: n_bits,
def to_binary(%NxRegMove{
n_bits: n_bits,
src_offset: src_ofs,
dst_offset: dst_ofs,
src_field: src_field,
dst_field: dst_field}) do
dst_field: dst_field
}) do
src_field_bin = Openflow.Match.codec_header(src_field)
dst_field_bin = Openflow.Match.codec_header(dst_field)
body = <<n_bits::16, src_ofs::16, dst_ofs::16,
src_field_bin::4-bytes, dst_field_bin::4-bytes>>
body =
<<n_bits::16, src_ofs::16, dst_ofs::16, src_field_bin::4-bytes, dst_field_bin::4-bytes>>
exp_body = <<@experimenter::32, @nxast::16, body::bytes>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, body::bytes>>) do
<<n_bits::16, src_ofs::16, dst_ofs::16,
src_field_bin::4-bytes, dst_field_bin::4-bytes>> = body
<<n_bits::16, src_ofs::16, dst_ofs::16, src_field_bin::4-bytes, dst_field_bin::4-bytes>> =
body
src_field = Openflow.Match.codec_header(src_field_bin)
dst_field = Openflow.Match.codec_header(dst_field_bin)
%NxRegMove{n_bits: n_bits,
%NxRegMove{
n_bits: n_bits,
src_offset: src_ofs,
dst_offset: dst_ofs,
src_field: src_field,
dst_field: dst_field}
dst_field: dst_field
}
end
end

4
lib/openflow/actions/nx_resubmit.ex
View file

@ -1,5 +1,5 @@
defmodule Openflow.Action.NxResubmit do
defstruct([in_port: :in_port])
defstruct(in_port: :in_port)
@experimenter 0x00002320
@nxast 1
@ -16,7 +16,7 @@ defmodule Openflow.Action.NxResubmit do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, in_port_int::16, _::size(4)-unit(8)>>) do

9
lib/openflow/actions/nx_resubmit_table.ex
View file

@ -1,5 +1,5 @@
defmodule Openflow.Action.NxResubmitTable do
defstruct([in_port: :in_port, table_id: :all])
defstruct(in_port: :in_port, table_id: :all)
@experimenter 0x00002320
@nxast 14
@ -9,6 +9,7 @@ defmodule Openflow.Action.NxResubmitTable do
def new(table_id) when is_atom(table_id) or is_integer(table_id) do
new(table_id: table_id)
end
def new(options) do
in_port = Keyword.get(options, :in_port, :in_port)
table_id = Keyword.get(options, :table_id, :all)
@ -22,10 +23,12 @@ defmodule Openflow.Action.NxResubmitTable do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>) do
def read(
<<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>
) do
in_port = Openflow.Utils.get_enum(in_port_int, :openflow10_port_no)
table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
%NxResubmitTable{in_port: in_port, table_id: table_id}

8
lib/openflow/actions/nx_resubmit_table_ct.ex
View file

@ -19,10 +19,12 @@ defmodule Openflow.Action.NxResubmitTableCt do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>) do
def read(
<<@experimenter::32, @nxast::16, in_port_int::16, table_id_int::8, 0::size(3)-unit(8)>>
) do
in_port = Openflow.Utils.get_enum(in_port_int, :openflow10_port_no)
table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
%NxResubmitTableCt{in_port: in_port, table_id: table_id}

33
lib/openflow/actions/nx_sample.ex
View file

@ -16,29 +16,40 @@ defmodule Openflow.Action.NxSample do
collector_set_id = Keyword.get(options, :collector_set_id, 0)
obs_domain_id = Keyword.get(options, :obs_domain_id, 0)
obs_point_id = Keyword.get(options, :obs_point_id, 0)
%NxSample{probability: probability,
%NxSample{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id}
obs_point_id: obs_point_id
}
end
def to_binary(%NxSample{probability: probability,
def to_binary(%NxSample{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id}) do
exp_body = <<@experimenter::32, @nxast::16, probability::16,
collector_set_id::32, obs_domain_id::32, obs_point_id::32>>
obs_point_id: obs_point_id
}) do
exp_body =
<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
obs_point_id::32>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, probability::16,
collector_set_id::32, obs_domain_id::32, obs_point_id::32>>) do
%NxSample{probability: probability,
def read(
<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
obs_point_id::32>>
) do
%NxSample{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id}
obs_point_id: obs_point_id
}
end
end

33
lib/openflow/actions/nx_sample2.ex
View file

@ -18,32 +18,43 @@ defmodule Openflow.Action.NxSample2 do
obs_domain_id = Keyword.get(options, :obs_domain_id, 0)
obs_point_id = Keyword.get(options, :obs_point_id, 0)
sampling_port = Keyword.get(options, :sampling_port, 0)
%NxSample2{probability: probability,
%NxSample2{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id,
sampling_port: sampling_port}
sampling_port: sampling_port
}
end
def to_binary(%NxSample2{probability: probability,
def to_binary(%NxSample2{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id,
sampling_port: sampling_port}) do
exp_body = <<@experimenter::32, @nxast::16, probability::16,
collector_set_id::32, obs_domain_id::32, obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>
sampling_port: sampling_port
}) do
exp_body =
<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32,
obs_domain_id::32, obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>) do
%NxSample2{probability: probability,
def read(
<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
obs_point_id::32, sampling_port::16, 0::size(6)-unit(8)>>
) do
%NxSample2{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id,
sampling_port: sampling_port}
sampling_port: sampling_port
}
end
end

35
lib/openflow/actions/nx_sample3.ex
View file

@ -20,37 +20,50 @@ defmodule Openflow.Action.NxSample3 do
obs_point_id = Keyword.get(options, :obs_point_id, 0)
sampling_port = Keyword.get(options, :sampling_port, 0)
direction = Keyword.get(options, :direction, :default)
%NxSample3{probability: probability,
%NxSample3{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id,
sampling_port: sampling_port,
direction: direction}
direction: direction
}
end
def to_binary(%NxSample3{probability: probability,
def to_binary(%NxSample3{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id,
sampling_port: sampling_port,
direction: direction}) do
direction: direction
}) do
direction_int = Openflow.Enums.to_int(direction, :nx_action_sample_direction)
exp_body = <<@experimenter::32, @nxast::16, probability::16, collector_set_id::32,
obs_domain_id::32, obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>
exp_body =
<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32,
obs_domain_id::32, obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>) do
def read(
<<@experimenter::32, @nxast::16, probability::16, collector_set_id::32, obs_domain_id::32,
obs_point_id::32, sampling_port::16, direction_int::8, 0::size(5)-unit(8)>>
) do
direction = Openflow.Enums.to_atom(direction_int, :nx_action_sample_direction)
%NxSample3{probability: probability,
%NxSample3{
probability: probability,
collector_set_id: collector_set_id,
obs_domain_id: obs_domain_id,
obs_point_id: obs_point_id,
sampling_port: sampling_port,
direction: direction}
direction: direction
}
end
end

2
lib/openflow/actions/nx_set_mpls_label.ex
View file

@ -15,7 +15,7 @@ defmodule Openflow.Action.NxSetMplsLabel do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, _::16, label::32>>) do

2
lib/openflow/actions/nx_set_mpls_tc.ex
View file

@ -15,7 +15,7 @@ defmodule Openflow.Action.NxSetMplsTc do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, tc::8, _::size(5)-unit(8)>>) do

2
lib/openflow/actions/nx_set_mpls_ttl.ex
View file

@ -15,7 +15,7 @@ defmodule Openflow.Action.NxSetMplsTtl do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, ttl::8, _::size(5)-unit(8)>>) do

4
lib/openflow/actions/nx_set_queue.ex
View file

@ -1,5 +1,5 @@
defmodule Openflow.Action.NxSetQueue do
defstruct([queue_id: 0])
defstruct(queue_id: 0)
@experimenter 0x00002320
@nxast 4
@ -15,7 +15,7 @@ defmodule Openflow.Action.NxSetQueue do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, 0::size(2)-unit(8), queue_id::32>>) do

2
lib/openflow/actions/nx_set_tunnel.ex
View file

@ -15,7 +15,7 @@ defmodule Openflow.Action.NxSetTunnel do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, _::16, tunnel_id::32>>) do

4
lib/openflow/actions/nx_set_tunnel64.ex
View file

@ -1,5 +1,5 @@
defmodule Openflow.Action.NxSetTunnel64 do
defstruct([tunnel_id: 0])
defstruct(tunnel_id: 0)
@experimenter 0x00002320
@nxast 9
@ -15,7 +15,7 @@ defmodule Openflow.Action.NxSetTunnel64 do
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, 0::size(6)-unit(8), tunnel_id::64>>) do

15
lib/openflow/actions/nx_stack_pop.ex
View file

@ -20,16 +20,21 @@ defmodule Openflow.Action.NxStackPop do
def to_binary(%NxStackPop{n_bits: n_bits, offset: ofs, field: field}) do
field_bin = Openflow.Match.codec_header(field)
exp_body = <<@experimenter::32, @nxast::16, ofs::16,
field_bin::4-bytes, n_bits::16, 0::size(6)-unit(8)>>
exp_body =
<<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
0::size(6)-unit(8)>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, ofs::16,
field_bin::4-bytes, n_bits::16, _::size(6)-unit(8)>>) do
def read(
<<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
_::size(6)-unit(8)>>
) do
field = Openflow.Match.codec_header(field_bin)
%NxStackPop{n_bits: n_bits, offset: ofs, field: field}
end

15
lib/openflow/actions/nx_stack_push.ex
View file

@ -20,16 +20,21 @@ defmodule Openflow.Action.NxStackPush do
def to_binary(%NxStackPush{n_bits: n_bits, offset: ofs, field: field}) do
field_bin = Openflow.Match.codec_header(field)
exp_body = <<@experimenter::32, @nxast::16, ofs::16,
field_bin::4-bytes, n_bits::16, 0::size(6)-unit(8)>>
exp_body =
<<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
0::size(6)-unit(8)>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, ofs::16,
field_bin::4-bytes, n_bits::16, _::size(6)-unit(8)>>) do
def read(
<<@experimenter::32, @nxast::16, ofs::16, field_bin::4-bytes, n_bits::16,
_::size(6)-unit(8)>>
) do
field = Openflow.Match.codec_header(field_bin)
%NxStackPush{n_bits: n_bits, offset: ofs, field: field}
end

11
lib/openflow/actions/nx_write_metadata.ex
View file

@ -1,7 +1,7 @@
defmodule Openflow.Action.NxWriteMetadata do
defstruct(
metadata: 0,
metadata_mask: 0xffffffffffffffff
metadata_mask: 0xFFFFFFFFFFFFFFFF
)
@experimenter 0x00002320
@ -12,18 +12,21 @@ defmodule Openflow.Action.NxWriteMetadata do
def new(metadata) when is_integer(metadata) do
new(metadata: metadata)
end
def new(options) when is_list(options) do
metadata = Keyword.get(options, :metadata, 0)
metadata_mask = Keyword.get(options, :metadata_mask, 0xffffffffffffffff)
metadata_mask = Keyword.get(options, :metadata_mask, 0xFFFFFFFFFFFFFFFF)
%NxWriteMetadata{metadata: metadata, metadata_mask: metadata_mask}
end
def to_binary(%NxWriteMetadata{metadata: metadata, metadata_mask: metadata_mask}) do
exp_body = <<@experimenter::32, @nxast::16, 0::size(6)-unit(8), metadata::64, metadata_mask::64>>
exp_body =
<<@experimenter::32, @nxast::16, 0::size(6)-unit(8), metadata::64, metadata_mask::64>>
exp_body_size = byte_size(exp_body)
padding_length = Openflow.Utils.padding(4 + exp_body_size, 8)
length = 4 + exp_body_size + padding_length
<<0xffff::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
<<0xFFFF::16, length::16, exp_body::bytes, 0::size(padding_length)-unit(8)>>
end
def read(<<@experimenter::32, @nxast::16, _::size(6)-unit(8), metadata::64, metadata_mask::64>>) do

1
lib/openflow/actions/output.ex
View file

@ -11,6 +11,7 @@ defmodule Openflow.Action.Output do
def new(port) when not is_list(port) do
new(port_number: port)
end
def new(options) when is_list(options) do
port_no = Keyword.get(options, :port_number)
max_len = Keyword.get(options, :max_len, :no_buffer)

2
lib/openflow/actions/push_pbb.ex
View file

@ -1,5 +1,5 @@
defmodule Openflow.Action.PushPbb do
defstruct(ethertype: 0x88e7)
defstruct(ethertype: 0x88E7)
alias __MODULE__

6
lib/openflow/actions/set_field.ex
View file

@ -14,8 +14,8 @@ defmodule Openflow.Action.SetField do
def to_binary(%SetField{field: {field, value}}) do
match_bin =
[{field, value}]
|> Openflow.Match.new
|> Openflow.Match.to_binary
|> Openflow.Match.new()
|> Openflow.Match.to_binary()
<<1::16, _length::16, padded_field::bytes>> = match_bin
patial_len = @set_field_size - 4 + byte_size(padded_field)
@ -28,7 +28,7 @@ defmodule Openflow.Action.SetField do
<<_class::16, _field::7, _hm::1, flen::8, _rest::bytes>> = match_field_bin
match_len = 4 + 4 + flen
match_bin = <<1::16, match_len::16, match_field_bin::bytes>>
{[field|_], _rest} = Openflow.Match.read(match_bin)
{[field | _], _rest} = Openflow.Match.read(match_bin)
%SetField{field: field}
end
end

6
lib/openflow/barrier/reply.ex
View file

@ -2,8 +2,10 @@ defmodule Openflow.Barrier.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__

6
lib/openflow/barrier/request.ex
View file

@ -2,8 +2,10 @@ defmodule Openflow.Barrier.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__

33
lib/openflow/buckets.ex
View file

@ -29,26 +29,43 @@ defmodule Openflow.Bucket do
# private functions
defp do_read(acc, ""), do: Enum.reverse(acc)
defp do_read(acc, <<length::16, weight::16, watch_port_int::32,
watch_group_int::32, _::size(4)-unit(8), binary::bytes>>) do
defp do_read(
acc,
<<length::16, weight::16, watch_port_int::32, watch_group_int::32, _::size(4)-unit(8),
binary::bytes>>
) do
actions_len = length - @header_size
<<actions_bin::size(actions_len)-bytes, rest::bytes>> = binary
watch_port = Openflow.Utils.get_enum(watch_port_int, :openflow13_port_no)
watch_group = Openflow.Utils.get_enum(watch_group_int, :group_id)
actions = Openflow.Action.read(actions_bin)
bucket = %Bucket{weight: weight, watch_port: watch_port, watch_group: watch_group, actions: actions}
do_read([bucket|acc], rest)
bucket = %Bucket{
weight: weight,
watch_port: watch_port,
watch_group: watch_group,
actions: actions
}
do_read([bucket | acc], rest)
end
defp to_binary(acc, []), do: acc
defp to_binary(acc, [bucket|rest]) do
%Bucket{weight: weight, watch_port: watch_port, watch_group: watch_group, actions: actions} = bucket
defp to_binary(acc, [bucket | rest]) do
%Bucket{weight: weight, watch_port: watch_port, watch_group: watch_group, actions: actions} =
bucket
watch_port_int = Openflow.Utils.get_enum(watch_port, :openflow13_port_no)
watch_group_int = Openflow.Utils.get_enum(watch_group, :group_id)
actions_bin = Openflow.Action.to_binary(actions)
length = byte_size(actions_bin) + @header_size
bucket_bin = <<length::16, weight::16, watch_port_int::32,
watch_group_int::32, 0::size(4)-unit(8), actions_bin::bytes>>
bucket_bin =
<<length::16, weight::16, watch_port_int::32, watch_group_int::32, 0::size(4)-unit(8),
actions_bin::bytes>>
to_binary(<<acc::bytes, bucket_bin::bytes>>, rest)
end
end

6
lib/openflow/echo/reply.ex
View file

@ -3,8 +3,10 @@ defmodule Openflow.Echo.Reply do
version: 4,
xid: 0,
data: "",
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__

7
lib/openflow/echo/request.ex
View file

@ -3,8 +3,10 @@ defmodule Openflow.Echo.Request do
version: 4,
xid: 0,
data: "",
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__
@ -23,4 +25,3 @@ defmodule Openflow.Echo.Request do
data
end
end

212
lib/openflow/enums.ex
View file

@ -32,12 +32,10 @@ defmodule Openflow.Enums do
{Openflow.SetAsync, 28},
{Openflow.MeterMod, 29}
],
experimenter_id: [
nicira_ext_message: 0x00002320,
onf_ext_message: 0x4f4e4600
onf_ext_message: 0x4F4E4600
],
nicira_ext_message: [
# {Openflow.NxRole.Request, 10}, /* Openflow 1.3 support role request/reply */
# {Openflow.NxRole.Reply, 11},
@ -61,20 +59,16 @@ defmodule Openflow.Enums do
{Openflow.NxCtFlushZone, 29},
{Openflow.NxPacketIn2, 30}
],
onf_ext_message: [
{Openflow.OnfBundleControl, 2300},
{Openflow.OnfBundleAddMessage, 2301},
{Openflow.OnfBundleAddMessage, 2301}
],
multipart_request_flags: [
more: 1 <<< 0
],
multipart_reply_flags: [
more: 1 <<< 0
],
multipart_request_codec: [
{Openflow.Multipart.Desc.Request, 0},
{Openflow.Multipart.Flow.Request, 1},
@ -90,9 +84,8 @@ defmodule Openflow.Enums do
{Openflow.Multipart.MeterFeatures.Request, 11},
{Openflow.Multipart.TableFeatures.Request, 12},
{Openflow.Multipart.PortDesc.Request, 13},
{Openflow.Multipart.Experimenter.Request, 0xffff},
{Openflow.Multipart.Experimenter.Request, 0xFFFF}
],
multipart_reply_codec: [
{Openflow.Multipart.Desc.Reply, 0},
{Openflow.Multipart.Flow.Reply, 1},
@ -108,21 +101,18 @@ defmodule Openflow.Enums do
{Openflow.Multipart.MeterFeatures.Reply, 11},
{Openflow.Multipart.TableFeatures.Reply, 12},
{Openflow.Multipart.PortDesc.Reply, 13},
{Openflow.Multipart.Experimenter.Reply, 0xffff},
{Openflow.Multipart.Experimenter.Reply, 0xFFFF}
],
nicira_ext_stats: [
{Openflow.Multipart.NxFlow, 0},
{Openflow.Multipart.NxAggregate, 1},
{Openflow.Multipart.NxFlowMonitor, 2},
{Openflow.Multipart.NxIPFIXBridge, 3},
{Openflow.Multipart.NxIPFIXFlow, 4},
{Openflow.Multipart.NxIPFIXFlow, 4}
],
hello_elem: [
versionbitmap: 1
],
error_type: [
hello_failed: 0,
bad_request: 1,
@ -138,14 +128,12 @@ defmodule Openflow.Enums do
role_request_failed: 11,
meter_mod_failed: 12,
table_features_failed: 13,
experimenter: 0xffff
experimenter: 0xFFFF
],
hello_failed: [
inconpatible: 0,
eperm: 1
],
bad_request: [
bad_version: 0,
bad_type: 1,
@ -162,7 +150,6 @@ defmodule Openflow.Enums do
bad_packet: 12,
multipart_buffer_overflow: 13
],
bad_action: [
bad_type: 0,
bad_len: 1,
@ -181,7 +168,6 @@ defmodule Openflow.Enums do
bad_set_len: 14,
bad_set_argument: 15
],
bad_instruction: [
unknown_instruction: 0,
unsupported_instruction: 1,
@ -193,7 +179,6 @@ defmodule Openflow.Enums do
bad_len: 7,
eperm: 8
],
bad_match: [
bad_type: 0,
bad_len: 1,
@ -208,7 +193,6 @@ defmodule Openflow.Enums do
dup_field: 10,
eperm: 11
],
flow_mod_failed: [
unknown: 0,
table_full: 1,
@ -219,7 +203,6 @@ defmodule Openflow.Enums do
bad_command: 6,
bad_flags: 7
],
group_mod_failed: [
group_exists: 0,
invalid_group: 1,
@ -237,7 +220,6 @@ defmodule Openflow.Enums do
bad_watch: 13,
eperm: 14
],
port_mod_failed: [
bad_port: 0,
bad_hw_addr: 1,
@ -245,31 +227,26 @@ defmodule Openflow.Enums do
bad_advertise: 3,
eperm: 4
],
table_mod_failed: [
bad_table: 0,
bad_config: 1,
eperm: 2
],
queue_op_failed: [
bad_port: 0,
bad_queue: 1,
eperm: 2
],
switch_config_failed: [
bad_flags: 0,
bad_len: 1,
eperm: 2
],
role_request_failed: [
stale: 0,
unsup: 1,
bad_role: 2
],
meter_mod_failed: [
unknown: 0,
meter_exists: 1,
@ -284,7 +261,6 @@ defmodule Openflow.Enums do
out_of_meters: 10,
out_of_bands: 11
],
table_features_failed: [
bad_table: 0,
bad_metadata: 1,
@ -293,7 +269,6 @@ defmodule Openflow.Enums do
bad_argument: 4,
eperm: 5
],
switch_capabilities: [
flow_stats: 1 <<< 0,
table_stats: 1 <<< 1,
@ -304,36 +279,30 @@ defmodule Openflow.Enums do
arp_match_ip: 1 <<< 7,
port_blocked: 1 <<< 8
],
config_flags: [
drop: 1 <<< 0,
reasm: 1 <<< 1
],
controller_max_len: [
max: 0xffe5,
no_buffer: 0xffff
max: 0xFFE5,
no_buffer: 0xFFFF
],
experimenter_oxm_vendors: [
nicira_ext_match: 0x00002320,
hp_ext_match: 0x00002428,
onf_ext_match: 0x4f4e4600
onf_ext_match: 0x4F4E4600
],
match_type: [
standard: 0,
oxm: 1
],
oxm_class: [
nxm_0: 0x0000,
nxm_1: 0x0001,
openflow_basic: 0x8000,
packet_register: 0x8001,
experimenter: 0xffff
experimenter: 0xFFFF
],
nxm_0: [
nx_in_port: 0,
nx_eth_dst: 1,
@ -353,9 +322,8 @@ defmodule Openflow.Enums do
nx_arp_op: 15,
nx_arp_spa: 16,
nx_arp_tpa: 17,
nx_tcp_flags: 34,
nx_tcp_flags: 34
],
nxm_1: [
reg0: 0,
reg1: 1,
@ -483,7 +451,6 @@ defmodule Openflow.Enums do
ct_tp_src: 124,
ct_tp_dst: 125
],
openflow_basic: [
in_port: 0,
in_phy_port: 1,
@ -555,12 +522,10 @@ defmodule Openflow.Enums do
gtpu_extn_udp_port: 66,
gtpu_extn_sci: 67
],
vlan_id: [
present: 0x1000,
none: 0x0000
],
ipv6exthdr_flags: [
nonext: 1 <<< 0,
esp: 1 <<< 1,
@ -572,7 +537,6 @@ defmodule Openflow.Enums do
unrep: 1 <<< 7,
unseq: 1 <<< 8
],
tcp_flags: [
fin: 1 <<< 0,
syn: 1 <<< 1,
@ -584,18 +548,24 @@ defmodule Openflow.Enums do
cwr: 1 <<< 7,
ns: 1 <<< 8
],
ct_state_flags: [
new: 1 <<< 0, # Beginning of a new connection.
est: 1 <<< 1, # Part of an existing connection.
rel: 1 <<< 2, # Related to an established connection.
rep: 1 <<< 3, # Flow is in the reply direction.
inv: 1 <<< 4, # Could not track connection.
trk: 1 <<< 5, # Conntrack has occurred.
snat: 1 <<< 6, # Packet's source address/port was mangled by NAT.
dnat: 1 <<< 7 # Packet's destination address/port was mangled by NAT.
# Beginning of a new connection.
new: 1 <<< 0,
# Part of an existing connection.
est: 1 <<< 1,
# Related to an established connection.
rel: 1 <<< 2,
# Flow is in the reply direction.
rep: 1 <<< 3,
# Could not track connection.
inv: 1 <<< 4,
# Conntrack has occurred.
trk: 1 <<< 5,
# Packet's source address/port was mangled by NAT.
snat: 1 <<< 6,
# Packet's destination address/port was mangled by NAT.
dnat: 1 <<< 7
],
packet_register: [
xreg0: 0,
xreg1: 1,
@ -606,7 +576,6 @@ defmodule Openflow.Enums do
xreg6: 6,
xreg7: 7
],
nicira_ext_match: [
nsh_flags: 1,
nsh_mdtype: 2,
@ -618,7 +587,6 @@ defmodule Openflow.Enums do
nsh_c3: 8,
nsh_c4: 9
],
hp_ext_match: [
hp_udp_src_port_range: 0,
hp_udp_dst_port_range: 1,
@ -630,42 +598,35 @@ defmodule Openflow.Enums do
hp_custom_3: 7,
hp_custom_4: 8
],
hp_custom_match_type: [
l2_start: 1,
l3_start: 2,
l4_start: 3
],
onf_ext_match: [
onf_tcp_flags: 42,
onf_actset_output: 43,
onf_pbb_uca: 2560,
onf_pbb_uca: 2560
],
packet_in_reason: [
no_match: 0,
action: 1,
invalid_ttl: 2
],
buffer_id: [
no_buffer: 0xffffffff
no_buffer: 0xFFFFFFFF
],
port_config: [
port_down: 1 <<< 0,
no_receive: 1 <<< 2,
no_forward: 1 <<< 5,
no_packet_in: 1 <<< 6
],
port_state: [
link_down: 1 <<< 0,
blocked: 1 <<< 1,
live: 1 <<< 2
],
port_features: [
{:"10mb_hd", 1 <<< 0},
{:"10mb_fd", 1 <<< 1},
@ -684,31 +645,28 @@ defmodule Openflow.Enums do
{:pause, 1 <<< 14},
{:pause_asym, 1 <<< 15}
],
openflow10_port_no: [
max: 0xff00,
in_port: 0xfff8,
table: 0xfff9,
normal: 0xfffa,
flood: 0xfffb,
all: 0xfffc,
controller: 0xfffd,
local: 0xfffe,
none: 0xffff
max: 0xFF00,
in_port: 0xFFF8,
table: 0xFFF9,
normal: 0xFFFA,
flood: 0xFFFB,
all: 0xFFFC,
controller: 0xFFFD,
local: 0xFFFE,
none: 0xFFFF
],
openflow13_port_no: [
max: 0xffffff00,
in_port: 0xfffffff8,
table: 0xfffffff9,
normal: 0xfffffffa,
flood: 0xfffffffb,
all: 0xfffffffc,
controller: 0xfffffffd,
local: 0xfffffffe,
any: 0xffffffff
max: 0xFFFFFF00,
in_port: 0xFFFFFFF8,
table: 0xFFFFFFF9,
normal: 0xFFFFFFFA,
flood: 0xFFFFFFFB,
all: 0xFFFFFFFC,
controller: 0xFFFFFFFD,
local: 0xFFFFFFFE,
any: 0xFFFFFFFF
],
packet_in_reason: [
no_match: 0,
action: 1,
@ -717,7 +675,6 @@ defmodule Openflow.Enums do
group: 4,
packet_out: 5
],
flow_mod_command: [
add: 0,
modify: 1,
@ -725,7 +682,6 @@ defmodule Openflow.Enums do
delete: 3,
delete_strict: 4
],
flow_mod_flags: [
send_flow_rem: 1 <<< 0,
check_overlap: 1 <<< 1,
@ -733,7 +689,6 @@ defmodule Openflow.Enums do
no_packet_counts: 1 <<< 3,
no_byte_counts: 1 <<< 4
],
flow_removed_reason: [
idle_timeout: 0,
hard_timeout: 1,
@ -742,74 +697,62 @@ defmodule Openflow.Enums do
meter_delete: 4,
eviction: 5
],
port_reason: [
add: 0,
delete: 1,
modify: 2
],
group_mod_command: [
add: 0,
modify: 1,
delete: 2
],
group_type: [
all: 0,
select: 1,
indirect: 2,
fast_failover: 3
],
group_id: [
max: 0xffffff00,
all: 0xfffffffc,
any: 0xffffffff
max: 0xFFFFFF00,
all: 0xFFFFFFFC,
any: 0xFFFFFFFF
],
group_capabilities: [
select_weight: 1 <<< 0,
select_liveness: 1 <<< 1,
chaining: 1 <<< 2,
chaining_checks: 1 <<< 3
],
table_id: [
max: 0xfe,
all: 0xff
max: 0xFE,
all: 0xFF
],
queue_id: [
all: 0xffffffff
all: 0xFFFFFFFF
],
meter_mod_command: [
add: 0,
modify: 1,
delete: 2
],
meter_id: [
max: 0xffff0000,
slowpath: 0xfffffffd,
controller: 0xfffffffe,
all: 0xffffffff
max: 0xFFFF0000,
slowpath: 0xFFFFFFFD,
controller: 0xFFFFFFFE,
all: 0xFFFFFFFF
],
meter_flags: [
kbps: 1 <<< 0,
pktps: 1 <<< 1,
burst: 1 <<< 2,
stats: 1 <<< 3
],
meter_band_type: [
{Openflow.MeterBand.Drop, 1},
{Openflow.MeterBand.Remark, 2},
{Openflow.MeterBand.Experimenter, 0xffff},
{Openflow.MeterBand.Experimenter, 0xFFFF}
],
table_config: [
table_miss_controller: 0 <<< 0,
table_miss_continue: 1 <<< 0,
@ -818,7 +761,6 @@ defmodule Openflow.Enums do
eviction: 1 <<< 2,
vacancy_events: 1 <<< 3
],
action_type: [
{Openflow.Action.Output, 0},
{Openflow.Action.CopyTtlOut, 11},
@ -840,18 +782,15 @@ defmodule Openflow.Enums do
{Openflow.Action.Decap, 29},
{Openflow.Action.SetSequence, 30},
{Openflow.Action.ValidateSequence, 31},
{Openflow.Action.Experimenter, 0xffff}
{Openflow.Action.Experimenter, 0xFFFF}
],
action_vendor: [
nicira_ext_action: 0x00002320,
onf_ext_action: 0x4f4e4600
onf_ext_action: 0x4F4E4600
],
onf_ext_action: [
{Openflow.Action.OnfCopyField, 3200}
],
nicira_ext_action: [
{Openflow.Action.NxResubmit, 1},
{Openflow.Action.NxSetTunnel, 2},
@ -898,41 +837,35 @@ defmodule Openflow.Enums do
{Openflow.Action.NxLearn2, 45},
{Openflow.Action.NxEncap, 46},
{Openflow.Action.NxDecap, 47},
{Openflow.Action.NxDebugRecirc, 0xff},
{Openflow.Action.NxDebugRecirc, 0xFF}
],
nx_mp_algorithm: [
modulo_n: 0,
hash_threshold: 1,
highest_random_weight: 2,
iterative_hash: 3
],
nx_hash_fields: [
eth_src: 0,
symmetric_l4: 1,
symmetric_l3l4: 2,
symmetric_l3l4_udp: 3,
nw_src: 4,
nw_dst: 5,
nw_dst: 5
],
nx_bd_algorithm: [
active_backup: 0,
highest_random_weight: 1
],
nx_learn_flag: [
send_flow_rem: 1 <<< 0,
delete_learned: 1 <<< 1,
write_result: 1 <<< 2
],
nx_conntrack_flags: [
commit: 1 <<< 0,
force: 1 <<< 1
],
nx_nat_flags: [
src: 1 <<< 0,
dst: 1 <<< 1,
@ -940,7 +873,6 @@ defmodule Openflow.Enums do
protocol_hash: 1 <<< 3,
protocol_random: 1 <<< 4
],
nx_nat_range: [
ipv4_min: 1 <<< 0,
ipv4_max: 1 <<< 1,
@ -949,7 +881,6 @@ defmodule Openflow.Enums do
proto_min: 1 <<< 4,
proto_max: 1 <<< 5
],
nx_action_controller2_prop_type: [
max_len: 0,
controller_id: 1,
@ -957,19 +888,16 @@ defmodule Openflow.Enums do
userdata: 3,
pause: 4
],
nx_action_sample_direction: [
default: 0,
ingress: 1,
egress: 2
],
nx_flow_spec_type: [
{Openflow.Action.NxFlowSpecMatch, 0},
{Openflow.Action.NxFlowSpecLoad, 1},
{Openflow.Action.NxFlowSpecOutput, 2}
],
instruction_type: [
{Openflow.Instruction.GotoTable, 1},
{Openflow.Instruction.WriteMetadata, 2},
@ -977,33 +905,28 @@ defmodule Openflow.Enums do
{Openflow.Instruction.ApplyActions, 4},
{Openflow.Instruction.ClearActions, 5},
{Openflow.Instruction.Meter, 6},
{Openflow.Instruction.Experimenter, 0xffff}
{Openflow.Instruction.Experimenter, 0xFFFF}
],
controller_role: [
nochange: 0,
equal: 1,
master: 2,
slave: 3
],
nx_role: [
other: 0,
master: 1,
slave: 2
],
packet_in_format: [
standard: 0,
nxt_packet_in: 1,
nxt_packet_in2: 2
],
flow_format: [
openflow10: 0,
nxm: 1
],
packet_in2_prop_type: [
packet: 0,
full_len: 1,
@ -1015,7 +938,6 @@ defmodule Openflow.Enums do
userdata: 7,
continuation: 8
],
continuation_prop_type: [
bridge: 0x8000,
stack: 0x8001,
@ -1026,7 +948,6 @@ defmodule Openflow.Enums do
actions: 0x8006,
action_set: 0x8007
],
flow_monitor_flag: [
initial: 1 <<< 0,
add: 1 <<< 1,
@ -1035,20 +956,17 @@ defmodule Openflow.Enums do
actions: 1 <<< 4,
own: 1 <<< 5
],
flow_update_event: [
added: 0,
deleted: 1,
modified: 2,
abbrev: 3
],
tlv_table_mod_command: [
add: 0,
delete: 1,
clear: 2
],
table_feature_prop_type: [
instructions: 0,
instructions_miss: 1,
@ -1064,8 +982,8 @@ defmodule Openflow.Enums do
write_setfield_miss: 13,
apply_setfield: 14,
apply_setfield_miss: 15,
experimenter: 0xfffe,
experimenter_miss: 0xffff
experimenter: 0xFFFE,
experimenter_miss: 0xFFFF
]
]

24
lib/openflow/error_msg.ex
View file

@ -9,16 +9,19 @@ defmodule Openflow.ErrorMsg do
data: "",
exp_type: nil,
experimenter: nil,
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__
def ofp_type, do: 1
def read(<<0xffff::16, exp_type::16, experimenter::32, data::bytes>>) do
error_type = Openflow.Enums.to_atom(0xffff, :error_type)
def read(<<0xFFFF::16, exp_type::16, experimenter::32, data::bytes>>) do
error_type = Openflow.Enums.to_atom(0xFFFF, :error_type)
%ErrorMsg{
type: error_type,
exp_type: exp_type,
@ -26,9 +29,11 @@ defmodule Openflow.ErrorMsg do
data: data
}
end
def read(<<type::16, code::16, data::bytes>>) do
error_type = Openflow.Enums.to_atom(type, :error_type)
error_code = Openflow.Enums.to_atom(code, error_type)
%ErrorMsg{
type: error_type,
code: error_code,
@ -36,16 +41,17 @@ defmodule Openflow.ErrorMsg do
}
end
def to_binary(%ErrorMsg{type: :experimenter,
def to_binary(%ErrorMsg{
type: :experimenter,
exp_type: exp_type,
experimenter: experimenter,
data: data}) do
data: data
}) do
error_type = Openflow.Enums.to_int(:experimenter, :error_type)
<<error_type::16, exp_type::16, experimenter::32, data::bytes>>
end
def to_binary(%ErrorMsg{type: type,
code: code,
data: data}) do
def to_binary(%ErrorMsg{type: type, code: code, data: data}) do
error_type = Openflow.Enums.to_int(type, :error_type)
error_code = Openflow.Enums.to_int(code, type)
<<error_type::16, error_code::16, data::bytes>>

8
lib/openflow/experimenter.ex
View file

@ -14,9 +14,11 @@ defmodule Openflow.Experimenter do
def ofp_type, do: 4
def new(options) do
%Experimenter{exp_id: Keyword.get(options, :exp_id, 0),
%Experimenter{
exp_id: Keyword.get(options, :exp_id, 0),
exp_type: Keyword.get(options, :exp_type, 0),
data: Keyword.get(options, :data, "")}
data: Keyword.get(options, :data, "")
}
end
def to_binary(%Experimenter{exp_id: exp_id, exp_type: exp_type, data: data}) do
@ -27,10 +29,12 @@ defmodule Openflow.Experimenter do
case Openflow.Utils.get_enum(exp_id, :experimenter_id) do
^exp_id ->
%Experimenter{exp_id: exp_id, exp_type: exp_type, data: data}
experimenter when is_atom(experimenter) ->
case Openflow.Utils.get_enum(exp_type, experimenter) do
^exp_type ->
%Experimenter{exp_id: exp_id, exp_type: exp_type, data: data}
codec when is_atom(codec) ->
codec.read(<<exp_id::32, exp_type::32, data::bytes>>)
end

9
lib/openflow/features/reply.ex
View file

@ -13,10 +13,12 @@ defmodule Openflow.Features.Reply do
def ofp_type, do: 6
def read(<<datapath_id::64-bits, n_buf::32, n_tab::8,
aux_id::8, _pad::16, caps_int::32, _rsv::32>>) do
def read(
<<datapath_id::64-bits, n_buf::32, n_tab::8, aux_id::8, _pad::16, caps_int::32, _rsv::32>>
) do
dpid = Openflow.Utils.to_hex_string(datapath_id)
flags = Openflow.Enums.int_to_flags(caps_int, :switch_capabilities)
%Reply{
datapath_id: dpid,
n_buffers: n_buf,
@ -31,7 +33,8 @@ defmodule Openflow.Features.Reply do
n_buffers: n_buf,
n_tables: n_tab,
aux_id: aux_id,
capabilities: flags}) do
capabilities: flags
}) do
dpid_int = String.to_integer(datapath_id, 16)
flags_int = Openflow.Enums.flags_to_int(flags, :switch_capabilities)
<<dpid_int::64, n_buf::32, n_tab::8, aux_id::8, 0::16, flags_int::32, 0::32>>

6
lib/openflow/features/request.ex
View file

@ -2,8 +2,10 @@ defmodule Openflow.Features.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__

37
lib/openflow/flow_mod.ex
View file

@ -35,9 +35,11 @@ defmodule Openflow.FlowMod do
out_port = Keyword.get(options, :out_port, :any)
out_group = Keyword.get(options, :out_group, :any)
flags = Keyword.get(options, :flags, [])
match = Keyword.get(options, :match, Openflow.Match.new)
match = Keyword.get(options, :match, Openflow.Match.new())
instructions = Keyword.get(options, :instructions, [])
%FlowMod{cookie: cookie,
%FlowMod{
cookie: cookie,
cookie_mask: cookie_mask,
priority: priority,
table_id: table_id,
@ -49,12 +51,15 @@ defmodule Openflow.FlowMod do
out_group: out_group,
flags: flags,
match: match,
instructions: instructions}
instructions: instructions
}
end
def read(<<cookie::64, cookie_mask::64, table_id_int::8, command_int::8,
idle::16, hard::16, prio::16, buffer_id_int::32, out_port_int::32,
out_group_int::32, flags_int::16, _::size(2)-unit(8), rest::bytes>>) do
def read(
<<cookie::64, cookie_mask::64, table_id_int::8, command_int::8, idle::16, hard::16,
prio::16, buffer_id_int::32, out_port_int::32, out_group_int::32, flags_int::16,
_::size(2)-unit(8), rest::bytes>>
) do
table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
command = Openflow.Utils.get_enum(command_int, :flow_mod_command)
buffer_id = Openflow.Utils.get_enum(buffer_id_int, :buffer_id)
@ -64,7 +69,9 @@ defmodule Openflow.FlowMod do
{match_fields, instructions_bin} = Openflow.Match.read(rest)
match = Openflow.Match.new(match_fields)
instructions = Openflow.Instruction.read(instructions_bin)
%FlowMod{cookie: cookie,
%FlowMod{
cookie: cookie,
cookie_mask: cookie_mask,
priority: prio,
table_id: table_id,
@ -76,11 +83,13 @@ defmodule Openflow.FlowMod do
out_group: out_group,
flags: flags,
match: match,
instructions: instructions}
instructions: instructions
}
end
def to_binary(flow_mod) do
%FlowMod{cookie: cookie,
%FlowMod{
cookie: cookie,
cookie_mask: cookie_mask,
priority: prio,
table_id: table_id,
@ -92,7 +101,9 @@ defmodule Openflow.FlowMod do
out_group: out_group,
flags: flags,
match: match_fields,
instructions: instructions} = flow_mod
instructions: instructions
} = flow_mod
table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
command_int = Openflow.Utils.get_enum(command, :flow_mod_command)
buffer_id_int = Openflow.Utils.get_enum(buffer_id, :buffer_id)
@ -101,9 +112,9 @@ defmodule Openflow.FlowMod do
flags_int = Openflow.Enums.flags_to_int(flags, :flow_mod_flags)
match_fields_bin = Openflow.Match.to_binary(match_fields)
instructions_bin = Openflow.Instruction.to_binary(instructions)
<<cookie::64, cookie_mask::64, table_id_int::8, command_int::8,
idle::16, hard::16, prio::16, buffer_id_int::32, out_port_int::32,
out_group_int::32, flags_int::16, 0::size(2)-unit(8),
<<cookie::64, cookie_mask::64, table_id_int::8, command_int::8, idle::16, hard::16, prio::16,
buffer_id_int::32, out_port_int::32, out_group_int::32, flags_int::16, 0::size(2)-unit(8),
match_fields_bin::bytes, instructions_bin::bytes>>
end
end

14
lib/openflow/flow_removed.ex
View file

@ -21,13 +21,16 @@ defmodule Openflow.FlowRemoved do
def ofp_type, do: 11
def read(<<cookie::64, priority::16, reason_int::8,
table_id_int::8, dsec::32, dnsec::32,
idle::16, hard::16, pkt::64, byt::64, rest::bytes>>) do
def read(
<<cookie::64, priority::16, reason_int::8, table_id_int::8, dsec::32, dnsec::32, idle::16,
hard::16, pkt::64, byt::64, rest::bytes>>
) do
reason = Openflow.Enums.to_atom(reason_int, :flow_removed_reason)
table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
{match_fields, _rest} = Openflow.Match.read(rest)
%FlowRemoved{cookie: cookie,
%FlowRemoved{
cookie: cookie,
priority: priority,
reason: reason,
table_id: table_id,
@ -37,6 +40,7 @@ defmodule Openflow.FlowRemoved do
hard_timeout: hard,
packet_count: pkt,
byte_count: byt,
match: match_fields}
match: match_fields
}
end
end

30
lib/openflow/get_async/reply.ex
View file

@ -2,8 +2,10 @@ defmodule Openflow.GetAsync.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
aux_id: 0, # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0,
packet_in_mask_master: 0,
packet_in_mask_slave: 0,
port_status_mask_master: 0,
@ -16,25 +18,29 @@ defmodule Openflow.GetAsync.Reply do
def ofp_type, do: 27
def read(<<packet_in_mask_master::32, packet_in_mask_slave::32,
port_status_mask_master::32, port_status_mask_slave::32,
flow_removed_mask_master::32, flow_removed_mask_slave::32>>) do
%Reply{packet_in_mask_master: packet_in_mask_master,
def read(
<<packet_in_mask_master::32, packet_in_mask_slave::32, port_status_mask_master::32,
port_status_mask_slave::32, flow_removed_mask_master::32, flow_removed_mask_slave::32>>
) do
%Reply{
packet_in_mask_master: packet_in_mask_master,
packet_in_mask_slave: packet_in_mask_slave,
port_status_mask_master: port_status_mask_master,
port_status_mask_slave: port_status_mask_slave,
flow_removed_mask_master: flow_removed_mask_master,
flow_removed_mask_slave: flow_removed_mask_slave}
flow_removed_mask_slave: flow_removed_mask_slave
}
end
def to_binary(%Reply{packet_in_mask_master: packet_in_mask_master,
def to_binary(%Reply{
packet_in_mask_master: packet_in_mask_master,
packet_in_mask_slave: packet_in_mask_slave,
port_status_mask_master: port_status_mask_master,
port_status_mask_slave: port_status_mask_slave,
flow_removed_mask_master: flow_removed_mask_master,
flow_removed_mask_slave: flow_removed_mask_slave}) do
<<packet_in_mask_master::32, packet_in_mask_slave::32,
port_status_mask_master::32, port_status_mask_slave::32,
flow_removed_mask_master::32, flow_removed_mask_slave::32>>
flow_removed_mask_slave: flow_removed_mask_slave
}) do
<<packet_in_mask_master::32, packet_in_mask_slave::32, port_status_mask_master::32,
port_status_mask_slave::32, flow_removed_mask_master::32, flow_removed_mask_slave::32>>
end
end

6
lib/openflow/get_async/request.ex
View file

@ -2,8 +2,10 @@ defmodule Openflow.GetAsync.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__

3
lib/openflow/get_config/reply.ex
View file

@ -4,7 +4,8 @@ defmodule Openflow.GetConfig.Reply do
xid: 0,
datapath_id: "",
aux_id: 0,
flags: [], # default = "normal" is no special handling
# default = "normal" is no special handling
flags: [],
miss_send_len: 128
)

6
lib/openflow/get_config/request.ex
View file

@ -2,8 +2,10 @@ defmodule Openflow.GetConfig.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
aux_id: 0 # virtual field
# virtual field
datapath_id: nil,
# virtual field
aux_id: 0
)
alias __MODULE__

15
lib/openflow/group_mod.ex
View file

@ -19,10 +19,7 @@ defmodule Openflow.GroupMod do
type = Keyword.get(options, :type, :all)
group_id = Keyword.get(options, :group_id, 0)
buckets = Keyword.get(options, :buckets, [])
%GroupMod{command: command,
type: type,
group_id: group_id,
buckets: buckets}
%GroupMod{command: command, type: type, group_id: group_id, buckets: buckets}
end
def read(<<command_int::16, type_int::8, _::8, group_id_int::32, buckets_bin::bytes>>) do
@ -30,16 +27,10 @@ defmodule Openflow.GroupMod do
type = Openflow.Utils.get_enum(type_int, :group_type)
group_id = Openflow.Utils.get_enum(group_id_int, :group_id)
buckets = Openflow.Bucket.read(buckets_bin)
%GroupMod{command: command,
type: type,
group_id: group_id,
buckets: buckets}
%GroupMod{command: command, type: type, group_id: group_id, buckets: buckets}
end
def to_binary(%GroupMod{command: command,
type: type,
group_id: group_id,
buckets: buckets}) do
def to_binary(%GroupMod{command: command, type: type, group_id: group_id, buckets: buckets}) do
command_int = Openflow.Utils.get_enum(command, :group_mod_command)
type_int = Openflow.Utils.get_enum(type, :group_type)
group_id_int = Openflow.Utils.get_enum(group_id, :group_id)

47
lib/openflow/hello.ex
View file

@ -9,32 +9,32 @@ defmodule Openflow.Hello do
alias __MODULE__
def ofp_type,
do: 0
def ofp_type, do: 0
def new(version) when is_integer(version) do
%Hello{elements: [versionbitmap: [version]]}
end
def new(versions) when is_list(versions) do
%Hello{elements: [versionbitmap: versions]}
end
def supported_version?(%Hello{version: 4, elements: []}), do: true
def supported_version?(%Hello{elements: []}), do: false
def supported_version?(%Hello{elements: elements}) do
versionbitmaps = for {:versionbitmap, versions} <- elements, do: versions
Enum.any?(versionbitmaps, fn(versions) -> 4 in versions end)
Enum.any?(versionbitmaps, fn versions -> 4 in versions end)
end
def read(binary),
do: %Hello{elements: decode([], binary)}
def read(binary), do: %Hello{elements: decode([], binary)}
def to_binary(%Hello{elements: elements}),
do: encode([], elements)
def to_binary(%Hello{elements: elements}), do: encode([], elements)
# private functions
defp decode(acc, <<>>), do: acc
defp decode(acc, <<typeint::16, length::16, rest::bytes>>) do
data_len = length - @ofp_hello_size
<<data::bytes-size(data_len), rest2::bytes>> = rest
@ -50,15 +50,13 @@ defmodule Openflow.Hello do
end
end
defp encode(acc, []),
do: to_string(acc)
defp encode(acc, [h|rest]),
do: encode([encode_hello_elem(h)|acc], rest)
defp encode(acc, []), do: to_string(acc)
defp encode(acc, [h | rest]), do: encode([encode_hello_elem(h) | acc], rest)
defp decode_hello_elem(:versionbitmap, acc, binary),
do: [{:versionbitmap, decode_bitmap([], binary, 0)}|acc]
defp decode_hello_elem(_, acc, _binary),
do: acc
do: [{:versionbitmap, decode_bitmap([], binary, 0)} | acc]
defp decode_hello_elem(_, acc, _binary), do: acc
defp encode_hello_elem({:versionbitmap, versions}) do
bitmap_bin = encode_bitmap(versions)
@ -66,11 +64,13 @@ defmodule Openflow.Hello do
size_int = @ofp_hello_size + byte_size(bitmap_bin)
<<type_int::16, size_int::16, bitmap_bin::bytes>>
end
defp encode_hello_elem(_) do
<<>>
end
defp decode_bitmap(acc, "", _), do: acc
defp decode_bitmap(acc, <<int::32, rest::bytes>>, base) do
acc
|> decode_bitmap(int, 0, base)
@ -80,24 +80,27 @@ defmodule Openflow.Hello do
defp encode_bitmap(list) do
size =
list
|> Enum.max
|> Enum.max()
|> div(32)
encode_bitmap(0, list, size)
end
defp decode_bitmap(acc, _, index, _) when index >= 32,
do: acc
defp decode_bitmap(acc, int, index, base) when (int &&& (1 <<< index)) == 0,
defp decode_bitmap(acc, _, index, _) when index >= 32, do: acc
defp decode_bitmap(acc, int, index, base) when (int &&& 1 <<< index) == 0,
do: decode_bitmap(acc, int, index + 1, base)
defp decode_bitmap(acc, int, index, base),
do: decode_bitmap([base + index|acc], int, index + 1, base)
do: decode_bitmap([base + index | acc], int, index + 1, base)
defp encode_bitmap(acc, [], size) do
bytes = (size + 1) * 32
<<acc::size(bytes)>>
end
defp encode_bitmap(acc, [h|rest], size) do
index = (size - div(h, 32) * 32 + rem(h, 32))
encode_bitmap(acc ||| (1 <<< index), rest, size)
defp encode_bitmap(acc, [h | rest], size) do
index = size - div(h, 32) * 32 + rem(h, 32)
encode_bitmap(acc ||| 1 <<< index, rest, size)
end
end

10
lib/openflow/instruction.ex
View file

@ -1,5 +1,4 @@
defmodule Openflow.Instruction do
def read(instruction_bin) do
do_read([], instruction_bin)
end
@ -7,6 +6,7 @@ defmodule Openflow.Instruction do
def to_binary(instructions) when is_list(instructions) do
to_binary(<<>>, instructions)
end
def to_binary(instruction) do
to_binary([instruction])
end
@ -14,15 +14,17 @@ defmodule Openflow.Instruction do
# private functions
defp do_read(acc, <<>>), do: Enum.reverse(acc)
defp do_read(acc, <<type::16, length::16, _::bytes>> = binary) do
<<instruction_bin::size(length)-bytes, rest::bytes>> = binary
codec = Openflow.Enums.to_atom(type, :instruction_type)
do_read([codec.read(instruction_bin)|acc], rest)
do_read([codec.read(instruction_bin) | acc], rest)
end
defp to_binary(acc, []), do: acc
defp to_binary(acc, [instruction|rest]) do
defp to_binary(acc, [instruction | rest]) do
codec = instruction.__struct__
to_binary(<<acc::bytes, (codec.to_binary(instruction))::bytes>>, rest)
to_binary(<<acc::bytes, codec.to_binary(instruction)::bytes>>, rest)
end
end

4
lib/openflow/instructions/experimenter.ex
View file

@ -9,10 +9,10 @@ defmodule Openflow.Instruction.Experimenter do
def to_binary(%Experimenter{exp_id: exp_id, data: data}) do
length = 8 + byte_size(data)
<<0xffff::16, length::16, exp_id::32, data::bytes>>
<<0xFFFF::16, length::16, exp_id::32, data::bytes>>
end
def read(<<0xffff::16, _::16, exp_id::32, data::bytes>>) do
def read(<<0xFFFF::16, _::16, exp_id::32, data::bytes>>) do
%Experimenter{exp_id: exp_id, data: data}
end
end

4
lib/openflow/instructions/write_metadata.ex
View file

@ -1,11 +1,11 @@
defmodule Openflow.Instruction.WriteMetadata do
defstruct(metadata: 0, metadata_mask: 0xffffffffffffffff)
defstruct(metadata: 0, metadata_mask: 0xFFFFFFFFFFFFFFFF)
alias __MODULE__
def new(options) do
metadata = Keyword.get(options, :metadata, 0)
metadata_mask = Keyword.get(options, :metadata_mask, 0xffffffffffffffff)
metadata_mask = Keyword.get(options, :metadata_mask, 0xFFFFFFFFFFFFFFFF)
%WriteMetadata{metadata: metadata, metadata_mask: metadata_mask}
end

91
lib/openflow/match.ex
View file

@ -2,10 +2,10 @@ defmodule Openflow.Match do
@match_size 8
@header_size 4
defstruct([
defstruct(
type: :oxm,
fields: []
])
)
alias __MODULE__
@ -13,6 +13,7 @@ defmodule Openflow.Match do
oxm_fields =
fields
|> keyword_to_oxm_fields([])
%Match{type: :oxm, fields: oxm_fields}
end
@ -20,7 +21,10 @@ defmodule Openflow.Match do
<<1::16, no_pad_len::16, binary1::binary>> = binary
padding_length = Openflow.Utils.pad_length(no_pad_len, 8)
match_field_len = no_pad_len - @header_size
<<match_fields::size(match_field_len)-binary, _::size(padding_length)-unit(8), rest::bitstring>> = binary1
<<match_fields::size(match_field_len)-binary, _::size(padding_length)-unit(8),
rest::bitstring>> = binary1
{decode_fields(match_fields, []), rest}
end
@ -33,14 +37,17 @@ defmodule Openflow.Match do
end
def codec_header(oxm_field0) when is_atom(oxm_field0) do
oxm_field = case has_mask(oxm_field0) do
oxm_field =
case has_mask(oxm_field0) do
1 ->
string = to_string(oxm_field0)
"masked_" <> field = string
String.to_atom(field)
0 ->
oxm_field0
end
case Openflow.Match.Field.vendor_of(oxm_field) do
oxm_class when oxm_class in [:nxm_0, :nxm_1, :openflow_basic, :packet_register] ->
oxm_class_int = Openflow.Enums.to_int(oxm_class, :oxm_class)
@ -48,8 +55,9 @@ defmodule Openflow.Match do
oxm_length = div(Openflow.Match.Field.n_bits_of(oxm_field), 8)
has_mask = has_mask(oxm_field0)
<<oxm_class_int::16, oxm_field_int::7, has_mask::1, oxm_length::8>>
experimenter when experimenter in [:nicira_ext_match, :onf_ext_match, :hp_ext_match] ->
oxm_class_int = 0xffff
oxm_class_int = 0xFFFF
experimenter_int = Openflow.Enums.to_int(experimenter, :experimenter_oxm_vendors)
oxm_field_int = Openflow.Enums.to_int(oxm_field, experimenter)
oxm_length = div(Openflow.Match.Field.n_bits_of(oxm_field) + 4, 8)
@ -57,41 +65,63 @@ defmodule Openflow.Match do
<<oxm_class_int::16, oxm_field_int::7, has_mask::1, oxm_length::8, experimenter_int::32>>
end
end
def codec_header(<<oxm_class_int::16, oxm_field_int::7, oxm_has_mask::1, _oxm_length::8>>) do
oxm_class = Openflow.Enums.to_atom(oxm_class_int, :oxm_class)
case oxm_has_mask do
0 -> Openflow.Enums.to_atom(oxm_field_int, oxm_class)
0 ->
Openflow.Enums.to_atom(oxm_field_int, oxm_class)
1 ->
field_str =
oxm_field_int
|> Openflow.Enums.to_atom(oxm_class)
|> to_string
String.to_atom("masked_" <> field_str)
end
end
def codec_header(<<0xffff::16, oxm_field_int::7, oxm_has_mask::1, _oxm_length::8, experimenter_int::32>>) do
def codec_header(
<<0xFFFF::16, oxm_field_int::7, oxm_has_mask::1, _oxm_length::8, experimenter_int::32>>
) do
experimenter = Openflow.Enums.to_atom(experimenter_int, :experimenter_oxm_vendors)
Openflow.Enums.to_atom(oxm_field_int, experimenter)
case oxm_has_mask do
0 -> Openflow.Enums.to_atom(oxm_field_int, experimenter)
0 ->
Openflow.Enums.to_atom(oxm_field_int, experimenter)
1 ->
field_str =
oxm_field_int
|> Openflow.Enums.to_atom(experimenter)
|> to_string
String.to_atom("masked_" <> field_str)
end
end
def header_size(<<_oxm_class_int::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _::bytes>>),
def header_size(
<<_oxm_class_int::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _::bytes>>
),
do: 4
def header_size(<<0xffff::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _exp_int::32, _::bytes>>),
def header_size(
<<0xFFFF::16, _oxm_field_int::7, _oxm_has_mask::1, _oxm_length::8, _exp_int::32,
_::bytes>>
),
do: 8
# private functions
defp decode_fields(<<>>, acc), do: Enum.reverse(acc)
defp decode_fields(<<0xffff::16, _::7, 1::1, length::8, vendor_int::32, field_int::16, binary::bytes>>, acc) do
defp decode_fields(
<<0xFFFF::16, _::7, 1::1, length::8, vendor_int::32, field_int::16, binary::bytes>>,
acc
) do
length = length - 6
field_len = div(length, 2)
<<value_bin::size(field_len)-bytes, mask_bin::size(field_len)-bytes, rest::bytes>> = binary
@ -99,16 +129,21 @@ defmodule Openflow.Match do
field_name = Openflow.Enums.to_atom(field_int, experimenter)
value = Openflow.Match.Field.codec(value_bin, field_name)
mask = Openflow.Match.Field.codec(mask_bin, field_name)
decode_fields(rest, [{field_name, {value, mask}}|acc])
decode_fields(rest, [{field_name, {value, mask}} | acc])
end
defp decode_fields(<<0xffff::16, _::7, 0::1, length::8, vendor_int::32, field_int::16, binary::bytes>>, acc) do
defp decode_fields(
<<0xFFFF::16, _::7, 0::1, length::8, vendor_int::32, field_int::16, binary::bytes>>,
acc
) do
length = length - 6
<<value_bin::size(length)-bytes, rest::bytes>> = binary
experimenter = Openflow.Enums.to_atom(vendor_int, :experimenter_oxm_vendors)
field_name = Openflow.Enums.to_atom(field_int, experimenter)
value = Openflow.Match.Field.codec(value_bin, field_name)
decode_fields(rest, [{field_name, value}|acc])
decode_fields(rest, [{field_name, value} | acc])
end
defp decode_fields(<<class_int::16, field_int::7, 1::1, length::8, binary::bytes>>, acc) do
field_len = div(length, 2)
<<value_bin::size(field_len)-bytes, mask_bin::size(field_len)-bytes, rest::bytes>> = binary
@ -116,19 +151,21 @@ defmodule Openflow.Match do
field_name = Openflow.Enums.to_atom(field_int, class)
value = Openflow.Match.Field.codec(value_bin, field_name)
mask = Openflow.Match.Field.codec(mask_bin, field_name)
decode_fields(rest, [{field_name, {value, mask}}|acc])
decode_fields(rest, [{field_name, {value, mask}} | acc])
end
defp decode_fields(<<class_int::16, field_int::7, 0::1, length::8, binary::bytes>>, acc) do
<<value_bin::size(length)-bytes, rest::bytes>> = binary
class = Openflow.Enums.to_atom(class_int, :oxm_class)
field_name = Openflow.Enums.to_atom(field_int, class)
value = Openflow.Match.Field.codec(value_bin, field_name)
decode_fields(rest, [{field_name, value}|acc])
decode_fields(rest, [{field_name, value} | acc])
end
defp encode_fields([], acc), do: acc
defp encode_fields([field|fields], acc) do
encode_fields(fields, <<acc::bytes, (encode_field(field))::bytes>>)
defp encode_fields([field | fields], acc) do
encode_fields(fields, <<acc::bytes, encode_field(field)::bytes>>)
end
defp encode_field(%{class: class, field: field, has_mask: true, value: value, mask: mask})
@ -136,17 +173,21 @@ defmodule Openflow.Match do
vendor_int = Openflow.Enums.to_int(class, :experimenter_oxm_vendors)
field_int = Openflow.Enums.to_int(field, class)
has_mask_int = 1
length = (byte_size(value) * 2) + 6
<<0xffff::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes, mask::bytes>>
length = byte_size(value) * 2 + 6
<<0xFFFF::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes,
mask::bytes>>
end
defp encode_field(%{class: class, field: field, has_mask: false, value: value})
when class == :nicira_ext_match or class == :onf_ext_match do
vendor_int = Openflow.Enums.to_int(class, :experimenter_oxm_vendors)
field_int = Openflow.Enums.to_int(field, class)
has_mask_int = 0
length = byte_size(value) + 6
<<0xffff::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes>>
<<0xFFFF::16, 0::7, has_mask_int::1, length::8, vendor_int::32, field_int::16, value::bytes>>
end
defp encode_field(%{class: class, field: field, has_mask: true, value: value, mask: mask}) do
class_int = Openflow.Enums.to_int(class, :oxm_class)
field_int = Openflow.Enums.to_int(field, class)
@ -154,6 +195,7 @@ defmodule Openflow.Match do
length = byte_size(value) * 2
<<class_int::16, field_int::7, has_mask_int::1, length::8, value::bytes, mask::bytes>>
end
defp encode_field(%{class: class, field: field, has_mask: false, value: value}) do
class_int = Openflow.Enums.to_int(class, :oxm_class)
field_int = Openflow.Enums.to_int(field, class)
@ -163,8 +205,9 @@ defmodule Openflow.Match do
end
defp keyword_to_oxm_fields([], acc), do: Enum.reverse(acc)
defp keyword_to_oxm_fields([{field_name, field_value}|fields], acc) do
keyword_to_oxm_fields(fields, [oxm_field(field_name, field_value)|acc])
defp keyword_to_oxm_fields([{field_name, field_value} | fields], acc) do
keyword_to_oxm_fields(fields, [oxm_field(field_name, field_value) | acc])
end
defp oxm_field(field_name, {value, mask}) do
@ -173,6 +216,7 @@ defmodule Openflow.Match do
match_class = Openflow.Match.Field.vendor_of(field_name)
%{class: match_class, field: field_name, has_mask: true, value: value_bin, mask: mask_bin}
end
defp oxm_field(field_name, value) do
value_bin = Openflow.Match.Field.codec(value, field_name)
match_class = Openflow.Match.Field.vendor_of(field_name)
@ -184,6 +228,7 @@ defmodule Openflow.Match do
oxm_field
|> to_string
|> String.match?(~r/^masked_/)
if has_mask? do
1
else

31
lib/openflow/match/field.ex
View file

@ -1,10 +1,11 @@
defmodule Openflow.Match.Field do
def codec(value0, field) when is_binary(value0) do
{type, format} = format_of(field)
n_bits = n_bits_of(field)
bit_size = bit_size(value0)
value = if bit_size < n_bits do
value =
if bit_size < n_bits do
head_pad_len = n_bits - bit_size
<<0::size(head_pad_len), value0::bytes>>
else
@ -16,8 +17,10 @@ defmodule Openflow.Match.Field do
value0
end
end
formatting(value, type, format)
end
def codec(value, type) do
{type, format} = format_of(type)
formatting(value, type, format)
@ -577,17 +580,22 @@ defmodule Openflow.Match.Field do
# Formatting = ethernet
def formatting(<<value::48-bits>>, :mac, :ethernet), do: Openflow.Utils.to_hex_string(value)
def formatting(value, :mac, :ethernet), do: <<(String.to_integer(value, 16))::48>>
def formatting(value, :mac, :ethernet), do: <<String.to_integer(value, 16)::48>>
# Formatting = IPv4
def formatting(<<a1, a2, a3, a4>>, :be32, :ipv4), do: {a1, a2, a3, a4}
def formatting({a1, a2, a3, a4}, :be32, :ipv4), do: <<a1, a2, a3, a4>>
# Formatting = IPv6
def formatting(<<a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16>>, :be128, :ipv6) do
def formatting(
<<a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16>>,
:be128,
:ipv6
) do
{a1, a2, a3, a4, a5, a6, a7, a8}
end
def formatting({a1, a2, a3, a4, a5, a6, a7, a8},:be128, :ipv6) do
def formatting({a1, a2, a3, a4, a5, a6, a7, a8}, :be128, :ipv6) do
<<a1::16, a2::16, a3::16, a4::16, a5::16, a6::16, a7::16, a8::16>>
end
@ -599,6 +607,7 @@ defmodule Openflow.Match.Field do
:bad_enum -> value
end
end
def formatting(value, :be16, :openflow10_port) do
port_no =
try do
@ -606,6 +615,7 @@ defmodule Openflow.Match.Field do
catch
:bad_enum -> value
end
<<port_no::16>>
end
@ -617,6 +627,7 @@ defmodule Openflow.Match.Field do
:bad_enum -> value
end
end
def formatting(value, :be32, :openflow13_port) do
port_no =
try do
@ -624,6 +635,7 @@ defmodule Openflow.Match.Field do
catch
:bad_enum -> value
end
<<port_no::32>>
end
@ -631,24 +643,27 @@ defmodule Openflow.Match.Field do
def formatting(<<value::16>>, :be16, :tcp_flags) do
Openflow.Enums.int_to_flags(value, :tcp_flags)
end
def formatting(value, :be16, :tcp_flags) do
<<(Openflow.Enums.flags_to_int(value, :tcp_flags))::16>>
<<Openflow.Enums.flags_to_int(value, :tcp_flags)::16>>
end
# CT State
def formatting(<<value::32>>, :be32, :ct_state) do
Openflow.Enums.int_to_flags(value, :ct_state_flags)
end
def formatting(value, :be32, :ct_state) do
<<(Openflow.Enums.flags_to_int(value, :ct_state_flags))::32>>
<<Openflow.Enums.flags_to_int(value, :ct_state_flags)::32>>
end
# CT State
def formatting(<<value::16>>, :be16, :ipv6exthdr_flags) do
Openflow.Enums.int_to_flags(value, :ipv6exthdr_flags)
end
def formatting(value, :be16, :ipv6exthdr_flags) do
<<(Openflow.Enums.flags_to_int(value, :ipv6exthdr_flags))::16>>
<<Openflow.Enums.flags_to_int(value, :ipv6exthdr_flags)::16>>
end
# Other

10
lib/openflow/meter_band.ex
View file

@ -1,5 +1,4 @@
defmodule Openflow.MeterBand do
def read(meter_band_bin) do
do_read([], meter_band_bin)
end
@ -7,6 +6,7 @@ defmodule Openflow.MeterBand do
def to_binary(meter_bands) when is_list(meter_bands) do
to_binary(<<>>, meter_bands)
end
def to_binary(meter_band) do
to_binary([meter_band])
end
@ -14,15 +14,17 @@ defmodule Openflow.MeterBand do
# private functions
defp do_read(acc, <<>>), do: Enum.reverse(acc)
defp do_read(acc, <<type::16, length::16, _::bytes>> = binary) do
<<meter_band_bin::size(length)-bytes, rest::bytes>> = binary
codec = Openflow.Enums.to_atom(type, :meter_band_type)
do_read([codec.read(meter_band_bin)|acc], rest)
do_read([codec.read(meter_band_bin) | acc], rest)
end
defp to_binary(acc, []), do: acc
defp to_binary(acc, [meter_band|rest]) do
defp to_binary(acc, [meter_band | rest]) do
codec = meter_band.__struct__
to_binary(<<acc::bytes, (codec.to_binary(meter_band))::bytes>>, rest)
to_binary(<<acc::bytes, codec.to_binary(meter_band)::bytes>>, rest)
end
end

4
lib/openflow/meter_band/experimenter.ex
View file

@ -14,11 +14,11 @@ defmodule Openflow.MeterBand.Experimenter do
%Experimenter{rate: rate, burst_size: burst_size, experimenter: experimenter}
end
def read(<<0xffff::16, _::16, rate::32, burst_size::32, experimenter::32>>) do
def read(<<0xFFFF::16, _::16, rate::32, burst_size::32, experimenter::32>>) do
%Experimenter{rate: rate, burst_size: burst_size, experimenter: experimenter}
end
def to_binary(%Experimenter{rate: rate, burst_size: burst_size, experimenter: experimenter}) do
<<0xffff::16, 16::16, rate::32, burst_size::32, experimenter::32>>
<<0xFFFF::16, 16::16, rate::32, burst_size::32, experimenter::32>>
end
end

3
lib/openflow/multipart/aggregate/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Aggregate.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
packet_count: 0,

42
lib/openflow/multipart/aggregate/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Aggregate.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
table_id: :all,
out_port: :any,
@ -23,44 +24,55 @@ defmodule Openflow.Multipart.Aggregate.Request do
cookie = Keyword.get(options, :cookie, 0)
cookie_mask = Keyword.get(options, :cookie, 0)
match = Keyword.get(options, :match, [])
%Request{table_id: table_id,
%Request{
table_id: table_id,
out_port: out_port,
out_group: out_group,
cookie: cookie,
cookie_mask: cookie_mask,
match: match}
match: match
}
end
def read(<<table_id_int::8, _::size(3)-unit(8),
out_port_int::32, out_group_int::32,
_::size(4)-unit(8), cookie::64,
cookie_mask::64, match_bin::bytes>>) do
def read(
<<table_id_int::8, _::size(3)-unit(8), out_port_int::32, out_group_int::32,
_::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
) do
table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
out_port = Openflow.Utils.get_enum(out_port_int, :openflow13_port_no)
out_group = Openflow.Utils.get_enum(out_group_int, :group_id)
{match, _rest} = Openflow.Match.read(match_bin)
%Request{table_id: table_id,
%Request{
table_id: table_id,
out_port: out_port,
out_group: out_group,
cookie: cookie,
cookie_mask: cookie_mask,
match: match}
match: match
}
end
def to_binary(%Request{table_id: table_id,
def to_binary(
%Request{
table_id: table_id,
out_port: out_port,
out_group: out_group,
cookie: cookie,
cookie_mask: cookie_mask,
match: match} = msg) do
match: match
} = msg
) do
table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
out_port_int = Openflow.Utils.get_enum(out_port, :openflow13_port_no)
out_group_int = Openflow.Utils.get_enum(out_group, :group_id)
match_bin = Openflow.Match.to_binary(match)
body_bin = <<table_id_int::8, 0::size(3)-unit(8),
out_port_int::32, out_group_int::32,
0::size(4)-unit(8), cookie::64,
cookie_mask::64, match_bin::bytes>>
body_bin =
<<table_id_int::8, 0::size(3)-unit(8), out_port_int::32, out_group_int::32,
0::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
header_bin = Openflow.Multipart.Request.header(msg)
<<header_bin::bytes, body_bin::bytes>>
end

15
lib/openflow/multipart/desc/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Desc.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
mfr_desc: "",
@ -19,13 +20,17 @@ defmodule Openflow.Multipart.Desc.Reply do
def ofp_type, do: 19
def read(<<mfr_desc::size(@desc_str_len)-bytes, hw_desc::size(@desc_str_len)-bytes,
def read(
<<mfr_desc::size(@desc_str_len)-bytes, hw_desc::size(@desc_str_len)-bytes,
sw_desc::size(@desc_str_len)-bytes, serial_num::size(@serial_num_len)-bytes,
dp_desc::size(@desc_str_len)-bytes>>) do
%Reply{mfr_desc: Openflow.Utils.decode_string(mfr_desc),
dp_desc::size(@desc_str_len)-bytes>>
) do
%Reply{
mfr_desc: Openflow.Utils.decode_string(mfr_desc),
hw_desc: Openflow.Utils.decode_string(hw_desc),
sw_desc: Openflow.Utils.decode_string(sw_desc),
serial_num: Openflow.Utils.decode_string(serial_num),
dp_desc: Openflow.Utils.decode_string(dp_desc)}
dp_desc: Openflow.Utils.decode_string(dp_desc)
}
end
end

3
lib/openflow/multipart/desc/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Desc.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: []
)

35
lib/openflow/multipart/flow/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Flow.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
flows: []
@ -22,13 +23,16 @@ defmodule Openflow.Multipart.Flow.Reply do
end
def append_body(%Reply{flows: flows} = message, %Reply{flags: [:more], flows: continue}) do
%{message|flows: [continue|flows]}
%{message | flows: [continue | flows]}
end
def append_body(%Reply{flows: flows} = message, %Reply{flags: [], flows: continue}) do
new_flows = [continue|flows]
|> Enum.reverse
|> List.flatten
%{message|flows: new_flows}
new_flows =
[continue | flows]
|> Enum.reverse()
|> List.flatten()
%{message | flows: new_flows}
end
end
@ -57,20 +61,24 @@ defmodule Openflow.Multipart.FlowStats do
# private functions
defp do_read(acc, ""), do: Enum.reverse(acc)
defp do_read(acc, <<length::16, _tail::bytes>> = binary) do
<<flow_stats_bin::size(length)-bytes, rest::bytes>> = binary
do_read([codec(flow_stats_bin)|acc], rest)
do_read([codec(flow_stats_bin) | acc], rest)
end
defp codec(<<_length::16, table_id_int::8, 0::8, duration_sec::32,
duration_nsec::32, priority::16, idle::16, hard::16,
flags_int::16, _::size(4)-unit(8), cookie::64,
packet_count::64, byte_count::64, tail::bytes>>) do
defp codec(
<<_length::16, table_id_int::8, 0::8, duration_sec::32, duration_nsec::32, priority::16,
idle::16, hard::16, flags_int::16, _::size(4)-unit(8), cookie::64, packet_count::64,
byte_count::64, tail::bytes>>
) do
{match, instructions_bin} = Openflow.Match.read(tail)
table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
flags = Openflow.Enums.int_to_flags(flags_int, :flow_mod_flags)
instructions = Openflow.Instruction.read(instructions_bin)
%FlowStats{table_id: table_id,
%FlowStats{
table_id: table_id,
duration_sec: duration_sec,
duration_nsec: duration_nsec,
priority: priority,
@ -81,6 +89,7 @@ defmodule Openflow.Multipart.FlowStats do
packet_count: packet_count,
byte_count: byte_count,
match: match,
instructions: instructions}
instructions: instructions
}
end
end

44
lib/openflow/multipart/flow/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Flow.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
table_id: :all,
out_port: :any,
@ -22,45 +23,56 @@ defmodule Openflow.Multipart.Flow.Request do
out_group = Keyword.get(options, :out_group, :any)
cookie = Keyword.get(options, :cookie, 0)
cookie_mask = Keyword.get(options, :cookie, 0)
match = Keyword.get(options, :match, Openflow.Match.new)
%Request{table_id: table_id,
match = Keyword.get(options, :match, Openflow.Match.new())
%Request{
table_id: table_id,
out_port: out_port,
out_group: out_group,
cookie: cookie,
cookie_mask: cookie_mask,
match: match}
match: match
}
end
def read(<<table_id_int::8, _::size(3)-unit(8),
out_port_int::32, out_group_int::32,
_::size(4)-unit(8), cookie::64,
cookie_mask::64, match_bin::bytes>>) do
def read(
<<table_id_int::8, _::size(3)-unit(8), out_port_int::32, out_group_int::32,
_::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
) do
table_id = Openflow.Utils.get_enum(table_id_int, :table_id)
out_port = Openflow.Utils.get_enum(out_port_int, :openflow13_port_no)
out_group = Openflow.Utils.get_enum(out_group_int, :group_id)
{match, _rest} = Openflow.Match.read(match_bin)
%Request{table_id: table_id,
%Request{
table_id: table_id,
out_port: out_port,
out_group: out_group,
cookie: cookie,
cookie_mask: cookie_mask,
match: match}
match: match
}
end
def to_binary(%Request{table_id: table_id,
def to_binary(
%Request{
table_id: table_id,
out_port: out_port,
out_group: out_group,
cookie: cookie,
cookie_mask: cookie_mask,
match: match} = msg) do
match: match
} = msg
) do
table_id_int = Openflow.Utils.get_enum(table_id, :table_id)
out_port_int = Openflow.Utils.get_enum(out_port, :openflow13_port_no)
out_group_int = Openflow.Utils.get_enum(out_group, :group_id)
match_bin = Openflow.Match.to_binary(match)
body_bin = <<table_id_int::8, 0::size(3)-unit(8),
out_port_int::32, out_group_int::32,
0::size(4)-unit(8), cookie::64,
cookie_mask::64, match_bin::bytes>>
body_bin =
<<table_id_int::8, 0::size(3)-unit(8), out_port_int::32, out_group_int::32,
0::size(4)-unit(8), cookie::64, cookie_mask::64, match_bin::bytes>>
header_bin = Openflow.Multipart.Request.header(msg)
<<header_bin::bytes, body_bin::bytes>>
end

39
lib/openflow/multipart/group/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Group.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
groups: []
@ -22,13 +23,16 @@ defmodule Openflow.Multipart.Group.Reply do
end
def append_body(%Reply{groups: groups} = message, %Reply{flags: [:more], groups: continue}) do
%{message|groups: [continue|groups]}
%{message | groups: [continue | groups]}
end
def append_body(%Reply{groups: groups} = message, %Reply{flags: [], groups: continue}) do
new_groups = [continue|groups]
|> Enum.reverse
|> List.flatten
%{message|groups: new_groups}
new_groups =
[continue | groups]
|> Enum.reverse()
|> List.flatten()
%{message | groups: new_groups}
end
end
@ -54,27 +58,32 @@ defmodule Openflow.Multipart.Group do
# private functions
defp do_read(acc, ""), do: Enum.reverse(acc)
defp do_read(acc, <<length::16, _binary::bytes>> = binary) do
<<group_bin::size(length)-bytes, rest::bytes>> = binary
do_read([codec(group_bin)|acc], rest)
do_read([codec(group_bin) | acc], rest)
end
defp codec(<<length::16, _::size(2)-unit(8),
group_id::32, ref_count::32,
_::size(4)-unit(8), packet_count::64,
byte_count::64, duration_sec::32,
duration_nsec::32, tail::bytes>>) do
defp codec(
<<length::16, _::size(2)-unit(8), group_id::32, ref_count::32, _::size(4)-unit(8),
packet_count::64, byte_count::64, duration_sec::32, duration_nsec::32, tail::bytes>>
) do
bucket_stats_size = length - @ofp_group_stats_size
<<bucket_stats_bin::size(bucket_stats_size)-bytes, _rest::bytes>> = tail
bucket_stats = for <<packet_count::64, byte_count::64 <- bucket_stats_bin>> do
bucket_stats =
for <<packet_count::64, byte_count::64 <- bucket_stats_bin>> do
%{packet_count: packet_count, byte_count: byte_count}
end
%Group{group_id: group_id,
%Group{
group_id: group_id,
ref_count: ref_count,
packet_count: packet_count,
byte_count: byte_count,
duration_sec: duration_sec,
duration_nsec: duration_nsec,
bucket_stats: bucket_stats}
bucket_stats: bucket_stats
}
end
end

3
lib/openflow/multipart/group/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Group.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
group_id: :all
)

19
lib/openflow/multipart/group_desc/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.GroupDesc.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
groups: []
)
@ -21,13 +22,16 @@ defmodule Openflow.Multipart.GroupDesc.Reply do
end
def append_body(%Reply{groups: groups} = message, %Reply{flags: [:more], groups: continue}) do
%{message|groups: [continue|groups]}
%{message | groups: [continue | groups]}
end
def append_body(%Reply{groups: groups} = message, %Reply{flags: [], groups: continue}) do
new_groups = [continue|groups]
|> Enum.reverse
|> List.flatten
%{message|groups: new_groups}
new_groups =
[continue | groups]
|> Enum.reverse()
|> List.flatten()
%{message | groups: new_groups}
end
end
@ -49,9 +53,10 @@ defmodule Openflow.Multipart.GroupDescStats do
# private functions
defp do_read(acc, ""), do: Enum.reverse(acc)
defp do_read(acc, <<length::16, _tail::bytes>> = binary) do
<<group_stats_bin::size(length)-bytes, rest::bytes>> = binary
do_read([codec(group_stats_bin)|acc], rest)
do_read([codec(group_stats_bin) | acc], rest)
end
defp codec(<<length::16, type_int::8, _::8, group_id::32, tail::bytes>>) do

3
lib/openflow/multipart/group_desc/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.GroupDesc.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: []
)

26
lib/openflow/multipart/group_features/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.GroupFeatures.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
types: 0,
@ -21,17 +22,17 @@ defmodule Openflow.Multipart.GroupFeatures.Reply do
def ofp_type, do: 18
def read(<<types_int::32, capabilities_int::32,
max_groups_for_all_int::32,
max_groups_for_select_int::32,
max_groups_for_indirect_int::32,
max_groups_for_fast_failover_int::32,
actions_for_all_int::32,
actions_for_select_int::32,
actions_for_indirect_int::32,
actions_for_fast_failover_int::32>>) do
def read(
<<types_int::32, capabilities_int::32, max_groups_for_all_int::32,
max_groups_for_select_int::32, max_groups_for_indirect_int::32,
max_groups_for_fast_failover_int::32, actions_for_all_int::32,
actions_for_select_int::32, actions_for_indirect_int::32,
actions_for_fast_failover_int::32>>
) do
capabilities = Openflow.Enums.int_to_flags(capabilities_int, :group_capabilities)
%Reply{types: types_int,
%Reply{
types: types_int,
capabilities: capabilities,
max_groups_for_all: max_groups_for_all_int,
max_groups_for_select: max_groups_for_select_int,
@ -40,6 +41,7 @@ defmodule Openflow.Multipart.GroupFeatures.Reply do
actions_for_all: actions_for_all_int,
actions_for_select: actions_for_select_int,
actions_for_indirect: actions_for_indirect_int,
actions_for_fast_failover: actions_for_fast_failover_int}
actions_for_fast_failover: actions_for_fast_failover_int
}
end
end

3
lib/openflow/multipart/group_features/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.GroupFeatures.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: []
)

39
lib/openflow/multipart/meter/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Meter.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
meters: []
@ -18,13 +19,16 @@ defmodule Openflow.Multipart.Meter.Reply do
end
def append_body(%Reply{meters: meters} = message, %Reply{flags: [:more], meters: continue}) do
%{message|meters: [continue|meters]}
%{message | meters: [continue | meters]}
end
def append_body(%Reply{meters: meters} = message, %Reply{flags: [], meters: continue}) do
new_meters = [continue|meters]
|> Enum.reverse
|> List.flatten
%{message|meters: new_meters}
new_meters =
[continue | meters]
|> Enum.reverse()
|> List.flatten()
%{message | meters: new_meters}
end
end
@ -50,25 +54,32 @@ defmodule Openflow.Multipart.Meter do
# private functions
defp do_read(acc, ""), do: Enum.reverse(acc)
defp do_read(acc, <<_::32, length::16, _binary::bytes>> = binary) do
<<meter_bin::size(length)-bytes, rest::bytes>> = binary
do_read([codec(meter_bin)|acc], rest)
do_read([codec(meter_bin) | acc], rest)
end
defp codec(<<meter_id::32, length::16, _::size(6)-unit(8),
flow_count::32, packet_in_count::64, byte_in_count::64,
duration_sec::32, duration_nsec::32, tail::bytes>>) do
defp codec(
<<meter_id::32, length::16, _::size(6)-unit(8), flow_count::32, packet_in_count::64,
byte_in_count::64, duration_sec::32, duration_nsec::32, tail::bytes>>
) do
band_stats_size = length - @ofp_meter_stats_size
<<band_stats_bin::size(band_stats_size)-bytes, _rest::bytes>> = tail
band_stats = for <<packet_band_count::64, byte_band_count::64 <- band_stats_bin>> do
%{packet_band_count: packet_band_count,byte_band_count: byte_band_count}
band_stats =
for <<packet_band_count::64, byte_band_count::64 <- band_stats_bin>> do
%{packet_band_count: packet_band_count, byte_band_count: byte_band_count}
end
%Meter{meter_id: meter_id,
%Meter{
meter_id: meter_id,
flow_count: flow_count,
packet_in_count: packet_in_count,
byte_in_count: byte_in_count,
duration_sec: duration_sec,
duration_nsec: duration_nsec,
band_stats: band_stats}
band_stats: band_stats
}
end
end

3
lib/openflow/multipart/meter/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Meter.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
meter_id: :all
)

3
lib/openflow/multipart/meter_config/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.MeterConfig.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
meter_id: :all
)

18
lib/openflow/multipart/port_desc/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.PortDesc.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
ports: []
@ -17,17 +18,20 @@ defmodule Openflow.Multipart.PortDesc.Reply do
end
def read(<<ports_bin::bytes>>) do
ports = for (<<port_bin::64-bytes <- ports_bin>>), do: Openflow.Port.read(port_bin)
ports = for <<port_bin::64-bytes <- ports_bin>>, do: Openflow.Port.read(port_bin)
%Reply{ports: Enum.reverse(ports)}
end
def append_body(%Reply{ports: ports} = message, %Reply{flags: [:more], ports: continue}) do
%{message|ports: [continue|ports]}
%{message | ports: [continue | ports]}
end
def append_body(%Reply{ports: ports} = message, %Reply{flags: [], ports: continue}) do
new_ports = [continue|ports]
|> Enum.reverse
|> List.flatten
%{message|ports: new_ports}
new_ports =
[continue | ports]
|> Enum.reverse()
|> List.flatten()
%{message | ports: new_ports}
end
end

3
lib/openflow/multipart/port_desc/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.PortDesc.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: []
)

37
lib/openflow/multipart/port_stats/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.PortStats.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
ports: []
@ -22,13 +23,16 @@ defmodule Openflow.Multipart.PortStats.Reply do
end
def append_body(%Reply{ports: ports} = message, %Reply{flags: [:more], ports: continue}) do
%{message|ports: [continue|ports]}
%{message | ports: [continue | ports]}
end
def append_body(%Reply{ports: ports} = message, %Reply{flags: [], ports: continue}) do
new_ports = [continue|ports]
|> Enum.reverse
|> List.flatten
%{message|ports: new_ports}
new_ports =
[continue | ports]
|> Enum.reverse()
|> List.flatten()
%{message | ports: new_ports}
end
end
@ -60,17 +64,19 @@ defmodule Openflow.Multipart.PortStats do
# private functions
defp do_read(acc, ""), do: Enum.reverse(acc)
defp do_read(acc, <<port_stats_bin::112-bytes, rest::bytes>>) do
do_read([codec(port_stats_bin)|acc], rest)
do_read([codec(port_stats_bin) | acc], rest)
end
defp codec(<<port_no::32, _::size(4)-unit(8), rx_packets::64,
tx_packets::64, rx_bytes::64, tx_bytes::64,
rx_dropped::64, tx_dropped::64, rx_errors::64,
tx_errors::64, rx_frame_err::64, rx_over_err::64,
rx_crc_err::64, collisions::64,
duration_sec::32, duration_nsec::32>>) do
%PortStats{port_number: port_no,
defp codec(
<<port_no::32, _::size(4)-unit(8), rx_packets::64, tx_packets::64, rx_bytes::64,
tx_bytes::64, rx_dropped::64, tx_dropped::64, rx_errors::64, tx_errors::64,
rx_frame_err::64, rx_over_err::64, rx_crc_err::64, collisions::64, duration_sec::32,
duration_nsec::32>>
) do
%PortStats{
port_number: port_no,
rx_packets: rx_packets,
tx_packets: tx_packets,
rx_bytes: rx_bytes,
@ -84,6 +90,7 @@ defmodule Openflow.Multipart.PortStats do
rx_crc_err: rx_crc_err,
collisions: collisions,
duration_sec: duration_sec,
duration_nsec: duration_nsec}
duration_nsec: duration_nsec
}
end
end

3
lib/openflow/multipart/port_stats/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.PortStats.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
port_number: :any
)

32
lib/openflow/multipart/queue/reply.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Queue.Reply do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
aux_id: nil,
flags: [],
queues: []
@ -22,13 +23,16 @@ defmodule Openflow.Multipart.Queue.Reply do
end
def append_body(%Reply{queues: queues} = message, %Reply{flags: [:more], queues: continue}) do
%{message|queues: [continue|queues]}
%{message | queues: [continue | queues]}
end
def append_body(%Reply{queues: queues} = message, %Reply{flags: [], queues: continue}) do
new_queues = [continue|queues]
|> Enum.reverse
|> List.flatten
%{message|queues: new_queues}
new_queues =
[continue | queues]
|> Enum.reverse()
|> List.flatten()
%{message | queues: new_queues}
end
end
@ -52,19 +56,23 @@ defmodule Openflow.Multipart.Queue do
# private functions
defp do_read(acc, ""), do: Enum.reverse(acc)
defp do_read(acc, <<queue_bin::40-bytes, rest::bytes>>) do
do_read([codec(queue_bin)|acc], rest)
do_read([codec(queue_bin) | acc], rest)
end
defp codec(<<port_no::32, queue_id::32, tx_bytes::64,
tx_packets::64, tx_errors::64,
duration_sec::32, duration_nsec::32>>) do
%Queue{port_number: port_no,
defp codec(
<<port_no::32, queue_id::32, tx_bytes::64, tx_packets::64, tx_errors::64,
duration_sec::32, duration_nsec::32>>
) do
%Queue{
port_number: port_no,
queue_id: queue_id,
tx_bytes: tx_bytes,
tx_packets: tx_packets,
tx_errors: tx_errors,
duration_sec: duration_sec,
duration_nsec: duration_nsec}
duration_nsec: duration_nsec
}
end
end

3
lib/openflow/multipart/queue/request.ex
View file

@ -2,7 +2,8 @@ defmodule Openflow.Multipart.Queue.Request do
defstruct(
version: 4,
xid: 0,
datapath_id: nil, # virtual field
# virtual field
datapath_id: nil,
flags: [],
port_number: :any,
queue_id: :all

4
lib/openflow/multipart/reply.ex
View file

@ -5,15 +5,17 @@ defmodule Openflow.Multipart.Reply do
codec = Openflow.Enums.to_atom(type_int, :multipart_reply_codec)
flags = Openflow.Enums.int_to_flags(flags_int, :multipart_reply_flags)
reply = codec.read(reply_bin)
%{reply|flags: flags}
%{reply | flags: flags}
end
def to_binary(%{__struct__: codec, flags: flags} = msg) do
flags_int = Openflow.Enums.flags_to_int(flags, :multipart_reply_flags)
type_int = Openflow.Enums.to_int(codec, :multipart_reply_codec)
case codec.to_binary(msg) do
reply_bin when is_binary(reply_bin) ->
<<type_int::16, flags_int::16, 0::size(4)-unit(8), reply_bin::bytes>>
{:error, reason} ->
{:error, reason}
end

Some files were not shown because too many files have changed in this diff Show more