Mercurial > noffle
view src/filter.c @ 193:021d145e34e9 noffle
[svn] * src/fetch.c: Only leave articles in the requested list if the error
fetching them was fatal. Otherwise article requests will accumulate
indefinitely (e.g retrieving through NNTPcache when it can't find
the body of an article, now or event. Yes, this happened to me; I
had nearly 2000 requests backed up and never being cleared).
* src/group.c: The weekend's change introduced code that causes a bus
error on Sparc ( *(time_t *)p = xxx ). Replace with a safe memcpy,
and also use memcpy when reading the Entry and time items to remove
warnings on Sparc compilation.
author | bears |
---|---|
date | Mon, 22 Oct 2001 14:41:43 +0100 |
parents | fed1334d766b |
children | a4e9a20e50e5 |
line wrap: on
line source
/* filter.c Article filtering. $Id: filter.c 300 2001-08-05 08:24:22Z bears $ */ #if HAVE_CONFIG_H #include <config.h> #endif #include "filter.h" #include <ctype.h> #include "common.h" #include "itemlist.h" #include "log.h" #include "wildmat.h" struct { int nFilters; int maxFilters; const Filter **filters; Bool needGroups; } filter = { 0, 0, NULL, FALSE }; static unsigned long countGroups( const char *grps ) { unsigned long res; res = 1; while ( *grps != '\0' ) { if ( *grps == ',' ) res++; grps++; } return res; } static unsigned long countRefs( const char *refs ) { unsigned long res; Bool inRef; res = 0; inRef = FALSE; while ( *refs != '\0' ) { if ( inRef ) { if ( *refs == '>' ) { inRef = FALSE; res++; } } else if ( *refs == '<' ) inRef = TRUE; refs++; } return res; } /* Check a single rule to see if it passes. */ static Bool checkRule( const char *thisGrp, const char *newsgroups, const Over *ov, const FilterRule *r ) { unsigned long ul; ItemList *grps; const char *p; switch( r->type ) { case RULE_NEWSGROUP: if ( Wld_match( thisGrp, r->data.grp ) ) return TRUE; if ( newsgroups != NULL ) { grps = new_Itl( newsgroups, " ,\t" ); for ( p = Itl_first( grps ); p != NULL; p = Itl_next( grps ) ) if ( Wld_match( p, r->data.grp ) ) return TRUE; del_Itl( grps ); } return FALSE; case RULE_SUBJECT: return ( regexec( &r->data.regex, Ov_subj( ov ), 0, NULL, 0 ) == 0 ); case RULE_FROM: return ( regexec( &r->data.regex, Ov_from( ov ), 0, NULL, 0 ) == 0 ); case RULE_BYTES_LT: return ( Ov_bytes( ov ) < r->data.amount ); case RULE_BYTES_EQ: return ( Ov_bytes( ov ) == r->data.amount ); case RULE_BYTES_GT: return ( Ov_bytes( ov ) > r->data.amount ); case RULE_LINES_LT: return ( Ov_lines( ov ) < r->data.amount ); case RULE_LINES_EQ: return ( Ov_lines( ov ) == r->data.amount ); case RULE_LINES_GT: return ( Ov_lines( ov ) > r->data.amount ); case RULE_MSGID: return ( regexec( &r->data.regex, Ov_msgId( ov ), 0, NULL, 0 ) == 0 ); case RULE_NOREFS_LT: ul = countRefs( Ov_ref( ov ) ); return ( ul < r->data.amount ); case RULE_NOREFS_EQ: ul = countRefs( Ov_ref( ov ) ); return ( ul == r->data.amount ); case RULE_NOREFS_GT: ul = countRefs( Ov_ref( ov ) ); return ( ul > r->data.amount ); case RULE_XPOSTS_LT: if ( newsgroups == NULL ) return FALSE; ul = countGroups( newsgroups ); return ( ul < r->data.amount ); case RULE_XPOSTS_EQ: if ( newsgroups == NULL ) return FALSE; ul = countGroups( newsgroups ); return ( ul == r->data.amount ); case RULE_XPOSTS_GT: if ( newsgroups == NULL ) return FALSE; ul = countGroups( newsgroups ); return ( ul > r->data.amount ); } ASSERT( FALSE ); /* Shouldn't get here */ return 0; /* Keep compiler quiet */ } /* Check a single filter to see if it fires. */ static Bool checkFilter( const char *thisGrp, const char *newsgroups, const Over *ov, const Filter *f ) { int i; for ( i = 0; i < f->nRules; i++ ) if ( ! checkRule( thisGrp, newsgroups, ov, &f->rules[i] ) ) return FALSE; return TRUE; } /* Add a filter to the list of filters. */ void Flt_addFilter( const Filter *f ) { ASSERT( f != NULL ); if ( ( filter.nFilters + 1 ) > filter.maxFilters ) { filter.filters = ( const Filter ** ) realloc( filter.filters, ( filter.maxFilters + 5 ) * sizeof( Filter * ) ); if ( filter.filters == NULL ) { Log_err( "Could not realloc filter list" ); exit( EXIT_FAILURE ); } filter.maxFilters += 5; } filter.filters[ filter.nFilters++ ] = f; } /* * Run the rules over the supplied overview. If a specific rule fires, * returns its action. If no rule fires, return the default read mode. */ FilterAction Flt_checkFilters( const char *thisGrp, const char *newsgroups, const Over *ov, FetchMode mode ) { int i; for ( i = 0; i < filter.nFilters; i++ ) if ( checkFilter( thisGrp, newsgroups, ov, filter.filters[ i ] ) ) { Log_dbg( LOG_DBG_FILTER, "Filter %d fired on message %s", i, Ov_msgId( ov ) ); return filter.filters[ i ]->action; } switch( mode ) { case FULL: return FILTER_FULL; case THREAD: return FILTER_THREAD; case OVER: return FILTER_XOVER; } ASSERT( FALSE ); /* Shouldn't get here */ return FILTER_FULL; /* Keep compiler quiet */ } Filter * new_Filter( void ) { Filter *f; if ( ! ( f = ( Filter * ) malloc( sizeof( Filter ) ) ) ) { Log_err( "Cannot allocate Filter" ); exit( EXIT_FAILURE ); } f->nRules = 0; f->maxRules = 0; f->rules = NULL; f->action = FILTER_FULL; return f; } void del_Filter( Filter *f ) { if ( f == NULL ) return; if ( f->rules != NULL ) free( f->rules ); free( f ); } FilterAction Flt_action( const Filter *f ) { return f->action; } int Flt_nRules( const Filter *f ) { return f->nRules; } /* * Do we have a rule requiring us to fetch the Newsgroups: headers of * articles? */ Bool Flt_getNewsgroups( void ) { return filter.needGroups; } FilterRule Flt_rule( const Filter *f, int ruleNo ) { ASSERT( ruleNo < f->nRules ); return f->rules[ ruleNo ]; } void Flt_setAction( Filter *f, FilterAction action ) { f->action = action; } void Flt_addRule( Filter *f, FilterRule rule ) { /* Does the rule require Newsgroups: headers to be fetched? */ if ( rule.type == RULE_NEWSGROUP || ( rule.type >= RULE_XPOSTS_LT && rule.type <= RULE_XPOSTS_GT ) ) filter.needGroups = TRUE; if ( f->nRules + 1 > f->maxRules ) { f->rules = ( FilterRule * ) realloc( f->rules, ( f->maxRules + 5 ) * sizeof( FilterRule ) ); if ( f->rules == NULL ) { Log_err( "Could not realloc rule list" ); exit( EXIT_FAILURE ); } f->maxRules += 5; } f->rules[ f->nRules++ ] = rule; }