anchor.diff:  	  mac_mode,
   	  tunnel_mode,
   	  last_response,
  -	  last_request,
  +	  request_queue,
   	  retransmit_timer,
   	  retransmit_counter,
   	  echo_request_timer,
  
positive.code: 
  handle_capwap_packet(Packet, StateName, State = #state{
  					  last_response = LastResponse,
  					  last_request = LastRequest}) ->
      try	capwap_packet:decode(control, Packet) of
  	{Header, {Msg, 1, Seq, Elements}} ->
  	    %% Request
  
negative.code: 	     State = #state{socket = Socket, seqno = SeqNo}) ->
      lager:debug("send capwap request(~w): ~w~n", [SeqNo, MsgType]),
      BinMsg = capwap_packet:encode(control, {Header, {MsgType, SeqNo, ReqElements}}),
      State1 = send_request_queue(BinMsg, State),
      bump_seqno(State1).
  
  send_request_queue(BinMsg, State = #state{socket = Socket, request_queue = Queue, seqno = SeqNo}) ->
      NewState = queue_request(State, {SeqNo, BinMsg}),
      case queue:is_empty(Queue) of
          true ->
              ok = socket_send(Socket, BinMsg),
              init_retransmit(NewState);
          false ->
              NewState
      end.
  
  resend_request(StateName, State = #state{retransmit_counter = 0}) ->
      lager:debug("Final Timeout in ~w, STOPPING~n", [StateName]),
      {stop, normal, State};
  resend_request(StateName,
  	       State = #state{socket = Socket,
                            request_queue = Queue,
                            retransmit_counter = MaxRetransmit}) ->
      lager:warning("resend capwap request~n", []),
      {value, {_, BinMsg}} = queue:peek(Queue),
      ok = socket_send(Socket, BinMsg),
      State1 = State#state{retransmit_timer = send_info_after(?RetransmitInterval, retransmit),
  			 retransmit_counter = MaxRetransmit - 1
  			},
      {next_state, StateName, State1, ?IDLE_TIMEOUT}.
  
  init_retransmit(State) ->
      State#state{retransmit_timer = send_info_after(?RetransmitInterval, retransmit),
                  retransmit_counter = ?MaxRetransmit}.
  
  %% Stop Timer, clear LastRequest
  ack_request(State0 = #state{socket = Socket}) ->
      State1 = cancel_retransmit(State0),
      case dequeue_request_next(State1) of
          {{value, {_, BinMsg}}, State2} ->
              ok = socket_send(Socket, BinMsg),
              init_retransmit(State2);
          {empty, State2} ->
              State2
      end.
  
  cancel_retransmit(State = #state{retransmit_timer = undefined}) ->
      State;
  cancel_retransmit(State = #state{retransmit_timer = Timer}) ->
      gen_fsm:cancel_timer(Timer),
      State#state{retransmit_timer = undefined}.
  
  queue_request(State = #state{request_queue = Queue}, {SeqNo, BinMsg}) ->
      State#state{request_queue = queue:in({SeqNo, BinMsg}, Queue)}.
  
  dequeue_request_next(State = #state{request_queue = Queue0}) ->
      Queue1 = queue:drop(Queue0),
      {queue:peek(Queue1), State#state{request_queue = Queue1}}.
  
  control_addresses(App) ->
      case application:get_env(App, control_ips) of
  