Skip to content

B
brpc
Commit 50625b48 authored by James Ge's avatar James Ge
Browse files
Options

Support gcc7 glib2.25 openssl 1.1 and fedora26 

Change-Id: I05e1685765ed24345ff8af6cf3608d674fa5ab05
parent 76664c60
Show whitespace changes
Inline Side-by-side
Showing with 932 additions and 446 deletions
Makefile
View file @ 50625b48
NEED_LIBPROTOC=1
include config.mk 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)\" 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 -fPIC -fstrict-aliasing -Wno-invalid-offsetof -Wno-unused-parameter -fno-omit-frame-pointer -std=c++0x -include brpc/config.h
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 -fPIC -fstrict-aliasing -Wno-unused-parameter -fno-omit-frame-pointer
CFLAGS=$(CPPFLAGS) -O2 -g -pipe -Wall -W -Werror -fPIC -fstrict-aliasing -Wno-unused-parameter -fno-omit-frame-pointer
HDRPATHS=-I. $(addprefix -I, $(HDRS)) HDRPATHS=-I. $(addprefix -I, $(HDRS))
LIBPATHS = $(addprefix -L, $(LIBS)) LIBPATHS = $(addprefix -L, $(LIBS))
SRCEXTS = .c .cc .cpp .proto SRCEXTS = .c .cc .cpp .proto
HDREXTS = .h .hpp 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_SOURCES = \
base/third_party/dmg_fp/g_fmt.cc \ base/third_party/dmg_fp/g_fmt.cc \
......
base/errno.cpp
View file @ 50625b48
...@@ -15,13 +15,13 @@ ...@@ -15,13 +15,13 @@
namespace base { namespace base {
static const int ERRNO_BEGIN = -32768; const int ERRNO_BEGIN = -32768;
static const int ERRNO_END = 32768; const int ERRNO_END = 32768;
const char* errno_desc[ERRNO_END - ERRNO_BEGIN] = {}; static const char* errno_desc[ERRNO_END - ERRNO_BEGIN] = {};
pthread_mutex_t modify_desc_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t modify_desc_mutex = PTHREAD_MUTEX_INITIALIZER;
static const size_t UNKNOWN_ERROR_BUFSIZE = 32; const size_t ERROR_BUFSIZE = 64;
__thread char unknown_error_buf[UNKNOWN_ERROR_BUFSIZE]; __thread char tls_error_buf[ERROR_BUFSIZE];
int DescribeCustomizedErrno( int DescribeCustomizedErrno(
int error_code, const char* error_name, const char* description) { int error_code, const char* error_name, const char* description) {
...@@ -32,21 +32,19 @@ int DescribeCustomizedErrno( ...@@ -32,21 +32,19 @@ int DescribeCustomizedErrno(
error_name, error_code); error_name, error_code);
} }
const char* desc = errno_desc[error_code - ERRNO_BEGIN]; 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 (desc) {
if (strcmp(desc, description) == 0) { if (strcmp(desc, description) == 0) {
fprintf(stderr, "WARNING: Detected shared library loading\n"); 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, error(EXIT_FAILURE, 0,
"Fail to define %s(%d) which is already defined as `%s', abort.", "Fail to define %s(%d) which is already defined as `%s', abort.",
error_name, error_code, desc); error_name, error_code, desc);
} }
}
errno_desc[error_code - ERRNO_BEGIN] = description; errno_desc[error_code - ERRNO_BEGIN] = description;
return 0; // must return 0; // must
} }
...@@ -55,24 +53,21 @@ int DescribeCustomizedErrno( ...@@ -55,24 +53,21 @@ int DescribeCustomizedErrno(
const char* berror(int error_code) { const char* berror(int error_code) {
if (error_code == -1) { if (error_code == -1) {
return "General Error(-1)"; return "General Error -1";
} }
if (error_code >= base::ERRNO_BEGIN && error_code < base::ERRNO_END) { if (error_code >= base::ERRNO_BEGIN && error_code < base::ERRNO_END) {
const char* s = base::errno_desc[error_code - base::ERRNO_BEGIN]; const char* s = base::errno_desc[error_code - base::ERRNO_BEGIN];
if (s) { if (s) {
return s; return s;
} }
// g++ 4.8.2 reports nonnull warning for directly using NULL as the s = strerror_r(error_code, base::tls_error_buf, base::ERROR_BUFSIZE);
// second parameter to strerror_r which is totally valid.
char* cheat_nonnull = NULL;
s = strerror_r(error_code, cheat_nonnull, 0);
if (s) { // strerror_r returns NULL if error_code is unknown if (s) { // strerror_r returns NULL if error_code is unknown
return s; return s;
} }
} }
snprintf(base::unknown_error_buf, base::UNKNOWN_ERROR_BUFSIZE, snprintf(base::tls_error_buf, base::ERROR_BUFSIZE,
"Unknown Error(%d)", error_code); "Unknown Error %d", error_code);
return base::unknown_error_buf; return base::tls_error_buf;
} }
const char* berror() { const char* berror() {
......
base/files/file_enumerator_posix.cc
View file @ 50625b48
...@@ -129,9 +129,17 @@ bool FileEnumerator::ReadDirectory(std::vector<FileInfo>* entries, ...@@ -129,9 +129,17 @@ bool FileEnumerator::ReadDirectory(std::vector<FileInfo>* entries,
additional space for pathname may be needed additional space for pathname may be needed
#endif #endif
struct dirent dent_buf;
struct dirent* dent; 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) { while (readdir_r(dir, &dent_buf, &dent) == 0 && dent) {
#endif
FileInfo info; FileInfo info;
info.filename_ = FilePath(dent->d_name); info.filename_ = FilePath(dent->d_name);
......
base/iobuf.h
View file @ 50625b48
...@@ -652,15 +652,17 @@ private: ...@@ -652,15 +652,17 @@ private:
} // namespace base } // namespace base
// Specialize std::swap for IOBuf // 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 { namespace std {
template <class T> void swap ( T& a, T& b );
template <> template <>
inline void swap(base::IOBuf& a, base::IOBuf& b) { inline void swap(base::IOBuf& a, base::IOBuf& b) {
return a.swap(b); return a.swap(b);
} }
} // namespace std
};
#include "base/iobuf_inl.h" #include "base/iobuf_inl.h"
......
base/safe_strerror_posix.cc
View file @ 50625b48
...@@ -9,7 +9,11 @@ ...@@ -9,7 +9,11 @@
#include <stdio.h> #include <stdio.h>
#include <string.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__) #if USE_HISTORICAL_STRERRO_R && defined(__GNUC__)
// GCC will complain about the unused second wrap function unless we tell it // GCC will complain about the unused second wrap function unless we tell it
......
base/ssl_compat.h 0 → 100644
View file @ 50625b48
/* 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
View file @ 50625b48
...@@ -10,6 +10,12 @@ ...@@ -10,6 +10,12 @@
#include "base/strings/string_util.h" #include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.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 {
namespace { namespace {
......
base/third_party/dmg_fp/dtoa.cc
View file @ 50625b48
...@@ -1840,7 +1840,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign) ...@@ -1840,7 +1840,7 @@ gethex( CONST char **sp, U *rvp, int rounding, int sign)
switch(*++s) { switch(*++s) {
case '-': case '-':
esign = 1; esign = 1;
/* no break */ // fall through
case '+': case '+':
s++; s++;
} }
...@@ -2462,11 +2462,11 @@ strtod ...@@ -2462,11 +2462,11 @@ strtod
for(s = s00;;s++) switch(*s) { for(s = s00;;s++) switch(*s) {
case '-': case '-':
sign = 1; sign = 1;
/* no break */ // fall through
case '+': case '+':
if (*++s) if (*++s)
goto break2; goto break2;
/* no break */ // fall through
case 0: case 0:
goto ret0; goto ret0;
case '\t': case '\t':
...@@ -2570,6 +2570,7 @@ strtod ...@@ -2570,6 +2570,7 @@ strtod
switch(c = *++s) { switch(c = *++s) {
case '-': case '-':
esign = 1; esign = 1;
// fall through
case '+': case '+':
c = *++s; c = *++s;
} }
...@@ -3755,7 +3756,7 @@ dtoa ...@@ -3755,7 +3756,7 @@ dtoa
break; break;
case 2: case 2:
leftright = 0; leftright = 0;
/* no break */ // fall through
case 4: case 4:
if (ndigits <= 0) if (ndigits <= 0)
ndigits = 1; ndigits = 1;
...@@ -3763,7 +3764,7 @@ dtoa ...@@ -3763,7 +3764,7 @@ dtoa
break; break;
case 3: case 3:
leftright = 0; leftright = 0;
/* no break */ // fall through
case 5: case 5:
i = ndigits + k + 1; i = ndigits + k + 1;
ilim = i; ilim = i;
......
base/third_party/icu/icu_utf.cc
View file @ 50625b48
...@@ -159,10 +159,12 @@ utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c, ...@@ -159,10 +159,12 @@ utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c,
illegal=1; illegal=1;
break; break;
} }
// fall through
case 2: case 2:
trail=s[(i)++]; trail=s[(i)++];
(c)=((c)<<6)|(trail&0x3f); (c)=((c)<<6)|(trail&0x3f);
illegal|=(trail&0xc0)^0x80; illegal|=(trail&0xc0)^0x80;
// fall through
case 1: case 1:
trail=s[(i)++]; trail=s[(i)++];
(c)=((c)<<6)|(trail&0x3f); (c)=((c)<<6)|(trail&0x3f);
......
base/third_party/murmurhash3/murmurhash3.cpp
View file @ 50625b48
...@@ -17,6 +17,11 @@ ...@@ -17,6 +17,11 @@
#include <algorithm> // std::min #include <algorithm> // std::min
#include "base/third_party/murmurhash3/murmurhash3.h" #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 // Platform-specific functions and macros
......
brpc/amf.cpp
View file @ 50625b48
...@@ -433,6 +433,7 @@ static bool ReadAMFObjectField(AMFInputStream* stream, ...@@ -433,6 +433,7 @@ static bool ReadAMFObjectField(AMFInputStream* stream,
LOG(ERROR) << "Fail to read class_name"; LOG(ERROR) << "Fail to read class_name";
} }
} }
// fall through
case AMF_MARKER_OBJECT: { case AMF_MARKER_OBJECT: {
if (field) { if (field) {
if (field->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) { if (field->cpp_type() != google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
...@@ -633,6 +634,7 @@ static bool ReadAMFObjectField(AMFInputStream* stream, ...@@ -633,6 +634,7 @@ static bool ReadAMFObjectField(AMFInputStream* stream,
LOG(ERROR) << "Fail to read class_name"; LOG(ERROR) << "Fail to read class_name";
} }
} }
// fall through
case AMF_MARKER_OBJECT: { case AMF_MARKER_OBJECT: {
if (!ReadAMFObjectBody(obj->MutableObject(name), stream)) { if (!ReadAMFObjectBody(obj->MutableObject(name), stream)) {
return false; return false;
...@@ -781,6 +783,7 @@ static bool ReadAMFArrayItem(AMFInputStream* stream, AMFArray* arr) { ...@@ -781,6 +783,7 @@ static bool ReadAMFArrayItem(AMFInputStream* stream, AMFArray* arr) {
LOG(ERROR) << "Fail to read class_name"; LOG(ERROR) << "Fail to read class_name";
} }
} }
// fall through
case AMF_MARKER_OBJECT: { case AMF_MARKER_OBJECT: {
if (!ReadAMFObjectBody(arr->AddObject(), stream)) { if (!ReadAMFObjectBody(arr->AddObject(), stream)) {
return false; return false;
......
brpc/builtin/dir_service.cpp
View file @ 50625b48
...@@ -75,8 +75,14 @@ void DirService::default_method(::google::protobuf::RpcController* cntl_base, ...@@ -75,8 +75,14 @@ void DirService::default_method(::google::protobuf::RpcController* cntl_base,
std::vector<std::string> files; std::vector<std::string> files;
files.reserve(32); files.reserve(32);
struct dirent ent; // readdir_r is marked as deprecated since glibc 2.24.
for (struct dirent* p = &ent; readdir_r(dir, &ent, &p) == 0 && p; ) { #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); files.push_back(p->d_name);
} }
CHECK_EQ(0, closedir(dir)); CHECK_EQ(0, closedir(dir));
......
brpc/controller.cpp
View file @ 50625b48
...@@ -664,6 +664,7 @@ void Controller::Call::OnComplete(Controller* c, int error_code/*note*/, ...@@ -664,6 +664,7 @@ void Controller::Call::OnComplete(Controller* c, int error_code/*note*/,
} }
break; break;
} }
// fall through
case CONNECTION_TYPE_SHORT: case CONNECTION_TYPE_SHORT:
if (sending_sock != NULL) { if (sending_sock != NULL) {
// Check the comment in CONNECTION_TYPE_POOLED branch. // Check the comment in CONNECTION_TYPE_POOLED branch.
......
brpc/details/http_parser.cpp
View file @ 50625b48
...@@ -2271,8 +2271,7 @@ http_parser_parse_url(const char *buf, size_t buflen, int is_connect, ...@@ -2271,8 +2271,7 @@ http_parser_parse_url(const char *buf, size_t buflen, int is_connect,
case s_req_server_with_at: case s_req_server_with_at:
found_at = 1; found_at = 1;
// fall through
/* FALLTROUGH */
case s_req_server: case s_req_server:
uf = UF_HOST; uf = UF_HOST;
break; break;
......
brpc/details/ssl_helper.cpp
View file @ 50625b48
...@@ -11,19 +11,12 @@ ...@@ -11,19 +11,12 @@
#include <openssl/x509v3.h> #include <openssl/x509v3.h>
#include "base/unique_ptr.h" #include "base/unique_ptr.h"
#include "base/logging.h" #include "base/logging.h"
#include "base/ssl_compat.h"
#include "brpc/socket.h" #include "brpc/socket.h"
#include "brpc/details/ssl_helper.h" #include "brpc/details/ssl_helper.h"
namespace brpc { 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 #ifndef OPENSSL_NO_DH
static DH* g_dh_1024 = NULL; static DH* g_dh_1024 = NULL;
static DH* g_dh_2048 = NULL; static DH* g_dh_2048 = NULL;
...@@ -157,7 +150,7 @@ static void SSLMessageCallback(int write_p, int version, int content_type, ...@@ -157,7 +150,7 @@ static void SSLMessageCallback(int write_p, int version, int content_type,
static DH* SSLGetDHCallback(SSL* ssl, int exp, int keylen) { static DH* SSLGetDHCallback(SSL* ssl, int exp, int keylen) {
(void)exp; (void)exp;
EVP_PKEY* pkey = SSL_get_privatekey(ssl); 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. // The keylen supplied by OpenSSL can only be 512 or 1024.
// See ssl3_send_server_key_exchange() in ssl/s3_srvr.c // 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) { ...@@ -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) { while ((i = X509_NAME_get_index_by_NID(xname, NID_commonName, i)) != -1) {
char* str = NULL; char* str = NULL;
X509_NAME_ENTRY* entry = X509_NAME_get_entry(xname, i); X509_NAME_ENTRY* entry = X509_NAME_get_entry(xname, i);
if (ASN1_STRING_to_UTF8((unsigned char**)&str, entry->value) >= 0) { const int len = ASN1_STRING_to_UTF8((unsigned char**)&str,
std::string hostname(str); X509_NAME_ENTRY_get_data(entry));
if (len >= 0) {
std::string hostname(str, len);
hostnames->push_back(hostname); hostnames->push_back(hostname);
OPENSSL_free(str); OPENSSL_free(str);
} }
...@@ -303,10 +298,14 @@ SSL_CTX* CreateSSLContext(const std::string& certificate, ...@@ -303,10 +298,14 @@ SSL_CTX* CreateSSLContext(const std::string& certificate,
} }
// Load the certificate chain // Load the certificate chain
#if (OPENSSL_VERSION_NUMBER >= 0x10002000L)
SSL_CTX_clear_chain_certs(ssl_ctx.get());
#else
if (ssl_ctx->extra_certs != NULL) { if (ssl_ctx->extra_certs != NULL) {
sk_X509_pop_free(ssl_ctx->extra_certs, X509_free); sk_X509_pop_free(ssl_ctx->extra_certs, X509_free);
ssl_ctx->extra_certs = NULL; ssl_ctx->extra_certs = NULL;
} }
#endif
X509* ca = NULL; X509* ca = NULL;
while ((ca = PEM_read_bio_X509(cbio.get(), NULL, 0, NULL))) { while ((ca = PEM_read_bio_X509(cbio.get(), NULL, 0, NULL))) {
if (SSL_CTX_add_extra_chain_cert(ssl_ctx.get(), ca) != 1) { if (SSL_CTX_add_extra_chain_cert(ssl_ctx.get(), ca) != 1) {
...@@ -460,6 +459,8 @@ SSLState DetectSSLState(int fd, int* error_code) { ...@@ -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 // NOTE: Can't find a macro for CRYPTO_THREADID
// Fallback to use CRYPTO_LOCK_ECDH as flag // Fallback to use CRYPTO_LOCK_ECDH as flag
#ifdef CRYPTO_LOCK_ECDH #ifdef CRYPTO_LOCK_ECDH
...@@ -472,6 +473,13 @@ static unsigned long SSLGetThreadId() { ...@@ -472,6 +473,13 @@ static unsigned long SSLGetThreadId() {
} }
#endif // CRYPTO_LOCK_ECDH #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) { static void SSLLockCallback(int mode, int n, const char* file, int line) {
(void)file; (void)file;
(void)line; (void)line;
...@@ -485,279 +493,112 @@ static void SSLLockCallback(int mode, int n, const char* file, int line) { ...@@ -485,279 +493,112 @@ static void SSLLockCallback(int mode, int n, const char* file, int line) {
g_ssl_mutexs[n].unlock(); g_ssl_mutexs[n].unlock();
} }
} }
#endif // OPENSSL_VERSION_NUMBER < 0x10100000L
int SSLThreadInit() { int SSLThreadInit() {
#if OPENSSL_VERSION_NUMBER < 0x10100000L
g_ssl_mutexs = new base::Mutex[CRYPTO_num_locks()]; g_ssl_mutexs = new base::Mutex[CRYPTO_num_locks()];
CRYPTO_set_locking_callback(SSLLockCallback); CRYPTO_set_locking_callback(SSLLockCallback);
#ifdef CRYPTO_LOCK_ECDH # ifdef CRYPTO_LOCK_ECDH
CRYPTO_THREADID_set_callback(SSLGetThreadId); CRYPTO_THREADID_set_callback(SSLGetThreadId);
#else # else
CRYPTO_set_id_callback(SSLGetThreadId); CRYPTO_set_id_callback(SSLGetThreadId);
#endif // CRYPTO_LOCK_ECDH # endif // CRYPTO_LOCK_ECDH
#endif // OPENSSL_VERSION_NUMBER < 0x10100000L
return 0; return 0;
} }
#ifndef OPENSSL_NO_DH #ifndef OPENSSL_NO_DH
static DH* SSLGetDH1024() { static DH* SSLGetDH1024() {
#if OPENSSL_VERSION_NUMBER < 0x0090801fL BIGNUM* p = get_rfc2409_prime_1024(NULL);
static const unsigned char rfc_2409_prime_1024[] = { if (!p) {
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) {
return NULL; 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" // See RFC 2409, Section 6 "Oakley Groups"
// for the reason why 2 is used as generator. // for the reason why 2 is used as generator.
BN_dec2bn(&dh->g, "2"); BIGNUM* g = NULL;
if (!dh->p || !dh->g) { BN_dec2bn(&g, "2");
DH_free(dh); if (!g) {
BN_free(p);
return NULL;
}
DH *dh = DH_new();
if (!dh) {
BN_free(p);
BN_free(g);
return NULL; return NULL;
} }
DH_set0_pqg(dh, p, NULL, g);
return dh; return dh;
} }
static DH* SSLGetDH2048() { static DH* SSLGetDH2048() {
#if OPENSSL_VERSION_NUMBER < 0x0090801fL BIGNUM* p = get_rfc3526_prime_2048(NULL);
static const unsigned char rfc_3526_prime_2048[] = { if (!p) {
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) {
return NULL; 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" // See RFC 3526, Section 3 "2048-bit MODP Group"
// for the reason why 2 is used as generator. // for the reason why 2 is used as generator.
BN_dec2bn(&dh->g, "2"); BIGNUM* g = NULL;
if (!dh->p || !dh->g) { BN_dec2bn(&g, "2");
DH_free(dh); if (!g) {
BN_free(p);
return NULL;
}
DH* dh = DH_new();
if (!dh) {
BN_free(p);
BN_free(g);
return NULL; return NULL;
} }
DH_set0_pqg(dh, p, NULL, g);
return dh; return dh;
} }
static DH* SSLGetDH4096() { static DH* SSLGetDH4096() {
#if OPENSSL_VERSION_NUMBER < 0x0090801fL BIGNUM* p = get_rfc3526_prime_4096(NULL);
static const unsigned char rfc_3526_prime_4096[] = { if (!p) {
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) {
return NULL; 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" // See RFC 3526, Section 5 "4096-bit MODP Group"
// for the reason why 2 is used as generator. // for the reason why 2 is used as generator.
BN_dec2bn(&dh->g, "2"); BIGNUM* g = NULL;
if (!dh->p || !dh->g) { BN_dec2bn(&g, "2");
DH_free(dh); if (!g) {
BN_free(p);
return NULL; 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; return dh;
} }
static DH* SSLGetDH8192() { static DH* SSLGetDH8192() {
#if OPENSSL_VERSION_NUMBER < 0x0090801fL BIGNUM* p = get_rfc3526_prime_8192(NULL);
static const unsigned char rfc_3526_prime_8192[] = { if (!p) {
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) {
return NULL; 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" // See RFC 3526, Section 7 "8192-bit MODP Group"
// for the reason why 2 is used as generator. // for the reason why 2 is used as generator.
BN_dec2bn(&dh->g, "2"); BIGNUM* g = NULL;
if (!dh->p || !dh->g) { BN_dec2bn(&g, "2");
DH_free(dh); if (!g) {
BN_free(g);
return NULL; 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; return dh;
} }
...@@ -786,4 +627,3 @@ int SSLDHInit() { ...@@ -786,4 +627,3 @@ int SSLDHInit() {
} }
} // namespace brpc } // namespace brpc
brpc/policy/dh.cpp
View file @ 50625b48
...@@ -22,30 +22,14 @@ ...@@ -22,30 +22,14 @@
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "base/logging.h" #include "base/logging.h"
#include "base/ssl_compat.h"
#include "brpc/policy/dh.h" #include "brpc/policy/dh.h"
namespace brpc { namespace brpc {
namespace policy { namespace policy {
#define RFC2409_PRIME_1024 \
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" \
"29024E088A67CC74020BBEA63B139B22514A08798E3404DD" \
"EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" \
"E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" \
"EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381" \
"FFFFFFFFFFFFFFFF"
void DHWrapper::clear() { void DHWrapper::clear() {
if (_pdh != NULL) { 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); DH_free(_pdh);
_pdh = NULL; _pdh = NULL;
} }
...@@ -57,7 +41,9 @@ int DHWrapper::initialize(bool ensure_128bytes_public_key) { ...@@ -57,7 +41,9 @@ int DHWrapper::initialize(bool ensure_128bytes_public_key) {
return -1; return -1;
} }
if (ensure_128bytes_public_key) { 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) { if (key_size != 128) {
RPC_VLOG << "regenerate 128B key, current=" << key_size; RPC_VLOG << "regenerate 128B key, current=" << key_size;
clear(); clear();
...@@ -70,15 +56,17 @@ int DHWrapper::initialize(bool ensure_128bytes_public_key) { ...@@ -70,15 +56,17 @@ int DHWrapper::initialize(bool ensure_128bytes_public_key) {
} }
int DHWrapper::copy_public_key(char* pkey, int* pkey_size) const { 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. // copy public key to bytes.
// sometimes, the key_size is 127, seems ok. // 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); CHECK_GT(key_size, 0);
// maybe the key_size is 127, but dh will write all 128bytes pkey, // maybe the key_size is 127, but dh will write all 128bytes pkey,
// no need to set/initialize the pkey. // no need to set/initialize the pkey.
// @see https://github.com/ossrs/srs/issues/165 // @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); CHECK_GT(key_size, 0);
// output the size of public key. // output the size of public key.
...@@ -107,40 +95,27 @@ int DHWrapper::copy_shared_key(const void* ppkey, int ppkey_size, ...@@ -107,40 +95,27 @@ int DHWrapper::copy_shared_key(const void* ppkey, int ppkey_size,
} }
int DHWrapper::do_initialize() { int DHWrapper::do_initialize() {
int bits_count = 1024; BIGNUM* p = get_rfc2409_prime_1024(NULL);
if (!p) {
//1. Create the DH
if ((_pdh = DH_new()) == NULL) {
LOG(ERROR) << "Fail to DH_new";
return -1; return -1;
} }
// See RFC 2409, Section 6 "Oakley Groups"
//2. Create his internal p and g // for the reason why 2 is used as generator.
if ((_pdh->p = BN_new()) == NULL) { BIGNUM* g = NULL;
LOG(ERROR) << "Fail to BN_new _pdh->p"; BN_dec2bn(&g, "2");
if (!g) {
BN_free(p);
return -1; return -1;
} }
if ((_pdh->g = BN_new()) == NULL) { _pdh = DH_new();
LOG(ERROR) << "Fail to BN_new _pdh->g"; if (!_pdh) {
BN_free(p);
BN_free(g);
return -1; return -1;
} }
DH_set0_pqg(_pdh, p, NULL, g);
//3. initialize p and g, @see ./test/ectest.c:260 // Generate private and public key
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
if (!DH_generate_key(_pdh)) { if (!DH_generate_key(_pdh)) {
LOG(ERROR) << "Fail to DH_generate_key"; LOG(ERROR) << "Fail to DH_generate_key";
return -1; return -1;
...@@ -148,8 +123,6 @@ int DHWrapper::do_initialize() { ...@@ -148,8 +123,6 @@ int DHWrapper::do_initialize() {
return 0; return 0;
} }
#undef RFC2409_PRIME_1024
} // namespace policy } // namespace policy
} // namespace brpc } // namespace brpc
brpc/policy/http_rpc_protocol.cpp
View file @ 50625b48
...@@ -168,7 +168,7 @@ static void PrintMessage(const base::IOBuf& inbuf, ...@@ -168,7 +168,7 @@ static void PrintMessage(const base::IOBuf& inbuf,
bool has_content) { bool has_content) {
base::IOBuf buf1 = inbuf; base::IOBuf buf1 = inbuf;
base::IOBuf buf2; base::IOBuf buf2;
char str[32]; char str[48];
if (request_or_response) { if (request_or_response) {
snprintf(str, sizeof(str), "[HTTP REQUEST @%s]", base::my_ip_cstr()); snprintf(str, sizeof(str), "[HTTP REQUEST @%s]", base::my_ip_cstr());
} else { } else {
......
brpc/redis_reply.cpp
View file @ 50625b48
...@@ -255,6 +255,7 @@ void RedisReply::Print(std::ostream& os) const { ...@@ -255,6 +255,7 @@ void RedisReply::Print(std::ostream& os) const {
break; break;
case REDIS_REPLY_ERROR: case REDIS_REPLY_ERROR:
os << "(error) "; os << "(error) ";
// fall through
case REDIS_REPLY_STATUS: case REDIS_REPLY_STATUS:
if (_length < sizeof(_data.short_str)) { if (_length < sizeof(_data.short_str)) {
os << _data.short_str; os << _data.short_str;
......
brpc/serialized_request.cpp
View file @ 50625b48
...@@ -120,7 +120,9 @@ const ::google::protobuf::Descriptor* SerializedRequest::descriptor() { ...@@ -120,7 +120,9 @@ const ::google::protobuf::Descriptor* SerializedRequest::descriptor() {
} }
const SerializedRequest& SerializedRequest::default_instance() { 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; SerializedRequest* SerializedRequest::default_instance_ = NULL;
......
bvar/collector.cpp
View file @ 50625b48
...@@ -86,8 +86,7 @@ private: ...@@ -86,8 +86,7 @@ private:
bool _stop; // Set to true in dtor. bool _stop; // Set to true in dtor.
pthread_t _grab_thread; // For joining. pthread_t _grab_thread; // For joining.
pthread_t _dump_thread; pthread_t _dump_thread;
int64_t _ngrab BAIDU_CACHELINE_ALIGNMENT;
int64_t BAIDU_CACHELINE_ALIGNMENT _ngrab;
int64_t _ndrop; int64_t _ndrop;
int64_t _ndump; int64_t _ndump;
pthread_mutex_t _dump_thread_mutex; pthread_mutex_t _dump_thread_mutex;
......
bvar/default_variables.cpp
View file @ 50625b48
...@@ -11,6 +11,7 @@ ...@@ -11,6 +11,7 @@
#include "base/memory/singleton_on_pthread_once.h" #include "base/memory/singleton_on_pthread_once.h"
#include "base/scoped_lock.h" #include "base/scoped_lock.h"
#include "base/files/scoped_file.h" #include "base/files/scoped_file.h"
#include "base/files/file_enumerator.h"
#include "base/file_util.h" #include "base/file_util.h"
#include "bvar/passive_status.h" #include "bvar/passive_status.h"
...@@ -235,18 +236,15 @@ public: ...@@ -235,18 +236,15 @@ public:
// ================================================== // ==================================================
static int get_fd_count(int limit) { static int get_fd_count(int limit) {
DIR *dir = opendir("/proc/self/fd"); base::FileEnumerator fd_enum(base::FilePath("/proc/self/fd"),
if (dir == NULL) { false/*non recursive*/,
PLOG_ONCE(WARNING) << "Fail to opendir /proc/self/fd"; base::FileEnumerator::FILES);
return -1;
}
int count = 0; int count = 0;
dirent ent; // Have to limit the scaning which consumes a lot of CPU when #fd
// We have to limit the scaning which consumes a lot of CPU when #fd
// are huge (100k+) // are huge (100k+)
for (dirent* p = &ent; readdir_r(dir, &ent, &p) == 0 && p && for (base::FilePath name = fd_enum.Next();
count <= limit; ++count) {} !name.empty() && count <= limit;
closedir(dir); name = fd_enum.Next(), ++count) {}
return count - 2/*. and ..*/ - 1/*opendir itself*/; return count - 2/*. and ..*/ - 1/*opendir itself*/;
} }
......
bvar/detail/agent_group.h
View file @ 50625b48
...@@ -168,8 +168,7 @@ private: ...@@ -168,8 +168,7 @@ private:
static pthread_mutex_t _s_mutex; static pthread_mutex_t _s_mutex;
static AgentId _s_agent_kinds; static AgentId _s_agent_kinds;
static std::deque<AgentId> *_s_free_ids; static std::deque<AgentId> *_s_free_ids;
static __thread static __thread std::vector<ThreadBlock *> *_s_tls_blocks;
BAIDU_CACHELINE_ALIGNMENT std::vector<ThreadBlock *> *_s_tls_blocks;
}; };
template <typename Agent> template <typename Agent>
......
bvar/detail/combiner.h
View file @ 50625b48
...@@ -7,8 +7,6 @@ ...@@ -7,8 +7,6 @@
#define BAIDU_BVAR__COMBINER_H #define BAIDU_BVAR__COMBINER_H
#include <string> // std::string #include <string> // std::string
#include <algorithm> // std::swap until C++11
#include <utility> // std::swap since C++11
#include <vector> // std::vector #include <vector> // std::vector
#include "base/atomicops.h" // base::atomic #include "base/atomicops.h" // base::atomic
#include "base/scoped_lock.h" // BAIDU_SCOPED_LOCK #include "base/scoped_lock.h" // BAIDU_SCOPED_LOCK
......
config_brpc.sh
View file @ 50625b48
...@@ -17,8 +17,8 @@ CC=gcc ...@@ -17,8 +17,8 @@ CC=gcc
CXX=g++ CXX=g++
while true; do while true; do
case "$1" in case "$1" in
--headers ) HDRS="$(readlink -f $2)"; shift 2 ;; --headers ) HDRS_IN="$(readlink -f $2)"; shift 2 ;;
--libs ) LIBS="$(readlink -f $2)"; shift 2 ;; --libs ) LIBS_IN="$(readlink -f $2)"; shift 2 ;;
--cc ) CC=$2; shift 2 ;; --cc ) CC=$2; shift 2 ;;
--cxx ) CXX=$2; shift 2 ;; --cxx ) CXX=$2; shift 2 ;;
-- ) shift; break ;; -- ) shift; break ;;
...@@ -26,13 +26,13 @@ while true; do ...@@ -26,13 +26,13 @@ while true; do
esac esac
done 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" >&2 $ECHO "config_brpc: --headers=HDRPATHS --libs=LIBPATHS must be specified"
exit 1 exit 1
fi fi
find_dir_of_lib() { 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 if [ ! -z "$lib" ]; then
dirname $lib dirname $lib
fi fi
...@@ -40,7 +40,7 @@ find_dir_of_lib() { ...@@ -40,7 +40,7 @@ find_dir_of_lib() {
find_dir_of_lib_or_die() { find_dir_of_lib_or_die() {
local dir=$(find_dir_of_lib $1) local dir=$(find_dir_of_lib $1)
if [ -z "$dir" ]; then if [ -z "$dir" ]; then
>&2 $ECHO "fail to find $1 from -libs" >&2 $ECHO "Fail to find $1 from --libs"
exit 1 exit 1
else else
$ECHO $dir $ECHO $dir
...@@ -48,60 +48,77 @@ find_dir_of_lib_or_die() { ...@@ -48,60 +48,77 @@ find_dir_of_lib_or_die() {
} }
find_bin() { 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_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() { find_dir_of_header_or_die() {
local dir=$(find_dir_of_header $1) local dir=$(find_dir_of_header $1)
if [ -z "$dir" ]; then if [ -z "$dir" ]; then
>&2 $ECHO "fail to find $1 from -incs" >&2 $ECHO "Fail to find $1 from --headers"
exit 1 exit 1
else else
$ECHO $dir $ECHO $dir
fi 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= STATIC_LINKINGS=
DYNAMIC_LINKINGS="-lpthread -lrt -lssl -lcrypto -ldl -lz" DYNAMIC_LINKINGS="-lpthread -lrt -lssl -lcrypto -ldl -lz"
append_linking() { append_linking() {
if [ -f $1/lib${2}.a ]; then 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 else
DYNAMIC_LINKINGS="${DYNAMIC_LINKINGS} -l$2" DYNAMIC_LINKINGS="$DYNAMIC_LINKINGS -l$2"
export STATICALLY_LINKED_$2=0
fi fi
} }
GFLAGS_LIB=$(find_dir_of_lib_or_die gflags) GFLAGS_LIB=$(find_dir_of_lib_or_die gflags)
append_linking $GFLAGS_LIB gflags append_linking $GFLAGS_LIB gflags
PROTOBUF_LIB=$(find_dir_of_lib_or_die protobuf) PROTOBUF_LIB=$(find_dir_of_lib_or_die protobuf)
append_linking $PROTOBUF_LIB protobuf append_linking $PROTOBUF_LIB protobuf
PROTOC_LIB=$(find_dir_of_lib_or_die protoc)
LEVELDB_LIB=$(find_dir_of_lib_or_die leveldb) LEVELDB_LIB=$(find_dir_of_lib_or_die leveldb)
append_linking $LEVELDB_LIB leveldb if [ -f $LEVELDB_LIB/libleveldb.a ]; then
# required by leveldb STATIC_LINKINGS="$STATIC_LINKINGS -lleveldb"
SNAPPY_LIB=$(find_dir_of_lib snappy) # required by leveldb
if [ ! -z "$SNAPPY_LIB" ]; then SNAPPY_LIB=$(find_dir_of_lib snappy)
if [ ! -z "$SNAPPY_LIB" ]; then
append_linking $SNAPPY_LIB snappy 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 fi
else
DYNAMIC_LINKINGS="$DYNAMIC_LINKINGS -lleveldb"
fi fi
GFLAGS_HDR=$(find_dir_of_header gflags/gflags.h) PROTOC=$(find_bin_or_die protoc)
PROTOBUF_HDR=$(find_dir_of_header google/protobuf/message.h)
LEVELDB_HDR=$(find_dir_of_header leveldb/db.h) 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) HDRS=$($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) LIBS=$($ECHO "$GFLAGS_LIB\n$PROTOBUF_LIB\n$LEVELDB_LIB\n$SNAPPY_LIB" | sort | uniq)
absent_in_the_list() { absent_in_the_list() {
TMP=$($ECHO "`$ECHO "$1\n$2" | sort | uniq`") TMP=$($ECHO "`$ECHO "$1\n$2" | sort | uniq`")
...@@ -111,96 +128,115 @@ absent_in_the_list() { ...@@ -111,96 +128,115 @@ absent_in_the_list() {
return 0 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 #can't use \n in texts because sh does not support -e
CONTENT="HDRS=$($ECHO $HDRS2)" append_to_output "HDRS=$($ECHO $HDRS)"
CONTENT="${CONTENT}\nLIBS=$($ECHO $LIBS2)" append_to_output "LIBS=$($ECHO $LIBS)"
CONTENT="${CONTENT}\nPROTOC=$PROTOC" append_to_output "PROTOC=$PROTOC"
CONTENT="${CONTENT}\nPROTOBUF_HDR=$PROTOBUF_HDR" append_to_output "PROTOBUF_HDR=$PROTOBUF_HDR"
CONTENT="${CONTENT}\nCC=$CC" append_to_output "CC=$CC"
CONTENT="${CONTENT}\nCXX=$CXX" append_to_output "CXX=$CXX"
CONTENT="${CONTENT}\nSTATIC_LINKINGS=$STATIC_LINKINGS" append_to_output "STATIC_LINKINGS=$STATIC_LINKINGS"
CONTENT="${CONTENT}\nDYNAMIC_LINKINGS=$DYNAMIC_LINKINGS" append_to_output "DYNAMIC_LINKINGS=$DYNAMIC_LINKINGS"
CONTENT="${CONTENT}\nifeq (\$(NEED_GPERFTOOLS), 1)"
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 # required by cpu/heap profiler
TCMALLOC_LIB=$(find_dir_of_lib tcmalloc_and_profiler) TCMALLOC_LIB=$(find_dir_of_lib tcmalloc_and_profiler)
if [ -z "$TCMALLOC_LIB" ]; then if [ -z "$TCMALLOC_LIB" ]; then
CONTENT="${CONTENT}\n \$(error \"Fail to find gperftools\")" append_to_output " \$(error \"Fail to find gperftools\")"
else else
if absent_in_the_list "$TCMALLOC_LIB" "$LIBS2"; then append_to_output_libs "$TCMALLOC_LIB" " "
CONTENT="${CONTENT}\n LIBS+=$TCMALLOC_LIB" TCMALLOC_HDR=$(find_dir_of_header_or_die google/profiler.h)
LIBS2="${LIBS2}\n$TCMALLOC_LIB" 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 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 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
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 fi
# required by libunwind
CONTENT="${CONTENT}\n DYNAMIC_LINKINGS+=-llzma"
fi fi
CONTENT="${CONTENT}\nendif" append_to_output "endif"
# required by UT # required by UT
#gtest #gtest
GTEST_LIB=$(find_dir_of_lib 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 if [ -z "$GTEST_LIB" ]; then
CONTENT="${CONTENT}\n \$(error \"Fail to find gtest\")" append_to_output " \$(error \"Fail to find gtest\")"
else else
GTEST_HDR=$(find_dir_of_header gtest/gtest.h) GTEST_HDR=$(find_dir_of_header_or_die gtest/gtest.h)
if absent_in_the_list "$GTEST_LIB" "$LIBS2"; then append_to_output_libs $GTEST_LIB " "
CONTENT="${CONTENT}\n LIBS+=$GTEST_LIB" append_to_output_headers $GTEST_HDR " "
LIBS2="${LIBS2}\n$GTEST_LIB" append_to_output_linkings $GTEST_LIB gtest " "
fi append_to_output_linkings $GTEST_LIB gtest_main " "
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
fi fi
CONTENT="${CONTENT}\nendif" append_to_output "endif"
#gmock #gmock
GMOCK_LIB=$(find_dir_of_lib 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 if [ -z "$GMOCK_LIB" ]; then
CONTENT="${CONTENT}\n \$(error \"Fail to find gmock\")" append_to_output " \$(error \"Fail to find gmock\")"
else else
GMOCK_HDR=$(find_dir_of_header gmock/gmock.h) GMOCK_HDR=$(find_dir_of_header_or_die gmock/gmock.h)
if absent_in_the_list "$GMOCK_LIB" "$LIBS2"; then append_to_output_libs $GMOCK_LIB " "
CONTENT="${CONTENT}\n LIBS+=$GMOCK_LIB" append_to_output_headers $GMOCK_HDR " "
LIBS2="${LIBS2}\n$GMOCK_LIB" append_to_output_linkings $GMOCK_LIB gmock " "
fi append_to_output_linkings $GMOCK_LIB gmock_main " "
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
fi fi
CONTENT="${CONTENT}\nendif" append_to_output "endif"
$ECHO "$CONTENT" > config.mk
# write to config.mk
$ECHO "$OUTPUT_CONTENT" > config.mk
test/Makefile
View file @ 50625b48
...@@ -4,8 +4,11 @@ NEED_GMOCK=1 ...@@ -4,8 +4,11 @@ NEED_GMOCK=1
include ../config.mk 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=-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 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 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 -Werror -fPIC -fstrict-aliasing -Wno-unused-parameter -fno-omit-frame-pointer 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)) HDRPATHS=-I. -I.. $(addprefix -I, $(HDRS))
LIBPATHS=$(addprefix -L, $(LIBS)) LIBPATHS=$(addprefix -L, $(LIBS))
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment