TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-03 10:22:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

rename ssl -> openssl, cv -> opencv

Browse Source
This commit is contained in:
David Rose 2005-09-21 23:50:36 +00:00
parent a4680750b6
commit f91ee87026
15 changed files with 263 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
dtool/Config.pp
View File

@ -362,12 +362,12 @@
#define HAVE_STL_HASH #define HAVE_STL_HASH
// Is OpenSSL installed, and where? // Is OpenSSL installed, and where?
#define SSL_IPATH /usr/local/ssl/include #define OPENSSL_IPATH /usr/local/ssl/include
#define SSL_LPATH /usr/local/ssl/lib #define OPENSSL_LPATH /usr/local/ssl/lib
#define SSL_LIBS ssl crypto #define OPENSSL_LIBS ssl crypto
#defer HAVE_SSL $[libtest $[SSL_LPATH],$[SSL_LIBS]] #defer HAVE_OPENSSL $[libtest $[OPENSSL_LPATH],$[OPENSSL_LIBS]]
// Define this nonempty if your version of OpenSSL is 0.9.7 or better. // Define this nonempty if your version of OpenSSL is 0.9.7 or better.
#define SSL_097 #define OPENSSL_097
// Define this true to include the OpenSSL code to report verbose // Define this true to include the OpenSSL code to report verbose
// error messages when they occur. // error messages when they occur.
@ -511,10 +511,10 @@
#defer HAVE_DX $[libtest $[DX_LPATH],$[DX_LIBS]] #defer HAVE_DX $[libtest $[DX_LPATH],$[DX_LIBS]]
// Is OpenCV installed, and where? // Is OpenCV installed, and where?
#define CV_IPATH /usr/local/include/opencv #define OPENCV_IPATH /usr/local/include/opencv
#define CV_LPATH /usr/local/lib #define OPENCV_LPATH /usr/local/lib
#define CV_LIBS $[if $[WINDOWS_PLATFORM],cv.lib highgui.lib cxcore.lib,cv highgui cxcore] #define OPENCV_LIBS $[if $[WINDOWS_PLATFORM],cv.lib highgui.lib cxcore.lib,cv highgui cxcore]
#defer HAVE_CV $[libtest $[CV_LPATH],$[CV_LIBS]] #defer HAVE_OPENCV $[libtest $[OPENCV_LPATH],$[OPENCV_LIBS]]
// Do you want to build the DirectD tools for starting Panda clients // Do you want to build the DirectD tools for starting Panda clients
// remotely? This only affects the direct tree. Enabling this may // remotely? This only affects the direct tree. Enabling this may

10
dtool/LocalSetup.pp
View File

@ -16,7 +16,7 @@
#else #else
#print - Did not find NSPR #print - Did not find NSPR
#endif #endif
#if $[HAVE_SSL] #if $[HAVE_OPENSSL]
#print + OpenSSL #print + OpenSSL
#else #else
#print - Did not find OpenSSL #print - Did not find OpenSSL
@ -86,7 +86,7 @@
#else #else
#print - Did not find DirectX #print - Did not find DirectX
#endif #endif
#if $[HAVE_CV] #if $[HAVE_OPENCV]
#print + OpenCV #print + OpenCV
#else #else
#print - Did not find OpenCV #print - Did not find OpenCV
@ -144,8 +144,8 @@ $[cdefine HAVE_SOFTIMAGE]
$[cdefine HAVE_NSPR] $[cdefine HAVE_NSPR]
/* Define if we have OpenSSL installed. */ /* Define if we have OpenSSL installed. */
$[cdefine HAVE_SSL] $[cdefine HAVE_OPENSSL]
$[cdefine SSL_097] $[cdefine OPENSSL_097]
$[cdefine REPORT_OPENSSL_ERRORS] $[cdefine REPORT_OPENSSL_ERRORS]
/* Define if we have libjpeg installed. */ /* Define if we have libjpeg installed. */
@ -182,7 +182,7 @@ $[cdefine HAVE_ZLIB]
$[cdefine HAVE_GL] $[cdefine HAVE_GL]
/* Define if we have OpenCV installed and want to build for OpenCV. */ /* Define if we have OpenCV installed and want to build for OpenCV. */
$[cdefine HAVE_CV] $[cdefine HAVE_OPENCV]
/* Define if we have Mesa installed and want to build mesadisplay. */ /* Define if we have Mesa installed and want to build mesadisplay. */

