void InitBSPLog(Int4 randseed,CharPtr sequence,Int4 tstruc) { CharPtr decsequence; static Char pcUname[PATH_MAX]=""; Char timedate[25]; #ifdef OS_UNIX struct utsname utsbuf; #endif bspTempLog=BSNew(0); /* compute log file name */ if (generation==0) sprintf(LogOutName,"%sfold_%ld_%s_%ld_%s",CFG_local_datafilepath,(long)experiment,handle,(long)tstruc,fnamtrj); else sprintf(LogOutName,"%sfold_%ld_%s_%ld_%s_%s_%d",CFG_local_datafilepath,(long)experiment,handle,(long)tstruc,handle,fnamtrj,generation); BSprintf(bspTempLog,"\nFoldtraj v%s log report",FOLDTRAJ_VERSION); BSprintf(bspTempLog,"\nTrajectory File: %s%s_%d",CFG_local_datafilepath,fnamtrj,generation); BSprintf(bspTempLog,"\tStructure File Base Name: %s_%s_%d",handle,fnamtrj,generation); BSprintf(bspTempLog,"\tRandom Seed: %ld\t# Generated: %ld\tStart Numbering at: %ld",randseed,STRUCS_PER_RUN,1); BSprintf(bspTempLog,"\tCompared to Native Structure: 1CDZ"); decsequence=DecodeSequence(sequence,EXTAA_PARENT); BSprintf(bspTempLog,"\nSequence: %s",decsequence); decsequence=MemFree(decsequence); BSprintf(bspTempLog,"\nFolding Conditions:\t%ldx%ld Trajectory Distributions\t%s Random Walk\tAverage Timeout: %ld\tBackbone Error Tolerance: %4.2f\tBackbone Precision: %6.4f\tBackbone Atom Bounciness: %5.2f%%\tSidechain Atom Bounciness: %5.2f %%\tHydrogen Bumpchecking: %s\t# Rotamer Tries: %d/chi angle\tMarkov Scale Factor: %4.2f", TRAJDIV,TRAJDIV,WALKTYPE==WALK_CA?"C-Alpha":"Phi-Psi",TIMEOUT,BACKBONE_ERROR_TOLERANCE, BACKBONE_PRECISION,ATOM_BOUNCINESS_BB*100.0,ATOM_BOUNCINESS_SC*100.0, BUMPCHECK_HYDROGEN?"On":"Off",NUM_ROT_TRIES,MARKOV_SCALE_FACTOR); if (WALKTYPE!=WALK_CA && MARKOV_SCALE_FACTOR>0.0) ErrPostEx(SEV_ERROR,2,2,"Markov Scale Factor should be zero for non-Ca walk -- ignored"); if (TRAJTYPE!=TRAJ_NA) { BSprintf(bspTempLog,"\tTrajectory Distribution: "); switch (TRAJTYPE) { case TRAJ_UNIFORM: BSprintf(bspTempLog,"Uniform"); break; case TRAJ_STANDARD: BSprintf(bspTempLog,"Amino-Acid Based"); break; case TRAJ_SSTRU: BSprintf(bspTempLog,"1-State Secondary Structure Prediction"); break; case TRAJ_GOR: BSprintf(bspTempLog,"3-State Secondary Structure Prediction"); break; default: BSprintf(bspTempLog,"Unknown"); } } if (StringCmp(CONSTRAINT_FILE,"")) BSprintf(bspTempLog,"\tConstraint file: %s",CONSTRAINT_FILE); BSprintf(bspTempLog,"\nSystem Information: "); if (StringLen(pcUname)==0) { StringCpy(pcUname,"Not Available\n"); #ifdef OS_UNIX /* use uname to get sysinfo */ if (uname(&utsbuf)>=0) { sprintf(pcUname,"%s %s %s %s %s\n",utsbuf.sysname,utsbuf.nodename,utsbuf.release,utsbuf.version,utsbuf.machine); } #else #ifdef OS_MSWIN /* assume ver is available */ if (GetMSWinVerInfo(pcUname)!=ERR_SUCCESS) { StringCpy(pcUname,"Not Available\n"); } #endif #endif } BSWrite(bspTempLog,pcUname,StringLen(pcUname)); DayTimeStr(timedate,TRUE,TRUE); BSprintf(bspTempLog,"Job started: %s\n",timedate); BSprintf(bspTempLog,"\nStructure\tTime(s)\tTries\tBad Backbone Tries\tCrashes\tDistant Constraint Tries (# Violations)\tChain Length\tRadius of Gyration(A)\tHydrophobics Radius of Gyration(A)\tEnd-to-end Distance(A)\tRn\tCn"); BSprintf(bspTempLog,"\tSurface Accessibility (A^2)\tExposed Hydrophobics (A^2)"); BSprintf(bspTempLog,"\t# Helical Residues (DSSP)\t# Extended Residues (DSSP)"); BSprintf(bspTempLog,"\t# Extended Residues (CA-CA dist.)"); BSprintf(bspTempLog,"\tRMSD from Native(A)"); BSprintf(bspTempLog,"\tZhang Potential(Exclusive Window Size %d)\tBryant-Lawrence Potential(Exclusive Window Size %d)\tCrease Energy\n",ZHANG_WINDOWSIZE,BRYANT_WINDOWSIZE); }
static SECStatus DecodeItem(void* dest, const SEC_ASN1Template* templateEntry, SECItem* src, PLArenaPool* arena, PRBool checkTag) { SECStatus rv = SECSuccess; SECItem temp; SECItem mark; PRBool pop = PR_FALSE; PRBool decode = PR_TRUE; PRBool save = PR_FALSE; unsigned long kind; PRBool match = PR_TRUE; PRBool optional = PR_FALSE; PR_ASSERT(src && dest && templateEntry && arena); #if 0 if (!src || !dest || !templateEntry || !arena) { PORT_SetError(SEC_ERROR_INVALID_ARGS); rv = SECFailure; } #endif if (SECSuccess == rv) { /* do the template validation */ kind = templateEntry->kind; optional = (0 != (kind & SEC_ASN1_OPTIONAL)); if (!kind) { PORT_SetError(SEC_ERROR_BAD_TEMPLATE); rv = SECFailure; } } if (SECSuccess == rv) { #ifdef DEBUG if (kind & SEC_ASN1_DEBUG_BREAK) { /* when debugging the decoder or a template that fails to decode, put SEC_ASN1_DEBUG in the component that gives you trouble. The decoder will then get to this block and assert. If you want to debug the rest of the code, you can set a breakpoint and set dontassert to PR_TRUE, which will let you skip over the assert and continue the debugging session past it. */ PRBool dontassert = PR_FALSE; PR_ASSERT(dontassert); /* set bkpoint here & set dontassert*/ } #endif if ((kind & SEC_ASN1_SKIP) || (kind & SEC_ASN1_SAVE)) { /* if skipping or saving this component, don't decode it */ decode = PR_FALSE; } if (kind & (SEC_ASN1_SAVE | SEC_ASN1_OPTIONAL)) { /* if saving this component, or if it is optional, we may not want to move past it, so save the position in case we have to rewind */ mark = *src; if (kind & SEC_ASN1_SAVE) { save = PR_TRUE; if (0 == (kind & SEC_ASN1_SKIP)) { /* we will for sure have to rewind when saving this component and not skipping it. This is true for all legacy uses of SEC_ASN1_SAVE where the following entry in the template would causes the same component to be processed again */ pop = PR_TRUE; } } } rv = GetItem(src, &temp, PR_TRUE); } if (SECSuccess == rv) { /* now check if the component matches what we expect in the template */ if (PR_TRUE == checkTag) { rv = MatchComponentType(templateEntry, &temp, &match, dest); } if ( (SECSuccess == rv) && (PR_TRUE != match) ) { if (kind & SEC_ASN1_OPTIONAL) { /* the optional component is missing. This is not fatal. */ /* Rewind, don't decode, and don't save */ pop = PR_TRUE; decode = PR_FALSE; save = PR_FALSE; } else { /* a required component is missing. abort */ PORT_SetError(SEC_ERROR_BAD_DER); rv = SECFailure; } } } if ((SECSuccess == rv) && (PR_TRUE == decode)) { /* the order of processing here is is the tricky part */ /* we start with our special cases */ /* first, check the component class */ if (kind & SEC_ASN1_INLINE) { /* decode inline template */ rv = DecodeInline(dest, templateEntry, &temp , arena, PR_TRUE); } else if (kind & SEC_ASN1_EXPLICIT) { rv = DecodeExplicit(dest, templateEntry, &temp, arena); } else if ( (SEC_ASN1_UNIVERSAL != (kind & SEC_ASN1_CLASS_MASK)) && (!(kind & SEC_ASN1_EXPLICIT))) { /* decode implicitly tagged components */ rv = DecodeImplicit(dest, templateEntry, &temp , arena); } else if (kind & SEC_ASN1_POINTER) { rv = DecodePointer(dest, templateEntry, &temp, arena, PR_TRUE); } else if (kind & SEC_ASN1_CHOICE) { rv = DecodeChoice(dest, templateEntry, &temp, arena); } else if (kind & SEC_ASN1_ANY) { /* catch-all ANY type, don't decode */ save = PR_TRUE; if (kind & SEC_ASN1_INNER) { /* skip the tag and length */ SECItem newtemp = temp; rv = GetItem(&newtemp, &temp, PR_FALSE); } } else if (kind & SEC_ASN1_GROUP) { if ( (SEC_ASN1_SEQUENCE == (kind & SEC_ASN1_TAGNUM_MASK)) || (SEC_ASN1_SET == (kind & SEC_ASN1_TAGNUM_MASK)) ) { rv = DecodeGroup(dest, templateEntry, &temp , arena); } else { /* a group can only be a SET OF or SEQUENCE OF */ PORT_SetError(SEC_ERROR_BAD_TEMPLATE); rv = SECFailure; } } else if (SEC_ASN1_SEQUENCE == (kind & SEC_ASN1_TAGNUM_MASK)) { /* plain SEQUENCE */ rv = DecodeSequence(dest, templateEntry, &temp , arena); } else { /* handle all other types as "save" */ /* we should only get here for primitive universal types */ SECItem newtemp = temp; rv = GetItem(&newtemp, &temp, PR_FALSE); save = PR_TRUE; if ((SECSuccess == rv) && SEC_ASN1_UNIVERSAL == (kind & SEC_ASN1_CLASS_MASK)) { unsigned long tagnum = kind & SEC_ASN1_TAGNUM_MASK; if ( temp.len == 0 && (tagnum == SEC_ASN1_BOOLEAN || tagnum == SEC_ASN1_INTEGER || tagnum == SEC_ASN1_BIT_STRING || tagnum == SEC_ASN1_OBJECT_ID || tagnum == SEC_ASN1_ENUMERATED || tagnum == SEC_ASN1_UTC_TIME || tagnum == SEC_ASN1_GENERALIZED_TIME) ) { /* these types MUST have at least one content octet */ PORT_SetError(SEC_ERROR_BAD_DER); rv = SECFailure; } else switch (tagnum) { /* special cases of primitive types */ case SEC_ASN1_INTEGER: { /* remove leading zeroes if the caller requested siUnsignedInteger This is to allow RSA key operations to work */ SECItem* destItem = (SECItem*) ((char*)dest + templateEntry->offset); if (destItem && (siUnsignedInteger == destItem->type)) { while (temp.len > 1 && temp.data[0] == 0) { /* leading 0 */ temp.data++; temp.len--; } } break; } case SEC_ASN1_BIT_STRING: { /* change the length in the SECItem to be the number of bits */ temp.len = (temp.len-1)*8 - (temp.data[0] & 0x7); temp.data++; break; } default: { break; } } } } } if ((SECSuccess == rv) && (PR_TRUE == save)) { SECItem* destItem = (SECItem*) ((char*)dest + templateEntry->offset); if (destItem) { /* we leave the type alone in the destination SECItem. If part of the destination was allocated by the decoder, in cases of POINTER, SET OF and SEQUENCE OF, then type is set to siBuffer due to the use of PORT_ArenaZAlloc*/ destItem->data = temp.len ? temp.data : NULL; destItem->len = temp.len; } else { PORT_SetError(SEC_ERROR_INVALID_ARGS); rv = SECFailure; } } if (PR_TRUE == pop) { /* we don't want to move ahead, so restore the position */ *src = mark; } return rv; }