common_types.h

Go to the documentation of this file.

/*
 *
 * Copyright (c) Microsoft Corporation.
 * All rights reserved.
 *
 * This code is licensed under the MIT License.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files(the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions :
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */
#ifndef API_MIP_COMMON_TYPES_H_
#define API_MIP_COMMON_TYPES_H_
 
#include <cstring>
#include <exception>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "mip/mip_namespace.h"
 
#ifndef UNUSED
#define UNUSED(x) (void)x
#endif
MIP_NAMESPACE_BEGIN
 
enum class WatermarkLayout : unsigned int {
  HORIZONTAL = 0, 
  DIAGONAL = 1, 
};
 
enum class ContentMarkAlignment : unsigned int {
  LEFT = 0, 
  RIGHT = 1, 
  CENTER = 2, 
};
 
enum class AssignmentMethod : unsigned int {
  STANDARD = 0, 
  PRIVILEGED = 1, 
  AUTO = 2, 
};
 
enum class ActionSource : unsigned int {
  MANUAL, 
  AUTOMATIC, 
  RECOMMENDED, 
  DEFAULT 
};
 
enum class DataState : unsigned int {
  REST, 
  MOTION, 
  USE, 
};
 
inline const std::string& GetFileContentFormat() {
  static const std::string fileContentFormat = "file";
  return fileContentFormat;
}
 
inline const std::string& GetEmailContentFormat() {
  static const std::string emailContentFormat = "email";
  return emailContentFormat;
}
 
enum LabelFilterType : unsigned int {
  None                                    = 0,       
  CustomProtection                        = 1 << 0,  
  TemplateProtection                      = 1 << 1,  
  DoNotForwardProtection                  = 1 << 2,  
  AdhocProtection                         = 1 << 3,  
  HyokProtection                          = 1 << 4,  
  PredefinedTemplateProtection            = 1 << 5,  
  DoubleKeyProtection                     = 1 << 6,  
  DoubleKeyUserDefinedProtection          = 1 << 7,  
  EncryptOnlyProtection                   = 1 << 8,  
  SensitiveInformationClassifier          = 1 << 9,  
  MachineLearningClassifier               = 1 << 10, 
  ExtendedSensitiveInformationClassifier  = 1 << 11, 
};
 
typedef LabelFilterType FunctionalityFilterType;
 
inline FunctionalityFilterType operator|(FunctionalityFilterType firstFilter, FunctionalityFilterType secondFilter) {
  return static_cast<FunctionalityFilterType>(static_cast<int>(firstFilter) | static_cast<int>(secondFilter));
}
 
inline FunctionalityFilterType operator&(FunctionalityFilterType firstFilter, FunctionalityFilterType secondFilter) {
  return static_cast<FunctionalityFilterType>(static_cast<int>(firstFilter) & static_cast<int>(secondFilter));
}
 
inline FunctionalityFilterType operator~(FunctionalityFilterType filter) {
  return static_cast<FunctionalityFilterType>(~(static_cast<int>(filter)));
}
 
enum class FeatureId : unsigned int {
  EncryptOnly, 
};
 
enum class VariableTextMarkingType : unsigned int {
  Default = 0, 
  PassThrough = 1, 
  None = 2, 
};
 
enum class ContainerDecryptionOption : unsigned int {
  Default = 0, 
  Msg = 1, 
  Top = 2, 
  All = 3, 
};
 
inline std::string ContainerDecryptionOptionString(ContainerDecryptionOption option) {
  static std::string kMethodArray[] = { "default", "msg", "top", "all" };
  return kMethodArray[static_cast<int>(option)];
}
 
enum class Classifier : unsigned int {
  SensitiveInformation          = 0,  // Classifier based on specific content (credit cards); Uses Microsoft Classification Engine
  MachineLearning               = 1,  // Classifier based on Machine Learning recognition (offensive language)
  ExtendedSensitiveInformation  = 2,  // Classifier based on specific content (credit cards); Does not use Microsoft Classification Engine
};
 
enum class Workload : unsigned int {
  Office                = 0,  // Office type workloads, which include File and Email content types.
  Purview               = 1,  // Purview type workloads, which includes File, Email and SchematizedData content types.
};
 
struct UniqueIdsAndContentFormats
{
  std::unordered_map<std::string, std::string> uniqueIds;
  std::vector<std::string> contentFormats;
};
typedef std::map<mip::Classifier, UniqueIdsAndContentFormats> ClassifierUniqueIdsAndContentFormats;
 
