int sieve_test (struct sieve_binary *sbin, const struct sieve_message_data *msgdata, const struct sieve_script_env *senv, struct sieve_error_handler *ehandler, struct ostream *stream, enum sieve_runtime_flags flags, bool *keep) { struct sieve_result *result = NULL; int ret; if ( keep != NULL ) *keep = FALSE; /* Run the script */ ret = sieve_run(sbin, &result, msgdata, senv, ehandler, flags); /* Print result if successful */ if ( ret > 0 ) { ret = sieve_result_print(result, senv, stream, keep); } else if ( ret == 0 ) { if ( keep != NULL ) *keep = TRUE; } /* Cleanup */ if ( result != NULL ) sieve_result_unref(&result); return ret; }
void sieve_multiscript_run_discard (struct sieve_multiscript *mscript, struct sieve_binary *sbin, struct sieve_error_handler *exec_ehandler, struct sieve_error_handler *action_ehandler, enum sieve_execute_flags flags) { if ( !sieve_multiscript_will_discard(mscript) ) return; i_assert( !mscript->discard_handled ); sieve_result_set_keep_action (mscript->result, NULL, &act_store); /* Run the discard script */ mscript->status = sieve_run(sbin, &mscript->result, mscript->msgdata, mscript->scriptenv, exec_ehandler, flags); if ( mscript->status >= 0 ) { mscript->keep = FALSE; if ( mscript->teststream != NULL ) { sieve_multiscript_test(mscript, &mscript->keep); } else { sieve_multiscript_execute(mscript, action_ehandler, flags, &mscript->keep); } } mscript->discard_handled = TRUE; }
/*------------------------------------------------------------------------*/ static uint64 get_next_composite(sieve_fb_t *s) { while (1) { uint32 curr_offset; p_sieve_t *p_sieve = &s->p_sieve; uint8 *sieve_block = p_sieve->sieve_block; uint32 cutoff = MIN(SIEVE_SIZE, (s->p_max - p_sieve->sieve_start + 1) / 2); for (curr_offset = p_sieve->curr_offset; curr_offset < cutoff; curr_offset++) { if (!(sieve_block[curr_offset] & 0x80)) continue; p_sieve->curr_offset = curr_offset + 1; return p_sieve->sieve_start + (2 * curr_offset + 1); } p_sieve->sieve_start += 2 * SIEVE_SIZE; p_sieve->curr_offset = curr_offset = 0; if (p_sieve->sieve_start >= s->p_max) break; sieve_run(s); } return P_SEARCH_DONE; }
bool sieve_multiscript_run (struct sieve_multiscript *mscript, struct sieve_binary *sbin, struct sieve_error_handler *exec_ehandler, struct sieve_error_handler *action_ehandler, enum sieve_execute_flags flags) { if ( !mscript->active ) return FALSE; /* Run the script */ mscript->status = sieve_run(sbin, &mscript->result, mscript->msgdata, mscript->scriptenv, exec_ehandler, flags); if ( mscript->status >= 0 ) { mscript->keep = FALSE; if ( mscript->teststream != NULL ) { sieve_multiscript_test(mscript, &mscript->keep); } else { sieve_multiscript_execute(mscript, action_ehandler, flags, &mscript->keep); } mscript->active = ( mscript->active && mscript->keep && mscript->status > 0 ); } if ( mscript->status <= 0 ) return FALSE; return mscript->active; }
int mu_sieve_disass (mu_sieve_machine_t mach) { int level = mach->debug_level; int rc; mach->debug_level = MU_SIEVE_DEBUG_INSTR | MU_SIEVE_DEBUG_DISAS; rc = sieve_run (mach); mach->debug_level = level; return rc; }
static int _sieve_action (mu_observer_t obs, size_t type, void *data, void *action_data) { mu_sieve_machine_t mach; if (type != MU_EVT_MESSAGE_ADD) return 0; mach = mu_observer_get_owner (obs); mach->msgno++; mu_mailbox_get_message (mach->mailbox, mach->msgno, &mach->msg); sieve_run (mach); return 0; }
int mu_sieve_message (mu_sieve_machine_t mach, mu_message_t msg) { int rc; if (!mach || !msg) return EINVAL; mach->msgno = 1; mach->msg = msg; mach->mailbox = NULL; rc = sieve_run (mach); mach->msg = NULL; return rc; }
int sieve_execute (struct sieve_binary *sbin, const struct sieve_message_data *msgdata, const struct sieve_script_env *senv, struct sieve_error_handler *exec_ehandler, struct sieve_error_handler *action_ehandler, enum sieve_runtime_flags flags, bool *keep) { struct sieve_result *result = NULL; int ret; if ( keep != NULL ) *keep = FALSE; /* Run the script */ ret = sieve_run(sbin, &result, msgdata, senv, exec_ehandler, flags); /* Evaluate status and execute the result: * Strange situations, e.g. currupt binaries, must be handled by the caller. * In that case no implicit keep is attempted, because the situation may be * resolved. */ if ( ret > 0 ) { /* Execute result */ ret = sieve_result_execute(result, keep, action_ehandler); } else if ( ret == SIEVE_EXEC_FAILURE ) { /* Perform implicit keep if script failed with a normal runtime error */ switch ( sieve_result_implicit_keep (result, action_ehandler) ) { case SIEVE_EXEC_OK: if ( keep != NULL ) *keep = TRUE; break; case SIEVE_EXEC_TEMP_FAILURE: ret = SIEVE_EXEC_TEMP_FAILURE; break; default: ret = SIEVE_EXEC_KEEP_FAILED; } } /* Cleanup */ if ( result != NULL ) sieve_result_unref(&result); return ret; }
/*------------------------------------------------------------------------*/ void sieve_fb_reset(sieve_fb_t *s, uint64 p_min, uint64 p_max, uint32 num_roots_min, uint32 num_roots_max) { uint32 i; free_prime_sieve(&s->p_prime); if (p_min % 2) p_min--; s->p_min = p_min; s->p_max = p_max; s->num_roots_min = num_roots_min; s->num_roots_max = num_roots_max; if (p_max > 10000000) { p_enum_t *p_enum = &s->p_enum; s->curr_algo = ALGO_ENUM; p_enum->next_prime = 0; p_enum->curr_entry = 0; p_enum->curr_list.num_entries = 1; p_enum->curr_list.list[0].num_factors = 0; p_enum->curr_list.list[0].prod = 1; } else { p_sieve_t *p_sieve = &s->p_sieve; sieve_prime_list_t *list; s->curr_algo = ALGO_SIEVE; p_sieve->sieve_start = p_min; list = &p_sieve->good_primes; for (i = 0; i < list->num_primes; i++) { sieve_prime_t *curr = list->primes + i; uint32 p = curr->p; uint32 rem = p - p_min % p; if (rem != p && rem % 2 == 0) rem += p; curr->r = rem / 2; } list = &p_sieve->bad_primes; for (i = 0; i < list->num_primes; i++) { sieve_prime_t *curr = list->primes + i; uint32 p = curr->p; uint32 rem = p - p_min % p; if (rem != p && rem % 2 == 0) rem += p; curr->r = rem / 2; } sieve_run(s); } }