int vce_tcpcontext_init_world( void ) {
if( vce_limit.max_tcpcontext > 0 ){
vce_tcpcontext_mi = vce_init_array( sizeof( tcpcontext ), vce_limit.max_tcpcontext, "tcpctx" );
if( vce_tcpcontext_mi < 0 ) return SET_LAST_ERROR(VCE_EARRAY);
}
return SET_LAST_ERROR(VCE_NOERROR);
}
int vce_protocol_parser_text( conn_t ct ) {
conn *c = (conn*) ct.p;
int datalen, ret = 0;
char *data;
int i;
vce_sbuf_get_buffer( &c->rb, &data, &datalen );
if( datalen < 1 ) return SET_LAST_ERROR(0);
// Do I have enough characters to compose a line?
for(i=0;i<datalen;i++){
if( data[i] == '\r' && data[i+1] == '\n' && (i<(datalen-1))){
if( c->pcallback ){
ret = c->pcallback( ct, data, i );
}
vce_sbuf_shrink( &c->rb, NULL, i+2 );
SET_LAST_ERROR(0);
return ret;
} else if( data[i] == '\n' ){
if( c->pcallback ){
ret = c->pcallback( ct, data, i );
}
vce_sbuf_shrink( &c->rb, NULL, i+1 );
SET_LAST_ERROR(0);
return ret;
}
}
return 0;
}
/* set */
int vce_set_variable_length_specifier( char *out, int outmax, unsigned int len_upper, unsigned int len_lower ) {
if( len_upper == 0 ){
if( len_lower <= 0xfc ){
if(out){
if( outmax < 1 ) return SET_LAST_ERROR(VCE_EFULL);
out[0] = (unsigned char)len_lower;
}
return 1;
} else {
if(out){
if( outmax < (1+4) ) return SET_LAST_ERROR(VCE_EFULL);
out[0] = 0xfd;
SET_32BIT_INT(out+1, len_lower);
}
return 1+4;
}
} else {
if(out){
if( outmax < (1+8) ) return SET_LAST_ERROR(VCE_EFULL);
out[0] = 0xfe;
SET_32BIT_INT(out+1,len_upper);
SET_32BIT_INT(out+1+4,len_lower);
}
return 1 + 8;
}
/* not reached */
return SET_LAST_ERROR(VCE_EBUG);
}
int vce_protocol_parser_bin16( conn_t ct ) {
conn *c = ( conn *) ct.p;
int datalen, contentlen, ret=0;
char *data;
vce_sbuf_get_buffer( &c->rb, &data, &datalen );
if( datalen < 2 ) return SET_LAST_ERROR(0);
contentlen = GET_16BIT_INT( data ) & 0xffff;
// Limitting length of the record.
if(c->maxlen_record>=1 && contentlen > c->maxlen_record ) {
if(c->maxlen_warning) {
if(c->maxlen_warning(ct)<0) return SET_LAST_ERROR(VCE_EPROTO_TOOLONG);
} else {
return SET_LAST_ERROR(VCE_EPROTO_TOOLONG);
}
}
if( datalen < ( 2 + contentlen ) ) return SET_LAST_ERROR(0);
if( c->pcallback ){
ret = c->pcallback( ct, data + 2, contentlen );
}
vce_sbuf_shrink( &c->rb, NULL, contentlen + 2 );
SET_LAST_ERROR(0);
return ret;
}
/*
String array.
Format:
[VARLEN(string num)][ STRING ][ STRING ]...
STRING : [VARLEN][data]
eachmax : Max length of each strings.
If you have longer strings than this, it gives error. This function doesn't truncate string.
No null terminator.
*/
int vce_binary_push_nb_stra( char *out, int ofs, int maxlen, const char * const *stra, int num, int eachmax ) {
int headlen,i,total_l;
char lenwork[10];
if(num<0)return SET_LAST_ERROR(VCE_EINVAL);
headlen = vce_set_variable_length_specifier( lenwork,sizeof(lenwork),
0,num);
if( (ofs+headlen) > maxlen ) return SET_LAST_ERROR(VCE_EFULL);
memcpy( out + ofs, lenwork, headlen );
total_l = ofs + headlen;
for(i=0;i<num;i++){
char slenwork[10];
char sheadlen;
int sl = vce_strlenmax( stra[i], eachmax );
if( sl <0 ) return SET_LAST_ERROR(VCE_EFULL);
sheadlen = vce_set_variable_length_specifier( slenwork,
sizeof(slenwork),
0,sl);
if( (total_l+sheadlen+sl) >= maxlen ) return SET_LAST_ERROR(VCE_EFULL);
memcpy( out + total_l , slenwork, sheadlen );
memcpy( out + total_l + sheadlen , stra[i], sl );
total_l += sheadlen + sl;
}
SET_LAST_ERROR(VCE_NOERROR);
return total_l;
}
int vce_protocol_unparser_bin16( conn_t ct, char *data , int len ) {
int totallen;
char work[2];
int wable;
if( !vce_conn_is_valid(ct) ) return SET_LAST_ERROR(VCE_EINVAL);
if( len > BIN16DATA_MAX ) return SET_LAST_ERROR(VCE_ELONGINPUT);
totallen = 2 + len ;
wable = vce_conn_writable(ct);
if( wable < 0 ) return SET_LAST_ERROR(wable);
if( totallen > wable ){
return SET_LAST_ERROR( VCE_EWBFULL );
}
// write twice, but never get error (checking by writable() function beforehand
// header first
SET_16BIT_INT( work, len );
vce_conn_write( ct, work, 2 );
// content second
vce_conn_write( ct, data, len );
SET_LAST_ERROR(0);
return len+2;
}
//============================================================
// Loads the PKCS#11 driver and
// tests if the driver loaded correctly
// Returns 0 for ok otherwise error code
//============================================================
int loadAndTestDriver(const char* driver, LIBHANDLE* pLibrary, CK_SLOT_ID* slotids, int slots, CK_ULONG slot)
{
CK_TOKEN_INFO tokinfo;
CK_SLOT_INFO slotinfo;
CK_ULONG idlen, i, ok;
CK_RV rv;
int err = ERR_OK;
// initialize
*pLibrary = NULL;
memset(slotids, 0, sizeof(CK_SLOT_ID) * slots);
// try to load the driver
*pLibrary = initPKCS11Library(driver);
if(!(*pLibrary))
SET_LAST_ERROR_RETURN_CODE(ERR_PKCS_LIB_LOAD);
idlen = slots;
rv = GetSlotIds(slotids, &idlen);
ddocDebug(3, "loadAndTestDriver", "RV: %d slots: %ld", (int)rv, (long)idlen);
if (rv != CKR_OK) {
err = ERR_PKCS_SLOT_LIST;
SET_LAST_ERROR(err);
}
if ((slot < 0) || (slot >= idlen)) {
err = ERR_PKCS_WRONG_SLOT;
SET_LAST_ERROR(err);
}
// it's useful to test DLL load status this way:
ok = 0;
for(i = 0; i < idlen; i++) {
rv = GetSlotInfo(&slotinfo, slotids[i]);
if(slotinfo.flags & CKF_TOKEN_PRESENT) {
ddocDebug(3, "loadAndTestDriver", "Read Token: %ld", (long)i);
rv = GetTokenInfo(&tokinfo, slotids[i]); // if !CKR_OK test
tokinfo.label[31] = 0;
ddocDebug(3, "loadAndTestDriver", "RV: %d Token: %s", (int)rv, tokinfo.label);
if(rv != CKR_OK)
slotids[i] = INVALID_SLOTIID; // set bad slotids to 0
else
ok++; // count the good slots
} else {
slotids[i] = INVALID_SLOTIID; // no tokne in this slot
}
}
// fill other slotid's with invalid slotid
for(i = idlen; i < (CK_ULONG)slots; i++)
slotids[i] = INVALID_SLOTIID;
if(ok < slot) {
err = ERR_PKCS_CARD_READ; // if not enough good slots
SET_LAST_ERROR(err);
}
// in case of error try to unload the module and notify caller
if (err) {
if (*pLibrary)
closePKCS11Library(*pLibrary, 0);
*pLibrary = NULL;
}
return err;
}
//============================================================
// Locates and reads users certificate from smartcard
// slot - number of the slot for decryption key. On ID card allways 0
// ppCert - address for newly allocated certificate pointer
// return error code or ERR_OK
//============================================================
EXP_OPTION int findUsersCertificate(int slot, X509** ppCert)
{
int err = ERR_OK, l1, l2;
LIBHANDLE pLibrary = 0;
CK_RV rv = 0;
CK_SLOT_ID slotids[20], slId;
CK_OBJECT_HANDLE hCert;
CK_SESSION_HANDLE hSession = 0;
CK_ULONG certLen;
CK_BYTE certData[2048];
char driver[100];
*ppCert = 0;
snprintf(driver, sizeof(driver), "DIGIDOC_DRIVER_%d_FILE", ConfigItem_lookup_int("DIGIDOC_DEFAULT_DRIVER", 1));
ddocDebug(3, "findUsersCertificate", "Slot: %d Driver nr: %d - %s", slot,
ConfigItem_lookup_int("DIGIDOC_DEFAULT_DRIVER", 1),
ConfigItem_lookup(driver));
err = loadAndTestDriver(ConfigItem_lookup(driver),
&pLibrary, (CK_SLOT_ID*)slotids, 20, (CK_ULONG)slot);
if(err) return err;
// find the right slotid
for(l1 = l2 = 0; l1 < 20; l1++) {
if(slotids[l1] != INVALID_SLOTIID) {
if(l2 == slot)
slId = slotids[l1];
l2++;
}
}
// open session
hSession = OpenSession(slId, NULL);
if (hSession == CK_INVALID_HANDLE) { SET_LAST_ERROR(ERR_PKCS_LOGIN); return ERR_PKCS_LOGIN; }
ddocDebug(3, "findUsersCertificate", "OpenSession ok, hSession = %d", (int)hSession);
// get cert
memset(certData, 0, sizeof(certData));
certLen = sizeof(certData);
hCert = LocateCertificate(hSession, certData, &certLen, 0, 0, 0);
ddocDebug(3, "findUsersCertificate", "hCert = %d, len: %d", (int)hCert, certLen);
if (hCert == (CK_OBJECT_HANDLE)-1) { err = ERR_PKCS_CERT_LOC; SET_LAST_ERROR(err); }
// set cert data
if(certLen)
err = ddocDecodeX509Data(ppCert, certData, certLen);
ddocDebug(3, "findUsersCertificate", "RV: %d, cert: %s", (int)rv, (*ppCert ? "OK" : "NULL"));
if(hSession)
closePKCS11Library(pLibrary, hSession);
return err;
}
int vce_binary_push_nb_ia8( char *out, int ofs, int maxlen, const void *ia, int num ) {
int headlen,i;
char lenwork[10];
if(num<0)return SET_LAST_ERROR(VCE_EINVAL);
headlen = vce_set_variable_length_specifier( lenwork,sizeof(lenwork),
0,num );
if( ( ofs + headlen + num*8 ) > maxlen ) return SET_LAST_ERROR(VCE_EFULL);
for(i=0;i<num;i++){
SET_64BIT_INT( out + ofs + headlen + i*8, ((VCEI64*)ia)[i]);
}
memcpy( out + ofs, lenwork, headlen );
SET_LAST_ERROR(VCE_NOERROR);
return ofs + headlen + num*8;
}
int vce_binary_pop_nb_ia8( const char *src, int len, int ofs, VCEI64 *out, int *outlen ) {
int headlen, available = len - ofs , i;
unsigned int lu,ll;
headlen = vce_get_variable_length_specifier( src + ofs, available,
&lu, &ll );
if( headlen < 0 ) return SET_LAST_ERROR(headlen);
if( lu ) return SET_LAST_ERROR(VCE_ESUPPORT);
if( (headlen+ll*8) > available ) return SET_LAST_ERROR(VCE_ETOOSHORT);
if( ll > *outlen ) return SET_LAST_ERROR(VCE_EFULL);
for(i=0;i<ll;i++){
out[i] = GET_64BIT_INT( src +ofs + headlen + i*8 );
}
*outlen = ll;
SET_LAST_ERROR(VCE_NOERROR);
return ofs + headlen + ll*8;
}
// get signers first name
EXP_OPTION int getSignerFirstName(const SignatureInfo* pSigInfo, char* buf)
{
int err = ERR_OK, l1;
X509* cert;
char buf1[500], *p, *p2, *p1;
RETURN_IF_NULL_PARAM(pSigInfo);
RETURN_IF_NULL_PARAM(buf);
cert = getSignCertData(pSigInfo);
if (!cert) SET_LAST_ERROR_RETURN_CODE(ERR_CERT_INVALID);
l1 = sizeof(buf1);
err = getCertSubjectName(cert, buf1, &l1);
if (err != ERR_OK) SET_LAST_ERROR_RETURN_CODE(err);
p = strstr(buf1, "CN=");
if (p) {
p1 = strchr(p, ',');
if(!p1)
p1 = strchr(p, '/');
if (p1) {
p1 += 1;
p2 = strchr(p1, ',');
if(!p2)
p2 = strchr(p1, '/');
if(p2) {
strncpy(buf, p1, p2-p1);
buf[p2-p1] = 0;
err = ERR_OK;
}
}
}
if (err != ERR_OK) SET_LAST_ERROR(err);
return err;
}
// get signers id-code
EXP_OPTION int getSignerCode(const SignatureInfo* pSigInfo, char* buf)
{
int err, l1;
X509* cert;
char buf1[500], *p;
RETURN_IF_NULL_PARAM(pSigInfo);
RETURN_IF_NULL_PARAM(buf);
cert = getSignCertData(pSigInfo);
if (!cert) SET_LAST_ERROR_RETURN_CODE(ERR_CERT_INVALID);
l1 = sizeof(buf1);
err = getCertSubjectName(cert, buf1, &l1);
if (err != ERR_OK) SET_LAST_ERROR_RETURN_CODE(err);
err = ERR_CERT_READ;
p = strstr(buf1, "CN=");
if (p) {
p = strchr(p, ',');
if(p) {
p = strchr(p+1, ',');
if(p) {
strncpy(buf, p+1, 11);
buf[11] = 0;
err = ERR_OK;
}
} else { // no comma -> no id-code !
buf[0] = 0;
// is this really an error ?
err = ERR_WRONG_CERT;
}
}
if (err != ERR_OK) SET_LAST_ERROR(err);
return err;
}
EXP_OPTION int getSignerCN(const SignatureInfo* pSigInfo, char* buf, int bUTF8)
{
int err = ERR_OK, l1;
X509* cert;
char buf1[500], *p, *p2, buf2[500];
RETURN_IF_NULL_PARAM(pSigInfo);
RETURN_IF_NULL_PARAM(buf);
cert = getSignCertData(pSigInfo);
if (!cert) SET_LAST_ERROR_RETURN_CODE(ERR_CERT_INVALID);
l1 = sizeof(buf1);
err = getCertSubjectName(cert, buf1, &l1);
if (err != ERR_OK) SET_LAST_ERROR_RETURN_CODE(err);
if(!bUTF8) {
l1 = sizeof(buf2);
utf82ascii(buf1, buf2, &l1);
strncpy(buf1, buf2, sizeof(buf1));
}
err = ERR_CERT_READ;
p = strstr(buf1, "CN=");
if (p) {
p += 3;
p2 = strchr(p, '/');
if(!p2)
p2 = p + strlen(p);
if (p2) {
strncpy(buf, p, p2-p);
buf[p2-p] = 0;
err = ERR_OK;
}
}
if (err != ERR_OK) SET_LAST_ERROR(err);
return err;
}
//--------------------------------------------------
// Calculates files SHA1 digest
// szFileName - file name
// nDigestType - digest type. Supports only SHA1 (0)
// pDigestBuf - buffer to store the digest
// nDigestLen - buffer size, must be at least 20
// will be updated by actual digest length
// returns error code or ERR_OK for success
//--------------------------------------------------
EXP_OPTION int calculateDigest(const byte* data, int nDataLen, int nDigestType,
byte* pDigestBuf, int* nDigestLen)
{
int err = ERR_OK;
RETURN_IF_NULL_PARAM(data);
RETURN_IF_NULL_PARAM(pDigestBuf);
RETURN_IF_NULL_PARAM(nDigestLen);
memset(pDigestBuf, 0, *nDigestLen);
if(nDigestType == DIGEST_SHA1) {
if(*nDigestLen >= SHA_DIGEST_LENGTH) {
*nDigestLen = SHA_DIGEST_LENGTH;
SHA1(data, nDataLen, pDigestBuf);
}
}//AM 22.04.08
else if(nDigestType == DIGEST_SHA256) {
if(*nDigestLen >= SHA256_DIGEST_LENGTH) {
*nDigestLen = SHA256_DIGEST_LENGTH;
SHA256(data, nDataLen, pDigestBuf);
}
else
err = ERR_DIGEST_LEN;
}
else
err = ERR_UNSUPPORTED_DIGEST;
if (err != ERR_OK) SET_LAST_ERROR(err);
return err;
}
//============================================================
// Reads in an OCSP Response file in DER format
// szFileName - OCSP response file name
//============================================================
int ReadOCSPResponse(OCSP_RESPONSE **newOCSP_RESPONSE, const char* szFileName)
{
BIO *bin = NULL;
OCSP_RESPONSE *resp = NULL;
int err = ERR_OK;
ddocDebug(4, "ReadOCSPResponse", "File: %s", szFileName);
RETURN_IF_NULL_PARAM(newOCSP_RESPONSE);
RETURN_IF_NULL_PARAM(szFileName);
if((bin = BIO_new_file(szFileName, "rb")) != NULL) {
ddocDebug(4, "ReadOCSPResponse", "File opened");
resp = d2i_OCSP_RESPONSE_bio(bin, NULL);
BIO_free(bin);
if (resp == NULL) {
err = ERR_OCSP_WRONG_VERSION;
}
} else {
ddocDebug(4, "ReadOCSPResponse", "Cannot read file:%s", szFileName);
err =ERR_FILE_READ;
}
if (err != ERR_OK) SET_LAST_ERROR(err);
*newOCSP_RESPONSE = resp;
return err;
}
int vce_binary_pop_nb_ia1( const char *src, int len, int ofs, char *out, int *outlen ) {
int headlen, available = len - ofs;
unsigned int lu,ll;
headlen = vce_get_variable_length_specifier( src + ofs, available,
&lu,&ll );
if( headlen < 0 ) return SET_LAST_ERROR(headlen);
if( lu ) return SET_LAST_ERROR(VCE_ESUPPORT);
if( (headlen+ll) > available ) return SET_LAST_ERROR(VCE_ETOOSHORT);
if( ll > *outlen ) return SET_LAST_ERROR(VCE_EFULL);
memcpy( out, src + ofs + headlen, ll );
*outlen = ll;
SET_LAST_ERROR(VCE_NOERROR);
return ofs + headlen + ll;
}
int vce_tcpcontext_get_next_conn_serial() {
vce_conn_serial++;
if( vce_conn_serial == 0 ){
vce_conn_serial = 1;
}
SET_LAST_ERROR(VCE_NOERROR);
return vce_conn_serial;
}
int vce_finalize( void ) {
int e = 0;
if( vce_tcpcontext_fin_world() < 0 ) e = 1;
if( vce_conn_fin_world() < 0 ) e = 1;
if( vce_array_fin_world() < 0 ) e = 1;
VCEFREE( vce_sendbuf_work );
VCEFREE( vce_recvbuf_work );
VCE_ERROUT_V0( NOTE_VCE_FINALIZED );
if( e ) {
return SET_LAST_ERROR(VCE_EFINALIZE);
} else {
return SET_LAST_ERROR(0);
}
}
int vce_protocol_unparser_text( conn_t ct, char *data, int len ) {
int totallen = len + 1;
int rest = vce_conn_writable( ct );
if( !vce_conn_is_valid(ct) ) return SET_LAST_ERROR(VCE_EINVAL);
// Do I have room to store newline?
if( rest < 0 ) return SET_LAST_ERROR(rest);
if( rest < totallen ) return SET_LAST_ERROR(VCE_EWBFULL);
// write body and newline
vce_conn_write( ct, data, len );
vce_conn_write( ct, "\n", 1 );
return totallen;
}
int vce_protocol_parser_bin32( conn_t ct ) {
conn *c = ( conn * ) ct.p;
int datalen , ret = 0;
unsigned int contentlen;
char *data;
vce_sbuf_get_buffer( &c->rb, &data, &datalen );
if( datalen < 4 ) return SET_LAST_ERROR(0);
if( datalen > BIN32DATA_MAX ) return SET_LAST_ERROR(VCE_EPROTO_TOOLONG);
contentlen = GET_32BIT_INT( data ) & 0xffffffff;
if( contentlen > BIN32DATA_MAX ) return SET_LAST_ERROR(VCE_EPROTO_TOOLONG);
if( datalen < ( 4 + contentlen ) ) return SET_LAST_ERROR(0);
if( c->pcallback ){
ret = c->pcallback( ct, data + 4, contentlen );
}
vce_sbuf_shrink( &c->rb, NULL, contentlen + 4 );
SET_LAST_ERROR(0);
return ret;
}
BOOL
APIENTRY
GetConsoleDisplayMode(
OUT LPDWORD lpModeFlags
)
/*++
Description:
This routine returns the display mode of the console.
Parameters:
lpModeFlags - pointer to store display mode in.
Return value:
TRUE - The operation was successful.
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
CONSOLE_API_MSG m;
PCONSOLE_GETDISPLAYMODE_MSG a = &m.u.GetConsoleDisplayMode;
a->ConsoleHandle = GET_CONSOLE_HANDLE;
CsrClientCallServer( (PCSR_API_MSG)&m,
NULL,
CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX,
ConsolepGetDisplayMode
),
sizeof( *a )
);
if (!NT_SUCCESS( m.ReturnValue)) {
SET_LAST_NT_ERROR(m.ReturnValue);
return FALSE;
}
else {
try {
*lpModeFlags = a->ModeFlags;
}
except( EXCEPTION_EXECUTE_HANDLER ) {
SET_LAST_ERROR(ERROR_INVALID_ACCESS);
return FALSE;
}
return TRUE;
}
}
//--------------------------------------------------
// Decodes a single hex digit
// h - hex digit
// return binary value
//--------------------------------------------------
byte h2b(char h)
{
int i;
for(i = 0; i < 16; i++) {
if(g_hexChars[i] == h || g_hexChars[i] == toupper(h))
return (byte)i;
}
// if not found then return an error
ddocDebug(1, "h2b", "Invalid hex byte: %c", h);
SET_LAST_ERROR(ERR_BAD_PARAM);
return 0; // MSTERN: incorrect, VS - yes return -1 if not found. This is an error code
}
/* get */
int vce_get_variable_length_specifier( const char *src, int srcmax, unsigned int *len_upper, unsigned int *len_lower ) {
unsigned char top;
if( srcmax < 1 ) return SET_LAST_ERROR(VCE_ETOOSHORT);
top = src[0];
if( top <= 0xfc ){
*len_upper = 0;
*len_lower = GET_8BIT_INT( src ) & 0xff;
return 1;
} else if( top == 0xfd ){
if( srcmax < (1+4)) return SET_LAST_ERROR(VCE_ETOOSHORT);
*len_upper = 0;
*len_lower = GET_32BIT_INT( src+1);
return 1+4;
} else if( top == 0xfe ){
if( srcmax < (1+8)) return SET_LAST_ERROR(VCE_ETOOSHORT);
*len_upper = GET_32BIT_INT(src+1);
*len_lower = GET_32BIT_INT(src+1+4);
return 1+8;
return SET_LAST_ERROR(VCE_NOERROR);
} else if( top == 0xff ){
*len_lower = *len_upper = 0;
return SET_LAST_ERROR(VCE_ESUPPORT);
}
/* not reached */
return SET_LAST_ERROR(VCE_EBUG);
}
int vce_binary_pop_nb_stra( const char *src, int len, int ofs, char **out, int *strnum, int eachmax ) {
int headlen, available = len - ofs;
int i,total_l;
unsigned int lu,ll;
headlen = vce_get_variable_length_specifier( src + ofs, available,
&lu, &ll );
if( headlen < 0 ) return SET_LAST_ERROR(headlen);
if( lu ) return SET_LAST_ERROR(VCE_ESUPPORT);
if( *strnum < ll ){
return SET_LAST_ERROR(VCE_EFULL);
}
total_l = ofs + headlen;
for(i=0;i<ll;i++){
unsigned int slu, sll;
int sheadlen;
sheadlen = vce_get_variable_length_specifier( src + total_l,
len - total_l,
&slu, &sll );
if( slu ) return SET_LAST_ERROR(VCE_ESUPPORT);
if( sll > (eachmax-1) ){
return SET_LAST_ERROR(VCE_EFULL);
}
memcpy( out[i], src + total_l + sheadlen, sll );
out[i][sll] = 0; /* null byte */
total_l += sheadlen + sll;
}
*strnum = ll;
SET_LAST_ERROR(VCE_NOERROR);
return total_l;
}
int vce_initialize( void ) {
int ret;
if( vce_socket_library_ok == 0 ) {
if( vce_socket_lib_os_init() == 0 ) {
vce_socket_library_ok = 1;
}
}
vce_update_time();
// fixed size of send/recv buffer.
vce_sendbuf_work = (char*) VCEMALLOC( vce_limit.sendbuf_work_size );
vce_recvbuf_work = (char*) VCEMALLOC( vce_limit.recvbuf_work_size );
if( !vce_sendbuf_work || !vce_recvbuf_work ) {
if( vce_sendbuf_work ) VCEFREE( vce_sendbuf_work );
if( vce_recvbuf_work ) VCEFREE( vce_recvbuf_work );
return SET_LAST_ERROR(VCE_EMEM);
}
if( (ret = vce_array_init_world()) < 0 ) {
return SET_LAST_ERROR(ret);
}
if( (ret = vce_conn_init_world()) < 0 ) {
vce_array_fin_world();
return SET_LAST_ERROR(ret);
}
if( ( ret = vce_tcpcontext_init_world())<0) {
vce_conn_fin_world();
vce_array_fin_world();
return SET_LAST_ERROR(ret);
}
vce_usage_set_boot_time( vce_global_time );
return SET_LAST_ERROR(0);
}
int vce_protocol_unparser_bin32( conn_t ct, char *data, int len ) {
int totallen,wable;
char work[4];
if( !vce_conn_is_valid(ct) ) return SET_LAST_ERROR(VCE_EINVAL);
if( len > BIN32DATA_MAX ) return SET_LAST_ERROR(VCE_ELONGINPUT);
totallen = 4 + len;
wable = vce_conn_writable(ct);
if( wable < 0 ) return SET_LAST_ERROR(wable);
if( totallen > wable ){
return SET_LAST_ERROR(VCE_EWBFULL);
}
SET_32BIT_INT(work, len);
vce_conn_write( ct, work, 4 );
vce_conn_write( ct, data, len );
SET_LAST_ERROR(0);
return len+4;
}
int vce_protocol_parser_through( conn_t ct ) {
conn *c = (conn*) ct.p;
char *data;
int datalen , ret = 0;
vce_sbuf_get_buffer( &c->rb, &data, &datalen );
if( datalen > 0 ){
ret = c->pcallback( ct, data , datalen );
}
vce_sbuf_shrink( &c->rb, NULL, datalen );
SET_LAST_ERROR(0);
return ret;
}
//--------------------------------------------------
// Calculates files SHA1-RSA signature
// szFileName - file name
// nDigestType - digest type. Supports only SHA1 (0)
// pSigBuf - buffer to store the signature
// nSigLen - buffer size, must be at least 128
// will be updated by actual signature length
// keyfile - name of the private key file
// passwd - private key password
// returns error code or ERR_OK for success
//--------------------------------------------------
EXP_OPTION int calculateFileSignature(const char* szFileName, int nDigestType,
byte* pSigBuf, int* nSigLen,
const char *keyfile, const char* passwd)
{
int err = ERR_OK;
EVP_MD_CTX ctx;
byte buf[FILE_BUFSIZE];
int i;
FILE *f = NULL;
EVP_PKEY* pkey = NULL;
RETURN_IF_NULL_PARAM(szFileName);
RETURN_IF_NULL_PARAM(pSigBuf);
RETURN_IF_NULL_PARAM(nSigLen);
RETURN_IF_NULL_PARAM(keyfile);
RETURN_IF_NULL_PARAM(passwd);
memset(pSigBuf, 0, *nSigLen);
if(nDigestType == DIGEST_SHA1) {
if(*nSigLen >= SIGNATURE_LEN) {
if((err = ReadPrivateKey(&pkey, keyfile, passwd, FILE_FORMAT_PEM)) == ERR_OK) {
if((f = fopen(szFileName,"rb")) != NULL) {
EVP_SignInit(&ctx, EVP_sha1());
for (;;) {
i = fread(buf, sizeof(char), FILE_BUFSIZE, f);
if (i <= 0) break;
EVP_SignUpdate (&ctx, buf, (unsigned long)i);
}
err = EVP_SignFinal(&ctx, pSigBuf, (unsigned int*)nSigLen, pkey);
if(err == ERR_LIB_NONE)
err = ERR_OK;
fclose(f);
EVP_PKEY_free(pkey);
} // if - fopen
else
err = ERR_FILE_READ;
}
else
err = ERR_PRIVKEY_READ;
}
else
err = ERR_SIGNATURE_LEN;
}
else
err = ERR_UNSUPPORTED_DIGEST;
if (err != ERR_OK) SET_LAST_ERROR(err);
return err;
}
BOOL
RemoveCtrlHandler(
IN PHANDLER_ROUTINE HandlerRoutine
)
/*++
Routine Description:
This routine removes a ctrl handler from the process's list.
Arguments:
HandlerRoutine - pointer to ctrl handler.
Return Value:
TRUE - success.
--*/
{
ULONG i;
//
// NULL handler routine is not stored in table. It is
// used to temporarily inhibit ^C event handling. Removing
// this handler allows normal processing to occur
//
if ( !HandlerRoutine ) {
NtCurrentPeb()->ProcessParameters->ConsoleFlags = 0;
return TRUE;
}
for (i=0; i<HandlerListLength; i++) {
if (*(HandlerList+i) == HandlerRoutine) {
if (i < (HandlerListLength-1)) {
memmove(&HandlerList[i],&HandlerList[i+1],sizeof(PHANDLER_ROUTINE) * (HandlerListLength - i - 1));
}
HandlerListLength -= 1;
return TRUE;
}
}
SET_LAST_ERROR(ERROR_INVALID_PARAMETER);
return FALSE;
}
void vce_tcpcontext_cleanup( tcpcontext_t tp ) {
tcpcontext *t = ( tcpcontext * ) tp;
vce_conn_close_tcpcontext_all( (tcpcontext_t) tp );
if( t->is_server ) vce_socket_close( t->mainsock );
vce_end_array( t->rbmaster_mi );
vce_end_array( t->erbmaster_mi );
vce_end_array( t->wbmaster_mi );
vce_end_array( t->ewbmaster_mi );
vce_end_array( t->statebuf_mi );
vce_free_array_object( vce_tcpcontext_mi , t );
vce_usage_increment_tcpcontext_cleanup();
SET_LAST_ERROR(VCE_NOERROR);
}
