/*
 *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

/*
 * vie_encryption_impl.cc
 */

#include "vie_encryption_impl.h"

// Defines
#include "vie_defines.h"
#include "vie_errors.h"
#include "vie_channel.h"
#include "vie_channel_manager.h"

#include "trace.h"
#include "vie_impl.h"

#ifdef WEBRTC_SRTP
#include "SrtpModule.h"
#endif

namespace webrtc
{

// ----------------------------------------------------------------------------
// GetInterface
// ----------------------------------------------------------------------------

ViEEncryption* ViEEncryption::GetInterface(VideoEngine* videoEngine)
{
#ifdef WEBRTC_VIDEO_ENGINE_ENCRYPTION_API
    if (videoEngine == NULL)
    {
        return NULL;
    }
    VideoEngineImpl* vieImpl = reinterpret_cast<VideoEngineImpl*> (videoEngine);
    ViEEncryptionImpl* vieEncryptionImpl = vieImpl;
    (*vieEncryptionImpl)++; // Increase ref count

    return vieEncryptionImpl;
#else
    return NULL;
#endif
}

// ----------------------------------------------------------------------------
// Release
//
// Releases the interface, i.e. reduces the reference counter. The number of
// remaining references is returned, -1 if released too many times.
// ----------------------------------------------------------------------------

int ViEEncryptionImpl::Release()
{
    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo, _instanceId,
               "ViEEncryptionImpl::Release()");
    (*this)--; // Decrease ref count

    WebRtc_Word32 refCount = GetCount();
    if (refCount < 0)
    {
        WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, _instanceId,
                   "ViEEncryptionImpl release too many times");
        SetLastError(kViEAPIDoesNotExist);
        return -1;
    }
    WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, _instanceId,
               "ViEEncryptionImpl reference count: %d", refCount);
    return refCount;
}

// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------

ViEEncryptionImpl::ViEEncryptionImpl()
{
    WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, _instanceId,
               "ViEEncryptionImpl::ViEEncryptionImpl() Ctor");
}

// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------

ViEEncryptionImpl::~ViEEncryptionImpl()
{
    WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, _instanceId,
               "ViEEncryptionImpl::~ViEEncryptionImpl() Dtor");
}

// ============================================================================
// SRTP
// ============================================================================

// ----------------------------------------------------------------------------
// EnableSRTPSend
//
// ----------------------------------------------------------------------------

int ViEEncryptionImpl::EnableSRTPSend(
    const int videoChannel, const CipherTypes cipherType,
    const unsigned int cipherKeyLength, const AuthenticationTypes authType,
    const unsigned int authKeyLength, const unsigned int authTagLength,
    const SecurityLevels level, const unsigned char key[kViEMaxSrtpKeyLength],
    const bool useForRTCP)
{

    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo, _instanceId,
               "EnableSRTPSend(channel=%d, cipherType=%d, cipherKeyLength=%d, "
               "authType=%d, authKeyLength=%d, authTagLength=%d, level=%d, "
               "key=?, RTCP=%s",
               videoChannel, cipherType, cipherKeyLength, authType,
               authKeyLength, authTagLength, level,
               useForRTCP ? "true" : "false");
#ifdef WEBRTC_SRTP
    if (!IsInitialized())
    {
        SetLastError(kViENotInitialized);
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_instanceId),
                   "%s - ViE instance %d not initialized", __FUNCTION__,
                   _instanceId);
        return -1;
    }

    bool cipherAllZero = (kCipherNull == cipherType) && (0 == cipherKeyLength);
    bool authAllZero = (kAuthNull == authType) &&
                       (0 == authKeyLength) &&
                       (0 == authTagLength);

    // 1. For no protection all cipher and auth must be zero
    // 2. For encryption only all auth must be zero
    // 3. For authentication only all cipher must be zero
    if (((kNoProtection == level) && (!cipherAllZero || !authAllZero))
        || ((kEncryption == level) && !authAllZero)
        || ((kAuthentication == level) && !cipherAllZero))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, _instanceId,
                   "  Invalid input argument");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    // 16 <= cipherKeyLength <= 256
    if (((kEncryption == level) || (kEncryptionAndAuthentication == level))
        && ((cipherKeyLength < kViEMinSrtpEncryptLength)
            || (cipherKeyLength > kViEMaxSrtpEncryptLength)))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, _instanceId,
                   "  Invalid cipher key length");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    // For HMAC_SHA1 auth:
    // authKeyLength <= 20, authTagLength <= 20
    if (((kAuthentication == level) || (kEncryptionAndAuthentication == level))
        && (kAuthHmacSha1 == authType)
        && ((authKeyLength > kViEMaxSrtpAuthSh1Length)
            || (authTagLength > kViEMaxSrtpAuthSh1Length)))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, _instanceId,
                   "  Invalid auth key or tag length");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    // For NULL auth:
    // authKeyLength <= 256, authTagLength <= 12
    if (((kAuthentication == level) || (kEncryptionAndAuthentication == level))
        && (kAuthNull == authType)
        && ((authKeyLength > kViEMaxSrtpKeyAuthNullLength)
            || (authTagLength > kViEMaxSrtpTagAuthNullLength)))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, _instanceId,
                   "  Invalid auth key or tag length");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }
    if (!key)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, _instanceId,
                   "  key NULL pointer");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    const SrtpModule::CipherTypes cipher_type =
        static_cast<const SrtpModule::CipherTypes> (cipherType);
    const SrtpModule::AuthenticationTypes auth_type =
        static_cast<const SrtpModule::AuthenticationTypes> (authType);
    const SrtpModule::SecurityLevels security_level =
        static_cast<const SrtpModule::SecurityLevels> (level);

    ViEChannelManagerScoped cs(_channelManager);
    ViEChannel* vieChannel = cs.Channel(videoChannel);
    if (vieChannel == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel), "%s: No channel %d",
                   __FUNCTION__, videoChannel);
        SetLastError(kViEEncryptionInvalidChannelId);
        return -1;
    }

    if (0 != vieChannel->EnableSRTPSend(cipher_type, cipherKeyLength, auth_type,
                                        authKeyLength, authTagLength,
                                        security_level, key, useForRTCP))
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, _instanceId,
                   "Failed to configure SRTP Encryption for sending");
        SetLastError(kViEEncryptionUnknownError);
        return -1;
    }

    WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideo, _instanceId,
               "SRTP Enabled for sending");
    return 0;
