static QueryCondition* create_condition(STATE, Array* ary) {
if(ary->size() < 2) return 0;
Symbol* what = try_as<Symbol>(ary->get(state, 0));
Object* arg = ary->get(state, 1);
if(what == state->symbol("kind_of")) {
if(Module* mod = try_as<Module>(arg)) {
return new KindofCondition(mod);
}
} else if(what == state->symbol("object_id")) {
if(Fixnum* id = try_as<Fixnum>(arg)) {
return new ObjectIdCondition(id);
}
} else if(what == state->symbol("ivar")) {
if(Symbol* ivar = try_as<Symbol>(arg)) {
return new HasIvarCondition(ivar);
}
} else if(what == state->symbol("method")) {
if(Symbol* method = try_as<Symbol>(arg)) {
return new HasMethodCondition(method);
}
} else if(what == state->symbol("references")) {
return new ReferencesCondition(arg);
} else if(what == state->symbol("and") ||
what == state->symbol("or")) {
if(ary->size() != 3) return 0;
QueryCondition* left = 0;
QueryCondition* right = 0;
if(Array* sub = try_as<Array>(arg)) {
left = create_condition(state, sub);
}
if(!left) return 0;
if(Array* sub = try_as<Array>(ary->get(state, 2))) {
right = create_condition(state, sub);
}
if(!right) {
delete left;
return 0;
}
if(what == state->symbol("and")) {
return new AndCondition(left, right);
} else {
return new OrCondition(left, right);
}
}
return 0;
}
int main()
{
try
{
using once = Once;
using times = Times;
// run-time configurable:
const int Nsweep = 1;
const int Nsection = 2;
const bool onceX = true;
auto scanner = create_scanner ( "Z" );
const auto distance = create_condition( "123 nm" );
const auto threshold = create_condition( "chan1", "<=", "2.7 V" );
Curve curve;
curve.times( Nsweep )
.scans( scanner )
.add ( Retract().stop_on( distance ) ).unless( onceX )
.add ( once ( Retract().stop_on( distance ) ) ).when ( onceX )
.add ( times( Nsection )
.add ( Dwell() )
.add ( Approach().stop_on( threshold ) )
.add ( Dwell() )
.add ( Retract ().stop_on( distance ) ) )
;
std::cout << "\n1.curve.sweep(): "; curve.sweep();
std::cout << "\n2.curve.sweep(): "; curve.sweep();
}
catch ( std::exception const & e )
{
std::cout << "Error: " << e.what() << std::endl;
}
}
rampart_saml_token_t * AXIS2_CALL
create_saml_token(const axutil_env_t *env)
{
oxs_sign_ctx_t *sign_ctx = NULL;
oxs_x509_cert_t *cert = NULL;
openssl_pkey_t *prv_key = NULL;
rampart_saml_token_t *saml = NULL;
axutil_date_time_t *time = NULL;
saml_assertion_t *assertion = NULL;
axiom_node_t *node = NULL;
axis2_char_t *prv_key_file = NULL;
axis2_char_t *certificate_file = NULL;
/*
* Create a rampart_saml_token_t to give to the Rampart/C
* Here the token type is protection token.
*/
saml = rampart_saml_token_create(env, NULL, RAMPART_ST_CONFIR_TYPE_HOLDER_OF_KEY);
time = axutil_date_time_create(env);
assertion = saml_assertion_create(env);
if (assertion)
{
saml_assertion_set_minor_version(assertion, env, 1);
saml_assertion_set_issue_instant(assertion, env, time);
saml_assertion_set_issuer(assertion, env, "http://ws.apache.org/rampart/c");
saml_assertion_add_condition(assertion, env, create_condition(env));
saml_assertion_set_not_before(assertion, env, axutil_date_time_create(env));
saml_assertion_add_statement(assertion, env, create_auth_statement(env, saml));
}
/* Load the private key from file*/
prv_key_file = axutil_stracat(env, axis2c_home, PRIVATE_KEY_FILE);
certificate_file = axutil_stracat(env, axis2c_home, CERTIFICATE_FILE);
prv_key = oxs_key_mgr_load_private_key_from_pem_file(env, prv_key_file, PRIVATE_KEY_PASSWORD);
cert = oxs_key_mgr_load_x509_cert_from_pem_file(env, certificate_file);
sign_ctx = oxs_sign_ctx_create(env);
saml_util_set_sig_ctx_defaults(sign_ctx, env, "AssertionID");
oxs_sign_ctx_set_private_key(sign_ctx, env, prv_key);
oxs_sign_ctx_set_certificate(sign_ctx, env, cert);
saml_assertion_set_signature(assertion, env, sign_ctx);
node = saml_assertion_to_om(assertion, NULL, env);
rampart_saml_token_set_assertion(saml, env, node);
rampart_saml_token_set_token_type(saml, env, RAMPART_ST_TYPE_PROTECTION_TOKEN);
saml_assertion_free(assertion, env);
return saml;
}
axiom_node_t *
create_saml_token(axutil_env_t *env)
{
axutil_date_time_t *time = NULL;
saml_assertion_t *assertion = NULL;
axiom_node_t *node = NULL;
time = axutil_date_time_create(env);
assertion = saml_assertion_create(env);
if (assertion)
{
saml_assertion_set_minor_version(assertion, env, 1);
saml_assertion_set_issue_instant(assertion, env, time);
saml_assertion_set_issuer(assertion, env, "http://ws.apache.org/rampart/c");
saml_assertion_add_condition(assertion, env, create_condition(env));
saml_assertion_set_not_before(assertion, env, axutil_date_time_create(env));
saml_assertion_add_statement(assertion, env, create_auth_statement(env));
}
node = saml_assertion_to_om(assertion, NULL, env);
saml_assertion_free(assertion, env);
return node;
}
Object* System::vm_find_object(STATE, GCToken gct,
Array* arg, Object* callable,
CallFrame* calling_environment)
{
ObjectMemory::GCInhibit inhibitor(state->memory());
// Support an aux mode, where callable is an array and we just append
// objects to it rather than #call it.
Array* ary = try_as<Array>(callable);
if(!ary) ary = nil<Array>();
Array* args = Array::create(state, 1);
int total = 0;
QueryCondition* condition = create_condition(state, arg);
if(!condition) return Fixnum::from(0);
Object* ret = cNil;
// Special case for looking for an immediate
if(Object* obj = condition->immediate()) {
if(Symbol* sym = try_as<Symbol>(obj)) {
// Check whether this is actually a valid symbol, not
// some random non existing symbol.
if(!state->shared().symbols.lookup_string(state, sym)) {
delete condition;
std::ostringstream msg;
msg << "Invalid symbol 0x" << std::hex << reinterpret_cast<uintptr_t>(sym);
Exception::range_error(state, msg.str().c_str());
return 0;
}
}
if(!ary->nil_p()) {
ary->append(state, obj);
} else {
args->set(state, 0, obj);
ret = callable->send(state, calling_environment, G(sym_call),
args, cNil, false);
}
delete condition;
if(!ret) return 0;
return Fixnum::from(1);
}
OnStack<2> os(state, ary, args);
state->set_call_frame(calling_environment);
ObjectWalker walker(state->memory());
GCData gc_data(state->vm());
{
StopTheWorld stw(state, gct, calling_environment);
// Seed it with the root objects.
walker.seed(gc_data);
}
Object* obj = walker.next();
while(obj) {
if(condition->perform(state, obj)) {
total++;
if(!ary->nil_p()) {
ary->append(state, obj);
} else {
// We call back into Ruby land here, so that might trigger a GC
// This ensures we mark all the locations of the current search
// queue for the walker, so we update these object references
// properly.
Object** stack_buf = walker.stack_buf();
size_t stack_size = walker.stack_size();
Object** variable_buffer[stack_size];
for(size_t i = 0; i < stack_size; ++i) {
variable_buffer[i] = &stack_buf[i];
}
VariableRootBuffer vrb(state->vm()->current_root_buffers(),
variable_buffer, stack_size);
args->set(state, 0, obj);
ret = callable->send(state, calling_environment, G(sym_call),
args, cNil, false);
if(!ret) break;
}
}
obj = walker.next();
}
delete condition;
if(!ret) return 0;
return Integer::from(state, total);
}
