void regexp_remove( char *channelRegexp, char *contentRegexp )
{
LinkedListItem_t *item;
Regexp_t *regexp;
if( !channelRegexp ) {
channelRegexp = channelsAll;
}
LinkedListLock( regexpList );
for( item = regexpList->head; item; item = item->next ) {
regexp = (Regexp_t *)item;
if( !strcmp( channelRegexp, regexp->channelRegexp ) &&
!strcmp( contentRegexp, regexp->contentRegexp ) ) {
LinkedListRemove( regexpList, item, LOCKED );
free( regexp->reChannel );
free( regexp->peChannel );
free( regexp->reContent );
free( regexp->peContent );
free( item );
LinkedListUnlock( regexpList );
return;
}
}
LinkedListUnlock( regexpList );
}
static ServiceJob *RemoveServiceJobFromServicesListManager (JobsManager *manager_p, const uuid_t job_key, bool get_job_flag)
{
ServiceJob *job_p = NULL;
UUIDJobNode *node_p = (UUIDJobNode *) ((ServicesListManager *) s_manager_p) -> slm_running_services.ll_head_p;
while (node_p)
{
if (uuid_compare (node_p -> ujn_id, job_key) == 0)
{
job_p = node_p -> ujn_job_p;
LinkedListRemove (& (s_manager_p -> slm_running_services), (ListItem * const) node_p);
node_p -> ujn_job_p = NULL;
FreeUUIDJobNode ((ListItem * const) node_p);
node_p = NULL;
}
else
{
node_p = (UUIDJobNode *) (node_p -> ujn_node.ln_next_p);
}
}
return job_p;
}
bool LogOutputRemove( LogFileChain_t *logfile )
{
if( logfile == NULL )
{
return( FALSE );
}
/* logfile will be pointing at the offending member, close then
* remove it. It is assumed that the caller already has the Mutex
* locked.
*/
switch( logfile->type )
{
case LT_FILE:
case LT_CONSOLE:
close( logfile->fd );
if( logfile->identifier.filename != NULL )
{
free( logfile->identifier.filename );
}
break;
case LT_SYSLOG:
/* Nothing to do */
break;
default:
break;
}
/* Remove the log file from the linked list */
LinkedListRemove( LogList, (LinkedListItem_t *)logfile, LOCKED );
free( logfile );
return( TRUE );
}
void QueueDestroy( QueueObject_t *queue )
{
/*
* Assumes: queue is empty and locked. Any items still in the queue will
* be not be freed
*/
/*
* get rid of the two condition vars
*/
pthread_cond_broadcast( queue->cNotFull );
pthread_cond_destroy( queue->cNotFull );
free( queue->cNotFull );
pthread_cond_broadcast( queue->cNotEmpty );
pthread_cond_destroy( queue->cNotEmpty );
free( queue->cNotEmpty );
/*
* get rid of the mutex
*/
pthread_mutex_unlock( queue->mutex );
pthread_mutex_destroy( queue->mutex );
free( queue->mutex );
/*
* get rid of the item table
*/
free( queue->itemTable );
LinkedListRemove( QueueList, (LinkedListItem_t *)queue, UNLOCKED );
/*
* get rid of the queue object
*/
free( queue );
}
void serverKill( BalancedBTreeItem_t *node, IRCServer_t *server, bool unalloc )
{
LinkedListItem_t *listItem, *next;
IRCChannel_t *channel;
BalancedBTreeItem_t *item;
if( server->enabled || server->enabledChanged ) {
server->threadAbort = TRUE;
thread_deregister( server->txThreadId );
thread_deregister( server->threadId );
server->threadAbort = FALSE;
}
if( unalloc ) {
BalancedBTreeRemove( node->btree, node, LOCKED, FALSE );
} else {
server->enabled = FALSE;
}
if( server->txQueue ) {
/* This *might* leak the contents of any queue entries? */
QueueClear( server->txQueue, TRUE );
QueueLock( server->txQueue );
QueueDestroy( server->txQueue );
server->txQueue = NULL;
}
if( server->channels ) {
LinkedListLock( server->channels );
BalancedBTreeLock( server->channelName );
BalancedBTreeLock( server->channelNum );
for( listItem = server->channels->head; listItem; listItem = next ) {
next = listItem->next;
channel = (IRCChannel_t *)listItem;
regexpBotCmdRemove( server, channel );
LinkedListRemove( server->channels, listItem, LOCKED );
item = BalancedBTreeFind( server->channelName,
&channel->channel, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelName, item, LOCKED,
FALSE );
}
item = BalancedBTreeFind( server->channelNum,
&channel->channelId, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelNum, item, LOCKED,
FALSE );
}
ThreadAllNotifyChannel( channel );
cursesMenuItemRemove( 2, MENU_CHANNELS, channel->menuText );
free( channel->menuText );
free( channel->channel );
free( channel->fullspec );
free( channel->url );
free( channel );
}
LinkedListDestroy( server->channels );
BalancedBTreeDestroy( server->channelName );
BalancedBTreeDestroy( server->channelNum );
server->channels = NULL;
server->channelName = NULL;
server->channelNum = NULL;
}
if( unalloc ) {
free( server->server );
free( server->password );
free( server->nick );
free( server->username );
free( server->realname );
free( server->nickserv );
free( server->nickservmsg );
free( server->ircInfo.Server );
}
LinkedListLock( server->floodList );
for( listItem = server->floodList->head; listItem; listItem = next ) {
next = listItem->next;
LinkedListRemove( server->floodList, listItem, LOCKED );
free( listItem );
}
LinkedListDestroy( server->floodList );
server->floodList = NULL;
ThreadAllNotifyServer( server );
if( unalloc ) {
cursesMenuItemRemove( 2, MENU_SERVERS, server->menuText );
free( server->menuText );
free( server->threadName );
free( server->txThreadName );
free( server );
free( node );
}
}
void botSighup( int signum, void *arg )
{
IRCServer_t *server;
LinkedListItem_t *listItem, *next;
BalancedBTreeItem_t *item;
IRCChannel_t *channel;
bool newChannel = FALSE;
server = (IRCServer_t *)arg;
if( !server ) {
return;
}
/*
* Check each channel on the server, leave those no longer needed
*/
if( server->channels ) {
LinkedListLock( server->channels );
BalancedBTreeLock( server->channelName );
BalancedBTreeLock( server->channelNum );
for( listItem = server->channels->head; listItem; listItem = next ) {
next = listItem->next;
channel = (IRCChannel_t *)listItem;
if( !channel->visited ) {
channelLeave( server, channel, channel->channel );
regexpBotCmdRemove( server, channel );
LinkedListRemove( server->channels, listItem, LOCKED );
item = BalancedBTreeFind( server->channelName,
&channel->channel, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelName, item, LOCKED,
FALSE );
}
item = BalancedBTreeFind( server->channelNum,
&channel->channelId, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelNum, item, LOCKED,
FALSE );
}
ThreadAllNotifyChannel( channel );
cursesMenuItemRemove( 2, MENU_CHANNELS, channel->menuText );
free( channel->menuText );
free( channel->channel );
free( channel->fullspec );
free( channel->url );
free( channel );
} else if( channel->newChannel && channel->enabled &&
!channel->joined && !newChannel ) {
newChannel = TRUE;
transmitMsg( server, TX_JOIN, channel->channel, NULL );
} else if( channel->newChannel && !channel->enabled ) {
channel->newChannel = FALSE;
}
}
BalancedBTreeUnlock( server->channelNum );
BalancedBTreeUnlock( server->channelName );
LinkedListUnlock( server->channels );
}
}
char DictionaryRemove(Dictionary* dictionary, char* key){
if(LinkedListRemove(dictionary->linkedList,key,&comparer, &destructor)!=0)
return -1;
return 0;
}