#else    
    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVoice,
               ViEId(_instanceId, videoChannel),
               "  _SRTP is undefined => _lastError = %d",
               LastErrorInternal());
    SetLastError(kViEEncryptionSrtpNotSupported);
    return -1;
#endif
}

// ----------------------------------------------------------------------------
// DisableSRTPSend
//
// ----------------------------------------------------------------------------

int ViEEncryptionImpl::DisableSRTPSend(const int videoChannel)
{
    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel),
               "DisableSRTPSend(videoChannel=%d)", videoChannel);
#ifdef WEBRTC_SRTP
    ViEChannelManagerScoped cs(_channelManager);
    ViEChannel* vieChannel = cs.Channel(videoChannel);
    if (vieChannel == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel), "%s: No channel %d",
                   __FUNCTION__, videoChannel);
        SetLastError(kViEEncryptionInvalidChannelId);
        return -1;
    }

    if (0 != vieChannel->DisableSRTPSend())
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel),
                   "Failed to Disable SRTP Encryption for sending");
        SetLastError(kViEEncryptionUnknownError);
        return -1;
    }

    WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel),
               "SRTP Disabled for sending");
    return 0;
#else    
    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVoice,
               ViEId(_instanceId, videoChannel),
               "  _SRTP is undefined => _lastError = %d",
               LastErrorInternal());
    SetLastError(kViEEncryptionSrtpNotSupported);
    return -1;
#endif

}

// ----------------------------------------------------------------------------
// EnableSRTPReceive
//
// ----------------------------------------------------------------------------

int ViEEncryptionImpl::EnableSRTPReceive(
    const int videoChannel, const CipherTypes cipherType,
    const unsigned int cipherKeyLength, const AuthenticationTypes authType,
    const unsigned int authKeyLength, const unsigned int authTagLength,
    const SecurityLevels level,
    const unsigned char key[kViEMaxSrtpKeyLength], const bool useForRTCP)
{
    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel),
               "EnableSRTPReceive(channel=%d, cipherType=%d, "
               "cipherKeyLength=%d, authType=%d, authKeyLength=%d, "
               "authTagLength=%d, level=%d, key=?, RTCP=%s)",
               videoChannel, cipherType, cipherKeyLength, authType,
               authKeyLength, authTagLength, level,
               useForRTCP ? "true" : "false");

