diff --git a/src/cats/CMakeLists.txt b/src/cats/CMakeLists.txt
index 8b603d1a6ba..32ee94c2e8c 100644
--- a/src/cats/CMakeLists.txt
+++ b/src/cats/CMakeLists.txt
@@ -27,11 +27,9 @@ set(LIBBAREOSSQL_SRCS
     bvfs.cc cats.cc sql.cc sql_create.cc sql_delete.cc sql_find.cc
     sql_get.cc sql_list.cc sql_pooling.cc sql_query.cc sql_update.cc
     )
-
-
-set(LIBBAREOSCATS_DYN_SRCS cats_backends.cc)
-
-
+ set(LIBBAREOSCATS_SRCS
+    cats_backends.cc
+    )
 
 set(SQLITE_SRCS sqlite.cc)
 
@@ -45,6 +43,7 @@ add_library(bareossql SHARED ${LIBBAREOSSQL_SRCS})
 set_target_properties(bareossql PROPERTIES VERSION "${VERSION}"
                                           SOVERSION "${SOVERSION}"
                                           )
+target_link_libraries (bareossql bareoscats bareos)
 
 
 # TODO: install default db backend
@@ -55,23 +54,16 @@ set_target_properties(bareossql PROPERTIES VERSION "${VERSION}"
 list(LENGTH db_backends nr_db_backends)
 
 
-#IF(${nr_db_backends} EQUAL 1)
-#   ADD_CUSTOM_COMMAND(
-#         OUTPUT ${bindir}/libbareoscats${CMAKE_SHARED_LIBRARY_SUFFIX} ALL
-#         COMMENT "Only one db backend (${default_db_backend}) available, creating symlink"
-#         COMMAND ${CMAKE_COMMAND} -E create_symlink ${libdir}/libbareoscats${CMAKE_SHARED_LIBRARY_SUFFIX}
-#                                                    ${backenddir}/libbareoscats-${default_db_backend}${CMAKE_SHARED_LIBRARY_SUFFIX})
-#ELSE()
-   add_library(bareoscats SHARED ${LIBBAREOSCATS_SRCS} ${LIBBAREOSCATS_DYN_SRCS})
-   target_link_libraries (bareoscats bareossql bareos)
-   set_target_properties(bareoscats PROPERTIES
-      VERSION ${VERSION}
-      SOVERSION "${SOVERSION}"
-      )
-   INSTALL(TARGETS bareoscats
-                DESTINATION ${libdir})
 
-#ENDIF()
+add_library(bareoscats SHARED ${LIBBAREOSCATS_SRCS})
+target_link_libraries (bareoscats bareos)
+set_target_properties(bareoscats PROPERTIES
+   VERSION ${VERSION}
+   SOVERSION "${SOVERSION}"
+   )
+INSTALL(TARGETS bareoscats
+   DESTINATION ${libdir})
+
 
 IF (HAVE_SQLITE3)
 add_library(bareoscats-sqlite3 MODULE ${SQLITE_SRCS})
diff --git a/src/cats/protos.h b/src/cats/protos.h
index 2f347bcd096..17f857acd25 100644
--- a/src/cats/protos.h
+++ b/src/cats/protos.h
@@ -30,14 +30,15 @@
 
 #include "cats.h"
 
+
 /* Database prototypes */
 
 /* cats_backends.c */
 #if defined(HAVE_DYNAMIC_CATS_BACKENDS)
-void db_set_backend_dirs(alist *new_backend_dirs);
+DLL_IMP_EXP void db_set_backend_dirs(alist *new_backend_dirs);
 #endif
-void db_flush_backends(void);
-B_DB *db_init_database(JCR *jcr,
+DLL_IMP_EXP void db_flush_backends(void);
+DLL_IMP_EXP B_DB *db_init_database(JCR *jcr,
                        const char *db_driver,
                        const char *db_name,
                        const char *db_user,
@@ -52,14 +53,14 @@ B_DB *db_init_database(JCR *jcr,
                        bool need_private = false);
 
 /* sql.c */
-int db_int64_handler(void *ctx, int num_fields, char **row);
-int db_strtime_handler(void *ctx, int num_fields, char **row);
-int db_list_handler(void *ctx, int num_fields, char **row);
-void db_debug_print(JCR *jcr, FILE *fp);
-int db_int_handler(void *ctx, int num_fields, char **row);
+DLL_IMP_EXP int db_int64_handler(void *ctx, int num_fields, char **row);
+DLL_IMP_EXP int db_strtime_handler(void *ctx, int num_fields, char **row);
+DLL_IMP_EXP int db_list_handler(void *ctx, int num_fields, char **row);
+DLL_IMP_EXP void db_debug_print(JCR *jcr, FILE *fp);
+DLL_IMP_EXP int db_int_handler(void *ctx, int num_fields, char **row);
 
 /* sql_pooling.c */
-bool db_sql_pool_initialize(const char *db_drivername,
+DLL_IMP_EXP bool db_sql_pool_initialize(const char *db_drivername,
                             const char *db_name,
                             const char *db_user,
                             const char *db_password,
@@ -74,9 +75,9 @@ bool db_sql_pool_initialize(const char *db_drivername,
                             int increment_connections,
                             int idle_timeout,
                             int validate_timeout);
-void db_sql_pool_destroy(void);
-void db_sql_pool_flush(void);
-B_DB *db_sql_get_non_pooled_connection(JCR *jcr,
+DLL_IMP_EXP void db_sql_pool_destroy(void);
+DLL_IMP_EXP void db_sql_pool_flush(void);
+DLL_IMP_EXP B_DB *db_sql_get_non_pooled_connection(JCR *jcr,
                                        const char *db_drivername,
                                        const char *db_name,
                                        const char *db_user,
@@ -89,7 +90,7 @@ B_DB *db_sql_get_non_pooled_connection(JCR *jcr,
                                        bool try_reconnect,
                                        bool exit_on_fatal,
                                        bool need_private = false);
-B_DB *db_sql_get_pooled_connection(JCR *jcr,
+DLL_IMP_EXP B_DB *db_sql_get_pooled_connection(JCR *jcr,
                                    const char *db_drivername,
                                    const char *db_name,
                                    const char *db_user,
@@ -102,7 +103,7 @@ B_DB *db_sql_get_pooled_connection(JCR *jcr,
                                    bool try_reconnect,
                                    bool exit_on_fatal,
                                    bool need_private = false);
-void db_sql_close_pooled_connection(JCR *jcr, B_DB *mdb, bool abort = false);
+DLL_IMP_EXP void db_sql_close_pooled_connection(JCR *jcr, B_DB *mdb, bool abort = false);
 
 /* sql_query.c */
 #endif /* __SQL_PROTOS_H */
diff --git a/src/findlib/CMakeLists.txt b/src/findlib/CMakeLists.txt
index 252cd10279b..c86e9771fdd 100644
--- a/src/findlib/CMakeLists.txt
+++ b/src/findlib/CMakeLists.txt
@@ -39,6 +39,7 @@ INSTALL(TARGETS bareosfind DESTINATION ${libdir})
 set_target_properties(bareosfind PROPERTIES VERSION "${VERSION}"
                                           SOVERSION "${SOVERSION}"
                                           DEFINE_SYMBOL "BUILDING_DLL"
+                                          LINK_FLAGS -Wl,--output-def,bareosfind.def -L bareos.def
                                           )
 
 add_subdirectory(unittests)
diff --git a/src/findlib/find.h b/src/findlib/find.h
index 16d5f18fc72..56261d98b48 100644
--- a/src/findlib/find.h
+++ b/src/findlib/find.h
@@ -66,7 +66,7 @@ struct utimbuf {
 #endif
 #ifdef USE_READDIR_R
 #ifndef HAVE_READDIR_R
-int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result);
+DLL_IMP_EXP int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result);
 #endif
 #endif
 /**
diff --git a/src/findlib/protos.h b/src/findlib/protos.h
index fad462e663c..3438baf5aa5 100644
--- a/src/findlib/protos.h
+++ b/src/findlib/protos.h
@@ -94,11 +94,11 @@ bool makepath(ATTR *attr, const char *path, mode_t mode,
               bool keep_dir_modes);
 
 /* fstype.c */
-bool fstype(const char *fname, char *fs, int fslen);
-bool fstype_equals(const char *fname, const char *fstypename);
+DLL_IMP_EXP bool fstype(const char *fname, char *fs, int fslen);
+DLL_IMP_EXP bool fstype_equals(const char *fname, const char *fstypename);
 
 /* drivetype.c */
-bool drivetype(const char *fname, char *fs, int fslen);
+DLL_IMP_EXP bool drivetype(const char *fname, char *fs, int fslen);
 
 /* shadowing.c */
 void check_include_list_shadowing(JCR *jcr, findFILESET *fileset);
diff --git a/src/include/baconfig.h b/src/include/baconfig.h
index 378f666bce7..ec3e42ed61b 100644
--- a/src/include/baconfig.h
+++ b/src/include/baconfig.h
@@ -559,18 +559,18 @@ m_msg(__FILE__, __LINE__, buf, msg, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11
 
 class POOL_MEM;
 /* Edit message into Pool Memory buffer -- no __FILE__ and __LINE__ */
-int Mmsg(POOLMEM *&msgbuf, const char *fmt, ...);
-int Mmsg(POOL_MEM &msgbuf, const char *fmt, ...);
-int Mmsg(POOL_MEM *&msgbuf, const char *fmt, ...);
+DLL_IMP_EXP int Mmsg(POOLMEM *&msgbuf, const char *fmt, ...);
+DLL_IMP_EXP int Mmsg(POOL_MEM &msgbuf, const char *fmt, ...);
+DLL_IMP_EXP int Mmsg(POOL_MEM *&msgbuf, const char *fmt, ...);
 
 class JCR;
-void d_msg(const char *file, int line, int level, const char *fmt, ...);
-void p_msg(const char *file, int line, int level, const char *fmt, ...);
-void p_msg_fb(const char *file, int line, int level, const char *fmt,...);
-void e_msg(const char *file, int line, int type, int level, const char *fmt, ...);
-void j_msg(const char *file, int line, JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
-void q_msg(const char *file, int line, JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
-int m_msg(const char *file, int line, POOLMEM *&pool_buf, const char *fmt, ...);
+DLL_IMP_EXP void d_msg(const char *file, int line, int level, const char *fmt, ...);
+DLL_IMP_EXP void p_msg(const char *file, int line, int level, const char *fmt, ...);
+DLL_IMP_EXP void p_msg_fb(const char *file, int line, int level, const char *fmt,...);
+DLL_IMP_EXP void e_msg(const char *file, int line, int type, int level, const char *fmt, ...);
+DLL_IMP_EXP void j_msg(const char *file, int line, JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
+DLL_IMP_EXP void q_msg(const char *file, int line, JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
+DLL_IMP_EXP int m_msg(const char *file, int line, POOLMEM *&pool_buf, const char *fmt, ...);
 
 /** Use our strdup with smartalloc */
 #undef strdup
diff --git a/src/include/jcr.h b/src/include/jcr.h
index 4668d46fc78..36491299642 100644
--- a/src/include/jcr.h
+++ b/src/include/jcr.h
@@ -638,16 +638,16 @@ extern DLL_IMP_EXP dlist *last_jobs;
 /*
  * The following routines are found in lib/jcr.c
  */
-extern int get_next_jobid_from_list(char **p, uint32_t *JobId);
-extern bool init_jcr_subsystem(int timeout);
-extern JCR *new_jcr(int size, JCR_free_HANDLER *daemon_free_jcr);
-extern JCR *get_jcr_by_id(uint32_t JobId);
-extern JCR *get_jcr_by_session(uint32_t SessionId, uint32_t SessionTime);
-extern JCR *get_jcr_by_partial_name(char *Job);
-extern JCR *get_jcr_by_full_name(char *Job);
-extern JCR *get_next_jcr(JCR *jcr);
-extern void set_jcr_job_status(JCR *jcr, int JobStatus);
-extern int DLL_IMP_EXP num_jobs_run;
+DLL_IMP_EXP extern int get_next_jobid_from_list(char **p, uint32_t *JobId);
+DLL_IMP_EXP extern bool init_jcr_subsystem(int timeout);
+DLL_IMP_EXP extern JCR *new_jcr(int size, JCR_free_HANDLER *daemon_free_jcr);
+DLL_IMP_EXP extern JCR *get_jcr_by_id(uint32_t JobId);
+DLL_IMP_EXP extern JCR *get_jcr_by_session(uint32_t SessionId, uint32_t SessionTime);
+DLL_IMP_EXP extern JCR *get_jcr_by_partial_name(char *Job);
+DLL_IMP_EXP extern JCR *get_jcr_by_full_name(char *Job);
+DLL_IMP_EXP extern JCR *get_next_jcr(JCR *jcr);
+DLL_IMP_EXP extern void set_jcr_job_status(JCR *jcr, int JobStatus);
+DLL_IMP_EXP extern int DLL_IMP_EXP num_jobs_run;
 
 #ifdef DEBUG
 extern void b_free_jcr(const char *file, int line, JCR *jcr);
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index d28bc278235..724c5453f5b 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -79,7 +79,7 @@ set (BAREOSCFG_SRCS ini.cc lex.cc parse_bsr.cc )
 
 
 add_library(bareoscfg SHARED ${BAREOSCFG_SRCS})
-target_link_libraries(bareoscfg ${JANSSON_LIBRARIES})
+target_link_libraries(bareoscfg bareos ${JANSSON_LIBRARIES})
 
 set (BAREOS_STATIC_SRCS parse_conf.cc res.cc)
 add_library(bareosstatic STATIC ${BAREOS_STATIC_SRCS})
@@ -91,14 +91,14 @@ INSTALL(TARGETS bareoscfg DESTINATION ${libdir})
 set_target_properties(bareoscfg PROPERTIES VERSION "${VERSION}"
                                           SOVERSION "${SOVERSION}"
                                           DEFINE_SYMBOL "BUILDING_DLL"
+                                          LINK_FLAGS -Wl,--output-def,bareoscfg.def
                                           )
-                                       #LINK_FLAGS -Wl,--out-implib,bareoscfg.a
 
 set_target_properties(bareos PROPERTIES VERSION "${VERSION}"
                                           SOVERSION "${SOVERSION}"
                                           DEFINE_SYMBOL "BUILDING_DLL"
+                                          LINK_FLAGS -Wl,--output-def,bareos.def
                                           )
-                                       #LINK_FLAGS -Wl,--out-implib,bareos.a
 
 INSTALL(FILES ${INCLUDE_FILES} DESTINATION ${includedir})
 
diff --git a/src/lib/alist.h b/src/lib/alist.h
index d854309bd1e..50b9ea2e915 100644
--- a/src/lib/alist.h
+++ b/src/lib/alist.h
@@ -83,7 +83,7 @@ enum {
  * Array list -- much like a simplified STL vector
  *               array of pointers to inserted items
  */
-class alist : public SMARTALLOC {
+class DLL_IMP_EXP alist : public SMARTALLOC {
    void **items;
    int num_items;
    int max_items;
diff --git a/src/lib/berrno.h b/src/lib/berrno.h
index 2c47c50b1f2..9cbd88f7f18 100644
--- a/src/lib/berrno.h
+++ b/src/lib/berrno.h
@@ -51,7 +51,7 @@
  * If bit 29 in m_berrno is not set, then it is a Unix errno.
  *
  */
-class berrno : public SMARTALLOC {
+class DLL_IMP_EXP berrno : public SMARTALLOC {
    POOLMEM *m_buf;
    int m_berrno;
    void format_win32_message();
diff --git a/src/lib/bregex.h b/src/lib/bregex.h
index d43052c3479..dcfe43a571d 100644
--- a/src/lib/bregex.h
+++ b/src/lib/bregex.h
@@ -186,12 +186,12 @@ void re_compile_fastmap(regex_t *compiled);
  * to an array of 256 characters. */
 
 
-int regcomp(regex_t *preg, const char *regex, int cflags);
-int regexec(regex_t *preg, const char *string, size_t nmatch,
+DLL_IMP_EXP int regcomp(regex_t *preg, const char *regex, int cflags);
+DLL_IMP_EXP int regexec(regex_t *preg, const char *string, size_t nmatch,
             regmatch_t pmatch[], int eflags);
-size_t regerror(int errcode, regex_t *preg, char *errbuf,
+DLL_IMP_EXP size_t regerror(int errcode, regex_t *preg, char *errbuf,
                 size_t errbuf_size);
-void regfree(regex_t *preg);
+DLL_IMP_EXP void regfree(regex_t *preg);
 
 #endif /* REGEXPR_H */
 
diff --git a/src/lib/btime.h b/src/lib/btime.h
index 3b70e54c6dd..7584d7d3d4f 100644
--- a/src/lib/btime.h
+++ b/src/lib/btime.h
@@ -23,21 +23,21 @@
 #define __btime_INCLUDED
 
 /* New btime definition -- use this */
-btime_t get_current_btime(void);
-time_t btime_to_unix(btime_t bt);   /* bareos time to epoch time */
-utime_t btime_to_utime(btime_t bt); /* bareos time to utime_t */
-
-int tm_wom(int mday, int wday);
-int tm_woy(time_t stime);
-
-void blocaltime(const time_t *time, struct tm *tm);
-char *bstrutime(char *dt, int maxlen, utime_t tim);
-char *bstrftime(char *dt, int maxlen, utime_t tim, const char *fmt = NULL);
-char *bstrftimes(char *dt, int maxlen, utime_t tim);
-char *bstrftime_ny(char *dt, int maxlen, utime_t tim);
-char *bstrftime_nc(char *dt, int maxlen, utime_t tim);
-char *bstrftime_wd(char *dt, int maxlen, utime_t tim);
-utime_t str_to_utime(const char *str);
+DLL_IMP_EXP btime_t get_current_btime(void);
+DLL_IMP_EXP time_t btime_to_unix(btime_t bt);   /* bareos time to epoch time */
+DLL_IMP_EXP utime_t btime_to_utime(btime_t bt); /* bareos time to utime_t */
+
+DLL_IMP_EXP int tm_wom(int mday, int wday);
+DLL_IMP_EXP int tm_woy(time_t stime);
+
+DLL_IMP_EXP void blocaltime(const time_t *time, struct tm *tm);
+DLL_IMP_EXP char *bstrutime(char *dt, int maxlen, utime_t tim);
+DLL_IMP_EXP char *bstrftime(char *dt, int maxlen, utime_t tim, const char *fmt = NULL);
+DLL_IMP_EXP char *bstrftimes(char *dt, int maxlen, utime_t tim);
+DLL_IMP_EXP char *bstrftime_ny(char *dt, int maxlen, utime_t tim);
+DLL_IMP_EXP char *bstrftime_nc(char *dt, int maxlen, utime_t tim);
+DLL_IMP_EXP char *bstrftime_wd(char *dt, int maxlen, utime_t tim);
+DLL_IMP_EXP utime_t str_to_utime(const char *str);
 
 
 /* =========================================================== */
diff --git a/src/lib/cbuf.h b/src/lib/cbuf.h
index 1251530f04f..45498e3c129 100644
--- a/src/lib/cbuf.h
+++ b/src/lib/cbuf.h
@@ -29,8 +29,7 @@
 
 #define QSIZE 10              /**< # of pointers in the queue */
 
-class circbuf : public SMARTALLOC {
-private:
+class DLL_IMP_EXP circbuf : public SMARTALLOC {
    int m_size;
    int m_next_in;
    int m_next_out;
diff --git a/src/lib/crypto_cache.h b/src/lib/crypto_cache.h
index 15a782f22e9..ee63b0b5701 100644
--- a/src/lib/crypto_cache.h
+++ b/src/lib/crypto_cache.h
@@ -45,14 +45,14 @@ struct crypto_cache_entry_t {
    utime_t added;
 };
 
-void read_crypto_cache(const char *dir, const char *progname, int port);
-void read_crypto_cache(const char *cache_file);
-void write_crypto_cache(const char *dir, const char *progname, int port);
-void write_crypto_cache(const char *cache_file);
-bool update_crypto_cache(const char *VolumeName, const char *EncryptionKey);
-char *lookup_crypto_cache_entry(const char *VolumeName);
-void dump_crypto_cache(int fd);
-void reset_crypto_cache(void);
-void flush_crypto_cache(void);
+DLL_IMP_EXP void read_crypto_cache(const char *dir, const char *progname, int port);
+DLL_IMP_EXP void read_crypto_cache(const char *cache_file);
+DLL_IMP_EXP void write_crypto_cache(const char *dir, const char *progname, int port);
+DLL_IMP_EXP void write_crypto_cache(const char *cache_file);
+DLL_IMP_EXP bool update_crypto_cache(const char *VolumeName, const char *EncryptionKey);
+DLL_IMP_EXP char *lookup_crypto_cache_entry(const char *VolumeName);
+DLL_IMP_EXP void dump_crypto_cache(int fd);
+DLL_IMP_EXP void reset_crypto_cache(void);
+DLL_IMP_EXP void flush_crypto_cache(void);
 
 #endif /* _CRYPTO_CACHE_H */
diff --git a/src/lib/dlist.h b/src/lib/dlist.h
index e51f8ed697c..2c4e3457f2c 100644
--- a/src/lib/dlist.h
+++ b/src/lib/dlist.h
@@ -54,7 +54,7 @@ struct dlink {
    void *prev;
 };
 
-class dlist : public SMARTALLOC {
+class DLL_IMP_EXP dlist : public SMARTALLOC {
    void *head;
    void *tail;
    int16_t loffset;
@@ -199,5 +199,5 @@ class dlistString
     */
 };
 
-extern dlistString *new_dlistString(const char *str, int len);
-extern dlistString *new_dlistString(const char *str);
+DLL_IMP_EXP extern dlistString *new_dlistString(const char *str, int len);
+DLL_IMP_EXP extern dlistString *new_dlistString(const char *str);
diff --git a/src/lib/fnmatch.h b/src/lib/fnmatch.h
index b1c6a86e063..65b669e7e93 100644
--- a/src/lib/fnmatch.h
+++ b/src/lib/fnmatch.h
@@ -50,6 +50,6 @@
 #define FNM_IGNORECASE  FNM_CASEFOLD
 #define FNM_FILE_NAME   FNM_PATHNAME
 
-extern "C" int fnmatch(const char *, const char *, int);
+extern "C" DLL_IMP_EXP int fnmatch(const char *, const char *, int);
 
 #endif                          /* !_FNMATCH_H_ */
diff --git a/src/lib/htable.h b/src/lib/htable.h
index d665405cc78..7a288df878e 100644
--- a/src/lib/htable.h
+++ b/src/lib/htable.h
@@ -74,7 +74,7 @@ struct h_mem {
    char first[1];                     /* First byte */
 };
 
-class htable : public SMARTALLOC {
+class  DLL_IMP_EXP htable : public SMARTALLOC {
    hlink **table;                     /* Hash table */
    int loffset;                       /* Link offset in item */
    hlink *walkptr;                    /* Table walk pointer */
diff --git a/src/lib/lockmgr.h b/src/lib/lockmgr.h
index ddd868a889b..09a7c1e6905 100644
--- a/src/lib/lockmgr.h
+++ b/src/lib/lockmgr.h
@@ -27,8 +27,8 @@
 /*
  * P and V op that don't use the lock manager (for memory allocation or on win32)
  */
-void lmgr_p(pthread_mutex_t *m);
-void lmgr_v(pthread_mutex_t *m);
+DLL_IMP_EXP void lmgr_p(pthread_mutex_t *m);
+DLL_IMP_EXP void lmgr_v(pthread_mutex_t *m);
 
 #ifdef _USE_LOCKMGR
 
diff --git a/src/lib/mem_pool.h b/src/lib/mem_pool.h
index 79fc3555d8f..3adf6ff1355 100644
--- a/src/lib/mem_pool.h
+++ b/src/lib/mem_pool.h
@@ -33,23 +33,23 @@
 #ifdef SMARTALLOC
 
 #define get_pool_memory(pool) sm_get_pool_memory(__FILE__, __LINE__, pool)
-POOLMEM *sm_get_pool_memory(const char *file, int line, int pool);
+DLL_IMP_EXP POOLMEM *sm_get_pool_memory(const char *file, int line, int pool);
 
 #define get_memory(size) sm_get_memory(__FILE__, __LINE__, size)
-POOLMEM *sm_get_memory(const char *fname, int line, int32_t size);
+DLL_IMP_EXP POOLMEM *sm_get_memory(const char *fname, int line, int32_t size);
 
 #define sizeof_pool_memory(buf) sm_sizeof_pool_memory(__FILE__, __LINE__, buf)
-int32_t sm_sizeof_pool_memory(const char *fname, int line, POOLMEM *buf);
+DLL_IMP_EXP int32_t sm_sizeof_pool_memory(const char *fname, int line, POOLMEM *buf);
 
 #define realloc_pool_memory(buf,size) sm_realloc_pool_memory(__FILE__, __LINE__, buf, size)
-POOLMEM *sm_realloc_pool_memory(const char *fname, int line, POOLMEM *buf, int32_t size);
+DLL_IMP_EXP POOLMEM *sm_realloc_pool_memory(const char *fname, int line, POOLMEM *buf, int32_t size);
 
 #define check_pool_memory_size(buf,size) sm_check_pool_memory_size(__FILE__, __LINE__, buf, size)
-POOLMEM *sm_check_pool_memory_size(const char *fname, int line, POOLMEM *buf, int32_t size);
+DLL_IMP_EXP POOLMEM *sm_check_pool_memory_size(const char *fname, int line, POOLMEM *buf, int32_t size);
 
 #define free_pool_memory(x) sm_free_pool_memory(__FILE__, __LINE__, x)
 #define free_memory(x) sm_free_pool_memory(__FILE__, __LINE__, x)
-void sm_free_pool_memory(const char *fname, int line, POOLMEM *buf);
+DLL_IMP_EXP void sm_free_pool_memory(const char *fname, int line, POOLMEM *buf);
 
 #else
 
@@ -86,7 +86,7 @@ enum {
 
 #define PM_MAX PM_RECORD              /* Number of types */
 
-class POOL_MEM {
+class DLL_IMP_EXP POOL_MEM {
    char *mem;
 public:
    POOL_MEM() { mem = get_pool_memory(PM_NAME); *mem = 0; }
@@ -112,18 +112,18 @@ class POOL_MEM {
    int bvsprintf(const char *fmt, va_list arg_ptr);
 };
 
-int pm_strcat(POOLMEM *&pm, const char *str);
-int pm_strcat(POOLMEM *&pm, POOL_MEM &str);
-int pm_strcat(POOL_MEM &pm, const char *str);
-int pm_strcat(POOL_MEM *&pm, const char *str);
+DLL_IMP_EXP int pm_strcat(POOLMEM *&pm, const char *str);
+DLL_IMP_EXP int pm_strcat(POOLMEM *&pm, POOL_MEM &str);
+DLL_IMP_EXP int pm_strcat(POOL_MEM &pm, const char *str);
+DLL_IMP_EXP int pm_strcat(POOL_MEM *&pm, const char *str);
 
-int pm_strcpy(POOLMEM *&pm, const char *str);
-int pm_strcpy(POOLMEM *&pm, POOL_MEM &str);
-int pm_strcpy(POOL_MEM &pm, const char *str);
-int pm_strcpy(POOL_MEM *&pm, const char *str);
+DLL_IMP_EXP int pm_strcpy(POOLMEM *&pm, const char *str);
+DLL_IMP_EXP int pm_strcpy(POOLMEM *&pm, POOL_MEM &str);
+DLL_IMP_EXP int pm_strcpy(POOL_MEM &pm, const char *str);
+DLL_IMP_EXP int pm_strcpy(POOL_MEM *&pm, const char *str);
 
-int pm_memcpy(POOLMEM *&pm, const char *data, int32_t n);
-int pm_memcpy(POOLMEM *&pm, POOL_MEM &data, int32_t n);
-int pm_memcpy(POOL_MEM &pm, const char *data, int32_t n);
-int pm_memcpy(POOL_MEM *&pm, const char *data, int32_t n);
+DLL_IMP_EXP int pm_memcpy(POOLMEM *&pm, const char *data, int32_t n);
+DLL_IMP_EXP int pm_memcpy(POOLMEM *&pm, POOL_MEM &data, int32_t n);
+DLL_IMP_EXP int pm_memcpy(POOL_MEM &pm, const char *data, int32_t n);
+DLL_IMP_EXP int pm_memcpy(POOL_MEM *&pm, const char *data, int32_t n);
 #endif
diff --git a/src/lib/message.h b/src/lib/message.h
index a61ccce1c5c..3f0bec4526a 100644
--- a/src/lib/message.h
+++ b/src/lib/message.h
@@ -165,7 +165,7 @@ extern "C" {
 }
 
 void Jmsg(JCR *jcr, int type, utime_t mtime, const char *fmt,...);
-void Qmsg(JCR *jcr, int type, utime_t mtime, const char *fmt,...);
+DLL_IMP_EXP void Qmsg(JCR *jcr, int type, utime_t mtime, const char *fmt,...);
 bool get_trace(void);
 const char *get_basename(const char *pathname);
 void set_log_timestamp_format(const char *format);
diff --git a/src/lib/mntent_cache.h b/src/lib/mntent_cache.h
index 6ee8c0ff42d..0c58f17a3fd 100644
--- a/src/lib/mntent_cache.h
+++ b/src/lib/mntent_cache.h
@@ -29,7 +29,7 @@
 #define _MNTENT_CACHE_H 1
 
 /*
- * Don't use the mountlist data when its older then this amount
+ * Don't use the mountlist data when its older than this amount
  * of seconds but perform a rescan of the mountlist.
  */
 #define MNTENT_RESCAN_INTERVAL		1800
@@ -59,6 +59,6 @@ struct mntent_cache_entry_t {
 
 mntent_cache_entry_t *find_mntent_mapping(uint32_t dev);
 void release_mntent_mapping(mntent_cache_entry_t *mce);
-void flush_mntent_cache(void);
+DLL_IMP_EXP void flush_mntent_cache(void);
 
 #endif /* _MNTENT_CACHE_H */
diff --git a/src/lib/output_formatter.h b/src/lib/output_formatter.h
index 50a73c3b15f..40afd495724 100644
--- a/src/lib/output_formatter.h
+++ b/src/lib/output_formatter.h
@@ -103,7 +103,7 @@ typedef struct of_filter_tuple {
 /**
  * Actual output formatter class.
  */
-class OUTPUT_FORMATTER : public SMARTALLOC {
+class DLL_IMP_EXP OUTPUT_FORMATTER : public SMARTALLOC {
 public:
    /*
     * Typedefs.
diff --git a/src/lib/protos.h b/src/lib/protos.h
index e18aa04bc91..67819a39d5f 100644
--- a/src/lib/protos.h
+++ b/src/lib/protos.h
@@ -31,349 +31,349 @@
 class JCR;
 
 /* attr.c */
-ATTR *new_attr(JCR *jcr);
-void free_attr(ATTR *attr);
-int unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, int32_t reclen, ATTR *attr);
-void build_attr_output_fnames(JCR *jcr, ATTR *attr);
-const char *attr_to_str(POOL_MEM &resultbuffer, JCR *jcr, ATTR *attr);
-void print_ls_output(JCR *jcr, ATTR *attr);
+DLL_IMP_EXP ATTR *new_attr(JCR *jcr);
+DLL_IMP_EXP void free_attr(ATTR *attr);
+DLL_IMP_EXP int unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, int32_t reclen, ATTR *attr);
+DLL_IMP_EXP void build_attr_output_fnames(JCR *jcr, ATTR *attr);
+DLL_IMP_EXP const char *attr_to_str(POOL_MEM &resultbuffer, JCR *jcr, ATTR *attr);
+DLL_IMP_EXP void print_ls_output(JCR *jcr, ATTR *attr);
 
 /* attribs.c */
-void encode_stat(char *buf, struct stat *statp, int stat_size, int32_t LinkFI, int data_stream);
-int decode_stat(char *buf, struct stat *statp, int stat_size, int32_t *LinkFI);
-int32_t decode_LinkFI(char *buf, struct stat *statp, int stat_size);
+DLL_IMP_EXP void encode_stat(char *buf, struct stat *statp, int stat_size, int32_t LinkFI, int data_stream);
+DLL_IMP_EXP int decode_stat(char *buf, struct stat *statp, int stat_size, int32_t *LinkFI);
+DLL_IMP_EXP int32_t decode_LinkFI(char *buf, struct stat *statp, int stat_size);
 
 /* base64.c */
-void base64_init(void);
-int to_base64(int64_t value, char *where);
-int from_base64(int64_t *value, char *where);
-int bin_to_base64(char *buf, int buflen, char *bin, int binlen, bool compatible);
-int base64_to_bin(char *dest, int destlen, char *src, int srclen);
+DLL_IMP_EXP void base64_init(void);
+DLL_IMP_EXP int to_base64(int64_t value, char *where);
+DLL_IMP_EXP int from_base64(int64_t *value, char *where);
+DLL_IMP_EXP int bin_to_base64(char *buf, int buflen, char *bin, int binlen, bool compatible);
+DLL_IMP_EXP int base64_to_bin(char *dest, int destlen, char *src, int srclen);
 
 /* bget_msg.c */
-int bget_msg(BSOCK *sock);
+DLL_IMP_EXP int bget_msg(BSOCK *sock);
 
 /* bnet.c */
-int32_t bnet_recv(BSOCK *bsock);
-bool bnet_send(BSOCK *bsock);
-bool bnet_fsend(BSOCK *bs, const char *fmt, ...);
-bool bnet_set_buffer_size(BSOCK *bs, uint32_t size, int rw);
-bool bnet_sig(BSOCK *bs, int sig);
-bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK *bsock,
+DLL_IMP_EXP int32_t bnet_recv(BSOCK *bsock);
+DLL_IMP_EXP bool bnet_send(BSOCK *bsock);
+DLL_IMP_EXP bool bnet_fsend(BSOCK *bs, const char *fmt, ...);
+DLL_IMP_EXP bool bnet_set_buffer_size(BSOCK *bs, uint32_t size, int rw);
+DLL_IMP_EXP bool bnet_sig(BSOCK *bs, int sig);
+DLL_IMP_EXP bool bnet_tls_server(TLS_CONTEXT *ctx, BSOCK *bsock,
                      alist *verify_list);
-bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK *bsock,
+DLL_IMP_EXP bool bnet_tls_client(TLS_CONTEXT *ctx, BSOCK *bsock,
                      bool verify_peer, alist *verify_list);
-int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen);
-BSOCK *dup_bsock(BSOCK *bsock);
-const char *bnet_strerror(BSOCK *bsock);
-const char *bnet_sig_to_ascii(BSOCK *bsock);
-int bnet_wait_data(BSOCK *bsock, int sec);
-int bnet_wait_data_intr(BSOCK *bsock, int sec);
-bool is_bnet_stop(BSOCK *bsock);
-int is_bnet_error(BSOCK *bsock);
-void bnet_suppress_error_messages(BSOCK *bsock, bool flag);
-dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr);
-int bnet_set_blocking(BSOCK *sock);
-int bnet_set_nonblocking(BSOCK *sock);
-void bnet_restore_blocking(BSOCK *sock, int flags);
-int net_connect(int port);
-BSOCK *bnet_bind(int port);
-BSOCK *bnet_accept(BSOCK *bsock, char *who);
+DLL_IMP_EXP int bnet_get_peer(BSOCK *bs, char *buf, socklen_t buflen);
+DLL_IMP_EXP BSOCK *dup_bsock(BSOCK *bsock);
+DLL_IMP_EXP const char *bnet_strerror(BSOCK *bsock);
+DLL_IMP_EXP const char *bnet_sig_to_ascii(BSOCK *bsock);
+DLL_IMP_EXP int bnet_wait_data(BSOCK *bsock, int sec);
+DLL_IMP_EXP int bnet_wait_data_intr(BSOCK *bsock, int sec);
+DLL_IMP_EXP bool is_bnet_stop(BSOCK *bsock);
+DLL_IMP_EXP int is_bnet_error(BSOCK *bsock);
+DLL_IMP_EXP void bnet_suppress_error_messages(BSOCK *bsock, bool flag);
+DLL_IMP_EXP dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr);
+DLL_IMP_EXP int bnet_set_blocking(BSOCK *sock);
+DLL_IMP_EXP int bnet_set_nonblocking(BSOCK *sock);
+DLL_IMP_EXP void bnet_restore_blocking(BSOCK *sock, int flags);
+DLL_IMP_EXP int net_connect(int port);
+DLL_IMP_EXP BSOCK *bnet_bind(int port);
+DLL_IMP_EXP BSOCK *bnet_accept(BSOCK *bsock, char *who);
 
 /* bnet_server_tcp.c */
-void cleanup_bnet_thread_server_tcp(alist *sockfds, workq_t *client_wq);
-void bnet_thread_server_tcp(dlist *addr_list,
+DLL_IMP_EXP void cleanup_bnet_thread_server_tcp(alist *sockfds, workq_t *client_wq);
+DLL_IMP_EXP void bnet_thread_server_tcp(dlist *addr_list,
                             int max_clients,
                             alist *sockfds,
                             workq_t *client_wq,
                             bool nokeepalive,
                             void *handle_client_request(void *bsock));
-void bnet_stop_thread_server_tcp(pthread_t tid);
+DLL_IMP_EXP void bnet_stop_thread_server_tcp(pthread_t tid);
 
 /* bpipe.c */
-BPIPE *open_bpipe(char *prog, int wait, const char *mode,
+DLL_IMP_EXP BPIPE *open_bpipe(char *prog, int wait, const char *mode,
                   bool dup_stderr = true);
-int close_wpipe(BPIPE *bpipe);
-int close_bpipe(BPIPE *bpipe);
+DLL_IMP_EXP int close_wpipe(BPIPE *bpipe);
+DLL_IMP_EXP int close_bpipe(BPIPE *bpipe);
 
 /* bsys.c */
-char *bstrinlinecpy(char *dest, const char *src);
-char *bstrncpy(char *dest, const char *src, int maxlen);
-char *bstrncpy(char *dest, POOL_MEM &src, int maxlen);
-char *bstrncat(char *dest, const char *src, int maxlen);
-char *bstrncat(char *dest, POOL_MEM &src, int maxlen);
-bool bstrcmp(const char *s1, const char *s2);
-bool bstrncmp(const char *s1, const char *s2, int n);
-bool bstrcasecmp(const char *s1, const char *s2);
-bool bstrncasecmp(const char *s1, const char *s2, int n);
-int cstrlen(const char *str);
-void *b_malloc(const char *file, int line, size_t size);
+DLL_IMP_EXP char *bstrinlinecpy(char *dest, const char *src);
+DLL_IMP_EXP char *bstrncpy(char *dest, const char *src, int maxlen);
+DLL_IMP_EXP char *bstrncpy(char *dest, POOL_MEM &src, int maxlen);
+DLL_IMP_EXP char *bstrncat(char *dest, const char *src, int maxlen);
+DLL_IMP_EXP char *bstrncat(char *dest, POOL_MEM &src, int maxlen);
+DLL_IMP_EXP bool bstrcmp(const char *s1, const char *s2);
+DLL_IMP_EXP bool bstrncmp(const char *s1, const char *s2, int n);
+DLL_IMP_EXP bool bstrcasecmp(const char *s1, const char *s2);
+DLL_IMP_EXP bool bstrncasecmp(const char *s1, const char *s2, int n);
+DLL_IMP_EXP int cstrlen(const char *str);
+DLL_IMP_EXP void *b_malloc(const char *file, int line, size_t size);
 #ifndef bmalloc
-void *bmalloc(size_t size);
+DLL_IMP_EXP void *bmalloc(size_t size);
 #endif
-void bfree(void *buf);
-void *brealloc(void *buf, size_t size);
-void *bcalloc(size_t size1, size_t size2);
-int bsnprintf(char *str, int32_t size, const char *format, ...);
-int bvsnprintf(char *str, int32_t size, const char *format, va_list ap);
-int pool_sprintf(char *pool_buf, const char *fmt, ...);
-void create_pid_file(char *dir, const char *progname, int port);
-int delete_pid_file(char *dir, const char *progname, int port);
-void drop(char *uid, char *gid, bool keep_readall_caps);
-int bmicrosleep(int32_t sec, int32_t usec);
-char *bfgets(char *s, int size, FILE *fd);
-char *bfgets(POOLMEM *&s, FILE *fd);
-void make_unique_filename(POOLMEM *&name, int Id, char *what);
+DLL_IMP_EXP void bfree(void *buf);
+DLL_IMP_EXP void *brealloc(void *buf, size_t size);
+DLL_IMP_EXP void *bcalloc(size_t size1, size_t size2);
+DLL_IMP_EXP int bsnprintf(char *str, int32_t size, const char *format, ...);
+DLL_IMP_EXP int bvsnprintf(char *str, int32_t size, const char *format, va_list ap);
+DLL_IMP_EXP int pool_sprintf(char *pool_buf, const char *fmt, ...);
+DLL_IMP_EXP void create_pid_file(char *dir, const char *progname, int port);
+DLL_IMP_EXP int delete_pid_file(char *dir, const char *progname, int port);
+DLL_IMP_EXP void drop(char *uid, char *gid, bool keep_readall_caps);
+DLL_IMP_EXP int bmicrosleep(int32_t sec, int32_t usec);
+DLL_IMP_EXP char *bfgets(char *s, int size, FILE *fd);
+DLL_IMP_EXP char *bfgets(POOLMEM *&s, FILE *fd);
+DLL_IMP_EXP void make_unique_filename(POOLMEM *&name, int Id, char *what);
 #ifndef HAVE_STRTOLL
-long long int strtoll(const char *ptr, char **endptr, int base);
+DLL_IMP_EXP long long int strtoll(const char *ptr, char **endptr, int base);
 #endif
-void read_state_file(char *dir, const char *progname, int port);
-int b_strerror(int errnum, char *buf, size_t bufsiz);
-char *escape_filename(const char *file_path);
-int Zdeflate(char *in, int in_len, char *out, int &out_len);
-int Zinflate(char *in, int in_len, char *out, int &out_len);
-void stack_trace();
-int safer_unlink(const char *pathname, const char *regex);
-int secure_erase(JCR *jcr, const char *pathname);
-void set_secure_erase_cmdline(const char *cmdline);
-bool path_exists(const char *path);
-bool path_exists(POOL_MEM &path);
-bool path_is_directory(const char *path);
-bool path_is_directory(POOL_MEM &path);
-bool path_is_absolute(const char *path);
-bool path_is_absolute(POOL_MEM &path);
-bool path_get_directory(POOL_MEM &directory, POOL_MEM &path);
-bool path_append(char *path, const char *extra, unsigned int max_path);
-bool path_append(POOL_MEM &path, const char *extra);
-bool path_append(POOL_MEM &path, POOL_MEM &extra);
-bool path_create(const char *path, mode_t mode = 0750);
-bool path_create(POOL_MEM &path, mode_t mode = 0750);
+DLL_IMP_EXP void read_state_file(char *dir, const char *progname, int port);
+DLL_IMP_EXP int b_strerror(int errnum, char *buf, size_t bufsiz);
+DLL_IMP_EXP char *escape_filename(const char *file_path);
+DLL_IMP_EXP int Zdeflate(char *in, int in_len, char *out, int &out_len);
+DLL_IMP_EXP int Zinflate(char *in, int in_len, char *out, int &out_len);
+DLL_IMP_EXP void stack_trace();
+DLL_IMP_EXP int safer_unlink(const char *pathname, const char *regex);
+DLL_IMP_EXP int secure_erase(JCR *jcr, const char *pathname);
+DLL_IMP_EXP void set_secure_erase_cmdline(const char *cmdline);
+DLL_IMP_EXP bool path_exists(const char *path);
+DLL_IMP_EXP bool path_exists(POOL_MEM &path);
+DLL_IMP_EXP bool path_is_directory(const char *path);
+DLL_IMP_EXP bool path_is_directory(POOL_MEM &path);
+DLL_IMP_EXP bool path_is_absolute(const char *path);
+DLL_IMP_EXP bool path_is_absolute(POOL_MEM &path);
+DLL_IMP_EXP bool path_get_directory(POOL_MEM &directory, POOL_MEM &path);
+DLL_IMP_EXP bool path_append(char *path, const char *extra, unsigned int max_path);
+DLL_IMP_EXP bool path_append(POOL_MEM &path, const char *extra);
+DLL_IMP_EXP bool path_append(POOL_MEM &path, POOL_MEM &extra);
+DLL_IMP_EXP bool path_create(const char *path, mode_t mode = 0750);
+DLL_IMP_EXP bool path_create(POOL_MEM &path, mode_t mode = 0750);
 
 /* compression.c */
-const char *cmprs_algo_to_text(uint32_t compression_algorithm);
-bool setup_compression_buffers(JCR *jcr, bool compatible,
+DLL_IMP_EXP const char *cmprs_algo_to_text(uint32_t compression_algorithm);
+DLL_IMP_EXP bool setup_compression_buffers(JCR *jcr, bool compatible,
                                uint32_t compression_algorithm,
                                uint32_t *compress_buf_size);
-bool setup_decompression_buffers(JCR *jcr, uint32_t *decompress_buf_size);
-bool compress_data(JCR *jcr, uint32_t compression_algorithm, char *rbuf,
+DLL_IMP_EXP bool setup_decompression_buffers(JCR *jcr, uint32_t *decompress_buf_size);
+DLL_IMP_EXP bool compress_data(JCR *jcr, uint32_t compression_algorithm, char *rbuf,
                    uint32_t rsize, unsigned char *cbuf,
                    uint32_t max_compress_len, uint32_t *compress_len);
-bool decompress_data(JCR *jcr, const char *last_fname, int32_t stream,
+DLL_IMP_EXP bool decompress_data(JCR *jcr, const char *last_fname, int32_t stream,
                      char **data, uint32_t *length, bool want_data_stream);
-void cleanup_compression(JCR *jcr);
+DLL_IMP_EXP void cleanup_compression(JCR *jcr);
 
 /* cram-md5.c */
-bool cram_md5_respond(BSOCK *bs, const char *password, int *tls_remote_need, bool *compatible);
-bool cram_md5_challenge(BSOCK *bs, const char *password, int tls_local_need, bool compatible);
-void hmac_md5(uint8_t *text, int text_len, uint8_t *key, int key_len, uint8_t *hmac);
+DLL_IMP_EXP bool cram_md5_respond(BSOCK *bs, const char *password, int *tls_remote_need, bool *compatible);
+DLL_IMP_EXP bool cram_md5_challenge(BSOCK *bs, const char *password, int tls_local_need, bool compatible);
+DLL_IMP_EXP void hmac_md5(uint8_t *text, int text_len, uint8_t *key, int key_len, uint8_t *hmac);
 
 /* crypto.c */
-int init_crypto(void);
-int cleanup_crypto(void);
-DIGEST *crypto_digest_new(JCR *jcr, crypto_digest_t type);
-bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length);
-bool crypto_digest_finalize(DIGEST *digest, uint8_t *dest, uint32_t *length);
-void crypto_digest_free(DIGEST *digest);
-SIGNATURE *crypto_sign_new(JCR *jcr);
-crypto_error_t crypto_sign_get_digest(SIGNATURE *sig, X509_KEYPAIR *keypair,
+DLL_IMP_EXP int init_crypto(void);
+DLL_IMP_EXP int cleanup_crypto(void);
+DLL_IMP_EXP DIGEST *crypto_digest_new(JCR *jcr, crypto_digest_t type);
+DLL_IMP_EXP bool crypto_digest_update(DIGEST *digest, const uint8_t *data, uint32_t length);
+DLL_IMP_EXP bool crypto_digest_finalize(DIGEST *digest, uint8_t *dest, uint32_t *length);
+DLL_IMP_EXP void crypto_digest_free(DIGEST *digest);
+DLL_IMP_EXP SIGNATURE *crypto_sign_new(JCR *jcr);
+DLL_IMP_EXP crypto_error_t crypto_sign_get_digest(SIGNATURE *sig, X509_KEYPAIR *keypair,
                                       crypto_digest_t &algorithm, DIGEST **digest);
-crypto_error_t crypto_sign_verify(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest);
-int crypto_sign_add_signer(SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair);
-int crypto_sign_encode(SIGNATURE *sig, uint8_t *dest, uint32_t *length);
-SIGNATURE *crypto_sign_decode(JCR *jcr, const uint8_t *sigData, uint32_t length);
-void crypto_sign_free(SIGNATURE *sig);
-CRYPTO_SESSION *crypto_session_new(crypto_cipher_t cipher, alist *pubkeys);
-void crypto_session_free(CRYPTO_SESSION *cs);
-bool crypto_session_encode(CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length);
-crypto_error_t crypto_session_decode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session);
-CRYPTO_SESSION *crypto_session_decode(const uint8_t *data, uint32_t length);
-CIPHER_CONTEXT *crypto_cipher_new(CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize);
-bool crypto_cipher_update(CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written);
-bool crypto_cipher_finalize(CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written);
-void crypto_cipher_free(CIPHER_CONTEXT *cipher_ctx);
-X509_KEYPAIR *crypto_keypair_new(void);
-X509_KEYPAIR *crypto_keypair_dup(X509_KEYPAIR *keypair);
-int crypto_keypair_load_cert(X509_KEYPAIR *keypair, const char *file);
-bool crypto_keypair_has_key(const char *file);
-int crypto_keypair_load_key(X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata);
-void crypto_keypair_free(X509_KEYPAIR *keypair);
-int crypto_default_pem_callback(char *buf, int size, const void *userdata);
-const char *crypto_digest_name(crypto_digest_t type);
-const char *crypto_digest_name(DIGEST *digest);
-crypto_digest_t crypto_digest_stream_type(int stream);
-const char *crypto_strerror(crypto_error_t error);
+DLL_IMP_EXP crypto_error_t crypto_sign_verify(SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest);
+DLL_IMP_EXP int crypto_sign_add_signer(SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair);
+DLL_IMP_EXP int crypto_sign_encode(SIGNATURE *sig, uint8_t *dest, uint32_t *length);
+DLL_IMP_EXP SIGNATURE *crypto_sign_decode(JCR *jcr, const uint8_t *sigData, uint32_t length);
+DLL_IMP_EXP void crypto_sign_free(SIGNATURE *sig);
+DLL_IMP_EXP CRYPTO_SESSION *crypto_session_new(crypto_cipher_t cipher, alist *pubkeys);
+DLL_IMP_EXP void crypto_session_free(CRYPTO_SESSION *cs);
+DLL_IMP_EXP bool crypto_session_encode(CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length);
+DLL_IMP_EXP crypto_error_t crypto_session_decode(const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session);
+DLL_IMP_EXP CRYPTO_SESSION *crypto_session_decode(const uint8_t *data, uint32_t length);
+DLL_IMP_EXP CIPHER_CONTEXT *crypto_cipher_new(CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize);
+DLL_IMP_EXP bool crypto_cipher_update(CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written);
+DLL_IMP_EXP bool crypto_cipher_finalize(CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written);
+DLL_IMP_EXP void crypto_cipher_free(CIPHER_CONTEXT *cipher_ctx);
+DLL_IMP_EXP X509_KEYPAIR *crypto_keypair_new(void);
+DLL_IMP_EXP X509_KEYPAIR *crypto_keypair_dup(X509_KEYPAIR *keypair);
+DLL_IMP_EXP int crypto_keypair_load_cert(X509_KEYPAIR *keypair, const char *file);
+DLL_IMP_EXP bool crypto_keypair_has_key(const char *file);
+DLL_IMP_EXP int crypto_keypair_load_key(X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata);
+DLL_IMP_EXP void crypto_keypair_free(X509_KEYPAIR *keypair);
+DLL_IMP_EXP int crypto_default_pem_callback(char *buf, int size, const void *userdata);
+DLL_IMP_EXP const char *crypto_digest_name(crypto_digest_t type);
+DLL_IMP_EXP const char *crypto_digest_name(DIGEST *digest);
+DLL_IMP_EXP crypto_digest_t crypto_digest_stream_type(int stream);
+DLL_IMP_EXP const char *crypto_strerror(crypto_error_t error);
 
 /* crypto_openssl.c */
 #ifdef HAVE_OPENSSL
-void openssl_post_errors(int code, const char *errstring);
-void openssl_post_errors(JCR *jcr, int code, const char *errstring);
-int openssl_init_threads(void);
-void openssl_cleanup_threads(void);
-int openssl_seed_prng(void);
-int openssl_save_prng(void);
+DLL_IMP_EXP void openssl_post_errors(int code, const char *errstring);
+DLL_IMP_EXP void openssl_post_errors(JCR *jcr, int code, const char *errstring);
+DLL_IMP_EXP int openssl_init_threads(void);
+DLL_IMP_EXP void openssl_cleanup_threads(void);
+DLL_IMP_EXP int openssl_seed_prng(void);
+DLL_IMP_EXP int openssl_save_prng(void);
 #endif /* HAVE_OPENSSL */
 
 /* crypto_wrap.c */
-void aes_wrap(uint8_t *kek, int n, uint8_t *plain, uint8_t *cipher);
-int aes_unwrap(uint8_t *kek, int n, uint8_t *cipher, uint8_t *plain);
+DLL_IMP_EXP void aes_wrap(uint8_t *kek, int n, uint8_t *plain, uint8_t *cipher);
+DLL_IMP_EXP int aes_unwrap(uint8_t *kek, int n, uint8_t *cipher, uint8_t *plain);
 
 /* daemon.c */
-void daemon_start();
+DLL_IMP_EXP void daemon_start();
 
 /* edit.c */
-uint64_t str_to_uint64(const char *str);
-int64_t str_to_int64(const char *str);
+DLL_IMP_EXP uint64_t str_to_uint64(const char *str);
+DLL_IMP_EXP int64_t str_to_int64(const char *str);
 #define str_to_int16(str)((int16_t)str_to_int64(str))
 #define str_to_int32(str)((int32_t)str_to_int64(str))
-char *edit_uint64_with_commas(uint64_t val, char *buf);
-char *edit_uint64_with_suffix(uint64_t val, char *buf);
-char *add_commas(char *val, char *buf);
-char *edit_uint64(uint64_t val, char *buf);
-char *edit_int64(int64_t val, char *buf);
-char *edit_int64_with_commas(int64_t val, char *buf);
-bool duration_to_utime(char *str, utime_t *value);
-bool size_to_uint64(char *str, uint64_t *value);
-bool speed_to_uint64(char *str, uint64_t *value);
-char *edit_utime(utime_t val, char *buf, int buf_len);
-char *edit_pthread(pthread_t val, char *buf, int buf_len);
-bool is_a_number(const char *num);
-bool is_a_number_list(const char *n);
-bool is_an_integer(const char *n);
-bool is_name_valid(const char *name, POOLMEM *&msg);
-bool is_name_valid(const char *name);
+DLL_IMP_EXP char *edit_uint64_with_commas(uint64_t val, char *buf);
+DLL_IMP_EXP char *edit_uint64_with_suffix(uint64_t val, char *buf);
+DLL_IMP_EXP char *add_commas(char *val, char *buf);
+DLL_IMP_EXP char *edit_uint64(uint64_t val, char *buf);
+DLL_IMP_EXP char *edit_int64(int64_t val, char *buf);
+DLL_IMP_EXP char *edit_int64_with_commas(int64_t val, char *buf);
+DLL_IMP_EXP bool duration_to_utime(char *str, utime_t *value);
+DLL_IMP_EXP bool size_to_uint64(char *str, uint64_t *value);
+DLL_IMP_EXP bool speed_to_uint64(char *str, uint64_t *value);
+DLL_IMP_EXP char *edit_utime(utime_t val, char *buf, int buf_len);
+DLL_IMP_EXP char *edit_pthread(pthread_t val, char *buf, int buf_len);
+DLL_IMP_EXP bool is_a_number(const char *num);
+DLL_IMP_EXP bool is_a_number_list(const char *n);
+DLL_IMP_EXP bool is_an_integer(const char *n);
+DLL_IMP_EXP bool is_name_valid(const char *name, POOLMEM *&msg);
+DLL_IMP_EXP bool is_name_valid(const char *name);
 
 /* jcr.c (most definitions are in src/jcr.h) */
-void init_last_jobs_list();
-void term_last_jobs_list();
-void lock_last_jobs_list();
-void unlock_last_jobs_list();
-bool read_last_jobs_list(int fd, uint64_t addr);
-uint64_t write_last_jobs_list(int fd, uint64_t addr);
-void write_state_file(char *dir, const char *progname, int port);
-void register_job_end_callback(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx);
-void lock_jobs();
-void unlock_jobs();
-JCR *jcr_walk_start();
-JCR *jcr_walk_next(JCR *prev_jcr);
-void jcr_walk_end(JCR *jcr);
-int job_count();
-JCR *get_jcr_from_tsd();
-void set_jcr_in_tsd(JCR *jcr);
-void remove_jcr_from_tsd(JCR *jcr);
-uint32_t get_jobid_from_tsd();
-uint32_t get_jobid_from_tid(pthread_t tid);
+DLL_IMP_EXP void init_last_jobs_list();
+DLL_IMP_EXP void term_last_jobs_list();
+DLL_IMP_EXP void lock_last_jobs_list();
+DLL_IMP_EXP void unlock_last_jobs_list();
+DLL_IMP_EXP bool read_last_jobs_list(int fd, uint64_t addr);
+DLL_IMP_EXP uint64_t write_last_jobs_list(int fd, uint64_t addr);
+DLL_IMP_EXP void write_state_file(char *dir, const char *progname, int port);
+DLL_IMP_EXP void register_job_end_callback(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx);
+DLL_IMP_EXP void lock_jobs();
+DLL_IMP_EXP void unlock_jobs();
+DLL_IMP_EXP JCR *jcr_walk_start();
+DLL_IMP_EXP JCR *jcr_walk_next(JCR *prev_jcr);
+DLL_IMP_EXP void jcr_walk_end(JCR *jcr);
+DLL_IMP_EXP int job_count();
+DLL_IMP_EXP JCR *get_jcr_from_tsd();
+DLL_IMP_EXP void set_jcr_in_tsd(JCR *jcr);
+DLL_IMP_EXP void remove_jcr_from_tsd(JCR *jcr);
+DLL_IMP_EXP uint32_t get_jobid_from_tsd();
+DLL_IMP_EXP uint32_t get_jobid_from_tid(pthread_t tid);
 
 /* json.c */
-void initialize_json();
+DLL_IMP_EXP void initialize_json();
 
 /* lex.c */
-LEX *lex_close_file(LEX *lf);
-LEX *lex_open_file(LEX *lf,
+DLL_IMP_EXP LEX *lex_close_file(LEX *lf);
+DLL_IMP_EXP LEX *lex_open_file(LEX *lf,
                    const char *fname,
                    LEX_ERROR_HANDLER *scan_error,
                    LEX_WARNING_HANDLER *scan_warning);
-LEX *lex_new_buffer(LEX *lf,
+DLL_IMP_EXP LEX *lex_new_buffer(LEX *lf,
                     LEX_ERROR_HANDLER *scan_error,
                     LEX_WARNING_HANDLER *scan_warning);
-int lex_get_char(LEX *lf);
-void lex_unget_char(LEX *lf);
-const char *lex_tok_to_str(int token);
-int lex_get_token(LEX *lf, int expect);
-void lex_set_default_error_handler(LEX *lf);
-void lex_set_default_warning_handler(LEX *lf);
-void lex_set_error_handler_error_type(LEX *lf, int err_type);
+DLL_IMP_EXP int lex_get_char(LEX *lf);
+DLL_IMP_EXP void lex_unget_char(LEX *lf);
+DLL_IMP_EXP const char *lex_tok_to_str(int token);
+DLL_IMP_EXP int lex_get_token(LEX *lf, int expect);
+DLL_IMP_EXP void lex_set_default_error_handler(LEX *lf);
+DLL_IMP_EXP void lex_set_default_warning_handler(LEX *lf);
+DLL_IMP_EXP void lex_set_error_handler_error_type(LEX *lf, int err_type);
 
 /* message.c */
-void my_name_is(int argc, char *argv[], const char *name);
-void init_msg(JCR *jcr, MSGSRES *msg, job_code_callback_t job_code_callback = NULL);
-void term_msg(void);
-void close_msg(JCR *jcr);
-void add_msg_dest(MSGSRES *msg, int dest, int type,
+DLL_IMP_EXP void my_name_is(int argc, char *argv[], const char *name);
+DLL_IMP_EXP void init_msg(JCR *jcr, MSGSRES *msg, job_code_callback_t job_code_callback = NULL);
+DLL_IMP_EXP void term_msg(void);
+DLL_IMP_EXP void close_msg(JCR *jcr);
+DLL_IMP_EXP void add_msg_dest(MSGSRES *msg, int dest, int type,
                   char *where, char *mail_cmd, char *timestamp_format);
-void rem_msg_dest(MSGSRES *msg, int dest, int type, char *where);
-void Jmsg(JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
-void dispatch_message(JCR *jcr, int type, utime_t mtime, char *buf);
-void init_console_msg(const char *wd);
-void free_msgs_res(MSGSRES *msgs);
-void dequeue_messages(JCR *jcr);
-void set_trace(int trace_flag);
-bool get_trace(void);
-void set_hangup(int hangup_value);
-bool get_hangup(void);
-void set_timestamp(int timestamp_flag);
-bool get_timestamp(void);
-void set_db_type(const char *name);
-void register_message_callback(void msg_callback(int type, char *msg));
+DLL_IMP_EXP void rem_msg_dest(MSGSRES *msg, int dest, int type, char *where);
+DLL_IMP_EXP void Jmsg(JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
+DLL_IMP_EXP void dispatch_message(JCR *jcr, int type, utime_t mtime, char *buf);
+DLL_IMP_EXP void init_console_msg(const char *wd);
+DLL_IMP_EXP void free_msgs_res(MSGSRES *msgs);
+DLL_IMP_EXP void dequeue_messages(JCR *jcr);
+DLL_IMP_EXP void set_trace(int trace_flag);
+DLL_IMP_EXP bool get_trace(void);
+DLL_IMP_EXP void set_hangup(int hangup_value);
+DLL_IMP_EXP bool get_hangup(void);
+DLL_IMP_EXP void set_timestamp(int timestamp_flag);
+DLL_IMP_EXP bool get_timestamp(void);
+DLL_IMP_EXP void set_db_type(const char *name);
+DLL_IMP_EXP void register_message_callback(void msg_callback(int type, char *msg));
 
 /* passphrase.c */
-char *generate_crypto_passphrase(uint16_t length);
+DLL_IMP_EXP char *generate_crypto_passphrase(uint16_t length);
 
 /* path_list.c */
-htable *path_list_init();
-bool path_list_lookup(htable *path_list, const char *fname);
-bool path_list_add(htable *path_list, uint32_t len, const char *fname);
-void free_path_list(htable *path_list);
+DLL_IMP_EXP htable *path_list_init();
+DLL_IMP_EXP bool path_list_lookup(htable *path_list, const char *fname);
+DLL_IMP_EXP bool path_list_add(htable *path_list, uint32_t len, const char *fname);
+DLL_IMP_EXP void free_path_list(htable *path_list);
 
 /* poll.c */
-int wait_for_readable_fd(int fd, int sec, bool ignore_interupts);
-int wait_for_writable_fd(int fd, int sec, bool ignore_interupts);
+DLL_IMP_EXP int wait_for_readable_fd(int fd, int sec, bool ignore_interupts);
+DLL_IMP_EXP int wait_for_writable_fd(int fd, int sec, bool ignore_interupts);
 
 /* pythonlib.c */
-int generate_daemon_event(JCR *jcr, const char *event);
+DLL_IMP_EXP int generate_daemon_event(JCR *jcr, const char *event);
 
 /* scan.c */
-void strip_leading_space(char *str);
-void strip_trailing_junk(char *str);
-void strip_trailing_newline(char *str);
-void strip_trailing_slashes(char *dir);
-bool skip_spaces(char **msg);
-bool skip_nonspaces(char **msg);
-int fstrsch(const char *a, const char *b);
-char *next_arg(char **s);
-int parse_args(POOLMEM *cmd, POOLMEM *&args, int *argc,
+DLL_IMP_EXP void strip_leading_space(char *str);
+DLL_IMP_EXP void strip_trailing_junk(char *str);
+DLL_IMP_EXP void strip_trailing_newline(char *str);
+DLL_IMP_EXP void strip_trailing_slashes(char *dir);
+DLL_IMP_EXP bool skip_spaces(char **msg);
+DLL_IMP_EXP bool skip_nonspaces(char **msg);
+DLL_IMP_EXP int fstrsch(const char *a, const char *b);
+DLL_IMP_EXP char *next_arg(char **s);
+DLL_IMP_EXP int parse_args(POOLMEM *cmd, POOLMEM *&args, int *argc,
                char **argk, char **argv, int max_args);
-int parse_args_only(POOLMEM *cmd, POOLMEM *&args, int *argc,
+DLL_IMP_EXP int parse_args_only(POOLMEM *cmd, POOLMEM *&args, int *argc,
                     char **argk, char **argv, int max_args);
-void split_path_and_filename(const char *fname, POOLMEM *&path,
+DLL_IMP_EXP void split_path_and_filename(const char *fname, POOLMEM *&path,
                              int *pnl, POOLMEM *&file, int *fnl);
-int bsscanf(const char *buf, const char *fmt, ...);
+DLL_IMP_EXP int bsscanf(const char *buf, const char *fmt, ...);
 
 /* scsi_crypto.c */
-bool clear_scsi_encryption_key(int fd, const char *device);
-bool set_scsi_encryption_key(int fd, const char *device, char *encryption_key);
-int get_scsi_drive_encryption_status(int fd, const char *device_name,
+DLL_IMP_EXP bool clear_scsi_encryption_key(int fd, const char *device);
+DLL_IMP_EXP bool set_scsi_encryption_key(int fd, const char *device, char *encryption_key);
+DLL_IMP_EXP int get_scsi_drive_encryption_status(int fd, const char *device_name,
                                      POOLMEM *&status, int indent);
-int get_scsi_volume_encryption_status(int fd, const char *device_name,
+DLL_IMP_EXP int get_scsi_volume_encryption_status(int fd, const char *device_name,
                                       POOLMEM *&status, int indent);
-bool need_scsi_crypto_key(int fd, const char *device_name, bool use_drive_status);
-bool is_scsi_encryption_enabled(int fd, const char *device_name);
+DLL_IMP_EXP bool need_scsi_crypto_key(int fd, const char *device_name, bool use_drive_status);
+DLL_IMP_EXP bool is_scsi_encryption_enabled(int fd, const char *device_name);
 
 /* scsi_lli.c */
-bool recv_scsi_cmd_page(int fd, const char *device_name,
+DLL_IMP_EXP bool recv_scsi_cmd_page(int fd, const char *device_name,
                         void *cdb, unsigned int cdb_len,
                         void *cmd_page, unsigned int cmd_page_len);
-bool send_scsi_cmd_page(int fd, const char *device_name,
+DLL_IMP_EXP bool send_scsi_cmd_page(int fd, const char *device_name,
                         void *cdb, unsigned int cdb_len,
                         void *cmd_page, unsigned int cmd_page_len);
-bool check_scsi_at_eod(int fd);
+DLL_IMP_EXP bool check_scsi_at_eod(int fd);
 
 /* scsi_tapealert.c */
-bool get_tapealert_flags(int fd, const char *device_name, uint64_t *flags);
+DLL_IMP_EXP bool get_tapealert_flags(int fd, const char *device_name, uint64_t *flags);
 
 /* signal.c */
-void init_signals(void terminate(int sig));
-void init_stack_dump(void);
+DLL_IMP_EXP void init_signals(void terminate(int sig));
+DLL_IMP_EXP void init_stack_dump(void);
 
 /* timers.c */
-btimer_t *start_child_timer(JCR *jcr, pid_t pid, uint32_t wait);
-void stop_child_timer(btimer_t *wid);
-btimer_t *start_thread_timer(JCR *jcr, pthread_t tid, uint32_t wait);
-void stop_thread_timer(btimer_t *wid);
-btimer_t *start_bsock_timer(BSOCK *bs, uint32_t wait);
-void stop_bsock_timer(btimer_t *wid);
+DLL_IMP_EXP btimer_t *start_child_timer(JCR *jcr, pid_t pid, uint32_t wait);
+DLL_IMP_EXP void stop_child_timer(btimer_t *wid);
+DLL_IMP_EXP btimer_t *start_thread_timer(JCR *jcr, pthread_t tid, uint32_t wait);
+DLL_IMP_EXP void stop_thread_timer(btimer_t *wid);
+DLL_IMP_EXP btimer_t *start_bsock_timer(BSOCK *bs, uint32_t wait);
+DLL_IMP_EXP void stop_bsock_timer(btimer_t *wid);
 
 /* tls.c */
-TLS_CONTEXT *new_tls_context(const char *ca_certfile,
+DLL_IMP_EXP TLS_CONTEXT *new_tls_context(const char *ca_certfile,
                              const char *ca_certdir,
                              const char *crlfile,
                              const char *certfile,
@@ -383,61 +383,61 @@ TLS_CONTEXT *new_tls_context(const char *ca_certfile,
                              const char *dhfile,
                              const char *cipherlist,
                              bool verify_peer);
-void free_tls_context(TLS_CONTEXT *ctx);
+DLL_IMP_EXP void free_tls_context(TLS_CONTEXT *ctx);
 #ifdef HAVE_TLS
-bool tls_postconnect_verify_host(JCR *jcr, TLS_CONNECTION *tls_conn,
+DLL_IMP_EXP bool tls_postconnect_verify_host(JCR *jcr, TLS_CONNECTION *tls_conn,
                                  const char *host);
-bool tls_postconnect_verify_cn(JCR *jcr, TLS_CONNECTION *tls_conn,
+DLL_IMP_EXP bool tls_postconnect_verify_cn(JCR *jcr, TLS_CONNECTION *tls_conn,
                                alist *verify_list);
-TLS_CONNECTION *new_tls_connection(TLS_CONTEXT *ctx, int fd, bool server);
-bool tls_bsock_accept(BSOCK *bsock);
-int tls_bsock_writen(BSOCK *bsock, char *ptr, int32_t nbytes);
-int tls_bsock_readn(BSOCK *bsock, char *ptr, int32_t nbytes);
+DLL_IMP_EXP TLS_CONNECTION *new_tls_connection(TLS_CONTEXT *ctx, int fd, bool server);
+DLL_IMP_EXP bool tls_bsock_accept(BSOCK *bsock);
+DLL_IMP_EXP int tls_bsock_writen(BSOCK *bsock, char *ptr, int32_t nbytes);
+DLL_IMP_EXP int tls_bsock_readn(BSOCK *bsock, char *ptr, int32_t nbytes);
 #endif /* HAVE_TLS */
-bool tls_bsock_connect(BSOCK *bsock);
-void tls_bsock_shutdown(BSOCK *bsock);
-void free_tls_connection(TLS_CONNECTION *tls_conn);
-bool get_tls_require(TLS_CONTEXT *ctx);
-void set_tls_require(TLS_CONTEXT *ctx, bool value);
-bool get_tls_enable(TLS_CONTEXT *ctx);
-void set_tls_enable(TLS_CONTEXT *ctx, bool value);
-bool get_tls_verify_peer(TLS_CONTEXT *ctx);
+DLL_IMP_EXP bool tls_bsock_connect(BSOCK *bsock);
+DLL_IMP_EXP void tls_bsock_shutdown(BSOCK *bsock);
+DLL_IMP_EXP void free_tls_connection(TLS_CONNECTION *tls_conn);
+DLL_IMP_EXP bool get_tls_require(TLS_CONTEXT *ctx);
+DLL_IMP_EXP void set_tls_require(TLS_CONTEXT *ctx, bool value);
+DLL_IMP_EXP bool get_tls_enable(TLS_CONTEXT *ctx);
+DLL_IMP_EXP void set_tls_enable(TLS_CONTEXT *ctx, bool value);
+DLL_IMP_EXP bool get_tls_verify_peer(TLS_CONTEXT *ctx);
 
 /* util.c */
-void escape_string(POOL_MEM &snew, char *old, int len);
-bool is_buf_zero(char *buf, int len);
-void lcase(char *str);
-void bash_spaces(char *str);
-void bash_spaces(POOL_MEM &pm);
-void unbash_spaces(char *str);
-void unbash_spaces(POOL_MEM &pm);
-const char* indent_multiline_string(POOL_MEM &resultbuffer, const char *multilinestring, const char *separator);
-char *encode_time(utime_t time, char *buf);
-bool convert_timeout_to_timespec(timespec &timeout, int timeout_in_seconds);
-char *encode_mode(mode_t mode, char *buf);
-int do_shell_expansion(char *name, int name_len);
-void jobstatus_to_ascii(int JobStatus, char *msg, int maxlen);
-void jobstatus_to_ascii_gui(int JobStatus, char *msg, int maxlen);
-int run_program(char *prog, int wait, POOLMEM *&results);
-int run_program_full_output(char *prog, int wait, POOLMEM *&results);
-char *action_on_purge_to_string(int aop, POOL_MEM &ret);
-const char *job_type_to_str(int type);
-const char *job_status_to_str(int stat);
-const char *job_level_to_str(int level);
-const char *volume_status_to_str(const char *status);
-void make_session_key(char *key, char *seed, int mode);
-void encode_session_key(char *encode, char *session, char *key, int maxlen);
-void decode_session_key(char *decode, char *session, char *key, int maxlen);
-POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to, job_code_callback_t job_code_callback = NULL);
-void set_working_directory(char *wd);
-const char *last_path_separator(const char *str);
+DLL_IMP_EXP void escape_string(POOL_MEM &snew, char *old, int len);
+DLL_IMP_EXP bool is_buf_zero(char *buf, int len);
+DLL_IMP_EXP void lcase(char *str);
+DLL_IMP_EXP void bash_spaces(char *str);
+DLL_IMP_EXP void bash_spaces(POOL_MEM &pm);
+DLL_IMP_EXP void unbash_spaces(char *str);
+DLL_IMP_EXP void unbash_spaces(POOL_MEM &pm);
+DLL_IMP_EXP const char* indent_multiline_string(POOL_MEM &resultbuffer, const char *multilinestring, const char *separator);
+DLL_IMP_EXP char *encode_time(utime_t time, char *buf);
+DLL_IMP_EXP bool convert_timeout_to_timespec(timespec &timeout, int timeout_in_seconds);
+DLL_IMP_EXP char *encode_mode(mode_t mode, char *buf);
+DLL_IMP_EXP int do_shell_expansion(char *name, int name_len);
+DLL_IMP_EXP void jobstatus_to_ascii(int JobStatus, char *msg, int maxlen);
+DLL_IMP_EXP void jobstatus_to_ascii_gui(int JobStatus, char *msg, int maxlen);
+DLL_IMP_EXP int run_program(char *prog, int wait, POOLMEM *&results);
+DLL_IMP_EXP int run_program_full_output(char *prog, int wait, POOLMEM *&results);
+DLL_IMP_EXP char *action_on_purge_to_string(int aop, POOL_MEM &ret);
+DLL_IMP_EXP const char *job_type_to_str(int type);
+DLL_IMP_EXP const char *job_status_to_str(int stat);
+DLL_IMP_EXP const char *job_level_to_str(int level);
+DLL_IMP_EXP const char *volume_status_to_str(const char *status);
+DLL_IMP_EXP void make_session_key(char *key, char *seed, int mode);
+DLL_IMP_EXP void encode_session_key(char *encode, char *session, char *key, int maxlen);
+DLL_IMP_EXP void decode_session_key(char *decode, char *session, char *key, int maxlen);
+DLL_IMP_EXP POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to, job_code_callback_t job_code_callback = NULL);
+DLL_IMP_EXP void set_working_directory(char *wd);
+DLL_IMP_EXP const char *last_path_separator(const char *str);
 
 /* watchdog.c */
-int start_watchdog(void);
-int stop_watchdog(void);
-watchdog_t *new_watchdog(void);
-bool register_watchdog(watchdog_t *wd);
-bool unregister_watchdog(watchdog_t *wd);
-bool is_watchdog();
+DLL_IMP_EXP int start_watchdog(void);
+DLL_IMP_EXP int stop_watchdog(void);
+DLL_IMP_EXP watchdog_t *new_watchdog(void);
+DLL_IMP_EXP bool register_watchdog(watchdog_t *wd);
+DLL_IMP_EXP bool unregister_watchdog(watchdog_t *wd);
+DLL_IMP_EXP bool is_watchdog();
 
 #endif /* __LIBPROTOS_H */
diff --git a/src/lib/rwlock.h b/src/lib/rwlock.h
index d7d8cea79ed..5588b7731fa 100644
--- a/src/lib/rwlock.h
+++ b/src/lib/rwlock.h
@@ -62,16 +62,16 @@ typedef struct s_rwsteal_tag {
 /**
  * read/write lock prototypes
  */
-extern int rwl_init(brwlock_t *rwl, int priority = 0);
-extern int rwl_destroy(brwlock_t *rwl);
-extern bool rwl_is_init(brwlock_t *rwl);
-extern int rwl_readlock(brwlock_t *rwl);
-extern int rwl_readtrylock(brwlock_t *rwl);
-extern int rwl_readunlock(brwlock_t *rwl);
-extern int rwl_writelock_p(brwlock_t *rwl,
+DLL_IMP_EXP extern int rwl_init(brwlock_t *rwl, int priority = 0);
+DLL_IMP_EXP extern int rwl_destroy(brwlock_t *rwl);
+DLL_IMP_EXP extern bool rwl_is_init(brwlock_t *rwl);
+DLL_IMP_EXP extern int rwl_readlock(brwlock_t *rwl);
+DLL_IMP_EXP extern int rwl_readtrylock(brwlock_t *rwl);
+DLL_IMP_EXP extern int rwl_readunlock(brwlock_t *rwl);
+DLL_IMP_EXP extern int rwl_writelock_p(brwlock_t *rwl,
                            const char *file = "*unknown*",
                            int line = 0);
-extern int rwl_writetrylock(brwlock_t *rwl);
-extern int rwl_writeunlock(brwlock_t *rwl);
+DLL_IMP_EXP extern int rwl_writetrylock(brwlock_t *rwl);
+DLL_IMP_EXP extern int rwl_writeunlock(brwlock_t *rwl);
 
 #endif /* __RWLOCK_H */
diff --git a/src/lib/smartall.h b/src/lib/smartall.h
index cdf3059a8cf..3c89556a11d 100644
--- a/src/lib/smartall.h
+++ b/src/lib/smartall.h
@@ -38,17 +38,17 @@ extern uint32_t DLL_IMP_EXP sm_buffers;
 #define SMARTALLOC SMARTALLOC
 
 
-extern void *sm_malloc(const char *fname, int lineno, unsigned int nbytes),
+DLL_IMP_EXP extern void *sm_malloc(const char *fname, int lineno, unsigned int nbytes),
             *sm_calloc(const char *fname, int lineno,
                 unsigned int nelem, unsigned int elsize),
             *sm_realloc(const char *fname, int lineno, void *ptr, unsigned int size),
             *actuallymalloc(unsigned int size),
             *actuallycalloc(unsigned int nelem, unsigned int elsize),
             *actuallyrealloc(void *ptr, unsigned int size);
-extern void sm_free(const char *fname, int lineno, void *fp);
-extern void actuallyfree(void *cp),
+DLL_IMP_EXP extern void sm_free(const char *fname, int lineno, void *fp);
+DLL_IMP_EXP extern void actuallyfree(void *cp),
             sm_dump(bool bufdump, bool in_use=false), sm_static(int mode);
-extern void sm_new_owner(const char *fname, int lineno, char *buf);
+DLL_IMP_EXP extern void sm_new_owner(const char *fname, int lineno, char *buf);
 
 #ifdef SMCHECK
 #define Dsm_check(lvl) if ((lvl)<=debug_level) sm_check(__FILE__, __LINE__, true)
diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt
index 63dd99228a9..a29e8d2f6ef 100644
--- a/src/tools/CMakeLists.txt
+++ b/src/tools/CMakeLists.txt
@@ -35,21 +35,29 @@ target_link_libraries(bregex bareos bareosfind ${JANSSON_LIBRARIES})
 add_executable(bwild bwild.cc)
 target_link_libraries(bwild bareos ${JANSSON_LIBRARIES})
 
-add_executable(bpluginfo bpluginfo.cc)
-target_link_libraries(bpluginfo bareos ${DL_LIBRARIES} ${JANSSON_LIBRARIES})
-
 add_executable(bscrypto bscrypto.cc)
 target_link_libraries(bscrypto bareos ${JANSSON_LIBRARIES})
 
-add_executable(timelimit timelimit.cc)
+IF(NOT ${HAVE_WIN32})
+   add_executable(bpluginfo bpluginfo.cc)
+   target_link_libraries(bpluginfo bareos ${DL_LIBRARIES} ${JANSSON_LIBRARIES})
+
+   add_executable(timelimit timelimit.cc)
+ENDIF()
 
 set (TOOLS_BIN
-   bsmtp bwild bregex timelimit
+   bsmtp bwild bregex
    )
+
 set (TOOLS_SBIN
-   bpluginfo bscrypto bwild bregex timelimit
+   bscrypto bwild bregex
    )
 
+IF(NOT ${HAVE_WIN32})
+   LIST(APPEND TOOLS_BIN  timelimit)
+   LIST(APPEND TOOLS_SBIN bpluginfo timelimit)
+ENDIF()
+
 INSTALL(TARGETS ${TOOLS_BIN} DESTINATION "${bindir}")
 INSTALL(TARGETS ${TOOLS_SBIN} DESTINATION "${sbindir}")
 
diff --git a/src/win32/compat/compat.cc b/src/win32/compat/compat.cc
index 00425a4ab49..b35d4d1b67c 100644
--- a/src/win32/compat/compat.cc
+++ b/src/win32/compat/compat.cc
@@ -412,7 +412,7 @@ static inline void conv_unix_to_vss_win32_path(const char *name, char *win32_nam
 /**
  * Conversion of a Unix filename to a Win32 filename
  */
-void unix_name_to_win32(POOLMEM *&win32_name, const char *name)
+DLL_IMP_EXP void unix_name_to_win32(POOLMEM *&win32_name, const char *name)
 {
    DWORD dwSize;
 
diff --git a/src/win32/compat/include/compat.h b/src/win32/compat/include/compat.h
index 59f22896de0..5b753b98004 100644
--- a/src/win32/compat/include/compat.h
+++ b/src/win32/compat/include/compat.h
@@ -35,6 +35,22 @@
 #define _STAT_H         /* don't pull in MinGW stat.h */
 #endif
 
+
+#if defined(BUILDING_DLL)
+#define DLL_IMP_EXP _declspec(dllexport)
+#define CATS_IMP_EXP _declspec(dllexport)
+#define SD_IMP_EXP _declspec(dllexport)
+#elif defined(USING_DLL)
+#define DLL_IMP_EXP _declspec(dllimport)
+#define CATS_IMP_EXP _declspec(dllimport)
+#define SD_IMP_EXP _declspec(dllimport)
+#else
+#define DLL_IMP_EXP
+#define CATS_IMP_EXP
+#define SD_IMP_EXP
+#endif
+
+
 #ifndef _STAT_DEFINED
 #define _STAT_DEFINED 1 /* don't pull in MinGW struct stat from wchar.h */
 #endif
@@ -239,7 +255,7 @@ typedef bool (*t_pVSSPathConvert)(const char *szFilePath, char *szShadowPath, in
 typedef bool (*t_pVSSPathConvertW)(const wchar_t *szFilePath, wchar_t *szShadowPath, int nBuflen);
 bool SetVSSPathConvert(t_pVSSPathConvert pPathConvert, t_pVSSPathConvertW pPathConvertW);
 
-int lchown(const char *, uid_t uid, gid_t gid);
+DLL_IMP_EXP int lchown(const char *, uid_t uid, gid_t gid);
 int chown(const char *, uid_t uid, gid_t gid);
 #define O_NONBLOCK   04000
 #define F_GETFL      3
@@ -277,24 +293,24 @@ int utime(const char *filename, struct utimbuf *buf);
 #define HAVE_OLD_SOCKOPT
 
 struct timespec;
-int readdir(unsigned int fd, struct dirent *dirp, unsigned int count);
-int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
-long int random(void);
-void srandom(unsigned int seed);
-int lstat(const char *filename, struct stat *sb);
-int stat(const char *file, struct stat *sb);
-long pathconf(const char *path, int name);
-ssize_t readlink(const char *path, char *buf, size_t bufsiz);
-int win32_symlink(const char *name1, const char *name2, _dev_t st_rdev);
-int link(const char *existing, const char *newfile);
+DLL_IMP_EXP int readdir(unsigned int fd, struct dirent *dirp, unsigned int count);
+DLL_IMP_EXP int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
+DLL_IMP_EXP long int random(void);
+DLL_IMP_EXP void srandom(unsigned int seed);
+DLL_IMP_EXP int lstat(const char *filename, struct stat *sb);
+DLL_IMP_EXP int stat(const char *file, struct stat *sb);
+DLL_IMP_EXP long pathconf(const char *path, int name);
+DLL_IMP_EXP ssize_t readlink(const char *path, char *buf, size_t bufsiz);
+DLL_IMP_EXP int win32_symlink(const char *name1, const char *name2, _dev_t st_rdev);
+DLL_IMP_EXP int link(const char *existing, const char *newfile);
 
 #define _PC_PATH_MAX 1
 #define _PC_NAME_MAX 2
 
 int geteuid();
 
-DIR *opendir(const char *filename);
-int closedir(DIR *dir);
+DLL_IMP_EXP DIR *opendir(const char *filename);
+DLL_IMP_EXP int closedir(DIR *dir);
 
 struct passwd {
     char *foo;
@@ -344,12 +360,12 @@ extern "C" void *  __cdecl _alloca(size_t);
 #define getcwd win32_getcwd
 #define chdir win32_chdir
 #define fputs win32_fputs
-char *win32_getcwd(char *buf, int maxlen);
-int win32_chdir(const char *buf);
-int win32_mkdir(const char *buf);
-int win32_fputs(const char *string, FILE *stream);
-int win32_unlink(const char *filename);
-int win32_chmod(const char *, mode_t, _dev_t);
+DLL_IMP_EXP char *win32_getcwd(char *buf, int maxlen);
+DLL_IMP_EXP int win32_chdir(const char *buf);
+DLL_IMP_EXP int win32_mkdir(const char *buf);
+DLL_IMP_EXP int win32_fputs(const char *string, FILE *stream);
+DLL_IMP_EXP int win32_unlink(const char *filename);
+DLL_IMP_EXP int win32_chmod(const char *, mode_t, _dev_t);
 
 char* win32_cgets (char* buffer, int len);
 
@@ -405,9 +421,9 @@ inline unsigned long ffs(unsigned long word)
 #define  ffs   __builtin_ffs
 #endif
 
-bool win32_get_vmp_devicename(const char *filename, POOLMEM *&device);
+DLL_IMP_EXP bool win32_get_vmp_devicename(const char *filename, POOLMEM *&device);
 int win32_ftruncate(int fd, int64_t length);
-bool win32_restore_file_attributes(POOLMEM *ofname,
+DLL_IMP_EXP bool win32_restore_file_attributes(POOLMEM *ofname,
                                    HANDLE handle,
                                    WIN32_FILE_ATTRIBUTE_DATA *atts);
 
diff --git a/src/win32/compat/include/dlfcn.h b/src/win32/compat/include/dlfcn.h
index 9cfd44a97d3..3299f9e49c8 100644
--- a/src/win32/compat/include/dlfcn.h
+++ b/src/win32/compat/include/dlfcn.h
@@ -32,9 +32,9 @@
 #define RTLD_GLOBAL             0x00100         /* Export symbols to others */
 #define RTLD_LOCAL              0x00000         /* Symbols are only available to group members */
 
-void *dlopen(const char *file, int mode);
-void *dlsym(void *handle, const char *name);
-int dlclose(void *handle);
-char *dlerror(void);
+DLL_IMP_EXP void *dlopen(const char *file, int mode);
+DLL_IMP_EXP void *dlsym(void *handle, const char *name);
+DLL_IMP_EXP int dlclose(void *handle);
+DLL_IMP_EXP char *dlerror(void);
 
 #endif /* __DLFCN_H_ */
diff --git a/src/win32/include/winapi.h b/src/win32/include/winapi.h
index 29f1c827202..f8a5008e033 100644
--- a/src/win32/include/winapi.h
+++ b/src/win32/include/winapi.h
@@ -67,7 +67,7 @@ int UTF8_2_wchar(POOLMEM *&pszUCS, const char *pszUTF);
 int wchar_2_UTF8(char *pszUTF, const wchar_t *pszUCS, int cchChar);
 BSTR str_2_BSTR(const char *pSrc);
 char *BSTR_2_str(const BSTR pSrc);
-int make_win32_path_UTF8_2_wchar(POOLMEM *&pszUCS, const char *pszUTF, BOOL* pBIsRawPath = NULL);
+DLL_IMP_EXP int make_win32_path_UTF8_2_wchar(POOLMEM *&pszUCS, const char *pszUTF, BOOL* pBIsRawPath = NULL);
 
 // init with win9x, but maybe set to NT in InitWinAPI
 extern DWORD DLL_IMP_EXP g_platform_id;
@@ -211,7 +211,7 @@ extern t_GetLogicalDriveStringsW DLL_IMP_EXP p_GetLogicalDriveStringsW;
 
 extern t_AttachConsole DLL_IMP_EXP p_AttachConsole;
 
-void InitWinAPIWrapper();
+DLL_IMP_EXP void InitWinAPIWrapper();
 
 /*
  * In SHFOLDER.DLL on older systems, and now SHELL32.DLL