changed omgssapi and omfwd to utilize new object calling interface; made a

    tcpclt class; (stage work, among others, for more intelligent recovery
    from TCP session recovery)

12 files changed, 630 insertions, 336 deletions

diff --git a/Makefile.am b/Makefile.am
index 5b3253f9..7bdec73a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -94,10 +94,20 @@ rsyslogd_LDADD = $(zlib_libs) $(pthreads_libs) $(dl_libs) $(rt_libs)
 rsyslogd_LDFLAGS = -export-dynamic
 
 # now come the library plugins
-pkglib_LTLIBRARIES = lmtcpsrv.la
+pkglib_LTLIBRARIES = 
 
+if ENABLE_INET
+pkglib_LTLIBRARIES += lmnet.la lmtcpsrv.la lmtcpclt.la
+#
+# network support
+# 
+lmnet_la_SOURCES = net.c net.h
+lmnet_la_CPPFLAGS = $(pthreads_cflags)
+lmnet_la_LDFLAGS = -module -avoid-version
+lmnet_la_LIBADD =
+#
 #
-# TCP (Stream) Server support
+# TCP (stream) server support
 #
 lmtcpsrv_la_SOURCES = \
 	tcps_sess.c \
@@ -109,15 +119,16 @@ lmtcpsrv_la_LDFLAGS = -module -avoid-version
 lmtcpsrv_la_LIBADD = 
 
 #
-# network support
-# 
-if ENABLE_INET
-pkglib_LTLIBRARIES += lmnet.la
-lmnet_la_SOURCES = net.c net.h
-lmnet_la_CPPFLAGS = $(pthreads_cflags)
-lmnet_la_LDFLAGS = -module -avoid-version
-lmnet_la_LIBADD =
-endif
+# TCP (stream) client support
+#
+lmtcpclt_la_SOURCES = \
+	tcpclt.c \
+	tcpclt.h
+lmtcpclt_la_CPPFLAGS = $(pthreads_cflags)
+lmtcpclt_la_LDFLAGS = -module -avoid-version
+lmtcpclt_la_LIBADD = 
+
+endif # if ENABLE_INET
 
 #
 # regular expression support
diff --git a/modules.c b/modules.c
index 357a2fe9..70945cae 100644
--- a/modules.c
+++ b/modules.c
@@ -484,7 +484,12 @@ modUnlinkAndDestroy(modInfo_t *pThis)
 	/* finally, we are ready for the module to go away... */
 	dbgprintf("Unloading module %s\n", modGetName(pThis));
 	CHKiRet(modPrepareUnload(pThis));
+modInfo_t *prev, *next;
+char *name = strdup(pThis->pszName);
+prev = pThis->pPrev; next = pThis->pNext;
 	moduleDestruct(pThis);
+dbgprintf("end unload, pThis %p (%s), prev %p, next %p\n", pThis, name, prev, next);
+free(name);
 
 finalize_it:
 	RETiRet;
@@ -512,6 +517,13 @@ modUnloadAndDestructAll(eModLinkType_t modLinkTypesToUnload)
 		}
 	}
 
+#	ifdef DEBUG
+		if(pLoadedModules != NULL) {
+			dbgprintf("modules still loaded after module.UnloadAndDestructAll:\n");
+			modUsrPrintAll();
+		}
+#	endif
+
 	RETiRet;
 }
 
