In broadcast mode if we get a response then that means someone is disputing our claim to this name.
501184
function(response) {
      delete self._requestState[transactionId];
      if (typeof callback === 'function') {
        // negative response
        if (response.error) {
          var owner = response.answerRecords[0].nb.entries[0].address;
          callback(null, false, owner);

        // positive response
        } else {
          // ignore as this should not happen for 'broadcast' nodes
        }
      }
    }
372204
def valid_response(self, beacon_config, response, server_address):
		
		try:
			self._message_address_parse(response, invert_hello=self.__invert_hello)
			return True
		except ValueError:
			pass
		return False
983018
def _map_user_details(self, response):
        
        dest = {}
        for source_key, dest_key in self.CLAIMS_TO_DETAILS_KEY_MAP.items():
            value = response.get(source_key)
            if value is not None:
                dest[dest_key] = value

        return dest
1029144
void fakeResponse(
        StatusLine statusline, 
        HeaderGroup responseheaders,
        HttpConnection conn,
        InputStream responseStream
    ) {
        // set used so that the response can be read
        this.used = true;
        this.statusLine = statusline;
        this.responseHeaders = responseheaders;
        this.responseConnection = conn;
        this.responseBody = null;
        this.responseStream = responseStream;
    }
920890
private boolean responseIsInValid() {
        if (response == null) {
            return true;
        }
        else if (!response.isHeadless() && validityCheck) {
            return request.getTransactionID() != response.getTransactionID();
        }
        else {
            return false;
        }
    }
1125676
def verified(self):
        
        for who, record in self.logs:
            if record["field_name"] == "status" \
                    and record["added"] == "VERIFIED":
                return True
        return False
1040361
private boolean validateProducerClaim(
        final int activeCycleIndex,
        final long producerCycleClaim,
        final long cycleId,
        final int positionOnCycle,
        final int cycleLengthLog2,
        final boolean slowProducer)
    {
        final long producerPosition = producerPosition(positionOnCycle, cycleId, cycleLengthLog2);
        final long claimLimit = lvProducerLimit();
        if (producerPosition >= claimLimit)
        {
            // it is really full?
            if (isFull(producerPosition))
            {
                return fixProducerOverClaim(activeCycleIndex, producerCycleClaim, slowProducer);
            }
        }
        return true;
    }
510107
def id(self):
        
        m = re.match(r'You are not authorized to access bug #(\d+)',
                     self.message)
        return m.group(1)
859999
private static Node checkPosterIdentifier(final HttpServletRequest request,
			final ReadResponse response) {
		final String posterId = request
				.getParameter(ProtocolConstants.Parameters.Read.POSTER_IDENTIFIER);
		if (posterId != null) {
			final Node user = NeoUtils.getUserByIdentifier(posterId);
			if (user != null) {
				return user;
			}
			response.posterIdentifierInvalid(posterId);
		} else {
			response.posterIdentifierMissing();
		}

		return null;
	}
858287
private static boolean isPubSubMessage(ResponseHeaderReplayOutput<?, ?> replay) {

        if (replay == null) {
            return false;
        }

        String firstElement = replay.firstElement;
        if (replay.multiCount != null && firstElement != null) {

            if (replay.multiCount == 3 && firstElement.equalsIgnoreCase(PubSubOutput.Type.message.name())) {
                return true;
            }

            if (replay.multiCount == 4 && firstElement.equalsIgnoreCase(PubSubOutput.Type.pmessage.name())) {
                return true;
            }
        }

        return false;
    }
365921
def call
      return broadcast(:invalid) unless user&.invited_to_sign_up?

      user.invite!(user.invited_by, invitation_instructions: instructions)

      broadcast(:ok)
    end
1224322
def send(self, sender, **kwargs):
        """"""
        if id(self) not in _alleged_receivers:
            return
        for func in _alleged_receivers[id(self)]:
            func(sender, **kwargs)
857392
def is_logged(self, user):
        """"""

        response = None
        if user.is_authenticated():
            if not user.needs_update:
                response = redirect('user_profile', username=user.username)

        return response
917005
def ack(self, msg):
        
        self.log.info("senderID:%s Received: %s " % (self.senderID, msg['body']))
        return stomper.NO_REPONSE_NEEDED
407857
private static Node checkUserIdentifier(final HttpServletRequest request,
			final DeleteFollowResponse response) {
		final String userId = request
				.getParameter(ProtocolConstants.Parameters.Delete.Follow.USER_IDENTIFIER);
		if (userId != null) {
			final Node user = NeoUtils.getUserByIdentifier(userId);
			if (user != null) {
				return user;
			}
			response.userIdentifierInvalid(userId);
		} else {
			response.userIdentifierMissing();
		}

		return null;
	}
482251
private void doCustomServerIdentityCheck(X509Certificate cert) throws CertificateException{
		if (EndpointIdentificationAlgorithm.APIS == identityAlg) {
			APINameChecker.verifyAndThrow(trustedNameSet, cert);
		}
	}
1103343
def call
      return broadcast(:invalid) if membership.blank?
      return broadcast(:invalid) if membership.user_group != user_group

      transaction do
        remove_membership
        send_notification
      end

      broadcast(:ok)
    end