auth-provider.h

Go to the documentation of this file.

// Copyright 2012 Cloudera 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.

#ifndef IMPALA_RPC_AUTH_PROVIDER_H
#define IMPALA_RPC_AUTH_PROVIDER_H

#include <string>
#include <boost/scoped_ptr.hpp>
#include <boost/thread/mutex.hpp>
#include <sasl/sasl.h>

#include "common/status.h"
#include "util/promise.h"

namespace sasl { class TSasl; }

namespace impala {

class Thread;

class AuthProvider {
 public:
  virtual Status Start() = 0;

  virtual Status GetServerTransportFactory(
      boost::shared_ptr<apache::thrift::transport::TTransportFactory>* factory) = 0;

  virtual Status WrapClientTransport(const std::string& hostname,
      boost::shared_ptr<apache::thrift::transport::TTransport> raw_transport,
      const std::string& service_name,
      boost::shared_ptr<apache::thrift::transport::TTransport>* wrapped_transport) = 0;

  virtual bool is_sasl() = 0;
};

class SaslAuthProvider : public AuthProvider {
 public:
  SaslAuthProvider(bool is_internal) : has_ldap_(false), is_internal_(is_internal),
      needs_kinit_(false) {}

  virtual Status Start();

  virtual Status WrapClientTransport(const std::string& hostname,
      boost::shared_ptr<apache::thrift::transport::TTransport> raw_transport,
      const std::string& service_name,
      boost::shared_ptr<apache::thrift::transport::TTransport>* wrapped_transport);

  virtual Status GetServerTransportFactory(
      boost::shared_ptr<apache::thrift::transport::TTransportFactory>* factory);

  virtual bool is_sasl() { return true; }

  Status InitKerberos(const std::string& principal, const std::string& keytab_path);

  void InitLdap() { has_ldap_ = true; }

  const std::string& principal() const { return principal_; }
  const std::string& service_name() const { return service_name_; }
  const std::string& hostname() const { return hostname_; }
  const std::string& realm() const { return realm_; }
  bool has_ldap() { return has_ldap_; }

 private:
  bool has_ldap_;

  std::string hostname_;

  bool is_internal_;


  std::string principal_;

  std::string keytab_file_;

  std::string service_name_;

  std::string realm_;

  bool needs_kinit_;

  boost::scoped_ptr<Thread> kinit_thread_;

  void RunKinit(Promise<Status>* first_kinit);

  static bool env_setup_complete_;

  Status InitKerberosEnv();
};

class NoAuthProvider : public AuthProvider {
 public:
  NoAuthProvider() { }

  virtual Status Start() { return Status::OK; }

  virtual Status GetServerTransportFactory(
      boost::shared_ptr<apache::thrift::transport::TTransportFactory>* factory);

  virtual Status WrapClientTransport(const std::string& hostname,
      boost::shared_ptr<apache::thrift::transport::TTransport> raw_transport,
      const std::string& service_name,
      boost::shared_ptr<apache::thrift::transport::TTransport>* wrapped_transport);

  virtual bool is_sasl() { return false; }
};

Status InitAuth(const std::string& appname);

}

#endif