anchor.diff:      ActiveFaults = 0,
       CrashedNodes = [],
       SendOmissions = dict:new(),
  +    ReceiveOmissions = dict:new(),
  +
       #fault_model_state{active_faults=ActiveFaults, 
                          crashed_nodes=CrashedNodes, 
  -                       send_omissions=SendOmissions}.
  +                       send_omissions=SendOmissions,
  +                       receive_omissions=ReceiveOmissions}.
  +%% Receive omission.
  +fault_precondition(#fault_model_state{crashed_nodes=CrashedNodes}=FaultModelState, {call, _Mod, begin_receive_omission, [SourceNode, DestinationNode]}=Call) ->
  +    %% Fault must be allowed at this moment.
  +    fault_allowed(Call, FaultModelState) andalso 
  +
  +    %% Nodes must not be the same node.
  +    SourceNode =/= DestinationNode andalso
  +
  +    %% Both nodes have to be non-crashed.
  +    not lists:member(SourceNode, CrashedNodes) andalso not lists:member(DestinationNode, CrashedNodes);
  +
  +fault_precondition(#fault_model_state{receive_omissions=ReceiveOmissions}, {call, _Mod, end_receive_omission, [SourceNode, DestinationNode]}) ->
  +    %% We must be in the middle of a send omission to resolve it.
  +    case dict:find({SourceNode, DestinationNode}, ReceiveOmissions) of 
  +        {ok, _Value} ->
  +            true;
  +        error ->
  +            false
  +    end;
   
   %% Send omission.
   fault_precondition(#fault_model_state{crashed_nodes=CrashedNodes}=FaultModelState, {call, _Mod, begin_send_omission, [SourceNode, DestinationNode]}=Call) ->
  
positive.code: 
       %% Send omission failures.
       {call, ?MODULE, begin_send_omission, [node_name(), node_name()]},
       {call, ?MODULE, end_send_omission, [node_name(), node_name()]}
      ].
  
  %% Names of the node functions so we kow when we can dispatch to the node
  
negative.code:             ct:fail(Error)
      end.
  
  %% Create a receive omission failure.
  begin_receive_omission(SourceNode0, DestinationNode) ->
      fault_debug("begin_receive_omission: source_node ~p destination_node ~p", [SourceNode0, DestinationNode]),
  
      %% Convert to real node name and not symbolic name.
      SourceNode = ?NAME(SourceNode0),
  
      InterpositionFun = fun({receive_message, N, Message}) ->
          case N of
              SourceNode ->
                  lager:info("~p: dropping packet from ~p to ~p due to interposition.", [node(), SourceNode, DestinationNode]),
                  undefined;
              OtherNode ->
                  lager:info("~p: allowing message, doesn't match interposition as destination is ~p and not ~p", [node(), OtherNode, DestinationNode]),
                  Message
          end;
          ({forward_message, _N, Message}) -> Message
      end,
      rpc:call(?NAME(DestinationNode), ?MANAGER, add_interposition_fun, [{receive_omission, SourceNode}, InterpositionFun]).
  
  %% End receive omission failure period.
  end_receive_omission(SourceNode0, DestinationNode) ->
      fault_debug("end_receive_omission: source_node ~p destination_node ~p", [SourceNode0, DestinationNode]),
  
      %% Convert to real node name and not symbolic name.
      SourceNode = ?NAME(SourceNode0),
  
      rpc:call(?NAME(DestinationNode), ?MANAGER, remove_interposition_fun, [{receive_omission, SourceNode}]).
  
  %% Create a send omission failure.
  begin_send_omission(SourceNode, DestinationNode0) ->
      fault_debug("begin_send_omission: source_node ~p destination_node ~p", [SourceNode, DestinationNode0]),
  