SET_TARGET_PROPERTIES(
${TARGET_KEY_MANAGER_CLIENT}
PROPERTIES
- COMPILE_FLAGS "-D_GNU_SOURCE -fPIC -fvisibility=default"
+ COMPILE_FLAGS "-D_GNU_SOURCE -fPIC -fvisibility=hidden"
SOVERSION ${KEY_MANAGER_CLIENT_VERSION_MAJOR}
VERSION ${KEY_MANAGER_CLIENT_VERSION}
)
SET_TARGET_PROPERTIES(
${TARGET_KEY_MANAGER_CONTROL_CLIENT}
PROPERTIES
- COMPILE_FLAGS "-D_GNU_SOURCE -fPIC -fvisibility=default"
+ COMPILE_FLAGS "-D_GNU_SOURCE -fPIC -fvisibility=hidden"
SOVERSION ${KEY_MANAGER_CONTROL_CLIENT_VERSION_MAJOR}
VERSION ${KEY_MANAGER_CONTROL_CLIENT_VERSION}
)
class Certificate;
typedef std::shared_ptr<Certificate> CertificateShPtr;
-class Certificate {
+class KEY_MANAGER_API Certificate {
public:
virtual bool empty() const = 0;
typedef std::shared_ptr<Control> ControlShPtr;
// used by login manager to unlock user data with global password
-class Control
+class KEY_MANAGER_API Control
{
public:
// decrypt user key with password
class Key;
typedef std::shared_ptr<Key> KeyShPtr;
-class Key {
+class KEY_MANAGER_API Key {
public:
virtual bool empty() const = 0;
virtual KeyType getType() const = 0;
// Asynchronous interface to Central Key Manager. This implementation uses
// internal thread for connection. Key Manager is not thread safe.
-class ManagerAsync
+class KEY_MANAGER_API ManagerAsync
{
public:
class Impl;
class Manager;
typedef std::shared_ptr<Manager> ManagerShPtr;
-class Manager {
+class KEY_MANAGER_API Manager {
public:
virtual ~Manager(){}
class PKCS12;
typedef std::shared_ptr<PKCS12> PKCS12ShPtr;
-class PKCS12 {
+class KEY_MANAGER_API PKCS12 {
public:
virtual KeyShPtr getKey() const = 0;
#include <ckm/ckm-raw-buffer.h>
#include <ckm/ckm-password.h>
+#define KEY_MANAGER_API __attribute__((visibility("default")))
+
namespace CKM {
// used to pass password and raw key data
* case, separator " " (space bar) is used to separate label and alias.
* @see key-manager_doc.h
*/
-extern char const * const ckmc_label_name_separator;
+KEY_MANAGER_CAPI extern char const * const ckmc_label_name_separator;
/**
* @brief Enumeration for key types of key manager.
SET_TARGET_PROPERTIES(
${TARGET_KEY_MANAGER_COMMON}
PROPERTIES
- COMPILE_FLAGS "-D_GNU_SOURCE -fPIC -fvisibility=default"
+ COMPILE_FLAGS "-D_GNU_SOURCE -fPIC -fvisibility=hidden"
SOVERSION ${KEY_MANAGER_COMMON_VERSION_MAJOR}
VERSION ${KEY_MANAGER_COMMON_VERSION}
)
#include <ckmc/ckmc-error.h>
#include <ckm/ckm-type.h>
+#include <ckmc/ckmc-type.h>
#include <ckmc-type-converter.h>
+KEY_MANAGER_CAPI
const char * ckmc_error_to_string(int error) {
return CKM::ErrorToString(to_ckm_error(error));
}
return CKMC_ERROR_NONE;
}
+KEY_MANAGER_CAPI
int ckmc_load_from_pkcs12_file2(const char *file_path, const char *passphrase, ckmc_pkcs12_s **pkcs12_bundle)
{
int ec;
#include <message-buffer.h>
#include <protocols.h>
-#define KEY_MANAGER_API __attribute__((visibility("default")))
-
extern "C" {
struct msghdr;
}
#include <ckm/ckm-type.h>
+#include <symbol-visibility.h>
+
struct bio_st;
typedef bio_st BIO;
namespace CKM {
-class Base64Encoder : public CKM::Noncopyable
+class COMMON_API Base64Encoder : public CKM::Noncopyable
{
public:
class Exception
bool m_finalized;
};
-class Base64Decoder : public CKM::Noncopyable
+class COMMON_API Base64Decoder : public CKM::Noncopyable
{
public:
class Exception
#include <set>
#include <string>
+#include <symbol-visibility.h>
#pragma once
namespace CKM {
-class CertificateConfig
+class COMMON_API CertificateConfig
{
public:
static void addSystemCertificateDir(const std::string& dir) { m_sysCertDirs.insert(dir); }
#include <ckm/ckm-certificate.h>
#include <key-impl.h>
+#include <symbol-visibility.h>
namespace CKM {
-class CertificateImpl : public Certificate {
+class COMMON_API CertificateImpl : public Certificate {
public:
CertificateImpl() : m_x509(NULL) {}
explicit CertificateImpl(X509* x509, bool duplicate = true);
* @brief Certificate Stack Implmentation.
*/
#include <certificate-impl.h>
+#include <symbol-visibility.h>
extern "C" {
struct x509_store_st;
namespace CKM {
-class CertificateStore {
+class COMMON_API CertificateStore {
public:
CertificateStore();
CertificateStore(const CertificateStore &) = delete;
#include <dpl/exception.h>
#include <dpl/raw-buffer.h>
+#include <symbol-visibility.h>
+
// TODO move it to static const int
#define AES_GCM_TAG_SIZE 16
namespace CKM {
-void initCryptoLib();
+COMMON_API void initCryptoLib();
namespace Crypto {
namespace Cipher {
template<class T>
-struct Base {
+struct COMMON_API Base {
Base()
: m_ctx(EVP_CIPHER_CTX_new())
{
};
template<class T>
-class EvpCipherWrapper : public Base<T> {
+class COMMON_API EvpCipherWrapper : public Base<T> {
public:
using Base<T>::m_ctx;
};
#define DEFINE_CIPHER(__classname, __type, __evpcipher, __encryption) \
-class __classname : public EvpCipherWrapper<__type> { \
+class COMMON_API __classname : public EvpCipherWrapper<__type> { \
public: \
__classname(const __type &key, const __type &iv) \
: EvpCipherWrapper(__evpcipher, key, iv, __encryption) \
#include <dpl/exception.h>
#include <poll.h>
#include <noncopyable.h>
+#include <symbol-visibility.h>
namespace CKM {
/**
* @brief Wrapper for poll()
*/
-class DescriptorSet : public IDescriptorSet
+class COMMON_API DescriptorSet : public IDescriptorSet
{
public:
DescriptorSet();
#include <dpl/noncopyable.h>
#include <dpl/exception.h>
#include <ckm/ckm-type.h>
+#include <symbol-visibility.h>
/*
* Taken from openssl/ossl_typ.h
namespace CKM {
-class Digest : public CKM::Noncopyable
+class COMMON_API Digest : public CKM::Noncopyable
{
public:
class Exception
#pragma once
#include <noncopyable.h>
+#include <symbol-visibility.h>
namespace CKM {
-class FileLock
+class COMMON_API FileLock
{
public:
explicit FileLock(const char* const file);
#include <ckm/ckm-type.h>
#include <ckm/ckm-key.h>
#include <openssl/evp.h>
+#include <symbol-visibility.h>
namespace CKM {
-class KeyImpl : public Key {
+class COMMON_API KeyImpl : public Key {
public:
typedef std::shared_ptr<EVP_PKEY> EvpShPtr;
#include <dpl/binary_queue.h>
#include <dpl/exception.h>
#include <dpl/serialization.h>
-
#include <dpl/raw-buffer.h>
+#include <symbol-visibility.h>
namespace CKM {
-class MessageBuffer : public CKM::IStream {
+class COMMON_API MessageBuffer : public CKM::IStream {
public:
class Exception
{
#include <memory>
#include <ckm/ckm-pkcs12.h>
+#include <symbol-visibility.h>
namespace CKM {
-class PKCS12Impl : public PKCS12 {
+class COMMON_API PKCS12Impl : public PKCS12 {
public:
PKCS12Impl() {}
explicit PKCS12Impl(const PKCS12 &);
#include <dpl/exception.h>
#include <dpl/serialization.h>
+#include <symbol-visibility.h>
namespace CKM {
-extern char const * const SERVICE_SOCKET_ECHO;
-extern char const * const SERVICE_SOCKET_CKM_CONTROL;
-extern char const * const SERVICE_SOCKET_CKM_STORAGE;
-extern char const * const SERVICE_SOCKET_OCSP;
+COMMON_API extern char const * const SERVICE_SOCKET_ECHO;
+COMMON_API extern char const * const SERVICE_SOCKET_CKM_CONTROL;
+COMMON_API extern char const * const SERVICE_SOCKET_CKM_STORAGE;
+COMMON_API extern char const * const SERVICE_SOCKET_OCSP;
enum class ControlCommand : int {
UNLOCK_USER_KEY,
// for backward compatibility append new at the end
};
-class DataType {
+class COMMON_API DataType {
public:
class Exception {
public:
};
// (client side) Alias = (service side) Label::Name
-extern char const * const LABEL_NAME_SEPARATOR;
+COMMON_API extern char const * const LABEL_NAME_SEPARATOR;
typedef std::string Name;
typedef std::vector<std::pair<Label, Name> > LabelNameVector;
class IStream;
-struct PolicySerializable : public Policy, ISerializable {
+struct COMMON_API PolicySerializable : public Policy, ISerializable {
PolicySerializable() {};
explicit PolicySerializable(const Policy &policy) : Policy(policy) {}
explicit PolicySerializable(IStream &stream) {
}
};
-struct PKCS12Serializable : public PKCS12Impl, ISerializable {
+struct COMMON_API PKCS12Serializable : public PKCS12Impl, ISerializable {
PKCS12Serializable();
explicit PKCS12Serializable(const PKCS12 &);
explicit PKCS12Serializable(IStream &);
#ifndef _SMACK_CHECK_H_
#define _SMACK_CHECK_H_
+#include <symbol-visibility.h>
+
namespace CKM {
/*
* Returns 1 if SMACK is present, 0 otherwise. If SMACK_ENABLED is not defined
* It returns 0.
*/
+COMMON_API
int smack_check(void);
} // namespace CKM
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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
+ *
+ *
+ * @file symbol-visibility.h
+ * @author Kyungwook Tak (k.tak@samsung.com)
+ * @version 1.0
+ * @brief define symbol visiblity for common library.
+ */
+
+#define COMMON_API __attribute__((visibility("default")))
#include <dpl/noreturn.h>
#include <string>
+#include <symbol-visibility.h>
namespace CKM {
// Assertion handler procedure
// Do not call directly
// Always use Assert macro
-CENT_KEY_NORETURN void AssertProc(const char *condition,
+COMMON_API CENT_KEY_NORETURN void AssertProc(const char *condition,
const char *file,
int line,
const char *function);
#include <dpl/noncopyable.h>
#include <memory>
#include <list>
+#include <symbol-visibility.h>
namespace CKM {
/**
*
* @todo Add optimized implementation for FlattenConsume
*/
-class BinaryQueue
+class COMMON_API BinaryQueue
// : public AbstractInputOutput
{
public:
#ifndef CKM_COLORS_H
#define CKM_COLORS_H
+#include <symbol-visibility.h>
+
namespace CKM {
namespace Colors {
namespace Text {
-extern const char* BOLD_GREEN_BEGIN;
-extern const char* BOLD_GREEN_END;
-extern const char* PURPLE_BEGIN;
-extern const char* PURPLE_END;
-extern const char* RED_BEGIN;
-extern const char* RED_END;
-extern const char* GREEN_BEGIN;
-extern const char* GREEN_END;
-extern const char* CYAN_BEGIN;
-extern const char* CYAN_END;
-extern const char* BOLD_RED_BEGIN;
-extern const char* BOLD_RED_END;
-extern const char* BOLD_YELLOW_BEGIN;
-extern const char* BOLD_YELLOW_END;
-extern const char* BOLD_GOLD_BEGIN;
-extern const char* BOLD_GOLD_END;
-extern const char* BOLD_WHITE_BEGIN;
-extern const char* BOLD_WHITE_END;
-extern const char* COLOR_END;
+COMMON_API extern const char* BOLD_GREEN_BEGIN;
+COMMON_API extern const char* BOLD_GREEN_END;
+COMMON_API extern const char* PURPLE_BEGIN;
+COMMON_API extern const char* PURPLE_END;
+COMMON_API extern const char* RED_BEGIN;
+COMMON_API extern const char* RED_END;
+COMMON_API extern const char* GREEN_BEGIN;
+COMMON_API extern const char* GREEN_END;
+COMMON_API extern const char* CYAN_BEGIN;
+COMMON_API extern const char* CYAN_END;
+COMMON_API extern const char* BOLD_RED_BEGIN;
+COMMON_API extern const char* BOLD_RED_END;
+COMMON_API extern const char* BOLD_YELLOW_BEGIN;
+COMMON_API extern const char* BOLD_YELLOW_END;
+COMMON_API extern const char* BOLD_GOLD_BEGIN;
+COMMON_API extern const char* BOLD_GOLD_END;
+COMMON_API extern const char* BOLD_WHITE_BEGIN;
+COMMON_API extern const char* BOLD_WHITE_END;
+COMMON_API extern const char* COLOR_END;
} //namespace Text
} //namespace Colors
} //namespace CKM
#include <dpl/exception.h>
#include <string>
#include <cerrno>
+#include <symbol-visibility.h>
namespace CKM {
DECLARE_EXCEPTION_TYPE(CKM::Exception, InvalidErrnoValue)
-std::string GetErrnoString(int error = errno);
+COMMON_API std::string GetErrnoString(int error = errno);
} // namespace CKM
#endif // CKM_ERRNO_STRING_H
#include <exception>
#include <cstdlib>
#include <sstream>
+#include <symbol-visibility.h>
namespace CKM {
-void LogUnhandledException(const std::string &str);
-void LogUnhandledException(const std::string &str,
+COMMON_API void LogUnhandledException(const std::string &str);
+COMMON_API void LogUnhandledException(const std::string &str,
const char *filename,
int line,
const char *function);
}
namespace CKM {
-class Exception
+class COMMON_API Exception
{
private:
static unsigned int m_exceptionCount;
#ifndef CENT_KEY_FSTREAM_ACCESSORS_H
#define CENT_KEY_FSTREAM_ACCESSORS_H
+#include <symbol-visibility.h>
+
namespace CKM {
/*
*/
template<typename T>
-class FstreamAccessors : T::__filebuf_type {
+class COMMON_API FstreamAccessors : T::__filebuf_type {
typedef FstreamAccessors<T> MyType;
public:
static int GetFd(T &strm) {
#ifndef CENT_KEY_NONCOPYABLE_H
#define CENT_KEY_NONCOPYABLE_H
+#include <symbol-visibility.h>
+
namespace CKM {
-class Noncopyable
+class COMMON_API Noncopyable
{
private:
Noncopyable(const Noncopyable &);
#ifndef CENT_KEY_SINGLETON_H
#define CENT_KEY_SINGLETON_H
+#include <symbol-visibility.h>
+
namespace CKM {
template<typename Class>
-class Singleton :
+class COMMON_API Singleton :
private Class
{
//
#include <stdint.h>
#include <dpl/raw-buffer.h>
+#include <symbol-visibility.h>
+
namespace CKM {
namespace DB {
/**
* SQL connection class
*/
-class SqlConnection
+class COMMON_API SqlConnection
{
public:
/**
#include <sstream>
#include <list>
+#include <symbol-visibility.h>
+
namespace CKM {
namespace Log {
/**
* CKM log system
*/
-class LogSystem : private Noncopyable
+class COMMON_API LogSystem : private Noncopyable
{
public:
LogSystem();
*/
rc = sqlcipher3BtreeBeginTrans(pDb->pBt, 1); /* begin write transaction */
sqlcipher3PagerPagecount(pPager, &page_count);
- for(pgno = 1; rc == SQLCIPHER_OK && pgno <= page_count; pgno++) { /* pgno's start at 1 see pager.c:pagerAcquire */
+ for(pgno = 1; rc == SQLCIPHER_OK && (int)pgno <= page_count; pgno++) { /* pgno's start at 1 see pager.c:pagerAcquire */
if(!sqlcipher3pager_is_mj_pgno(pPager, pgno)) { /* skip this page (see pager.c:pagerAcquire for reasoning) */
rc = sqlcipher3PagerGet(pPager, pgno, &page);
if(rc == SQLCIPHER_OK) { /* write page see pager_incr_changecounter for example */
if( nSrcReserve!=nDestReserve ){
u32 newPgsz = nSrcPgsz;
rc = sqlcipher3PagerSetPagesize(pDestPager, &newPgsz, nSrcReserve);
- if( rc==SQLCIPHER_OK && newPgsz!=nSrcPgsz ) rc = SQLCIPHER_READONLY;
+ if( rc==SQLCIPHER_OK && (int)newPgsz!=nSrcPgsz ) rc = SQLCIPHER_READONLY;
}
#endif
if( rc==SQLCIPHER_OK ){
extern int sqlcipher3CodecAttach(sqlcipher3*, int, const void*, int);
extern void sqlcipher3CodecGetKey(sqlcipher3*, int, void**, int*);
- int nKey;
- char *zKey;
+ int nKey = 0;
+ char *zKey = NULL;
int t = sqlcipher3_value_type(argv[2]);
switch( t ){
case SQLCIPHER_INTEGER:
#ifdef SQLCIPHER_HAS_CODEC
if( db->nextPagesize ){
extern void sqlcipher3CodecGetKey(sqlcipher3*, int, void**, int*);
- int nKey;
- char *zKey;
+ int nKey = 0;
+ char *zKey = NULL;
sqlcipher3CodecGetKey(db, 0, (void**)&zKey, &nKey);
if( nKey ) db->nextPagesize = 0;
}