16
dtool/Package.pp
View File

@ -113,10 +113,10 @@
#set NSPR_LIBS $[NSPR_LIBS] #set NSPR_LIBS $[NSPR_LIBS]
#set HAVE_NSPR $[HAVE_NSPR] #set HAVE_NSPR $[HAVE_NSPR]
#set SSL_IPATH $[unixfilename $[SSL_IPATH]] #set OPENSSL_IPATH $[unixfilename $[OPENSSL_IPATH]]
#set SSL_LPATH $[unixfilename $[SSL_LPATH]] #set OPENSSL_LPATH $[unixfilename $[OPENSSL_LPATH]]
#set SSL_LIBS $[SSL_LIBS] #set OPENSSL_LIBS $[OPENSSL_LIBS]
#set HAVE_SSL $[HAVE_SSL] #set HAVE_OPENSSL $[HAVE_OPENSSL]
#set JPEG_IPATH $[unixfilename $[JPEG_IPATH]] #set JPEG_IPATH $[unixfilename $[JPEG_IPATH]]
#set JPEG_LPATH $[unixfilename $[JPEG_LPATH]] #set JPEG_LPATH $[unixfilename $[JPEG_LPATH]]
@ -192,10 +192,10 @@
#set DX_LIBS $[DX_LIBS] #set DX_LIBS $[DX_LIBS]
#set HAVE_DX $[HAVE_DX] #set HAVE_DX $[HAVE_DX]
#set CV_IPATH $[unixfilename $[CV_IPATH]] #set OPENCV_IPATH $[unixfilename $[OPENCV_IPATH]]
#set CV_LPATH $[unixfilename $[CV_LPATH]] #set OPENCV_LPATH $[unixfilename $[OPENCV_LPATH]]
#set CV_LIBS $[CV_LIBS] #set OPENCV_LIBS $[OPENCV_LIBS]
#set HAVE_CV $[HAVE_CV] #set HAVE_OPENCV $[HAVE_OPENCV]
#set HAVE_THREADS $[HAVE_THREADS] #set HAVE_THREADS $[HAVE_THREADS]

20
dtool/pptempl/Global.pp
View File

@ -104,11 +104,11 @@
#define nspr_libs $[NSPR_LIBS] #define nspr_libs $[NSPR_LIBS]
#endif #endif
#if $[HAVE_SSL] #if $[HAVE_OPENSSL]
#define ssl_ipath $[wildcard $[SSL_IPATH]] #define openssl_ipath $[wildcard $[OPENSSL_IPATH]]
#define ssl_lpath $[wildcard $[SSL_LPATH]] #define openssl_lpath $[wildcard $[OPENSSL_LPATH]]
#define ssl_cflags $[SSL_CFLAGS] #define openssl_cflags $[OPENSSL_CFLAGS]
#define ssl_libs $[SSL_LIBS] #define openssl_libs $[OPENSSL_LIBS]
#endif #endif
#if $[HAVE_ZLIB] #if $[HAVE_ZLIB]
@ -160,11 +160,11 @@
#define dx_libs $[DX_LIBS] #define dx_libs $[DX_LIBS]
#endif #endif
#if $[HAVE_CV] #if $[HAVE_OPENCV]
#define cv_ipath $[wildcard $[CV_IPATH]] #define opencv_ipath $[wildcard $[OPENCV_IPATH]]
#define cv_lpath $[wildcard $[CV_LPATH]] #define opencv_lpath $[wildcard $[OPENCV_LPATH]]
#define cv_cflags $[CV_CFLAGS] #define opencv_cflags $[OPENCV_CFLAGS]
#define cv_libs $[CV_LIBS] #define opencv_libs $[OPENCV_LIBS]
#endif #endif
#if $[HAVE_JPEG] #if $[HAVE_JPEG]

