pgbouncer-1.24.1/ 0000755 0000000 0000000 00000000000 14777762567 010566 5 0000000 0000000 pgbouncer-1.24.1/config.guess 0000755 0001750 0001750 00000140512 14777762315 013052 0000000 0000000 #! /bin/sh
# Attempt to guess a canonical system name.
# Copyright 1992-2022 Free Software Foundation, Inc.
# shellcheck disable=SC2006,SC2268 # see below for rationale
timestamp='2022-01-09'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see .
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program. This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").
#
# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
#
# You can get the latest version of this script from:
# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess
#
# Please send patches to .
# The "shellcheck disable" line above the timestamp inhibits complaints
# about features and limitations of the classic Bourne shell that were
# superseded or lifted in POSIX. However, this script identifies a wide
# variety of pre-POSIX systems that do not have POSIX shells at all, and
# even some reasonably current systems (Solaris 10 as case-in-point) still
# have a pre-POSIX /bin/sh.
me=`echo "$0" | sed -e 's,.*/,,'`
usage="\
Usage: $0 [OPTION]
Output the configuration name of the system \`$me' is run on.
Options:
-h, --help print this help, then exit
-t, --time-stamp print date of last modification, then exit
-v, --version print version number, then exit
Report bugs and patches to ."
version="\
GNU config.guess ($timestamp)
Originally written by Per Bothner.
Copyright 1992-2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
help="
Try \`$me --help' for more information."
# Parse command line
while test $# -gt 0 ; do
case $1 in
--time-stamp | --time* | -t )
echo "$timestamp" ; exit ;;
--version | -v )
echo "$version" ; exit ;;
--help | --h* | -h )
echo "$usage"; exit ;;
-- ) # Stop option processing
shift; break ;;
- ) # Use stdin as input.
break ;;
-* )
echo "$me: invalid option $1$help" >&2
exit 1 ;;
* )
break ;;
esac
done
if test $# != 0; then
echo "$me: too many arguments$help" >&2
exit 1
fi
# Just in case it came from the environment.
GUESS=
# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
# compiler to aid in system detection is discouraged as it requires
# temporary files to be created and, as you can see below, it is a
# headache to deal with in a portable fashion.
# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
# use `HOST_CC' if defined, but it is deprecated.
# Portable tmp directory creation inspired by the Autoconf team.
tmp=
# shellcheck disable=SC2172
trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15
set_cc_for_build() {
# prevent multiple calls if $tmp is already set
test "$tmp" && return 0
: "${TMPDIR=/tmp}"
# shellcheck disable=SC2039,SC3028
{ tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
{ test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } ||
{ tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } ||
{ echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; }
dummy=$tmp/dummy
case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in
,,) echo "int x;" > "$dummy.c"
for driver in cc gcc c89 c99 ; do
if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
CC_FOR_BUILD=$driver
break
fi
done
if test x"$CC_FOR_BUILD" = x ; then
CC_FOR_BUILD=no_compiler_found
fi
;;
,,*) CC_FOR_BUILD=$CC ;;
,*,*) CC_FOR_BUILD=$HOST_CC ;;
esac
}
# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
# (ghazi@noc.rutgers.edu 1994-08-24)
if test -f /.attbin/uname ; then
PATH=$PATH:/.attbin ; export PATH
fi
UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
case $UNAME_SYSTEM in
Linux|GNU|GNU/*)
LIBC=unknown
set_cc_for_build
cat <<-EOF > "$dummy.c"
#include
#if defined(__UCLIBC__)
LIBC=uclibc
#elif defined(__dietlibc__)
LIBC=dietlibc
#elif defined(__GLIBC__)
LIBC=gnu
#else
#include
/* First heuristic to detect musl libc. */
#ifdef __DEFINED_va_list
LIBC=musl
#endif
#endif
EOF
cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
eval "$cc_set_libc"
# Second heuristic to detect musl libc.
if [ "$LIBC" = unknown ] &&
command -v ldd >/dev/null &&
ldd --version 2>&1 | grep -q ^musl; then
LIBC=musl
fi
# If the system lacks a compiler, then just pick glibc.
# We could probably try harder.
if [ "$LIBC" = unknown ]; then
LIBC=gnu
fi
;;
esac
# Note: order is significant - the case branches are not exclusive.
case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in
*:NetBSD:*:*)
# NetBSD (nbsd) targets should (where applicable) match one or
# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
# *-*-netbsdecoff* and *-*-netbsd*. For targets that recently
# switched to ELF, *-*-netbsd* would select the old
# object file format. This provides both forward
# compatibility and a consistent mechanism for selecting the
# object file format.
#
# Note: NetBSD doesn't particularly care about the vendor
# portion of the name. We always set it to "unknown".
UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
/sbin/sysctl -n hw.machine_arch 2>/dev/null || \
/usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \
echo unknown)`
case $UNAME_MACHINE_ARCH in
aarch64eb) machine=aarch64_be-unknown ;;
armeb) machine=armeb-unknown ;;
arm*) machine=arm-unknown ;;
sh3el) machine=shl-unknown ;;
sh3eb) machine=sh-unknown ;;
sh5el) machine=sh5le-unknown ;;
earmv*)
arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'`
endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'`
machine=${arch}${endian}-unknown
;;
*) machine=$UNAME_MACHINE_ARCH-unknown ;;
esac
# The Operating System including object format, if it has switched
# to ELF recently (or will in the future) and ABI.
case $UNAME_MACHINE_ARCH in
earm*)
os=netbsdelf
;;
arm*|i386|m68k|ns32k|sh3*|sparc|vax)
set_cc_for_build
if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ELF__
then
# Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
# Return netbsd for either. FIX?
os=netbsd
else
os=netbsdelf
fi
;;
*)
os=netbsd
;;
esac
# Determine ABI tags.
case $UNAME_MACHINE_ARCH in
earm*)
expr='s/^earmv[0-9]/-eabi/;s/eb$//'
abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
;;
esac
# The OS release
# Debian GNU/NetBSD machines have a different userland, and
# thus, need a distinct triplet. However, they do not need
# kernel version information, so it can be replaced with a
# suitable tag, in the style of linux-gnu.
case $UNAME_VERSION in
Debian*)
release='-gnu'
;;
*)
release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2`
;;
esac
# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
# contains redundant information, the shorter form:
# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
GUESS=$machine-${os}${release}${abi-}
;;
*:Bitrig:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE
;;
*:OpenBSD:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE
;;
*:SecBSD:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'`
GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE
;;
*:LibertyBSD:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE
;;
*:MidnightBSD:*:*)
GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE
;;
*:ekkoBSD:*:*)
GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE
;;
*:SolidBSD:*:*)
GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE
;;
*:OS108:*:*)
GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE
;;
macppc:MirBSD:*:*)
GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE
;;
*:MirBSD:*:*)
GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE
;;
*:Sortix:*:*)
GUESS=$UNAME_MACHINE-unknown-sortix
;;
*:Twizzler:*:*)
GUESS=$UNAME_MACHINE-unknown-twizzler
;;
*:Redox:*:*)
GUESS=$UNAME_MACHINE-unknown-redox
;;
mips:OSF1:*.*)
GUESS=mips-dec-osf1
;;
alpha:OSF1:*:*)
# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
trap '' 0
case $UNAME_RELEASE in
*4.0)
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
;;
*5.*)
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
;;
esac
# According to Compaq, /usr/sbin/psrinfo has been available on
# OSF/1 and Tru64 systems produced since 1995. I hope that
# covers most systems running today. This code pipes the CPU
# types through head -n 1, so we only detect the type of CPU 0.
ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1`
case $ALPHA_CPU_TYPE in
"EV4 (21064)")
UNAME_MACHINE=alpha ;;
"EV4.5 (21064)")
UNAME_MACHINE=alpha ;;
"LCA4 (21066/21068)")
UNAME_MACHINE=alpha ;;
"EV5 (21164)")
UNAME_MACHINE=alphaev5 ;;
"EV5.6 (21164A)")
UNAME_MACHINE=alphaev56 ;;
"EV5.6 (21164PC)")
UNAME_MACHINE=alphapca56 ;;
"EV5.7 (21164PC)")
UNAME_MACHINE=alphapca57 ;;
"EV6 (21264)")
UNAME_MACHINE=alphaev6 ;;
"EV6.7 (21264A)")
UNAME_MACHINE=alphaev67 ;;
"EV6.8CB (21264C)")
UNAME_MACHINE=alphaev68 ;;
"EV6.8AL (21264B)")
UNAME_MACHINE=alphaev68 ;;
"EV6.8CX (21264D)")
UNAME_MACHINE=alphaev68 ;;
"EV6.9A (21264/EV69A)")
UNAME_MACHINE=alphaev69 ;;
"EV7 (21364)")
UNAME_MACHINE=alphaev7 ;;
"EV7.9 (21364A)")
UNAME_MACHINE=alphaev79 ;;
esac
# A Pn.n version is a patched version.
# A Vn.n version is a released version.
# A Tn.n version is a released field test version.
# A Xn.n version is an unreleased experimental baselevel.
# 1.2 uses "1.2" for uname -r.
OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
GUESS=$UNAME_MACHINE-dec-osf$OSF_REL
;;
Amiga*:UNIX_System_V:4.0:*)
GUESS=m68k-unknown-sysv4
;;
*:[Aa]miga[Oo][Ss]:*:*)
GUESS=$UNAME_MACHINE-unknown-amigaos
;;
*:[Mm]orph[Oo][Ss]:*:*)
GUESS=$UNAME_MACHINE-unknown-morphos
;;
*:OS/390:*:*)
GUESS=i370-ibm-openedition
;;
*:z/VM:*:*)
GUESS=s390-ibm-zvmoe
;;
*:OS400:*:*)
GUESS=powerpc-ibm-os400
;;
arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
GUESS=arm-acorn-riscix$UNAME_RELEASE
;;
arm*:riscos:*:*|arm*:RISCOS:*:*)
GUESS=arm-unknown-riscos
;;
SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
GUESS=hppa1.1-hitachi-hiuxmpp
;;
Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
case `(/bin/universe) 2>/dev/null` in
att) GUESS=pyramid-pyramid-sysv3 ;;
*) GUESS=pyramid-pyramid-bsd ;;
esac
;;
NILE*:*:*:dcosx)
GUESS=pyramid-pyramid-svr4
;;
DRS?6000:unix:4.0:6*)
GUESS=sparc-icl-nx6
;;
DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
case `/usr/bin/uname -p` in
sparc) GUESS=sparc-icl-nx7 ;;
esac
;;
s390x:SunOS:*:*)
SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL
;;
sun4H:SunOS:5.*:*)
SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
GUESS=sparc-hal-solaris2$SUN_REL
;;
sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
GUESS=sparc-sun-solaris2$SUN_REL
;;
i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
GUESS=i386-pc-auroraux$UNAME_RELEASE
;;
i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
set_cc_for_build
SUN_ARCH=i386
# If there is a compiler, see if it is configured for 64-bit objects.
# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
# This test works for both compilers.
if test "$CC_FOR_BUILD" != no_compiler_found; then
if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
(CCOPTS="" $CC_FOR_BUILD -m64 -E - 2>/dev/null) | \
grep IS_64BIT_ARCH >/dev/null
then
SUN_ARCH=x86_64
fi
fi
SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
GUESS=$SUN_ARCH-pc-solaris2$SUN_REL
;;
sun4*:SunOS:6*:*)
# According to config.sub, this is the proper way to canonicalize
# SunOS6. Hard to guess exactly what SunOS6 will be like, but
# it's likely to be more like Solaris than SunOS4.
SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
GUESS=sparc-sun-solaris3$SUN_REL
;;
sun4*:SunOS:*:*)
case `/usr/bin/arch -k` in
Series*|S4*)
UNAME_RELEASE=`uname -v`
;;
esac
# Japanese Language versions have a version number like `4.1.3-JL'.
SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'`
GUESS=sparc-sun-sunos$SUN_REL
;;
sun3*:SunOS:*:*)
GUESS=m68k-sun-sunos$UNAME_RELEASE
;;
sun*:*:4.2BSD:*)
UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
case `/bin/arch` in
sun3)
GUESS=m68k-sun-sunos$UNAME_RELEASE
;;
sun4)
GUESS=sparc-sun-sunos$UNAME_RELEASE
;;
esac
;;
aushp:SunOS:*:*)
GUESS=sparc-auspex-sunos$UNAME_RELEASE
;;
# The situation for MiNT is a little confusing. The machine name
# can be virtually everything (everything which is not
# "atarist" or "atariste" at least should have a processor
# > m68000). The system name ranges from "MiNT" over "FreeMiNT"
# to the lowercase version "mint" (or "freemint"). Finally
# the system name "TOS" denotes a system which is actually not
# MiNT. But MiNT is downward compatible to TOS, so this should
# be no problem.
atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
GUESS=m68k-atari-mint$UNAME_RELEASE
;;
atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
GUESS=m68k-atari-mint$UNAME_RELEASE
;;
*falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
GUESS=m68k-atari-mint$UNAME_RELEASE
;;
milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
GUESS=m68k-milan-mint$UNAME_RELEASE
;;
hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
GUESS=m68k-hades-mint$UNAME_RELEASE
;;
*:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
GUESS=m68k-unknown-mint$UNAME_RELEASE
;;
m68k:machten:*:*)
GUESS=m68k-apple-machten$UNAME_RELEASE
;;
powerpc:machten:*:*)
GUESS=powerpc-apple-machten$UNAME_RELEASE
;;
RISC*:Mach:*:*)
GUESS=mips-dec-mach_bsd4.3
;;
RISC*:ULTRIX:*:*)
GUESS=mips-dec-ultrix$UNAME_RELEASE
;;
VAX*:ULTRIX*:*:*)
GUESS=vax-dec-ultrix$UNAME_RELEASE
;;
2020:CLIX:*:* | 2430:CLIX:*:*)
GUESS=clipper-intergraph-clix$UNAME_RELEASE
;;
mips:*:*:UMIPS | mips:*:*:RISCos)
set_cc_for_build
sed 's/^ //' << EOF > "$dummy.c"
#ifdef __cplusplus
#include /* for printf() prototype */
int main (int argc, char *argv[]) {
#else
int main (argc, argv) int argc; char *argv[]; {
#endif
#if defined (host_mips) && defined (MIPSEB)
#if defined (SYSTYPE_SYSV)
printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0);
#endif
#if defined (SYSTYPE_SVR4)
printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0);
#endif
#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0);
#endif
#endif
exit (-1);
}
EOF
$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` &&
SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
{ echo "$SYSTEM_NAME"; exit; }
GUESS=mips-mips-riscos$UNAME_RELEASE
;;
Motorola:PowerMAX_OS:*:*)
GUESS=powerpc-motorola-powermax
;;
Motorola:*:4.3:PL8-*)
GUESS=powerpc-harris-powermax
;;
Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
GUESS=powerpc-harris-powermax
;;
Night_Hawk:Power_UNIX:*:*)
GUESS=powerpc-harris-powerunix
;;
m88k:CX/UX:7*:*)
GUESS=m88k-harris-cxux7
;;
m88k:*:4*:R4*)
GUESS=m88k-motorola-sysv4
;;
m88k:*:3*:R3*)
GUESS=m88k-motorola-sysv3
;;
AViiON:dgux:*:*)
# DG/UX returns AViiON for all architectures
UNAME_PROCESSOR=`/usr/bin/uname -p`
if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110
then
if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \
test "$TARGET_BINARY_INTERFACE"x = x
then
GUESS=m88k-dg-dgux$UNAME_RELEASE
else
GUESS=m88k-dg-dguxbcs$UNAME_RELEASE
fi
else
GUESS=i586-dg-dgux$UNAME_RELEASE
fi
;;
M88*:DolphinOS:*:*) # DolphinOS (SVR3)
GUESS=m88k-dolphin-sysv3
;;
M88*:*:R3*:*)
# Delta 88k system running SVR3
GUESS=m88k-motorola-sysv3
;;
XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
GUESS=m88k-tektronix-sysv3
;;
Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
GUESS=m68k-tektronix-bsd
;;
*:IRIX*:*:*)
IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'`
GUESS=mips-sgi-irix$IRIX_REL
;;
????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
GUESS=romp-ibm-aix # uname -m gives an 8 hex-code CPU id
;; # Note that: echo "'`uname -s`'" gives 'AIX '
i*86:AIX:*:*)
GUESS=i386-ibm-aix
;;
ia64:AIX:*:*)
if test -x /usr/bin/oslevel ; then
IBM_REV=`/usr/bin/oslevel`
else
IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
fi
GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV
;;
*:AIX:2:3)
if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
set_cc_for_build
sed 's/^ //' << EOF > "$dummy.c"
#include
main()
{
if (!__power_pc())
exit(1);
puts("powerpc-ibm-aix3.2.5");
exit(0);
}
EOF
if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
then
GUESS=$SYSTEM_NAME
else
GUESS=rs6000-ibm-aix3.2.5
fi
elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
GUESS=rs6000-ibm-aix3.2.4
else
GUESS=rs6000-ibm-aix3.2
fi
;;
*:AIX:*:[4567])
IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
IBM_ARCH=rs6000
else
IBM_ARCH=powerpc
fi
if test -x /usr/bin/lslpp ; then
IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \
awk -F: '{ print $3 }' | sed s/[0-9]*$/0/`
else
IBM_REV=$UNAME_VERSION.$UNAME_RELEASE
fi
GUESS=$IBM_ARCH-ibm-aix$IBM_REV
;;
*:AIX:*:*)
GUESS=rs6000-ibm-aix
;;
ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
GUESS=romp-ibm-bsd4.4
;;
ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and
GUESS=romp-ibm-bsd$UNAME_RELEASE # 4.3 with uname added to
;; # report: romp-ibm BSD 4.3
*:BOSX:*:*)
GUESS=rs6000-bull-bosx
;;
DPX/2?00:B.O.S.:*:*)
GUESS=m68k-bull-sysv3
;;
9000/[34]??:4.3bsd:1.*:*)
GUESS=m68k-hp-bsd
;;
hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
GUESS=m68k-hp-bsd4.4
;;
9000/[34678]??:HP-UX:*:*)
HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
case $UNAME_MACHINE in
9000/31?) HP_ARCH=m68000 ;;
9000/[34]??) HP_ARCH=m68k ;;
9000/[678][0-9][0-9])
if test -x /usr/bin/getconf; then
sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
case $sc_cpu_version in
523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
532) # CPU_PA_RISC2_0
case $sc_kernel_bits in
32) HP_ARCH=hppa2.0n ;;
64) HP_ARCH=hppa2.0w ;;
'') HP_ARCH=hppa2.0 ;; # HP-UX 10.20
esac ;;
esac
fi
if test "$HP_ARCH" = ""; then
set_cc_for_build
sed 's/^ //' << EOF > "$dummy.c"
#define _HPUX_SOURCE
#include
#include
int main ()
{
#if defined(_SC_KERNEL_BITS)
long bits = sysconf(_SC_KERNEL_BITS);
#endif
long cpu = sysconf (_SC_CPU_VERSION);
switch (cpu)
{
case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
case CPU_PA_RISC2_0:
#if defined(_SC_KERNEL_BITS)
switch (bits)
{
case 64: puts ("hppa2.0w"); break;
case 32: puts ("hppa2.0n"); break;
default: puts ("hppa2.0"); break;
} break;
#else /* !defined(_SC_KERNEL_BITS) */
puts ("hppa2.0"); break;
#endif
default: puts ("hppa1.0"); break;
}
exit (0);
}
EOF
(CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
test -z "$HP_ARCH" && HP_ARCH=hppa
fi ;;
esac
if test "$HP_ARCH" = hppa2.0w
then
set_cc_for_build
# hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
# 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler
# generating 64-bit code. GNU and HP use different nomenclature:
#
# $ CC_FOR_BUILD=cc ./config.guess
# => hppa2.0w-hp-hpux11.23
# $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
# => hppa64-hp-hpux11.23
if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
grep -q __LP64__
then
HP_ARCH=hppa2.0w
else
HP_ARCH=hppa64
fi
fi
GUESS=$HP_ARCH-hp-hpux$HPUX_REV
;;
ia64:HP-UX:*:*)
HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'`
GUESS=ia64-hp-hpux$HPUX_REV
;;
3050*:HI-UX:*:*)
set_cc_for_build
sed 's/^ //' << EOF > "$dummy.c"
#include
int
main ()
{
long cpu = sysconf (_SC_CPU_VERSION);
/* The order matters, because CPU_IS_HP_MC68K erroneously returns
true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct
results, however. */
if (CPU_IS_PA_RISC (cpu))
{
switch (cpu)
{
case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
default: puts ("hppa-hitachi-hiuxwe2"); break;
}
}
else if (CPU_IS_HP_MC68K (cpu))
puts ("m68k-hitachi-hiuxwe2");
else puts ("unknown-hitachi-hiuxwe2");
exit (0);
}
EOF
$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
{ echo "$SYSTEM_NAME"; exit; }
GUESS=unknown-hitachi-hiuxwe2
;;
9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*)
GUESS=hppa1.1-hp-bsd
;;
9000/8??:4.3bsd:*:*)
GUESS=hppa1.0-hp-bsd
;;
*9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
GUESS=hppa1.0-hp-mpeix
;;
hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*)
GUESS=hppa1.1-hp-osf
;;
hp8??:OSF1:*:*)
GUESS=hppa1.0-hp-osf
;;
i*86:OSF1:*:*)
if test -x /usr/sbin/sysversion ; then
GUESS=$UNAME_MACHINE-unknown-osf1mk
else
GUESS=$UNAME_MACHINE-unknown-osf1
fi
;;
parisc*:Lites*:*:*)
GUESS=hppa1.1-hp-lites
;;
C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
GUESS=c1-convex-bsd
;;
C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
if getsysinfo -f scalar_acc
then echo c32-convex-bsd
else echo c2-convex-bsd
fi
exit ;;
C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
GUESS=c34-convex-bsd
;;
C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
GUESS=c38-convex-bsd
;;
C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
GUESS=c4-convex-bsd
;;
CRAY*Y-MP:*:*:*)
CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
GUESS=ymp-cray-unicos$CRAY_REL
;;
CRAY*[A-Z]90:*:*:*)
echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-e 's/\.[^.]*$/.X/'
exit ;;
CRAY*TS:*:*:*)
CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
GUESS=t90-cray-unicos$CRAY_REL
;;
CRAY*T3E:*:*:*)
CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
GUESS=alphaev5-cray-unicosmk$CRAY_REL
;;
CRAY*SV1:*:*:*)
CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
GUESS=sv1-cray-unicos$CRAY_REL
;;
*:UNICOS/mp:*:*)
CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'`
GUESS=craynv-cray-unicosmp$CRAY_REL
;;
F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
;;
5000:UNIX_System_V:4.*:*)
FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}
;;
i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE
;;
sparc*:BSD/OS:*:*)
GUESS=sparc-unknown-bsdi$UNAME_RELEASE
;;
*:BSD/OS:*:*)
GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE
;;
arm:FreeBSD:*:*)
UNAME_PROCESSOR=`uname -p`
set_cc_for_build
if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_PCS_VFP
then
FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi
else
FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf
fi
;;
*:FreeBSD:*:*)
UNAME_PROCESSOR=`/usr/bin/uname -p`
case $UNAME_PROCESSOR in
amd64)
UNAME_PROCESSOR=x86_64 ;;
i386)
UNAME_PROCESSOR=i586 ;;
esac
FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL
;;
i*:CYGWIN*:*)
GUESS=$UNAME_MACHINE-pc-cygwin
;;
*:MINGW64*:*)
GUESS=$UNAME_MACHINE-pc-mingw64
;;
*:MINGW*:*)
GUESS=$UNAME_MACHINE-pc-mingw32
;;
*:MSYS*:*)
GUESS=$UNAME_MACHINE-pc-msys
;;
i*:PW*:*)
GUESS=$UNAME_MACHINE-pc-pw32
;;
*:SerenityOS:*:*)
GUESS=$UNAME_MACHINE-pc-serenity
;;
*:Interix*:*)
case $UNAME_MACHINE in
x86)
GUESS=i586-pc-interix$UNAME_RELEASE
;;
authenticamd | genuineintel | EM64T)
GUESS=x86_64-unknown-interix$UNAME_RELEASE
;;
IA64)
GUESS=ia64-unknown-interix$UNAME_RELEASE
;;
esac ;;
i*:UWIN*:*)
GUESS=$UNAME_MACHINE-pc-uwin
;;
amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
GUESS=x86_64-pc-cygwin
;;
prep*:SunOS:5.*:*)
SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`
GUESS=powerpcle-unknown-solaris2$SUN_REL
;;
*:GNU:*:*)
# the GNU system
GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'`
GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'`
GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL
;;
*:GNU/*:*:*)
# other systems with GNU libc and userland
GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"`
GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC
;;
*:Minix:*:*)
GUESS=$UNAME_MACHINE-unknown-minix
;;
aarch64:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
aarch64_be:Linux:*:*)
UNAME_MACHINE=aarch64_be
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
alpha:Linux:*:*)
case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in
EV5) UNAME_MACHINE=alphaev5 ;;
EV56) UNAME_MACHINE=alphaev56 ;;
PCA56) UNAME_MACHINE=alphapca56 ;;
PCA57) UNAME_MACHINE=alphapca56 ;;
EV6) UNAME_MACHINE=alphaev6 ;;
EV67) UNAME_MACHINE=alphaev67 ;;
EV68*) UNAME_MACHINE=alphaev68 ;;
esac
objdump --private-headers /bin/sh | grep -q ld.so.1
if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
arm*:Linux:*:*)
set_cc_for_build
if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_EABI__
then
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
else
if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_PCS_VFP
then
GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi
else
GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf
fi
fi
;;
avr32*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
cris:Linux:*:*)
GUESS=$UNAME_MACHINE-axis-linux-$LIBC
;;
crisv32:Linux:*:*)
GUESS=$UNAME_MACHINE-axis-linux-$LIBC
;;
e2k:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
frv:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
hexagon:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
i*86:Linux:*:*)
GUESS=$UNAME_MACHINE-pc-linux-$LIBC
;;
ia64:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
k1om:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
m32r*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
m68*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
mips:Linux:*:* | mips64:Linux:*:*)
set_cc_for_build
IS_GLIBC=0
test x"${LIBC}" = xgnu && IS_GLIBC=1
sed 's/^ //' << EOF > "$dummy.c"
#undef CPU
#undef mips
#undef mipsel
#undef mips64
#undef mips64el
#if ${IS_GLIBC} && defined(_ABI64)
LIBCABI=gnuabi64
#else
#if ${IS_GLIBC} && defined(_ABIN32)
LIBCABI=gnuabin32
#else
LIBCABI=${LIBC}
#endif
#endif
#if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
CPU=mipsisa64r6
#else
#if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6
CPU=mipsisa32r6
#else
#if defined(__mips64)
CPU=mips64
#else
CPU=mips
#endif
#endif
#endif
#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
MIPS_ENDIAN=el
#else
#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
MIPS_ENDIAN=
#else
MIPS_ENDIAN=
#endif
#endif
EOF
cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'`
eval "$cc_set_vars"
test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; }
;;
mips64el:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
openrisc*:Linux:*:*)
GUESS=or1k-unknown-linux-$LIBC
;;
or32:Linux:*:* | or1k*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
padre:Linux:*:*)
GUESS=sparc-unknown-linux-$LIBC
;;
parisc64:Linux:*:* | hppa64:Linux:*:*)
GUESS=hppa64-unknown-linux-$LIBC
;;
parisc:Linux:*:* | hppa:Linux:*:*)
# Look for CPU level
case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;;
PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;;
*) GUESS=hppa-unknown-linux-$LIBC ;;
esac
;;
ppc64:Linux:*:*)
GUESS=powerpc64-unknown-linux-$LIBC
;;
ppc:Linux:*:*)
GUESS=powerpc-unknown-linux-$LIBC
;;
ppc64le:Linux:*:*)
GUESS=powerpc64le-unknown-linux-$LIBC
;;
ppcle:Linux:*:*)
GUESS=powerpcle-unknown-linux-$LIBC
;;
riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
s390:Linux:*:* | s390x:Linux:*:*)
GUESS=$UNAME_MACHINE-ibm-linux-$LIBC
;;
sh64*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
sh*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
sparc:Linux:*:* | sparc64:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
tile*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
vax:Linux:*:*)
GUESS=$UNAME_MACHINE-dec-linux-$LIBC
;;
x86_64:Linux:*:*)
set_cc_for_build
LIBCABI=$LIBC
if test "$CC_FOR_BUILD" != no_compiler_found; then
if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \
(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_X32 >/dev/null
then
LIBCABI=${LIBC}x32
fi
fi
GUESS=$UNAME_MACHINE-pc-linux-$LIBCABI
;;
xtensa*:Linux:*:*)
GUESS=$UNAME_MACHINE-unknown-linux-$LIBC
;;
i*86:DYNIX/ptx:4*:*)
# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
# earlier versions are messed up and put the nodename in both
# sysname and nodename.
GUESS=i386-sequent-sysv4
;;
i*86:UNIX_SV:4.2MP:2.*)
# Unixware is an offshoot of SVR4, but it has its own version
# number series starting with 2...
# I am not positive that other SVR4 systems won't match this,
# I just have to hope. -- rms.
# Use sysv4.2uw... so that sysv4* matches it.
GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION
;;
i*86:OS/2:*:*)
# If we were able to find `uname', then EMX Unix compatibility
# is probably installed.
GUESS=$UNAME_MACHINE-pc-os2-emx
;;
i*86:XTS-300:*:STOP)
GUESS=$UNAME_MACHINE-unknown-stop
;;
i*86:atheos:*:*)
GUESS=$UNAME_MACHINE-unknown-atheos
;;
i*86:syllable:*:*)
GUESS=$UNAME_MACHINE-pc-syllable
;;
i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
GUESS=i386-unknown-lynxos$UNAME_RELEASE
;;
i*86:*DOS:*:*)
GUESS=$UNAME_MACHINE-pc-msdosdjgpp
;;
i*86:*:4.*:*)
UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL
else
GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL
fi
;;
i*86:*:5:[678]*)
# UnixWare 7.x, OpenUNIX and OpenServer 6.
case `/bin/uname -X | grep "^Machine"` in
*486*) UNAME_MACHINE=i486 ;;
*Pentium) UNAME_MACHINE=i586 ;;
*Pent*|*Celeron) UNAME_MACHINE=i686 ;;
esac
GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
;;
i*86:*:3.2:*)
if test -f /usr/options/cb.name; then
UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then
UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
&& UNAME_MACHINE=i586
(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
&& UNAME_MACHINE=i686
(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
&& UNAME_MACHINE=i686
GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL
else
GUESS=$UNAME_MACHINE-pc-sysv32
fi
;;
pc:*:*:*)
# Left here for compatibility:
# uname -m prints for DJGPP always 'pc', but it prints nothing about
# the processor, so we play safe by assuming i586.
# Note: whatever this is, it MUST be the same as what config.sub
# prints for the "djgpp" host, or else GDB configure will decide that
# this is a cross-build.
GUESS=i586-pc-msdosdjgpp
;;
Intel:Mach:3*:*)
GUESS=i386-pc-mach3
;;
paragon:*:*:*)
GUESS=i860-intel-osf1
;;
i860:*:4.*:*) # i860-SVR4
if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
GUESS=i860-stardent-sysv$UNAME_RELEASE # Stardent Vistra i860-SVR4
else # Add other i860-SVR4 vendors below as they are discovered.
GUESS=i860-unknown-sysv$UNAME_RELEASE # Unknown i860-SVR4
fi
;;
mini*:CTIX:SYS*5:*)
# "miniframe"
GUESS=m68010-convergent-sysv
;;
mc68k:UNIX:SYSTEM5:3.51m)
GUESS=m68k-convergent-sysv
;;
M680?0:D-NIX:5.3:*)
GUESS=m68k-diab-dnix
;;
M68*:*:R3V[5678]*:*)
test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
OS_REL=''
test -r /etc/.relid \
&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
&& { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4; exit; } ;;
NCR*:*:4.2:* | MPRAS*:*:4.2:*)
OS_REL='.3'
test -r /etc/.relid \
&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
&& { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
&& { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
GUESS=m68k-unknown-lynxos$UNAME_RELEASE
;;
mc68030:UNIX_System_V:4.*:*)
GUESS=m68k-atari-sysv4
;;
TSUNAMI:LynxOS:2.*:*)
GUESS=sparc-unknown-lynxos$UNAME_RELEASE
;;
rs6000:LynxOS:2.*:*)
GUESS=rs6000-unknown-lynxos$UNAME_RELEASE
;;
PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
GUESS=powerpc-unknown-lynxos$UNAME_RELEASE
;;
SM[BE]S:UNIX_SV:*:*)
GUESS=mips-dde-sysv$UNAME_RELEASE
;;
RM*:ReliantUNIX-*:*:*)
GUESS=mips-sni-sysv4
;;
RM*:SINIX-*:*:*)
GUESS=mips-sni-sysv4
;;
*:SINIX-*:*:*)
if uname -p 2>/dev/null >/dev/null ; then
UNAME_MACHINE=`(uname -p) 2>/dev/null`
GUESS=$UNAME_MACHINE-sni-sysv4
else
GUESS=ns32k-sni-sysv
fi
;;
PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
# says
GUESS=i586-unisys-sysv4
;;
*:UNIX_System_V:4*:FTX*)
# From Gerald Hewes .
# How about differentiating between stratus architectures? -djm
GUESS=hppa1.1-stratus-sysv4
;;
*:*:*:FTX*)
# From seanf@swdc.stratus.com.
GUESS=i860-stratus-sysv4
;;
i*86:VOS:*:*)
# From Paul.Green@stratus.com.
GUESS=$UNAME_MACHINE-stratus-vos
;;
*:VOS:*:*)
# From Paul.Green@stratus.com.
GUESS=hppa1.1-stratus-vos
;;
mc68*:A/UX:*:*)
GUESS=m68k-apple-aux$UNAME_RELEASE
;;
news*:NEWS-OS:6*:*)
GUESS=mips-sony-newsos6
;;
R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
if test -d /usr/nec; then
GUESS=mips-nec-sysv$UNAME_RELEASE
else
GUESS=mips-unknown-sysv$UNAME_RELEASE
fi
;;
BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
GUESS=powerpc-be-beos
;;
BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only.
GUESS=powerpc-apple-beos
;;
BePC:BeOS:*:*) # BeOS running on Intel PC compatible.
GUESS=i586-pc-beos
;;
BePC:Haiku:*:*) # Haiku running on Intel PC compatible.
GUESS=i586-pc-haiku
;;
x86_64:Haiku:*:*)
GUESS=x86_64-unknown-haiku
;;
SX-4:SUPER-UX:*:*)
GUESS=sx4-nec-superux$UNAME_RELEASE
;;
SX-5:SUPER-UX:*:*)
GUESS=sx5-nec-superux$UNAME_RELEASE
;;
SX-6:SUPER-UX:*:*)
GUESS=sx6-nec-superux$UNAME_RELEASE
;;
SX-7:SUPER-UX:*:*)
GUESS=sx7-nec-superux$UNAME_RELEASE
;;
SX-8:SUPER-UX:*:*)
GUESS=sx8-nec-superux$UNAME_RELEASE
;;
SX-8R:SUPER-UX:*:*)
GUESS=sx8r-nec-superux$UNAME_RELEASE
;;
SX-ACE:SUPER-UX:*:*)
GUESS=sxace-nec-superux$UNAME_RELEASE
;;
Power*:Rhapsody:*:*)
GUESS=powerpc-apple-rhapsody$UNAME_RELEASE
;;
*:Rhapsody:*:*)
GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE
;;
arm64:Darwin:*:*)
GUESS=aarch64-apple-darwin$UNAME_RELEASE
;;
*:Darwin:*:*)
UNAME_PROCESSOR=`uname -p`
case $UNAME_PROCESSOR in
unknown) UNAME_PROCESSOR=powerpc ;;
esac
if command -v xcode-select > /dev/null 2> /dev/null && \
! xcode-select --print-path > /dev/null 2> /dev/null ; then
# Avoid executing cc if there is no toolchain installed as
# cc will be a stub that puts up a graphical alert
# prompting the user to install developer tools.
CC_FOR_BUILD=no_compiler_found
else
set_cc_for_build
fi
if test "$CC_FOR_BUILD" != no_compiler_found; then
if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_64BIT_ARCH >/dev/null
then
case $UNAME_PROCESSOR in
i386) UNAME_PROCESSOR=x86_64 ;;
powerpc) UNAME_PROCESSOR=powerpc64 ;;
esac
fi
# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_PPC >/dev/null
then
UNAME_PROCESSOR=powerpc
fi
elif test "$UNAME_PROCESSOR" = i386 ; then
# uname -m returns i386 or x86_64
UNAME_PROCESSOR=$UNAME_MACHINE
fi
GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE
;;
*:procnto*:*:* | *:QNX:[0123456789]*:*)
UNAME_PROCESSOR=`uname -p`
if test "$UNAME_PROCESSOR" = x86; then
UNAME_PROCESSOR=i386
UNAME_MACHINE=pc
fi
GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE
;;
*:QNX:*:4*)
GUESS=i386-pc-qnx
;;
NEO-*:NONSTOP_KERNEL:*:*)
GUESS=neo-tandem-nsk$UNAME_RELEASE
;;
NSE-*:NONSTOP_KERNEL:*:*)
GUESS=nse-tandem-nsk$UNAME_RELEASE
;;
NSR-*:NONSTOP_KERNEL:*:*)
GUESS=nsr-tandem-nsk$UNAME_RELEASE
;;
NSV-*:NONSTOP_KERNEL:*:*)
GUESS=nsv-tandem-nsk$UNAME_RELEASE
;;
NSX-*:NONSTOP_KERNEL:*:*)
GUESS=nsx-tandem-nsk$UNAME_RELEASE
;;
*:NonStop-UX:*:*)
GUESS=mips-compaq-nonstopux
;;
BS2000:POSIX*:*:*)
GUESS=bs2000-siemens-sysv
;;
DS/*:UNIX_System_V:*:*)
GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE
;;
*:Plan9:*:*)
# "uname -m" is not consistent, so use $cputype instead. 386
# is converted to i386 for consistency with other x86
# operating systems.
if test "${cputype-}" = 386; then
UNAME_MACHINE=i386
elif test "x${cputype-}" != x; then
UNAME_MACHINE=$cputype
fi
GUESS=$UNAME_MACHINE-unknown-plan9
;;
*:TOPS-10:*:*)
GUESS=pdp10-unknown-tops10
;;
*:TENEX:*:*)
GUESS=pdp10-unknown-tenex
;;
KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
GUESS=pdp10-dec-tops20
;;
XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
GUESS=pdp10-xkl-tops20
;;
*:TOPS-20:*:*)
GUESS=pdp10-unknown-tops20
;;
*:ITS:*:*)
GUESS=pdp10-unknown-its
;;
SEI:*:*:SEIUX)
GUESS=mips-sei-seiux$UNAME_RELEASE
;;
*:DragonFly:*:*)
DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'`
GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL
;;
*:*VMS:*:*)
UNAME_MACHINE=`(uname -p) 2>/dev/null`
case $UNAME_MACHINE in
A*) GUESS=alpha-dec-vms ;;
I*) GUESS=ia64-dec-vms ;;
V*) GUESS=vax-dec-vms ;;
esac ;;
*:XENIX:*:SysV)
GUESS=i386-pc-xenix
;;
i*86:skyos:*:*)
SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`
GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL
;;
i*86:rdos:*:*)
GUESS=$UNAME_MACHINE-pc-rdos
;;
i*86:Fiwix:*:*)
GUESS=$UNAME_MACHINE-pc-fiwix
;;
*:AROS:*:*)
GUESS=$UNAME_MACHINE-unknown-aros
;;
x86_64:VMkernel:*:*)
GUESS=$UNAME_MACHINE-unknown-esx
;;
amd64:Isilon\ OneFS:*:*)
GUESS=x86_64-unknown-onefs
;;
*:Unleashed:*:*)
GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE
;;
esac
# Do we have a guess based on uname results?
if test "x$GUESS" != x; then
echo "$GUESS"
exit
fi
# No uname command or uname output not recognized.
set_cc_for_build
cat > "$dummy.c" <
#include
#endif
#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
#if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
#include
#if defined(_SIZE_T_) || defined(SIGLOST)
#include
#endif
#endif
#endif
main ()
{
#if defined (sony)
#if defined (MIPSEB)
/* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed,
I don't know.... */
printf ("mips-sony-bsd\n"); exit (0);
#else
#include
printf ("m68k-sony-newsos%s\n",
#ifdef NEWSOS4
"4"
#else
""
#endif
); exit (0);
#endif
#endif
#if defined (NeXT)
#if !defined (__ARCHITECTURE__)
#define __ARCHITECTURE__ "m68k"
#endif
int version;
version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
if (version < 4)
printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
else
printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
exit (0);
#endif
#if defined (MULTIMAX) || defined (n16)
#if defined (UMAXV)
printf ("ns32k-encore-sysv\n"); exit (0);
#else
#if defined (CMU)
printf ("ns32k-encore-mach\n"); exit (0);
#else
printf ("ns32k-encore-bsd\n"); exit (0);
#endif
#endif
#endif
#if defined (__386BSD__)
printf ("i386-pc-bsd\n"); exit (0);
#endif
#if defined (sequent)
#if defined (i386)
printf ("i386-sequent-dynix\n"); exit (0);
#endif
#if defined (ns32000)
printf ("ns32k-sequent-dynix\n"); exit (0);
#endif
#endif
#if defined (_SEQUENT_)
struct utsname un;
uname(&un);
if (strncmp(un.version, "V2", 2) == 0) {
printf ("i386-sequent-ptx2\n"); exit (0);
}
if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
printf ("i386-sequent-ptx1\n"); exit (0);
}
printf ("i386-sequent-ptx\n"); exit (0);
#endif
#if defined (vax)
#if !defined (ultrix)
#include
#if defined (BSD)
#if BSD == 43
printf ("vax-dec-bsd4.3\n"); exit (0);
#else
#if BSD == 199006
printf ("vax-dec-bsd4.3reno\n"); exit (0);
#else
printf ("vax-dec-bsd\n"); exit (0);
#endif
#endif
#else
printf ("vax-dec-bsd\n"); exit (0);
#endif
#else
#if defined(_SIZE_T_) || defined(SIGLOST)
struct utsname un;
uname (&un);
printf ("vax-dec-ultrix%s\n", un.release); exit (0);
#else
printf ("vax-dec-ultrix\n"); exit (0);
#endif
#endif
#endif
#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__)
#if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__)
#if defined(_SIZE_T_) || defined(SIGLOST)
struct utsname *un;
uname (&un);
printf ("mips-dec-ultrix%s\n", un.release); exit (0);
#else
printf ("mips-dec-ultrix\n"); exit (0);
#endif
#endif
#endif
#if defined (alliant) && defined (i860)
printf ("i860-alliant-bsd\n"); exit (0);
#endif
exit (1);
}
EOF
$CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` &&
{ echo "$SYSTEM_NAME"; exit; }
# Apollos put the system type in the environment.
test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; }
echo "$0: unable to guess system type" >&2
case $UNAME_MACHINE:$UNAME_SYSTEM in
mips:Linux | mips64:Linux)
# If we got here on MIPS GNU/Linux, output extra information.
cat >&2 <&2 <&2 </dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
hostinfo = `(hostinfo) 2>/dev/null`
/bin/universe = `(/bin/universe) 2>/dev/null`
/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null`
/bin/arch = `(/bin/arch) 2>/dev/null`
/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
UNAME_MACHINE = "$UNAME_MACHINE"
UNAME_RELEASE = "$UNAME_RELEASE"
UNAME_SYSTEM = "$UNAME_SYSTEM"
UNAME_VERSION = "$UNAME_VERSION"
EOF
fi
exit 1
# Local variables:
# eval: (add-hook 'before-save-hook 'time-stamp)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End:
pgbouncer-1.24.1/requirements.txt 0000644 0001750 0000000 00000000147 14777762222 013775 0000000 0000000 pytest
pytest-asyncio
pytest-timeout
pytest-xdist
psycopg
filelock
contextlib2; python_version < "3.7"
pgbouncer-1.24.1/README.md 0000644 0001750 0000000 00000011655 14777762222 011776 0000000 0000000 PgBouncer
=========
Lightweight connection pooler for PostgreSQL.
Homepage:
Sources, bug tracking:
Building
---------
PgBouncer depends on few things to get compiled:
* [GNU Make] 3.81+
* [Libevent] 2.0+
* [pkg-config]
* [OpenSSL] 1.0.1+ for TLS support
* (optional) [c-ares] as alternative to Libevent's evdns
* (optional) PAM libraries
[GNU Make]: https://www.gnu.org/software/make/
[Libevent]: http://libevent.org/
[pkg-config]: https://www.freedesktop.org/wiki/Software/pkg-config/
[OpenSSL]: https://www.openssl.org/
[c-ares]: http://c-ares.haxx.se/
When dependencies are installed just run:
$ ./configure --prefix=/usr/local
$ make
$ make install
If you are building from Git, or are building for Windows, please see
separate build instructions below.
DNS lookup support
------------------
PgBouncer does host name lookups at connect time instead of just once
at configuration load time. This requires an asynchronous DNS
implementation. The following table shows supported backends and
their probing order:
| backend | parallel | EDNS0 (1) | /etc/hosts | SOA lookup (2) | note |
|----------------------------|----------|-----------|------------|----------------|---------------------------------------|
| c-ares | yes | yes | yes | yes | IPv6+CNAME buggy in <=1.10 |
| evdns, libevent 2.x | yes | no | yes | no | does not check /etc/hosts updates |
| getaddrinfo_a, glibc 2.9+ | yes | yes (3) | yes | no | N/A on non-glibc |
| getaddrinfo, libc | no | yes (3) | yes | no | requires pthreads |
1. EDNS0 is required to have more than 8 addresses behind one host name.
2. SOA lookup is needed to re-check host names on zone serial change.
3. To enable EDNS0, add `options edns0` to `/etc/resolv.conf`.
c-ares is the most fully-featured implementation and is recommended
for most uses and binary packaging (if a sufficiently new version is
available). Libevent's built-in evdns is also suitable for many uses,
with the listed restrictions. The other backends are mostly legacy
options at this point and don't receive much testing anymore.
By default, c-ares is used if it can be found. Its use can be forced
with `configure --with-cares` or disabled with `--without-cares`. If
c-ares is not used (not found or disabled), then Libevent is used. Specify
`--disable-evdns` to disable the use of Libevent's evdns and fall back to a
libc-based implementation.
PAM authentication
------------------
To enable PAM authentication, `./configure` has a flag `--with-pam`
(default value is no). When compiled with PAM support, a new global
authentication type `pam` is available to validate users through PAM.
systemd integration
-------------------
To enable systemd integration, use the `configure` option
`--with-systemd`. This allows using `Type=notify` (or `Type=notify-reload` if
you are using systemd 253 or later) as well as socket activation. See
`etc/pgbouncer.service` and `etc/pgbouncer.socket` for examples.
Building from Git
-----------------
Building PgBouncer from Git requires that you fetch the libusual and
uthash submodules and generate the header and configuration files before
you can run `configure`:
$ git clone https://github.com/pgbouncer/pgbouncer.git
$ cd pgbouncer
$ git submodule init
$ git submodule update
$ ./autogen.sh
$ ./configure
$ make
$ make install
All files will be installed under `/usr/local` by default. You can
supply one or more command-line options to `configure`. Run
`./configure --help` to list the available options and the environment
variables that customizes the configuration.
Additional packages required: autoconf, automake, libtool, pandoc
Testing
-------
See the [`README.md` file in the test directory][1] on how to run the tests.
[1]: https://github.com/pgbouncer/pgbouncer/blob/master/test/README.md
Building on Windows
-------------------
The only supported build environment on Windows is MinGW. Cygwin and
Visual $ANYTHING are not supported.
To build on MinGW, do the usual:
$ ./configure
$ make
If cross-compiling from Unix:
$ ./configure --host=i586-mingw32msvc
Running on Windows
------------------
Running from the command line goes as usual, except that the `-d` (daemonize),
`-R` (reboot), and `-u` (switch user) switches will not work.
To run PgBouncer as a Windows service, you need to configure the
`service_name` parameter to set a name for the service. Then:
$ pgbouncer -regservice config.ini
To uninstall the service:
$ pgbouncer -unregservice config.ini
To use the Windows event log, set `syslog = 1` in the configuration file.
But before that, you need to register `pgbevent.dll`:
$ regsvr32 pgbevent.dll
To unregister it, do:
$ regsvr32 /u pgbevent.dll
pgbouncer-1.24.1/test/ 0000755 0000000 0000000 00000000000 14777762567 011545 5 0000000 0000000 pgbouncer-1.24.1/test/ssl/ 0000755 0000000 0000000 00000000000 14777762567 012346 5 0000000 0000000 pgbouncer-1.24.1/test/ssl/test.ini 0000644 0001750 0000000 00000001327 14777762222 013752 0000000 0000000 [databases]
p0 = port=6666 host=localhost dbname=p0 user=bouncer pool_size=2
p1 = port=6666 host=localhost dbname=p1 user=bouncer
p7a= port=6666 host=localhost dbname=p7
pTxnPool = port=6666 host=127.0.0.1 dbname=p0 user=bouncer pool_mode=transaction
[pgbouncer]
logfile = test.log
pidfile = test.pid
listen_addr = 127.0.0.1
listen_port = 6667
unix_socket_dir = /tmp
auth_type = trust
auth_file = tmp/userlist.txt
pool_mode = statement
server_check_delay = 10
max_client_conn = 10
default_pool_size = 5
server_lifetime = 120
server_idle_timeout = 60
server_login_retry = 1
;; Accept even old TLS versions so that builds with older OpenSSL can
;; run the test suite.
client_tls_protocols = all
server_tls_protocols = all
pgbouncer-1.24.1/test/ssl/lib.sh 0000644 0001750 0000000 00000001476 14777762222 013401 0000000 0000000 #! /bin/sh
# PEM format
# req fields
# C = Country
# ST = State/Province
# L = Locality
# O = Organization
# OU = Org Unit
# CN = commonName
# ? = emailAddress
umask 077
run() {
echo '$' "$@"
"$@" 2>&1 | sed 's/^/ > /'
}
# key -> csr
run_req() {
tmp="csr.template"
args=""
while test "$1" != '--'; do
args="$args $1"
shift
done
shift
(
echo "[req]"
echo "prompt=no"
echo "distinguished_name=req_distinguished_name"
echo "[req_distinguished_name]"
for arg; do echo "$arg"; done
) > "$tmp"
run openssl req $args -config "$tmp"
rm -f csr.template
}
run_ca() {
ser=`cat ${CaName}/serial`
run openssl ca -batch -config "${CaName}/config.ini" "$@"
while test "$1" != '-out'; do
shift
done
if test "$1" = '-out'; then
cp "${CaName}/certs/$ser.pem" "$2"
fi
}
pgbouncer-1.24.1/test/ssl/newca.sh 0000755 0001750 0000000 00000002675 14777762222 013735 0000000 0000000 #! /bin/sh
# create new CA
set -e
test -n "$1" || {
echo "usage: $0 CaName [K=V]*"
exit 1
}
test -d "$1" && {
echo "CA '$1' already exists"
exit 1
}
name="$1"
shift
mkdir -p "$name"/certs
mkdir -p "$name"/sites
touch "$name"/index.txt
echo 01 > "$name"/serial
. ./lib.sh
days=10240
#run openssl genrsa -out "$name/ca.key" $ksize
run openssl ecparam -name prime256v1 -genkey -out "$name/ca.key"
# self-signed cert
# the -addext option is not required for old OpenSSL versions
openssl_version=`openssl version | awk '{print $2}'`
if expr "X$openssl_version" : 'X1.*.*' >/dev/null; then
run_req -new -x509 -days $days -key "$name/ca.key" -out "$name/ca.crt" -- "$@"
else
run_req -new -x509 -days $days -key "$name/ca.key" -out "$name/ca.crt" -addext basicConstraints=critical,CA:TRUE,pathlen:1 -- "$@"
fi
cat > "$name"/config.ini < "
exit 1
}
test -f "$1/ca.key" || {
echo "CA $1 does not exist"
exit 1
}
days=1024
. ./lib.sh
CaName="$1"
DstName="$2"
shift 2
ser=`cat $CaName/serial`
pfx=$CaName/sites/${ser}-$DstName
run openssl ecparam -genkey -name prime256v1 -out $pfx.key
# cert reqs
run_req -new -key "$pfx.key" -out "$pfx.csr" -- CN="$DstName" "$@"
# accept certs
run_ca -days $days -policy pol-server -in "$pfx.csr" -out "$pfx.crt"
pgbouncer-1.24.1/test/ssl/create_certs.sh 0000755 0001750 0000000 00000000666 14777762222 015301 0000000 0000000 #! /bin/sh
set -e
rm -rf TestCA1 TestCA2
./newca.sh TestCA1 C=QQ O=Org1 CN="TestCA1"
./newsite.sh TestCA1 localhost C=QQ O=Org1 L=computer OU=db
./newsite.sh TestCA1 bouncer C=QQ O=Org1 L=computer OU=Dev
./newsite.sh TestCA1 random C=QQ O=Org1 L=computer OU=Dev
./newsite.sh TestCA1 pgbouncer.acme.org C=QQ O=Org1 L=computer OU=Dev
./newca.sh TestCA2 C=QQ O=Org2 CN="TestCA2"
./newsite.sh TestCA2 localhost C=QQ O=Org1 L=computer OU=db
pgbouncer-1.24.1/test/ssl/Makefile 0000644 0001750 0000000 00000000257 14777762222 013733 0000000 0000000 EXTRA_DIST = lib.sh newca.sh newsite.sh create_certs.sh test.ini Makefile
SUBLOC = test/ssl
include ../../config.mak
include ../../lib/mk/antimake.mk
check: all
./test.sh
pgbouncer-1.24.1/test/test.ini 0000644 0001750 0000000 00000010612 14777762222 013146 0000000 0000000 [databases]
p0 = port=6666 host=127.0.0.1 dbname=p0 user=bouncer pool_size=2 reserve_pool_size=2
p0a= port=6666 host=127.0.0.1 dbname=p0 pool_size=2 reserve_pool=2
p0x= port=6666 host=127.0.0.1 dbname=p0 min_pool_size=5 pool_size=5
p0y= port=6666 host=127.0.0.1 dbname=p0 min_pool_size=5 pool_size=5 max_db_connections=2
; for testing 'min_pool_size' with forced user
;p0z= port=6666 host=127.0.0.1 dbname=p0 min_pool_size=3 user=pswcheck
p1 = port=6666 host=127.0.0.1 dbname=p1 user=bouncer
p2 = port=6666 host=127.0.0.1 dbname=p0 max_db_connections=4
p3 = port=6666 host=127.0.0.1 dbname=p0 user=bouncer pool_mode=session
p4 = port=6666 host=127.0.0.1 dbname=p4 user=puser1 password=foo
p4x= port=6666 host=127.0.0.1 dbname=p4 user=puser1 password=wrong
p4y= port=6666 host=127.0.0.1 dbname=p4 user=puser1
p4z= port=6666 host=127.0.0.1 dbname=p4 user=puser2
p4l= port=6666 host=127.0.0.1 dbname=p4 user=longpass
p5 = port=6666 host=127.0.0.1 dbname=p5 user=muser1 password=foo
p5x= port=6666 host=127.0.0.1 dbname=p5 user=muser1 password=wrong
p5y= port=6666 host=127.0.0.1 dbname=p5 user=muser1
p5z= port=6666 host=127.0.0.1 dbname=p5 user=muser2
p6 = port=6666 host=127.0.0.1 dbname=p6 user=scramuser1 password=foo
p6x= port=6666 host=127.0.0.1 dbname=p6 user=scramuser1 password=wrong
p6y= port=6666 host=127.0.0.1 dbname=p6 user=scramuser1
p6z= port=6666 host=127.0.0.1 dbname=p6 user=scramuser2
p61= port=6666 host=127.0.0.1 dbname=p6 user=scramuser3
p62= port=6666 host=127.0.0.1 dbname=p6
p7a= port=6666 host=127.0.0.1 dbname=p7
p7b= port=6666 host=127.0.0.1 dbname=p7
p7c= port=6666 host=127.0.0.1 dbname=p7
p8 = port=6666 host=127.0.0.1 dbname=p0 connect_query='set enable_seqscan=off; set enable_nestloop=off'
p9 = port=6666 host=127.0.0.1 dbname=postgres server_lifetime=2 user=bouncer
user_passthrough = port=6666 host=127.0.0.1 dbname=p0
user_passthrough2 = port=6666 host=127.0.0.1 dbname=p2
user_passthrough_pool_size2 = port=6666 host=127.0.0.1 dbname=p0 pool_size=2
user_passthrough_pool_size5 = port=6666 host=127.0.0.1 dbname=p0 pool_size=2
pauthz = port=6666 host=127.0.0.1 dbname=p7 auth_user=pswcheck auth_dbname=authdb
authdb = port=6666 host=127.0.0.1 dbname=p1 auth_user=pswcheck
hostlist1 = port=6666 host=127.0.0.1,::1 dbname=p0 user=bouncer
hostlist2 = port=6666 host=127.0.0.1,127.0.0.1 dbname=p0 user=bouncer
hostlist_good_first = port=6666 host=127.0.0.1,127.0.0.3 dbname=p0 user=bouncer load_balance_hosts=disable
hostlist_bad_first = port=6666 host=unresolvable-hostname,127.0.0.1 dbname=p0 user=bouncer load_balance_hosts=disable
load_balance_hosts_update = port=6666 host=127.0.0.1,127.0.0.3 dbname=p0 user=bouncer load_balance_hosts=disable
varcache_change = port=6666 host=127.0.0.1 dbname=p0 client_encoding=SQL_ASCII
non_existing_pg_db = port=6666 host=127.0.0.1 dbname=non_existing_pg_db
conn_limit_db = port=6666 host=127.0.0.1 dbname=p0 max_db_client_connections=2
; Needed for pg_receivewal and pg_basebackup tests until this patch is merged
; in PostgreSQL (and we don't support PG16 anymore):
; https://www.postgresql.org/message-id/flat/CAGECzQTw-dZkVT_RELRzfWRzY714-VaTjoBATYfZq93R8C-auA@mail.gmail.com
replication = port=6666 host=127.0.0.1 dbname=replication
client_limit_db= port=6666 host=127.0.0.1 dbname=p0 max_db_client_connections=2
client_limit_db_auth_passthrough = port=6666 host=127.0.0.1 dbname=p0 auth_user=pswcheck max_db_client_connections=2
; commented out except for auto-database tests
;* = port=6666 host=127.0.0.1
[users]
maxedout = max_user_connections=3
maxedout2 = max_user_connections=2 max_user_client_connections=2
maxedout3 = max_user_client_connections=2
poolsize1 = pool_size=1
respoolsize1 = pool_size=1 reserve_pool_size=2
pswcheck_not_in_auth_file = max_user_client_connections=2
[pgbouncer]
logfile = test.log
pidfile = test.pid
listen_addr = 127.0.0.1
listen_port = 6667
unix_socket_dir = /tmp
auth_type = trust
auth_file = userlist.txt
pool_mode = statement
server_check_delay = 10
max_client_conn = 10
default_pool_size = 5
server_lifetime = 120
server_idle_timeout = 60
tcp_defer_accept = 0
tcp_keepalive = 0
; use a small tcp_socket_buffer so that we trigger EAGAIN more often in tests.
; Otherwise bugs caused by EAGAIN are hard to debug.
tcp_socket_buffer = 4096
;track_extra_parameters is case sensitive.
;bgbouncer will only track the parameters with GUC_REPORT flag set in Postgres
track_extra_parameters = search_path, intervalstyle
ignore_startup_parameters = extra_float_digits
pgbouncer-1.24.1/test/test_auth.py 0000644 0001750 0000000 00000114513 14777762222 014045 0000000 0000000 import getpass
import re
import subprocess
import time
import psycopg
import pytest
from .utils import (
FREEBSD,
LONG_PASSWORD,
MACOS,
PG_SUPPORTS_SCRAM,
TLS_SUPPORT,
WINDOWS,
)
@pytest.fixture
def test_message_fixture(bouncer, pg):
yield bouncer, pg
pg.sql("ALTER USER test_error_message_user WITH LOGIN;")
@pytest.mark.skipif("FREEBSD", reason="FreeBSD error reporting broken")
@pytest.mark.skipif("WINDOWS", reason="Windows error reporting broken")
def test_message(test_message_fixture):
bouncer, pg = test_message_fixture
test_user = "test_error_message_user"
connection_params = {"user": test_user, "dbname": "p0a"}
# Connect to database as User, creates existing pool
_ = bouncer.conn(**connection_params)
# Change user to nologin
pg.sql(f"ALTER USER {test_user} WITH NOLOGIN;")
# Kill process on postgres
terminate_string = f"""
SELECT pg_terminate_backend(pid)
FROM pg_stat_activity
WHERE
pid <> pg_backend_pid()
AND usename = '{test_user}'
"""
pg.sql(terminate_string)
# login, check error message
# login again, check error message
for _ in range(2):
with pytest.raises(
psycopg.OperationalError, match=r"is not permitted to log in"
):
bouncer.test(**connection_params)
@pytest.mark.md5
def test_auth_user(pg, bouncer):
bouncer.default_db = "authdb"
bouncer.admin(f"set auth_type='md5'")
bouncer.test(user="someuser", password="anypasswd")
with pytest.raises(psycopg.OperationalError, match="no such user"):
bouncer.test(user="nouser", password="anypasswd")
with pytest.raises(
psycopg.OperationalError, match="(SASL|password) authentication failed"
):
bouncer.test(user="someuser", password="badpasswd")
pg.sql("ALTER USER someuser VALID UNTIL '1999-01-01'")
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(user="someuser", password="anypasswd")
pg.sql("ALTER USER someuser VALID UNTIL 'infinity'")
bouncer.test(user="someuser", password="anypasswd")
@pytest.mark.md5
def test_auth_dbname_global(bouncer):
bouncer.admin(f"set auth_dbname='authdb'")
bouncer.admin(f"set auth_user='pswcheck'")
bouncer.admin(f"set auth_type='md5'")
bouncer.test(dbname="p7a", user="someuser", password="anypasswd")
bouncer.test(dbname="p7a", user="pswcheck", password="pgbouncer-check")
@pytest.mark.md5
def test_auth_dbname_global_invalid(bouncer):
bouncer.admin(f"set auth_dbname='p_unconfigured_auth_dbname'")
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(
'authentication database "p_unconfigured_auth_dbname" is not configured'
):
with pytest.raises(psycopg.OperationalError, match="bouncer config error"):
bouncer.test(dbname="authdb", user="someuser", password="anypasswd")
# test if auth_dbname specified in connection string takes precedence over
# global setting. This automatically tests that the local logic works.
bouncer.test(dbname="pauthz", user="someuser", password="anypasswd")
def test_auth_dbname_disabled(bouncer):
bouncer.admin("disable authdb")
bouncer.admin(f"set auth_type='md5'")
with pytest.raises(
psycopg.OperationalError, match='authentication database "authdb" is disabled'
):
bouncer.test(dbname="pauthz", user="someuser", password="anypasswd")
@pytest.mark.md5
def test_auth_dbname_with_auto_database(bouncer):
with bouncer.ini_path.open() as f:
original = f.read()
with bouncer.ini_path.open("w") as f:
# uncomment the auto-database line and add auth_dbname to it
new = re.sub(
r"^;\* = ", "* = auth_dbname=authdb ", original, flags=re.MULTILINE
)
print(new)
f.write(new)
bouncer.admin("reload")
bouncer.admin("set verbose=2")
bouncer.admin("set auth_user='pswcheck'")
bouncer.admin(f"set auth_type='md5'")
# postgres is not defined in test.ini
bouncer.test(dbname="postgres", user="someuser", password="anypasswd")
bouncer.test(dbname="postgres", user="pswcheck", password="pgbouncer-check")
@pytest.mark.md5
def test_unconfigured_auth_database_with_auto_database(bouncer):
"""
Tests the scenario where the authentication database does not
have a connection string configured under [databases] section.
However, there is an auto-datatabase, '*', configured. The expectation
is to use the wild card connection string for the auth_database.
"""
with bouncer.ini_path.open() as f:
original = f.read()
assert (
re.search(r"^unconfigured_auth_database", original, flags=re.MULTILINE)
is None
)
with bouncer.ini_path.open("w") as f:
# uncomment the auto-database line
new = re.sub(r"^;\* = ", "* = ", original, flags=re.MULTILINE)
print(new)
f.write(new)
# configure the auth_dbname to a database that is not configured
# expected behavior is to fallback to auto-database and auto-register.
bouncer.admin("set auth_dbname=unconfigured_auth_database")
bouncer.admin("reload")
bouncer.admin("set auth_user='pswcheck'")
bouncer.admin(f"set auth_type='md5'")
# test a database that does not exist on the server, it should fail.
# but this error will only surface when we attempt to make the connection to client's
# database. Hence, we can conclude that we were able to look up the password using
# auth_dbname
with pytest.raises(
psycopg.OperationalError,
match='database "this_database_doesnt_exist" does not exist',
):
bouncer.test(dbname="this_database_doesnt_exist", user="muser1", password="foo")
# do a final sanity check that we can connect.
bouncer.test(user="muser1", password="foo")
def run_server_auth_test(bouncer, dbname):
bouncer.admin(f"set auth_type='trust'")
# good password from ini
bouncer.test(dbname=dbname)
# bad password from ini
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname=f"{dbname}x")
# good password from auth_file
bouncer.test(dbname=f"{dbname}y")
# bad password from auth_file
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname=f"{dbname}z")
# Test plain-text password authentication from PgBouncer to PostgreSQL server
#
# The PostgreSQL server no longer supports storing plain-text
# passwords, so the server-side user actually uses md5 passwords in
# this test case, but the communication is still in plain text.
def test_password_server(bouncer):
run_server_auth_test(bouncer, "p4")
# long password from auth_file
bouncer.test(dbname="p4l")
@pytest.mark.md5
def test_md5_server(bouncer):
run_server_auth_test(bouncer, "p5")
@pytest.mark.skipif("not PG_SUPPORTS_SCRAM")
def test_scram_server(bouncer):
# good password from ini
bouncer.test(dbname="p6")
# bad password from ini
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname="p6x")
# good password from auth_file, but it is not supported with SCRAM
with pytest.raises(psycopg.OperationalError, match="wrong password type"):
bouncer.test(dbname="p6y")
# bad password from auth_file
with pytest.raises(psycopg.OperationalError, match="wrong password type"):
bouncer.test(dbname="p6z")
@pytest.mark.md5
def connect_with_password_client_users(bouncer):
# good password
bouncer.test(user="puser1", password="foo")
# bad password
with pytest.raises(
psycopg.OperationalError, match="(password|SASL) authentication failed"
):
bouncer.test(user="puser1", password="wrong")
def connect_with_md5_client_users(bouncer):
# good password
bouncer.test(user="muser1", password="foo")
# bad password
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(user="muser1", password="wrong")
def connect_with_scram_client_users(bouncer):
# users with a stored SCRAM password
bouncer.test(user="scramuser1", password="foo")
# bad password
with pytest.raises(
psycopg.OperationalError, match="(password|SASL) authentication failed"
):
bouncer.test(user="scramuser1", password="wrong")
# Test plain-text password authentication from client to PgBouncer
@pytest.mark.md5
def test_password_client(bouncer):
bouncer.admin(f"set auth_type='plain'")
connect_with_password_client_users(bouncer)
connect_with_md5_client_users(bouncer)
connect_with_scram_client_users(bouncer)
# long password
bouncer.test(user="longpass", password=LONG_PASSWORD)
# too long password
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(user="longpass", password="X" + LONG_PASSWORD)
@pytest.mark.md5
def test_md5_client(bouncer):
bouncer.admin(f"set auth_type='md5'")
connect_with_password_client_users(bouncer)
connect_with_md5_client_users(bouncer)
connect_with_scram_client_users(bouncer)
def test_scram_client(bouncer):
bouncer.admin(f"set auth_type='scram-sha-256'")
connect_with_password_client_users(bouncer)
connect_with_scram_client_users(bouncer)
# cannot authenticate to MD5 stored passwords with SCRAM auth
# good password
with pytest.raises(
psycopg.OperationalError, match="(password|SASL) authentication failed"
):
bouncer.test(user="muser1", password="foo")
# bad password
with pytest.raises(
psycopg.OperationalError, match="(password|SASL) authentication failed"
):
bouncer.test(user="muser1", password="wrong")
@pytest.mark.skipif("not PG_SUPPORTS_SCRAM")
def test_scram_both(bouncer):
bouncer.admin(f"set auth_type='scram-sha-256'")
# plain-text password in userlist.txt
bouncer.test(dbname="p61", user="scramuser3", password="baz")
# SCRAM password in userlist.txt
bouncer.test(dbname="p62", user="scramuser1", password="foo")
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
def test_auth_dbname_usage(
bouncer,
):
"""
Check that the pgbouncer handles correctly the reserved pgbouncer
database usage as an authentication database
"""
config = f"""
[databases]
pgbouncer_test = host={bouncer.pg.host} port={bouncer.pg.port} auth_dbname=pgbouncer
* = host={bouncer.host} port={bouncer.port} auth_dbname=pgbouncer
[pgbouncer]
auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pswcheck
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
"""
# We expect that stats user does not exist in userlist.txt
with bouncer.log_contains(
'cannot use the reserved "pgbouncer" database as an auth_dbname', 3
):
with bouncer.run_with_config(config):
# Check the pgbouncer does not crash when we connect to pgbouncer admin db
with pytest.raises(psycopg.OperationalError, match="bouncer config error"):
bouncer.sql(
query="show stats",
user="stats",
password="stats",
dbname="pgbouncer",
)
# Check the pgbouncer does not crash when explicitly pgbouncer database
# (admin DB) was set in auth_dbname in the databases definition section
with pytest.raises(psycopg.OperationalError, match="bouncer config error"):
bouncer.sql(
query="show stats",
user="stats",
password="stats",
dbname="pgbouncer_test",
)
# Check the pgbouncer does not crash when explicitly pgbouncer database
# (admin DB) was set in auth_dbname in the autodb definition
with pytest.raises(psycopg.OperationalError, match="bouncer config error"):
bouncer.sql(
query="show stats", user="stats", password="stats", dbname="p4"
)
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
def test_auth_dbname_usage_global_setting(
bouncer,
):
"""
Check that the pgbouncer does not apply config which contains
explicitly "pgbouncer" database (admin DB) set in [pgbouncer] section
"""
config = f"""
[databases]
* = host={bouncer.host} port={bouncer.port}
[pgbouncer]
auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pswcheck
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = pgbouncer
"""
with bouncer.log_contains(
'cannot use the reserved "pgbouncer" database as an auth_dbname', 1
):
with bouncer.run_with_config(config):
pass
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
def test_auth_query_database_setting(
bouncer,
):
"""
Check the pgbouncer can use auth_query in database section to get password
"""
config = f"""
[databases]
postgres = auth_query='SELECT usename, passwd FROM pg_shadow where usename = $1'\
host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
auth_query = SELECT 1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
"""
with bouncer.run_with_config(config):
with bouncer.run_with_config(config):
bouncer.sql(
query="select version()",
user="stats",
password="stats",
dbname="postgres",
)
config = f"""
[databases]
postgres = auth_query='SELECT usename, substring(passwd,1,3) FROM pg_shadow where usename = $1'\
host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
"""
with bouncer.run_with_config(config):
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
with bouncer.run_with_config(config):
bouncer.sql(
query="select version()",
user="stats",
password="stats",
dbname="postgres",
)
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
def test_auth_query_works_with_configured_users(bouncer):
"""
Check that when a user is configured with per-user options, but missing from auth_file
pgBouncer will still attempt to valididate passwords if auth_query is configured.
"""
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
pool_mode = session
[users]
puser1 = pool_mode=statement
"""
# As a sanity check, make sure that a user with a password in auth_file cannot run transactions
# while configured to be in statement pooling mode
with bouncer.run_with_config(config):
with pytest.raises(psycopg.OperationalError):
with bouncer.log_contains(
"closing because: transaction blocks not allowed in statement pooling mode"
):
bouncer.sql(
query="begin",
user="puser1",
password="foo",
dbname="postgres",
)
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
pool_mode = session
[users]
stats = pool_mode=statement
"""
# While pgbouncer is set to use session mode by default, the stats user
# is set to use statement pooling. pgBouncer should fail to allow a begin
# statement while in statement pooling mode, but still be able to authenticate
# using auth_query.
with bouncer.run_with_config(config):
with pytest.raises(psycopg.OperationalError):
with bouncer.log_contains(
"closing because: transaction blocks not allowed in statement pooling mode"
):
bouncer.sql(
query="begin",
user="stats",
password="stats",
dbname="postgres",
)
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
def test_auth_query_logs_server_error(
bouncer,
):
"""
Check that when the auth_query response has an error, pgbouncer logs
the error message provided by postgres.
"""
config = f"""
[databases]
postgres = auth_query='SELECT usename, passwd FROM not_pg_shadow where usename = $1'\
host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
auth_query = SELECT 1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
"""
with bouncer.log_contains('"not_pg_shadow" does not exist'):
with bouncer.run_with_config(config):
with pytest.raises(psycopg.OperationalError, match="bouncer config error"):
bouncer.sql(
query="select version()",
user="stats",
password="stats",
dbname="postgres",
)
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
@pytest.mark.md5
def test_auth_dbname_works_fine(
bouncer,
):
"""
Check that we handle correctly all positive cases of auth_dbname usage
"""
config = f"""
[databases]
postgres_authdb1 = host={bouncer.pg.host} port={bouncer.pg.port} dbname=postgres auth_dbname=postgres
postgres_authdb2 = host={bouncer.pg.host} port={bouncer.pg.port} dbname=postgres auth_dbname=postgres
pgbouncer2pgbpouncer = host={bouncer.host} port={bouncer.port} dbname=pgbouncer auth_dbname=postgres_authdb2
pgbouncer2pgbpouncer_global = host={bouncer.host} port={bouncer.port} dbname=pgbouncer
postgres_test = host={bouncer.host} port={bouncer.port}
* = host={bouncer.pg.host} port={bouncer.pg.port} auth_dbname=postgres
[pgbouncer]
auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1
auth_user = pswcheck
stats_users = stats
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = md5
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres_authdb1
"""
with bouncer.run_with_config(config):
# The client connects to pgbouncer (admin DB) using userlist.txt file match
bouncer.sql(
query="show stats", user="pgbouncer", password="fake", dbname="pgbouncer"
)
# The client connects to pgbouncer (admin DB) using auth_query, pgbouncer must
# use postgres_authdb1 as an auth DB, that defined in [pgbouncer] section
bouncer.sql(
query="show stats", user="stats", password="stats", dbname="pgbouncer"
)
# The client connects to pgbouncer2pgbpouncer DB which redirects
# to pgbouncer (admin DB) itself, pgbouncer must use postgres_authdb2, which
# is defined in the database definition
bouncer.sql(
query="show stats",
user="stats",
password="stats",
dbname="pgbouncer2pgbpouncer",
)
# The client connects to pgbouncer2pgbpouncer_global DB which redirects
# to pgbouncer (admin DB) itself, pgbouncer must use postgres_authdb1, which
# is defined in [pgbouncer] section
bouncer.sql(
query="show stats",
user="stats",
password="stats",
dbname="pgbouncer2pgbpouncer_global",
)
# The client connects to admin DB directly
# pgbouncer must use postgres_authdb1, which is defined in [pgbouncer] section
bouncer.sql(
query="show stats", user="stats", password="stats", dbname="pgbouncer"
)
# The client connects to postgres DB that matches with autodb
# pgbouncer must use postgres_authdb1, which is defined in [pgbouncer] section
bouncer.test(user="stats", password="stats", dbname="postgres")
def test_hba_leak(bouncer):
"""
Don't actually check if HBA auth works, but check that it doesn't leak
memory when using the feature.
"""
bouncer.write_ini(f"auth_type = hba")
bouncer.write_ini(f"auth_hba_file = hba_test.rules")
bouncer.admin("reload")
bouncer.write_ini(f"auth_type = trust")
bouncer.admin("reload")
bouncer.write_ini(f"auth_type = hba")
bouncer.admin("reload")
bouncer.admin("reload")
async def test_change_server_password_reconnect(bouncer, pg):
bouncer.default_db = "p4"
bouncer.admin(f"set default_pool_size=1")
bouncer.admin(f"set pool_mode=transaction")
try:
# good password, opens connection
bouncer.test()
pg.sql("ALTER USER puser1 PASSWORD 'bar'")
# works fine because server connection is still open
bouncer.test()
with bouncer.transaction() as cur1:
# Claim the connection
cur1.execute("select 1")
# Because of our fast client closure on server auth failures (see
# kill_pool_logins), we should only have one connection failing at
# the postgres side. But we should still have 3 failing at the
# pgbouncer side.
with pg.log_contains(
r"password authentication failed", times=1
), bouncer.log_contains(
r"closing because: password authentication failed for user", times=4
):
result1 = bouncer.atest()
result2 = bouncer.atest()
result3 = bouncer.atest()
# Mark the old connection as dirty
bouncer.admin("reconnect")
# Trigger new connection creation
bouncer.admin(f"set default_pool_size=2")
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
await result1
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
await result2
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
await result3
time.sleep(3)
finally:
pg.sql("ALTER USER puser1 PASSWORD 'foo'")
async def test_change_server_password_server_lifetime(bouncer, pg):
bouncer.default_db = "p4"
bouncer.admin(f"set default_pool_size=1")
bouncer.admin(f"set pool_mode=transaction")
bouncer.admin(f"set server_lifetime=1")
try:
# good password, opens connection
bouncer.test()
pg.sql("ALTER USER puser1 PASSWORD 'bar'")
# wait until server disconnect
time.sleep(3)
# Because of our fast client closure on server auth failures (see
# kill_pool_logins), we should only have one connection failing at
# the postgres side. But we should still have 3 failing at the
# pgbouncer side.
with pg.log_contains(
r"password authentication failed", times=1
), bouncer.log_contains(
r"closing because: password authentication failed for user", times=4
):
result1 = bouncer.atest()
result2 = bouncer.atest()
result3 = bouncer.atest()
with pytest.raises(psycopg.OperationalError):
await result1
with pytest.raises(psycopg.OperationalError):
await result2
with pytest.raises(psycopg.OperationalError):
await result3
time.sleep(3)
finally:
pg.sql("ALTER USER puser1 PASSWORD 'foo'")
@pytest.mark.skipif("MACOS", reason="SSL tests are broken on OSX in CI #1031")
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
@pytest.mark.skipif(not TLS_SUPPORT, reason="pgbouncer is built without TLS support")
def test_client_hba_cert(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = require")
bouncer.write_ini(f"auth_type = hba")
bouncer.write_ini(
f"auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1"
)
bouncer.write_ini(f"auth_user = pswcheck")
bouncer.write_ini(f"auth_file = {bouncer.auth_path}")
bouncer.write_ini(f"auth_hba_file = pgbouncer_hba.conf")
bouncer.write_ini(f"auth_ident_file = pgident.conf")
bouncer.admin("reload")
client_key = cert_dir / "TestCA1" / "sites" / "04-pgbouncer.acme.org.key"
client_cert = cert_dir / "TestCA1" / "sites" / "04-pgbouncer.acme.org.crt"
# The client connects to p0x using a client certificate with CN=pgbouncer.acme.org.
# hba_eval returns the following line:
# hostssl p0x all 0.0.0.0/0 cert map=test
# where "test" map is defined in pgident.conf as
# test pgbouncer.acme.org someuser
# test pgbouncer.acme.org anotheruser
# hence the test succeeds.
bouncer.psql_test(
dbname="p0x",
host="localhost",
user="someuser",
sslmode="verify-full",
sslkey=client_key,
sslcert=client_cert,
sslrootcert=root,
)
bouncer.pg.sql("create user anotheruser with login;")
# The client connects to p0x using a client certificate with CN=pgbouncer.acme.org.
# hba_eval returns the following line:
# hostssl p0x all 0.0.0.0/0 cert map=test
# where "test" map is defined in pgident.conf as
# test pgbouncer.acme.org someuser
# test pgbouncer.acme.org anotheruser
# hence the test succeeds.
bouncer.psql_test(
dbname="p0x",
host="localhost",
user="anotheruser",
sslmode="verify-full",
sslkey=client_key,
sslcert=client_cert,
sslrootcert=root,
)
# The client connects to p0x using a client certificate with CN=pgbouncer.acme.org.
# hba_eval returns the following line:
# hostssl p0x all 0.0.0.0/0 cert map=test
# where "test" map is defined in pgident.conf as
# test pgbouncer.acme.org someuser
# test pgbouncer.acme.org anotheruser
# the username 'bouncer' does not match any mapped pg-username.
# hence the test fails.
with pytest.raises(
subprocess.CalledProcessError,
):
with bouncer.log_contains(
"p0x/bouncer@127.0.0.1:43544 ident map: test does not have a match"
):
bouncer.psql_test(
dbname="p0x",
host="localhost",
user="bouncer",
sslmode="verify-full",
sslkey=client_key,
sslcert=client_cert,
sslrootcert=root,
)
client_key = cert_dir / "TestCA1" / "sites" / "02-bouncer.key"
client_cert = cert_dir / "TestCA1" / "sites" / "02-bouncer.crt"
# The client connects to p0 using a client certificate with CN=bouncer.
# hba_eval returns the following line:
# hostssl p0 bouncer 0.0.0.0/0 cert
# CN expected in map is "bouncer" which matches the CN in the client cert
# hence the test succeeds.
bouncer.psql_test(
dbname="p0",
host="localhost",
user="bouncer",
sslmode="verify-full",
sslkey=client_key,
sslcert=client_cert,
sslrootcert=root,
)
# The client connects to p0y using a client certificate with CN=bouncer.
# hba_eval returns the following line:
# hostssl p0y all 0.0.0.0/0 cert map=test2
# where
# test2 bouncer all
# test2 pgbouncer.acme.org "anotheruser"
# test2 mapping allows any client with CN="bouncer" to connect using any user name.
# Hence the test succeeds.
bouncer.psql_test(
dbname="p0y",
host="localhost",
user="someuser",
sslmode="verify-full",
sslkey=client_key,
sslcert=client_cert,
sslrootcert=root,
)
client_key = cert_dir / "TestCA1" / "sites" / "04-pgbouncer.acme.org.key"
client_cert = cert_dir / "TestCA1" / "sites" / "04-pgbouncer.acme.org.crt"
# The client connects to p0y using a client certificate with CN=pgbouncer.acme.org.
# hba_eval returns the following line:
# hostssl p0y all 0.0.0.0/0 cert map=test2
# where
# test2 bouncer all
# test2 pgbouncer.acme.org "anotheruser"
# for CN=pgbouncer.acme.org, test2 allows to use anotheruser. Hence the test fails.
with pytest.raises(
subprocess.CalledProcessError,
):
with bouncer.log_contains(
"p0y/someuser@127.0.0.1:39712 ident map: test2 does not have a match"
):
bouncer.psql_test(
dbname="p0y",
host="localhost",
user="someuser",
sslmode="verify-full",
sslkey=client_key,
sslcert=client_cert,
sslrootcert=root,
)
# The client connects to p0y using a client certificate with CN=pgbouncer.acme.org.
# hba_eval returns the following line:
# hostssl p0y all 0.0.0.0/0 cert map=test2
# where
# test2 bouncer all
# test2 pgbouncer.acme.org "anotheruser"
# for CN=pgbouncer.acme.org, test2 allows to use anotheruser. Hence the test succeeds.
bouncer.psql_test(
dbname="p0y",
host="localhost",
user="anotheruser",
sslmode="verify-full",
sslkey=client_key,
sslcert=client_cert,
sslrootcert=root,
)
@pytest.mark.skipif("WINDOWS", reason="Windows does not have peer authentication")
def test_peer_auth_ident_map(bouncer):
cur_user = getpass.getuser()
ident_conf_file = bouncer.config_dir / "ident.conf"
hba_conf_file = bouncer.config_dir / "hba.conf"
with open(ident_conf_file, "w") as f:
f.write(f"mymap {cur_user} postgres\n")
f.write(f"mymap {cur_user} someuser\n")
with open(hba_conf_file, "w") as f:
f.write(f"local all all peer map=mymap")
bouncer.write_ini(f"auth_type = hba")
bouncer.write_ini(
f"auth_query = SELECT usename, passwd FROM pg_shadow where usename = $1"
)
bouncer.write_ini(f"auth_user = pswcheck")
bouncer.write_ini(f"auth_file = {bouncer.auth_path}")
bouncer.write_ini(f"auth_hba_file = {hba_conf_file}")
bouncer.write_ini(f"auth_ident_file = {ident_conf_file}")
bouncer.admin("reload")
bouncer.psql_test(
dbname="p0y",
host=f"{bouncer.admin_host}",
user="postgres",
)
bouncer.psql_test(
dbname="p0y",
host=f"{bouncer.admin_host}",
user="someuser",
)
with pytest.raises(
subprocess.CalledProcessError,
):
with bouncer.log_contains(
"p0y/bouncer@unix(6202):10202 ident map mymap cannot be matched"
):
bouncer.psql_test(
dbname="p0y",
host=f"{bouncer.admin_host}",
user="bouncer",
)
with open(ident_conf_file, "w") as f:
f.write(f"mymap {cur_user} all")
bouncer.admin("reload")
bouncer.psql_test(
dbname="p0",
host=f"{bouncer.admin_host}",
user="bouncer",
)
async def test_auth_user_trust_auth_without_auth_file_set(bouncer) -> None:
"""
This is a regression test for issue #1116, using the SET command
"""
bouncer.admin("set auth_user='pswcheck_not_in_auth_file'")
bouncer.admin("set auth_type='trust'")
with bouncer.conn(
dbname="p7a",
user="pswcheck_not_in_auth_file",
) as cn:
with cn.cursor() as cur:
cur.execute("select 1")
def test_auth_user_trust_auth_without_auth_file_reload(bouncer) -> None:
"""
This is a regression test for issue #1116, using the RELOAD command
"""
config = f"""
[databases]
postgres = host={bouncer.pg.host} dbname=postgres port={bouncer.pg.port} min_pool_size=2
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
auth_user = pswcheck_not_in_auth_file
auth_dbname = postgres
admin_users = pgbouncer
logfile = {bouncer.log_path}
auth_file = {bouncer.auth_path}
"""
with bouncer.run_with_config(config):
with bouncer.conn(
dbname="postgres",
user="postgres",
) as cn:
with cn.cursor() as cur:
cur.execute("select 1")
def test_auth_user_at_db_level_trust_auth_without_auth_file_reload(bouncer) -> None:
"""
This is a regression test for issue #1116, when auth_user was set at the
database level
"""
config = f"""
[databases]
postgres = host={bouncer.pg.host} dbname=postgres port={bouncer.pg.port} min_pool_size=2 auth_user=pswcheck_not_in_auth_file
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
auth_dbname = postgres
admin_users = pgbouncer
logfile = {bouncer.log_path}
auth_file = {bouncer.auth_path}
"""
with bouncer.run_with_config(config):
with bouncer.conn(
dbname="postgres",
user="pswcheck_not_in_auth_file",
) as cn:
with cn.cursor() as cur:
cur.execute("select 1")
def test_auth_user_with_same_forced_user(bouncer):
"""
Check that the pgbouncer correctly handles multiple credentials with the
same name with a global auth_user (isue #1103).
"""
config = f"""
[databases]
* = host={bouncer.pg.host} port={bouncer.pg.port} user=postgres min_pool_size=2
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
auth_user = postgres
auth_dbname = postgres
admin_users = pgbouncer
logfile = {bouncer.log_path}
auth_file = {bouncer.auth_path}
"""
with bouncer.run_with_config(config):
# Let's get an error "no such user"
with pytest.raises(psycopg.OperationalError, match="no such user"):
bouncer.conn(dbname="dummydb2", user="dummyuser2", password="dummypswd2")
# Let's wait a few seconds for the janitor to kick in and crash pgbouncer
time.sleep(2)
# Now we will try to connect with OK parameters
with bouncer.conn(dbname="p3", user="postgres", password="asdasd") as cn:
with cn.cursor() as cur:
cur.execute("select 1")
def test_auth_user_at_db_level_with_same_forced_user(bouncer):
"""
Check that the pgbouncer correctly handles multiple credentials with the
same name with auth_user for the specific database (isue #1103).
"""
config = f"""
[databases]
* = host={bouncer.pg.host} port={bouncer.pg.port} auth_user=postgres user=postgres min_pool_size=2
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
auth_dbname = postgres
admin_users = pgbouncer
logfile = {bouncer.log_path}
auth_file = {bouncer.auth_path}
"""
with bouncer.run_with_config(config):
# Let's get an error "no such user"
with pytest.raises(psycopg.OperationalError, match="no such user"):
bouncer.conn(dbname="dummydb2", user="dummyuser2", password="dummypswd2")
# Let's wait a few seconds for the janitor to kick in and crash pgbouncer
time.sleep(2)
# Now we will try to connect with OK parameters
with bouncer.conn(dbname="p3", user="postgres", password="asdasd") as cn:
with cn.cursor() as cur:
cur.execute("select 1")
pgbouncer-1.24.1/test/__init__.py 0000644 0001750 0000000 00000000000 14777762222 013565 0000000 0000000 pgbouncer-1.24.1/test/test_admin.py 0000644 0001750 0000000 00000017655 14777762222 014205 0000000 0000000 import time
import psycopg
import pytest
from psycopg.rows import dict_row
from .utils import capture, run
def test_show(bouncer):
show_items = [
"clients",
"config",
"databases",
# Calling SHOW FDS on MacOS leaks the returned file descriptors to the
# python test runner. So we don't test this one directly. SHOW FDS is
# still tested indirectly by the takeover tests.
# "fds",
"help",
"lists",
"peers",
"peer_pools",
"pools",
"servers",
"sockets",
"active_sockets",
"state",
"stats",
"stats_totals",
"stats_averages",
"users",
"totals",
"mem",
"dns_hosts",
"dns_zones",
]
for item in show_items:
bouncer.admin(f"SHOW {item}")
def test_socket_id(bouncer) -> None:
"""Test that PgSocket id is assigned as expected for sockets."""
config = f"""
[databases]
p1 = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
admin_users = pgbouncer
logfile = {bouncer.log_path}
auth_file = {bouncer.auth_path}
pool_mode = session
server_lifetime = 0
"""
with bouncer.run_with_config(config):
with bouncer.cur(
dbname="pgbouncer", user="pgbouncer", row_factory=dict_row
) as admin_cursor:
admin_cursor.execute("SHOW SOCKETS")
servers = admin_cursor.fetchall()
initial_id = max([i["id"] for i in servers])
for i in range(1, 4):
conn_2 = bouncer.conn(dbname="p1")
curr = conn_2.cursor()
_ = curr.execute("SELECT 1")
time.sleep(2)
clients = admin_cursor.execute("SHOW SOCKETS").fetchall()
assert len(clients) == 3
assert set(
[
initial_id,
initial_id + i * 2 - 1,
initial_id + i * 2,
]
) == set([client["id"] for client in clients])
conn_2.close()
time.sleep(2)
def test_server_id(bouncer) -> None:
"""Test that PgSocket id is assigned as expected for servers."""
config = f"""
[databases]
p1 = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
admin_users = pgbouncer
logfile = {bouncer.log_path}
auth_file = {bouncer.auth_path}
server_lifetime = 0
"""
with bouncer.run_with_config(config):
with bouncer.cur(
dbname="pgbouncer", user="pgbouncer", row_factory=dict_row
) as admin_cursor:
admin_cursor.execute("SHOW SOCKETS")
servers = admin_cursor.fetchall()
initial_id = max([i["id"] for i in servers])
for i in range(1, 4):
conn_2 = bouncer.conn(dbname="p1")
curr = conn_2.cursor()
_ = curr.execute("SELECT 1")
time.sleep(2)
clients = admin_cursor.execute("SHOW SERVERS").fetchall()
assert [
initial_id + i * 2,
] == [client["id"] for client in clients]
conn_2.close()
time.sleep(2)
def test_client_id(bouncer) -> None:
"""Test that PgSocket id is assigned as expected for clients."""
config = f"""
[databases]
p1 = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
admin_users = pgbouncer
logfile = {bouncer.log_path}
auth_file = {bouncer.auth_path}
server_lifetime = 0
"""
with bouncer.run_with_config(config):
initial_id = bouncer.admin("SHOW CLIENTS", row_factory=dict_row)[0]["id"]
for i in range(1, 4):
clients = bouncer.admin("SHOW CLIENTS", row_factory=dict_row)
assert [
initial_id + i,
] == [client["id"] for client in clients]
def test_kill_client_nonexisting(bouncer):
# Connect to client as user A
conn_1 = bouncer.conn(dbname="p0", user="maxedout")
# Validate count
clients = bouncer.admin("SHOW CLIENTS", row_factory=dict_row)
assert len(clients) == 2
# Issue kill client command
with pytest.raises(
psycopg.errors.ProtocolViolation,
match=r"client not found",
):
clients = bouncer.admin(f"KILL_CLIENT 1000")
# Validate count
clients = bouncer.admin("SHOW CLIENTS")
assert len(clients) == 2
conn_1.close()
def test_kill_client_invalid(bouncer):
# Connect to client as user A
conn_1 = bouncer.conn(dbname="p0", user="maxedout")
# Validate count
clients = bouncer.admin("SHOW CLIENTS")
assert len(clients) == 2
# Issue kill client command
with pytest.raises(
psycopg.errors.ProtocolViolation,
match=r"invalid client pointer supplied",
):
clients = bouncer.admin("KILL_CLIENT non_existant_client_id")
# Validate count
clients = bouncer.admin("SHOW CLIENTS")
assert len(clients) == 2
conn_1.close()
def test_kill_client(bouncer):
# Connect to client as user A
conn_1 = bouncer.conn(dbname="p0", user="maxedout")
# Validate count
clients = bouncer.admin("SHOW CLIENTS", row_factory=dict_row)
assert len(clients) == 2
# Get clients id
client_id = [client for client in clients if client["database"] == "p0"][0]["id"]
# Issue kill client command
clients = bouncer.admin(f"KILL_CLIENT {client_id}")
# Validate count
clients = bouncer.admin("SHOW CLIENTS")
assert len(clients) == 1
conn_1.close()
def test_show_version(bouncer):
admin_version = bouncer.admin_value(f"SHOW VERSION")
subprocess_result = capture(
[*bouncer.base_command(), "--version"],
)
subprocess_version = subprocess_result.split("\n")[0]
assert admin_version == subprocess_version
def test_help(bouncer):
run([*bouncer.base_command(), "--help"])
def test_show_stats(bouncer):
# Use session pooling database to see differenecs between transactions and
# server assignments
bouncer.default_db = "p3"
bouncer.test()
bouncer.test()
bouncer.test()
bouncer.test()
with bouncer.cur() as cur:
with cur.connection.transaction():
cur.execute("SELECT 1")
cur.execute("SELECT 1")
cur.execute("SELECT 1")
with cur.connection.transaction():
cur.execute("SELECT 1")
cur.execute("SELECT 1")
cur.execute("SELECT 1")
stats = bouncer.admin("SHOW STATS", row_factory=dict_row)
p3_stats = next(s for s in stats if s["database"] == "p3")
assert p3_stats is not None
# 5 connection attempts (and thus assignments)
assert p3_stats["total_server_assignment_count"] == 5
# 4 autocommit queries + 2 transactions
assert p3_stats["total_xact_count"] == 6
# 11 SELECT 1 + 2 times COMMIT and ROLLBACK
assert p3_stats["total_query_count"] == 15
stats = bouncer.admin("SHOW STATS_TOTALS", row_factory=dict_row)
p3_stats = next(s for s in stats if s["database"] == "p3")
assert p3_stats is not None
# 5 connection attempts (and thus assignments)
assert p3_stats["server_assignment_count"] == 5
# 4 autocommit queries + 2 transactions
assert p3_stats["xact_count"] == 6
# 11 SELECT 1 + 2 times COMMIT and ROLLBACK
assert p3_stats["query_count"] == 15
totals = bouncer.admin("SHOW TOTALS")
# 5 connection attempts (and thus assignments)
assert ("total_server_assignment_count", 5) in totals
# 4 autocommit queries + 2 transactions + 4 admin commands
assert ("total_xact_count", 10) in totals
# 11 SELECT 1 + 2 times COMMIT and ROLLBACK + 4 admin commands
assert ("total_query_count", 19) in totals
pgbouncer-1.24.1/test/test_no_user.py 0000644 0001750 0000000 00000006710 14777762222 014555 0000000 0000000 import psycopg
import pytest
# Several tests that check the behavior when connecting with a
# nonexistent user under various authentication types. Database p1
# has a forced user, p2 does not; these exercise slightly different
# code paths.
def test_no_user_trust(bouncer):
bouncer.admin(f"set auth_type='trust'")
with bouncer.log_contains(r'closing because: "trust" authentication failed'):
with pytest.raises(
psycopg.OperationalError, match='"trust" authentication failed'
):
bouncer.test(dbname="p2", user="nosuchuser")
def test_no_user_trust_forced_user(bouncer):
bouncer.admin(f"set auth_type='trust'")
with bouncer.log_contains(r'closing because: "trust" authentication failed'):
with pytest.raises(
psycopg.OperationalError, match='"trust" authentication failed'
):
bouncer.test(dbname="p1", user="nosuchuser")
def test_no_user_password(bouncer):
bouncer.admin(f"set auth_type='plain'")
with bouncer.log_contains(r"closing because: password authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname="p2", user="nosuchuser", password="whatever")
def test_no_user_password_forced_user(bouncer):
bouncer.admin(f"set auth_type='plain'")
with bouncer.log_contains(r"closing because: password authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname="p1", user="nosuchuser", password="whatever")
def test_no_user_md5(bouncer):
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(r"closing because: password authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname="p2", user="nosuchuser", password="whatever")
def test_no_user_md5_forced_user(bouncer):
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(r"closing because: password authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname="p1", user="nosuchuser", password="whatever")
def test_no_user_scram(bouncer):
bouncer.admin(f"set auth_type='scram-sha-256'")
with bouncer.log_contains(r"closing because: SASL authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="SASL authentication failed"
):
bouncer.test(dbname="p2", user="nosuchuser", password="whatever")
def test_no_user_scram_forced_user(bouncer):
bouncer.admin(f"set auth_type='scram-sha-256'")
with bouncer.log_contains(r"closing because: SASL authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="SASL authentication failed"
):
bouncer.test(dbname="p1", user="nosuchuser", password="whatever")
def test_no_user_auth_user(bouncer):
bouncer.admin(f"set auth_type='md5'")
# Currently no mock authentication when using
# auth_query/auth_user. See TODO in
# handle_auth_query_response().
with bouncer.log_contains(r"closing because: no such user \(age"):
with pytest.raises(psycopg.OperationalError, match="no such user"):
bouncer.test(dbname="authdb", user="nosuchuser", password="whatever")
pgbouncer-1.24.1/test/userlist.txt 0000644 0001750 0000000 00000001406 14777762222 014102 0000000 0000000 "marko" "kama"
"postgres" "asdasd"
;Commented out line should be ignored.
"pgbouncer" "fake"
"pswcheck" "pgbouncer-check"
"maxedout" ""
"maxedout2" ""
"maxedout3" ""
"maxedout4" ""
"maxedout5" ""
"poolsize1" ""
"respoolsize1" ""
"bouncer" "zzzz"
;the following pairs of passwords are "foo" and "bar"
"puser1" "foo"
"puser2" "bar"
"muser1" "md5ab8b744ff66bee42dc47bae34ca17959"
"muser2" "md598455b3585818e23c2653a59f6d84551"
"scramuser1" "SCRAM-SHA-256$4096:D76gvGUVj9Z4DNiGoabOBg==$RukL0Xo3Ql/2F9FsD7mcQ3GATG2fD3PA71qY1JagGDs=:BhKUwyyivFm7Tq2jDJVXSVRbRDgTWyBilZKgg6DDuYU="
"scramuser2" "SCRAM-SHA-256$4096:BUYIT9YAsWf036OHLPfv2Q==$zuk7pzdEc5tvftsRIuwlStNxVc+wIE/xfDs7ahsKN0k=:Lov6mndE0DmlgtY60e1LyDsLctQyoH+Bvkm9K9njSa8="
"scramuser3" "baz"
"test_error_message_user" ""
pgbouncer-1.24.1/test/hba_test.rules 0000644 0001750 0000000 00000003375 14777762222 014343 0000000 0000000 # METHOD: trust, reject, md5, password, peer, cert
# local DATABASE USER METHOD [OPTIONS]
# host DATABASE USER ADDRESS METHOD [OPTIONS]
# hostssl DATABASE USER ADDRESS METHOD [OPTIONS]
# hostnossl DATABASE USER ADDRESS METHOD [OPTIONS]
# The following lines test that weird whitespace does not break parsing
# ws
# z
# testing
# Allow access to pgbouncer admin database from localhost for windows tests
host pgbouncer pgbouncer 127.0.0.1/32 trust
# actual tests
local dbp all peer
local all userp password
local dbz userz trust
local dbs users scram-sha-256
local all all md5
hostssl all all 10.0.0.0/8 cert
hostnossl all all 11.0.0.0/8 md5
host all all 127.0.0.0 255.255.255.0 password
host db1 all 0.0.0.0/0 md5
host all user1 15.0.0.0/8 md5
host tmp1,all user1,user2 , user3 16.0.0.0/8 md5
host tmp2,all u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u2 17.0.0.0/8 md5
host d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11 t18user 18.0.0.0/8 trust # comment
host "all" "all" 19.0.0.0/8 cert
host "q1""q2" "a , b" 19.0.0.0/8 cert
# mask
host mdb muser 199.199.199.199/32 cert
host mdb2 muser 128.0.0.0/9 trust
host mdb2 muser 128.0.0.0/8 md5
host mdb2 muser 128.0.0.0/7 cert
host mdb2 muser 128.0.0.0/6 password
host mdb2 muser 128.0.0.0/5 cert
host mdb2 muser 128.0.0.0/4 trust
host mdb2 muser 128.0.0.0/3 md5
host mdb2 muser 128.0.0.0/2 password
host mdb2 muser 128.0.0.0/1 cert
# ipv6
host mdb muser ff11::0/16 md5
host mdb muser ff20::/12 md5
host mdb muser ::1/128 trust
# "all" address
host mdb3 muser all scram-sha-256
host mdb4 muser all reject
# replication
host replication admin ::1/128 trust
host db2,replication admin2 ::1/128 trust
pgbouncer-1.24.1/test/stress.py 0000755 0001750 0000000 00000005036 14777762222 013372 0000000 0000000 #! /usr/bin/env python3
import random
import threading
import time
import psycopg2
n_thread = 100
longtx = False
tx_sleep = 8
conn_data = {
"dbname": "marko",
#'host': '127.0.0.1',
"host": "/tmp",
"port": "6432",
"user": "marko",
#'password': '',
"connect_timeout": "5",
}
def get_connstr():
tmp = []
for k, v in conn_data.items():
tmp.append(k + "=" + v)
return " ".join(tmp)
class WorkThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.setDaemon(True)
self.stat_lock = threading.Lock()
self.query_cnt = 0
def inc_cnt(self):
self.stat_lock.acquire()
self.query_cnt += 1
self.stat_lock.release()
def fetch_cnt(self):
self.stat_lock.acquire()
val = self.query_cnt
self.query_cnt = 0
self.stat_lock.release()
return val
def run(self):
try:
time.sleep(random.random() * 10.0)
except Exception:
pass
while 1:
try:
self.main_loop()
except KeyboardInterrupt:
break
except SystemExit:
break
except Exception as d:
print(d)
try:
time.sleep(5)
except Exception:
pass
def main_loop(self):
db = psycopg2.connect(get_connstr())
if not longtx:
db.autocommit = True
n = 0
while n < 10:
self.do_work(db)
self.inc_cnt()
n += 1
def do_work(self, db):
curs = db.cursor()
q = "select pg_sleep(%.02f)" % (random.random() * 1)
curs.execute(q)
time.sleep(tx_sleep * random.random() + 1)
if longtx:
db.commit()
def main():
print("connstr %s" % get_connstr())
thread_list = []
while len(thread_list) < n_thread:
t = WorkThread()
t.start()
thread_list.append(t)
print("started %d threads" % len(thread_list))
last = time.time()
while 1:
time.sleep(1)
now = time.time()
dur = now - last
if dur >= 5:
last = now
cnt = 0
for t in thread_list:
cnt += t.fetch_cnt()
avg = cnt / dur
print("avg %s" % avg)
if __name__ == "__main__":
try:
main()
except SystemExit:
pass
except KeyboardInterrupt:
pass
# except Exception as d:
# print d
pgbouncer-1.24.1/test/conntest.sh 0000755 0001750 0000000 00000001654 14777762222 013670 0000000 0000000 #!/bin/sh
fw_drop_port() {
echo "fw_drop_port"
case `uname` in
Linux)
sudo iptables -A OUTPUT -p tcp --dport $1 -j DROP;;
Darwin|OpenBSD)
echo "block drop out proto tcp from any to 127.0.0.1 port $1" \
| sudo pfctl -a pgbouncer -f -;;
*)
echo "Unknown OS"; exit 1;;
esac
}
fw_reject_port() {
echo "fw_reject_port"
case `uname` in
Linux)
sudo iptables -A OUTPUT -p tcp --dport $1 -j REJECT --reject-with tcp-reset;;
Darwin|OpenBSD)
echo "block return-rst out proto tcp from any to 127.0.0.1 port $1" \
| sudo pfctl -a pgbouncer -f -;;
*)
echo "Unknown OS"; exit 1;;
esac
}
fw_reset() {
echo "fw_reset"
case `uname` in
Linux)
sudo iptables -F;;
Darwin|OpenBSD)
sudo pfctl -a pgbouncer -F all;;
*)
echo "Unknown OS"; exit 1;;
esac
}
port=5432
port=7000
fw_reset
while true; do
fw_drop_port $port
sleep 12
fw_reset
sleep 12
fw_reject_port $port
sleep 3
fw_reset
sleep 6
done
pgbouncer-1.24.1/test/test_replication.py 0000644 0001750 0000000 00000023550 14777762222 015415 0000000 0000000 import asyncio
import signal
import subprocess
import time
import psycopg
import psycopg.errors
import pytest
from psycopg import sql
from .utils import PG_MAJOR_VERSION, WINDOWS, run
def test_logical_rep(bouncer):
connect_args = {
"dbname": "user_passthrough",
"replication": "database",
"user": "postgres",
"application_name": "abc",
"options": "-c enable_seqscan=off",
}
# Starting in PG10 you can do other commands over logical rep connections
if PG_MAJOR_VERSION >= 10:
bouncer.test(**connect_args)
assert bouncer.sql_value("SHOW application_name", **connect_args) == "abc"
assert bouncer.sql_value("SHOW enable_seqscan", **connect_args) == "off"
bouncer.sql("IDENTIFY_SYSTEM", **connect_args)
# Do a normal connection to the same pool, to ensure that that doesn't
# break anything
bouncer.test(dbname="user_passthrough", user="postgres")
bouncer.sql("IDENTIFY_SYSTEM", **connect_args)
def test_logical_rep_auth_query(bouncer):
connect_args = {
"dbname": "pauthz",
"replication": "database",
"user": "pswcheck_not_in_auth_file",
"application_name": "abc",
"options": "-c enable_seqscan=off",
}
# Starting in PG10 you can do other commands over logical rep connections
if PG_MAJOR_VERSION >= 10:
bouncer.test(**connect_args)
assert bouncer.sql_value("SHOW application_name", **connect_args) == "abc"
assert bouncer.sql_value("SHOW enable_seqscan", **connect_args) == "off"
bouncer.sql("IDENTIFY_SYSTEM", **connect_args)
# Do a normal connection to the same pool, to ensure that that doesn't
# break anything
bouncer.test(dbname="user_passthrough", user="postgres")
bouncer.sql("IDENTIFY_SYSTEM", **connect_args)
def test_logical_rep_unprivileged(bouncer):
if PG_MAJOR_VERSION < 10:
expected_log = "no pg_hba.conf entry for replication connection"
elif PG_MAJOR_VERSION < 16:
expected_log = "must be superuser or replication role to start walsender"
else:
expected_log = "permission denied to start WAL sender"
with bouncer.log_contains(
expected_log,
), bouncer.log_contains(
r"closing because: login failed \(age", times=2
), pytest.raises(psycopg.OperationalError, match=r"login failed"):
bouncer.sql("IDENTIFY_SYSTEM", replication="database")
@pytest.mark.skipif(
"PG_MAJOR_VERSION < 10", reason="logical replication was introduced in PG10"
)
def test_logical_rep_subscriber(bouncer):
bouncer.admin("set pool_mode=transaction")
# First write create a table and insert a row in the source database.
# Also create the replication slot and publication
bouncer.default_db = "user_passthrough"
bouncer.create_schema("test_logical_rep_subscriber")
bouncer.sql("CREATE TABLE test_logical_rep_subscriber.table(a int)")
bouncer.sql("INSERT INTO test_logical_rep_subscriber.table values (1)")
assert (
bouncer.sql_value("SELECT count(*) FROM test_logical_rep_subscriber.table") == 1
)
bouncer.create_publication(
"mypub", sql.SQL("FOR TABLE test_logical_rep_subscriber.table")
)
bouncer.create_logical_replication_slot("test_logical_rep_subscriber", "pgoutput")
# Create an equivalent, but empty schema in the target database.
# And setup the subscription
bouncer.default_db = "user_passthrough2"
bouncer.create_schema("test_logical_rep_subscriber")
bouncer.sql("CREATE TABLE test_logical_rep_subscriber.table(a int)")
conninfo = bouncer.make_conninfo(dbname="user_passthrough")
bouncer.create_subscription(
"mysub",
sql.SQL(
"""
CONNECTION {}
PUBLICATION mypub
WITH (slot_name=test_logical_rep_subscriber, create_slot=false)
"""
).format(sql.Literal(conninfo)),
)
# The initial copy should now copy over the row
time.sleep(2)
assert (
bouncer.sql_value("SELECT count(*) FROM test_logical_rep_subscriber.table") >= 1
)
# Insert another row and logical replication should replicate it correctly
bouncer.sql(
"INSERT INTO test_logical_rep_subscriber.table values (2)",
dbname="user_passthrough",
)
time.sleep(2)
assert (
bouncer.sql_value("SELECT count(*) FROM test_logical_rep_subscriber.table") >= 2
)
@pytest.mark.skipif(
"WINDOWS", reason="MINGW does not have contrib package containing test_decoding"
)
def test_logical_rep_pg_recvlogical(bouncer):
bouncer.default_db = "user_passthrough"
bouncer.create_schema("test_logical_rep_pg_recvlogical")
bouncer.sql("CREATE TABLE test_logical_rep_pg_recvlogical.table(a int)")
bouncer.create_logical_replication_slot(
"test_logical_rep_pg_recvlogical", "test_decoding"
)
process = subprocess.Popen(
[
"pg_recvlogical",
"--dbname",
bouncer.default_db,
"--host",
bouncer.host,
"--port",
str(bouncer.port),
"--user",
bouncer.default_user,
"--slot=test_logical_rep_pg_recvlogical",
"--file=-",
"--no-loop",
"--start",
],
stdout=subprocess.PIPE,
)
assert process.stdout is not None
bouncer.sql("INSERT INTO test_logical_rep_pg_recvlogical.table values (1)")
try:
assert process.stdout.readline().startswith(b"BEGIN ")
assert (
process.stdout.readline()
== b'table test_logical_rep_pg_recvlogical."table": INSERT: a[integer]:1\n'
)
assert process.stdout.readline().startswith(b"COMMIT ")
finally:
process.kill()
process.communicate(timeout=5)
def test_physical_rep(bouncer):
connect_args = {
"dbname": "user_passthrough",
"replication": "yes",
"user": "postgres",
"application_name": "abc",
"options": "-c enable_seqscan=off",
}
# Starting in PG10 you can do SHOW commands
if PG_MAJOR_VERSION >= 10:
with pytest.raises(
psycopg.errors.FeatureNotSupported,
match="cannot execute SQL commands in WAL sender for physical replication",
):
bouncer.test(**connect_args)
assert bouncer.sql_value("SHOW application_name", **connect_args) == "abc"
assert bouncer.sql_value("SHOW enable_seqscan", **connect_args) == "off"
bouncer.sql("IDENTIFY_SYSTEM", **connect_args)
# Do a normal connection to the same pool, to ensure that that doesn't
# break anything
bouncer.test(dbname="user_passthrough", user="postgres")
bouncer.sql("IDENTIFY_SYSTEM", **connect_args)
def test_physcal_rep_unprivileged(bouncer):
with bouncer.log_contains(
r"no pg_hba.conf entry for replication connection from host"
), bouncer.log_contains(
r"closing because: login failed \(age", times=2
), pytest.raises(
psycopg.OperationalError, match=r"login failed"
):
bouncer.test(replication="yes")
@pytest.mark.skipif("PG_MAJOR_VERSION < 10", reason="pg_receivewal was added in PG10")
def test_physical_rep_pg_receivewal(bouncer, tmp_path):
bouncer.default_db = "user_passthrough"
bouncer.create_physical_replication_slot("test_physical_rep_pg_receivewal")
wal_dump_dir = tmp_path / "wal-dump"
wal_dump_dir.mkdir()
process = subprocess.Popen(
[
"pg_receivewal",
"--dbname",
bouncer.make_conninfo(),
"--slot=test_physical_rep_pg_receivewal",
"--directory",
str(wal_dump_dir),
],
)
time.sleep(3)
if WINDOWS:
process.terminate()
else:
process.send_signal(signal.SIGINT)
process.communicate(timeout=5)
if WINDOWS:
assert process.returncode == 1
else:
assert process.returncode == 0
children = list(wal_dump_dir.iterdir())
assert len(children) > 0
def test_physical_rep_pg_basebackup(bouncer, tmp_path):
bouncer.default_db = "user_passthrough"
dump_dir = tmp_path / "db-dump"
dump_dir.mkdir()
run(
[
"pg_basebackup",
"--dbname",
bouncer.make_conninfo(),
"--checkpoint=fast",
"--pgdata",
dump_dir,
],
)
children = list(dump_dir.iterdir())
assert len(children) > 0
print(children)
@pytest.mark.asyncio
@pytest.mark.skipif(
"PG_MAJOR_VERSION < 10",
reason="normal SQL commands are only supported in PG10+ on logical replication connections",
)
async def test_replication_pool_size(pg, bouncer):
connect_args = {
"dbname": "user_passthrough_pool_size2",
"replication": "database",
"user": "postgres",
"connect_timeout": 10,
}
start = time.time()
await bouncer.asleep(0.5, times=10, **connect_args)
assert time.time() - start > 2.5
# Replication connections always get closed right away
assert pg.connection_count("p0") == 0
connect_args["dbname"] = "user_passthrough_pool_size5"
start = time.time()
await bouncer.asleep(0.5, times=10, **connect_args)
assert time.time() - start > 1
# Replication connections always get closed right away
assert pg.connection_count("p0") == 0
@pytest.mark.asyncio
@pytest.mark.skipif(
"PG_MAJOR_VERSION < 10",
reason="normal SQL commands are only supported in PG10+ on logical replication connections",
)
async def test_replication_pool_size_mixed_clients(bouncer):
connect_args = {
"dbname": "user_passthrough_pool_size2",
"user": "postgres",
}
# Fill the pool with normal connections
await bouncer.asleep(0.5, times=2, **connect_args)
# Then try to open a replication connection and ensure that it causes
# eviction of one of the normal connections
with bouncer.log_contains("closing because: evicted"):
bouncer.test(**connect_args, replication="database")
pgbouncer-1.24.1/test/test_prepared.py 0000644 0001750 0000000 00000065475 14777762222 014722 0000000 0000000 import random
import time
import psycopg
import pytest
from psycopg import pq, sql
from psycopg.rows import dict_row
from .utils import LIBPQ_SUPPORTS_PIPELINING, LINUX, PKT_BUF_SIZE, USE_SUDO
def test_prepared_statement(bouncer):
bouncer.admin(f"set pool_mode=transaction")
prepared_query = "SELECT 1"
with bouncer.cur() as cur1:
with bouncer.cur() as cur2:
# prepare query on server 1 and client 1
cur1.execute(prepared_query, prepare=True)
# Run the prepared query again on same server and client
cur1.execute(prepared_query)
with cur2.connection.transaction():
# Claim server 1 with client 2
cur2.execute("SELECT 2")
# Client 1 now runs the prepared query, and it's automatically
# prepared on server 2
cur1.execute(prepared_query)
# Client 2 now prepares the same query that was already
# prepared on server 1. And PgBouncer reuses that already
# prepared query for this different client.
cur2.execute(prepared_query, prepare=True)
def test_prepared_statement_params(bouncer):
bouncer.admin(f"set pool_mode=transaction")
prepared_query = "SELECT %s"
with bouncer.cur() as cur1:
with bouncer.cur() as cur2:
# prepare query on server 1 and client 1
cur1.execute(prepared_query, params=(1,), prepare=True)
# Run the prepared query again on same server and client
cur1.execute(prepared_query, params=(1,))
with cur2.connection.transaction():
# Claim server 1 with client 2
cur2.execute("SELECT 2")
# Client 1 now runs the prepared query, and it's automatically
# prepared on server 2
cur1.execute(prepared_query, params=(1,))
# Client 2 now prepares the same query that was already
# prepared on server 1. And PgBouncer reuses that already
# prepared query for this different client.
cur2.execute(prepared_query, params=(1,), prepare=True)
def test_deallocate_all(bouncer):
bouncer.admin(f"set pool_mode=transaction")
prepared_query = "SELECT 1"
with bouncer.cur() as cur1:
with bouncer.cur() as cur2:
# prepare query on client 1
cur1.execute(prepared_query, prepare=True)
# Run the prepared query again on same server and client
cur1.execute(prepared_query)
# prepared query for client 2
cur2.execute(prepared_query, prepare=True)
# execute DEALLOCATE ALL on client 1
cur1.execute("DEALLOCATE ALL")
# Run the prepared query again on server 2 and client 2
cur2.execute(prepared_query)
# Confirm that the prepared query is not available anymore on
# client 1
with bouncer.log_contains("prepared statement did not exist"):
with pytest.raises(
psycopg.OperationalError,
match="prepared statement did not exist|server closed the connection unexpectedly",
):
cur1.execute(prepared_query)
def test_discard_all(bouncer):
bouncer.admin(f"set pool_mode=transaction")
prepared_query = "SELECT 1"
with bouncer.cur() as cur1:
with bouncer.cur() as cur2:
# prepare query on client 1
cur1.execute(prepared_query, prepare=True)
# Run the prepared query again on same server and client
cur1.execute(prepared_query)
# prepared query for client 2
cur2.execute(prepared_query, prepare=True)
# execute DISCARD ALL on client 1
cur1.execute("DISCARD ALL")
# Run the prepared query again on server 2 and client 2
cur2.execute(prepared_query)
# Confirm that the prepared query is not available anymore on
# client 1
with bouncer.log_contains("prepared statement did not exist"):
with pytest.raises(
psycopg.OperationalError,
match="prepared statement did not exist|server closed the connection unexpectedly",
):
cur1.execute(prepared_query)
def test_parse_larger_than_pkt_buf(bouncer):
long_string = "1" * PKT_BUF_SIZE * 10
prepared_query = "SELECT '" + long_string + "'"
with bouncer.cur() as cur1:
result = cur1.execute(prepared_query, prepare=True).fetchone()[0]
assert result == long_string
def test_bind_larger_than_pkt_buf(bouncer):
long_string = "1" * PKT_BUF_SIZE * 10
prepared_query = "SELECT %s::text"
with bouncer.cur() as cur1:
result = cur1.execute(
prepared_query, params=(long_string,), prepare=True
).fetchone()[0]
assert result == long_string
# The 4x larger than pkt_buf amount is special, because if the extra_packets
# buffer becomes larger than that it will be freed.
# (see sbuf_process_pending in sbuf.c)
def test_parse_larger_than_pkt_buf_but_smaller_than_4x(bouncer):
long_string = "1" * PKT_BUF_SIZE * 2
prepared_query = "SELECT '" + long_string + "'"
with bouncer.cur() as cur1:
result = cur1.execute(prepared_query, prepare=True).fetchone()[0]
assert result == long_string
def test_bind_larger_than_pkt_buf_but_smaller_than_4x(bouncer):
long_string = "1" * PKT_BUF_SIZE * 2
prepared_query = "SELECT %s::text"
with bouncer.cur() as cur1:
result = cur1.execute(
prepared_query, params=(long_string,), prepare=True
).fetchone()[0]
assert result == long_string
# In one of the initial implementation of prepared statement support there was
# a bug, that if a varcache change was needed, then the callback would not be
# called again correctly later.
def test_parse_larger_than_pkt_buf_with_varcache_change(bouncer):
long_string = "1" * PKT_BUF_SIZE * 10
prepared_query = "SELECT '" + long_string + "'"
with bouncer.cur(dbname="varcache_change") as cur1:
result = cur1.execute(prepared_query, prepare=True).fetchone()[0]
assert result == long_string
def test_evict_statement_cache(bouncer):
bouncer.admin(f"set max_prepared_statements=1")
with bouncer.cur() as cur:
for i in range(5):
prepared_query = f"SELECT '{i}'"
result = cur.execute(prepared_query, prepare=True).fetchone()[0]
assert result == str(i)
n_statements = cur.execute(
"SELECT count(*) FROM pg_prepared_statements"
).fetchone()[0]
assert n_statements == 1
bouncer.admin(f"set max_prepared_statements=5")
for i in range(5, 10):
prepared_query = f"SELECT '{i}'"
result = cur.execute(prepared_query, prepare=True).fetchone()[0]
assert result == str(i)
n_statements = cur.execute(
"SELECT count(*) FROM pg_prepared_statements"
).fetchone()[0]
assert n_statements == 5
bouncer.admin(f"set max_prepared_statements=2")
n_statements = cur.execute(
"SELECT count(*) FROM pg_prepared_statements"
).fetchone()[0]
assert n_statements == 5
result = cur.execute("SELECT '10'", prepare=True).fetchone()[0]
assert result == "10"
n_statements = cur.execute(
"SELECT count(*) FROM pg_prepared_statements"
).fetchone()[0]
assert n_statements == 2
# Test behaviour when disabling prepared statement handling
bouncer.admin(f"set max_prepared_statements=0")
# Since we disabled prepared statement handling, this should now fail
# because we forward the client its prepared statement name to the
# server and the server doesn't know about that name.
with pytest.raises(psycopg.errors.InvalidSqlStatementName):
cur.execute("SELECT '10'", prepare=True)
# While setting the cache size to 0 disables prepared statement
# handling completely, but it doesn't clear any of existing caches.
# Preferably we would clear the existing caches, but that's not easy to
# implement. Right now we only evict statements from the cache when we
# insert into a cache, and since we disabled prepared statement
# handling we never insert into a cache.
n_statements = cur.execute(
"SELECT count(*) FROM pg_prepared_statements"
).fetchone()[0]
assert n_statements == 2
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_evict_statement_cache_pipeline_failure(bouncer):
bouncer.admin(f"set max_prepared_statements=1")
with bouncer.conn() as conn:
with conn.pipeline() as p:
curs = [conn.cursor() for _ in range(4)]
curs[0].execute("SELECT 1", prepare=True)
curs[1].execute("bad query", prepare=True)
with pytest.raises(psycopg.errors.SyntaxError):
p.sync()
assert curs[0].fetchall() == [(1,)]
curs[0].execute("SELECT 1", prepare=True)
p.sync()
assert curs[0].fetchall() == [(1,)]
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_prepared_statement_pipeline(bouncer):
# Prepare query on the server connection and then disconnect again
prepared_query = "SELECT 1"
with bouncer.cur() as cur:
result = cur.execute(prepared_query, prepare=True).fetchone()[0]
assert result == 1
# Try with a prepared query first and a unprepared query second
with bouncer.conn() as conn:
with conn.pipeline():
curs = [conn.cursor() for _ in range(4)]
curs[0].execute("SELECT 2", prepare=True)
curs[1].execute(prepared_query, prepare=True)
curs[2].execute("SELECT 3")
curs[3].execute(prepared_query, prepare=True)
assert curs[0].fetchall() == [(2,)]
assert curs[1].fetchall() == [(1,)]
assert curs[2].fetchall() == [(3,)]
assert curs[3].fetchall() == [(1,)]
# Try with a unprepared query first and a prepared query second
with bouncer.conn() as conn:
with conn.pipeline(), conn.cursor() as cur:
curs = [conn.cursor() for _ in range(4)]
curs[0].execute("SELECT 2", prepare=True)
curs[1].execute(prepared_query, prepare=True)
curs[2].execute("SELECT 3")
curs[3].execute(prepared_query, prepare=True)
assert curs[0].fetchall() == [(2,)]
assert curs[1].fetchall() == [(1,)]
assert curs[2].fetchall() == [(3,)]
assert curs[3].fetchall() == [(1,)]
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
@pytest.mark.timeout(300)
def test_prepared_statement_pipeline_stress(bouncer):
max_pipeline_length = 10
max_prepared_stmt = 100
n_iterations = 100
max_prepared_statements = max_prepared_stmt * 2 // 3
size_of_param = 512
bouncer.admin(f"set max_prepared_statements={max_prepared_statements}")
for pipeline_length in range(max_pipeline_length):
# Try with a prepared query first and a unprepared query second
with bouncer.conn() as conn:
with conn.pipeline():
curs = [conn.cursor() for _ in range(pipeline_length)]
for _ in range(n_iterations):
for i in range(pipeline_length):
stmt_id = random.randint(1, max_prepared_stmt)
curs[i].execute(
sql.SQL("SELECT %s, %s::text as {}").format(
sql.Identifier(f"s{stmt_id}")
),
params=(i, str(i).zfill(size_of_param)),
prepare=True,
)
for i in range(pipeline_length):
assert curs[i].fetchall() == [(i, str(i).zfill(size_of_param))]
def test_describe_non_existent_prepared_statement(bouncer):
bouncer.admin(f"set max_prepared_statements=100")
with bouncer.conn() as conn:
result = conn.pgconn.describe_prepared(b"doesnotexist")
assert result.status == pq.ExecStatus.FATAL_ERROR
assert b"server closed the connection unexpectedly" in result.error_message
# libpq before PG17 does not support sending Close messages
@pytest.mark.skipif("psycopg.pq.version() < 170000")
@pytest.mark.skipif(
"psycopg.__version__ < '3.2.0'",
reason="Debian oldstable doesn't support a version of psycopg with 'close_prepared' support",
)
def test_close_prepared_statement(bouncer):
with bouncer.conn() as conn:
result = conn.pgconn.prepare(b"test", b"SELECT 1")
assert result.status == pq.ExecStatus.COMMAND_OK
result = conn.pgconn.close_prepared(b"test")
assert result.status == pq.ExecStatus.COMMAND_OK
# closing a non-existent prepared statement should not raise an error
result = conn.pgconn.close_prepared(b"test")
assert result.status == pq.ExecStatus.COMMAND_OK
# ensure that the prepared statement is actually closed by trying to
# describe it.
result = conn.pgconn.describe_prepared(b"test")
assert result.status == pq.ExecStatus.FATAL_ERROR
def test_statement_name_longer_than_pkt_buf(bouncer):
name = b"a" * PKT_BUF_SIZE * 4
with bouncer.conn() as conn:
result = conn.pgconn.prepare(name, b"SELECT $1::text")
assert result.status == pq.ExecStatus.COMMAND_OK
result = conn.pgconn.describe_prepared(name)
assert result.status == pq.ExecStatus.COMMAND_OK
result = conn.pgconn.exec_prepared(name, (b"abc",))
assert result.status == pq.ExecStatus.TUPLES_OK
assert result.get_value(0, 0) == b"abc"
if psycopg.pq.version() >= 170000 and psycopg.__version__ >= "3.2.0":
# libpq before PG17 does not support sending Close messages
# Debian oldstable does not package psycopg with 'close_prepared'
result = conn.pgconn.close_prepared(name)
assert result.status == pq.ExecStatus.COMMAND_OK
# Ensure that the close was successful
result = conn.pgconn.describe_prepared(name)
assert result.status == pq.ExecStatus.FATAL_ERROR
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_prepared_statement_pipeline_error(bouncer):
# Prepare query on the server connection and then disconnect again
prepared_query = "SELECT 1"
with bouncer.cur() as cur:
result = cur.execute(prepared_query, prepare=True).fetchone()[0]
assert result == 1
# Make sure queue is cleared after error
with bouncer.conn() as conn:
with conn.pipeline() as p, conn.cursor() as cur:
cur.execute("SELECT aaaa")
with pytest.raises(
psycopg.errors.UndefinedColumn, match='column "aaaa" does not exist'
):
p.sync()
cur.execute(prepared_query, prepare=True)
assert cur.fetchall() == [(1,)]
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_prepared_statement_pipeline_error_delayed_sync(bouncer):
# Prepare query on the server connection and then disconnect again
prepared_query = "SELECT 1"
with bouncer.cur() as cur:
result = cur.execute(prepared_query, prepare=True).fetchone()[0]
assert result == 1
# Make sure queue is fully cleared until Sync on error, even future
# messages that have not yet been received by PgBouncer (including the Sync
# itself)
with bouncer.conn() as conn:
with conn.pipeline() as p, conn.cursor() as cur:
cur.execute("SELECT aaaa")
time.sleep(0.1)
with pytest.raises(
psycopg.errors.UndefinedColumn, match='column "aaaa" does not exist'
):
cur.execute("SELECT 123")
with pytest.raises(psycopg.errors.PipelineAborted):
cur.fetchall()
p.sync()
cur.execute(prepared_query, prepare=True)
assert cur.fetchall() == [(1,)]
def test_prepared_failed_prepare(bouncer):
with bouncer.cur() as cur:
with pytest.raises(psycopg.errors.UndefinedTable):
cur.execute("SELECT * FROM doesnotexistyet", prepare=True)
cur.execute("CREATE TABLE doesnotexistyet (a int)")
cur.execute("SELECT * FROM doesnotexistyet", prepare=True)
cur.execute("DROP TABLE doesnotexistyet")
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_prepared_failed_prepare_pipeline(bouncer):
with bouncer.conn() as conn:
with conn.pipeline() as p, conn.cursor() as cur:
cur.execute("SELECT 1", prepare=True)
cur.execute("SELECT * FROM doesnotexistyet", prepare=True)
with pytest.raises(psycopg.errors.UndefinedTable):
# Either of these two commands might fail due to timing
# differences, usually it's the sync. If the execute fails we
# still want it to sync though.
try:
cur.execute("SELECT 2", prepare=True)
finally:
p.sync()
cur.execute("SELECT 1", prepare=True)
p.sync()
cur.execute("SELECT 2", prepare=True)
p.sync()
cur.execute("CREATE TABLE doesnotexistyet (a int)")
cur.execute("SELECT * FROM doesnotexistyet", prepare=True)
p.sync()
cur.execute("DROP TABLE doesnotexistyet")
def test_prepared_disallow_name_reuse(bouncer):
with bouncer.conn() as conn:
result = conn.pgconn.prepare(b"test", b"SELECT 1")
assert result.status == pq.ExecStatus.COMMAND_OK
with bouncer.log_contains("prepared statement 'test' was already prepared"):
result = conn.pgconn.prepare(b"test", b"SELECT 1")
assert result.status == pq.ExecStatus.FATAL_ERROR
# This reproduces a bug that was found by running the JDBC test suite. We would
# only remove old data from the packet buffer when the amount of unparsed data
# was less than SMALL_PACKET_SIZE bytes left in the buffer. This meant that if
# we had a prepared statement larger than that it would loop ininitely. Now we
# remove old data from the buffer whenever the callback reports that it needs
# more data.
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_pipeline_with_half_pkt_buf_prepare(bouncer):
long_string1 = "1" * (PKT_BUF_SIZE // 2)
long_string2 = "2" * (PKT_BUF_SIZE // 2)
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_prepare(b"p1", f"SELECT 'a{long_string1}'".encode())
conn.pgconn.send_prepare(b"p2", f"SELECT 'b{long_string2}'".encode())
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
# This reproduces a bug that was found by running the JDBC test suite. The
# problem was that when we could not fit the entire prepare massage in pkt_buf
# anymore, but there was some data in the buffer that was not yet sent then
# PgBouncer would loop infinitely. Now we flush already parsed messages from
# the buffer, when the parsing of the next packet informs that it needs more
# data to do so.
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_pipeline_flushes_on_full_pkt_buf(bouncer):
query = b"SELECT 1"
# We want to construct a Parse packet that is exactly the size of pkt_buf,
# so we don't trigger the logic to use the callback buffering logic, but do
# need the whole sbuf buffer to be available. So let's calculate the exact
# length of the statement name that we need to make this happen.
size_type = 1 # 'P'
size_length = 4 # int32
size_query = len(query) + 1 # +1 for the null terminator
size_param_count = 2 # int16
size_non_statement_name = size_type + size_length + size_query + size_param_count
# So now we construct a statement name that makes all this add up pkt_buf
# (-1 for null terminator of the statement name)
statement_name = b"p" * (PKT_BUF_SIZE - size_non_statement_name - 1)
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
# First send a tiny packet to use some space in the sbuf, Flush is used
# arbitrarily since it only takes 5 bytes
conn.pgconn.send_flush_request()
conn.pgconn.send_prepare(statement_name, query)
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
# This resolves a bug where we would incorrectly release a server connection
# even though there were still requests in flight. This was causing a weird
# errors in Npgsql, because halfway through the second transaction its
# connection could be changed, thus removing any state such as portals.
# The following test reproduces a minimal version of this bug.
# See #714 for the initial report
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_pause_before_last_sync(bouncer):
bouncer.admin(f"set pool_mode=transaction")
with bouncer.conn() as conn1, bouncer.cur() as cur2:
conn1.pgconn.enter_pipeline_mode()
conn1.pgconn.send_prepare(b"", b"SELECT $1::text")
conn1.pgconn.send_query_prepared(b"", [b"a"])
# This sync triggers a ready for query, which would release the
# connection (before the fix).
conn1.pgconn.pipeline_sync()
# But not before the next commands were forwarded to the server
# After the fix these commands cause the server to stay linked to the
# client.
conn1.pgconn.send_prepare(b"", b"SELECT $1::text")
conn1.pgconn.flush()
with cur2.connection.transaction():
# Sleep a little bit to ensure the server would be released
# (without the fix).
time.sleep(2)
# Then cur2 would claim the server connection that still had
# commands from conn1 on it.
cur2.execute("SELECT 1")
# The execution of the prepared statement command would then open a
# new connection without the expected prepared query on it
conn1.pgconn.send_query_prepared(b"", [b"b"])
conn1.pgconn.pipeline_sync()
assert conn1.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn1.pgconn.get_result() is None
assert conn1.pgconn.get_result().status == pq.ExecStatus.TUPLES_OK
assert conn1.pgconn.get_result() is None
assert conn1.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
assert conn1.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn1.pgconn.get_result() is None
assert conn1.pgconn.get_result().status == pq.ExecStatus.TUPLES_OK
assert conn1.pgconn.get_result() is None
assert conn1.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
@pytest.mark.skipif("not LINUX", reason="add_latency only supports Linux")
@pytest.mark.skipif("not USE_SUDO")
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_prepared_statement_pipeline_latency(bouncer, pg):
with bouncer.conn() as conn1:
with conn1.pipeline() as p1:
with pg.add_latency():
start = time.time()
num_queries = 7
curs = [conn1.cursor() for _ in range(num_queries)]
for i in range(num_queries):
curs[i].execute(f"SELECT '{i}'", prepare=True)
p1.sync()
# Each query takes at least 1 second due to the latency
# introduced by the add_latency contextmanager. But because of
# pipelining the latency the whole series of queries should be
# a lot less.
end = time.time()
duration = end - start
assert duration < num_queries
# The results should be correct too
for i in range(num_queries):
assert curs[i].fetchone()[0] == str(i)
def test_prepared_statement_counters(bouncer):
bouncer.default_db = "p0"
bouncer.admin(f"set pool_mode=transaction")
# Explicitly disable prepared statement support
bouncer.admin(f"set max_prepared_statements=0")
with bouncer.cur() as cur:
with cur.connection.transaction():
cur.execute("SELECT 1")
cur.execute("SELECT 1")
cur.execute("SELECT 1")
with cur.connection.transaction():
cur.execute("SELECT 1")
cur.execute("SELECT 1")
cur.execute("SELECT 1")
stats = bouncer.admin("SHOW STATS", row_factory=dict_row)
p0_stats = next(s for s in stats if s["database"] == "p0")
# All the prepared statement counters should be 0, as they are not applicable
assert p0_stats["total_client_parse_count"] == 0
assert p0_stats["total_server_parse_count"] == 0
assert p0_stats["total_bind_count"] == 0
assert p0_stats["avg_client_parse_count"] == 0
assert p0_stats["avg_server_parse_count"] == 0
assert p0_stats["avg_bind_count"] == 0
# Explicitly enable prepared statement support
bouncer.admin(f"set max_prepared_statements=10")
prepared_query = "SELECT 1"
with bouncer.cur() as cur1:
with bouncer.cur() as cur2:
# prepare query on server 1 and client 1
cur1.execute(prepared_query, prepare=True)
# Run the prepared query twice on same server and client
cur1.execute(prepared_query)
cur1.execute(prepared_query)
with cur2.connection.transaction():
# Claim server 1 with client 2
cur2.execute("SELECT 2")
# Client 1 now runs the prepared query, and it's automatically
# prepared on server 2
cur1.execute(prepared_query)
# Client 2 now prepares the same query that was already
# prepared on server 1. And PgBouncer reuses that already
# prepared query for this different client.
cur2.execute(prepared_query, prepare=True)
stats = bouncer.admin("SHOW STATS", row_factory=dict_row)
p0_stats = next(s for s in stats if s["database"] == "p0")
# 2 prepare=True executions
assert p0_stats["total_client_parse_count"] == 2
# server 1 and server 2 have to prepare the query
assert p0_stats["total_server_parse_count"] == 2
# 2 executions with prepare=True + 3 re-use executions
assert p0_stats["total_bind_count"] == 5
pgbouncer-1.24.1/test/conftest.py 0000644 0001750 0000000 00000016006 14777762222 013670 0000000 0000000 import os
import shutil
import filelock
import pytest
from .utils import (
LINUX,
LONG_PASSWORD,
PG_SUPPORTS_SCRAM,
TEST_DIR,
TLS_SUPPORT,
USE_SUDO,
Bouncer,
Postgres,
run,
sudo,
)
def add_qdisc():
if not LINUX or not USE_SUDO:
return
# Add the all zeros priomap to prio so all regular traffic flows
# through a single band. By default prio assigns traffic to different
# band according to the DSCP value of the packet. This means that some
# traffic that doesn't match your filter might end up in the same class
# as the delayed traffic.
# Source: https://stackoverflow.com/a/40203517/2570866
sudo(
"tc qdisc add dev lo root handle 1: prio bands 2 priomap 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"
)
# Add one band with additional latency
sudo("tc qdisc add dev lo parent 1:2 handle 20: netem delay 1000ms")
def delete_qdisc():
if not LINUX or not USE_SUDO:
return
sudo("tc qdisc del dev lo parent 1:2 handle 20:")
sudo("tc qdisc del dev lo root")
def create_certs(cert_dir):
run(
"sh create_certs.sh",
cwd=TEST_DIR / "ssl",
silent=True,
)
if not TLS_SUPPORT:
return
cert_dir.mkdir()
shutil.move(TEST_DIR / "ssl" / "TestCA1", cert_dir / "TestCA1")
shutil.move(TEST_DIR / "ssl" / "TestCA2", cert_dir / "TestCA2")
@pytest.fixture(autouse=True, scope="session", name="cert_dir")
def shared_setup(tmp_path_factory, worker_id):
"""Does some setup that's shared between workers
This setup should only be done once and should only be cleaned up once, at
the end of the last finished worker process.
It currently sets up 2 things:
1. A cert directory, for TLS tests
2. A queueing disciplines (qdisc), for tests that require latency
It yields the certificate directory, which is why the fixture name is
cert_dir.
"""
if worker_id == "master":
# not executing in with multiple workers, just do the setup without any
# file locking.
cert_dir = tmp_path_factory.getbasetemp() / "certs"
add_qdisc()
create_certs(cert_dir)
yield cert_dir
delete_qdisc()
return
total_workers = int(os.environ.get("PYTEST_XDIST_WORKER_COUNT", ""))
# get the temp directory shared by all workers
root_tmp_dir = tmp_path_factory.getbasetemp().parent
cert_dir = root_tmp_dir / "certs"
lock_name = root_tmp_dir / "worker.lock"
finished_count_file = root_tmp_dir / "finished_workers"
with filelock.FileLock(lock_name):
if not cert_dir.is_dir():
finished_count_file.write_text("0")
add_qdisc()
create_certs(cert_dir)
try:
yield cert_dir
finally:
with filelock.FileLock(lock_name):
finished_count = int(finished_count_file.read_text()) + 1
if finished_count == total_workers:
delete_qdisc()
else:
finished_count_file.write_text(str(finished_count))
@pytest.fixture(autouse=True, scope="session")
def pg(tmp_path_factory, cert_dir):
"""Starts a new Postgres db that is shared for tests in this process"""
pg = Postgres(tmp_path_factory.getbasetemp() / "pgdata")
pg.initdb()
os.truncate(pg.hba_path, 0)
if TLS_SUPPORT:
with pg.conf_path.open("a") as f:
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
f.write(f"ssl_cert_file='{cert}'\n")
f.write(f"ssl_key_file='{key}'\n")
pg.nossl_access("replication", "trust", user="postgres")
pg.nossl_access("all", "trust")
pg.nossl_access("p4", "password")
pg.nossl_access("p5", "md5")
if PG_SUPPORTS_SCRAM:
pg.nossl_access("p6", "scram-sha-256")
pg.commit_hba()
pg.start()
for i in range(8):
pg.sql(f"create database p{i}")
pg.sql("create database unconfigured_auth_database")
pg.sql("create user bouncer")
pg.sql("create user pswcheck_not_in_auth_file with superuser;")
pg.sql("create user pswcheck with superuser createdb password 'pgbouncer-check';")
pg.sql("create user someuser with password 'anypasswd';")
pg.sql("create user maxedout;")
pg.sql("create user maxedout2;")
pg.sql("create user maxedout3;")
pg.sql("create user maxedout4;")
pg.sql("create user maxedout5;")
pg.sql("create user poolsize1;")
pg.sql("create user respoolsize1;")
pg.sql("create user test_error_message_user;")
pg.sql(f"create user longpass with password '{LONG_PASSWORD}';")
pg.sql("create user stats password 'stats';")
pg.sql("grant all on schema public to public", dbname="p0")
pg.sql("create table test_copy(i int)", dbname="p0")
pg.sql("grant all on table test_copy to public", dbname="p0")
if PG_SUPPORTS_SCRAM:
pg.sql("set password_encryption = 'md5'; create user muser1 password 'foo';")
pg.sql("set password_encryption = 'md5'; create user muser2 password 'wrong';")
pg.sql("set password_encryption = 'md5'; create user puser1 password 'foo';")
pg.sql("set password_encryption = 'md5'; create user puser2 password 'wrong';")
pg.sql(
"set password_encryption = 'scram-sha-256'; create user scramuser1 password '"
"SCRAM-SHA-256$4096:D76gvGUVj9Z4DNiGoabOBg==$RukL0Xo3Ql/2F9FsD7mcQ3GATG2fD3PA71qY1JagGDs=:BhKUwyyivFm7Tq2jDJVXSVRbRDgTWyBilZKgg6DDuYU="
"'"
)
pg.sql(
"set password_encryption = 'scram-sha-256'; create user scramuser3 password 'baz';"
)
else:
pg.sql("set password_encryption = 'on'; create user muser1 password 'foo';")
pg.sql("set password_encryption = 'on'; create user muser2 password 'wrong';")
pg.sql("set password_encryption = 'on'; create user puser1 password 'foo';")
pg.sql("set password_encryption = 'on'; create user puser2 password 'wrong';")
yield pg
pg.cleanup()
@pytest.mark.asyncio
@pytest.fixture
async def bouncer(pg, tmp_path):
"""Starts a new PgBouncer process"""
bouncer = Bouncer(pg, tmp_path / "bouncer")
await bouncer.start()
yield bouncer
await bouncer.cleanup()
@pytest.fixture(autouse=True)
def pg_log(pg):
"""Prints the Postgres logs that were created during the test
This can be useful for debugging a failure.
"""
with pg.log_path.open() as f:
f.seek(0, os.SEEK_END)
yield
print("\n\nPG_LOG\n")
print(f.read())
@pytest.fixture(autouse=True)
def pg_reset(pg):
"""Resets any changes to Postgres settings from previous tests"""
pg.reset_hba()
os.truncate(pg.pgdata / "postgresql.auto.conf", 0)
# If a previous test restarted postgres, it was probably because of some
# config that could only be changed across restarts. To reset those, we'll
# have to restart it again. In other cases a reload should be enough to
# reset the configuration.
if pg.restarted:
pg.restart()
pg.restarted = False
else:
pg.reload()
yield
pgbouncer-1.24.1/test/utils.py 0000644 0001750 0000000 00000117337 14777762222 013214 0000000 0000000 import subprocess
from contextlib import closing, contextmanager
from pathlib import Path
try:
from contextlib import asynccontextmanager
except ImportError:
# Fallback for python3.6
from contextlib2 import asynccontextmanager
import asyncio
import os
import platform
import re
import shlex
import signal
import socket
import sys
import time
import typing
from tempfile import gettempdir
import filelock
import psycopg
import psycopg.sql
from psycopg import sql
TEST_DIR = Path(os.path.dirname(os.path.realpath(__file__)))
os.chdir(TEST_DIR)
PGDATA = TEST_DIR / "pgdata"
PGHOST = "127.0.0.1"
BOUNCER_LOG = TEST_DIR / "test.log"
BOUNCER_INI = TEST_DIR / "test.ini"
BOUNCER_AUTH = TEST_DIR / "userlist.txt"
BOUNCER_PID = TEST_DIR / "test.pid"
BOUNCER_PORT = 6667
BOUNCER_EXE = TEST_DIR / "../pgbouncer"
NEW_CA_SCRIPT = TEST_DIR / "ssl" / "newca.sh"
NEW_SITE_SCRIPT = TEST_DIR / "ssl" / "newsite.sh"
ENABLE_VALGRIND = bool(os.environ.get("ENABLE_VALGRIND"))
HAVE_IPV6_LOCALHOST = bool(os.environ.get("HAVE_IPV6_LOCALHOST"))
USE_SUDO = bool(os.environ.get("USE_SUDO"))
# The tests require that psql can connect to the PgBouncer admin
# console. On platforms that have getpeereid(), this works by
# connecting as user pgbouncer over the Unix socket. On other
# platforms, we have to rely on "trust" authentication, but then we
# have to skip any tests that use authentication methods other than
# "trust".
if os.name == "nt":
USE_UNIX_SOCKETS = False
HAVE_GETPEEREID = False
# psycopg only supports WindowsSelectorEventLoopPolicy
from asyncio import WindowsSelectorEventLoopPolicy
asyncio.set_event_loop_policy(WindowsSelectorEventLoopPolicy())
WINDOWS = True
else:
USE_UNIX_SOCKETS = True
HAVE_GETPEEREID = True
WINDOWS = False
LINUX = False
MACOS = False
FREEBSD = False
OPENBSD = False
if platform.system() == "Linux":
LINUX = True
elif platform.system() == "Darwin":
MACOS = True
elif platform.system() == "FreeBSD":
FREEBSD = True
elif platform.system() == "OpenBSD":
OPENBSD = True
BSD = MACOS or FREEBSD or OPENBSD
def eprint(*args, **kwargs):
"""eprint prints to stderr"""
print(*args, file=sys.stderr, **kwargs)
def run(command, *args, check=True, shell=None, silent=False, **kwargs):
"""run runs the given command and prints it to stderr"""
if shell is None:
shell = isinstance(command, str)
if not shell:
command = list(map(str, command))
if not silent:
if shell:
eprint(f"+ {command}")
else:
# We could normally use shlex.join here, but it's not available in
# Python 3.6 which we still like to support
unsafe_string_cmd = " ".join(map(shlex.quote, command))
eprint(f"+ {unsafe_string_cmd}")
if silent:
kwargs.setdefault("stdout", subprocess.DEVNULL)
return subprocess.run(command, *args, check=check, shell=shell, **kwargs)
def sudo(command, *args, shell=None, **kwargs):
"""
A version of run that prefixes the command with sudo when the process is
not already run as root
"""
effective_user_id = os.geteuid()
if effective_user_id == 0:
return run(command, *args, shell=shell, **kwargs)
if shell is None:
shell = isinstance(command, str)
if shell:
return run(f"sudo {command}", *args, shell=shell, **kwargs)
else:
return run(["sudo", *command], *args, shell=shell, **kwargs)
def capture(command, *args, stdout=subprocess.PIPE, encoding="utf-8", **kwargs):
return run(command, *args, stdout=stdout, encoding=encoding, **kwargs).stdout
def get_pg_major_version():
full_version_string = capture("initdb --version", silent=True)
major_version_string = re.search("[0-9]+", full_version_string)
assert major_version_string is not None
return int(major_version_string.group(0))
PG_MAJOR_VERSION = get_pg_major_version()
def get_max_password_length():
with open("../include/bouncer.h", encoding="utf-8") as f:
match = re.search(r"#define MAX_PASSWORD\s+([0-9].*)", f.read())
assert match is not None
max_password_length = int(match.group(1))
assert max_password_length >= 996
if max_password_length > 996 and PG_MAJOR_VERSION < 14:
return 996
return max_password_length
PKT_BUF_SIZE = 4096
MAX_PASSWORD_LENGTH = get_max_password_length()
LONG_PASSWORD = "a" * (MAX_PASSWORD_LENGTH - 1)
PG_SUPPORTS_SCRAM = PG_MAJOR_VERSION >= 10
# psycopg.Pipeline.is_supported() does not work on rocky:8 in CI, so we create
# our own check here that works on all our supported systems
LIBPQ_SUPPORTS_PIPELINING = psycopg.pq.version() >= 140000
def get_tls_support():
with open("../config.mak", encoding="utf-8") as f:
match = re.search(r"tls_support = (\w+)", f.read())
assert match is not None
return match.group(1) == "yes"
TLS_SUPPORT = get_tls_support()
# this is out of ephemeral port range for many systems hence
# it is a lower change that it will conflict with "in-use" ports
PORT_LOWER_BOUND = 10200
# ephemeral port start on many Linux systems
PORT_UPPER_BOUND = 32768
next_port = PORT_LOWER_BOUND
def cleanup_test_leftovers(*nodes):
"""
Cleaning up test leftovers needs to be done in a specific order, because
some of these leftovers depend on others having been removed. They might
even depend on leftovers on other nodes being removed. So this takes a list
of nodes, so that we can clean up all test leftovers globally in the
correct order.
"""
for node in nodes:
node.cleanup_subscriptions()
for node in nodes:
node.cleanup_publications()
for node in nodes:
node.cleanup_replication_slots()
for node in nodes:
node.cleanup_schemas()
for node in nodes:
node.cleanup_users()
class PortLock:
def __init__(self):
global next_port
while True:
next_port += 1
if next_port >= PORT_UPPER_BOUND:
next_port = PORT_LOWER_BOUND
self.lock = filelock.FileLock(Path(gettempdir()) / f"port-{next_port}.lock")
try:
self.lock.acquire(timeout=0)
except filelock.Timeout:
continue
with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
try:
s.bind(("127.0.0.1", next_port))
self.port = next_port
break
except Exception:
continue
def release(self):
self.lock.release()
def notice_handler(diag: psycopg.errors.Diagnostic):
print(f"{diag.severity}: {diag.message_primary}")
if diag.message_detail:
print(f"DETAIL: {diag.message_detail}")
if diag.message_hint:
print(f"HINT: {diag.message_hint}")
if diag.context:
print(f"CONTEXT: {diag.context}")
class QueryRunner:
def __init__(self, host, port):
self.host = host
self.port = port
self.default_db = "postgres"
self.default_user = "postgres"
# Used to track objects that we want to clean up at the end of a test
self.subscriptions = set()
self.publications = set()
self.replication_slots = set()
self.schemas = set()
self.users = set()
def set_default_connection_options(self, options):
"""Sets the default connection options on the given options dictionary"""
options.setdefault("dbname", self.default_db)
options.setdefault("user", self.default_user)
options.setdefault("host", self.host)
options.setdefault("port", self.port)
if ENABLE_VALGRIND:
# If valgrind is enabled PgBouncer is a significantly slower to
# respond to connection requests, so we wait a little longer.
options.setdefault("connect_timeout", 20)
else:
options.setdefault("connect_timeout", 3)
# Always required for Ubuntu 18.04, but also needed for any tests
# involving the varcache_change database. The difference between the
# client_encoding specified in the config and client_encoding by the
# client will force a varcache change when a connection is given.
options.setdefault("client_encoding", "UTF8")
return options
def make_conninfo(self, **kwargs) -> str:
self.set_default_connection_options(kwargs)
return psycopg.conninfo.make_conninfo(**kwargs)
def conn(self, *, autocommit=True, **kwargs):
"""Open a psycopg connection to this server"""
self.set_default_connection_options(kwargs)
conn = psycopg.connect(
autocommit=autocommit,
**kwargs,
)
conn.add_notice_handler(notice_handler)
return conn
def aconn(self, *, autocommit=True, **kwargs):
"""Open an asynchronous psycopg connection to this server"""
self.set_default_connection_options(kwargs)
return psycopg.AsyncConnection.connect(
autocommit=autocommit,
**kwargs,
)
@contextmanager
def cur(self, autocommit=True, **kwargs):
"""Open an psycopg cursor to this server
The connection and the cursors automatically close once you leave the
"with" block
"""
with self.conn(
autocommit=autocommit,
**kwargs,
) as conn:
with conn.cursor() as cur:
yield cur
@asynccontextmanager
async def acur(self, **kwargs):
"""Open an asynchronous psycopg cursor to this server
The connection and the cursors automatically close once you leave the
"async with" block
"""
async with await self.aconn(**kwargs) as conn:
async with conn.cursor() as cur:
yield cur
def sql(self, query, params=None, **kwargs):
"""Run an SQL query
This opens a new connection and closes it once the query is done
"""
with self.cur(**kwargs) as cur:
cur.execute(query, params=params)
try:
return cur.fetchall()
except psycopg.ProgrammingError as e:
if "the last operation didn't produce a result" == str(e):
return None
raise
def sql_value(self, query, params=None, **kwargs):
"""Run an SQL query that returns a single cell and return this value
This opens a new connection and closes it once the query is done
"""
with self.cur(**kwargs) as cur:
cur.execute(query, params=params)
result = cur.fetchall()
assert len(result) == 1
assert len(result[0]) == 1
value = result[0][0]
return value
def asql(self, query, **kwargs):
"""Run an SQL query in asynchronous task
This opens a new connection and closes it once the query is done
"""
return asyncio.ensure_future(self.asql_coroutine(query, **kwargs))
async def asql_coroutine(
self, query, params=None, **kwargs
) -> typing.Optional[typing.List[typing.Any]]:
async with self.acur(**kwargs) as cur:
await cur.execute(query, params=params)
try:
return await cur.fetchall()
except psycopg.ProgrammingError as e:
if "the last operation didn't produce a result" == str(e):
return None
raise
def psql(self, query, **kwargs):
"""Run an SQL query using psql instead of psycopg
This opens a new connection and closes it once the query is done
"""
self.set_default_connection_options(kwargs)
connect_options = " ".join([f"{k}={v}" for k, v in kwargs.items()])
run(["psql", f"port={self.port} {connect_options}", "-c", query], shell=False)
@contextmanager
def transaction(self, **kwargs):
with self.cur(**kwargs) as cur:
with cur.connection.transaction():
yield cur
def sleep(self, duration=3, **kwargs):
"""Run pg_sleep"""
return self.sql(f"select pg_sleep({duration})", **kwargs)
def asleep(self, duration=3, times=1, sequentially=False, **kwargs):
"""Run pg_sleep asynchronously in a task.
times:
You can create a single task that opens multiple connections, which
run pg_sleep concurrently. The asynchronous task will only complete
once all these pg_sleep calls are finished.
sequentially:
Instead of running all pg_sleep calls spawned by providing
times > 1 concurrently, this will run them sequentially.
"""
return asyncio.ensure_future(
self.asleep_coroutine(
duration=duration, times=times, sequentially=sequentially, **kwargs
)
)
async def asleep_coroutine(self, duration=3, times=1, sequentially=False, **kwargs):
"""This is the coroutine that the asleep task runs internally"""
if not sequentially:
await asyncio.gather(
*[
self.asql(f"select pg_sleep({duration})", **kwargs)
for _ in range(times)
]
)
else:
for _ in range(times):
await self.asql(f"select pg_sleep({duration})", **kwargs)
def test(self, **kwargs):
"""Test if you can connect"""
return self.sql("select 1", **kwargs)
def atest(self, **kwargs):
"""Test if you can connect asynchronously"""
return self.asql("select 1", **kwargs)
def psql_test(self, **kwargs):
"""Test if you can connect with psql instead of psycopg"""
return self.psql("select 1", **kwargs)
@contextmanager
def enable_firewall(self):
"""Enables the firewall for the platform that you are running
Normally this should not be called directly, and instead drop_traffic
or reject_traffic should be used.
"""
fw_token = None
if BSD:
if MACOS:
command_stderr = sudo(
f"pfctl -E", stderr=subprocess.PIPE, text=True
).stderr
match = re.search(r"^Token : (\d+)", command_stderr, flags=re.MULTILINE)
assert match is not None
fw_token = match.group(1)
sudo(
'bash -c "'
f"echo 'anchor \\\"port_{self.port}\\\"'"
f' | pfctl -a pgbouncer_test -f -"'
)
try:
yield
finally:
if MACOS:
sudo(f"pfctl -X {fw_token}")
@contextmanager
def drop_traffic(self):
"""Drops all TCP packets to this query runner"""
with self.enable_firewall():
if LINUX:
sudo(
"iptables --append OUTPUT "
"--protocol tcp "
f"--destination {self.host} "
f"--destination-port {self.port} "
"--jump DROP "
)
elif BSD:
sudo(
"bash -c '"
f'echo "block drop out proto tcp from any to {self.host} port {self.port}"'
f"| pfctl -a pgbouncer_test/port_{self.port} -f -'"
)
else:
raise Exception("This OS cannot run this test")
try:
yield
finally:
if LINUX:
sudo(
"iptables --delete OUTPUT "
"--protocol tcp "
f"--destination {self.host} "
f"--destination-port {self.port} "
"--jump DROP "
)
elif BSD:
sudo(f"pfctl -a pgbouncer_test/port_{self.port} -F all")
@contextmanager
def reject_traffic(self):
"""Rejects all traffic to this query runner with a TCP RST message"""
with self.enable_firewall():
if LINUX:
sudo(
"iptables --append OUTPUT "
"--protocol tcp "
f"--destination {self.host} "
f"--destination-port {self.port} "
"--jump REJECT "
"--reject-with tcp-reset"
)
elif BSD:
sudo(
"bash -c '"
f'echo "block return-rst out out proto tcp from any to {self.host} port {self.port}"'
f"| pfctl -a pgbouncer_test/port_{self.port} -f -'"
)
else:
raise Exception("This OS cannot run this test")
try:
yield
finally:
if LINUX:
sudo(
"iptables --delete OUTPUT "
"--protocol tcp "
f"--destination {self.host} "
f"--destination-port {self.port} "
"--jump REJECT "
"--reject-with tcp-reset"
)
elif BSD:
sudo(f"pfctl -a pgbouncer_test/port_{self.port} -F all")
@contextmanager
def add_latency(self):
"""Adds one second of latency to all packets to this query runner"""
if not LINUX:
raise Exception("This OS cannot run this test")
sudo(
f"tc filter add dev lo parent 1:0 protocol ip prio {self.port} u32 match ip dport {self.port} 0xffff flowid 1:2"
)
try:
yield
finally:
sudo(f"tc filter del dev lo parent 1: prio {self.port}")
pass
def create_user(self, name, args: typing.Optional[psycopg.sql.Composable] = None):
self.users.add(name)
if args is None:
args = sql.SQL("")
self.sql(sql.SQL("CREATE USER {} {}").format(sql.Identifier(name), args))
def create_schema(self, name, dbname=None):
dbname = dbname or self.default_db
self.schemas.add((dbname, name))
self.sql(sql.SQL("CREATE SCHEMA {}").format(sql.Identifier(name)))
def create_publication(self, name: str, args: psycopg.sql.Composable, dbname=None):
dbname = dbname or self.default_db
self.publications.add((dbname, name))
self.sql(sql.SQL("CREATE PUBLICATION {} {}").format(sql.Identifier(name), args))
def create_logical_replication_slot(self, name, plugin):
self.replication_slots.add(name)
self.sql(
"SELECT pg_catalog.pg_create_logical_replication_slot(%s,%s)",
(name, plugin),
)
def create_physical_replication_slot(self, name):
self.replication_slots.add(name)
self.sql(
"SELECT pg_catalog.pg_create_physical_replication_slot(%s)",
(name,),
)
def create_subscription(self, name: str, args: psycopg.sql.Composable, dbname=None):
dbname = dbname or self.default_db
self.subscriptions.add((dbname, name))
self.sql(
sql.SQL("CREATE SUBSCRIPTION {} {}").format(sql.Identifier(name), args)
)
def cleanup_users(self):
for user in self.users:
self.sql(sql.SQL("DROP USER IF EXISTS {}").format(sql.Identifier(user)))
def cleanup_schemas(self):
for dbname, schema in self.schemas:
self.sql(
sql.SQL("DROP SCHEMA IF EXISTS {} CASCADE").format(
sql.Identifier(schema)
),
dbname=dbname,
)
def cleanup_publications(self):
for dbname, publication in self.publications:
self.sql(
sql.SQL("DROP PUBLICATION IF EXISTS {}").format(
sql.Identifier(publication)
),
dbname=dbname,
)
def cleanup_replication_slots(self):
for slot in self.replication_slots:
start = time.time()
while True:
try:
self.sql(
"SELECT pg_drop_replication_slot(slot_name) FROM pg_replication_slots WHERE slot_name = %s",
(slot,),
)
except psycopg.errors.ObjectInUse:
if time.time() < start + 10:
time.sleep(0.5)
continue
raise
break
def cleanup_subscriptions(self):
for dbname, subscription in self.subscriptions:
try:
self.sql(
sql.SQL("ALTER SUBSCRIPTION {} DISABLE").format(
sql.Identifier(subscription)
),
dbname=dbname,
)
except psycopg.errors.UndefinedObject:
# Subscription didn't exist already
continue
self.sql(
sql.SQL("ALTER SUBSCRIPTION {} SET (slot_name = NONE)").format(
sql.Identifier(subscription)
),
dbname=dbname,
)
self.sql(
sql.SQL("DROP SUBSCRIPTION {}").format(sql.Identifier(subscription)),
dbname=dbname,
)
def debug(self):
print("Connect manually to:\n ", repr(self.make_conninfo()))
print("Press Enter to continue running the test...")
input()
def psql_debug(self, **kwargs):
conninfo = self.make_conninfo(**kwargs)
run(
["psql", conninfo],
silent=True,
)
class Postgres(QueryRunner):
def __init__(self, pgdata):
self.port_lock = PortLock()
super().__init__("127.0.0.1", self.port_lock.port)
self.pgdata = pgdata
self.log_path = self.pgdata / "pg.log"
self.connections = {}
self.cursors = {}
self.restarted = False
def initdb(self):
run(
f"initdb -A trust --nosync --username postgres --pgdata {self.pgdata}",
stdout=subprocess.DEVNULL,
)
with self.conf_path.open(mode="a") as pgconf:
if USE_UNIX_SOCKETS:
pgconf.write("unix_socket_directories = '/tmp'\n")
pgconf.write("log_connections = on\n")
pgconf.write("log_disconnections = on\n")
pgconf.write("logging_collector = off\n")
# Allow CREATE SUBSCRIPTION to work
pgconf.write("wal_level = 'logical'\n")
# Faster logical replication status update so tests with logical replication
# run faster
pgconf.write("wal_receiver_status_interval = 1\n")
# Faster logical replication apply worker launch so tests with logical
# replication run faster. This is used in ApplyLauncherMain in
# src/backend/replication/logical/launcher.c.
pgconf.write("wal_retrieve_retry_interval = '250ms'\n")
# Make sure there's enough logical replication resources for our
# tests
if PG_MAJOR_VERSION >= 10:
pgconf.write("max_logical_replication_workers = 5\n")
pgconf.write("max_wal_senders = 5\n")
pgconf.write("max_replication_slots = 10\n")
pgconf.write("max_worker_processes = 20\n")
# We need to make the log go to stderr so that the tests can
# check what is being logged. This should be the default, but
# some packagings change the default configuration.
pgconf.write("log_destination = stderr\n")
# This makes tests run faster and we don't care about crash safety
# of our test data.
pgconf.write("fsync = false\n")
# Use a consistent value across postgres versions, so test results
# are the same.
pgconf.write("extra_float_digits = 1\n")
# Make sure this is consistent across platforms
pgconf.write("datestyle = 'iso, mdy'\n")
# Make PostgreSQL listen on both IPv4 and IPv6 (if supported)
if HAVE_IPV6_LOCALHOST:
pgconf.write("listen_addresses='127.0.0.1,::1'\n")
def pgctl(self, command, **kwargs):
run(f"pg_ctl -w --pgdata {self.pgdata} {command}", **kwargs)
def apgctl(self, command, **kwargs):
return asyncio.create_subprocess_shell(
f"pg_ctl -w --pgdata {self.pgdata} {command}", **kwargs
)
def start(self):
try:
self.pgctl(f'-o "-p {self.port}" -l {self.log_path} start')
except Exception:
print("\n\nPG_LOG\n")
with self.log_path.open() as f:
print(f.read())
raise
def stop(self):
self.pgctl("-m fast stop", check=False)
def cleanup(self):
self.stop()
self.port_lock.release()
def restart(self):
self.restarted = True
self.stop()
self.start()
def reload(self):
if WINDOWS:
# SIGHUP and thus reload don't exist on Windows
self.restart()
else:
self.pgctl("reload")
time.sleep(1)
async def arestart(self):
process = await self.apgctl("-m fast restart")
await process.communicate()
def nossl_access(self, dbname, auth_type, user="all"):
"""Prepends a local non-SSL access to the HBA file"""
with self.hba_path.open() as pghba:
old_contents = pghba.read()
with self.hba_path.open(mode="w") as pghba:
if USE_UNIX_SOCKETS:
pghba.write(f"local {dbname} {user} {auth_type}\n")
pghba.write(f"hostnossl {dbname} {user} 127.0.0.1/32 {auth_type}\n")
pghba.write(f"hostnossl {dbname} {user} ::1/128 {auth_type}\n")
pghba.write(old_contents)
def ssl_access(self, dbname, auth_type, user="all"):
"""Prepends a local SSL access rule to the HBA file"""
with self.hba_path.open() as pghba:
old_contents = pghba.read()
with self.hba_path.open(mode="w") as pghba:
pghba.write(f"hostssl {dbname} {user} 127.0.0.1/32 {auth_type}\n")
pghba.write(f"hostssl {dbname} {user} ::1/128 {auth_type}\n")
pghba.write(old_contents)
@property
def hba_path(self):
return self.pgdata / "pg_hba.conf"
@property
def conf_path(self):
return self.pgdata / "postgresql.conf"
def commit_hba(self):
"""Mark the current HBA contents as non-resettable by reset_hba"""
with self.hba_path.open() as pghba:
old_contents = pghba.read()
with self.hba_path.open(mode="w") as pghba:
pghba.write("# committed-rules\n")
pghba.write(old_contents)
def reset_hba(self):
"""Remove any HBA rules that were added after the last call to commit_hba"""
with self.hba_path.open() as f:
hba_contents = f.read()
committed = hba_contents[hba_contents.find("# committed-rules\n") :]
with self.hba_path.open("w") as f:
f.write(committed)
def connection_count(self, dbname=None, users=("bouncer",)):
"""Returns the number of connections that are active
You can pass values for dbname and users to only count connections
for a certain database and/or user(s).
"""
dbname_filter = ""
if dbname:
dbname_filter = f" and datname='{dbname}'"
return self.sql_value(
f"select count(1) from pg_stat_activity where usename = ANY(%s) {dbname_filter}",
params=(list(users),),
)
async def delayed_start(self, delay=1):
"""Start Postgres after a delay
NOTE: The sleep is asynchronous, but while waiting for Postgres to
start the pg_ctl start command will block the event loop. This is
currently acceptable for our usage of this method in the existing
tests and this way it was easiest to implement. However, it seems
totally reasonable to change this behaviour in the future if necessary.
"""
await asyncio.sleep(delay)
self.start()
def configure(self, config):
"""Configure specific Postgres settings using ALTER SYSTEM SET
NOTE: after configuring a call to reload or restart is needed for the
settings to become effective.
"""
self.sql(f"alter system set {config}")
@contextmanager
def log_contains(self, re_string, times=None):
"""Checks if during this with block the log matches re_string
re_string:
The regex to search for.
times:
If None, any number of matches is accepted. If a number, only that
specific number of matches is accepted.
"""
with self.log_path.open() as f:
f.seek(0, os.SEEK_END)
yield
content = f.read()
if times is None:
assert re.search(re_string, content)
else:
match_count = len(re.findall(re_string, content))
assert match_count == times
class Bouncer(QueryRunner):
def __init__(
self,
pg: Postgres,
config_dir: Path,
base_ini_path=BOUNCER_INI,
base_auth_path=BOUNCER_AUTH,
port=None,
):
if port:
self.port_lock = None
super().__init__("127.0.0.1", port)
else:
self.port_lock = PortLock()
super().__init__("127.0.0.1", self.port_lock.port)
self.process: typing.Optional[subprocess.Popen] = None
self.aprocess: typing.Optional[asyncio.subprocess.Process] = None
config_dir.mkdir()
self.config_dir = config_dir
self.ini_path = self.config_dir / "test.ini"
self.log_path = self.config_dir / "test.log"
self.auth_path = self.config_dir / "userlist.txt"
self.default_db = "p0"
self.pg = pg
if USE_UNIX_SOCKETS:
if LINUX:
# On Linux we do so_reuseport tests with multiple pgbouncer
# processes listening on the same port. This requires that each
# of the pgbouncer processes should have a unique
# unix_socket_dir. We use the known-unique config_dir for this.
# You would expect we could do the same for other platforms
# too. But UNIX sockets cannot have paths longer than 103
# characters on and the config_dir chosen by pytest on MacOS
# exceeds this limit. So we use /tmp everywhere except for
# Linux.
self.admin_host = str(self.config_dir)
else:
self.admin_host = "/tmp"
else:
self.admin_host = "127.0.0.1"
self.admin_runner = QueryRunner(self.admin_host, self.port)
self.admin_runner.default_db = "pgbouncer"
self.admin_runner.default_user = "pgbouncer"
with open(base_auth_path) as base_auth:
with self.auth_path.open("w") as auth:
auth.write(base_auth.read())
auth.write(f'"longpass" "{LONG_PASSWORD}"\n')
auth.flush()
with open(base_ini_path) as base_ini:
with self.ini_path.open("w") as ini:
ini.write(base_ini.read().replace("port=6666", f"port={pg.port}"))
ini.write("\n")
ini.write(f"logfile = {self.log_path}\n")
ini.write(f"auth_file = {self.auth_path}\n")
ini.write("pidfile = \n")
# Uncomment for much more noise but, more detailed debugging
# ini.write("verbose = 3\n")
if not USE_UNIX_SOCKETS:
ini.write(f"unix_socket_dir = \n")
ini.write(f"admin_users = pgbouncer\n")
else:
ini.write(f"unix_socket_dir = {self.admin_host}\n")
ini.write(f"listen_port = {self.port}\n")
ini.flush()
def base_command(self):
"""returns the basecommand that is used to run PgBouncer
This includes valgrind and all its arguments when ENABLE_VALGRIND is
set
"""
if ENABLE_VALGRIND:
valgrind_log_file = self.config_dir / "valgrind.%p.log"
return [
"valgrind",
"--quiet",
"--leak-check=full",
"--show-reachable=no",
"--track-origins=yes",
"--error-markers=VALGRIND-ERROR-BEGIN,VALGRIND-ERROR-END",
f"--log-file={valgrind_log_file}",
str(BOUNCER_EXE),
]
return [str(BOUNCER_EXE)]
async def start(self):
# Due to using WindowsSelectorEventLoopPolicy for support with psycopg
# we cannot use asyncio subprocesses. Since this eventloop does not
# support it. We fall back to regular subprocesses.
if WINDOWS:
self.process = subprocess.Popen(
[*self.base_command(), "--quiet", self.ini_path], close_fds=True
)
else:
self.aprocess = await asyncio.create_subprocess_exec(
*self.base_command(), "--quiet", str(self.ini_path), close_fds=True
)
await self.wait_until_running()
async def wait_until_running(self):
tries = 1
while True:
try:
await self.aadmin("show version")
except psycopg.Error:
if tries > 50:
self.print_logs()
raise
tries += 1
time.sleep(0.1)
continue
break
def admin(self, query, **kwargs):
"""Run an SQL query on the PgBouncer admin database"""
return self.admin_runner.sql(query, **kwargs)
def admin_value(self, query, **kwargs):
"""Run an SQL query on the PgBouncer admin database that returns only a
single cell and return this value"""
return self.admin_runner.sql_value(query, **kwargs)
def aadmin(self, query, **kwargs):
"""Run an SQL query on the PgBouncer admin database in an asynchronous
task"""
return self.admin_runner.asql(query, **kwargs)
def running(self):
if self.process:
return self.process.poll() is None
if self.aprocess:
return self.aprocess.returncode is None
return False
async def wait_for_exit(self):
if self.process is not None:
self.process.communicate()
self.process.wait()
if self.aprocess is not None:
await self.aprocess.communicate()
await self.aprocess.wait()
self.process = None
self.aprocess = None
async def stop(self):
if not WINDOWS:
self.sigquit()
else:
# Windows does not have SIGQUIT, so call terminate() twice to
# trigger fast exit
if self.process is not None:
self.process.terminate()
self.process.terminate()
if self.aprocess is not None:
self.aprocess.terminate()
self.aprocess.terminate()
await self.wait_for_exit()
async def reboot(self):
"""Starts a new PgBouncer with the --reboot flag
This new PgBouncer process will replace the current process and take
over its non-SSL sockets.
"""
assert self.aprocess is not None or self.process is not None
if self.aprocess:
old_process = self.aprocess
old_pid = old_process.pid
self.aprocess = await asyncio.create_subprocess_exec(
*self.base_command(),
"--reboot",
"--quiet",
str(self.ini_path),
close_fds=True,
)
await old_process.communicate()
await old_process.wait()
await self.wait_until_running()
assert self.aprocess.pid != old_pid
if self.process:
old_process = self.process
old_pid = old_process.pid
self.process = subprocess.Popen(
[*self.base_command(), "--reboot", "--quiet", self.ini_path],
close_fds=True,
)
old_process.communicate()
old_process.wait()
await self.wait_until_running()
assert self.process.pid != old_pid
def send_signal(self, sig):
if self.aprocess:
self.aprocess.send_signal(sig)
if self.process:
self.process.send_signal(sig)
def sighup(self):
self.send_signal(signal.SIGHUP)
time.sleep(1)
def sigterm(self):
self.send_signal(signal.SIGTERM)
def sigint(self):
self.send_signal(signal.SIGINT)
def sigquit(self):
self.send_signal(signal.SIGQUIT)
def sigusr2(self):
self.send_signal(signal.SIGUSR2)
def print_logs(self):
print(f"\n\nBOUNCER_LOG {self.config_dir}\n")
log_contents = ""
try:
with self.log_path.open() as f:
log_contents = f.read()
print(log_contents)
except Exception:
pass
# Most reliable way to detect Assert failures. Otherwise we might miss
# Assert failures at the end of the test run.
assert not re.search("FATAL.*Assert", log_contents)
# None of our tests should have a query in progress on the server when
# the client disconnects. If this fails it almost certainly indicates a
# bug in our outstanding request tracking.
assert "client disconnected with query in progress" not in log_contents
if ENABLE_VALGRIND:
failed_valgrind = False
for valgrind_log in self.config_dir.glob("valgrind.*.log"):
with valgrind_log.open() as f:
contents = f.read()
if "VALGRIND-ERROR" in contents:
failed_valgrind = True
print(f"\n\nVALGRIND LOG {valgrind_log}\n")
print(contents)
assert not failed_valgrind
async def cleanup(self):
try:
cleanup_test_leftovers(self)
await self.stop()
finally:
self.print_logs()
if self.port_lock:
self.port_lock.release()
def write_ini(self, config):
"""Writes a config to the ini file of this PgBouncer
It appends a newline automatically. To apply these changes PgBouncer
still needs to be reloaded or restarted. To reload in a cross platform
way you need can use admin("reload").
"""
with self.ini_path.open("a") as f:
f.write(config + "\n")
@contextmanager
def log_contains(self, re_string, times=None):
"""Checks if during this with block the log matches re_string
re_string:
The regex to search for.
times:
If None, any number of matches is accepted. If a number, only that
specific number of matches is accepted.
"""
with self.log_path.open() as f:
f.seek(0, os.SEEK_END)
yield
content = f.read()
if times is None:
assert re.search(re_string, content)
else:
match_count = len(re.findall(re_string, content))
assert match_count == times
@contextmanager
def run_with_config(self, config):
"""Run the pgbouncer instance with provided config and restore the
previous config after execution
config:
A new pgbouncer config in ini format
"""
with self.ini_path.open("r") as f:
config_old = f.read()
with self.ini_path.open("w") as f:
f.write(config)
try:
self.admin("RELOAD")
yield self
finally:
# Code to release resource, e.g.:
with self.ini_path.open("w") as f:
f.write(config_old)
self.admin("RELOAD")
pgbouncer-1.24.1/test/test_peering.py 0000644 0001750 0000000 00000011570 14777762222 014534 0000000 0000000 import asyncio
import time
from concurrent.futures import ThreadPoolExecutor
from typing import Dict
import psycopg
import pytest
from .utils import LINUX, Bouncer
if not LINUX:
pytest.skip(allow_module_level=True, reason="peering tests require so_reuseport")
@pytest.mark.asyncio
@pytest.fixture
async def peers(pg, tmp_path):
peers: Dict[int, Bouncer] = {}
peers[1] = Bouncer(pg, tmp_path / "bouncer1")
peers[2] = Bouncer(pg, tmp_path / "bouncer2", port=peers[1].port)
peers[3] = Bouncer(pg, tmp_path / "bouncer3", port=peers[1].port)
for own_index, bouncer in peers.items():
with bouncer.ini_path.open("a") as f:
f.write("so_reuseport=1\n")
f.write(f"peer_id={own_index}\n")
f.write("[peers]\n")
for other_index, peer in peers.items():
if own_index == other_index:
continue
f.write(f"{other_index} = host={peer.admin_host} port={peer.port}\n")
await asyncio.gather(*[p.start() for p in peers.values()])
yield peers
await asyncio.gather(*[p.cleanup() for p in peers.values()])
def test_peering_without_own_index(peers):
with peers[1].cur() as cur:
with ThreadPoolExecutor(max_workers=2) as pool:
for _ in range(10):
query = pool.submit(cur.execute, "select pg_sleep(5)")
time.sleep(0.5)
cancel = pool.submit(cur.connection.cancel)
cancel.result()
with pytest.raises(
psycopg.errors.QueryCanceled, match="due to user request"
):
query.result()
def test_peering_with_own_index(peers):
for own_index, bouncer in peers.items():
with bouncer.ini_path.open("a") as f:
f.write(f"{own_index} = host={bouncer.admin_host} port={bouncer.port}\n")
bouncer.admin("reload")
with peers[1].cur() as cur:
with ThreadPoolExecutor(max_workers=2) as pool:
for _ in range(10):
query = pool.submit(cur.execute, "select pg_sleep(5)")
time.sleep(0.5)
cancel = pool.submit(cur.connection.cancel)
cancel.result()
with pytest.raises(
psycopg.errors.QueryCanceled, match="due to user request"
):
query.result()
async def test_rolling_restart_admin(peers):
# Stop 2 of the 3 peers, so that we know we connect to peer 1
await peers[2].stop()
await peers[3].stop()
with peers[1].cur() as cur:
cur.execute("select 1")
# Trigger a shutdown, but the process should keep running until we
# close the connection
peers[1].admin("shutdown wait_for_clients")
time.sleep(1)
assert peers[1].running()
# New connection attempts are now expected to fail, because no process
# is listening on the port. Under normal usage you would continue to
# leave at least one running. But for testing purposes this is the
# easiest way to show that peer[1] is not accepting new connections
# anymore.
with pytest.raises(psycopg.OperationalError, match="Connection refused"):
peers[1].test()
# But the existing connection is still be allowed to execute any
# queries.
cur.execute("select 1")
await peers[2].start()
# Now that peer[2] is running again, new connections should start
# working too.
peers[1].test()
# Now that the connection is closed, peer[1] should exit automatically.
await peers[1].wait_for_exit()
assert not peers[1].running()
async def test_rolling_restart_sigterm(peers):
# Stop 2 of the 3 peers, so that we know we connect to peer 1
await peers[2].stop()
await peers[3].stop()
with peers[1].cur() as cur:
cur.execute("select 1")
# Trigger a shutdown, but the process should keep running until we
# close the connection
peers[1].sigterm()
time.sleep(1)
assert peers[1].running()
# New connection attempts are now expected to fail, because no process
# is listening on the port. Under normal usage you would continue to
# leave at least one running. But for testing purposes this is the
# easiest way to show that peer[1] is not accepting new connections
# anymore.
with pytest.raises(psycopg.OperationalError, match="Connection refused"):
peers[1].test()
# But the existing connection is still be allowed to execute any
# queries.
cur.execute("select 1")
await peers[2].start()
# Now that peer[2] is running again, new connections should start
# working too.
peers[1].test()
# Now that the connection is closed, peer[1] should exit automatically.
await peers[1].wait_for_exit()
assert not peers[1].running()
pgbouncer-1.24.1/test/test_load_balance_hosts.py 0000644 0001750 0000000 00000003433 14777762222 016706 0000000 0000000 import re
import psycopg
import pytest
@pytest.mark.asyncio
async def test_load_balance_hosts_disable_good_first(bouncer):
with bouncer.log_contains(r"127.0.0.1:\d+ new connection to server", 2):
await bouncer.asleep(dbname="hostlist_good_first", duration=0.5, times=2)
@pytest.mark.asyncio
async def test_load_balance_hosts_disable_bad_first(bouncer):
bouncer.admin(f"set server_login_retry=1")
with bouncer.log_contains(r"closing because: server DNS lookup failed", 1):
with bouncer.log_contains(r"127.0.0.1:\d+ new connection to server", 2):
# Execute two concurrent sleeps to force two backend connections.
# The first connection will attempt the "bad" host and retry on
# the "good" host.
# The second connection will honor `load_balance_hosts` and use the
# `disable` host.
await bouncer.asleep(dbname="hostlist_bad_first", duration=0.5, times=2)
def test_load_balance_hosts_reload(bouncer):
with bouncer.admin_runner.cur() as cur:
results = cur.execute("show databases").fetchall()
result = [r for r in results if r[0] == "load_balance_hosts_update"][0]
assert "disable" in result
with bouncer.ini_path.open() as f:
original = f.read()
with bouncer.ini_path.open("w") as f:
f.write(
re.sub(
r"^(load_balance_hosts_update.*load_balance_hosts=)disable",
"\\1round-robin",
original,
flags=re.MULTILINE,
)
)
bouncer.admin("reload")
with bouncer.admin_runner.cur() as cur:
results = cur.execute("show databases").fetchall()
result = [r for r in results if r[0] == "load_balance_hosts_update"][0]
assert "round-robin" in result
pgbouncer-1.24.1/test/test_operations.py 0000644 0001750 0000000 00000006544 14777762222 015273 0000000 0000000 import asyncio
import time
import psycopg
import pytest
from .utils import PG_SUPPORTS_SCRAM, WINDOWS
@pytest.mark.asyncio
@pytest.mark.skipif("WINDOWS", reason="gets stuck for some reason during takeover")
async def test_online_restart(bouncer):
for _ in range(5):
# max_client_conn = 10
# default_pool_size = 5
task = bouncer.asleep(2, dbname="p1", times=5)
await asyncio.sleep(0.5)
await bouncer.reboot()
await task
@pytest.mark.asyncio
async def test_pause_resume(bouncer):
task = bouncer.asleep(0.1, times=50, sequentially=True, connect_timeout=30)
for _ in range(5):
await bouncer.aadmin("pause")
await asyncio.sleep(1)
await bouncer.aadmin("resume")
await asyncio.sleep(1)
await task
@pytest.mark.asyncio
async def test_suspend_resume(bouncer):
task = bouncer.asleep(0.1, times=50, sequentially=True)
for _ in range(5):
async with bouncer.admin_runner.acur() as cur:
await cur.execute("suspend")
await asyncio.sleep(1)
await cur.execute("resume")
await asyncio.sleep(1)
await task
def test_enable_disable(bouncer):
bouncer.test()
bouncer.admin("disable p0")
with pytest.raises(
psycopg.OperationalError,
match=r'database "p0" is disabled',
):
bouncer.test()
bouncer.admin("enable p0")
bouncer.test()
@pytest.mark.asyncio
async def test_database_restart(pg, bouncer):
bouncer.admin("set server_login_retry=1")
bouncer.test()
pg.restart()
bouncer.test()
tasks = []
for i in range(1, 6):
tasks.append(bouncer.asleep(i, dbname="p0"))
tasks.append(bouncer.asleep(i, dbname="p1"))
await asyncio.sleep(0.5)
if WINDOWS:
# WindowsSelectorEventLoopPolicy does not support async subprocesses,
# so we fall back to regular suprocesses here.
pg.restart()
else:
await pg.arestart()
for task in tasks:
try:
await task
except psycopg.OperationalError:
pass
bouncer.test(dbname="p0")
bouncer.test(dbname="p1")
def test_database_change(bouncer):
bouncer.admin("set server_lifetime=2")
bouncer.default_db = "p1"
assert bouncer.sql_value("select current_database()") == "p1"
with bouncer.ini_path.open() as f:
original = f.read()
with bouncer.ini_path.open("w") as f:
f.write(original.replace("dbname=p1", "dbname=p0"))
bouncer.admin("reload")
time.sleep(3)
assert bouncer.sql_value("select current_database()") == "p0"
def test_reconnect(bouncer):
pid1 = bouncer.sql_value("select pg_backend_pid()")
bouncer.admin("reconnect")
time.sleep(1)
pid2 = bouncer.sql_value("select pg_backend_pid()")
assert pid1 != pid2
@pytest.mark.asyncio
@pytest.mark.skipif("not PG_SUPPORTS_SCRAM")
@pytest.mark.skipif("WINDOWS", reason="gets stuck for some reason during takeover")
async def test_scram_takeover(bouncer):
bouncer.admin("set pool_mode=transaction")
bouncer.admin("set server_lifetime=3")
bouncer.admin("set auth_type='scram-sha-256'")
async with bouncer.acur(dbname="p62", user="scramuser1", password="foo") as cur:
await cur.execute("select 1")
await asyncio.sleep(4) # wait for server_lifetime
await bouncer.reboot()
await cur.execute("select 1")
pgbouncer-1.24.1/test/test_no_database.py 0000644 0001750 0000000 00000011401 14777762222 015334 0000000 0000000 import re
import psycopg
import pytest
def test_no_database(bouncer):
with bouncer.log_contains(r"closing because: no such database: nosuchdb"):
with pytest.raises(
psycopg.OperationalError, match="no such database: nosuchdb"
):
bouncer.test(dbname="nosuchdb")
def test_no_database_authfail(bouncer):
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(r"closing because: password authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname="nosuchdb", password="wrong")
def test_no_database_auth_user(bouncer):
bouncer.admin(f"set auth_user='pswcheck'")
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(r"closing because: password authentication failed"):
with pytest.raises(
psycopg.OperationalError, match="password authentication failed"
):
bouncer.test(dbname="nosuchdb", user="someuser", password="wrong")
def test_no_database_pg(bouncer):
with bouncer.log_contains(
r'server login failed: FATAL database "non_existing_pg_db" does not exist'
), bouncer.log_contains(
r'closing because: database "non_existing_pg_db" does not exist'
):
with pytest.raises(
psycopg.OperationalError,
match='database "non_existing_pg_db" does not exist',
):
bouncer.test(dbname="non_existing_pg_db")
def test_no_database_auto_database(bouncer):
with bouncer.ini_path.open() as f:
original = f.read()
with bouncer.ini_path.open("w") as f:
# uncomment the auto-database line
f.write(re.sub(r"^;\*", "*", original, flags=re.MULTILINE))
bouncer.admin("reload")
with bouncer.log_contains(
r'server login failed: FATAL database "nosuchdb" does not exist'
), bouncer.log_contains(r'closing because: database "nosuchdb" does not exist'):
with pytest.raises(
psycopg.OperationalError, match='database "nosuchdb" does not exist'
):
bouncer.test(dbname="nosuchdb")
def test_no_database_auto_database_auth_user(bouncer):
with bouncer.ini_path.open() as f:
original = f.read()
with bouncer.ini_path.open("w") as f:
# uncomment the auto-database line
f.write(re.sub(r"^;\*", "*", original, flags=re.MULTILINE))
bouncer.admin("reload")
bouncer.admin(f"set auth_user='pswcheck'")
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(
r'server login failed: FATAL database "nosuchdb" does not exist'
), bouncer.log_contains(r'closing because: database "nosuchdb" does not exist'):
with pytest.raises(
psycopg.OperationalError, match='database "nosuchdb" does not exist'
):
bouncer.test(dbname="nosuchdb", user="nonexistinguser")
def test_no_database_md5_auth_scram_pw_success(bouncer):
# Testing what happens on successful SCRAM auth connection to non-existent
# DB Segfaults have been seen after mock authentication was put in place
# with md5 auth and a scram PW when saving SCRAM credentials. Including
# this test to check for the condition repeating.
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(r"closing because: no such database: nosuchdb"):
with pytest.raises(
psycopg.OperationalError, match="no such database: nosuchdb"
):
bouncer.test(dbname="nosuchdb", user="scramuser1", password="foo")
def test_no_database_scram_auth_scram_pw_success(bouncer):
# Testing what happens on successful SCRAM auth with a SCRAM PW connection
# to non-existent DB. Segfaults have been seen after mock authentication
# was put in place with md5 auth and a scram PW. Including this test for
# completeness.
bouncer.admin(f"set auth_type='scram-sha-256'")
with bouncer.log_contains(r"closing because: no such database: nosuchdb"):
with pytest.raises(
psycopg.OperationalError, match="no such database: nosuchdb"
):
bouncer.test(dbname="nosuchdb", user="scramuser1", password="foo")
@pytest.mark.md5
def test_no_database_md5_auth_md5_pw_success(bouncer):
# Testing what happens on successful MD5 auth with a MD5 pw connection to
# non-existent DB Segfaults have been seen after mock authentication was
# put in place with md5 auth and a scram PW. Including this test for
# completeness.
bouncer.admin(f"set auth_type='md5'")
with bouncer.log_contains(r"closing because: no such database: nosuchdb"):
with pytest.raises(
psycopg.OperationalError, match="no such database: nosuchdb"
):
bouncer.test(dbname="nosuchdb", user="muser1", password="foo")
pgbouncer-1.24.1/test/pgbouncer_hba.conf 0000644 0001750 0000000 00000001271 14777762222 015134 0000000 0000000 # TYPE DATABASE USER ADDRESS METHOD
local all postgres peer
# do not let the "postgres" superuser login via a certificate
hostssl all postgres ::/0 reject
hostssl all postgres 0.0.0.0/0 reject
#
hostssl all all ::/0 md5
hostssl p0y all 0.0.0.0/0 cert map=test2
hostssl p0x all 0.0.0.0/0 cert map=test
hostssl p0 bouncer 0.0.0.0/0 cert
hostssl all all 192.168.1.1/0 md5
pgbouncer-1.24.1/test/test_limits.py 0000644 0001750 0000000 00000056337 14777762222 014416 0000000 0000000 import asyncio
import os
import re
import psycopg
import pytest
from psycopg.rows import dict_row
@pytest.mark.asyncio
async def test_max_client_conn(bouncer):
bouncer.default_db = "p1"
bouncer.admin(f"set max_client_conn=5")
result = bouncer.asleep(3, times=4)
await asyncio.sleep(1)
# should still be allowed, since it's the last allowed connection
await bouncer.atest()
result_last = bouncer.asleep(3)
await asyncio.sleep(1)
with pytest.raises(psycopg.OperationalError, match=r"max_client_conn"):
await bouncer.atest()
await result
await result_last
def test_max_db_client_connections_local_override_global(bouncer):
"""Test that database level max_db_client_connections overrides server level max_db_client_connections."""
test_db = "conn_limit_db"
connect_args = {"dbname": test_db, "user": "muser1"}
conns = [bouncer.conn(**connect_args) for _ in range(2)]
dbs = bouncer.admin("SHOW DATABASES", row_factory=dict_row)
db = [db for db in dbs if db["name"] == test_db][0]
assert db["current_client_connections"] == 2
assert db["max_client_connections"] == 2
with pytest.raises(psycopg.OperationalError, match=r"max_db_client_connections"):
_ = bouncer.conn(**connect_args)
with pytest.raises(psycopg.OperationalError, match=r"max_db_client_connections"):
_ = bouncer.conn(**connect_args)
for conn in conns:
conn.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "muser1"),
("pgbouncer", "pgbouncer"),
("pgbouncer", "muser1"),
("authdb", "pswcheck_not_in_auth_file"),
],
)
def test_max_db_client_connections_global_negative(
bouncer, test_db: str, test_user: str
) -> None:
"""Negative test of server wide max_db_client_connections setting."""
bouncer.admin("SET max_db_client_connections = 2")
bouncer.admin("SET stats_users = 'muser1'")
bouncer.admin("SET admin_users = 'pgbouncer'")
connect_args = {"dbname": test_db, "user": test_user}
conns = [bouncer.conn(**connect_args) for _ in range(2)]
dbs = bouncer.admin("SHOW DATABASES", row_factory=dict_row)
db = [db for db in dbs if db["name"] == test_db][0]
assert db["current_client_connections"] == 2 if test_db == "p0" else 3
assert db["max_client_connections"] == 2
if test_db == "pgbouncer" and test_user == "pgbouncer":
_ = bouncer.conn(**connect_args)
else:
with pytest.raises(
psycopg.OperationalError, match=r"max_db_client_connections"
):
_ = bouncer.conn(**connect_args)
for conn in conns:
conn.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "muser1"),
("pgbouncer", "pgbouncer"),
("pgbouncer", "muser1"),
("authdb", "pswcheck_not_in_auth_file"),
],
)
def test_max_db_client_connections_global_positive(
bouncer, test_db: str, test_user: str
) -> None:
"""Positive test of server wide max_db_client_connections setting."""
# with bouncer.run_with_config(config):
bouncer.admin("SET max_db_client_connections = 2")
bouncer.admin("SET stats_users = 'muser1'")
bouncer.admin("SET admin_users = 'pgbouncer'")
connect_args = {"dbname": test_db, "user": test_user}
conn = bouncer.conn(**connect_args)
# should still be allowed, since it's the last allowed connection
dbs = bouncer.admin("SHOW DATABASES", row_factory=dict_row)
db = [db for db in dbs if db["name"] == test_db][0]
assert db["current_client_connections"] == 1 if test_db == "p0" else 2
assert db["max_client_connections"] == 2
_ = bouncer.conn(**connect_args)
conn.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "muser1"),
("pgbouncer", "pgbouncer"),
("pgbouncer", "muser1"),
("authdb", "pswcheck_not_in_auth_file"),
],
)
def test_max_db_client_connections_decrement(
bouncer, test_db: str, test_user: str
) -> None:
"""Test that max_db_connections is correctly decremented when user closes connection."""
bouncer.admin("SET stats_users = 'muser1'")
bouncer.admin("SET admin_users = 'pgbouncer'")
connect_args = {"dbname": test_db, "user": test_user}
[conn_1, conn_2] = [bouncer.conn(**connect_args) for _ in range(2)]
dbs = bouncer.admin("SHOW DATABASES", row_factory=dict_row)
db = [db for db in dbs if db["name"] == test_db][0]
assert db["current_client_connections"] == 2 if test_db == "p0" else 3
conn_2.close()
dbs = bouncer.admin("SHOW DATABASES", row_factory=dict_row)
db = [db for db in dbs if db["name"] == test_db][0]
assert db["current_client_connections"] == 1 if test_db == "p0" else 2
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("client_limit_db", "muser1"),
("client_limit_db_auth_passthrough", "pswcheck_not_in_auth_file"),
],
)
def test_max_db_client_connections_negative(
bouncer, test_db: str, test_user: str
) -> None:
"""Negative test of database specific max_db_client_connections setting."""
connect_args = {"dbname": test_db, "user": test_user}
# with bouncer.run_with_config(config):
conns = [bouncer.conn(**connect_args) for _ in range(2)]
dbs = bouncer.admin("SHOW DATABASES", row_factory=dict_row)
db = [db for db in dbs if db["name"] == test_db][0]
assert db["current_client_connections"] == 2 if test_db == "p0" else 3
assert db["max_client_connections"] == 2
with pytest.raises(psycopg.OperationalError, match=r"max_db_client_connections"):
bouncer.conn(**connect_args)
for conn in conns:
conn.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("client_limit_db", "muser1"),
("client_limit_db_auth_passthrough", "pswcheck_not_in_auth_file"),
],
)
def test_max_db_client_connections_positive(bouncer, test_db: str, test_user) -> None:
"""Positive test of database specific max_db_client_connections setting."""
connect_args = {"dbname": test_db, "user": test_user}
# with bouncer.run_with_config(config):
conn = bouncer.conn(**connect_args)
# should still be allowed, since it's the last allowed connection
dbs = bouncer.admin("SHOW DATABASES", row_factory=dict_row)
db = [db for db in dbs if db["name"] == test_db][0]
assert db["current_client_connections"] == 1 if test_db == "p0" else 2
assert db["max_client_connections"] == 2
_ = bouncer.conn(**connect_args)
conn.close()
@pytest.mark.asyncio
async def test_pool_size(pg, bouncer):
# per user pool_size
await bouncer.asleep(0.5, dbname="p0a", user="poolsize1", times=3)
assert pg.connection_count(dbname="p0", users=("poolsize1",)) == 1
# even though we connect using user poolsize1 its setting do not apply is forced user is configured for db
await bouncer.asleep(0.5, dbname="p0", user="poolsize1", times=5)
assert pg.connection_count(dbname="p0", users=("bouncer",)) == 2
# per db pool_size
await bouncer.asleep(0.5, times=5)
assert pg.connection_count("p0") == 2
# global pool_size
bouncer.default_db = "p1"
await bouncer.asleep(0.5, times=10)
assert pg.connection_count("p1") == 5
# test reload (GH issue #248)
bouncer.admin("set default_pool_size = 7")
await bouncer.asleep(0.5, times=10)
assert pg.connection_count("p1") == 7
@pytest.mark.asyncio
async def test_min_pool_size(pg, bouncer):
# uncommenting the db that has "forced" maintenance enabled
# by not having this db enabled we avoid polluting other tests
# with connections getting autocreated
with bouncer.ini_path.open() as f:
original = f.read()
with bouncer.ini_path.open("w") as f:
# uncomment the relevant db
new = re.sub(r"^;p0z= (.+)", r"p0z= \g<1>", original, flags=re.MULTILINE)
print(new)
f.write(new)
bouncer.admin("reload")
# having to wait a little to give janitor time to create connection to satisfy min_pool_size
await asyncio.sleep(2)
# ensure db without min_pool_size has no connections
# p0
assert pg.connection_count(dbname="p0", users=("bouncer",)) == 0
# ensure db with min_pool_size and forced user (p0z) has the required
# backend connections
assert pg.connection_count(dbname="p0", users=("pswcheck",)) == 3
# ensure db with min_pool_size and no forced user (p0x) has no backend
# connections
assert pg.connection_count(dbname="p0", users=("postgres",)) == 0
# client connecting to p0x should trigger backend connection creation up to
# min_pool_size.
#
# NOTE: It's a bit tricky to get the timing of this test to work
# robustly: Full maintenance runs three times a second, so we
# need to wait at least 1/3 seconds for it to notice for sure
# that the pool is in use. When it does, it will launch one
# connection per round, so we need to wait at least 3 * 1/3
# second before all the min pool connections are launched.
# Also, we need to keep the query running while this is
# happening so that the pool doesn't become momentarily
# unused.
result = bouncer.asleep(2, dbname="p0x")
await asyncio.sleep(2)
await result
assert pg.connection_count(dbname="p0", users=("postgres",)) == 5
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "maxedout3"),
("pgbouncer", "maxedout3"),
("pgbouncer", "maxedout2"),
("pauthz", "pswcheck_not_in_auth_file"),
],
)
def test_max_user_client_connections_local_override_global(
bouncer, test_db: str, test_user: str
) -> None:
"""Test that user level overrides global connection limit.
1. Set global client connection limit
2. Grab user data from `SHOW USERS` for user with max_user_client_connections set
3. Validate that the user level max_user_client_connections is returned
Tests 4 users: normal, admin, stats, and auth pass through
"""
bouncer.admin("set max_user_client_connections=1")
bouncer.admin("set admin_users='maxedout3,pgbouncer'")
bouncer.admin("set stats_users=maxedout2")
connect_args = {"dbname": test_db, "user": test_user}
conn_1 = bouncer.conn(**connect_args)
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["max_user_client_connections"] == 2
assert user["current_client_connections"] == 1
bouncer.conn(**connect_args)
conn_1.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "maxedout4"),
("pgbouncer", "maxedout4"),
("pgbouncer", "maxedout5"),
("authdb", "pswcheck_not_in_auth_file"),
],
)
def test_max_user_client_connections_global_positive(
bouncer, test_db: str, test_user: str
) -> None:
"""Positive test for global max_user_client_connections setting."""
bouncer.admin("SET max_user_client_connections=2")
bouncer.admin("SET admin_users='maxedout4,pgbouncer'")
bouncer.admin("SET stats_users='maxedout5'")
connect_args = {"dbname": test_db, "user": test_user}
conn_1 = bouncer.conn(**connect_args)
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["max_user_client_connections"] == 2
assert user["current_client_connections"] == 1
# should still be allowed, since it's the last allowed connection
bouncer.conn(**connect_args)
conn_1.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "maxedout4"),
("pgbouncer", "maxedout4"),
("pgbouncer", "maxedout5"),
("authdb", "pswcheck_not_in_auth_file"),
],
)
def test_max_user_client_connections_global_negative(
bouncer, test_db: str, test_user: str
) -> None:
"""Negative test for max_user_client_connections setting.
Test that default user level connection limit correctly rejects connection after
2 users are connected. Also checks that user counts are correctly reflected in
SHOW USERS stats command.
Test covers admin db and real db
"""
bouncer.admin("SET max_user_client_connections=2")
bouncer.admin("SET admin_users='maxedout4,pgbouncer'")
bouncer.admin("SET stats_users='maxedout5'")
connect_args = {"dbname": test_db, "user": test_user}
conns = [bouncer.conn(**connect_args) for _ in range(2)]
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["max_user_client_connections"] == 2
assert user["current_client_connections"] == 2
# Make sure error is correctly 2 times sequentially
for _ in range(2):
if test_db == "pgbouncer" and test_user == "maxedout4":
bouncer.conn(**connect_args)
else:
with pytest.raises(
psycopg.OperationalError, match=r"max_user_client_connections"
):
bouncer.conn(**connect_args)
for conn in conns:
conn.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "maxedout3"),
("pgbouncer", "maxedout3"),
("pgbouncer", "maxedout2"),
("authdb", "pswcheck_not_in_auth_file"),
],
)
def test_max_user_client_connections_positive(
bouncer, test_db: str, test_user: str
) -> None:
"""Positive test of user level max_user_client_connections setting.
Test that user level connection limits allow users to connect up to the limit level.
Also test that SHOW USERS stats correctly reflect this number.
"""
bouncer.admin("SET max_user_client_connections=2")
bouncer.admin("SET admin_users='maxedout2,pgbouncer'")
bouncer.admin("SET stats_users='maxedout3'")
connect_args = {"dbname": test_db, "user": test_user}
conn_1 = bouncer.conn(**connect_args)
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["max_user_client_connections"] == 2
assert user["current_client_connections"] == 1
# should still be allowed, since it's the last allowed connection
conn_2 = bouncer.conn(**connect_args)
for conn in [conn_1, conn_2]:
conn.close()
@pytest.mark.parametrize(
("test_db", "test_user"),
[
("p0", "maxedout3"),
("pgbouncer", "maxedout3"),
("pgbouncer", "maxedout2"),
("authdb", "pswcheck_not_in_auth_file"),
],
)
def test_max_user_client_connections_negative(
bouncer, test_db: str, test_user: str
) -> None:
"""Negative test of user level max_user_client_connections setting.
Test that user level connection limit correctly rejects connection after
2 users are connected. Also checks that user counts are correctly reflected in
SHOW USERS stats command.
Test covers admin db and real db
"""
bouncer.admin("SET max_user_client_connections=2")
bouncer.admin("SET admin_users='maxedout2,pgbouncer'")
bouncer.admin("SET stats_users='maxedout3'")
connect_args = {"dbname": test_db, "user": test_user}
conns = [bouncer.conn(**connect_args) for _ in range(2)]
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["max_user_client_connections"] == 2
assert user["current_client_connections"] == 2
if test_db == "pgbouncer" and test_user == "maxedout2":
bouncer.conn(**connect_args)
else:
with pytest.raises(
psycopg.OperationalError, match=r"max_user_client_connections"
):
bouncer.conn(**connect_args)
for conn in conns:
conn.close()
def test_user_client_count_db_connect_fail(pg, bouncer) -> None:
test_user = "maxedout3"
test_dbname = "user_passthrough"
pg.nossl_access(dbname="p0", auth_type="reject", user=test_user)
pg.ssl_access(dbname="p0", auth_type="reject", user=test_user)
pg.reload()
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["current_client_connections"] == 0
connect_args = {"dbname": test_dbname, "user": test_user}
with pytest.raises(
psycopg.OperationalError, match="pg_hba.conf rejects connection"
):
_ = bouncer.conn(**connect_args)
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["current_client_connections"] == 0
def test_user_client_count_db_connect_fail_2(bouncer) -> None:
test_user = "pswcheck_not_in_auth_file"
test_dbname = "user_passthrough"
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["current_client_connections"] == 0
connect_args = {"dbname": test_dbname, "user": test_user}
with pytest.raises(psycopg.OperationalError, match="authentication failed"):
_ = bouncer.conn(**connect_args)
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
user = next(user for user in users if user["name"] == test_user)
assert user["current_client_connections"] == 0
def test_user_client_count_db_connect_fail_3(bouncer) -> None:
test_user = "non_existent_user"
test_dbname = "user_passthrough"
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
assert len([user for user in users if user["name"] == test_user]) == 0
connect_args = {"dbname": test_dbname, "user": test_user}
with pytest.raises(psycopg.OperationalError, match="authentication failed"):
_ = bouncer.conn(**connect_args)
users = bouncer.admin("SHOW USERS", row_factory=dict_row)
# We don't expect non-existent users which cannot authentiticate to show up
# in the stats at all. This would just pollute the stats output with people
# making typos or attackers trying random user accounts.
assert len([user for user in users if user["name"] == test_user]) == 0
def test_min_pool_size_with_lower_max_user_connections(bouncer):
# The p0x in test.init has min_pool_size set to 5. This should make
# the PgBouncer try to create a pool for maxedout2 user of size 5 after a
# client connects to the PgBouncer. However maxedout2 user has
# max_user_connections set to 2, so the final pool size should be only 2.
# Running a query for sufficient time for us to reach the final
# connection count in the pool and detect any evictions.
with bouncer.log_contains(r"new connection to server \(from", times=2):
with bouncer.log_contains("closing because: evicted", times=0):
bouncer.sleep(2, dbname="p0x", user="maxedout2")
def test_min_pool_size_with_lower_max_db_connections(bouncer):
# The p0x in test.init has min_pool_size set to 5. This should make
# the PgBouncer try to create a pool for puser1 user of size 5 after a client
# connects to the PgBouncer. However the db also has max_db_connections set
# to 2, so the final pool size should be only 2.
# Running a query for sufficient time for us to reach the final
# connection count in the pool and detect any evictions.
with bouncer.log_contains(r"new connection to server \(from", times=2):
with bouncer.log_contains("closing because: evicted", times=0):
bouncer.sleep(2, dbname="p0y", user="puser1")
@pytest.mark.asyncio
async def test_reserve_pool_size(pg, bouncer):
bouncer.admin("set reserve_pool_size = 3")
bouncer.admin("set reserve_pool_timeout = 2")
# Disable tls to get more consistent timings
bouncer.admin("set server_tls_sslmode = disable")
with bouncer.log_contains("taking connection from reserve_pool", times=3):
# default_pool_size is 5, so half of the connections will need to wait
# until the reserve_pool_timeout (2 seconds) is reached. At that point
# 3 more connections should be allowed to continue.
result = bouncer.asleep(10, dbname="p1", times=10)
await asyncio.sleep(1)
assert pg.connection_count("p1") == 5
await asyncio.sleep(8)
assert pg.connection_count("p1") == 8
await result
@pytest.mark.asyncio
async def test_user_reserve_pool_size(pg, bouncer):
bouncer.admin("set reserve_pool_timeout = 2")
# Disable tls to get more consistent timings
bouncer.admin("set server_tls_sslmode = disable")
with bouncer.log_contains("taking connection from reserve_pool", times=2):
# respoolsize1 user has a pool_size of 1 and reserve_pool_size of 2
# this means 1 connection should happen immediately while 2 out of
# the 3 remaining connections happen after reserve_pool_timeout
result = bouncer.asleep(10, dbname="p0a", user="respoolsize1", times=4)
await asyncio.sleep(1)
assert pg.connection_count(dbname="p0", users=("respoolsize1",)) == 1
await asyncio.sleep(8)
assert pg.connection_count(dbname="p0", users=("respoolsize1",)) == 3
await result
@pytest.mark.asyncio
async def test_database_reserve_pool_size(pg, bouncer):
bouncer.admin("set reserve_pool_timeout = 2")
# Disable tls to get more consistent timings
bouncer.admin("set server_tls_sslmode = disable")
with bouncer.log_contains("taking connection from reserve_pool", times=2):
# p0 db has a pool_size of 2 and reserve_pool_size of 2
# this means 2 connections should happen immediately while 2 out of
# the 3 remaining connections happen after reserve_pool_timeout
result = bouncer.asleep(10, dbname="p0", user="bouncer", times=5)
await asyncio.sleep(1)
assert pg.connection_count(dbname="p0", users=("bouncer",)) == 2
await asyncio.sleep(8)
assert pg.connection_count(dbname="p0", users=("bouncer",)) == 4
await result
@pytest.mark.asyncio
async def test_database_reserve_pool_size_old_param(pg, bouncer):
bouncer.admin("set reserve_pool_timeout = 2")
# Disable tls to get more consistent timings
bouncer.admin("set server_tls_sslmode = disable")
with bouncer.log_contains("taking connection from reserve_pool", times=2):
# p0a db has a pool_size of 2 and reserve_pool of 2
# this means 2 connections should happen immediately while 2 out of
# the 3 remaining connections happen after reserve_pool_timeout
result = bouncer.asleep(10, dbname="p0a", user="bouncer", times=5)
await asyncio.sleep(1)
assert pg.connection_count(dbname="p0", users=("bouncer",)) == 2
await asyncio.sleep(8)
assert pg.connection_count(dbname="p0", users=("bouncer",)) == 4
await result
@pytest.mark.asyncio
async def test_max_db_connections(pg, bouncer):
# some users, doesn't matter which ones
users = ["muser1", "muser2", "puser1", "puser2", "postgres"]
# p2 has max_db_connections=4
await asyncio.gather(
*[bouncer.asleep(0.5, dbname="p2", user=u, times=2) for u in users]
)
# p2 in PgBouncer maps to p0 in Postgres
assert pg.connection_count("p0", users=users) == 4
@pytest.mark.asyncio
async def test_max_user_connections(pg, bouncer):
# some users, doesn't matter which ones
dbnames = ["p7a", "p7b", "p7c"]
await asyncio.gather(
*[
bouncer.asleep(0.5, dbname=db, user="maxedout", times=3, connect_timeout=10)
for db in dbnames
]
)
assert pg.connection_count("p7", users=["maxedout"]) == 3
pgbouncer-1.24.1/test/run-conntest.sh 0000644 0001750 0000000 00000000222 14777762222 014455 0000000 0000000 #! /bin/sh
createdb conntest
../pgbouncer -d ctest6000.ini
../pgbouncer -d ctest7000.ini
./asynctest
# now run conntest.sh on another console
pgbouncer-1.24.1/test/test_ssl.py 0000644 0001750 0000000 00000036670 14777762222 013714 0000000 0000000 import subprocess
import time
import psycopg
import pytest
from .utils import MACOS, PG_MAJOR_VERSION, TEST_DIR, TLS_SUPPORT, WINDOWS, Bouncer
if not TLS_SUPPORT:
pytest.skip(allow_module_level=True)
# XXX: These test use psql to connect using sslmode=verify-full instead of
# using psycopg. The reason for this is that psycopg has a bug on Apple
# silicon when enabling SSL: https://github.com/psycopg/psycopg/discussions/270
# override regular bouncer fixture with one that uses the special SSL config
@pytest.mark.asyncio
@pytest.fixture
async def bouncer(pg, tmp_path):
bouncer = Bouncer(
pg, tmp_path / "bouncer", base_ini_path=TEST_DIR / "ssl" / "test.ini"
)
await bouncer.start()
yield bouncer
await bouncer.cleanup()
def test_server_ssl(pg, bouncer, cert_dir):
bouncer.admin("set server_tls_sslmode = require")
pg.ssl_access("all", "trust")
pg.configure("ssl=on")
root = cert_dir / "TestCA1" / "ca.crt"
pg.configure(f"ssl_ca_file='{root}'")
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
bouncer.test()
def test_server_ssl_set_disable(pg, bouncer, cert_dir):
bouncer.admin("set server_tls_sslmode = require")
pg.ssl_access("all", "trust")
pg.configure("ssl=on")
root = cert_dir / "TestCA1" / "ca.crt"
pg.configure(f"ssl_ca_file='{root}'")
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
bouncer.test()
pg.reset_hba()
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
bouncer.test() # connection is still cached
bouncer.admin("reconnect")
with pytest.raises(
psycopg.OperationalError,
match="no pg_hba.conf entry for .*, (SSL encryption|SSL on)",
):
bouncer.test()
# XXX: It would be nice if this reset server_login_retry, but it currently
# doesn't. So we have server_login_retry=1 in the ini file.
bouncer.admin("set server_tls_sslmode = disable")
bouncer.test()
def test_server_ssl_set_enable(pg, bouncer, cert_dir):
bouncer.admin("set server_tls_sslmode = disable")
pg.configure("ssl=on")
root = cert_dir / "TestCA1" / "ca.crt"
pg.configure(f"ssl_ca_file='{root}'")
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
bouncer.test()
pg.nossl_access("all", "reject")
pg.ssl_access("all", "trust")
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
bouncer.test() # connection is still cached
bouncer.admin("reconnect")
with pytest.raises(
psycopg.OperationalError,
match="pg_hba.conf rejects connection for .*, (no encryption|SSL off)",
):
bouncer.test()
# XXX: It would be nice if this reset server_login_retry, but it currently
# doesn't. So we have server_login_retry=1 in the ini file.
bouncer.admin("set server_tls_sslmode = require")
bouncer.test()
def test_server_ssl_verify(pg, bouncer, cert_dir):
bouncer.admin("set server_tls_sslmode = 'verify-full'")
root = cert_dir / "TestCA1" / "ca.crt"
wrong_root = cert_dir / "TestCA2" / "ca.crt"
bouncer.admin(f"set server_tls_ca_file = '{wrong_root}'")
pg.ssl_access("all", "trust")
pg.configure("ssl=on")
pg.configure(f"ssl_ca_file='{root}'")
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
with bouncer.log_contains(r"certificate verify failed"):
with pytest.raises(
psycopg.OperationalError,
match="connection timeout expired",
):
bouncer.test(connect_timeout=4)
bouncer.admin(f"set server_tls_ca_file = '{root}'")
bouncer.test()
def test_server_ssl_auth(pg, bouncer, cert_dir):
bouncer.admin("set server_tls_sslmode = 'verify-full'")
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "02-bouncer.key"
cert = cert_dir / "TestCA1" / "sites" / "02-bouncer.crt"
bouncer.admin(f"set server_tls_ca_file = '{root}'")
bouncer.admin(f"set server_tls_key_file = '{key}'")
bouncer.admin(f"set server_tls_cert_file = '{cert}'")
pg.ssl_access("all", "cert")
pg.configure("ssl=on")
pg.configure(f"ssl_ca_file='{root}'")
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
bouncer.test()
def test_client_ssl(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.admin(f"set client_tls_key_file = '{key}'")
bouncer.admin(f"set client_tls_cert_file = '{cert}'")
bouncer.admin(f"set client_tls_ca_file = '{root}'")
bouncer.admin(f"set client_tls_sslmode = require")
bouncer.psql_test(host="localhost", sslmode="require")
def test_client_ssl_set_enable_disable(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.admin(f"set client_tls_key_file = '{key}'")
bouncer.admin(f"set client_tls_cert_file = '{cert}'")
bouncer.admin(f"set client_tls_ca_file = '{root}'")
bouncer.admin(f"set client_tls_sslmode = require")
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
bouncer.admin(f"set client_tls_sslmode = disable")
bouncer.test(sslmode="disable")
bouncer.admin(f"set client_tls_sslmode = require")
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
def test_client_ssl_set_change_ca(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.admin(f"set client_tls_key_file = '{key}'")
bouncer.admin(f"set client_tls_cert_file = '{cert}'")
bouncer.admin(f"set client_tls_ca_file = '{root}'")
bouncer.admin(f"set client_tls_sslmode = require")
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
new_root = cert_dir / "TestCA2" / "ca.crt"
new_key = cert_dir / "TestCA2" / "sites" / "01-localhost.key"
new_cert = cert_dir / "TestCA2" / "sites" / "01-localhost.crt"
bouncer.admin(f"set client_tls_key_file = '{new_key}'")
bouncer.admin(f"set client_tls_cert_file = '{new_cert}'")
bouncer.admin(f"set client_tls_ca_file = '{new_root}'")
with pytest.raises(
subprocess.CalledProcessError,
):
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=new_root)
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
def test_client_ssl_sighup_enable_disable(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = require")
bouncer.sighup()
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
bouncer.write_ini(f"client_tls_sslmode = disable")
bouncer.sighup()
bouncer.test(sslmode="disable")
@pytest.mark.skipif("WINDOWS", reason="Windows does not have SIGHUP")
def test_client_ssl_sighup_change_ca(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = require")
bouncer.sighup()
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
new_root = cert_dir / "TestCA2" / "ca.crt"
new_key = cert_dir / "TestCA2" / "sites" / "01-localhost.key"
new_cert = cert_dir / "TestCA2" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {new_key}")
bouncer.write_ini(f"client_tls_cert_file = {new_cert}")
bouncer.write_ini(f"client_tls_ca_file = {new_root}")
bouncer.sighup()
with pytest.raises(
subprocess.CalledProcessError,
):
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=new_root)
def test_client_ssl_reload_enable_disable(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = require")
bouncer.admin("reload")
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
bouncer.write_ini(f"client_tls_sslmode = disable")
bouncer.admin("reload")
bouncer.test(sslmode="disable")
def test_client_ssl_reload_change_ca(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = require")
bouncer.admin("reload")
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
new_root = cert_dir / "TestCA2" / "ca.crt"
new_key = cert_dir / "TestCA2" / "sites" / "01-localhost.key"
new_cert = cert_dir / "TestCA2" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {new_key}")
bouncer.write_ini(f"client_tls_cert_file = {new_cert}")
bouncer.write_ini(f"client_tls_ca_file = {new_root}")
bouncer.admin("reload")
with pytest.raises(
subprocess.CalledProcessError,
):
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=root)
bouncer.psql_test(host="localhost", sslmode="verify-full", sslrootcert=new_root)
def test_client_ssl_auth(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = verify-full")
bouncer.write_ini(f"auth_type = cert")
bouncer.admin("reload")
client_key = cert_dir / "TestCA1" / "sites" / "02-bouncer.key"
client_cert = cert_dir / "TestCA1" / "sites" / "02-bouncer.crt"
bouncer.psql_test(
host="localhost",
sslmode="verify-full",
user="bouncer",
sslrootcert=root,
sslkey=client_key,
sslcert=client_cert,
)
def test_client_ssl_scram(bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = require")
bouncer.write_ini(f"auth_type = scram-sha-256")
bouncer.admin("reload")
bouncer.psql_test(
host="localhost",
user="bouncer",
password="zzzz",
sslmode="verify-full",
sslrootcert=root,
)
def test_ssl_replication(pg, bouncer, cert_dir):
root = cert_dir / "TestCA1" / "ca.crt"
key = cert_dir / "TestCA1" / "sites" / "01-localhost.key"
cert = cert_dir / "TestCA1" / "sites" / "01-localhost.crt"
bouncer.write_ini(f"server_tls_sslmode = verify-full")
bouncer.write_ini(f"server_tls_ca_file = {root}")
bouncer.write_ini(f"client_tls_sslmode = require")
bouncer.write_ini(f"client_tls_key_file = {key}")
bouncer.write_ini(f"client_tls_cert_file = {cert}")
bouncer.write_ini(f"client_tls_ca_file = {root}")
bouncer.admin("reload")
pg.ssl_access("all", "trust")
pg.ssl_access("replication", "trust", user="postgres")
pg.configure("ssl=on")
pg.configure(f"ssl_ca_file='{root}'")
if PG_MAJOR_VERSION < 10 or WINDOWS:
pg.restart()
else:
pg.reload()
# Logical rep
connect_args = {
"host": "localhost",
"dbname": "p7a",
"replication": "database",
"user": "postgres",
"application_name": "abc",
"sslmode": "verify-full",
"sslrootcert": root,
}
bouncer.psql("IDENTIFY_SYSTEM", **connect_args)
# physical rep
connect_args["replication"] = "true"
bouncer.psql("IDENTIFY_SYSTEM", **connect_args)
def test_servers_no_disconnect_on_reload_with_no_tls_change(bouncer, pg, cert_dir):
bouncer.default_db = "pTxnPool"
with bouncer.cur() as cur:
assert pg.connection_count(dbname="p0") == 1
with bouncer.log_contains(
r"pTxnPool.*database configuration changed|pTxnPool.*obsolete connection", 0
):
# change nothing and RELOAD
bouncer.admin("RELOAD")
# keep cursor open for > full_maint_period
# full_maint_period = 3x/s https://github.com/pgbouncer/pgbouncer/blob/master/src/janitor.c#L28
time.sleep(0.5)
assert pg.connection_count(dbname="p0") == 1
cur.execute("SELECT 1")
def test_servers_disconnect_when_changing_tls_config(bouncer, pg, cert_dir):
bouncer.default_db = "pTxnPool"
bouncer.write_ini(f"server_tls_protocols = tlsv1.0")
bouncer.admin("RELOAD")
with bouncer.cur() as cur:
assert pg.connection_count(dbname="p0") == 1
bouncer.write_ini(f"server_tls_protocols = secure")
with bouncer.log_contains(
r"pTxnPool.*database configuration changed|pTxnPool.*obsolete connection", 1
):
bouncer.admin("RELOAD")
time.sleep(0.5)
assert pg.connection_count(dbname="p0") == 0
cur.execute("SELECT 1")
def test_servers_disconnect_when_enabling_ssl(bouncer, pg, cert_dir):
bouncer.default_db = "pTxnPool"
bouncer.write_ini(f"server_tls_sslmode = disable")
bouncer.admin("RELOAD")
with bouncer.cur() as cur:
assert pg.connection_count(dbname="p0") == 1
bouncer.write_ini(f"server_tls_sslmode = allow")
with bouncer.log_contains(
r"pTxnPool.*database configuration changed|pTxnPool.*obsolete connection"
):
bouncer.admin("RELOAD")
cur.execute("SELECT 1")
def test_servers_disconnect_when_changing_sslmode(bouncer, pg, cert_dir):
bouncer.default_db = "pTxnPool"
with bouncer.cur() as cur:
assert pg.connection_count(dbname="p0") == 1
bouncer.write_ini(f"server_tls_sslmode = allow")
with bouncer.log_contains(
r"pTxnPool.*database configuration changed|pTxnPool.*obsolete connection"
):
bouncer.admin("RELOAD")
cur.execute("SELECT 1")
pgbouncer-1.24.1/test/pgident.conf 0000644 0001750 0000000 00000000363 14777762222 013771 0000000 0000000 # PostgreSQL User Name Maps
# =========================
# MAPNAME SYSTEM-USERNAME PG-USERNAME
test pgbouncer.acme.org someuser
test pgbouncer.acme.org anotheruser
test2 "bouncer" all
test2 pgbouncer.acme.org "anotheruser"
pgbouncer-1.24.1/test/test_timeouts.py 0000644 0001750 0000000 00000034402 14777762222 014753 0000000 0000000 import asyncio
import platform
import time
from concurrent.futures import ThreadPoolExecutor
import psycopg
import pytest
from .utils import USE_SUDO
def test_server_lifetime(pg, bouncer):
bouncer.admin(f"set server_lifetime=2")
bouncer.test()
assert pg.connection_count() == 1
time.sleep(3)
assert pg.connection_count() == 0
bouncer.test()
def test_server_lifetime_per_pool(pg, bouncer):
bouncer.test(dbname="p9")
assert pg.connection_count() == 1
time.sleep(3)
assert pg.connection_count() == 0
bouncer.test(dbname="p9")
def test_server_idle_timeout(pg, bouncer):
bouncer.admin(f"set server_idle_timeout=2")
bouncer.test()
assert pg.connection_count() == 1
time.sleep(3)
assert pg.connection_count() == 0
bouncer.test()
def test_user_idle_transaction_timeout_negative(bouncer):
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = trust
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
pool_mode = session
[users]
puser1 = pool_mode=transaction idle_transaction_timeout=6
"""
# while configured to be in statement pooling mode
with bouncer.run_with_config(config):
with bouncer.transaction(dbname="postgres", user="puser1") as cur:
time.sleep(3)
cur.execute("select 1")
def test_user_idle_transaction_timeout_override_global(bouncer):
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = trust
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
pool_mode = session
idle_transaction_timeout=100000
[users]
puser1 = pool_mode=transaction idle_transaction_timeout=1
"""
# while configured to be in statement pooling mode
with bouncer.run_with_config(config):
with bouncer.transaction(dbname="postgres", user="puser1") as cur:
with bouncer.log_contains(r"idle transaction timeout"):
time.sleep(3)
with pytest.raises(
psycopg.OperationalError,
match=r"idle transaction timeout|Software caused connection abort|server closed the connection unexpectedly",
):
cur.execute("select 1")
def test_user_idle_transaction_timeout(bouncer):
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = trust
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
pool_mode = session
[users]
puser1 = pool_mode=transaction idle_transaction_timeout=1
"""
# while configured to be in statement pooling mode
with bouncer.run_with_config(config):
with bouncer.transaction(dbname="postgres", user="puser1") as cur:
with bouncer.log_contains(r"idle transaction timeout"):
time.sleep(3)
with pytest.raises(
psycopg.OperationalError,
match=r"idle transaction timeout|Software caused connection abort|server closed the connection unexpectedly",
):
cur.execute("select 1")
def test_user_query_timeout_override_global(bouncer):
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = trust
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
pool_mode = session
query_timeout=100000
[users]
puser1 = pool_mode=statement query_timeout=1
"""
# while configured to be in statement pooling mode
with bouncer.run_with_config(config):
with bouncer.log_contains(r"query timeout"):
with pytest.raises(
psycopg.OperationalError,
match=r"query timeout|server closed the connection unexpectedly",
):
bouncer.sleep(5, user="puser1", dbname="postgres")
def test_user_query_timeout_negative(bouncer):
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = trust
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
pool_mode = session
[users]
puser1 = pool_mode=statement query_timeout=10
"""
# while configured to be in statement pooling mode
with bouncer.run_with_config(config):
bouncer.sleep(5, user="puser1", dbname="postgres")
def test_user_query_timeout(bouncer):
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
admin_users = pgbouncer
auth_type = trust
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
pool_mode = session
[users]
puser1 = pool_mode=statement query_timeout=1
"""
# while configured to be in statement pooling mode
with bouncer.run_with_config(config):
with bouncer.log_contains(r"query timeout"):
with pytest.raises(
psycopg.OperationalError,
match=r"query timeout|server closed the connection unexpectedly",
):
bouncer.sleep(5, user="puser1", dbname="postgres")
def test_query_timeout(bouncer):
bouncer.admin(f"set query_timeout=1")
with bouncer.log_contains(r"query timeout"):
with pytest.raises(
psycopg.OperationalError,
match=r"query timeout|server closed the connection unexpectedly",
):
bouncer.sleep(5)
def test_user_level_idle_client_timeout_negative(bouncer):
"""Test user level client_idle_timeout correctly closes connection."""
bouncer.admin("set pool_mode=transaction")
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
auth_type = trust
admin_users = pgbouncer
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
pool_mode = session
[users]
puser1 = pool_mode=transaction client_idle_timeout=2
"""
with bouncer.run_with_config(config):
bouncer.admin("RELOAD")
with bouncer.cur(dbname="postgres", user="puser1") as cur:
cur.execute("SELECT 1")
with bouncer.log_contains(r"client_idle_timeout"):
time.sleep(3)
with pytest.raises(
psycopg.OperationalError,
match=r"client_idle_timeout|Software caused connection abort|server closed the connection unexpectedly",
):
cur.execute("SELECT 1")
def test_user_level_idle_client_timeout(bouncer):
"""Test that user level client_idle_timeout allows connection to stay open."""
bouncer.admin("set pool_mode=transaction")
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
auth_type = trust
admin_users = pgbouncer
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
pool_mode = session
[users]
puser1 = pool_mode=transaction client_idle_timeout=6
"""
with bouncer.run_with_config(config):
bouncer.admin("RELOAD")
with bouncer.cur(dbname="postgres", user="puser1") as cur:
cur.execute("SELECT 1")
time.sleep(3)
cur.execute("SELECT 1")
def test_user_level_idle_client_timeout_override(bouncer):
"""Test that user level client_idle_timeout overrides global level setting."""
bouncer.admin("set pool_mode=transaction")
config = f"""
[databases]
postgres = host={bouncer.pg.host} port={bouncer.pg.port}
[pgbouncer]
listen_addr = {bouncer.host}
auth_type = trust
admin_users = pgbouncer
auth_file = {bouncer.auth_path}
listen_port = {bouncer.port}
logfile = {bouncer.log_path}
auth_dbname = postgres
pool_mode = session
client_idle_timeout=1000000
[users]
puser1 = pool_mode=transaction client_idle_timeout=2
"""
with bouncer.run_with_config(config):
bouncer.admin("RELOAD")
with bouncer.cur(dbname="postgres", user="puser1") as cur:
cur.execute("SELECT 1")
with bouncer.log_contains(r"client_idle_timeout"):
time.sleep(3)
with pytest.raises(
psycopg.OperationalError,
match=r"client_idle_timeout|Software caused connection abort|server closed the connection unexpectedly",
):
cur.execute("SELECT 1")
def test_idle_transaction_timeout(bouncer):
bouncer.admin(f"set pool_mode=transaction")
bouncer.admin(f"set idle_transaction_timeout=2")
with bouncer.transaction() as cur:
with bouncer.log_contains(r"idle transaction timeout"):
time.sleep(3)
with pytest.raises(
psycopg.OperationalError,
match=r"idle transaction timeout|Software caused connection abort|server closed the connection unexpectedly",
):
cur.execute("select 1")
# test for GH issue #125
with bouncer.transaction() as cur:
cur.execute("select pg_sleep(2)").fetchone()
time.sleep(1)
cur.execute("select 1")
def test_client_idle_timeout(bouncer):
bouncer.admin(f"set client_idle_timeout=2")
with bouncer.cur() as cur:
cur.execute("select 1")
with bouncer.log_contains(r"client_idle_timeout"):
time.sleep(3)
with pytest.raises(
psycopg.OperationalError,
match=r"client_idle_timeout|Software caused connection abort|server closed the connection unexpectedly",
):
cur.execute("select 1")
@pytest.mark.asyncio
async def test_server_login_retry(pg, bouncer):
bouncer.admin(f"set query_timeout=10")
bouncer.admin(f"set server_login_retry=3")
# Disable tls to get more consistent timings
bouncer.admin("set server_tls_sslmode = disable")
pg.stop()
if platform.system() == "FreeBSD":
# XXX: For some reason FreeBSD logs don't contain connect failed
# For now we simply remove this check. But this warants further
# investigation.
await asyncio.gather(
bouncer.atest(connect_timeout=10),
pg.delayed_start(1),
)
else:
with bouncer.log_contains("connect failed"):
await asyncio.gather(
bouncer.atest(connect_timeout=10),
pg.delayed_start(1),
)
def test_server_connect_timeout_establish(pg, bouncer):
pg.configure("pre_auth_delay to '5s'")
pg.reload()
bouncer.admin("set query_timeout=3")
bouncer.admin("set server_connect_timeout=2")
with bouncer.log_contains(r"closing because: connect timeout"):
with pytest.raises(psycopg.errors.OperationalError, match="query_timeout"):
bouncer.test(connect_timeout=10)
@pytest.mark.skipif("not USE_SUDO")
def test_server_connect_timeout_drop_traffic(pg, bouncer):
bouncer.admin("set query_timeout=3")
bouncer.admin("set server_connect_timeout=2")
with bouncer.log_contains(r"closing because: connect failed"):
with pg.drop_traffic():
with pytest.raises(psycopg.errors.OperationalError, match="query_timeout"):
bouncer.test(connect_timeout=10)
@pytest.mark.skipif("not USE_SUDO")
@pytest.mark.skipif(
"platform.system() != 'Linux'", reason="tcp_user_timeout is only supported on Linux"
)
def test_tcp_user_timeout(pg, bouncer):
bouncer.admin("set tcp_user_timeout=1000")
bouncer.admin("set query_timeout=5")
# Make PgBouncer cache a connection to Postgres
bouncer.test()
# without tcp_user_timeout, you get a different error message
# about "query timeout" instead
with bouncer.log_contains(r"closing because: server conn crashed?"):
with pg.reject_traffic():
with pytest.raises(
psycopg.OperationalError,
match=r"query timeout|Software caused connection abort|server closed the connection unexpectedly",
):
bouncer.test(connect_timeout=10)
@pytest.mark.skipif("not USE_SUDO")
@pytest.mark.asyncio
async def test_server_check_delay(pg, bouncer):
bouncer.admin("set server_check_delay=2")
bouncer.admin("set server_login_retry=3")
bouncer.admin("set query_timeout=10")
with pg.drop_traffic():
time.sleep(3)
query_task = bouncer.atest(connect_timeout=10)
# We wait for 1 second to show that the query is blocked while traffic
# is dropped.
done, pending = await asyncio.wait([query_task], timeout=1)
assert done == set()
assert pending == {query_task}
await query_task
@pytest.mark.skipif("not USE_SUDO")
def test_cancel_wait_timeout(pg, bouncer):
bouncer.admin("set cancel_wait_timeout=1")
with bouncer.cur() as cur:
with ThreadPoolExecutor(max_workers=2) as pool:
query = pool.submit(cur.execute, "select pg_sleep(3)")
time.sleep(1)
with pg.drop_traffic():
with bouncer.log_contains(r"closing because: cancel_wait_timeout"):
cancel = pool.submit(cur.connection.cancel)
cancel.result()
query.result()
pgbouncer-1.24.1/test/hba_test.eval 0000644 0001750 0000000 00000004160 14777762222 014131 0000000 0000000 # peer
md5 db user unix
peer dbp user unix
password db userp unix
trust dbz userz unix
scram-sha-256 dbs users unix
# hostssl
cert db user 10.1.1.1 tls
reject db user 10.1.1.1
reject db user 13.1.1.1
# hostnossl
reject db user 11.1.1.1 tls
md5 db user 11.1.1.1
reject db user 13.1.1.1
# host
password db user 127.0.0.2 tls
password db user 127.0.0.3
reject db user 127.0.1.4
# db1 filt
reject db1x user 127.0.1.4
md5 db1 user 127.0.1.4
# user1 filt
md5 db1z user1 15.0.0.1
reject db1z user2 15.0.0.1
# someusers
reject db2 user 16.0.0.1
md5 db2 user1 16.0.0.1
md5 db2 user2 16.0.0.1
md5 db2 user3 16.0.0.1
reject db2 user4 16.0.0.1
# manyusers
md5 db2 u1 17.0.0.1
md5 db2 u2 17.0.0.1
md5 db2 u3 17.0.0.1
md5 db2 u4 17.0.0.1
md5 db2 u5 17.0.0.1
md5 db2 u6 17.0.0.1
md5 db2 u7 17.0.0.1
md5 db2 u8 17.0.0.1
md5 db2 u9 17.0.0.1
md5 db2 u10 17.0.0.1
md5 db2 u11 17.0.0.1
# manydbs
reject d1 user 18.0.0.2
trust d1 t18user 18.0.0.2
trust d2 t18user 18.0.0.2
trust d3 t18user 18.0.0.2
trust d4 t18user 18.0.0.2
trust d5 t18user 18.0.0.2
trust d6 t18user 18.0.0.2
trust d7 t18user 18.0.0.2
trust d8 t18user 18.0.0.2
trust d9 t18user 18.0.0.2
trust d10 t18user 18.0.0.2
trust d11 t18user 18.0.0.2
# quoting
reject db t19user 19.0.0.2
cert all all 19.0.0.2
cert q1"q2 a , b 19.0.0.2
# bitmask
cert mdb muser 199.199.199.199
reject mdb muser 199.199.199.198
reject mdb muser 199.199.199.200
cert mdb2 muser 254.1.1.1
# ipv6
md5 mdb muser ff11:2::1
md5 mdb muser ff22:3::1
trust mdb muser ::1
reject mdb muser ::2
# "all" address
scram-sha-256 mdb3 muser 1.2.3.4
scram-sha-256 mdb3 muser face::1
reject mdb4 muser 1.2.3.4
reject mdb4 muser face::1
# replication
reject mdb muser ::1 replication
reject db userp unix replication
reject replication userp unix replication
trust db admin ::1 replication
trust replication admin ::1 replication
reject db admin ::1
reject replication admin ::1
trust db admin2 ::1 replication
trust replication admin2 ::1 replication
trust db2 admin2 ::1
reject replication admin2 ::1
pgbouncer-1.24.1/test/ctest6000.ini 0000644 0001750 0000000 00000001374 14777762222 013624 0000000 0000000 ;; database name = connect string
[databases]
; redirect bardb to bazdb on localhost
conntest = host=127.0.0.1 port=7000 dbname=conntest
;; Configuration section
[pgbouncer]
logfile = ctest6000.log
pidfile = ctest6000.pid
listen_addr = 127.0.0.1
listen_port = 6000
unix_socket_dir = /tmp
auth_type = md5
auth_file = userlist.txt
admin_users = marko
stats_users = stats
pool_mode = transaction
server_reset_query = reset all
server_check_query = select 1
server_check_delay = 2
max_client_conn = 1000
default_pool_size = 20
log_connections = 0
log_disconnections = 0
log_pooler_errors = 0
server_lifetime = 30
server_idle_timeout = 3
server_connect_timeout = 2
server_login_retry = 5
query_timeout = 5
client_idle_timeout = 10
client_login_timeout = 50
pgbouncer-1.24.1/test/test_cancel.py 0000644 0001750 0000000 00000007633 14777762222 014335 0000000 0000000 import time
from concurrent.futures import ThreadPoolExecutor
import psycopg
import pytest
def test_cancel(bouncer):
with bouncer.cur(dbname="p3") as cur:
with ThreadPoolExecutor(max_workers=2) as pool:
query = pool.submit(cur.execute, "select pg_sleep(5)")
time.sleep(1)
cancel = pool.submit(cur.connection.cancel)
cancel.result()
with pytest.raises(
psycopg.errors.QueryCanceled, match="due to user request"
):
query.result()
# Test for waiting connections handling for cancel requests.
#
# The bug fixed by GH PR #542 was: When the connection pool is full,
# cancel requests cannot get through (that is normal), but then when
# unused connections close and pool slots are available, those are not
# used for waiting cancel requests.
def test_cancel_wait(bouncer):
# default_pool_size=5
bouncer.admin(f"set server_idle_timeout=2")
with bouncer.cur(dbname="p3") as cur:
with ThreadPoolExecutor(max_workers=6) as pool:
q1 = pool.submit(cur.execute, "select pg_sleep(5)")
others = [pool.submit(bouncer.sleep, 2, dbname="p3") for _ in range(4)]
cancel = pool.submit(cur.connection.cancel)
cancel.result()
with pytest.raises(
psycopg.errors.QueryCanceled, match="due to user request"
):
q1.result()
for q in others:
q.result()
# Test that cancel requests can exceed the pool size
#
# Cancel request connections can use twice the pool size. See also GH
# PR #543.
def test_cancel_pool_size(bouncer):
# default_pool_size=5
bouncer.admin(f"set server_idle_timeout=2")
with ThreadPoolExecutor(max_workers=10) as pool:
conns = [bouncer.conn(dbname="p3") for _ in range(5)]
try:
queries = [
pool.submit(conn.cursor().execute, "select pg_sleep(20)")
for conn in conns
]
time.sleep(1)
cancels = [pool.submit(conn.cancel) for conn in conns]
for c in cancels:
c.result()
for q in queries:
with pytest.raises(
psycopg.errors.QueryCanceled, match="due to user request"
):
q.result()
finally:
for conn in conns:
conn.close()
# Test that cancel requests connections don't trigger cancellation of a query
# from a different client.
#
# See also GH PR #717. Prior to this change it was possible to that a query was
# cancelled on client A by a cancellation for client B, if the server was
# released by client B and then reused by client A while the cancellation was
# already in flight.
def test_cancel_race(bouncer):
# Make sure only one query can run at the same time so that its ensured
# that both clients will use the same server connection.
bouncer.admin("set default_pool_size=1")
bouncer.admin("set server_idle_timeout=2")
bouncer.admin("set verbose=1")
conn1 = bouncer.conn(dbname="p1")
cur1 = conn1.cursor()
conn2 = bouncer.conn(dbname="p1")
cur2 = conn2.cursor()
try:
with ThreadPoolExecutor(max_workers=100) as pool:
q1 = pool.submit(cur1.execute, "select pg_sleep(5)")
time.sleep(1)
q2 = pool.submit(cur2.execute, "select pg_sleep(1)")
time.sleep(1)
cancels = [pool.submit(conn1.cancel) for _ in range(100)]
# Spam many concurrent cancel requests to try and with the goal of
# triggering race conditions
for c in cancels:
c.result()
with pytest.raises(
psycopg.errors.QueryCanceled, match="due to user request"
):
q1.result()
q2.result()
bouncer.print_logs()
finally:
conn1.close()
conn2.close()
pgbouncer-1.24.1/test/hba_test.c 0000644 0001750 0000000 00000006010 14777762222 013420 0000000 0000000
#include "bouncer.h"
#include
#include
#include
#include
#include
#include
#include
#include
int cf_tcp_keepcnt;
int cf_tcp_keepintvl;
int cf_tcp_keepidle;
int cf_tcp_keepalive;
int cf_tcp_user_timeout;
int cf_tcp_socket_buffer;
int cf_listen_port;
static const char *method2string(int method)
{
switch (method) {
case AUTH_TYPE_TRUST:
return "trust";
case AUTH_TYPE_PLAIN:
return "password";
case AUTH_TYPE_MD5:
return "md5";
case AUTH_TYPE_CERT:
return "cert";
case AUTH_TYPE_PEER:
return "peer";
case AUTH_TYPE_HBA:
return "hba";
case AUTH_TYPE_REJECT:
return "reject";
case AUTH_TYPE_PAM:
return "pam";
case AUTH_TYPE_SCRAM_SHA_256:
return "scram-sha-256";
default:
return "???";
}
}
static char *get_token(char **ln_p)
{
char *ln = *ln_p, *tok, *end;
while (*ln && *ln == '\t') ln++;
tok = ln;
while (*ln && *ln != '\t') ln++;
end = ln;
while (*ln && *ln == '\t') ln++;
*ln_p = ln;
if (tok == end)
return NULL;
*end = 0;
return tok;
}
static int hba_test_eval(struct HBA *hba, char *ln, int linenr)
{
const char *addr=NULL, *user=NULL, *db=NULL, *modifier=NULL, *exp=NULL;
PgAddr pgaddr;
struct HBARule *rule;
int res = 0;
bool tls;
ReplicationType replication;
if (ln[0] == '#')
return 0;
exp = get_token(&ln);
db = get_token(&ln);
user = get_token(&ln);
addr = get_token(&ln);
modifier = get_token(&ln);
tls = strcmpeq(modifier, "tls");
replication = strcmpeq(modifier, "replication") ? REPLICATION_PHYSICAL : REPLICATION_NONE;
if (!exp)
return 0;
if (!db || !user)
die("hbatest: invalid line #%d", linenr);
if (!pga_pton(&pgaddr, addr, 9999))
die("hbatest: invalid addr on line #%d", linenr);
rule = hba_eval(hba, &pgaddr, !!tls, replication, db, user);
if (!rule) {
if (strcmp("reject", exp) == 0) {
res = 0;
} else {
log_warning("FAIL on line %d: No rule for user=%s db=%s addr=%s",
linenr, user, db, addr);
res = 1;
}
} else {
if (strcmp(method2string(rule->rule_method), exp) == 0) {
res = 0;
} else {
log_warning("FAIL on line %d: expected '%s' got '%s' - user=%s db=%s addr=%s",
linenr, exp, method2string(rule->rule_method), user, db, addr);
res = 1;
}
}
return res;
}
static void hba_test(void)
{
struct HBA *hba;
FILE *f;
char *ln = NULL;
size_t lnbuf = 0;
ssize_t len;
int linenr;
int nfailed = 0;
hba = hba_load_rules("hba_test.rules", NULL);
if (!hba)
die("hbatest: did not find config");
f = fopen("hba_test.eval", "r");
if (!f)
die("hbatest: cannot open eval");
for (linenr = 1; ; linenr++) {
len = getline(&ln, &lnbuf, f);
if (len < 0)
break;
if (len && ln[len-1] == '\n')
ln[len-1] = 0;
nfailed += hba_test_eval(hba, ln, linenr);
}
free(ln);
fclose(f);
hba_free(hba);
if (nfailed)
errx(1, "HBA test failures: %d", nfailed);
else
printf("HBA test OK\n");
}
int main(void)
{
hba_test();
return 0;
}
pgbouncer-1.24.1/test/test_misc.py 0000644 0001750 0000000 00000032432 14777762222 014036 0000000 0000000 import asyncio
import re
import time
import psycopg
import pytest
from .utils import HAVE_IPV6_LOCALHOST, PG_MAJOR_VERSION, PKT_BUF_SIZE, WINDOWS
def test_connect_query(bouncer):
# The p8 database definition in test.ini has some GUC settings
# in connect_query. Check that they get set. (The particular
# settings don't matter; just use some that are easy to set
# and read.)
assert bouncer.sql_value("show enable_seqscan", dbname="p8") == "off"
assert bouncer.sql_value("show enable_nestloop", dbname="p8") == "off"
def test_fast_close(bouncer):
with bouncer.cur(dbname="p3") as cur:
cur.execute("select 1")
bouncer.admin("set server_fast_close = 1")
with bouncer.log_contains(r"closing because: database configuration changed"):
bouncer.admin("reconnect p3")
time.sleep(1)
with pytest.raises(
psycopg.OperationalError,
match=r"database configuration changed|server closed the connection unexpectedly|Software caused connection abort",
):
cur.execute("select 1")
def test_track_extra_parameters(bouncer):
# test.ini has track_extra_parameters set to a list of Postgres
# parameters. Test that the parameters in the list in addition to the
# default hardcoded list of parameters are cached per client.
bouncer.admin(f"set pool_mode=transaction")
test_set = {
"intervalstyle": ["sql_standard", "postgres"],
"standard_conforming_strings": ["ON", "OFF"],
"timezone": ["'Europe/Amsterdam'", "'Europe/Rome'"],
"datestyle": ["PostgreSQL,European", "ISO,US"],
"application_name": ["client1", "client2"],
}
if not WINDOWS:
test_set["client_encoding"] = ["LATIN1", "LATIN5"]
test_expected = {
"intervalstyle": ["sql_standard", "postgres"],
"standard_conforming_strings": ["on", "off"],
"timezone": ["Europe/Amsterdam", "Europe/Rome"],
"datestyle": ["Postgres, DMY", "ISO, MDY"],
"application_name": ["client1", "client2"],
}
if not WINDOWS:
test_expected["client_encoding"] = ["LATIN1", "LATIN5"]
with bouncer.cur(dbname="p1") as cur1:
with bouncer.cur(dbname="p1") as cur2:
for key in test_set:
stmt1 = "SET " + key + " TO " + test_set[key][0]
stmt2 = "SET " + key + " TO " + test_set[key][1]
cur1.execute(stmt1)
cur2.execute(stmt2)
stmt = "SHOW " + key
cur1.execute(stmt)
cur2.execute(stmt)
result1 = cur1.fetchone()
assert result1[0] == test_expected[key][0]
result2 = cur2.fetchone()
assert result2[0] == test_expected[key][1]
@pytest.mark.asyncio
async def test_wait_close(bouncer):
with bouncer.cur(dbname="p3") as cur:
cur.execute("select 1")
await bouncer.aadmin("reconnect p3")
wait_close_task = bouncer.aadmin("wait_close p3")
# We wait for 1 second to show that wait_close continues unless the
# connection is closed.
done, pending = await asyncio.wait([wait_close_task], timeout=1)
assert done == set()
assert pending == {wait_close_task}
await wait_close_task
def test_auto_database(bouncer):
with bouncer.ini_path.open() as f:
original = f.read()
with bouncer.ini_path.open("w") as f:
# uncomment the auto-database line
f.write(re.sub(r"^;\*", "*", original, flags=re.MULTILINE))
bouncer.admin("reload")
with bouncer.log_contains(r"registered new auto-database"):
# p7 is not defined in test.ini
bouncer.test(dbname="p7")
# This test checks database specifications with host lists. The way
# we test this here is to have a host list containing an IPv4 and an
# IPv6 representation of localhost, and then we check the log that
# both connections were made. Some CI environments don't have IPv6
# localhost configured. Therefore, this test is skipped by default
# and needs to be enabled explicitly by setting HAVE_IPV6_LOCALHOST to
# non-empty.
@pytest.mark.asyncio
@pytest.mark.skipif("not HAVE_IPV6_LOCALHOST")
async def test_host_list(bouncer):
with bouncer.log_contains(r"new connection to server \(from 127.0.0.1", times=1):
with bouncer.log_contains(r"new connection to server \(from \[::1\]", times=1):
await bouncer.asleep(1, dbname="hostlist1", times=2)
# This is the same test as above, except it doesn't use any IPv6
# addresses. So we can't actually tell apart that two separate
# connections are made. But the test is useful to get some test
# coverage (valgrind etc.) of the host list code on systems without
# IPv6 enabled.
@pytest.mark.asyncio
async def test_host_list_dummy(bouncer):
with bouncer.log_contains(r"new connection to server \(from 127.0.0.1", times=2):
await bouncer.asleep(1, dbname="hostlist2", times=2)
def test_options_startup_param(bouncer):
assert (
bouncer.sql_value("SHOW datestyle", options=" -c datestyle=German,\\ YMD")
== "German, YMD"
)
assert (
bouncer.sql_value(
"SHOW datestyle",
options="-c timezone=Portugal -c datestyle=German,\\ YMD",
)
== "German, YMD"
)
assert (
bouncer.sql_value(
"SHOW timezone",
options="-c timezone=Portugal -c datestyle=German,\\ YMD",
)
== "Portugal"
)
assert (
bouncer.sql_value(
"SHOW timezone", options="-ctimezone=Portugal -cdatestyle=German,\\ YMD"
)
== "Portugal"
)
assert (
bouncer.sql_value(
"SHOW timezone", options="--timezone=Portugal --datestyle=German,\\ YMD"
)
== "Portugal"
)
assert (
bouncer.sql_value(
"SHOW timezone",
options="-c t\\imezone=\\P\\o\\r\\t\\ugal -c dat\\estyle\\=\\Ge\\rman,\\ YMD",
)
== "Portugal"
)
# extra_float_digits is in ignore_startup_parameters so setting it has no
# effect, and the default of 1 will still be used.
assert (
bouncer.sql_value("SHOW extra_float_digits", options="-c extra_float_digits=2")
== "1"
)
with pytest.raises(
psycopg.OperationalError,
match="unsupported options startup parameter: only '-c config=val' and '--config=val' are allowed",
):
bouncer.test(options="-d")
with pytest.raises(
psycopg.OperationalError,
match="unsupported options startup parameter: only '-c config=val' and '--config=val' are allowed",
):
bouncer.test(options="-c timezone")
with pytest.raises(
psycopg.OperationalError,
match="unsupported startup parameter in options: enable_seqscan",
):
bouncer.test(options="-c enable_seqscan=false")
bouncer.admin("set ignore_startup_parameters = options")
# Unsupported values should be ignored, so it shouldn't error but it should
# have its default value instead.
assert (
bouncer.sql_value(
"SHOW enable_seqscan",
options="-c enable_seqscan=false",
)
== "on"
)
# Even though we have options in ignore_startup_parameters, we still parse
# and configure any values in it that we support
assert (
bouncer.sql_value(
"SHOW timezone", options="-ctimezone=Portugal -cdatestyle=German,\\ YMD"
)
== "Portugal"
)
def test_startup_packet_larger_than_pktbuf(bouncer):
long_string = "1" * PKT_BUF_SIZE
bouncer.test(options=f"-c extra_float_digits={long_string}")
def test_empty_application_name(bouncer):
with bouncer.cur(dbname="p1", application_name="") as cur:
assert cur.execute("SHOW application_name").fetchone()[0] == ""
cur.execute("SET application_name = test")
assert cur.execute("SHOW application_name").fetchone()[0] == "test"
with bouncer.cur(dbname="p1", application_name="") as cur:
assert cur.execute("SHOW application_name").fetchone()[0] == ""
cur.execute("SET application_name = test")
assert cur.execute("SHOW application_name").fetchone()[0] == "test"
def test_equivalent_startup_param(bouncer):
bouncer.admin("set verbose=2")
canonical_expected_times = 1 if PG_MAJOR_VERSION >= 14 else 0
with bouncer.cur(options="-c DateStyle=ISO") as cur:
with bouncer.log_contains(
"varcache_apply: .*SET DateStyle='ISO'", times=1
), bouncer.log_contains(
"varcache_set_canonical: setting DateStyle to its canonical version ISO -> ISO, MDY",
times=canonical_expected_times,
):
cur.execute("SELECT 1")
cur.execute("SELECT 1")
@pytest.mark.skipif("WINDOWS", reason="Windows doesn't support sending SIGTERM")
async def test_repeated_sigterm(bouncer):
with bouncer.cur() as cur:
cur.execute("SELECT 1")
bouncer.sigterm()
# Single sigterm should wait for clients
time.sleep(1)
cur.execute("SELECT 1")
assert bouncer.running()
# Second sigterm should cause fast exit
bouncer.sigterm()
await bouncer.wait_for_exit()
with pytest.raises(
psycopg.OperationalError,
match="database removed|server closed the connection unexpectedly",
):
cur.execute("SELECT 1")
assert not bouncer.running()
@pytest.mark.skipif("WINDOWS", reason="Windows doesn't support sending SIGINT")
async def test_repeated_sigint(bouncer):
bouncer.admin(f"set pool_mode=session")
with bouncer.cur() as cur:
cur.execute("SELECT 1")
bouncer.sigint()
# Single sigint should wait for servers to be released
time.sleep(1)
cur.execute("SELECT 1")
assert bouncer.running()
# But new clients should be rejected, because we stopped listening for
# new connections.
with pytest.raises(psycopg.OperationalError, match="Connection refused"):
bouncer.test()
# Second sigint should cause fast exit
bouncer.sigint()
await bouncer.wait_for_exit()
with pytest.raises(
psycopg.OperationalError,
match="database removed|server closed the connection unexpectedly",
):
cur.execute("SELECT 1")
assert not bouncer.running()
def test_newly_paused_client_during_wait_for_servers_shutdown(bouncer):
bouncer.admin(f"set pool_mode=transaction")
with bouncer.transaction() as cur1, bouncer.cur() as cur2:
cur1.execute("SELECT 1")
bouncer.admin("SHUTDOWN WAIT_FOR_SERVERS")
# Still in the same transaction, so this should work
cur1.execute("SELECT 1")
# New transaction so this should fail
with bouncer.log_contains(r"closing because: server shutting down"):
with pytest.raises(psycopg.OperationalError):
cur2.execute("SELECT 1")
async def test_already_paused_client_during_wait_for_servers_shutdown(bouncer):
bouncer.admin(f"set pool_mode=transaction")
bouncer.admin(f"set default_pool_size=1")
bouncer.default_db = "p1"
with bouncer.transaction() as cur1:
conn2 = await bouncer.aconn()
cur2 = conn2.cursor()
cur1.execute("SELECT 1")
# start the request before the shutdown
task = asyncio.ensure_future(cur2.execute("SELECT 1"))
# We wait so that the client goes to CL_WAITING state
done, pending = await asyncio.wait([task], timeout=3)
assert done == set()
assert pending == {task}
bouncer.admin("SHUTDOWN WAIT_FOR_SERVERS")
# Still in the same transaction, so this should work
cur1.execute("SELECT 1")
# New transaction so this should fail
with bouncer.log_contains(r"closing because: server shutting down"):
with pytest.raises(psycopg.OperationalError):
await task
def test_resume_during_shutdown(bouncer):
with bouncer.cur() as cur, bouncer.admin_runner.cur() as admin_cur:
cur.execute("SELECT 1")
bouncer.admin("SHUTDOWN WAIT_FOR_CLIENTS")
with pytest.raises(
psycopg.errors.ProtocolViolation, match="pooler is shutting down"
):
admin_cur.execute("RESUME")
def test_sigusr2_during_shutdown(bouncer):
with bouncer.cur() as cur:
cur.execute("SELECT 1")
bouncer.admin("SHUTDOWN WAIT_FOR_CLIENTS")
if not WINDOWS:
with bouncer.log_contains(r"got SIGUSR2 while shutting down, ignoring"):
bouncer.sigusr2()
time.sleep(1)
def test_issue_1104(bouncer):
# regression test for GitHub issue #1104 [PgCredentials objects are freed incorrectly]
for i in range(1, 15):
config = """
[databases]
"""
for j in range(1, 10 * i):
config += f"""
testdb_{i}_{j} = host={bouncer.pg.host} port={bouncer.pg.port} user=dummy_user_{i}_{j}
"""
config += f"""
[pgbouncer]
listen_addr = {bouncer.host}
listen_port = {bouncer.port}
auth_type = trust
auth_file = {bouncer.auth_path}
admin_users = pgbouncer
logfile = {bouncer.log_path}
"""
with bouncer.run_with_config(config):
bouncer.admin("RELOAD")
pgbouncer-1.24.1/test/test_copy.py 0000644 0001750 0000000 00000024323 14777762222 014055 0000000 0000000 import time
import pytest
from psycopg import pq
from .utils import LIBPQ_SUPPORTS_PIPELINING
def test_copy_stdin_success_simple(bouncer):
with bouncer.conn() as conn:
conn.pgconn.send_query(f"COPY test_copy(i) FROM STDIN".encode())
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
conn.pgconn.put_copy_data(b"1\n")
conn.pgconn.put_copy_end()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
def test_copy_stdin_error_before_copy_done_simple(bouncer):
with bouncer.conn() as conn:
conn.pgconn.send_query(f"COPY test_copy(i) FROM STDIN".encode())
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
# Send bad row
conn.pgconn.put_copy_data(b"\n")
# Flush and wait a bit so PgBouncer can receive the error
conn.pgconn.flush()
time.sleep(1)
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
conn.pgconn.put_copy_end()
assert conn.pgconn.get_result().status == pq.ExecStatus.FATAL_ERROR
assert conn.pgconn.get_result() is None
def test_copy_stdin_error_after_copy_done_simple(bouncer):
with bouncer.conn() as conn:
conn.pgconn.send_query(f"COPY test_copy(i) FROM STDIN".encode())
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
# Send bad row
conn.pgconn.put_copy_data(b"\n")
conn.pgconn.put_copy_end()
assert conn.pgconn.get_result().status == pq.ExecStatus.FATAL_ERROR
assert conn.pgconn.get_result() is None
def test_copy_stdout_simple(bouncer):
bouncer.sql("TRUNCATE test_copy")
bouncer.sql("INSERT INTO test_copy VALUES (1), (2)")
with bouncer.conn() as conn:
conn.pgconn.send_query(
f"COPY (SELECT i FROM test_copy ORDER BY i) TO STDOUT (FORMAT TEXT)".encode()
)
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_OUT
assert conn.pgconn.get_copy_data(0) == (2, b"1\n")
assert conn.pgconn.get_copy_data(0) == (2, b"2\n")
assert conn.pgconn.get_copy_data(0) == (-1, b"")
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdin_success_extended(bouncer):
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_query_params(f"COPY test_copy(i) FROM STDIN".encode(), [])
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
conn.pgconn.put_copy_data(b"1\n")
conn.pgconn.put_copy_end()
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdin_error_before_copy_done_extended(bouncer):
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_query_params(f"COPY test_copy(i) FROM STDIN".encode(), [])
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
# Send bad row
conn.pgconn.put_copy_data(b"\n")
# Flush and wait a bit so PgBouncer can receive the error
conn.pgconn.flush()
time.sleep(1)
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
conn.pgconn.put_copy_end()
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.FATAL_ERROR
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdin_error_after_copy_done_extended(bouncer):
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_query_params(f"COPY test_copy(i) FROM STDIN".encode(), [])
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
# Send bad row
conn.pgconn.put_copy_data(b"\n")
conn.pgconn.put_copy_end()
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.FATAL_ERROR
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdout_extended(bouncer):
bouncer.sql("TRUNCATE test_copy")
bouncer.sql("INSERT INTO test_copy VALUES (1), (2)")
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_query_params(
f"COPY (SELECT i FROM test_copy ORDER BY i) TO STDOUT (FORMAT TEXT)".encode(),
[],
)
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_OUT
assert conn.pgconn.get_copy_data(0) == (2, b"1\n")
assert conn.pgconn.get_copy_data(0) == (2, b"2\n")
assert conn.pgconn.get_copy_data(0) == (-1, b"")
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdin_success_prepared(bouncer):
bouncer.admin(f"set max_prepared_statements=100")
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_prepare(b"p1", f"COPY test_copy(i) FROM STDIN".encode())
conn.pgconn.send_query_prepared(b"p1", [])
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
conn.pgconn.put_copy_data(b"1\n")
conn.pgconn.put_copy_end()
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdin_error_before_copy_done_prepared(bouncer):
bouncer.admin(f"set max_prepared_statements=100")
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_prepare(b"p1", f"COPY test_copy(i) FROM STDIN".encode())
conn.pgconn.send_query_prepared(b"p1", [])
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
# Send bad row
conn.pgconn.put_copy_data(b"\n")
# Flush and wait a bit so PgBouncer can receive the error
conn.pgconn.flush()
time.sleep(1)
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
conn.pgconn.put_copy_end()
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.FATAL_ERROR
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdin_error_after_copy_done_prepared(bouncer):
bouncer.admin(f"set max_prepared_statements=100")
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_prepare(b"p1", f"COPY test_copy(i) FROM STDIN".encode())
conn.pgconn.send_query_prepared(b"p1", [])
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_IN
# Send bad row
conn.pgconn.put_copy_data(b"\n")
conn.pgconn.put_copy_end()
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.FATAL_ERROR
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
@pytest.mark.skipif("not LIBPQ_SUPPORTS_PIPELINING")
def test_copy_stdout_prepared(bouncer):
bouncer.admin(f"set max_prepared_statements=100")
bouncer.sql("TRUNCATE test_copy")
bouncer.sql("INSERT INTO test_copy VALUES (1), (2)")
with bouncer.conn() as conn:
conn.pgconn.enter_pipeline_mode()
conn.pgconn.send_prepare(
b"p1",
f"COPY (SELECT i FROM test_copy ORDER BY i) TO STDOUT (FORMAT TEXT)".encode(),
)
conn.pgconn.send_query_prepared(b"p1", [])
conn.pgconn.pipeline_sync()
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.COPY_OUT
assert conn.pgconn.get_copy_data(0) == (2, b"1\n")
assert conn.pgconn.get_copy_data(0) == (2, b"2\n")
assert conn.pgconn.get_copy_data(0) == (-1, b"")
assert conn.pgconn.get_result().status == pq.ExecStatus.COMMAND_OK
assert conn.pgconn.get_result() is None
assert conn.pgconn.get_result().status == pq.ExecStatus.PIPELINE_SYNC
conn.pgconn.exit_pipeline_mode()
pgbouncer-1.24.1/test/Makefile 0000644 0001750 0000000 00000002374 14777762222 013134 0000000 0000000
PG_CPPFLAGS = -I$(shell pg_config --includedir)
PG_LIBS = -lpq
PG_LDFLAGS = -L$(shell pg_config --libdir)
USUAL_DIR = ../lib
SUBLOC = test
DIST_SUBDIRS = ssl
EXTRA_DIST = conntest.sh ctest6000.ini ctest7000.ini run-conntest.sh \
hba_test.eval hba_test.rules Makefile pgident.conf\
test.ini stress.py userlist.txt pgbouncer_hba.conf \
__init__.py conftest.py utils.py \
test_admin.py test_auth.py test_cancel.py test_copy.py test_limits.py \
test_load_balance_hosts.py test_misc.py test_no_database.py \
test_no_user.py test_operations.py test_peering.py test_prepared.py \
test_ssl.py test_timeouts.py test_replication.py
UTHASH = ../uthash
noinst_PROGRAMS = hba_test
hba_test_CPPFLAGS = -I../include $(LIBEVENT_CFLAGS) -I$(UTHASH)/src
hba_test_LDADD = $(LIBEVENT_LIBS) $(TLS_LIBS)
hba_test_CFLAGS = -O0
hba_test_SOURCES = hba_test.c ../src/hba.c ../src/util.c
hba_test_EMBED_LIBUSUAL = 1
EXTRA_PROGRAMS = asynctest
asynctest_CPPFLAGS = -I../include $(PG_CPPFLAGS) $(LIBEVENT_CFLAGS)
asynctest_LDFLAGS = $(PG_LDFLAGS)
asynctest_LDADD = $(PG_LIBS) $(LIBEVENT_LIBS)
asynctest_SOURCES = asynctest.c
asynctest_EMBED_LIBUSUAL = 1
AM_FEATURES = libusual
include ../config.mak
include ../lib/mk/antimake.mk
check: all
./hba_test
pgbouncer-1.24.1/test/asynctest.c 0000644 0001750 0000000 00000026404 14777762222 013655 0000000 0000000 /*
* Things to test:
* - Conn per query
* - show tx
* - long tx
* - variable-size query
*/
#ifdef WIN32
#undef strerror
#undef main
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
static char *simple_query = "select 1";
static struct event_base *evbase;
typedef struct DbConn {
struct List head;
const char *connstr;
struct event ev;
PGconn *con;
bool logged_in;
/* time_t connect_time; */
int query_count;
/* const char *query; */
int _arglen;
} DbConn;
#define QT_SIMPLE 1
#define QT_BIGDATA 2
#define QT_SLEEP 4
static unsigned QueryTypes = 0;
static uint64_t LoginOkCount = 0;
static uint64_t LoginFailedCount = 0;
static uint64_t SqlErrorCount = 0;
static uint64_t QueryCount = 0;
static char *bulk_data;
static int bulk_data_max = 128*1024; /* power of 2 */
static int verbose = 0;
static int throttle_connects = 0;
static int throttle_queries = 0;
static int per_conn_queries = 1;
static STATLIST(idle_list);
static STATLIST(active_list);
/*
* utility functions
*/
/* fill mem with random junk */
static void init_bulk_data(void)
{
int i;
bulk_data = malloc(bulk_data_max + 1);
for (i = 0; i < bulk_data_max; i++) {
bulk_data[i] = 'a' + (i % 26);
}
bulk_data[i] = 0;
}
static DbConn *new_db(const char *connstr)
{
DbConn *db = malloc(sizeof(*db));
memset(db, 0, sizeof(*db));
list_init(&db->head);
db->connstr = connstr;
return db;
}
static void set_idle(DbConn *db)
{
statlist_remove(&active_list, &db->head);
statlist_append(&idle_list, &db->head);
log_debug("%p: set_idle", db);
}
static void set_active(DbConn *db)
{
statlist_remove(&idle_list, &db->head);
statlist_append(&active_list, &db->head);
log_debug("%p: set_active", db);
}
static void wait_event(DbConn *db, short ev, event_callback_fn fn)
{
event_assign(&db->ev, evbase, PQsocket(db->con), ev, fn, db);
if (event_add(&db->ev, NULL) < 0)
fatal_perror("event_add");
}
_PRINTF(3, 4)
static void disconnect(DbConn *db, bool is_err, const char *reason, ...)
{
char buf[1024];
va_list ap;
if (is_err) {
if (db->logged_in)
SqlErrorCount++;
else
LoginFailedCount++;
}
if (db->con) {
va_start(ap, reason);
vsnprintf(buf, sizeof(buf), reason, ap);
va_end(ap);
log_debug("disconnect because: %s", buf);
PQfinish(db->con);
db->con = NULL;
db->logged_in = false;
set_idle(db);
}
}
/* some error happened */
static void conn_error(DbConn *db, const char *desc)
{
static int ecount = 0;
if (db->con) {
if (ecount++ < 3)
printf("\r%s (arglen=%d)\n", PQerrorMessage(db->con), db->_arglen);
disconnect(db, true, "%s: %s", desc, PQerrorMessage(db->con));
} else {
printf("random error: %s\n", desc);
exit(1);
}
}
/*
* Connection has a resultset available, fetch it.
*
* Returns true if there may be more results coming,
* false if all done.
*/
static bool another_result(DbConn *db)
{
PGresult *res;
/* got one */
res = PQgetResult(db->con);
if (res == NULL) {
QueryCount++;
set_idle(db);
return false;
}
switch (PQresultStatus(res)) {
case PGRES_TUPLES_OK:
/* TODO: check result */
if (db->_arglen > 0) {
int curlen = strlen(PQgetvalue(res, 0, 0));
if (curlen != db->_arglen) {
printf("result does not match: sent=%d got=%d\n",
db->_arglen, curlen);
}
}
/* fallthrough */
case PGRES_COMMAND_OK:
PQclear(res);
break;
default:
PQclear(res);
conn_error(db, "weird result");
return false;
}
return true;
}
/*
* Called when select() told that conn is avail for reading/writing.
*
* It should call postgres handlers and then change state if needed.
*/
static void result_cb(int sock, short flags, void *arg)
{
DbConn *db = arg;
int res;
res = PQconsumeInput(db->con);
if (res == 0) {
conn_error(db, "PQconsumeInput");
return;
}
/* loop until PQgetResult returns NULL */
while (1) {
/* if PQisBusy, then incomplete result */
if (PQisBusy(db->con)) {
wait_event(db, EV_READ, result_cb);
break;
}
/* got one */
if (!another_result(db))
break;
}
}
static void send_cb(int sock, short flags, void *arg)
{
int res;
DbConn *db = arg;
res = PQflush(db->con);
if (res > 0) {
wait_event(db, EV_WRITE, send_cb);
} else if (res == 0) {
wait_event(db, EV_READ, result_cb);
} else
conn_error(db, "PQflush");
}
static int send_query_bigdata(DbConn *db)
{
const char *values[1];
int lengths[1];
int fmts[1];
int arglen;
char *q = "select $1::text";
arglen = random() % bulk_data_max;
db->_arglen = arglen;
values[0] = bulk_data + bulk_data_max - arglen;
lengths[0] = arglen;
fmts[0] = 1;
return PQsendQueryParams(db->con, q, 1, NULL, values, lengths, fmts, 1);
}
static int send_query_sleep(DbConn *db)
{
const char *q = "select pg_sleep(0.2)";
return PQsendQueryParams(db->con, q, 0, NULL, NULL, NULL, NULL, 0);
}
static int send_query_simple(DbConn *db)
{
const char *q = simple_query;
return PQsendQueryParams(db->con, q, 0, NULL, NULL, NULL, NULL, 0);
}
/* send the query to server connection */
static void send_query(DbConn *db)
{
int res;
if (db->query_count >= per_conn_queries) {
disconnect(db, false, "query count full");
return;
}
db->query_count++;
/* send query */
if (QueryTypes & QT_SLEEP) {
res = send_query_sleep(db);
} else if (QueryTypes & QT_BIGDATA) {
res = send_query_bigdata(db);
} else {
res = send_query_simple(db);
}
if (!res) {
conn_error(db, "PQsendQueryParams");
return;
}
/* flush it down */
res = PQflush(db->con);
if (res > 0) {
wait_event(db, EV_WRITE, send_cb);
} else if (res == 0) {
wait_event(db, EV_READ, result_cb);
} else
conn_error(db, "PQflush");
}
static void connect_cb(int sock, short flags, void *arg)
{
DbConn *db = arg;
PostgresPollingStatusType poll_res;
poll_res = PQconnectPoll(db->con);
switch (poll_res) {
case PGRES_POLLING_WRITING:
wait_event(db, EV_WRITE, connect_cb);
break;
case PGRES_POLLING_READING:
wait_event(db, EV_READ, connect_cb);
break;
case PGRES_POLLING_OK:
log_debug("login ok: fd=%d", PQsocket(db->con));
LoginOkCount++;
db->logged_in = true;
send_query(db);
break;
default:
conn_error(db, "PQconnectPoll");
}
}
static void launch_connect(DbConn *db)
{
/* launch new connection */
db->logged_in = false;
db->query_count = 0;
db->con = PQconnectStart(db->connstr);
if (db->con == NULL) {
log_error("PQconnectStart: no mem");
exit(1);
}
if (PQstatus(db->con) == CONNECTION_BAD) {
conn_error(db, "PQconnectStart");
return;
}
wait_event(db, EV_WRITE, connect_cb);
}
#define ACT_ONCE 10
static void handle_idle(void)
{
DbConn *db;
struct List *item, *tmp;
int allow_connects = 100000;
int allow_queries = 100000;
static usec_t startup_time = 0;
usec_t now = get_cached_time();
usec_t diff;
int once;
if (startup_time == 0)
startup_time = get_cached_time();
diff = now - startup_time;
if (diff < USEC)
diff = USEC;
if (throttle_connects > 0) {
allow_connects = throttle_connects - LoginOkCount * USEC / diff;
once = throttle_connects / ACT_ONCE;
if (!once)
once = 1;
if (once < allow_connects)
allow_connects = once;
}
if (throttle_queries > 0) {
allow_queries = throttle_queries - QueryCount * USEC / diff;
once = throttle_connects / ACT_ONCE;
if (!once)
once = 1;
if (once < allow_connects)
allow_connects = once;
}
statlist_for_each_safe(item, &idle_list, tmp) {
db = container_of(item, DbConn, head);
if (db->con && allow_queries > 0) {
set_active(db);
send_query(db);
allow_queries--;
} else if (allow_connects > 0) {
set_active(db);
launch_connect(db);
allow_connects--;
}
}
}
static void run_stats(int fd, short ev, void *arg)
{
static struct event ev_stats;
struct timeval period = { 5, 0 };
static usec_t last_time = 0;
static uint64_t last_query_count = 0;
static uint64_t last_login_failed_count = 0;
static uint64_t last_login_ok_count = 0;
static uint64_t last_sql_error_count = 0;
double time_diff, qcount_diff, loginerr_diff, loginok_diff, sqlerr_diff;
usec_t now = get_cached_time();
time_diff = now - last_time;
if (last_time && time_diff) {
qcount_diff = QueryCount - last_query_count;
loginerr_diff = LoginFailedCount - last_login_failed_count;
sqlerr_diff = SqlErrorCount - last_sql_error_count;
loginok_diff = LoginOkCount - last_login_ok_count;
if (verbose == 0) {
printf(">> loginok,loginerr,sqlerr,qcount: %6.1f / %6.1f / %6.1f / %6.1f active/idle: %3d / %3d \r",
USEC * loginok_diff / time_diff,
USEC * loginerr_diff / time_diff,
USEC * sqlerr_diff / time_diff,
USEC * qcount_diff / time_diff,
statlist_count(&active_list), statlist_count(&idle_list));
fflush(stdout);
}
}
if (!last_time)
evtimer_assign(&ev_stats, evbase, run_stats, NULL);
if (evtimer_add(&ev_stats, &period) < 0)
fatal_perror("evtimer_add");
last_query_count = QueryCount;
last_login_failed_count = LoginFailedCount;
last_sql_error_count = SqlErrorCount;
last_login_ok_count = LoginOkCount;
last_time = now;
}
static const char usage_str [] =
"usage: asynctest [-d connstr][-n numconn][-s seed][-t ][-C maxconn][-Q maxquery][-q perconnq]\n"
" -d connstr libpq connect string\n"
" -n num number of connections\n"
" -s seed random number seed\n"
" -t type of queries query type, see below\n"
" -C maxcps max number of connects per sec\n"
" -Q maxqps max number of queries per sec\n"
" -q num queries per connection (default 1)\n"
" -S sql set simple query\n"
"accepted query types:\n"
" B - bigdata\n"
" S - sleep occasionally\n"
" 1 - simple 'select 1'\n";
int main(int argc, char *argv[])
{
int i, c;
DbConn *db;
unsigned seed = time(NULL) ^ getpid();
char *cstr = "";
int numcon = 50;
#ifdef WIN32
int wsresult;
WSADATA wsaData;
#endif
while ((c = getopt(argc, argv, "S:d:n:s:t:hvC:Q:q:")) != EOF) {
switch (c) {
default:
case 'h':
printf("%s", usage_str);
return 0;
case 'S':
simple_query = optarg;
break;
case 'd':
cstr = optarg;
break;
case 'C':
throttle_connects = atoi(optarg);
break;
case 'Q':
throttle_queries = atoi(optarg);
break;
case 'n':
numcon = atoi(optarg);
break;
case 's':
seed = atoi(optarg);
break;
case 'v':
verbose++;
break;
case 'q':
per_conn_queries = atoi(optarg);
break;
case 't':
for (i = 0; optarg[i]; i++) {
switch (optarg[i]) {
case 'B': QueryTypes = QT_BIGDATA; break;
case 'S': QueryTypes = QT_SLEEP; break;
case '1': QueryTypes = QT_SIMPLE; break;
default: log_error("bad type"); break;
}
}
}
}
#ifdef WIN32
wsresult = WSAStartup(MAKEWORD(2,0),&wsaData);
if (wsresult != 0)
fatal("cannot start the network subsystem: -%d", wsresult);
#endif
if (throttle_connects < 0 || throttle_queries < 0 || numcon < 0)
fatal("invalid parameter");
if (QueryTypes == 0)
QueryTypes = QT_SIMPLE;
printf("using seed: %u\n", seed);
srandom(seed);
init_bulk_data();
for (i = 0; i < numcon; i++) {
db = new_db(cstr);
statlist_append(&idle_list, &db->head);
}
evbase = event_base_new();
run_stats(0, 0, NULL);
printf("running..\n");
while (1) {
handle_idle();
reset_time_cache();
if (event_base_loop(evbase, EVLOOP_ONCE) < 0)
log_error("event_loop: %s", strerror(errno));
}
return 0;
}
pgbouncer-1.24.1/test/ctest7000.ini 0000644 0001750 0000000 00000001407 14777762222 013622 0000000 0000000 ;; database name = connect string
[databases]
; redirect bardb to bazdb on localhost
conntest = host=127.0.0.1 port=5432 dbname=marko password=kama
;; Configuration section
[pgbouncer]
logfile = ctest7000.log
pidfile = ctest7000.pid
listen_addr = 127.0.0.1
listen_port = 7000
unix_socket_dir = /tmp
auth_type = md5
auth_file = userlist.txt
admin_users = marko
stats_users = stats
pool_mode = transaction
server_reset_query = reset all
server_check_query = select 1
server_check_delay = 2
max_client_conn = 5000
default_pool_size = 20
log_connections = 0
log_disconnections = 0
log_pooler_errors = 0
server_lifetime = 30
server_idle_timeout = 3
server_connect_timeout = 2
server_login_retry = 5
query_timeout = 5
client_idle_timeout = 10
client_login_timeout = 50
pgbouncer-1.24.1/config.mak.in 0000644 0001750 0000000 00000003104 14777762222 013051 0000000 0000000 PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PORTNAME = @PORTNAME@
EXEEXT = @EXEEXT@
HAVE_CC_DEPFLAG = @HAVE_CC_DEPFLAG@
CC = @CC@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CFLAGS = @CFLAGS@
DEFS = @DEFS@
WFLAGS = @WFLAGS@
CXX = @CXX@
CXXFLAGS = @CXXFLAGS@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBS = @LIBS@
AR = @AR@
ARFLAGS = @ARFLAGS@
RANLIB = @RANLIB@
LIBTOOL = @LIBTOOL@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_DATA = @INSTALL_DATA@
MKDIR_P = @MKDIR_P@
SED = @SED@
AWK = @AWK@
GREP = @GREP@
EGREP = @EGREP@
STRIP = @STRIP@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
includedir = @includedir@
sbindir = @sbindir@
libexecdir = @libexecdir@
datarootdir = @datarootdir@
datadir = @datadir@
sysconfdir = @sysconfdir@
docdir = @docdir@
mandir = @mandir@
libdir = @libdir@
localedir = @localedir@
pkgdatadir = @pkgdatadir@
pkgconfigdir = @pkgconfigdir@
abs_top_srcdir ?= @abs_top_srcdir@
abs_top_builddir ?= @abs_top_builddir@
nosub_top_srcdir ?= @top_srcdir@
nosub_top_builddir ?= @top_builddir@
CARES_CFLAGS = @CARES_CFLAGS@
CARES_LIBS = @CARES_LIBS@
LIBEVENT_CFLAGS = @LIBEVENT_CFLAGS@
LIBEVENT_LIBS = @LIBEVENT_LIBS@
TLS_CPPFLAGS = @TLS_CPPFLAGS@
TLS_LDFLAGS = @TLS_LDFLAGS@
TLS_LIBS = @TLS_LIBS@
PANDOC = @PANDOC@
PYTHON = @PYTHON@
DLLWRAP = @DLLWRAP@
DLLTOOL = @DLLTOOL@
WINDRES = @WINDRES@
enable_debug = @enable_debug@
tls_support = @tls_support@
host_cpu = @host_cpu@
pgbouncer-1.24.1/install-sh 0000755 0001750 0001750 00000035776 14777762315 012555 0000000 0000000 #!/bin/sh
# install - install a program, script, or datafile
scriptversion=2020-11-14.01; # UTC
# This originates from X11R5 (mit/util/scripts/install.sh), which was
# later released in X11R6 (xc/config/util/install.sh) with the
# following copyright and license.
#
# Copyright (C) 1994 X Consortium
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Except as contained in this notice, the name of the X Consortium shall not
# be used in advertising or otherwise to promote the sale, use or other deal-
# ings in this Software without prior written authorization from the X Consor-
# tium.
#
#
# FSF changes to this file are in the public domain.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# 'make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.
tab=' '
nl='
'
IFS=" $tab$nl"
# Set DOITPROG to "echo" to test this script.
doit=${DOITPROG-}
doit_exec=${doit:-exec}
# Put in absolute file names if you don't have them in your path;
# or use environment vars.
chgrpprog=${CHGRPPROG-chgrp}
chmodprog=${CHMODPROG-chmod}
chownprog=${CHOWNPROG-chown}
cmpprog=${CMPPROG-cmp}
cpprog=${CPPROG-cp}
mkdirprog=${MKDIRPROG-mkdir}
mvprog=${MVPROG-mv}
rmprog=${RMPROG-rm}
stripprog=${STRIPPROG-strip}
posix_mkdir=
# Desired mode of installed file.
mode=0755
# Create dirs (including intermediate dirs) using mode 755.
# This is like GNU 'install' as of coreutils 8.32 (2020).
mkdir_umask=22
backupsuffix=
chgrpcmd=
chmodcmd=$chmodprog
chowncmd=
mvcmd=$mvprog
rmcmd="$rmprog -f"
stripcmd=
src=
dst=
dir_arg=
dst_arg=
copy_on_change=false
is_target_a_directory=possibly
usage="\
Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
or: $0 [OPTION]... SRCFILES... DIRECTORY
or: $0 [OPTION]... -t DIRECTORY SRCFILES...
or: $0 [OPTION]... -d DIRECTORIES...
In the 1st form, copy SRCFILE to DSTFILE.
In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
In the 4th, create DIRECTORIES.
Options:
--help display this help and exit.
--version display version info and exit.
-c (ignored)
-C install only if different (preserve data modification time)
-d create directories instead of installing files.
-g GROUP $chgrpprog installed files to GROUP.
-m MODE $chmodprog installed files to MODE.
-o USER $chownprog installed files to USER.
-p pass -p to $cpprog.
-s $stripprog installed files.
-S SUFFIX attempt to back up existing files, with suffix SUFFIX.
-t DIRECTORY install into DIRECTORY.
-T report an error if DSTFILE is a directory.
Environment variables override the default commands:
CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
RMPROG STRIPPROG
By default, rm is invoked with -f; when overridden with RMPROG,
it's up to you to specify -f if you want it.
If -S is not specified, no backups are attempted.
Email bug reports to bug-automake@gnu.org.
Automake home page: https://www.gnu.org/software/automake/
"
while test $# -ne 0; do
case $1 in
-c) ;;
-C) copy_on_change=true;;
-d) dir_arg=true;;
-g) chgrpcmd="$chgrpprog $2"
shift;;
--help) echo "$usage"; exit $?;;
-m) mode=$2
case $mode in
*' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
echo "$0: invalid mode: $mode" >&2
exit 1;;
esac
shift;;
-o) chowncmd="$chownprog $2"
shift;;
-p) cpprog="$cpprog -p";;
-s) stripcmd=$stripprog;;
-S) backupsuffix="$2"
shift;;
-t)
is_target_a_directory=always
dst_arg=$2
# Protect names problematic for 'test' and other utilities.
case $dst_arg in
-* | [=\(\)!]) dst_arg=./$dst_arg;;
esac
shift;;
-T) is_target_a_directory=never;;
--version) echo "$0 $scriptversion"; exit $?;;
--) shift
break;;
-*) echo "$0: invalid option: $1" >&2
exit 1;;
*) break;;
esac
shift
done
# We allow the use of options -d and -T together, by making -d
# take the precedence; this is for compatibility with GNU install.
if test -n "$dir_arg"; then
if test -n "$dst_arg"; then
echo "$0: target directory not allowed when installing a directory." >&2
exit 1
fi
fi
if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
# When -d is used, all remaining arguments are directories to create.
# When -t is used, the destination is already specified.
# Otherwise, the last argument is the destination. Remove it from $@.
for arg
do
if test -n "$dst_arg"; then
# $@ is not empty: it contains at least $arg.
set fnord "$@" "$dst_arg"
shift # fnord
fi
shift # arg
dst_arg=$arg
# Protect names problematic for 'test' and other utilities.
case $dst_arg in
-* | [=\(\)!]) dst_arg=./$dst_arg;;
esac
done
fi
if test $# -eq 0; then
if test -z "$dir_arg"; then
echo "$0: no input file specified." >&2
exit 1
fi
# It's OK to call 'install-sh -d' without argument.
# This can happen when creating conditional directories.
exit 0
fi
if test -z "$dir_arg"; then
if test $# -gt 1 || test "$is_target_a_directory" = always; then
if test ! -d "$dst_arg"; then
echo "$0: $dst_arg: Is not a directory." >&2
exit 1
fi
fi
fi
if test -z "$dir_arg"; then
do_exit='(exit $ret); exit $ret'
trap "ret=129; $do_exit" 1
trap "ret=130; $do_exit" 2
trap "ret=141; $do_exit" 13
trap "ret=143; $do_exit" 15
# Set umask so as not to create temps with too-generous modes.
# However, 'strip' requires both read and write access to temps.
case $mode in
# Optimize common cases.
*644) cp_umask=133;;
*755) cp_umask=22;;
*[0-7])
if test -z "$stripcmd"; then
u_plus_rw=
else
u_plus_rw='% 200'
fi
cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
*)
if test -z "$stripcmd"; then
u_plus_rw=
else
u_plus_rw=,u+rw
fi
cp_umask=$mode$u_plus_rw;;
esac
fi
for src
do
# Protect names problematic for 'test' and other utilities.
case $src in
-* | [=\(\)!]) src=./$src;;
esac
if test -n "$dir_arg"; then
dst=$src
dstdir=$dst
test -d "$dstdir"
dstdir_status=$?
# Don't chown directories that already exist.
if test $dstdir_status = 0; then
chowncmd=""
fi
else
# Waiting for this to be detected by the "$cpprog $src $dsttmp" command
# might cause directories to be created, which would be especially bad
# if $src (and thus $dsttmp) contains '*'.
if test ! -f "$src" && test ! -d "$src"; then
echo "$0: $src does not exist." >&2
exit 1
fi
if test -z "$dst_arg"; then
echo "$0: no destination specified." >&2
exit 1
fi
dst=$dst_arg
# If destination is a directory, append the input filename.
if test -d "$dst"; then
if test "$is_target_a_directory" = never; then
echo "$0: $dst_arg: Is a directory" >&2
exit 1
fi
dstdir=$dst
dstbase=`basename "$src"`
case $dst in
*/) dst=$dst$dstbase;;
*) dst=$dst/$dstbase;;
esac
dstdir_status=0
else
dstdir=`dirname "$dst"`
test -d "$dstdir"
dstdir_status=$?
fi
fi
case $dstdir in
*/) dstdirslash=$dstdir;;
*) dstdirslash=$dstdir/;;
esac
obsolete_mkdir_used=false
if test $dstdir_status != 0; then
case $posix_mkdir in
'')
# With -d, create the new directory with the user-specified mode.
# Otherwise, rely on $mkdir_umask.
if test -n "$dir_arg"; then
mkdir_mode=-m$mode
else
mkdir_mode=
fi
posix_mkdir=false
# The $RANDOM variable is not portable (e.g., dash). Use it
# here however when possible just to lower collision chance.
tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
trap '
ret=$?
rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
exit $ret
' 0
# Because "mkdir -p" follows existing symlinks and we likely work
# directly in world-writeable /tmp, make sure that the '$tmpdir'
# directory is successfully created first before we actually test
# 'mkdir -p'.
if (umask $mkdir_umask &&
$mkdirprog $mkdir_mode "$tmpdir" &&
exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
then
if test -z "$dir_arg" || {
# Check for POSIX incompatibilities with -m.
# HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
# other-writable bit of parent directory when it shouldn't.
# FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
test_tmpdir="$tmpdir/a"
ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
case $ls_ld_tmpdir in
d????-?r-*) different_mode=700;;
d????-?--*) different_mode=755;;
*) false;;
esac &&
$mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
}
}
then posix_mkdir=:
fi
rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
else
# Remove any dirs left behind by ancient mkdir implementations.
rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
fi
trap '' 0;;
esac
if
$posix_mkdir && (
umask $mkdir_umask &&
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
)
then :
else
# mkdir does not conform to POSIX,
# or it failed possibly due to a race condition. Create the
# directory the slow way, step by step, checking for races as we go.
case $dstdir in
/*) prefix='/';;
[-=\(\)!]*) prefix='./';;
*) prefix='';;
esac
oIFS=$IFS
IFS=/
set -f
set fnord $dstdir
shift
set +f
IFS=$oIFS
prefixes=
for d
do
test X"$d" = X && continue
prefix=$prefix$d
if test -d "$prefix"; then
prefixes=
else
if $posix_mkdir; then
(umask $mkdir_umask &&
$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
# Don't fail if two instances are running concurrently.
test -d "$prefix" || exit 1
else
case $prefix in
*\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
*) qprefix=$prefix;;
esac
prefixes="$prefixes '$qprefix'"
fi
fi
prefix=$prefix/
done
if test -n "$prefixes"; then
# Don't fail if two instances are running concurrently.
(umask $mkdir_umask &&
eval "\$doit_exec \$mkdirprog $prefixes") ||
test -d "$dstdir" || exit 1
obsolete_mkdir_used=true
fi
fi
fi
if test -n "$dir_arg"; then
{ test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
{ test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
{ test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
else
# Make a couple of temp file names in the proper directory.
dsttmp=${dstdirslash}_inst.$$_
rmtmp=${dstdirslash}_rm.$$_
# Trap to clean up those temp files at exit.
trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
# Copy the file name to the temp name.
(umask $cp_umask &&
{ test -z "$stripcmd" || {
# Create $dsttmp read-write so that cp doesn't create it read-only,
# which would cause strip to fail.
if test -z "$doit"; then
: >"$dsttmp" # No need to fork-exec 'touch'.
else
$doit touch "$dsttmp"
fi
}
} &&
$doit_exec $cpprog "$src" "$dsttmp") &&
# and set any options; do chmod last to preserve setuid bits.
#
# If any of these fail, we abort the whole thing. If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $cpprog $src $dsttmp" command.
#
{ test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
{ test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
{ test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
{ test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
# If -C, don't bother to copy if it wouldn't change the file.
if $copy_on_change &&
old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
set -f &&
set X $old && old=:$2:$4:$5:$6 &&
set X $new && new=:$2:$4:$5:$6 &&
set +f &&
test "$old" = "$new" &&
$cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
then
rm -f "$dsttmp"
else
# If $backupsuffix is set, and the file being installed
# already exists, attempt a backup. Don't worry if it fails,
# e.g., if mv doesn't support -f.
if test -n "$backupsuffix" && test -f "$dst"; then
$doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
fi
# Rename the file to the real destination.
$doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
# The rename failed, perhaps because mv can't rename something else
# to itself, or perhaps because mv is so ancient that it does not
# support -f.
{
# Now remove or move aside any old file at destination location.
# We try this two ways since rm can't unlink itself on some
# systems and the destination file might be busy for other
# reasons. In this case, the final cleanup might fail but the new
# file should still install successfully.
{
test ! -f "$dst" ||
$doit $rmcmd "$dst" 2>/dev/null ||
{ $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
{ $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
} ||
{ echo "$0: cannot unlink or rename $dst" >&2
(exit 1); exit 1
}
} &&
# Now rename the file to the real destination.
$doit $mvcmd "$dsttmp" "$dst"
}
fi || exit 1
trap '' 0
fi
done
# Local variables:
# eval: (add-hook 'before-save-hook 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:
pgbouncer-1.24.1/COPYRIGHT 0000644 0001750 0000000 00000001477 14777762222 012013 0000000 0000000 PgBouncer - Lightweight connection pooler for PostgreSQL.
ISC License
Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
pgbouncer-1.24.1/win32/ 0000755 0000000 0000000 00000000000 14777762567 011530 5 0000000 0000000 pgbouncer-1.24.1/win32/eventmsg.rc 0000644 0001750 0000000 00000000047 14777762222 013630 0000000 0000000 LANGUAGE 0x9,0x1
1 11 "MSG00001.bin"
pgbouncer-1.24.1/win32/pgbevent.c 0000644 0001750 0000000 00000005124 14777762222 013431 0000000 0000000 /*-------------------------------------------------------------------------
* pgbevent.c
* Defines the entry point for pgbevent dll.
* The DLL defines event source for pgbouncer tools
*-------------------------------------------------------------------------
*/
#define WIN32_LEAN_AND_MEAN
#include
#include
#include
#define APP_KEY "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\pgbouncer"
/* Global variables */
static HANDLE g_module = NULL; /* hModule of DLL */
/* Prototypes */
STDAPI DllRegisterServer(void);
STDAPI DllUnregisterServer(void);
BOOL WINAPI DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved);
/*
* DllRegisterServer --- Instructs DLL to create its registry entries
*/
STDAPI DllRegisterServer(void)
{
HKEY key;
DWORD data;
char buffer[_MAX_PATH];
/* Set the name of DLL full path name. */
if (!GetModuleFileName((HMODULE)g_module, buffer, sizeof(buffer))) {
MessageBox(NULL, "Could not retrieve DLL filename", "pgbouncer error", MB_OK | MB_ICONSTOP);
return SELFREG_E_TYPELIB;
}
/*
* Add our source name as a subkey under the Application key in
* the EventLog registry key.
*/
if (RegCreateKey(HKEY_LOCAL_MACHINE, APP_KEY, &key)) {
MessageBox(NULL, "Could not create the registry key.", "pgbouncer error", MB_OK | MB_ICONSTOP);
return SELFREG_E_TYPELIB;
}
/* Add the name to the EventMessageFile subkey. */
if (RegSetValueEx(key, "EventMessageFile", 0, REG_EXPAND_SZ, (LPBYTE)buffer, strlen(buffer) + 1)) {
MessageBox(NULL, "Could not set the event message file.", "pgbouncer error", MB_OK | MB_ICONSTOP);
return SELFREG_E_TYPELIB;
}
/* Set the supported event types in the TypesSupported subkey. */
data = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
if (RegSetValueEx(key, "TypesSupported", 0, REG_DWORD, (LPBYTE)&data, sizeof(DWORD))) {
MessageBox(NULL, "Could not set the supported types.", "pgbouncer error", MB_OK | MB_ICONSTOP);
return SELFREG_E_TYPELIB;
}
RegCloseKey(key);
return S_OK;
}
/*
* DllUnregisterServer --- Instructs DLL to remove only those entries created through DllRegisterServer
*/
STDAPI DllUnregisterServer(void)
{
if (RegDeleteKey(HKEY_LOCAL_MACHINE, APP_KEY)) {
MessageBox(NULL, "Could not delete the registry key.", "pgbouncer error", MB_OK | MB_ICONSTOP);
return SELFREG_E_TYPELIB;
}
return S_OK;
}
/*
* DllMain --- is an optional entry point into a DLL.
*/
BOOL WINAPI DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
if (ul_reason_for_call == DLL_PROCESS_ATTACH)
g_module = hModule;
return TRUE;
}
pgbouncer-1.24.1/win32/win32support.h 0000644 0001750 0000000 00000000136 14777762222 014221 0000000 0000000 /* redirect main() */
#define main(a,b) real_main(a,b)
int real_main(int argc, char *argv[]);
pgbouncer-1.24.1/win32/eventmsg.mc 0000644 0001750 0000000 00000000075 14777762222 013624 0000000 0000000 MessageId=0
SymbolicName=MSG_PGBOUNCER
Language=English
%1
.
pgbouncer-1.24.1/win32/MSG00001.bin 0000644 0001750 0000000 00000000040 14777762222 013144 0000000 0000000 % 1
pgbouncer-1.24.1/win32/win32ver.rc 0000644 0001750 0000000 00000001450 14777762222 013456 0000000 0000000 #include
#include "usual/config.h"
// https://docs.microsoft.com/en-us/windows/win32/menurc/versioninfo-resource
VS_VERSION_INFO VERSIONINFO
FILEVERSION PACKAGE_VERSION_4B
PRODUCTVERSION PACKAGE_VERSION_4B
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0x0L
FILEOS VOS_NT_WINDOWS32
FILETYPE VFT_APP
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904B0" // U.S. English, Unicode
BEGIN
VALUE "CompanyName", "PgBouncer developers"
VALUE "FileDescription", "connection pooler for PostgreSQL"
VALUE "FileVersion", PACKAGE_VERSION
VALUE "ProductName", PACKAGE_NAME
VALUE "ProductVersion", PACKAGE_VERSION
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x0409, 1200 // U.S. English, Unicode
END
END
pgbouncer-1.24.1/win32/win32support.c 0000644 0001750 0000000 00000016765 14777762222 014233 0000000 0000000 /*-------------------------------------------------------------------------
* win32service.c
*
* Windows service integration and eventlog
*
* Copyright (c) 2005, PostgreSQL Global Development Group
* Authors: Magnus Hagander, Hiroshi Saito, Marko Kreen
*-------------------------------------------------------------------------
*/
#include "bouncer.h"
#include "win32support.h"
#if defined(UNICODE) || defined(_UNICODE)
#error This code does not support wide characters.
#endif
/* Globals for service control */
static SERVICE_STATUS_HANDLE hStatus = 0;
static SERVICE_STATUS svcStatus = {
.dwServiceType = SERVICE_WIN32_OWN_PROCESS,
.dwControlsAccepted = 0,
.dwWin32ExitCode = NO_ERROR,
.dwCheckPoint = 0,
.dwWaitHint = 0,
.dwCurrentState = SERVICE_START_PENDING,
};
/* Event source name for ReportEvent.
*
* Also used as placeholder for service handling API's, but it is ignored
* because our service is defined as WIN32_OWN_PROCESS.
*/
static char *servicename = "pgbouncer";
static char *service_username = NULL;
static char *service_password = NULL;
static char *serviceDescription = "Lightweight connection pooler for PostgreSQL.";
static int exec_real_main(int argc, char *argv[])
{
/* win32 stdio seems to be fully buffered by default */
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
/* call actual main() */
return real_main(argc, argv);
}
/* Set the current service status */
static void win32_setservicestatus(DWORD state)
{
svcStatus.dwCurrentState = state;
switch (state) {
case SERVICE_START_PENDING:
case SERVICE_STOP_PENDING:
svcStatus.dwControlsAccepted = 0;
svcStatus.dwWaitHint = 5000;
break;
default:
svcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
svcStatus.dwWaitHint = 0;
}
SetServiceStatus(hStatus, &svcStatus);
}
/*
* Handle any events sent by the service control manager
* NOTE! Events are sent on a different thread! And it's
* not a pthreads thread, so avoid calling anything that
* may use pthreads - like pgbouncer_log()
*/
static void WINAPI win32_servicehandler(DWORD request)
{
switch (request) {
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_SHUTDOWN:
win32_setservicestatus(SERVICE_STOP_PENDING);
cf_shutdown = SHUTDOWN_IMMEDIATE;
break;
case SERVICE_CONTROL_INTERROGATE:
SetServiceStatus(hStatus, &svcStatus);
break;
}
}
/* notify control thread about stop */
static void win32_service_cleanup(void)
{
if (hStatus)
win32_setservicestatus(SERVICE_STOPPED);
hStatus = 0; /* may get called twice from atexit */
}
/*
* Entrypoint for actual service work.
*
* Service is set-up and then actual main() is called.
*/
static void WINAPI win32_servicemain(DWORD argc, LPSTR *argv)
{
int new_argc = 2;
char *new_argv[] = { servicename, cf_config_file, NULL };
/* register control request handler */
hStatus = RegisterServiceCtrlHandler(servicename, win32_servicehandler);
if (hStatus == 0)
die("could not connect to service control handler: %s", strerror(GetLastError()));
/* Tell SCM we are running before we make any API calls */
win32_setservicestatus(SERVICE_RUNNING);
/* register with system atexit(), in case somebody calls exit() */
atexit(win32_service_cleanup);
/* Execute actual main() */
exec_real_main(new_argc, new_argv);
win32_service_cleanup();
}
/* Start running as a service */
static void win32_servicestart(void)
{
SERVICE_TABLE_ENTRY st[] = { {servicename, win32_servicemain}, {NULL, NULL} };
if (StartServiceCtrlDispatcher(st) == 0) {
fprintf(stderr, "could not start service control dispatcher: %s\n",
strerror(GetLastError()));
exit(1);
}
}
/* Open Service Control Manager */
static SC_HANDLE openSCM(void)
{
SC_HANDLE manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (!manager) {
fprintf(stderr, "Failed to open service control manager: %s\n", strerror(GetLastError()));
exit(1);
}
return manager;
}
/* Full path to current config file. */
static const char *get_config_fullpath(void)
{
DWORD r;
static char buf[PATH_MAX];
r = GetFullPathName(cf_config_file, sizeof(buf), buf, NULL);
if (r == 0 || r >= sizeof(buf)) {
fprintf(stderr, "Failed to get full pathname for '%s': %s\n",
cf_config_file, strerror(GetLastError()));
exit(1);
}
return buf;
}
/* Register a service with the specified name with the local service control manager */
static void RegisterService(void)
{
char self[1024];
char cmdline[2048];
const char *config_fn = get_config_fullpath();
SC_HANDLE manager;
SC_HANDLE service;
SERVICE_DESCRIPTION sd;
DWORD r;
r = GetModuleFileName(NULL, self, sizeof(self));
if (!r || r >= sizeof(self)) {
fprintf(stderr, "Failed to determine path name: %s\n", strerror(GetLastError()));
exit(1);
}
snprintf(cmdline, sizeof(cmdline), "%s --service \"%s\"", self, config_fn);
manager = openSCM();
service = CreateService(manager, cf_jobname, cf_jobname, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, cmdline, NULL, NULL, "RPCSS\0",
service_username, service_password);
if (!service) {
fprintf(stderr, "Failed to create service: %s\n", strerror(GetLastError()));
exit(1);
}
/* explain the service purpose */
sd.lpDescription = serviceDescription;
ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &sd);
CloseServiceHandle(service);
CloseServiceHandle(manager);
printf("Service registered.\n");
if (service_username == NULL) {
printf("\nWARNING! Service is registered to run as Local System. You are\n");
printf("encouraged to change this to a low privilege account to increase\n");
printf("system security. (Eg. NT AUTHORITY\\Local Service)\n");
}
}
/* Remove a service with the specified name from the local service control manager */
static void UnRegisterService(void)
{
SC_HANDLE manager;
SC_HANDLE service;
manager = openSCM();
service = OpenService(manager, cf_jobname, SC_MANAGER_ALL_ACCESS);
if (!service) {
fprintf(stderr, "Failed to open service: %s\n", strerror(GetLastError()));
exit(1);
}
if (!DeleteService(service)) {
fprintf(stderr, "Failed to delete service: %s\n", strerror(GetLastError()));
exit(1);
}
CloseServiceHandle(service);
CloseServiceHandle(manager);
printf("Service removed.\n");
}
/* config loader for service register/unregister */
static void win32_load_config(char *conf)
{
cf_config_file = conf;
init_objects();
load_config();
}
/*
* Wrapper around actual main() that handles win32 hacks.
*/
#undef main
int main(int argc, char *argv[])
{
WSADATA wsaData;
/* initialize socket subsystem */
if (WSAStartup(MAKEWORD(2,0), &wsaData))
die("could not start the network subsystem");
/* service cmdline */
if (argc >= 3) {
if (strcmp(argv[1], "--service") == 0 || strcmp(argv[1], "-service") == 0) {
cf_quiet = 1;
cf_config_file = argv[2];
win32_servicestart();
return 0;
}
if (strcmp(argv[1], "--regservice") == 0 || strcmp(argv[1], "-regservice") == 0) {
int i;
win32_load_config(argv[2]);
for (i = 3; i < argc; i++) {
if (strcmp(argv[i], "-U") == 0 && i + 1 < argc) {
service_username = argv[++i];
} else if (strcmp(argv[i], "-P") == 0 && i + 1 < argc) {
service_password = argv[++i];
} else {
fprintf(stderr, "unknown arg: %s\n", argv[i]);
fprintf(stderr, "Try \"%s --help\" for more information.\n", argv[0]);
exit(1);
}
}
RegisterService();
return 0;
}
if (strcmp(argv[1], "--unregservice") == 0 || strcmp(argv[1], "-unregservice") == 0) {
win32_load_config(argv[2]);
UnRegisterService();
return 0;
}
}
return exec_real_main(argc, argv);
}
pgbouncer-1.24.1/win32/Makefile 0000644 0001750 0000000 00000000115 14777762222 013106 0000000 0000000 # create eventmsg.rc + MSG*.bin
eventmsg.rc: eventmsg.mc
mc.exe eventmsg.mc
pgbouncer-1.24.1/etc/ 0000755 0000000 0000000 00000000000 14777762567 011341 5 0000000 0000000 pgbouncer-1.24.1/etc/pgbouncer.socket 0000644 0001750 0000000 00000001263 14777762222 014462 0000000 0000000 # Example systemd socket unit for PgBouncer
#
# Note that /var/run/postgresql/ would typically be owned or managed
# by the respective PostgreSQL package. If you specify it here,
# systemd will create it first, which might upset the PostgreSQL
# package (or not). See pgbouncer.service for further context.
#
[Unit]
Description=sockets for PgBouncer
[Socket]
ListenStream=/tmp/.s.PGSQL.6432
#ListenStream=/var/run/postgresql/.s.PGSQL.6432
#ListenStream=6432
# additional settings that might be useful
#Backlog=
#SocketUser=
#SocketGroup=
#SocketMode=
#KeepAlive=
#KeepAliveTimeSec=
#KeepAliveIntervalSec=
#KeepAliveProbes=
#DeferAcceptSec=
#ReusePort=
[Install]
WantedBy=sockets.target
pgbouncer-1.24.1/etc/example.debian.init.sh 0000644 0001750 0000000 00000002054 14777762222 015435 0000000 0000000 #!/bin/bash
#
# pgbouncer Start the PgBouncer PostgreSQL pooler.
#
# The variables below are NOT to be changed. They are there to make the
# script more readable.
NAME=pgbouncer
DAEMON=/usr/bin/$NAME
PIDFILE=/var/run/$NAME.pid
CONF=/etc/$NAME.ini
OPTS="-d $CONF"
# note: SSD is required only at startup of the daemon.
SSD=`command -v start-stop-daemon`
ENV="env -i LANG=C PATH=/bin:/usr/bin:/usr/local/bin"
trap "" 1
# Check if configuration exists
test -f $CONF || exit 0
case "$1" in
start)
echo -n "Starting server: $NAME"
$ENV $SSD --start --pidfile $PIDFILE --exec $DAEMON -- $OPTS > /dev/null
;;
stop)
echo -n "Stopping server: $NAME"
start-stop-daemon --stop --pidfile $PIDFILE
;;
reload | force-reload)
echo -n "Reloading $NAME configuration"
start-stop-daemon --stop --pidfile $PIDFILE --signal HUP
;;
restart)
$0 stop
$0 start
;;
*)
echo "Usage: /etc/init.d/$NAME {start|stop|reload|restart}"
exit 1
;;
esac
if [ $? -eq 0 ]; then
echo .
exit 0
else
echo " failed"
exit 1
fi
pgbouncer-1.24.1/etc/pgbouncer.service 0000644 0001750 0000000 00000002703 14777762222 014632 0000000 0000000 # Example systemd service unit for PgBouncer
#
# - Adjust the paths in ExecStart for your installation.
#
# - For systemd 253 and later, PgBouncer supports Type=notify-reload
# (instead of Type=notify with ExecReload= command).
#
# - The User setting requires careful consideration. PgBouncer needs
# to be able to place a Unix-domain socket file where PostgreSQL
# clients will look for it. In the olden days, this was in /tmp,
# but systems using systemd now prefer something like
# /var/run/postgresql/. But then some systems also lock down that
# directory so that only the postgres user can write to it. That
# means you need to either
#
# - run PgBouncer as the postgres user, or
#
# - create a separate user and add it to the postgres group and
# make /var/run/postgresql/ group-writable, or
#
# - use systemd to create the sockets; see pgbouncer.socket nearby.
#
# For packagers and deployment systems, this requires some
# coordination between the PgBouncer and the PostgreSQL
# packages/components.
#
[Unit]
Description=connection pooler for PostgreSQL
Documentation=man:pgbouncer(1)
Documentation=https://www.pgbouncer.org/
After=network-online.target
Wants=network-online.target
#Requires=pgbouncer.socket
[Service]
Type=notify
User=postgres
ExecStart=/usr/bin/pgbouncer /etc/pgbouncer/pgbouncer.ini
ExecReload=/bin/kill -HUP $MAINPID
KillSignal=SIGINT
Restart=on-failure
#LimitNOFILE=1024
[Install]
WantedBy=multi-user.target
pgbouncer-1.24.1/etc/userlist.txt 0000644 0001750 0000000 00000000070 14777762222 013672 0000000 0000000 "marko" "asdasd"
"postgres" "asdasd"
"pgbouncer" "fake"
pgbouncer-1.24.1/etc/optscan.sh 0000755 0001750 0000000 00000000602 14777762222 013266 0000000 0000000 #! /bin/sh
# Check if all options in main.c are defined in sample ini and docs
sources="src/main.c"
targets="doc/config.md etc/pgbouncer.ini"
status=0
for opt in `grep CF_ABS "$sources" | sed -r 's/^[^"]*"([^"]*)".*/\1/'`; do
for conf in $targets; do
if ! grep -q "$opt" "$conf"; then
echo "$opt is missing in $conf" 1>&2
status=1
fi
done
done
exit $status
pgbouncer-1.24.1/etc/pgbouncer.ini 0000644 0001750 0000000 00000024637 14777762222 013763 0000000 0000000 ;;;
;;; PgBouncer configuration file
;;;
;; database name = connect string
;;
;; connect string params:
;; dbname= host= port= user= password= auth_user=
;; client_encoding= datestyle= timezone=
;; pool_size= reserve_pool_size= max_db_connections=
;; pool_mode= connect_query= application_name=
[databases]
;; foodb over Unix socket
;foodb =
;; redirect bardb to bazdb on localhost
;bardb = host=localhost dbname=bazdb
;; access to dest database will go with single user
;forcedb = host=localhost port=300 user=baz password=foo client_encoding=UNICODE datestyle=ISO connect_query='SELECT 1'
;; use custom pool sizes
;nondefaultdb = pool_size=50 reserve_pool_size=10
;; use auth_user with auth_query if user not present in auth_file
;; auth_user must exist in auth_file
; foodb = auth_user=bar
;; run auth_query on a specific database.
; bardb = auth_dbname=foo max_db_client_connections=10
;; fallback connect string
;* = host=testserver
;; User-specific configuration
[users]
;user1 = pool_size=5 reserve_pool_size=2 pool_mode=transaction max_user_connections=10 max_user_client_connections=20
;; Configuration section
[pgbouncer]
;;;
;;; Administrative settings
;;;
logfile = /var/log/pgbouncer/pgbouncer.log
pidfile = /var/run/pgbouncer/pgbouncer.pid
;;;
;;; Where to wait for clients
;;;
;; IP address or * which means all IPs
listen_addr = localhost
listen_port = 6432
;; Unix socket is also used for -R.
;; On Debian it should be /var/run/postgresql
;unix_socket_dir = /tmp
;unix_socket_mode = 0777
;unix_socket_group =
;; The peer id used to identify this pgbouncer process in a group of pgbouncer
;; processes that are peered together. When set to 0 pgbouncer peering is disabled
;peer_id = 0
;;;
;;; TLS settings for accepting clients
;;;
;; disable, allow, require, verify-ca, verify-full
;client_tls_sslmode = disable
;; Path to file that contains trusted CA certs
;client_tls_ca_file =
;; Private key and cert to present to clients.
;; Required for accepting TLS connections from clients.
;client_tls_key_file =
;client_tls_cert_file =
;; default, secure, fast, normal,
;client_tls_ciphers = default
;; all, secure, tlsv1.0, tlsv1.1, tlsv1.2, tlsv1.3
;client_tls_protocols = secure
;; none, auto, legacy
;client_tls_dheparams = auto
;; none, auto,
;client_tls_ecdhcurve = auto
;;;
;;; TLS settings for connecting to backend databases
;;;
;; disable, allow, prefer, require, verify-ca, verify-full
;server_tls_sslmode = prefer
;; Path to that contains trusted CA certs
;server_tls_ca_file =
;; Private key and cert to present to backend.
;; Needed only if backend server require client cert.
;server_tls_key_file =
;server_tls_cert_file =
;; all, secure, tlsv1.0, tlsv1.1, tlsv1.2, tlsv1.3
;server_tls_protocols = secure
;; default, secure, fast, normal,
;server_tls_ciphers = default
;;;
;;; Authentication settings
;;;
;; any, trust, plain, md5, cert, hba, pam
auth_type = md5
auth_file = /etc/pgbouncer/userlist.txt
;; Path to HBA-style auth config
;auth_hba_file =
;; Path to Pg-ident-style map file
; auth_ident_file =
;; Query to use to fetch password from database. Result
;; must have 2 columns - username and password hash.
;auth_query = SELECT rolname, CASE WHEN rolvaliduntil < pg_catalog.now() THEN NULL ELSE rolpassword END FROM pg_authid WHERE rolname=$1 AND rolcanlogin
;; Authentication database that can be set globally to run "auth_query".
;auth_dbname =
;;;
;;; Users allowed into database 'pgbouncer'
;;;
;; comma-separated list of users who are allowed to change settings
;admin_users = user2, someadmin, otheradmin
;; comma-separated list of users who are just allowed to use SHOW command
;stats_users = stats, root
;;;
;;; Pooler personality questions
;;;
;; When server connection is released back to pool:
;; session - after client disconnects (default)
;; transaction - after transaction finishes
;; statement - after statement finishes
;pool_mode = session
;; Number of prepared statements to cache on a server connection (zero value
;; disables support of prepared statements).
;max_prepared_statements = 0
;; Query for cleaning connection immediately after releasing from
;; client. No need to put ROLLBACK here, pgbouncer does not reuse
;; connections where transaction is left open.
;server_reset_query = DISCARD ALL
;; Whether server_reset_query should run in all pooling modes. If it
;; is off, server_reset_query is used only for session-pooling.
;server_reset_query_always = 0
;; Comma-separated list of parameters to track per client. The
;; Postgres parameters listed here will be cached per client by
;; pgbouncer and restored in server every time the client runs a query.
;track_extra_parameters = IntervalStyle
;; Comma-separated list of parameters to ignore when given in startup
;; packet. Newer JDBC versions require the extra_float_digits here.
;ignore_startup_parameters = extra_float_digits
;; When taking idle server into use, this query is run first.
;server_check_query = select 1
;; If server was used more recently that this many seconds ago,
;; skip the check query. Value 0 may or may not run in immediately.
;server_check_delay = 30
;; Close servers in session pooling mode after a RECONNECT, RELOAD,
;; etc. when they are idle instead of at the end of the session.
;server_fast_close = 0
;; Use as application_name on server.
;application_name_add_host = 0
;; Period for updating aggregated stats.
;stats_period = 60
;;;
;;; Connection limits
;;;
;; Total number of clients that can connect
;max_client_conn = 100
;; Default pool size. 20 is good number when transaction pooling
;; is in use, in session pooling it needs to be the number of
;; max clients you want to handle at any moment
;default_pool_size = 20
;; Minimum number of server connections to keep in pool.
;min_pool_size = 0
; how many additional connection to allow in case of trouble
;reserve_pool_size = 0
;; If a clients needs to wait more than this many seconds, use reserve
;; pool.
;reserve_pool_timeout = 5
;; Maximum number of server connections for a database
;max_db_connections = 0
;; Maximum number of server connections for a user
;max_user_connections = 0
;; If off, then server connections are reused in LIFO manner
;server_round_robin = 0
;;;
;;; Logging
;;;
;; Syslog settings
;syslog = 0
;syslog_facility = daemon
;syslog_ident = pgbouncer
;; log if client connects or server connection is made
;log_connections = 1
;; log if and why connection was closed
;log_disconnections = 1
;; log error messages pooler sends to clients
;log_pooler_errors = 1
;; write aggregated stats into log
;log_stats = 1
;; Logging verbosity. Same as -v switch on command line.
;verbose = 0
;;;
;;; Timeouts
;;;
;; Close server connection if its been connected longer.
;server_lifetime = 3600
;; Close server connection if its not been used in this time. Allows
;; to clean unnecessary connections from pool after peak.
;server_idle_timeout = 600
;; Cancel connection attempt if server does not answer takes longer.
;server_connect_timeout = 15
;; If server login failed (server_connect_timeout or auth failure)
;; then wait this many second before trying again.
;server_login_retry = 15
;; Dangerous. Server connection is closed if query does not return in
;; this time. Should be used to survive network problems, _not_ as
;; statement_timeout. (default: 0)
;query_timeout = 0
;; Dangerous. Client connection is closed if the query is not
;; assigned to a server in this time. Should be used to limit the
;; number of queued queries in case of a database or network
;; failure. (default: 120)
;query_wait_timeout = 120
;; Dangerous. Client connection is closed if the cancellation request
;; is not assigned to a server in this time. Should be used to limit
;; the time a client application blocks on a queued cancel request in
;; case of a database or network failure. (default: 10)
;cancel_wait_timeout = 10
;; Dangerous. Client connection is closed if no activity in this
;; time. Should be used to survive network problems. (default: 0)
;client_idle_timeout = 0
;; Disconnect clients who have not managed to log in after connecting
;; in this many seconds.
;client_login_timeout = 60
;; Clean automatically created database entries (via "*") if they stay
;; unused in this many seconds.
;autodb_idle_timeout = 3600
;; Close connections which are in "IDLE in transaction" state longer
;; than this many seconds.
;idle_transaction_timeout = 0
;; How long SUSPEND/-R waits for buffer flush before closing
;; connection.
;suspend_timeout = 10
;;;
;;; Low-level tuning options
;;;
;; buffer for streaming packets
;pkt_buf = 4096
;; man 2 listen
;listen_backlog = 128
;; Max number pkt_buf to process in one event loop.
;sbuf_loopcnt = 5
;; Maximum PostgreSQL protocol packet size.
;max_packet_size = 2147483647
;; Set SO_REUSEPORT socket option
;so_reuseport = 0
;; networking options, for info: man 7 tcp
;; Linux: Notify program about new connection only if there is also
;; data received. (Seconds to wait.) On Linux the default is 45, on
;; other OS'es 0.
;tcp_defer_accept = 0
;; In-kernel buffer size (Linux default: 4096)
;tcp_socket_buffer = 0
;; whether tcp keepalive should be turned on (0/1)
;tcp_keepalive = 1
;; The following options are Linux-specific. They also require
;; tcp_keepalive=1.
;; Count of keepalive packets
;tcp_keepcnt = 0
;; How long the connection can be idle before sending keepalive
;; packets
;tcp_keepidle = 0
;; The time between individual keepalive probes
;tcp_keepintvl = 0
;; How long may transmitted data remain unacknowledged before TCP
;; connection is closed (in milliseconds)
;tcp_user_timeout = 0
;; DNS lookup caching time
;dns_max_ttl = 15
;; DNS zone SOA lookup period
;dns_zone_check_period = 0
;; DNS negative result caching time
;dns_nxdomain_ttl = 15
;; Custom resolv.conf file, to set custom DNS servers or other options
;; (default: empty = use OS settings)
;resolv_conf = /etc/pgbouncer/resolv.conf
;;;
;;; Random stuff
;;;
;; Hackish security feature. Helps against SQL injection: when PQexec
;; is disabled, multi-statement cannot be made.
;disable_pqexec = 0
;; Config file to use for next RELOAD/SIGHUP
;; By default contains config file from command line.
;conffile
;; Windows service name to register as. job_name is alias for
;; service_name, used by some Skytools scripts.
;service_name = pgbouncer
;job_name = pgbouncer
;; Read additional config from other file
;%include /etc/pgbouncer/pgbouncer-other.ini
pgbouncer-1.24.1/etc/mkauth.py 0000755 0001750 0000000 00000001623 14777762222 013132 0000000 0000000 #! /usr/bin/env python3
import os
import sys
import tempfile
import psycopg2
if len(sys.argv) != 3:
print("usage: mkauth DSTFN CONNSTR")
sys.exit(1)
# read old file
fn = sys.argv[1]
try:
old = open(fn, "r").read()
except IOError:
old = ""
# create new file data
db = psycopg2.connect(sys.argv[2])
curs = db.cursor()
curs.execute(
"SELECT rolname, CASE WHEN rolvaliduntil < pg_catalog.now() THEN NULL ELSE rolpassword END FROM pg_authid WHERE rolcanlogin order by 1"
)
lines = []
for user, psw in curs.fetchall():
user = user.replace('"', '""')
if not psw:
psw = ""
psw = psw.replace('"', '""')
lines.append('"%s" "%s" ""\n' % (user, psw))
db.commit()
cur = "".join(lines)
# if changed, replace data securely
if old != cur:
fd, tmpfn = tempfile.mkstemp(dir=os.path.split(fn)[0])
f = os.fdopen(fd, "w")
f.write(cur)
f.close()
os.rename(tmpfn, fn)
pgbouncer-1.24.1/etc/pgbouncer-minimal.ini 0000644 0001750 0000000 00000001361 14777762222 015374 0000000 0000000 ;;; This is an almost minimal starter configuration file that only
;;; contains the settings that are either mandatory or almost always
;;; useful. All settings show their default value.
[databases]
;; add yours here
;; fallback
;* =
[pgbouncer]
;; required in daemon mode unless syslog is used
;logfile =
;; required in daemon mode
;pidfile =
;syslog = 0
;; set to enable TCP/IP connections
;listen_addr =
;; PgBouncer port
;listen_port = 6432
;; some systems prefer /var/run/postgresql
;unix_socket_dir = /tmp
;; change to taste
;auth_type = md5
;; probably need this
;auth_file =
;; pool settings are perhaps best done per pool
;pool_mode = session
;default_pool_size = 20
;; should probably be raised for production
;max_client_conn = 100
pgbouncer-1.24.1/src/ 0000755 0000000 0000000 00000000000 14777762567 011355 5 0000000 0000000 pgbouncer-1.24.1/src/system.c 0000644 0001750 0000000 00000006577 14777762222 013005 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Compat functions for OSes where libc does not provide them.
*/
#include "bouncer.h"
#include
#ifdef HAVE_SYS_PARAM_H
#include
#endif
#ifdef HAVE_UCRED_H
#include
#endif
#ifdef HAVE_SYS_UCRED_H
#include
#endif
#ifdef HAVE_PWD_H
#include
#endif
#ifdef HAVE_GRP_H
#include
#endif
void change_user(const char *user)
{
const struct passwd *pw;
gid_t gset[1];
#ifdef WIN32
die("option --user (-u) is not supported on this platform");
#endif
/* check for a valid username */
pw = getpwnam(user);
if (pw == NULL)
die("could not find user '%s' to switch to", user);
gset[0] = pw->pw_gid;
if (getuid() == 0) {
if (setgroups(1, gset) < 0)
die("failed to reset groups: %s", strerror(errno));
}
if (setgid(pw->pw_gid) < 0 || setuid(pw->pw_uid) < 0)
die("failed to assume identity of user '%s': %s", user, strerror(errno));
if (getuid() != pw->pw_uid || geteuid() != pw->pw_uid)
die("setuid() failed to work");
}
/* set permissions & mode for file */
void change_file_mode(const char *fn, mode_t mode,
const char *user_name,
const char *group_name)
{
int res;
uid_t uid = -1;
gid_t gid = -1;
unsigned long val;
char *end;
/* user lookup */
if (user_name && user_name[0]) {
const struct passwd *pw;
val = strtoul(user_name, &end, 0);
if (*end == 0) {
uid = val;
} else {
/* check for a valid username */
pw = getpwnam(user_name);
if (!pw) {
die("could not find user '%s': %s",
user_name, strerror(errno));
}
uid = pw->pw_uid;
}
}
/* group lookup */
if (group_name && group_name[0]) {
struct group *gr;
val = strtoul(group_name, &end, 0);
if (*end == 0) {
gid = val;
} else {
gr = getgrnam(group_name);
if (!gr) {
die("could not find group '%s': %s",
group_name, strerror(errno));
}
gid = gr->gr_gid;
}
}
/* change user/group */
if (uid != (uid_t)-1 || gid != (gid_t)-1) {
res = chown(fn, uid, gid);
if (res != 0) {
die("chown(%s, %u, %u) failed: %s",
fn, uid, gid, strerror(errno));
}
}
/* change mode */
res = chmod(fn, mode);
if (res != 0) {
die("failure to chmod(%s, 0%o): %s",
fn, mode, strerror(errno));
}
}
/*
* UNIX socket helper.
*/
bool check_unix_peer_name(int fd, const char *username)
{
int res;
uid_t peer_uid = -1;
gid_t peer_gid = -1;
struct passwd *pw;
res = getpeereid(fd, &peer_uid, &peer_gid);
if (res < 0)
return false;
pw = getpwuid(peer_uid);
if (!pw)
return false;
return strcmp(pw->pw_name, username) == 0;
}
pgbouncer-1.24.1/src/pooler.c 0000644 0001750 0000000 00000035131 14777762222 012745 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Handling of pooler listening sockets
*/
#include "bouncer.h"
#include
#include
#include
struct ListenSocket {
struct List node;
int fd;
bool active;
struct event ev;
PgAddr addr;
};
static STATLIST(sock_list);
/* hints for getaddrinfo(listen_addr) */
static const struct addrinfo hints = {
.ai_family = AF_UNSPEC,
.ai_socktype = SOCK_STREAM,
.ai_protocol = IPPROTO_TCP,
.ai_flags = AI_PASSIVE,
};
/* should listening sockets be active or suspended? */
static bool need_active = false;
/* is it actually active or suspended? */
static bool pooler_active = false;
/* is listen_addr set, we can only know this by parsing it */
static bool listen_addr_empty = true;
/* on accept() failure sleep 5 seconds */
static struct event ev_err;
static struct timeval err_timeout = {5, 0};
static void tune_accept(int sock, bool on);
/* atexit() cleanup func */
void cleanup_sockets(void)
{
struct ListenSocket *ls;
struct List *el;
/* avoid cleanup if exit() while suspended */
if (cf_pause_mode == P_SUSPEND)
return;
while ((el = statlist_pop(&sock_list)) != NULL) {
ls = container_of(el, struct ListenSocket, node);
if (event_del(&ls->ev) < 0) {
log_warning("cleanup_sockets, event_del: %s", strerror(errno));
}
if (ls->fd > 0) {
safe_close(ls->fd);
ls->fd = 0;
}
if (pga_is_unix(&ls->addr) && cf_unix_socket_dir[0] != '@') {
char buf[sizeof(struct sockaddr_un) + 20];
snprintf(buf, sizeof(buf), "%s/.s.PGSQL.%d", cf_unix_socket_dir, cf_listen_port);
unlink(buf);
}
statlist_remove(&sock_list, &ls->node);
free(ls);
}
}
/*
* initialize another listening socket.
*/
static bool add_listen(int af, const struct sockaddr *sa, int salen)
{
struct ListenSocket *ls;
int sock, res;
char buf[128];
const char *errpos;
log_debug("add_listen: %s", sa2str(sa, buf, sizeof(buf)));
/* create socket */
errpos = "socket";
sock = socket(af, SOCK_STREAM, 0);
if (sock < 0)
goto failed;
/* SO_REUSEADDR behaviour it default in WIN32. */
#ifndef WIN32
/* relaxed binding */
if (af != AF_UNIX) {
int val = 1;
errpos = "setsockopt";
res = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
if (res < 0)
goto failed;
}
#endif
#ifdef IPV6_V6ONLY
/* avoid ipv6 socket's attempt to takeover ipv4 port */
if (af == AF_INET6) {
int val = 1;
errpos = "setsockopt/IPV6_V6ONLY";
res = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof(val));
if (res < 0)
goto failed;
}
#endif
/*
* If configured, set SO_REUSEPORT or equivalent. If it's not
* enabled, just leave the socket alone. (We could also unset
* the socket option in that case, but this area is fairly
* unportable, so perhaps better to avoid it.)
*/
if (af != AF_UNIX && cf_so_reuseport) {
#if defined(SO_REUSEPORT_LB)
int val = 1;
errpos = "setsockopt/SO_REUSEPORT_LB";
res = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT_LB, &val, sizeof(val));
if (res < 0)
goto failed;
#elif defined(SO_REUSEPORT)
int val = 1;
errpos = "setsockopt/SO_REUSEPORT";
res = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val));
if (res < 0)
goto failed;
#else
die("so_reuseport not supported on this platform");
#endif
}
/* bind it */
errpos = "bind";
res = bind(sock, sa, salen);
if (res < 0)
goto failed;
/* set common options */
errpos = "tune_socket";
if (!tune_socket(sock, (af == AF_UNIX)))
goto failed;
/* finally, accept connections */
errpos = "listen";
res = listen(sock, cf_listen_backlog);
if (res < 0)
goto failed;
errpos = "calloc";
ls = calloc(1, sizeof(*ls));
if (!ls)
goto failed;
list_init(&ls->node);
ls->fd = sock;
if (sa->sa_family == AF_UNIX) {
pga_set(&ls->addr, AF_UNIX, cf_listen_port);
} else {
pga_copy(&ls->addr, sa);
}
if (af == AF_UNIX) {
#ifndef WIN32
if (cf_unix_socket_dir[0] != '@') {
struct sockaddr_un *un = (struct sockaddr_un *)sa;
change_file_mode(un->sun_path, cf_unix_socket_mode, NULL, cf_unix_socket_group);
}
#endif
} else {
tune_accept(sock, cf_tcp_defer_accept);
}
log_info("listening on %s", sa2str(sa, buf, sizeof(buf)));
statlist_append(&sock_list, &ls->node);
return true;
failed:
log_warning("cannot listen on %s: %s(): %s",
sa2str(sa, buf, sizeof(buf)),
errpos, strerror(errno));
if (sock >= 0)
safe_close(sock);
return false;
}
static void create_unix_socket(const char *socket_dir, int listen_port)
{
struct sockaddr_un un;
int addrlen;
int res;
char lockfile[sizeof(struct sockaddr_un) + 10];
struct stat st;
/* fill sockaddr struct */
memset(&un, 0, sizeof(un));
un.sun_family = AF_UNIX;
snprintf(un.sun_path, sizeof(un.sun_path),
"%s/.s.PGSQL.%d", socket_dir, listen_port);
if (socket_dir[0] == '@') {
/*
* By convention, for abstract Unix sockets, only the
* length of the string is the sockaddr length.
*/
addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
un.sun_path[0] = '\0';
} else {
addrlen = sizeof(un);
}
if (socket_dir[0] != '@') {
/* check for lockfile */
snprintf(lockfile, sizeof(lockfile), "%s.lock", un.sun_path);
res = lstat(lockfile, &st);
if (res == 0)
die("unix port %d is in use", listen_port);
/* expect old bouncer gone */
unlink(un.sun_path);
}
/*
* The user expects a socket to be created in this directory and a simple
* typo might cause this to fail. So we fail hard to notify the user that
* we were unable to create the socket. Not creating the socket is
* especially bad when so_reuseport is used in combination with peering,
* because the peer list would then contain sockets that don't exist and
* forwarding cancels would wait for timeout and then fail silently.
*
* The exact directory is already listed in a warning created by
* add_listen, so we don't show it here again.
*/
if (!add_listen(AF_UNIX, (const struct sockaddr *)&un, addrlen))
die("failed to create unix socket");
}
/*
* Notify pooler only when also data is arrived.
*
* optval specifies how long after connection attempt to wait for data.
*
* Related to tcp_synack_retries sysctl, default 5 (corresponds 180 secs).
*/
static void tune_accept(int sock, bool on)
{
const char *act = on ? "install" : "uninstall";
int res = 0;
#ifdef TCP_DEFER_ACCEPT
int val = 45; /* FIXME: proper value */
socklen_t vlen = sizeof(val);
if (getsockopt(sock, IPPROTO_TCP, TCP_DEFER_ACCEPT, &val, &vlen) == 0)
log_noise("old TCP_DEFER_ACCEPT on %d = %d", sock, val);
val = on ? 1 : 0;
log_noise("%s TCP_DEFER_ACCEPT on %d", act, sock);
res = setsockopt(sock, IPPROTO_TCP, TCP_DEFER_ACCEPT, &val, sizeof(val));
#else
if (on) {
errno = EINVAL;
res = -1;
}
#endif
if (res < 0) {
log_warning("tune_accept: %s TCP_DEFER_ACCEPT: %s",
act, strerror(errno));
}
}
void pooler_tune_accept(bool on)
{
struct List *el;
struct ListenSocket *ls;
statlist_for_each(el, &sock_list) {
ls = container_of(el, struct ListenSocket, node);
if (!pga_is_unix(&ls->addr))
tune_accept(ls->fd, on);
}
}
static void err_wait_func(evutil_socket_t sock, short flags, void *arg)
{
if (cf_pause_mode != P_SUSPEND)
resume_pooler();
}
static const char *addrpair(const PgAddr *src, const PgAddr *dst)
{
static char ip1buf[PGADDR_BUF], ip2buf[PGADDR_BUF],
buf[2*PGADDR_BUF + 16];
const char *ip1, *ip2;
if (pga_is_unix(src))
return "unix->unix";
ip1 = pga_ntop(src, ip1buf, sizeof(ip1buf));
ip2 = pga_ntop(dst, ip2buf, sizeof(ip2buf));
snprintf(buf, sizeof(buf), "%s:%d -> %s:%d",
ip1, pga_port(src), ip2, pga_port(dst));
return buf;
}
static const char *conninfo(const PgSocket *sk)
{
if (is_server_socket(sk)) {
return addrpair(&sk->local_addr, &sk->remote_addr);
} else {
return addrpair(&sk->remote_addr, &sk->local_addr);
}
}
/* got new connection, associate it with client struct */
static void pool_accept(evutil_socket_t sock, short flags, void *arg)
{
struct ListenSocket *ls = arg;
int fd;
PgSocket *client;
union {
struct sockaddr_in in;
struct sockaddr_in6 in6;
struct sockaddr_un un;
struct sockaddr sa;
} raddr;
socklen_t len = sizeof(raddr);
bool is_unix = pga_is_unix(&ls->addr);
if (!(flags & EV_READ)) {
log_warning("no EV_READ in pool_accept");
return;
}
loop:
/* get fd */
fd = safe_accept(sock, &raddr.sa, &len);
if (fd < 0) {
if (errno == EAGAIN)
return;
else if (errno == ECONNABORTED)
return;
/*
* probably fd limit, pointless to try often
* wait a bit, hope that admin resolves somehow
*/
log_error("accept() failed: %s", strerror(errno));
evtimer_assign(&ev_err, pgb_event_base, err_wait_func, NULL);
safe_evtimer_add(&ev_err, &err_timeout);
suspend_pooler();
return;
}
log_noise("new fd from accept=%d", fd);
if (is_unix) {
client = accept_client(fd, true);
} else {
client = accept_client(fd, false);
}
if (client)
slog_debug(client, "P: got connection: %s", conninfo(client));
/*
* there may be several clients waiting,
* avoid context switch by looping
*/
goto loop;
}
bool use_pooler_socket(int sock, bool is_unix)
{
struct ListenSocket *ls;
int res;
char buf[PGADDR_BUF];
if (!tune_socket(sock, is_unix))
return false;
ls = calloc(1, sizeof(*ls));
if (!ls)
return false;
ls->fd = sock;
if (is_unix) {
pga_set(&ls->addr, AF_UNIX, cf_listen_port);
} else {
struct sockaddr_storage ss;
socklen_t len = sizeof(ss);
res = getsockname(sock, (struct sockaddr *)&ss, &len);
if (res < 0) {
log_error("getsockname failed");
free(ls);
return false;
}
pga_copy(&ls->addr, (struct sockaddr *)&ss);
}
log_info("got pooler socket: %s", pga_str(&ls->addr, buf, sizeof(buf)));
statlist_append(&sock_list, &ls->node);
return true;
}
void suspend_pooler(void)
{
struct List *el;
struct ListenSocket *ls;
need_active = false;
statlist_for_each(el, &sock_list) {
ls = container_of(el, struct ListenSocket, node);
if (!ls->active)
continue;
if (event_del(&ls->ev) < 0) {
log_warning("suspend_pooler, event_del: %s", strerror(errno));
return;
}
ls->active = false;
}
pooler_active = false;
}
void resume_pooler(void)
{
struct List *el;
struct ListenSocket *ls;
need_active = true;
statlist_for_each(el, &sock_list) {
ls = container_of(el, struct ListenSocket, node);
if (ls->active)
continue;
event_assign(&ls->ev, pgb_event_base, ls->fd, EV_READ | EV_PERSIST, pool_accept, ls);
if (event_add(&ls->ev, NULL) < 0) {
log_warning("event_add failed: %s", strerror(errno));
return;
}
ls->active = true;
}
pooler_active = true;
}
/* retry previously failed suspend_pooler() / resume_pooler() */
void per_loop_pooler_maint(void)
{
if (need_active && !pooler_active)
resume_pooler();
else if (!need_active && pooler_active)
suspend_pooler();
}
static bool parse_addr(void *arg, const char *addr)
{
int res;
char service[64];
struct addrinfo *ai, *gaires = NULL;
if (!*addr)
return true;
listen_addr_empty = false;
if (strcmp(addr, "*") == 0)
addr = NULL;
snprintf(service, sizeof(service), "%d", cf_listen_port);
res = getaddrinfo(addr, service, &hints, &gaires);
if (res != 0) {
die("getaddrinfo('%s', '%d') = %s [%d]", addr ? addr : "*",
cf_listen_port, gai_strerror(res), res);
}
for (ai = gaires; ai; ai = ai->ai_next) {
/*
* add_listen() will log a warning if there is a
* problem. We don't use the return value to fail the
* whole thing, because that might lead to problems in
* practice with overlapping host names or address
* families and other weird stuff. If no address at all
* can be listened on though, we do fail hard later.
*/
add_listen(ai->ai_family, ai->ai_addr, ai->ai_addrlen);
}
freeaddrinfo(gaires);
return true;
}
/* listen on socket - should happen after all other initializations */
void pooler_setup(void)
{
int n;
n = sd_listen_fds(0);
if (n > 0) {
if (cf_listen_addr && *cf_listen_addr)
log_warning("sockets passed from service manager, cf_listen_addr ignored");
if (cf_unix_socket_dir && *cf_unix_socket_dir && strcmp(cf_unix_socket_dir, DEFAULT_UNIX_SOCKET_DIR) != 0)
log_warning("sockets passed from service manager, cf_unix_socket_dir ignored");
for (int i = 0; i < n; i++) {
int fd = SD_LISTEN_FDS_START + i;
struct ListenSocket *ls;
bool ok = true;
ls = calloc(1, sizeof(*ls));
if (!ls)
die("out of memory");
list_init(&ls->node);
ls->fd = fd;
if (sd_is_socket(fd, AF_UNIX, 0, -1)) {
pga_set(&ls->addr, AF_UNIX, 0);
if (!tune_socket(fd, true))
ok = false;
} else if (sd_is_socket(fd, AF_INET, 0, -1)) {
pga_set(&ls->addr, AF_INET, 0);
if (!tune_socket(fd, false))
ok = false;
tune_accept(fd, cf_tcp_defer_accept);
} else if (sd_is_socket(fd, AF_INET6, 0, -1)) {
pga_set(&ls->addr, AF_INET6, 0);
if (!tune_socket(fd, false))
ok = false;
tune_accept(fd, cf_tcp_defer_accept);
}
if (!ok)
die("failed to set up socket passed from service manager (fd %d)", fd);
log_info("socket passed from service manager (fd %d)", fd);
statlist_append(&sock_list, &ls->node);
}
} else {
bool ok;
static bool init_done = false;
if (!init_done) {
/* remove socket on shutdown */
atexit(cleanup_sockets);
init_done = true;
}
ok = parse_word_list(cf_listen_addr, parse_addr, NULL);
if (!ok)
die("failed to parse listen_addr list: %s", cf_listen_addr);
if (!listen_addr_empty && !statlist_count(&sock_list))
die("failed to listen on any address in listen_addr list: %s", cf_listen_addr);
if (cf_unix_socket_dir && *cf_unix_socket_dir)
create_unix_socket(cf_unix_socket_dir, cf_listen_port);
}
if (!statlist_count(&sock_list))
die("nowhere to listen on");
resume_pooler();
}
bool for_each_pooler_fd(pooler_cb cbfunc, void *arg)
{
struct List *el;
struct ListenSocket *ls;
bool ok;
statlist_for_each(el, &sock_list) {
ls = container_of(el, struct ListenSocket, node);
ok = cbfunc(arg, ls->fd, &ls->addr);
if (!ok)
return false;
}
return true;
}
pgbouncer-1.24.1/src/sbuf.c 0000644 0001750 0000000 00000116260 14777762222 012407 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Stream buffer
*
* The task is to copy data from one socket to another
* efficiently, while allowing callbacks to look
* at packet headers.
*/
#include "bouncer.h"
#include
#include
#include
#ifdef USUAL_LIBSSL_FOR_TLS
#define USE_TLS
#endif
/* sbuf_main_loop() skip_recv values */
#define DO_RECV false
#define SKIP_RECV true
#define ACT_UNSET 0
#define ACT_SEND 1
#define ACT_SKIP 2
#define ACT_CALL 3
enum TLSState {
SBUF_TLS_NONE,
SBUF_TLS_DO_HANDSHAKE,
SBUF_TLS_IN_HANDSHAKE,
SBUF_TLS_OK,
};
enum WaitType {
W_NONE = 0,
W_CONNECT,
W_RECV,
W_SEND,
W_ONCE
};
#define AssertSanity(sbuf) do { \
Assert(iobuf_sane((sbuf)->io)); \
} while (0)
#define AssertActive(sbuf) do { \
Assert((sbuf)->sock > 0); \
AssertSanity(sbuf); \
} while (0)
/* declare static stuff */
static bool sbuf_queue_send(SBuf *sbuf) _MUSTCHECK;
static bool sbuf_send_pending_iobuf(SBuf *sbuf) _MUSTCHECK;
static bool sbuf_process_pending(SBuf *sbuf) _MUSTCHECK;
static void sbuf_connect_cb(evutil_socket_t sock, short flags, void *arg);
static void sbuf_recv_cb(evutil_socket_t sock, short flags, void *arg);
static void sbuf_send_cb(evutil_socket_t sock, short flags, void *arg);
static void sbuf_try_resync(SBuf *sbuf, bool release);
static bool sbuf_wait_for_data(SBuf *sbuf) _MUSTCHECK;
static void sbuf_main_loop(SBuf *sbuf, bool skip_recv);
static bool sbuf_call_proto(SBuf *sbuf, int event) /* _MUSTCHECK */;
static bool sbuf_actual_recv(SBuf *sbuf, size_t len) _MUSTCHECK;
static bool sbuf_after_connect_check(SBuf *sbuf) _MUSTCHECK;
static bool handle_tls_handshake(SBuf *sbuf) _MUSTCHECK;
/* regular I/O */
static ssize_t raw_sbufio_recv(struct SBuf *sbuf, void *dst, size_t len);
static ssize_t raw_sbufio_send(struct SBuf *sbuf, const void *data, size_t len);
static int raw_sbufio_close(struct SBuf *sbuf);
static const SBufIO raw_sbufio_ops = {
raw_sbufio_recv,
raw_sbufio_send,
raw_sbufio_close
};
/* I/O over TLS */
#ifdef USE_TLS
static ssize_t tls_sbufio_recv(struct SBuf *sbuf, void *dst, size_t len);
static ssize_t tls_sbufio_send(struct SBuf *sbuf, const void *data, size_t len);
static int tls_sbufio_close(struct SBuf *sbuf);
static const SBufIO tls_sbufio_ops = {
tls_sbufio_recv,
tls_sbufio_send,
tls_sbufio_close
};
static void sbuf_tls_handshake_cb(evutil_socket_t fd, short flags, void *_sbuf);
#endif
/*
*********************************
* Public functions
*********************************
*/
/* initialize SBuf with proto handler */
void sbuf_init(SBuf *sbuf, sbuf_cb_t proto_fn)
{
memset(sbuf, 0, sizeof(SBuf));
sbuf->proto_cb = proto_fn;
sbuf->ops = &raw_sbufio_ops;
}
/* got new socket from accept() */
bool sbuf_accept(SBuf *sbuf, int sock, bool is_unix)
{
bool res;
Assert(iobuf_empty(sbuf->io) && sbuf->sock == 0);
AssertSanity(sbuf);
sbuf->sock = sock;
if (!tune_socket(sock, is_unix))
goto failed;
if (!cf_reboot) {
res = sbuf_wait_for_data(sbuf);
if (!res)
goto failed;
/* socket should already have some data (linux only) */
if (cf_tcp_defer_accept && !is_unix) {
sbuf_main_loop(sbuf, DO_RECV);
if (!sbuf->sock)
return false;
}
}
return true;
failed:
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
return false;
}
/* need to connect() to get a socket */
bool sbuf_connect(SBuf *sbuf, const struct sockaddr *sa, socklen_t sa_len, time_t timeout_sec)
{
int res, sock;
struct timeval timeout;
char buf[128];
bool is_unix = sa->sa_family == AF_UNIX;
Assert(iobuf_empty(sbuf->io) && sbuf->sock == 0);
AssertSanity(sbuf);
/*
* common stuff
*/
sock = socket(sa->sa_family, SOCK_STREAM, 0);
if (sock < 0) {
/* probably fd limit */
goto failed;
}
if (!tune_socket(sock, is_unix))
goto failed;
sbuf->sock = sock;
timeout.tv_sec = timeout_sec;
timeout.tv_usec = 0;
/* launch connection */
res = safe_connect(sock, sa, sa_len);
if (res == 0) {
/* unix socket gives connection immediately */
sbuf_connect_cb(sock, EV_WRITE, sbuf);
return true;
} else if (errno == EINPROGRESS || errno == EAGAIN) {
/* tcp socket needs waiting */
event_assign(&sbuf->ev, pgb_event_base, sock, EV_WRITE, sbuf_connect_cb, sbuf);
res = event_add(&sbuf->ev, &timeout);
if (res >= 0) {
sbuf->wait_type = W_CONNECT;
return true;
}
}
failed:
log_warning("sbuf_connect failed to connect to %s: %s",
sa2str(sa, buf, sizeof(buf)), strerror(errno));
if (sock >= 0)
safe_close(sock);
sbuf->sock = 0;
sbuf_call_proto(sbuf, SBUF_EV_CONNECT_FAILED);
return false;
}
/* don't wait for data on this socket */
bool sbuf_pause(SBuf *sbuf)
{
AssertActive(sbuf);
Assert(sbuf->wait_type == W_RECV);
if (event_del(&sbuf->ev) < 0) {
log_warning("event_del: %s", strerror(errno));
return false;
}
sbuf->wait_type = W_NONE;
return true;
}
/* resume from pause, start waiting for data */
void sbuf_continue(SBuf *sbuf)
{
bool do_recv = DO_RECV;
bool res;
AssertActive(sbuf);
res = sbuf_wait_for_data(sbuf);
if (!res) {
/* drop if problems */
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
return;
}
/*
* It's tempting to try to avoid the recv() but that would
* only work if no code wants to see full packet.
*
* This is not true in ServerParameter case.
*/
/*
* if (sbuf->recv_pos - sbuf->pkt_pos >= SBUF_SMALL_PKT)
* do_recv = false;
*/
sbuf_main_loop(sbuf, do_recv);
}
/*
* Resume from pause and give socket over to external
* callback function.
*
* The callback will be called with arg given to sbuf_init.
*/
bool sbuf_continue_with_callback(SBuf *sbuf, event_callback_fn user_cb)
{
int err;
AssertActive(sbuf);
event_assign(&sbuf->ev, pgb_event_base, sbuf->sock, EV_READ | EV_PERSIST,
user_cb, sbuf);
err = event_add(&sbuf->ev, NULL);
if (err < 0) {
log_warning("sbuf_continue_with_callback: %s", strerror(errno));
return false;
}
sbuf->wait_type = W_RECV;
return true;
}
bool sbuf_use_callback_once(SBuf *sbuf, short ev, event_callback_fn user_cb)
{
int err;
AssertActive(sbuf);
if (sbuf->wait_type != W_NONE) {
err = event_del(&sbuf->ev);
sbuf->wait_type = W_NONE; /* make sure its called only once */
if (err < 0) {
log_warning("sbuf_queue_once: event_del failed: %s", strerror(errno));
return false;
}
}
/* setup one one-off event handler */
event_assign(&sbuf->ev, pgb_event_base, sbuf->sock, ev, user_cb, sbuf);
err = event_add(&sbuf->ev, NULL);
if (err < 0) {
log_warning("sbuf_queue_once: event_add failed: %s", strerror(errno));
return false;
}
sbuf->wait_type = W_ONCE;
return true;
}
/* socket cleanup & close: keeps .handler and .arg values */
bool sbuf_close(SBuf *sbuf)
{
if (sbuf->wait_type) {
Assert(sbuf->sock);
/* event_del() acts funny occasionally, debug it */
errno = 0;
if (event_del(&sbuf->ev) < 0) {
if (errno) {
log_warning("event_del: %s", strerror(errno));
} else {
log_warning("event_del: libevent error");
}
/* we can retry whole sbuf_close() if needed */
/* if (errno == ENOMEM) return false; */
}
}
sbuf_op_close(sbuf);
sbuf->dst = NULL;
sbuf->sock = 0;
sbuf->pkt_remain = 0;
sbuf->pkt_action = sbuf->wait_type = 0;
if (sbuf->io) {
slab_free(iobuf_cache, sbuf->io);
sbuf->io = NULL;
}
mbuf_free(&sbuf->extra_packets);
return true;
}
/* proto_fn tells to send some bytes to socket */
void sbuf_prepare_send(SBuf *sbuf, SBuf *dst, unsigned amount)
{
AssertActive(sbuf);
Assert(sbuf->pkt_remain == 0);
/* Assert(sbuf->pkt_action == ACT_UNSET || sbuf->pkt_action == ACT_SEND || iobuf_amount_pending(&sbuf->io)); */
Assert(amount > 0);
sbuf->pkt_action = ACT_SEND;
sbuf->pkt_remain = amount;
sbuf->dst = dst;
}
/* proto_fn tells to skip some amount of bytes */
void sbuf_prepare_skip(SBuf *sbuf, unsigned amount)
{
AssertActive(sbuf);
Assert(sbuf->pkt_remain == 0);
/* Assert(sbuf->pkt_action == ACT_UNSET || iobuf_send_pending_avail(&sbuf->io)); */
Assert(amount > 0);
sbuf->pkt_action = ACT_SKIP;
sbuf->skip_remain = amount;
sbuf->pkt_remain = amount;
}
/*
* proto_fn tells to send some bytes to socket, but before doing that skip
* some of the bytes first.
*/
void sbuf_prepare_skip_then_send_leftover(SBuf *sbuf, SBuf *dst, unsigned skip_amount, unsigned total_amount)
{
AssertActive(sbuf);
Assert(sbuf->pkt_remain == 0);
/* Assert(sbuf->pkt_action == ACT_UNSET || sbuf->pkt_action == ACT_SEND || iobuf_amount_pending(&sbuf->io)); */
Assert(total_amount > 0);
Assert(total_amount >= skip_amount);
sbuf->pkt_action = ACT_SKIP;
sbuf->pkt_remain = total_amount;
sbuf->skip_remain = skip_amount;
sbuf->dst = dst;
}
/*
* proto_fn tells to skip some amount of bytes and call a callback with those
* bytes instead
*/
void sbuf_prepare_fetch(SBuf *sbuf, unsigned amount)
{
AssertActive(sbuf);
Assert(sbuf->pkt_remain == 0);
/* Assert(sbuf->pkt_action == ACT_UNSET || iobuf_send_pending_avail(&sbuf->io)); */
Assert(amount > 0);
sbuf->pkt_action = ACT_CALL;
sbuf->skip_remain = amount;
sbuf->pkt_remain = amount;
}
/*
* queue a packet for sending and free it too (on both failure and success)
*
* This is used to inject custom packets into the stream of packets from source
* to clients. The packet is sent before the packet that is currently being
* processed, unless src->extra_packet_queue_after is set to true (then it is
* sent right after the current one). By calling sbuf_prepare_skip after
* sbuf_queue_packet, you effectively repalce the current packet with the one
* that you're passing into sbuf_queue_packet.
*/
bool sbuf_queue_packet(SBuf *src, SBuf *dst, PktBuf *pkt)
{
bool res;
AssertActive(src);
Assert(dst);
/*
* If we're queueing the packet before the packet that we're currently
* handling, we need to make sure that any pending data in iobuf is
* flushed. One important reason to do so is because we might want to
* call sbuf_prepare_skip later (to skip sending the current packet and
* completely replace it with this packet). Then the resulting ACT_SKIP
* will trigger a flush of iobuf too. By making sure we're flush here
* already, we make sure that its impossible for the flush caused by
* ACT_SKIP to fail. And knowing that significantly reduces the already
* complex failure scenarios we need to consider, because any failure
* will cause a rerun of the code that queues these packets.
*/
Assert(src->extra_packet_queue_after
|| src->io == NULL
|| iobuf_amount_pending(src->io) == 0);
if (!pkt || pkt->failed) {
pktbuf_free(pkt);
return false;
}
src->dst = dst;
res = mbuf_write(&src->extra_packets, pkt->buf, pkt->write_pos);
pktbuf_free(pkt);
return res;
}
/*
* queue the packet in PktHdr for sending
*
* This is pretty much the same as sbuf_queue_packet, but it works with a PktHdr
* instead of a PktBuf. Apart from that the only difference is that it does not
* free the passed in packet.
*/
bool sbuf_queue_full_packet(SBuf *src, SBuf *dst, PktHdr *pkt)
{
bool res;
AssertActive(src);
Assert(dst);
/*
* If we're queueing the packet before the packet that we're currently
* handling, we need to make sure that any pending data in iobuf is
* flushed. One important reason to do so is because we might want to
* call sbuf_prepare_skip later (to skip sending the current packet and
* completely replace it with this packet). Then the resulting ACT_SKIP
* will trigger a flush of iobuf too. By making sure we're flush here
* already, we make sure that its impossible for the flush caused by
* ACT_SKIP to fail. And knowing that significantly reduces the already
* complex failure scenarios we need to consider, because any failure
* will cause a rerun of the code that queues these packets.
*/
Assert(src->extra_packet_queue_after
|| src->io == NULL
|| iobuf_amount_pending(src->io) == 0);
Assert(!incomplete_pkt(pkt));
Assert(pkt->data.read_pos == 0);
src->dst = dst;
res = mbuf_write(&src->extra_packets, pkt->data.data, pkt->data.write_pos);
return res;
}
/*
*************************
* Internal functions
*************************
*/
/*
* Call proto callback with proper struct MBuf.
*
* If callback returns true it used one of sbuf_prepare_* on sbuf,
* and processing can continue.
*
* If it returned false it used sbuf_pause(), sbuf_close() or simply
* wants to wait for next event loop (e.g. too few data available).
* Callee should not touch sbuf in that case and just return to libevent.
*/
static bool sbuf_call_proto(SBuf *sbuf, int event)
{
struct MBuf mbuf;
IOBuf *io = sbuf->io;
bool res;
AssertSanity(sbuf);
Assert(event != SBUF_EV_READ || iobuf_amount_parse(io) > 0);
/* if pkt callback, limit only with current packet */
if (event == SBUF_EV_PKT_CALLBACK) {
iobuf_parse_limit(io, &mbuf, sbuf->pkt_remain);
} else if (event == SBUF_EV_READ) {
iobuf_parse_all(io, &mbuf);
} else {
memset(&mbuf, 0, sizeof(mbuf));
}
res = sbuf->proto_cb(sbuf, event, &mbuf);
AssertSanity(sbuf);
Assert(event != SBUF_EV_READ || !res || sbuf->sock > 0);
return res;
}
/* let's wait for new data */
static bool sbuf_wait_for_data(SBuf *sbuf)
{
int err;
event_assign(&sbuf->ev, pgb_event_base, sbuf->sock, EV_READ | EV_PERSIST, sbuf_recv_cb, sbuf);
err = event_add(&sbuf->ev, NULL);
if (err < 0) {
log_warning("sbuf_wait_for_data: event_add failed: %s", strerror(errno));
return false;
}
sbuf->wait_type = W_RECV;
return true;
}
static void sbuf_recv_forced_cb(evutil_socket_t sock, short flags, void *arg)
{
SBuf *sbuf = arg;
sbuf->wait_type = W_NONE;
if (sbuf_wait_for_data(sbuf)) {
sbuf_recv_cb(sock, flags, arg);
} else {
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
}
}
static bool sbuf_wait_for_data_forced(SBuf *sbuf)
{
int err;
struct timeval tv_min;
tv_min.tv_sec = 0;
tv_min.tv_usec = 1;
if (sbuf->wait_type != W_NONE) {
event_del(&sbuf->ev);
sbuf->wait_type = W_NONE;
}
event_assign(&sbuf->ev, pgb_event_base, sbuf->sock, EV_READ, sbuf_recv_forced_cb, sbuf);
err = event_add(&sbuf->ev, &tv_min);
if (err < 0) {
log_warning("sbuf_wait_for_data: event_add failed: %s", strerror(errno));
return false;
}
sbuf->wait_type = W_ONCE;
return true;
}
/* libevent EV_WRITE: called when dest socket is writable again */
static void sbuf_send_cb(evutil_socket_t sock, short flags, void *arg)
{
SBuf *sbuf = arg;
bool res;
log_noise("Socket is writable again");
/* sbuf was closed before in this loop */
if (!sbuf->sock)
return;
AssertSanity(sbuf);
Assert(sbuf->wait_type == W_SEND);
sbuf->wait_type = W_NONE;
/* prepare normal situation for sbuf_main_loop */
res = sbuf_wait_for_data(sbuf);
if (res) {
/* here we should certainly skip recv() */
sbuf_main_loop(sbuf, SKIP_RECV);
} else {
/* drop if problems */
sbuf_call_proto(sbuf, SBUF_EV_SEND_FAILED);
}
}
/* socket is full, wait until it's writable again */
static bool sbuf_queue_send(SBuf *sbuf)
{
int err;
AssertActive(sbuf);
Assert(sbuf->wait_type == W_RECV);
/* if false is returned, the socket will be closed later */
/* stop waiting for read events */
err = event_del(&sbuf->ev);
sbuf->wait_type = W_NONE; /* make sure its called only once */
if (err < 0) {
log_warning("sbuf_queue_send: event_del failed: %s", strerror(errno));
return false;
}
/* instead wait for EV_WRITE on destination socket */
event_assign(&sbuf->ev, pgb_event_base, sbuf->dst->sock, EV_WRITE, sbuf_send_cb, sbuf);
err = event_add(&sbuf->ev, NULL);
if (err < 0) {
log_warning("sbuf_queue_send: event_add failed: %s", strerror(errno));
return false;
}
sbuf->wait_type = W_SEND;
return true;
}
/*
* flush all pending data in the iobuf. This should be called before calling
* needed before calling sbuf_queue_packet.
*/
bool sbuf_flush(SBuf *sbuf)
{
if (sbuf->io) {
log_noise("sbuf_flush");
return sbuf_send_pending_iobuf(sbuf);
}
return true;
}
/*
* There's data in buffer to be sent. Returns bool if processing can continue.
*
* Does not look at pkt_pos/remain fields, expects them to be merged to send_*
*/
static bool sbuf_send_pending_iobuf(SBuf *sbuf)
{
int avail;
ssize_t res;
IOBuf *io = sbuf->io;
AssertActive(sbuf);
Assert(sbuf->dst || iobuf_amount_pending(io) == 0);
log_noise("sbuf_send_pending_iobuf");
try_more:
/* how much data is available for sending */
avail = iobuf_amount_pending(io);
if (avail == 0)
return true;
if (sbuf->dst->sock == 0) {
log_error("sbuf_send_pending_iobuf: no dst sock?");
sbuf_call_proto(sbuf, SBUF_EV_SEND_FAILED);
return false;
}
/* actually send it */
//res = iobuf_send_pending(io, sbuf->dst->sock);
res = sbuf_op_send(sbuf->dst, io->buf + io->done_pos, avail);
if (res > 0) {
io->done_pos += res;
} else if (res < 0) {
if (errno == EAGAIN) {
if (!sbuf_queue_send(sbuf)) {
/* drop if queue failed */
sbuf_call_proto(sbuf, SBUF_EV_SEND_FAILED);
}
} else {
sbuf_call_proto(sbuf, SBUF_EV_SEND_FAILED);
}
return false;
}
AssertActive(sbuf);
/*
* Should do sbuf_queue_send() immediately?
*
* To be sure, let's run into EAGAIN.
*/
goto try_more;
}
/*
* There's data in extra_packets buffer to be sent. Returns bool if processing
* can continue.
*/
static bool sbuf_send_pending_extra_packets(SBuf *sbuf)
{
int avail;
ssize_t res;
struct MBuf *mbuf = &sbuf->extra_packets;
AssertActive(sbuf);
Assert(sbuf->dst || mbuf_avail_for_read(mbuf) == 0);
log_noise("sbuf_send_pending_extra_packets ");
try_more:
/* how much data is available for sending */
avail = mbuf_avail_for_read(mbuf);
if (avail == 0)
return true;
if (sbuf->dst->sock == 0) {
log_error("sbuf_send_pending_extra_packets: no dst sock?");
sbuf_call_proto(sbuf, SBUF_EV_SEND_FAILED);
return false;
}
/* actually send it */
//res = iobuf_send_pending(io, sbuf->dst->sock);
res = sbuf_op_send(sbuf->dst, mbuf->data + mbuf->read_pos, avail);
if (res > 0) {
mbuf->read_pos += res;
} else if (res < 0) {
if (errno == EAGAIN) {
if (!sbuf_queue_send(sbuf)) {
/* drop if queue failed */
sbuf_call_proto(sbuf, SBUF_EV_SEND_FAILED);
}
} else {
sbuf_call_proto(sbuf, SBUF_EV_SEND_FAILED);
}
return false;
}
AssertActive(sbuf);
/*
* Should do sbuf_queue_send() immediately?
*
* To be sure, let's run into EAGAIN.
*/
goto try_more;
}
/* process as much data as possible */
static bool sbuf_process_pending(SBuf *sbuf)
{
unsigned avail;
IOBuf *io = sbuf->io;
struct MBuf *extra_packets = &sbuf->extra_packets;
bool full = iobuf_amount_recv(io) <= 0;
int loop_number = 0;
log_noise("sbuf_process_pending: start");
while (1) {
/*
* If there's still queued extra packets from a previous packet, make
* sure to flush those first. Otherwise the packet we process next
* might add even more packets there, which would be bad because it
* would mean they get delivered out of order.
*/
if (mbuf_avail_for_read(extra_packets)) {
if (sbuf->extra_packet_queue_after) {
if (!sbuf_send_pending_iobuf(sbuf)) {
log_noise("sbuf_process_pending failed to send all pending data");
return false;
}
}
if (!sbuf_send_pending_extra_packets(sbuf)) {
log_noise("sbuf_process_pending ended early because of not being able to send the queued extra packets");
return false;
}
/*
* To avoid frequent allocations we try to reuse the
* extra_packets MBuf. But if it has grown to more than
* 4 times pkt_buf, we free it to avoid wasting memory.
* Otherwise one huge packet can cause a lot of memory
* to stay allocated for the lifetime of the
* connection. The most common case where this might
* occur is a huge query in a prepared statement.
*
* We use 4 times pkt_buf as an arbitrary but
* reosanable limit.
*/
if (extra_packets->alloc_len > (unsigned) cf_sbuf_len * 4) {
mbuf_free(extra_packets);
} else {
mbuf_rewind_writer(extra_packets);
}
}
AssertActive(sbuf);
loop_number++;
log_noise("sbuf_process_pending: loop %d", loop_number);
/*
* Enough for now?
*
* The (avail <= SBUF_SMALL_PKT) check is to avoid partial pkts.
* As SBuf should not assume knowledge about packets,
* the check is not done in !full case. Packet handler can
* then still notify about partial packet by returning false.
*/
avail = iobuf_amount_parse(io);
if (avail == 0 || (full && avail <= SBUF_SMALL_PKT))
break;
/*
* If start of packet, process packet header.
*/
if (sbuf->pkt_remain == 0) {
if (!sbuf_call_proto(sbuf, SBUF_EV_READ)) {
goto need_more_data;
}
Assert(sbuf->pkt_remain > 0);
}
if (sbuf->pkt_action == ACT_SKIP || sbuf->pkt_action == ACT_CALL) {
/* send any pending data before skipping */
if (iobuf_amount_pending(io) > 0) {
if (!sbuf_send_pending_iobuf(sbuf))
return false;
}
}
if (avail > sbuf->pkt_remain)
avail = sbuf->pkt_remain;
switch (sbuf->pkt_action) {
case ACT_SEND:
iobuf_tag_send(io, avail);
break;
case ACT_CALL:
if (!sbuf_call_proto(sbuf, SBUF_EV_PKT_CALLBACK)) {
goto need_more_data;
}
/* fallthrough */
/* after callback, skip pkt */
case ACT_SKIP:
if (sbuf->skip_remain >= avail) {
iobuf_tag_skip(io, avail);
sbuf->skip_remain -= avail;
} else {
if (sbuf->skip_remain != 0) {
iobuf_tag_skip(io, sbuf->skip_remain);
}
iobuf_tag_send(io, avail - sbuf->skip_remain);
sbuf->skip_remain = 0;
}
break;
}
sbuf->pkt_remain -= avail;
}
log_noise("sbuf_process_pending: done looping");
if (!sbuf_send_pending_iobuf(sbuf)) {
log_noise("sbuf_process_pending failed to send all pending data");
return false;
}
log_noise("sbuf_process_pending: end");
return true;
need_more_data:
/*
* We need to wait for more data before we can handle the current
* packet. We'll call the handler for this packet again after receiving
* more data and then all of the extra packets that were generated this
* time will be regenerated again, so clean the ones up that were
* generated this time.
*/
mbuf_rewind_writer(extra_packets);
if (sbuf->sock && io && sbuf->wait_type == W_RECV) {
/*
* There might still be some previous packets that we're able
* to send though. Let's do that now to create some extra space
* in the buffer.
*/
if (iobuf_amount_pending(io) > 0) {
if (!sbuf_send_pending_iobuf(sbuf))
return false;
}
/*
* If we've filled the whole buffer, but the packet handler
* still needs more data, we should force a resync to make some
* space.
*/
if (io && io->recv_pos == (unsigned) cf_sbuf_len) {
log_noise("resync(%d): done=%u, parse=%u, recv=%u, forced",
sbuf->sock,
io->done_pos, io->parse_pos, io->recv_pos);
iobuf_try_resync(io, cf_sbuf_len);
}
}
return false;
}
/* reposition at buffer start again */
static void sbuf_try_resync(SBuf *sbuf, bool release)
{
IOBuf *io = sbuf->io;
if (io) {
log_noise("resync(%d): done=%u, parse=%u, recv=%u",
sbuf->sock,
io->done_pos, io->parse_pos, io->recv_pos);
}
AssertActive(sbuf);
if (!io)
return;
if (release && iobuf_empty(io)) {
slab_free(iobuf_cache, io);
sbuf->io = NULL;
} else {
iobuf_try_resync(io, SBUF_SMALL_PKT);
}
}
/* actually ask kernel for more data */
static bool sbuf_actual_recv(SBuf *sbuf, size_t len)
{
ssize_t got;
IOBuf *io = sbuf->io;
uint8_t *dst = io->buf + io->recv_pos;
unsigned avail = iobuf_amount_recv(io);
if (len > avail)
len = avail;
got = sbuf_op_recv(sbuf, dst, len);
if (got > 0) {
io->recv_pos += got;
} else if (got == 0) {
/* eof from socket */
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
return false;
} else if (got < 0 && errno != EAGAIN) {
/* some error occurred */
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
return false;
}
return true;
}
/* callback for libevent EV_READ */
static void sbuf_recv_cb(evutil_socket_t sock, short flags, void *arg)
{
SBuf *sbuf = arg;
sbuf_main_loop(sbuf, DO_RECV);
}
static bool allocate_iobuf(SBuf *sbuf)
{
if (sbuf->io == NULL) {
sbuf->io = slab_alloc(iobuf_cache);
if (sbuf->io == NULL) {
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
return false;
}
iobuf_reset(sbuf->io);
}
return true;
}
/*
* Main recv-parse-send-repeat loop.
*
* Reason for skip_recv is to avoid extra recv(). The problem with it
* is EOF from socket. Currently that means that the pending data is
* dropped. Fortunately server sockets are not paused and dropping
* data from client is no problem. So only place where skip_recv is
* important is sbuf_send_cb().
*/
static void sbuf_main_loop(SBuf *sbuf, bool skip_recv)
{
unsigned free, ok;
int loopcnt = 0;
/* sbuf was closed before in this event loop */
if (!sbuf->sock)
return;
/* reading should be disabled when waiting */
Assert(sbuf->wait_type == W_RECV);
AssertSanity(sbuf);
if (!allocate_iobuf(sbuf))
return;
/* avoid recv() if asked */
if (skip_recv)
goto skip_recv;
try_more:
/* make room in buffer */
sbuf_try_resync(sbuf, false);
/* avoid spending too much time on single socket */
if (cf_sbuf_loopcnt > 0 && loopcnt >= cf_sbuf_loopcnt) {
bool _ignore;
log_debug("loopcnt full");
/*
* sbuf_process_pending() avoids some data if buffer is full,
* but as we exit processing loop here, we need to retry
* after resync to process all data. (result is ignored)
*/
_ignore = sbuf_process_pending(sbuf);
(void) _ignore;
sbuf_wait_for_data_forced(sbuf);
return;
}
loopcnt++;
/*
* here used to be if (free > SBUF_SMALL_PKT) check
* but with skip_recv switch its should not be needed anymore.
*/
free = iobuf_amount_recv(sbuf->io);
if (free > 0) {
/*
* When suspending, try to hit packet boundary ASAP.
*/
if (cf_pause_mode == P_SUSPEND
&& sbuf->pkt_remain > 0
&& sbuf->pkt_remain < free) {
free = sbuf->pkt_remain;
}
/* now fetch the data */
ok = sbuf_actual_recv(sbuf, free);
if (!ok)
return;
}
skip_recv:
/* now handle it */
ok = sbuf_process_pending(sbuf);
if (!ok)
return;
/* if the buffer is full, there can be more data available */
if (iobuf_amount_recv(sbuf->io) <= 0)
goto try_more;
/* clean buffer */
sbuf_try_resync(sbuf, true);
/* notify proto that all is sent */
if (sbuf_is_empty(sbuf))
sbuf_call_proto(sbuf, SBUF_EV_FLUSH);
if (sbuf->tls_state == SBUF_TLS_DO_HANDSHAKE) {
sbuf->pkt_action = SBUF_TLS_IN_HANDSHAKE;
if (!handle_tls_handshake(sbuf))
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
}
}
/* check if there is any error pending on socket */
static bool sbuf_after_connect_check(SBuf *sbuf)
{
int optval = 0, err;
socklen_t optlen = sizeof(optval);
err = getsockopt(sbuf->sock, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen);
if (err < 0) {
log_debug("sbuf_after_connect_check: getsockopt: %s",
strerror(errno));
return false;
}
if (optval != 0) {
log_debug("sbuf_after_connect_check: pending error: %s",
strerror(optval));
return false;
}
return true;
}
/* callback for libevent EV_WRITE when connecting */
static void sbuf_connect_cb(evutil_socket_t sock, short flags, void *arg)
{
SBuf *sbuf = arg;
Assert(sbuf->wait_type == W_CONNECT || sbuf->wait_type == W_NONE);
sbuf->wait_type = W_NONE;
if (flags & EV_WRITE) {
if (!sbuf_after_connect_check(sbuf))
goto failed;
if (!sbuf_call_proto(sbuf, SBUF_EV_CONNECT_OK))
return;
if (!sbuf_wait_for_data(sbuf))
goto failed;
return;
}
failed:
sbuf_call_proto(sbuf, SBUF_EV_CONNECT_FAILED);
}
/* send some data to listening socket */
bool sbuf_answer(SBuf *sbuf, const void *buf, size_t len)
{
ssize_t res;
if (sbuf->sock <= 0)
return false;
res = sbuf_op_send(sbuf, buf, len);
if (res < 0) {
log_debug("sbuf_answer: error sending: %s", strerror(errno));
} else if ((unsigned)res != len) {
log_debug("sbuf_answer: partial send: len=%zu sent=%zd", len, res);
}
return (unsigned)res == len;
}
/*
* Standard IO ops.
*/
static ssize_t raw_sbufio_recv(struct SBuf *sbuf, void *dst, size_t len)
{
return safe_recv(sbuf->sock, dst, len, 0);
}
static ssize_t raw_sbufio_send(struct SBuf *sbuf, const void *data, size_t len)
{
return safe_send(sbuf->sock, data, len, 0);
}
static int raw_sbufio_close(struct SBuf *sbuf)
{
if (sbuf->sock > 0) {
safe_close(sbuf->sock);
sbuf->sock = 0;
}
return 0;
}
/*
* TLS support.
*/
#ifdef USE_TLS
/*
* These global variables contain the currently applied TLS configurations.
* They might differ from the current configuration if there was an error
* applying the configured parameters (e.g. cert file not found).
*/
static struct tls *client_accept_base;
static struct tls_config *client_accept_conf;
int client_accept_sslmode;
static struct tls_config *server_connect_conf;
int server_connect_sslmode;
/*
* TLS setup
*/
static bool setup_tls(struct tls_config *conf, const char *pfx, int sslmode,
const char *protocols, const char *ciphers,
const char *keyfile, const char *certfile, const char *cafile,
const char *dheparams, const char *ecdhecurve,
bool does_connect)
{
int err;
if (*protocols) {
uint32_t protos = TLS_PROTOCOLS_ALL;
err = tls_config_parse_protocols(&protos, protocols);
if (err) {
log_error("invalid %s_protocols: %s", pfx, protocols);
return false;
}
tls_config_set_protocols(conf, protos);
}
if (*ciphers) {
err = tls_config_set_ciphers(conf, ciphers);
if (err) {
log_error("invalid %s_ciphers: %s", pfx, ciphers);
return false;
}
}
if (*dheparams) {
err = tls_config_set_dheparams(conf, dheparams);
if (err) {
log_error("invalid %s_dheparams: %s", pfx, dheparams);
return false;
}
}
if (*ecdhecurve) {
err = tls_config_set_ecdhecurve(conf, ecdhecurve);
if (err) {
log_error("invalid %s_ecdhecurve: %s", pfx, ecdhecurve);
return false;
}
}
if (*cafile) {
err = tls_config_set_ca_file(conf, cafile);
if (err) {
log_error("invalid %s_ca_file: %s", pfx, cafile);
return false;
}
}
if (*keyfile) {
err = tls_config_set_key_file(conf, keyfile);
if (err) {
log_error("invalid %s_key_file: %s", pfx, keyfile);
return false;
}
}
if (*certfile) {
err = tls_config_set_cert_file(conf, certfile);
if (err) {
log_error("invalid %s_cert_file: %s", pfx, certfile);
return false;
}
}
if (does_connect) {
/* TLS client, check server? */
if (sslmode == SSLMODE_VERIFY_FULL) {
tls_config_verify(conf);
} else if (sslmode == SSLMODE_VERIFY_CA) {
tls_config_verify(conf);
tls_config_insecure_noverifyname(conf);
} else {
tls_config_insecure_noverifycert(conf);
tls_config_insecure_noverifyname(conf);
}
} else {
/* TLS server, check client? */
if (sslmode == SSLMODE_VERIFY_FULL) {
tls_config_verify_client(conf);
} else if (sslmode == SSLMODE_VERIFY_CA) {
tls_config_verify_client(conf);
} else {
tls_config_verify_client_optional(conf);
}
}
return true;
}
static bool tls_change_requires_reconnect(struct tls_config *new_server_connect_conf)
{
if (server_connect_sslmode != cf_server_tls_sslmode) {
log_noise("new server_tls_sslmode detected");
return true;
} else if (server_connect_conf == NULL) {
log_noise("no existing server tls config detected");
return true;
} else if (tls_config_equal(new_server_connect_conf, server_connect_conf)) {
log_noise("no server tls config change detected");
return false;
} else {
log_noise("server tls config change detected");
return true;
}
}
bool sbuf_tls_setup(void)
{
int err;
/*
* These variables store the new TLS configurations, based on the latest
* settings provided by the user. Once they have been configured completely
* without errors they are assigned to the globals at the end of this
* function. This way the globals never contain partially configured TLS
* configurations.
*/
struct tls_config *new_client_accept_conf = NULL;
struct tls_config *new_server_connect_conf = NULL;
struct tls *new_client_accept_base = NULL;
if (cf_client_tls_sslmode != SSLMODE_DISABLED) {
if (!*cf_client_tls_key_file || !*cf_client_tls_cert_file) {
log_error("To allow TLS connections from clients, client_tls_key_file and client_tls_cert_file must be set.");
return false;
}
}
if (cf_auth_type == AUTH_TYPE_CERT) {
if (cf_client_tls_sslmode != SSLMODE_VERIFY_FULL) {
log_error("auth_type=cert requires client_tls_sslmode=SSLMODE_VERIFY_FULL");
return false;
}
if (*cf_client_tls_ca_file == '\0') {
log_error("auth_type=cert requires client_tls_ca_file");
return false;
}
} else if (cf_client_tls_sslmode > SSLMODE_VERIFY_CA && *cf_client_tls_ca_file == '\0') {
log_error("client_tls_sslmode requires client_tls_ca_file");
return false;
}
err = tls_init();
if (err)
fatal("tls_init failed");
if (cf_server_tls_sslmode != SSLMODE_DISABLED) {
new_server_connect_conf = tls_config_new();
if (!new_server_connect_conf) {
log_error("tls_config_new failed 1");
return false;
}
if (!setup_tls(new_server_connect_conf, "server_tls", cf_server_tls_sslmode,
cf_server_tls_protocols, cf_server_tls_ciphers,
cf_server_tls_key_file, cf_server_tls_cert_file,
cf_server_tls_ca_file, "", "", true))
goto failed;
}
if (cf_client_tls_sslmode != SSLMODE_DISABLED) {
new_client_accept_conf = tls_config_new();
if (!new_client_accept_conf) {
log_error("tls_config_new failed 2");
goto failed;
}
if (!setup_tls(new_client_accept_conf, "client_tls", cf_client_tls_sslmode,
cf_client_tls_protocols, cf_client_tls_ciphers,
cf_client_tls_key_file, cf_client_tls_cert_file,
cf_client_tls_ca_file, cf_client_tls_dheparams,
cf_client_tls_ecdhecurve, false))
goto failed;
new_client_accept_base = tls_server();
if (!new_client_accept_base) {
log_error("server_base failed");
goto failed;
}
err = tls_configure(new_client_accept_base, new_client_accept_conf);
if (err) {
log_error("TLS setup failed: %s", tls_error(new_client_accept_base));
goto failed;
}
}
/*
* To change server TLS settings all connections are marked as dirty. This
* way they are recycled and the new TLS settings will be used. Otherwise
* old TLS settings, possibly less secure, could be used for old
* connections indefinitely. If TLS is disabled, and it was disabled before
* as well then recycling connections is not necessary, since we know none
* of the settings have changed. */
if ((server_connect_conf || new_server_connect_conf) && tls_change_requires_reconnect(new_server_connect_conf)) {
struct List *item;
PgPool *pool;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
tag_pool_dirty(pool);
}
}
usual_tls_free(client_accept_base);
tls_config_free(client_accept_conf);
tls_config_free(server_connect_conf);
client_accept_base = new_client_accept_base;
client_accept_conf = new_client_accept_conf;
client_accept_sslmode = cf_client_tls_sslmode;
server_connect_conf = new_server_connect_conf;
server_connect_sslmode = cf_server_tls_sslmode;
return true;
failed:
usual_tls_free(new_client_accept_base);
tls_config_free(new_client_accept_conf);
tls_config_free(new_server_connect_conf);
return false;
}
/*
* TLS handshake
*/
static bool handle_tls_handshake(SBuf *sbuf)
{
int err;
err = tls_handshake(sbuf->tls);
log_noise("tls_handshake: err=%d", err);
if (err == TLS_WANT_POLLIN) {
return sbuf_use_callback_once(sbuf, EV_READ, sbuf_tls_handshake_cb);
} else if (err == TLS_WANT_POLLOUT) {
return sbuf_use_callback_once(sbuf, EV_WRITE, sbuf_tls_handshake_cb);
} else if (err == 0) {
sbuf->tls_state = SBUF_TLS_OK;
sbuf_call_proto(sbuf, SBUF_EV_TLS_READY);
return true;
} else {
log_warning("TLS handshake error: %s", tls_error(sbuf->tls));
return false;
}
}
static void sbuf_tls_handshake_cb(evutil_socket_t fd, short flags, void *_sbuf)
{
SBuf *sbuf = _sbuf;
sbuf->wait_type = W_NONE;
if (!handle_tls_handshake(sbuf))
sbuf_call_proto(sbuf, SBUF_EV_RECV_FAILED);
}
/*
* Accept TLS connection.
*/
bool sbuf_tls_accept(SBuf *sbuf)
{
int err;
if (!sbuf_pause(sbuf))
return false;
sbuf->ops = &tls_sbufio_ops;
err = tls_accept_fds(client_accept_base, &sbuf->tls, sbuf->sock, sbuf->sock);
log_noise("tls_accept_fds: err=%d", err);
if (err < 0) {
log_warning("TLS accept error: %s", tls_error(sbuf->tls));
return false;
}
sbuf->tls_state = SBUF_TLS_DO_HANDSHAKE;
return true;
}
/*
* Connect to remote TLS host.
*/
bool sbuf_tls_connect(SBuf *sbuf, const char *hostname)
{
struct tls *ctls;
int err;
if (!sbuf_pause(sbuf))
return false;
if (cf_server_tls_sslmode != SSLMODE_VERIFY_FULL)
hostname = NULL;
ctls = tls_client();
if (!ctls)
return false;
err = tls_configure(ctls, server_connect_conf);
if (err < 0) {
log_error("tls client config failed: %s", tls_error(ctls));
usual_tls_free(ctls);
return false;
}
sbuf->tls = ctls;
sbuf->tls_host = hostname;
sbuf->ops = &tls_sbufio_ops;
err = tls_connect_fds(sbuf->tls, sbuf->sock, sbuf->sock, sbuf->tls_host);
if (err < 0) {
log_warning("TLS connect error: %s", tls_error(sbuf->tls));
return false;
}
sbuf->tls_state = SBUF_TLS_DO_HANDSHAKE;
return true;
}
/*
* TLS IO ops.
*/
static ssize_t tls_sbufio_recv(struct SBuf *sbuf, void *dst, size_t len)
{
ssize_t out = 0;
if (sbuf->tls_state != SBUF_TLS_OK) {
errno = EIO;
return -1;
}
out = tls_read(sbuf->tls, dst, len);
log_noise("tls_read: req=%zu out=%zd", len, out);
if (out >= 0) {
return out;
} else if (out == TLS_WANT_POLLIN) {
errno = EAGAIN;
} else if (out == TLS_WANT_POLLOUT) {
log_warning("tls_sbufio_recv: got TLS_WANT_POLLOUT");
errno = EIO;
} else {
log_warning("tls_sbufio_recv: %s", tls_error(sbuf->tls));
errno = EIO;
}
return -1;
}
static ssize_t tls_sbufio_send(struct SBuf *sbuf, const void *data, size_t len)
{
ssize_t out;
if (sbuf->tls_state != SBUF_TLS_OK) {
errno = EIO;
return -1;
}
out = tls_write(sbuf->tls, data, len);
log_noise("tls_write: req=%zu out=%zd", len, out);
if (out >= 0) {
return out;
} else if (out == TLS_WANT_POLLOUT) {
errno = EAGAIN;
} else if (out == TLS_WANT_POLLIN) {
log_warning("tls_sbufio_send: got TLS_WANT_POLLIN");
errno = EIO;
} else {
log_warning("tls_sbufio_send: %s", tls_error(sbuf->tls));
errno = EIO;
}
return -1;
}
static int tls_sbufio_close(struct SBuf *sbuf)
{
log_noise("tls_close");
if (sbuf->tls) {
tls_close(sbuf->tls);
usual_tls_free(sbuf->tls);
sbuf->tls = NULL;
}
if (sbuf->sock > 0) {
safe_close(sbuf->sock);
sbuf->sock = 0;
}
return 0;
}
void sbuf_cleanup(void)
{
usual_tls_free(client_accept_base);
tls_config_free(client_accept_conf);
tls_config_free(server_connect_conf);
client_accept_conf = NULL;
server_connect_conf = NULL;
client_accept_base = NULL;
}
#else
int client_accept_sslmode = SSLMODE_DISABLED;
int server_connect_sslmode = SSLMODE_DISABLED;
bool sbuf_tls_setup(void)
{
return true;
}
bool sbuf_tls_accept(SBuf *sbuf)
{
return false;
}
bool sbuf_tls_connect(SBuf *sbuf, const char *hostname)
{
return false;
}
void sbuf_cleanup(void)
{
}
static bool handle_tls_handshake(SBuf *sbuf)
{
return false;
}
#endif
pgbouncer-1.24.1/src/admin.c 0000644 0001750 0000000 00000151122 14777762222 012534 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Admin console commands.
*/
#include "bouncer.h"
#include
#include
#include
#include
#include
#include
/* regex elements */
#define WS0 "[ \t\n\r]*"
#define WS1 "[ \t\n\r]+"
#define WORD "(\"([^\"]+|\"\")*\"|[0-9a-z_]+)"
#define STRING "('([^']|'')*')"
/* possible max + 1 */
#define MAX_GROUPS 10
/* group numbers */
#define CMD_NAME 1
#define CMD_ARG 4
#define SET_KEY 1
#define SET_VAL 4
typedef bool (*cmd_func_t)(PgSocket *admin, const char *arg);
struct cmd_lookup {
const char *word;
cmd_func_t func;
};
/* CMD [arg]; */
static const char cmd_normal_rx[] =
"^" WS0 WORD "(" WS1 WORD ")?" WS0 "(;" WS0 ")?$";
/* SET with simple value */
static const char cmd_set_word_rx[] =
"^" WS0 "set" WS1 WORD WS0 "(=|to)" WS0 WORD WS0 "(;" WS0 ")?$";
/* SET with quoted value */
static const char cmd_set_str_rx[] =
"^" WS0 "set" WS1 WORD WS0 "(=|to)" WS0 STRING WS0 "(;" WS0 ")?$";
/* compiled regexes */
static regex_t rc_cmd;
static regex_t rc_set_word;
static regex_t rc_set_str;
static PgPool *admin_pool;
/* only valid during processing */
static const char *current_query;
void admin_cleanup(void)
{
regfree(&rc_cmd);
regfree(&rc_set_str);
regfree(&rc_set_word);
admin_pool = NULL;
}
static bool syntax_error(PgSocket *admin)
{
return admin_error(admin, "invalid command '%s', use SHOW HELP;",
current_query ? current_query : "");
}
static bool exec_cmd(struct cmd_lookup *lookup, PgSocket *admin,
const char *cmd, const char *arg)
{
for (; lookup->word; lookup++) {
if (strcasecmp(lookup->word, cmd) == 0)
return lookup->func(admin, arg);
}
return syntax_error(admin);
}
bool admin_error(PgSocket *admin, const char *fmt, ...)
{
char str[1024];
va_list ap;
bool res = true;
va_start(ap, fmt);
vsnprintf(str, sizeof(str), fmt, ap);
va_end(ap);
log_error("%s", str);
if (admin)
res = send_pooler_error(admin, true, NULL, false, str);
return res;
}
static int count_paused_databases(void)
{
struct List *item;
PgDatabase *db;
int cnt = 0;
statlist_for_each(item, &database_list) {
db = container_of(item, PgDatabase, head);
cnt += db->db_paused;
}
return cnt;
}
static int count_db_active(PgDatabase *db)
{
struct List *item;
PgPool *pool;
int cnt = 0;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db != db)
continue;
cnt += pool_server_count(pool);
}
return cnt;
}
bool admin_flush(PgSocket *admin, PktBuf *buf, const char *desc)
{
pktbuf_write_CommandComplete(buf, desc);
pktbuf_write_ReadyForQuery(buf);
return pktbuf_send_queued(buf, admin);
}
bool admin_ready(PgSocket *admin, const char *desc)
{
PktBuf buf;
uint8_t tmp[512];
pktbuf_static(&buf, tmp, sizeof(tmp));
pktbuf_write_CommandComplete(&buf, desc);
pktbuf_write_ReadyForQuery(&buf);
return pktbuf_send_immediate(&buf, admin);
}
/*
* some silly clients start actively messing with server parameters
* without checking if that's necessary. Fake some env for them.
*/
struct FakeParam {
const char *name;
const char *value;
};
static const struct FakeParam fake_param_list[] = {
{ "client_encoding", "UTF-8" },
{ "default_transaction_isolation", "read committed" },
{ "standard_conforming_strings", "on" },
{ "datestyle", "ISO" },
{ "timezone", "GMT" },
{ NULL },
};
/* fake result send, returns if handled */
static bool fake_show(PgSocket *admin, const char *name)
{
PktBuf *buf;
const struct FakeParam *p;
bool got = false;
for (p = fake_param_list; p->name; p++) {
if (strcasecmp(name, p->name) == 0) {
got = true;
break;
}
}
if (got) {
buf = pktbuf_dynamic(256);
if (buf) {
pktbuf_write_RowDescription(buf, "s", p->name);
pktbuf_write_DataRow(buf, "s", p->value);
admin_flush(admin, buf, "SHOW");
} else {
admin_error(admin, "no mem");
}
}
return got;
}
static bool fake_set(PgSocket *admin, const char *key, const char *val)
{
PktBuf *buf;
const struct FakeParam *p;
bool got = false;
for (p = fake_param_list; p->name; p++) {
if (strcasecmp(key, p->name) == 0) {
got = true;
break;
}
}
if (got) {
buf = pktbuf_dynamic(256);
if (buf) {
pktbuf_write_Notice(buf, "SET ignored");
admin_flush(admin, buf, "SET");
} else {
admin_error(admin, "no mem");
}
}
return got;
}
/* Command: SET key = val; */
static bool admin_set(PgSocket *admin, const char *key, const char *val)
{
char tmp[512];
bool ok;
if (fake_set(admin, key, val))
return true;
if (admin->admin_user) {
ok = set_config_param(key, val);
if (ok) {
PktBuf *buf = pktbuf_dynamic(256);
if (!buf) {
return admin_error(admin, "no mem");
}
if (strstr(key, "_tls_") != NULL) {
if (!sbuf_tls_setup())
pktbuf_write_Notice(buf, "TLS settings could not be applied, still using old configuration");
}
snprintf(tmp, sizeof(tmp), "SET %s=%s", key, val);
return admin_flush(admin, buf, tmp);
} else {
return admin_error(admin, "SET failed");
}
} else {
return admin_error(admin, "admin access needed");
}
}
/* send a row with sendmsg, optionally attaching a fd */
static bool send_one_fd(PgSocket *admin,
int fd, const char *task,
const char *user, const char *db,
const char *addr, int port,
uint64_t ckey, int link,
const char *client_enc,
const char *std_strings,
const char *datestyle,
const char *timezone,
const char *password,
const uint8_t *scram_client_key,
int scram_client_key_len,
const uint8_t *scram_server_key,
int scram_server_key_len)
{
struct msghdr msg;
struct cmsghdr *cmsg;
struct iovec iovec;
ssize_t res;
uint8_t cntbuf[CMSG_SPACE(sizeof(int))];
struct PktBuf *pkt = pktbuf_temp();
pktbuf_write_DataRow(pkt, "issssiqisssssbb",
fd, task, user, db, addr, port, ckey, link,
client_enc, std_strings, datestyle, timezone,
password,
scram_client_key_len, scram_client_key,
scram_server_key_len, scram_server_key);
if (pkt->failed)
return false;
iovec.iov_base = pkt->buf;
iovec.iov_len = pktbuf_written(pkt);
/* sending fds */
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iovec;
msg.msg_iovlen = 1;
/* attach a fd */
if (pga_is_unix(&admin->remote_addr) && admin->own_user && !admin->sbuf.tls) {
msg.msg_control = cntbuf;
msg.msg_controllen = sizeof(cntbuf);
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
msg.msg_controllen = cmsg->cmsg_len;
}
slog_debug(admin, "sending socket list: fd=%d, len=%d",
fd, (int)msg.msg_controllen);
if (msg.msg_controllen) {
res = safe_sendmsg(sbuf_socket(&admin->sbuf), &msg, 0);
} else {
res = sbuf_op_send(&admin->sbuf, pkt->buf, pktbuf_written(pkt));
}
if (res < 0) {
log_error("send_one_fd: sendmsg error: %s", strerror(errno));
return false;
} else if ((size_t)res != iovec.iov_len) {
log_error("send_one_fd: partial sendmsg");
return false;
}
return true;
}
/* send a row with sendmsg, optionally attaching a fd */
static bool show_one_fd(PgSocket *admin, PgSocket *sk)
{
PgAddr *addr = &sk->remote_addr;
struct MBuf tmp;
VarCache *v = &sk->vars;
uint64_t ckey;
const struct PStr *client_encoding = v->var_list[VClientEncoding];
const struct PStr *std_strings = v->var_list[VStdStr];
const struct PStr *datestyle = v->var_list[VDateStyle];
const struct PStr *timezone = v->var_list[VTimeZone];
char addrbuf[PGADDR_BUF];
const char *password = NULL;
bool send_scram_keys = false;
/* Skip TLS sockets */
if (sk->sbuf.tls || (sk->link && sk->link->sbuf.tls))
return true;
mbuf_init_fixed_reader(&tmp, sk->cancel_key, 8);
if (!mbuf_get_uint64be(&tmp, &ckey))
return false;
if (sk->pool && sk->pool->db->auth_user_credentials && sk->login_user_credentials && !find_global_user(sk->login_user_credentials->name))
password = sk->login_user_credentials->passwd;
/* PAM requires passwords as well since they are not stored externally */
if (cf_auth_type == AUTH_TYPE_PAM && !find_global_user(sk->login_user_credentials->name))
password = sk->login_user_credentials->passwd;
if (sk->pool && sk->pool->user_credentials && sk->pool->user_credentials->has_scram_keys)
send_scram_keys = true;
return send_one_fd(admin, sbuf_socket(&sk->sbuf),
is_server_socket(sk) ? "server" : "client",
sk->login_user_credentials ? sk->login_user_credentials->name : NULL,
sk->pool ? sk->pool->db->name : NULL,
pga_ntop(addr, addrbuf, sizeof(addrbuf)),
pga_port(addr),
ckey,
sk->link ? sbuf_socket(&sk->link->sbuf) : 0,
client_encoding ? client_encoding->str : NULL,
std_strings ? std_strings->str : NULL,
datestyle ? datestyle->str : NULL,
timezone ? timezone->str : NULL,
password,
send_scram_keys ? sk->pool->user_credentials->scram_ClientKey : NULL,
send_scram_keys ? (int) sizeof(sk->pool->user_credentials->scram_ClientKey) : -1,
send_scram_keys ? sk->pool->user_credentials->scram_ServerKey : NULL,
send_scram_keys ? (int) sizeof(sk->pool->user_credentials->scram_ServerKey) : -1);
}
static bool show_pooler_cb(void *arg, int fd, const PgAddr *a)
{
char buf[PGADDR_BUF];
return send_one_fd(arg, fd, "pooler", NULL, NULL,
pga_ntop(a, buf, sizeof(buf)), pga_port(a), 0, 0,
NULL, NULL, NULL, NULL, NULL, NULL, -1, NULL, -1);
}
/* send a row with sendmsg, optionally attaching a fd */
static bool show_pooler_fds(PgSocket *admin)
{
return for_each_pooler_fd(show_pooler_cb, admin);
}
static bool show_fds_from_list(PgSocket *admin, struct StatList *list)
{
struct List *item;
PgSocket *sk;
bool res = true;
statlist_for_each(item, list) {
sk = container_of(item, PgSocket, head);
res = show_one_fd(admin, sk);
if (!res)
break;
}
return res;
}
/*
* Command: SHOW FDS
*
* If privileged connection, send also actual fds
*/
static bool admin_show_fds(PgSocket *admin, const char *arg)
{
struct List *item;
PgPool *pool;
bool res;
/*
* Dangerous to show to everybody:
* - can lock pooler as code flips async option
* - show cancel keys for all users
* - shows passwords (md5) for dynamic users
*/
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
/*
* It's very hard to send it reliably over in async manner,
* so turn async off for this resultset.
*/
socket_set_nonblocking(sbuf_socket(&admin->sbuf), 0);
/*
* send resultset
*/
SEND_RowDescription(res, admin, "issssiqisssssbb",
"fd", "task",
"user", "database",
"addr", "port",
"cancel", "link",
"client_encoding", "std_strings",
"datestyle", "timezone", "password",
"scram_client_key", "scram_server_key");
if (res)
res = show_pooler_fds(admin);
if (res)
res = show_fds_from_list(admin, &login_client_list);
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db->admin)
continue;
res = res && show_fds_from_list(admin, &pool->active_client_list);
res = res && show_fds_from_list(admin, &pool->waiting_client_list);
res = res && show_fds_from_list(admin, &pool->active_server_list);
res = res && show_fds_from_list(admin, &pool->idle_server_list);
res = res && show_fds_from_list(admin, &pool->used_server_list);
res = res && show_fds_from_list(admin, &pool->tested_server_list);
res = res && show_fds_from_list(admin, &pool->new_server_list);
if (!res)
break;
}
if (res)
res = admin_ready(admin, "SHOW");
/* turn async back on */
socket_set_nonblocking(sbuf_socket(&admin->sbuf), 1);
return res;
}
/* Command: SHOW DATABASES */
static bool admin_show_databases(PgSocket *admin, const char *arg)
{
PgDatabase *db;
struct List *item;
const char *f_user;
PktBuf *buf;
struct CfValue cv;
struct CfValue load_balance_hosts_lookup;
const char *pool_mode_str;
usec_t server_lifetime_secs;
const char *load_balance_hosts_str;
cv.extra = pool_mode_map;
load_balance_hosts_lookup.extra = load_balance_hosts_map;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "ssissiiiissiiiiii",
"name", "host", "port",
"database", "force_user", "pool_size", "min_pool_size", "reserve_pool_size",
"server_lifetime", "pool_mode", "load_balance_hosts", "max_connections",
"current_connections", "max_client_connections", "current_client_connections",
"paused", "disabled");
statlist_for_each(item, &database_list) {
db = container_of(item, PgDatabase, head);
server_lifetime_secs = (db->server_lifetime > 0 ? db->server_lifetime : cf_server_lifetime) / USEC;
f_user = db->forced_user_credentials ? db->forced_user_credentials->name : NULL;
pool_mode_str = NULL;
load_balance_hosts_str = NULL;
cv.value_p = &db->pool_mode;
load_balance_hosts_lookup.value_p = &db->load_balance_hosts;
if (db->pool_mode != POOL_INHERIT)
pool_mode_str = cf_get_lookup(&cv);
if (db->host && strchr(db->host, ','))
load_balance_hosts_str = cf_get_lookup(&load_balance_hosts_lookup);
pktbuf_write_DataRow(buf, "ssissiiiissiiiiii",
db->name, db->host, db->port,
db->dbname, f_user,
db->pool_size >= 0 ? db->pool_size : cf_default_pool_size,
db->min_pool_size >= 0 ? db->min_pool_size : cf_min_pool_size,
db->res_pool_size >= 0 ? db->res_pool_size : cf_res_pool_size,
server_lifetime_secs,
pool_mode_str,
load_balance_hosts_str,
database_max_connections(db),
db->connection_count,
database_max_client_connections(db),
db->client_connection_count,
db->db_paused,
db->db_disabled);
}
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW PEERS */
static bool admin_show_peers(PgSocket *admin, const char *arg)
{
PgDatabase *peer;
struct List *item;
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "isii",
"peer_id", "host", "port", "pool_size");
statlist_for_each(item, &peer_list) {
peer = container_of(item, PgDatabase, head);
pktbuf_write_DataRow(buf, "isii",
peer->peer_id, peer->host, peer->port,
peer->pool_size >= 0 ? peer->pool_size : cf_default_pool_size);
}
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW LISTS */
static bool admin_show_lists(PgSocket *admin, const char *arg)
{
PktBuf *buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "si", "list", "items");
#define SENDLIST(name, size) pktbuf_write_DataRow(buf, "si", (name), (size))
SENDLIST("databases", statlist_count(&database_list));
SENDLIST("users", statlist_count(&user_list));
SENDLIST("peers", statlist_count(&peer_list));
SENDLIST("pools", statlist_count(&pool_list));
SENDLIST("peer_pools", statlist_count(&peer_pool_list));
SENDLIST("free_clients", slab_free_count(client_cache));
SENDLIST("used_clients", slab_active_count(client_cache));
SENDLIST("login_clients", statlist_count(&login_client_list));
SENDLIST("free_servers", slab_free_count(server_cache));
SENDLIST("used_servers", slab_active_count(server_cache));
{
int names, zones, qry, pend;
adns_info(adns, &names, &zones, &qry, &pend);
SENDLIST("dns_names", names);
SENDLIST("dns_zones", zones);
SENDLIST("dns_queries", qry);
SENDLIST("dns_pending", pend);
}
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW USERS */
static bool admin_show_users(PgSocket *admin, const char *arg)
{
struct List *item;
PktBuf *buf = pktbuf_dynamic(256);
struct CfValue cv;
char pool_size_str[12] = "";
char res_pool_size_str[12] = "";
const char *pool_mode_str;
if (!buf) {
admin_error(admin, "no mem");
return true;
}
cv.extra = pool_mode_map;
pktbuf_write_RowDescription(
buf, "ssssiiii", "name", "pool_size", "reserve_pool_size", "pool_mode", "max_user_connections", "current_connections",
"max_user_client_connections", "current_client_connections");
statlist_for_each(item, &user_list) {
PgGlobalUser *user = container_of(item, PgGlobalUser, head);
if (user->pool_size >= 0)
snprintf(pool_size_str, sizeof(pool_size_str), "%9d", user->pool_size);
if (user->res_pool_size >= 0)
snprintf(res_pool_size_str, sizeof(res_pool_size_str), "%9d", user->res_pool_size);
pool_mode_str = NULL;
cv.value_p = &user->pool_mode;
if (user->pool_mode != POOL_INHERIT)
pool_mode_str = cf_get_lookup(&cv);
pktbuf_write_DataRow(buf, "ssssiiii", user->credentials.name,
pool_size_str,
res_pool_size_str,
pool_mode_str,
user_max_connections(user),
user->connection_count,
user_client_max_connections(user),
user->client_connection_count
);
}
admin_flush(admin, buf, "SHOW");
return true;
}
#define SKF_STD "ssssssisiTTiiississii"
#define SKF_DBG "ssssssisiTTiiississiiiiiiiii"
static void socket_header(PktBuf *buf, bool debug)
{
pktbuf_write_RowDescription(buf, debug ? SKF_DBG : SKF_STD,
"type", "user", "database", "replication", "state",
"addr", "port", "local_addr", "local_port",
"connect_time", "request_time",
"wait", "wait_us", "close_needed",
"ptr", "link", "remote_pid", "tls",
"application_name",
"prepared_statements", "id",
/* debug follows */
"recv_pos", "pkt_pos", "pkt_remain",
"send_pos", "send_remain",
"pkt_avail", "send_avail");
}
static void adr2txt(const PgAddr *adr, char *dst, unsigned dstlen)
{
pga_ntop(adr, dst, dstlen);
}
static void socket_row(PktBuf *buf, PgSocket *sk, const char *state, bool debug)
{
int pkt_avail = 0, send_avail = 0;
int remote_pid;
int prepared_statement_count = 0;
char ptrbuf[128], linkbuf[128];
char l_addr[PGADDR_BUF], r_addr[PGADDR_BUF];
IOBuf *io = sk->sbuf.io;
char infobuf[96] = "";
VarCache *v = &sk->vars;
const struct PStr *application_name = v->var_list[VAppName];
usec_t now = get_cached_time();
usec_t wait_time = sk->query_start ? now - sk->query_start : 0;
char *replication;
if (io) {
pkt_avail = iobuf_amount_parse(sk->sbuf.io);
send_avail = iobuf_amount_pending(sk->sbuf.io);
}
adr2txt(&sk->remote_addr, r_addr, sizeof(r_addr));
adr2txt(&sk->local_addr, l_addr, sizeof(l_addr));
snprintf(ptrbuf, sizeof(ptrbuf), "%p", sk);
if (sk->link)
snprintf(linkbuf, sizeof(linkbuf), "%p", sk->link);
else
linkbuf[0] = 0;
/* get pid over unix socket */
if (pga_is_unix(&sk->remote_addr))
remote_pid = sk->remote_addr.scred.pid;
else
remote_pid = 0;
/* if that failed, get it from cancel key */
if (is_server_socket(sk) && remote_pid == 0)
remote_pid = be32dec(sk->cancel_key);
if (sk->sbuf.tls)
tls_get_connection_info(sk->sbuf.tls, infobuf, sizeof infobuf);
if (is_server_socket(sk))
prepared_statement_count = HASH_COUNT(sk->server_prepared_statements);
else
prepared_statement_count = HASH_COUNT(sk->client_prepared_statements);
if (sk->replication == REPLICATION_NONE)
replication = "none";
else if (sk->replication == REPLICATION_LOGICAL)
replication = "logical";
else
replication = "physical";
pktbuf_write_DataRow(buf, debug ? SKF_DBG : SKF_STD,
is_server_socket(sk) ? "S" : "C",
sk->login_user_credentials ? sk->login_user_credentials->name : "(nouser)",
sk->pool && !sk->pool->db->peer_id ? sk->pool->db->name : "(nodb)",
replication,
state, r_addr, pga_port(&sk->remote_addr),
l_addr, pga_port(&sk->local_addr),
sk->connect_time,
sk->request_time,
(int)(wait_time / USEC),
(int)(wait_time % USEC),
sk->close_needed,
ptrbuf, linkbuf, remote_pid, infobuf,
application_name ? application_name->str : "",
prepared_statement_count, sk->id,
/* debug */
io ? io->recv_pos : 0,
io ? io->parse_pos : 0,
sk->sbuf.pkt_remain,
io ? io->done_pos : 0,
0,
pkt_avail, send_avail);
}
/* Helper for SHOW CLIENTS/SERVERS/SOCKETS */
static void show_socket_list(PktBuf *buf, struct StatList *list, const char *state, bool debug)
{
struct List *item;
PgSocket *sk;
statlist_for_each(item, list) {
sk = container_of(item, PgSocket, head);
socket_row(buf, sk, state, debug);
}
}
/* Command: SHOW CLIENTS */
static bool admin_show_clients(PgSocket *admin, const char *arg)
{
struct List *item;
PgPool *pool;
PktBuf *buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
socket_header(buf, false);
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
show_socket_list(buf, &pool->active_client_list, "active", false);
show_socket_list(buf, &pool->waiting_client_list, "waiting", false);
show_socket_list(buf, &pool->active_cancel_req_list, "active_cancel_req", false);
show_socket_list(buf, &pool->waiting_cancel_req_list, "waiting_cancel_req", false);
}
statlist_for_each(item, &peer_pool_list) {
pool = container_of(item, PgPool, head);
show_socket_list(buf, &pool->active_cancel_req_list, "active_cancel_req", false);
show_socket_list(buf, &pool->waiting_cancel_req_list, "waiting_cancel_req", false);
}
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW SERVERS */
static bool admin_show_servers(PgSocket *admin, const char *arg)
{
struct List *item;
PgPool *pool;
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
socket_header(buf, false);
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
show_socket_list(buf, &pool->active_server_list, "active", false);
show_socket_list(buf, &pool->idle_server_list, "idle", false);
show_socket_list(buf, &pool->used_server_list, "used", false);
show_socket_list(buf, &pool->tested_server_list, "tested", false);
show_socket_list(buf, &pool->new_server_list, "new", false);
show_socket_list(buf, &pool->active_cancel_server_list, "active_cancel", false);
show_socket_list(buf, &pool->being_canceled_server_list, "being_canceled", false);
}
statlist_for_each(item, &peer_pool_list) {
pool = container_of(item, PgPool, head);
show_socket_list(buf, &pool->new_server_list, "new", false);
show_socket_list(buf, &pool->active_cancel_server_list, "active_cancel", false);
}
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW SOCKETS */
static bool admin_show_sockets(PgSocket *admin, const char *arg)
{
struct List *item;
PgPool *pool;
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
socket_header(buf, true);
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
show_socket_list(buf, &pool->active_client_list, "cl_active", true);
show_socket_list(buf, &pool->waiting_client_list, "cl_waiting", true);
show_socket_list(buf, &pool->active_server_list, "sv_active", true);
show_socket_list(buf, &pool->idle_server_list, "sv_idle", true);
show_socket_list(buf, &pool->used_server_list, "sv_used", true);
show_socket_list(buf, &pool->tested_server_list, "sv_tested", true);
show_socket_list(buf, &pool->new_server_list, "sv_login", true);
}
show_socket_list(buf, &login_client_list, "cl_login", true);
admin_flush(admin, buf, "SHOW");
return true;
}
static void show_active_socket_list(PktBuf *buf, struct StatList *list, const char *state)
{
struct List *item;
statlist_for_each(item, list) {
PgSocket *sk = container_of(item, PgSocket, head);
if (!sbuf_is_empty(&sk->sbuf))
socket_row(buf, sk, state, true);
}
}
/* Command: SHOW ACTIVE_SOCKETS */
static bool admin_show_active_sockets(PgSocket *admin, const char *arg)
{
struct List *item;
PgPool *pool;
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
socket_header(buf, true);
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
show_active_socket_list(buf, &pool->active_client_list, "cl_active");
show_active_socket_list(buf, &pool->waiting_client_list, "cl_waiting");
show_active_socket_list(buf, &pool->active_server_list, "sv_active");
show_active_socket_list(buf, &pool->idle_server_list, "sv_idle");
show_active_socket_list(buf, &pool->used_server_list, "sv_used");
show_active_socket_list(buf, &pool->tested_server_list, "sv_tested");
show_active_socket_list(buf, &pool->new_server_list, "sv_login");
}
show_active_socket_list(buf, &login_client_list, "cl_login");
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW POOLS */
static bool admin_show_pools(PgSocket *admin, const char *arg)
{
struct List *item;
PgPool *pool;
PktBuf *buf;
PgSocket *waiter;
usec_t now = get_cached_time();
usec_t max_wait;
struct CfValue cv;
struct CfValue load_balance_hosts_lookup;
int pool_mode;
const char *load_balance_hosts_str;
cv.extra = pool_mode_map;
cv.value_p = &pool_mode;
load_balance_hosts_lookup.extra = load_balance_hosts_map;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "ssiiiiiiiiiiiiiss",
"database", "user",
"cl_active", "cl_waiting",
"cl_active_cancel_req",
"cl_waiting_cancel_req",
"sv_active",
"sv_active_cancel",
"sv_being_canceled",
"sv_idle",
"sv_used", "sv_tested",
"sv_login", "maxwait",
"maxwait_us", "pool_mode",
"load_balance_hosts");
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
waiter = first_socket(&pool->waiting_client_list);
max_wait = (waiter && waiter->query_start) ? now - waiter->query_start : 0;
pool_mode = probably_wrong_pool_pool_mode(pool);
load_balance_hosts_str = NULL;
load_balance_hosts_lookup.value_p = &pool->db->load_balance_hosts;
if (pool->db->host && strchr(pool->db->host, ','))
load_balance_hosts_str = cf_get_lookup(&load_balance_hosts_lookup);
pktbuf_write_DataRow(buf, "ssiiiiiiiiiiiiiss",
pool->db->name, pool->user_credentials->name,
statlist_count(&pool->active_client_list),
statlist_count(&pool->waiting_client_list),
statlist_count(&pool->active_cancel_req_list),
statlist_count(&pool->waiting_cancel_req_list),
statlist_count(&pool->active_server_list),
statlist_count(&pool->active_cancel_server_list),
statlist_count(&pool->being_canceled_server_list),
statlist_count(&pool->idle_server_list),
statlist_count(&pool->used_server_list),
statlist_count(&pool->tested_server_list),
statlist_count(&pool->new_server_list),
/* how long is the oldest client waited */
(int)(max_wait / USEC),
(int)(max_wait % USEC),
cf_get_lookup(&cv),
load_balance_hosts_str);
}
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW PEER_POOLS */
static bool admin_show_peer_pools(PgSocket *admin, const char *arg)
{
struct List *item;
PgPool *pool;
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "iiiii",
"peer_id",
"cl_active_cancel_req",
"cl_waiting_cancel_req",
"sv_active_cancel",
"sv_login");
statlist_for_each(item, &peer_pool_list) {
pool = container_of(item, PgPool, head);
pktbuf_write_DataRow(buf, "iiiii",
pool->db->peer_id,
statlist_count(&pool->active_cancel_req_list),
statlist_count(&pool->waiting_cancel_req_list),
statlist_count(&pool->active_cancel_server_list),
statlist_count(&pool->new_server_list));
}
admin_flush(admin, buf, "SHOW");
return true;
}
static void slab_stat_cb(void *arg, const char *slab_name,
unsigned size, unsigned free,
unsigned total)
{
PktBuf *buf = arg;
unsigned alloc = total * size;
pktbuf_write_DataRow(buf, "siiii", slab_name,
size, total - free, free, alloc);
}
/* Command: SHOW MEM */
static bool admin_show_mem(PgSocket *admin, const char *arg)
{
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "siiii", "name",
"size", "used", "free", "memtotal");
slab_stats(slab_stat_cb, buf);
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW STATE */
static bool admin_show_state(PgSocket *admin, const char *arg)
{
PktBuf *buf;
buf = pktbuf_dynamic(64);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "ss", "key", "value");
pktbuf_write_DataRow(buf, "ss", "active", (cf_pause_mode == P_NONE) ? "yes" : "no");
pktbuf_write_DataRow(buf, "ss", "paused", (cf_pause_mode == P_PAUSE) ? "yes" : "no");
pktbuf_write_DataRow(buf, "ss", "suspended", (cf_pause_mode == P_SUSPEND) ? "yes" : "no");
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW DNS_HOSTS */
static void dns_name_cb(void *arg, const char *name, const struct addrinfo *ai, usec_t ttl)
{
PktBuf *buf = arg;
char *s, *end;
char adrs[1024];
usec_t now = get_cached_time();
end = adrs + sizeof(adrs) - 2;
for (s = adrs; ai && s < end; ai = ai->ai_next) {
if (s != adrs)
*s++ = ',';
sa2str(ai->ai_addr, s, end - s);
s += strlen(s);
}
*s = 0;
/*
* Ttl can be smaller than now if we are waiting for dns reply for long.
*
* It's better to show 0 in that case as otherwise it confuses users into
* thinking that there is large ttl for the name.
*/
pktbuf_write_DataRow(buf, "sqs", name, ttl < now ? 0 : (ttl - now) / USEC, adrs);
}
static bool admin_show_dns_hosts(PgSocket *admin, const char *arg)
{
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "sqs", "hostname", "ttl", "addrs");
adns_walk_names(adns, dns_name_cb, buf);
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW DNS_ZONES */
static void dns_zone_cb(void *arg, const char *name, uint32_t serial, int nhosts)
{
PktBuf *buf = arg;
pktbuf_write_DataRow(buf, "sqi", name, (uint64_t)serial, nhosts);
}
static bool admin_show_dns_zones(PgSocket *admin, const char *arg)
{
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "sqi", "zonename", "serial", "count");
adns_walk_zones(adns, dns_zone_cb, buf);
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: SHOW CONFIG */
static void show_one_param(void *arg, const char *name, const char *val, const char *defval, bool reloadable)
{
PktBuf *buf = arg;
pktbuf_write_DataRow(buf, "ssss", name, val, defval,
reloadable ? "yes" : "no");
}
static bool admin_show_config(PgSocket *admin, const char *arg)
{
PktBuf *buf;
buf = pktbuf_dynamic(256);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "ssss", "key", "value", "default", "changeable");
config_for_each(show_one_param, buf);
admin_flush(admin, buf, "SHOW");
return true;
}
/* Command: RELOAD */
static bool admin_cmd_reload(PgSocket *admin, const char *arg)
{
if (arg && *arg)
return syntax_error(admin);
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
log_info("RELOAD command issued");
load_config();
if (!sbuf_tls_setup())
log_error("TLS configuration could not be reloaded, keeping old configuration");
return admin_ready(admin, "RELOAD");
}
/* Command: SHUTDOWN */
static bool admin_cmd_shutdown(PgSocket *admin, const char *arg)
{
enum ShutDownMode mode = SHUTDOWN_IMMEDIATE;
if (arg && *arg) {
if (strcasecmp(arg, "WAIT_FOR_CLIENTS") == 0)
mode = SHUTDOWN_WAIT_FOR_CLIENTS;
else if (strcasecmp(arg, "WAIT_FOR_SERVERS") == 0)
mode = SHUTDOWN_WAIT_FOR_SERVERS;
else
return syntax_error(admin);
}
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
/*
* note: new pooler expects unix socket file gone when it gets
* event from fd. Currently atexit() cleanup should be called
* before closing open sockets.
*/
cf_shutdown = mode;
if (mode == SHUTDOWN_IMMEDIATE) {
log_info("SHUTDOWN command issued");
event_base_loopbreak(pgb_event_base);
/*
* By not running admin_ready the connection is kept open
* until the process is actually shut down.
*/
return true;
} else {
if (mode == SHUTDOWN_WAIT_FOR_SERVERS) {
cf_pause_mode = P_PAUSE;
log_info("SHUTDOWN WAIT_FOR_SERVERS command issued");
} else {
log_info("SHUTDOWN WAIT_FOR_CLIENTS command issued");
}
cleanup_sockets();
return admin_ready(admin, "SHUTDOWN");
}
}
static void full_resume(void)
{
int tmp_mode = cf_pause_mode;
cf_pause_mode = P_NONE;
if (tmp_mode == P_SUSPEND)
resume_all();
}
/* Command: RESUME */
static bool admin_cmd_resume(PgSocket *admin, const char *arg)
{
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (!arg[0]) {
log_info("RESUME command issued");
if (cf_shutdown) {
return admin_error(admin, "pooler is shutting down");
} else if (cf_pause_mode != P_NONE) {
full_resume();
} else {
return admin_error(admin, "pooler is not paused/suspended");
}
} else {
PgDatabase *db = find_database(arg);
log_info("RESUME '%s' command issued", arg);
if (db == NULL)
return admin_error(admin, "no such database: %s", arg);
if (!db->db_paused)
return admin_error(admin, "database %s is not paused", arg);
db->db_paused = false;
}
return admin_ready(admin, "RESUME");
}
/* Command: SUSPEND */
static bool admin_cmd_suspend(PgSocket *admin, const char *arg)
{
if (arg && *arg)
return syntax_error(admin);
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (cf_pause_mode)
return admin_error(admin, "already suspended/paused");
/* suspend needs to be able to flush buffers */
if (count_paused_databases() > 0)
return admin_error(admin, "cannot suspend with paused databases");
log_info("SUSPEND command issued");
cf_pause_mode = P_SUSPEND;
admin->wait_for_response = true;
suspend_pooler();
g_suspend_start = get_cached_time();
return true;
}
/* Command: PAUSE */
static bool admin_cmd_pause(PgSocket *admin, const char *arg)
{
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (cf_pause_mode)
return admin_error(admin, "already suspended/paused");
if (!arg[0]) {
log_info("PAUSE command issued");
cf_pause_mode = P_PAUSE;
admin->wait_for_response = true;
} else {
PgDatabase *db;
log_info("PAUSE '%s' command issued", arg);
db = find_or_register_database(admin, arg);
if (db == NULL)
return admin_error(admin, "no such database: %s", arg);
if (db == admin->pool->db)
return admin_error(admin, "cannot pause admin db: %s", arg);
db->db_paused = true;
if (count_db_active(db) > 0)
admin->wait_for_response = true;
else
return admin_ready(admin, "PAUSE");
}
return true;
}
/* Command: RECONNECT */
static bool admin_cmd_reconnect(PgSocket *admin, const char *arg)
{
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (!arg[0]) {
struct List *item;
PgPool *pool;
log_info("RECONNECT command issued");
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db->admin)
continue;
tag_database_dirty(pool->db);
}
} else {
PgDatabase *db;
log_info("RECONNECT '%s' command issued", arg);
db = find_or_register_database(admin, arg);
if (db == NULL)
return admin_error(admin, "no such database: %s", arg);
if (db == admin->pool->db)
return admin_error(admin, "cannot reconnect admin db: %s", arg);
tag_database_dirty(db);
}
return admin_ready(admin, "RECONNECT");
}
/* Command: DISABLE */
static bool admin_cmd_disable(PgSocket *admin, const char *arg)
{
PgDatabase *db;
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (!arg[0])
return admin_error(admin, "a database is required");
log_info("DISABLE '%s' command issued", arg);
db = find_or_register_database(admin, arg);
if (db == NULL)
return admin_error(admin, "no such database: %s", arg);
if (db->admin)
return admin_error(admin, "cannot disable admin db: %s", arg);
db->db_disabled = true;
return admin_ready(admin, "DISABLE");
}
/* Command: ENABLE */
static bool admin_cmd_enable(PgSocket *admin, const char *arg)
{
PgDatabase *db;
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (!arg[0])
return admin_error(admin, "a database is required");
log_info("ENABLE '%s' command issued", arg);
db = find_database(arg);
if (db == NULL)
return admin_error(admin, "no such database: %s", arg);
if (db->admin)
return admin_error(admin, "cannot disable admin db: %s", arg);
db->db_disabled = false;
return admin_ready(admin, "ENABLE");
}
static PgSocket *find_socket_in_list(unsigned long long int target_id, struct StatList *sockets)
{
struct List *item;
PgSocket *socket;
statlist_for_each(item, sockets) {
socket = container_of(item, PgSocket, head);
if (target_id == socket->id) {
return socket;
}
}
return NULL;
}
static PgSocket *find_client_global(unsigned long long int target_id)
{
PgSocket *kill_client;
struct List *item;
PgPool *pool;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
kill_client = find_socket_in_list(target_id, &pool->active_client_list);
if (kill_client != NULL) {
return kill_client;
}
kill_client = find_socket_in_list(target_id, &pool->waiting_client_list);
if (kill_client != NULL) {
return kill_client;
}
kill_client = find_socket_in_list(target_id, &pool->active_cancel_req_list);
if (kill_client != NULL) {
return kill_client;
}
kill_client = find_socket_in_list(target_id, &pool->waiting_cancel_req_list);
if (kill_client != NULL) {
return kill_client;
}
}
statlist_for_each(item, &peer_pool_list) {
pool = container_of(item, PgPool, head);
kill_client = find_socket_in_list(target_id, &pool->active_cancel_req_list);
if (kill_client != NULL) {
return kill_client;
}
kill_client = find_socket_in_list(target_id, &pool->waiting_cancel_req_list);
if (kill_client != NULL) {
return kill_client;
}
}
return NULL;
}
/* Command: KILL_CLIENT */
static bool admin_cmd_kill_client(PgSocket *admin, const char *arg)
{
PgSocket *kill_client;
unsigned long long int target_id = 0;
if (sscanf(arg, "%llu", &target_id) != 1) {
return admin_error(admin, "invalid client pointer supplied");
}
kill_client = find_client_global((unsigned long long int) target_id);
if (kill_client == NULL) {
return admin_error(admin, "client not found");
}
disconnect_client(kill_client, true, "admin forced disconnect");
return admin_ready(admin, "KILL_CLIENT");
}
/* Command: KILL */
static bool admin_cmd_kill(PgSocket *admin, const char *arg)
{
struct List *item, *tmp;
PgDatabase *db;
PgPool *pool;
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (cf_pause_mode)
return admin_error(admin, "already suspended/paused");
if (!arg[0])
return admin_error(admin, "a database is required");
log_info("KILL '%s' command issued", arg);
db = find_or_register_database(admin, arg);
if (db == NULL)
return admin_error(admin, "no such database: %s", arg);
if (db == admin->pool->db)
return admin_error(admin, "cannot kill admin db: %s", arg);
db->db_paused = true;
statlist_for_each_safe(item, &pool_list, tmp) {
pool = container_of(item, PgPool, head);
if (pool->db == db)
kill_pool(pool);
}
return admin_ready(admin, "KILL");
}
/* Command: WAIT_CLOSE */
static bool admin_cmd_wait_close(PgSocket *admin, const char *arg)
{
if (!admin->admin_user)
return admin_error(admin, "admin access needed");
if (!arg[0]) {
struct List *item;
PgPool *pool;
int active = 0;
log_info("WAIT_CLOSE command issued");
statlist_for_each(item, &pool_list) {
PgDatabase *db;
pool = container_of(item, PgPool, head);
db = pool->db;
db->db_wait_close = true;
active += count_db_active(db);
}
if (active > 0)
admin->wait_for_response = true;
else
return admin_ready(admin, "WAIT_CLOSE");
} else {
PgDatabase *db;
log_info("WAIT_CLOSE '%s' command issued", arg);
db = find_or_register_database(admin, arg);
if (db == NULL)
return admin_error(admin, "no such database: %s", arg);
if (db == admin->pool->db)
return admin_error(admin, "cannot wait in admin db: %s", arg);
db->db_wait_close = true;
if (count_db_active(db) > 0)
admin->wait_for_response = true;
else
return admin_ready(admin, "WAIT_CLOSE");
}
return true;
}
/* extract substring from regex group */
static bool copy_arg(const char *src, regmatch_t *glist,
int gnum, char *dst, unsigned dstmax,
char qchar)
{
regmatch_t *g = &glist[gnum];
unsigned len;
const char *s;
char *d = dst;
unsigned i;
/* no match, if regex allows, it must be fine */
if (g->rm_so < 0 || g->rm_eo < 0) {
dst[0] = 0;
return true;
}
len = g->rm_eo - g->rm_so;
s = src + g->rm_so;
/* too big value */
if (len >= dstmax) {
dst[0] = 0;
return false;
}
/* copy and unquote */
if (*s == qchar) {
for (i = 1; i < len - 1; i++) {
if (s[i] == qchar && s[i + 1] == qchar)
i++;
*d++ = s[i];
}
len = d - dst;
} else {
memcpy(dst, s, len);
}
dst[len] = 0;
return true;
}
static bool admin_show_help(PgSocket *admin, const char *arg)
{
bool res;
SEND_generic(res, admin, PqMsg_NoticeResponse,
"sssss",
"SNOTICE", "C00000", "MConsole usage",
"D\n\tSHOW HELP|CONFIG|DATABASES"
"|POOLS|CLIENTS|SERVERS|USERS|VERSION\n"
"\tSHOW PEERS|PEER_POOLS\n"
"\tSHOW FDS|SOCKETS|ACTIVE_SOCKETS|LISTS|MEM|STATE\n"
"\tSHOW DNS_HOSTS|DNS_ZONES\n"
"\tSHOW STATS|STATS_TOTALS|STATS_AVERAGES|TOTALS\n"
"\tSET key = arg\n"
"\tRELOAD\n"
"\tPAUSE []\n"
"\tRESUME []\n"
"\tDISABLE \n"
"\tENABLE \n"
"\tRECONNECT []\n"
"\tKILL \n"
"\tKILL_CLIENT \n"
"\tSUSPEND\n"
"\tSHUTDOWN\n"
"\tSHUTDOWN WAIT_FOR_SERVERS|WAIT_FOR_CLIENTS\n"
"\tWAIT_CLOSE []", "");
if (res)
res = admin_ready(admin, "SHOW");
return res;
}
static bool admin_show_version(PgSocket *admin, const char *arg)
{
PktBuf *buf;
buf = pktbuf_dynamic(128);
if (!buf) {
admin_error(admin, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "s", "version");
pktbuf_write_DataRow(buf, "s", PACKAGE_STRING);
admin_flush(admin, buf, "SHOW");
return true;
}
static bool admin_show_stats(PgSocket *admin, const char *arg)
{
return admin_database_stats(admin, &pool_list);
}
static bool admin_show_stats_totals(PgSocket *admin, const char *arg)
{
return admin_database_stats_totals(admin, &pool_list);
}
static bool admin_show_stats_averages(PgSocket *admin, const char *arg)
{
return admin_database_stats_averages(admin, &pool_list);
}
static bool admin_show_totals(PgSocket *admin, const char *arg)
{
return show_stat_totals(admin, &pool_list);
}
static struct cmd_lookup show_map [] = {
{"clients", admin_show_clients},
{"config", admin_show_config},
{"databases", admin_show_databases},
{"fds", admin_show_fds},
{"help", admin_show_help},
{"lists", admin_show_lists},
{"peers", admin_show_peers},
{"peer_pools", admin_show_peer_pools},
{"pools", admin_show_pools},
{"servers", admin_show_servers},
{"sockets", admin_show_sockets},
{"active_sockets", admin_show_active_sockets},
{"stats", admin_show_stats},
{"stats_totals", admin_show_stats_totals},
{"stats_averages", admin_show_stats_averages},
{"users", admin_show_users},
{"version", admin_show_version},
{"totals", admin_show_totals},
{"mem", admin_show_mem},
{"dns_hosts", admin_show_dns_hosts},
{"dns_zones", admin_show_dns_zones},
{"state", admin_show_state},
{NULL, NULL}
};
static bool admin_cmd_show(PgSocket *admin, const char *arg)
{
if (fake_show(admin, arg))
return true;
return exec_cmd(show_map, admin, arg, NULL);
}
static struct cmd_lookup cmd_list [] = {
{"disable", admin_cmd_disable},
{"enable", admin_cmd_enable},
{"kill", admin_cmd_kill},
{"kill_client", admin_cmd_kill_client},
{"pause", admin_cmd_pause},
{"reconnect", admin_cmd_reconnect},
{"reload", admin_cmd_reload},
{"resume", admin_cmd_resume},
{"select", admin_cmd_show},
{"show", admin_cmd_show},
{"shutdown", admin_cmd_shutdown},
{"suspend", admin_cmd_suspend},
{"wait_close", admin_cmd_wait_close},
{NULL, NULL}
};
/* handle user query */
static bool admin_parse_query(PgSocket *admin, const char *q)
{
regmatch_t grp[MAX_GROUPS];
char cmd[16];
char arg[64];
char val[256];
bool res;
bool ok;
current_query = q;
if (regexec(&rc_cmd, q, MAX_GROUPS, grp, 0) == 0) {
ok = copy_arg(q, grp, CMD_NAME, cmd, sizeof(cmd), '"');
if (!ok)
goto failed;
ok = copy_arg(q, grp, CMD_ARG, arg, sizeof(arg), '"');
if (!ok)
goto failed;
res = exec_cmd(cmd_list, admin, cmd, arg);
} else if (regexec(&rc_set_str, q, MAX_GROUPS, grp, 0) == 0) {
ok = copy_arg(q, grp, SET_KEY, arg, sizeof(arg), '"');
if (!ok || !arg[0])
goto failed;
ok = copy_arg(q, grp, SET_VAL, val, sizeof(val), '\'');
if (!ok)
goto failed;
res = admin_set(admin, arg, val);
} else if (regexec(&rc_set_word, q, MAX_GROUPS, grp, 0) == 0) {
ok = copy_arg(q, grp, SET_KEY, arg, sizeof(arg), '"');
if (!ok || !arg[0])
goto failed;
ok = copy_arg(q, grp, SET_VAL, val, sizeof(val), '"');
if (!ok)
goto failed;
res = admin_set(admin, arg, val);
} else {
res = syntax_error(admin);
}
done:
current_query = NULL;
if (!res)
disconnect_client(admin, true, "failure");
return res;
failed:
res = admin_error(admin, "bad arguments");
goto done;
}
/* handle packets */
bool admin_handle_client(PgSocket *admin, PktHdr *pkt)
{
const char *q;
bool res;
/* don't tolerate partial packets */
if (incomplete_pkt(pkt)) {
disconnect_client(admin, true, "incomplete pkt");
return false;
}
switch (pkt->type) {
case PqMsg_Query:
if (!mbuf_get_string(&pkt->data, &q)) {
disconnect_client(admin, true, "incomplete query");
return false;
}
log_debug("got admin query: %s", q);
res = admin_parse_query(admin, q);
if (res)
sbuf_prepare_skip(&admin->sbuf, pkt->len);
return res;
case PqMsg_Terminate:
disconnect_client(admin, false, "close req");
break;
case PqMsg_Parse:
case PqMsg_Bind:
case PqMsg_Execute:
/*
* Effectively the same as the default case, but give
* a more helpful error message in these cases.
*/
admin_error(admin, "extended query protocol not supported by admin console");
disconnect_client(admin, true, "bad packet");
break;
default:
admin_error(admin, "unsupported packet type for admin console: %d", pkt_desc(pkt));
disconnect_client(admin, true, "bad packet");
break;
}
return false;
}
/**
* Client is unauthenticated, look if it wants to connect
* to special "pgbouncer" user.
*/
bool admin_pre_login(PgSocket *client, const char *username)
{
client->admin_user = false;
client->own_user = false;
/* tag same uid as special */
if (pga_is_unix(&client->remote_addr)) {
uid_t peer_uid;
gid_t peer_gid;
int res;
res = getpeereid(sbuf_socket(&client->sbuf), &peer_uid, &peer_gid);
if (res >= 0 && peer_uid == getuid()
&& strcmp("pgbouncer", username) == 0) {
client->login_user_credentials = admin_pool->db->forced_user_credentials;
client->own_user = true;
client->admin_user = true;
if (!check_db_connection_count(client))
return false;
if (cf_log_connections)
slog_info(client, "pgbouncer access from unix socket");
return true;
}
}
/*
* auth_type=any does not keep original username around,
* so username based check has to take place here
*/
if (cf_auth_type == AUTH_TYPE_ANY) {
if (strlist_contains(cf_admin_users, username)) {
client->login_user_credentials = admin_pool->db->forced_user_credentials;
client->admin_user = true;
if (!check_db_connection_count(client))
return false;
return true;
} else if (strlist_contains(cf_stats_users, username)) {
client->login_user_credentials = admin_pool->db->forced_user_credentials;
if (!check_db_connection_count(client))
return false;
if (!check_user_connection_count(client))
return false;
return true;
}
}
return false;
}
bool admin_post_login(PgSocket *client)
{
const char *username = client->login_user_credentials->name;
if (cf_auth_type == AUTH_TYPE_ANY)
return true;
if (client->admin_user || strlist_contains(cf_admin_users, username)) {
client->admin_user = true;
return true;
} else if (strlist_contains(cf_stats_users, username)) {
return true;
}
disconnect_client(client, true, "not allowed");
return false;
}
/* init special database and query parsing */
void admin_setup(void)
{
PgDatabase *db;
PgPool *pool;
PgGlobalUser *user;
PktBuf *msg;
int res;
/* fake database */
db = add_database("pgbouncer");
if (!db)
die("no memory for admin database");
db->port = cf_listen_port;
db->pool_size = 2;
db->admin = true;
db->pool_mode = POOL_STMT;
if (!force_user_credentials(db, "pgbouncer", ""))
die("no mem on startup - cannot alloc pgbouncer user");
/* fake pool */
pool = get_pool(db, db->forced_user_credentials);
if (!pool)
die("cannot create admin pool?");
admin_pool = pool;
/* find an existing user or create a new fake user with disabled password */
user = find_or_add_new_global_user("pgbouncer", "");
if (!user) {
die("cannot create admin user?");
}
/* prepare welcome */
msg = pktbuf_dynamic(128);
if (!msg)
die("out of memory");
pktbuf_write_AuthenticationOk(msg);
pktbuf_write_ParameterStatus(msg, "server_version", PACKAGE_VERSION "/bouncer");
pktbuf_write_ParameterStatus(msg, "client_encoding", "UTF8");
pktbuf_write_ParameterStatus(msg, "server_encoding", "UTF8");
pktbuf_write_ParameterStatus(msg, "DateStyle", "ISO");
pktbuf_write_ParameterStatus(msg, "TimeZone", "GMT");
pktbuf_write_ParameterStatus(msg, "standard_conforming_strings", "on");
pktbuf_write_ParameterStatus(msg, "is_superuser", "on");
if (msg->failed)
die("admin welcome failed");
pool->welcome_msg = msg;
pool->welcome_msg_ready = true;
msg = pktbuf_dynamic(128);
if (!msg)
die("cannot create admin startup pkt");
db->startup_params = msg;
pktbuf_put_string(msg, "database");
db->dbname = "pgbouncer";
pktbuf_put_string(msg, db->dbname);
/* initialize regexes */
res = regcomp(&rc_cmd, cmd_normal_rx, REG_EXTENDED | REG_ICASE);
if (res != 0)
fatal("cmd regex compilation error");
res = regcomp(&rc_set_word, cmd_set_word_rx, REG_EXTENDED | REG_ICASE);
if (res != 0)
fatal("set/word regex compilation error");
res = regcomp(&rc_set_str, cmd_set_str_rx, REG_EXTENDED | REG_ICASE);
if (res != 0)
fatal("set/str regex compilation error");
}
void admin_pause_done(void)
{
struct List *item, *tmp;
PgSocket *admin;
bool res;
statlist_for_each_safe(item, &admin_pool->active_client_list, tmp) {
admin = container_of(item, PgSocket, head);
if (!admin->wait_for_response)
continue;
switch (cf_pause_mode) {
case P_PAUSE:
res = admin_ready(admin, "PAUSE");
break;
case P_SUSPEND:
res = admin_ready(admin, "SUSPEND");
break;
default:
if (count_paused_databases() > 0) {
res = admin_ready(admin, "PAUSE");
} else {
/* FIXME */
fatal("admin_pause_done: bad state");
res = false;
}
}
if (!res)
disconnect_client(admin, false, "dead admin");
else
admin->wait_for_response = false;
}
if (statlist_empty(&admin_pool->active_client_list)
&& cf_pause_mode == P_SUSPEND) {
log_info("admin disappeared when suspended, doing RESUME");
cf_pause_mode = P_NONE;
resume_all();
}
}
void admin_wait_close_done(void)
{
struct List *item, *tmp;
PgSocket *admin;
bool res;
statlist_for_each_safe(item, &admin_pool->active_client_list, tmp) {
admin = container_of(item, PgSocket, head);
if (!admin->wait_for_response)
continue;
res = admin_ready(admin, "WAIT_CLOSE");
if (!res)
disconnect_client(admin, false, "dead admin");
else
admin->wait_for_response = false;
}
}
/* admin on console has pressed ^C */
void admin_handle_cancel(PgSocket *admin)
{
/* weird, but no reason to fail */
if (!admin->wait_for_response)
slog_warning(admin, "admin cancel request for non-waiting client?");
if (cf_shutdown)
return;
if (cf_pause_mode != P_NONE)
full_resume();
}
pgbouncer-1.24.1/src/varcache.c 0000644 0001750 0000000 00000016455 14777762222 013231 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Operations with server config parameters.
*/
#include "bouncer.h"
#include
#include
#include "common/uthash_lowercase.h"
static int num_var_cached = 0;
struct var_lookup {
const char *name; /* key (string is WITHIN the structure) */
int idx;
UT_hash_handle hh; /* makes this structure hashable */
};
static struct var_lookup *lookup_map;
static struct StrPool *vpool;
static inline struct PStr *get_value(VarCache *cache, const struct var_lookup *lk)
{
return cache->var_list[lk->idx];
}
static bool sl_add(void *arg, const char *s)
{
return strlist_append(arg, s);
}
int get_num_var_cached(void)
{
return num_var_cached;
}
static void init_var_lookup_from_config(const char *cf_track_extra_parameters, int *num_vars)
{
char *var_name = NULL;
struct var_lookup *lookup = NULL;
struct StrList *sl = strlist_new(NULL);
if (!parse_word_list(cf_track_extra_parameters, sl_add, sl))
die("failed to parse track_extra_parameters in config %s", cf_track_extra_parameters);
while (!strlist_empty(sl)) {
var_name = strlist_pop(sl);
if (!var_name)
continue;
HASH_FIND_STR(lookup_map, var_name, lookup);
/* If the var name is already on the hash map, do not update its idx */
if (lookup != NULL)
continue;
lookup = (struct var_lookup *)malloc(sizeof *lookup);
lookup->name = strdup(var_name);
lookup->idx = (*num_vars)++;
HASH_ADD_KEYPTR(hh, lookup_map, lookup->name, strlen(lookup->name), lookup);
free(var_name);
}
strlist_free(sl);
}
void init_var_lookup(const char *cf_track_extra_parameters)
{
const char *names[] = { "DateStyle", "client_encoding", "TimeZone", "standard_conforming_strings", "application_name", NULL };
int idx = 0;
struct var_lookup *lookup = NULL;
/* Always add the static list of names for compatibility */
for (; names[idx]; idx++) {
lookup = (struct var_lookup *)malloc(sizeof *lookup);
lookup->name = names[idx];
lookup->idx = idx;
HASH_ADD_KEYPTR(hh, lookup_map, lookup->name, strlen(lookup->name), lookup);
}
init_var_lookup_from_config(cf_track_extra_parameters, &idx);
num_var_cached = idx;
}
bool varcache_set(VarCache *cache, const char *key, const char *value)
{
const struct var_lookup *lk = NULL;
struct PStr *pstr = NULL;
if (!vpool) {
vpool = strpool_create(USUAL_ALLOC);
if (!vpool)
return false;
}
HASH_FIND_STR(lookup_map, key, lk);
if (lk == NULL)
return false;
/* drop old value */
strpool_decref(cache->var_list[lk->idx]);
cache->var_list[lk->idx] = NULL;
/* NULL value? */
if (!value)
return false;
/* set new value */
pstr = strpool_get(vpool, value, strlen(value));
if (!pstr)
return false;
cache->var_list[lk->idx] = pstr;
return true;
}
static bool variable_is_guc_list_quote(const char *key)
{
if (strcasecmp("search_path", key) == 0)
return true;
return false;
}
static int apply_var(PktBuf *pkt, const char *key,
const struct PStr *cval,
const struct PStr *sval)
{
char buf[300];
char qbuf[128];
unsigned len;
const char *tmp;
/* if unset, skip */
if (!cval || !sval)
return 0;
/* if equal, skip */
if (cval == sval)
return 0;
/* ignore case difference */
if (strcasecmp(cval->str, sval->str) == 0)
return 0;
/* parameters that are marked GUC_LIST_QUOTE are returned already fully quoted
* re-quoting them using pg_quote_literal will result in malformed values. */
if (variable_is_guc_list_quote(key)) {
/* zero length elements of the form "" should be specially handled.*/
if (strcmp(cval->str, "\"\"") == 0) {
tmp = "''";
} else {
tmp = cval->str;
}
} else if (pg_quote_literal(qbuf, cval->str, sizeof(qbuf))) {
tmp = qbuf;
} else {
return 0;
}
/* add SET statement to packet */
len = snprintf(buf, sizeof(buf), "SET %s=%s;", key, tmp);
if (len < sizeof(buf)) {
pktbuf_put_bytes(pkt, buf, len);
} else {
char *buf2 = malloc(sizeof(char)*len);
if (!buf2)
die("failed to allocate memory in apply_var");
snprintf(buf2, len, "SET %s=%s;", key, tmp);
pktbuf_put_bytes(pkt, buf2, len);
free(buf2);
}
return 1;
}
bool varcache_apply(PgSocket *server, PgSocket *client, bool *changes_p)
{
int changes = 0;
struct PStr *cval, *sval;
const struct var_lookup *lk, *tmp;
int sql_ofs;
struct PktBuf *pkt = pktbuf_temp();
pktbuf_start_packet(pkt, PqMsg_Query);
/* grab query position inside pkt */
sql_ofs = pktbuf_written(pkt);
HASH_ITER(hh, lookup_map, lk, tmp) {
sval = get_value(&server->vars, lk);
cval = get_value(&client->vars, lk);
changes += apply_var(pkt, lk->name, cval, sval);
}
*changes_p = changes > 0;
if (!changes)
return true;
pktbuf_put_char(pkt, 0);
pktbuf_finish_packet(pkt);
slog_debug(server, "varcache_apply: %s", pkt->buf + sql_ofs);
return pktbuf_send_immediate(pkt, server);
}
void varcache_set_canonical(PgSocket *server, PgSocket *client)
{
struct PStr *server_val, *client_val;
const struct var_lookup *lk, *tmp;
HASH_ITER(hh, lookup_map, lk, tmp) {
server_val = server->vars.var_list[lk->idx];
client_val = client->vars.var_list[lk->idx];
if (client_val && server_val && client_val != server_val) {
slog_debug(client, "varcache_set_canonical: setting %s to its canonical version %s -> %s",
lk->name, client_val->str, server_val->str);
strpool_incref(server_val);
strpool_decref(client_val);
client->vars.var_list[lk->idx] = server_val;
}
}
}
void varcache_apply_startup(PktBuf *pkt, PgSocket *client)
{
const struct var_lookup *lk, *tmp;
HASH_ITER(hh, lookup_map, lk, tmp) {
struct PStr *val = get_value(&client->vars, lk);
if (!val)
continue;
slog_debug(client, "varcache_apply_startup: %s=%s", lk->name, val->str);
pktbuf_put_string(pkt, lk->name);
pktbuf_put_string(pkt, val->str);
}
}
void varcache_fill_unset(VarCache *src, PgSocket *dst)
{
struct PStr *srcval, *dstval;
const struct var_lookup *lk, *tmp;
HASH_ITER(hh, lookup_map, lk, tmp) {
srcval = src->var_list[lk->idx];
dstval = dst->vars.var_list[lk->idx];
if (!dstval) {
strpool_incref(srcval);
dst->vars.var_list[lk->idx] = srcval;
}
}
}
void varcache_clean(VarCache *cache)
{
for (int i = 0; i < num_var_cached; i++) {
strpool_decref(cache->var_list[i]);
cache->var_list[i] = NULL;
}
}
void varcache_add_params(PktBuf *pkt, VarCache *vars)
{
struct PStr *val;
const struct var_lookup *lk, *tmp;
HASH_ITER(hh, lookup_map, lk, tmp) {
val = vars->var_list[lk->idx];
if (val)
pktbuf_write_ParameterStatus(pkt, lk->name, val->str);
}
}
void varcache_deinit(void)
{
strpool_free(vpool);
vpool = NULL;
}
pgbouncer-1.24.1/src/messages.c 0000644 0001750 0000000 00000013077 14777762222 013261 0000000 0000000 #include "bouncer.h"
/* Inspect Parse packet to see if it defines a named prepared statement */
PreparedStatementAction inspect_parse_packet(PgSocket *client, PktHdr *pkt)
{
const char *statement;
if (!mbuf_get_string(&pkt->data, &statement))
return PS_INSPECT_FAILED;
if (!*statement) { /* ignore empty statements */
slog_noise(client, "inspect_parse_packet: type=%c, len=%d, statement=", pkt->type, pkt->len);
return PS_IGNORE;
}
slog_noise(client, "inspect_parse_packet: type=%c, len=%d, statement=%s", pkt->type, pkt->len, statement);
return PS_HANDLE_FULL_PACKET;
}
/* Inspect Bind packet to see if it defines a named prepared statement */
PreparedStatementAction inspect_bind_packet(PgSocket *client, PktHdr *pkt)
{
const char *portal;
const char *statement;
if (!mbuf_get_string(&pkt->data, &portal))
return PS_INSPECT_FAILED;
if (!mbuf_get_string(&pkt->data, &statement))
return PS_INSPECT_FAILED;
if (!*statement) { /* ignore empty statements */
slog_noise(client, "inspect_bind_packet: type=%c, len=%d, statement=", pkt->type, pkt->len);
return PS_IGNORE;
}
slog_noise(client, "inspect_bind_packet: type=%c, len=%d, statement=%s", pkt->type, pkt->len, statement);
return PS_HANDLE;
}
/* Inspect Describe packet to see if it defines a named prepared statement */
PreparedStatementAction inspect_describe_or_close_packet(PgSocket *client, PktHdr *pkt)
{
char describe;
const char *statement;
if (!mbuf_get_char(&pkt->data, &describe))
return PS_INSPECT_FAILED;
if (describe != 'S') {
slog_noise(client, "inspect_describe_or_close_packet: type=%c, len=%d, P/S=%c", pkt->type, pkt->len, describe);
return PS_IGNORE;
}
if (!mbuf_get_string(&pkt->data, &statement))
return PS_INSPECT_FAILED;
if (!*statement) { /* ignore empty statements */
slog_noise(client, "inspect_describe_or_close_packet: type=%c, len=%d, P/S=%c, statement=", pkt->type, pkt->len, describe);
return PS_IGNORE;
}
slog_noise(client, "inspect_describe_or_close_packet: type=%c, len=%d, P/S=%c, statement=%s", pkt->type, pkt->len, describe, statement);
return PS_HANDLE;
}
/*
* Unmarshall Parse packet into PgParsePacket struct for further processing.
*
* Note: The PgParsePacket still references the data stored in the PktHdr. So
* the PktHdr should not be freed until the PgParsePacket is not necessary
* anymore.
*/
bool unmarshall_parse_packet(PgSocket *client, PktHdr *pkt, PgParsePacket *parse_packet)
{
const char *statement;
const char *query;
uint16_t num_parameters;
const uint8_t *parameter_types_bytes;
size_t parameters_length;
if (!mbuf_get_string(&pkt->data, &statement))
goto failed;
if (!mbuf_get_string(&pkt->data, &query))
goto failed;
/* number of parameter data types */
if (!mbuf_get_uint16be(&pkt->data, &num_parameters))
goto failed;
parameters_length = (size_t) num_parameters * 4;
if (!mbuf_get_bytes(&pkt->data, parameters_length, ¶meter_types_bytes))
goto failed;
parse_packet->len = pkt->len;
parse_packet->name = statement;
parse_packet->query_and_parameters_len =
strlen(query)
+ 1 /* \0 */
+ sizeof(num_parameters)
+ parameters_length;
parse_packet->query_and_parameters = query;
return true;
failed:
disconnect_client(client, true, "broken Parse packet");
return false;
}
/*
* Unmarshall (partial) Bind packet into PgBindPacket struct for further processing
*
* Note: The PgBindPacket still references the data stored in the PktHdr. So
* the PktHdr should not be freed until the PgBindPacket is not necessary
* anymore.
*/
bool unmarshall_bind_packet(PgSocket *client, PktHdr *pkt, PgBindPacket *bind_packet)
{
const char *portal;
const char *statement;
if (!mbuf_get_string(&pkt->data, &portal))
goto failed;
if (!mbuf_get_string(&pkt->data, &statement))
goto failed;
bind_packet->len = pkt->len;
bind_packet->portal = portal;
bind_packet->name = statement;
return true;
failed:
disconnect_client(client, true, "broken Bind packet");
return false;
}
/*
* Unmarshall Describe packet into PgDescribePacket struct for further processing
*
* Note: The PgDescribePacket still references the data stored in the PktHdr. So
* the PktHdr should not be freed until the PgDescribePacket is not necessary
* anymore.
*/
bool unmarshall_describe_packet(PgSocket *client, PktHdr *pkt, PgDescribePacket *describe_packet)
{
char describe;
const char *statement;
if (incomplete_pkt(pkt))
return false;
if (!mbuf_get_char(&pkt->data, &describe))
goto failed;
if (!mbuf_get_string(&pkt->data, &statement))
goto failed;
describe_packet->type = describe;
describe_packet->name = statement;
return true;
failed:
disconnect_client(client, true, "broken Describe packet");
return false;
}
/*
* Unmarshall Close packet into PgClosePacket struct for further processing
*
* Note: The PgClosePacket still references the data stored in the PktHdr. So
* the PktHdr should not be freed until the PgClosePacket is not necessary
* anymore.
*/
bool unmarshall_close_packet(PgSocket *client, PktHdr *pkt, PgClosePacket *close_packet)
{
char type;
const char *name;
if (incomplete_pkt(pkt))
return false;
if (!mbuf_get_char(&pkt->data, &type))
goto failed;
if (!mbuf_get_string(&pkt->data, &name))
goto failed;
close_packet->type = type;
close_packet->name = name;
slog_noise(client, "unmarshall_close_packet: type=%c, len=%d, S/P=%c, name=%s", pkt->type, pkt->len, type, name);
return true;
failed:
disconnect_client(client, true, "broken Close packet");
return false;
}
bool is_close_named_statement_packet(PgClosePacket *close_packet)
{
return close_packet->type == 'S' && *close_packet->name;
}
pgbouncer-1.24.1/src/proto.c 0000644 0001750 0000000 00000050773 14777762222 012621 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Pieces that need to have detailed info about protocol.
*/
#include "bouncer.h"
#include "scram.h"
/*
* parse protocol header from struct MBuf
*/
/*
* Parses pkt header from buffer, returns false if failed.
*
* This handles both regular packets as well as startup/special
* packets (which are actually v2-style packets). Afterwards, the
* type and the length is available in pkt independent of what kind
* this packet is.
*/
bool get_header(struct MBuf *data, PktHdr *pkt)
{
unsigned type;
uint32_t len;
unsigned got;
unsigned avail;
uint16_t len16;
uint8_t type8;
uint32_t code;
struct MBuf hdr;
const uint8_t *ptr;
mbuf_copy(data, &hdr);
if (mbuf_avail_for_read(&hdr) < NEW_HEADER_LEN) {
log_noise("get_header: less than %d bytes available", NEW_HEADER_LEN);
return false;
}
if (!mbuf_get_byte(&hdr, &type8))
return false;
type = type8;
if (type != 0) {
/*
* Regular (v3) packet, starts with type byte and
* 4-byte length.
*/
/* wire length does not include type byte */
if (!mbuf_get_uint32be(&hdr, &len))
return false;
len++;
got = NEW_HEADER_LEN;
} else {
/*
* Startup/special (formerly v2) packet, formally
* starts with 4-byte length. We assume the first
* byte is zero because in current use they shouldn't
* be that long to have more than zero in the MSB.
*/
/* second byte should also be zero */
if (!mbuf_get_byte(&hdr, &type8))
return false;
if (type8 != 0) {
log_noise("get_header: unknown special pkt");
return false;
}
/* don't tolerate partial pkt */
if (mbuf_avail_for_read(&hdr) < OLD_HEADER_LEN - 2) {
log_noise("get_header: less than %d bytes for special pkt", OLD_HEADER_LEN);
return false;
}
if (!mbuf_get_uint16be(&hdr, &len16))
return false;
len = len16;
/* 4-byte code follows */
if (!mbuf_get_uint32be(&hdr, &code))
return false;
if (code == PKT_CANCEL) {
type = PKT_CANCEL;
} else if (code == PKT_SSLREQ) {
type = PKT_SSLREQ;
} else if (code == PKT_GSSENCREQ) {
type = PKT_GSSENCREQ;
} else if (code >= PKT_STARTUP_V3 && code < PKT_STARTUP_V3_UNSUPPORTED) {
type = PKT_STARTUP_V3;
} else if (code >= PKT_STARTUP_V3_UNSUPPORTED && code < PKT_STARTUP_V4) {
type = PKT_STARTUP_V3_UNSUPPORTED;
} else if (code == PKT_STARTUP_V2) {
type = PKT_STARTUP_V2;
} else {
log_noise("get_header: unknown special pkt: len=%u code=%u", len, code);
return false;
}
got = OLD_HEADER_LEN;
}
/* don't believe nonsense */
if (len < got || len > cf_max_packet_size)
return false;
/* store pkt info */
pkt->type = type;
pkt->len = len;
/* fill pkt with only data for this packet */
if (len > mbuf_avail_for_read(data)) {
avail = mbuf_avail_for_read(data);
} else {
avail = len;
}
if (!mbuf_slice(data, avail, &pkt->data))
return false;
/* tag header as read */
return mbuf_get_bytes(&pkt->data, got, &ptr);
}
/*
* Send error message packet to client.
*
* If level_fatal is true, use severity "FATAL", else "ERROR". Although it is
* not technically part of the protocol specification, some clients expect the
* connection to be closed after receiving a FATAL error, and don't expect it
* to be closed after an ERROR-level error. So to be nice, level_fatal should
* be true if the caller plans to close the connection after sending this
* error.
* Error code 08P01 (ERRCODE_PROTOCOL_VIOLATION) is used as default error code
* if no SQLSTATE is provided.
*/
bool send_pooler_error(PgSocket *client, bool send_ready, const char *sqlstate, bool level_fatal, const char *msg)
{
uint8_t tmpbuf[512];
PktBuf buf;
if (cf_log_pooler_errors)
slog_warning(client, "pooler error: %s", msg);
pktbuf_static(&buf, tmpbuf, sizeof(tmpbuf));
pktbuf_write_generic(&buf, PqMsg_ErrorResponse, "cscscsc",
'S', level_fatal ? "FATAL" : "ERROR",
'C', sqlstate ? sqlstate : "08P01", 'M', msg, 0);
if (send_ready)
pktbuf_write_ReadyForQuery(&buf);
return pktbuf_send_immediate(&buf, client);
}
/*
* Parse server error message and log it.
*/
void parse_server_error(PktHdr *pkt, const char **level_p, const char **msg_p, const char **sqlstate_p)
{
const char *level = NULL, *msg = NULL, *sqlstate = NULL, *val;
uint8_t type;
while (mbuf_avail_for_read(&pkt->data)) {
if (!mbuf_get_byte(&pkt->data, &type))
break;
if (type == 0)
break;
if (!mbuf_get_string(&pkt->data, &val))
break;
if (type == 'S') {
level = val;
} else if (type == 'M') {
msg = val;
} else if (type == 'C') {
sqlstate = val;
}
}
*level_p = level;
*msg_p = msg;
*sqlstate_p = sqlstate;
}
void log_server_error(const char *note, PktHdr *pkt)
{
const char *level = NULL, *msg = NULL, *sqlstate = NULL;
parse_server_error(pkt, &level, &msg, &sqlstate);
if (!msg || !level) {
log_error("%s: partial error message, cannot log", note);
} else {
log_error("%s: %s: %s", note, level, msg);
}
}
/*
* Preparation of welcome message for client connection.
*/
/* add another server parameter packet to cache */
bool add_welcome_parameter(PgPool *pool, const char *key, const char *val)
{
PktBuf *msg = pool->welcome_msg;
if (pool->welcome_msg_ready)
return true;
if (!msg) {
msg = pktbuf_dynamic(128);
if (!msg)
return false;
pool->welcome_msg = msg;
}
/* first packet must be AuthOk */
if (msg->write_pos == 0)
pktbuf_write_AuthenticationOk(msg);
/* if not stored in ->orig_vars, write full packet */
if (!varcache_set(&pool->orig_vars, key, val))
pktbuf_write_ParameterStatus(msg, key, val);
return !msg->failed;
}
/* all parameters processed */
void finish_welcome_msg(PgSocket *server)
{
PgPool *pool = server->pool;
if (pool->welcome_msg_ready)
return;
pool->welcome_msg_ready = true;
}
bool welcome_client(PgSocket *client)
{
int res;
PgPool *pool = client->pool;
const PktBuf *pmsg = pool->welcome_msg;
PktBuf *msg;
slog_noise(client, "P: welcome_client");
/* copy prepared stuff around */
msg = pktbuf_temp();
pktbuf_put_bytes(msg, pmsg->buf, pmsg->write_pos);
/* fill vars */
varcache_fill_unset(&pool->orig_vars, client);
varcache_add_params(msg, &client->vars);
/* give each client its own cancel key */
get_random_bytes(client->cancel_key, 8);
/*
* If pgbouncer peering is enabled we change some of the random bits of the
* cancel key to non random values, otherwise the peering feature cannot be
* implemented in an efficient way. This reduces the randomness of the key
* somewhat, but it still leaves us with 45 bits of randomness. This should
* be enough for all practical attacks to be mitigated (there are still
* ~35 trillion random combinations of these bits).
*/
if (cf_peer_id > 0) {
/*
* The 2nd and 3rd byte represent the peer id. Pgbouncers that are
* peered with this one can forward the request to us by reading this
* peer id when they receive this cancellation.
*/
client->cancel_key[1] = cf_peer_id & 0xFF;
client->cancel_key[2] = (cf_peer_id >> 8) & 0xFF;
/*
* Initially we set the two TTL mask bits to a 1, so that the cancel
* message can be forwarded to peers up to 3 times.
*/
client->cancel_key[7] |= CANCELLATION_TTL_MASK;
}
/*
* The first 32 bits of the cancel_key are considered a PID. Since
* actual PIDs are always positive we clear the sign bit. Most clients
* work fine when receiving a negative number in this PID part, but it
* turned out that pg_basebackup did not. This is fixed in
* pg_basebackup, but to avoid similar future problems with other
* clients we clear the sign bit. See this thread for more details:
* https://www.postgresql.org/message-id/flat/CAGECzQQOGvYfp8ziF4fWQ_o8s2K7ppaoWBQnTmdakn3s-4Z%3D5g%40mail.gmail.com
*/
client->cancel_key[0] &= 0x7F;
pktbuf_write_BackendKeyData(msg, client->cancel_key);
/* finish */
pktbuf_write_ReadyForQuery(msg);
if (msg->failed) {
disconnect_client(client, true, "failed to prepare welcome message");
return false;
}
/* send all together */
res = pktbuf_send_immediate(msg, client);
if (!res) {
disconnect_client(client, true, "failed to send welcome message");
return false;
}
return true;
}
/*
* Password authentication for server
*/
static PgCredentials *get_srv_psw(PgSocket *server)
{
PgDatabase *db = server->pool->db;
PgCredentials *credentials = server->pool->user_credentials;
/* if forced user without password, use userlist psw */
if (!credentials->passwd[0] && db->forced_user_credentials) {
PgCredentials *c2 = find_global_credentials(credentials->name);
if (c2)
return c2;
}
return credentials;
}
/* actual packet send */
static bool send_password(PgSocket *server, const char *enc_psw)
{
bool res;
SEND_PasswordMessage(res, server, enc_psw);
return res;
}
static bool login_clear_psw(PgSocket *server)
{
PgCredentials *credentials = get_srv_psw(server);
slog_debug(server, "P: send clear password");
return send_password(server, credentials->passwd);
}
static bool login_md5_psw(PgSocket *server, const uint8_t *salt)
{
char txt[MD5_PASSWD_LEN + 1], *src;
PgCredentials *credentials = get_srv_psw(server);
slog_debug(server, "P: send md5 password");
switch (get_password_type(credentials->passwd)) {
case PASSWORD_TYPE_PLAINTEXT:
if (!pg_md5_encrypt(credentials->passwd, credentials->name, strlen(credentials->name), txt))
return false;
src = txt + 3;
break;
case PASSWORD_TYPE_MD5:
src = credentials->passwd + 3;
break;
default:
slog_error(server, "cannot do MD5 authentication: wrong password type");
kill_pool_logins(server->pool, NULL, "server login failed: wrong password type");
return false;
}
if (!pg_md5_encrypt(src, (char *)salt, 4, txt))
return false;
return send_password(server, txt);
}
static bool login_scram_sha_256(PgSocket *server)
{
PgCredentials *credentials = get_srv_psw(server);
bool res;
char *client_first_message = NULL;
switch (get_password_type(credentials->passwd)) {
case PASSWORD_TYPE_PLAINTEXT:
/* ok */
break;
case PASSWORD_TYPE_SCRAM_SHA_256:
if (!credentials->has_scram_keys) {
slog_error(server, "cannot do SCRAM authentication: password is SCRAM secret but client authentication did not provide SCRAM keys");
kill_pool_logins(server->pool, NULL, "server login failed: wrong password type");
return false;
}
break;
default:
slog_error(server, "cannot do SCRAM authentication: wrong password type");
kill_pool_logins(server->pool, NULL, "server login failed: wrong password type");
return false;
}
if (server->scram_state.client_nonce) {
slog_error(server, "protocol error: duplicate AuthenticationSASL message from server");
return false;
}
client_first_message = build_client_first_message(&server->scram_state);
if (!client_first_message)
return false;
slog_debug(server, "SCRAM client-first-message = \"%s\"", client_first_message);
slog_debug(server, "P: send SASLInitialResponse");
SEND_SASLInitialResponseMessage(res, server, "SCRAM-SHA-256", client_first_message);
free(client_first_message);
return res;
}
static bool login_scram_sha_256_cont(PgSocket *server, unsigned datalen, const uint8_t *data)
{
PgCredentials *credentials = get_srv_psw(server);
char *ibuf = NULL;
char *input;
char *server_nonce;
int saltlen;
char *salt = NULL;
int iterations;
bool res;
char *client_final_message = NULL;
if (!server->scram_state.client_nonce) {
slog_error(server, "protocol error: AuthenticationSASLContinue without prior AuthenticationSASL");
return false;
}
if (server->scram_state.server_first_message) {
slog_error(server, "SCRAM exchange protocol error: received second AuthenticationSASLContinue");
return false;
}
ibuf = malloc(datalen + 1);
if (ibuf == NULL)
return false;
memcpy(ibuf, data, datalen);
ibuf[datalen] = '\0';
input = ibuf;
slog_debug(server, "SCRAM server-first-message = \"%s\"", input);
if (!read_server_first_message(server, input,
&server_nonce, &salt, &saltlen, &iterations))
goto failed;
client_final_message = build_client_final_message(&server->scram_state,
credentials, server_nonce,
salt, saltlen, iterations);
free(salt);
free(ibuf);
slog_debug(server, "SCRAM client-final-message = \"%s\"", client_final_message);
slog_debug(server, "P: send SASLResponse");
SEND_SASLResponseMessage(res, server, client_final_message);
free(client_final_message);
return res;
failed:
free(salt);
free(ibuf);
free(client_final_message);
return false;
}
static bool login_scram_sha_256_final(PgSocket *server, unsigned datalen, const uint8_t *data)
{
PgCredentials *credentials = get_srv_psw(server);
char *ibuf = NULL;
char *input;
char ServerSignature[SHA256_DIGEST_LENGTH];
if (!server->scram_state.server_first_message) {
slog_error(server, "protocol error: AuthenticationSASLFinal without prior AuthenticationSASLContinue");
return false;
}
ibuf = malloc(datalen + 1);
if (ibuf == NULL)
return false;
memcpy(ibuf, data, datalen);
ibuf[datalen] = '\0';
input = ibuf;
slog_debug(server, "SCRAM server-final-message = \"%s\"", input);
if (!read_server_final_message(server, input, ServerSignature))
goto failed;
if (!verify_server_signature(&server->scram_state, credentials, ServerSignature)) {
slog_error(server, "invalid server signature");
kill_pool_logins(server->pool, NULL, "server login failed: invalid server signature");
goto failed;
}
free(ibuf);
return true;
failed:
free(ibuf);
return false;
}
/* answer server authentication request */
bool answer_authreq(PgSocket *server, PktHdr *pkt)
{
uint32_t cmd;
const uint8_t *salt;
bool res = false;
/* authreq body must contain 32bit cmd */
if (mbuf_avail_for_read(&pkt->data) < 4)
return false;
if (!mbuf_get_uint32be(&pkt->data, &cmd))
return false;
switch (cmd) {
case AUTH_REQ_OK:
slog_debug(server, "S: auth ok");
res = true;
break;
case AUTH_REQ_PASSWORD:
slog_debug(server, "S: req cleartext password");
res = login_clear_psw(server);
break;
case AUTH_REQ_MD5:
slog_debug(server, "S: req md5-crypted psw");
if (!mbuf_get_bytes(&pkt->data, 4, &salt))
return false;
res = login_md5_psw(server, salt);
break;
case AUTH_REQ_SASL:
{
bool selected_mechanism = false;
slog_debug(server, "S: req SASL");
do {
const char *mech;
if (!mbuf_get_string(&pkt->data, &mech))
return false;
if (!mech[0])
break;
slog_debug(server, "S: SASL advertised mechanism: %s", mech);
if (strcmp(mech, "SCRAM-SHA-256") == 0)
selected_mechanism = true;
} while (!selected_mechanism);
if (!selected_mechanism) {
slog_error(server, "none of the server's SASL authentication mechanisms are supported");
kill_pool_logins(server->pool, NULL, "server login failed: none of the server's SASL authentication mechanisms are supported");
} else {
res = login_scram_sha_256(server);
}
break;
}
case AUTH_REQ_SASL_CONT:
{
unsigned len;
const uint8_t *data;
slog_debug(server, "S: SASL cont");
len = mbuf_avail_for_read(&pkt->data);
if (!mbuf_get_bytes(&pkt->data, len, &data))
return false;
res = login_scram_sha_256_cont(server, len, data);
break;
}
case AUTH_REQ_SASL_FIN:
{
unsigned len;
const uint8_t *data;
slog_debug(server, "S: SASL final");
len = mbuf_avail_for_read(&pkt->data);
if (!mbuf_get_bytes(&pkt->data, len, &data))
return false;
res = login_scram_sha_256_final(server, len, data);
free_scram_state(&server->scram_state);
break;
}
default:
slog_error(server, "unknown/unsupported auth method: %u", cmd);
res = false;
break;
}
return res;
}
bool send_startup_packet(PgSocket *server)
{
PgPool *pool = server->pool;
PgDatabase *db = pool->db;
const char *username = server->pool->user_credentials->name;
PktBuf *pkt = pktbuf_temp();
PgSocket *client = NULL;
pktbuf_start_packet(pkt, PKT_STARTUP_V3);
pktbuf_put_bytes(pkt, db->startup_params->buf, db->startup_params->write_pos);
/*
* If the next client in the list is a replication connection, we need
* to do some special stuff for it.
*/
client = first_socket(&pool->waiting_client_list);
if (client && client->replication && !sending_auth_query(client)) {
server->replication = client->replication;
pktbuf_put_string(pkt, "replication");
slog_debug(server, "send_startup_packet: creating replication connection");
pktbuf_put_string(pkt, replication_type_parameters[server->replication]);
/*
* For a replication connection we apply the varcache in the
* startup instead of through SET commands after connecting.
* The main reason to do so is because physical replication
* connections don't allow SET commands. A second reason is
* because it allows us to skip running the SET logic
* completely, which normally requires waiting on multiple
* server responses. This SET logic is normally executed in the
* codepath where we link the client to the server
* (find_server), but because we link the client here already
* we don't run that code for replication connections. Adding
* the varcache parameters to the startup message allows us to
* skip the dance that involves sending Query packets and
* waiting for responses.
*/
varcache_apply_startup(pkt, client);
if (client->startup_options) {
pktbuf_put_string(pkt, "options");
pktbuf_put_string(pkt, client->startup_options);
}
}
pktbuf_put_string(pkt, "user");
pktbuf_put_string(pkt, username);
pktbuf_put_string(pkt, ""); /* terminator required in StartupMessage */
pktbuf_finish_packet(pkt);
if (!pktbuf_send_immediate(pkt, server)) {
return false;
}
if (server->replication) {
/*
* We link replication connections to a client directly when they are
* created. One reason for is because the startup parameters need to be
* forwarded, because physical replication connections don't allow SET
* commands. Another reason is so that we don't need a separate state.
*/
client->link = server;
server->link = client;
}
return true;
}
bool send_sslreq_packet(PgSocket *server)
{
int res;
SEND_wrap(16, pktbuf_write_SSLRequest, res, server);
return res;
}
/*
* decode DataRow packet (opposite of pktbuf_write_DataRow)
*
* tupdesc keys:
* 'i' - int4
* 'q' - int8
* 's' - text to string
* 'b' - bytea to bytes (result is malloced)
*/
int scan_text_result(struct MBuf *pkt, const char *tupdesc, ...)
{
uint16_t ncol;
unsigned asked;
va_list ap;
asked = strlen(tupdesc);
if (!mbuf_get_uint16be(pkt, &ncol))
return -1;
va_start(ap, tupdesc);
for (unsigned i = 0; i < asked; i++) {
const char *val = NULL;
uint32_t len;
if (i < ncol) {
if (!mbuf_get_uint32be(pkt, &len)) {
goto failed;
}
if ((int32_t)len < 0) {
val = NULL;
} else {
if (!mbuf_get_chars(pkt, len, &val)) {
goto failed;
}
}
/* hack to zero-terminate the result */
if (val) {
char *xval = (char *)val - 1;
memmove(xval, val, len);
xval[len] = 0;
val = xval;
}
} else {
/* tuple was shorter than requested */
val = NULL;
len = -1;
}
switch (tupdesc[i]) {
case 'i': {
int *int_p;
int_p = va_arg(ap, int *);
*int_p = val ? atoi(val) : 0;
break;
}
case 'q': {
uint64_t *long_p;
long_p = va_arg(ap, uint64_t *);
*long_p = val ? atoll(val) : 0;
break;
}
case 's': {
const char **str_p;
str_p = va_arg(ap, const char **);
*str_p = val;
break;
}
case 'b': {
int *len_p = va_arg(ap, int *);
uint8_t **bytes_p = va_arg(ap, uint8_t **);
if (val) {
int newlen;
if (strncmp(val, "\\x", 2) != 0) {
log_warning("invalid bytea value");
goto failed;
}
newlen = (len - 2) / 2;
*len_p = newlen;
*bytes_p = malloc(newlen);
if (!(*bytes_p)) {
goto failed;
}
for (int j = 0; j < newlen; j++) {
unsigned int b;
sscanf(val + 2 + 2 * j, "%2x", &b);
(*bytes_p)[j] = b;
}
} else {
*len_p = -1;
*bytes_p = NULL;
}
break;
}
default:
fatal("bad tupdesc: %s", tupdesc);
}
}
va_end(ap);
return ncol;
failed:
va_end(ap);
return -1;
}
pgbouncer-1.24.1/src/pam.c 0000644 0001750 0000000 00000027670 14777762222 012233 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* PAM authentication support.
*/
#include "bouncer.h"
#ifdef HAVE_PAM
#include
#include
/* The request is waiting in the queue or being authenticated */
#define PAM_STATUS_IN_PROGRESS 1
/* The request was successfully authenticated */
#define PAM_STATUS_SUCCESS 2
/* The request failed authentication */
#define PAM_STATUS_FAILED 3
/*
* How many microseconds to sleep between calls to pam_poll in
* pam_auth_begin when the queue is full.
* Default is 100 milliseconds.
*/
#define PAM_QUEUE_WAIT_SLEEP_MCS (100*1000)
struct pam_auth_request {
/* The socket we check authentication for */
PgSocket *client;
/* CHECKME: The socket can be closed and reused while the request is waiting
* in the queue. Thus we need something to check the socket validity, and
* combination of its state and connect_time seems to be the good one.
*/
usec_t connect_time;
/* Same as in client->remote_addr.
* We want to minimize synchronization between the authentication thread and
* the rest of pgbouncer, so the username and remote_addr are explicitly stored here.
*/
PgAddr remote_addr;
/* The request status, one of the PAM_STATUS_* constants */
int status;
/* The username (same as in client->login_user_credentials->name).
* See the comment for remote_addr.
*/
char username[MAX_USERNAME];
/* password we should check for validity together with the socket's username */
char password[MAX_PASSWORD];
};
/*
* All incoming requests are kept in a queue which is implemented using a ring buffer.
* Such structure allows to avoid memory reallocation thus minimizing amount of
* synchronization to be done between threads.
*
* pam_first_taken_slot points to the first element in the queue;
* pam_first_free_slot points to the next slot after the last element in the queue.
*
* if pam_first_taken_slot == pam_first_free_slot then the queue is considered empty;
*
*/
volatile int pam_first_taken_slot;
volatile int pam_first_free_slot;
struct pam_auth_request pam_auth_queue[PAM_REQUEST_QUEUE_SIZE];
pthread_t pam_worker_thread;
/*
* Mutex serializes access to the queue's tail when we add new requests or
* check that we reach the end of the queue in the worker thread.
*
* Head and tail are modified only in the main thread. In theory, being sure that they
* are properly aligned we can access them directly without any risk for data races.
* Practically, it is better to secure them anyway to increase overall stability and
* provide faster notification of new requests via the condition variable.
*/
pthread_mutex_t pam_queue_tail_mutex;
pthread_cond_t pam_data_available;
/* Forward declarations */
static void * pam_auth_worker(void *arg);
static bool is_valid_socket(const struct pam_auth_request *request);
static void pam_auth_finish(struct pam_auth_request *request);
static bool pam_check_passwd(struct pam_auth_request *request);
/*
* Initialize PAM subsystem.
*/
void pam_init(void)
{
int rc;
pam_first_taken_slot = 0;
pam_first_free_slot = 0;
rc = pthread_mutex_init(&pam_queue_tail_mutex, NULL);
if (rc != 0) {
die("failed to initialize a mutex: %s", strerror(errno));
}
rc = pthread_cond_init(&pam_data_available, NULL);
if (rc != 0) {
die("failed to initialize a condition variable: %s", strerror(errno));
}
rc = pthread_create(&pam_worker_thread, NULL, &pam_auth_worker, NULL);
if (rc != 0) {
die("failed to create the authentication thread: %s", strerror(errno));
}
}
/*
* Initiate the authentication request using PAM. The request result will be
* available during next calls to pam_poll(). The function might block if the
* request queue is full until there are free slots available.
* The function is called only from the main thread.
*/
void pam_auth_begin(PgSocket *client, const char *passwd)
{
int next_free_slot = (pam_first_free_slot + 1) % PAM_REQUEST_QUEUE_SIZE;
struct pam_auth_request *request;
slog_debug(
client,
"pam_auth_begin(): pam_first_taken_slot=%d, pam_first_free_slot=%d",
pam_first_taken_slot, pam_first_free_slot);
client->wait_for_auth = true;
/* Check that we have free slots in the queue, and if no
* then block until one is available.
*/
if (next_free_slot == pam_first_taken_slot)
slog_debug(client, "PAM queue is full, waiting");
while (next_free_slot == pam_first_taken_slot) {
if (pam_poll() == 0) {
/* Sleep a bit between consequent queue checks to avoid consuming too much CPU */
usleep(PAM_QUEUE_WAIT_SLEEP_MCS);
}
}
pthread_mutex_lock(&pam_queue_tail_mutex);
request = &pam_auth_queue[pam_first_free_slot];
request->client = client;
request->connect_time = client->connect_time;
request->status = PAM_STATUS_IN_PROGRESS;
memcpy(&request->remote_addr, &client->remote_addr, sizeof(client->remote_addr));
safe_strcpy(request->username, client->login_user_credentials->name, MAX_USERNAME);
safe_strcpy(request->password, passwd, MAX_PASSWORD);
pam_first_free_slot = next_free_slot;
pthread_mutex_unlock(&pam_queue_tail_mutex);
pthread_cond_signal(&pam_data_available);
}
/*
* Checks for completed auth requests, returns amount of requests handled.
* The function is called only from the main thread.
*/
int pam_poll(void)
{
struct pam_auth_request *request;
int count = 0;
while (pam_first_taken_slot != pam_first_free_slot) {
request = &pam_auth_queue[pam_first_taken_slot];
if (request->status == PAM_STATUS_IN_PROGRESS) {
/* When still-in-progress slot is found there is no need to continue
* the loop since all further requests will be in progress too.
*/
break;
}
if (is_valid_socket(request)) {
pam_auth_finish(request);
}
count++;
pam_first_taken_slot = (pam_first_taken_slot + 1) % PAM_REQUEST_QUEUE_SIZE;
}
return count;
}
/*
* The authentication thread function.
* Performs scanning the queue for new requests and calling PAM for them.
*/
static void * pam_auth_worker(void *arg)
{
int current_slot = pam_first_taken_slot;
struct pam_auth_request *request;
while (true) {
/* Wait for new data in the queue */
pthread_mutex_lock(&pam_queue_tail_mutex);
while (current_slot == pam_first_free_slot) {
pthread_cond_wait(&pam_data_available, &pam_queue_tail_mutex);
}
pthread_mutex_unlock(&pam_queue_tail_mutex);
log_debug("pam_auth_worker(): processing slot %d", current_slot);
/* We have at least one request in the queue */
request = &pam_auth_queue[current_slot];
current_slot = (current_slot + 1) % PAM_REQUEST_QUEUE_SIZE;
/* If the socket is already in the wrong state or reused then ignore it.
* This check is not safe and should not be trusted (the socket state
* might change exactly after it), but it helps to quickly filter out invalid
* sockets and thus save some time.
*/
if (!is_valid_socket(request)) {
log_debug("pam_auth_worker(): invalid socket in slot %d", current_slot);
request->status = PAM_STATUS_FAILED;
continue;
}
if (pam_check_passwd(request)) {
request->status = PAM_STATUS_SUCCESS;
} else {
request->status = PAM_STATUS_FAILED;
}
log_debug("pam_auth_worker(): authentication completed, status=%d", request->status);
}
return NULL;
}
/*
* Checks that the socket is still valid to be processed.
* By validity we mean that it is still waiting in the login phase
* and was not reused for other connections.
*/
static bool is_valid_socket(const struct pam_auth_request *request)
{
if (request->client->state != CL_LOGIN || request->client->connect_time != request->connect_time)
return false;
return true;
}
/*
* Finishes the handshake after successful or unsuccessful authentication.
* The function is only called from the main thread.
*/
static void pam_auth_finish(struct pam_auth_request *request)
{
PgSocket *client = request->client;
bool authenticated = (request->status == PAM_STATUS_SUCCESS);
if (authenticated) {
safe_strcpy(client->login_user_credentials->passwd, request->password, sizeof(client->login_user_credentials->passwd));
sbuf_continue(&client->sbuf);
} else {
disconnect_client(client, true, "PAM authentication failed");
}
}
static int pam_conversation(int msgc,
const struct pam_message **msgv,
struct pam_response **rspv,
void *authdata)
{
struct pam_auth_request *request = (struct pam_auth_request *)authdata;
int i, rc;
if (msgc < 1 || msgv == NULL || request == NULL) {
log_debug(
"pam_conversation(): wrong input, msgc=%d, msgv=%p, authdata=%p",
msgc, msgv, authdata);
return PAM_CONV_ERR;
}
/* Allocate and fill with zeroes an array of responses.
* By filling with zeroes we automatically set resp_retcode to
* zero and simplify freeing resp on errors.
*/
*rspv = malloc(msgc * sizeof(struct pam_response));
if (*rspv == NULL) {
log_warning("pam_conversation(): not enough memory for responses");
return PAM_CONV_ERR;
}
memset(*rspv, 0, msgc * sizeof(struct pam_response));
rc = PAM_SUCCESS;
for (i = 0; i < msgc; i++) {
if (rc != PAM_SUCCESS)
break;
switch (msgv[i]->msg_style) {
case PAM_PROMPT_ECHO_OFF:
(*rspv)[i].resp = strdup(request->password);
if ((*rspv)[i].resp == NULL) {
log_warning("pam_conversation(): not enough memory for password");
rc = PAM_CONV_ERR;
}
break;
case PAM_ERROR_MSG:
log_warning(
"pam_conversation(): PAM error: %s",
msgv[i]->msg);
break;
default:
log_debug(
"pam_conversation(): unhandled message, msg_style=%d",
msgv[i]->msg_style);
break;
}
}
if (rc != PAM_SUCCESS) {
for (i = 0; i < msgc; i++)
free((*rspv)[i].resp);
free(*rspv);
}
return rc;
}
static bool pam_check_passwd(struct pam_auth_request *request)
{
pam_handle_t *hpam;
char raddr[PGADDR_BUF];
int rc;
struct pam_conv pam_conv = {
.conv = pam_conversation,
.appdata_ptr = request
};
rc = pam_start(PGBOUNCER_PAM_SERVICE, request->username, &pam_conv, &hpam);
if (rc != PAM_SUCCESS) {
log_warning("pam_start() failed: %s", pam_strerror(NULL, rc));
return false;
}
/* Set rhost too in case if some PAM modules want to take it into account (and for logging too) */
pga_ntop(&request->remote_addr, raddr, sizeof(raddr));
rc = pam_set_item(hpam, PAM_RHOST, raddr);
if (rc != PAM_SUCCESS) {
log_warning("pam_set_item(): can't set PAM_RHOST to '%s'", raddr);
pam_end(hpam, rc);
return false;
}
/* Here the authentication is performed */
rc = pam_authenticate(hpam, PAM_SILENT);
if (rc != PAM_SUCCESS) {
log_warning("pam_authenticate() failed: %s", pam_strerror(hpam, rc));
pam_end(hpam, rc);
return false;
}
/* And here we check that the account is not expired, verifies access hours, etc */
rc = pam_acct_mgmt(hpam, PAM_SILENT);
if (rc != PAM_SUCCESS) {
log_warning("pam_acct_mgmt() failed: %s", pam_strerror(hpam, rc));
pam_end(hpam, rc);
return false;
}
rc = pam_end(hpam, rc);
if (rc != PAM_SUCCESS) {
log_warning("pam_end() failed: %s", pam_strerror(hpam, rc));
}
return true;
}
#else /* !HAVE_PAM */
/* If PAM is not supported then this dummy functions is used which always rejects passwords */
void pam_init(void)
{
/* do nothing */
}
void pam_auth_begin(PgSocket *client, const char *passwd)
{
die("PAM authentication is not supported");
}
int pam_poll(void)
{
/* do nothing */
return 0;
}
#endif
pgbouncer-1.24.1/src/prepare.c 0000644 0001750 0000000 00000056624 14777762222 013115 0000000 0000000 /*
* Contains code for handling prepared statement related packets.
*
* The main entrypoints are the handle_xxx_command functions. They do the
* translation from prepared statement names of the client to the equivalent
* prepared statement name on the server.
*/
#include "bouncer.h"
#include
#include
#include
static uint64_t next_unique_query_id;
/*
* Track allocation failures in uthash, so that we can fail more gracefully
* than a full process crash. Instead we will just disconnect the client and
* server.
*/
static bool uthash_alloc_failed;
#undef uthash_nonfatal_oom
#define uthash_nonfatal_oom(elt) uthash_alloc_failed = true
/*
* Like uthash HASH_DELETE, but doesn't remove item from hash table just
* unlink element from the doubly-linked-list.
*/
#define HASH_UNLINK(hh, head, delptr) \
do { \
struct UT_hash_handle *_hd_hh_del = &(delptr)->hh; \
if (_hd_hh_del->prev != NULL) { \
HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->prev)->next = _hd_hh_del->next; \
} else { \
DECLTYPE_ASSIGN(head, _hd_hh_del->next); \
} \
if (_hd_hh_del->next != NULL) { \
HH_FROM_ELMT((head)->hh.tbl, _hd_hh_del->next)->prev = _hd_hh_del->prev; \
} else { \
_hd_hh_del->tbl->tail = HH_FROM_ELMT(_hd_hh_del->tbl, _hd_hh_del->prev); \
} \
} while (0)
#define HASH_FIND_UINT64(head, findint, out) \
HASH_FIND(hh, head, findint, sizeof(uint64_t), out)
#define HASH_ADD_UINT64(head, intfield, add) \
HASH_ADD(hh, head, intfield, sizeof(uint64_t), add)
/*
* Benchmarking showed that HASH_BER is one of the fastest hash functions for our
* usecases
*/
#undef HASH_FUNCTION
#define HASH_FUNCTION HASH_BER
/*
* Converts a PgParsePacket to a malloc-ed PgPreparedStatement. The
* PgPreparedStatement can be stored in the global prepared statement cache.
*/
static PgPreparedStatement *create_prepared_statement(PgParsePacket *pkt)
{
PgPreparedStatement *ps = malloc(
sizeof(PgPreparedStatement)
+ pkt->query_and_parameters_len);
if (ps == NULL)
return NULL;
next_unique_query_id += 1;
ps->query_id = next_unique_query_id;
ps->use_count = 0;
ps->query_and_parameters_len = pkt->query_and_parameters_len;
memcpy(ps->query_and_parameters,
pkt->query_and_parameters,
pkt->query_and_parameters_len);
return ps;
}
/*
* Creates a PgClientPreparedStatement from a PgPreparedStatement. The
* PgClientPreparedStatement can be stored inside the client its prepared
* statement hashmap.
*/
static PgClientPreparedStatement *create_client_prepared_statement(char const *name, PgPreparedStatement *ps)
{
size_t name_len = strlen(name) + 1;
PgClientPreparedStatement *client_ps = malloc(
sizeof(PgClientPreparedStatement) + name_len);
if (client_ps == NULL)
return NULL;
memcpy(client_ps->stmt_name, name, name_len);
client_ps->ps = ps;
ps->use_count += 1;
return client_ps;
}
/*
* Creates a PgServerPreparedStatement from a PgPreparedStatement. The
* PgClientPreparedStatement can be stored inside the server its prepared
* statement hashmap.
*/
static PgServerPreparedStatement *create_server_prepared_statement(PgPreparedStatement *ps)
{
PgServerPreparedStatement *server_ps = slab_alloc(server_prepared_statement_cache);
if (server_ps == NULL)
return NULL;
server_ps->ps = ps;
server_ps->query_id = ps->query_id;
ps->use_count += 1;
return server_ps;
}
/*
* Gets a prepared statement from the global cache. If it doesn't exist yet, it
* is created and added.
*/
static PgPreparedStatement *get_prepared_statement(PgParsePacket *pkt, bool *found)
{
PgPreparedStatement *ps = NULL;
HASH_FIND(hh,
prepared_statements,
pkt->query_and_parameters,
pkt->query_and_parameters_len,
ps);
if (ps != NULL) {
*found = true;
return ps;
}
ps = create_prepared_statement(pkt);
if (ps == NULL)
return NULL;
HASH_ADD(hh,
prepared_statements,
query_and_parameters,
ps->query_and_parameters_len,
ps);
if (uthash_alloc_failed) {
uthash_alloc_failed = false;
free(ps);
return NULL;
}
ps->stmt_name_len = (uint8_t)snprintf(
ps->stmt_name,
sizeof ps->stmt_name,
PREPARED_STMT_NAME_FORMAT,
ps->query_id);
*found = false;
return ps;
}
/*
* This is equivalent of sbuf_prepare_skip() but it also handles the case where
* we used our special callbacke packet buffering logic.
*/
static void skip_possibly_completely_buffered_packet(PgSocket *client, PktHdr *pkt)
{
/*
* Now we need to make sure the original packet is not sent to the server.
*/
if (client->packet_cb_state.flag == CB_HANDLE_COMPLETE_PACKET) {
/*
* If we used special callback packet buffering, then we don't need to
* do anything. Because the callback already "consumed" the data from
* the SBuf.
*/
return;
}
/*
* If we used the regular packet buffering, then we do still need to tell
* SBuf that we handled the packet.
*/
sbuf_prepare_skip(&client->sbuf, pkt->len);
}
/*
* Unregister prepared statement at server
*/
void free_server_prepared_statement(PgServerPreparedStatement *server_ps)
{
if (server_ps == NULL)
return;
if (--server_ps->ps->use_count == 0) {
HASH_DEL(prepared_statements, server_ps->ps);
free(server_ps->ps);
}
slab_free(server_prepared_statement_cache, server_ps);
}
/*
* Unregister prepared statement from the server its cache.
*/
void unregister_prepared_statement(PgSocket *server, uint64_t query_id)
{
PgServerPreparedStatement *server_ps;
HASH_FIND_UINT64(server->server_prepared_statements, &query_id, server_ps);
if (server_ps) {
HASH_DEL(server->server_prepared_statements, server_ps);
free_server_prepared_statement(server_ps);
}
}
/*
* Add the prepared statement to the server its cache.
*/
bool add_prepared_statement(PgSocket *server, PgServerPreparedStatement *server_ps)
{
HASH_ADD_UINT64(server->server_prepared_statements, query_id, server_ps);
if (uthash_alloc_failed) {
uthash_alloc_failed = false;
return false;
}
return true;
}
/*
* Register prepared statement in the server its cache. If the cache is full, we
* evict the least recently used query/queries before adding a new one.
*
* NOTE: Before calling this a matching outstanding request should have been
* added to the server its queue.
*/
static bool register_prepared_statement(PgSocket *client, PgSocket *server, PgServerPreparedStatement *server_ps)
{
struct PgServerPreparedStatement *current, *tmp;
OutstandingRequest *outstanding_request;
struct List *el;
int res;
Assert(server_ps);
/*
* Now we need to link the outstanding request to the server_ps, so
* that it can be unregistered if the request fails.
*/
el = statlist_last(&server->outstanding_requests);
Assert(el);
outstanding_request = container_of(el, OutstandingRequest, node);
Assert(outstanding_request->type == PqMsg_Parse);
Assert(outstanding_request->server_ps_query_id == 0);
outstanding_request->server_ps_query_id = server_ps->ps->query_id;
if (!add_prepared_statement(server, server_ps))
return false;
slog_noise(server, "prepared statement " PREPARED_STMT_NAME_FORMAT " added to server cache, %d cached items",
server_ps->ps->query_id,
HASH_COUNT(server->server_prepared_statements));
/*
* Ensure the cache is not larger than the intended size. To do so we
* can simply remove the first N items from the hash table, because we
* maintain its order as an LRU. (see
* ensure_statement_is_prepared_on_server for details)
*/
HASH_ITER(hh, server->server_prepared_statements, current, tmp) {
if (HASH_COUNT(server->server_prepared_statements) <= (unsigned int)cf_max_prepared_statements) {
break;
}
QUEUE_CloseStmt(res, client, server, current->ps->stmt_name);
if (!res) {
return false;
}
if (!add_outstanding_request(client, PqMsg_Close, RA_SKIP)) {
return false;
}
el = statlist_last(&server->outstanding_requests);
Assert(el);
outstanding_request = container_of(el, OutstandingRequest, node);
outstanding_request->server_ps = current;
/*
* We remove the statement from the cache, but we don't
* free the memory yet. Because we might still need to
* add it back if the Close fails.
*/
slog_noise(server, "prepared statement '%s' deleted from server cache", current->ps->stmt_name);
HASH_DEL(server->server_prepared_statements, current);
}
return true;
}
/*
* Handle a Parse packet for a named prepared statement
*
* This adds the prepared statement to the client's hash of prepared statements.
* If the exact same prepared statement (query + argument types) was previously
* prepared by another client on this server, then we don't actually send
* anything to the server but instead reuse that one. Otherwise we prepare it on
* the server and add it to the server's hash of prepared statements.
*/
bool handle_parse_command(PgSocket *client, PktHdr *pkt)
{
PgSocket *server = client->link;
PgParsePacket pp;
PgServerPreparedStatement *server_ps = NULL;
PgClientPreparedStatement *client_ps = NULL;
PgPreparedStatement *ps;
PktBuf *buf;
bool found = false;
Assert(server);
if (!unmarshall_parse_packet(client, pkt, &pp))
return false;
HASH_FIND_STR(client->client_prepared_statements, pp.name, client_ps);
if (client_ps) {
slog_error(client, "prepared statement '%s' was already prepared", pp.name);
/*
* It would be nice if we would not completely close the client
* connection here, but instead only sent an error after which
* the client could continue. This is what Postgres does.
* However, doing that in a way which works with query
* pipelining is not trivial. So for now we take the easy way
* out and simply close the connection. This is no problem for
* most clients anyway, since they will only issue Parse for
* with currently unused names.
*/
disconnect_client(client, true, "prepared statement name is already in use");
return false;
}
/* update stats */
client->pool->stats.ps_client_parse_count++;
/* Lookup query in global hash */
ps = get_prepared_statement(&pp, &found);
if (ps == NULL)
goto oom;
/* Register statement on client */
client_ps = create_client_prepared_statement(pp.name, ps);
if (client_ps == NULL)
goto oom;
HASH_ADD_STR(client->client_prepared_statements, stmt_name, client_ps);
if (uthash_alloc_failed) {
uthash_alloc_failed = false;
goto oom;
}
if (found) {
/* Such query was already prepared */
HASH_FIND_UINT64(server->server_prepared_statements, &ps->query_id, server_ps);
if (server_ps) {
/* Statement was already prepared on this server, do not forward packet */
slog_debug(client, "handle_parse_command: mapping statement '%s' to '%s' (query '%s')",
client_ps->stmt_name, ps->stmt_name, ps->query_and_parameters);
/*
* Insert an entry into the request queue, so we can send a fake
* response to the client at the point where they expect it.
*/
if (!add_outstanding_request(client, PqMsg_Parse, RA_FAKE))
goto oom;
goto success;
}
}
/* Statement was not prepared on this server, sent modified P packet */
slog_debug(client, "handle_parse_command: creating mapping for statement '%s' to '%s' (query '%s')",
client_ps->stmt_name, ps->stmt_name, ps->query_and_parameters);
buf = pktbuf_temp();
pktbuf_write_Parse(buf, ps->stmt_name, ps->query_and_parameters, ps->query_and_parameters_len);
if (!sbuf_queue_packet(&client->sbuf, &server->sbuf, buf))
goto oom;
/* update stats */
client->pool->stats.ps_server_parse_count++;
/*
* Track the Parse command that we send to server and forward the response
* to the client, because they expect one.
*/
if (!add_outstanding_request(client, PqMsg_Parse, RA_FORWARD))
goto oom;
/* Register statement on server */
server_ps = create_server_prepared_statement(ps);
if (!server_ps)
goto oom;
if (!register_prepared_statement(client, server, server_ps))
goto oom;
success:
skip_possibly_completely_buffered_packet(client, pkt);
return true;
oom:
free(client_ps);
free_server_prepared_statement(server_ps);
disconnect_client(client, true, "out of memory");
/*
* We also disconnect the server, because we probably messed with its state
* at this prepared statement state at this point. And rolling that back is
* hard.
*/
disconnect_server(client->link, true, "out of memory");
return false;
}
/*
* Get the given prepared statement from the client hash map. This returns NULL
* and closes the client connection if no prepared statement with this name
* could not be found.
*/
static PgClientPreparedStatement *get_client_prepared_statement(PgSocket *client, const char *name)
{
PgClientPreparedStatement *client_ps;
HASH_FIND_STR(client->client_prepared_statements, name, client_ps);
if (!client_ps) {
slog_error(client, "prepared statement '%s' not found", name);
/*
* It would be nice if we would not completely close the client
* connection here, but instead only sent an error after which
* the client could continue. This is what Postgres does.
* However, doing that in a way which works with query
* pipelining is not trivial. So for now we take the easy way
* out and simply close the connection. This is no problem for
* most clients anyway, since they will only issue
* Bind/Describe for prepared statements that actually exist.
*/
disconnect_client(client, true, "prepared statement did not exist");
}
return client_ps;
}
/*
* Prepare the given prepared statement on the server, if it isn't prepared
* there yet. If it's already prepared on the server this call is essentially a
* no-op, except that we mark the prepared statement as used in the LRU cache
* of the server.
*
* This returns false if it cannot allocate any needed memory.
*/
static bool ensure_statement_is_prepared_on_server(PgSocket *server, PgPreparedStatement *ps)
{
PgSocket *client = server->link;
PgServerPreparedStatement *server_ps = NULL;
PktBuf *buf;
HASH_FIND_UINT64(server->server_prepared_statements, &ps->query_id, server_ps);
if (server_ps) {
/*
* The statement is already prepared. Move it to the start of
* the server its LRU double-linked list, except if there's
* only one statement prepared (because then it's already at
* the start by definition).
*/
if (HASH_COUNT(server->server_prepared_statements) != 1) {
HASH_UNLINK(hh, server->server_prepared_statements, server_ps);
HASH_APPEND_LIST(hh, server->server_prepared_statements, server_ps);
}
return true;
}
/* Statement is not prepared on this link, sent P packet now */
slog_debug(server, "handle_bind_command: prepared statement '%s' (query '%s') not available on server, preparing '%s' before bind",
ps->stmt_name, ps->query_and_parameters, ps->stmt_name);
/* update stats */
client->pool->stats.ps_server_parse_count++;
/*
* Track Parse command that we sent to server. But make sure the client
* does not receive the respective response, because they did not
* actually send a Parse request.
*/
if (!add_outstanding_request(client, PqMsg_Parse, RA_SKIP))
return false;
buf = pktbuf_temp();
pktbuf_write_Parse(buf, ps->stmt_name, ps->query_and_parameters, ps->query_and_parameters_len);
if (!sbuf_queue_packet(&client->sbuf, &server->sbuf, buf))
return false;
/* Register statement on server link */
server_ps = create_server_prepared_statement(ps);
if (!server_ps)
return false;
if (!register_prepared_statement(client, server, server_ps)) {
free_server_prepared_statement(server_ps);
return false;
}
return true;
}
/*
* Handle a Bind packet for a named prepared statement
*
* Rewrites the given Bind packet to use the server-side statement name instead
* of the client-side one. If the statement is not yet prepared on the server,
* then we first send a Parse command to the server for the prepared statement
* in question.
*/
bool handle_bind_command(PgSocket *client, PktHdr *pkt)
{
PgSocket *server = client->link;
PgBindPacket bp;
PgClientPreparedStatement *client_ps = NULL;
PgPreparedStatement *ps;
PktBuf *buf;
int diff;
Assert(server);
if (!unmarshall_bind_packet(client, pkt, &bp))
return false;
/* update stats */
client->pool->stats.ps_bind_count++;
client_ps = get_client_prepared_statement(client, bp.name);
if (!client_ps)
return false;
ps = client_ps->ps;
if (!ensure_statement_is_prepared_on_server(server, ps))
goto oom;
slog_debug(client, "handle_bind_command: mapped statement '%s' (query '%s') to '%s'",
bp.name, ps->query_and_parameters, ps->stmt_name);
/*
* Track the Bind command that we're going send to server and forward
* the response to the client, because they expect one.
*/
if (!add_outstanding_request(client, PqMsg_Bind, RA_FORWARD))
goto oom;
/*
* The Bind packet that we received from the client won't be sent as-is
* to the server. Instead we replace the statement name with our mapped
* name and also change the length if statement name is different
* length. Those are the only changes that we wish to make though, and
* the rest of the packet can be forwarded as is.
*/
diff = strlen(bp.name) - ps->stmt_name_len;
buf = pktbuf_temp();
if (buf == NULL)
goto oom;
pktbuf_put_char(buf, pkt->type);
/*
* the -1 is because the length field does not include type byte, but
* pkt->len does
*/
pktbuf_put_uint32(buf, pkt->len - diff - 1);
pktbuf_put_string(buf, bp.portal);
pktbuf_put_string(buf, ps->stmt_name);
if (client->packet_cb_state.flag == CB_HANDLE_COMPLETE_PACKET) {
/*
* If we used special callback buffering for this packet then
* we need to include all the bytes following the statement
* name, because our SBuf logic considers those already
* consumed by the callback. This is an exceptional case. It
* only happens when the statement name does not fit in
* pkt_buf.
*/
pktbuf_put_bytes(buf, pkt->data.data + pkt->data.read_pos,
pkt->data.write_pos - pkt->data.read_pos);
if (!sbuf_queue_packet(&client->sbuf, &server->sbuf, buf))
goto oom;
return true;
}
/*
* If we didn't use special callback buffering then we tell SBuf to
* skip over all the bytes up to and including the statement name. But
* for all the bytes after the statement name we use normal packet
* forwarding logic. The reason for this is that our normal packet
* forwarding logic is more efficient at sending data than the
* sbuf_queue_packet logic, especially for large amounts of data. And
* since the data after the statement name include the arguments to the
* prepared statement, the remaining amount of data can be quite large.
*/
if (!sbuf_queue_packet(&client->sbuf, &server->sbuf, buf))
goto oom;
sbuf_prepare_skip_then_send_leftover(&client->sbuf, &server->sbuf, pkt->data.read_pos, pkt->len);
return true;
oom:
disconnect_client(client, true, "out of memory");
/*
* We also disconnect the server, because we probably messed with its state
* at this prepared statement state at this point. And rolling that back is
* hard.
*/
disconnect_server(client->link, true, "out of memory");
return false;
}
/*
* Handle a Describe packet for a named prepared statement
*
* Rewrites the given Describe packet to use the server-side statement name
* instead of the client-side one. If the statement is not yet prepared on the
* server, then we first send a Parse command to the server for the prepared
* statement in question.
*/
bool handle_describe_command(PgSocket *client, PktHdr *pkt)
{
PgSocket *server = client->link;
PgDescribePacket dp;
PgClientPreparedStatement *client_ps = NULL;
PgPreparedStatement *ps;
bool res;
Assert(server);
if (!unmarshall_describe_packet(client, pkt, &dp) || dp.type != 'S')
return false;
client_ps = get_client_prepared_statement(client, dp.name);
if (!client_ps)
return false;
ps = client_ps->ps;
if (!ensure_statement_is_prepared_on_server(server, ps))
goto oom;
slog_debug(client, "handle_describe_command: mapped statement '%s' (query '%s') to '%s'",
dp.name, ps->query_and_parameters, ps->stmt_name);
/*
* Track the Describe command that we send to server and forward the
* response to the client, because they expect one.
*/
if (!add_outstanding_request(client, PqMsg_Describe, RA_FORWARD))
goto oom;
skip_possibly_completely_buffered_packet(client, pkt);
QUEUE_DescribeStmt(res, client, server, ps->stmt_name);
return res;
oom:
disconnect_client(client, true, "out of memory");
/*
* We also disconnect the server, because we probably messed with its state
* at this prepared statement state at this point. And rolling that back is
* hard.
*/
disconnect_server(client->link, true, "out of memory");
return false;
}
/*
* Handle a Close packet for a named prepared statement
*
* This does not actually close the mapped prepared statement on the server. But
* it does remove the mapping from the client, so that the client can reuse the
* name of this prepared statement for a new one.
*/
bool handle_close_statement_command(PgSocket *client, PktHdr *pkt, PgClosePacket *close_packet)
{
PgClientPreparedStatement *client_ps = NULL;
bool res = true;
HASH_FIND_STR(client->client_prepared_statements, close_packet->name, client_ps);
if (client_ps) {
slog_noise(client, "handle_close_command: removed '%s' from cached prepared statements, items remaining %u", close_packet->name, HASH_COUNT(client->client_prepared_statements));
HASH_DEL(client->client_prepared_statements, client_ps);
if (--client_ps->ps->use_count == 0) {
HASH_DEL(prepared_statements, client_ps->ps);
free(client_ps->ps);
}
free(client_ps);
}
/* Do not forward packet to server */
skip_possibly_completely_buffered_packet(client, pkt);
if (!client->link || statlist_count(&client->link->outstanding_requests) == 0) {
slog_debug(client, "handle_close_statement_command: no outstanding requests so instantly answering client");
SEND_CloseComplete(res, client);
return res;
}
if (!add_outstanding_request(client, PqMsg_Close, RA_FAKE)) {
return false;
}
return true;
}
/*
* Frees all the prepared statements that are cached on the client.
*/
void free_client_prepared_statements(PgSocket *client)
{
PgClientPreparedStatement *client_ps, *tmp;
HASH_ITER(hh, client->client_prepared_statements, client_ps, tmp) {
HASH_DEL(client->client_prepared_statements, client_ps);
if (--client_ps->ps->use_count == 0) {
HASH_DEL(prepared_statements, client_ps->ps);
free(client_ps->ps);
}
free(client_ps);
}
free(client->client_prepared_statements);
client->client_prepared_statements = NULL;
}
/*
* Frees all the prepared statements that are cached on the server.
*/
void free_server_prepared_statements(PgSocket *server)
{
struct PgServerPreparedStatement *current, *tmp_s;
HASH_ITER(hh, server->server_prepared_statements, current, tmp_s) {
HASH_DEL(server->server_prepared_statements, current);
free_server_prepared_statement(current);
}
free(server->server_prepared_statements);
server->server_prepared_statements = NULL;
}
pgbouncer-1.24.1/src/dnslookup.c 0000644 0001750 0000000 00000063431 14777762222 013467 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2010 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "bouncer.h"
#include
#include
#if !defined(USE_EVDNS) && !defined(USE_CARES)
#define USE_GETADDRINFO_A
#endif
#ifdef USE_EVDNS
#include
#define addrinfo evutil_addrinfo
#define freeaddrinfo evutil_freeaddrinfo
#endif /* USE_EVDNS */
#ifdef USE_CARES
#define CARES_NO_DEPRECATED
#include
#include
#ifdef HAVE_ARES_NAMESER_H
#include
#else
#include
#endif
#define ZONE_RECHECK 1
#else
/* only c-ares requires this */
#define impl_per_loop(ctx)
#endif
#ifndef ZONE_RECHECK
#define ZONE_RECHECK 0
/* no implementation, also avoid 'unused' warning */
#define impl_query_soa_serial(ctx, name) do { if (0) got_zone_serial(ctx, NULL); } while (0)
#define cf_dns_zone_check_period (0)
#endif
/*
* There can be several client request (tokens)
* attached to single actual request.
*/
struct DNSToken {
struct List node;
adns_callback_f cb_func;
void *cb_arg;
};
/*
* Cached DNS query (hostname).
*/
struct DNSRequest {
struct AANode node; /* DNSContext->req_tree */
struct List znode; /* DNSZone->host_list */
struct DNSContext *ctx;
struct DNSZone *zone;
struct List ucb_list; /* DNSToken->node */
char *name;
int namelen;
bool done;
struct addrinfo *result;
struct addrinfo *current;
struct addrinfo *oldres;
usec_t res_ttl;
};
/* zone name serial */
struct DNSZone {
struct List lnode; /* DNSContext->zone_list */
struct AANode tnode; /* DNSContext->zone_tree */
struct StatList host_list; /* DNSRequest->znode */
char *zonename;
uint32_t serial;
};
/*
* Top struct for DNS data.
*/
struct DNSContext {
struct AATree req_tree;
void *edns;
struct AATree zone_tree; /* DNSZone->tnode */
struct List zone_list; /* DNSZone->lnode */
struct DNSZone *cur_zone;
struct event ev_zone_timer;
int zone_state;
int active; /* number of in-flight queries */
};
static void deliver_info(struct DNSRequest *req);
static void got_result_gai(int result, struct addrinfo *res, void *arg);
static void zone_register(struct DNSContext *ctx, struct DNSRequest *req);
static void zone_init(struct DNSContext *ctx);
static void zone_free(struct DNSContext *ctx);
static void got_zone_serial(struct DNSContext *ctx, uint32_t *serial);
/*
* Custom addrinfo generation
*/
#if defined(USE_CARES)
static struct addrinfo *mk_addrinfo(const void *adr, int af)
{
struct addrinfo *ai;
ai = calloc(1, sizeof(*ai));
if (!ai)
return NULL;
if (af == AF_INET) {
struct sockaddr_in *sa4;
sa4 = calloc(1, sizeof(*sa4));
if (!sa4)
goto failed;
memcpy(&sa4->sin_addr, adr, 4);
sa4->sin_family = af;
ai->ai_addr = (struct sockaddr *)sa4;
ai->ai_addrlen = sizeof(*sa4);
} else if (af == AF_INET6) {
struct sockaddr_in6 *sa6;
sa6 = calloc(1, sizeof(*sa6));
if (!sa6)
goto failed;
memcpy(&sa6->sin6_addr, adr, sizeof(sa6->sin6_addr));
sa6->sin6_family = af;
ai->ai_addr = (struct sockaddr *)sa6;
ai->ai_addrlen = sizeof(*sa6);
}
ai->ai_protocol = IPPROTO_TCP;
ai->ai_socktype = SOCK_STREAM;
ai->ai_family = af;
return ai;
failed:
free(ai);
return NULL;
}
#define freeaddrinfo(x) local_freeaddrinfo(x)
static void freeaddrinfo(struct addrinfo *ai)
{
struct addrinfo *cur;
while (ai) {
cur = ai;
ai = ai->ai_next;
free(cur->ai_addr);
free(cur);
}
}
#ifdef USE_CARES
static inline struct addrinfo *convert_hostent(const struct hostent *h)
{
struct addrinfo *ai, *first = NULL, *last = NULL;
int i;
for (i = 0; h->h_addr_list[i]; i++) {
ai = mk_addrinfo(h->h_addr_list[i], h->h_addrtype);
if (!ai)
goto failed;
if (!first)
first = ai;
else
last->ai_next = ai;
last = ai;
}
return first;
failed:
freeaddrinfo(first);
return NULL;
}
#endif /* USE_CARES */
#endif /* custom addrinfo */
/*
* ADNS with glibc's getaddrinfo_a()
*/
#ifdef USE_GETADDRINFO_A
const char *adns_get_backend(void)
{
#ifdef HAVE_GETADDRINFO_A
return "libc"
#ifdef __GLIBC__
"-" STR(__GLIBC__) "." STR(__GLIBC_MINOR__);
#endif
;
#else
return "compat";
#endif
}
struct GaiRequest {
struct List node;
struct DNSRequest *req;
struct gaicb gairq;
};
struct GaiContext {
struct DNSContext *ctx;
struct List gairq_list;
struct event ev;
struct sigevent sev;
};
static void dns_signal(int f, short ev, void *arg)
{
struct GaiContext *gctx = arg;
struct List *el, *tmp;
struct GaiRequest *rq;
int e;
list_for_each_safe(el, &gctx->gairq_list, tmp) {
rq = container_of(el, struct GaiRequest, node);
e = gai_error(&rq->gairq);
if (e == EAI_INPROGRESS)
continue;
/* got one */
list_del(&rq->node);
got_result_gai(e, rq->gairq.ar_result, rq->req);
free(rq);
}
}
static bool impl_init(struct DNSContext *ctx)
{
struct GaiContext *gctx;
if (cf_resolv_conf && cf_resolv_conf[0]) {
log_error("resolv_conf setting is not supported by libc adns");
return false;
}
gctx = calloc(1, sizeof(*gctx));
if (!gctx)
return false;
list_init(&gctx->gairq_list);
gctx->ctx = ctx;
gctx->sev.sigev_notify = SIGEV_SIGNAL;
gctx->sev.sigev_signo = SIGALRM;
evsignal_assign(&gctx->ev, pgb_event_base, SIGALRM, dns_signal, gctx);
if (evsignal_add(&gctx->ev, NULL) < 0) {
free(gctx);
return false;
}
ctx->edns = gctx;
return true;
}
static void impl_launch_query(struct DNSRequest *req)
{
static const struct addrinfo hints = { .ai_socktype = SOCK_STREAM };
struct GaiContext *gctx = req->ctx->edns;
struct GaiRequest *grq;
int res;
struct gaicb *cb;
grq = calloc(1, sizeof(*grq));
if (!grq)
goto failed2;
list_init(&grq->node);
grq->req = req;
grq->gairq.ar_name = req->name;
grq->gairq.ar_request = &hints;
list_append(&gctx->gairq_list, &grq->node);
cb = &grq->gairq;
res = getaddrinfo_a(GAI_NOWAIT, &cb, 1, &gctx->sev);
if (res != 0)
goto failed;
return;
failed:
if (res == EAI_SYSTEM) {
log_warning("dns: getaddrinfo_a(%s)=%d, errno=%d (%s)",
req->name, res, errno, strerror(errno));
} else {
log_warning("dns: getaddrinfo_a(%s)=%d", req->name, res);
}
list_del(&grq->node);
free(grq);
failed2:
req->done = true;
deliver_info(req);
}
static void impl_release(struct DNSContext *ctx)
{
struct GaiContext *gctx = ctx->edns;
if (gctx) {
evsignal_del(&gctx->ev);
free(gctx);
ctx->edns = NULL;
}
}
#endif /* USE_GETADDRINFO_A */
/*
* ADNS with libevent2
*/
#ifdef USE_EVDNS
const char *adns_get_backend(void)
{
return "evdns2";
}
/*
* Confusingly, this is not the same as evdns_err_to_string().
*/
static const char *_evdns_base_resolv_conf_parse_err_to_string(int err)
{
switch (err) {
case 0: return "no error";
case 1: return "failed to open file";
case 2: return "failed to stat file";
case 3: return "file too large";
case 4: return "out of memory";
case 5: return "short read from file";
case 6: return "no nameservers listed in the file";
default: return "[Unknown error code]";
}
}
static bool impl_init(struct DNSContext *ctx)
{
if (cf_resolv_conf && cf_resolv_conf[0]) {
int err;
ctx->edns = evdns_base_new(pgb_event_base, 0);
if (!ctx->edns) {
log_error("evdns_base_new failed");
return false;
}
err = evdns_base_resolv_conf_parse(ctx->edns, DNS_OPTIONS_ALL,
cf_resolv_conf);
if (err) {
log_error("evdns parsing of \"%s\" failed: %s",
cf_resolv_conf,
_evdns_base_resolv_conf_parse_err_to_string(err));
return false;
}
} else {
ctx->edns = evdns_base_new(pgb_event_base, 1);
if (!ctx->edns) {
log_error("evdns_base_new failed");
return false;
}
}
return true;
}
static void impl_launch_query(struct DNSRequest *req)
{
static const struct addrinfo hints = { .ai_socktype = SOCK_STREAM };
struct evdns_getaddrinfo_request *gai_req;
struct evdns_base *dns = req->ctx->edns;
gai_req = evdns_getaddrinfo(dns, req->name, NULL, &hints, got_result_gai, req);
log_noise("dns: evdns_getaddrinfo(%s)=%p", req->name, gai_req);
}
static void impl_release(struct DNSContext *ctx)
{
struct evdns_base *dns = ctx->edns;
evdns_base_free(dns, 0);
}
#endif /* USE_EVDNS */
/*
* ADNS with
*/
#ifdef USE_CARES
#define MAX_CARES_FDS 16
struct XaresFD {
struct event ev; /* fd event state is persistent */
struct XaresMeta *meta; /* pointer to parent context */
ares_socket_t sock; /* socket value */
short wait; /* EV_READ / EV_WRITE */
bool in_use; /* is this slot assigned */
};
struct XaresMeta {
/* c-ares descriptor */
ares_channel chan;
/* how many elements in fds array are in use */
int max_fds;
/* static array for fds */
struct XaresFD fds[MAX_CARES_FDS];
/* timer event is one-shot */
struct event ev_timer;
/* is timer activated? */
bool timer_active;
/* If dns events happened during event loop,
timer may need recalibration. */
bool got_events;
};
const char *adns_get_backend(void)
{
return "c-ares " ARES_VERSION_STR;
}
/* called by libevent on timer timeout */
static void xares_timer_cb(evutil_socket_t sock, short flags, void *arg)
{
struct DNSContext *ctx = arg;
struct XaresMeta *meta = ctx->edns;
ares_process_fd(meta->chan, ARES_SOCKET_BAD, ARES_SOCKET_BAD);
meta->timer_active = false;
meta->got_events = true;
}
/* called by libevent on fd event */
static void xares_fd_cb(evutil_socket_t sock, short flags, void *arg)
{
struct XaresFD *xfd = arg;
struct XaresMeta *meta = xfd->meta;
ares_socket_t r, w;
r = (flags & EV_READ) ? xfd->sock : ARES_SOCKET_BAD;
w = (flags & EV_WRITE) ? xfd->sock : ARES_SOCKET_BAD;
ares_process_fd(meta->chan, r, w);
meta->got_events = true;
}
/* called by c-ares on new socket creation */
static int xares_new_socket_cb(ares_socket_t sock, int sock_type, void *arg)
{
struct DNSContext *ctx = arg;
struct XaresMeta *meta = ctx->edns;
struct XaresFD *xfd;
int pos;
/* find free slot in array */
for (pos = 0; pos < meta->max_fds; pos++) {
if (!meta->fds[pos].in_use)
break;
}
if (pos >= MAX_CARES_FDS) {
log_warning("c-ares fd overflow");
return ARES_ENOMEM;
}
if (pos == meta->max_fds)
meta->max_fds++;
/* fill it */
xfd = &meta->fds[pos];
xfd->meta = meta;
xfd->sock = sock;
xfd->wait = 0;
xfd->in_use = true;
return ARES_SUCCESS;
}
/* called by c-ares on socket state change (r=w=0 means socket close) */
static void xares_state_cb(void *arg, ares_socket_t sock, int r, int w)
{
struct DNSContext *ctx = arg;
struct XaresMeta *meta = ctx->edns;
struct XaresFD *xfd;
int pos;
short new_wait = 0;
if (r)
new_wait |= EV_READ;
if (w)
new_wait |= EV_WRITE;
/* find socket */
for (pos = 0; pos < meta->max_fds; pos++) {
xfd = &meta->fds[pos];
if (!xfd->in_use)
continue;
if (xfd->sock != sock)
continue;
/* no change? */
if (xfd->wait == new_wait)
return;
goto re_set;
}
log_warning("adns: c-ares state change for unknown fd: %u", (unsigned)sock);
return;
re_set:
if (xfd->wait)
event_del(&xfd->ev);
xfd->wait = new_wait;
if (new_wait) {
event_assign(&xfd->ev, pgb_event_base, sock, new_wait | EV_PERSIST, xares_fd_cb, xfd);
if (event_add(&xfd->ev, NULL) < 0)
log_warning("adns: event_add failed: %s", strerror(errno));
} else {
xfd->in_use = false;
}
return;
}
/* called by c-ares on dns reply */
static void xares_host_cb(void *arg, int status, int timeouts, struct hostent *h)
{
struct DNSRequest *req = arg;
struct addrinfo *res = NULL;
log_noise("dns: xares_host_cb(%s)=%s", req->name, ares_strerror(status));
if (status == ARES_SUCCESS) {
res = convert_hostent(h);
got_result_gai(0, res, req);
} else {
log_debug("DNS lookup failed: %s - %s", req->name, ares_strerror(status));
got_result_gai(0, res, req);
}
}
/* send hostname query */
static void impl_launch_query(struct DNSRequest *req)
{
struct XaresMeta *meta = req->ctx->edns;
int af;
/*
* c-ares <= 1.10 cannot resolve CNAME with AF_UNSPEC.
*
* Force IPv4 there.
*
* Fixed in "host_callback: Fall back to AF_INET on searching with AF_UNSPEC" (c1fe47f)
* in c-ares repo.
*/
#if ARES_VERSION <= 0x10A00
#warning c-ares <=1.10 has buggy IPv6 support; this PgBouncer build will use IPv4 only.
af = AF_INET;
#else
af = AF_UNSPEC;
#endif
log_noise("dns: ares_gethostbyname(%s)", req->name);
ares_gethostbyname(meta->chan, req->name, af, xares_host_cb, req);
meta->got_events = true;
}
/* re-set timer if any dns event happened */
static void impl_per_loop(struct DNSContext *ctx)
{
struct timeval tv, *tvp;
struct XaresMeta *meta = ctx->edns;
if (!meta->got_events)
return;
if (meta->timer_active) {
event_del(&meta->ev_timer);
meta->timer_active = false;
}
tvp = ares_timeout(meta->chan, NULL, &tv);
if (tvp != NULL) {
if (event_add(&meta->ev_timer, tvp) < 0)
log_warning("impl_per_loop: event_add failed: %s", strerror(errno));
meta->timer_active = true;
}
meta->got_events = false;
}
/* c-ares setup */
static bool impl_init(struct DNSContext *ctx)
{
struct XaresMeta *meta;
int err;
int mask;
struct ares_options opts;
err = ares_library_init(ARES_LIB_INIT_ALL);
if (err) {
log_error("ares_library_init: %s", ares_strerror(err));
return false;
}
meta = calloc(1, sizeof(*meta));
if (!meta)
return false;
memset(&opts, 0, sizeof(opts));
opts.sock_state_cb = xares_state_cb;
opts.sock_state_cb_data = ctx;
mask = ARES_OPT_SOCK_STATE_CB;
if (cf_resolv_conf && cf_resolv_conf[0]) {
#ifdef ARES_OPT_RESOLVCONF
opts.resolvconf_path = strdup(cf_resolv_conf);
if (!opts.resolvconf_path) {
free(meta);
return false;
}
mask |= ARES_OPT_RESOLVCONF;
#else
log_error("resolv_conf setting is not supported by this version of c-ares");
free(meta);
return false;
#endif
}
err = ares_init_options(&meta->chan, &opts, mask);
if (err) {
free(meta);
log_error("ares_library_init: %s", ares_strerror(err));
return false;
}
ares_set_socket_callback(meta->chan, xares_new_socket_cb, ctx);
evtimer_assign(&meta->ev_timer, pgb_event_base, xares_timer_cb, ctx);
ctx->edns = meta;
return true;
}
/* c-ares shutdown */
static void impl_release(struct DNSContext *ctx)
{
struct XaresMeta *meta = ctx->edns;
ares_destroy(meta->chan);
ares_library_cleanup();
if (meta->timer_active)
event_del(&meta->ev_timer);
free(meta);
ctx->edns = NULL;
}
/*
* query SOA with c-ares
*/
/* called by c-ares on SOA reply */
static void xares_soa_cb(void *arg, int status, int timeouts,
unsigned char *abuf, int alen)
{
struct DNSContext *ctx = arg;
struct XaresMeta *meta = ctx->edns;
struct ares_soa_reply *soa = NULL;
meta->got_events = true;
log_noise("ares SOA result: %s", ares_strerror(status));
if (status != ARES_SUCCESS) {
got_zone_serial(ctx, NULL);
return;
}
status = ares_parse_soa_reply(abuf, alen, &soa);
if (status == ARES_SUCCESS) {
got_zone_serial(ctx, &soa->serial);
} else {
log_warning("ares_parse_soa: %s", ares_strerror(status));
got_zone_serial(ctx, NULL);
}
ares_free_data(soa);
}
/* send SOA query */
static int impl_query_soa_serial(struct DNSContext *ctx, const char *zonename)
{
struct XaresMeta *meta = ctx->edns;
log_debug("dns: ares query SOA(%s)", zonename);
ares_search(meta->chan, zonename, ns_c_in, ns_t_soa,
xares_soa_cb, ctx);
meta->got_events = true;
return 0;
}
#endif /* USE_CARES */
/*
* Generic framework
*/
static void deliver_info(struct DNSRequest *req)
{
struct DNSContext *ctx = req->ctx;
struct DNSToken *ucb;
struct List *el;
const struct addrinfo *ai = req->current;
char sabuf[128];
ctx->active--;
loop:
/* get next req */
el = list_pop(&req->ucb_list);
if (!el)
return;
ucb = container_of(el, struct DNSToken, node);
/* launch callback */
log_noise("dns: deliver_info(%s) addr=%s", req->name,
ai ? sa2str(ai->ai_addr, sabuf, sizeof(sabuf)) : "NULL");
ucb->cb_func(ucb->cb_arg,
ai ? ai->ai_addr : NULL,
ai ? ai->ai_addrlen : 0);
free(ucb);
/* scroll req list */
if (ai) {
req->current = ai->ai_next;
if (!req->current)
req->current = req->result;
}
goto loop;
}
static int req_cmp(uintptr_t arg, struct AANode *node)
{
const char *s1 = (char *)arg;
struct DNSRequest *req = container_of(node, struct DNSRequest, node);
return strcmp(s1, req->name);
}
static void req_reset(struct DNSRequest *req)
{
req->done = false;
if (req->result) {
if (req->oldres)
freeaddrinfo(req->oldres);
req->oldres = req->result;
}
req->result = req->current = NULL;
}
static void req_free(struct AANode *node, void *arg)
{
struct DNSToken *ucb;
struct DNSRequest *req;
struct List *el;
req = container_of(node, struct DNSRequest, node);
while ((el = list_pop(&req->ucb_list)) != NULL) {
ucb = container_of(el, struct DNSToken, node);
free(ucb);
}
req_reset(req);
if (req->oldres) {
freeaddrinfo(req->oldres);
req->oldres = NULL;
}
if (req->zone)
statlist_remove(&req->zone->host_list, &req->znode);
free(req->name);
free(req);
}
struct DNSContext *adns_create_context(void)
{
struct DNSContext *ctx;
log_debug("adns_create_context: %s", adns_get_backend());
ctx = calloc(1, sizeof(*ctx));
if (!ctx)
return NULL;
aatree_init(&ctx->req_tree, req_cmp, req_free);
zone_init(ctx);
if (!impl_init(ctx)) {
adns_free_context(ctx);
return NULL;
}
return ctx;
}
void adns_free_context(struct DNSContext *ctx)
{
if (ctx) {
impl_release(ctx);
aatree_destroy(&ctx->req_tree);
zone_free(ctx);
free(ctx);
}
}
struct DNSToken *adns_resolve(struct DNSContext *ctx, const char *name, adns_callback_f cb_func, void *cb_arg)
{
int namelen = strlen(name);
struct DNSRequest *req;
struct DNSToken *ucb;
struct AANode *node;
/* setup actual lookup */
node = aatree_search(&ctx->req_tree, (uintptr_t)name);
if (node) {
req = container_of(node, struct DNSRequest, node);
} else {
log_noise("dns: new req: %s", name);
req = calloc(1, sizeof(*req));
if (!req)
goto nomem;
req->name = strdup(name);
if (!req->name) {
free(req);
goto nomem;
}
req->ctx = ctx;
req->namelen = namelen;
list_init(&req->ucb_list);
list_init(&req->znode);
aatree_insert(&ctx->req_tree, (uintptr_t)req->name, &req->node);
zone_register(ctx, req);
ctx->active++;
impl_launch_query(req);
}
/* remember user callback */
ucb = calloc(1, sizeof(*ucb));
if (!ucb)
goto nomem;
list_init(&ucb->node);
ucb->cb_func = cb_func;
ucb->cb_arg = cb_arg;
list_append(&req->ucb_list, &ucb->node);
/* if already have final result, report it */
if (req->done) {
if (req->res_ttl < get_cached_time()) {
log_noise("dns: ttl over: %s", req->name);
req_reset(req);
ctx->active++;
impl_launch_query(req);
} else {
deliver_info(req);
}
}
/* if ->done, then we have already reported */
return req->done ? NULL : ucb;
nomem:
log_warning("dns(%s): req failed, no mem", name);
cb_func(cb_arg, NULL, 0);
return NULL;
}
static int cmp_addrinfo(const struct addrinfo *a1, const struct addrinfo *a2)
{
if (a1->ai_family != a2->ai_family)
return a1->ai_family - a2->ai_family;
if (a1->ai_addrlen != a2->ai_addrlen)
return a1->ai_addrlen - a2->ai_addrlen;
return memcmp(a1->ai_addr, a2->ai_addr, a1->ai_addrlen);
}
/* check if new dns reply is missing some IP compared to old one */
static void check_req_result_changes(struct DNSRequest *req)
{
struct addrinfo *ai, *aj;
for (ai = req->oldres; ai; ai = ai->ai_next) {
bool found = false;
for (aj = req->result; aj; aj = aj->ai_next) {
if (cmp_addrinfo(ai, aj) == 0) {
found = true;
break;
}
}
/* missing IP (possible DNS failover) make connections to it dirty */
if (!found)
tag_host_addr_dirty(req->name, ai->ai_addr);
}
}
/* struct addrinfo -> deliver_info() */
static void got_result_gai(int result, struct addrinfo *res, void *arg)
{
struct DNSRequest *req = arg;
req_reset(req);
if (result == 0 && res) {
req->result = res;
req->current = res;
if (req->oldres)
check_req_result_changes(req);
/* show all results */
if (cf_verbose > 1) {
const struct addrinfo *ai = res;
int n = 0;
char buf[128];
while (ai) {
log_noise("DNS: %s[%d] = %s [%s]", req->name, n++,
sa2str(ai->ai_addr, buf, sizeof(buf)),
ai->ai_socktype == SOCK_STREAM ? "STREAM" : "OTHER");
ai = ai->ai_next;
}
}
req->res_ttl = get_cached_time() + cf_dns_max_ttl;
} else {
/* lookup failed */
log_warning("DNS lookup failed: %s: result=%d", req->name, result);
req->res_ttl = get_cached_time() + cf_dns_nxdomain_ttl;
}
req->done = true;
deliver_info(req);
}
void adns_cancel(struct DNSContext *ctx, struct DNSToken *tk)
{
list_del(&tk->node);
memset(tk, 0, sizeof(*tk));
free(tk);
}
void adns_info(struct DNSContext *ctx, int *names, int *zones, int *queries, int *pending)
{
*names = ctx->req_tree.count;
*zones = ctx->zone_tree.count;
*queries = ctx->active;
*pending = 0;
}
/*
* zone code
*/
static void zone_item_free(struct AANode *n, void *arg)
{
struct DNSZone *z = container_of(n, struct DNSZone, tnode);
list_del(&z->lnode);
free(z->zonename);
free(z);
}
static int zone_item_cmp(uintptr_t val1, struct AANode *n2)
{
const char *name1 = (const char *)val1;
struct DNSZone *z2 = container_of(n2, struct DNSZone, tnode);
return strcasecmp(name1, z2->zonename);
}
static void zone_init(struct DNSContext *ctx)
{
aatree_init(&ctx->zone_tree, zone_item_cmp, zone_item_free);
list_init(&ctx->zone_list);
}
static void zone_free(struct DNSContext *ctx)
{
aatree_destroy(&ctx->zone_tree);
}
static void zone_register(struct DNSContext *ctx, struct DNSRequest *req)
{
struct DNSZone *z;
struct AANode *n;
const char *name;
log_debug("zone_register(%s)", req->name);
name = strchr(req->name, '.');
if (!name || name[1] == 0)
return;
name++;
log_debug("zone_register(%s): name=%s", req->name, name);
n = aatree_search(&ctx->zone_tree, (uintptr_t)name);
if (n) {
/* already exists */
z = container_of(n, struct DNSZone, tnode);
req->zone = z;
statlist_append(&z->host_list, &req->znode);
return;
}
/* create struct */
z = calloc(1, sizeof(*z));
if (!z)
return;
z->zonename = strdup(name);
if (!z->zonename) {
free(z);
return;
}
statlist_init(&z->host_list, "host_list");
list_init(&z->lnode);
/* link */
aatree_insert(&ctx->zone_tree, (uintptr_t)z->zonename, &z->tnode);
list_append(&ctx->zone_list, &z->lnode);
statlist_append(&z->host_list, &req->znode);
req->zone = z;
}
static void zone_timer(evutil_socket_t fd, short flg, void *arg)
{
struct DNSContext *ctx = arg;
struct List *el;
struct DNSZone *z;
if (list_empty(&ctx->zone_list)) {
ctx->zone_state = 0;
return;
}
el = list_first(&ctx->zone_list);
z = container_of(el, struct DNSZone, lnode);
ctx->zone_state = 1;
ctx->cur_zone = z;
ctx->active++;
impl_query_soa_serial(ctx, z->zonename);
}
static void launch_zone_timer(struct DNSContext *ctx)
{
struct timeval tv;
tv.tv_sec = cf_dns_zone_check_period / USEC;
tv.tv_usec = cf_dns_zone_check_period % USEC;
evtimer_assign(&ctx->ev_zone_timer, pgb_event_base, zone_timer, ctx);
safe_evtimer_add(&ctx->ev_zone_timer, &tv);
ctx->zone_state = 2;
}
void adns_zone_cache_maint(struct DNSContext *ctx)
{
if (!cf_dns_zone_check_period) {
if (ctx->zone_state == 2) {
event_del(&ctx->ev_zone_timer);
ctx->zone_state = 0;
}
ctx->cur_zone = NULL;
return;
} else if (ctx->zone_state == 0) {
if (list_empty(&ctx->zone_list))
return;
launch_zone_timer(ctx);
}
}
static void zone_requeue(struct DNSContext *ctx, struct DNSZone *z)
{
struct List *el;
struct DNSRequest *req;
statlist_for_each(el, &z->host_list) {
req = container_of(el, struct DNSRequest, znode);
if (!req->done)
continue;
req->res_ttl = 0;
ctx->active++;
impl_launch_query(req);
}
}
static void got_zone_serial(struct DNSContext *ctx, uint32_t *serial)
{
struct DNSZone *z = ctx->cur_zone;
struct List *el;
ctx->active--;
if (!ctx->zone_state || !z)
return;
if (serial) {
/* wraparound compare */
int32_t s1 = z->serial;
int32_t s2 = *serial;
int32_t ds = s2 - s1;
if (ds > 0) {
log_info("zone '%s' serial changed: old=%u new=%u",
z->zonename, z->serial, *serial);
z->serial = *serial;
zone_requeue(ctx, z);
} else {
log_debug("zone '%s' unchanged: serial=%u", z->zonename, *serial);
}
} else {
log_debug("failure to get zone '%s' serial", z->zonename);
}
el = z->lnode.next;
if (el != &ctx->zone_list) {
z = container_of(el, struct DNSZone, lnode);
ctx->cur_zone = z;
ctx->active++;
impl_query_soa_serial(ctx, z->zonename);
} else {
launch_zone_timer(ctx);
}
}
/*
* Cache walkers
*/
struct WalkInfo {
adns_walk_name_f name_cb;
adns_walk_zone_f zone_cb;
void *arg;
};
static void walk_name(struct AANode *n, void *arg)
{
struct WalkInfo *w = arg;
struct DNSRequest *req = container_of(n, struct DNSRequest, node);
w->name_cb(w->arg, req->name, req->result, req->res_ttl);
}
static void walk_zone(struct AANode *n, void *arg)
{
struct WalkInfo *w = arg;
struct DNSZone *z = container_of(n, struct DNSZone, tnode);
w->zone_cb(w->arg, z->zonename, z->serial, statlist_count(&z->host_list));
}
void adns_walk_names(struct DNSContext *ctx, adns_walk_name_f cb, void *arg)
{
struct WalkInfo w;
w.name_cb = cb;
w.arg = arg;
aatree_walk(&ctx->req_tree, AA_WALK_IN_ORDER, walk_name, &w);
}
void adns_walk_zones(struct DNSContext *ctx, adns_walk_zone_f cb, void *arg)
{
struct WalkInfo w;
w.zone_cb = cb;
w.arg = arg;
aatree_walk(&ctx->zone_tree, AA_WALK_IN_ORDER, walk_zone, &w);
}
void adns_per_loop(struct DNSContext *ctx)
{
impl_per_loop(ctx);
}
pgbouncer-1.24.1/src/takeover.c 0000644 0001750 0000000 00000023337 14777762222 013272 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Connect to running bouncer process, load fds from it, shut it down
* and continue with them.
*
* Each row from SHOW FDS will have corresponding fd in ancillary message.
*
* Manpages: unix, sendmsg, recvmsg, cmsg, readv
*/
#include "bouncer.h"
#include
/*
* Takeover done, old process shut down,
* kick this one running.
*/
static PgSocket *old_bouncer = NULL;
void takeover_finish(void)
{
uint8_t buf[512];
int fd = sbuf_socket(&old_bouncer->sbuf);
bool res;
ssize_t got;
log_info("sending SHUTDOWN;");
socket_set_nonblocking(fd, 0);
SEND_generic(res, old_bouncer, PqMsg_Query, "s", "SHUTDOWN;");
if (!res)
die("failed to send SHUTDOWN;");
while (1) {
got = safe_recv(fd, buf, sizeof(buf), 0);
if (got == 0)
break;
if (got < 0)
die("sky is falling - error while waiting result from SHUTDOWN: %s", strerror(errno));
}
disconnect_server(old_bouncer, false, "disko over");
old_bouncer = NULL;
if (cf_pidfile && cf_pidfile[0]) {
log_info("waiting for old pidfile to go away");
while (1) {
struct stat st;
if (stat(cf_pidfile, &st) < 0) {
if (errno == ENOENT)
break;
}
usleep(USEC/10);
}
}
log_info("old process killed, resuming work");
resume_all();
}
static void takeover_finish_part1(PgSocket *bouncer)
{
Assert(old_bouncer == NULL);
/* unregister bouncer from libevent */
if (!sbuf_pause(&bouncer->sbuf))
fatal_perror("sbuf_pause failed");
old_bouncer = bouncer;
cf_reboot = 0;
log_info("disko over, going background");
}
/* parse msg for fd and info */
static void takeover_load_fd(struct MBuf *pkt, const struct cmsghdr *cmsg)
{
int fd;
char *task, *saddr, *user, *db;
char *client_enc, *std_string, *datestyle, *timezone, *password,
*scram_client_key, *scram_server_key;
int scram_client_key_len, scram_server_key_len;
int oldfd, port, linkfd;
int got;
uint64_t ckey;
PgAddr addr;
bool res = false;
memset(&addr, 0, sizeof(addr));
if (cmsg->cmsg_level == SOL_SOCKET
&& cmsg->cmsg_type == SCM_RIGHTS
&& cmsg->cmsg_len >= CMSG_LEN(sizeof(int))) {
/* get the fd */
memcpy(&fd, CMSG_DATA(cmsg), sizeof(int));
log_debug("got fd: %d", fd);
} else {
fatal("broken fd packet");
}
/* parse row contents */
got = scan_text_result(pkt, "issssiqisssssbb", &oldfd, &task, &user, &db,
&saddr, &port, &ckey, &linkfd,
&client_enc, &std_string, &datestyle, &timezone,
&password,
&scram_client_key_len,
&scram_client_key,
&scram_server_key_len,
&scram_server_key);
if (got < 0)
die("invalid data from old process");
if (task == NULL || saddr == NULL)
die("incomplete data from old process");
log_debug("FD row: fd=%d(%d) linkfd=%d task=%s user=%s db=%s enc=%s",
oldfd, fd, linkfd, task,
user ? user : "NULL", db ? db : "NULL",
client_enc ? client_enc : "NULL");
if (!password)
password = "";
/* fill address */
if (strcmp(saddr, "unix") == 0) {
pga_set(&addr, AF_UNIX, cf_listen_port);
} else {
if (!pga_pton(&addr, saddr, port))
fatal("failed to convert address: %s", saddr);
}
/* decide what to do with it */
if (strcmp(task, "client") == 0) {
res = use_client_socket(fd, &addr, db, user, ckey, oldfd, linkfd,
client_enc, std_string, datestyle, timezone,
password,
scram_client_key, scram_client_key_len,
scram_server_key, scram_server_key_len);
} else if (strcmp(task, "server") == 0) {
res = use_server_socket(fd, &addr, db, user, ckey, oldfd, linkfd,
client_enc, std_string, datestyle, timezone,
password,
scram_client_key, scram_client_key_len,
scram_server_key, scram_server_key_len);
} else if (strcmp(task, "pooler") == 0) {
res = use_pooler_socket(fd, pga_is_unix(&addr));
} else {
fatal("unknown task: %s", task);
}
free(scram_client_key);
free(scram_server_key);
if (!res)
fatal("socket takeover failed");
}
static void takeover_create_link(PgPool *pool, PgSocket *client)
{
struct List *item;
PgSocket *server;
statlist_for_each(item, &pool->active_server_list) {
server = container_of(item, PgSocket, head);
if (server->tmp_sk_oldfd == client->tmp_sk_linkfd) {
server->link = client;
client->link = server;
return;
}
}
fatal("takeover_create_link: failed to find pair");
}
/* clean the inappropriate places the old fds got stored in */
static void takeover_clean_socket_list(struct StatList *list)
{
struct List *item;
PgSocket *sk;
statlist_for_each(item, list) {
sk = container_of(item, PgSocket, head);
if (sk->suspended) {
sk->tmp_sk_oldfd = get_cached_time();
sk->tmp_sk_linkfd = get_cached_time();
}
}
}
/* all fds loaded, create links */
static void takeover_postprocess_fds(void)
{
struct List *item, *item2;
PgSocket *client;
PgPool *pool;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db->admin)
continue;
statlist_for_each(item2, &pool->active_client_list) {
client = container_of(item2, PgSocket, head);
if (client->suspended && client->tmp_sk_linkfd)
takeover_create_link(pool, client);
}
}
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
takeover_clean_socket_list(&pool->active_client_list);
takeover_clean_socket_list(&pool->active_server_list);
takeover_clean_socket_list(&pool->idle_server_list);
}
}
static void next_command(PgSocket *bouncer, struct MBuf *pkt)
{
bool res = true;
const char *cmd;
if (!mbuf_get_string(pkt, &cmd))
fatal("bad result pkt");
log_debug("takeover_recv_fds: CommandComplete body: %s", cmd);
if (strcmp(cmd, "SUSPEND") == 0) {
log_info("SUSPEND finished, sending SHOW FDS");
SEND_generic(res, bouncer, PqMsg_Query, "s", "SHOW FDS;");
} else if (strncmp(cmd, "SHOW", 4) == 0) {
/* all fds loaded, review them */
takeover_postprocess_fds();
log_info("SHOW FDS finished");
takeover_finish_part1(bouncer);
} else {
fatal("got bad CMD from old bouncer: %s", cmd);
}
if (!res)
fatal("command send failed");
}
static void takeover_parse_data(PgSocket *bouncer,
struct msghdr *msg, struct MBuf *data)
{
struct cmsghdr *cmsg;
PktHdr pkt;
cmsg = msg->msg_controllen ? CMSG_FIRSTHDR(msg) : NULL;
while (mbuf_avail_for_read(data) > 0) {
if (!get_header(data, &pkt))
fatal("cannot parse packet");
/*
* There should not be partial reads from UNIX socket.
*/
if (incomplete_pkt(&pkt))
fatal("unexpected partial packet");
switch (pkt.type) {
case PqMsg_RowDescription:
log_debug("takeover_parse_data: RowDescription");
break;
case PqMsg_DataRow:
log_debug("takeover_parse_data: DataRow");
if (cmsg) {
takeover_load_fd(&pkt.data, cmsg);
cmsg = CMSG_NXTHDR(msg, cmsg);
} else {
fatal("got row without fd info");
}
break;
case PqMsg_ReadyForQuery:
log_debug("takeover_parse_data: ReadyForQuery");
break;
case PqMsg_CommandComplete:
log_debug("takeover_parse_data: CommandComplete");
next_command(bouncer, &pkt.data);
break;
case PqMsg_ErrorResponse:
log_server_error("old bouncer sent", &pkt);
fatal("something failed");
default:
fatal("takeover_parse_data: unexpected pkt: '%c'", pkt_desc(&pkt));
}
}
}
/*
* listen for data from old bouncer.
*
* use always recvmsg, to keep code simpler
*/
static void takeover_recv_cb(evutil_socket_t sock, short flags, void *arg)
{
PgSocket *bouncer = container_of(arg, PgSocket, sbuf);
uint8_t data_buf[STARTUP_BUF * 2];
uint8_t cnt_buf[128];
struct msghdr msg;
struct iovec io;
ssize_t res;
struct MBuf data;
memset(&msg, 0, sizeof(msg));
io.iov_base = data_buf;
io.iov_len = sizeof(data_buf);
msg.msg_iov = &io;
msg.msg_iovlen = 1;
msg.msg_control = cnt_buf;
msg.msg_controllen = sizeof(cnt_buf);
res = safe_recvmsg(sock, &msg, 0);
if (res > 0) {
mbuf_init_fixed_reader(&data, data_buf, res);
takeover_parse_data(bouncer, &msg, &data);
} else if (res == 0) {
fatal("unexpected EOF");
} else {
if (errno == EAGAIN)
return;
fatal_perror("safe_recvmsg");
}
}
/*
* login finished, send first command,
* replace recv callback with custom recvmsg() based one.
*/
bool takeover_login(PgSocket *bouncer)
{
bool res;
slog_info(bouncer, "login OK, sending SUSPEND");
SEND_generic(res, bouncer, PqMsg_Query, "s", "SUSPEND;");
if (res) {
/* use own callback */
if (!sbuf_pause(&bouncer->sbuf))
fatal("sbuf_pause failed");
res = sbuf_continue_with_callback(&bouncer->sbuf, takeover_recv_cb);
if (!res)
fatal("takeover_login: sbuf_continue_with_callback failed");
} else {
fatal("takeover_login: failed to send command");
}
return res;
}
/* launch connection to running process */
void takeover_init(void)
{
PgDatabase *db;
PgPool *pool = NULL;
db = find_database("pgbouncer");
if (db)
pool = get_pool(db, db->forced_user_credentials);
if (!pool)
fatal("no admin pool?");
log_info("takeover_init: launching connection");
launch_new_connection(pool, /* evict_if_needed= */ true);
}
void takeover_login_failed(void)
{
fatal("login failed");
}
pgbouncer-1.24.1/src/server.c 0000644 0001750 0000000 00000064364 14777762222 012765 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Handling of server connections
*/
#include "bouncer.h"
#include "usual/time.h"
#include
#define ERRCODE_CANNOT_CONNECT_NOW "57P03"
static bool load_parameter(PgSocket *server, PktHdr *pkt, bool startup)
{
const char *key, *val;
PgSocket *client = server->link;
/*
* Want to see complete packet. That means SMALL_PKT
* in sbuf.c must be larger than max param pkt.
*/
if (incomplete_pkt(pkt))
return false;
if (!mbuf_get_string(&pkt->data, &key))
goto failed;
if (!mbuf_get_string(&pkt->data, &val))
goto failed;
slog_debug(server, "S: param: %s = %s", key, val);
varcache_set(&server->vars, key, val);
if (client) {
slog_debug(client, "setting client var: %s='%s'", key, val);
varcache_set(&client->vars, key, val);
}
if (startup) {
if (!add_welcome_parameter(server->pool, key, val))
goto failed_store;
}
return true;
failed:
disconnect_server(server, true, "broken ParameterStatus packet");
return false;
failed_store:
disconnect_server(server, true, "failed to store ParameterStatus");
return false;
}
/*
* We cannot log in to the server at all. If we don't already have any usable
* server connections, we disconnect all other clients in the pool that are
* waiting for a server.
*/
void kill_pool_logins(PgPool *pool, const char *sqlstate, const char *msg)
{
struct List *item, *tmp;
PgSocket *client;
/*
* The check for welcome_msg_ready is necessary because that indicates
* that the pool got tagged as dirty. It's possible that there's still
* working server connections in that case, but as soon as they get
* unassigned from their client they would be closed. So they don't
* really count as usable anymore.
*/
if (pool_connected_server_count(pool) != 0 && pool->welcome_msg_ready)
return;
statlist_for_each_safe(item, &pool->waiting_client_list, tmp) {
client = container_of(item, PgSocket, head);
disconnect_client_sqlstate(client, true, sqlstate, msg);
}
}
/*
* We cannot log in to the server at all. If we don't already have any usable
* server connections, we disconnect all other clients in the pool that are
* also waiting for a server. We disconnect them with exactly the same error
* message and code as we received from the server.
*/
const char * kill_pool_logins_server_error(PgPool *pool, PktHdr *errpkt)
{
const char *level, *sqlstate, *msg;
parse_server_error(errpkt, &level, &msg, &sqlstate);
log_warning("server login failed: %s %s", level, msg);
/*
* Kill all waiting clients unless it's a temporary error, such as
* "database system is starting up".
*/
if (strcmp(sqlstate, ERRCODE_CANNOT_CONNECT_NOW) != 0) {
log_noise("kill_pool_logins_server_error: sqlstate: %s", sqlstate);
kill_pool_logins(pool, sqlstate, msg);
}
return msg;
}
/* process packets on server auth phase */
static bool handle_server_startup(PgSocket *server, PktHdr *pkt)
{
SBuf *sbuf = &server->sbuf;
const char *msg;
bool res = false;
const uint8_t *ckey;
if (incomplete_pkt(pkt)) {
disconnect_server(server, true, "partial pkt in login phase");
return false;
}
/* ignore most that happens during connect_query */
if (server->exec_on_connect) {
switch (pkt->type) {
case PqMsg_ReadyForQuery:
case PqMsg_ParameterStatus:
/* handle them below */
break;
case PqMsg_ErrorResponse:
/* log & ignore errors */
log_server_error("S: error while executing exec_on_query", pkt);
/* fallthrough */
default: /* ignore rest */
sbuf_prepare_skip(sbuf, pkt->len);
return true;
}
}
switch (pkt->type) {
default:
slog_error(server, "unknown pkt from server: '%c'", pkt_desc(pkt));
disconnect_server(server, true, "unknown pkt from server");
break;
case PqMsg_ErrorResponse:
/*
* If we cannot log into the server, then we drop all clients
* that are currently trying to log in because they will almost
* certainly hit the same error.
*
* However, we don't do this if it's a replication connection,
* because those can fail due to a variety of missing
* permissions specific to replication connections, such as
* missing REPLICATION role or missing pg_hba.conf line for the
* replication database. In such cases normal connections would
* still be able connect and query the database just fine, so
* we don't want to kill all of those just yet. If there really
* is a problem impacting all connections, we can wait for a
* normal connection to report this problem.
*/
if (!server->replication) {
msg = kill_pool_logins_server_error(server->pool, pkt);
disconnect_server(server, true, "%s", (char *)msg);
} else {
log_server_error("S: login failed", pkt);
disconnect_server(server, true, "login failed");
}
break;
/* packets that need closer look */
case PqMsg_AuthenticationRequest:
slog_debug(server, "calling login_answer");
res = answer_authreq(server, pkt);
if (!res)
disconnect_server(server, false, "failed to answer authreq");
break;
case PqMsg_ParameterStatus:
res = load_parameter(server, pkt, true);
break;
case PqMsg_ReadyForQuery:
if (server->exec_on_connect) {
server->exec_on_connect = false;
/* deliberately ignore transaction status */
} else if (server->pool->db->connect_query) {
server->exec_on_connect = true;
slog_debug(server, "server connect ok, send exec_on_connect");
SEND_generic(res, server, PqMsg_Query, "s", server->pool->db->connect_query);
if (!res)
disconnect_server(server, false, "exec_on_connect query failed");
break;
}
/* login ok */
slog_debug(server, "server login ok, start accepting queries");
server->ready = true;
/* got all params */
finish_welcome_msg(server);
/* need to notify sbuf if server was closed */
res = release_server(server);
/* let the takeover process handle it */
if (res && server->pool->db->admin)
res = takeover_login(server);
break;
/* ignorable packets */
case PqMsg_BackendKeyData:
if (!mbuf_get_bytes(&pkt->data, BACKENDKEY_LEN, &ckey)) {
disconnect_server(server, true, "bad cancel key");
return false;
}
memcpy(server->cancel_key, ckey, BACKENDKEY_LEN);
res = true;
break;
case PqMsg_NoticeResponse:
slog_noise(server, "skipping pkt: %c", pkt_desc(pkt));
res = true;
break;
}
if (res)
sbuf_prepare_skip(sbuf, pkt->len);
return res;
}
/*
* connection_pool_mode returns the pool_mode for the server. It specifically
* forces session pooling if the server is a replication connection, because
* replication connections require session pooling to work correctly.
*/
int connection_pool_mode(PgSocket *connection)
{
if (connection->replication)
return POOL_SESSION;
return probably_wrong_pool_pool_mode(connection->pool);
}
/*
* probably_wrong_pool_pool_mode returns the pool_mode for the pool.
*
* IMPORTANT: You should almost certainly not use this function directly,
* because the pool_mode of a pool is not necessarily the same as the pool mode
* of each of the clients and servers in the pool. Most importantly replication
* connections in a transaction/statement pool will still use session pooling.
*
* Normally you should use connection_pool_mode()
*/
int probably_wrong_pool_pool_mode(PgPool *pool)
{
int pool_mode = pool->user_credentials->global_user->pool_mode;
if (pool_mode == POOL_INHERIT)
pool_mode = pool->db->pool_mode;
if (pool_mode == POOL_INHERIT)
pool_mode = cf_pool_mode;
return pool_mode;
}
int pool_pool_size(PgPool *pool)
{
int user_pool_size = pool->user_credentials ? pool->user_credentials->global_user->pool_size : -1;
if (user_pool_size >= 0)
return user_pool_size;
else if (pool->db->pool_size >= 0)
return pool->db->pool_size;
else
return cf_default_pool_size;
}
/* min_pool_size of the pool's db */
int pool_min_pool_size(PgPool *pool)
{
return database_min_pool_size(pool->db);
}
/* server_lifetime of the pool's db */
usec_t pool_server_lifetime(PgPool *pool)
{
if (pool->db->server_lifetime == 0)
return cf_server_lifetime;
else
return pool->db->server_lifetime;
}
/* min_pool_size of the db */
int database_min_pool_size(PgDatabase *db)
{
if (db->min_pool_size < 0)
return cf_min_pool_size;
else
return db->min_pool_size;
}
int pool_res_pool_size(PgPool *pool)
{
int user_res_pool_size = pool->user_credentials ? pool->user_credentials->global_user->res_pool_size : -1;
if (user_res_pool_size >= 0)
return user_res_pool_size;
else if (pool->db->res_pool_size >= 0)
return pool->db->res_pool_size;
else
return cf_res_pool_size;
}
int database_max_client_connections(PgDatabase *db)
{
if (db->max_db_client_connections <= 0)
return cf_max_db_client_connections;
else
return db->max_db_client_connections;
}
int database_max_connections(PgDatabase *db)
{
if (db->max_db_connections <= 0)
return cf_max_db_connections;
else
return db->max_db_connections;
}
int user_max_connections(PgGlobalUser *user)
{
if (user->max_user_connections <= 0)
return cf_max_user_connections;
else
return user->max_user_connections;
}
int user_client_max_connections(PgGlobalUser *user)
{
if (user->max_user_client_connections <= 0)
return cf_max_user_client_connections;
else
return user->max_user_client_connections;
}
/* process packets on logged in connection */
static bool handle_server_work(PgSocket *server, PktHdr *pkt)
{
bool ready = false;
bool idle_tx = false;
char state;
SBuf *sbuf = &server->sbuf;
PgSocket *client = server->link;
bool async_response = false;
struct List *item, *tmp;
bool ignore_packet = false;
Assert(!server->pool->db->admin);
switch (pkt->type) {
default:
slog_error(server, "unknown pkt: '%c'", pkt_desc(pkt));
disconnect_server(server, true, "unknown pkt");
return false;
/* pooling decisions will be based on this packet */
case PqMsg_ReadyForQuery:
/* if partial pkt, wait */
if (!mbuf_get_char(&pkt->data, &state))
return false;
if (!pop_outstanding_request(server, (char[]) {PqMsg_Sync, PqMsg_Query, PqMsg_FunctionCall, '\0'}, &ignore_packet)
&& server->query_failed) {
if (!clear_outstanding_requests_until(server, (char[]) {PqMsg_Sync, '\0'}))
return false;
}
server->query_failed = false;
/* set ready only if no tx */
if (state == 'I') {
ready = true;
} else if (connection_pool_mode(server) == POOL_STMT) {
disconnect_server(server, true, "transaction blocks not allowed in statement pooling mode");
return false;
} else if (state == 'T' || state == 'E') {
idle_tx = true;
}
break;
case PqMsg_ParameterStatus:
if (!load_parameter(server, pkt, false))
return false;
break;
/*
* ErrorResponse and NoticeResponse packets currently set ->ready to false. Correct would
* be to leave ->ready as-is, because overall TX state stays same.
* It matters for connections in IDLE or USED state which get dirty
* suddenly but should not as they are still usable.
*
* But the ErrorResponse or NoticeResponse packet between transactions signifies probably
* dying backend. It is better to tag server as dirty and drop
* it later.
*/
case PqMsg_ErrorResponse:
if (server->setting_vars) {
/*
* the SET and user query will be different TX
* so we cannot report SET error to user.
*/
log_server_error("varcache_apply failed", pkt);
/*
* client probably gave invalid values in startup pkt.
*
* no reason to keep such guys.
*/
disconnect_server(server, true, "invalid server parameter");
return false;
}
/* ErrorResponse and CommandComplete show end of copy mode */
if (server->copy_mode) {
slog_debug(server, "COPY failed");
server->copy_mode = false;
/*
* Clear until next CopyDone or CopyFail message in the
* queue. This is needed to remove any Sync messages
* from the outstanding requests queue, for which we
* don't expect a response from the server.
*
* It isn't a problem if the CopyDone or CopyFail
* message has not been received yet. This message will
* be removed from the queue later when the server
* sends a ReadyForQuery message and we clear the queue
* until the next Sync.
*
* NOTE: CopyFail is the obvious error case, because
* here the client triggers a failure of the COPY.
* But CopyDone is also included in the search. The
* reason for that being that the server might fail the
* COPY for some reason unknown to the client (e.g. a
* unique constraint violation).
*/
if (!clear_outstanding_requests_until(server, (char[]) {PqMsg_CopyDone, PqMsg_CopyFail, '\0'}))
return false;
}
server->query_failed = true;
break;
case PqMsg_CommandComplete:
/* ErrorResponse and CommandComplete show end of copy mode */
if (server->copy_mode) {
slog_debug(server, "COPY finished");
server->copy_mode = false;
/*
* Clear until next CopyDone message in the queue. This
* is needed to remove any Sync messages from the
* outstanding requests queue, for which we don't
* expect a response from the server.
*/
if (!clear_outstanding_requests_until(server, (char[]) {PqMsg_CopyDone, '\0'}))
return false;
}
/*
* Clean up prepared statements if needed if the client sent a
* DEALLOCATE ALL or a DISCARD ALL query. Not doing so would
* confuse our prepared statement handling, because we would
* expect certain queries to be prepared at the server that are
* not.
*/
if (is_prepared_statements_enabled(server)
&& (pkt->len == 1 + 4 + 15 || pkt->len == 1 + 4 + 12)) { /* size of complete DEALLOCATE/DISCARD ALL */
const char *tag;
if (mbuf_get_string(&pkt->data, &tag)) {
if (strcmp(tag, "DEALLOCATE ALL") == 0 ||
strcmp(tag, "DISCARD ALL") == 0) {
free_server_prepared_statements(server);
if (client)
free_client_prepared_statements(client);
}
} else {
return false;
}
}
pop_outstanding_request(server, (char[]) {PqMsg_Execute, '\0'}, &ignore_packet);
break;
case PqMsg_NoticeResponse:
break;
/* reply to LISTEN, don't change connection state */
case PqMsg_NotificationResponse:
idle_tx = server->idle_tx;
ready = server->ready;
async_response = true;
break;
/* copy mode */
case PqMsg_CopyInResponse:
case PqMsg_CopyBothResponse:
slog_debug(server, "COPY started");
server->copy_mode = true;
break;
case PqMsg_CopyOutResponse:
break;
/* chat packets */
case PqMsg_ParseComplete:
pop_outstanding_request(server, (char[]) {PqMsg_Parse, '\0'}, &ignore_packet);
break;
case PqMsg_BindComplete:
pop_outstanding_request(server, (char[]) {PqMsg_Bind, '\0'}, &ignore_packet);
break;
case PqMsg_CloseComplete:
pop_outstanding_request(server, (char[]) {PqMsg_Close, '\0'}, &ignore_packet);
break;
case PqMsg_NoData:
case PqMsg_RowDescription:
pop_outstanding_request(server, (char[]) {PqMsg_Describe, '\0'}, &ignore_packet);
break;
case PqMsg_ParameterDescription:
case PqMsg_CopyDone:
case PqMsg_CopyFail:
case PqMsg_FunctionCallResponse:
break;
case PqMsg_EmptyQueryResponse: /* EmptyQueryResponse is similar to CommandComplete, which is handled above */
case PqMsg_PortalSuspended:
pop_outstanding_request(server, (char[]) {PqMsg_Execute, '\0'}, &ignore_packet);
break;
/* data packets, there will be more coming */
case PqMsg_CopyData:
case PqMsg_DataRow:
break;
}
server->idle_tx = idle_tx;
server->ready = ready;
server->pool->stats.server_bytes += pkt->len;
if (server->setting_vars) {
Assert(client);
sbuf_prepare_skip(sbuf, pkt->len);
} else if (client) {
if (client->state == CL_LOGIN) {
return handle_auth_query_response(client, pkt);
} else if (ignore_packet) {
slog_noise(server, "not forwarding packet with type '%c' from server", pkt->type);
sbuf_prepare_skip(sbuf, pkt->len);
} else {
sbuf_prepare_send(sbuf, &client->sbuf, pkt->len);
/*
* Compute query and transaction times
*
* For pipelined overlapping commands, we wait until
* the last command is done (outstanding_requests==0).
* That means, we count the time that PgBouncer is
* occupied in a series of pipelined commands, not the
* total time that all commands/queries take
* individually. For that, we would have to track the
* start time of each command separately in queue or
* similar, not only per client. (which would probably
* be a good future improvement)
*/
if (statlist_count(&server->outstanding_requests) == 0) {
/* every statement (independent or in a transaction) counts as a query */
if (ready || idle_tx) {
if (client->query_start) {
usec_t total;
total = get_cached_time() - client->query_start;
client->query_start = 0;
server->pool->stats.query_time += total;
slog_debug(client, "query time: %d us", (int)total);
} else if (!async_response) {
slog_warning(client, "FIXME: query end, but query_start == 0");
Assert(false);
}
}
/* statement ending in "idle" ends a transaction */
if (ready) {
if (client->xact_start) {
usec_t total;
total = get_cached_time() - client->xact_start;
client->xact_start = 0;
server->pool->stats.xact_time += total;
slog_debug(client, "transaction time: %d us", (int)total);
} else if (!async_response) {
/* XXX This happens during takeover if the new process
* continues a transaction. */
slog_warning(client, "FIXME: transaction end, but xact_start == 0");
}
}
}
statlist_for_each_safe(item, &server->outstanding_requests, tmp) {
OutstandingRequest *request = container_of(item, OutstandingRequest, node);
if (request->action != RA_FAKE)
break;
statlist_pop(&server->outstanding_requests);
sbuf->extra_packet_queue_after = true;
if (!queue_fake_response(client, request->type)) {
/*
* The only reason the above could have failed is because
* of allocation errors. To actually be able to retry after
* these failures the next round we would need to restore
* the outstanding_requests queue to how it was before.
* Instead of doing that, we take the easy and known
* correct way out: Simply disconnecting the involved
* client and server.
*/
disconnect_client(client, true, "out of memory");
disconnect_server(client->link, true, "out of memory");
return false;
}
slab_free(outstanding_request_cache, request);
}
}
} else {
if (server->state != SV_TESTED) {
slog_warning(server,
"got packet '%c' from server when not linked",
pkt_desc(pkt));
}
sbuf_prepare_skip(sbuf, pkt->len);
}
return true;
}
/* got connection, decide what to do */
static bool handle_connect(PgSocket *server)
{
bool res = false;
PgPool *pool = server->pool;
char buf[PGADDR_BUF + 32];
bool is_unix = pga_is_unix(&server->remote_addr);
fill_local_addr(server, sbuf_socket(&server->sbuf), is_unix);
if (cf_log_connections) {
if (pga_is_unix(&server->remote_addr)) {
slog_info(server, "new connection to server");
} else {
slog_info(server, "new connection to server (from %s)",
pga_str(&server->local_addr, buf, sizeof(buf)));
}
}
/*
* If there are cancel requests waiting we first handle those. By handling
* these first we reduce the load on the server and we a server connection
* might actually become free to use for queries, because its query got
* canceled.
*
* Only if there are no cancel requests we proceed with the login procedure
* that's necessary to handle queries. Cancel requests need to be sent
* before the login procedure starts.
*
* A special case is when this is a peer pool, instead of a regular pool.
* Since only cancellation requests should be sent to peers.
*/
if (!statlist_empty(&pool->waiting_cancel_req_list)) {
slog_debug(server, "use it for pending cancel req");
if (forward_cancel_request(server)) {
change_server_state(server, SV_ACTIVE_CANCEL);
sbuf_continue(&server->sbuf);
} else {
/* notify disconnect_server() that connect did not fail */
server->ready = true;
disconnect_server(server, false, "failed to send cancel req");
}
} else if (pool->db->peer_id) {
/* notify disconnect_server() that connect did not fail */
server->ready = true;
disconnect_server(server, false, "peer server was not necessary anymore, because client cancel connection was already closed");
} else {
/* proceed with login */
if (server_connect_sslmode > SSLMODE_DISABLED && !is_unix) {
slog_noise(server, "P: SSL request");
res = send_sslreq_packet(server);
if (res)
server->wait_sslchar = true;
} else {
slog_noise(server, "P: startup");
res = send_startup_packet(server);
}
if (!res)
disconnect_server(server, false, "startup pkt failed");
}
return res;
}
static bool handle_sslchar(PgSocket *server, struct MBuf *data)
{
uint8_t schar = '?';
bool ok;
server->wait_sslchar = false;
ok = mbuf_get_byte(data, &schar);
if (!ok || (schar != 'S' && schar != 'N')) {
disconnect_server(server, false, "bad sslreq answer");
return false;
}
/*
* At this point we should have no data already buffered. If
* we do, it was received before we performed the SSL
* handshake, so it wasn't encrypted and indeed may have been
* injected by a man-in-the-middle.
*/
if (mbuf_avail_for_read(data) != 0) {
disconnect_server(server, false, "received unencrypted data after SSL response");
return false;
}
if (schar == 'S') {
slog_noise(server, "launching tls");
ok = sbuf_tls_connect(&server->sbuf, server->pool->db->host);
} else if (server_connect_sslmode >= SSLMODE_REQUIRE) {
disconnect_server(server, false, "server refused SSL");
return false;
} else {
/* proceed with non-TLS connection */
ok = send_startup_packet(server);
}
if (ok) {
sbuf_prepare_skip(&server->sbuf, 1);
} else {
disconnect_server(server, false, "sslreq processing failed");
}
return ok;
}
/* callback from SBuf */
bool server_proto(SBuf *sbuf, SBufEvent evtype, struct MBuf *data)
{
bool res = false;
PgSocket *server = container_of(sbuf, PgSocket, sbuf);
PgPool *pool = server->pool;
PktHdr pkt;
char infobuf[96];
Assert(is_server_socket(server));
Assert(server->state != SV_FREE);
/* may happen if close failed */
if (server->state == SV_JUSTFREE)
return false;
switch (evtype) {
case SBUF_EV_RECV_FAILED:
if (server->state == SV_ACTIVE_CANCEL)
disconnect_server(server, false, "successfully sent cancel request");
else
disconnect_server(server, false, "server conn crashed?");
break;
case SBUF_EV_SEND_FAILED:
disconnect_client(server->link, false, "unexpected eof");
break;
case SBUF_EV_READ:
if (server->wait_sslchar) {
res = handle_sslchar(server, data);
break;
}
if (incomplete_header(data)) {
slog_noise(server, "S: got partial header, trying to wait a bit");
break;
}
/* parse pkt header */
if (!get_header(data, &pkt)) {
disconnect_server(server, true, "bad pkt header");
break;
}
slog_noise(server, "read pkt='%c', len=%u", pkt_desc(&pkt), pkt.len);
server->request_time = get_cached_time();
switch (server->state) {
case SV_LOGIN:
res = handle_server_startup(server, &pkt);
break;
case SV_TESTED:
case SV_USED:
case SV_ACTIVE:
case SV_ACTIVE_CANCEL:
case SV_BEING_CANCELED:
case SV_IDLE:
res = handle_server_work(server, &pkt);
break;
default:
fatal("server_proto: server in bad state: %d", server->state);
}
break;
case SBUF_EV_CONNECT_FAILED:
Assert(server->state == SV_LOGIN);
disconnect_server(server, false, "connect failed");
break;
case SBUF_EV_CONNECT_OK:
slog_debug(server, "S: connect ok");
Assert(server->state == SV_LOGIN);
server->request_time = get_cached_time();
res = handle_connect(server);
break;
case SBUF_EV_FLUSH:
res = true;
if (!server->ready)
break;
if (server->setting_vars) {
PgSocket *client = server->link;
Assert(client);
/*
* It's possible that the client vars and server vars have
* different string representations, but still Postgres did not
* send a ParameterStatus packet. This happens when the server
* variable is the canonical version of the client variable, i.e.
* they mean the same just written slightly different. To make sure
* that the canonical version is also stored in the client, we now
* copy the server variables over to the client variables.
* See issue #776 for an example of this.
*/
varcache_set_canonical(server, client);
server->setting_vars = false;
log_noise("done setting vars unpausing client");
sbuf_continue(&client->sbuf);
break;
}
if (connection_pool_mode(server) != POOL_SESSION || server->state == SV_TESTED || server->resetting) {
server->resetting = false;
switch (server->state) {
case SV_ACTIVE:
case SV_ACTIVE_CANCEL:
case SV_TESTED:
/* keep link if client expects more responses */
if (server->link) {
if (statlist_count(&server->outstanding_requests) > 0)
break;
}
/* retval does not matter here */
release_server(server);
break;
default:
slog_warning(server, "EV_FLUSH with state=%d", server->state);
case SV_BEING_CANCELED:
case SV_IDLE:
break;
}
}
break;
case SBUF_EV_PKT_CALLBACK:
slog_warning(server, "SBUF_EV_PKT_CALLBACK with state=%d", server->state);
break;
case SBUF_EV_TLS_READY:
Assert(server->state == SV_LOGIN);
tls_get_connection_info(server->sbuf.tls, infobuf, sizeof infobuf);
if (cf_log_connections) {
slog_info(server, "SSL established: %s", infobuf);
} else {
slog_noise(server, "SSL established: %s", infobuf);
}
server->request_time = get_cached_time();
res = send_startup_packet(server);
if (res)
sbuf_continue(&server->sbuf);
else
disconnect_server(server, false, "TLS startup failed");
break;
}
if (!res && pool->db->admin)
takeover_login_failed();
return res;
}
pgbouncer-1.24.1/src/hba.c 0000644 0001750 0000000 00000052200 14777762222 012173 0000000 0000000 /*
* Host-Based-Access-control file support.
*
* Copyright (c) 2015 Marko Kreen
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "bouncer.h"
#include
#include
#include
#include
#include
/*
* StrSet
*/
struct StrSetNode {
unsigned int s_len;
char s_val[FLEX_ARRAY];
};
struct StrSet {
CxMem *pool;
unsigned count;
unsigned alloc;
struct StrSetNode **nodes;
struct CBTree *cbtree;
};
struct StrSet *strset_new(CxMem *cx);
void strset_free(struct StrSet *set);
bool strset_add(struct StrSet *set, const char *str, unsigned int len);
bool strset_contains(struct StrSet *set, const char *str, unsigned int len);
struct StrSet *strset_new(CxMem *cx)
{
struct StrSet *set;
CxMem *pool;
pool = cx_new_pool(cx, 1024, 0);
if (!pool)
return NULL;
set = cx_alloc(pool, sizeof *set);
if (!set)
return NULL;
set->pool = pool;
set->cbtree = NULL;
set->count = 0;
set->alloc = 10;
set->nodes = cx_alloc0(pool, set->alloc * sizeof(struct StrSet *));
if (!set->nodes) {
cx_destroy(pool);
return NULL;
}
return set;
}
static size_t strset_node_key(void *ctx, void *obj, const void **ptr_p)
{
struct StrSetNode *node = obj;
*ptr_p = node->s_val;
return node->s_len;
}
bool strset_add(struct StrSet *set, const char *str, unsigned int len)
{
struct StrSetNode *node;
unsigned int i;
bool ok;
if (strset_contains(set, str, len))
return true;
node = cx_alloc(set->pool, offsetof(struct StrSetNode, s_val) + len + 1);
if (!node)
return false;
node->s_len = len;
memcpy(node->s_val, str, len);
node->s_val[len] = 0;
if (set->count < set->alloc) {
set->nodes[set->count++] = node;
return true;
}
if (!set->cbtree) {
set->cbtree = cbtree_create(strset_node_key, NULL, set, set->pool);
if (!set->cbtree)
return false;
for (i = 0; i < set->count; i++) {
ok = cbtree_insert(set->cbtree, set->nodes[i]);
if (!ok)
return false;
}
}
ok = cbtree_insert(set->cbtree, node);
if (!ok)
return false;
set->count++;
return true;
}
bool strset_contains(struct StrSet *set, const char *str, unsigned int len)
{
unsigned int i;
struct StrSetNode *node;
if (set->cbtree)
return cbtree_lookup(set->cbtree, str, len) != NULL;
for (i = 0; i < set->count; i++) {
node = set->nodes[i];
if (node->s_len != len)
continue;
if (memcmp(node->s_val, str, len) == 0)
return true;
}
return false;
}
void strset_free(struct StrSet *set)
{
if (set)
cx_destroy(set->pool);
}
/*
* Parse HBA tokens.
*/
enum TokType {
TOK_STRING,
TOK_IDENT,
TOK_COMMA,
TOK_FAIL,
TOK_EOL
};
struct TokParser {
const char *pos;
enum TokType cur_tok;
char *cur_tok_str;
char *buf;
size_t buflen;
};
static bool tok_buf_check(struct TokParser *p, size_t len)
{
size_t tmplen;
char *tmp;
if (p->buflen >= len)
return true;
tmplen = len*2;
tmp = realloc(p->buf, tmplen);
if (!tmp)
return false;
p->buf = tmp;
p->buflen = tmplen;
return true;
}
static enum TokType next_token(struct TokParser *p)
{
const char *s, *s2;
char *dst;
if (p->cur_tok == TOK_EOL)
return TOK_EOL;
p->cur_tok_str = NULL;
p->cur_tok = TOK_FAIL;
while (p->pos[0] && isspace((unsigned char)p->pos[0]))
p->pos++;
if (p->pos[0] == '#' || p->pos[0] == '\0') {
p->cur_tok = TOK_EOL;
p->pos = NULL;
} else if (p->pos[0] == ',') {
p->cur_tok = TOK_COMMA;
p->pos++;
} else if (p->pos[0] == '"') {
for (s = p->pos + 1; s[0]; s++) {
if (s[0] == '"') {
if (s[1] == '"')
s++;
else
break;
}
}
if (s[0] != '"' || !tok_buf_check(p, s - p->pos))
return TOK_FAIL;
dst = p->buf;
for (s2 = p->pos + 1; s2 < s; s2++) {
*dst++ = *s2;
if (*s2 == '"') s2++;
}
*dst = 0;
p->pos = s + 1;
p->cur_tok = TOK_STRING;
p->cur_tok_str = p->buf;
} else {
for (s = p->pos + 1; *s; s++) {
if (*s == ',' || *s == '#' || *s == '"')
break;
if (isspace((unsigned char)*s))
break;
}
if (!tok_buf_check(p, s - p->pos + 1))
return TOK_FAIL;
memcpy(p->buf, p->pos, s - p->pos);
p->buf[s - p->pos] = 0;
p->pos = s;
p->cur_tok = TOK_IDENT;
p->cur_tok_str = p->buf;
}
return p->cur_tok;
}
static bool eat(struct TokParser *p, enum TokType ttype)
{
if (p->cur_tok == ttype) {
next_token(p);
return true;
}
return false;
}
static bool eat_kw(struct TokParser *p, const char *kw)
{
if (p->cur_tok == TOK_IDENT && strcmp(kw, p->cur_tok_str) == 0) {
next_token(p);
return true;
}
return false;
}
static bool expect(struct TokParser *tp, enum TokType ttype, const char **str_p)
{
if (tp->cur_tok == ttype) {
*str_p = tp->buf;
return true;
}
return false;
}
static char *path_join(const char *p1, const char *p2)
{
size_t len1, len2;
char *res = NULL, *pos;
if (p2[0] == '/' || p1[0] == 0 || !memcmp(p1, ".", 2))
return strdup(p2);
len1 = strlen(p1);
len2 = strlen(p2);
res = malloc(len1 + len2 + 2 + 1);
if (res) {
memcpy(res, p1, len1);
pos = res + len1;
if (pos[-1] != '/')
*pos++ = '/';
memcpy(pos, p2, len2 + 1);
}
return res;
}
static char *path_join_dirname(const char *parent, const char *fn)
{
char *tmp, *res;
const char *basedir;
if (fn[0] == '/')
return strdup(fn);
tmp = strdup(parent);
if (!tmp)
return NULL;
basedir = dirname(tmp);
res = path_join(basedir, fn);
free(tmp);
return res;
}
static void init_parser(struct TokParser *p)
{
memset(p, 0, sizeof(*p));
}
static void parse_from_string(struct TokParser *p, const char *str)
{
p->pos = str;
p->cur_tok = TOK_COMMA;
p->cur_tok_str = NULL;
next_token(p);
}
static void free_parser(struct TokParser *p)
{
free(p->buf);
p->buf = NULL;
}
static bool parse_names(struct HBAName *hname, struct TokParser *p, bool is_db, const char *parent_filename);
static bool parse_ident_name(const char **ident_name, struct TokParser *tp, bool *is_name_all);
static bool parse_namefile(struct HBAName *hname, const char *fn, bool is_db)
{
FILE *f;
ssize_t len;
char *ln = NULL;
size_t buflen = 0;
bool ok = false;
struct TokParser tp;
init_parser(&tp);
f = fopen(fn, "r");
if (!f) {
return false;
}
for (;;) {
len = getline(&ln, &buflen, f);
if (len < 0) {
ok = true;
break;
}
parse_from_string(&tp, ln);
if (!parse_names(hname, &tp, is_db, fn))
break;
}
free_parser(&tp);
free(ln);
fclose(f);
return ok;
}
static bool parse_ident_name(const char **ident_name, struct TokParser *tp, bool *is_name_all)
{
if (eat_kw(tp, "all")) {
*is_name_all = true;
return true;
}
if (!expect(tp, TOK_IDENT, ident_name)) {
if (!expect(tp, TOK_STRING, ident_name)) {
return false;
}
}
return true;
}
static bool parse_names(struct HBAName *hname, struct TokParser *tp, bool is_db, const char *parent_filename)
{
const char *tok;
while (1) {
if (eat_kw(tp, "all")) {
hname->flags |= NAME_ALL;
goto eat_comma;
}
if (is_db) {
if (eat_kw(tp, "sameuser")) {
hname->flags |= NAME_SAMEUSER;
goto eat_comma;
}
if (eat_kw(tp, "samerole")) {
log_warning("samerole is not supported");
return false;
}
if (eat_kw(tp, "samegroup")) {
log_warning("samegroup is not supported");
return false;
}
if (eat_kw(tp, "replication")) {
hname->flags |= NAME_REPLICATION;
goto eat_comma;
}
}
if (expect(tp, TOK_IDENT, &tok)) {
if (tok[0] == '+') {
return false;
}
if (tok[0] == '@') {
bool ok;
char *fn;
fn = path_join_dirname(parent_filename, tok + 1);
if (!fn)
return false;
ok = parse_namefile(hname, fn, is_db);
free(fn);
if (!ok)
return false;
next_token(tp);
goto eat_comma;
}
/* fallthrough */
} else if (expect(tp, TOK_STRING, &tok)) {
/* fallthrough */
} else {
return false;
}
/*
* TOK_IDENT or TOK_STRING as plain name.
*/
if (!hname->name_set) {
hname->name_set = strset_new(NULL);
if (!hname->name_set)
return false;
}
if (!strset_add(hname->name_set, tok, strlen(tok)))
return false;
next_token(tp);
eat_comma:
if (!eat(tp, TOK_COMMA))
break;
}
return true;
}
static void rule_free(struct HBARule *rule)
{
strset_free(rule->db_name.name_set);
strset_free(rule->user_name.name_set);
free(rule);
}
static bool parse_addr(struct HBAAddress *haddress, const char *addr)
{
if (inet_pton(AF_INET6, addr, haddress->addr)) {
haddress->family = AF_INET6;
} else if (inet_pton(AF_INET, addr, haddress->addr)) {
haddress->family = AF_INET;
} else {
return false;
}
return true;
}
static bool parse_nmask(struct HBAAddress *haddress, const char *nmask)
{
char *end = NULL;
unsigned long bits;
unsigned int i;
errno = 0;
bits = strtoul(nmask, &end, 10);
if (errno || *end) {
return false;
}
if (haddress->family == AF_INET && bits > 32) {
return false;
}
if (haddress->family == AF_INET6 && bits > 128) {
return false;
}
for (i = 0; i < bits/8; i++)
haddress->mask[i] = 255;
if (bits % 8)
haddress->mask[i] = 255 << (8 - (bits % 8));
return true;
}
static bool bad_mask(struct HBAAddress *haddress)
{
int i, bytes = haddress->family == AF_INET ? 4 : 16;
uint8_t res = 0;
for (i = 0; i < bytes; i++)
res |= haddress->addr[i] & (255 ^ haddress->mask[i]);
return !!res;
}
static bool match_map(struct HBARule *rule, struct Ident *ident, const char *mapname)
{
struct List *el;
struct IdentMap *map;
if (!ident)
return false;
list_for_each(el, &ident->maps) {
map = container_of(el, struct IdentMap, node);
if (strcmp(map->map_name, mapname) == 0) {
rule->identmap = map;
return true;
}
}
return false;
}
static bool parse_map_definition(struct HBARule *rule, struct Ident *ident, struct TokParser *tp, int linenr)
{
const char *str;
char *val;
if (!expect(tp, TOK_IDENT, &str))
return true;
val = strchr(str, '=');
if (val == NULL || strncmp(str, "map=", 4) != 0) {
log_warning("hba line %d: Ident map %s is malformed. It is not in map=value format.", linenr, str);
return false;
}
val++;
next_token(tp);
if (!match_map(rule, ident, val)) {
log_warning("hba line %d: Ident map %s is not found in ident config file", linenr, val);
return false;
}
return true;
}
static void mapping_free(struct Mapping *mapping)
{
free(mapping->system_user_name);
free(mapping->postgres_user_name);
free(mapping);
}
static void ident_map_free(struct IdentMap *ident_map)
{
struct List *el, *tmp;
struct Mapping *mapping;
if (!ident_map)
return;
list_for_each_safe(el, &ident_map->mappings, tmp) {
mapping = container_of(el, struct Mapping, node);
list_del(&mapping->node);
mapping_free(mapping);
}
free(ident_map->map_name);
free(ident_map);
}
static bool find_ident_map(struct Ident *ident, const char *mapname, struct IdentMap **ident_map)
{
struct List *el;
list_for_each(el, &ident->maps) {
*ident_map = container_of(el, struct IdentMap, node);
if (!strcmp((*ident_map)->map_name, mapname))
return true;
}
return false;
}
static bool parse_ident_line(struct Ident *ident, struct TokParser *tp, int linenr)
{
const char *map_name = NULL;
char *map_name_copy = NULL;
const char *system_user_name = NULL;
const char *postgres_user_name = NULL;
struct IdentMap *ident_map = NULL;
struct Mapping *mapping = NULL;
bool is_name_all = false;
if (eat(tp, TOK_EOL)) {
return true;
}
mapping = calloc(1, sizeof(*mapping));
if (!mapping) {
log_warning("ident: no mem for parsing mapping");
return false;
}
if (!expect(tp, TOK_IDENT, &map_name)) {
goto failed;
}
map_name_copy = strdup(map_name);
if (!map_name_copy) {
log_warning("ident: no mem for map_name");
goto failed;
}
next_token(tp);
if (!expect(tp, TOK_IDENT, &system_user_name)) {
if (!expect(tp, TOK_STRING, &system_user_name))
goto failed;
}
mapping->system_user_name = strdup(system_user_name);
if (!mapping->system_user_name) {
log_warning("ident: no mem for system_user_name");
goto failed;
}
next_token(tp);
if (!parse_ident_name(&postgres_user_name, tp, &is_name_all)) {
goto failed;
}
if (is_name_all) {
mapping->name_flags |= NAME_ALL;
} else {
mapping->postgres_user_name = strdup(postgres_user_name);
if (!mapping->postgres_user_name) {
log_warning("ident: no mem for postgres_user_name");
goto failed;
}
}
next_token(tp);
if (!eat(tp, TOK_EOL)) {
log_warning("ident line %d: unsupported parameters", linenr);
goto failed;
}
if (find_ident_map(ident, map_name_copy, &ident_map)) {
list_append(&ident_map->mappings, &mapping->node);
free(map_name_copy);
map_name_copy = NULL;
} else {
ident_map = calloc(1, sizeof(*ident_map));
if (!ident_map) {
log_warning("ident: no mem for parsing ident_map");
goto failed;
}
ident_map->map_name = map_name_copy;
map_name_copy = NULL;
list_init(&ident_map->mappings);
list_append(&ident_map->mappings, &mapping->node);
list_append(&ident->maps, &ident_map->node);
}
return true;
failed:
mapping_free(mapping);
ident_map_free(ident_map);
free(map_name_copy);
return false;
}
static bool parse_line(struct HBA *hba, struct Ident *ident, struct TokParser *tp, int linenr, const char *parent_filename)
{
const char *addr = NULL, *mask = NULL;
enum RuleType rtype;
char *nmask = NULL;
struct HBARule *rule = NULL;
if (eat_kw(tp, "local")) {
rtype = RULE_LOCAL;
} else if (eat_kw(tp, "host")) {
rtype = RULE_HOST;
} else if (eat_kw(tp, "hostssl")) {
rtype = RULE_HOSTSSL;
} else if (eat_kw(tp, "hostnossl")) {
rtype = RULE_HOSTNOSSL;
} else if (eat(tp, TOK_EOL)) {
return true;
} else {
log_warning("hba line %d: unknown type", linenr);
return false;
}
rule = calloc(1, sizeof(*rule));
if (!rule) {
log_warning("hba: no mem for rule");
return false;
}
rule->rule_type = rtype;
if (!parse_names(&rule->db_name, tp, true, parent_filename))
goto failed;
if (!parse_names(&rule->user_name, tp, true, parent_filename))
goto failed;
if (rtype == RULE_LOCAL) {
rule->address.family = AF_UNIX;
} else if (eat_kw(tp, "all")) {
rule->address.flags |= ADDRESS_ALL;
} else {
if (!expect(tp, TOK_IDENT, &addr)) {
log_warning("hba line %d: did not find address - %d - '%s'", linenr, tp->cur_tok, tp->buf);
goto failed;
}
nmask = strchr(addr, '/');
if (nmask) {
*nmask++ = 0;
}
if (!parse_addr(&rule->address, addr)) {
log_warning("hba line %d: failed to parse address - %s", linenr, addr);
goto failed;
}
if (nmask) {
if (!parse_nmask(&rule->address, nmask)) {
log_warning("hba line %d: invalid mask", linenr);
goto failed;
}
next_token(tp);
} else {
next_token(tp);
if (!expect(tp, TOK_IDENT, &mask)) {
log_warning("hba line %d: did not find mask", linenr);
goto failed;
}
if (!inet_pton(rule->address.family, mask, rule->address.mask)) {
log_warning("hba line %d: failed to parse mask: %s", linenr, mask);
goto failed;
}
next_token(tp);
}
if (bad_mask(&rule->address)) {
char buf1[128], buf2[128];
log_warning("address does not match mask in %s line #%d: %s / %s", parent_filename, linenr,
inet_ntop(rule->address.family, rule->address.addr, buf1, sizeof buf1),
inet_ntop(rule->address.family, rule->address.mask, buf2, sizeof buf2));
}
}
if (eat_kw(tp, "trust")) {
rule->rule_method = AUTH_TYPE_TRUST;
} else if (eat_kw(tp, "reject")) {
rule->rule_method = AUTH_TYPE_REJECT;
} else if (eat_kw(tp, "md5")) {
rule->rule_method = AUTH_TYPE_MD5;
} else if (eat_kw(tp, "password")) {
rule->rule_method = AUTH_TYPE_PLAIN;
} else if (eat_kw(tp, "peer")) {
rule->rule_method = AUTH_TYPE_PEER;
} else if (eat_kw(tp, "cert")) {
rule->rule_method = AUTH_TYPE_CERT;
} else if (eat_kw(tp, "scram-sha-256")) {
rule->rule_method = AUTH_TYPE_SCRAM_SHA_256;
} else {
log_warning("hba line %d: unsupported method: buf=%s", linenr, tp->buf);
goto failed;
}
if (!parse_map_definition(rule, ident, tp, linenr)) {
goto failed;
}
if (!eat(tp, TOK_EOL)) {
log_warning("hba line %d: unsupported parameters", linenr);
goto failed;
}
rule->hba_linenr = linenr;
list_append(&hba->rules, &rule->node);
return true;
failed:
rule_free(rule);
return false;
}
struct Ident *ident_load_map(const char *fn)
{
struct Ident *ident = NULL;
FILE *f = NULL;
char *ln = NULL;
size_t lnbuf = 0;
ssize_t len;
int linenr;
struct TokParser tp;
if (fn == NULL)
return NULL;
init_parser(&tp);
ident = malloc(sizeof *ident);
if (!ident)
goto out;
list_init(&ident->maps);
f = fopen(fn, "r");
if (!f) {
log_error("could not open ident config file %s: %s", fn, strerror(errno));
goto out;
}
for (linenr = 1; ; linenr++) {
len = getline(&ln, &lnbuf, f);
if (len < 0)
break;
parse_from_string(&tp, ln);
if (!parse_ident_line(ident, &tp, linenr)) {
/* Tell the admin where to look for the problem. */
log_warning("could not parse ident config line %d", linenr);
/* Ignore line, but parse to the end. */
continue;
}
}
out:
free_parser(&tp);
free(ln);
if (f)
fclose(f);
return ident;
}
struct HBA *hba_load_rules(const char *fn, struct Ident *ident)
{
struct HBA *hba = NULL;
FILE *f = NULL;
char *ln = NULL;
size_t lnbuf = 0;
ssize_t len;
int linenr;
struct TokParser tp;
init_parser(&tp);
hba = malloc(sizeof *hba);
if (!hba)
goto out;
list_init(&hba->rules);
f = fopen(fn, "r");
if (!f) {
log_error("could not open hba config file %s: %s", fn, strerror(errno));
goto out;
}
for (linenr = 1; ; linenr++) {
len = getline(&ln, &lnbuf, f);
if (len < 0)
break;
parse_from_string(&tp, ln);
if (!parse_line(hba, ident, &tp, linenr, fn)) {
/* Tell the admin where to look for the problem. */
log_warning("could not parse hba config line %d", linenr);
/* Ignore line, but parse to the end. */
continue;
}
}
out:
free_parser(&tp);
free(ln);
if (f)
fclose(f);
return hba;
}
void ident_free(struct Ident *ident)
{
struct List *el, *tmp;
struct IdentMap *map;
if (!ident)
return;
list_for_each_safe(el, &ident->maps, tmp) {
map = container_of(el, struct IdentMap, node);
list_del(&map->node);
ident_map_free(map);
}
free(ident);
}
void hba_free(struct HBA *hba)
{
struct List *el, *tmp;
struct HBARule *rule;
if (!hba)
return;
list_for_each_safe(el, &hba->rules, tmp) {
rule = container_of(el, struct HBARule, node);
list_del(&rule->node);
rule_free(rule);
}
free(hba);
}
static bool name_match(struct HBAName *hname, const char *name, unsigned int namelen, const char *pair)
{
if (hname->flags & NAME_ALL)
return true;
if ((hname->flags & NAME_SAMEUSER) && strcmp(name, pair) == 0)
return true;
if (hname->name_set)
return strset_contains(hname->name_set, name, namelen);
return false;
}
static bool match_inet4(const struct HBAAddress *haddress, PgAddr *addr)
{
const uint32_t *src, *base, *mask;
if (pga_family(addr) != AF_INET)
return false;
src = (uint32_t *)&addr->sin.sin_addr.s_addr;
base = (uint32_t *)haddress->addr;
mask = (uint32_t *)haddress->mask;
return (src[0] & mask[0]) == base[0];
}
static bool match_inet6(const struct HBAAddress *haddress, PgAddr *addr)
{
const uint32_t *src, *base, *mask;
if (pga_family(addr) != AF_INET6)
return false;
src = (uint32_t *)addr->sin6.sin6_addr.s6_addr;
base = (uint32_t *)haddress->addr;
mask = (uint32_t *)haddress->mask;
return (src[0] & mask[0]) == base[0] && (src[1] & mask[1]) == base[1] &&
(src[2] & mask[2]) == base[2] && (src[3] & mask[3]) == base[3];
}
static bool address_match(const struct HBAAddress *haddress, PgAddr *addr)
{
if (haddress->flags & ADDRESS_ALL)
return true;
switch (haddress->family) {
case AF_INET:
return match_inet4(haddress, addr);
case AF_INET6:
return match_inet6(haddress, addr);
default:
return false;
}
}
struct HBARule * hba_eval(struct HBA *hba, PgAddr *addr, bool is_tls, ReplicationType replication, const char *dbname, const char *username)
{
struct List *el;
struct HBARule *rule;
unsigned int dbnamelen = strlen(dbname);
unsigned int unamelen = strlen(username);
if (!hba)
return NULL;
list_for_each(el, &hba->rules) {
rule = container_of(el, struct HBARule, node);
/* match address */
if (pga_is_unix(addr)) {
if (rule->rule_type != RULE_LOCAL)
continue;
} else if (rule->rule_type == RULE_LOCAL) {
continue;
} else if (rule->rule_type == RULE_HOSTSSL && !is_tls) {
continue;
} else if (rule->rule_type == RULE_HOSTNOSSL && is_tls) {
continue;
} else if (!address_match(&rule->address, addr)) {
continue;
}
/* match db & user */
if (replication == REPLICATION_PHYSICAL) {
if (!(rule->db_name.flags & NAME_REPLICATION)) {
continue;
}
} else {
if (!name_match(&rule->db_name, dbname, dbnamelen, username))
continue;
}
if (!name_match(&rule->user_name, username, unamelen, dbname))
continue;
/* rule matches */
return rule;
}
return NULL;
}
pgbouncer-1.24.1/src/common/ 0000755 0000000 0000000 00000000000 14777762567 012645 5 0000000 0000000 pgbouncer-1.24.1/src/common/wchar.c 0000644 0001750 0000000 00000102625 14777762222 014044 0000000 0000000 /*-------------------------------------------------------------------------
*
* wchar.c
* Functions for working with multibyte characters in various encodings.
*
* Portions Copyright (c) 1998-2020, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/common/wchar.c
*
*-------------------------------------------------------------------------
*/
//#include "c.h"
#include "system.h"
#include "common/postgres_compat.h"
#include "common/pg_wchar.h"
/*
* Operations on multi-byte encodings are driven by a table of helper
* functions.
*
* To add an encoding support, define mblen(), dsplen() and verifier() for
* the encoding. For server-encodings, also define mb2wchar() and wchar2mb()
* conversion functions.
*
* These functions generally assume that their input is validly formed.
* The "verifier" functions, further down in the file, have to be more
* paranoid.
*
* We expect that mblen() does not need to examine more than the first byte
* of the character to discover the correct length. GB18030 is an exception
* to that rule, though, as it also looks at second byte. But even that
* behaves in a predictable way, if you only pass the first byte: it will
* treat 4-byte encoded characters as two 2-byte encoded characters, which is
* good enough for all current uses.
*
* Note: for the display output of psql to work properly, the return values
* of the dsplen functions must conform to the Unicode standard. In particular
* the NUL character is zero width and control characters are generally
* width -1. It is recommended that non-ASCII encodings refer their ASCII
* subset to the ASCII routines to ensure consistency.
*/
/*
* SQL/ASCII
*/
static int
pg_ascii2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
*to++ = *from++;
len--;
cnt++;
}
*to = 0;
return cnt;
}
static int
pg_ascii_mblen(const unsigned char *s)
{
return 1;
}
static int
pg_ascii_dsplen(const unsigned char *s)
{
if (*s == '\0')
return 0;
if (*s < 0x20 || *s == 0x7f)
return -1;
return 1;
}
/*
* EUC
*/
static int
pg_euc2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
if (*from == SS2 && len >= 2) /* JIS X 0201 (so called "1 byte
* KANA") */
{
from++;
*to = (SS2 << 8) | *from++;
len -= 2;
}
else if (*from == SS3 && len >= 3) /* JIS X 0212 KANJI */
{
from++;
*to = (SS3 << 16) | (*from++ << 8);
*to |= *from++;
len -= 3;
}
else if (IS_HIGHBIT_SET(*from) && len >= 2) /* JIS X 0208 KANJI */
{
*to = *from++ << 8;
*to |= *from++;
len -= 2;
}
else /* must be ASCII */
{
*to = *from++;
len--;
}
to++;
cnt++;
}
*to = 0;
return cnt;
}
static inline int
pg_euc_mblen(const unsigned char *s)
{
int len;
if (*s == SS2)
len = 2;
else if (*s == SS3)
len = 3;
else if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = 1;
return len;
}
static inline int
pg_euc_dsplen(const unsigned char *s)
{
int len;
if (*s == SS2)
len = 2;
else if (*s == SS3)
len = 2;
else if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = pg_ascii_dsplen(s);
return len;
}
/*
* EUC_JP
*/
static int
pg_eucjp2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
return pg_euc2wchar_with_len(from, to, len);
}
static int
pg_eucjp_mblen(const unsigned char *s)
{
return pg_euc_mblen(s);
}
static int
pg_eucjp_dsplen(const unsigned char *s)
{
int len;
if (*s == SS2)
len = 1;
else if (*s == SS3)
len = 2;
else if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = pg_ascii_dsplen(s);
return len;
}
/*
* EUC_KR
*/
static int
pg_euckr2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
return pg_euc2wchar_with_len(from, to, len);
}
static int
pg_euckr_mblen(const unsigned char *s)
{
return pg_euc_mblen(s);
}
static int
pg_euckr_dsplen(const unsigned char *s)
{
return pg_euc_dsplen(s);
}
/*
* EUC_CN
*
*/
static int
pg_euccn2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
if (*from == SS2 && len >= 3) /* code set 2 (unused?) */
{
from++;
*to = (SS2 << 16) | (*from++ << 8);
*to |= *from++;
len -= 3;
}
else if (*from == SS3 && len >= 3) /* code set 3 (unused ?) */
{
from++;
*to = (SS3 << 16) | (*from++ << 8);
*to |= *from++;
len -= 3;
}
else if (IS_HIGHBIT_SET(*from) && len >= 2) /* code set 1 */
{
*to = *from++ << 8;
*to |= *from++;
len -= 2;
}
else
{
*to = *from++;
len--;
}
to++;
cnt++;
}
*to = 0;
return cnt;
}
static int
pg_euccn_mblen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = 1;
return len;
}
static int
pg_euccn_dsplen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = pg_ascii_dsplen(s);
return len;
}
/*
* EUC_TW
*
*/
static int
pg_euctw2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
if (*from == SS2 && len >= 4) /* code set 2 */
{
from++;
*to = (((uint32) SS2) << 24) | (*from++ << 16);
*to |= *from++ << 8;
*to |= *from++;
len -= 4;
}
else if (*from == SS3 && len >= 3) /* code set 3 (unused?) */
{
from++;
*to = (SS3 << 16) | (*from++ << 8);
*to |= *from++;
len -= 3;
}
else if (IS_HIGHBIT_SET(*from) && len >= 2) /* code set 2 */
{
*to = *from++ << 8;
*to |= *from++;
len -= 2;
}
else
{
*to = *from++;
len--;
}
to++;
cnt++;
}
*to = 0;
return cnt;
}
static int
pg_euctw_mblen(const unsigned char *s)
{
int len;
if (*s == SS2)
len = 4;
else if (*s == SS3)
len = 3;
else if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = 1;
return len;
}
static int
pg_euctw_dsplen(const unsigned char *s)
{
int len;
if (*s == SS2)
len = 2;
else if (*s == SS3)
len = 2;
else if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = pg_ascii_dsplen(s);
return len;
}
/*
* Convert pg_wchar to EUC_* encoding.
* caller must allocate enough space for "to", including a trailing zero!
* len: length of from.
* "from" not necessarily null terminated.
*/
static int
pg_wchar2euc_with_len(const pg_wchar *from, unsigned char *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
unsigned char c;
if ((c = (*from >> 24)))
{
*to++ = c;
*to++ = (*from >> 16) & 0xff;
*to++ = (*from >> 8) & 0xff;
*to++ = *from & 0xff;
cnt += 4;
}
else if ((c = (*from >> 16)))
{
*to++ = c;
*to++ = (*from >> 8) & 0xff;
*to++ = *from & 0xff;
cnt += 3;
}
else if ((c = (*from >> 8)))
{
*to++ = c;
*to++ = *from & 0xff;
cnt += 2;
}
else
{
*to++ = *from;
cnt++;
}
from++;
len--;
}
*to = 0;
return cnt;
}
/*
* JOHAB
*/
static int
pg_johab_mblen(const unsigned char *s)
{
return pg_euc_mblen(s);
}
static int
pg_johab_dsplen(const unsigned char *s)
{
return pg_euc_dsplen(s);
}
/*
* convert UTF8 string to pg_wchar (UCS-4)
* caller must allocate enough space for "to", including a trailing zero!
* len: length of from.
* "from" not necessarily null terminated.
*/
static int
pg_utf2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
int cnt = 0;
uint32 c1,
c2,
c3,
c4;
while (len > 0 && *from)
{
if ((*from & 0x80) == 0)
{
*to = *from++;
len--;
}
else if ((*from & 0xe0) == 0xc0)
{
if (len < 2)
break; /* drop trailing incomplete char */
c1 = *from++ & 0x1f;
c2 = *from++ & 0x3f;
*to = (c1 << 6) | c2;
len -= 2;
}
else if ((*from & 0xf0) == 0xe0)
{
if (len < 3)
break; /* drop trailing incomplete char */
c1 = *from++ & 0x0f;
c2 = *from++ & 0x3f;
c3 = *from++ & 0x3f;
*to = (c1 << 12) | (c2 << 6) | c3;
len -= 3;
}
else if ((*from & 0xf8) == 0xf0)
{
if (len < 4)
break; /* drop trailing incomplete char */
c1 = *from++ & 0x07;
c2 = *from++ & 0x3f;
c3 = *from++ & 0x3f;
c4 = *from++ & 0x3f;
*to = (c1 << 18) | (c2 << 12) | (c3 << 6) | c4;
len -= 4;
}
else
{
/* treat a bogus char as length 1; not ours to raise error */
*to = *from++;
len--;
}
to++;
cnt++;
}
*to = 0;
return cnt;
}
/*
* Map a Unicode code point to UTF-8. utf8string must have 4 bytes of
* space allocated.
*/
unsigned char *
unicode_to_utf8(pg_wchar c, unsigned char *utf8string)
{
if (c <= 0x7F)
{
utf8string[0] = c;
}
else if (c <= 0x7FF)
{
utf8string[0] = 0xC0 | ((c >> 6) & 0x1F);
utf8string[1] = 0x80 | (c & 0x3F);
}
else if (c <= 0xFFFF)
{
utf8string[0] = 0xE0 | ((c >> 12) & 0x0F);
utf8string[1] = 0x80 | ((c >> 6) & 0x3F);
utf8string[2] = 0x80 | (c & 0x3F);
}
else
{
utf8string[0] = 0xF0 | ((c >> 18) & 0x07);
utf8string[1] = 0x80 | ((c >> 12) & 0x3F);
utf8string[2] = 0x80 | ((c >> 6) & 0x3F);
utf8string[3] = 0x80 | (c & 0x3F);
}
return utf8string;
}
/*
* Trivial conversion from pg_wchar to UTF-8.
* caller should allocate enough space for "to"
* len: length of from.
* "from" not necessarily null terminated.
*/
static int
pg_wchar2utf_with_len(const pg_wchar *from, unsigned char *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
int char_len;
unicode_to_utf8(*from, to);
char_len = pg_utf_mblen(to);
cnt += char_len;
to += char_len;
from++;
len--;
}
*to = 0;
return cnt;
}
/*
* Return the byte length of a UTF8 character pointed to by s
*
* Note: in the current implementation we do not support UTF8 sequences
* of more than 4 bytes; hence do NOT return a value larger than 4.
* We return "1" for any leading byte that is either flat-out illegal or
* indicates a length larger than we support.
*
* pg_utf2wchar_with_len(), utf8_to_unicode(), pg_utf8_islegal(), and perhaps
* other places would need to be fixed to change this.
*/
int
pg_utf_mblen(const unsigned char *s)
{
int len;
if ((*s & 0x80) == 0)
len = 1;
else if ((*s & 0xe0) == 0xc0)
len = 2;
else if ((*s & 0xf0) == 0xe0)
len = 3;
else if ((*s & 0xf8) == 0xf0)
len = 4;
#ifdef NOT_USED
else if ((*s & 0xfc) == 0xf8)
len = 5;
else if ((*s & 0xfe) == 0xfc)
len = 6;
#endif
else
len = 1;
return len;
}
/*
* This is an implementation of wcwidth() and wcswidth() as defined in
* "The Single UNIX Specification, Version 2, The Open Group, 1997"
*
*
* Markus Kuhn -- 2001-09-08 -- public domain
*
* customised for PostgreSQL
*
* original available at : http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
*/
struct mbinterval
{
unsigned short first;
unsigned short last;
};
/* auxiliary function for binary search in interval table */
static int
mbbisearch(pg_wchar ucs, const struct mbinterval *table, int max)
{
int min = 0;
int mid;
if (ucs < table[0].first || ucs > table[max].last)
return 0;
while (max >= min)
{
mid = (min + max) / 2;
if (ucs > table[mid].last)
min = mid + 1;
else if (ucs < table[mid].first)
max = mid - 1;
else
return 1;
}
return 0;
}
/* The following functions define the column width of an ISO 10646
* character as follows:
*
* - The null character (U+0000) has a column width of 0.
*
* - Other C0/C1 control characters and DEL will lead to a return
* value of -1.
*
* - Non-spacing and enclosing combining characters (general
* category code Mn or Me in the Unicode database) have a
* column width of 0.
*
* - Other format characters (general category code Cf in the Unicode
* database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
*
* - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
* have a column width of 0.
*
* - Spacing characters in the East Asian Wide (W) or East Asian
* FullWidth (F) category as defined in Unicode Technical
* Report #11 have a column width of 2.
*
* - All remaining characters (including all printable
* ISO 8859-1 and WGL4 characters, Unicode control characters,
* etc.) have a column width of 1.
*
* This implementation assumes that wchar_t characters are encoded
* in ISO 10646.
*/
static int
ucs_wcwidth(pg_wchar ucs)
{
#include "common/unicode_combining_table.h"
/* test for 8-bit control characters */
if (ucs == 0)
return 0;
if (ucs < 0x20 || (ucs >= 0x7f && ucs < 0xa0) || ucs > 0x0010ffff)
return -1;
/* binary search in table of non-spacing characters */
if (mbbisearch(ucs, combining,
sizeof(combining) / sizeof(struct mbinterval) - 1))
return 0;
/*
* if we arrive here, ucs is not a combining or C0/C1 control character
*/
return 1 +
(ucs >= 0x1100 &&
(ucs <= 0x115f || /* Hangul Jamo init. consonants */
(ucs >= 0x2e80 && ucs <= 0xa4cf && (ucs & ~0x0011) != 0x300a &&
ucs != 0x303f) || /* CJK ... Yi */
(ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
(ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility
* Ideographs */
(ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
(ucs >= 0xff00 && ucs <= 0xff5f) || /* Fullwidth Forms */
(ucs >= 0xffe0 && ucs <= 0xffe6) ||
(ucs >= 0x20000 && ucs <= 0x2ffff)));
}
/*
* Convert a UTF-8 character to a Unicode code point.
* This is a one-character version of pg_utf2wchar_with_len.
*
* No error checks here, c must point to a long-enough string.
*/
pg_wchar
utf8_to_unicode(const unsigned char *c)
{
if ((*c & 0x80) == 0)
return (pg_wchar) c[0];
else if ((*c & 0xe0) == 0xc0)
return (pg_wchar) (((c[0] & 0x1f) << 6) |
(c[1] & 0x3f));
else if ((*c & 0xf0) == 0xe0)
return (pg_wchar) (((c[0] & 0x0f) << 12) |
((c[1] & 0x3f) << 6) |
(c[2] & 0x3f));
else if ((*c & 0xf8) == 0xf0)
return (pg_wchar) (((c[0] & 0x07) << 18) |
((c[1] & 0x3f) << 12) |
((c[2] & 0x3f) << 6) |
(c[3] & 0x3f));
else
/* that is an invalid code on purpose */
return 0xffffffff;
}
static int
pg_utf_dsplen(const unsigned char *s)
{
return ucs_wcwidth(utf8_to_unicode(s));
}
/*
* convert mule internal code to pg_wchar
* caller should allocate enough space for "to"
* len: length of from.
* "from" not necessarily null terminated.
*/
static int
pg_mule2wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
if (IS_LC1(*from) && len >= 2)
{
*to = *from++ << 16;
*to |= *from++;
len -= 2;
}
else if (IS_LCPRV1(*from) && len >= 3)
{
from++;
*to = *from++ << 16;
*to |= *from++;
len -= 3;
}
else if (IS_LC2(*from) && len >= 3)
{
*to = *from++ << 16;
*to |= *from++ << 8;
*to |= *from++;
len -= 3;
}
else if (IS_LCPRV2(*from) && len >= 4)
{
from++;
*to = *from++ << 16;
*to |= *from++ << 8;
*to |= *from++;
len -= 4;
}
else
{ /* assume ASCII */
*to = (unsigned char) *from++;
len--;
}
to++;
cnt++;
}
*to = 0;
return cnt;
}
/*
* convert pg_wchar to mule internal code
* caller should allocate enough space for "to"
* len: length of from.
* "from" not necessarily null terminated.
*/
static int
pg_wchar2mule_with_len(const pg_wchar *from, unsigned char *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
unsigned char lb;
lb = (*from >> 16) & 0xff;
if (IS_LC1(lb))
{
*to++ = lb;
*to++ = *from & 0xff;
cnt += 2;
}
else if (IS_LC2(lb))
{
*to++ = lb;
*to++ = (*from >> 8) & 0xff;
*to++ = *from & 0xff;
cnt += 3;
}
else if (IS_LCPRV1_A_RANGE(lb))
{
*to++ = LCPRV1_A;
*to++ = lb;
*to++ = *from & 0xff;
cnt += 3;
}
else if (IS_LCPRV1_B_RANGE(lb))
{
*to++ = LCPRV1_B;
*to++ = lb;
*to++ = *from & 0xff;
cnt += 3;
}
else if (IS_LCPRV2_A_RANGE(lb))
{
*to++ = LCPRV2_A;
*to++ = lb;
*to++ = (*from >> 8) & 0xff;
*to++ = *from & 0xff;
cnt += 4;
}
else if (IS_LCPRV2_B_RANGE(lb))
{
*to++ = LCPRV2_B;
*to++ = lb;
*to++ = (*from >> 8) & 0xff;
*to++ = *from & 0xff;
cnt += 4;
}
else
{
*to++ = *from & 0xff;
cnt += 1;
}
from++;
len--;
}
*to = 0;
return cnt;
}
/* exported for direct use by conv.c */
int
pg_mule_mblen(const unsigned char *s)
{
int len;
if (IS_LC1(*s))
len = 2;
else if (IS_LCPRV1(*s))
len = 3;
else if (IS_LC2(*s))
len = 3;
else if (IS_LCPRV2(*s))
len = 4;
else
len = 1; /* assume ASCII */
return len;
}
static int
pg_mule_dsplen(const unsigned char *s)
{
int len;
/*
* Note: it's not really appropriate to assume that all multibyte charsets
* are double-wide on screen. But this seems an okay approximation for
* the MULE charsets we currently support.
*/
if (IS_LC1(*s))
len = 1;
else if (IS_LCPRV1(*s))
len = 1;
else if (IS_LC2(*s))
len = 2;
else if (IS_LCPRV2(*s))
len = 2;
else
len = 1; /* assume ASCII */
return len;
}
/*
* ISO8859-1
*/
static int
pg_latin12wchar_with_len(const unsigned char *from, pg_wchar *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
*to++ = *from++;
len--;
cnt++;
}
*to = 0;
return cnt;
}
/*
* Trivial conversion from pg_wchar to single byte encoding. Just ignores
* high bits.
* caller should allocate enough space for "to"
* len: length of from.
* "from" not necessarily null terminated.
*/
static int
pg_wchar2single_with_len(const pg_wchar *from, unsigned char *to, int len)
{
int cnt = 0;
while (len > 0 && *from)
{
*to++ = *from++;
len--;
cnt++;
}
*to = 0;
return cnt;
}
static int
pg_latin1_mblen(const unsigned char *s)
{
return 1;
}
static int
pg_latin1_dsplen(const unsigned char *s)
{
return pg_ascii_dsplen(s);
}
/*
* SJIS
*/
static int
pg_sjis_mblen(const unsigned char *s)
{
int len;
if (*s >= 0xa1 && *s <= 0xdf)
len = 1; /* 1 byte kana? */
else if (IS_HIGHBIT_SET(*s))
len = 2; /* kanji? */
else
len = 1; /* should be ASCII */
return len;
}
static int
pg_sjis_dsplen(const unsigned char *s)
{
int len;
if (*s >= 0xa1 && *s <= 0xdf)
len = 1; /* 1 byte kana? */
else if (IS_HIGHBIT_SET(*s))
len = 2; /* kanji? */
else
len = pg_ascii_dsplen(s); /* should be ASCII */
return len;
}
/*
* Big5
*/
static int
pg_big5_mblen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2; /* kanji? */
else
len = 1; /* should be ASCII */
return len;
}
static int
pg_big5_dsplen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2; /* kanji? */
else
len = pg_ascii_dsplen(s); /* should be ASCII */
return len;
}
/*
* GBK
*/
static int
pg_gbk_mblen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2; /* kanji? */
else
len = 1; /* should be ASCII */
return len;
}
static int
pg_gbk_dsplen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2; /* kanji? */
else
len = pg_ascii_dsplen(s); /* should be ASCII */
return len;
}
/*
* UHC
*/
static int
pg_uhc_mblen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2; /* 2byte? */
else
len = 1; /* should be ASCII */
return len;
}
static int
pg_uhc_dsplen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2; /* 2byte? */
else
len = pg_ascii_dsplen(s); /* should be ASCII */
return len;
}
/*
* GB18030
* Added by Bill Huang ,
*/
/*
* Unlike all other mblen() functions, this also looks at the second byte of
* the input. However, if you only pass the first byte of a multi-byte
* string, and \0 as the second byte, this still works in a predictable way:
* a 4-byte character will be reported as two 2-byte characters. That's
* enough for all current uses, as a client-only encoding. It works that
* way, because in any valid 4-byte GB18030-encoded character, the third and
* fourth byte look like a 2-byte encoded character, when looked at
* separately.
*/
static int
pg_gb18030_mblen(const unsigned char *s)
{
int len;
if (!IS_HIGHBIT_SET(*s))
len = 1; /* ASCII */
else if (*(s + 1) >= 0x30 && *(s + 1) <= 0x39)
len = 4;
else
len = 2;
return len;
}
static int
pg_gb18030_dsplen(const unsigned char *s)
{
int len;
if (IS_HIGHBIT_SET(*s))
len = 2;
else
len = pg_ascii_dsplen(s); /* ASCII */
return len;
}
/*
*-------------------------------------------------------------------
* multibyte sequence validators
*
* These functions accept "s", a pointer to the first byte of a string,
* and "len", the remaining length of the string. If there is a validly
* encoded character beginning at *s, return its length in bytes; else
* return -1.
*
* The functions can assume that len > 0 and that *s != '\0', but they must
* test for and reject zeroes in any additional bytes of a multibyte character.
*
* Note that this definition allows the function for a single-byte
* encoding to be just "return 1".
*-------------------------------------------------------------------
*/
static int
pg_ascii_verifier(const unsigned char *s, int len)
{
return 1;
}
#define IS_EUC_RANGE_VALID(c) ((c) >= 0xa1 && (c) <= 0xfe)
static int
pg_eucjp_verifier(const unsigned char *s, int len)
{
int l;
unsigned char c1,
c2;
c1 = *s++;
switch (c1)
{
case SS2: /* JIS X 0201 */
l = 2;
if (l > len)
return -1;
c2 = *s++;
if (c2 < 0xa1 || c2 > 0xdf)
return -1;
break;
case SS3: /* JIS X 0212 */
l = 3;
if (l > len)
return -1;
c2 = *s++;
if (!IS_EUC_RANGE_VALID(c2))
return -1;
c2 = *s++;
if (!IS_EUC_RANGE_VALID(c2))
return -1;
break;
default:
if (IS_HIGHBIT_SET(c1)) /* JIS X 0208? */
{
l = 2;
if (l > len)
return -1;
if (!IS_EUC_RANGE_VALID(c1))
return -1;
c2 = *s++;
if (!IS_EUC_RANGE_VALID(c2))
return -1;
}
else
/* must be ASCII */
{
l = 1;
}
break;
}
return l;
}
static int
pg_euckr_verifier(const unsigned char *s, int len)
{
int l;
unsigned char c1,
c2;
c1 = *s++;
if (IS_HIGHBIT_SET(c1))
{
l = 2;
if (l > len)
return -1;
if (!IS_EUC_RANGE_VALID(c1))
return -1;
c2 = *s++;
if (!IS_EUC_RANGE_VALID(c2))
return -1;
}
else
/* must be ASCII */
{
l = 1;
}
return l;
}
/* EUC-CN byte sequences are exactly same as EUC-KR */
#define pg_euccn_verifier pg_euckr_verifier
static int
pg_euctw_verifier(const unsigned char *s, int len)
{
int l;
unsigned char c1,
c2;
c1 = *s++;
switch (c1)
{
case SS2: /* CNS 11643 Plane 1-7 */
l = 4;
if (l > len)
return -1;
c2 = *s++;
if (c2 < 0xa1 || c2 > 0xa7)
return -1;
c2 = *s++;
if (!IS_EUC_RANGE_VALID(c2))
return -1;
c2 = *s++;
if (!IS_EUC_RANGE_VALID(c2))
return -1;
break;
case SS3: /* unused */
return -1;
default:
if (IS_HIGHBIT_SET(c1)) /* CNS 11643 Plane 1 */
{
l = 2;
if (l > len)
return -1;
/* no further range check on c1? */
c2 = *s++;
if (!IS_EUC_RANGE_VALID(c2))
return -1;
}
else
/* must be ASCII */
{
l = 1;
}
break;
}
return l;
}
static int
pg_johab_verifier(const unsigned char *s, int len)
{
int l,
mbl;
unsigned char c;
l = mbl = pg_johab_mblen(s);
if (len < l)
return -1;
if (!IS_HIGHBIT_SET(*s))
return mbl;
while (--l > 0)
{
c = *++s;
if (!IS_EUC_RANGE_VALID(c))
return -1;
}
return mbl;
}
static int
pg_mule_verifier(const unsigned char *s, int len)
{
int l,
mbl;
unsigned char c;
l = mbl = pg_mule_mblen(s);
if (len < l)
return -1;
while (--l > 0)
{
c = *++s;
if (!IS_HIGHBIT_SET(c))
return -1;
}
return mbl;
}
static int
pg_latin1_verifier(const unsigned char *s, int len)
{
return 1;
}
static int
pg_sjis_verifier(const unsigned char *s, int len)
{
int l,
mbl;
unsigned char c1,
c2;
l = mbl = pg_sjis_mblen(s);
if (len < l)
return -1;
if (l == 1) /* pg_sjis_mblen already verified it */
return mbl;
c1 = *s++;
c2 = *s;
if (!ISSJISHEAD(c1) || !ISSJISTAIL(c2))
return -1;
return mbl;
}
static int
pg_big5_verifier(const unsigned char *s, int len)
{
int l,
mbl;
l = mbl = pg_big5_mblen(s);
if (len < l)
return -1;
while (--l > 0)
{
if (*++s == '\0')
return -1;
}
return mbl;
}
static int
pg_gbk_verifier(const unsigned char *s, int len)
{
int l,
mbl;
l = mbl = pg_gbk_mblen(s);
if (len < l)
return -1;
while (--l > 0)
{
if (*++s == '\0')
return -1;
}
return mbl;
}
static int
pg_uhc_verifier(const unsigned char *s, int len)
{
int l,
mbl;
l = mbl = pg_uhc_mblen(s);
if (len < l)
return -1;
while (--l > 0)
{
if (*++s == '\0')
return -1;
}
return mbl;
}
static int
pg_gb18030_verifier(const unsigned char *s, int len)
{
int l;
if (!IS_HIGHBIT_SET(*s))
l = 1; /* ASCII */
else if (len >= 4 && *(s + 1) >= 0x30 && *(s + 1) <= 0x39)
{
/* Should be 4-byte, validate remaining bytes */
if (*s >= 0x81 && *s <= 0xfe &&
*(s + 2) >= 0x81 && *(s + 2) <= 0xfe &&
*(s + 3) >= 0x30 && *(s + 3) <= 0x39)
l = 4;
else
l = -1;
}
else if (len >= 2 && *s >= 0x81 && *s <= 0xfe)
{
/* Should be 2-byte, validate */
if ((*(s + 1) >= 0x40 && *(s + 1) <= 0x7e) ||
(*(s + 1) >= 0x80 && *(s + 1) <= 0xfe))
l = 2;
else
l = -1;
}
else
l = -1;
return l;
}
static int
pg_utf8_verifier(const unsigned char *s, int len)
{
int l = pg_utf_mblen(s);
if (len < l)
return -1;
if (!pg_utf8_islegal(s, l))
return -1;
return l;
}
/*
* Check for validity of a single UTF-8 encoded character
*
* This directly implements the rules in RFC3629. The bizarre-looking
* restrictions on the second byte are meant to ensure that there isn't
* more than one encoding of a given Unicode character point; that is,
* you may not use a longer-than-necessary byte sequence with high order
* zero bits to represent a character that would fit in fewer bytes.
* To do otherwise is to create security hazards (eg, create an apparent
* non-ASCII character that decodes to plain ASCII).
*
* length is assumed to have been obtained by pg_utf_mblen(), and the
* caller must have checked that that many bytes are present in the buffer.
*/
bool
pg_utf8_islegal(const unsigned char *source, int length)
{
unsigned char a;
switch (length)
{
default:
/* reject lengths 5 and 6 for now */
return false;
case 4:
a = source[3];
if (a < 0x80 || a > 0xBF)
return false;
/* FALL THRU */
case 3:
a = source[2];
if (a < 0x80 || a > 0xBF)
return false;
/* FALL THRU */
case 2:
a = source[1];
switch (*source)
{
case 0xE0:
if (a < 0xA0 || a > 0xBF)
return false;
break;
case 0xED:
if (a < 0x80 || a > 0x9F)
return false;
break;
case 0xF0:
if (a < 0x90 || a > 0xBF)
return false;
break;
case 0xF4:
if (a < 0x80 || a > 0x8F)
return false;
break;
default:
if (a < 0x80 || a > 0xBF)
return false;
break;
}
/* FALL THRU */
case 1:
a = *source;
if (a >= 0x80 && a < 0xC2)
return false;
if (a > 0xF4)
return false;
break;
}
return true;
}
/*
*-------------------------------------------------------------------
* encoding info table
* XXX must be sorted by the same order as enum pg_enc (in mb/pg_wchar.h)
*-------------------------------------------------------------------
*/
const pg_wchar_tbl pg_wchar_table[] = {
{pg_ascii2wchar_with_len, pg_wchar2single_with_len, pg_ascii_mblen, pg_ascii_dsplen, pg_ascii_verifier, 1}, /* PG_SQL_ASCII */
{pg_eucjp2wchar_with_len, pg_wchar2euc_with_len, pg_eucjp_mblen, pg_eucjp_dsplen, pg_eucjp_verifier, 3}, /* PG_EUC_JP */
{pg_euccn2wchar_with_len, pg_wchar2euc_with_len, pg_euccn_mblen, pg_euccn_dsplen, pg_euccn_verifier, 2}, /* PG_EUC_CN */
{pg_euckr2wchar_with_len, pg_wchar2euc_with_len, pg_euckr_mblen, pg_euckr_dsplen, pg_euckr_verifier, 3}, /* PG_EUC_KR */
{pg_euctw2wchar_with_len, pg_wchar2euc_with_len, pg_euctw_mblen, pg_euctw_dsplen, pg_euctw_verifier, 4}, /* PG_EUC_TW */
{pg_eucjp2wchar_with_len, pg_wchar2euc_with_len, pg_eucjp_mblen, pg_eucjp_dsplen, pg_eucjp_verifier, 3}, /* PG_EUC_JIS_2004 */
{pg_utf2wchar_with_len, pg_wchar2utf_with_len, pg_utf_mblen, pg_utf_dsplen, pg_utf8_verifier, 4}, /* PG_UTF8 */
{pg_mule2wchar_with_len, pg_wchar2mule_with_len, pg_mule_mblen, pg_mule_dsplen, pg_mule_verifier, 4}, /* PG_MULE_INTERNAL */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN1 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN2 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN3 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN4 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN5 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN6 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN7 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN8 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN9 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_LATIN10 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1256 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1258 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN866 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN874 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_KOI8R */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1251 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1252 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* ISO-8859-5 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* ISO-8859-6 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* ISO-8859-7 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* ISO-8859-8 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1250 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1253 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1254 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1255 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1257 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_KOI8U */
{0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2}, /* PG_SJIS */
{0, 0, pg_big5_mblen, pg_big5_dsplen, pg_big5_verifier, 2}, /* PG_BIG5 */
{0, 0, pg_gbk_mblen, pg_gbk_dsplen, pg_gbk_verifier, 2}, /* PG_GBK */
{0, 0, pg_uhc_mblen, pg_uhc_dsplen, pg_uhc_verifier, 2}, /* PG_UHC */
{0, 0, pg_gb18030_mblen, pg_gb18030_dsplen, pg_gb18030_verifier, 4}, /* PG_GB18030 */
{0, 0, pg_johab_mblen, pg_johab_dsplen, pg_johab_verifier, 3}, /* PG_JOHAB */
{0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2} /* PG_SHIFT_JIS_2004 */
};
/*
* Returns the byte length of a multibyte character.
*
* Caution: when dealing with text that is not certainly valid in the
* specified encoding, the result may exceed the actual remaining
* string length. Callers that are not prepared to deal with that
* should use pg_encoding_mblen_bounded() instead.
*/
int
pg_encoding_mblen(int encoding, const char *mbstr)
{
return (PG_VALID_ENCODING(encoding) ?
pg_wchar_table[encoding].mblen((const unsigned char *) mbstr) :
pg_wchar_table[PG_SQL_ASCII].mblen((const unsigned char *) mbstr));
}
/*
* Returns the byte length of a multibyte character; but not more than
* the distance to end of string.
*/
int
pg_encoding_mblen_bounded(int encoding, const char *mbstr)
{
return strnlen(mbstr, pg_encoding_mblen(encoding, mbstr));
}
/*
* Returns the display length of a multibyte character.
*/
int
pg_encoding_dsplen(int encoding, const char *mbstr)
{
return (PG_VALID_ENCODING(encoding) ?
pg_wchar_table[encoding].dsplen((const unsigned char *) mbstr) :
pg_wchar_table[PG_SQL_ASCII].dsplen((const unsigned char *) mbstr));
}
/*
* Verify the first multibyte character of the given string.
* Return its byte length if good, -1 if bad. (See comments above for
* full details of the mbverify API.)
*/
int
pg_encoding_verifymb(int encoding, const char *mbstr, int len)
{
return (PG_VALID_ENCODING(encoding) ?
pg_wchar_table[encoding].mbverify((const unsigned char *) mbstr, len) :
pg_wchar_table[PG_SQL_ASCII].mbverify((const unsigned char *) mbstr, len));
}
/*
* fetch maximum length of a given encoding
*/
int
pg_encoding_max_length(int encoding)
{
Assert(PG_VALID_ENCODING(encoding));
return pg_wchar_table[encoding].maxmblen;
}
pgbouncer-1.24.1/src/common/unicode_norm.c 0000644 0001750 0000000 00000033130 14777762222 015413 0000000 0000000 /*-------------------------------------------------------------------------
* unicode_norm.c
* Normalize a Unicode string
*
* This implements Unicode normalization, per the documentation at
* https://www.unicode.org/reports/tr15/.
*
* Portions Copyright (c) 2017-2020, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/common/unicode_norm.c
*
*-------------------------------------------------------------------------
*/
//#ifndef FRONTEND
//#include "postgres.h"
//#else
//#include "postgres_fe.h"
//#endif
#include "system.h"
#include "common/postgres_compat.h"
#include "common/unicode_norm.h"
#include "common/unicode_norm_table.h"
#ifndef FRONTEND
#include "common/unicode_normprops_table.h"
#endif
#ifndef FRONTEND
#define ALLOC(size) palloc(size)
#define FREE(size) pfree(size)
#else
#define ALLOC(size) malloc(size)
#define FREE(size) free(size)
#endif
/* Constants for calculations with Hangul characters */
#define SBASE 0xAC00 /* U+AC00 */
#define LBASE 0x1100 /* U+1100 */
#define VBASE 0x1161 /* U+1161 */
#define TBASE 0x11A7 /* U+11A7 */
#define LCOUNT 19
#define VCOUNT 21
#define TCOUNT 28
#define NCOUNT VCOUNT * TCOUNT
#define SCOUNT LCOUNT * NCOUNT
/* comparison routine for bsearch() of decomposition lookup table. */
static int
conv_compare(const void *p1, const void *p2)
{
uint32 v1,
v2;
v1 = *(const uint32 *) p1;
v2 = ((const pg_unicode_decomposition *) p2)->codepoint;
return (v1 > v2) ? 1 : ((v1 == v2) ? 0 : -1);
}
/*
* Get the entry corresponding to code in the decomposition lookup table.
*/
static pg_unicode_decomposition *
get_code_entry(pg_wchar code)
{
return bsearch(&(code),
UnicodeDecompMain,
lengthof(UnicodeDecompMain),
sizeof(pg_unicode_decomposition),
conv_compare);
}
/*
* Given a decomposition entry looked up earlier, get the decomposed
* characters.
*
* Note: the returned pointer can point to statically allocated buffer, and
* is only valid until next call to this function!
*/
static const pg_wchar *
get_code_decomposition(pg_unicode_decomposition *entry, int *dec_size)
{
static pg_wchar x;
if (DECOMPOSITION_IS_INLINE(entry))
{
Assert(DECOMPOSITION_SIZE(entry) == 1);
x = (pg_wchar) entry->dec_index;
*dec_size = 1;
return &x;
}
else
{
*dec_size = DECOMPOSITION_SIZE(entry);
return &UnicodeDecomp_codepoints[entry->dec_index];
}
}
/*
* Calculate how many characters a given character will decompose to.
*
* This needs to recurse, if the character decomposes into characters that
* are, in turn, decomposable.
*/
static int
get_decomposed_size(pg_wchar code, bool compat)
{
pg_unicode_decomposition *entry;
int size = 0;
int i;
const uint32 *decomp;
int dec_size;
/*
* Fast path for Hangul characters not stored in tables to save memory as
* decomposition is algorithmic. See
* https://www.unicode.org/reports/tr15/tr15-18.html, annex 10 for details
* on the matter.
*/
if (code >= SBASE && code < SBASE + SCOUNT)
{
uint32 tindex,
sindex;
sindex = code - SBASE;
tindex = sindex % TCOUNT;
if (tindex != 0)
return 3;
return 2;
}
entry = get_code_entry(code);
/*
* Just count current code if no other decompositions. A NULL entry is
* equivalent to a character with class 0 and no decompositions.
*/
if (entry == NULL || DECOMPOSITION_SIZE(entry) == 0 ||
(!compat && DECOMPOSITION_IS_COMPAT(entry)))
return 1;
/*
* If this entry has other decomposition codes look at them as well. First
* get its decomposition in the list of tables available.
*/
decomp = get_code_decomposition(entry, &dec_size);
for (i = 0; i < dec_size; i++)
{
uint32 lcode = decomp[i];
size += get_decomposed_size(lcode, compat);
}
return size;
}
/*
* Recompose a set of characters. For hangul characters, the calculation
* is algorithmic. For others, an inverse lookup at the decomposition
* table is necessary. Returns true if a recomposition can be done, and
* false otherwise.
*/
static bool
recompose_code(uint32 start, uint32 code, uint32 *result)
{
/*
* Handle Hangul characters algorithmically, per the Unicode spec.
*
* Check if two current characters are L and V.
*/
if (start >= LBASE && start < LBASE + LCOUNT &&
code >= VBASE && code < VBASE + VCOUNT)
{
/* make syllable of form LV */
uint32 lindex = start - LBASE;
uint32 vindex = code - VBASE;
*result = SBASE + (lindex * VCOUNT + vindex) * TCOUNT;
return true;
}
/* Check if two current characters are LV and T */
else if (start >= SBASE && start < (SBASE + SCOUNT) &&
((start - SBASE) % TCOUNT) == 0 &&
code >= TBASE && code < (TBASE + TCOUNT))
{
/* make syllable of form LVT */
uint32 tindex = code - TBASE;
*result = start + tindex;
return true;
}
else
{
unsigned int i;
/*
* Do an inverse lookup of the decomposition tables to see if anything
* matches. The comparison just needs to be a perfect match on the
* sub-table of size two, because the start character has already been
* recomposed partially.
*/
for (i = 0; i < lengthof(UnicodeDecompMain); i++)
{
const pg_unicode_decomposition *entry = &UnicodeDecompMain[i];
if (DECOMPOSITION_SIZE(entry) != 2)
continue;
if (DECOMPOSITION_NO_COMPOSE(entry))
continue;
if (start == UnicodeDecomp_codepoints[entry->dec_index] &&
code == UnicodeDecomp_codepoints[entry->dec_index + 1])
{
*result = entry->codepoint;
return true;
}
}
}
return false;
}
/*
* Decompose the given code into the array given by caller. The
* decomposition begins at the position given by caller, saving one
* lookup on the decomposition table. The current position needs to be
* updated here to let the caller know from where to continue filling
* in the array result.
*/
static void
decompose_code(pg_wchar code, bool compat, pg_wchar **result, int *current)
{
pg_unicode_decomposition *entry;
int i;
const uint32 *decomp;
int dec_size;
/*
* Fast path for Hangul characters not stored in tables to save memory as
* decomposition is algorithmic. See
* https://www.unicode.org/reports/tr15/tr15-18.html, annex 10 for details
* on the matter.
*/
if (code >= SBASE && code < SBASE + SCOUNT)
{
uint32 l,
v,
tindex,
sindex;
pg_wchar *res = *result;
sindex = code - SBASE;
l = LBASE + sindex / (VCOUNT * TCOUNT);
v = VBASE + (sindex % (VCOUNT * TCOUNT)) / TCOUNT;
tindex = sindex % TCOUNT;
res[*current] = l;
(*current)++;
res[*current] = v;
(*current)++;
if (tindex != 0)
{
res[*current] = TBASE + tindex;
(*current)++;
}
return;
}
entry = get_code_entry(code);
/*
* Just fill in with the current decomposition if there are no
* decomposition codes to recurse to. A NULL entry is equivalent to a
* character with class 0 and no decompositions, so just leave also in
* this case.
*/
if (entry == NULL || DECOMPOSITION_SIZE(entry) == 0 ||
(!compat && DECOMPOSITION_IS_COMPAT(entry)))
{
pg_wchar *res = *result;
res[*current] = code;
(*current)++;
return;
}
/*
* If this entry has other decomposition codes look at them as well.
*/
decomp = get_code_decomposition(entry, &dec_size);
for (i = 0; i < dec_size; i++)
{
pg_wchar lcode = (pg_wchar) decomp[i];
/* Leave if no more decompositions */
decompose_code(lcode, compat, result, current);
}
}
/*
* unicode_normalize - Normalize a Unicode string to the specified form.
*
* The input is a 0-terminated array of codepoints.
*
* In frontend, returns a 0-terminated array of codepoints, allocated with
* malloc. Or NULL if we run out of memory. In backend, the returned
* string is palloc'd instead, and OOM is reported with ereport().
*/
pg_wchar *
unicode_normalize(UnicodeNormalizationForm form, const pg_wchar *input)
{
bool compat = (form == UNICODE_NFKC || form == UNICODE_NFKD);
bool recompose = (form == UNICODE_NFC || form == UNICODE_NFKC);
pg_wchar *decomp_chars;
pg_wchar *recomp_chars;
int decomp_size,
current_size;
int count;
const pg_wchar *p;
/* variables for recomposition */
int last_class;
int starter_pos;
int target_pos;
uint32 starter_ch;
/* First, do character decomposition */
/*
* Calculate how many characters long the decomposed version will be.
*/
decomp_size = 0;
for (p = input; *p; p++)
decomp_size += get_decomposed_size(*p, compat);
decomp_chars = (pg_wchar *) ALLOC((decomp_size + 1) * sizeof(pg_wchar));
if (decomp_chars == NULL)
return NULL;
/*
* Now fill in each entry recursively. This needs a second pass on the
* decomposition table.
*/
current_size = 0;
for (p = input; *p; p++)
decompose_code(*p, compat, &decomp_chars, ¤t_size);
decomp_chars[decomp_size] = '\0';
Assert(decomp_size == current_size);
/*
* Now apply canonical ordering.
*/
for (count = 1; count < decomp_size; count++)
{
pg_wchar prev = decomp_chars[count - 1];
pg_wchar next = decomp_chars[count];
pg_wchar tmp;
pg_unicode_decomposition *prevEntry = get_code_entry(prev);
pg_unicode_decomposition *nextEntry = get_code_entry(next);
/*
* If no entries are found, the character used is either an Hangul
* character or a character with a class of 0 and no decompositions,
* so move to next result.
*/
if (prevEntry == NULL || nextEntry == NULL)
continue;
/*
* Per Unicode (https://www.unicode.org/reports/tr15/tr15-18.html)
* annex 4, a sequence of two adjacent characters in a string is an
* exchangeable pair if the combining class (from the Unicode
* Character Database) for the first character is greater than the
* combining class for the second, and the second is not a starter. A
* character is a starter if its combining class is 0.
*/
if (nextEntry->comb_class == 0x0 || prevEntry->comb_class == 0x0)
continue;
if (prevEntry->comb_class <= nextEntry->comb_class)
continue;
/* exchange can happen */
tmp = decomp_chars[count - 1];
decomp_chars[count - 1] = decomp_chars[count];
decomp_chars[count] = tmp;
/* backtrack to check again */
if (count > 1)
count -= 2;
}
if (!recompose)
return decomp_chars;
/*
* The last phase of NFC and NFKC is the recomposition of the reordered
* Unicode string using combining classes. The recomposed string cannot be
* longer than the decomposed one, so make the allocation of the output
* string based on that assumption.
*/
recomp_chars = (pg_wchar *) ALLOC((decomp_size + 1) * sizeof(pg_wchar));
if (!recomp_chars)
{
FREE(decomp_chars);
return NULL;
}
last_class = -1; /* this eliminates a special check */
starter_pos = 0;
target_pos = 1;
starter_ch = recomp_chars[0] = decomp_chars[0];
for (count = 1; count < decomp_size; count++)
{
pg_wchar ch = decomp_chars[count];
pg_unicode_decomposition *ch_entry = get_code_entry(ch);
int ch_class = (ch_entry == NULL) ? 0 : ch_entry->comb_class;
pg_wchar composite;
if (last_class < ch_class &&
recompose_code(starter_ch, ch, &composite))
{
recomp_chars[starter_pos] = composite;
starter_ch = composite;
}
else if (ch_class == 0)
{
starter_pos = target_pos;
starter_ch = ch;
last_class = -1;
recomp_chars[target_pos++] = ch;
}
else
{
last_class = ch_class;
recomp_chars[target_pos++] = ch;
}
}
recomp_chars[target_pos] = (pg_wchar) '\0';
FREE(decomp_chars);
return recomp_chars;
}
/*
* Normalization "quick check" algorithm; see
*
*/
/* We only need this in the backend. */
#ifndef FRONTEND
static uint8
get_canonical_class(pg_wchar ch)
{
pg_unicode_decomposition *entry = get_code_entry(ch);
if (!entry)
return 0;
else
return entry->comb_class;
}
static int
qc_compare(const void *p1, const void *p2)
{
uint32 v1,
v2;
v1 = ((const pg_unicode_normprops *) p1)->codepoint;
v2 = ((const pg_unicode_normprops *) p2)->codepoint;
return (v1 - v2);
}
/*
* Look up the normalization quick check character property
*/
static UnicodeNormalizationQC
qc_is_allowed(UnicodeNormalizationForm form, pg_wchar ch)
{
pg_unicode_normprops key;
pg_unicode_normprops *found = NULL;
key.codepoint = ch;
switch (form)
{
case UNICODE_NFC:
found = bsearch(&key,
UnicodeNormProps_NFC_QC,
lengthof(UnicodeNormProps_NFC_QC),
sizeof(pg_unicode_normprops),
qc_compare);
break;
case UNICODE_NFKC:
found = bsearch(&key,
UnicodeNormProps_NFKC_QC,
lengthof(UnicodeNormProps_NFKC_QC),
sizeof(pg_unicode_normprops),
qc_compare);
break;
default:
Assert(false);
break;
}
if (found)
return found->quickcheck;
else
return UNICODE_NORM_QC_YES;
}
UnicodeNormalizationQC
unicode_is_normalized_quickcheck(UnicodeNormalizationForm form, const pg_wchar *input)
{
uint8 lastCanonicalClass = 0;
UnicodeNormalizationQC result = UNICODE_NORM_QC_YES;
/*
* For the "D" forms, we don't run the quickcheck. We don't include the
* lookup tables for those because they are huge, checking for these
* particular forms is less common, and running the slow path is faster
* for the "D" forms than the "C" forms because you don't need to
* recompose, which is slow.
*/
if (form == UNICODE_NFD || form == UNICODE_NFKD)
return UNICODE_NORM_QC_MAYBE;
for (const pg_wchar *p = input; *p; p++)
{
pg_wchar ch = *p;
uint8 canonicalClass;
UnicodeNormalizationQC check;
canonicalClass = get_canonical_class(ch);
if (lastCanonicalClass > canonicalClass && canonicalClass != 0)
return UNICODE_NORM_QC_NO;
check = qc_is_allowed(form, ch);
if (check == UNICODE_NORM_QC_NO)
return UNICODE_NORM_QC_NO;
else if (check == UNICODE_NORM_QC_MAYBE)
result = UNICODE_NORM_QC_MAYBE;
lastCanonicalClass = canonicalClass;
}
return result;
}
#endif /* !FRONTEND */
pgbouncer-1.24.1/src/common/bool.c 0000644 0001750 0000000 00000004212 14777762222 013664 0000000 0000000 /*-------------------------------------------------------------------------
*
* bool.c
* Functions for the built-in type "bool".
*
* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* src/backend/utils/adt/bool.c
*
*-------------------------------------------------------------------------
*/
#include "common/postgres_compat.h"
#include "common/builtins.h"
/*
* Try to interpret value as boolean value. Valid values are: true,
* false, yes, no, on, off, 1, 0; as well as unique prefixes thereof.
* If the string parses okay, return true, else false.
* If okay and result is not NULL, return the value in *result.
*/
bool
parse_bool(const char *value, bool *result)
{
return parse_bool_with_len(value, strlen(value), result);
}
bool
parse_bool_with_len(const char *value, size_t len, bool *result)
{
switch (*value)
{
case 't':
case 'T':
if (pg_strncasecmp(value, "true", len) == 0)
{
if (result)
*result = true;
return true;
}
break;
case 'f':
case 'F':
if (pg_strncasecmp(value, "false", len) == 0)
{
if (result)
*result = false;
return true;
}
break;
case 'y':
case 'Y':
if (pg_strncasecmp(value, "yes", len) == 0)
{
if (result)
*result = true;
return true;
}
break;
case 'n':
case 'N':
if (pg_strncasecmp(value, "no", len) == 0)
{
if (result)
*result = false;
return true;
}
break;
case 'o':
case 'O':
/* 'o' is not unique enough */
if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
{
if (result)
*result = true;
return true;
}
else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
{
if (result)
*result = false;
return true;
}
break;
case '1':
if (len == 1)
{
if (result)
*result = true;
return true;
}
break;
case '0':
if (len == 1)
{
if (result)
*result = false;
return true;
}
break;
default:
break;
}
if (result)
*result = false; /* suppress compiler warning */
return false;
}
pgbouncer-1.24.1/src/common/saslprep.c 0000644 0001750 0000000 00000062454 14777762222 014576 0000000 0000000 /*-------------------------------------------------------------------------
* saslprep.c
* SASLprep normalization, for SCRAM authentication
*
* The SASLprep algorithm is used to process a user-supplied password into
* canonical form. For more details, see:
*
* [RFC3454] Preparation of Internationalized Strings ("stringprep"),
* http://www.ietf.org/rfc/rfc3454.txt
*
* [RFC4013] SASLprep: Stringprep Profile for User Names and Passwords
* http://www.ietf.org/rfc/rfc4013.txt
*
*
* Portions Copyright (c) 2017-2020, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/common/saslprep.c
*
*-------------------------------------------------------------------------
*/
//#ifndef FRONTEND
//#include "postgres.h"
//#else
//#include "postgres_fe.h"
//#endif
#include "system.h"
#include "common/postgres_compat.h"
#include "common/saslprep.h"
#include "common/unicode_norm.h"
#include "common/pg_wchar.h"
/*
* Limit on how large password's we will try to process. A password
* larger than this will be treated the same as out-of-memory.
*/
#define MAX_PASSWORD_LENGTH 1024
/*
* In backend, we will use palloc/pfree. In frontend, use malloc, and
* return SASLPREP_OOM on out-of-memory.
*/
#ifndef FRONTEND
#define STRDUP(s) pstrdup(s)
#define ALLOC(size) palloc(size)
#define FREE(size) pfree(size)
#else
#define STRDUP(s) strdup(s)
#define ALLOC(size) malloc(size)
#define FREE(size) free(size)
#endif
/* Prototypes for local functions */
static int codepoint_range_cmp(const void *a, const void *b);
static bool is_code_in_table(pg_wchar code, const pg_wchar *map, int mapsize);
static int pg_utf8_string_len(const char *source);
static bool pg_is_ascii_string(const char *p);
/*
* Stringprep Mapping Tables.
*
* The stringprep specification includes a number of tables of Unicode
* codepoints, used in different parts of the algorithm. They are below,
* as arrays of codepoint ranges. Each range is a pair of codepoints,
* for the first and last codepoint included the range (inclusive!).
*/
/*
* C.1.2 Non-ASCII space characters
*
* These are all mapped to the ASCII space character (U+00A0).
*/
static const pg_wchar non_ascii_space_ranges[] =
{
0x00A0, 0x00A0,
0x1680, 0x1680,
0x2000, 0x200B,
0x202F, 0x202F,
0x205F, 0x205F,
0x3000, 0x3000
};
/*
* B.1 Commonly mapped to nothing
*
* If any of these appear in the input, they are removed.
*/
static const pg_wchar commonly_mapped_to_nothing_ranges[] =
{
0x00AD, 0x00AD,
0x034F, 0x034F,
0x1806, 0x1806,
0x180B, 0x180D,
0x200B, 0x200D,
0x2060, 0x2060,
0xFE00, 0xFE0F,
0xFEFF, 0xFEFF
};
/*
* prohibited_output_ranges is a union of all the characters from
* the following tables:
*
* C.1.2 Non-ASCII space characters
* C.2.1 ASCII control characters
* C.2.2 Non-ASCII control characters
* C.3 Private Use characters
* C.4 Non-character code points
* C.5 Surrogate code points
* C.6 Inappropriate for plain text characters
* C.7 Inappropriate for canonical representation characters
* C.7 Change display properties or deprecated characters
* C.8 Tagging characters
*
* These are the tables that are listed as "prohibited output"
* characters in the SASLprep profile.
*
* The comment after each code range indicates which source table
* the code came from. Note that there is some overlap in the source
* tables, so one code might originate from multiple source tables.
* Adjacent ranges have also been merged together, to save space.
*/
static const pg_wchar prohibited_output_ranges[] =
{
0x0000, 0x001F, /* C.2.1 */
0x007F, 0x00A0, /* C.1.2, C.2.1, C.2.2 */
0x0340, 0x0341, /* C.8 */
0x06DD, 0x06DD, /* C.2.2 */
0x070F, 0x070F, /* C.2.2 */
0x1680, 0x1680, /* C.1.2 */
0x180E, 0x180E, /* C.2.2 */
0x2000, 0x200F, /* C.1.2, C.2.2, C.8 */
0x2028, 0x202F, /* C.1.2, C.2.2, C.8 */
0x205F, 0x2063, /* C.1.2, C.2.2 */
0x206A, 0x206F, /* C.2.2, C.8 */
0x2FF0, 0x2FFB, /* C.7 */
0x3000, 0x3000, /* C.1.2 */
0xD800, 0xF8FF, /* C.3, C.5 */
0xFDD0, 0xFDEF, /* C.4 */
0xFEFF, 0xFEFF, /* C.2.2 */
0xFFF9, 0xFFFF, /* C.2.2, C.4, C.6 */
0x1D173, 0x1D17A, /* C.2.2 */
0x1FFFE, 0x1FFFF, /* C.4 */
0x2FFFE, 0x2FFFF, /* C.4 */
0x3FFFE, 0x3FFFF, /* C.4 */
0x4FFFE, 0x4FFFF, /* C.4 */
0x5FFFE, 0x5FFFF, /* C.4 */
0x6FFFE, 0x6FFFF, /* C.4 */
0x7FFFE, 0x7FFFF, /* C.4 */
0x8FFFE, 0x8FFFF, /* C.4 */
0x9FFFE, 0x9FFFF, /* C.4 */
0xAFFFE, 0xAFFFF, /* C.4 */
0xBFFFE, 0xBFFFF, /* C.4 */
0xCFFFE, 0xCFFFF, /* C.4 */
0xDFFFE, 0xDFFFF, /* C.4 */
0xE0001, 0xE0001, /* C.9 */
0xE0020, 0xE007F, /* C.9 */
0xEFFFE, 0xEFFFF, /* C.4 */
0xF0000, 0xFFFFF, /* C.3, C.4 */
0x100000, 0x10FFFF /* C.3, C.4 */
};
/* A.1 Unassigned code points in Unicode 3.2 */
static const pg_wchar unassigned_codepoint_ranges[] =
{
0x0221, 0x0221,
0x0234, 0x024F,
0x02AE, 0x02AF,
0x02EF, 0x02FF,
0x0350, 0x035F,
0x0370, 0x0373,
0x0376, 0x0379,
0x037B, 0x037D,
0x037F, 0x0383,
0x038B, 0x038B,
0x038D, 0x038D,
0x03A2, 0x03A2,
0x03CF, 0x03CF,
0x03F7, 0x03FF,
0x0487, 0x0487,
0x04CF, 0x04CF,
0x04F6, 0x04F7,
0x04FA, 0x04FF,
0x0510, 0x0530,
0x0557, 0x0558,
0x0560, 0x0560,
0x0588, 0x0588,
0x058B, 0x0590,
0x05A2, 0x05A2,
0x05BA, 0x05BA,
0x05C5, 0x05CF,
0x05EB, 0x05EF,
0x05F5, 0x060B,
0x060D, 0x061A,
0x061C, 0x061E,
0x0620, 0x0620,
0x063B, 0x063F,
0x0656, 0x065F,
0x06EE, 0x06EF,
0x06FF, 0x06FF,
0x070E, 0x070E,
0x072D, 0x072F,
0x074B, 0x077F,
0x07B2, 0x0900,
0x0904, 0x0904,
0x093A, 0x093B,
0x094E, 0x094F,
0x0955, 0x0957,
0x0971, 0x0980,
0x0984, 0x0984,
0x098D, 0x098E,
0x0991, 0x0992,
0x09A9, 0x09A9,
0x09B1, 0x09B1,
0x09B3, 0x09B5,
0x09BA, 0x09BB,
0x09BD, 0x09BD,
0x09C5, 0x09C6,
0x09C9, 0x09CA,
0x09CE, 0x09D6,
0x09D8, 0x09DB,
0x09DE, 0x09DE,
0x09E4, 0x09E5,
0x09FB, 0x0A01,
0x0A03, 0x0A04,
0x0A0B, 0x0A0E,
0x0A11, 0x0A12,
0x0A29, 0x0A29,
0x0A31, 0x0A31,
0x0A34, 0x0A34,
0x0A37, 0x0A37,
0x0A3A, 0x0A3B,
0x0A3D, 0x0A3D,
0x0A43, 0x0A46,
0x0A49, 0x0A4A,
0x0A4E, 0x0A58,
0x0A5D, 0x0A5D,
0x0A5F, 0x0A65,
0x0A75, 0x0A80,
0x0A84, 0x0A84,
0x0A8C, 0x0A8C,
0x0A8E, 0x0A8E,
0x0A92, 0x0A92,
0x0AA9, 0x0AA9,
0x0AB1, 0x0AB1,
0x0AB4, 0x0AB4,
0x0ABA, 0x0ABB,
0x0AC6, 0x0AC6,
0x0ACA, 0x0ACA,
0x0ACE, 0x0ACF,
0x0AD1, 0x0ADF,
0x0AE1, 0x0AE5,
0x0AF0, 0x0B00,
0x0B04, 0x0B04,
0x0B0D, 0x0B0E,
0x0B11, 0x0B12,
0x0B29, 0x0B29,
0x0B31, 0x0B31,
0x0B34, 0x0B35,
0x0B3A, 0x0B3B,
0x0B44, 0x0B46,
0x0B49, 0x0B4A,
0x0B4E, 0x0B55,
0x0B58, 0x0B5B,
0x0B5E, 0x0B5E,
0x0B62, 0x0B65,
0x0B71, 0x0B81,
0x0B84, 0x0B84,
0x0B8B, 0x0B8D,
0x0B91, 0x0B91,
0x0B96, 0x0B98,
0x0B9B, 0x0B9B,
0x0B9D, 0x0B9D,
0x0BA0, 0x0BA2,
0x0BA5, 0x0BA7,
0x0BAB, 0x0BAD,
0x0BB6, 0x0BB6,
0x0BBA, 0x0BBD,
0x0BC3, 0x0BC5,
0x0BC9, 0x0BC9,
0x0BCE, 0x0BD6,
0x0BD8, 0x0BE6,
0x0BF3, 0x0C00,
0x0C04, 0x0C04,
0x0C0D, 0x0C0D,
0x0C11, 0x0C11,
0x0C29, 0x0C29,
0x0C34, 0x0C34,
0x0C3A, 0x0C3D,
0x0C45, 0x0C45,
0x0C49, 0x0C49,
0x0C4E, 0x0C54,
0x0C57, 0x0C5F,
0x0C62, 0x0C65,
0x0C70, 0x0C81,
0x0C84, 0x0C84,
0x0C8D, 0x0C8D,
0x0C91, 0x0C91,
0x0CA9, 0x0CA9,
0x0CB4, 0x0CB4,
0x0CBA, 0x0CBD,
0x0CC5, 0x0CC5,
0x0CC9, 0x0CC9,
0x0CCE, 0x0CD4,
0x0CD7, 0x0CDD,
0x0CDF, 0x0CDF,
0x0CE2, 0x0CE5,
0x0CF0, 0x0D01,
0x0D04, 0x0D04,
0x0D0D, 0x0D0D,
0x0D11, 0x0D11,
0x0D29, 0x0D29,
0x0D3A, 0x0D3D,
0x0D44, 0x0D45,
0x0D49, 0x0D49,
0x0D4E, 0x0D56,
0x0D58, 0x0D5F,
0x0D62, 0x0D65,
0x0D70, 0x0D81,
0x0D84, 0x0D84,
0x0D97, 0x0D99,
0x0DB2, 0x0DB2,
0x0DBC, 0x0DBC,
0x0DBE, 0x0DBF,
0x0DC7, 0x0DC9,
0x0DCB, 0x0DCE,
0x0DD5, 0x0DD5,
0x0DD7, 0x0DD7,
0x0DE0, 0x0DF1,
0x0DF5, 0x0E00,
0x0E3B, 0x0E3E,
0x0E5C, 0x0E80,
0x0E83, 0x0E83,
0x0E85, 0x0E86,
0x0E89, 0x0E89,
0x0E8B, 0x0E8C,
0x0E8E, 0x0E93,
0x0E98, 0x0E98,
0x0EA0, 0x0EA0,
0x0EA4, 0x0EA4,
0x0EA6, 0x0EA6,
0x0EA8, 0x0EA9,
0x0EAC, 0x0EAC,
0x0EBA, 0x0EBA,
0x0EBE, 0x0EBF,
0x0EC5, 0x0EC5,
0x0EC7, 0x0EC7,
0x0ECE, 0x0ECF,
0x0EDA, 0x0EDB,
0x0EDE, 0x0EFF,
0x0F48, 0x0F48,
0x0F6B, 0x0F70,
0x0F8C, 0x0F8F,
0x0F98, 0x0F98,
0x0FBD, 0x0FBD,
0x0FCD, 0x0FCE,
0x0FD0, 0x0FFF,
0x1022, 0x1022,
0x1028, 0x1028,
0x102B, 0x102B,
0x1033, 0x1035,
0x103A, 0x103F,
0x105A, 0x109F,
0x10C6, 0x10CF,
0x10F9, 0x10FA,
0x10FC, 0x10FF,
0x115A, 0x115E,
0x11A3, 0x11A7,
0x11FA, 0x11FF,
0x1207, 0x1207,
0x1247, 0x1247,
0x1249, 0x1249,
0x124E, 0x124F,
0x1257, 0x1257,
0x1259, 0x1259,
0x125E, 0x125F,
0x1287, 0x1287,
0x1289, 0x1289,
0x128E, 0x128F,
0x12AF, 0x12AF,
0x12B1, 0x12B1,
0x12B6, 0x12B7,
0x12BF, 0x12BF,
0x12C1, 0x12C1,
0x12C6, 0x12C7,
0x12CF, 0x12CF,
0x12D7, 0x12D7,
0x12EF, 0x12EF,
0x130F, 0x130F,
0x1311, 0x1311,
0x1316, 0x1317,
0x131F, 0x131F,
0x1347, 0x1347,
0x135B, 0x1360,
0x137D, 0x139F,
0x13F5, 0x1400,
0x1677, 0x167F,
0x169D, 0x169F,
0x16F1, 0x16FF,
0x170D, 0x170D,
0x1715, 0x171F,
0x1737, 0x173F,
0x1754, 0x175F,
0x176D, 0x176D,
0x1771, 0x1771,
0x1774, 0x177F,
0x17DD, 0x17DF,
0x17EA, 0x17FF,
0x180F, 0x180F,
0x181A, 0x181F,
0x1878, 0x187F,
0x18AA, 0x1DFF,
0x1E9C, 0x1E9F,
0x1EFA, 0x1EFF,
0x1F16, 0x1F17,
0x1F1E, 0x1F1F,
0x1F46, 0x1F47,
0x1F4E, 0x1F4F,
0x1F58, 0x1F58,
0x1F5A, 0x1F5A,
0x1F5C, 0x1F5C,
0x1F5E, 0x1F5E,
0x1F7E, 0x1F7F,
0x1FB5, 0x1FB5,
0x1FC5, 0x1FC5,
0x1FD4, 0x1FD5,
0x1FDC, 0x1FDC,
0x1FF0, 0x1FF1,
0x1FF5, 0x1FF5,
0x1FFF, 0x1FFF,
0x2053, 0x2056,
0x2058, 0x205E,
0x2064, 0x2069,
0x2072, 0x2073,
0x208F, 0x209F,
0x20B2, 0x20CF,
0x20EB, 0x20FF,
0x213B, 0x213C,
0x214C, 0x2152,
0x2184, 0x218F,
0x23CF, 0x23FF,
0x2427, 0x243F,
0x244B, 0x245F,
0x24FF, 0x24FF,
0x2614, 0x2615,
0x2618, 0x2618,
0x267E, 0x267F,
0x268A, 0x2700,
0x2705, 0x2705,
0x270A, 0x270B,
0x2728, 0x2728,
0x274C, 0x274C,
0x274E, 0x274E,
0x2753, 0x2755,
0x2757, 0x2757,
0x275F, 0x2760,
0x2795, 0x2797,
0x27B0, 0x27B0,
0x27BF, 0x27CF,
0x27EC, 0x27EF,
0x2B00, 0x2E7F,
0x2E9A, 0x2E9A,
0x2EF4, 0x2EFF,
0x2FD6, 0x2FEF,
0x2FFC, 0x2FFF,
0x3040, 0x3040,
0x3097, 0x3098,
0x3100, 0x3104,
0x312D, 0x3130,
0x318F, 0x318F,
0x31B8, 0x31EF,
0x321D, 0x321F,
0x3244, 0x3250,
0x327C, 0x327E,
0x32CC, 0x32CF,
0x32FF, 0x32FF,
0x3377, 0x337A,
0x33DE, 0x33DF,
0x33FF, 0x33FF,
0x4DB6, 0x4DFF,
0x9FA6, 0x9FFF,
0xA48D, 0xA48F,
0xA4C7, 0xABFF,
0xD7A4, 0xD7FF,
0xFA2E, 0xFA2F,
0xFA6B, 0xFAFF,
0xFB07, 0xFB12,
0xFB18, 0xFB1C,
0xFB37, 0xFB37,
0xFB3D, 0xFB3D,
0xFB3F, 0xFB3F,
0xFB42, 0xFB42,
0xFB45, 0xFB45,
0xFBB2, 0xFBD2,
0xFD40, 0xFD4F,
0xFD90, 0xFD91,
0xFDC8, 0xFDCF,
0xFDFD, 0xFDFF,
0xFE10, 0xFE1F,
0xFE24, 0xFE2F,
0xFE47, 0xFE48,
0xFE53, 0xFE53,
0xFE67, 0xFE67,
0xFE6C, 0xFE6F,
0xFE75, 0xFE75,
0xFEFD, 0xFEFE,
0xFF00, 0xFF00,
0xFFBF, 0xFFC1,
0xFFC8, 0xFFC9,
0xFFD0, 0xFFD1,
0xFFD8, 0xFFD9,
0xFFDD, 0xFFDF,
0xFFE7, 0xFFE7,
0xFFEF, 0xFFF8,
0x10000, 0x102FF,
0x1031F, 0x1031F,
0x10324, 0x1032F,
0x1034B, 0x103FF,
0x10426, 0x10427,
0x1044E, 0x1CFFF,
0x1D0F6, 0x1D0FF,
0x1D127, 0x1D129,
0x1D1DE, 0x1D3FF,
0x1D455, 0x1D455,
0x1D49D, 0x1D49D,
0x1D4A0, 0x1D4A1,
0x1D4A3, 0x1D4A4,
0x1D4A7, 0x1D4A8,
0x1D4AD, 0x1D4AD,
0x1D4BA, 0x1D4BA,
0x1D4BC, 0x1D4BC,
0x1D4C1, 0x1D4C1,
0x1D4C4, 0x1D4C4,
0x1D506, 0x1D506,
0x1D50B, 0x1D50C,
0x1D515, 0x1D515,
0x1D51D, 0x1D51D,
0x1D53A, 0x1D53A,
0x1D53F, 0x1D53F,
0x1D545, 0x1D545,
0x1D547, 0x1D549,
0x1D551, 0x1D551,
0x1D6A4, 0x1D6A7,
0x1D7CA, 0x1D7CD,
0x1D800, 0x1FFFD,
0x2A6D7, 0x2F7FF,
0x2FA1E, 0x2FFFD,
0x30000, 0x3FFFD,
0x40000, 0x4FFFD,
0x50000, 0x5FFFD,
0x60000, 0x6FFFD,
0x70000, 0x7FFFD,
0x80000, 0x8FFFD,
0x90000, 0x9FFFD,
0xA0000, 0xAFFFD,
0xB0000, 0xBFFFD,
0xC0000, 0xCFFFD,
0xD0000, 0xDFFFD,
0xE0000, 0xE0000,
0xE0002, 0xE001F,
0xE0080, 0xEFFFD
};
/* D.1 Characters with bidirectional property "R" or "AL" */
static const pg_wchar RandALCat_codepoint_ranges[] =
{
0x05BE, 0x05BE,
0x05C0, 0x05C0,
0x05C3, 0x05C3,
0x05D0, 0x05EA,
0x05F0, 0x05F4,
0x061B, 0x061B,
0x061F, 0x061F,
0x0621, 0x063A,
0x0640, 0x064A,
0x066D, 0x066F,
0x0671, 0x06D5,
0x06DD, 0x06DD,
0x06E5, 0x06E6,
0x06FA, 0x06FE,
0x0700, 0x070D,
0x0710, 0x0710,
0x0712, 0x072C,
0x0780, 0x07A5,
0x07B1, 0x07B1,
0x200F, 0x200F,
0xFB1D, 0xFB1D,
0xFB1F, 0xFB28,
0xFB2A, 0xFB36,
0xFB38, 0xFB3C,
0xFB3E, 0xFB3E,
0xFB40, 0xFB41,
0xFB43, 0xFB44,
0xFB46, 0xFBB1,
0xFBD3, 0xFD3D,
0xFD50, 0xFD8F,
0xFD92, 0xFDC7,
0xFDF0, 0xFDFC,
0xFE70, 0xFE74,
0xFE76, 0xFEFC
};
/* D.2 Characters with bidirectional property "L" */
static const pg_wchar LCat_codepoint_ranges[] =
{
0x0041, 0x005A,
0x0061, 0x007A,
0x00AA, 0x00AA,
0x00B5, 0x00B5,
0x00BA, 0x00BA,
0x00C0, 0x00D6,
0x00D8, 0x00F6,
0x00F8, 0x0220,
0x0222, 0x0233,
0x0250, 0x02AD,
0x02B0, 0x02B8,
0x02BB, 0x02C1,
0x02D0, 0x02D1,
0x02E0, 0x02E4,
0x02EE, 0x02EE,
0x037A, 0x037A,
0x0386, 0x0386,
0x0388, 0x038A,
0x038C, 0x038C,
0x038E, 0x03A1,
0x03A3, 0x03CE,
0x03D0, 0x03F5,
0x0400, 0x0482,
0x048A, 0x04CE,
0x04D0, 0x04F5,
0x04F8, 0x04F9,
0x0500, 0x050F,
0x0531, 0x0556,
0x0559, 0x055F,
0x0561, 0x0587,
0x0589, 0x0589,
0x0903, 0x0903,
0x0905, 0x0939,
0x093D, 0x0940,
0x0949, 0x094C,
0x0950, 0x0950,
0x0958, 0x0961,
0x0964, 0x0970,
0x0982, 0x0983,
0x0985, 0x098C,
0x098F, 0x0990,
0x0993, 0x09A8,
0x09AA, 0x09B0,
0x09B2, 0x09B2,
0x09B6, 0x09B9,
0x09BE, 0x09C0,
0x09C7, 0x09C8,
0x09CB, 0x09CC,
0x09D7, 0x09D7,
0x09DC, 0x09DD,
0x09DF, 0x09E1,
0x09E6, 0x09F1,
0x09F4, 0x09FA,
0x0A05, 0x0A0A,
0x0A0F, 0x0A10,
0x0A13, 0x0A28,
0x0A2A, 0x0A30,
0x0A32, 0x0A33,
0x0A35, 0x0A36,
0x0A38, 0x0A39,
0x0A3E, 0x0A40,
0x0A59, 0x0A5C,
0x0A5E, 0x0A5E,
0x0A66, 0x0A6F,
0x0A72, 0x0A74,
0x0A83, 0x0A83,
0x0A85, 0x0A8B,
0x0A8D, 0x0A8D,
0x0A8F, 0x0A91,
0x0A93, 0x0AA8,
0x0AAA, 0x0AB0,
0x0AB2, 0x0AB3,
0x0AB5, 0x0AB9,
0x0ABD, 0x0AC0,
0x0AC9, 0x0AC9,
0x0ACB, 0x0ACC,
0x0AD0, 0x0AD0,
0x0AE0, 0x0AE0,
0x0AE6, 0x0AEF,
0x0B02, 0x0B03,
0x0B05, 0x0B0C,
0x0B0F, 0x0B10,
0x0B13, 0x0B28,
0x0B2A, 0x0B30,
0x0B32, 0x0B33,
0x0B36, 0x0B39,
0x0B3D, 0x0B3E,
0x0B40, 0x0B40,
0x0B47, 0x0B48,
0x0B4B, 0x0B4C,
0x0B57, 0x0B57,
0x0B5C, 0x0B5D,
0x0B5F, 0x0B61,
0x0B66, 0x0B70,
0x0B83, 0x0B83,
0x0B85, 0x0B8A,
0x0B8E, 0x0B90,
0x0B92, 0x0B95,
0x0B99, 0x0B9A,
0x0B9C, 0x0B9C,
0x0B9E, 0x0B9F,
0x0BA3, 0x0BA4,
0x0BA8, 0x0BAA,
0x0BAE, 0x0BB5,
0x0BB7, 0x0BB9,
0x0BBE, 0x0BBF,
0x0BC1, 0x0BC2,
0x0BC6, 0x0BC8,
0x0BCA, 0x0BCC,
0x0BD7, 0x0BD7,
0x0BE7, 0x0BF2,
0x0C01, 0x0C03,
0x0C05, 0x0C0C,
0x0C0E, 0x0C10,
0x0C12, 0x0C28,
0x0C2A, 0x0C33,
0x0C35, 0x0C39,
0x0C41, 0x0C44,
0x0C60, 0x0C61,
0x0C66, 0x0C6F,
0x0C82, 0x0C83,
0x0C85, 0x0C8C,
0x0C8E, 0x0C90,
0x0C92, 0x0CA8,
0x0CAA, 0x0CB3,
0x0CB5, 0x0CB9,
0x0CBE, 0x0CBE,
0x0CC0, 0x0CC4,
0x0CC7, 0x0CC8,
0x0CCA, 0x0CCB,
0x0CD5, 0x0CD6,
0x0CDE, 0x0CDE,
0x0CE0, 0x0CE1,
0x0CE6, 0x0CEF,
0x0D02, 0x0D03,
0x0D05, 0x0D0C,
0x0D0E, 0x0D10,
0x0D12, 0x0D28,
0x0D2A, 0x0D39,
0x0D3E, 0x0D40,
0x0D46, 0x0D48,
0x0D4A, 0x0D4C,
0x0D57, 0x0D57,
0x0D60, 0x0D61,
0x0D66, 0x0D6F,
0x0D82, 0x0D83,
0x0D85, 0x0D96,
0x0D9A, 0x0DB1,
0x0DB3, 0x0DBB,
0x0DBD, 0x0DBD,
0x0DC0, 0x0DC6,
0x0DCF, 0x0DD1,
0x0DD8, 0x0DDF,
0x0DF2, 0x0DF4,
0x0E01, 0x0E30,
0x0E32, 0x0E33,
0x0E40, 0x0E46,
0x0E4F, 0x0E5B,
0x0E81, 0x0E82,
0x0E84, 0x0E84,
0x0E87, 0x0E88,
0x0E8A, 0x0E8A,
0x0E8D, 0x0E8D,
0x0E94, 0x0E97,
0x0E99, 0x0E9F,
0x0EA1, 0x0EA3,
0x0EA5, 0x0EA5,
0x0EA7, 0x0EA7,
0x0EAA, 0x0EAB,
0x0EAD, 0x0EB0,
0x0EB2, 0x0EB3,
0x0EBD, 0x0EBD,
0x0EC0, 0x0EC4,
0x0EC6, 0x0EC6,
0x0ED0, 0x0ED9,
0x0EDC, 0x0EDD,
0x0F00, 0x0F17,
0x0F1A, 0x0F34,
0x0F36, 0x0F36,
0x0F38, 0x0F38,
0x0F3E, 0x0F47,
0x0F49, 0x0F6A,
0x0F7F, 0x0F7F,
0x0F85, 0x0F85,
0x0F88, 0x0F8B,
0x0FBE, 0x0FC5,
0x0FC7, 0x0FCC,
0x0FCF, 0x0FCF,
0x1000, 0x1021,
0x1023, 0x1027,
0x1029, 0x102A,
0x102C, 0x102C,
0x1031, 0x1031,
0x1038, 0x1038,
0x1040, 0x1057,
0x10A0, 0x10C5,
0x10D0, 0x10F8,
0x10FB, 0x10FB,
0x1100, 0x1159,
0x115F, 0x11A2,
0x11A8, 0x11F9,
0x1200, 0x1206,
0x1208, 0x1246,
0x1248, 0x1248,
0x124A, 0x124D,
0x1250, 0x1256,
0x1258, 0x1258,
0x125A, 0x125D,
0x1260, 0x1286,
0x1288, 0x1288,
0x128A, 0x128D,
0x1290, 0x12AE,
0x12B0, 0x12B0,
0x12B2, 0x12B5,
0x12B8, 0x12BE,
0x12C0, 0x12C0,
0x12C2, 0x12C5,
0x12C8, 0x12CE,
0x12D0, 0x12D6,
0x12D8, 0x12EE,
0x12F0, 0x130E,
0x1310, 0x1310,
0x1312, 0x1315,
0x1318, 0x131E,
0x1320, 0x1346,
0x1348, 0x135A,
0x1361, 0x137C,
0x13A0, 0x13F4,
0x1401, 0x1676,
0x1681, 0x169A,
0x16A0, 0x16F0,
0x1700, 0x170C,
0x170E, 0x1711,
0x1720, 0x1731,
0x1735, 0x1736,
0x1740, 0x1751,
0x1760, 0x176C,
0x176E, 0x1770,
0x1780, 0x17B6,
0x17BE, 0x17C5,
0x17C7, 0x17C8,
0x17D4, 0x17DA,
0x17DC, 0x17DC,
0x17E0, 0x17E9,
0x1810, 0x1819,
0x1820, 0x1877,
0x1880, 0x18A8,
0x1E00, 0x1E9B,
0x1EA0, 0x1EF9,
0x1F00, 0x1F15,
0x1F18, 0x1F1D,
0x1F20, 0x1F45,
0x1F48, 0x1F4D,
0x1F50, 0x1F57,
0x1F59, 0x1F59,
0x1F5B, 0x1F5B,
0x1F5D, 0x1F5D,
0x1F5F, 0x1F7D,
0x1F80, 0x1FB4,
0x1FB6, 0x1FBC,
0x1FBE, 0x1FBE,
0x1FC2, 0x1FC4,
0x1FC6, 0x1FCC,
0x1FD0, 0x1FD3,
0x1FD6, 0x1FDB,
0x1FE0, 0x1FEC,
0x1FF2, 0x1FF4,
0x1FF6, 0x1FFC,
0x200E, 0x200E,
0x2071, 0x2071,
0x207F, 0x207F,
0x2102, 0x2102,
0x2107, 0x2107,
0x210A, 0x2113,
0x2115, 0x2115,
0x2119, 0x211D,
0x2124, 0x2124,
0x2126, 0x2126,
0x2128, 0x2128,
0x212A, 0x212D,
0x212F, 0x2131,
0x2133, 0x2139,
0x213D, 0x213F,
0x2145, 0x2149,
0x2160, 0x2183,
0x2336, 0x237A,
0x2395, 0x2395,
0x249C, 0x24E9,
0x3005, 0x3007,
0x3021, 0x3029,
0x3031, 0x3035,
0x3038, 0x303C,
0x3041, 0x3096,
0x309D, 0x309F,
0x30A1, 0x30FA,
0x30FC, 0x30FF,
0x3105, 0x312C,
0x3131, 0x318E,
0x3190, 0x31B7,
0x31F0, 0x321C,
0x3220, 0x3243,
0x3260, 0x327B,
0x327F, 0x32B0,
0x32C0, 0x32CB,
0x32D0, 0x32FE,
0x3300, 0x3376,
0x337B, 0x33DD,
0x33E0, 0x33FE,
0x3400, 0x4DB5,
0x4E00, 0x9FA5,
0xA000, 0xA48C,
0xAC00, 0xD7A3,
0xD800, 0xFA2D,
0xFA30, 0xFA6A,
0xFB00, 0xFB06,
0xFB13, 0xFB17,
0xFF21, 0xFF3A,
0xFF41, 0xFF5A,
0xFF66, 0xFFBE,
0xFFC2, 0xFFC7,
0xFFCA, 0xFFCF,
0xFFD2, 0xFFD7,
0xFFDA, 0xFFDC,
0x10300, 0x1031E,
0x10320, 0x10323,
0x10330, 0x1034A,
0x10400, 0x10425,
0x10428, 0x1044D,
0x1D000, 0x1D0F5,
0x1D100, 0x1D126,
0x1D12A, 0x1D166,
0x1D16A, 0x1D172,
0x1D183, 0x1D184,
0x1D18C, 0x1D1A9,
0x1D1AE, 0x1D1DD,
0x1D400, 0x1D454,
0x1D456, 0x1D49C,
0x1D49E, 0x1D49F,
0x1D4A2, 0x1D4A2,
0x1D4A5, 0x1D4A6,
0x1D4A9, 0x1D4AC,
0x1D4AE, 0x1D4B9,
0x1D4BB, 0x1D4BB,
0x1D4BD, 0x1D4C0,
0x1D4C2, 0x1D4C3,
0x1D4C5, 0x1D505,
0x1D507, 0x1D50A,
0x1D50D, 0x1D514,
0x1D516, 0x1D51C,
0x1D51E, 0x1D539,
0x1D53B, 0x1D53E,
0x1D540, 0x1D544,
0x1D546, 0x1D546,
0x1D54A, 0x1D550,
0x1D552, 0x1D6A3,
0x1D6A8, 0x1D7C9,
0x20000, 0x2A6D6,
0x2F800, 0x2FA1D,
0xF0000, 0xFFFFD,
0x100000, 0x10FFFD
};
/* End of stringprep tables */
/* Is the given Unicode codepoint in the given table of ranges? */
#define IS_CODE_IN_TABLE(code, map) is_code_in_table(code, map, lengthof(map))
static int
codepoint_range_cmp(const void *a, const void *b)
{
const pg_wchar *key = (const pg_wchar *) a;
const pg_wchar *range = (const pg_wchar *) b;
if (*key < range[0])
return -1; /* less than lower bound */
if (*key > range[1])
return 1; /* greater than upper bound */
return 0; /* within range */
}
static bool
is_code_in_table(pg_wchar code, const pg_wchar *map, int mapsize)
{
Assert(mapsize % 2 == 0);
if (code < map[0] || code > map[mapsize - 1])
return false;
if (bsearch(&code, map, mapsize / 2, sizeof(pg_wchar) * 2,
codepoint_range_cmp))
return true;
else
return false;
}
/*
* Calculate the length in characters of a null-terminated UTF-8 string.
*
* Returns -1 if the input is not valid UTF-8.
*/
static int
pg_utf8_string_len(const char *source)
{
const unsigned char *p = (const unsigned char *) source;
int l;
int num_chars = 0;
while (*p)
{
l = pg_utf_mblen(p);
if (!pg_utf8_islegal(p, l))
return -1;
p += l;
num_chars++;
}
return num_chars;
}
/*
* Returns true if the input string is pure ASCII.
*/
static bool
pg_is_ascii_string(const char *p)
{
while (*p)
{
if (IS_HIGHBIT_SET(*p))
return false;
p++;
}
return true;
}
/*
* pg_saslprep - Normalize a password with SASLprep.
*
* SASLprep requires the input to be in UTF-8 encoding, but PostgreSQL
* supports many encodings, so we don't blindly assume that. pg_saslprep
* will check if the input looks like valid UTF-8, and returns
* SASLPREP_INVALID_UTF8 if not.
*
* If the string contains prohibited characters (or more precisely, if the
* output string would contain prohibited characters after normalization),
* returns SASLPREP_PROHIBITED.
*
* On success, returns SASLPREP_SUCCESS, and the normalized string in
* *output.
*
* In frontend, the normalized string is malloc'd, and the caller is
* responsible for freeing it. If an allocation fails, returns
* SASLPREP_OOM. In backend, the normalized string is palloc'd instead,
* and a failed allocation leads to ereport(ERROR).
*/
pg_saslprep_rc
pg_saslprep(const char *input, char **output)
{
pg_wchar *input_chars = NULL;
pg_wchar *output_chars = NULL;
int input_size;
char *result;
int result_size;
int count;
int i;
bool contains_RandALCat;
unsigned char *p;
pg_wchar *wp;
/* Ensure we return *output as NULL on failure */
*output = NULL;
/* Check that the password isn't stupendously long */
if (strlen(input) > MAX_PASSWORD_LENGTH)
{
#ifndef FRONTEND
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg("password too long")));
#else
return SASLPREP_OOM;
#endif
}
/*
* Quick check if the input is pure ASCII. An ASCII string requires no
* further processing.
*/
if (pg_is_ascii_string(input))
{
*output = STRDUP(input);
if (!(*output))
goto oom;
return SASLPREP_SUCCESS;
}
/*
* Convert the input from UTF-8 to an array of Unicode codepoints.
*
* This also checks that the input is a legal UTF-8 string.
*/
input_size = pg_utf8_string_len(input);
if (input_size < 0)
return SASLPREP_INVALID_UTF8;
input_chars = ALLOC((input_size + 1) * sizeof(pg_wchar));
if (!input_chars)
goto oom;
p = (unsigned char *) input;
for (i = 0; i < input_size; i++)
{
input_chars[i] = utf8_to_unicode(p);
p += pg_utf_mblen(p);
}
input_chars[i] = (pg_wchar) '\0';
/*
* The steps below correspond to the steps listed in [RFC3454], Section
* "2. Preparation Overview"
*/
/*
* 1) Map -- For each character in the input, check if it has a mapping
* and, if so, replace it with its mapping.
*/
count = 0;
for (i = 0; i < input_size; i++)
{
pg_wchar code = input_chars[i];
if (IS_CODE_IN_TABLE(code, non_ascii_space_ranges))
input_chars[count++] = 0x0020;
else if (IS_CODE_IN_TABLE(code, commonly_mapped_to_nothing_ranges))
{
/* map to nothing */
}
else
input_chars[count++] = code;
}
input_chars[count] = (pg_wchar) '\0';
input_size = count;
if (input_size == 0)
goto prohibited; /* don't allow empty password */
/*
* 2) Normalize -- Normalize the result of step 1 using Unicode
* normalization.
*/
output_chars = unicode_normalize(UNICODE_NFKC, input_chars);
if (!output_chars)
goto oom;
/*
* 3) Prohibit -- Check for any characters that are not allowed in the
* output. If any are found, return an error.
*/
for (i = 0; i < input_size; i++)
{
pg_wchar code = input_chars[i];
if (IS_CODE_IN_TABLE(code, prohibited_output_ranges))
goto prohibited;
if (IS_CODE_IN_TABLE(code, unassigned_codepoint_ranges))
goto prohibited;
}
/*
* 4) Check bidi -- Possibly check for right-to-left characters, and if
* any are found, make sure that the whole string satisfies the
* requirements for bidirectional strings. If the string does not satisfy
* the requirements for bidirectional strings, return an error.
*
* [RFC3454], Section "6. Bidirectional Characters" explains in more
* detail what that means:
*
* "In any profile that specifies bidirectional character handling, all
* three of the following requirements MUST be met:
*
* 1) The characters in section 5.8 MUST be prohibited.
*
* 2) If a string contains any RandALCat character, the string MUST NOT
* contain any LCat character.
*
* 3) If a string contains any RandALCat character, a RandALCat character
* MUST be the first character of the string, and a RandALCat character
* MUST be the last character of the string."
*/
contains_RandALCat = false;
for (i = 0; i < input_size; i++)
{
pg_wchar code = input_chars[i];
if (IS_CODE_IN_TABLE(code, RandALCat_codepoint_ranges))
{
contains_RandALCat = true;
break;
}
}
if (contains_RandALCat)
{
pg_wchar first = input_chars[0];
pg_wchar last = input_chars[input_size - 1];
for (i = 0; i < input_size; i++)
{
pg_wchar code = input_chars[i];
if (IS_CODE_IN_TABLE(code, LCat_codepoint_ranges))
goto prohibited;
}
if (!IS_CODE_IN_TABLE(first, RandALCat_codepoint_ranges) ||
!IS_CODE_IN_TABLE(last, RandALCat_codepoint_ranges))
goto prohibited;
}
/*
* Finally, convert the result back to UTF-8.
*/
result_size = 0;
for (wp = output_chars; *wp; wp++)
{
unsigned char buf[4];
unicode_to_utf8(*wp, buf);
result_size += pg_utf_mblen(buf);
}
result = ALLOC(result_size + 1);
if (!result)
goto oom;
/*
* There are no error exits below here, so the error exit paths don't need
* to worry about possibly freeing "result".
*/
p = (unsigned char *) result;
for (wp = output_chars; *wp; wp++)
{
unicode_to_utf8(*wp, p);
p += pg_utf_mblen(p);
}
Assert((char *) p == result + result_size);
*p = '\0';
FREE(input_chars);
FREE(output_chars);
*output = result;
return SASLPREP_SUCCESS;
prohibited:
if (input_chars)
FREE(input_chars);
if (output_chars)
FREE(output_chars);
return SASLPREP_PROHIBITED;
oom:
if (input_chars)
FREE(input_chars);
if (output_chars)
FREE(output_chars);
return SASLPREP_OOM;
}
pgbouncer-1.24.1/src/common/scram-common.c 0000644 0001750 0000000 00000015522 14777762222 015332 0000000 0000000 /*-------------------------------------------------------------------------
* scram-common.c
* Shared frontend/backend code for SCRAM authentication
*
* This contains the common low-level functions needed in both frontend and
* backend, for implement the Salted Challenge Response Authentication
* Mechanism (SCRAM), per IETF's RFC 5802.
*
* Portions Copyright (c) 2017-2020, PostgreSQL Global Development Group
*
* IDENTIFICATION
* src/common/scram-common.c
*
*-------------------------------------------------------------------------
*/
//#ifndef FRONTEND
//#include "postgres.h"
//#else
//#include "postgres_fe.h"
//#endif
#include "system.h"
#include "common/postgres_compat.h"
#include "usual/crypto/sha256.h"
#include "usual/endian.h"
#include "common/base64.h"
#include "common/scram-common.h"
#define HMAC_IPAD 0x36
#define HMAC_OPAD 0x5C
/*
* Calculate HMAC per RFC2104.
*
* The hash function used is SHA-256.
*/
void
scram_HMAC_init(scram_HMAC_ctx *ctx, const uint8 *key, int keylen)
{
uint8 k_ipad[SHA256_HMAC_B];
int i;
uint8 keybuf[SCRAM_KEY_LEN];
/*
* If the key is longer than the block size (64 bytes for SHA-256), pass
* it through SHA-256 once to shrink it down.
*/
if (keylen > SHA256_HMAC_B)
{
pg_sha256_ctx sha256_ctx;
pg_sha256_init(&sha256_ctx);
pg_sha256_update(&sha256_ctx, key, keylen);
pg_sha256_final(&sha256_ctx, keybuf);
key = keybuf;
keylen = SCRAM_KEY_LEN;
}
memset(k_ipad, HMAC_IPAD, SHA256_HMAC_B);
memset(ctx->k_opad, HMAC_OPAD, SHA256_HMAC_B);
for (i = 0; i < keylen; i++)
{
k_ipad[i] ^= key[i];
ctx->k_opad[i] ^= key[i];
}
/* tmp = H(K XOR ipad, text) */
pg_sha256_init(&ctx->sha256ctx);
pg_sha256_update(&ctx->sha256ctx, k_ipad, SHA256_HMAC_B);
}
/*
* Update HMAC calculation
* The hash function used is SHA-256.
*/
void
scram_HMAC_update(scram_HMAC_ctx *ctx, const char *str, int slen)
{
pg_sha256_update(&ctx->sha256ctx, (const uint8 *) str, slen);
}
/*
* Finalize HMAC calculation.
* The hash function used is SHA-256.
*/
void
scram_HMAC_final(uint8 *result, scram_HMAC_ctx *ctx)
{
uint8 h[SCRAM_KEY_LEN];
pg_sha256_final(&ctx->sha256ctx, h);
/* H(K XOR opad, tmp) */
pg_sha256_init(&ctx->sha256ctx);
pg_sha256_update(&ctx->sha256ctx, ctx->k_opad, SHA256_HMAC_B);
pg_sha256_update(&ctx->sha256ctx, h, SCRAM_KEY_LEN);
pg_sha256_final(&ctx->sha256ctx, result);
}
/*
* Calculate SaltedPassword.
*
* The password should already be normalized by SASLprep.
*/
void
scram_SaltedPassword(const char *password,
const char *salt, int saltlen, int iterations,
uint8 *result)
{
int password_len = strlen(password);
uint32 one = pg_hton32(1);
int i,
j;
uint8 Ui[SCRAM_KEY_LEN];
uint8 Ui_prev[SCRAM_KEY_LEN];
scram_HMAC_ctx hmac_ctx;
/*
* Iterate hash calculation of HMAC entry using given salt. This is
* essentially PBKDF2 (see RFC2898) with HMAC() as the pseudorandom
* function.
*/
/* First iteration */
scram_HMAC_init(&hmac_ctx, (uint8 *) password, password_len);
scram_HMAC_update(&hmac_ctx, salt, saltlen);
scram_HMAC_update(&hmac_ctx, (char *) &one, sizeof(uint32));
scram_HMAC_final(Ui_prev, &hmac_ctx);
memcpy(result, Ui_prev, SCRAM_KEY_LEN);
/* Subsequent iterations */
for (i = 2; i <= iterations; i++)
{
scram_HMAC_init(&hmac_ctx, (uint8 *) password, password_len);
scram_HMAC_update(&hmac_ctx, (const char *) Ui_prev, SCRAM_KEY_LEN);
scram_HMAC_final(Ui, &hmac_ctx);
for (j = 0; j < SCRAM_KEY_LEN; j++)
result[j] ^= Ui[j];
memcpy(Ui_prev, Ui, SCRAM_KEY_LEN);
}
}
/*
* Calculate SHA-256 hash for a NULL-terminated string. (The NULL terminator is
* not included in the hash).
*/
void
scram_H(const uint8 *input, int len, uint8 *result)
{
pg_sha256_ctx ctx;
pg_sha256_init(&ctx);
pg_sha256_update(&ctx, input, len);
pg_sha256_final(&ctx, result);
}
/*
* Calculate ClientKey.
*/
void
scram_ClientKey(const uint8 *salted_password, uint8 *result)
{
scram_HMAC_ctx ctx;
scram_HMAC_init(&ctx, salted_password, SCRAM_KEY_LEN);
scram_HMAC_update(&ctx, "Client Key", strlen("Client Key"));
scram_HMAC_final(result, &ctx);
}
/*
* Calculate ServerKey.
*/
void
scram_ServerKey(const uint8 *salted_password, uint8 *result)
{
scram_HMAC_ctx ctx;
scram_HMAC_init(&ctx, salted_password, SCRAM_KEY_LEN);
scram_HMAC_update(&ctx, "Server Key", strlen("Server Key"));
scram_HMAC_final(result, &ctx);
}
/*
* Construct a SCRAM secret, for storing in pg_authid.rolpassword.
*
* The password should already have been processed with SASLprep, if necessary!
*
* If iterations is 0, default number of iterations is used. The result is
* palloc'd or malloc'd, so caller is responsible for freeing it.
*/
char *
scram_build_secret(const char *salt, int saltlen, int iterations,
const char *password)
{
uint8 salted_password[SCRAM_KEY_LEN];
uint8 stored_key[SCRAM_KEY_LEN];
uint8 server_key[SCRAM_KEY_LEN];
char *result;
char *p;
int maxlen;
int encoded_salt_len;
int encoded_stored_len;
int encoded_server_len;
int encoded_result;
if (iterations <= 0)
iterations = SCRAM_DEFAULT_ITERATIONS;
/* Calculate StoredKey and ServerKey */
scram_SaltedPassword(password, salt, saltlen, iterations,
salted_password);
scram_ClientKey(salted_password, stored_key);
scram_H(stored_key, SCRAM_KEY_LEN, stored_key);
scram_ServerKey(salted_password, server_key);
/*----------
* The format is:
* SCRAM-SHA-256$:$:
*----------
*/
encoded_salt_len = pg_b64_enc_len(saltlen);
encoded_stored_len = pg_b64_enc_len(SCRAM_KEY_LEN);
encoded_server_len = pg_b64_enc_len(SCRAM_KEY_LEN);
maxlen = strlen("SCRAM-SHA-256") + 1
+ 10 + 1 /* iteration count */
+ encoded_salt_len + 1 /* Base64-encoded salt */
+ encoded_stored_len + 1 /* Base64-encoded StoredKey */
+ encoded_server_len + 1; /* Base64-encoded ServerKey */
#ifdef FRONTEND
result = malloc(maxlen);
if (!result)
return NULL;
#else
result = palloc(maxlen);
#endif
p = result + sprintf(result, "SCRAM-SHA-256$%d:", iterations);
/* salt */
encoded_result = pg_b64_encode(salt, saltlen, p, encoded_salt_len);
if (encoded_result < 0)
{
#ifdef FRONTEND
free(result);
return NULL;
#else
elog(ERROR, "could not encode salt");
#endif
}
p += encoded_result;
*(p++) = '$';
/* stored key */
encoded_result = pg_b64_encode((char *) stored_key, SCRAM_KEY_LEN, p,
encoded_stored_len);
if (encoded_result < 0)
{
#ifdef FRONTEND
free(result);
return NULL;
#else
elog(ERROR, "could not encode stored key");
#endif
}
p += encoded_result;
*(p++) = ':';
/* server key */
encoded_result = pg_b64_encode((char *) server_key, SCRAM_KEY_LEN, p,
encoded_server_len);
if (encoded_result < 0)
{
#ifdef FRONTEND
free(result);
return NULL;
#else
elog(ERROR, "could not encode server key");
#endif
}
p += encoded_result;
*(p++) = '\0';
Assert(p - result <= maxlen);
return result;
}
pgbouncer-1.24.1/src/common/pgstrcasecmp.c 0000644 0001750 0000000 00000003443 14777762222 015431 0000000 0000000 /*-------------------------------------------------------------------------
*
* pgstrcasecmp.c
* Portable SQL-like case-independent comparisons and conversions.
*
* SQL99 specifies Unicode-aware case normalization, which we don't yet
* have the infrastructure for. Instead we use tolower() to provide a
* locale-aware translation. However, there are some locales where this
* is not right either (eg, Turkish may do strange things with 'i' and
* 'I'). Our current compromise is to use tolower() for characters with
* the high bit set, and use an ASCII-only downcasing for 7-bit
* characters.
*
* NB: this code should match downcase_truncate_identifier() in scansup.c.
*
* We also provide strict ASCII-only case conversion functions, which can
* be used to implement C/POSIX case folding semantics no matter what the
* C library thinks the locale is.
*
*
* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
*
* src/port/pgstrcasecmp.c
*
*-------------------------------------------------------------------------
*/
#include "common/postgres_compat.h"
#include "common/builtins.h"
/*
* Case-independent comparison of two not-necessarily-null-terminated strings.
* At most n bytes will be examined from each string.
*/
int
pg_strncasecmp(const char *s1, const char *s2, size_t n)
{
while (n-- > 0)
{
unsigned char ch1 = (unsigned char) *s1++;
unsigned char ch2 = (unsigned char) *s2++;
if (ch1 != ch2)
{
if (ch1 >= 'A' && ch1 <= 'Z')
ch1 += 'a' - 'A';
else if (IS_HIGHBIT_SET(ch1) && isupper(ch1))
ch1 = tolower(ch1);
if (ch2 >= 'A' && ch2 <= 'Z')
ch2 += 'a' - 'A';
else if (IS_HIGHBIT_SET(ch2) && isupper(ch2))
ch2 = tolower(ch2);
if (ch1 != ch2)
return (int) ch1 - (int) ch2;
}
if (ch1 == 0)
break;
}
return 0;
}
pgbouncer-1.24.1/src/common/base64.c 0000644 0001750 0000000 00000011500 14777762222 014013 0000000 0000000 /*-------------------------------------------------------------------------
*
* base64.c
* Encoding and decoding routines for base64 without whitespace.
*
* Copyright (c) 2001-2020, PostgreSQL Global Development Group
*
*
* IDENTIFICATION
* src/common/base64.c
*
*-------------------------------------------------------------------------
*/
//#ifndef FRONTEND
//#include "postgres.h"
//#else
//#include "postgres_fe.h"
//#endif
#include "system.h"
#include "common/postgres_compat.h"
#include "common/base64.h"
/*
* BASE64
*/
static const char _base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static const int8 b64lookup[128] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
};
/*
* pg_b64_encode
*
* Encode into base64 the given string. Returns the length of the encoded
* string, and -1 in the event of an error with the result buffer zeroed
* for safety.
*/
int
pg_b64_encode(const char *src, int len, char *dst, int dstlen)
{
char *p;
const char *s,
*end = src + len;
int pos = 2;
uint32 buf = 0;
s = src;
p = dst;
while (s < end)
{
buf |= (unsigned char) *s << (pos << 3);
pos--;
s++;
/* write it out */
if (pos < 0)
{
/*
* Leave if there is an overflow in the area allocated for the
* encoded string.
*/
if ((p - dst + 4) > dstlen)
goto error;
*p++ = _base64[(buf >> 18) & 0x3f];
*p++ = _base64[(buf >> 12) & 0x3f];
*p++ = _base64[(buf >> 6) & 0x3f];
*p++ = _base64[buf & 0x3f];
pos = 2;
buf = 0;
}
}
if (pos != 2)
{
/*
* Leave if there is an overflow in the area allocated for the encoded
* string.
*/
if ((p - dst + 4) > dstlen)
goto error;
*p++ = _base64[(buf >> 18) & 0x3f];
*p++ = _base64[(buf >> 12) & 0x3f];
*p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '=';
*p++ = '=';
}
Assert((p - dst) <= dstlen);
return p - dst;
error:
memset(dst, 0, dstlen);
return -1;
}
/*
* pg_b64_decode
*
* Decode the given base64 string. Returns the length of the decoded
* string on success, and -1 in the event of an error with the result
* buffer zeroed for safety.
*/
int
pg_b64_decode(const char *src, int len, char *dst, int dstlen)
{
const char *srcend = src + len,
*s = src;
char *p = dst;
char c;
int b = 0;
uint32 buf = 0;
int pos = 0,
end = 0;
while (s < srcend)
{
c = *s++;
/* Leave if a whitespace is found */
if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
goto error;
if (c == '=')
{
/* end sequence */
if (!end)
{
if (pos == 2)
end = 1;
else if (pos == 3)
end = 2;
else
{
/*
* Unexpected "=" character found while decoding base64
* sequence.
*/
goto error;
}
}
b = 0;
}
else
{
b = -1;
if (c > 0 && c < 127)
b = b64lookup[(unsigned char) c];
if (b < 0)
{
/* invalid symbol found */
goto error;
}
}
/* add it to buffer */
buf = (buf << 6) + b;
pos++;
if (pos == 4)
{
/*
* Leave if there is an overflow in the area allocated for the
* decoded string.
*/
if ((p - dst + 1) > dstlen)
goto error;
*p++ = (buf >> 16) & 255;
if (end == 0 || end > 1)
{
/* overflow check */
if ((p - dst + 1) > dstlen)
goto error;
*p++ = (buf >> 8) & 255;
}
if (end == 0 || end > 2)
{
/* overflow check */
if ((p - dst + 1) > dstlen)
goto error;
*p++ = buf & 255;
}
buf = 0;
pos = 0;
}
}
if (pos != 0)
{
/*
* base64 end sequence is invalid. Input data is missing padding, is
* truncated or is otherwise corrupted.
*/
goto error;
}
Assert((p - dst) <= dstlen);
return p - dst;
error:
memset(dst, 0, dstlen);
return -1;
}
/*
* pg_b64_enc_len
*
* Returns to caller the length of the string if it were encoded with
* base64 based on the length provided by caller. This is useful to
* estimate how large a buffer allocation needs to be done before doing
* the actual encoding.
*/
int
pg_b64_enc_len(int srclen)
{
/* 3 bytes will be converted to 4 */
return (srclen + 2) * 4 / 3;
}
/*
* pg_b64_dec_len
*
* Returns to caller the length of the string if it were to be decoded
* with base64, based on the length given by caller. This is useful to
* estimate how large a buffer allocation needs to be done before doing
* the actual decoding.
*/
int
pg_b64_dec_len(int srclen)
{
return (srclen * 3) >> 2;
}
pgbouncer-1.24.1/src/janitor.c 0000644 0001750 0000000 00000063015 14777762222 013115 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Periodic maintenance.
*/
#include "bouncer.h"
#include
/* do full maintenance 3x per second */
static struct timeval full_maint_period = {0, USEC / 3};
static struct event full_maint_ev;
extern bool any_user_level_server_timeout_set;
extern bool any_user_level_client_timeout_set;
/* close all sockets in server list */
static void close_server_list(struct StatList *sk_list, const char *reason)
{
struct List *item, *tmp;
PgSocket *server;
statlist_for_each_safe(item, sk_list, tmp) {
server = container_of(item, PgSocket, head);
disconnect_server(server, true, "%s", reason);
}
}
static void close_client_list(struct StatList *sk_list, const char *reason)
{
struct List *item, *tmp;
PgSocket *client;
statlist_for_each_safe(item, sk_list, tmp) {
client = container_of(item, PgSocket, head);
disconnect_client(client, true, "%s", reason);
}
}
bool suspend_socket(PgSocket *sk, bool force_suspend)
{
if (sk->suspended)
return true;
if (sbuf_is_empty(&sk->sbuf)) {
if (sbuf_pause(&sk->sbuf))
sk->suspended = true;
}
if (sk->suspended || !force_suspend)
return sk->suspended;
if (is_server_socket(sk))
disconnect_server(sk, true, "suspend_timeout");
else
disconnect_client(sk, true, "suspend_timeout");
return true;
}
/* suspend all sockets in socket list */
static int suspend_socket_list(struct StatList *list, bool force_suspend)
{
struct List *item, *tmp;
PgSocket *sk;
int active = 0;
statlist_for_each_safe(item, list, tmp) {
sk = container_of(item, PgSocket, head);
if (!suspend_socket(sk, force_suspend))
active++;
}
return active;
}
/* resume all suspended sockets in socket list */
static void resume_socket_list(struct StatList *list)
{
struct List *item, *tmp;
PgSocket *sk;
statlist_for_each_safe(item, list, tmp) {
sk = container_of(item, PgSocket, head);
if (sk->suspended) {
sk->suspended = false;
sbuf_continue(&sk->sbuf);
}
}
}
/* resume all suspended sockets in all pools */
static void resume_sockets(void)
{
struct List *item;
PgPool *pool;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db->admin)
continue;
resume_socket_list(&pool->active_client_list);
resume_socket_list(&pool->active_server_list);
resume_socket_list(&pool->idle_server_list);
resume_socket_list(&pool->used_server_list);
}
}
/* resume pools and listen sockets */
void resume_all(void)
{
resume_sockets();
resume_pooler();
}
/*
* send test/reset query to server if needed
*/
static void launch_recheck(PgPool *pool)
{
const char *q = cf_server_check_query;
bool need_check = true;
PgSocket *server;
bool res = true;
/* find clean server */
while (1) {
server = first_socket(&pool->used_server_list);
if (!server)
return;
if (server->ready)
break;
disconnect_server(server, true, "idle server got dirty");
}
/* is the check needed? */
if (q == NULL || q[0] == 0) {
need_check = false;
} else if (cf_server_check_delay > 0) {
usec_t now = get_cached_time();
if (now - server->request_time < cf_server_check_delay)
need_check = false;
}
if (need_check) {
/* send test query, wait for result */
slog_debug(server, "P: checking: %s", q);
change_server_state(server, SV_TESTED);
SEND_generic(res, server, PqMsg_Query, "s", q);
if (!res)
disconnect_server(server, false, "test query failed");
} else {
/* make immediately available */
release_server(server);
}
}
/*
* make servers available
*/
static void per_loop_activate(PgPool *pool)
{
struct List *item, *tmp;
PgSocket *client;
int sv_tested, sv_used;
/* if there is a cancel request waiting, open a new connection */
if (!statlist_empty(&pool->waiting_cancel_req_list)) {
launch_new_connection(pool, /* evict_if_needed= */ true);
return;
}
/* see if any server have been freed */
sv_tested = statlist_count(&pool->tested_server_list);
sv_used = statlist_count(&pool->used_server_list);
statlist_for_each_safe(item, &pool->waiting_client_list, tmp) {
client = container_of(item, PgSocket, head);
if (client->replication) {
/*
* For replication connections we always launch
* a new connection, but we continue with the loop,
* because there might be normal clients waiting too.
*/
launch_new_connection(pool, /* evict_if_needed= */ true);
} else if (!statlist_empty(&pool->idle_server_list)) {
/* db not fully initialized after reboot */
if (client->wait_for_welcome && !pool->welcome_msg_ready) {
launch_new_connection(pool, /* evict_if_needed= */ true);
continue;
}
/* there is a ready server already */
activate_client(client);
} else if (sv_tested > 0) {
/* some connections are in testing process */
--sv_tested;
} else if (sv_used > 0) {
/* ask for more connections to be tested */
launch_recheck(pool);
--sv_used;
} else {
/* not enough connections */
launch_new_connection(pool, /* evict_if_needed= */ true);
break;
}
}
}
/*
* pause active clients
*/
static int per_loop_pause(PgPool *pool)
{
int active = 0;
if (pool->db->admin)
return 0;
close_server_list(&pool->idle_server_list, "pause mode");
close_server_list(&pool->used_server_list, "pause mode");
close_server_list(&pool->new_server_list, "pause mode");
active += statlist_count(&pool->active_server_list);
active += statlist_count(&pool->tested_server_list);
return active;
}
/*
* suspend active clients and servers
*/
static int per_loop_suspend(PgPool *pool, bool force_suspend)
{
int active = 0;
if (pool->db->admin)
return 0;
active += suspend_socket_list(&pool->active_client_list, force_suspend);
/* this list is not suspendable, but still need force_suspend and counting */
active += suspend_socket_list(&pool->waiting_client_list, force_suspend);
if (active)
per_loop_activate(pool);
if (!active) {
active += suspend_socket_list(&pool->active_server_list, force_suspend);
active += suspend_socket_list(&pool->idle_server_list, force_suspend);
/* as all clients are done, no need for them */
close_server_list(&pool->tested_server_list, "close unsafe file descriptors on suspend");
close_server_list(&pool->used_server_list, "close unsafe file descriptors on suspend");
}
return active;
}
/*
* Count the servers in server_list that have close_needed set.
*/
static int count_close_needed(struct StatList *server_list)
{
struct List *item;
PgSocket *server;
int count = 0;
statlist_for_each(item, server_list) {
server = container_of(item, PgSocket, head);
if (server->close_needed)
count++;
}
return count;
}
/*
* Per-loop tasks for WAIT_CLOSE
*/
static int per_loop_wait_close(PgPool *pool)
{
int count = 0;
if (pool->db->admin)
return 0;
count += count_close_needed(&pool->active_server_list);
count += count_close_needed(&pool->idle_server_list);
count += count_close_needed(&pool->new_server_list);
count += count_close_needed(&pool->tested_server_list);
count += count_close_needed(&pool->used_server_list);
return count;
}
/*
* this function is called for each event loop.
*/
void per_loop_maint(void)
{
struct List *item;
PgPool *pool;
int active_count = 0;
int waiting_count = 0;
bool partial_pause = false;
bool partial_wait = false;
bool force_suspend = false;
if (cf_pause_mode == P_SUSPEND && cf_suspend_timeout > 0) {
usec_t stime = get_cached_time() - g_suspend_start;
if (stime >= cf_suspend_timeout)
force_suspend = true;
}
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db->admin)
continue;
switch (cf_pause_mode) {
case P_NONE:
if (pool->db->db_paused) {
partial_pause = true;
active_count += per_loop_pause(pool);
} else {
per_loop_activate(pool);
}
break;
case P_PAUSE:
active_count += per_loop_pause(pool);
break;
case P_SUSPEND:
active_count += per_loop_suspend(pool, force_suspend);
break;
}
if (pool->db->db_wait_close) {
partial_wait = true;
waiting_count += per_loop_wait_close(pool);
}
}
switch (cf_pause_mode) {
case P_SUSPEND:
if (force_suspend) {
close_client_list(&login_client_list, "suspend_timeout");
} else {
active_count += statlist_count(&login_client_list);
}
/* fallthrough */
case P_PAUSE:
if (!active_count)
admin_pause_done();
break;
case P_NONE:
if (partial_pause && !active_count)
admin_pause_done();
break;
}
if (partial_wait && !waiting_count)
admin_wait_close_done();
}
/* maintaining clients in pool */
static void pool_client_maint(PgPool *pool)
{
struct List *item, *tmp;
usec_t now = get_cached_time();
PgSocket *client;
PgGlobalUser *user;
usec_t age;
usec_t effective_client_idle_timeout;
/* force client_idle_timeout */
if (cf_client_idle_timeout > 0 || any_user_level_client_timeout_set) {
statlist_for_each_safe(item, &pool->active_client_list, tmp) {
client = container_of(item, PgSocket, head);
Assert(client->state == CL_ACTIVE);
if (client->link)
continue;
user = client->login_user_credentials->global_user;
effective_client_idle_timeout = cf_client_idle_timeout;
if (user->client_idle_timeout > 0)
effective_client_idle_timeout = user->client_idle_timeout;
if (now - client->request_time > effective_client_idle_timeout)
disconnect_client(client, true, "client_idle_timeout");
}
}
/* force timeouts for waiting queries */
if (cf_query_timeout > 0 || cf_query_wait_timeout > 0) {
statlist_for_each_safe(item, &pool->waiting_client_list, tmp) {
client = container_of(item, PgSocket, head);
Assert(client->state == CL_WAITING || client->state == CL_WAITING_LOGIN);
if (client->query_start == 0) {
age = now - client->request_time;
/* log_warning("query_start==0"); */
} else {
age = now - client->query_start;
}
if (cf_shutdown == SHUTDOWN_WAIT_FOR_SERVERS) {
disconnect_client(client, true, "server shutting down");
} else if (cf_query_timeout > 0 && age > cf_query_timeout) {
disconnect_client(client, true, "query_timeout");
} else if (cf_query_wait_timeout > 0 && age > cf_query_wait_timeout) {
disconnect_client(client, true, "query_wait_timeout");
}
}
}
/* apply cancel_wait_timeout for cancel connections */
if (cf_cancel_wait_timeout > 0) {
statlist_for_each_safe(item, &pool->waiting_cancel_req_list, tmp) {
client = container_of(item, PgSocket, head);
Assert(client->state == CL_WAITING_CANCEL);
age = now - client->request_time;
if (age > cf_cancel_wait_timeout)
disconnect_client(client, false, "cancel_wait_timeout");
}
}
/* apply client_login_timeout to clients waiting for welcome pkt */
if (cf_client_login_timeout > 0 && !pool->welcome_msg_ready) {
statlist_for_each_safe(item, &pool->waiting_client_list, tmp) {
client = container_of(item, PgSocket, head);
if (!client->wait_for_welcome)
continue;
age = now - client->connect_time;
if (age > cf_client_login_timeout)
disconnect_client(client, true, "client_login_timeout (server down)");
}
}
}
/* maintaining clients in peer pool */
static void peer_pool_client_maint(PgPool *pool)
{
struct List *item, *tmp;
usec_t now = get_cached_time();
PgSocket *client;
usec_t age;
if (cf_cancel_wait_timeout > 0) {
statlist_for_each_safe(item, &pool->waiting_cancel_req_list, tmp) {
client = container_of(item, PgSocket, head);
Assert(client->state == CL_WAITING_CANCEL);
age = now - client->request_time;
if (age > cf_cancel_wait_timeout)
disconnect_client(client, false, "cancel_wait_timeout");
}
}
}
static void check_unused_servers(PgPool *pool, struct StatList *slist, bool idle_test)
{
usec_t now = get_cached_time();
usec_t server_lifetime = pool_server_lifetime(pool);
struct List *item, *tmp;
usec_t idle, age;
PgSocket *server;
/* disconnect idle servers if needed */
statlist_for_each_safe(item, slist, tmp) {
server = container_of(item, PgSocket, head);
age = now - server->connect_time;
idle = now - server->request_time;
if (server->close_needed) {
disconnect_server(server, true, "database configuration changed");
} else if (server->state == SV_IDLE && !server->ready) {
disconnect_server(server, true, "SV_IDLE server got dirty");
} else if (server->state == SV_USED && !server->ready) {
disconnect_server(server, true, "SV_USED server got dirty");
} else if (cf_server_idle_timeout > 0 && idle > cf_server_idle_timeout
&& (pool_min_pool_size(pool) == 0 || pool_connected_server_count(pool) > pool_min_pool_size(pool))) {
disconnect_server(server, true, "server idle timeout");
} else if (age >= server_lifetime) {
if (life_over(server)) {
disconnect_server(server, true, "server lifetime over");
pool->last_lifetime_disconnect = now;
}
} else if (cf_pause_mode == P_PAUSE) {
disconnect_server(server, true, "pause mode");
} else if (idle_test && *cf_server_check_query) {
if (idle > cf_server_check_delay)
change_server_state(server, SV_USED);
}
}
}
/*
* Check pool size, close conns if too many. Makes pooler
* react faster to the case when admin decreased pool size.
*/
static void check_pool_size(PgPool *pool)
{
PgSocket *server;
int cur = pool_connected_server_count(pool);
int many = cur - (pool_pool_size(pool) + pool_res_pool_size(pool));
Assert(pool_pool_size(pool) >= 0);
if (pool_pool_size(pool) > 0) {
while (many > 0) {
server = first_socket(&pool->used_server_list);
if (!server)
server = first_socket(&pool->idle_server_list);
if (!server)
break;
disconnect_server(server, true, "too many servers in the pool");
many--;
cur--;
}
}
/* launch extra connections to satisfy min_pool_size */
if (cur < pool_min_pool_size(pool) &&
cur < pool_pool_size(pool) &&
cf_pause_mode == P_NONE &&
cf_reboot == 0 &&
(pool_client_count(pool) > 0 || pool->db->forced_user_credentials != NULL)) {
log_debug("launching new connection to satisfy min_pool_size");
launch_new_connection(pool, /* evict_if_needed= */ false);
}
}
/* maintain servers in a pool */
static void pool_server_maint(PgPool *pool)
{
struct List *item, *tmp;
usec_t now = get_cached_time();
PgSocket *server;
/* find and disconnect idle servers */
check_unused_servers(pool, &pool->used_server_list, 0);
check_unused_servers(pool, &pool->tested_server_list, 0);
check_unused_servers(pool, &pool->idle_server_list, 1);
statlist_for_each_safe(item, &pool->active_server_list, tmp) {
server = container_of(item, PgSocket, head);
Assert(server->state == SV_ACTIVE);
/*
* Disconnect active servers without outstanding requests if
* server_fast_close is set. This only applies to session
* pooling.
*/
if (cf_server_fast_close && server->ready && server->close_needed)
disconnect_server(server, true, "database configuration changed");
/*
* Always disconnect close_needed replication servers. These
* connections are expected to be very long lived (possibly
* indefinitely), so waiting until the session/transaction is
* over is not an option.
*/
if (server->replication && server->close_needed)
disconnect_server(server, true, "database configuration changed");
}
/* handle query_timeout and idle_transaction_timeout */
if (cf_query_timeout > 0 || cf_idle_transaction_timeout > 0 || any_user_level_timeout_set) {
statlist_for_each_safe(item, &pool->active_server_list, tmp) {
usec_t age_client, age_server;
usec_t effective_query_timeout;
usec_t effective_idle_transaction_timeout;
usec_t user_query_timeout;
usec_t user_idle_transaction_timeout;
server = container_of(item, PgSocket, head);
Assert(server->state == SV_ACTIVE);
if (server->ready)
continue;
/*
* Note the different age calculations:
* query_timeout counts from the last request
* of the client (the client started the
* query), idle_transaction_timeout counts
* from the last request of the server (the
* server sent the idle information).
*/
age_client = now - server->link->request_time;
age_server = now - server->request_time;
user_idle_transaction_timeout = server->login_user_credentials->global_user->idle_transaction_timeout;
user_query_timeout = server->login_user_credentials->global_user->query_timeout;
effective_idle_transaction_timeout = cf_idle_transaction_timeout;
effective_query_timeout = cf_query_timeout;
if (user_idle_transaction_timeout > 0)
effective_idle_transaction_timeout = user_idle_transaction_timeout;
if (user_query_timeout > 0)
effective_query_timeout = user_query_timeout;
if (effective_query_timeout > 0 && age_client > effective_query_timeout) {
disconnect_server(server, true, "query timeout");
} else if (effective_idle_transaction_timeout > 0 &&
server->idle_tx &&
age_server > effective_idle_transaction_timeout) {
disconnect_server(server, true, "idle transaction timeout");
}
}
}
/* find connections that got connect, but could not log in */
if (cf_server_connect_timeout > 0) {
statlist_for_each_safe(item, &pool->new_server_list, tmp) {
usec_t age;
server = container_of(item, PgSocket, head);
Assert(server->state == SV_LOGIN);
age = now - server->connect_time;
if (age > cf_server_connect_timeout)
disconnect_server(server, true, "connect timeout");
}
}
check_pool_size(pool);
}
/* maintain servers in a peer pool */
static void peer_pool_server_maint(PgPool *pool)
{
struct List *item, *tmp;
usec_t now = get_cached_time();
PgSocket *server;
/*
* find connections that got connected, but could not log in. For normal
* pools we only compare against server_connect_timeout for these servers,
* but since peer pools are only for sending cancellations we also compare
* against cancel_wait_timeout here.
*/
if (cf_server_connect_timeout > 0 || cf_cancel_wait_timeout > 0) {
statlist_for_each_safe(item, &pool->new_server_list, tmp) {
usec_t age;
server = container_of(item, PgSocket, head);
Assert(server->state == SV_LOGIN);
age = now - server->connect_time;
if (cf_server_connect_timeout > 0 && age > cf_server_connect_timeout) {
disconnect_server(server, true, "connect timeout");
} else if (cf_cancel_wait_timeout > 0 && age > cf_cancel_wait_timeout) {
disconnect_server(server, true, "cancel_wait_timeout");
}
}
}
}
static void cleanup_client_logins(void)
{
struct List *item, *tmp;
PgSocket *client;
usec_t age;
usec_t now = get_cached_time();
if (cf_client_login_timeout <= 0)
return;
statlist_for_each_safe(item, &login_client_list, tmp) {
client = container_of(item, PgSocket, head);
age = now - client->connect_time;
if (age > cf_client_login_timeout)
disconnect_client(client, true, "client_login_timeout");
}
}
static void cleanup_inactive_autodatabases(void)
{
struct List *item, *tmp;
PgDatabase *db;
usec_t age;
usec_t now = get_cached_time();
if (cf_autodb_idle_timeout <= 0)
return;
/* now kill the old ones */
statlist_for_each_safe(item, &autodatabase_idle_list, tmp) {
db = container_of(item, PgDatabase, head);
if (db->db_paused)
continue;
age = now - db->inactive_time;
if (age > cf_autodb_idle_timeout) {
kill_database(db);
} else {
break;
}
}
}
/* full-scale maintenance, done only occasionally */
static void do_full_maint(evutil_socket_t sock, short flags, void *arg)
{
struct List *item, *tmp;
PgPool *pool;
PgDatabase *db;
static unsigned int seq;
seq++;
/*
* Avoid doing anything that may surprise other pgbouncer.
*/
if (cf_pause_mode == P_SUSPEND)
return;
/*
* Creating new pools to enable `min_pool_size` enforcement even if
* there are no active clients.
*
* If clients never connect there won't be a pool to maintain the
* min_pool_size on, which means we have to proactively create a pool,
* so that it can be maintained.
*
* We are doing this for databases with forced users only, to reduce
* the risk of creating connections in unexpected ways, where there are
* many users.
_ */
statlist_for_each_safe(item, &database_list, tmp) {
db = container_of(item, PgDatabase, head);
if (database_min_pool_size(db) > 0 && db->forced_user_credentials != NULL) {
get_pool(db, db->forced_user_credentials);
}
}
statlist_for_each_safe(item, &pool_list, tmp) {
pool = container_of(item, PgPool, head);
if (pool->db->admin)
continue;
pool_server_maint(pool);
pool_client_maint(pool);
/* is autodb active? */
if (pool->db->db_auto && pool->db->inactive_time == 0) {
if (pool_client_count(pool) > 0 || pool_server_count(pool) > 0)
pool->db->active_stamp = seq;
}
}
statlist_for_each_safe(item, &peer_pool_list, tmp) {
pool = container_of(item, PgPool, head);
peer_pool_server_maint(pool);
peer_pool_client_maint(pool);
}
/* find inactive autodbs */
statlist_for_each_safe(item, &database_list, tmp) {
db = container_of(item, PgDatabase, head);
if (db->db_auto && db->inactive_time == 0) {
if (db->active_stamp == seq)
continue;
db->inactive_time = get_cached_time();
statlist_remove(&database_list, &db->head);
statlist_append(&autodatabase_idle_list, &db->head);
}
}
cleanup_inactive_autodatabases();
cleanup_client_logins();
if (cf_shutdown == SHUTDOWN_WAIT_FOR_SERVERS && get_active_server_count() == 0) {
log_info("server connections dropped, exiting");
cf_shutdown = SHUTDOWN_IMMEDIATE;
event_base_loopbreak(pgb_event_base);
return;
}
if (cf_shutdown == SHUTDOWN_WAIT_FOR_CLIENTS && get_active_client_count() == 0) {
log_info("client connections dropped, exiting");
cf_shutdown = SHUTDOWN_IMMEDIATE;
event_base_loopbreak(pgb_event_base);
return;
}
adns_zone_cache_maint(adns);
}
/* first-time initialization */
void janitor_setup(void)
{
/* launch maintenance */
event_assign(&full_maint_ev, pgb_event_base, -1, EV_PERSIST, do_full_maint, NULL);
if (event_add(&full_maint_ev, &full_maint_period) < 0)
log_warning("event_add failed: %s", strerror(errno));
}
void kill_pool(PgPool *pool)
{
const char *reason = "database removed";
close_client_list(&pool->active_client_list, reason);
close_client_list(&pool->waiting_client_list, reason);
close_client_list(&pool->active_cancel_req_list, reason);
close_client_list(&pool->waiting_cancel_req_list, reason);
close_server_list(&pool->active_server_list, reason);
close_server_list(&pool->active_cancel_server_list, reason);
close_server_list(&pool->being_canceled_server_list, reason);
close_server_list(&pool->idle_server_list, reason);
close_server_list(&pool->used_server_list, reason);
close_server_list(&pool->tested_server_list, reason);
close_server_list(&pool->new_server_list, reason);
pktbuf_free(pool->welcome_msg);
list_del(&pool->map_head);
statlist_remove(&pool_list, &pool->head);
varcache_clean(&pool->orig_vars);
slab_free(var_list_cache, pool->orig_vars.var_list);
slab_free(pool_cache, pool);
}
void kill_peer_pool(PgPool *pool)
{
const char *reason = "peer removed";
close_client_list(&pool->active_cancel_req_list, reason);
close_client_list(&pool->waiting_cancel_req_list, reason);
close_server_list(&pool->active_cancel_server_list, reason);
close_server_list(&pool->new_server_list, reason);
pktbuf_free(pool->welcome_msg);
list_del(&pool->map_head);
statlist_remove(&peer_pool_list, &pool->head);
varcache_clean(&pool->orig_vars);
slab_free(var_list_cache, pool->orig_vars.var_list);
slab_free(peer_pool_cache, pool);
}
void kill_database(PgDatabase *db)
{
PgPool *pool;
struct List *item, *tmp;
log_warning("dropping database '%s' as it does not exist anymore or inactive auto-database", db->name);
statlist_for_each_safe(item, &pool_list, tmp) {
pool = container_of(item, PgPool, head);
if (pool->db == db)
kill_pool(pool);
}
pktbuf_free(db->startup_params);
free(db->host);
if (db->forced_user_credentials)
slab_free(credentials_cache, db->forced_user_credentials);
free(db->connect_query);
if (db->inactive_time) {
statlist_remove(&autodatabase_idle_list, &db->head);
} else {
statlist_remove(&database_list, &db->head);
}
if (db->auth_dbname)
free((void *)db->auth_dbname);
if (db->auth_query)
free((void *)db->auth_query);
aatree_destroy(&db->user_tree);
slab_free(db_cache, db);
}
void kill_peer(PgDatabase *db)
{
PgPool *pool;
struct List *item, *tmp;
log_warning("dropping peer %s as it does not exist anymore", db->name);
statlist_for_each_safe(item, &peer_pool_list, tmp) {
pool = container_of(item, PgPool, head);
if (pool->db == db)
kill_peer_pool(pool);
}
free(db->host);
statlist_remove(&peer_list, &db->head);
slab_free(peer_cache, db);
}
/* as [pgbouncer] section can be loaded after databases,
there's need for review */
void config_postprocess(void)
{
struct List *item, *tmp;
PgDatabase *db;
statlist_for_each_safe(item, &database_list, tmp) {
db = container_of(item, PgDatabase, head);
if (db->db_dead) {
kill_database(db);
continue;
}
}
statlist_for_each_safe(item, &peer_list, tmp) {
db = container_of(item, PgDatabase, head);
if (db->db_dead) {
kill_peer(db);
continue;
}
}
}
pgbouncer-1.24.1/src/client.c 0000644 0001750 0000000 00000146754 14777762222 012741 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Client connection handling
*/
#include "bouncer.h"
#include "pam.h"
#include "scram.h"
#include "common/builtins.h"
#include
#include
static const char *hdr2hex(const struct MBuf *data, char *buf, unsigned buflen)
{
const uint8_t *bin = data->data + data->read_pos;
unsigned int dlen;
dlen = mbuf_avail_for_read(data);
return bin2hex(bin, dlen, buf, buflen);
}
/*
* Get authentication database for the current client. The order of preference is:
* client->db->auth_dbname: per client authentication database
* cf_auth_dbname: global authentication database
* client->db: client database
*
* NOTE: if the authentication database is not found or it is disabled, client
* will be disconnected.
*/
PgDatabase *prepare_auth_database(PgSocket *client)
{
PgDatabase *auth_db = NULL;
const char *auth_dbname = client->db->auth_dbname ? client->db->auth_dbname : cf_auth_dbname;
if (!auth_dbname) {
auth_db = client->db;
} else {
auth_db = find_or_register_database(client, auth_dbname);
}
if (!auth_db) {
slog_error(client, "authentication database \"%s\" is not configured.", auth_dbname);
disconnect_client(client, true, "bouncer config error");
return NULL;
}
if (auth_db->db_disabled) {
disconnect_client(
client,
true,
"authentication database \"%s\" is disabled",
auth_dbname);
return NULL;
}
if (auth_db->admin) {
slog_error(client, "cannot use the reserved \"%s\" database as an auth_dbname", auth_db->dbname);
disconnect_client(client, true, "bouncer config error");
return NULL;
}
return auth_db;
}
static bool check_client_passwd(PgSocket *client, const char *passwd)
{
PgCredentials *user = client->login_user_credentials;
int auth_type = client->client_auth_type;
if (user->mock_auth)
return false;
/* disallow empty passwords */
if (!*user->passwd)
return false;
switch (auth_type) {
case AUTH_TYPE_PLAIN:
switch (get_password_type(user->passwd)) {
case PASSWORD_TYPE_PLAINTEXT:
return strcmp(user->passwd, passwd) == 0;
case PASSWORD_TYPE_MD5: {
char md5[MD5_PASSWD_LEN + 1];
if (!pg_md5_encrypt(passwd, user->name, strlen(user->name), md5))
return false;
return strcmp(user->passwd, md5) == 0;
}
case PASSWORD_TYPE_SCRAM_SHA_256:
return scram_verify_plain_password(client, user->name, passwd, user->passwd);
default:
return false;
}
case AUTH_TYPE_MD5: {
char *stored_passwd;
char md5[MD5_PASSWD_LEN + 1];
if (strlen(passwd) != MD5_PASSWD_LEN)
return false;
/*
* The client sends
* 'md5'+md5(md5(password+username)+salt). The stored
* password is either 'md5'+md5(password+username) or
* plain text. If the latter, we compute the inner
* md5() call first.
*/
if (get_password_type(user->passwd) == PASSWORD_TYPE_PLAINTEXT) {
if (!pg_md5_encrypt(user->passwd, user->name, strlen(user->name), md5))
return false;
stored_passwd = md5;
} else {
stored_passwd = user->passwd;
}
if (!pg_md5_encrypt(stored_passwd + 3, (char *)client->tmp_login_salt, 4, md5))
return false;
return strcmp(md5, passwd) == 0;
}
}
return false;
}
static bool send_client_authreq(PgSocket *client)
{
int res;
int auth_type = client->client_auth_type;
if (auth_type == AUTH_TYPE_MD5) {
uint8_t saltlen = 4;
get_random_bytes((void *)client->tmp_login_salt, saltlen);
SEND_generic(res, client, PqMsg_AuthenticationRequest, "ib", AUTH_REQ_MD5, client->tmp_login_salt, saltlen);
} else if (auth_type == AUTH_TYPE_PLAIN || auth_type == AUTH_TYPE_PAM) {
SEND_generic(res, client, PqMsg_AuthenticationRequest, "i", AUTH_REQ_PASSWORD);
} else if (auth_type == AUTH_TYPE_SCRAM_SHA_256) {
SEND_generic(res, client, PqMsg_AuthenticationRequest, "iss", AUTH_REQ_SASL, "SCRAM-SHA-256", "");
} else {
return false;
}
if (!res) {
slog_noise(client, "No authentication response received");
disconnect_client(client, false, "failed to send auth req");
} else {
slog_noise(client, "Auth request sent successfully");
}
return res;
}
/*
* Returns true if the client is currently trying to send an auth query to the
* server.
*/
bool sending_auth_query(PgSocket *client)
{
return client->wait_for_user_conn || client->wait_for_user;
}
static void start_auth_query(PgSocket *client, const char *username)
{
int res;
PktBuf *buf;
const char *auth_query = client->db->auth_query ? client->db->auth_query : cf_auth_query;
/* have to fetch user info from db */
PgDatabase *auth_db = prepare_auth_database(client);
if (!auth_db)
return;
client->pool = get_pool(auth_db, client->db->auth_user_credentials);
if (!client->pool) {
disconnect_client(client, true, "no memory for authentication pool");
return;
}
client->wait_for_user_conn = true;
if (!find_server(client)) {
return;
}
slog_noise(client, "doing auth_conn query: %s", auth_query);
client->wait_for_user_conn = false;
client->wait_for_user = true;
if (!sbuf_pause(&client->sbuf)) {
release_server(client->link);
disconnect_client(client, true, "pause failed");
return;
}
client->link->ready = false;
/*
* Add outstanding request, so that the server is closed if the client
* disconnects before the auth_query completes.
*/
if (!add_outstanding_request(client, PqMsg_Sync, RA_SKIP)) {
disconnect_server(client->link, true, "out of memory");
return;
}
res = 0;
buf = pktbuf_dynamic(512);
if (buf) {
pktbuf_write_ExtQuery(buf, auth_query, 1, username);
res = pktbuf_send_immediate(buf, client->link);
pktbuf_free(buf);
/*
* Should do instead:
* res = pktbuf_send_queued(buf, client->link);
* but that needs better integration with SBuf.
*/
}
if (!res)
disconnect_server(client->link, false, "unable to send auth_query");
}
static bool login_via_cert(PgSocket *client, struct HBARule *rule)
{
struct tls *tls = client->sbuf.tls;
if (!tls) {
slog_error(client, "TLS connection required");
goto fail;
}
if (!tls_peer_cert_provided(client->sbuf.tls)) {
slog_error(client, "TLS client certificate required");
goto fail;
}
if (client->login_user_credentials->mock_auth)
goto fail;
log_debug("TLS cert login: %s", tls_peer_cert_subject(client->sbuf.tls));
if (rule && rule->identmap) {
struct List *el;
struct Mapping *mapping;
bool mapped = false;
list_for_each(el, &rule->identmap->mappings) {
mapping = container_of(el, struct Mapping, node);
if (!tls_peer_cert_contains_name(client->sbuf.tls, mapping->system_user_name)) {
continue;
}
if (!(mapping->name_flags & NAME_ALL)) {
if (strcmp(client->login_user_credentials->name, mapping->postgres_user_name)) {
continue;
}
}
slog_noise(client, "ident map: %s %s %s", rule->identmap->map_name, mapping->system_user_name, mapping->postgres_user_name);
mapped = true;
break;
}
if (!mapped) {
slog_error(client, "ident map: %s does not have a match", rule->identmap->map_name);
goto fail;
}
} else if (!tls_peer_cert_contains_name(client->sbuf.tls, client->login_user_credentials->name)) {
slog_error(client, "TLS certificate name mismatch");
goto fail;
}
/* login successful */
return finish_client_login(client);
fail:
disconnect_client(client, true, "certificate authentication failed");
return false;
}
static bool login_as_unix_peer(PgSocket *client, struct HBARule *rule)
{
if (!pga_is_unix(&client->remote_addr))
goto fail;
if (client->login_user_credentials->mock_auth)
goto fail;
if (rule && rule->identmap) {
struct List *el;
struct Mapping *mapping;
bool mapped = false;
list_for_each(el, &rule->identmap->mappings) {
mapping = container_of(el, struct Mapping, node);
if (check_unix_peer_name(sbuf_socket(&client->sbuf), mapping->system_user_name)) {
if ((mapping->name_flags & NAME_ALL) ||
strcmp(mapping->postgres_user_name, client->login_user_credentials->name) == 0) {
slog_noise(client, "ident map '%s' is applied", rule->identmap->map_name);
mapped = true;
break;
}
}
}
if (!mapped) {
slog_error(client, "ident map %s cannot be matched",
rule->identmap->map_name);
goto fail;
}
} else {
if (!check_unix_peer_name(sbuf_socket(&client->sbuf), client->login_user_credentials->name))
goto fail;
}
return finish_client_login(client);
fail:
disconnect_client(client, true, "unix socket login rejected");
return false;
}
static bool finish_set_pool(PgSocket *client, bool takeover)
{
bool ok = false;
int auth;
struct HBARule *rule = NULL;
if (!client->login_user_credentials->mock_auth && !client->db->fake) {
PgCredentials *pool_user_credentials;
if (client->db->forced_user_credentials)
pool_user_credentials = client->db->forced_user_credentials;
else
pool_user_credentials = client->login_user_credentials;
client->pool = get_pool(client->db, pool_user_credentials);
if (!client->pool) {
disconnect_client(client, true, "no memory for pool");
return false;
}
}
if (cf_log_connections) {
if (client->sbuf.tls) {
char infobuf[96] = "";
tls_get_connection_info(client->sbuf.tls, infobuf, sizeof infobuf);
slog_info(client, "login attempt: db=%s user=%s tls=%s replication=%s",
client->db->name,
client->login_user_credentials->name,
infobuf,
replication_type_parameters[client->replication]);
} else {
slog_info(client, "login attempt: db=%s user=%s tls=no replication=%s",
client->db->name, client->login_user_credentials->name,
replication_type_parameters[client->replication]);
}
}
if (takeover)
return true;
if (client->pool && client->pool->db->admin) {
if (!admin_post_login(client))
return false;
}
if (client->own_user)
return finish_client_login(client);
auth = cf_auth_type;
if (auth == AUTH_TYPE_HBA) {
rule = hba_eval(
parsed_hba,
&client->remote_addr,
!!client->sbuf.tls,
client->replication,
client->db->name,
client->login_user_credentials->name);
if (!rule) {
disconnect_client(client, true, "no authentication method is found");
return false;
}
slog_noise(client, "HBA Line %d is matched", rule->hba_linenr);
auth = rule->rule_method;
}
if (auth == AUTH_TYPE_MD5) {
if (get_password_type(client->login_user_credentials->passwd) == PASSWORD_TYPE_SCRAM_SHA_256)
auth = AUTH_TYPE_SCRAM_SHA_256;
}
/* remember method */
client->client_auth_type = auth;
switch (auth) {
case AUTH_TYPE_ANY:
ok = finish_client_login(client);
break;
case AUTH_TYPE_TRUST:
if (client->login_user_credentials->mock_auth)
disconnect_client(client, true, "\"trust\" authentication failed");
else
ok = finish_client_login(client);
break;
case AUTH_TYPE_PLAIN:
case AUTH_TYPE_MD5:
case AUTH_TYPE_PAM:
case AUTH_TYPE_SCRAM_SHA_256:
ok = send_client_authreq(client);
break;
case AUTH_TYPE_CERT:
ok = login_via_cert(client, rule);
break;
case AUTH_TYPE_PEER:
ok = login_as_unix_peer(client, rule);
break;
default:
disconnect_client(client, true, "login rejected");
ok = false;
}
return ok;
}
bool check_db_connection_count(PgSocket *client)
{
if (!client->contributes_db_client_count) {
client->contributes_db_client_count = true;
client->db->client_connection_count++;
}
if (database_max_client_connections(client->db) <= 0)
return true;
if (client->db->client_connection_count <= database_max_client_connections(client->db))
return true;
if (client->db->admin && strlist_contains(cf_admin_users, client->login_user_credentials->name))
return true;
log_debug("set_pool: db '%s' full (%d >= %d)",
client->db->name, client->db->client_connection_count, client->db->max_db_client_connections);
disconnect_client(client, true, "client connections exceeded (max_db_client_connections)");
return false;
}
bool check_user_connection_count(PgSocket *client)
{
int client_connection_count;
int max_user_client_connections;
/* Check client_connection count limit */
if (!client->login_user_credentials)
return true;
if (!client->login_user_credentials->global_user)
return true;
if (!client->user_connection_counted) {
client->login_user_credentials->global_user->client_connection_count++;
client->user_connection_counted = 1;
}
if (client->db->admin && strlist_contains(cf_admin_users, client->login_user_credentials->name)) {
return true;
}
max_user_client_connections = user_client_max_connections(client->login_user_credentials->global_user);
if (max_user_client_connections == 0)
return true;
client_connection_count = client->login_user_credentials->global_user->client_connection_count;
if (client_connection_count <= max_user_client_connections)
return true;
log_debug("set_pool: user '%s' full (%d >= %d)",
client->login_user_credentials->name, client_connection_count, max_user_client_connections);
disconnect_client(client, true, "client connections exceeded (max_user_client_connections)");
return false;
}
bool set_pool(PgSocket *client, const char *dbname, const char *username, const char *password, bool takeover)
{
Assert((password && takeover) || (!password && !takeover));
/* find database */
client->db = find_or_register_database(client, dbname);
if (!client->db) {
client->db = calloc(1, sizeof(*client->db));
client->db->fake = true;
strlcpy(client->db->name, dbname, sizeof(client->db->name));
}
if (client->db->admin) {
if (admin_pre_login(client, username))
return finish_set_pool(client, takeover);
}
/* avoid dealing with invalid data below, and give an
* appropriate error message */
if (strlen(username) >= MAX_USERNAME) {
disconnect_client(client, true, "username too long");
if (cf_log_connections)
slog_info(client, "login failed: db=%s user=%s", dbname, username);
return false;
}
if (password && strlen(password) >= MAX_PASSWORD) {
disconnect_client(client, true, "password too long");
if (cf_log_connections)
slog_info(client, "login failed: db=%s user=%s", dbname, username);
return false;
}
/* find user */
if (cf_auth_type == AUTH_TYPE_ANY) {
/* ignore requested user */
if (client->db->forced_user_credentials == NULL) {
slog_error(client, "auth_type=any requires forced user");
disconnect_client(client, true, "bouncer config error");
return false;
}
client->login_user_credentials = client->db->forced_user_credentials;
if (!check_db_connection_count(client))
return false;
if (!check_user_connection_count(client))
return false;
} else if (cf_auth_type == AUTH_TYPE_PAM) {
if (client->db->auth_user_credentials) {
slog_error(client, "PAM can't be used together with database authentication");
disconnect_client(client, true, "bouncer config error");
return false;
}
/* Password will be set after successful authentication when not in takeover mode */
client->login_user_credentials = add_pam_credentials(username, password);
if (!check_db_connection_count(client))
return false;
if (!client->login_user_credentials) {
slog_error(client, "set_pool(): failed to allocate new PAM user");
disconnect_client(client, true, "bouncer resources exhaustion");
return false;
}
if (!check_user_connection_count(client)) {
return false;
}
} else {
client->login_user_credentials = find_global_credentials(username);
if (!check_db_connection_count(client))
return false;
if (!check_user_connection_count(client))
return false;
if (!client->login_user_credentials || client->login_user_credentials->dynamic_passwd) {
PgGlobalUser *global_user;
/*
* If the login user specified by the client
* does not exist or if it has no entry in auth_file,
* check if an auth_user is set and if so, send off
* an auth_query. If no auth_user is set for the db,
* see if the global auth_user is set and use that.
*/
if (!client->db->auth_user_credentials && cf_auth_user) {
client->db->auth_user_credentials = find_or_add_new_global_credentials(cf_auth_user, "");
if (client->db->auth_user_credentials == NULL) {
slog_error(client, "set_pool(): failed to allocate a new global credentials");
disconnect_client(client, true, "bouncer resources exhaustion");
return false;
}
}
if (client->db->auth_user_credentials) {
if (client->db->fake) {
slog_debug(client, "not running auth_query because database is fake");
} else {
if (takeover) {
client->login_user_credentials = add_dynamic_credentials(client->db, username, password);
if (!check_db_connection_count(client))
return false;
if (!check_user_connection_count(client))
return false;
return finish_set_pool(client, takeover);
}
start_auth_query(client, username);
return false;
}
}
slog_info(client, "no such user: %s", username);
client->login_user_credentials = calloc(1, sizeof(*client->login_user_credentials));
/*
* For users that we are already tracking, we want to
* track this correctly as a connection count. But for
* users that we don't know about at all, we don't want
* to create a new global user. That's why we use
* find_global_user instead of
* find_or_add_new_global_user.
*/
global_user = find_global_user(username);
if (global_user)
client->login_user_credentials->global_user = global_user;
if (!check_db_connection_count(client))
return false;
client->login_user_credentials->mock_auth = true;
safe_strcpy(client->login_user_credentials->name, username, sizeof(client->login_user_credentials->name));
if (!check_user_connection_count(client)) {
return false;
}
}
}
return finish_set_pool(client, takeover);
}
bool handle_auth_query_response(PgSocket *client, PktHdr *pkt)
{
uint16_t columns;
uint32_t length;
const char *username, *password;
PgCredentials credentials;
PgSocket *server = client->link;
switch (pkt->type) {
case PqMsg_RowDescription:
if (!mbuf_get_uint16be(&pkt->data, &columns)) {
disconnect_server(server, false, "bad packet");
return false;
}
if (columns != 2u) {
disconnect_server(server, false, "expected 2 columns from auth_query, not %hu", columns);
return false;
}
break;
case PqMsg_DataRow:
memset(&credentials, 0, sizeof(credentials));
if (!mbuf_get_uint16be(&pkt->data, &columns)) {
disconnect_server(server, false, "bad packet");
return false;
}
if (columns != 2u) {
disconnect_server(server, false, "expected 2 columns from auth_query, not %hu", columns);
return false;
}
if (!mbuf_get_uint32be(&pkt->data, &length)) {
disconnect_server(server, false, "bad packet");
return false;
}
if (length == (uint32_t)-1) {
disconnect_server(server, false, "auth_query response contained null user name");
return false;
}
if (!mbuf_get_chars(&pkt->data, length, &username)) {
disconnect_server(server, false, "bad packet");
return false;
}
if (sizeof(credentials.name) - 1 < length)
length = sizeof(credentials.name) - 1;
memcpy(credentials.name, username, length);
if (!mbuf_get_uint32be(&pkt->data, &length)) {
disconnect_server(server, false, "bad packet");
return false;
}
if (length == (uint32_t)-1) {
/*
* NULL - set an md5 password with an impossible value,
* so that nothing will ever match
*/
password = "md5";
length = 3;
} else {
if (!mbuf_get_chars(&pkt->data, length, &password)) {
disconnect_server(server, false, "bad packet");
return false;
}
}
if (sizeof(credentials.passwd) - 1 < length)
length = sizeof(credentials.passwd) - 1;
memcpy(credentials.passwd, password, length);
slog_debug(client, "successfully parsed auth_query response for user %s", credentials.name);
client->login_user_credentials = add_dynamic_credentials(client->db, credentials.name, credentials.passwd);
if (!check_user_connection_count(client)) {
return false;
}
if (!client->login_user_credentials) {
disconnect_server(server, false, "unable to allocate new user for auth");
return false;
}
break;
case PqMsg_NoticeResponse:
break;
case PqMsg_CommandComplete:
break;
case PqMsg_ParseComplete:
break;
case PqMsg_BindComplete:
break;
case PqMsg_ParameterStatus:
break;
case PqMsg_ReadyForQuery:
sbuf_prepare_skip(&client->link->sbuf, pkt->len);
if (!client->login_user_credentials) {
if (cf_log_connections)
slog_info(client, "login failed: db=%s", client->db->name);
/*
* TODO: Currently no mock authentication when
* using auth_query/auth_user; we just abort
* with a revealing message to the client.
* The main problem is that at this point we
* don't know the original user name anymore
* to do that. As a workaround, the
* auth_query could be written in a way that
* it returns a fake user and password if the
* requested user doesn't exist.
*/
disconnect_client(client, true, "no such user");
} else {
slog_noise(client, "auth query complete");
client->link->resetting = true;
sbuf_continue(&client->sbuf);
}
/*
* either sbuf_continue or disconnect_client could disconnect the server
* way down in their bowels of other callbacks. so check that, and
* return appropriately (similar to reuse_on_release)
*/
if (server->state == SV_FREE || server->state == SV_JUSTFREE)
return false;
return true;
case PqMsg_ErrorResponse:
log_server_error("S: error in auth_query", pkt);
disconnect_server(server, false, "error response from auth_query");
return false;
default:
disconnect_server(server, false, "unexpected response from auth_query");
return false;
}
sbuf_prepare_skip(&server->sbuf, pkt->len);
return true;
}
/*
* read_escaped_token reads a token that might be escaped using backslashes
* from the escaped_string_ptr. The token is written in unescaped form to the
* unescaped_token buffer. escape_string_ptr is set to the character right
* after the token.
*/
static bool read_escaped_token(const char **escaped_string_ptr, struct MBuf *unescaped_token)
{
const char *position = *escaped_string_ptr;
const char *unwritten_start = position;
while (*position) {
if (*position == '\\') {
if (!mbuf_write(unescaped_token, unwritten_start, position - unwritten_start))
return false;
position++;
unwritten_start = position;
if (!*position)
break;
} else if (isspace(*position)) {
break;
}
position++;
}
if (!mbuf_write(unescaped_token, unwritten_start, position - unwritten_start))
return false;
if (!mbuf_write_byte(unescaped_token, '\0'))
return false;
*escaped_string_ptr = position;
return true;
}
/*
* set_startup_options takes the value of the "options" startup parameter
* and uses it to set the parameters that are embedded in this value.
*
* It only supports the following type of PostgreSQL command line argument:
* -c config=value
*
* The reason that we don't support all arguments is to keep the parsing simple
* an this is by far the argument that's most commonly used in practice in the
* options startup parameter. Also all other postgres command line arguments
* can be rewritten to this form.
*
* NOTE: it's possible to supply "options" in ignore_startup_parameters, which
* results in all unknown options being ignored. This is for historical reasons,
* because it was supported like that in the past.
*/
static bool set_startup_options(PgSocket *client, const char *options)
{
char arg_buf[400];
struct MBuf arg;
const char *position = options;
if (client->replication) {
/*
* Since replication clients will be bound 1-to-1 to a server
* connection, we can support any configuration flags and
* fields in the options startup parameter. Because we can
* simply send the exact same value for the options parameter
* when opening the replication connection to the server. This
* allows us to also support GUCs that don't have the
* GUC_REPORT flag, specifically extra_float_digits which is a
* configuration that is set by CREATE SUBSCRIPTION in the
* options parameter.
*
* First free it, because set_startup_options might be called
* multiple times in some cases. One of these being when
* auth_user is enabled.
*/
free(client->startup_options);
client->startup_options = strdup(options);
if (!client->startup_options)
disconnect_client(client, true, "out of memory");
return true;
}
mbuf_init_fixed_writer(&arg, arg_buf, sizeof(arg_buf));
slog_debug(client, "received options: %s", options);
while (*position) {
const char *start_position = position;
const char *key_string, *value_string;
char *equals;
mbuf_rewind_writer(&arg);
position = cstr_skip_ws((char *) position);
if (strncmp("-c", position, 2) == 0) {
position += 2;
position = cstr_skip_ws((char *) position);
} else if (strncmp("--", position, 2) == 0) {
position += 2;
} else {
goto fail;
}
if (!read_escaped_token(&position, &arg)) {
if (arg.fixed) {
mbuf_init_dynamic(&arg);
position = start_position;
continue;
}
disconnect_client(client, true, "out of memory");
mbuf_free(&arg);
return false;
}
equals = strchr((char *) arg.data, '=');
if (!equals)
goto fail;
*equals = '\0';
key_string = (const char *) arg.data;
value_string = (const char *) equals + 1;
if (varcache_set(&client->vars, key_string, value_string)) {
slog_debug(client, "got var from options: %s=%s", key_string, value_string);
} else if (strlist_contains(cf_ignore_startup_params, key_string) || strlist_contains(cf_ignore_startup_params, "options")) {
slog_debug(client, "ignoring startup parameter from options: %s=%s", key_string, value_string);
} else {
slog_warning(client, "unsupported startup parameter in options: %s=%s", key_string, value_string);
disconnect_client(client, true, "unsupported startup parameter in options: %s", key_string);
mbuf_free(&arg);
return false;
}
}
mbuf_free(&arg);
return true;
fail:
disconnect_client(client, true, "unsupported options startup parameter: only '-c config=val' and '--config=val' are allowed");
mbuf_free(&arg);
return false;
}
static void set_appname(PgSocket *client, const char *app_name)
{
char buf[400], abuf[300];
const char *details;
if (cf_application_name_add_host) {
/* give app a name */
if (!app_name)
app_name = "app";
/* add details */
details = pga_details(&client->remote_addr, abuf, sizeof(abuf));
snprintf(buf, sizeof(buf), "%s - %s", app_name, details);
app_name = buf;
}
if (app_name) {
slog_debug(client, "using application_name: %s", app_name);
varcache_set(&client->vars, "application_name", app_name);
}
}
/*
* set_replication sets the replication field on the client according the given
* replicationString.
*/
static bool set_replication(PgSocket *client, const char *replicationString)
{
bool replicationBool = false;
if (strcmp(replicationString, "database") == 0) {
client->replication = REPLICATION_LOGICAL;
return true;
}
if (!parse_bool(replicationString, &replicationBool)) {
return false;
}
client->replication = replicationBool ? REPLICATION_PHYSICAL : REPLICATION_NONE;
return true;
}
static bool decide_startup_pool(PgSocket *client, PktHdr *pkt)
{
const char *username = NULL, *dbname = NULL;
const char *key, *val;
bool ok;
bool appname_found = false;
struct MBuf unsupported_protocol_extensions;
int unsupported_protocol_extensions_count = 0;
unsigned original_read_pos = pkt->data.read_pos;
mbuf_init_dynamic(&unsupported_protocol_extensions);
/*
* First check if we're dealing with a replication connection. Because for
* those we support some additional things when parsing the startup
* parameters, specifically we support any arguments in the options startup
* packet.
*/
while (1) {
ok = mbuf_get_string(&pkt->data, &key);
if (!ok || *key == 0)
break;
ok = mbuf_get_string(&pkt->data, &val);
if (!ok)
break;
if (strcmp(key, "replication") == 0) {
slog_debug(client, "got var: %s=%s", key, val);
set_replication(client, val);
}
}
pkt->data.read_pos = original_read_pos;
while (1) {
ok = mbuf_get_string(&pkt->data, &key);
if (!ok || *key == 0)
break;
ok = mbuf_get_string(&pkt->data, &val);
if (!ok)
break;
if (strcmp(key, "database") == 0) {
slog_debug(client, "got var: %s=%s", key, val);
dbname = val;
} else if (strcmp(key, "user") == 0) {
slog_debug(client, "got var: %s=%s", key, val);
username = val;
} else if (strcmp(key, "options") == 0) {
if (!set_startup_options(client, val))
return false;
} else if (strcmp(key, "application_name") == 0) {
set_appname(client, val);
appname_found = true;
} else if (strcmp(key, "replication") == 0) {
/* do nothing, already checked in the previous loop */
} else if (strncmp("_pq_.", key, 5) == 0) {
slog_debug(client, "ignoring protocol extension parameter: %s=%s", key, val);
unsupported_protocol_extensions_count++;
if (!mbuf_write(&unsupported_protocol_extensions, key, strlen(key) + 1))
return false;
} else if (varcache_set(&client->vars, key, val)) {
slog_debug(client, "got var: %s=%s", key, val);
} else if (strlist_contains(cf_ignore_startup_params, key)) {
slog_debug(client, "ignoring startup parameter: %s=%s", key, val);
} else {
slog_warning(client, "unsupported startup parameter: %s=%s", key, val);
disconnect_client(client, true, "unsupported startup parameter: %s", key);
return false;
}
}
if (!username || !username[0]) {
disconnect_client(client, true, "no username supplied");
return false;
}
/* if missing dbname, default to username */
if (!dbname || !dbname[0])
dbname = username;
/* create application_name if requested */
if (!appname_found)
set_appname(client, NULL);
/* check if limit allows, don't limit admin db
nb: new incoming conn will be attached to PgSocket, thus
get_active_client_count() counts it */
if (get_active_client_count() > cf_max_client_conn) {
if (strcmp(dbname, "pgbouncer") != 0) {
disconnect_client(client, true, "no more connections allowed (max_client_conn)");
return false;
}
}
if (pkt->type == PKT_STARTUP_V3_UNSUPPORTED || unsupported_protocol_extensions_count > 0) {
PktBuf *buf = pktbuf_dynamic(512);
int res;
pktbuf_write_NegotiateProtocolVersion(
buf,
unsupported_protocol_extensions_count,
unsupported_protocol_extensions.data,
unsupported_protocol_extensions.write_pos
);
res = pktbuf_send_immediate(buf, client);
if (!res) {
pktbuf_free(buf);
disconnect_client(client, false, "unable to send protocol negotiation packet");
return false;
}
}
/* find pool */
return set_pool(client, dbname, username, NULL, false);
}
static bool scram_client_first(PgSocket *client, uint32_t datalen, const uint8_t *data)
{
char *ibuf;
char *input;
int res;
PgCredentials *user = client->login_user_credentials;
ibuf = malloc(datalen + 1);
if (ibuf == NULL)
return false;
memcpy(ibuf, data, datalen);
ibuf[datalen] = '\0';
input = ibuf;
slog_debug(client, "SCRAM client-first-message = \"%s\"", input);
if (!read_client_first_message(client, input,
&client->scram_state.cbind_flag,
&client->scram_state.client_first_message_bare,
&client->scram_state.client_nonce))
goto failed;
if (!user->mock_auth) {
slog_debug(client, "stored secret = \"%s\"", user->passwd);
switch (get_password_type(user->passwd)) {
case PASSWORD_TYPE_MD5:
slog_error(client, "SCRAM authentication failed: user has MD5 secret");
goto failed;
case PASSWORD_TYPE_PLAINTEXT:
case PASSWORD_TYPE_SCRAM_SHA_256:
break;
}
}
if (!build_server_first_message(&client->scram_state, user->name, user->mock_auth ? NULL : user->passwd))
goto failed;
slog_debug(client, "SCRAM server-first-message = \"%s\"", client->scram_state.server_first_message);
SEND_generic(res, client, PqMsg_AuthenticationRequest, "ib",
AUTH_REQ_SASL_CONT,
client->scram_state.server_first_message,
strlen(client->scram_state.server_first_message));
free(ibuf);
return res;
failed:
free(ibuf);
return false;
}
static bool scram_client_final(PgSocket *client, uint32_t datalen, const uint8_t *data)
{
char *ibuf;
char *input;
const char *client_final_nonce = NULL;
char *proof = NULL;
char *server_final_message;
int res;
ibuf = malloc(datalen + 1);
if (ibuf == NULL)
return false;
memcpy(ibuf, data, datalen);
ibuf[datalen] = '\0';
input = ibuf;
slog_debug(client, "SCRAM client-final-message = \"%s\"", input);
if (!read_client_final_message(client, data, input,
&client_final_nonce,
&proof))
goto failed;
slog_debug(client, "SCRAM client-final-message-without-proof = \"%s\"",
client->scram_state.client_final_message_without_proof);
if (!verify_final_nonce(&client->scram_state, client_final_nonce)) {
slog_error(client, "invalid SCRAM response (nonce does not match)");
goto failed;
}
if (!verify_client_proof(&client->scram_state, proof)
|| !client->login_user_credentials) {
slog_error(client, "password authentication failed");
goto failed;
}
server_final_message = build_server_final_message(&client->scram_state);
if (!server_final_message)
goto failed;
slog_debug(client, "SCRAM server-final-message = \"%s\"", server_final_message);
SEND_generic(res, client, PqMsg_AuthenticationRequest, "ib",
AUTH_REQ_SASL_FIN,
server_final_message,
strlen(server_final_message));
free(server_final_message);
free(proof);
free(ibuf);
return res;
failed:
free(proof);
free(ibuf);
return false;
}
/* decide on packets of client in login phase */
static bool handle_client_startup(PgSocket *client, PktHdr *pkt)
{
const char *passwd;
const uint8_t *key;
bool ok;
bool is_unix = pga_is_unix(&client->remote_addr);
SBuf *sbuf = &client->sbuf;
/* don't tolerate partial packets */
if (incomplete_pkt(pkt)) {
if (pkt->len > (unsigned) cf_sbuf_len) {
/*
* We need to handle the complete packet, but it is too
* large to fit into our sbuf buffer size (determined
* by the pkt_buf config). So now we need to fetch the
* whole packet using our dynamically sized packet
* buffering logic.
*/
client->packet_cb_state.flag = CB_WANT_COMPLETE_PACKET;
sbuf_prepare_fetch(sbuf, pkt->len);
return true;
} else {
/*
* We need to handle the complete packet, but it fits
* in our sbuf buffer, so we can simply return false to
* indicate to sbuf to retry once it has received more
* data
*/
return false;
}
}
if (client->wait_for_welcome || client->wait_for_auth) {
if (finish_client_login(client)) {
if (client->packet_cb_state.flag != CB_HANDLE_COMPLETE_PACKET) {
/* the packet was already parsed */
sbuf_prepare_skip(sbuf, pkt->len);
}
return true;
} else {
return false;
}
}
switch (pkt->type) {
case PKT_SSLREQ:
slog_noise(client, "C: req SSL");
if (client->sbuf.tls) {
disconnect_client(client, false, "SSL req inside SSL");
return false;
}
if (client_accept_sslmode != SSLMODE_DISABLED && !is_unix) {
slog_noise(client, "P: SSL ack");
if (!sbuf_answer(&client->sbuf, "S", 1)) {
disconnect_client(client, false, "failed to ack SSL");
return false;
}
if (!sbuf_tls_accept(&client->sbuf)) {
disconnect_client(client, false, "failed to accept SSL");
return false;
}
break;
}
/* reject SSL attempt */
slog_noise(client, "P: nak");
if (!sbuf_answer(&client->sbuf, "N", 1)) {
disconnect_client(client, false, "failed to nak SSL");
return false;
}
break;
case PKT_GSSENCREQ:
/* reject GSS encryption attempt */
slog_noise(client, "C: req GSS enc");
if (!sbuf_answer(&client->sbuf, "N", 1)) {
disconnect_client(client, false, "failed to nak GSS enc");
return false;
}
break;
case PKT_STARTUP_V2:
disconnect_client(client, true, "old V2 protocol not supported");
return false;
case PKT_STARTUP_V3_UNSUPPORTED:
case PKT_STARTUP_V3:
/* require SSL except on unix socket */
if (client_accept_sslmode >= SSLMODE_REQUIRE && !client->sbuf.tls && !is_unix) {
disconnect_client(client, true, "SSL required");
return false;
}
if (client->pool && !sending_auth_query(client)) {
disconnect_client(client, true, "client re-sent startup pkt");
return false;
}
if (client->wait_for_user) {
client->wait_for_user = false;
if (!finish_set_pool(client, false))
return false;
} else if (!decide_startup_pool(client, pkt)) {
return false;
}
break;
case PqMsg_PasswordMessage: /* or SASLInitialResponse, or SASLResponse */
/* too early */
if (!client->login_user_credentials) {
disconnect_client(client, true, "client password pkt before startup packet");
return false;
}
if (client->client_auth_type == AUTH_TYPE_SCRAM_SHA_256) {
const char *mech;
uint32_t length;
const uint8_t *data;
if (!client->scram_state.server_nonce) {
/* process as SASLInitialResponse */
if (!mbuf_get_string(&pkt->data, &mech))
return false;
slog_debug(client, "C: selected SASL mechanism: %s", mech);
if (strcmp(mech, "SCRAM-SHA-256") != 0) {
disconnect_client(client, true, "client selected an invalid SASL authentication mechanism");
return false;
}
if (!mbuf_get_uint32be(&pkt->data, &length))
return false;
if (!mbuf_get_bytes(&pkt->data, length, &data))
return false;
if (!scram_client_first(client, length, data)) {
disconnect_client(client, true, "SASL authentication failed");
return false;
}
} else {
/* process as SASLResponse */
length = mbuf_avail_for_read(&pkt->data);
if (!mbuf_get_bytes(&pkt->data, length, &data))
return false;
if (scram_client_final(client, length, data)) {
/* save SCRAM keys for user */
if (!client->scram_state.adhoc && !client->db->fake) {
memcpy(client->pool->user_credentials->scram_ClientKey,
client->scram_state.ClientKey,
sizeof(client->scram_state.ClientKey));
memcpy(client->pool->user_credentials->scram_ServerKey,
client->scram_state.ServerKey,
sizeof(client->scram_state.ServerKey));
client->pool->user_credentials->has_scram_keys = true;
}
free_scram_state(&client->scram_state);
if (!finish_client_login(client))
return false;
} else {
disconnect_client(client, true, "SASL authentication failed");
return false;
}
}
} else {
/* process as PasswordMessage */
ok = mbuf_get_string(&pkt->data, &passwd);
if (ok) {
/*
* Don't allow an empty password; see
* PostgreSQL recv_password_packet().
*/
if (!*passwd) {
disconnect_client(client, true, "empty password returned by client");
return false;
}
if (client->client_auth_type == AUTH_TYPE_PAM) {
if (!sbuf_pause(&client->sbuf)) {
disconnect_client(client, true, "pause failed");
return false;
}
pam_auth_begin(client, passwd);
return false;
}
if (check_client_passwd(client, passwd)) {
if (!finish_client_login(client))
return false;
} else {
disconnect_client(client, true, "password authentication failed");
return false;
}
}
}
break;
case PKT_CANCEL:
if (mbuf_avail_for_read(&pkt->data) == BACKENDKEY_LEN
&& mbuf_get_bytes(&pkt->data, BACKENDKEY_LEN, &key)) {
memcpy(client->cancel_key, key, BACKENDKEY_LEN);
accept_cancel_request(client);
} else {
disconnect_client(client, false, "bad cancel request");
}
return false;
default:
disconnect_client(client, false, "bad packet");
return false;
}
if (client->packet_cb_state.flag != CB_HANDLE_COMPLETE_PACKET) {
sbuf_prepare_skip(sbuf, pkt->len);
}
client->request_time = get_cached_time();
return true;
}
/* decide on packets of logged-in client */
static bool handle_client_work(PgSocket *client, PktHdr *pkt)
{
SBuf *sbuf = &client->sbuf;
int track_outstanding = false;
PreparedStatementAction ps_action = PS_IGNORE;
PgClosePacket close_packet;
switch (pkt->type) {
/* one-packet queries */
case PqMsg_Query:
if (cf_disable_pqexec) {
slog_error(client, "client used \"Query\" packet type");
disconnect_client(client, true, "PQexec disallowed");
return false;
}
track_outstanding = true;
break;
case PqMsg_FunctionCall:
track_outstanding = true;
break;
/* request immediate response from server */
case PqMsg_Sync:
track_outstanding = true;
break;
case PqMsg_Flush:
break;
/* copy end markers */
case PqMsg_CopyDone:
case PqMsg_CopyFail:
track_outstanding = true;
break;
/*
* extended protocol allows server (and thus pooler)
* to buffer packets until sync or flush is sent by client
*/
case PqMsg_Parse:
track_outstanding = true;
if (is_prepared_statements_enabled(client)) {
ps_action = inspect_parse_packet(client, pkt);
pkt_rewind_v3(pkt);
}
break;
case PqMsg_Execute:
track_outstanding = true;
break;
case PqMsg_Close:
track_outstanding = true;
if (is_prepared_statements_enabled(client)) {
ps_action = inspect_describe_or_close_packet(client, pkt);
pkt_rewind_v3(pkt);
}
break;
case PqMsg_Bind:
track_outstanding = true;
if (is_prepared_statements_enabled(client)) {
ps_action = inspect_bind_packet(client, pkt);
pkt_rewind_v3(pkt);
}
break;
case PqMsg_Describe:
track_outstanding = true;
if (is_prepared_statements_enabled(client)) {
ps_action = inspect_describe_or_close_packet(client, pkt);
pkt_rewind_v3(pkt);
}
break;
case PqMsg_CopyData:
break;
/* client wants to go away */
default:
slog_error(client, "unknown pkt from client: %u/0x%x", pkt->type, pkt->type);
disconnect_client(client, true, "unknown pkt");
return false;
case PqMsg_Terminate:
disconnect_client(client, false, "client close request");
return false;
}
if (ps_action == PS_HANDLE_FULL_PACKET && incomplete_pkt(pkt)) {
if (pkt->len > (unsigned) cf_sbuf_len) {
/*
* We need to handle the complete packet, but it is too
* large to fit into our sbuf buffer size (determined
* by the pkt_buf config). So now we need to fetch the
* whole packet using our dynamically sized packet
* buffering logic.
*/
client->packet_cb_state.flag = CB_WANT_COMPLETE_PACKET;
sbuf_prepare_fetch(sbuf, pkt->len);
return true;
} else {
/*
* We need to handle the complete packet, but it fits
* in our sbuf buffer, so we can simply return false to
* indicate to sbuf to retry once it has received more
* data
*/
return false;
}
}
if (ps_action == PS_INSPECT_FAILED) {
if (!incomplete_pkt(pkt)) {
/*
* We have the full packet, but still inspection
* failed. That means the packet is plain wrong.
*/
slog_error(client, "failed to parse prepared statement packet type '%c'", pkt->type);
disconnect_client(client, true, "failed to parse packet");
return false;
}
/*
* We don't have the full packet yet, so probably inspection
* failed because the required part of the packet was not
* received yet.
*/
if (pkt->data.write_pos >= (unsigned) cf_sbuf_len) {
/*
* We've filled up our complete sbuf buffer with this
* packet, but we still haven't been able to determine
* if we should handle this packet or not. This is
* quite unexpected, and probably means that the
* name of the prepared statement is larger than
* pkt_buf.
*/
client->packet_cb_state.flag = CB_WANT_COMPLETE_PACKET;
sbuf_prepare_fetch(sbuf, pkt->len);
return true;
}
/*
* In all other cases we simply return false to indicate to
* sbuf to retry after receiving more data.
*/
return false;
}
if (ps_action != PS_IGNORE && pkt->type == PqMsg_Close) {
if (!unmarshall_close_packet(client, pkt, &close_packet))
return false;
if (is_close_named_statement_packet(&close_packet)) {
if (!handle_close_statement_command(client, pkt, &close_packet))
return false;
client->pool->stats.client_bytes += pkt->len;
/* No further processing required */
return true;
}
}
/* update stats */
if (!client->query_start) {
client->pool->stats.query_count++;
client->query_start = get_cached_time();
}
/* remember timestamp of the first query in a transaction */
if (!client->xact_start) {
client->pool->stats.xact_count++;
client->xact_start = client->query_start;
}
if (client->pool->db->admin)
return admin_handle_client(client, pkt);
/* acquire server */
if (!find_server(client))
return false;
client->pool->stats.client_bytes += pkt->len;
/* tag the server as dirty */
client->link->ready = false;
client->link->idle_tx = false;
if (ps_action != PS_IGNORE) {
/*
* All the following handle_xxx_packet functions below insert packets
* into the packet queue through the extra_packets field of SBuf. This
* requires that all previous data in the iobuf is flushed. So lets
* just do that now, so that these functions don't have to worry about
* doing that.
*/
if (!sbuf_flush(sbuf))
return false;
switch (pkt->type)
{
case PqMsg_Parse:
return handle_parse_command(client, pkt);
case PqMsg_Bind:
return handle_bind_command(client, pkt);
case PqMsg_Describe:
return handle_describe_command(client, pkt);
}
return true;
}
/* forward the packet */
if (track_outstanding) {
if (!add_outstanding_request(client, pkt->type, RA_FORWARD)) {
/* TODO disconnect oom */
return false;
}
}
if (client->packet_cb_state.flag == CB_HANDLE_COMPLETE_PACKET) {
/*
* It's possible that the prepared statement logic required fully
* buffering the packet for inspection purposes using our callback
* packet buffering logic. But once it was fully buffered and the
* inspection caused us to determine that we should simply forward the
* packet (e.g. it was a Describe for a Portal). In those cases we
* cannot simply call sbuf_prepare_send, because we already consumed
* the packet using our callback logic. So now we need to first flush
* the queue, and then re-queue the fully buffered packet using our
* packet queueing logic.
*/
if (!sbuf_flush(sbuf))
return false;
if (!sbuf_queue_full_packet(&client->sbuf, &client->link->sbuf, pkt)) {
disconnect_client(client, true, "out of memory");
disconnect_server(client->link, true, "out of memory");
return false;
}
return true;
}
sbuf_prepare_send(sbuf, &client->link->sbuf, pkt->len);
return true;
}
/*
* expect_startup_packet chooses returns true if we expect a startup packet and
* false if we expect a regular packet.
*/
static bool expect_startup_packet(PgSocket *client)
{
switch (client->state) {
case CL_LOGIN:
return true;
break;
case CL_ACTIVE:
if (client->wait_for_welcome)
return true;
else
return false;
break;
case CL_WAITING:
fatal("why waiting client in client_proto()");
case CL_WAITING_CANCEL:
case CL_ACTIVE_CANCEL:
fatal("why canceling client in client_proto()");
default:
fatal("bad client state: %d", client->state);
}
}
/* callback from SBuf */
bool client_proto(SBuf *sbuf, SBufEvent evtype, struct MBuf *data)
{
bool res = false;
PgSocket *client = container_of(sbuf, PgSocket, sbuf);
PktHdr pkt;
Assert(!is_server_socket(client));
Assert(client->sbuf.sock);
Assert(client->state != CL_FREE);
/* may happen if close failed */
if (client->state == CL_JUSTFREE)
return false;
switch (evtype) {
case SBUF_EV_CONNECT_OK:
case SBUF_EV_CONNECT_FAILED:
/* ^ those should not happen */
case SBUF_EV_RECV_FAILED:
/*
* Don't log error if client disconnects right away,
* could be monitoring probe.
*/
if (client->state == CL_LOGIN && mbuf_avail_for_read(data) == 0)
disconnect_client(client, false, NULL);
else
disconnect_client(client, false, "client unexpected eof");
break;
case SBUF_EV_SEND_FAILED:
disconnect_server(client->link, false, "server connection closed");
break;
case SBUF_EV_READ:
/* Wait until full packet headers is available. */
if (incomplete_header(data)) {
slog_noise(client, "C: got partial header, trying to wait a bit");
return false;
}
if (!get_header(data, &pkt)) {
char hex[8*2 + 1];
disconnect_client(client, true, "bad packet header: '%s'",
hdr2hex(data, hex, sizeof(hex)));
return false;
}
slog_noise(client, "read pkt='%c' len=%u", pkt_desc(&pkt), pkt.len);
/*
* If we are reading an SSL request or GSSAPI
* encryption request, we should have no data already
* buffered at this point. If we do, it was received
* before we performed the SSL or GSSAPI handshake, so
* it wasn't encrypted and indeed may have been
* injected by a man-in-the-middle. We report this
* case to the client.
*/
if (pkt.type == PKT_SSLREQ && mbuf_avail_for_read(data) > 0) {
disconnect_client(client, true, "received unencrypted data after SSL request");
return false;
}
if (pkt.type == PKT_GSSENCREQ && mbuf_avail_for_read(data) > 0) {
disconnect_client(client, true, "received unencrypted data after GSSAPI encryption request");
return false;
}
client->request_time = get_cached_time();
if (expect_startup_packet(client)) {
res = handle_client_startup(client, &pkt);
} else {
res = handle_client_work(client, &pkt);
}
break;
case SBUF_EV_FLUSH:
/* client is not interested in it */
break;
case SBUF_EV_PKT_CALLBACK:
{
bool first = false;
if (client->packet_cb_state.pkt.type == 0) {
first = true;
if (!get_header(data, &client->packet_cb_state.pkt)) {
char hex[8*2 + 1];
disconnect_client(client, true, "bad packet header: '%s'",
hdr2hex(data, hex, sizeof(hex)));
return false;
}
mbuf_rewind_reader(data);
}
switch (client->packet_cb_state.flag) {
case CB_WANT_COMPLETE_PACKET:
if (first) {
slog_debug(client,
"buffering complete packet, pkt='%c' len=%d incomplete=%s available=%d",
pkt_desc(&client->packet_cb_state.pkt),
client->packet_cb_state.pkt.len,
incomplete_pkt(&client->packet_cb_state.pkt) ? "true" : "false",
mbuf_avail_for_read(data));
mbuf_init_dynamic(&client->packet_cb_state.pkt.data);
if (!mbuf_make_room(&client->packet_cb_state.pkt.data, client->packet_cb_state.pkt.len))
return false;
}
if (!mbuf_write_raw_mbuf(&client->packet_cb_state.pkt.data, data))
return false;
if (sbuf->pkt_remain != mbuf_avail_for_read(data)) {
/*
* We wrote the partial packet to our temporary buffer. So
* we "handled" it and want to receive more data.
*/
res = true;
break;
}
/*
* We wrote the full packet into memory. Change the callback state
* to indicate that. If anything fails while handling this packet
* we'll continue from the current state in the callback state
* machine.
*/
client->packet_cb_state.flag = CB_HANDLE_COMPLETE_PACKET;
/* fallthrough */
case CB_HANDLE_COMPLETE_PACKET:
/* Make sure we start reading after the header. */
if (expect_startup_packet(client)) {
pkt_rewind_v2(&client->packet_cb_state.pkt);
res = handle_client_startup(client, &client->packet_cb_state.pkt);
} else {
pkt_rewind_v3(&client->packet_cb_state.pkt);
res = handle_client_work(client, &client->packet_cb_state.pkt);
}
if (!res) {
return false;
}
client->packet_cb_state.flag = CB_NONE;
free_header(&client->packet_cb_state.pkt);
break;
default:
disconnect_client(client, true, "BUG: unknown packet callback flag");
break;
}
break;
}
case SBUF_EV_TLS_READY:
sbuf_continue(&client->sbuf);
res = true;
break;
}
return res;
}
pgbouncer-1.24.1/src/pktbuf.c 0000644 0001750 0000000 00000025707 14777762222 012750 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Packet writing and sending.
*/
#include "bouncer.h"
/*
* PostgreSQL type OIDs for result sets
*/
#define BYTEAOID 17
#define INT8OID 20
#define INT4OID 23
#define TEXTOID 25
#define NUMERICOID 1700
static void pktbuf_free_internal(PktBuf *buf)
{
if (!buf || buf->fixed_buf)
return;
log_debug("pktbuf_free(%p)", buf);
free(buf->buf);
free(buf->ev);
free(buf);
}
static PktBuf *temp_pktbuf;
/*
* free the given buffer, if it's a dynamic buffer and not the global temp
* buffer
*/
void pktbuf_free(PktBuf *buf)
{
if (buf == temp_pktbuf)
return;
pktbuf_free_internal(buf);
}
PktBuf *pktbuf_dynamic(int start_len)
{
PktBuf *buf = zmalloc(sizeof(PktBuf));
log_debug("pktbuf_dynamic(%d): %p", start_len, buf);
if (!buf)
return NULL;
buf->ev = zmalloc(sizeof(*buf->ev));
if (!buf->ev) {
pktbuf_free(buf);
return NULL;
}
buf->buf = malloc(start_len);
if (!buf->buf) {
pktbuf_free(buf);
return NULL;
}
buf->buf_len = start_len;
return buf;
}
void pktbuf_reset(struct PktBuf *pkt)
{
pkt->failed = false;
pkt->write_pos = 0;
pkt->pktlen_pos = 0;
pkt->send_pos = 0;
pkt->sending = false;
}
void pktbuf_static(PktBuf *buf, uint8_t *data, int len)
{
memset(buf, 0, sizeof(*buf));
buf->buf = data;
buf->buf_len = len;
buf->fixed_buf = true;
}
struct PktBuf *pktbuf_temp(void)
{
if (!temp_pktbuf)
temp_pktbuf = pktbuf_dynamic(512);
if (!temp_pktbuf)
die("out of memory");
pktbuf_reset(temp_pktbuf);
return temp_pktbuf;
}
void pktbuf_cleanup(void)
{
pktbuf_free_internal(temp_pktbuf);
temp_pktbuf = NULL;
}
bool pktbuf_send_immediate(PktBuf *buf, PgSocket *sk)
{
uint8_t *pos = buf->buf + buf->send_pos;
int amount = buf->write_pos - buf->send_pos;
ssize_t res;
if (buf->failed)
return false;
res = sbuf_op_send(&sk->sbuf, pos, amount);
if (res < 0) {
log_debug("pktbuf_send_immediate: %s", strerror(errno));
}
return res == amount;
}
static void pktbuf_send_func(evutil_socket_t fd, short flags, void *arg)
{
PktBuf *buf = arg;
SBuf *sbuf = &buf->queued_dst->sbuf;
int amount, res;
log_debug("pktbuf_send_func(%" PRId64 ", %d, %p)", (int64_t)fd, (int)flags, buf);
if (buf->failed)
return;
amount = buf->write_pos - buf->send_pos;
res = sbuf_op_send(sbuf, buf->buf + buf->send_pos, amount);
if (res < 0) {
if (errno == EAGAIN) {
res = 0;
} else {
log_error("pktbuf_send_func: %s", strerror(errno));
pktbuf_free(buf);
return;
}
}
buf->send_pos += res;
if (buf->send_pos < buf->write_pos) {
event_assign(buf->ev, pgb_event_base, fd, EV_WRITE, pktbuf_send_func, buf);
res = event_add(buf->ev, NULL);
if (res < 0) {
log_error("pktbuf_send_func: %s", strerror(errno));
pktbuf_free(buf);
}
} else {
pktbuf_free(buf);
}
}
bool pktbuf_send_queued(PktBuf *buf, PgSocket *sk)
{
Assert(!buf->sending);
Assert(!buf->fixed_buf);
if (buf->failed) {
pktbuf_free(buf);
return send_pooler_error(sk, true, NULL, false, "result prepare failed");
} else {
buf->sending = true;
buf->queued_dst = sk;
pktbuf_send_func(sk->sbuf.sock, EV_WRITE, buf);
return true;
}
}
static void make_room(PktBuf *buf, int len)
{
int newlen = buf->buf_len;
int need = buf->write_pos + len;
void *ptr;
if (newlen >= need)
return;
if (buf->failed)
return;
if (buf->fixed_buf) {
buf->failed = true;
return;
}
while (newlen < need)
newlen = newlen * 2;
log_debug("make_room(%p, %d): realloc newlen=%d",
buf, len, newlen);
ptr = realloc(buf->buf, newlen);
if (!ptr) {
buf->failed = true;
} else {
buf->buf = ptr;
buf->buf_len = newlen;
}
}
void pktbuf_put_char(PktBuf *buf, char val)
{
make_room(buf, 1);
if (buf->failed)
return;
buf->buf[buf->write_pos++] = val;
}
void pktbuf_put_uint16(PktBuf *buf, uint16_t val)
{
make_room(buf, 4);
if (buf->failed)
return;
buf->buf[buf->write_pos++] = (val >> 8) & 255;
buf->buf[buf->write_pos++] = val & 255;
}
void pktbuf_put_uint32(PktBuf *buf, uint32_t val)
{
uint8_t *pos;
make_room(buf, 4);
if (buf->failed)
return;
pos = buf->buf + buf->write_pos;
pos[0] = (val >> 24) & 255;
pos[1] = (val >> 16) & 255;
pos[2] = (val >> 8) & 255;
pos[3] = val & 255;
buf->write_pos += 4;
}
void pktbuf_put_uint64(PktBuf *buf, uint64_t val)
{
pktbuf_put_uint32(buf, val >> 32);
pktbuf_put_uint32(buf, (uint32_t)val);
}
void pktbuf_put_bytes(PktBuf *buf, const void *data, int len)
{
if (len == 0)
return;
make_room(buf, len);
if (buf->failed)
return;
memcpy(buf->buf + buf->write_pos, data, len);
buf->write_pos += len;
}
void pktbuf_put_string(PktBuf *buf, const char *str)
{
int len = strlen(str);
pktbuf_put_bytes(buf, str, len + 1);
}
/*
* write header, remember pos to write length later.
*/
void pktbuf_start_packet(PktBuf *buf, int type)
{
if (buf->failed)
return;
if (type < 256) {
/* new-style packet */
pktbuf_put_char(buf, type);
buf->pktlen_pos = buf->write_pos;
pktbuf_put_uint32(buf, 0);
} else {
/* old-style packet */
buf->pktlen_pos = buf->write_pos;
pktbuf_put_uint32(buf, 0);
pktbuf_put_uint32(buf, type);
}
}
void pktbuf_finish_packet(PktBuf *buf)
{
uint8_t *pos;
unsigned len;
if (buf->failed)
return;
len = buf->write_pos - buf->pktlen_pos;
pos = buf->buf + buf->pktlen_pos;
buf->pktlen_pos = 0;
*pos++ = (len >> 24) & 255;
*pos++ = (len >> 16) & 255;
*pos++ = (len >> 8) & 255;
*pos++ = len & 255;
}
/* types:
* c - char/byte
* h - uint16
* i - uint32
* q - uint64
* s - Cstring
* b - bytes
*/
void pktbuf_write_generic(PktBuf *buf, int type, const char *pktdesc, ...)
{
va_list ap;
int len;
const char *adesc = pktdesc;
uint8_t *bin;
pktbuf_start_packet(buf, type);
va_start(ap, pktdesc);
while (*adesc) {
switch (*adesc) {
case 'c':
pktbuf_put_char(buf, va_arg(ap, int));
break;
case 'h':
pktbuf_put_uint16(buf, va_arg(ap, int));
break;
case 'i':
pktbuf_put_uint32(buf, va_arg(ap, int));
break;
case 'q':
pktbuf_put_uint64(buf, va_arg(ap, uint64_t));
break;
case 's':
pktbuf_put_string(buf, va_arg(ap, char *));
break;
case 'b':
bin = va_arg(ap, uint8_t *);
len = va_arg(ap, int);
pktbuf_put_bytes(buf, bin, len);
break;
default:
fatal("bad pktdesc: %s", pktdesc);
}
adesc++;
}
va_end(ap);
/* set correct length */
pktbuf_finish_packet(buf);
}
/* send resultset column info
* tupdesc keys:
* 'i' - int4
* 'q' - int8
* 's' - string to text
* 'b' - bytes to bytea
* 'N' - uint64_t to numeric
* 'T' - usec_t to date
*/
void pktbuf_write_RowDescription(PktBuf *buf, const char *tupdesc, ...)
{
va_list ap;
char *name;
int i, ncol = strlen(tupdesc);
log_noise("write RowDescription");
pktbuf_start_packet(buf, PqMsg_RowDescription);
pktbuf_put_uint16(buf, ncol);
va_start(ap, tupdesc);
for (i = 0; i < ncol; i++) {
name = va_arg(ap, char *);
/* Fields: name, reloid, colnr, oid, typsize, typmod, fmt */
pktbuf_put_string(buf, name);
pktbuf_put_uint32(buf, 0);
pktbuf_put_uint16(buf, 0);
if (tupdesc[i] == 's') {
pktbuf_put_uint32(buf, TEXTOID);
pktbuf_put_uint16(buf, -1);
} else if (tupdesc[i] == 'b') {
pktbuf_put_uint32(buf, BYTEAOID);
pktbuf_put_uint16(buf, -1);
} else if (tupdesc[i] == 'i') {
pktbuf_put_uint32(buf, INT4OID);
pktbuf_put_uint16(buf, 4);
} else if (tupdesc[i] == 'q') {
pktbuf_put_uint32(buf, INT8OID);
pktbuf_put_uint16(buf, 8);
} else if (tupdesc[i] == 'N') {
pktbuf_put_uint32(buf, NUMERICOID);
pktbuf_put_uint16(buf, -1);
} else if (tupdesc[i] == 'T') {
pktbuf_put_uint32(buf, TEXTOID);
pktbuf_put_uint16(buf, -1);
} else {
fatal("bad tupdesc");
}
pktbuf_put_uint32(buf, -1);
pktbuf_put_uint16(buf, 0);
}
va_end(ap);
/* set correct length */
pktbuf_finish_packet(buf);
}
/*
* send DataRow.
*
* tupdesc keys:
* 'i' - int4
* 'q' - int8
* 's' - string to text
* 'b' - bytes to bytea
* 'N' - uint64_t to numeric
* 'T' - usec_t to date
*/
void pktbuf_write_DataRow(PktBuf *buf, const char *tupdesc, ...)
{
int ncol = strlen(tupdesc);
va_list ap;
pktbuf_start_packet(buf, PqMsg_DataRow);
pktbuf_put_uint16(buf, ncol);
va_start(ap, tupdesc);
for (int i = 0; i < ncol; i++) {
char tmp[100]; /* XXX good enough in practice */
const char *val = NULL;
if (tupdesc[i] == 'i') {
snprintf(tmp, sizeof(tmp), "%d", va_arg(ap, int));
val = tmp;
} else if (tupdesc[i] == 'q' || tupdesc[i] == 'N') {
snprintf(tmp, sizeof(tmp), "%" PRIu64, va_arg(ap, uint64_t));
val = tmp;
} else if (tupdesc[i] == 's') {
val = va_arg(ap, char *);
} else if (tupdesc[i] == 'b') {
int blen = va_arg(ap, int);
if (blen >= 0) {
uint8_t *bval = va_arg(ap, uint8_t *);
size_t required = 2 + blen * 2 + 1;
if (required > sizeof(tmp))
fatal("byte array too long (%zu > %zu)", required, sizeof(tmp));
strcpy(tmp, "\\x");
for (int j = 0; j < blen; j++)
sprintf(tmp + (2 + j * 2), "%02x", bval[j]);
val = tmp;
} else {
(void) va_arg(ap, uint8_t *);
val = NULL;
}
} else if (tupdesc[i] == 'T') {
usec_t time = va_arg(ap, usec_t);
val = format_time_s(time, tmp, sizeof(tmp));
} else {
fatal("bad tupdesc: %s", tupdesc);
}
if (val) {
int len = strlen(val);
pktbuf_put_uint32(buf, len);
pktbuf_put_bytes(buf, val, len);
} else {
/* NULL */
pktbuf_put_uint32(buf, -1);
}
}
va_end(ap);
pktbuf_finish_packet(buf);
}
/*
* Send Parse+Bind+Execute with string parameters.
*/
void pktbuf_write_ExtQuery(PktBuf *buf, const char *query, int nargs, ...)
{
va_list ap;
const char *val;
int len, i;
pktbuf_write_generic(buf, PqMsg_Parse, "csh", 0, query, 0);
pktbuf_start_packet(buf, PqMsg_Bind);
pktbuf_put_char(buf, 0); /* portal name */
pktbuf_put_char(buf, 0); /* query name */
pktbuf_put_uint16(buf, 0); /* number of parameter format codes */
pktbuf_put_uint16(buf, nargs); /* number of parameter values */
va_start(ap, nargs);
for (i = 0; i < nargs; i++) {
val = va_arg(ap, char *);
len = strlen(val);
pktbuf_put_uint32(buf, len);
pktbuf_put_bytes(buf, val, len);
}
va_end(ap);
pktbuf_put_uint16(buf, 0); /* number of result-column format codes */
pktbuf_finish_packet(buf);
pktbuf_write_generic(buf, PqMsg_Describe, "cc", 'P', 0);
pktbuf_write_generic(buf, PqMsg_Execute, "ci", 0, 0);
pktbuf_write_generic(buf, PqMsg_Sync, "");
}
pgbouncer-1.24.1/src/util.c 0000644 0001750 0000000 00000030073 14777762222 012422 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Random small utility functions
*/
#include "bouncer.h"
#include
#include
#include
#include
#ifdef USUAL_LIBSSL_FOR_TLS
#include
#include
#endif
int log_socket_prefix(enum LogLevel lev, void *ctx, char *dst, unsigned int dstlen)
{
const struct PgSocket *sock = ctx;
const char *user, *db, *host;
char host6[PGADDR_BUF];
int peer_id;
int port;
char stype;
/* no prefix */
if (!sock)
return 0;
/* format prefix */
stype = is_server_socket(sock) ? 'S' : 'C';
port = pga_port(&sock->remote_addr);
peer_id = sock->pool ? sock->pool->db->peer_id : 0;
db = sock->pool ? sock->pool->db->name : "(nodb)";
user = sock->login_user_credentials ? sock->login_user_credentials->name : "(nouser)";
if (pga_is_unix(&sock->remote_addr)) {
unsigned long pid = sock->remote_addr.scred.pid;
if (pid) {
snprintf(host6, sizeof(host6), "unix(%lu)", pid);
host = host6;
} else {
host = "unix";
}
} else {
host = pga_ntop(&sock->remote_addr, host6, sizeof(host6));
}
if (pga_family(&sock->remote_addr) == AF_INET6) {
if (peer_id) {
return snprintf(dst, dstlen, "%c-%p: peer-%d@[%s]:%d ",
stype, sock, peer_id, host, port);
}
return snprintf(dst, dstlen, "%c-%p: %s/%s@[%s]:%d ",
stype, sock, db, user, host, port);
} else {
if (peer_id) {
return snprintf(dst, dstlen, "%c-%p: peer-%d@%s:%d ",
stype, sock, peer_id, host, port);
}
return snprintf(dst, dstlen, "%c-%p: %s/%s@%s:%d ",
stype, sock, db, user, host, port);
}
}
const char *bin2hex(const uint8_t *src, unsigned srclen, char *dst, unsigned dstlen)
{
unsigned int i, j;
static const char hextbl [] = "0123456789abcdef";
if (!dstlen)
return "";
if (srclen*2 + 1 > dstlen)
srclen = (dstlen - 1) / 2;
for (i = j = 0; i < srclen; i++) {
dst[j++] = hextbl[src[i] >> 4];
dst[j++] = hextbl[src[i] & 15];
}
dst[j] = 0;
return dst;
}
/*
* PostgreSQL MD5 hashing.
*/
static void hash2hex(const uint8_t *hash, char *dst)
{
bin2hex(hash, MD5_DIGEST_LENGTH, dst, 16*2 + 1);
}
bool pg_md5_encrypt(const char *part1,
const char *part2, size_t part2len,
char *dest)
{
#ifdef USUAL_LIBSSL_FOR_TLS
EVP_MD_CTX *mdctx;
uint8_t hash[MD5_DIGEST_LENGTH];
ERR_clear_error();
mdctx = EVP_MD_CTX_create();
if (mdctx == NULL) {
log_error("MD5 authentication failed: out-of-memory");
return false;
}
if (!EVP_DigestInit(mdctx, EVP_md5()))
goto failed;
if (!EVP_DigestUpdate(mdctx, part1, strlen(part1)))
goto failed;
if (!EVP_DigestUpdate(mdctx, part2, part2len))
goto failed;
if (!EVP_DigestFinal_ex(mdctx, hash, 0))
goto failed;
EVP_MD_CTX_destroy(mdctx);
memcpy(dest, "md5", 3);
hash2hex(hash, dest + 3);
return true;
failed:
log_error("MD5 authentication failed: %s", ERR_reason_error_string(ERR_get_error()));
EVP_MD_CTX_destroy(mdctx);
return false;
#else
struct md5_ctx ctx;
uint8_t hash[MD5_DIGEST_LENGTH];
md5_reset(&ctx);
md5_update(&ctx, part1, strlen(part1));
md5_update(&ctx, part2, part2len);
md5_final(&ctx, hash);
memcpy(dest, "md5", 3);
hash2hex(hash, dest + 3);
return true;
#endif
}
/* wrapped for getting random bytes */
void get_random_bytes(uint8_t *dest, int len)
{
csrandom_bytes(dest, len);
}
/* set needed socket options */
bool tune_socket(int sock, bool is_unix)
{
int res;
int val;
const char *errpos;
bool ok;
/*
* Generic stuff + nonblock.
*/
errpos = "socket_setup";
ok = socket_setup(sock, true);
if (!ok)
goto fail;
/*
* Following options are for network sockets
*/
if (is_unix)
return true;
/*
* TCP Keepalive
*/
errpos = "socket_set_keepalive";
ok = socket_set_keepalive(sock, cf_tcp_keepalive, cf_tcp_keepidle,
cf_tcp_keepintvl, cf_tcp_keepcnt);
if (!ok)
goto fail;
/*
* TCP user timeout
*/
if (cf_tcp_user_timeout) {
errpos = "setsockopt/TCP_USER_TIMEOUT";
#ifdef TCP_USER_TIMEOUT
val = cf_tcp_user_timeout;
res = setsockopt(sock, IPPROTO_TCP, TCP_USER_TIMEOUT, &val, sizeof(val));
if (res < 0)
goto fail;
#else
errno = EINVAL;
goto fail;
#endif
}
/*
* set in-kernel socket buffer size
*/
if (cf_tcp_socket_buffer) {
val = cf_tcp_socket_buffer;
errpos = "setsockopt/SO_SNDBUF";
res = setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &val, sizeof(val));
if (res < 0)
goto fail;
val = cf_tcp_socket_buffer;
errpos = "setsockopt/SO_RCVBUF";
res = setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &val, sizeof(val));
if (res < 0)
goto fail;
}
/*
* Turn off kernel buffering, each send() will be one packet.
*/
val = 1;
errpos = "setsockopt/TCP_NODELAY";
res = setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
if (res < 0)
goto fail;
return true;
fail:
log_warning("%s(%d) failed: %s", errpos, sock, strerror(errno));
return false;
}
/*
* Find a string in comma-separated list.
*
* It does not support space inside tokens.
*/
bool strlist_contains(const char *liststr, const char *str)
{
int c, len = strlen(str);
const char *p, *listpos = liststr;
loop:
/* find string fragment, later check if actual token */
p = strstr(listpos, str);
if (p == NULL)
return false;
/* move listpos further */
listpos = p + len;
/* survive len=0 and avoid unnecessary compare */
if (*listpos)
listpos++;
/* check previous symbol */
if (p > liststr) {
c = *(p - 1);
if (!isspace(c) && c != ',')
goto loop;
}
/* check following symbol */
c = p[len];
if (c != 0 && !isspace(c) && c != ',')
goto loop;
return true;
}
void fill_remote_addr(PgSocket *sk, int fd, bool is_unix)
{
PgAddr *dst = &sk->remote_addr;
socklen_t len = sizeof(PgAddr);
int err;
if (is_unix) {
uid_t uid = 0;
gid_t gid = 0;
pid_t pid = 0;
pga_set(dst, AF_UNIX, cf_listen_port);
if (getpeercreds(fd, &uid, &gid, &pid) >= 0) {
log_noise("unix peer uid: %d", (int)uid);
} else if (errno != ENOSYS) {
/*
* Check for ENOSYS, so we don't write a
* warning every time if the OS doesn't
* support this call.
*/
log_warning("unix peer uid failed: %s", strerror(errno));
}
dst->scred.uid = uid;
dst->scred.pid = pid;
} else {
err = getpeername(fd, (struct sockaddr *)dst, &len);
if (err < 0) {
log_error("fill_remote_addr: getpeername(%d) = %s",
fd, strerror(errno));
}
}
}
void fill_local_addr(PgSocket *sk, int fd, bool is_unix)
{
PgAddr *dst = &sk->local_addr;
socklen_t len = sizeof(PgAddr);
int err;
if (is_unix) {
pga_set(dst, AF_UNIX, cf_listen_port);
dst->scred.uid = geteuid();
dst->scred.pid = getpid();
} else {
err = getsockname(fd, (struct sockaddr *)dst, &len);
if (err < 0) {
log_error("fill_local_addr: getsockname(%d) = %s",
fd, strerror(errno));
}
}
}
/*
* Error handling around evtimer_add() is nasty as the code
* may not be called again. As there is fixed number of timers
* in pgbouncer, provider safe_evtimer_add() that stores args of
* failed calls in static array and retries later.
*/
#define TIMER_BACKUP_SLOTS 10
struct timer_slot {
struct event *ev;
struct timeval tv;
};
static struct timer_slot timer_backup_list[TIMER_BACKUP_SLOTS];
static int timer_backup_used = 0;
void safe_evtimer_add(struct event *ev, struct timeval *tv)
{
int res;
struct timer_slot *ts;
res = evtimer_add(ev, tv);
if (res >= 0)
return;
if (timer_backup_used >= TIMER_BACKUP_SLOTS)
fatal("TIMER_BACKUP_SLOTS full");
ts = &timer_backup_list[timer_backup_used++];
ts->ev = ev;
ts->tv = *tv;
}
void rescue_timers(void)
{
struct timer_slot *ts;
while (timer_backup_used) {
ts = &timer_backup_list[timer_backup_used - 1];
if (evtimer_add(ts->ev, &ts->tv) < 0)
break;
timer_backup_used--;
}
}
/*
* PgAddr operations
*/
int pga_port(const PgAddr *a)
{
if (a->sa.sa_family == AF_INET6) {
return ntohs(a->sin6.sin6_port);
} else {
return ntohs(a->sin.sin_port);
}
}
/* set family and port */
void pga_set(PgAddr *a, int af, int port)
{
memset(a, 0, sizeof(*a));
if (af == AF_INET6) {
a->sin6.sin6_family = af;
a->sin6.sin6_port = htons(port);
} else {
a->sin.sin_family = af;
a->sin.sin_port = htons(port);
}
}
/* copy sockaddr_in/in6 to PgAddr */
void pga_copy(PgAddr *a, const struct sockaddr *sa)
{
switch (sa->sa_family) {
case AF_INET:
memcpy(&a->sin, sa, sizeof(a->sin));
break;
case AF_INET6:
memcpy(&a->sin6, sa, sizeof(a->sin6));
break;
case AF_UNIX:
log_error("pga_copy: AF_UNIX copy not supported");
}
}
int pga_cmp_addr(const PgAddr *a, const PgAddr *b)
{
if (pga_family(a) != pga_family(b))
return pga_family(a) - pga_family(b);
switch (pga_family(a)) {
case AF_INET:
return memcmp(&a->sin.sin_addr, &b->sin.sin_addr, sizeof(a->sin.sin_addr));
break;
case AF_INET6:
return memcmp(&a->sin6.sin6_addr, &b->sin6.sin6_addr, sizeof(a->sin6.sin6_addr));
break;
default:
log_error("pga_cmp_addr: unsupported family");
return 0;
}
}
/* convert pgaddr to string */
const char *pga_ntop(const PgAddr *a, char *dst, int dstlen)
{
const char *res = NULL;
char buf[PGADDR_BUF];
memset(buf, 0, sizeof(buf));
switch (pga_family(a)) {
case AF_UNIX:
res = "unix";
break;
case AF_INET:
res = inet_ntop(AF_INET, &a->sin.sin_addr, buf, sizeof(buf));
break;
case AF_INET6:
res = inet_ntop(AF_INET6, &a->sin6.sin6_addr, buf, sizeof(buf));
break;
default:
res = "(bad-af)";
}
if (res == NULL)
res = "(err-ntop)";
strlcpy(dst, res, dstlen);
return dst;
}
/* parse address from string */
bool pga_pton(PgAddr *a, const char *s, int port)
{
int res = 1;
if (strcmp(s, "unix") == 0) {
pga_set(a, AF_UNIX, port);
} else if (strcmp(s, "*") == 0) {
pga_set(a, AF_INET, port);
a->sin.sin_addr.s_addr = htonl(INADDR_ANY);
} else if (strchr(s, ':')) {
pga_set(a, AF_INET6, port);
res = inet_pton(AF_INET6, s, &a->sin6.sin6_addr);
} else {
pga_set(a, AF_INET, port);
res = inet_pton(AF_INET, s, &a->sin.sin_addr);
}
if (res == 0)
errno = EINVAL;
return res > 0;
}
const char *pga_str(const PgAddr *a, char *dst, int dstlen)
{
char buf[PGADDR_BUF];
pga_ntop(a, buf, sizeof(buf));
if (pga_family(a) == AF_INET6) {
snprintf(dst, dstlen, "[%s]:%d", buf, pga_port(a));
} else if (pga_family(a) == AF_UNIX && a->scred.pid) {
snprintf(dst, dstlen, "%s:%d$%lu", buf, pga_port(a), (unsigned long)a->scred.pid);
} else {
snprintf(dst, dstlen, "%s:%d", buf, pga_port(a));
}
return dst;
}
static const char *cached_hostname(void)
{
static char cache[256];
int err;
if (cache[0] == 0) {
err = gethostname(cache, sizeof(cache));
if (err != 0)
strlcpy(cache, "somehost", sizeof(cache));
}
return cache;
}
const char *pga_details(const PgAddr *a, char *dst, int dstlen)
{
char buf[PGADDR_BUF];
pga_ntop(a, buf, sizeof(buf));
if (pga_family(a) == AF_INET6) {
snprintf(dst, dstlen, "[%s]:%d", buf, pga_port(a));
} else if (pga_family(a) == AF_UNIX && a->scred.pid) {
snprintf(dst, dstlen, "%s(%lu@%s):%d", buf, (unsigned long)a->scred.pid, cached_hostname(), pga_port(a));
} else {
snprintf(dst, dstlen, "%s:%d", buf, pga_port(a));
}
return dst;
}
bool cf_set_authdb(struct CfValue *cv, const char *value)
{
if (!check_reserved_database(value)) {
log_error("cannot use the reserved \"%s\" database as an auth_dbname", value);
return false;
}
return cf_set_str(cv, value);
}
bool check_reserved_database(const char *value)
{
if (value && strcmp(value, "pgbouncer") == 0) {
return false;
}
return true;
}
pgbouncer-1.24.1/src/stats.c 0000644 0001750 0000000 00000027430 14777762222 012606 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include "bouncer.h"
static struct event ev_stats;
static usec_t old_stamp, new_stamp;
static void reset_stats(PgStats *stat)
{
stat->server_bytes = 0;
stat->client_bytes = 0;
stat->server_assignment_count = 0;
stat->query_count = 0;
stat->query_time = 0;
stat->xact_count = 0;
stat->xact_time = 0;
stat->wait_time = 0;
stat->ps_client_parse_count = 0;
stat->ps_server_parse_count = 0;
stat->ps_bind_count = 0;
}
static void stat_add(PgStats *total, PgStats *stat)
{
total->server_bytes += stat->server_bytes;
total->client_bytes += stat->client_bytes;
total->server_assignment_count += stat->server_assignment_count;
total->query_count += stat->query_count;
total->query_time += stat->query_time;
total->xact_count += stat->xact_count;
total->xact_time += stat->xact_time;
total->wait_time += stat->wait_time;
total->ps_client_parse_count += stat->ps_client_parse_count;
total->ps_server_parse_count += stat->ps_server_parse_count;
total->ps_bind_count += stat->ps_bind_count;
}
static void calc_average(PgStats *avg, PgStats *cur, PgStats *old)
{
uint64_t server_assignment_count;
uint64_t query_count;
uint64_t xact_count;
uint64_t ps_client_parse_count;
uint64_t ps_server_parse_count;
uint64_t ps_bind_count;
usec_t dur = get_cached_time() - old_stamp;
reset_stats(avg);
if (dur <= 0)
return;
query_count = cur->query_count - old->query_count;
xact_count = cur->xact_count - old->xact_count;
server_assignment_count = cur->server_assignment_count - old->server_assignment_count;
avg->query_count = USEC * query_count / dur;
avg->xact_count = USEC * xact_count / dur;
avg->server_assignment_count = USEC * server_assignment_count / dur;
avg->client_bytes = USEC * (cur->client_bytes - old->client_bytes) / dur;
avg->server_bytes = USEC * (cur->server_bytes - old->server_bytes) / dur;
if (query_count > 0)
avg->query_time = (cur->query_time - old->query_time) / query_count;
if (xact_count > 0)
avg->xact_time = (cur->xact_time - old->xact_time) / xact_count;
if (server_assignment_count > 0)
avg->wait_time = (cur->wait_time - old->wait_time) / server_assignment_count;
ps_client_parse_count = cur->ps_client_parse_count - old->ps_client_parse_count;
ps_server_parse_count = cur->ps_server_parse_count - old->ps_server_parse_count;
ps_bind_count = cur->ps_bind_count - old->ps_bind_count;
avg->ps_client_parse_count = USEC * ps_client_parse_count / dur;
avg->ps_server_parse_count = USEC * ps_server_parse_count / dur;
avg->ps_bind_count = USEC * ps_bind_count / dur;
}
static void write_stats(PktBuf *buf, PgStats *stat, PgStats *old, char *dbname)
{
PgStats avg;
calc_average(&avg, stat, old);
pktbuf_write_DataRow(buf, "sNNNNNNNNNNNNNNNNNNNNNN", dbname,
stat->server_assignment_count,
stat->xact_count, stat->query_count,
stat->client_bytes, stat->server_bytes,
stat->xact_time, stat->query_time,
stat->wait_time, stat->ps_client_parse_count,
stat->ps_server_parse_count, stat->ps_bind_count,
avg.server_assignment_count,
avg.xact_count, avg.query_count,
avg.client_bytes, avg.server_bytes,
avg.xact_time, avg.query_time,
avg.wait_time, avg.ps_client_parse_count,
avg.ps_server_parse_count, avg.ps_bind_count);
}
bool admin_database_stats(PgSocket *client, struct StatList *pool_list)
{
PgPool *pool;
struct List *item;
PgDatabase *cur_db = NULL;
PgStats st_db, old_db;
PktBuf *buf;
reset_stats(&st_db);
reset_stats(&old_db);
buf = pktbuf_dynamic(512);
if (!buf) {
admin_error(client, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "sNNNNNNNNNNNNNNNNNNNNNN", "database",
"total_server_assignment_count",
"total_xact_count", "total_query_count",
"total_received", "total_sent",
"total_xact_time", "total_query_time",
"total_wait_time", "total_client_parse_count",
"total_server_parse_count", "total_bind_count",
"avg_server_assignment_count",
"avg_xact_count", "avg_query_count",
"avg_recv", "avg_sent",
"avg_xact_time", "avg_query_time",
"avg_wait_time", "avg_client_parse_count",
"avg_server_parse_count", "avg_bind_count");
statlist_for_each(item, pool_list) {
pool = container_of(item, PgPool, head);
if (!cur_db)
cur_db = pool->db;
if (pool->db != cur_db) {
write_stats(buf, &st_db, &old_db, cur_db->name);
cur_db = pool->db;
reset_stats(&st_db);
reset_stats(&old_db);
}
stat_add(&st_db, &pool->stats);
stat_add(&old_db, &pool->older_stats);
}
if (cur_db) {
write_stats(buf, &st_db, &old_db, cur_db->name);
}
admin_flush(client, buf, "SHOW");
return true;
}
static void write_stats_totals(PktBuf *buf, PgStats *stat, PgStats *old, char *dbname)
{
pktbuf_write_DataRow(buf, "sNNNNNNNNNNN", dbname,
stat->server_assignment_count,
stat->xact_count, stat->query_count,
stat->client_bytes, stat->server_bytes,
stat->xact_time, stat->query_time,
stat->wait_time, stat->ps_client_parse_count,
stat->ps_server_parse_count, stat->ps_bind_count);
}
bool admin_database_stats_totals(PgSocket *client, struct StatList *pool_list)
{
PgPool *pool;
struct List *item;
PgDatabase *cur_db = NULL;
PgStats st_db, old_db;
PktBuf *buf;
reset_stats(&st_db);
reset_stats(&old_db);
buf = pktbuf_dynamic(512);
if (!buf) {
admin_error(client, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "sNNNNNNNNNNN", "database",
"server_assignment_count",
"xact_count", "query_count",
"bytes_received", "bytes_sent",
"xact_time", "query_time",
"wait_time", "client_parse_count",
"server_parse_count", "bind_count");
statlist_for_each(item, pool_list) {
pool = container_of(item, PgPool, head);
if (!cur_db)
cur_db = pool->db;
if (pool->db != cur_db) {
write_stats_totals(buf, &st_db, &old_db, cur_db->name);
cur_db = pool->db;
reset_stats(&st_db);
reset_stats(&old_db);
}
stat_add(&st_db, &pool->stats);
stat_add(&old_db, &pool->older_stats);
}
if (cur_db) {
write_stats_totals(buf, &st_db, &old_db, cur_db->name);
}
admin_flush(client, buf, "SHOW");
return true;
}
static void write_stats_averages(PktBuf *buf, PgStats *stat, PgStats *old, char *dbname)
{
PgStats avg;
calc_average(&avg, stat, old);
pktbuf_write_DataRow(buf, "sNNNNNNNNNNN", dbname,
avg.server_assignment_count,
avg.xact_count, avg.query_count,
avg.client_bytes, avg.server_bytes,
avg.xact_time, avg.query_time,
avg.wait_time, avg.ps_client_parse_count,
avg.ps_server_parse_count, avg.ps_bind_count);
}
bool admin_database_stats_averages(PgSocket *client, struct StatList *pool_list)
{
PgPool *pool;
struct List *item;
PgDatabase *cur_db = NULL;
PgStats st_db, old_db;
PktBuf *buf;
reset_stats(&st_db);
reset_stats(&old_db);
buf = pktbuf_dynamic(512);
if (!buf) {
admin_error(client, "no mem");
return true;
}
pktbuf_write_RowDescription(buf, "sNNNNNNNNNNN", "database",
"server_assignment_count",
"xact_count", "query_count",
"bytes_received", "bytes_sent",
"xact_time", "query_time",
"wait_time", "avg_client_parse_count",
"avg_server_parse_count", "avg_bind_count");
statlist_for_each(item, pool_list) {
pool = container_of(item, PgPool, head);
if (!cur_db)
cur_db = pool->db;
if (pool->db != cur_db) {
write_stats_averages(buf, &st_db, &old_db, cur_db->name);
cur_db = pool->db;
reset_stats(&st_db);
reset_stats(&old_db);
}
stat_add(&st_db, &pool->stats);
stat_add(&old_db, &pool->older_stats);
}
if (cur_db) {
write_stats_averages(buf, &st_db, &old_db, cur_db->name);
}
admin_flush(client, buf, "SHOW");
return true;
}
bool show_stat_totals(PgSocket *client, struct StatList *pool_list)
{
PgPool *pool;
struct List *item;
PgStats st_total, old_total, avg;
PktBuf *buf;
reset_stats(&st_total);
reset_stats(&old_total);
buf = pktbuf_dynamic(512);
if (!buf) {
admin_error(client, "no mem");
return true;
}
statlist_for_each(item, pool_list) {
pool = container_of(item, PgPool, head);
stat_add(&st_total, &pool->stats);
stat_add(&old_total, &pool->older_stats);
}
calc_average(&avg, &st_total, &old_total);
pktbuf_write_RowDescription(buf, "sN", "name", "value");
#define WTOTAL(name) pktbuf_write_DataRow(buf, "sN", "total_" #name, st_total.name)
#define WAVG(name) pktbuf_write_DataRow(buf, "sN", "avg_" #name, avg.name)
WTOTAL(server_assignment_count);
WTOTAL(xact_count);
WTOTAL(query_count);
WTOTAL(client_bytes);
WTOTAL(server_bytes);
WTOTAL(xact_time);
WTOTAL(query_time);
WTOTAL(wait_time);
WTOTAL(ps_client_parse_count);
WTOTAL(ps_server_parse_count);
WTOTAL(ps_bind_count);
WAVG(server_assignment_count);
WAVG(xact_count);
WAVG(query_count);
WAVG(client_bytes);
WAVG(server_bytes);
WAVG(xact_time);
WAVG(query_time);
WAVG(wait_time);
WAVG(ps_client_parse_count);
WAVG(ps_server_parse_count);
WAVG(ps_bind_count);
admin_flush(client, buf, "SHOW");
return true;
}
static void refresh_stats(evutil_socket_t s, short flags, void *arg)
{
struct List *item;
PgPool *pool;
PgStats old_total, cur_total;
PgStats avg;
reset_stats(&old_total);
reset_stats(&cur_total);
old_stamp = new_stamp;
new_stamp = get_cached_time();
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
pool->older_stats = pool->newer_stats;
pool->newer_stats = pool->stats;
if (cf_log_stats) {
stat_add(&cur_total, &pool->stats);
stat_add(&old_total, &pool->older_stats);
}
}
calc_average(&avg, &cur_total, &old_total);
if (cf_log_stats) {
log_info("stats: %" PRIu64 " xacts/s,"
" %" PRIu64 " queries/s,"
" %" PRIu64 " client parses/s,"
" %" PRIu64 " server parses/s,"
" %" PRIu64 " binds/s,"
" in %" PRIu64 " B/s,"
" out %" PRIu64 " B/s,"
" xact %" PRIu64 " us,"
" query %" PRIu64 " us,"
" wait %" PRIu64 " us",
avg.xact_count,
avg.query_count,
avg.ps_client_parse_count,
avg.ps_server_parse_count,
avg.ps_bind_count,
avg.client_bytes, avg.server_bytes,
avg.xact_time, avg.query_time,
avg.wait_time);
}
sd_notifyf(0,
"STATUS=stats: %" PRIu64 " xacts/s,"
" %" PRIu64 " queries/s,"
" %" PRIu64 " client parses/s,"
" %" PRIu64 " server parses/s,"
" %" PRIu64 " binds/s,"
" in %" PRIu64 " B/s,"
" out %" PRIu64 " B/s,"
" xact %" PRIu64 " μs,"
" query %" PRIu64 " μs,"
" wait %" PRIu64 " μs",
avg.xact_count,
avg.query_count,
avg.ps_client_parse_count,
avg.ps_server_parse_count,
avg.ps_bind_count,
avg.client_bytes, avg.server_bytes,
avg.xact_time, avg.query_time,
avg.wait_time);
}
void stats_setup(void)
{
struct timeval period = { cf_stats_period, 0 };
new_stamp = get_cached_time();
old_stamp = new_stamp - USEC;
/* launch stats */
event_assign(&ev_stats, pgb_event_base, -1, EV_PERSIST, refresh_stats, NULL);
if (event_add(&ev_stats, &period) < 0)
log_warning("event_add failed: %s", strerror(errno));
}
pgbouncer-1.24.1/src/objects.c 0000644 0001750 0000000 00000227512 14777762222 013104 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Herding objects between lists happens here.
*/
#include "bouncer.h"
#include "scram.h"
#include
#include
#include
/* those items will be allocated as needed, never freed */
STATLIST(user_list);
STATLIST(database_list);
STATLIST(pool_list);
STATLIST(peer_list);
STATLIST(peer_pool_list);
/* All locally defined users (in auth_file) are kept here. */
struct AATree user_tree;
/*
* All PAM users are kept here. We need to differentiate two user
* lists to avoid user clashing for different authentication types,
* and because pam_user_tree is closer to PgDatabase.user_tree in
* logic.
*/
struct AATree pam_user_tree;
/*
* The global prepared statement cache, which deduplicates prepared statements
* sent by the clients statements by storing every unique prepared statement
* only once.
*/
PgPreparedStatement *prepared_statements = NULL;
/*
* client and server objects will be pre-allocated
* they are always in either active or free lists
* in addition to others.
*/
STATLIST(login_client_list);
struct Slab *server_cache;
struct Slab *client_cache;
struct Slab *db_cache;
struct Slab *peer_cache;
struct Slab *peer_pool_cache;
struct Slab *pool_cache;
struct Slab *user_cache;
struct Slab *credentials_cache;
struct Slab *iobuf_cache;
struct Slab *outstanding_request_cache;
struct Slab *var_list_cache;
struct Slab *server_prepared_statement_cache;
unsigned long long int last_pgsocket_id;
/*
* libevent may still report events when event_del()
* is called from somewhere else. So hide just freed
* PgSockets for one loop.
*/
static STATLIST(justfree_client_list);
static STATLIST(justfree_server_list);
/* init autodb idle list */
STATLIST(autodatabase_idle_list);
const char *replication_type_parameters[] = {
[REPLICATION_NONE] = "no",
[REPLICATION_LOGICAL] = "database",
[REPLICATION_PHYSICAL] = "yes",
};
/* fast way to get number of active clients */
int get_active_client_count(void)
{
return slab_active_count(client_cache);
}
/* fast way to get number of active servers */
int get_active_server_count(void)
{
return slab_active_count(server_cache);
}
static void construct_client(void *obj)
{
PgSocket *client = obj;
memset(client, 0, sizeof(PgSocket));
list_init(&client->head);
sbuf_init(&client->sbuf, client_proto);
client->vars.var_list = slab_alloc(var_list_cache);
client->state = CL_FREE;
client->client_prepared_statements = NULL;
client->id = ++last_pgsocket_id;
}
static void construct_server(void *obj)
{
PgSocket *server = obj;
memset(server, 0, sizeof(PgSocket));
list_init(&server->head);
sbuf_init(&server->sbuf, server_proto);
server->vars.var_list = slab_alloc(var_list_cache);
server->state = SV_FREE;
server->server_prepared_statements = NULL;
statlist_init(&server->outstanding_requests, "outstanding_requests");
server->id = ++last_pgsocket_id;
}
/* compare string with PgGlobalUser->credentials.name, for usage with btree */
static int global_user_node_cmp(uintptr_t userptr, struct AANode *node)
{
const char *name = (const char *)userptr;
PgGlobalUser *global_user = container_of(node, PgGlobalUser, credentials.tree_node);
return strcmp(name, global_user->credentials.name);
}
/* compare string with PgCredentials->name, for usage with btree */
static int credentials_node_cmp(uintptr_t userptr, struct AANode *node)
{
const char *name = (const char *)userptr;
PgCredentials *credentials = container_of(node, PgCredentials, tree_node);
return strcmp(name, credentials->name);
}
/* destroy PgCredentials, for usage with btree */
static void credentials_node_release(struct AANode *node, void *arg)
{
PgCredentials *user = container_of(node, PgCredentials, tree_node);
slab_free(credentials_cache, user);
}
/* initialization before config loading */
void init_objects(void)
{
aatree_init(&user_tree, global_user_node_cmp, NULL);
aatree_init(&pam_user_tree, credentials_node_cmp, NULL);
user_cache = slab_create("user_cache", sizeof(PgGlobalUser), 0, NULL, USUAL_ALLOC);
credentials_cache = slab_create("credentials_cache", sizeof(PgCredentials), 0, NULL, USUAL_ALLOC);
db_cache = slab_create("db_cache", sizeof(PgDatabase), 0, NULL, USUAL_ALLOC);
peer_cache = slab_create("peer_cache", sizeof(PgDatabase), 0, NULL, USUAL_ALLOC);
peer_pool_cache = slab_create("peer_pool_cache", sizeof(PgPool), 0, NULL, USUAL_ALLOC);
pool_cache = slab_create("pool_cache", sizeof(PgPool), 0, NULL, USUAL_ALLOC);
outstanding_request_cache = slab_create("outstanding_request_cache", sizeof(OutstandingRequest), 0, NULL, USUAL_ALLOC);
if (!user_cache || !db_cache || !peer_cache || !peer_pool_cache || !pool_cache)
fatal("cannot create initial caches");
}
static void do_iobuf_reset(void *arg)
{
IOBuf *io = arg;
iobuf_reset(io);
}
/* initialization after config loading */
void init_caches(void)
{
server_cache = slab_create("server_cache", sizeof(PgSocket), 0, construct_server, USUAL_ALLOC);
client_cache = slab_create("client_cache", sizeof(PgSocket), 0, construct_client, USUAL_ALLOC);
iobuf_cache = slab_create("iobuf_cache", IOBUF_SIZE, 0, do_iobuf_reset, USUAL_ALLOC);
var_list_cache = slab_create("var_list_cache", sizeof(struct PStr *) * get_num_var_cached(), 0, NULL, USUAL_ALLOC);
server_prepared_statement_cache = slab_create("server_prepared_statement_cache", sizeof(PgServerPreparedStatement), 0, NULL, USUAL_ALLOC);
}
/* free all memory related to the given client */
static void client_free(PgSocket *client)
{
free_client_prepared_statements(client);
varcache_clean(&client->vars);
slab_free(var_list_cache, client->vars.var_list);
slab_free(client_cache, client);
}
/* free all memory related to the given server */
static void server_free(PgSocket *server)
{
struct List *el, *tmp_l;
OutstandingRequest *request;
statlist_for_each_safe(el, &server->outstanding_requests, tmp_l) {
request = container_of(el, OutstandingRequest, node);
statlist_remove(&server->canceling_clients, el);
if (request->server_ps)
free_server_prepared_statement(request->server_ps);
slab_free(outstanding_request_cache, request);
}
free_server_prepared_statements(server);
varcache_clean(&server->vars);
slab_free(var_list_cache, server->vars.var_list);
slab_free(server_cache, server);
}
/* state change means moving between lists */
void change_client_state(PgSocket *client, SocketState newstate)
{
PgPool *pool = client->pool;
/* remove from old location */
switch (client->state) {
case CL_FREE:
break;
case CL_JUSTFREE:
statlist_remove(&justfree_client_list, &client->head);
break;
case CL_LOGIN:
if (newstate == CL_WAITING)
newstate = CL_WAITING_LOGIN;
statlist_remove(&login_client_list, &client->head);
break;
case CL_WAITING_LOGIN:
if (newstate == CL_ACTIVE)
newstate = CL_LOGIN;
/* fallthrough */
case CL_WAITING:
statlist_remove(&pool->waiting_client_list, &client->head);
break;
case CL_ACTIVE:
statlist_remove(&pool->active_client_list, &client->head);
break;
case CL_ACTIVE_CANCEL:
statlist_remove(&pool->active_cancel_req_list, &client->head);
break;
case CL_WAITING_CANCEL:
statlist_remove(&pool->waiting_cancel_req_list, &client->head);
break;
default:
fatal("bad cur client state: %d", client->state);
}
client->state = newstate;
/* put to new location */
switch (client->state) {
case CL_FREE:
client_free(client);
break;
case CL_JUSTFREE:
statlist_append(&justfree_client_list, &client->head);
break;
case CL_LOGIN:
statlist_append(&login_client_list, &client->head);
break;
case CL_WAITING:
case CL_WAITING_LOGIN:
client->wait_start = get_cached_time();
statlist_append(&pool->waiting_client_list, &client->head);
break;
case CL_ACTIVE:
statlist_append(&pool->active_client_list, &client->head);
break;
case CL_ACTIVE_CANCEL:
statlist_append(&pool->active_cancel_req_list, &client->head);
break;
case CL_WAITING_CANCEL:
statlist_append(&pool->waiting_cancel_req_list, &client->head);
break;
default:
fatal("bad new client state: %d", client->state);
}
}
/* state change means moving between lists */
void change_server_state(PgSocket *server, SocketState newstate)
{
PgPool *pool = server->pool;
/* remove from old location */
switch (server->state) {
case SV_FREE:
break;
case SV_JUSTFREE:
statlist_remove(&justfree_server_list, &server->head);
break;
case SV_LOGIN:
statlist_remove(&pool->new_server_list, &server->head);
break;
case SV_USED:
statlist_remove(&pool->used_server_list, &server->head);
break;
case SV_TESTED:
statlist_remove(&pool->tested_server_list, &server->head);
break;
case SV_BEING_CANCELED:
statlist_remove(&pool->being_canceled_server_list, &server->head);
break;
case SV_IDLE:
statlist_remove(&pool->idle_server_list, &server->head);
break;
case SV_ACTIVE:
statlist_remove(&pool->active_server_list, &server->head);
break;
case SV_ACTIVE_CANCEL:
statlist_remove(&pool->active_cancel_server_list, &server->head);
break;
default:
fatal("bad old server state: %d", server->state);
}
server->state = newstate;
/* put to new location */
switch (server->state) {
case SV_FREE:
server_free(server);
break;
case SV_JUSTFREE:
statlist_append(&justfree_server_list, &server->head);
break;
case SV_LOGIN:
statlist_append(&pool->new_server_list, &server->head);
break;
case SV_USED:
/* use LIFO */
statlist_prepend(&pool->used_server_list, &server->head);
break;
case SV_TESTED:
statlist_append(&pool->tested_server_list, &server->head);
break;
case SV_BEING_CANCELED:
statlist_append(&pool->being_canceled_server_list, &server->head);
break;
case SV_IDLE:
if (server->close_needed || cf_server_round_robin) {
/* try to avoid immediate usage then */
statlist_append(&pool->idle_server_list, &server->head);
} else {
/* otherwise use LIFO */
statlist_prepend(&pool->idle_server_list, &server->head);
}
break;
case SV_ACTIVE:
statlist_append(&pool->active_server_list, &server->head);
break;
case SV_ACTIVE_CANCEL:
statlist_append(&pool->active_cancel_server_list, &server->head);
break;
default:
fatal("bad server state: %d", server->state);
}
}
/* compare pool names, for use with put_in_order */
static int cmp_pool(struct List *i1, struct List *i2)
{
PgPool *p1 = container_of(i1, PgPool, head);
PgPool *p2 = container_of(i2, PgPool, head);
if (p1->db != p2->db)
return strcmp(p1->db->name, p2->db->name);
if (p1->user_credentials != p2->user_credentials) {
if (p1->user_credentials == NULL) {
return 1;
}
if (p2->user_credentials == NULL) {
return -1;
}
return strcmp(p1->user_credentials->name, p2->user_credentials->name);
}
return 0;
}
/* compare pool names, for use with put_in_order */
static int cmp_peer_pool(struct List *i1, struct List *i2)
{
PgPool *p1 = container_of(i1, PgPool, head);
PgPool *p2 = container_of(i2, PgPool, head);
if (p1->db != p2->db)
return p1->db->peer_id - p2->db->peer_id;
return 0;
}
/* compare user names, for use with put_in_order */
static int cmp_user(struct List *i1, struct List *i2)
{
PgGlobalUser *u1 = container_of(i1, PgGlobalUser, head);
PgGlobalUser *u2 = container_of(i2, PgGlobalUser, head);
return strcmp(u1->credentials.name, u2->credentials.name);
}
/* compare db names, for use with put_in_order */
static int cmp_peer(struct List *i1, struct List *i2)
{
PgDatabase *db1 = container_of(i1, PgDatabase, head);
PgDatabase *db2 = container_of(i2, PgDatabase, head);
return db1->peer_id - db2->peer_id;
}
/* compare db names, for use with put_in_order */
static int cmp_database(struct List *i1, struct List *i2)
{
PgDatabase *db1 = container_of(i1, PgDatabase, head);
PgDatabase *db2 = container_of(i2, PgDatabase, head);
return strcmp(db1->name, db2->name);
}
/* put elem into list in correct pos */
static void put_in_order(struct List *newitem, struct StatList *list,
int (*cmpfn)(struct List *, struct List *))
{
int res;
struct List *item;
statlist_for_each(item, list) {
res = cmpfn(item, newitem);
if (res == 0) {
fatal("put_in_order: found existing elem");
} else if (res > 0) {
statlist_put_before(list, newitem, item);
return;
}
}
statlist_append(list, newitem);
}
/* create new object if new, then return it */
PgDatabase *add_peer(const char *name, int peer_id)
{
PgDatabase *peer = find_peer(peer_id);
/* create new object if needed */
if (peer == NULL) {
peer = slab_alloc(peer_cache);
if (!peer)
return NULL;
list_init(&peer->head);
peer->peer_id = peer_id;
put_in_order(&peer->head, &peer_list, cmp_peer);
}
return peer;
}
/* create new object if new, then return it */
PgDatabase *add_database(const char *name)
{
PgDatabase *db = find_database(name);
/* create new object if needed */
if (db == NULL) {
db = slab_alloc(db_cache);
if (!db)
return NULL;
list_init(&db->head);
if (strlcpy(db->name, name, sizeof(db->name)) >= sizeof(db->name)) {
log_warning("too long db name: %s", name);
slab_free(db_cache, db);
return NULL;
}
aatree_init(&db->user_tree, credentials_node_cmp, credentials_node_release);
put_in_order(&db->head, &database_list, cmp_database);
}
return db;
}
/* register new auto database */
PgDatabase *register_auto_database(const char *name)
{
PgDatabase *db;
if (!cf_autodb_connstr)
return NULL;
if (!parse_database(NULL, name, cf_autodb_connstr))
return NULL;
db = find_database(name);
if (db) {
db->db_auto = true;
}
return db;
}
PgGlobalUser *update_global_user_passwd(PgGlobalUser *user, const char *passwd)
{
Assert(user);
passwd = passwd ? passwd : "";
safe_strcpy(user->credentials.passwd, passwd, sizeof(user->credentials.passwd));
user->credentials.dynamic_passwd = strlen(passwd) == 0;
return user;
}
static PgGlobalUser *add_new_global_user(const char *name, const char *passwd)
{
PgGlobalUser *user = slab_alloc(user_cache);
if (!user)
return NULL;
user->credentials.global_user = user;
list_init(&user->head);
list_init(&user->pool_list);
safe_strcpy(user->credentials.name, name, sizeof(user->credentials.name));
put_in_order(&user->head, &user_list, cmp_user);
aatree_insert(&user_tree, (uintptr_t)user->credentials.name, &user->credentials.tree_node);
user->pool_mode = POOL_INHERIT;
user->pool_size = -1;
user->res_pool_size = -1;
return update_global_user_passwd(user, passwd);
}
/*
* Add dynamic credentials to this database. This should be used for dynamic
* credentials, that were retrieved using the auth_query.
*/
PgCredentials *add_dynamic_credentials(PgDatabase *db, const char *name, const char *passwd)
{
PgCredentials *credentials = NULL;
struct AANode *node;
/*
* Dynamic credentials are stored in an aatree that's specific to the
* database. So we cannot use find_global_user() here.
*/
node = aatree_search(&db->user_tree, (uintptr_t)name);
credentials = node ? container_of(node, PgCredentials, tree_node) : NULL;
if (credentials == NULL) {
credentials = slab_alloc(credentials_cache);
if (!credentials)
return NULL;
safe_strcpy(credentials->name, name, sizeof(credentials->name));
credentials->global_user = find_or_add_new_global_user(name, NULL);
if (!credentials->global_user) {
slab_free(credentials_cache, credentials);
return NULL;
}
aatree_insert(&db->user_tree, (uintptr_t)credentials->name, &credentials->tree_node);
}
safe_strcpy(credentials->passwd, passwd, sizeof(credentials->passwd));
credentials->dynamic_passwd = true;
return credentials;
}
/* Add PAM user. The logic is same as in add_dynamic_credentials */
PgCredentials *add_pam_credentials(const char *name, const char *passwd)
{
PgCredentials *credentials = NULL;
struct AANode *node;
node = aatree_search(&pam_user_tree, (uintptr_t)name);
credentials = node ? container_of(node, PgCredentials, tree_node) : NULL;
if (credentials == NULL) {
credentials = slab_alloc(credentials_cache);
if (!credentials)
return NULL;
safe_strcpy(credentials->name, name, sizeof(credentials->name));
credentials->global_user = find_or_add_new_global_user(name, NULL);
if (!credentials->global_user) {
slab_free(credentials_cache, credentials);
return NULL;
}
aatree_insert(&pam_user_tree, (uintptr_t)credentials->name, &credentials->tree_node);
}
if (passwd)
safe_strcpy(credentials->passwd, passwd, sizeof(credentials->passwd));
return credentials;
}
/* create separate PgCredentials object for this database */
PgCredentials *force_user_credentials(PgDatabase *db, const char *name, const char *passwd)
{
PgCredentials *credentials = db->forced_user_credentials;
if (!credentials) {
credentials = slab_alloc(credentials_cache);
if (!credentials)
return NULL;
credentials->global_user = find_or_add_new_global_user(name, NULL);
if (!credentials->global_user) {
slab_free(credentials_cache, credentials);
return NULL;
}
}
safe_strcpy(credentials->name, name, sizeof(credentials->name));
safe_strcpy(credentials->passwd, passwd, sizeof(credentials->passwd));
db->forced_user_credentials = credentials;
return credentials;
}
/* find an existing database */
PgDatabase *find_peer(int peer_id)
{
struct List *item;
PgDatabase *peer;
statlist_for_each(item, &peer_list) {
peer = container_of(item, PgDatabase, head);
if (peer->peer_id == peer_id)
return peer;
}
return NULL;
}
/* find an existing database */
PgDatabase *find_database(const char *name)
{
struct List *item, *tmp;
PgDatabase *db;
statlist_for_each(item, &database_list) {
db = container_of(item, PgDatabase, head);
if (strcmp(db->name, name) == 0)
return db;
}
/* also trying to find in idle autodatabases list */
statlist_for_each_safe(item, &autodatabase_idle_list, tmp) {
db = container_of(item, PgDatabase, head);
if (strcmp(db->name, name) == 0) {
db->inactive_time = 0;
statlist_remove(&autodatabase_idle_list, &db->head);
put_in_order(&db->head, &database_list, cmp_database);
return db;
}
}
return NULL;
}
/*
* Similar to find_database. In case database is not found, it will try to register
* it if auto-database ('*') is configured.
*/
PgDatabase *find_or_register_database(PgSocket *connection, const char *name)
{
PgDatabase *db = find_database(name);
if (db == NULL) {
db = register_auto_database(name);
if (db != NULL) {
slog_info(connection,
"registered new auto-database: %s", name);
}
}
return db;
}
/* find existing user */
PgGlobalUser *find_global_user(const char *name)
{
PgGlobalUser *user = NULL;
struct AANode *node;
node = aatree_search(&user_tree, (uintptr_t)name);
/* we use the tree_node in the embedded PgCredentials struct */
user = node ? (PgGlobalUser *) container_of(node, PgCredentials, tree_node) : NULL;
return user;
}
PgCredentials *find_global_credentials(const char *name)
{
PgGlobalUser *user = find_global_user(name);
if (!user)
return NULL;
return &user->credentials;
}
/* create new pool object */
static PgPool *new_pool(PgDatabase *db, PgCredentials *user_credentials)
{
PgPool *pool;
pool = slab_alloc(pool_cache);
if (!pool)
return NULL;
list_init(&pool->head);
list_init(&pool->map_head);
pool->orig_vars.var_list = slab_alloc(var_list_cache);
pool->user_credentials = user_credentials;
pool->db = db;
statlist_init(&pool->active_client_list, "active_client_list");
statlist_init(&pool->waiting_client_list, "waiting_client_list");
statlist_init(&pool->active_server_list, "active_server_list");
statlist_init(&pool->idle_server_list, "idle_server_list");
statlist_init(&pool->tested_server_list, "tested_server_list");
statlist_init(&pool->used_server_list, "used_server_list");
statlist_init(&pool->new_server_list, "new_server_list");
statlist_init(&pool->waiting_cancel_req_list, "waiting_cancel_req_list");
statlist_init(&pool->active_cancel_req_list, "active_cancel_req_list");
statlist_init(&pool->active_cancel_server_list, "active_cancel_server_list");
statlist_init(&pool->being_canceled_server_list, "being_canceled_server_list");
list_append(&user_credentials->global_user->pool_list, &pool->map_head);
/* keep pools in db/user order to make stats faster */
put_in_order(&pool->head, &pool_list, cmp_pool);
return pool;
}
/*
* create new peer pool object
*
* This pool should only be used to forward cancellations to other pgbouncers
* behind the same load balancer. The user field of this pool is NULL, because
* cancellations don't need a user.
*/
static PgPool *new_peer_pool(PgDatabase *db)
{
PgPool *pool;
pool = slab_alloc(peer_pool_cache);
if (!pool)
return NULL;
list_init(&pool->head);
list_init(&pool->map_head);
pool->orig_vars.var_list = slab_alloc(var_list_cache);
pool->db = db;
statlist_init(&pool->new_server_list, "new_server_list");
statlist_init(&pool->waiting_cancel_req_list, "waiting_cancel_req_list");
statlist_init(&pool->active_cancel_req_list, "active_cancel_req_list");
statlist_init(&pool->active_cancel_server_list, "active_cancel_server_list");
/* keep pools in peer_id order to make stats faster */
put_in_order(&pool->head, &peer_pool_list, cmp_peer_pool);
return pool;
}
/* find pool object, create if needed */
PgPool *get_pool(PgDatabase *db, PgCredentials *user_credentials)
{
struct List *item;
PgPool *pool;
if (!db || !user_credentials)
return NULL;
list_for_each(item, &user_credentials->global_user->pool_list) {
pool = container_of(item, PgPool, map_head);
if (pool->db == db)
return pool;
}
return new_pool(db, user_credentials);
}
/* find pool object for the peer */
PgPool *get_peer_pool(PgDatabase *db)
{
if (!db)
return NULL;
if (!db->pool) {
db->pool = new_peer_pool(db);
}
return db->pool;
}
/* deactivate socket and put into wait queue */
static void pause_client(PgSocket *client)
{
Assert(client->state == CL_ACTIVE || client->state == CL_LOGIN);
slog_debug(client, "pause_client");
if (cf_shutdown == SHUTDOWN_WAIT_FOR_SERVERS) {
disconnect_client(client, true, "server shutting down");
return;
}
change_client_state(client, CL_WAITING);
if (!sbuf_pause(&client->sbuf))
disconnect_client(client, true, "pause failed");
}
/*
* Deactivate the client socket and put it into the cancel request wait queue.
* We're not expecting any data from the client anymore at this point at all.
* But some clients might send some anyway (specifically the Go client). Since
* we don't care about any of that extra data we just stop reading from the
* socket.
*/
static void pause_cancel_request(PgSocket *client)
{
Assert(client->state == CL_LOGIN);
slog_debug(client, "pause_cancel_request");
change_client_state(client, CL_WAITING_CANCEL);
if (!sbuf_pause(&client->sbuf))
disconnect_client(client, true, "pause cancel request failed");
}
/* wake client from wait */
void activate_client(PgSocket *client)
{
Assert(client->state == CL_WAITING || client->state == CL_WAITING_LOGIN);
Assert(client->wait_start > 0);
/* account for time client spent waiting for server */
client->pool->stats.wait_time += (get_cached_time() - client->wait_start);
slog_debug(client, "activate_client");
change_client_state(client, CL_ACTIVE);
sbuf_continue(&client->sbuf);
}
/*
* Don't let clients queue at all if there is no working server connection.
*
* It must still allow following cases:
* - empty pool on startup
* - idle pool where all servers are removed
*
* Current assumptions:
* - old server connections will be dropped by query_timeout
* - new server connections fail due to server_connect_timeout, or other failure
*
* So here we drop client if all server connections have been dropped
* and new ones fail.
*
* Return true if the client connection should be allowed, false if it
* should be rejected.
*/
bool check_fast_fail(PgSocket *client)
{
int cnt;
PgPool *pool = client->pool;
/* Could be mock authentication, proceed normally */
if (!pool)
return true;
/* If last login succeeded, client can go ahead. */
if (!pool->last_login_failed)
return true;
/* If there are servers available, client can go ahead. */
cnt = pool_server_count(pool) - statlist_count(&pool->new_server_list);
if (cnt)
return true;
/* Else we fail the client. */
disconnect_client(client, true, "server login has been failing, cached error: %s (server_login_retry)", pool->last_connect_failed_message);
/*
* Try to launch a new connection. (launch_new_connection()
* will check for server_login_retry etc.) The usual relaunch
* from janitor.c won't do anything, as there are no waiting
* clients, so we need to do it here to get any new servers
* eventually.
*/
launch_new_connection(pool, /* evict_if_needed= */ true);
return false;
}
/* link if found, otherwise put into wait queue */
bool find_server(PgSocket *client)
{
PgPool *pool = client->pool;
PgSocket *server;
bool res;
bool varchange = false;
Assert(client->state == CL_ACTIVE || client->state == CL_LOGIN);
/* no wait by default */
client->wait_start = 0;
if (client->link)
return true;
slog_noise(client, "find_server: client had no linked server yet");
/* try to get idle server, if allowed */
if (cf_pause_mode == P_PAUSE || pool->db->db_paused) {
server = NULL;
} else if (client->replication && !sending_auth_query(client)) {
/*
* For replication clients we open dedicated server connections. These
* connections are linked to a client as soon as the server is ready,
* instead of lazily being assigned to a client only when the client
* sends a query. So if we reach this point we know that that has not
* happened yet, and we need to create a new replication connection for
* this client.
*/
launch_new_connection(pool, /*evict_if_needed= */ true);
server = NULL;
} else {
while (1) {
server = first_socket(&pool->idle_server_list);
if (!server) {
break;
} else if (server->close_needed) {
disconnect_server(server, true, "obsolete connection");
} else if (!server->ready) {
disconnect_server(server, true, "idle server got dirty");
} else {
break;
}
}
if (!server && !check_fast_fail(client))
return false;
}
Assert(!server || server->state == SV_IDLE);
/* send var changes */
if (server) {
res = varcache_apply(server, client, &varchange);
if (!res) {
disconnect_server(server, true, "var change failed");
server = NULL;
}
}
/* link or send to waiters list */
if (server) {
slog_noise(client, "linking client to S-%p", server);
client->link = server;
server->link = client;
server->pool->stats.server_assignment_count++;
change_server_state(server, SV_ACTIVE);
if (varchange) {
server->setting_vars = true;
server->ready = false;
res = false; /* don't process client data yet */
slog_noise(client, "pausing client while applying vars");
if (!sbuf_pause(&client->sbuf))
disconnect_client(client, true, "pause failed");
} else {
res = true;
}
} else {
pause_client(client);
res = false;
}
return res;
}
/* pick waiting client */
static bool reuse_on_release(PgSocket *server)
{
bool res = true;
PgPool *pool = server->pool;
PgSocket *client;
Assert(!server->replication);
slog_debug(server, "reuse_on_release: replication %d", server->replication);
client = first_socket(&pool->waiting_client_list);
if (client && (!client->replication || sending_auth_query(client))) {
activate_client(client);
/*
* As the activate_client() does full read loop,
* then it may happen that linked client closing
* causes server closing. Report it.
*/
if (server->state == SV_FREE || server->state == SV_JUSTFREE)
res = false;
}
return res;
}
bool queue_fake_response(PgSocket *client, char request_type)
{
bool res = true;
PgSocket *server = client->link;
Assert(server);
if (request_type == PqMsg_Parse) {
slog_debug(client, "Queuing fake ParseComplete packet");
QUEUE_ParseComplete(res, server, client);
} else if (request_type == PqMsg_Close) {
slog_debug(client, "Queuing fake CloseComplete packet");
QUEUE_CloseComplete(res, server, client);
} else {
fatal("Unknown fake request type %c", request_type);
}
return res;
}
/* Find an existing global user or add a new global user */
PgGlobalUser *find_or_add_new_global_user(const char *name, const char *passwd)
{
PgGlobalUser *user = find_global_user(name);
if (!user)
user = add_new_global_user(name, passwd);
return user;
}
/* Find an existing global credentials or add a new global credentials */
PgCredentials *find_or_add_new_global_credentials(const char *name, const char *passwd)
{
PgGlobalUser *user = find_or_add_new_global_user(name, passwd);
if (!user)
return NULL;
return &user->credentials;
}
/*
* Adds a request to the outstanding requests queue, and schedule the given
* action (see comments on ResponseAction for details).
*
* returns false if the required allocations failed
*/
bool add_outstanding_request(PgSocket *client, char type, ResponseAction action)
{
OutstandingRequest *request = NULL;
PgSocket *server = client->link;
Assert(server);
if (action == RA_FAKE && statlist_empty(&server->outstanding_requests)) {
/*
* If there's no outstanding requests, we can send the response
* right away. And we're actually required to do that to make
* sure the client receives it, because we normally only send
* responses to fake requests right after we handle a response
* to a real request. So if none are outstanding, we won't send
* such a response.
*/
slog_noise(client, "add_outstanding_request: queueing fake response right away %c",
type);
return queue_fake_response(client, type);
}
request = slab_alloc(outstanding_request_cache);
if (request == NULL)
return false;
request->type = type;
request->action = action;
statlist_append(&server->outstanding_requests, &request->node);
slog_noise(client, "add_outstanding_request: added %c, still outstanding %d",
type, statlist_count(&client->link->outstanding_requests));
return true;
}
/*
* If the next outstanding request is of one of the given types, pop it off the
* queue. If it is of a different type, don't do anything.
*
* returns true if one of the given types was popped of off the queue.
*/
bool pop_outstanding_request(PgSocket *server, const char types[], bool *skip)
{
OutstandingRequest *request;
struct List *item = statlist_first(&server->outstanding_requests);
if (!item)
return false;
request = container_of(item, OutstandingRequest, node);
if (request->action == RA_FAKE) {
/*
* This is weird, normally we should have already processed all fake
* requests at the end of the previous packet.
*/
slog_warning(server, "pop_outstanding_request: unexpected fake request of type %c", request->type);
return false;
}
if (strchr(types, request->type) == NULL)
return false;
statlist_pop(&server->outstanding_requests);
if (skip)
*skip = request->action == RA_SKIP;
slog_noise(server, "pop_outstanding_request: popped %c, still outstanding %d, skip %d",
request->type, statlist_count(&server->outstanding_requests), request->action == RA_SKIP);
if (request->server_ps != NULL) {
free_server_prepared_statement(request->server_ps);
}
slab_free(outstanding_request_cache, request);
return true;
}
/*
* Clear all outstanding requests until we reach response of any of the message
* types in "types". Any Parse or Close statement requests that were still
* outstanding will be unregistered or re-registered from the server its cache.
*/
bool clear_outstanding_requests_until(PgSocket *server, const char types[])
{
struct List *item, *tmp;
statlist_for_each_safe(item, &server->outstanding_requests, tmp) {
OutstandingRequest *request = container_of(item, OutstandingRequest, node);
char type = request->type;
if (type == PqMsg_Parse && request->server_ps_query_id > 0) {
unregister_prepared_statement(server, request->server_ps_query_id);
slog_noise(server,
"failed prepared statement '" PREPARED_STMT_NAME_FORMAT "' removed from server cache, %d cached items",
request->server_ps_query_id,
HASH_COUNT(server->server_prepared_statements));
} else if (type == PqMsg_Close && request->server_ps != NULL) {
if (!add_prepared_statement(server, request->server_ps)) {
if (server->link)
disconnect_client(server->link, true, "out of memory");
disconnect_server(server, true, "out of memory");
return false;
}
slog_noise(server,
"prepared statement '%s' added back to server cache, %d cached items",
request->server_ps->ps->stmt_name,
HASH_COUNT(server->server_prepared_statements));
}
statlist_remove(&server->outstanding_requests, item);
slab_free(outstanding_request_cache, request);
if (strchr(types, type))
break;
}
slog_noise(server, "clear_outstanding_requests_until_sync: still outstanding %d", statlist_count(&server->outstanding_requests));
return true;
}
/* send reset query */
static bool reset_on_release(PgSocket *server)
{
bool res;
Assert(server->state == SV_TESTED);
slog_debug(server, "resetting: %s", cf_server_reset_query);
SEND_generic(res, server, PqMsg_Query, "s", cf_server_reset_query);
if (!res)
disconnect_server(server, false, "reset query failed");
return res;
}
bool life_over(PgSocket *server)
{
PgPool *pool = server->pool;
usec_t lifetime_kill_gap = 0;
usec_t now = get_cached_time();
usec_t age = now - server->connect_time;
usec_t last_kill = now - pool->last_lifetime_disconnect;
usec_t server_lifetime = pool_server_lifetime(pool);
if (age < server_lifetime)
return false;
/*
* Calculate the time that disconnects because of server_lifetime
* must be separated. This avoids the need to re-launch lot
* of connections together.
*/
if (pool_pool_size(pool) > 0)
lifetime_kill_gap = server_lifetime / pool_pool_size(pool);
if (last_kill >= lifetime_kill_gap)
return true;
return false;
}
/* connecting/active -> idle, unlink if needed */
bool release_server(PgSocket *server)
{
PgPool *pool = server->pool;
SocketState newstate = SV_IDLE;
struct List *cancel_item, *tmp;
Assert(server->ready);
/* remove from old list */
switch (server->state) {
case SV_BEING_CANCELED:
case SV_ACTIVE:
if (server->link) {
server->link->link = NULL;
server->link = NULL;
}
if (*cf_server_reset_query && (cf_server_reset_query_always ||
connection_pool_mode(server) == POOL_SESSION)) {
/* notify reset is required */
newstate = SV_TESTED;
} else if (cf_server_check_delay == 0 && *cf_server_check_query) {
/*
* deprecated: before reset_query, the check_delay = 0
* was used to get same effect. This if() can be removed
* after couple of releases.
*/
newstate = SV_USED;
}
case SV_USED:
case SV_TESTED:
break;
case SV_LOGIN:
pool->last_login_failed = false;
pool->last_connect_failed = false;
break;
default:
fatal("bad server state: %d", server->state);
}
statlist_for_each_safe(cancel_item, &server->canceling_clients, tmp) {
PgSocket *cancel_client = container_of(cancel_item, PgSocket, cancel_head);
/*
* If the cancel request is not in flight yet we can simply unlink
* the cancel_client. When a cancel request doesn't have a
* canceled_server linked to it forward_cancel_request will simply drop
* the cancel request without forwarding it anywhere.
*/
if (cancel_client->state == CL_WAITING_CANCEL) {
cancel_client->canceled_server = NULL;
statlist_remove(&server->canceling_clients, cancel_item);
}
}
/* enforce lifetime immediately on release */
if (server->state != SV_LOGIN && life_over(server)) {
disconnect_server(server, true, "server lifetime over");
pool->last_lifetime_disconnect = get_cached_time();
return false;
}
if (statlist_count(&server->outstanding_requests) > 0) {
/*
* We can't release the server if there are outstanding requests
* that haven't been responded to yet, otherwise the server
* might get linked to another client and it will get those
* responses when it does not expect them. To be on the safe
* side we simply close this connection.
*/
disconnect_server(server, true, "client disconnected with queries in progress");
return true;
}
/* enforce close request */
if (server->close_needed) {
disconnect_server(server, true, "close_needed");
return false;
}
if (statlist_count(&server->canceling_clients) > 0) {
change_server_state(server, SV_BEING_CANCELED);
return true;
}
if (server->replication) {
if (server->link) {
slog_debug(server, "release_server: new replication connection ready");
change_server_state(server, SV_ACTIVE);
activate_client(server->link);
return true;
} else {
disconnect_server(server, true, "replication client was closed");
return false;
}
}
Assert(server->link == NULL);
slog_noise(server, "release_server: new state=%d", newstate);
change_server_state(server, newstate);
if (newstate == SV_IDLE) {
/* immediately process waiters, to give fair chance */
return reuse_on_release(server);
} else if (newstate == SV_TESTED) {
return reset_on_release(server);
}
return true;
}
static void unlink_server(PgSocket *server, const char *reason)
{
PgSocket *client;
if (!server->link)
return;
client = server->link;
client->link = NULL;
server->link = NULL;
/*
* Send reason to client if it is already
* logged in, otherwise send generic message.
*/
if (client->state == CL_ACTIVE || client->state == CL_WAITING)
disconnect_client(client, true, "%s", reason);
else if (client->state == CL_ACTIVE_CANCEL)
disconnect_client(client, false, "successfully sent cancel request");
else
disconnect_client(client, true, "bouncer config error");
}
/*
* close server connection
*
* send_term=true means to send a Terminate message to the server
* before disconnecting, send_term=false means to disconnect without.
* The latter is for protocol and communication errors where a normal
* protocol termination is not possible.
*/
void disconnect_server(PgSocket *server, bool send_term, const char *reason, ...)
{
usec_t now = get_cached_time();
char buf[128];
va_list ap;
struct List *cancel_item, *tmp;
if (server == NULL) {
return;
}
va_start(ap, reason);
vsnprintf(buf, sizeof(buf), reason, ap);
va_end(ap);
reason = buf;
if (cf_log_disconnections) {
slog_info(server, "closing because: %s (age=%" PRIu64 "s)", reason,
(now - server->connect_time) / USEC);
}
switch (server->state) {
case SV_ACTIVE_CANCEL:
case SV_ACTIVE:
unlink_server(server, reason);
break;
case SV_TESTED:
case SV_USED:
case SV_IDLE:
case SV_BEING_CANCELED:
break;
case SV_LOGIN:
/*
* usually disconnect means problems in startup phase,
* except when sending cancel packet
*/
if (!server->ready) {
server->pool->last_login_failed = true;
server->pool->last_connect_failed = true;
safe_strcpy(server->pool->last_connect_failed_message, reason, sizeof(server->pool->last_connect_failed_message));
} else
{
/*
* We did manage to connect and used the connection for query
* cancellation, so to the best of our knowledge we can connect to
* the server, reset last_connect_failed accordingly.
*/
server->pool->last_connect_failed = false;
send_term = false;
}
if (server->replication)
unlink_server(server, reason);
break;
default:
fatal("bad server state: %d", server->state);
}
Assert(server->link == NULL);
statlist_for_each_safe(cancel_item, &server->canceling_clients, tmp) {
PgSocket *cancel_client = container_of(cancel_item, PgSocket, cancel_head);
cancel_client->canceled_server = NULL;
statlist_remove(&server->canceling_clients, cancel_item);
}
/* notify server and close connection */
if (send_term) {
static const uint8_t pkt_term[] = {PqMsg_Terminate, 0, 0, 0, 4};
bool _ignore = sbuf_answer(&server->sbuf, pkt_term, sizeof(pkt_term));
(void) _ignore;
}
if (server->dns_token) {
adns_cancel(adns, server->dns_token);
server->dns_token = NULL;
}
free_scram_state(&server->scram_state);
server->pool->db->connection_count--;
if (server->pool->user_credentials)
server->pool->user_credentials->global_user->connection_count--;
change_server_state(server, SV_JUSTFREE);
if (!sbuf_close(&server->sbuf))
log_noise("sbuf_close failed, retry later");
}
/*
* A wrapper around disconnect_client_sqlstate()
*
* The function disconnect_client_sqlstate() inherits the disconnect_client()
* content and add a new option that provides a specific SQLSTATE that is
* forwarded to client. PgBouncer used to report SQLSTATE 08P01
* (protocol_violation) for all cases but it diverges from what Postgres
* reports in some cases.
*/
void disconnect_client(PgSocket *client, bool notify, const char *reason, ...)
{
if (reason) {
char buf[128];
va_list ap;
va_start(ap, reason);
vsnprintf(buf, sizeof(buf), reason, ap);
va_end(ap);
disconnect_client_sqlstate(client, notify, NULL, buf);
} else {
disconnect_client_sqlstate(client, notify, NULL, reason);
}
}
/*
* close client connection
*
* notify=true means to send the reason message as an error to the
* client, notify=false means no message is sent. The latter is for
* protocol and communication errors where sending a regular error
* message is not possible.
*/
void disconnect_client_sqlstate(PgSocket *client, bool notify, const char *sqlstate, const char *reason)
{
usec_t now = get_cached_time();
if (client->db && client->contributes_db_client_count)
client->db->client_connection_count--;
if (client->login_user_credentials) {
if (client->login_user_credentials->global_user && client->user_connection_counted) {
client->login_user_credentials->global_user->client_connection_count--;
}
}
if (cf_log_disconnections && reason) {
slog_info(client, "closing because: %s (age=%" PRIu64 "s)", reason,
(now - client->connect_time) / USEC);
}
switch (client->state) {
case CL_ACTIVE:
case CL_LOGIN:
if (client->link) {
PgSocket *server = client->link;
if (!server->ready) {
server->link = NULL;
client->link = NULL;
/*
* This can happen if the client
* connection is normally closed while
* the server has a transaction block
* open. Then there is no way for us
* to reset the server other than by
* closing it. Perhaps it would be
* worth tracking this separately to
* make the error message more
* precise and less scary.
*/
disconnect_server(server, true, "client disconnect while server was not ready");
} else if (statlist_count(&server->outstanding_requests) > 0) {
server->link = NULL;
client->link = NULL;
/*
* If there are outstanding requests we can't
* release the server, because the responses
* might be received by a different client. So
* we need to close the client connection
* immediately.
*/
disconnect_server(server, true, "client disconnected with query in progress");
} else if (!sbuf_is_empty(&server->sbuf)) {
/* ->ready may be set before all is sent */
server->link = NULL;
client->link = NULL;
disconnect_server(server, true, "client disconnect before everything was sent to the server");
} else {
/* retval does not matter here */
release_server(server);
}
}
break;
case CL_ACTIVE_CANCEL:
case CL_WAITING_CANCEL:
/*
* During normal operation, cancel clients get closed because their
* linked server finished sending the cancel request. But this is not
* always the case. It's possible for the client to disconnect
* itself. To avoid a reference to freed client object from the linked
* server in such cases, we now unlink any still linked server.
*/
if (client->link) {
PgSocket *server = client->link;
server->link = NULL;
client->link = NULL;
disconnect_server(server, false, "client gave up on cancel request, so we also give up forwarding to server");
}
/*
* If the cancel request is still linked to the server that it
* cancelled (or wanted to cancel) a query from, this is the time to
* unlink them. The cancel request has finished at this point and we're
* going to free its memory soon, so we don't want references to it
* left behind.
*/
if (client->canceled_server) {
PgSocket *canceled_server = client->canceled_server;
statlist_remove(&canceled_server->canceling_clients, &client->cancel_head);
client->canceled_server = NULL;
/*
* If the linked server was waiting until all cancel requests
* targeting it were finished, and we were the last cancel request,
* then we can now safely move the server to the idle state. We
* trigger this by calling release_server again.
*/
if (canceled_server->state == SV_BEING_CANCELED
&& statlist_count(&canceled_server->canceling_clients) == 0) {
release_server(canceled_server);
}
}
break;
case CL_WAITING:
case CL_WAITING_LOGIN:
/*
* replication connections might already be linked to a server
* while they are still in a waiting state.
*/
if (client->replication && client->link) {
PgSocket *server = client->link;
server->link = NULL;
client->link = NULL;
disconnect_server(server, false, "replication client disconnected");
}
break;
default:
fatal("bad client state: %d", client->state);
}
/* send reason to client */
if (notify && reason && client->state != CL_WAITING_CANCEL) {
/*
* don't send Ready pkt here, or client won't notice
* closed connection
*/
send_pooler_error(client, false, sqlstate, true, reason);
}
free_header(&client->packet_cb_state.pkt);
free_scram_state(&client->scram_state);
if (client->login_user_credentials && client->login_user_credentials->mock_auth) {
free(client->login_user_credentials);
client->login_user_credentials = NULL;
}
if (client->db && client->db->fake) {
free(client->db);
client->db = NULL;
}
free(client->startup_options);
client->startup_options = NULL;
change_client_state(client, CL_JUSTFREE);
if (!sbuf_close(&client->sbuf))
log_noise("sbuf_close failed, retry later");
}
/*
* Connection creation utilities
*/
static void connect_server(struct PgSocket *server, const struct sockaddr *sa, int salen)
{
bool res;
/* fill remote_addr */
memset(&server->remote_addr, 0, sizeof(server->remote_addr));
if (sa->sa_family == AF_UNIX) {
pga_set(&server->remote_addr, AF_UNIX, server->pool->db->port);
} else {
pga_copy(&server->remote_addr, sa);
}
slog_debug(server, "launching new connection to server");
/* start connecting */
res = sbuf_connect(&server->sbuf, sa, salen,
cf_server_connect_timeout / USEC);
if (!res)
log_noise("failed to launch new connection");
}
static void dns_callback(void *arg, const struct sockaddr *sa, int salen)
{
struct PgSocket *server = arg;
struct PgDatabase *db = server->pool->db;
struct sockaddr_in sa_in;
struct sockaddr_in6 sa_in6;
server->dns_token = NULL;
if (!sa) {
disconnect_server(server, true, "server DNS lookup failed");
return;
} else if (sa->sa_family == AF_INET) {
char buf[64];
memcpy(&sa_in, sa, sizeof(sa_in));
sa_in.sin_port = htons(db->port);
sa = (struct sockaddr *)&sa_in;
salen = sizeof(sa_in);
slog_debug(server, "dns_callback: inet4: %s",
sa2str(sa, buf, sizeof(buf)));
} else if (sa->sa_family == AF_INET6) {
char buf[64];
memcpy(&sa_in6, sa, sizeof(sa_in6));
sa_in6.sin6_port = htons(db->port);
sa = (struct sockaddr *)&sa_in6;
salen = sizeof(sa_in6);
slog_debug(server, "dns_callback: inet6: %s",
sa2str(sa, buf, sizeof(buf)));
} else {
disconnect_server(server, true, "unknown address family: %d", sa->sa_family);
return;
}
connect_server(server, sa, salen);
}
static void dns_connect(struct PgSocket *server)
{
struct sockaddr_un sa_un;
struct sockaddr_in sa_in;
struct sockaddr_in6 sa_in6;
struct sockaddr *sa;
struct PgDatabase *db = server->pool->db;
const char *host;
int sa_len;
int res;
char *host_copy = NULL;
/* host list? */
if (db->host && strchr(db->host, ',')) {
int count = 1;
int n;
if (server->pool->db->load_balance_hosts == LOAD_BALANCE_HOSTS_DISABLE && server->pool->last_connect_failed)
server->pool->rrcounter++;
for (const char *p = db->host; *p; p++)
if (*p == ',')
count++;
host_copy = xstrdup(db->host);
for (host = strtok(host_copy, ","), n = 0; host; host = strtok(NULL, ","), n++)
if (server->pool->rrcounter % count == n)
break;
Assert(host);
if (server->pool->db->load_balance_hosts == LOAD_BALANCE_HOSTS_ROUND_ROBIN)
server->pool->rrcounter++;
} else {
host = db->host;
}
if (!host || host[0] == '/' || host[0] == '@') {
const char *unix_dir;
memset(&sa_un, 0, sizeof(sa_un));
sa_un.sun_family = AF_UNIX;
unix_dir = host ? host : cf_unix_socket_dir;
if (!unix_dir || !*unix_dir) {
log_error("unix socket dir not configured: %s", db->name);
disconnect_server(server, false, "cannot connect");
goto cleanup;
}
snprintf(sa_un.sun_path, sizeof(sa_un.sun_path),
"%s/.s.PGSQL.%d", unix_dir, db->port);
slog_noise(server, "unix socket: %s", sa_un.sun_path);
if (unix_dir[0] == '@') {
/*
* By convention, for abstract Unix sockets,
* only the length of the string is the
* sockaddr length.
*/
sa_len = offsetof(struct sockaddr_un, sun_path) + strlen(sa_un.sun_path);
sa_un.sun_path[0] = '\0';
} else {
sa_len = sizeof(sa_un);
}
sa = (struct sockaddr *)&sa_un;
res = 1;
} else if (strchr(host, ':')) { /* assume IPv6 address on any : in addr */
slog_noise(server, "inet6 socket: %s", host);
memset(&sa_in6, 0, sizeof(sa_in6));
sa_in6.sin6_family = AF_INET6;
res = inet_pton(AF_INET6, host, &sa_in6.sin6_addr);
sa_in6.sin6_port = htons(db->port);
sa = (struct sockaddr *)&sa_in6;
sa_len = sizeof(sa_in6);
} else {/* else try IPv4 */
slog_noise(server, "inet socket: %s", host);
memset(&sa_in, 0, sizeof(sa_in));
sa_in.sin_family = AF_INET;
res = inet_pton(AF_INET, host, &sa_in.sin_addr);
sa_in.sin_port = htons(db->port);
sa = (struct sockaddr *)&sa_in;
sa_len = sizeof(sa_in);
}
/* if simple parse failed, use DNS */
if (res != 1) {
struct DNSToken *tk;
slog_noise(server, "dns socket: %s", host);
/* launch dns lookup */
tk = adns_resolve(adns, host, dns_callback, server);
if (tk)
server->dns_token = tk;
goto cleanup;
}
connect_server(server, sa, sa_len);
cleanup:
free(host_copy);
}
PgSocket *compare_connections_by_time(PgSocket *lhs, PgSocket *rhs)
{
if (!lhs)
return rhs;
if (!rhs)
return lhs;
return lhs->request_time < rhs->request_time ? lhs : rhs;
}
/* evict the single most idle connection from among all pools to make room in the db */
bool evict_connection(PgDatabase *db)
{
struct List *item;
PgPool *pool;
PgSocket *oldest_connection = NULL;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db != db)
continue;
oldest_connection = compare_connections_by_time(oldest_connection, last_socket(&pool->idle_server_list));
/* only evict testing connections if nobody's waiting */
if (statlist_empty(&pool->waiting_client_list)) {
oldest_connection = compare_connections_by_time(oldest_connection, last_socket(&pool->used_server_list));
oldest_connection = compare_connections_by_time(oldest_connection, last_socket(&pool->tested_server_list));
}
}
if (oldest_connection) {
disconnect_server(oldest_connection, true, "evicted");
return true;
}
return false;
}
/* evict the oldest idle connection from the pool */
bool evict_pool_connection(PgPool *pool)
{
PgSocket *oldest_connection = NULL;
oldest_connection = compare_connections_by_time(oldest_connection, last_socket(&pool->idle_server_list));
if (oldest_connection) {
disconnect_server(oldest_connection, true, "evicted");
return true;
}
return false;
}
/* evict the single most idle connection from among all pools to make room in the user */
bool evict_user_connection(PgCredentials *user_credentials)
{
struct List *item;
PgPool *pool;
PgSocket *oldest_connection = NULL;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->user_credentials != user_credentials)
continue;
oldest_connection = compare_connections_by_time(oldest_connection, last_socket(&pool->idle_server_list));
/* only evict testing connections if nobody's waiting */
if (statlist_empty(&pool->waiting_client_list)) {
oldest_connection = compare_connections_by_time(oldest_connection, last_socket(&pool->used_server_list));
oldest_connection = compare_connections_by_time(oldest_connection, last_socket(&pool->tested_server_list));
}
}
if (oldest_connection) {
disconnect_server(oldest_connection, true, "evicted");
return true;
}
return false;
}
/*
* Launches a new connection if possible.
*
* Called when the pool needs new connection.
*
* If `evict_if_needed` is true and the db or user has reached their
* connection limits, this method will attempt to evict existing connections
* from other users/dbs to make room for the new connection.
*/
void launch_new_connection(PgPool *pool, bool evict_if_needed)
{
PgSocket *server;
int max;
log_debug("launch_new_connection: start");
/*
* Allow only a single connection attempt at a time.
*
* NOTE: If this is ever changed to allow more than a single connection
* attempt at once (which would probably be a good thing), some code needs
* to change that depends on the fact that there's only ever one connection
* attempt at once. At least a little bit below in this function, where
* connections are opened for cancel requests.
*/
if (!statlist_empty(&pool->new_server_list)) {
log_debug("launch_new_connection: already progress");
return;
}
/* if server bounces, don't retry too fast */
if (pool->last_connect_failed) {
usec_t now = get_cached_time();
if (now - pool->last_connect_time < cf_server_login_retry) {
log_debug("launch_new_connection: last failed, not launching new connection yet, still waiting %" PRIu64 " s",
(cf_server_login_retry - (now - pool->last_connect_time)) / USEC);
return;
}
}
max = pool_server_count(pool);
/*
* Peer pools only have a single pool_size.
*/
if (pool->db->peer_id) {
if (max < pool_pool_size(pool))
goto force_new;
log_debug("launch_new_connection: peer pool full (%d >= %d)",
max, pool_pool_size(pool));
return;
}
/*
* When a cancel request is queued allow connections up to twice the pool
* size.
*
* NOTE: This logic might seem a bit confusing, because it seems like we'll
* open many connections even if there's only a single cancel request. But
* this works just fine, because we only ever open a single connection at
* once (see top of this function).
*/
if (!statlist_empty(&pool->waiting_cancel_req_list) && max < (2 * pool_pool_size(pool))) {
log_debug("launch_new_connection: bypass pool limitations for cancel request");
goto force_new;
}
/* is it allowed to add servers? */
if (pool_pool_size(pool) > 0) {
if (max >= pool_pool_size(pool) && pool->welcome_msg_ready) {
/* should we use reserve pool? */
PgSocket *c = first_socket(&pool->waiting_client_list);
if (cf_res_pool_timeout && pool_res_pool_size(pool)) {
usec_t now = get_cached_time();
if (c && (now - c->request_time) >= cf_res_pool_timeout) {
if (max < pool_pool_size(pool) + pool_res_pool_size(pool)) {
slog_warning(c, "taking connection from reserve_pool");
goto allow_new;
}
}
}
if (c && c->replication && !sending_auth_query(c)) {
while (evict_if_needed && pool_pool_size(pool) >= max) {
if (!evict_pool_connection(pool))
break;
}
if (pool_pool_size(pool) < max)
goto allow_new;
}
log_debug("launch_new_connection: pool full (%d >= %d)",
max, pool_pool_size(pool));
return;
}
}
allow_new:
max = database_max_connections(pool->db);
if (max > 0) {
/* try to evict unused connections first */
while (evict_if_needed && pool->db->connection_count >= max) {
if (!evict_connection(pool->db)) {
break;
}
}
if (pool->db->connection_count >= max) {
log_debug("launch_new_connection: database '%s' full (%d >= %d)",
pool->db->name, pool->db->connection_count, max);
return;
}
}
max = user_max_connections(pool->user_credentials->global_user);
if (max > 0) {
/* try to evict unused connection first */
while (evict_if_needed && pool->user_credentials->global_user->connection_count >= max) {
if (!evict_user_connection(pool->user_credentials)) {
break;
}
}
if (pool->user_credentials->global_user->connection_count >= max) {
log_debug("launch_new_connection: user '%s' full (%d >= %d)",
pool->user_credentials->name, pool->user_credentials->global_user->connection_count, max);
return;
}
}
force_new:
/* get free conn object */
server = slab_alloc(server_cache);
if (!server) {
log_debug("launch_new_connection: no memory");
return;
}
/* initialize it */
server->pool = pool;
server->login_user_credentials = server->pool->user_credentials;
server->connect_time = get_cached_time();
statlist_init(&server->canceling_clients, "canceling_clients");
pool->last_connect_time = get_cached_time();
change_server_state(server, SV_LOGIN);
pool->db->connection_count++;
if (pool->user_credentials)
pool->user_credentials->global_user->connection_count++;
dns_connect(server);
}
/* new client connection attempt */
PgSocket *accept_client(int sock, bool is_unix)
{
bool res;
PgSocket *client;
/* get free PgSocket */
client = slab_alloc(client_cache);
if (!client) {
log_warning("cannot allocate client struct");
safe_close(sock);
return NULL;
}
client->connect_time = client->request_time = get_cached_time();
client->query_start = 0;
/* FIXME: take local and remote address from pool_accept() */
fill_remote_addr(client, sock, is_unix);
fill_local_addr(client, sock, is_unix);
change_client_state(client, CL_LOGIN);
res = sbuf_accept(&client->sbuf, sock, is_unix);
if (!res) {
if (cf_log_connections)
slog_debug(client, "failed connection attempt");
return NULL;
}
return client;
}
/* send cached parameters to client to pretend being server */
/* client managed to authenticate, send welcome msg and accept queries */
bool finish_client_login(PgSocket *client)
{
if (client->db->fake) {
if (cf_log_connections)
slog_info(client, "login failed: db=%s user=%s", client->db->name, client->login_user_credentials->name);
disconnect_client(client, true, "no such database: %s", client->db->name);
return false;
}
if (client->db->db_disabled) {
disconnect_client(client, true, "database \"%s\" is disabled", client->db->name);
return false;
}
switch (client->state) {
case CL_LOGIN:
change_client_state(client, CL_ACTIVE);
case CL_ACTIVE:
break;
default:
fatal("bad client state: %d", client->state);
}
client->wait_for_auth = false;
/* check if we know server signature */
if (!client->pool->welcome_msg_ready) {
log_debug("finish_client_login: no welcome message, pause");
client->wait_for_welcome = true;
pause_client(client);
if (cf_pause_mode == P_NONE)
launch_new_connection(client->pool, /* evict_if_needed= */ true);
return false;
}
client->wait_for_welcome = false;
/* send the message */
if (!welcome_client(client))
return false;
slog_debug(client, "logged in");
return true;
}
static void accept_cancel_request_for_peer(int peer_id, PgSocket *req)
{
PgDatabase *peer = NULL;
PgPool *pool = NULL;
int ttl = req->cancel_key[7] & CANCELLATION_TTL_MASK;
if (ttl == 0) {
disconnect_client(req, false, "failed to forward cancel request because its TTL was exhausted");
return;
}
/*
* Before forwarding the cancel key, we need to decrement the TTL. Now is
* as a good a time as any to do so. We simply subtract 1 from the last
* byte, since the TTL is stored in the least significant bits.
*/
req->cancel_key[7]--;
peer = find_peer(peer_id);
if (!peer) {
disconnect_client(req, false, "could not find peer to forward request to");
return;
}
log_debug("forwarding cancellation request to peer %d", peer_id);
/*
* When using peering (multiple pgbouncers behind the same load
* balancer), we may receive cancellation messages that were intended
* for another peer via the load balancer. We propagate the
* cancellation via the peer's pool, instead of the server pool.
*/
pool = get_peer_pool(peer);
if (!pool) {
disconnect_client(req, false, "out of memory");
return;
}
/*
* Attach to the target pool and change state to waiting_cancel. This way
* once a new connection is opened, it's used to forward the cancel
* request.
*/
req->pool = pool;
pause_cancel_request(req);
/*
* Open a new connection over which the cancel request is forwarded to the
* server.
*/
launch_new_connection(pool, /* evict_if_needed= */ true);
}
/*
* Accepts a cancellation request, which will eventual cancel the query running
* on the client that matches req->client_key
*/
void accept_cancel_request(PgSocket *req)
{
struct List *pitem, *citem;
PgPool *pool = NULL;
PgSocket *server = NULL, *client, *main_client = NULL;
bool peering_enabled = false;
Assert(req->state == CL_LOGIN);
/*
* PgBouncer peering
*/
peering_enabled = cf_peer_id > 0;
if (peering_enabled) {
/*
* Extract the peer id from the cancel key. The peer id is
* stored in the 2nd and 3rd byte.
*/
int peer_id = req->cancel_key[1] + (req->cancel_key[2] << 8);
bool needs_forwarding_to_peer = cf_peer_id != peer_id;
if (needs_forwarding_to_peer) {
accept_cancel_request_for_peer(peer_id, req);
return;
}
/*
* Set the last two bits of the cancel key to 1. This is necessary to
* compare the key from the request to our stored cancel keys, because
* the stored cancel keys always have these TTL bits set to 1.
*/
req->cancel_key[7] |= CANCELLATION_TTL_MASK;
}
/* find the client that has the same cancel_key as this request */
statlist_for_each(pitem, &pool_list) {
pool = container_of(pitem, PgPool, head);
statlist_for_each(citem, &pool->active_client_list) {
client = container_of(citem, PgSocket, head);
if (memcmp(client->cancel_key, req->cancel_key, 8) == 0) {
main_client = client;
goto found;
}
}
statlist_for_each(citem, &pool->waiting_client_list) {
client = container_of(citem, PgSocket, head);
if (memcmp(client->cancel_key, req->cancel_key, 8) == 0) {
main_client = client;
goto found;
}
}
}
found:
/* wrong key */
if (!main_client) {
disconnect_client(req, false, "failed cancel request");
return;
}
/*
* cancel requests for administrative databases should be handled
* differently from cancel request for normal servers. We should handle
* these directly instead of forwarding them.
*/
if (main_client->pool->db->admin) {
disconnect_client(req, false, "cancel request for console client");
admin_handle_cancel(main_client);
return;
}
/*
* The client is not linked to a server, which means that no query is
* running that can be cancelled. This likely means the query finished by
* itself before the cancel request arived to pgbouncer.
*/
if (!main_client->link) {
disconnect_client(req, false, "cancel request for idle client");
return;
}
server = main_client->link;
if (server->setting_vars) {
disconnect_client(req, false, "ignoring cancel request for server that is setting vars");
return;
}
/*
* Link the cancel request and the server on which the query is being
* cancelled in a many-to-one way.
*/
req->canceled_server = server;
statlist_append(&server->canceling_clients, &req->cancel_head);
/*
* Attach to the target pool and change state to waiting_cancel. This way
* once a new connection is opened, it's used to forward the cancel
* request.
*/
req->pool = pool;
pause_cancel_request(req);
/*
* Open a new connection over which the cancel request is forwarded to the
* server.
*/
launch_new_connection(pool, /* evict_if_needed= */ true);
}
bool forward_cancel_request(PgSocket *server)
{
bool res;
PgSocket *req = first_socket(&server->pool->waiting_cancel_req_list);
bool forwarding_to_peer = server->pool->db->peer_id != 0;
Assert(req != NULL && req->state == CL_WAITING_CANCEL);
Assert(server->state == SV_LOGIN);
if (!forwarding_to_peer) {
/*
* In between accepting the cancel request and receiving an open connection
* the query that was supposed to be cancelled has now completed. This
* becomes a problem when the server is then reused for some other client.
* Because this will mean that the cancel that is forwarded will cancel a
* query from a completely different client than the client it was intended
* for.
*/
if (!req->canceled_server) {
disconnect_client(req, false, "not sending cancel request for client that is now idle");
return false;
}
}
server->link = req;
req->link = server;
if (forwarding_to_peer) {
SEND_CancelRequest(res, server, req->cancel_key);
} else {
SEND_CancelRequest(res, server, req->canceled_server->cancel_key);
}
if (!res) {
slog_warning(req, "sending cancel request failed: %s", strerror(errno));
disconnect_client(req, false, "failed to send cancel request");
return false;
}
slog_debug(req, "started sending cancel request");
change_client_state(req, CL_ACTIVE_CANCEL);
return true;
}
bool use_client_socket(int fd, PgAddr *addr,
const char *dbname, const char *username,
uint64_t ckey, int oldfd, int linkfd,
const char *client_enc, const char *std_string,
const char *datestyle, const char *timezone,
const char *password,
const char *scram_client_key, int scram_client_key_len,
const char *scram_server_key, int scram_server_key_len)
{
PgDatabase *db = find_database(dbname);
PgSocket *client;
PktBuf tmp;
/* if the database not found, it's an auto database -> registering... */
if (!db) {
db = register_auto_database(dbname);
if (!db)
return true;
}
if (scram_client_key || scram_server_key) {
PgCredentials *credentials;
if (!scram_client_key || !scram_server_key) {
log_error("incomplete SCRAM key data");
return false;
}
if (sizeof(credentials->scram_ClientKey) != scram_client_key_len
|| sizeof(credentials->scram_ServerKey) != scram_server_key_len) {
log_error("incompatible SCRAM key data");
return false;
}
if (db->forced_user_credentials) {
log_error("SCRAM key data received for forced user");
return false;
}
if (cf_auth_type == AUTH_TYPE_PAM) {
log_error("SCRAM key data received for PAM user");
return false;
}
credentials = find_global_credentials(username);
if (!credentials && db->auth_user_credentials)
credentials = add_dynamic_credentials(db, username, password);
if (!credentials)
return false;
memcpy(credentials->scram_ClientKey, scram_client_key, sizeof(credentials->scram_ClientKey));
memcpy(credentials->scram_ServerKey, scram_server_key, sizeof(credentials->scram_ServerKey));
credentials->has_scram_keys = true;
}
client = accept_client(fd, pga_is_unix(addr));
if (client == NULL)
return false;
client->suspended = true;
if (!set_pool(client, dbname, username, password, true))
return false;
change_client_state(client, CL_ACTIVE);
/* store old cancel key */
pktbuf_static(&tmp, client->cancel_key, 8);
pktbuf_put_uint64(&tmp, ckey);
/* store old fds */
client->tmp_sk_oldfd = oldfd;
client->tmp_sk_linkfd = linkfd;
varcache_set(&client->vars, "client_encoding", client_enc);
varcache_set(&client->vars, "standard_conforming_strings", std_string);
varcache_set(&client->vars, "datestyle", datestyle);
varcache_set(&client->vars, "timezone", timezone);
return true;
}
bool use_server_socket(int fd, PgAddr *addr,
const char *dbname, const char *username,
uint64_t ckey, int oldfd, int linkfd,
const char *client_enc, const char *std_string,
const char *datestyle, const char *timezone,
const char *password,
const char *scram_client_key, int scram_client_key_len,
const char *scram_server_key, int scram_server_key_len)
{
PgDatabase *db = find_database(dbname);
PgCredentials *credentials;
PgPool *pool;
PgSocket *server;
PktBuf tmp;
bool res;
/* if the database not found, it's an auto database -> registering... */
if (!db) {
db = register_auto_database(dbname);
if (!db)
return true;
}
if (db->forced_user_credentials) {
credentials = db->forced_user_credentials;
} else if (cf_auth_type == AUTH_TYPE_PAM) {
credentials = add_pam_credentials(username, password);
} else {
credentials = find_global_credentials(username);
}
if (!credentials && db->auth_user_credentials)
credentials = add_dynamic_credentials(db, username, password);
pool = get_pool(db, credentials);
if (!pool)
return false;
server = slab_alloc(server_cache);
if (!server)
return false;
res = sbuf_accept(&server->sbuf, fd, pga_is_unix(addr));
if (!res)
return false;
db->connection_count++;
server->suspended = true;
server->pool = pool;
server->login_user_credentials = credentials;
server->connect_time = server->request_time = get_cached_time();
server->query_start = 0;
statlist_init(&server->canceling_clients, "canceling_clients");
fill_remote_addr(server, fd, pga_is_unix(addr));
fill_local_addr(server, fd, pga_is_unix(addr));
if (linkfd) {
server->ready = false;
change_server_state(server, SV_ACTIVE);
} else {
server->ready = true;
change_server_state(server, SV_IDLE);
}
/* store old cancel key */
pktbuf_static(&tmp, server->cancel_key, 8);
pktbuf_put_uint64(&tmp, ckey);
/* store old fds */
server->tmp_sk_oldfd = oldfd;
server->tmp_sk_linkfd = linkfd;
varcache_set(&server->vars, "client_encoding", client_enc);
varcache_set(&server->vars, "standard_conforming_strings", std_string);
varcache_set(&server->vars, "datestyle", datestyle);
varcache_set(&server->vars, "timezone", timezone);
return true;
}
void for_each_server(PgPool *pool, void (*func)(PgSocket *sk))
{
struct List *item;
statlist_for_each(item, &pool->idle_server_list) {
func(container_of(item, PgSocket, head));
}
statlist_for_each(item, &pool->used_server_list) {
func(container_of(item, PgSocket, head));
}
statlist_for_each(item, &pool->tested_server_list) {
func(container_of(item, PgSocket, head));
}
statlist_for_each(item, &pool->active_server_list) {
func(container_of(item, PgSocket, head));
}
statlist_for_each(item, &pool->new_server_list) {
func(container_of(item, PgSocket, head));
}
}
static void for_each_server_filtered(PgPool *pool, void (*func)(PgSocket *sk), bool (*filter)(PgSocket *sk, void *arg), void *filter_arg)
{
struct List *item;
PgSocket *sk;
statlist_for_each(item, &pool->idle_server_list) {
sk = container_of(item, PgSocket, head);
if (filter(sk, filter_arg))
func(sk);
}
statlist_for_each(item, &pool->used_server_list) {
sk = container_of(item, PgSocket, head);
if (filter(sk, filter_arg))
func(sk);
}
statlist_for_each(item, &pool->tested_server_list) {
sk = container_of(item, PgSocket, head);
if (filter(sk, filter_arg))
func(sk);
}
statlist_for_each(item, &pool->active_server_list) {
sk = container_of(item, PgSocket, head);
if (filter(sk, filter_arg))
func(sk);
}
statlist_for_each(item, &pool->new_server_list) {
sk = container_of(item, PgSocket, head);
if (filter(sk, filter_arg))
func(sk);
}
}
static void tag_dirty(PgSocket *sk)
{
sk->close_needed = true;
}
void tag_pool_dirty(PgPool *pool)
{
struct List *item, *tmp;
struct PgSocket *server;
/*
* Don't tag the admin pool as dirty, since this is not an actual postgres
* server. Marking it as dirty breaks connecting to the pgbouncer admin
* database on future connections.
*/
if (pool->db->admin)
return;
/* reset welcome msg */
if (pool->welcome_msg) {
pktbuf_free(pool->welcome_msg);
pool->welcome_msg = NULL;
}
pool->welcome_msg_ready = false;
/* drop all existing servers ASAP */
for_each_server(pool, tag_dirty);
/* drop servers login phase immediately */
statlist_for_each_safe(item, &pool->new_server_list, tmp) {
server = container_of(item, PgSocket, head);
disconnect_server(server, true, "connect string changed");
}
}
void tag_database_dirty(PgDatabase *db)
{
struct List *item;
PgPool *pool;
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db == db)
tag_pool_dirty(pool);
}
}
void tag_autodb_dirty(void)
{
struct List *item, *tmp;
PgDatabase *db;
PgPool *pool;
/*
* reload databases.
*/
statlist_for_each(item, &database_list) {
db = container_of(item, PgDatabase, head);
if (db->db_auto)
register_auto_database(db->name);
}
statlist_for_each_safe(item, &autodatabase_idle_list, tmp) {
db = container_of(item, PgDatabase, head);
if (db->db_auto)
register_auto_database(db->name);
}
/*
* reload pools
*/
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db->db_auto)
tag_pool_dirty(pool);
}
}
static bool server_remote_addr_filter(PgSocket *sk, void *arg)
{
PgAddr *addr = arg;
return (pga_cmp_addr(&sk->remote_addr, addr) == 0);
}
void tag_host_addr_dirty(const char *host, const struct sockaddr *sa)
{
struct List *item;
PgPool *pool;
PgAddr addr;
memset(&addr, 0, sizeof(addr));
pga_copy(&addr, sa);
statlist_for_each(item, &pool_list) {
pool = container_of(item, PgPool, head);
if (pool->db->host && strcmp(host, pool->db->host) == 0) {
for_each_server_filtered(pool, tag_dirty, server_remote_addr_filter, &addr);
}
}
}
/* move objects from justfree_* to free_* lists */
void reuse_just_freed_objects(void)
{
struct List *tmp, *item;
PgSocket *sk;
bool close_works = true;
/*
* event_del() may fail because of ENOMEM for event handlers
* that need only changes sent to kernel on each loop.
*
* Keep open sbufs in justfree lists until successful.
*/
statlist_for_each_safe(item, &justfree_client_list, tmp) {
sk = container_of(item, PgSocket, head);
if (sbuf_is_closed(&sk->sbuf)) {
change_client_state(sk, CL_FREE);
} else if (close_works) {
close_works = sbuf_close(&sk->sbuf);
}
}
statlist_for_each_safe(item, &justfree_server_list, tmp) {
sk = container_of(item, PgSocket, head);
if (sbuf_is_closed(&sk->sbuf)) {
change_server_state(sk, SV_FREE);
} else if (close_works) {
close_works = sbuf_close(&sk->sbuf);
}
}
}
void objects_cleanup(void)
{
struct List *item, *tmp;
PgDatabase *db;
/* close can be postpones, just in case call twice */
reuse_just_freed_objects();
reuse_just_freed_objects();
statlist_for_each_safe(item, &autodatabase_idle_list, tmp) {
db = container_of(item, PgDatabase, head);
kill_database(db);
}
statlist_for_each_safe(item, &database_list, tmp) {
db = container_of(item, PgDatabase, head);
kill_database(db);
}
statlist_for_each_safe(item, &peer_list, tmp) {
PgDatabase *peer = container_of(item, PgDatabase, head);
kill_peer(peer);
}
statlist_for_each_safe(item, &justfree_server_list, tmp) {
PgSocket *server = container_of(item, PgSocket, head);
server_free(server);
}
statlist_for_each_safe(item, &justfree_client_list, tmp) {
PgSocket *client = container_of(item, PgSocket, head);
client_free(client);
}
memset(&login_client_list, 0, sizeof login_client_list);
memset(&user_list, 0, sizeof user_list);
memset(&database_list, 0, sizeof database_list);
memset(&pool_list, 0, sizeof pool_list);
memset(&pam_user_tree, 0, sizeof pam_user_tree);
memset(&user_tree, 0, sizeof user_tree);
memset(&autodatabase_idle_list, 0, sizeof autodatabase_idle_list);
slab_destroy(server_cache);
server_cache = NULL;
slab_destroy(client_cache);
client_cache = NULL;
slab_destroy(db_cache);
db_cache = NULL;
slab_destroy(peer_cache);
peer_cache = NULL;
slab_destroy(peer_pool_cache);
peer_pool_cache = NULL;
slab_destroy(pool_cache);
pool_cache = NULL;
slab_destroy(user_cache);
user_cache = NULL;
slab_destroy(credentials_cache);
credentials_cache = NULL;
slab_destroy(iobuf_cache);
iobuf_cache = NULL;
slab_destroy(outstanding_request_cache);
outstanding_request_cache = NULL;
slab_destroy(var_list_cache);
var_list_cache = NULL;
slab_destroy(server_prepared_statement_cache);
server_prepared_statement_cache = NULL;
}
pgbouncer-1.24.1/src/loader.c 0000644 0001750 0000000 00000042410 14777762222 012711 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Config and auth file reading.
*/
#include "bouncer.h"
#include "usual/time.h"
#include
#include
/*
* ConnString parsing
*/
bool any_user_level_timeout_set;
bool any_user_level_client_timeout_set;
/* parse parameter name before '=' */
static char *cstr_get_key(char *p, char **dst_p)
{
char *end;
p = cstr_skip_ws(p);
*dst_p = p;
while (*p && *p != '=' && *p != ' ')
p++;
end = p;
p = cstr_skip_ws(p);
/* fail if no '=' or empty name */
if (*p != '=' || *dst_p == end)
return NULL;
*end = 0;
return p + 1;
}
/* unquote the quoted value after first quote */
static char *cstr_unquote_value(char *p)
{
char *s = p;
while (1) {
if (!*p)
return NULL;
if (p[0] == '\'') {
if (p[1] == '\'')
p++;
else
break;
}
*s++ = *p++;
}
/* terminate actual value */
*s = 0;
/* return position after quote */
return p + 1;
}
/* parse value, possibly quoted */
static char *cstr_get_value(char *p, char **dst_p)
{
p = cstr_skip_ws(p);
if (*p == '\'') {
*dst_p = ++p;
p = cstr_unquote_value(p);
if (!p)
return NULL;
} else {
*dst_p = p;
while (*p && *p != ' ')
p++;
}
if (*p) {
/* if not EOL, cut value */
*p = 0;
p++;
}
/* disallow empty values */
if (*dst_p[0] == 0)
return NULL;
return p;
}
/*
* Get key=val pair from connstring. Returns position it stopped
* or NULL on error. EOF is signaled by *key = 0.
*/
static char * cstr_get_pair(char *p,
char **key_p,
char **val_p)
{
p = cstr_skip_ws(p);
*key_p = *val_p = p;
if (*p == 0)
return p;
/* read key */
p = cstr_get_key(p, key_p);
if (!p)
return NULL;
/* read value */
p = cstr_get_value(p, val_p);
if (!p)
return NULL;
log_noise("cstr_get_pair: \"%s\"=\"%s\"", *key_p, *val_p);
return cstr_skip_ws(p);
}
/*
* Free the old value and set the new value
*/
static bool set_param_value(char **old_value, const char *new_value)
{
if (strcmpeq(*old_value, new_value))
return true;
if (*old_value)
free(*old_value);
if (new_value) {
*old_value = strdup(new_value);
if (!(*old_value)) {
log_error("out of memory");
return false;
}
} else {
*old_value = NULL;
}
return true;
}
static bool set_autodb(const char *connstr)
{
char *tmp = strdup(connstr);
char *old = cf_autodb_connstr;
if (!tmp) {
log_error("no mem to change autodb_connstr");
return false;
}
cf_autodb_connstr = tmp;
if (old) {
if (strcmp(connstr, old) != 0)
tag_autodb_dirty();
free(old);
}
return true;
}
/* fill PgDatabase from connstr */
bool parse_peer(void *base, const char *name, const char *connstr)
{
char *p, *key, *val;
PgDatabase *peer;
char *tmp_connstr;
char *host = NULL;
int port = 6432;
int pool_size = -1;
int peer_id = strtonum(name, 1, 0xFFFF, NULL);
if (peer_id == 0) {
log_error("ids of peers must be a number larger than 0 and at most 65536");
return false;
}
tmp_connstr = strdup(connstr);
if (!tmp_connstr) {
log_error("out of memory");
return false;
}
p = tmp_connstr;
while (*p) {
p = cstr_get_pair(p, &key, &val);
if (p == NULL) {
log_error("syntax error in connection string");
goto fail;
} else if (!key[0]) {
break;
}
if (strcmp("host", key) == 0) {
if (!set_param_value(&host, val))
goto fail;
} else if (strcmp("port", key) == 0) {
port = atoi(val);
if (port == 0) {
log_error("invalid port: %s", val);
goto fail;
}
} else if (strcmp("pool_size", key) == 0) {
pool_size = atoi(val);
} else {
log_error("unrecognized connection parameter: %s", key);
goto fail;
}
}
if (!host) {
log_error("host was not provided for peer %d", peer_id);
goto fail;
}
peer = add_peer(name, peer_id);
if (!peer) {
log_error("cannot create peer, no memory?");
goto fail;
}
/* tag the peer as alive */
peer->db_dead = false;
free(peer->host);
peer->host = host;
peer->port = port;
peer->pool_size = pool_size;
free(tmp_connstr);
return true;
fail:
free(tmp_connstr);
free(host);
return false;
}
/* fill PgDatabase from connstr */
bool parse_database(void *base, const char *name, const char *connstr)
{
char *p, *key, *val;
PktBuf *msg;
PgDatabase *db;
struct CfValue cv;
struct CfValue load_balance_hosts_lookup;
int pool_size = -1;
int min_pool_size = -1;
int res_pool_size = -1;
int max_db_client_connections = -1;
int max_db_connections = -1;
usec_t server_lifetime = 0;
int dbname_ofs;
int pool_mode = POOL_INHERIT;
enum LoadBalanceHosts load_balance_hosts = LOAD_BALANCE_HOSTS_ROUND_ROBIN;
char *tmp_connstr;
const char *dbname = name;
char *host = NULL;
int port = 5432;
char *username = NULL;
char *password = "";
char *auth_username = NULL;
char *auth_dbname = NULL;
char *client_encoding = NULL;
char *datestyle = NULL;
char *timezone = NULL;
char *connect_query = NULL;
char *appname = NULL;
char *auth_query = NULL;
cv.value_p = &pool_mode;
cv.extra = (const void *)pool_mode_map;
load_balance_hosts_lookup.value_p = &load_balance_hosts;
load_balance_hosts_lookup.extra = (const void *)load_balance_hosts_map;
if (!check_reserved_database(name)) {
log_error("database name \"%s\" is reserved", name);
return false;
}
if (strcmp(name, "*") == 0) {
return set_autodb(connstr);
}
tmp_connstr = strdup(connstr);
if (!tmp_connstr) {
log_error("out of memory");
return false;
}
p = tmp_connstr;
while (*p) {
p = cstr_get_pair(p, &key, &val);
if (p == NULL) {
log_error("syntax error in connection string");
goto fail;
} else if (!key[0]) {
break;
}
if (strcmp("dbname", key) == 0) {
dbname = val;
} else if (strcmp("host", key) == 0) {
if (!set_param_value(&host, val))
goto fail;
} else if (strcmp("port", key) == 0) {
port = atoi(val);
if (port == 0) {
log_error("invalid port: %s", val);
goto fail;
}
} else if (strcmp("user", key) == 0) {
username = val;
} else if (strcmp("password", key) == 0) {
password = val;
} else if (strcmp("auth_user", key) == 0) {
auth_username = val;
} else if (strcmp("auth_dbname", key) == 0) {
auth_dbname = val;
} else if (strcmp("client_encoding", key) == 0) {
client_encoding = val;
} else if (strcmp("datestyle", key) == 0) {
datestyle = val;
} else if (strcmp("timezone", key) == 0) {
timezone = val;
} else if (strcmp("pool_size", key) == 0) {
pool_size = atoi(val);
} else if (strcmp("min_pool_size", key) == 0) {
min_pool_size = atoi(val);
} else if (strcmp("reserve_pool", key) == 0) {
/* We continue supporting this option for backwards compatibility */
res_pool_size = atoi(val);
} else if (strcmp("reserve_pool_size", key) == 0) {
res_pool_size = atoi(val);
} else if (strcmp("max_db_connections", key) == 0) {
max_db_connections = atoi(val);
} else if (strcmp("max_db_client_connections", key) == 0) {
max_db_client_connections = atoi(val);
} else if (strcmp("server_lifetime", key) == 0) {
server_lifetime = atoi(val) * USEC;
} else if (strcmp("load_balance_hosts", key) == 0) {
if (!cf_set_lookup(&load_balance_hosts_lookup, val)) {
log_error("invalid load_balance_hosts: %s", val);
goto fail;
}
} else if (strcmp("pool_mode", key) == 0) {
if (!cf_set_lookup(&cv, val)) {
log_error("invalid pool mode: %s", val);
goto fail;
}
} else if (strcmp("connect_query", key) == 0) {
if (!set_param_value(&connect_query, val))
goto fail;
} else if (strcmp("application_name", key) == 0) {
appname = val;
} else if (strcmp("auth_query", key) == 0) {
auth_query = val;
} else {
log_error("unrecognized connection parameter: %s", key);
goto fail;
}
}
db = add_database(name);
if (!db) {
log_error("cannot create database, no memory?");
goto fail;
}
/* tag the db as alive */
db->db_dead = false;
/* assuming not an autodb */
db->db_auto = false;
db->inactive_time = 0;
/* if updating old db, check if anything changed */
if (db->dbname) {
bool changed = false;
if (strcmp(db->dbname, dbname) != 0) {
changed = true;
} else if (!strcmpeq(host, db->host)) {
changed = true;
} else if (port != db->port) {
changed = true;
} else if (username && !db->forced_user_credentials) {
changed = true;
} else if (username && strcmp(username, db->forced_user_credentials->name) != 0) {
changed = true;
} else if (!username && db->forced_user_credentials) {
changed = true;
} else if (!strcmpeq(connect_query, db->connect_query)) {
changed = true;
} else if (!strcmpeq(db->auth_dbname, auth_dbname)) {
changed = true;
} else if (!strcmpeq(db->auth_query, auth_query)) {
changed = true;
} else if (load_balance_hosts != db->load_balance_hosts) {
changed = true;
}
if (changed)
tag_database_dirty(db);
}
free(db->host);
db->host = host;
host = NULL;
db->port = port;
db->pool_size = pool_size;
db->min_pool_size = min_pool_size;
db->res_pool_size = res_pool_size;
db->pool_mode = pool_mode;
db->max_db_client_connections = max_db_client_connections;
db->max_db_connections = max_db_connections;
db->server_lifetime = server_lifetime;
db->load_balance_hosts = load_balance_hosts;
free(db->connect_query);
db->connect_query = connect_query;
connect_query = NULL;
if (!set_param_value(&db->auth_dbname, auth_dbname))
goto fail;
if (!set_param_value(&db->auth_query, auth_query))
goto fail;
if (db->startup_params) {
msg = db->startup_params;
pktbuf_reset(msg);
} else {
msg = pktbuf_dynamic(128);
if (!msg)
die("out of memory");
db->startup_params = msg;
}
pktbuf_put_string(msg, "database");
dbname_ofs = msg->write_pos;
pktbuf_put_string(msg, dbname);
if (client_encoding) {
pktbuf_put_string(msg, "client_encoding");
pktbuf_put_string(msg, client_encoding);
}
if (datestyle) {
pktbuf_put_string(msg, "datestyle");
pktbuf_put_string(msg, datestyle);
}
if (timezone) {
pktbuf_put_string(msg, "timezone");
pktbuf_put_string(msg, timezone);
}
if (appname) {
pktbuf_put_string(msg, "application_name");
pktbuf_put_string(msg, appname);
}
if (auth_username != NULL) {
db->auth_user_credentials = find_or_add_new_global_credentials(auth_username, "");
if (!db->auth_user_credentials)
goto fail;
} else if (db->auth_user_credentials) {
db->auth_user_credentials = NULL;
}
/* if user is forced, create fake object for it */
if (username != NULL) {
if (!force_user_credentials(db, username, password))
log_warning("db setup failed, trying to continue");
} else if (db->forced_user_credentials) {
log_warning("losing forced user not supported,"
" keeping old setting");
}
/* remember dbname */
db->dbname = (char *)msg->buf + dbname_ofs;
free(tmp_connstr);
return true;
fail:
free(tmp_connstr);
free(host);
free(connect_query);
return false;
}
bool parse_user(void *base, const char *name, const char *connstr)
{
char *p, *key, *val, *tmp_connstr;
PgGlobalUser *user;
struct CfValue cv;
int pool_mode = POOL_INHERIT;
int pool_size = -1;
int res_pool_size = -1;
int max_user_connections = -1;
usec_t idle_transaction_timeout = 0;
usec_t query_timeout = 0;
usec_t client_idle_timeout = 0;
int max_user_client_connections = -1;
cv.value_p = &pool_mode;
cv.extra = (const void *)pool_mode_map;
tmp_connstr = strdup(connstr);
if (!tmp_connstr) {
log_error("out of memory");
return false;
}
p = tmp_connstr;
while (*p) {
p = cstr_get_pair(p, &key, &val);
if (p == NULL) {
log_error("syntax error in user settings");
goto fail;
} else if (!key[0]) {
break;
}
if (strcmp("pool_mode", key) == 0) {
if (!cf_set_lookup(&cv, val)) {
log_error("invalid pool mode: %s", val);
goto fail;
}
} else if (strcmp("pool_size", key) == 0) {
pool_size = atoi(val);
} else if (strcmp("reserve_pool_size", key) == 0) {
res_pool_size = atoi(val);
} else if (strcmp("max_user_connections", key) == 0) {
max_user_connections = atoi(val);
} else if (strcmp("idle_transaction_timeout", key) == 0) {
any_user_level_timeout_set = true;
idle_transaction_timeout = atoi(val) * USEC;
} else if (strcmp("query_timeout", key) == 0) {
any_user_level_timeout_set = true;
query_timeout = atoi(val) * USEC;
} else if (strcmp("client_idle_timeout", key) == 0) {
any_user_level_client_timeout_set = true;
client_idle_timeout = atoi(val) * USEC;
} else if (strcmp("max_user_client_connections", key) == 0) {
max_user_client_connections = atoi(val);
} else {
log_error("unrecognized user parameter: %s", key);
goto fail;
}
}
user = find_or_add_new_global_user(name, "");
if (!user) {
log_error("cannot create user, no memory?");
goto fail;
}
user->pool_mode = pool_mode;
user->pool_size = pool_size;
user->res_pool_size = res_pool_size;
user->max_user_connections = max_user_connections;
user->idle_transaction_timeout = idle_transaction_timeout;
user->query_timeout = query_timeout;
user->client_idle_timeout = client_idle_timeout;
user->max_user_client_connections = max_user_client_connections;
free(tmp_connstr);
return true;
fail:
free(tmp_connstr);
return false;
}
/*
* User file parsing
*/
/* find next " in string, skipping escaped ones */
static char *find_quote(char *p, bool start)
{
loop:
while (*p && *p != '"')
p++;
if (p[0] == '"' && p[1] == '"' && !start) {
p += 2;
goto loop;
}
return p;
}
/* string is unquoted while copying */
static void copy_quoted(char *dst, const char *src, int len)
{
char *end = dst + len - 1;
while (*src && dst < end) {
if (*src == '"')
src++;
*dst++ = *src++;
}
*dst = 0;
}
/* This function is only called when parsing the auth file, so
all users added by this function do not have a dynamic password,
by definition. If the password is empty, so be it. */
static void unquote_add_authfile_user(const char *username, const char *password)
{
char real_user[MAX_USERNAME];
char real_passwd[MAX_PASSWORD];
PgGlobalUser *user;
copy_quoted(real_user, username, sizeof(real_user));
copy_quoted(real_passwd, password, sizeof(real_passwd));
user = find_or_add_new_global_user(real_user, real_passwd);
if (!user) {
log_warning("cannot create user, no memory");
return;
}
if (strcmp(user->credentials.passwd, real_passwd) != 0) {
user = update_global_user_passwd(user, real_passwd);
}
user->credentials.dynamic_passwd = false;
}
static bool auth_loaded(const char *fn)
{
static bool cache_set = false;
static struct stat cache;
struct stat cur;
/* no file specified */
if (fn == NULL) {
memset(&cache, 0, sizeof(cache));
cache_set = true;
return false;
}
if (stat(fn, &cur) < 0)
memset(&cur, 0, sizeof(cur));
if (cache_set && cache.st_dev == cur.st_dev
&& cache.st_ino == cur.st_ino
&& cache.st_mode == cur.st_mode
&& cache.st_uid == cur.st_uid
&& cache.st_gid == cur.st_gid
&& cache.st_mtime == cur.st_mtime
&& cache.st_size == cur.st_size)
return true;
cache = cur;
cache_set = true;
return false;
}
bool loader_users_check(void)
{
if (auth_loaded(cf_auth_file))
return true;
return load_auth_file(cf_auth_file);
}
static void disable_users(void)
{
struct List *item;
statlist_for_each(item, &user_list) {
PgGlobalUser *user = container_of(item, PgGlobalUser, head);
user->credentials.passwd[0] = 0;
}
}
/* load list of users from auth_file */
bool load_auth_file(const char *fn)
{
char *user, *password, *buf, *p;
/* No file to load? */
if (fn == NULL)
return false;
buf = load_file(fn, NULL);
if (buf == NULL) {
log_error("could not open auth_file %s: %s", fn, strerror(errno));
return false;
}
log_debug("loading auth_file: \"%s\"", fn);
disable_users();
p = buf;
while (*p) {
/* skip whitespace and empty lines */
while (*p && isspace(*p)) p++;
if (!*p)
break;
/* skip commented-out lines */
if (*p == ';') {
while (*p && *p != '\n') p++;
continue;
}
/* start of line */
if (*p != '"') {
log_error("broken auth file");
break;
}
user = ++p;
p = find_quote(p, false);
if (*p != '"') {
log_error("broken auth file");
break;
}
if (p - user >= MAX_USERNAME) {
log_error("username too long in auth file");
break;
}
*p++ = 0; /* tag username end */
/* get password */
p = find_quote(p, true);
if (*p != '"') {
log_error("broken auth file");
break;
}
password = ++p;
p = find_quote(p, false);
if (*p != '"') {
log_error("broken auth file");
break;
}
if (p - password >= MAX_PASSWORD) {
log_error("password too long in auth file");
break;
}
*p++ = 0; /* tag password end */
/* send them away */
unquote_add_authfile_user(user, password);
/* skip rest of the line */
while (*p && *p != '\n') p++;
}
free(buf);
return true;
}
pgbouncer-1.24.1/src/scram.c 0000644 0001750 0000000 00000072155 14777762222 012561 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* SCRAM support
*/
#include "bouncer.h"
#include "scram.h"
#include "common/base64.h"
#include "common/saslprep.h"
#include "common/scram-common.h"
static bool calculate_client_proof(ScramState *scram_state,
const PgCredentials *credentials,
const char *salt,
int saltlen,
int iterations,
const char *client_final_message_without_proof,
uint8_t *result);
/*
* free SCRAM state info after auth is done
*/
void free_scram_state(ScramState *scram_state)
{
free(scram_state->client_nonce);
free(scram_state->client_first_message_bare);
free(scram_state->client_final_message_without_proof);
free(scram_state->server_nonce);
free(scram_state->server_first_message);
free(scram_state->SaltedPassword);
free(scram_state->salt);
memset(scram_state, 0, sizeof(*scram_state));
}
static bool is_scram_printable(char *p)
{
/*------
* Printable characters, as defined by SCRAM spec: (RFC 5802)
*
* printable = %x21-2B / %x2D-7E
* ;; Printable ASCII except ",".
* ;; Note that any "printable" is also
* ;; a valid "value".
*------
*/
for (; *p; p++)
if (*p < 0x21 || *p > 0x7E || *p == 0x2C /* comma */)
return false;
return true;
}
static char *sanitize_char(char c)
{
static char buf[5];
if (c >= 0x21 && c <= 0x7E)
snprintf(buf, sizeof(buf), "'%c'", c);
else
snprintf(buf, sizeof(buf), "0x%02x", (unsigned char) c);
return buf;
}
/*
* Read value for an attribute part of a SCRAM message.
*/
static char *read_attr_value(PgSocket *sk, char **input, char attr)
{
char *begin = *input;
char *end;
if (*begin != attr) {
slog_error(sk, "malformed SCRAM message (attribute \"%c\" expected)",
attr);
return NULL;
}
begin++;
if (*begin != '=') {
slog_error(sk, "malformed SCRAM message (expected \"=\" after attribute \"%c\")",
attr);
return NULL;
}
begin++;
end = begin;
while (*end && *end != ',')
end++;
if (*end) {
*end = '\0';
*input = end + 1;
} else {
*input = end;
}
return begin;
}
/*
* Read the next attribute and value in a SCRAM exchange message.
*
* Returns NULL if there is no attribute.
*/
static char *read_any_attr(PgSocket *sk, char **input, char *attr_p)
{
char *begin = *input;
char *end;
char attr = *begin;
if (!((attr >= 'A' && attr <= 'Z') ||
(attr >= 'a' && attr <= 'z'))) {
slog_error(sk, "malformed SCRAM message (attribute expected, but found invalid character \"%s\")",
sanitize_char(attr));
return NULL;
}
if (attr_p)
*attr_p = attr;
begin++;
if (*begin != '=') {
slog_error(sk, "malformed SCRAM message (expected character \"=\" after attribute \"%c\")",
attr);
return NULL;
}
begin++;
end = begin;
while (*end && *end != ',')
end++;
if (*end) {
*end = '\0';
*input = end + 1;
} else {
*input = end;
}
return begin;
}
/*
* Parse and validate format of given SCRAM secret.
*
* Returns true if the SCRAM secret has been parsed, and false otherwise.
*/
static bool parse_scram_secret(const char *secret, int *iterations, char **salt,
uint8_t *stored_key, uint8_t *server_key)
{
char *s;
char *p;
char *scheme_str;
char *salt_str;
char *iterations_str;
char *storedkey_str;
char *serverkey_str;
int decoded_len;
char *decoded_salt_buf;
char *decoded_stored_buf = NULL;
char *decoded_server_buf = NULL;
/*
* The secret is of form:
*
* SCRAM-SHA-256$:$:
*/
s = strdup(secret);
if (!s)
goto invalid_secret;
if ((scheme_str = strtok(s, "$")) == NULL)
goto invalid_secret;
if ((iterations_str = strtok(NULL, ":")) == NULL)
goto invalid_secret;
if ((salt_str = strtok(NULL, "$")) == NULL)
goto invalid_secret;
if ((storedkey_str = strtok(NULL, ":")) == NULL)
goto invalid_secret;
if ((serverkey_str = strtok(NULL, "")) == NULL)
goto invalid_secret;
/* Parse the fields */
if (strcmp(scheme_str, "SCRAM-SHA-256") != 0)
goto invalid_secret;
errno = 0;
*iterations = strtol(iterations_str, &p, 10);
if (*p || errno != 0)
goto invalid_secret;
/*
* Verify that the salt is in Base64-encoded format, by decoding it,
* although we return the encoded version to the caller.
*/
decoded_len = pg_b64_dec_len(strlen(salt_str));
decoded_salt_buf = malloc(decoded_len);
if (!decoded_salt_buf)
goto invalid_secret;
decoded_len = pg_b64_decode(salt_str, strlen(salt_str), decoded_salt_buf, decoded_len);
free(decoded_salt_buf);
if (decoded_len < 0)
goto invalid_secret;
*salt = strdup(salt_str);
if (!*salt)
goto invalid_secret;
/*
* Decode StoredKey and ServerKey.
*/
decoded_len = pg_b64_dec_len(strlen(storedkey_str));
decoded_stored_buf = malloc(decoded_len);
if (!decoded_stored_buf)
goto invalid_secret;
decoded_len = pg_b64_decode(storedkey_str, strlen(storedkey_str), decoded_stored_buf, decoded_len);
if (decoded_len != SCRAM_KEY_LEN)
goto invalid_secret;
memcpy(stored_key, decoded_stored_buf, SCRAM_KEY_LEN);
decoded_len = pg_b64_dec_len(strlen(serverkey_str));
decoded_server_buf = malloc(decoded_len);
decoded_len = pg_b64_decode(serverkey_str, strlen(serverkey_str),
decoded_server_buf, decoded_len);
if (decoded_len != SCRAM_KEY_LEN)
goto invalid_secret;
memcpy(server_key, decoded_server_buf, SCRAM_KEY_LEN);
free(decoded_stored_buf);
free(decoded_server_buf);
free(s);
return true;
invalid_secret:
free(decoded_stored_buf);
free(decoded_server_buf);
free(s);
free(*salt);
*salt = NULL;
return false;
}
#define MD5_PASSWD_CHARSET "0123456789abcdef"
/*
* What kind of a password type is 'shadow_pass'?
*/
PasswordType get_password_type(const char *shadow_pass)
{
char *encoded_salt = NULL;
int iterations;
uint8_t stored_key[SCRAM_KEY_LEN];
uint8_t server_key[SCRAM_KEY_LEN];
if (strncmp(shadow_pass, "md5", 3) == 0 &&
strlen(shadow_pass) == MD5_PASSWD_LEN &&
strspn(shadow_pass + 3, MD5_PASSWD_CHARSET) == MD5_PASSWD_LEN - 3)
return PASSWORD_TYPE_MD5;
if (parse_scram_secret(shadow_pass, &iterations, &encoded_salt,
stored_key, server_key)) {
free(encoded_salt);
return PASSWORD_TYPE_SCRAM_SHA_256;
}
free(encoded_salt);
return PASSWORD_TYPE_PLAINTEXT;
}
/*
* Functions for communicating as a client with the server
*/
char *build_client_first_message(ScramState *scram_state)
{
uint8_t raw_nonce[SCRAM_RAW_NONCE_LEN + 1];
int encoded_len;
size_t len;
char *result = NULL;
get_random_bytes(raw_nonce, SCRAM_RAW_NONCE_LEN);
encoded_len = pg_b64_enc_len(SCRAM_RAW_NONCE_LEN);
scram_state->client_nonce = malloc(encoded_len + 1);
if (scram_state->client_nonce == NULL)
goto failed;
encoded_len = pg_b64_encode((char *) raw_nonce, SCRAM_RAW_NONCE_LEN, scram_state->client_nonce, encoded_len);
if (encoded_len < 0)
goto failed;
scram_state->client_nonce[encoded_len] = '\0';
len = 8 + strlen(scram_state->client_nonce) + 1;
result = malloc(len);
if (result == NULL)
goto failed;
snprintf(result, len, "n,,n=,r=%s", scram_state->client_nonce);
scram_state->client_first_message_bare = strdup(result + 3);
if (scram_state->client_first_message_bare == NULL)
goto failed;
return result;
failed:
free(result);
free(scram_state->client_nonce);
free(scram_state->client_first_message_bare);
return NULL;
}
char *build_client_final_message(ScramState *scram_state,
const PgCredentials *credentials,
const char *server_nonce,
const char *salt,
int saltlen,
int iterations)
{
char buf[512];
size_t len;
uint8_t client_proof[SCRAM_KEY_LEN];
int enclen;
snprintf(buf, sizeof(buf), "c=biws,r=%s", server_nonce);
scram_state->client_final_message_without_proof = strdup(buf);
if (scram_state->client_final_message_without_proof == NULL)
goto failed;
if (!calculate_client_proof(scram_state, credentials,
salt, saltlen, iterations, buf,
client_proof))
goto failed;
len = strlcat(buf, ",p=", sizeof(buf));
enclen = pg_b64_enc_len(sizeof(client_proof));
enclen = pg_b64_encode((char *) client_proof,
SCRAM_KEY_LEN,
buf + len, enclen);
if (enclen < 0)
goto failed;
len += enclen;
buf[len] = '\0';
return strdup(buf);
failed:
return NULL;
}
bool read_server_first_message(PgSocket *server, char *input,
char **server_nonce_p, char **salt_p, int *saltlen_p, int *iterations_p)
{
char *server_nonce;
char *encoded_salt;
char *salt = NULL;
int saltlen;
char *iterations_str;
char *endptr;
int iterations;
server->scram_state.server_first_message = strdup(input);
if (server->scram_state.server_first_message == NULL)
goto failed;
server_nonce = read_attr_value(server, &input, 'r');
if (server_nonce == NULL)
goto failed;
if (strlen(server_nonce) < strlen(server->scram_state.client_nonce) ||
memcmp(server_nonce, server->scram_state.client_nonce, strlen(server->scram_state.client_nonce)) != 0) {
slog_error(server, "invalid SCRAM response (nonce mismatch)");
goto failed;
}
encoded_salt = read_attr_value(server, &input, 's');
if (encoded_salt == NULL)
goto failed;
saltlen = pg_b64_dec_len(strlen(encoded_salt));
salt = malloc(saltlen);
if (salt == NULL)
goto failed;
saltlen = pg_b64_decode(encoded_salt,
strlen(encoded_salt),
salt, saltlen);
if (saltlen < 0) {
slog_error(server, "malformed SCRAM message (invalid salt)");
goto failed;
}
iterations_str = read_attr_value(server, &input, 'i');
if (iterations_str == NULL)
goto failed;
iterations = strtol(iterations_str, &endptr, 10);
if (*endptr != '\0' || iterations < 1) {
slog_error(server, "malformed SCRAM message (invalid iteration count)");
goto failed;
}
if (*input != '\0') {
slog_error(server, "malformed SCRAM message (garbage at end of server-first-message)");
goto failed;
}
*server_nonce_p = server_nonce;
*salt_p = salt;
*saltlen_p = saltlen;
*iterations_p = iterations;
return true;
failed:
free(salt);
return false;
}
bool read_server_final_message(PgSocket *server, char *input, char *ServerSignature)
{
char *encoded_server_signature;
char *decoded_server_signature = NULL;
int server_signature_len;
if (*input == 'e') {
char *errmsg = read_attr_value(server, &input, 'e');
slog_error(server, "error received from server in SCRAM exchange: %s",
errmsg);
goto failed;
}
encoded_server_signature = read_attr_value(server, &input, 'v');
if (encoded_server_signature == NULL)
goto failed;
if (*input != '\0')
slog_error(server, "malformed SCRAM message (garbage at end of server-final-message)");
server_signature_len = pg_b64_dec_len(strlen(encoded_server_signature));
decoded_server_signature = malloc(server_signature_len);
if (!decoded_server_signature)
goto failed;
server_signature_len = pg_b64_decode(encoded_server_signature,
strlen(encoded_server_signature),
decoded_server_signature,
server_signature_len);
if (server_signature_len != SCRAM_KEY_LEN) {
slog_error(server, "malformed SCRAM message (malformed server signature)");
goto failed;
}
memcpy(ServerSignature, decoded_server_signature, SCRAM_KEY_LEN);
free(decoded_server_signature);
return true;
failed:
free(decoded_server_signature);
return false;
}
static bool calculate_client_proof(ScramState *scram_state,
const PgCredentials *credentials,
const char *salt,
int saltlen,
int iterations,
const char *client_final_message_without_proof,
uint8_t *result)
{
pg_saslprep_rc rc;
char *prep_password = NULL;
uint8_t StoredKey[SCRAM_KEY_LEN];
uint8_t ClientKey[SCRAM_KEY_LEN];
uint8_t ClientSignature[SCRAM_KEY_LEN];
scram_HMAC_ctx ctx;
if (credentials->has_scram_keys) {
memcpy(ClientKey, credentials->scram_ClientKey, SCRAM_KEY_LEN);
} else
{
rc = pg_saslprep(credentials->passwd, &prep_password);
if (rc == SASLPREP_OOM)
return false;
if (rc != SASLPREP_SUCCESS) {
prep_password = strdup(credentials->passwd);
if (!prep_password)
return false;
}
scram_state->SaltedPassword = malloc(SCRAM_KEY_LEN);
if (scram_state->SaltedPassword == NULL)
goto failed;
scram_SaltedPassword(prep_password,
salt,
saltlen,
iterations,
scram_state->SaltedPassword);
scram_ClientKey(scram_state->SaltedPassword, ClientKey);
}
scram_H(ClientKey, SCRAM_KEY_LEN, StoredKey);
scram_HMAC_init(&ctx, StoredKey, SCRAM_KEY_LEN);
scram_HMAC_update(&ctx,
scram_state->client_first_message_bare,
strlen(scram_state->client_first_message_bare));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
scram_state->server_first_message,
strlen(scram_state->server_first_message));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
client_final_message_without_proof,
strlen(client_final_message_without_proof));
scram_HMAC_final(ClientSignature, &ctx);
for (int i = 0; i < SCRAM_KEY_LEN; i++)
result[i] = ClientKey[i] ^ ClientSignature[i];
free(prep_password);
return true;
failed:
free(prep_password);
return false;
}
bool verify_server_signature(ScramState *scram_state, const PgCredentials *credentials, const char *ServerSignature)
{
uint8_t expected_ServerSignature[SCRAM_KEY_LEN];
uint8_t ServerKey[SCRAM_KEY_LEN];
scram_HMAC_ctx ctx;
if (credentials->has_scram_keys)
memcpy(ServerKey, credentials->scram_ServerKey, SCRAM_KEY_LEN);
else
scram_ServerKey(scram_state->SaltedPassword, ServerKey);
scram_HMAC_init(&ctx, ServerKey, SCRAM_KEY_LEN);
scram_HMAC_update(&ctx,
scram_state->client_first_message_bare,
strlen(scram_state->client_first_message_bare));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
scram_state->server_first_message,
strlen(scram_state->server_first_message));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
scram_state->client_final_message_without_proof,
strlen(scram_state->client_final_message_without_proof));
scram_HMAC_final(expected_ServerSignature, &ctx);
if (memcmp(expected_ServerSignature, ServerSignature, SCRAM_KEY_LEN) != 0)
return false;
return true;
}
/*
* Functions for communicating as a server to the client
*/
bool read_client_first_message(PgSocket *client, char *input,
char *cbind_flag_p,
char **client_first_message_bare_p,
char **client_nonce_p)
{
char *client_first_message_bare = NULL;
char *client_nonce = NULL;
char *client_nonce_copy = NULL;
*cbind_flag_p = *input;
switch (*input) {
case 'n':
/* Client does not support channel binding */
input++;
break;
case 'y':
/* Client supports channel binding, but we're not doing it today */
input++;
break;
case 'p':
/* Client requires channel binding. We don't support it. */
slog_error(client, "client requires SCRAM channel binding, but it is not supported");
goto failed;
default:
slog_error(client, "malformed SCRAM message (unexpected channel-binding flag \"%s\")",
sanitize_char(*input));
goto failed;
}
if (*input != ',') {
slog_error(client, "malformed SCRAM message (comma expected, but found character \"%s\")",
sanitize_char(*input));
goto failed;
}
input++;
if (*input == 'a') {
slog_error(client, "client uses authorization identity, but it is not supported");
goto failed;
}
if (*input != ',') {
slog_error(client, "malformed SCRAM message (unexpected attribute \"%s\" in client-first-message)",
sanitize_char(*input));
goto failed;
}
input++;
client_first_message_bare = strdup(input);
if (client_first_message_bare == NULL)
goto failed;
if (*input == 'm') {
slog_error(client, "client requires an unsupported SCRAM extension");
goto failed;
}
/* read and ignore user name */
read_attr_value(client, &input, 'n');
client_nonce = read_attr_value(client, &input, 'r');
if (client_nonce == NULL)
goto failed;
if (!is_scram_printable(client_nonce)) {
slog_error(client, "non-printable characters in SCRAM nonce");
goto failed;
}
client_nonce_copy = strdup(client_nonce);
if (client_nonce_copy == NULL)
goto failed;
/*
* There can be any number of optional extensions after this. We don't
* support any extensions, so ignore them.
*/
while (*input != '\0') {
if (!read_any_attr(client, &input, NULL))
goto failed;
}
*client_first_message_bare_p = client_first_message_bare;
*client_nonce_p = client_nonce_copy;
return true;
failed:
free(client_first_message_bare);
free(client_nonce_copy);
return false;
}
bool read_client_final_message(PgSocket *client, const uint8_t *raw_input, char *input,
const char **client_final_nonce_p,
char **proof_p)
{
const char *input_start = input;
char attr;
char *channel_binding;
char *client_final_nonce;
char *proof_start;
char *value;
char *encoded_proof;
char *proof = NULL;
int prooflen;
/*
* Read channel-binding. We don't support channel binding, so
* it's expected to always be "biws", which is "n,,",
* base64-encoded, or "eSws", which is "y,,". We also have to
* check whether the flag is the same one that the client
* originally sent.
*/
channel_binding = read_attr_value(client, &input, 'c');
if (channel_binding == NULL)
goto failed;
if (!(strcmp(channel_binding, "biws") == 0 && client->scram_state.cbind_flag == 'n') &&
!(strcmp(channel_binding, "eSws") == 0 && client->scram_state.cbind_flag == 'y')) {
slog_error(client, "unexpected SCRAM channel-binding attribute in client-final-message");
goto failed;
}
client_final_nonce = read_attr_value(client, &input, 'r');
/* ignore optional extensions */
do {
proof_start = input - 1;
value = read_any_attr(client, &input, &attr);
} while (value && attr != 'p');
if (!value) {
slog_error(client, "could not read proof");
goto failed;
}
encoded_proof = value;
prooflen = pg_b64_dec_len(strlen(encoded_proof));
proof = malloc(prooflen);
if (proof == NULL) {
slog_error(client, "could not decode proof");
goto failed;
}
prooflen = pg_b64_decode(encoded_proof,
strlen(encoded_proof),
proof, prooflen);
if (prooflen != SCRAM_KEY_LEN) {
slog_error(client, "malformed SCRAM message (malformed proof in client-final-message)");
goto failed;
}
if (*input != '\0') {
slog_error(client, "malformed SCRAM message (garbage at the end of client-final-message)");
goto failed;
}
client->scram_state.client_final_message_without_proof = malloc(proof_start - input_start + 1);
if (!client->scram_state.client_final_message_without_proof)
goto failed;
memcpy(client->scram_state.client_final_message_without_proof, raw_input, proof_start - input_start);
client->scram_state.client_final_message_without_proof[proof_start - input_start] = '\0';
*client_final_nonce_p = client_final_nonce;
*proof_p = proof;
return true;
failed:
free(proof);
return false;
}
/*
* For doing SCRAM with a password stored in plain text, build a SCRAM
* secret on the fly.
*/
static bool build_adhoc_scram_secret(const char *plain_password, ScramState *scram_state)
{
const char *password;
char *prep_password;
pg_saslprep_rc rc;
char saltbuf[SCRAM_DEFAULT_SALT_LEN];
int encoded_len;
uint8_t salted_password[SCRAM_KEY_LEN];
rc = pg_saslprep(plain_password, &prep_password);
if (rc == SASLPREP_OOM)
goto failed;
else if (rc == SASLPREP_SUCCESS)
password = prep_password;
else
password = plain_password;
get_random_bytes((uint8_t *) saltbuf, sizeof(saltbuf));
scram_state->adhoc = true;
scram_state->iterations = SCRAM_DEFAULT_ITERATIONS;
encoded_len = pg_b64_enc_len(sizeof(saltbuf));
scram_state->salt = malloc(encoded_len + 1);
if (!scram_state->salt)
goto failed;
encoded_len = pg_b64_encode(saltbuf, sizeof(saltbuf), scram_state->salt, encoded_len);
if (encoded_len < 0)
goto failed;
scram_state->salt[encoded_len] = '\0';
/* Calculate StoredKey and ServerKey */
scram_SaltedPassword(password, saltbuf, sizeof(saltbuf),
scram_state->iterations,
salted_password);
scram_ClientKey(salted_password, scram_state->StoredKey);
scram_H(scram_state->StoredKey, SCRAM_KEY_LEN, scram_state->StoredKey);
scram_ServerKey(salted_password, scram_state->ServerKey);
free(prep_password);
return true;
failed:
free(prep_password);
return false;
}
/*
* Deterministically generate salt for mock authentication, using a
* SHA256 hash based on the username and an instance-level secret key.
* Target buffer needs to be of size SCRAM_DEFAULT_SALT_LEN.
*/
static void scram_mock_salt(const char *username, uint8_t *saltbuf)
{
static uint8_t mock_auth_nonce[32];
static bool mock_auth_nonce_initialized = false;
struct sha256_ctx ctx;
uint8_t sha_digest[PG_SHA256_DIGEST_LENGTH];
/*
* Generating salt using a SHA256 hash works as long as the
* required salt length is not larger than the SHA256 digest
* length.
*/
static_assert(PG_SHA256_DIGEST_LENGTH >= SCRAM_DEFAULT_SALT_LEN,
"salt length greater than SHA256 digest length");
if (!mock_auth_nonce_initialized) {
get_random_bytes(mock_auth_nonce, sizeof(mock_auth_nonce));
mock_auth_nonce_initialized = true;
}
sha256_reset(&ctx);
sha256_update(&ctx, (uint8_t *) username, strlen(username));
sha256_update(&ctx, mock_auth_nonce, sizeof(mock_auth_nonce));
sha256_final(&ctx, sha_digest);
memcpy(saltbuf, sha_digest, SCRAM_DEFAULT_SALT_LEN);
}
static bool build_mock_scram_secret(const char *username, ScramState *scram_state)
{
uint8_t saltbuf[SCRAM_DEFAULT_SALT_LEN];
int encoded_len;
scram_state->iterations = SCRAM_DEFAULT_ITERATIONS;
scram_mock_salt(username, saltbuf);
encoded_len = pg_b64_enc_len(sizeof(saltbuf));
scram_state->salt = malloc(encoded_len + 1);
if (!scram_state->salt)
goto failed;
encoded_len = pg_b64_encode((char *) saltbuf, sizeof(saltbuf), scram_state->salt, encoded_len);
if (encoded_len < 0)
goto failed;
scram_state->salt[encoded_len] = '\0';
return true;
failed:
return false;
}
char *build_server_first_message(ScramState *scram_state, const char *username, const char *stored_secret)
{
uint8_t raw_nonce[SCRAM_RAW_NONCE_LEN + 1];
int encoded_len;
size_t len;
char *result;
if (!stored_secret) {
if (!build_mock_scram_secret(username, scram_state))
goto failed;
} else {
switch (get_password_type(stored_secret)) {
case PASSWORD_TYPE_SCRAM_SHA_256:
if (!parse_scram_secret(stored_secret,
&scram_state->iterations,
&scram_state->salt,
scram_state->StoredKey,
scram_state->ServerKey))
goto failed;
break;
case PASSWORD_TYPE_PLAINTEXT:
if (!build_adhoc_scram_secret(stored_secret, scram_state))
goto failed;
break;
default:
/* shouldn't get here */
goto failed;
}
}
get_random_bytes(raw_nonce, SCRAM_RAW_NONCE_LEN);
encoded_len = pg_b64_enc_len(SCRAM_RAW_NONCE_LEN);
scram_state->server_nonce = malloc(encoded_len + 1);
if (scram_state->server_nonce == NULL)
goto failed;
encoded_len = pg_b64_encode((char *) raw_nonce, SCRAM_RAW_NONCE_LEN, scram_state->server_nonce, encoded_len);
if (encoded_len < 0)
goto failed;
scram_state->server_nonce[encoded_len] = '\0';
len = (2
+ strlen(scram_state->client_nonce)
+ strlen(scram_state->server_nonce)
+ 3
+ strlen(scram_state->salt)
+ 3 + 10 + 1);
result = malloc(len);
if (!result)
goto failed;
snprintf(result, len,
"r=%s%s,s=%s,i=%u",
scram_state->client_nonce,
scram_state->server_nonce,
scram_state->salt,
scram_state->iterations);
scram_state->server_first_message = result;
return result;
failed:
free(scram_state->server_nonce);
free(scram_state->server_first_message);
return NULL;
}
static char *compute_server_signature(ScramState *state)
{
uint8_t ServerSignature[SCRAM_KEY_LEN];
char *server_signature_base64;
int siglen;
scram_HMAC_ctx ctx;
/* calculate ServerSignature */
scram_HMAC_init(&ctx, state->ServerKey, SCRAM_KEY_LEN);
scram_HMAC_update(&ctx,
state->client_first_message_bare,
strlen(state->client_first_message_bare));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
state->server_first_message,
strlen(state->server_first_message));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
state->client_final_message_without_proof,
strlen(state->client_final_message_without_proof));
scram_HMAC_final(ServerSignature, &ctx);
siglen = pg_b64_enc_len(SCRAM_KEY_LEN);
server_signature_base64 = malloc(siglen + 1);
if (!server_signature_base64)
return NULL;
siglen = pg_b64_encode((const char *) ServerSignature,
SCRAM_KEY_LEN, server_signature_base64, siglen);
if (siglen < 0) {
free(server_signature_base64);
return NULL;
}
server_signature_base64[siglen] = '\0';
return server_signature_base64;
}
char *build_server_final_message(ScramState *scram_state)
{
char *server_signature = NULL;
size_t len;
char *result;
server_signature = compute_server_signature(scram_state);
if (!server_signature)
goto failed;
len = 2 + strlen(server_signature) + 1;
/*
* Avoid compiler warning at snprintf() below because len
* could in theory overflow snprintf() result. If this
* happened in practice, it would surely be some crazy
* corruption, so treat it as an error.
*/
if (len >= INT_MAX)
goto failed;
result = malloc(len);
if (!result)
goto failed;
snprintf(result, len, "v=%s", server_signature);
free(server_signature);
return result;
failed:
free(server_signature);
return NULL;
}
bool verify_final_nonce(const ScramState *scram_state, const char *client_final_nonce)
{
size_t client_nonce_len = strlen(scram_state->client_nonce);
size_t server_nonce_len = strlen(scram_state->server_nonce);
size_t final_nonce_len = strlen(client_final_nonce);
if (final_nonce_len != client_nonce_len + server_nonce_len)
return false;
if (memcmp(client_final_nonce, scram_state->client_nonce, client_nonce_len) != 0)
return false;
if (memcmp(client_final_nonce + client_nonce_len, scram_state->server_nonce, server_nonce_len) != 0)
return false;
return true;
}
bool verify_client_proof(ScramState *state, const char *ClientProof)
{
uint8_t ClientSignature[SCRAM_KEY_LEN];
uint8_t client_StoredKey[SCRAM_KEY_LEN];
scram_HMAC_ctx ctx;
int i;
/* calculate ClientSignature */
scram_HMAC_init(&ctx, state->StoredKey, SCRAM_KEY_LEN);
scram_HMAC_update(&ctx,
state->client_first_message_bare,
strlen(state->client_first_message_bare));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
state->server_first_message,
strlen(state->server_first_message));
scram_HMAC_update(&ctx, ",", 1);
scram_HMAC_update(&ctx,
state->client_final_message_without_proof,
strlen(state->client_final_message_without_proof));
scram_HMAC_final(ClientSignature, &ctx);
/* Extract the ClientKey that the client calculated from the proof */
for (i = 0; i < SCRAM_KEY_LEN; i++)
state->ClientKey[i] = ClientProof[i] ^ ClientSignature[i];
/* Hash it one more time, and compare with StoredKey */
scram_H(state->ClientKey, SCRAM_KEY_LEN, client_StoredKey);
if (memcmp(client_StoredKey, state->StoredKey, SCRAM_KEY_LEN) != 0)
return false;
return true;
}
/*
* Verify a plaintext password against a SCRAM secret. This is used when
* performing plaintext password authentication for a user that has a SCRAM
* secret stored in pg_authid.
*/
bool scram_verify_plain_password(PgSocket *client,
const char *username, const char *password,
const char *secret)
{
char *encoded_salt = NULL;
char *salt = NULL;
int saltlen;
int iterations;
uint8_t salted_password[SCRAM_KEY_LEN];
uint8_t stored_key[SCRAM_KEY_LEN];
uint8_t server_key[SCRAM_KEY_LEN];
uint8_t computed_key[SCRAM_KEY_LEN];
char *prep_password = NULL;
pg_saslprep_rc rc;
bool result = false;
if (!parse_scram_secret(secret, &iterations, &encoded_salt,
stored_key, server_key)) {
/* The password looked like a SCRAM secret, but could not be parsed. */
slog_warning(client, "invalid SCRAM secret for user \"%s\"", username);
goto failed;
}
saltlen = pg_b64_dec_len(strlen(encoded_salt));
salt = malloc(saltlen);
if (!salt)
goto failed;
saltlen = pg_b64_decode(encoded_salt, strlen(encoded_salt), salt, saltlen);
if (saltlen < 0) {
slog_warning(client, "invalid SCRAM secret for user \"%s\"", username);
goto failed;
}
/* Normalize the password */
rc = pg_saslprep(password, &prep_password);
if (rc == SASLPREP_SUCCESS)
password = prep_password;
/* Compute Server Key based on the user-supplied plaintext password */
scram_SaltedPassword(password, salt, saltlen, iterations, salted_password);
scram_ServerKey(salted_password, computed_key);
/*
* Compare the secret's Server Key with the one computed from the
* user-supplied password.
*/
result = memcmp(computed_key, server_key, SCRAM_KEY_LEN) == 0;
failed:
free(encoded_salt);
free(salt);
free(prep_password);
return result;
}
pgbouncer-1.24.1/src/main.c 0000644 0001750 0000000 00000075504 14777762222 012401 0000000 0000000 /*
* PgBouncer - Lightweight connection pooler for PostgreSQL.
*
* Copyright (c) 2007-2009 Marko Kreen, Skype Technologies OÜ
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
* Launcher for all the rest.
*/
#include "bouncer.h"
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef WIN32
#include "win32support.h"
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include
#endif
static void usage(const char *exe)
{
printf("%s is a connection pooler for PostgreSQL.\n\n", exe);
printf("Usage:\n");
printf(" %s [OPTION]... CONFIG_FILE\n", exe);
printf("\nOptions:\n");
printf(" -d, --daemon run in background (as a daemon)\n");
printf(" -q, --quiet run quietly\n");
printf(" -R, --reboot do an online reboot\n");
printf(" -u, --user=USERNAME assume identity of USERNAME\n");
printf(" -v, --verbose increase verbosity\n");
printf(" -V, --version show version, then exit\n");
printf(" -h, --help show this help, then exit\n");
printf("\n");
#ifdef WIN32
printf("Windows service registration:\n");
printf(" --regservice CONFIG_FILE [-U USERNAME [-P PASSWORD]]\n");
printf(" --unregservice CONFIG_FILE\n");
printf("\n");
#endif
printf("Report bugs to <%s>.\n", PACKAGE_BUGREPORT);
printf("%s home page: <%s>\n", PACKAGE_NAME, PACKAGE_URL);
exit(0);
}
/* global libevent handle */
struct event_base *pgb_event_base;
/* async dns handler */
struct DNSContext *adns;
struct HBA *parsed_hba;
struct Ident *parsed_ident;
/*
* configuration storage
*/
int cf_daemon;
int cf_pause_mode = P_NONE;
int cf_shutdown = SHUTDOWN_NONE;
int cf_reboot;
static char *global_username;
char *cf_config_file;
char *cf_listen_addr;
int cf_listen_port;
int cf_listen_backlog;
char *cf_unix_socket_dir;
int cf_unix_socket_mode;
char *cf_unix_socket_group;
int cf_peer_id;
int cf_pool_mode = POOL_SESSION;
/* sbuf config */
int cf_sbuf_len;
int cf_sbuf_loopcnt;
int cf_so_reuseport;
int cf_tcp_socket_buffer;
int cf_tcp_defer_accept;
#if defined(TCP_DEFER_ACCEPT)
#define DEFAULT_TCP_DEFER_ACCEPT "1"
#else
#define DEFAULT_TCP_DEFER_ACCEPT "0"
#endif
int cf_tcp_keepalive;
int cf_tcp_keepcnt;
int cf_tcp_keepidle;
int cf_tcp_keepintvl;
int cf_tcp_user_timeout;
int cf_auth_type = AUTH_TYPE_MD5;
char *cf_auth_file;
char *cf_auth_hba_file;
char *cf_auth_ident_file;
char *cf_auth_user;
char *cf_auth_query;
char *cf_auth_dbname;
char *cf_track_extra_parameters;
int cf_max_client_conn;
int cf_default_pool_size;
int cf_min_pool_size;
int cf_res_pool_size;
usec_t cf_res_pool_timeout;
int cf_max_db_connections;
int cf_max_db_client_connections;
int cf_max_user_connections;
int cf_max_user_client_connections;
char *cf_server_reset_query;
int cf_server_reset_query_always;
char *cf_server_check_query;
usec_t cf_server_check_delay;
int cf_server_fast_close;
int cf_server_round_robin;
int cf_disable_pqexec;
usec_t cf_dns_max_ttl;
usec_t cf_dns_nxdomain_ttl;
usec_t cf_dns_zone_check_period;
char *cf_resolv_conf;
unsigned int cf_max_packet_size;
char *cf_ignore_startup_params;
char *cf_autodb_connstr; /* here is "" different from NULL */
usec_t cf_autodb_idle_timeout;
usec_t cf_server_lifetime;
usec_t cf_server_idle_timeout;
usec_t cf_server_connect_timeout;
usec_t cf_server_login_retry;
usec_t cf_query_timeout;
usec_t cf_query_wait_timeout;
usec_t cf_cancel_wait_timeout;
usec_t cf_client_idle_timeout;
usec_t cf_client_login_timeout;
usec_t cf_idle_transaction_timeout;
usec_t cf_suspend_timeout;
usec_t g_suspend_start;
char *cf_pidfile;
char *cf_jobname;
char *cf_admin_users;
char *cf_stats_users;
int cf_stats_period;
int cf_log_stats;
int cf_log_connections;
int cf_log_disconnections;
int cf_log_pooler_errors;
int cf_application_name_add_host;
int cf_client_tls_sslmode;
char *cf_client_tls_protocols;
char *cf_client_tls_ca_file;
char *cf_client_tls_cert_file;
char *cf_client_tls_key_file;
char *cf_client_tls_ciphers;
char *cf_client_tls_dheparams;
char *cf_client_tls_ecdhecurve;
int cf_server_tls_sslmode;
char *cf_server_tls_protocols;
char *cf_server_tls_ca_file;
char *cf_server_tls_cert_file;
char *cf_server_tls_key_file;
char *cf_server_tls_ciphers;
int cf_max_prepared_statements;
/*
* config file description
*/
static bool set_defer_accept(struct CfValue *cv, const char *val);
#define DEFER_OPS {set_defer_accept, cf_get_int}
static const struct CfLookup auth_type_map[] = {
{ "any", AUTH_TYPE_ANY },
{ "trust", AUTH_TYPE_TRUST },
{ "plain", AUTH_TYPE_PLAIN },
{ "md5", AUTH_TYPE_MD5 },
{ "cert", AUTH_TYPE_CERT },
{ "hba", AUTH_TYPE_HBA },
#ifdef HAVE_PAM
{ "pam", AUTH_TYPE_PAM },
#endif
{ "scram-sha-256", AUTH_TYPE_SCRAM_SHA_256 },
{ NULL }
};
const struct CfLookup pool_mode_map[] = {
{ "session", POOL_SESSION },
{ "transaction", POOL_TX },
{ "statement", POOL_STMT },
{ NULL }
};
const struct CfLookup sslmode_map[] = {
{ "disable", SSLMODE_DISABLED },
{ "allow", SSLMODE_ALLOW },
{ "prefer", SSLMODE_PREFER },
{ "require", SSLMODE_REQUIRE },
{ "verify-ca", SSLMODE_VERIFY_CA },
{ "verify-full", SSLMODE_VERIFY_FULL },
{ NULL }
};
const struct CfLookup load_balance_hosts_map[] = {
{ "disable", LOAD_BALANCE_HOSTS_DISABLE },
{ "round-robin", LOAD_BALANCE_HOSTS_ROUND_ROBIN },
{ NULL }
};
/*
* Add new parameters in alphabetical order. This order is used by SHOW CONFIG.
*/
static const struct CfKey bouncer_params [] = {
CF_ABS("admin_users", CF_STR, cf_admin_users, 0, ""),
CF_ABS("application_name_add_host", CF_INT, cf_application_name_add_host, 0, "0"),
CF_ABS("auth_dbname", CF_AUTHDB, cf_auth_dbname, 0, NULL),
CF_ABS("auth_file", CF_STR, cf_auth_file, 0, NULL),
CF_ABS("auth_hba_file", CF_STR, cf_auth_hba_file, 0, ""),
CF_ABS("auth_ident_file", CF_STR, cf_auth_ident_file, 0, NULL),
CF_ABS("auth_query", CF_STR, cf_auth_query, 0, "SELECT rolname, CASE WHEN rolvaliduntil < now() THEN NULL ELSE rolpassword END FROM pg_authid WHERE rolname=$1 AND rolcanlogin"),
CF_ABS("auth_type", CF_LOOKUP(auth_type_map), cf_auth_type, 0, "md5"),
CF_ABS("auth_user", CF_STR, cf_auth_user, 0, NULL),
CF_ABS("autodb_idle_timeout", CF_TIME_USEC, cf_autodb_idle_timeout, 0, "3600"),
CF_ABS("client_idle_timeout", CF_TIME_USEC, cf_client_idle_timeout, 0, "0"),
CF_ABS("client_login_timeout", CF_TIME_USEC, cf_client_login_timeout, 0, "60"),
CF_ABS("client_tls_ca_file", CF_STR, cf_client_tls_ca_file, 0, ""),
CF_ABS("client_tls_cert_file", CF_STR, cf_client_tls_cert_file, 0, ""),
CF_ABS("client_tls_ciphers", CF_STR, cf_client_tls_ciphers, 0, "default"),
CF_ABS("client_tls_dheparams", CF_STR, cf_client_tls_dheparams, 0, "auto"),
CF_ABS("client_tls_ecdhcurve", CF_STR, cf_client_tls_ecdhecurve, 0, "auto"),
CF_ABS("client_tls_key_file", CF_STR, cf_client_tls_key_file, 0, ""),
CF_ABS("client_tls_protocols", CF_STR, cf_client_tls_protocols, 0, "secure"),
CF_ABS("client_tls_sslmode", CF_LOOKUP(sslmode_map), cf_client_tls_sslmode, 0, "disable"),
CF_ABS("conffile", CF_STR, cf_config_file, 0, NULL),
CF_ABS("default_pool_size", CF_INT, cf_default_pool_size, 0, "20"),
CF_ABS("disable_pqexec", CF_INT, cf_disable_pqexec, CF_NO_RELOAD, "0"),
CF_ABS("dns_max_ttl", CF_TIME_USEC, cf_dns_max_ttl, 0, "15"),
CF_ABS("dns_nxdomain_ttl", CF_TIME_USEC, cf_dns_nxdomain_ttl, 0, "15"),
CF_ABS("dns_zone_check_period", CF_TIME_USEC, cf_dns_zone_check_period, 0, "0"),
CF_ABS("idle_transaction_timeout", CF_TIME_USEC, cf_idle_transaction_timeout, 0, "0"),
CF_ABS("ignore_startup_parameters", CF_STR, cf_ignore_startup_params, 0, ""),
CF_ABS("job_name", CF_STR, cf_jobname, CF_NO_RELOAD, "pgbouncer"),
CF_ABS("listen_addr", CF_STR, cf_listen_addr, CF_NO_RELOAD, ""),
CF_ABS("listen_backlog", CF_INT, cf_listen_backlog, CF_NO_RELOAD, "128"),
CF_ABS("listen_port", CF_INT, cf_listen_port, CF_NO_RELOAD, "6432"),
CF_ABS("log_connections", CF_INT, cf_log_connections, 0, "1"),
CF_ABS("log_disconnections", CF_INT, cf_log_disconnections, 0, "1"),
CF_ABS("log_pooler_errors", CF_INT, cf_log_pooler_errors, 0, "1"),
CF_ABS("log_stats", CF_INT, cf_log_stats, 0, "1"),
CF_ABS("logfile", CF_STR, cf_logfile, 0, ""),
CF_ABS("max_client_conn", CF_INT, cf_max_client_conn, 0, "100"),
CF_ABS("max_db_connections", CF_INT, cf_max_db_connections, 0, "0"),
CF_ABS("max_db_client_connections", CF_INT, cf_max_db_client_connections, 0, "0"),
CF_ABS("max_packet_size", CF_UINT, cf_max_packet_size, 0, "2147483647"),
CF_ABS("max_prepared_statements", CF_INT, cf_max_prepared_statements, 0, "200"),
CF_ABS("max_user_connections", CF_INT, cf_max_user_connections, 0, "0"),
CF_ABS("max_user_client_connections", CF_INT, cf_max_user_client_connections, 0, "0"),
CF_ABS("min_pool_size", CF_INT, cf_min_pool_size, 0, "0"),
CF_ABS("peer_id", CF_INT, cf_peer_id, 0, "0"),
CF_ABS("pidfile", CF_STR, cf_pidfile, CF_NO_RELOAD, ""),
CF_ABS("pkt_buf", CF_INT, cf_sbuf_len, CF_NO_RELOAD, "4096"),
CF_ABS("pool_mode", CF_LOOKUP(pool_mode_map), cf_pool_mode, 0, "session"),
CF_ABS("query_timeout", CF_TIME_USEC, cf_query_timeout, 0, "0"),
CF_ABS("query_wait_timeout", CF_TIME_USEC, cf_query_wait_timeout, 0, "120"),
CF_ABS("cancel_wait_timeout", CF_TIME_USEC, cf_cancel_wait_timeout, 0, "10"),
CF_ABS("reserve_pool_size", CF_INT, cf_res_pool_size, 0, "0"),
CF_ABS("reserve_pool_timeout", CF_TIME_USEC, cf_res_pool_timeout, 0, "5"),
CF_ABS("resolv_conf", CF_STR, cf_resolv_conf, CF_NO_RELOAD, ""),
CF_ABS("sbuf_loopcnt", CF_INT, cf_sbuf_loopcnt, 0, "5"),
CF_ABS("server_check_delay", CF_TIME_USEC, cf_server_check_delay, 0, "30"),
CF_ABS("server_check_query", CF_STR, cf_server_check_query, 0, "select 1"),
CF_ABS("server_connect_timeout", CF_TIME_USEC, cf_server_connect_timeout, 0, "15"),
CF_ABS("server_fast_close", CF_INT, cf_server_fast_close, 0, "0"),
CF_ABS("server_idle_timeout", CF_TIME_USEC, cf_server_idle_timeout, 0, "600"),
CF_ABS("server_lifetime", CF_TIME_USEC, cf_server_lifetime, 0, "3600"),
CF_ABS("server_login_retry", CF_TIME_USEC, cf_server_login_retry, 0, "15"),
CF_ABS("server_reset_query", CF_STR, cf_server_reset_query, 0, "DISCARD ALL"),
CF_ABS("server_reset_query_always", CF_INT, cf_server_reset_query_always, 0, "0"),
CF_ABS("server_round_robin", CF_INT, cf_server_round_robin, 0, "0"),
CF_ABS("server_tls_ca_file", CF_STR, cf_server_tls_ca_file, 0, ""),
CF_ABS("server_tls_cert_file", CF_STR, cf_server_tls_cert_file, 0, ""),
CF_ABS("server_tls_ciphers", CF_STR, cf_server_tls_ciphers, 0, "default"),
CF_ABS("server_tls_key_file", CF_STR, cf_server_tls_key_file, 0, ""),
CF_ABS("server_tls_protocols", CF_STR, cf_server_tls_protocols, 0, "secure"),
CF_ABS("server_tls_sslmode", CF_LOOKUP(sslmode_map), cf_server_tls_sslmode, 0, "prefer"),
#ifdef WIN32
CF_ABS("service_name", CF_STR, cf_jobname, CF_NO_RELOAD, NULL), /* alias for job_name */
#endif
CF_ABS("so_reuseport", CF_INT, cf_so_reuseport, CF_NO_RELOAD, "0"),
CF_ABS("stats_period", CF_INT, cf_stats_period, 0, "60"),
CF_ABS("stats_users", CF_STR, cf_stats_users, 0, ""),
CF_ABS("suspend_timeout", CF_TIME_USEC, cf_suspend_timeout, 0, "10"),
CF_ABS("syslog", CF_INT, cf_syslog, 0, "0"),
CF_ABS("syslog_facility", CF_STR, cf_syslog_facility, 0, "daemon"),
CF_ABS("syslog_ident", CF_STR, cf_syslog_ident, 0, "pgbouncer"),
CF_ABS("tcp_defer_accept", DEFER_OPS, cf_tcp_defer_accept, 0, DEFAULT_TCP_DEFER_ACCEPT),
CF_ABS("tcp_keepalive", CF_INT, cf_tcp_keepalive, 0, "1"),
CF_ABS("tcp_keepcnt", CF_INT, cf_tcp_keepcnt, 0, "0"),
CF_ABS("tcp_keepidle", CF_INT, cf_tcp_keepidle, 0, "0"),
CF_ABS("tcp_keepintvl", CF_INT, cf_tcp_keepintvl, 0, "0"),
CF_ABS("tcp_socket_buffer", CF_INT, cf_tcp_socket_buffer, 0, "0"),
CF_ABS("tcp_user_timeout", CF_INT, cf_tcp_user_timeout, 0, "0"),
CF_ABS("track_extra_parameters", CF_STR, cf_track_extra_parameters, CF_NO_RELOAD, "IntervalStyle"),
CF_ABS("unix_socket_dir", CF_STR, cf_unix_socket_dir, CF_NO_RELOAD, DEFAULT_UNIX_SOCKET_DIR),
#ifndef WIN32
CF_ABS("unix_socket_group", CF_STR, cf_unix_socket_group, CF_NO_RELOAD, ""),
CF_ABS("unix_socket_mode", CF_INT, cf_unix_socket_mode, CF_NO_RELOAD, "0777"),
#endif
#ifndef WIN32
CF_ABS("user", CF_STR, global_username, CF_NO_RELOAD, NULL),
#endif
CF_ABS("verbose", CF_INT, cf_verbose, 0, NULL),
{NULL}
};
static const struct CfSect config_sects [] = {
{
.sect_name = "pgbouncer",
.key_list = bouncer_params,
}, {
.sect_name = "databases",
.set_key = parse_database,
}, {
.sect_name = "users",
.set_key = parse_user,
}, {
.sect_name = "peers",
.set_key = parse_peer,
}, {
.sect_name = NULL,
}
};
static struct CfContext main_config = { config_sects, };
bool set_config_param(const char *key, const char *val)
{
return cf_set(&main_config, "pgbouncer", key, val);
}
void config_for_each(void (*param_cb)(void *arg, const char *name, const char *val, const char *defval, bool reloadable),
void *arg)
{
const struct CfKey *k = bouncer_params;
char buf[256];
bool reloadable;
const char *val;
int ro = CF_NO_RELOAD | CF_READONLY;
for (; k->key_name; k++) {
val = cf_get(&main_config, "pgbouncer", k->key_name, buf, sizeof(buf));
reloadable = (k->flags & ro) == 0;
param_cb(arg, k->key_name, val, k->def_value, reloadable);
}
}
static bool set_defer_accept(struct CfValue *cv, const char *val)
{
int *p = cv->value_p;
bool ok;
int oldval = *p;
ok = cf_set_int(cv, val);
if (ok && !!oldval != !!*p)
pooler_tune_accept(*p);
return ok;
}
static void set_dbs_dead(bool flag)
{
struct List *item;
PgDatabase *db;
statlist_for_each(item, &database_list) {
db = container_of(item, PgDatabase, head);
if (db->admin)
continue;
if (db->db_auto)
continue;
db->db_dead = flag;
}
}
static void set_peers_dead(bool flag)
{
struct List *item;
PgDatabase *db;
statlist_for_each(item, &peer_list) {
db = container_of(item, PgDatabase, head);
db->db_dead = flag;
}
}
/* Tells if the specified auth type requires data from the auth file. */
static bool requires_auth_file(int auth_type)
{
/* For PAM authentication auth file is not used */
if (auth_type == AUTH_TYPE_PAM)
return false;
return auth_type >= AUTH_TYPE_TRUST;
}
/* config loading, tries to be tolerant to errors */
void load_config(void)
{
static bool loaded = false;
bool ok;
any_user_level_timeout_set = false;
any_user_level_client_timeout_set = false;
set_dbs_dead(true);
set_peers_dead(true);
/* actual loading */
ok = cf_load_file(&main_config, cf_config_file);
if (ok) {
/* load users if needed */
if (requires_auth_file(cf_auth_type))
loader_users_check();
loaded = true;
} else if (!loaded) {
die("cannot load config file");
} else {
log_warning("config file loading failed");
/* if ini file missing, don't kill anybody */
set_dbs_dead(false);
}
if (cf_auth_type == AUTH_TYPE_HBA) {
struct Ident *ident;
struct HBA *hba;
ident = ident_load_map(cf_auth_ident_file);
if (ident) {
ident_free(parsed_ident);
parsed_ident = ident;
}
hba = hba_load_rules(cf_auth_hba_file, parsed_ident);
if (hba) {
hba_free(parsed_hba);
parsed_hba = hba;
}
} else {
hba_free(parsed_hba);
parsed_hba = NULL;
}
/* kill dbs */
config_postprocess();
/* reopen logfile */
if (main_config.loaded)
reset_logging();
}
/*
* signal handling.
*
* handle_* functions are not actual signal handlers but called from
* event_loop() so they have no restrictions what they can do.
*/
static struct event ev_sigterm;
static struct event ev_sigint;
static void handle_sigterm(evutil_socket_t sock, short flags, void *arg)
{
if (cf_shutdown) {
log_info("got SIGTERM while shutting down, fast exit");
/* pidfile cleanup happens via atexit() */
exit(0);
}
log_info("got SIGTERM, shutting down, waiting for all clients disconnect");
sd_notify(0, "STOPPING=1");
if (cf_reboot)
die("takeover was in progress, going down immediately");
if (cf_pause_mode == P_SUSPEND)
die("suspend was in progress, going down immediately");
cf_shutdown = SHUTDOWN_WAIT_FOR_CLIENTS;
cleanup_sockets();
}
static void handle_sigint(evutil_socket_t sock, short flags, void *arg)
{
if (cf_shutdown) {
log_info("got SIGINT while shutting down, fast exit");
/* pidfile cleanup happens via atexit() */
exit(0);
}
log_info("got SIGINT, shutting down, waiting for all servers connections to be released");
sd_notify(0, "STOPPING=1");
if (cf_reboot)
die("takeover was in progress, going down immediately");
if (cf_pause_mode == P_SUSPEND)
die("suspend was in progress, going down immediately");
cf_pause_mode = P_PAUSE;
cf_shutdown = SHUTDOWN_WAIT_FOR_SERVERS;
cleanup_sockets();
}
#ifndef WIN32
static struct event ev_sigquit;
static struct event ev_sigusr1;
static struct event ev_sigusr2;
static struct event ev_sighup;
static void handle_sigquit(evutil_socket_t sock, short flags, void *arg)
{
log_info("got SIGQUIT, fast exit");
/* pidfile cleanup happens via atexit() */
exit(0);
}
static void handle_sigusr1(int sock, short flags, void *arg)
{
if (cf_pause_mode == P_NONE) {
log_info("got SIGUSR1, pausing all activity");
cf_pause_mode = P_PAUSE;
} else {
log_info("got SIGUSR1, but already paused/suspended");
}
}
static void handle_sigusr2(int sock, short flags, void *arg)
{
if (cf_shutdown) {
log_info("got SIGUSR2 while shutting down, ignoring");
return;
}
switch (cf_pause_mode) {
case P_SUSPEND:
log_info("got SIGUSR2, continuing from SUSPEND");
resume_all();
cf_pause_mode = P_NONE;
break;
case P_PAUSE:
log_info("got SIGUSR2, continuing from PAUSE");
cf_pause_mode = P_NONE;
break;
case P_NONE:
log_info("got SIGUSR2, but not paused/suspended");
}
}
/*
* Notify systemd that we are reloading, including a CLOCK_MONOTONIC timestamp
* in usec so that the program is compatible with a Type=notify-reload service.
*
* See https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html
*/
static void notify_reloading(void)
{
#ifdef USE_SYSTEMD
struct timespec ts;
usec_t usec;
clock_gettime(CLOCK_MONOTONIC, &ts);
usec = (usec_t)ts.tv_sec * USEC + (usec_t)ts.tv_nsec / (usec_t)1000;
sd_notifyf(0, "RELOADING=1\nMONOTONIC_USEC=%" PRIu64, usec);
#endif
}
static void handle_sighup(int sock, short flags, void *arg)
{
log_info("got SIGHUP, re-reading config");
notify_reloading();
load_config();
if (!sbuf_tls_setup())
log_error("TLS configuration could not be reloaded, keeping old configuration");
sd_notify(0, "READY=1");
}
#endif
static void signal_setup(void)
{
int err;
#ifndef WIN32
sigset_t set;
/* block SIGPIPE */
sigemptyset(&set);
sigaddset(&set, SIGPIPE);
err = sigprocmask(SIG_BLOCK, &set, NULL);
if (err < 0)
fatal_perror("sigprocmask");
/* install handlers */
evsignal_assign(&ev_sigusr1, pgb_event_base, SIGUSR1, handle_sigusr1, NULL);
err = evsignal_add(&ev_sigusr1, NULL);
if (err < 0)
fatal_perror("evsignal_add");
evsignal_assign(&ev_sigusr2, pgb_event_base, SIGUSR2, handle_sigusr2, NULL);
err = evsignal_add(&ev_sigusr2, NULL);
if (err < 0)
fatal_perror("evsignal_add");
evsignal_assign(&ev_sighup, pgb_event_base, SIGHUP, handle_sighup, NULL);
err = evsignal_add(&ev_sighup, NULL);
if (err < 0)
fatal_perror("evsignal_add");
evsignal_assign(&ev_sigquit, pgb_event_base, SIGQUIT, handle_sigquit, NULL);
err = evsignal_add(&ev_sigquit, NULL);
if (err < 0)
fatal_perror("evsignal_add");
#endif
evsignal_assign(&ev_sigterm, pgb_event_base, SIGTERM, handle_sigterm, NULL);
err = evsignal_add(&ev_sigterm, NULL);
if (err < 0)
fatal_perror("evsignal_add");
evsignal_assign(&ev_sigint, pgb_event_base, SIGINT, handle_sigint, NULL);
err = evsignal_add(&ev_sigint, NULL);
if (err < 0)
fatal_perror("evsignal_add");
}
/*
* daemon mode
*/
static void go_daemon(void)
{
int pid, fd;
#ifdef WIN32
die("option --daemon (-d) is not supported on this platform");
#endif
if (!cf_pidfile || !cf_pidfile[0])
die("daemon needs pidfile configured");
/* don't log to stdout anymore */
cf_quiet = 1;
/* send stdin, stdout, stderr to /dev/null */
fd = open("/dev/null", O_RDWR);
if (fd < 0)
die("could not open /dev/null: %s", strerror(errno));
dup2(fd, 0);
dup2(fd, 1);
dup2(fd, 2);
if (fd > 2)
close(fd);
/* fork new process */
pid = fork();
if (pid < 0)
die("fork failed: %s", strerror(errno));
if (pid > 0)
_exit(0);
/* create new session */
pid = setsid();
if (pid < 0)
die("setsid failed: %s", strerror(errno));
/* fork again to avoid being session leader */
pid = fork();
if (pid < 0)
die("fork failed: %s", strerror(errno));
if (pid > 0)
_exit(0);
}
/*
* pidfile management.
*/
static void remove_pidfile(void)
{
if (cf_pidfile) {
if (cf_pidfile[0])
unlink(cf_pidfile);
free(cf_pidfile);
cf_pidfile = NULL;
}
}
static void check_pidfile(void)
{
char buf[128 + 1];
pid_t pid = 0;
int fd, res, err;
if (!cf_pidfile || !cf_pidfile[0])
return;
/* read old pid */
fd = open(cf_pidfile, O_RDONLY);
if (fd < 0) {
if (errno == ENOENT)
return;
die("could not open pidfile '%s': %s", cf_pidfile, strerror(errno));
}
res = read(fd, buf, sizeof(buf) - 1);
close(fd);
if (res < 0)
die("could not read pidfile '%s': %s", cf_pidfile, strerror(errno));
if (res == 0)
goto locked_pidfile;
/* parse pid */
buf[res] = 0;
pid = atol(buf);
if (pid <= 0)
goto locked_pidfile;
/* check if running */
if (kill(pid, 0) >= 0)
goto locked_pidfile;
if (errno != ESRCH)
goto locked_pidfile;
/* seems the pidfile is not in use */
log_info("stale pidfile, removing");
err = unlink(cf_pidfile);
if (err != 0)
die("could not remove stale pidfile: %s", strerror(errno));
return;
locked_pidfile:
die("pidfile '%s' exists, another instance running?", cf_pidfile);
}
static void write_pidfile(void)
{
char buf[64];
pid_t pid;
int res, fd;
if (!cf_pidfile || !cf_pidfile[0])
return;
pid = getpid();
snprintf(buf, sizeof(buf), "%u\n", (unsigned)pid);
fd = open(cf_pidfile, O_WRONLY | O_CREAT | O_EXCL, 0644);
if (fd < 0)
die("could not open pidfile '%s': %s", cf_pidfile, strerror(errno));
res = safe_write(fd, buf, strlen(buf));
if (res < 0)
die("could not write pidfile '%s': %s", cf_pidfile, strerror(errno));
close(fd);
/* only remove when we have it actually written */
atexit(remove_pidfile);
}
/* just print out max files, in the future may warn if something is off */
static void check_limits(void)
{
struct rlimit lim;
int total_users = statlist_count(&user_list);
int fd_count;
int err;
struct List *item;
PgDatabase *db;
log_noise("event: %d, SBuf: %d, PgSocket: %d, IOBuf: %d",
(int)sizeof(struct event), (int)sizeof(SBuf),
(int)sizeof(PgSocket), (int)IOBUF_SIZE);
/* load limits */
err = getrlimit(RLIMIT_NOFILE, &lim);
if (err < 0) {
log_error("could not get RLIMIT_NOFILE: %s", strerror(errno));
return;
}
/* calculate theoretical max, +10 is just in case */
fd_count = cf_max_client_conn + 10;
statlist_for_each(item, &database_list) {
db = container_of(item, PgDatabase, head);
if (db->forced_user_credentials)
fd_count += (db->pool_size >= 0 ? db->pool_size : cf_default_pool_size);
else
fd_count += (db->pool_size >= 0 ? db->pool_size : cf_default_pool_size) * total_users;
}
log_info("kernel file descriptor limit: %d (hard: %d); max_client_conn: %d, max expected fd use: %d",
(int)lim.rlim_cur, (int)lim.rlim_max, cf_max_client_conn, fd_count);
}
static bool check_old_process_unix(void)
{
struct sockaddr_un sa_un;
socklen_t len = sizeof(sa_un);
int domain = AF_UNIX;
int res, fd;
if (!cf_unix_socket_dir || !*cf_unix_socket_dir || sd_listen_fds(0) > 0)
return false;
memset(&sa_un, 0, len);
sa_un.sun_family = domain;
snprintf(sa_un.sun_path, sizeof(sa_un.sun_path),
"%s/.s.PGSQL.%d", cf_unix_socket_dir, cf_listen_port);
fd = socket(domain, SOCK_STREAM, 0);
if (fd < 0)
die("could not create socket: %s", strerror(errno));
res = safe_connect(fd, (struct sockaddr *)&sa_un, len);
safe_close(fd);
if (res < 0)
return false;
return true;
}
static void main_loop_once(void)
{
int err;
reset_time_cache();
err = event_base_loop(pgb_event_base, EVLOOP_ONCE);
if (err < 0) {
if (errno != EINTR)
log_warning("event_loop failed: %s", strerror(errno));
}
pam_poll();
per_loop_maint();
reuse_just_freed_objects();
rescue_timers();
per_loop_pooler_maint();
if (adns)
adns_per_loop(adns);
}
static void takeover_part1(void)
{
/* use temporary libevent base */
struct event_base *evtmp;
evtmp = pgb_event_base;
pgb_event_base = event_base_new();
if (!cf_unix_socket_dir || !*cf_unix_socket_dir)
die("cannot reboot if unix dir not configured");
/*
* Takeover with abstract Unix socket doesn't work because the
* new process can't unlink the socket used by the old process
* and put its own in place (see create_unix_socket()).
*/
if (cf_unix_socket_dir[0] == '@')
die("cannot reboot with abstract Unix socket");
if (sd_listen_fds(0) > 0)
die("cannot reboot under service manager");
takeover_init();
while (cf_reboot)
main_loop_once();
event_base_free(pgb_event_base);
pgb_event_base = evtmp;
}
static void dns_setup(void)
{
if (adns)
return;
adns = adns_create_context();
if (!adns)
die("dns setup failed");
}
static void xfree(char **ptr_p)
{
if (*ptr_p) {
free(*ptr_p);
*ptr_p = NULL;
}
}
_UNUSED
static void cleanup(void)
{
/*
* We don't want to cleanup when we're the target of a takeover, because
* that would close the sockets that we hand over. There's no real clean
* way to detect that we were the target, so the below check is rather
* crude. But since this cleanup is only happening in builds with asserts
* enabled anyway it seems fine.
*/
if (cf_pause_mode == P_SUSPEND && cf_shutdown == SHUTDOWN_IMMEDIATE) {
return;
}
adns_free_context(adns);
adns = NULL;
hba_free(parsed_hba);
parsed_hba = NULL;
ident_free(parsed_ident);
parsed_ident = NULL;
admin_cleanup();
objects_cleanup();
sbuf_cleanup();
event_base_free(pgb_event_base);
tls_deinit();
varcache_deinit();
pktbuf_cleanup();
reset_logging();
xfree(&global_username);
xfree(&cf_config_file);
xfree(&cf_listen_addr);
xfree(&cf_unix_socket_dir);
xfree(&cf_unix_socket_group);
xfree(&cf_auth_file);
xfree(&cf_auth_ident_file);
xfree(&cf_auth_dbname);
xfree(&cf_auth_hba_file);
xfree(&cf_auth_query);
xfree(&cf_auth_user);
xfree(&cf_server_reset_query);
xfree(&cf_server_check_query);
xfree(&cf_ignore_startup_params);
xfree(&cf_autodb_connstr);
xfree(&cf_jobname);
xfree(&cf_admin_users);
xfree(&cf_stats_users);
xfree(&cf_client_tls_protocols);
xfree(&cf_client_tls_ca_file);
xfree(&cf_client_tls_cert_file);
xfree(&cf_client_tls_key_file);
xfree(&cf_client_tls_ciphers);
xfree(&cf_client_tls_dheparams);
xfree(&cf_client_tls_ecdhecurve);
xfree(&cf_server_tls_protocols);
xfree(&cf_server_tls_ca_file);
xfree(&cf_server_tls_cert_file);
xfree(&cf_server_tls_key_file);
xfree(&cf_server_tls_ciphers);
xfree((char **)&cf_logfile);
xfree((char **)&cf_syslog_ident);
xfree((char **)&cf_syslog_facility);
xfree(&cf_track_extra_parameters);
}
/* boot everything */
int main(int argc, char *argv[])
{
int c;
bool did_takeover = false;
char *arg_username = NULL;
int long_idx;
static const struct option long_options[] = {
{"quiet", no_argument, NULL, 'q'},
{"verbose", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{"daemon", no_argument, NULL, 'd'},
{"version", no_argument, NULL, 'V'},
{"reboot", no_argument, NULL, 'R'},
{"user", required_argument, NULL, 'u'},
{NULL, 0, NULL, 0}
};
setprogname(basename(argv[0]));
/* parse cmdline */
while ((c = getopt_long(argc, argv, "qvhdVRu:", long_options, &long_idx)) != -1) {
switch (c) {
case 'R':
cf_reboot = 1;
break;
case 'v':
cf_verbose++;
break;
case 'V':
printf("%s\n", PACKAGE_STRING);
printf("libevent %s\nadns: %s\ntls: %s\n",
event_get_version(),
adns_get_backend(),
tls_backend_version());
#ifdef USE_SYSTEMD
printf("systemd: yes\n");
#endif
return 0;
case 'd':
cf_daemon = 1;
break;
case 'q':
cf_quiet = 1;
break;
case 'u':
arg_username = optarg;
break;
case 'h':
usage(argv[0]);
break;
default:
fprintf(stderr, "Try \"%s --help\" for more information.\n", argv[0]);
exit(1);
break;
}
}
if (optind + 1 != argc) {
fprintf(stderr, "%s: no configuration file specified\n", argv[0]);
fprintf(stderr, "Try \"%s --help\" for more information.\n", argv[0]);
exit(1);
}
cf_config_file = xstrdup(argv[optind]);
#ifdef CASSERT
/*
* Clean up all objects at the end, only for testing the
* cleanup code, not useful for production. This must be the
* first atexit() call, since other atexit() handlers still
* make use of things that will be cleaned up.
*/
atexit(cleanup);
#endif
init_objects();
load_config();
main_config.loaded = true;
init_var_lookup(cf_track_extra_parameters);
init_caches();
logging_prefix_cb = log_socket_prefix;
if (!sbuf_tls_setup())
die("TLS setup failed");
/* prefer cmdline over config for username */
if (arg_username) {
free(global_username);
global_username = xstrdup(arg_username);
}
/* switch user is needed */
if (global_username && *global_username)
change_user(global_username);
/* disallow running as root */
if (getuid() == 0)
die("PgBouncer should not run as root");
admin_setup();
if (cf_reboot) {
log_warning("Online restart is deprecated, use so_reuseport instead");
if (check_old_process_unix()) {
takeover_part1();
did_takeover = true;
} else {
log_info("old process not found, try to continue normally");
cf_reboot = 0;
check_pidfile();
}
} else {
if (check_old_process_unix())
die("unix socket is in use, cannot continue");
check_pidfile();
}
if (cf_daemon)
go_daemon();
#ifndef USE_SYSTEMD
if (getenv("NOTIFY_SOCKET"))
log_warning("apparently running under systemd with notify socket, but systemd support was not built");
#endif
/* need to do that after loading config; also do after
* go_daemon() so that output goes to log file */
check_limits();
/* initialize subsystems, order important */
srandom(time(NULL) ^ getpid());
if (!(pgb_event_base = event_base_new()))
die("event_base_new() failed");
dns_setup();
signal_setup();
janitor_setup();
stats_setup();
pam_init();
if (did_takeover) {
takeover_finish();
} else {
pooler_setup();
}
write_pidfile();
log_info("process up: %s, libevent %s (%s), adns: %s, tls: %s", PACKAGE_STRING,
event_get_version(), event_base_get_method(pgb_event_base), adns_get_backend(),
tls_backend_version());
sd_notify(0, "READY=1");
/* main loop */
while (cf_shutdown != SHUTDOWN_IMMEDIATE)
main_loop_once();
return 0;
}
pgbouncer-1.24.1/AUTHORS 0000644 0001750 0000000 00000001460 14777762222 011560 0000000 0000000 Maintainers
-----------
Peter Eisentraut
Maintainers emeriti
-------------------
Marko Kreen
Petr Jelinek
Contributors
------------
Alexander Schöcke
Andrew Dunstan
Bjoern Metzdorf
Bob Poekert
Christoph Berg
Cody Cutrer
Dan McGee
David Fetter
David Galoyan
David Sommerseth
Devrim GÃœNDÃœZ
Dimitri Fontaine
Dmitriy Olshevskiy
Dominique Hermsdorff
Emmanuel Courreges
Eric Radman
Euler Taveira
Filip Rembiałkowski
Giorgio Valoti
Guillaume Aubert
Guillaume Lelarge
Greg Sabino Mullane
Hannu Krosing
Heikki Linnakangas
Hiroshi Saito
Hubert Depesz Lubaczewski
Jacob Coby
James Pye
Jørgen Austvik
Lou Picciano
Magne Mæhre
Magnus Hagander
Martin Pihlak
Mathieu Fenniak
Michael Tharp
Michał Trojnara
Matan Ryngler
Pavel Stehule
Pierre-Emmanuel André
Rich Schaaf
Robert Gogolok
Sam McLeod
Teodor Sigaev
William Grant
pgbouncer-1.24.1/configure 0000775 0001750 0001750 00001056063 14777762315 012453 0000000 0000000 #! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.71 for PgBouncer 1.24.1.
#
# Report bugs to .
#
#
# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation,
# Inc.
#
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##
# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
as_nop=:
if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else $as_nop
case `(set -o) 2>/dev/null` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
fi
# Reset variables that may have inherited troublesome values from
# the environment.
# IFS needs to be set, to space, tab, and newline, in precisely that order.
# (If _AS_PATH_WALK were called with IFS unset, it would have the
# side effect of setting IFS to empty, thus disabling word splitting.)
# Quoting is to prevent editors from complaining about space-tab.
as_nl='
'
export as_nl
IFS=" "" $as_nl"
PS1='$ '
PS2='> '
PS4='+ '
# Ensure predictable behavior from utilities with locale-dependent output.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE
# We cannot yet rely on "unset" to work, but we need these variables
# to be unset--not just set to an empty or harmless value--now, to
# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct
# also avoids known problems related to "unset" and subshell syntax
# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
do eval test \${$as_var+y} \
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
# Ensure that fds 0, 1, and 2 are open.
if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
if (exec 3>&2) ; then :; else exec 2>/dev/null; fi
# The user is always right.
if ${PATH_SEPARATOR+false} :; then
PATH_SEPARATOR=:
(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
PATH_SEPARATOR=';'
}
fi
# Find who we are. Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
*[\\/]* ) as_myself=$0 ;;
*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
test -r "$as_dir$0" && as_myself=$as_dir$0 && break
done
IFS=$as_save_IFS
;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
as_myself=$0
fi
if test ! -f "$as_myself"; then
printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
exit 1
fi
# Use a proper internal environment variable to ensure we don't fall
# into an infinite loop, continuously re-executing ourselves.
if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
_as_can_reexec=no; export _as_can_reexec;
# We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
*v*x* | *x*v* ) as_opts=-vx ;;
*v* ) as_opts=-v ;;
*x* ) as_opts=-x ;;
* ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi
# We don't want this to propagate to other subprocesses.
{ _as_can_reexec=; unset _as_can_reexec;}
if test "x$CONFIG_SHELL" = x; then
as_bourne_compatible="as_nop=:
if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
# is contrary to our usage. Disable this feature.
alias -g '\${1+\"\$@\"}'='\"\$@\"'
setopt NO_GLOB_SUBST
else \$as_nop
case \`(set -o) 2>/dev/null\` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
fi
"
as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }
exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" )
then :
else \$as_nop
exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1
blah=\$(echo \$(echo blah))
test x\"\$blah\" = xblah || exit 1
test -x / || exit 1"
as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
if (eval "$as_required") 2>/dev/null
then :
as_have_required=yes
else $as_nop
as_have_required=no
fi
if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null
then :
else $as_nop
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
as_found=:
case $as_dir in #(
/*)
for as_base in sh bash ksh sh5; do
# Try only shells that exist, to save several forks.
as_shell=$as_dir$as_base
if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null
then :
CONFIG_SHELL=$as_shell as_have_required=yes
if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null
then :
break 2
fi
fi
done;;
esac
as_found=false
done
IFS=$as_save_IFS
if $as_found
then :
else $as_nop
if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null
then :
CONFIG_SHELL=$SHELL as_have_required=yes
fi
fi
if test "x$CONFIG_SHELL" != x
then :
export CONFIG_SHELL
# We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
*v*x* | *x*v* ) as_opts=-vx ;;
*v* ) as_opts=-v ;;
*x* ) as_opts=-x ;;
* ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi
if test x$as_have_required = xno
then :
printf "%s\n" "$0: This script requires a shell more modern than all"
printf "%s\n" "$0: the shells that I found on your system."
if test ${ZSH_VERSION+y} ; then
printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should"
printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later."
else
printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and
$0: https://github.com/pgbouncer/pgbouncer/issues about
$0: your system, including any error possibly output before
$0: this message. Then install a modern shell, or manually
$0: run the script under such a shell if you do have one."
fi
exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS
## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
{ eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
return $1
} # as_fn_set_status
# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
set +e
as_fn_set_status $1
exit $1
} # as_fn_exit
# as_fn_nop
# ---------
# Do nothing but, unlike ":", preserve the value of $?.
as_fn_nop ()
{
return $?
}
as_nop=as_fn_nop
# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{
case $as_dir in #(
-*) as_dir=./$as_dir;;
esac
test -d "$as_dir" || eval $as_mkdir_p || {
as_dirs=
while :; do
case $as_dir in #(
*\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
*) as_qdir=$as_dir;;
esac
as_dirs="'$as_qdir' $as_dirs"
as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$as_dir" : 'X\(//\)[^/]' \| \
X"$as_dir" : 'X\(//\)$' \| \
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
printf "%s\n" X"$as_dir" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
test -d "$as_dir" && break
done
test -z "$as_dirs" || eval "mkdir $as_dirs"
} || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
} # as_fn_mkdir_p
# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
test -f "$1" && test -x "$1"
} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
then :
eval 'as_fn_append ()
{
eval $1+=\$2
}'
else $as_nop
as_fn_append ()
{
eval $1=\$$1\$2
}
fi # as_fn_append
# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
then :
eval 'as_fn_arith ()
{
as_val=$(( $* ))
}'
else $as_nop
as_fn_arith ()
{
as_val=`expr "$@" || test $? -eq 1`
}
fi # as_fn_arith
# as_fn_nop
# ---------
# Do nothing but, unlike ":", preserve the value of $?.
as_fn_nop ()
{
return $?
}
as_nop=as_fn_nop
# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
as_status=$1; test $as_status -eq 0 && as_status=1
if test "$4"; then
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
fi
printf "%s\n" "$as_me: error: $2" >&2
as_fn_exit $as_status
} # as_fn_error
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
else
as_expr=false
fi
if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
as_basename=basename
else
as_basename=false
fi
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
as_dirname=dirname
else
as_dirname=false
fi
as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
printf "%s\n" X/"$0" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
}
/^X\/\(\/\/\)$/{
s//\1/
q
}
/^X\/\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
as_lineno_1=$LINENO as_lineno_1a=$LINENO
as_lineno_2=$LINENO as_lineno_2a=$LINENO
eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
# Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
sed -n '
p
/[$]LINENO/=
' <$as_myself |
sed '
s/[$]LINENO.*/&-/
t lineno
b
:lineno
N
:loop
s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
t loop
s/-\n.*//
' >$as_me.lineno &&
chmod +x "$as_me.lineno" ||
{ printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
# If we had to re-execute with $CONFIG_SHELL, we're ensured to have
# already done that, so ensure we don't try to do so again and fall
# in an infinite loop. This has already happened in practice.
_as_can_reexec=no; export _as_can_reexec
# Don't try to exec as it changes $[0], causing all sort of problems
# (the dirname of $[0] is not the place where we might find the
# original and so on. Autoconf is especially sensitive to this).
. "./$as_me.lineno"
# Exit status is that of the last command.
exit
}
# Determine whether it's possible to make 'echo' print without a newline.
# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
# for compatibility with existing Makefiles.
ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
case `echo 'xy\c'` in
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
xy) ECHO_C='\c';;
*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
ECHO_T=' ';;
esac;;
*)
ECHO_N='-n';;
esac
# For backward compatibility with old third-party macros, we provide
# the shell variables $as_echo and $as_echo_n. New code should use
# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
as_echo='printf %s\n'
as_echo_n='printf %s'
rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
rm -f conf$$.dir/conf$$.file
else
rm -f conf$$.dir
mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
if ln -s conf$$.file conf$$ 2>/dev/null; then
as_ln_s='ln -s'
# ... but there are two gotchas:
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
# In both cases, we have to default to `cp -pR'.
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
as_ln_s='cp -pR'
elif ln conf$$.file conf$$ 2>/dev/null; then
as_ln_s=ln
else
as_ln_s='cp -pR'
fi
else
as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
if mkdir -p . 2>/dev/null; then
as_mkdir_p='mkdir -p "$as_dir"'
else
test -d ./-p && rmdir ./-p
as_mkdir_p=false
fi
as_test_x='test -x'
as_executable_p=as_fn_executable_p
# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
test -n "$DJDIR" || exec 7<&0 &1
# Name of the host.
# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
# so uname gets run too.
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
#
# Initializations.
#
ac_default_prefix=/usr/local
ac_clean_files=
ac_config_libobj_dir=.
LIBOBJS=
cross_compiling=no
subdirs=
MFLAGS=
MAKEFLAGS=
# Identity of this package.
PACKAGE_NAME='PgBouncer'
PACKAGE_TARNAME='pgbouncer'
PACKAGE_VERSION='1.24.1'
PACKAGE_STRING='PgBouncer 1.24.1'
PACKAGE_BUGREPORT='https://github.com/pgbouncer/pgbouncer/issues'
PACKAGE_URL='https://www.pgbouncer.org/'
ac_unique_file="src/janitor.c"
# Factoring default headers for most tests.
ac_includes_default="\
#include
#ifdef HAVE_STDIO_H
# include
#endif
#ifdef HAVE_STDLIB_H
# include
#endif
#ifdef HAVE_STRING_H
# include
#endif
#ifdef HAVE_INTTYPES_H
# include
#endif
#ifdef HAVE_STDINT_H
# include
#endif
#ifdef HAVE_STRINGS_H
# include
#endif
#ifdef HAVE_SYS_TYPES_H
# include
#endif
#ifdef HAVE_SYS_STAT_H
# include
#endif
#ifdef HAVE_UNISTD_H
# include
#endif"
ac_header_c_list=
ac_subst_vars='LTLIBOBJS
LIBOBJS
enable_debug
TLS_LIBS
TLS_LDFLAGS
TLS_CPPFLAGS
tls_support
PTHREAD_CFLAGS
PTHREAD_LIBS
PTHREAD_CC
ax_pthread_config
CARES_LIBS
CARES_CFLAGS
with_systemd
LIBEVENT_LIBS
LIBEVENT_CFLAGS
DLLTOOL
DLLWRAP
WINDRES
PYTHON
PANDOC
PKG_CONFIG_LIBDIR
PKG_CONFIG_PATH
PKG_CONFIG
ARFLAGS
AR
RANLIB
STRIP
SED
MKDIR_P
AWK
EGREP
GREP
LN_S
INSTALL_DATA
INSTALL_SCRIPT
INSTALL_PROGRAM
WFLAGS
HAVE_CC_DEPFLAG
CPP
OBJEXT
EXEEXT
ac_ct_CC
CPPFLAGS
LDFLAGS
CFLAGS
CC
pkgconfigdir
pkgdatadir
PORTNAME
host_os
host_vendor
host_cpu
host
build_os
build_vendor
build_cpu
build
target_alias
host_alias
build_alias
LIBS
ECHO_T
ECHO_N
ECHO_C
DEFS
mandir
localedir
libdir
psdir
pdfdir
dvidir
htmldir
infodir
docdir
oldincludedir
includedir
runstatedir
localstatedir
sharedstatedir
sysconfdir
datadir
datarootdir
libexecdir
sbindir
bindir
program_transform_name
prefix
exec_prefix
PACKAGE_URL
PACKAGE_BUGREPORT
PACKAGE_STRING
PACKAGE_VERSION
PACKAGE_TARNAME
PACKAGE_NAME
PATH_SEPARATOR
SHELL'
ac_subst_files=''
ac_user_opts='
enable_option_checking
enable_largefile
with_pam
with_systemd
with_cares
enable_evdns
with_openssl
with_root_ca_file
enable_debug
enable_cassert
enable_werror
'
ac_precious_vars='build_alias
host_alias
target_alias
CC
CFLAGS
LDFLAGS
LIBS
CPPFLAGS
CPP
PKG_CONFIG
PKG_CONFIG_PATH
PKG_CONFIG_LIBDIR
LIBEVENT_CFLAGS
LIBEVENT_LIBS
CARES_CFLAGS
CARES_LIBS'
# Initialize some variables set by options.
ac_init_help=
ac_init_version=false
ac_unrecognized_opts=
ac_unrecognized_sep=
# The variables have the same names as the options, with
# dashes changed to underlines.
cache_file=/dev/null
exec_prefix=NONE
no_create=
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
verbose=
x_includes=NONE
x_libraries=NONE
# Installation directory options.
# These are left unexpanded so users can "make install exec_prefix=/foo"
# and all the variables that are supposed to be based on exec_prefix
# by default will actually change.
# Use braces instead of parens because sh, perl, etc. also accept them.
# (The list follows the same order as the GNU Coding Standards.)
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datarootdir='${prefix}/share'
datadir='${datarootdir}'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
runstatedir='${localstatedir}/run'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
infodir='${datarootdir}/info'
htmldir='${docdir}'
dvidir='${docdir}'
pdfdir='${docdir}'
psdir='${docdir}'
libdir='${exec_prefix}/lib'
localedir='${datarootdir}/locale'
mandir='${datarootdir}/man'
ac_prev=
ac_dashdash=
for ac_option
do
# If the previous option needs an argument, assign it.
if test -n "$ac_prev"; then
eval $ac_prev=\$ac_option
ac_prev=
continue
fi
case $ac_option in
*=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
*=) ac_optarg= ;;
*) ac_optarg=yes ;;
esac
case $ac_dashdash$ac_option in
--)
ac_dashdash=yes ;;
-bindir | --bindir | --bindi | --bind | --bin | --bi)
ac_prev=bindir ;;
-bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
bindir=$ac_optarg ;;
-build | --build | --buil | --bui | --bu)
ac_prev=build_alias ;;
-build=* | --build=* | --buil=* | --bui=* | --bu=*)
build_alias=$ac_optarg ;;
-cache-file | --cache-file | --cache-fil | --cache-fi \
| --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
ac_prev=cache_file ;;
-cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
| --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
cache_file=$ac_optarg ;;
--config-cache | -C)
cache_file=config.cache ;;
-datadir | --datadir | --datadi | --datad)
ac_prev=datadir ;;
-datadir=* | --datadir=* | --datadi=* | --datad=*)
datadir=$ac_optarg ;;
-datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
| --dataroo | --dataro | --datar)
ac_prev=datarootdir ;;
-datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
| --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
datarootdir=$ac_optarg ;;
-disable-* | --disable-*)
ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid feature name: \`$ac_useropt'"
ac_useropt_orig=$ac_useropt
ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"enable_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval enable_$ac_useropt=no ;;
-docdir | --docdir | --docdi | --doc | --do)
ac_prev=docdir ;;
-docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
docdir=$ac_optarg ;;
-dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
ac_prev=dvidir ;;
-dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
dvidir=$ac_optarg ;;
-enable-* | --enable-*)
ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid feature name: \`$ac_useropt'"
ac_useropt_orig=$ac_useropt
ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"enable_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval enable_$ac_useropt=\$ac_optarg ;;
-exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
| --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
| --exec | --exe | --ex)
ac_prev=exec_prefix ;;
-exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
| --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
| --exec=* | --exe=* | --ex=*)
exec_prefix=$ac_optarg ;;
-gas | --gas | --ga | --g)
# Obsolete; use --with-gas.
with_gas=yes ;;
-help | --help | --hel | --he | -h)
ac_init_help=long ;;
-help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
ac_init_help=recursive ;;
-help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
ac_init_help=short ;;
-host | --host | --hos | --ho)
ac_prev=host_alias ;;
-host=* | --host=* | --hos=* | --ho=*)
host_alias=$ac_optarg ;;
-htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
ac_prev=htmldir ;;
-htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
| --ht=*)
htmldir=$ac_optarg ;;
-includedir | --includedir | --includedi | --included | --include \
| --includ | --inclu | --incl | --inc)
ac_prev=includedir ;;
-includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
| --includ=* | --inclu=* | --incl=* | --inc=*)
includedir=$ac_optarg ;;
-infodir | --infodir | --infodi | --infod | --info | --inf)
ac_prev=infodir ;;
-infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
infodir=$ac_optarg ;;
-libdir | --libdir | --libdi | --libd)
ac_prev=libdir ;;
-libdir=* | --libdir=* | --libdi=* | --libd=*)
libdir=$ac_optarg ;;
-libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
| --libexe | --libex | --libe)
ac_prev=libexecdir ;;
-libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
| --libexe=* | --libex=* | --libe=*)
libexecdir=$ac_optarg ;;
-localedir | --localedir | --localedi | --localed | --locale)
ac_prev=localedir ;;
-localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
localedir=$ac_optarg ;;
-localstatedir | --localstatedir | --localstatedi | --localstated \
| --localstate | --localstat | --localsta | --localst | --locals)
ac_prev=localstatedir ;;
-localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
| --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
localstatedir=$ac_optarg ;;
-mandir | --mandir | --mandi | --mand | --man | --ma | --m)
ac_prev=mandir ;;
-mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
mandir=$ac_optarg ;;
-nfp | --nfp | --nf)
# Obsolete; use --without-fp.
with_fp=no ;;
-no-create | --no-create | --no-creat | --no-crea | --no-cre \
| --no-cr | --no-c | -n)
no_create=yes ;;
-no-recursion | --no-recursion | --no-recursio | --no-recursi \
| --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
no_recursion=yes ;;
-oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
| --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
| --oldin | --oldi | --old | --ol | --o)
ac_prev=oldincludedir ;;
-oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
| --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
| --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
oldincludedir=$ac_optarg ;;
-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
ac_prev=prefix ;;
-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
prefix=$ac_optarg ;;
-program-prefix | --program-prefix | --program-prefi | --program-pref \
| --program-pre | --program-pr | --program-p)
ac_prev=program_prefix ;;
-program-prefix=* | --program-prefix=* | --program-prefi=* \
| --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
program_prefix=$ac_optarg ;;
-program-suffix | --program-suffix | --program-suffi | --program-suff \
| --program-suf | --program-su | --program-s)
ac_prev=program_suffix ;;
-program-suffix=* | --program-suffix=* | --program-suffi=* \
| --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
program_suffix=$ac_optarg ;;
-program-transform-name | --program-transform-name \
| --program-transform-nam | --program-transform-na \
| --program-transform-n | --program-transform- \
| --program-transform | --program-transfor \
| --program-transfo | --program-transf \
| --program-trans | --program-tran \
| --progr-tra | --program-tr | --program-t)
ac_prev=program_transform_name ;;
-program-transform-name=* | --program-transform-name=* \
| --program-transform-nam=* | --program-transform-na=* \
| --program-transform-n=* | --program-transform-=* \
| --program-transform=* | --program-transfor=* \
| --program-transfo=* | --program-transf=* \
| --program-trans=* | --program-tran=* \
| --progr-tra=* | --program-tr=* | --program-t=*)
program_transform_name=$ac_optarg ;;
-pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
ac_prev=pdfdir ;;
-pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
pdfdir=$ac_optarg ;;
-psdir | --psdir | --psdi | --psd | --ps)
ac_prev=psdir ;;
-psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
psdir=$ac_optarg ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
| -silent | --silent | --silen | --sile | --sil)
silent=yes ;;
-runstatedir | --runstatedir | --runstatedi | --runstated \
| --runstate | --runstat | --runsta | --runst | --runs \
| --run | --ru | --r)
ac_prev=runstatedir ;;
-runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
| --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
| --run=* | --ru=* | --r=*)
runstatedir=$ac_optarg ;;
-sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
ac_prev=sbindir ;;
-sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
| --sbi=* | --sb=*)
sbindir=$ac_optarg ;;
-sharedstatedir | --sharedstatedir | --sharedstatedi \
| --sharedstated | --sharedstate | --sharedstat | --sharedsta \
| --sharedst | --shareds | --shared | --share | --shar \
| --sha | --sh)
ac_prev=sharedstatedir ;;
-sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
| --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
| --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
| --sha=* | --sh=*)
sharedstatedir=$ac_optarg ;;
-site | --site | --sit)
ac_prev=site ;;
-site=* | --site=* | --sit=*)
site=$ac_optarg ;;
-srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
ac_prev=srcdir ;;
-srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
srcdir=$ac_optarg ;;
-sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
| --syscon | --sysco | --sysc | --sys | --sy)
ac_prev=sysconfdir ;;
-sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
| --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
sysconfdir=$ac_optarg ;;
-target | --target | --targe | --targ | --tar | --ta | --t)
ac_prev=target_alias ;;
-target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
target_alias=$ac_optarg ;;
-v | -verbose | --verbose | --verbos | --verbo | --verb)
verbose=yes ;;
-version | --version | --versio | --versi | --vers | -V)
ac_init_version=: ;;
-with-* | --with-*)
ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid package name: \`$ac_useropt'"
ac_useropt_orig=$ac_useropt
ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"with_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval with_$ac_useropt=\$ac_optarg ;;
-without-* | --without-*)
ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid package name: \`$ac_useropt'"
ac_useropt_orig=$ac_useropt
ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"with_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval with_$ac_useropt=no ;;
--x)
# Obsolete; use --with-x.
with_x=yes ;;
-x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
| --x-incl | --x-inc | --x-in | --x-i)
ac_prev=x_includes ;;
-x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
| --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
x_includes=$ac_optarg ;;
-x-libraries | --x-libraries | --x-librarie | --x-librari \
| --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
ac_prev=x_libraries ;;
-x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
| --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
x_libraries=$ac_optarg ;;
-*) as_fn_error $? "unrecognized option: \`$ac_option'
Try \`$0 --help' for more information"
;;
*=*)
ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
# Reject names that are not valid shell variable names.
case $ac_envvar in #(
'' | [0-9]* | *[!_$as_cr_alnum]* )
as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
esac
eval $ac_envvar=\$ac_optarg
export $ac_envvar ;;
*)
# FIXME: should be removed in autoconf 3.0.
printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2
expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2
: "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
;;
esac
done
if test -n "$ac_prev"; then
ac_option=--`echo $ac_prev | sed 's/_/-/g'`
as_fn_error $? "missing argument to $ac_option"
fi
if test -n "$ac_unrecognized_opts"; then
case $enable_option_checking in
no) ;;
fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
*) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
esac
fi
# Check all directory arguments for consistency.
for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
datadir sysconfdir sharedstatedir localstatedir includedir \
oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
libdir localedir mandir runstatedir
do
eval ac_val=\$$ac_var
# Remove trailing slashes.
case $ac_val in
*/ )
ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
eval $ac_var=\$ac_val;;
esac
# Be sure to have absolute directory names.
case $ac_val in
[\\/$]* | ?:[\\/]* ) continue;;
NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
esac
as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
done
# There might be people who depend on the old broken behavior: `$host'
# used to hold the argument of --host etc.
# FIXME: To remove some day.
build=$build_alias
host=$host_alias
target=$target_alias
# FIXME: To remove some day.
if test "x$host_alias" != x; then
if test "x$build_alias" = x; then
cross_compiling=maybe
elif test "x$build_alias" != "x$host_alias"; then
cross_compiling=yes
fi
fi
ac_tool_prefix=
test -n "$host_alias" && ac_tool_prefix=$host_alias-
test "$silent" = yes && exec 6>/dev/null
ac_pwd=`pwd` && test -n "$ac_pwd" &&
ac_ls_di=`ls -di .` &&
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
as_fn_error $? "working directory cannot be determined"
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
as_fn_error $? "pwd does not report name of working directory"
# Find the source files, if location was not specified.
if test -z "$srcdir"; then
ac_srcdir_defaulted=yes
# Try the directory containing this script, then the parent directory.
ac_confdir=`$as_dirname -- "$as_myself" ||
$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$as_myself" : 'X\(//\)[^/]' \| \
X"$as_myself" : 'X\(//\)$' \| \
X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
printf "%s\n" X"$as_myself" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
srcdir=$ac_confdir
if test ! -r "$srcdir/$ac_unique_file"; then
srcdir=..
fi
else
ac_srcdir_defaulted=no
fi
if test ! -r "$srcdir/$ac_unique_file"; then
test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
fi
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
ac_abs_confdir=`(
cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
pwd)`
# When building in place, set srcdir=.
if test "$ac_abs_confdir" = "$ac_pwd"; then
srcdir=.
fi
# Remove unnecessary trailing slashes from srcdir.
# Double slashes in file names in object file debugging info
# mess up M-x gdb in Emacs.
case $srcdir in
*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
esac
for ac_var in $ac_precious_vars; do
eval ac_env_${ac_var}_set=\${${ac_var}+set}
eval ac_env_${ac_var}_value=\$${ac_var}
eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
eval ac_cv_env_${ac_var}_value=\$${ac_var}
done
#
# Report the --help message.
#
if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
\`configure' configures PgBouncer 1.24.1 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
To assign environment variables (e.g., CC, CFLAGS...), specify them as
VAR=VALUE. See below for descriptions of some of the useful variables.
Defaults for the options are specified in brackets.
Configuration:
-h, --help display this help and exit
--help=short display options specific to this package
--help=recursive display the short help of all the included packages
-V, --version display version information and exit
-q, --quiet, --silent do not print \`checking ...' messages
--cache-file=FILE cache test results in FILE [disabled]
-C, --config-cache alias for \`--cache-file=config.cache'
-n, --no-create do not create output files
--srcdir=DIR find the sources in DIR [configure dir or \`..']
Installation directories:
--prefix=PREFIX install architecture-independent files in PREFIX
[$ac_default_prefix]
--exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
[PREFIX]
By default, \`make install' will install all the files in
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
for instance \`--prefix=\$HOME'.
For better control, use the options below.
Fine tuning of the installation directories:
--bindir=DIR user executables [EPREFIX/bin]
--sbindir=DIR system admin executables [EPREFIX/sbin]
--libexecdir=DIR program executables [EPREFIX/libexec]
--sysconfdir=DIR read-only single-machine data [PREFIX/etc]
--sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
--localstatedir=DIR modifiable single-machine data [PREFIX/var]
--runstatedir=DIR modifiable per-process data [LOCALSTATEDIR/run]
--libdir=DIR object code libraries [EPREFIX/lib]
--includedir=DIR C header files [PREFIX/include]
--oldincludedir=DIR C header files for non-gcc [/usr/include]
--datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
--datadir=DIR read-only architecture-independent data [DATAROOTDIR]
--infodir=DIR info documentation [DATAROOTDIR/info]
--localedir=DIR locale-dependent data [DATAROOTDIR/locale]
--mandir=DIR man documentation [DATAROOTDIR/man]
--docdir=DIR documentation root [DATAROOTDIR/doc/pgbouncer]
--htmldir=DIR html documentation [DOCDIR]
--dvidir=DIR dvi documentation [DOCDIR]
--pdfdir=DIR pdf documentation [DOCDIR]
--psdir=DIR ps documentation [DOCDIR]
_ACEOF
cat <<\_ACEOF
System types:
--build=BUILD configure for building on BUILD [guessed]
--host=HOST cross-compile to build programs to run on HOST [BUILD]
_ACEOF
fi
if test -n "$ac_init_help"; then
case $ac_init_help in
short | recursive ) echo "Configuration of PgBouncer 1.24.1:";;
esac
cat <<\_ACEOF
Optional Features:
--disable-option-checking ignore unrecognized --enable/--with options
--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
--disable-largefile omit support for large files
--disable-evdns do not use libevent for DNS lookups
--disable-debug strip binary
--enable-cassert turn on assert checking in code
--enable-werror add -Werror to CFLAGS
Optional Packages:
--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
--without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
--with-pam build with PAM support
--with-systemd build with systemd support
--with-cares[=PREFIX] build with c-ares support
--without-openssl do not build with OpenSSL support
--with-openssl[=PREFIX] specify where OpenSSL is installed
--with-root-ca-file=FILE
specify where the root CA certificates are
Some influential environment variables:
CC C compiler command
CFLAGS C compiler flags
LDFLAGS linker flags, e.g. -L if you have libraries in a
nonstandard directory
LIBS libraries to pass to the linker, e.g. -l
CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if
you have headers in a nonstandard directory
CPP C preprocessor
PKG_CONFIG path to pkg-config utility
PKG_CONFIG_PATH
directories to add to pkg-config's search path
PKG_CONFIG_LIBDIR
path overriding pkg-config's built-in search path
LIBEVENT_CFLAGS
C compiler flags for LIBEVENT, overriding pkg-config
LIBEVENT_LIBS
linker flags for LIBEVENT, overriding pkg-config
CARES_CFLAGS
C compiler flags for CARES, overriding pkg-config
CARES_LIBS linker flags for CARES, overriding pkg-config
Use these variables to override the choices made by `configure' or to help
it to find libraries and programs with nonstandard names/locations.
Report bugs to .
PgBouncer home page: .
_ACEOF
ac_status=$?
fi
if test "$ac_init_help" = "recursive"; then
# If there are subdirs, report their specific --help.
for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
test -d "$ac_dir" ||
{ cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
continue
ac_builddir=.
case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
# A ".." for each directory in $ac_dir_suffix.
ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
case $ac_top_builddir_sub in
"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
*) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix
case $srcdir in
.) # We are building in place.
ac_srcdir=.
ac_top_srcdir=$ac_top_builddir_sub
ac_abs_top_srcdir=$ac_pwd ;;
[\\/]* | ?:[\\/]* ) # Absolute name.
ac_srcdir=$srcdir$ac_dir_suffix;
ac_top_srcdir=$srcdir
ac_abs_top_srcdir=$srcdir ;;
*) # Relative name.
ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
ac_top_srcdir=$ac_top_build_prefix$srcdir
ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
cd "$ac_dir" || { ac_status=$?; continue; }
# Check for configure.gnu first; this name is used for a wrapper for
# Metaconfig's "Configure" on case-insensitive file systems.
if test -f "$ac_srcdir/configure.gnu"; then
echo &&
$SHELL "$ac_srcdir/configure.gnu" --help=recursive
elif test -f "$ac_srcdir/configure"; then
echo &&
$SHELL "$ac_srcdir/configure" --help=recursive
else
printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2
fi || ac_status=$?
cd "$ac_pwd" || { ac_status=$?; break; }
done
fi
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
PgBouncer configure 1.24.1
generated by GNU Autoconf 2.71
Copyright (C) 2021 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
exit
fi
## ------------------------ ##
## Autoconf initialization. ##
## ------------------------ ##
# ac_fn_c_try_compile LINENO
# --------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_compile ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
rm -f conftest.$ac_objext conftest.beam
if { { ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext
then :
ac_retval=0
else $as_nop
printf "%s\n" "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1
fi
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_compile
# ac_fn_c_try_cpp LINENO
# ----------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_cpp ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } > conftest.i && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}
then :
ac_retval=0
else $as_nop
printf "%s\n" "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1
fi
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_cpp
# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_link ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_link") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
test -x conftest$ac_exeext
}
then :
ac_retval=0
else $as_nop
printf "%s\n" "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1
fi
# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
# interfere with the next link command; also delete a directory that is
# left behind by Apple's compiler. We do this before executing the actions.
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_link
# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists and can be compiled using the include files in
# INCLUDES, setting the cache variable VAR accordingly.
ac_fn_c_check_header_compile ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
printf %s "checking for $2... " >&6; }
if eval test \${$3+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
eval "$3=yes"
else $as_nop
eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
eval ac_res=\$$3
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
printf "%s\n" "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_header_compile
# ac_fn_c_try_run LINENO
# ----------------------
# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that
# executables *can* be run.
ac_fn_c_try_run ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }
then :
ac_retval=0
else $as_nop
printf "%s\n" "$as_me: program exited with status $ac_status" >&5
printf "%s\n" "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=$ac_status
fi
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_run
# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
# -------------------------------------------
# Tests whether TYPE exists after having included INCLUDES, setting cache
# variable VAR accordingly.
ac_fn_c_check_type ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
printf %s "checking for $2... " >&6; }
if eval test \${$3+y}
then :
printf %s "(cached) " >&6
else $as_nop
eval "$3=no"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
int
main (void)
{
if (sizeof ($2))
return 0;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
int
main (void)
{
if (sizeof (($2)))
return 0;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
else $as_nop
eval "$3=yes"
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
eval ac_res=\$$3
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
printf "%s\n" "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_type
# ac_fn_c_find_uintX_t LINENO BITS VAR
# ------------------------------------
# Finds an unsigned integer type with width BITS, setting cache variable VAR
# accordingly.
ac_fn_c_find_uintX_t ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for uint$2_t" >&5
printf %s "checking for uint$2_t... " >&6; }
if eval test \${$3+y}
then :
printf %s "(cached) " >&6
else $as_nop
eval "$3=no"
# Order is important - never check a type that is potentially smaller
# than half of the expected target width.
for ac_type in uint$2_t 'unsigned int' 'unsigned long int' \
'unsigned long long int' 'unsigned short int' 'unsigned char'; do
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$ac_includes_default
int
main (void)
{
static int test_array [1 - 2 * !((($ac_type) -1 >> ($2 / 2 - 1)) >> ($2 / 2 - 1) == 3)];
test_array [0] = 0;
return test_array [0];
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
case $ac_type in #(
uint$2_t) :
eval "$3=yes" ;; #(
*) :
eval "$3=\$ac_type" ;;
esac
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
if eval test \"x\$"$3"\" = x"no"
then :
else $as_nop
break
fi
done
fi
eval ac_res=\$$3
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
printf "%s\n" "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_find_uintX_t
# ac_fn_c_check_func LINENO FUNC VAR
# ----------------------------------
# Tests whether FUNC exists, setting the cache variable VAR accordingly
ac_fn_c_check_func ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
printf %s "checking for $2... " >&6; }
if eval test \${$3+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Define $2 to an innocuous variant, in case declares $2.
For example, HP-UX 11i declares gettimeofday. */
#define $2 innocuous_$2
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $2 (); below. */
#include
#undef $2
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
#ifdef __cplusplus
extern "C"
#endif
char $2 ();
/* The GNU C library defines this for functions which it implements
to always fail with ENOSYS. Some functions are actually named
something starting with __ and the normal name is an alias. */
#if defined __stub_$2 || defined __stub___$2
choke me
#endif
int
main (void)
{
return $2 ();
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
eval "$3=yes"
else $as_nop
eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
fi
eval ac_res=\$$3
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
printf "%s\n" "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_func
# ac_fn_check_decl LINENO SYMBOL VAR INCLUDES EXTRA-OPTIONS FLAG-VAR
# ------------------------------------------------------------------
# Tests whether SYMBOL is declared in INCLUDES, setting cache variable VAR
# accordingly. Pass EXTRA-OPTIONS to the compiler, using FLAG-VAR.
ac_fn_check_decl ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
as_decl_name=`echo $2|sed 's/ *(.*//'`
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
printf %s "checking whether $as_decl_name is declared... " >&6; }
if eval test \${$3+y}
then :
printf %s "(cached) " >&6
else $as_nop
as_decl_use=`echo $2|sed -e 's/(/((/' -e 's/)/) 0&/' -e 's/,/) 0& (/g'`
eval ac_save_FLAGS=\$$6
as_fn_append $6 " $5"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
int
main (void)
{
#ifndef $as_decl_name
#ifdef __cplusplus
(void) $as_decl_use;
#else
(void) $as_decl_name;
#endif
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
eval "$3=yes"
else $as_nop
eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
eval $6=\$ac_save_FLAGS
fi
eval ac_res=\$$3
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
printf "%s\n" "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_check_decl
ac_configure_args_raw=
for ac_arg
do
case $ac_arg in
*\'*)
ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
as_fn_append ac_configure_args_raw " '$ac_arg'"
done
case $ac_configure_args_raw in
*$as_nl*)
ac_safe_unquote= ;;
*)
ac_unsafe_z='|&;<>()$`\\"*?[ '' ' # This string ends in space, tab.
ac_unsafe_a="$ac_unsafe_z#~"
ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g"
ac_configure_args_raw=` printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;;
esac
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
It was created by PgBouncer $as_me 1.24.1, which was
generated by GNU Autoconf 2.71. Invocation command line was
$ $0$ac_configure_args_raw
_ACEOF
exec 5>>config.log
{
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
_ASUNAME
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
printf "%s\n" "PATH: $as_dir"
done
IFS=$as_save_IFS
} >&5
cat >&5 <<_ACEOF
## ----------- ##
## Core tests. ##
## ----------- ##
_ACEOF
# Keep a trace of the command line.
# Strip out --no-create and --no-recursion so they do not pile up.
# Strip out --silent because we don't want to record it for future runs.
# Also quote any args containing shell meta-characters.
# Make two passes to allow for proper duplicate-argument suppression.
ac_configure_args=
ac_configure_args0=
ac_configure_args1=
ac_must_keep_next=false
for ac_pass in 1 2
do
for ac_arg
do
case $ac_arg in
-no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
| -silent | --silent | --silen | --sile | --sil)
continue ;;
*\'*)
ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
case $ac_pass in
1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2)
as_fn_append ac_configure_args1 " '$ac_arg'"
if test $ac_must_keep_next = true; then
ac_must_keep_next=false # Got value, back to normal.
else
case $ac_arg in
*=* | --config-cache | -C | -disable-* | --disable-* \
| -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
| -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
| -with-* | --with-* | -without-* | --without-* | --x)
case "$ac_configure_args0 " in
"$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
esac
;;
-* ) ac_must_keep_next=true ;;
esac
fi
as_fn_append ac_configure_args " '$ac_arg'"
;;
esac
done
done
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}
# When interrupted or exit'd, cleanup temporary files, and complete
# config.log. We remove comments because anyway the quotes in there
# would cause problems or look ugly.
# WARNING: Use '\'' to represent an apostrophe within the trap.
# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
trap 'exit_status=$?
# Sanitize IFS.
IFS=" "" $as_nl"
# Save into config.log some information that might help in debugging.
{
echo
printf "%s\n" "## ---------------- ##
## Cache variables. ##
## ---------------- ##"
echo
# The following way of writing the cache mishandles newlines in values,
(
for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
eval ac_val=\$$ac_var
case $ac_val in #(
*${as_nl}*)
case $ac_var in #(
*_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
esac
case $ac_var in #(
_ | IFS | as_nl) ;; #(
BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
*) { eval $ac_var=; unset $ac_var;} ;;
esac ;;
esac
done
(set) 2>&1 |
case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
*${as_nl}ac_space=\ *)
sed -n \
"s/'\''/'\''\\\\'\'''\''/g;
s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
;; #(
*)
sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
;;
esac |
sort
)
echo
printf "%s\n" "## ----------------- ##
## Output variables. ##
## ----------------- ##"
echo
for ac_var in $ac_subst_vars
do
eval ac_val=\$$ac_var
case $ac_val in
*\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
esac
printf "%s\n" "$ac_var='\''$ac_val'\''"
done | sort
echo
if test -n "$ac_subst_files"; then
printf "%s\n" "## ------------------- ##
## File substitutions. ##
## ------------------- ##"
echo
for ac_var in $ac_subst_files
do
eval ac_val=\$$ac_var
case $ac_val in
*\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
esac
printf "%s\n" "$ac_var='\''$ac_val'\''"
done | sort
echo
fi
if test -s confdefs.h; then
printf "%s\n" "## ----------- ##
## confdefs.h. ##
## ----------- ##"
echo
cat confdefs.h
echo
fi
test "$ac_signal" != 0 &&
printf "%s\n" "$as_me: caught signal $ac_signal"
printf "%s\n" "$as_me: exit $exit_status"
} >&5
rm -f core *.core core.conftest.* &&
rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
ac_signal=0
# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h
printf "%s\n" "/* confdefs.h */" > confdefs.h
# Predefined preprocessor variables.
printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h
printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h
printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h
printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h
printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h
printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h
# Let the site file select an alternate cache file if it wants to.
# Prefer an explicitly selected file to automatically selected ones.
if test -n "$CONFIG_SITE"; then
ac_site_files="$CONFIG_SITE"
elif test "x$prefix" != xNONE; then
ac_site_files="$prefix/share/config.site $prefix/etc/config.site"
else
ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
fi
for ac_site_file in $ac_site_files
do
case $ac_site_file in #(
*/*) :
;; #(
*) :
ac_site_file=./$ac_site_file ;;
esac
if test -f "$ac_site_file" && test -r "$ac_site_file"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;}
sed 's/^/| /' "$ac_site_file" >&5
. "$ac_site_file" \
|| { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "failed to load site script $ac_site_file
See \`config.log' for more details" "$LINENO" 5; }
fi
done
if test -r "$cache_file"; then
# Some versions of bash will fail to source /dev/null (special files
# actually), so we avoid doing that. DJGPP emulates it as a regular file.
if test /dev/null != "$cache_file" && test -f "$cache_file"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
printf "%s\n" "$as_me: loading cache $cache_file" >&6;}
case $cache_file in
[\\/]* | ?:[\\/]* ) . "$cache_file";;
*) . "./$cache_file";;
esac
fi
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
printf "%s\n" "$as_me: creating cache $cache_file" >&6;}
>$cache_file
fi
# Test code for whether the C compiler supports C89 (global declarations)
ac_c_conftest_c89_globals='
/* Does the compiler advertise C89 conformance?
Do not test the value of __STDC__, because some compilers set it to 0
while being otherwise adequately conformant. */
#if !defined __STDC__
# error "Compiler does not advertise C89 conformance"
#endif
#include
#include
struct stat;
/* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */
struct buf { int x; };
struct buf * (*rcsopen) (struct buf *, struct stat *, int);
static char *e (p, i)
char **p;
int i;
{
return p[i];
}
static char *f (char * (*g) (char **, int), char **p, ...)
{
char *s;
va_list v;
va_start (v,p);
s = g (p, va_arg (v,int));
va_end (v);
return s;
}
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
function prototypes and stuff, but not \xHH hex character constants.
These do not provoke an error unfortunately, instead are silently treated
as an "x". The following induces an error, until -std is added to get
proper ANSI mode. Curiously \x00 != x always comes out true, for an
array size at least. It is necessary to write \x00 == 0 to get something
that is true only with -std. */
int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1];
/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
inside strings and character constants. */
#define FOO(x) '\''x'\''
int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1];
int test (int i, double x);
struct s1 {int (*f) (int a);};
struct s2 {int (*f) (double a);};
int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int),
int, int);'
# Test code for whether the C compiler supports C89 (body of main).
ac_c_conftest_c89_main='
ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]);
'
# Test code for whether the C compiler supports C99 (global declarations)
ac_c_conftest_c99_globals='
// Does the compiler advertise C99 conformance?
#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
# error "Compiler does not advertise C99 conformance"
#endif
#include
extern int puts (const char *);
extern int printf (const char *, ...);
extern int dprintf (int, const char *, ...);
extern void *malloc (size_t);
// Check varargs macros. These examples are taken from C99 6.10.3.5.
// dprintf is used instead of fprintf to avoid needing to declare
// FILE and stderr.
#define debug(...) dprintf (2, __VA_ARGS__)
#define showlist(...) puts (#__VA_ARGS__)
#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
static void
test_varargs_macros (void)
{
int x = 1234;
int y = 5678;
debug ("Flag");
debug ("X = %d\n", x);
showlist (The first, second, and third items.);
report (x>y, "x is %d but y is %d", x, y);
}
// Check long long types.
#define BIG64 18446744073709551615ull
#define BIG32 4294967295ul
#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
#if !BIG_OK
#error "your preprocessor is broken"
#endif
#if BIG_OK
#else
#error "your preprocessor is broken"
#endif
static long long int bignum = -9223372036854775807LL;
static unsigned long long int ubignum = BIG64;
struct incomplete_array
{
int datasize;
double data[];
};
struct named_init {
int number;
const wchar_t *name;
double average;
};
typedef const char *ccp;
static inline int
test_restrict (ccp restrict text)
{
// See if C++-style comments work.
// Iterate through items via the restricted pointer.
// Also check for declarations in for loops.
for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i)
continue;
return 0;
}
// Check varargs and va_copy.
static bool
test_varargs (const char *format, ...)
{
va_list args;
va_start (args, format);
va_list args_copy;
va_copy (args_copy, args);
const char *str = "";
int number = 0;
float fnumber = 0;
while (*format)
{
switch (*format++)
{
case '\''s'\'': // string
str = va_arg (args_copy, const char *);
break;
case '\''d'\'': // int
number = va_arg (args_copy, int);
break;
case '\''f'\'': // float
fnumber = va_arg (args_copy, double);
break;
default:
break;
}
}
va_end (args_copy);
va_end (args);
return *str && number && fnumber;
}
'
# Test code for whether the C compiler supports C99 (body of main).
ac_c_conftest_c99_main='
// Check bool.
_Bool success = false;
success |= (argc != 0);
// Check restrict.
if (test_restrict ("String literal") == 0)
success = true;
char *restrict newvar = "Another string";
// Check varargs.
success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234);
test_varargs_macros ();
// Check flexible array members.
struct incomplete_array *ia =
malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
ia->datasize = 10;
for (int i = 0; i < ia->datasize; ++i)
ia->data[i] = i * 1.234;
// Check named initializers.
struct named_init ni = {
.number = 34,
.name = L"Test wide string",
.average = 543.34343,
};
ni.number = 58;
int dynamic_array[ni.number];
dynamic_array[0] = argv[0][0];
dynamic_array[ni.number - 1] = 543;
// work around unused variable warnings
ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\''
|| dynamic_array[ni.number - 1] != 543);
'
# Test code for whether the C compiler supports C11 (global declarations)
ac_c_conftest_c11_globals='
// Does the compiler advertise C11 conformance?
#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L
# error "Compiler does not advertise C11 conformance"
#endif
// Check _Alignas.
char _Alignas (double) aligned_as_double;
char _Alignas (0) no_special_alignment;
extern char aligned_as_int;
char _Alignas (0) _Alignas (int) aligned_as_int;
// Check _Alignof.
enum
{
int_alignment = _Alignof (int),
int_array_alignment = _Alignof (int[100]),
char_alignment = _Alignof (char)
};
_Static_assert (0 < -_Alignof (int), "_Alignof is signed");
// Check _Noreturn.
int _Noreturn does_not_return (void) { for (;;) continue; }
// Check _Static_assert.
struct test_static_assert
{
int x;
_Static_assert (sizeof (int) <= sizeof (long int),
"_Static_assert does not work in struct");
long int y;
};
// Check UTF-8 literals.
#define u8 syntax error!
char const utf8_literal[] = u8"happens to be ASCII" "another string";
// Check duplicate typedefs.
typedef long *long_ptr;
typedef long int *long_ptr;
typedef long_ptr long_ptr;
// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
struct anonymous
{
union {
struct { int i; int j; };
struct { int k; long int l; } w;
};
int m;
} v1;
'
# Test code for whether the C compiler supports C11 (body of main).
ac_c_conftest_c11_main='
_Static_assert ((offsetof (struct anonymous, i)
== offsetof (struct anonymous, w.k)),
"Anonymous union alignment botch");
v1.i = 2;
v1.w.k = 5;
ok |= v1.i != 5;
'
# Test code for whether the C compiler supports C11 (complete).
ac_c_conftest_c11_program="${ac_c_conftest_c89_globals}
${ac_c_conftest_c99_globals}
${ac_c_conftest_c11_globals}
int
main (int argc, char **argv)
{
int ok = 0;
${ac_c_conftest_c89_main}
${ac_c_conftest_c99_main}
${ac_c_conftest_c11_main}
return ok;
}
"
# Test code for whether the C compiler supports C99 (complete).
ac_c_conftest_c99_program="${ac_c_conftest_c89_globals}
${ac_c_conftest_c99_globals}
int
main (int argc, char **argv)
{
int ok = 0;
${ac_c_conftest_c89_main}
${ac_c_conftest_c99_main}
return ok;
}
"
# Test code for whether the C compiler supports C89 (complete).
ac_c_conftest_c89_program="${ac_c_conftest_c89_globals}
int
main (int argc, char **argv)
{
int ok = 0;
${ac_c_conftest_c89_main}
return ok;
}
"
as_fn_append ac_header_c_list " stdio.h stdio_h HAVE_STDIO_H"
as_fn_append ac_header_c_list " stdlib.h stdlib_h HAVE_STDLIB_H"
as_fn_append ac_header_c_list " string.h string_h HAVE_STRING_H"
as_fn_append ac_header_c_list " inttypes.h inttypes_h HAVE_INTTYPES_H"
as_fn_append ac_header_c_list " stdint.h stdint_h HAVE_STDINT_H"
as_fn_append ac_header_c_list " strings.h strings_h HAVE_STRINGS_H"
as_fn_append ac_header_c_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H"
as_fn_append ac_header_c_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H"
as_fn_append ac_header_c_list " unistd.h unistd_h HAVE_UNISTD_H"
# Auxiliary files required by this configure script.
ac_aux_files="install-sh config.guess config.sub"
# Locations in which to look for auxiliary files.
ac_aux_dir_candidates="${srcdir}${PATH_SEPARATOR}${srcdir}/..${PATH_SEPARATOR}${srcdir}/../.."
# Search for a directory containing all of the required auxiliary files,
# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates.
# If we don't find one directory that contains all the files we need,
# we report the set of missing files from the *first* directory in
# $ac_aux_dir_candidates and give up.
ac_missing_aux_files=""
ac_first_candidate=:
printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in $ac_aux_dir_candidates
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
as_found=:
printf "%s\n" "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5
ac_aux_dir_found=yes
ac_install_sh=
for ac_aux in $ac_aux_files
do
# As a special case, if "install-sh" is required, that requirement
# can be satisfied by any of "install-sh", "install.sh", or "shtool",
# and $ac_install_sh is set appropriately for whichever one is found.
if test x"$ac_aux" = x"install-sh"
then
if test -f "${as_dir}install-sh"; then
printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5
ac_install_sh="${as_dir}install-sh -c"
elif test -f "${as_dir}install.sh"; then
printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5
ac_install_sh="${as_dir}install.sh -c"
elif test -f "${as_dir}shtool"; then
printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5
ac_install_sh="${as_dir}shtool install -c"
else
ac_aux_dir_found=no
if $ac_first_candidate; then
ac_missing_aux_files="${ac_missing_aux_files} install-sh"
else
break
fi
fi
else
if test -f "${as_dir}${ac_aux}"; then
printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5
else
ac_aux_dir_found=no
if $ac_first_candidate; then
ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}"
else
break
fi
fi
fi
done
if test "$ac_aux_dir_found" = yes; then
ac_aux_dir="$as_dir"
break
fi
ac_first_candidate=false
as_found=false
done
IFS=$as_save_IFS
if $as_found
then :
else $as_nop
as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5
fi
# These three variables are undocumented and unsupported,
# and are intended to be withdrawn in a future Autoconf release.
# They can cause serious problems if a builder's source tree is in a directory
# whose full name contains unusual characters.
if test -f "${ac_aux_dir}config.guess"; then
ac_config_guess="$SHELL ${ac_aux_dir}config.guess"
fi
if test -f "${ac_aux_dir}config.sub"; then
ac_config_sub="$SHELL ${ac_aux_dir}config.sub"
fi
if test -f "$ac_aux_dir/configure"; then
ac_configure="$SHELL ${ac_aux_dir}configure"
fi
# Check that the precious variables saved in the cache have kept the same
# value.
ac_cache_corrupted=false
for ac_var in $ac_precious_vars; do
eval ac_old_set=\$ac_cv_env_${ac_var}_set
eval ac_new_set=\$ac_env_${ac_var}_set
eval ac_old_val=\$ac_cv_env_${ac_var}_value
eval ac_new_val=\$ac_env_${ac_var}_value
case $ac_old_set,$ac_new_set in
set,)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
printf "%s\n" "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
ac_cache_corrupted=: ;;
,set)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
ac_cache_corrupted=: ;;
,);;
*)
if test "x$ac_old_val" != "x$ac_new_val"; then
# differences in whitespace do not lead to failure.
ac_old_val_w=`echo x $ac_old_val`
ac_new_val_w=`echo x $ac_new_val`
if test "$ac_old_val_w" != "$ac_new_val_w"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
printf "%s\n" "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
ac_cache_corrupted=:
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
printf "%s\n" "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
eval $ac_var=\$ac_old_val
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
printf "%s\n" "$as_me: former value: \`$ac_old_val'" >&2;}
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
printf "%s\n" "$as_me: current value: \`$ac_new_val'" >&2;}
fi;;
esac
# Pass precious variables to config.status.
if test "$ac_new_set" = set; then
case $ac_new_val in
*\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
*) ac_arg=$ac_var=$ac_new_val ;;
esac
case " $ac_configure_args " in
*" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
*) as_fn_append ac_configure_args " '$ac_arg'" ;;
esac
fi
done
if $ac_cache_corrupted; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;}
as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file'
and start over" "$LINENO" 5
fi
## -------------------- ##
## Main body of script. ##
## -------------------- ##
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
ac_config_headers="$ac_config_headers lib/usual/config.h"
# Make sure we can run config.sub.
$SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 ||
as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
printf %s "checking build system type... " >&6; }
if test ${ac_cv_build+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_build_alias=$build_alias
test "x$ac_build_alias" = x &&
ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"`
test "x$ac_build_alias" = x &&
as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` ||
as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
printf "%s\n" "$ac_cv_build" >&6; }
case $ac_cv_build in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
esac
build=$ac_cv_build
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_build
shift
build_cpu=$1
build_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
build_os=$*
IFS=$ac_save_IFS
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
printf %s "checking host system type... " >&6; }
if test ${ac_cv_host+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test "x$host_alias" = x; then
ac_cv_host=$ac_cv_build
else
ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` ||
as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
printf "%s\n" "$ac_cv_host" >&6; }
case $ac_cv_host in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
esac
host=$ac_cv_host
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_host
shift
host_cpu=$1
host_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
host_os=$*
IFS=$ac_save_IFS
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
# if building separately from srcdir, write top-level makefile
if test "$srcdir" != "."; then
echo "include $srcdir/Makefile" > Makefile
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking target host type" >&5
printf %s "checking target host type... " >&6; }
xhost="$host_alias"
if test "x$xhost" = "x"; then
xhost=`uname -s`
fi
case "$xhost" in
*cygwin* | *mingw* | *pw32* | *MINGW*)
LIBS="$LIBS -lws2_32"
PORTNAME=win32;;
*) PORTNAME=unix ;;
esac
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PORTNAME" >&5
printf "%s\n" "$PORTNAME" >&6; }
if test "$PORTNAME" = "win32"; then
printf "%s\n" "#define WIN32_LEAN_AND_MEAN 1" >>confdefs.h
printf "%s\n" "#define WINVER 0x0600" >>confdefs.h
fi
printf "%s\n" "#define _GNU_SOURCE 1" >>confdefs.h
pkgdatadir='${datarootdir}'/${PACKAGE_TARNAME}
pkgconfigdir='${libdir}/pkgconfig'
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}gcc"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
printf "%s\n" "$CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_CC"; then
ac_ct_CC=$CC
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_CC"; then
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="gcc"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
printf "%s\n" "$ac_ct_CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_CC" = x; then
CC=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
fi
else
CC="$ac_cv_prog_CC"
fi
if test -z "$CC"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}cc"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
printf "%s\n" "$CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
fi
if test -z "$CC"; then
# Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
ac_prog_rejected=no
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
if test "$as_dir$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
ac_prog_rejected=yes
continue
fi
ac_cv_prog_CC="cc"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
if test $ac_prog_rejected = yes; then
# We found a bogon in the path, so make sure we never use it.
set dummy $ac_cv_prog_CC
shift
if test $# != 0; then
# We chose a different compiler from the bogus one.
# However, it has the same basename, so the bogon will be chosen
# first if we set CC to just the basename; use the full file name.
shift
ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@"
fi
fi
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
printf "%s\n" "$CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$CC"; then
if test -n "$ac_tool_prefix"; then
for ac_prog in cl.exe
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
printf "%s\n" "$CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
test -n "$CC" && break
done
fi
if test -z "$CC"; then
ac_ct_CC=$CC
for ac_prog in cl.exe
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_CC"; then
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="$ac_prog"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
printf "%s\n" "$ac_ct_CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
test -n "$ac_ct_CC" && break
done
if test "x$ac_ct_CC" = x; then
CC=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
fi
fi
fi
if test -z "$CC"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args.
set dummy ${ac_tool_prefix}clang; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}clang"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
printf "%s\n" "$CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_CC"; then
ac_ct_CC=$CC
# Extract the first word of "clang", so it can be a program name with args.
set dummy clang; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_CC"; then
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="clang"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
printf "%s\n" "$ac_ct_CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_CC" = x; then
CC=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
fi
else
CC="$ac_cv_prog_CC"
fi
fi
test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "no acceptable C compiler found in \$PATH
See \`config.log' for more details" "$LINENO" 5; }
# Provide some information about the compiler.
printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion -version; do
{ { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
sed '10a\
... rest of stderr output deleted ...
10q' conftest.err >conftest.er1
cat conftest.er1 >&5
fi
rm -f conftest.er1 conftest.err
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
done
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main (void)
{
;
return 0;
}
_ACEOF
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
printf %s "checking whether the C compiler works... " >&6; }
ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
# The possible output files:
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
ac_rmfiles=
for ac_file in $ac_files
do
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
* ) ac_rmfiles="$ac_rmfiles $ac_file";;
esac
done
rm -f $ac_rmfiles
if { { ac_try="$ac_link_default"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_link_default") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then :
# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
# in a Makefile. We should not override ac_cv_exeext if it was cached,
# so that the user can short-circuit this test for compilers unknown to
# Autoconf.
for ac_file in $ac_files ''
do
test -f "$ac_file" || continue
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
;;
[ab].out )
# We found the default executable, but exeext='' is most
# certainly right.
break;;
*.* )
if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no;
then :; else
ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
fi
# We set ac_cv_exeext here because the later test for it is not
# safe: cross compilers may not add the suffix if given an `-o'
# argument, so we may need to know it at that point already.
# Even if this section looks crufty: it has the advantage of
# actually working.
break;;
* )
break;;
esac
done
test "$ac_cv_exeext" = no && ac_cv_exeext=
else $as_nop
ac_file=''
fi
if test -z "$ac_file"
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
printf "%s\n" "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "C compiler cannot create executables
See \`config.log' for more details" "$LINENO" 5; }
else $as_nop
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
printf %s "checking for C compiler default output file name... " >&6; }
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
printf "%s\n" "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext
rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
printf %s "checking for suffix of executables... " >&6; }
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then :
# If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with
# `rm'.
for ac_file in conftest.exe conftest conftest.*; do
test -f "$ac_file" || continue
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
*.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
break;;
* ) break;;
esac
done
else $as_nop
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest conftest$ac_cv_exeext
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
printf "%s\n" "$ac_cv_exeext" >&6; }
rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
FILE *f = fopen ("conftest.out", "w");
return ferror (f) || fclose (f) != 0;
;
return 0;
}
_ACEOF
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
printf %s "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
{ { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
if { ac_try='./conftest$ac_cv_exeext'
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }; then
cross_compiling=no
else
if test "$cross_compiling" = maybe; then
cross_compiling=yes
else
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details" "$LINENO" 5; }
fi
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
printf "%s\n" "$cross_compiling" >&6; }
rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
ac_clean_files=$ac_clean_files_save
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
printf %s "checking for suffix of object files... " >&6; }
if test ${ac_cv_objext+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main (void)
{
;
return 0;
}
_ACEOF
rm -f conftest.o conftest.obj
if { { ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
printf "%s\n" "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then :
for ac_file in conftest.o conftest.obj conftest.*; do
test -f "$ac_file" || continue;
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
*) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
break;;
esac
done
else $as_nop
printf "%s\n" "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of object files: cannot compile
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest.$ac_cv_objext conftest.$ac_ext
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
printf "%s\n" "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
printf %s "checking whether the compiler supports GNU C... " >&6; }
if test ${ac_cv_c_compiler_gnu+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main (void)
{
#ifndef __GNUC__
choke me
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_compiler_gnu=yes
else $as_nop
ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test $ac_compiler_gnu = yes; then
GCC=yes
else
GCC=
fi
ac_test_CFLAGS=${CFLAGS+y}
ac_save_CFLAGS=$CFLAGS
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
printf %s "checking whether $CC accepts -g... " >&6; }
if test ${ac_cv_prog_cc_g+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_save_c_werror_flag=$ac_c_werror_flag
ac_c_werror_flag=yes
ac_cv_prog_cc_g=no
CFLAGS="-g"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_prog_cc_g=yes
else $as_nop
CFLAGS=""
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
else $as_nop
ac_c_werror_flag=$ac_save_c_werror_flag
CFLAGS="-g"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_prog_cc_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
if test $ac_test_CFLAGS; then
CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then
if test "$GCC" = yes; then
CFLAGS="-g -O2"
else
CFLAGS="-g"
fi
else
if test "$GCC" = yes; then
CFLAGS="-O2"
else
CFLAGS=
fi
fi
ac_prog_cc_stdc=no
if test x$ac_prog_cc_stdc = xno
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
printf %s "checking for $CC option to enable C11 features... " >&6; }
if test ${ac_cv_prog_cc_c11+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_prog_cc_c11=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$ac_c_conftest_c11_program
_ACEOF
for ac_arg in '' -std=gnu11
do
CC="$ac_save_CC $ac_arg"
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_prog_cc_c11=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam
test "x$ac_cv_prog_cc_c11" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC
fi
if test "x$ac_cv_prog_cc_c11" = xno
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
printf "%s\n" "unsupported" >&6; }
else $as_nop
if test "x$ac_cv_prog_cc_c11" = x
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
printf "%s\n" "none needed" >&6; }
else $as_nop
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
CC="$CC $ac_cv_prog_cc_c11"
fi
ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
ac_prog_cc_stdc=c11
fi
fi
if test x$ac_prog_cc_stdc = xno
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
printf %s "checking for $CC option to enable C99 features... " >&6; }
if test ${ac_cv_prog_cc_c99+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_prog_cc_c99=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$ac_c_conftest_c99_program
_ACEOF
for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99=
do
CC="$ac_save_CC $ac_arg"
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_prog_cc_c99=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam
test "x$ac_cv_prog_cc_c99" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC
fi
if test "x$ac_cv_prog_cc_c99" = xno
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
printf "%s\n" "unsupported" >&6; }
else $as_nop
if test "x$ac_cv_prog_cc_c99" = x
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
printf "%s\n" "none needed" >&6; }
else $as_nop
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
CC="$CC $ac_cv_prog_cc_c99"
fi
ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
ac_prog_cc_stdc=c99
fi
fi
if test x$ac_prog_cc_stdc = xno
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
printf %s "checking for $CC option to enable C89 features... " >&6; }
if test ${ac_cv_prog_cc_c89+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$ac_c_conftest_c89_program
_ACEOF
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
CC="$ac_save_CC $ac_arg"
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_prog_cc_c89=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam
test "x$ac_cv_prog_cc_c89" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC
fi
if test "x$ac_cv_prog_cc_c89" = xno
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
printf "%s\n" "unsupported" >&6; }
else $as_nop
if test "x$ac_cv_prog_cc_c89" = x
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
printf "%s\n" "none needed" >&6; }
else $as_nop
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
CC="$CC $ac_cv_prog_cc_c89"
fi
ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
ac_prog_cc_stdc=c89
fi
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
# Find a good install program. We prefer a C program (faster),
# so one script is as good as another. But avoid the broken or
# incompatible versions:
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install
# AIX /bin/install
# AmigaOS /C/install, which installs bootblocks on floppy discs
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
printf %s "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if test ${ac_cv_path_install+y}
then :
printf %s "(cached) " >&6
else $as_nop
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
# Account for fact that we put trailing slashes in our PATH walk.
case $as_dir in #((
./ | /[cC]/* | \
/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
/usr/ucb/* ) ;;
*)
# OSF1 and SCO ODT 3.0 have their own names for install.
# Don't use installbsd from OSF since it installs stuff as root
# by default.
for ac_prog in ginstall scoinst install; do
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext"; then
if test $ac_prog = install &&
grep dspmsg "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# AIX install. It has an incompatible calling convention.
:
elif test $ac_prog = install &&
grep pwplus "$as_dir$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# program-specific install script used by HP pwplus--don't use.
:
else
rm -rf conftest.one conftest.two conftest.dir
echo one > conftest.one
echo two > conftest.two
mkdir conftest.dir
if "$as_dir$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir/" &&
test -s conftest.one && test -s conftest.two &&
test -s conftest.dir/conftest.one &&
test -s conftest.dir/conftest.two
then
ac_cv_path_install="$as_dir$ac_prog$ac_exec_ext -c"
break 3
fi
fi
fi
done
done
;;
esac
done
IFS=$as_save_IFS
rm -rf conftest.one conftest.two conftest.dir
fi
if test ${ac_cv_path_install+y}; then
INSTALL=$ac_cv_path_install
else
# As a last resort, use the slow shell script. Don't cache a
# value for INSTALL within a source directory, because that will
# break other packages using the cache if that directory is
# removed, or if the value is a relative name.
INSTALL=$ac_install_sh
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
printf "%s\n" "$INSTALL" >&6; }
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
printf %s "checking for grep that handles long lines and -e... " >&6; }
if test ${ac_cv_path_GREP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -z "$GREP"; then
ac_path_GREP_found=false
# Loop through the user's path and test for each of PROGNAME-LIST
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_prog in grep ggrep
do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
as_fn_executable_p "$ac_path_GREP" || continue
# Check for GNU ac_path_GREP and select it if it is found.
# Check for GNU $ac_path_GREP
case `"$ac_path_GREP" --version 2>&1` in
*GNU*)
ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
*)
ac_count=0
printf %s 0123456789 >"conftest.in"
while :
do
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
printf "%s\n" 'GREP' >> "conftest.nl"
"$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_GREP_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_GREP="$ac_path_GREP"
ac_path_GREP_max=$ac_count
fi
# 10*(2^10) chars as input seems more than enough
test $ac_count -gt 10 && break
done
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac
$ac_path_GREP_found && break 3
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_GREP"; then
as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
fi
else
ac_cv_path_GREP=$GREP
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
printf "%s\n" "$ac_cv_path_GREP" >&6; }
GREP="$ac_cv_path_GREP"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5
printf %s "checking for a race-free mkdir -p... " >&6; }
if test -z "$MKDIR_P"; then
if test ${ac_cv_path_mkdir+y}
then :
printf %s "(cached) " >&6
else $as_nop
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_prog in mkdir gmkdir; do
for ac_exec_ext in '' $ac_executable_extensions; do
as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue
case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #(
'mkdir ('*'coreutils) '* | \
'BusyBox '* | \
'mkdir (fileutils) '4.1*)
ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext
break 3;;
esac
done
done
done
IFS=$as_save_IFS
fi
test -d ./--version && rmdir ./--version
if test ${ac_cv_path_mkdir+y}; then
MKDIR_P="$ac_cv_path_mkdir -p"
else
# As a last resort, use the slow shell script. Don't cache a
# value for MKDIR_P within a source directory, because that will
# break other packages using the cache if that directory is
# removed, or if the value is a relative name.
MKDIR_P="$ac_install_sh -d"
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
printf "%s\n" "$MKDIR_P" >&6; }
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
printf %s "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
CPP=
fi
if test -z "$CPP"; then
if test ${ac_cv_prog_CPP+y}
then :
printf %s "(cached) " >&6
else $as_nop
# Double quotes because $CC needs to be expanded
for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp
do
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
# Use a header file that comes with gcc, so configuring glibc
# with a fresh cross-compiler works.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"
then :
else $as_nop
# Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if ac_fn_c_try_cpp "$LINENO"
then :
# Broken: success on invalid input.
continue
else $as_nop
# Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok
then :
break
fi
done
ac_cv_prog_CPP=$CPP
fi
CPP=$ac_cv_prog_CPP
else
ac_cv_prog_CPP=$CPP
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
printf "%s\n" "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
# Use a header file that comes with gcc, so configuring glibc
# with a fresh cross-compiler works.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"
then :
else $as_nop
# Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if ac_fn_c_try_cpp "$LINENO"
then :
# Broken: success on invalid input.
continue
else $as_nop
# Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok
then :
else $as_nop
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details" "$LINENO" 5; }
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether compiler supports __func__" >&5
printf %s "checking whether compiler supports __func__... " >&6; }
if test ${pgac_cv_funcname_func+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
printf("%s\n", __func__);
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
pgac_cv_funcname_func=yes
else $as_nop
pgac_cv_funcname_func=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_funcname_func" >&5
printf "%s\n" "$pgac_cv_funcname_func" >&6; }
if test x"$pgac_cv_funcname_func" = xyes ; then
printf "%s\n" "#define HAVE_FUNCNAME__FUNC 1" >>confdefs.h
fi
if test "$GCC" = "yes"; then
old_LDFLAGS="$LDFLAGS"
LDFLAGS="$LDFLAGS -Wl,--as-needed"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether linker supports --as-needed" >&5
printf %s "checking whether linker supports --as-needed... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int main(void) { return 0; }
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
else $as_nop
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
LDFLAGS="$old_LDFLAGS"
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether compiler supports dependency generation" >&5
printf %s "checking whether compiler supports dependency generation... " >&6; }
old_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -MD -MP -MT conftest.o -MF conftest.o.d"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
void foo(void){}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
HAVE_CC_DEPFLAG=yes
else $as_nop
HAVE_CC_DEPFLAG=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
rm -f conftest.d
CFLAGS="$old_CFLAGS"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HAVE_CC_DEPFLAG" >&5
printf "%s\n" "$HAVE_CC_DEPFLAG" >&6; }
WFLAGS=""
if test x"$GCC" = xyes; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working warning switches" >&5
printf %s "checking for working warning switches... " >&6; }
good_CFLAGS="$CFLAGS"
flags="-Wall -Wextra"
# turn off noise from Wextra
flags="$flags -Wno-unused-parameter -Wno-missing-field-initializers"
# Wextra does not turn those on?
flags="$flags -Wmissing-prototypes -Wpointer-arith -Wendif-labels"
flags="$flags -Wdeclaration-after-statement -Wold-style-definition"
flags="$flags -Wstrict-prototypes -Wundef -Wformat=2"
flags="$flags -Wuninitialized -Wmissing-format-attribute"
for f in $flags; do
CFLAGS="$good_CFLAGS $WFLAGS $f"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
void foo(void){}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
WFLAGS="$WFLAGS $f"
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
done
# avoid -Wextra if missing-field.initializers does not work
echo "$WFLAGS" | grep missing-field-initializers > /dev/null \
|| WFLAGS=`echo "$WFLAGS"|sed 's/ -Wextra//'`
CFLAGS="$good_CFLAGS"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5
printf "%s\n" "done" >&6; }
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
printf %s "checking whether ln -s works... " >&6; }
LN_S=$as_ln_s
if test "$LN_S" = "ln -s"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
printf "%s\n" "no, using $LN_S" >&6; }
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
printf %s "checking for egrep... " >&6; }
if test ${ac_cv_path_EGREP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
then ac_cv_path_EGREP="$GREP -E"
else
if test -z "$EGREP"; then
ac_path_EGREP_found=false
# Loop through the user's path and test for each of PROGNAME-LIST
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_prog in egrep
do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
as_fn_executable_p "$ac_path_EGREP" || continue
# Check for GNU ac_path_EGREP and select it if it is found.
# Check for GNU $ac_path_EGREP
case `"$ac_path_EGREP" --version 2>&1` in
*GNU*)
ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
*)
ac_count=0
printf %s 0123456789 >"conftest.in"
while :
do
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
printf "%s\n" 'EGREP' >> "conftest.nl"
"$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_EGREP_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_EGREP="$ac_path_EGREP"
ac_path_EGREP_max=$ac_count
fi
# 10*(2^10) chars as input seems more than enough
test $ac_count -gt 10 && break
done
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac
$ac_path_EGREP_found && break 3
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_EGREP"; then
as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
fi
else
ac_cv_path_EGREP=$EGREP
fi
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
printf "%s\n" "$ac_cv_path_EGREP" >&6; }
EGREP="$ac_cv_path_EGREP"
for ac_prog in gawk mawk nawk awk
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_AWK+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$AWK"; then
ac_cv_prog_AWK="$AWK" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_AWK="$ac_prog"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
printf "%s\n" "$AWK" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
test -n "$AWK" && break
done
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
printf %s "checking for a sed that does not truncate output... " >&6; }
if test ${ac_cv_path_SED+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
for ac_i in 1 2 3 4 5 6 7; do
ac_script="$ac_script$as_nl$ac_script"
done
echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
{ ac_script=; unset ac_script;}
if test -z "$SED"; then
ac_path_SED_found=false
# Loop through the user's path and test for each of PROGNAME-LIST
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_prog in sed gsed
do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
as_fn_executable_p "$ac_path_SED" || continue
# Check for GNU ac_path_SED and select it if it is found.
# Check for GNU $ac_path_SED
case `"$ac_path_SED" --version 2>&1` in
*GNU*)
ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
*)
ac_count=0
printf %s 0123456789 >"conftest.in"
while :
do
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
printf "%s\n" '' >> "conftest.nl"
"$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_SED_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_SED="$ac_path_SED"
ac_path_SED_max=$ac_count
fi
# 10*(2^10) chars as input seems more than enough
test $ac_count -gt 10 && break
done
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac
$ac_path_SED_found && break 3
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_SED"; then
as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
fi
else
ac_cv_path_SED=$SED
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
printf "%s\n" "$ac_cv_path_SED" >&6; }
SED="$ac_cv_path_SED"
rm -f conftest.sed
case "$ac_install_sh" in
./*) ac_install_sh="`pwd`/${ac_install_sh}" ;;
../*) ac_install_sh="`pwd`/${ac_install_sh}" ;;
esac
case "$INSTALL" in
./*) INSTALL="`pwd`/${INSTALL}" ;;
../*) INSTALL="`pwd`/${INSTALL}" ;;
esac
case "$MKDIR_P" in
./*) MKDIR_P="`pwd`/${MKDIR_P}" ;;
../*) MKDIR_P="`pwd`/${MKDIR_P}" ;;
esac
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_STRIP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$STRIP"; then
ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
printf "%s\n" "$STRIP" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_STRIP"; then
ac_ct_STRIP=$STRIP
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_STRIP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_STRIP"; then
ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_STRIP="strip"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
printf "%s\n" "$ac_ct_STRIP" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_STRIP" = x; then
STRIP=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
STRIP=$ac_ct_STRIP
fi
else
STRIP="$ac_cv_prog_STRIP"
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_RANLIB+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$RANLIB"; then
ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
RANLIB=$ac_cv_prog_RANLIB
if test -n "$RANLIB"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
printf "%s\n" "$RANLIB" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_RANLIB"; then
ac_ct_RANLIB=$RANLIB
# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_RANLIB+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_RANLIB"; then
ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_RANLIB="ranlib"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
if test -n "$ac_ct_RANLIB"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
printf "%s\n" "$ac_ct_RANLIB" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_RANLIB" = x; then
RANLIB="true"
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
RANLIB=$ac_ct_RANLIB
fi
else
RANLIB="$ac_cv_prog_RANLIB"
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
set dummy ${ac_tool_prefix}ar; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_AR+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$AR"; then
ac_cv_prog_AR="$AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_AR="${ac_tool_prefix}ar"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
printf "%s\n" "$AR" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_AR"; then
ac_ct_AR=$AR
# Extract the first word of "ar", so it can be a program name with args.
set dummy ar; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_AR+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_AR"; then
ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_AR="ar"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
printf "%s\n" "$ac_ct_AR" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_AR" = x; then
AR=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
AR=$ac_ct_AR
fi
else
AR="$ac_cv_prog_AR"
fi
ARFLAGS=rcu
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_path_PKG_CONFIG+y}
then :
printf %s "(cached) " >&6
else $as_nop
case $PKG_CONFIG in
[\\/]* | ?:[\\/]*)
ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_path_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
PKG_CONFIG=$ac_cv_path_PKG_CONFIG
if test -n "$PKG_CONFIG"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
printf "%s\n" "$PKG_CONFIG" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_path_PKG_CONFIG"; then
ac_pt_PKG_CONFIG=$PKG_CONFIG
# Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_path_ac_pt_PKG_CONFIG+y}
then :
printf %s "(cached) " >&6
else $as_nop
case $ac_pt_PKG_CONFIG in
[\\/]* | ?:[\\/]*)
ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_path_ac_pt_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
if test -n "$ac_pt_PKG_CONFIG"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
printf "%s\n" "$ac_pt_PKG_CONFIG" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_pt_PKG_CONFIG" = x; then
PKG_CONFIG=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
PKG_CONFIG=$ac_pt_PKG_CONFIG
fi
else
PKG_CONFIG="$ac_cv_path_PKG_CONFIG"
fi
fi
if test -n "$PKG_CONFIG"; then
_pkg_min_version=0.9.0
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
printf %s "checking pkg-config is at least version $_pkg_min_version... " >&6; }
if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
PKG_CONFIG=""
fi
fi
for ac_prog in pandoc
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_PANDOC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$PANDOC"; then
ac_cv_prog_PANDOC="$PANDOC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_PANDOC="$ac_prog"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
PANDOC=$ac_cv_prog_PANDOC
if test -n "$PANDOC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
printf "%s\n" "$PANDOC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
test -n "$PANDOC" && break
done
test -n "$PANDOC" || PANDOC="pandoc"
for ac_prog in python3 python
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_PYTHON+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$PYTHON"; then
ac_cv_prog_PYTHON="$PYTHON" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_PYTHON="$ac_prog"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
PYTHON=$ac_cv_prog_PYTHON
if test -n "$PYTHON"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5
printf "%s\n" "$PYTHON" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
test -n "$PYTHON" && break
done
test -n "$PYTHON" || PYTHON="python3"
if test "$PORTNAME" = "win32"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}windres", so it can be a program name with args.
set dummy ${ac_tool_prefix}windres; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_WINDRES+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$WINDRES"; then
ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_WINDRES="${ac_tool_prefix}windres"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
WINDRES=$ac_cv_prog_WINDRES
if test -n "$WINDRES"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WINDRES" >&5
printf "%s\n" "$WINDRES" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_WINDRES"; then
ac_ct_WINDRES=$WINDRES
# Extract the first word of "windres", so it can be a program name with args.
set dummy windres; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_WINDRES+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_WINDRES"; then
ac_cv_prog_ac_ct_WINDRES="$ac_ct_WINDRES" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_WINDRES="windres"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_WINDRES=$ac_cv_prog_ac_ct_WINDRES
if test -n "$ac_ct_WINDRES"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_WINDRES" >&5
printf "%s\n" "$ac_ct_WINDRES" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_WINDRES" = x; then
WINDRES=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
WINDRES=$ac_ct_WINDRES
fi
else
WINDRES="$ac_cv_prog_WINDRES"
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}dllwrap", so it can be a program name with args.
set dummy ${ac_tool_prefix}dllwrap; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_DLLWRAP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$DLLWRAP"; then
ac_cv_prog_DLLWRAP="$DLLWRAP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_DLLWRAP="${ac_tool_prefix}dllwrap"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
DLLWRAP=$ac_cv_prog_DLLWRAP
if test -n "$DLLWRAP"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLWRAP" >&5
printf "%s\n" "$DLLWRAP" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_DLLWRAP"; then
ac_ct_DLLWRAP=$DLLWRAP
# Extract the first word of "dllwrap", so it can be a program name with args.
set dummy dllwrap; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_DLLWRAP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_DLLWRAP"; then
ac_cv_prog_ac_ct_DLLWRAP="$ac_ct_DLLWRAP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_DLLWRAP="dllwrap"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_DLLWRAP=$ac_cv_prog_ac_ct_DLLWRAP
if test -n "$ac_ct_DLLWRAP"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLWRAP" >&5
printf "%s\n" "$ac_ct_DLLWRAP" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_DLLWRAP" = x; then
DLLWRAP=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
DLLWRAP=$ac_ct_DLLWRAP
fi
else
DLLWRAP="$ac_cv_prog_DLLWRAP"
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
set dummy ${ac_tool_prefix}dlltool; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_DLLTOOL+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$DLLTOOL"; then
ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
DLLTOOL=$ac_cv_prog_DLLTOOL
if test -n "$DLLTOOL"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
printf "%s\n" "$DLLTOOL" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_DLLTOOL"; then
ac_ct_DLLTOOL=$DLLTOOL
# Extract the first word of "dlltool", so it can be a program name with args.
set dummy dlltool; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_DLLTOOL"; then
ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_DLLTOOL="dlltool"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
if test -n "$ac_ct_DLLTOOL"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_DLLTOOL" = x; then
DLLTOOL=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
DLLTOOL=$ac_ct_DLLTOOL
fi
else
DLLTOOL="$ac_cv_prog_DLLTOOL"
fi
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_STRIP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$STRIP"; then
ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
printf "%s\n" "$STRIP" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_STRIP"; then
ac_ct_STRIP=$STRIP
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_STRIP+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ac_ct_STRIP"; then
ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_STRIP="strip"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
printf "%s\n" "$ac_ct_STRIP" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ac_ct_STRIP" = x; then
STRIP=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
STRIP=$ac_ct_STRIP
fi
else
STRIP="$ac_cv_prog_STRIP"
fi
ac_header= ac_cache=
for ac_item in $ac_header_c_list
do
if test $ac_cache; then
ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
printf "%s\n" "#define $ac_item 1" >> confdefs.h
fi
ac_header= ac_cache=
elif test $ac_header; then
ac_cache=$ac_item
else
ac_header=$ac_item
fi
done
if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
then :
printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "inttypes.h" "ac_cv_header_inttypes_h" "$ac_includes_default"
if test "x$ac_cv_header_inttypes_h" = xyes
then :
printf "%s\n" "#define HAVE_INTTYPES_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "stdbool.h" "ac_cv_header_stdbool_h" "$ac_includes_default"
if test "x$ac_cv_header_stdbool_h" = xyes
then :
printf "%s\n" "#define HAVE_STDBOOL_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "unistd.h" "ac_cv_header_unistd_h" "$ac_includes_default"
if test "x$ac_cv_header_unistd_h" = xyes
then :
printf "%s\n" "#define HAVE_UNISTD_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/time.h" "ac_cv_header_sys_time_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_time_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_TIME_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/socket.h" "ac_cv_header_sys_socket_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_socket_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_SOCKET_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "poll.h" "ac_cv_header_poll_h" "$ac_includes_default"
if test "x$ac_cv_header_poll_h" = xyes
then :
printf "%s\n" "#define HAVE_POLL_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/un.h" "ac_cv_header_sys_un_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_un_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_UN_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "arpa/inet.h" "ac_cv_header_arpa_inet_h" "$ac_includes_default"
if test "x$ac_cv_header_arpa_inet_h" = xyes
then :
printf "%s\n" "#define HAVE_ARPA_INET_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "netinet/in.h" "ac_cv_header_netinet_in_h" "$ac_includes_default"
if test "x$ac_cv_header_netinet_in_h" = xyes
then :
printf "%s\n" "#define HAVE_NETINET_IN_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "netinet/tcp.h" "ac_cv_header_netinet_tcp_h" "$ac_includes_default"
if test "x$ac_cv_header_netinet_tcp_h" = xyes
then :
printf "%s\n" "#define HAVE_NETINET_TCP_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/param.h" "ac_cv_header_sys_param_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_param_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_PARAM_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/uio.h" "ac_cv_header_sys_uio_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_uio_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_UIO_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "pwd.h" "ac_cv_header_pwd_h" "$ac_includes_default"
if test "x$ac_cv_header_pwd_h" = xyes
then :
printf "%s\n" "#define HAVE_PWD_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "grp.h" "ac_cv_header_grp_h" "$ac_includes_default"
if test "x$ac_cv_header_grp_h" = xyes
then :
printf "%s\n" "#define HAVE_GRP_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/wait.h" "ac_cv_header_sys_wait_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_wait_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_WAIT_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/mman.h" "ac_cv_header_sys_mman_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_mman_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_MMAN_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "syslog.h" "ac_cv_header_syslog_h" "$ac_includes_default"
if test "x$ac_cv_header_syslog_h" = xyes
then :
printf "%s\n" "#define HAVE_SYSLOG_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "netdb.h" "ac_cv_header_netdb_h" "$ac_includes_default"
if test "x$ac_cv_header_netdb_h" = xyes
then :
printf "%s\n" "#define HAVE_NETDB_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default"
if test "x$ac_cv_header_dlfcn_h" = xyes
then :
printf "%s\n" "#define HAVE_DLFCN_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "err.h" "ac_cv_header_err_h" "$ac_includes_default"
if test "x$ac_cv_header_err_h" = xyes
then :
printf "%s\n" "#define HAVE_ERR_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "pthread.h" "ac_cv_header_pthread_h" "$ac_includes_default"
if test "x$ac_cv_header_pthread_h" = xyes
then :
printf "%s\n" "#define HAVE_PTHREAD_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "endian.h" "ac_cv_header_endian_h" "$ac_includes_default"
if test "x$ac_cv_header_endian_h" = xyes
then :
printf "%s\n" "#define HAVE_ENDIAN_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/endian.h" "ac_cv_header_sys_endian_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_endian_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_ENDIAN_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "byteswap.h" "ac_cv_header_byteswap_h" "$ac_includes_default"
if test "x$ac_cv_header_byteswap_h" = xyes
then :
printf "%s\n" "#define HAVE_BYTESWAP_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "malloc.h" "ac_cv_header_malloc_h" "$ac_includes_default"
if test "x$ac_cv_header_malloc_h" = xyes
then :
printf "%s\n" "#define HAVE_MALLOC_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "regex.h" "ac_cv_header_regex_h" "$ac_includes_default"
if test "x$ac_cv_header_regex_h" = xyes
then :
printf "%s\n" "#define HAVE_REGEX_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "getopt.h" "ac_cv_header_getopt_h" "$ac_includes_default"
if test "x$ac_cv_header_getopt_h" = xyes
then :
printf "%s\n" "#define HAVE_GETOPT_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "fnmatch.h" "ac_cv_header_fnmatch_h" "$ac_includes_default"
if test "x$ac_cv_header_fnmatch_h" = xyes
then :
printf "%s\n" "#define HAVE_FNMATCH_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "langinfo.h" "ac_cv_header_langinfo_h" "$ac_includes_default"
if test "x$ac_cv_header_langinfo_h" = xyes
then :
printf "%s\n" "#define HAVE_LANGINFO_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "xlocale.h" "ac_cv_header_xlocale_h" "$ac_includes_default"
if test "x$ac_cv_header_xlocale_h" = xyes
then :
printf "%s\n" "#define HAVE_XLOCALE_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "linux/random.h" "ac_cv_header_linux_random_h" "$ac_includes_default"
if test "x$ac_cv_header_linux_random_h" = xyes
then :
printf "%s\n" "#define HAVE_LINUX_RANDOM_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "ucred.h" "ac_cv_header_ucred_h" "
#ifdef HAVE_SYS_TYPES_H
#include
#endif
#ifdef HAVE_SYS_PARAM_H
#include
#endif
"
if test "x$ac_cv_header_ucred_h" = xyes
then :
printf "%s\n" "#define HAVE_UCRED_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/ucred.h" "ac_cv_header_sys_ucred_h" "
#ifdef HAVE_SYS_TYPES_H
#include
#endif
#ifdef HAVE_SYS_PARAM_H
#include
#endif
"
if test "x$ac_cv_header_sys_ucred_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_UCRED_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/resource.h" "ac_cv_header_sys_resource_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_resource_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_RESOURCE_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "sys/wait.h" "ac_cv_header_sys_wait_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_wait_h" = xyes
then :
printf "%s\n" "#define HAVE_SYS_WAIT_H 1" >>confdefs.h
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
printf %s "checking for inline... " >&6; }
if test ${ac_cv_c_inline+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_c_inline=no
for ac_kw in inline __inline__ __inline; do
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifndef __cplusplus
typedef int foo_t;
static $ac_kw foo_t static_foo (void) {return 0; }
$ac_kw foo_t foo (void) {return 0; }
#endif
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_c_inline=$ac_kw
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
test "$ac_cv_c_inline" != no && break
done
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
printf "%s\n" "$ac_cv_c_inline" >&6; }
case $ac_cv_c_inline in
inline | yes) ;;
*)
case $ac_cv_c_inline in
no) ac_val=;;
*) ac_val=$ac_cv_c_inline;;
esac
cat >>confdefs.h <<_ACEOF
#ifndef __cplusplus
#define inline $ac_val
#endif
_ACEOF
;;
esac
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C/C++ restrict keyword" >&5
printf %s "checking for C/C++ restrict keyword... " >&6; }
if test ${ac_cv_c_restrict+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_c_restrict=no
# Put '__restrict__' first, to avoid problems with glibc and non-GCC; see:
# https://lists.gnu.org/archive/html/bug-autoconf/2016-02/msg00006.html
# Put 'restrict' last, because C++ lacks it.
for ac_kw in __restrict__ __restrict _Restrict restrict; do
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
typedef int *int_ptr;
int foo (int_ptr $ac_kw ip) { return ip[0]; }
int bar (int [$ac_kw]); /* Catch GCC bug 14050. */
int bar (int ip[$ac_kw]) { return ip[0]; }
int
main (void)
{
int s[1];
int *$ac_kw t = s;
t[0] = 0;
return foo (t) + bar (t);
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_c_restrict=$ac_kw
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
test "$ac_cv_c_restrict" != no && break
done
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_restrict" >&5
printf "%s\n" "$ac_cv_c_restrict" >&6; }
case $ac_cv_c_restrict in
restrict) ;;
no) printf "%s\n" "#define restrict /**/" >>confdefs.h
;;
*) printf "%s\n" "#define restrict $ac_cv_c_restrict" >>confdefs.h
;;
esac
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
printf %s "checking whether byte ordering is bigendian... " >&6; }
if test ${ac_cv_c_bigendian+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_c_bigendian=unknown
# See if we're dealing with a universal compiler.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifndef __APPLE_CC__
not a universal capable compiler
#endif
typedef int dummy;
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
# Check for potential -arch flags. It is not universal unless
# there are at least two -arch flags with different values.
ac_arch=
ac_prev=
for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do
if test -n "$ac_prev"; then
case $ac_word in
i?86 | x86_64 | ppc | ppc64)
if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then
ac_arch=$ac_word
else
ac_cv_c_bigendian=universal
break
fi
;;
esac
ac_prev=
elif test "x$ac_word" = "x-arch"; then
ac_prev=arch
fi
done
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
if test $ac_cv_c_bigendian = unknown; then
# See if sys/param.h defines the BYTE_ORDER macro.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
int
main (void)
{
#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
&& defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
&& LITTLE_ENDIAN)
bogus endian macros
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
# It does; now see whether it defined to BIG_ENDIAN or not.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
int
main (void)
{
#if BYTE_ORDER != BIG_ENDIAN
not big endian
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_c_bigendian=yes
else $as_nop
ac_cv_c_bigendian=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
if test $ac_cv_c_bigendian = unknown; then
# See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
bogus endian macros
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
# It does; now see whether it defined to _BIG_ENDIAN or not.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
#ifndef _BIG_ENDIAN
not big endian
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_c_bigendian=yes
else $as_nop
ac_cv_c_bigendian=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
if test $ac_cv_c_bigendian = unknown; then
# Compile a test program.
if test "$cross_compiling" = yes
then :
# Try to guess by grepping values from an object file.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
unsigned short int ascii_mm[] =
{ 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
unsigned short int ascii_ii[] =
{ 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
int use_ascii (int i) {
return ascii_mm[i] + ascii_ii[i];
}
unsigned short int ebcdic_ii[] =
{ 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
unsigned short int ebcdic_mm[] =
{ 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
int use_ebcdic (int i) {
return ebcdic_mm[i] + ebcdic_ii[i];
}
extern int foo;
int
main (void)
{
return use_ascii (foo) == use_ebcdic (foo);
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
ac_cv_c_bigendian=yes
fi
if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
if test "$ac_cv_c_bigendian" = unknown; then
ac_cv_c_bigendian=no
else
# finding both strings is unlikely to happen, but who knows?
ac_cv_c_bigendian=unknown
fi
fi
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$ac_includes_default
int
main (void)
{
/* Are we little or big endian? From Harbison&Steele. */
union
{
long int l;
char c[sizeof (long int)];
} u;
u.l = 1;
return u.c[sizeof (long int) - 1] == 1;
;
return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"
then :
ac_cv_c_bigendian=no
else $as_nop
ac_cv_c_bigendian=yes
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
printf "%s\n" "$ac_cv_c_bigendian" >&6; }
case $ac_cv_c_bigendian in #(
yes)
printf "%s\n" "#define WORDS_BIGENDIAN 1" >>confdefs.h
;; #(
no)
;; #(
universal)
printf "%s\n" "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
;; #(
*)
as_fn_error $? "unknown endianness
presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;;
esac
# Check whether --enable-largefile was given.
if test ${enable_largefile+y}
then :
enableval=$enable_largefile;
fi
if test "$enable_largefile" != no; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for special C compiler options needed for large files" >&5
printf %s "checking for special C compiler options needed for large files... " >&6; }
if test ${ac_cv_sys_largefile_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_sys_largefile_CC=no
if test "$GCC" != yes; then
ac_save_CC=$CC
while :; do
# IRIX 6.2 and later do not support large files by default,
# so use the C compiler's -n32 option if that helps.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
/* Check that off_t can represent 2**63 - 1 correctly.
We can't simply define LARGE_OFF_T to be 9223372036854775807,
since some C++ compilers masquerading as C compilers
incorrectly reject 9223372036854775807. */
#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
&& LARGE_OFF_T % 2147483647 == 1)
? 1 : -1];
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam
CC="$CC -n32"
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_sys_largefile_CC=' -n32'; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam
break
done
CC=$ac_save_CC
rm -f conftest.$ac_ext
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_CC" >&5
printf "%s\n" "$ac_cv_sys_largefile_CC" >&6; }
if test "$ac_cv_sys_largefile_CC" != no; then
CC=$CC$ac_cv_sys_largefile_CC
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _FILE_OFFSET_BITS value needed for large files" >&5
printf %s "checking for _FILE_OFFSET_BITS value needed for large files... " >&6; }
if test ${ac_cv_sys_file_offset_bits+y}
then :
printf %s "(cached) " >&6
else $as_nop
while :; do
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
/* Check that off_t can represent 2**63 - 1 correctly.
We can't simply define LARGE_OFF_T to be 9223372036854775807,
since some C++ compilers masquerading as C compilers
incorrectly reject 9223372036854775807. */
#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
&& LARGE_OFF_T % 2147483647 == 1)
? 1 : -1];
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_sys_file_offset_bits=no; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#define _FILE_OFFSET_BITS 64
#include
/* Check that off_t can represent 2**63 - 1 correctly.
We can't simply define LARGE_OFF_T to be 9223372036854775807,
since some C++ compilers masquerading as C compilers
incorrectly reject 9223372036854775807. */
#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
&& LARGE_OFF_T % 2147483647 == 1)
? 1 : -1];
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_sys_file_offset_bits=64; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
ac_cv_sys_file_offset_bits=unknown
break
done
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_file_offset_bits" >&5
printf "%s\n" "$ac_cv_sys_file_offset_bits" >&6; }
case $ac_cv_sys_file_offset_bits in #(
no | unknown) ;;
*)
printf "%s\n" "#define _FILE_OFFSET_BITS $ac_cv_sys_file_offset_bits" >>confdefs.h
;;
esac
rm -rf conftest*
if test $ac_cv_sys_file_offset_bits = unknown; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _LARGE_FILES value needed for large files" >&5
printf %s "checking for _LARGE_FILES value needed for large files... " >&6; }
if test ${ac_cv_sys_large_files+y}
then :
printf %s "(cached) " >&6
else $as_nop
while :; do
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
/* Check that off_t can represent 2**63 - 1 correctly.
We can't simply define LARGE_OFF_T to be 9223372036854775807,
since some C++ compilers masquerading as C compilers
incorrectly reject 9223372036854775807. */
#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
&& LARGE_OFF_T % 2147483647 == 1)
? 1 : -1];
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_sys_large_files=no; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#define _LARGE_FILES 1
#include
/* Check that off_t can represent 2**63 - 1 correctly.
We can't simply define LARGE_OFF_T to be 9223372036854775807,
since some C++ compilers masquerading as C compilers
incorrectly reject 9223372036854775807. */
#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
int off_t_is_large[(LARGE_OFF_T % 2147483629 == 721
&& LARGE_OFF_T % 2147483647 == 1)
? 1 : -1];
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_sys_large_files=1; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
ac_cv_sys_large_files=unknown
break
done
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_large_files" >&5
printf "%s\n" "$ac_cv_sys_large_files" >&6; }
case $ac_cv_sys_large_files in #(
no | unknown) ;;
*)
printf "%s\n" "#define _LARGE_FILES $ac_cv_sys_large_files" >>confdefs.h
;;
esac
rm -rf conftest*
fi
fi
ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default
"
if test "x$ac_cv_type_pid_t" = xyes
then :
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#if defined _WIN64 && !defined __CYGWIN__
LLP64
#endif
int
main (void)
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_pid_type='int'
else $as_nop
ac_pid_type='__int64'
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
printf "%s\n" "#define pid_t $ac_pid_type" >>confdefs.h
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for uid_t in sys/types.h" >&5
printf %s "checking for uid_t in sys/types.h... " >&6; }
if test ${ac_cv_type_uid_t+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "uid_t" >/dev/null 2>&1
then :
ac_cv_type_uid_t=yes
else $as_nop
ac_cv_type_uid_t=no
fi
rm -rf conftest*
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_type_uid_t" >&5
printf "%s\n" "$ac_cv_type_uid_t" >&6; }
if test $ac_cv_type_uid_t = no; then
printf "%s\n" "#define uid_t int" >>confdefs.h
printf "%s\n" "#define gid_t int" >>confdefs.h
fi
ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
if test "x$ac_cv_type_size_t" = xyes
then :
else $as_nop
printf "%s\n" "#define size_t unsigned int" >>confdefs.h
fi
ac_fn_c_find_uintX_t "$LINENO" "8" "ac_cv_c_uint8_t"
case $ac_cv_c_uint8_t in #(
no|yes) ;; #(
*)
printf "%s\n" "#define _UINT8_T 1" >>confdefs.h
printf "%s\n" "#define uint8_t $ac_cv_c_uint8_t" >>confdefs.h
;;
esac
ac_fn_c_find_uintX_t "$LINENO" "32" "ac_cv_c_uint32_t"
case $ac_cv_c_uint32_t in #(
no|yes) ;; #(
*)
printf "%s\n" "#define _UINT32_T 1" >>confdefs.h
printf "%s\n" "#define uint32_t $ac_cv_c_uint32_t" >>confdefs.h
;;
esac
ac_fn_c_find_uintX_t "$LINENO" "64" "ac_cv_c_uint64_t"
case $ac_cv_c_uint64_t in #(
no|yes) ;; #(
*)
printf "%s\n" "#define _UINT64_T 1" >>confdefs.h
printf "%s\n" "#define uint64_t $ac_cv_c_uint64_t" >>confdefs.h
;;
esac
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5
printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; }
if test ${ac_cv_c_undeclared_builtin_options+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_save_CFLAGS=$CFLAGS
ac_cv_c_undeclared_builtin_options='cannot detect'
for ac_arg in '' -fno-builtin; do
CFLAGS="$ac_save_CFLAGS $ac_arg"
# This test program should *not* compile successfully.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main (void)
{
(void) strchr;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
else $as_nop
# This test program should compile successfully.
# No library function is consistently available on
# freestanding implementations, so test against a dummy
# declaration. Include always-available headers on the
# off chance that they somehow elicit warnings.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
#include
#include
extern void ac_decl (int, char *);
int
main (void)
{
(void) ac_decl (0, (char *) 0);
(void) ac_decl;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
if test x"$ac_arg" = x
then :
ac_cv_c_undeclared_builtin_options='none needed'
else $as_nop
ac_cv_c_undeclared_builtin_options=$ac_arg
fi
break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
done
CFLAGS=$ac_save_CFLAGS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5
printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; }
case $ac_cv_c_undeclared_builtin_options in #(
'cannot detect') :
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot make $CC report undeclared builtins
See \`config.log' for more details" "$LINENO" 5; } ;; #(
'none needed') :
ac_c_undeclared_builtin_options='' ;; #(
*) :
ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;;
esac
ac_fn_check_decl "$LINENO" "strerror_r" "ac_cv_have_decl_strerror_r" "$ac_includes_default" "$ac_c_undeclared_builtin_options" "CFLAGS"
if test "x$ac_cv_have_decl_strerror_r" = xyes
then :
ac_have_decl=1
else $as_nop
ac_have_decl=0
fi
printf "%s\n" "#define HAVE_DECL_STRERROR_R $ac_have_decl" >>confdefs.h
### Functions provided if missing
ac_fn_c_check_func "$LINENO" "strlcpy" "ac_cv_func_strlcpy"
if test "x$ac_cv_func_strlcpy" = xyes
then :
printf "%s\n" "#define HAVE_STRLCPY 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "strlcat" "ac_cv_func_strlcat"
if test "x$ac_cv_func_strlcat" = xyes
then :
printf "%s\n" "#define HAVE_STRLCAT 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "strnlen" "ac_cv_func_strnlen"
if test "x$ac_cv_func_strnlen" = xyes
then :
printf "%s\n" "#define HAVE_STRNLEN 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "strsep" "ac_cv_func_strsep"
if test "x$ac_cv_func_strsep" = xyes
then :
printf "%s\n" "#define HAVE_STRSEP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getpeereid" "ac_cv_func_getpeereid"
if test "x$ac_cv_func_getpeereid" = xyes
then :
printf "%s\n" "#define HAVE_GETPEEREID 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "sigaction" "ac_cv_func_sigaction"
if test "x$ac_cv_func_sigaction" = xyes
then :
printf "%s\n" "#define HAVE_SIGACTION 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "sigqueue" "ac_cv_func_sigqueue"
if test "x$ac_cv_func_sigqueue" = xyes
then :
printf "%s\n" "#define HAVE_SIGQUEUE 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "memmem" "ac_cv_func_memmem"
if test "x$ac_cv_func_memmem" = xyes
then :
printf "%s\n" "#define HAVE_MEMMEM 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "memrchr" "ac_cv_func_memrchr"
if test "x$ac_cv_func_memrchr" = xyes
then :
printf "%s\n" "#define HAVE_MEMRCHR 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "mempcpy" "ac_cv_func_mempcpy"
if test "x$ac_cv_func_mempcpy" = xyes
then :
printf "%s\n" "#define HAVE_MEMPCPY 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "inet_ntop" "ac_cv_func_inet_ntop"
if test "x$ac_cv_func_inet_ntop" = xyes
then :
printf "%s\n" "#define HAVE_INET_NTOP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "inet_pton" "ac_cv_func_inet_pton"
if test "x$ac_cv_func_inet_pton" = xyes
then :
printf "%s\n" "#define HAVE_INET_PTON 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "poll" "ac_cv_func_poll"
if test "x$ac_cv_func_poll" = xyes
then :
printf "%s\n" "#define HAVE_POLL 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getline" "ac_cv_func_getline"
if test "x$ac_cv_func_getline" = xyes
then :
printf "%s\n" "#define HAVE_GETLINE 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "regcomp" "ac_cv_func_regcomp"
if test "x$ac_cv_func_regcomp" = xyes
then :
printf "%s\n" "#define HAVE_REGCOMP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "err" "ac_cv_func_err"
if test "x$ac_cv_func_err" = xyes
then :
printf "%s\n" "#define HAVE_ERR 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "errx" "ac_cv_func_errx"
if test "x$ac_cv_func_errx" = xyes
then :
printf "%s\n" "#define HAVE_ERRX 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "warn" "ac_cv_func_warn"
if test "x$ac_cv_func_warn" = xyes
then :
printf "%s\n" "#define HAVE_WARN 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "warnx" "ac_cv_func_warnx"
if test "x$ac_cv_func_warnx" = xyes
then :
printf "%s\n" "#define HAVE_WARNX 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getprogname" "ac_cv_func_getprogname"
if test "x$ac_cv_func_getprogname" = xyes
then :
printf "%s\n" "#define HAVE_GETPROGNAME 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "setprogname" "ac_cv_func_setprogname"
if test "x$ac_cv_func_setprogname" = xyes
then :
printf "%s\n" "#define HAVE_SETPROGNAME 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "posix_memalign" "ac_cv_func_posix_memalign"
if test "x$ac_cv_func_posix_memalign" = xyes
then :
printf "%s\n" "#define HAVE_POSIX_MEMALIGN 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "memalign" "ac_cv_func_memalign"
if test "x$ac_cv_func_memalign" = xyes
then :
printf "%s\n" "#define HAVE_MEMALIGN 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "valloc" "ac_cv_func_valloc"
if test "x$ac_cv_func_valloc" = xyes
then :
printf "%s\n" "#define HAVE_VALLOC 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "explicit_bzero" "ac_cv_func_explicit_bzero"
if test "x$ac_cv_func_explicit_bzero" = xyes
then :
printf "%s\n" "#define HAVE_EXPLICIT_BZERO 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "memset_s" "ac_cv_func_memset_s"
if test "x$ac_cv_func_memset_s" = xyes
then :
printf "%s\n" "#define HAVE_MEMSET_S 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "reallocarray" "ac_cv_func_reallocarray"
if test "x$ac_cv_func_reallocarray" = xyes
then :
printf "%s\n" "#define HAVE_REALLOCARRAY 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getopt" "ac_cv_func_getopt"
if test "x$ac_cv_func_getopt" = xyes
then :
printf "%s\n" "#define HAVE_GETOPT 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getopt_long" "ac_cv_func_getopt_long"
if test "x$ac_cv_func_getopt_long" = xyes
then :
printf "%s\n" "#define HAVE_GETOPT_LONG 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getopt_long_only" "ac_cv_func_getopt_long_only"
if test "x$ac_cv_func_getopt_long_only" = xyes
then :
printf "%s\n" "#define HAVE_GETOPT_LONG_ONLY 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "fls" "ac_cv_func_fls"
if test "x$ac_cv_func_fls" = xyes
then :
printf "%s\n" "#define HAVE_FLS 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "flsl" "ac_cv_func_flsl"
if test "x$ac_cv_func_flsl" = xyes
then :
printf "%s\n" "#define HAVE_FLSL 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "flsll" "ac_cv_func_flsll"
if test "x$ac_cv_func_flsll" = xyes
then :
printf "%s\n" "#define HAVE_FLSLL 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "ffs" "ac_cv_func_ffs"
if test "x$ac_cv_func_ffs" = xyes
then :
printf "%s\n" "#define HAVE_FFS 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "ffsl" "ac_cv_func_ffsl"
if test "x$ac_cv_func_ffsl" = xyes
then :
printf "%s\n" "#define HAVE_FFSL 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "ffsll" "ac_cv_func_ffsll"
if test "x$ac_cv_func_ffsll" = xyes
then :
printf "%s\n" "#define HAVE_FFSLL 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "fnmatch" "ac_cv_func_fnmatch"
if test "x$ac_cv_func_fnmatch" = xyes
then :
printf "%s\n" "#define HAVE_FNMATCH 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "mbsnrtowcs" "ac_cv_func_mbsnrtowcs"
if test "x$ac_cv_func_mbsnrtowcs" = xyes
then :
printf "%s\n" "#define HAVE_MBSNRTOWCS 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "nl_langinfo" "ac_cv_func_nl_langinfo"
if test "x$ac_cv_func_nl_langinfo" = xyes
then :
printf "%s\n" "#define HAVE_NL_LANGINFO 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "strtod_l" "ac_cv_func_strtod_l"
if test "x$ac_cv_func_strtod_l" = xyes
then :
printf "%s\n" "#define HAVE_STRTOD_L 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "strtonum" "ac_cv_func_strtonum"
if test "x$ac_cv_func_strtonum" = xyes
then :
printf "%s\n" "#define HAVE_STRTONUM 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "asprintf" "ac_cv_func_asprintf"
if test "x$ac_cv_func_asprintf" = xyes
then :
printf "%s\n" "#define HAVE_ASPRINTF 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "vasprintf" "ac_cv_func_vasprintf"
if test "x$ac_cv_func_vasprintf" = xyes
then :
printf "%s\n" "#define HAVE_VASPRINTF 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "timegm" "ac_cv_func_timegm"
if test "x$ac_cv_func_timegm" = xyes
then :
printf "%s\n" "#define HAVE_TIMEGM 1" >>confdefs.h
fi
### Functions provided only on win32
ac_fn_c_check_func "$LINENO" "localtime_r" "ac_cv_func_localtime_r"
if test "x$ac_cv_func_localtime_r" = xyes
then :
printf "%s\n" "#define HAVE_LOCALTIME_R 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "gettimeofday" "ac_cv_func_gettimeofday"
if test "x$ac_cv_func_gettimeofday" = xyes
then :
printf "%s\n" "#define HAVE_GETTIMEOFDAY 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "recvmsg" "ac_cv_func_recvmsg"
if test "x$ac_cv_func_recvmsg" = xyes
then :
printf "%s\n" "#define HAVE_RECVMSG 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "sendmsg" "ac_cv_func_sendmsg"
if test "x$ac_cv_func_sendmsg" = xyes
then :
printf "%s\n" "#define HAVE_SENDMSG 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "usleep" "ac_cv_func_usleep"
if test "x$ac_cv_func_usleep" = xyes
then :
printf "%s\n" "#define HAVE_USLEEP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getrusage" "ac_cv_func_getrusage"
if test "x$ac_cv_func_getrusage" = xyes
then :
printf "%s\n" "#define HAVE_GETRUSAGE 1" >>confdefs.h
fi
### Functions used by libusual itself
ac_fn_c_check_func "$LINENO" "syslog" "ac_cv_func_syslog"
if test "x$ac_cv_func_syslog" = xyes
then :
printf "%s\n" "#define HAVE_SYSLOG 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "mmap" "ac_cv_func_mmap"
if test "x$ac_cv_func_mmap" = xyes
then :
printf "%s\n" "#define HAVE_MMAP 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getpeerucred" "ac_cv_func_getpeerucred"
if test "x$ac_cv_func_getpeerucred" = xyes
then :
printf "%s\n" "#define HAVE_GETPEERUCRED 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "arc4random_buf" "ac_cv_func_arc4random_buf"
if test "x$ac_cv_func_arc4random_buf" = xyes
then :
printf "%s\n" "#define HAVE_ARC4RANDOM_BUF 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getentropy" "ac_cv_func_getentropy"
if test "x$ac_cv_func_getentropy" = xyes
then :
printf "%s\n" "#define HAVE_GETENTROPY 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "getrandom" "ac_cv_func_getrandom"
if test "x$ac_cv_func_getrandom" = xyes
then :
printf "%s\n" "#define HAVE_GETRANDOM 1" >>confdefs.h
fi
### win32: link with ws2_32
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing WSAGetLastError" >&5
printf %s "checking for library containing WSAGetLastError... " >&6; }
if test ${ac_cv_search_WSAGetLastError+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char WSAGetLastError ();
int
main (void)
{
return WSAGetLastError ();
;
return 0;
}
_ACEOF
for ac_lib in '' ws2_32
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_WSAGetLastError=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_WSAGetLastError+y}
then :
break
fi
done
if test ${ac_cv_search_WSAGetLastError+y}
then :
else $as_nop
ac_cv_search_WSAGetLastError=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_WSAGetLastError" >&5
printf "%s\n" "$ac_cv_search_WSAGetLastError" >&6; }
ac_res=$ac_cv_search_WSAGetLastError
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
fi
if test $ac_cv_have_decl_strerror_r = yes; then
# For backward compatibility's sake, define HAVE_STRERROR_R.
# (We used to run AC_CHECK_FUNCS_ONCE for strerror_r, as well
# as AC_CHECK_DECLS_ONCE.)
printf "%s\n" "#define HAVE_STRERROR_R 1" >>confdefs.h
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether strerror_r returns char *" >&5
printf %s "checking whether strerror_r returns char *... " >&6; }
if test ${ac_cv_func_strerror_r_char_p+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_cv_func_strerror_r_char_p=no
if test $ac_cv_have_decl_strerror_r = yes; then
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
char buf[100];
char x = *strerror_r (0, buf, sizeof buf);
char *p = strerror_r (0, buf, sizeof buf);
return !p || x;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"
then :
ac_cv_func_strerror_r_char_p=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strerror_r_char_p" >&5
printf "%s\n" "$ac_cv_func_strerror_r_char_p" >&6; }
if test $ac_cv_func_strerror_r_char_p = yes; then
printf "%s\n" "#define STRERROR_R_CHAR_P 1" >>confdefs.h
fi
###
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for integer enc/dec functions" >&5
printf %s "checking for integer enc/dec functions... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#ifdef HAVE_SYS_ENDIAN_H
#include
#endif
#ifdef HAVE_ENDIAN_H
#include
#endif
char p[] = "01234567";
int main(void) {
be16enc(p, 0); be32enc(p, 1); be64enc(p, 2);
le16enc(p, 2); le32enc(p, 3); le64enc(p, 4);
return (int)(be16dec(p) + be32dec(p) + be64dec(p)) +
(int)(le16dec(p) + le32dec(p) + le64dec(p));
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: found" >&5
printf "%s\n" "found" >&6; }
printf "%s\n" "#define HAVE_ENCDEC_FUNCS 1" >>confdefs.h
else $as_nop
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
printf "%s\n" "not found" >&6; }
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
printf %s "checking for library containing clock_gettime... " >&6; }
if test ${ac_cv_search_clock_gettime+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char clock_gettime ();
int
main (void)
{
return clock_gettime ();
;
return 0;
}
_ACEOF
for ac_lib in '' rt
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_clock_gettime=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_clock_gettime+y}
then :
break
fi
done
if test ${ac_cv_search_clock_gettime+y}
then :
else $as_nop
ac_cv_search_clock_gettime=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime" >&5
printf "%s\n" "$ac_cv_search_clock_gettime" >&6; }
ac_res=$ac_cv_search_clock_gettime
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing getsockname" >&5
printf %s "checking for library containing getsockname... " >&6; }
if test ${ac_cv_search_getsockname+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char getsockname ();
int
main (void)
{
return getsockname ();
;
return 0;
}
_ACEOF
for ac_lib in '' socket
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_getsockname=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_getsockname+y}
then :
break
fi
done
if test ${ac_cv_search_getsockname+y}
then :
else $as_nop
ac_cv_search_getsockname=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getsockname" >&5
printf "%s\n" "$ac_cv_search_getsockname" >&6; }
ac_res=$ac_cv_search_getsockname
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing gethostbyname" >&5
printf %s "checking for library containing gethostbyname... " >&6; }
if test ${ac_cv_search_gethostbyname+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char gethostbyname ();
int
main (void)
{
return gethostbyname ();
;
return 0;
}
_ACEOF
for ac_lib in '' nsl
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_gethostbyname=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_gethostbyname+y}
then :
break
fi
done
if test ${ac_cv_search_gethostbyname+y}
then :
else $as_nop
ac_cv_search_gethostbyname=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_gethostbyname" >&5
printf "%s\n" "$ac_cv_search_gethostbyname" >&6; }
ac_res=$ac_cv_search_gethostbyname
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing hstrerror" >&5
printf %s "checking for library containing hstrerror... " >&6; }
if test ${ac_cv_search_hstrerror+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char hstrerror ();
int
main (void)
{
return hstrerror ();
;
return 0;
}
_ACEOF
for ac_lib in '' resolv
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_hstrerror=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_hstrerror+y}
then :
break
fi
done
if test ${ac_cv_search_hstrerror+y}
then :
else $as_nop
ac_cv_search_hstrerror=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_hstrerror" >&5
printf "%s\n" "$ac_cv_search_hstrerror" >&6; }
ac_res=$ac_cv_search_hstrerror
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
fi
ac_fn_c_check_func "$LINENO" "lstat" "ac_cv_func_lstat"
if test "x$ac_cv_func_lstat" = xyes
then :
printf "%s\n" "#define HAVE_LSTAT 1" >>confdefs.h
fi
pkg_failed=no
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libevent" >&5
printf %s "checking for libevent... " >&6; }
if test -n "$LIBEVENT_CFLAGS"; then
pkg_cv_LIBEVENT_CFLAGS="$LIBEVENT_CFLAGS"
elif test -n "$PKG_CONFIG"; then
if test -n "$PKG_CONFIG" && \
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libevent\""; } >&5
($PKG_CONFIG --exists --print-errors "libevent") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_LIBEVENT_CFLAGS=`$PKG_CONFIG --cflags "libevent" 2>/dev/null`
test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
else
pkg_failed=untried
fi
if test -n "$LIBEVENT_LIBS"; then
pkg_cv_LIBEVENT_LIBS="$LIBEVENT_LIBS"
elif test -n "$PKG_CONFIG"; then
if test -n "$PKG_CONFIG" && \
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libevent\""; } >&5
($PKG_CONFIG --exists --print-errors "libevent") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_LIBEVENT_LIBS=`$PKG_CONFIG --libs "libevent" 2>/dev/null`
test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
else
pkg_failed=untried
fi
if test $pkg_failed = yes; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
else
_pkg_short_errors_supported=no
fi
if test $_pkg_short_errors_supported = yes; then
LIBEVENT_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libevent" 2>&1`
else
LIBEVENT_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libevent" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$LIBEVENT_PKG_ERRORS" >&5
as_fn_error $? "Package requirements (libevent) were not met:
$LIBEVENT_PKG_ERRORS
Consider adjusting the PKG_CONFIG_PATH environment variable if you
installed software in a non-standard prefix.
Alternatively, you may set the environment variables LIBEVENT_CFLAGS
and LIBEVENT_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details." "$LINENO" 5
elif test $pkg_failed = untried; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it
is in your PATH or set the PKG_CONFIG environment variable to the full
path to pkg-config.
Alternatively, you may set the environment variables LIBEVENT_CFLAGS
and LIBEVENT_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details.
To get pkg-config, see .
See \`config.log' for more details" "$LINENO" 5; }
else
LIBEVENT_CFLAGS=$pkg_cv_LIBEVENT_CFLAGS
LIBEVENT_LIBS=$pkg_cv_LIBEVENT_LIBS
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
fi
pam_support=no
# Check whether --with-pam was given.
if test ${with_pam+y}
then :
withval=$with_pam; PAM=
if test "$withval" != no; then
have_pthreads=no
# Look for PAM header and lib
for ac_header in security/pam_appl.h
do :
ac_fn_c_check_header_compile "$LINENO" "security/pam_appl.h" "ac_cv_header_security_pam_appl_h" "$ac_includes_default"
if test "x$ac_cv_header_security_pam_appl_h" = xyes
then :
printf "%s\n" "#define HAVE_SECURITY_PAM_APPL_H 1" >>confdefs.h
have_pam_header=t
fi
done
for ac_header in pthread.h
do :
ac_fn_c_check_header_compile "$LINENO" "pthread.h" "ac_cv_header_pthread_h" "$ac_includes_default"
if test "x$ac_cv_header_pthread_h" = xyes
then :
printf "%s\n" "#define HAVE_PTHREAD_H 1" >>confdefs.h
have_pthreads=yes
fi
done
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing pam_start" >&5
printf %s "checking for library containing pam_start... " >&6; }
if test ${ac_cv_search_pam_start+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char pam_start ();
int
main (void)
{
return pam_start ();
;
return 0;
}
_ACEOF
for ac_lib in '' pam
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_pam_start=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_pam_start+y}
then :
break
fi
done
if test ${ac_cv_search_pam_start+y}
then :
else $as_nop
ac_cv_search_pam_start=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_pam_start" >&5
printf "%s\n" "$ac_cv_search_pam_start" >&6; }
ac_res=$ac_cv_search_pam_start
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
have_libpam=t
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing pthread_create" >&5
printf %s "checking for library containing pthread_create... " >&6; }
if test ${ac_cv_search_pthread_create+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char pthread_create ();
int
main (void)
{
return pthread_create ();
;
return 0;
}
_ACEOF
for ac_lib in '' pthread
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_pthread_create=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_pthread_create+y}
then :
break
fi
done
if test ${ac_cv_search_pthread_create+y}
then :
else $as_nop
ac_cv_search_pthread_create=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_pthread_create" >&5
printf "%s\n" "$ac_cv_search_pthread_create" >&6; }
ac_res=$ac_cv_search_pthread_create
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
else $as_nop
have_pthreads=no
fi
if test x"${have_pthreads}" != xyes; then
as_fn_error $? "pthread library should be available for PAM support" "$LINENO" 5
fi
if test x"${have_pam_header}" != x -a x"${have_libpam}" != x -a x"${have_pthreads}" = xyes; then
pam_support=yes
printf "%s\n" "#define HAVE_PAM 1" >>confdefs.h
fi
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build with systemd support" >&5
printf %s "checking whether to build with systemd support... " >&6; }
# Check whether --with-systemd was given.
if test ${with_systemd+y}
then :
withval=$with_systemd; if test "$withval" != no; then with_systemd=yes; else with_systemd=no; fi
else $as_nop
with_systemd=no
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_systemd" >&5
printf "%s\n" "$with_systemd" >&6; }
if test "$with_systemd" = yes; then
printf "%s\n" "#define USE_SYSTEMD 1" >>confdefs.h
ac_fn_c_check_header_compile "$LINENO" "systemd/sd-daemon.h" "ac_cv_header_systemd_sd_daemon_h" "$ac_includes_default"
if test "x$ac_cv_header_systemd_sd_daemon_h" = xyes
then :
else $as_nop
as_fn_error $? "header file is required for systemd support" "$LINENO" 5
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing sd_notify" >&5
printf %s "checking for library containing sd_notify... " >&6; }
if test ${ac_cv_search_sd_notify+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char sd_notify ();
int
main (void)
{
return sd_notify ();
;
return 0;
}
_ACEOF
for ac_lib in '' systemd
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_sd_notify=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_sd_notify+y}
then :
break
fi
done
if test ${ac_cv_search_sd_notify+y}
then :
else $as_nop
ac_cv_search_sd_notify=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_sd_notify" >&5
printf "%s\n" "$ac_cv_search_sd_notify" >&6; }
ac_res=$ac_cv_search_sd_notify
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
fi
fi
##
## DNS backend
##
# make sure all vars are set
use_cares=no
use_evdns=no
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use c-ares for DNS lookups" >&5
printf %s "checking whether to use c-ares for DNS lookups... " >&6; }
# Check whether --with-cares was given.
if test ${with_cares+y}
then :
withval=$with_cares; if test "$withval" = "no"; then
use_cares=no
elif test "$withval" = "yes"; then
use_cares="$withval"
CARES_CFLAGS=""
CARES_LIBS="-lcares"
elif test "$withval" = "auto"; then
use_cares="$withval"
else
use_cares=yes
CARES_CFLAGS="-I$withval/include"
CARES_LIBS="-L$withval/lib -lcares"
fi
else $as_nop
use_cares=auto
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $use_cares" >&5
printf "%s\n" "$use_cares" >&6; }
if test "$use_cares" = "auto"; then
pkg_failed=no
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libcares >= 1.9.0" >&5
printf %s "checking for libcares >= 1.9.0... " >&6; }
if test -n "$CARES_CFLAGS"; then
pkg_cv_CARES_CFLAGS="$CARES_CFLAGS"
elif test -n "$PKG_CONFIG"; then
if test -n "$PKG_CONFIG" && \
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libcares >= 1.9.0\""; } >&5
($PKG_CONFIG --exists --print-errors "libcares >= 1.9.0") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_CARES_CFLAGS=`$PKG_CONFIG --cflags "libcares >= 1.9.0" 2>/dev/null`
test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
else
pkg_failed=untried
fi
if test -n "$CARES_LIBS"; then
pkg_cv_CARES_LIBS="$CARES_LIBS"
elif test -n "$PKG_CONFIG"; then
if test -n "$PKG_CONFIG" && \
{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libcares >= 1.9.0\""; } >&5
($PKG_CONFIG --exists --print-errors "libcares >= 1.9.0") 2>&5
ac_status=$?
printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_CARES_LIBS=`$PKG_CONFIG --libs "libcares >= 1.9.0" 2>/dev/null`
test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
else
pkg_failed=untried
fi
if test $pkg_failed = yes; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
else
_pkg_short_errors_supported=no
fi
if test $_pkg_short_errors_supported = yes; then
CARES_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libcares >= 1.9.0" 2>&1`
else
CARES_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libcares >= 1.9.0" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$CARES_PKG_ERRORS" >&5
use_cares=no
elif test $pkg_failed = untried; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
use_cares=no
else
CARES_CFLAGS=$pkg_cv_CARES_CFLAGS
CARES_LIBS=$pkg_cv_CARES_LIBS
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
use_cares=yes
fi
fi
if test "$use_cares" = "yes"; then
printf "%s\n" "#define USE_CARES 1" >>confdefs.h
tmp_CFLAGS="$CFLAGS"
tmp_LIBS="$LIBS"
CFLAGS="$CARES_CFLAGS $CFLAGS"
LIBS="$CARES_LIBS $LIBS"
# portability substitute for arpa/nameser.h, needed mainly for Windows
ac_fn_c_check_header_compile "$LINENO" "ares_nameser.h" "ac_cv_header_ares_nameser_h" "$ac_includes_default"
if test "x$ac_cv_header_ares_nameser_h" = xyes
then :
printf "%s\n" "#define HAVE_ARES_NAMESER_H 1" >>confdefs.h
fi
LIBS="$tmp_LIBS"
CFLAGS="$tmp_CFLAGS"
else # !cares
# Check whether --enable-evdns was given.
if test ${enable_evdns+y}
then :
enableval=$enable_evdns; use_evdns=$enableval
else $as_nop
use_evdns=yes
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use libevent for DNS lookups" >&5
printf %s "checking whether to use libevent for DNS lookups... " >&6; }
if test "$use_evdns" = "yes"; then
printf "%s\n" "#define USE_EVDNS 1" >>confdefs.h
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "$use_cares.$use_evdns" = "no.no"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing getaddrinfo_a" >&5
printf %s "checking for library containing getaddrinfo_a... " >&6; }
if test ${ac_cv_search_getaddrinfo_a+y}
then :
printf %s "(cached) " >&6
else $as_nop
ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char getaddrinfo_a ();
int
main (void)
{
return getaddrinfo_a ();
;
return 0;
}
_ACEOF
for ac_lib in '' anl
do
if test -z "$ac_lib"; then
ac_res="none required"
else
ac_res=-l$ac_lib
LIBS="-l$ac_lib $ac_func_search_save_LIBS"
fi
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_search_getaddrinfo_a=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext
if test ${ac_cv_search_getaddrinfo_a+y}
then :
break
fi
done
if test ${ac_cv_search_getaddrinfo_a+y}
then :
else $as_nop
ac_cv_search_getaddrinfo_a=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_getaddrinfo_a" >&5
printf "%s\n" "$ac_cv_search_getaddrinfo_a" >&6; }
ac_res=$ac_cv_search_getaddrinfo_a
if test "$ac_res" != no
then :
test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use native getaddinfo_a" >&5
printf %s "checking whether to use native getaddinfo_a... " >&6; }
if test ${ac_cv_usual_glibc_gaia+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#ifdef HAVE_NETDB_H
#include
#endif
int
main (void)
{
#if __GLIBC_PREREQ(2,9)
getaddrinfo_a(0,NULL,0,NULL);
#else
none or broken
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
ac_cv_usual_glibc_gaia=yes
else $as_nop
ac_cv_usual_glibc_gaia=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_usual_glibc_gaia" >&5
printf "%s\n" "$ac_cv_usual_glibc_gaia" >&6; }
if test x"$ac_cv_usual_glibc_gaia" = xyes ; then
printf "%s\n" "#define HAVE_GETADDRINFO_A 1" >>confdefs.h
else
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
ax_pthread_ok=no
# We used to check for pthread.h first, but this fails if pthread.h
# requires special compiler flags (e.g. on Tru64 or Sequent).
# It gets checked for in the link test anyway.
# First of all, check if the user has set any of the PTHREAD_LIBS,
# etcetera environment variables, and if threads linking works using
# them:
if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then
ax_pthread_save_CC="$CC"
ax_pthread_save_CFLAGS="$CFLAGS"
ax_pthread_save_LIBS="$LIBS"
if test "x$PTHREAD_CC" != "x"
then :
CC="$PTHREAD_CC"
fi
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS" >&5
printf %s "checking for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
char pthread_join ();
int
main (void)
{
return pthread_join ();
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
ax_pthread_ok=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_ok" >&5
printf "%s\n" "$ax_pthread_ok" >&6; }
if test "x$ax_pthread_ok" = "xno"; then
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
fi
CC="$ax_pthread_save_CC"
CFLAGS="$ax_pthread_save_CFLAGS"
LIBS="$ax_pthread_save_LIBS"
fi
# We must check for the threads library under a number of different
# names; the ordering is very important because some systems
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
# libraries is broken (non-POSIX).
# Create a list of thread flags to try. Items with a "," contain both
# C compiler flags (before ",") and linker flags (after ","). Other items
# starting with a "-" are C compiler flags, and remaining items are
# library names, except for "none" which indicates that we try without
# any flags at all, and "pthread-config" which is a program returning
# the flags for the Pth emulation library.
ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
# The ordering *is* (sometimes) important. Some notes on the
# individual items follow:
# pthreads: AIX (must check this before -lpthread)
# none: in case threads are in libc; should be tried before -Kthread and
# other compiler flags to prevent continual compiler warnings
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64
# (Note: HP C rejects this with "bad form for `-t' option")
# -pthreads: Solaris/gcc (Note: HP C also rejects)
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
# doesn't hurt to check since this sometimes defines pthreads and
# -D_REENTRANT too), HP C (must be checked before -lpthread, which
# is present but should not be used directly; and before -mthreads,
# because the compiler interprets this as "-mt" + "-hreads")
# -mthreads: Mingw32/gcc, Lynx/gcc
# pthread: Linux, etcetera
# --thread-safe: KAI C++
# pthread-config: use pthread-config program (for GNU Pth library)
case $host_os in
freebsd*)
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
ax_pthread_flags="-kthread lthread $ax_pthread_flags"
;;
hpux*)
# From the cc(1) man page: "[-mt] Sets various -D flags to enable
# multi-threading and also sets -lpthread."
ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags"
;;
openedition*)
# IBM z/OS requires a feature-test macro to be defined in order to
# enable POSIX threads at all, so give the user a hint if this is
# not set. (We don't define these ourselves, as they can affect
# other portions of the system API in unpredictable ways.)
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
# if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS)
AX_PTHREAD_ZOS_MISSING
# endif
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "AX_PTHREAD_ZOS_MISSING" >/dev/null 2>&1
then :
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support." >&5
printf "%s\n" "$as_me: WARNING: IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support." >&2;}
fi
rm -rf conftest*
;;
solaris*)
# On Solaris (at least, for some versions), libc contains stubbed
# (non-functional) versions of the pthreads routines, so link-based
# tests will erroneously succeed. (N.B.: The stubs are missing
# pthread_cleanup_push, or rather a function called by this macro,
# so we could check for that, but who knows whether they'll stub
# that too in a future libc.) So we'll check first for the
# standard Solaris way of linking pthreads (-mt -lpthread).
ax_pthread_flags="-mt,-lpthread pthread $ax_pthread_flags"
;;
esac
# Are we compiling with Clang?
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC is Clang" >&5
printf %s "checking whether $CC is Clang... " >&6; }
if test ${ax_cv_PTHREAD_CLANG+y}
then :
printf %s "(cached) " >&6
else $as_nop
ax_cv_PTHREAD_CLANG=no
# Note that Autoconf sets GCC=yes for Clang as well as GCC
if test "x$GCC" = "xyes"; then
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Note: Clang 2.7 lacks __clang_[a-z]+__ */
# if defined(__clang__) && defined(__llvm__)
AX_PTHREAD_CC_IS_CLANG
# endif
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "AX_PTHREAD_CC_IS_CLANG" >/dev/null 2>&1
then :
ax_cv_PTHREAD_CLANG=yes
fi
rm -rf conftest*
fi
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_CLANG" >&5
printf "%s\n" "$ax_cv_PTHREAD_CLANG" >&6; }
ax_pthread_clang="$ax_cv_PTHREAD_CLANG"
# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC)
# Note that for GCC and Clang -pthread generally implies -lpthread,
# except when -nostdlib is passed.
# This is problematic using libtool to build C++ shared libraries with pthread:
# [1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25460
# [2] https://bugzilla.redhat.com/show_bug.cgi?id=661333
# [3] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=468555
# To solve this, first try -pthread together with -lpthread for GCC
if test "x$GCC" = "xyes"
then :
ax_pthread_flags="-pthread,-lpthread -pthread -pthreads $ax_pthread_flags"
fi
# Clang takes -pthread (never supported any other flag), but we'll try with -lpthread first
if test "x$ax_pthread_clang" = "xyes"
then :
ax_pthread_flags="-pthread,-lpthread -pthread"
fi
# The presence of a feature test macro requesting re-entrant function
# definitions is, on some systems, a strong hint that pthreads support is
# correctly enabled
case $host_os in
darwin* | hpux* | linux* | osf* | solaris*)
ax_pthread_check_macro="_REENTRANT"
;;
aix*)
ax_pthread_check_macro="_THREAD_SAFE"
;;
*)
ax_pthread_check_macro="--"
;;
esac
if test "x$ax_pthread_check_macro" = "x--"
then :
ax_pthread_check_cond=0
else $as_nop
ax_pthread_check_cond="!defined($ax_pthread_check_macro)"
fi
if test "x$ax_pthread_ok" = "xno"; then
for ax_pthread_try_flag in $ax_pthread_flags; do
case $ax_pthread_try_flag in
none)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether pthreads work without any flags" >&5
printf %s "checking whether pthreads work without any flags... " >&6; }
;;
*,*)
PTHREAD_CFLAGS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\1/"`
PTHREAD_LIBS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\2/"`
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with \"$PTHREAD_CFLAGS\" and \"$PTHREAD_LIBS\"" >&5
printf %s "checking whether pthreads work with \"$PTHREAD_CFLAGS\" and \"$PTHREAD_LIBS\"... " >&6; }
;;
-*)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with $ax_pthread_try_flag" >&5
printf %s "checking whether pthreads work with $ax_pthread_try_flag... " >&6; }
PTHREAD_CFLAGS="$ax_pthread_try_flag"
;;
pthread-config)
# Extract the first word of "pthread-config", so it can be a program name with args.
set dummy pthread-config; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ax_pthread_config+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$ax_pthread_config"; then
ac_cv_prog_ax_pthread_config="$ax_pthread_config" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ax_pthread_config="yes"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
test -z "$ac_cv_prog_ax_pthread_config" && ac_cv_prog_ax_pthread_config="no"
fi
fi
ax_pthread_config=$ac_cv_prog_ax_pthread_config
if test -n "$ax_pthread_config"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_config" >&5
printf "%s\n" "$ax_pthread_config" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
if test "x$ax_pthread_config" = "xno"
then :
continue
fi
PTHREAD_CFLAGS="`pthread-config --cflags`"
PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
;;
*)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the pthreads library -l$ax_pthread_try_flag" >&5
printf %s "checking for the pthreads library -l$ax_pthread_try_flag... " >&6; }
PTHREAD_LIBS="-l$ax_pthread_try_flag"
;;
esac
ax_pthread_save_CFLAGS="$CFLAGS"
ax_pthread_save_LIBS="$LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
# Check for various functions. We must include pthread.h,
# since some functions may be macros. (On the Sequent, we
# need a special flag -Kthread to make this header compile.)
# We check for pthread_join because it is in -lpthread on IRIX
# while pthread_create is in libc. We check for pthread_attr_init
# due to DEC craziness with -lpthreads. We check for
# pthread_cleanup_push because it is one of the few pthread
# functions on Solaris that doesn't have a non-functional libc stub.
# We try pthread_create on general principles.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
# if $ax_pthread_check_cond
# error "$ax_pthread_check_macro must be defined"
# endif
static void *some_global = NULL;
static void routine(void *a)
{
/* To avoid any unused-parameter or
unused-but-set-parameter warning. */
some_global = a;
}
static void *start_routine(void *a) { return a; }
int
main (void)
{
pthread_t th; pthread_attr_t attr;
pthread_create(&th, 0, start_routine, 0);
pthread_join(th, 0);
pthread_attr_init(&attr);
pthread_cleanup_push(routine, 0);
pthread_cleanup_pop(0) /* ; */
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
ax_pthread_ok=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
CFLAGS="$ax_pthread_save_CFLAGS"
LIBS="$ax_pthread_save_LIBS"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_ok" >&5
printf "%s\n" "$ax_pthread_ok" >&6; }
if test "x$ax_pthread_ok" = "xyes"
then :
break
fi
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
done
fi
# Clang needs special handling, because older versions handle the -pthread
# option in a rather... idiosyncratic way
if test "x$ax_pthread_clang" = "xyes"; then
# Clang takes -pthread; it has never supported any other flag
# (Note 1: This will need to be revisited if a system that Clang
# supports has POSIX threads in a separate library. This tends not
# to be the way of modern systems, but it's conceivable.)
# (Note 2: On some systems, notably Darwin, -pthread is not needed
# to get POSIX threads support; the API is always present and
# active. We could reasonably leave PTHREAD_CFLAGS empty. But
# -pthread does define _REENTRANT, and while the Darwin headers
# ignore this macro, third-party headers might not.)
# However, older versions of Clang make a point of warning the user
# that, in an invocation where only linking and no compilation is
# taking place, the -pthread option has no effect ("argument unused
# during compilation"). They expect -pthread to be passed in only
# when source code is being compiled.
#
# Problem is, this is at odds with the way Automake and most other
# C build frameworks function, which is that the same flags used in
# compilation (CFLAGS) are also used in linking. Many systems
# supported by AX_PTHREAD require exactly this for POSIX threads
# support, and in fact it is often not straightforward to specify a
# flag that is used only in the compilation phase and not in
# linking. Such a scenario is extremely rare in practice.
#
# Even though use of the -pthread flag in linking would only print
# a warning, this can be a nuisance for well-run software projects
# that build with -Werror. So if the active version of Clang has
# this misfeature, we search for an option to squash it.
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether Clang needs flag to prevent \"argument unused\" warning when linking with -pthread" >&5
printf %s "checking whether Clang needs flag to prevent \"argument unused\" warning when linking with -pthread... " >&6; }
if test ${ax_cv_PTHREAD_CLANG_NO_WARN_FLAG+y}
then :
printf %s "(cached) " >&6
else $as_nop
ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown
# Create an alternate version of $ac_link that compiles and
# links in two steps (.c -> .o, .o -> exe) instead of one
# (.c -> exe), because the warning occurs only in the second
# step
ax_pthread_save_ac_link="$ac_link"
ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g'
ax_pthread_link_step=`printf "%s\n" "$ac_link" | sed "$ax_pthread_sed"`
ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)"
ax_pthread_save_CFLAGS="$CFLAGS"
for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do
if test "x$ax_pthread_try" = "xunknown"
then :
break
fi
CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS"
ac_link="$ax_pthread_save_ac_link"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int main(void){return 0;}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
ac_link="$ax_pthread_2step_ac_link"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int main(void){return 0;}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
done
ac_link="$ax_pthread_save_ac_link"
CFLAGS="$ax_pthread_save_CFLAGS"
if test "x$ax_pthread_try" = "x"
then :
ax_pthread_try=no
fi
ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try"
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" >&5
printf "%s\n" "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" >&6; }
case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in
no | unknown) ;;
*) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;;
esac
fi # $ax_pthread_clang = yes
# Various other checks:
if test "x$ax_pthread_ok" = "xyes"; then
ax_pthread_save_CFLAGS="$CFLAGS"
ax_pthread_save_LIBS="$LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
# Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for joinable pthread attribute" >&5
printf %s "checking for joinable pthread attribute... " >&6; }
if test ${ax_cv_PTHREAD_JOINABLE_ATTR+y}
then :
printf %s "(cached) " >&6
else $as_nop
ax_cv_PTHREAD_JOINABLE_ATTR=unknown
for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
int attr = $ax_pthread_attr; return attr /* ; */
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
done
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_JOINABLE_ATTR" >&5
printf "%s\n" "$ax_cv_PTHREAD_JOINABLE_ATTR" >&6; }
if test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \
test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \
test "x$ax_pthread_joinable_attr_defined" != "xyes"
then :
printf "%s\n" "#define PTHREAD_CREATE_JOINABLE $ax_cv_PTHREAD_JOINABLE_ATTR" >>confdefs.h
ax_pthread_joinable_attr_defined=yes
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether more special flags are required for pthreads" >&5
printf %s "checking whether more special flags are required for pthreads... " >&6; }
if test ${ax_cv_PTHREAD_SPECIAL_FLAGS+y}
then :
printf %s "(cached) " >&6
else $as_nop
ax_cv_PTHREAD_SPECIAL_FLAGS=no
case $host_os in
solaris*)
ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS"
;;
esac
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_SPECIAL_FLAGS" >&5
printf "%s\n" "$ax_cv_PTHREAD_SPECIAL_FLAGS" >&6; }
if test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \
test "x$ax_pthread_special_flags_added" != "xyes"
then :
PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS"
ax_pthread_special_flags_added=yes
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for PTHREAD_PRIO_INHERIT" >&5
printf %s "checking for PTHREAD_PRIO_INHERIT... " >&6; }
if test ${ax_cv_PTHREAD_PRIO_INHERIT+y}
then :
printf %s "(cached) " >&6
else $as_nop
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
int i = PTHREAD_PRIO_INHERIT;
return i;
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
ax_cv_PTHREAD_PRIO_INHERIT=yes
else $as_nop
ax_cv_PTHREAD_PRIO_INHERIT=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_PRIO_INHERIT" >&5
printf "%s\n" "$ax_cv_PTHREAD_PRIO_INHERIT" >&6; }
if test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \
test "x$ax_pthread_prio_inherit_defined" != "xyes"
then :
printf "%s\n" "#define HAVE_PTHREAD_PRIO_INHERIT 1" >>confdefs.h
ax_pthread_prio_inherit_defined=yes
fi
CFLAGS="$ax_pthread_save_CFLAGS"
LIBS="$ax_pthread_save_LIBS"
# More AIX lossage: compile with *_r variant
if test "x$GCC" != "xyes"; then
case $host_os in
aix*)
case "x/$CC" in #(
x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6) :
#handle absolute path differently from PATH based program lookup
case "x$CC" in #(
x/*) :
if as_fn_executable_p ${CC}_r
then :
PTHREAD_CC="${CC}_r"
fi ;; #(
*) :
for ac_prog in ${CC}_r
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_PTHREAD_CC+y}
then :
printf %s "(cached) " >&6
else $as_nop
if test -n "$PTHREAD_CC"; then
ac_cv_prog_PTHREAD_CC="$PTHREAD_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_PTHREAD_CC="$ac_prog"
printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
PTHREAD_CC=$ac_cv_prog_PTHREAD_CC
if test -n "$PTHREAD_CC"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PTHREAD_CC" >&5
printf "%s\n" "$PTHREAD_CC" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
test -n "$PTHREAD_CC" && break
done
test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
;;
esac ;; #(
*) :
;;
esac
;;
esac
fi
fi
test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test "x$ax_pthread_ok" = "xyes"; then
printf "%s\n" "#define HAVE_PTHREAD 1" >>confdefs.h
:
else
ax_pthread_ok=no
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Threads not available and fallback getaddrinfo_a() non-functional." >&5
printf "%s\n" "Threads not available and fallback getaddrinfo_a() non-functional." >&6; }
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
CC="$PTHREAD_CC"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
LIBS="$LIBS $PTHREAD_LIBS"
fi
fi
fi # !cares
## end of DNS
tls_support=auto
TLS_CPPFLAGS=""
TLS_LDFLAGS=""
TLS_LIBS=""
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for OpenSSL" >&5
printf %s "checking for OpenSSL... " >&6; }
# Check whether --with-openssl was given.
if test ${with_openssl+y}
then :
withval=$with_openssl; if test "$withval" = "no"; then
tls_support=no
elif test "$withval" = "yes"; then
tls_support=libssl
TLS_LIBS="-lssl -lcrypto"
else
tls_support=libssl
TLS_CPPFLAGS="-I$withval/include"
TLS_LDFLAGS="-L$withval/lib"
TLS_LIBS="-lssl -lcrypto"
fi
else $as_nop
tls_support=auto
TLS_CPPFLAGS=""
TLS_LDFLAGS=""
TLS_LIBS="-lssl -lcrypto"
fi
if test "$tls_support" = "auto" -o "$tls_support" = "libssl"; then
printf "%s\n" "#define USUAL_LIBSSL_FOR_TLS 1" >>confdefs.h
printf "%s\n" "#define OPENSSL_API_COMPAT 0x00908000L" >>confdefs.h
tmp_LIBS="$LIBS"
tmp_LDFLAGS="$LDFLAGS"
tmp_CPPFLAGS="$CPPFLAGS"
CPPFLAGS="$TLS_CPPFLAGS $CPPFLAGS"
LDFLAGS="$TLS_LDFLAGS $LDFLAGS"
LIBS="$TLS_LIBS $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main (void)
{
SSL_CTX *ctx = SSL_CTX_new(SSLv23_method());
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"
then :
tls_support=yes; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: found" >&5
printf "%s\n" "found" >&6; }
else $as_nop
as_fn_error $? "not found" "$LINENO" 5
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
ac_fn_c_check_func "$LINENO" "SSL_CTX_use_certificate_chain_mem" "ac_cv_func_SSL_CTX_use_certificate_chain_mem"
if test "x$ac_cv_func_SSL_CTX_use_certificate_chain_mem" = xyes
then :
printf "%s\n" "#define HAVE_SSL_CTX_USE_CERTIFICATE_CHAIN_MEM 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "SSL_CTX_load_verify_mem" "ac_cv_func_SSL_CTX_load_verify_mem"
if test "x$ac_cv_func_SSL_CTX_load_verify_mem" = xyes
then :
printf "%s\n" "#define HAVE_SSL_CTX_LOAD_VERIFY_MEM 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "asn1_time_parse" "ac_cv_func_asn1_time_parse"
if test "x$ac_cv_func_asn1_time_parse" = xyes
then :
printf "%s\n" "#define HAVE_ASN1_TIME_PARSE 1" >>confdefs.h
fi
CPPFLAGS="$tmp_CPPFLAGS"
LDFLAGS="$tmp_LDFLAGS"
LIBS="$tmp_LIBS"
cafile=auto
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for root CA certs" >&5
printf %s "checking for root CA certs... " >&6; }
# Check whether --with-root-ca-file was given.
if test ${with_root_ca_file+y}
then :
withval=$with_root_ca_file; if test "$withval" = "no"; then
:
elif test "$withval" = "yes"; then
:
else
cafile="$withval"
fi
fi
if test "$cafile" = "auto"; then
for cafile in \
/etc/ssl/certs/ca-certificates.crt \
/etc/pki/tls/certs/ca-bundle.crt \
/etc/ssl/ca-bundle.pem \
/etc/pki/tls/cacert.pem \
/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem \
/etc/ssl/cert.pem
do
if test -f "$cafile"; then
break
fi
done
fi
printf "%s\n" "#define USUAL_TLS_CA_FILE \"$cafile\"" >>confdefs.h
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cafile" >&5
printf "%s\n" "$cafile" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
# Check whether --enable-debug was given.
if test ${enable_debug+y}
then :
enableval=$enable_debug;
else $as_nop
enable_debug=yes
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build debug binary" >&5
printf %s "checking whether to build debug binary... " >&6; }
if test "$enable_debug" = "yes"; then
LDFLAGS="-g $LDFLAGS"
BININSTALL="$INSTALL"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
else
BININSTALL="$INSTALL -s"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
# Check whether --enable-cassert was given.
if test ${enable_cassert+y}
then :
enableval=$enable_cassert;
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to enable asserts" >&5
printf %s "checking whether to enable asserts... " >&6; }
if test "$enable_cassert" = "yes"; then
printf "%s\n" "#define CASSERT 1" >>confdefs.h
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
# Check whether --enable-werror was given.
if test ${enable_werror+y}
then :
enableval=$enable_werror;
fi
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to fail on warnings" >&5
printf %s "checking whether to fail on warnings... " >&6; }
if test "$enable_werror" = "yes"; then
CFLAGS="$CFLAGS -Werror"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
printf "%s\n" "yes" >&6; }
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
printf "%s\n" "no" >&6; }
fi
PACKAGE_VERSION_4B=`echo "${PACKAGE_VERSION}.0" | sed -e 's/\./,/g'`
printf "%s\n" "#define PACKAGE_VERSION_4B $PACKAGE_VERSION_4B" >>confdefs.h
ac_config_files="$ac_config_files config.mak"
cat >confcache <<\_ACEOF
# This file is a shell script that caches the results of configure
# tests run on this system so they can be shared between configure
# scripts and configure runs, see configure's option --config-cache.
# It is not useful on other systems. If it contains results you don't
# want to keep, you may remove or edit it.
#
# config.status only pays attention to the cache file if you give it
# the --recheck option to rerun configure.
#
# `ac_cv_env_foo' variables (set or unset) will be overridden when
# loading this file, other *unset* `ac_cv_foo' will be assigned the
# following values.
_ACEOF
# The following way of writing the cache mishandles newlines in values,
# but we know of no workaround that is simple, portable, and efficient.
# So, we kill variables containing newlines.
# Ultrix sh set writes to stderr and can't be redirected directly,
# and sets the high bit in the cache file unless we assign to the vars.
(
for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
eval ac_val=\$$ac_var
case $ac_val in #(
*${as_nl}*)
case $ac_var in #(
*_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
esac
case $ac_var in #(
_ | IFS | as_nl) ;; #(
BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
*) { eval $ac_var=; unset $ac_var;} ;;
esac ;;
esac
done
(set) 2>&1 |
case $as_nl`(ac_space=' '; set) 2>&1` in #(
*${as_nl}ac_space=\ *)
# `set' does not quote correctly, so add quotes: double-quote
# substitution turns \\\\ into \\, and sed turns \\ into \.
sed -n \
"s/'/'\\\\''/g;
s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
;; #(
*)
# `set' quotes correctly as required by POSIX, so do not add quotes.
sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
;;
esac |
sort
) |
sed '
/^ac_cv_env_/b end
t clear
:clear
s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/
t end
s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
:end' >>confcache
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
if test -w "$cache_file"; then
if test "x$cache_file" != "x/dev/null"; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
printf "%s\n" "$as_me: updating cache $cache_file" >&6;}
if test ! -f "$cache_file" || test -h "$cache_file"; then
cat confcache >"$cache_file"
else
case $cache_file in #(
*/* | ?:*)
mv -f confcache "$cache_file"$$ &&
mv -f "$cache_file"$$ "$cache_file" ;; #(
*)
mv -f confcache "$cache_file" ;;
esac
fi
fi
else
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;}
fi
fi
rm -f confcache
test "x$prefix" = xNONE && prefix=$ac_default_prefix
# Let make expand exec_prefix.
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
DEFS=-DHAVE_CONFIG_H
ac_libobjs=
ac_ltlibobjs=
U=
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
# 1. Remove the extension, and $U if already installed.
ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"`
# 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR
# will be set to the directory where LIBOBJS objects are built.
as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
done
LIBOBJS=$ac_libobjs
LTLIBOBJS=$ac_ltlibobjs
: "${CONFIG_STATUS=./config.status}"
ac_write_fail=0
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;}
as_write_fail=0
cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
# Compiler output produced by configure, useful for debugging
# configure, is in config.log if it exists.
debug=false
ac_cs_recheck=false
ac_cs_silent=false
SHELL=\${CONFIG_SHELL-$SHELL}
export SHELL
_ASEOF
cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##
# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
as_nop=:
if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else $as_nop
case `(set -o) 2>/dev/null` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
fi
# Reset variables that may have inherited troublesome values from
# the environment.
# IFS needs to be set, to space, tab, and newline, in precisely that order.
# (If _AS_PATH_WALK were called with IFS unset, it would have the
# side effect of setting IFS to empty, thus disabling word splitting.)
# Quoting is to prevent editors from complaining about space-tab.
as_nl='
'
export as_nl
IFS=" "" $as_nl"
PS1='$ '
PS2='> '
PS4='+ '
# Ensure predictable behavior from utilities with locale-dependent output.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE
# We cannot yet rely on "unset" to work, but we need these variables
# to be unset--not just set to an empty or harmless value--now, to
# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh). This construct
# also avoids known problems related to "unset" and subshell syntax
# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
do eval test \${$as_var+y} \
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
# Ensure that fds 0, 1, and 2 are open.
if (exec 3>&0) 2>/dev/null; then :; else exec 0&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
if (exec 3>&2) ; then :; else exec 2>/dev/null; fi
# The user is always right.
if ${PATH_SEPARATOR+false} :; then
PATH_SEPARATOR=:
(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
PATH_SEPARATOR=';'
}
fi
# Find who we are. Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
*[\\/]* ) as_myself=$0 ;;
*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
case $as_dir in #(((
'') as_dir=./ ;;
*/) ;;
*) as_dir=$as_dir/ ;;
esac
test -r "$as_dir$0" && as_myself=$as_dir$0 && break
done
IFS=$as_save_IFS
;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
as_myself=$0
fi
if test ! -f "$as_myself"; then
printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
exit 1
fi
# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
as_status=$1; test $as_status -eq 0 && as_status=1
if test "$4"; then
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
fi
printf "%s\n" "$as_me: error: $2" >&2
as_fn_exit $as_status
} # as_fn_error
# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
return $1
} # as_fn_set_status
# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
set +e
as_fn_set_status $1
exit $1
} # as_fn_exit
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
{ eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
then :
eval 'as_fn_append ()
{
eval $1+=\$2
}'
else $as_nop
as_fn_append ()
{
eval $1=\$$1\$2
}
fi # as_fn_append
# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
then :
eval 'as_fn_arith ()
{
as_val=$(( $* ))
}'
else $as_nop
as_fn_arith ()
{
as_val=`expr "$@" || test $? -eq 1`
}
fi # as_fn_arith
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
else
as_expr=false
fi
if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
as_basename=basename
else
as_basename=false
fi
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
as_dirname=dirname
else
as_dirname=false
fi
as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
printf "%s\n" X/"$0" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
}
/^X\/\(\/\/\)$/{
s//\1/
q
}
/^X\/\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
# Determine whether it's possible to make 'echo' print without a newline.
# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
# for compatibility with existing Makefiles.
ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
case `echo 'xy\c'` in
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
xy) ECHO_C='\c';;
*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
ECHO_T=' ';;
esac;;
*)
ECHO_N='-n';;
esac
# For backward compatibility with old third-party macros, we provide
# the shell variables $as_echo and $as_echo_n. New code should use
# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
as_echo='printf %s\n'
as_echo_n='printf %s'
rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
rm -f conf$$.dir/conf$$.file
else
rm -f conf$$.dir
mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
if ln -s conf$$.file conf$$ 2>/dev/null; then
as_ln_s='ln -s'
# ... but there are two gotchas:
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
# In both cases, we have to default to `cp -pR'.
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
as_ln_s='cp -pR'
elif ln conf$$.file conf$$ 2>/dev/null; then
as_ln_s=ln
else
as_ln_s='cp -pR'
fi
else
as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{
case $as_dir in #(
-*) as_dir=./$as_dir;;
esac
test -d "$as_dir" || eval $as_mkdir_p || {
as_dirs=
while :; do
case $as_dir in #(
*\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
*) as_qdir=$as_dir;;
esac
as_dirs="'$as_qdir' $as_dirs"
as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$as_dir" : 'X\(//\)[^/]' \| \
X"$as_dir" : 'X\(//\)$' \| \
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
printf "%s\n" X"$as_dir" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
test -d "$as_dir" && break
done
test -z "$as_dirs" || eval "mkdir $as_dirs"
} || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
} # as_fn_mkdir_p
if mkdir -p . 2>/dev/null; then
as_mkdir_p='mkdir -p "$as_dir"'
else
test -d ./-p && rmdir ./-p
as_mkdir_p=false
fi
# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
test -f "$1" && test -x "$1"
} # as_fn_executable_p
as_test_x='test -x'
as_executable_p=as_fn_executable_p
# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
exec 6>&1
## ----------------------------------- ##
## Main body of $CONFIG_STATUS script. ##
## ----------------------------------- ##
_ASEOF
test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by PgBouncer $as_me 1.24.1, which was
generated by GNU Autoconf 2.71. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
CONFIG_HEADERS = $CONFIG_HEADERS
CONFIG_LINKS = $CONFIG_LINKS
CONFIG_COMMANDS = $CONFIG_COMMANDS
$ $0 $@
on `(hostname || uname -n) 2>/dev/null | sed 1q`
"
_ACEOF
case $ac_config_files in *"
"*) set x $ac_config_files; shift; ac_config_files=$*;;
esac
case $ac_config_headers in *"
"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
esac
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Files that config.status was made for.
config_files="$ac_config_files"
config_headers="$ac_config_headers"
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
ac_cs_usage="\
\`$as_me' instantiates files and other configuration actions
from templates according to the current configuration. Unless the files
and actions are specified as TAGs, all are instantiated by default.
Usage: $0 [OPTION]... [TAG]...
-h, --help print this help, then exit
-V, --version print version number and configuration settings, then exit
--config print configuration, then exit
-q, --quiet, --silent
do not print progress messages
-d, --debug don't remove temporary files
--recheck update $as_me by reconfiguring in the same conditions
--file=FILE[:TEMPLATE]
instantiate the configuration file FILE
--header=FILE[:TEMPLATE]
instantiate the configuration header FILE
Configuration files:
$config_files
Configuration headers:
$config_headers
Report bugs to .
PgBouncer home page: ."
_ACEOF
ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"`
ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"`
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config='$ac_cs_config_escaped'
ac_cs_version="\\
PgBouncer config.status 1.24.1
configured by $0, generated by GNU Autoconf 2.71,
with options \\"\$ac_cs_config\\"
Copyright (C) 2021 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
ac_pwd='$ac_pwd'
srcdir='$srcdir'
INSTALL='$INSTALL'
MKDIR_P='$MKDIR_P'
AWK='$AWK'
test -n "\$AWK" || AWK=awk
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
while test $# != 0
do
case $1 in
--*=?*)
ac_option=`expr "X$1" : 'X\([^=]*\)='`
ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
ac_shift=:
;;
--*=)
ac_option=`expr "X$1" : 'X\([^=]*\)='`
ac_optarg=
ac_shift=:
;;
*)
ac_option=$1
ac_optarg=$2
ac_shift=shift
;;
esac
case $ac_option in
# Handling of the options.
-recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
ac_cs_recheck=: ;;
--version | --versio | --versi | --vers | --ver | --ve | --v | -V )
printf "%s\n" "$ac_cs_version"; exit ;;
--config | --confi | --conf | --con | --co | --c )
printf "%s\n" "$ac_cs_config"; exit ;;
--debug | --debu | --deb | --de | --d | -d )
debug=: ;;
--file | --fil | --fi | --f )
$ac_shift
case $ac_optarg in
*\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
'') as_fn_error $? "missing file argument" ;;
esac
as_fn_append CONFIG_FILES " '$ac_optarg'"
ac_need_defaults=false;;
--header | --heade | --head | --hea )
$ac_shift
case $ac_optarg in
*\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
as_fn_append CONFIG_HEADERS " '$ac_optarg'"
ac_need_defaults=false;;
--he | --h)
# Conflict between --help and --header
as_fn_error $? "ambiguous option: \`$1'
Try \`$0 --help' for more information.";;
--help | --hel | -h )
printf "%s\n" "$ac_cs_usage"; exit ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
| -silent | --silent | --silen | --sile | --sil | --si | --s)
ac_cs_silent=: ;;
# This is an error.
-*) as_fn_error $? "unrecognized option: \`$1'
Try \`$0 --help' for more information." ;;
*) as_fn_append ac_config_targets " $1"
ac_need_defaults=false ;;
esac
shift
done
ac_configure_extra_args=
if $ac_cs_silent; then
exec 6>/dev/null
ac_configure_extra_args="$ac_configure_extra_args --silent"
fi
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
shift
\printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6
CONFIG_SHELL='$SHELL'
export CONFIG_SHELL
exec "\$@"
fi
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
exec 5>>config.log
{
echo
sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
printf "%s\n" "$ac_log"
} >&5
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# Handling of arguments.
for ac_config_target in $ac_config_targets
do
case $ac_config_target in
"lib/usual/config.h") CONFIG_HEADERS="$CONFIG_HEADERS lib/usual/config.h" ;;
"config.mak") CONFIG_FILES="$CONFIG_FILES config.mak" ;;
*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
esac
done
# If the user did not use the arguments to specify the items to instantiate,
# then the envvar interface is used. Set only those that are not.
# We use the long form for the default assignment because of an extremely
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files
test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers
fi
# Have a temporary directory for convenience. Make it in the build tree
# simply because there is no reason against having it here, and in addition,
# creating and moving files from /tmp can sometimes cause problems.
# Hook for its removal unless debugging.
# Note that there is a small window in which the directory will not be cleaned:
# after its creation but before its name has been assigned to `$tmp'.
$debug ||
{
tmp= ac_tmp=
trap 'exit_status=$?
: "${ac_tmp:=$tmp}"
{ test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
' 0
trap 'as_fn_exit 1' 1 2 13 15
}
# Create a (secure) tmp directory for tmp files.
{
tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
test -d "$tmp"
} ||
{
tmp=./conf$$-$RANDOM
(umask 077 && mkdir "$tmp")
} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
ac_tmp=$tmp
# Set up the scripts for CONFIG_FILES section.
# No need to generate them if there are no CONFIG_FILES.
# This happens for instance with `./config.status config.h'.
if test -n "$CONFIG_FILES"; then
ac_cr=`echo X | tr X '\015'`
# On cygwin, bash can eat \r inside `` if the user requested igncr.
# But we know of no other shell where ac_cr would be empty at this
# point, so we can use a bashism as a fallback.
if test "x$ac_cr" = x; then
eval ac_cr=\$\'\\r\'
fi
ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null`
if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
ac_cs_awk_cr='\\r'
else
ac_cs_awk_cr=$ac_cr
fi
echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
_ACEOF
{
echo "cat >conf$$subs.awk <<_ACEOF" &&
echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
echo "_ACEOF"
} >conf$$subs.sh ||
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
ac_delim='%!_!# '
for ac_last_try in false false false false false :; do
. ./conf$$subs.sh ||
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
if test $ac_delim_n = $ac_delim_num; then
break
elif $ac_last_try; then
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
else
ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
fi
done
rm -f conf$$subs.sh
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
_ACEOF
sed -n '
h
s/^/S["/; s/!.*/"]=/
p
g
s/^[^!]*!//
:repl
t repl
s/'"$ac_delim"'$//
t delim
:nl
h
s/\(.\{148\}\)..*/\1/
t more1
s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
p
n
b repl
:more1
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t nl
:delim
h
s/\(.\{148\}\)..*/\1/
t more2
s/["\\]/\\&/g; s/^/"/; s/$/"/
p
b
:more2
s/["\\]/\\&/g; s/^/"/; s/$/"\\/
p
g
s/.\{148\}//
t delim
' >$CONFIG_STATUS || ac_write_fail=1
rm -f conf$$subs.awk
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
_ACAWK
cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
for (key in S) S_is_set[key] = 1
FS = ""
}
{
line = $ 0
nfields = split(line, field, "@")
substed = 0
len = length(field[1])
for (i = 2; i < nfields; i++) {
key = field[i]
keylen = length(key)
if (S_is_set[key]) {
value = S[key]
line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
len += length(value) + length(field[++i])
substed = 1
} else
len += 1 + keylen
}
print line
}
_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
else
cat
fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
|| as_fn_error $? "could not setup config files machinery" "$LINENO" 5
_ACEOF
# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
# trailing colons and then remove the whole line if VPATH becomes empty
# (actually we leave an empty line to preserve line numbers).
if test "x$srcdir" = x.; then
ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{
h
s///
s/^/:/
s/[ ]*$/:/
s/:\$(srcdir):/:/g
s/:\${srcdir}:/:/g
s/:@srcdir@:/:/g
s/^:*//
s/:*$//
x
s/\(=[ ]*\).*/\1/
G
s/\n//
s/^[^=]*=[ ]*$//
}'
fi
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
fi # test -n "$CONFIG_FILES"
# Set up the scripts for CONFIG_HEADERS section.
# No need to generate them if there are no CONFIG_HEADERS.
# This happens for instance with `./config.status Makefile'.
if test -n "$CONFIG_HEADERS"; then
cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
BEGIN {
_ACEOF
# Transform confdefs.h into an awk script `defines.awk', embedded as
# here-document in config.status, that substitutes the proper values into
# config.h.in to produce config.h.
# Create a delimiter string that does not exist in confdefs.h, to ease
# handling of long lines.
ac_delim='%!_!# '
for ac_last_try in false false :; do
ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
if test -z "$ac_tt"; then
break
elif $ac_last_try; then
as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
else
ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
fi
done
# For the awk script, D is an array of macro values keyed by name,
# likewise P contains macro parameters if any. Preserve backslash
# newline sequences.
ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
sed -n '
s/.\{148\}/&'"$ac_delim"'/g
t rset
:rset
s/^[ ]*#[ ]*define[ ][ ]*/ /
t def
d
:def
s/\\$//
t bsnl
s/["\\]/\\&/g
s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\
D["\1"]=" \3"/p
s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p
d
:bsnl
s/["\\]/\\&/g
s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\
D["\1"]=" \3\\\\\\n"\\/p
t cont
s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
t cont
d
:cont
n
s/.\{148\}/&'"$ac_delim"'/g
t clear
:clear
s/\\$//
t bsnlc
s/["\\]/\\&/g; s/^/"/; s/$/"/p
d
:bsnlc
s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
b cont
' >$CONFIG_STATUS || ac_write_fail=1
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
for (key in D) D_is_set[key] = 1
FS = ""
}
/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
line = \$ 0
split(line, arg, " ")
if (arg[1] == "#") {
defundef = arg[2]
mac1 = arg[3]
} else {
defundef = substr(arg[1], 2)
mac1 = arg[2]
}
split(mac1, mac2, "(") #)
macro = mac2[1]
prefix = substr(line, 1, index(line, defundef) - 1)
if (D_is_set[macro]) {
# Preserve the white space surrounding the "#".
print prefix "define", macro P[macro] D[macro]
next
} else {
# Replace #undef with comments. This is necessary, for example,
# in the case of _POSIX_SOURCE, which is predefined and required
# on some systems where configure will not decide to define it.
if (defundef == "undef") {
print "/*", prefix defundef, macro, "*/"
next
}
}
}
{ print }
_ACAWK
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
fi # test -n "$CONFIG_HEADERS"
eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS "
shift
for ac_tag
do
case $ac_tag in
:[FHLC]) ac_mode=$ac_tag; continue;;
esac
case $ac_mode$ac_tag in
:[FHL]*:*);;
:L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
:[FH]-) ac_tag=-:-;;
:[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
esac
ac_save_IFS=$IFS
IFS=:
set x $ac_tag
IFS=$ac_save_IFS
shift
ac_file=$1
shift
case $ac_mode in
:L) ac_source=$1;;
:[FH])
ac_file_inputs=
for ac_f
do
case $ac_f in
-) ac_f="$ac_tmp/stdin";;
*) # Look for the file first in the build tree, then in the source tree
# (if the path is not absolute). The absolute path cannot be DOS-style,
# because $ac_f cannot contain `:'.
test -f "$ac_f" ||
case $ac_f in
[\\/$]*) false;;
*) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
esac ||
as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
esac
case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
as_fn_append ac_file_inputs " '$ac_f'"
done
# Let's still pretend it is `configure' which instantiates (i.e., don't
# use $as_me), people would be surprised to read:
# /* config.h. Generated by config.status. */
configure_input='Generated from '`
printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
`' by configure.'
if test x"$ac_file" != x-; then
configure_input="$ac_file. $configure_input"
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
printf "%s\n" "$as_me: creating $ac_file" >&6;}
fi
# Neutralize special characters interpreted by sed in replacement strings.
case $configure_input in #(
*\&* | *\|* | *\\* )
ac_sed_conf_input=`printf "%s\n" "$configure_input" |
sed 's/[\\\\&|]/\\\\&/g'`;; #(
*) ac_sed_conf_input=$configure_input;;
esac
case $ac_tag in
*:-:* | *:-) cat >"$ac_tmp/stdin" \
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
esac
;;
esac
ac_dir=`$as_dirname -- "$ac_file" ||
$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$ac_file" : 'X\(//\)[^/]' \| \
X"$ac_file" : 'X\(//\)$' \| \
X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
printf "%s\n" X"$ac_file" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
as_dir="$ac_dir"; as_fn_mkdir_p
ac_builddir=.
case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
# A ".." for each directory in $ac_dir_suffix.
ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
case $ac_top_builddir_sub in
"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
*) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix
case $srcdir in
.) # We are building in place.
ac_srcdir=.
ac_top_srcdir=$ac_top_builddir_sub
ac_abs_top_srcdir=$ac_pwd ;;
[\\/]* | ?:[\\/]* ) # Absolute name.
ac_srcdir=$srcdir$ac_dir_suffix;
ac_top_srcdir=$srcdir
ac_abs_top_srcdir=$srcdir ;;
*) # Relative name.
ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
ac_top_srcdir=$ac_top_build_prefix$srcdir
ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
case $ac_mode in
:F)
#
# CONFIG_FILE
#
case $INSTALL in
[\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
*) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
esac
ac_MKDIR_P=$MKDIR_P
case $MKDIR_P in
[\\/$]* | ?:[\\/]* ) ;;
*/*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
esac
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# If the template does not know about datarootdir, expand it.
# FIXME: This hack should be removed a few years after 2.60.
ac_datarootdir_hack=; ac_datarootdir_seen=
ac_sed_dataroot='
/datarootdir/ {
p
q
}
/@datadir@/p
/@docdir@/p
/@infodir@/p
/@localedir@/p
/@mandir@/p'
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
*datarootdir*) ac_datarootdir_seen=yes;;
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_datarootdir_hack='
s&@datadir@&$datadir&g
s&@docdir@&$docdir&g
s&@infodir@&$infodir&g
s&@localedir@&$localedir&g
s&@mandir@&$mandir&g
s&\\\${datarootdir}&$datarootdir&g' ;;
esac
_ACEOF
# Neutralize VPATH when `$srcdir' = `.'.
# Shell code in configure.ac might set extrasub.
# FIXME: do we really want to maintain this feature?
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_sed_extra="$ac_vpsub
$extrasub
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
:t
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
s|@configure_input@|$ac_sed_conf_input|;t t
s&@top_builddir@&$ac_top_builddir_sub&;t t
s&@top_build_prefix@&$ac_top_build_prefix&;t t
s&@srcdir@&$ac_srcdir&;t t
s&@abs_srcdir@&$ac_abs_srcdir&;t t
s&@top_srcdir@&$ac_top_srcdir&;t t
s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
s&@builddir@&$ac_builddir&;t t
s&@abs_builddir@&$ac_abs_builddir&;t t
s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
s&@INSTALL@&$ac_INSTALL&;t t
s&@MKDIR_P@&$ac_MKDIR_P&;t t
$ac_datarootdir_hack
"
eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
>$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
{ ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
{ ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \
"$ac_tmp/out"`; test -z "$ac_out"; } &&
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined. Please make sure it is defined" >&5
printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
which seems to be undefined. Please make sure it is defined" >&2;}
rm -f "$ac_tmp/stdin"
case $ac_file in
-) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
*) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
esac \
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
;;
:H)
#
# CONFIG_HEADER
#
if test x"$ac_file" != x-; then
{
printf "%s\n" "/* $configure_input */" >&1 \
&& eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
} >"$ac_tmp/config.h" \
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
printf "%s\n" "$as_me: $ac_file is unchanged" >&6;}
else
rm -f "$ac_file"
mv "$ac_tmp/config.h" "$ac_file" \
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
fi
else
printf "%s\n" "/* $configure_input */" >&1 \
&& eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
|| as_fn_error $? "could not create -" "$LINENO" 5
fi
;;
esac
done # for ac_tag
as_fn_exit 0
_ACEOF
ac_clean_files=$ac_clean_files_save
test $ac_write_fail = 0 ||
as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
# configure is writing to config.log, and then calls config.status.
# config.status does its own redirection, appending to config.log.
# Unfortunately, on DOS this fails, as config.log is still kept open
# by configure, so config.status won't be able to write to it; its
# output is simply discarded. So we exec the FD to /dev/null,
# effectively closing config.log, so it can be properly (re)opened and
# appended to by config.status. When coming back to configure, we
# need to make the FD available again.
if test "$no_create" != yes; then
ac_cs_success=:
ac_config_status_args=
test "$silent" = yes &&
ac_config_status_args="$ac_config_status_args --quiet"
exec 5>/dev/null
$SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
exec 5>>config.log
# Use ||, not &&, to avoid exiting from the if with $? = 1, which
# would make configure fail if this is the last instruction.
$ac_cs_success || as_fn_exit 1
fi
if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
fi
test -f Makefile || {
echo "Linking Makefile"
ln -s $srcdir/Makefile
}
echo ""
echo "Results:"
if test "$use_cares" = "yes"; then
echo " adns = c-ares"
elif test "$use_evdns" = "yes"; then
echo " adns = evdns2"
elif test "$ac_cv_usual_glibc_gaia" = "yes"; then
echo " adns = libc"
else
echo " adns = compat"
fi
echo " pam = $pam_support"
echo " systemd = $with_systemd"
echo " tls = $tls_support"
echo ""
pgbouncer-1.24.1/configure.ac 0000644 0001750 0000000 00000012627 14777762222 013005 0000000 0000000 dnl Process this file with autoconf to produce a configure script.
AC_INIT([PgBouncer],
[1.24.1],
[https://github.com/pgbouncer/pgbouncer/issues], [],
[https://www.pgbouncer.org/])
AC_CONFIG_SRCDIR(src/janitor.c)
AC_CONFIG_HEADERS([lib/usual/config.h])
AC_PREREQ([2.59])
dnl basic init
AC_USUAL_INIT
dnl Checks for programs.
AC_USUAL_PROGRAM_CHECK
PKG_PROG_PKG_CONFIG
AC_CHECK_PROGS(PANDOC, pandoc, pandoc)
AC_CHECK_PROGS(PYTHON, [python3 python], python3)
dnl check for windows tools
if test "$PORTNAME" = "win32"; then
AC_CHECK_TOOL([WINDRES], [windres])
AC_CHECK_TOOL([DLLWRAP], [dllwrap])
AC_CHECK_TOOL([DLLTOOL], [dlltool])
fi
AC_CHECK_TOOL([STRIP], [strip])
dnl Checks for header files.
AC_USUAL_HEADER_CHECK
AC_CHECK_HEADERS([sys/resource.h sys/wait.h])
dnl Checks for typedefs, structures, and compiler characteristics.
AC_USUAL_TYPE_CHECK
dnl autoconf 2.59 does not have UINT macros nor docdir
m4_ifdef([AC_TYPE_UINT8_T], [
AC_TYPE_UINT8_T
AC_TYPE_UINT32_T
AC_TYPE_UINT64_T
], [
datarootdir='${prefix}/share'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
AC_SUBST(datarootdir)
AC_SUBST(docdir)
])
dnl Checks for library functions.
AC_USUAL_FUNCTION_CHECK
AC_SEARCH_LIBS(clock_gettime, rt)
AC_SEARCH_LIBS(getsockname, socket)
AC_SEARCH_LIBS(gethostbyname, nsl)
AC_SEARCH_LIBS(hstrerror, resolv)
AC_CHECK_FUNCS(lstat)
dnl Find libevent
PKG_CHECK_MODULES(LIBEVENT, libevent)
dnl Check for PAM authentication support
pam_support=no
AC_ARG_WITH(pam,
AS_HELP_STRING([--with-pam], [build with PAM support]),
[ PAM=
if test "$withval" != no; then
have_pthreads=no
# Look for PAM header and lib
AC_CHECK_HEADERS(security/pam_appl.h, [have_pam_header=t])
AC_CHECK_HEADERS(pthread.h, [have_pthreads=yes])
AC_SEARCH_LIBS(pam_start, pam, [have_libpam=t])
AC_SEARCH_LIBS(pthread_create, pthread, [], [have_pthreads=no])
if test x"${have_pthreads}" != xyes; then
AC_MSG_ERROR([pthread library should be available for PAM support])
fi
if test x"${have_pam_header}" != x -a x"${have_libpam}" != x -a x"${have_pthreads}" = xyes; then
pam_support=yes
AC_DEFINE(HAVE_PAM, 1, [PAM support])
fi
fi
], [])
dnl Check for systemd support
AC_MSG_CHECKING([whether to build with systemd support])
AC_ARG_WITH(systemd,
[AS_HELP_STRING([--with-systemd], [build with systemd support])],
[if test "$withval" != no; then with_systemd=yes; else with_systemd=no; fi],
[with_systemd=no])
AC_MSG_RESULT([$with_systemd])
AC_SUBST(with_systemd)[]dnl
if test "$with_systemd" = yes; then
AC_DEFINE([USE_SYSTEMD], 1, [Define to build with systemd support. (--with-systemd)])
AC_CHECK_HEADER(systemd/sd-daemon.h, [], [AC_MSG_ERROR([header file is required for systemd support])])
AC_SEARCH_LIBS(sd_notify, systemd)
fi
##
## DNS backend
##
# make sure all vars are set
use_cares=no
use_evdns=no
dnl Find c-ares
AC_MSG_CHECKING([whether to use c-ares for DNS lookups])
AC_ARG_WITH(cares,
AS_HELP_STRING([--with-cares@<:@=PREFIX@:>@], [build with c-ares support]),
[ if test "$withval" = "no"; then
use_cares=no
elif test "$withval" = "yes"; then
use_cares="$withval"
CARES_CFLAGS=""
CARES_LIBS="-lcares"
elif test "$withval" = "auto"; then
use_cares="$withval"
else
use_cares=yes
CARES_CFLAGS="-I$withval/include"
CARES_LIBS="-L$withval/lib -lcares"
fi
], [use_cares=auto])
AC_MSG_RESULT([$use_cares])
if test "$use_cares" = "auto"; then
PKG_CHECK_MODULES(CARES, [libcares >= 1.9.0], [use_cares=yes], [use_cares=no])
fi
if test "$use_cares" = "yes"; then
AC_DEFINE(USE_CARES, 1, [Use c-ares for name resolution.])
tmp_CFLAGS="$CFLAGS"
tmp_LIBS="$LIBS"
CFLAGS="$CARES_CFLAGS $CFLAGS"
LIBS="$CARES_LIBS $LIBS"
# portability substitute for arpa/nameser.h, needed mainly for Windows
AC_CHECK_HEADERS([ares_nameser.h])
LIBS="$tmp_LIBS"
CFLAGS="$tmp_CFLAGS"
else # !cares
dnl Allow user to override the decision
AC_ARG_ENABLE(evdns, AS_HELP_STRING([--disable-evdns], [do not use libevent for DNS lookups]),
[use_evdns=$enableval], [use_evdns=yes])
AC_MSG_CHECKING([whether to use libevent for DNS lookups])
if test "$use_evdns" = "yes"; then
AC_DEFINE(USE_EVDNS, 1, [Use libevent for DNS lookups.])
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
fi
dnl Check if need getaddinfo_a compat
if test "$use_cares.$use_evdns" = "no.no"; then
AC_USUAL_GETADDRINFO_A
fi
fi # !cares
## end of DNS
AC_USUAL_TLS
AC_USUAL_DEBUG
AC_USUAL_CASSERT
AC_USUAL_WERROR
PACKAGE_VERSION_4B=`echo "${PACKAGE_VERSION}.0" | sed -e 's/\./,/g'`
AC_DEFINE_UNQUOTED(PACKAGE_VERSION_4B, [$PACKAGE_VERSION_4B],
[Define to the version of this package for Windows resource file (1,2,3,4).])dnl
dnl Output findings
AC_CONFIG_FILES([config.mak])
AC_OUTPUT
dnl If separate build dir, link Makefile over
test -f Makefile || {
echo "Linking Makefile"
ln -s $srcdir/Makefile
}
echo ""
echo "Results:"
dnl Note: Report here should match selection in src/dnslookup.c
if test "$use_cares" = "yes"; then
echo " adns = c-ares"
elif test "$use_evdns" = "yes"; then
echo " adns = evdns2"
elif test "$ac_cv_usual_glibc_gaia" = "yes"; then
echo " adns = libc"
else
echo " adns = compat"
fi
echo " pam = $pam_support"
echo " systemd = $with_systemd"
echo " tls = $tls_support"
echo ""
pgbouncer-1.24.1/doc/ 0000755 0000000 0000000 00000000000 14777762567 011333 5 0000000 0000000 pgbouncer-1.24.1/doc/usage.md 0000644 0001750 0000000 00000065371 14777762222 012716 0000000 0000000 # pgbouncer
## Synopsis
pgbouncer [-d][-R][-v][-u user]
pgbouncer -V|-h
On Windows, the options are:
pgbouncer.exe [-v][-u user]
pgbouncer.exe -V|-h
Additional options for setting up a Windows service:
pgbouncer.exe --regservice
pgbouncer.exe --unregservice
## Description
**pgbouncer** is a PostgreSQL connection pooler. Any target application
can be connected to **pgbouncer** as if it were a PostgreSQL server,
and **pgbouncer** will create a connection to the actual server, or it
will reuse one of its existing connections.
The aim of **pgbouncer** is to lower the performance impact of opening
new connections to PostgreSQL.
In order not to compromise transaction semantics for connection
pooling, **pgbouncer** supports several types of pooling when
rotating connections:
Session pooling
: Most polite method. When a client connects, a server connection will
be assigned to it for the whole duration the client stays connected. When
the client disconnects, the server connection will be put back into the pool.
This is the default method.
Transaction pooling
: A server connection is assigned to a client only during a transaction.
When PgBouncer notices that transaction is over, the server connection
will be put back into the pool.
Statement pooling
: Most aggressive method. The server connection will be put back into the
pool immediately after a query completes. Multi-statement
transactions are disallowed in this mode as they would break.
The administration interface of **pgbouncer** consists of some new
`SHOW` commands available when connected to a special "virtual"
database **pgbouncer**.
## Quick-start
Basic setup and usage is as follows.
1. Create a pgbouncer.ini file. Details in **pgbouncer(5)**. Simple example:
[databases]
template1 = host=localhost port=5432 dbname=template1
[pgbouncer]
listen_port = 6432
listen_addr = localhost
auth_type = md5
auth_file = userlist.txt
logfile = pgbouncer.log
pidfile = pgbouncer.pid
admin_users = someuser
2. Create a `userlist.txt` file that contains the users allowed in:
"someuser" "same_password_as_in_server"
3. Launch **pgbouncer**:
$ pgbouncer -d pgbouncer.ini
4. Have your application (or the **psql** client) connect to
**pgbouncer** instead of directly to the PostgreSQL server:
$ psql -p 6432 -U someuser template1
5. Manage **pgbouncer** by connecting to the special administration
database **pgbouncer** and issuing `SHOW HELP;` to begin:
$ psql -p 6432 -U someuser pgbouncer
pgbouncer=# SHOW HELP;
NOTICE: Console usage
DETAIL:
SHOW [HELP|CONFIG|DATABASES|FDS|POOLS|CLIENTS|SERVERS|SOCKETS|LISTS|VERSION|...]
SET key = arg
RELOAD
PAUSE
SUSPEND
RESUME
SHUTDOWN
[...]
6. If you made changes to the pgbouncer.ini file, you can reload it with:
pgbouncer=# RELOAD;
## Command line switches
`-d`, `--daemon`
: Run in the background. Without it, the process will run in the foreground.
In daemon mode, setting `pidfile` as well as `logfile` or `syslog`
is required. No log messages will be written to stderr after
going into the background.
Note: Does not work on Windows; **pgbouncer** need to run as service there.
`-R`, `--reboot`
: **DEPRECATED: Instead of this option use a rolling restart with multiple
pgbouncer processes listening on the same port using so_reuseport instead**
Do an online restart. That means connecting to the running process,
loading the open sockets from it, and then using them. If there
is no active process, boot normally.
Note: Works only if OS supports Unix sockets and the `unix_socket_dir`
is not disabled in configuration. Does not work on Windows.
Does not work with TLS connections, they are dropped.
`-u` _USERNAME_, `--user=`_USERNAME_
: Switch to the given user on startup.
`-v`, `--verbose`
: Increase verbosity. Can be used multiple times.
`-q`, `--quiet`
: Be quiet: do not log to stderr. This does not affect
logging verbosity, only that stderr is not to be used.
For use in init.d scripts.
`-V`, `--version`
: Show version.
`-h`, `--help`
: Show short help.
`--regservice`
: Win32: Register pgbouncer to run as Windows service. The **service_name**
configuration parameter value is used as the name to register under.
`--unregservice`
: Win32: Unregister Windows service.
## Admin console
The console is available by connecting as normal to the
database **pgbouncer**:
$ psql -p 6432 pgbouncer
Only users listed in the configuration parameters **admin_users** or **stats_users**
are allowed to log in to the console. (Except when `auth_type=any`, then
any user is allowed in as a stats_user.)
Additionally, the user name **pgbouncer** is allowed to log in without password,
if the login comes via the Unix socket and the client has same Unix user UID
as the running process.
The admin console currently only supports the simple query protocol.
Some drivers use the extended query protocol for all commands; these
drivers will not work for this.
### Show commands
The **SHOW** commands output information. Each command is described below.
#### SHOW STATS
Shows statistics. In this and related commands, the total figures are
since process start, the averages are updated every `stats_period`.
database
: Statistics are presented per database.
total_xact_count
: Total number of SQL transactions pooled by **pgbouncer**.
total_query_count
: Total number of SQL commands pooled by **pgbouncer**.
total_server_assignment_count
: Total times a server was assigned to a client
total_received
: Total volume in bytes of network traffic received by **pgbouncer**.
total_sent
: Total volume in bytes of network traffic sent by **pgbouncer**.
total_xact_time
: Total number of microseconds spent by **pgbouncer** when connected
to PostgreSQL in a transaction, either idle in transaction or
executing queries.
total_query_time
: Total number of microseconds spent by **pgbouncer** when actively
connected to PostgreSQL, executing queries.
total_wait_time
: Time spent by clients waiting for a server, in microseconds. Updated
when a client connection is assigned a backend connection.
total_client_parse_count
: Total number of prepared statements created by clients. Only applicable
in named prepared statement tracking mode, see `max_prepared_statements`.
total_server_parse_count
: Total number of prepared statements created by **pgbouncer** on a server. Only
applicable in named prepared statement tracking mode, see `max_prepared_statements`.
total_bind_count
: Total number of prepared statements readied for execution by clients and forwarded
to PostgreSQL by **pgbouncer**. Only applicable in named prepared statement tracking
mode, see `max_prepared_statements`.
avg_xact_count
: Average transactions per second in last stat period.
avg_query_count
: Average queries per second in last stat period.
avg_server_assignment_count
: Average number of times a server as assigned to a client per second in the
last stat period.
avg_recv
: Average received (from clients) bytes per second.
avg_sent
: Average sent (to clients) bytes per second.
avg_xact_time
: Average transaction duration, in microseconds.
avg_query_time
: Average query duration, in microseconds.
avg_wait_time
: Time spent by clients waiting for a server, in microseconds (average
of the wait times for clients assigned a backend during the current
`stats_period`).
avg_client_parse_count
: Average number of prepared statements created by clients. Only applicable
in named prepared statement tracking mode, see `max_prepared_statements`.
avg_server_parse_count
: Average number of prepared statements created by **pgbouncer** on a server. Only
applicable in named prepared statement tracking mode, see `max_prepared_statements`.
avg_bind_count
: Average number of prepared statements readied for execution by clients and forwarded
to PostgreSQL by **pgbouncer**. Only applicable in named prepared statement tracking
mode, see `max_prepared_statements`.
#### SHOW STATS_TOTALS
Subset of **SHOW STATS** showing the total values (**total_**).
#### SHOW STATS_AVERAGES
Subset of **SHOW STATS** showing the average values (**avg_**).
#### SHOW TOTALS
Like **SHOW STATS** but aggregated across all databases.
#### SHOW SERVERS
type
: S, for server.
user
: User name **pgbouncer** uses to connect to server.
database
: Database name.
replication
: If server connection uses replication. Can be **none**, **logical** or **physical**.
state
: State of the pgbouncer server connection, one of **active**,
**idle**, **used**, **tested**, **new**, **active_cancel**,
**being_canceled**.
addr
: IP address of PostgreSQL server.
port
: Port of PostgreSQL server.
local_addr
: Connection start address on local machine.
local_port
: Connection start port on local machine.
connect_time
: When the connection was made.
request_time
: When last request was issued.
wait
: Not used for server connections.
wait_us
: Not used for server connections.
close_needed
: 1 if the connection will be closed as soon as possible,
because a configuration file reload or DNS update changed the
connection information or **RECONNECT** was issued.
ptr
: Address of internal object for this connection.
link
: Address of client connection the server is paired with.
remote_pid
: PID of backend server process. In case connection is made over
Unix socket and OS supports getting process ID info, its
OS PID. Otherwise it's extracted from cancel packet the server sent,
which should be the PID in case the server is PostgreSQL, but it's a random
number in case the server it is another PgBouncer.
tls
: A string with TLS connection information, or empty if not using TLS.
application_name
: A string containing the `application_name` set on the linked client connection,
or empty if this is not set, or if there is no linked connection.
prepared_statements
: The amount of prepared statements that are prepared on the server. This
number is limited by the `max_prepared_statements` setting.
id
: Unique ID for server.
#### SHOW CLIENTS
type
: C, for client.
user
: Client connected user.
database
: Database name.
replication
: If client connection uses replication. Can be **none**, **logical** or **physical**.
state
: State of the client connection, one of **active**, **waiting**,
**active_cancel_req**, or **waiting_cancel_req**.
addr
: IP address of client.
port
: Source port of client.
local_addr
: Connection end address on local machine.
local_port
: Connection end port on local machine.
connect_time
: Timestamp of connect time.
request_time
: Timestamp of latest client request.
wait
: Current waiting time in seconds.
wait_us
: Microsecond part of the current waiting time.
close_needed
: not used for clients
ptr
: Address of internal object for this connection.
link
: Address of server connection the client is paired with.
remote_pid
: Process ID, in case client connects over Unix socket
and OS supports getting it.
tls
: A string with TLS connection information, or empty if not using TLS.
application_name
: A string containing the `application_name` set by the client
for this connection, or empty if this was not set.
prepared_statements
: The amount of prepared statements that the client has prepared
id
: Unique ID for client.
#### SHOW POOLS
A new pool entry is made for each couple of (database, user).
database
: Database name.
user
: User name.
cl_active
: Client connections that are either linked to server connections or are idle with no queries waiting to be processed.
cl_waiting
: Client connections that have sent queries but have not yet got a server connection.
cl_active_cancel_req
: Client connections that have forwarded query cancellations to the server and
are waiting for the server response.
cl_waiting_cancel_req
: Client connections that have not forwarded query cancellations to the server yet.
sv_active
: Server connections that are linked to a client.
sv_active_cancel
: Server connections that are currently forwarding a cancel request.
sv_being_canceled
: Servers that normally could become idle but are waiting to do so until
all in-flight cancel requests have completed that were sent to cancel
a query on this server.
sv_idle
: Server connections that are unused and immediately usable for client queries.
sv_used
: Server connections that have been idle for more than `server_check_delay`,
so they need `server_check_query` to run on them before they can be used again.
sv_tested
: Server connections that are currently running either `server_reset_query`
or `server_check_query`.
sv_login
: Server connections currently in the process of logging in.
maxwait
: How long the first (oldest) client in the queue has waited, in seconds.
If this starts increasing, then the current pool of servers does
not handle requests quickly enough. The reason may be either an overloaded
server or just too small of a **pool_size** setting.
maxwait_us
: Microsecond part of the maximum waiting time.
pool_mode
: The pooling mode in use.
load_balance_hosts
: The load_balance_hosts in use if the pool's host contains a comma-separated list.
#### SHOW PEER_POOLS
A new peer_pool entry is made for each configured peer.
database
: ID of the configured peer entry.
cl_active_cancel_req
: Client connections that have forwarded query cancellations to the server and
are waiting for the server response.
cl_waiting_cancel_req
: Client connections that have not forwarded query cancellations to the server yet.
sv_active_cancel
: Server connections that are currently forwarding a cancel request.
sv_login
: Server connections currently in the process of logging in.
#### SHOW LISTS
Show following internal information, in columns (not rows):
databases
: Count of databases.
users
: Count of users.
pools
: Count of pools.
free_clients
: Count of free clients. These are clients that are disconnected, but
PgBouncer keeps the memory around that was allocated for them so it can be
reused for a future clients to avoid allocations.
used_clients
: Count of used clients.
login_clients
: Count of clients in **login** state.
free_servers
: Count of free servers. These are servers that are disconnected, but
PgBouncer keeps the memory around that was allocated for them so it can be
reused for a future servers to avoid allocations.
used_servers
: Count of used servers.
dns_names
: Count of DNS names in the cache.
dns_zones
: Count of DNS zones in the cache.
dns_queries
: Count of in-flight DNS queries.
dns_pending
: not used
#### SHOW USERS
name
: The user name
pool_size
: The user's override pool_size. or NULL if not set.
reserve_pool_size
: The user's override reserve_pool_size. or NULL if not set.
pool_mode
: The user's override pool_mode, or NULL if not set.
max_user_connections
: The user's max_user_connections setting. If this setting is not set
for this specific user, then the default value will be displayed.
current_connections
: Current number of server connections that this user has open to all servers.
max_user_client_connections
: The user's max_user_client_connections setting. If this setting is not set
for this specific user, then the default value will be displayed.
current_client_connections
: Current number of client connections that this user has open to pgbouncer.
#### SHOW DATABASES
name
: Name of configured database entry.
host
: Host pgbouncer connects to.
port
: Port pgbouncer connects to.
database
: Actual database name pgbouncer connects to.
force_user
: When the user is part of the connection string, the connection between
pgbouncer and PostgreSQL is forced to the given user, whatever the
client user.
pool_size
: Maximum number of server connections.
min_pool_size
: Minimum number of server connections.
reserve_pool_size
: Maximum number of additional connections for this database.
server_lifetime
: The maximum lifetime of a server connection for this database
pool_mode
: The database's override pool_mode, or NULL if the default will be used instead.
load_balance_hosts
: The database's load_balance_hosts if the host contains a comma-separated list.
max_connections
: Maximum number of allowed server connections for this database, as set by
**max_db_connections**, either globally or per database.
current_connections
: Current number of server connections for this database.
max_client_connections
: Maximum number of allowed client connections for this pgbouncer instance, as set by max_db_client_connections per database.
current_client_connections
: Current number of client connections for this database.
paused
: 1 if this database is currently paused, else 0.
disabled
: 1 if this database is currently disabled, else 0.
#### SHOW PEERS
peer_id
: ID of the configured peer entry.
host
: Host pgbouncer connects to.
port
: Port pgbouncer connects to.
pool_size
: Maximum number of server connections that can be made to this peer
#### SHOW FDS
Internal command - shows list of file descriptors in use with internal state attached to them.
When the connected user has the user name "pgbouncer", connects through the Unix socket
and has same the UID as the running process, the actual FDs are passed over the connection.
This mechanism is used to do an online restart.
Note: This does not work on Windows.
This command also blocks the internal event loop, so it should not be used
while PgBouncer is in use.
fd
: File descriptor numeric value.
task
: One of **pooler**, **client** or **server**.
user
: User of the connection using the FD.
database
: Database of the connection using the FD.
addr
: IP address of the connection using the FD, **unix** if a Unix socket
is used.
port
: Port used by the connection using the FD.
cancel
: Cancel key for this connection.
link
: fd for corresponding server/client. NULL if idle.
#### SHOW SOCKETS, SHOW ACTIVE_SOCKETS
Shows low-level information about sockets or only active sockets.
This includes the information shown under **SHOW CLIENTS** and **SHOW
SERVERS** as well as other more low-level information.
#### SHOW CONFIG
Show the current configuration settings, one per row, with the following
columns:
key
: Configuration variable name
value
: Configuration value
default
: Configuration default value
changeable
: Either **yes** or **no**, shows if the variable can be changed while running.
If **no**, the variable can be changed only at boot time. Use
**SET** to change a variable at run time.
#### SHOW MEM
Shows low-level information about the current sizes of various
internal memory allocations. The information presented is subject to
change.
#### SHOW DNS_HOSTS
Show host names in DNS cache.
hostname
: Host name.
ttl
: How many seconds until next lookup.
addrs
: Comma separated list of addresses.
#### SHOW DNS_ZONES
Show DNS zones in cache.
zonename
: Zone name.
serial
: Current serial.
count
: Host names belonging to this zone.
#### SHOW VERSION
Show the PgBouncer version string.
#### SHOW STATE
Show the PgBouncer state settings. Current states are active, paused and suspended.
### Process controlling commands
#### PAUSE [db]
PgBouncer tries to disconnect from all servers. Disconnecting each server connection
waits for that server connection to be released according to the server pool's pooling
mode (in transaction pooling mode, the transaction must complete, in statement mode,
the statement must complete, and in session pooling mode the client must disconnect).
The command will not return before all server connections have been disconnected.
To be used at the time of database restart.
If database name is given, only that database will be paused.
New client connections to a paused database will wait until **RESUME**
is called.
#### DISABLE db
Reject all new client connections on the given database.
#### ENABLE db
Allow new client connections after a previous **DISABLE** command.
#### RECONNECT [db]
Close each open server connection for the given database, or all
databases, after it is released (according to the pooling mode), even
if its lifetime is not up yet. New server connections can be made
immediately and will connect as necessary according to the pool size
settings.
This command is useful when the server connection setup has changed,
for example to perform a gradual switchover to a new server. It is
*not* necessary to run this command when the connection string in
pgbouncer.ini has been changed and reloaded (see **RELOAD**) or when
DNS resolution has changed, because then the equivalent of this
command will be run automatically. This command is only necessary if
something downstream of PgBouncer routes the connections.
After this command is run, there could be an extended period where
some server connections go to an old destination and some server
connections go to a new destination. This is likely only sensible
when switching read-only traffic between read-only replicas, or when
switching between nodes of a multimaster replication setup. If all
connections need to be switched at the same time, **PAUSE** is
recommended instead. To close server connections without waiting (for
example, in emergency failover rather than gradual switchover
scenarios), also consider **KILL**.
#### KILL db
Immediately drop all client and server connections on given database.
New client connections to a killed database will wait until **RESUME**
is called.
#### KILL_CLIENT id
Immediately kill specificed client connection along with any server
connections for the given client. The client to kill, is identified
by the `id` value that can be found using the `SHOW CLIENTS` command.
An example command will look something like `KILL_CLIENT 1234`.
#### SUSPEND
All socket buffers are flushed and PgBouncer stops listening for data on them.
The command will not return before all buffers are empty. To be used at the time
of PgBouncer online reboot.
New client connections to a suspended database will wait until
**RESUME** is called.
#### RESUME [db]
Resume work from previous **KILL**, **PAUSE**, or **SUSPEND** command.
#### SHUTDOWN
The PgBouncer process will exit.
#### SHUTDOWN WAIT_FOR_SERVERS
Stop accepting new connections and shutdown after all servers are released.
This is basically the same as issuing **PAUSE** and **SHUTDOWN**, except that
this also stops accepting new connections while waiting for the **PAUSE** as
well as eagerly disconnecting clients that are waiting to receive a server
connection.
#### SHUTDOWN WAIT_FOR_CLIENTS
Stop accepting new connections and shutdown the process once all existing
clients have disconnected. This command can be used to do zero-downtime rolling
restart of two PgBouncer processes using the following procedure:
1. Have two or more PgBouncer processes running on the same port using
`so_reuseport` ([configuring peering](/config.html#section-peers) is
recommended, but not required). To achieve zero downtime when
restarting we'll restart these processes one-by-one, thus leaving the
others running to accept connections while one is being restarted.
2. Pick a process to restart first, let's call it A.
3. Run `SHUTDOWN WAIT_FOR_CLIENTS` (or send `SIGTERM`) to process A.
4. Cause all clients to reconnect. Possibly by waiting some time until the
client side pooler causes reconnects due to its `server_idle_timeout`
(or similar config). Or if no client side pooler is used, possibly by
restarting the clients. Once all clients have reconnected. Process A
will exit automatically, because no clients are connected to it anymore.
5. Start process A again.
6. Repeat step 3, 4 and 5 for each of the remaining processes, one-by-one
until you restarted all processes.
#### RELOAD
The PgBouncer process will reload its configuration files and update
changeable settings. This includes the main configuration file as
well as the files specified by the settings `auth_file` and
`auth_hba_file`.
PgBouncer notices when a configuration file reload changes the
connection parameters of a database definition. An existing server
connection to the old destination will be closed when the server
connection is next released (according to the pooling mode), and new
server connections will immediately use the updated connection
parameters.
#### WAIT_CLOSE [db]
Wait until all server connections, either of the specified database or
of all databases, have cleared the "close_needed" state (see **SHOW
SERVERS**). This can be called after a **RECONNECT** or **RELOAD** to
wait until the respective configuration change has been fully
activated, for example in switchover scripts.
### Other commands
#### SET key = arg
Changes a configuration setting (see also **SHOW CONFIG**). For example:
SET log_connections = 1;
SET server_check_query = 'select 2';
(Note that this command is run on the PgBouncer admin console and sets
PgBouncer settings. A **SET** command run on another database will be
passed to the PostgreSQL backend like any other SQL command.)
### Signals
SIGHUP
: Reload config. Same as issuing the command **RELOAD** on the console.
SIGTERM
: Super safe shutdown. Wait for all existing clients to disconnect, but don't
accept new connections. This is the same as issuing
**SHUTDOWN WAIT_FOR_CLIENTS** on the console. If this signal is received while
there is already a shutdown in progress, then an "immediate shutdown" is
triggered instead of a "super safe shutdown". In PgBouncer versions earlier
than 1.23.0, this signal would cause an "immediate shutdown".
SIGINT
: Safe shutdown. Same as issuing **SHUTDOWN WAIT_FOR_SERVERS** on the console.
If this signal is received while there is already a shutdown in progress,
then an "immediate shutdown" is triggered instead of a "safe shutdown".
SIGQUIT
: Immediate shutdown. Same as issuing **SHUTDOWN** on the console.
SIGUSR1
: Same as issuing **PAUSE** on the console.
SIGUSR2
: Same as issuing **RESUME** on the console.
### Libevent settings
From the Libevent documentation:
> It is possible to disable support for epoll, kqueue, devpoll, poll
> or select by setting the environment variable EVENT_NOEPOLL,
> EVENT_NOKQUEUE, EVENT_NODEVPOLL, EVENT_NOPOLL or EVENT_NOSELECT,
> respectively.
>
> By setting the environment variable EVENT_SHOW_METHOD, libevent
> displays the kernel notification method that it uses.
## See also
pgbouncer(5) - man page of configuration settings descriptions
pgbouncer-1.24.1/doc/frag-config-man.md 0000644 0001750 0000000 00000000154 14777762222 014531 0000000 0000000 % PGBOUNCER.INI(5) @PACKAGE_VERSION@ | Databases
## Name
pgbouncer.ini - configuration file for pgbouncer
pgbouncer-1.24.1/doc/filter.py 0000644 0001750 0000000 00000001045 14777762222 013113 0000000 0000000 #!/usr/bin/env python3
import fileinput
import os
import sys
for line in fileinput.input():
# substitute package version
if line.startswith("% "):
line = line.replace("@PACKAGE_VERSION@", os.environ["PACKAGE_VERSION"])
# drop level-1 header
if line.startswith("# "):
continue
# decrease level of all headers by 1
if line.startswith("##"):
line = line.replace("#", "", 1)
# convert level-1 headers to uppercase
if line.startswith("# "):
line = line.upper()
sys.stdout.write(line)
pgbouncer-1.24.1/doc/frag-usage-man.md 0000644 0001750 0000000 00000000160 14777762222 014365 0000000 0000000 % PGBOUNCER(1) @PACKAGE_VERSION@ | Databases
## Name
pgbouncer - lightweight connection pooler for PostgreSQL
pgbouncer-1.24.1/doc/config.md 0000644 0001750 0000000 00000161067 14777762222 013056 0000000 0000000 # pgbouncer.ini
## Description
The configuration file is in "ini" format. Section names are between "[" and "]". Lines
starting with ";" or "#" are taken as comments and ignored. The characters ";"
and "#" are not recognized as special when they appear later in the line.
## Generic settings
### logfile
Specifies the log file. For daemonization (`-d`), either this or
`syslog` need to be set.
The log file is kept open, so after rotation, `kill -HUP`
or on console `RELOAD;` should be done.
On Windows, the service must be stopped and started.
Note that setting `logfile` does not by itself turn off logging to
stderr. Use the command-line option `-q` or `-d` for that.
Default: not set
### pidfile
Specifies the PID file. Without `pidfile` set, daemonization (`-d`) is not allowed.
Default: not set
### listen_addr
Specifies a list (comma-separated) of addresses where to listen for TCP connections.
You may also use `*` meaning "listen on all addresses". When not set,
only Unix socket connections are accepted.
Addresses can be specified numerically (IPv4/IPv6) or by name.
Default: not set
### listen_port
Which port to listen on. Applies to both TCP and Unix sockets.
Default: 6432
### unix_socket_dir
Specifies the location for Unix sockets. Applies to both the listening socket and to
server connections. If set to an empty string, Unix sockets are disabled.
A value that starts with `@` specifies that a Unix socket in the
abstract namespace should be created (currently supported on Linux and
Windows).
For online reboot (`-R`) to work, a Unix socket needs to be
configured, and it needs to be in the file-system namespace.
Default: `/tmp` (empty on Windows)
### unix_socket_mode
File system mode for Unix socket.
Ignored for sockets in the abstract namespace.
Not supported on Windows.
Default: 0777
### unix_socket_group
Group name to use for Unix socket.
Ignored for sockets in the abstract namespace.
Not supported on Windows.
Default: not set
### user
If set, specifies the Unix user to change to after startup. Works only if
PgBouncer is started as root or if it's already running as the given user.
Not supported on Windows.
Default: not set
### pool_mode
Specifies when a server connection can be reused by other clients.
session
: Server is released back to pool after client disconnects. Default.
transaction
: Server is released back to pool after transaction finishes.
statement
: Server is released back to pool after query finishes. Transactions
spanning multiple statements are disallowed in this mode.
### max_client_conn
Maximum number of client connections allowed.
When this setting is increased, then the file descriptor limits in the
operating system might also have to be increased. Note that the
number of file descriptors potentially used is more than
`max_client_conn`. If each user connects under its own user name to
the server, the theoretical maximum used is:
max_client_conn + (max pool_size * total databases * total users)
If a database user
is specified in the connection string (all users connect under the same user name),
the theoretical maximum is:
max_client_conn + (max pool_size * total databases)
The theoretical maximum should never be reached, unless somebody deliberately
crafts a special load for it. Still, it means you should set the number of
file descriptors to a safely high number.
Search for `ulimit` in your favorite shell man page.
Note: `ulimit` does not apply in a Windows environment.
Default: 100
### default_pool_size
How many server connections to allow per user/database pair. Can be overridden in
the per-database configuration.
Default: 20
### min_pool_size
Add more server connections to pool if below this number.
Improves behavior when the normal load suddenly comes back after a period
of total inactivity. The value is effectively capped at the pool size.
Only enforced for pools where at least one of the following is true:
* the entry in the `[database]` section for the pool has a value set for the
`user` key (aka forced user)
* there is at least one client connected to the pool
Default: 0 (disabled)
### reserve_pool_size
How many additional connections to allow to a pool (see `reserve_pool_timeout`). 0 disables.
Default: 0 (disabled)
### reserve_pool_timeout
If a client has not been serviced in this time,
use additional connections from the reserve pool. 0 disables. [seconds]
Default: 5.0
### max_db_connections
Do not allow more than this many server connections per database
(regardless of user). This considers the PgBouncer database that the
client has connected to, not the PostgreSQL database of the outgoing
connection.
This can also be set per database in the `[databases]` section.
Note that when you hit the limit, closing a client connection to one
pool will not immediately allow a server connection to be established
for another pool, because the server connection for the first pool is
still open. Once the server connection closes (due to idle timeout),
a new server connection will immediately be opened for the waiting
pool.
Default: 0 (unlimited)
### max_db_client_connections
Do not allow more than this many client connections to PgBouncer per database
(regardless of user). This considers the PgBouncer database that the
client has connected to, not the PostgreSQL database of the outgoing
connection.
This should be set at a number greater than or equal to
max_db_connections. The difference between the two numbers can be thought
of as how many connections to a given database can be in the queue while
waiting for active connections to finish.
This can also be set per database in the `[databases]` section.
Default: 0 (unlimited)
### max_user_connections
Do not allow more than this many server connections per user
(regardless of database). This considers the PgBouncer user that is
associated with a pool, which is either the user specified for the
server connection or in absence of that the user the client has
connected as.
This can also be set per user in the `[users]` section.
Note that when you hit the limit, closing a client connection to one
pool will not immediately allow a server connection to be established
for another pool, because the server connection for the first pool is
still open. Once the server connection closes (due to idle timeout),
a new server connection will immediately be opened for the waiting
pool.
Default: 0 (unlimited)
### max_user_client_connections
Do not allow more than this many client connections per user
(regardless of database). This value should be set to a number higher than max_user_connections. This difference between max_user_connections and max_user_client_connections can be conceptualized as the number the max size of the queue for the user.
This can also be set per user in the `[users]` section.
Default: 0 (unlimited)
### server_round_robin
By default, PgBouncer reuses server connections in LIFO (last-in, first-out) manner,
so that few connections get the most load. This gives best performance if you have
a single server serving a database. But if there is a round-robin
system behind a database address (TCP, DNS, or host list), then it is
better if PgBouncer also uses connections in that manner, thus
achieving uniform load.
Default: 0
### track_extra_parameters
By default, PgBouncer tracks `client_encoding`, `datestyle`, `timezone`, `standard_conforming_strings`
and `application_name` parameters per client. To allow other parameters to be tracked, they can be
specified here, so that PgBouncer knows that they should be maintained in the client variable cache
and restored in the server whenever the client becomes active.
If you need to specify multiple values, use a comma-separated list (e.g.
`default_transaction_read_only, IntervalStyle`)
Note: Most parameters cannot be tracked this way. The only parameters that can be tracked are ones that
Postgres reports to the client. Postgres has
[an official list of parameters that it reports to the client](https://www.postgresql.org/docs/15/protocol-flow.html#PROTOCOL-ASYNC).
Postgres extensions can change this list though, they can add parameters themselves that they also report,
and they can start reporting already existing parameters that Postgres does not report.
Notably Citus 12.0+ causes Postgres to also report `search_path`.
The Postgres protocol allows specifying parameters settings, both directly as a
parameter in the startup packet, or inside the [`options` startup
packet][options-startup]. Parameters specified using both of these methods are
supported by `track_extra_parameters`. However, it's not possible to include
`options` itself in `track_extra_parameters`, only the parameters contained in
`options`.
Default: IntervalStyle
### ignore_startup_parameters
By default, PgBouncer allows only parameters it can keep track of in startup
packets: `client_encoding`, `datestyle`, `timezone` and `standard_conforming_strings`.
All others parameters will raise an error. To allow others parameters, they can be
specified here, so that PgBouncer knows that they are handled by the admin and it can ignore them.
If you need to specify multiple values, use a comma-separated list (e.g.
`options,extra_float_digits`)
The Postgres protocol allows specifying parameters settings, both directly as a
parameter in the startup packet, or inside the [`options` startup
packet][options-startup]. Parameters specified using both of these methods are
supported by `ignore_startup_parameters`. It's even possible to include
`options` itself in `track_extra_parameters`, which results in any unknown
parameters contained inside `options` to be ignored.
[options-startup]: https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNECT-OPTIONS
Default: empty
### peer_id
The peer id used to identify this PgBouncer process in a group of PgBouncer
processes that are peered together. The `peer_id` value should be unique within
a group of peered PgBouncer processes. When set to 0 pgbouncer peering is
disabled. See the docs for the `[peers]` section for more information. The
maximum value that can be used for the `peer_id` is 16383.
Default: 0
### disable_pqexec
Disable the Simple Query protocol (PQexec). Unlike the Extended Query protocol, Simple Query
allows multiple queries in one packet, which allows some classes of SQL-injection
attacks. Disabling it can improve security. Obviously, this means only clients that
exclusively use the Extended Query protocol will stay working.
Default: 0
### application_name_add_host
Add the client host address and port to the application name setting set on connection start.
This helps in identifying the source of bad queries etc. This logic applies
only at the start of a connection. If `application_name` is later changed with `SET`,
PgBouncer does not change it again.
Default: 0
### conffile
Show location of current config file. Changing it will make PgBouncer use another
config file for next `RELOAD` / `SIGHUP`.
Default: file from command line
### service_name
Used on win32 service registration.
Default: `pgbouncer`
### job_name
Alias for `service_name`.
### stats_period
Sets how often the averages shown in various `SHOW` commands are
updated and how often aggregated statistics are written to the log
(but see `log_stats`). [seconds]
Default: 60
### max_prepared_statements
When this is set to a non-zero value PgBouncer tracks protocol-level named
prepared statements related commands sent by the client in transaction and
statement pooling mode. PgBouncer makes sure that any statement prepared by
a client is available on the backing server connection. Even when the statement
was originally prepared on another server connection.
PgBouncer internally examines all the queries that are sent by clients as a prepared
statement, and gives each unique query string an internal name with
the format `PGBOUNCER_{unique_id}`. If the same query string is prepared
multiple times (possibly by different clients), then these queries share the
same internal name. PgBouncer only prepares the statement on the actual
PostgreSQL server using the internal name (so not the name provided by the
client). PgBouncer keeps track of the name that the client gave to each
prepared statement. It then rewrites each command that uses a prepared
statement to by replacing the client side name with the the internal name (e.g.
replacing `my_prepared_statement` with `PGBOUNCER_123`) before forwarding that
command to the server. More importantly, if the prepared statement that the
client wants to execute is not yet prepared on the server (e.g. because a
different server is now assigned to the client than when the client prepared
the statement), then PgBouncer transparently prepares the statement before
executing it.
Note: This tracking and rewriting of prepared statement commands does not work
for SQL-level prepared statement commands, so `PREPARE`, `EXECUTE` and
`DEALLOCATE` are forwarded straight to Postgres. The exception to this rule are
the `DEALLOCATE ALL` and `DISCARD ALL` commands, these do work as expected and
will clear the prepared statements that PgBouncer tracked for the client that
sends this command.
The actual value of this setting controls the number of prepared statements
kept active in an LRU cache on a single server connection. When the setting is
set to 0 prepared statement support for transaction and statement pooling is
disabled. To get the best performance you should try to make sure that this
setting is larger than the amount of commonly used prepared statements in your
application. Keep in mind that the higher this value, the larger the memory
footprint of each PgBouncer connection will be on your PostgreSQL server,
because it will keep more queries prepared on those connections. It also
increases the memory footprint of PgBouncer itself, because it now needs to
keep track of query strings.
The impact on PgBouncer memory usage is not that big though:
- Each unique query is stored once in a global query cache.
- Each client connection keeps a buffer that it uses to rewrite packets. This
is, at most, 4 times the size of `pkt_buf`. This limit is often not reached
though, it only happens when the queries in your prepared statements are
between 2 and 4 times the size of `pkt_buf`.
So if you consider the following as an example scenario:
- There are 1000 active clients
- The clients prepare 200 unique queries
- The average size of a query is 5kB
- `pkt_buf` parameter is set to the default of 4096 (4kB)
Then, PgBouncer needs at most the following amount of memory to handle these
prepared statements:
200 x 5kB + 1000 x 4 x 4kB = ~17MB of memory.
Tracking prepared statements does not only come with a memory cost, but also
with increased CPU usage, because PgBouncer needs to inspect and rewrite the
queries. Multiple PgBouncer instances can listen on the same port to use more
than one core for processing, see [the documentation for the `so_reuseport`
option](/config.html#so_reuseport) for details.
But of course there are also performance benefits to prepared statements. Just
as when connecting to PostgreSQL directly, by preparing a query that is
executed many times, it reduces the total amount of parsing and planning that
needs to be done. The way that PgBouncer tracks prepared statements is
especially beneficial to performance when multiple clients prepare the same
queries. Because client connections automatically reuse a prepared statement on
a server connection, even if it was prepared by another client. As an example, if
you have a `pool_size` of 20 and you have 100 clients that all prepare the
exact same query, then the query is prepared (and thus parsed) only 20 times on
the PostgreSQL server.
The reuse of prepared statements has one downside. If the return or argument
types of a prepared statement changes across executions then PostgreSQL
currently throws an error such as:
```
ERROR: cached plan must not change result type
```
You can avoid such errors by not having multiple clients that use the exact
same query string in a prepared statement, but expecting different argument or
result types. One of the most common ways of running into this issue is during
a DDL migration where you add a new column or change a column type on an
existing table. In those cases you can run `RECONNECT` on the PgBouncer admin
console after doing the migration to force a re-prepare of the query and make
the error go away.
Default: 200
## Authentication settings
PgBouncer handles its own client authentication and has its own
database of users. These settings control this.
### auth_type
How to authenticate users.
cert
: Client must connect over TLS connection with a valid client certificate.
The user name is then taken from the CommonName field from the certificate.
md5
: Use MD5-based password check. This is the default authentication
method. `auth_file` may contain both MD5-encrypted and plain-text
passwords. If `md5` is configured and a user has a SCRAM secret,
then SCRAM authentication is used automatically instead.
scram-sha-256
: Use password check with SCRAM-SHA-256. `auth_file` has to contain
SCRAM secrets or plain-text passwords.
plain
: The clear-text password is sent over the wire. Deprecated.
trust
: No authentication is done. The user name must still exist in `auth_file`.
any
: Like the `trust` method, but the user name given is ignored. Requires that all
databases are configured to log in as a specific user. Additionally, the console
database allows any user to log in as admin.
hba
: The actual authentication type is loaded from `auth_hba_file`. This allows different
authentication methods for different access paths, for example: connections
over Unix socket use the `peer` auth method, connections over TCP
must use TLS.
pam
: PAM is used to authenticate users, `auth_file` is ignored. This method is not
compatible with databases using the `auth_user` option. The service name reported to
PAM is "pgbouncer". `pam` is not supported in the HBA configuration file.
### auth_hba_file
HBA configuration file to use when `auth_type` is `hba`. See
section [HBA file format](#hba-file-format) below about details.
Default: not set
### auth_ident_file
Identity map file to use when `auth_type` is `hba` and a user map will be defined. See
section [Ident map file format](#ident-map-file-format) below about details.
Default: not set
### auth_file
The name of the file to load user names and passwords from. See
section [Authentication file format](#authentication-file-format) below about details.
Most authentication types (see above) require that either `auth_file`
or `auth_user` be set; otherwise there would be no users defined.
Default: not set
### auth_user
If `auth_user` is set, then any user not specified in `auth_file` will be
queried through the `auth_query` query from `pg_authid` in the database,
using `auth_user`. The password of `auth_user` will be taken from `auth_file`.
(If the `auth_user` does not require a password then it does not need
to be defined in `auth_file`.)
Direct access to `pg_authid` requires admin rights. It's preferable to
use a non-superuser that calls a SECURITY DEFINER function instead.
Default: not set
### auth_query
Query to load user's password from database.
Direct access to `pg_authid` requires admin rights. It's preferable to
use a non-superuser that calls a SECURITY DEFINER function instead.
Note that the query is run inside the target database. So if a function
is used, it needs to be installed into each database.
Default: `SELECT rolname, CASE WHEN rolvaliduntil < now() THEN NULL ELSE rolpassword END FROM pg_authid WHERE rolname=$1 AND rolcanlogin`
### auth_dbname
Database name in the `[database]` section to be used for authentication purposes. This
option can be either global or overridden in the connection string if this parameter is
specified.
## Log settings
### syslog
Toggles syslog on/off.
On Windows, the event log is used instead.
Default: 0
### syslog_ident
Under what name to send logs to syslog.
Default: `pgbouncer` (program name)
### syslog_facility
Under what facility to send logs to syslog.
Possibilities: `auth`, `authpriv`, `daemon`, `user`, `local0-7`.
Default: `daemon`
### log_connections
Log successful logins.
Default: 1
### log_disconnections
Log disconnections with reasons.
Default: 1
### log_pooler_errors
Log error messages the pooler sends to clients.
Default: 1
### log_stats
Write aggregated statistics into the log, every `stats_period`. This
can be disabled if external monitoring tools are used to grab the same
data from `SHOW` commands.
Default: 1
### verbose
Increase verbosity. Mirrors the "-v" switch on the command line.
For example, using "-v -v" on the command line is the same as `verbose=2`.
3 is the highest currently-supported verbosity.
Default: 0
## Console access control
### admin_users
Comma-separated list of database users that are allowed to connect and
run all commands on the console. Ignored when `auth_type` is `any`,
in which case any user name is allowed in as admin.
Default: empty
### stats_users
Comma-separated list of database users that are allowed to connect and
run read-only queries on the console. That means all `SHOW` commands except
`SHOW FDS`.
Default: empty
## Connection sanity checks, timeouts
### server_reset_query
Query sent to server on connection release, before making it
available to other clients. At that moment no transaction is in
progress, so the value should not include `ABORT` or `ROLLBACK`.
The query is supposed to clean any changes made to the database session
so that the next client gets the connection in a well-defined state. The default is
`DISCARD ALL`, which cleans everything, but that leaves the next client
no pre-cached state. It can be made lighter, e.g. `DEALLOCATE ALL`
to just drop prepared statements, if the application does not break when
some state is kept around.
When transaction pooling is used, the `server_reset_query` is not used,
because in that mode, clients must not use any session-based features, since each transaction
ends up in a different connection and thus gets a different session state.
Default: `DISCARD ALL`
### server_reset_query_always
Whether `server_reset_query` should be run in all pooling modes. When this
setting is off (default), the `server_reset_query` will be run only in pools
that are in sessions-pooling mode. Connections in transaction-pooling mode
should not have any need for a reset query.
This setting is for working around broken setups that run applications that use session features
over a transaction-pooled PgBouncer. It changes non-deterministic breakage
to deterministic breakage: Clients always lose their state after each
transaction.
Default: 0
### server_check_delay
How long to keep released connections available for immediate re-use, without running
`server_check_query` on it. If 0 then the check is always run.
Default: 30.0
### server_check_query
Simple do-nothing query to check if the server connection is alive.
If an empty string, then sanity checking is disabled.
Default: `select 1`
### server_fast_close
Disconnect a server in session pooling mode immediately or after the
end of the current transaction if it is in "close_needed" mode (set by
`RECONNECT`, `RELOAD` that changes connection settings, or DNS
change), rather than waiting for the session end. In statement or
transaction pooling mode, this has no effect since that is the default
behavior there.
If because of this setting a server connection is closed before the
end of the client session, the client connection is also closed. This
ensures that the client notices that the session has been interrupted.
This setting makes connection configuration changes take effect sooner
if session pooling and long-running sessions are used. The downside
is that client sessions are liable to be interrupted by a
configuration change, so client applications will need logic to
reconnect and reestablish session state. But note that no
transactions will be lost, because running transactions are not
interrupted, only idle sessions.
Default: 0
### server_lifetime
The pooler will close an unused (not currently linked to any client connection)
server connection that has been connected longer
than this. Setting it to 0 means the connection is to be used only once,
then closed. [seconds]
This can also be set per database in the `[databases]` section.
Default: 3600.0
### server_idle_timeout
If a server connection has been idle more than this many seconds it will be closed.
If 0 then this timeout is disabled. [seconds]
Default: 600.0
### server_connect_timeout
If connection and login don't finish in this amount of time, the connection
will be closed. [seconds]
Default: 15.0
### server_login_retry
If login to the server failed, because of failure to connect or from
authentication, the pooler waits this much before retrying to connect.
During the waiting interval, new clients trying to connect to the
failing server will get an error immediately without another
connection attempt. [seconds]
The purpose of this behavior is that clients don't unnecessarily queue
up waiting for a server connection to become available if the server
is not working. However, it also means that if a server is
momentarily failing, for example during a restart or if the
configuration was erroneous, then it will take at least this long
until the pooler will consider connecting to it again. Planned events
such as restarts should normally be managed using the `PAUSE` command
to avoid this.
Default: 15.0
### client_login_timeout
If a client connects but does not manage to log in in this amount of time, it
will be disconnected. Mainly needed to avoid dead connections stalling
`SUSPEND` and thus online restart. [seconds]
Default: 60.0
### autodb_idle_timeout
If the automatically created (via "*") database pools have
been unused this many seconds, they are freed. The negative
aspect of that is that their statistics are also forgotten. [seconds]
Default: 3600.0
### dns_max_ttl
How long DNS lookups can be cached. The actual DNS TTL is ignored.
[seconds]
Default: 15.0
### dns_nxdomain_ttl
How long DNS errors and NXDOMAIN DNS lookups can be cached. [seconds]
Default: 15.0
### dns_zone_check_period
Period to check if a zone serial has changed.
PgBouncer can collect DNS zones from host names (everything after first dot)
and then periodically check if the zone serial changes.
If it notices changes, all host names under that zone
are looked up again. If any host IP changes, its connections
are invalidated.
Works only with c-ares backend (`configure` option `--with-cares`).
Default: 0.0 (disabled)
### resolv_conf
The location of a custom `resolv.conf` file. This is to allow
specifying custom DNS servers and perhaps other name resolution
options, independent of the global operating system configuration.
Requires evdns (>= 2.0.3) or c-ares (>= 1.15.0) backend.
The parsing of the file is done by the DNS backend library, not
PgBouncer, so see the library's documentation for details on allowed
syntax and directives.
Default: empty (use operating system defaults)
## TLS settings
If the contents of any of the cert or key files are changed without
changing the actual setting filename in the config, the new file
contents will be used for new connections after a RELOAD. Existing
connections won't be closed though. If it's necessary for security
reasons that all connections start using the new files ASAP, it's
advised to run RECONNECT after the RELOAD.
Changing any TLS settings will trigger a RECONNECT automatically
for security reasons.
### client_tls_sslmode
TLS mode to use for connections from clients. TLS connections
are disabled by default. When enabled, `client_tls_key_file`
and `client_tls_cert_file` must be also configured to set up
the key and certificate PgBouncer uses to accept client connections.
The most common certificate file format usable by PgBouncer is pem.
disable
: Plain TCP. If client requests TLS, it's ignored. Default.
allow
: If client requests TLS, it is used. If not, plain TCP is used.
If the client presents a client certificate, it is not validated.
prefer
: Same as `allow`.
require
: Client must use TLS. If not, the client connection is rejected.
If the client presents a client certificate, it is not validated.
verify-ca
: Client must use TLS with valid client certificate.
verify-full
: Same as `verify-ca`.
### client_tls_key_file
Private key for PgBouncer to accept client connections.
Default: not set
### client_tls_cert_file
Certificate for private key. Clients can validate it.
Default: not set
### client_tls_ca_file
Root certificate file to validate client certificates.
Default: not set
### client_tls_protocols
Which TLS protocol versions are allowed. Allowed values: `tlsv1.0`, `tlsv1.1`, `tlsv1.2`, `tlsv1.3`.
Shortcuts: `all` (tlsv1.0,tlsv1.1,tlsv1.2,tlsv1.3), `secure` (tlsv1.2,tlsv1.3).
Default: `secure`
### client_tls_ciphers
Allowed TLS ciphers, in OpenSSL syntax. Shortcuts:
- `default`/`secure`/`fast`/`normal` (these all use system wide OpenSSL defaults)
- `all` (enables all ciphers, not recommended)
Only connections using TLS version 1.2 and lower are affected. There
is currently no setting that controls the cipher choices used by TLS
version 1.3 connections.
Default: `default`
### client_tls_ecdhcurve
Elliptic Curve name to use for ECDH key exchanges.
Allowed values: `none` (DH is disabled), `auto` (256-bit ECDH), curve name
Default: `auto`
### client_tls_dheparams
DHE key exchange type.
Allowed values: `none` (DH is disabled), `auto` (2048-bit DH), `legacy` (1024-bit DH)
Default: `auto`
### server_tls_sslmode
TLS mode to use for connections to PostgreSQL servers. The default mode is
`prefer`.
disable
: Plain TCP. TLS is not even requested from the server.
allow
: FIXME: if server rejects plain, try TLS?
prefer
: TLS connection is always requested first from PostgreSQL.
If refused, the connection will be established over plain TCP.
Server certificate is not validated. Default
require
: Connection must go over TLS. If server rejects it,
plain TCP is not attempted. Server certificate is not validated.
verify-ca
: Connection must go over TLS and server certificate must be valid
according to `server_tls_ca_file`. Server host name is not checked
against certificate.
verify-full
: Connection must go over TLS and server certificate must be valid
according to `server_tls_ca_file`. Server host name must match
certificate information.
### server_tls_ca_file
Root certificate file to validate PostgreSQL server certificates.
Default: not set
### server_tls_key_file
Private key for PgBouncer to authenticate against PostgreSQL server.
Default: not set
### server_tls_cert_file
Certificate for private key. PostgreSQL server can validate it.
Default: not set
### server_tls_protocols
Which TLS protocol versions are allowed. Allowed values: `tlsv1.0`, `tlsv1.1`, `tlsv1.2`, `tlsv1.3`.
Shortcuts: `all` (tlsv1.0,tlsv1.1,tlsv1.2,tlsv1.3), `secure` (tlsv1.2,tlsv1.3), `legacy` (all).
Default: `secure`
### server_tls_ciphers
Allowed TLS ciphers, in OpenSSL syntax. Shortcuts:
- `default`/`secure`/`fast`/`normal` (these all use system wide OpenSSL defaults)
- `all` (enables all ciphers, not recommended)
Only connections using TLS version 1.2 and lower are affected. There
is currently no setting that controls the cipher choices used by TLS
version 1.3 connections.
Default: `default`
## Dangerous timeouts
Setting the following timeouts can cause unexpected errors.
### query_timeout
Queries running longer than that are canceled. This should be used only with
a slightly smaller server-side `statement_timeout`, to apply only for network
problems. [seconds]
Default: 0.0 (disabled)
### query_wait_timeout
Maximum time queries are allowed to spend waiting for execution. If the query
is not assigned to a server during that time, the client is disconnected.
0 disables. If this is disabled, clients will be queued indefinitely. [seconds]
This setting is used to prevent unresponsive servers from grabbing up
connections. It also helps when the server is down or rejects
connections for any reason.
Default: 120.0
### cancel_wait_timeout
Maximum time cancellation requests are allowed to spend waiting for execution.
If the cancel request is not assigned to a server during that time, the client is
disconnected.
0 disables. If this is disabled, cancel requests will be queued indefinitely. [seconds]
This setting is used to prevent a client locking up when a cancel cannot be
forwarded due to the server being down.
Default: 10.0
### client_idle_timeout
Client connections idling longer than this many seconds are closed. This should
be larger than the client-side connection lifetime settings, and only used
for network problems. [seconds]
Default: 0.0 (disabled)
### idle_transaction_timeout
If a client has been in "idle in transaction" state longer,
it will be disconnected. [seconds]
Default: 0.0 (disabled)
### suspend_timeout
How long to wait for buffer flush during `SUSPEND` or reboot (`-R`).
A connection is dropped if the flush does not succeed. [seconds]
Default: 10
## Low-level network settings
### pkt_buf
Internal buffer size for packets. Affects size of TCP packets sent and general
memory usage. Actual libpq packets can be larger than this, so no need to set it
large.
Default: 4096
### max_packet_size
Maximum size for PostgreSQL packets that PgBouncer allows through. One packet
is either one query or one result set row. The full result set can be larger.
Default: 2147483647
### listen_backlog
Backlog argument for listen(2). Determines how many new unanswered connection
attempts are kept in the queue. When the queue is full, further new connections are dropped.
Default: 128
### sbuf_loopcnt
How many times to process data on one connection, before proceeding.
Without this limit, one connection with a big result set can stall
PgBouncer for a long time. One loop processes one `pkt_buf` amount of data.
0 means no limit.
Default: 5
### so_reuseport
Specifies whether to set the socket option `SO_REUSEPORT` on TCP
listening sockets. On some operating systems, this allows running
multiple PgBouncer instances on the same host listening on the same
port and having the kernel distribute the connections automatically.
This option is a way to get PgBouncer to use more CPU cores.
(PgBouncer is single-threaded and uses one CPU core per instance.)
The behavior in detail depends on the operating system kernel. As of
this writing, this setting has the desired effect on (sufficiently
recent versions of) Linux, DragonFlyBSD, and FreeBSD. (On FreeBSD, it
applies the socket option `SO_REUSEPORT_LB` instead.) Some other
operating systems support the socket option but it won't have the
desired effect: It will allow multiple processes to bind to the same
port but only one of them will get the connections. See your
operating system's setsockopt() documentation for details.
On systems that don't support the socket option at all, turning this
setting on will result in an error.
Each PgBouncer instance on the same host needs different settings for
at least `unix_socket_dir` and `pidfile`, as well as `logfile` if that
is used. Also note that if you make use of this option, you can no
longer connect to a specific PgBouncer instance via TCP/IP, which
might have implications for monitoring and metrics collection.
To make sure query cancellations keep working, you should set up PgBouncer
peering between the different PgBouncer processes. For details look at docs
for the `peer_id` configuration option and the `peers` configuration section.
There's also an example that uses peering and so_reuseport in the example
section of these docs.
Default: 0
### tcp_defer_accept
Sets the `TCP_DEFER_ACCEPT` socket option; see `man 7 tcp` for
details. (This is a Boolean option: 1 means enabled. The actual
value set if enabled is currently hardcoded to 45 seconds.)
This is currently only supported on Linux.
Default: 1 on Linux, otherwise 0
### tcp_socket_buffer
Default: not set
### tcp_keepalive
Turns on basic keepalive with OS defaults.
On Linux, the system defaults are tcp_keepidle=7200, tcp_keepintvl=75,
tcp_keepcnt=9. They are probably similar on other operating systems.
Default: 1
### tcp_keepcnt
Default: not set
### tcp_keepidle
Default: not set
### tcp_keepintvl
Default: not set
### tcp_user_timeout
Sets the `TCP_USER_TIMEOUT` socket option. This specifies the maximum
amount of time in milliseconds that transmitted data may remain
unacknowledged before the TCP connection is forcibly closed. If set
to 0, then operating system's default is used.
This is currently only supported on Linux.
Default: 0
## Section [databases]
The section `[databases]` defines the names of the databases that
clients of PgBouncer can connect to and specifies where those
connections will be routed. The section contains key=value lines like
dbname = connection string
where the key will be taken as a database name and the value as a
connection string, consisting of key=value pairs of connection
parameters, described below (similar to libpq, but the actual libpq is
not used and the set of available features is different). Example:
foodb = host=host1.example.com port=5432
bardb = host=localhost dbname=bazdb
The database name can contain characters `_0-9A-Za-z` without quoting.
Names that contain other characters need to be quoted with standard SQL
identifier quoting: double quotes, with "" for a single instance of a double quote.
The database name "pgbouncer" is reserved for the admin console and
cannot be used as a key here.
"*" acts as a fallback database: If the exact name does not exist, its
value is taken as connection string for the requested database. For
example, if there is an entry (and no other overriding entries)
* = host=foo
then a connection to PgBouncer specifying a database "bar" will
effectively behave as if an entry
bar = host=foo dbname=bar
exists (taking advantage of the default for `dbname` being the
client-side database name; see below).
Such automatically created database entries are cleaned up
if they stay idle longer than the time specified by the `autodb_idle_timeout`
parameter.
### dbname
Destination database name.
Default: same as client-side database name
### host
Host name or IP address to connect to. Host names are resolved
at connection time, the result is cached per `dns_max_ttl` parameter.
When a host name's resolution changes, existing server connections are
automatically closed when they are released (according to the pooling
mode), and new server connections immediately use the new resolution.
If DNS returns several results, they are used in a round-robin
manner.
If the value begins with `/`, then a Unix socket in the file-system
namespace is used. If the value begins with `@`, then a Unix socket
in the abstract namespace is used.
A comma-separated list of host names or addresses can be specified.
In that case, connections are made in a round-robin manner. (If a
host list contains host names that in turn resolve via DNS to multiple
addresses, the round-robin systems operate independently. This is an
implementation dependency that is subject to change.) Note that in a
list, all hosts must be available at all times: There are no
mechanisms to skip unreachable hosts or to select only available hosts
from a list or similar. (This is different from what a host list in
libpq means.) Also note that this only affects how the destinations
of new connections are chosen. See also the setting
`server_round_robin` for how clients are assigned to already
established server connections.
Examples:
host=localhost
host=127.0.0.1
host=2001:0db8:85a3:0000:0000:8a2e:0370:7334
host=/var/run/postgresql
host=192.168.0.1,192.168.0.2,192.168.0.3
Default: not set, meaning to use a Unix socket
### port
Default: 5432
### user
If `user=` is set, all connections to the destination database will be
done with the specified user, meaning that there will be only one pool
for this database.
Otherwise, PgBouncer logs into the destination database with the client
user name, meaning that there will be one pool per user.
### password
If no password is specified here, the password from the `auth_file` will
be used for the user specified above. Dynamic forms of password discovery
such as `auth_query` are not currently supported.
### auth_user
Override of the global `auth_user` setting, if specified.
### auth_query
Override of the global `auth_query` setting, if specified. The entire SQL statement needs to be enclosed in single quotes.
### auth_dbname
Override of the global `auth_dbname` setting, if specified.
### pool_size
Set the maximum size of pools for this database. If not set,
the `default_pool_size` is used.
### min_pool_size
Set the minimum pool size for this database. If not set, the global `min_pool_size` is
used.
Only enforced if at least one of the following is true:
* this entry in the `[database]` section has a value set for the `user` key
(aka forced user)
* there is at least one client connected to the pool
### reserve_pool_size
Set additional connections for this database. If not set, the global `reserve_pool_size`
is used. For backwards compatibilty reasons `reserve_pool` is an alias for this option.
### connect_query
Query to be executed after a connection is established, but before
allowing the connection to be used by any clients. If the query raises errors,
they are logged but ignored otherwise.
### pool_mode
Set the pool mode specific to this database. If not set,
the default `pool_mode` is used.
### load_balance_hosts
When a comma-separated list is specified in `host`, `load_balance_hosts` controls
which entry is chosen for a new connection.
Note: This setting currently only controls the load balancing behaviour when
providing multiple hosts in the connection string, but not when a single host
its DNS record references multiple IP addresses. This is a missing feature, so
in a future release this setting might start to to control both methods of load
balancing.
round-robin
: A new connection attempt chooses the next host entry in the list.
disable
: A new connection continues using the same host entry until a connection
fails, after which the next host entry is chosen.
It is recommended to set `server_login_retry` lower than the default to ensure
fast retries when multiple hosts are available.
Default: `round-robin`
### max_db_connections
Configure a database-wide maximum of server connections (i.e. all pools within the database will
not have more than this many server connections).
### max_db_client_connections
Configure a database-wide client connection maximum. Should be used in conjunction with max_client_conn
to limit the number of connections that PgBouncer is allowed to accept.
### server_lifetime
Configure the server_lifetime per database. If not set the database will fall back
to the instance wide configured value for `server_lifetime`
### client_encoding
Ask specific `client_encoding` from server.
### datestyle
Ask specific `datestyle` from server.
### timezone
Ask specific `timezone` from server.
## Section [users]
This section contains key=value lines like
user1 = settings
where the key will be taken as a user name and the value as a list of
key=value pairs of configuration settings specific for this user.
Example:
user1 = pool_mode=session
Only a few settings are available here.
Note that when `auth_file` is configured, if a user is defined in this section
but not listed in `auth_file`, pgBouncer will attempt to use `auth_query` to
find a password for that user if `auth_user` is set. If `auth_user` is not set,
pgBouncer will pretend the user exists and fail to return "no such user"
messages to the client, but neither will it accept any provided password.
### pool_size
Set the maximum size of pools for all connections from this user. If not set,
the database or `default_pool_size` is used.
### reserve_pool_size
Set the number of additional connections to allow to a pool for this user. If
not set, the database configuration or the global `reserve_pool_size` is used.
### pool_mode
Set the pool mode to be used for all connections from this user. If not set, the
database or default `pool_mode` is used.
### max_user_connections
Configure a maximum for the user of server connections (i.e. all pools with the user will
not have more than this many server connections).
### query_timeout
Set the maximum number of seconds that a user query can run for.
If set this timeout overrides the server level query_timeout described above.
### idle_transaction_timeout
Set the maximum number of seconds that a user can have an idle transaction open.
If set this timeout overides the server level idle_transaction_timeout
described above.
### client_idle_timeout
Set the maximum amount of time in seconds that a client is allowed to idly connect to
the pgbouncer instance. If set this timeout overrides the server level client_idle_timeout
described above.
Please note that this is a potentially dangeous timeout.
### max_user_client_connections
Configure a maximum for the user of client connections. This is the user equivalent ofthe max_client_conn setting.
## Section [peers]
The section `[peers]` defines the peers that PgBouncer can forward cancellation
requests to and where those cancellation requests will be routed.
PgBouncer processes can be peered together in a group by defining a `peer_id`
value and a `[peers]` section in the configs of all the PgBouncer processes.
These PgBouncer processes can then forward cancellations requests to the process
that it originated from. This is needed to make cancellations work when
multiple PgBouncer processes (possibly on different servers) are behind the same
TCP load balancer. Cancellation requests are sent over different TCP
connections than the query they are cancelling, so a TCP load balancer might
send the cancellation request connection to a different process than the one
that it was meant for. By peering them these cancellation requests eventually
end up at the right process. A more in-depth explanation is provided in this
[recording of a conference talk][cancel-problem-video].
[cancel-problem-video]: https://www.youtube.com/watch?v=X-nCHcZ6vQU
The section contains key=value lines like
peer_id = connection string
Where the key will be taken as a `peer_id` and the value as a connection string,
consisting of key=value pairs of connection parameters, described below (similar
to libpq, but the actual libpq is not used and the set of available features is
different). Example:
1 = host=host1.example.com
2 = host=/tmp/pgbouncer-2 port=5555
Note 1: For peering to work, the `peer_id` of each PgBouncer process in the group
must be unique within the peered group. And the `[peers]` section should
contain entries for each of those peer ids. An example can be found in the
examples section of these docs. It **is** allowed, but not necessary, for the
`[peers]` section to contain the `peer_id` of the PgBouncer that the config is
for. Such an entry will be ignored, but it is allowed to config management easy.
Because it allows using the exact same `[peers]` section for multiple
configs.
Note 2: Cross-version peering is supported as long as all peers are on the same
side of the v1.21.0 version boundary. In v1.21.0 some breaking changes were
made in how we encode the cancellation tokens that made them incompatible with
the ones created by earlier versions.
### host
Host name or IP address to connect to. Host names are resolved at connection
time, the result is cached per `dns_max_ttl` parameter. If DNS returns several
results, they are used in a round-robin manner. But in general it's not
recommended to use a hostname that resolves to multiple IPs, because then the
cancel request might still be forwarded to the wrong node and it would need to
be forwarded again (which is only allowed up to three times).
If the value begins with `/`, then a Unix socket in the file-system namespace is
used. If the value begins with `@`, then a Unix socket in the abstract
namespace is used.
Examples:
host=localhost
host=127.0.0.1
host=2001:0db8:85a3:0000:0000:8a2e:0370:7334
host=/var/run/pgbouncer-1
### port
Default: 6432
### pool_size
Set the maximum number of cancel requests that can be in flight to the peer at
the same time. It's quite normal for cancel requests to arrive in bursts, e.g.
when the backing Postgres server slow or down. So it's important for
`pool_size` to not be so low that it cannot handle these bursts.
If not set, the `default_pool_size` is used.
## Include directive
The PgBouncer configuration file can contain include directives, which specify
another configuration file to read and process. This allows splitting the
configuration file into physically separate parts. The include directives look
like this:
%include filename
If the file name is not an absolute path, it is taken as relative to the current
working directory.
## Authentication file format
This section describes the format of the file specified by the
`auth_file` setting. It is a text file in the following format:
"username1" "password" ...
"username2" "md5abcdef012342345" ...
"username2" "SCRAM-SHA-256$:$:"
There should be at least 2 fields, surrounded by double quotes. The first
field is the user name and the second is either a plain-text, a MD5-hashed
password, or a SCRAM secret. PgBouncer ignores the rest of the line.
Double quotes in a field value can be escaped by writing two double quotes.
PostgreSQL MD5-hashed password format:
"md5" + md5(password + username)
So user `admin` with password `1234` will have MD5-hashed password
`md545f2603610af569b6155c45067268c6b`.
PostgreSQL SCRAM secret format:
SCRAM-SHA-256$:$:
See the PostgreSQL documentation and RFC 5803 for details on this.
The passwords or secrets stored in the authentication file serve two
purposes. First, they are used to verify the passwords of incoming
client connections, if a password-based authentication method is
configured. Second, they are used as the passwords for outgoing
connections to the backend server, if the backend server requires
password-based authentication (unless the password is specified
directly in the database's connection string).
### Limitations
If the password is stored in plain text, it can be used for any password-based
authentication used in the backend server; plain text, MD5 or SCRAM
(see for details).
MD5-hashed passwords can be used if backend server uses MD5 authentication
(or specific users have MD5-hashed passwords).
SCRAM secrets can
only be used for logging into a server if the client authentication
also uses SCRAM, the PgBouncer database definition does not specify a
user name, and the SCRAM secrets are identical in PgBouncer and the
PostgreSQL server (same salt and iterations, not merely the same
password). This is due to an inherent security property of SCRAM: The
stored SCRAM secret cannot by itself be used for deriving login
credentials.
The authentication file can be written by hand, but it's also useful
to generate it from some other list of users and passwords. See
`./etc/mkauth.py` for a sample script to generate the authentication
file from the `pg_authid` system table. Alternatively, use
`auth_query` instead of `auth_file` to avoid having to maintain a
separate authentication file.
### Note on managed servers
If the backend server is configured to use SCRAM password authentication PgBouncer cannot
successfully authenticate if it does not know either a) user password in plain text or
b) corresponding SCRAM secret.
Some cloud providers (i.e. AWS RDS) prohibit access to PostgreSQL sensitive system tables
for fetching passwords. Even for the most privileged user (i.e. member of rds_superuser) the
`select * from pg_authid`; returns the `ERROR: permission denied for table pg_authid.`
That is a known behaviour
([blog](https://aws.amazon.com/blogs/database/best-practices-for-migrating-postgresql-databases-to-amazon-rds-and-amazon-aurora/)).
Therefore, fetching an existing SCRAM secret once it has been stored in a managed server
is impossible which makes it hard to configure PgBouncer to use the same SCRAM secret.
Nevertheless, SCRAM secret can still be configured and used on both sides using the following trick:
Generate SCRAM secret for arbitrary password with a tool that is capable of printing out the secret.
For example `psql --echo-hidden` and the command `\password` prints out the SCRAM secret
to the console before sending it over to the server.
```
$ psql --echo-hidden
postgres=# \password
Enter new password for user "":
Enter it again:
********* QUERY **********
ALTER USER PASSWORD 'SCRAM-SHA-256$:$:'
**************************
```
Note down the SCRAM secret from the QUERY and set it in PgBouncer's `userlist.txt`.
If you used a tool other than `psql --echo-hidden` then you need to set the SCRAM secret also in the server
(you can use `alter role password ''` for that).
## HBA file format
The location of the HBA file is specified by the setting
`auth_hba_file`. It is only used if `auth_type` is set to `hba`.
The file follows the format of the PostgreSQL `pg_hba.conf` file
(see ).
* Supported record types: `local`, `host`, `hostssl`, `hostnossl`.
* Database field: Supports `all`, `replication`, `sameuser`, `@file`, multiple names. Not supported: `samerole`, `samegroup`.
* User name field: Supports `all`, `@file`, multiple names. Not supported: `+groupname`.
* Address field: Supports `all`, IPv4, IPv6. Not supported: `samehost`, `samenet`, DNS names, domain prefixes.
* Auth-method field: Only methods supported by PgBouncer's `auth_type`
are supported, plus `peer` and `reject`, but except `any` and `pam`, which only work globally.
* User name map (`map=`) parameter is supported when `auth_type` is `cert` or `peer`.
## Ident map file format
The location of the ident map file is specified by the setting
`auth_ident_file`. It is only loaded if `auth_type` is set to `hba`.
The file format is a simplified variation of the PostgreSQL ident map file
(see ).
* Supported lines are only of the form `map-name system-username database-username`.
* There is no support for including file/directory.
* System-username field: Not supported: regular expressions.
* Database-username field: Supports `all` or a single postgres user name. Not supported: `+groupname`, regular expressions.
## Examples
Small example configuration:
[databases]
template1 = host=localhost dbname=template1 auth_user=someuser
[pgbouncer]
pool_mode = session
listen_port = 6432
listen_addr = localhost
auth_type = md5
auth_file = users.txt
logfile = pgbouncer.log
pidfile = pgbouncer.pid
admin_users = someuser
stats_users = stat_collector
Database examples:
[databases]
; foodb over Unix socket
foodb =
; redirect bardb to bazdb on localhost
bardb = host=localhost dbname=bazdb
; access to destination database will go with single user
forcedb = host=localhost port=300 user=baz password=foo client_encoding=UNICODE datestyle=ISO
Example of a secure function for `auth_query`:
CREATE OR REPLACE FUNCTION pgbouncer.user_lookup(in i_username text, out uname text, out phash text)
RETURNS record AS $$
BEGIN
SELECT rolname, CASE WHEN rolvaliduntil < now() THEN NULL ELSE rolpassword END
FROM pg_authid
WHERE rolname=i_username AND rolcanlogin
INTO uname, phash;
RETURN;
END;
$$ LANGUAGE plpgsql
SECURITY DEFINER
-- Set a secure search_path: trusted schema(s), then 'pg_temp'.
SET search_path = pg_catalog, pg_temp;
REVOKE ALL ON FUNCTION pgbouncer.user_lookup(text) FROM public, pgbouncer;
GRANT EXECUTE ON FUNCTION pgbouncer.user_lookup(text) TO pgbouncer;
Example configs for 2 peered PgBouncer processes to create a multi-core
PgBouncer setup using `so_reuseport`. The config for the first process:
[databases]
postgres = host=localhost dbname=postgres
[peers]
1 = host=/tmp/pgbouncer1
2 = host=/tmp/pgbouncer2
[pgbouncer]
listen_addr=127.0.0.1
auth_file=auth_file.conf
so_reuseport=1
unix_socket_dir=/tmp/pgbouncer1
peer_id=1
The config for the second process:
[databases]
postgres = host=localhost dbname=postgres
[peers]
1 = host=/tmp/pgbouncer1
2 = host=/tmp/pgbouncer2
[pgbouncer]
listen_addr=127.0.0.1
auth_file=auth_file.conf
so_reuseport=1
; only unix_socket_dir and peer_id are different
unix_socket_dir=/tmp/pgbouncer2
peer_id=2
## See also
pgbouncer(1) - man page for general usage, console commands
pgbouncer-1.24.1/doc/pgbouncer.5 0000664 0001750 0001750 00000170255 14777762332 013361 0000000 0000000 .\" Automatically generated by Pandoc 2.9.2.1
.\"
.TH "PGBOUNCER.INI" "5" "" "1.24.1" "Databases"
.hy
.SH NAME
.PP
pgbouncer.ini - configuration file for pgbouncer
.SH DESCRIPTION
.PP
The configuration file is in \[lq]ini\[rq] format.
Section names are between \[lq][\[dq] and \[dq]]\[rq].
Lines starting with \[lq];\[rq] or \[lq]#\[rq] are taken as comments and
ignored.
The characters \[lq];\[rq] and \[lq]#\[rq] are not recognized as special
when they appear later in the line.
.SH GENERIC SETTINGS
.SS logfile
.PP
Specifies the log file.
For daemonization (\f[C]-d\f[R]), either this or \f[C]syslog\f[R] need
to be set.
.PP
The log file is kept open, so after rotation, \f[C]kill -HUP\f[R] or on
console \f[C]RELOAD;\f[R] should be done.
On Windows, the service must be stopped and started.
.PP
Note that setting \f[C]logfile\f[R] does not by itself turn off logging
to stderr.
Use the command-line option \f[C]-q\f[R] or \f[C]-d\f[R] for that.
.PP
Default: not set
.SS pidfile
.PP
Specifies the PID file.
Without \f[C]pidfile\f[R] set, daemonization (\f[C]-d\f[R]) is not
allowed.
.PP
Default: not set
.SS listen_addr
.PP
Specifies a list (comma-separated) of addresses where to listen for TCP
connections.
You may also use \f[C]*\f[R] meaning \[lq]listen on all addresses\[rq].
When not set, only Unix socket connections are accepted.
.PP
Addresses can be specified numerically (IPv4/IPv6) or by name.
.PP
Default: not set
.SS listen_port
.PP
Which port to listen on.
Applies to both TCP and Unix sockets.
.PP
Default: 6432
.SS unix_socket_dir
.PP
Specifies the location for Unix sockets.
Applies to both the listening socket and to server connections.
If set to an empty string, Unix sockets are disabled.
A value that starts with \f[C]\[at]\f[R] specifies that a Unix socket in
the abstract namespace should be created (currently supported on Linux
and Windows).
.PP
For online reboot (\f[C]-R\f[R]) to work, a Unix socket needs to be
configured, and it needs to be in the file-system namespace.
.PP
Default: \f[C]/tmp\f[R] (empty on Windows)
.SS unix_socket_mode
.PP
File system mode for Unix socket.
Ignored for sockets in the abstract namespace.
Not supported on Windows.
.PP
Default: 0777
.SS unix_socket_group
.PP
Group name to use for Unix socket.
Ignored for sockets in the abstract namespace.
Not supported on Windows.
.PP
Default: not set
.SS user
.PP
If set, specifies the Unix user to change to after startup.
Works only if PgBouncer is started as root or if it\[cq]s already
running as the given user.
Not supported on Windows.
.PP
Default: not set
.SS pool_mode
.PP
Specifies when a server connection can be reused by other clients.
.TP
session
Server is released back to pool after client disconnects.
Default.
.TP
transaction
Server is released back to pool after transaction finishes.
.TP
statement
Server is released back to pool after query finishes.
Transactions spanning multiple statements are disallowed in this mode.
.SS max_client_conn
.PP
Maximum number of client connections allowed.
.PP
When this setting is increased, then the file descriptor limits in the
operating system might also have to be increased.
Note that the number of file descriptors potentially used is more than
\f[C]max_client_conn\f[R].
If each user connects under its own user name to the server, the
theoretical maximum used is:
.IP
.nf
\f[C]
max_client_conn + (max pool_size * total databases * total users)
\f[R]
.fi
.PP
If a database user is specified in the connection string (all users
connect under the same user name), the theoretical maximum is:
.IP
.nf
\f[C]
max_client_conn + (max pool_size * total databases)
\f[R]
.fi
.PP
The theoretical maximum should never be reached, unless somebody
deliberately crafts a special load for it.
Still, it means you should set the number of file descriptors to a
safely high number.
.PP
Search for \f[C]ulimit\f[R] in your favorite shell man page.
Note: \f[C]ulimit\f[R] does not apply in a Windows environment.
.PP
Default: 100
.SS default_pool_size
.PP
How many server connections to allow per user/database pair.
Can be overridden in the per-database configuration.
.PP
Default: 20
.SS min_pool_size
.PP
Add more server connections to pool if below this number.
Improves behavior when the normal load suddenly comes back after a
period of total inactivity.
The value is effectively capped at the pool size.
.PP
Only enforced for pools where at least one of the following is true:
.IP \[bu] 2
the entry in the \f[C][database]\f[R] section for the pool has a value
set for the \f[C]user\f[R] key (aka forced user)
.IP \[bu] 2
there is at least one client connected to the pool
.PP
Default: 0 (disabled)
.SS reserve_pool_size
.PP
How many additional connections to allow to a pool (see
\f[C]reserve_pool_timeout\f[R]).
0 disables.
.PP
Default: 0 (disabled)
.SS reserve_pool_timeout
.PP
If a client has not been serviced in this time, use additional
connections from the reserve pool.
0 disables.
[seconds]
.PP
Default: 5.0
.SS max_db_connections
.PP
Do not allow more than this many server connections per database
(regardless of user).
This considers the PgBouncer database that the client has connected to,
not the PostgreSQL database of the outgoing connection.
.PP
This can also be set per database in the \f[C][databases]\f[R] section.
.PP
Note that when you hit the limit, closing a client connection to one
pool will not immediately allow a server connection to be established
for another pool, because the server connection for the first pool is
still open.
Once the server connection closes (due to idle timeout), a new server
connection will immediately be opened for the waiting pool.
.PP
Default: 0 (unlimited)
.SS max_db_client_connections
.PP
Do not allow more than this many client connections to PgBouncer per
database (regardless of user).
This considers the PgBouncer database that the client has connected to,
not the PostgreSQL database of the outgoing connection.
.PP
This should be set at a number greater than or equal to
max_db_connections.
The difference between the two numbers can be thought of as how many
connections to a given database can be in the queue while waiting for
active connections to finish.
.PP
This can also be set per database in the \f[C][databases]\f[R] section.
.PP
Default: 0 (unlimited)
.SS max_user_connections
.PP
Do not allow more than this many server connections per user (regardless
of database).
This considers the PgBouncer user that is associated with a pool, which
is either the user specified for the server connection or in absence of
that the user the client has connected as.
.PP
This can also be set per user in the \f[C][users]\f[R] section.
.PP
Note that when you hit the limit, closing a client connection to one
pool will not immediately allow a server connection to be established
for another pool, because the server connection for the first pool is
still open.
Once the server connection closes (due to idle timeout), a new server
connection will immediately be opened for the waiting pool.
.PP
Default: 0 (unlimited)
.SS max_user_client_connections
.PP
Do not allow more than this many client connections per user (regardless
of database).
This value should be set to a number higher than max_user_connections.
This difference between max_user_connections and
max_user_client_connections can be conceptualized as the number the max
size of the queue for the user.
.PP
This can also be set per user in the \f[C][users]\f[R] section.
.PP
Default: 0 (unlimited)
.SS server_round_robin
.PP
By default, PgBouncer reuses server connections in LIFO (last-in,
first-out) manner, so that few connections get the most load.
This gives best performance if you have a single server serving a
database.
But if there is a round-robin system behind a database address (TCP,
DNS, or host list), then it is better if PgBouncer also uses connections
in that manner, thus achieving uniform load.
.PP
Default: 0
.SS track_extra_parameters
.PP
By default, PgBouncer tracks \f[C]client_encoding\f[R],
\f[C]datestyle\f[R], \f[C]timezone\f[R],
\f[C]standard_conforming_strings\f[R] and \f[C]application_name\f[R]
parameters per client.
To allow other parameters to be tracked, they can be specified here, so
that PgBouncer knows that they should be maintained in the client
variable cache and restored in the server whenever the client becomes
active.
.PP
If you need to specify multiple values, use a comma-separated list (e.g.
\f[C]default_transaction_read_only, IntervalStyle\f[R])
.PP
Note: Most parameters cannot be tracked this way.
The only parameters that can be tracked are ones that Postgres reports
to the client.
Postgres has an official list of parameters that it reports to the
client (https://www.postgresql.org/docs/15/protocol-flow.html#PROTOCOL-ASYNC).
Postgres extensions can change this list though, they can add parameters
themselves that they also report, and they can start reporting already
existing parameters that Postgres does not report.
Notably Citus 12.0+ causes Postgres to also report
\f[C]search_path\f[R].
.PP
The Postgres protocol allows specifying parameters settings, both
directly as a parameter in the startup packet, or inside the
\f[C]options\f[R] startup
packet (https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNECT-OPTIONS).
Parameters specified using both of these methods are supported by
\f[C]track_extra_parameters\f[R].
However, it\[cq]s not possible to include \f[C]options\f[R] itself in
\f[C]track_extra_parameters\f[R], only the parameters contained in
\f[C]options\f[R].
.PP
Default: IntervalStyle
.SS ignore_startup_parameters
.PP
By default, PgBouncer allows only parameters it can keep track of in
startup packets: \f[C]client_encoding\f[R], \f[C]datestyle\f[R],
\f[C]timezone\f[R] and \f[C]standard_conforming_strings\f[R].
All others parameters will raise an error.
To allow others parameters, they can be specified here, so that
PgBouncer knows that they are handled by the admin and it can ignore
them.
.PP
If you need to specify multiple values, use a comma-separated list (e.g.
\f[C]options,extra_float_digits\f[R])
.PP
The Postgres protocol allows specifying parameters settings, both
directly as a parameter in the startup packet, or inside the
\f[C]options\f[R] startup
packet (https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNECT-OPTIONS).
Parameters specified using both of these methods are supported by
\f[C]ignore_startup_parameters\f[R].
It\[cq]s even possible to include \f[C]options\f[R] itself in
\f[C]track_extra_parameters\f[R], which results in any unknown
parameters contained inside \f[C]options\f[R] to be ignored.
.PP
Default: empty
.SS peer_id
.PP
The peer id used to identify this PgBouncer process in a group of
PgBouncer processes that are peered together.
The \f[C]peer_id\f[R] value should be unique within a group of peered
PgBouncer processes.
When set to 0 pgbouncer peering is disabled.
See the docs for the \f[C][peers]\f[R] section for more information.
The maximum value that can be used for the \f[C]peer_id\f[R] is 16383.
.PP
Default: 0
.SS disable_pqexec
.PP
Disable the Simple Query protocol (PQexec).
Unlike the Extended Query protocol, Simple Query allows multiple queries
in one packet, which allows some classes of SQL-injection attacks.
Disabling it can improve security.
Obviously, this means only clients that exclusively use the Extended
Query protocol will stay working.
.PP
Default: 0
.SS application_name_add_host
.PP
Add the client host address and port to the application name setting set
on connection start.
This helps in identifying the source of bad queries etc.
This logic applies only at the start of a connection.
If \f[C]application_name\f[R] is later changed with \f[C]SET\f[R],
PgBouncer does not change it again.
.PP
Default: 0
.SS conffile
.PP
Show location of current config file.
Changing it will make PgBouncer use another config file for next
\f[C]RELOAD\f[R] / \f[C]SIGHUP\f[R].
.PP
Default: file from command line
.SS service_name
.PP
Used on win32 service registration.
.PP
Default: \f[C]pgbouncer\f[R]
.SS job_name
.PP
Alias for \f[C]service_name\f[R].
.SS stats_period
.PP
Sets how often the averages shown in various \f[C]SHOW\f[R] commands are
updated and how often aggregated statistics are written to the log (but
see \f[C]log_stats\f[R]).
[seconds]
.PP
Default: 60
.SS max_prepared_statements
.PP
When this is set to a non-zero value PgBouncer tracks protocol-level
named prepared statements related commands sent by the client in
transaction and statement pooling mode.
PgBouncer makes sure that any statement prepared by a client is
available on the backing server connection.
Even when the statement was originally prepared on another server
connection.
.PP
PgBouncer internally examines all the queries that are sent by clients
as a prepared statement, and gives each unique query string an internal
name with the format \f[C]PGBOUNCER_{unique_id}\f[R].
If the same query string is prepared multiple times (possibly by
different clients), then these queries share the same internal name.
PgBouncer only prepares the statement on the actual PostgreSQL server
using the internal name (so not the name provided by the client).
PgBouncer keeps track of the name that the client gave to each prepared
statement.
It then rewrites each command that uses a prepared statement to by
replacing the client side name with the the internal name (e.g.
replacing \f[C]my_prepared_statement\f[R] with \f[C]PGBOUNCER_123\f[R])
before forwarding that command to the server.
More importantly, if the prepared statement that the client wants to
execute is not yet prepared on the server (e.g.\ because a different
server is now assigned to the client than when the client prepared the
statement), then PgBouncer transparently prepares the statement before
executing it.
.PP
Note: This tracking and rewriting of prepared statement commands does
not work for SQL-level prepared statement commands, so
\f[C]PREPARE\f[R], \f[C]EXECUTE\f[R] and \f[C]DEALLOCATE\f[R] are
forwarded straight to Postgres.
The exception to this rule are the \f[C]DEALLOCATE ALL\f[R] and
\f[C]DISCARD ALL\f[R] commands, these do work as expected and will clear
the prepared statements that PgBouncer tracked for the client that sends
this command.
.PP
The actual value of this setting controls the number of prepared
statements kept active in an LRU cache on a single server connection.
When the setting is set to 0 prepared statement support for transaction
and statement pooling is disabled.
To get the best performance you should try to make sure that this
setting is larger than the amount of commonly used prepared statements
in your application.
Keep in mind that the higher this value, the larger the memory footprint
of each PgBouncer connection will be on your PostgreSQL server, because
it will keep more queries prepared on those connections.
It also increases the memory footprint of PgBouncer itself, because it
now needs to keep track of query strings.
.PP
The impact on PgBouncer memory usage is not that big though: - Each
unique query is stored once in a global query cache.
- Each client connection keeps a buffer that it uses to rewrite packets.
This is, at most, 4 times the size of \f[C]pkt_buf\f[R].
This limit is often not reached though, it only happens when the queries
in your prepared statements are between 2 and 4 times the size of
\f[C]pkt_buf\f[R].
.PP
So if you consider the following as an example scenario: - There are
1000 active clients - The clients prepare 200 unique queries - The
average size of a query is 5kB - \f[C]pkt_buf\f[R] parameter is set to
the default of 4096 (4kB)
.PP
Then, PgBouncer needs at most the following amount of memory to handle
these prepared statements:
.PP
200 x 5kB + 1000 x 4 x 4kB = \[ti]17MB of memory.
.PP
Tracking prepared statements does not only come with a memory cost, but
also with increased CPU usage, because PgBouncer needs to inspect and
rewrite the queries.
Multiple PgBouncer instances can listen on the same port to use more
than one core for processing, see the documentation for the
\f[C]so_reuseport\f[R] option for details.
.PP
But of course there are also performance benefits to prepared
statements.
Just as when connecting to PostgreSQL directly, by preparing a query
that is executed many times, it reduces the total amount of parsing and
planning that needs to be done.
The way that PgBouncer tracks prepared statements is especially
beneficial to performance when multiple clients prepare the same
queries.
Because client connections automatically reuse a prepared statement on a
server connection, even if it was prepared by another client.
As an example, if you have a \f[C]pool_size\f[R] of 20 and you have 100
clients that all prepare the exact same query, then the query is
prepared (and thus parsed) only 20 times on the PostgreSQL server.
.PP
The reuse of prepared statements has one downside.
If the return or argument types of a prepared statement changes across
executions then PostgreSQL currently throws an error such as:
.IP
.nf
\f[C]
ERROR: cached plan must not change result type
\f[R]
.fi
.PP
You can avoid such errors by not having multiple clients that use the
exact same query string in a prepared statement, but expecting different
argument or result types.
One of the most common ways of running into this issue is during a DDL
migration where you add a new column or change a column type on an
existing table.
In those cases you can run \f[C]RECONNECT\f[R] on the PgBouncer admin
console after doing the migration to force a re-prepare of the query and
make the error go away.
.PP
Default: 200
.SH AUTHENTICATION SETTINGS
.PP
PgBouncer handles its own client authentication and has its own database
of users.
These settings control this.
.SS auth_type
.PP
How to authenticate users.
.TP
cert
Client must connect over TLS connection with a valid client certificate.
The user name is then taken from the CommonName field from the
certificate.
.TP
md5
Use MD5-based password check.
This is the default authentication method.
\f[C]auth_file\f[R] may contain both MD5-encrypted and plain-text
passwords.
If \f[C]md5\f[R] is configured and a user has a SCRAM secret, then SCRAM
authentication is used automatically instead.
.TP
scram-sha-256
Use password check with SCRAM-SHA-256.
\f[C]auth_file\f[R] has to contain SCRAM secrets or plain-text
passwords.
.TP
plain
The clear-text password is sent over the wire.
Deprecated.
.TP
trust
No authentication is done.
The user name must still exist in \f[C]auth_file\f[R].
.TP
any
Like the \f[C]trust\f[R] method, but the user name given is ignored.
Requires that all databases are configured to log in as a specific user.
Additionally, the console database allows any user to log in as admin.
.TP
hba
The actual authentication type is loaded from \f[C]auth_hba_file\f[R].
This allows different authentication methods for different access paths,
for example: connections over Unix socket use the \f[C]peer\f[R] auth
method, connections over TCP must use TLS.
.TP
pam
PAM is used to authenticate users, \f[C]auth_file\f[R] is ignored.
This method is not compatible with databases using the
\f[C]auth_user\f[R] option.
The service name reported to PAM is \[lq]pgbouncer\[rq].
\f[C]pam\f[R] is not supported in the HBA configuration file.
.SS auth_hba_file
.PP
HBA configuration file to use when \f[C]auth_type\f[R] is \f[C]hba\f[R].
See section HBA file format below about details.
.PP
Default: not set
.SS auth_ident_file
.PP
Identity map file to use when \f[C]auth_type\f[R] is \f[C]hba\f[R] and a
user map will be defined.
See section Ident map file format below about details.
.PP
Default: not set
.SS auth_file
.PP
The name of the file to load user names and passwords from.
See section Authentication file format below about details.
.PP
Most authentication types (see above) require that either
\f[C]auth_file\f[R] or \f[C]auth_user\f[R] be set; otherwise there would
be no users defined.
.PP
Default: not set
.SS auth_user
.PP
If \f[C]auth_user\f[R] is set, then any user not specified in
\f[C]auth_file\f[R] will be queried through the \f[C]auth_query\f[R]
query from \f[C]pg_authid\f[R] in the database, using
\f[C]auth_user\f[R].
The password of \f[C]auth_user\f[R] will be taken from
\f[C]auth_file\f[R].
(If the \f[C]auth_user\f[R] does not require a password then it does not
need to be defined in \f[C]auth_file\f[R].)
.PP
Direct access to \f[C]pg_authid\f[R] requires admin rights.
It\[cq]s preferable to use a non-superuser that calls a SECURITY DEFINER
function instead.
.PP
Default: not set
.SS auth_query
.PP
Query to load user\[cq]s password from database.
.PP
Direct access to \f[C]pg_authid\f[R] requires admin rights.
It\[cq]s preferable to use a non-superuser that calls a SECURITY DEFINER
function instead.
.PP
Note that the query is run inside the target database.
So if a function is used, it needs to be installed into each database.
.PP
Default:
\f[C]SELECT rolname, CASE WHEN rolvaliduntil < now() THEN NULL ELSE rolpassword END FROM pg_authid WHERE rolname=$1 AND rolcanlogin\f[R]
.SS auth_dbname
.PP
Database name in the \f[C][database]\f[R] section to be used for
authentication purposes.
This option can be either global or overridden in the connection string
if this parameter is specified.
.SH LOG SETTINGS
.SS syslog
.PP
Toggles syslog on/off.
On Windows, the event log is used instead.
.PP
Default: 0
.SS syslog_ident
.PP
Under what name to send logs to syslog.
.PP
Default: \f[C]pgbouncer\f[R] (program name)
.SS syslog_facility
.PP
Under what facility to send logs to syslog.
Possibilities: \f[C]auth\f[R], \f[C]authpriv\f[R], \f[C]daemon\f[R],
\f[C]user\f[R], \f[C]local0-7\f[R].
.PP
Default: \f[C]daemon\f[R]
.SS log_connections
.PP
Log successful logins.
.PP
Default: 1
.SS log_disconnections
.PP
Log disconnections with reasons.
.PP
Default: 1
.SS log_pooler_errors
.PP
Log error messages the pooler sends to clients.
.PP
Default: 1
.SS log_stats
.PP
Write aggregated statistics into the log, every \f[C]stats_period\f[R].
This can be disabled if external monitoring tools are used to grab the
same data from \f[C]SHOW\f[R] commands.
.PP
Default: 1
.SS verbose
.PP
Increase verbosity.
Mirrors the \[lq]-v\[rq] switch on the command line.
For example, using \[lq]-v -v\[rq] on the command line is the same as
\f[C]verbose=2\f[R].
3 is the highest currently-supported verbosity.
.PP
Default: 0
.SH CONSOLE ACCESS CONTROL
.SS admin_users
.PP
Comma-separated list of database users that are allowed to connect and
run all commands on the console.
Ignored when \f[C]auth_type\f[R] is \f[C]any\f[R], in which case any
user name is allowed in as admin.
.PP
Default: empty
.SS stats_users
.PP
Comma-separated list of database users that are allowed to connect and
run read-only queries on the console.
That means all \f[C]SHOW\f[R] commands except \f[C]SHOW FDS\f[R].
.PP
Default: empty
.SH CONNECTION SANITY CHECKS, TIMEOUTS
.SS server_reset_query
.PP
Query sent to server on connection release, before making it available
to other clients.
At that moment no transaction is in progress, so the value should not
include \f[C]ABORT\f[R] or \f[C]ROLLBACK\f[R].
.PP
The query is supposed to clean any changes made to the database session
so that the next client gets the connection in a well-defined state.
The default is \f[C]DISCARD ALL\f[R], which cleans everything, but that
leaves the next client no pre-cached state.
It can be made lighter, e.g.\ \f[C]DEALLOCATE ALL\f[R] to just drop
prepared statements, if the application does not break when some state
is kept around.
.PP
When transaction pooling is used, the \f[C]server_reset_query\f[R] is
not used, because in that mode, clients must not use any session-based
features, since each transaction ends up in a different connection and
thus gets a different session state.
.PP
Default: \f[C]DISCARD ALL\f[R]
.SS server_reset_query_always
.PP
Whether \f[C]server_reset_query\f[R] should be run in all pooling modes.
When this setting is off (default), the \f[C]server_reset_query\f[R]
will be run only in pools that are in sessions-pooling mode.
Connections in transaction-pooling mode should not have any need for a
reset query.
.PP
This setting is for working around broken setups that run applications
that use session features over a transaction-pooled PgBouncer.
It changes non-deterministic breakage to deterministic breakage: Clients
always lose their state after each transaction.
.PP
Default: 0
.SS server_check_delay
.PP
How long to keep released connections available for immediate re-use,
without running \f[C]server_check_query\f[R] on it.
If 0 then the check is always run.
.PP
Default: 30.0
.SS server_check_query
.PP
Simple do-nothing query to check if the server connection is alive.
.PP
If an empty string, then sanity checking is disabled.
.PP
Default: \f[C]select 1\f[R]
.SS server_fast_close
.PP
Disconnect a server in session pooling mode immediately or after the end
of the current transaction if it is in \[lq]close_needed\[rq] mode (set
by \f[C]RECONNECT\f[R], \f[C]RELOAD\f[R] that changes connection
settings, or DNS change), rather than waiting for the session end.
In statement or transaction pooling mode, this has no effect since that
is the default behavior there.
.PP
If because of this setting a server connection is closed before the end
of the client session, the client connection is also closed.
This ensures that the client notices that the session has been
interrupted.
.PP
This setting makes connection configuration changes take effect sooner
if session pooling and long-running sessions are used.
The downside is that client sessions are liable to be interrupted by a
configuration change, so client applications will need logic to
reconnect and reestablish session state.
But note that no transactions will be lost, because running transactions
are not interrupted, only idle sessions.
.PP
Default: 0
.SS server_lifetime
.PP
The pooler will close an unused (not currently linked to any client
connection) server connection that has been connected longer than this.
Setting it to 0 means the connection is to be used only once, then
closed.
[seconds]
.PP
This can also be set per database in the \f[C][databases]\f[R] section.
.PP
Default: 3600.0
.SS server_idle_timeout
.PP
If a server connection has been idle more than this many seconds it will
be closed.
If 0 then this timeout is disabled.
[seconds]
.PP
Default: 600.0
.SS server_connect_timeout
.PP
If connection and login don\[cq]t finish in this amount of time, the
connection will be closed.
[seconds]
.PP
Default: 15.0
.SS server_login_retry
.PP
If login to the server failed, because of failure to connect or from
authentication, the pooler waits this much before retrying to connect.
During the waiting interval, new clients trying to connect to the
failing server will get an error immediately without another connection
attempt.
[seconds]
.PP
The purpose of this behavior is that clients don\[cq]t unnecessarily
queue up waiting for a server connection to become available if the
server is not working.
However, it also means that if a server is momentarily failing, for
example during a restart or if the configuration was erroneous, then it
will take at least this long until the pooler will consider connecting
to it again.
Planned events such as restarts should normally be managed using the
\f[C]PAUSE\f[R] command to avoid this.
.PP
Default: 15.0
.SS client_login_timeout
.PP
If a client connects but does not manage to log in in this amount of
time, it will be disconnected.
Mainly needed to avoid dead connections stalling \f[C]SUSPEND\f[R] and
thus online restart.
[seconds]
.PP
Default: 60.0
.SS autodb_idle_timeout
.PP
If the automatically created (via \[dq]*\[dq]) database pools have been
unused this many seconds, they are freed.
The negative aspect of that is that their statistics are also forgotten.
[seconds]
.PP
Default: 3600.0
.SS dns_max_ttl
.PP
How long DNS lookups can be cached.
The actual DNS TTL is ignored.
[seconds]
.PP
Default: 15.0
.SS dns_nxdomain_ttl
.PP
How long DNS errors and NXDOMAIN DNS lookups can be cached.
[seconds]
.PP
Default: 15.0
.SS dns_zone_check_period
.PP
Period to check if a zone serial has changed.
.PP
PgBouncer can collect DNS zones from host names (everything after first
dot) and then periodically check if the zone serial changes.
If it notices changes, all host names under that zone are looked up
again.
If any host IP changes, its connections are invalidated.
.PP
Works only with c-ares backend (\f[C]configure\f[R] option
\f[C]--with-cares\f[R]).
.PP
Default: 0.0 (disabled)
.SS resolv_conf
.PP
The location of a custom \f[C]resolv.conf\f[R] file.
This is to allow specifying custom DNS servers and perhaps other name
resolution options, independent of the global operating system
configuration.
.PP
Requires evdns (>= 2.0.3) or c-ares (>= 1.15.0) backend.
.PP
The parsing of the file is done by the DNS backend library, not
PgBouncer, so see the library\[cq]s documentation for details on allowed
syntax and directives.
.PP
Default: empty (use operating system defaults)
.SH TLS SETTINGS
.PP
If the contents of any of the cert or key files are changed without
changing the actual setting filename in the config, the new file
contents will be used for new connections after a RELOAD.
Existing connections won\[cq]t be closed though.
If it\[cq]s necessary for security reasons that all connections start
using the new files ASAP, it\[cq]s advised to run RECONNECT after the
RELOAD.
.PP
Changing any TLS settings will trigger a RECONNECT automatically for
security reasons.
.SS client_tls_sslmode
.PP
TLS mode to use for connections from clients.
TLS connections are disabled by default.
When enabled, \f[C]client_tls_key_file\f[R] and
\f[C]client_tls_cert_file\f[R] must be also configured to set up the key
and certificate PgBouncer uses to accept client connections.
The most common certificate file format usable by PgBouncer is pem.
.TP
disable
Plain TCP.
If client requests TLS, it\[cq]s ignored.
Default.
.TP
allow
If client requests TLS, it is used.
If not, plain TCP is used.
If the client presents a client certificate, it is not validated.
.TP
prefer
Same as \f[C]allow\f[R].
.TP
require
Client must use TLS.
If not, the client connection is rejected.
If the client presents a client certificate, it is not validated.
.TP
verify-ca
Client must use TLS with valid client certificate.
.TP
verify-full
Same as \f[C]verify-ca\f[R].
.SS client_tls_key_file
.PP
Private key for PgBouncer to accept client connections.
.PP
Default: not set
.SS client_tls_cert_file
.PP
Certificate for private key.
Clients can validate it.
.PP
Default: not set
.SS client_tls_ca_file
.PP
Root certificate file to validate client certificates.
.PP
Default: not set
.SS client_tls_protocols
.PP
Which TLS protocol versions are allowed.
Allowed values: \f[C]tlsv1.0\f[R], \f[C]tlsv1.1\f[R], \f[C]tlsv1.2\f[R],
\f[C]tlsv1.3\f[R].
Shortcuts: \f[C]all\f[R] (tlsv1.0,tlsv1.1,tlsv1.2,tlsv1.3),
\f[C]secure\f[R] (tlsv1.2,tlsv1.3).
.PP
Default: \f[C]secure\f[R]
.SS client_tls_ciphers
.PP
Allowed TLS ciphers, in OpenSSL syntax.
Shortcuts:
.IP \[bu] 2
\f[C]default\f[R]/\f[C]secure\f[R]/\f[C]fast\f[R]/\f[C]normal\f[R]
(these all use system wide OpenSSL defaults)
.IP \[bu] 2
\f[C]all\f[R] (enables all ciphers, not recommended)
.PP
Only connections using TLS version 1.2 and lower are affected.
There is currently no setting that controls the cipher choices used by
TLS version 1.3 connections.
.PP
Default: \f[C]default\f[R]
.SS client_tls_ecdhcurve
.PP
Elliptic Curve name to use for ECDH key exchanges.
.PP
Allowed values: \f[C]none\f[R] (DH is disabled), \f[C]auto\f[R] (256-bit
ECDH), curve name
.PP
Default: \f[C]auto\f[R]
.SS client_tls_dheparams
.PP
DHE key exchange type.
.PP
Allowed values: \f[C]none\f[R] (DH is disabled), \f[C]auto\f[R]
(2048-bit DH), \f[C]legacy\f[R] (1024-bit DH)
.PP
Default: \f[C]auto\f[R]
.SS server_tls_sslmode
.PP
TLS mode to use for connections to PostgreSQL servers.
The default mode is \f[C]prefer\f[R].
.TP
disable
Plain TCP.
TLS is not even requested from the server.
.TP
allow
FIXME: if server rejects plain, try TLS?
.TP
prefer
TLS connection is always requested first from PostgreSQL.
If refused, the connection will be established over plain TCP.
Server certificate is not validated.
Default
.TP
require
Connection must go over TLS.
If server rejects it, plain TCP is not attempted.
Server certificate is not validated.
.TP
verify-ca
Connection must go over TLS and server certificate must be valid
according to \f[C]server_tls_ca_file\f[R].
Server host name is not checked against certificate.
.TP
verify-full
Connection must go over TLS and server certificate must be valid
according to \f[C]server_tls_ca_file\f[R].
Server host name must match certificate information.
.SS server_tls_ca_file
.PP
Root certificate file to validate PostgreSQL server certificates.
.PP
Default: not set
.SS server_tls_key_file
.PP
Private key for PgBouncer to authenticate against PostgreSQL server.
.PP
Default: not set
.SS server_tls_cert_file
.PP
Certificate for private key.
PostgreSQL server can validate it.
.PP
Default: not set
.SS server_tls_protocols
.PP
Which TLS protocol versions are allowed.
Allowed values: \f[C]tlsv1.0\f[R], \f[C]tlsv1.1\f[R], \f[C]tlsv1.2\f[R],
\f[C]tlsv1.3\f[R].
Shortcuts: \f[C]all\f[R] (tlsv1.0,tlsv1.1,tlsv1.2,tlsv1.3),
\f[C]secure\f[R] (tlsv1.2,tlsv1.3), \f[C]legacy\f[R] (all).
.PP
Default: \f[C]secure\f[R]
.SS server_tls_ciphers
.PP
Allowed TLS ciphers, in OpenSSL syntax.
Shortcuts:
.IP \[bu] 2
\f[C]default\f[R]/\f[C]secure\f[R]/\f[C]fast\f[R]/\f[C]normal\f[R]
(these all use system wide OpenSSL defaults)
.IP \[bu] 2
\f[C]all\f[R] (enables all ciphers, not recommended)
.PP
Only connections using TLS version 1.2 and lower are affected.
There is currently no setting that controls the cipher choices used by
TLS version 1.3 connections.
.PP
Default: \f[C]default\f[R]
.SH DANGEROUS TIMEOUTS
.PP
Setting the following timeouts can cause unexpected errors.
.SS query_timeout
.PP
Queries running longer than that are canceled.
This should be used only with a slightly smaller server-side
\f[C]statement_timeout\f[R], to apply only for network problems.
[seconds]
.PP
Default: 0.0 (disabled)
.SS query_wait_timeout
.PP
Maximum time queries are allowed to spend waiting for execution.
If the query is not assigned to a server during that time, the client is
disconnected.
0 disables.
If this is disabled, clients will be queued indefinitely.
[seconds]
.PP
This setting is used to prevent unresponsive servers from grabbing up
connections.
It also helps when the server is down or rejects connections for any
reason.
.PP
Default: 120.0
.SS cancel_wait_timeout
.PP
Maximum time cancellation requests are allowed to spend waiting for
execution.
If the cancel request is not assigned to a server during that time, the
client is disconnected.
0 disables.
If this is disabled, cancel requests will be queued indefinitely.
[seconds]
.PP
This setting is used to prevent a client locking up when a cancel cannot
be forwarded due to the server being down.
.PP
Default: 10.0
.SS client_idle_timeout
.PP
Client connections idling longer than this many seconds are closed.
This should be larger than the client-side connection lifetime settings,
and only used for network problems.
[seconds]
.PP
Default: 0.0 (disabled)
.SS idle_transaction_timeout
.PP
If a client has been in \[lq]idle in transaction\[rq] state longer, it
will be disconnected.
[seconds]
.PP
Default: 0.0 (disabled)
.SS suspend_timeout
.PP
How long to wait for buffer flush during \f[C]SUSPEND\f[R] or reboot
(\f[C]-R\f[R]).
A connection is dropped if the flush does not succeed.
[seconds]
.PP
Default: 10
.SH LOW-LEVEL NETWORK SETTINGS
.SS pkt_buf
.PP
Internal buffer size for packets.
Affects size of TCP packets sent and general memory usage.
Actual libpq packets can be larger than this, so no need to set it
large.
.PP
Default: 4096
.SS max_packet_size
.PP
Maximum size for PostgreSQL packets that PgBouncer allows through.
One packet is either one query or one result set row.
The full result set can be larger.
.PP
Default: 2147483647
.SS listen_backlog
.PP
Backlog argument for listen(2).
Determines how many new unanswered connection attempts are kept in the
queue.
When the queue is full, further new connections are dropped.
.PP
Default: 128
.SS sbuf_loopcnt
.PP
How many times to process data on one connection, before proceeding.
Without this limit, one connection with a big result set can stall
PgBouncer for a long time.
One loop processes one \f[C]pkt_buf\f[R] amount of data.
0 means no limit.
.PP
Default: 5
.SS so_reuseport
.PP
Specifies whether to set the socket option \f[C]SO_REUSEPORT\f[R] on TCP
listening sockets.
On some operating systems, this allows running multiple PgBouncer
instances on the same host listening on the same port and having the
kernel distribute the connections automatically.
This option is a way to get PgBouncer to use more CPU cores.
(PgBouncer is single-threaded and uses one CPU core per instance.)
.PP
The behavior in detail depends on the operating system kernel.
As of this writing, this setting has the desired effect on (sufficiently
recent versions of) Linux, DragonFlyBSD, and FreeBSD.
(On FreeBSD, it applies the socket option \f[C]SO_REUSEPORT_LB\f[R]
instead.) Some other operating systems support the socket option but it
won\[cq]t have the desired effect: It will allow multiple processes to
bind to the same port but only one of them will get the connections.
See your operating system\[cq]s setsockopt() documentation for details.
.PP
On systems that don\[cq]t support the socket option at all, turning this
setting on will result in an error.
.PP
Each PgBouncer instance on the same host needs different settings for at
least \f[C]unix_socket_dir\f[R] and \f[C]pidfile\f[R], as well as
\f[C]logfile\f[R] if that is used.
Also note that if you make use of this option, you can no longer connect
to a specific PgBouncer instance via TCP/IP, which might have
implications for monitoring and metrics collection.
.PP
To make sure query cancellations keep working, you should set up
PgBouncer peering between the different PgBouncer processes.
For details look at docs for the \f[C]peer_id\f[R] configuration option
and the \f[C]peers\f[R] configuration section.
There\[cq]s also an example that uses peering and so_reuseport in the
example section of these docs.
.PP
Default: 0
.SS tcp_defer_accept
.PP
Sets the \f[C]TCP_DEFER_ACCEPT\f[R] socket option; see
\f[C]man 7 tcp\f[R] for details.
(This is a Boolean option: 1 means enabled.
The actual value set if enabled is currently hardcoded to 45 seconds.)
.PP
This is currently only supported on Linux.
.PP
Default: 1 on Linux, otherwise 0
.SS tcp_socket_buffer
.PP
Default: not set
.SS tcp_keepalive
.PP
Turns on basic keepalive with OS defaults.
.PP
On Linux, the system defaults are tcp_keepidle=7200, tcp_keepintvl=75,
tcp_keepcnt=9.
They are probably similar on other operating systems.
.PP
Default: 1
.SS tcp_keepcnt
.PP
Default: not set
.SS tcp_keepidle
.PP
Default: not set
.SS tcp_keepintvl
.PP
Default: not set
.SS tcp_user_timeout
.PP
Sets the \f[C]TCP_USER_TIMEOUT\f[R] socket option.
This specifies the maximum amount of time in milliseconds that
transmitted data may remain unacknowledged before the TCP connection is
forcibly closed.
If set to 0, then operating system\[cq]s default is used.
.PP
This is currently only supported on Linux.
.PP
Default: 0
.SH SECTION [DATABASES]
.PP
The section \f[C][databases]\f[R] defines the names of the databases
that clients of PgBouncer can connect to and specifies where those
connections will be routed.
The section contains key=value lines like
.IP
.nf
\f[C]
dbname = connection string
\f[R]
.fi
.PP
where the key will be taken as a database name and the value as a
connection string, consisting of key=value pairs of connection
parameters, described below (similar to libpq, but the actual libpq is
not used and the set of available features is different).
Example:
.IP
.nf
\f[C]
foodb = host=host1.example.com port=5432
bardb = host=localhost dbname=bazdb
\f[R]
.fi
.PP
The database name can contain characters \f[C]_0-9A-Za-z\f[R] without
quoting.
Names that contain other characters need to be quoted with standard SQL
identifier quoting: double quotes, with \[dq]\[dq] for a single instance
of a double quote.
.PP
The database name \[lq]pgbouncer\[rq] is reserved for the admin console
and cannot be used as a key here.
.PP
\[dq]*\[dq] acts as a fallback database: If the exact name does not
exist, its value is taken as connection string for the requested
database.
For example, if there is an entry (and no other overriding entries)
.IP
.nf
\f[C]
* = host=foo
\f[R]
.fi
.PP
then a connection to PgBouncer specifying a database \[lq]bar\[rq] will
effectively behave as if an entry
.IP
.nf
\f[C]
bar = host=foo dbname=bar
\f[R]
.fi
.PP
exists (taking advantage of the default for \f[C]dbname\f[R] being the
client-side database name; see below).
.PP
Such automatically created database entries are cleaned up if they stay
idle longer than the time specified by the \f[C]autodb_idle_timeout\f[R]
parameter.
.SS dbname
.PP
Destination database name.
.PP
Default: same as client-side database name
.SS host
.PP
Host name or IP address to connect to.
Host names are resolved at connection time, the result is cached per
\f[C]dns_max_ttl\f[R] parameter.
When a host name\[cq]s resolution changes, existing server connections
are automatically closed when they are released (according to the
pooling mode), and new server connections immediately use the new
resolution.
If DNS returns several results, they are used in a round-robin manner.
.PP
If the value begins with \f[C]/\f[R], then a Unix socket in the
file-system namespace is used.
If the value begins with \f[C]\[at]\f[R], then a Unix socket in the
abstract namespace is used.
.PP
A comma-separated list of host names or addresses can be specified.
In that case, connections are made in a round-robin manner.
(If a host list contains host names that in turn resolve via DNS to
multiple addresses, the round-robin systems operate independently.
This is an implementation dependency that is subject to change.) Note
that in a list, all hosts must be available at all times: There are no
mechanisms to skip unreachable hosts or to select only available hosts
from a list or similar.
(This is different from what a host list in libpq means.) Also note that
this only affects how the destinations of new connections are chosen.
See also the setting \f[C]server_round_robin\f[R] for how clients are
assigned to already established server connections.
.PP
Examples:
.IP
.nf
\f[C]
host=localhost
host=127.0.0.1
host=2001:0db8:85a3:0000:0000:8a2e:0370:7334
host=/var/run/postgresql
host=192.168.0.1,192.168.0.2,192.168.0.3
\f[R]
.fi
.PP
Default: not set, meaning to use a Unix socket
.SS port
.PP
Default: 5432
.SS user
.PP
If \f[C]user=\f[R] is set, all connections to the destination database
will be done with the specified user, meaning that there will be only
one pool for this database.
.PP
Otherwise, PgBouncer logs into the destination database with the client
user name, meaning that there will be one pool per user.
.SS password
.PP
If no password is specified here, the password from the
\f[C]auth_file\f[R] will be used for the user specified above.
Dynamic forms of password discovery such as \f[C]auth_query\f[R] are not
currently supported.
.SS auth_user
.PP
Override of the global \f[C]auth_user\f[R] setting, if specified.
.SS auth_query
.PP
Override of the global \f[C]auth_query\f[R] setting, if specified.
The entire SQL statement needs to be enclosed in single quotes.
.SS auth_dbname
.PP
Override of the global \f[C]auth_dbname\f[R] setting, if specified.
.SS pool_size
.PP
Set the maximum size of pools for this database.
If not set, the \f[C]default_pool_size\f[R] is used.
.SS min_pool_size
.PP
Set the minimum pool size for this database.
If not set, the global \f[C]min_pool_size\f[R] is used.
.PP
Only enforced if at least one of the following is true:
.IP \[bu] 2
this entry in the \f[C][database]\f[R] section has a value set for the
\f[C]user\f[R] key (aka forced user)
.IP \[bu] 2
there is at least one client connected to the pool
.SS reserve_pool_size
.PP
Set additional connections for this database.
If not set, the global \f[C]reserve_pool_size\f[R] is used.
For backwards compatibilty reasons \f[C]reserve_pool\f[R] is an alias
for this option.
.SS connect_query
.PP
Query to be executed after a connection is established, but before
allowing the connection to be used by any clients.
If the query raises errors, they are logged but ignored otherwise.
.SS pool_mode
.PP
Set the pool mode specific to this database.
If not set, the default \f[C]pool_mode\f[R] is used.
.SS load_balance_hosts
.PP
When a comma-separated list is specified in \f[C]host\f[R],
\f[C]load_balance_hosts\f[R] controls which entry is chosen for a new
connection.
.PP
Note: This setting currently only controls the load balancing behaviour
when providing multiple hosts in the connection string, but not when a
single host its DNS record references multiple IP addresses.
This is a missing feature, so in a future release this setting might
start to to control both methods of load balancing.
.TP
round-robin
A new connection attempt chooses the next host entry in the list.
.TP
disable
A new connection continues using the same host entry until a connection
fails, after which the next host entry is chosen.
.PP
It is recommended to set \f[C]server_login_retry\f[R] lower than the
default to ensure fast retries when multiple hosts are available.
.PP
Default: \f[C]round-robin\f[R]
.SS max_db_connections
.PP
Configure a database-wide maximum of server connections (i.e.\ all pools
within the database will not have more than this many server
connections).
.SS max_db_client_connections
.PP
Configure a database-wide client connection maximum.
Should be used in conjunction with max_client_conn to limit the number
of connections that PgBouncer is allowed to accept.
.SS server_lifetime
.PP
Configure the server_lifetime per database.
If not set the database will fall back to the instance wide configured
value for \f[C]server_lifetime\f[R]
.SS client_encoding
.PP
Ask specific \f[C]client_encoding\f[R] from server.
.SS datestyle
.PP
Ask specific \f[C]datestyle\f[R] from server.
.SS timezone
.PP
Ask specific \f[C]timezone\f[R] from server.
.SH SECTION [USERS]
.PP
This section contains key=value lines like
.IP
.nf
\f[C]
user1 = settings
\f[R]
.fi
.PP
where the key will be taken as a user name and the value as a list of
key=value pairs of configuration settings specific for this user.
Example:
.IP
.nf
\f[C]
user1 = pool_mode=session
\f[R]
.fi
.PP
Only a few settings are available here.
.PP
Note that when \f[C]auth_file\f[R] is configured, if a user is defined
in this section but not listed in \f[C]auth_file\f[R], pgBouncer will
attempt to use \f[C]auth_query\f[R] to find a password for that user if
\f[C]auth_user\f[R] is set.
If \f[C]auth_user\f[R] is not set, pgBouncer will pretend the user
exists and fail to return \[lq]no such user\[rq] messages to the client,
but neither will it accept any provided password.
.SS pool_size
.PP
Set the maximum size of pools for all connections from this user.
If not set, the database or \f[C]default_pool_size\f[R] is used.
.SS reserve_pool_size
.PP
Set the number of additional connections to allow to a pool for this
user.
If not set, the database configuration or the global
\f[C]reserve_pool_size\f[R] is used.
.SS pool_mode
.PP
Set the pool mode to be used for all connections from this user.
If not set, the database or default \f[C]pool_mode\f[R] is used.
.SS max_user_connections
.PP
Configure a maximum for the user of server connections (i.e.\ all pools
with the user will not have more than this many server connections).
.SS query_timeout
.PP
Set the maximum number of seconds that a user query can run for.
If set this timeout overrides the server level query_timeout described
above.
.SS idle_transaction_timeout
.PP
Set the maximum number of seconds that a user can have an idle
transaction open.
If set this timeout overides the server level idle_transaction_timeout
described above.
.SS client_idle_timeout
.PP
Set the maximum amount of time in seconds that a client is allowed to
idly connect to the pgbouncer instance.
If set this timeout overrides the server level client_idle_timeout
described above.
.PP
Please note that this is a potentially dangeous timeout.
.SS max_user_client_connections
.PP
Configure a maximum for the user of client connections.
This is the user equivalent ofthe max_client_conn setting.
.SH SECTION [PEERS]
.PP
The section \f[C][peers]\f[R] defines the peers that PgBouncer can
forward cancellation requests to and where those cancellation requests
will be routed.
.PP
PgBouncer processes can be peered together in a group by defining a
\f[C]peer_id\f[R] value and a \f[C][peers]\f[R] section in the configs
of all the PgBouncer processes.
These PgBouncer processes can then forward cancellations requests to the
process that it originated from.
This is needed to make cancellations work when multiple PgBouncer
processes (possibly on different servers) are behind the same TCP load
balancer.
Cancellation requests are sent over different TCP connections than the
query they are cancelling, so a TCP load balancer might send the
cancellation request connection to a different process than the one that
it was meant for.
By peering them these cancellation requests eventually end up at the
right process.
A more in-depth explanation is provided in this recording of a
conference talk (https://www.youtube.com/watch?v=X-nCHcZ6vQU).
.PP
The section contains key=value lines like
.IP
.nf
\f[C]
peer_id = connection string
\f[R]
.fi
.PP
Where the key will be taken as a \f[C]peer_id\f[R] and the value as a
connection string, consisting of key=value pairs of connection
parameters, described below (similar to libpq, but the actual libpq is
not used and the set of available features is different).
Example:
.IP
.nf
\f[C]
1 = host=host1.example.com
2 = host=/tmp/pgbouncer-2 port=5555
\f[R]
.fi
.PP
Note 1: For peering to work, the \f[C]peer_id\f[R] of each PgBouncer
process in the group must be unique within the peered group.
And the \f[C][peers]\f[R] section should contain entries for each of
those peer ids.
An example can be found in the examples section of these docs.
It \f[B]is\f[R] allowed, but not necessary, for the \f[C][peers]\f[R]
section to contain the \f[C]peer_id\f[R] of the PgBouncer that the
config is for.
Such an entry will be ignored, but it is allowed to config management
easy.
Because it allows using the exact same \f[C][peers]\f[R] section for
multiple configs.
.PP
Note 2: Cross-version peering is supported as long as all peers are on
the same side of the v1.21.0 version boundary.
In v1.21.0 some breaking changes were made in how we encode the
cancellation tokens that made them incompatible with the ones created by
earlier versions.
.SS host
.PP
Host name or IP address to connect to.
Host names are resolved at connection time, the result is cached per
\f[C]dns_max_ttl\f[R] parameter.
If DNS returns several results, they are used in a round-robin manner.
But in general it\[cq]s not recommended to use a hostname that resolves
to multiple IPs, because then the cancel request might still be
forwarded to the wrong node and it would need to be forwarded again
(which is only allowed up to three times).
.PP
If the value begins with \f[C]/\f[R], then a Unix socket in the
file-system namespace is used.
If the value begins with \f[C]\[at]\f[R], then a Unix socket in the
abstract namespace is used.
.PP
Examples:
.IP
.nf
\f[C]
host=localhost
host=127.0.0.1
host=2001:0db8:85a3:0000:0000:8a2e:0370:7334
host=/var/run/pgbouncer-1
\f[R]
.fi
.SS port
.PP
Default: 6432
.SS pool_size
.PP
Set the maximum number of cancel requests that can be in flight to the
peer at the same time.
It\[cq]s quite normal for cancel requests to arrive in bursts, e.g.
when the backing Postgres server slow or down.
So it\[cq]s important for \f[C]pool_size\f[R] to not be so low that it
cannot handle these bursts.
.PP
If not set, the \f[C]default_pool_size\f[R] is used.
.SH INCLUDE DIRECTIVE
.PP
The PgBouncer configuration file can contain include directives, which
specify another configuration file to read and process.
This allows splitting the configuration file into physically separate
parts.
The include directives look like this:
.IP
.nf
\f[C]
%include filename
\f[R]
.fi
.PP
If the file name is not an absolute path, it is taken as relative to the
current working directory.
.SH AUTHENTICATION FILE FORMAT
.PP
This section describes the format of the file specified by the
\f[C]auth_file\f[R] setting.
It is a text file in the following format:
.IP
.nf
\f[C]
\[dq]username1\[dq] \[dq]password\[dq] ...
\[dq]username2\[dq] \[dq]md5abcdef012342345\[dq] ...
\[dq]username2\[dq] \[dq]SCRAM-SHA-256$:$:\[dq]
\f[R]
.fi
.PP
There should be at least 2 fields, surrounded by double quotes.
The first field is the user name and the second is either a plain-text,
a MD5-hashed password, or a SCRAM secret.
PgBouncer ignores the rest of the line.
Double quotes in a field value can be escaped by writing two double
quotes.
.PP
PostgreSQL MD5-hashed password format:
.IP
.nf
\f[C]
\[dq]md5\[dq] + md5(password + username)
\f[R]
.fi
.PP
So user \f[C]admin\f[R] with password \f[C]1234\f[R] will have
MD5-hashed password \f[C]md545f2603610af569b6155c45067268c6b\f[R].
.PP
PostgreSQL SCRAM secret format:
.IP
.nf
\f[C]
SCRAM-SHA-256$:$:
\f[R]
.fi
.PP
See the PostgreSQL documentation and RFC 5803 for details on this.
.PP
The passwords or secrets stored in the authentication file serve two
purposes.
First, they are used to verify the passwords of incoming client
connections, if a password-based authentication method is configured.
Second, they are used as the passwords for outgoing connections to the
backend server, if the backend server requires password-based
authentication (unless the password is specified directly in the
database\[cq]s connection string).
.SS Limitations
.PP
If the password is stored in plain text, it can be used for any
password-based authentication used in the backend server; plain text,
MD5 or SCRAM (see
for
details).
.PP
MD5-hashed passwords can be used if backend server uses MD5
authentication (or specific users have MD5-hashed passwords).
.PP
SCRAM secrets can only be used for logging into a server if the client
authentication also uses SCRAM, the PgBouncer database definition does
not specify a user name, and the SCRAM secrets are identical in
PgBouncer and the PostgreSQL server (same salt and iterations, not
merely the same password).
This is due to an inherent security property of SCRAM: The stored SCRAM
secret cannot by itself be used for deriving login credentials.
.PP
The authentication file can be written by hand, but it\[cq]s also useful
to generate it from some other list of users and passwords.
See \f[C]./etc/mkauth.py\f[R] for a sample script to generate the
authentication file from the \f[C]pg_authid\f[R] system table.
Alternatively, use \f[C]auth_query\f[R] instead of \f[C]auth_file\f[R]
to avoid having to maintain a separate authentication file.
.SS Note on managed servers
.PP
If the backend server is configured to use SCRAM password authentication
PgBouncer cannot successfully authenticate if it does not know either a)
user password in plain text or b) corresponding SCRAM secret.
.PP
Some cloud providers (i.e.\ AWS RDS) prohibit access to PostgreSQL
sensitive system tables for fetching passwords.
Even for the most privileged user (i.e.\ member of rds_superuser) the
\f[C]select * from pg_authid\f[R]; returns the
\f[C]ERROR: permission denied for table pg_authid.\f[R] That is a known
behaviour
(blog (https://aws.amazon.com/blogs/database/best-practices-for-migrating-postgresql-databases-to-amazon-rds-and-amazon-aurora/)).
.PP
Therefore, fetching an existing SCRAM secret once it has been stored in
a managed server is impossible which makes it hard to configure
PgBouncer to use the same SCRAM secret.
Nevertheless, SCRAM secret can still be configured and used on both
sides using the following trick:
.PP
Generate SCRAM secret for arbitrary password with a tool that is capable
of printing out the secret.
For example \f[C]psql --echo-hidden\f[R] and the command
\f[C]\[rs]password\f[R] prints out the SCRAM secret to the console
before sending it over to the server.
.IP
.nf
\f[C]
$ psql --echo-hidden
postgres=# \[rs]password
Enter new password for user \[dq]\[dq]:
Enter it again:
********* QUERY **********
ALTER USER PASSWORD \[aq]SCRAM-SHA-256$:$:\[aq]
**************************
\f[R]
.fi
.PP
Note down the SCRAM secret from the QUERY and set it in PgBouncer\[cq]s
\f[C]userlist.txt\f[R].
.PP
If you used a tool other than \f[C]psql --echo-hidden\f[R] then you need
to set the SCRAM secret also in the server (you can use
\f[C]alter role password \[aq]\[aq]\f[R] for
that).
.SH HBA FILE FORMAT
.PP
The location of the HBA file is specified by the setting
\f[C]auth_hba_file\f[R].
It is only used if \f[C]auth_type\f[R] is set to \f[C]hba\f[R].
.PP
The file follows the format of the PostgreSQL \f[C]pg_hba.conf\f[R] file
(see ).
.IP \[bu] 2
Supported record types: \f[C]local\f[R], \f[C]host\f[R],
\f[C]hostssl\f[R], \f[C]hostnossl\f[R].
.IP \[bu] 2
Database field: Supports \f[C]all\f[R], \f[C]replication\f[R],
\f[C]sameuser\f[R], \f[C]\[at]file\f[R], multiple names.
Not supported: \f[C]samerole\f[R], \f[C]samegroup\f[R].
.IP \[bu] 2
User name field: Supports \f[C]all\f[R], \f[C]\[at]file\f[R], multiple
names.
Not supported: \f[C]+groupname\f[R].
.IP \[bu] 2
Address field: Supports \f[C]all\f[R], IPv4, IPv6.
Not supported: \f[C]samehost\f[R], \f[C]samenet\f[R], DNS names, domain
prefixes.
.IP \[bu] 2
Auth-method field: Only methods supported by PgBouncer\[cq]s
\f[C]auth_type\f[R] are supported, plus \f[C]peer\f[R] and
\f[C]reject\f[R], but except \f[C]any\f[R] and \f[C]pam\f[R], which only
work globally.
.IP \[bu] 2
User name map (\f[C]map=\f[R]) parameter is supported when
\f[C]auth_type\f[R] is \f[C]cert\f[R] or \f[C]peer\f[R].
.SH IDENT MAP FILE FORMAT
.PP
The location of the ident map file is specified by the setting
\f[C]auth_ident_file\f[R].
It is only loaded if \f[C]auth_type\f[R] is set to \f[C]hba\f[R].
.PP
The file format is a simplified variation of the PostgreSQL ident map
file (see
).
.IP \[bu] 2
Supported lines are only of the form
\f[C]map-name system-username database-username\f[R].
.IP \[bu] 2
There is no support for including file/directory.
.IP \[bu] 2
System-username field: Not supported: regular expressions.
.IP \[bu] 2
Database-username field: Supports \f[C]all\f[R] or a single postgres
user name.
Not supported: \f[C]+groupname\f[R], regular expressions.
.SH EXAMPLES
.PP
Small example configuration:
.IP
.nf
\f[C]
[databases]
template1 = host=localhost dbname=template1 auth_user=someuser
[pgbouncer]
pool_mode = session
listen_port = 6432
listen_addr = localhost
auth_type = md5
auth_file = users.txt
logfile = pgbouncer.log
pidfile = pgbouncer.pid
admin_users = someuser
stats_users = stat_collector
\f[R]
.fi
.PP
Database examples:
.IP
.nf
\f[C]
[databases]
; foodb over Unix socket
foodb =
; redirect bardb to bazdb on localhost
bardb = host=localhost dbname=bazdb
; access to destination database will go with single user
forcedb = host=localhost port=300 user=baz password=foo client_encoding=UNICODE datestyle=ISO
\f[R]
.fi
.PP
Example of a secure function for \f[C]auth_query\f[R]:
.IP
.nf
\f[C]
CREATE OR REPLACE FUNCTION pgbouncer.user_lookup(in i_username text, out uname text, out phash text)
RETURNS record AS $$
BEGIN
SELECT rolname, CASE WHEN rolvaliduntil < now() THEN NULL ELSE rolpassword END
FROM pg_authid
WHERE rolname=i_username AND rolcanlogin
INTO uname, phash;
RETURN;
END;
$$ LANGUAGE plpgsql
SECURITY DEFINER
-- Set a secure search_path: trusted schema(s), then \[aq]pg_temp\[aq].
SET search_path = pg_catalog, pg_temp;
REVOKE ALL ON FUNCTION pgbouncer.user_lookup(text) FROM public, pgbouncer;
GRANT EXECUTE ON FUNCTION pgbouncer.user_lookup(text) TO pgbouncer;
\f[R]
.fi
.PP
Example configs for 2 peered PgBouncer processes to create a multi-core
PgBouncer setup using \f[C]so_reuseport\f[R].
The config for the first process:
.IP
.nf
\f[C]
[databases]
postgres = host=localhost dbname=postgres
[peers]
1 = host=/tmp/pgbouncer1
2 = host=/tmp/pgbouncer2
[pgbouncer]
listen_addr=127.0.0.1
auth_file=auth_file.conf
so_reuseport=1
unix_socket_dir=/tmp/pgbouncer1
peer_id=1
\f[R]
.fi
.PP
The config for the second process:
.IP
.nf
\f[C]
[databases]
postgres = host=localhost dbname=postgres
[peers]
1 = host=/tmp/pgbouncer1
2 = host=/tmp/pgbouncer2
[pgbouncer]
listen_addr=127.0.0.1
auth_file=auth_file.conf
so_reuseport=1
; only unix_socket_dir and peer_id are different
unix_socket_dir=/tmp/pgbouncer2
peer_id=2
\f[R]
.fi
.SH SEE ALSO
.PP
pgbouncer(1) - man page for general usage, console commands
.PP
pgbouncer-1.24.1/doc/Makefile 0000644 0001750 0000000 00000001256 14777762222 012720 0000000 0000000 -include ../config.mak
manpages = pgbouncer.1 pgbouncer.5
dist_man_MANS = $(manpages)
EXTRA_DIST = config.md usage.md Makefile $(manpages) \
frag-config-man.md frag-usage-man.md \
filter.py
CLEANFILES = pgbouncer_1.md pgbouncer_5.md
# make maintainer-clean removes those
MAINTAINERCLEANFILES = $(manpages)
SUBLOC = doc
abs_top_srcdir ?= $(CURDIR)/..
include $(abs_top_srcdir)/lib/mk/antimake.mk
export PACKAGE_VERSION
pgbouncer.%: pgbouncer_%.md
$(PANDOC) -s -t man -o $@ $<
pgbouncer_1.md: filter.py frag-usage-man.md usage.md
$(PYTHON) $^ >$@
pgbouncer_5.md: filter.py frag-config-man.md config.md
$(PYTHON) $^ >$@
web:
$(MAKE) -C ../../pgbouncer.github.io
pgbouncer-1.24.1/doc/pgbouncer.1 0000664 0001750 0001750 00000067600 14777762332 013354 0000000 0000000 .\" Automatically generated by Pandoc 2.9.2.1
.\"
.TH "PGBOUNCER" "1" "" "1.24.1" "Databases"
.hy
.SH NAME
.PP
pgbouncer - lightweight connection pooler for PostgreSQL
.SH SYNOPSIS
.IP
.nf
\f[C]
pgbouncer [-d][-R][-v][-u user]
pgbouncer -V|-h
\f[R]
.fi
.PP
On Windows, the options are:
.IP
.nf
\f[C]
pgbouncer.exe [-v][-u user]
pgbouncer.exe -V|-h
\f[R]
.fi
.PP
Additional options for setting up a Windows service:
.IP
.nf
\f[C]
pgbouncer.exe --regservice