BOOL ssl_parse_certificate_internal(void * bytes, size_t size, void* pwd, void* x509CertData)
{
char *name,*subject;
X509CertData* x509 = (X509CertData*)x509CertData;
X509* x = ssl_parse_certificate(bytes, size, (LPCSTR)pwd, NULL);
if (x == NULL)
{
TINYCLR_SSL_PRINTF("Unable to load certificate\n");
ERR_print_errors_fp(OPENSSL_TYPE__FILE_STDERR);
return FALSE;
}
name=X509_NAME_oneline(X509_get_issuer_name(x),NULL,0);
subject=X509_NAME_oneline(X509_get_subject_name(x),NULL,0);
TINYCLR_SSL_STRNCPY(x509->Issuer, name, TINYCLR_SSL_STRLEN(name));
TINYCLR_SSL_STRNCPY(x509->Subject, subject, TINYCLR_SSL_STRLEN(subject));
ssl_get_ASN1_UTCTIME(X509_get_notBefore(x), &x509->EffectiveDate);
ssl_get_ASN1_UTCTIME(X509_get_notAfter(x), &x509->ExpirationDate);
#if defined(DEBUG) || defined(_DEBUG)
TINYCLR_SSL_PRINTF("\n Issuer: ");
TINYCLR_SSL_PRINTF(name);
TINYCLR_SSL_PRINTF("\n",1);
TINYCLR_SSL_PRINTF(" Validity\n");
TINYCLR_SSL_PRINTF(" Not Before: ");
TINYCLR_SSL_PRINTF("%s %2d %02d:%02d:%02d %d%s",
mon[x509->EffectiveDate.month-1],
x509->EffectiveDate.day,
x509->EffectiveDate.hour,
x509->EffectiveDate.minute,
x509->EffectiveDate.second,
x509->EffectiveDate.year,
(x509->EffectiveDate.tzOffset)?" GMT":"");
TINYCLR_SSL_PRINTF("\n Not After : ");
TINYCLR_SSL_PRINTF("%s %2d %02d:%02d:%02d %d%s",
mon[x509->ExpirationDate.month-1],
x509->ExpirationDate.day,
x509->ExpirationDate.hour,
x509->ExpirationDate.minute,
x509->ExpirationDate.second,
x509->ExpirationDate.year,
(x509->ExpirationDate.tzOffset)?" GMT":"");
TINYCLR_SSL_PRINTF("\n");
TINYCLR_SSL_PRINTF(" Subject: ");
TINYCLR_SSL_PRINTF(subject);
TINYCLR_SSL_PRINTF("\n");
#endif
OPENSSL_free(name);
OPENSSL_free(subject);
X509_free(x);
return TRUE;
}
const char *LP_find_file(LP_DIR_CTX **ctx, const char *directory)
{
struct dirent *direntry = NULL;
if (ctx == NULL || directory == NULL)
{
errno = EINVAL;
return 0;
}
errno = 0;
if (*ctx == NULL)
{
*ctx = (LP_DIR_CTX *)malloc(sizeof(LP_DIR_CTX));
if (*ctx == NULL)
{
errno = ENOMEM;
return 0;
}
TINYCLR_SSL_MEMSET(*ctx, '\0', sizeof(LP_DIR_CTX));
(*ctx)->dir = opendir(directory);
if ((*ctx)->dir == NULL)
{
int save_errno = errno; /* Probably not needed, but I'm paranoid */
free(*ctx);
*ctx = NULL;
errno = save_errno;
return 0;
}
}
direntry = readdir((*ctx)->dir);
if (direntry == NULL)
{
return 0;
}
TINYCLR_SSL_STRNCPY((*ctx)->entry_name, direntry->d_name, sizeof((*ctx)->entry_name) - 1);
(*ctx)->entry_name[sizeof((*ctx)->entry_name) - 1] = '\0';
return (*ctx)->entry_name;
}
static char *win32_joiner(DSO *dso, const struct file_st *file_split)
{
int len = 0, offset = 0;
char *result = NULL;
const char *start;
if(!file_split)
{
DSOerr(DSO_F_WIN32_JOINER,
ERR_R_PASSED_NULL_PARAMETER);
return(NULL);
}
if(file_split->node)
{
len += 2 + file_split->nodelen; /* 2 for starting \\ */
if(file_split->predir || file_split->dir || file_split->file)
len++; /* 1 for ending \ */
}
else if(file_split->device)
{
len += file_split->devicelen + 1; /* 1 for ending : */
}
len += file_split->predirlen;
if(file_split->predir && (file_split->dir || file_split->file))
{
len++; /* 1 for ending \ */
}
len += file_split->dirlen;
if(file_split->dir && file_split->file)
{
len++; /* 1 for ending \ */
}
len += file_split->filelen;
if(!len)
{
DSOerr(DSO_F_WIN32_JOINER, DSO_R_EMPTY_FILE_STRUCTURE);
return(NULL);
}
result = OPENSSL_malloc(len + 1);
if (!result)
{
DSOerr(DSO_F_WIN32_JOINER,
ERR_R_MALLOC_FAILURE);
return(NULL);
}
if(file_split->node)
{
TINYCLR_SSL_STRCPY(&result[offset], "\\\\"); offset += 2;
TINYCLR_SSL_STRNCPY(&result[offset], file_split->node,
file_split->nodelen); offset += file_split->nodelen;
if(file_split->predir || file_split->dir || file_split->file)
{
result[offset] = '\\'; offset++;
}
}
else if(file_split->device)
{
TINYCLR_SSL_STRNCPY(&result[offset], file_split->device,
file_split->devicelen); offset += file_split->devicelen;
result[offset] = ':'; offset++;
}
start = file_split->predir;
while(file_split->predirlen > (start - file_split->predir))
{
const char *end = openssl_strnchr(start, '/',
file_split->predirlen - (start - file_split->predir));
if(!end)
end = start
+ file_split->predirlen
- (start - file_split->predir);
TINYCLR_SSL_STRNCPY(&result[offset], start,
end - start); offset += (int)(end - start);
result[offset] = '\\'; offset++;
start = end + 1;
}
#if 0 /* Not needed, since the directory converter above already appeneded
a backslash */
if(file_split->predir && (file_split->dir || file_split->file))
{
result[offset] = '\\'; offset++;
}
#endif
start = file_split->dir;
while(file_split->dirlen > (start - file_split->dir))
{
const char *end = openssl_strnchr(start, '/',
file_split->dirlen - (start - file_split->dir));
if(!end)
end = start
+ file_split->dirlen
- (start - file_split->dir);
TINYCLR_SSL_STRNCPY(&result[offset], start,
end - start); offset += (int)(end - start);
result[offset] = '\\'; offset++;
start = end + 1;
}
#if 0 /* Not needed, since the directory converter above already appeneded
a backslash */
if(file_split->dir && file_split->file)
{
result[offset] = '\\'; offset++;
}
#endif
TINYCLR_SSL_STRNCPY(&result[offset], file_split->file,
file_split->filelen); offset += file_split->filelen;
result[offset] = '\0';
return(result);
}
const char *LP_find_file(LP_DIR_CTX **ctx, const char *directory)
{
if (ctx == NULL || directory == NULL)
{
errno = EINVAL;
return 0;
}
errno = 0;
if (*ctx == NULL)
{
*ctx = (LP_DIR_CTX *)OPENSSL_malloc(sizeof(LP_DIR_CTX));
if (*ctx == NULL)
{
errno = ENOMEM;
return 0;
}
TINYCLR_SSL_MEMSET(*ctx, '\0', sizeof(LP_DIR_CTX));
if (sizeof(TCHAR) != sizeof(char))
{
TCHAR *wdir = NULL;
/* len_0 denotes string length *with* trailing 0 */
size_t index = 0,len_0 = TINYCLR_SSL_STRLEN(directory) + 1;
wdir = (TCHAR *)OPENSSL_malloc(len_0 * sizeof(TCHAR));
if (wdir == NULL)
{
OPENSSL_free(*ctx);
*ctx = NULL;
errno = ENOMEM;
return 0;
}
#ifdef LP_MULTIBYTE_AVAILABLE
if (!MultiByteToWideChar(CP_ACP, 0, directory, len_0, (WCHAR *)wdir, len_0))
#endif
for (index = 0; index < len_0; index++)
wdir[index] = (TCHAR)directory[index];
(*ctx)->handle = FindFirstFile(wdir, &(*ctx)->ctx);
OPENSSL_free(wdir);
}
else
(*ctx)->handle = FindFirstFile((TCHAR *)directory, &(*ctx)->ctx);
if ((*ctx)->handle == INVALID_HANDLE_VALUE)
{
OPENSSL_free(*ctx);
*ctx = NULL;
errno = EINVAL;
return 0;
}
}
else
{
if (FindNextFile((*ctx)->handle, &(*ctx)->ctx) == FALSE)
{
return 0;
}
}
if (sizeof(TCHAR) != sizeof(char))
{
TCHAR *wdir = (*ctx)->ctx.cFileName;
size_t index, len_0 = 0;
while (wdir[len_0] && len_0 < (sizeof((*ctx)->entry_name) - 1)) len_0++;
len_0++;
#ifdef LP_MULTIBYTE_AVAILABLE
if (!WideCharToMultiByte(CP_ACP, 0, (WCHAR *)wdir, len_0, (*ctx)->entry_name,
sizeof((*ctx)->entry_name), NULL, 0))
#endif
for (index = 0; index < len_0; index++)
(*ctx)->entry_name[index] = (char)wdir[index];
}
else
TINYCLR_SSL_STRNCPY((*ctx)->entry_name, (const char *)(*ctx)->ctx.cFileName,
sizeof((*ctx)->entry_name)-1);
(*ctx)->entry_name[sizeof((*ctx)->entry_name)-1] = '\0';
return (*ctx)->entry_name;
}
const char *LP_find_file(LP_DIR_CTX **ctx, const char *directory)
{
int status;
char *p, *r;
size_t l;
unsigned long flags = 0;
#ifdef NAML$C_MAXRSS
flags |= LIB$M_FIL_LONG_NAMES;
#endif
if (ctx == NULL || directory == NULL)
{
errno = EINVAL;
return 0;
}
errno = 0;
if (*ctx == NULL)
{
size_t filespeclen = TINYCLR_SSL_STRLEN(directory);
char *filespec = NULL;
/* MUST be a VMS directory specification! Let's estimate if it is. */
if (directory[filespeclen-1] != ']'
&& directory[filespeclen-1] != '>'
&& directory[filespeclen-1] != ':')
{
errno = EINVAL;
return 0;
}
filespeclen += 4; /* "*.*;" */
if (filespeclen >
#ifdef NAML$C_MAXRSS
NAML$C_MAXRSS
#else
255
#endif
)
{
errno = ENAMETOOLONG;
return 0;
}
*ctx = (LP_DIR_CTX *)OPENSSL_malloc(sizeof(LP_DIR_CTX));
if (*ctx == NULL)
{
errno = ENOMEM;
return 0;
}
TINYCLR_SSL_MEMSET(*ctx, '\0', sizeof(LP_DIR_CTX));
TINYCLR_SSL_STRCPY((*ctx)->filespec,directory);
TINYCLR_SSL_STRCAT((*ctx)->filespec,"*.*;");
(*ctx)->filespec_dsc.dsc$w_length = filespeclen;
(*ctx)->filespec_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
(*ctx)->filespec_dsc.dsc$b_class = DSC$K_CLASS_S;
(*ctx)->filespec_dsc.dsc$a_pointer = (*ctx)->filespec;
(*ctx)->result_dsc.dsc$w_length = 0;
(*ctx)->result_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
(*ctx)->result_dsc.dsc$b_class = DSC$K_CLASS_D;
(*ctx)->result_dsc.dsc$a_pointer = 0;
}
(*ctx)->result_dsc.dsc$w_length = 0;
(*ctx)->result_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
(*ctx)->result_dsc.dsc$b_class = DSC$K_CLASS_D;
(*ctx)->result_dsc.dsc$a_pointer = 0;
status = lib$find_file(&(*ctx)->filespec_dsc, &(*ctx)->result_dsc,
&(*ctx)->VMS_context, 0, 0, 0, &flags);
if (status == RMS$_NMF)
{
errno = 0;
vaxc$errno = status;
return NULL;
}
if(!$VMS_STATUS_SUCCESS(status))
{
errno = EVMSERR;
vaxc$errno = status;
return NULL;
}
/* Quick, cheap and dirty way to discard any device and directory,
since we only want file names */
l = (*ctx)->result_dsc.dsc$w_length;
p = (*ctx)->result_dsc.dsc$a_pointer;
r = p;
for (; *p; p++)
{
if (*p == '^' && p[1] != '\0') /* Take care of ODS-5 escapes */
{
p++;
}
else if (*p == ':' || *p == '>' || *p == ']')
{
l -= p + 1 - r;
r = p + 1;
}
else if (*p == ';')
{
l = p - r;
break;
}
}
TINYCLR_SSL_STRNCPY((*ctx)->result, r, l);
(*ctx)->result[l] = '\0';
str$free1_dx(&(*ctx)->result_dsc);
return (*ctx)->result;
}
char *X509_NAME_oneline(X509_NAME *a, char *buf, int len)
{
X509_NAME_ENTRY *ne;
int i;
int n,lold,l,l1,l2,num,j,type;
const char *s;
char *p;
unsigned char *q;
BUF_MEM *b=NULL;
static const char hex[17]="0123456789ABCDEF";
int gs_doit[4];
char tmp_buf[80];
#ifdef CHARSET_EBCDIC
char ebcdic_buf[1024];
#endif
if (buf == NULL)
{
if ((b=BUF_MEM_new()) == NULL) goto err;
if (!BUF_MEM_grow(b,200)) goto err;
b->data[0]='\0';
len=200;
}
if (a == NULL)
{
if(b)
{
buf=b->data;
OPENSSL_free(b);
}
TINYCLR_SSL_STRNCPY(buf,"NO X509_NAME",len);
buf[len-1]='\0';
return buf;
}
len--; /* space for '\0' */
l=0;
for (i=0; i<sk_X509_NAME_ENTRY_num(a->entries); i++)
{
ne=sk_X509_NAME_ENTRY_value(a->entries,i);
n=OBJ_obj2nid(ne->object);
if ((n == NID_undef) || ((s=OBJ_nid2sn(n)) == NULL))
{
i2t_ASN1_OBJECT(tmp_buf,sizeof(tmp_buf),ne->object);
s=tmp_buf;
}
l1=TINYCLR_SSL_STRLEN(s);
type=ne->value->type;
num=ne->value->length;
q=ne->value->data;
#ifdef CHARSET_EBCDIC
if (type == V_ASN1_GENERALSTRING ||
type == V_ASN1_VISIBLESTRING ||
type == V_ASN1_PRINTABLESTRING ||
type == V_ASN1_TELETEXSTRING ||
type == V_ASN1_VISIBLESTRING ||
type == V_ASN1_IA5STRING) {
ascii2ebcdic(ebcdic_buf, q,
(num > sizeof ebcdic_buf)
? sizeof ebcdic_buf : num);
q=ebcdic_buf;
}
#endif
if ((type == V_ASN1_GENERALSTRING) && ((num%4) == 0))
{
gs_doit[0]=gs_doit[1]=gs_doit[2]=gs_doit[3]=0;
for (j=0; j<num; j++)
if (q[j] != 0) gs_doit[j&3]=1;
if (gs_doit[0]|gs_doit[1]|gs_doit[2])
gs_doit[0]=gs_doit[1]=gs_doit[2]=gs_doit[3]=1;
else
{
gs_doit[0]=gs_doit[1]=gs_doit[2]=0;
gs_doit[3]=1;
}
}
else
gs_doit[0]=gs_doit[1]=gs_doit[2]=gs_doit[3]=1;
for (l2=j=0; j<num; j++)
{
if (!gs_doit[j&3]) continue;
l2++;
#ifndef CHARSET_EBCDIC
if ((q[j] < ' ') || (q[j] > '~')) l2+=3;
#else
if ((os_toascii[q[j]] < os_toascii[' ']) ||
(os_toascii[q[j]] > os_toascii['~'])) l2+=3;
#endif
}
lold=l;
l+=1+l1+1+l2;
if (b != NULL)
{
if (!BUF_MEM_grow(b,l+1)) goto err;
p= &(b->data[lold]);
}
else if (l > len)
{
break;
}
else
p= &(buf[lold]);
*(p++)='/';
TINYCLR_SSL_MEMCPY(p,s,(unsigned int)l1);
p+=l1;
*(p++)='=';
#ifndef CHARSET_EBCDIC /* q was assigned above already. */
q=ne->value->data;
#endif
for (j=0; j<num; j++)
{
if (!gs_doit[j&3]) continue;
#ifndef CHARSET_EBCDIC
n=q[j];
if ((n < ' ') || (n > '~'))
{
*(p++)='\\';
*(p++)='x';
*(p++)=hex[(n>>4)&0x0f];
*(p++)=hex[n&0x0f];
}
else
*(p++)=n;
#else
n=os_toascii[q[j]];
if ((n < os_toascii[' ']) ||
(n > os_toascii['~']))
{
*(p++)='\\';
*(p++)='x';
*(p++)=hex[(n>>4)&0x0f];
*(p++)=hex[n&0x0f];
}
