anchor.diff:  		loop     :: pid(),
   		raw      :: boolean()}).
   
  +-define(DEFAULT_PATH, "/tmp/erlang-dbus").
  +
   connect(BusOptions, _Options) ->
       Path = case proplists:get_value(path, BusOptions) of
   	       undefined ->
  -		   case proplists:get_value(abstract, BusOptions) of
  -		       undefined ->
  -			   throw(no_path);
  -		       V ->
  -			   {abstract, list_to_binary(V)}
  -		   end;
  +                   throw(no_path);
   	       V ->
  -		   {path, list_to_binary(V)}
  +		   list_to_binary(V)
   	   end,
       gen_server:start_link(?MODULE, [Path, self()],[]).
   
   %%
   %% gen_server callbacks
   %%
  -init([{Mode, Path}, Owner]) when is_pid(Owner), is_binary(Path) ->
  +init([Path, Owner]) when is_pid(Owner), is_binary(Path) ->
       true = link(Owner),
       ?debug("Connecting to UNIX socket: ~p~n", [Path]),
  -    ok = inert:start(),
  -    case procket:socket(?PF_LOCAL, ?SOCK_STREAM, 0) of
  +    {ok, S} = prim_inet:open(tcp, local, stream),
  +    {ok, Fd} = prim_inet:getfd(S),
  +    case gen_tcp:connect({local, Path}, 0, [{fd, Fd}]) of
   	{ok, Sock} ->
  -	    SockUn = get_sock_un(Mode, Path),
  -	    case procket:connect(Sock, SockUn) of
  -		ok ->
  -		    process_flag(trap_exit, true),
  -		    Loop = spawn_link(?MODULE, do_read, [Sock, self()]),
  -		    {ok, #state{sock=Sock, owner=Owner, loop=Loop}};
  -		{error, Err} ->
  -		    ?error("Error connecting socket: ~p~n", [Err]),
  -		    {error, Err}
  -	    end;
  +            Loop = spawn_link(?MODULE, do_read, [Sock, self()]),
  +            gen_tcp:controlling_process(Sock, Loop),
  +            {ok, #state{sock=Sock, owner=Owner, loop=Loop}};
   	{error, Err} ->
   	    ?error("Error creating socket: ~p~n", [Err]),
   	    {error, Err}
  
positive.code:     ?error("Unhandled cast in ~p: ~p~n", [?MODULE, Request]),
      {noreply, State}.
  
  
  handle_info({unix, Data}, #state{owner=Owner}=State) ->
      %%?debug("unix received(~p)~n", [Data]),
      Owner ! {received, Data},
      {noreply, State};
  
  
negative.code: 	    exit(Loop, kill),
  	    %% Avoid do_read loop polling on closed fd
  	    timer:sleep(100),
              gen_tcp:close(Sock)
      end,
      ok.
  
  