mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-11-14 03:30:17 +01:00
a572ea8ca3
bug1095307, bug1073330(backout), bug1084986, bug1050069, bug942172, bug1054547, bug532081, bug1096348, bug1058870, bug1093940, bug1102985, bug1112461, bug1094492, bug112029, bug1119983, bug1120685, bug1120691, bug1113632, bug863076, bug1082973, bug1124539, bug1117617, bug1117621, bug1121273, bug753136, bug921684, bug1132818, bug1125375, bug647690, bug1055441, bug1134455, bug975010, bug950369, bug1128367, bug1129573, bug1136095, bug1117897, bug1113453, bug1061725, bug1073330, bug1111901, bug1083900, bug1136095, bug1138820, bug1096741, bug1134548, bug345725, bug950348, bug950344, bug1151037, bug991783, bug1153994
922 lines
23 KiB
Bash
922 lines
23 KiB
Bash
#!/bin/bash
|
|
#
|
|
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
########################################################################
|
|
#
|
|
# mozilla/security/nss/tests/memleak/memleak.sh
|
|
#
|
|
# Script to test memory leaks in NSS
|
|
#
|
|
# needs to work on Solaris and Linux platforms, on others just print a message
|
|
# that OS is not supported
|
|
#
|
|
# special strings
|
|
# ---------------
|
|
# FIXME ... known problems, search for this string
|
|
# NOTE .... unexpected behavior
|
|
#
|
|
########################################################################
|
|
|
|
############################# memleak_init #############################
|
|
# local shell function to initialize this script
|
|
########################################################################
|
|
memleak_init()
|
|
{
|
|
if [ -z "${INIT_SOURCED}" -o "${INIT_SOURCED}" != "TRUE" ]; then
|
|
cd ../common
|
|
. ./init.sh
|
|
fi
|
|
|
|
if [ ! -r ${CERT_LOG_FILE} ]; then
|
|
cd ${QADIR}/cert
|
|
. ./cert.sh
|
|
fi
|
|
|
|
SCRIPTNAME="memleak.sh"
|
|
if [ -z "${CLEANUP}" ] ; then
|
|
CLEANUP="${SCRIPTNAME}"
|
|
fi
|
|
|
|
OLD_LIBRARY_PATH=${LD_LIBRARY_PATH}
|
|
TMP_LIBDIR="${HOSTDIR}/tmp"
|
|
TMP_STACKS="${HOSTDIR}/stacks"
|
|
TMP_SORTED="${HOSTDIR}/sorted"
|
|
TMP_COUNT="${HOSTDIR}/count"
|
|
DBXOUT="${HOSTDIR}/dbxout"
|
|
DBXERR="${HOSTDIR}/dbxerr"
|
|
DBXCMD="${HOSTDIR}/dbxcmd"
|
|
|
|
PORT=${PORT:-8443}
|
|
|
|
MODE_LIST="NORMAL BYPASS FIPS"
|
|
|
|
SERVER_DB="${HOSTDIR}/server_memleak"
|
|
CLIENT_DB="${HOSTDIR}/client_memleak"
|
|
cp -r ${HOSTDIR}/server ${SERVER_DB}
|
|
cp -r ${HOSTDIR}/client ${CLIENT_DB}
|
|
|
|
LOGDIR="${HOSTDIR}/memleak_logs"
|
|
mkdir -p ${LOGDIR}
|
|
|
|
FOUNDLEAKS="${LOGDIR}/foundleaks"
|
|
|
|
REQUEST_FILE="${QADIR}/memleak/sslreq.dat"
|
|
IGNORED_STACKS="${QADIR}/memleak/ignored"
|
|
|
|
gline=`echo ${OBJDIR} | grep "_64_"`
|
|
if [ -n "${gline}" ] ; then
|
|
BIT_NAME="64"
|
|
else
|
|
BIT_NAME="32"
|
|
fi
|
|
|
|
case "${OS_NAME}" in
|
|
"SunOS")
|
|
DBX=`which dbx`
|
|
AWK=nawk
|
|
|
|
if [ $? -eq 0 ] ; then
|
|
echo "${SCRIPTNAME}: DBX found: ${DBX}"
|
|
else
|
|
echo "${SCRIPTNAME}: DBX not found, skipping memory leak checking."
|
|
exit 0
|
|
fi
|
|
|
|
PROC_ARCH=`uname -p`
|
|
|
|
if [ "${PROC_ARCH}" = "sparc" ] ; then
|
|
if [ "${BIT_NAME}" = "64" ] ; then
|
|
FREEBL_DEFAULT="libfreebl_64fpu_3"
|
|
FREEBL_LIST="${FREEBL_DEFAULT} libfreebl_64int_3"
|
|
else
|
|
FREEBL_DEFAULT="libfreebl_32fpu_3"
|
|
FREEBL_LIST="${FREEBL_DEFAULT} libfreebl_32int64_3"
|
|
fi
|
|
else
|
|
if [ "${BIT_NAME}" = "64" ] ; then
|
|
echo "${SCRIPTNAME}: OS not supported for memory leak checking."
|
|
exit 0
|
|
fi
|
|
|
|
FREEBL_DEFAULT="libfreebl_3"
|
|
FREEBL_LIST="${FREEBL_DEFAULT}"
|
|
fi
|
|
|
|
RUN_COMMAND_DBG="run_command_dbx"
|
|
PARSE_LOGFILE="parse_logfile_dbx"
|
|
;;
|
|
"Linux")
|
|
VALGRIND=`which valgrind`
|
|
AWK=awk
|
|
|
|
if [ $? -eq 0 ] ; then
|
|
echo "${SCRIPTNAME}: Valgrind found: ${VALGRIND}"
|
|
else
|
|
echo "${SCRIPTNAME}: Valgrind not found, skipping memory leak checking."
|
|
exit 0
|
|
fi
|
|
|
|
FREEBL_DEFAULT="libfreebl_3"
|
|
FREEBL_LIST="${FREEBL_DEFAULT}"
|
|
|
|
RUN_COMMAND_DBG="run_command_valgrind"
|
|
PARSE_LOGFILE="parse_logfile_valgrind"
|
|
;;
|
|
*)
|
|
echo "${SCRIPTNAME}: OS not supported for memory leak checking."
|
|
exit 0
|
|
;;
|
|
esac
|
|
|
|
if [ "${BUILD_OPT}" = "1" ] ; then
|
|
OPT="OPT"
|
|
else
|
|
OPT="DBG"
|
|
fi
|
|
|
|
NSS_DISABLE_UNLOAD="1"
|
|
export NSS_DISABLE_UNLOAD
|
|
|
|
SELFSERV_ATTR="-D -p ${PORT} -d ${SERVER_DB} -n ${HOSTADDR} -e ${HOSTADDR}-ec -w nss -c ABCDEF:C001:C002:C003:C004:C005:C006:C007:C008:C009:C00A:C00B:C00C:C00D:C00E:C00F:C010:C011:C012:C013:C014cdefgijklmnvyz -t 5"
|
|
TSTCLNT_ATTR="-p ${PORT} -h ${HOSTADDR} -c j -f -d ${CLIENT_DB} -w nss -o"
|
|
STRSCLNT_ATTR="-q -p ${PORT} -d ${CLIENT_DB} -w nss -c 1000 -n TestUser ${HOSTADDR}"
|
|
|
|
tbytes=0
|
|
tblocks=0
|
|
truns=0
|
|
|
|
MEMLEAK_DBG=1
|
|
export MEMLEAK_DBG
|
|
}
|
|
|
|
########################### memleak_cleanup ############################
|
|
# local shell function to clean up after this script
|
|
########################################################################
|
|
memleak_cleanup()
|
|
{
|
|
unset MEMLEAK_DBG
|
|
unset NSS_DISABLE_UNLOAD
|
|
|
|
. ${QADIR}/common/cleanup.sh
|
|
}
|
|
|
|
############################ set_test_mode #############################
|
|
# local shell function to set testing mode for server and for client
|
|
########################################################################
|
|
set_test_mode()
|
|
{
|
|
if [ "${server_mode}" = "BYPASS" ] ; then
|
|
echo "${SCRIPTNAME}: BYPASS is ON"
|
|
SERVER_OPTION="-B -s"
|
|
CLIENT_OPTION=""
|
|
elif [ "${client_mode}" = "BYPASS" ] ; then
|
|
echo "${SCRIPTNAME}: BYPASS is ON"
|
|
SERVER_OPTION=""
|
|
CLIENT_OPTION="-B -s"
|
|
else
|
|
echo "${SCRIPTNAME}: BYPASS is OFF"
|
|
SERVER_OPTION=""
|
|
CLIENT_OPTION=""
|
|
fi
|
|
|
|
if [ "${server_mode}" = "FIPS" ] ; then
|
|
${BINDIR}/modutil -dbdir ${SERVER_DB} -fips true -force
|
|
${BINDIR}/modutil -dbdir ${SERVER_DB} -list
|
|
${BINDIR}/modutil -dbdir ${CLIENT_DB} -fips false -force
|
|
${BINDIR}/modutil -dbdir ${CLIENT_DB} -list
|
|
|
|
echo "${SCRIPTNAME}: FIPS is ON"
|
|
cipher_list="c d e i j k n v y z"
|
|
elif [ "${client_mode}" = "FIPS" ] ; then
|
|
|
|
${BINDIR}/modutil -dbdir ${SERVER_DB} -fips false -force
|
|
${BINDIR}/modutil -dbdir ${SERVER_DB} -list
|
|
${BINDIR}/modutil -dbdir ${CLIENT_DB} -fips true -force
|
|
${BINDIR}/modutil -dbdir ${CLIENT_DB} -list
|
|
|
|
echo "${SCRIPTNAME}: FIPS is ON"
|
|
cipher_list="c d e i j k n v y z"
|
|
else
|
|
${BINDIR}/modutil -dbdir ${SERVER_DB} -fips false -force
|
|
${BINDIR}/modutil -dbdir ${SERVER_DB} -list
|
|
${BINDIR}/modutil -dbdir ${CLIENT_DB} -fips false -force
|
|
${BINDIR}/modutil -dbdir ${CLIENT_DB} -list
|
|
|
|
echo "${SCRIPTNAME}: FIPS is OFF"
|
|
# ciphers l and m removed, see bug 1136095
|
|
cipher_list="A B C D E F :C001 :C002 :C003 :C004 :C005 :C006 :C007 :C008 :C009 :C00A :C010 :C011 :C012 :C013 :C014 c d e f g i j k n v y z"
|
|
fi
|
|
}
|
|
|
|
############################## set_freebl ##############################
|
|
# local shell function to set freebl - sets temporary path for libraries
|
|
########################################################################
|
|
set_freebl()
|
|
{
|
|
if [ "${freebl}" = "${FREEBL_DEFAULT}" ] ; then
|
|
LD_LIBRARY_PATH="${OLD_LIBRARY_PATH}"
|
|
export LD_LIBRARY_PATH
|
|
else
|
|
if [ -d "${TMP_LIBDIR}" ] ; then
|
|
rm -rf ${TMP_LIBDIR}
|
|
fi
|
|
|
|
mkdir ${TMP_LIBDIR}
|
|
[ $? -ne 0 ] && html_failed "Create temp directory" && return 1
|
|
|
|
cp ${DIST}/${OBJDIR}/lib/*.so ${DIST}/${OBJDIR}/lib/*.chk ${TMP_LIBDIR}
|
|
[ $? -ne 0 ] && html_failed "Copy libraries to temp directory" && return 1
|
|
|
|
echo "${SCRIPTNAME}: Using ${freebl} instead of ${FREEBL_DEFAULT}"
|
|
|
|
mv ${TMP_LIBDIR}/${FREEBL_DEFAULT}.so ${TMP_LIBDIR}/${FREEBL_DEFAULT}.so.orig
|
|
[ $? -ne 0 ] && html_failed "Move ${FREEBL_DEFAULT}.so -> ${FREEBL_DEFAULT}.so.orig" && return 1
|
|
|
|
cp ${TMP_LIBDIR}/${freebl}.so ${TMP_LIBDIR}/${FREEBL_DEFAULT}.so
|
|
[ $? -ne 0 ] && html_failed "Copy ${freebl}.so -> ${FREEBL_DEFAULT}.so" && return 1
|
|
|
|
mv ${TMP_LIBDIR}/${FREEBL_DEFAULT}.chk ${TMP_LIBDIR}/${FREEBL_DEFAULT}.chk.orig
|
|
[ $? -ne 0 ] && html_failed "Move ${FREEBL_DEFAULT}.chk -> ${FREEBL_DEFAULT}.chk.orig" && return 1
|
|
|
|
cp ${TMP_LIBDIR}/${freebl}.chk ${TMP_LIBDIR}/${FREEBL_DEFAULT}.chk
|
|
[ $? -ne 0 ] && html_failed "Copy ${freebl}.chk to temp directory" && return 1
|
|
|
|
echo "ls -l ${TMP_LIBDIR}"
|
|
ls -l ${TMP_LIBDIR}
|
|
|
|
LD_LIBRARY_PATH="${TMP_LIBDIR}"
|
|
export LD_LIBRARY_PATH
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
############################# clear_freebl #############################
|
|
# local shell function to set default library path and clear temporary
|
|
# directory for libraries created by function set_freebl
|
|
########################################################################
|
|
clear_freebl()
|
|
{
|
|
LD_LIBRARY_PATH="${OLD_LIBRARY_PATH}"
|
|
export LD_LIBRARY_PATH
|
|
|
|
if [ -d "${TMP_LIBDIR}" ] ; then
|
|
rm -rf ${TMP_LIBDIR}
|
|
fi
|
|
}
|
|
|
|
############################ run_command_dbx ###########################
|
|
# local shell function to run command under dbx tool
|
|
########################################################################
|
|
run_command_dbx()
|
|
{
|
|
COMMAND=$1
|
|
shift
|
|
ATTR=$*
|
|
|
|
COMMAND=`which ${COMMAND}`
|
|
|
|
echo "dbxenv follow_fork_mode parent" > ${DBXCMD}
|
|
echo "dbxenv rtc_mel_at_exit verbose" >> ${DBXCMD}
|
|
echo "dbxenv rtc_biu_at_exit verbose" >> ${DBXCMD}
|
|
echo "check -memuse -match 16 -frames 16" >> ${DBXCMD}
|
|
echo "run ${ATTR}" >> ${DBXCMD}
|
|
|
|
export NSS_DISABLE_ARENA_FREE_LIST=1
|
|
|
|
echo "${SCRIPTNAME}: -------- Running ${COMMAND} under DBX:"
|
|
echo "${DBX} ${COMMAND}"
|
|
echo "${SCRIPTNAME}: -------- DBX commands:"
|
|
cat ${DBXCMD}
|
|
|
|
( ${DBX} ${COMMAND} < ${DBXCMD} > ${DBXOUT} 2> ${DBXERR} )
|
|
grep -v Reading ${DBXOUT} 1>&2
|
|
cat ${DBXERR}
|
|
|
|
unset NSS_DISABLE_ARENA_FREE_LIST
|
|
|
|
grep "exit code is" ${DBXOUT}
|
|
grep "exit code is 0" ${DBXOUT} > /dev/null
|
|
return $?
|
|
}
|
|
|
|
######################### run_command_valgrind #########################
|
|
# local shell function to run command under valgrind tool
|
|
########################################################################
|
|
run_command_valgrind()
|
|
{
|
|
COMMAND=$1
|
|
shift
|
|
ATTR=$*
|
|
|
|
export NSS_DISABLE_ARENA_FREE_LIST=1
|
|
|
|
echo "${SCRIPTNAME}: -------- Running ${COMMAND} under Valgrind:"
|
|
echo "${VALGRIND} --tool=memcheck --leak-check=yes --show-reachable=yes --partial-loads-ok=yes --leak-resolution=high --num-callers=50 ${COMMAND} ${ATTR}"
|
|
echo "Running: ${COMMAND} ${ATTR}" 1>&2
|
|
${VALGRIND} --tool=memcheck --leak-check=yes --show-reachable=yes --partial-loads-ok=yes --leak-resolution=high --num-callers=50 ${COMMAND} ${ATTR} 1>&2
|
|
ret=$?
|
|
echo "==0=="
|
|
|
|
unset NSS_DISABLE_ARENA_FREE_LIST
|
|
|
|
return $ret
|
|
}
|
|
|
|
############################# run_selfserv #############################
|
|
# local shell function to start selfserv
|
|
########################################################################
|
|
run_selfserv()
|
|
{
|
|
echo "PATH=${PATH}"
|
|
echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
|
|
echo "${SCRIPTNAME}: -------- Running selfserv:"
|
|
echo "selfserv ${SELFSERV_ATTR}"
|
|
${BINDIR}/selfserv ${SELFSERV_ATTR}
|
|
ret=$?
|
|
if [ $ret -ne 0 ]; then
|
|
html_failed "${LOGNAME}: Selfserv"
|
|
echo "${SCRIPTNAME} ${LOGNAME}: " \
|
|
"Selfserv produced a returncode of ${ret} - FAILED"
|
|
fi
|
|
}
|
|
|
|
########################### run_selfserv_dbg ###########################
|
|
# local shell function to start selfserv under debug tool
|
|
########################################################################
|
|
run_selfserv_dbg()
|
|
{
|
|
echo "PATH=${PATH}"
|
|
echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
|
|
${RUN_COMMAND_DBG} ${BINDIR}/selfserv ${SERVER_OPTION} ${SELFSERV_ATTR}
|
|
ret=$?
|
|
if [ $ret -ne 0 ]; then
|
|
html_failed "${LOGNAME}: Selfserv"
|
|
echo "${SCRIPTNAME} ${LOGNAME}: " \
|
|
"Selfserv produced a returncode of ${ret} - FAILED"
|
|
fi
|
|
}
|
|
|
|
############################# run_strsclnt #############################
|
|
# local shell function to run strsclnt for all ciphers and send stop
|
|
# command to selfserv over tstclnt
|
|
########################################################################
|
|
run_strsclnt()
|
|
{
|
|
for cipher in ${cipher_list}; do
|
|
VMIN="ssl3"
|
|
VMAX=
|
|
case "${cipher}" in
|
|
A|B|C|D|E|F)
|
|
# Enable SSL 2 only for SSL 2 cipher suites.
|
|
VMIN="ssl2"
|
|
;;
|
|
f|g)
|
|
# TLS 1.1 disallows export cipher suites.
|
|
VMAX="tls1.0"
|
|
;;
|
|
esac
|
|
ATTR="${STRSCLNT_ATTR} -C ${cipher} -V ${VMIN}:${VMAX}"
|
|
echo "${SCRIPTNAME}: -------- Trying cipher ${cipher}:"
|
|
echo "strsclnt ${ATTR}"
|
|
${BINDIR}/strsclnt ${ATTR}
|
|
ret=$?
|
|
if [ $ret -ne 0 ]; then
|
|
html_failed "${LOGNAME}: Strsclnt with cipher ${cipher}"
|
|
echo "${SCRIPTNAME} ${LOGNAME}: " \
|
|
"Strsclnt produced a returncode of ${ret} - FAILED"
|
|
fi
|
|
done
|
|
|
|
echo "${SCRIPTNAME}: -------- Stopping server:"
|
|
echo "tstclnt ${TSTCLNT_ATTR} < ${REQUEST_FILE}"
|
|
${BINDIR}/tstclnt ${TSTCLNT_ATTR} < ${REQUEST_FILE}
|
|
ret=$?
|
|
if [ $ret -ne 0 ]; then
|
|
html_failed "${LOGNAME}: Tstclnt"
|
|
echo "${SCRIPTNAME} ${LOGNAME}: " \
|
|
"Tstclnt produced a returncode of ${ret} - FAILED"
|
|
fi
|
|
|
|
sleep 20
|
|
kill $(jobs -p) 2> /dev/null
|
|
}
|
|
|
|
########################### run_strsclnt_dbg ###########################
|
|
# local shell function to run strsclnt under debug tool for all ciphers
|
|
# and send stop command to selfserv over tstclnt
|
|
########################################################################
|
|
run_strsclnt_dbg()
|
|
{
|
|
for cipher in ${cipher_list}; do
|
|
VMIN="ssl3"
|
|
VMAX=
|
|
case "${cipher}" in
|
|
A|B|C|D|E|F)
|
|
# Enable SSL 2 only for SSL 2 cipher suites.
|
|
VMIN="ssl2"
|
|
;;
|
|
f|g)
|
|
# TLS 1.1 disallows export cipher suites.
|
|
VMAX="tls1.0"
|
|
;;
|
|
esac
|
|
ATTR="${STRSCLNT_ATTR} -C ${cipher} -V ${VMIN}:${VMAX}"
|
|
${RUN_COMMAND_DBG} ${BINDIR}/strsclnt ${CLIENT_OPTION} ${ATTR}
|
|
ret=$?
|
|
if [ $ret -ne 0 ]; then
|
|
html_failed "${LOGNAME}: Strsclnt with cipher ${cipher}"
|
|
echo "${SCRIPTNAME} ${LOGNAME}: " \
|
|
"Strsclnt produced a returncode of ${ret} - FAILED"
|
|
fi
|
|
done
|
|
|
|
echo "${SCRIPTNAME}: -------- Stopping server:"
|
|
echo "tstclnt ${TSTCLNT_ATTR} < ${REQUEST_FILE}"
|
|
${BINDIR}/tstclnt ${TSTCLNT_ATTR} < ${REQUEST_FILE}
|
|
ret=$?
|
|
if [ $ret -ne 0 ]; then
|
|
html_failed "${LOGNAME}: Tstclnt"
|
|
echo "${SCRIPTNAME} ${LOGNAME}: " \
|
|
"Tstclnt produced a returncode of ${ret} - FAILED"
|
|
fi
|
|
|
|
kill $(jobs -p) 2> /dev/null
|
|
}
|
|
|
|
stat_clear()
|
|
{
|
|
stat_minbytes=9999999
|
|
stat_maxbytes=0
|
|
stat_minblocks=9999999
|
|
stat_maxblocks=0
|
|
stat_bytes=0
|
|
stat_blocks=0
|
|
stat_runs=0
|
|
}
|
|
|
|
stat_add()
|
|
{
|
|
read hash lbytes bytes_str lblocks blocks_str in_str lruns runs_str \
|
|
minbytes minbytes_str maxbytes maxbytes_str minblocks \
|
|
minblocks_str maxblocks maxblocks_str rest < ${TMP_COUNT}
|
|
rm ${TMP_COUNT}
|
|
|
|
tbytes=`expr ${tbytes} + ${lbytes}`
|
|
tblocks=`expr ${tblocks} + ${lblocks}`
|
|
truns=`expr ${truns} + ${lruns}`
|
|
|
|
if [ ${stat_minbytes} -gt ${minbytes} ]; then
|
|
stat_minbytes=${minbytes}
|
|
fi
|
|
|
|
if [ ${stat_maxbytes} -lt ${maxbytes} ]; then
|
|
stat_maxbytes=${maxbytes}
|
|
fi
|
|
|
|
if [ ${stat_minblocks} -gt ${minblocks} ]; then
|
|
stat_minblocks=${minblocks}
|
|
fi
|
|
|
|
if [ ${stat_maxblocks} -lt ${maxblocks} ]; then
|
|
stat_maxblocks=${maxblocks}
|
|
fi
|
|
|
|
stat_bytes=`expr ${stat_bytes} + ${lbytes}`
|
|
stat_blocks=`expr ${stat_blocks} + ${lblocks}`
|
|
stat_runs=`expr ${stat_runs} + ${lruns}`
|
|
}
|
|
|
|
stat_print()
|
|
{
|
|
if [ ${stat_runs} -gt 0 ]; then
|
|
stat_avgbytes=`expr "${stat_bytes}" / "${stat_runs}"`
|
|
stat_avgblocks=`expr "${stat_blocks}" / "${stat_runs}"`
|
|
|
|
echo
|
|
echo "$1 statistics:"
|
|
echo "Leaked bytes: ${stat_minbytes} min, ${stat_avgbytes} avg, ${stat_maxbytes} max"
|
|
echo "Leaked blocks: ${stat_minblocks} min, ${stat_avgblocks} avg, ${stat_maxblocks} max"
|
|
echo "Total runs: ${stat_runs}"
|
|
echo
|
|
fi
|
|
}
|
|
|
|
########################## run_ciphers_server ##########################
|
|
# local shell function to test server part of code (selfserv)
|
|
########################################################################
|
|
run_ciphers_server()
|
|
{
|
|
html_head "Memory leak checking - server"
|
|
|
|
stat_clear
|
|
|
|
client_mode="NORMAL"
|
|
for server_mode in ${MODE_LIST}; do
|
|
set_test_mode
|
|
|
|
for freebl in ${FREEBL_LIST}; do
|
|
set_freebl || continue
|
|
|
|
LOGNAME=server-${BIT_NAME}-${freebl}-${server_mode}
|
|
LOGFILE=${LOGDIR}/${LOGNAME}.log
|
|
echo "Running ${LOGNAME}"
|
|
|
|
(
|
|
run_selfserv_dbg 2>> ${LOGFILE} &
|
|
sleep 5
|
|
run_strsclnt
|
|
)
|
|
|
|
sleep 20
|
|
clear_freebl
|
|
|
|
log_parse
|
|
ret=$?
|
|
|
|
html_msg ${ret} 0 "${LOGNAME}" "produced a returncode of $ret, expected is 0"
|
|
done
|
|
done
|
|
|
|
stat_print "Selfserv"
|
|
|
|
html "</TABLE><BR>"
|
|
}
|
|
|
|
########################## run_ciphers_client ##########################
|
|
# local shell function to test client part of code (strsclnt)
|
|
########################################################################
|
|
run_ciphers_client()
|
|
{
|
|
html_head "Memory leak checking - client"
|
|
|
|
stat_clear
|
|
|
|
server_mode="NORMAL"
|
|
for client_mode in ${MODE_LIST}; do
|
|
set_test_mode
|
|
|
|
for freebl in ${FREEBL_LIST}; do
|
|
set_freebl || continue
|
|
|
|
LOGNAME=client-${BIT_NAME}-${freebl}-${client_mode}
|
|
LOGFILE=${LOGDIR}/${LOGNAME}.log
|
|
echo "Running ${LOGNAME}"
|
|
|
|
(
|
|
run_selfserv &
|
|
sleep 5
|
|
run_strsclnt_dbg 2>> ${LOGFILE}
|
|
)
|
|
|
|
sleep 20
|
|
clear_freebl
|
|
|
|
log_parse
|
|
ret=$?
|
|
html_msg ${ret} 0 "${LOGNAME}" "produced a returncode of $ret, expected is 0"
|
|
done
|
|
done
|
|
|
|
stat_print "Strsclnt"
|
|
|
|
html "</TABLE><BR>"
|
|
}
|
|
|
|
########################## parse_logfile_dbx ###########################
|
|
# local shell function to parse and process logs from dbx
|
|
########################################################################
|
|
parse_logfile_dbx()
|
|
{
|
|
${AWK} '
|
|
BEGIN {
|
|
in_mel = 0
|
|
mel_line = 0
|
|
bytes = 0
|
|
lbytes = 0
|
|
minbytes = 9999999
|
|
maxbytes = 0
|
|
blocks = 0
|
|
lblocks = 0
|
|
minblocks = 9999999
|
|
maxblocks = 0
|
|
runs = 0
|
|
stack_string = ""
|
|
bin_name = ""
|
|
}
|
|
/Memory Leak \(mel\):/ ||
|
|
/Possible memory leak -- address in block \(aib\):/ ||
|
|
/Block in use \(biu\):/ {
|
|
in_mel = 1
|
|
stack_string = ""
|
|
next
|
|
}
|
|
in_mel == 1 && /^$/ {
|
|
print bin_name stack_string
|
|
in_mel = 0
|
|
mel_line = 0
|
|
next
|
|
}
|
|
in_mel == 1 {
|
|
mel_line += 1
|
|
}
|
|
/Found leaked block of size/ {
|
|
bytes += $6
|
|
blocks += 1
|
|
next
|
|
}
|
|
/Found .* leaked blocks/ {
|
|
bytes += $8
|
|
blocks += $2
|
|
next
|
|
}
|
|
/Found block of size/ {
|
|
bytes += $5
|
|
blocks += 1
|
|
next
|
|
}
|
|
/Found .* blocks totaling/ {
|
|
bytes += $5
|
|
blocks += $2
|
|
next
|
|
}
|
|
mel_line > 2 {
|
|
gsub(/\(\)/, "")
|
|
new_line = $2
|
|
stack_string = "/" new_line stack_string
|
|
next
|
|
}
|
|
/^Running: / {
|
|
bin_name = $2
|
|
next
|
|
}
|
|
/execution completed/ {
|
|
runs += 1
|
|
lbytes += bytes
|
|
minbytes = (minbytes < bytes) ? minbytes : bytes
|
|
maxbytes = (maxbytes > bytes) ? maxbytes : bytes
|
|
bytes = 0
|
|
lblocks += blocks
|
|
minblocks = (minblocks < blocks) ? minblocks : blocks
|
|
maxblocks = (maxblocks > blocks) ? maxblocks : blocks
|
|
blocks = 0
|
|
next
|
|
}
|
|
END {
|
|
print "# " lbytes " bytes " lblocks " blocks in " runs " runs " \
|
|
minbytes " minbytes " maxbytes " maxbytes " minblocks " minblocks " \
|
|
maxblocks " maxblocks " > "/dev/stderr"
|
|
}' 2> ${TMP_COUNT}
|
|
|
|
stat_add
|
|
}
|
|
|
|
######################## parse_logfile_valgrind ########################
|
|
# local shell function to parse and process logs from valgrind
|
|
########################################################################
|
|
parse_logfile_valgrind()
|
|
{
|
|
${AWK} '
|
|
BEGIN {
|
|
in_mel = 0
|
|
in_sum = 0
|
|
bytes = 0
|
|
lbytes = 0
|
|
minbytes = 9999999
|
|
maxbytes = 0
|
|
blocks = 0
|
|
lblocks = 0
|
|
minblocks = 9999999
|
|
maxblocks = 0
|
|
runs = 0
|
|
stack_string = ""
|
|
bin_name = ""
|
|
}
|
|
!/==[0-9]*==/ {
|
|
if ( $1 == "Running:" )
|
|
bin_name = $2
|
|
bin_nf = split(bin_name, bin_fields, "/")
|
|
bin_name = bin_fields[bin_nf]
|
|
next
|
|
}
|
|
/blocks are/ {
|
|
in_mel = 1
|
|
stack_string = ""
|
|
next
|
|
}
|
|
/LEAK SUMMARY/ {
|
|
in_sum = 1
|
|
next
|
|
}
|
|
/^==[0-9]*== *$/ {
|
|
if (in_mel)
|
|
print bin_name stack_string
|
|
if (in_sum) {
|
|
runs += 1
|
|
lbytes += bytes
|
|
minbytes = (minbytes < bytes) ? minbytes : bytes
|
|
maxbytes = (maxbytes > bytes) ? maxbytes : bytes
|
|
bytes = 0
|
|
lblocks += blocks
|
|
minblocks = (minblocks < blocks) ? minblocks : blocks
|
|
maxblocks = (maxblocks > blocks) ? maxblocks : blocks
|
|
blocks = 0
|
|
}
|
|
in_sum = 0
|
|
in_mel = 0
|
|
next
|
|
}
|
|
in_mel == 1 {
|
|
new_line = $4
|
|
if ( new_line == "(within")
|
|
new_line = "*"
|
|
stack_string = "/" new_line stack_string
|
|
}
|
|
in_sum == 1 {
|
|
for (i = 2; i <= NF; i++) {
|
|
if ($i == "bytes") {
|
|
str = $(i - 1)
|
|
gsub(",", "", str)
|
|
bytes += str
|
|
}
|
|
if ($i == "blocks.") {
|
|
str = $(i - 1)
|
|
gsub(",", "", str)
|
|
blocks += str
|
|
}
|
|
}
|
|
}
|
|
END {
|
|
print "# " lbytes " bytes " lblocks " blocks in " runs " runs " \
|
|
minbytes " minbytes " maxbytes " maxbytes " minblocks " minblocks " \
|
|
maxblocks " maxblocks " > "/dev/stderr"
|
|
}' 2> ${TMP_COUNT}
|
|
|
|
stat_add
|
|
}
|
|
|
|
############################# check_ignored ############################
|
|
# local shell function to check all stacks if they are not ignored
|
|
########################################################################
|
|
check_ignored()
|
|
{
|
|
${AWK} -F/ '
|
|
BEGIN {
|
|
ignore = "'${IGNORED_STACKS}'"
|
|
# read in the ignore file
|
|
BUGNUM = ""
|
|
count = 0
|
|
new = 0
|
|
while ((getline line < ignore) > 0) {
|
|
if (line ~ "^#[0-9]+") {
|
|
BUGNUM = line
|
|
} else if (line ~ "^#") {
|
|
continue
|
|
} else if (line == "") {
|
|
continue
|
|
} else {
|
|
bugnum_array[count] = BUGNUM
|
|
# Create a regular expression for the ignored stack:
|
|
# replace * with % so we can later replace them with regular expressions
|
|
# without messing up everything (the regular expressions contain *)
|
|
gsub("\\*", "%", line)
|
|
# replace %% with .*
|
|
gsub("%%", ".*", line)
|
|
# replace % with [^/]*
|
|
gsub("%", "[^/]*", line)
|
|
# add ^ at the beginning
|
|
# add $ at the end
|
|
line_array[count] = "^" line "$"
|
|
count++
|
|
}
|
|
}
|
|
}
|
|
{
|
|
match_found = 0
|
|
# Look for matching ignored stack
|
|
for (i = 0; i < count; i++) {
|
|
if ($0 ~ line_array[i]) {
|
|
# found a match
|
|
match_found = 1
|
|
bug_found = bugnum_array[i]
|
|
break
|
|
}
|
|
}
|
|
# Process result
|
|
if (match_found == 1 ) {
|
|
if (bug_found != "") {
|
|
print "IGNORED STACK (" bug_found "): " $0
|
|
} else {
|
|
print "IGNORED STACK: " $0
|
|
}
|
|
} else {
|
|
print "NEW STACK: " $0
|
|
new = 1
|
|
}
|
|
}
|
|
END {
|
|
exit new
|
|
}'
|
|
ret=$?
|
|
return $ret
|
|
}
|
|
|
|
############################### parse_log ##############################
|
|
# local shell function to parse log file
|
|
########################################################################
|
|
log_parse()
|
|
{
|
|
${PARSE_LOGFILE} < ${LOGFILE} > ${TMP_STACKS}
|
|
echo "${SCRIPTNAME}: Processing log ${LOGNAME}:" > ${TMP_SORTED}
|
|
cat ${TMP_STACKS} | sort -u | check_ignored >> ${TMP_SORTED}
|
|
ret=$?
|
|
echo >> ${TMP_SORTED}
|
|
|
|
cat ${TMP_SORTED} | tee -a ${FOUNDLEAKS}
|
|
rm ${TMP_STACKS} ${TMP_SORTED}
|
|
|
|
return ${ret}
|
|
}
|
|
|
|
############################## cnt_total ###############################
|
|
# local shell function to count total leaked bytes
|
|
########################################################################
|
|
cnt_total()
|
|
{
|
|
echo ""
|
|
echo "TinderboxPrint:${OPT} Lk bytes: ${tbytes}"
|
|
echo "TinderboxPrint:${OPT} Lk blocks: ${tblocks}"
|
|
echo "TinderboxPrint:${OPT} # of runs: ${truns}"
|
|
echo ""
|
|
}
|
|
|
|
############################### run_ocsp ###############################
|
|
# local shell function to run ocsp tests
|
|
########################################################################
|
|
run_ocsp()
|
|
{
|
|
stat_clear
|
|
|
|
cd ${QADIR}/iopr
|
|
. ./ocsp_iopr.sh
|
|
ocsp_iopr_run
|
|
|
|
stat_print "Ocspclnt"
|
|
}
|
|
|
|
############################## run_chains ##############################
|
|
# local shell function to run PKIX certificate chains tests
|
|
########################################################################
|
|
run_chains()
|
|
{
|
|
stat_clear
|
|
|
|
LOGNAME="chains"
|
|
LOGFILE=${LOGDIR}/chains.log
|
|
|
|
. ${QADIR}/chains/chains.sh
|
|
|
|
stat_print "Chains"
|
|
}
|
|
|
|
############################## run_chains ##############################
|
|
# local shell function to run memory leak tests
|
|
#
|
|
# NSS_MEMLEAK_TESTS - list of tests to run, if not defined before,
|
|
# then is redefined to default list
|
|
########################################################################
|
|
memleak_run_tests()
|
|
{
|
|
nss_memleak_tests="ssl_server ssl_client chains ocsp"
|
|
NSS_MEMLEAK_TESTS="${NSS_MEMLEAK_TESTS:-$nss_memleak_tests}"
|
|
|
|
for MEMLEAK_TEST in ${NSS_MEMLEAK_TESTS}
|
|
do
|
|
case "${MEMLEAK_TEST}" in
|
|
"ssl_server")
|
|
run_ciphers_server
|
|
;;
|
|
"ssl_client")
|
|
run_ciphers_client
|
|
;;
|
|
"chains")
|
|
run_chains
|
|
;;
|
|
"ocsp")
|
|
run_ocsp
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
################################# main #################################
|
|
|
|
memleak_init
|
|
memleak_run_tests
|
|
cnt_total
|
|
memleak_cleanup
|
|
|