/*
* Clean up a DCS block. This routine is called to clear out any
* lingering state information when the CA FSM reverts to an 'earlier'
* state (Down or Master/Slave Negotiation).
*
* Arguments:
* dcsp pointer to a DCS control block for the neighbor
*
* Returns:
* none
*
*/
void
scsp_dcs_cleanup(Scsp_dcs *dcsp)
{
Scsp_cse *csep, *ncsep;
Scsp_csa *csap, *next_csap;
Scsp_csu_rexmt *rxp, *rx_next;
/*
* Free any CSAS entries waiting to be sent
*/
for (csep = dcsp->sd_ca_csas; csep; csep = ncsep) {
ncsep = csep->sc_next;
UNLINK(csep, Scsp_cse, dcsp->sd_ca_csas, sc_next);
UM_FREE(csep);
}
/*
* Free any entries on the CRL
*/
for (csap = dcsp->sd_crl; csap; csap = next_csap) {
next_csap = csap->next;
UNLINK(csap, Scsp_csa, dcsp->sd_crl, next);
SCSP_FREE_CSA(csap);
}
/*
* Free any saved CA message and cancel the CA
* retransmission timer
*/
if (dcsp->sd_ca_rexmt_msg) {
scsp_free_msg(dcsp->sd_ca_rexmt_msg);
dcsp->sd_ca_rexmt_msg = NULL;
}
HARP_CANCEL(&dcsp->sd_ca_rexmt_t);
/*
* Free any saved CSU Solicit message and cancel the CSUS
* retransmission timer
*/
if (dcsp->sd_csus_rexmt_msg) {
scsp_free_msg(dcsp->sd_csus_rexmt_msg);
dcsp->sd_csus_rexmt_msg = NULL;
}
HARP_CANCEL(&dcsp->sd_csus_rexmt_t);
/*
* Free any entries on the CSU Request retransmission queue
*/
for (rxp = dcsp->sd_csu_rexmt; rxp; rxp = rx_next) {
rx_next = rxp->sr_next;
HARP_CANCEL(&rxp->sr_t);
for (csap = rxp->sr_csa; csap; csap = next_csap) {
next_csap = csap->next;
SCSP_FREE_CSA(csap);
}
UNLINK(rxp, Scsp_csu_rexmt, dcsp->sd_csu_rexmt,
sr_next);
UM_FREE(rxp);
}
}
void clear_news( bool sMatch, int nCount )
{
int nCurrent = 1;
NEWS_DATA *news;
if ( sMatch == FALSE ) {
while ( ( news = first_news ) != NULL ) {
STRFREE( news->data );
UNLINK( news, first_news, last_news, next, prev );
DISPOSE( news );
}
}
else {
for ( news = first_news; news != NULL; news = news->next ) {
if ( nCount == nCurrent ) {
STRFREE( news->data );
UNLINK( news, first_news, last_news, next, prev );
DISPOSE( news );
break;
}
else
nCurrent++;
}
}
}
void dispose_ban( BAN_DATA * pban, int type )
{
if( !pban )
return;
if( type != BAN_SITE && type != BAN_CLASS && type != BAN_RACE )
{
bug( "%s: Unknown Ban Type %d.", __func__, type );
return;
}
switch ( type )
{
case BAN_SITE:
UNLINK( pban, first_ban, last_ban, next, prev );
break;
case BAN_CLASS:
UNLINK( pban, first_ban_class, last_ban_class, next, prev );
break;
case BAN_RACE:
UNLINK( pban, first_ban_race, last_ban_race, next, prev );
break;
}
free_ban( pban );
}
static int
testCreateFromFile ()
{
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p1;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p2;
key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
GNUNET_CRYPTO_rsa_key_get_public (key, &p1);
GNUNET_CRYPTO_rsa_key_free (key);
key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_assert (0 == UNLINK (KEYFILE));
key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
GNUNET_assert (NULL != key);
GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_assert (0 == UNLINK (KEYFILE));
return GNUNET_OK;
}
void extract_char(Character *ch, bool fPull)
{
for (Object * obj_next, *obj = ch->carrying; obj != NULL;
obj = obj_next)
{
obj_next = obj->next_content;
extract_obj(obj);
}
if (ch->inRoom != NULL) {
char_from_room(ch);
}
/*
* Death room is set in the clan tabe now
*/
if (!fPull)
{
char_to_room(ch, get_room_by_id(DEFAULT_ROOM));
return;
}
UNLINK(first_character, Character, ch, next);
if (ch->pc) {
UNLINK(first_player, Character, ch, next_player);
}
destroy_char(ch);
}
static void close_archive(FILE *archfp, FILE *outfp, FILE *dupfp) {
int last_errno;
if (fclose(archfp) != 0) {
note_archive_failure(outfp, last_errno = errno);
note_archive_failure(dupfp, last_errno);
if (outfp != stderr && dupfp != stderr)
note_archive_failure(stderr, last_errno);
return;
}
UNLINK(chkpnt_cfn);
UNLINK(chkpnt_tfn);
}
static int
testReadWrite ()
{
char tmp[100 + 1];
int ret;
if (strlen (TESTSTRING) !=
GNUNET_DISK_fn_write (".testfile", TESTSTRING, strlen (TESTSTRING),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
return 1;
if (GNUNET_OK != GNUNET_DISK_file_test (".testfile"))
return 1;
ret = GNUNET_DISK_fn_read (".testfile", tmp, sizeof (tmp) - 1);
if (ret < 0)
{
FPRINTF (stderr, "Error reading file `%s' in testReadWrite\n", ".testfile");
return 1;
}
tmp[ret] = '\0';
if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
{
FPRINTF (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
TESTSTRING, ".testfile");
return 1;
}
GNUNET_DISK_file_copy (".testfile", ".testfile2");
memset (tmp, 0, sizeof (tmp));
ret = GNUNET_DISK_fn_read (".testfile2", tmp, sizeof (tmp) - 1);
if (ret < 0)
{
FPRINTF (stderr, "Error reading file `%s' in testReadWrite\n",
".testfile2");
return 1;
}
tmp[ret] = '\0';
if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
{
FPRINTF (stderr, "Error in testReadWrite: *%s* != *%s* for file %s\n", tmp,
TESTSTRING, ".testfile2");
return 1;
}
GNUNET_break (0 == UNLINK (".testfile"));
GNUNET_break (0 == UNLINK (".testfile2"));
if (GNUNET_NO != GNUNET_DISK_file_test (".testfile"))
return 1;
return 0;
}
void CTB_unlink(char *name)
{
char str[MAXPATH], *p = ctb_last_punct(name);
if (p)
*p = '\0';
STRCPY(str, name);
STRCAT(str, ".CTB");
UNLINK(str);
STRCPY(str, name);
STRCAT(str, ".IND");
UNLINK(str);
return;
}
void do_remcontract( CHAR_DATA * ch, char *argument )
{
CONTRACT_DATA *contract;
CONTRACT_DATA *scontract = NULL;
if( argument[0] == '\0' )
{
send_to_char( "&RSyntax: remcontract <target name>\n\r", ch );
return;
}
for( contract = ch->first_contract; contract; contract = contract->next_in_contract )
{
if( !str_cmp( contract->target, argument ) )
{
scontract = contract;
break;
}
}
if( !scontract || scontract == NULL )
{
send_to_char( "No such target.\n\r", ch );
return;
}
STRFREE( scontract->target );
UNLINK( scontract, ch->first_contract, ch->last_contract, next_in_contract, prev_in_contract );
DISPOSE( scontract );
send_to_char( "Contract removed.\n\r", ch );
return;
}
void CGridDlg::OnBnClickedButtonDiagram() {
if(!validate()) return;
windowToValue();
const GridParameters v = getCurrentValue();
PearlDiagram diagram;
PixRect *tmp = v.calculateImage(getImage(), &diagram);
SAFEDELETE(tmp);
const String dumpFileName = createTempFileName(_T("txt"));
FILE *f = NULL;
try {
const String dstr = diagram.toString();
f = MKFOPEN(dumpFileName,_T("w"));
_ftprintf(f, _T("%s"), dstr.cstr());
fclose(f); f = NULL;
ExternProcess::run(false, _T("c:\\windows\\system32\\notepad.exe"), dumpFileName.cstr(), NULL);
UNLINK(dumpFileName);
} catch (Exception e) {
if(f) { fclose(f); f = NULL; }
showException(e);
}
}
int
main (int argc, char *argv[])
{
int ret;
GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
GNUNET_log_setup ("test-gnunet-daemon-hostlist",
"WARNING",
NULL);
#if !WINDOWS
system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > /dev/null");
system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > /dev/null");
#else
system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > NUL");
system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > NUL");
#endif
ret = check ();
GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
if (GNUNET_YES == GNUNET_DISK_file_test ("hostlists_learn_peer.file"))
{
if (0 == UNLINK ("hostlists_learn_peer.file"))
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Hostlist file hostlists_learn_peer.file was removed\n");
}
return ret;
}
PRIVATE void xlog_unlink(xlog_s *xp)
{
xlog_s *server = xp->xl_use ;
/*
* Step 1: remove from server chain
*/
if ( server != XLOG_NULL )
{
if ( server->xl_clients == xp )
if ( NEXT( xp, xl_other_users ) == xp )
server->xl_clients = XLOG_NULL ;
else
server->xl_clients = NEXT( xp, xl_other_users ) ;
else
UNLINK( xp, xl_other_users ) ;
}
/*
* Step 2: If we have users, clear their link to us.
*/
if ( xp->xl_clients != NULL )
{
xlog_s *xp2 = xp->xl_clients ;
do
{
xp2->xl_use = XLOG_NULL ;
xp2 = NEXT( xp2, xl_other_users ) ;
}
while ( xp2 != xp->xl_clients ) ;
}
}
static void
task_finished(isc_task_t *task) {
isc_taskmgr_t *manager = task->manager;
REQUIRE(EMPTY(task->events));
REQUIRE(EMPTY(task->on_shutdown));
REQUIRE(task->references == 0);
REQUIRE(task->state == task_state_done);
XTRACE("task_finished");
LOCK(&manager->lock);
UNLINK(manager->tasks, task, link);
#ifdef ISC_PLATFORM_USETHREADS
if (FINISHED(manager)) {
/*
* All tasks have completed and the
* task manager is exiting. Wake up
* any idle worker threads so they
* can exit.
*/
BROADCAST(&manager->work_available);
}
#endif /* ISC_PLATFORM_USETHREADS */
UNLOCK(&manager->lock);
DESTROYLOCK(&task->lock);
task->magic = 0;
isc_mem_put(manager->mctx, task, sizeof(*task));
}
static DWORD
VMCABackupFiles(
PCSTR pszBaseFilePath
)
{
DWORD dwError = ERROR_SUCCESS;
const DWORD MAX_NUMBER_OF_BAKUPS = 32;
struct STAT st = { 0 };
DWORD dwCounter;
PSTR pszDestFile = NULL;
PSTR pszSourceFile = NULL;
for (dwCounter = MAX_NUMBER_OF_BAKUPS; dwCounter > 0; --dwCounter)
{
dwError = VMCAAllocateStringPrintfA(
&pszDestFile,
"%s.%d",
pszBaseFilePath,
dwCounter);
BAIL_ON_ERROR(dwError);
if(STAT(pszDestFile, &st) == ERROR_SUCCESS )
{
UNLINK(pszDestFile);
}
dwError = VMCAAllocateStringPrintfA(
&pszSourceFile,
"%s.%d",
pszBaseFilePath,
dwCounter - 1);
BAIL_ON_ERROR(dwError);
RENAME(pszSourceFile, pszDestFile);
VMCA_SAFE_FREE_STRINGA(pszDestFile);
VMCA_SAFE_FREE_STRINGA(pszSourceFile);
pszDestFile = NULL;
pszSourceFile = NULL;
}
VMCA_SAFE_FREE_STRINGA(pszDestFile);
dwError = VMCAAllocateStringPrintfA(
&pszDestFile,
"%s.%d",
pszBaseFilePath,
0);
BAIL_ON_ERROR(dwError);
RENAME(pszBaseFilePath, pszDestFile);
error:
VMCA_SAFE_FREE_STRINGA(pszDestFile);
VMCA_SAFE_FREE_STRINGA(pszSourceFile);
return dwError;
}
void MatchGraph::UNPAIR_ALL ()
{
long u;
for (v=1; v <= U; ++v) {
if (BASE[(int)v] != v || LASTVTX[(int)v] == v)
continue;
nextu = v;
NEXTVTX[(int)LASTVTX[(int)nextu]] = DUMMYVERTEX;
while (1) {
u = nextu;
nextu = NEXTVTX[(int)nextu];
UNLINK (u);
if (LASTVTX[(int)u] != u) {
f = (LASTEDGE[2] == OPPEDGE(e)) ? LASTEDGE[1] : LASTEDGE[2];
NEXTVTX[(int)LASTVTX[(int)BEND(f)]] = u;
}
newbase = BMATE (BMATE(u));
if (newbase != DUMMYVERTEX && newbase != u) {
LINK[(int)u] = -DUMMYEDGE;
REMATCH (newbase, MATE[(int)u]);
}
while (LASTVTX[(int)nextu] == nextu && nextu != DUMMYVERTEX)
nextu = NEXTVTX[(int)nextu];
if (LASTVTX[(int)nextu] == nextu && nextu == DUMMYVERTEX)
break;
}
}
}
/*
* Remove less1-connected-components located to the right of
* the less1-connected-component containing p->point.
*
* Undefined behavior if p is the pattern with only one node.
*/
static pattern *remove_end_clumps( pattern *p )
{
node *n, *n_next;
pattern *q;
/*
* Search for the first node (if any) that lies further right
* than every circle containing p->point.
*/
n = p->first_node->next;
while ( n->position <= p->point->position )
{
n = n->less1->next;
if ( !n )
return p;
}
/*
* Having found such a node, n, we make a copy of p,
* and in the copy, kill everything from n onward.
*/
q = copy_pattern(p);
q->nodes = n->position;
for ( n = isom(n,q); n; n = n_next )
{
n_next = n->next;
UNLINK( n, q->first_node, q->last_node, next, prev );
kill_node( n );
}
return q;
}
/*
* Having successfully marked some points for removal ("successfully" here
* means that doing so did not force us to mark p->point), make a copy of
* the pattern, and remove the marked points from it.
*/
static pattern *execute_removal(pattern *p)
{
node *n, *m, *m_next;
pattern *q;
int i;
q = copy_pattern(p);
for ( i=0, n=p->first_node, m=q->first_node; n; n = n->next, m = m_next )
{
m_next = m->next;
if ( n->simplify_data == SIMPL_MARKED )
{
UNLINK( m, q->first_node, q->last_node, next, prev );
kill_node( m );
}
else
{
/*
* Maintain a running count of how many nodes we DON'T remove,
* so we can fix the nodecount after the dust settles.
*/
i++;
}
}
q->nodes = i;
for ( i = 0, m = q->first_node; m; m = m->next )
m->position = i++;
return q;
}
/**
* Exit point from the plugin.
*
* @param cls the plugin context (as returned by "init")
* @return always NULL
*/
void *
libgnunet_plugin_datastore_sqlite_done (void *cls)
{
char *fn;
struct GNUNET_DATASTORE_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"sqlite plugin is done\n");
fn = NULL;
if (plugin->drop_on_shutdown)
fn = GNUNET_strdup (plugin->fn);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"Shutting down database\n");
database_shutdown (plugin);
plugin->env = NULL;
GNUNET_free (api);
if (fn != NULL)
{
if (0 != UNLINK (fn))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
GNUNET_free (fn);
}
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"sqlite plugin is finished\n");
return NULL;
}
/* good1() uses the GoodSinkBody in the while loop */
static void good1()
{
while(1)
{
{
char * filename;
char tmpl[] = "goodXXXXXX";
FILE *pFile;
/* Establish that this is a temporary file and that it should be deleted */
filename = MKTEMP(tmpl);
if (filename != NULL)
{
pFile = FOPEN(filename, "w");
if (pFile != NULL)
{
fprintf(pFile, "Temporary file");
fclose(pFile);
/* FIX: Unlink the temporary file */
UNLINK(filename); /* EXPECTED INCIDENTAL: CWE367 TOCTOU - This POSIX API is essentially insecure by design */
}
}
}
break;
}
}
/* Take a qbit off a character */
void remove_qbit( CHAR_DATA * ch, int number )
{
BIT_DATA *bit;
if( IS_NPC( ch ) )
return;
if( number < 0 || number > MAX_xBITS )
return;
if( !ch->pcdata->first_qbit )
return;
bit = ch->pcdata->first_qbit;
while( bit )
{
BIT_DATA *tmp;
if( bit->number == number )
{
tmp = bit;
bit = bit->next;
UNLINK( tmp, ch->pcdata->first_qbit, ch->pcdata->last_qbit, next, prev );
DISPOSE( tmp );
}
else
bit = bit->next;
}
}
/* good1() uses if(GLOBAL_CONST_FIVE!=5) instead of if(GLOBAL_CONST_FIVE==5) */
static void good1()
{
if(GLOBAL_CONST_FIVE!=5)
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
}
else
{
{
char * filename;
char tmpl[] = "goodXXXXXX";
FILE *pFile;
/* Establish that this is a temporary file and that it should be deleted */
filename = MKTEMP(tmpl);
if (filename != NULL)
{
pFile = FOPEN(filename, "w");
if (pFile != NULL)
{
fprintf(pFile, "Temporary file");
fclose(pFile);
/* FIX: Unlink the temporary file */
UNLINK(filename); /* EXPECTED INCIDENTAL: CWE367 TOCTOU - This POSIX API is essentially insecure by design */
}
}
}
}
}
void CWE511_Logic_Time_Bomb__w32CompareFileTime_15_bad()
{
switch(6)
{
case 6:
{
SYSTEMTIME setTime, currentTime;
FILETIME setTimeAsFileTime, currentTimeAsFileTime;
/* Jan 1, 2008 12:00:00 PM */
setTime.wYear = 2008; /* Year */
setTime.wMonth = 1; /* January */
setTime.wDayOfWeek = 0; /* Ignored */
setTime.wDay = 1; /* The first of the month */
setTime.wHour = 12; /* 12 PM */
setTime.wMinute = 0; /* 0 minutes into the hour */
setTime.wSecond = 0; /* 0 seconds into the minute */
setTime.wMilliseconds = 0; /* 0 milliseconds into the second */
GetSystemTime(¤tTime);
/* Must convert to FILETIME for comparison */
SystemTimeToFileTime(¤tTime, ¤tTimeAsFileTime);
SystemTimeToFileTime(&setTime, &setTimeAsFileTime);
/* FLAW: After a certain date, delete a file */
if (CompareFileTime(¤tTimeAsFileTime, &setTimeAsFileTime) == 1)
{
UNLINK("important_file.txt");
}
}
break;
default:
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
break;
}
}
static mrb_value
mrb_file_s_rename(mrb_state *mrb, mrb_value obj)
{
mrb_value from, to;
char *src, *dst;
mrb_get_args(mrb, "SS", &from, &to);
src = mrb_locale_from_utf8(mrb_string_value_cstr(mrb, &from), -1);
dst = mrb_locale_from_utf8(mrb_string_value_cstr(mrb, &to), -1);
if (rename(src, dst) < 0) {
#if defined(_WIN32) || defined(_WIN64)
if (CHMOD(dst, 0666) == 0 && UNLINK(dst) == 0 && rename(src, dst) == 0) {
mrb_locale_free(src);
mrb_locale_free(dst);
return mrb_fixnum_value(0);
}
#endif
mrb_locale_free(src);
mrb_locale_free(dst);
mrb_sys_fail(mrb, mrb_str_to_cstr(mrb, mrb_format(mrb, "(%S, %S)", from, to)));
}
mrb_locale_free(src);
mrb_locale_free(dst);
return mrb_fixnum_value(0);
}
static void
test_reopen(const char *path)
{
PMEMlogpool *log1 = pmemlog_create(path, PMEMLOG_MIN_POOL,
S_IWUSR | S_IRUSR);
if (!log1)
FATAL("!create");
PMEMlogpool *log2 = pmemlog_open(path);
if (log2)
FATAL("pmemlog_open should not succeed");
if (errno != EWOULDBLOCK)
FATAL("!pmemlog_open failed but for unexpected reason");
pmemlog_close(log1);
log2 = pmemlog_open(path);
if (!log2)
FATAL("pmemlog_open should succeed after close");
pmemlog_close(log2);
UNLINK(path);
}
void CWE511_Logic_Time_Bomb__time_12_bad()
{
if(globalReturnsTrueOrFalse())
{
{
time_t currentTime;
/* FLAW: After a certain date, delete a file */
time(¤tTime);
if (currentTime > TIME_CHECK)
{
UNLINK("important_file.txt");
}
}
}
else
{
{
time_t currentTime;
/* FIX: After a certain date, print to the console */
time(¤tTime);
if (currentTime > TIME_CHECK)
{
printLine("Happy New Year!");
}
}
}
}
UINT AviConverter::run() {
try {
CPicture picture;
picture.load(m_nameArray[0]);
const CSize imageSize = picture.getSize();
HDC screenDC = getScreenDC();
m_dc = CreateCompatibleDC(screenDC);
m_bitmap = CreateCompatibleBitmap(screenDC, imageSize.cx, imageSize.cy);
DeleteDC(screenDC);
DWORD codec = 0; // mmioFOURCC('w','m','v',' ');
if(ACCESS(m_outFileName, 0) == 0) {
UNLINK(m_outFileName);
}
CAviFile aviFile(m_outFileName, true, codec, m_framesPerSecond);
for(m_index = 0; m_index < (int)m_nameArray.size(); m_index += m_useEvery) {
if(isInterrupted()) {
throwException(_T("Interrupted by user"));
}
picture.load(m_nameArray[m_index]);
HGDIOBJ oldGDI = SelectObject(m_dc, m_bitmap);
picture.show(m_dc);
SelectObject(m_dc, oldGDI);
aviFile.appendNewFrame(m_bitmap);
}
} catch(Exception e) {
m_ok = false;
m_msg = e.what();
}
return 0;
}
static void
destroy(isc__timer_t *timer) {
isc__timermgr_t *manager = timer->manager;
/*
* The caller must ensure it is safe to destroy the timer.
*/
LOCK(&manager->lock);
(void)isc_task_purgerange(timer->task,
timer,
ISC_TIMEREVENT_FIRSTEVENT,
ISC_TIMEREVENT_LASTEVENT,
NULL);
deschedule(timer);
UNLINK(manager->timers, timer, link);
UNLOCK(&manager->lock);
isc_task_detach(&timer->task);
DESTROYLOCK(&timer->lock);
timer->common.impmagic = 0;
timer->common.magic = 0;
isc_mem_put(manager->mctx, timer, sizeof(*timer));
}
void CWE511_Logic_Time_Bomb__w32CompareFileTime_10_bad()
{
if(globalTrue)
{
{
SYSTEMTIME setTime, currentTime;
FILETIME setTimeAsFileTime, currentTimeAsFileTime;
/* Jan 1, 2008 12:00:00 PM */
setTime.wYear = 2008; /* Year */
setTime.wMonth = 1; /* January */
setTime.wDayOfWeek = 0; /* Ignored */
setTime.wDay = 1; /* The first of the month */
setTime.wHour = 12; /* 12 PM */
setTime.wMinute = 0; /* 0 minutes into the hour */
setTime.wSecond = 0; /* 0 seconds into the minute */
setTime.wMilliseconds = 0; /* 0 milliseconds into the second */
GetSystemTime(¤tTime);
/* Must convert to FILETIME for comparison */
SystemTimeToFileTime(¤tTime, ¤tTimeAsFileTime);
SystemTimeToFileTime(&setTime, &setTimeAsFileTime);
/* FLAW: After a certain date, delete a file */
if (CompareFileTime(¤tTimeAsFileTime, &setTimeAsFileTime) == 1)
{
UNLINK("important_file.txt");
}
}
}
}
void gtmsecshr_sock_cleanup(int caller)
{
int save_errno;
struct sockaddr_un *sock_ptr;
/* Close the secshr client socket */
if (-1 != gtmsecshr_sockfd)
{
close(gtmsecshr_sockfd);
gtmsecshr_sockfd = -1;
}
/* do the unlink */
sock_ptr = (CLIENT == caller) ? >msecshr_cli_sock_name : >msecshr_sock_name;
if (('\0' != sock_ptr->sun_path[0]) && (-1 == UNLINK(sock_ptr->sun_path))
&& (ENOENT != errno))
{
save_errno = errno;
send_msg(VARLSTCNT(12) ERR_GTMSECSHR, 1, process_id, ERR_TEXT, 2, RTS_ERROR_TEXT("unlinking socket"),
ERR_TEXT, 2, RTS_ERROR_STRING(sock_ptr->sun_path), save_errno);
}
sock_ptr->sun_path[0] = '\0'; /* Even if error unlinking since it is useless now */
gtmsecshr_sock_init_done = FALSE;
}
/*
* Process a CA message
*
* Arguments:
* dcsp pointer to a DCS control block for the neighbor
* cap pointer to the CA part of the received message
*
* Returns:
* none
*
*/
void
scsp_process_ca(Scsp_dcs* dcsp, Scsp_ca *cap)
{
Scsp_csa *csap, *next_csap;
Scsp_cse *csep;
Scsp_server *ssp = dcsp->sd_server;
/*
* Process CSAS records from the CA message
*/
for (csap = cap->ca_csa_rec; csap; csap = next_csap) {
next_csap = csap->next;
SCSP_LOOKUP(ssp, &csap->key, csep);
if (!csep || (scsp_cmp_id(&csap->oid,
&csep->sc_oid) == 0 &&
csap->seq > csep->sc_seq)) {
/*
* CSAS entry not in cache or more
* up to date than cache, add it to CRL
*/
UNLINK(csap, Scsp_csa, cap->ca_csa_rec, next);
LINK2TAIL(csap, Scsp_csa, dcsp->sd_crl, next);
}
}
}