inline std::string GetAssignmentMethodString(AssignmentMethod method) {
  static std::string kMethodArray[] = { "Standard", "Privileged", "Auto" };
  return kMethodArray[static_cast<int>(method)];
}
 
inline static std::string GetActionSourceString(ActionSource actionSource) {
  static std::string kMethodArray[] = { "Manual", "Automatic", "Recommended", "Default" };
  return kMethodArray[static_cast<int>(actionSource)];
}
 
inline static std::string GetDataStateString(DataState state) {
  static std::string kMethodArray[] = { "Rest", "Motion", "Use" };
  return kMethodArray[static_cast<int>(state)];
}
 
// Extension to use when creating sqlite table on disk
inline const std::string& GetSqliteExtension() {
  static const std::string sqliteExtension = ".sqlite3";
  return sqliteExtension;
}
 
// Path to use when creating a table in memory
inline const std::string& GetMemoryDatabasePath() {
  static const std::string memoryPath = ":memory:";
  return memoryPath;
}
 
enum class StorageTableVersion : unsigned int {
  One       = 1, // Version 1 of the storage table
  Two       = 2, // Version 2 of the storage table. Adds delete range support.
};
 
class Identity {
public:
  Identity() { }
  Identity(const Identity& other)
    : mEmail(other.mEmail),
      mName(other.mName) { }
 
  explicit Identity(const std::string& email) : mEmail(email) { }
 
  explicit Identity(const std::string& email, const std::string& name) : mEmail(email), mName(name) { }
 
  const std::string& GetEmail() const { return mEmail; }
 
  const std::string& GetName() const { return mName; }
 
private:
  std::string mEmail;
  std::string mName;
};
 
class AuthDelegate {
public:
  class OAuth2Challenge {
  public:
    OAuth2Challenge(
        const std::string& authority,
        const std::string& resource,
        const std::string& scope = std::string(),
        const std::string& claims = std::string())
        : mAuthority(authority),
          mResource(resource),
          mScope(scope),
          mClaims(claims) {
    }
    const std::string& GetAuthority() const { return mAuthority; }
    const std::string& GetResource() const { return mResource; }
    const std::string& GetScope() const { return mScope; }
    const std::string& GetClaims() const { return mClaims; }
  private:
    std::string mAuthority;
    std::string mResource;
    std::string mScope;
    std::string mClaims;
  };
 
  class OAuth2Token {
  public:
    OAuth2Token() {}
 
    OAuth2Token(const std::string& accessToken) : mAccessToken(accessToken) {}
 
    const std::string& GetAccessToken() const { return mAccessToken; }
 
    void SetAccessToken(const std::string& accessToken) { mAccessToken = accessToken; }
 
    const std::string& GetErrorMessage() const { return mErrorMessage; }
 
    void SetErrorMessage(const std::string& errorMessage) { mErrorMessage = errorMessage; }
 
  private:
    std::string mAccessToken;
    std::string mErrorMessage;
  };
 
  virtual bool AcquireOAuth2Token(
      const Identity& identity,
      const OAuth2Challenge& challenge,
      OAuth2Token& token) { UNUSED(identity); UNUSED(challenge); UNUSED(token); return false; }
 
  virtual bool AcquireOAuth2Token(
      const Identity& identity,
      const OAuth2Challenge& challenge,
      const std::shared_ptr<void>& context,
      OAuth2Token& token) {
    // Temporarily call into old 'AcquireOAuth2Token' method until it is fully deprecated (in case application
    // hasn't yet implemented this new method)
    UNUSED(context);
    return AcquireOAuth2Token(identity, challenge, token);
  }
 
  virtual ~AuthDelegate() { }
protected:
  AuthDelegate() { }
};
 
enum class Consent : unsigned int {
  AcceptAlways, 
  Accept,       
  Reject        
};
 
class ConsentDelegate {
public:
  virtual Consent GetUserConsent(const std::string& url) = 0;
 
  virtual ~ConsentDelegate() { }
protected:
  ConsentDelegate() { }
};
 
struct ApplicationInfo {
  std::string applicationId;     
  std::string applicationName;   
  std::string applicationVersion;
};
 
