TiclMessageValidator2.java

/*
 * Copyright 2011 Google Inc.
 *
 * 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 com.google.ipc.invalidation.common;

import com.google.ipc.invalidation.common.ClientProtocolAccessor.ApplicationClientIdPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ClientConfigPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ClientHeaderAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ClientToServerMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ClientVersionAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ConfigChangeMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ErrorMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.InfoMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.InfoRequestMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.InitializeMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.InvalidationMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.InvalidationPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ObjectIdPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ProtocolHandlerConfigPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RateLimitPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RegistrationMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RegistrationPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RegistrationStatusAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RegistrationStatusMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RegistrationSubtreeAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RegistrationSummaryAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.RegistrationSyncMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ServerHeaderAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.ServerToClientMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.StatusPAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.TokenControlMessageAccessor;
import com.google.ipc.invalidation.common.ClientProtocolAccessor.VersionAccessor;
import com.google.ipc.invalidation.util.BaseLogger;
import com.google.protobuf.MessageLite;
import com.google.protos.ipc.invalidation.ClientProtocol.ApplicationClientIdP;
import com.google.protos.ipc.invalidation.ClientProtocol.ClientHeader;
import com.google.protos.ipc.invalidation.ClientProtocol.ClientToServerMessage;
import com.google.protos.ipc.invalidation.ClientProtocol.ConfigChangeMessage;
import com.google.protos.ipc.invalidation.ClientProtocol.InitializeMessage;
import com.google.protos.ipc.invalidation.ClientProtocol.InvalidationP;
import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP;
import com.google.protos.ipc.invalidation.ClientProtocol.RateLimitP;
import com.google.protos.ipc.invalidation.ClientProtocol.RegistrationSummary;
import com.google.protos.ipc.invalidation.ClientProtocol.ServerHeader;
import com.google.protos.ipc.invalidation.ClientProtocol.ServerToClientMessage;
import com.google.protos.ipc.invalidation.ClientProtocol.Version;

/**
 * Validator for v2 protocol messages.
 * <p>
 * The basic idea is to declare information about each field in each message, i.e., whether it is
 * optional or it is required. {@code FieldInfo} is a class that keeps track of information
 * about each field and {@code MessageInfo} is a class that keeps track of information about each
 * message. Given a message, we recursively descend a MessageInfo and determine if the fields
 * are as expected. Then once we are done with a message, we perform a post validation step
 * which checks constraints across fields.
 *
 */
public class TiclMessageValidator2 extends ProtoValidator {
  public TiclMessageValidator2(BaseLogger logger) {
    super(logger);
  }

  /** Describes how to validate common messages. */
  
  public class CommonMsgInfos {

    /** Validation for composite (major/minor) versions. */
    final MessageInfo VERSION = new MessageInfo(ClientProtocolAccessor.VERSION_ACCESSOR,
      FieldInfo.newRequired(VersionAccessor.MAJOR_VERSION),
      FieldInfo.newRequired(VersionAccessor.MINOR_VERSION)) {
      @Override
      public boolean postValidate(MessageLite message) {
        // Versions must be non-negative.
        Version version = (Version) message;
        if ((version.getMajorVersion() < 0) || (version.getMinorVersion() < 0)) {
          logger.info("Invalid versions: %s", version);
          return false;
        }
        return true;
      }
    };

    /** Validation for the protocol version. */
    final MessageInfo PROTOCOL_VERSION = new MessageInfo(
        ClientProtocolAccessor.PROTOCOL_VERSION_ACCESSOR,
        FieldInfo.newRequired(ClientProtocolAccessor.ProtocolVersionAccessor.VERSION, VERSION));

