pcep/impl/src/main/java/org/opendaylight/protocol/pcep/impl/AbstractPCEPSessionNegotiator.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.protocol.pcep.impl;
   9
  10 import com.google.common.annotations.VisibleForTesting;
  11 import com.google.common.base.Preconditions;
  12 import io.netty.channel.Channel;
  13 import io.netty.handler.ssl.SslHandler;
  14 import io.netty.util.concurrent.Promise;
  15 import java.util.concurrent.Future;
  16 import java.util.concurrent.TimeUnit;
  17 import java.util.concurrent.TimeoutException;
  18 import javax.net.ssl.SSLContext;
  19 import javax.net.ssl.SSLEngine;
  20 import org.opendaylight.controller.config.yang.pcep.impl.Tls;
  21 import org.opendaylight.protocol.pcep.impl.spi.Util;
  22 import org.opendaylight.protocol.pcep.impl.tls.SslContextFactory;
  23 import org.opendaylight.protocol.pcep.spi.PCEPErrors;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Keepalive;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.KeepaliveBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.OpenBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Pcerr;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Starttls;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.StarttlsBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.Message;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.OpenMessage;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.keepalive.message.KeepaliveMessageBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.message.OpenMessageBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.object.Open;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcep.error.object.ErrorObject;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.pcerr.message.error.type.SessionCase;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.start.tls.message.StartTlsMessageBuilder;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 /**
  42  * Abstract PCEP session negotiator. Takes care of basic handshake without implementing a specific policy. Policies need
  43  * to be provided by a specific subclass.
  44  */
  45 public abstract class AbstractPCEPSessionNegotiator extends AbstractSessionNegotiator {
  46     /**
  47      * Unified KeepWait and OpenWait timer expiration, in seconds.
  48      */
  49     public static final int FAIL_TIMER_VALUE = 60;
  50
  51     /**
  52      * PCEP session negotiation state transitions are described in RFC5440. Simplification the two timers (KeepWait and
  53      * OpenWait) are merged into a FailTimer, as they are mutually exclusive, have the same timeout value and their
  54      * action is to terminate negotiation. This timer is restarted between state transitions and runs in all states
  55      * except Idle and Finished.
  56      */
  57     @VisibleForTesting
  58     public enum State {
  59         /**
  60          * Negotiation has not begun. It will be activated once we are asked to provide our initial proposal, at which
  61          * point we move into OpenWait state.
  62          */
  63         IDLE,
  64         /**
  65          * Waiting for the peer's StartTLS message
  66          */
  67         START_TLS_WAIT,
  68         /**
  69          * Waiting for the peer's OPEN message.
  70          */
  71         OPEN_WAIT,
  72         /**
  73          * Waiting for the peer's KEEPALIVE message.
  74          */
  75         KEEP_WAIT,
  76         /**
  77          * Negotiation has completed.
  78          */
  79         FINISHED,
  80     }
  81
  82     private static final Logger LOG = LoggerFactory.getLogger(AbstractPCEPSessionNegotiator.class);
  83     private static final Keepalive KEEPALIVE = new KeepaliveBuilder().setKeepaliveMessage(new KeepaliveMessageBuilder().build()).build();
  84
  85     private volatile boolean localOK, openRetry, remoteOK;
  86     private volatile State state = State.IDLE;
  87     private Future<?> failTimer;
  88     private Open localPrefs;
  89     private Open remotePrefs;
  90     private Tls tlsConfiguration;
  91
  92     protected AbstractPCEPSessionNegotiator(final Promise<PCEPSessionImpl> promise, final Channel channel) {
  93         super(promise, channel);
  94     }
  95
  96     /**
  97      * Get the initial session parameters proposal.
  98      *
  99      * @return Session parameters proposal.
 100      */
 101     protected abstract Open getInitialProposal();
 102
 103     /**
 104      * Get the revised session parameters proposal based on the feedback the peer has provided to us.
 105      *
 106      * @param suggestion Peer-provided suggested session parameters
 107      * @return Session parameters proposal, or null if peers session parameters preclude us from suggesting anything
 108      */
 109     protected abstract Open getRevisedProposal(Open suggestion);
 110
 111     /**
 112      * Check whether a peer-provided session parameters proposal is acceptable.
 113      *
 114      * @param proposal peer-proposed session parameters
 115      * @return true if the proposal is acceptable, false otherwise
 116      */
 117     protected abstract boolean isProposalAcceptable(Open proposal);
 118
 119     /**
 120      * Given a peer-provided session parameters proposal which we found unacceptable, provide a counter-proposal. The
 121      * requirement is that the isProposalAcceptable() method has to return true when presented with this proposal.
 122      *
 123      * @param proposal unacceptable peer proposal
 124      * @return our counter-proposal, or null if there is no way to negotiate an acceptable proposal
 125      */
 126     protected abstract Open getCounterProposal(Open proposal);
 127
 128     /**
 129      * Create the protocol session.
 130      *
 131      * @param channel Underlying channel.
 132      * @param localPrefs Session preferences proposed by us and accepted by the peer.
 133      * @param remotePrefs Session preferences proposed by the peer and accepted by us.
 134      * @return New protocol session.
 135      */
 136     protected abstract PCEPSessionImpl createSession(Channel channel, Open localPrefs, Open remotePrefs);
 137
 138     /**
 139      * Sends PCEP Error Message with one PCEPError.
 140      *
 141      * @param value
 142      */
 143     private void sendErrorMessage(final PCEPErrors value) {
 144
 145         this.sendMessage(Util.createErrorMessage(value, null));
 146     }
 147
 148     private void scheduleFailTimer() {
 149         this.failTimer = this.channel.eventLoop().schedule(new Runnable() {
 150             @Override
 151             public void run() {
 152                 switch (AbstractPCEPSessionNegotiator.this.state) {
 153                 case FINISHED:
 154                 case IDLE:
 155                     break;
 156                 case START_TLS_WAIT:
 157                     sendErrorMessage(PCEPErrors.STARTTLS_TIMER_EXP);
 158                     negotiationFailed(new TimeoutException("StartTLSWait timer expired"));
 159                     AbstractPCEPSessionNegotiator.this.state = State.FINISHED;
 160                     break;
 161                 case KEEP_WAIT:
 162                     sendErrorMessage(PCEPErrors.NO_MSG_BEFORE_EXP_KEEPWAIT);
 163                     negotiationFailed(new TimeoutException("KeepWait timer expired"));
 164                     AbstractPCEPSessionNegotiator.this.state = State.FINISHED;
 165                     break;
 166                 case OPEN_WAIT:
 167                     sendErrorMessage(PCEPErrors.NO_OPEN_BEFORE_EXP_OPENWAIT);
 168                     negotiationFailed(new TimeoutException("OpenWait timer expired"));
 169                     AbstractPCEPSessionNegotiator.this.state = State.FINISHED;
 170                     break;
 171                 default:
 172                     break;
 173                 }
 174             }
 175         }, FAIL_TIMER_VALUE, TimeUnit.SECONDS);
 176     }
 177
 178     @Override
 179     protected final void startNegotiation() {
 180         Preconditions.checkState(this.state == State.IDLE);
 181         if (this.tlsConfiguration != null) {
 182             this.sendMessage(new StarttlsBuilder().setStartTlsMessage(new StartTlsMessageBuilder().build()).build());
 183             this.state = State.START_TLS_WAIT;
 184             scheduleFailTimer();
 185             LOG.info("Started TLS connection negotiation with peer {}", this.channel);
 186         } else {
 187             startNegotiationWithOpen();
 188         }
 189     }
 190
 191     private void startNegotiationWithOpen() {
 192         this.localPrefs = getInitialProposal();
 193         final OpenMessage m = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.OpenBuilder().setOpenMessage(
 194                 new OpenMessageBuilder().setOpen(this.localPrefs).build()).build();
 195         this.sendMessage(m);
 196         this.state = State.OPEN_WAIT;
 197         scheduleFailTimer();
 198
 199         LOG.info("PCEP session with {} started, sent proposal {}", this.channel, this.localPrefs);
 200     }
 201
 202     private boolean handleMessageKeepWait(final Message msg) {
 203         if (msg instanceof Keepalive) {
 204             return handleMessageKeepAlive();
 205         } else if (msg instanceof Pcerr) {
 206             return handleMessagePcerr(msg);
 207         }
 208         return false;
 209     }
 210
 211     private boolean handleMessageKeepAlive() {
 212         this.localOK = true;
 213         if (this.remoteOK) {
 214             LOG.info("PCEP peer {} completed negotiation", this.channel);
 215             negotiationSuccessful(createSession(this.channel, this.localPrefs, this.remotePrefs));
 216             this.state = State.FINISHED;
 217         } else {
 218             scheduleFailTimer();
 219             this.state = State.OPEN_WAIT;
 220             LOG.debug("Channel {} moved to OpenWait state with localOK=1", this.channel);
 221         }
 222         return true;
 223     }
 224
 225     private boolean handleMessagePcerr(final Message msg) {
 226         final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.pcerr.message.PcerrMessage err = ((Pcerr) msg).getPcerrMessage();
 227         if (err.getErrorType() == null) {
 228             final ErrorObject obj = err.getErrors().get(0).getErrorObject();
 229             LOG.warn("Unexpected error received from PCC: type {} value {}", obj.getType(), obj.getValue());
 230             negotiationFailed(new IllegalStateException("Unexpected error received from PCC."));
 231             this.state = State.IDLE;
 232             return true;
 233         }
 234         this.localPrefs = getRevisedProposal(((SessionCase) err.getErrorType()).getSession().getOpen());
 235         if (this.localPrefs == null) {
 236             sendErrorMessage(PCEPErrors.PCERR_NON_ACC_SESSION_CHAR);
 237             negotiationFailed(new IllegalStateException("Peer suggested unacceptable retry proposal"));
 238             this.state = State.FINISHED;
 239             return true;
 240         }
 241         this.sendMessage(new OpenBuilder().setOpenMessage(new OpenMessageBuilder().setOpen(this.localPrefs).build()).build());
 242         if (!this.remoteOK) {
 243             this.state = State.OPEN_WAIT;
 244         }
 245         scheduleFailTimer();
 246         return true;
 247     }
 248
 249     private boolean handleMessageOpenWait(final Message msg) {
 250         if (!(msg instanceof org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Open)) {
 251             return false;
 252         }
 253         final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev131005.open.message.OpenMessage o = ((org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.message.rev131007.Open) msg).getOpenMessage();
 254         final Open open = o.getOpen();
 255         if (isProposalAcceptable(open)) {
 256             this.sendMessage(KEEPALIVE);
 257             this.remotePrefs = open;
 258             this.remoteOK = true;
 259             if (this.localOK) {
 260                 negotiationSuccessful(createSession(this.channel, this.localPrefs, this.remotePrefs));
 261                 LOG.info("PCEP peer {} completed negotiation", this.channel);
 262                 this.state = State.FINISHED;
 263             } else {
 264                 scheduleFailTimer();
 265                 this.state = State.KEEP_WAIT;
 266                 LOG.debug("Channel {} moved to KeepWait state with remoteOK=1", this.channel);
 267             }
 268             return true;
 269         }
 270         if (this.openRetry) {
 271             sendErrorMessage(PCEPErrors.SECOND_OPEN_MSG);
 272             negotiationFailed(new IllegalStateException("OPEN renegotiation failed"));
 273             this.state = State.FINISHED;
 274             return true;
 275         }
 276         final Open newPrefs = getCounterProposal(open);
 277         if (newPrefs == null) {
 278             sendErrorMessage(PCEPErrors.NON_ACC_NON_NEG_SESSION_CHAR);
 279             negotiationFailed(new IllegalStateException("Peer sent unacceptable session parameters"));
 280             this.state = State.FINISHED;
 281             return true;
 282         }
 283         this.sendMessage(Util.createErrorMessage(PCEPErrors.NON_ACC_NEG_SESSION_CHAR, newPrefs));
 284         this.openRetry = true;
 285         this.state = this.localOK ? State.OPEN_WAIT : State.KEEP_WAIT;
 286         scheduleFailTimer();
 287         return true;
 288     }
 289
 290     private boolean handleMessageStartTlsWait(final Message msg) {
 291         if (msg instanceof Starttls) {
 292             final SslContextFactory sslFactory = new SslContextFactory(this.tlsConfiguration);
 293             final SSLContext sslContext = sslFactory.getServerContext();
 294             if (sslContext == null) {
 295                 this.sendErrorMessage(PCEPErrors.NOT_POSSIBLE_WITHOUT_TLS);
 296                 negotiationFailed(new IllegalStateException("Failed to establish a TLS connection."));
 297                 this.state = State.FINISHED;
 298                 return true;
 299             }
 300             final SSLEngine engine = sslContext.createSSLEngine();
 301             engine.setNeedClientAuth(true);
 302             engine.setUseClientMode(false);
 303             this.channel.pipeline().addFirst(new SslHandler(engine));
 304             LOG.info("PCEPS TLS connection with peer: {} established succesfully.", this.channel);
 305             startNegotiationWithOpen();
 306             return true;
 307         } else if (!(msg instanceof Pcerr)) {
 308             this.sendErrorMessage(PCEPErrors.NON_STARTTLS_MSG_RCVD);
 309             negotiationFailed(new IllegalStateException("Unexpected message recieved."));
 310             this.state = State.FINISHED;
 311             return true;
 312         }
 313         return false;
 314     }
 315
 316     @Override
 317     protected final void handleMessage(final Message msg) {
 318         this.failTimer.cancel(false);
 319
 320         LOG.debug("Channel {} handling message {} in state {}", this.channel, msg, this.state);
 321
 322         switch (this.state) {
 323         case FINISHED:
 324         case IDLE:
 325             throw new IllegalStateException("Unexpected handleMessage in state " + this.state);
 326         case START_TLS_WAIT:
 327             if (handleMessageStartTlsWait(msg)) {
 328                 return;
 329             }
 330             break;
 331         case KEEP_WAIT:
 332             if (handleMessageKeepWait(msg)) {
 333                 return;
 334             }
 335             break;
 336         case OPEN_WAIT:
 337             if (handleMessageOpenWait(msg)) {
 338                 return;
 339             }
 340             break;
 341         default:
 342             break;
 343         }
 344         LOG.warn("Channel {} in state {} received unexpected message {}", this.channel, this.state, msg);
 345         sendErrorMessage(PCEPErrors.NON_OR_INVALID_OPEN_MSG);
 346         negotiationFailed(new Exception("Illegal message encountered"));
 347         this.state = State.FINISHED;
 348     }
 349
 350     @VisibleForTesting
 351     State getState() {
 352         return this.state;
 353     }
 354
 355     public void setTlsConfiguration(final Tls tlsConfiguration) {
 356         this.tlsConfiguration = tlsConfiguration;
 357     }
 358
 359     @Override
 360     protected void negotiationFailed(final Throwable cause) {
 361         this.LOG.debug("Negotiation on channel {} failed", this.channel, cause);
 362         this.channel.close();
 363         this.promise.setFailure(cause);
 364     }
 365 }