int main() {
configurePin(GPIO_MODE_OUTPUT,PIN_14,PORTG);
configurePin(GPIO_MODE_OUTPUT,PIN_13,PORTG);
//configurePin(GPIO_MODE_OUTPUT,PIN_5,PORTC);
//configurePin(GPIO_MODE_OUTPUT,PIN_13,PORTB);
configureIntPin(GPIO_MODE_INPUT,PIN_0,PORTA);
int realSignal;
int inputSignal;
while(1) {
realSignal = PORTA->IDR;
inputSignal = filterSignal(PORTA->IDR);
if( inputSignal != 1 ) {
//writeOutHigh(PORTG,14);
writeSet(PORTG,14);
writeReset(PORTG,13);
//writeOutLow(PORTG,13);
} else {
//writeOutHigh(PORTG,13);
//writeOutLow(PORTG,14);
writeSet(PORTG,13);
writeReset(PORTG,14);
}
}
/*
delay(100000);
writeOutHigh(PORTG,14);
writeOutLow(PORTG,13);
writeOutLow(PORTC,5);
writeOutLow(PORTB,13);
//writeOne(GPIO_PIN_14,GPIOG);
//writeZero(GPIO_PIN_13,GPIOG);
//writeZero(GPIO_PIN_5,GPIOC);
//writeZero(GPIO_PIN_13,GPIOB);
delay(100000);
writeOutLow(PORTG,14);
writeOutHigh(PORTG,13);
writeOutHigh(PORTC,5);
writeOutHigh(PORTB,13);
//writeZero(GPIO_PIN_14,GPIOG);
//writeOne(GPIO_PIN_13,GPIOG);
//writeOne(GPIO_PIN_5,GPIOC);
//writeOne(GPIO_PIN_13,GPIOB);
*/
}
static int writeCertID( INOUT STREAM *stream,
IN_HANDLE const CRYPT_CONTEXT iCryptCert )
{
MESSAGE_DATA msgData;
BYTE certHash[ CRYPT_MAX_HASHSIZE + 8 ];
int essCertIDSize, payloadSize, status;
assert( isWritePtr( stream, sizeof( STREAM ) ) );
REQUIRES( isHandleRangeValid( iCryptCert ) );
/* Find out how big the payload will be */
setMessageData( &msgData, certHash, CRYPT_MAX_HASHSIZE );
status = krnlSendMessage( iCryptCert, IMESSAGE_GETATTRIBUTE_S,
&msgData, CRYPT_CERTINFO_FINGERPRINT_SHA1 );
if( cryptStatusError( status ) )
return( status );
essCertIDSize = ( int ) sizeofObject( msgData.length );
payloadSize = objSize( objSize( objSize( essCertIDSize ) ) );
/* Write the signing certificate ID information */
writeSequence( stream, sizeofOID( OID_ESS_CERTID ) + \
( int ) sizeofObject( payloadSize ) );
writeOID( stream, OID_ESS_CERTID );
writeSet( stream, payloadSize );
writeSequence( stream, objSize( objSize( essCertIDSize ) ) );
writeSequence( stream, objSize( essCertIDSize ) );
writeSequence( stream, essCertIDSize );
return( writeOctetString( stream, certHash, msgData.length,
DEFAULT_TAG ) );
}
/* Compact font set */
void tcCompactSet(tcCtx g) {
tcprivCtx h = g->ctx.tcpriv;
fillSet(g);
writeSet(g);
freeFonts(g);
initSet(g, h);
#if TC_SUBR_SUPPORT
subrReuse(g);
#endif /* TC_SUBR_SUPPORT */
}
bool RC2UI::makeDialog()
{
line = in->readLine();
do {
QFile fileOut;
QString buffer;
int count;
QCString className;
uint x, y, w, h;
uint endDesc;
bool space = FALSE;
for ( endDesc = 0; endDesc < line.length() ; endDesc++ ) {
char c = (QChar)line.at(endDesc);
if ( space && (c >= '0') && (c <= '9') )
break;
space = c==' ';
}
QString desc = line.left(endDesc-1);
line = line.right( line.length() - endDesc );
className = parseNext( desc, ' ' );
count = sscanf( line, "%d, %d, %d, %d", &x, &y, &w, &h );
if ( !count && count == EOF )
return FALSE;
char property[256];
QStringList styles;
QStringList extendedStyles;
QString caption = "";
QString baseClass = "";
QString widgetType;
QString widgetName;
QString arguments;
int pointsize;
QString fontname;
do {
if ( in->eof() )
return TRUE;
line = "";
do {
line += in->readLine();
} while ( line[(int)line.length()-1] == '|' ||
line[(int)line.length()-1] == ',' );
count = sscanf( line, "%s", property );
line = line.right( line.length() - line.find(" ") -1 );
if ( QString(property) == "STYLE" ) {
styles = splitStyles(line);
if ( styles.contains( "WS_CAPTION" ) )
baseClass = "QDialog";
else
baseClass = "QWidget";
} else if ( QString(property) == "CAPTION" ) {
caption = stripQM( line );
} else if ( QString(property) == "FONT" ) {
QString pt = line.left( line.find(",") );
pointsize = pt.toInt();
fontname = stripQM(line.right( line.length() - line.find(",") - 2 ));
}
} while ( line != "BEGIN" );
if ( writeToFile ) {
QString outputFile = QString(className) + ".ui";
fileOut.setName( outputFile );
if (!fileOut.open( IO_WriteOnly ) )
qFatal( "rc2ui: Could not open output file '%s'", outputFile.latin1() );
out = new QTextStream( &fileOut );
} else {
out = new QTextStream( &buffer, IO_WriteOnly );
}
*out << "<!DOCTYPE UI><UI>" << endl;
writeClass( className );
wi(); *out << "<widget>"<< endl; indent();
writeClass( baseClass );
writeCString( "name", className );
writeRect( "geometry", x, y, w, h );
writeString( "caption", caption );
writeFont( fontname, pointsize );
do {
line = in->readLine().stripWhiteSpace();
if ( line == "END" )
continue;
widgetType = parseNext(line, ' ');
arguments = line.stripWhiteSpace();
while ( arguments[(int)arguments.length()-1] == ',' ||
arguments[(int)arguments.length()-1] == '|' )
arguments += " "+in->readLine().stripWhiteSpace();
wi(); *out << "<widget>" << endl; indent();
WidgetType ID = IDUnknown;
QString controlType;
QString widgetID;
QString widgetText;
bool hasText = FALSE;
bool isControl = FALSE;
bool isFrame = FALSE;
if ( widgetType == "PUSHBUTTON" ) {
ID = IDPushButton;
hasText = TRUE;
} else if ( widgetType == "DEFPUSHBUTTON" ) {
ID = IDPushButton;
hasText = TRUE;
} else if ( widgetType == "LTEXT" ) {
ID = IDLabel;
hasText = TRUE;
} else if ( widgetType == "CTEXT" ) {
ID = IDLabel;
hasText = TRUE;
} else if ( widgetType == "RTEXT" ) {
ID = IDLabel;
hasText = TRUE;
} else if ( widgetType == "EDITTEXT" ) {
ID = IDLineEdit;
} else if ( widgetType == "GROUPBOX" ) {
ID = IDGroupBox;
hasText = TRUE;
} else if ( widgetType == "COMBOBOX" ) {
ID = IDComboBox;
} else if ( widgetType == "LISTBOX" ) {
ID = IDListBox;
} else if ( widgetType == "SCROLLBAR" ) {
ID = IDScrollBar;
} else if ( widgetType == "CHECKBOX" ) {
ID = IDCheckBox;
hasText = TRUE;
} else if ( widgetType == "RADIOBUTTON" ) {
ID = IDRadioButton;
hasText = TRUE;
} else if ( widgetType == "CONTROL" ) {
isControl = TRUE;
widgetText = stripQM(parseNext( arguments ));
widgetID = parseNext( arguments );
controlType = stripQM(parseNext( arguments ));
styles = splitStyles(parseNext( arguments ));
if ( controlType == "Static" ) {
ID = IDLabel;
} else if ( controlType == "Button" ) {
if ( styles.contains("BS_AUTOCHECKBOX") ||
styles.contains("BS_3STATE") )
ID = IDCheckBox;
else if ( styles.contains("BS_AUTORADIOBUTTON") )
ID = IDRadioButton;
} else if ( controlType == "msctls_updown32" ) {
ID = IDSpinBox;
} else if ( controlType == "msctls_progress32" ) {
ID = IDProgressBar;
} else if ( controlType == "msctls_trackbar32" ) {
ID = IDSlider;
} else if ( controlType == "SysListView32" ) {
ID = IDIconView;
} else if ( controlType == "SysTreeView32" ) {
ID = IDListView;
} else if ( controlType == "SysTabControl32" ) {
ID = IDTabWidget;
} else if ( controlType == "SysAnimate32" ) {
ID = IDLabel;
} else if ( controlType == "RICHEDIT" ) {
ID = IDMultiLineEdit;
} else if ( controlType == "ComboBoxEx32" ) {
ID = IDComboBox;
} else if ( controlType == "" ) {
ID = IDCustom;
} else {
ID = IDUnknown;
}
} else
ID = IDUnknown;
if ( hasText )
widgetText = stripQM(parseNext( arguments ));
if ( isControl ) {
x = parseNext( arguments ).toInt();
y = parseNext( arguments ).toInt();
w = parseNext( arguments ).toInt();
h = parseNext( arguments ).toInt();
} else {
widgetID = parseNext( arguments );
x = parseNext( arguments ).toInt();
y = parseNext( arguments ).toInt();
w = parseNext( arguments ).toInt();
h = parseNext( arguments ).toInt();
styles.clear();
}
do {
extendedStyles = splitStyles(parseNext( arguments ));
for ( uint i = 0; i < extendedStyles.count(); i++ )
styles << (*extendedStyles.at(i));
} while ( arguments.find(',') > -1 );
switch ( ID ) {
case IDWidget:
break;
case IDPushButton:
{
writeClass("QPushButton");
writeCString( "name", useName("PushButton_"+widgetID) );
writeRect( "geometry", x, y, w, h );
writeString( "text", widgetText );
if ( widgetType == "DEFPUSHBUTTON" )
writeBool( "default", TRUE );
}
break;
case IDLabel:
{
isFrame = TRUE,
writeClass("QLabel");
writeCString( "name", useName("Label_"+widgetID) );
writeRect( "geometry", x,y,w,h );
writeString( "text", widgetText );
QString align;
if ( !styles.contains("SS_CENTERIMAGE") )
align += "|AlignTop";
else
align += "|AlignVCenter";
if ( widgetType == "LTEXT" ) {
align += "|AlignLeft";
} else if ( widgetType == "CTEXT") {
align += "|AlignHCenter";
} else if ( widgetType == "RTEXT") {
align += "|AlignRight";
}
writeSet("alignment", align );
}
break;
case IDCheckBox:
{
writeClass("QCheckBox");
writeCString("name", useName("CheckBox_"+widgetID) );
writeRect("geometry", x,y,w,h);
writeString("text", widgetText );
if ( styles.contains( "BS_3STATE" ) )
writeBool( "tristate", TRUE );
}
break;
case IDRadioButton:
{
writeClass("QRadioButton");
writeCString("name", useName("RadioButton_"+widgetID) );
writeRect("geometry", x,y,w,h);
writeString("text", widgetText );
}
break;
case IDGroupBox:
{
isFrame = TRUE;
writeClass("QGroupBox");
writeCString( "name", useName("GroupBox_"+widgetID) );
writeRect( "geometry", x,y,w,h );
writeString( "title", widgetText );
if ( !styles.contains( "WS_BORDER" ) )
styles.append( "WS_BORDER" );
}
break;
case IDLineEdit:
{
if ( !styles.contains("ES_MULTILINE") ) {
writeClass("QLineEdit");
writeCString( "name", useName("LineEdit_"+widgetID) );
} else {
writeClass("QMultiLineEdit");
writeCString( "name", useName("MultiLineEdit_"+widgetID) );
}
writeRect( "geometry", x,y,w,h );
QString align = "AlignTop";
if ( styles.contains("ES_CENTER") )
align+="|AlignHCenter";
else if ( styles.contains("ES_RIGHT") )
align+="|AlignRight";
else
align+="|AlignLeft";
writeSet("alignment", align);
}
break;
case IDMultiLineEdit:
{
writeClass("QMultiLineEdit");
writeCString("name", useName("MultiLineEdit_"+widgetID) );
writeRect("geometry", x,y,w,h );
}
break;
case IDIconView:
{
isFrame = TRUE;
writeClass("QIconView");
writeCString("name", useName("IconView_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( !styles.contains( "LVS_SINGLESEL" ) )
writeEnum( "selectionMode", "Extended" );
if ( styles.contains( "LVS_NOLABELWRAP" ) )
writeBool("wordWrapIconText", FALSE );
}
break;
case IDListView:
{
isFrame = TRUE;
writeClass("QListView");
writeCString("name", useName("ListView_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains( "TVS_LINESATROOT" ) )
writeBool( "rootIsDecorated", TRUE );
if ( styles.contains( "TVS_FULLROWSELECT" ) )
writeBool( "allColumnsShowFocus", TRUE );
}
break;
case IDProgressBar:
{
isFrame = TRUE;
writeClass("QProgressBar");
writeCString("name", useName("ProgressBar_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains("TBS_VERT") )
writeEnum("orientation", "Vertical");
else
writeEnum("orientation", "Horizontal");
}
break;
case IDTabWidget:
{
writeClass("QTabWidget");
writeCString("name", useName("TabWidget_"+widgetID) );
writeRect("geometry", x,y,w,h );
wi(); *out << "<widget>" << endl; indent();
writeClass("QWidget");
wi(); *out << "<attribute>" << endl; indent();
wi(); *out << "<name>title</name>" << endl;
wi(); *out << "<string>Tab1</string>" << endl; undent();
wi(); *out << "</attribute>" << endl; undent();
wi(); *out << "</widget>" << endl;
}
break;
case IDSpinBox:
{
isFrame = TRUE;
writeClass("QSpinBox");
writeCString("name", useName("SpinBox_"+widgetID) );
writeRect("geometry", x,y,w,h);
}
break;
case IDSlider:
{
writeClass("QSlider");
writeCString("name", useName("Slider_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains("TBS_VERT") )
writeEnum("orientation", "Vertical");
else
writeEnum("orientation", "Horizontal");
if ( !styles.contains("TBS_NOTICKS") )
writeEnum("tickmarks", "Left" );
}
break;
case IDComboBox:
{
writeClass("QComboBox");
writeCString("name", useName("ComboBox_"+widgetID) );
if ( isControl )
writeRect( "geometry", x,y,w,14 );
else
writeRect( "geometry", x,y,w,h );
}
break;
case IDListBox:
{
isFrame = TRUE;
writeClass("QListBox");
writeCString("name", useName("ListBox_"+widgetID) );
writeRect( "geometry", x,y,w,h );
if ( styles.contains("WS_HSCROLL") )
writeEnum("hScrollBarMode", "Auto");
else
writeEnum("hScrollBarMode", "AlwaysOff");
if ( styles.contains("WS_VSCROLL") )
writeEnum("vScrollBarMode", "Auto");
else
writeEnum("vScrollBarMode", "AlwaysOff");
if ( styles.contains("LBS_EXTENDEDSEL") )
writeEnum("selectionMode", "Extended");
else if ( styles.contains("LBS_MULTIPLESEL") )
writeEnum("selectionMode", "Multi");
else if ( styles.contains("LBS_NOSEL") )
writeEnum("selectionMode", "NoSelection");
else
writeEnum("selectionMode", "Single");
if ( !styles.contains( "NO WS_BORDER" ) )
styles.append( "WS_BORDER" );
}
break;
case IDScrollBar:
{
writeClass("QScrollBar");
writeCString("name", useName("ScrollBar_"+widgetID) );
writeRect("geometry", x,y,w,h );
if ( styles.contains("SBS_VERT") )
writeEnum("orientation", "Vertical");
else
writeEnum("orientation", "Horizontal");
}
break;
case IDCustom:
{
writeClass("QLabel");
writeCString("name", useName("Custom_"+widgetID) );
writeRect("geometry", x,y,w,h );
writeString("text", "Create a custom widget and place it here." );
}
default:
{
writeClass("QLabel");
writeCString("name", useName("Unknown_"+widgetID) );
writeRect("geometry", x,y,w,h );
writeString("text", QString("No support for %1.").arg(controlType) );
}
break;
}
writeStyles( styles, isFrame );
styles.clear();
undent();
wi(); *out << "</widget>" << endl;
} while ( line != "END" );
undent();
wi(); *out << "</widget>" << endl;
*out << "</UI>" << endl;
do {
line = in->readLine();
} while ( line.isEmpty() );
if ( !writeToFile )
target.append( buffer.copy() );
if (out) {
delete out;
out = 0;
}
fileOut.close();
if ( writeToFile )
printf( QDir::currentDirPath() + "/" + fileOut.name() + '\n' );
} while ( line != blockStart1 );
return TRUE;
}
int writeDN( INOUT STREAM *stream,
IN_OPT const DN_PTR *dnComponentList,
IN_TAG const int tag )
{
DN_COMPONENT *dnComponentPtr;
int size, iterationCount, status;
assert( isWritePtr( stream, sizeof( STREAM ) ) );
assert( dnComponentList == NULL || \
isReadPtr( dnComponentList, sizeof( DN_COMPONENT ) ) );
REQUIRES_S( tag == DEFAULT_TAG || ( tag >= 0 && tag < MAX_TAG_VALUE ) );
/* Special case for empty DNs */
if( dnComponentList == NULL )
return( writeConstructed( stream, 0, tag ) );
status = preEncodeDN( ( DN_COMPONENT * ) dnComponentList, &size );
if( cryptStatusError( status ) )
return( status );
/* Write the DN */
writeConstructed( stream, size, tag );
for( dnComponentPtr = ( DN_COMPONENT * ) dnComponentList, \
iterationCount = 0;
dnComponentPtr != NULL && \
iterationCount < FAILSAFE_ITERATIONS_MED;
dnComponentPtr = dnComponentPtr->next, iterationCount++ )
{
const DN_COMPONENT_INFO *dnComponentInfo = dnComponentPtr->typeInfo;
BYTE dnString[ MAX_ATTRIBUTE_SIZE + 8 ];
int dnStringLength;
/* Write the RDN wrapper */
if( dnComponentPtr->encodedRDNdataSize > 0 )
{
/* If it's the start of an RDN, write the RDN header */
writeSet( stream, dnComponentPtr->encodedRDNdataSize );
}
writeSequence( stream, dnComponentPtr->encodedAVAdataSize );
status = swrite( stream, dnComponentInfo->oid,
sizeofOID( dnComponentInfo->oid ) );
if( cryptStatusError( status ) )
return( status );
/* Convert the string to an ASN.1-compatible format and write it
out */
status = copyToAsn1String( dnString, MAX_ATTRIBUTE_SIZE,
&dnStringLength, dnComponentPtr->value,
dnComponentPtr->valueLength,
dnComponentPtr->valueStringType );
if( cryptStatusError( status ) )
return( status );
if( dnComponentPtr->asn1EncodedStringType == BER_STRING_IA5 && \
!dnComponentInfo->ia5OK )
{
/* If an IA5String isn't allowed in this instance, use a
T61String instead */
dnComponentPtr->asn1EncodedStringType = BER_STRING_T61;
}
status = writeCharacterString( stream, dnString, dnStringLength,
dnComponentPtr->asn1EncodedStringType );
if( cryptStatusError( status ) )
return( status );
}
ENSURES( iterationCount < FAILSAFE_ITERATIONS_MED );
return( CRYPT_OK );
}
static void doSerialize(A2PWriter writer, A2PType expected, ATerm value){
DKISIndexedSet sharedValues = writer->valueSharingMap;
int valueHash = hashValue(value);
int valueId = DKISget(sharedValues, (void*) value, (void*) expected, valueHash); /* TODO: Fix sharing (check types). */
if(valueId != -1){
writeByteToBuffer(writer->buffer, PDB_SHARED_FLAG);
printInteger(writer->buffer, valueId);
return;
}
switch(expected->id){
case PDB_VALUE_TYPE_HEADER:
serializeUntypedTerm(writer, value);
break;
case PDB_BOOL_TYPE_HEADER:
if(ATgetType(value) != AT_APPL){ fprintf(stderr, "Boolean didn't have AT_APPL type.\n"); exit(1); }
writeBool(writer, (ATermAppl) value);
break;
case PDB_INTEGER_TYPE_HEADER:
if(ATgetType(value) != AT_INT){ fprintf(stderr, "Integer didn't have AT_INT type.\n"); exit(1); }
writeInteger(writer, (ATermInt) value);
break;
case PDB_DOUBLE_TYPE_HEADER:
if(ATgetType(value) != AT_REAL){ fprintf(stderr, "Double didn't have AT_REAL type.\n"); exit(1); }
writeDouble(writer, (ATermReal) value);
break;
case PDB_STRING_TYPE_HEADER:
if(ATgetType(value) != AT_APPL || ATisQuoted(ATgetAFun((ATermAppl) value)) == ATfalse){ fprintf(stderr, "String didn't have 'quoted' AT_APPL type.\n"); ATabort(""); exit(1); }
writeString(writer, (ATermAppl) value);
break;
case PDB_SOURCE_LOCATION_TYPE_HEADER:
if(ATgetType(value) != AT_APPL){ fprintf(stderr, "Source location didn't have AT_APPL type.\n"); exit(1); }
writeSourceLocation(writer, (ATermAppl) value);
break;
case PDB_NODE_TYPE_HEADER:
if(ATgetType(value) != AT_APPL){ fprintf(stderr, "Node didn't have AT_APPL type.\n"); exit(1); }
{
ATermList annotations = (ATermList) ATgetAnnotations(value);
if(annotations == NULL){
writeNode(writer, expected, (ATermAppl) value);
}else{
if(((A2PNodeType) expected->theType)->declaredAnnotations == NULL){ fprintf(stderr, "Node term has annotations, but none are declared.\n"); exit(1); }
writeAnnotatedNode(writer, expected, (ATermAppl) value, annotations);
}
}
break;
case PDB_TUPLE_TYPE_HEADER:
if(ATgetType(value) != AT_APPL){ fprintf(stderr, "Tuple didn't have AT_APPL type.\n"); exit(1); }
writeTuple(writer, expected, (ATermAppl) value);
break;
case PDB_LIST_TYPE_HEADER:
if(ATgetType(value) != AT_LIST){ fprintf(stderr, "List didn't have AT_LIST type.\n"); exit(1); }
writeList(writer, expected, (ATermList) value);
break;
case PDB_SET_TYPE_HEADER:
if(ATgetType(value) != AT_LIST){ fprintf(stderr, "Set didn't have AT_LIST type.\n"); exit(1); }
writeSet(writer, expected, (ATermList) value);
break;
case PDB_RELATION_TYPE_HEADER:
if(ATgetType(value) != AT_LIST){ fprintf(stderr, "Relation didn't have AT_LIST type.\n"); exit(1); }
writeRelation(writer, expected, (ATermList) value);
break;
case PDB_MAP_TYPE_HEADER:
if(ATgetType(value) != AT_LIST){ fprintf(stderr, "Map didn't have AT_LIST type.\n"); exit(1); }
writeMap(writer, expected, (ATermList) value);
break;
case PDB_CONSTRUCTOR_TYPE_HEADER:
if(ATgetType(value) != AT_APPL){ fprintf(stderr, "Constructor didn't have AT_APPL type.\n"); exit(1); }
{
ATermList annotations = (ATermList) ATgetAnnotations(value);
if(annotations == NULL){
writeConstructor(writer, expected, (ATermAppl) value);
}else{
if(((A2PConstructorType) expected->theType)->declaredAnnotations == NULL){ fprintf(stderr, "Constructor term has annotations, but none are declared.\n"); exit(1); }
writeAnnotatedConstructor(writer, expected, (ATermAppl) value, annotations);
}
}
break;
case PDB_ADT_TYPE_HEADER:
writeADT(writer, expected, value);
break;
default:
fprintf(stderr, "Unserializable type: %d\n.", expected->id);
exit(1);
}
DKISstore(sharedValues, (void*) value, (void*) expected, valueHash);
}
static int writePkiHeader( INOUT STREAM *stream,
INOUT SESSION_INFO *sessionInfoPtr,
INOUT CMP_PROTOCOL_INFO *protocolInfo )
{
CRYPT_HANDLE senderNameObject = DUMMY_INIT, recipNameObject = DUMMY_INIT;
STREAM nullStream;
MESSAGE_DATA msgData;
#ifdef USE_FULL_HEADERS
const BOOLEAN sendFullHeader = TRUE;
#else
BOOLEAN sendFullHeader = FALSE;
#endif /* USE_FULL_HEADERS */
BOOLEAN sendClibID = FALSE, sendCertID = FALSE, sendMacInfo = FALSE;
BOOLEAN sendUserID = FALSE;
int senderNameLength, recipNameLength, attributeLength = 0;
int protInfoLength = DUMMY_INIT, totalLength, hashAlgo, status;
assert( isWritePtr( stream, sizeof( STREAM ) ) );
assert( isWritePtr( sessionInfoPtr, sizeof( SESSION_INFO ) ) );
assert( isWritePtr( protocolInfo, sizeof( CMP_PROTOCOL_INFO ) ) );
/* Determine which of the many unnecessary and inexplicable bits of the
CMP header we actually have to send:
sendCertID: Sent on the first message where it's required (which
isn't necessarily the first message in an exchange, for example
it's not used in an ir/ip), either to identify the CA's cert in
a CTL sent in a PKIBoot response or to identify the signing
certificate when we're using signature-based message
authentication.
sendClibID: Sent on the first message to tell the other side that
this is a cryptlib client/server.
sendFullHeader: Sent if the other side isn't running cryptlib, unless
we're doing PKIBoot, for which we couldn't send full headers even
if we wanted to
sendMacInfo: Sent if we're using MAC integrity protection and the
the other side isn't running cryptlib, or if this is the first
message.
sendUserID: Sent on the first message or if we're sending full
headers, provided that it's actually available to send */
if( !( sessionInfoPtr->protocolFlags & CMP_PFLAG_CERTIDSENT ) && \
( ( isServer( sessionInfoPtr ) && \
protocolInfo->operation == CTAG_PB_GENM ) || \
!protocolInfo->useMACsend ) )
sendCertID = TRUE;
if( !( sessionInfoPtr->protocolFlags & CMP_PFLAG_CLIBIDSENT ) )
sendClibID = TRUE;
#ifndef USE_FULL_HEADERS
if( !protocolInfo->isCryptlib && \
protocolInfo->operation != CTAG_PB_GENM )
sendFullHeader = TRUE;
#endif /* !USE_FULL_HEADERS */
if( protocolInfo->useMACsend && \
!( protocolInfo->isCryptlib && \
( sessionInfoPtr->protocolFlags & CMP_PFLAG_MACINFOSENT ) ) )
sendMacInfo = TRUE;
if( ( sendFullHeader || \
!( sessionInfoPtr->protocolFlags & CMP_PFLAG_USERIDSENT ) ) && \
( protocolInfo->userIDsize > 0 ) )
sendUserID = TRUE;
REQUIRES( !sendFullHeader || !protocolInfo->headerRead || \
( protocolInfo->userIDsize > 0 && \
protocolInfo->userIDsize < MAX_INTLENGTH_SHORT ) );
REQUIRES( protocolInfo->transIDsize > 0 && \
protocolInfo->transIDsize < MAX_INTLENGTH_SHORT );
/* Get any other state information that we may need */
status = krnlSendMessage( sessionInfoPtr->ownerHandle,
IMESSAGE_GETATTRIBUTE, &hashAlgo,
CRYPT_OPTION_ENCR_HASH );
ENSURES( cryptStatusOK( status ) );
protocolInfo->hashAlgo = hashAlgo; /* int vs.enum */
/* Determine how big the sender and recipient information will be. We
shouldn't need to send a recipient name for an ir because it won't
usually be known yet, but various implementations can't handle a
zero-length GeneralName so we supply it if it's available even though
it's redundant */
if( sendFullHeader )
{
status = initDNInfo( sessionInfoPtr, &senderNameObject,
&recipNameObject, &senderNameLength,
&recipNameLength,
( protocolInfo->operation == CTAG_PB_IR ) ? \
TRUE : FALSE,
protocolInfo->cryptOnlyKey );
if( cryptStatusError( status ) )
return( status );
}
else
{
/* We're not using sender or recipient information since it doesn't
serve any useful purpose, just set the fields to an empty
SEQUENCE */
senderNameLength = recipNameLength = sizeofObject( 0 );
}
/* Determine how big the remaining header data will be */
sMemNullOpen( &nullStream );
if( protocolInfo->useMACsend )
{
status = writeMacInfo( &nullStream, protocolInfo, sendMacInfo );
}
else
{
status = writeContextAlgoID( &nullStream, protocolInfo->authContext,
protocolInfo->hashAlgo );
}
if( cryptStatusOK( status ) )
protInfoLength = stell( &nullStream );
sMemClose( &nullStream );
if( cryptStatusError( status ) )
return( status );
if( sendClibID )
{
attributeLength += sizeofObject( \
sizeofOID( OID_CRYPTLIB_PRESENCECHECK ) + \
sizeofObject( 0 ) );
}
if( sendCertID )
{
const int certIDsize = sizeofCertID( protocolInfo->authContext );
ENSURES( certIDsize > 0 && certIDsize < MAX_INTLENGTH_SHORT );
attributeLength += certIDsize;
}
totalLength = sizeofShortInteger( CMP_VERSION ) + \
objSize( senderNameLength ) + objSize( recipNameLength ) + \
objSize( protInfoLength ) + \
objSize( sizeofObject( protocolInfo->transIDsize ) );
if( sendUserID )
totalLength += objSize( sizeofObject( protocolInfo->userIDsize ) );
if( sendFullHeader )
{
if( protocolInfo->senderNonceSize > 0 )
totalLength += objSize( \
sizeofObject( protocolInfo->senderNonceSize ) );
if( protocolInfo->recipNonceSize > 0 )
totalLength += objSize( \
sizeofObject( protocolInfo->recipNonceSize ) );
}
if( attributeLength > 0 )
totalLength += objSize( objSize( attributeLength ) );
/* Perform an early check for data-size problems before we go through
all of the following code */
if( sizeofObject( totalLength ) <= 0 || \
sizeofObject( totalLength ) > sMemDataLeft( stream ) )
return( CRYPT_ERROR_OVERFLOW );
/* Write the PKI header wrapper, version information, and sender and
recipient names if there's name information present */
writeSequence( stream, totalLength );
writeShortInteger( stream, CMP_VERSION, DEFAULT_TAG );
if( sendFullHeader )
{
writeConstructed( stream, senderNameLength, 4 );
if( senderNameObject != CRYPT_ERROR )
{
status = exportAttributeToStream( stream, senderNameObject,
CRYPT_IATTRIBUTE_SUBJECT );
if( cryptStatusError( status ) )
return( status );
}
else
writeSequence( stream, 0 );
writeConstructed( stream, recipNameLength, 4 );
if( recipNameObject != CRYPT_ERROR )
{
status = exportAttributeToStream( stream, recipNameObject,
CRYPT_IATTRIBUTE_SUBJECT );
}
else
status = writeSequence( stream, 0 );
}
else
{
/* This is one of the portions of CMP where an optional field is
marked as mandatory, to balance out the mandatory fields that are
marked as optional. To work around this we write the names as
zero-length DNs */
writeConstructed( stream, senderNameLength, 4 );
writeSequence( stream, 0 );
writeConstructed( stream, recipNameLength, 4 );
status = writeSequence( stream, 0 );
}
if( cryptStatusError( status ) )
return( status );
/* Write the protection information, assorted nonces and IDs, and extra
information that the other side may be able to make use of */
writeConstructed( stream, protInfoLength, CTAG_PH_PROTECTIONALGO );
if( protocolInfo->useMACsend )
{
status = writeMacInfo( stream, protocolInfo, sendMacInfo );
sessionInfoPtr->protocolFlags |= CMP_PFLAG_MACINFOSENT;
}
else
{
status = writeContextAlgoID( stream, protocolInfo->authContext,
protocolInfo->hashAlgo );
}
if( cryptStatusError( status ) )
return( status );
if( sendUserID )
{
/* We're using full headers or we're the client sending our first
message, identify the sender key */
writeConstructed( stream, objSize( protocolInfo->userIDsize ),
CTAG_PH_SENDERKID );
writeOctetString( stream, protocolInfo->userID,
protocolInfo->userIDsize, DEFAULT_TAG );
DEBUG_PRINT(( "%s: Writing userID.\n",
protocolInfo->isServer ? "SVR" : "CLI" ));
DEBUG_DUMP_HEX( protocolInfo->isServer ? "SVR" : "CLI",
protocolInfo->userID, protocolInfo->userIDsize );
sessionInfoPtr->protocolFlags |= CMP_PFLAG_USERIDSENT;
}
writeConstructed( stream, objSize( protocolInfo->transIDsize ),
CTAG_PH_TRANSACTIONID );
status = writeOctetString( stream, protocolInfo->transID,
protocolInfo->transIDsize, DEFAULT_TAG );
if( cryptStatusError( status ) )
return( status );
if( sendFullHeader )
{
if( protocolInfo->senderNonceSize > 0 )
{
/* We're using nonces, generate a new sender nonce (the initial
nonce will have been set when the protocol state was
initialised) */
setMessageData( &msgData, protocolInfo->senderNonce,
protocolInfo->senderNonceSize );
krnlSendMessage( SYSTEM_OBJECT_HANDLE, IMESSAGE_GETATTRIBUTE_S,
&msgData, CRYPT_IATTRIBUTE_RANDOM_NONCE );
writeConstructed( stream,
objSize( protocolInfo->senderNonceSize ),
CTAG_PH_SENDERNONCE );
status = writeOctetString( stream, protocolInfo->senderNonce,
protocolInfo->senderNonceSize,
DEFAULT_TAG );
}
if( protocolInfo->recipNonceSize > 0 )
{
writeConstructed( stream,
objSize( protocolInfo->recipNonceSize ),
CTAG_PH_RECIPNONCE );
status = writeOctetString( stream, protocolInfo->recipNonce,
protocolInfo->recipNonceSize,
DEFAULT_TAG );
}
}
if( cryptStatusError( status ) )
return( status );
if( attributeLength > 0 )
{
ENSURES( sendClibID || sendCertID );
/* We haven't sent any messages yet, let the other side know that
we're running cryptlib and identify our signing certificate as
required */
writeConstructed( stream, objSize( attributeLength ),
CTAG_PH_GENERALINFO );
writeSequence( stream, attributeLength );
if( sendClibID )
{
sessionInfoPtr->protocolFlags |= CMP_PFLAG_CLIBIDSENT;
writeSequence( stream, sizeofOID( OID_CRYPTLIB_PRESENCECHECK ) + \
sizeofObject( 0 ) );
writeOID( stream, OID_CRYPTLIB_PRESENCECHECK );
status = writeSet( stream, 0 );
}
if( sendCertID )
{
sessionInfoPtr->protocolFlags |= CMP_PFLAG_CERTIDSENT;
status = writeCertID( stream, protocolInfo->authContext );
}
}
return( status );
}