    /** Validation for object ids. */
    final MessageInfo OID = new MessageInfo(ClientProtocolAccessor.OBJECT_ID_P_ACCESSOR,
        FieldInfo.newRequired(ObjectIdPAccessor.NAME),
        FieldInfo.newRequired(ObjectIdPAccessor.SOURCE)) {
      @Override
      public boolean postValidate(MessageLite message) {
        // Must have non-negative source code.
        ObjectIdP oid = (ObjectIdP) message;
        if (oid.getSource() < 0) {
          logger.info("Source was negative: %s", oid);
          return false;
        }
        return true;
      }
    };

    /** Validation for invalidations. */
    final MessageInfo INVALIDATION = new MessageInfo(
        ClientProtocolAccessor.INVALIDATION_P_ACCESSOR,
        FieldInfo.newRequired(InvalidationPAccessor.OBJECT_ID, OID),
        FieldInfo.newRequired(InvalidationPAccessor.IS_KNOWN_VERSION),
        FieldInfo.newRequired(InvalidationPAccessor.VERSION),
        FieldInfo.newOptional(InvalidationPAccessor.PAYLOAD),
        FieldInfo.newOptional(InvalidationPAccessor.IS_TRICKLE_RESTART),
        FieldInfo.newOptional(InvalidationPAccessor.BRIDGE_ARRIVAL_TIME_MS_DEPRECATED)) {
      @Override
      public boolean postValidate(MessageLite message) {
        // Must have non-negative version.
        InvalidationP invalidation = (InvalidationP) message;
        if (invalidation.getVersion() < 0) {
          logger.info("Version was negative: %s", invalidation);
          return false;
        }
        boolean isUnknownVersion = !invalidation.getIsKnownVersion();
        // Note that a missing value for is_trickle_restart is treated like a true value,
        // becomes it comes from a downlevel client that uses invalidation semantics.
        boolean isTrickleRestart = !invalidation.hasIsTrickleRestart() ||
            invalidation.getIsTrickleRestart();
        if (isUnknownVersion && !isTrickleRestart) {
          logger.info(
              "if is_known_version is false, is_trickle_restart must be true or missing: %s",
              invalidation);
          return false;
        }
        return true;
      }
    };

    /** Validation for a message containing many invalidations. */
    final MessageInfo INVALIDATION_MSG;

    /** Validation for a single registration description. */
    final MessageInfo REGISTRATIONP = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_P_ACCESSOR,
        FieldInfo.newRequired(RegistrationPAccessor.OBJECT_ID, OID),
        FieldInfo.newRequired(RegistrationPAccessor.OP_TYPE));

