#include <sys/time.h>
#include <netinet/tcp.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

Typedefs
typedef enum CAC_state	CAC_state

typedef struct ClientConnectionInfo	ClientConnectionInfo

typedef struct Port	Port

Enumerations
enum	CAC_state { CAC_OK , CAC_STARTUP , CAC_SHUTDOWN , CAC_RECOVERY , CAC_NOTCONSISTENT , CAC_TOOMANY }

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

◆ CAC_state

typedef enum CAC_state CAC_state

◆ ClientConnectionInfo

typedef struct ClientConnectionInfo ClientConnectionInfo

◆ Port

typedef struct Port Port

Enumeration Type Documentation

◆ CAC_state

enum CAC_state

Enumerator
CAC_OK
CAC_STARTUP
CAC_SHUTDOWN
CAC_RECOVERY
CAC_NOTCONSISTENT
CAC_TOOMANY

Definition at line 61 of file libpq-be.h.

 {
     CAC_OK,
     CAC_STARTUP,
     CAC_SHUTDOWN,
     CAC_RECOVERY,
     CAC_NOTCONSISTENT,
     CAC_TOOMANY
 } CAC_state;

Function Documentation

◆ pq_getkeepalivescount()

int pq_getkeepalivescount ( Port * port )

Definition at line 1778 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(), LOG, and port.

Referenced by pq_setkeepalivescount(), and show_tcp_keepalives_count().

◆ pq_getkeepalivesidle()

int pq_getkeepalivesidle ( Port * port )

Definition at line 1609 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(), LOG, and port.

Referenced by pq_setkeepalivesidle(), and show_tcp_keepalives_idle().

◆ pq_getkeepalivesinterval()

int pq_getkeepalivesinterval ( Port * port )

Definition at line 1694 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(), LOG, and port.

Referenced by pq_setkeepalivesinterval(), and show_tcp_keepalives_interval().

◆ pq_gettcpusertimeout()

int pq_gettcpusertimeout ( Port * port )

Definition at line 1853 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(), LOG, and port.

Referenced by pq_settcpusertimeout(), and show_tcp_user_timeout().

◆ pq_setkeepalivescount()

int pq_setkeepalivescount	(	int	count,
		Port *	port
	)

Definition at line 1808 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(), LOG, port, pq_getkeepalivescount(), STATUS_ERROR, and STATUS_OK.

Referenced by assign_tcp_keepalives_count(), and StreamConnection().

◆ pq_setkeepalivesidle()

int pq_setkeepalivesidle	(	int	idle,
		Port *	port
	)

Definition at line 1644 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(), LOG, port, pq_getkeepalivesidle(), STATUS_ERROR, and STATUS_OK.

Referenced by assign_tcp_keepalives_idle(), and StreamConnection().

◆ pq_setkeepalivesinterval()

int pq_setkeepalivesinterval	(	int	interval,
		Port *	port
	)

Definition at line 1729 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(), LOG, port, pq_getkeepalivesinterval(), STATUS_ERROR, and STATUS_OK.

Referenced by assign_tcp_keepalives_interval(), and StreamConnection().

◆ pq_settcpusertimeout()

int pq_settcpusertimeout	(	int	timeout,
		Port *	port
	)

Definition at line 1883 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;
 }