inline constexpr const char* GetCustomSettingPolicyDataName() {
  return "policy_data";
}
inline constexpr const char* GetCustomSettingExportPolicyFileName() {
  return "export_policy_file";
}
inline constexpr const char* GetCustomSettingSensitivityTypesDataName() {
  return "sensitivity_types_data";
}
inline constexpr const char* GetCustomSettingPolicyDataFile() {
  return "policy_file";
}
inline constexpr const char* GetCustomSettingSensitivityTypesDataFile() {
  return "sensitivity_types_file";
}
inline constexpr const char* GetCustomSettingLabelCustomPropertiesSyncEnabled() {
  return "label_custom_properties_sync_enabled";
}
inline constexpr const char* GetCustomSettingPolicyTtlDays() {
  return "PolicyTtlDays";
}
inline constexpr const char* GetCustomSettingSensitivityPolicyTtlDays() {
  return "SensitivityPolicyTtlDays";
}
inline constexpr const char* GetEnforceMsgPfileProtection() {
  return "EnforceMsgPfileProtection";
}
inline constexpr const char* GetCustomSettingEnableMsgFileType() {
  return "enable_msg_file_type";
}
inline constexpr const char* GetCustomSettingContainerDecryptionOption() {
  return "container_decryption_option";
}
inline constexpr const char* GetCustomSettingEnablePowerBIFileType() {
  return "enable_power_bi_file_type";
}
inline constexpr const char* GetCustomSettingEnableEmlFileType() {
  return "enable_eml_file_type";
}
inline constexpr const char* GetCustomSettingKeepPdfLinearization() {
  return "keep_pdf_linearization";
}
inline constexpr const char* GetCustomSettingEnableDeprecatedRemoveActions() {
  return "enable_deprecated_remove_actions";
}
inline constexpr const char* GetCustomSettingPrintDiscoveredInfoTypesToTrace() {
  return "LogMatchedContentToTrace";
}
inline constexpr const char* GetCustomSettingTaskTimeoutMs() {
  return "TaskTimeoutMs";
}
 
inline constexpr const char* GetCustomSettingLabelWithoutPolicy() {
  return "label_without_policy";
}
 
inline constexpr const char* GetCustomSettingMaxFileSizeForProtection() {
  return "max_file_size_for_protection";
}
 
inline constexpr const char* GetCustomSettingMaxNestedProtectedMsgs() {
  return "max_nested_protected_msgs";
}
 
inline constexpr const char* GetCustomSettingMaxPolicyXmlVersion() {
  return "max_policy_xml_version";
}
 
inline constexpr const char* GetCustomSettingDelegateApplicationInfo() {
  return "delegate_application_info";
}
 
inline constexpr const char* GetCustomSettingEnableCoAuthMetadata() {
  return "co_auth_metadata";
}
 
inline constexpr const char* GetCustomSettingLabelsForAllContentFormats() {
  return "labels_for_all_content_formats";
}
inline constexpr const char* GetCustomSettingDnsInfoTtlDays() {
  return "DnsInfoTtlDays";
}
 
class CaseInsensitiveComparator {
public:
  bool operator() (const std::string& lhs, const std::string& rhs) const {
    if (lhs.size() != rhs.size())
      return lhs.size() < rhs.size();
 
#ifdef _WIN32
    return _strnicmp(lhs.c_str(), rhs.c_str(), lhs.size()) < 0;
#else
    return strncasecmp(lhs.c_str(), rhs.c_str(), lhs.size()) < 0;
#endif // WIN32
  }
};
enum class CacheStorageType : unsigned int {
  InMemory = 0, 
  OnDisk = 1, 
  OnDiskEncrypted = 2 
};
 
enum class PFileExtensionBehavior {
  Default = 0,     
  PFileSuffix = 1, 
  PPrefix = 2,     
};
 
enum class Cloud {
  Unknown = 0,                     
  Custom = 1,                      
  Test = 2,                        
  Commercial = 3,                  
  Germany = 4,                     
  US_DoD = 5,                      
  US_GCC = 6,                      
  US_GCC_High = 7,                 
  US_Sec = 8,                      
  US_Nat = 9,                      
  China_01 = 10,                   
};
 
enum class DataBoundary {
  Default = 0,                  
  United_States = 1,            
  North_America = 1,            
  European_Union = 2,           
  Germany = 3,                  
  Europe_MiddleEast_Africa = 3, 
  Japan = 4,                    
  Asia = 4,                     
  Australia = 5,                
};
 
enum class ServiceType {
  Protection = 0,                  
  Policy = 1,                      
  Telemetry = 2,                   
};
 
class AsyncControl {
public:
  virtual bool Cancel() = 0;
  virtual ~AsyncControl() = default;
};
 
MIP_NAMESPACE_END
 
#endif  // API_MIP_COMMON_TYPES_H_