    /** Validation for a summary of registration state. */
    final MessageInfo REGISTRATION_SUMMARY = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_SUMMARY_ACCESSOR,
        FieldInfo.newRequired(RegistrationSummaryAccessor.NUM_REGISTRATIONS),
        FieldInfo.newRequired(RegistrationSummaryAccessor.REGISTRATION_DIGEST)) {
      @Override
      public boolean postValidate(MessageLite message) {
        RegistrationSummary summary = (RegistrationSummary) message;
        return (summary.getNumRegistrations() >= 0)
            && (!summary.getRegistrationDigest().isEmpty());
      }
    };

    final MessageInfo RATE_LIMIT = new MessageInfo(
        ClientProtocolAccessor.RATE_LIMIT_P_ACCESSOR,
        FieldInfo.newRequired(RateLimitPAccessor.WINDOW_MS),
        FieldInfo.newRequired(RateLimitPAccessor.COUNT)) {
      @Override
      public boolean postValidate(MessageLite message) {
        RateLimitP rateLimit = (RateLimitP) message;
        return (rateLimit.getWindowMs() >= 1000) &&
            (rateLimit.getWindowMs() > rateLimit.getCount());
      }
    };

    final MessageInfo PROTOCOL_HANDLER_CONFIG = new MessageInfo(
        ClientProtocolAccessor.PROTOCOL_HANDLER_CONFIG_P_ACCESSOR,
        FieldInfo.newOptional(ProtocolHandlerConfigPAccessor.BATCHING_DELAY_MS),
        FieldInfo.newOptional(ProtocolHandlerConfigPAccessor.RATE_LIMIT, RATE_LIMIT)
        );

    // Validation for Client Config. */
    final MessageInfo CLIENT_CONFIG = new MessageInfo(
        ClientProtocolAccessor.CLIENT_CONFIG_P_ACCESSOR,
        FieldInfo.newRequired(ClientConfigPAccessor.VERSION, VERSION),
        FieldInfo.newOptional(ClientConfigPAccessor.NETWORK_TIMEOUT_DELAY_MS),
        FieldInfo.newOptional(ClientConfigPAccessor.WRITE_RETRY_DELAY_MS),
        FieldInfo.newOptional(ClientConfigPAccessor.HEARTBEAT_INTERVAL_MS),
        FieldInfo.newOptional(ClientConfigPAccessor.PERF_COUNTER_DELAY_MS),
        FieldInfo.newOptional(ClientConfigPAccessor.MAX_EXPONENTIAL_BACKOFF_FACTOR),
        FieldInfo.newOptional(ClientConfigPAccessor.SMEAR_PERCENT),
        FieldInfo.newOptional(ClientConfigPAccessor.IS_TRANSIENT),
        FieldInfo.newOptional(ClientConfigPAccessor.INITIAL_PERSISTENT_HEARTBEAT_DELAY_MS),
        FieldInfo.newOptional(ClientConfigPAccessor.CHANNEL_SUPPORTS_OFFLINE_DELIVERY),
        FieldInfo.newRequired(ClientConfigPAccessor.PROTOCOL_HANDLER_CONFIG,
            PROTOCOL_HANDLER_CONFIG),
        FieldInfo.newOptional(ClientConfigPAccessor.OFFLINE_HEARTBEAT_THRESHOLD_MS),
        FieldInfo.newOptional(ClientConfigPAccessor.ALLOW_SUPPRESSION)
        );

    private CommonMsgInfos() {
      // Initialize in constructor since other instance fields are referenced
      INVALIDATION_MSG = new MessageInfo(
          ClientProtocolAccessor.INVALIDATION_MESSAGE_ACCESSOR,
          FieldInfo.newRequired(InvalidationMessageAccessor.INVALIDATION,
              this.INVALIDATION));
    }
  }

  /** Describes how to validate client messages. */
  private class ClientMsgInfos {
    /** Validation for client headers. */
    final MessageInfo HEADER = new MessageInfo(
        ClientProtocolAccessor.CLIENT_HEADER_ACCESSOR,
        FieldInfo.newRequired(ClientHeaderAccessor.PROTOCOL_VERSION,
            commonMsgInfos.PROTOCOL_VERSION),
        FieldInfo.newOptional(ClientHeaderAccessor.CLIENT_TOKEN),
        FieldInfo.newOptional(ClientHeaderAccessor.REGISTRATION_SUMMARY,
            commonMsgInfos.REGISTRATION_SUMMARY),
        FieldInfo.newRequired(ClientHeaderAccessor.CLIENT_TIME_MS),
        FieldInfo.newRequired(ClientHeaderAccessor.MAX_KNOWN_SERVER_TIME_MS),
        FieldInfo.newOptional(ClientHeaderAccessor.MESSAGE_ID),
        FieldInfo.newOptional(ClientHeaderAccessor.CLIENT_TYPE)) {
      @Override
      public boolean postValidate(MessageLite message) {
        ClientHeader header = (ClientHeader) message;

        // If set, token must not be empty.
        if (header.hasClientToken() && header.getClientToken().isEmpty()) {
          logger.info("Client token was set but empty: %s", header);
          return false;
        }

        // If set, message id must not be empty.
        // Do not use String.isEmpty() here for Froyo (JDK5) compatibility.
        if (header.hasMessageId() && (header.getMessageId().length() == 0)) {
          logger.info("Message id was set but empty: %s", header);
          return false;
        }

        if (header.getClientTimeMs() < 0) {
          logger.info("Client time was negative: %s", header);
          return false;
        }

        if (header.getMaxKnownServerTimeMs() < 0) {
          logger.info("Max known server time was negative: %s", header);
          return false;
        }
        return true;
      }
    };

    /** Validation for application client ids. */
    final MessageInfo APPLICATION_CLIENT_ID = new MessageInfo(
        // Client type is optional here since the registrar needs to accept messages from
        // the ticls that do not set the client type.
        ClientProtocolAccessor.APPLICATION_CLIENT_ID_P_ACCESSOR,
        FieldInfo.newOptional(ApplicationClientIdPAccessor.CLIENT_TYPE),
        FieldInfo.newRequired(ApplicationClientIdPAccessor.CLIENT_NAME)) {
      @Override
      public boolean postValidate(MessageLite message) {
        ApplicationClientIdP applicationClientId = (ApplicationClientIdP) message;
        return !applicationClientId.getClientName().isEmpty();
      }
    };

    /** Validation for client initialization messages. */
    final MessageInfo INITIALIZE_MESSAGE = new MessageInfo(
        ClientProtocolAccessor.INITIALIZE_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(InitializeMessageAccessor.CLIENT_TYPE),
        FieldInfo.newRequired(InitializeMessageAccessor.NONCE),
        FieldInfo.newRequired(InitializeMessageAccessor.DIGEST_SERIALIZATION_TYPE),
        FieldInfo.newRequired(InitializeMessageAccessor.APPLICATION_CLIENT_ID,
            APPLICATION_CLIENT_ID)) {
      @Override
      public boolean postValidate(MessageLite message) {
        return ((InitializeMessage) message).getClientType() >= 0;
      }
    };

    /** Validation for registration requests. */
    final MessageInfo REGISTRATION = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(RegistrationMessageAccessor.REGISTRATION,
            commonMsgInfos.REGISTRATIONP));

    /** Validation for client versions. */
    final MessageInfo CLIENT_VERSION = new MessageInfo(
        ClientProtocolAccessor.CLIENT_VERSION_ACCESSOR,
        FieldInfo.newRequired(ClientVersionAccessor.VERSION, commonMsgInfos.VERSION),
        FieldInfo.newRequired(ClientVersionAccessor.PLATFORM),
        FieldInfo.newRequired(ClientVersionAccessor.LANGUAGE),
        FieldInfo.newRequired(ClientVersionAccessor.APPLICATION_INFO));

    /** Validation for client information messages. */
    final MessageInfo INFO = new MessageInfo(
        ClientProtocolAccessor.INFO_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(InfoMessageAccessor.CLIENT_VERSION, CLIENT_VERSION),
        FieldInfo.newOptional(InfoMessageAccessor.CONFIG_PARAMETER),
        FieldInfo.newOptional(InfoMessageAccessor.PERFORMANCE_COUNTER),
        FieldInfo.newOptional(InfoMessageAccessor.CLIENT_CONFIG, commonMsgInfos.CLIENT_CONFIG),
        FieldInfo.newOptional(InfoMessageAccessor.SERVER_REGISTRATION_SUMMARY_REQUESTED));

    /** Validation for registration subtrees. */
    final MessageInfo SUBTREE = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_SUBTREE_ACCESSOR,
        FieldInfo.newOptional(RegistrationSubtreeAccessor.REGISTERED_OBJECT));

    /** Validation for registration sync messages. */
    final MessageInfo REGISTRATION_SYNC = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_SYNC_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(RegistrationSyncMessageAccessor.SUBTREE, SUBTREE));

    /** Validation for a ClientToServerMessage. */
    final MessageInfo CLIENT_MSG = new MessageInfo(
        ClientProtocolAccessor.CLIENT_TO_SERVER_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(ClientToServerMessageAccessor.HEADER, HEADER),
        FieldInfo.newOptional(ClientToServerMessageAccessor.INFO_MESSAGE, INFO),
        FieldInfo.newOptional(ClientToServerMessageAccessor.INITIALIZE_MESSAGE, INITIALIZE_MESSAGE),
        FieldInfo.newOptional(ClientToServerMessageAccessor.INVALIDATION_ACK_MESSAGE,
            commonMsgInfos.INVALIDATION_MSG),
        FieldInfo.newOptional(ClientToServerMessageAccessor.REGISTRATION_MESSAGE, REGISTRATION),
        FieldInfo.newOptional(ClientToServerMessageAccessor.REGISTRATION_SYNC_MESSAGE,
            REGISTRATION_SYNC)) {
      @Override
      public boolean postValidate(MessageLite message) {
        ClientToServerMessage parsedMessage = (ClientToServerMessage) message;
        // The message either has an initialize request from the client or it has the client token.
        return (parsedMessage.hasInitializeMessage() ^ parsedMessage.getHeader().hasClientToken());
      }
    };
  }

  /** Describes how to validate server messages. */
  
  class ServerMsgInfos {
    /** Validation for server headers. */
    final MessageInfo HEADER = new MessageInfo(
        ClientProtocolAccessor.SERVER_HEADER_ACCESSOR,
        FieldInfo.newRequired(ServerHeaderAccessor.PROTOCOL_VERSION,
            commonMsgInfos.PROTOCOL_VERSION),
        FieldInfo.newRequired(ServerHeaderAccessor.CLIENT_TOKEN),
        FieldInfo.newOptional(ServerHeaderAccessor.REGISTRATION_SUMMARY,
            commonMsgInfos.REGISTRATION_SUMMARY),
        FieldInfo.newRequired(ServerHeaderAccessor.SERVER_TIME_MS),
        FieldInfo.newOptional(ServerHeaderAccessor.MESSAGE_ID)) {
      @Override
      public boolean postValidate(MessageLite message) {
        ServerHeader header = (ServerHeader) message;
        if (header.getClientToken().isEmpty()) {
          logger.info("Client token was empty: %s", header);
          return false;
        }
        if (header.getServerTimeMs() < 0) {
          logger.info("Server time was negative: %s", header);
          return false;
        }
        // If set, message id must not be empty.
        // Do not use String.isEmpty() here for Froyo (JDK5) compatibility.
        if (header.hasMessageId() && (header.getMessageId().length() == 0)) {
          logger.info("Message id was set but empty: %s", header);
          return false;
        }
        return true;
      }
    };

    /** Validation for server response codes. */
    final MessageInfo STATUSP = new MessageInfo(
        ClientProtocolAccessor.STATUS_P_ACCESSOR,
        FieldInfo.newRequired(StatusPAccessor.CODE),
        FieldInfo.newOptional(StatusPAccessor.DESCRIPTION));

    /** Validation for token control messages. */
    final MessageInfo TOKEN_CONTROL = new MessageInfo(
        ClientProtocolAccessor.TOKEN_CONTROL_MESSAGE_ACCESSOR,
        FieldInfo.newOptional(TokenControlMessageAccessor.NEW_TOKEN));

    /** Validation for error messages. */
    final MessageInfo ERROR = new MessageInfo(
        ClientProtocolAccessor.ERROR_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(ErrorMessageAccessor.CODE),
        FieldInfo.newRequired(ErrorMessageAccessor.DESCRIPTION));

    /** Validation for registration results. */
    final MessageInfo REGISTRATION_RESULT = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_STATUS_ACCESSOR,
        FieldInfo.newRequired(RegistrationStatusAccessor.REGISTRATION,
            commonMsgInfos.REGISTRATIONP),
        FieldInfo.newRequired(RegistrationStatusAccessor.STATUS, STATUSP));

    /** Validation for registration status messages. */
    final MessageInfo REGISTRATION_STATUS_MSG = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_STATUS_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(RegistrationStatusMessageAccessor.REGISTRATION_STATUS,
            REGISTRATION_RESULT));

    /** Validation for registration sync requests. */
    final MessageInfo REGISTRATION_SYNC_REQUEST = new MessageInfo(
        ClientProtocolAccessor.REGISTRATION_SYNC_REQUEST_MESSAGE_ACCESSOR);

    /** Validation for info requests. */
    final MessageInfo INFO_REQUEST = new MessageInfo(
        ClientProtocolAccessor.INFO_REQUEST_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(InfoRequestMessageAccessor.INFO_TYPE));

    /** Validation for config change message. */
    final MessageInfo CONFIG_CHANGE = new MessageInfo(
        ClientProtocolAccessor.CONFIG_CHANGE_MESSAGE_ACCESSOR,
        FieldInfo.newOptional(ConfigChangeMessageAccessor.NEXT_MESSAGE_DELAY_MS)) {
          @Override
          public boolean postValidate(MessageLite message) {
            ConfigChangeMessage parsedMessage = (ConfigChangeMessage) message;
            // If the message has a next_message_delay_ms value, it must be positive.
            return !parsedMessage.hasNextMessageDelayMs() ||
                (parsedMessage.getNextMessageDelayMs() > 0);
          }
        };

    /** Validation for the top-level server messages. */
    final MessageInfo SERVER_MSG = new MessageInfo(
        ClientProtocolAccessor.SERVER_TO_CLIENT_MESSAGE_ACCESSOR,
        FieldInfo.newRequired(ServerToClientMessageAccessor.HEADER, HEADER),
        FieldInfo.newOptional(ServerToClientMessageAccessor.TOKEN_CONTROL_MESSAGE, TOKEN_CONTROL),
        FieldInfo.newOptional(ServerToClientMessageAccessor.INVALIDATION_MESSAGE,
            commonMsgInfos.INVALIDATION_MSG),
        FieldInfo.newOptional(ServerToClientMessageAccessor.REGISTRATION_STATUS_MESSAGE,
            REGISTRATION_STATUS_MSG),
        FieldInfo.newOptional(ServerToClientMessageAccessor.REGISTRATION_SYNC_REQUEST_MESSAGE,
            REGISTRATION_SYNC_REQUEST),
        FieldInfo.newOptional(ServerToClientMessageAccessor.CONFIG_CHANGE_MESSAGE, CONFIG_CHANGE),
        FieldInfo.newOptional(ServerToClientMessageAccessor.INFO_REQUEST_MESSAGE, INFO_REQUEST),
        FieldInfo.newOptional(ServerToClientMessageAccessor.ERROR_MESSAGE, ERROR));
  }

  /** Common validation information */
  
  final CommonMsgInfos commonMsgInfos = new CommonMsgInfos();

  /** Client validation information */
  private final ClientMsgInfos clientMsgInfos = new ClientMsgInfos();

  /** Server validation information */
  
  final ServerMsgInfos serverMsgInfos = new ServerMsgInfos();

  /** Returns whether {@code clientMessage} is valid. */
  public boolean isValid(ClientToServerMessage clientMessage) {
    return checkMessage(clientMessage, clientMsgInfos.CLIENT_MSG);
  }

  /** Returns whether {@code serverMessage} is valid. */
  public boolean isValid(ServerToClientMessage serverMessage) {
    return checkMessage(serverMessage, serverMsgInfos.SERVER_MSG);
  }

  /** Returns whether {@code invalidation} is valid. */
  public boolean isValid(InvalidationP invalidation) {
    return checkMessage(invalidation, commonMsgInfos.INVALIDATION);
  }

  /** Returns whether {@code version} is valid. */
  public boolean isValid(Version version) {
    return checkMessage(version, commonMsgInfos.VERSION);
  }

  /** Returns the {@code MessageInfo} for a {@link ServerToClientMessage}. */
  public MessageInfo getServerToClientMessageInfo() {
    return serverMsgInfos.SERVER_MSG;
  }
}