Index: generic/tlsDigest.c
==================================================================
--- generic/tlsDigest.c
+++ generic/tlsDigest.c
@@ -374,10 +374,12 @@
  *
  *-------------------------------------------------------------------
  */
 static int DigestBlockModeProc(ClientData clientData, int mode) {
     DigestState *statePtr = (DigestState *) clientData;
+
+    dprintf("Called");
 
     if (mode == TCL_MODE_NONBLOCKING) {
 	statePtr->flags |= TLS_TCL_ASYNC;
     } else {
 	statePtr->flags &= ~(TLS_TCL_ASYNC);
@@ -402,10 +404,12 @@
  *
  *-------------------------------------------------------------------
  */
 int DigestCloseProc(ClientData clientData, Tcl_Interp *interp) {
     DigestState *statePtr = (DigestState *) clientData;
+
+    dprintf("Called");
 
     /* Cancel active timer, if any */
     if (statePtr->timer != (Tcl_TimerToken) NULL) {
 	Tcl_DeleteTimerHandler(statePtr->timer);
 	statePtr->timer = (Tcl_TimerToken) NULL;
@@ -435,10 +439,12 @@
 
 /*
  * Same as DigestCloseProc but with individual read and write close control
  */
 static int DigestClose2Proc(ClientData instanceData, Tcl_Interp *interp, int flags) {
+
+    dprintf("Called");
 
     if ((flags & (TCL_CLOSE_READ | TCL_CLOSE_WRITE)) == 0) {
 	return DigestCloseProc(instanceData, interp);
     }
     return EINVAL;
@@ -464,10 +470,12 @@
 int DigestInputProc(ClientData clientData, char *buf, int toRead, int *errorCodePtr) {
     DigestState *statePtr = (DigestState *) clientData;
     Tcl_Channel parent;
     Tcl_Size read;
     *errorCodePtr = 0;
+
+    dprintf("Called");
 
     /* Abort if nothing to process */
     if (toRead <= 0 || statePtr->self == (Tcl_Channel) NULL) {
 	return 0;
     }
@@ -528,10 +536,12 @@
  *----------------------------------------------------------------------
  */
  int DigestOutputProc(ClientData clientData, const char *buf, int toWrite, int *errorCodePtr) {
     DigestState *statePtr = (DigestState *) clientData;
     *errorCodePtr = 0;
+
+    dprintf("Called");
 
     /* Abort if nothing to process */
     if (toWrite <= 0 || statePtr->self == (Tcl_Channel) NULL) {
 	return 0;
     }
@@ -564,10 +574,12 @@
 static int DigestSetOptionProc(ClientData clientData, Tcl_Interp *interp, const char *optionName,
 	const char *optionValue) {
     DigestState *statePtr = (DigestState *) clientData;
     Tcl_Channel parent;
     Tcl_DriverSetOptionProc *setOptionProc;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
     }
@@ -602,10 +614,12 @@
 static int DigestGetOptionProc(ClientData clientData, Tcl_Interp *interp, const char *optionName,
 	Tcl_DString *optionValue) {
     DigestState *statePtr = (DigestState *) clientData;
     Tcl_Channel parent;
     Tcl_DriverGetOptionProc *getOptionProc;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
     }
@@ -639,10 +653,12 @@
  *
  *----------------------------------------------------------------------
  */
 static void DigestTimerHandler(ClientData clientData) {
     DigestState *statePtr = (DigestState *) clientData;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return;
     }
@@ -673,10 +689,12 @@
  */
 void DigestWatchProc(ClientData clientData, int mask) {
     DigestState *statePtr = (DigestState *) clientData;
     Tcl_Channel parent;
     Tcl_DriverWatchProc *watchProc;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return;
     }
@@ -720,10 +738,12 @@
  *----------------------------------------------------------------------
  */
 int DigestGetHandleProc(ClientData clientData, int direction, ClientData *handlePtr) {
     DigestState *statePtr = (DigestState *) clientData;
     Tcl_Channel parent;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
     }
@@ -747,10 +767,12 @@
  *
  *----------------------------------------------------------------------
  */
 int DigestNotifyProc(ClientData clientData, int interestMask) {
     DigestState *statePtr = (DigestState *) clientData;
+
+    dprintf("Called");
 
     /* Skip timer event as redundant */
     if (statePtr->timer != (Tcl_TimerToken) NULL) {
 	Tcl_DeleteTimerHandler(statePtr->timer);
 	statePtr->timer = (Tcl_TimerToken) NULL;
@@ -982,10 +1004,12 @@
  *
  *-------------------------------------------------------------------
  */
 void DigestCommandDeleteHandler(ClientData clientData) {
     DigestState *statePtr = (DigestState *) clientData;
+
+    dprintf("Called");
 
     /* Clean-up */
     DigestStateFree(statePtr);
 }
 

Index: generic/tlsEncrypt.c
==================================================================
--- generic/tlsEncrypt.c
+++ generic/tlsEncrypt.c
@@ -307,10 +307,12 @@
  *
  *-------------------------------------------------------------------
  */
 static int EncryptBlockModeProc(ClientData clientData, int mode) {
     EncryptState *statePtr = (EncryptState *) clientData;
+
+    dprintf("Called");
 
     if (mode == TCL_MODE_NONBLOCKING) {
 	statePtr->flags |= TLS_TCL_ASYNC;
     } else {
 	statePtr->flags &= ~(TLS_TCL_ASYNC);
@@ -335,10 +337,12 @@
  *
  *-------------------------------------------------------------------
  */
 int EncryptCloseProc(ClientData clientData, Tcl_Interp *interp) {
     EncryptState *statePtr = (EncryptState *) clientData;
+
+    dprintf("Called");
 
     /* Cancel active timer, if any */
     if (statePtr->timer != (Tcl_TimerToken) NULL) {
 	Tcl_DeleteTimerHandler(statePtr->timer);
 	statePtr->timer = (Tcl_TimerToken) NULL;
@@ -372,10 +376,12 @@
 
 /*
  * Same as EncryptCloseProc but with individual read and write close control
  */
 static int EncryptClose2Proc(ClientData instanceData, Tcl_Interp *interp, int flags) {
+    dprintf("Called");
+
     if ((flags & (TCL_CLOSE_READ | TCL_CLOSE_WRITE)) == 0) {
 	return EncryptCloseProc(instanceData, interp);
     }
     return EINVAL;
 }
@@ -403,10 +409,12 @@
     int out_len;
     Tcl_Size read;
     *errorCodePtr = 0;
     char *in_buf;
     
+    dprintf("Called");
+
     /* Abort if nothing to process */
     if (toRead <= 0 || statePtr->self == (Tcl_Channel) NULL) {
 	return 0;
     }
 
@@ -416,11 +424,12 @@
     read = Tcl_ReadRaw(parent, in_buf, (Tcl_Size) toRead);
 
     /* Update function */
     if (read > 0) {
 	/* Have data - Update function */
-	if (EncryptUpdate(statePtr->interp, statePtr->type, statePtr->ctx, (unsigned char *) buf, &out_len, (unsigned char *) in_buf, read) == TCL_OK) {
+	if (EncryptUpdate(statePtr->interp, statePtr->type, statePtr->ctx, (unsigned char *) buf,
+		&out_len, (unsigned char *) in_buf, read) == TCL_OK) {
 	    /* If have data, put in buf, otherwise tell TCL to try again */
 	    if (out_len > 0) {
 		read = (Tcl_Size) out_len;
 	    } else {
 		*errorCodePtr = EAGAIN;
@@ -472,20 +481,23 @@
  int EncryptOutputProc(ClientData clientData, const char *buf, int toWrite, int *errorCodePtr) {
     EncryptState *statePtr = (EncryptState *) clientData;
     int write = 0, out_len;
     *errorCodePtr = 0;
     char *out_buf;
+
+    dprintf("Called");
 
     /* Abort if nothing to process */
     if (toWrite <= 0 || statePtr->self == (Tcl_Channel) NULL) {
 	return 0;
     }
 
     out_buf = Tcl_Alloc((Tcl_Size) toWrite+EVP_MAX_BLOCK_LENGTH);
 
     /* Update function */
-    if (EncryptUpdate(statePtr->interp, statePtr->type, statePtr->ctx, (unsigned char *) out_buf, &out_len, (unsigned char *) buf, (Tcl_Size) toWrite) == TCL_OK) {
+    if (EncryptUpdate(statePtr->interp, statePtr->type, statePtr->ctx, (unsigned char *) out_buf,
+	    &out_len, (unsigned char *) buf, (Tcl_Size) toWrite) == TCL_OK) {
 	/* If have data, output it, otherwise tell TCL to try again */
 	if (out_len > 0) {
 	    Tcl_Channel parent = Tcl_GetStackedChannel(statePtr->self);
 	    write = (int) Tcl_WriteRaw(parent, (const char *) out_buf, (Tcl_Size) out_len);
 	    write = toWrite;
@@ -522,10 +534,12 @@
 static int EncryptSetOptionProc(ClientData clientData, Tcl_Interp *interp, const char *optionName,
 	const char *optionValue) {
     EncryptState *statePtr = (EncryptState *) clientData;
     Tcl_Channel parent;
     Tcl_DriverSetOptionProc *setOptionProc;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
     }
@@ -560,10 +574,12 @@
 static int EncryptGetOptionProc(ClientData clientData, Tcl_Interp *interp, const char *optionName,
 	Tcl_DString *optionValue) {
     EncryptState *statePtr = (EncryptState *) clientData;
     Tcl_Channel parent;
     Tcl_DriverGetOptionProc *getOptionProc;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
     }
@@ -597,10 +613,12 @@
  *
  *----------------------------------------------------------------------
  */
 static void EncryptTimerHandler(ClientData clientData) {
     EncryptState *statePtr = (EncryptState *) clientData;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return;
     }
@@ -631,10 +649,12 @@
  */
 void EncryptWatchProc(ClientData clientData, int mask) {
     EncryptState *statePtr = (EncryptState *) clientData;
     Tcl_Channel parent;
     Tcl_DriverWatchProc *watchProc;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return;
     }
@@ -678,10 +698,12 @@
  *----------------------------------------------------------------------
  */
 int EncryptGetHandleProc(ClientData clientData, int direction, ClientData *handlePtr) {
     EncryptState *statePtr = (EncryptState *) clientData;
     Tcl_Channel parent;
+
+    dprintf("Called");
 
     /* Abort if no channel */
     if (statePtr->self == (Tcl_Channel) NULL) {
 	return TCL_ERROR;
     }
@@ -705,10 +727,12 @@
  *
  *----------------------------------------------------------------------
  */
 int EncryptNotifyProc(ClientData clientData, int interestMask) {
     EncryptState *statePtr = (EncryptState *) clientData;
+
+    dprintf("Called");
 
     /* Skip timer event as redundant */
     if (statePtr->timer != (Tcl_TimerToken) NULL) {
 	Tcl_DeleteTimerHandler(statePtr->timer);
 	statePtr->timer = (Tcl_TimerToken) NULL;
@@ -958,10 +982,12 @@
  *
  *-------------------------------------------------------------------
  */
 void EncryptCommandDeleteHandler(ClientData clientData) {
     EncryptState *statePtr = (EncryptState *) clientData;
+
+    dprintf("Called");
 
     /* Clean-up */
     EncryptStateFree(statePtr);
 }