#include "common/scram-common.h"
#include <sys/time.h>
#include <netinet/tcp.h>
#include "libpq/pg-gssapi.h"
#include "datatype/timestamp.h"
#include "libpq/hba.h"
#include "libpq/pqcomm.h"

Include dependency graph for libpq-be.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ClientConnectionInfo

struct	Port

struct	ClientSocket

Typedefs
typedef struct ClientConnectionInfo	ClientConnectionInfo

typedef struct Port	Port

typedef struct ClientSocket	ClientSocket

Functions
int	pq_getkeepalivesidle (Port *port)

int	pq_getkeepalivesinterval (Port *port)

int	pq_getkeepalivescount (Port *port)

int	pq_gettcpusertimeout (Port *port)

int	pq_setkeepalivesidle (int idle, Port *port)

int	pq_setkeepalivesinterval (int interval, Port *port)

int	pq_setkeepalivescount (int count, Port *port)

int	pq_settcpusertimeout (int timeout, Port *port)

Variables
PGDLLIMPORT ProtocolVersion	FrontendProtocol

PGDLLIMPORT ClientConnectionInfo	MyClientConnectionInfo

Typedef Documentation

◆ ClientConnectionInfo

typedef struct ClientConnectionInfo ClientConnectionInfo

◆ ClientSocket

typedef struct ClientSocket ClientSocket

◆ Port

typedef struct Port Port

Function Documentation

◆ pq_getkeepalivescount()

int pq_getkeepalivescount ( Port * port )

extern

Definition at line 1801 of file pqcomm.c.

{
#ifdef TCP_KEEPCNT
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return 0;
 
    if (port->keepalives_count != 0)
        return port->keepalives_count;
 
    if (port->default_keepalives_count == 0)
    {
        socklen_t   size = sizeof(port->default_keepalives_count);
 
        if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPCNT,
                       (char *) &port->default_keepalives_count,
                       &size) < 0)
        {
            ereport(LOG,
                    (errmsg("%s(%s) failed: %m", "getsockopt", "TCP_KEEPCNT")));
            port->default_keepalives_count = -1;    /* don't know */
        }
    }
 
    return port->default_keepalives_count;
#else
    return 0;
#endif
}

References ereport, errmsg(), fb(), LOG, and port.

Referenced by pq_setkeepalivescount(), and show_tcp_keepalives_count().

◆ pq_getkeepalivesidle()

int pq_getkeepalivesidle ( Port * port )

extern

Definition at line 1632 of file pqcomm.c.

{
#if defined(PG_TCP_KEEPALIVE_IDLE) || defined(SIO_KEEPALIVE_VALS)
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return 0;
 
    if (port->keepalives_idle != 0)
        return port->keepalives_idle;
 
    if (port->default_keepalives_idle == 0)
    {
#ifndef WIN32
        socklen_t   size = sizeof(port->default_keepalives_idle);
 
        if (getsockopt(port->sock, IPPROTO_TCP, PG_TCP_KEEPALIVE_IDLE,
                       (char *) &port->default_keepalives_idle,
                       &size) < 0)
        {
            ereport(LOG,
                    (errmsg("%s(%s) failed: %m", "getsockopt", PG_TCP_KEEPALIVE_IDLE_STR)));
            port->default_keepalives_idle = -1; /* don't know */
        }
#else                           /* WIN32 */
        /* We can't get the defaults on Windows, so return "don't know" */
        port->default_keepalives_idle = -1;
#endif                          /* WIN32 */
    }
 
    return port->default_keepalives_idle;
#else
    return 0;
#endif
}

References ereport, errmsg(), fb(), LOG, and port.

Referenced by pq_setkeepalivesidle(), and show_tcp_keepalives_idle().

◆ pq_getkeepalivesinterval()

int pq_getkeepalivesinterval ( Port * port )

extern

Definition at line 1717 of file pqcomm.c.

{
#if defined(TCP_KEEPINTVL) || defined(SIO_KEEPALIVE_VALS)
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return 0;
 
    if (port->keepalives_interval != 0)
        return port->keepalives_interval;
 
    if (port->default_keepalives_interval == 0)
    {
#ifndef WIN32
        socklen_t   size = sizeof(port->default_keepalives_interval);
 
        if (getsockopt(port->sock, IPPROTO_TCP, TCP_KEEPINTVL,
                       (char *) &port->default_keepalives_interval,
                       &size) < 0)
        {
            ereport(LOG,
                    (errmsg("%s(%s) failed: %m", "getsockopt", "TCP_KEEPINTVL")));
            port->default_keepalives_interval = -1; /* don't know */
        }
#else
        /* We can't get the defaults on Windows, so return "don't know" */
        port->default_keepalives_interval = -1;
#endif                          /* WIN32 */
    }
 
    return port->default_keepalives_interval;
#else
    return 0;
#endif
}

References ereport, errmsg(), fb(), LOG, and port.

Referenced by pq_setkeepalivesinterval(), and show_tcp_keepalives_interval().

◆ pq_gettcpusertimeout()

int pq_gettcpusertimeout ( Port * port )

extern

Definition at line 1876 of file pqcomm.c.

{
#ifdef TCP_USER_TIMEOUT
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return 0;
 
    if (port->tcp_user_timeout != 0)
        return port->tcp_user_timeout;
 
    if (port->default_tcp_user_timeout == 0)
    {
        socklen_t   size = sizeof(port->default_tcp_user_timeout);
 
        if (getsockopt(port->sock, IPPROTO_TCP, TCP_USER_TIMEOUT,
                       (char *) &port->default_tcp_user_timeout,
                       &size) < 0)
        {
            ereport(LOG,
                    (errmsg("%s(%s) failed: %m", "getsockopt", "TCP_USER_TIMEOUT")));
            port->default_tcp_user_timeout = -1;    /* don't know */
        }
    }
 
    return port->default_tcp_user_timeout;
#else
    return 0;
#endif
}

References ereport, errmsg(), fb(), LOG, and port.

Referenced by pq_settcpusertimeout(), and show_tcp_user_timeout().

◆ pq_setkeepalivescount()

int pq_setkeepalivescount	(	int	count,
		Port *	port
	)

extern

Definition at line 1831 of file pqcomm.c.

{
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return STATUS_OK;
 
#ifdef TCP_KEEPCNT
    if (count == port->keepalives_count)
        return STATUS_OK;
 
    if (port->default_keepalives_count <= 0)
    {
        if (pq_getkeepalivescount(port) < 0)
        {
            if (count == 0)
                return STATUS_OK;   /* default is set but unknown */
            else
                return STATUS_ERROR;
        }
    }
 
    if (count == 0)
        count = port->default_keepalives_count;
 
    if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPCNT,
                   (char *) &count, sizeof(count)) < 0)
    {
        ereport(LOG,
                (errmsg("%s(%s) failed: %m", "setsockopt", "TCP_KEEPCNT")));
        return STATUS_ERROR;
    }
 
    port->keepalives_count = count;
#else
    if (count != 0)
    {
        ereport(LOG,
                (errmsg("%s(%s) not supported", "setsockopt", "TCP_KEEPCNT")));
        return STATUS_ERROR;
    }
#endif
 
    return STATUS_OK;
}

References ereport, errmsg(), fb(), LOG, port, pq_getkeepalivescount(), STATUS_ERROR, and STATUS_OK.

Referenced by assign_tcp_keepalives_count(), and pq_init().

◆ pq_setkeepalivesidle()

int pq_setkeepalivesidle	(	int	idle,
		Port *	port
	)

extern

Definition at line 1667 of file pqcomm.c.

