anchor.diff:      next_state(run, State1);
   
   run({ieee_802_11_wlan_configuration_response, _Seq,
  -     Elements, _Header}, State = #state{}) ->
  -    State1 =
  -        case proplists:get_value(result_code, Elements) of
  -            0 ->
  -                lager:debug("IEEE 802.11 WLAN Configuration ok"),
  -                case lists:keyfind(false, #wlan.started, State#state.wlans) of
  -                    #wlan{wlan_identifier = {RadioId, WlanId},
  -			  reply_to_after_start = From} ->
  -                        State0 = internal_add_wlan(RadioId, WlanId, State),
  -                        gen_fsm:reply(From, ok),
  -                        State0;
  -                    _ ->
  -                        State
  -                end;
  -            Code ->
  -                lager:warning("IEEE 802.11 WLAN Configuration failed with ~w", [Code]),
  -                State
  -        end,
  -    next_state(run, State1);
  +     Elements, _Header}, State) ->
  +    case proplists:get_value(result_code, Elements) of
  +	0 ->
  +	    lager:debug("IEEE 802.11 WLAN Configuration ok"),
  +	    ok;
  +	Code ->
  +	    lager:warning("IEEE 802.11 WLAN Configuration failed with ~w", [Code]),
  +            ok
  +    end,
  +    next_state(run, State);
   
   run({station_configuration_response, _Seq,
        Elements, _Header}, State) ->
  
positive.code:     Config = capwap_config:update_wlan_config(RadioId, WlanId, Settings, Config0),
      State1 = State0#state{config = Config},
  
      case get_wlan(WlanIdent, State1) of
          false ->
  	    State = internal_add_wlan(RadioId, WlanId, State1),
  	    reply(ok, run, State);
  
          #wlan{} ->
              State2 = internal_del_wlan(WlanIdent, State1),
              State = update_wlan_state(WlanIdent,
  				      fun(W) ->
  					      W#wlan{started = false,reply_to_after_start = From}
  				      end, State2),
              next_state(run, State)
      end;
  
  handle_sync_event({stop_radio, RadioId}, _From, run, State) ->
      State1 =
  	lists:foldl(fun(WlanIdent = {RId, _}, S) when RId == RadioId->
  			    internal_del_wlan(WlanIdent, S);
  		       (_, S) ->
  			    S
  		    end, State, State#state.wlans),
  
negative.code:     lager:warning("resend capwap response ~w", [SeqNo]),
      stream_send(Msg, State).
  
  send_request(Header, MsgType, ReqElements, State) ->
      send_request(Header, MsgType, ReqElements, undefined, State).
  
  send_request(Header, MsgType, ReqElements, NotfiyFun,
  	     State0 = #state{request_queue = Queue, seqno = SeqNo}) ->
      ?log_capwap_control(peer_log_str(State0), MsgType, SeqNo, ReqElements, Header),
      Msg = {Header, {MsgType, SeqNo, ReqElements}},
      State1 = queue_request(State0, {SeqNo, Msg, NotfiyFun}),
      State2 = bump_seqno(State1),
      case queue:is_empty(Queue) of
          true ->
  