anchor.diff:  		undefined ->
   			{ok, Req, State};
   		Subprotocols ->
  -			case lists:keymember(<<"mychat2">>, 1, Subprotocols) of
  +			case lists:keymember(<<"mqtt">>, 1, Subprotocols) of
   				true ->
   					Req2 = cowboy_req:set_resp_header(<<"sec-websocket-protocol">>,
  -						<<"mychat2">>, Req),
  +						<<"mqtt">>, Req),
   					{ok, Req2, State};
   				false ->
   					{stop, Req, State}
  
positive.code: 	{ok, State}.
  ----
  
  === Sending frames to the socket
  
  Cowboy allows sending either a single frame or a list of
  frames to the socket, in which case the frames are sent
  sequentially. Any frame can be sent: text, binary, ping,
  pong or close frames.
  
  The following example sends three frames using a single `reply`
  tuple.
  
  [source,erlang]
  ----
  websocket_info(hello_world, State) ->
  	{reply, [
  		{text, "Hello"},
  		{text, <<"world!">>},
  		{binary, <<0:8000>>}
  	], State};
  %% More websocket_info/2 clauses here...
  ----
  
  Note that the payload for text and binary frames is of type
  `iodata()`, meaning it can be either a `binary()` or an
  `iolist()`.
  
  Sending a `close` frame will immediately initiate the closing
  of the Websocket connection. Be aware that any additional
  frames sent by the client or any Erlang messages waiting to
  be received will not be processed. Also note that when replying
  a list of frames that includes close, any frame found after the
  close frame will not be sent.
  
  === Ping and timeout
  
  The biggest performance improvement you can do when dealing
  with a huge number of Websocket connections is to reduce the
  number of timers that are started on the server. A common use
  of timers when dealing with connections is for sending a ping
  every once in a while. This should be done exclusively on the
  client side. Indeed, a server handling one million Websocket
  connections will perform a lot better when it doesn't have to
  handle one million extra timers too!
  
  Cowboy will automatically respond to ping frames sent by the
  client. It will still forward the frame to the handler for
  informative purpose, but no further action is required.
  
  Cowboy can be configured to automatically close the Websocket
  connection when no data arrives on the socket. It is highly
  recommended to configure a timeout for it, as otherwise you
  may end up with zombie "half-connected" sockets that may
  leave the process alive forever.
  
  A good timeout value is 60 seconds.
  
  [source,erlang]
  ----
  
negative.code: 	{ok, State}.
  ----
  
  Note that ping and pong frames require no action from the
  handler as Cowboy will automatically reply to ping frames.
  They are provided for informative purposes only.
  
  === Receiving Erlang messages
  
  Cowboy will call `websocket_info/2` whenever an Erlang message
  arrives.
  
  The handler can handle or ignore the messages. It can also
  send frames to the client or stop the connection.
  
  The following snippet forwards log messages to the client
  and ignores all others:
  
  [source,erlang]
  ----
  