@@ -53,11 +53,11 @@ } DigestState; /* *------------------------------------------------------------------- * - * Tls_DigestNew -- + * DigestStateNew -- * * This function creates a per-instance state data structure * * Returns: * Digest structure pointer @@ -65,11 +65,11 @@ * Side effects: * Creates structure * *------------------------------------------------------------------- */ -DigestState *Tls_DigestNew(Tcl_Interp *interp, int format) { +DigestState *DigestStateNew(Tcl_Interp *interp, int format) { DigestState *statePtr; statePtr = (DigestState *) ckalloc((unsigned) sizeof(DigestState)); if (statePtr != NULL) { memset(statePtr, 0, sizeof(DigestState)); @@ -89,11 +89,11 @@ } /* *------------------------------------------------------------------- * - * Tls_DigestFree -- + * DigestStateFree -- * * This function deletes a digest state structure * * Returns: * Nothing @@ -101,11 +101,11 @@ * Side effects: * Removes structure * *------------------------------------------------------------------- */ -void Tls_DigestFree(DigestState *statePtr) { +void DigestStateFree(DigestState *statePtr) { if (statePtr == (DigestState *) NULL) { return; } /* Remove pending timer */ @@ -129,11 +129,11 @@ /*******************************************************************/ /* *------------------------------------------------------------------- * - * Tls_DigestInit -- + * DigestInitialize -- * * Initialize a hash function * * Returns: * TCL_OK if successful or TCL_ERROR for failure with result set @@ -142,11 +142,11 @@ * Side effects: * No result or error message * *------------------------------------------------------------------- */ -int Tls_DigestInit(Tcl_Interp *interp, DigestState *statePtr, const EVP_MD *md, +int DigestInitialize(Tcl_Interp *interp, DigestState *statePtr, const EVP_MD *md, const EVP_CIPHER *cipher, Tcl_Obj *keyObj) { int key_len = 0, res = 0; const unsigned char *key = NULL; /* Create message digest context */ @@ -186,11 +186,11 @@ } /* *------------------------------------------------------------------- * - * Tls_DigestUpdate -- + * DigestUpdate -- * * Update a hash function with data * * Returns: * 1 if successful or 0 for failure @@ -198,11 +198,11 @@ * Side effects: * Adds buf data to hash function or sets result to error message * *------------------------------------------------------------------- */ -int Tls_DigestUpdate(DigestState *statePtr, char *buf, size_t read, int do_result) { +int DigestUpdate(DigestState *statePtr, char *buf, size_t read, int do_result) { int res = 0; if (statePtr->format & TYPE_MD) { res = EVP_DigestUpdate(statePtr->ctx, buf, read); } else if (statePtr->format & TYPE_HMAC) { @@ -218,11 +218,11 @@ } /* *------------------------------------------------------------------- * - * Tls_DigestFinialize -- + * DigestFinalize -- * * Finalize a hash function and return the message digest * * Returns: * TCL_OK if successful or TCL_ERROR for failure with result set @@ -231,11 +231,11 @@ * Side effects: * Sets result to message digest or an error message. * *------------------------------------------------------------------- */ -int Tls_DigestFinialize(Tcl_Interp *interp, DigestState *statePtr, Tcl_Obj **resultObj) { +int DigestFinalize(Tcl_Interp *interp, DigestState *statePtr, Tcl_Obj **resultObj) { unsigned char md_buf[EVP_MAX_MD_SIZE]; unsigned int md_len; int res = 0; /* Finalize hash function and calculate message digest */ @@ -350,20 +350,20 @@ if (!(statePtr->flags & CHAN_EOF)) { Tcl_Channel parent = Tcl_GetStackedChannel(statePtr->self); Tcl_Obj *resultObj; int written; - if (Digest_Finalize(statePtr->interp, statePtr, &resultObj) == TCL_OK) { + if (DigestFinalize(statePtr->interp, statePtr, &resultObj) == TCL_OK) { unsigned char *data = Tcl_GetByteArrayFromObj(resultObj, &written); Tcl_WriteRaw(parent, data, written); Tcl_DecrRefCount(resultObj); } statePtr->flags |= CHAN_EOF; } /* Clean-up */ - Tls_DigestFree(statePtr); + DigestStateFree(statePtr); return 0; } /* * Same as DigestCloseProc but with individual read and write close control @@ -409,11 +409,11 @@ read = Tcl_ReadRaw(parent, buf, toRead); /* Update hash function */ if (read > 0) { /* Have data */ - if (!Tls_DigestUpdate(statePtr, buf, (size_t) read, 0)) { + if (!DigestUpdate(statePtr, buf, (size_t) read, 0)) { Tcl_SetChannelError(statePtr->self, Tcl_ObjPrintf("Update failed: %s", REASON())); *errorCodePtr = EINVAL; return 0; } /* This is correct */ @@ -425,11 +425,11 @@ *errorCodePtr = Tcl_GetErrno(); } else if (!(statePtr->flags & CHAN_EOF)) { /* EOF */ Tcl_Obj *resultObj; - if (Tls_DigestFinialize(statePtr->interp, statePtr, &resultObj) == TCL_OK) { + if (DigestFinalize(statePtr->interp, statePtr, &resultObj) == TCL_OK) { unsigned char *data = Tcl_GetByteArrayFromObj(resultObj, &read); memcpy(buf, data, read); Tcl_DecrRefCount(resultObj); } else { @@ -467,11 +467,11 @@ if (toWrite <= 0 || statePtr->self == (Tcl_Channel) NULL) { return 0; } /* Update hash function */ - if (toWrite > 0 && !Tls_DigestUpdate(statePtr, buf, (size_t) toWrite, 0)) { + if (toWrite > 0 && !DigestUpdate(statePtr, buf, (size_t) toWrite, 0)) { Tcl_SetChannelError(statePtr->self, Tcl_ObjPrintf("Update failed: %s", REASON())); *errorCodePtr = EINVAL; return 0; } return toWrite; @@ -716,11 +716,11 @@ }; /* *---------------------------------------------------------------------- * - * Tls_DigestChannel -- + * DigestChannelHandler -- * * Create a stacked channel for a message digest transformation. * * Returns: * TCL_OK or TCL_ERROR @@ -729,11 +729,11 @@ * Adds transform to channel and sets result to channel id or error message. * *---------------------------------------------------------------------- */ static int -Tls_DigestChannel(Tcl_Interp *interp, const char *channel, const EVP_MD *md, +DigestChannelHandler(Tcl_Interp *interp, const char *channel, const EVP_MD *md, const EVP_CIPHER *cipher, int format, Tcl_Obj *keyObj) { int mode; /* OR-ed combination of TCL_READABLE and TCL_WRITABLE */ Tcl_Channel chan; DigestState *statePtr; @@ -750,19 +750,19 @@ /* Make sure to operate on the topmost channel */ chan = Tcl_GetTopChannel(chan); /* Create state data structure */ - if ((statePtr = Tls_DigestNew(interp, format)) == NULL) { + if ((statePtr = DigestStateNew(interp, format)) == NULL) { Tcl_AppendResult(interp, "Memory allocation error", (char *) NULL); return TCL_ERROR; } statePtr->self = chan; statePtr->mode = mode; /* Initialize hash function */ - if (Tls_DigestInit(interp, statePtr, md, cipher, keyObj) != TCL_OK) { + if (DigestInitialize(interp, statePtr, md, cipher, keyObj) != TCL_OK) { return TCL_ERROR; } /* Configure channel */ Tcl_SetChannelOption(interp, chan, "-translation", "binary"); @@ -771,11 +771,11 @@ } /* Stack channel, abort for error */ statePtr->self = Tcl_StackChannel(interp, &digestChannelType, (ClientData) statePtr, mode, chan); if (statePtr->self == (Tcl_Channel) NULL) { - Tls_DigestFree(statePtr); + DigestStateFree(statePtr); return TCL_ERROR; } /* Set result to channel Id */ Tcl_SetResult(interp, (char *) Tcl_GetChannelName(chan), TCL_VOLATILE); @@ -797,11 +797,11 @@ * Removes transform from channel or sets result to error message. * *---------------------------------------------------------------------- */ static int -UnstackObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { +DigestUnstackObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { Tcl_Channel chan; int mode; /* OR-ed combination of TCL_READABLE and TCL_WRITABLE */ /* Validate arg count */ if (objc != 2) { @@ -836,11 +836,11 @@ static const char *instance_fns [] = { "finalize", "update", NULL }; /* *------------------------------------------------------------------- * - * InstanceObjCmd -- + * DigestInstanceObjCmd -- * * Handler for digest command instances. Used to add data to hash * function or retrieve message digest. * * Returns: @@ -849,11 +849,11 @@ * Side effects: * Adds data to hash or returns message digest * *------------------------------------------------------------------- */ -int InstanceObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { +int DigestInstanceObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { DigestState *statePtr = (DigestState *) clientData; int fn, len = 0; char *buf = NULL; /* Validate arg count */ @@ -876,17 +876,17 @@ Tcl_WrongNumArgs(interp, 1, objv, "update data"); return TCL_ERROR; } /* Update hash function */ - if (!Tls_DigestUpdate(statePtr, buf, (size_t) len, 1)) { + if (!DigestUpdate(statePtr, buf, (size_t) len, 1)) { return TCL_ERROR; } } else { /* Finalize hash function and calculate message digest */ - if (Tls_DigestFinialize(interp, statePtr, NULL) != TCL_OK) { + if (DigestFinalize(interp, statePtr, NULL) != TCL_OK) { return TCL_ERROR; } Tcl_DeleteCommandFromToken(interp, statePtr->token); } @@ -894,11 +894,11 @@ } /* *------------------------------------------------------------------- * - * InstanceDelCallback -- + * DigestCommandDeleteHandler -- * * Callback to clean-up when digest instance command is deleted. * * Returns: * Nothing @@ -906,21 +906,21 @@ * Side effects: * Destroys state info structure * *------------------------------------------------------------------- */ -void InstanceDelCallback(ClientData clientData) { +void DigestCommandDeleteHandler(ClientData clientData) { DigestState *statePtr = (DigestState *) clientData; /* Clean-up */ - Tls_DigestFree(statePtr); + DigestStateFree(statePtr); } /* *------------------------------------------------------------------- * - * Tls_DigestInstance -- + * DigestCommandHandler -- * * Create command to allow user to add data to hash function. * * Returns: * TCL_OK or TCL_ERROR @@ -928,29 +928,29 @@ * Side effects: * Creates command or error message * *------------------------------------------------------------------- */ -int Tls_DigestInstance(Tcl_Interp *interp, Tcl_Obj *cmdObj, const EVP_MD *md, +int DigestCommandHandler(Tcl_Interp *interp, Tcl_Obj *cmdObj, const EVP_MD *md, const EVP_CIPHER *cipher, int format, Tcl_Obj *keyObj) { DigestState *statePtr; char *cmdName = Tcl_GetStringFromObj(cmdObj, NULL); /* Create state data structure */ - if ((statePtr = Tls_DigestNew(interp, format)) == NULL) { + if ((statePtr = DigestStateNew(interp, format)) == NULL) { Tcl_AppendResult(interp, "Memory allocation error", (char *) NULL); return TCL_ERROR; } /* Initialize hash function */ - if (Tls_DigestInit(interp, statePtr, md, cipher, keyObj) != TCL_OK) { + if (DigestInitialize(interp, statePtr, md, cipher, keyObj) != TCL_OK) { return TCL_ERROR; } /* Create instance command */ - statePtr->token = Tcl_CreateObjCommand(interp, cmdName, InstanceObjCmd, - (ClientData) statePtr, InstanceDelCallback); + statePtr->token = Tcl_CreateObjCommand(interp, cmdName, DigestInstanceObjCmd, + (ClientData) statePtr, DigestCommandDeleteHandler); /* Return command name */ Tcl_SetObjResult(interp, cmdObj); return TCL_OK; } @@ -959,11 +959,11 @@ /*******************************************************************/ /* *------------------------------------------------------------------- * - * Tls_DigestData -- + * DigestDataHandler -- * * Return message digest for data using user specified hash function. * * Returns: * TCL_OK or TCL_ERROR @@ -972,11 +972,11 @@ * Sets result to message digest or error message * *------------------------------------------------------------------- */ int -Tls_DigestData(Tcl_Interp *interp, Tcl_Obj *dataObj, const EVP_MD *md, +DigestDataHandler(Tcl_Interp *interp, Tcl_Obj *dataObj, const EVP_MD *md, const EVP_CIPHER *cipher, int format, Tcl_Obj *keyObj) { char *data; int data_len; DigestState *statePtr; @@ -986,34 +986,34 @@ Tcl_SetResult(interp, "No data", NULL); return TCL_ERROR; } /* Create state data structure */ - if ((statePtr = Tls_DigestNew(interp, format)) == NULL) { + if ((statePtr = DigestStateNew(interp, format)) == NULL) { Tcl_AppendResult(interp, "Memory allocation error", (char *) NULL); return TCL_ERROR; } /* Calc Digest, abort for error */ - if (Tls_DigestInit(interp, statePtr, md, cipher, keyObj) != TCL_OK || - Tls_DigestUpdate(statePtr, data, (size_t) data_len, 1) == 0 || - Tls_DigestFinialize(interp, statePtr, NULL) != TCL_OK) { - Tls_DigestFree(statePtr); + if (DigestInitialize(interp, statePtr, md, cipher, keyObj) != TCL_OK || + DigestUpdate(statePtr, data, (size_t) data_len, 1) == 0 || + DigestFinalize(interp, statePtr, NULL) != TCL_OK) { + DigestStateFree(statePtr); return TCL_ERROR; } /* Clean-up */ - Tls_DigestFree(statePtr); + DigestStateFree(statePtr); return TCL_OK; } /*******************************************************************/ /* *------------------------------------------------------------------- * - * Tls_DigestFile -- + * DigestFileHandler -- * * Return message digest for file using user specified hash function. * * Returns: * TCL_OK or TCL_ERROR @@ -1021,27 +1021,27 @@ * Side effects: * Result is message digest or error message * *------------------------------------------------------------------- */ -int Tls_DigestFile(Tcl_Interp *interp, Tcl_Obj *filename, const EVP_MD *md, +int DigestFileHandler(Tcl_Interp *interp, Tcl_Obj *filename, const EVP_MD *md, const EVP_CIPHER *cipher, int format, Tcl_Obj *keyObj) { DigestState *statePtr; Tcl_Channel chan = NULL; unsigned char buf[BUFFER_SIZE]; int res = TCL_OK, len; /* Create state data structure */ - if ((statePtr = Tls_DigestNew(interp, format)) == NULL) { + if ((statePtr = DigestStateNew(interp, format)) == NULL) { Tcl_AppendResult(interp, "Memory allocation error", (char *) NULL); return TCL_ERROR; } /* Open file channel, abort for error */ chan = Tcl_FSOpenFileChannel(interp, filename, "rb", 0444); if (chan == (Tcl_Channel) NULL) { - Tls_DigestFree(statePtr); + DigestStateFree(statePtr); return TCL_ERROR; } /* Configure channel */ if ((res = Tcl_SetChannelOption(interp, chan, "-translation", "binary")) == TCL_ERROR) { @@ -1048,36 +1048,36 @@ goto done; } Tcl_SetChannelBufferSize(chan, BUFFER_SIZE); /* Initialize hash function */ - if ((res = Tls_DigestInit(interp, statePtr, md, cipher, keyObj)) != TCL_OK) { + if ((res = DigestInitialize(interp, statePtr, md, cipher, keyObj)) != TCL_OK) { goto done; } /* Read file data and update hash function */ while (!Tcl_Eof(chan)) { len = Tcl_ReadRaw(chan, (char *) buf, BUFFER_SIZE); if (len > 0) { - if (!Tls_DigestUpdate(statePtr, &buf[0], (size_t) len, 1)) { + if (!DigestUpdate(statePtr, &buf[0], (size_t) len, 1)) { res = TCL_ERROR; goto done; } } } /* Finalize hash function and calculate message digest */ - res = Tls_DigestFinialize(interp, statePtr, NULL); + res = DigestFinalize(interp, statePtr, NULL); done: /* Close channel */ if (Tcl_Close(interp, chan) == TCL_ERROR) { res = TCL_ERROR; } /* Clean-up */ - Tls_DigestFree(statePtr); + DigestStateFree(statePtr); return res; } /*******************************************************************/ @@ -1116,11 +1116,11 @@ /* Optimal case for a digest and blob of data */ if (objc == 3 && type == TYPE_MD) { digestName = Tcl_GetStringFromObj(objv[1],NULL); if ((md = EVP_get_digestbyname(digestName)) != NULL) { - return Tls_DigestData(interp, objv[2], md, NULL, HEX_FORMAT | TYPE_MD, NULL); + return DigestDataHandler(interp, objv[2], md, NULL, HEX_FORMAT | TYPE_MD, NULL); } else { Tcl_AppendResult(interp, "Invalid digest \"", digestName, "\"", NULL); return TCL_ERROR; } } @@ -1189,17 +1189,17 @@ return TCL_ERROR; } /* Calc digest on file, stacked channel, using instance command, or data blob */ if (fileObj != NULL) { - res = Tls_DigestFile(interp, fileObj, md, cipher, format | type, keyObj); + res = DigestFileHandler(interp, fileObj, md, cipher, format | type, keyObj); } else if (channel != NULL) { - res = Tls_DigestChannel(interp, channel, md, cipher, format | type, keyObj); + res = DigestChannelHandler(interp, channel, md, cipher, format | type, keyObj); } else if (cmdObj != NULL) { - res = Tls_DigestInstance(interp, cmdObj, md, cipher, format | type, keyObj); + res = DigestCommandHandler(interp, cmdObj, md, cipher, format | type, keyObj); } else if (dataObj != NULL) { - res = Tls_DigestData(interp, dataObj, md, cipher, format | type, keyObj); + res = DigestDataHandler(interp, dataObj, md, cipher, format | type, keyObj); } return res; } /* @@ -1215,11 +1215,11 @@ * Side effects: * Sets result to message digest or error message * *------------------------------------------------------------------- */ -static int DigestObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { +static int MdObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { return DigestMain(TYPE_MD, interp, objc, objv); } static int CMACObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { return DigestMain(TYPE_CMAC, interp, objc, objv); @@ -1249,33 +1249,33 @@ Tcl_WrongNumArgs(interp, 1, objv, "data"); \ return TCL_ERROR; \ } \ } -int DigestMD4Cmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - validate_argc(objc, objv); - return Tls_DigestData(interp, objv[1], EVP_md4(), NULL, HEX_FORMAT | TYPE_MD, NULL); -} - -int DigestMD5Cmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - validate_argc(objc, objv); - return Tls_DigestData(interp, objv[1], EVP_md5(), NULL, HEX_FORMAT | TYPE_MD, NULL); -} - -int DigestSHA1Cmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - validate_argc(objc, objv); - return Tls_DigestData(interp, objv[1], EVP_sha1(), NULL, HEX_FORMAT | TYPE_MD, NULL); -} - -int DigestSHA256Cmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - validate_argc(objc, objv); - return Tls_DigestData(interp, objv[1], EVP_sha256(), NULL, HEX_FORMAT | TYPE_MD, NULL); -} - -int DigestSHA512Cmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { - validate_argc(objc, objv); - return Tls_DigestData(interp, objv[1], EVP_sha512(), NULL, HEX_FORMAT | TYPE_MD, NULL); +int MD4ObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { + validate_argc(objc, objv); + return DigestDataHandler(interp, objv[1], EVP_md4(), NULL, HEX_FORMAT | TYPE_MD, NULL); +} + +int MD5ObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { + validate_argc(objc, objv); + return DigestDataHandler(interp, objv[1], EVP_md5(), NULL, HEX_FORMAT | TYPE_MD, NULL); +} + +int SHA1ObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { + validate_argc(objc, objv); + return DigestDataHandler(interp, objv[1], EVP_sha1(), NULL, HEX_FORMAT | TYPE_MD, NULL); +} + +int SHA256ObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { + validate_argc(objc, objv); + return DigestDataHandler(interp, objv[1], EVP_sha256(), NULL, HEX_FORMAT | TYPE_MD, NULL); +} + +int SHA512ObjCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) { + validate_argc(objc, objv); + return DigestDataHandler(interp, objv[1], EVP_sha512(), NULL, HEX_FORMAT | TYPE_MD, NULL); } /* *------------------------------------------------------------------- * @@ -1290,17 +1290,18 @@ * Creates commands * *------------------------------------------------------------------- */ int Tls_DigestCommands(Tcl_Interp *interp) { - Tcl_CreateObjCommand(interp, "tls::digest", DigestObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::digest", MdObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::md", MdObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); Tcl_CreateObjCommand(interp, "tls::cmac", CMACObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); Tcl_CreateObjCommand(interp, "tls::hmac", HMACObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); - Tcl_CreateObjCommand(interp, "tls::md4", DigestMD4Cmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); - Tcl_CreateObjCommand(interp, "tls::md5", DigestMD5Cmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); - Tcl_CreateObjCommand(interp, "tls::sha1", DigestSHA1Cmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); - Tcl_CreateObjCommand(interp, "tls::sha256", DigestSHA256Cmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); - Tcl_CreateObjCommand(interp, "tls::sha512", DigestSHA512Cmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); - Tcl_CreateObjCommand(interp, "tls::unstack", UnstackObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::md4", MD4ObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::md5", MD5ObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::sha1", SHA1ObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::sha256", SHA256ObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::sha512", SHA512ObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); + Tcl_CreateObjCommand(interp, "tls::unstack", DigestUnstackObjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); return TCL_OK; }