diff --git a/obj.c b/obj.c
index 9156be9f..0baaf7a1 100644
--- a/obj.c
+++ b/obj.c
@@ -1002,6 +1002,13 @@ FindObjInfo(cstr_t *pstrOID, objInfo_t **ppInfo)
 	bFound = 0;
 	i = 0;
 	while(!bFound && i < OBJ_NUM_IDS) {
+#if 0
+RUNLOG_VAR("%d", i);
+if(arrObjInfo[i] != NULL) {
+RUNLOG_VAR("%p", arrObjInfo[i]->pszID);
+RUNLOG_VAR("%s", arrObjInfo[i]->pszID);
+}
+#endif
 		if(arrObjInfo[i] != NULL && !rsCStrSzStrCmp(pstrOID, arrObjInfo[i]->pszID, arrObjInfo[i]->lenID)) {
 			bFound = 1;
 			break;
diff --git a/omfwd.c b/omfwd.c
index 62b774cc..f036f173 100644
--- a/omfwd.c
+++ b/omfwd.c
@@ -56,6 +56,7 @@
 #include "template.h"
 #include "msg.h"
 #include "tcpsyslog.h"
+#include "tcpclt.h"
 #include "cfsysline.h"
 #include "module-template.h"
 #include "errmsg.h"
@@ -63,19 +64,16 @@
 MODULE_TYPE_OUTPUT
 
 #ifdef SYSLOG_INET
-#define INET_SUSPEND_TIME 60		/* equal to 1 minute 
-					 * rgerhards, 2005-07-26: This was 3 minutes. As the
-					 * same timer is used for tcp based syslog, we have
-					 * reduced it. However, it might actually be worth
-					 * thinking about a buffered tcp sender, which would be 
-					 * a much better alternative. When that happens, this
-					 * time here can be re-adjusted to 3 minutes (or,
-					 * even better, made configurable).
-					 */
+#define INET_SUSPEND_TIME 60
+/* equal to 1 minute - TODO: see if we can get rid of this now that we have
+ * the retry intervals in the engine -- rgerhards, 2008-03-12
+ */
+
 #define INET_RETRY_MAX 30		/* maximum of retries for gethostbyname() */
 	/* was 10, changed to 30 because we reduced INET_SUSPEND_TIME by one third. So
 	 * this "fixes" some of implications of it (see comment on INET_SUSPEND_TIME).
 	 * rgerhards, 2005-07-26
+	 * TODO: this needs to be reviewed in spite of the new engine, too -- rgerhards, 2008-03-12
 	 */
 #endif
 
@@ -84,6 +82,7 @@ MODULE_TYPE_OUTPUT
 DEF_OMOD_STATIC_DATA
 DEFobjCurrIf(errmsg)
 DEFobjCurrIf(net)
+DEFobjCurrIf(tcpclt)
 
 typedef struct _instanceData {
 	char	f_hname[MAXHOSTNAMELEN+1];
@@ -99,11 +98,11 @@ typedef struct _instanceData {
 	int compressionLevel; /* 0 - no compression, else level for zlib */
 	char *port;
 	int protocol;
-	TCPFRAMINGMODE tcp_framing;
 #	define	FORW_UDP 0
 #	define	FORW_TCP 1
 	/* following fields for TCP-based delivery */
 	time_t	ttSuspend;	/* time selector was suspended */
+	tcpclt_t *pTCPClt;		/* our tcpclt object */
 } instanceData;
 
 /* get the syslog forward port from selector_t. The passed in
@@ -152,6 +151,11 @@ CODESTARTfreeInstance
 		close(pData->sock);
 	if(pData->pSockArray != NULL)
 		net.closeUDPListenSockets(pData->pSockArray);
+
+	if(pData->protocol == FORW_TCP) {
+		tcpclt.Destruct(&pData->pTCPClt);
+	}
+
 ENDfreeInstance
 
 
@@ -274,7 +278,7 @@ static rsRetVal TCPSendInit(void *pvData)
 
 	assert(pData != NULL);
 	if(pData->sock < 0) {
-		if((pData->sock = TCPSendCreateSocket(pData->f_addr)) < 0)
+		if((pData->sock = tcpclt.CreateSocket(pData->f_addr)) < 0)
 			iRet = RS_RET_TCP_SOCKCREATE_ERR;
 	}
 
@@ -422,7 +426,7 @@ CODESTARTdoAction
 			} else {
 				/* forward via TCP */
 				rsRetVal ret;
-				ret = TCPSend(pData, psz, l, pData->tcp_framing, TCPSendInit, TCPSendFrame, TCPSendPrepRetry);
+				ret = tcpclt.Send(pData->pTCPClt, pData, psz, l);
 				if(ret != RS_RET_OK) {
 					/* error! */
 					dbgprintf("error forwarding via tcp, suspending\n");
@@ -443,6 +447,7 @@ BEGINparseSelectorAct
         int error;
 	int bErr;
         struct addrinfo hints, *res;
+	TCPFRAMINGMODE tcp_framing;
 CODESTARTparseSelectorAct
 CODE_STD_STRING_REQUESTparseSelectorAct(1)
 	if(*p == '@') {
@@ -494,7 +499,7 @@ CODE_STD_STRING_REQUESTparseSelectorAct(1)
 				} else if(*p == 'o') { /* octet-couting based TCP framing? */
 					++p; /* eat */
 					/* no further options settable */
-					pData->tcp_framing = TCP_FRAMING_OCTET_COUNTING;
+					tcp_framing = TCP_FRAMING_OCTET_COUNTING;
 				} else { /* invalid option! Just skip it... */
 					errmsg.LogError(NO_ERRCODE, "Invalid option %c in forwarding action - ignoring.", *p);
 					++p; /* eat invalid option */
@@ -582,13 +587,22 @@ CODE_STD_STRING_REQUESTparseSelectorAct(1)
 			pData->eDestState = eDestFORW;
 			pData->f_addr = res;
 		}
-
 		/*
 		 * Otherwise the host might be unknown due to an
 		 * inaccessible nameserver (perhaps on the same
 		 * host). We try to get the ip number later, like
 		 * FORW_SUSP.
 		 */
+		if(pData->protocol == FORW_TCP) {
+			/* create our tcpclt */
+			CHKiRet(tcpclt.Construct(&pData->pTCPClt));
+			/* and set callbacks */
+			CHKiRet(tcpclt.SetSendInit(pData->pTCPClt, TCPSendInit));
+			CHKiRet(tcpclt.SetSendFrame(pData->pTCPClt, TCPSendFrame));
+			CHKiRet(tcpclt.SetSendPrepRetry(pData->pTCPClt, TCPSendPrepRetry));
+			CHKiRet(tcpclt.SetFraming(pData->pTCPClt, tcp_framing));
+		}
+
 	} else {
 		iRet = RS_RET_CONFLINE_UNPROCESSED;
 	}
@@ -611,6 +625,7 @@ CODESTARTmodExit
 	/* release what we no longer need */
 	objRelease(errmsg, CORE_COMPONENT);
 	objRelease(net, LM_NET_FILENAME);
+	objRelease(tcpclt, LM_TCPCLT_FILENAME);
 ENDmodExit
 
 
@@ -626,9 +641,9 @@ CODESTARTmodInit
 CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(objUse(errmsg, CORE_COMPONENT));
 	CHKiRet(objUse(net, LM_NET_FILENAME));
+	CHKiRet(objUse(tcpclt, LM_TCPCLT_FILENAME));
 ENDmodInit
 
 #endif /* #ifdef SYSLOG_INET */
-/*
- * vi:set ai:
+/* vim:set ai:
  */
diff --git a/plugins/imtcp/imtcp.c b/plugins/imtcp/imtcp.c
index d4ac9cb6..ed0131b8 100644
--- a/plugins/imtcp/imtcp.c
+++ b/plugins/imtcp/imtcp.c
@@ -129,11 +129,9 @@ static rsRetVal addTCPListener(void __attribute__((unused)) *pVal, uchar *pNewVa
 	DEFiRet;
 	if(pOurTcpsrv == NULL) {
 		CHKiRet(tcpsrv.Construct(&pOurTcpsrv));
-		/* TODO: fill params! */
 		CHKiRet(tcpsrv.SetCBIsPermittedHost(pOurTcpsrv, isPermittedHost));
 		CHKiRet(tcpsrv.SetCBRcvData(pOurTcpsrv, doRcvData));
 		CHKiRet(tcpsrv.SetCBOpenLstnSocks(pOurTcpsrv, doOpenLstnSocks));
-		//CHKiRet(tcpsrv.SetCBOnListenDeinit(pOurTcpsrv, ));
 		CHKiRet(tcpsrv.SetCBOnSessAccept(pOurTcpsrv, onSessAccept));
 		CHKiRet(tcpsrv.SetCBOnRegularClose(pOurTcpsrv, onRegularClose));
 		CHKiRet(tcpsrv.SetCBOnErrClose(pOurTcpsrv, onErrClose));
diff --git a/plugins/omgssapi/omgssapi.c b/plugins/omgssapi/omgssapi.c
index ba7b0b6c..dcc21dc5 100644
--- a/plugins/omgssapi/omgssapi.c
+++ b/plugins/omgssapi/omgssapi.c
@@ -54,23 +54,21 @@
 #include "cfsysline.h"
 #include "module-template.h"
 #include "gss-misc.h"
+#include "tcpclt.h"
 #include "errmsg.h"
 
 MODULE_TYPE_OUTPUT
 
-#define INET_SUSPEND_TIME 60		/* equal to 1 minute 
-					 * rgerhards, 2005-07-26: This was 3 minutes. As the
-					 * same timer is used for tcp based syslog, we have
-					 * reduced it. However, it might actually be worth
-					 * thinking about a buffered tcp sender, which would be 
-					 * a much better alternative. When that happens, this
-					 * time here can be re-adjusted to 3 minutes (or,
-					 * even better, made configurable).
-					 */
+#define INET_SUSPEND_TIME 60
+/* equal to 1 minute - TODO: see if we can get rid of this now that we have
+ * the retry intervals in the engine -- rgerhards, 2008-03-12
+ */
+
 #define INET_RETRY_MAX 30		/* maximum of retries for gethostbyname() */
 	/* was 10, changed to 30 because we reduced INET_SUSPEND_TIME by one third. So
 	 * this "fixes" some of implications of it (see comment on INET_SUSPEND_TIME).
 	 * rgerhards, 2005-07-26
+	 * TODO: this needs to be reviewed in spite of the new engine, too -- rgerhards, 2008-03-12
 	 */
 
 /* internal structures
@@ -78,6 +76,7 @@ MODULE_TYPE_OUTPUT
 DEF_OMOD_STATIC_DATA
 DEFobjCurrIf(errmsg)
 DEFobjCurrIf(gssutil)
+DEFobjCurrIf(tcpclt)
 
 typedef struct _instanceData {
 	char	f_hname[MAXHOSTNAMELEN+1];
@@ -91,8 +90,8 @@ typedef struct _instanceData {
 	struct addrinfo *f_addr;
 	int compressionLevel; /* 0 - no compression, else level for zlib */
 	char *port;
-	TCPFRAMINGMODE tcp_framing;
 	time_t	ttSuspend;	/* time selector was suspended */
+	tcpclt_t *pTCPClt;		/* our tcpclt object */
 	gss_ctx_id_t gss_context;
 	OM_uint32 gss_flags;
 } instanceData;
@@ -158,6 +157,7 @@ CODESTARTfreeInstance
 	}
 
 	/* final cleanup */
+	tcpclt.Destruct(&pData->pTCPClt);
 	if(pData->sock >= 0)
 		close(pData->sock);
 ENDfreeInstance
@@ -249,7 +249,7 @@ static rsRetVal TCPSendGSSInit(void *pvData)
 		}
 
 		if (s == -1)
-			if ((s = pData->sock = TCPSendCreateSocket(pData->f_addr)) == -1)
+			if ((s = pData->sock = tcpclt.CreateSocket(pData->f_addr)) == -1)
 				goto fail;
 
 		if (out_tok.length != 0) {
@@ -448,7 +448,7 @@ CODESTARTdoAction
 		}
 #		endif
 
-		CHKiRet_Hdlr(TCPSend(pData, psz, l, pData->tcp_framing, TCPSendGSSInit, TCPSendGSSSend, TCPSendGSSPrepRetry)) {
+		CHKiRet_Hdlr(tcpclt.Send(pData->pTCPClt, pData, psz, l)) {
 			/* error! */
 			dbgprintf("error forwarding via tcp, suspending\n");
 			pData->eDestState = eDestFORW_SUSP;
@@ -465,6 +465,7 @@ BEGINparseSelectorAct
         int error;
 	int bErr;
         struct addrinfo hints, *res;
+	TCPFRAMINGMODE tcp_framing;
 CODESTARTparseSelectorAct
 CODE_STD_STRING_REQUESTparseSelectorAct(1)
 	/* first check if this config line is actually for us
@@ -525,7 +526,7 @@ CODE_STD_STRING_REQUESTparseSelectorAct(1)
 			} else if(*p == 'o') { /* octet-couting based TCP framing? */
 				++p; /* eat */
 				/* no further options settable */
-				pData->tcp_framing = TCP_FRAMING_OCTET_COUNTING;
+				tcp_framing = TCP_FRAMING_OCTET_COUNTING;
 			} else { /* invalid option! Just skip it... */
 				errmsg.LogError(NO_ERRCODE, "Invalid option %c in forwarding action - ignoring.", *p);
 				++p; /* eat invalid option */
@@ -614,6 +615,14 @@ CODE_STD_STRING_REQUESTparseSelectorAct(1)
 		pData->f_addr = res;
 	}
 
+	/* now create our tcpclt */
+	CHKiRet(tcpclt.Construct(&pData->pTCPClt));
+	/* and set callbacks */
+	CHKiRet(tcpclt.SetSendInit(pData->pTCPClt, TCPSendGSSInit));
+	CHKiRet(tcpclt.SetSendFrame(pData->pTCPClt, TCPSendGSSSend));
+	CHKiRet(tcpclt.SetSendPrepRetry(pData->pTCPClt, TCPSendGSSPrepRetry));
+	CHKiRet(tcpclt.SetFraming(pData->pTCPClt, tcp_framing));
+
 	/* TODO: do we need to call freeInstance if we failed - this is a general question for
 	 * all output modules. I'll address it lates as the interface evolves. rgerhards, 2007-07-25
 	 */
@@ -629,6 +638,9 @@ ENDneedUDPSocket
 
 BEGINmodExit
 CODESTARTmodExit
+	objRelease(errmsg, CORE_COMPONENT);
+	objRelease(gssutil, LM_GSSUTIL_FILENAME);
+	objRelease(tcpclt, LM_TCPCLT_FILENAME);
 ENDmodExit
 
 
@@ -676,6 +688,7 @@ CODESTARTmodInit
 CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(objUse(errmsg, CORE_COMPONENT));
 	CHKiRet(objUse(gssutil, LM_GSSUTIL_FILENAME));
+	CHKiRet(objUse(tcpclt, LM_TCPCLT_FILENAME));
 
 	CHKiRet(omsdRegCFSLineHdlr((uchar *)"gssforwardservicename", 0, eCmdHdlrGetWord, NULL, &gss_base_service_name, STD_LOADABLE_MODULE_ID));
 	CHKiRet(omsdRegCFSLineHdlr((uchar *)"gssmode", 0, eCmdHdlrGetWord, setGSSMode, &gss_mode, STD_LOADABLE_MODULE_ID));
diff --git a/syslogd.c b/syslogd.c
index c811c897..487fbb40 100644
--- a/syslogd.c
+++ b/syslogd.c
@@ -1962,8 +1962,6 @@ die(int sig)
 	 */
 	module.UnloadAndDestructAll(eMOD_LINK_ALL);
 
-dbgprintf("modules still loaded:\n");
-modUsrPrintAll();
 	dbgprintf("Clean shutdown completed, bye\n");
 	/* dbgClassExit MUST be the last one, because it de-inits the debug system */
 	dbgClassExit();
diff --git a/tcpclt.c b/tcpclt.c
new file mode 100644
index 00000000..7262737c
--- /dev/null
+++ b/tcpclt.c
@@ -0,0 +1,461 @@
+/* tcpclt.c
+ *
+ * This is the implementation of TCP-based syslog clients (the counterpart
+ * of the tcpsrv class).
+ *
+ * Copyright 2007, 2008 Rainer Gerhards and Adiscon GmbH.
+ *
+ * This file is part of rsyslog.
+ *
+ * Rsyslog 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.
+ *
+ * Rsyslog 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 Rsyslog.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * A copy of the GPL can be found in the file "COPYING" in this distribution.
+ */
+#include "config.h"
+#include "rsyslog.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#if HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include "syslogd.h"
+#include "syslogd-types.h"
+#include "net.h"
+#include "tcpsyslog.h"
+#include "tcpclt.h"
+#include "module-template.h"
+#include "srUtils.h"
+
+MODULE_TYPE_LIB
+
+/* static data */
+DEFobjStaticHelpers
+
+/* Initialize TCP sockets (for sender)
+ * This is done once per selector line, if not yet initialized.
+ */
+static int
+CreateSocket(struct addrinfo *addrDest)
+{
+	int fd;
+	struct addrinfo *r; 
+	
+	r = addrDest;
+
+	while(r != NULL) {
+		fd = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
+		if (fd != -1) {
+			/* We can not allow the TCP sender to block syslogd, at least
+			 * not in a single-threaded design. That would cause rsyslogd to
+			 * loose input messages - which obviously also would affect
+			 * other selector lines, too. So we do set it to non-blocking and 
+			 * handle the situation ourselfs (by discarding messages). IF we run
+			 * dual-threaded, however, the situation is different: in this case,
+			 * the receivers and the selector line processing are only loosely
+			 * coupled via a memory buffer. Now, I think, we can afford the extra
+			 * wait time. Thus, we enable blocking mode for TCP if we compile with
+			 * pthreads. -- rgerhards, 2005-10-25
+			 * And now, we always run on multiple threads... -- rgerhards, 2007-12-20
+			 */
+			if (connect (fd, r->ai_addr, r->ai_addrlen) != 0) {
+				if(errno == EINPROGRESS) {
+					/* this is normal - will complete later select */
+					return fd;
+				} else {
+					char errStr[1024];
+					dbgprintf("create tcp connection failed, reason %s",
+						rs_strerror_r(errno, errStr, sizeof(errStr)));
+				}
+
+			}
+			else {
+				return fd;
+			}
+			close(fd);
+		}
+		else {
+			char errStr[1024];
+			dbgprintf("couldn't create send socket, reason %s", rs_strerror_r(errno, errStr, sizeof(errStr)));
+		}		
+		r = r->ai_next;
+	}
+
+	dbgprintf("no working socket could be obtained");
+
+	return -1;
+}
+
+
+
+/* Build frame based on selected framing 
+ * This function was created by pulling code from TCPSend()
+ * on 2007-12-27 by rgerhards. Older comments are still relevant.
+ *
+ * In order to support compressed messages via TCP, we must support an
+ * octet-counting based framing (LF may be part of the compressed message).
+ * We are now supporting the same mode that is available in IETF I-D
+ * syslog-transport-tls-05 (current at the time of this writing). This also
+ * eases things when we go ahead and implement that framing. I have now made
+ * available two cases where this framing is used: either by explitely
+ * specifying it in the config file or implicitely when sending a compressed
+ * message. In the later case, compressed and uncompressed messages within
+ * the same session have different framings. If it is explicitely set to
+ * octet-counting, only this framing mode is used within the session.
+ * rgerhards, 2006-12-07
+ */
+static rsRetVal
+TCPSendBldFrame(tcpclt_t *pThis, char **pmsg, size_t *plen, int *pbMustBeFreed)
+{
+	DEFiRet;
+	TCPFRAMINGMODE framingToUse;
+	int bIsCompressed;
+	size_t len;
+	char *msg;
+	char *buf = NULL;	/* if this is non-NULL, it MUST be freed before return! */
+
+	assert(plen != NULL);
+	assert(pbMustBeFreed != NULL);
+	assert(pmsg != NULL);
+
+	msg = *pmsg;
+	len = *plen;
+	bIsCompressed = *msg == 'z';	/* cache this, so that we can modify the message buffer */
+	/* select framing for this record. If we have a compressed record, we always need to
+	 * use octet counting because the data potentially contains all control characters
+	 * including LF.
+	 */
+	framingToUse = bIsCompressed ? TCP_FRAMING_OCTET_COUNTING : pThis->tcp_framing;
+
+	/* now check if we need to add a line terminator. We need to
+	 * copy the string in memory in this case, this is probably
+	 * quicker than using writev and definitely quicker than doing
+	 * two socket calls.
+	 * rgerhards 2005-07-22
+	 *
+	 * Some messages already contain a \n character at the end
+	 * of the message. We append one only if we there is not
+	 * already one. This seems the best fit, though this also
+	 * means the message does not arrive unaltered at the final
+	 * destination. But in the spirit of legacy syslog, this is
+	 * probably the best to do...
+	 * rgerhards 2005-07-20
+	 */
+
+	/* Build frame based on selected framing */
+	if(framingToUse == TCP_FRAMING_OCTET_STUFFING) {
+		if((*(msg+len-1) != '\n')) {
+			/* in the malloc below, we need to add 2 to the length. The
+			 * reason is that we a) add one character and b) len does
+			 * not take care of the '\0' byte. Up until today, it was just
+			 * +1 , which caused rsyslogd to sometimes dump core.
+			 * I have added this comment so that the logic is not accidently
+			 * changed again. rgerhards, 2005-10-25
+			 */
+			if((buf = malloc((len + 2) * sizeof(char))) == NULL) {
+				/* extreme mem shortage, try to solve
+				 * as good as we can. No point in calling
+				 * any alarms, they might as well run out
+				 * of memory (the risk is very high, so we
+				 * do NOT risk that). If we have a message of
+				 * more than 1 byte (what I guess), we simply
+				 * overwrite the last character.
+				 * rgerhards 2005-07-22
+				 */
+				if(len > 1) {
+					*(msg+len-1) = '\n';
+				} else {
+					/* we simply can not do anything in
+					 * this case (its an error anyhow...).
+					 */
+				}
+			} else {
+				/* we got memory, so we can copy the message */
+				memcpy(buf, msg, len); /* do not copy '\0' */
+				*(buf+len) = '\n';
+				*(buf+len+1) = '\0';
+				msg = buf; /* use new one */
+				++len; /* care for the \n */
+			}
+		}
+	} else {
+		/* Octect-Counting
+		 * In this case, we need to always allocate a buffer. This is because
+		 * we need to put a header in front of the message text
+		 */
+		char szLenBuf[16];
+		int iLenBuf;
+
+		/* important: the printf-mask is "%d<sp>" because there must be a
+		 * space after the len!
+		 *//* The chairs of the IETF syslog-sec WG have announced that it is
+		 * consensus to do the octet count on the SYSLOG-MSG part only. I am
+		 * now changing the code to reflect this. Hopefully, it will not change
+		 * once again (there can no compatibility layer programmed for this).
+		 * To be on the save side, I just comment the code out. I mark these
+		 * comments with "IETF20061218".
+		 * rgerhards, 2006-12-19
+		 */
+		iLenBuf = snprintf(szLenBuf, sizeof(szLenBuf)/sizeof(char), "%d ", (int) len);
+		/* IETF20061218 iLenBuf =
+		  snprintf(szLenBuf, sizeof(szLenBuf)/sizeof(char), "%d ", len + iLenBuf);*/
+
+		if((buf = malloc((len + iLenBuf) * sizeof(char))) == NULL) {
+			/* we are out of memory. This is an extreme situation. We do not
+			 * call any alarm handlers because they most likely run out of mem,
+			 * too. We are brave enough to call debug output, though. Other than
+			 * that, there is nothing left to do. We can not sent the message (as
+			 * in case of the other framing, because the message is incomplete.
+			 * We could, however, send two chunks (header and text separate), but
+			 * that would cause a lot of complexity in the code. So we think it
+			 * is appropriate enough to just make sure we do not crash in this
+			 * very unlikely case. For this, it is justified just to loose
+			 * the message. Rgerhards, 2006-12-07
+			 */
+			 dbgprintf("Error: out of memory when building TCP octet-counted "
+				 "frame. Message is lost, trying to continue.\n");
+			ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
+		}
+
+		 memcpy(buf, szLenBuf, iLenBuf); /* header */
+		 memcpy(buf + iLenBuf, msg, len); /* message */
+		 len += iLenBuf;	/* new message size */
+		 msg = buf;	/* set message buffer */
+	}
+
+	/* frame building complete, on to actual sending */
+
+	*plen = len;
+	if(buf == NULL) {
+		/* msg not modified */
+		*pbMustBeFreed = 0;
+	} else {
+		*pmsg = msg;
+		*pbMustBeFreed = 1;
+	}
+
+finalize_it:
+	RETiRet;
+}
+
+
+/* Sends a TCP message. It is first checked if the
+ * session is open and, if not, it is opened. Then the send
+ * is tried. If it fails, one silent re-try is made. If the send
+ * fails again, an error status (-1) is returned. If all goes well,
+ * 0 is returned. The TCP session is NOT torn down.
+ * For now, EAGAIN is ignored (causing message loss) - but it is
+ * hard to do something intelligent in this case. With this
+ * implementation here, we can not block and/or defer. Things are
+ * probably a bit better when we move to liblogging. The alternative
+ * would be to enhance the current select server with buffering and
+ * write descriptors. This seems not justified, given the expected
+ * short life span of this code (and the unlikeliness of this event).
+ * rgerhards 2005-07-06
+ * This function is now expected to stay. Libloging won't be used for
+ * that purpose. I have added the param "len", because it is known by the
+ * caller and so saves us some time. Also, it MUST be given because there
+ * may be NULs inside msg so that we can not rely on strlen(). Please note
+ * that the restrictions outlined above do not existin in multi-threaded
+ * mode, which we assume will now be most often used. So there is no
+ * real issue with the potential message loss in single-threaded builds.
+ * rgerhards, 2006-11-30
+ * I greatly restructured the function to be more generic and work
+ * with function pointers. So it now can be used with any type of transport,
+ * as long as it follows stream semantics. This was initially done to 
+ * support plain TCP and GSS via common code.
+ */
+static int
+Send(tcpclt_t *pThis, void *pData, char *msg, size_t len)
+{
+	DEFiRet;
+	int bDone = 0;
+	int retry = 0;
+	int bMsgMustBeFreed = 0;/* must msg be freed at end of function? 0 - no, 1 - yes */
+
+	ISOBJ_TYPE_assert(pThis, tcpclt);
+	assert(pData != NULL);
+	assert(msg != NULL);
+	assert(len > 0);
+
+	CHKiRet(TCPSendBldFrame(pThis, &msg, &len, &bMsgMustBeFreed));
+
+	while(!bDone) { /* loop is broken when send succeeds or error occurs */
+		CHKiRet(pThis->initFunc(pData));
+		iRet = pThis->sendFunc(pData, msg, len);
+
+		if(iRet == RS_RET_OK || retry > 0) {
+			/* we are done - either we succeeded or the retry failed */
+			bDone = 1;
+		} else { /* OK, one retry */
+			++retry;
+			CHKiRet(pThis->prepRetryFunc(pData)); /* try to recover */
+		}
+	}
+
+finalize_it:
+	if(bMsgMustBeFreed)
+		free(msg);
+	RETiRet;
+}
+
+
+/* set functions */
+static rsRetVal
+SetSendInit(tcpclt_t *pThis, rsRetVal (*pCB)(void*))
+{
+	DEFiRet;
+	pThis->initFunc = pCB;
+	RETiRet;
+}
+static rsRetVal
+SetSendPrepRetry(tcpclt_t *pThis, rsRetVal (*pCB)(void*))
+{
+	DEFiRet;
+	pThis->prepRetryFunc = pCB;
+	RETiRet;
+}
+static rsRetVal
+SetSendFrame(tcpclt_t *pThis, rsRetVal (*pCB)(void*, char*, size_t))
+{
+	DEFiRet;
+	pThis->sendFunc = pCB;
+	RETiRet;
+}
+static rsRetVal
+SetFraming(tcpclt_t *pThis, TCPFRAMINGMODE framing)
+{
+	DEFiRet;
+	pThis->tcp_framing = framing;
+	RETiRet;
+}
+
+
+/* Standard-Constructor
+ */
+BEGINobjConstruct(tcpclt) /* be sure to specify the object type also in END macro! */
+ENDobjConstruct(tcpclt)
+
+
+/* ConstructionFinalizer
+ */
+static rsRetVal
+tcpcltConstructFinalize(tcpclt_t __attribute__((unused)) *pThis)
+{
+	DEFiRet;
+	ISOBJ_TYPE_assert(pThis, tcpclt);
+
+	RETiRet;
+}
+
+
+/* destructor for the tcpclt object */
+BEGINobjDestruct(tcpclt) /* be sure to specify the object type also in END and CODESTART macros! */
+CODESTARTobjDestruct(tcpclt)
+
+ENDobjDestruct(tcpclt)
+
+
+/* ------------------------------ handling the interface plumbing ------------------------------ */
+
+/* queryInterface function
+ * rgerhards, 2008-03-12
+ */
+BEGINobjQueryInterface(tcpclt)
+CODESTARTobjQueryInterface(tcpclt)
+	if(pIf->ifVersion != tcpcltCURR_IF_VERSION) { /* check for current version, increment on each change */
+		ABORT_FINALIZE(RS_RET_INTERFACE_NOT_SUPPORTED);
+	}
+
+	/* ok, we have the right interface, so let's fill it
+	 * Please note that we may also do some backwards-compatibility
+	 * work here (if we can support an older interface version - that,
+	 * of course, also affects the "if" above).
+	 */
+	pIf->Construct = tcpcltConstruct;
+	pIf->ConstructFinalize = tcpcltConstructFinalize;
+	pIf->Destruct = tcpcltDestruct;
+
+	pIf->CreateSocket = CreateSocket;
+	pIf->Send = Send;
+
+	/* set functions */
+	pIf->SetSendInit = SetSendInit;
+	pIf->SetSendFrame = SetSendFrame;
+	pIf->SetSendPrepRetry = SetSendPrepRetry;
+	pIf->SetFraming = SetFraming;
+
+finalize_it:
+ENDobjQueryInterface(tcpclt)
+
+
+/* exit our class
+ * rgerhards, 2008-03-10
+ */
+BEGINObjClassExit(tcpclt, OBJ_IS_LOADABLE_MODULE) /* CHANGE class also in END MACRO! */
+CODESTARTObjClassExit(tcpclt)
+	/* release objects we no longer need */
+//objRelease(net, LM_NET_FILENAME);
+ENDObjClassExit(tcpclt)
+
+
+/* Initialize our class. Must be called as the very first method
+ * before anything else is called inside this class.
+ * rgerhards, 2008-02-29
+ */
+BEGINObjClassInit(tcpclt, 1, OBJ_IS_LOADABLE_MODULE) /* class, version - CHANGE class also in END MACRO! */
+	/* request objects we use */
+//CHKiRet(objUse(net, LM_NET_FILENAME));
+
+	/* set our own handlers */
+	OBJSetMethodHandler(objMethod_CONSTRUCTION_FINALIZER, tcpcltConstructFinalize);
+ENDObjClassInit(tcpclt)
+
+
+/* --------------- here now comes the plumbing that makes as a library module --------------- */
+
+
+BEGINmodExit
+CODESTARTmodExit
+	/* de-init in reverse order! */
+	tcpcltClassExit();
+ENDmodExit
+
+
+BEGINqueryEtryPt
+CODESTARTqueryEtryPt
+CODEqueryEtryPt_STD_LIB_QUERIES
+ENDqueryEtryPt
+
+
+BEGINmodInit()
+CODESTARTmodInit
+	*ipIFVersProvided = CURR_MOD_IF_VERSION; /* we only support the current interface specification */
+
+	/* Initialize all classes that are in our module - this includes ourselfs */
+	CHKiRet(tcpcltClassInit(pModInfo)); /* must be done after tcps_sess, as we use it */
+ENDmodInit
+
+
+/*
+ * vi:set ai:
+ */
diff --git a/tcpclt.h b/tcpclt.h
new file mode 100644
index 00000000..9f1f4c5f
--- /dev/null
+++ b/tcpclt.h
@@ -0,0 +1,67 @@
+/* tcpclt.h
+ *
+ * This are the definitions for the TCP based clients class.
+ *
+ * File begun on 2007-07-21 by RGerhards (extracted from syslogd.c)
+ *
+ * Copyright 2007, 2008 Rainer Gerhards and Adiscon GmbH.
+ *
+ * This file is part of rsyslog.
+ *
+ * Rsyslog 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.
+ *
+ * Rsyslog 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 Rsyslog.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * A copy of the GPL can be found in the file "COPYING" in this distribution.
+ */
+#ifndef	TCPCLT_H_INCLUDED
+#define	TCPCLT_H_INCLUDED 1
+
+#include "tcpsyslog.h"
+#include "obj.h"
+
+/* the tcpclt object */
+typedef struct tcpclt_s {
+	BEGINobjInstance;	/**< Data to implement generic object - MUST be the first data element! */
+	TCPFRAMINGMODE tcp_framing;
+	/* session specific callbacks */
+	rsRetVal (*initFunc)(void*);
+	rsRetVal (*sendFunc)(void*, char*, size_t);
+	rsRetVal (*prepRetryFunc)(void*);
+} tcpclt_t;
+
+
+/* interfaces */
+BEGINinterface(tcpclt) /* name must also be changed in ENDinterface macro! */
+	rsRetVal (*Construct)(tcpclt_t **ppThis);
+	rsRetVal (*ConstructFinalize)(tcpclt_t __attribute__((unused)) *pThis);
+	rsRetVal (*Destruct)(tcpclt_t **ppThis);
+	int (*Send)(tcpclt_t *pThis, void*pData, char*msg, size_t len);
+	int (*CreateSocket)(struct addrinfo *addrDest);
+	/* set methods */
+	rsRetVal (*SetSendInit)(tcpclt_t*, rsRetVal (*)(void*));
+	rsRetVal (*SetSendFrame)(tcpclt_t*, rsRetVal (*)(void*, char*, size_t));
+	rsRetVal (*SetSendPrepRetry)(tcpclt_t*, rsRetVal (*)(void*));
+	rsRetVal (*SetFraming)(tcpclt_t*, TCPFRAMINGMODE framing);
+ENDinterface(tcpclt)
+#define tcpcltCURR_IF_VERSION 1 /* increment whenever you change the interface structure! */
+
+
+/* prototypes */
+PROTOTYPEObj(tcpclt);
+
+/* the name of our library binary */
+#define LM_TCPCLT_FILENAME "lmtcpclt"
+
+#endif /* #ifndef TCPCLT_H_INCLUDED */
+/* vim:set ai:
+ */
diff --git a/tcpsrv.c b/tcpsrv.c
index 85d0c670..0f87165d 100644
--- a/tcpsrv.c
+++ b/tcpsrv.c
@@ -625,13 +625,11 @@ Run(tcpsrv_t *pThis)
 }
 
 
-
-
 /* Standard-Constructor
  */
 BEGINobjConstruct(tcpsrv) /* be sure to specify the object type also in END macro! */
 	pThis->pSocksLstn = NULL;
-	pThis->iSessMax = 200; // TODO: useful default ;)
+	pThis->iSessMax = 200; /* TODO: useful default ;) */
 ENDobjConstruct(tcpsrv)
 
 
@@ -753,7 +751,6 @@ SetUsrP(tcpsrv_t *pThis, void *pUsr)
 }
 
 
-
 /* queryInterface function
  * rgerhards, 2008-02-29
  */
diff --git a/tcpsyslog.c b/tcpsyslog.c
index b521eac2..d00731d3 100644
--- a/tcpsyslog.c
+++ b/tcpsyslog.c
@@ -1,5 +1,6 @@
 /* tcpsyslog.c
- * This is the implementation of TCP-based syslog.
+ * This is the implementation of TCP-based syslog. It includes those
+ * (few) things that both clients and servers need.
  *
  * File begun on 2007-07-20 by RGerhards (extracted from syslogd.c)
  * This file is under development and has not yet arrived at being fully
@@ -49,285 +50,6 @@
 #include "tcpsyslog.h"
 #include "srUtils.h"
 
-#ifdef SYSLOG_INET
 
-/* ----------------------------------------------------------------- *
- *          CODE THAT SHALL GO INTO ITS OWN MODULE  (SENDING)        *
- * ----------------------------------------------------------------- */
-
-/* Initialize TCP sockets (for sender)
- * This is done once per selector line, if not yet initialized.
- */
-int TCPSendCreateSocket(struct addrinfo *addrDest)
-{
-	int fd;
-	struct addrinfo *r; 
-	
-	r = addrDest;
-
-	while(r != NULL) {
-		fd = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
-		if (fd != -1) {
-			/* We can not allow the TCP sender to block syslogd, at least
-			 * not in a single-threaded design. That would cause rsyslogd to
-			 * loose input messages - which obviously also would affect
-			 * other selector lines, too. So we do set it to non-blocking and 
-			 * handle the situation ourselfs (by discarding messages). IF we run
-			 * dual-threaded, however, the situation is different: in this case,
-			 * the receivers and the selector line processing are only loosely
-			 * coupled via a memory buffer. Now, I think, we can afford the extra
-			 * wait time. Thus, we enable blocking mode for TCP if we compile with
-			 * pthreads. -- rgerhards, 2005-10-25
-			 * And now, we always run on multiple threads... -- rgerhards, 2007-12-20
-			 */
-			if (connect (fd, r->ai_addr, r->ai_addrlen) != 0) {
-				if(errno == EINPROGRESS) {
-					/* this is normal - will complete later select */
-					return fd;
-				} else {
-					char errStr[1024];
-					dbgprintf("create tcp connection failed, reason %s",
-						rs_strerror_r(errno, errStr, sizeof(errStr)));
-				}
-
-			}
-			else {
-				return fd;
-			}
-			close(fd);
-		}
-		else {
-			char errStr[1024];
-			dbgprintf("couldn't create send socket, reason %s", rs_strerror_r(errno, errStr, sizeof(errStr)));
-		}		
-		r = r->ai_next;
-	}
-
-	dbgprintf("no working socket could be obtained");
-
-	return -1;
-}
-
-
-
-/* Build frame based on selected framing 
- * This function was created by pulling code from TCPSend()
- * on 2007-12-27 by rgerhards. Older comments are still relevant.
- *
- * In order to support compressed messages via TCP, we must support an
- * octet-counting based framing (LF may be part of the compressed message).
- * We are now supporting the same mode that is available in IETF I-D
- * syslog-transport-tls-05 (current at the time of this writing). This also
- * eases things when we go ahead and implement that framing. I have now made
- * available two cases where this framing is used: either by explitely
- * specifying it in the config file or implicitely when sending a compressed
- * message. In the later case, compressed and uncompressed messages within
- * the same session have different framings. If it is explicitely set to
- * octet-counting, only this framing mode is used within the session.
- * rgerhards, 2006-12-07
- */
-static rsRetVal TCPSendBldFrame(TCPFRAMINGMODE rqdFraming, char **pmsg, size_t *plen, int *pbMustBeFreed)
-{
-	DEFiRet;
-	TCPFRAMINGMODE framingToUse;
-	int bIsCompressed;
-	size_t len;
-	char *msg;
-	char *buf = NULL;	/* if this is non-NULL, it MUST be freed before return! */
-
-	assert(plen != NULL);
-	assert(pbMustBeFreed != NULL);
-	assert(pmsg != NULL);
-
-	msg = *pmsg;
-	len = *plen;
-	bIsCompressed = *msg == 'z';	/* cache this, so that we can modify the message buffer */
-	/* select framing for this record. If we have a compressed record, we always need to
-	 * use octet counting because the data potentially contains all control characters
-	 * including LF.
-	 */
-	framingToUse = bIsCompressed ? TCP_FRAMING_OCTET_COUNTING : rqdFraming;
-
-	/* now check if we need to add a line terminator. We need to
-	 * copy the string in memory in this case, this is probably
-	 * quicker than using writev and definitely quicker than doing
-	 * two socket calls.
-	 * rgerhards 2005-07-22
-	 *
-	 * Some messages already contain a \n character at the end
-	 * of the message. We append one only if we there is not
-	 * already one. This seems the best fit, though this also
-	 * means the message does not arrive unaltered at the final
-	 * destination. But in the spirit of legacy syslog, this is
-	 * probably the best to do...
-	 * rgerhards 2005-07-20
-	 */
-
-	/* Build frame based on selected framing */
-	if(framingToUse == TCP_FRAMING_OCTET_STUFFING) {
-		if((*(msg+len-1) != '\n')) {
-			/* in the malloc below, we need to add 2 to the length. The
-			 * reason is that we a) add one character and b) len does
-			 * not take care of the '\0' byte. Up until today, it was just
-			 * +1 , which caused rsyslogd to sometimes dump core.
-			 * I have added this comment so that the logic is not accidently
-			 * changed again. rgerhards, 2005-10-25
-			 */
-			if((buf = malloc((len + 2) * sizeof(char))) == NULL) {
-				/* extreme mem shortage, try to solve
-				 * as good as we can. No point in calling
-				 * any alarms, they might as well run out
-				 * of memory (the risk is very high, so we
-				 * do NOT risk that). If we have a message of
-				 * more than 1 byte (what I guess), we simply
-				 * overwrite the last character.
-				 * rgerhards 2005-07-22
-				 */
-				if(len > 1) {
-					*(msg+len-1) = '\n';
-				} else {
-					/* we simply can not do anything in
-					 * this case (its an error anyhow...).
-					 */
-				}
-			} else {
-				/* we got memory, so we can copy the message */
-				memcpy(buf, msg, len); /* do not copy '\0' */
-				*(buf+len) = '\n';
-				*(buf+len+1) = '\0';
-				msg = buf; /* use new one */
-				++len; /* care for the \n */
-			}
-		}
-	} else {
-		/* Octect-Counting
-		 * In this case, we need to always allocate a buffer. This is because
-		 * we need to put a header in front of the message text
-		 */
-		char szLenBuf[16];
-		int iLenBuf;
-
-		/* important: the printf-mask is "%d<sp>" because there must be a
-		 * space after the len!
-		 *//* The chairs of the IETF syslog-sec WG have announced that it is
-		 * consensus to do the octet count on the SYSLOG-MSG part only. I am
-		 * now changing the code to reflect this. Hopefully, it will not change
-		 * once again (there can no compatibility layer programmed for this).
-		 * To be on the save side, I just comment the code out. I mark these
-		 * comments with "IETF20061218".
-		 * rgerhards, 2006-12-19
-		 */
-		iLenBuf = snprintf(szLenBuf, sizeof(szLenBuf)/sizeof(char), "%d ", (int) len);
-		/* IETF20061218 iLenBuf =
-		  snprintf(szLenBuf, sizeof(szLenBuf)/sizeof(char), "%d ", len + iLenBuf);*/
-
-		if((buf = malloc((len + iLenBuf) * sizeof(char))) == NULL) {
-			/* we are out of memory. This is an extreme situation. We do not
-			 * call any alarm handlers because they most likely run out of mem,
-			 * too. We are brave enough to call debug output, though. Other than
-			 * that, there is nothing left to do. We can not sent the message (as
-			 * in case of the other framing, because the message is incomplete.
-			 * We could, however, send two chunks (header and text separate), but
-			 * that would cause a lot of complexity in the code. So we think it
-			 * is appropriate enough to just make sure we do not crash in this
-			 * very unlikely case. For this, it is justified just to loose
-			 * the message. Rgerhards, 2006-12-07
-			 */
-			 dbgprintf("Error: out of memory when building TCP octet-counted "
-				 "frame. Message is lost, trying to continue.\n");
-			ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
-		}
-
-		 memcpy(buf, szLenBuf, iLenBuf); /* header */
-		 memcpy(buf + iLenBuf, msg, len); /* message */
-		 len += iLenBuf;	/* new message size */
-		 msg = buf;	/* set message buffer */
-	}
-
-	/* frame building complete, on to actual sending */
-
-	*plen = len;
-	if(buf == NULL) {
-		/* msg not modified */
-		*pbMustBeFreed = 0;
-	} else {
-		*pmsg = msg;
-		*pbMustBeFreed = 1;
-	}
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* Sends a TCP message. It is first checked if the
- * session is open and, if not, it is opened. Then the send
- * is tried. If it fails, one silent re-try is made. If the send
- * fails again, an error status (-1) is returned. If all goes well,
- * 0 is returned. The TCP session is NOT torn down.
- * For now, EAGAIN is ignored (causing message loss) - but it is
- * hard to do something intelligent in this case. With this
- * implementation here, we can not block and/or defer. Things are
- * probably a bit better when we move to liblogging. The alternative
- * would be to enhance the current select server with buffering and
- * write descriptors. This seems not justified, given the expected
- * short life span of this code (and the unlikeliness of this event).
- * rgerhards 2005-07-06
- * This function is now expected to stay. Libloging won't be used for
- * that purpose. I have added the param "len", because it is known by the
- * caller and so saves us some time. Also, it MUST be given because there
- * may be NULs inside msg so that we can not rely on strlen(). Please note
- * that the restrictions outlined above do not existin in multi-threaded
- * mode, which we assume will now be most often used. So there is no
- * real issue with the potential message loss in single-threaded builds.
- * rgerhards, 2006-11-30
- * I greatly restructured the function to be more generic and work
- * with function pointers. So it now can be used with any type of transport,
- * as long as it follows stream semantics. This was initially done to 
- * support plain TCP and GSS via common code.
- */
-int TCPSend(void *pData, char *msg, size_t len, TCPFRAMINGMODE rqdFraming,
-	    rsRetVal (*initFunc)(void*),
-	    rsRetVal (*sendFunc)(void*, char*, size_t),
-	    rsRetVal (*prepRetryFunc)(void*))
-{
-	DEFiRet;
-	int bDone = 0;
-	int retry = 0;
-	int bMsgMustBeFreed = 0;/* must msg be freed at end of function? 0 - no, 1 - yes */
-
-	assert(pData != NULL);
-	assert(msg != NULL);
-	assert(len > 0);
-
-	CHKiRet(TCPSendBldFrame(rqdFraming, &msg, &len, &bMsgMustBeFreed));
-
-	while(!bDone) { /* loop is broken when send succeeds or error occurs */
-		CHKiRet(initFunc(pData));
-		iRet = sendFunc(pData, msg, len);
-
-		if(iRet == RS_RET_OK || retry > 0) {
-			/* we are done - either we succeeded or the retry failed */
-			bDone = 1;
-		} else { /* OK, one retry */
-			++retry;
-			CHKiRet(prepRetryFunc(pData)); /* try to recover */
-		}
-	}
-
-finalize_it:
-	if(bMsgMustBeFreed)
-		free(msg);
-	RETiRet;
-}
-
-
-/* ----------------------------------------------------------------- *
- *          END OF CODE THAT SHALL GO INTO ITS OWN MODULE            *
- * ----------------------------------------------------------------- */
-
-#endif
-
-/*
- * vi:set ai:
+/* vi:set ai:
  */
diff --git a/tcpsyslog.h b/tcpsyslog.h
index c547d399..13c40a92 100644
--- a/tcpsyslog.h
+++ b/tcpsyslog.h
@@ -32,13 +32,6 @@ typedef enum _TCPFRAMINGMODE {
 		TCP_FRAMING_OCTET_COUNTING = 1  /* -transport-tls like octet count */
 	} TCPFRAMINGMODE;
 
-/* TCP Send support (shall go into its own module later) */
-int TCPSendCreateSocket(struct addrinfo *addrDest);
-int TCPSend(void *pData, char *msg, size_t len, TCPFRAMINGMODE rqdFraming,
-	    rsRetVal (*initFunc)(void*),
-	    rsRetVal (*sendFunc)(void*, char*, size_t),
-	    rsRetVal (*prepRetryFunc)(void*));
-
 #endif /* #ifndef TCPSYSLOG_H_INCLUDED */
 /*
  * vi:set ai: