Support gcc7 glib2.25 openssl 1.1 and fedora26

Change-Id: I05e1685765ed24345ff8af6cf3608d674fa5ab05

Makefile

+NEED_LIBPROTOC=1
 include config.mk
+
+# Notes on the flags:
+# 1. -fno-omit-frame-pointer is required by perf/tcmalloc-profiler which use frame pointers by default
+# 2. -D__const__= MUST be added in user's gcc compilation as well to avoid the over-optimization on TLS variables by gcc
+# 3. Removed -Werror to not block compilation for non-vital warnings, especially when the code is compiled on newer systems. If you use the code in production, add -Werror back
 CPPFLAGS=-DBTHREAD_USE_FAST_PTHREAD_MUTEX -D__const__= -D_GNU_SOURCE -DUSE_SYMBOLIZE -DNO_TCMALLOC -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS -DBRPC_REVISION=\"$(shell git rev-parse --short HEAD)\"
-#Add -fno-omit-frame-pointer: perf/tcmalloc-profiler uses frame pointers by default
-CXXFLAGS=$(CPPFLAGS) -O2 -g -pipe -Wall -W -Werror -fPIC -fstrict-aliasing -Wno-invalid-offsetof -Wno-unused-parameter -fno-omit-frame-pointer -std=c++0x -include brpc/config.h
-CFLAGS=$(CPPFLAGS) -O2 -g -pipe -Wall -W -Werror -fPIC -fstrict-aliasing -Wno-unused-parameter -fno-omit-frame-pointer
+CXXFLAGS=$(CPPFLAGS) -O2 -g -pipe -Wall -W -fPIC -fstrict-aliasing -Wno-invalid-offsetof -Wno-unused-parameter -fno-omit-frame-pointer -std=c++0x -include brpc/config.h
+CFLAGS=$(CPPFLAGS) -O2 -g -pipe -Wall -W -fPIC -fstrict-aliasing -Wno-unused-parameter -fno-omit-frame-pointer
 HDRPATHS=-I. $(addprefix -I, $(HDRS))
 LIBPATHS = $(addprefix -L, $(LIBS))
 SRCEXTS = .c .cc .cpp .proto
 HDREXTS = .h .hpp
-#dyanmic linking of libprotoc.so crashes on ubuntu when protoc-gen-mcpack is invoked
-STATIC_LINKINGS += -lprotoc
+
+ifeq ($(shell test $(shell $(CXX) -dumpversion) -ge 7; echo $$?),0)
+CXXFLAGS+=-Wno-aligned-new
+endif
 
 BASE_SOURCES = \
     base/third_party/dmg_fp/g_fmt.cc \

base/errno.cpp

@@ -15,13 +15,13 @@
 
 namespace base {
 
-static const int ERRNO_BEGIN = -32768;
-static const int ERRNO_END = 32768;
-const char* errno_desc[ERRNO_END - ERRNO_BEGIN] = {};
-pthread_mutex_t modify_desc_mutex = PTHREAD_MUTEX_INITIALIZER;
+const int ERRNO_BEGIN = -32768;
+const int ERRNO_END = 32768;
+static const char* errno_desc[ERRNO_END - ERRNO_BEGIN] = {};
+static pthread_mutex_t modify_desc_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-static const size_t UNKNOWN_ERROR_BUFSIZE = 32;
-__thread char unknown_error_buf[UNKNOWN_ERROR_BUFSIZE];
+const size_t ERROR_BUFSIZE = 64;
+__thread char tls_error_buf[ERROR_BUFSIZE];
 
 int DescribeCustomizedErrno(
     int error_code, const char* error_name, const char* description) {
@@ -32,21 +32,19 @@ int DescribeCustomizedErrno(
               error_name, error_code);
     }
     const char* desc = errno_desc[error_code - ERRNO_BEGIN];
-    if (!desc) {
-        // g++ 4.8.2 reports nonnull warning for directly using NULL as the
-        // second parameter to strerror_r which is totally valid.
-        char* cheat_nonnull = NULL;
-        desc = strerror_r(error_code, cheat_nonnull, 0);
-    }
     if (desc) {
         if (strcmp(desc, description) == 0) {
             fprintf(stderr, "WARNING: Detected shared library loading\n");
-            return 0;
+            return -1;
         }
+    } else {
+        desc = strerror_r(error_code, tls_error_buf, ERROR_BUFSIZE);
+        if (desc && strncmp(desc, "Unknown error", 13) != 0) {
             error(EXIT_FAILURE, 0,
                     "Fail to define %s(%d) which is already defined as `%s', abort.",
                     error_name, error_code, desc);
         }
+    }
     errno_desc[error_code - ERRNO_BEGIN] = description;
     return 0;  // must
 }
