anchor.diff:      case deadline(Timeout) of
           badarg = Reason ->
               erlang:error(Reason, [Socket, Data, Dest, Flags, Timeout]);
  +        nowait ->
  +            send_common_nowait(SockRef, Data, Dest, Flags, sendto);
           Deadline ->
  -            send_common(SockRef, Data, Dest, Flags, Deadline, sendto)
  +            send_common_deadline(
  +              SockRef, Data, Dest, Flags, Deadline, sendto)
       end;
   sendto(Socket, Data, Dest, Flags, Timeout) ->
       erlang:error(badarg, [Socket, Data, Dest, Flags, Timeout]).
  
positive.code:         badarg = Reason ->
              erlang:error(Reason, [Socket, MsgHdr, Flags, Timeout]);
          Deadline ->
              do_sendmsg(SockRef, MsgHdr, Flags, Deadline)
      end;
  sendmsg(Socket, MsgHdr, Flags, Timeout) ->
      erlang:error(badarg, [Socket, MsgHdr, Flags, Timeout]).
  
  
  do_sendmsg(SockRef, MsgHdr, Flags, Deadline) ->
  
      SendRef = make_ref(),
  
      case prim_socket:sendmsg(SockRef, SendRef, MsgHdr, Flags) of
          ok ->
              %% We are done
              ok;
  
  
          {ok, Written} when is_integer(Written) andalso (Written > 0) ->
              %% We should not retry here since the protocol may not
              %% be able to handle a message being split. Leave it to
  
negative.code: 	    Timeout = timeout(Deadline),
              receive
                  {?ESOCK_TAG, #socket{ref = LSockRef}, select, AccRef} ->
                      accept_deadline(LSockRef, Deadline);
                  {?ESOCK_TAG, _Socket, abort, {AccRef, Reason}} ->
                      {error, Reason}
              after Timeout ->
                      cancel(LSockRef, accept, AccRef),
                      {error, timeout}
              end;
          Result ->
              accept_result(LSockRef, AccRef, Result)
      end.
  
  accept_result(LSockRef, AccRef, Result) ->
      case Result of
          {ok, SockRef} ->
              Socket = #socket{ref = SockRef},
              {ok, Socket};
          {error, _} = ERROR ->
              cancel(LSockRef, accept, AccRef), % Just to be on the safe side...
              ERROR
      end.
  
  
  %% ===========================================================================
  