void wsplayer_t::delegate_step()
{
incer_t<int> hld_thinking(thinking);
field=game().field();
root=item_ptr(new item_t(*this,field.back()));
ObjectProgress::log_generator lg(true);
init_states();
try
{
root->process_deep_common();
}
catch(e_cancel&)
{
lg<<"canceled";
hld_thinking.reset();
throw;
}
if(!root->get_wins().empty())
{
unsigned int depth=root->get_chain_depth()-1;
std::string chain=print_chain(root->get_wins().get_best());
lg<<"wsplayer_t::delegate_step(): find win chain_depth="<<depth<<": "<<chain;
}
if(!root->get_fails().empty() && root->get_neitrals().empty())lg<<"wsplayer_t::delegate_step(): find fail chain_depth="<<(root->get_chain_depth()-1)
<<": "<<print_chain(root->get_fails().get_best());
point p=*root->get_next_step();
game().OnNextStep(*this,p);
}
static cl_error_t post(int fd, int result, const char *virname, void *context)
{
struct clamscan_cb_data *d = context;
struct metachain *c;
char str[128];
UNUSEDPARAM(fd);
UNUSEDPARAM(result);
if (d != NULL)
c = d->chain;
if (c && c->nchains) {
print_chain(c, str, sizeof(str));
if (c->level == c->lastadd && !virname)
free(c->chains[--c->nchains]);
if (virname && !c->lastvir)
c->lastvir = c->level;
}
if (c)
c->level--;
return CL_CLEAN;
}
int main ()
{
freopen ("aplusb.in", "rt", stdin);
freopen ("aplusb.out", "wt", stdout);
chain a, b, c;
read_chain (a);
read_chain (b);
double x = eval_chain (a);
double y = eval_chain (b);
if (x < 0 || y < 0)
{
printf ("Impossible");
return 0;
}
x += y;
for (c.n = 1; c.n <= 7; c.n++)
{
for (c.k = 0; c.k < c.n; c.k++)
{
for (int i = 0; i <= c.n; i++)
c.d[i] = 1;
while (true)
{
double r = eval_chain (c);
if (r < x - EPS)
{
int v = isint (x - r);
if (v >= 0)
{
c.d[0] += v;
print_chain (c);
return 0;
}
}
int cur = c.n;
while (cur > 0 && c.d[cur] == 10)
c.d[cur] = 1, cur--;
if (cur <= 0)
break;
c.d[cur]++;
}
}
}
printf ("Impossible");
return 0;
}
static cl_error_t post(int fd, int result, const char *virname, void *context)
{
struct metachain *c = context;
if (c && c->n) {
char str[128];
int toolong = print_chain(c, str, sizeof(str));
if (c->level == c->lastadd && !virname)
free(c->chains[--c->n]);
if (virname && !c->lastvir)
c->lastvir = c->level;
}
if (c)
c->level--;
return CL_CLEAN;
}
int init_module()
{
nfho.hook = hook_func;
nfho.hooknum = NF_INET_PRE_ROUTING;
nfho.pf = PF_INET;
nfho.priority = NF_IP_PRI_FIRST;
udp_capture_chain_head = create_chain(buffer_len);
udp_capture_chain_cur = udp_capture_chain_head;
print_chain(udp_capture_chain_head);
nf_register_hook(&nfho);
file1 = debugfs_create_file("mmap_example", 0644, NULL, NULL, &my_fops);
return 0;
}
static cl_error_t meta(const char* container_type, unsigned long fsize_container, const char *filename,
unsigned long fsize_real, int is_encrypted, unsigned int filepos_container, void *context)
{
int na = 0;
char prev[128];
struct metachain *c = context;
const char *type = !strncmp(container_type,"CL_TYPE_",8) ? container_type + 8 : container_type;
unsigned n = strlen(type) + 1 + strlen(filename) + 1;
char *chain;
char **chains;
int toolong;
if (!c)
return CL_CLEAN;
chain = malloc(n);
if (!chain)
return CL_CLEAN;
if (!strcmp(type, "ANY"))
snprintf(chain, n,"%s", filename);
else
snprintf(chain, n,"%s:%s", type, filename);
if (c->lastadd != c->level) {
n = c->n + 1;
chains = realloc(c->chains, n * sizeof(*chains));
if (!chains) {
free(chain);
return CL_CLEAN;
}
c->chains = chains;
c->n = n;
c->lastadd = c->level;
} else {
free(c->chains[c->n-1]);
}
c->chains[c->n-1] = chain;
toolong = print_chain(c, prev, sizeof(prev));
logg("*Scanning %s%s!%s\n", prev,toolong ? "..." : "", chain);
return CL_CLEAN;
}
static void consensus(args_t *args)
{
htsFile *fasta = hts_open(args->ref_fname, "rb");
if ( !fasta ) error("Error reading %s\n", args->ref_fname);
kstring_t str = {0,0,0};
while ( hts_getline(fasta, KS_SEP_LINE, &str) > 0 )
{
if ( str.s[0]=='>' )
{
// new sequence encountered, apply all chached variants
while ( args->vcf_rbuf.n )
{
if (args->chain) {
print_chain(args);
destroy_chain(args);
}
bcf1_t *rec = args->vcf_buf[args->vcf_rbuf.f];
if ( rec->rid!=args->rid || ( args->fa_end_pos && rec->pos > args->fa_end_pos ) ) break;
int i = rbuf_shift(&args->vcf_rbuf);
apply_variant(args, args->vcf_buf[i]);
}
flush_fa_buffer(args, 0);
init_region(args, str.s+1);
continue;
}
args->fa_length += str.l;
args->fa_src_pos += str.l;
// determine if uppercase or lowercase is used in this fasta file
if ( args->fa_case==-1 ) args->fa_case = toupper(str.s[0])==str.s[0] ? 1 : 0;
if ( args->mask && args->rid>=0) mask_region(args, str.s, str.l);
kputs(str.s, &args->fa_buf);
bcf1_t **rec_ptr = NULL;
while ( args->rid>=0 && (rec_ptr = next_vcf_line(args)) )
{
bcf1_t *rec = *rec_ptr;
// still the same chr and the same region? if not, fasta buf can be flushed
if ( rec->rid!=args->rid || ( args->fa_end_pos && rec->pos > args->fa_end_pos ) )
{
// save the vcf record until next time and flush
unread_vcf_line(args, rec_ptr);
rec_ptr = NULL;
break;
}
// is the vcf record well beyond cached fasta buffer? if yes, the buf can be flushed
if ( args->fa_ori_pos + args->fa_buf.l - args->fa_mod_off <= rec->pos )
{
unread_vcf_line(args, rec_ptr);
rec_ptr = NULL;
break;
}
// is the cached fasta buffer full enough? if not, read more fasta, no flushing
if ( args->fa_ori_pos + args->fa_buf.l - args->fa_mod_off < rec->pos + rec->rlen )
{
unread_vcf_line(args, rec_ptr);
break;
}
apply_variant(args, rec);
}
if ( !rec_ptr ) flush_fa_buffer(args, 60);
}
if (args->chain) {
print_chain(args);
destroy_chain(args);
}
flush_fa_buffer(args, 0);
hts_close(fasta);
free(str.s);
}
static void scanfile(const char *filename, struct cl_engine *engine, const struct optstruct *opts, unsigned int options)
{
int ret = 0, fd, included;
unsigned i;
const struct optstruct *opt;
const char *virname;
STATBUF sb;
struct metachain chain;
struct clamscan_cb_data data;
if((opt = optget(opts, "exclude"))->enabled) {
while(opt) {
if(match_regex(filename, opt->strarg) == 1) {
if(!printinfected)
logg("~%s: Excluded\n", filename);
return;
}
opt = opt->nextarg;
}
}
if((opt = optget(opts, "include"))->enabled) {
included = 0;
while(opt) {
if(match_regex(filename, opt->strarg) == 1) {
included = 1;
break;
}
opt = opt->nextarg;
}
if(!included) {
if(!printinfected)
logg("~%s: Excluded\n", filename);
return;
}
}
/* argh, don't scan /proc files */
if(CLAMSTAT(filename, &sb) != -1) {
#ifdef C_LINUX
if(procdev && sb.st_dev == procdev) {
if(!printinfected)
logg("~%s: Excluded (/proc)\n", filename);
return;
}
#endif
if(!sb.st_size) {
if(!printinfected)
logg("~%s: Empty file\n", filename);
return;
}
info.rblocks += sb.st_size / CL_COUNT_PRECISION;
}
#ifndef _WIN32
if(geteuid()) {
if(checkaccess(filename, NULL, R_OK) != 1) {
if(!printinfected)
logg("~%s: Access denied\n", filename);
info.errors++;
return;
}
}
#endif
memset(&chain, 0, sizeof(chain));
if(optget(opts, "archive-verbose")->enabled) {
chain.chains = malloc(sizeof(char **));
if (chain.chains) {
chain.chains[0] = strdup(filename);
if (!chain.chains[0]) {
free(chain.chains);
logg("Unable to allocate memory in scanfile()\n");
info.errors++;
return;
}
chain.nchains = 1;
}
}
logg("*Scanning %s\n", filename);
if((fd = safe_open(filename, O_RDONLY|O_BINARY)) == -1) {
logg("^Can't open file %s: %s\n", filename, strerror(errno));
info.errors++;
return;
}
data.chain = &chain;
data.filename = filename;
if((ret = cl_scandesc_callback(fd, &virname, &info.blocks, engine, options, &data)) == CL_VIRUS) {
if(optget(opts, "archive-verbose")->enabled) {
if (chain.nchains > 1) {
char str[128];
int toolong = print_chain(&chain, str, sizeof(str));
logg("~%s%s!(%llu)%s: %s FOUND\n", str, toolong ? "..." : "", (long long unsigned)(chain.lastvir-1), chain.chains[chain.nchains-1], virname);
} else if (chain.lastvir) {
logg("~%s!(%llu): %s FOUND\n", filename, (long long unsigned)(chain.lastvir-1), virname);
}
}
info.files++;
info.ifiles++;
if(bell)
fprintf(stderr, "\007");
} else if(ret == CL_CLEAN) {
if(!printinfected && printclean)
mprintf("~%s: OK\n", filename);
info.files++;
} else {
if(!printinfected)
logg("~%s: %s ERROR\n", filename, cl_strerror(ret));
info.errors++;
}
for (i=0;i<chain.nchains;i++)
free(chain.chains[i]);
free(chain.chains);
close(fd);
if(ret == CL_VIRUS && action)
action(filename);
}
static cl_error_t meta(const char* container_type, unsigned long fsize_container, const char *filename,
unsigned long fsize_real, int is_encrypted, unsigned int filepos_container, void *context)
{
char prev[128];
struct metachain *c;
struct clamscan_cb_data *d;
const char *type;
size_t n;
char *chain;
char **chains;
int toolong;
UNUSEDPARAM(fsize_container);
UNUSEDPARAM(fsize_real);
UNUSEDPARAM(is_encrypted);
UNUSEDPARAM(filepos_container);
if (!(context))
return CL_CLEAN;
d = (struct clamscan_cb_data *)context;
c = d->chain;
type = (strncmp(container_type, "CL_TYPE_", 8) == 0 ? container_type + 8 : container_type);
n = strlen(type) + strlen(filename) + 2;
if (!c)
return CL_CLEAN;
chain = malloc(n);
if (!chain)
return CL_CLEAN;
if (!strcmp(type, "ANY"))
snprintf(chain, n,"%s", filename);
else
snprintf(chain, n,"%s:%s", type, filename);
if (c->lastadd != c->level) {
n = c->nchains + 1;
chains = realloc(c->chains, n * sizeof(*chains));
if (!chains) {
free(chain);
return CL_CLEAN;
}
c->chains = chains;
c->nchains = n;
c->lastadd = c->level;
} else {
if (c->nchains > 0)
free(c->chains[c->nchains-1]);
}
if (c->nchains > 0) {
c->chains[c->nchains-1] = chain;
toolong = print_chain(c, prev, sizeof(prev));
logg("*Scanning %s%s!%s\n", prev,toolong ? "..." : "", chain);
} else {
free(chain);
}
return CL_CLEAN;
}
/* print hash table contents */
void print(FILE* outfp, struct hash_table *table )
{
int i;
for( i = 0; i < table->size; i++ )
print_chain(outfp, table->chain[i] );
}
