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; } } } }