#ifdef WEBRTC_SRTP
    if (!IsInitialized())
    {
        SetLastError(kViENotInitialized);
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_instanceId),
                   "%s - ViE instance %d not initialized", __FUNCTION__,
                   _instanceId);
        return -1;
    }

    bool cipherAllZero = (kCipherNull == cipherType) && (0 == cipherKeyLength);
    bool authAllZero = (kAuthNull == authType)
                       && (0 == authKeyLength)
                       && (0 == authTagLength);

    // 1. For no protection all cipher and auth must be zero
    // 2. For encryption only all auth must be zero
    // 3. For authentication only all cipher must be zero
    if (((kNoProtection == level) && (!cipherAllZero || !authAllZero)) ||
        ((kEncryption == level) && !authAllZero) ||
        ((kAuthentication == level) && !cipherAllZero))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel),
                   "  Invalid input argument");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    // 16 <= cipherKeyLength <= 256
    if (((kEncryption == level) || (kEncryptionAndAuthentication == level))
        && ((cipherKeyLength < kViEMinSrtpEncryptLength)
            || (cipherKeyLength > kViEMaxSrtpEncryptLength)))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel),
                   "  Invalid cipher key length");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    // For HMAC_SHA1 auth:
    // authKeyLength <= 20, authTagLength <= 20
    if (((kAuthentication == level) || (kEncryptionAndAuthentication == level))
        && (kAuthHmacSha1 == authType)
        && ((authKeyLength > kViEMaxSrtpAuthSh1Length)
            || (authTagLength > kViEMaxSrtpAuthSh1Length)))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel),
                   "  Invalid auth key or tag length");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    // For NULL auth:
    // authKeyLength <= 256, authTagLength <= 12
    if (((kAuthentication == level) || (kEncryptionAndAuthentication == level))
        && (kAuthNull == authType)
        && ((authKeyLength > kViEMaxSrtpKeyAuthNullLength)
            || (authTagLength > kViEMaxSrtpTagAuthNullLength)))

    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel),
                   "  Invalid auth key or tag length");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    if (!key)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel), "  key NULL pointer");
        SetLastError(kViEEncryptionInvalidSrtpParameter);
        return -1;
    }

    const SrtpModule::CipherTypes cipher_type =
        static_cast<const SrtpModule::CipherTypes> (cipherType);
    const SrtpModule::AuthenticationTypes auth_type =
        static_cast<const SrtpModule::AuthenticationTypes> (authType);
    const SrtpModule::SecurityLevels security_level =
        static_cast<const SrtpModule::SecurityLevels> (level);

    ViEChannelManagerScoped cs(_channelManager);
    ViEChannel* vieChannel = cs.Channel(videoChannel);
    if (vieChannel == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel), "%s: No channel %d",
                   __FUNCTION__, videoChannel);
        SetLastError(kViEEncryptionInvalidChannelId);
        return -1;
    }

    if (0 != vieChannel->EnableSRTPReceive(cipher_type, cipherKeyLength,
                                           auth_type, authKeyLength,
                                           authTagLength, security_level, key,
                                           useForRTCP))
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel),
                   "Failed to configure SRTP Encryption for receiving");
        SetLastError(kViEEncryptionUnknownError);
        return -1;
    }

    WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel),
               "SRTP Enabled for receiving");
    return 0;

#else    
    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVoice,
               ViEId(_instanceId, videoChannel),
               "  _SRTP is undefined => _lastError = %d",
               LastErrorInternal());
    SetLastError(kViEEncryptionSrtpNotSupported);
    return -1;
#endif
}

// ----------------------------------------------------------------------------
// DisableSRTPReceive
//
// ----------------------------------------------------------------------------

int ViEEncryptionImpl::DisableSRTPReceive(const int videoChannel)
{
    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel),
               "DisableSRTPReceive(videoChannel=%d)", videoChannel);

#ifdef WEBRTC_SRTP
    ViEChannelManagerScoped cs(_channelManager);
    ViEChannel* vieChannel = cs.Channel(videoChannel);
    if (vieChannel == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel), "%s: No channel %d",
                   __FUNCTION__, videoChannel);
        SetLastError(kViEEncryptionInvalidChannelId);
        return -1;
    }

    if (0 != vieChannel->DisableSRTPReceive())
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel),
                   "Failed to Disable SRTP Encryption for receiving");
        SetLastError(kViEEncryptionUnknownError);
        return -1;
    }

    WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel), "SRTP Disabled for receiving");
    return 0;
#else    
    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVoice,
               ViEId(_instanceId, videoChannel),
               "  _SRTP is undefined => _lastError = %d",
               LastErrorInternal());
    SetLastError(kViEEncryptionSrtpNotSupported);
    return -1;
#endif
}

// ============================================================================
// External encryption
// ============================================================================

// ----------------------------------------------------------------------------
// RegisterExternalEncryption
//
// ----------------------------------------------------------------------------

int ViEEncryptionImpl::RegisterExternalEncryption(const int videoChannel,
                                                  Encryption& encryption)
{
    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel),
               "RegisterExternalEncryption(videoChannel=%d)", videoChannel);

    ViEChannelManagerScoped cs(_channelManager);
    ViEChannel* vieChannel = cs.Channel(videoChannel);
    if (vieChannel == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel), "%s: No channel %d",
                   __FUNCTION__, videoChannel);
        SetLastError(kViEEncryptionInvalidChannelId);
        return -1;
    }
    if (vieChannel->RegisterExternalEncryption(&encryption) != 0)
    {
        SetLastError(kViEEncryptionUnknownError);
        return -1;
    }

    return 0;
}

// ----------------------------------------------------------------------------
// DeregisterExternalEncryption
//
// ----------------------------------------------------------------------------

int ViEEncryptionImpl::DeregisterExternalEncryption(const int videoChannel)
{
    WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo,
               ViEId(_instanceId, videoChannel),
               "RegisterExternalEncryption(videoChannel=%d)", videoChannel);

    ViEChannelManagerScoped cs(_channelManager);
    ViEChannel* vieChannel = cs.Channel(videoChannel);
    if (vieChannel == NULL)
    {
        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
                   ViEId(_instanceId, videoChannel), "%s: No channel %d",
                   __FUNCTION__, videoChannel);
        SetLastError(kViEEncryptionInvalidChannelId);
        return -1;
    }

    if (vieChannel->DeRegisterExternalEncryption() != 0)
    {
        SetLastError(kViEEncryptionUnknownError);
        return -1;
    }
    return 0;
}
} // namespace webrtc