anchor.diff:  stop(Pid) ->
       call_infinity(Pid, stop).
   
  +%% @private Like `gen_server:call/3', but with the timeout hardcoded
  +%% to `infinity'.
  +call_infinity(Pid, Msg) ->
  +   gen_server:call(Pid, Msg, infinity).
  +
   %% @private
  -handle_info(_, State) ->
  -    {noreply, State}.
  +handle_call({req, Msg, Timeout}, From, State) ->
  +    {noreply, send_request(new_request(Msg, From, Timeout), State)}.
  +
  +%% @private
  +handle_info({_Proto, Sock, Data}, State=#state{active = Active}) ->
  +    <<MsgCode:8, MsgData/binary>> = Data,
  +    Resp = riak_pb_codec:decode(MsgCode, MsgData),
  +    NewState = case Resp of
  +        %Must improve message handling
  +        #fpboperationresp{success = true} ->
  +            cancel_req_timer(Active#request.tref),
  +             _ = send_caller(Resp, Active),
  +            State#state{ active = undefined };
  +        _ ->
  +            lager:warning("Unexpected Message ~p",[Resp]),
  +            State#state{ active = undefined }
  +    end,
  +    ok = inet:setopts(Sock, [{active, once}]),
  +   {noreply, NewState};
  +
  +handle_info(Msg, State) ->
  +    State.
   
   %% @private
   handle_cast(_Msg, State) ->
  
positive.code:           address :: address(),    % address to connect to
            port :: portnum(),       % port to connect to
            sock :: port(),       % gen_tcp socket
            queue :: queue() | undefined,
            auto_reconnect = false :: boolean(), % if true, automatically reconnects to server
                                                 % if false, exits on connection failure/request timeout
            connect_timeout=infinity :: timeout(), % timeout of TCP connection
            keepalive = false :: boolean(), % if true, enabled TCP keepalive for the socket
            connects=0 :: non_neg_integer(), % number of successful connects
            reconnect_interval=?FIRST_RECONNECT_INTERVAL :: non_neg_integer(),
            credentials :: undefined | {string(), string()} % username/password
           }).
  
  -export([start_link/2, start_link/3,
  
negative.code: %% @private
  %% Connect the socket if disconnected
  connect(State) when State#state.sock =:= undefined ->
      #state{address = Address, port = Port} = State,
      case gen_tcp:connect(Address, Port,
                           [binary, {active, once}, {packet, 4},
                            {keepalive, State#state.keepalive}],
                           State#state.connect_timeout) of
          {ok, Sock} ->
              {ok, State#state{sock = Sock}};
          Error -> Error
      end.
  
  
  %% @private
  new_request(Msg, From, Timeout) ->
      Ref = make_ref(),
      #request{ref = Ref, msg = Msg, from = From, timeout = Timeout, tref = create_req_timer(Timeout, Ref)}.
  