mirror of
https://github.com/google/nomulus.git
synced 2025-04-30 12:07:51 +02:00
c458c05801
The dark lord Gosling designed the Java package naming system so that ownership flows from the DNS system. Since we own the domain name registry.google, it seems only appropriate that we should use google.registry as our package name.
276 lines
12 KiB
Java
276 lines
12 KiB
Java
// Copyright 2016 The Domain Registry Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package google.registry.rdap;
|
|
|
|
import static google.registry.model.EppResourceUtils.loadByUniqueId;
|
|
import static google.registry.model.index.ForeignKeyIndex.loadAndGetReference;
|
|
import static google.registry.model.ofy.ObjectifyService.ofy;
|
|
import static google.registry.request.Action.Method.GET;
|
|
import static google.registry.request.Action.Method.HEAD;
|
|
import static google.registry.util.DateTimeUtils.END_OF_TIME;
|
|
|
|
import com.google.common.base.Optional;
|
|
import com.google.common.collect.ImmutableList;
|
|
import com.google.common.collect.ImmutableMap;
|
|
import com.google.common.collect.ImmutableSortedSet;
|
|
import com.google.common.collect.Iterables;
|
|
import com.google.common.primitives.Booleans;
|
|
|
|
import com.googlecode.objectify.Key;
|
|
import com.googlecode.objectify.Ref;
|
|
import com.googlecode.objectify.cmd.Query;
|
|
import com.googlecode.objectify.cmd.QueryKeys;
|
|
|
|
import google.registry.model.domain.DomainResource;
|
|
import google.registry.model.host.HostResource;
|
|
import google.registry.rdap.RdapJsonFormatter.BoilerplateType;
|
|
import google.registry.request.Action;
|
|
import google.registry.request.HttpException;
|
|
import google.registry.request.HttpException.BadRequestException;
|
|
import google.registry.request.HttpException.NotFoundException;
|
|
import google.registry.request.Parameter;
|
|
import google.registry.util.Clock;
|
|
import google.registry.util.Idn;
|
|
|
|
import org.joda.time.DateTime;
|
|
|
|
import java.net.InetAddress;
|
|
import java.util.List;
|
|
|
|
import javax.inject.Inject;
|
|
|
|
/**
|
|
* RDAP (new WHOIS) action for domain search requests.
|
|
*
|
|
* <p>All commands and responses conform to the RDAP spec as defined in RFCs 7480 through 7485.
|
|
*
|
|
* @see <a href="http://tools.ietf.org/html/rfc7482">
|
|
* RFC 7482: Registration Data Access Protocol (RDAP) Query Format</a>
|
|
* @see <a href="http://tools.ietf.org/html/rfc7483">
|
|
* RFC 7483: JSON Responses for the Registration Data Access Protocol (RDAP)</a>
|
|
*/
|
|
@Action(path = RdapDomainSearchAction.PATH, method = {GET, HEAD}, isPrefix = true)
|
|
public class RdapDomainSearchAction extends RdapActionBase {
|
|
|
|
public static final String PATH = "/rdap/domains";
|
|
|
|
@Inject Clock clock;
|
|
@Inject @Parameter("name") Optional<String> nameParam;
|
|
@Inject @Parameter("nsLdhName") Optional<String> nsLdhNameParam;
|
|
@Inject @Parameter("nsIp") Optional<InetAddress> nsIpParam;
|
|
@Inject RdapDomainSearchAction() {}
|
|
|
|
@Override
|
|
public String getHumanReadableObjectTypeName() {
|
|
return "domain search";
|
|
}
|
|
|
|
@Override
|
|
public String getActionPath() {
|
|
return PATH;
|
|
}
|
|
|
|
/** Parses the parameters and calls the appropriate search function. */
|
|
@Override
|
|
public ImmutableMap<String, Object> getJsonObjectForResource(
|
|
String pathSearchString, boolean isHeadRequest, String linkBase) throws HttpException {
|
|
DateTime now = clock.nowUtc();
|
|
// RDAP syntax example: /rdap/domains?name=exam*.com.
|
|
// The pathSearchString is not used by search commands.
|
|
if (pathSearchString.length() > 0) {
|
|
throw new BadRequestException("Unexpected path");
|
|
}
|
|
if (Booleans.countTrue(nameParam.isPresent(), nsLdhNameParam.isPresent(), nsIpParam.isPresent())
|
|
!= 1) {
|
|
throw new BadRequestException(
|
|
"You must specify either name=XXXX, nsLdhName=YYYY or nsIp=ZZZZ");
|
|
}
|
|
ImmutableList<ImmutableMap<String, Object>> results;
|
|
if (nameParam.isPresent()) {
|
|
// syntax: /rdap/domains?name=exam*.com
|
|
String asciiName;
|
|
try {
|
|
asciiName = Idn.toASCII(nameParam.get());
|
|
} catch (Exception e) {
|
|
throw new BadRequestException("Invalid value of nsLdhName parameter");
|
|
}
|
|
results = searchByDomainName(RdapSearchPattern.create(asciiName, true), now);
|
|
} else if (nsLdhNameParam.isPresent()) {
|
|
// syntax: /rdap/domains?nsLdhName=ns1.exam*.com
|
|
// RFC 7482 appears to say that Unicode domains must be specified using punycode when
|
|
// passed to nsLdhName, so IDN.toASCII is not called here.
|
|
if (!LDH_PATTERN.matcher(nsLdhNameParam.get()).matches()) {
|
|
throw new BadRequestException("Invalid value of nsLdhName parameter");
|
|
}
|
|
results = searchByNameserverLdhName(
|
|
RdapSearchPattern.create(nsLdhNameParam.get(), true), now);
|
|
} else {
|
|
// syntax: /rdap/domains?nsIp=1.2.3.4
|
|
results = searchByNameserverIp(nsIpParam.get(), now);
|
|
}
|
|
if (results.isEmpty()) {
|
|
throw new NotFoundException("No domains found");
|
|
}
|
|
ImmutableMap.Builder<String, Object> builder = new ImmutableMap.Builder<>();
|
|
builder.put("domainSearchResults", results);
|
|
RdapJsonFormatter.addTopLevelEntries(builder, BoilerplateType.DOMAIN, null, rdapLinkBase);
|
|
return builder.build();
|
|
}
|
|
|
|
/** Searches for domains by domain name, returning a JSON array of domain info maps. */
|
|
private ImmutableList<ImmutableMap<String, Object>>
|
|
searchByDomainName(final RdapSearchPattern partialStringQuery, final DateTime now) {
|
|
// Handle queries without a wildcard -- just load by foreign key.
|
|
if (!partialStringQuery.getHasWildcard()) {
|
|
DomainResource domainResource =
|
|
loadByUniqueId(DomainResource.class, partialStringQuery.getInitialString(), now);
|
|
if (domainResource == null) {
|
|
return ImmutableList.of();
|
|
}
|
|
return ImmutableList.of(
|
|
RdapJsonFormatter.makeRdapJsonForDomain(
|
|
domainResource, false, rdapLinkBase, rdapWhoisServer));
|
|
// Handle queries with a wildcard.
|
|
} else {
|
|
Query<DomainResource> query = ofy().load()
|
|
.type(DomainResource.class)
|
|
// TODO(b/24463238): figure out how to limit the size of these queries effectively
|
|
.filter("fullyQualifiedDomainName >=", partialStringQuery.getInitialString())
|
|
.filter("fullyQualifiedDomainName <", partialStringQuery.getNextInitialString())
|
|
.limit(1000);
|
|
if (partialStringQuery.getSuffix() != null) {
|
|
query = query.filter("tld", partialStringQuery.getSuffix());
|
|
}
|
|
ImmutableList.Builder<ImmutableMap<String, Object>> builder = new ImmutableList.Builder<>();
|
|
for (DomainResource domainResource : query) {
|
|
if (domainResource.getDeletionTime().isAfter(now)) {
|
|
builder.add(
|
|
RdapJsonFormatter.makeRdapJsonForDomain(
|
|
domainResource, false, rdapLinkBase, rdapWhoisServer));
|
|
}
|
|
}
|
|
return builder.build();
|
|
}
|
|
}
|
|
|
|
/** Searches for domains by nameserver name, returning a JSON array of domain info maps. */
|
|
private ImmutableList<ImmutableMap<String, Object>>
|
|
searchByNameserverLdhName(final RdapSearchPattern partialStringQuery, final DateTime now)
|
|
throws HttpException {
|
|
ImmutableList<Ref<HostResource>> hostRefs;
|
|
// Handle queries without a wildcard; just load the host by foreign key in the usual way.
|
|
if (!partialStringQuery.getHasWildcard()) {
|
|
Ref<HostResource> hostRef = loadAndGetReference(
|
|
HostResource.class, partialStringQuery.getInitialString(), clock.nowUtc());
|
|
if (hostRef == null) {
|
|
return ImmutableList.of();
|
|
}
|
|
hostRefs = ImmutableList.of(hostRef);
|
|
// Handle queries with a wildcard, but no suffix. Query the host resources themselves, rather
|
|
// than the foreign key index, because then we have an index on fully qualified host name and
|
|
// deletion time, so we can check the deletion status in the query itself. There are no pending
|
|
// deletes for hosts, so we can call queryUndeleted.
|
|
} else if (partialStringQuery.getSuffix() == null) {
|
|
// TODO (b/24463238): figure out how to limit the size of these queries effectively
|
|
Query<HostResource> query = queryUndeleted(
|
|
HostResource.class,
|
|
"fullyQualifiedHostName",
|
|
partialStringQuery, 1000);
|
|
ImmutableList.Builder<Ref<HostResource>> builder = new ImmutableList.Builder<>();
|
|
for (Key<HostResource> hostResourceKey : query.keys()) {
|
|
builder.add(Ref.create(hostResourceKey));
|
|
}
|
|
hostRefs = builder.build();
|
|
if (hostRefs.isEmpty()) {
|
|
throw new NotFoundException("No matching nameservers found");
|
|
}
|
|
// Handle queries with a wildcard and a suffix. In this case, it is more efficient to do things
|
|
// differently. We use the suffix to look up the domain, then loop through the subordinate hosts
|
|
// looking for matches.
|
|
} else {
|
|
DomainResource domainResource = loadByUniqueId(
|
|
DomainResource.class, partialStringQuery.getSuffix(), clock.nowUtc());
|
|
if (domainResource == null) {
|
|
throw new NotFoundException("No domain found for specified nameserver suffix");
|
|
}
|
|
ImmutableList.Builder<Ref<HostResource>> builder = new ImmutableList.Builder<>();
|
|
for (String fqhn : ImmutableSortedSet.copyOf(domainResource.getSubordinateHosts())) {
|
|
// We can't just check that the host name starts with the initial query string, because then
|
|
// the query ns.exam*.example.com would match against nameserver ns.example.com.
|
|
if (partialStringQuery.matches(fqhn)) {
|
|
Ref<HostResource> hostRef = loadAndGetReference(HostResource.class, fqhn, clock.nowUtc());
|
|
if (hostRef != null) {
|
|
builder.add(hostRef);
|
|
}
|
|
}
|
|
}
|
|
hostRefs = builder.build();
|
|
if (hostRefs.isEmpty()) {
|
|
throw new NotFoundException("No matching nameservers found");
|
|
}
|
|
}
|
|
// Find all domains that link to any of these hosts, and return information about them.
|
|
return searchByNameserverRefs(hostRefs, now);
|
|
}
|
|
|
|
/** Searches for domains by nameserver address, returning a JSON array of domain info maps. */
|
|
private ImmutableList<ImmutableMap<String, Object>>
|
|
searchByNameserverIp(final InetAddress inetAddress, final DateTime now) {
|
|
// In theory, we could filter on the deletion time being in the future. But we can't do that in
|
|
// the query on nameserver name (because we're already using an inequality query), and it seems
|
|
// dangerous and confusing to filter on deletion time differently between the two queries.
|
|
QueryKeys<HostResource> query = ofy()
|
|
.load()
|
|
.type(HostResource.class)
|
|
.filter("inetAddresses", inetAddress.getHostAddress())
|
|
.filter("deletionTime", END_OF_TIME)
|
|
.limit(1000)
|
|
.keys();
|
|
ImmutableList.Builder<Ref<HostResource>> builder = new ImmutableList.Builder<>();
|
|
for (Key<HostResource> key : query) {
|
|
builder.add(Ref.create(key));
|
|
}
|
|
ImmutableList<Ref<HostResource>> hostRefs = builder.build();
|
|
if (hostRefs.isEmpty()) {
|
|
return ImmutableList.of();
|
|
}
|
|
// Find all domains that link to any of these hosts, and return information about them.
|
|
return searchByNameserverRefs(hostRefs, now);
|
|
}
|
|
|
|
/**
|
|
* Locates all domains which are linked to a set of host refs. This method is called by
|
|
* {@link #searchByNameserverLdhName} and {@link #searchByNameserverIp} after they assemble the
|
|
* relevant host refs.
|
|
*/
|
|
private ImmutableList<ImmutableMap<String, Object>>
|
|
searchByNameserverRefs(final Iterable<Ref<HostResource>> hostRefs, final DateTime now) {
|
|
// We must break the query up into chunks, because the in operator is limited to 30 subqueries.
|
|
ImmutableList.Builder<ImmutableMap<String, Object>> builder = new ImmutableList.Builder<>();
|
|
for (List<Ref<HostResource>> chunk : Iterables.partition(hostRefs, 30)) {
|
|
Query<DomainResource> query = ofy().load()
|
|
.type(DomainResource.class)
|
|
.filter("nameservers.linked in", chunk)
|
|
.filter("deletionTime >", now)
|
|
.limit(1000);
|
|
for (DomainResource domainResource : query) {
|
|
builder.add(
|
|
RdapJsonFormatter.makeRdapJsonForDomain(
|
|
domainResource, false, rdapLinkBase, rdapWhoisServer));
|
|
}
|
|
}
|
|
return builder.build();
|
|
}
|
|
}
|