static int
check_Null(hx509_validate_ctx ctx,
struct cert_status *status,
enum critical_flag cf, const Extension *e)
{
switch(cf) {
case D_C:
break;
case S_C:
if (!e->critical)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"\tCritical not set on SHOULD\n");
break;
case S_N_C:
if (e->critical)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"\tCritical set on SHOULD NOT\n");
break;
case M_C:
if (!e->critical)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"\tCritical not set on MUST\n");
break;
case M_N_C:
if (e->critical)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"\tCritical set on MUST NOT\n");
break;
default:
_hx509_abort("internal check_Null state error");
}
return 0;
}
static int
check_authorityInfoAccess(hx509_validate_ctx ctx,
struct cert_status *status,
enum critical_flag cf,
const Extension *e)
{
AuthorityInfoAccessSyntax aia;
size_t size;
int ret, i;
check_Null(ctx, status, cf, e);
ret = decode_AuthorityInfoAccessSyntax(e->extnValue.data,
e->extnValue.length,
&aia, &size);
if (ret) {
printf("\tret = %d while decoding AuthorityInfoAccessSyntax\n", ret);
return 0;
}
for (i = 0; i < aia.len; i++) {
char *str;
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\ttype: ");
hx509_oid_print(&aia.val[i].accessMethod, validate_vprint, ctx);
hx509_general_name_unparse(&aia.val[i].accessLocation, &str);
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\n\tdirname: %s\n", str);
free(str);
}
free_AuthorityInfoAccessSyntax(&aia);
return 0;
}
int
int_legdwavf
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2;
static int minlhs = 1, maxlhs = 1, minrhs = 1, maxrhs = 1;
swt_wavelet pWaveStruct;
int errCode, family, member;
int readFlag;
char * input_string1 = NULL;
double *output1;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
legdwavf_form_validate (pvApiCtx, &errCode);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (1, "c", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
m1=1;n1=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
legdwavf_content_validate (pvApiCtx, &errCode,input_string1);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
wavelet_parser(input_string1,&family,&member);
legendre_synthesis_initialize (member, &pWaveStruct);
m2 = 1;
n2 = pWaveStruct.length;
//CreateVar (2, "d", &m2, &n2, &l2);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
filter_clear();
//LhsVar (1) = 2;
return 0;
}
static int
check_extKeyUsage(hx509_validate_ctx ctx,
struct cert_status *status,
enum critical_flag cf,
const Extension *e)
{
ExtKeyUsage eku;
size_t size, i;
int ret;
check_Null(ctx, status, cf, e);
ret = decode_ExtKeyUsage(e->extnValue.data,
e->extnValue.length,
&eku, &size);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding ExtKeyUsage failed: %d", ret);
return 1;
}
if (size != e->extnValue.length) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Padding data in EKU");
free_ExtKeyUsage(&eku);
return 1;
}
if (eku.len == 0) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"ExtKeyUsage length is 0");
return 1;
}
for (i = 0; i < eku.len; i++) {
char *str;
ret = der_print_heim_oid (&eku.val[i], '.', &str);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"\tEKU: failed to print oid %d", i);
free_ExtKeyUsage(&eku);
return 1;
}
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\teku-%d: %s\n", i, str);;
free(str);
}
free_ExtKeyUsage(&eku);
return 0;
}
static int
check_subjectKeyIdentifier(hx509_validate_ctx ctx,
struct cert_status *status,
enum critical_flag cf,
const Extension *e)
{
SubjectKeyIdentifier si;
size_t size;
int ret;
status->haveSKI = 1;
check_Null(ctx, status, cf, e);
ret = decode_SubjectKeyIdentifier(e->extnValue.data,
e->extnValue.length,
&si, &size);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding SubjectKeyIdentifier failed: %d", ret);
return 1;
}
if (size != e->extnValue.length) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding SKI ahve extra bits on the end");
return 1;
}
if (si.length == 0)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"SKI is too short (0 bytes)");
if (si.length > 20)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"SKI is too long");
{
char *id;
hex_encode(si.data, si.length, &id);
if (id) {
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\tsubject key id: %s\n", id);
free(id);
}
}
free_SubjectKeyIdentifier(&si);
return 0;
}
static int
check_utf8_string_san(hx509_validate_ctx ctx, heim_any *a)
{
PKIXXmppAddr jid;
size_t size;
int ret;
ret = decode_PKIXXmppAddr(a->data, a->length, &jid, &size);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding JID in SAN failed: %d", ret);
return 1;
}
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "%s", jid);
free_PKIXXmppAddr(&jid);
return 0;
}
static int
check_basicConstraints(hx509_validate_ctx ctx,
struct cert_status *status,
enum critical_flag cf,
const Extension *e)
{
BasicConstraints b;
size_t size;
int ret;
check_Null(ctx, status, cf, e);
ret = decode_BasicConstraints(e->extnValue.data, e->extnValue.length,
&b, &size);
if (ret) {
printf("\tret = %d while decoding BasicConstraints\n", ret);
return 0;
}
if (size != e->extnValue.length)
printf("\tlength of der data isn't same as extension\n");
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\tis %sa CA\n", b.cA && *b.cA ? "" : "NOT ");
if (b.pathLenConstraint)
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\tpathLenConstraint: %d\n", *b.pathLenConstraint);
if (b.cA) {
if (*b.cA) {
if (!e->critical)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Is a CA and not BasicConstraints CRITICAL\n");
status->isca = 1;
}
else
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"cA is FALSE, not allowed to be\n");
}
free_BasicConstraints(&b);
return 0;
}
static int
check_pkinit_san(hx509_validate_ctx ctx, heim_any *a)
{
KRB5PrincipalName kn;
unsigned i;
size_t size;
int ret;
ret = decode_KRB5PrincipalName(a->data, a->length, &kn, &size);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding kerberos name in SAN failed: %d", ret);
return 1;
}
if (size != a->length) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding kerberos name have extra bits on the end");
return 1;
}
/* print kerberos principal, add code to quote / within components */
for (i = 0; i < kn.principalName.name_string.len; i++) {
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "%s",
kn.principalName.name_string.val[i]);
if (i + 1 < kn.principalName.name_string.len)
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "/");
}
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "@");
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "%s", kn.realm);
free_KRB5PrincipalName(&kn);
return 0;
}
static int
check_authorityKeyIdentifier(hx509_validate_ctx ctx,
struct cert_status *status,
enum critical_flag cf,
const Extension *e)
{
AuthorityKeyIdentifier ai;
size_t size;
int ret;
status->haveAKI = 1;
check_Null(ctx, status, cf, e);
ret = decode_AuthorityKeyIdentifier(e->extnValue.data,
e->extnValue.length,
&ai, &size);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding AuthorityKeyIdentifier failed: %d", ret);
return 1;
}
if (size != e->extnValue.length) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding SKI ahve extra bits on the end");
return 1;
}
if (ai.keyIdentifier) {
char *id;
hex_encode(ai.keyIdentifier->data, ai.keyIdentifier->length, &id);
if (id) {
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\tauthority key id: %s\n", id);
free(id);
}
}
return 0;
}
int
hx509_validate_cert(hx509_context context,
hx509_validate_ctx ctx,
hx509_cert cert)
{
Certificate *c = _hx509_get_cert(cert);
TBSCertificate *t = &c->tbsCertificate;
hx509_name issuer, subject;
char *str;
struct cert_status status;
int ret;
memset(&status, 0, sizeof(status));
if (_hx509_cert_get_version(c) != 3)
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"Not version 3 certificate\n");
if ((t->version == NULL || *t->version < 2) && t->extensions)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Not version 3 certificate with extensions\n");
if (_hx509_cert_get_version(c) >= 3 && t->extensions == NULL)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Version 3 certificate without extensions\n");
ret = hx509_cert_get_subject(cert, &subject);
if (ret) abort();
hx509_name_to_string(subject, &str);
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"subject name: %s\n", str);
free(str);
ret = hx509_cert_get_issuer(cert, &issuer);
if (ret) abort();
hx509_name_to_string(issuer, &str);
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"issuer name: %s\n", str);
free(str);
if (hx509_name_cmp(subject, issuer) == 0) {
status.selfsigned = 1;
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"\tis a self-signed certificate\n");
}
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"Validity:\n");
Time2string(&t->validity.notBefore, &str);
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "\tnotBefore %s\n", str);
free(str);
Time2string(&t->validity.notAfter, &str);
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "\tnotAfter %s\n", str);
free(str);
if (t->extensions) {
int i, j;
if (t->extensions->len == 0) {
validate_print(ctx,
HX509_VALIDATE_F_VALIDATE|HX509_VALIDATE_F_VERBOSE,
"The empty extensions list is not "
"allowed by PKIX\n");
}
for (i = 0; i < t->extensions->len; i++) {
for (j = 0; check_extension[j].name; j++)
if (der_heim_oid_cmp(check_extension[j].oid,
&t->extensions->val[i].extnID) == 0)
break;
if (check_extension[j].name == NULL) {
int flags = HX509_VALIDATE_F_VERBOSE;
if (t->extensions->val[i].critical)
flags |= HX509_VALIDATE_F_VALIDATE;
validate_print(ctx, flags, "don't know what ");
if (t->extensions->val[i].critical)
validate_print(ctx, flags, "and is CRITICAL ");
if (ctx->flags & flags)
hx509_oid_print(&t->extensions->val[i].extnID,
validate_vprint, ctx);
validate_print(ctx, flags, " is\n");
continue;
}
validate_print(ctx,
HX509_VALIDATE_F_VALIDATE|HX509_VALIDATE_F_VERBOSE,
"checking extention: %s\n",
check_extension[j].name);
(*check_extension[j].func)(ctx,
&status,
check_extension[j].cf,
&t->extensions->val[i]);
}
} else
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "no extentions\n");
if (status.isca) {
if (!status.haveSKI)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"CA certificate have no SubjectKeyIdentifier\n");
} else {
if (!status.haveAKI)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Is not CA and doesn't have "
"AuthorityKeyIdentifier\n");
}
if (!status.haveSKI)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Doesn't have SubjectKeyIdentifier\n");
if (status.isproxy && status.isca)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Proxy and CA at the same time!\n");
if (status.isproxy) {
if (status.haveSAN)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Proxy and have SAN\n");
if (status.haveIAN)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Proxy and have IAN\n");
}
if (hx509_name_is_null_p(subject) && !status.haveSAN)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"NULL subject DN and doesn't have a SAN\n");
if (!status.selfsigned && !status.haveCRLDP)
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Not a CA nor PROXY and doesn't have"
"CRL Dist Point\n");
if (status.selfsigned) {
ret = _hx509_verify_signature_bitstring(context,
cert,
&c->signatureAlgorithm,
&c->tbsCertificate._save,
&c->signatureValue);
if (ret == 0)
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"Self-signed certificate was self-signed\n");
else
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Self-signed certificate NOT really self-signed!\n");
}
hx509_name_free(&subject);
hx509_name_free(&issuer);
return 0;
}
static int
check_altName(hx509_validate_ctx ctx,
struct cert_status *status,
const char *name,
enum critical_flag cf,
const Extension *e)
{
GeneralNames gn;
size_t size;
int ret, i;
check_Null(ctx, status, cf, e);
if (e->extnValue.length == 0) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"%sAltName empty, not allowed", name);
return 1;
}
ret = decode_GeneralNames(e->extnValue.data, e->extnValue.length,
&gn, &size);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"\tret = %d while decoding %s GeneralNames\n",
ret, name);
return 1;
}
if (gn.len == 0) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"%sAltName generalName empty, not allowed\n", name);
return 1;
}
for (i = 0; i < gn.len; i++) {
switch (gn.val[i].element) {
case choice_GeneralName_otherName: {
unsigned j;
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"%sAltName otherName ", name);
for (j = 0; j < sizeof(altname_types)/sizeof(altname_types[0]); j++) {
if (der_heim_oid_cmp(altname_types[j].oid,
&gn.val[i].u.otherName.type_id) != 0)
continue;
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "%s: ",
altname_types[j].name);
(*altname_types[j].func)(ctx, &gn.val[i].u.otherName.value);
break;
}
if (j == sizeof(altname_types)/sizeof(altname_types[0])) {
hx509_oid_print(&gn.val[i].u.otherName.type_id,
validate_vprint, ctx);
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, " unknown");
}
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "\n");
break;
}
default: {
char *s;
ret = hx509_general_name_unparse(&gn.val[i], &s);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"ret = %d unparsing GeneralName\n", ret);
return 1;
}
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "%s\n", s);
free(s);
break;
}
}
}
free_GeneralNames(&gn);
return 0;
}
static int
check_CRLDistributionPoints(hx509_validate_ctx ctx,
struct cert_status *status,
enum critical_flag cf,
const Extension *e)
{
CRLDistributionPoints dp;
size_t size;
int ret, i;
check_Null(ctx, status, cf, e);
ret = decode_CRLDistributionPoints(e->extnValue.data,
e->extnValue.length,
&dp, &size);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Decoding CRL Distribution Points failed: %d\n", ret);
return 1;
}
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "CRL Distribution Points:\n");
for (i = 0 ; i < dp.len; i++) {
if (dp.val[i].distributionPoint) {
DistributionPointName dpname;
heim_any *data = dp.val[i].distributionPoint;
int j;
ret = decode_DistributionPointName(data->data, data->length,
&dpname, NULL);
if (ret) {
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Failed to parse CRL Distribution Point Name: %d\n", ret);
continue;
}
switch (dpname.element) {
case choice_DistributionPointName_fullName:
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, "Fullname:\n");
for (j = 0 ; j < dpname.u.fullName.len; j++) {
char *s;
GeneralName *name = &dpname.u.fullName.val[j];
ret = hx509_general_name_unparse(name, &s);
if (ret == 0 && s != NULL) {
validate_print(ctx, HX509_VALIDATE_F_VERBOSE, " %s\n", s);
free(s);
}
}
break;
case choice_DistributionPointName_nameRelativeToCRLIssuer:
validate_print(ctx, HX509_VALIDATE_F_VERBOSE,
"Unknown nameRelativeToCRLIssuer");
break;
default:
validate_print(ctx, HX509_VALIDATE_F_VALIDATE,
"Unknown DistributionPointName");
break;
}
free_DistributionPointName(&dpname);
}
}
free_CRLDistributionPoints(&dp);
status->haveCRLDP = 1;
return 0;
}
int
int_dwtmode
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
static int minlhs = 0, maxlhs = 1, minrhs = 0, maxrhs = 2;
int errCode;
//int row1, row2;
// int col;
//char *Str[] = {"symhh"};
//char sss[6] = "symhh";
char **Str;
int i;
int readFlag;
char * input_string1 = NULL;
char * input_string2 = NULL;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
if (Rhs == 0)
dwt_print();
else if (Rhs == 1)
{
//GetMatrixdims(1,&row,&col);
if (sci_strings_scalar(pvApiCtx,1))
{
//sciprint("before GetVAR\n");
//GetRhsVar(1, "c", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
m1=1;n1=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
if (!strcmp(input_string1,"status"))
dwt_print();
else
{
dwt_write(input_string1,&errCode);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
sciprint("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
sciprint("!! WARNING: Change DWT Extension Mode !!\n");
sciprint("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
dwt_print();
}
}
else
{
sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
return 0;
}
}
else if (Rhs == 2)
{
// GetMatrixdims(1, &row1, &col1);
//GetMatrixdims(2, &row2, &col2);
/* if ((swt_gwsupport_GetType(pvApiCtx, 1) == sci_strings) && (swt_gwsupport_GetType(pvApiCtx, 2) == sci_strings) && (is_scalar(row1,col1)) && (is_scalar(row2,col2)))*/
if (sci_strings_scalar(pvApiCtx, 1) && sci_strings_scalar(pvApiCtx, 2))
{
//GetRhsVar(1, "c", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
m1=1;n1=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//GetRhsVar(2, "c", &m2, &n2, &l2);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
m2=1;n2=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
if ((strcmp(input_string1,"status")==0) && (strcmp(input_string2,"nodisp")==0))
{
m3 = 1;
n3 = 1;
//*Str = sss;
Str=NULL;
Str = (char **)malloc(1*sizeof(char *));
for(i=0; i<(int)1; i++)
{
Str[i] = (char *)malloc(6*sizeof(char));
}
//printf("before dwt_parse\n");
dwt_parse(Str);
//printf("after dwt_parse\n");
//printf("%s\n",Str[0]);
//CreateVarFromPtr(3,"S", &m3, &n3, Str);
readFlag = swt_gwsupport_CreateMatrixOfString (pvApiCtx, fname, 1, m3 , n3 , Str );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//printf("after Create\n");
//AssignOutputVariable(pvApiCtx,1) = 3;
//FreeRhsSVar(Str);
}
else if (strcmp(input_string2,"nodisp")==0 )
{
dwt_write(input_string1,&errCode);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
}
else
{
sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
return 0;
}
}
else
{
sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
return 0;
}
}
else
{
sciprint("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
return 0;
}
return 0;
}
int
int_wmaxlev
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
static int minlhs = 1, maxlhs = 1, minrhs = 2, maxrhs = 2;
int ii, stride, val, stride1, stride2, val1, val2;
// int filterLen;
swt_wavelet pWaveStruct;
int errCode, family, member;
Func syn_fun;
int readFlag;
char * input_string1 = NULL;
int *input1;
int *output1;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
wmaxlev_form_validate (pvApiCtx, &errCode);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (1, "i", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetRealMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, &m1 , &n1 , &input1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//GetRhsVar (2, "c", &m2, &n2, &l2);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname,2 , &input_string1 );
m2=1;n2=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
wfilters_content_validate (pvApiCtx, &errCode, input_string1);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
filter_clear();
if (sci_matrix_scalar_real(pvApiCtx,1))
{
if (input1[0] <= 0)
{
sciprint("Input integer must be positive!\n");
return 0;
}
wave_len_validate (input1[0], pWaveStruct.length,
&stride, &val);
if (val == 0)
{
sciprint
("Unrecognized Input Pattern or parameter not valid for the algorithm! Please refer to help pages!\n");
return 0;
}
else
{
m3 = 1;
n3 = 1;
//CreateVar (3, "i", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
output1[0] = stride;
// LhsVar (1) = 3;
}
}
else
{
//sciprint("enter matrix\n");
if (input1[0] <= 0)
{
sciprint("Input integer must be positive!\n");
return 0;
}
if (input1[0] <= 0)
{
sciprint("Input integer must be positive!\n");
return 0;
}
wave_len_validate ( input1[0], pWaveStruct.length,
&stride1, &val1);
if (val1 == 0)
{
sciprint
("The wavelet you select is not appropriate for that row size of the matrix!\n");
return 0;
}
wave_len_validate ( input1[1], pWaveStruct.length,
&stride2, &val2);
if (val2 == 0)
{
sciprint
("The wavelet you select is not appropriate for that column size of the matrix!\n");
return 0;
}
if ((val1 == 0) || (val2 == 0))
return 0;
m3 = 1;
n3 = 1;
//CreateVar (3, "i", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoublesAsInteger (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
output1[0] = (stride1 > stride2) ? stride2 : stride1;
//if (stride1>=stride2)
// istk(l3)[0]=stride2;
//else
// istk(l3)[0]=stride1;
// LhsVar (1) = 3;
}
return 0;
}
int
int_wfilters
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
static int l4, m4, n4, l5, m5, n5;
static int minlhs = 2, maxlhs = 4, minrhs = 1, maxrhs = 2;
int errCode, flow, family, member, ii;
Func ana_fun, syn_fun;
swt_wavelet pWaveStruct;
int readFlag;
char * input_string1 = NULL;
char * input_string2 = NULL;
double *output1;
double *output2;
double *output3;
double *output4;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
errCode = SUCCESS;
if (swt_gwsupport_GetType(pvApiCtx, 1)!=sci_strings)
errCode = UNKNOWN_INPUT_ERR;
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (1, "c", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 1 , &input_string1 );
m1=1;n1=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
l2 = 0;
if (Rhs==2)
{
if (swt_gwsupport_GetType(pvApiCtx, 2)!=sci_strings)
errCode = UNKNOWN_INPUT_ERR;
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
//GetRhsVar (2, "c", &m2, &n2, &l2);
readFlag = swt_gwsupport_GetScalarString(pvApiCtx, fname, 2 , &input_string2 );
m2=1;n2=1;
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
}
wfilters_form_validate (pvApiCtx, &errCode, &flow, input_string2,Rhs,Lhs);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
wfilters_content_validate (pvApiCtx, &errCode, input_string1);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
switch (flow) {
case 1:
{
//sciprint("enter flow 1!\n");
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
syn_fun = wi[ii].synthesis;
(*ana_fun)(member, &pWaveStruct);
m2 = 1;
m3 = 1;
m4 = 1;
m5 = 1;
n2 = pWaveStruct.length;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
n5 = pWaveStruct.length;
//CreateVar (2, "d", &m2, &n2, &l2);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m3 , n3 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m4 , n4 , &output3 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (5, "d", &m5, &n5, &l5);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 4, m5 , n5 , &output4 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m2*n2, output1, m2*n2);
verbatim_copy (pWaveStruct.pHiPass, m3*n3, output2, m3*n3);
(*syn_fun)(member, &pWaveStruct);
verbatim_copy (pWaveStruct.pLowPass, m4*n4, output3, m4*n4);
verbatim_copy (pWaveStruct.pHiPass, m5*n5, output4, m5*n5);
filter_clear();
// AssignOutputVariable(pvApiCtx,1) = 2;
// AssignOutputVariable(pvApiCtx,2) = 3;
// AssignOutputVariable(pvApiCtx,3) = 4;
// AssignOutputVariable(pvApiCtx,4) = 5;
break;
}
case 2:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
(*ana_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
filter_clear();
// LhsVar (1) = 3;
// LhsVar (2) = 4;
break;
}
case 3:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
filter_clear();
//LhsVar (1) = 3;
//LhsVar (2) = 4;
break;
}
case 4:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
(*ana_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pLowPass, m3*n3, output1, m3*n3);
//filter_clear();
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
verbatim_copy (pWaveStruct.pLowPass, m4*n4, output2, m4*n4);
filter_clear();
//LhsVar (1) = 3;
//LhsVar (2) = 4;
break;
}
case 5:
{
wavelet_parser(input_string1,&family,&member);
wavelet_fun_parser (input_string1, &ii);
ana_fun = wi[ii].analysis;
(*ana_fun)(member, &pWaveStruct);
m3 = 1;
m4 = 1;
n3 = pWaveStruct.length;
n4 = pWaveStruct.length;
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m3 , n3 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m4 , n4 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
verbatim_copy (pWaveStruct.pHiPass, m3*n3, output1, m3*n3);
syn_fun = wi[ii].synthesis;
(*syn_fun)(member, &pWaveStruct);
verbatim_copy (pWaveStruct.pHiPass, m4*n4, output2, m4*n4);
filter_clear();
//LhsVar (1) = 3;
//LhsVar (2) = 4;
break;
}
default:
break;
}
return 0;
}
int
int_orthfilt
#ifdef _SCILAB6_
(char *fname, void* pvApiCtx)
#else
(char *fname)
#endif
{
static int l1, m1, n1, l2, m2, n2, l3, m3, n3;
static int l4, m4, n4, l5, m5, n5;
static int minlhs = 4, maxlhs = 4, minrhs = 1, maxrhs = 1;
int errCode;
int readFlag;
double *input1;
double *output1;
double *output2;
double *output3;
double *output4;
CheckInputArgument(pvApiCtx,minrhs, maxrhs);
CheckOutputArgument(pvApiCtx,minlhs, maxlhs);
// GetRhsVar (1, "d", &m1, &n1, &l1);
readFlag = swt_gwsupport_GetRealMatrixOfDoubles(pvApiCtx, fname, 1, &m1, &n1, &input1);
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
orthfilt_form_validate (pvApiCtx, &errCode);
if (errCode != SUCCESS)
{
validate_print (errCode);
return 0;
}
m2 = 1;
m3 = 1;
m4 = 1;
m5 = 1;
n2 = n1 * m1;
n3 = n1 * m1;
n4 = n1 * m1;
n5 = n1 * m1;
//CreateVar (2, "d", &m2, &n2, &l2);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 1, m2 , n2 , &output1 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (3, "d", &m3, &n3, &l3);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 2, m3 , n3 , &output2 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (4, "d", &m4, &n4, &l4);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 3, m4 , n4 , &output3 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
//CreateVar (5, "d", &m5, &n5, &l5);
readFlag = swt_gwsupport_AllocMatrixOfDoubles (pvApiCtx, fname, 4, m5 , n5 , &output4 );
if(readFlag==SWT_GWSUPPORT_ERROR)
{
return 0;
}
orth_filt_group (input1, n1 * m1, output3, output1, output4, output2);
//LhsVar (1) = 2;
//LhsVar (2) = 3;
//LhsVar (3) = 4;
//LhsVar (4) = 5;
return 0;
}