235
dtool/src/dtoolbase/cmath.I
View File

@ -16,52 +16,74 @@
// //
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
//Windows has isnan in a different place and with a different name
//than everyone else. Sheesh
#ifdef _WIN32
#include <float.h>
#endif
#ifdef __APPLE__ #ifdef __APPLE__
#define isnan( x ) ( ( sizeof ( x ) == sizeof(double) ) ? \ #define isnan(x) \
((sizeof(x) == sizeof(double)) ? \
__isnand(x) : \ __isnand(x) : \
( sizeof ( x ) == sizeof( float) ) ? \ (sizeof(x) == sizeof(float)) ? __isnanf(x) : __isnan(x))
__isnanf ( x ) : \
__isnan ( x ) )
#endif #endif
INLINE float csqrt(float v) { #ifdef __INTEL_COMPILER
// see float.h
#define FPU_CONTROLWORD_WRITEMASK 0xFFFFF // if you look at defn of _CW_DEFAULT, all settings fall within 0xFFFFF
#define FPU_CONTROLWORD_NEW_SETTING _CW_DEFAULT
#endif
////////////////////////////////////////////////////////////////////
// Function: csqrt
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
csqrt(float v) {
return sqrtf(v); return sqrtf(v);
} }
INLINE float csin(float v) { ////////////////////////////////////////////////////////////////////
// Function: csin
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
csin(float v) {
return sinf(v); return sinf(v);
} }
INLINE float ccos(float v) { ////////////////////////////////////////////////////////////////////
// Function: ccos
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
ccos(float v) {
return cosf(v); return cosf(v);
} }
////////////////////////////////////////////////////////////////////
// Function: ctan
// Description:
////////////////////////////////////////////////////////////////////
INLINE float ctan(float v) { INLINE float ctan(float v) {
return tanf(v); return tanf(v);
} }
////////////////////////////////////////////////////////////////////
// Function: csincos
// Description:
////////////////////////////////////////////////////////////////////
INLINE void INLINE void
csincos(float v, float *pSinResult, float *pCosResult) { csincos(float v, float *sin_result, float *cos_result) {
// MS VC defines _M_IX86 for x86. gcc should define _X86_ // MS VC defines _M_IX86 for x86. gcc should define _X86_
#if defined(_M_IX86) || defined(_X86_) #if defined(_M_IX86) || defined(_X86_)
//#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb //#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb
__asm { __asm {
mov eax, pSinResult mov eax, sin_result
mov edx, pCosResult mov edx, cos_result
fld v fld v
fsincos fsincos
fstp DWORD ptr [edx] fstp DWORD ptr [edx]
fstp DWORD ptr [eax] fstp DWORD ptr [eax]
} }
#else //!_X86_ #else //!_X86_
*pSinResult = sinf(v); *sin_result = sinf(v);
*pCosResult = cosf(v); *cos_result = cosf(v);
#endif //!_X86_ #endif //!_X86_
} }
@ -78,33 +100,68 @@ csin_over_x(float v) {
} }
} }
INLINE float cabs(float v) { ////////////////////////////////////////////////////////////////////
// Function: cabs
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
cabs(float v) {
return fabs(v); return fabs(v);
} }
INLINE float catan(float v) { ////////////////////////////////////////////////////////////////////
// Function: catan
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
catan(float v) {
return atanf(v); return atanf(v);
} }
INLINE float catan2(float y, float x) { ////////////////////////////////////////////////////////////////////
// Function: catan2
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
catan2(float y, float x) {
return atan2f(y, x); return atan2f(y, x);
} }
INLINE float casin(float v) { ////////////////////////////////////////////////////////////////////
// Function: casin
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
casin(float v) {
return asinf(v); return asinf(v);
} }
INLINE float cacos(float v) { ////////////////////////////////////////////////////////////////////
// Function: cacos
// Description:
////////////////////////////////////////////////////////////////////
INLINE float
cacos(float v) {
return acosf(v); return acosf(v);
} }
#ifdef __INTEL_COMPILER ////////////////////////////////////////////////////////////////////
// see float.h // Function: cmod
#define FPU_CONTROLWORD_WRITEMASK 0xFFFFF // if you look at defn of _CW_DEFAULT, all settings fall within 0xFFFFF // Description: This is similar to fmod(), but it behaves properly
#define FPU_CONTROLWORD_NEW_SETTING _CW_DEFAULT // when x is negative: that is, it always returns a
#endif // value in the range [0, y), assuming y is positive.
////////////////////////////////////////////////////////////////////
INLINE float
cmod(float x, float y) {
return x - cfloor(x / y) * y;
}
INLINE double cfloor(double f) { ////////////////////////////////////////////////////////////////////
// Function: cfloor
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
cfloor(double f) {
#ifdef __INTEL_COMPILER #ifdef __INTEL_COMPILER
// intel floor doesnt work right if fpu mode is not double, so make double-prec mode is on // intel floor doesnt work right if fpu mode is not double, so make double-prec mode is on
unsigned int saved_fpu_control_word=_controlfp(0x0,0x0); unsigned int saved_fpu_control_word=_controlfp(0x0,0x0);
@ -117,7 +174,12 @@ INLINE double cfloor(double f) {
#endif #endif
} }
INLINE double cceil(double f) { ////////////////////////////////////////////////////////////////////
// Function: cceil
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
cceil(double f) {
#ifdef __INTEL_COMPILER #ifdef __INTEL_COMPILER
// intel ceil doesnt work right if fpu mode is not double, so make double-prec mode is on // intel ceil doesnt work right if fpu mode is not double, so make double-prec mode is on
unsigned int saved_fpu_control_word=_controlfp(0x0,0x0); unsigned int saved_fpu_control_word=_controlfp(0x0,0x0);
@ -130,37 +192,61 @@ INLINE double cceil(double f) {
#endif #endif
} }
INLINE double csqrt(double v) { ////////////////////////////////////////////////////////////////////
// Function: csqrt
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
csqrt(double v) {
return sqrt(v); return sqrt(v);
} }
INLINE double csin(double v) { ////////////////////////////////////////////////////////////////////
// Function: csin
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
csin(double v) {
return sin(v); return sin(v);
} }
INLINE double ccos(double v) { ////////////////////////////////////////////////////////////////////
// Function: ccos
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
ccos(double v) {
return cos(v); return cos(v);
} }
INLINE double ctan(double v) { ////////////////////////////////////////////////////////////////////
// Function: ctan
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
ctan(double v) {
return tan(v); return tan(v);
} }
////////////////////////////////////////////////////////////////////
// Function: csincos
// Description:
////////////////////////////////////////////////////////////////////
INLINE void INLINE void
csincos(double v, double *pSinResult, double *pCosResult) { csincos(double v, double *sin_result, double *cos_result) {
#if defined(_M_IX86) || defined(_X86_) #if defined(_M_IX86) || defined(_X86_)
//#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb //#define fsincos_opcode __asm _emit 0xd9 __asm _emit 0xfb
__asm { __asm {
mov eax, pSinResult mov eax, sin_result
mov edx, pCosResult mov edx, cos_result
fld v fld v
fsincos fsincos
fstp QWORD ptr [edx] fstp QWORD ptr [edx]
fstp QWORD ptr [eax] fstp QWORD ptr [eax]
} }
#else //!_X86_ #else //!_X86_
*pSinResult = sin(v); *sin_result = sin(v);
*pCosResult = cos(v); *cos_result = cos(v);
#endif //!_X86_ #endif //!_X86_
} }
@ -177,27 +263,68 @@ csin_over_x(double v) {
} }
} }
INLINE double cabs(double v) { ////////////////////////////////////////////////////////////////////
// Function: cabs
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
cabs(double v) {
return fabs(v); return fabs(v);
} }
INLINE double catan(double v) { ////////////////////////////////////////////////////////////////////
// Function: catan
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
catan(double v) {
return atan(v); return atan(v);
} }
INLINE double catan2(double y, double x) { ////////////////////////////////////////////////////////////////////
// Function: catan2
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
catan2(double y, double x) {
return atan2(y, x); return atan2(y, x);
} }
INLINE double casin(double v) { ////////////////////////////////////////////////////////////////////
// Function: casin
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
casin(double v) {
return asin(v); return asin(v);
} }
INLINE double cacos(double v) { ////////////////////////////////////////////////////////////////////
// Function: cacos
// Description:
////////////////////////////////////////////////////////////////////
INLINE double
cacos(double v) {
return acos(v); return acos(v);
} }
INLINE bool cnan(double v) { ////////////////////////////////////////////////////////////////////
// Function: cmod
// Description: This is similar to fmod(), but it behaves properly
// when x is negative: that is, it always returns a
// value in the range [0, y), assuming y is positive.
////////////////////////////////////////////////////////////////////
INLINE double
cmod(double x, double y) {
return x - cfloor(x / y) * y;
}
////////////////////////////////////////////////////////////////////
// Function: cnan
// Description:
////////////////////////////////////////////////////////////////////
INLINE bool
cnan(double v) {
#ifndef _WIN32 #ifndef _WIN32
return (isnan(v) != 0); return (isnan(v) != 0);
#else #else
@ -206,3 +333,21 @@ INLINE bool cnan(double v) {
} }
////////////////////////////////////////////////////////////////////
// Function: cmod
// Description: This is similar to fmod(), but it behaves properly
// when x is negative: that is, it always returns a
// value in the range [0, y), assuming y is positive.
//
// This integer-valued function is provided since the
// built-in modulo operator % does not work properly for
// negative x.
////////////////////////////////////////////////////////////////////
INLINE int
cmod(int x, int y) {
if (x < 0) {
return y - 1 - ((-x - 1) % y);
} else {
return x % y;
}
}

28
dtool/src/dtoolbase/cmath.h
View File

@ -19,28 +19,34 @@
#ifndef CMATH_H #ifndef CMATH_H
#define CMATH_H #define CMATH_H
#include "dtoolbase.h"
#include <math.h>
// This file declares a number of C++-style overloading wrappers // This file declares a number of C++-style overloading wrappers
// around the standard math library functions, so we can use // around the standard math library functions, so we can use
// overloading to differentiate on type instead of having to know // overloading to differentiate on type instead of having to know
// explicitly whether we need to call, for instance, sqrtf() or // explicitly whether we need to call, for instance, sqrtf() or
// sqrt(). // sqrt().
#include "dtoolbase.h"
#include <math.h>
// Windows defines isnan() in a different place and with a different
// name than everyone else. Sheesh.
#ifdef _WIN32
#include <float.h>
#endif
INLINE float csqrt(float v); INLINE float csqrt(float v);
INLINE float csin(float v); INLINE float csin(float v);
INLINE float ccos(float v); INLINE float ccos(float v);
INLINE float ctan(float v); INLINE float ctan(float v);
INLINE void csincos(float v, float *pSinResult, float *pCosResult); // does both at once (faster on x86) INLINE void csincos(float v, float *sin_result, float *cos_result);
INLINE float csin_over_x(float v); INLINE float csin_over_x(float v);
INLINE float cabs(float v); INLINE float cabs(float v);
INLINE float catan(float v); INLINE float catan(float v);
INLINE float catan2(float y, float x); INLINE float catan2(float y, float x);
INLINE float casin(float v); INLINE float casin(float v);
//INLINE float cfloor(float f); INLINE float cacos(float v);
//INLINE float cceil(float f); INLINE float cmod(float x, float y);
INLINE double cfloor(double f); INLINE double cfloor(double f);
INLINE double cceil(double f); INLINE double cceil(double f);
@ -48,16 +54,20 @@ INLINE double csqrt(double v);
INLINE double csin(double v); INLINE double csin(double v);
INLINE double ccos(double v); INLINE double ccos(double v);
INLINE double ctan(double v); INLINE double ctan(double v);
INLINE void csincos(double v, double *pSinResult, double *pCosResult); // does both at once (faster on x86) INLINE void csincos(double v, double *sin_result, double *cos_result);
INLINE double cabs(double v); INLINE double cabs(double v);
INLINE double catan(double v); INLINE double catan(double v);
INLINE double catan2(double y, double x); INLINE double catan2(double y, double x);
INLINE double casin(double y, double x); INLINE double casin(double v);
INLINE double cacos(double v);
INLINE double cmod(double x, double y);
// Returns true if the number is nan, false if it's a genuine number // Returns true if the number is nan, false if it's a genuine number
// or infinity. // or infinity.
INLINE bool cnan(double v); INLINE bool cnan(double v);
INLINE int cmod(int x, int y);
#include "cmath.I" #include "cmath.I"
#endif #endif

2
dtool/src/interrogate/Sources.pp
View File

@ -1,7 +1,7 @@
#define BUILD_DIRECTORY $[HAVE_INTERROGATE] #define BUILD_DIRECTORY $[HAVE_INTERROGATE]
#define LOCAL_LIBS cppParser pystub interrogatedb dconfig dtoolutil dtoolbase #define LOCAL_LIBS cppParser pystub interrogatedb dconfig dtoolutil dtoolbase
#define USE_PACKAGES ssl #define USE_PACKAGES openssl
#begin bin_target #begin bin_target
#define TARGET interrogate #define TARGET interrogate

2
dtool/src/prc/Sources.pp
View File

@ -1,5 +1,5 @@
#define LOCAL_LIBS dtoolutil dtoolbase #define LOCAL_LIBS dtoolutil dtoolbase
#define USE_PACKAGES ssl #define USE_PACKAGES openssl
#begin lib_target #begin lib_target
#define TARGET prc #define TARGET prc

14
dtool/src/prc/configPage.cxx
View File

@ -25,7 +25,7 @@
#include <ctype.h> #include <ctype.h>
#ifdef HAVE_SSL #ifdef HAVE_OPENSSL
#include <openssl/evp.h> #include <openssl/evp.h>
#endif #endif
@ -133,7 +133,7 @@ read_prc(istream &in) {
static const size_t buffer_size = 1024; static const size_t buffer_size = 1024;
char buffer[buffer_size]; char buffer[buffer_size];
#ifdef HAVE_SSL #ifdef HAVE_OPENSSL
// Set up the evp context for verifying the signature, if we find // Set up the evp context for verifying the signature, if we find
// one. // one.
#ifdef SSL_097 #ifdef SSL_097
@ -142,7 +142,7 @@ read_prc(istream &in) {
_md_ctx = new EVP_MD_CTX; _md_ctx = new EVP_MD_CTX;
#endif #endif
EVP_VerifyInit((EVP_MD_CTX *)_md_ctx, EVP_sha1()); EVP_VerifyInit((EVP_MD_CTX *)_md_ctx, EVP_sha1());
#endif // HAVE_SSL #endif // HAVE_OPENSSL
string prev_line; string prev_line;
@ -194,7 +194,7 @@ read_prc(istream &in) {
read_prc_line(prev_line); read_prc_line(prev_line);
} }
#ifdef HAVE_SSL #ifdef HAVE_OPENSSL
// Now validate the signature and free the SSL structures. // Now validate the signature and free the SSL structures.
if (!_signature.empty()) { if (!_signature.empty()) {
PrcKeyRegistry *pkr = PrcKeyRegistry::get_global_ptr(); PrcKeyRegistry *pkr = PrcKeyRegistry::get_global_ptr();
@ -221,7 +221,7 @@ read_prc(istream &in) {
#else #else
delete (EVP_MD_CTX *)_md_ctx; delete (EVP_MD_CTX *)_md_ctx;
#endif #endif
#endif // HAVE_SSL #endif // HAVE_OPENSSL
bool failed = (in.fail() && !in.eof()); bool failed = (in.fail() && !in.eof());
@ -381,11 +381,11 @@ read_prc_line(const string &line) {
return; return;
} }
#ifdef HAVE_SSL #ifdef HAVE_OPENSSL
// Accumulate any line that's not itself a signature into the hash, // Accumulate any line that's not itself a signature into the hash,
// so we can validate the signature at the end. // so we can validate the signature at the end.
EVP_VerifyUpdate((EVP_MD_CTX *)_md_ctx, line.data(), line.size()); EVP_VerifyUpdate((EVP_MD_CTX *)_md_ctx, line.data(), line.size());
#endif // HAVE_SSL #endif // HAVE_OPENSSL
// Separate the line into a variable and a value. // Separate the line into a variable and a value.
size_t p = 0; size_t p = 0;

4
dtool/src/prc/configPage.h
View File

@ -86,11 +86,11 @@ private:
string _signature; string _signature;
#ifdef HAVE_SSL #ifdef HAVE_OPENSSL
// This maintains the hash of the prc file as we are scanning it, so // This maintains the hash of the prc file as we are scanning it, so
// we can compare its signature which we discover at the end. // we can compare its signature which we discover at the end.
void *_md_ctx; void *_md_ctx;
#endif // HAVE_SSL #endif // HAVE_OPENSSL
static ConfigPage *_default_page; static ConfigPage *_default_page;
static ConfigPage *_local_page; static ConfigPage *_local_page;

1
dtool/src/prc/configVariableManager.cxx
View File

@ -86,6 +86,7 @@ make_variable(const string &name) {
_variables_by_name[name] = variable; _variables_by_name[name] = variable;
_variables.push_back(variable); _variables.push_back(variable);
return variable; return variable;
} }

4
dtool/src/prc/prcKeyRegistry.cxx
View File

@ -23,7 +23,7 @@
// the OpenSSL library to manage keys and to sign and validate // the OpenSSL library to manage keys and to sign and validate
// signatures. // signatures.
#ifdef HAVE_SSL #ifdef HAVE_OPENSSL
#include <openssl/pem.h> #include <openssl/pem.h>
@ -183,4 +183,4 @@ get_global_ptr() {
return _global_ptr; return _global_ptr;
} }
#endif // HAVE_SSL #endif // HAVE_OPENSSL

4
dtool/src/prc/prcKeyRegistry.h
View File

@ -25,7 +25,7 @@
// the OpenSSL library to manage keys and to sign and validate // the OpenSSL library to manage keys and to sign and validate
// signatures. // signatures.
#ifdef HAVE_SSL #ifdef HAVE_OPENSSL
#include "pvector.h" #include "pvector.h"
#include <openssl/evp.h> #include <openssl/evp.h>
@ -82,7 +82,7 @@ private:
#include "prcKeyRegistry.I" #include "prcKeyRegistry.I"
#endif // HAVE_SSL #endif // HAVE_OPENSSL
#endif #endif

8
dtool/src/prckeys/Sources.pp
View File

@ -1,8 +1,8 @@
#define LOCAL_LIBS pystub dtoolutil dtoolbase prc dconfig interrogatedb #define LOCAL_LIBS pystub dtoolutil dtoolbase prc dconfig interrogatedb
#begin bin_target #begin bin_target
#define BUILD_TARGET $[HAVE_SSL] #define BUILD_TARGET $[HAVE_OPENSSL]
#define USE_PACKAGES ssl #define USE_PACKAGES openssl
#define TARGET make-prc-key #define TARGET make-prc-key
@ -15,8 +15,8 @@
#end bin_target #end bin_target
// #begin bin_target // #begin bin_target
// #define BUILD_TARGET $[HAVE_SSL] // #define BUILD_TARGET $[HAVE_OPENSSL]
// #define USE_PACKAGES ssl // #define USE_PACKAGES openssl
// //
// #define TARGET panda-sign1 // #define TARGET panda-sign1
// //

2
dtool/src/test_interrogate/Sources.pp
View File

@ -1,5 +1,5 @@
#define LOCAL_LIBS pystub interrogatedb dconfig dtoolutil dtoolbase #define LOCAL_LIBS pystub interrogatedb dconfig dtoolutil dtoolbase
#define USE_PACKAGES ssl #define USE_PACKAGES openssl
#begin bin_target #begin bin_target
#define TARGET test_interrogate #define TARGET test_interrogate