@@ -55,24 +53,21 @@ int DescribeCustomizedErrno(
 
 const char* berror(int error_code) {
     if (error_code == -1) {
-        return "General Error(-1)";
+        return "General Error -1";
     }
     if (error_code >= base::ERRNO_BEGIN && error_code < base::ERRNO_END) {
         const char* s = base::errno_desc[error_code - base::ERRNO_BEGIN];
         if (s) {
             return s;
         }
-        // g++ 4.8.2 reports nonnull warning for directly using NULL as the
-        // second parameter to strerror_r which is totally valid.
-        char* cheat_nonnull = NULL;
-        s = strerror_r(error_code, cheat_nonnull, 0);
+        s = strerror_r(error_code, base::tls_error_buf, base::ERROR_BUFSIZE);
         if (s) {  // strerror_r returns NULL if error_code is unknown
             return s;
         }
     }
-    snprintf(base::unknown_error_buf, base::UNKNOWN_ERROR_BUFSIZE,
-             "Unknown Error(%d)", error_code);
-    return base::unknown_error_buf;
+    snprintf(base::tls_error_buf, base::ERROR_BUFSIZE,
+             "Unknown Error %d", error_code);
+    return base::tls_error_buf;
 }
 
 const char* berror() {

base/files/file_enumerator_posix.cc

@@ -129,9 +129,17 @@ bool FileEnumerator::ReadDirectory(std::vector<FileInfo>* entries,
          additional space for pathname may be needed
 #endif
 
-  struct dirent dent_buf;
   struct dirent* dent;
+  // readdir_r is marked as deprecated since glibc 2.24. 
+  // Using readdir on _different_ DIR* object is already thread-safe in
+  // most modern libc implementations.
+#if defined(__GLIBC__) &&  \
+    (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 24))
+  while ((dent = readdir(dir))) {
+#else
+  struct dirent dent_buf;
   while (readdir_r(dir, &dent_buf, &dent) == 0 && dent) {
+#endif
     FileInfo info;
     info.filename_ = FilePath(dent->d_name);
 

base/iobuf.h

@@ -652,15 +652,17 @@ private:
 }  // namespace base
 
 // Specialize std::swap for IOBuf
+#if __cplusplus < 201103L  // < C++11
+#include <algorithm>  // std::swap until C++11
+#else
+#include <utility>  // std::swap since C++11
+#endif  // __cplusplus < 201103L
 namespace std {
-template <class T> void swap ( T& a, T& b );
-
 template <>
 inline void swap(base::IOBuf& a, base::IOBuf& b) {
     return a.swap(b);
 }
-
-};
+} // namespace std
 
 #include "base/iobuf_inl.h"
 

base/safe_strerror_posix.cc

@@ -9,7 +9,11 @@
 #include <stdio.h>
 #include <string.h>
 
-#define USE_HISTORICAL_STRERRO_R (defined(__GLIBC__) || defined(OS_NACL))
+#if defined(__GLIBC__) || defined(OS_NACL)
+# define USE_HISTORICAL_STRERRO_R 1
+#else
+# define USE_HISTORICAL_STRERRO_R 0
+#endif
 
 #if USE_HISTORICAL_STRERRO_R && defined(__GNUC__)
 // GCC will complain about the unused second wrap function unless we tell it

base/ssl_compat.h

+/* Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved
+ * Author: The baidu-rpc authors (pbrpc@baidu.com)
+ * Date: Sun Aug 20 11:39:01 CST 2017
+ */
+
+#ifndef BRPC_BASE_SSL_COMPAT_H
+#define BRPC_BASE_SSL_COMPAT_H
+
+#include <openssl/opensslv.h>
+
+/* Provide functions added in newer openssl but missing in older versions */
+
+#if defined(__cplusplus) || __STDC_VERSION__ >= 199901L/*C99*/
+#define BRPC_INLINE inline
+#else
+#define BRPC_INLINE static
+#endif
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+
+#include <string.h>
+#include <openssl/engine.h>
+
+BRPC_INLINE void *OPENSSL_zalloc(size_t num) {
+    void *ret = OPENSSL_malloc(num);
+
+    if (ret != NULL)
+        memset(ret, 0, num);
+    return ret;
+}
+
+BRPC_INLINE int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d) {
+    /* If the fields n and e in r are NULL, the corresponding input
+     * parameters MUST be non-NULL for n and e.  d may be
+     * left NULL (in case only the public key is used).
+     */
+    if ((r->n == NULL && n == NULL)
+            || (r->e == NULL && e == NULL))
+        return 0;
+
+    if (n != NULL) {
+        BN_free(r->n);
+        r->n = n;
+    }
+    if (e != NULL) {
+        BN_free(r->e);
+        r->e = e;
+    }
+    if (d != NULL) {
+        BN_free(r->d);
+        r->d = d;
+    }
+
+    return 1;
+}
+
+BRPC_INLINE int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q) {
+    /* If the fields p and q in r are NULL, the corresponding input
+     * parameters MUST be non-NULL.
+     */
+    if ((r->p == NULL && p == NULL)
+            || (r->q == NULL && q == NULL))
+        return 0;
+
+    if (p != NULL) {
+        BN_free(r->p);
+        r->p = p;
+    }
+    if (q != NULL) {
+        BN_free(r->q);
+        r->q = q;
+    }
+
+    return 1;
+}
+
+BRPC_INLINE int RSA_set0_crt_params(RSA *r, BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp) {
+    /* If the fields dmp1, dmq1 and iqmp in r are NULL, the corresponding input
+     * parameters MUST be non-NULL.
+     */
+    if ((r->dmp1 == NULL && dmp1 == NULL)
+            || (r->dmq1 == NULL && dmq1 == NULL)
+            || (r->iqmp == NULL && iqmp == NULL))
+        return 0;
+
+    if (dmp1 != NULL) {
+        BN_free(r->dmp1);
+        r->dmp1 = dmp1;
+    }
+    if (dmq1 != NULL) {
+        BN_free(r->dmq1);
+        r->dmq1 = dmq1;
+    }
+    if (iqmp != NULL) {
+        BN_free(r->iqmp);
+        r->iqmp = iqmp;
+    }
+
+    return 1;
+}
+
+BRPC_INLINE void RSA_get0_key(const RSA *r, 
+        const BIGNUM **n, const BIGNUM **e, const BIGNUM **d) {
+    if (n != NULL)
+        *n = r->n;
+    if (e != NULL)
+        *e = r->e;
+    if (d != NULL)
+        *d = r->d;
+}
+
+BRPC_INLINE void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q) {
+    if (p != NULL)
+        *p = r->p;
+    if (q != NULL)
+        *q = r->q;
+}
+
+BRPC_INLINE void RSA_get0_crt_params(const RSA *r,
+        const BIGNUM **dmp1, const BIGNUM **dmq1,
+        const BIGNUM **iqmp) {
+    if (dmp1 != NULL)
+        *dmp1 = r->dmp1;
+    if (dmq1 != NULL)
+        *dmq1 = r->dmq1;
+    if (iqmp != NULL)
+        *iqmp = r->iqmp;
+}
+
+BRPC_INLINE void DSA_get0_pqg(const DSA *d,
+        const BIGNUM **p, const BIGNUM **q, const BIGNUM **g) {
+    if (p != NULL)
+        *p = d->p;
+    if (q != NULL)
+        *q = d->q;
+    if (g != NULL)
+        *g = d->g;
+}
+
+BRPC_INLINE int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g) {
+    /* If the fields p, q and g in d are NULL, the corresponding input
+     * parameters MUST be non-NULL.
+     */
+    if ((d->p == NULL && p == NULL)
+            || (d->q == NULL && q == NULL)
+            || (d->g == NULL && g == NULL))
+        return 0;
+
+    if (p != NULL) {
+        BN_free(d->p);
+        d->p = p;
+    }
+    if (q != NULL) {
+        BN_free(d->q);
+        d->q = q;
+    }
+    if (g != NULL) {
+        BN_free(d->g);
+        d->g = g;
+    }
+
+    return 1;
+}
+
+BRPC_INLINE void DSA_get0_key(const DSA *d,
+        const BIGNUM **pub_key, const BIGNUM **priv_key) {
+    if (pub_key != NULL)
+        *pub_key = d->pub_key;
+    if (priv_key != NULL)
+        *priv_key = d->priv_key;
+}
+
+BRPC_INLINE int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key) {
+    /* If the field pub_key in d is NULL, the corresponding input
+     * parameters MUST be non-NULL.  The priv_key field may
+     * be left NULL.
+     */
+    if (d->pub_key == NULL && pub_key == NULL)
+        return 0;
+
+    if (pub_key != NULL) {
+        BN_free(d->pub_key);
+        d->pub_key = pub_key;
+    }
+    if (priv_key != NULL) {
+        BN_free(d->priv_key);
+        d->priv_key = priv_key;
+    }
+
+    return 1;
+}
+
+BRPC_INLINE void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps) {
+    if (pr != NULL)
+        *pr = sig->r;
+    if (ps != NULL)
+        *ps = sig->s;
+}
+
+BRPC_INLINE int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s) {
+    if (r == NULL || s == NULL)
+        return 0;
+    BN_clear_free(sig->r);
+    BN_clear_free(sig->s);
+    sig->r = r;
+    sig->s = s;
+    return 1;
+}
+
+BRPC_INLINE void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps) {
+    if (pr != NULL)
+        *pr = sig->r;
+    if (ps != NULL)
+        *ps = sig->s;
+}
+
+BRPC_INLINE int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s) {
+    if (r == NULL || s == NULL)
+        return 0;
+    BN_clear_free(sig->r);
+    BN_clear_free(sig->s);
+    sig->r = r;
+    sig->s = s;
+    return 1;
+}
+
+BRPC_INLINE void DH_get0_pqg(const DH *dh,
+        const BIGNUM **p, const BIGNUM **q, const BIGNUM **g) {
+    if (p != NULL)
+        *p = dh->p;
+    if (q != NULL)
+        *q = dh->q;
+    if (g != NULL)
+        *g = dh->g;
+}
+
+BRPC_INLINE int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g) {
+    /* If the fields p and g in d are NULL, the corresponding input
+     * parameters MUST be non-NULL.  q may remain NULL.
+     */
+    if ((dh->p == NULL && p == NULL)
+            || (dh->g == NULL && g == NULL))
+        return 0;
+
+    if (p != NULL) {
+        BN_free(dh->p);
+        dh->p = p;
+    }
+    if (q != NULL) {
+        BN_free(dh->q);
+        dh->q = q;
+    }
+    if (g != NULL) {
+        BN_free(dh->g);
+        dh->g = g;
+    }
+
+    if (q != NULL) {
+        dh->length = BN_num_bits(q);
+    }
+
+    return 1;
+}
+
+BRPC_INLINE void DH_get0_key(const DH *dh, const BIGNUM **pub_key, const BIGNUM **priv_key) {
+    if (pub_key != NULL)
+        *pub_key = dh->pub_key;
+    if (priv_key != NULL)
+        *priv_key = dh->priv_key;
+}
+
+BRPC_INLINE int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key) {
+    /* If the field pub_key in dh is NULL, the corresponding input
+     * parameters MUST be non-NULL.  The priv_key field may
+     * be left NULL.
+     */
+    if (dh->pub_key == NULL && pub_key == NULL)
+        return 0;
+
+    if (pub_key != NULL) {
+        BN_free(dh->pub_key);
+        dh->pub_key = pub_key;
+    }
+    if (priv_key != NULL) {
+        BN_free(dh->priv_key);
+        dh->priv_key = priv_key;
+    }
+
+    return 1;
+}
+
+BRPC_INLINE int DH_set_length(DH *dh, long length) {
+    dh->length = length;
+    return 1;
+}
+
+BRPC_INLINE const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx) {
+    return ctx->iv;
+}
+
+BRPC_INLINE unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx) {
+    return ctx->iv;
+}
+
+BRPC_INLINE EVP_MD_CTX *EVP_MD_CTX_new(void) {
+    return OPENSSL_zalloc(sizeof(EVP_MD_CTX));
+}
+
+BRPC_INLINE void EVP_MD_CTX_free(EVP_MD_CTX *ctx) {
+    EVP_MD_CTX_cleanup(ctx);
+    OPENSSL_free(ctx);
+}
+
+BRPC_INLINE RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth) {
+    RSA_METHOD *ret;
+
+    ret = OPENSSL_malloc(sizeof(RSA_METHOD));
+
+    if (ret != NULL) {
+        memcpy(ret, meth, sizeof(*meth));
+        ret->name = OPENSSL_strdup(meth->name);
+        if (ret->name == NULL) {
+            OPENSSL_free(ret);
+            return NULL;
+        }
+    }
+
+    return ret;
+}
+
+BRPC_INLINE int RSA_meth_set1_name(RSA_METHOD *meth, const char *name) {
+    char *tmpname;
+
+    tmpname = OPENSSL_strdup(name);
+    if (tmpname == NULL) {
+        return 0;
+    }
+
+    OPENSSL_free((char *)meth->name);
+    meth->name = tmpname;
+
+    return 1;
+}
+
+BRPC_INLINE int RSA_meth_set_priv_enc(RSA_METHOD *meth,
+        int (*priv_enc) (int flen, const unsigned char *from,
+            unsigned char *to, RSA *rsa,
+            int padding)) {
+    meth->rsa_priv_enc = priv_enc;
+    return 1;
+}
+
+BRPC_INLINE int RSA_meth_set_priv_dec(RSA_METHOD *meth,
+        int (*priv_dec) (int flen, const unsigned char *from,
+            unsigned char *to, RSA *rsa,
+            int padding)) {
+    meth->rsa_priv_dec = priv_dec;
+    return 1;
+}
+
+BRPC_INLINE int RSA_meth_set_finish(RSA_METHOD *meth, int (*finish) (RSA *rsa)) {
+    meth->finish = finish;
+    return 1;
+}
+
+BRPC_INLINE void RSA_meth_free(RSA_METHOD *meth) {
+    if (meth != NULL) {
+        OPENSSL_free((char *)meth->name);
+        OPENSSL_free(meth);
+    }
+}
+
+BRPC_INLINE int RSA_bits(const RSA *r) {
+    return (BN_num_bits(r->n));
+}
+
+BRPC_INLINE RSA *EVP_PKEY_get0_RSA(EVP_PKEY *pkey) {
+    if (pkey->type != EVP_PKEY_RSA) {
+        return NULL;
+    }
+    return pkey->pkey.rsa;
+}
+
+
+BRPC_INLINE HMAC_CTX *HMAC_CTX_new(void) {
+    HMAC_CTX *ctx = OPENSSL_malloc(sizeof(*ctx));
+    if (ctx != NULL) {
+        if (!HMAC_CTX_reset(ctx)) {
+            HMAC_CTX_free(ctx);
+            return NULL;
+        }
+    }
+    return ctx;
+}
+
+BRPC_INLINE void HMAC_CTX_free(HMAC_CTX *ctx) {
+    if (ctx != NULL) {
+        hmac_ctx_cleanup(ctx);
+        EVP_MD_CTX_free(ctx->i_ctx);
+        EVP_MD_CTX_free(ctx->o_ctx);
+        EVP_MD_CTX_free(ctx->md_ctx);
+        OPENSSL_free(ctx);
+    }
+}
+
+#endif /* OPENSSL_VERSION_NUMBER < 0x10100000L */
+
+#if OPENSSL_VERSION_NUMBER < 0x0090801fL
+BRPC_INLINE BIGNUM* get_rfc2409_prime_1024(BIGNUM* bn) {
+    static const unsigned char RFC2409_PRIME_1024[] = {
+        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
+        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
+        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
+        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
+        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
+        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
+        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
+        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
+        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
+        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE6,0x53,0x81,
+        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    };
+    return BN_bin2bn(RFC2409_PRIME_1024, sizeof(RFC2409_RPIME_1024), bn);
+}
+
+BRPC_INLINE BIGNUM* get_rfc3526_prime_2048(BIGNUM* bn);
+    static const unsigned char RFC3526_PRIME_2048[] = {
+        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
+        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
+        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
+        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
+        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
+        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
+        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
+        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
+        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
+        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
+        0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
+        0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
+        0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
+        0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
+        0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
+        0xCA,0x18,0x21,0x7C,0x32,0x90,0x5E,0x46,0x2E,0x36,0xCE,0x3B,
+        0xE3,0x9E,0x77,0x2C,0x18,0x0E,0x86,0x03,0x9B,0x27,0x83,0xA2,
+        0xEC,0x07,0xA2,0x8F,0xB5,0xC5,0x5D,0xF0,0x6F,0x4C,0x52,0xC9,
+        0xDE,0x2B,0xCB,0xF6,0x95,0x58,0x17,0x18,0x39,0x95,0x49,0x7C,
+        0xEA,0x95,0x6A,0xE5,0x15,0xD2,0x26,0x18,0x98,0xFA,0x05,0x10,
+        0x15,0x72,0x8E,0x5A,0x8A,0xAC,0xAA,0x68,0xFF,0xFF,0xFF,0xFF,
+        0xFF,0xFF,0xFF,0xFF,
+    };
+    return BN_bin2bn(RFC3526_PRIME_2048, sizeof(RFC3526_PRIME_2048), bn);
+}
+
+BRPC_INLINE BIGNUM* get_rfc3526_prime_4096(BIGNUM* bn) {
+    static const unsigned char RFC3526_PRIME_4096[] = {
+        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
+        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
+        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
+        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
+        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
+        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
+        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
+        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
+        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
+        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
+        0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
+        0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
+        0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
+        0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
+        0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
+        0xCA,0x18,0x21,0x7C,0x32,0x90,0x5E,0x46,0x2E,0x36,0xCE,0x3B,
+        0xE3,0x9E,0x77,0x2C,0x18,0x0E,0x86,0x03,0x9B,0x27,0x83,0xA2,
+        0xEC,0x07,0xA2,0x8F,0xB5,0xC5,0x5D,0xF0,0x6F,0x4C,0x52,0xC9,
+        0xDE,0x2B,0xCB,0xF6,0x95,0x58,0x17,0x18,0x39,0x95,0x49,0x7C,
+        0xEA,0x95,0x6A,0xE5,0x15,0xD2,0x26,0x18,0x98,0xFA,0x05,0x10,
+        0x15,0x72,0x8E,0x5A,0x8A,0xAA,0xC4,0x2D,0xAD,0x33,0x17,0x0D,
+        0x04,0x50,0x7A,0x33,0xA8,0x55,0x21,0xAB,0xDF,0x1C,0xBA,0x64,
+        0xEC,0xFB,0x85,0x04,0x58,0xDB,0xEF,0x0A,0x8A,0xEA,0x71,0x57,
+        0x5D,0x06,0x0C,0x7D,0xB3,0x97,0x0F,0x85,0xA6,0xE1,0xE4,0xC7,
+        0xAB,0xF5,0xAE,0x8C,0xDB,0x09,0x33,0xD7,0x1E,0x8C,0x94,0xE0,
+        0x4A,0x25,0x61,0x9D,0xCE,0xE3,0xD2,0x26,0x1A,0xD2,0xEE,0x6B,
+        0xF1,0x2F,0xFA,0x06,0xD9,0x8A,0x08,0x64,0xD8,0x76,0x02,0x73,
+        0x3E,0xC8,0x6A,0x64,0x52,0x1F,0x2B,0x18,0x17,0x7B,0x20,0x0C,
+        0xBB,0xE1,0x17,0x57,0x7A,0x61,0x5D,0x6C,0x77,0x09,0x88,0xC0,
+        0xBA,0xD9,0x46,0xE2,0x08,0xE2,0x4F,0xA0,0x74,0xE5,0xAB,0x31,
+        0x43,0xDB,0x5B,0xFC,0xE0,0xFD,0x10,0x8E,0x4B,0x82,0xD1,0x20,
+        0xA9,0x21,0x08,0x01,0x1A,0x72,0x3C,0x12,0xA7,0x87,0xE6,0xD7,
+        0x88,0x71,0x9A,0x10,0xBD,0xBA,0x5B,0x26,0x99,0xC3,0x27,0x18,
+        0x6A,0xF4,0xE2,0x3C,0x1A,0x94,0x68,0x34,0xB6,0x15,0x0B,0xDA,
+        0x25,0x83,0xE9,0xCA,0x2A,0xD4,0x4C,0xE8,0xDB,0xBB,0xC2,0xDB,
+        0x04,0xDE,0x8E,0xF9,0x2E,0x8E,0xFC,0x14,0x1F,0xBE,0xCA,0xA6,
+        0x28,0x7C,0x59,0x47,0x4E,0x6B,0xC0,0x5D,0x99,0xB2,0x96,0x4F,
+        0xA0,0x90,0xC3,0xA2,0x23,0x3B,0xA1,0x86,0x51,0x5B,0xE7,0xED,
+        0x1F,0x61,0x29,0x70,0xCE,0xE2,0xD7,0xAF,0xB8,0x1B,0xDD,0x76,
+        0x21,0x70,0x48,0x1C,0xD0,0x06,0x91,0x27,0xD5,0xB0,0x5A,0xA9,
+        0x93,0xB4,0xEA,0x98,0x8D,0x8F,0xDD,0xC1,0x86,0xFF,0xB7,0xDC,
+        0x90,0xA6,0xC0,0x8F,0x4D,0xF4,0x35,0xC9,0x34,0x06,0x31,0x99,
+        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+    };
+    return BN_bin2bn(RFC3526_PRIME_4096, sizeof(RFC3526_PRIME_4096), bn);
+}
+
+
+BRPC_INLINE BIGNUM* get_rfc3526_prime_8192(BIGNUM* bn) {
+    static const unsigned char RFC3526_PRIME_8192[] = {
+        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
+        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
+        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
+        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
+        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
+        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
+        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
+        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
+        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
+        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
+        0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
+        0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
+        0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
+        0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
+        0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
+        0xCA,0x18,0x21,0x7C,0x32,0x90,0x5E,0x46,0x2E,0x36,0xCE,0x3B,
+        0xE3,0x9E,0x77,0x2C,0x18,0x0E,0x86,0x03,0x9B,0x27,0x83,0xA2,
+        0xEC,0x07,0xA2,0x8F,0xB5,0xC5,0x5D,0xF0,0x6F,0x4C,0x52,0xC9,
+        0xDE,0x2B,0xCB,0xF6,0x95,0x58,0x17,0x18,0x39,0x95,0x49,0x7C,
+        0xEA,0x95,0x6A,0xE5,0x15,0xD2,0x26,0x18,0x98,0xFA,0x05,0x10,
+        0x15,0x72,0x8E,0x5A,0x8A,0xAA,0xC4,0x2D,0xAD,0x33,0x17,0x0D,
+        0x04,0x50,0x7A,0x33,0xA8,0x55,0x21,0xAB,0xDF,0x1C,0xBA,0x64,
+        0xEC,0xFB,0x85,0x04,0x58,0xDB,0xEF,0x0A,0x8A,0xEA,0x71,0x57,
+        0x5D,0x06,0x0C,0x7D,0xB3,0x97,0x0F,0x85,0xA6,0xE1,0xE4,0xC7,
+        0xAB,0xF5,0xAE,0x8C,0xDB,0x09,0x33,0xD7,0x1E,0x8C,0x94,0xE0,
+        0x4A,0x25,0x61,0x9D,0xCE,0xE3,0xD2,0x26,0x1A,0xD2,0xEE,0x6B,
+        0xF1,0x2F,0xFA,0x06,0xD9,0x8A,0x08,0x64,0xD8,0x76,0x02,0x73,
+        0x3E,0xC8,0x6A,0x64,0x52,0x1F,0x2B,0x18,0x17,0x7B,0x20,0x0C,
+        0xBB,0xE1,0x17,0x57,0x7A,0x61,0x5D,0x6C,0x77,0x09,0x88,0xC0,
+        0xBA,0xD9,0x46,0xE2,0x08,0xE2,0x4F,0xA0,0x74,0xE5,0xAB,0x31,
+        0x43,0xDB,0x5B,0xFC,0xE0,0xFD,0x10,0x8E,0x4B,0x82,0xD1,0x20,
+        0xA9,0x21,0x08,0x01,0x1A,0x72,0x3C,0x12,0xA7,0x87,0xE6,0xD7,
+        0x88,0x71,0x9A,0x10,0xBD,0xBA,0x5B,0x26,0x99,0xC3,0x27,0x18,
+        0x6A,0xF4,0xE2,0x3C,0x1A,0x94,0x68,0x34,0xB6,0x15,0x0B,0xDA,
+        0x25,0x83,0xE9,0xCA,0x2A,0xD4,0x4C,0xE8,0xDB,0xBB,0xC2,0xDB,
+        0x04,0xDE,0x8E,0xF9,0x2E,0x8E,0xFC,0x14,0x1F,0xBE,0xCA,0xA6,
+        0x28,0x7C,0x59,0x47,0x4E,0x6B,0xC0,0x5D,0x99,0xB2,0x96,0x4F,
+        0xA0,0x90,0xC3,0xA2,0x23,0x3B,0xA1,0x86,0x51,0x5B,0xE7,0xED,
+        0x1F,0x61,0x29,0x70,0xCE,0xE2,0xD7,0xAF,0xB8,0x1B,0xDD,0x76,
+        0x21,0x70,0x48,0x1C,0xD0,0x06,0x91,0x27,0xD5,0xB0,0x5A,0xA9,
+        0x93,0xB4,0xEA,0x98,0x8D,0x8F,0xDD,0xC1,0x86,0xFF,0xB7,0xDC,
+        0x90,0xA6,0xC0,0x8F,0x4D,0xF4,0x35,0xC9,0x34,0x02,0x84,0x92,
+        0x36,0xC3,0xFA,0xB4,0xD2,0x7C,0x70,0x26,0xC1,0xD4,0xDC,0xB2,
+        0x60,0x26,0x46,0xDE,0xC9,0x75,0x1E,0x76,0x3D,0xBA,0x37,0xBD,
+        0xF8,0xFF,0x94,0x06,0xAD,0x9E,0x53,0x0E,0xE5,0xDB,0x38,0x2F,
+        0x41,0x30,0x01,0xAE,0xB0,0x6A,0x53,0xED,0x90,0x27,0xD8,0x31,
+        0x17,0x97,0x27,0xB0,0x86,0x5A,0x89,0x18,0xDA,0x3E,0xDB,0xEB,
+        0xCF,0x9B,0x14,0xED,0x44,0xCE,0x6C,0xBA,0xCE,0xD4,0xBB,0x1B,
+        0xDB,0x7F,0x14,0x47,0xE6,0xCC,0x25,0x4B,0x33,0x20,0x51,0x51,
+        0x2B,0xD7,0xAF,0x42,0x6F,0xB8,0xF4,0x01,0x37,0x8C,0xD2,0xBF,
+        0x59,0x83,0xCA,0x01,0xC6,0x4B,0x92,0xEC,0xF0,0x32,0xEA,0x15,
+        0xD1,0x72,0x1D,0x03,0xF4,0x82,0xD7,0xCE,0x6E,0x74,0xFE,0xF6,
+        0xD5,0x5E,0x70,0x2F,0x46,0x98,0x0C,0x82,0xB5,0xA8,0x40,0x31,
+        0x90,0x0B,0x1C,0x9E,0x59,0xE7,0xC9,0x7F,0xBE,0xC7,0xE8,0xF3,
+        0x23,0xA9,0x7A,0x7E,0x36,0xCC,0x88,0xBE,0x0F,0x1D,0x45,0xB7,
+        0xFF,0x58,0x5A,0xC5,0x4B,0xD4,0x07,0xB2,0x2B,0x41,0x54,0xAA,
+        0xCC,0x8F,0x6D,0x7E,0xBF,0x48,0xE1,0xD8,0x14,0xCC,0x5E,0xD2,
+        0x0F,0x80,0x37,0xE0,0xA7,0x97,0x15,0xEE,0xF2,0x9B,0xE3,0x28,
+        0x06,0xA1,0xD5,0x8B,0xB7,0xC5,0xDA,0x76,0xF5,0x50,0xAA,0x3D,
+        0x8A,0x1F,0xBF,0xF0,0xEB,0x19,0xCC,0xB1,0xA3,0x13,0xD5,0x5C,
+        0xDA,0x56,0xC9,0xEC,0x2E,0xF2,0x96,0x32,0x38,0x7F,0xE8,0xD7,
+        0x6E,0x3C,0x04,0x68,0x04,0x3E,0x8F,0x66,0x3F,0x48,0x60,0xEE,
+        0x12,0xBF,0x2D,0x5B,0x0B,0x74,0x74,0xD6,0xE6,0x94,0xF9,0x1E,
+        0x6D,0xBE,0x11,0x59,0x74,0xA3,0x92,0x6F,0x12,0xFE,0xE5,0xE4,
+        0x38,0x77,0x7C,0xB6,0xA9,0x32,0xDF,0x8C,0xD8,0xBE,0xC4,0xD0,
+        0x73,0xB9,0x31,0xBA,0x3B,0xC8,0x32,0xB6,0x8D,0x9D,0xD3,0x00,
+        0x74,0x1F,0xA7,0xBF,0x8A,0xFC,0x47,0xED,0x25,0x76,0xF6,0x93,
+        0x6B,0xA4,0x24,0x66,0x3A,0xAB,0x63,0x9C,0x5A,0xE4,0xF5,0x68,
+        0x34,0x23,0xB4,0x74,0x2B,0xF1,0xC9,0x78,0x23,0x8F,0x16,0xCB,
+        0xE3,0x9D,0x65,0x2D,0xE3,0xFD,0xB8,0xBE,0xFC,0x84,0x8A,0xD9,
+        0x22,0x22,0x2E,0x04,0xA4,0x03,0x7C,0x07,0x13,0xEB,0x57,0xA8,
+        0x1A,0x23,0xF0,0xC7,0x34,0x73,0xFC,0x64,0x6C,0xEA,0x30,0x6B,
+        0x4B,0xCB,0xC8,0x86,0x2F,0x83,0x85,0xDD,0xFA,0x9D,0x4B,0x7F,
+        0xA2,0xC0,0x87,0xE8,0x79,0x68,0x33,0x03,0xED,0x5B,0xDD,0x3A,
+        0x06,0x2B,0x3C,0xF5,0xB3,0xA2,0x78,0xA6,0x6D,0x2A,0x13,0xF8,
+        0x3F,0x44,0xF8,0x2D,0xDF,0x31,0x0E,0xE0,0x74,0xAB,0x6A,0x36,
+        0x45,0x97,0xE8,0x99,0xA0,0x25,0x5D,0xC1,0x64,0xF3,0x1C,0xC5,
+        0x08,0x46,0x85,0x1D,0xF9,0xAB,0x48,0x19,0x5D,0xED,0x7E,0xA1,
+        0xB1,0xD5,0x10,0xBD,0x7E,0xE7,0x4D,0x73,0xFA,0xF3,0x6B,0xC3,
+        0x1E,0xCF,0xA2,0x68,0x35,0x90,0x46,0xF4,0xEB,0x87,0x9F,0x92,
+        0x40,0x09,0x43,0x8B,0x48,0x1C,0x6C,0xD7,0x88,0x9A,0x00,0x2E,
+        0xD5,0xEE,0x38,0x2B,0xC9,0x19,0x0D,0xA6,0xFC,0x02,0x6E,0x47,
+        0x95,0x58,0xE4,0x47,0x56,0x77,0xE9,0xAA,0x9E,0x30,0x50,0xE2,
+        0x76,0x56,0x94,0xDF,0xC8,0x1F,0x56,0xE8,0x80,0xB9,0x6E,0x71,
+        0x60,0xC9,0x80,0xDD,0x98,0xED,0xD3,0xDF,0xFF,0xFF,0xFF,0xFF,
+        0xFF,0xFF,0xFF,0xFF,
+    };
+    return BN_bin2bn(RFC3526_PRIME_8192, sizeof(RFC3526_PRIME_8192), bn);
+}
+
+#endif /* OPENSSL_VERSION_NUMBER < 0x0090801fL */
+
+#endif /* BRPC_BASE_SSL_COMPAT_H */

