}	return ret;}#ifdef USE_SSL/* *	The stuff for SSL. *//* included in  <openssl/ssl.h>#define SSL_ERROR_NONE			0#define SSL_ERROR_SSL			1#define SSL_ERROR_WANT_READ		2#define SSL_ERROR_WANT_WRITE		3#define SSL_ERROR_WANT_X509_LOOKUP	4#define SSL_ERROR_SYSCALL		5 // look at error stack/return value/errno#define SSL_ERROR_ZERO_RETURN		6#define SSL_ERROR_WANT_CONNECT		7#define SSL_ERROR_WANT_ACCEPT		8*//* *	recv more than 1 bytes using SSL. */static int SOCK_SSL_recv(SocketClass *sock, void *buffer, int len){	CSTR	func = "SOCK_SSL_recv";	int n, err, gerrno, retry_count = 0;retry:	n = SSL_read(sock->ssl, buffer, len);	err = SSL_get_error(sock->ssl, len);	gerrno = SOCK_ERRNO;inolog("%s: %d get_error=%d Lasterror=%d\n", func, n, err, gerrno);	switch (err)	{		case	SSL_ERROR_NONE:			break;		case	SSL_ERROR_WANT_READ:			retry_count++;			if (SOCK_wait_for_ready(sock, FALSE, retry_count) >= 0)				goto retry;			n = -1;			break;		case	SSL_ERROR_WANT_WRITE:			goto retry;			break;		case	SSL_ERROR_SYSCALL:			if (-1 != n)			{				n = -1;				SOCK_ERRNO_SET(ECONNRESET);			}			break;		case	SSL_ERROR_SSL:		case	SSL_ERROR_ZERO_RETURN:			n = -1;			SOCK_ERRNO_SET(ECONNRESET);			break;		default:			n = -1;	}	return n;}/* *	send more than 1 bytes using SSL. */static int SOCK_SSL_send(SocketClass *sock, void *buffer, int len){	CSTR	func = "SOCK_SSL_send";	int n, err, gerrno, retry_count = 0;retry:	n = SSL_write(sock->ssl, buffer, len);	err = SSL_get_error(sock->ssl, len);	gerrno = SOCK_ERRNO;inolog("%s: %d get_error=%d Lasterror=%d\n", func,  n, err, gerrno);	switch (err)	{		case	SSL_ERROR_NONE:			break;		case	SSL_ERROR_WANT_READ:		case	SSL_ERROR_WANT_WRITE:			retry_count++;			if (SOCK_wait_for_ready(sock, TRUE, retry_count) >= 0)				goto retry;			n = -1;			break;		case	SSL_ERROR_SYSCALL:			if (-1 != n)			{				n = -1;				SOCK_ERRNO_SET(ECONNRESET);			}			break;		case	SSL_ERROR_SSL:		case	SSL_ERROR_ZERO_RETURN:			n = -1;			SOCK_ERRNO_SET(ECONNRESET);			break;		default:			n = -1;	}	return n;}#endif /* USE_SSL */intSOCK_get_id(SocketClass *self){	int	id;	if (0 != self->errornumber)		return 0;	if (self->reslen > 0)	{		mylog("SOCK_get_id has to eat %d bytes\n", self->reslen);		do		{			SOCK_get_next_byte(self);			if (0 != self->errornumber)				return 0;		} while (self->reslen > 0);	}	id = SOCK_get_next_byte(self);	self->reslen = 0;	return id;}voidSOCK_get_n_char(SocketClass *self, char *buffer, Int4 len){	int			lf;	if (!self)		return;	if (!buffer)	{		SOCK_set_error(self, SOCKET_NULLPOINTER_PARAMETER, "get_n_char was called with NULL-Pointer");		return;	}	for (lf = 0; lf < len; lf++)	{		if (0 != self->errornumber)			break;		buffer[lf] = SOCK_get_next_byte(self);	}}voidSOCK_put_n_char(SocketClass *self, const char *buffer, Int4 len){	int			lf;	if (!self)		return;	if (!buffer)	{		SOCK_set_error(self, SOCKET_NULLPOINTER_PARAMETER, "put_n_char was called with NULL-Pointer");		return;	}	for (lf = 0; lf < len; lf++)	{		if (0 != self->errornumber)			break;		SOCK_put_next_byte(self, (UCHAR) buffer[lf]);	}}/* *	bufsize must include room for the null terminator *	will read at most bufsize-1 characters + null. *	returns TRUE if truncation occurs. */BOOLSOCK_get_string(SocketClass *self, char *buffer, Int4 bufsize){	int lf;	for (lf = 0; lf < bufsize - 1; lf++)		if (!(buffer[lf] = SOCK_get_next_byte(self)))			return FALSE;	buffer[bufsize - 1] = '\0';	return TRUE;}voidSOCK_put_string(SocketClass *self, const char *string){	size_t	lf, len;	len = strlen(string) + 1;	for (lf = 0; lf < len; lf++)	{		if (0 != self->errornumber)			break;		SOCK_put_next_byte(self, (UCHAR) string[lf]);	}}intSOCK_get_int(SocketClass *self, short len){	if (!self)		return 0;	switch (len)	{		case 2:			{				unsigned short buf;				SOCK_get_n_char(self, (char *) &buf, len);				if (self->reverse)					return buf;				else					return ntohs(buf);			}		case 4:			{				unsigned int buf;				SOCK_get_n_char(self, (char *) &buf, len);				if (self->reverse)					return buf;				else					return ntohl(buf);			}		default:			SOCK_set_error(self, SOCKET_GET_INT_WRONG_LENGTH, "Cannot read ints of that length");			return 0;	}}voidSOCK_put_int(SocketClass *self, int value, short len){	unsigned int rv;	if (!self)		return;	switch (len)	{		case 2:			rv = self->reverse ? value : htons((unsigned short) value);			SOCK_put_n_char(self, (char *) &rv, 2);			return;		case 4:			rv = self->reverse ? value : htonl((unsigned int) value);			SOCK_put_n_char(self, (char *) &rv, 4);			return;		default:			SOCK_set_error(self, SOCKET_PUT_INT_WRONG_LENGTH, "Cannot write ints of that length");			return;	}}Int4SOCK_flush_output(SocketClass *self){	int	written, pos = 0, retry_count = 0, ttlsnd = 0, gerrno;	if (!self)		return -1;	if (0 != self->errornumber)		return -1;	while (self->buffer_filled_out > 0)	{#ifdef USE_SSL 		if (self->ssl)			written = SOCK_SSL_send(self, (char *) self->buffer_out + pos, self->buffer_filled_out);		else#endif /* USE_SSL */			written = send(self->socket, (char *) self->buffer_out + pos, self->buffer_filled_out, 0);		gerrno = SOCK_ERRNO;		if (written < 0)		{			switch (gerrno)			{				case EINTR:					continue;					break;				case EWOULDBLOCK:					retry_count++;					if (SOCK_wait_for_ready(self, TRUE, retry_count) >= 0)						continue;					break;			}			SOCK_set_error(self, SOCKET_WRITE_ERROR, "Could not flush socket buffer.");			return -1;		}		pos += written;		self->buffer_filled_out -= written;		ttlsnd += written;		retry_count = 0;	}		return ttlsnd;}UCHARSOCK_get_next_byte(SocketClass *self){	int	retry_count = 0, gerrno;	BOOL	maybeEOF = FALSE;	if (!self)		return 0;	if (self->buffer_read_in >= self->buffer_filled_in)	{		/*		 * there are no more bytes left in the buffer so reload the buffer		 */		self->buffer_read_in = 0;retry:#ifdef USE_SSL 		if (self->ssl)			self->buffer_filled_in = SOCK_SSL_recv(self, (char *) self->buffer_in, self->buffer_size);		else#endif /* USE_SSL */			self->buffer_filled_in = recv(self->socket, (char *) self->buffer_in, self->buffer_size, 0);		gerrno = SOCK_ERRNO;		mylog("read %d, global_socket_buffersize=%d\n", self->buffer_filled_in, self->buffer_size);		if (self->buffer_filled_in < 0)		{mylog("Lasterror=%d\n", gerrno);			switch (gerrno)			{				case	EINTR:					goto retry;					break;				case	EWOULDBLOCK:					retry_count++;					if (SOCK_wait_for_ready(self, FALSE, retry_count) >= 0)						goto retry;					break;				case	ECONNRESET:inolog("ECONNRESET\n");					maybeEOF = TRUE;					SOCK_set_error(self, SOCKET_CLOSED, "Connection reset by peer.");					break;			}			if (0 == self->errornumber)				SOCK_set_error(self, SOCKET_READ_ERROR, "Error while reading from the socket.");			self->buffer_filled_in = 0;			return 0;		}		if (self->buffer_filled_in == 0)		{			if (!maybeEOF)			{				int	nbytes = SOCK_wait_for_ready(self, FALSE, 0);				if (nbytes > 0)				{					maybeEOF = TRUE;					goto retry;				}				else if (0 == nbytes)					maybeEOF = TRUE;			}			if (maybeEOF)				SOCK_set_error(self, SOCKET_CLOSED, "Socket has been closed.");			else				SOCK_set_error(self, SOCKET_READ_ERROR, "Error while reading from the socket.");			return 0;		}	}	if (PG_PROTOCOL_74 == self->pversion)		self->reslen--;	return self->buffer_in[self->buffer_read_in++];}voidSOCK_put_next_byte(SocketClass *self, UCHAR next_byte){	int	bytes_sent, pos = 0, retry_count = 0, gerrno;	if (!self)		return;	if (0 != self->errornumber)		return;	self->buffer_out[self->buffer_filled_out++] = next_byte;	if (self->buffer_filled_out == self->buffer_size)	{		/* buffer is full, so write it out */		do		{#ifdef USE_SSL			if (self->ssl)				bytes_sent = SOCK_SSL_send(self, (char *) self->buffer_out + pos, self->buffer_filled_out);			else#endif /* USE_SSL */				bytes_sent = send(self->socket, (char *) self->buffer_out + pos, self->buffer_filled_out, 0);			gerrno = SOCK_ERRNO;			if (bytes_sent < 0)			{				switch (gerrno)				{					case	EINTR:						continue;					case	EWOULDBLOCK:						retry_count++;						if (SOCK_wait_for_ready(self, TRUE, retry_count) >= 0)							continue;				}				if (0 == self->errornumber)					SOCK_set_error(self, SOCKET_WRITE_ERROR, "Error while writing to the socket.");				break;			}			pos += bytes_sent;			self->buffer_filled_out -= bytes_sent;			retry_count = 0;		} while (self->buffer_filled_out > 0);	}}Int4SOCK_get_response_length(SocketClass *self){	int     leng = -1;	if (PG_PROTOCOL_74 == self->pversion)	{		leng = SOCK_get_int(self, 4) - 4;		self->reslen = leng;	}	return leng;}