herr_t write_za(hid_t zafid, char* sname)
{
hid_t zaid = FAIL;
/* Create a Swath. */
zaid = HE5_ZAcreate(zafid, sname);
/* Define dimension. */
write_dimension(zaid);
/* Define geolocation fields. */
write_field_1d(zaid, "Pressure", "ZDim", 4);
write_field_1d(zaid, "Latitude", "YDim", 8);
/* Define data fields. */
write_field_2d(zaid, "Temperature");
/* Write attributes. */
write_attr(zaid, "Pressure", "units", "hPa");
write_attr(zaid, "Latitude", "units", "degrees_north");
write_attr(zaid, "Temperature", "units", "K");
/* Close the Swath. */
return HE5_ZAdetach(zaid);
}
int main(int argc, char *argv[])
{
intn status = 0;
char filename[]= "swath_2_3d_2x2yz.hdf";
char swathname[]= "Swath";
/* Create an HDF-EOS2 file. */
int32 swfid = SWopen(filename, DFACC_RDWR);
if(swfid == -1){
fprintf(stderr, "SWopen() failed.\n");
return 1;
}
/* Create a swath. */
write_swath(swfid, "Swath1", 4, 8, 4);
write_swath(swfid, "Swath2", 8, 16, 8);
/* Close the HDF-EOS2 file. */
status= SWclose(swfid);
if (status == -1) {
fprintf(stderr, "SWclose() failed.\n");
return 1;
}
/* Write attriubtes using generic HDF4 SDS interface. */
write_attr(filename);
return 0;
}
herr_t write_field_2d(hid_t gdid, char* field_name)
{
int i = 0;
int j = 0;
float temp[4][8]; /* longitude-xdim first. */
hsize_t edge[2];
hssize_t start[2];
/* Fill data. */
for (i=0; i < 4; i++)
for(j=0; j < 8; j++)
temp[i][j] = (float)(10 + i);
start[0] = 0;
start[1] = 0;
edge[0] = 4; /* latitude-ydim first */
edge[1] = 8;
/* Create a field. */
HE5_GDdeffield(gdid, field_name, "YDim,XDim", NULL,
H5T_NATIVE_FLOAT, 0);
HE5_GDwritefield(gdid, field_name, start, NULL, edge, temp);
/* Write attribute. */
return write_attr(gdid, field_name, "units", "K");
}
herr_t write_field_1d(hid_t gdid, char* field_name, char* dim_name, int size,
char* unit)
{
int dim = 0;
float val = 0.0;
float* var = NULL;
hssize_t start[1];
hsize_t count[1];
start[0] = 0;
count[0] = size;
var = (float*) malloc(size * sizeof(float));
while(dim < size) {
var[dim] = val;
val = val + 1.0;
dim++;
}
HE5_GDdeffield(gdid, field_name, dim_name, NULL, H5T_NATIVE_FLOAT, 0);
HE5_GDwritefield(gdid, field_name, start, NULL, count, var);
if(var != NULL)
free(var);
return write_attr(gdid, field_name, "units", unit);
}
herr_t write_field_1d(hid_t swid, char* field_name, int geo, int size,
char* dim_name, char* unit)
{
int dim = 0;
float val = 0.0;
float* var = NULL;
hssize_t start[1];
hsize_t count[1];
start[0] = 0;
count[0] = size;
var = (float*) malloc(size * sizeof(float));
if(var == NULL){
fprintf(stderr, "Out of Memory\n");
return FAIL;
}
while(dim < size) {
var[dim] = val;
val = val + 1.0;
dim++;
}
if(1 == geo)
HE5_SWdefgeofield(swid, field_name, dim_name, NULL,
H5T_NATIVE_FLOAT, 0);
if(0 == geo)
HE5_SWdefdatafield(swid, field_name, dim_name, NULL,
H5T_NATIVE_FLOAT, 0);
HE5_SWwritefield(swid, field_name, start, NULL, count, var);
if(var != NULL)
free(var);
return write_attr(swid, field_name, "units", unit);
}
herr_t write_field_3d(hid_t gdid, char* field_name)
{
int ydim = 0;
int xdim = 0;
int zdim = 0;
float val = 0.0;
float var[2][4][8];
hssize_t start[3];
hsize_t count[3];
start[0] = 0;
start[1] = 0;
start[2] = 0;
count[0] = 2;
count[1] = 4;
count[2] = 8;
while(zdim < 2) {
while(ydim < 4) {
while(xdim < 8) {
var[zdim][ydim][xdim] = val;
val = val + 1.0;
xdim++;
}
ydim++;
xdim = 0;
}
zdim++;
ydim = 0;
xdim = 0;
}
HE5_GDdeffield(gdid, field_name, "ZDim,YDim,XDim", NULL,
H5T_NATIVE_FLOAT, 0);
HE5_GDwritefield(gdid, field_name, start, NULL, count, var);
return write_attr(gdid, field_name, "units", "K");
}
herr_t write_field_2d(hid_t swid, char* field_name, int geo, char* dim_name,
char* unit)
{
int dim1 = 0;
int dim0 = 0;
float val = 0.0;
float var[4][8];
hssize_t start[2];
hsize_t count[2];
start[0] = 0;
start[1] = 0;
count[0] = 4;
count[1] = 8;
while(dim1 < 4) {
while(dim0 < 8) {
var[dim1][dim0] = val;
val = val + 1.0;
dim0++;
}
dim1++;
dim0 = 0;
}
if(1 == geo)
HE5_SWdefgeofield(swid, field_name, dim_name, NULL,
H5T_NATIVE_FLOAT, 0);
if(0 == geo)
HE5_SWdefdatafield(swid, field_name, dim_name, NULL,
H5T_NATIVE_FLOAT, 0);
HE5_SWwritefield(swid, field_name, start, NULL, count, var);
return write_attr(swid, field_name, "units", unit);
}
int
NdbOperation::write_attr(Uint32 anAttrId, Uint32 RegDest)
{
return write_attr(m_currentTable->getColumn(anAttrId), RegDest);
}
int
NdbOperation::write_attr(const char* anAttrName, Uint32 RegDest)
{
return write_attr(m_currentTable->getColumn(anAttrName), RegDest);
}
std::vector<bytestring> silvia_irma_issuer::get_issue_commands_round_1()
{
assert(irma_issuer_state == IRMA_ISSUER_SELECTED);
std::vector<bytestring> commands;
////////////////////////////////////////////////////////////////////
// Step 3: start issuance
////////////////////////////////////////////////////////////////////
// FIXME: context is randomly generated and kept as state!
mpz_class context_mpz = silvia_rng::i()->get_random(SYSPAR(l_H));
context = bytestring(context_mpz);
bytestring id;
id += (unsigned char) ((ispec->get_credential_id() & 0xff00) >> 8);
id += (unsigned char) (ispec->get_credential_id() & 0x00ff);
bytestring attr_count;
attr_count += (unsigned char) ((ispec->get_attributes().size() + 1) & 0xff00) >> 8; // +1 for expires
attr_count += (unsigned char) ((ispec->get_attributes().size() + 1) & 0x00ff); // +1 for expires
// FIXME: actually do something with these flags!
bytestring attr_flags = "000000";
bytestring timestamp = (unsigned long) time(NULL);
timestamp = timestamp.substr(timestamp.size() - 4);
PAD_TO_SYSPAR(context, l_H);
silvia_apdu issue_start(0x80, 0x10, 0x00, 0x00);
issue_start.append_data(id);
issue_start.append_data(attr_count);
issue_start.append_data(attr_flags);
issue_start.append_data(context);
issue_start.append_data(timestamp);
commands.push_back(issue_start.get_apdu());
////////////////////////////////////////////////////////////////////
// Step 4: write the public key to the card
////////////////////////////////////////////////////////////////////
// n
silvia_apdu issue_set_n(0x80, 0x11, 0x00, 0x00);
bytestring n(pubkey->get_n());
// Pad if necessary
PAD_TO_SYSPAR(n, l_n);
issue_set_n.append_data(n);
commands.push_back(issue_set_n.get_apdu());
// S
silvia_apdu issue_set_S(0x80, 0x11, 0x01, 0x00);
bytestring S(pubkey->get_S());
// Pad if necessary
PAD_TO_SYSPAR(S, l_n);
issue_set_S.append_data(S);
commands.push_back(issue_set_S.get_apdu());
// Z
silvia_apdu issue_set_Z(0x80, 0x11, 0x02, 0x00);
bytestring Z(pubkey->get_Z());
// Pad if necessary
PAD_TO_SYSPAR(Z, l_n);
issue_set_Z.append_data(Z);
commands.push_back(issue_set_Z.get_apdu());
for (int i = 0; i < (ispec->get_attributes().size() + 2); i++)
{
silvia_apdu issue_set_R(0x80, 0x11, 0x03, (unsigned char) (0x00 + i));
bytestring R(pubkey->get_R()[i]);
// Pad if necessary
PAD_TO_SYSPAR(R, l_n);
issue_set_R.append_data(R);
commands.push_back(issue_set_R.get_apdu());
}
////////////////////////////////////////////////////////////////////
// Step 5: write the attributes to the card
////////////////////////////////////////////////////////////////////
issue_attributes.clear();
// Create the "expires+metadata" attribute
bytestring expires_and_metadata;
// Add metadata version number
expires_and_metadata += IRMA_CREDENTIAL_METADATA_VERSION;
// Add expiration date
int expires = ispec->get_expires();
expires_and_metadata += (unsigned char) ((expires & 0x00ff0000) >> 16);
expires_and_metadata += (unsigned char) ((expires & 0x0000ff00) >> 8);
expires_and_metadata += (unsigned char) (expires & 0x000000ff);
// Add credential ID
expires_and_metadata += (unsigned char) ((ispec->get_credential_id() & 0xff00) >> 8);
expires_and_metadata += (unsigned char) (ispec->get_credential_id() & 0x00ff);
metadata_attribute = new silvia_integer_attribute(expires_and_metadata.mpz_val());
silvia_apdu write_expires_attr(0x80, 0x12, 0x01, 0x00);
write_expires_attr.append_data(metadata_attribute->bs_rep());
commands.push_back(write_expires_attr.get_apdu());
issue_attributes.push_back(metadata_attribute);
// Create all other attributes
unsigned char ctr = 0x02;
for (std::vector<silvia_attribute*>::iterator i = ispec->get_attributes().begin(); i != ispec->get_attributes().end(); i++, ctr++)
{
silvia_apdu write_attr(0x80, 0x12, ctr, 0x00);
write_attr.append_data((*i)->bs_rep());
commands.push_back(write_attr.get_apdu());
issue_attributes.push_back(*i);
}
issuer->set_attributes(issue_attributes);
////////////////////////////////////////////////////////////////////
// Step 6: get issue commitment from card
////////////////////////////////////////////////////////////////////
silvia_apdu issue_commitment_nonce(0x80, 0x1a, 0x00, 0x00);
bytestring n1(issuer->get_issuer_nonce());
// pad if necessary
PAD_TO_SYSPAR(n1, l_statzk);
silvia_apdu issue_commitment(0x80, 0x1a, 0x00, 0x00);
issue_commitment.append_data(n1);
commands.push_back(issue_commitment.get_apdu());
////////////////////////////////////////////////////////////////////
// Step 7: get proof values c, v'^, s^
////////////////////////////////////////////////////////////////////
silvia_apdu get_proof_c(0x80, 0x1b, 0x01, 0x00);
silvia_apdu get_proof_v_prime_hat(0x80, 0x1b, 0x02, 0x00);
silvia_apdu get_proof_s_hat(0x80, 0x1b, 0x03, 0x00);
commands.push_back(get_proof_c.get_apdu());
commands.push_back(get_proof_v_prime_hat.get_apdu());
commands.push_back(get_proof_s_hat.get_apdu());
////////////////////////////////////////////////////////////////////
// Step 8: get card nonce n2
////////////////////////////////////////////////////////////////////
silvia_apdu get_card_nonce_n2(0x80, 0x1c, 0x00, 0x00);
commands.push_back(get_card_nonce_n2.get_apdu());
irma_issuer_state = IRMA_ISSUER_WAIT_COMMITMENT;
return commands;
}
void
StyleTask::markup( const Token &t )
{
ComplexTask::markup(t);
if (t.type() == START) {
/*
* Process Stylesheet start tags...
*/
switch(t.olaf()){
case OLAF::Stylesheet:
if (f_base >= 0) {
throw
(Unexpected
("illegal nested STYLESHEET architectural form"));
}
f_base = t.level();
#ifdef FISH_DEBUG
DBUG_PRINT("Style", ("Style level=`%d'\n", f_base));
#endif
break;
case OLAF::Path:
if ( f_pathbuf != NULL ) {
delete f_pathbuf;
}
f_pathbuf = new FlexBuffer();
f_buffer = f_pathbuf;
f_dataMode = inPath;
break;
case OLAF::Select:
f_buffer->writeStr( "[" );
f_select = t.level();
break;
case OLAF::Online:
f_buffer = onlineSS;
// feature_depth->clear();
if ( f_pathbuf == NULL ) {
throw(Unexpected("no path available for online feature."));
}
report_position(f_buffer, t.file(), t.line());
f_buffer->writeStr( f_pathbuf->GetBuffer() );
f_buffer->writeStr( "\n" );
write_tabs( f_buffer, feature_depth, '\t');
f_buffer->writeStr( "{\n" );
feature_depth->push(t.level());
break;
case OLAF::Print:
f_buffer = printSS;
// feature_depth->clear();
if ( f_pathbuf == NULL ) {
throw(Unexpected("no path available for print feature."));
}
report_position(f_buffer, t.file(), t.line());
f_buffer->writeStr( f_pathbuf->GetBuffer() );
f_buffer->writeStr( "\n" );
write_tabs( f_buffer, feature_depth, '\t');
f_buffer->writeStr( "{\n" );
feature_depth->push( t.level() );
break;
case OLAF::AutoNumber:
report_position(onlineSS, t.file(), t.line());
autonumber(onlineSS, t);
report_position(printSS, t.file(), t.line());
autonumber(printSS, t);
break;
case OLAF::FeatureText:
report_position(f_buffer, t.file(), t.line());
write_tabs( f_buffer, feature_depth, '\t');
f_buffer->writeStr( t.giName() );
f_buffer->writeStr( ": " );
f_dataMode = startContent;
break;
case OLAF::AutoRef:
{
const AttributeRec *arec;
int id = SGMLName::intern("ID");
if((arec = t.LookupAttr(id))){
if(f_dataMode == inContent){
f_buffer->writeStr(" + ");
}
f_buffer->writeStr(arec->getAttrValueString());
f_dataMode = inContent;
} /* else document is not conforming... sgmls will report error */
}
break;
case OLAF::Feature:
report_position(f_buffer, t.file(), t.line());
write_tabs( f_buffer, feature_depth, '\t');
f_buffer->writeStr( t.giName() );
f_buffer->writeStr( ": " );
const AttributeRec *arec;
/*
* Is it an enumeration feature?
*/
if((arec = t.LookupAttr(OLAF::OL_Choice))){
/* OL_Choice can only be applied to NAME attributes, hence
we don't neet to worryabout "'s in the attribute value.
*/
/* except TRUE and FALSE....*/
const char *val = arec->getAttrValueString();
int quotes = !isdigit(val[0])
&& strcmp(val, "TRUE") != 0
&& strcmp(val, "FALSE") != 0
&& val[0] != '@';
if (quotes) f_buffer->writeStr("\"");
f_buffer->writeStr(val);
if (quotes) f_buffer->writeStr("\" ");
}else{
f_buffer->writeStr( " {\n" );
for (arec = t.GetFirstAttr();
arec != NULL;
arec = t.GetNextAttr( arec )) {
if (( arec->getAttrValueString() != NULL ) &&
( arec->getAttrName() != OLAF::OLIAS )) {
write_tabs( f_buffer, feature_depth, '\t');
f_buffer->put('\t');
write_attr(f_buffer, arec);
f_buffer->writeStr( ",\n" );
}
}
feature_depth->push(t.level());
}
break;
}
/*
* first time we see OL-ID="...", spawn an OL_Data to collect the id
*/
if ((f_base >= 0) && (f_locator == NULL) &&
(t.LookupAttr(OLAF::OL_id))) {
#ifdef FISH_DEBUG
DBUG_PRINT("Style", ("spawning locator collection subtask\n"));
#endif
f_locator = new OL_Data(t, OLAF::OL_id, REMOVE_SPACES);
addSubTask( f_locator );
}
}
else if (t.type() == END) {
if (f_base > 0) {
int topelement;
if ( !feature_depth->empty() ) {
if ( (topelement = feature_depth->top()) ) {
if ( topelement == t.level() ) {
topelement = feature_depth->pop();
write_tabs( f_buffer, feature_depth, '\t');
if(feature_depth->empty()){
f_buffer->writeStr("}\n");
}
else {
f_buffer->writeStr("},\n");
}
}else if ( topelement + 1 == t.level() ) {
/* need a new-line at end of FeatureText data */
f_buffer->writeStr(",\n");
}
}
}
if (t.level() == f_base) {
/* found end of stylesheet... write out StyleSheet data */
#ifdef FISH_DEBUG
DBUG_PRINT("Style", ("found end of stylesheet write out StyleSheet data\n"));
#endif
write_record();
}
else if(t.level() == f_select){
f_buffer->writeStr( "]" );
f_select = -1;
}
}
}
}