base/strings/stringprintf.cc

@@ -10,6 +10,12 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 
+// gcc7 reports that the first arg to vsnprintfT in StringAppendVT is NULL,
+// which I can't figure out why, turn off the warning right now.
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic warning "-Wformat-truncation=0"
+#endif
+
 namespace base {
 
 namespace {

base/third_party/dmg_fp/dtoa.cc

@@ -1840,7 +1840,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
 		switch(*++s) {
 		  case '-':
 			esign = 1;
-			/* no break */
+			// fall through
 		  case '+':
 			s++;
 		  }
@@ -2462,11 +2462,11 @@ strtod
 	for(s = s00;;s++) switch(*s) {
 		case '-':
 			sign = 1;
-			/* no break */
+			// fall through
 		case '+':
 			if (*++s)
 				goto break2;
-			/* no break */
+			// fall through
 		case 0:
 			goto ret0;
 		case '\t':
@@ -2570,6 +2570,7 @@ strtod
 		switch(c = *++s) {
 			case '-':
 				esign = 1;
+				// fall through
 			case '+':
 				c = *++s;
 			}
@@ -3755,7 +3756,7 @@ dtoa
 			break;
 		case 2:
 			leftright = 0;
-			/* no break */
+			// fall through
 		case 4:
 			if (ndigits <= 0)
 				ndigits = 1;
@@ -3763,7 +3764,7 @@ dtoa
 			break;
 		case 3:
 			leftright = 0;
-			/* no break */
+			// fall through
 		case 5:
 			i = ndigits + k + 1;
 			ilim = i;

base/third_party/icu/icu_utf.cc

@@ -159,10 +159,12 @@ utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c,
                 illegal=1;
                 break;
             }
+            // fall through
         case 2:
             trail=s[(i)++];
             (c)=((c)<<6)|(trail&0x3f);
             illegal|=(trail&0xc0)^0x80;
+            // fall through
         case 1:
             trail=s[(i)++];
             (c)=((c)<<6)|(trail&0x3f);

base/third_party/murmurhash3/murmurhash3.cpp

@@ -17,6 +17,11 @@
 #include <algorithm> // std::min
 #include "base/third_party/murmurhash3/murmurhash3.h"
 
+// Too many fallthroughs in this file to mark, just ignore the warning.
+#if defined(__GNUC__) && __GNUC__ >= 7
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+#endif
+
 //-----------------------------------------------------------------------------
 // Platform-specific functions and macros
 

brpc/amf.cpp

@@ -433,6 +433,7 @@ static bool ReadAMFObjectField(AMFInputStream* stream,
             LOG(ERROR) << "Fail to read class_name";
         }
     }
+    // fall through
     case AMF_MARKER_OBJECT: {
         if (field) {
             if (field->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
@@ -633,6 +634,7 @@ static bool ReadAMFObjectField(AMFInputStream* stream,
             LOG(ERROR) << "Fail to read class_name";
         }
     }
+    // fall through
     case AMF_MARKER_OBJECT: {
         if (!ReadAMFObjectBody(obj->MutableObject(name), stream)) {
             return false;
@@ -781,6 +783,7 @@ static bool ReadAMFArrayItem(AMFInputStream* stream, AMFArray* arr) {
             LOG(ERROR) << "Fail to read class_name";
         }
     }
+    // fall through
     case AMF_MARKER_OBJECT: {
         if (!ReadAMFObjectBody(arr->AddObject(), stream)) {
             return false;

brpc/builtin/dir_service.cpp

@@ -75,8 +75,14 @@ void DirService::default_method(::google::protobuf::RpcController* cntl_base,
 
         std::vector<std::string> files;
         files.reserve(32);
-        struct dirent ent;
-        for (struct dirent* p = &ent; readdir_r(dir, &ent, &p) == 0 && p; ) {
+        // readdir_r is marked as deprecated since glibc 2.24. 
+#if defined(__GLIBC__) && \
+        (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 24))
+        for (struct dirent* p = NULL; (p = readdir(dir)) != NULL; ) {
+#else
+        struct dirent entbuf;
+        for (struct dirent* p = NULL; readdir_r(dir, &entbuf, &p) == 0 && p; ) {
+#endif
             files.push_back(p->d_name);
         }
         CHECK_EQ(0, closedir(dir));

brpc/controller.cpp

@@ -664,6 +664,7 @@ void Controller::Call::OnComplete(Controller* c, int error_code/*note*/,
             }
             break;
         }
+        // fall through
     case CONNECTION_TYPE_SHORT:
         if (sending_sock != NULL) {
             // Check the comment in CONNECTION_TYPE_POOLED branch.

brpc/details/http_parser.cpp

@@ -2271,8 +2271,7 @@ http_parser_parse_url(const char *buf, size_t buflen, int is_connect,
 
       case s_req_server_with_at:
         found_at = 1;
-
-      /* FALLTROUGH */
+        // fall through
       case s_req_server:
         uf = UF_HOST;
         break;

brpc/details/ssl_helper.cpp

@@ -11,19 +11,12 @@
 #include <openssl/x509v3.h>
 #include "base/unique_ptr.h"
 #include "base/logging.h"
+#include "base/ssl_compat.h"
 #include "brpc/socket.h"
 #include "brpc/details/ssl_helper.h"
 
-
 namespace brpc {
 
-// Locks for SSL library
-// NOTE: If we replace this with bthread_mutex_t, SSL routines
-// may crash probably due to some TLS data used inside OpenSSL
-// Also according to performance test, there is little difference
-// between pthread mutex and bthread mutex
-static base::Mutex* g_ssl_mutexs = NULL;
-
 #ifndef OPENSSL_NO_DH
 static DH* g_dh_1024 = NULL;
 static DH* g_dh_2048 = NULL;
@@ -157,7 +150,7 @@ static void SSLMessageCallback(int write_p, int version, int content_type,
 static DH* SSLGetDHCallback(SSL* ssl, int exp, int keylen) {
     (void)exp;
     EVP_PKEY* pkey = SSL_get_privatekey(ssl);
-    int type = pkey ? EVP_PKEY_type(pkey->type) : EVP_PKEY_NONE;
+    int type = pkey ? EVP_PKEY_base_id(pkey) : EVP_PKEY_NONE;
 
     // The keylen supplied by OpenSSL can only be 512 or 1024.
     // See ssl3_send_server_key_exchange() in ssl/s3_srvr.c
@@ -203,8 +196,10 @@ static void ExtractHostnames(X509* x, std::vector<std::string>* hostnames) {
     while ((i = X509_NAME_get_index_by_NID(xname, NID_commonName, i)) != -1) {
         char* str = NULL;
         X509_NAME_ENTRY* entry = X509_NAME_get_entry(xname, i);
-        if (ASN1_STRING_to_UTF8((unsigned char**)&str, entry->value) >= 0) {
-            std::string hostname(str);
+        const int len = ASN1_STRING_to_UTF8((unsigned char**)&str, 
+                                 X509_NAME_ENTRY_get_data(entry));
+        if (len >= 0) {
+            std::string hostname(str, len);
             hostnames->push_back(hostname);
             OPENSSL_free(str);
         }
@@ -303,10 +298,14 @@ SSL_CTX* CreateSSLContext(const std::string& certificate,
     }
 
     // Load the certificate chain
+#if (OPENSSL_VERSION_NUMBER >= 0x10002000L)
+    SSL_CTX_clear_chain_certs(ssl_ctx.get());
+#else
     if (ssl_ctx->extra_certs != NULL) {
         sk_X509_pop_free(ssl_ctx->extra_certs, X509_free);
         ssl_ctx->extra_certs = NULL;
     }
+#endif
     X509* ca = NULL;
     while ((ca = PEM_read_bio_X509(cbio.get(), NULL, 0, NULL))) {
         if (SSL_CTX_add_extra_chain_cert(ssl_ctx.get(), ca) != 1) {
@@ -460,6 +459,8 @@ SSLState DetectSSLState(int fd, int* error_code) {
     }
 }
 
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+
 // NOTE: Can't find a macro for CRYPTO_THREADID
 //       Fallback to use CRYPTO_LOCK_ECDH as flag
 #ifdef CRYPTO_LOCK_ECDH
@@ -472,6 +473,13 @@ static unsigned long SSLGetThreadId() {
 }
 #endif  // CRYPTO_LOCK_ECDH
 
+// Locks for SSL library
+// NOTE: If we replace this with bthread_mutex_t, SSL routines
+// may crash probably due to some TLS data used inside OpenSSL
+// Also according to performance test, there is little difference
+// between pthread mutex and bthread mutex
+static base::Mutex* g_ssl_mutexs = NULL;
+
 static void SSLLockCallback(int mode, int n, const char* file, int line) {
     (void)file;
     (void)line;
@@ -485,279 +493,112 @@ static void SSLLockCallback(int mode, int n, const char* file, int line) {
         g_ssl_mutexs[n].unlock();
     }
 }
+#endif // OPENSSL_VERSION_NUMBER < 0x10100000L
 
 int SSLThreadInit() {
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
     g_ssl_mutexs = new base::Mutex[CRYPTO_num_locks()];
     CRYPTO_set_locking_callback(SSLLockCallback);
-#ifdef CRYPTO_LOCK_ECDH
+# ifdef CRYPTO_LOCK_ECDH
     CRYPTO_THREADID_set_callback(SSLGetThreadId);
-#else
+# else
     CRYPTO_set_id_callback(SSLGetThreadId);
-#endif  // CRYPTO_LOCK_ECDH
+# endif  // CRYPTO_LOCK_ECDH
+#endif // OPENSSL_VERSION_NUMBER < 0x10100000L 
     return 0;
 }
 
 #ifndef OPENSSL_NO_DH
 
 static DH* SSLGetDH1024() {
-#if OPENSSL_VERSION_NUMBER < 0x0090801fL
-    static const unsigned char rfc_2409_prime_1024[] = {
-        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
-        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
-        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
-        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
-        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
-        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
-        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
-        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
-        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
-        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE6,0x53,0x81,
-        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
-    };
-#endif
-    DH *dh = DH_new();
-    if (!dh) {
+    BIGNUM* p = get_rfc2409_prime_1024(NULL);
+    if (!p) {
         return NULL;
     }
-
-#if OPENSSL_VERSION_NUMBER >= 0x0090801fL
-    dh->p = get_rfc2409_prime_1024(NULL);
-#else
-    dh->p = BN_bin2bn(rfc_2409_prime_1024, sizeof rfc_2409_prime_1024, NULL);
-#endif
     // See RFC 2409, Section 6 "Oakley Groups"
     // for the reason why 2 is used as generator.
-    BN_dec2bn(&dh->g, "2");
-    if (!dh->p || !dh->g) {
-        DH_free(dh);
+    BIGNUM* g = NULL;
+    BN_dec2bn(&g, "2");
+    if (!g) {
+        BN_free(p);
+        return NULL;
+    }
+    DH *dh = DH_new();
+    if (!dh) {
+        BN_free(p);
+        BN_free(g);
         return NULL;
     }
+    DH_set0_pqg(dh, p, NULL, g);
     return dh;
 }
 
 static DH* SSLGetDH2048() {
-#if OPENSSL_VERSION_NUMBER < 0x0090801fL
-    static const unsigned char rfc_3526_prime_2048[] = {
-        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
-        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
-        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
-        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
-        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
-        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
-        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
-        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
-        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
-        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
-        0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
-        0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
-        0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
-        0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
-        0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
-        0xCA,0x18,0x21,0x7C,0x32,0x90,0x5E,0x46,0x2E,0x36,0xCE,0x3B,
-        0xE3,0x9E,0x77,0x2C,0x18,0x0E,0x86,0x03,0x9B,0x27,0x83,0xA2,
-        0xEC,0x07,0xA2,0x8F,0xB5,0xC5,0x5D,0xF0,0x6F,0x4C,0x52,0xC9,
-        0xDE,0x2B,0xCB,0xF6,0x95,0x58,0x17,0x18,0x39,0x95,0x49,0x7C,
-        0xEA,0x95,0x6A,0xE5,0x15,0xD2,0x26,0x18,0x98,0xFA,0x05,0x10,
-        0x15,0x72,0x8E,0x5A,0x8A,0xAC,0xAA,0x68,0xFF,0xFF,0xFF,0xFF,
-        0xFF,0xFF,0xFF,0xFF,
-    };
-#endif
-    DH* dh = DH_new();
-    if (!dh) {
+    BIGNUM* p = get_rfc3526_prime_2048(NULL);
+    if (!p) {
         return NULL;
     }
-
-#if OPENSSL_VERSION_NUMBER >= 0x0090801fL
-    dh->p = get_rfc3526_prime_2048(NULL);
-#else
-    dh->p = BN_bin2bn(rfc_3526_prime_2048, sizeof(rfc_3526_prime_2048), NULL);
-#endif
     // See RFC 3526, Section 3 "2048-bit MODP Group"
     // for the reason why 2 is used as generator.
-    BN_dec2bn(&dh->g, "2");
-    if (!dh->p || !dh->g) {
-        DH_free(dh);
+    BIGNUM* g = NULL;
+    BN_dec2bn(&g, "2");
+    if (!g) {
+        BN_free(p);
+        return NULL;
+    }
+    DH* dh = DH_new();
+    if (!dh) {
+        BN_free(p);
+        BN_free(g);
         return NULL;
     }
+    DH_set0_pqg(dh, p, NULL, g);
     return dh;
 }
 
 static DH* SSLGetDH4096() {
-#if OPENSSL_VERSION_NUMBER < 0x0090801fL
-    static const unsigned char rfc_3526_prime_4096[] = {
-        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
-        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
-        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
-        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
-        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
-        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
-        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
-        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
-        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
-        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
-        0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
-        0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
-        0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
-        0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
-        0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
-        0xCA,0x18,0x21,0x7C,0x32,0x90,0x5E,0x46,0x2E,0x36,0xCE,0x3B,
-        0xE3,0x9E,0x77,0x2C,0x18,0x0E,0x86,0x03,0x9B,0x27,0x83,0xA2,
-        0xEC,0x07,0xA2,0x8F,0xB5,0xC5,0x5D,0xF0,0x6F,0x4C,0x52,0xC9,
-        0xDE,0x2B,0xCB,0xF6,0x95,0x58,0x17,0x18,0x39,0x95,0x49,0x7C,
-        0xEA,0x95,0x6A,0xE5,0x15,0xD2,0x26,0x18,0x98,0xFA,0x05,0x10,
-        0x15,0x72,0x8E,0x5A,0x8A,0xAA,0xC4,0x2D,0xAD,0x33,0x17,0x0D,
-        0x04,0x50,0x7A,0x33,0xA8,0x55,0x21,0xAB,0xDF,0x1C,0xBA,0x64,
-        0xEC,0xFB,0x85,0x04,0x58,0xDB,0xEF,0x0A,0x8A,0xEA,0x71,0x57,
-        0x5D,0x06,0x0C,0x7D,0xB3,0x97,0x0F,0x85,0xA6,0xE1,0xE4,0xC7,
-        0xAB,0xF5,0xAE,0x8C,0xDB,0x09,0x33,0xD7,0x1E,0x8C,0x94,0xE0,
-        0x4A,0x25,0x61,0x9D,0xCE,0xE3,0xD2,0x26,0x1A,0xD2,0xEE,0x6B,
-        0xF1,0x2F,0xFA,0x06,0xD9,0x8A,0x08,0x64,0xD8,0x76,0x02,0x73,
-        0x3E,0xC8,0x6A,0x64,0x52,0x1F,0x2B,0x18,0x17,0x7B,0x20,0x0C,
-        0xBB,0xE1,0x17,0x57,0x7A,0x61,0x5D,0x6C,0x77,0x09,0x88,0xC0,
-        0xBA,0xD9,0x46,0xE2,0x08,0xE2,0x4F,0xA0,0x74,0xE5,0xAB,0x31,
-        0x43,0xDB,0x5B,0xFC,0xE0,0xFD,0x10,0x8E,0x4B,0x82,0xD1,0x20,
-        0xA9,0x21,0x08,0x01,0x1A,0x72,0x3C,0x12,0xA7,0x87,0xE6,0xD7,
-        0x88,0x71,0x9A,0x10,0xBD,0xBA,0x5B,0x26,0x99,0xC3,0x27,0x18,
-        0x6A,0xF4,0xE2,0x3C,0x1A,0x94,0x68,0x34,0xB6,0x15,0x0B,0xDA,
-        0x25,0x83,0xE9,0xCA,0x2A,0xD4,0x4C,0xE8,0xDB,0xBB,0xC2,0xDB,
-        0x04,0xDE,0x8E,0xF9,0x2E,0x8E,0xFC,0x14,0x1F,0xBE,0xCA,0xA6,
-        0x28,0x7C,0x59,0x47,0x4E,0x6B,0xC0,0x5D,0x99,0xB2,0x96,0x4F,
-        0xA0,0x90,0xC3,0xA2,0x23,0x3B,0xA1,0x86,0x51,0x5B,0xE7,0xED,
-        0x1F,0x61,0x29,0x70,0xCE,0xE2,0xD7,0xAF,0xB8,0x1B,0xDD,0x76,
-        0x21,0x70,0x48,0x1C,0xD0,0x06,0x91,0x27,0xD5,0xB0,0x5A,0xA9,
-        0x93,0xB4,0xEA,0x98,0x8D,0x8F,0xDD,0xC1,0x86,0xFF,0xB7,0xDC,
-        0x90,0xA6,0xC0,0x8F,0x4D,0xF4,0x35,0xC9,0x34,0x06,0x31,0x99,
-        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
-    };
-#endif
-    DH *dh = DH_new();
-    if (!dh) {
+    BIGNUM* p = get_rfc3526_prime_4096(NULL);
+    if (!p) {
         return NULL;
     }
-
-#if OPENSSL_VERSION_NUMBER >= 0x0090801fL
-    dh->p = get_rfc3526_prime_4096(NULL);
-#else
-    dh->p = BN_bin2bn(rfc_3526_prime_4096, sizeof rfc_3526_prime_4096, NULL);
-#endif
     // See RFC 3526, Section 5 "4096-bit MODP Group"
     // for the reason why 2 is used as generator.
-    BN_dec2bn(&dh->g, "2");
-    if (!dh->p || !dh->g) {
-        DH_free(dh);
+    BIGNUM* g = NULL;
+    BN_dec2bn(&g, "2");
+    if (!g) {
+        BN_free(p);
         return NULL;
     }
+    DH *dh = DH_new();
+    if (!dh) {
+        BN_free(p);
+        BN_free(g);
+        return NULL;
+    }
+    DH_set0_pqg(dh, p, NULL, g);
     return dh;
 }
 
 static DH* SSLGetDH8192() {
-#if OPENSSL_VERSION_NUMBER < 0x0090801fL
-    static const unsigned char rfc_3526_prime_8192[] = {
-        0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC9,0x0F,0xDA,0xA2,
-        0x21,0x68,0xC2,0x34,0xC4,0xC6,0x62,0x8B,0x80,0xDC,0x1C,0xD1,
-        0x29,0x02,0x4E,0x08,0x8A,0x67,0xCC,0x74,0x02,0x0B,0xBE,0xA6,
-        0x3B,0x13,0x9B,0x22,0x51,0x4A,0x08,0x79,0x8E,0x34,0x04,0xDD,
-        0xEF,0x95,0x19,0xB3,0xCD,0x3A,0x43,0x1B,0x30,0x2B,0x0A,0x6D,
-        0xF2,0x5F,0x14,0x37,0x4F,0xE1,0x35,0x6D,0x6D,0x51,0xC2,0x45,
-        0xE4,0x85,0xB5,0x76,0x62,0x5E,0x7E,0xC6,0xF4,0x4C,0x42,0xE9,
-        0xA6,0x37,0xED,0x6B,0x0B,0xFF,0x5C,0xB6,0xF4,0x06,0xB7,0xED,
-        0xEE,0x38,0x6B,0xFB,0x5A,0x89,0x9F,0xA5,0xAE,0x9F,0x24,0x11,
-        0x7C,0x4B,0x1F,0xE6,0x49,0x28,0x66,0x51,0xEC,0xE4,0x5B,0x3D,
-        0xC2,0x00,0x7C,0xB8,0xA1,0x63,0xBF,0x05,0x98,0xDA,0x48,0x36,
-        0x1C,0x55,0xD3,0x9A,0x69,0x16,0x3F,0xA8,0xFD,0x24,0xCF,0x5F,
-        0x83,0x65,0x5D,0x23,0xDC,0xA3,0xAD,0x96,0x1C,0x62,0xF3,0x56,
-        0x20,0x85,0x52,0xBB,0x9E,0xD5,0x29,0x07,0x70,0x96,0x96,0x6D,
-        0x67,0x0C,0x35,0x4E,0x4A,0xBC,0x98,0x04,0xF1,0x74,0x6C,0x08,
-        0xCA,0x18,0x21,0x7C,0x32,0x90,0x5E,0x46,0x2E,0x36,0xCE,0x3B,
-        0xE3,0x9E,0x77,0x2C,0x18,0x0E,0x86,0x03,0x9B,0x27,0x83,0xA2,
-        0xEC,0x07,0xA2,0x8F,0xB5,0xC5,0x5D,0xF0,0x6F,0x4C,0x52,0xC9,
-        0xDE,0x2B,0xCB,0xF6,0x95,0x58,0x17,0x18,0x39,0x95,0x49,0x7C,
-        0xEA,0x95,0x6A,0xE5,0x15,0xD2,0x26,0x18,0x98,0xFA,0x05,0x10,
-        0x15,0x72,0x8E,0x5A,0x8A,0xAA,0xC4,0x2D,0xAD,0x33,0x17,0x0D,
-        0x04,0x50,0x7A,0x33,0xA8,0x55,0x21,0xAB,0xDF,0x1C,0xBA,0x64,
-        0xEC,0xFB,0x85,0x04,0x58,0xDB,0xEF,0x0A,0x8A,0xEA,0x71,0x57,
-        0x5D,0x06,0x0C,0x7D,0xB3,0x97,0x0F,0x85,0xA6,0xE1,0xE4,0xC7,
-        0xAB,0xF5,0xAE,0x8C,0xDB,0x09,0x33,0xD7,0x1E,0x8C,0x94,0xE0,
-        0x4A,0x25,0x61,0x9D,0xCE,0xE3,0xD2,0x26,0x1A,0xD2,0xEE,0x6B,
-        0xF1,0x2F,0xFA,0x06,0xD9,0x8A,0x08,0x64,0xD8,0x76,0x02,0x73,
-        0x3E,0xC8,0x6A,0x64,0x52,0x1F,0x2B,0x18,0x17,0x7B,0x20,0x0C,
-        0xBB,0xE1,0x17,0x57,0x7A,0x61,0x5D,0x6C,0x77,0x09,0x88,0xC0,
-        0xBA,0xD9,0x46,0xE2,0x08,0xE2,0x4F,0xA0,0x74,0xE5,0xAB,0x31,
-        0x43,0xDB,0x5B,0xFC,0xE0,0xFD,0x10,0x8E,0x4B,0x82,0xD1,0x20,
-        0xA9,0x21,0x08,0x01,0x1A,0x72,0x3C,0x12,0xA7,0x87,0xE6,0xD7,
-        0x88,0x71,0x9A,0x10,0xBD,0xBA,0x5B,0x26,0x99,0xC3,0x27,0x18,
-        0x6A,0xF4,0xE2,0x3C,0x1A,0x94,0x68,0x34,0xB6,0x15,0x0B,0xDA,
-        0x25,0x83,0xE9,0xCA,0x2A,0xD4,0x4C,0xE8,0xDB,0xBB,0xC2,0xDB,
-        0x04,0xDE,0x8E,0xF9,0x2E,0x8E,0xFC,0x14,0x1F,0xBE,0xCA,0xA6,
-        0x28,0x7C,0x59,0x47,0x4E,0x6B,0xC0,0x5D,0x99,0xB2,0x96,0x4F,
-        0xA0,0x90,0xC3,0xA2,0x23,0x3B,0xA1,0x86,0x51,0x5B,0xE7,0xED,
-        0x1F,0x61,0x29,0x70,0xCE,0xE2,0xD7,0xAF,0xB8,0x1B,0xDD,0x76,
-        0x21,0x70,0x48,0x1C,0xD0,0x06,0x91,0x27,0xD5,0xB0,0x5A,0xA9,
-        0x93,0xB4,0xEA,0x98,0x8D,0x8F,0xDD,0xC1,0x86,0xFF,0xB7,0xDC,
-        0x90,0xA6,0xC0,0x8F,0x4D,0xF4,0x35,0xC9,0x34,0x02,0x84,0x92,
-        0x36,0xC3,0xFA,0xB4,0xD2,0x7C,0x70,0x26,0xC1,0xD4,0xDC,0xB2,
-        0x60,0x26,0x46,0xDE,0xC9,0x75,0x1E,0x76,0x3D,0xBA,0x37,0xBD,
-        0xF8,0xFF,0x94,0x06,0xAD,0x9E,0x53,0x0E,0xE5,0xDB,0x38,0x2F,
-        0x41,0x30,0x01,0xAE,0xB0,0x6A,0x53,0xED,0x90,0x27,0xD8,0x31,
-        0x17,0x97,0x27,0xB0,0x86,0x5A,0x89,0x18,0xDA,0x3E,0xDB,0xEB,
-        0xCF,0x9B,0x14,0xED,0x44,0xCE,0x6C,0xBA,0xCE,0xD4,0xBB,0x1B,
-        0xDB,0x7F,0x14,0x47,0xE6,0xCC,0x25,0x4B,0x33,0x20,0x51,0x51,
-        0x2B,0xD7,0xAF,0x42,0x6F,0xB8,0xF4,0x01,0x37,0x8C,0xD2,0xBF,
-        0x59,0x83,0xCA,0x01,0xC6,0x4B,0x92,0xEC,0xF0,0x32,0xEA,0x15,
-        0xD1,0x72,0x1D,0x03,0xF4,0x82,0xD7,0xCE,0x6E,0x74,0xFE,0xF6,
-        0xD5,0x5E,0x70,0x2F,0x46,0x98,0x0C,0x82,0xB5,0xA8,0x40,0x31,
-        0x90,0x0B,0x1C,0x9E,0x59,0xE7,0xC9,0x7F,0xBE,0xC7,0xE8,0xF3,
-        0x23,0xA9,0x7A,0x7E,0x36,0xCC,0x88,0xBE,0x0F,0x1D,0x45,0xB7,
-        0xFF,0x58,0x5A,0xC5,0x4B,0xD4,0x07,0xB2,0x2B,0x41,0x54,0xAA,
-        0xCC,0x8F,0x6D,0x7E,0xBF,0x48,0xE1,0xD8,0x14,0xCC,0x5E,0xD2,
-        0x0F,0x80,0x37,0xE0,0xA7,0x97,0x15,0xEE,0xF2,0x9B,0xE3,0x28,
-        0x06,0xA1,0xD5,0x8B,0xB7,0xC5,0xDA,0x76,0xF5,0x50,0xAA,0x3D,
-        0x8A,0x1F,0xBF,0xF0,0xEB,0x19,0xCC,0xB1,0xA3,0x13,0xD5,0x5C,
-        0xDA,0x56,0xC9,0xEC,0x2E,0xF2,0x96,0x32,0x38,0x7F,0xE8,0xD7,
-        0x6E,0x3C,0x04,0x68,0x04,0x3E,0x8F,0x66,0x3F,0x48,0x60,0xEE,
-        0x12,0xBF,0x2D,0x5B,0x0B,0x74,0x74,0xD6,0xE6,0x94,0xF9,0x1E,
-        0x6D,0xBE,0x11,0x59,0x74,0xA3,0x92,0x6F,0x12,0xFE,0xE5,0xE4,
-        0x38,0x77,0x7C,0xB6,0xA9,0x32,0xDF,0x8C,0xD8,0xBE,0xC4,0xD0,
-        0x73,0xB9,0x31,0xBA,0x3B,0xC8,0x32,0xB6,0x8D,0x9D,0xD3,0x00,
-        0x74,0x1F,0xA7,0xBF,0x8A,0xFC,0x47,0xED,0x25,0x76,0xF6,0x93,
-        0x6B,0xA4,0x24,0x66,0x3A,0xAB,0x63,0x9C,0x5A,0xE4,0xF5,0x68,
-        0x34,0x23,0xB4,0x74,0x2B,0xF1,0xC9,0x78,0x23,0x8F,0x16,0xCB,
-        0xE3,0x9D,0x65,0x2D,0xE3,0xFD,0xB8,0xBE,0xFC,0x84,0x8A,0xD9,
-        0x22,0x22,0x2E,0x04,0xA4,0x03,0x7C,0x07,0x13,0xEB,0x57,0xA8,
-        0x1A,0x23,0xF0,0xC7,0x34,0x73,0xFC,0x64,0x6C,0xEA,0x30,0x6B,
-        0x4B,0xCB,0xC8,0x86,0x2F,0x83,0x85,0xDD,0xFA,0x9D,0x4B,0x7F,
-        0xA2,0xC0,0x87,0xE8,0x79,0x68,0x33,0x03,0xED,0x5B,0xDD,0x3A,
-        0x06,0x2B,0x3C,0xF5,0xB3,0xA2,0x78,0xA6,0x6D,0x2A,0x13,0xF8,
-        0x3F,0x44,0xF8,0x2D,0xDF,0x31,0x0E,0xE0,0x74,0xAB,0x6A,0x36,
-        0x45,0x97,0xE8,0x99,0xA0,0x25,0x5D,0xC1,0x64,0xF3,0x1C,0xC5,
-        0x08,0x46,0x85,0x1D,0xF9,0xAB,0x48,0x19,0x5D,0xED,0x7E,0xA1,
-        0xB1,0xD5,0x10,0xBD,0x7E,0xE7,0x4D,0x73,0xFA,0xF3,0x6B,0xC3,
-        0x1E,0xCF,0xA2,0x68,0x35,0x90,0x46,0xF4,0xEB,0x87,0x9F,0x92,
-        0x40,0x09,0x43,0x8B,0x48,0x1C,0x6C,0xD7,0x88,0x9A,0x00,0x2E,
-        0xD5,0xEE,0x38,0x2B,0xC9,0x19,0x0D,0xA6,0xFC,0x02,0x6E,0x47,
-        0x95,0x58,0xE4,0x47,0x56,0x77,0xE9,0xAA,0x9E,0x30,0x50,0xE2,
-        0x76,0x56,0x94,0xDF,0xC8,0x1F,0x56,0xE8,0x80,0xB9,0x6E,0x71,
-        0x60,0xC9,0x80,0xDD,0x98,0xED,0xD3,0xDF,0xFF,0xFF,0xFF,0xFF,
-        0xFF,0xFF,0xFF,0xFF,
-    };
-#endif
-    DH *dh = DH_new();
-    if (!dh) {
+    BIGNUM* p = get_rfc3526_prime_8192(NULL);
+    if (!p) {
         return NULL;
     }
-
-#if OPENSSL_VERSION_NUMBER >= 0x0090801fL
-    dh->p = get_rfc3526_prime_8192(NULL);
-#else
-    dh->p = BN_bin2bn(rfc_3526_prime_8192, sizeof rfc_3526_prime_8192, NULL);
-#endif
     // See RFC 3526, Section 7 "8192-bit MODP Group"
     // for the reason why 2 is used as generator.
-    BN_dec2bn(&dh->g, "2");
-    if (!dh->p || !dh->g) {
-        DH_free(dh);
+    BIGNUM* g = NULL;
+    BN_dec2bn(&g, "2");
+    if (!g) {
+        BN_free(g);
         return NULL;
     }
+    DH *dh = DH_new();
+    if (!dh) {
+        BN_free(p);
+        BN_free(g);
+        return NULL;
+    }
+    DH_set0_pqg(dh, p, NULL, g);
     return dh;
 }
 
@@ -786,4 +627,3 @@ int SSLDHInit() {
 }
 
 } // namespace brpc
-

brpc/policy/dh.cpp

@@ -22,30 +22,14 @@
 // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "base/logging.h"
+#include "base/ssl_compat.h"
 #include "brpc/policy/dh.h"
 
-
 namespace brpc {
 namespace policy {
 
-#define RFC2409_PRIME_1024                              \
-    "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"  \
-    "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"  \
-    "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"  \
-    "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"  \
-    "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381"  \
-    "FFFFFFFFFFFFFFFF"
-
 void DHWrapper::clear() {
     if (_pdh != NULL) {
-        if (_pdh->p != NULL) {
-            BN_free(_pdh->p);
-            _pdh->p = NULL;
-        }
-        if (_pdh->g != NULL) {
-            BN_free(_pdh->g);
-            _pdh->g = NULL;
-        }
         DH_free(_pdh);
         _pdh = NULL;
     }
@@ -57,7 +41,9 @@ int DHWrapper::initialize(bool ensure_128bytes_public_key) {
             return -1;
         }
         if (ensure_128bytes_public_key) {
-            int key_size = BN_num_bytes(_pdh->pub_key);
+            const BIGNUM* pub_key = NULL;
+            DH_get0_key(_pdh, &pub_key, NULL);
+            int key_size = BN_num_bytes(pub_key);
             if (key_size != 128) {
                 RPC_VLOG << "regenerate 128B key, current=" << key_size;
                 clear();
@@ -70,15 +56,17 @@ int DHWrapper::initialize(bool ensure_128bytes_public_key) {
 }
     
 int DHWrapper::copy_public_key(char* pkey, int* pkey_size) const {
+    const BIGNUM* pub_key = NULL;
+    DH_get0_key(_pdh, &pub_key, NULL);
     // copy public key to bytes.
     // sometimes, the key_size is 127, seems ok.
-    int key_size = BN_num_bytes(_pdh->pub_key);
+    int key_size = BN_num_bytes(pub_key);
     CHECK_GT(key_size, 0);
         
     // maybe the key_size is 127, but dh will write all 128bytes pkey,
     // no need to set/initialize the pkey.
     // @see https://github.com/ossrs/srs/issues/165
-    key_size = BN_bn2bin(_pdh->pub_key, (unsigned char*)pkey);
+    key_size = BN_bn2bin(pub_key, (unsigned char*)pkey);
     CHECK_GT(key_size, 0);
         
     // output the size of public key.
@@ -107,40 +95,27 @@ int DHWrapper::copy_shared_key(const void* ppkey, int ppkey_size,
 }
     
 int DHWrapper::do_initialize() {
-    int bits_count = 1024; 
-        
-    //1. Create the DH
-    if ((_pdh = DH_new()) == NULL) {
-        LOG(ERROR) << "Fail to DH_new";
+    BIGNUM* p = get_rfc2409_prime_1024(NULL);
+    if (!p) {
         return -1;
     }
-    
-    //2. Create his internal p and g
-    if ((_pdh->p = BN_new()) == NULL) {
-        LOG(ERROR) << "Fail to BN_new _pdh->p";
+    // See RFC 2409, Section 6 "Oakley Groups"
+    // for the reason why 2 is used as generator.
+    BIGNUM* g = NULL;
+    BN_dec2bn(&g, "2");
+    if (!g) {
+        BN_free(p);
         return -1;
     }
-    if ((_pdh->g = BN_new()) == NULL) {
-        LOG(ERROR) << "Fail to BN_new _pdh->g";
+    _pdh = DH_new();
+    if (!_pdh) {
+        BN_free(p);
+        BN_free(g);
         return -1;
     }
+    DH_set0_pqg(_pdh, p, NULL, g);
     
-    //3. initialize p and g, @see ./test/ectest.c:260
-    if (!BN_hex2bn(&_pdh->p, RFC2409_PRIME_1024)) {
-        LOG(ERROR) << "Fail to BN_hex2bn _pdh->p";
-        return -1;
-    }
-    // @see ./test/bntest.c:1764
-    if (!BN_set_word(_pdh->g, 2)) {
-        LOG(ERROR) << "Fail to BN_set_word _pdh->g";
-        return -1;
-    }
-    
-    // 4. Set the key length
-    _pdh->length = bits_count;
-    
-    // 5. Generate private and public key
-    // @see ./test/dhtest.c:152
+    // Generate private and public key
     if (!DH_generate_key(_pdh)) {
         LOG(ERROR) << "Fail to DH_generate_key";
         return -1;
@@ -148,8 +123,6 @@ int DHWrapper::do_initialize() {
     return 0;
 }
 
-#undef RFC2409_PRIME_1024
-
 }  // namespace policy
 } // namespace brpc
 

brpc/policy/http_rpc_protocol.cpp

@@ -168,7 +168,7 @@ static void PrintMessage(const base::IOBuf& inbuf,
                          bool has_content) {
     base::IOBuf buf1 = inbuf;
     base::IOBuf buf2;
-    char str[32];
+    char str[48];
     if (request_or_response) {
         snprintf(str, sizeof(str), "[HTTP REQUEST @%s]", base::my_ip_cstr());
     } else {

brpc/redis_reply.cpp

@@ -255,6 +255,7 @@ void RedisReply::Print(std::ostream& os) const {
         break;
     case REDIS_REPLY_ERROR:
         os << "(error) ";
+        // fall through
     case REDIS_REPLY_STATUS:
         if (_length < sizeof(_data.short_str)) {
             os << _data.short_str;

brpc/serialized_request.cpp

@@ -120,7 +120,9 @@ const ::google::protobuf::Descriptor* SerializedRequest::descriptor() {
 }
 
 const SerializedRequest& SerializedRequest::default_instance() {
-    if (default_instance_ == NULL) protobuf_AddDesc_baidu_2frpc_2fserialized_5frequest_2eproto();  return *default_instance_;
+    if (default_instance_ == NULL)
+        protobuf_AddDesc_baidu_2frpc_2fserialized_5frequest_2eproto();
+    return *default_instance_;
 }
 
 SerializedRequest* SerializedRequest::default_instance_ = NULL;

bvar/collector.cpp

@@ -86,8 +86,7 @@ private:
     bool _stop;         // Set to true in dtor.
     pthread_t _grab_thread;     // For joining.
     pthread_t _dump_thread;
-
-    int64_t BAIDU_CACHELINE_ALIGNMENT _ngrab;
+    int64_t _ngrab BAIDU_CACHELINE_ALIGNMENT;
     int64_t _ndrop;
     int64_t _ndump;
     pthread_mutex_t _dump_thread_mutex;

bvar/default_variables.cpp

@@ -11,6 +11,7 @@
 #include "base/memory/singleton_on_pthread_once.h"
 #include "base/scoped_lock.h"
 #include "base/files/scoped_file.h"
+#include "base/files/file_enumerator.h"
 #include "base/file_util.h"
 #include "bvar/passive_status.h"
 
@@ -235,18 +236,15 @@ public:
 // ==================================================
 
 static int get_fd_count(int limit) {
-    DIR *dir = opendir("/proc/self/fd");
-    if (dir == NULL) {
-        PLOG_ONCE(WARNING) << "Fail to opendir /proc/self/fd";
-        return -1;
-    }
+    base::FileEnumerator fd_enum(base::FilePath("/proc/self/fd"),
+                                 false/*non recursive*/,
+                                 base::FileEnumerator::FILES);
     int count = 0;
-    dirent ent;
-    // We have to limit the scaning which consumes a lot of CPU when #fd
+    // Have to limit the scaning which consumes a lot of CPU when #fd
     // are huge (100k+)
-    for (dirent* p = &ent; readdir_r(dir, &ent, &p) == 0 && p &&
-             count <= limit; ++count) {}
-    closedir(dir);
+    for (base::FilePath name = fd_enum.Next();
+         !name.empty() && count <= limit;
+         name = fd_enum.Next(), ++count) {}
     return count - 2/*. and ..*/ - 1/*opendir itself*/;
 }
 

bvar/detail/agent_group.h

@@ -168,8 +168,7 @@ private:
     static pthread_mutex_t                      _s_mutex;
     static AgentId                              _s_agent_kinds;
     static std::deque<AgentId>                  *_s_free_ids;
-    static __thread
-        BAIDU_CACHELINE_ALIGNMENT std::vector<ThreadBlock *>    *_s_tls_blocks;
+    static __thread std::vector<ThreadBlock *>  *_s_tls_blocks;
 };
 
 template <typename Agent>

bvar/detail/combiner.h

@@ -7,8 +7,6 @@
 #define  BAIDU_BVAR__COMBINER_H
 
 #include <string>                       // std::string
-#include <algorithm>                    // std::swap until C++11
-#include <utility>                      // std::swap since C++11
 #include <vector>                       // std::vector
 #include "base/atomicops.h"             // base::atomic
 #include "base/scoped_lock.h"           // BAIDU_SCOPED_LOCK

config_brpc.sh

@@ -17,8 +17,8 @@ CC=gcc
 CXX=g++
 while true; do
     case "$1" in
-        --headers ) HDRS="$(readlink -f $2)"; shift 2 ;;
-        --libs ) LIBS="$(readlink -f $2)"; shift 2 ;;
+        --headers ) HDRS_IN="$(readlink -f $2)"; shift 2 ;;
+        --libs ) LIBS_IN="$(readlink -f $2)"; shift 2 ;;
         --cc ) CC=$2; shift 2 ;;
         --cxx ) CXX=$2; shift 2 ;;
         -- ) shift; break ;;
@@ -26,13 +26,13 @@ while true; do
     esac
 done
 
-if [ -z "$HDRS" ] || [ -z "$LIBS" ]; then
+if [ -z "$HDRS_IN" ] || [ -z "$LIBS_IN" ]; then
     >&2 $ECHO "config_brpc: --headers=HDRPATHS --libs=LIBPATHS must be specified"
     exit 1
 fi
 
 find_dir_of_lib() {
-    local lib=$(find ${LIBS} -name "lib${1}.a" -o -name "lib${1}.so*" | head -n1)
+    local lib=$(find ${LIBS_IN} -name "lib${1}.*" | head -n1)
     if [ ! -z "$lib" ]; then
         dirname $lib
     fi
@@ -40,7 +40,7 @@ find_dir_of_lib() {
 find_dir_of_lib_or_die() {
     local dir=$(find_dir_of_lib $1)
     if [ -z "$dir" ]; then
-        >&2 $ECHO "fail to find $1 from -libs"
+        >&2 $ECHO "Fail to find $1 from --libs"
         exit 1
     else
         $ECHO $dir
@@ -48,60 +48,77 @@ find_dir_of_lib_or_die() {
 }
 
 find_bin() {
-    find ${LIBS} -name "$1" | head -n1
+    TARGET_BIN=$(which "$1" 2>/dev/null)
+    if [ ! -z "$TARGET_BIN" ]; then
+        $ECHO $TARGET_BIN
+    else
+        find ${LIBS_IN} -name "$1" | head -n1
+    fi
+}
+find_bin_or_die() {
+    TARGET_BIN=$(find_bin "$1")
+    if [ -z "$TARGET_BIN" ]; then
+        >&2 $ECHO "Fail to find $1 from --libs"
+        exit 1
+    fi
+    $ECHO $TARGET_BIN
 }
 
 find_dir_of_header() {
-    find ${HDRS} -path "*/$1" | head -n1 | sed "s|$1||g"
+    find ${HDRS_IN} -path "*/$1" | head -n1 | sed "s|$1||g"
 }
 find_dir_of_header_or_die() {
     local dir=$(find_dir_of_header $1)
     if [ -z "$dir" ]; then
-        >&2 $ECHO "fail to find $1 from -incs"
+        >&2 $ECHO "Fail to find $1 from --headers"
         exit 1
     else
         $ECHO $dir
     fi
 }
 
+# required headers
+PTHREAD_HDR=$(find_dir_of_header_or_die pthread.h)
+OPENSSL_HDR=$(find_dir_of_header_or_die openssl/ssl.h)
+
 STATIC_LINKINGS=
 DYNAMIC_LINKINGS="-lpthread -lrt -lssl -lcrypto -ldl -lz"
 append_linking() {
     if [ -f $1/lib${2}.a ]; then
-        STATIC_LINKINGS="${STATIC_LINKINGS} -l$2"
+        STATIC_LINKINGS="$STATIC_LINKINGS -l$2"
+        export STATICALLY_LINKED_$2=1
     else
-        DYNAMIC_LINKINGS="${DYNAMIC_LINKINGS} -l$2"
+        DYNAMIC_LINKINGS="$DYNAMIC_LINKINGS -l$2"
+        export STATICALLY_LINKED_$2=0
     fi
 }
 
 GFLAGS_LIB=$(find_dir_of_lib_or_die gflags)
 append_linking $GFLAGS_LIB gflags
+
 PROTOBUF_LIB=$(find_dir_of_lib_or_die protobuf)
 append_linking $PROTOBUF_LIB protobuf
-PROTOC_LIB=$(find_dir_of_lib_or_die protoc)
+
 LEVELDB_LIB=$(find_dir_of_lib_or_die leveldb)
-append_linking $LEVELDB_LIB leveldb
-# required by leveldb
-SNAPPY_LIB=$(find_dir_of_lib snappy)
-if [ ! -z "$SNAPPY_LIB" ]; then
+if [ -f $LEVELDB_LIB/libleveldb.a ]; then
+	STATIC_LINKINGS="$STATIC_LINKINGS -lleveldb"
+	# required by leveldb
+	SNAPPY_LIB=$(find_dir_of_lib snappy)
+	if [ ! -z "$SNAPPY_LIB" ]; then
 		append_linking $SNAPPY_LIB snappy
-fi
-
-PROTOC=$(which protoc 2>/dev/null)
-if [ -z "$PROTOC" ]; then
-    PROTOC=$(find_bin protoc)
-    if [ -z "$PROTOC" ]; then
-        >&2 $ECHO "Fail to find protoc"
-        exit 1
 	fi
+else
+	DYNAMIC_LINKINGS="$DYNAMIC_LINKINGS -lleveldb"
 fi
 
-GFLAGS_HDR=$(find_dir_of_header gflags/gflags.h)
-PROTOBUF_HDR=$(find_dir_of_header google/protobuf/message.h)
-LEVELDB_HDR=$(find_dir_of_header leveldb/db.h)
+PROTOC=$(find_bin_or_die protoc)
+
+GFLAGS_HDR=$(find_dir_of_header_or_die gflags/gflags.h)
+PROTOBUF_HDR=$(find_dir_of_header_or_die google/protobuf/message.h)
+LEVELDB_HDR=$(find_dir_of_header_or_die leveldb/db.h)
 
-HDRS2=$($ECHO "$GFLAGS_HDR\n$PROTOBUF_HDR\n$LEVELDB_HDR" | sort | uniq)
-LIBS2=$($ECHO "$GFLAGS_LIB\n$PROTOBUF_LIB\n$LEVELDB_LIB\n$SNAPPY_LIB\n$PROTOC_LIB" | sort | uniq)
+HDRS=$($ECHO "$GFLAGS_HDR\n$PROTOBUF_HDR\n$LEVELDB_HDR" | sort | uniq)
+LIBS=$($ECHO "$GFLAGS_LIB\n$PROTOBUF_LIB\n$LEVELDB_LIB\n$SNAPPY_LIB" | sort | uniq)
 
 absent_in_the_list() {
     TMP=$($ECHO "`$ECHO "$1\n$2" | sort | uniq`")
@@ -111,96 +128,115 @@ absent_in_the_list() {
     return 0
 }
 
+OUTPUT_CONTENT="# Generated by config_brpc.sh, don't modify manually"
+append_to_output() {
+    OUTPUT_CONTENT="${OUTPUT_CONTENT}\n$*"
+}
+# $1: libname, $2: indentation
+append_to_output_headers() {
+    if absent_in_the_list "$1" "$HDRS"; then
+        append_to_output "${2}HDRS+=$1"
+        HDRS="${HDRS}\n$1"
+    fi
+}
+# $1: libname, $2: indentation
+append_to_output_libs() {
+    if absent_in_the_list "$1" "$LIBS"; then
+        append_to_output "${2}LIBS+=$1"
+        LIBS="${LIBS}\n$1"
+    fi
+}
+# $1: libdir, $2: libname, $3: indentation
+append_to_output_linkings() {
+    if [ -f $1/lib$2.a ]; then
+        append_to_output "${3}STATIC_LINKINGS+=-l$2"
+        export STATICALLY_LINKED_$2=1
+    else
+        append_to_output "${3}DYNAMIC_LINKINGS+=-l$2"
+        export STATICALLY_LINKED_$2=0
+    fi
+}
+
 #can't use \n in texts because sh does not support -e
-CONTENT="HDRS=$($ECHO $HDRS2)"
-CONTENT="${CONTENT}\nLIBS=$($ECHO $LIBS2)"
-CONTENT="${CONTENT}\nPROTOC=$PROTOC"
-CONTENT="${CONTENT}\nPROTOBUF_HDR=$PROTOBUF_HDR"
-CONTENT="${CONTENT}\nCC=$CC"
-CONTENT="${CONTENT}\nCXX=$CXX"
-CONTENT="${CONTENT}\nSTATIC_LINKINGS=$STATIC_LINKINGS"
-CONTENT="${CONTENT}\nDYNAMIC_LINKINGS=$DYNAMIC_LINKINGS"
-CONTENT="${CONTENT}\nifeq (\$(NEED_GPERFTOOLS), 1)"
+append_to_output "HDRS=$($ECHO $HDRS)"
+append_to_output "LIBS=$($ECHO $LIBS)"
+append_to_output "PROTOC=$PROTOC"
+append_to_output "PROTOBUF_HDR=$PROTOBUF_HDR"
+append_to_output "CC=$CC"
+append_to_output "CXX=$CXX"
+append_to_output "STATIC_LINKINGS=$STATIC_LINKINGS"
+append_to_output "DYNAMIC_LINKINGS=$DYNAMIC_LINKINGS"
+
+append_to_output "ifeq (\$(NEED_LIBPROTOC), 1)"
+PROTOC_LIB=$(find $PROTOBUF_LIB -name "libprotoc.*" | head -n1)
+if [ -z "$PROTOC_LIB" ]; then
+    append_to_output "   \$(error \"Fail to find libprotoc\")"
+else
+    # libprotobuf and libprotoc must be linked same statically or dynamically
+    # otherwise the bin will crash.
+    if [ $STATICALLY_LINKED_protobuf -gt 0 ]; then
+        append_to_output "    STATIC_LINKINGS+=-lprotoc"
+    else
+        append_to_output "    DYNAMIC_LINKINGS+=-lprotoc"
+    fi
+fi
+append_to_output "endif"
+
+append_to_output "ifeq (\$(NEED_GPERFTOOLS), 1)"
 # required by cpu/heap profiler
 TCMALLOC_LIB=$(find_dir_of_lib tcmalloc_and_profiler)
 if [ -z "$TCMALLOC_LIB" ]; then
-    CONTENT="${CONTENT}\n    \$(error \"Fail to find gperftools\")"
+    append_to_output "    \$(error \"Fail to find gperftools\")"
 else
-    if absent_in_the_list "$TCMALLOC_LIB" "$LIBS2"; then
-        CONTENT="${CONTENT}\n    LIBS+=$TCMALLOC_LIB"
-        LIBS2="${LIBS2}\n$TCMALLOC_LIB"
+    append_to_output_libs "$TCMALLOC_LIB" "    "
+    TCMALLOC_HDR=$(find_dir_of_header_or_die google/profiler.h)
+    append_to_output_headers "$TCMALLOC_HDR" "    "
+    append_to_output_linkings $TCMALLOC_LIB tcmalloc_and_profiler "    "
+    if [ $STATICALLY_LINKED_tcmalloc_and_profiler -gt 0 ]; then
+        # required by tcmalloc('s profiler)
+        UNWIND_LIB=$(find_dir_of_lib unwind)
+        if [ ! -z "$UNWIND_LIB" ]; then
+            append_to_output_libs $UNWIND_LIB "    "
+            append_to_output_linkings $UNWIND_LIB unwind "    "
+            if [ $STATICALLY_LINKED_unwind -gt 0 ]; then
+                # required by libunwind
+                LZMA_LIB=$(find_dir_of_lib lzma)
+                if [ ! -z "$LZMA_LIB" ]; then
+                    append_to_output_linkings $LZMA_LIB lzma "    "
                 fi
-    TCMALLOC_HDR=$(find_dir_of_header google/tcmalloc.h)
-    if absent_in_the_list "$TCMALLOC_HDR" "$HDRS2"; then
-        CONTENT="${CONTENT}\n    HDRS+=$TCMALLOC_HDR"
-        HDRS2="${HDRS2}\n$TCMALLOC_HDR"
             fi
-    if [ -f $TCMALLOC_LIB/libtcmalloc_and_profiler.a ]; then
-        CONTENT="${CONTENT}\n    STATIC_LINKINGS+=-ltcmalloc_and_profiler"
-    else
-        CONTENT="${CONTENT}\n    DYNAMIC_LINKINGS+=-ltcmalloc_and_profiler"
         fi
-fi
-# required by tcmalloc('s profiler)
-UNWIND_LIB=$(find_dir_of_lib unwind)
-if [ ! -z "$UNWIND_LIB" ]; then
-    if absent_in_the_list "$UNWIND_LIB" "$LIBS2"; then
-        CONTENT="${CONTENT}\n    LIBS+=$UNWIND_LIB"
-        LIBS2="${LIBS2}\n$UNWIND_LIB"
-    fi
-    if [ -f $UNWIND_LIB/libunwind.a ]; then
-        CONTENT="${CONTENT}\n    STATIC_LINKINGS+=-lunwind"
-    else
-        CONTENT="${CONTENT}\n    DYNAMIC_LINKINGS+=-lunwind"
     fi
-    # required by libunwind
-    CONTENT="${CONTENT}\n    DYNAMIC_LINKINGS+=-llzma"
 fi
-CONTENT="${CONTENT}\nendif"
+append_to_output "endif"
 
 # required by UT
 #gtest
 GTEST_LIB=$(find_dir_of_lib gtest)
-CONTENT="${CONTENT}\nifeq (\$(NEED_GTEST), 1)"
+append_to_output "ifeq (\$(NEED_GTEST), 1)"
 if [ -z "$GTEST_LIB" ]; then
-    CONTENT="${CONTENT}\n    \$(error \"Fail to find gtest\")"
+    append_to_output "    \$(error \"Fail to find gtest\")"
 else
-    GTEST_HDR=$(find_dir_of_header gtest/gtest.h)
-    if absent_in_the_list "$GTEST_LIB" "$LIBS2"; then
-        CONTENT="${CONTENT}\n    LIBS+=$GTEST_LIB"
-        LIBS2="${LIBS2}\n$GTEST_LIB"
-    fi
-    if absent_in_the_list "$GTEST_HDR" "$HDRS2"; then
-        CONTENT="${CONTENT}\n    HDRS+=$GTEST_HDR"
-        HDRS2="${HDRS2}\n$GTEST_HDR"
-    fi
-    if [ -f $GTEST_LIB/libgtest.a ]; then
-        CONTENT="${CONTENT}\n    STATIC_LINKINGS+=-lgtest -lgtest_main"
-    else
-        CONTENT="${CONTENT}\n    DYNAMIC_LINKINGS+=-lgtest -lgtest_main"
-    fi
+    GTEST_HDR=$(find_dir_of_header_or_die gtest/gtest.h)
+    append_to_output_libs $GTEST_LIB "    "
+    append_to_output_headers $GTEST_HDR "    "
+    append_to_output_linkings $GTEST_LIB gtest "    "
+    append_to_output_linkings $GTEST_LIB gtest_main "    "
 fi
-CONTENT="${CONTENT}\nendif"
+append_to_output "endif"
 #gmock
 GMOCK_LIB=$(find_dir_of_lib gmock)
-CONTENT="${CONTENT}\nifeq (\$(NEED_GMOCK), 1)"
+append_to_output "ifeq (\$(NEED_GMOCK), 1)"
 if [ -z "$GMOCK_LIB" ]; then
-    CONTENT="${CONTENT}\n    \$(error \"Fail to find gmock\")"
+    append_to_output "    \$(error \"Fail to find gmock\")"
 else
-    GMOCK_HDR=$(find_dir_of_header gmock/gmock.h)
-    if absent_in_the_list "$GMOCK_LIB" "$LIBS2"; then
-        CONTENT="${CONTENT}\n    LIBS+=$GMOCK_LIB"
-        LIBS2="${LIBS2}\n$GMOCK_LIB"
-    fi
-    if absent_in_the_list "$GMOCK_HDR" "$HDRS2"; then
-        CONTENT="${CONTENT}\n    HDRS+=$GMOCK_HDR"
-        HDRS2="${HDRS2}\n$GMOCK_HDR"
-    fi
-    if [ -f $GMOCK_LIB/libgmock.a ]; then
-        CONTENT="${CONTENT}\n    STATIC_LINKINGS+=-lgmock -lgmock_main"
-    else
-        CONTENT="${CONTENT}\n    DYNAMIC_LINKINGS+=-lgmock -lgmock_main"
-    fi
+    GMOCK_HDR=$(find_dir_of_header_or_die gmock/gmock.h)
+    append_to_output_libs $GMOCK_LIB "    "
+    append_to_output_headers $GMOCK_HDR "    "
+    append_to_output_linkings $GMOCK_LIB gmock "    "
+    append_to_output_linkings $GMOCK_LIB gmock_main "    "
 fi
-CONTENT="${CONTENT}\nendif"
-$ECHO "$CONTENT" > config.mk
+append_to_output "endif"
+
+# write to config.mk
+$ECHO "$OUTPUT_CONTENT" > config.mk

test/Makefile

@@ -4,8 +4,11 @@ NEED_GMOCK=1
 include ../config.mk
 CPPFLAGS=-DBTHREAD_USE_FAST_PTHREAD_MUTEX -D__const__= -D_GNU_SOURCE -DUSE_SYMBOLIZE -DNO_TCMALLOC -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS
 CPPFLAGS+=-DUNIT_TEST -Dprivate=public -Dprotected=public -DBVAR_NOT_LINK_DEFAULT_VARIABLES
-CXXFLAGS=$(CPPFLAGS) -g -pipe -Wall -W -Werror -fPIC -fstrict-aliasing -Wno-invalid-offsetof -Wno-unused-parameter -fno-omit-frame-pointer -std=c++0x
-CFLAGS=$(CPPFLAGS) -g -pipe -Wall -W -Werror -fPIC -fstrict-aliasing -Wno-unused-parameter -fno-omit-frame-pointer
+CXXFLAGS=$(CPPFLAGS) -g -pipe -Wall -W -fPIC -fstrict-aliasing -Wno-invalid-offsetof -Wno-unused-parameter -fno-omit-frame-pointer -std=c++0x
+CFLAGS=$(CPPFLAGS) -g -pipe -Wall -W -fPIC -fstrict-aliasing -Wno-unused-parameter -fno-omit-frame-pointer
+ifeq ($(shell test $(shell $(CXX) -dumpversion) -ge 7; echo $$?),0)
+CXXFLAGS+=-Wno-aligned-new
+endif
 
 HDRPATHS=-I. -I.. $(addprefix -I, $(HDRS))
 LIBPATHS=$(addprefix -L, $(LIBS))