code: def receive_empty(self, message):
          
          logger.debug("receive_empty - " + str(message))
          try:
              host, port = message.source
          except AttributeError:
              return
          key_mid = str_append_hash(host, port, message.mid)
          key_mid_multicast = str_append_hash(defines.ALL_COAP_NODES, port, message.mid)
          key_token = str_append_hash(host, port, message.token)
          key_token_multicast = str_append_hash(defines.ALL_COAP_NODES, port, message.token)
          if key_mid in list(self._transactions.keys()):
              transaction = self._transactions[key_mid]
          elif key_token in self._transactions_token:
              transaction = self._transactions_token[key_token]
          elif key_mid_multicast in list(self._transactions.keys()):
              transaction = self._transactions[key_mid_multicast]
          elif key_token_multicast in self._transactions_token:
              transaction = self._transactions_token[key_token_multicast]
          else:
              logger.warning("Un-Matched incoming empty message " + str(host) + ":" + str(port))
              return None
  
          if message.type == defines.Types["ACK"]:
              if not transaction.request.acknowledged:
                  transaction.request.acknowledged = True
              elif (transaction.response is not None) and (not transaction.response.acknowledged):
                  transaction.response.acknowledged = True
          elif message.type == defines.Types["RST"]:
              if not transaction.request.acknowledged:
                  transaction.request.rejected = True
              elif not transaction.response.acknowledged:
                  transaction.response.rejected = True
          elif message.type == defines.Types["CON"]:
              #implicit ACK (might have been lost)
              logger.debug("Implicit ACK on received CON for waiting transaction")
              transaction.request.acknowledged = True
          else:
              logger.warning("Unhandled message type...")
  
          if transaction.retransmit_stop is not None:
              transaction.retransmit_stop.set()
  
          return transaction
docs: Pair ACKs with requests.
  
          :type message: Message
          :param message: the received message
          :rtype : Transaction
          :return: the transaction to which the message belongs to