TSaslTransport.h

Go to the documentation of this file.

// This file will be removed when the code is accepted into the Thrift library.
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */

#ifndef _THRIFT_TRANSPORT_TSSLTRANSPORT_H_
#define _THRIFT_TRANSPORT_TSSLTRANSPORT_H_ 1

#include <string>

#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
#include <thrift/transport/TTransport.h>
#include <thrift/transport/TVirtualTransport.h>
#include <thrift/transport/TBufferTransports.h>

#include "transport/TSasl.h"

namespace apache { namespace thrift { namespace transport {

enum NegotiationStatus {
  TSASL_INVALID = -1,
  TSASL_START = 1,
  TSASL_OK = 2,
  TSASL_BAD = 3,
  TSASL_ERROR = 4,
  TSASL_COMPLETE = 5
};

static const int MECHANISM_NAME_BYTES = 1;
static const int STATUS_BYTES = 1;
static const int PAYLOAD_LENGTH_BYTES = 4;
static const int HEADER_LENGTH = STATUS_BYTES + PAYLOAD_LENGTH_BYTES;

class TSaslTransport : public TVirtualTransport<TSaslTransport> {
 public:
  TSaslTransport(boost::shared_ptr<TTransport> transport);

  TSaslTransport(boost::shared_ptr<sasl::TSasl> saslClient,
                 boost::shared_ptr<TTransport> transport);

  virtual ~TSaslTransport();

  virtual bool isOpen();

  virtual bool peek();

  virtual void open();

  virtual void close();

  uint32_t read(uint8_t* buf, uint32_t len);

  void write(const uint8_t* buf, uint32_t len);

  virtual void flush();

  boost::shared_ptr<TTransport> getUnderlyingTransport() {
    return transport_;
  }

  std::string getUsername();

 protected:
  boost::shared_ptr<TTransport> transport_;

  TMemoryBuffer* memBuf_;

  boost::shared_ptr<sasl::TSasl> sasl_;

  bool shouldWrap_;

  bool isClient_;

  boost::scoped_array<uint8_t> protoBuf_;

  /* store the big endian format int to given buffer */
  void encodeInt(uint32_t x, uint8_t* buf, uint32_t offset) {
    *(reinterpret_cast<uint32_t*>(buf + offset)) = htonl(x);
  }

  /* load the big endian format int to given buffer */
  uint32_t decodeInt (uint8_t* buf, uint32_t offset) {
    return ntohl(*(reinterpret_cast<uint32_t*>(buf + offset)));
  }

  uint8_t* receiveSaslMessage(NegotiationStatus* status , uint32_t* length);

  void sendSaslMessage(const NegotiationStatus status,
                       const uint8_t* payload, const uint32_t length, bool flush = true);

  uint32_t readLength();

  void writeLength(uint32_t length);
  virtual void handleSaslStartMessage() = 0;

  void shrinkBuffer();
};

}}} // apache::thrift::transport

#endif // #ifndef _THRIFT_TRANSPORT_TSSLTRANSPORT_H_