cl_error_t postscan_cb(int fd, int result, const char *virname, void *context) {
struct scan_ctx *sctx = (struct scan_ctx *)context;
instance *inst;
CLAM_SCAN_INFO si;
CLAM_ACTION act;
DWORD perf;
wchar_t wvirname[MAX_VIRNAME_LEN] = L"Clam.";
if(!context) {
logg("!postscan_cb called with NULL clamav context\n");
return CL_CLEAN;
}
inst = sctx->inst;
if(inst && inst->filetype)
return CL_CLEAN; /* No callback, we are just filetyping */
if(fd == sctx->entryfd)
return CL_CLEAN; /* Moved to after cl_scandesc returns due to heuristic results not being yet set in magicscan */
si.cbSize = sizeof(si);
si.flags = 0;
si.scanPhase = SCAN_PHASE_POSTSCAN;
si.errorCode = CLAMAPI_SUCCESS;
if(result == CL_VIRUS) {
if(MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, virname, -1, &wvirname[5], MAX_VIRNAME_LEN-5))
si.pThreatName = wvirname;
else
si.pThreatName = L"Clam.UNOFFICIAL";
} else
si.pThreatName = NULL;
logg("*in postscan_cb with clamav context %p, instance %p, fd %d, result %d, virusname %S)\n", context, inst, fd, result, si.pThreatName);
si.pThreatType = threat_type(virname);
si.objectId = (HANDLE)_get_osfhandle(fd);
si.object = INVALID_HANDLE_VALUE;
si.pInnerObjectPath = NULL;
logg("*postscan_cb (clamav context %p, instance %p) invoking callback %p with context %p\n", context, inst, inst->scancb, inst->scancb_ctx);
perf = GetTickCount();
inst->scancb(&si, &act, inst->scancb_ctx);
perf = GetTickCount() - perf;
sctx->cb_times += perf;
logg("*postscan_cb (clamav context %p, instance %p) callback completed with %u in %u ms\n", context, inst, act, perf);
switch(act) {
case CLAM_ACTION_SKIP:
logg("*postscan_cb (clamav context %p, instance %p) cb result: SKIP\n", context, inst);
return CL_BREAK;
case CLAM_ACTION_ABORT:
logg("*postscan_cb (clamav context %p, instance %p) cb result: ABORT\n", context, inst);
return CL_VIRUS;
case CLAM_ACTION_CONTINUE:
logg("*postscan_cb (clamav context %p, instance %p) cb result: CONTINUE\n", context, inst);
return CL_CLEAN;
default:
logg("^postscan_cb (clamav context %p, instance %p) cb result: INVALID result %d, assuming continue\n", context, inst, act);
return CL_CLEAN;
}
}
int CLAMAPI Scan_ScanObjectByHandle(CClamAVScanner *pScanner, HANDLE object, int *pScanStatus, PCLAM_SCAN_INFO_LIST *pInfoList) {
instance *inst;
HANDLE duphdl, self;
char *virname = NULL;
int fd, res;
unsigned int i;
struct scan_ctx sctx;
DWORD perf;
logg("*in Scan_ScanObjectByHandle(pScanner = %p, HANDLE = %p, pScanStatus = %p, pInfoList = %p)\n", pScanner, object, pScanStatus, pInfoList);
if(!pScanner)
FAIL(CL_ENULLARG, "NULL pScanner");
if(!pScanStatus)
FAIL(CL_ENULLARG, "NULL pScanStatus on instance %p", pScanner);
self = GetCurrentProcess();
if(!DuplicateHandle(self, object, self, &duphdl, GENERIC_READ, FALSE, 0))
FAIL(CL_EDUP, "Duplicate handle failed for instance %p", pScanner);
if((fd = _open_osfhandle((intptr_t)duphdl, _O_RDONLY)) == -1) {
CloseHandle(duphdl);
FAIL(CL_EOPEN, "Open handle failed for instance %p", pScanner);
}
if(lock_instances()) {
close(fd);
FAIL(CL_ELOCK, "failed to lock instances for instance %p", pScanner);
}
inst = (instance *)pScanner;
for(i=0; i<ninsts_total; i++) {
if(instances[i].inst == inst)
break;
}
if(i == ninsts_total) {
unlock_instances();
close(fd);
FAIL(CL_EARG, "invalid instance %p", inst);
}
instances[i].refcnt++;
ResetEvent(reload_event);
unlock_instances();
sctx.entryfd = fd;
sctx.inst = inst;
sctx.cb_times = 0;
sctx.copy_times = 0;
logg("*Scan_ScanObjectByHandle (instance %p) invoking cl_scandesc with clamav context %p\n", inst, &sctx);
perf = GetTickCount();
res = cl_scandesc_callback(fd, &virname, NULL, engine, inst->scanopts, &sctx);
if(!inst->filetype) do {
CLAM_SCAN_INFO si;
CLAM_ACTION act;
DWORD cbperf;
wchar_t wvirname[MAX_VIRNAME_LEN] = L"Clam.";
LONG lo = 0, hi = 0, hi2 = 0;
si.cbSize = sizeof(si);
si.flags = 0;
si.scanPhase = SCAN_PHASE_FINAL;
si.errorCode = CLAMAPI_SUCCESS;
if(res == CL_VIRUS) {
if(MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, virname, -1, &wvirname[5], MAX_VIRNAME_LEN - 5))
si.pThreatName = wvirname;
else
si.pThreatName = L"Clam.UNOFFICIAL";
} else
si.pThreatName = NULL;
logg("*in final_cb with clamav context %p, instance %p, fd %d, result %d, virusname %S)\n", &sctx, inst, fd, res, si.pThreatName);
si.pThreatType = threat_type(virname);
si.object = INVALID_HANDLE_VALUE;
si.objectId = INVALID_HANDLE_VALUE;
si.pInnerObjectPath = NULL;
lo = SetFilePointer(duphdl, 0, &hi, FILE_CURRENT);
SetFilePointer(duphdl, 0, &hi2, FILE_BEGIN);
logg("*final_cb (clamav context %p, instance %p) invoking callback %p with context %p\n", &sctx, inst, inst->scancb, inst->scancb_ctx);
cbperf = GetTickCount();
inst->scancb(&si, &act, inst->scancb_ctx);
cbperf = GetTickCount() - cbperf;
sctx.cb_times += cbperf;
logg("*final_cb (clamav context %p, instance %p) callback completed with %u (result ignored) in %u ms\n", &sctx, inst, act, cbperf);
SetFilePointer(duphdl, lo, &hi, FILE_BEGIN);
} while(0);
perf = GetTickCount() - perf;
close(fd);
logg("*Scan_ScanObjectByHandle (instance %p): cl_scandesc returned %d in %u ms (%d ms own, %d ms copy)\n", inst, res, perf, perf - sctx.cb_times - sctx.copy_times, sctx.copy_times);
if(lock_instances())
FAIL(CL_ELOCK, "failed to lock instances for instance %p", pScanner);
instances[i].refcnt--;
if(!instances[i].refcnt)
SetEvent(reload_event);
unlock_instances();
if(res == CL_VIRUS) {
logg("Scan_ScanObjectByHandle (instance %p): file is INFECTED with %s\n", inst, virname);
if(pInfoList) {
CLAM_SCAN_INFO_LIST *infolist = (CLAM_SCAN_INFO_LIST *)calloc(1, sizeof(CLAM_SCAN_INFO_LIST) + sizeof(CLAM_SCAN_INFO) + MAX_VIRNAME_LEN * 2);
PCLAM_SCAN_INFO scaninfo;
wchar_t *wvirname;
if(!infolist)
FAIL(CL_EMEM, "ScanByHandle (instance %p): OOM while allocating result list", inst);
scaninfo = (PCLAM_SCAN_INFO)(infolist + 1);
infolist->cbCount = 1;
scaninfo->cbSize = sizeof(*scaninfo);
scaninfo->scanPhase = SCAN_PHASE_FINAL;
scaninfo->errorCode = CLAMAPI_SUCCESS;
scaninfo->pThreatType = threat_type(virname);
scaninfo->object = INVALID_HANDLE_VALUE;
scaninfo->objectId = INVALID_HANDLE_VALUE;
wvirname = (wchar_t *)(scaninfo + 1);
scaninfo->pThreatName = wvirname;
memcpy(wvirname, L"Clam.", 10);
if(!MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, virname, -1, &wvirname[5], MAX_VIRNAME_LEN-5))
scaninfo->pThreatName = L"Clam.UNOFFICIAL";
*pInfoList = infolist;
logg("*Scan_ScanObjectByHandle (instance %p): created result list %p\n", inst, infolist);
}
*pScanStatus = CLAM_INFECTED;
} else if(res == CL_CLEAN) {
logg("*Scan_ScanObjectByHandle (instance %p): file is CLEAN\n", inst);
if(pInfoList) *pInfoList = NULL;
*pScanStatus = CLAM_CLEAN;
} else {
FAIL(res, "Scan failed for instance %p: %s", inst, cl_strerror(res));
}
WIN();
}
double agent_alex(Game_state *state, int player, int x, int y) {
Pair** rmap = NULL;
double score = 0;
int is_game_won = game_won(state);
int a = 0, b = 0, c = 0, d = 0;
int lines, i;
int t_threat;
/* keep track of who went first */
if(first_player == -1)
first_player = player;
/* player has won with this board */
if(is_game_won == player) {
score = 1000000;
/* player has lost with this board */
} else if (is_game_won == other(player)) {
score = -1000000;
} else {
lines = num_of_win_places(state->width, state->height,
state->num_to_connect);
rmap = r_map(state);
for(i = 0; i < lines; i++) {
t_threat = threat_type(state, rmap, player, i);
/* a - odd threat */
if(t_threat == 1)
a++;
/* b - even threat */
else if(t_threat == 0)
b++;
/* c - 2 in a rows */
if(has_n_in_row(state, rmap, player, i, 2))
c++;
/* d - 1 in a rows */
if(has_n_in_row(state, rmap, player, i, 1))
d++;
}
/* favour the center column (but more so earlier on) */
if(state->board[state->width/2][y] == player) {
score += 50;
}
if(first_player == player) {
score += a * 16 + b * 8 + c * 2 + d;
} else {
score += b * 16 + a * 8 + c * 2 + d;
if(state->num_of_pieces >= 5 &&
arrow_attack(state, other(player), rmap, 2)) {
score -= 10;
}
}
if(three_attack(state, other(player), rmap)) {
score -= 100;
}
if(arrow_attack(state, other(player), rmap, 1)) {
score -= 100;
}
if(arrow_attack(state, player, rmap, 1)) {
score += 30;
}
if(three_support(state, other(player), rmap)) {
score -= 100;
}
for(i = 0; i < lines; i++)
free(rmap[i]);
free(rmap);
}
return score;
}