{
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return STATUS_OK;
 
/* check SIO_KEEPALIVE_VALS here, not just WIN32, as some toolchains lack it */
#if defined(PG_TCP_KEEPALIVE_IDLE) || defined(SIO_KEEPALIVE_VALS)
    if (idle == port->keepalives_idle)
        return STATUS_OK;
 
#ifndef WIN32
    if (port->default_keepalives_idle <= 0)
    {
        if (pq_getkeepalivesidle(port) < 0)
        {
            if (idle == 0)
                return STATUS_OK;   /* default is set but unknown */
            else
                return STATUS_ERROR;
        }
    }
 
    if (idle == 0)
        idle = port->default_keepalives_idle;
 
    if (setsockopt(port->sock, IPPROTO_TCP, PG_TCP_KEEPALIVE_IDLE,
                   (char *) &idle, sizeof(idle)) < 0)
    {
        ereport(LOG,
                (errmsg("%s(%s) failed: %m", "setsockopt", PG_TCP_KEEPALIVE_IDLE_STR)));
        return STATUS_ERROR;
    }
 
    port->keepalives_idle = idle;
#else                           /* WIN32 */
    return pq_setkeepaliveswin32(port, idle, port->keepalives_interval);
#endif
#else
    if (idle != 0)
    {
        ereport(LOG,
                (errmsg("setting the keepalive idle time is not supported")));
        return STATUS_ERROR;
    }
#endif
 
    return STATUS_OK;
}

References ereport, errmsg(), fb(), LOG, port, pq_getkeepalivesidle(), STATUS_ERROR, and STATUS_OK.

Referenced by assign_tcp_keepalives_idle(), and pq_init().

◆ pq_setkeepalivesinterval()

int pq_setkeepalivesinterval	(	int	interval,
		Port *	port
	)

extern

Definition at line 1752 of file pqcomm.c.

{
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return STATUS_OK;
 
#if defined(TCP_KEEPINTVL) || defined(SIO_KEEPALIVE_VALS)
    if (interval == port->keepalives_interval)
        return STATUS_OK;
 
#ifndef WIN32
    if (port->default_keepalives_interval <= 0)
    {
        if (pq_getkeepalivesinterval(port) < 0)
        {
            if (interval == 0)
                return STATUS_OK;   /* default is set but unknown */
            else
                return STATUS_ERROR;
        }
    }
 
    if (interval == 0)
        interval = port->default_keepalives_interval;
 
    if (setsockopt(port->sock, IPPROTO_TCP, TCP_KEEPINTVL,
                   (char *) &interval, sizeof(interval)) < 0)
    {
        ereport(LOG,
                (errmsg("%s(%s) failed: %m", "setsockopt", "TCP_KEEPINTVL")));
        return STATUS_ERROR;
    }
 
    port->keepalives_interval = interval;
#else                           /* WIN32 */
    return pq_setkeepaliveswin32(port, port->keepalives_idle, interval);
#endif
#else
    if (interval != 0)
    {
        ereport(LOG,
                (errmsg("%s(%s) not supported", "setsockopt", "TCP_KEEPINTVL")));
        return STATUS_ERROR;
    }
#endif
 
    return STATUS_OK;
}

References ereport, errmsg(), fb(), LOG, port, pq_getkeepalivesinterval(), STATUS_ERROR, and STATUS_OK.

Referenced by assign_tcp_keepalives_interval(), and pq_init().

◆ pq_settcpusertimeout()

int pq_settcpusertimeout	(	int	timeout,
		Port *	port
	)

extern

Definition at line 1906 of file pqcomm.c.

{
    if (port == NULL || port->laddr.addr.ss_family == AF_UNIX)
        return STATUS_OK;
 
#ifdef TCP_USER_TIMEOUT
    if (timeout == port->tcp_user_timeout)
        return STATUS_OK;
 
    if (port->default_tcp_user_timeout <= 0)
    {
        if (pq_gettcpusertimeout(port) < 0)
        {
            if (timeout == 0)
                return STATUS_OK;   /* default is set but unknown */
            else
                return STATUS_ERROR;
        }
    }
 
    if (timeout == 0)
        timeout = port->default_tcp_user_timeout;
 
    if (setsockopt(port->sock, IPPROTO_TCP, TCP_USER_TIMEOUT,
                   (char *) &timeout, sizeof(timeout)) < 0)
    {
        ereport(LOG,
                (errmsg("%s(%s) failed: %m", "setsockopt", "TCP_USER_TIMEOUT")));
        return STATUS_ERROR;
    }
 
    port->tcp_user_timeout = timeout;
#else
    if (timeout != 0)
    {
        ereport(LOG,
                (errmsg("%s(%s) not supported", "setsockopt", "TCP_USER_TIMEOUT")));
        return STATUS_ERROR;
    }
#endif
 
    return STATUS_OK;
}